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

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

IP电话/视频会议

开发平台：

Visual C++

inetprot.cxx：源码内容
  1. /*
  2.  * inetprot.cxx
  3.  *
  4.  * Internet Protocol ancestor class.
  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: inetprot.cxx,v $
  30.  * Revision 1.45  2000/05/05 10:08:29  robertj
  31.  * Fixed some GNU compiler warnings
  32.  *
  33.  * Revision 1.44  2000/05/02 08:29:07  craigs
  34.  * Removed "memory leaks" caused by brain-dead GNU linker
  35.  *
  36.  * Revision 1.43  1999/05/04 15:26:01  robertj
  37.  * Improved HTTP/1.1 compatibility (pass through user commands).
  38.  * Fixed problems with quicktime installer.
  39.  *
  40.  * Revision 1.42  1998/12/04 10:08:01  robertj
  41.  * Fixed bug in PMIMInfo read functions, should clear entries before loading.
  42.  *
  43.  * Revision 1.41  1998/11/30 04:52:02  robertj
  44.  * New directory structure
  45.  *
  46.  * Revision 1.40  1998/11/03 01:03:09  robertj
  47.  * Fixed problem with multiline response that is non-numeric.
  48.  *
  49.  * Revision 1.39  1998/10/16 02:05:55  robertj
  50.  * Tried to make ReadLine more forgiving of CR CR LF combination.
  51.  *
  52.  * Revision 1.38  1998/09/23 06:22:20  robertj
  53.  * Added open source copyright license.
  54.  *
  55.  * Revision 1.37  1998/07/24 06:55:00  robertj
  56.  * Improved robustness of base64 decoding.
  57.  *
  58.  * Revision 1.36  1998/02/03 06:20:25  robertj
  59.  * Fixed bug in Accept() function passing on to IP Accept().
  60.  *
  61.  * Revision 1.35  1998/01/26 02:49:20  robertj
  62.  * GNU support.
  63.  *
  64.  * Revision 1.34  1998/01/26 00:46:48  robertj
  65.  * Fixed Connect functions on PInternetProtocol so propagates read timeout variable so can adjust the connect timeout..
  66.  *
  67.  * Revision 1.33  1997/11/06 10:26:48  robertj
  68.  * Fixed bug in debug dump of MIME dictionary, did not have linefeeds between entries.
  69.  *
  70.  * Revision 1.32  1997/06/09 04:30:03  robertj
  71.  * Fixed multiple MIME field bug.
  72.  *
  73.  * Revision 1.31  1997/06/06 08:53:51  robertj
  74.  * Fixed bug with multiple cookies (MIME fields) are sent to IE.
  75.  *
  76.  * Revision 1.30  1997/03/28 13:04:37  robertj
  77.  * Fixed bug for multiple fields in MIME headers, especially cookies.
  78.  *
  79.  * Revision 1.29  1997/03/18 21:26:46  robertj
  80.  * Fixed stream write of MIME putting double CR's in text files..
  81.  *
  82.  * Revision 1.28  1997/02/05 11:53:13  robertj
  83.  * Changed construction of MIME dictionary to be delayed untill it is used.
  84.  *
  85.  * Revision 1.27  1996/12/05 11:41:12  craigs
  86.  * Fix problem with STAT command response containing lines not starting
  87.  * with response number
  88.  *
  89.  * Revision 1.26  1996/10/08 13:07:39  robertj
  90.  * Changed default for assert to be ignore, not abort.
  91.  *
  92.  * Revision 1.25  1996/09/16 12:57:07  robertj
  93.  * Fixed missing propagationof errors on open of subchannel.
  94.  *
  95.  * Revision 1.24  1996/09/14 13:09:36  robertj
  96.  * Major upgrade:
  97.  *   rearranged sockets to help support IPX.
  98.  *   added indirect channel class and moved all protocols to descend from it,
  99.  *   separating the protocol from the low level byte transport.
  100.  *
  101.  * Revision 1.23  1996/08/25 09:35:47  robertj
  102.  * Added bug in appsock that last response is set on an I/O error.
  103.  *
  104.  * Revision 1.22  1996/07/15 10:33:14  robertj
  105.  * Changed memory block base64 conversion functions to be void *.
  106.  *
  107.  * Revision 1.21  1996/06/03 11:58:43  robertj
  108.  * Fixed bug in reading successive UnRead() calls getting save in wrong order.
  109.  *
  110.  * Revision 1.20  1996/05/26 03:46:22  robertj
  111.  * Compatibility to GNU 2.7.x
  112.  *
  113.  * Revision 1.19  1996/05/15 10:15:15  robertj
  114.  * Added access function to set intercharacter line read timeout.
  115.  *
  116.  * Revision 1.18  1996/05/09 12:14:04  robertj
  117.  * Rewrote the "unread" buffer usage and then used it to improve ReadLine() performance.
  118.  *
  119.  * Revision 1.17  1996/03/31 08:57:34  robertj
  120.  * Changed MIME type for no extension from binary to text.
  121.  * Added flush of data before sending a command.
  122.  * Added version of WriteCommand() and ExecteCommand() without argument string.
  123.  *
  124.  * Revision 1.15  1996/03/18 13:33:13  robertj
  125.  * Fixed incompatibilities to GNU compiler where PINDEX != int.
  126.  *
  127.  * Revision 1.14  1996/03/16 04:53:07  robertj
  128.  * Changed all the get host name and get host address functions to be more consistent.
  129.  * Added ParseReponse() for splitting reponse line into code and info.
  130.  * Changed lastResponseCode to an integer.
  131.  * Fixed bug in MIME write function, should be const.
  132.  * Added PString parameter version of UnRead().
  133.  *
  134.  * Revision 1.13  1996/03/04 12:20:41  robertj
  135.  * Split file into mailsock.cxx
  136.  *
  137.  * Revision 1.12  1996/02/25 11:16:07  robertj
  138.  * Fixed bug in ReadResponse() for multi-line responses under FTP..
  139.  *
  140.  * Revision 1.11  1996/02/25 03:05:12  robertj
  141.  * Added decoding of Base64 to a block of memory instead of PBYTEArray.
  142.  *
  143.  * Revision 1.10  1996/02/19 13:31:26  robertj
  144.  * Changed stuff to use new & operator..
  145.  *
  146.  * Revision 1.9  1996/02/15 14:42:41  robertj
  147.  * Fixed warning for long to int conversion.
  148.  *
  149.  * Revision 1.8  1996/02/13 12:57:49  robertj
  150.  * Added access to the last response in an application socket.
  151.  *
  152.  * Revision 1.7  1996/02/03 11:33:17  robertj
  153.  * Changed RadCmd() so can distinguish between I/O error and unknown command.
  154.  *
  155.  * Revision 1.6  1996/01/28 14:11:11  robertj
  156.  * Fixed bug in MIME content types for non caseless strings.
  157.  * Added default value in string for service name.
  158.  *
  159.  * Revision 1.5  1996/01/28 02:48:27  robertj
  160.  * Removal of MemoryPointer classes as usage didn't work for GNU.
  161.  *
  162.  * Revision 1.4  1996/01/26 02:24:29  robertj
  163.  * Further implemetation.
  164.  *
  165.  * Revision 1.3  1996/01/23 13:18:43  robertj
  166.  * Major rewrite for HTTP support.
  167.  *
  168.  * Revision 1.2  1995/11/09 12:19:29  robertj
  169.  * Fixed missing state assertion in state machine.
  170.  *
  171.  * Revision 1.1  1995/06/17 00:50:37  robertj
  172.  * Initial revision
  173.  *
  174.  */
  176. #ifdef __GNUC__
  177. #pragma implementation "inetprot.h"
  178. #pragma implementation "mime.h"
  179. #endif
  181. #include <ptlib.h>
  182. #include <ptlib/sockets.h>
  183. #include <ptclib/inetprot.h>
  184. #include <ptclib/mime.h>
  187. static const char * CRLF = "rn";
  190. //////////////////////////////////////////////////////////////////////////////
  191. // PInternetProtocol
  193. PInternetProtocol::PInternetProtocol(const char * svcName,
  194.                                      PINDEX cmdCount,
  195.                                      char const * const * cmdNames)
  196.   : defaultServiceName(svcName),
  197.     commandNames(cmdCount, cmdNames, TRUE),
  198.     readLineTimeout(0, 10)   // 10 seconds
  199. {
  200.   SetReadTimeout(PTimeInterval(0, 0, 10));  // 10 minutes
  201.   stuffingState = DontStuff;
  202.   newLineToCRLF = TRUE;
  203.   unReadCount = 0;
  204. }
  207. void PInternetProtocol::SetReadLineTimeout(const PTimeInterval & t)
  208. {
  209.   readLineTimeout = t;
  210. }
  213. BOOL PInternetProtocol::Read(void * buf, PINDEX len)
  214. {
  215.   lastReadCount = PMIN(unReadCount, len);
  216.   const char * unReadPtr = ((const char *)unReadBuffer)+unReadCount;
  217.   char * bufptr = (char *)buf;
  218.   while (unReadCount > 0 && len > 0) {
  219.     *bufptr++ = *--unReadPtr;
  220.     unReadCount--;
  221.     len--;
  222.   }
  224.   if (unReadCount == 0)
  225.     unReadBuffer.SetSize(0);
  227.   if (len > 0) {
  228.     PINDEX saveCount = lastReadCount;
  229.     PIndirectChannel::Read(bufptr, len);
  230.     lastReadCount += saveCount;
  231.   }
  233.   return lastReadCount > 0;
  234. }
  237. BOOL PInternetProtocol::Write(const void * buf, PINDEX len)
  238. {
  239.   if (len == 0 || stuffingState == DontStuff)
  240.     return PIndirectChannel::Write(buf, len);
  242.   PINDEX totalWritten = 0;
  243.   const char * base = (const char *)buf;
  244.   const char * current = base;
  245.   while (len-- > 0) {
  246.     switch (stuffingState) {
  247.       case StuffIdle :
  248.         switch (*current) {
  249.           case 'r' :
  250.             stuffingState = StuffCR;
  251.             break;
  253.           case 'n' :
  254.             if (newLineToCRLF) {
  255.               if (current > base) {
  256.                 if (!PIndirectChannel::Write(base, current - base))
  257.                   return FALSE;
  258.                 totalWritten += lastWriteCount;
  259.               }
  260.               if (!PIndirectChannel::Write("r", 1))
  261.                 return FALSE;
  262.               totalWritten += lastWriteCount;
  263.               base = current;
  264.             }
  265.         }
  266.         break;
  268.       case StuffCR :
  269.         stuffingState = *current != 'n' ? StuffIdle : StuffCRLF;
  270.         break;
  272.       case StuffCRLF :
  273.         if (*current == '.') {
  274.           if (current > base) {
  275.             if (!PIndirectChannel::Write(base, current - base))
  276.               return FALSE;
  277.             totalWritten += lastWriteCount;
  278.           }
  279.           if (!PIndirectChannel::Write(".", 1))
  280.             return FALSE;
  281.           totalWritten += lastWriteCount;
  282.           base = current;
  283.         }
  284.         // Then do default state
  286.       default :
  287.         stuffingState = StuffIdle;
  288.         break;
  289.     }
  290.     current++;
  291.   }
  293.   if (current > base)
  294.     if (!PIndirectChannel::Write(base, current - base))
  295.       return FALSE;
  297.   lastWriteCount += totalWritten;
  298.   return lastWriteCount > 0;
  299. }
  302. BOOL PInternetProtocol::AttachSocket(PIPSocket * socket)
  303. {
  304.   if (socket->IsOpen()) {
  305.     if (Open(socket))
  306.       return TRUE;
  307.     Close();
  308.     lastError = Miscellaneous;
  309.     osError = 0x41000000;
  310.   }
  311.   else {
  312.     lastError = socket->GetErrorCode();
  313.     osError = socket->GetErrorNumber();
  314.     delete socket;
  315.   }
  317.   return FALSE;
  318. }
  321. BOOL PInternetProtocol::Connect(const PString & address, WORD port)
  322. {
  323.   if (port == 0)
  324.     return Connect(address, defaultServiceName);
  326.   if (readTimeout == PMaxTimeInterval)
  327.     return AttachSocket(new PTCPSocket(address, port));
  329.   PTCPSocket * s = new PTCPSocket(port);
  330.   s->SetReadTimeout(readTimeout);
  331.   s->Connect(address);
  332.   return AttachSocket(s);
  333. }
  336. BOOL PInternetProtocol::Connect(const PString & address, const PString & service)
  337. {
  338.   if (readTimeout == PMaxTimeInterval)
  339.     return AttachSocket(new PTCPSocket(address, service));
  341.   PTCPSocket * s = new PTCPSocket;
  342.   s->SetReadTimeout(readTimeout);
  343.   s->SetPort(service);
  344.   s->Connect(address);
  345.   return AttachSocket(s);
  346. }
  349. BOOL PInternetProtocol::Accept(PSocket & listener)
  350. {
  351.   if (readTimeout == PMaxTimeInterval)
  352.     return AttachSocket(new PTCPSocket(listener));
  354.   PTCPSocket * s = new PTCPSocket;
  355.   s->SetReadTimeout(readTimeout);
  356.   s->Accept(listener);
  357.   return AttachSocket(s);
  358. }
  361. const PString & PInternetProtocol::GetDefaultService() const
  362. {
  363.   return defaultServiceName;
  364. }
  367. PIPSocket * PInternetProtocol::GetSocket() const
  368. {
  369.   PChannel * channel = GetBaseReadChannel();
  370.   if (channel != NULL && channel->IsDescendant(PIPSocket::Class()))
  371.     return (PIPSocket *)channel;
  372.   return NULL;
  373. }
  376. BOOL PInternetProtocol::WriteLine(const PString & line)
  377. {
  378.   if (line.FindOneOf(CRLF) == P_MAX_INDEX)
  379.     return WriteString(line + CRLF);
  381.   PStringArray lines = line.Lines();
  382.   for (PINDEX i = 0; i < lines.GetSize(); i++)
  383.     if (!WriteString(lines[i] + CRLF))
  384.       return FALSE;
  386.   return TRUE;
  387. }
  390. BOOL PInternetProtocol::ReadLine(PString & str, BOOL allowContinuation)
  391. {
  392.   str = PString();
  394.   PCharArray line(100);
  395.   PINDEX count = 0;
  396.   BOOL gotEndOfLine = FALSE;
  398.   int c = ReadChar();
  399.   if (c < 0)
  400.     return FALSE;
  402.   PTimeInterval oldTimeout = GetReadTimeout();
  403.   SetReadTimeout(readLineTimeout);
  405.   while (c >= 0 && !gotEndOfLine) {
  406.     if (unReadCount == 0) {
  407.       char readAhead[1000];
  408.       SetReadTimeout(0);
  409.       if (PIndirectChannel::Read(readAhead, sizeof(readAhead)))
  410.         UnRead(readAhead, GetLastReadCount());
  411.       SetReadTimeout(readLineTimeout);
  412.     }
  413.     switch (c) {
  414.       case 'b' :
  415.       case '177' :
  416.         if (count > 0)
  417.           count--;
  418.         c = ReadChar();
  419.         break;
  421.       case 'r' :
  422.         c = ReadChar();
  423.         switch (c) {
  424.           case -1 :
  425.           case 'n' :
  426.             break;
  428.           case 'r' :
  429.             c = ReadChar();
  430.             if (c == 'n')
  431.               break;
  432.             UnRead(c);
  433.             c = 'r';
  434.             // Then do default case
  436.           default :
  437.             UnRead(c);
  438.         }
  439.         // Then do line feed case
  441.       case 'n' :
  442.         if (count == 0 || !allowContinuation || (c = ReadChar()) < 0)
  443.           gotEndOfLine = TRUE;
  444.         else if (c != ' ' && c != 't') {
  445.           UnRead(c);
  446.           gotEndOfLine = TRUE;
  447.         }
  448.         break;
  450.       default :
  451.         if (count >= line.GetSize())
  452.           line.SetSize(count + 100);
  453.         line[count++] = (char)c;
  454.         c = ReadChar();
  455.     }
  456.   }
  458.   SetReadTimeout(oldTimeout);
  460.   if (count > 0)
  461.     str = PString(line, count);
  462.   return gotEndOfLine;
  463. }
  466. void PInternetProtocol::UnRead(int ch)
  467. {
  468.   unReadBuffer.SetSize((unReadCount+256)&~255);
  469.   unReadBuffer[unReadCount++] = (char)ch;
  470. }
  473. void PInternetProtocol::UnRead(const PString & str)
  474. {
  475.   UnRead((const char *)str, str.GetLength());
  476. }
  479. void PInternetProtocol::UnRead(const void * buffer, PINDEX len)
  480. {
  481.   char * unreadptr =
  482.                unReadBuffer.GetPointer((unReadCount+len+255)&~255)+unReadCount;
  483.   const char * bufptr = ((const char *)buffer)+len;
  484.   unReadCount += len;
  485.   while (len-- > 0)
  486.     *unreadptr++ = *--bufptr;
  487. }
  490. BOOL PInternetProtocol::WriteCommand(PINDEX cmdNumber)
  491. {
  492.   if (cmdNumber >= commandNames.GetSize())
  493.     return FALSE;
  494.   return WriteLine(commandNames[cmdNumber]);
  495. }
  498. BOOL PInternetProtocol::WriteCommand(PINDEX cmdNumber, const PString & param)
  499. {
  500.   if (cmdNumber >= commandNames.GetSize())
  501.     return FALSE;
  502.   if (param.IsEmpty())
  503.     return WriteLine(commandNames[cmdNumber]);
  504.   else
  505.     return WriteLine(commandNames[cmdNumber] & param);
  506. }
  509. BOOL PInternetProtocol::ReadCommand(PINDEX & num, PString & args)
  510. {
  511.   do {
  512.     if (!ReadLine(args))
  513.       return FALSE;
  514.   } while (args.IsEmpty());
  516.   PINDEX endCommand = args.Find(' ');
  517.   if (endCommand == P_MAX_INDEX)
  518.     endCommand = args.GetLength();
  519.   PCaselessString cmd = args.Left(endCommand);
  521.   num = commandNames.GetValuesIndex(cmd);
  522.   if (num != P_MAX_INDEX)
  523.     args = args.Mid(endCommand+1);
  525.   return TRUE;
  526. }
  529. BOOL PInternetProtocol::WriteResponse(unsigned code, const PString & info)
  530. {
  531.   return WriteResponse(psprintf("%03u", code), info);
  532. }
  535. BOOL PInternetProtocol::WriteResponse(const PString & code,
  536.                                        const PString & info)
  537. {
  538.   if (info.FindOneOf(CRLF) == P_MAX_INDEX)
  539.     return WriteString(code & info + CRLF);
  541.   PStringArray lines = info.Lines();
  542.   PINDEX i;
  543.   for (i = 0; i < lines.GetSize()-1; i++)
  544.     if (!WriteString(code + '-' + lines[i] + CRLF))
  545.       return FALSE;
  547.   return WriteString(code & lines[i] + CRLF);
  548. }
  551. BOOL PInternetProtocol::ReadResponse()
  552. {
  553.   PString line;
  554.   if (!ReadLine(line)) {
  555.     lastResponseCode = -1;
  556.     lastResponseInfo = GetErrorText();
  557.     return FALSE;
  558.   }
  560.   PINDEX continuePos = ParseResponse(line);
  561.   if (continuePos == 0)
  562.     return TRUE;
  564.   PString prefix = line.Left(continuePos);
  565.   char continueChar = line[continuePos];
  566.   while (line[continuePos] == continueChar ||
  567.          (!isdigit(line[0]) && strncmp(line, prefix, continuePos) != 0)) {
  568.     lastResponseInfo += 'n';
  569.     if (!ReadLine(line)) {
  570.       lastResponseInfo += GetErrorText();
  571.       return FALSE;
  572.     }
  573.     if (line.Left(continuePos) == prefix)
  574.       lastResponseInfo += line.Mid(continuePos+1);
  575.     else
  576.       lastResponseInfo += line;
  577.   }
  579.   return TRUE;
  580. }
  583. BOOL PInternetProtocol::ReadResponse(int & code, PString & info)
  584. {
  585.   BOOL retval = ReadResponse();
  587.   code = lastResponseCode;
  588.   info = lastResponseInfo;
  590.   return retval;
  591. }
  594. PINDEX PInternetProtocol::ParseResponse(const PString & line)
  595. {
  596.   PINDEX endCode = line.FindOneOf(" -");
  597.   if (endCode == P_MAX_INDEX) {
  598.     lastResponseCode = -1;
  599.     lastResponseInfo = line;
  600.     return 0;
  601.   }
  603.   lastResponseCode = line.Left(endCode).AsInteger();
  604.   lastResponseInfo = line.Mid(endCode+1);
  605.   return line[endCode] != ' ' ? endCode : 0;
  606. }
  609. int PInternetProtocol::ExecuteCommand(PINDEX cmd)
  610. {
  611.   return ExecuteCommand(cmd, PString());
  612. }
  615. int PInternetProtocol::ExecuteCommand(PINDEX cmd,
  616.                                        const PString & param)
  617. {
  618.   PTimeInterval oldTimeout = GetReadTimeout();
  619.   SetReadTimeout(0);
  620.   while (ReadChar() >= 0)
  621.     ;
  622.   SetReadTimeout(oldTimeout);
  623.   return WriteCommand(cmd, param) && ReadResponse() ? lastResponseCode : -1;
  624. }
  627. int PInternetProtocol::GetLastResponseCode() const
  628. {
  629.   return lastResponseCode;
  630. }
  633. PString PInternetProtocol::GetLastResponseInfo() const
  634. {
  635.   return lastResponseInfo;
  636. }
  639. //////////////////////////////////////////////////////////////////////////////
  640. // PMIMEInfo
  642. PMIMEInfo::PMIMEInfo(istream & strm)
  643. {
  644.   ReadFrom(strm);
  645. }
  648. PMIMEInfo::PMIMEInfo(PInternetProtocol & socket)
  649. {
  650.   Read(socket);
  651. }
  654. void PMIMEInfo::PrintOn(ostream &strm) const
  655. {
  656.   BOOL output_cr = strm.fill() == 'r';
  657.   strm.fill(' ');
  658.   for (PINDEX i = 0; i < GetSize(); i++) {
  659.     PString name = GetKeyAt(i) + ": ";
  660.     PString value = GetDataAt(i);
  661.     if (value.FindOneOf("rn") != P_MAX_INDEX) {
  662.       PStringArray vals = value.Lines();
  663.       for (PINDEX j = 0; j < vals.GetSize(); j++) {
  664.         strm << name << vals[j];
  665.         if (output_cr)
  666.           strm << 'r';
  667.         strm << 'n';
  668.       }
  669.     }
  670.     else {
  671.       strm << name << value;
  672.       if (output_cr)
  673.         strm << 'r';
  674.       strm << 'n';
  675.     }
  676.   }
  677.   if (output_cr)
  678.     strm << 'r';
  679.   strm << endl;
  680. }
  683. void PMIMEInfo::ReadFrom(istream &strm)
  684. {
  685.   RemoveAll();
  687.   PString line;
  688.   while (strm.good()) {
  689.     strm >> line;
  690.     if (line.IsEmpty())
  691.       break;
  693.     PINDEX colonPos = line.Find(':');
  694.     if (colonPos != P_MAX_INDEX) {
  695.       PCaselessString fieldName  = line.Left(colonPos).Trim();
  696.       PString fieldValue = line(colonPos+1, P_MAX_INDEX).Trim();
  697.       if (Contains(fieldName))
  698.         fieldValue = (*this)[fieldName] + "n" + fieldValue;
  699.       SetAt(fieldName, fieldValue);
  700.     }
  701.   }
  702. }
  705. BOOL PMIMEInfo::Read(PInternetProtocol & socket)
  706. {
  707.   RemoveAll();
  709.   PString line;
  710.   while (socket.ReadLine(line, TRUE)) {
  711.     if (line.IsEmpty())
  712.       return TRUE;
  714.     PINDEX colonPos = line.Find(':');
  715.     if (colonPos != P_MAX_INDEX) {
  716.       PCaselessString fieldName  = line.Left(colonPos).Trim();
  717.       PString fieldValue = line(colonPos+1, P_MAX_INDEX).Trim();
  718.       if (Contains(fieldName))
  719.         fieldValue = (*this)[fieldName] + "n" + fieldValue;
  720.       SetAt(fieldName, fieldValue);
  721.     }
  722.   }
  724.   return FALSE;
  725. }
  728. BOOL PMIMEInfo::Write(PInternetProtocol & socket) const
  729. {
  730.   for (PINDEX i = 0; i < GetSize(); i++) {
  731.     PString name = GetKeyAt(i) + ": ";
  732.     PString value = GetDataAt(i);
  733.     if (value.FindOneOf("rn") != P_MAX_INDEX) {
  734.       PStringArray vals = value.Lines();
  735.       for (PINDEX j = 0; j < vals.GetSize(); j++) {
  736.         if (!socket.WriteLine(name + vals[j]))
  737.           return FALSE;
  738.       }
  739.     }
  740.     else {
  741.       if (!socket.WriteLine(name + value))
  742.         return FALSE;
  743.     }
  744.   }
  746.   return socket.WriteString(CRLF);
  747. }
  750. PString PMIMEInfo::GetString(const PString & key, const PString & dflt) const
  751. {
  752.   if (GetAt(PCaselessString(key)) == NULL)
  753.     return dflt;
  754.   return operator[](key);
  755. }
  758. long PMIMEInfo::GetInteger(const PString & key, long dflt) const
  759. {
  760.   if (GetAt(PCaselessString(key)) == NULL)
  761.     return dflt;
  762.   return operator[](key).AsInteger();
  763. }
  766. static const PStringToString::Initialiser DefaultContentTypes[] = {
  767.   { ".txt", "text/plain" },
  768.   { ".text", "text/plain" },
  769.   { ".html", "text/html" },
  770.   { ".htm", "text/html" },
  771.   { ".aif", "audio/aiff" },
  772.   { ".aiff", "audio/aiff" },
  773.   { ".au", "audio/basic" },
  774.   { ".snd", "audio/basic" },
  775.   { ".wav", "audio/wav" },
  776.   { ".gif", "image/gif" },
  777.   { ".xbm", "image/x-bitmap" },
  778.   { ".tif", "image/tiff" },
  779.   { ".tiff", "image/tiff" },
  780.   { ".jpg", "image/jpeg" },
  781.   { ".jpe", "image/jpeg" },
  782.   { ".jpeg", "image/jpeg" },
  783.   { ".avi", "video/avi" },
  784.   { ".mpg", "video/mpeg" },
  785.   { ".mpeg", "video/mpeg" },
  786.   { ".qt", "video/quicktime" },
  787.   { ".mov", "video/quicktime" }
  788. };
  790. PStringToString & PMIMEInfo::GetContentTypes()
  791. {
  792.   static PStringToString contentTypes(PARRAYSIZE(DefaultContentTypes),
  793.                                       DefaultContentTypes,
  794.                                       TRUE);
  795.   return contentTypes;
  796. }
  799. void PMIMEInfo::SetAssociation(const PStringToString & allTypes, BOOL merge)
  800. {
  801.   PStringToString & types = GetContentTypes();
  802.   if (!merge)
  803.     types.RemoveAll();
  804.   for (PINDEX i = 0; i < allTypes.GetSize(); i++)
  805.     types.SetAt(allTypes.GetKeyAt(i), allTypes.GetDataAt(i));
  806. }
  809. PString PMIMEInfo::GetContentType(const PString & fType)
  810. {
  811.   if (fType.IsEmpty())
  812.     return "text/plain";
  814.   PStringToString & types = GetContentTypes();
  815.   if (types.Contains(fType))
  816.     return types[fType];
  818.   return "application/octet-stream";
  819. }
  822. ///////////////////////////////////////////////////////////////////////////////
  823. // PBase64
  825. PBase64::PBase64()
  826. {
  827.   StartEncoding();
  828.   StartDecoding();
  829. }
  832. void PBase64::StartEncoding(BOOL useCRLF)
  833. {
  834.   encodedString = "";
  835.   encodeLength = nextLine = saveCount = 0;
  836.   useCRLFs = useCRLF;
  837. }
  840. void PBase64::ProcessEncoding(const PString & str)
  841. {
  842.   ProcessEncoding((const char *)str);
  843. }
  846. void PBase64::ProcessEncoding(const char * cstr)
  847. {
  848.   ProcessEncoding((const BYTE *)cstr, strlen(cstr));
  849. }
  852. void PBase64::ProcessEncoding(const PBYTEArray & data)
  853. {
  854.   ProcessEncoding(data, data.GetSize());
  855. }
  858. static const char Binary2Base64[65] =
  859.             "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  861. void PBase64::OutputBase64(const BYTE * data)
  862. {
  863.   char * out = encodedString.GetPointer((encodeLength&~255) + 256);
  865.   out[encodeLength++] = Binary2Base64[data[0] >> 2];
  866.   out[encodeLength++] = Binary2Base64[((data[0]&3)<<4) | (data[1]>>4)];
  867.   out[encodeLength++] = Binary2Base64[((data[1]&15)<<2) | (data[2]>>6)];
  868.   out[encodeLength++] = Binary2Base64[data[2]&0x3f];
  870.   if (++nextLine > 76) {
  871.     if (useCRLFs)
  872.       out[encodeLength++] = 'r';
  873.     out[encodeLength++] = 'n';
  874.     nextLine = 0;
  875.   }
  876. }
  879. void PBase64::ProcessEncoding(const void * dataPtr, PINDEX length)
  880. {
  881.   const BYTE * data = (const BYTE *)dataPtr;
  882.   while (saveCount < 3) {
  883.     saveTriple[saveCount++] = *data++;
  884.     if (--length <= 0)
  885.       return;
  886.   }
  888.   OutputBase64(saveTriple);
  890.   PINDEX i;
  891.   for (i = 0; i+2 < length; i += 3)
  892.     OutputBase64(data+i);
  894.   saveCount = length - i;
  895.   switch (saveCount) {
  896.     case 2 :
  897.       saveTriple[0] = data[i++];
  898.       saveTriple[1] = data[i];
  899.       break;
  900.     case 1 :
  901.       saveTriple[0] = data[i];
  902.   }
  903. }
  906. PString PBase64::GetEncodedString()
  907. {
  908.   PString retval = encodedString;
  909.   encodedString = "";
  910.   encodeLength = 0;
  911.   return retval;
  912. }
  915. PString PBase64::CompleteEncoding()
  916. {
  917.   char * out = encodedString.GetPointer(encodeLength + 5)+encodeLength;
  919.   switch (saveCount) {
  920.     case 1 :
  921.       *out++ = Binary2Base64[saveTriple[0] >> 2];
  922.       *out++ = Binary2Base64[(saveTriple[0]&3)<<4];
  923.       *out++ = '=';
  924.       *out   = '=';
  925.       break;
  927.     case 2 :
  928.       *out++ = Binary2Base64[saveTriple[0] >> 2];
  929.       *out++ = Binary2Base64[((saveTriple[0]&3)<<4) | (saveTriple[1]>>4)];
  930.       *out++ = Binary2Base64[((saveTriple[1]&15)<<2)];
  931.       *out   = '=';
  932.   }
  934.   return encodedString;
  935. }
  938. PString PBase64::Encode(const PString & str)
  939. {
  940.   return Encode((const char *)str);
  941. }
  944. PString PBase64::Encode(const char * cstr)
  945. {
  946.   return Encode((const BYTE *)cstr, strlen(cstr));
  947. }
  950. PString PBase64::Encode(const PBYTEArray & data)
  951. {
  952.   return Encode(data, data.GetSize());
  953. }
  956. PString PBase64::Encode(const void * data, PINDEX length)
  957. {
  958.   PBase64 encoder;
  959.   encoder.ProcessEncoding(data, length);
  960.   return encoder.CompleteEncoding();
  961. }
  964. void PBase64::StartDecoding()
  965. {
  966.   perfectDecode = TRUE;
  967.   quadPosition = 0;
  968.   decodedData.SetSize(0);
  969.   decodeSize = 0;
  970. }
  973. BOOL PBase64::ProcessDecoding(const PString & str)
  974. {
  975.   return ProcessDecoding((const char *)str);
  976. }
  979. BOOL PBase64::ProcessDecoding(const char * cstr)
  980. {
  981.   static const BYTE Base642Binary[256] = {
  982.     96, 99, 99, 99, 99, 99, 99, 99, 99, 99, 98, 99, 99, 98, 99, 99,
  983.     99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
  984.     99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 62, 99, 99, 99, 63,
  985.     52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 99, 99, 99, 97, 99, 99,
  986.     99,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
  987.     15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 99, 99, 99, 99, 99,
  988.     99, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
  989.     41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 99, 99, 99, 99, 99,
  990.     99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
  991.     99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
  992.     99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
  993.     99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
  994.     99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
  995.     99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
  996.     99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
  997.     99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99
  998.   };
  1000.   for (;;) {
  1001.     BYTE value = Base642Binary[(BYTE)*cstr++];
  1002.     switch (value) {
  1003.       case 96 : // end of string
  1004.         return FALSE;
  1006.       case 97 : // '=' sign
  1007.         if (quadPosition == 3 || (quadPosition == 2 && *cstr == '=')) {
  1008.           quadPosition = 0;  // Reset this to zero, as have a perfect decode
  1009.           return TRUE; // Stop decoding now as must be at end of data
  1010.         }
  1011.         perfectDecode = FALSE;  // Ignore '=' sign but flag decode as suspect
  1012.         break;
  1014.       case 98 : // CRLFs
  1015.         break;  // Ignore totally
  1017.       case 99 :  // Illegal characters
  1018.         perfectDecode = FALSE;  // Ignore rubbish but flag decode as suspect
  1019.         break;
  1021.       default : // legal value from 0 to 63
  1022.         BYTE * out = decodedData.GetPointer(((decodeSize+1)&~255) + 256);
  1023.         switch (quadPosition) {
  1024.           case 0 :
  1025.             out[decodeSize] = (BYTE)(value << 2);
  1026.             break;
  1027.           case 1 :
  1028.             out[decodeSize++] |= (BYTE)(value >> 4);
  1029.             out[decodeSize] = (BYTE)((value&15) << 4);
  1030.             break;
  1031.           case 2 :
  1032.             out[decodeSize++] |= (BYTE)(value >> 2);
  1033.             out[decodeSize] = (BYTE)((value&3) << 6);
  1034.             break;
  1035.           case 3 :
  1036.             out[decodeSize++] |= (BYTE)value;
  1037.             break;
  1038.         }
  1039.         quadPosition = (quadPosition+1)&3;
  1040.     }
  1041.   }
  1042. }
  1045. PBYTEArray PBase64::GetDecodedData()
  1046. {
  1047.   perfectDecode = quadPosition == 0;
  1048.   decodedData.SetSize(decodeSize);
  1049.   PBYTEArray retval = decodedData;
  1050.   retval.MakeUnique();
  1051.   decodedData.SetSize(0);
  1052.   decodeSize = 0;
  1053.   return retval;
  1054. }
  1057. BOOL PBase64::GetDecodedData(void * dataBlock, PINDEX length)
  1058. {
  1059.   perfectDecode = quadPosition == 0;
  1060.   BOOL bigEnough = length >= decodeSize;
  1061.   memcpy(dataBlock, decodedData, bigEnough ? decodeSize : length);
  1062.   decodedData.SetSize(0);
  1063.   decodeSize = 0;
  1064.   return bigEnough;
  1065. }
  1068. PString PBase64::Decode(const PString & str)
  1069. {
  1070.   PBYTEArray data;
  1071.   Decode(str, data);
  1072.   return PString((const char *)(const BYTE *)data, data.GetSize());
  1073. }
  1076. BOOL PBase64::Decode(const PString & str, PBYTEArray & data)
  1077. {
  1078.   PBase64 decoder;
  1079.   decoder.ProcessDecoding(str);
  1080.   data = decoder.GetDecodedData();
  1081.   return decoder.IsDecodeOK();
  1082. }
  1085. BOOL PBase64::Decode(const PString & str, void * dataBlock, PINDEX length)
  1086. {
  1087.   PBase64 decoder;
  1088.   decoder.ProcessDecoding(str);
  1089.   return decoder.GetDecodedData(dataBlock, length);
  1090. }
  1093. // End Of File ///////////////////////////////////////////////////////////////