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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
inetmail.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：25k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

inetmail.cxx：源码内容
  1. /*
  2.  * inetmail.cxx
  3.  *
  4.  * Internet Mail classes.
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: inetmail.cxx,v $
  30.  * Revision 1.13  2000/06/21 01:01:22  robertj
  31.  * AIX port, thanks Wolfgang Platzer (wolfgang.platzer@infonova.at).
  32.  *
  33.  * Revision 1.12  1998/11/30 04:52:01  robertj
  34.  * New directory structure
  35.  *
  36.  * Revision 1.11  1998/09/23 06:22:18  robertj
  37.  * Added open source copyright license.
  38.  *
  39.  * Revision 1.10  1998/01/26 02:49:20  robertj
  40.  * GNU support.
  41.  *
  42.  * Revision 1.9  1997/07/14 11:47:14  robertj
  43.  * Added "const" to numerous variables.
  44.  *
  45.  * Revision 1.8  1996/12/21 01:24:39  robertj
  46.  * Added missing open message to smtp server.
  47.  *
  48.  * Revision 1.7  1996/09/14 13:18:03  robertj
  49.  * Renamed file and changed to be a protocol off new indirect channel to separate
  50.  *   the protocol from the low level byte transport channel.
  51.  *
  52.  * Revision 1.6  1996/07/27 04:12:45  robertj
  53.  * Redesign and reimplement of mail sockets.
  54.  *
  55.  * Revision 1.5  1996/06/28 13:22:09  robertj
  56.  * Changed SMTP incoming message handler so can tell when started, processing or ended message.
  57.  *
  58.  * Revision 1.4  1996/05/26 03:46:51  robertj
  59.  * Compatibility to GNU 2.7.x
  60.  *
  61.  * Revision 1.3  1996/03/18 13:33:16  robertj
  62.  * Fixed incompatibilities to GNU compiler where PINDEX != int.
  63.  *
  64.  * Revision 1.2  1996/03/16 04:51:28  robertj
  65.  * Changed lastResponseCode to an integer.
  66.  * Added ParseReponse() for splitting reponse line into code and info.
  67.  *
  68.  * Revision 1.1  1996/03/04 12:12:51  robertj
  69.  * Initial revision
  70.  *
  71.  */
  73. #ifdef __GNUC__
  74. #pragma implementation "inetmail.h"
  75. #endif
  77. #include <ptlib.h>
  78. #include <ptlib/sockets.h>
  79. #include <ptclib/inetmail.h>
  82. static const PString CRLF = "rn";
  83. static const PString CRLFdotCRLF = "rn.rn";
  86. //////////////////////////////////////////////////////////////////////////////
  87. // PSMTP
  89. static char const * const SMTPCommands[PSMTP::NumCommands] = {
  90.   "HELO", "EHLO", "QUIT", "HELP", "NOOP",
  91.   "TURN", "RSET", "VRFY", "EXPN", "RCPT",
  92.   "MAIL", "SEND", "SAML", "SOML", "DATA"
  93. };
  96. PSMTP::PSMTP()
  97.   : PInternetProtocol("smtp 25", NumCommands, SMTPCommands)
  98. {
  99. }
  102. //////////////////////////////////////////////////////////////////////////////
  103. // PSMTPClient
  105. PSMTPClient::PSMTPClient()
  106. {
  107.   haveHello = FALSE;
  108.   extendedHello = FALSE;
  109.   eightBitMIME = FALSE;
  110. }
  113. PSMTPClient::~PSMTPClient()
  114. {
  115.   Close();
  116. }
  119. BOOL PSMTPClient::OnOpen()
  120. {
  121.   return ReadResponse() && lastResponseCode/100 == 2;
  122. }
  125. BOOL PSMTPClient::Close()
  126. {
  127.   BOOL ok = TRUE;
  128.   if (IsOpen() && haveHello) {
  129.     SetReadTimeout(60000);
  130.     ok = ExecuteCommand(QUIT, "") == '2';
  131.   }
  132.   return PInternetProtocol::Close() && ok;
  133. }
  136. BOOL PSMTPClient::BeginMessage(const PString & from,
  137.                                const PString & to,
  138.                                BOOL useEightBitMIME)
  139. {
  140.   fromAddress = from;
  141.   toNames.RemoveAll();
  142.   toNames.AppendString(to);
  143.   eightBitMIME = useEightBitMIME;
  144.   return _BeginMessage();
  145. }
  148. BOOL PSMTPClient::BeginMessage(const PString & from,
  149.                                const PStringList & toList,
  150.                                BOOL useEightBitMIME)
  151. {
  152.   fromAddress = from;
  153.   toNames = toList;
  154.   eightBitMIME = useEightBitMIME;
  155.   return _BeginMessage();
  156. }
  159. BOOL PSMTPClient::_BeginMessage()
  160. {
  161.   PString localHost;
  162.   PString peerHost;
  163.   PIPSocket * socket = GetSocket();
  164.   if (socket != NULL) {
  165.     localHost = socket->GetLocalHostName();
  166.     peerHost = socket->GetPeerHostName();
  167.   }
  169.   if (!haveHello) {
  170.     if (ExecuteCommand(EHLO, localHost) == '2')
  171.       haveHello = extendedHello = TRUE;
  172.   }
  174.   if (!haveHello) {
  175.     extendedHello = FALSE;
  176.     if (eightBitMIME)
  177.       return FALSE;
  178.     if (ExecuteCommand(HELO, localHost) != '2')
  179.       return FALSE;
  180.     haveHello = TRUE;
  181.   }
  183.   if (fromAddress[0] != '"' && fromAddress.Find(' ') != P_MAX_INDEX)
  184.     fromAddress = '"' + fromAddress + '"';
  185.   if (!localHost && fromAddress.Find('@') == P_MAX_INDEX)
  186.     fromAddress += '@' + localHost;
  187.   if (ExecuteCommand(MAIL, "FROM:<" + fromAddress + '>') != '2')
  188.     return FALSE;
  190.   for (PINDEX i = 0; i < toNames.GetSize(); i++) {
  191.     if (!peerHost && toNames[i].Find('@') == P_MAX_INDEX)
  192.       toNames[i] += '@' + peerHost;
  193.     if (ExecuteCommand(RCPT, "TO:<" + toNames[i] + '>') != '2')
  194.       return FALSE;
  195.   }
  197.   if (ExecuteCommand(DATA, PString()) != '3')
  198.     return FALSE;
  200.   stuffingState = StuffIdle;
  201.   return TRUE;
  202. }
  205. BOOL PSMTPClient::EndMessage()
  206. {
  207.   flush();
  208.   stuffingState = DontStuff;
  209.   if (!WriteString(CRLFdotCRLF))
  210.     return FALSE;
  211.   return ReadResponse() && lastResponseCode/100 == 2;
  212. }
  215. //////////////////////////////////////////////////////////////////////////////
  216. // PSMTPServer
  218. PSMTPServer::PSMTPServer()
  219. {
  220.   extendedHello = FALSE;
  221.   eightBitMIME = FALSE;
  222.   messageBufferSize = 30000;
  223.   ServerReset();
  224. }
  227. void PSMTPServer::ServerReset()
  228. {
  229.   eightBitMIME = FALSE;
  230.   sendCommand = WasMAIL;
  231.   fromAddress = PString();
  232.   toNames.RemoveAll();
  233. }
  236. BOOL PSMTPServer::OnOpen()
  237. {
  238.   return WriteResponse(220, PIPSocket::GetHostName() + "ESMTP server ready");
  239. }
  242. BOOL PSMTPServer::ProcessCommand()
  243. {
  244.   PString args;
  245.   PINDEX num;
  246.   if (!ReadCommand(num, args))
  247.     return FALSE;
  249.   switch (num) {
  250.     case HELO :
  251.       OnHELO(args);
  252.       break;
  253.     case EHLO :
  254.       OnEHLO(args);
  255.       break;
  256.     case QUIT :
  257.       OnQUIT();
  258.       return FALSE;
  259.     case NOOP :
  260.       OnNOOP();
  261.       break;
  262.     case TURN :
  263.       OnTURN();
  264.       break;
  265.     case RSET :
  266.       OnRSET();
  267.       break;
  268.     case VRFY :
  269.       OnVRFY(args);
  270.       break;
  271.     case EXPN :
  272.       OnEXPN(args);
  273.       break;
  274.     case RCPT :
  275.       OnRCPT(args);
  276.       break;
  277.     case MAIL :
  278.       OnMAIL(args);
  279.       break;
  280.     case SEND :
  281.       OnSEND(args);
  282.       break;
  283.     case SAML :
  284.       OnSAML(args);
  285.       break;
  286.     case SOML :
  287.       OnSOML(args);
  288.       break;
  289.     case DATA :
  290.       OnDATA();
  291.       break;
  292.     default :
  293.       return OnUnknown(args);
  294.   }
  296.   return TRUE;
  297. }
  300. void PSMTPServer::OnHELO(const PCaselessString & remoteHost)
  301. {
  302.   extendedHello = FALSE;
  303.   ServerReset();
  305.   PCaselessString peerHost;
  306.   PIPSocket * socket = GetSocket();
  307.   if (socket != NULL)
  308.     peerHost = socket->GetPeerHostName();
  310.   PString response = PIPSocket::GetHostName() & "Hello" & peerHost + ", ";
  312.   if (remoteHost == peerHost)
  313.     response += "pleased to meet you.";
  314.   else if (remoteHost.IsEmpty())
  315.     response += "why do you wish to remain anonymous?";
  316.   else
  317.     response += "why do you wish to call yourself "" + remoteHost + ""?";
  319.   WriteResponse(250, response);
  320. }
  323. void PSMTPServer::OnEHLO(const PCaselessString & remoteHost)
  324. {
  325.   extendedHello = TRUE;
  326.   ServerReset();
  328.   PCaselessString peerHost;
  329.   PIPSocket * socket = GetSocket();
  330.   if (socket != NULL)
  331.     peerHost = socket->GetPeerHostName();
  333.   PString response = PIPSocket::GetHostName() & "Hello" & peerHost + ", ";
  335.   if (remoteHost == peerHost)
  336.     response += ", pleased to meet you.";
  337.   else if (remoteHost.IsEmpty())
  338.     response += "why do you wish to remain anonymous?";
  339.   else
  340.     response += "why do you wish to call yourself "" + remoteHost + ""?";
  342.   response += "nHELPnVERBnONEXnMULTnEXPNnTICKn8BITMIMEn";
  343.   WriteResponse(250, response);
  344. }
  347. void PSMTPServer::OnQUIT()
  348. {
  349.   WriteResponse(221, PIPSocket::GetHostName() + " closing connection, goodbye.");
  350.   Close();
  351. }
  354. void PSMTPServer::OnHELP()
  355. {
  356.   WriteResponse(214, "No help here.");
  357. }
  360. void PSMTPServer::OnNOOP()
  361. {
  362.   WriteResponse(250, "Ok");
  363. }
  366. void PSMTPServer::OnTURN()
  367. {
  368.   WriteResponse(502, "I don't do that yet. Sorry.");
  369. }
  372. void PSMTPServer::OnRSET()
  373. {
  374.   ServerReset();
  375.   WriteResponse(250, "Reset state.");
  376. }
  379. void PSMTPServer::OnVRFY(const PCaselessString & name)
  380. {
  381.   PString expandedName;
  382.   switch (LookUpName(name, expandedName)) {
  383.     case AmbiguousUser :
  384.       WriteResponse(553, "User "" + name + "" ambiguous.");
  385.       break;
  387.     case ValidUser :
  388.       WriteResponse(250, expandedName);
  389.       break;
  391.     case UnknownUser :
  392.       WriteResponse(550, "Name "" + name + "" does not match anything.");
  393.       break;
  395.     default :
  396.       WriteResponse(550, "Error verifying user "" + name + "".");
  397.   }
  398. }
  401. void PSMTPServer::OnEXPN(const PCaselessString &)
  402. {
  403.   WriteResponse(502, "I don't do that. Sorry.");
  404. }
  407. static PINDEX ParseMailPath(const PCaselessString & args,
  408.                             const PCaselessString & subCmd,
  409.                             PString & name,
  410.                             PString & domain,
  411.                             PString & forwardList)
  412. {
  413.   PINDEX colon = args.Find(':');
  414.   if (colon == P_MAX_INDEX)
  415.     return 0;
  417.   PCaselessString word = args.Left(colon).Trim();
  418.   if (subCmd != word)
  419.     return 0;
  421.   PINDEX leftAngle = args.Find('<', colon);
  422.   if (leftAngle == P_MAX_INDEX)
  423.     return 0;
  425.   PINDEX finishQuote;
  426.   PINDEX startQuote = args.Find('"', leftAngle);
  427.   if (startQuote == P_MAX_INDEX) {
  428.     colon = args.Find(':', leftAngle);
  429.     if (colon == P_MAX_INDEX)
  430.       colon = leftAngle;
  431.     finishQuote = startQuote = colon+1;
  432.   }
  433.   else {
  434.     finishQuote = args.Find('"', startQuote+1);
  435.     if (finishQuote == P_MAX_INDEX)
  436.       finishQuote = startQuote;
  437.     colon = args.Find(':', leftAngle);
  438.     if (colon > startQuote)
  439.       colon = leftAngle;
  440.   }
  442.   PINDEX rightAngle = args.Find('>', finishQuote);
  443.   if (rightAngle == P_MAX_INDEX)
  444.     return 0;
  446.   PINDEX at = args.Find('@', finishQuote);
  447.   if (at > rightAngle)
  448.     at = rightAngle;
  450.   if (startQuote == finishQuote)
  451.     finishQuote = at;
  453.   name = args(startQuote, finishQuote-1);
  454.   domain = args(at+1, rightAngle-1);
  455.   forwardList = args(leftAngle+1, colon-1);
  457.   return rightAngle+1;
  458. }
  461. void PSMTPServer::OnRCPT(const PCaselessString & recipient)
  462. {
  463.   PCaselessString toName;
  464.   PCaselessString toDomain;
  465.   PCaselessString forwardList;
  466.   if (ParseMailPath(recipient, "to", toName, toDomain, forwardList) == 0)
  467.     WriteResponse(501, "Syntax error.");
  468.   else {
  469.     switch (ForwardDomain(toDomain, forwardList)) {
  470.       case CannotForward :
  471.         WriteResponse(550, "Cannot do forwarding.");
  472.         break;
  474.       case WillForward :
  475.         if (!forwardList)
  476.           forwardList += ":";
  477.         forwardList += toName;
  478.         if (!toDomain)
  479.           forwardList += "@" + toDomain;
  480.         toNames.AppendString(toName);
  481.         toDomains.AppendString(forwardList);
  482.         break;
  484.       case LocalDomain :
  485.       {
  486.         PString expandedName;
  487.         switch (LookUpName(toName, expandedName)) {
  488.           case ValidUser :
  489.             WriteResponse(250, "Recipient " + toName + " Ok");
  490.             toNames.AppendString(toName);
  491.             toDomains.AppendString("");
  492.             break;
  494.           case AmbiguousUser :
  495.             WriteResponse(553, "User ambiguous.");
  496.             break;
  498.           case UnknownUser :
  499.             WriteResponse(550, "User unknown.");
  500.             break;
  502.           default :
  503.             WriteResponse(550, "Error verifying user.");
  504.         }
  505.       }
  506.     }
  507.   }
  508. }
  511. void PSMTPServer::OnMAIL(const PCaselessString & sender)
  512. {
  513.   sendCommand = WasMAIL;
  514.   OnSendMail(sender);
  515. }
  518. void PSMTPServer::OnSEND(const PCaselessString & sender)
  519. {
  520.   sendCommand = WasSEND;
  521.   OnSendMail(sender);
  522. }
  525. void PSMTPServer::OnSAML(const PCaselessString & sender)
  526. {
  527.   sendCommand = WasSAML;
  528.   OnSendMail(sender);
  529. }
  532. void PSMTPServer::OnSOML(const PCaselessString & sender)
  533. {
  534.   sendCommand = WasSOML;
  535.   OnSendMail(sender);
  536. }
  539. void PSMTPServer::OnSendMail(const PCaselessString & sender)
  540. {
  541.   if (!fromAddress) {
  542.     WriteResponse(503, "Sender already specified.");
  543.     return;
  544.   }
  546.   PString fromDomain;
  547.   PINDEX extendedArgPos = ParseMailPath(sender, "from", fromAddress, fromDomain, fromPath);
  548.   if (extendedArgPos == 0 || fromAddress.IsEmpty()) {
  549.     WriteResponse(501, "Syntax error.");
  550.     return;
  551.   }
  552.   fromAddress += fromDomain;
  554.   if (extendedHello) {
  555.     PINDEX equalPos = sender.Find('=', extendedArgPos);
  556.     PCaselessString body = sender(extendedArgPos, equalPos).Trim();
  557.     PCaselessString mime = sender.Mid(equalPos+1).Trim();
  558.     eightBitMIME = (body == "BODY" && mime == "8BITMIME");
  559.   }
  561.   PString response = "Sender " + fromAddress;
  562.   if (eightBitMIME)
  563.     response += " and 8BITMIME";
  564.   WriteResponse(250, response + " Ok");
  565. }
  568. void PSMTPServer::OnDATA()
  569. {
  570.   if (fromAddress.IsEmpty()) {
  571.     WriteResponse(503, "Need a valid MAIL command.");
  572.     return;
  573.   }
  575.   if (toNames.GetSize() == 0) {
  576.     WriteResponse(503, "Need a valid RCPT command.");
  577.     return;
  578.   }
  580.   // Ok, everything is ready to start the message.
  581.   if (!WriteResponse(354,
  582.         eightBitMIME ? "Enter 8BITMIME message, terminate with '<CR><LF>.<CR><LF>'."
  583.                      : "Enter mail, terminate with '.' alone on a line."))
  584.     return;
  586.   endMIMEDetectState = eightBitMIME ? StuffIdle : DontStuff;
  588.   BOOL ok = TRUE;
  589.   BOOL completed = FALSE;
  590.   BOOL starting = TRUE;
  592.   while (ok && !completed) {
  593.     PCharArray buffer;
  594.     if (eightBitMIME)
  595.       ok = OnMIMEData(buffer, completed);
  596.     else
  597.       ok = OnTextData(buffer, completed);
  598.     if (ok) {
  599.       ok = HandleMessage(buffer, starting, completed);
  600.       starting = FALSE;
  601.     }
  602.   }
  604.   if (ok)
  605.     WriteResponse(250, "Message received Ok.");
  606.   else
  607.     WriteResponse(554, "Message storage failed.");
  608. }
  611. BOOL PSMTPServer::OnUnknown(const PCaselessString & command)
  612. {
  613.   WriteResponse(500, "Command "" + command + "" unrecognised.");
  614.   return TRUE;
  615. }
  618. BOOL PSMTPServer::OnTextData(PCharArray & buffer, BOOL & completed)
  619. {
  620.   PString line;
  621.   while (ReadLine(line)) {
  622.     PINDEX len = line.GetLength();
  623.     if (len == 1 && line[0] == '.') {
  624.       completed = TRUE;
  625.       return TRUE;
  626.     }
  628.     PINDEX start = (len > 1 && line[0] == '.' && line[1] == '.') ? 1 : 0;
  629.     PINDEX size = buffer.GetSize();
  630.     len -= start;
  631.     memcpy(buffer.GetPointer(size + len + 2) + size,
  632.            ((const char *)line)+start, len);
  633.     size += len;
  634.     buffer[size++] = 'r';
  635.     buffer[size++] = 'n';
  636.     if (size > messageBufferSize)
  637.       return TRUE;
  638.   }
  639.   return FALSE;
  640. }
  643. BOOL PSMTPServer::OnMIMEData(PCharArray & buffer, BOOL & completed)
  644. {
  645.   PINDEX count = 0;
  646.   int c;
  647.   while ((c = ReadChar()) >= 0) {
  648.     if (count >= buffer.GetSize())
  649.       buffer.SetSize(count + 100);
  650.     switch (endMIMEDetectState) {
  651.       case StuffIdle :
  652.         buffer[count++] = (char)c;
  653.         break;
  655.       case StuffCR :
  656.         endMIMEDetectState = c != 'n' ? StuffIdle : StuffCRLF;
  657.         buffer[count++] = (char)c;
  658.         break;
  660.       case StuffCRLF :
  661.         if (c == '.')
  662.           endMIMEDetectState = StuffCRLFdot;
  663.         else {
  664.           endMIMEDetectState = StuffIdle;
  665.           buffer[count++] = (char)c;
  666.         }
  667.         break;
  669.       case StuffCRLFdot :
  670.         switch (c) {
  671.           case 'r' :
  672.             endMIMEDetectState = StuffCRLFdotCR;
  673.             break;
  675.           case '.' :
  676.             endMIMEDetectState = StuffIdle;
  677.             buffer[count++] = (char)c;
  678.             break;
  680.           default :
  681.             endMIMEDetectState = StuffIdle;
  682.             buffer[count++] = '.';
  683.             buffer[count++] = (char)c;
  684.         }
  685.         break;
  687.       case StuffCRLFdotCR :
  688.         if (c == 'n') {
  689.           completed = TRUE;
  690.           return TRUE;
  691.         }
  692.         buffer[count++] = '.';
  693.         buffer[count++] = 'r';
  694.         buffer[count++] = (char)c;
  695.         endMIMEDetectState = StuffIdle;
  697.       default :
  698.         PAssertAlways("Illegal SMTP state");
  699.     }
  700.     if (count > messageBufferSize) {
  701.       buffer.SetSize(messageBufferSize);
  702.       return TRUE;
  703.     }
  704.   }
  706.   return FALSE;
  707. }
  710. PSMTPServer::ForwardResult PSMTPServer::ForwardDomain(PCaselessString & userDomain,
  711.                                                       PCaselessString & forwardDomainList)
  712. {
  713.   return userDomain.IsEmpty() && forwardDomainList.IsEmpty() ? LocalDomain : CannotForward;
  714. }
  717. PSMTPServer::LookUpResult PSMTPServer::LookUpName(const PCaselessString &,
  718.                                                   PString & expandedName)
  719. {
  720.   expandedName = PString();
  721.   return LookUpError;
  722. }
  725. BOOL PSMTPServer::HandleMessage(PCharArray &, BOOL, BOOL)
  726. {
  727.   return FALSE;
  728. }
  731. //////////////////////////////////////////////////////////////////////////////
  732. // PPOP3
  734. static char const * const POP3Commands[PPOP3::NumCommands] = {
  735.   "USER", "PASS", "QUIT", "RSET", "NOOP", "STAT",
  736.   "LIST", "RETR", "DELE", "APOP", "TOP",  "UIDL"
  737. };
  740. PString PPOP3::okResponse = "+OK";
  741. PString PPOP3::errResponse = "-ERR";
  744. PPOP3::PPOP3()
  745.   : PInternetProtocol("pop3 110", NumCommands, POP3Commands)
  746. {
  747. }
  750. PINDEX PPOP3::ParseResponse(const PString & line)
  751. {
  752.   lastResponseCode = line[0] == '+';
  753.   PINDEX endCode = line.Find(' ');
  754.   if (endCode != P_MAX_INDEX)
  755.     lastResponseInfo = line.Mid(endCode+1);
  756.   else
  757.     lastResponseInfo = PString();
  758.   return 0;
  759. }
  762. //////////////////////////////////////////////////////////////////////////////
  763. // PPOP3Client
  765. PPOP3Client::PPOP3Client()
  766. {
  767.   loggedIn = FALSE;
  768. }
  771. PPOP3Client::~PPOP3Client()
  772. {
  773.   Close();
  774. }
  776. BOOL PPOP3Client::OnOpen()
  777. {
  778.   return ReadResponse() && lastResponseCode > 0;
  779. }
  782. BOOL PPOP3Client::Close()
  783. {
  784.   BOOL ok = TRUE;
  785.   if (IsOpen() && loggedIn) {
  786.     SetReadTimeout(60000);
  787.     ok = ExecuteCommand(QUIT, "") > 0;
  788.   }
  789.   return PInternetProtocol::Close() && ok;
  790. }
  793. BOOL PPOP3Client::LogIn(const PString & username, const PString & password)
  794. {
  795.   if (ExecuteCommand(USER, username) <= 0)
  796.     return FALSE;
  798.   if (ExecuteCommand(PASS, password) <= 0)
  799.     return FALSE;
  801.   loggedIn = TRUE;
  802.   return TRUE;
  803. }
  806. int PPOP3Client::GetMessageCount()
  807. {
  808.   if (ExecuteCommand(STATcmd, "") <= 0)
  809.     return -1;
  811.   return (int)lastResponseInfo.AsInteger();
  812. }
  815. PUnsignedArray PPOP3Client::GetMessageSizes()
  816. {
  817.   PUnsignedArray sizes;
  819.   if (ExecuteCommand(LIST, "") > 0) {
  820.     PString msgInfo;
  821.     while (ReadLine(msgInfo))
  822.       sizes.SetAt((PINDEX)msgInfo.AsInteger()-1,
  823.                   (unsigned)msgInfo.Mid(msgInfo.Find(' ')).AsInteger());
  824.   }
  826.   return sizes;
  827. }
  830. PStringArray PPOP3Client::GetMessageHeaders()
  831. {
  832.   PStringArray headers;
  834.   int count = GetMessageCount();
  835.   for (int msgNum = 1; msgNum <= count; msgNum++) {
  836.     if (ExecuteCommand(TOP, PString(PString::Unsigned,msgNum) + " 0") > 0) {
  837.       PString headerLine;
  838.       while (ReadLine(headerLine, TRUE))
  839.         headers[msgNum-1] += headerLine;
  840.     }
  841.   }
  842.   return headers;
  843. }
  846. BOOL PPOP3Client::BeginMessage(PINDEX messageNumber)
  847. {
  848.   return ExecuteCommand(RETR, PString(PString::Unsigned, messageNumber)) > 0;
  849. }
  852. BOOL PPOP3Client::DeleteMessage(PINDEX messageNumber)
  853. {
  854.   return ExecuteCommand(DELE, PString(PString::Unsigned, messageNumber)) > 0;
  855. }
  858. //////////////////////////////////////////////////////////////////////////////
  859. // PPOP3Server
  861. PPOP3Server::PPOP3Server()
  862. {
  863. }
  866. BOOL PPOP3Server::OnOpen()
  867. {
  868.   return WriteResponse(okResponse, PIPSocket::GetHostName() +
  869.                      " POP3 server ready at " +
  870.                       PTime(PTime::MediumDateTime).AsString());
  871. }
  874. BOOL PPOP3Server::ProcessCommand()
  875. {
  876.   PString args;
  877.   PINDEX num;
  878.   if (!ReadCommand(num, args))
  879.     return FALSE;
  881.   switch (num) {
  882.     case USER :
  883.       OnUSER(args);
  884.       break;
  885.     case PASS :
  886.       OnPASS(args);
  887.       break;
  888.     case QUIT :
  889.       OnQUIT();
  890.       return FALSE;
  891.     case RSET :
  892.       OnRSET();
  893.       break;
  894.     case NOOP :
  895.       OnNOOP();
  896.       break;
  897.     case STATcmd :
  898.       OnSTAT();
  899.       break;
  900.     case LIST :
  901.       OnLIST((PINDEX)args.AsInteger());
  902.       break;
  903.     case RETR :
  904.       OnRETR((PINDEX)args.AsInteger());
  905.       break;
  906.     case DELE :
  907.       OnDELE((PINDEX)args.AsInteger());
  908.       break;
  909.     case TOP :
  910.       if (args.Find(' ') == P_MAX_INDEX)
  911.         WriteResponse(errResponse, "Syntax error");
  912.       else
  913.         OnTOP((PINDEX)args.AsInteger(),
  914.               (PINDEX)args.Mid(args.Find(' ')).AsInteger());
  915.       break;
  916.     case UIDL :
  917.       OnUIDL((PINDEX)args.AsInteger());
  918.       break;
  919.     default :
  920.       return OnUnknown(args);
  921.   }
  923.   return TRUE;
  924. }
  927. void PPOP3Server::OnUSER(const PString & name)
  928. {
  929.   messageSizes.SetSize(0);
  930.   messageIDs.SetSize(0);
  931.   username = name;
  932.   WriteResponse(okResponse, "User name accepted.");
  933. }
  936. void PPOP3Server::OnPASS(const PString & password)
  937. {
  938.   if (username.IsEmpty())
  939.     WriteResponse(errResponse, "No user name specified.");
  940.   else if (HandleOpenMailbox(username, password))
  941.     WriteResponse(okResponse, username + " mail is available.");
  942.   else
  943.     WriteResponse(errResponse, "No access to " + username + " mail.");
  944.   messageDeletions.SetSize(messageIDs.GetSize());
  945. }
  948. void PPOP3Server::OnQUIT()
  949. {
  950.   for (PINDEX i = 0; i < messageDeletions.GetSize(); i++)
  951.     if (messageDeletions[i])
  952.       HandleDeleteMessage(i+1, messageIDs[i]);
  954.   WriteResponse(okResponse, PIPSocket::GetHostName() +
  955.                      " POP3 server signing off at " +
  956.                       PTime(PTime::MediumDateTime).AsString());
  958.   Close();
  959. }
  962. void PPOP3Server::OnRSET()
  963. {
  964.   for (PINDEX i = 0; i < messageDeletions.GetSize(); i++)
  965.     messageDeletions[i] = FALSE;
  966.   WriteResponse(okResponse, "Resetting state.");
  967. }
  970. void PPOP3Server::OnNOOP()
  971. {
  972.   WriteResponse(okResponse, "Doing nothing.");
  973. }
  976. void PPOP3Server::OnSTAT()
  977. {
  978.   DWORD total = 0;
  979.   for (PINDEX i = 0; i < messageSizes.GetSize(); i++)
  980.     total += messageSizes[i];
  981.   WriteResponse(okResponse, psprintf("%u %u", messageSizes.GetSize(), total));
  982. }
  985. void PPOP3Server::OnLIST(PINDEX msg)
  986. {
  987.   if (msg == 0) {
  988.     WriteResponse(okResponse, psprintf("%u messages.", messageSizes.GetSize()));
  989.     for (PINDEX i = 0; i < messageSizes.GetSize(); i++)
  990.       if (!messageDeletions[i])
  991.         WriteLine(psprintf("%u %u", i+1, messageSizes[i]));
  992.     WriteLine(".");
  993.   }
  994.   else if (msg < 1 || msg > messageSizes.GetSize())
  995.     WriteResponse(errResponse, "No such message.");
  996.   else
  997.     WriteResponse(okResponse, psprintf("%u %u", msg, messageSizes[msg-1]));
  998. }
  1001. void PPOP3Server::OnRETR(PINDEX msg)
  1002. {
  1003.   if (msg < 1 || msg > messageDeletions.GetSize())
  1004.     WriteResponse(errResponse, "No such message.");
  1005.   else {
  1006.     WriteResponse(okResponse,
  1007.                  PString(PString::Unsigned, messageSizes[msg-1]) + " octets.");
  1008.     stuffingState = StuffIdle;
  1009.     HandleSendMessage(msg, messageIDs[msg-1], P_MAX_INDEX);
  1010.     stuffingState = DontStuff;
  1011.     WriteString(CRLFdotCRLF);
  1012.   }
  1013. }
  1016. void PPOP3Server::OnDELE(PINDEX msg)
  1017. {
  1018.   if (msg < 1 || msg > messageDeletions.GetSize())
  1019.     WriteResponse(errResponse, "No such message.");
  1020.   else {
  1021.     messageDeletions[msg-1] = TRUE;
  1022.     WriteResponse(okResponse, "Message marked for deletion.");
  1023.   }
  1024. }
  1027. void PPOP3Server::OnTOP(PINDEX msg, PINDEX count)
  1028. {
  1029.   if (msg < 1 || msg > messageDeletions.GetSize())
  1030.     WriteResponse(errResponse, "No such message.");
  1031.   else {
  1032.     WriteResponse(okResponse, "Top of message");
  1033.     stuffingState = StuffIdle;
  1034.     HandleSendMessage(msg, messageIDs[msg-1], count);
  1035.     stuffingState = DontStuff;
  1036.     WriteString(CRLFdotCRLF);
  1037.   }
  1038. }
  1041. void PPOP3Server::OnUIDL(PINDEX msg)
  1042. {
  1043.   if (msg == 0) {
  1044.     WriteResponse(okResponse,
  1045.               PString(PString::Unsigned, messageIDs.GetSize()) + " messages.");
  1046.     for (PINDEX i = 0; i < messageIDs.GetSize(); i++)
  1047.       if (!messageDeletions[i])
  1048.         WriteLine(PString(PString::Unsigned, i+1) & messageIDs[i]);
  1049.     WriteLine(".");
  1050.   }
  1051.   else if (msg < 1 || msg > messageSizes.GetSize())
  1052.     WriteResponse(errResponse, "No such message.");
  1053.   else
  1054.     WriteLine(PString(PString::Unsigned, msg) & messageIDs[msg-1]);
  1055. }
  1058. BOOL PPOP3Server::OnUnknown(const PCaselessString & command)
  1059. {
  1060.   WriteResponse(errResponse, "Command "" + command + "" unrecognised.");
  1061.   return TRUE;
  1062. }
  1065. BOOL PPOP3Server::HandleOpenMailbox(const PString &, const PString &)
  1066. {
  1067.   return FALSE;
  1068. }
  1071. void PPOP3Server::HandleSendMessage(PINDEX, const PString &, PINDEX)
  1072. {
  1073. }
  1076. void PPOP3Server::HandleDeleteMessage(PINDEX, const PString &)
  1077. {
  1078. }
  1081. // End Of File ///////////////////////////////////////////////////////////////