Main Page   Modules   Data Structures   File List   Data Fields   Globals   Related Pages   Examples  

/opentcp/smtp/smtp_client.c

Go to the documentation of this file.
00001 /*
00002  *Copyright (c) 2000-2002 Viola Systems Ltd.
00003  *All rights reserved.
00004  *
00005  *Redistribution and use in source and binary forms, with or without 
00006  *modification, are permitted provided that the following conditions 
00007  *are met:
00008  *
00009  *1. Redistributions of source code must retain the above copyright 
00010  *notice, this list of conditions and the following disclaimer.
00011  *
00012  *2. Redistributions in binary form must reproduce the above copyright 
00013  *notice, this list of conditions and the following disclaimer in the 
00014  *documentation and/or other materials provided with the distribution.
00015  *
00016  *3. The end-user documentation included with the redistribution, if 
00017  *any, must include the following acknowledgment:
00018  *      "This product includes software developed by Viola 
00019  *      Systems (http://www.violasystems.com/)."
00020  *
00021  *Alternately, this acknowledgment may appear in the software itself, 
00022  *if and wherever such third-party acknowledgments normally appear.
00023  *
00024  *4. The names "OpenTCP" and "Viola Systems" must not be used to 
00025  *endorse or promote products derived from this software without prior 
00026  *written permission. For written permission, please contact 
00027  *opentcp@opentcp.org.
00028  *
00029  *5. Products derived from this software may not be called "OpenTCP", 
00030  *nor may "OpenTCP" appear in their name, without prior written 
00031  *permission of the Viola Systems Ltd.
00032  *
00033  *THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED 
00034  *WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
00035  *MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
00036  *IN NO EVENT SHALL VIOLA SYSTEMS LTD. OR ITS CONTRIBUTORS BE LIABLE 
00037  *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
00038  *CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
00039  *SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 
00040  *BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
00041  *WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
00042  *OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 
00043  *EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00044  *====================================================================
00045  *
00046  *OpenTCP is the unified open source TCP/IP stack available on a series 
00047  *of 8/16-bit microcontrollers, please see <http://www.opentcp.org>.
00048  *
00049  *For more information on how to network-enable your devices, or how to 
00050  *obtain commercial technical support for OpenTCP, please see 
00051  *<http://www.violasystems.com/>.
00052  */
00053 
00067 #include <inet/datatypes.h>
00068 #include <inet/debug.h>
00069 #include <inet/globalvariables.h>
00070 #include <inet/system.h>
00071 #include <inet/timers.h>
00072 #include <inet/tcp_ip.h>
00073 #include <inet/smtp/smtp_client.h>
00074 
00075 UINT8 smtpc_init_done = 0; 
00083 struct
00084 {
00085         UINT8 state;
00086         UINT32 remip;
00087         UINT16 remport;
00088         INT8 sochandle;
00089         UINT8 tmrhandle;
00090         UINT16 unacked;
00091         UINT16 bufindex;
00092         
00093 }smtp_client;
00094 
00095 
00096 /* The applications that use TCP must implement following function stubs                        */
00097 /* void application_name_init (void) - call once when processor starts                          */
00098 /* void application_name_run (void) - call periodically on main loop                            */
00099 /* INT32 application_name_eventlistener (INT8, UINT8, UINT32, UINT32)                           */
00100 /* - called by TCP input process to inform arriving data, errors etc                            */
00101 
00102 /* SMTP client application              */
00103 
00120 INT8 smtpc_connect (UINT32 ip, UINT16 port){
00121         /* Do we have socket    */
00122 
00123         if( smtp_client.sochandle < 0 ) {
00124                 DEBUGOUT("smtpc_connect() called but no socket\r\n");
00125                 return(-1);
00126         }
00127         
00128         if( smtp_client.state < SMTP_CLOSED ) {
00129                 DEBUGOUT("smtpc_connect() called but uninitialized\r\n");
00130                 return(-1);
00131         }
00132         
00133         if( smtp_client.state == SMTP_CLOSED ) {
00134                 DEBUGOUT("SMTP Connection request going to be processed\r\n");
00135                 smtp_client.remip = ip;
00136                 smtp_client.remport = port;
00137                 smtpc_changestate(SMTP_OPEN_REQUESTED);
00138                 return(1);
00139         }
00140         
00141         return(-1);     
00142         
00143 }
00144 
00145 
00155 void smtpc_init (void){
00156         
00157         if(smtpc_init_done) {
00158                 DEBUGOUT("smtp client already initialized\r\n");
00159                 return;
00160         }
00161         
00162         
00163         /* Get timer handle     */
00164         
00165         smtp_client.tmrhandle = get_timer();
00166         
00167         /* Get TCP Socket       */
00168         
00169         smtp_client.sochandle = tcp_getsocket(TCP_TYPE_CLIENT, TCP_TOS_NORMAL, TCP_DEF_TOUT, smtpc_eventlistener);
00170         
00171         if( smtp_client.sochandle < 0 ) {
00172                 DEBUGOUT("smtpc_init() uncapable of getting socket\r\n");
00173                 RESET_SYSTEM();
00174         }       
00175         
00176         smtpc_changestate(SMTP_CLOSED);
00177         smtp_client.bufindex = TCP_APP_OFFSET;
00178         smtp_client.unacked = 0;        
00179         smtp_client.remip = 0;
00180         smtp_client.remport = 0;
00181 
00182         smtpc_init_done = 0x01;
00183 
00184 }
00185 
00193 UINT8 smtpc_getstate (void){
00194         return(smtp_client.state);
00195         
00196 }
00197 
00198 /********************************************************************************
00199 Function:               smtpc_eventlistener
00200 
00201 Parameters:             INT8 cbhandle - handle to TCP socket where event is coming from 
00202                                 UINT8 event - type of event
00203                                 UINT32 par1 - parameter the meaning of depends on event
00204                                 UINT32 par2 - parameter the meaning of depends on event
00205                                 
00206 Return val:             INT32 - depends on event but usually (-1) is error of some
00207                                                 kind and positive reply means OK
00208                                 
00209 Date:                   21.7.2002
00210 
00211 Desc:                   This function is given to TCP socket as function pointer to be
00212                                 used by TCP engine to make callbacks to inform about events
00213                                 on TCP e.g. arriving data. Main functionality of this function 
00214                                 is to parse data from TCP to detect SMTP server reply commands,
00215                                 handling out retransmissions and making state changes
00216 *********************************************************************************/
00217 
00218 
00219 INT32 smtpc_eventlistener (INT8 cbhandle, UINT8 event, UINT32 par1, UINT32 par2)
00220 {
00221         /* This function is called by TCP stack to inform about events  */
00222         
00223         UINT16 cmd;
00224                 
00225         
00226         if( cbhandle != smtp_client.sochandle)          /* Not our handle       */
00227                 return(-1);
00228         
00229         switch( event ) {
00230         
00231                 case TCP_EVENT_CONREQ:
00232                 
00233                         /* We don't allow incoming connections  */
00234                         
00235                         return(-1);
00236         
00237                 case TCP_EVENT_ABORT:
00238                 
00239                         if(smtp_client.state > SMTP_CLOSED)     {
00240                                 /* Inform application   */      
00241                                 smtpc_error();  
00242                         }
00243                 
00244                         smtpc_changestate(SMTP_CLOSED);
00245                         smtp_client.unacked = 0;
00246                         
00247                         return(1);
00248                 
00249                         break;
00250                 
00251                 case TCP_EVENT_CONNECTED:
00252                 
00253                         if(smtp_client.state == SMTP_CONNECTIONOPEN_SENT) {
00254                                 DEBUGOUT("SMTP TCP connection opened\r\n");
00255                                 smtpc_changestate(SMTP_CONNECTION_OPENED);
00256                                 smtp_client.unacked = 0;
00257                                 smtp_client.bufindex = TCP_APP_OFFSET;
00258                                 return(-1);
00259                         }
00260                                 
00261                         break;
00262                         
00263                 case TCP_EVENT_CLOSE:
00264                 
00265                         smtpc_changestate(SMTP_CLOSED);
00266                         smtp_client.unacked = 0;
00267                         return(1);
00268                 
00269                         break;
00270                         
00271                 case TCP_EVENT_ACK:
00272                 
00273                         /* Our message is acked */
00274                         
00275                         smtp_client.unacked = 0;
00276                         
00277                         break;
00278                         
00279                 case TCP_EVENT_DATA:
00280                 
00281                         /* Do we have unacked data?     */
00282                         
00283                         if(smtp_client.unacked)
00284                                 return(-1);
00285                 
00286                         /* Get reply from server        */
00287                         
00288                         if(par1 < 3)                                    /* Long enough? */
00289                                 return(-1);
00290                 
00291                         /* Get command                          */
00292                         
00293                         NETWORK_RECEIVE_INITIALIZE(received_tcp_packet.buf_index);
00294                         cmd = RECEIVE_NETWORK_B();
00295                         cmd += RECEIVE_NETWORK_B();
00296                         cmd += RECEIVE_NETWORK_B();
00297                         
00298                         switch(smtp_client.state) { 
00299                                 
00300                                 case SMTP_CONNECTION_OPENED:
00301                                 
00302                                         if(cmd == SMTP_CMD_SERVER_READY) {
00303                                                 DEBUGOUT("SMTP Server is ready\r\n");
00304                                                 smtpc_changestate(SMTP_SERVER_READY);
00305                                                 return(1);
00306                                         }
00307                                         
00308                                         break;
00309                                 
00310                                 case SMTP_HELO_SENT:
00311                                 
00312                                         if(cmd == SMTP_CMD_OK) {        
00313                                                 DEBUGOUT("HELO acked by SMTP server\r\n");
00314                                                 smtpc_changestate(SMTP_HELO_ACKED);
00315                                                 return(1);
00316                                         }
00317                                         
00318                                         break;                          
00319                                         
00320                                 case SMTP_MAILFROM_SENT:
00321                                 
00322                                         if(cmd == SMTP_CMD_OK) {
00323                                                 DEBUGOUT("MAIL FROM Acked by SMTP server\r\n");
00324                                                 smtpc_changestate(SMTP_MAILFROM_ACKED);
00325                                                 return(1);
00326                                         }
00327                                         
00328                                         break;                  
00329                                         
00330                                 case SMTP_RCPTTO_SENT: 
00331                                 
00332                                         if(cmd == SMTP_CMD_OK) {
00333                                                 DEBUGOUT("RCPT TO Acked by SMTP server\r\n");
00334                                                 smtpc_changestate(SMTP_RCPTTO_ACKED);
00335                                                 return(1);
00336                                         }
00337                                         
00338                                         break;  
00339                                         
00340                                 case SMTP_DATAREQ_SENT:
00341                                 
00342                                         if(cmd == SMTP_CMD_DATAOK) {
00343                                                 DEBUGOUT("DATA Acked by SMTP Server\r\n");
00344                                                 smtpc_changestate(SMTP_DATAREQ_ACKED);
00345                                                 return(1);
00346                                         }
00347                                         
00348                                         break;                                                                          
00349                                 
00350                                 case SMTP_DATAEND_SENT:
00351                                 
00352                                         if(cmd == SMTP_CMD_OK) {
00353                                                 DEBUGOUT("CRLF.CRLF Acked by SMTP Server\r\n");
00354                                                 smtpc_changestate(SMTP_DATAEND_ACKED);
00355                                                 return(1);
00356                                         }
00357                                         
00358                                         break;                                  
00359                                         
00360                                 case SMTP_QUIT_SENT:
00361                                 
00362                                         if(cmd == SMTP_CMD_QUITOK) {
00363                                                 DEBUGOUT("QUIT Acked by SMTP Server\r\n");
00364                                                 smtpc_changestate(SMTP_QUIT_ACKED);
00365                                                 return(1);
00366                                         }
00367                                         
00368                                         break;
00369                                         
00370                                 default:
00371                                         break;
00372 
00373                         
00374                         }
00375 
00376                 
00377                         return(1);
00378                 
00379                         
00380                 case TCP_EVENT_REGENERATE:
00381                 
00382                         /* Send last packet again       */
00383                 
00384                         DEBUGOUT("SMTP is regenerating...\r\n");
00385                 
00386                         switch (smtp_client.state) {
00387                         
00388                                 case SMTP_HELO_SENT:
00389                                         smtpc_sendhelo();
00390                                         return(1);
00391                                 
00392                                 case SMTP_MAILFROM_SENT:
00393                                         smtpc_sendmailfrom();
00394                                         return(1);
00395                                         
00396                                 case SMTP_RCPTTO_SENT:
00397                                         smtpc_sendrcptto();
00398                                         return(1);
00399                                 
00400                                 case SMTP_DATAREQ_SENT:
00401                                         smtpc_senddatareq();
00402                                         return(1);
00403                                 
00404                                 case SMTP_BODY_SENT:
00405                                         smtpc_sendbody();
00406                                         return(1);      
00407                                 
00408                                 case SMTP_SENDING_DATA:
00409                                         smtpc_senddata();
00410                                         return(1);
00411                                 
00412                                 case SMTP_DATAEND_SENT: 
00413                                         smtpc_senddataend();
00414                                         return(1);
00415                                 
00416                                 case SMTP_QUIT_SENT:
00417                                         smtpc_sendquit();
00418                                         return(1);
00419                                         
00420                                 default:
00421                                         return(-1);
00422                         }
00423                 
00424                 
00425                         break;
00426         
00427         
00428                 default:
00429                         return(-1);
00430         }       
00431 
00432         return(-1);
00433 
00434 }
00435 
00436 /********************************************************************************
00437 Function:               smtpc_run
00438 
00439 Parameters:             void    
00440                                 
00441 Return val:             void
00442                                 
00443 Date:                   21.7.2002
00444 
00445 Desc:                   This function is main 'thread' of SMTP client program
00446                                 and should be called periodically when SMTP client is
00447                                 active. This function is responsible of sending commands and
00448                                 data to SMTP server and making callbacks to user function stubs.
00449 *********************************************************************************/
00450 
00451 
00452 void smtpc_run (void)
00453 {
00454         /* On that function we can send data when called by main loop   */
00455         
00456         if( smtpc_init_done == 0 )
00457                 return;
00458         
00459         if( smtp_client.state < SMTP_OPEN_REQUESTED)
00460                 return;
00461                 
00462         /* Is there timeout of some sort?       */
00463                 
00464         if(check_timer(smtp_client.tmrhandle) == 0) {
00465                 /* Yep  */
00466                 tcp_abort(smtp_client.sochandle);
00467                 smtpc_changestate(SMTP_CLOSED);
00468                         
00469                 /* Make user callback   */
00470                 smtpc_error();
00471                 return;
00472                 
00473         }       
00474         
00475         if( smtp_client.state == SMTP_OPEN_REQUESTED) {
00476                 /* We are on this state because user has requested connection   */
00477                 /* but connection is not yet opened.                                                    */
00478                 /* Try to get TCP stack to accept our connection request                */
00479                 
00480                 tcp_abort(smtp_client.sochandle);       /* Release old connection       */
00481                 if(tcp_connect(smtp_client.sochandle, smtp_client.remip, smtp_client.remport, 0) >= 0)
00482                         smtpc_changestate(SMTP_CONNECTIONOPEN_SENT);
00483                 
00484                 return;
00485         }
00486         
00487         
00488 
00489         if( tcp_getstate(smtp_client.sochandle) != TCP_STATE_CONNECTED ) {
00490                 return;
00491         }
00492         
00493         if( tcp_checksend(smtp_client.sochandle) < 0 )
00494                 return;
00495         
00496         /* It's connected and no unacked data so try to send    */
00497         
00498         
00499         if(smtp_client.state == SMTP_SERVER_READY) {
00500                 /* Send HELO    */
00501                 smtpc_sendhelo();
00502                 smtpc_changestate(SMTP_HELO_SENT);
00503                 DEBUGOUT("SMTP HELO packet sent\r\n");
00504                 return;
00505         }
00506         
00507         if(smtp_client.state == SMTP_HELO_ACKED) {
00508                 /* Send MAIL FROM       */
00509                 smtpc_sendmailfrom();
00510                 smtpc_changestate(SMTP_MAILFROM_SENT);
00511                 DEBUGOUT("SMTP MAIL FROM packet sent\r\n");
00512                 return;
00513         }       
00514         
00515         if(smtp_client.state == SMTP_MAILFROM_ACKED) {
00516                 /* Send RCPT TO */
00517                 smtpc_sendrcptto();
00518                 smtpc_changestate(SMTP_RCPTTO_SENT);
00519                 DEBUGOUT("SMTP RCPT TO packet sent\r\n");
00520                 return;
00521         }       
00522         
00523         if(smtp_client.state == SMTP_RCPTTO_ACKED) {
00524                 /* Send DATA    */
00525                 smtpc_senddatareq();
00526                 smtpc_changestate(SMTP_DATAREQ_SENT);
00527                 DEBUGOUT("SMTP DATA packet sent\r\n");
00528                 return;
00529         }       
00530         
00531         if(smtp_client.state == SMTP_DATAREQ_ACKED)     {
00532                 /* Send BODY    */
00533                 smtpc_sendbody();
00534                 smtpc_changestate(SMTP_BODY_SENT);
00535                 DEBUGOUT("SMTP BODY packet sent\r\n");
00536                 return;
00537         }       
00538         
00539         
00540         /* Body is part of plain text so we just make internal state change     */
00541         /* when TCP has acked the body packet. This pseudo-state just helps */
00542         /* us to regenerate the body when needed                                                        */
00543         
00544         if(smtp_client.state == SMTP_BODY_SENT)
00545                 smtpc_changestate(SMTP_SENDING_DATA);
00546         
00547         if(smtp_client.state == SMTP_SENDING_DATA) {
00548                 /* Inform user app that old data is acked now   */
00549                 
00550                 smtpc_dataacked();              
00551         
00552                 if (smtpc_senddata() < 0) {
00553                         /* End of data, send CRLF.CRLF  */
00554                         
00555                         DEBUGOUT("SMTP End of data reached\r\n");
00556                         smtpc_senddataend();
00557                         smtpc_changestate(SMTP_DATAEND_SENT);
00558                         
00559                 }
00560                 return;
00561         }       
00562         
00563                 
00564         if(smtp_client.state == SMTP_DATAEND_ACKED) {
00565                 /* Send QUIT    */
00566                 smtpc_sendquit();
00567                 smtpc_changestate(SMTP_QUIT_SENT);
00568                 DEBUGOUT("SMTP QUIT packet sent\r\n");
00569                 return;
00570         }               
00571 
00572 
00573         if(smtp_client.state == SMTP_QUIT_ACKED) {
00574         
00575                 /* Inform application that data is sent OK      */
00576                 
00577                 smtpc_allok();
00578         
00579                 /* Try to close TCP     */
00580                 
00581                 if(tcp_close(smtp_client.sochandle) >= 0) {
00582                         smtpc_changestate(SMTP_CLOSED);
00583                         DEBUGOUT("SMTP connection closed OK\r\n");
00584                         return;
00585                 }
00586                 
00587                 /* Close is not accepted by TCP. See if timeout */
00588                 
00589                 if(check_timer(smtp_client.tmrhandle) == 0) {
00590                         /* Use brute force              */
00591                         
00592                         tcp_abort(smtp_client.sochandle);
00593                         smtpc_changestate(SMTP_CLOSED);
00594                         DEBUGOUT("SMTP connection closed by ABORT\r\n");
00595                         return;
00596                 }
00597                 
00598                 /* Keep trying untill timeout   */
00599                 
00600                 return;
00601                 
00602         }       
00603         
00604         return;
00605 
00606 }
00607 
00608 
00609 void smtpc_sendhelo (void)
00610 {
00611         INT8 i;
00612         UINT8* buf;
00613 
00614         /* Fill TCP Tx buffer with "HELO " and use callback function    */
00615         /* smtp_getdomain in order to get domain from systems and send  */
00616         /* that combined "HELO domainnname" to SMTP server                              */
00617         
00618         buf = &net_buf[TCP_APP_OFFSET];
00619         
00620         *buf++ = 'H';
00621         *buf++ = 'E';
00622         *buf++ = 'L';
00623         *buf++ = 'O';
00624         *buf++ = ' '; 
00625         
00626         i = smtpc_getdomain(buf);
00627         
00628         if(i < 0)
00629                 return;
00630         
00631         buf += i;       
00632         
00633         /* Insert CRLF  */
00634         
00635         *buf++ = '\r';
00636         *buf = '\n';
00637                 
00638 
00639         tcp_send(smtp_client.sochandle, &net_buf[TCP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - TCP_APP_OFFSET, i + 7);
00640 
00641 }
00642 
00643 
00644 
00645 void smtpc_sendmailfrom (void)
00646 {
00647         INT8 i;
00648         UINT8* buf;
00649 
00650         /* Fill TCP Tx buffer with "MAIL FROM: <" and use callback function                             */
00651         /* smtp_getsender in order to get local e-mail address from user and send               */
00652         /* that combined "MAIL FROM: <myadr>" to SMTP server                                                    */
00653         
00654         buf = &net_buf[TCP_APP_OFFSET];
00655         
00656         *buf++ = 'M';
00657         *buf++ = 'A';
00658         *buf++ = 'I';
00659         *buf++ = 'L';
00660         *buf++ = ' '; 
00661         *buf++ = 'F';
00662         *buf++ = 'R';
00663         *buf++ = 'O';
00664         *buf++ = 'M';
00665         *buf++ = ':';
00666         *buf++ = ' ';
00667         *buf++ = '<';   
00668         
00669         i = smtpc_getsender(buf);
00670         
00671         if(i < 0)
00672                 return;
00673         
00674         buf += i;
00675         
00676         /* Insert >CRLF */
00677         
00678         *buf++ = '>';
00679         *buf++ = '\r';
00680         *buf = '\n';
00681                 
00682 
00683         tcp_send(smtp_client.sochandle, &net_buf[TCP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - TCP_APP_OFFSET, i + 15);
00684 
00685 }
00686 
00687 
00688 
00689 void smtpc_sendrcptto (void)
00690 {
00691         INT8 i;
00692         UINT8* buf;
00693 
00694         /* Fill TCP Tx buffer with "RCPT TO: <" and use callback function                       */
00695         /* smtp_getreceiver in order to get receiver address from user and send         */
00696         /* that combined "RCPT To: <rcvadr>" to SMTP server                                                     */
00697         
00698         buf = &net_buf[TCP_APP_OFFSET];
00699         
00700         *buf++ = 'R';
00701         *buf++ = 'C';
00702         *buf++ = 'P';
00703         *buf++ = 'T';
00704         *buf++ = ' '; 
00705         *buf++ = 'T';
00706         *buf++ = 'O';
00707         *buf++ = ':';
00708         *buf++ = ' ';
00709         *buf++ = '<';   
00710         
00711         i = smtpc_getreceiver(buf);
00712         
00713         if(i < 0)
00714                 return;
00715                 
00716         buf += i;       
00717         
00718         /* Insert >CRLF */
00719         
00720         *buf++ = '>';
00721         *buf++ = '\r';
00722         *buf = '\n';
00723                 
00724 
00725         tcp_send(smtp_client.sochandle, &net_buf[TCP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - TCP_APP_OFFSET, i + 13);
00726 
00727 }
00728 
00729 void smtpc_senddatareq (void)
00730 {
00731         UINT8* buf;
00732 
00733         /* Fill TCP Tx buffer with "DATA" and send to SMTP server       */
00734         
00735         buf = &net_buf[TCP_APP_OFFSET];
00736         
00737         *buf++ = 'D';
00738         *buf++ = 'A';
00739         *buf++ = 'T';
00740         *buf++ = 'A';
00741 
00742         /* Insert CRLF  */
00743         
00744         *buf++ = '\r';
00745         *buf = '\n';
00746                 
00747         tcp_send(smtp_client.sochandle, &net_buf[TCP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - TCP_APP_OFFSET, 6);
00748 
00749 }
00750 
00751 void smtpc_sendbody (void)
00752 {
00753         UINT8* buf;
00754         INT8 i;
00755         UINT8 j;
00756 
00757         /* Fill TCP Tx buffer with RFC 822 body and send to SMTP server */
00758         
00759         j = 0;
00760         buf = &net_buf[TCP_APP_OFFSET];
00761         
00762         *buf++ = 'T';
00763         *buf++ = 'o';
00764         *buf++ = ':';
00765         *buf++ = ' ';
00766         
00767         i = smtpc_getreceiver(buf);
00768         
00769         if(i < 0)
00770                 return;
00771                 
00772         buf += i;       
00773                 
00774         j += i;
00775 
00776         /* Insert CRLF  */
00777         
00778         *buf++ = '\r';
00779         *buf++ = '\n';
00780         
00781         *buf++ = 'S';
00782         *buf++ = 'u';
00783         *buf++ = 'b';
00784         *buf++ = 'j';
00785         *buf++ = 'e';
00786         *buf++ = 'c';
00787         *buf++ = 't';
00788         *buf++ = ':';
00789         *buf++ = ' ';
00790         
00791         i = smtpc_getsubject(buf);
00792         
00793         if(i < 0)
00794                 return;
00795         
00796         buf += i;
00797         
00798         j += i;
00799 
00800         /* Insert CRLF  */
00801         
00802         *buf++ = '\r';
00803         *buf++ = '\n';  
00804         
00805         *buf++ = 'F';
00806         *buf++ = 'r';
00807         *buf++ = 'o';
00808         *buf++ = 'm';
00809         *buf++ = ':';
00810         *buf++ = ' ';
00811         
00812         i = smtpc_getsender(buf);
00813         
00814         if(i < 0)
00815                 return;
00816         
00817         buf += i;
00818         
00819         j += i;
00820 
00821         /* Insert CRLF  */
00822         
00823         *buf++ = '\r';
00824         *buf++ = '\n';  
00825         
00826         /* Insert emty row      */
00827         
00828         *buf++ = '\r';
00829         *buf = '\n';
00830                 
00831         tcp_send(smtp_client.sochandle, &net_buf[TCP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - TCP_APP_OFFSET, j + 27);
00832 
00833 }
00834 
00835 
00836 void smtpc_senddataend (void)
00837 {
00838         UINT8* buf;
00839 
00840         /* Fill TCP Tx buffer with CRLF.CRLF and send to SMTP server    */
00841         
00842         buf = &net_buf[TCP_APP_OFFSET];
00843         
00844         *buf++ = '\r';
00845         *buf++ = '\n';
00846         *buf++ = '.';
00847         *buf++ = '\r';
00848         *buf = '\n';
00849                 
00850         tcp_send(smtp_client.sochandle, &net_buf[TCP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - TCP_APP_OFFSET, 5);
00851 
00852 }
00853 
00854 
00855 void smtpc_sendquit (void)
00856 {
00857         UINT8* buf;
00858 
00859         /* Fill TCP Tx buffer with "QUIT" and send to SMTP server       */
00860         
00861         buf = &net_buf[TCP_APP_OFFSET];
00862         
00863         *buf++ = 'Q';
00864         *buf++ = 'U';
00865         *buf++ = 'I';
00866         *buf++ = 'T';
00867 
00868         /* Insert CRLF  */
00869         
00870         *buf++ = '\r';
00871         *buf = '\n';
00872                 
00873         tcp_send(smtp_client.sochandle, &net_buf[TCP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - TCP_APP_OFFSET, 6);
00874 
00875 }
00876 
00877 
00878 INT16 smtpc_senddata (void)
00879 {
00880 
00881         INT16 len;
00882 
00883         /* Use callback smtpc_getdata in order to fill Tx buffer with user data */
00884         /* Normally user callback should return number of bytes assembled but   */
00885         /* when end of data is reached no bytes are written but (-1) returned   */
00886         
00887         len = smtpc_getdata(&net_buf[TCP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - TCP_APP_OFFSET);
00888         
00889         if(len < 0)
00890                 return(-1);
00891                 
00892         if(len > 0)     
00893                 tcp_send(smtp_client.sochandle, &net_buf[TCP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - TCP_APP_OFFSET, (UINT16)len);
00894         
00895         return(len);
00896         
00897 }
00898 
00899 void smtpc_changestate (UINT8 nstate)
00900 {
00901         
00902         init_timer(smtp_client.tmrhandle, SMTPC_TOUT*TIMERTIC);
00903         smtp_client.state = nstate;
00904 
00905 }
00906 
00907 

Generated on Sun Aug 3 20:33:00 2003 for OpenTCP by doxygen1.2.18