=> bootstrap should use plugins, possible multiple at the same time!
Util:
-* Should "server" argument be given in event callbacks?
* consider adding "get_time" to "configuration" API
TESTCASES WANTED:
* Start the specified service.
*/
static void
-start_service (struct GNUNET_SERVER_Handle *server,
- struct GNUNET_SERVER_Client *client, const char *servicename)
+start_service (struct GNUNET_SERVER_Client *client, const char *servicename)
{
struct ServiceList *sl;
char *binary;
config, servicename);
signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
GNUNET_free (binary);
+ GNUNET_free (config);
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
* Stop the specified service.
*/
static void
-stop_service (struct GNUNET_SERVER_Handle *server,
- struct GNUNET_SERVER_Client *client, const char *servicename)
+stop_service (struct GNUNET_SERVER_Client *client, const char *servicename)
{
struct ServiceList *pos;
struct GNUNET_CLIENT_Connection *sc;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Preparing to stop `%s'\n", servicename);
pos = find_name (servicename);
- if (pos->kill_continuation != NULL)
+ if ((pos != NULL) && (pos->kill_continuation != NULL))
{
/* killing already in progress */
signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
* Handle START-message.
*
* @param cls closure (always NULL)
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
* @return GNUNET_OK to keep the connection open,
*/
static void
handle_start (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
- start_service (server, client, servicename);
+ start_service (client, servicename);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
* Handle STOP-message.
*
* @param cls closure (always NULL)
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
* @return GNUNET_OK to keep the connection open,
*/
static void
handle_stop (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
- stop_service (server, client, servicename);
+ stop_service (client, servicename);
}
pos = strtok (defaultservices, " ");
while (pos != NULL)
{
- start_service (server, NULL, pos);
+ start_service (NULL, pos);
pos = strtok (NULL, " ");
}
GNUNET_free (defaultservices);
GNUNET_CLIENT_receive (h->client,
&init_reply_handler,
h,
- GNUNET_TIME_absolute_get_remaining (h->
- startup_timeout));
+ GNUNET_TIME_absolute_get_remaining
+ (h->startup_timeout));
return sizeof (struct InitMessage) + h->hcnt * sizeof (uint16_t);
}
*/
static void
handle_client_init (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
*/
static void
handle_client_request_configure (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
"Asking transport for transmission of %u bytes to `%4s' in next %llu ms\n",
n->encrypted_head->size,
GNUNET_i2s (&n->peer),
- GNUNET_TIME_absolute_get_remaining (n->encrypted_head->
- deadline).value);
+ GNUNET_TIME_absolute_get_remaining (n->
+ encrypted_head->deadline).
+ value);
n->th =
GNUNET_TRANSPORT_notify_transmit_ready (transport, &n->peer,
n->encrypted_head->size,
}
if (discard_low_prio)
{
+ GNUNET_assert (min != NULL);
/* remove lowest-priority entry from consideration */
min->do_transmit = GNUNET_YES; /* means: discard (for now) */
}
*/
static void
handle_client_send (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Connection to peer `%4s' succeeded, retrying original send request\n",
GNUNET_i2s (&sm->peer));
- handle_client_send (NULL, NULL, NULL, &sm->header);
+ handle_client_send (NULL, NULL, &sm->header);
GNUNET_free (sm);
return 0;
}
*/
static void
handle_client_send (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
* received.
*
* @param cls closure
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
*/
typedef void (*GNUNET_SERVER_MessageCallback) (void *cls,
- struct GNUNET_SERVER_Handle *
- server,
struct GNUNET_SERVER_Client *
client,
const struct
*/
static void
send_to_each_host (const struct GNUNET_PeerIdentity *only,
- int trust_change,
- struct GNUNET_SERVER_Client *client,
- struct GNUNET_SERVER_Handle *server)
+ int trust_change, struct GNUNET_SERVER_Client *client)
{
struct HostEntry *pos;
struct InfoMessage *im;
* Handle ADD-message.
*
* @param cls closure
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
*/
static void
handle_add (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
* Handle GET-message.
*
* @param cls closure
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
*/
static void
handle_get (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
const struct ListPeerMessage *lpm;
lpm = (const struct ListPeerMessage *) message;
- send_to_each_host (&lpm->peer, ntohl (lpm->trust_change), client, server);
+ send_to_each_host (&lpm->peer, ntohl (lpm->trust_change), client);
}
* Handle GET-ALL-message.
*
* @param cls closure
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
*/
static void
handle_get_all (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
const struct ListAllPeersMessage *lpm;
lpm = (const struct ListAllPeersMessage *) message;
- send_to_each_host (NULL, ntohl (lpm->trust_change), client, server);
+ send_to_each_host (NULL, ntohl (lpm->trust_change), client);
}
* Handle GET-message.
*
* @param cls closure
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
*/
static void
handle_get (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
* Handle GET-message.
*
* @param cls closure
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
* @return GNUNET_OK to keep the connection open,
*/
static void
handle_get (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
* Handle SET-message.
*
* @param cls closure
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
*/
static void
handle_set (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
GNUNET_CLIENT_receive (h->client,
&receive_stats,
h,
- GNUNET_TIME_absolute_get_remaining (h->
- current->
- timeout));
+ GNUNET_TIME_absolute_get_remaining
+ (h->current->timeout));
return;
}
GNUNET_break (0);
GNUNET_CLIENT_receive (handle->client,
&receive_stats,
handle,
- GNUNET_TIME_absolute_get_remaining (handle->current->
- timeout));
+ GNUNET_TIME_absolute_get_remaining (handle->
+ current->timeout));
return msize;
}
GNUNET_NO,
GNUNET_SCHEDULER_PRIORITY_IDLE,
GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
- GNUNET_TIME_absolute_get_remaining (pos->
- timeout),
- &cleanup_validation, NULL);
+ GNUNET_TIME_absolute_get_remaining
+ (pos->timeout), &cleanup_validation, NULL);
}
{
first_call = GNUNET_YES;
chvc->e = GNUNET_malloc (sizeof (struct ValidationList));
- GNUNET_HELLO_get_key (h != NULL ? h : chvc->hello, &chvc->e->publicKey);
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_HELLO_get_key (h != NULL ? h : chvc->hello,
+ &chvc->e->publicKey));
chvc->e->timeout =
GNUNET_TIME_relative_to_absolute (HELLO_VERIFICATION_TIMEOUT);
chvc->e->next = pending_validations;
GNUNET_NO,
GNUNET_SCHEDULER_PRIORITY_IDLE,
GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
- GNUNET_TIME_absolute_get_remaining (chvc->
- e->
- timeout),
- &cleanup_validation, NULL);
+ GNUNET_TIME_absolute_get_remaining
+ (chvc->e->timeout), &cleanup_validation,
+ NULL);
GNUNET_free (chvc);
}
"Trying to transmit PONG using inbound connection\n");
#endif
n = find_neighbour (sender);
+ if (n == NULL)
+ {
+ GNUNET_break (0);
+ return;
+ }
transmit_to_peer (NULL, &vcr.header, GNUNET_YES, n);
}
* by any client which causes us to add it to our list.
*
* @param cls closure (always NULL)
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
*/
static void
handle_start (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
* Handle HELLO-message.
*
* @param cls closure (always NULL)
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
*/
static void
handle_hello (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
* Handle SEND-message.
*
* @param cls closure (always NULL)
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
*/
static void
handle_send (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
* Handle SET_QUOTA-message.
*
* @param cls closure (always NULL)
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
*/
static void
handle_set_quota (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
* Handle TRY_CONNECT-message.
*
* @param cls closure (always NULL)
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
*/
static void
handle_try_connect (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
cpy = sizeof (GNUNET_MessageHeader) - httpSession->cs.client.rpos1;
if (cpy > have)
cpy = have;
- memcpy (&httpSession->cs.client.
- rbuff1[httpSession->cs.client.rpos1], &inbuf[poff], cpy);
+ memcpy (&httpSession->cs.
+ client.rbuff1[httpSession->cs.client.rpos1], &inbuf[poff],
+ cpy);
httpSession->cs.client.rpos1 += cpy;
have -= cpy;
poff += cpy;
httpSession->cs.client.rpos2;
if (cpy > have)
cpy = have;
- memcpy (&httpSession->cs.client.
- rbuff2[httpSession->cs.client.rpos2], &inbuf[poff], cpy);
+ memcpy (&httpSession->cs.
+ client.rbuff2[httpSession->cs.client.rpos2], &inbuf[poff],
+ cpy);
have -= cpy;
poff += cpy;
httpSession->cs.client.rpos2 += cpy;
return;
session->transmit_handle
= GNUNET_SERVER_notify_transmit_ready (session->client,
- htons (session->pending_messages->
- msg->size) +
- (session->pending_messages->
- is_welcome ? 0 : sizeof (struct
- DataMessage)),
+ htons (session->
+ pending_messages->msg->
+ size) +
+ (session->
+ pending_messages->is_welcome ? 0 :
+ sizeof (struct DataMessage)),
GNUNET_TIME_absolute_get_remaining
- (session->pending_messages[0].
- timeout), &do_transmit, session);
+ (session->
+ pending_messages[0].timeout),
+ &do_transmit, session);
}
* our welcome.
*
* @param cls closure
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
*/
static void
handle_tcp_welcome (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
* compute latency and forward.
*
* @param cls closure
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
*/
static void
handle_tcp_data (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
GNUNET_NO,
GNUNET_SCHEDULER_PRIORITY_KEEP,
GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
- GNUNET_TIME_absolute_get_remaining (th->
- timeout),
- &transmit_timeout, th);
+ GNUNET_TIME_absolute_get_remaining
+ (th->timeout), &transmit_timeout, th);
insert_transmit_handle (&h->connect_wait_head, th);
return sizeof (struct TryConnectMessage);
}
default:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_
- ("Received unexpected message of type %u from `%4s' in %s:%u\n"),
- ntohs (msg->type), GNUNET_i2s (&im->peer), __FILE__,
- __LINE__);
+ ("Received unexpected message of type %u in %s:%u\n"),
+ ntohs (msg->type), __FILE__, __LINE__);
GNUNET_break (0);
break;
}
{
if ((conn->received_pos >= sizeof (struct GNUNET_MessageHeader)) &&
(conn->received_pos >=
- ntohs (((const struct GNUNET_MessageHeader *) conn->received_buf)->
- size)))
+ ntohs (((const struct GNUNET_MessageHeader *) conn->
+ received_buf)->size)))
conn->msg_complete = GNUNET_YES;
}
GNUNET_CRYPTO_RSA_KEY_LENGTH - GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH;
GNUNET_assert (0 ==
gcry_mpi_print (GCRYMPI_FMT_USG,
- &result->
- key[GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH],
+ &result->key
+ [GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH],
size, &size, skey[1]));
adjust (&result->key[GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH], size,
GNUNET_CRYPTO_RSA_KEY_LENGTH -
enc = GNUNET_malloc (sbuf.st_size);
GNUNET_assert (sbuf.st_size == READ (fd, enc, sbuf.st_size));
len = ntohs (enc->len);
+ ret = NULL;
if ((len != sbuf.st_size) || (NULL == (ret = rsa_decode_key (enc))))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
inet_ntop (fam,
(fam == AF_INET6)
? (const void *) &((struct sockaddr_in6 *)
- &addr)->
- sin6_addr : (const void *)
+ &addr)->sin6_addr : (const
+ void
+ *)
&((struct sockaddr_in *) &addr)->sin_addr,
msg, sizeof (msg)));
}
pTable->table[dwIfIdx].dwPhysAddrLen);
snprintf (szEntry, 1000, "%s (%s - %I64u)",
- pszIfName ? pszIfName : (char *) pTable->
- table[dwIfIdx].bDescr, inet_ntop (AF_INET, &dwIP, dst,
- INET_ADDRSTRLEN),
+ pszIfName ? pszIfName : (char *)
+ pTable->table[dwIfIdx].bDescr, inet_ntop (AF_INET,
+ &dwIP, dst,
+ INET_ADDRSTRLEN),
*((unsigned long long *) bPhysAddr));
szEntry[1000] = 0;
task->timeout = GNUNET_TIME_relative_to_absolute (delay);
task->priority =
check_priority ((prio ==
- GNUNET_SCHEDULER_PRIORITY_KEEP) ? sched->
- current_priority : prio);
+ GNUNET_SCHEDULER_PRIORITY_KEEP) ? sched->current_priority
+ : prio);
task->nfds = nfds;
task->run_on_shutdown = run_on_shutdown;
task->next = sched->pending;
}
if (sender != NULL)
sender->suspended++;
- mh->callback (mh->callback_cls, server, sender, message);
+ mh->callback (mh->callback_cls, sender, message);
found = GNUNET_YES;
}
i++;
* Handler for TEST message.
*
* @param cls closure (refers to service)
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
*/
static void
handle_test (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
* Handler for SHUTDOWN message.
*
* @param cls closure (refers to service)
- * @param server the server handling the message
* @param client identification of the client
* @param message the actual message
*/
static void
handle_shutdown (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
{
if (GNUNET_SYSERR ==
(disablev6 = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg,
- sctx->
- serviceName,
+ sctx->serviceName,
"DISABLEV6")))
return GNUNET_SYSERR;
}
*/
static void
echo_cb (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
}
printf ("%d RSA encrypt/decrypt operations %llums (%d failures)\n",
ITER,
- (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
- value, ok);
+ (unsigned long long)
+ GNUNET_TIME_absolute_get_duration (start).value, ok);
if (ok == 0)
return GNUNET_OK;
else
}
printf ("%d RSA sign/verify operations %llums\n",
ITER,
- (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
- value);
+ (unsigned long long)
+ GNUNET_TIME_absolute_get_duration (start).value);
return ok;
}
}
printf ("%d RSA encrypt/decrypt operations %llums (%d failures)\n",
ITER,
- (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
- value, ok);
+ (unsigned long long)
+ GNUNET_TIME_absolute_get_duration (start).value, ok);
GNUNET_CRYPTO_rsa_key_free (hostkey);
if (ok == 0)
return GNUNET_OK;
}
printf ("%d RSA encrypt operations %llu ms (%d failures)\n",
ITER,
- (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
- value, ok);
+ (unsigned long long)
+ GNUNET_TIME_absolute_get_duration (start).value, ok);
GNUNET_CRYPTO_rsa_key_free (hostkey);
if (ok != 0)
return GNUNET_SYSERR;
}
printf ("%d RSA encrypt/decrypt SK operations %llus (%d failures)\n",
ITER,
- (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
- value, ok);
+ (unsigned long long)
+ GNUNET_TIME_absolute_get_duration (start).value, ok);
GNUNET_CRYPTO_rsa_key_free (hostkey);
if (ok != 0)
return GNUNET_SYSERR;
}
printf ("%d RSA sign/verify operations %llums\n",
ITER,
- (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
- value);
+ (unsigned long long)
+ GNUNET_TIME_absolute_get_duration (start).value);
GNUNET_CRYPTO_rsa_key_free (hostkey);
return ok;
}
expect.sin_port = v4->sin_port;
expect.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
GNUNET_assert (0 == memcmp (&expect, v4, alen));
+ GNUNET_free (addr);
GNUNET_NETWORK_socket_destroy (lsock);
GNUNET_NETWORK_receive (asock,
1024,
static void
recv_fin_cb (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
static void
recv_cb (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *argclient,
const struct GNUNET_MessageHeader *message)
{
static void
recv_cb (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *argclient,
const struct GNUNET_MessageHeader *message)
{
static void
recv_cb (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *argclient,
const struct GNUNET_MessageHeader *message)
{
static void
recv_cb (void *cls,
- struct GNUNET_SERVER_Handle *server,
struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
projects / oweals / gnunet.git / commitdiff