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

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

IP电话/视频会议

开发平台：

Visual C++

mail.cxx：源码内容
  1. /*
  2.  * mail.cxx
  3.  *
  4.  * Electronic mail 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: mail.cxx,v $
  30.  * Revision 1.14  1999/02/10 13:20:53  robertj
  31.  * Added ability to have attachments in mail messages.
  32.  *
  33.  * Revision 1.13  1998/11/30 04:48:40  robertj
  34.  * New directory structure
  35.  *
  36.  * Revision 1.12  1998/10/15 05:41:49  robertj
  37.  * New memory leak check code.
  38.  *
  39.  * Revision 1.11  1998/09/24 03:30:48  robertj
  40.  * Added open software license.
  41.  *
  42.  * Revision 1.10  1997/07/14 11:47:19  robertj
  43.  * Added "const" to numerous variables.
  44.  *
  45.  * Revision 1.9  1997/05/16 12:05:05  robertj
  46.  * Added BCC capability to send mail.
  47.  *
  48.  * Revision 1.8  1997/02/05 11:48:08  robertj
  49.  * Fixed compatibility with MSVC debug memory allocation macros.
  50.  *
  51.  * Revision 1.7  1996/11/18 11:30:15  robertj
  52.  * Fixed support for new libraries.
  53.  *
  54.  * Revision 1.6  1996/07/15 10:26:31  robertj
  55.  * MSVC 4.1 Support
  56.  *
  57.  * Revision 1.5  1996/02/15 14:55:01  robertj
  58.  * Win16 compatibility
  59.  *
  60.  * Revision 1.4  1995/08/24 12:41:25  robertj
  61.  * Implementation of mail for GUIs.
  62.  *
  63.  * Revision 1.3  1995/07/02 01:22:50  robertj
  64.  * Changed mail to use CMC then MAPI if available.
  65.  *
  66.  * Revision 1.2  1995/04/01 08:05:04  robertj
  67.  * Added GUI support.
  68.  *
  69.  * Revision 1.1  1995/03/14 12:45:14  robertj
  70.  * Initial revision
  71.  *
  72.  */
  74. #include <ptlib.h>
  75. #include <ptlib/mail.h>
  77. #include <ctype.h>
  79. #if P_HAS_CMC
  80. #include <xcmcext.h>
  81. #include <xcmcmsxt.h>
  82. #endif
  85. #define new PNEW
  88. //////////////////////////////////////////////////////////////////////////////
  89. // PMail
  91. PMail::PMail()
  92. {
  93.   Construct();
  94. }
  97. PMail::PMail(const PString & username, const PString & password)
  98. {
  99.   Construct();
  100.   LogOnCommonInterface(username, password, NULL);
  101. }
  104. PMail::PMail(const PString & username,
  105.              const PString & password,
  106.              const PString & service)
  107. {
  108.   Construct();
  109.   LogOnCommonInterface(username, password, service);
  110. }
  113. PMail::~PMail()
  114. {
  115.   LogOff();
  116. }
  119. void PMail::Construct()
  120. {
  121.   loggedOn = FALSE;
  122.   hUserInterface = NULL;
  123. }
  126. BOOL PMail::LogOn(const PString & username, const PString & password)
  127. {
  128.   return LogOnCommonInterface(username, password, NULL);
  129. }
  132. BOOL PMail::LogOn(const PString & username,
  133.                   const PString & password,
  134.                   const PString & service)
  135. {
  136.   return LogOnCommonInterface(username, password, service);
  137. }
  140. BOOL PMail::LogOnCommonInterface(const char * username,
  141.                                  const char * password,
  142.                                  const char * service)
  143. {
  144.   if (!LogOff())
  145.     return FALSE;
  147. #if P_HAS_CMC
  148.   if (cmc.IsLoaded()) {
  149.     CMC_X_COM_support support[2];
  150.     support[0].item_code = CMC_XS_COM;
  151.     support[0].flags = 0;
  152.     support[1].item_code = CMC_XS_MS;
  153.     support[1].flags = 0;
  154.     CMC_extension extension;
  155.     extension.item_code = CMC_X_COM_SUPPORT_EXT;
  156.     extension.item_data = PARRAYSIZE(support);
  157.     extension.item_reference = support;
  158.     extension.extension_flags = CMC_EXT_LAST_ELEMENT;
  159.     lastError = cmc.logon((CMC_string)service,
  160.                           (CMC_string)username,
  161.                           (CMC_string)password,
  162.                           NULL,
  163.                           (CMC_ui_id)hUserInterface,
  164.                           100,
  165.                           hUserInterface == NULL ? 0 :
  166.                                  (CMC_LOGON_UI_ALLOWED | CMC_ERROR_UI_ALLOWED),
  167.                           &sessionId,
  168.                           &extension);
  169.     loggedOn = lastError == CMC_SUCCESS;
  170.     return loggedOn;
  171.   }
  172. #endif
  174. #if P_HAS_MAPI
  175.   if (mapi.IsLoaded()) {
  176.     PAssert(service == NULL, "Cannot have variable services");
  178.     lastError = mapi.Logon((HWND)hUserInterface, username, password, 0, 0, &sessionId);
  179.     loggedOn = lastError == SUCCESS_SUCCESS;
  180.     return loggedOn;
  181.   }
  182. #endif
  184.   lastError = 1;
  185.   return FALSE;
  186. }
  189. BOOL PMail::LogOff()
  190. {
  191.   if (!loggedOn)
  192.     return TRUE;
  194. #if P_HAS_CMC
  195.   if (cmc.IsLoaded()) {
  196.     lastError = cmc.logoff(sessionId,
  197.                            (CMC_ui_id)hUserInterface,
  198.                            hUserInterface == NULL ? 0
  199.                               : (CMC_LOGOFF_UI_ALLOWED | CMC_ERROR_UI_ALLOWED),
  200.                            NULL);
  201.     switch (lastError) {
  202.       case CMC_SUCCESS :
  203.       case CMC_E_INVALID_SESSION_ID :
  204.       case CMC_E_USER_NOT_LOGGED_ON :
  205.         loggedOn = FALSE;
  206.     }
  207.     return lastError == CMC_SUCCESS;
  208.   }
  209. #endif
  211. #if P_HAS_MAPI
  212.   if (mapi.IsLoaded()) {
  213.     lastError = mapi.Logoff(sessionId, (HWND)hUserInterface, 0, 0);
  214.     if (lastError == SUCCESS_SUCCESS || lastError == MAPI_E_INVALID_SESSION)
  215.       loggedOn = FALSE;
  216.     return lastError == SUCCESS_SUCCESS;
  217.   }
  218. #endif
  220.   lastError = 1;
  221.   return FALSE;
  222. }
  225. BOOL PMail::IsLoggedOn() const
  226. {
  227.   return loggedOn;
  228. }
  231. BOOL PMail::SendNote(const PString & recipient,
  232.                      const PString & subject,
  233.                      const char * body)
  234. {
  235.   PStringList dummy;
  236.   return SendNote(recipient, dummy, dummy, subject, body, dummy);
  237. }
  240. BOOL PMail::SendNote(const PString & recipient,
  241.                      const PString & subject,
  242.                      const char * body,
  243.                      const PStringList & attachments)
  244. {
  245.   PStringList dummy;
  246.   return SendNote(recipient, dummy, dummy, subject, body, attachments);
  247. }
  250. BOOL PMail::SendNote(const PString & recipient,
  251.                      const PStringList & carbonCopies,
  252.                      const PStringList & blindCarbons,
  253.                      const PString & subject,
  254.                      const char * body,
  255.                      const PStringList & attachments)
  256. {
  257. #if P_HAS_CMC
  258.   if (cmc.IsLoaded()) {
  259.     CMC_message message;
  260.     memset(&message, 0, sizeof(message));
  262.     PINDEX size = carbonCopies.GetSize() + blindCarbons.GetSize() + 1;
  263.     message.recipients = new CMC_recipient[size];
  264.     memset(message.recipients, 0, size*sizeof(CMC_recipient));
  266.     message.recipients[0].role = CMC_ROLE_TO;
  267.     message.recipients[0].name = (CMC_string)(const char *)recipient;
  269.     PINDEX count = 0;
  270.     PINDEX i;
  271.     for (i = 0 ; i < carbonCopies.GetSize(); i++) {
  272.       message.recipients[++count].role = CMC_ROLE_CC;
  273.       message.recipients[count].name = (CMC_string)(const char *)carbonCopies[i];
  274.     }
  275.     for (i = 0 ; i < blindCarbons.GetSize(); i++) {
  276.       message.recipients[++count].role = CMC_ROLE_BCC;
  277.       message.recipients[count].name = (CMC_string)(const char *)blindCarbons[i];
  278.     }
  279.     message.recipients[count].recip_flags = CMC_RECIP_LAST_ELEMENT;
  281.     message.subject = (CMC_string)(const char *)subject;
  282.     message.text_note = (CMC_string)body;
  283.     message.message_flags = CMC_MSG_LAST_ELEMENT;
  285.     if (!attachments.IsEmpty()) {
  286.       message.attachments = new CMC_attachment[attachments.GetSize()];
  287.       memset(message.attachments, 0, attachments.GetSize()*sizeof(CMC_attachment));
  288.       for (i = 0 ; i < attachments.GetSize(); i++) {
  289.         message.attachments[i].attach_type = CMC_ATT_OID_BINARY;
  290.         message.attachments[i].attach_filename = (CMC_string)(const char *)attachments[i];
  291.       }
  292.       message.attachments[i-1].attach_flags = CMC_ATT_LAST_ELEMENT;
  293.     }
  295.     lastError = cmc.send(sessionId, &message, 0, (CMC_ui_id)hUserInterface, NULL);
  297.     delete [] message.attachments;
  298.     delete [] message.recipients;
  300.     return lastError == CMC_SUCCESS;
  301.   }
  302. #endif
  304. #if P_HAS_MAPI
  305.   if (mapi.IsLoaded()) {
  306.     MapiMessage message;
  307.     memset(&message, 0, sizeof(message));
  309.     message.nRecipCount = carbonCopies.GetSize() + blindCarbons.GetSize() + 1;
  310.     message.lpRecips = new MapiRecipDesc[message.nRecipCount];
  311.     memset(message.lpRecips, 0, message.nRecipCount*sizeof(MapiRecipDesc));
  313.     message.lpRecips[0].ulRecipClass = MAPI_TO;
  314.     message.lpRecips[0].lpszName = (char *)(const char *)recipient;
  316.     PINDEX count = 0;
  317.     PINDEX i;
  318.     for (i = 0 ; i < carbonCopies.GetSize(); i++) {
  319.       message.lpRecips[++count].ulRecipClass = MAPI_CC;
  320.       message.lpRecips[count].lpszName = (char *)(const char *)carbonCopies[i];
  321.     }
  322.     for (i = 0 ; i < blindCarbons.GetSize(); i++) {
  323.       message.lpRecips[++count].ulRecipClass = MAPI_BCC;
  324.       message.lpRecips[count].lpszName = (char *)(const char *)blindCarbons[i];
  325.     }
  327.     message.lpszSubject = (char *)(const char *)subject;
  328.     message.lpszNoteText = (char *)body;
  330.     if (!attachments.IsEmpty()) {
  331.       message.lpFiles = new MapiFileDesc[attachments.GetSize()];
  332.       memset(message.lpFiles, 0, attachments.GetSize()*sizeof(MapiFileDesc));
  333.       for (i = 0 ; i < attachments.GetSize(); i++) {
  334.         message.lpFiles[i].nPosition = (DWORD)-1;
  335.         message.lpFiles[i].lpszPathName = (CMC_string)(const char *)attachments[i];
  336.       }
  337.     }
  339.     lastError = mapi.SendMail(sessionId, (HWND)hUserInterface, &message, 0, 0);
  341.     delete [] message.lpRecips;
  343.     return lastError == SUCCESS_SUCCESS;
  344.   }
  345. #endif
  347.   lastError = 1;
  348.   return FALSE;
  349. }
  352. PStringArray PMail::GetMessageIDs(BOOL unreadOnly)
  353. {
  354.   PStringArray msgIDs;
  356. #if P_HAS_CMC
  357.   if (cmc.IsLoaded()) {
  358.     CMC_flags flags = CMC_LIST_MSG_REFS_ONLY;
  359.     if (unreadOnly)
  360.       flags |= CMC_LIST_UNREAD_ONLY;
  361.     if (hUserInterface != NULL)
  362.       flags |= CMC_ERROR_UI_ALLOWED;
  363.     CMC_uint32 count = 0;
  364.     CMC_message_summary * messages;
  366.     lastError = cmc.list(sessionId,
  367.                    NULL, flags, NULL, &count, hUserInterface, &messages, NULL);
  368.     if (lastError == CMC_SUCCESS) {
  369.       msgIDs.SetSize((PINDEX)count);
  370.       for (PINDEX m = 0; m < (PINDEX)count; m++) {
  371.         for (CMC_uint32 c = 0; c < messages[m].message_reference->length; c++)
  372.           if (!isprint(messages[m].message_reference->string[c]))
  373.             break;
  374.         if (c >= messages[m].message_reference->length)
  375.           msgIDs[m] = 'L' + PString(messages[m].message_reference->string,
  376.                                     (PINDEX)messages[m].message_reference->length);
  377.         else {
  378.           PCharArray buf((PINDEX)(messages[m].message_reference->length*2 + 6));
  379.           char * ptr = buf.GetPointer();
  380.           *ptr++ = 'H';
  381.           for (c = 0; c < messages[m].message_reference->length; c++) {
  382.             sprintf(ptr, "%02x", messages[m].message_reference->string[c]);
  383.             ptr += 2;
  384.           }
  385.           msgIDs[m] = buf;
  386.         }
  387.       }
  388.       cmc.free_buf(messages);
  389.     }
  390.     return msgIDs;
  391.   }
  392. #endif
  394. #if P_HAS_MAPI
  395.   if (mapi.IsLoaded()) {
  396.     FLAGS flags = unreadOnly ? MAPI_UNREAD_ONLY : 0;
  397.     PINDEX count = 0;
  398.     const char * seed = NULL;
  399.     char msgIdBuffer[64];
  401.     while ((lastError = mapi.FindNext(sessionId, (HWND)hUserInterface,
  402.                       NULL, seed, flags, 0, msgIdBuffer)) == SUCCESS_SUCCESS) {
  403.       if (count >= msgIDs.GetSize())
  404.         msgIDs.SetSize(count+10);
  405.       msgIDs[count] = msgIdBuffer;
  406.       seed = msgIDs[count++];
  407.     }
  409.     msgIDs.SetSize(count);
  411.     return msgIDs;
  412.   }
  413. #endif
  415.   lastError = 1;
  416.   return msgIDs;
  417. }
  420. #if P_HAS_CMC
  421. class CMC_message_reference_ptr
  422. {
  423.   public:
  424.     CMC_message_reference_ptr(const PString & id);
  425.     ~CMC_message_reference_ptr() { free(ref); }
  426.     operator CMC_message_reference *() { return ref; }
  427.   private:
  428.     CMC_message_reference * ref;
  429. };
  431. CMC_message_reference_ptr::CMC_message_reference_ptr(const PString & id)
  432. {
  433.   PINDEX len = id.GetLength();
  434.   if (id[0] == 'H') {
  435.     ref = (CMC_message_reference *)malloc(sizeof(ref)+(len-1)/2);
  436.     ref->length = (len-1)/2;
  437.     for (PINDEX i = 0; i < (PINDEX)ref->length; i++) {
  438.       int val = 0;
  439.       for (PINDEX j = 1; j <= 2; j++) {
  440.         char c = id[i*2+j];
  441.         if (isdigit(c))
  442.           val += c - '0';
  443.         else
  444.           val += toupper(c) - '0' - 7;
  445.       }
  446.       ref->string[i] = (char)val;
  447.     }
  448.   }
  449.   else if (id[0] == 'L') {
  450.     ref = (CMC_message_reference *)malloc(sizeof(ref)+len-1);
  451.     ref->length = len-1;
  452.     memcpy(ref->string, ((const char *)id)+1, len-1);
  453.   }
  454.   else {
  455.     ref = (CMC_message_reference *)malloc(sizeof(ref)+len);
  456.     ref->length = len;
  457.     memcpy(ref->string, (const char *)id, len);
  458.   }
  459. }
  460. #endif
  463. BOOL PMail::GetMessageHeader(const PString & id,
  464.                              Header & hdrInfo)
  465. {
  466. #if P_HAS_CMC
  467.   if (cmc.IsLoaded()) {
  468.     CMC_flags flags =  hUserInterface != NULL ? CMC_ERROR_UI_ALLOWED : 0;
  469.     CMC_uint32 count = 1;
  470.     CMC_message_summary * message;
  471.     CMC_message_reference_ptr seed = id;
  473.     lastError = cmc.list(sessionId,
  474.                     NULL, flags, seed, &count, hUserInterface, &message, NULL);
  475.     if (lastError != CMC_SUCCESS)
  476.       return FALSE;
  478.     hdrInfo.subject = message->subject;
  479.     hdrInfo.received = PTime(0, message->time_sent.minute,
  480.                                 message->time_sent.hour,
  481.                                 message->time_sent.day,
  482.                                 message->time_sent.month,
  483.                                 message->time_sent.year);
  484.     hdrInfo.originatorName = message->originator->name;
  485.     if (message->originator->address != 0)
  486.       hdrInfo.originatorAddress = message->originator->address;
  487.     else
  488.       hdrInfo.originatorAddress = '"' + hdrInfo.originatorName + '"';
  490.     cmc.free_buf(message);
  491.     return TRUE;
  492.   }
  493. #endif
  495. #if P_HAS_MAPI
  496.   if (mapi.IsLoaded()) {
  497.     MapiMessage * message;
  498.     lastError = mapi.ReadMail(sessionId,
  499.                     (HWND)hUserInterface, id, MAPI_ENVELOPE_ONLY, 0, &message);
  500.     if (lastError != SUCCESS_SUCCESS)
  501.       return FALSE;
  503.     PStringStream str = message->lpszDateReceived;
  504.     int min, hr, day, mon, yr;
  505.     char c;
  506.     str >> yr >> c >> mon >> c >> day >> hr >> c >> min;
  508.     hdrInfo.subject = message->lpszSubject;
  509.     hdrInfo.received = PTime(0, min, hr, day, mon, yr);
  510.     hdrInfo.originatorName = message->lpOriginator->lpszName;
  511.     if (message->lpOriginator->lpszAddress != 0)
  512.       hdrInfo.originatorAddress = message->lpOriginator->lpszAddress;
  513.     else
  514.       hdrInfo.originatorAddress = '"' + hdrInfo.originatorName + '"';
  516.     mapi.FreeBuffer(message);
  517.     return TRUE;
  518.   }
  519. #endif
  521.   lastError = 1;
  522.   return FALSE;
  523. }
  526. BOOL PMail::GetMessageBody(const PString & id, PString & body, BOOL markAsRead)
  527. {
  528.   body = PString();
  530. #if P_HAS_CMC
  531.   if (cmc.IsLoaded()) {
  532.     CMC_flags flags = CMC_MSG_AND_ATT_HDRS_ONLY;
  533.     if (!markAsRead)
  534.       flags |= CMC_DO_NOT_MARK_AS_READ;
  535.     if (hUserInterface != NULL)
  536.       flags |= CMC_ERROR_UI_ALLOWED;
  538.     CMC_message_reference_ptr seed = id;
  539.     CMC_message * message;
  541.     lastError = cmc.read(sessionId,seed,flags,&message,hUserInterface,NULL);
  542.     if (lastError != CMC_SUCCESS)
  543.       return FALSE;
  545.     if (message->text_note != NULL)
  546.       body = message->text_note;
  548.     BOOL ok = (message->message_flags&CMC_MSG_TEXT_NOTE_AS_FILE) == 0;
  549.     cmc.free_buf(message);
  551.     return ok;
  552.   }
  553. #endif
  555. #if P_HAS_MAPI
  556.   if (mapi.IsLoaded()) {
  557.     FLAGS flags = MAPI_SUPPRESS_ATTACH;
  558.     if (!markAsRead)
  559.       flags |= MAPI_PEEK;
  561.     MapiMessage * message;
  563.     lastError = mapi.ReadMail(sessionId,
  564.                                  (HWND)hUserInterface, id, flags, 0, &message);
  565.     if (lastError != SUCCESS_SUCCESS)
  566.       return FALSE;
  568.     body = message->lpszNoteText;
  569.     mapi.FreeBuffer(message);
  570.     return TRUE;
  571.   }
  572. #endif
  574.   lastError = 1;
  575.   return FALSE;
  576. }
  579. BOOL PMail::GetMessageAttachments(const PString & id,
  580.                                   PStringArray & filenames,
  581.                                   BOOL includeBody,
  582.                                   BOOL markAsRead)
  583. {
  584.   filenames.SetSize(0);
  586. #if P_HAS_CMC
  587.   if (cmc.IsLoaded()) {
  588.     CMC_flags flags = 0;
  589.     if (!markAsRead)
  590.       flags |= CMC_DO_NOT_MARK_AS_READ;
  591.     if (hUserInterface != NULL)
  592.       flags |= CMC_ERROR_UI_ALLOWED;
  594.     CMC_message_reference_ptr seed = id;
  595.     CMC_message * message;
  597.     lastError = cmc.read(sessionId,seed,flags,&message,hUserInterface,NULL);
  598.     if (lastError != CMC_SUCCESS)
  599.       return FALSE;
  601.     if (message->attachments != NULL) {
  602.       PINDEX total = 1;
  603.       for (CMC_attachment * attachment = message->attachments;
  604.             (attachment->attach_flags&CMC_ATT_LAST_ELEMENT) != 0; attachment++)
  605.         total++;
  606.       filenames.SetSize(total);
  608.       PINDEX attnum = 0;
  609.       attachment = &message->attachments[attnum];
  610.       do {
  611.         if (includeBody ||
  612.                        (message->message_flags&CMC_MSG_TEXT_NOTE_AS_FILE) == 0)
  613.           filenames[attnum++] = attachment->attach_filename;
  614.       } while (((attachment++)->attach_flags&CMC_ATT_LAST_ELEMENT) != 0);
  615.     }
  617.     cmc.free_buf(message);
  618.     return TRUE;
  619.   }
  620. #endif
  622. #if P_HAS_MAPI
  623.   if (mapi.IsLoaded()) {
  624.     FLAGS flags = 0;
  625.     if (includeBody)
  626.       flags |= MAPI_BODY_AS_FILE;
  627.     if (!markAsRead)
  628.       flags |= MAPI_PEEK;
  630.     MapiMessage * message;
  631.     lastError = mapi.ReadMail(sessionId,
  632.                                  (HWND)hUserInterface, id, flags, 0, &message);
  633.     if (lastError != SUCCESS_SUCCESS)
  634.       return FALSE;
  636.     filenames.SetSize(message->nFileCount);
  637.     for (PINDEX i = 0; i < filenames.GetSize(); i++)
  638.       filenames[i] = message->lpFiles[i].lpszPathName;
  640.     mapi.FreeBuffer(message);
  641.     return TRUE;
  642.   }
  643. #endif
  645.   lastError = 1;
  646.   return FALSE;
  647. }
  650. BOOL PMail::MarkMessageRead(const PString & id)
  651. {
  652. #if P_HAS_CMC
  653.   if (cmc.IsLoaded()) {
  654.     CMC_flags flags = CMC_MSG_AND_ATT_HDRS_ONLY;
  655.     if (hUserInterface != NULL)
  656.       flags |= CMC_ERROR_UI_ALLOWED;
  658.     CMC_message_reference_ptr seed = id;
  659.     CMC_message * message;
  661.     lastError = cmc.read(sessionId,seed,flags,&message,hUserInterface,NULL);
  662.     if (lastError != CMC_SUCCESS)
  663.       return FALSE;
  665.     cmc.free_buf(message);
  666.     return TRUE;
  667.   }
  668. #endif
  670. #if P_HAS_MAPI
  671.   if (mapi.IsLoaded()) {
  672.     MapiMessage * message;
  673.     lastError = mapi.ReadMail(sessionId,
  674.                     (HWND)hUserInterface, id, MAPI_ENVELOPE_ONLY, 0, &message);
  675.     if (lastError != SUCCESS_SUCCESS)
  676.       return FALSE;
  678.     mapi.FreeBuffer(message);
  679.     return TRUE;
  680.   }
  681. #endif
  683.   lastError = 1;
  684.   return FALSE;
  685. }
  688. BOOL PMail::DeleteMessage(const PString & id)
  689. {
  690. #if P_HAS_CMC
  691.   if (cmc.IsLoaded()) {
  692.     CMC_flags flags =  hUserInterface != NULL ? CMC_ERROR_UI_ALLOWED : 0;
  693.     CMC_message_reference_ptr seed = id;
  695.     lastError = cmc.act_on(sessionId,
  696.                          seed, CMC_ACT_ON_DELETE, flags, hUserInterface, NULL);
  697.     return lastError == CMC_SUCCESS;
  698.   }
  699. #endif
  701. #if P_HAS_MAPI
  702.   if (mapi.IsLoaded()) {
  703.     lastError = mapi.DeleteMail(sessionId, (HWND)hUserInterface, id, 0, 0);
  704.     return lastError == SUCCESS_SUCCESS;
  705.   }
  706. #endif
  708.   lastError = 1;
  709.   return FALSE;
  710. }
  713. PMail::LookUpResult PMail::LookUp(const PString & name, PString * fullName)
  714. {
  715. #if P_HAS_CMC
  716.   if (cmc.IsLoaded()) {
  717.     CMC_recipient recip_in;
  718.     memset(&recip_in, 0, sizeof(recip_in));
  719.     recip_in.name = (CMC_string)(const char *)name;
  720.     recip_in.recip_flags = CMC_RECIP_LAST_ELEMENT;
  722.     CMC_recipient * recip_out;
  723.     CMC_uint32 count = 1;
  724.     lastError = cmc.look_up(sessionId, &recip_in, CMC_LOOKUP_RESOLVE_IDENTITY,
  725.                           (CMC_ui_id)hUserInterface, &count, &recip_out, NULL);
  726.     switch (lastError) {
  727.       case CMC_SUCCESS :
  728.         if (fullName != NULL)
  729.           *fullName = recip_out->name;
  730.         cmc.free_buf(recip_out);
  731.         return ValidUser;
  733.       case CMC_E_AMBIGUOUS_RECIPIENT :
  734.         return AmbiguousUser;
  736.       case CMC_E_RECIPIENT_NOT_FOUND :
  737.         return UnknownUser;
  738.     }
  739.   
  740.     return LookUpError;
  741.   }
  742. #endif
  744. #if P_HAS_MAPI
  745.   if (mapi.IsLoaded()) {
  746.     MapiRecipDesc * recip;
  747.     lastError = mapi.ResolveName(sessionId,
  748.                       (HWND)hUserInterface, name, MAPI_AB_NOMODIFY, 0, &recip);
  750.     switch (lastError) {
  751.       case SUCCESS_SUCCESS :
  752.         if (fullName != NULL)
  753.           *fullName = recip->lpszName;
  754.         mapi.FreeBuffer(recip);
  755.         return ValidUser;
  757.       case MAPI_E_AMBIGUOUS_RECIPIENT :
  758.         return AmbiguousUser;
  760.       case MAPI_E_UNKNOWN_RECIPIENT :
  761.         return UnknownUser;
  762.     }
  763.   
  764.     return LookUpError;
  765.   }
  766. #endif
  768.   lastError = 1;
  769.   return LookUpError;
  770. }
  773. int PMail::GetErrorCode() const
  774. {
  775.   return (int)lastError;
  776. }
  779. PString PMail::GetErrorText() const
  780. {
  781. #if P_HAS_CMC
  782.   static const char * const cmcErrMsg[] = {
  783.     "CMC_SUCCESS",
  784.     "CMC_E_AMBIGUOUS_RECIPIENT",
  785.     "CMC_E_ATTACHMENT_NOT_FOUND",
  786.     "CMC_E_ATTACHMENT_OPEN_FAILURE",
  787.     "CMC_E_ATTACHMENT_READ_FAILURE",
  788.     "CMC_E_ATTACHMENT_WRITE_FAILURE",
  789.     "CMC_E_COUNTED_STRING_UNSUPPORTED",
  790.     "CMC_E_DISK_FULL",
  791.     "CMC_E_FAILURE",
  792.     "CMC_E_INSUFFICIENT_MEMORY",
  793.     "CMC_E_INVALID_CONFIGURATION",
  794.     "CMC_E_INVALID_ENUM",
  795.     "CMC_E_INVALID_FLAG",
  796.     "CMC_E_INVALID_MEMORY",
  797.     "CMC_E_INVALID_MESSAGE_PARAMETER",
  798.     "CMC_E_INVALID_MESSAGE_REFERENCE",
  799.     "CMC_E_INVALID_PARAMETER",
  800.     "CMC_E_INVALID_SESSION_ID",
  801.     "CMC_E_INVALID_UI_ID",
  802.     "CMC_E_LOGON_FAILURE",
  803.     "CMC_E_MESSAGE_IN_USE",
  804.     "CMC_E_NOT_SUPPORTED",
  805.     "CMC_E_PASSWORD_REQUIRED",
  806.     "CMC_E_RECIPIENT_NOT_FOUND",
  807.     "CMC_E_SERVICE_UNAVAILABLE",
  808.     "CMC_E_TEXT_TOO_LARGE",
  809.     "CMC_E_TOO_MANY_FILES",
  810.     "CMC_E_TOO_MANY_RECIPIENTS",
  811.     "CMC_E_UNABLE_TO_NOT_MARK_AS_READ",
  812.     "CMC_E_UNRECOGNIZED_MESSAGE_TYPE",
  813.     "CMC_E_UNSUPPORTED_ACTION",
  814.     "CMC_E_UNSUPPORTED_CHARACTER_SET",
  815.     "CMC_E_UNSUPPORTED_DATA_EXT",
  816.     "CMC_E_UNSUPPORTED_FLAG",
  817.     "CMC_E_UNSUPPORTED_FUNCTION_EXT",
  818.     "CMC_E_UNSUPPORTED_VERSION",
  819.     "CMC_E_USER_CANCEL",
  820.     "CMC_E_USER_NOT_LOGGED_ON"
  821.   };
  822.   if (cmc.IsLoaded()) {
  823.     if (lastError < PARRAYSIZE(cmcErrMsg))
  824.       return cmcErrMsg[lastError];
  825.     return PString(PString::Printf, "CMC Error=%lu", lastError);
  826.   }
  827. #endif
  829. #if P_HAS_MAPI
  830.   static const char * const mapiErrMsg[] = {
  831.     "SUCCESS_SUCCESS",
  832.     "MAPI_USER_ABORT",
  833.     "MAPI_E_FAILURE",
  834.     "MAPI_E_LOGIN_FAILURE",
  835.     "MAPI_E_DISK_FULL",
  836.     "MAPI_E_INSUFFICIENT_MEMORY",
  837.     "MAPI_E_ACCESS_DENIED",
  838.     "MAPI_E_UNKNOWN",
  839.     "MAPI_E_TOO_MANY_SESSIONS",
  840.     "MAPI_E_TOO_MANY_FILES",
  841.     "MAPI_E_TOO_MANY_RECIPIENTS",
  842.     "MAPI_E_ATTACHMENT_NOT_FOUND",
  843.     "MAPI_E_ATTACHMENT_OPEN_FAILURE",
  844.     "MAPI_E_ATTACHMENT_WRITE_FAILURE",
  845.     "MAPI_E_UNKNOWN_RECIPIENT",
  846.     "MAPI_E_BAD_RECIPTYPE",
  847.     "MAPI_E_NO_MESSAGES",
  848.     "MAPI_E_INVALID_MESSAGE",
  849.     "MAPI_E_TEXT_TOO_LARGE",
  850.     "MAPI_E_INVALID_SESSION",
  851.     "MAPI_E_TYPE_NOT_SUPPORTED",
  852.     "MAPI_E_AMBIGUOUS_RECIPIENT",
  853.     "MAPI_E_MESSAGE_IN_USE",
  854.     "MAPI_E_NETWORK_FAILURE",
  855.     "MAPI_E_INVALID_EDITFIELDS",
  856.     "MAPI_E_INVALID_RECIPS",
  857.     "MAPI_E_NOT_SUPPORTED"
  858.   };
  859.   if (mapi.IsLoaded()) {
  860.     if (lastError < PARRAYSIZE(mapiErrMsg))
  861.       return mapiErrMsg[lastError];
  862.     return PString(PString::Printf, "MAPI Error=%lu", lastError);
  863.   }
  864. #endif
  866.   return "No mail library loaded.";
  867. }
  870. #if P_HAS_CMC
  871. PMail::CMCDLL::CMCDLL()
  872. #ifdef _WIN32
  873.   : PDynaLink("MAPI32.DLL")
  874. #else
  875.   : PDynaLink("CMC.DLL")
  876. #endif
  877. {
  878.   if (!GetFunction("cmc_logon", (Function &)logon) ||
  879.       !GetFunction("cmc_logoff", (Function &)logoff) ||
  880.       !GetFunction("cmc_free", (Function &)free_buf) ||
  881.       !GetFunction("cmc_query_configuration", (Function &)query_configuration) ||
  882.       !GetFunction("cmc_look_up", (Function &)look_up) ||
  883.       !GetFunction("cmc_list", (Function &)list) ||
  884.       !GetFunction("cmc_send", (Function &)send) ||
  885.       !GetFunction("cmc_read", (Function &)read) ||
  886.       !GetFunction("cmc_act_on", (Function &)act_on))
  887.     Close();
  888. }
  889. #endif
  892. #if P_HAS_MAPI
  893. PMail::MAPIDLL::MAPIDLL()
  894. #ifdef _WIN32
  895.   : PDynaLink("MAPI32.DLL")
  896. #else
  897.   : PDynaLink("MAPI.DLL")
  898. #endif
  899. {
  900.   if (!GetFunction("MAPILogon", (Function &)Logon) ||
  901.       !GetFunction("MAPILogoff", (Function &)Logoff) ||
  902.       !GetFunction("MAPISendMail", (Function &)SendMail) ||
  903.       !GetFunction("MAPISendDocuments", (Function &)SendDocuments) ||
  904.       !GetFunction("MAPIFindNext", (Function &)FindNext) ||
  905.       !GetFunction("MAPIReadMail", (Function &)ReadMail) ||
  906.       !GetFunction("MAPISaveMail", (Function &)SaveMail) ||
  907.       !GetFunction("MAPIDeleteMail", (Function &)DeleteMail) ||
  908.       !GetFunction("MAPIFreeBuffer", (Function &)FreeBuffer) ||
  909.       !GetFunction("MAPIAddress", (Function &)Address) ||
  910.       !GetFunction("MAPIDetails", (Function &)Details) ||
  911.       !GetFunction("MAPIResolveName", (Function &)ResolveName))
  912.     Close();
  913. }
  914. #endif
  917. // End Of File ///////////////////////////////////////////////////////////////