* g10.c (main): Add --no-textmode.
[gnupg.git] / g10 / parse-packet.c
index 5ed75e4..7b50206 100644 (file)
@@ -752,12 +752,12 @@ dump_sig_subpkt( int hashed, int type, int critical,
                type, (unsigned)length );
     }
     
+    buffer++;
+    length--;
    
     printf("\t%s%ssubpkt %d len %u (", /*)*/
              critical ? "critical ":"",
              hashed ? "hashed ":"", type, (unsigned)length );
-    buffer++;
-    length--;
     if( length > buflen ) {
        printf("too short: buffer is only %u)\n", (unsigned)buflen );
        return;
@@ -778,13 +778,13 @@ dump_sig_subpkt( int hashed, int type, int critical,
        break;
       case SIGSUBPKT_TRUST:
        if(length!=2)
-         p="[invalid trust signature]";
+         p="[invalid trust subpacket]";
        else
-         printf("trust signature of level %d, amount %d",buffer[0],buffer[1]);
+         printf("trust signature of depth %d, value %d",buffer[0],buffer[1]);
        break;
       case SIGSUBPKT_REGEXP:
        if(!length)
-         p="[invalid regexp]";
+         p="[invalid regexp subpacket]";
        else
          printf("regular expression: \"%s\"",buffer);
        break;
@@ -823,8 +823,6 @@ dump_sig_subpkt( int hashed, int type, int critical,
            fputs("notation: ", stdout );
            if( length < 8 )
                p = "[too short]";
-           else if( !(*buffer & 0x80) )
-               p = "[not human readable]";
            else {
                const byte *s = buffer;
                size_t n1, n2;
@@ -837,7 +835,11 @@ dump_sig_subpkt( int hashed, int type, int critical,
                else {
                    print_string( stdout, s, n1, ')' );
                    putc( '=', stdout );
-                   print_string( stdout, s+n1, n2, ')' );
+
+                   if( *buffer & 0x80 )
+                     print_string( stdout, s+n1, n2, ')' );
+                   else
+                     p = "[not human readable]";
                }
            }
        }
@@ -933,6 +935,7 @@ parse_one_sig_subpkt( const byte *buffer, size_t n, int type )
       case SIGSUBPKT_PREF_COMPR:
       case SIGSUBPKT_POLICY:
       case SIGSUBPKT_FEATURES:
+      case SIGSUBPKT_REGEXP:
        return 0;
       case SIGSUBPKT_EXPORTABLE:
       case SIGSUBPKT_REVOCABLE:
@@ -955,6 +958,10 @@ parse_one_sig_subpkt( const byte *buffer, size_t n, int type )
           if ( n != 1 )
               break;
           return 0;   
+      case SIGSUBPKT_TRUST:
+         if ( n != 2 )
+             break;
+         return 0;
       case SIGSUBPKT_PRIV_VERIFY_CACHE:
         /* We used this in gpg 1.0.5 and 1.0.6 to cache signature
          * verification results - it is no longer used.
@@ -997,6 +1004,8 @@ can_handle_critical( const byte *buffer, size_t n, int type )
       case SIGSUBPKT_PRIMARY_UID:
       case SIGSUBPKT_FEATURES:
       case SIGSUBPKT_POLICY: /* Is it enough to show the policy? */
+      case SIGSUBPKT_TRUST:
+      case SIGSUBPKT_REGEXP:
        return 1;
 
       default:
@@ -1061,13 +1070,15 @@ enum_sig_subpkt( const subpktarea_t *pktbuf, sigsubpkttype_t reqtype,
            if( *critical ) {
                if( n-1 > buflen+1 )
                    goto too_short;
-               if( !can_handle_critical(buffer+1, n-1, type ) ) {
-                   log_info(_("subpacket of type %d has critical bit set\n"),
-                                                                       type);
+               if( !can_handle_critical(buffer+1, n-1, type ) )
+                 {
+                   if(opt.verbose)
+                     log_info(_("subpacket of type %d has "
+                                "critical bit set\n"),type);
                    if( start )
-                       *start = seq;
+                     *start = seq;
                    return NULL; /* this is an error */
-               }
+                 }
            }
        }
        else if( reqtype < 0 ) /* list packets */
@@ -1221,7 +1232,7 @@ parse_signature( IOBUF inp, int pkttype, unsigned long pktlen,
        }
        if( n ) {
             /* we add 8 extra bytes so that we have space for the signature
-             * status cache.  Well we are wastin this if there is a cache
+             * status cache.  Well we are wasting this if there is a cache
              * packet already, but in the other case it avoids an realloc */
            sig->unhashed = m_alloc (sizeof(*sig->unhashed) + n + 8 - 1 );
             sig->unhashed->size = n + 8;
@@ -1247,6 +1258,7 @@ parse_signature( IOBUF inp, int pkttype, unsigned long pktlen,
 
     if( is_v4 && sig->pubkey_algo ) { /*extract required information */
        const byte *p;
+       size_t len;
 
        /* set sig->flags.unknown_critical if there is a
         * critical bit set for packets which we do not understand */
@@ -1288,6 +1300,23 @@ parse_signature( IOBUF inp, int pkttype, unsigned long pktlen,
        if(p && *p==0)
          sig->flags.revocable=0;
 
+       p=parse_sig_subpkt(sig->hashed,SIGSUBPKT_TRUST,&len);
+       if(p && len==2)
+         {
+           sig->trust_depth=p[0];
+           sig->trust_value=p[1];
+
+           /* Only look for a regexp if there is also a trust
+              subpacket. */
+           sig->trust_regexp=
+             parse_sig_subpkt(sig->hashed,SIGSUBPKT_REGEXP,&len);
+
+           /* If the regular expression is of 0 length, there is no
+              regular expression. */
+           if(len==0)
+             sig->trust_regexp=NULL;
+         }
+
        /* We accept the exportable subpacket from either the hashed
           or unhashed areas as older versions of gpg put it in the
           unhashed area.  In theory, anyway, we should never see this
@@ -1523,6 +1552,7 @@ parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
        pk->max_expiredate = max_expiredate;
        pk->hdrbytes    = hdrlen;
        pk->version     = version;
+       pk->is_primary = pkttype == PKT_PUBLIC_KEY;
        pk->pubkey_algo = algorithm;
        pk->req_usage = 0; 
        pk->pubkey_usage = 0; /* not yet used */
@@ -1574,6 +1604,9 @@ parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
                }
                 sk->protect.sha1chk = (sk->protect.algo == 254);
                sk->protect.algo = iobuf_get_noeof(inp); pktlen--;
+               /* Note that a sk->protect.algo > 110 is illegal, but
+                  I'm not erroring on it here as otherwise there
+                  would be no way to delete such a key. */
                sk->protect.s2k.mode  = iobuf_get_noeof(inp); pktlen--;
                sk->protect.s2k.hash_algo = iobuf_get_noeof(inp); pktlen--;
                /* check for the special GNU extension */
@@ -1647,6 +1680,9 @@ parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
                                            (ulong)sk->protect.s2k.count);
                }
            }
+           /* Note that a sk->protect.algo > 110 is illegal, but I'm
+              not erroring on it here as otherwise there would be no
+              way to delete such a key. */
            else { /* old version; no S2K, so we set mode to 0, hash MD5 */
                sk->protect.s2k.mode = 0;
                sk->protect.s2k.hash_algo = DIGEST_ALGO_MD5;
@@ -1845,6 +1881,7 @@ static void setup_user_id(PACKET *packet)
   packet->pkt.user_id->help_key_usage = 0;
   packet->pkt.user_id->help_key_expire = 0;
   packet->pkt.user_id->prefs = NULL;
+  packet->pkt.user_id->namehash = NULL;
 }
 
 static int