/[winpt]/trunk/Src/wptMAPI.cpp
ViewVC logotype

Diff of /trunk/Src/wptMAPI.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 27 by twoaday, Tue Oct 18 07:57:13 2005 UTC revision 317 by twoaday, Fri May 25 14:53:02 2007 UTC
# Line 1  Line 1 
 /* wptMAPI.cpp  
  *      Copyright (C) 2003, 2004 Timo Schulz  
  *  
  * This file is part of WinPT.  
  *  
  * WinPT is free software; you can redistribute it and/or modify  
  * it under the terms of the GNU General Public License as published by  
  * the Free Software Foundation; either version 2 of the License, or  
  * (at your option) any later version.  
  *  
  * WinPT is distributed in the hope that it will be useful,  
  * but WITHOUT ANY WARRANTY; without even the implied warranty of  
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
  * GNU General Public License for more details.  
  *  
  * You should have received a copy of the GNU General Public License  
  * along with WinPT; if not, write to the Free Software Foundation,  
  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA  
  */  
 #include <windows.h>  
 #include <stdio.h>  
 #include <mapi.h>  
   
 extern HINSTANCE glob_hinst;  
   
 #include "../resource.h"  
 #include "wptTypes.h"  
 #include "wptErrors.h"  
 #include "wptW32API.h"  
 #include "wptGPG.h"  
   
   
 static LPMAPILOGON          mapi_logon = NULL;  
 static LPMAPILOGOFF         mapi_logoff = NULL;      
 static LPMAPISENDDOCUMENTS  mapi_send_documents = NULL;  
 static LPMAPISENDMAIL       mapi_send_mail = NULL;  
 static HINSTANCE            hlib = NULL;  
 static int                  init = 0;  
   
 #define load_one_fnc(cast, hlib, name) (cast)GetProcAddress ((hlib), name)  
   
   
 int  
 mapi_init (void)  
 {  
     if (init)  
         return 0;  
   
     hlib = LoadLibrary ("MAPI32.DLL");  
     if (!hlib)  
         return -1;  
   
     mapi_logon = load_one_fnc (LPMAPILOGON, hlib, "MAPILogon");  
     mapi_logoff = load_one_fnc (LPMAPILOGOFF, hlib, "MAPILogoff");  
     mapi_send_documents = load_one_fnc (LPMAPISENDDOCUMENTS, hlib, "MAPISendDocuments");  
     mapi_send_mail = load_one_fnc (LPMAPISENDMAIL, hlib, "MAPISendMail");  
     if (!mapi_logon || !mapi_logoff || !mapi_send_documents || !mapi_send_mail)  
         return -1;  
     init = 1;  
   
     return 0;  
 } /* mapi_init */  
   
   
 void  
 mapi_deinit (void)  
 {  
     if (hlib) {  
         FreeLibrary (hlib);  
         hlib = NULL;  
         init = 0;  
     }  
 } /* mapi_deinit */  
   
 #if 0 /* low:priority XXX port the code */  
 int  
 mapi_send_ascfile (char *ascfile)  
 {  
     LHANDLE hd;  
     int rc;  
   
     if (!init)  
         return 0;  
   
     rc = mapi_logon (0, NULL, NULL, MAPI_LOGON_UI, 0, &hd);  
     if (rc != SUCCESS_SUCCESS) {  
         MessageBox (NULL, _("MAPI Login failed."), "MAPI", MB_ICONWARNING|MB_OK);  
         goto fail;  
     }  
     rc = mapi_send_documents (0, ";", ascfile, NULL, 0);  
     if (rc == MAPI_E_USER_ABORT)  
         rc = SUCCESS_SUCCESS;  
     if (rc != SUCCESS_SUCCESS)  
         MessageBox (NULL, _("Could not sent mail."), "MAPI", MB_ICONERROR|MB_OK);  
   
 fail:  
     mapi_logoff (hd, 0, 0, 0);  
     return rc;  
 }  
   
   
 int  
 mapi_send_pubkey (const char *keyid, char *keyfile)  
 {  
     LHANDLE hd;  
     const char * fmt;  
     char * keyinf = NULL;  
     int rc;  
   
     if (!init)  
         return 0;  
   
     fmt = _("GPG Public Key of %s");  
     keyinf = new char[strlen (fmt) + strlen (keyid) + 2];  
     if (!keyinf)  
         BUG (0);  
     sprintf (keyinf, fmt, keyid);  
     rc = mapi_logon (0, NULL, NULL, MAPI_LOGON_UI, 0, &hd);  
     if (rc != SUCCESS_SUCCESS) {  
         MessageBox (NULL, _("MAPI Login failed."), "MAPI", MB_ICONWARNING|MB_OK);  
         goto fail;  
     }  
     rc = mapi_send_documents (0, ";", keyfile, keyinf, 0);  
     if (rc == MAPI_E_USER_ABORT)  
         rc = SUCCESS_SUCCESS;  
     if (rc != SUCCESS_SUCCESS)  
         MessageBox (NULL, _("Could not sent mail."), "MAPI", MB_ICONERROR|MB_OK);  
   
 fail:  
     mapi_logoff (hd, 0, 0, 0);  
     free_if_alloc (keyinf);  
     return rc;  
 } /* mapi_send_pubkey */  
   
   
 static void  
 free_mapi_msg (MapiMessage * msg)  
 {  
     if (!msg)  
         return;  
     safe_free (msg->lpszSubject);  
     safe_free (msg->lpszNoteText);  
     safe_free (msg);  
 } /* free_mapi_msg */  
   
   
 static void  
 free_recip_tab (MapiRecipDesc *recip, size_t n)  
 {  
     size_t i;  
   
     if (!recip)  
         return;  
     if (!n)  
         return;  
     for (i=0; i < n; i++)  
         safe_free (recip[i].lpszName);  
     safe_free (recip);  
 } /* free_recip_tab */  
   
   
 static void  
 free_files_tab (MapiFileDesc * files, size_t n)  
 {  
     size_t i;  
   
     if (!files)  
         return;  
     if (!n)  
         return;  
     for (i=0; i < n; i++) {  
         safe_free (files[i].lpszFileName);  
         safe_free (files[i].lpszPathName);  
     }  
     safe_free (files);  
 } /* free_files_tab */  
   
   
   
 static gpgme_recipients_t  
 conv_recipients (gpgme_recipients_t rset)  
 {  
     gpgme_recipients_t r;  
     gpgme_error_t rc;  
     void * ctx=NULL;  
     const char * s;  
   
     /* we need to convert the recipients to email addresses so  
        GPG can handle them. */  
     rc = gpgme_recipients_new (&r);  
     if (rc)  
         return NULL;  
     gpgme_recipients_enum_open (rset, &ctx);  
   
     while ((s=gpgme_recipients_enum_read (rset, &ctx))) {  
         char * p, * q, * buf;  
         if (!(p = strchr (s, '<')) || !(q = strchr (s, '>')))  
             continue;  
         buf = (char * )calloc (1, (q-s)-(p-s)+2);  
         if (!buf)  
             BUG (0);  
         strncpy (buf, s+(p-s)+1, (q-s)-(p-s)-1);  
         gpgme_recipients_add_name (r, buf);  
         safe_free (buf);  
     }  
     return r;  
 } /* conv_recipients */  
   
   
 static char *  
 secure_attachment (gpgme_recipients_t rset, const char *fname)  
 {  
     char tmpdir[512+32], * p;  
     gpgme_recipients_t addrs;  
     gpgme_ctx_t ctx;  
     gpgme_error_t rc;  
   
     if (strlen (fname) > 200)  
         BUG (0);  
     GetTempPath (sizeof tmpdir-200, tmpdir);  
     p = strrchr (fname, '\\');  
     if (!p)  
         strcat (tmpdir, fname);  
     else  
         strcat (tmpdir, fname+(p-fname)+1);  
     strcat (tmpdir, ".asc");  
   
     rc = gpgme_new (&ctx);  
     if (rc)  
         return NULL;  
     gpgme_set_armor (ctx, 1);  
     addrs = conv_recipients (rset);  
     if (!addrs) {  
         msg_box (NULL, _("No valid mail addresses found."), _("Secure Attachment"), MB_ERR);  
         gpgme_release (NULL);  
         return NULL;  
     }  
     rc = gpgme_op_file_encrypt (ctx, addrs, fname, tmpdir);  
     if (rc)  
         log_box (_("Secure Attachment"), MB_ERR, _("Could not encrypt '%s'"), fname);  
     gpgme_recipients_release (addrs);  
     gpgme_release (ctx);  
     return strdup (tmpdir);  
 } /* secure_attachment */  
   
   
 static gpgme_error_t  
 secure_message (gpgme_recipients_t rset, const char *data,  
                 char *enc_msg, size_t *r_enclen)  
 {  
     gpgme_recipients_t addrs;  
     gpgme_error_t rc;  
     gpgme_data_t in, out;  
     gpgme_ctx_t ctx;  
     char * p;  
     size_t n=0;  
   
     rc = gpgme_new (&ctx);  
     if (rc)  
         return NULL;  
     gpgme_set_armor (ctx, 1);  
   
     addrs = conv_recipients (rset);  
     rc = gpgme_data_new_from_mem (&in, data, strlen (data), 1);  
     if (rc) {  
         gpgme_release (ctx);  
         return rc;  
     }  
     gpgme_data_new (&out);  
     rc = gpgme_op_encrypt (ctx, addrs, GPGME_ENCRYPT_ALWAYS_TRUST, in, out);  
     if (rc)  
         log_box (_("Secure Message"), MB_ERR, "Could not encrypt the data");  
   
     *r_enc_msg = gpgme_data_release_and_get_mem (&n);  
     *r_enclen = n;  
   
     gpgme_data_release (in);  
     gpgme_release (ctx);  
     gpgme_recipients_release (addrs);  
   
     return rc;  
 } /* secure_message */  
   
   
 int  
 mapi_send_message (gpgme_recipients_t rset, const char * msgtxt,  
                    const char * subject, const char **files, size_t nfiles)  
 {  
     LHANDLE hd;  
     MapiMessage * msg;  
     MapiRecipDesc * recip;  
     MapiFileDesc * attch;  
     char * p;  
     const char * s;  
     void * ctx=NULL;  
     size_t n, i=0, encmsg_len=0;  
     int rc;  
   
     if (!init)  
         return 0;  
   
     rc = mapi_logon (0, NULL, NULL, MAPI_LOGON_UI, 0, &hd);  
     if (rc != SUCCESS_SUCCESS) {  
         MessageBox (NULL, "MAPI Login failed.", "MAPI", MB_ICONWARNING|MB_OK);  
         return rc;  
     }  
   
     msg = (MapiMessage *)calloc (1, sizeof * msg);  
     if (!msg)  
         BUG (0);  
     p = msg->lpszSubject = strdup (subject);  
     if (!p)  
         BUG (0);  
     p = msg->lpszNoteText = secure_message (rset, msgtxt, &p, &encmsg_len);  
     if (!p)  
         BUG (0);  
     n = msg->nRecipCount = gpgme_recipients_count (rset);  
     recip = (MapiRecipDesc *)calloc (n+1, sizeof * recip);  
     if (!recip)  
         BUG (0);  
       
     gpgme_recipients_enum_open (rset, &ctx);  
     while ((s = gpgme_recipients_enum_read (rset, &ctx))) {  
         if (!i)  
             recip[i].ulRecipClass = MAPI_TO;  
         else  
             recip[i].ulRecipClass = MAPI_CC;      
         p = recip[i].lpszName = strdup (s);  
         if (!p)  
             BUG (0);  
         i++;  
     }  
     msg->lpRecips = recip;  
   
     if (nfiles) {  
         msg->nFileCount = nfiles;  
         attch = (MapiFileDesc *)calloc (nfiles+1, sizeof * attch);  
         if (!attch)  
             BUG (0);  
         for (i=0; i < nfiles; i++) {  
             char * p = secure_attachment (rset, *files);  
             if (!p)  
                 continue;  
             attch[i].lpszFileName = strdup (*files);          
             attch[i].lpszPathName = strdup (p);  
             files++;  
             safe_free (p);  
         }  
         msg->lpFiles = attch;  
     }  
   
     rc = mapi_send_mail (hd, 0, msg, 0, 0);  
     if (rc == MAPI_E_USER_ABORT)  
         rc = SUCCESS_SUCCESS;  
     if (rc != SUCCESS_SUCCESS)  
         MessageBox (NULL, _("Could not sent mail."), "MAPI", MB_ERR);  
   
     free_recip_tab (recip, n);  
     free_files_tab (attch, nfiles);  
     free_mapi_msg (msg);  
     gpgme_free (p);  
     mapi_logoff (hd, 0, 0, 0);  
   
     return 0;  
 } /* mapi_send_message */  
   
   
 static int  
 add_recipient (gpgme_recipients_t * r_rset, const char * addr)  
 {  
     gpg_keycache_t pub = keycache_get_ctx (1);  
     gpgme_key_t key;  
     gpgme_error_t rc;  
     const char * s;  
   
     if (!*r_rset)  
         gpgme_recipients_new (&(*r_rset));  
     rc = gpgme_keycache_find_key (pub, addr, 0, &key);  
     if (rc) {  
         log_box (_("Add Recipient"), MB_ERR, _("Could not find key for '%s'"), addr);  
         return -1;  
     }  
     s = key->uids->uid;  
     if (s)  
         gpgme_recipients_add_name (*r_rset, s);  
     return 0;  
 } /* add_recipient */  
   
   
 static int  
 add_all_recipients (HWND dlg, int itemid, gpgme_recipients_t * r_rset)  
 {      
     char buf[1024], * p;  
     int n=0;  
   
     n = GetDlgItemText (dlg, itemid, buf, sizeof buf-10);  
     if (!n)  
         return -1;  
     p = strtok (buf, ";,");  
     while (p != NULL) {  
         add_recipient (&*r_rset, p);  
         p = strtok (NULL, ";,");  
     }  
     return 0;  
 } /* add_all_recipients */  
   
   
 BOOL CALLBACK  
 winpt_mail_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)  
 {  
     static gpgme_recipients_t rset=NULL;  
     char subject[128];  
     char * msgbuf;  
     int n;  
   
     switch (msg) {  
     case WM_INITDIALOG:  
         center_window (dlg, NULL);  
         SetForegroundWindow (dlg);  
         break;  
   
     case WM_COMMAND:  
         switch (LOWORD (wparam)) {  
         case IDOK:  
             add_all_recipients (dlg, IDC_PMAIL_TO, &rset);  
             add_all_recipients (dlg, IDC_PMAIL_CC, &rset);  
             if (!gpgme_recipients_count (rset)) {  
                 msg_box (dlg, _("Please enter a recipient."), _("Mail"), MB_ERR);  
                 return FALSE;  
             }  
             n=GetDlgItemText (dlg, IDC_PMAIL_SUBJECT, subject, sizeof subject-1);  
             if (!n)  
                 strcpy (subject, "");  
             n = SendDlgItemMessage (dlg, IDC_PMAIL_MSG, WM_GETTEXTLENGTH, 0, 0);  
             if (!n) {  
                 msg_box (dlg, _("Please enter a message."), _("Mail"), MB_ERR);  
                 return FALSE;  
             }  
             msgbuf = (char * )calloc (1, n+2);  
             if (!msgbuf)  
                 BUG (0);  
             GetDlgItemText (dlg, IDC_PMAIL_MSG, msgbuf, n+1);  
             mapi_send_message (rset, msgbuf, subject, NULL, 0);  
             safe_free (msgbuf);  
             EndDialog (dlg, TRUE);  
             break;  
   
         case IDCANCEL:  
             EndDialog (dlg, FALSE);  
             break;  
         }  
         break;  
     }  
   
     return FALSE;  
 } /* winpt_mail_proc */  
 #endif  
1    /* wptMAPI.cpp - MAPI interface for sending keys.
2     *      Copyright (C) 2003-2006 Timo Schulz
3     *
4     * This file is part of WinPT.
5     *
6     * WinPT is free software; you can redistribute it and/or modify
7     * it under the terms of the GNU General Public License as published by
8     * the Free Software Foundation; either version 2 of the License, or
9     * (at your option) any later version.
10     *
11     * WinPT is distributed in the hope that it will be useful,
12     * but WITHOUT ANY WARRANTY; without even the implied warranty of
13     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     * GNU General Public License for more details.
15     *
16     * You should have received a copy of the GNU General Public License
17     * along with WinPT; if not, write to the Free Software Foundation,
18     * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19     */
20    #ifdef HAVE_CONFIG_H
21    #include <config.h>
22    #endif
23    
24    #include <windows.h>
25    #include <stdio.h>
26    #include <mapi.h>
27    
28    #include "resource.h"
29    #include "wptTypes.h"
30    #include "wptErrors.h"
31    #include "wptW32API.h"
32    #include "wptGPG.h"
33    #include "wptVersion.h"
34    #include "wptCommonCtl.h"
35    #include "wptKeyManager.h"
36    
37    
38    static LPMAPILOGON          mapi_logon = NULL;
39    static LPMAPILOGOFF         mapi_logoff = NULL;    
40    static LPMAPISENDDOCUMENTS  mapi_send_documents = NULL;
41    static LPMAPISENDMAIL       mapi_send_mail = NULL;
42    static HINSTANCE            hlib = NULL;
43    static int                  init = 0;
44    
45    #define load_one_fnc(cast, hlib, name) (cast)GetProcAddress ((hlib), name)
46    
47    
48    /* Table with all valid MAPI errors. */
49    struct mapi_err_s {
50        int err_no;
51        const char *msg;
52    } mapi_errors[] = {
53        {MAPI_E_FAILURE, "One or more unspecified errors occurred. "},
54        {MAPI_E_AMBIGUOUS_RECIPIENT, "A recipient matched more than one of the recipient descriptor structures and MAPI_DIALOG was not set. "},
55        {MAPI_E_ATTACHMENT_NOT_FOUND, "The specified attachment was not found. "},
56        {MAPI_E_ATTACHMENT_OPEN_FAILURE, "The specified attachment could not be opened. "},
57        {MAPI_E_BAD_RECIPTYPE, "The type of a recipient was not MAPI_TO, MAPI_CC, or MAPI_BCC. "},
58        {MAPI_E_INSUFFICIENT_MEMORY, "There was insufficient memory to proceed." },
59        {MAPI_E_INVALID_RECIPS, "One or more recipients were invalid or did not resolve to any address."},
60        {MAPI_E_LOGIN_FAILURE, "There was no default logon, and the user failed to log on successfully when the logon dialog box was displayed."},
61        {MAPI_E_TEXT_TOO_LARGE, "The text in the message was too large."},
62        {MAPI_E_TOO_MANY_FILES, "There were too many file attachments."},
63        {MAPI_E_TOO_MANY_RECIPIENTS, "There were too many recipients."},
64        {MAPI_E_UNKNOWN_RECIPIENT, "A recipient did not appear in the address list."},
65        {MAPI_E_USER_ABORT, "The user canceled one of the dialog boxes."},
66        {SUCCESS_SUCCESS, "The call succeeded and the message was sent."},
67        {0, NULL}
68    };
69    
70    
71    /* Return a human readable MAPI error based on the given error @err. */
72    const char*
73    mapi_strerror (int err)
74    {
75        int i;
76    
77        for (i=0; mapi_errors[i].msg; i++) {
78            if (err == mapi_errors[i].err_no)
79                return mapi_errors[i].msg;
80        }
81        return mapi_errors[0].msg;
82    }
83    
84    
85    /* Load MAPI library and set function pointers.
86       Return value: 0 on success. */
87    int
88    mapi_init (void)
89    {
90        if (init)
91            return 0;
92    
93        hlib = LoadLibrary ("MAPI32.DLL");
94        if (!hlib)
95            return -1;
96    
97        mapi_logon = load_one_fnc (LPMAPILOGON, hlib, "MAPILogon");
98        mapi_logoff = load_one_fnc (LPMAPILOGOFF, hlib, "MAPILogoff");
99        mapi_send_documents = load_one_fnc (LPMAPISENDDOCUMENTS, hlib, "MAPISendDocuments");
100        mapi_send_mail = load_one_fnc (LPMAPISENDMAIL, hlib, "MAPISendMail");
101        if (!mapi_logon || !mapi_logoff || !mapi_send_documents || !mapi_send_mail)
102            return -1;
103        init = 1;
104    
105        return 0;
106    }
107    
108    
109    /* Free library and cleanup. */
110    void
111    mapi_deinit (void)
112    {
113        if (!hlib)
114            return;
115        FreeLibrary (hlib);
116        hlib = NULL;
117        init = 0;
118    }
119    
120    
121    /* Send the file given in @ascfile via the MAPI mechanism. */
122    int
123    mapi_send_ascfile (char *ascfile)
124    {
125        LHANDLE hd;
126        int rc;
127    
128        if (!init)
129            return 0;
130    
131        rc = mapi_logon (0, NULL, NULL, MAPI_LOGON_UI, 0, &hd);
132        if (rc != SUCCESS_SUCCESS) {
133            MessageBox (NULL, mapi_strerror (rc), _("MAPI Login failed"), MB_WARN);
134            goto fail;
135        }
136        rc = mapi_send_documents (0, ";", ascfile, NULL, 0);
137        if (rc == MAPI_E_USER_ABORT)
138            rc = SUCCESS_SUCCESS;
139        if (rc != SUCCESS_SUCCESS)
140            MessageBox (NULL, _("Could not send mail."), "MAPI", MB_ICONERROR|MB_OK);
141    
142    fail:
143        mapi_logoff (hd, 0, 0, 0);
144        return rc;
145    }
146    
147    
148    static void
149    free_mapi_msg (MapiMessage *msg)
150    {
151        if (!msg)
152            return;
153        safe_free (msg->lpszSubject);
154        safe_free (msg->lpszNoteText);
155        safe_free (msg);
156    }
157    
158    
159    static void
160    free_recip_tab (MapiRecipDesc *recip, DWORD n)
161    {
162        DWORD i;
163    
164        if (!recip)
165            return;
166        if (!n)
167            return;
168        for (i=0; i < n; i++)
169            safe_free (recip[i].lpszName);
170        safe_free (recip);
171    }
172    
173    
174    static void
175    free_files_tab (MapiFileDesc *files, DWORD n)
176    {
177        DWORD i;
178    
179        if (!files)
180            return;
181        if (!n)
182            return;
183        for (i=0; i < n; i++) {
184            safe_free (files[i].lpszFileName);
185            safe_free (files[i].lpszPathName);
186        }
187        safe_free (files);
188    }
189    
190    
191    /* Same as mapi_send_pubkey but there is an additional note. */
192    int
193    mapi_send_pubkey_ext (winpt_key_t key, const char *keyfile, int flags)
194    {
195        LHANDLE hd;
196        MapiMessage *msg;
197        MapiRecipDesc *recip;
198        MapiFileDesc *attch;
199        char *p, *kinf;
200        const char *s;
201        int rc;
202    
203        if (!init)
204            return 0;
205    
206        rc = mapi_logon (0, NULL, NULL, MAPI_LOGON_UI, 0, &hd);
207        if (rc != SUCCESS_SUCCESS) {
208            MessageBox (NULL, mapi_strerror (rc), _("MAPI Login failed"), MB_WARN);
209            return rc;
210        }
211    
212        msg = (MapiMessage *)calloc (1, sizeof *msg);
213        if (!msg)
214            BUG (0);
215        p = msg->lpszSubject = strdup ("OpenPGP Public Key");
216        if (!p)
217            BUG (0);
218    
219        s = "Attached is this OpenPGP public key:\n%s\n\n"
220            "Import this key via the clipboard or the Key Manager to\n"
221            "exchange encrypted mails with the key holder and to be able\n"
222            "to verify its signatures.\n"
223            "\n"
224            "If you don't have WinPT, you can download it at http://www.winpt.eu";
225        kinf = km_key_get_info (key, 0);
226        p = (char*)malloc (strlen (s) + strlen (kinf) + 2);
227        sprintf (p, s, kinf);
228        free_if_alloc (kinf);
229    
230        p = msg->lpszNoteText = p;
231        if (!p)
232            BUG (0);
233    
234        /* If the key was signed, we assume it shall be sent back to the owner. */
235        if (flags) {
236            recip = (MapiRecipDesc *)calloc (1, sizeof *recip);
237            if (!recip)
238                BUG (0);
239            recip[0].ulRecipClass = MAPI_TO;
240            p = recip[0].lpszName = strdup (key->ext->uids->uid);
241            if (!p)    
242                BUG (0);
243            msg->lpRecips = recip;
244            msg->nRecipCount = 1;
245        }
246        else {
247            msg->lpRecips = recip = NULL;
248            msg->nRecipCount = 0;
249        }
250    
251        msg->nFileCount = 1;
252        attch = (MapiFileDesc *)calloc (1, sizeof *attch);
253        if (!attch)
254            BUG (0);
255        attch[0].lpszFileName = strdup (keyfile);
256        attch[0].lpszPathName = strdup (keyfile);
257        msg->lpFiles = attch;
258    
259        rc = mapi_send_mail (hd, 0, msg, MAPI_DIALOG , 0);
260        if (rc == MAPI_E_USER_ABORT)
261            rc = SUCCESS_SUCCESS;
262        if (rc != SUCCESS_SUCCESS)
263            MessageBox (NULL, _("Could not sent mail."), "MAPI", MB_ERR);
264    
265        free_recip_tab (recip, 1);
266        free_files_tab (attch, 1);
267        free_mapi_msg (msg);
268        mapi_logoff (hd, 0, 0, 0);
269    
270        return 0;
271    }
272    
273    
274    
275    int
276    mapi_send_pubkey (const char *keyid, char *keyfile)
277    {
278        winpt_key_s key;
279    
280        memset (&key, 0, sizeof (key));
281        if (winpt_get_pubkey (keyid, &key))
282            return -1;
283        return mapi_send_pubkey_ext (&key, keyfile, 0);
284    }
Legend:
Removed from v.27  
changed lines
  Added in v.317
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26