GNUNET_SOCIAL_AppEgoCallback ego_cb;
GNUNET_SOCIAL_AppHostPlaceCallback host_cb;
GNUNET_SOCIAL_AppGuestPlaceCallback guest_cb;
+ GNUNET_SOCIAL_AppConnectedCallback connected_cb;
void *cb_cls;
-
- /**
- * Is this place in the process of disconnecting from the service?
- * #GNUNET_YES or #GNUNET_NO
- */
- uint8_t is_disconnecting;
};
* Does this place belong to a host (#GNUNET_YES) or guest (#GNUNET_NO)?
*/
uint8_t is_host;
-
- /**
- * Is this place in the process of disconnecting from the service?
- * #GNUNET_YES or #GNUNET_NO
- */
- uint8_t is_disconnecting;
};
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"_notice_place_leave: got method from nym %s (%s).\n",
GNUNET_h2s (&hst->notice_place_leave_nym->pub_key_hash), str);
+ GNUNET_free (str);
}
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Host received modifier for _notice_place_leave message with ID %" PRIu64 ":\n"
"%c%s: %.*s\n",
- message_id, oper, name, value_size, value);
+ message_id, oper, name, value_size, (const char *) value);
/* skip _nym, it's added later in eom() */
if (0 == memcmp (name, "_nym", sizeof ("_nym"))
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"_notice_place_leave: got EOM from nym %s (%s).\n",
GNUNET_h2s (&hst->notice_place_leave_nym->pub_key_hash), str);
+ GNUNET_free (str);
if (GNUNET_YES != is_cancelled)
{
{
uint16_t cmsg_size = ntohs (app->connect_msg->size);
struct GNUNET_MessageHeader * cmsg = GNUNET_malloc (cmsg_size);
- memcpy (cmsg, app->connect_msg, cmsg_size);
+ GNUNET_memcpy (cmsg, app->connect_msg, cmsg_size);
GNUNET_CLIENT_MANAGER_transmit_now (app->client, cmsg);
GNUNET_free (cmsg);
}
{
uint16_t cmsg_size = ntohs (plc->connect_msg->size);
struct GNUNET_MessageHeader * cmsg = GNUNET_malloc (cmsg_size);
- memcpy (cmsg, plc->connect_msg, cmsg_size);
+ GNUNET_memcpy (cmsg, plc->connect_msg, cmsg_size);
GNUNET_CLIENT_MANAGER_transmit_now (plc->client, cmsg);
GNUNET_free (cmsg);
}
{
look->mod_value_remaining = look->mod_value_size;
look->mod_name = GNUNET_malloc (name_size);
- memcpy (look->mod_name, name, name_size);
+ GNUNET_memcpy (look->mod_name, name, name_size);
}
break;
}
struct GNUNET_SOCIAL_Nym *nym = nym_get_or_create (&req->slave_pub_key);
hst->answer_door_cb (hst->cb_cls, nym, method_name, env,
- data_size, data);
+ data, data_size);
} while (0);
if (NULL != env)
ego = GNUNET_malloc (sizeof (*ego));
ego->pub_key = emsg->ego_pub_key;
ego->name = GNUNET_malloc (name_size);
- memcpy (ego->name, &emsg[1], name_size);
+ GNUNET_memcpy (ego->name, &emsg[1], name_size);
}
else
{
ego->name = GNUNET_realloc (ego->name, name_size);
- memcpy (ego->name, &emsg[1], name_size);
+ GNUNET_memcpy (ego->name, &emsg[1], name_size);
}
GNUNET_CONTAINER_multihashmap_put (app->egos, &ego_pub_hash, ego,
}
+static void
+app_recv_ego_end (void *cls,
+ struct GNUNET_CLIENT_MANAGER_Connection *client,
+ const struct GNUNET_MessageHeader *msg)
+{
+ struct GNUNET_SOCIAL_App *
+ app = GNUNET_CLIENT_MANAGER_get_user_context_ (client, sizeof (*app));
+}
+
+
static void
app_recv_place (void *cls,
struct GNUNET_CLIENT_MANAGER_Connection *client,
ego = GNUNET_CONTAINER_multihashmap_get (app->egos, &ego_pub_hash);
if (NULL == ego)
{
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failure to obtain ego %s.\n",
+ GNUNET_h2s (&ego_pub_hash));
GNUNET_break (0);
return;
}
if (GNUNET_YES == pmsg->is_host)
{
- struct GNUNET_SOCIAL_HostConnection *hconn = GNUNET_malloc (sizeof (*hconn));
- hconn->app = app;
- hconn->plc_msg = *pmsg;
- app->host_cb (app->cb_cls, hconn, ego, &pmsg->place_pub_key, pmsg->place_state);
+ if (NULL != app->host_cb) {
+ struct GNUNET_SOCIAL_HostConnection *hconn = GNUNET_malloc (sizeof (*hconn));
+ hconn->app = app;
+ hconn->plc_msg = *pmsg;
+ app->host_cb (app->cb_cls, hconn, ego, &pmsg->place_pub_key, pmsg->place_state);
+ // FIXME: should this have a GNUNET_free (hconn) here?
+ }
}
- else
+ else if (NULL != app->guest_cb)
{
struct GNUNET_SOCIAL_GuestConnection *gconn = GNUNET_malloc (sizeof (*gconn));
gconn->app = app;
gconn->plc_msg = *pmsg;
app->guest_cb (app->cb_cls, gconn, ego, &pmsg->place_pub_key, pmsg->place_state);
+ // GNUNET_free (gconn); // FIXME: is this correct here? apparently not!
}
}
+static void
+app_recv_place_end (void *cls,
+ struct GNUNET_CLIENT_MANAGER_Connection *client,
+ const struct GNUNET_MessageHeader *msg)
+{
+ struct GNUNET_SOCIAL_App *
+ app = GNUNET_CLIENT_MANAGER_get_user_context_ (client, sizeof (*app));
+
+ if (NULL != app->connected_cb)
+ app->connected_cb (app->cb_cls);
+}
+
+
static struct GNUNET_CLIENT_MANAGER_MessageHandler host_handlers[] =
{
{ host_recv_enter_ack, NULL,
GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO,
sizeof (struct AppEgoMessage), GNUNET_YES },
+ { app_recv_ego_end, NULL,
+ GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO_END,
+ sizeof (struct GNUNET_MessageHeader), GNUNET_NO },
+
{ app_recv_place, NULL,
GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE,
sizeof (struct AppPlaceMessage), GNUNET_NO },
+ { app_recv_place_end, NULL,
+ GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE_END,
+ sizeof (struct GNUNET_MessageHeader), GNUNET_NO },
+
{ app_recv_result, NULL,
GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE,
sizeof (struct GNUNET_OperationResultMessage), GNUNET_YES },
* Application handle.
* @param ego
* Identity of the host.
- * @param place_key
- * Private-public key pair of the place.
- * NULL to generate a key.
* @param policy
* Policy specifying entry and history restrictions for the place.
* @param slicer
* @param cls
* Closure for the callbacks.
*
- * @return Handle for the host.
+ * @return Handle for the host. This handle contains the pubkey.
*/
struct GNUNET_SOCIAL_Host *
GNUNET_SOCIAL_host_enter (const struct GNUNET_SOCIAL_App *app,
hreq->header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER);
hreq->policy = policy;
hreq->ego_pub_key = ego->pub_key;
- memcpy (&hreq[1], app->id, app_id_size);
+ GNUNET_memcpy (&hreq[1], app->id, app_id_size);
plc->connect_msg = &hreq->header;
place_send_connect_msg (plc);
hreq->header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER);
hreq->place_pub_key = hconn->plc_msg.place_pub_key;
hreq->ego_pub_key = hconn->plc_msg.ego_pub_key;
- memcpy (&hreq[1], hconn->app->id, app_id_size);
+ GNUNET_memcpy (&hreq[1], hconn->app->id, app_id_size);
plc->connect_msg = &hreq->header;
place_send_connect_msg (plc);
dcsn->slave_pub_key = nym->pub_key;
if (0 < entry_resp_size)
- memcpy (&dcsn[1], entry_resp, entry_resp_size);
+ GNUNET_memcpy (&dcsn[1], entry_resp, entry_resp_size);
GNUNET_CLIENT_MANAGER_transmit (hst->plc.client, &dcsn->header);
GNUNET_free (dcsn);
void
GNUNET_SOCIAL_host_eject (struct GNUNET_SOCIAL_Host *hst,
const struct GNUNET_SOCIAL_Nym *nym,
- struct GNUNET_PSYC_Environment *env)
+ struct GNUNET_PSYC_Environment *e)
{
+ struct GNUNET_PSYC_Environment *env = e;
if (NULL == env)
env = GNUNET_PSYC_env_create ();
GNUNET_PSYC_env_add (env, GNUNET_PSYC_OP_SET,
"_nym", &nym->pub_key, sizeof (nym->pub_key));
GNUNET_SOCIAL_host_announce (hst, "_notice_place_leave", env, NULL, NULL,
GNUNET_SOCIAL_ANNOUNCE_NONE);
+ if (NULL == e)
+ GNUNET_PSYC_env_destroy (env);
}
GNUNET_ContinuationCallback disconnect_cb,
void *disconnect_cls)
{
- plc->is_disconnecting = GNUNET_YES;
plc->disconnect_cb = disconnect_cb;
plc->disconnect_cls = disconnect_cls;
/**
* Stop hosting the home.
*
- * Sends a _notice_place_closed announcement to the home.
+ * Sends a _notice_place_closing announcement to the home.
* Invalidates host handle.
*
* @param hst
GNUNET_ContinuationCallback disconnect_cb,
void *cls)
{
- GNUNET_SOCIAL_host_announce (hst, "_notice_place_closed", env, NULL, NULL,
+ GNUNET_SOCIAL_host_announce (hst, "_notice_place_closing", env, NULL, NULL,
GNUNET_SOCIAL_ANNOUNCE_NONE);
place_leave (&hst->plc);
GNUNET_SOCIAL_host_disconnect (hst, disconnect_cb, cls);
greq->relay_count = htonl (relay_count);
char *p = (char *) &greq[1];
- memcpy (p, app_id, app_id_size);
+ GNUNET_memcpy (p, app_id, app_id_size);
p += app_id_size;
if (0 < relay_size)
{
- memcpy (p, relays, relay_size);
+ GNUNET_memcpy (p, relays, relay_size);
p += relay_size;
}
- memcpy (p, join_msg, join_msg_size);
+ GNUNET_memcpy (p, join_msg, join_msg_size);
return greq;
}
uint16_t password_size = strlen (password) + 1;
uint16_t join_msg_size = 0;
- if (NULL != join_msg);
+ if (NULL != join_msg)
join_msg_size = ntohs (join_msg->header.size);
uint16_t greq_size = sizeof (struct GuestEnterByNameRequest)
greq->ego_pub_key = ego->pub_key;
char *p = (char *) &greq[1];
- memcpy (p, app->id, app_id_size);
+ GNUNET_memcpy (p, app->id, app_id_size);
p += app_id_size;
- memcpy (p, gns_name, gns_name_size);
+ GNUNET_memcpy (p, gns_name, gns_name_size);
p += gns_name_size;
- memcpy (p, password, password_size);
+ GNUNET_memcpy (p, password, password_size);
p += password_size;
if (NULL != join_msg)
- memcpy (p, join_msg, join_msg_size);
+ GNUNET_memcpy (p, join_msg, join_msg_size);
gst->enter_cb = local_enter_cb;
gst->entry_dcsn_cb = entry_decision_cb;
greq->place_pub_key = gconn->plc_msg.place_pub_key;
greq->flags = htonl (flags);
- memcpy (&greq[1], gconn->app->id, app_id_size);
+ GNUNET_memcpy (&greq[1], gconn->app->id, app_id_size);
gst->enter_cb = local_enter_cb;
gst->cb_cls = cls;
mpreq->header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_MSG_PROC_SET);
mpreq->header.size = htons (sizeof (*mpreq) + method_size);
mpreq->flags = htonl (flags);
- memcpy (&mpreq[1], method_prefix, method_size);
+ GNUNET_memcpy (&mpreq[1], method_prefix, method_size);
GNUNET_CLIENT_MANAGER_transmit (plc->client, &mpreq->header);
GNUNET_free (mpreq);
req->message_limit = GNUNET_htonll (message_limit);
req->flags = htonl (flags);
req->op_id = GNUNET_htonll (hist->op_id);
- memcpy (&req[1], method_prefix, method_size);
+ GNUNET_memcpy (&req[1], method_prefix, method_size);
GNUNET_CLIENT_MANAGER_transmit (plc->client, &req->header);
GNUNET_free (req);
req->header.type = htons (type);
req->header.size = htons (sizeof (*req) + name_size);
req->op_id = GNUNET_htonll (look->op_id);
- memcpy (&req[1], name, name_size);
+ GNUNET_memcpy (&req[1], name, name_size);
GNUNET_CLIENT_MANAGER_transmit (plc->client, &req->header);
GNUNET_free (req);
preq->relay_count = htonl (relay_count);
char *p = (char *) &preq[1];
- memcpy (p, name, name_size);
+ GNUNET_memcpy (p, name, name_size);
p += name_size;
- memcpy (p, password, password_size);
+ GNUNET_memcpy (p, password, password_size);
p += password_size;
- memcpy (p, relays, relay_size);
+ GNUNET_memcpy (p, relays, relay_size);
struct ZoneAddPlaceHandle * add_plc = GNUNET_malloc (sizeof (*add_plc));
add_plc->req = preq;
nreq->expiration_time = GNUNET_htonll (expiration_time.abs_value_us);
nreq->ego_pub_key = ego->pub_key;
nreq->nym_pub_key = *nym_pub_key;
- memcpy (&nreq[1], name, name_size);
+ GNUNET_memcpy (&nreq[1], name, name_size);
struct ZoneAddNymHandle * add_nym = GNUNET_malloc (sizeof (*add_nym));
add_nym->req = nreq;
* Configuration.
* @param id
* Application ID.
- * @param notify_host
+ * @param ego_cb
+ * Function to notify about an available ego.
+ * @param host_cb
* Function to notify about a place entered as host.
- * @param notify_guest
- * Function to notify about a place entered as guest..
- * @param notify_cls
+ * @param guest_cb
+ * Function to notify about a place entered as guest.
+ * @param cls
* Closure for the callbacks.
*
* @return Handle that can be used to stop listening.
GNUNET_SOCIAL_AppEgoCallback ego_cb,
GNUNET_SOCIAL_AppHostPlaceCallback host_cb,
GNUNET_SOCIAL_AppGuestPlaceCallback guest_cb,
+ GNUNET_SOCIAL_AppConnectedCallback connected_cb,
void *cls)
{
uint16_t app_id_size = strnlen (id, GNUNET_SOCIAL_APP_MAX_ID_SIZE);
app->ego_cb = ego_cb;
app->host_cb = host_cb;
app->guest_cb = guest_cb;
+ app->connected_cb = connected_cb;
app->cb_cls = cls;
app->egos = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
app->client = GNUNET_CLIENT_MANAGER_connect (cfg, "social",
GNUNET_CLIENT_MANAGER_set_user_context_ (app->client, app, sizeof (*app));
app->id = GNUNET_malloc (app_id_size);
- memcpy (app->id, id, app_id_size);
+ GNUNET_memcpy (app->id, id, app_id_size);
struct AppConnectRequest *creq = GNUNET_malloc (sizeof (*creq) + app_id_size);
creq->header.size = htons (sizeof (*creq) + app_id_size);
creq->header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_APP_CONNECT);
- memcpy (&creq[1], app->id, app_id_size);
+ GNUNET_memcpy (&creq[1], app->id, app_id_size);
app->connect_msg = &creq->header;
app_send_connect_msg (app);
*
* @param app
* Application handle.
+ * @param disconnect_cb
+ * Disconnect callback.
+ * @param disconnect_cls
+ * Disconnect closure.
*/
void
-GNUNET_SOCIAL_app_disconnect (struct GNUNET_SOCIAL_App *app)
+GNUNET_SOCIAL_app_disconnect (struct GNUNET_SOCIAL_App *app,
+ GNUNET_ContinuationCallback disconnect_cb,
+ void *disconnect_cls)
{
- GNUNET_CLIENT_MANAGER_disconnect (app->client, GNUNET_NO, NULL, NULL);
+ GNUNET_CLIENT_MANAGER_disconnect (app->client, GNUNET_NO,
+ disconnect_cb, disconnect_cls);
}