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

Diff of /trunk/Src/wptCardEdit.cpp

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

revision 35 by twoaday, Thu Oct 20 12:35:59 2005 UTC revision 36 by werner, Thu Oct 27 15:25:13 2005 UTC
# Line 1  Line 1 
1  /* wptCardEdit.cpp - OpenPGP editing interface  /* wptCardEdit.cpp - OpenPGP editing interface
2   *      Copyright (C) 2005 Timo Schulz   *      Copyright (C) 2005 Timo Schulz
3   *   *
4   * This file is part of WinPT.   * This file is part of WinPT.
5   *   *
6   * WinPT is free software; you can redistribute it and/or modify   * 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   * 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   * the Free Software Foundation; either version 2 of the License, or
9   * (at your option) any later version.   * (at your option) any later version.
10   *   *
11   * WinPT is distributed in the hope that it will be useful,   * WinPT is distributed in the hope that it will be useful,
12   * but WITHOUT ANY WARRANTY; without even the implied warranty of   * but WITHOUT ANY WARRANTY; without even the implied warranty of
13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14   * GNU General Public License for more details.   * GNU General Public License for more details.
15   *   *
16   * You should have received a copy of the GNU General Public License   * You should have received a copy of the GNU General Public License
17   * along with WinPT; if not, write to the Free Software Foundation,   * along with WinPT; if not, write to the Free Software Foundation,
18   * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA   * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19   */   */
20    
21  #include <windows.h>  #ifdef HAVE_CONFIG_H
22  #include <time.h>  #include <config.h>
23    #endif
24  #include "gpgme.h"  
25  #include "wptCard.h"  #include <windows.h>
26  #include "wptCardEdit.h"  #include <windows.h>
27  #include "wptGPG.h"  #include <time.h>
28  #include "wptErrors.h"  
29    #include "gpgme.h"
30  /* Create a new Smartcard context. */  #include "wptCard.h"
31  static gpgme_error_t  #include "wptCardEdit.h"
32  gpg_card_new (gpg_card_t *ret_card)  #include "wptGPG.h"
33  {  #include "wptErrors.h"
34      gpg_card_t c;  
35    /* Create a new Smartcard context. */
36      if (!ret_card)  static gpgme_error_t
37          return gpg_error (GPG_ERR_INV_ARG);  gpg_card_new (gpg_card_t *ret_card)
38      *ret_card = NULL;  {
39      c = (gpg_card_t)calloc (1, sizeof *c);      gpg_card_t c;
40      if (!c)  
41          return gpg_error (GPG_ERR_ENOMEM);      if (!ret_card)
42      *ret_card = c;          return gpg_error (GPG_ERR_INV_ARG);
43      return 0;      *ret_card = NULL;
44  }      c = (gpg_card_t)calloc (1, sizeof *c);
45        if (!c)
46            return gpg_error (GPG_ERR_ENOMEM);
47  /* Release an existing Smartcard context. @card. */      *ret_card = c;
48  void      return 0;
49  gpg_card_release (gpg_card_t card)  }
50  {  
51      int i;  
52    /* Release an existing Smartcard context. @card. */
53      if (!card)  void
54          return;  gpg_card_release (gpg_card_t card)
55      if (card->aid)  {
56          free (card->aid);        int i;
57      if (card->version)  
58          free (card->version);      if (!card)
59      if (card->lang)          return;
60          free (card->lang);      if (card->aid)
61      if (card->login)          free (card->aid);  
62          free (card->login);      if (card->version)
63      for (i=0; i < 3; i++) {          free (card->version);
64          if (card->fpr[i])      if (card->lang)
65              free (card->fpr[i]);          free (card->lang);
66          if (card->ca_fpr[i])      if (card->login)
67              free (card->ca_fpr[i]);          free (card->login);
68          if (card->fpr_created_str[i])      for (i=0; i < 3; i++) {
69              free (card->fpr_created_str[i]);          if (card->fpr[i])
70      }              free (card->fpr[i]);
71      if (card->surname)          if (card->ca_fpr[i])
72          free (card->surname);              free (card->ca_fpr[i]);
73      if (card->givenname)          if (card->fpr_created_str[i])
74          free (card->givenname);              free (card->fpr_created_str[i]);
75      if (card->serial)      }
76          free (card->serial);      if (card->surname)
77      if (card->vendor)          free (card->surname);
78          free (card->vendor);      if (card->givenname)
79      if (card->url)          free (card->givenname);
80          free (card->url);      if (card->serial)
81      if (card->card_type)          free (card->serial);
82          free (card->card_type);      if (card->vendor)
83      free (card);          free (card->vendor);
84        if (card->url)
85  }          free (card->url);
86        if (card->card_type)
87            free (card->card_type);
88  /* Parse the timestamp @long_ts and return a string      free (card);
89     representation of it (format: YYYY-DD-MM HH:MM:SS). */  
90  static char*  }
91  get_str_timestamp (long long_ts)  
92  {  
93      struct tm *tm;  /* Parse the timestamp @long_ts and return a string
94      char *p, *fmt;     representation of it (format: YYYY-DD-MM HH:MM:SS). */
95    static char*
96      tm = localtime (&long_ts);  get_str_timestamp (long long_ts)
97      fmt = "%04d-%02d-%02d %02d:%02d:%02d";  {
98      p = (char*)calloc (1, strlen (fmt)+32);      struct tm *tm;
99      if (!p)      char *p, *fmt;
100          abort ();  
101      sprintf (p, fmt,      tm = localtime (&long_ts);
102               tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,      fmt = "%04d-%02d-%02d %02d:%02d:%02d";
103               tm->tm_hour, tm->tm_min, tm->tm_sec);      p = (char*)calloc (1, strlen (fmt)+32);
104      return p;      if (!p)
105  }          abort ();
106        sprintf (p, fmt,
107                 tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
108  /* Colon handler for parsing the GPG card colon output. */               tm->tm_hour, tm->tm_min, tm->tm_sec);
109  static gpgme_error_t      return p;
110  statuscard_colon_handler (gpg_card_t card, char * line)  }
111  {  
112      enum rectype_t {  
113          CARD_None = 0,  /* Colon handler for parsing the GPG card colon output. */
114          CARD_AID,  static gpgme_error_t
115          CARD_Version,  statuscard_colon_handler (gpg_card_t card, char * line)
116          CARD_Vendor,  {
117          CARD_Serial,      enum rectype_t {
118          CARD_Name,          CARD_None = 0,
119          CARD_Lang,          CARD_AID,
120          CARD_Sex,          CARD_Version,
121          CARD_Url,          CARD_Vendor,
122          CARD_Login,          CARD_Serial,
123          CARD_MaxPinLen,          CARD_Name,
124          CARD_SigCount,          CARD_Lang,
125          CARD_CAFpr,          CARD_Sex,
126          CARD_Fpr,          CARD_Url,
127          CARD_FprTime          CARD_Login,
128      };          CARD_MaxPinLen,
129      enum rectype_t rectype;              CARD_SigCount,
130      char *p, *pend;          CARD_CAFpr,
131      int field = 0;          CARD_Fpr,
132            CARD_FprTime
133      if (!line)      };
134          return gpg_error (GPG_ERR_EOF);      enum rectype_t rectype;    
135        char *p, *pend;
136      for (p = line; p; p = pend) {      int field = 0;
137          field++;  
138          pend = strchr (p, ':');      if (!line)
139          if (pend)          return gpg_error (GPG_ERR_EOF);
140              *pend++ = 0;  
141        for (p = line; p; p = pend) {
142          if (field == 1) {          field++;
143              if (!strcmp (p, "AID"))          pend = strchr (p, ':');
144                  rectype = CARD_AID;          if (pend)
145              else if( !strcmp( p, "version" ) )              *pend++ = 0;
146                  rectype = CARD_Version;  
147              else if( !strcmp( p, "vendor" ) )          if (field == 1) {
148                  rectype = CARD_Vendor;              if (!strcmp (p, "AID"))
149              else if( !strcmp( p, "serial" ) )                  rectype = CARD_AID;
150                  rectype = CARD_Serial;              else if( !strcmp( p, "version" ) )
151              else if( !strcmp( p, "name" ) )                  rectype = CARD_Version;
152                  rectype = CARD_Name;              else if( !strcmp( p, "vendor" ) )
153              else if( !strcmp( p, "lang" ) )                  rectype = CARD_Vendor;
154                  rectype = CARD_Lang;              else if( !strcmp( p, "serial" ) )
155              else if( !strcmp( p, "sex" ) )                  rectype = CARD_Serial;
156                  rectype = CARD_Sex;              else if( !strcmp( p, "name" ) )
157              else if( !strcmp( p, "url" ) )                  rectype = CARD_Name;
158                  rectype = CARD_Url;              else if( !strcmp( p, "lang" ) )
159              else if( !strcmp( p, "login" ) )                  rectype = CARD_Lang;
160                  rectype = CARD_Login;              else if( !strcmp( p, "sex" ) )
161              else if( !strcmp( p, "maxpinlen" ) )                  rectype = CARD_Sex;
162                  rectype = CARD_MaxPinLen;              else if( !strcmp( p, "url" ) )
163              else if( !strcmp( p, "sigcount" ) )                  rectype = CARD_Url;
164                  rectype = CARD_SigCount;              else if( !strcmp( p, "login" ) )
165              else if (!strcmp (p, "cafpr"))                  rectype = CARD_Login;
166                  rectype = CARD_CAFpr;              else if( !strcmp( p, "maxpinlen" ) )
167              else if (!strcmp (p, "fpr"))                  rectype = CARD_MaxPinLen;
168                  rectype = CARD_Fpr;                      else if( !strcmp( p, "sigcount" ) )
169              else if (!strcmp (p, "fprtime"))                  rectype = CARD_SigCount;
170                  rectype = CARD_FprTime;              else if (!strcmp (p, "cafpr"))
171              else                  rectype = CARD_CAFpr;
172                  rectype = CARD_None;              else if (!strcmp (p, "fpr"))
173          }                  rectype = CARD_Fpr;        
174          switch (rectype) {              else if (!strcmp (p, "fprtime"))
175          case CARD_AID:                  rectype = CARD_FprTime;
176              if (field == 2) {              else
177                  card->aid = strdup (p);                  rectype = CARD_None;
178                  if (!card->aid)          }
179                      return gpg_error (GPG_ERR_ENOMEM);          switch (rectype) {
180              }          case CARD_AID:
181              else if (field == 3) {              if (field == 2) {
182                  card->card_type = strdup (p);                  card->aid = strdup (p);
183                  if (!card->card_type)                  if (!card->aid)
184                      return gpg_error (GPG_ERR_ENOMEM);                      return gpg_error (GPG_ERR_ENOMEM);
185              }              }
186              break;              else if (field == 3) {
187                    card->card_type = strdup (p);
188          case CARD_Version:                  if (!card->card_type)
189              if (field == 2) {                      return gpg_error (GPG_ERR_ENOMEM);
190                  card->version = strdup (p);              }
191                  if (!card->version)              break;
192                      return gpg_error (GPG_ERR_ENOMEM);  
193              }          case CARD_Version:
194              break;              if (field == 2) {
195                    card->version = strdup (p);
196          case CARD_Vendor:                  if (!card->version)
197              if (field == 3) {                      return gpg_error (GPG_ERR_ENOMEM);
198                  card->vendor = strdup (p);              }
199                  if (!card->vendor)              break;
200                      return gpg_error (GPG_ERR_ENOMEM);  
201              }          case CARD_Vendor:
202              break;              if (field == 3) {
203                    card->vendor = strdup (p);
204          case CARD_Serial:                  if (!card->vendor)
205              if (field == 2) {                      return gpg_error (GPG_ERR_ENOMEM);
206                  card->serial = strdup (p);              }
207                  if (!card->serial)              break;
208                      return gpg_error (GPG_ERR_ENOMEM);  
209              }          case CARD_Serial:
210              break;              if (field == 2) {
211          case CARD_Name:                  card->serial = strdup (p);
212              if (field == 2) {                  if (!card->serial)
213                  card->givenname = strdup (p);                      return gpg_error (GPG_ERR_ENOMEM);
214                  if (!card->givenname)              }
215                      return gpg_error (GPG_ERR_ENOMEM);              break;
216              }          case CARD_Name:
217              else if (field == 3) {              if (field == 2) {
218                  card->surname = strdup (p);                  card->givenname = strdup (p);
219                  if (!card->surname)                  if (!card->givenname)
220                      return gpg_error (GPG_ERR_ENOMEM);                      return gpg_error (GPG_ERR_ENOMEM);
221              }              }
222              break;              else if (field == 3) {
223          case CARD_Lang:                  card->surname = strdup (p);
224              if( field == 2 ) {                  if (!card->surname)
225                  card->lang = strdup (p);                      return gpg_error (GPG_ERR_ENOMEM);
226                  if (!card->lang)              }
227                      return gpg_error (GPG_ERR_ENOMEM);              break;
228              }          case CARD_Lang:
229              break;              if( field == 2 ) {
230          case CARD_Sex:                  card->lang = strdup (p);
231              if( field == 2 )                  if (!card->lang)
232                  card->sex = *p;                      return gpg_error (GPG_ERR_ENOMEM);
233              break;              }
234                break;
235          case CARD_Url:          case CARD_Sex:
236              if( field == 2 ) {              if( field == 2 )
237                  if (card->url)                  card->sex = *p;
238                      free (card->url);              break;
239                  card->url = (char*)calloc (1, strlen (p) + 1);  
240                  if( !card->url ) {          case CARD_Url:
241                      return gpg_error (GPG_ERR_ENOMEM);              if( field == 2 ) {
242                  }                  if (card->url)
243                  gpg_decode_c_string (p, &card->url, strlen (p) + 1);                      free (card->url);
244                  if (!card->url)                  card->url = (char*)calloc (1, strlen (p) + 1);
245                      return gpg_error (GPG_ERR_ENOMEM);                  if( !card->url ) {
246              }                      return gpg_error (GPG_ERR_ENOMEM);
247              break;                  }
248                    gpg_decode_c_string (p, &card->url, strlen (p) + 1);
249          case CARD_Login:                  if (!card->url)
250              if (field == 2) {                      return gpg_error (GPG_ERR_ENOMEM);
251                  card->login = strdup (p);              }
252                  if (!card->login)              break;
253                      return gpg_error (GPG_ERR_ENOMEM);  
254              }          case CARD_Login:
255              break;              if (field == 2) {
256                    card->login = strdup (p);
257          case CARD_MaxPinLen:                  if (!card->login)
258              break;                      return gpg_error (GPG_ERR_ENOMEM);
259                }
260          case CARD_SigCount:              break;
261              if (field == 2)  
262                  card->sig_count = atol (p);          case CARD_MaxPinLen:
263              break;              break;
264    
265          case CARD_CAFpr:          case CARD_SigCount:
266              if (!p)              if (field == 2)
267                  break;                  card->sig_count = atol (p);
268              if (field > 4 || field == 1)              break;
269                  break;  
270              card->ca_fpr[field-2] = strdup (p);          case CARD_CAFpr:
271              if (!card->ca_fpr[field-2])              if (!p)
272                  return gpg_error (GPG_ERR_ENOMEM);                  break;
273              break;              if (field > 4 || field == 1)
274                    break;
275          case CARD_Fpr:              card->ca_fpr[field-2] = strdup (p);
276              if (field > 4 || field == 1) /* max 3 fprs */              if (!card->ca_fpr[field-2])
277                  break;                  return gpg_error (GPG_ERR_ENOMEM);
278              card->fpr[field-2] = strdup (p);              break;
279              if (!card->fpr[field-2])  
280                  return gpg_error (GPG_ERR_ENOMEM);          case CARD_Fpr:
281              break;              if (field > 4 || field == 1) /* max 3 fprs */
282                    break;
283          case CARD_FprTime:              card->fpr[field-2] = strdup (p);
284              if (field > 4 || field == 1)              if (!card->fpr[field-2])
285                  break;                  return gpg_error (GPG_ERR_ENOMEM);
286              card->fpr_created[field-2] = strtoul (p, NULL, 10);              break;
287              card->fpr_created_str[field-2] = get_str_timestamp (strtoul (p, NULL, 10));  
288              if (!card->fpr_created_str[field-2])          case CARD_FprTime:
289                  return gpg_error (GPG_ERR_ENOMEM);              if (field > 4 || field == 1)
290              break;                  break;
291                card->fpr_created[field-2] = strtoul (p, NULL, 10);
292          }              card->fpr_created_str[field-2] = get_str_timestamp (strtoul (p, NULL, 10));
293      }              if (!card->fpr_created_str[field-2])
294      return 0;                  return gpg_error (GPG_ERR_ENOMEM);
295  }              break;
296    
297            }
298  /* Dummy handler to get the colon data and then quit. */      }
299  static gpgme_error_t      return 0;
300  list_handler (void *opaque, gpgme_status_code_t code, const char *key, int fd)  }
301  {  
302      static int wait_card=0;  
303      GpgCardEdit *ce = (GpgCardEdit *)opaque;  /* Dummy handler to get the colon data and then quit. */
304      const char *s="";      static gpgme_error_t
305      DWORD n;  list_handler (void *opaque, gpgme_status_code_t code, const char *key, int fd)
306            {
307        static int wait_card=0;
308      if (code == GPGME_STATUS_CARDCTRL) {      GpgCardEdit *ce = (GpgCardEdit *)opaque;
309          if (!strcmp (key, "5"))      const char *s="";    
310              ce->setResult (GPG_CARDRES_NOCARD);      DWORD n;
311          else if (!strcmp (key, "1"))          
312              wait_card = 1;  
313      }      if (code == GPGME_STATUS_CARDCTRL) {
314      if (wait_card && !strcmp (key, "cardctrl.insert_card.okay")) {          if (!strcmp (key, "5"))
315          n = MessageBox (NULL, _("Please insert the card and click OK or Cancel to abort."),              ce->setResult (GPG_CARDRES_NOCARD);
316                          _("GPG Card Status"), MB_ICONQUESTION|MB_OKCANCEL);          else if (!strcmp (key, "1"))
317          if (n == IDCANCEL) {              wait_card = 1;
318              ce->setResult (GPG_CARDRES_CANCEL);      }
319              WriteFile ((HANDLE)fd, "c\n", 2, &n, NULL);      if (wait_card && !strcmp (key, "cardctrl.insert_card.okay")) {
320              wait_card = 0;          n = MessageBox (NULL, _("Please insert the card and click OK or Cancel to abort."),
321          }                          _("GPG Card Status"), MB_ICONQUESTION|MB_OKCANCEL);
322      }          if (n == IDCANCEL) {
323      if (!strcmp (key, "cardedit.prompt")) {              ce->setResult (GPG_CARDRES_CANCEL);
324          s = "quit\n";              WriteFile ((HANDLE)fd, "c\n", 2, &n, NULL);
325          if (!WriteFile ((HANDLE)fd, s, strlen (s), &n, NULL))              wait_card = 0;
326              log_debug ("list_handler: WriteFile() failed ec=%d\r\n",          }
327                         (int)GetLastError ());      }
328          wait_card = 0;      if (!strcmp (key, "cardedit.prompt")) {
329      }          s = "quit\n";
330      return 0;          if (!WriteFile ((HANDLE)fd, s, strlen (s), &n, NULL))
331  }              log_debug ("list_handler: WriteFile() failed ec=%d\r\n",
332                           (int)GetLastError ());
333            wait_card = 0;
334  /* Construct an empty object. */      }
335  GpgCardEdit::GpgCardEdit (void)      return 0;
336  {  }
337      pin = NULL;  
338      pin_new = NULL;  
339      admin_pin = NULL;  /* Construct an empty object. */
340    GpgCardEdit::GpgCardEdit (void)
341      keygen.comment = NULL;  {
342      keygen.email = NULL;      pin = NULL;
343      keygen.name = NULL;      pin_new = NULL;
344      keygen.expdate = NULL;      admin_pin = NULL;
345      keygen.key_fpr = NULL;  
346        keygen.comment = NULL;
347      type = 0;      keygen.email = NULL;
348      cnt = 0;      keygen.name = NULL;
349      cancel = 0;      keygen.expdate = NULL;
350      result = 0;      keygen.key_fpr = NULL;
351    
352      gpgme_new (&ctx); /* XXX: check return code */      type = 0;
353  }      cnt = 0;
354        cancel = 0;
355  /* Release the object. */      result = 0;
356  GpgCardEdit::~GpgCardEdit (void)  
357  {          gpgme_new (&ctx); /* XXX: check return code */
358      if (keygen.name)  }
359          free (keygen.name);  
360      if (keygen.comment)  /* Release the object. */
361          free (keygen.comment);  GpgCardEdit::~GpgCardEdit (void)
362      if (keygen.email)  {    
363          free (keygen.email);      if (keygen.name)
364      if (keygen.expdate)          free (keygen.name);
365          free (keygen.expdate);      if (keygen.comment)
366      if (keygen.key_fpr)          free (keygen.comment);
367          free (keygen.key_fpr);      if (keygen.email)
368      gpgme_release (ctx);          free (keygen.email);
369  }      if (keygen.expdate)
370            free (keygen.expdate);
371        if (keygen.key_fpr)
372  /* Set the user PIN for the object to @pin. */          free (keygen.key_fpr);
373  void      gpgme_release (ctx);
374  GpgCardEdit::setPIN (const char *pin)  }
375  {  
376      this->pin = pin;  
377  }  /* Set the user PIN for the object to @pin. */
378    void
379  /* Set the admin PIN for the object to @admin_pin. */  GpgCardEdit::setPIN (const char *pin)
380  void  {
381  GpgCardEdit::setAdminPIN (const char *admin_pin)      this->pin = pin;
382  {  }
383      this->admin_pin = admin_pin;  
384  }  /* Set the admin PIN for the object to @admin_pin. */
385    void
386    GpgCardEdit::setAdminPIN (const char *admin_pin)
387  /* Set the new user PIN for the object to @new_pin. */  {
388  void      this->admin_pin = admin_pin;
389  GpgCardEdit::setNewPIN (const char *new_pin)  }
390  {  
391      this->pin_new = new_pin;  
392  }  /* Set the new user PIN for the object to @new_pin. */
393    void
394    GpgCardEdit::setNewPIN (const char *new_pin)
395  /* Set the passphrase needed when generating a key to @pass. */  {
396  void      this->pin_new = new_pin;
397  GpgCardEdit::setKeygenPassphrase (const char *pass)  }
398  {  
399      this->keygen.pass = pass;  
400  }  /* Set the passphrase needed when generating a key to @pass. */
401    void
402    GpgCardEdit::setKeygenPassphrase (const char *pass)
403  /* Set the callback to @cb and the hook value to @cb_value. */  {
404  void      this->keygen.pass = pass;
405  GpgCardEdit::setCallback (const char* (*cb)(int code, void *opaque),  }
406                            void *cb_value)  
407  {  
408      this->cb_value = cb_value;  /* Set the callback to @cb and the hook value to @cb_value. */
409      this->card_cb = cb;  void
410  }  GpgCardEdit::setCallback (const char* (*cb)(int code, void *opaque),
411                              void *cb_value)
412    {
413  /* Read the information from the inserted card and return      this->cb_value = cb_value;
414     it in form of a card context @r_card.      this->card_cb = cb;
415     Return value: 0 on success. */  }
416  gpgme_error_t  
417  GpgCardEdit::getCardStatus (gpg_card_t *r_card)  
418  {  /* Read the information from the inserted card and return
419      gpgme_data_t out = NULL;     it in form of a card context @r_card.
420      gpgme_error_t err;     Return value: 0 on success. */
421      gpg_card_t card=NULL;  gpgme_error_t
422      char buf[200];  GpgCardEdit::getCardStatus (gpg_card_t *r_card)
423    {
424      if (!r_card)      gpgme_data_t out = NULL;
425          return gpg_error (GPG_ERR_INV_ARG);      gpgme_error_t err;
426        gpg_card_t card=NULL;
427      err = gpg_card_new (&card);      char buf[200];
428      if (err)  
429          return err;      if (!r_card)
430            return gpg_error (GPG_ERR_INV_ARG);
431      err = gpgme_data_new (&out);  
432      if (err) {      err = gpg_card_new (&card);
433          gpg_card_release (card);      if (err)
434          return err;          return err;
435      }  
436            err = gpgme_data_new (&out);
437      err = gpgme_op_card_edit  (ctx, NULL, list_handler, this, out);      if (err) {
438      gpgme_data_rewind (out);          gpg_card_release (card);
439      if (err) {          return err;
440          gpgme_data_release (out);      }
441          gpg_card_release (card);      
442          return err;      err = gpgme_op_card_edit  (ctx, NULL, list_handler, this, out);
443      }      gpgme_data_rewind (out);
444      if (getResult () & GPG_CARDRES_NOCARD ||      if (err) {
445          getResult () & GPG_CARDRES_CANCEL) {          gpgme_data_release (out);
446          gpg_card_release (card);          gpg_card_release (card);
447          gpgme_data_release (out);          return err;
448          return gpg_error (GPG_ERR_CARD_NOT_PRESENT);      }
449      }      if (getResult () & GPG_CARDRES_NOCARD ||
450            getResult () & GPG_CARDRES_CANCEL) {
451      *r_card = card;          gpg_card_release (card);
452      while (gpg_data_readline (out, buf, sizeof (buf)-2) > 0) {          gpgme_data_release (out);
453          err = statuscard_colon_handler (card, buf);          return gpg_error (GPG_ERR_CARD_NOT_PRESENT);
454          if (err)      }
455              break;  
456      }      *r_card = card;
457      gpgme_data_release (out);      while (gpg_data_readline (out, buf, sizeof (buf)-2) > 0) {
458            err = statuscard_colon_handler (card, buf);
459      return err;          if (err)
460  }              break;
461        }
462        gpgme_data_release (out);
463  /* Generate a key on a smart card with the following params:  
464     @flags: user specific params.      return err;
465     @name: name of the key holder.  }
466     @email: email of the key holder.  
467     @comment: optional comment.  
468     @valid: how long is the key valid in days.  /* Generate a key on a smart card with the following params:
469     Return value: 0 on success. */     @flags: user specific params.
470  gpgme_error_t     @name: name of the key holder.
471  GpgCardEdit::genKey (int flags, const char *name,     @email: email of the key holder.
472                       const char *email, const char *comment, long valid,     @comment: optional comment.
473                       char **r_key_fpr)     @valid: how long is the key valid in days.
474  {     Return value: 0 on success. */
475      gpgme_error_t err;  gpgme_error_t
476    GpgCardEdit::genKey (int flags, const char *name,
477      if (!name || !email)                       const char *email, const char *comment, long valid,
478          return gpg_error (GPG_ERR_INV_ARG);                       char **r_key_fpr)
479      if (!this->keygen.pass)  {
480          return gpg_error (GPG_ERR_INV_OBJ);      gpgme_error_t err;
481    
482      type = GPG_EDITCARD_GENKEY;      if (!name || !email)
483      this->keygen.flags = flags;          return gpg_error (GPG_ERR_INV_ARG);
484        if (!this->keygen.pass)
485      if (this->keygen.name)          return gpg_error (GPG_ERR_INV_OBJ);
486          free (this->keygen.name);  
487      this->keygen.name = strdup (name);      type = GPG_EDITCARD_GENKEY;
488      if (this->keygen.email)      this->keygen.flags = flags;
489          free (this->keygen.email);  
490      this->keygen.email = strdup (email);      if (this->keygen.name)
491      if (this->keygen.comment)          free (this->keygen.name);
492          free (this->keygen.comment);      this->keygen.name = strdup (name);
493      this->keygen.comment = comment? strdup (comment) : strdup ("");      if (this->keygen.email)
494      if (this->keygen.expdate)          free (this->keygen.email);
495          free (this->keygen.expdate);      this->keygen.email = strdup (email);
496      this->keygen.expdate = (char*)calloc (1, 16);      if (this->keygen.comment)
497      if (this->keygen.expdate)          free (this->keygen.comment);
498          sprintf (this->keygen.expdate, "%d", valid);      this->keygen.comment = comment? strdup (comment) : strdup ("");
499        if (this->keygen.expdate)
500      if (!this->keygen.name || !this->keygen.email)          free (this->keygen.expdate);
501          return gpg_error (GPG_ERR_ENOMEM);      this->keygen.expdate = (char*)calloc (1, 16);
502        if (this->keygen.expdate)
503      err = gpg_card_edit (ctx, this);          sprintf (this->keygen.expdate, "%d", valid);
504      if (!err)  
505          err = getResult () & GPG_CARDRES_CANCEL? gpg_error (GPG_ERR_CANCELED) : 0;      if (!this->keygen.name || !this->keygen.email)
506      if (!err && r_key_fpr)          return gpg_error (GPG_ERR_ENOMEM);
507          *r_key_fpr = strdup (keygen.key_fpr? keygen.key_fpr : "");  
508      return err;      err = gpg_card_edit (ctx, this);
509  }      if (!err)
510            err = getResult () & GPG_CARDRES_CANCEL? gpg_error (GPG_ERR_CANCELED) : 0;
511        if (!err && r_key_fpr)
512  /* Change the pin from @pin to @pin_new.          *r_key_fpr = strdup (keygen.key_fpr? keygen.key_fpr : "");
513     Return value: 0 on success. */      return err;
514  gpgme_error_t  }
515  GpgCardEdit::changePIN (int type)  
516  {  
517      gpgme_error_t err;  /* Change the pin from @pin to @pin_new.
518       Return value: 0 on success. */
519      if (!this->pin_new)  gpgme_error_t
520          return gpg_error (GPG_ERR_INV_ARG);  GpgCardEdit::changePIN (int type)
521    {
522      if (!type) {      gpgme_error_t err;
523          if (this->pin && this->pin_new)  
524              this->type = GPG_EDITCARD_CHUPIN;      if (!this->pin_new)
525          else if (this->pin && this->admin_pin)          return gpg_error (GPG_ERR_INV_ARG);
526              this->type = GPG_EDITCARD_CHAPIN;  
527          else      if (!type) {
528              this->type = GPG_EDITCARD_UNBPIN;          if (this->pin && this->pin_new)
529      }              this->type = GPG_EDITCARD_CHUPIN;
530      else          else if (this->pin && this->admin_pin)
531          this->type = type;              this->type = GPG_EDITCARD_CHAPIN;
532      /* check if the user provided the needed PIN. */          else
533      if ((this->type == GPG_EDITCARD_CHUPIN && !this->pin) ||              this->type = GPG_EDITCARD_UNBPIN;
534          (this->type == GPG_EDITCARD_CHAPIN && !this->admin_pin))      }
535          return gpg_error (GPG_ERR_INV_ARG);      else
536            this->type = type;
537      err = gpg_card_edit (ctx, this);      /* check if the user provided the needed PIN. */
538      return err;      if ((this->type == GPG_EDITCARD_CHUPIN && !this->pin) ||
539  }          (this->type == GPG_EDITCARD_CHAPIN && !this->admin_pin))
540            return gpg_error (GPG_ERR_INV_ARG);
541    
542  gpgme_error_t      err = gpg_card_edit (ctx, this);
543  GpgCardEdit::updateName (const char *given, const char *sur)      return err;
544  {  }
545      gpgme_error_t err;  
546    
547      if (!this->admin_pin)  gpgme_error_t
548          return gpg_error (GPG_ERR_INV_OBJ);  GpgCardEdit::updateName (const char *given, const char *sur)
549    {
550      this->type = GPG_EDITCARD_NAME;      gpgme_error_t err;
551      this->edit.surname = sur;  
552      this->edit.givenname = given;      if (!this->admin_pin)
553            return gpg_error (GPG_ERR_INV_OBJ);
554      err = gpg_card_edit (ctx, this);  
555      return err;      this->type = GPG_EDITCARD_NAME;
556  }      this->edit.surname = sur;
557            this->edit.givenname = given;
558  gpgme_error_t  
559  GpgCardEdit::updateURL (const char *url)      err = gpg_card_edit (ctx, this);
560  {      return err;
561      gpgme_error_t err;  }
562        
563      if (!this->admin_pin)  gpgme_error_t
564          return gpg_error (GPG_ERR_INV_OBJ);  GpgCardEdit::updateURL (const char *url)
565    {
566      type = GPG_EDITCARD_KEYURL;      gpgme_error_t err;
567      this->edit.keyurl = url;  
568        if (!this->admin_pin)
569      err = gpg_card_edit (ctx, this);          return gpg_error (GPG_ERR_INV_OBJ);
570      return err;  
571  }      type = GPG_EDITCARD_KEYURL;
572        this->edit.keyurl = url;
573    
574  gpgme_error_t      err = gpg_card_edit (ctx, this);
575  GpgCardEdit::updateLogin (const char *login)      return err;
576  {  }
577      gpgme_error_t err;  
578    
579      if (!this->admin_pin)  gpgme_error_t
580          return gpg_error (GPG_ERR_INV_OBJ);  GpgCardEdit::updateLogin (const char *login)
581    {
582      this->type = GPG_EDITCARD_LOGIN;      gpgme_error_t err;
583      this->edit.login = login;  
584        if (!this->admin_pin)
585      err = gpg_card_edit (ctx, this);          return gpg_error (GPG_ERR_INV_OBJ);
586      return err;  
587  }      this->type = GPG_EDITCARD_LOGIN;
588        this->edit.login = login;
589  gpgme_error_t  
590  GpgCardEdit::updateSex (char sex)      err = gpg_card_edit (ctx, this);
591  {      return err;
592      gpgme_error_t err;  }
593    
594      if (!this->admin_pin)  gpgme_error_t
595          return gpg_error (GPG_ERR_INV_OBJ);  GpgCardEdit::updateSex (char sex)
596    {
597      type = GPG_EDITCARD_SEX;      gpgme_error_t err;
598      this->edit.sex = sex;  
599        if (!this->admin_pin)
600      err = gpg_card_edit (ctx, this);          return gpg_error (GPG_ERR_INV_OBJ);
601      return err;  
602  }      type = GPG_EDITCARD_SEX;
603        this->edit.sex = sex;
604  gpgme_error_t  
605  GpgCardEdit::updateLanguage (const char *lang)      err = gpg_card_edit (ctx, this);
606  {      return err;
607      gpgme_error_t err;  }
608    
609      if (!this->admin_pin)  gpgme_error_t
610          return gpg_error (GPG_ERR_INV_OBJ);  GpgCardEdit::updateLanguage (const char *lang)
611    {
612      type = GPG_EDITCARD_LANG;      gpgme_error_t err;
613      this->edit.lang = lang;  
614        if (!this->admin_pin)
615      err = gpg_card_edit (ctx, this);          return gpg_error (GPG_ERR_INV_OBJ);
616      return err;  
617  }      type = GPG_EDITCARD_LANG;
618        this->edit.lang = lang;
619    
620  /* Fetch the key specified by the url stored on the card.      err = gpg_card_edit (ctx, this);
621     Return value: 0 on success. */      return err;
622  gpgme_error_t  }
623  GpgCardEdit::fetchKey (void)  
624  {  
625      gpgme_error_t err = 0;  /* Fetch the key specified by the url stored on the card.
626       Return value: 0 on success. */
627      if (!this->pin)  gpgme_error_t
628          return gpg_error (GPG_ERR_INV_OBJ);  GpgCardEdit::fetchKey (void)
629    {
630      return 0;      gpgme_error_t err = 0;
631  }  
632        if (!this->pin)
633            return gpg_error (GPG_ERR_INV_OBJ);
634  /* Dispatcher for the various commands. @cmd is the card command ID  
635     and @arg1 and @arg2 the actual values for the command.      return 0;
636     Return value: 0 on success. */  }
637  gpgme_error_t  
638  GpgCardEdit:: doCmd (int cmd, const char *arg1, const char *arg2)  
639  {  /* Dispatcher for the various commands. @cmd is the card command ID
640      switch (cmd) {     and @arg1 and @arg2 the actual values for the command.
641      case GPG_EDITCARD_NAME:     Return value: 0 on success. */
642          return updateName (arg1, arg2); /* given, surname */  gpgme_error_t
643    GpgCardEdit:: doCmd (int cmd, const char *arg1, const char *arg2)
644      case GPG_EDITCARD_LANG:  {
645          return updateLanguage (arg1); /* lang */      switch (cmd) {
646        case GPG_EDITCARD_NAME:
647      case GPG_EDITCARD_SEX:          return updateName (arg1, arg2); /* given, surname */
648          return updateSex (*arg1); /* sex */  
649        case GPG_EDITCARD_LANG:
650      case GPG_EDITCARD_KEYURL:          return updateLanguage (arg1); /* lang */
651          return updateURL (arg1); /* url */  
652        case GPG_EDITCARD_SEX:
653      case GPG_EDITCARD_LOGIN:          return updateSex (*arg1); /* sex */
654          return updateLogin (arg1); /* login */  
655        case GPG_EDITCARD_KEYURL:
656      default:          return updateURL (arg1); /* url */
657          return gpg_error (GPG_ERR_INV_VALUE);  
658      }      case GPG_EDITCARD_LOGIN:
659            return updateLogin (arg1); /* login */
660      return 0;  
661  }      default:
662            return gpg_error (GPG_ERR_INV_VALUE);
663        }
664  /* Set the result for the executed operation.  
665     The values will be ORed. */      return 0;
666  void  }
667  GpgCardEdit::setResult (int res)  
668  {  
669      result |= res;  /* Set the result for the executed operation.
670  }     The values will be ORed. */
671    void
672    GpgCardEdit::setResult (int res)
673  /* Return the result of the executed operation. */  {
674  int      result |= res;
675  GpgCardEdit::getResult (void)  }
676  {  
677      return result;  
678  }  /* Return the result of the executed operation. */
679    int
680    GpgCardEdit::getResult (void)
681  /* Reset the object state. */  {
682  void      return result;
683  GpgCardEdit::reset (void)  }
684  {  
685      cnt = 0;  
686  }  /* Reset the object state. */
687    void
688    GpgCardEdit::reset (void)
689  /* Return card command type */  {
690  int      cnt = 0;
691  GpgCardEdit::getType (void)  }
692  {  
693      return type;  
694  }  /* Return card command type */
695    int
696    GpgCardEdit::getType (void)
697    {
698        return type;
699    }
Legend:
Removed from v.35  
changed lines
  Added in v.36
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26