/[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 25 by twoaday, Wed Oct 12 10:04:26 2005 UTC revision 26 by twoaday, Mon Oct 17 08:49:30 2005 UTC
# Line 19  Line 19 
19   */   */
20    
21  #include <windows.h>  #include <windows.h>
22    #include <time.h>
23    
24  #include "gpgme.h"  #include "gpgme.h"
25    #include "wptCard.h"
26  #include "wptCardEdit.h"  #include "wptCardEdit.h"
27  #include "wptGPG.h"  #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
# 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)
# Line 210  statuscard_colon_handler (gpg_card_t *ct Line 245  statuscard_colon_handler (gpg_card_t *ct
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 238  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      static int step=0;      GpgCardEdit *ce = (GpgCardEdit *)opaque;
303      const char *s="";      const char *s="";
304      DWORD n;      DWORD n;
305    
306      if (!strcmp (key, "keyedit.prompt") && step == 0) {      if (code == GPGME_STATUS_CARDCTRL && *key == '5')
307          step = 1;          ce->setResult (GPG_CARDRES_NOCARD);
308          s = "list\n";      if (!strcmp (key, "cardedit.prompt")) {
         WriteFile ((HANDLE)fd, s, strlen (s), &n, NULL);  
     }  
     else if (!strcmp (key, "keyedit.prompt") && step == 1) {  
         step = 0;  
309          s = "quit\n";          s = "quit\n";
310          WriteFile ((HANDLE)fd, s, strlen (s), &n, NULL);          if (!WriteFile ((HANDLE)fd, s, strlen (s), &n, NULL))
311                log_debug ("list_handler: WriteFile() failed ec=%d\r\n",
312                           (int)GetLastError ());
313      }      }
314      return 0;      return 0;
315  }  }
# Line 263  GpgCardEdit::GpgCardEdit (void) Line 322  GpgCardEdit::GpgCardEdit (void)
322      pin_new = NULL;      pin_new = NULL;
323      admin_pin = NULL;      admin_pin = NULL;
324    
325        keygen.comment = NULL;
326        keygen.email = NULL;
327        keygen.name = NULL;
328        keygen.expdate = NULL;
329        keygen.key_fpr = NULL;
330    
331      type = 0;      type = 0;
332      cnt = 0;      cnt = 0;
333      cancel = 0;      cancel = 0;
334        result = 0;
335    
336      gpgme_new (&ctx);      gpgme_new (&ctx); /* XXX: check return code */
337  }  }
338    
339  /* Release the object. */  /* Release the object. */
340  GpgCardEdit::~GpgCardEdit (void)  GpgCardEdit::~GpgCardEdit (void)
341  {  {    
342      gpgme_release (ctx);          if (keygen.name)
343      if (this->keygen.name)          free (keygen.name);
344          free (this->keygen.name);      if (keygen.comment)
345      if (this->keygen.comment)          free (keygen.comment);
346          free (this->keygen.comment);      if (keygen.email)
347      if (this->keygen.email)          free (keygen.email);
348          free (this->keygen.email);      if (keygen.expdate)
349      if (this->keygen.expdate)          free (keygen.expdate);
350          free (this->keygen.expdate);      if (keygen.key_fpr)
351            free (keygen.key_fpr);
352        gpgme_release (ctx);
353  }  }
354    
355    
# Line 326  GpgCardEdit::setCallback (const char* (* Line 394  GpgCardEdit::setCallback (const char* (*
394  }  }
395    
396    
 void  
 GpgCardEdit::setType (int type)  
 {  
     this->type = type;  
 }  
   
397  /* Read the information from the inserted card and return  /* Read the information from the inserted card and return
398     it in form of a card context @r_card.     it in form of a card context @r_card.
399     Return value: 0 on success. */     Return value: 0 on success. */
400  gpgme_error_t  gpgme_error_t
401  GpgCardEdit::getCardStatus (gpg_card_t *r_card)  GpgCardEdit::getCardStatus (gpg_card_t *r_card)
402  {  {
403      gpgme_data_t tmp = NULL;      gpgme_data_t out = NULL;
404        gpgme_key_t key=NULL;    
405      gpgme_error_t err;      gpgme_error_t err;
406        gpg_card_t card=NULL;
407      char buf[200];      char buf[200];
     int cnt = 0;  
408    
409      if (!r_card)      if (!r_card)
410          return gpg_error (GPG_ERR_INV_ARG);          return gpg_error (GPG_ERR_INV_ARG);
411    
412      err = gpgme_data_new (&tmp);      /* XXX: dummy key */
413        key = (gpgme_key_t)calloc (1, sizeof *key);
414        key->subkeys = (gpgme_subkey_t)calloc (1, sizeof *key->subkeys);
415        key->subkeys->fpr = strdup ("foo");
416    
417        err = gpg_card_new (&card);
418      if (err)      if (err)
419          return err;          return err;
420    
421        err = gpgme_data_new (&out);
422        if (err) {
423            gpg_card_release (card);
424            return err;
425        }
426            
427      err = gpgme_op_card_edit  (ctx, NULL, list_handler, NULL, tmp);      err = gpgme_op_card_edit  (ctx, key, list_handler, this, out);
428        gpgme_data_rewind (out);
429      if (err) {      if (err) {
430          gpgme_data_release (tmp);          gpgme_data_release (out);
431            gpg_card_release (card);
432          return err;          return err;
433      }      }
434        if (getResult () & GPG_CARDRES_NOCARD) {
435            gpg_card_release (card);
436            gpgme_data_release (out);
437            return gpg_error (GPG_ERR_CARD_REMOVED);
438        }
439    
440      *r_card=NULL;      *r_card = card;
441      gpgme_data_rewind (tmp);      while (gpg_data_readline (out, buf, sizeof (buf)-2) > 0) {
442      while (gpg_data_readline (tmp, buf, sizeof buf-2) > 0)          err = statuscard_colon_handler (card, buf);
443          statuscard_colon_handler (r_card, buf, &cnt);          if (err)
444      gpgme_data_release (tmp);              break;
445        }
446        gpgme_data_release (out);
447    
448        if (key) { /* XXX */
449            free (key->subkeys->keyid);
450            free (key->subkeys);
451            free (key);
452        }
453    
454      return err;      return err;
455  }  }
# Line 375  GpgCardEdit::getCardStatus (gpg_card_t * Line 464  GpgCardEdit::getCardStatus (gpg_card_t *
464     Return value: 0 on success. */     Return value: 0 on success. */
465  gpgme_error_t  gpgme_error_t
466  GpgCardEdit::genKey (int flags, const char *name,  GpgCardEdit::genKey (int flags, const char *name,
467                       const char *email, const char *comment,                       const char *email, const char *comment, long valid,
468                       long valid)                       char **r_key_fpr)
469  {  {
470      gpgme_error_t err;      gpgme_error_t err;
471    
# Line 398  GpgCardEdit::genKey (int flags, const ch Line 487  GpgCardEdit::genKey (int flags, const ch
487          free (this->keygen.comment);          free (this->keygen.comment);
488      this->keygen.comment = comment? strdup (comment) : strdup ("");      this->keygen.comment = comment? strdup (comment) : strdup ("");
489      if (this->keygen.expdate)      if (this->keygen.expdate)
490          free (this->keygen.expdate);              free (this->keygen.expdate);
491      this->keygen.expdate = (char*)calloc (1, 16);      this->keygen.expdate = (char*)calloc (1, 16);
492      if (this->keygen.expdate)      if (this->keygen.expdate)
493          sprintf (this->keygen.expdate, "%d", valid);          sprintf (this->keygen.expdate, "%d", valid);
494    
495      if (!this->keygen.name || !this->keygen.email ||      if (!this->keygen.name || !this->keygen.email)
         !this->keygen.comment || !this->keygen.expdate)  
496          return gpg_error (GPG_ERR_ENOMEM);          return gpg_error (GPG_ERR_ENOMEM);
497    
498      err = gpg_card_edit (ctx, this);      err = gpg_card_edit (ctx, this);
499        if (!err && r_key_fpr)
500            *r_key_fpr = strdup (keygen.key_fpr? keygen.key_fpr : "");
501      return err;      return err;
502  }  }
503    
# Line 415  GpgCardEdit::genKey (int flags, const ch Line 505  GpgCardEdit::genKey (int flags, const ch
505  /* Change the pin from @pin to @pin_new.  /* Change the pin from @pin to @pin_new.
506     Return value: 0 on success. */     Return value: 0 on success. */
507  gpgme_error_t  gpgme_error_t
508  GpgCardEdit::changePIN (void)  GpgCardEdit::changePIN (int type)
509  {  {
510      gpgme_error_t err;      gpgme_error_t err;
511    
512      if (!this->pin || !this->pin_new)      if (!this->pin_new)
513          return gpg_error (GPG_ERR_INV_ARG);          return gpg_error (GPG_ERR_INV_ARG);
514    
515      if (!type) {      if (!type) {
516          if (this->pin && this->pin_new)          if (this->pin && this->pin_new)
517              type = GPG_EDITCARD_CHUPIN;              this->type = GPG_EDITCARD_CHUPIN;
518          else if (this->pin && this->admin_pin)          else if (this->pin && this->admin_pin)
519              type = GPG_EDITCARD_CHAPIN;              this->type = GPG_EDITCARD_CHAPIN;
520          else          else
521              type = GPG_EDITCARD_UNBPIN;              this->type = GPG_EDITCARD_UNBPIN;
522      }      }
523        else
524            this->type = type;
525        /* check if the user provided the needed PIN. */
526        if ((this->type == GPG_EDITCARD_CHUPIN && !this->pin) ||
527            (this->type == GPG_EDITCARD_CHAPIN && !this->admin_pin))
528            return gpg_error (GPG_ERR_INV_ARG);
529    
530      err = gpg_card_edit (ctx, this);      err = gpg_card_edit (ctx, this);
531      return err;      return err;
# Line 441  GpgCardEdit::updateName (const char *giv Line 537  GpgCardEdit::updateName (const char *giv
537  {  {
538      gpgme_error_t err;      gpgme_error_t err;
539    
540      if (!this->pin)      if (!this->admin_pin)
541          return gpg_error (GPG_ERR_INV_OBJ);          return gpg_error (GPG_ERR_INV_OBJ);
542    
543        this->type = GPG_EDITCARD_NAME;
544      this->edit.surname = sur;      this->edit.surname = sur;
545      this->edit.givenname = given;      this->edit.givenname = given;
546    
# Line 456  GpgCardEdit::updateURL (const char *url) Line 553  GpgCardEdit::updateURL (const char *url)
553  {  {
554      gpgme_error_t err;      gpgme_error_t err;
555    
556      if (!this->pin)      if (!this->admin_pin)
557          return gpg_error (GPG_ERR_INV_OBJ);          return gpg_error (GPG_ERR_INV_OBJ);
558    
559        type = GPG_EDITCARD_KEYURL;
560      this->edit.keyurl = url;      this->edit.keyurl = url;
561    
562      err = gpg_card_edit (ctx, this);      err = gpg_card_edit (ctx, this);
# Line 471  GpgCardEdit::updateLogin (const char *lo Line 569  GpgCardEdit::updateLogin (const char *lo
569  {  {
570      gpgme_error_t err;      gpgme_error_t err;
571    
572      if (!this->pin)      if (!this->admin_pin)
573          return gpg_error (GPG_ERR_INV_OBJ);          return gpg_error (GPG_ERR_INV_OBJ);
574    
575        this->type = GPG_EDITCARD_LOGIN;
576      this->edit.login = login;      this->edit.login = login;
577    
578      err = gpg_card_edit (ctx, this);      err = gpg_card_edit (ctx, this);
# Line 485  GpgCardEdit::updateSex (char sex) Line 584  GpgCardEdit::updateSex (char sex)
584  {  {
585      gpgme_error_t err;      gpgme_error_t err;
586    
587      if (!this->pin)      if (!this->admin_pin)
588          return gpg_error (GPG_ERR_INV_OBJ);          return gpg_error (GPG_ERR_INV_OBJ);
589    
590        type = GPG_EDITCARD_SEX;
591      this->edit.sex = sex;      this->edit.sex = sex;
592    
593      err = gpg_card_edit (ctx, this);      err = gpg_card_edit (ctx, this);
594      return err;      return err;
595  }  }
# Line 498  GpgCardEdit::updateLanguage (const char Line 599  GpgCardEdit::updateLanguage (const char
599  {  {
600      gpgme_error_t err;      gpgme_error_t err;
601    
602      if (!this->pin)      if (!this->admin_pin)
603          return gpg_error (GPG_ERR_INV_OBJ);          return gpg_error (GPG_ERR_INV_OBJ);
604    
605        type = GPG_EDITCARD_LANG;
606      this->edit.lang = lang;      this->edit.lang = lang;
607    
608      err = gpg_card_edit (ctx, this);      err = gpg_card_edit (ctx, this);
609      return err;      return err;
610  }  }
# Line 521  GpgCardEdit::fetchKey (void) Line 624  GpgCardEdit::fetchKey (void)
624  }  }
625    
626    
627    /* Dispatcher for the various commands. @cmd is the card command ID
628       and @arg1 and @arg2 the actual values for the command.
629       Return value: 0 on success. */
630  gpgme_error_t  gpgme_error_t
631  GpgCardEdit:: doCmd (int cmd, const char *arg1, const char *arg2)  GpgCardEdit:: doCmd (int cmd, const char *arg1, const char *arg2)
632  {  {
# Line 539  GpgCardEdit:: doCmd (int cmd, const char Line 645  GpgCardEdit:: doCmd (int cmd, const char
645    
646      case GPG_EDITCARD_LOGIN:      case GPG_EDITCARD_LOGIN:
647          return updateLogin (arg1); /* login */          return updateLogin (arg1); /* login */
648    
649        default:
650            return gpg_error (GPG_ERR_INV_VALUE);
651      }      }
652    
653      return 0;      return 0;
654  }  }
655    
656    
657    /* Set the result for the executed operation.
658       The values will be ORed. */
659    void
660    GpgCardEdit::setResult (int res)
661    {
662        result |= res;
663    }
664    
665    
666    /* Return the result of the executed operation. */
667    int
668    GpgCardEdit::getResult (void)
669    {
670        return result;
671    }
672    
673    
674    /* Reset the object state. */
675    void
676    GpgCardEdit::reset (void)
677    {
678        cnt = 0;
679    }
Legend:
Removed from v.25  
changed lines
  Added in v.26
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26