/**
* HTTP methods allows for this plugin
*/
-static char* allow_methods;
+static char *allow_methods;
/**
* @brief struct returned by the initialization function of the plugin
/**
* The data from the REST request
*/
- const char* data;
+ const char *data;
/**
* The name to look up
* Response code
*/
int response_code;
-
};
/**
struct EgoEntry *ego_entry;
struct EgoEntry *ego_tmp;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
if (NULL != handle->timeout_task)
{
GNUNET_SCHEDULER_cancel (handle->timeout_task);
}
if (NULL != handle->url)
- GNUNET_free(handle->url);
+ GNUNET_free (handle->url);
if (NULL != handle->emsg)
- GNUNET_free(handle->emsg);
+ GNUNET_free (handle->emsg);
if (NULL != handle->name)
GNUNET_free (handle->name);
if (NULL != handle->identity_handle)
GNUNET_IDENTITY_disconnect (handle->identity_handle);
- for (ego_entry = handle->ego_head;
- NULL != ego_entry;)
+ for (ego_entry = handle->ego_head; NULL != ego_entry;)
{
ego_tmp = ego_entry;
ego_entry = ego_entry->next;
- GNUNET_free(ego_tmp->identifier);
- GNUNET_free(ego_tmp->keystring);
- GNUNET_free(ego_tmp);
+ GNUNET_free (ego_tmp->identifier);
+ GNUNET_free (ego_tmp->keystring);
+ GNUNET_free (ego_tmp);
}
- GNUNET_free(handle);
+ GNUNET_free (handle);
}
/**
{
struct RequestHandle *handle = cls;
struct MHD_Response *resp;
- json_t *json_error = json_object();
+ json_t *json_error = json_object ();
char *response;
if (NULL == handle->emsg)
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_ERROR_UNKNOWN);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_ERROR_UNKNOWN);
- json_object_set_new(json_error,"error", json_string(handle->emsg));
+ json_object_set_new (json_error, "error", json_string (handle->emsg));
if (0 == handle->response_code)
handle->response_code = MHD_HTTP_OK;
response = json_dumps (json_error, 0);
resp = GNUNET_REST_create_response (response);
handle->proc (handle->proc_cls, resp, handle->response_code);
- json_decref(json_error);
- GNUNET_free(response);
+ json_decref (json_error);
+ GNUNET_free (response);
GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
}
-
/**
* Get EgoEntry from list with either a public key or a name
* If public key and name are not NULL, it returns the public key result first
* @param name the name of an identity (only one can be NULL)
* @return EgoEntry or NULL if not found
*/
-struct EgoEntry*
-get_egoentry(struct RequestHandle *handle, char* pubkey, char *name)
+struct EgoEntry *
+get_egoentry (struct RequestHandle *handle, char *pubkey, char *name)
{
struct EgoEntry *ego_entry;
if (NULL != pubkey)
{
- for (ego_entry = handle->ego_head;
- NULL != ego_entry;
- ego_entry = ego_entry->next)
+ for (ego_entry = handle->ego_head; NULL != ego_entry;
+ ego_entry = ego_entry->next)
{
if (0 != strcasecmp (pubkey, ego_entry->keystring))
- continue;
+ continue;
return ego_entry;
}
}
if (NULL != name)
{
- for (ego_entry = handle->ego_head;
- NULL != ego_entry;
- ego_entry = ego_entry->next)
+ for (ego_entry = handle->ego_head; NULL != ego_entry;
+ ego_entry = ego_entry->next)
{
if (0 != strcasecmp (name, ego_entry->identifier))
- continue;
+ continue;
return ego_entry;
}
}
*/
static void
ego_get_for_subsystem (void *cls,
- struct GNUNET_IDENTITY_Ego *ego,
- void **ctx,
- const char *name)
+ struct GNUNET_IDENTITY_Ego *ego,
+ void **ctx,
+ const char *name)
{
struct RequestHandle *handle = cls;
struct MHD_Response *resp;
char *result_str;
char *public_key_string;
- if(NULL == ego)
+ if (NULL == ego)
{
handle->response_code = MHD_HTTP_NOT_FOUND;
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
- GNUNET_IDENTITY_ego_get_public_key(ego,&public_key);
- public_key_string = GNUNET_CRYPTO_ecdsa_public_key_to_string(&public_key);
+ GNUNET_IDENTITY_ego_get_public_key (ego, &public_key);
+ public_key_string = GNUNET_CRYPTO_ecdsa_public_key_to_string (&public_key);
// create json with subsystem identity
json_root = json_object ();
json_object_set_new (json_root,
- GNUNET_REST_IDENTITY_PARAM_PUBKEY,
- json_string(public_key_string));
+ GNUNET_REST_IDENTITY_PARAM_PUBKEY,
+ json_string (public_key_string));
json_object_set_new (json_root,
- GNUNET_REST_IDENTITY_PARAM_NAME,
- json_string(name));
+ GNUNET_REST_IDENTITY_PARAM_NAME,
+ json_string (name));
result_str = json_dumps (json_root, 0);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
resp = GNUNET_REST_create_response (result_str);
json_decref (json_root);
handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
- GNUNET_free(result_str);
- GNUNET_free(public_key_string);
+ GNUNET_free (result_str);
+ GNUNET_free (public_key_string);
GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
}
*/
void
ego_get_subsystem (struct GNUNET_REST_RequestHandle *con_handle,
- const char* url,
- void *cls)
+ const char *url,
+ void *cls)
{
struct RequestHandle *handle = cls;
char *subsystem;
if (strlen (GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) >= strlen (handle->url))
{
- handle->emsg = GNUNET_strdup("Missing subsystem name");
+ handle->emsg = GNUNET_strdup ("Missing subsystem name");
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
- subsystem = &handle->url[strlen (
- GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) + 1];
+ subsystem = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) + 1];
//requested default identity of subsystem
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Looking for %s's ego\n", subsystem);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Looking for %s's ego\n", subsystem);
handle->op = GNUNET_IDENTITY_get (handle->identity_handle,
- subsystem,
- &ego_get_for_subsystem,
- handle);
+ subsystem,
+ &ego_get_for_subsystem,
+ handle);
if (NULL == handle->op)
{
handle->response_code = MHD_HTTP_NOT_FOUND;
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
*/
void
ego_get_all (struct GNUNET_REST_RequestHandle *con_handle,
- const char* url,
- void *cls)
+ const char *url,
+ void *cls)
{
struct RequestHandle *handle = cls;
struct EgoEntry *ego_entry;
json_root = json_array ();
//Return ego/egos
- for (ego_entry = handle->ego_head;
- NULL != ego_entry; ego_entry = ego_entry->next)
+ for (ego_entry = handle->ego_head; NULL != ego_entry;
+ ego_entry = ego_entry->next)
{
json_ego = json_object ();
json_object_set_new (json_ego,
- GNUNET_REST_IDENTITY_PARAM_PUBKEY,
- json_string (ego_entry->keystring));
+ GNUNET_REST_IDENTITY_PARAM_PUBKEY,
+ json_string (ego_entry->keystring));
json_object_set_new (json_ego,
- GNUNET_REST_IDENTITY_PARAM_NAME,
- json_string (ego_entry->identifier));
+ GNUNET_REST_IDENTITY_PARAM_NAME,
+ json_string (ego_entry->identifier));
json_array_append (json_root, json_ego);
json_decref (json_ego);
}
result_str = json_dumps (json_root, 0);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
resp = GNUNET_REST_create_response (result_str);
json_decref (json_root);
handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
- GNUNET_free(result_str);
+ GNUNET_free (result_str);
GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
}
json_ego = json_object ();
json_object_set_new (json_ego,
- GNUNET_REST_IDENTITY_PARAM_PUBKEY,
- json_string (ego_entry->keystring));
+ GNUNET_REST_IDENTITY_PARAM_PUBKEY,
+ json_string (ego_entry->keystring));
json_object_set_new (json_ego,
- GNUNET_REST_IDENTITY_PARAM_NAME,
- json_string (ego_entry->identifier));
+ GNUNET_REST_IDENTITY_PARAM_NAME,
+ json_string (ego_entry->identifier));
result_str = json_dumps (json_ego, 0);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
resp = GNUNET_REST_create_response (result_str);
handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
json_decref (json_ego);
- GNUNET_free(result_str);
+ GNUNET_free (result_str);
GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
}
*/
void
ego_get_pubkey (struct GNUNET_REST_RequestHandle *con_handle,
- const char* url,
- void *cls)
+ const char *url,
+ void *cls)
{
struct RequestHandle *handle = cls;
struct EgoEntry *ego_entry;
if (strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen (handle->url))
{
handle->response_code = MHD_HTTP_NOT_FOUND;
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_MISSING_PUBKEY);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_PUBKEY);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
- keystring = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY)+1];
- ego_entry = get_egoentry(handle, keystring, NULL);
+ keystring = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) + 1];
+ ego_entry = get_egoentry (handle, keystring, NULL);
if (NULL == ego_entry)
{
handle->response_code = MHD_HTTP_NOT_FOUND;
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
- ego_get_response(handle, ego_entry);
+ ego_get_response (handle, ego_entry);
}
/**
*/
void
ego_get_name (struct GNUNET_REST_RequestHandle *con_handle,
- const char* url,
- void *cls)
+ const char *url,
+ void *cls)
{
struct RequestHandle *handle = cls;
struct EgoEntry *ego_entry;
if (strlen (GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen (handle->url))
{
handle->response_code = MHD_HTTP_NOT_FOUND;
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_MISSING_NAME);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_NAME);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
- egoname = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME)+1];
- ego_entry = get_egoentry(handle, NULL, egoname);
+ egoname = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME) + 1];
+ ego_entry = get_egoentry (handle, NULL, egoname);
if (NULL == ego_entry)
{
handle->response_code = MHD_HTTP_NOT_FOUND;
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
- ego_get_response(handle, ego_entry);
+ ego_get_response (handle, ego_entry);
}
handle->op = NULL;
if (NULL != emsg)
{
- handle->emsg = GNUNET_strdup(emsg);
+ handle->emsg = GNUNET_strdup (emsg);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
*/
static void
do_finished_create (void *cls,
- const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk,
- const char *emsg)
+ const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk,
+ const char *emsg)
{
struct RequestHandle *handle = cls;
(void) pk;
- do_finished (handle,
- emsg);
+ do_finished (handle, emsg);
}
//if no data
if (0 >= handle->data_size)
{
- handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_NO_DATA);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
//if not json
term_data[handle->data_size] = '\0';
- GNUNET_memcpy(term_data, handle->data, handle->data_size);
- data_js = json_loads (term_data,JSON_DECODE_ANY,&err);
+ GNUNET_memcpy (term_data, handle->data, handle->data_size);
+ data_js = json_loads (term_data, JSON_DECODE_ANY, &err);
if (NULL == data_js)
{
- handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_NO_DATA);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
newname = NULL;
//NEW NAME
json_state = 0;
- json_state = json_unpack(data_js,
- "{s:s!}",
- GNUNET_REST_IDENTITY_PARAM_NEWNAME,
- &newname);
+ json_state = json_unpack (data_js,
+ "{s:s!}",
+ GNUNET_REST_IDENTITY_PARAM_NEWNAME,
+ &newname);
//Change name with pubkey or name identifier
if (0 != json_state)
{
- handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
GNUNET_SCHEDULER_add_now (&do_error, handle);
json_decref (data_js);
return;
if (NULL == newname)
{
- handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
GNUNET_SCHEDULER_add_now (&do_error, handle);
json_decref (data_js);
return;
if (0 >= strlen (newname))
{
- handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
GNUNET_SCHEDULER_add_now (&do_error, handle);
json_decref (data_js);
return;
return;
}
handle->op = GNUNET_IDENTITY_rename (handle->identity_handle,
- ego_entry->identifier,
- newname,
- &do_finished,
- handle);
+ ego_entry->identifier,
+ newname,
+ &do_finished,
+ handle);
if (NULL == handle->op)
{
- handle->emsg = GNUNET_strdup("Rename failed");
+ handle->emsg = GNUNET_strdup ("Rename failed");
GNUNET_SCHEDULER_add_now (&do_error, handle);
json_decref (data_js);
return;
}
json_decref (data_js);
return;
-
}
*/
void
ego_edit_pubkey (struct GNUNET_REST_RequestHandle *con_handle,
- const char* url,
- void *cls)
+ const char *url,
+ void *cls)
{
struct RequestHandle *handle = cls;
struct EgoEntry *ego_entry;
if (strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen (handle->url))
{
handle->response_code = MHD_HTTP_NOT_FOUND;
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_MISSING_PUBKEY);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_PUBKEY);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
- keystring = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY)+1];
- ego_entry = get_egoentry(handle, keystring, NULL);
+ keystring = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) + 1];
+ ego_entry = get_egoentry (handle, keystring, NULL);
if (NULL == ego_entry)
{
handle->response_code = MHD_HTTP_NOT_FOUND;
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
- ego_edit(handle,ego_entry);
+ ego_edit (handle, ego_entry);
}
/**
*/
void
ego_edit_name (struct GNUNET_REST_RequestHandle *con_handle,
- const char* url,
- void *cls)
+ const char *url,
+ void *cls)
{
struct RequestHandle *handle = cls;
struct EgoEntry *ego_entry;
if (strlen (GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen (handle->url))
{
handle->response_code = MHD_HTTP_NOT_FOUND;
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_MISSING_NAME);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_NAME);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
- name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME)+1];
- ego_entry = get_egoentry(handle, NULL, name);
+ name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME) + 1];
+ ego_entry = get_egoentry (handle, NULL, name);
if (NULL == ego_entry)
{
handle->response_code = MHD_HTTP_NOT_FOUND;
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
- ego_edit(handle,ego_entry);
+ ego_edit (handle, ego_entry);
}
/**
*/
void
ego_edit_subsystem (struct GNUNET_REST_RequestHandle *con_handle,
- const char* url,
- void *cls)
+ const char *url,
+ void *cls)
{
struct RequestHandle *handle = cls;
struct EgoEntry *ego_entry;
if (strlen (GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) >= strlen (handle->url))
{
handle->response_code = MHD_HTTP_NOT_FOUND;
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_MISSING_NAME);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_NAME);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
- name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM)+1];
- ego_entry = get_egoentry(handle, NULL, name);
+ name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) + 1];
+ ego_entry = get_egoentry (handle, NULL, name);
if (NULL == ego_entry)
{
handle->response_code = MHD_HTTP_NOT_FOUND;
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
//if no data
if (0 >= handle->data_size)
{
- handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_NO_DATA);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
//if not json
term_data[handle->data_size] = '\0';
- GNUNET_memcpy(term_data, handle->data, handle->data_size);
- data_js = json_loads (term_data,JSON_DECODE_ANY,&err);
+ GNUNET_memcpy (term_data, handle->data, handle->data_size);
+ data_js = json_loads (term_data, JSON_DECODE_ANY, &err);
if (NULL == data_js)
{
- handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_NO_DATA);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
newsubsys = NULL;
//SUBSYSTEM
json_state = 0;
- json_state = json_unpack(data_js,
- "{s:s!}",
- GNUNET_REST_IDENTITY_PARAM_SUBSYSTEM,
- &newsubsys);
+ json_state = json_unpack (data_js,
+ "{s:s!}",
+ GNUNET_REST_IDENTITY_PARAM_SUBSYSTEM,
+ &newsubsys);
//Change subsystem with pubkey or name identifier
if (0 != json_state)
{
- handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
GNUNET_SCHEDULER_add_now (&do_error, handle);
json_decref (data_js);
return;
if (NULL == newsubsys)
{
- handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
GNUNET_SCHEDULER_add_now (&do_error, handle);
json_decref (data_js);
return;
if (0 >= strlen (newsubsys))
{
- handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
GNUNET_SCHEDULER_add_now (&do_error, handle);
json_decref (data_js);
return;
handle->response_code = MHD_HTTP_NO_CONTENT;
handle->op = GNUNET_IDENTITY_set (handle->identity_handle,
- newsubsys,
- ego_entry->ego,
- &do_finished,
- handle);
+ newsubsys,
+ ego_entry->ego,
+ &do_finished,
+ handle);
if (NULL == handle->op)
{
- handle->emsg = GNUNET_strdup("Setting subsystem failed");
+ handle->emsg = GNUNET_strdup ("Setting subsystem failed");
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
json_decref (data_js);
return;
-
}
/**
*/
void
ego_create (struct GNUNET_REST_RequestHandle *con_handle,
- const char* url,
- void *cls)
+ const char *url,
+ void *cls)
{
struct RequestHandle *handle = cls;
struct EgoEntry *ego_entry;
struct MHD_Response *resp;
json_t *data_js;
json_error_t err;
- char* egoname;
+ char *egoname;
int json_unpack_state;
char term_data[handle->data_size + 1];
if (0 >= handle->data_size)
{
- handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_NO_DATA);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
term_data[handle->data_size] = '\0';
- GNUNET_memcpy(term_data, handle->data, handle->data_size);
- data_js = json_loads (term_data,
- JSON_DECODE_ANY,
- &err);
+ GNUNET_memcpy (term_data, handle->data, handle->data_size);
+ data_js = json_loads (term_data, JSON_DECODE_ANY, &err);
if (NULL == data_js)
{
- handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_NO_DATA);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
GNUNET_SCHEDULER_add_now (&do_error, handle);
json_decref (data_js);
return;
}
json_unpack_state = 0;
- json_unpack_state = json_unpack(data_js,
- "{s:s!}",
- GNUNET_REST_IDENTITY_PARAM_NAME,
- &egoname);
+ json_unpack_state =
+ json_unpack (data_js, "{s:s!}", GNUNET_REST_IDENTITY_PARAM_NAME, &egoname);
if (0 != json_unpack_state)
{
- handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
GNUNET_SCHEDULER_add_now (&do_error, handle);
json_decref (data_js);
return;
if (NULL == egoname)
{
- handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
GNUNET_SCHEDULER_add_now (&do_error, handle);
json_decref (data_js);
return;
if (0 >= strlen (egoname))
{
json_decref (data_js);
- handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
- GNUNET_STRINGS_utf8_tolower(egoname, egoname);
- for (ego_entry = handle->ego_head;
- NULL != ego_entry; ego_entry = ego_entry->next)
+ GNUNET_STRINGS_utf8_tolower (egoname, egoname);
+ for (ego_entry = handle->ego_head; NULL != ego_entry;
+ ego_entry = ego_entry->next)
{
if (0 == strcasecmp (egoname, ego_entry->identifier))
{
return;
}
}
- handle->name = GNUNET_strdup(egoname);
+ handle->name = GNUNET_strdup (egoname);
json_decref (data_js);
handle->response_code = MHD_HTTP_CREATED;
- handle->op = GNUNET_IDENTITY_create (handle->identity_handle, handle->name,
- &do_finished_create, handle);
+ handle->op = GNUNET_IDENTITY_create (handle->identity_handle,
+ handle->name,
+ &do_finished_create,
+ handle);
}
/**
*/
void
ego_delete_pubkey (struct GNUNET_REST_RequestHandle *con_handle,
- const char* url,
- void *cls)
+ const char *url,
+ void *cls)
{
struct RequestHandle *handle = cls;
struct EgoEntry *ego_entry;
if (strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen (handle->url))
{
handle->response_code = MHD_HTTP_NOT_FOUND;
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_MISSING_PUBKEY);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_PUBKEY);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
- keystring = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY)+1];
- ego_entry = get_egoentry(handle, keystring, NULL);
+ keystring = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) + 1];
+ ego_entry = get_egoentry (handle, keystring, NULL);
if (NULL == ego_entry)
{
handle->response_code = MHD_HTTP_NOT_FOUND;
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
handle->response_code = MHD_HTTP_NO_CONTENT;
handle->op = GNUNET_IDENTITY_delete (handle->identity_handle,
- ego_entry->identifier,
- &do_finished,
- handle);
+ ego_entry->identifier,
+ &do_finished,
+ handle);
}
*/
void
ego_delete_name (struct GNUNET_REST_RequestHandle *con_handle,
- const char* url,
- void *cls)
+ const char *url,
+ void *cls)
{
struct RequestHandle *handle = cls;
struct EgoEntry *ego_entry;
if (strlen (GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen (handle->url))
{
handle->response_code = MHD_HTTP_NOT_FOUND;
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_MISSING_NAME);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_NAME);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
- name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME)+1];
- ego_entry = get_egoentry(handle, NULL, name);
+ name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME) + 1];
+ ego_entry = get_egoentry (handle, NULL, name);
if (NULL == ego_entry)
{
handle->response_code = MHD_HTTP_NOT_FOUND;
- handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+ handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
handle->response_code = MHD_HTTP_NO_CONTENT;
handle->op = GNUNET_IDENTITY_delete (handle->identity_handle,
- ego_entry->identifier,
- &do_finished,
- handle);
+ ego_entry->identifier,
+ &do_finished,
+ handle);
}
* @param cls the RequestHandle
*/
static void
-options_cont (struct GNUNET_REST_RequestHandle *con_handle, const char* url,
- void *cls)
+options_cont (struct GNUNET_REST_RequestHandle *con_handle,
+ const char *url,
+ void *cls)
{
struct MHD_Response *resp;
struct RequestHandle *handle = cls;
init_cont (struct RequestHandle *handle)
{
struct GNUNET_REST_RequestHandlerError err;
- static const struct GNUNET_REST_RequestHandler handlers[] = {
- { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_ALL, &ego_get_all },
- { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_PUBKEY, &ego_get_pubkey },
- { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_NAME, &ego_get_name },
- { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM, &ego_get_subsystem },
- { MHD_HTTP_METHOD_PUT, GNUNET_REST_API_NS_IDENTITY_PUBKEY, &ego_edit_pubkey },
- { MHD_HTTP_METHOD_PUT, GNUNET_REST_API_NS_IDENTITY_NAME, &ego_edit_name },
- { MHD_HTTP_METHOD_PUT, GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM, &ego_edit_subsystem },
- { MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY, &ego_create },
- { MHD_HTTP_METHOD_DELETE, GNUNET_REST_API_NS_IDENTITY_PUBKEY, &ego_delete_pubkey },
- { MHD_HTTP_METHOD_DELETE, GNUNET_REST_API_NS_IDENTITY_NAME, &ego_delete_name },
- { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_IDENTITY, &options_cont },
- GNUNET_REST_HANDLER_END
- };
-
- if (GNUNET_NO
- == GNUNET_REST_handle_request (handle->rest_handle, handlers, &err,
- handle))
+ static const struct GNUNET_REST_RequestHandler handlers[] =
+ {{MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_ALL, &ego_get_all},
+ {MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_PUBKEY, &ego_get_pubkey},
+ {MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_NAME, &ego_get_name},
+ {MHD_HTTP_METHOD_GET,
+ GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM,
+ &ego_get_subsystem},
+ {MHD_HTTP_METHOD_PUT,
+ GNUNET_REST_API_NS_IDENTITY_PUBKEY,
+ &ego_edit_pubkey},
+ {MHD_HTTP_METHOD_PUT, GNUNET_REST_API_NS_IDENTITY_NAME, &ego_edit_name},
+ {MHD_HTTP_METHOD_PUT,
+ GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM,
+ &ego_edit_subsystem},
+ {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY, &ego_create},
+ {MHD_HTTP_METHOD_DELETE,
+ GNUNET_REST_API_NS_IDENTITY_PUBKEY,
+ &ego_delete_pubkey},
+ {MHD_HTTP_METHOD_DELETE,
+ GNUNET_REST_API_NS_IDENTITY_NAME,
+ &ego_delete_name},
+ {MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_IDENTITY, &options_cont},
+ GNUNET_REST_HANDLER_END};
+
+ if (GNUNET_NO ==
+ GNUNET_REST_handle_request (handle->rest_handle, handlers, &err, handle))
{
handle->response_code = err.error_code;
GNUNET_SCHEDULER_add_now (&do_error, handle);
* must thus no longer be used
*/
static void
-init_egos (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx,
- const char *identifier)
+init_egos (void *cls,
+ struct GNUNET_IDENTITY_Ego *ego,
+ void **ctx,
+ const char *identifier)
{
struct RequestHandle *handle = cls;
struct EgoEntry *ego_entry;
}
if (ID_REST_STATE_INIT == handle->state)
{
- ego_entry = GNUNET_new(struct EgoEntry);
+ ego_entry = GNUNET_new (struct EgoEntry);
GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
ego_entry->keystring = GNUNET_CRYPTO_ecdsa_public_key_to_string (&pk);
ego_entry->ego = ego;
GNUNET_asprintf (&ego_entry->identifier, "%s", identifier);
- GNUNET_CONTAINER_DLL_insert_tail(handle->ego_head, handle->ego_tail,
- ego_entry);
+ GNUNET_CONTAINER_DLL_insert_tail (handle->ego_head,
+ handle->ego_tail,
+ ego_entry);
}
}
*/
static void
rest_process_request (struct GNUNET_REST_RequestHandle *rest_handle,
- GNUNET_REST_ResultProcessor proc, void *proc_cls)
+ GNUNET_REST_ResultProcessor proc,
+ void *proc_cls)
{
- struct RequestHandle *handle = GNUNET_new(struct RequestHandle);
+ struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
handle->response_code = 0;
handle->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
handle->data = rest_handle->data;
handle->data_size = rest_handle->data_size;
- handle->url = GNUNET_strdup(rest_handle->url);
+ handle->url = GNUNET_strdup (rest_handle->url);
if (handle->url[strlen (handle->url) - 1] == '/')
handle->url[strlen (handle->url) - 1] = '\0';
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
handle->identity_handle = GNUNET_IDENTITY_connect (cfg, &init_egos, handle);
- handle->timeout_task = GNUNET_SCHEDULER_add_delayed (handle->timeout,
- &do_error, handle);
+ handle->timeout_task =
+ GNUNET_SCHEDULER_add_delayed (handle->timeout, &do_error, handle);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
}
/**
cfg = cls;
if (NULL != plugin.cfg)
return NULL; /* can only initialize once! */
- memset (&plugin, 0, sizeof(struct Plugin));
+ memset (&plugin, 0, sizeof (struct Plugin));
plugin.cfg = cfg;
- api = GNUNET_new(struct GNUNET_REST_Plugin);
+ api = GNUNET_new (struct GNUNET_REST_Plugin);
api->cls = &plugin;
api->name = GNUNET_REST_API_NS_IDENTITY;
api->process_request = &rest_process_request;
- GNUNET_asprintf (&allow_methods, "%s, %s, %s, %s, %s",
- MHD_HTTP_METHOD_GET,
- MHD_HTTP_METHOD_POST,
- MHD_HTTP_METHOD_PUT,
- MHD_HTTP_METHOD_DELETE,
- MHD_HTTP_METHOD_OPTIONS);
-
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, _("Identity REST API initialized\n"));
+ GNUNET_asprintf (&allow_methods,
+ "%s, %s, %s, %s, %s",
+ MHD_HTTP_METHOD_GET,
+ MHD_HTTP_METHOD_POST,
+ MHD_HTTP_METHOD_PUT,
+ MHD_HTTP_METHOD_DELETE,
+ MHD_HTTP_METHOD_OPTIONS);
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Identity REST API initialized\n"));
return api;
}
struct Plugin *plugin = api->cls;
plugin->cfg = NULL;
- GNUNET_free_non_null(allow_methods);
- GNUNET_free(api);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Identity REST plugin is finished\n");
+ GNUNET_free_non_null (allow_methods);
+ GNUNET_free (api);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Identity REST plugin is finished\n");
return NULL;
}