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

Diff of /trunk/Src/wptKeyEditCB.cpp

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

revision 36 by werner, Thu Oct 27 15:25:13 2005 UTC revision 220 by twoaday, Tue May 30 15:31:49 2006 UTC
# Line 1  Line 1 
1  /* wptKeyEditCB.cpp - Key edit callback handling  /* wptKeyEditCB.cpp - Key edit callback handling
2   *      Copyright (C) 2005 Timo Schulz   *      Copyright (C) 2005, 2006 Timo Schulz
3   *      Copyright (C) 2005 g10 Code GmbH   *      Copyright (C) 2005 g10 Code GmbH
4   *   *
5   * This file is part of WinPT.   * This file is part of WinPT.
# Line 18  Line 18 
18   * along with WinPT; if not, write to the Free Software Foundation,   * along with WinPT; if not, write to the Free Software Foundation,
19   * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA   * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20   */   */
21    
22  #ifdef HAVE_CONFIG_H  #ifdef HAVE_CONFIG_H
23  #include <config.h>  #include <config.h>
24  #endif  #endif
25    
26  #include <stdio.h>  #include <stdio.h>
 #include <stdio.h>  
27  #include <string.h>  #include <string.h>
28  #include <stdlib.h>  #include <stdlib.h>
29  #include <assert.h>  #include <assert.h>
# Line 35  Line 35 
35  #include "wptKeyEdit.h"  #include "wptKeyEdit.h"
36  #include "wptErrors.h"  #include "wptErrors.h"
37    
38    /* Possible errors for the edit key operation. */
39    enum editkey_error_t {
40        EDITKEY_ERR_ALREADY_SIGNED = 1,
41        EDITKEY_ERR_BAD_PASSPHRASE = 2
42    };
43    
44    typedef gpgme_status_code_t status_code_t;
45    
46    /* 'notation' command handler. */
47    static const char*
48    cmd_notation_handler (GpgKeyEdit *ctx, status_code_t code, const char *key)
49    {
50        static char buf[32];
51    
52        if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
53            int uid = ctx->getUseridIndex ();
54            ctx->cmd_sent = 1;
55            if (uid != -1) {
56                sprintf (buf, "uid %d", ctx->getUseridIndex ());
57                return buf;
58            }
59        }
60        if (!strcmp (key, "keyedit.prompt") && ctx->cnt == 0) {
61            ctx->cnt = 1;
62            return "notation";
63        }
64        if (!strcmp (key, "keyedit.add_notation"))
65            return ctx->notation;
66        if (!strcmp (key, "passphrase.enter"))
67            return ctx->pass;
68    
69        return NULL;
70    }
71    
72    
73  /* 'keyserver' command handler. */  /* 'keyserver' command handler. */
74  static const char*  static const char*
# Line 43  cmd_keyserv_handler (GpgKeyEdit *ctx, gp Line 77  cmd_keyserv_handler (GpgKeyEdit *ctx, gp
77      static char buf[32];      static char buf[32];
78    
79      if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {      if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
80            int uid = ctx->getUseridIndex ();
81          ctx->cmd_sent = 1;          ctx->cmd_sent = 1;
82          sprintf (buf, "uid %d", ctx->uid_index);          if (uid != -1) {
83          return buf;              sprintf (buf, "uid %d", ctx->getUseridIndex ());
84                return buf;
85            }
86      }      }
87      if (!strcmp (key, "keyedit.prompt") && !ctx->cnt) {      if (!strcmp (key, "keyedit.prompt") && ctx->cnt == 0) {
88          ctx->cnt = 1;          ctx->cnt = 1;
89          return "keyserver";          return "keyserver";
90      }      }
91      if (!strcmp (key, "keyedit.add_keyserver"))      if (!strcmp (key, "keyedit.add_keyserver"))
92          return ctx->url;          return ctx->url;
93      if ( !strcmp (key, "keyedit.confirm_keyserver"))      if (!strcmp (key, "keyedit.confirm_keyserver"))
94          return "Y";          return "Y";
95      if (!strcmp (key, "passphrase.enter"))      if (!strcmp (key, "passphrase.enter"))
96          return ctx->pass;          return ctx->pass;
# Line 66  cmd_keyserv_handler (GpgKeyEdit *ctx, gp Line 103  cmd_keyserv_handler (GpgKeyEdit *ctx, gp
103  }  }
104    
105    
106    /* 'sign' command handler. */
107  static const char*  static const char*
108  cmd_sign_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char *key)  cmd_sign_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char *key)
109  {  {
110      static char buf[32];      static char buf[32];
111    
112        if (ctx->getUseridIndex () != -1 &&
113            ctx->cnt == 0 && !strcmp (key, "keyedit.prompt")) {
114            ctx->cnt++;
115            sprintf (buf, "uid %d", ctx->getUseridIndex ());
116            return buf;
117        }
118    
119      if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {      if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
120          ctx->cmd_sent = 1;          ctx->cmd_sent = 1;
121          switch (ctx->getType ()) {          switch (ctx->getType ()) {
122          case GPG_EDITKEY_SIGN: return "sign";          case GPG_EDITKEY_SIGN:      return "sign";
123          case GPG_EDITKEY_TSIGN: return "tsign";          case GPG_EDITKEY_TSIGN:     return "tsign";
124          case GPG_EDITKEY_LSIGN: return "lsign";          case GPG_EDITKEY_LSIGN:     return "lsign";
125          case GPG_EDITKEY_NRSIGN: return"nrsign";          case GPG_EDITKEY_NRSIGN:    return"nrsign";
126          case GPG_EDITKEY_NRLSIGN: return "nrlsign";          case GPG_EDITKEY_NRLSIGN:   return "nrlsign";
127          }          }
128      }      }
129      if (!strcmp (key, "sign_uid.class")) {      if (!strcmp (key, "sign_uid.class")) {
# Line 164  cmd_adduid_handler (GpgKeyEdit *ctx, gpg Line 209  cmd_adduid_handler (GpgKeyEdit *ctx, gpg
209    
210    
211  static const char*  static const char*
212  cmd_deluid_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char *key,  cmd_deluid_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
213                      int *r_step)                      const char *key)
214  {  {
215      static char buf[64];      static char buf[64];
     int step = *r_step;  
216    
217      if (step == 0 && !strcmp (key, "keyedit.prompt")) {      if (ctx->cnt == 0 && !strcmp (key, "keyedit.prompt")) {
218          sprintf (buf, "uid %d", ctx->uid_index);          sprintf (buf, "uid %d", ctx->getUseridIndex ());
219          *r_step = step = 1;          ctx->cnt = 1;
220          return buf;          return buf;
221      }      }
222      if (step == 1 && !strcmp (key, "keyedit.prompt")) {      if (ctx->cnt == 1 && !strcmp (key, "keyedit.prompt")) {
223          *r_step = step = 2;          ctx->cnt = 2;
224          return "deluid";          return "deluid";
225      }      }
226      if (step == 2 && !strcmp (key, "keyedit.remove.uid.okay")) {      if (ctx->cnt == 2 && !strcmp (key, "keyedit.remove.uid.okay")) {
227          *r_step = step = 3;          ctx->cnt = 3;
228          return "Y";          return "Y";
229      }      }
230      if (step == 3 && !strcmp (key, "keyedit.prompt" )) {      if (ctx->cnt == 3 && !strcmp (key, "keyedit.prompt" )) {
         *r_step = step = 0;  
231          ctx->reset ();          ctx->reset ();
232          return "save";          return "save";
233      }      }
# Line 193  cmd_deluid_handler (GpgKeyEdit *ctx, gpg Line 236  cmd_deluid_handler (GpgKeyEdit *ctx, gpg
236  }  }
237    
238    
239  static const char *  static const char*
240  cmd_delsig_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char * key,  cmd_delsig_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char *key)
                     int * r_step)  
241  {  {
242      static char buf[64];      static char buf[64];
243      int step = *r_step;      static int sig_cnt = 0;
244    
245      if (step == 0 && !strcmp (key, "keyedit.prompt")) {      if (ctx->cnt == 0 && !strcmp (key, "keyedit.prompt")) {
246          sprintf (buf, "uid %d", ctx->uid_index);          sprintf (buf, "uid %d", ctx->getUseridIndex ());
247          *r_step = step = 1;          ctx->cnt = 1;
248          return buf;          return buf;
249      }      }
250      if (step == 1 && !strcmp (key, "keyedit.prompt")) {      if (ctx->cnt == 1 && !strcmp (key, "keyedit.prompt")) {
251          *r_step = step = 2;          ctx->cnt = 2;
252          return "delsig";          return "delsig";
253      }      }
254      if (!strcmp (key, "keyedit.delsig.unknown") ||      if (!strcmp (key, "keyedit.delsig.unknown") ||
255          !strcmp (key, "keyedit.delsig.valid")) {          !strcmp (key, "keyedit.delsig.valid")) {
256          if (++ctx->cnt == ctx->sig_index)          if (++sig_cnt == ctx->getSigIndex ())
257              return "Y";              return "Y";
258          else          else
259              return "N";              return "N";
260      }      }
261      if (ctx->sig_index == 0 &&      if (!strcmp (key, "keyedit.delsig.selfsig"))
         !strcmp (key, "keyedit.delsig.selfsig"))  
262          return "Y";          return "Y";
263      if (step == 2 && !strcmp (key, "keyedit.prompt")) {      if (ctx->cnt == 2 && !strcmp (key, "keyedit.prompt")) {
264          *r_step = step = 0;          sig_cnt = 0;
265          ctx->reset ();          ctx->reset ();
266          return "save";          return "save";
267      }      }
# Line 231  cmd_delsig_handler (GpgKeyEdit *ctx, gpg Line 272  cmd_delsig_handler (GpgKeyEdit *ctx, gpg
272  /* 'delkey' command handler. */  /* 'delkey' command handler. */
273  static const char*  static const char*
274  cmd_delkey_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,  cmd_delkey_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
275                      const char *key, int *r_step )                      const char *key)
276  {  {
277      static char buf[64];      static char buf[64];
     int step = *r_step;  
278    
279      if (step == 0 && !strcmp (key, "keyedit.prompt")) {      if (ctx->cnt == 0 && !strcmp (key, "keyedit.prompt")) {
280          sprintf (buf, "key %d", ctx->key_index);          sprintf (buf, "key %d", ctx->getKeyIndex ());
281          *r_step = step = 1;          ctx->cnt = 1;
282          return buf;          return buf;
283      }      }
284      if (step == 1 && !strcmp (key, "keyedit.prompt")) {      if (ctx->cnt == 1 && !strcmp (key, "keyedit.prompt")) {
285          *r_step = step = 2;          ctx->cnt = 2;
286          return "delkey";          return "delkey";
287      }      }
288      if (step == 2 && !strcmp (key, "keyedit.remove.subkey.okay")) {      if (ctx->cnt == 2 && !strcmp (key, "keyedit.remove.subkey.okay")) {
289          *r_step = step = 3;          ctx->cnt = 3;
290          return "Y";          return "Y";
291      }      }
292      if (step == 3 && !strcmp (key, "keyedit.prompt")) {      if (ctx->cnt == 3 && !strcmp (key, "keyedit.prompt")) {
         *r_step = step = 0;  
293          ctx->reset ();          ctx->reset ();
294          return "save";          return "save";
295      }      }
# Line 273  cmd_addkey_handler (GpgKeyEdit *ctx, gpg Line 312  cmd_addkey_handler (GpgKeyEdit *ctx, gpg
312      if (!strcmp (key, "passphrase.enter"))      if (!strcmp (key, "passphrase.enter"))
313          return ctx->pass;          return ctx->pass;
314      if (!strcmp (key, "keygen.algo")) {      if (!strcmp (key, "keygen.algo")) {
315          _snprintf (buf, sizeof buf-1, "%d", ctx->pubkey_algo);          _snprintf (buf, sizeof (buf)-1, "%d", ctx->pubkey_algo);
316          return buf;          return buf;
317      }        }  
318      if (!strcmp (key, "keygen.size")) {      if (!strcmp (key, "keygen.size")) {
319          _snprintf (buf, sizeof buf-1, "%d", ctx->pubkey_size);          _snprintf (buf, sizeof (buf)-1, "%d", ctx->pubkey_size);
320          return buf;          return buf;
321      }      }
322      if (!strcmp (key, "keygen.valid")) {      if (!strcmp (key, "keygen.valid")) {
323          _snprintf (buf, sizeof buf-1, "%d", ctx->valid);          _snprintf (buf, sizeof (buf)-1, "%d", ctx->getValidDays ());
324          return buf;                  return buf;        
325      }      }
326      if (!strcmp (key, "keyedit.prompt")) {      if (!strcmp (key, "keyedit.prompt")) {
# Line 291  cmd_addkey_handler (GpgKeyEdit *ctx, gpg Line 330  cmd_addkey_handler (GpgKeyEdit *ctx, gpg
330      return NULL;      return NULL;
331  }  }
332    
333    
334  /* 'passwd' command handler. */  /* 'passwd' command handler. */
335  static const char*  static const char*
336  cmd_passwd_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char *key)  cmd_passwd_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char *key)
# Line 299  cmd_passwd_handler (GpgKeyEdit *ctx, gpg Line 339  cmd_passwd_handler (GpgKeyEdit *ctx, gpg
339          ctx->cmd_sent = 1;          ctx->cmd_sent = 1;
340          return "passwd";          return "passwd";
341      }      }
342      if( !strcmp (key, "passphrase.enter") && !ctx->cnt) {      if (ctx->cnt == 0 && !strcmp (key, "passphrase.enter")) {
343          ctx->cnt = 1;          ctx->cnt = 1;
344            /* it is possible that there is no old passphrase. */
345            if (!ctx->pass && ctx->flags)
346                return "";
347          return ctx->pass;          return ctx->pass;
348      }      }
349      if( !strcmp (key, "passphrase.enter" ))      if (!strcmp (key, "passphrase.enter" ))
350          return ctx->new_pass;          return ctx->new_pass;
351      if( !strcmp (key, "change_passwd.empty.okay" ))      if (!strcmp (key, "change_passwd.empty.okay" ))
352          return ctx->flags?  "Y" : "N";          return ctx->flags?  "Y" : "N";
353      if (!strcmp (key, "keyedit.prompt")) {      if (!strcmp (key, "keyedit.prompt")) {
354          ctx->reset ();          ctx->reset ();
355          return "save";          return "save";
356      }      }
357    
358      return NULL;      return NULL;
359  }  }
360    
# Line 318  cmd_passwd_handler (GpgKeyEdit *ctx, gpg Line 362  cmd_passwd_handler (GpgKeyEdit *ctx, gpg
362  static const char*  static const char*
363  cmd_setpref_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char * key)  cmd_setpref_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char * key)
364  {  {
365      static char buf[128];      static char buf[128] = {0};
366    
367      /* XXX: check the code. */      /* XXX: check the code. */
368  #if 0  #if 0
# Line 326  cmd_setpref_handler (GpgKeyEdit *ctx, gp Line 370  cmd_setpref_handler (GpgKeyEdit *ctx, gp
370          ctx->cmd_sent = 1;          ctx->cmd_sent = 1;
371          return "";          return "";
372      }      }
373      if (!strcmp ( key, "keyedit.prompt") && ctx->u.pref.id == 0) {      if (!strcmp (key, "keyedit.prompt") && ctx->u.pref.id == 0) {
374          ctx->u.pref.id++;          ctx->u.pref.id++;
375          _snprintf (buf, sizeof buf-1, "setpref %s", ctx->u.pref.new_prefs);          _snprintf (buf, sizeof buf-1, "setpref %s", ctx->u.pref.new_prefs);
376          return buf;          return buf;
377      }      }
378      if (!strcmp ( key, "keyedit.prompt") && ctx->u.pref.id == 1) {      if (!strcmp (key, "keyedit.prompt") && ctx->u.pref.id == 1) {
379          ctx->u.pref.id++;          ctx->u.pref.id++;
380          return "updpref";          return "updpref";
381      }      }
382      if (!strcmp ( key, "keyedit.updpref.okay"))      if (!strcmp (key, "keyedit.updpref.okay"))
383          return "Y";          return "Y";
384      if (!strcmp (key, "passphrase.enter"))      if (!strcmp (key, "passphrase.enter"))
385          return ctx->u.pref.passwd;          return ctx->u.pref.passwd;
# Line 345  cmd_setpref_handler (GpgKeyEdit *ctx, gp Line 389  cmd_setpref_handler (GpgKeyEdit *ctx, gp
389          return "save";          return "save";
390      }      }
391  #endif  #endif
392      return NULL;      return buf;
393  }  }
394    
395    
396  /* 'primary' command handler. */  /* 'primary' command handler. */
397  static const char*  static const char*
398  cmd_primary_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,  cmd_primary_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
399                       const char *key, int *r_step )                       const char *key)
400  {  {
401      static char buf[64];      static char buf[64];
     int step = *r_step;  
402    
403      if (step == 0 && !strcmp (key, "keyedit.prompt")) {      if (ctx->cnt == 0 && !strcmp (key, "keyedit.prompt")) {
404          sprintf (buf, "uid %d", ctx->uid_index);          sprintf (buf, "uid %d", ctx->getUseridIndex ());
405          *r_step = step = 1;          ctx->cnt = 1;
406          return buf;          return buf;
407      }      }
408      if (step == 1 && !strcmp (key, "keyedit.prompt" )) {      if (ctx->cnt == 1 && !strcmp (key, "keyedit.prompt" )) {
409          *r_step = step = 2;          ctx->cnt = 2;
410          return "primary";          return "primary";
411      }      }
412      if (step == 2 && !strcmp (key, "passphrase.enter")) {      if (ctx->cnt == 2 && !strcmp (key, "passphrase.enter")) {
413          *r_step = step = 3;          ctx->cnt = 3;
414          return ctx->pass;          return ctx->pass;
415      }      }
416      if (step == 3 && !strcmp (key, "keyedit.prompt")) {      if (ctx->cnt == 3 && !strcmp (key, "keyedit.prompt")) {
         *r_step = step = 0;  
417          ctx->reset ();          ctx->reset ();
418          return "save";          return "save";
419      }      }
420      return NULL;      return NULL;
421  }  }
422    
423    
424  /* 'expire' command handler. */  /* 'expire' command handler. */
425  static const char*  static const char*
426  cmd_expire_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,  cmd_expire_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
427                      const char *key, int *r_step )                      const char *key)
428  {  {
429      static char buf[64];      static char buf[64];
     int step = *r_step;  
430    
431      if (step == 0 && !strcmp (key, "keyedit.prompt")) {      if (ctx->cnt == 0 && !strcmp (key, "keyedit.prompt")) {
432          sprintf (buf, "key %d", ctx->key_index);          sprintf (buf, "key %d", ctx->getKeyIndex ());
433          *r_step = step = 1;          ctx->cnt = 1;
434          return buf;          return buf;
435      }      }
436      if (step == 1 && !strcmp (key, "keyedit.prompt")) {      if (ctx->cnt == 1 && !strcmp (key, "keyedit.prompt")) {
437          *r_step = step = 2;          ctx->cnt = 2;
438          return "expire";          return "expire";
439      }      }
440      if( step == 2 && !strcmp ( key, "keygen.valid" ) ) {      if (ctx->cnt == 2 && !strcmp (key, "keygen.valid" )) {
441          *r_step = step = 3;          ctx->cnt = 3;
442          sprintf (buf, "%d", ctx->valid);          sprintf (buf, "%d", ctx->getValidDays ());
443          return buf;          return buf;
444      }      }
445      if (step == 3 && !strcmp (key, "passphrase.enter")) {      if (ctx->cnt == 3 && !strcmp (key, "passphrase.enter")) {
446          *r_step = step = 4;          ctx->cnt = 4;
447          return ctx->pass;          return ctx->pass;
448      }      }
449      if (step == 4 && !strcmp (key, "keyedit.prompt")) {      if (ctx->cnt == 4 && !strcmp (key, "keyedit.prompt")) {
         *r_step = step = 0;  
450          ctx->reset ();          ctx->reset ();
451          return "save";          return "save";
452      }      }
# Line 417  cmd_expire_handler (GpgKeyEdit *ctx, gpg Line 458  cmd_expire_handler (GpgKeyEdit *ctx, gpg
458  /* 'revuid' command handler. */  /* 'revuid' command handler. */
459  const char*  const char*
460  cmd_revuid_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,  cmd_revuid_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
461                      const char *key, int *r_step)                      const char *key)
462  {  {
463      static char buf[32];      static char buf[32];
     int step = *r_step;  
464            
465      if (step == 0 && !strcmp (key, "keyedit.prompt")) {      if (ctx->cnt == 0 && !strcmp (key, "keyedit.prompt")) {
466          *r_step = step = 1;          ctx->cnt = 1;
467          sprintf (buf, "uid %d", ctx->uid_index);          sprintf (buf, "uid %d", ctx->getUseridIndex ());
468          return buf;          return buf;
469      }      }
470      else if (step == 1 && !strcmp (key, "keyedit.prompt")) {      else if (ctx->cnt == 1 && !strcmp (key, "keyedit.prompt")) {
471          *r_step = step = 2;          ctx->cnt = 2;
472          return "revuid";          return "revuid";
473      }      }
474      else if (step == 2 && !strcmp (key, "keyedit.revoke.uid.okay")) {      else if (ctx->cnt == 2 && !strcmp (key, "keyedit.revoke.uid.okay")) {
475          *r_step = step = 3;          ctx->cnt = 3;
476          return "Y";          return "Y";
477      }      }
478      else if (step == 3 && !strcmp (key, "ask_revocation_reason.code")) {      else if (ctx->cnt == 3 && !strcmp (key, "ask_revocation_reason.code")) {
479          *r_step = step = 4;          ctx->cnt = 4;
480          return "4";          return "4";
481      }      }
482      else if (step == 4 && !strcmp (key, "ask_revocation_reason.text")) {      else if (ctx->cnt == 4 && !strcmp (key, "ask_revocation_reason.text")) {
483          *r_step = step = 5;          ctx->cnt = 5;
484          return "";          return "";
485      }      }
486      else if (step == 5 && !strcmp (key, "ask_revocation_reason.okay")) {      else if (ctx->cnt == 5 && !strcmp (key, "ask_revocation_reason.okay")) {
487          *r_step = step = 6;          ctx->cnt = 6;
488          return "Y";          return "Y";
489      }      }
490      else if (step == 6 && !strcmp (key, "passphrase.enter")) {      else if (ctx->cnt == 6 && !strcmp (key, "passphrase.enter")) {
491          *r_step = step = 7;          ctx->cnt = 7;
492          return ctx->pass;          return ctx->pass;
493      }      }
494      else if (step == 7 && !strcmp (key, "keyedit.prompt")) {      else if (ctx->cnt == 7 && !strcmp (key, "keyedit.prompt")) {
         *r_step = step = 0;  
495          ctx->reset ();          ctx->reset ();
496          return "save";          return "save";
497      }      }
# Line 462  cmd_revuid_handler (GpgKeyEdit *ctx, gpg Line 501  cmd_revuid_handler (GpgKeyEdit *ctx, gpg
501    
502  const char*  const char*
503  cmd_revsig_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,  cmd_revsig_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
504                      const char *key, int *r_step)                      const char *key)
505  {  {
506      static char buf[64];      static char buf[64];
     int step = *r_step;  
507            
508      if( step == 0 && !strcmp ( key, "keyedit.prompt" ) ) {      if (ctx->cnt == 0 && !strcmp (key, "keyedit.prompt" )) {
509          sprintf( buf, "uid %d", ctx->uid_index);          sprintf( buf, "uid %d", ctx->getUseridIndex ());
510          *r_step = step = 1;          ctx->cnt = 1;
511          return buf;          return buf;
512      }      }
513      if( step == 1 && !strcmp ( key, "keyedit.prompt" ) ) {      if (ctx->cnt == 1 && !strcmp ( key, "keyedit.prompt" ) ) {
514          *r_step = step = 2;          ctx->cnt = 2;
515          return "revsig";          return "revsig";
516      }      }
517      if( step == 2 && !strcmp (key, "ask_revoke_sig.one" ) ) {      if (ctx->cnt == 2 && !strcmp (key, "ask_revoke_sig.one" ) ) {
518          *r_step = step = 3;          ctx->cnt = 3;
519          return "Y";          return "Y";
520      }      }
521      if( step == 3 && !strcmp (key, "ask_revoke_sig.okay" ) ) {      if (ctx->cnt == 3 && !strcmp (key, "ask_revoke_sig.okay" ) ) {
522          *r_step = step = 4;          ctx->cnt = 4;
523          return "Y";          return "Y";
524      }      }
525      if( step == 4 && !strcmp ( key, "ask_revocation_reason.code" ) ) {      if (ctx->cnt == 4 && !strcmp ( key, "ask_revocation_reason.code" ) ) {
526          *r_step = step = 5;          ctx->cnt = 5;
527          return "0";          return "0";
528      }      }
529      if( step == 5 && !strcmp ( key, "ask_revocation_reason.text" ) ) {      if (ctx->cnt == 5 && !strcmp ( key, "ask_revocation_reason.text" ) ) {
530          *r_step = step = 6;          ctx->cnt = 6;
531          return "";          return "";
532      }      }
533      if( step == 6 && !strcmp (key, "ask_revocation_reason.okay" ) ) {      if (ctx->cnt == 6 && !strcmp (key, "ask_revocation_reason.okay" ) ) {
534          *r_step = step = 7;          ctx->cnt = 7;
535          return "Y";          return "Y";
536      }      }
537      if( step == 7 && !strcmp (key, "passphrase.enter" ) ) {      if (ctx->cnt == 7 && !strcmp (key, "passphrase.enter" ) ) {
538          *r_step = step = 8;          ctx->cnt = 8;
539          return ctx->pass;          return ctx->pass;
540      }      }
541      if( step == 8 && !strcmp ( key, "keyedit.prompt" ) ) {      if (ctx->cnt == 8 && !strcmp ( key, "keyedit.prompt" ) ) {
         *r_step = step = 0;  
542          ctx->reset ();          ctx->reset ();
543          return "save";          return "save";
544      }      }
# Line 513  cmd_revsig_handler (GpgKeyEdit *ctx, gpg Line 550  cmd_revsig_handler (GpgKeyEdit *ctx, gpg
550  /* 'revoke' command handler. */  /* 'revoke' command handler. */
551  static const char *  static const char *
552  cmd_revkey_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,  cmd_revkey_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
553                      const char * key, int *r_step)                      const char *key)
554  {  {
     int step = *r_step;  
555      static char buf[64];      static char buf[64];
556    
557      if( step == 0 && !strcmp ( key, "keyedit.prompt" ) ) {      if (ctx->cnt == 0 && !strcmp ( key, "keyedit.prompt" ) ) {
558          sprintf( buf, "key %d", ctx->key_index);          sprintf( buf, "key %d", ctx->getKeyIndex ());
559          *r_step = step = 1;          ctx->cnt = 1;
560          return buf;          return buf;
561      }      }
562      if( step == 1 && !strcmp ( key, "keyedit.prompt" ) ) {      if (ctx->cnt == 1 && !strcmp (key, "keyedit.prompt")) {
563          *r_step = step = 2;          ctx->cnt = 2;
564          return "revkey";          return "revkey";
565      }      }
566      if( step == 2 && !strcmp (key, "keyedit.revoke.subkey.okay" ) ) {      if (ctx->cnt == 2 && !strcmp (key, "keyedit.revoke.subkey.okay")) {
567          *r_step = step = 3;          ctx->cnt = 3;
568          return "Y";          return "Y";
569      }      }
570      if( step == 3 &&  !strcmp ( key, "ask_revocation_reason.code" ) ) {      if (ctx->cnt == 3 &&  !strcmp ( key, "ask_revocation_reason.code")) {
571          sprintf( buf, "%d", ctx->reason);          sprintf( buf, "%d", ctx->reason);
572          *r_step = step = 4;          ctx->cnt = 4;
573          return buf;          return buf;
574      }      }
575      if( step == 4 && !strcmp ( key, "ask_revocation_reason.text" ) ) {      if (ctx->cnt == 4 && !strcmp (key, "ask_revocation_reason.text")) {
576          *r_step = step = 5;          ctx->cnt = 5;
577          return "";          return "";
578      }      }
579      if( step == 5 && !strcmp (key, "ask_revocation_reason.okay" ) ) {      if (ctx->cnt == 5 && !strcmp (key, "ask_revocation_reason.okay")) {
580          *r_step = step = 6;          ctx->cnt = 6;
581          return "Y";          return "Y";
582      }      }
583      if( step == 6 && !strcmp (key, "passphrase.enter" ) ) {      if (ctx->cnt == 6 && !strcmp (key, "passphrase.enter")) {
584          *r_step = step = 7;          ctx->cnt = 7;
585          return ctx->pass;          return ctx->pass;
586      }      }
587      if( step == 7 && !strcmp ( key, "keyedit.prompt" ) ) {      if (ctx->cnt == 7 && !strcmp ( key, "keyedit.prompt")) {
         *r_step = step = 0;  
588          ctx->reset ();          ctx->reset ();
589          return "save";          return "save";
590      }      }
# Line 560  cmd_revkey_handler (GpgKeyEdit *ctx, gpg Line 595  cmd_revkey_handler (GpgKeyEdit *ctx, gpg
595  /* 'addrevoker' command handler. */  /* 'addrevoker' command handler. */
596  static const char *  static const char *
597  cmd_addrev_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,  cmd_addrev_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
598                      const char * key, int * r_step)                      const char *key)
599  {  {
     int step = *r_step;  
600    
601      if (step == 0 && !strcmp (key, "keyedit.prompt")) {      /* If the isuser already signed the key, send an empty
602          *r_step = step = 1;             string and jump to quit. */
603        if (ctx->getResult () & EDITKEY_ERR_ALREADY_SIGNED
604            && ctx->cnt != -1 && ctx->cnt != 4) {
605            ctx->cnt = -1;
606            return "";
607        }
608        if (ctx->cnt == -1) {
609            ctx->cnt = 4;
610            return ""; /* empty value to abort. */
611        }
612        if (ctx->cnt == 0 && !strcmp (key, "keyedit.prompt")) {
613            ctx->cnt = 1;
614          return "addrevoker";          return "addrevoker";
615      }      }
616      if (step == 1 && !strcmp (key, "keyedit.add_revoker")) {      if (ctx->cnt == 1 && !strcmp (key, "keyedit.add_revoker")) {
617          *r_step = step = 2;          ctx->cnt = 2;
         /* XXX: handle already-signed. */  
618          return ctx->name;          return ctx->name;
619      }      }
620      if (step == 2 && !strcmp (key, "keyedit.add_revoker.okay")) {      if (ctx->cnt == 2 && !strcmp (key, "keyedit.add_revoker.okay")) {
621          *r_step = step = 3;          ctx->cnt = 3;
622          return "Y";          return "Y";
623      }      }
624      if (step == 3 && !strcmp (key, "passphrase.enter")) {      if (ctx->cnt == 3 && !strcmp (key, "passphrase.enter")) {
625          *r_step = step = 4;          ctx->cnt = 4;
626          return ctx->pass;          return ctx->pass;
627      }      }
628      if (step == 4 && !strcmp (key, "keyedit.prompt")) {      if (ctx->cnt == 4 && !strcmp (key, "keyedit.prompt")) {
         *r_step = step = 0;  
629          ctx->reset ();          ctx->reset ();
630          return "save";          return "save";
631      }      }
# Line 612  cmd_addphoto_handler (GpgKeyEdit *ctx, g Line 655  cmd_addphoto_handler (GpgKeyEdit *ctx, g
655      return NULL;      return NULL;
656  }  }
657    
658    
659    static const char*
660    cmd_minimize_handler (GpgKeyEdit *ctx, status_code_t code, const char *key)
661    {
662        if (!strcmp (key, "keyedit.prompt") && !ctx->cmd_sent) {
663            ctx->cmd_sent = 1;
664            return "minimize";
665        }
666        if (!strcmp (key, "keyedit.prompt")) {
667            ctx->reset ();
668            return "save";
669        }
670    
671        return NULL;
672    }
673    
674    /* 'clean' command handler. */
675    static const char*
676    cmd_clean_handler (GpgKeyEdit *ctx, status_code_t code, const char *key)
677    {
678        if (!strcmp (key, "keyedit.prompt") && !ctx->cmd_sent) {
679            ctx->cmd_sent = 1;
680            return "clean";
681        }
682        if (!strcmp (key, "keyedit.prompt")) {
683            ctx->reset ();
684            return "save";
685        }
686        return NULL;
687    }
688    
689    
690  /* 'enable' and 'disable' command handler. */  /* 'enable' and 'disable' command handler. */
691  static const char *  static const char *
692  cmd_enable_disable_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,  cmd_enable_disable_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
# Line 619  cmd_enable_disable_handler (GpgKeyEdit * Line 694  cmd_enable_disable_handler (GpgKeyEdit *
694  {  {
695      if (!strcmp (key, "keyedit.prompt") && !ctx->cmd_sent) {      if (!strcmp (key, "keyedit.prompt") && !ctx->cmd_sent) {
696          ctx->cmd_sent = 1;          ctx->cmd_sent = 1;
697          if (mode)          return mode? "disable": "enable";
             return "disable";  
         return "enable";  
698      }      }
699      if (!strcmp (key, "keyedit.prompt")) {      if (!strcmp (key, "keyedit.prompt")) {
700          ctx->reset ();          ctx->reset ();
# Line 636  static gpgme_error_t Line 709  static gpgme_error_t
709  editkey_command_handler (void *opaque, gpgme_status_code_t code,  editkey_command_handler (void *opaque, gpgme_status_code_t code,
710                           const char *key, int fd)                           const char *key, int fd)
711  {  {
     static int step = 0;  
712      const char *out = NULL;      const char *out = NULL;
713      GpgKeyEdit *ke = (GpgKeyEdit *)opaque;      GpgKeyEdit *ke = (GpgKeyEdit *)opaque;
714      HANDLE hd = (HANDLE)fd;      HANDLE hd = (HANDLE)fd;
# Line 648  editkey_command_handler (void *opaque, g Line 720  editkey_command_handler (void *opaque, g
720      /*log_debug ("key=%s code=%d\r\n", key, code);*/      /*log_debug ("key=%s code=%d\r\n", key, code);*/
721      switch (code) {      switch (code) {
722      case GPGME_STATUS_ALREADY_SIGNED:      case GPGME_STATUS_ALREADY_SIGNED:
723          ke->setResult (GPG_EDITRES_ALREADY_SIGNED);          ke->setResult (EDITKEY_ERR_ALREADY_SIGNED);
724          break;          break;
725    
726      case GPGME_STATUS_BAD_PASSPHRASE:      case GPGME_STATUS_BAD_PASSPHRASE:
727          ke->setResult (GPG_EDITRES_BAD_PASSPHRASE);          log_debug ("editkey_command_handler: bad passphrase\n");
728            ke->setResult (EDITKEY_ERR_BAD_PASSPHRASE);
729            break;
730    
731        default:
732          break;          break;
733      }      }
734    
735      if (ke->getResult () & GPG_EDITRES_BAD_PASSPHRASE) {      if (ke->getResult () & EDITKEY_ERR_BAD_PASSPHRASE) {
736          /* If the entered passphrase is bad, we supply empty          /* If the entered passphrase is bad, we supply empty
737             passphrase to abort and send 'quit' as soon as possible. */             passphrase to abort and send 'quit' as soon as possible. */
738          if (!strcmp (key, "passphrase.enter"))          if (!strcmp (key, "passphrase.enter"))
739              WriteFile (hd, "\n", 1, &n, NULL);              WriteFile (hd, "\n", 1, &n, NULL);
740          if (!strcmp (key, "keyedit.prompt"))          if (!strcmp (key, "keyedit.prompt"))
741              WriteFile (hd, "quit\n", 5, &n, NULL);              WriteFile (hd, "quit\n", 5, &n, NULL);
742            ke->reset ();
743            return 0;
744      }      }
745            
746      switch (ke->getType ()) {      switch (ke->getType ()) {
# Line 682  editkey_command_handler (void *opaque, g Line 761  editkey_command_handler (void *opaque, g
761          break;          break;
762                    
763      case GPG_EDITKEY_DELUID:      case GPG_EDITKEY_DELUID:
764          out =  cmd_deluid_handler (ke, code, key, &step);          out =  cmd_deluid_handler (ke, code, key);
765          break;          break;
766                    
767      case GPG_EDITKEY_DELSIG:      case GPG_EDITKEY_DELSIG:
768          out =  cmd_delsig_handler (ke, code, key, &step);          out =  cmd_delsig_handler (ke, code, key);
769          break;          break;
770    
771      case GPG_EDITKEY_DELKEY:      case GPG_EDITKEY_DELKEY:
772          out =  cmd_delkey_handler(ke, code, key, &step );          out =  cmd_delkey_handler(ke, code, key);
773          break;          break;
774                    
775      case GPG_EDITKEY_ADDKEY:      case GPG_EDITKEY_ADDKEY:
# Line 702  editkey_command_handler (void *opaque, g Line 781  editkey_command_handler (void *opaque, g
781          break;          break;
782                    
783      case GPG_EDITKEY_PRIMARY:      case GPG_EDITKEY_PRIMARY:
784          out =  cmd_primary_handler (ke, code, key, &step);          out =  cmd_primary_handler (ke, code, key);
785          break;          break;
786                    
787      case GPG_EDITKEY_EXPIRE:      case GPG_EDITKEY_EXPIRE:
788          out =  cmd_expire_handler (ke, code, key, &step);          out =  cmd_expire_handler (ke, code, key);
789          break;          break;
790    
791      case GPG_EDITKEY_REVSIG:      case GPG_EDITKEY_REVSIG:
792          out =  cmd_revsig_handler (ke, code, key, &step);          out =  cmd_revsig_handler (ke, code, key);
793          break;          break;
794    
795      case GPG_EDITKEY_REVKEY:      case GPG_EDITKEY_REVKEY:
796          out =  cmd_revkey_handler (ke, code, key, &step);          out =  cmd_revkey_handler (ke, code, key);
797          break;          break;
798                            
799      case GPG_EDITKEY_REVUID:      case GPG_EDITKEY_REVUID:
800          out = cmd_revuid_handler (ke, code, key, &step);          out = cmd_revuid_handler (ke, code, key);
801          break;          break;
802    
803      case GPG_EDITKEY_ADDREV:      case GPG_EDITKEY_ADDREV:
804          out =  cmd_addrev_handler (ke, code, key, &step);          out =  cmd_addrev_handler (ke, code, key);
805          break;          break;
806    
807      case GPG_EDITKEY_ADDPHOTO:      case GPG_EDITKEY_ADDPHOTO:
808          out =  cmd_addphoto_handler (ke, code, key);          out =  cmd_addphoto_handler (ke, code, key);
809          break;          break;
810    
811        case GPG_EDITKEY_NOTATION:
812            out = cmd_notation_handler (ke, code, key);
813            break;
814    
815        case GPG_EDITKEY_MINIMIZE:
816            out = cmd_minimize_handler (ke, code, key);
817            break;
818    
819        case GPG_EDITKEY_CLEAN:
820            out = cmd_clean_handler (ke, code, key);
821            break;
822    
823      case GPG_EDITKEY_ENABLE:      case GPG_EDITKEY_ENABLE:
824      case GPG_EDITKEY_DISABLE:      case GPG_EDITKEY_DISABLE:
825          out = cmd_enable_disable_handler (ke, code, key,          n = ke->getType () == GPG_EDITKEY_DISABLE? 1: 0;
826                                            ke->getType () == GPG_EDITKEY_DISABLE? 1: 0);          out = cmd_enable_disable_handler (ke, code, key, n);
827          break;          break;
828    
829      case GPG_EDITKEY_SETPREF:      case GPG_EDITKEY_SETPREF:
# Line 745  editkey_command_handler (void *opaque, g Line 836  editkey_command_handler (void *opaque, g
836      }      }
837    
838      if (out != NULL) {      if (out != NULL) {
         /* XXX: check return codes. */  
839          WriteFile (hd, out, strlen (out), &n, NULL);          WriteFile (hd, out, strlen (out), &n, NULL);
840          WriteFile (hd, "\n", 1, &n, NULL);          WriteFile (hd, "\n", 1, &n, NULL);
841      }      }
# Line 759  editkey_command_handler (void *opaque, g Line 849  editkey_command_handler (void *opaque, g
849  static gpgme_error_t  static gpgme_error_t
850  map_result (GpgKeyEdit *ke)  map_result (GpgKeyEdit *ke)
851  {  {
852        /* XXX Sometimes ALREADY_SIGNED indicates an failure. */
853      if (!ke->getResult ())      if (!ke->getResult ())
854          return gpg_error (GPG_ERR_NO_ERROR);          return gpg_error (GPG_ERR_NO_ERROR);
855      if (ke->getResult () & GPG_EDITRES_BAD_PASSPHRASE)      if (ke->getResult () & EDITKEY_ERR_BAD_PASSPHRASE)
856          return gpg_error (GPG_ERR_BAD_PASSPHRASE);          return gpg_error (GPG_ERR_BAD_PASSPHRASE);
857      return 0;      return 0;
858  }  }
Legend:
Removed from v.36  
changed lines
  Added in v.220
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26