开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Email客户端 > 查看源码
utils.c
资源名称：email-3.1.2.tar.gz　[点击查看]
上传用户：knt0001
上传日期：2022-01-28
资源大小：264k
文件大小：8k
源码类别：

Email客户端

开发平台：

C/C++

utils.c：源码内容
  1. /**
  2.     eMail is a command line SMTP client.
  4.     Copyright (C) 2001 - 2008 email by Dean Jones
  5.     Software supplied and written by http://www.cleancode.org
  7.     This file is part of eMail.
  9.     eMail is free software; you can redistribute it and/or modify
  10.     it under the terms of the GNU General Public License as published by
  11.     the Free Software Foundation; either version 2 of the License, or
  12.     (at your option) any later version.
  14.     eMail is distributed in the hope that it will be useful,
  15.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.     GNU General Public License for more details.
  19.     You should have received a copy of the GNU General Public License
  20.     along with eMail; if not, write to the Free Software
  21.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22. **/
  23. #if HAVE_CONFIG_H
  24. # include "config.h"
  25. #endif
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <unistd.h>
  30. #include <string.h>
  31. #include <ctype.h>
  32. #include <errno.h>
  33. #include <pwd.h>
  35. #include <sys/stat.h>
  36. #include <sys/wait.h>
  37. #include <sys/utsname.h>
  39. /* Autoconf manual suggests this. */
  40. #if TIME_WITH_SYS_TIME
  41. # include <sys/time.h>
  42. # include <time.h>
  43. #else
  44. # if HAVE_SYS_TIME_H
  45. #  include <sys/time.h>
  46. # else
  47. #  include <time.h>
  48. # endif
  49. #endif
  51. #include "email.h"
  52. #include "utils.h"
  53. #include "error.h"
  54. #include "mimeutils.h"
  56. /**
  57.  * Return number of printable chars in a utf8 string
  58.  */
  59. size_t
  60. utf8Strlen(const u_char *str)
  61. {
  62. size_t len=0;
  64. while (*str != '') {
  65. u_char fbyte = str[0];
  66. /* If greater than 0x7F (127) then it's not normal ASCII */
  67. if (fbyte > 0x7F) {
  68. /* It's a 2-byte sequence if it's between 0xC0(192) 
  69.    and 0xDF(223),
  70.    It's a 3-byte sequence if it's between 0xE0(224)
  71.    and 0xEF(239) 
  72.    It's a 4-byte sequence if it's between 0xF0(240)
  73.    and 0xF4(244) */
  74. if (fbyte >= 0xC0 && fbyte <= 0xDF) {
  75. str += 2;
  76. } else if (fbyte >= 0xE0 && fbyte <= 0xEF) {
  77. str += 3;
  78. } else if (fbyte >= 0xF0 && fbyte <= 0xF4) {
  79. str += 4;
  80. } else {
  81. str += 1;
  82. }
  83. len++;
  84. } else {
  85. len++;
  86. }
  87. }
  88. return len;
  89. }
  91. /**
  92.  * We're going to try and get the type of character set this
  93.  * string is.  We primarily just support UTF-8 and ASCII right
  94.  * now.  May support other charsets later.
  95.  */
  96. CharSetType
  97. getCharSet(const u_char *str)
  98. {
  99. CharSetType type=IS_ASCII;
  100. u_int utf8=0, ascii=0;
  101. u_int percent_ascii=0;
  103. while (*str != '') {
  104. u_char fbyte = str[0];
  105. /* If greater than 0x7F (127) then it's not normal ASCII */
  106. if (fbyte > 0x7F) {
  107. /* It's a 2-byte sequence if it's between 0xC0(192) 
  108.    and 0xDF(223),
  109.    It's a 3-byte sequence if it's between 0xE0(224)
  110.    and 0xEF(239) 
  111.    It's a 4-byte sequence if it's between 0xF0(240)
  112.    and 0xF4(244) */
  113. if (fbyte >= 0xC0 && fbyte <= 0xDF) {
  114. str += 2;
  115. } else if (fbyte >= 0xE0 && fbyte <= 0xEF) {
  116. str += 3;
  117. } else if (fbyte >= 0xF0 && fbyte <= 0xF4) {
  118. str += 4;
  119. } else {
  120. str += 1;
  121. }
  122. utf8++;
  123. } else {
  124. ascii++;
  125. str += 1;
  126. }
  127. }
  129. if (utf8) {
  130. /* If the string is 75% or more of ascii characters, 
  131.    we'll call it partial utf-8 */
  132. if (ascii > 0) {
  133. percent_ascii = ((float)ascii / (float)(ascii + utf8)) * 100;
  134. }
  135. if (percent_ascii >= 75) {
  136. type = IS_PARTIAL_UTF8;
  137. } else {
  138. type = IS_UTF8;
  139. }
  140. } else if (!utf8 && !ascii) {
  141. type = IS_OTHER;
  142. }
  144. return type;
  145. }
  147. dstrbuf *
  148. encodeUtf8String(const u_char *str, bool use_qp)
  149. {
  150. const u_int max_blk_len = 45;
  151. u_int i=max_blk_len;
  152. dstrbuf *enc, *dsb = DSB_NEW;
  153. size_t len = strlen((char *)str);
  155. if (use_qp) {
  156. // TODO: We need to break this up so that we're not 
  157. // creating extra long strings.
  158. enc = mimeQpEncodeString(str, false);
  159. dsbPrintf(dsb, "=?utf-8?q?%s?=", enc->str);
  160. i = len; // Just reset for now.
  161. } else {
  162. enc = mimeB64EncodeString(str, 
  163. (len > max_blk_len ? max_blk_len : len), false);
  164. dsbPrintf(dsb, "=?utf-8?b?%s?=", enc->str);
  165. }
  166. dsbDestroy(enc);
  168. /* If we have anymore data to encode, we have to do it by adding a newline
  169.    plus a space because each section can only be 75 chars long. */ 
  170. while (i < len) {
  171. size_t newlen = strlen((char *)str + i);
  172. /* only allow max_blk_len sections */
  173. if (newlen > max_blk_len) {
  174. newlen = max_blk_len;
  175. }
  176. enc = mimeB64EncodeString(str + i, newlen, false);
  177. dsbPrintf(dsb, "rn =?utf-8?b?%s?=", enc->str);
  178. dsbDestroy(enc);
  179. i += newlen;
  180. }
  181. return dsb;
  182. }
  184. /**
  185.  * takes a string that is a supposed file path, and 
  186.  * checks for certian wildcards ( like ~ for home directory ) 
  187.  * and resolves to an actual absolute path.
  188. **/
  189. dstrbuf *
  190. expandPath(const char *path)
  191. {
  192. struct passwd *pw = NULL;
  193. dstrbuf *tmp = DSB_NEW;
  194. dstrbuf *ret = DSB_NEW;
  196. dsbCopy(tmp, path);
  198. if (tmp->len > 0 && tmp->str[0] == '&') {
  199. dsbCopy(ret, EMAIL_DIR);
  200. } else if (tmp->len > 0 && tmp->str[0] == '~') {
  201. if (tmp->str[1] == '/') {
  202. pw = getpwuid(getuid());
  203. } else {
  204. int pos = strfind(tmp->str, '/');
  205. if (pos >= 0) {
  206. char *p = substr(tmp->str, 1, pos-1);
  207. if (p) {
  208. pw = getpwnam(p);
  209. xfree(p);
  210. }
  211. }
  212. if (!pw) {
  213. pw = getpwuid(getuid());
  214. }
  215. }
  216. if (pw) {
  217. dsbCopy(ret, pw->pw_dir);
  218. }
  219. }
  222. if (ret->len > 0) {
  223. int pos = strfind(tmp->str, '/');
  224. if (pos > 0) {
  225. char *p = substr(tmp->str, pos, tmp->len);
  226. if (p) {
  227. dsbCat(ret, p);
  228. xfree(p);
  229. }
  230. }
  231. } else {
  232. dsbCopy(ret, path);
  233. }
  235. dsbDestroy(tmp);
  236. return ret;
  237. }
  239. int
  240. copyfile(const char *from, const char *to)
  241. {
  242. FILE *ffrom, *fto;
  243. dstrbuf *buf=NULL;
  245. ffrom = fopen(from, "r");
  246. fto = fopen(to, "w");
  247. if (!ffrom || !fto) {
  248. return -1;
  249. }
  251. buf = DSB_NEW;
  252. while (dsbFread(buf, MAXBUF, ffrom) > 0) {
  253. fwrite(buf->str, sizeof(char), buf->len, fto);
  254. dsbClear(buf);
  255. }
  257. dsbDestroy(buf);
  258. fclose(ffrom);
  259. fclose(fto);
  261. if (ferror(ffrom) || ferror(fto)) {
  262. return -1;
  263. }
  265. return 0;
  266. }
  268. /**
  269.  * checks to see if the TEMP_FILE is around... if it is
  270.  * it will move it to the users home directory as dead.letter.
  271. **/
  272. static void
  273. deadLetter()
  274. {
  275. dstrbuf *path = expandPath("~/dead.letter");
  276. FILE *out = fopen(path->str, "w");
  278. if (!out || !global_msg) {
  279. warning("Could not save dead letter to %s", path->str);
  280. } else {
  281. fwrite(global_msg->str, sizeof(char), global_msg->len, out);
  282. }
  283. dsbDestroy(path);
  284. }
  288. /**
  289.  * Gererate a string of random characters
  290. **/
  291. static const char letters[] = "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz" 
  292.                               "0123456789";
  294. #define SIZEOF_LETTERS 62
  296. dstrbuf *
  297. randomString(size_t size)
  298. {
  299. size_t i;
  300. long randval;
  301. struct timeval mill;
  302. dstrbuf *ret = DSB_NEW;
  304. gettimeofday(&mill, NULL);
  305. srand((getuid() + getpid()) + (mill.tv_usec << 16));
  307. for (i=0; i < size; i++) {
  308. randval = rand() / (RAND_MAX / SIZEOF_LETTERS);
  309. dsbCatChar(ret, letters[randval]);
  310. }
  311. return ret;
  312. }
  314. /**
  315.  * Get the first element from the Mopts.to list of emails
  316.  * and return it without the name or formating. just the
  317.  * email address itself.
  318. **/
  319. dstrbuf *
  320. getFirstEmail(void)
  321. {
  322. char *tmp=NULL;
  323. dstrbuf *buf = DSB_NEW;
  324. struct addr *a = (struct addr *)dlGetTop(Mopts.to);
  326. assert(a != NULL);
  328. /* If we haven't found a <, consider the e-mail unformatted. */
  329. tmp = strchr(a->email, '<');
  330. if (!tmp) {
  331. tmp = a->email;
  332. } else {
  333. /* strchr only brings us to the '<', Get past it */
  334. ++tmp;
  335. }
  337. dsbCopy(buf, tmp);
  338. tmp = strchr(buf->str, '>');
  339. if (tmp) {
  340. *tmp = '';
  341. }
  343. return buf;
  344. }
  346. /**
  347.  * Exit just handles all the signals and exiting of the 
  348.  * program by freeing the allocated memory  and writing 
  349.  * the dead.letter if we had a sudden interrupt...
  350. **/
  351. void
  352. properExit(int sig)
  353. {
  354. if (sig != 0 && global_msg) {
  355. deadLetter();
  356. }
  357. dsbDestroy(global_msg);
  359. /* Free lists */
  360. if (Mopts.attach) {
  361. dlDestroy(Mopts.attach);
  362. }
  363. if (Mopts.headers) {
  364. dlDestroy(Mopts.headers);
  365. }
  366. if (Mopts.to) {
  367. dlDestroy(Mopts.to);
  368. }
  369. if (Mopts.cc) {
  370. dlDestroy(Mopts.cc);
  371. }
  372. if (Mopts.bcc) {
  373. dlDestroy(Mopts.bcc);
  374. }
  376. dhDestroy(table);
  377. exit(sig);
  378. }
  380. int
  381. copyUpTo(dstrbuf *buf, int stop, FILE *in)
  382. {
  383. int ch;
  384. while ((ch = fgetc(in)) != EOF) {
  385. if (ch == '\') {
  386. ch = fgetc(in);
  387. if (ch == 'r') {
  388. ch = fgetc(in);
  389. }
  390. if (ch == 'n') {
  391. continue;
  392. }
  393. }
  394. if (ch == 'r') {
  395. ch = fgetc(in);
  396. if (ch == 'n') {
  397. return ch;
  398. }
  399. }
  400. if (ch == stop) {
  401. return ch;
  402. }
  403. dsbCatChar(buf, ch);
  404. }
  405. return ch;
  406. }