Changeset 317

Show
Ignore:
Timestamp:
11/30/05 15:23:25
Author:
ben
Message:

Ignore trailing whitespace. Hide memory structures.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • openpgpsdk/trunk/examples/Makefile.template

    r314 r317  
    8989        echo "Sign this!" > $(SCRATCH)/to-be-signed-inline 
    9090        echo "- test dash-escaping" >> $(SCRATCH)/to-be-signed-inline 
     91        echo "and test trailing whitespace   " >> $(SCRATCH)/to-be-signed-inline 
    9192        ./sign-inline $(SCRATCH)/key.sec "Why a user ID?" SHA1 $(SCRATCH)/to-be-signed-inline $(SCRATCH)/to-be-signed-inline.sig 
    9293 

  • openpgpsdk/trunk/include/openpgpsdk/memory.h

    r307 r317  
    1111/** ops_memory_t 
    1212 */ 
    13 typedef struct  
    14     { 
    15     unsigned char *buf; 
    16     size_t length; 
    17     size_t allocated; 
    18     } ops_memory_t; 
     13typedef struct ops_memory ops_memory_t; 
    1914 
     15ops_memory_t *ops_memory_new(void); 
     16void ops_memory_free(ops_memory_t *mem); 
    2017void ops_memory_init(ops_memory_t *mem,size_t initial_size); 
    2118void ops_memory_pad(ops_memory_t *mem,size_t length); 
    …… 
    2421                          size_t length); 
    2522void ops_memory_make_packet(ops_memory_t *out,ops_content_tag_t tag); 
     23void ops_memory_clear(ops_memory_t *mem); 
    2624void ops_memory_release(ops_memory_t *mem); 
    2725 
    2826void ops_create_info_set_writer_memory(ops_create_info_t *info, 
    2927                                       ops_memory_t *mem); 
     28 
     29size_t ops_memory_get_length(const ops_memory_t *mem); 
     30void *ops_memory_get_data(ops_memory_t *mem); 
     31 
    3032#endif 

  • openpgpsdk/trunk/src/accumulate.c

    r271 r317  
    7676 * \ingroup Parse 
    7777 * 
    78  * ops_parse_and_accumulate() parses packets from an input stream until EOF or error. 
     78 * Parse packets from an input stream until EOF or error. 
    7979 * 
    80  * The parsed data is added to "keyring". 
     80 * Key data found in the parsed data is added to #keyring. 
    8181 * 
    82  * Once all the input data has been parsed: 
    83  * - the keyring is printed to stdout 
    84  * - each signature on the keyring is validated, with the result printed to stdout 
    85  * 
    86  * \sa See Detailed Description for usage. 
    87  * 
    88  * \param *keyring Pointer to an existing keyring 
    89  * \param *opt Options to use when parsing 
     82 * \param keyring Pointer to an existing keyring 
     83 * \param opt Options to use when parsing 
    9084*/ 
    9185 

  • openpgpsdk/trunk/src/armour.c

    r316 r317  
    719719    ops_boolean_t seen_cr:1; 
    720720    ops_create_signature_t *sig; 
     721    ops_memory_t *trailing; 
    721722    } dash_escaped_arg_t; 
    722723 
    …… 
    732733    for(n=0 ; n < length ; ++n) 
    733734        { 
     735        unsigned l; 
     736 
    734737        if(arg->seen_nl) 
    735738            { 
    …… 
    738741            arg->seen_nl=ops_false; 
    739742            } 
     743 
    740744        arg->seen_nl=src[n] == '\n'; 
     745 
    741746        if(arg->seen_nl && !arg->seen_cr) 
    742747            { 
    …… 
    745750            ops_signature_add_data(arg->sig,"\r",1); 
    746751            } 
     752 
    747753        arg->seen_cr=src[n] == '\r'; 
     754 
    748755        if(!ops_stacked_write(&src[n],1,errors,winfo)) 
    749756            return ops_false; 
    750         ops_signature_add_data(arg->sig,&src[n],1); 
     757 
     758        /* trailing whitespace isn't included in the signature */ 
     759        if(src[n] == ' ' || src[n] == '\t') 
     760            ops_memory_add(arg->trailing,&src[n],1); 
     761        else 
     762            { 
     763            if((l=ops_memory_get_length(arg->trailing))) 
     764                { 
     765                if(!arg->seen_nl && !arg->seen_cr) 
     766                    ops_signature_add_data(arg->sig, 
     767                                           ops_memory_get_data(arg->trailing), 
     768                                           l); 
     769                ops_memory_clear(arg->trailing); 
     770                } 
     771            ops_signature_add_data(arg->sig,&src[n],1); 
     772            } 
    751773        } 
    752774 
    …… 
    758780    dash_escaped_arg_t *arg=ops_writer_get_arg(winfo); 
    759781 
     782    ops_memory_free(arg->trailing); 
    760783    free(arg); 
    761784    } 
    …… 
    774797    arg->seen_nl=ops_true; 
    775798    arg->sig=sig; 
     799    arg->trailing=ops_memory_new(); 
    776800    ops_writer_push(info,dash_escaped_writer,NULL,dash_escaped_destroyer,arg); 
    777801    } 
    …… 
    913937                    ops_mallocz(sizeof(linebreak_arg_t))); 
    914938 
    915  
    916939    base64=ops_mallocz(sizeof *base64); 
    917940    base64->checksum=CRC24_INIT; 

  • openpgpsdk/trunk/src/fingerprint.c

    r312 r317  
    5252    else 
    5353        { 
    54         ops_memory_t mem; 
     54        ops_memory_t *mem=ops_memory_new(); 
    5555        ops_hash_t sha1; 
     56        size_t l; 
    5657 
    57         memset(&mem,'\0',sizeof mem); 
    58  
    59         ops_build_public_key(&mem,key,ops_false); 
     58        ops_build_public_key(mem,key,ops_false); 
    6059 
    6160        ops_hash_sha1(&sha1); 
    6261        sha1.init(&sha1); 
    6362 
     63        l=ops_memory_get_length(mem); 
     64 
    6465        ops_hash_add_int(&sha1,0x99,1); 
    65         ops_hash_add_int(&sha1,mem.length,2); 
    66         sha1.add(&sha1,mem.buf,mem.length); 
     66        ops_hash_add_int(&sha1,l,2); 
     67        sha1.add(&sha1,ops_memory_get_data(mem),l); 
    6768        sha1.finish(&sha1,fp->fingerprint); 
     69 
    6870        fp->length=20; 
    6971 
    70         ops_memory_release(&mem); 
     72        ops_memory_free(mem); 
    7173        } 
    7274    } 

  • openpgpsdk/trunk/src/memory.c

    r314 r317  
    66#include <string.h> 
    77#include <assert.h> 
     8 
     9struct ops_memory 
     10    { 
     11    unsigned char *buf; 
     12    size_t length; 
     13    size_t allocated; 
     14    }; 
    815 
    916void ops_memory_init(ops_memory_t *mem,size_t initial_size) 
    …… 
    5259    } 
    5360 
     61/** 
     62 * Unlike ops_memory_release(), this retains the allocated memory but 
     63 * sets the length of stored data to zero. 
     64 */ 
     65void ops_memory_clear(ops_memory_t *mem) 
     66    { mem->length=0; } 
     67 
    5468void ops_memory_release(ops_memory_t *mem) 
    5569    { 
    5670    free(mem->buf); 
    5771    mem->buf=NULL; 
     72    mem->length=0; 
    5873    } 
    5974 
    …… 
    7691 * 
    7792 * \param info The info structure 
    78  * \param mem The memory structure 
    79  */ 
     93 * \param mem The memory structure */ 
    8094 
    8195void ops_create_info_set_writer_memory(ops_create_info_t *info, 
    …… 
    119133    out->length+=extra+1; 
    120134    } 
     135 
     136ops_memory_t *ops_memory_new() 
     137    { return ops_mallocz(sizeof(ops_memory_t)); } 
     138 
     139void ops_memory_free(ops_memory_t *mem) 
     140    { 
     141    ops_memory_release(mem); 
     142    free(mem); 
     143    } 
     144 
     145size_t ops_memory_get_length(const ops_memory_t *mem) 
     146    { return mem->length; } 
     147 
     148void *ops_memory_get_data(ops_memory_t *mem) 
     149    { return mem->buf; } 

  • openpgpsdk/trunk/src/signature.c

    r314 r317  
    1515    ops_hash_t hash;  
    1616    ops_signature_t sig;  
    17     ops_memory_t mem;  
     17    ops_memory_t *mem;  
    1818    ops_create_info_t *info; /*!< how to do the writing */ 
    1919    unsigned hashed_count_offset; 
    …… 
    140140static void hash_add_key(ops_hash_t *hash,const ops_public_key_t *key) 
    141141    { 
    142     ops_memory_t mem; 
    143  
    144     memset(&mem,'\0',sizeof mem); 
    145     ops_build_public_key(&mem,key,ops_false); 
    146  
     142    ops_memory_t *mem=ops_memory_new(); 
     143    size_t l; 
     144 
     145    ops_build_public_key(mem,key,ops_false); 
     146 
     147    l=ops_memory_get_length(mem); 
    147148    ops_hash_add_int(hash,0x99,1); 
    148     ops_hash_add_int(hash,mem.length,2); 
    149     hash->add(hash,mem.buf,mem.length); 
    150  
    151     ops_memory_release(&mem); 
     149    ops_hash_add_int(hash,l,2); 
     150    hash->add(hash,ops_memory_get_data(mem),l); 
     151 
     152    ops_memory_free(mem); 
    152153    } 
    153154 
    …… 
    315316    return finalise_signature(hash,sig,signer,NULL); 
    316317    } 
    317      
     318 
     319static void start_signature(ops_create_signature_t *sig) 
     320    { 
     321    // since this has subpackets and stuff, we have to buffer the whole 
     322    // thing to get counts before writing. 
     323    sig->mem=ops_memory_new(); 
     324    ops_memory_init(sig->mem,100); 
     325    ops_create_info_set_writer_memory(sig->info,sig->mem); 
     326 
     327    // write nearly up to the first subpacket 
     328    ops_write_scalar(sig->sig.version,1,sig->info); 
     329    ops_write_scalar(sig->sig.type,1,sig->info); 
     330    ops_write_scalar(sig->sig.key_algorithm,1,sig->info); 
     331    ops_write_scalar(sig->sig.hash_algorithm,1,sig->info); 
     332 
     333    // dummy hashed subpacket count 
     334    sig->hashed_count_offset=ops_memory_get_length(sig->mem); 
     335    ops_write_scalar(0,2,sig->info); 
     336    }     
    318337 
    319338/** 
    …… 
    351370    sig->hash.add(&sig->hash,id->user_id,strlen((char *)id->user_id)); 
    352371 
    353     // since this has subpackets and stuff, we have to buffer the whole 
    354     // thing to get counts before writing. 
    355     ops_memory_init(&sig->mem,100); 
    356     ops_create_info_set_writer_memory(sig->info,&sig->mem); 
    357  
    358     // write nearly up to the first subpacket 
    359     ops_write_scalar(sig->sig.version,1,sig->info); 
    360     ops_write_scalar(sig->sig.type,1,sig->info); 
    361     ops_write_scalar(sig->sig.key_algorithm,1,sig->info); 
    362     ops_write_scalar(sig->sig.hash_algorithm,1,sig->info); 
    363  
    364     // dummy hashed subpacket count 
    365     sig->hashed_count_offset=sig->mem.length; 
    366     ops_write_scalar(0,2,sig->info); 
     372    start_signature(sig); 
    367373    } 
    368374 
    …… 
    395401 
    396402    common_init_signature(&sig->hash,&sig->sig); 
    397  
    398     // since this has subpackets and stuff, we have to buffer the whole 
    399     // thing to get counts before writing. 
    400     ops_memory_init(&sig->mem,100); 
    401     ops_create_info_set_writer_memory(sig->info,&sig->mem); 
    402  
    403     // write nearly up to the first subpacket 
    404     ops_write_scalar(sig->sig.version,1,sig->info); 
    405     ops_write_scalar(sig->sig.type,1,sig->info); 
    406     ops_write_scalar(sig->sig.key_algorithm,1,sig->info); 
    407     ops_write_scalar(sig->sig.hash_algorithm,1,sig->info); 
    408  
    409     // dummy hashed subpacket count 
    410     sig->hashed_count_offset=sig->mem.length; 
    411     ops_write_scalar(0,2,sig->info); 
     403    start_signature(sig); 
    412404    } 
    413405 
    …… 
    437429void ops_signature_hashed_subpackets_end(ops_create_signature_t *sig) 
    438430    { 
    439     sig->hashed_data_length=sig->mem.length-sig->hashed_count_offset-2; 
    440     ops_memory_place_int(&sig->mem,sig->hashed_count_offset, 
     431    sig->hashed_data_length=ops_memory_get_length(sig->mem) 
     432        -sig->hashed_count_offset-2; 
     433    ops_memory_place_int(sig->mem,sig->hashed_count_offset, 
    441434                         sig->hashed_data_length,2); 
    442435    // dummy unhashed subpacket count 
    443     sig->unhashed_count_offset=sig->mem.length; 
     436    sig->unhashed_count_offset=ops_memory_get_length(sig->mem); 
    444437    ops_write_scalar(0,2,sig->info); 
    445438    } 
    …… 
    461454                         ops_secret_key_t *skey,ops_create_info_t *info) 
    462455    { 
     456    size_t l=ops_memory_get_length(sig->mem); 
     457 
    463458    assert(sig->hashed_data_length != (unsigned)-1); 
    464459 
    465     ops_memory_place_int(&sig->mem,sig->unhashed_count_offset, 
    466                          sig->mem.length-sig->unhashed_count_offset-2,2); 
     460    ops_memory_place_int(sig->mem,sig->unhashed_count_offset, 
     461                         l-sig->unhashed_count_offset-2,2); 
    467462 
    468463    // add the packet from version number to end of hashed subpackets 
    469     sig->hash.add(&sig->hash,sig->mem.buf,sig->unhashed_count_offset); 
     464    sig->hash.add(&sig->hash,ops_memory_get_data(sig->mem), 
     465                  sig->unhashed_count_offset); 
    470466    ops_hash_add_int(&sig->hash,sig->sig.version,1); 
    471467    ops_hash_add_int(&sig->hash,0xff,1); 
    …… 
    479475 
    480476    ops_write_ptag(OPS_PTAG_CT_SIGNATURE,info); 
    481     ops_write_length(sig->mem.length,info); 
    482     ops_write(sig->mem.buf,sig->mem.length,info); 
    483  
    484     ops_memory_release(&sig->mem); 
     477    l=ops_memory_get_length(sig->mem); 
     478    ops_write_length(l,info); 
     479    ops_write(ops_memory_get_data(sig->mem),l,info); 
     480 
     481    ops_memory_free(sig->mem); 
    485482    } 
    486483