/**
\ingroup HighLevel_KeyringRead
\brief Reads a keyring from memory
\param keyring Pointer to existing ops_keyring_t struct
\param armour ops_true if file is armoured; else ops_false
\param mem Pointer to a ops_memory_t struct containing keyring to be read
\return ops true if OK; ops_false on error
\note Keyring struct must already exist.
\note Can be used with either a public or secret keyring.
\note You must call ops_keyring_free() after usage to free alloc-ed memory.
\note If you call this twice on the same keyring struct, without calling
ops_keyring_free() between these calls, you will introduce a memory leak.
\sa ops_keyring_read_from_file
\sa ops_keyring_free
Example code:
\code
ops_memory_t* mem; // Filled with keyring packets
ops_keyring_t* keyring=ops_mallocz(sizeof *keyring);
ops_boolean_t armoured=ops_false;
ops_keyring_read_from_mem(keyring, armoured, mem);
...
ops_keyring_free(keyring);
free (keyring);
\endcode
*/
ops_boolean_t ops_keyring_read_from_mem(ops_keyring_t *keyring, const ops_boolean_t armour, ops_memory_t* mem)
{
ops_parse_info_t *pinfo=NULL;
ops_boolean_t res = ops_true;
ops_setup_memory_read(&pinfo, mem, NULL, cb_keyring_read,
OPS_ACCUMULATE_NO);
ops_parse_options(pinfo,OPS_PTAG_SS_ALL,OPS_PARSE_PARSED);
if (armour)
{ ops_reader_push_dearmour(pinfo); }
if ( ops_parse_and_accumulate(keyring,pinfo) == 0 )
{
res = ops_false;
}
else
{
res = ops_true;
}
ops_print_errors(ops_parse_info_get_errors(pinfo));
if (armour)
ops_reader_pop_dearmour(pinfo);
// don't call teardown_memory_read because memory was passed
// in. But we need to free the parse_info object allocated by
// ops_setup_memory_read().
ops_parse_info_delete(pinfo);
return res;
}
void check_sig_with_ops_core(ops_parse_info_t *pinfo,
ops_boolean_t use_armour,
validate_data_cb_arg_t *validate_arg)
{
ops_validate_result_t* result=ops_mallocz(sizeof (ops_validate_result_t));
int rtn=0;
memset(validate_arg, '\0', sizeof *validate_arg);
validate_arg->result=result;
validate_arg->keyring=&pub_keyring;
validate_arg->rarg=ops_reader_get_arg_from_pinfo(pinfo);
ops_parse_options(pinfo, OPS_PTAG_SS_ALL, OPS_PARSE_PARSED);
pinfo->rinfo.accumulate=ops_true;
// Set up armour/passphrase options
if (use_armour)
ops_reader_push_dearmour(pinfo);
// Do the verification
rtn=ops_parse_and_print_errors(pinfo);
CU_ASSERT(rtn == 1);
// Tidy up
if (use_armour)
ops_reader_pop_dearmour(pinfo);
ops_parse_info_delete(pinfo);
ops_validate_result_free(result);
}
ops_boolean_t ops_keyring_read_from_file(ops_keyring_t *keyring, const ops_boolean_t armour, const char *filename)
{
ops_parse_info_t *pinfo;
int fd;
ops_boolean_t res = ops_true;
pinfo=ops_parse_info_new();
// add this for the moment,
// \todo need to fix the problems with reading signature subpackets later
// ops_parse_options(pinfo,OPS_PTAG_SS_ALL,OPS_PARSE_RAW);
ops_parse_options(pinfo,OPS_PTAG_SS_ALL,OPS_PARSE_PARSED);
fd=open(filename,O_RDONLY | O_BINARY);
if(fd < 0)
{
ops_parse_info_delete(pinfo);
perror(filename);
return ops_false;
}
ops_reader_set_fd(pinfo,fd);
ops_parse_cb_set(pinfo,cb_keyring_read,NULL);
if (armour)
{ ops_reader_push_dearmour(pinfo); }
if ( ops_parse_and_accumulate(keyring,pinfo) == 0 ) {
res = ops_false;
}
else
{
res = ops_true;
}
ops_print_errors(ops_parse_info_get_errors(pinfo));
if (armour)
ops_reader_pop_dearmour(pinfo);
close(fd);
ops_parse_info_delete(pinfo);
return res;
}
