/[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 23 by twoaday, Fri Sep 30 10:10:16 2005 UTC revision 27 by twoaday, Tue Oct 18 07:57:13 2005 UTC
# Line 19  Line 19 
19   */   */
20    
21  #include <windows.h>  #include <windows.h>
22  #include <io.h>  #include <time.h>
 #include "w32gpgme.h"  
 #include "wptCardEdit.h"  
23    
24    #include "gpgme.h"
25    #include "wptCard.h"
26    #include "wptCardEdit.h"
27    #include "wptGPG.h"
28    #include "wptErrors.h"
29    
30  /* Create a new Smartcard context. */  /* Create a new Smartcard context. */
31  static gpgme_error_t  static gpgme_error_t
32  gpg_card_new (gpg_card_t * ret_card)  gpg_card_new (gpg_card_t *ret_card)
33  {  {
34      gpg_card_t c;      gpg_card_t c;
35    
# Line 34  gpg_card_new (gpg_card_t * ret_card) Line 37  gpg_card_new (gpg_card_t * ret_card)
37          return gpg_error (GPG_ERR_INV_ARG);          return gpg_error (GPG_ERR_INV_ARG);
38      *ret_card = NULL;      *ret_card = NULL;
39      c = (gpg_card_t)calloc (1, sizeof *c);      c = (gpg_card_t)calloc (1, sizeof *c);
40      if( !c )      if (!c)
41          return gpg_error (GPG_ERR_ENOMEM);          return gpg_error (GPG_ERR_ENOMEM);
42      *ret_card = c;      *ret_card = c;
43      return 0;      return 0;
# Line 57  gpg_card_release (gpg_card_t card) Line 60  gpg_card_release (gpg_card_t card)
60          free (card->lang);          free (card->lang);
61      if (card->login)      if (card->login)
62          free (card->login);          free (card->login);
       
63      for (i=0; i < 3; i++) {      for (i=0; i < 3; i++) {
64          if (card->fpr[i])          if (card->fpr[i])
65              free (card->fpr[i]);              free (card->fpr[i]);
66            if (card->ca_fpr[i])
67                free (card->ca_fpr[i]);
68            if (card->fpr_created_str[i])
69                free (card->fpr_created_str[i]);
70      }      }
71      if (card->surname)      if (card->surname)
72          free (card->surname);          free (card->surname);
# Line 72  gpg_card_release (gpg_card_t card) Line 78  gpg_card_release (gpg_card_t card)
78          free (card->vendor);          free (card->vendor);
79      if (card->url)      if (card->url)
80          free (card->url);          free (card->url);
81        if (card->card_type)
82            free (card->card_type);
83      free (card);      free (card);
84    
85  }  }
86    
87    
88    /* Parse the timestamp @long_ts and return a string
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;
94        char *p, *fmt;
95    
96        tm = localtime (&long_ts);
97        fmt = "%04d-%02d-%02d %02d:%02d:%02d";
98        p = (char*)calloc (1, strlen (fmt)+32);
99        if (!p)
100            abort ();
101        sprintf (p, fmt,
102                 tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
103                 tm->tm_hour, tm->tm_min, tm->tm_sec);
104        return p;
105    }
106    
107    
108  /* Colon handler for parsing the GPG card colon output. */  /* Colon handler for parsing the GPG card colon output. */
109  static gpgme_error_t  static gpgme_error_t
110  statuscard_colon_handler (gpg_card_t *ctx, char * line, int *cnt)  statuscard_colon_handler (gpg_card_t card, char * line)
111  {  {
112      enum rectype_t {      enum rectype_t {
113          CARD_None = 0,          CARD_None = 0,
# Line 94  statuscard_colon_handler (gpg_card_t *ct Line 122  statuscard_colon_handler (gpg_card_t *ct
122          CARD_Login,          CARD_Login,
123          CARD_MaxPinLen,          CARD_MaxPinLen,
124          CARD_SigCount,          CARD_SigCount,
125          CARD_Fpr          CARD_CAFpr,
126      };              CARD_Fpr,
127            CARD_FprTime
128        };
129      enum rectype_t rectype;          enum rectype_t rectype;    
     gpgme_error_t err;  
     gpg_card_t card;  
130      char *p, *pend;      char *p, *pend;
131      int field = 0;      int field = 0;
132    
133      if (!line)      if (!line)
134          return gpg_error (GPG_ERR_EOF);          return gpg_error (GPG_ERR_EOF);
       
     if (!*ctx) {  
         err = gpg_card_new (ctx);  
         return err;  
     }  
     card = *ctx;  
135    
136      for( p = line; p; p = pend ) {      for (p = line; p; p = pend) {
137          field++;          field++;
138          pend = strchr (p, ':');          pend = strchr (p, ':');
139          if (pend)          if (pend)
140              *pend++ = 0;              *pend++ = 0;
141    
142          if (field == 1) {          if (field == 1) {
# Line 140  statuscard_colon_handler (gpg_card_t *ct Line 162  statuscard_colon_handler (gpg_card_t *ct
162                  rectype = CARD_MaxPinLen;                  rectype = CARD_MaxPinLen;
163              else if( !strcmp( p, "sigcount" ) )              else if( !strcmp( p, "sigcount" ) )
164                  rectype = CARD_SigCount;                  rectype = CARD_SigCount;
165              else if( !strcmp( p, "fpr" ) )              else if (!strcmp (p, "cafpr"))
166                  rectype = CARD_Fpr;                  rectype = CARD_CAFpr;
167                else if (!strcmp (p, "fpr"))
168                    rectype = CARD_Fpr;        
169                else if (!strcmp (p, "fprtime"))
170                    rectype = CARD_FprTime;
171              else              else
172                  rectype = CARD_None;                  rectype = CARD_None;
173          }          }
174          switch( rectype ) {          switch (rectype) {
175          case CARD_AID:          case CARD_AID:
176              if( field == 2 ) {              if (field == 2) {
177                  card->aid = strdup (p);                  card->aid = strdup (p);
178                  if (!card->aid)                  if (!card->aid)
179                      return gpg_error (GPG_ERR_ENOMEM);                      return gpg_error (GPG_ERR_ENOMEM);
180              }              }
181                else if (field == 3) {
182                    card->card_type = strdup (p);
183                    if (!card->card_type)
184                        return gpg_error (GPG_ERR_ENOMEM);
185                }
186              break;              break;
187    
188          case CARD_Version:          case CARD_Version:
189              if( field == 2 ) {              if (field == 2) {
190                  card->version = strdup (p);                  card->version = strdup (p);
191                  if (!card->version)                  if (!card->version)
192                      return gpg_error (GPG_ERR_ENOMEM);                      return gpg_error (GPG_ERR_ENOMEM);
193              }              }
194              break;              break;
195    
196          case CARD_Vendor:          case CARD_Vendor:
197              if( field == 3 ) {              if (field == 3) {
198                  card->vendor = strdup( p );                  card->vendor = strdup (p);
199                  if (!card->vendor)                  if (!card->vendor)
200                      return gpg_error (GPG_ERR_ENOMEM);                      return gpg_error (GPG_ERR_ENOMEM);
201              }              }
202              break;              break;
203    
204          case CARD_Serial:          case CARD_Serial:
205              if( field == 2 ) {              if (field == 2) {
206                  card->serial = strdup( p );                  card->serial = strdup (p);
207                  if (!card->serial)                  if (!card->serial)
208                      return gpg_error (GPG_ERR_ENOMEM);                      return gpg_error (GPG_ERR_ENOMEM);
209              }              }
210              break;              break;
211          case CARD_Name:          case CARD_Name:
212              if( field == 2 ) {              if (field == 2) {
213                  card->givenname = strdup( p );                  card->givenname = strdup (p);
214                  if (!card->givenname)                  if (!card->givenname)
215                      return gpg_error (GPG_ERR_ENOMEM);                      return gpg_error (GPG_ERR_ENOMEM);
216              }              }
217              else if( field == 3 ) {              else if (field == 3) {
218                  card->surname = strdup( p );                  card->surname = strdup (p);
219                  if (!card->surname)                  if (!card->surname)
220                      return gpg_error (GPG_ERR_ENOMEM);                      return gpg_error (GPG_ERR_ENOMEM);
221              }              }
222              break;              break;
223          case CARD_Lang:          case CARD_Lang:
224              if( field == 2 ) {              if( field == 2 ) {
225                  card->lang = strdup( p );                  card->lang = strdup (p);
226                  if (!card->lang)                  if (!card->lang)
227                      return gpg_error (GPG_ERR_ENOMEM);                      return gpg_error (GPG_ERR_ENOMEM);
228              }              }
# Line 197  statuscard_colon_handler (gpg_card_t *ct Line 231  statuscard_colon_handler (gpg_card_t *ct
231              if( field == 2 )              if( field == 2 )
232                  card->sex = *p;                  card->sex = *p;
233              break;              break;
234    
235          case CARD_Url:          case CARD_Url:
236              if( field == 2 ) {              if( field == 2 ) {
237                  if (card->url)                  if (card->url)
238                      free (card->url);                      free (card->url);
239                  /*                  card->url = (char*)calloc (1, strlen (p) + 1);
                 card->url = calloc( 1, strlen( p ) + 1 );  
240                  if( !card->url ) {                  if( !card->url ) {
241                      return; // XXX                      return gpg_error (GPG_ERR_ENOMEM);
242                  }                  }
243                  _gpgme_decode_c_string (p, &card->url, strlen (p) + 1);                  gpg_decode_c_string (p, &card->url, strlen (p) + 1);
                 */  
                 card->url = strdup (p); /* XXX */  
244                  if (!card->url)                  if (!card->url)
245                      return gpg_error (GPG_ERR_ENOMEM);                      return gpg_error (GPG_ERR_ENOMEM);
246              }              }
247              break;              break;
248    
249          case CARD_Login:          case CARD_Login:
250              if( field == 2 ) {              if (field == 2) {
251                  card->login = strdup (p);                  card->login = strdup (p);
252                  if (!card->login)                  if (!card->login)
253                      return gpg_error (GPG_ERR_ENOMEM);                      return gpg_error (GPG_ERR_ENOMEM);
254              }              }
255              break;              break;
256    
257          case CARD_MaxPinLen:          case CARD_MaxPinLen:
258              break;              break;
259    
260          case CARD_SigCount:          case CARD_SigCount:
261              if( field == 2 )              if (field == 2)
262                  card->sig_count = atol( p );                  card->sig_count = atol (p);
263              break;              break;
264    
265            case CARD_CAFpr:
266                if (!p)
267                    break;
268                if (field > 4 || field == 1)
269                    break;
270                card->ca_fpr[field-2] = strdup (p);
271                if (!card->ca_fpr[field-2])
272                    return gpg_error (GPG_ERR_ENOMEM);
273                break;
274    
275          case CARD_Fpr:          case CARD_Fpr:
276              if( field == 2 || field == 3 || field == 4 ) {              if (field > 4 || field == 1) /* max 3 fprs */
277                  card->fpr[(*cnt)++] = strdup( p );                  break;
278              }              card->fpr[field-2] = strdup (p);
279                if (!card->fpr[field-2])
280                    return gpg_error (GPG_ERR_ENOMEM);
281                break;
282    
283            case CARD_FprTime:
284                if (field > 4 || field == 1)
285                    break;
286                card->fpr_created[field-2] = strtoul (p, NULL, 10);
287                card->fpr_created_str[field-2] = get_str_timestamp (strtoul (p, NULL, 10));
288                if (!card->fpr_created_str[field-2])
289                    return gpg_error (GPG_ERR_ENOMEM);
290              break;              break;
291    
292          }          }
293      }      }
294      return 0;      return 0;
# Line 241  statuscard_colon_handler (gpg_card_t *ct Line 299  statuscard_colon_handler (gpg_card_t *ct
299  static gpgme_error_t  static gpgme_error_t
300  list_handler (void *opaque, gpgme_status_code_t code, const char *key, int fd)  list_handler (void *opaque, gpgme_status_code_t code, const char *key, int fd)
301  {  {
302      const char *s = "quit\n";      static int wait_card=0;
303      write (fd, s, strlen (s));      GpgCardEdit *ce = (GpgCardEdit *)opaque;
304        const char *s="";    
305        DWORD n;
306            
307    
308        if (code == GPGME_STATUS_CARDCTRL) {
309            if (!strcmp (key, "5"))
310                ce->setResult (GPG_CARDRES_NOCARD);
311            else if (!strcmp (key, "1"))
312                wait_card = 1;
313        }
314        if (wait_card && !strcmp (key, "cardctrl.insert_card.okay")) {
315            n = MessageBox (NULL, _("Please insert the card and click OK or Cancel to abort."),
316                            _("GPG Card Status"), MB_ICONQUESTION|MB_OKCANCEL);
317            if (n == IDCANCEL) {
318                ce->setResult (GPG_CARDRES_CANCEL);
319                WriteFile ((HANDLE)fd, "c\n", 2, &n, NULL);
320                wait_card = 0;
321            }
322        }
323        if (!strcmp (key, "cardedit.prompt")) {
324            s = "quit\n";
325            if (!WriteFile ((HANDLE)fd, s, strlen (s), &n, NULL))
326                log_debug ("list_handler: WriteFile() failed ec=%d\r\n",
327                           (int)GetLastError ());
328            wait_card = 0;
329        }
330      return 0;      return 0;
331  }  }
332    
# Line 254  GpgCardEdit::GpgCardEdit (void) Line 338  GpgCardEdit::GpgCardEdit (void)
338      pin_new = NULL;      pin_new = NULL;
339      admin_pin = NULL;      admin_pin = NULL;
340    
341        keygen.comment = NULL;
342        keygen.email = NULL;
343        keygen.name = NULL;
344        keygen.expdate = NULL;
345        keygen.key_fpr = NULL;
346    
347      type = 0;      type = 0;
348      cnt = 0;      cnt = 0;
349      cancel = 0;      cancel = 0;
350        result = 0;
351    
352      gpgme_new (&ctx);      gpgme_new (&ctx); /* XXX: check return code */
353  }  }
354    
355  /* Release the object. */  /* Release the object. */
356  GpgCardEdit::~GpgCardEdit (void)  GpgCardEdit::~GpgCardEdit (void)
357  {  {    
358      gpgme_release (ctx);          if (keygen.name)
359      if (this->keygen.name)          free (keygen.name);
360          free (this->keygen.name);      if (keygen.comment)
361      if (this->keygen.comment)          free (keygen.comment);
362          free (this->keygen.comment);      if (keygen.email)
363      if (this->keygen.email)          free (keygen.email);
364          free (this->keygen.email);      if (keygen.expdate)
365      if (this->keygen.expdate)          free (keygen.expdate);
366          free (this->keygen.expdate);      if (keygen.key_fpr)
367            free (keygen.key_fpr);
368        gpgme_release (ctx);
369  }  }
370    
371    
# Line 317  GpgCardEdit::setCallback (const char* (* Line 410  GpgCardEdit::setCallback (const char* (*
410  }  }
411    
412    
 void  
 GpgCardEdit::setType (int type)  
 {  
     this->type = type;  
 }  
   
413  /* Read the information from the inserted card and return  /* Read the information from the inserted card and return
414     it in form of a card context @r_card.     it in form of a card context @r_card.
415     Return value: 0 on success. */     Return value: 0 on success. */
416  gpgme_error_t  gpgme_error_t
417  GpgCardEdit::getCardStatus (gpg_card_t *r_card)  GpgCardEdit::getCardStatus (gpg_card_t *r_card)
418  {  {
419      gpgme_data_t tmp = NULL;      gpgme_data_t out = NULL;
420      gpgme_error_t err;      gpgme_error_t err;
421        gpg_card_t card=NULL;
422      char buf[200];      char buf[200];
     int cnt = 0;  
423    
424      if (!r_card)      if (!r_card)
425          return gpg_error (GPG_ERR_INV_ARG);          return gpg_error (GPG_ERR_INV_ARG);
426    
427      err = gpgme_data_new (&tmp);      err = gpg_card_new (&card);
428      if (err)      if (err)
429          return err;          return err;
430    
431        err = gpgme_data_new (&out);
432        if (err) {
433            gpg_card_release (card);
434            return err;
435        }
436            
437      err = gpgme_op_card_edit  (ctx, NULL, list_handler, NULL, tmp);      err = gpgme_op_card_edit  (ctx, NULL, list_handler, this, out);
438        gpgme_data_rewind (out);
439      if (err) {      if (err) {
440          gpgme_data_release (tmp);          gpgme_data_release (out);
441            gpg_card_release (card);
442          return err;          return err;
443      }      }
444        if (getResult () & GPG_CARDRES_NOCARD ||
445            getResult () & GPG_CARDRES_CANCEL) {
446            gpg_card_release (card);
447            gpgme_data_release (out);
448            return gpg_error (GPG_ERR_CARD_NOT_PRESENT);
449        }
450    
451      *r_card=NULL;      *r_card = card;
452      gpgme_data_rewind (tmp);      while (gpg_data_readline (out, buf, sizeof (buf)-2) > 0) {
453      while (gpg_data_readline (tmp, buf, sizeof buf-2) > 0)          err = statuscard_colon_handler (card, buf);
454          statuscard_colon_handler (r_card, buf, &cnt);          if (err)
455      gpgme_data_release (tmp);              break;
456        }
457        gpgme_data_release (out);
458    
459      return err;      return err;
460  }  }
# Line 366  GpgCardEdit::getCardStatus (gpg_card_t * Line 469  GpgCardEdit::getCardStatus (gpg_card_t *
469     Return value: 0 on success. */     Return value: 0 on success. */
470  gpgme_error_t  gpgme_error_t
471  GpgCardEdit::genKey (int flags, const char *name,  GpgCardEdit::genKey (int flags, const char *name,
472                       const char *email, const char *comment,                       const char *email, const char *comment, long valid,
473                       long valid)                       char **r_key_fpr)
474  {  {
475      gpgme_error_t err;      gpgme_error_t err;
476    
# Line 389  GpgCardEdit::genKey (int flags, const ch Line 492  GpgCardEdit::genKey (int flags, const ch
492          free (this->keygen.comment);          free (this->keygen.comment);
493      this->keygen.comment = comment? strdup (comment) : strdup ("");      this->keygen.comment = comment? strdup (comment) : strdup ("");
494      if (this->keygen.expdate)      if (this->keygen.expdate)
495          free (this->keygen.expdate);              free (this->keygen.expdate);
496      this->keygen.expdate = (char*)calloc (1, 16);      this->keygen.expdate = (char*)calloc (1, 16);
497      if (this->keygen.expdate)      if (this->keygen.expdate)
498          sprintf (this->keygen.expdate, "%d", valid);          sprintf (this->keygen.expdate, "%d", valid);
499    
500      if (!this->keygen.name || !this->keygen.email ||      if (!this->keygen.name || !this->keygen.email)
         !this->keygen.comment || !this->keygen.expdate)  
501          return gpg_error (GPG_ERR_ENOMEM);          return gpg_error (GPG_ERR_ENOMEM);
502    
503      err = gpg_card_edit (ctx, this);      err = gpg_card_edit (ctx, this);
504        if (!err && r_key_fpr)
505            *r_key_fpr = strdup (keygen.key_fpr? keygen.key_fpr : "");
506      return err;      return err;
507  }  }
508    
# Line 406  GpgCardEdit::genKey (int flags, const ch Line 510  GpgCardEdit::genKey (int flags, const ch
510  /* Change the pin from @pin to @pin_new.  /* Change the pin from @pin to @pin_new.
511     Return value: 0 on success. */     Return value: 0 on success. */
512  gpgme_error_t  gpgme_error_t
513  GpgCardEdit::changePIN (void)  GpgCardEdit::changePIN (int type)
514  {  {
515      gpgme_error_t err;      gpgme_error_t err;
516    
517      if (!this->pin || !this->pin_new)      if (!this->pin_new)
518          return gpg_error (GPG_ERR_INV_ARG);          return gpg_error (GPG_ERR_INV_ARG);
519    
520      if (!type) {      if (!type) {
521          if (this->pin && this->pin_new)          if (this->pin && this->pin_new)
522              type = GPG_EDITCARD_CHUPIN;              this->type = GPG_EDITCARD_CHUPIN;
523          else if (this->pin && this->admin_pin)          else if (this->pin && this->admin_pin)
524              type = GPG_EDITCARD_CHAPIN;              this->type = GPG_EDITCARD_CHAPIN;
525          else          else
526              type = GPG_EDITCARD_UNBPIN;              this->type = GPG_EDITCARD_UNBPIN;
527      }      }
528        else
529            this->type = type;
530        /* check if the user provided the needed PIN. */
531        if ((this->type == GPG_EDITCARD_CHUPIN && !this->pin) ||
532            (this->type == GPG_EDITCARD_CHAPIN && !this->admin_pin))
533            return gpg_error (GPG_ERR_INV_ARG);
534    
535      err = gpg_card_edit (ctx, this);      err = gpg_card_edit (ctx, this);
536      return err;      return err;
# Line 432  GpgCardEdit::updateName (const char *giv Line 542  GpgCardEdit::updateName (const char *giv
542  {  {
543      gpgme_error_t err;      gpgme_error_t err;
544    
545      if (!this->pin)      if (!this->admin_pin)
546          return gpg_error (GPG_ERR_INV_OBJ);          return gpg_error (GPG_ERR_INV_OBJ);
547    
548        this->type = GPG_EDITCARD_NAME;
549      this->edit.surname = sur;      this->edit.surname = sur;
550      this->edit.givenname = given;      this->edit.givenname = given;
551    
# Line 447  GpgCardEdit::updateURL (const char *url) Line 558  GpgCardEdit::updateURL (const char *url)
558  {  {
559      gpgme_error_t err;      gpgme_error_t err;
560    
561      if (!this->pin)      if (!this->admin_pin)
562          return gpg_error (GPG_ERR_INV_OBJ);          return gpg_error (GPG_ERR_INV_OBJ);
563    
564        type = GPG_EDITCARD_KEYURL;
565      this->edit.keyurl = url;      this->edit.keyurl = url;
566    
567      err = gpg_card_edit (ctx, this);      err = gpg_card_edit (ctx, this);
# Line 462  GpgCardEdit::updateLogin (const char *lo Line 574  GpgCardEdit::updateLogin (const char *lo
574  {  {
575      gpgme_error_t err;      gpgme_error_t err;
576    
577      if (!this->pin)      if (!this->admin_pin)
578          return gpg_error (GPG_ERR_INV_OBJ);          return gpg_error (GPG_ERR_INV_OBJ);
579    
580        this->type = GPG_EDITCARD_LOGIN;
581      this->edit.login = login;      this->edit.login = login;
582    
583      err = gpg_card_edit (ctx, this);      err = gpg_card_edit (ctx, this);
# Line 476  GpgCardEdit::updateSex (char sex) Line 589  GpgCardEdit::updateSex (char sex)
589  {  {
590      gpgme_error_t err;      gpgme_error_t err;
591    
592      if (!this->pin)      if (!this->admin_pin)
593          return gpg_error (GPG_ERR_INV_OBJ);          return gpg_error (GPG_ERR_INV_OBJ);
594    
595        type = GPG_EDITCARD_SEX;
596      this->edit.sex = sex;      this->edit.sex = sex;
597    
598      err = gpg_card_edit (ctx, this);      err = gpg_card_edit (ctx, this);
599      return err;      return err;
600  }  }
# Line 489  GpgCardEdit::updateLanguage (const char Line 604  GpgCardEdit::updateLanguage (const char
604  {  {
605      gpgme_error_t err;      gpgme_error_t err;
606    
607      if (!this->pin)      if (!this->admin_pin)
608          return gpg_error (GPG_ERR_INV_OBJ);          return gpg_error (GPG_ERR_INV_OBJ);
609    
610        type = GPG_EDITCARD_LANG;
611      this->edit.lang = lang;      this->edit.lang = lang;
612    
613      err = gpg_card_edit (ctx, this);      err = gpg_card_edit (ctx, this);
614      return err;      return err;
615  }  }
# Line 512  GpgCardEdit::fetchKey (void) Line 629  GpgCardEdit::fetchKey (void)
629  }  }
630    
631    
632    /* Dispatcher for the various commands. @cmd is the card command ID
633       and @arg1 and @arg2 the actual values for the command.
634       Return value: 0 on success. */
635  gpgme_error_t  gpgme_error_t
636  GpgCardEdit:: doCmd (int cmd, const char *arg1, const char *arg2)  GpgCardEdit:: doCmd (int cmd, const char *arg1, const char *arg2)
637  {  {
# Line 530  GpgCardEdit:: doCmd (int cmd, const char Line 650  GpgCardEdit:: doCmd (int cmd, const char
650    
651      case GPG_EDITCARD_LOGIN:      case GPG_EDITCARD_LOGIN:
652          return updateLogin (arg1); /* login */          return updateLogin (arg1); /* login */
653    
654        default:
655            return gpg_error (GPG_ERR_INV_VALUE);
656      }      }
657    
658      return 0;      return 0;
659  }  }
660    
661    
662    /* Set the result for the executed operation.
663       The values will be ORed. */
664    void
665    GpgCardEdit::setResult (int res)
666    {
667        result |= res;
668    }
669    
670    
671    /* Return the result of the executed operation. */
672    int
673    GpgCardEdit::getResult (void)
674    {
675        return result;
676    }
677    
678    
679    /* Reset the object state. */
680    void
681    GpgCardEdit::reset (void)
682    {
683        cnt = 0;
684    }
Legend:
Removed from v.23  
changed lines
  Added in v.27
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26