* @return GNUNET_YES (continue)
*/
static int
-disconnect_and_free_peer_entry (void *cls, const GNUNET_HashCode * key,
+disconnect_and_free_peer_entry (void *cls, const struct GNUNET_HashCode * key,
void *value)
{
struct GNUNET_CORE_Handle *h = cls;
struct GNUNET_CORE_TransmitHandle *th;
struct PeerRecord *pr = value;
- if (pr->timeout_task != GNUNET_SCHEDULER_NO_TASK)
+ if (GNUNET_SCHEDULER_NO_TASK != pr->timeout_task)
{
GNUNET_SCHEDULER_cancel (pr->timeout_task);
pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
- if (pr->ntr_task != GNUNET_SCHEDULER_NO_TASK)
+ if (GNUNET_SCHEDULER_NO_TASK != pr->ntr_task)
{
GNUNET_SCHEDULER_cancel (pr->ntr_task);
pr->ntr_task = GNUNET_SCHEDULER_NO_TASK;
}
- if ((pr->prev != NULL) || (pr->next != NULL) || (h->ready_peer_head == pr))
+ if ((NULL != pr->prev) || (NULL != pr->next) || (h->ready_peer_head == pr))
GNUNET_CONTAINER_DLL_remove (h->ready_peer_head, h->ready_peer_tail, pr);
- if (h->disconnects != NULL)
+ if (NULL != h->disconnects)
h->disconnects (h->cls, &pr->peer);
/* all requests should have been cancelled, clean up anyway, just in case */
th = &pr->th;
{
GNUNET_break (0);
th->peer = NULL;
- if (th->cm != NULL)
+ if (NULL != th->cm)
th->cm->th = NULL;
}
/* done with 'voluntary' cleanups, now on to normal freeing */
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_remove (h->peers, key, pr));
GNUNET_assert (pr->ch == h);
- GNUNET_assert (pr->timeout_task == GNUNET_SCHEDULER_NO_TASK);
- GNUNET_assert (pr->ntr_task == GNUNET_SCHEDULER_NO_TASK);
+ GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pr->timeout_task);
+ GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pr->ntr_task);
GNUNET_free (pr);
return GNUNET_YES;
}
struct ControlMessage *cm;
struct PeerRecord *pr;
- GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK);
+ GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->reconnect_task);
if (NULL != h->cth)
{
GNUNET_CLIENT_notify_transmit_ready_cancel (h->cth);
h->cth = NULL;
}
- if (h->client != NULL)
+ if (NULL != h->client)
{
GNUNET_CLIENT_disconnect (h->client);
h->client = NULL;
{
GNUNET_CONTAINER_DLL_remove (h->control_pending_head,
h->control_pending_tail, cm);
- if (cm->th != NULL)
+ if (NULL != cm->th)
cm->th->cm = NULL;
- if (cm->cont != NULL)
+ if (NULL != cm->cont)
cm->cont (cm->cont_cls, GNUNET_NO);
GNUNET_free (cm);
}
struct GNUNET_CORE_TransmitHandle *th;
pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+ if (GNUNET_SCHEDULER_NO_TASK != pr->ntr_task)
+ {
+ GNUNET_SCHEDULER_cancel (pr->ntr_task);
+ pr->ntr_task = GNUNET_SCHEDULER_NO_TASK;
+ }
th = &pr->th;
th->peer = NULL;
- if ((pr->prev != NULL) || (pr->next != NULL) || (pr == h->ready_peer_head))
+ if ((NULL != pr->prev) || (NULL != pr->next) || (pr == h->ready_peer_head))
{
/* the request that was 'approved' by core was
* canceled before it could be transmitted; remove
GNUNET_free (th->cm);
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Signalling timeout of request for transmission to CORE service\n");
- request_next_transmission (pr);
+ "Signalling timeout of request for transmission to peer `%s' via CORE\n",
+ GNUNET_i2s (&pr->peer));
+ trigger_next_request (h, GNUNET_NO);
+
GNUNET_assert (0 == th->get_message (th->get_message_cls, 0, NULL));
}
GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK);
h->cth = NULL;
- if (buf == NULL)
+ if (NULL == buf)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Transmission failed, initiating reconnect\n");
memcpy (buf, hdr, msize);
GNUNET_CONTAINER_DLL_remove (h->control_pending_head,
h->control_pending_tail, cm);
- if (cm->th != NULL)
+ if (NULL != cm->th)
cm->th->cm = NULL;
if (NULL != cm->cont)
cm->cont (cm->cont_cls, GNUNET_OK);
return msize;
}
/* now check for 'ready' P2P messages */
- if (NULL != (pr = h->ready_peer_head))
+ if (NULL == (pr = h->ready_peer_head))
+ return 0;
+ GNUNET_assert (NULL != pr->th.peer);
+ th = &pr->th;
+ if (size < th->msize + sizeof (struct SendMessage))
+ {
+ trigger_next_request (h, GNUNET_NO);
+ return 0;
+ }
+ GNUNET_CONTAINER_DLL_remove (h->ready_peer_head, h->ready_peer_tail, pr);
+ th->peer = NULL;
+ if (GNUNET_SCHEDULER_NO_TASK != pr->timeout_task)
+ {
+ GNUNET_SCHEDULER_cancel (pr->timeout_task);
+ pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+ }
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Transmitting SEND request to `%s' with %u bytes.\n",
+ 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->deadline = GNUNET_TIME_absolute_hton (th->timeout);
+ sm->peer = pr->peer;
+ sm->cork = htonl ((uint32_t) th->cork);
+ sm->reserved = htonl (0);
+ ret =
+ th->get_message (th->get_message_cls,
+ size - sizeof (struct SendMessage), &sm[1]);
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Transmitting SEND request to `%s' yielded %u bytes.\n",
+ GNUNET_i2s (&pr->peer), ret);
+ if (0 == ret)
{
- GNUNET_assert (NULL != pr->th.peer);
- th = &pr->th;
- if (size < th->msize + sizeof (struct SendMessage))
- {
- trigger_next_request (h, GNUNET_NO);
- return 0;
- }
- GNUNET_CONTAINER_DLL_remove (h->ready_peer_head, h->ready_peer_tail, pr);
- th->peer = NULL;
- if (pr->timeout_task != GNUNET_SCHEDULER_NO_TASK)
- {
- GNUNET_SCHEDULER_cancel (pr->timeout_task);
- pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;
- }
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Transmitting SEND request to `%s' with %u bytes.\n",
- 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->deadline = GNUNET_TIME_absolute_hton (th->timeout);
- sm->peer = pr->peer;
- sm->cork = htonl ((uint32_t) th->cork);
- sm->reserved = htonl (0);
- ret =
- th->get_message (th->get_message_cls,
- size - sizeof (struct SendMessage), &sm[1]);
-
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Transmitting SEND request to `%s' yielded %u bytes.\n",
- GNUNET_i2s (&pr->peer), ret);
- if (0 == ret)
- {
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Size of clients message to peer %s is 0!\n",
- GNUNET_i2s (&pr->peer));
- /* client decided to send nothing! */
- request_next_transmission (pr);
- return 0;
- }
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Produced SEND message to core with %u bytes payload\n",
- (unsigned int) ret);
- GNUNET_assert (ret >= sizeof (struct GNUNET_MessageHeader));
- if (ret + sizeof (struct SendMessage) >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
- {
- GNUNET_break (0);
- request_next_transmission (pr);
- return 0;
- }
- ret += sizeof (struct SendMessage);
- sm->header.size = htons (ret);
- GNUNET_assert (ret <= size);
+ "Size of clients message to peer %s is 0!\n",
+ GNUNET_i2s (&pr->peer));
+ /* client decided to send nothing! */
request_next_transmission (pr);
- return ret;
+ return 0;
+ }
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Produced SEND message to core with %u bytes payload\n",
+ (unsigned int) ret);
+ GNUNET_assert (ret >= sizeof (struct GNUNET_MessageHeader));
+ if (ret + sizeof (struct SendMessage) >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
+ {
+ GNUNET_break (0);
+ request_next_transmission (pr);
+ return 0;
}
- return 0;
+ ret += sizeof (struct SendMessage);
+ sm->header.size = htons (ret);
+ GNUNET_assert (ret <= size);
+ request_next_transmission (pr);
+ return ret;
}
LOG (GNUNET_ERROR_TYPE_DEBUG, "Request pending, not processing queue\n");
return;
}
- if (h->control_pending_head != NULL)
+ if (NULL != h->control_pending_head)
msize =
ntohs (((struct GNUNET_MessageHeader *) &h->
control_pending_head[1])->size);
continue;
if ((mh->expected_size != ntohs (em->size)) && (mh->expected_size != 0))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Unexpected message size %u for message of type %u from peer `%4s'\n",
- htons (em->size), mh->type, GNUNET_i2s (&ntm->peer));
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "Unexpected message size %u for message of type %u from peer `%4s'\n",
+ htons (em->size), mh->type, GNUNET_i2s (&ntm->peer));
GNUNET_break_op (0);
continue;
}
h->handlers = handlers;
h->hcnt = 0;
h->currently_down = GNUNET_YES;
- h->peers = GNUNET_CONTAINER_multihashmap_create (128);
+ h->peers = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
h->retry_backoff = GNUNET_TIME_UNIT_MILLISECONDS;
if (NULL != handlers)
while (handlers[h->hcnt].callback != NULL)
struct GNUNET_CORE_TransmitHandle *th;
GNUNET_assert (NULL != notify);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Asking core for transmission of %u bytes to `%s'\n",
+ (unsigned int) notify_size,
+ GNUNET_i2s (target));
pr = GNUNET_CONTAINER_multihashmap_get (handle->peers, &target->hashPubKey);
if (NULL == pr)
{
th->priority = priority;
th->msize = notify_size;
th->cork = cork;
+ 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");
struct GNUNET_CORE_Handle *h;
GNUNET_assert (NULL != pr);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Aborting transmission request to core for %u bytes to `%s'\n",
+ (unsigned int) th->msize,
+ GNUNET_i2s (&pr->peer));
th->peer = NULL;
h = pr->ch;
if (NULL != th->cm)
* us from the 'ready' list */
GNUNET_CONTAINER_DLL_remove (h->ready_peer_head, h->ready_peer_tail, pr);
}
+ if (GNUNET_SCHEDULER_NO_TASK != pr->ntr_task)
+ {
+ GNUNET_SCHEDULER_cancel (pr->ntr_task);
+ pr->ntr_task = GNUNET_SCHEDULER_NO_TASK;
+ }
}
projects / oweals / gnunet.git / blobdiff