Changeset 611

Show
Ignore:
Timestamp:
09/03/08 09:37:32
Author:
rachel
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • openpgpsdk/trunk/src/lib/create.c

    r599 r611  
    397397 
    398398 
    399 ops_boolean_t ops_write_transferable_public_key(const ops_keydata_t *key, ops_boolean_t armoured, ops_create_info_t *info) 
     399/** 
     400   \ingroup HighLevel_Key 
     401 
     402   \brief Writes a transferable PGP public key to the given output stream. 
     403 
     404   \param keydata Key to be written 
     405   \param armoured Flag is set for armoured output 
     406   \param info Output stream 
     407 
     408   Example code: 
     409   \code 
     410   void example(const ops_keydata_t* keydata) 
     411   { 
     412   ops_boolean_t armoured=ops_true; 
     413   char* filename="/tmp/testkey.asc"; 
     414 
     415   int fd; 
     416   ops_boolean_t overwrite=ops_true; 
     417   ops_create_info_t* cinfo; 
     418 
     419   fd=ops_setup_file_write(&cinfo, filename, overwrite); 
     420   ops_write_transferable_public_key(keydata,armoured,cinfo); 
     421   ops_teardown_file_write(cinfo,fd); 
     422   } 
     423   \endcode 
     424*/ 
     425 
     426ops_boolean_t ops_write_transferable_public_key(const ops_keydata_t *keydata, ops_boolean_t armoured, ops_create_info_t *info) 
    400427    { 
    401428    ops_boolean_t rtn; 
     
    406433 
    407434    // public key 
    408     rtn=ops_write_struct_public_key(&key->key.skey.public_key,info); 
     435    rtn=ops_write_struct_public_key(&keydata->key.skey.public_key,info); 
    409436    if (rtn!=ops_true) 
    410437        return rtn; 
     
    413440 
    414441    // user ids and corresponding signatures 
    415     for (i=0; i<key->nuids; i++) 
    416         { 
    417         ops_user_id_t* uid=&key->uids[i]; 
     442    for (i=0; i<keydata->nuids; i++) 
     443        { 
     444        ops_user_id_t* uid=&keydata->uids[i]; 
    418445 
    419446        rtn=ops_write_struct_user_id(uid, info); 
     
    423450 
    424451        // find signature for this packet if it exists 
    425         for (j=0; j<key->nsigs; j++) 
     452        for (j=0; j<keydata->nsigs; j++) 
    426453            { 
    427             sigpacket_t* sig=&key->sigs[i]; 
     454            sigpacket_t* sig=&keydata->sigs[i]; 
    428455            if (!strcmp((char *)sig->userid->user_id, (char *)uid->user_id)) 
    429456                { 
     
    448475    } 
    449476 
    450 ops_boolean_t ops_write_transferable_secret_key(const ops_keydata_t *key, const unsigned char* passphrase, const size_t pplen, ops_boolean_t armoured, ops_create_info_t *info) 
     477/** 
     478   \ingroup HighLevel_Key 
     479 
     480   \brief Writes a transferable PGP secret key to the given output stream. 
     481 
     482   \param keydata Key to be written 
     483   \param armoured Flag is set for armoured output 
     484   \param info Output stream 
     485 
     486   Example code: 
     487   \code 
     488   void example(const ops_keydata_t* keydata) 
     489   { 
     490   const unsigned char* passphrase=NULL; 
     491   const size_t passphraselen=0; 
     492   ops_boolean_t armoured=ops_true; 
     493 
     494   int fd; 
     495   char* filename="/tmp/testkey.asc"; 
     496   ops_boolean_t overwrite=ops_true; 
     497   ops_create_info_t* cinfo; 
     498 
     499   fd=ops_setup_file_write(&cinfo, filename, overwrite); 
     500   ops_write_transferable_secret_key(keydata,passphrase,pplen,armoured,cinfo); 
     501   ops_teardown_file_write(cinfo,fd); 
     502   } 
     503   \endcode 
     504*/ 
     505 
     506ops_boolean_t ops_write_transferable_secret_key(const ops_keydata_t *keydata, const unsigned char* passphrase, const size_t pplen, ops_boolean_t armoured, ops_create_info_t *info) 
    451507    { 
    452508    ops_boolean_t rtn; 
     
    457513 
    458514    // public key 
    459     rtn=ops_write_struct_secret_key(&key->key.skey,passphrase,pplen,info); 
     515    rtn=ops_write_struct_secret_key(&keydata->key.skey,passphrase,pplen,info); 
    460516    if (rtn!=ops_true) 
    461517        return rtn; 
     
    464520 
    465521    // user ids and corresponding signatures 
    466     for (i=0; i<key->nuids; i++) 
    467         { 
    468         ops_user_id_t* uid=&key->uids[i]; 
     522    for (i=0; i<keydata->nuids; i++) 
     523        { 
     524        ops_user_id_t* uid=&keydata->uids[i]; 
    469525 
    470526        rtn=ops_write_struct_user_id(uid, info); 
     
    474530 
    475531        // find signature for this packet if it exists 
    476         for (j=0; j<key->nsigs; j++) 
     532        for (j=0; j<keydata->nsigs; j++) 
    477533            { 
    478             sigpacket_t* sig=&key->sigs[i]; 
     534            sigpacket_t* sig=&keydata->sigs[i]; 
    479535            if (!strcmp((char *)sig->userid->user_id, (char *)uid->user_id)) 
    480536                { 
  • openpgpsdk/trunk/src/lib/keyring.c

    r574 r611  
    4646#include <openpgpsdk/final.h> 
    4747 
    48 void ops_keydata_free(ops_keydata_t *key) 
     48/** 
     49   \ingroup HighLevel_KeyringMemory 
     50    
     51   \brief Creates a new ops_keydata_t struct 
     52 
     53   \return A new ops_keydata_t struct, initialised to zero. 
     54 
     55   \note The returned ops_keydata_t struct must be freed after use with ops_keydata_free. 
     56*/ 
     57 
     58ops_keydata_t *ops_keydata_new(void) 
     59    { return ops_mallocz(sizeof(ops_keydata_t)); } 
     60 
     61 
     62/** 
     63 \ingroup HighLevel_KeyringMemory 
     64 
     65 \brief Frees keydata and its memory 
     66 
     67 \param key Key to be freed. 
     68 
     69 \note This frees the keydata itself, as well as any other memory alloc-ed by it.  
     70*/ 
     71void ops_keydata_free(ops_keydata_t *keydata) 
    4972    { 
    5073    unsigned n; 
    5174 
    52     for(n=0 ; n < key->nuids ; ++n) 
    53         ops_user_id_free(&key->uids[n]); 
    54     free(key->uids); 
    55     key->uids=NULL; 
    56     key->nuids=0; 
    57  
    58     for(n=0 ; n < key->npackets ; ++n) 
    59         ops_packet_free(&key->packets[n]); 
    60     free(key->packets); 
    61     key->packets=NULL; 
    62     key->npackets=0; 
    63  
    64     if(key->type == OPS_PTAG_CT_PUBLIC_KEY) 
    65         ops_public_key_free(&key->key.pkey); 
     75    for(n=0 ; n < keydata->nuids ; ++n) 
     76        ops_user_id_free(&keydata->uids[n]); 
     77    free(keydata->uids); 
     78    keydata->uids=NULL; 
     79    keydata->nuids=0; 
     80 
     81    for(n=0 ; n < keydata->npackets ; ++n) 
     82        ops_packet_free(&keydata->packets[n]); 
     83    free(keydata->packets); 
     84    keydata->packets=NULL; 
     85    keydata->npackets=0; 
     86 
     87    if(keydata->type == OPS_PTAG_CT_PUBLIC_KEY) 
     88        ops_public_key_free(&keydata->key.pkey); 
    6689    else 
    67         ops_secret_key_free(&key->key.skey); 
    68  
    69     free(key); 
    70     } 
     90        ops_secret_key_free(&keydata->key.skey); 
     91 
     92    free(keydata); 
     93    } 
     94 
     95/** 
     96 \ingroup HighLevel_Key 
     97 
     98 \brief Returns the public key in the given keydata. 
     99 \param keydata 
     100 
     101  \return Pointer to public key 
     102 
     103  \note This is not a copy, do not free it after use. 
     104*/ 
    71105 
    72106const ops_public_key_t * 
    73 ops_get_public_key_from_data(const ops_keydata_t *data) 
    74     { 
    75     if(data->type == OPS_PTAG_CT_PUBLIC_KEY) 
    76         return &data->key.pkey; 
    77     return &data->key.skey.public_key; 
    78     } 
    79  
    80 ops_boolean_t ops_key_is_secret(const ops_keydata_t *data) 
     107ops_get_public_key_from_data(const ops_keydata_t *keydata) 
     108    { 
     109    if(keydata->type == OPS_PTAG_CT_PUBLIC_KEY) 
     110        return &keydata->key.pkey; 
     111    return &keydata->key.skey.public_key; 
     112    } 
     113 
     114/** 
     115\ingroup HighLevel_Key 
     116 
     117\brief Check whether this is a secret key or not. 
     118*/ 
     119 
     120ops_boolean_t ops_is_key_secret(const ops_keydata_t *data) 
    81121    { return data->type != OPS_PTAG_CT_PUBLIC_KEY; } 
     122 
     123/** 
     124 \ingroup HighLevel_Key 
     125 
     126 \brief Returns the secret key in the given keydata. 
     127 
     128 \note This is not a copy, do not free it after use. 
     129 
     130 \note This returns a const. If you need to be able to write to this pointer, use ops_get_writable_secret_key_from_data 
     131*/ 
    82132 
    83133const ops_secret_key_t * 
     
    89139    return &data->key.skey; 
    90140    } 
     141 
     142/** 
     143 \ingroup HighLevel_Key 
     144 
     145  \brief Returns the secret key in the given keydata. 
     146 
     147  \note This is not a copy, do not free it after use. 
     148 
     149  \note If you do not need to be able to modify this key, there is an equivalent read-only function ops_get_secret_key_from_data. 
     150*/ 
    91151 
    92152ops_secret_key_t * 
     
    214274    } 
    215275 
    216 ops_boolean_t ops_key_is_supported(const ops_keydata_t *key) 
    217     { 
    218     if ( key->type == OPS_PTAG_CT_PUBLIC_KEY ) { 
    219         if ( key->key.pkey.algorithm == OPS_PKA_RSA ) { 
     276/** 
     277   \ingroup HighLevel_Key 
     278 
     279   \brief Checks whether key's algorithm and type are supported by OpenPGP::SDK 
     280 
     281   \param keydata Key to be checked 
     282 
     283   \return ops_true if key algorithm and type are supported by OpenPGP::SDK; ops_false if not 
     284*/ 
     285 
     286ops_boolean_t ops_is_key_supported(const ops_keydata_t *keydata) 
     287    { 
     288    if ( keydata->type == OPS_PTAG_CT_PUBLIC_KEY ) { 
     289        if ( keydata->key.pkey.algorithm == OPS_PKA_RSA ) { 
    220290            return ops_true; 
    221291        } 
    222     } else if ( key->type == OPS_PTAG_CT_PUBLIC_KEY ) { 
    223         if ( key->key.skey.algorithm == OPS_PKA_RSA ) { 
     292    } else if ( keydata->type == OPS_PTAG_CT_PUBLIC_KEY ) { 
     293        if ( keydata->key.skey.algorithm == OPS_PKA_RSA ) { 
    224294            return ops_true; 
    225295        } 
     
    229299 
    230300 
    231 const ops_keydata_t* ops_keyring_get_key(const ops_keyring_t *keyring, int index) 
    232     { 
     301/**  
     302    \ingroup HighLevel_KeyringFind 
     303 
     304    \brief Returns key inside a keyring, chosen by index 
     305 
     306    \param keyring Pointer to existing keyring 
     307    \param index Index of required key 
     308 
     309    \note Index starts at 0 
     310 
     311    \note This returns a pointer to the original key, not a copy. You do not need to free the key after use. 
     312 
     313    \return Pointer to the required key; or NULL if index too large. 
     314 
     315    Example code: 
     316    \code 
     317    void example(const ops_keyring_t* keyring) 
     318    { 
     319    ops_keydata_t* keydata=NULL; 
     320    keydata=ops_keyring_get_key_by_index(keyring, 0); 
     321    ... 
     322    } 
     323    \endcode 
     324*/ 
     325 
     326const ops_keydata_t* ops_keyring_get_key_by_index(const ops_keyring_t *keyring, int index) 
     327    { 
     328    if (index >= keyring->nkeys) 
     329        return NULL; 
    233330    return &keyring->keys[index];  
    234331    } 
     
    373470    } 
    374471 
    375 ops_keydata_t *ops_keydata_new(void) 
    376     { return ops_mallocz(sizeof(ops_keydata_t)); } 
    377  
    378472void ops_keydata_init(ops_keydata_t* keydata, const ops_content_tag_t type) 
    379473    { 
     
    384478    } 
    385479 
    386 /*! \file 
    387   \brief Standard API keyring functions 
    388  
    389 */ 
    390  
    391 /** @defgroup StdKeyring Keyring 
    392     \ingroup StandardAPI 
    393  
    394     @defgroup StdKeyringFile Keyring File Operations 
    395     \ingroup StdKeyring 
    396     \brief Keyring Open/Read/Write/Close 
    397  
     480/**  
    398481    Example Usage: 
    399482    \code 
     
    414497*/ 
    415498 
    416 /** 
    417     @defgroup StdKeyringFind Keyfind Find Operations 
    418     \ingroup StdKeyring 
    419     Find Key or its info within keyring 
    420  
    421     Example Usage: 
    422     \code 
    423  
    424     // definition of variables 
    425     ops_keyring_t keyring; 
    426     unsigned char* keyid; 
    427     ops_key_data_t *key; 
    428  
    429     // Read keyring from file 
    430     ops_keyring_read_from_file(&keyring,"~/.gnupg/pubring.gpg"); 
    431  
    432     // Search for keys 
    433  
    434     // - get Key ID from given userid 
    435     keyid=ops_keyring_find_keyid_by_userid (keyring, "user@domain.com") 
    436  
    437     // - now get key from Key ID 
    438     key=ops_keyring_find_key_by_id(keyring, keyid); 
    439  
    440     // do something with key 
    441     ... 
    442      
    443     // Free memory alloc-ed in ops_keyring_read_from_file() 
    444     ops_keyring_free(); 
    445     \endcode 
    446  */ 
    447  
    448499static ops_parse_cb_return_t 
    449500cb_keyring_read(const ops_parser_content_t *content_, 
     
    451502 
    452503/** 
    453    \ingroup StdKeyringFile 
    454     
    455    Reads a keyring from a file 
    456     
    457    \param keyring Ptr to existing keyring 
    458    \param file Filename of keyring 
    459     
     504   \ingroup HighLevel_KeyringRead 
     505    
     506   \brief Reads a keyring from a file 
     507    
     508   \param keyring Pointer to an existing ops_keyring_t struct 
     509   \param armour ops_true if file is armoured; else ops_false 
     510   \param filename Filename of keyring to be read 
     511 
     512   \return ops true if OK; ops_false on error 
     513 
    460514   \note Keyring struct must already exist. 
    461515 
     
    466520   \note If you call this twice on the same keyring struct, without calling 
    467521   ops_keyring_free() between these calls, you will introduce a memory leak. 
    468 */ 
     522 
     523   Example code: 
     524   \code 
     525   ops_keyring_t* keyring=ops_mallocz(sizeof *keyring); 
     526   ops_boolean_t armoured=ops_false; 
     527   ops_keyring_read_from_file(keyring, armoured, "~/.gnupg/pubring.gpg"); 
     528   ... 
     529   ops_keyring_free(keyring); 
     530   free (keyring); 
     531    
     532   \endcode 
     533*/ 
     534 
    469535ops_boolean_t ops_keyring_read_from_file(ops_keyring_t *keyring, const ops_boolean_t armour, const char *filename) 
    470536    { 
     
    472538    int fd; 
    473539    ops_boolean_t res = ops_true; 
    474  
    475     //memset(keyring,'\0',sizeof *keyring); 
    476540 
    477541    pinfo=ops_parse_info_new(); 
     
    511575    ops_print_errors(ops_parse_info_get_errors(pinfo)); 
    512576 
     577    if (armour) 
     578        ops_reader_pop_dearmour(pinfo); 
     579 
    513580    close(fd); 
    514581 
     
    519586 
    520587/** 
    521    \ingroup StdKeyring 
    522     
    523    Reads a keyring from memory 
    524     
    525    \param keyring Ptr to existing keyring 
    526    \param mem ptr to memory struct containing keyring info 
    527     
     588   \ingroup HighLevel_KeyringRead 
     589    
     590   \brief Reads a keyring from memory 
     591    
     592   \param keyring Pointer to existing ops_keyring_t struct 
     593   \param armour ops_true if file is armoured; else ops_false 
     594   \param mem Pointer to a ops_memory_t struct containing keyring to be read 
     595    
     596   \return ops true if OK; ops_false on error 
     597 
    528598   \note Keyring struct must already exist. 
    529599 
     
    534604   \note If you call this twice on the same keyring struct, without calling 
    535605   ops_keyring_free() between these calls, you will introduce a memory leak. 
    536 */ 
    537 ops_boolean_t ops_keyring_read_from_mem(ops_keyring_t *keyring, ops_memory_t* mem) 
    538     { 
    539     // \todo currently assuming this is an armoured key. 
    540  
     606   Example code: 
     607   \code 
     608   ops_memory_t* mem; // Filled with keyring packets 
     609   ops_keyring_t* keyring=ops_mallocz(sizeof *keyring); 
     610   ops_boolean_t armoured=ops_false; 
     611   ops_keyring_read_from_mem(keyring, armoured, mem); 
     612   ... 
     613   ops_keyring_free(keyring); 
     614   free (keyring); 
     615   \endcode 
     616*/ 
     617ops_boolean_t ops_keyring_read_from_mem(ops_keyring_t *keyring, const ops_boolean_t armour, ops_memory_t* mem) 
     618    { 
    541619    ops_parse_info_t *pinfo=NULL; 
    542620    ops_boolean_t res = ops_true; 
    543621 
    544     // \todo need to free memory first? 
    545     //memset(keyring,'\0',sizeof *keyring); 
    546  
    547622    pinfo=ops_parse_info_new(); 
    548623    ops_parse_options(pinfo,OPS_PTAG_SS_ALL,OPS_PARSE_PARSED); 
     
    550625    ops_setup_memory_read(&pinfo, mem, NULL, cb_keyring_read); 
    551626 
    552     ops_reader_push_dearmour(pinfo,ops_false,ops_false,ops_true); 
     627    //    ops_reader_push_dearmour(pinfo,ops_false,ops_false,ops_true); 
     628 
     629    if (armour) 
     630        { ops_reader_push_dearmour(pinfo, ops_false, ops_false, ops_false); } 
    553631 
    554632    if ( ops_parse_and_accumulate(keyring,pinfo) == 0 )  
     
    562640    ops_print_errors(ops_parse_info_get_errors(pinfo)); 
    563641 
    564     ops_reader_pop_dearmour(pinfo); 
     642    if (armour) 
     643        ops_reader_pop_dearmour(pinfo); 
    565644 
    566645    // don't call teardown_memory_read because memory was passed in 
     
    571650 
    572651/** 
    573    \ingroup StdKeyringFile 
     652   \ingroup HighLevel_KeyringMemory 
    574653  
    575    Frees alloc-ed memory 
     654   \brief Frees keyring's contents (but not keyring itself) 
    576655  
    577656   \param keyring Keyring whose data is to be freed 
     
    588667 
    589668/** 
    590    \ingroup StdKeyringFind 
    591  
    592    Finds key in keyring from its Key ID 
     669   \ingroup HighLevel_KeyringFind 
     670 
     671   \brief Finds key in keyring from its Key ID 
    593672 
    594673   \param keyring Keyring to be searched 
    595674   \param keyid ID of required key 
    596675 
    597    \return Ptr to key, if found; NULL, if not found 
     676   \return Pointer to key, if found; NULL, if not found 
     677 
     678   \note This returns a pointer to the key inside the given keyring, not a copy. Do not free it after use. 
     679    
     680   Example code: 
     681   \code 
     682   void example(ops_keyring_t* keyring) 
     683   { 
     684   ops_keydata_t* keydata=NULL; 
     685   unsigned char keyid[OPS_KEY_ID_SIZE]; // value set elsewhere 
     686   keydata=ops_keyring_find_key_by_id(keyring,keyid); 
     687   ... 
     688   } 
     689   \endcode 
    598690*/ 
    599691const ops_keydata_t * 
     
    616708 
    617709/** 
    618    \ingroup StdKeyringFind 
    619  
    620    Finds key from its User ID 
     710   \ingroup HighLevel_KeyringFind 
     711 
     712   \brief Finds key from its User ID 
    621713 
    622714   \param keyring Keyring to be searched 
    623715   \param userid User ID of required key 
    624716 
    625    \return Ptr to Key, if found; NULL, if not found 
     717   \return Pointer to Key, if found; NULL, if not found 
     718 
     719   \note This returns a pointer to the key inside the keyring, not a copy. Do not free it. 
     720 
     721   Example code: 
     722   \code 
     723   void example(ops_keyring_t* keyring) 
     724   { 
     725   ops_keydata_t* keydata=NULL; 
     726   keydata=ops_keyring_find_key_by_userid(keyring,"user@domain.com"); 
     727   ... 
     728   } 
     729   \endcode 
    626730*/ 
    627731const ops_keydata_t * 
     
    650754 
    651755/** 
    652    \ingroup StdKeyringList 
    653  
    654    List keys in keyring 
     756   \ingroup HighLevel_KeyringList 
     757 
     758   \brief Prints all keys in keyring to stdout. 
    655759 
    656760   \param keyring Keyring to use 
    657    \param match optional string to match 
    658  
     761 
     762   \return none 
     763 
     764   Example code: 
     765   \code 
     766   void example() 
     767   { 
     768   ops_keyring_t* keyring=ops_mallocz(sizeof *keyring); 
     769   ops_boolean_t armoured=ops_false; 
     770   ops_keyring_read_from_file(keyring, armoured, "~/.gnupg/pubring.gpg"); 
     771    
     772   ops_keyring_list(keyring); 
     773    
     774   ops_keyring_free(keyring); 
     775   free (keyring); 
     776   } 
     777   \endcode 
    659778*/ 
    660779 
    661780void 
    662 ops_keyring_list(const ops_keyring_t* keyring, 
    663                  const char* match) 
     781ops_keyring_list(const ops_keyring_t* keyring) 
    664782    { 
    665783    int n; 
     
    672790        for(i=0; i<key->nuids; i++) 
    673791            { 
    674             if (match) 
    675                 printf ("*** match %s\n", match); 
    676             // if match, compare 
    677             //      if(!strcmp((char *)keyring->keys[n].uids[i].user_id,userid)) 
    678             //         return &keyring->keys[n].keyid[0]; 
    679             if (ops_key_is_secret(key)) 
     792            if (ops_is_key_secret(key)) 
    680793                ops_print_secret_keydata(key); 
    681794            else 
  • openpgpsdk/trunk/src/lib/memory.c

    r574 r611  
    131131    } 
    132132 
     133/** 
     134   \ingroup HighLevel_Misc 
     135   \brief Create a new zeroed ops_memory_t 
     136   \return Pointer to new ops_memory_t 
     137   \note Free using ops_memory_free() after use. 
     138*/ 
     139 
    133140ops_memory_t *ops_memory_new() 
    134141    { return ops_mallocz(sizeof(ops_memory_t)); } 
     142 
     143/** 
     144   \ingroup HighLevel_Misc 
     145   \brief Free memory 
     146   \param mem Memory to be freed 
     147*/ 
    135148 
    136149void ops_memory_free(ops_memory_t *mem) 
     
    140153    } 
    141154 
     155/** 
     156   \ingroup HighLevel_Misc 
     157   \brief Get length of data stored in ops_memory_t struct 
     158   \return Number of bytes in data 
     159*/ 
    142160size_t ops_memory_get_length(const ops_memory_t *mem) 
    143161    { return mem->length; } 
    144162 
     163/** 
     164   \ingroup HighLevel_Misc 
     165   \brief Get data stored in ops_memory_t struct 
     166   \return Pointer to data 
     167*/ 
    145168void *ops_memory_get_data(ops_memory_t *mem) 
    146169    { return mem->buf; } 
  • openpgpsdk/trunk/src/lib/readerwriter.c

    r590 r611  
    252252    } 
    253253 
     254/** 
     255 \ingroup Core_Callbacks 
     256 
     257\brief Callback to get secret key, decrypting if necessary. 
     258 
     259@verbatim 
     260 This callback does the following: 
     261 * finds the session key in the keyring 
     262 * gets a passphrase if required 
     263 * decrypts the secret key, if necessary 
     264 * sets the secret_key in the content struct 
     265@endverbatim 
     266*/ 
     267 
    254268ops_parse_cb_return_t 
    255269callback_cmd_get_secret_key(const ops_parser_content_t *content_,ops_parse_cb_info_t *cbinfo) 
     
    267281    case OPS_PARSER_CMD_GET_SECRET_KEY: 
    268282        cbinfo->cryptinfo.keydata=ops_keyring_find_key_by_id(cbinfo->cryptinfo.keyring,content->get_secret_key.pk_session_key->key_id); 
    269         if (!cbinfo->cryptinfo.keydata || !ops_key_is_secret(cbinfo->cryptinfo.keydata)) 
     283        if (!cbinfo->cryptinfo.keydata || !ops_is_key_secret(cbinfo->cryptinfo.keydata)) 
    270284            return 0; 
    271285 
  • openpgpsdk/trunk/src/lib/util.c

    r574 r611  
    8282 
    8383/** 
    84  * \ingroup Utils 
    85  * 
    86  * Initialise OpenPGP:SDK. This <b>must</b> be called before any other 
    87  * OpenPGP:SDK function is used. 
     84 * \ingroup HighLevel_Misc 
     85 * \brief Initialises OpenPGP::SDK. To be called before any other OPS function. 
    8886 */ 
    8987 
     
    9492 
    9593/** 
    96  * \ingroup Utils 
     94 * \ingroup HighLevel_Misc 
     95 * \brief Closes down OpenPGP::SDK. 
    9796 * 
    9897 * Close down OpenPGP:SDK, release any resources under the control of 
     
    152151    } 
    153152 
     153/** 
     154   \ingroup HighLevel_Misc 
     155   \brief mallocs and zeros memory 
     156   \param n Number of bytes to be alloc-ed. 
     157   \return Pointer to new memory. 
     158   \note Should be freed after use with free(). 
     159*/ 
    154160void *ops_mallocz(size_t n) 
    155161    {