*/
int currently_down;
+ /**
+ * Did we ever get INIT?
+ */
+ int have_init;
+
};
{
struct GNUNET_CORE_Handle *h = cls;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "MQ ERROR: %d\n",
+ error);
reconnect_later (h);
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Connected to core service of peer `%s'.\n",
GNUNET_i2s (&h->me));
+ h->have_init = GNUNET_YES;
init (h->cls,
&h->me);
}
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Successfully reconnected to core service.\n");
- GNUNET_break (0 == memcmp (&h->me,
- &m->my_identity,
- sizeof (struct GNUNET_PeerIdentity)));
+ if (GNUNET_NO == h->have_init)
+ {
+ h->me = m->my_identity;
+ h->have_init = GNUNET_YES;
+ }
+ else
+ {
+ GNUNET_break (0 == memcmp (&h->me,
+ &m->my_identity,
+ sizeof (struct GNUNET_PeerIdentity)));
+ }
}
/* fake 'connect to self' */
pr = GNUNET_new (struct PeerRecord);
*/
static void
handle_connect_notify (void *cls,
- const struct ConnectNotifyMessage * cnm)
+ const struct ConnectNotifyMessage *cnm)
{
struct GNUNET_CORE_Handle *h = cls;
struct PeerRecord *pr;
sm->peer = pr->peer;
sm->cork = htonl ((uint32_t) th->cork);
sm->reserved = htonl (0);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Calling get_message with buffer of %u bytes\n",
+ (unsigned int) th->msize);
+ /* FIXME: this is ugly and a bit brutal, but "get_message"
+ may call GNUNET_CORE_notify_transmit_ready() which
+ may call GNUNET_MQ_send() as well, and we MUST get this
+ message out before the next SEND_REQUEST. So we queue
+ it (even though incomplete) and then---relying on MQ being
+ nice and not actually touching 'env' until much later---
+ fill it afterwards. This is horrible style, and once
+ the core_api abandons GNUNET_CORE_notify_transmit_ready
+ in favor of an MQ-style API, this hack should no longer
+ be required */
+ GNUNET_MQ_send (h->mq,
+ env);
ret = th->get_message (th->get_message_cls,
th->msize,
&sm[1]);
- sm->header.size = htons (ret);
- th->msize = ret;
- // GNUNET_assert (ret == th->msize); /* NOTE: API change! */
+ sm->header.size = htons (ret + sizeof (struct SendMessage));
delay = GNUNET_TIME_absolute_get_duration (th->request_time);
overdue = GNUNET_TIME_absolute_get_duration (th->deadline);
if (overdue.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
GNUNET_STRINGS_relative_time_to_string (delay,
GNUNET_YES),
(th->cork) ? " (corked)" : "");
- GNUNET_MQ_send (h->mq,
- env);
}
* @param inbound_notify function to call for all inbound messages, can be NULL
* @param inbound_hdr_only set to #GNUNET_YES if inbound_notify will only read the
* GNUNET_MessageHeader and hence we do not need to give it the full message;
- * can be used to improve efficiency, ignored if @a inbound_notify is NULLL
+ * can be used to improve efficiency, ignored if @a inbound_notify is NULL
* @param outbound_notify function to call for all outbound messages, can be NULL
* @param outbound_hdr_only set to #GNUNET_YES if outbound_notify will only read the
* GNUNET_MessageHeader and hence we do not need to give it the full message
- * can be used to improve efficiency, ignored if @a outbound_notify is NULLL
+ * can be used to improve efficiency, ignored if @a outbound_notify is NULL
* @param handlers callbacks for messages we care about, NULL-terminated
- * @return handle to the core service (only useful for disconnect until 'init' is called);
+ * @return handle to the core service (only useful for disconnect until @a init is called);
* NULL on error (in this case, init is never called)
*/
struct GNUNET_CORE_Handle *
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Connecting to CORE service\n");
reconnect (h);
+ if (NULL == h->mq)
+ {
+ GNUNET_CORE_disconnect (h);
+ return NULL;
+ }
return h;
}
struct SendMessageRequest *smr;
struct GNUNET_MQ_Envelope *env;
+ if (NULL == handle->mq)
+ {
+ GNUNET_break (0); /* SEE #4588: do not call NTR from disconnect notification! */
+ return NULL;
+ }
GNUNET_assert (NULL != notify);
if ( (notify_size > GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE) ||
(notify_size + sizeof (struct SendMessage) >= GNUNET_SERVER_MAX_MESSAGE_SIZE) )
th->priority = priority;
th->msize = notify_size;
th->cork = cork;
+ if (NULL == handle->mq)
+ return th; /* see #4588 (hack until we transition core fully to MQ) */
env = GNUNET_MQ_msg (smr,
GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST);
smr->priority = htonl ((uint32_t) th->priority);