See ChangeLog: Fri Nov 27 15:30:24 CET 1998 Werner Koch
[gnupg.git] / g10 / parse-packet.c
index 1cd14ac..2d82308 100644 (file)
@@ -33,6 +33,7 @@
 #include "filter.h"
 #include "options.h"
 #include "main.h"
+#include "i18n.h"
 
 static int mpi_print_mode = 0;
 static int list_mode = 0;
@@ -105,7 +106,7 @@ unknown_pubkey_warning( int algo )
     algo &= 0xff;
     if( !unknown_pubkey_algos[algo] ) {
        if( opt.verbose )
-           log_info("can't handle public key algorithm %d\n", algo );
+           log_info(_("can't handle public key algorithm %d\n"), algo );
        unknown_pubkey_algos[algo] = 1;
     }
 }
@@ -287,7 +288,7 @@ parse( IOBUF inp, PACKET *pkt, int reqtype, ulong *retpos,
     }
 
     if( do_skip || !pkttype || (reqtype && pkttype != reqtype) ) {
-       skip_packet(inp, pkttype, pktlen);
+       skip_rest(inp, pktlen);
        *skip = 1;
        rc = 0;
        goto leave;
@@ -406,10 +407,14 @@ static void
 skip_packet( IOBUF inp, int pkttype, unsigned long pktlen )
 {
     if( list_mode ) {
-       printf(":unknown packet: type %2d, length %lu\n", pkttype, pktlen );
+       if( pkttype == PKT_MARKER )
+           fputs(":marker packet:\n", stdout );
+       else
+           printf(":unknown packet: type %2d, length %lu\n", pkttype, pktlen);
        if( pkttype ) {
            int c, i=0 ;
-           printf("dump:");
+           if( pkttype != PKT_MARKER )
+               fputs("dump:", stdout );
            if( iobuf_in_block_mode(inp) ) {
                while( (c=iobuf_get(inp)) != -1 )
                    dump_hex_line(c, &i);
@@ -608,6 +613,107 @@ parse_pubkeyenc( IOBUF inp, int pkttype, unsigned long pktlen, PACKET *packet )
 }
 
 
+static void
+dump_sig_subpkt( int hashed, int type, int critical,
+                const byte *buffer, size_t buflen, size_t length )
+{
+    const char *p=NULL;
+    int i;
+
+    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;
+    }
+    switch( type ) {
+      case SIGSUBPKT_SIG_CREATED:
+       if( length >= 4 )
+           printf("sig created %s", strtimestamp( buffer_to_u32(buffer) ) );
+       break;
+      case SIGSUBPKT_SIG_EXPIRE:
+       if( length >= 4 )
+           printf("sig expires after %s",
+                                    strtimevalue( buffer_to_u32(buffer) ) );
+       break;
+      case SIGSUBPKT_EXPORTABLE:
+       if( length )
+           printf("%sexportable", *buffer? "":"not ");
+       break;
+      case SIGSUBPKT_TRUST:
+       p = "trust signature";
+       break;
+      case SIGSUBPKT_REGEXP:
+       p = "regular expression";
+       break;
+      case SIGSUBPKT_REVOCABLE:
+       p = "revocable";
+       break;
+      case SIGSUBPKT_KEY_EXPIRE:
+       if( length >= 4 )
+           printf("key expires after %s",
+                                   strtimevalue( buffer_to_u32(buffer) ) );
+       break;
+      case SIGSUBPKT_ARR:
+       p = "additional recipient request";
+       break;
+      case SIGSUBPKT_PREF_SYM:
+       fputs("pref-sym-algos:", stdout );
+       for( i=0; i < length; i++ )
+           printf(" %d", buffer[i] );
+       break;
+      case SIGSUBPKT_REV_KEY:
+       p = "revocation key";
+       break;
+      case SIGSUBPKT_ISSUER:
+       if( length >= 8 )
+           printf("issuer key ID %08lX%08lX",
+                     (ulong)buffer_to_u32(buffer),
+                     (ulong)buffer_to_u32(buffer+4) );
+       break;
+      case SIGSUBPKT_NOTATION:
+       p = "notation data";
+       break;
+      case SIGSUBPKT_PREF_HASH:
+       fputs("pref-hash-algos:", stdout );
+       for( i=0; i < length; i++ )
+           printf(" %d", buffer[i] );
+       break;
+      case SIGSUBPKT_PREF_COMPR:
+       fputs("pref-zip-algos:", stdout );
+       for( i=0; i < length; i++ )
+           printf(" %d", buffer[i] );
+       break;
+      case SIGSUBPKT_KS_FLAGS:
+       p = "key server preferences";
+       break;
+      case SIGSUBPKT_PREF_KS:
+       p = "preferred key server";
+       break;
+      case SIGSUBPKT_PRIMARY_UID:
+       p = "primary user id";
+       break;
+      case SIGSUBPKT_POLICY:
+       p = "policy URL";
+       break;
+      case SIGSUBPKT_KEY_FLAGS:
+       p = "key flags";
+       break;
+      case SIGSUBPKT_SIGNERS_UID:
+       p = "signer's user id";
+       break;
+      case SIGSUBPKT_PRIV_ADD_SIG:
+       p = "signs additional user id";
+       break;
+      default: p = "?"; break;
+    }
+
+    printf("%s)\n", p? p: "");
+}
+
 const byte *
 parse_sig_subpkt( const byte *buffer, sigsubpkttype_t reqtype, size_t *ret_n )
 {
@@ -648,32 +754,9 @@ parse_sig_subpkt( const byte *buffer, sigsubpkttype_t reqtype, size_t *ret_n )
        }
        else
            critical = 0;
-       if( reqtype < 0 ) { /* list packets */
-           printf("\t%ssubpacket %d of length %u (%s)\n",
-           reqtype == SIGSUBPKT_LIST_HASHED ? "hashed ":"", type, (unsigned)n,
-            type == SIGSUBPKT_SIG_CREATED ? "signature creation time"
-          : type == SIGSUBPKT_SIG_EXPIRE  ? "signature expiration time"
-          : type == SIGSUBPKT_EXPORTABLE  ? "exportable"
-          : type == SIGSUBPKT_TRUST       ? "trust signature"
-          : type == SIGSUBPKT_REGEXP      ? "regular expression"
-          : type == SIGSUBPKT_REVOCABLE   ? "revocable"
-          : type == SIGSUBPKT_KEY_EXPIRE  ? "key expiration time"
-          : type == SIGSUBPKT_ARR         ? "additional recipient request"
-          : type == SIGSUBPKT_PREF_SYM    ? "preferred symmetric algorithms"
-          : type == SIGSUBPKT_REV_KEY     ? "revocation key"
-          : type == SIGSUBPKT_ISSUER      ? "issuer key ID"
-          : type == SIGSUBPKT_NOTATION    ? "notation data"
-          : type == SIGSUBPKT_PREF_HASH   ? "preferred hash algorithms"
-          : type == SIGSUBPKT_PREF_COMPR  ? "preferred compression algorithms"
-          : type == SIGSUBPKT_KS_FLAGS    ? "key server preferences"
-          : type == SIGSUBPKT_PREF_KS     ? "preferred key server"
-          : type == SIGSUBPKT_PRIMARY_UID ? "primary user id"
-          : type == SIGSUBPKT_POLICY      ? "policy URL"
-          : type == SIGSUBPKT_KEY_FLAGS   ? "key flags"
-          : type == SIGSUBPKT_SIGNERS_UID ? "signer's user id"
-          : type == SIGSUBPKT_PRIV_ADD_SIG? "signs additional user id"
-                             : "?");
-       }
+       if( reqtype < 0 ) /* list packets */
+           dump_sig_subpkt( reqtype == SIGSUBPKT_LIST_HASHED,
+                                   type, critical, buffer, buflen, n );
        else if( type == reqtype )
            break; /* found */
        buffer += n; buflen -=n;
@@ -691,6 +774,10 @@ parse_sig_subpkt( const byte *buffer, sigsubpkttype_t reqtype, size_t *ret_n )
        if( n < 4 )
            break;
        return buffer;
+      case SIGSUBPKT_EXPORTABLE:
+       if( !n )
+           break;
+       return buffer;
       case SIGSUBPKT_ISSUER:/* issuer key ID */
        if( n < 8 )
            break;
@@ -811,6 +898,11 @@ parse_signature( IOBUF inp, int pkttype, unsigned long pktlen,
 
     if( is_v4 ) { /*extract required information */
        const byte *p;
+
+       /* FIXME: set sig->flags.unknown_critical is there is a
+        * critical bit set for packets which are not understood
+        * It does only make sense for hashed data.
+        */
        p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_SIG_CREATED, NULL );
        if( !p )
            log_error("signature packet without timestamp\n");
@@ -912,8 +1004,7 @@ parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
 {
     int i, version, algorithm;
     unsigned n;
-    unsigned long timestamp;
-    unsigned short valid_period;
+    unsigned long timestamp, expiredate;
     int npkey, nskey;
     int is_v4=0;
     int rc=0;
@@ -951,25 +1042,30 @@ parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
 
     timestamp = read_32(inp); pktlen -= 4;
     if( is_v4 )
-       valid_period = 0;
+       expiredate = 0; /* have to get it from the selfsignature */
     else {
-       valid_period = read_16(inp); pktlen -= 2;
+       unsigned short ndays;
+       ndays = read_16(inp); pktlen -= 2;
+       if( ndays )
+           expiredate = timestamp + ndays * 86400L;
+       else
+           expiredate = 0;
     }
     algorithm = iobuf_get_noeof(inp); pktlen--;
     if( list_mode )
        printf(":%s key packet:\n"
-              "\tversion %d, algo %d, created %lu, valid for %hu days\n",
+              "\tversion %d, algo %d, created %lu, expires %lu\n",
                pkttype == PKT_PUBLIC_KEY? "public" :
                pkttype == PKT_SECRET_KEY? "secret" :
                pkttype == PKT_PUBLIC_SUBKEY? "public sub" :
                pkttype == PKT_SECRET_SUBKEY? "secret sub" : "??",
-               version, algorithm, timestamp, valid_period );
+               version, algorithm, timestamp, expiredate );
 
     if( pkttype == PKT_SECRET_KEY || pkttype == PKT_SECRET_SUBKEY )  {
        PKT_secret_key *sk = pkt->pkt.secret_key;
 
        sk->timestamp = timestamp;
-       sk->valid_days = valid_period;
+       sk->expiredate = expiredate;
        sk->hdrbytes = hdrlen;
        sk->version = version;
        sk->pubkey_algo = algorithm;
@@ -979,7 +1075,7 @@ parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
        PKT_public_key *pk = pkt->pkt.public_key;
 
        pk->timestamp = timestamp;
-       pk->valid_days = valid_period;
+       pk->expiredate = expiredate;
        pk->hdrbytes    = hdrlen;
        pk->version     = version;
        pk->pubkey_algo = algorithm;