static int x509_parse_issuer_cert(ErlNifEnv* env, ERL_NIF_TERM issuer_cert_tuple, char **issuer_cert_pem)
{
char *issuer_cert_atom_string = NULL;
char *issuer_cert_pem_string = NULL;
int num_issuer_terms;
const ERL_NIF_TERM *issuer_terms;
*issuer_cert_pem = NULL;
if(NULL == issuer_cert_pem || !enif_get_tuple(env, issuer_cert_tuple, &num_issuer_terms, &issuer_terms)) return 0;
if(!atom_to_string(env, issuer_terms[0], &issuer_cert_atom_string) || strncmp(issuer_cert_atom_string, ISSUER_CERT_STR, issuer_cert_strlen)) {
if(NULL != issuer_cert_atom_string) free(issuer_cert_atom_string);
return 0;
}
free(issuer_cert_atom_string);
if(!binary_to_string(env, issuer_terms[1], &issuer_cert_pem_string)) return 0;
*issuer_cert_pem = issuer_cert_pem_string;
return 1;
}
gchar*
kvp_value_to_string(const KvpValue *val)
{
gchar *tmp1;
gchar *tmp2;
const gchar *ctmp;
g_return_val_if_fail(val, NULL);
switch (kvp_value_get_type(val))
{
case KVP_TYPE_GINT64:
return g_strdup_printf("KVP_VALUE_GINT64(%" G_GINT64_FORMAT ")",
kvp_value_get_gint64(val));
break;
case KVP_TYPE_DOUBLE:
return g_strdup_printf("KVP_VALUE_DOUBLE(%g)",
kvp_value_get_double(val));
break;
case KVP_TYPE_NUMERIC:
tmp1 = gnc_numeric_to_string(kvp_value_get_numeric(val));
tmp2 = g_strdup_printf("KVP_VALUE_NUMERIC(%s)", tmp1 ? tmp1 : "");
g_free(tmp1);
return tmp2;
break;
case KVP_TYPE_STRING:
tmp1 = kvp_value_get_string (val);
return g_strdup_printf("KVP_VALUE_STRING(%s)", tmp1 ? tmp1 : "");
break;
case KVP_TYPE_GUID:
gchar guidstr[GUID_ENCODING_LENGTH+1];
guid_to_string_buff(kvp_value_get_guid(val),guidstr);
tmp2 = g_strdup_printf("KVP_VALUE_GUID(%s)", guidstr);
return tmp2;
break;
case KVP_TYPE_TIMESPEC:
tmp1 = g_new0 (char, 40);
gnc_timespec_to_iso8601_buff (kvp_value_get_timespec (val), tmp1);
tmp2 = g_strdup_printf("KVP_VALUE_TIMESPEC(%s)", tmp1);
g_free(tmp1);
return tmp2;
break;
case KVP_TYPE_BINARY:
{
guint64 len;
void *data;
data = kvp_value_get_binary(val, &len);
tmp1 = binary_to_string(data, len);
return g_strdup_printf("KVP_VALUE_BINARY(%s)", tmp1 ? tmp1 : "");
}
break;
case KVP_TYPE_GLIST:
tmp1 = kvp_value_glist_to_string(kvp_value_get_glist(val));
tmp2 = g_strdup_printf("KVP_VALUE_GLIST(%s)", tmp1 ? tmp1 : "");
g_free(tmp1);
return tmp2;
break;
case KVP_TYPE_FRAME:
tmp1 = kvp_frame_to_string(kvp_value_get_frame(val));
tmp2 = g_strdup_printf("KVP_VALUE_FRAME(%s)", tmp1 ? tmp1 : "");
g_free(tmp1);
return tmp2;
break;
case KVP_TYPE_GDATE:
return g_strdup_printf("KVP_VALUE_GDATE(%04d-%02d-%02d)",
g_date_get_year(&val->value.gdate),
g_date_get_month(&val->value.gdate),
g_date_get_day(&val->value.gdate));
default:
break;
}
g_assert(FALSE); /* must not be reached */
return g_strdup("");
}
static int x509_parse_keypair(ErlNifEnv* env, const char* keypair_name, ERL_NIF_TERM key_tuple, char *keys[2]){
/* key_tuple := {keypair_name, {keypair , [{public_key, <<...>>}, {private_key, <<..>>}]}} */
unsigned atom_len = -1;
int num_named_key_terms = -1;
int num_keypair_terms = -1;
int num_public_key_terms = -1;
int num_private_key_terms = -1;
const ERL_NIF_TERM *named_key_terms = NULL;
const ERL_NIF_TERM *keypair_terms = NULL;
const ERL_NIF_TERM *public_key_terms = NULL;
const ERL_NIF_TERM *private_key_terms = NULL;
char *keyname = NULL;
char *keypair = NULL;
char *private_key_str, *public_key_str;
ERL_NIF_TERM head,tail;
if ( NULL == keys ||
NULL == keypair_name){
return 0;
}
/* get the name of the key, which is given as an atom */
if(!enif_get_tuple(env, key_tuple, &num_named_key_terms, &named_key_terms) ||
!atom_to_string(env, named_key_terms[0], &keyname)){
if(NULL != keyname) free(keyname);
return 0;
}
if(strncmp(keyname, keypair_name, atom_len)){
free(keyname);
return 0;
}
/* get the tagged tuple representing the keypair */
if(!enif_get_tuple(env, named_key_terms[1], &num_keypair_terms, &keypair_terms)) return 0;
/* get the atom 'keypair' and validate */
if(num_keypair_terms < 2) return 0;
if(!atom_to_string(env, keypair_terms[0], &keypair) || strncmp(keypair, KEYPAIR_STR, atom_len)){
if(keypair) free(keypair);
return 0;
}
/* keypair itself is a list of tuples, one member is the public key, the other is the private key */
enif_get_list_cell(env, keypair_terms[1], &head, &tail);
enif_get_tuple(env, head, &num_public_key_terms, &public_key_terms);
/* get the public key binary */
if(!atom_to_string(env, public_key_terms[0], &keyname) ||
strncmp(keyname, PUBLIC_KEY_STR, atom_len)){
if(NULL != keyname) free(keyname);
return 0;
}
free(keyname);
keyname = NULL;
if(!binary_to_string(env, public_key_terms[1], &public_key_str)) return 0;
enif_get_list_cell(env, tail, &head, &tail);
enif_get_tuple(env, head, &num_private_key_terms, &private_key_terms);
/* get the private key binary */
if(!atom_to_string(env, private_key_terms[0], &keyname) ||
strncmp(keyname, PRIVATE_KEY_STR, atom_len)){
if(NULL != keyname) free(keyname);
return 0;
}
free(keyname);
if(!binary_to_string(env, private_key_terms[1], &private_key_str)) return 0;
keys[0] = public_key_str;
keys[1] = private_key_str;
return 1;
}
static void
add_kvp_value_node(xmlNodePtr node, gchar *tag, kvp_value* val)
{
xmlNodePtr val_node;
gchar *tmp_str1;
kvp_value_t kvp_type;
kvp_type = kvp_value_get_type(val);
if (kvp_type == KVP_TYPE_STRING)
val_node = xmlNewTextChild(node, NULL, BAD_CAST tag, BAD_CAST kvp_value_get_string(val));
else if (kvp_type == KVP_TYPE_TIMESPEC)
val_node = NULL;
else if (kvp_type == KVP_TYPE_GDATE)
{
GDate d = kvp_value_get_gdate(val);
val_node = gdate_to_dom_tree(tag, &d);
xmlAddChild (node, val_node);
}
else
val_node = xmlNewTextChild(node, NULL, BAD_CAST tag, NULL);
switch (kvp_value_get_type(val))
{
case KVP_TYPE_GINT64:
add_text_to_node(val_node, "integer",
g_strdup_printf("%" G_GINT64_FORMAT,
kvp_value_get_gint64(val)));
break;
case KVP_TYPE_DOUBLE:
add_text_to_node(val_node, "double",
double_to_string(kvp_value_get_double(val)));
break;
case KVP_TYPE_NUMERIC:
add_text_to_node(val_node, "numeric",
gnc_numeric_to_string(kvp_value_get_numeric(val)));
break;
case KVP_TYPE_STRING:
xmlSetProp(val_node, BAD_CAST "type", BAD_CAST "string");
break;
case KVP_TYPE_GUID:
/* THREAD-UNSAFE */
add_text_to_node(val_node, "guid",
g_strdup(guid_to_string(kvp_value_get_guid(val))));
break;
case KVP_TYPE_TIMESPEC:
{
Timespec ts = kvp_value_get_timespec (val);
val_node = timespec_to_dom_tree (tag, &ts);
xmlSetProp (val_node, BAD_CAST "type", BAD_CAST "timespec");
xmlAddChild (node, val_node);
}
break;
case KVP_TYPE_GDATE:
xmlSetProp(val_node, BAD_CAST "type", BAD_CAST "gdate");
break;
case KVP_TYPE_BINARY:
{
guint64 size;
void *binary_data = kvp_value_get_binary(val, &size);
xmlSetProp(val_node, BAD_CAST "type", BAD_CAST "binary");
g_return_if_fail(binary_data);
tmp_str1 = binary_to_string(binary_data, size);
xmlNodeSetContent(val_node, BAD_CAST tmp_str1);
g_free(tmp_str1);
}
break;
case KVP_TYPE_GLIST:
{
GList *cursor;
xmlSetProp(val_node, BAD_CAST "type", BAD_CAST "list");
for (cursor = kvp_value_get_glist(val); cursor; cursor = cursor->next)
{
kvp_value *val = (kvp_value*)cursor->data;
add_kvp_value_node(val_node, "slot:value", val);
}
}
break;
case KVP_TYPE_FRAME:
{
kvp_frame *frame;
xmlSetProp(val_node, BAD_CAST "type", BAD_CAST "frame");
frame = kvp_value_get_frame (val);
if (!frame || !kvp_frame_get_hash (frame))
break;
g_hash_table_foreach_sorted(kvp_frame_get_hash(frame),
add_kvp_slot, val_node, (GCompareFunc)strcmp);
}
break;
}
}
