/**
* How important is this message?
*/
- uint32_t priority;
+ enum GNUNET_CORE_Priority priority;
/**
* Size of this request.
/**
* Task schedule to try to re-connect to core.
*
- * @param cls the 'struct GNUNET_CORE_Handle'
+ * @param cls the `struct GNUNET_CORE_Handle`
* @param tc task context
*/
static void
struct GNUNET_CORE_Handle *h = cls;
h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to CORE service after delay\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Connecting to CORE service after delay\n");
reconnect (h);
}
* Notify clients about disconnect and free
* the entry for connected peer.
*
- * @param cls the 'struct GNUNET_CORE_Handle*'
+ * @param cls the `struct GNUNET_CORE_Handle *`
* @param key the peer identity (not used)
- * @param value the 'struct PeerRecord' to free.
+ * @param value the `struct PeerRecord` to free.
* @return #GNUNET_YES (continue)
*/
static int
h->currently_down = GNUNET_YES;
GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK);
h->reconnect_task =
- GNUNET_SCHEDULER_add_delayed (h->retry_backoff, &reconnect_task, h);
+ GNUNET_SCHEDULER_add_delayed (h->retry_backoff,
+ &reconnect_task, h);
while (NULL != (cm = h->control_pending_head))
{
GNUNET_CONTAINER_DLL_remove (h->control_pending_head,
* @param tc context, can be NULL (!)
*/
static void
-transmission_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+transmission_timeout (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc);
/**
smr = (struct SendMessageRequest *) &cm[1];
smr->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST);
smr->header.size = htons (sizeof (struct SendMessageRequest));
- smr->priority = htonl (th->priority);
+ smr->priority = htonl ((uint32_t) th->priority);
smr->deadline = GNUNET_TIME_absolute_hton (th->timeout);
smr->peer = pr->peer;
smr->reserved = htonl (0);
* @param tc context, can be NULL (!)
*/
static void
-transmission_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+transmission_timeout (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct PeerRecord *pr = cls;
struct GNUNET_CORE_Handle *h = pr->ch;
/**
* Transmit the next message to the core service.
*
- * @param cls closure with the 'struct GNUNET_CORE_Handle'
+ * @param cls closure with the `struct GNUNET_CORE_Handle`
* @param size number of bytes available in @a buf
* @param buf where the callee should write the message
- * @return number of bytes written to buf
+ * @return number of bytes written to @a buf
*/
static size_t
transmit_message (void *cls, size_t size, void *buf)
GNUNET_i2s (&pr->peer), (unsigned int) th->msize);
sm = (struct SendMessage *) buf;
sm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_SEND);
- sm->priority = htonl (th->priority);
+ sm->priority = htonl ((uint32_t) th->priority);
sm->deadline = GNUNET_TIME_absolute_hton (th->timeout);
sm->peer = pr->peer;
sm->cork = htonl ((uint32_t) th->cork);
* @param ignore_currently_down transmit message even if not initialized?
*/
static void
-trigger_next_request (struct GNUNET_CORE_Handle *h, int ignore_currently_down)
+trigger_next_request (struct GNUNET_CORE_Handle *h,
+ int ignore_currently_down)
{
uint16_t msize;
/**
* Handler for notification messages received from the core.
*
- * @param cls our "struct GNUNET_CORE_Handle"
+ * @param cls our `struct GNUNET_CORE_Handle`
* @param msg the message received from the core service
*/
static void
-main_notify_handler (void *cls, const struct GNUNET_MessageHeader *msg)
+main_notify_handler (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
struct GNUNET_CORE_Handle *h = cls;
const struct InitReplyMessage *m;
unsigned int hpos;
GNUNET_assert (NULL == h->client);
- GNUNET_assert (h->currently_down == GNUNET_YES);
+ GNUNET_assert (GNUNET_YES == h->currently_down);
+ GNUNET_assert (NULL != h->cfg);
h->client = GNUNET_CLIENT_connect ("core", h->cfg);
if (NULL == h->client)
{
GNUNET_assert (h->hcnt <
(GNUNET_SERVER_MAX_MESSAGE_SIZE -
sizeof (struct InitMessage)) / sizeof (uint16_t));
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to CORE service\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Connecting to CORE service\n");
reconnect (h);
return h;
}
/**
* Disconnect from the core service. This function can only
- * be called *after* all pending 'GNUNET_CORE_notify_transmit_ready'
+ * be called *after* all pending #GNUNET_CORE_notify_transmit_ready()
* requests have been explicitly canceled.
*
* @param handle connection to core to disconnect
* @param handle connection to core service
* @param cork is corking allowed for this transmission?
* @param priority how important is the message?
- * @param maxdelay how long can the message wait?
+ * @param maxdelay how long can the message wait? Only effective if @a cork is #GNUNET_YES
* @param target who should receive the message, never NULL (can be this peer's identity for loopback)
* @param notify_size how many bytes of buffer space does @a notify want?
* @param notify function to call when buffer space is available;
* if NULL is returned, @a notify will NOT be called.
*/
struct GNUNET_CORE_TransmitHandle *
-GNUNET_CORE_notify_transmit_ready (struct GNUNET_CORE_Handle *handle, int cork,
- uint32_t priority,
+GNUNET_CORE_notify_transmit_ready (struct GNUNET_CORE_Handle *handle,
+ int cork,
+ enum GNUNET_CORE_Priority priority,
struct GNUNET_TIME_Relative maxdelay,
const struct GNUNET_PeerIdentity *target,
size_t notify_size,
struct PeerRecord *pr;
struct GNUNET_CORE_TransmitHandle *th;
- GNUNET_assert (NULL != handle);
- GNUNET_assert (NULL != target);
-
if (notify_size > GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE)
{
GNUNET_break (0);
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pr->ntr_task);
pr->ntr_task =
GNUNET_SCHEDULER_add_now (&run_request_next_transmission, pr);
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Transmission request added to queue\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Transmission request added to queue\n");
return th;
}
projects / oweals / gnunet.git / blobdiff