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

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

Email客户端

开发平台：

C/C++

smtpcommands.c：源码内容
  1. #if HAVE_CONFIG_H
  2. #include "config.h"
  3. #endif
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <stdarg.h>
  8. #include <unistd.h>
  9. #include <string.h>
  10. #include <assert.h>
  11. #include <termios.h>
  13. #include <sys/select.h>
  14. #include <sys/ioctl.h>
  16. #include "dnet.h"
  17. #include "dstrbuf.h"
  18. #include "email.h"
  19. #include "mimeutils.h"
  21. static dstrbuf *errorstr;
  24. /** 
  25.  * Figures out the screen width and prints the message to fit the screen.
  26.  */
  27. void printProgress(const char *msg)
  28. {
  29. uint i=0;
  30. char *buf=NULL;
  31. struct winsize win_size;
  33. if (!Mopts.verbose) {
  34. return;
  35. }
  36. if (!isatty(STDOUT_FILENO)) {
  37. return;
  38. }
  39. if (ioctl(STDOUT_FILENO, TIOCGWINSZ, (char *)&win_size) < 0) {
  40. return;
  41. }
  43. buf = xmalloc(win_size.ws_col+1);
  44. memset(buf, ' ', win_size.ws_col);
  45. for (i=0; i < win_size.ws_col; i++) {
  46. if (*msg == '') {
  47. break;
  48. }
  49. buf[i] = *msg++;
  50. }
  51. printf("r%s", buf);
  52. fflush(stdout);
  53. free(buf);
  54. }
  57. /**
  58.  * Will generate a string from an error code and return
  59.  * that string as a return value.
  60.  */
  61. char *
  62. smtpGetErr(void)
  63. {
  64. return errorstr->str;
  65. }
  67. /**
  68.  * Simple interface to copy over buffer into error string
  69.  */
  70. static void
  71. smtpSetErr(const char *buf)
  72. {
  73. if (!errorstr) {
  74. errorstr = DSB_NEW;
  75. }
  76. dsbClear(errorstr);
  77. dsbCopy(errorstr, buf);
  78. }
  80. /**
  81.  * Reads a line from the smtp server using sgets().
  82.  * It will continue to read the response until the 4th character
  83.  * in the line is found to be a space.    Per the RFC 821 this means
  84.  * that this will be the last line of response from the SMTP server
  85.  * and the appropirate return value response.
  86.  */
  87. static int
  88. readResponse(dsocket *sd, dstrbuf *buf)
  89. {
  90. int retval=ERROR;
  91. dstrbuf *tmpbuf = DSB_NEW;
  92. struct timeval tv;
  93. fd_set rfds;
  94. char *timeout = getConfValue("TIMEOUT");
  96. FD_ZERO(&rfds);
  97. FD_SET(dnetGetSock(sd), &rfds);
  98. if (timeout) {
  99. tv.tv_sec = atoi(timeout);
  100. } else {
  101. tv.tv_sec = 10;
  102. }
  103. tv.tv_usec = 0;
  104. (void) select(dnetGetSock(sd)+1, &rfds, NULL, NULL, &tv);
  105. if (FD_ISSET(dnetGetSock(sd), &rfds)) {
  106. do {
  107. dsbClear(tmpbuf);
  108. dnetReadline(sd, tmpbuf);
  109. if (dnetErr(sd)) {
  110. smtpSetErr("Lost connection with SMTP server");
  111. retval = ERROR;
  112. break;
  113. }
  114. dsbCat(buf, tmpbuf->str);
  115. retval = SUCCESS;
  116. /* The last line of a response has a space in the 4th column */
  117. } while (tmpbuf->str[3] != ' ');
  118. } else {
  119. smtpSetErr("Timeout(10) while trying to read from SMTP server");
  120. retval = ERROR;
  121. }
  123. if (retval != ERROR) {
  124. retval = atoi(tmpbuf->str);
  125. }
  127. dsbDestroy(tmpbuf);
  128. return retval;
  129. }
  131. static int
  132. writeResponse(dsocket *sd, char *line, ...)
  133. {
  134. va_list vp;
  135. int sval, size=MAXBUF, bytes=0;
  136. struct timeval tv;
  137. fd_set wfds;
  138. char *buf = xmalloc(size+1);
  139. char *timeout = getConfValue("TIMEOUT");
  141. while (true) {
  142. va_start(vp, line);
  143. bytes = vsnprintf(buf, size, line, vp);
  144. va_end(vp);
  145. if (bytes > -1 && bytes < size) {
  146. /* String written properly */
  147. break;
  148. }
  150. if (bytes > -1) {
  151. size += 1;
  152. } else { 
  153. size *= 2;
  154. }
  155. buf = xrealloc(buf, size+1);
  156. }
  159. FD_ZERO(&wfds);
  160. FD_SET(dnetGetSock(sd), &wfds);
  161. if (timeout) {
  162. tv.tv_sec = atoi(timeout);
  163. } else {
  164. tv.tv_sec = 10;
  165. }
  166. tv.tv_usec = 0;
  167. sval = select(dnetGetSock(sd)+1, NULL, &wfds, NULL, &tv);
  168. if (sval == -1) {
  169. smtpSetErr("writeResponse: select error");
  170. bytes = ERROR;
  171. } else if (sval) {
  172. dnetWrite(sd, buf, bytes);
  173. if (dnetErr(sd)) {
  174. smtpSetErr(dnetGetErr(sd));
  175. bytes = ERROR;
  176. }
  177. } else {
  178. smtpSetErr("Timeout(10) trying to write to SMTP server.");
  179. bytes = ERROR;
  180. }
  181. xfree(buf);
  182. return bytes;
  183. }
  185. static int
  186. helo(dsocket *sd, const char *domain)
  187. {
  188. int retval;
  189. dstrbuf *rbuf = DSB_NEW;
  191. /*
  192.  * We will be calling this function after ehlo() has already
  193.  * been called.  Since ehlo() already grabs the header, go
  194.  * straight into sending the HELO
  195.  */
  196. if (writeResponse(sd, "HELO %srn", domain) < 0) {
  197. smtpSetErr("Lost connection to SMTP server");
  198. retval = ERROR;
  199. goto end;
  200. }
  202. #ifdef DEBUG_SMTP
  203. printf("--> HELOn");
  204. fflush(stdout);
  205. #endif
  207. retval = readResponse(sd, rbuf);
  208. if (retval != 250) {
  209. if (retval != ERROR) {
  210. smtpSetErr(rbuf->str);
  211. }
  212. goto end;
  213. }
  215. #ifdef DEBUG_SMTP
  216. printf("<-- %sn", rbuf->str);
  217. fflush(stdout);
  218. #endif
  220. end:
  221. dsbDestroy(rbuf);
  222. return retval;
  223. }
  226. static int
  227. ehlo(dsocket *sd, const char *domain)
  228. {
  229. int retval;
  230. dstrbuf *rbuf = DSB_NEW;
  232. /* This initiates the connection, so let's read the header first */
  233. retval = readResponse(sd, rbuf);
  234. if (retval != 220) {
  235. if (retval != ERROR) {
  236. smtpSetErr(rbuf->str);
  237. }
  238. goto end;
  239. }
  241. #ifdef DEBUG_SMTP
  242. printf("rn<-- %s", rbuf->str);
  243. fflush(stdout);
  244. #endif
  246. if (writeResponse(sd, "EHLO %srn", domain) < 0) {
  247. smtpSetErr("Lost connection to SMTP server");
  248. retval = ERROR;
  249. goto end;
  250. }
  252. #ifdef DEBUG_SMTP
  253. printf("rn--> EHLO %srn", domain);
  254. fflush(stdout);
  255. #endif
  257. retval = readResponse(sd, rbuf);
  258. if (retval != 250) {
  259. if (retval != ERROR) {
  260. smtpSetErr(rbuf->str);
  261. }
  262. retval = ERROR;
  263. goto end;
  264. }
  266. #ifdef DEBUG_SMTP
  267. printf("rn<-- %s", rbuf->str);
  268. fflush(stdout);
  269. #endif
  271. end:
  272. dsbDestroy(rbuf);
  273. return retval;
  274. }
  276. /** 
  277.  * Send the MAIL FROM: command to the smtp server 
  278.  */
  279. static int
  280. mailFrom(dsocket *sd, const char *email)
  281. {
  282. int retval = 0;
  283. dstrbuf *rbuf = DSB_NEW;
  285. /* Create the MAIL FROM: command */
  286. if (writeResponse(sd, "MAIL FROM:<%s>rn", email) < 0) {
  287. smtpSetErr("Lost connection with SMTP server");
  288. retval = ERROR;
  289. goto end;
  290. }
  292. #ifdef DEBUG_SMTP
  293. printf("rn--> MAIL FROM:<%s>rn", email);
  294. #endif
  296. /* read return message and let's return it's code */
  297. retval = readResponse(sd, rbuf);
  298. if (retval != 250) {
  299. if (retval != ERROR) {
  300. smtpSetErr(rbuf->str);
  301. }
  302. retval = ERROR;
  303. goto end;
  304. }
  306. #ifdef DEBUG_SMTP
  307. printf("rn<-- %s", rbuf->str);
  308. #endif
  310. end:
  311. dsbDestroy(rbuf);
  312. return retval;
  313. }
  315. /**
  316.  * Send the RCPT TO: command to the smtp server
  317.  */
  318. static int
  319. rcpt(dsocket *sd, const char *email)
  320. {
  321. int retval = 0;
  322. dstrbuf *rbuf = DSB_NEW;
  324. if (writeResponse(sd, "RCPT TO: <%s>rn", email) < 0) {
  325. smtpSetErr("Lost connection with SMTP server");
  326. retval = ERROR;
  327. goto end;
  328. }
  330. #ifdef DEBUG_SMTP
  331. printf("rn--> RCPT TO: <%s>rn", email);
  332. fflush(stdout);
  333. #endif
  335. /* Read return message and let's return it's code */
  336. retval = readResponse(sd, rbuf);
  337. if ((retval != 250) && (retval != 251)) {
  338. if (retval != ERROR) {
  339. smtpSetErr(rbuf->str);
  340. }
  341. retval = ERROR;
  342. goto end;
  343. }
  345. #ifdef DEBUG_SMTP
  346. printf("rn<-- %s", rbuf->str);
  347. fflush(stdout);
  348. #endif
  350. end:
  351. dsbDestroy(rbuf);
  352. return retval;
  353. }
  356. /**
  357.  * Send the QUIT command
  358.  */
  359. static int
  360. quit(dsocket *sd)
  361. {
  362. int retval = 0;
  363. dstrbuf *rbuf = DSB_NEW;
  365. /* Create QUIT command and send it */
  366. if (writeResponse(sd, "QUITrn") < 0) {
  367. smtpSetErr("Lost Connection with SMTP server: Quit()");
  368. retval = ERROR;
  369. goto end;
  370. }
  372. #ifdef DEBUG_SMTP
  373. printf("--> QUITrn");
  374. #endif
  376. retval = readResponse(sd, rbuf);
  377. if (retval != 221) {
  378. if (retval != ERROR) {
  379. smtpSetErr(rbuf->str);
  380. }
  381. retval = ERROR;
  382. goto end;
  383. }
  385. #ifdef DEBUG_SMTP
  386. printf("<-- %s", rbuf->str);
  387. #endif
  389. end:
  390. dsbDestroy(rbuf);
  391. return retval;
  392. }
  394. int
  395. data(dsocket *sd)
  396. {
  397. int retval = 0;
  398. dstrbuf *rbuf = DSB_NEW;
  400. /* Create the DATA command and send it */
  401. if (writeResponse(sd, "DATArn") < 0) {
  402. smtpSetErr("Lost connection with SMTP server");
  403. retval = ERROR;
  404. goto end;
  405. }
  407. #ifdef DEBUG_SMTP
  408. printf("rn--> DATArn");
  409. #endif
  411. /* Read return message and let's return it's code */
  412. retval = readResponse(sd, rbuf);
  413. if (retval != 354) {
  414. if (retval != ERROR) {
  415. smtpSetErr(rbuf->str);
  416. }
  417. retval = ERROR;
  418. goto end;
  419. }
  421. #ifdef DEBUG_SMTP
  422. printf("<-- %s", rbuf->str);
  423. #endif
  425. end:
  426. dsbDestroy(rbuf);
  427. return retval;
  428. }
  430. /**
  431.  * Send the RSET command. 
  432.  */
  433. static int
  434. rset(dsocket *sd)
  435. {
  436. int retval = 0;
  437. dstrbuf *rbuf = DSB_NEW;
  439. /* Send the RSET command */
  440. if (writeResponse(sd, "RSETrn") < 0) {
  441. smtpSetErr("Socket write error: rset");
  442. retval = ERROR;
  443. goto end;
  444. }
  446. #ifdef DEBUG_SMTP
  447. printf("--> RSETn");
  448. fflush(stdout);
  449. #endif
  451. retval = readResponse(sd, rbuf);
  452. if (retval != 250) {
  453. if (retval != ERROR) {
  454. smtpSetErr(rbuf->str);
  455. }
  456. retval = ERROR;
  457. goto end;
  458. }
  461. #ifdef DEBUG_SMTP
  462. printf("<-- %sn", rbuf->str);
  463. fflush(stdout);
  464. #endif
  466. end:
  467. dsbDestroy(rbuf);
  468. return retval;
  469. }
  472. /** 
  473.  * SMTP AUTH login.
  474.  */
  475. static int
  476. smtpAuthLogin(dsocket *sd, const char *user, const char *pass)
  477. {
  478. int retval = 0;
  479. dstrbuf *data;
  480. dstrbuf *rbuf = DSB_NEW;
  482. data = mimeB64EncodeString((u_char *)user, strlen(user), false);
  483. if (writeResponse(sd, "AUTH LOGIN %srn", data->str) < 0) {
  484. smtpSetErr("Socket write error: smtp_auth_login");
  485. retval = ERROR;
  486. goto end;
  487. }
  489. #ifdef DEBUG_SMTP
  490. printf("--> AUTH LOGINn");
  491. fflush(stdout);
  492. #endif
  494. retval = readResponse(sd, rbuf);
  495. if (retval != 334) {
  496. if (retval != ERROR) {
  497. smtpSetErr(rbuf->str);
  498. }
  499. retval = ERROR;
  500. goto end;
  501. }
  503. #ifdef DEBUG_SMTP
  504. printf("<-- %sn", rbuf->str);
  505. fflush(stdout);
  506. #endif
  508. /* Encode the password */
  509. dsbDestroy(data);
  510. data = mimeB64EncodeString((u_char *)pass, strlen(pass), false);
  511. if (writeResponse(sd, "%srn", data->str) < 0) {
  512. smtpSetErr("Socket write error: smtp_auth_login");
  513. retval = ERROR;
  514. goto end;
  515. }
  517. #ifdef DEBUG_SMTP
  518. printf("--> %sn", data->str);
  519. fflush(stdout);
  520. #endif
  521. dsbDestroy(data);
  523. /* Read back "OK" from server */
  524. retval = readResponse(sd, rbuf);
  525. if (retval != 235) {
  526. if (retval != ERROR) {
  527. smtpSetErr(rbuf->str);
  528. }
  529. retval = ERROR;
  530. goto end;
  531. }
  533. #ifdef DEBUG_SMTP
  534. printf("<-- %sn", rbuf->str);
  535. fflush(stdout);
  536. #endif
  538. end:
  539. dsbDestroy(rbuf);
  540. return retval;
  541. }
  543. static int
  544. smtpAuthPlain(dsocket *sd, const char *user, const char *pass)
  545. {
  546. int retval = 0;
  547. dstrbuf *data=NULL;
  548. dstrbuf *up = DSB_NEW;
  549. dstrbuf *rbuf = DSB_NEW;
  551. if (writeResponse(sd, "AUTH PLAINrn") < 0) {
  552. smtpSetErr("Socket write error: smtp_auth_plain");
  553. retval = ERROR;
  554. goto end;
  555. }
  557. #ifdef DEBUG_SMTP
  558. printf("--> AUTH PLAINn");
  559. fflush(stdout);
  560. #endif
  562. retval = readResponse(sd, rbuf);
  563. if (retval != 334) {
  564. if (retval != ERROR) {
  565. smtpSetErr(rbuf->str);
  566. }
  567. retval = ERROR;
  568. goto end;
  569. }
  571. #ifdef DEBUG_SMTP
  572. printf("<-- %sn", rbuf->str);
  573. fflush(stdout);
  574. #endif
  576. dsbPrintf(up, "%c%s%c%s", '', user, '', pass);
  577. data = mimeB64EncodeString((u_char *)up->str, up->len, false);
  578. if (writeResponse(sd, "%srn", data->str) < 0) {
  579. smtpSetErr("Socket write error: smtp_auth_plain");
  580. retval = ERROR;
  581. goto end;
  582. }
  584. #ifdef DEBUG_SMTP
  585. printf("--> %sn", data->str);
  586. fflush(stdout);
  587. #endif
  589. dsbClear(rbuf);
  590. retval = readResponse(sd, rbuf);
  591. if (retval != 235) {
  592. if (retval != ERROR) {
  593. smtpSetErr(rbuf->str);
  594. }
  595. retval = ERROR;
  596. goto end;
  597. }
  599. #ifdef DEBUG_SMTP
  600. printf("<-- %sn", rbuf->str);
  601. fflush(stdout);
  602. #endif
  604. end:
  605. dsbDestroy(up);
  606. dsbDestroy(data);
  607. dsbDestroy(rbuf);
  608. return retval;
  609. }
  611. /**
  612.  * Initializes the SMTP communications with SMTP_AUTH.
  613.  *
  614.  * Params
  615.  *  sd - Socket descriptor
  616.  *  auth - LOGIN or PLAIN 
  617.  *  user - Username of the SMTP server
  618.  *  pass - Password for the Username
  619.  *
  620.  * Return
  621.  *  - ERROR
  622.  *  - SUCCESS
  623.  */
  624. int
  625. smtpInitAuth(dsocket *sd, const char *auth, const char *user, const char *pass)
  626. {
  627. int retval=ERROR;
  628. if (strcasecmp(auth, "LOGIN") == 0) {
  629. retval = smtpAuthLogin(sd, user, pass);
  630. } else if (strcasecmp(auth, "PLAIN") == 0) {
  631. retval = smtpAuthPlain(sd, user, pass);
  632. } 
  634. return retval;
  635. }
  638. /**
  639.  * Initializes the SMTP communications by sending the EHLO
  640.  * If EHLO errors out, it will try the HELO command.
  641.  *
  642.  * Params
  643.  *  sd - Socket descriptor
  644.  *  domain - Your domain name.
  645.  *
  646.  * Return
  647.  *  - ERROR
  648.  *  - SUCCESS
  649.  */
  650. int
  651. smtpInit(dsocket *sd, const char *domain)
  652. {
  653. int retval;
  655. printProgress("Greeting the SMTP server...");
  656. retval = ehlo(sd, domain);
  657. if (retval == ERROR) {
  658. /*
  659.  * Per RFC, if ehlo error's out, you can
  660.  * ignore the error, RSET and try a 
  661.  * regular helo.
  662.  */
  663. rset(sd);
  664. retval = helo(sd, domain);
  665. }
  667. return retval;
  668. }
  670. int
  671. smtpStartTls(dsocket *sd)
  672. {
  673.         int retval=SUCCESS;
  674. #ifdef HAVE_LIBSSL
  675.         dstrbuf *sb=DSB_NEW;
  677. printProgress("Starting TLS Communications...");
  678.         if (writeResponse(sd, "STARTTLSrn") < 0) {
  679.                 smtpSetErr("Lost connection to SMTP Server");
  680.                 retval = ERROR;
  681.                 goto end;
  682.         }
  684. #ifdef DEBUG_SMTP
  685. printf("--> STARTTLSn");
  686. fflush(stdout);
  687. #endif
  689.         retval = readResponse(sd, sb);
  690.         if (retval != 220) {
  691.                 smtpSetErr(sb->str);
  692.                 retval = ERROR;
  693.         }
  695. #ifdef DEBUG_SMTP
  696. printf("<-- %sn", sb->str);
  697. fflush(stdout);
  698. #endif
  700. end:
  701.         dsbDestroy(sb);
  702. #else
  703. sd = sd;
  704. #endif
  705.         return retval;
  706. }
  708. /**
  709.  * Sets who the message is from.  Basically runs the 
  710.  * MAIL FROM: SMTP command
  711.  *
  712.  * Params
  713.  *  sd - Socket descriptor
  714.  *  email - From Email
  715.  *
  716.  * Return
  717.  *  - ERROR
  718.  *  - SUCCESS
  719.  */
  720. int
  721. smtpSetMailFrom(dsocket *sd, const char *email)
  722. {
  723. return mailFrom(sd, email);
  724. }
  726. /**
  727.  * Sets all the recipients with the RCPT command
  728.  * to the smtp server. Multiple calls to this function
  729.  * are expected if you have multiple To, CC and BCC 
  730.  * recipients.
  731.  *
  732.  * Params
  733.  *  sd - Socket descriptor
  734.  *  to - An e-mail address to send the message to
  735.  *
  736.  * Return
  737.  *  - ERROR
  738.  *  - SUCCESS
  739.  */
  740. int
  741. smtpSetRcpt(dsocket *sd, const char *to)
  742. {
  743. return rcpt(sd, to);
  744. }
  746. /** 
  747.  * Send the DATA command to the smtp server (no data, just the command)
  748.  *
  749.  * Params
  750.  *  sd - Socket descriptor
  751.  *
  752.  * Return
  753.  *  - ERROR
  754.  *  - SUCCESS
  755.  */
  756. int
  757. smtpStartData(dsocket *sd)
  758. {
  759. return data(sd);
  760. }
  762. /**
  763.  * Sends data to the smtp server. You can try and send the
  764.  * whole chunk at once, or it may be a better idea to break
  765.  * up the data into smaller chunks.
  766.  *
  767.  * Params
  768.  *  sd - Socket descriptor
  769.  *  data - A chunk of data.
  770.  *  len - The length of the data to send
  771.  *
  772.  * Return
  773.  *  - ERROR
  774.  *  - SUCCESS
  775.  */
  776. int
  777. smtpSendData(dsocket *sd, const char *data, size_t len)
  778. {
  779. int retval = SUCCESS;
  781. assert(data != NULL);
  782. assert(sd != NULL);
  784. /* Write the data to the socket. */
  785. dnetWrite(sd, data, len);
  786. if (dnetErr(sd)) {
  787. smtpSetErr("Error writing to socket.");
  788. retval = ERROR;
  789. }
  790. return retval;
  791. }
  793. /**
  794.  * Let's the SMTP server know it's the end of the data stream.
  795.  *
  796.  * Params
  797.  *  sd - Socket descriptor
  798.  *
  799.  * Return
  800.  *  - ERROR
  801.  *  - SUCCESS
  802.  */
  803. int 
  804. smtpEndData(dsocket *sd)
  805. {
  806. int retval=ERROR;
  807. dstrbuf *rbuf = DSB_NEW;
  809. printProgress("Ending Data...");
  810. if (writeResponse(sd, "rn.rn") != ERROR) {
  811. retval = readResponse(sd, rbuf);
  812. if (retval != 250) {
  813. if (retval != ERROR) {
  814. smtpSetErr(rbuf->str);
  815. retval = ERROR;
  816. }
  817. }
  818. } else {
  819. smtpSetErr("Lost Connection with SMTP server: smtpEndData()");
  820. retval = ERROR;
  821. }
  823. dsbDestroy(rbuf);
  824. return retval;
  825. }
  827. /**
  828.  * Sends the QUITrn signal to the smtp server.
  829.  *
  830.  * Params
  831.  *  sd - Socket Descriptor
  832.  *
  833.  * Return
  834.  *  - ERROR
  835.  *  - SUCCESS
  836.  */
  837. int
  838. smtpQuit(dsocket *sd)
  839. {
  840. int retval=0;
  841. printProgress("Sending QUIT...");
  842. retval = quit(sd);
  843. dsbDestroy(errorstr);
  844. return retval;
  845. }