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

Diff of /trunk/Src/wptKeyCache.cpp

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

revision 168 by twoaday, Fri Jan 27 10:08:10 2006 UTC revision 188 by twoaday, Wed Mar 22 12:39:02 2006 UTC
# Line 36  Line 36 
36  #include "wptErrors.h"  #include "wptErrors.h"
37  #include "wptW32API.h"  #include "wptW32API.h"
38  #include "wptGPG.h"  #include "wptGPG.h"
39    #include "wptTypes.h"
40    
41    
42  /* Attribute list which holds the image data. */  /* Attribute list which holds the image data. */
# Line 49  struct attr_list_s { Line 50  struct attr_list_s {
50  typedef struct attr_list_s *attr_list_t;  typedef struct attr_list_s *attr_list_t;
51    
52    
53    /* Free attribute list @ctx. */
54  void  void
55  free_attr_list (attr_list_t ctx)  free_attr_list (attr_list_t ctx)
56  {  {
# Line 81  parse_attr_list (FILE *fp, const BYTE *d Line 83  parse_attr_list (FILE *fp, const BYTE *d
83          buffer = buf+9+10;          buffer = buf+9+10;
84          pos = 0;          pos = 0;
85          c = (attr_list_t)calloc (1, sizeof *c);          c = (attr_list_t)calloc (1, sizeof *c);
86            if (!c)
87                BUG (0);
88          p = strtok (buffer, " ");          p = strtok (buffer, " ");
89          while (p != NULL) {          while (p != NULL) {
90              switch (pos) {              switch (pos) {
# Line 102  parse_attr_list (FILE *fp, const BYTE *d Line 106  parse_attr_list (FILE *fp, const BYTE *d
106              pos++;              pos++;
107              p = strtok (NULL, " ");              p = strtok (NULL, " ");
108          }          }
         /*printf ("id=%s octets=%d flags=%d\n", c->fpr, c->octets, c->flags);*/  
109          if (!*ctx)          if (!*ctx)
110              *ctx = c;              *ctx = c;
111          else {          else {
# Line 111  parse_attr_list (FILE *fp, const BYTE *d Line 114  parse_attr_list (FILE *fp, const BYTE *d
114              t->next = c;              t->next = c;
115          }          }
116          c->d = (unsigned char*)malloc (c->octets);          c->d = (unsigned char*)malloc (c->octets);
117            if (!c->d)
118                BUG (0);
119          memcpy (c->d, data, c->octets);          memcpy (c->d, data, c->octets);
120          data += c->octets;          data += c->octets;
121          datlen -= c->octets;          datlen -= c->octets;
# Line 121  parse_attr_list (FILE *fp, const BYTE *d Line 126  parse_attr_list (FILE *fp, const BYTE *d
126  }  }
127    
128    
 /* Always use the $users temp folder. */  
 static FILE*  
 w32_tmpfile (char *tmp, DWORD tmplen)  
 {  
     char id[16];  
   
     if (!GetTempPath (tmplen-17, tmp))  
         return NULL;  
     if (tmp[strlen (tmp)-1] != '\\')  
         strcat (tmp, "\\");  
     _snprintf (id, sizeof (id)-1, "%lu", GetTickCount ());  
     strcat (tmp, id);  
     return fopen (tmp, "w+b");  
 }  
   
   
129  static int  static int
130  parse_attr_data (const char *keyid, attr_list_t *list)  parse_attr_data (const char *keyid, attr_list_t *list)
131  {  {
132      gpgme_error_t err;      gpgme_error_t err;
133      FILE *tmp;      FILE *tmp;    
     char *status, tmpnam[MAX_PATH+1];  
134      BYTE *data;      BYTE *data;
135      DWORD ndata;      char *status, tmpnam[MAX_PATH+1];
136        DWORD ndata = 0;
137    
138      err = gpg_get_photoid_data (keyid, &status, &data, &ndata);      err = gpg_get_photoid_data (keyid, &status, &data, &ndata);
139      if (err)      if (err)
140          return err;          return err;
141    
142      if (ndata > 0 && (tmp = w32_tmpfile (tmpnam, MAX_PATH)) != NULL) {      get_temp_name (tmpnam, MAX_PATH, NULL);
143        tmp = fopen (tmpnam, "w+b");
144        if (ndata > 0 && tmp != NULL) {
145          fwrite (status, 1, strlen (status), tmp);          fwrite (status, 1, strlen (status), tmp);
146          fflush (tmp);          fflush (tmp);
147          rewind (tmp);          rewind (tmp);
# Line 187  parse_secring (gpg_keycache_t cache, con Line 178  parse_secring (gpg_keycache_t cache, con
178    
179      gpg_iobuf_ioctl (inp, 3, 1, NULL);      gpg_iobuf_ioctl (inp, 3, 1, NULL);
180      pkt = (PACKET*)calloc (1, sizeof *pkt);      pkt = (PACKET*)calloc (1, sizeof *pkt);
181        if (!pkt)
182            BUG (0);
183      gpg_init_packet (pkt);      gpg_init_packet (pkt);
184      while (gpg_parse_packet (inp, pkt) != -1) {      while (gpg_parse_packet (inp, pkt) != -1) {
185          if (pkt->pkttype == PKT_SECRET_KEY) {          if (pkt->pkttype == PKT_SECRET_KEY) {
# Line 230  keycache_update_photo (gpg_keycache_t ct Line 223  keycache_update_photo (gpg_keycache_t ct
223      fnd->attrib.flags = dat->flags;      fnd->attrib.flags = dat->flags;
224      fnd->attrib.len = dat->octets;      fnd->attrib.len = dat->octets;
225      fnd->attrib.d = (unsigned char*)malloc (dat->octets);      fnd->attrib.d = (unsigned char*)malloc (dat->octets);
226        if (!fnd->attrib.d)
227            BUG (0);
228      memcpy (fnd->attrib.d, dat->d, dat->octets);      memcpy (fnd->attrib.d, dat->d, dat->octets);
229      return 0;      return 0;
230  }  }
# Line 281  keycache_prepare2 (gpg_keycache_t ctx, c Line 276  keycache_prepare2 (gpg_keycache_t ctx, c
276      gpg_iobuf_ioctl (inp, 3, 1, NULL); /* disable cache */      gpg_iobuf_ioctl (inp, 3, 1, NULL); /* disable cache */
277    
278      pkt = (PACKET*)calloc (1, sizeof * pkt);      pkt = (PACKET*)calloc (1, sizeof * pkt);
279        if (!pkt)
280            BUG (0);
281      gpg_init_packet (pkt);      gpg_init_packet (pkt);
282      while (gpg_parse_packet (inp, pkt) != -1) {      while (gpg_parse_packet (inp, pkt) != -1) {
283          if (pkt->pkttype == PKT_PUBLIC_KEY) {          if (pkt->pkttype == PKT_PUBLIC_KEY) {
# Line 316  keycache_prepare2 (gpg_keycache_t ctx, c Line 313  keycache_prepare2 (gpg_keycache_t ctx, c
313              else if (nsym > 0) {              else if (nsym > 0) {
314                  c->sym_prefs = (unsigned char*)calloc (1, nsym+1);                  c->sym_prefs = (unsigned char*)calloc (1, nsym+1);
315                  if (!c->sym_prefs)                  if (!c->sym_prefs)
316                      return gpg_error (GPG_ERR_ENOMEM);                      BUG (0);
317                  memcpy (c->sym_prefs, sym_prefs, nsym);                  memcpy (c->sym_prefs, sym_prefs, nsym);
318              }              }
319          }          }
# Line 358  gpg_keycache_new (gpg_keycache_t *r_ctx) Line 355  gpg_keycache_new (gpg_keycache_t *r_ctx)
355          return gpg_error (GPG_ERR_INV_ARG);          return gpg_error (GPG_ERR_INV_ARG);
356      ctx = (gpg_keycache_t)calloc (1, sizeof *ctx);      ctx = (gpg_keycache_t)calloc (1, sizeof *ctx);
357      if (!ctx)      if (!ctx)
358          return gpg_error (GPG_ERR_ENOMEM);          BUG (0);
359      ctx->secret = 0;      ctx->secret = 0;
360      ctx->pos = 0;      ctx->pos = 0;
361      *r_ctx = ctx;      *r_ctx = ctx;
# Line 379  gpg_keycache_release (gpg_keycache_t ctx Line 376  gpg_keycache_release (gpg_keycache_t ctx
376          c2 = c->next;          c2 = c->next;
377          gpgme_key_release (c->key);          gpgme_key_release (c->key);
378          c->key = NULL;          c->key = NULL;
379            safe_free (c->pref_keyserver);
380          safe_free (c->sym_prefs);          safe_free (c->sym_prefs);
381          safe_free (c->attrib.d);          safe_free (c->attrib.d);
382          safe_free (c->card_type);          safe_free (c->card_type);
# Line 418  gpg_keycache_add_key (gpg_keycache_t ctx Line 416  gpg_keycache_add_key (gpg_keycache_t ctx
416            
417      c = (struct keycache_s*)calloc (1, sizeof *c);      c = (struct keycache_s*)calloc (1, sizeof *c);
418      if (!c)      if (!c)
419          return gpg_error (GPG_ERR_ENOMEM);          BUG (0);
420      c->gloflags.is_protected = 1; /*default: assume protection. */      c->gloflags.is_protected = 1; /*default: assume protection. */
421      c->key = key;      c->key = key;
422      if (!ctx->item)      if (!ctx->item)
# Line 531  gpg_keycache_next_updated_key (gpg_keyca Line 529  gpg_keycache_next_updated_key (gpg_keyca
529      for (c = ctx->item; c; c = c->next) {      for (c = ctx->item; c; c = c->next) {
530          if (c->flags != 0) {          if (c->flags != 0) {
531              *r_status = c->flags;              *r_status = c->flags;
             c->flags = 0;  
532              *r_obj = c;              *r_obj = c;
533                c->flags = 0;
534              return 0;              return 0;
535          }          }
536      }      }
# Line 612  gpg_keycache_delete_key (gpg_keycache_t Line 610  gpg_keycache_delete_key (gpg_keycache_t
610      c = ctx->item;      c = ctx->item;
611      if (c->next == NULL) {      if (c->next == NULL) {
612          gpgme_key_release (itm->key);          gpgme_key_release (itm->key);
613          if (itm)          safe_free (itm);
             free (itm);  
614          ctx->item = NULL;          ctx->item = NULL;
615      }      }
616      else {      else {
617          while (c && c->next != itm)          for (; c != NULL; c = c->next) {
618              c = c->next;              if (c->next == itm)
619                    break;
620            }
621            assert (c != NULL); /* XXX: sometimes access violation. */
622          c->next = c->next->next;          c->next = c->next->next;
623          gpgme_key_release (itm->key);          gpgme_key_release (itm->key);
624          if (itm)          safe_free (itm);
             free (itm);  
625      }      }
626      return 0;      return 0;
627  }  }
# Line 696  copy_uid_prefs (const unsigned char *pre Line 695  copy_uid_prefs (const unsigned char *pre
695          pos++;          pos++;
696      p = (unsigned char*)calloc (1, pos+1);      p = (unsigned char*)calloc (1, pos+1);
697      if (!p)      if (!p)
698          abort ();          BUG (0);
699      memcpy (p, prefs, pos);      memcpy (p, prefs, pos);
700      return p;      return p;
701  }  }
# Line 793  gpg_keycache_next_key (gpg_keycache_t ct Line 792  gpg_keycache_next_key (gpg_keycache_t ct
792      return err;      return err;
793  }  }
794    
795    
796  /* Search for a key with the pattern @pattern and mark  /* Search for a key with the pattern @pattern and mark
797     this key as the default signing key if found.     this key as the default signing key if found.
798     Return value: 0 on success. */     Return value: 0 on success. */
# Line 835  gpg_keycache_get_default_key (gpg_keycac Line 835  gpg_keycache_get_default_key (gpg_keycac
835  }  }
836    
837    
838    static gpgme_error_t
839    decode_subpacket (const char *subpkt_data, int *type,
840                      char **out, WORD *outlen)
841    {
842        char tmp[128], *p = tmp, *val;
843        char *enc = NULL;
844        size_t pos = 0, i=0;
845    
846        /* example: spk:24:1:21:http%3A//subkeys.pgp.de */
847        *outlen = 0;
848        *out = NULL;
849        
850        if (strncmp (subpkt_data, "spk:", 4))
851            return gpg_error (GPG_ERR_NO_DATA);
852    
853        strncpy (tmp, subpkt_data, 62);
854        val = strtok (tmp, ":");
855        while (val != NULL) {
856            switch (pos++) {
857            case 0:
858                break;
859    
860            case 1:
861                if (type)
862                    *type = atoi (val);
863                break;
864    
865            case 2:
866                break;
867    
868            case 3:
869                *outlen = atoi (val);
870                break;
871    
872            case 4:
873                enc = strdup (val);
874                break;
875            }
876            val = strtok (NULL, ":");
877        }
878        if (!enc)
879            return gpg_error (GPG_ERR_NO_DATA);;
880        *out = (char*)calloc (1, strlen (enc)+1);
881        if (!*out)
882            BUG (0);
883        for (pos = 0; pos < strlen (enc); pos++) {
884            if (enc[pos] == '%' && enc[pos+1] == '%')
885                (*out)[i++] = '%';
886            else if (enc[pos] == '%') {
887                char temp[3];
888                temp[0] = enc[++pos];
889                temp[1] = enc[++pos];
890                temp[2] = 0;
891                (*out)[i++] = (char)strtoul (temp, NULL, 16);
892            }
893            else
894                (*out)[i++] = enc[pos];
895        }
896        (*out)[i] = 0;
897        free (enc);
898        return 0;
899    }
900    
901    
902    /* If the attribute given in @attr is not set in the
903       key cache object, try to update it. */
904    gpgme_error_t
905    gpg_keycache_update_attr (struct keycache_s *item,
906                              int attr, int force)
907    {
908        gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
909        char *val = NULL;
910        WORD n = 0;    
911    
912        switch (attr) {
913        case KC_ATTR_PREFSYM:
914            if (!force && item->sym_prefs)
915                break;
916            safe_free (item->sym_prefs);
917            err = gpg_find_key_subpacket (item->key->subkeys->keyid+8, attr, &val);
918            if (!err && val != NULL)
919                err = decode_subpacket (val, NULL, (char**)&item->sym_prefs, &n);
920            break;
921    
922        case KC_ATTR_PREFKSERV:
923            if (!force && item->pref_keyserver)
924                break;
925            safe_free (item->pref_keyserver);
926            err = gpg_find_key_subpacket (item->key->subkeys->keyid+8, attr, &val);
927            if (!err && val != NULL)
928                err = decode_subpacket (val, NULL, &item->pref_keyserver, &n);
929            break;
930        }
931        safe_free (val);
932        return err;
933    }
934    

Legend:
Removed from v.168  
changed lines
  Added in v.188

[email protected]
ViewVC Help
Powered by ViewVC 1.1.26