src/social/social_api.c

   1 /*
   2  * This file is part of GNUnet
   3  * Copyright (C) 2013 GNUnet e.V.
   4  *
   5  * GNUnet is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published
   7  * by the Free Software Foundation; either version 3, or (at your
   8  * option) any later version.
   9  *
  10  * GNUnet is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with GNUnet; see the file COPYING.  If not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 /**
  22  * @author Gabor X Toth
  23  *
  24  * @file
  25  * Social service; implements social interactions using the PSYC service.
  26  */
  27
  28 #include <inttypes.h>
  29 #include <string.h>
  30
  31 #include "platform.h"
  32 #include "gnunet_util_lib.h"
  33 #include "gnunet_psyc_service.h"
  34 #include "gnunet_psyc_util_lib.h"
  35 #include "gnunet_social_service.h"
  36 #include "social.h"
  37
  38 #define LOG(kind,...) GNUNET_log_from (kind, "social-api",__VA_ARGS__)
  39
  40 /**
  41  * Handle for an ego.
  42  */
  43 struct GNUNET_SOCIAL_Ego
  44 {
  45   struct GNUNET_CRYPTO_EcdsaPublicKey pub_key;
  46   struct GNUNET_HashCode pub_key_hash;
  47   char *name;
  48 };
  49
  50
  51 /**
  52  * Handle for a pseudonym of another user in the network.
  53  */
  54 struct GNUNET_SOCIAL_Nym
  55 {
  56   struct GNUNET_CRYPTO_EcdsaPublicKey pub_key;
  57   struct GNUNET_HashCode pub_key_hash;
  58 };
  59
  60
  61 /**
  62  * Handle for an application.
  63  */
  64 struct GNUNET_SOCIAL_App
  65 {
  66   /**
  67    * Configuration to use.
  68    */
  69   const struct GNUNET_CONFIGURATION_Handle *cfg;
  70
  71   /**
  72    * Client connection to the service.
  73    */
  74   struct GNUNET_MQ_Handle *mq;
  75
  76   /**
  77    * Message to send on connect.
  78    */
  79   struct GNUNET_MQ_Envelope *connect_env;
  80
  81   /**
  82    * Time to wait until we try to reconnect on failure.
  83    */
  84   struct GNUNET_TIME_Relative reconnect_delay;
  85
  86   /**
  87    * Task for reconnecting when the listener fails.
  88    */
  89   struct GNUNET_SCHEDULER_Task *reconnect_task;
  90
  91   /**
  92    * Async operations.
  93    */
  94   struct GNUNET_OP_Handle *op;
  95
  96   /**
  97    * Function called after disconnected from the service.
  98    */
  99   GNUNET_ContinuationCallback disconnect_cb;
 100
 101   /**
 102    * Closure for @a disconnect_cb.
 103    */
 104   void *disconnect_cls;
 105
 106   /**
 107    * Application ID.
 108    */
 109   char *id;
 110
 111   /**
 112    * Hash map of all egos.
 113    * pub_key_hash -> struct GNUNET_SOCIAL_Ego *
 114    */
 115   struct GNUNET_CONTAINER_MultiHashMap *egos;
 116
 117   GNUNET_SOCIAL_AppEgoCallback ego_cb;
 118   GNUNET_SOCIAL_AppHostPlaceCallback host_cb;
 119   GNUNET_SOCIAL_AppGuestPlaceCallback guest_cb;
 120   GNUNET_SOCIAL_AppConnectedCallback connected_cb;
 121   void *cb_cls;
 122 };
 123
 124
 125 struct GNUNET_SOCIAL_HostConnection
 126 {
 127   struct GNUNET_SOCIAL_App *app;
 128
 129   struct AppPlaceMessage plc_msg;
 130 };
 131
 132
 133 struct GNUNET_SOCIAL_GuestConnection
 134 {
 135   struct GNUNET_SOCIAL_App *app;
 136
 137   struct AppPlaceMessage plc_msg;
 138 };
 139
 140
 141 /**
 142  * Handle for a place where social interactions happen.
 143  */
 144 struct GNUNET_SOCIAL_Place
 145 {
 146   /**
 147    * Configuration to use.
 148    */
 149   const struct GNUNET_CONFIGURATION_Handle *cfg;
 150
 151   /**
 152    * Client connection to the service.
 153    */
 154   struct GNUNET_MQ_Handle *mq;
 155
 156   /**
 157    * Message to send on connect.
 158    */
 159   struct GNUNET_MQ_Envelope *connect_env;
 160
 161   /**
 162    * Time to wait until we try to reconnect on failure.
 163    */
 164   struct GNUNET_TIME_Relative reconnect_delay;
 165
 166   /**
 167    * Task for reconnecting when the listener fails.
 168    */
 169   struct GNUNET_SCHEDULER_Task *reconnect_task;
 170
 171   /**
 172    * Async operations.
 173    */
 174   struct GNUNET_OP_Handle *op;
 175
 176   /**
 177    * Transmission handle.
 178    */
 179   struct GNUNET_PSYC_TransmitHandle *tmit;
 180
 181   /**
 182    * Slicer for processing incoming messages.
 183    */
 184   struct GNUNET_PSYC_Slicer *slicer;
 185
 186   /**
 187    * Function called after disconnected from the service.
 188    */
 189   GNUNET_ContinuationCallback disconnect_cb;
 190
 191   /**
 192    * Closure for @a disconnect_cb.
 193    */
 194   void *disconnect_cls;
 195
 196   /**
 197    * Public key of the place.
 198    */
 199   struct GNUNET_CRYPTO_EddsaPublicKey pub_key;
 200
 201   /**
 202    * Public key of the ego.
 203    */
 204   struct GNUNET_CRYPTO_EcdsaPublicKey ego_pub_key;
 205
 206   /**
 207    * Does this place belong to a host (#GNUNET_YES) or guest (#GNUNET_NO)?
 208    */
 209   uint8_t is_host;
 210 };
 211
 212
 213 /**
 214  * Host handle for a place that we entered.
 215  */
 216 struct GNUNET_SOCIAL_Host
 217 {
 218   struct GNUNET_SOCIAL_Place plc;
 219
 220   /**
 221    * Slicer for processing incoming messages from guests.
 222    */
 223   struct GNUNET_PSYC_Slicer *slicer;
 224
 225   GNUNET_SOCIAL_HostEnterCallback enter_cb;
 226
 227   GNUNET_SOCIAL_AnswerDoorCallback answer_door_cb;
 228
 229   GNUNET_SOCIAL_FarewellCallback farewell_cb;
 230
 231   /**
 232    * Closure for callbacks.
 233    */
 234   void *cb_cls;
 235
 236   struct GNUNET_SOCIAL_Nym *notice_place_leave_nym;
 237   struct GNUNET_PSYC_Environment *notice_place_leave_env;
 238 };
 239
 240
 241 /**
 242  * Guest handle for place that we entered.
 243  */
 244 struct GNUNET_SOCIAL_Guest
 245 {
 246   struct GNUNET_SOCIAL_Place plc;
 247
 248   GNUNET_SOCIAL_GuestEnterCallback enter_cb;
 249
 250   GNUNET_SOCIAL_EntryDecisionCallback entry_dcsn_cb;
 251
 252   /**
 253    * Closure for callbacks.
 254    */
 255   void *cb_cls;
 256 };
 257
 258
 259 /**
 260  * Hash map of all nyms.
 261  * pub_key_hash -> struct GNUNET_SOCIAL_Nym *
 262  */
 263 struct GNUNET_CONTAINER_MultiHashMap *nyms;
 264
 265
 266 /**
 267  * Handle for an announcement request.
 268  */
 269 struct GNUNET_SOCIAL_Announcement
 270 {
 271
 272 };
 273
 274
 275 /**
 276  * A talk request.
 277  */
 278 struct GNUNET_SOCIAL_TalkRequest
 279 {
 280
 281 };
 282
 283
 284 /**
 285  * A history lesson.
 286  */
 287 struct GNUNET_SOCIAL_HistoryRequest
 288 {
 289   /**
 290    * Place.
 291    */
 292   struct GNUNET_SOCIAL_Place *plc;
 293
 294   /**
 295    * Operation ID.
 296    */
 297   uint64_t op_id;
 298
 299   /**
 300    * Slicer for processing incoming messages.
 301    */
 302   struct GNUNET_PSYC_Slicer *slicer;
 303
 304   /**
 305    * Function to call when the operation finished.
 306    */
 307   GNUNET_ResultCallback result_cb;
 308
 309   /**
 310    * Closure for @a result_cb.
 311    */
 312   void *cls;
 313 };
 314
 315
 316 struct GNUNET_SOCIAL_LookHandle
 317 {
 318   /**
 319    * Place.
 320    */
 321   struct GNUNET_SOCIAL_Place *plc;
 322
 323   /**
 324    * Operation ID.
 325    */
 326   uint64_t op_id;
 327
 328   /**
 329    * State variable result callback.
 330    */
 331   GNUNET_PSYC_StateVarCallback var_cb;
 332
 333   /**
 334    * Function to call when the operation finished.
 335    */
 336   GNUNET_ResultCallback result_cb;
 337
 338   /**
 339    * Name of current modifier being received.
 340    */
 341   char *mod_name;
 342
 343   /**
 344    * Size of current modifier value being received.
 345    */
 346   size_t mod_value_size;
 347
 348   /**
 349    * Remaining size of current modifier value still to be received.
 350    */
 351   size_t mod_value_remaining;
 352
 353   /**
 354    * Closure for @a result_cb.
 355    */
 356   void *cls;
 357 };
 358
 359
 360 struct ZoneAddPlaceHandle
 361 {
 362   GNUNET_ResultCallback result_cb;
 363   void *result_cls;
 364 };
 365
 366
 367 struct ZoneAddNymHandle
 368 {
 369   GNUNET_ResultCallback result_cb;
 370   void *result_cls;
 371 };
 372
 373
 374 /*** NYM ***/
 375
 376 static struct GNUNET_SOCIAL_Nym *
 377 nym_get_or_create (const struct GNUNET_CRYPTO_EcdsaPublicKey *pub_key)
 378 {
 379   struct GNUNET_SOCIAL_Nym *nym = NULL;
 380   struct GNUNET_HashCode pub_key_hash;
 381
 382   if (NULL == pub_key)
 383     return NULL;
 384
 385   GNUNET_CRYPTO_hash (pub_key, sizeof (*pub_key), &pub_key_hash);
 386
 387   if (NULL == nyms)
 388     nyms = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
 389   else
 390     nym = GNUNET_CONTAINER_multihashmap_get (nyms, &pub_key_hash);
 391
 392   if (NULL == nym)
 393   {
 394     nym = GNUNET_new (struct GNUNET_SOCIAL_Nym);
 395     nym->pub_key = *pub_key;
 396     nym->pub_key_hash = pub_key_hash;
 397     GNUNET_CONTAINER_multihashmap_put (nyms, &nym->pub_key_hash, nym,
 398                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
 399   }
 400   return nym;
 401 }
 402
 403
 404 static void
 405 nym_destroy (struct GNUNET_SOCIAL_Nym *nym)
 406 {
 407   GNUNET_CONTAINER_multihashmap_remove (nyms, &nym->pub_key_hash, nym);
 408   GNUNET_free (nym);
 409 }
 410
 411
 412 /*** MESSAGE HANDLERS ***/
 413
 414 /** _notice_place_leave from guests */
 415
 416 static void
 417 host_recv_notice_place_leave_method (void *cls,
 418                                      const struct GNUNET_PSYC_MessageHeader *msg,
 419                                      const struct GNUNET_PSYC_MessageMethod *meth,
 420                                      uint64_t message_id,
 421                                      const char *method_name)
 422 {
 423   struct GNUNET_SOCIAL_Host *hst = cls;
 424
 425   if (0 == memcmp (&(struct GNUNET_CRYPTO_EcdsaPublicKey) {},
 426                    &msg->slave_pub_key, sizeof (msg->slave_pub_key)))
 427     return;
 428
 429   struct GNUNET_SOCIAL_Nym *nym = nym_get_or_create (&msg->slave_pub_key);
 430
 431   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 432               "Host received method for message ID %" PRIu64 " from nym %s: %s\n",
 433               message_id, GNUNET_h2s (&nym->pub_key_hash), method_name);
 434
 435   hst->notice_place_leave_nym = (struct GNUNET_SOCIAL_Nym *) nym;
 436   hst->notice_place_leave_env = GNUNET_PSYC_env_create ();
 437
 438   char *str = GNUNET_CRYPTO_ecdsa_public_key_to_string (&hst->notice_place_leave_nym->pub_key);
 439   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 440               "_notice_place_leave: got method from nym %s (%s).\n",
 441               GNUNET_h2s (&hst->notice_place_leave_nym->pub_key_hash), str);
 442   GNUNET_free (str);
 443 }
 444
 445
 446 static void
 447 host_recv_notice_place_leave_modifier (void *cls,
 448                                        const struct GNUNET_PSYC_MessageHeader *msg,
 449                                        const struct GNUNET_MessageHeader *pmsg,
 450                                        uint64_t message_id,
 451                                        enum GNUNET_PSYC_Operator oper,
 452                                        const char *name,
 453                                        const void *value,
 454                                        uint16_t value_size,
 455                                        uint16_t full_value_size)
 456 {
 457   struct GNUNET_SOCIAL_Host *hst = cls;
 458   if (NULL == hst->notice_place_leave_env)
 459     return;
 460
 461   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 462               "Host received modifier for _notice_place_leave message with ID %" PRIu64 ":\n"
 463               "%c%s: %.*s\n",
 464               message_id, oper, name, value_size, (const char *) value);
 465
 466   /* skip _nym, it's added later in eom() */
 467   if (0 == memcmp (name, "_nym", sizeof ("_nym"))
 468       || 0 == memcmp (name, "_nym_", sizeof ("_nym_") - 1))
 469     return;
 470
 471   GNUNET_PSYC_env_add (hst->notice_place_leave_env,
 472                        GNUNET_PSYC_OP_SET, name, value, value_size);
 473 }
 474
 475
 476 static void
 477 host_recv_notice_place_leave_eom (void *cls,
 478                                   const struct GNUNET_PSYC_MessageHeader *msg,
 479                                   const struct GNUNET_MessageHeader *pmsg,
 480                                   uint64_t message_id,
 481                                   uint8_t is_cancelled)
 482 {
 483   struct GNUNET_SOCIAL_Host *hst = cls;
 484   if (NULL == hst->notice_place_leave_env)
 485     return;
 486
 487   char *str = GNUNET_CRYPTO_ecdsa_public_key_to_string (&hst->notice_place_leave_nym->pub_key);
 488   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 489               "_notice_place_leave: got EOM from nym %s (%s).\n",
 490               GNUNET_h2s (&hst->notice_place_leave_nym->pub_key_hash), str);
 491   GNUNET_free (str);
 492
 493   if (GNUNET_YES != is_cancelled)
 494   {
 495     if (NULL != hst->farewell_cb)
 496       hst->farewell_cb (hst->cb_cls, hst->notice_place_leave_nym,
 497                         hst->notice_place_leave_env);
 498     /* announce leaving guest to place */
 499     GNUNET_PSYC_env_add (hst->notice_place_leave_env, GNUNET_PSYC_OP_SET,
 500                          "_nym", hst->notice_place_leave_nym,
 501                          sizeof (*hst->notice_place_leave_nym));
 502     GNUNET_SOCIAL_host_announce (hst, "_notice_place_leave",
 503                                  hst->notice_place_leave_env,
 504                                  NULL, NULL, GNUNET_SOCIAL_ANNOUNCE_NONE);
 505     nym_destroy (hst->notice_place_leave_nym);
 506   }
 507   GNUNET_PSYC_env_destroy (hst->notice_place_leave_env);
 508   hst->notice_place_leave_env = NULL;
 509 }
 510
 511
 512 /*** PLACE ***/
 513
 514
 515 static int
 516 check_place_result (void *cls,
 517                     const struct GNUNET_OperationResultMessage *res)
 518 {
 519   uint16_t size = ntohs (res->header.size);
 520   if (size < sizeof (*res))
 521   { /* Error, message too small. */
 522     GNUNET_break (0);
 523     return GNUNET_SYSERR;
 524   }
 525   return GNUNET_OK;
 526 }
 527
 528
 529 static void
 530 handle_place_result (void *cls,
 531                      const struct GNUNET_OperationResultMessage *res)
 532 {
 533   struct GNUNET_SOCIAL_Place *plc = cls;
 534
 535   uint16_t size = ntohs (res->header.size);
 536   uint16_t data_size = size - sizeof (*res);
 537   const char *data = (0 < data_size) ? (const char *) &res[1] : NULL;
 538
 539   GNUNET_OP_result (plc->op, GNUNET_ntohll (res->op_id),
 540                     GNUNET_ntohll (res->result_code),
 541                     data, data_size, NULL);
 542 }
 543
 544
 545 static int
 546 check_app_result (void *cls,
 547                   const struct GNUNET_OperationResultMessage *res)
 548 {
 549   uint16_t size = ntohs (res->header.size);
 550   if (size < sizeof (*res))
 551   { /* Error, message too small. */
 552     GNUNET_break (0);
 553     return GNUNET_SYSERR;
 554   }
 555   return GNUNET_OK;
 556 }
 557
 558
 559 static void
 560 handle_app_result (void *cls,
 561                    const struct GNUNET_OperationResultMessage *res)
 562 {
 563   struct GNUNET_SOCIAL_App *app = cls;
 564
 565   uint16_t size = ntohs (res->header.size);
 566   uint16_t data_size = size - sizeof (*res);
 567   const char *data = (0 < data_size) ? (const char *) &res[1] : NULL;
 568
 569   GNUNET_OP_result (app->op, GNUNET_ntohll (res->op_id),
 570                     GNUNET_ntohll (res->result_code),
 571                     data, data_size, NULL);
 572 }
 573
 574
 575 static void
 576 op_recv_history_result (void *cls, int64_t result,
 577                         const void *err_msg, uint16_t err_msg_size)
 578 {
 579   LOG (GNUNET_ERROR_TYPE_DEBUG,
 580        "Received history replay result: %" PRId64 ".\n", result);
 581
 582   struct GNUNET_SOCIAL_HistoryRequest *hist = cls;
 583
 584   if (NULL != hist->result_cb)
 585     hist->result_cb (hist->cls, result, err_msg, err_msg_size);
 586
 587   GNUNET_free (hist);
 588 }
 589
 590
 591 static void
 592 op_recv_state_result (void *cls, int64_t result,
 593                       const void *err_msg, uint16_t err_msg_size)
 594 {
 595   LOG (GNUNET_ERROR_TYPE_DEBUG,
 596        "Received state request result: %" PRId64 ".\n", result);
 597
 598   struct GNUNET_SOCIAL_LookHandle *look = cls;
 599
 600   if (NULL != look->result_cb)
 601     look->result_cb (look->cls, result, err_msg, err_msg_size);
 602
 603   GNUNET_free (look);
 604 }
 605
 606
 607 static int
 608 check_place_history_result (void *cls,
 609                             const struct GNUNET_OperationResultMessage *res)
 610 {
 611   struct GNUNET_PSYC_MessageHeader *
 612     pmsg = (struct GNUNET_PSYC_MessageHeader *) GNUNET_MQ_extract_nested_mh (res);
 613   uint16_t size = ntohs (res->header.size);
 614
 615   if (NULL == pmsg || size < sizeof (*res) + sizeof (*pmsg))
 616   { /* Error, message too small. */
 617     GNUNET_break (0);
 618     return GNUNET_SYSERR;
 619   }
 620   return GNUNET_OK;
 621 }
 622
 623
 624 static void
 625 handle_place_history_result (void *cls,
 626                              const struct GNUNET_OperationResultMessage *res)
 627 {
 628   struct GNUNET_SOCIAL_Place *plc = cls;
 629   struct GNUNET_PSYC_MessageHeader *
 630     pmsg = (struct GNUNET_PSYC_MessageHeader *) GNUNET_MQ_extract_nested_mh (res);
 631
 632   LOG (GNUNET_ERROR_TYPE_DEBUG,
 633        "%p Received historic fragment for message #%" PRIu64 ".\n",
 634        plc, GNUNET_ntohll (pmsg->message_id));
 635
 636   GNUNET_ResultCallback result_cb = NULL;
 637   struct GNUNET_SOCIAL_HistoryRequest *hist = NULL;
 638
 639   if (GNUNET_YES != GNUNET_OP_get (plc->op,
 640                                    GNUNET_ntohll (res->op_id),
 641                                    &result_cb, (void *) &hist, NULL))
 642   { /* Operation not found. */
 643     LOG (GNUNET_ERROR_TYPE_WARNING,
 644          "%p Replay operation not found for historic fragment of message #%"
 645          PRIu64 ".\n",
 646          plc, GNUNET_ntohll (pmsg->message_id));
 647     return;
 648   }
 649
 650   GNUNET_PSYC_slicer_message (hist->slicer,
 651                               (const struct GNUNET_PSYC_MessageHeader *) pmsg);
 652 }
 653
 654
 655 static int
 656 check_place_state_result (void *cls,
 657                           const struct GNUNET_OperationResultMessage *res)
 658 {
 659   const struct GNUNET_MessageHeader *mod = GNUNET_MQ_extract_nested_mh (res);
 660   if (NULL == mod)
 661   {
 662     GNUNET_break_op (0);
 663     LOG (GNUNET_ERROR_TYPE_WARNING,
 664          "Invalid modifier in state result\n");
 665     return GNUNET_SYSERR;
 666   }
 667
 668   uint16_t size = ntohs (res->header.size);
 669   uint16_t mod_size = ntohs (mod->size);
 670   if (size - sizeof (*res) != mod_size)
 671   {
 672     GNUNET_break_op (0);
 673     LOG (GNUNET_ERROR_TYPE_WARNING,
 674          "Invalid modifier size in state result: %u - %u != %u\n",
 675          ntohs (res->header.size), sizeof (*res), mod_size);
 676     return GNUNET_SYSERR;
 677   }
 678   return GNUNET_OK;
 679 }
 680
 681
 682 static void
 683 handle_place_state_result (void *cls,
 684                            const struct GNUNET_OperationResultMessage *res)
 685 {
 686   struct GNUNET_SOCIAL_Place *plc = cls;
 687
 688   GNUNET_ResultCallback result_cb = NULL;
 689   struct GNUNET_SOCIAL_LookHandle *look = NULL;
 690
 691   if (GNUNET_YES != GNUNET_OP_get (plc->op,
 692                                    GNUNET_ntohll (res->op_id),
 693                                    &result_cb, (void *) &look, NULL))
 694   { /* Operation not found. */
 695     return;
 696   }
 697
 698   const struct GNUNET_MessageHeader *mod = GNUNET_MQ_extract_nested_mh (res);
 699   uint16_t mod_size = ntohs (mod->size);
 700
 701   switch (ntohs (mod->type))
 702   {
 703   case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MODIFIER:
 704   {
 705     const struct GNUNET_PSYC_MessageModifier *
 706       pmod = (const struct GNUNET_PSYC_MessageModifier *) mod;
 707
 708     const char *name = (const char *) &pmod[1];
 709     uint16_t name_size = ntohs (pmod->name_size);
 710     if (0 == name_size
 711         || mod_size - sizeof (*pmod) < name_size
 712         || '\0' != name[name_size - 1])
 713     {
 714       GNUNET_break_op (0);
 715       LOG (GNUNET_ERROR_TYPE_WARNING,
 716            "Invalid modifier name in state result\n");
 717       return;
 718     }
 719     look->mod_value_size = ntohs (pmod->value_size);
 720     look->var_cb (look->cls, mod, name, name + name_size,
 721                   mod_size - sizeof (*mod) - name_size,
 722                   look->mod_value_size);
 723     if (look->mod_value_size > mod_size - sizeof (*mod) - name_size)
 724     {
 725         look->mod_value_remaining = look->mod_value_size;
 726         look->mod_name = GNUNET_malloc (name_size);
 727         GNUNET_memcpy (look->mod_name, name, name_size);
 728     }
 729     break;
 730   }
 731
 732   case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MOD_CONT:
 733     look->var_cb (look->cls, mod, look->mod_name, (const char *) &mod[1],
 734                   mod_size - sizeof (*mod), look->mod_value_size);
 735     look->mod_value_remaining -= mod_size - sizeof (*mod);
 736     if (0 == look->mod_value_remaining)
 737     {
 738         GNUNET_free (look->mod_name);
 739     }
 740     break;
 741   }
 742 }
 743
 744
 745 static void
 746 handle_place_message_ack (void *cls,
 747                           const struct GNUNET_MessageHeader *msg)
 748 {
 749   struct GNUNET_SOCIAL_Place *plc = cls;
 750
 751   GNUNET_PSYC_transmit_got_ack (plc->tmit);
 752 }
 753
 754
 755 static int
 756 check_place_message (void *cls,
 757                      const struct GNUNET_PSYC_MessageHeader *pmsg)
 758 {
 759   return GNUNET_OK;
 760 }
 761
 762
 763 static void
 764 handle_place_message (void *cls,
 765                       const struct GNUNET_PSYC_MessageHeader *pmsg)
 766 {
 767   struct GNUNET_SOCIAL_Place *plc = cls;
 768
 769   GNUNET_PSYC_slicer_message (plc->slicer, pmsg);
 770 }
 771
 772
 773 static int
 774 check_host_message (void *cls,
 775                     const struct GNUNET_PSYC_MessageHeader *pmsg)
 776 {
 777   return GNUNET_OK;
 778 }
 779
 780
 781 static void
 782 handle_host_message (void *cls,
 783                      const struct GNUNET_PSYC_MessageHeader *pmsg)
 784 {
 785   struct GNUNET_SOCIAL_Host *hst = cls;
 786
 787   GNUNET_PSYC_slicer_message (hst->slicer, pmsg);
 788   GNUNET_PSYC_slicer_message (hst->plc.slicer, pmsg);
 789 }
 790
 791
 792 static void
 793 handle_host_enter_ack (void *cls,
 794                        const struct HostEnterAck *hack)
 795 {
 796   struct GNUNET_SOCIAL_Host *hst = cls;
 797
 798   hst->plc.pub_key = hack->place_pub_key;
 799
 800   int32_t result = ntohl (hack->result_code);
 801   if (NULL != hst->enter_cb)
 802     hst->enter_cb (hst->cb_cls, result, &hack->place_pub_key,
 803                    GNUNET_ntohll (hack->max_message_id));
 804 }
 805
 806
 807 static int
 808 check_host_enter_request (void *cls,
 809                           const struct GNUNET_PSYC_JoinRequestMessage *req)
 810 {
 811   return GNUNET_OK;
 812 }
 813
 814
 815 static void
 816 handle_host_enter_request (void *cls,
 817                            const struct GNUNET_PSYC_JoinRequestMessage *req)
 818 {
 819   struct GNUNET_SOCIAL_Host *hst = cls;
 820
 821   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 822               "handle_host_enter_request\n");
 823
 824   if (NULL == hst->answer_door_cb)
 825      return;
 826
 827   const char *method_name = NULL;
 828   struct GNUNET_PSYC_Environment *env = NULL;
 829   struct GNUNET_PSYC_MessageHeader *entry_pmsg = NULL;
 830   const void *data = NULL;
 831   uint16_t data_size = 0;
 832   char *str;
 833   const struct GNUNET_PSYC_Message *join_msg = NULL;
 834
 835   do
 836   {
 837     if (sizeof (*req) + sizeof (*join_msg) <= ntohs (req->header.size))
 838     {
 839       join_msg = (struct GNUNET_PSYC_Message *) GNUNET_MQ_extract_nested_mh (req);
 840       LOG (GNUNET_ERROR_TYPE_DEBUG,
 841            "Received join_msg of type %u and size %u.\n",
 842            ntohs (join_msg->header.type), ntohs (join_msg->header.size));
 843
 844       env = GNUNET_PSYC_env_create ();
 845       entry_pmsg = GNUNET_PSYC_message_header_create_from_psyc (join_msg);
 846       if (GNUNET_OK != GNUNET_PSYC_message_parse (entry_pmsg, &method_name, env,
 847                                                   &data, &data_size))
 848       {
 849         GNUNET_break_op (0);
 850         str = GNUNET_CRYPTO_ecdsa_public_key_to_string (&req->slave_pub_key);
 851         LOG (GNUNET_ERROR_TYPE_WARNING,
 852              "Ignoring invalid entry request from nym %s.\n",
 853              str);
 854         GNUNET_free (str);
 855         break;
 856       }
 857     }
 858
 859     struct GNUNET_SOCIAL_Nym *nym = nym_get_or_create (&req->slave_pub_key);
 860     hst->answer_door_cb (hst->cb_cls, nym, method_name, env,
 861                          data, data_size);
 862   } while (0);
 863
 864   if (NULL != env)
 865     GNUNET_PSYC_env_destroy (env);
 866   if (NULL != entry_pmsg)
 867     GNUNET_free (entry_pmsg);
 868 }
 869
 870
 871 static void
 872 handle_guest_enter_ack (void *cls,
 873                         const struct GNUNET_PSYC_CountersResultMessage *cres)
 874 {
 875   struct GNUNET_SOCIAL_Guest *gst = cls;
 876
 877   int32_t result = ntohl (cres->result_code);
 878   if (NULL != gst->enter_cb)
 879     gst->enter_cb (gst->cb_cls, result, &gst->plc.pub_key,
 880                    GNUNET_ntohll (cres->max_message_id));
 881 }
 882
 883
 884 static int
 885 check_guest_enter_decision (void *cls,
 886                             const struct GNUNET_PSYC_JoinDecisionMessage *dcsn)
 887 {
 888   return GNUNET_OK;
 889 }
 890
 891
 892 static void
 893 handle_guest_enter_decision (void *cls,
 894                              const struct GNUNET_PSYC_JoinDecisionMessage *dcsn)
 895 {
 896   struct GNUNET_SOCIAL_Guest *gst = cls;
 897
 898   struct GNUNET_PSYC_Message *pmsg = NULL;
 899   if (ntohs (dcsn->header.size) > sizeof (*dcsn))
 900     pmsg = (struct GNUNET_PSYC_Message *) GNUNET_MQ_extract_nested_mh (dcsn);
 901
 902   if (NULL != gst->entry_dcsn_cb)
 903     gst->entry_dcsn_cb (gst->cb_cls, ntohl (dcsn->is_admitted), pmsg);
 904 }
 905
 906
 907 static int
 908 check_app_ego (void *cls,
 909                const struct AppEgoMessage *emsg)
 910 {
 911   return GNUNET_OK;
 912 }
 913
 914
 915 static void
 916 handle_app_ego (void *cls,
 917                 const struct AppEgoMessage *emsg)
 918 {
 919   struct GNUNET_SOCIAL_App *app = cls;
 920
 921   uint16_t name_size = ntohs (emsg->header.size) - sizeof (*emsg);
 922
 923   struct GNUNET_HashCode ego_pub_hash;
 924   GNUNET_CRYPTO_hash (&emsg->ego_pub_key, sizeof (emsg->ego_pub_key),
 925                       &ego_pub_hash);
 926
 927   struct GNUNET_SOCIAL_Ego *
 928     ego = GNUNET_CONTAINER_multihashmap_get (app->egos, &ego_pub_hash);
 929   if (NULL == ego)
 930   {
 931     ego = GNUNET_malloc (sizeof (*ego));
 932     ego->pub_key = emsg->ego_pub_key;
 933     ego->name = GNUNET_malloc (name_size);
 934     GNUNET_memcpy (ego->name, &emsg[1], name_size);
 935   }
 936   else
 937   {
 938     ego->name = GNUNET_realloc (ego->name, name_size);
 939     GNUNET_memcpy (ego->name, &emsg[1], name_size);
 940   }
 941
 942   GNUNET_CONTAINER_multihashmap_put (app->egos, &ego_pub_hash, ego,
 943                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
 944
 945   if (NULL != app->ego_cb)
 946     app->ego_cb (app->cb_cls, ego, &ego->pub_key, ego->name);
 947 }
 948
 949
 950 static void
 951 handle_app_ego_end (void *cls,
 952                     const struct GNUNET_MessageHeader *msg)
 953 {
 954   //struct GNUNET_SOCIAL_App *app = cls;
 955 }
 956
 957
 958 static int
 959 check_app_place (void *cls,
 960                  const struct AppPlaceMessage *pmsg)
 961 {
 962   return GNUNET_OK;
 963 }
 964
 965
 966 static void
 967 handle_app_place (void *cls,
 968                   const struct AppPlaceMessage *pmsg)
 969 {
 970   struct GNUNET_SOCIAL_App *app = cls;
 971
 972   if ((GNUNET_YES == pmsg->is_host && NULL == app->host_cb)
 973       || (GNUNET_NO == pmsg->is_host && NULL == app->guest_cb))
 974     return;
 975
 976   struct GNUNET_HashCode ego_pub_hash;
 977   GNUNET_CRYPTO_hash (&pmsg->ego_pub_key, sizeof (pmsg->ego_pub_key),
 978                       &ego_pub_hash);
 979   struct GNUNET_SOCIAL_Ego *
 980     ego = GNUNET_CONTAINER_multihashmap_get (app->egos, &ego_pub_hash);
 981   if (NULL == ego)
 982   {
 983     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failure to obtain ego %s.\n",
 984                 GNUNET_h2s (&ego_pub_hash));
 985     GNUNET_break (0);
 986     return;
 987   }
 988
 989   if (GNUNET_YES == pmsg->is_host)
 990   {
 991     if (NULL != app->host_cb) {
 992       struct GNUNET_SOCIAL_HostConnection *hconn = GNUNET_malloc (sizeof (*hconn));
 993       hconn->app = app;
 994       hconn->plc_msg = *pmsg;
 995       app->host_cb (app->cb_cls, hconn, ego, &pmsg->place_pub_key, pmsg->place_state);
 996       GNUNET_free (hconn);
 997     }
 998   }
 999   else if (NULL != app->guest_cb)
1000   {
1001     struct GNUNET_SOCIAL_GuestConnection *gconn = GNUNET_malloc (sizeof (*gconn));
1002     gconn->app = app;
1003     gconn->plc_msg = *pmsg;
1004     app->guest_cb (app->cb_cls, gconn, ego, &pmsg->place_pub_key, pmsg->place_state);
1005     GNUNET_free (gconn);
1006   }
1007 }
1008
1009
1010 static void
1011 handle_app_place_end (void *cls,
1012                       const struct GNUNET_MessageHeader *msg)
1013 {
1014   struct GNUNET_SOCIAL_App *app = cls;
1015
1016   if (NULL != app->connected_cb)
1017     app->connected_cb (app->cb_cls);
1018 }
1019
1020
1021 /*** CLEANUP / DISCONNECT ***/
1022
1023
1024 static void
1025 host_cleanup (struct GNUNET_SOCIAL_Host *hst)
1026 {
1027   if (NULL != hst->slicer)
1028   {
1029     GNUNET_PSYC_slicer_destroy (hst->slicer);
1030     hst->slicer = NULL;
1031   }
1032   GNUNET_free (hst);
1033 }
1034
1035
1036 static void
1037 guest_cleanup (struct GNUNET_SOCIAL_Guest *gst)
1038 {
1039   GNUNET_free (gst);
1040 }
1041
1042
1043 static void
1044 place_cleanup (struct GNUNET_SOCIAL_Place *plc)
1045 {
1046   struct GNUNET_HashCode place_pub_hash;
1047   GNUNET_CRYPTO_hash (&plc->pub_key, sizeof (plc->pub_key), &place_pub_hash);
1048   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1049               "%s place cleanup: %s\n",
1050               GNUNET_YES == plc->is_host ? "host" : "guest",
1051               GNUNET_h2s (&place_pub_hash));
1052
1053   if (NULL != plc->tmit)
1054   {
1055     GNUNET_PSYC_transmit_destroy (plc->tmit);
1056     plc->tmit = NULL;
1057   }
1058   if (NULL != plc->connect_env)
1059   {
1060     GNUNET_MQ_discard (plc->connect_env);
1061     plc->connect_env = NULL;
1062   }
1063   if (NULL != plc->mq)
1064   {
1065     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1066                 "destroying MQ (place_cleanup)\n");
1067     GNUNET_MQ_destroy (plc->mq);
1068     plc->mq = NULL;
1069   }
1070   if (NULL != plc->disconnect_cb)
1071   {
1072     plc->disconnect_cb (plc->disconnect_cls);
1073     plc->disconnect_cb = NULL;
1074   }
1075
1076   (GNUNET_YES == plc->is_host)
1077     ? host_cleanup ((struct GNUNET_SOCIAL_Host *) plc)
1078     : guest_cleanup ((struct GNUNET_SOCIAL_Guest *) plc);
1079 }
1080
1081
1082 void
1083 place_disconnect (struct GNUNET_SOCIAL_Place *plc)
1084 {
1085   struct GNUNET_HashCode place_pub_hash;
1086   GNUNET_CRYPTO_hash (&plc->pub_key, sizeof (plc->pub_key), &place_pub_hash);
1087   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1088               "place_disconnect, plc = %s\n",
1089               GNUNET_h2s (&place_pub_hash));
1090   if (NULL != plc->mq)
1091   {
1092     struct GNUNET_MQ_Envelope *env = GNUNET_MQ_get_last_envelope (plc->mq);
1093     if (NULL != env)
1094     {
1095       GNUNET_MQ_notify_sent (env, (GNUNET_SCHEDULER_TaskCallback) place_cleanup, plc);
1096     }
1097     else
1098     {
1099       place_cleanup (plc);
1100     }
1101   }
1102   else
1103   {
1104     place_cleanup (plc);
1105   }
1106 }
1107
1108
1109 void
1110 place_leave (struct GNUNET_SOCIAL_Place *plc)
1111 {
1112   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1113               "social_api: place_leave\n");
1114   struct GNUNET_MessageHeader *msg;
1115   struct GNUNET_MQ_Envelope *
1116     env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_SOCIAL_PLACE_LEAVE);
1117
1118   GNUNET_MQ_send (plc->mq, env);
1119 }
1120
1121
1122 /*** HOST ***/
1123
1124
1125 static void
1126 host_connect (struct GNUNET_SOCIAL_Host *hst);
1127
1128
1129 static void
1130 host_reconnect (void *cls)
1131 {
1132   host_connect (cls);
1133 }
1134
1135
1136 /**
1137  * Host client disconnected from service.
1138  *
1139  * Reconnect after backoff period.
1140  */
1141 static void
1142 host_disconnected (void *cls, enum GNUNET_MQ_Error error)
1143 {
1144   struct GNUNET_SOCIAL_Host *hst = cls;
1145   struct GNUNET_SOCIAL_Place *plc = &hst->plc;
1146
1147   LOG (GNUNET_ERROR_TYPE_DEBUG,
1148        "Host client disconnected (%d), re-connecting\n",
1149        (int) error);
1150   if (NULL != plc->tmit)
1151   {
1152     GNUNET_PSYC_transmit_destroy (plc->tmit);
1153     plc->tmit = NULL;
1154   }
1155   if (NULL != plc->mq)
1156   {
1157     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1158                 "destroying MQ (host_disconnected)\n");
1159     GNUNET_MQ_destroy (plc->mq);
1160     plc->mq = NULL;
1161   }
1162
1163   plc->reconnect_task = GNUNET_SCHEDULER_add_delayed (plc->reconnect_delay,
1164                                                       host_reconnect,
1165                                                       hst);
1166   plc->reconnect_delay = GNUNET_TIME_STD_BACKOFF (plc->reconnect_delay);
1167 }
1168
1169
1170 static void
1171 host_connect (struct GNUNET_SOCIAL_Host *hst)
1172 {
1173   struct GNUNET_SOCIAL_Place *plc = &hst->plc;
1174
1175   struct GNUNET_MQ_MessageHandler handlers[] = {
1176     GNUNET_MQ_hd_fixed_size (host_enter_ack,
1177                              GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER_ACK,
1178                              struct HostEnterAck,
1179                              hst),
1180     GNUNET_MQ_hd_var_size (host_enter_request,
1181                            GNUNET_MESSAGE_TYPE_PSYC_JOIN_REQUEST,
1182                            struct GNUNET_PSYC_JoinRequestMessage,
1183                            hst),
1184     GNUNET_MQ_hd_var_size (host_message,
1185                            GNUNET_MESSAGE_TYPE_PSYC_MESSAGE,
1186                            struct GNUNET_PSYC_MessageHeader,
1187                            hst),
1188     GNUNET_MQ_hd_fixed_size (place_message_ack,
1189                              GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK,
1190                              struct GNUNET_MessageHeader,
1191                              plc),
1192     GNUNET_MQ_hd_var_size (place_history_result,
1193                            GNUNET_MESSAGE_TYPE_PSYC_HISTORY_RESULT,
1194                            struct GNUNET_OperationResultMessage,
1195                            plc),
1196     GNUNET_MQ_hd_var_size (place_state_result,
1197                            GNUNET_MESSAGE_TYPE_PSYC_STATE_RESULT,
1198                            struct GNUNET_OperationResultMessage,
1199                            plc),
1200     GNUNET_MQ_hd_var_size (place_result,
1201                            GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE,
1202                            struct GNUNET_OperationResultMessage,
1203                            plc),
1204     GNUNET_MQ_handler_end ()
1205   };
1206
1207   plc->mq = GNUNET_CLIENT_connect (plc->cfg, "social",
1208                                    handlers, host_disconnected, hst);
1209   GNUNET_assert (NULL != plc->mq);
1210   plc->tmit = GNUNET_PSYC_transmit_create (plc->mq);
1211
1212   GNUNET_MQ_send_copy (plc->mq, plc->connect_env);
1213 }
1214
1215
1216 /**
1217  * Enter a place as host.
1218  *
1219  * A place is created upon first entering, and it is active until permanently
1220  * left using GNUNET_SOCIAL_host_leave().
1221  *
1222  * @param app
1223  *        Application handle.
1224  * @param ego
1225  *        Identity of the host.
1226  * @param policy
1227  *        Policy specifying entry and history restrictions for the place.
1228  * @param slicer
1229  *        Slicer to handle incoming messages.
1230  * @param enter_cb
1231  *        Function called when the place is entered and ready to use.
1232  * @param answer_door_cb
1233  *        Function to handle new nyms that want to enter.
1234  * @param farewell_cb
1235  *        Function to handle departing nyms.
1236  * @param cls
1237  *        Closure for the callbacks.
1238  *
1239  * @return Handle for the host. This handle contains the pubkey.
1240  */
1241 struct GNUNET_SOCIAL_Host *
1242 GNUNET_SOCIAL_host_enter (const struct GNUNET_SOCIAL_App *app,
1243                           const struct GNUNET_SOCIAL_Ego *ego,
1244                           enum GNUNET_PSYC_Policy policy,
1245                           struct GNUNET_PSYC_Slicer *slicer,
1246                           GNUNET_SOCIAL_HostEnterCallback enter_cb,
1247                           GNUNET_SOCIAL_AnswerDoorCallback answer_door_cb,
1248                           GNUNET_SOCIAL_FarewellCallback farewell_cb,
1249                           void *cls)
1250 {
1251   struct GNUNET_SOCIAL_Host *hst = GNUNET_malloc (sizeof (*hst));
1252   struct GNUNET_SOCIAL_Place *plc = &hst->plc;
1253
1254   plc->cfg = app->cfg;
1255   plc->is_host = GNUNET_YES;
1256   plc->slicer = slicer;
1257
1258   hst->enter_cb = enter_cb;
1259   hst->answer_door_cb = answer_door_cb;
1260   hst->farewell_cb = farewell_cb;
1261   hst->cb_cls = cls;
1262
1263   plc->op = GNUNET_OP_create ();
1264
1265   hst->slicer = GNUNET_PSYC_slicer_create ();
1266   GNUNET_PSYC_slicer_method_add (hst->slicer, "_notice_place_leave", NULL,
1267                                  host_recv_notice_place_leave_method,
1268                                  host_recv_notice_place_leave_modifier,
1269                                  NULL, host_recv_notice_place_leave_eom, hst);
1270
1271   uint16_t app_id_size = strlen (app->id) + 1;
1272   struct HostEnterRequest *hreq;
1273   plc->connect_env = GNUNET_MQ_msg_extra (hreq, app_id_size,
1274                                           GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER);
1275   hreq->policy = policy;
1276   hreq->ego_pub_key = ego->pub_key;
1277   GNUNET_memcpy (&hreq[1], app->id, app_id_size);
1278
1279   host_connect (hst);
1280   return hst;
1281 }
1282
1283
1284 /**
1285  * Reconnect to an already entered place as host.
1286  *
1287  * @param hconn
1288  *        Host connection handle.
1289  *        @see GNUNET_SOCIAL_app_connect() & GNUNET_SOCIAL_AppHostPlaceCallback()
1290  * @param slicer
1291  *        Slicer to handle incoming messages.
1292  * @param enter_cb
1293  *        Function called when the place is entered and ready to use.
1294  * @param answer_door_cb
1295  *        Function to handle new nyms that want to enter.
1296  * @param farewell_cb
1297  *        Function to handle departing nyms.
1298  * @param cls
1299  *        Closure for the callbacks.
1300  *
1301  * @return Handle for the host.
1302  */
1303  struct GNUNET_SOCIAL_Host *
1304 GNUNET_SOCIAL_host_enter_reconnect (struct GNUNET_SOCIAL_HostConnection *hconn,
1305                                     struct GNUNET_PSYC_Slicer *slicer,
1306                                     GNUNET_SOCIAL_HostEnterCallback enter_cb,
1307                                     GNUNET_SOCIAL_AnswerDoorCallback answer_door_cb,
1308                                     GNUNET_SOCIAL_FarewellCallback farewell_cb,
1309                                     void *cls)
1310 {
1311   struct GNUNET_SOCIAL_Host *hst = GNUNET_malloc (sizeof (*hst));
1312   struct GNUNET_SOCIAL_Place *plc = &hst->plc;
1313
1314   hst->enter_cb = enter_cb;
1315   hst->answer_door_cb = answer_door_cb;
1316   hst->farewell_cb = farewell_cb;
1317   hst->cb_cls = cls;
1318
1319   plc->cfg = hconn->app->cfg;
1320   plc->is_host = GNUNET_YES;
1321   plc->slicer = slicer;
1322   plc->pub_key = hconn->plc_msg.place_pub_key;
1323   plc->ego_pub_key = hconn->plc_msg.ego_pub_key;
1324
1325   plc->op = GNUNET_OP_create ();
1326
1327   hst->slicer = GNUNET_PSYC_slicer_create ();
1328   GNUNET_PSYC_slicer_method_add (hst->slicer, "_notice_place_leave", NULL,
1329                                  host_recv_notice_place_leave_method,
1330                                  host_recv_notice_place_leave_modifier,
1331                                  NULL, host_recv_notice_place_leave_eom, hst);
1332
1333   size_t app_id_size = strlen (hconn->app->id) + 1;
1334   struct HostEnterRequest *hreq;
1335   plc->connect_env = GNUNET_MQ_msg_extra (hreq, app_id_size,
1336                                           GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER);
1337   hreq->place_pub_key = hconn->plc_msg.place_pub_key;
1338   hreq->ego_pub_key = hconn->plc_msg.ego_pub_key;
1339   GNUNET_memcpy (&hreq[1], hconn->app->id, app_id_size);
1340
1341   host_connect (hst);
1342   return hst;
1343 }
1344
1345
1346 /**
1347  * Decision whether to admit @a nym into the place or refuse entry.
1348  *
1349  * @param hst
1350  *        Host of the place.
1351  * @param nym
1352  *        Handle for the entity that wanted to enter.
1353  * @param is_admitted
1354  *        #GNUNET_YES    if @a nym is admitted,
1355  *        #GNUNET_NO     if @a nym is refused entry,
1356  *        #GNUNET_SYSERR if we cannot answer the request.
1357  * @param method_name
1358  *        Method name for the rejection message.
1359  * @param env
1360  *        Environment containing variables for the message, or NULL.
1361  * @param data
1362  *        Data for the rejection message to send back.
1363  * @param data_size
1364  *        Number of bytes in @a data for method.
1365  * @return #GNUNET_OK on success,
1366  *         #GNUNET_SYSERR if the message is too large.
1367  */
1368 int
1369 GNUNET_SOCIAL_host_entry_decision (struct GNUNET_SOCIAL_Host *hst,
1370                                    struct GNUNET_SOCIAL_Nym *nym,
1371                                    int is_admitted,
1372                                    const struct GNUNET_PSYC_Message *entry_resp)
1373 {
1374   struct GNUNET_SOCIAL_Place *plc = &hst->plc;
1375   struct GNUNET_PSYC_JoinDecisionMessage *dcsn;
1376   uint16_t entry_resp_size
1377     = (NULL != entry_resp) ? ntohs (entry_resp->header.size) : 0;
1378
1379   if (GNUNET_MULTICAST_FRAGMENT_MAX_PAYLOAD < sizeof (*dcsn) + entry_resp_size)
1380     return GNUNET_SYSERR;
1381
1382   struct GNUNET_MQ_Envelope *
1383     env = GNUNET_MQ_msg_extra (dcsn, entry_resp_size,
1384                                GNUNET_MESSAGE_TYPE_PSYC_JOIN_DECISION);
1385   dcsn->is_admitted = htonl (is_admitted);
1386   dcsn->slave_pub_key = nym->pub_key;
1387
1388   if (0 < entry_resp_size)
1389     GNUNET_memcpy (&dcsn[1], entry_resp, entry_resp_size);
1390
1391   GNUNET_MQ_send (plc->mq, env);
1392   return GNUNET_OK;
1393 }
1394
1395
1396 /**
1397  * Throw @a nym out of the place.
1398  *
1399  * The @a nym reference will remain valid until the
1400  * #GNUNET_SOCIAL_FarewellCallback is invoked,
1401  * which should be very soon after this call.
1402  *
1403  * @param host
1404  *        Host of the place.
1405  * @param nym
1406  *        Handle for the entity to be ejected.
1407  * @param env
1408  *        Environment for the message or NULL.
1409  */
1410 void
1411 GNUNET_SOCIAL_host_eject (struct GNUNET_SOCIAL_Host *hst,
1412                           const struct GNUNET_SOCIAL_Nym *nym,
1413                           struct GNUNET_PSYC_Environment *e)
1414 {
1415   struct GNUNET_PSYC_Environment *env = e;
1416   if (NULL == env)
1417     env = GNUNET_PSYC_env_create ();
1418   GNUNET_PSYC_env_add (env, GNUNET_PSYC_OP_SET,
1419                        "_nym", &nym->pub_key, sizeof (nym->pub_key));
1420   GNUNET_SOCIAL_host_announce (hst, "_notice_place_leave", env, NULL, NULL,
1421                                GNUNET_SOCIAL_ANNOUNCE_NONE);
1422   if (NULL == e)
1423     GNUNET_PSYC_env_destroy (env);
1424 }
1425
1426
1427 /**
1428  * Get the public key of @a ego.
1429  *
1430  * @param ego
1431  *        Ego.
1432  *
1433  * @return Public key of ego.
1434  */
1435 const struct GNUNET_CRYPTO_EcdsaPublicKey *
1436 GNUNET_SOCIAL_ego_get_pub_key (const struct GNUNET_SOCIAL_Ego *ego)
1437 {
1438   return &ego->pub_key;
1439 }
1440
1441
1442 /**
1443  * Get the hash of the public key of @a ego.
1444  *
1445  * @param ego
1446  *        Ego.
1447  *
1448  * @return Hash of the public key of @a ego.
1449  */
1450 const struct GNUNET_HashCode *
1451 GNUNET_SOCIAL_ego_get_pub_key_hash (const struct GNUNET_SOCIAL_Ego *ego)
1452 {
1453   return &ego->pub_key_hash;
1454 }
1455
1456
1457 /**
1458  * Get the name of @a ego.
1459  *
1460  * @param ego
1461  *        Ego.
1462  *
1463  * @return Public key of @a ego.
1464  */
1465 const char *
1466 GNUNET_SOCIAL_ego_get_name (const struct GNUNET_SOCIAL_Ego *ego)
1467 {
1468   return ego->name;
1469 }
1470
1471
1472 /**
1473  * Get the public key of @a nym.
1474  *
1475  * Suitable, for example, to be used with GNUNET_SOCIAL_zone_add_nym().
1476  *
1477  * @param nym
1478  *        Pseudonym.
1479  *
1480  * @return Public key of @a nym.
1481  */
1482 const struct GNUNET_CRYPTO_EcdsaPublicKey *
1483 GNUNET_SOCIAL_nym_get_pub_key (const struct GNUNET_SOCIAL_Nym *nym)
1484 {
1485   return &nym->pub_key;
1486 }
1487
1488
1489 /**
1490  * Get the hash of the public key of @a nym.
1491  *
1492  * @param nym
1493  *        Pseudonym.
1494  *
1495  * @return Hash of the public key of @a nym.
1496  */
1497 const struct GNUNET_HashCode *
1498 GNUNET_SOCIAL_nym_get_pub_key_hash (const struct GNUNET_SOCIAL_Nym *nym)
1499 {
1500   return &nym->pub_key_hash;
1501 }
1502
1503
1504 /**
1505  * Send a message to all nyms that are present in the place.
1506  *
1507  * This function is restricted to the host.  Nyms can only send requests
1508  * to the host who can decide to relay it to everyone in the place.
1509  *
1510  * @param host  Host of the place.
1511  * @param method_name Method to use for the announcement.
1512  * @param env  Environment containing variables for the message and operations
1513  *          on objects of the place.  Can be NULL.
1514  * @param notify Function to call to get the payload of the announcement.
1515  * @param notify_cls Closure for @a notify.
1516  * @param flags Flags for this announcement.
1517  *
1518  * @return NULL on error (announcement already in progress?).
1519  */
1520 struct GNUNET_SOCIAL_Announcement *
1521 GNUNET_SOCIAL_host_announce (struct GNUNET_SOCIAL_Host *hst,
1522                              const char *method_name,
1523                              const struct GNUNET_PSYC_Environment *env,
1524                              GNUNET_PSYC_TransmitNotifyData notify_data,
1525                              void *notify_data_cls,
1526                              enum GNUNET_SOCIAL_AnnounceFlags flags)
1527 {
1528   if (GNUNET_OK ==
1529       GNUNET_PSYC_transmit_message (hst->plc.tmit, method_name, env,
1530                                     NULL, notify_data, notify_data_cls, flags))
1531     return (struct GNUNET_SOCIAL_Announcement *) hst->plc.tmit;
1532   else
1533     return NULL;
1534 }
1535
1536
1537 /**
1538  * Resume transmitting announcement.
1539  *
1540  * @param a
1541  *        The announcement to resume.
1542  */
1543 void
1544 GNUNET_SOCIAL_host_announce_resume (struct GNUNET_SOCIAL_Announcement *a)
1545 {
1546   GNUNET_PSYC_transmit_resume ((struct GNUNET_PSYC_TransmitHandle *) a);
1547 }
1548
1549
1550 /**
1551  * Cancel announcement.
1552  *
1553  * @param a
1554  *        The announcement to cancel.
1555  */
1556 void
1557 GNUNET_SOCIAL_host_announce_cancel (struct GNUNET_SOCIAL_Announcement *a)
1558 {
1559   GNUNET_PSYC_transmit_cancel ((struct GNUNET_PSYC_TransmitHandle *) a);
1560 }
1561
1562
1563 /**
1564  * Obtain handle for a hosted place.
1565  *
1566  * The returned handle can be used to access the place API.
1567  *
1568  * @param host  Handle for the host.
1569  *
1570  * @return Handle for the hosted place, valid as long as @a host is valid.
1571  */
1572 struct GNUNET_SOCIAL_Place *
1573 GNUNET_SOCIAL_host_get_place (struct GNUNET_SOCIAL_Host *hst)
1574 {
1575   return &hst->plc;
1576 }
1577
1578
1579 /**
1580  * Disconnect from a home.
1581  *
1582  * Invalidates host handle.
1583  *
1584  * @param hst
1585  *        The host to disconnect.
1586  */
1587 void
1588 GNUNET_SOCIAL_host_disconnect (struct GNUNET_SOCIAL_Host *hst,
1589                                GNUNET_ContinuationCallback disconnect_cb,
1590                                void *cls)
1591 {
1592   struct GNUNET_SOCIAL_Place *plc = &hst->plc;
1593
1594   plc->disconnect_cb = disconnect_cb;
1595   plc->disconnect_cls = cls;
1596   place_disconnect (plc);
1597 }
1598
1599
1600 /**
1601  * Stop hosting the home.
1602  *
1603  * Sends a _notice_place_closing announcement to the home.
1604  * Invalidates host handle.
1605  *
1606  * @param hst
1607  *        The host leaving.
1608  * @param env
1609  *        Environment for the message or NULL.
1610  *        _nym is set to @e nym regardless whether an @e env is provided.
1611  * @param disconnect_cb
1612  *        Function called after the host left the place
1613  *        and disconnected from the social service.
1614  * @param cls
1615  *        Closure for @a disconnect_cb.
1616  */
1617 void
1618 GNUNET_SOCIAL_host_leave (struct GNUNET_SOCIAL_Host *hst,
1619                           const struct GNUNET_PSYC_Environment *env,
1620                           GNUNET_ContinuationCallback disconnect_cb,
1621                           void *cls)
1622 {
1623   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1624               "GNUNET_SOCIAL_host_leave\n");
1625   GNUNET_SOCIAL_host_announce (hst, "_notice_place_closing", env, NULL, NULL,
1626                                GNUNET_SOCIAL_ANNOUNCE_NONE);
1627   place_leave (&hst->plc);
1628   GNUNET_SOCIAL_host_disconnect (hst, disconnect_cb, cls);
1629 }
1630
1631
1632 /*** GUEST ***/
1633
1634
1635 static void
1636 guest_connect (struct GNUNET_SOCIAL_Guest *gst);
1637
1638
1639 static void
1640 guest_reconnect (void *cls)
1641 {
1642   guest_connect (cls);
1643 }
1644
1645
1646 /**
1647  * Guest client disconnected from service.
1648  *
1649  * Reconnect after backoff period.
1650  */
1651 static void
1652 guest_disconnected (void *cls, enum GNUNET_MQ_Error error)
1653 {
1654   struct GNUNET_SOCIAL_Guest *gst = cls;
1655   struct GNUNET_SOCIAL_Place *plc = &gst->plc;
1656
1657   LOG (GNUNET_ERROR_TYPE_DEBUG,
1658        "Guest client disconnected (%d), re-connecting\n",
1659        (int) error);
1660   if (NULL != plc->tmit)
1661   {
1662     GNUNET_PSYC_transmit_destroy (plc->tmit);
1663     plc->tmit = NULL;
1664   }
1665   if (NULL != plc->mq)
1666   {
1667     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1668                 "destroying MQ (guest_disconnected)\n");
1669     GNUNET_MQ_destroy (plc->mq);
1670     plc->mq = NULL;
1671   }
1672
1673   plc->reconnect_task = GNUNET_SCHEDULER_add_delayed (plc->reconnect_delay,
1674                                                       guest_reconnect,
1675                                                       gst);
1676   plc->reconnect_delay = GNUNET_TIME_STD_BACKOFF (plc->reconnect_delay);
1677 }
1678
1679
1680 static void
1681 guest_connect (struct GNUNET_SOCIAL_Guest *gst)
1682 {
1683   struct GNUNET_SOCIAL_Place *plc = &gst->plc;
1684
1685   struct GNUNET_MQ_MessageHandler handlers[] = {
1686     GNUNET_MQ_hd_fixed_size (guest_enter_ack,
1687                              GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_ACK,
1688                              struct GNUNET_PSYC_CountersResultMessage,
1689                              gst),
1690     GNUNET_MQ_hd_var_size (guest_enter_decision,
1691                            GNUNET_MESSAGE_TYPE_PSYC_JOIN_DECISION,
1692                            struct GNUNET_PSYC_JoinDecisionMessage,
1693                            gst),
1694     GNUNET_MQ_hd_var_size (place_message,
1695                            GNUNET_MESSAGE_TYPE_PSYC_MESSAGE,
1696                            struct GNUNET_PSYC_MessageHeader,
1697                            plc),
1698     GNUNET_MQ_hd_fixed_size (place_message_ack,
1699                              GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK,
1700                              struct GNUNET_MessageHeader,
1701                              plc),
1702     GNUNET_MQ_hd_var_size (place_history_result,
1703                            GNUNET_MESSAGE_TYPE_PSYC_HISTORY_RESULT,
1704                            struct GNUNET_OperationResultMessage,
1705                            plc),
1706     GNUNET_MQ_hd_var_size (place_state_result,
1707                            GNUNET_MESSAGE_TYPE_PSYC_STATE_RESULT,
1708                            struct GNUNET_OperationResultMessage,
1709                            plc),
1710     GNUNET_MQ_hd_var_size (place_result,
1711                            GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE,
1712                            struct GNUNET_OperationResultMessage,
1713                            plc),
1714     GNUNET_MQ_handler_end ()
1715   };
1716
1717   plc->mq = GNUNET_CLIENT_connect (plc->cfg, "social",
1718                                    handlers, guest_disconnected, gst);
1719   GNUNET_assert (NULL != plc->mq);
1720   plc->tmit = GNUNET_PSYC_transmit_create (plc->mq);
1721
1722   GNUNET_MQ_send_copy (plc->mq, plc->connect_env);
1723 }
1724
1725
1726 static struct GNUNET_MQ_Envelope *
1727 guest_enter_request_create (const char *app_id,
1728                             const struct GNUNET_CRYPTO_EcdsaPublicKey *ego_pub_key,
1729                             const struct GNUNET_CRYPTO_EddsaPublicKey *place_pub_key,
1730                             const struct GNUNET_PeerIdentity *origin,
1731                             size_t relay_count,
1732                             const struct GNUNET_PeerIdentity *relays,
1733                             const struct GNUNET_PSYC_Message *join_msg)
1734 {
1735   uint16_t app_id_size = strlen (app_id) + 1;
1736   uint16_t join_msg_size = ntohs (join_msg->header.size);
1737   uint16_t relay_size = relay_count * sizeof (*relays);
1738
1739   struct GuestEnterRequest *greq;
1740   struct GNUNET_MQ_Envelope *
1741     env = GNUNET_MQ_msg_extra (greq, app_id_size + relay_size + join_msg_size,
1742                                GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER);
1743   greq->place_pub_key = *place_pub_key;
1744   greq->ego_pub_key = *ego_pub_key;
1745   greq->origin = *origin;
1746   greq->relay_count = htonl (relay_count);
1747
1748   char *p = (char *) &greq[1];
1749   GNUNET_memcpy (p, app_id, app_id_size);
1750   p += app_id_size;
1751
1752   if (0 < relay_size)
1753   {
1754     GNUNET_memcpy (p, relays, relay_size);
1755     p += relay_size;
1756   }
1757
1758   GNUNET_memcpy (p, join_msg, join_msg_size);
1759   return env;
1760 }
1761
1762
1763 /**
1764  * Request entry to a place as a guest.
1765  *
1766  * @param app
1767  *        Application handle.
1768  * @param ego
1769  *        Identity of the guest.
1770  * @param place_pub_key
1771  *        Public key of the place to enter.
1772  * @param flags
1773  *        Flags for the entry.
1774  * @param origin
1775  *        Peer identity of the origin of the underlying multicast group.
1776  * @param relay_count
1777  *        Number of elements in the @a relays array.
1778  * @param relays
1779  *        Relays for the underlying multicast group.
1780  * @param method_name
1781  *        Method name for the message.
1782  * @param env
1783  *        Environment containing variables for the message, or NULL.
1784  * @param data
1785  *        Payload for the message to give to the enter callback.
1786  * @param data_size
1787  *        Number of bytes in @a data.
1788  * @param slicer
1789  *        Slicer to use for processing incoming requests from guests.
1790  *
1791  * @return NULL on errors, otherwise handle for the guest.
1792  */
1793 struct GNUNET_SOCIAL_Guest *
1794 GNUNET_SOCIAL_guest_enter (const struct GNUNET_SOCIAL_App *app,
1795                            const struct GNUNET_SOCIAL_Ego *ego,
1796                            const struct GNUNET_CRYPTO_EddsaPublicKey *place_pub_key,
1797                            enum GNUNET_PSYC_SlaveJoinFlags flags,
1798                            const struct GNUNET_PeerIdentity *origin,
1799                            uint32_t relay_count,
1800                            const struct GNUNET_PeerIdentity *relays,
1801                            const struct GNUNET_PSYC_Message *entry_msg,
1802                            struct GNUNET_PSYC_Slicer *slicer,
1803                            GNUNET_SOCIAL_GuestEnterCallback local_enter_cb,
1804                            GNUNET_SOCIAL_EntryDecisionCallback entry_dcsn_cb,
1805                            void *cls)
1806 {
1807   struct GNUNET_SOCIAL_Guest *gst = GNUNET_malloc (sizeof (*gst));
1808   struct GNUNET_SOCIAL_Place *plc = &gst->plc;
1809
1810   plc->ego_pub_key = ego->pub_key;
1811   plc->pub_key = *place_pub_key;
1812   plc->cfg = app->cfg;
1813   plc->is_host = GNUNET_NO;
1814   plc->slicer = slicer;
1815
1816   plc->op = GNUNET_OP_create ();
1817
1818   plc->connect_env
1819     = guest_enter_request_create (app->id, &ego->pub_key, &plc->pub_key,
1820                                   origin, relay_count, relays, entry_msg);
1821
1822   gst->enter_cb = local_enter_cb;
1823   gst->entry_dcsn_cb = entry_dcsn_cb;
1824   gst->cb_cls = cls;
1825
1826   guest_connect (gst);
1827   return gst;
1828 }
1829
1830
1831 /**
1832  * Request entry to a place by name as a guest.
1833  *
1834  * @param app
1835  *        Application handle.
1836  * @param ego
1837  *        Identity of the guest.
1838  * @param gns_name
1839  *        GNS name of the place to enter.  Either in the form of
1840  *        'room.friend.gnu', or 'NYMPUBKEY.zkey'.  This latter case refers to
1841  *        the 'PLACE' record of the empty label ("+") in the GNS zone with the
1842  *        nym's public key 'NYMPUBKEY', and can be used to request entry to a
1843  *        pseudonym's place directly.
1844  * @param password
1845  *        Password to decrypt the record, or NULL for cleartext records.
1846  * @param join_msg
1847  *        Entry request message or NULL.
1848  * @param slicer
1849  *        Slicer to use for processing incoming requests from guests.
1850  * @param local_enter_cb
1851  *        Called upon connection established to the social service.
1852  * @param entry_decision_cb
1853  *        Called upon receiving entry decision.
1854  *
1855  * @return NULL on errors, otherwise handle for the guest.
1856  */
1857 struct GNUNET_SOCIAL_Guest *
1858 GNUNET_SOCIAL_guest_enter_by_name (const struct GNUNET_SOCIAL_App *app,
1859                                    const struct GNUNET_SOCIAL_Ego *ego,
1860                                    const char *gns_name,
1861                                    const char *password,
1862                                    const struct GNUNET_PSYC_Message *join_msg,
1863                                    struct GNUNET_PSYC_Slicer *slicer,
1864                                    GNUNET_SOCIAL_GuestEnterCallback local_enter_cb,
1865                                    GNUNET_SOCIAL_EntryDecisionCallback entry_decision_cb,
1866                                    void *cls)
1867 {
1868   struct GNUNET_SOCIAL_Guest *gst = GNUNET_malloc (sizeof (*gst));
1869   struct GNUNET_SOCIAL_Place *plc = &gst->plc;
1870
1871   if (NULL == password)
1872     password = "";
1873
1874   uint16_t app_id_size = strlen (app->id) + 1;
1875   uint16_t gns_name_size = strlen (gns_name) + 1;
1876   uint16_t password_size = strlen (password) + 1;
1877
1878   uint16_t join_msg_size = 0;
1879   if (NULL != join_msg)
1880     join_msg_size = ntohs (join_msg->header.size);
1881
1882   struct GuestEnterByNameRequest *greq;
1883   plc->connect_env
1884     = GNUNET_MQ_msg_extra (greq, app_id_size + gns_name_size
1885                            + password_size + join_msg_size,
1886                            GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_BY_NAME);
1887
1888   greq->ego_pub_key = ego->pub_key;
1889
1890   char *p = (char *) &greq[1];
1891   GNUNET_memcpy (p, app->id, app_id_size);
1892   p += app_id_size;
1893   GNUNET_memcpy (p, gns_name, gns_name_size);
1894   p += gns_name_size;
1895   GNUNET_memcpy (p, password, password_size);
1896   p += password_size;
1897   if (NULL != join_msg)
1898     GNUNET_memcpy (p, join_msg, join_msg_size);
1899
1900   plc->ego_pub_key = ego->pub_key;
1901   plc->cfg = app->cfg;
1902   plc->is_host = GNUNET_NO;
1903   plc->slicer = slicer;
1904
1905   plc->op = GNUNET_OP_create ();
1906
1907   gst->enter_cb = local_enter_cb;
1908   gst->entry_dcsn_cb = entry_decision_cb;
1909   gst->cb_cls = cls;
1910
1911   guest_connect (gst);
1912   return gst;
1913 }
1914
1915
1916 /**
1917  * Reconnect to an already entered place as guest.
1918  *
1919  * @param gconn
1920  *        Guest connection handle.
1921  *        @see GNUNET_SOCIAL_app_connect() & GNUNET_SOCIAL_AppGuestPlaceCallback()
1922  * @param flags
1923  *        Flags for the entry.
1924  * @param slicer
1925  *        Slicer to use for processing incoming requests from guests.
1926  * @param local_enter_cb
1927  *        Called upon connection established to the social service.
1928  * @param entry_decision_cb
1929  *        Called upon receiving entry decision.
1930  *
1931  * @return NULL on errors, otherwise handle for the guest.
1932  */
1933 struct GNUNET_SOCIAL_Guest *
1934 GNUNET_SOCIAL_guest_enter_reconnect (struct GNUNET_SOCIAL_GuestConnection *gconn,
1935                                      enum GNUNET_PSYC_SlaveJoinFlags flags,
1936                                      struct GNUNET_PSYC_Slicer *slicer,
1937                                      GNUNET_SOCIAL_GuestEnterCallback local_enter_cb,
1938                                      void *cls)
1939 {
1940   struct GNUNET_SOCIAL_Guest *gst = GNUNET_malloc (sizeof (*gst));
1941   struct GNUNET_SOCIAL_Place *plc = &gst->plc;
1942
1943   uint16_t app_id_size = strlen (gconn->app->id) + 1;
1944   struct GuestEnterRequest *greq;
1945   plc->connect_env
1946     = GNUNET_MQ_msg_extra (greq, app_id_size,
1947                            GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER);
1948   greq->ego_pub_key = gconn->plc_msg.ego_pub_key;
1949   greq->place_pub_key = gconn->plc_msg.place_pub_key;
1950   greq->flags = htonl (flags);
1951
1952   GNUNET_memcpy (&greq[1], gconn->app->id, app_id_size);
1953
1954   plc->cfg = gconn->app->cfg;
1955   plc->is_host = GNUNET_NO;
1956   plc->slicer = slicer;
1957   plc->pub_key = gconn->plc_msg.place_pub_key;
1958   plc->ego_pub_key = gconn->plc_msg.ego_pub_key;
1959
1960   plc->op = GNUNET_OP_create ();
1961
1962   gst->enter_cb = local_enter_cb;
1963   gst->cb_cls = cls;
1964
1965   guest_connect (gst);
1966   return gst;
1967 }
1968
1969
1970 /**
1971  * Talk to the host of the place.
1972  *
1973  * @param place
1974  *        Place where we want to talk to the host.
1975  * @param method_name
1976  *        Method to invoke on the host.
1977  * @param env
1978  *        Environment containing variables for the message, or NULL.
1979  * @param notify_data
1980  *        Function to use to get the payload for the method.
1981  * @param notify_data_cls
1982  *        Closure for @a notify_data.
1983  * @param flags
1984  *        Flags for the message being sent.
1985  *
1986  * @return NULL if we are already trying to talk to the host,
1987  *         otherwise handle to cancel the request.
1988  */
1989 struct GNUNET_SOCIAL_TalkRequest *
1990 GNUNET_SOCIAL_guest_talk (struct GNUNET_SOCIAL_Guest *gst,
1991                           const char *method_name,
1992                           const struct GNUNET_PSYC_Environment *env,
1993                           GNUNET_PSYC_TransmitNotifyData notify_data,
1994                           void *notify_data_cls,
1995                           enum GNUNET_SOCIAL_TalkFlags flags)
1996 {
1997   struct GNUNET_SOCIAL_Place *plc = &gst->plc;
1998   GNUNET_assert (NULL != plc->tmit);
1999
2000   if (GNUNET_OK ==
2001       GNUNET_PSYC_transmit_message (plc->tmit, method_name, env,
2002                                     NULL, notify_data, notify_data_cls, flags))
2003     return (struct GNUNET_SOCIAL_TalkRequest *) plc->tmit;
2004   else
2005     return NULL;
2006 }
2007
2008
2009 /**
2010  * Resume talking to the host of the place.
2011  *
2012  * @param tr
2013  *        Talk request to resume.
2014  */
2015 void
2016 GNUNET_SOCIAL_guest_talk_resume (struct GNUNET_SOCIAL_TalkRequest *tr)
2017 {
2018   GNUNET_PSYC_transmit_resume ((struct GNUNET_PSYC_TransmitHandle *) tr);
2019 }
2020
2021
2022 /**
2023  * Cancel talking to the host of the place.
2024  *
2025  * @param tr
2026  *        Talk request to cancel.
2027  */
2028 void
2029 GNUNET_SOCIAL_guest_talk_cancel (struct GNUNET_SOCIAL_TalkRequest *tr)
2030 {
2031   GNUNET_PSYC_transmit_cancel ( (struct GNUNET_PSYC_TransmitHandle *) tr);
2032 }
2033
2034
2035 /**
2036  * Disconnect from a place.
2037  *
2038  * Invalidates guest handle.
2039  *
2040  * @param gst
2041  *        The guest to disconnect.
2042  */
2043 void
2044 GNUNET_SOCIAL_guest_disconnect (struct GNUNET_SOCIAL_Guest *gst,
2045                                 GNUNET_ContinuationCallback disconnect_cb,
2046                                 void *cls)
2047 {
2048   struct GNUNET_SOCIAL_Place *plc = &gst->plc;
2049
2050   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2051               "GNUNET_SOCIAL_guest_disconnect, gst = %p\n",
2052               gst);
2053   plc->disconnect_cb = disconnect_cb;
2054   plc->disconnect_cls = cls;
2055   place_disconnect (plc);
2056 }
2057
2058
2059 /**
2060  * Leave a place temporarily or permanently.
2061  *
2062  * Notifies the owner of the place about leaving, and destroys the place handle.
2063  *
2064  * @param place
2065  *        Place to leave.
2066  * @param keep_active
2067  *        Keep place active after last application disconnected.
2068  *        #GNUNET_YES or #GNUNET_NO
2069  * @param env
2070  *        Optional environment for the leave message if @a keep_active
2071  *        is #GNUNET_NO.  NULL if not needed.
2072  * @param leave_cb
2073  *        Called upon disconnecting from the social service.
2074  */
2075 void
2076 GNUNET_SOCIAL_guest_leave (struct GNUNET_SOCIAL_Guest *gst,
2077                            struct GNUNET_PSYC_Environment *env,
2078                            GNUNET_ContinuationCallback disconnect_cb,
2079                            void *cls)
2080 {
2081   GNUNET_SOCIAL_guest_talk (gst, "_notice_place_leave", env, NULL, NULL,
2082                             GNUNET_SOCIAL_TALK_NONE);
2083   place_leave (&gst->plc);
2084   GNUNET_SOCIAL_guest_disconnect (gst, disconnect_cb, cls);
2085 }
2086
2087
2088 /**
2089  * Obtain handle for a place entered as guest.
2090  *
2091  * The returned handle can be used to access the place API.
2092  *
2093  * @param guest  Handle for the guest.
2094  *
2095  * @return Handle for the place, valid as long as @a guest is valid.
2096  */
2097 struct GNUNET_SOCIAL_Place *
2098 GNUNET_SOCIAL_guest_get_place (struct GNUNET_SOCIAL_Guest *gst)
2099 {
2100   return &gst->plc;
2101 }
2102
2103
2104 /**
2105  * Obtain the public key of a place.
2106  *
2107  * @param plc
2108  *        Place.
2109  *
2110  * @return Public key of the place.
2111  */
2112 const struct GNUNET_CRYPTO_EddsaPublicKey *
2113 GNUNET_SOCIAL_place_get_pub_key (const struct GNUNET_SOCIAL_Place *plc)
2114 {
2115   return &plc->pub_key;
2116 }
2117
2118
2119 /**
2120  * Set message processing @a flags for a @a method_prefix.
2121  *
2122  * @param plc
2123  *        Place.
2124  * @param method_prefix
2125  *        Method prefix @a flags apply to.
2126  * @param flags
2127  *        The flags that apply to a matching @a method_prefix.
2128  */
2129 void
2130 GNUNET_SOCIAL_place_msg_proc_set (struct GNUNET_SOCIAL_Place *plc,
2131                                   const char *method_prefix,
2132                                   enum GNUNET_SOCIAL_MsgProcFlags flags)
2133 {
2134   GNUNET_assert (NULL != method_prefix);
2135   struct MsgProcRequest *mpreq;
2136   uint16_t method_size = strnlen (method_prefix,
2137                                   GNUNET_MAX_MESSAGE_SIZE
2138                                   - sizeof (*mpreq)) + 1;
2139   GNUNET_assert ('\0' == method_prefix[method_size - 1]);
2140
2141   struct GNUNET_MQ_Envelope *
2142     env = GNUNET_MQ_msg_extra (mpreq, method_size,
2143                                GNUNET_MESSAGE_TYPE_SOCIAL_MSG_PROC_SET);
2144   mpreq->flags = htonl (flags);
2145   GNUNET_memcpy (&mpreq[1], method_prefix, method_size);
2146
2147   GNUNET_MQ_send (plc->mq, env);
2148 }
2149
2150
2151 /**
2152  * Clear all message processing flags previously set for this place.
2153  */
2154 void
2155 GNUNET_SOCIAL_place_msg_proc_clear (struct GNUNET_SOCIAL_Place *plc)
2156 {
2157   struct GNUNET_MessageHeader *req;
2158   struct GNUNET_MQ_Envelope *
2159     env = GNUNET_MQ_msg (req, GNUNET_MESSAGE_TYPE_SOCIAL_MSG_PROC_CLEAR);
2160
2161   GNUNET_MQ_send (plc->mq, env);
2162 }
2163
2164
2165 static struct GNUNET_SOCIAL_HistoryRequest *
2166 place_history_replay (struct GNUNET_SOCIAL_Place *plc,
2167                       uint64_t start_message_id,
2168                       uint64_t end_message_id,
2169                       uint64_t message_limit,
2170                       const char *method_prefix,
2171                       uint32_t flags,
2172                       struct GNUNET_PSYC_Slicer *slicer,
2173                       GNUNET_ResultCallback result_cb,
2174                       void *cls)
2175 {
2176   struct GNUNET_PSYC_HistoryRequestMessage *req;
2177   struct GNUNET_SOCIAL_HistoryRequest *hist = GNUNET_malloc (sizeof (*hist));
2178   hist->plc = plc;
2179   hist->slicer = slicer;
2180   hist->result_cb = result_cb;
2181   hist->cls = cls;
2182   hist->op_id = GNUNET_OP_add (plc->op, op_recv_history_result, hist, NULL);
2183
2184   GNUNET_assert (NULL != method_prefix);
2185   uint16_t method_size = strnlen (method_prefix,
2186                                   GNUNET_MAX_MESSAGE_SIZE
2187                                   - sizeof (*req)) + 1;
2188   GNUNET_assert ('\0' == method_prefix[method_size - 1]);
2189
2190   struct GNUNET_MQ_Envelope *
2191     env = GNUNET_MQ_msg_extra (req, method_size,
2192                                GNUNET_MESSAGE_TYPE_PSYC_HISTORY_REPLAY);
2193   req->start_message_id = GNUNET_htonll (start_message_id);
2194   req->end_message_id = GNUNET_htonll (end_message_id);
2195   req->message_limit = GNUNET_htonll (message_limit);
2196   req->flags = htonl (flags);
2197   req->op_id = GNUNET_htonll (hist->op_id);
2198   GNUNET_memcpy (&req[1], method_prefix, method_size);
2199
2200   GNUNET_MQ_send (plc->mq, env);
2201   return hist;
2202 }
2203
2204
2205 /**
2206  * Learn about the history of a place.
2207  *
2208  * Messages are returned through the @a slicer function
2209  * and have the #GNUNET_PSYC_MESSAGE_HISTORIC flag set.
2210  *
2211  * @param place
2212  *        Place we want to learn more about.
2213  * @param start_message_id
2214  *        First historic message we are interested in.
2215  * @param end_message_id
2216  *        Last historic message we are interested in (inclusive).
2217  * @param method_prefix
2218  *        Only retrieve messages with this method prefix.
2219  * @param flags
2220  *        OR'ed GNUNET_PSYC_HistoryReplayFlags
2221  * @param slicer
2222  *        Slicer to use for retrieved messages.
2223  *        Can be the same as the slicer of the place.
2224  * @param result_cb
2225  *        Function called after all messages retrieved.
2226  *        NULL if not needed.
2227  * @param cls Closure for @a result_cb.
2228  */
2229 struct GNUNET_SOCIAL_HistoryRequest *
2230 GNUNET_SOCIAL_place_history_replay (struct GNUNET_SOCIAL_Place *plc,
2231                                     uint64_t start_message_id,
2232                                     uint64_t end_message_id,
2233                                     const char *method_prefix,
2234                                     uint32_t flags,
2235                                     struct GNUNET_PSYC_Slicer *slicer,
2236                                     GNUNET_ResultCallback result_cb,
2237                                     void *cls)
2238 {
2239   return place_history_replay (plc, start_message_id, end_message_id, 0,
2240                                method_prefix, flags, slicer, result_cb, cls);
2241 }
2242
2243
2244 /**
2245  * Learn about the history of a place.
2246  *
2247  * Sends messages through the slicer function of the place where
2248  * start_message_id <= message_id <= end_message_id.
2249  * The messages will have the #GNUNET_PSYC_MESSAGE_HISTORIC flag set.
2250  *
2251  * To get the latest message, use 0 for both the start and end message ID.
2252  *
2253  * @param place
2254  *        Place we want to learn more about.
2255  * @param message_limit
2256  *        Maximum number of historic messages we are interested in.
2257  * @param method_prefix
2258  *        Only retrieve messages with this method prefix.
2259  * @param flags
2260  *        OR'ed GNUNET_PSYC_HistoryReplayFlags
2261  * @param result_cb
2262  *        Function called after all messages retrieved.
2263  *        NULL if not needed.
2264  * @param cls Closure for @a result_cb.
2265  */
2266 struct GNUNET_SOCIAL_HistoryRequest *
2267 GNUNET_SOCIAL_place_history_replay_latest (struct GNUNET_SOCIAL_Place *plc,
2268                                            uint64_t message_limit,
2269                                            const char *method_prefix,
2270                                            uint32_t flags,
2271                                            struct GNUNET_PSYC_Slicer *slicer,
2272                                            GNUNET_ResultCallback result_cb,
2273                                            void *cls)
2274 {
2275   return place_history_replay (plc, 0, 0, message_limit, method_prefix, flags,
2276                                slicer, result_cb, cls);
2277 }
2278
2279
2280 /**
2281  * Cancel learning about the history of a place.
2282  *
2283  * @param hist
2284  *        History lesson to cancel.
2285  */
2286 void
2287 GNUNET_SOCIAL_place_history_replay_cancel (struct GNUNET_SOCIAL_HistoryRequest *hist)
2288 {
2289   GNUNET_OP_remove (hist->plc->op, hist->op_id);
2290   GNUNET_free (hist);
2291 }
2292
2293
2294 /**
2295  * Request matching state variables.
2296  */
2297 static struct GNUNET_SOCIAL_LookHandle *
2298 place_state_get (struct GNUNET_SOCIAL_Place *plc,
2299                  uint16_t type, const char *name,
2300                  GNUNET_PSYC_StateVarCallback var_cb,
2301                  GNUNET_ResultCallback result_cb, void *cls)
2302 {
2303   struct GNUNET_PSYC_StateRequestMessage *req;
2304   struct GNUNET_SOCIAL_LookHandle *look = GNUNET_malloc (sizeof (*look));
2305   look->plc = plc;
2306   look->var_cb = var_cb;
2307   look->result_cb = result_cb;
2308   look->cls = cls;
2309   look->op_id = GNUNET_OP_add (plc->op, &op_recv_state_result, look, NULL);
2310
2311   GNUNET_assert (NULL != name);
2312   size_t name_size = strnlen (name, GNUNET_MAX_MESSAGE_SIZE
2313                               - sizeof (*req)) + 1;
2314   struct GNUNET_MQ_Envelope *
2315     env = GNUNET_MQ_msg_extra (req, name_size, type);
2316   req->op_id = GNUNET_htonll (look->op_id);
2317   GNUNET_memcpy (&req[1], name, name_size);
2318
2319   GNUNET_MQ_send (plc->mq, env);
2320   return look;
2321 }
2322
2323
2324 /**
2325  * Look at a particular object in the place.
2326  *
2327  * The best matching object is returned (its name might be less specific than
2328  * what was requested).
2329  *
2330  * @param place
2331  *        The place where to look.
2332  * @param full_name
2333  *        Full name of the object.
2334  * @param value_size
2335  *        Set to the size of the returned value.
2336  *
2337  * @return NULL if there is no such object at this place.
2338  */
2339 struct GNUNET_SOCIAL_LookHandle *
2340 GNUNET_SOCIAL_place_look_at (struct GNUNET_SOCIAL_Place *plc,
2341                              const char *full_name,
2342                              GNUNET_PSYC_StateVarCallback var_cb,
2343                              GNUNET_ResultCallback result_cb,
2344                              void *cls)
2345 {
2346   return place_state_get (plc, GNUNET_MESSAGE_TYPE_PSYC_STATE_GET,
2347                           full_name, var_cb, result_cb, cls);
2348 }
2349
2350
2351 /**
2352  * Look for objects in the place with a matching name prefix.
2353  *
2354  * @param place
2355  *        The place where to look.
2356  * @param name_prefix
2357  *        Look at objects with names beginning with this value.
2358  * @param var_cb
2359  *        Function to call for each object found.
2360  * @param cls
2361  *        Closure for callback function.
2362  *
2363  * @return Handle that can be used to stop looking at objects.
2364  */
2365 struct GNUNET_SOCIAL_LookHandle *
2366 GNUNET_SOCIAL_place_look_for (struct GNUNET_SOCIAL_Place *plc,
2367                               const char *name_prefix,
2368                               GNUNET_PSYC_StateVarCallback var_cb,
2369                               GNUNET_ResultCallback result_cb,
2370                               void *cls)
2371 {
2372   return place_state_get (plc, GNUNET_MESSAGE_TYPE_PSYC_STATE_GET_PREFIX,
2373                           name_prefix, var_cb, result_cb, cls);
2374 }
2375
2376
2377 /**
2378  * Cancel a state request operation.
2379  *
2380  * @param sr
2381  *        Handle for the operation to cancel.
2382  */
2383 void
2384 GNUNET_SOCIAL_place_look_cancel (struct GNUNET_SOCIAL_LookHandle *look)
2385 {
2386   GNUNET_OP_remove (look->plc->op, look->op_id);
2387   GNUNET_free (look);
2388 }
2389
2390
2391 static void
2392 op_recv_zone_add_place_result (void *cls, int64_t result,
2393                                const void *err_msg, uint16_t err_msg_size)
2394 {
2395   LOG (GNUNET_ERROR_TYPE_DEBUG,
2396        "Received zone add place result: %" PRId64 ".\n", result);
2397
2398   struct ZoneAddPlaceHandle *add_plc = cls;
2399   if (NULL != add_plc->result_cb)
2400     add_plc->result_cb (add_plc->result_cls, result, err_msg, err_msg_size);
2401
2402   GNUNET_free (add_plc);
2403 }
2404
2405
2406 /**
2407  * Advertise @e place in the GNS zone of @e ego.
2408  *
2409  * @param app
2410  *        Application handle.
2411  * @param ego
2412  *        Ego.
2413  * @param place_pub_key
2414  *        Public key of place to add.
2415  * @param name
2416  *        The name for the PLACE record to put in the zone.
2417  * @param password
2418  *        Password used to encrypt the record or NULL to keep it cleartext.
2419  * @param relay_count
2420  *        Number of elements in the @a relays array.
2421  * @param relays
2422  *        List of relays to put in the PLACE record to advertise
2423  *        as entry points to the place in addition to the origin.
2424  * @param expiration_time
2425  *        Expiration time of the record, use 0 to remove the record.
2426  * @param result_cb
2427  *        Function called with the result of the operation.
2428  * @param result_cls
2429  *        Closure for @a result_cb
2430  *
2431  * @return #GNUNET_OK if the request was sent,
2432  *         #GNUNET_SYSERR on error, e.g. the name/password is too long.
2433  */
2434 int
2435 GNUNET_SOCIAL_zone_add_place (const struct GNUNET_SOCIAL_App *app,
2436                               const struct GNUNET_SOCIAL_Ego *ego,
2437                               const char *name,
2438                               const char *password,
2439                               const struct GNUNET_CRYPTO_EddsaPublicKey *place_pub_key,
2440                               const struct GNUNET_PeerIdentity *origin,
2441                               uint32_t relay_count,
2442                               const struct GNUNET_PeerIdentity *relays,
2443                               struct GNUNET_TIME_Absolute expiration_time,
2444                               GNUNET_ResultCallback result_cb,
2445                               void *result_cls)
2446 {
2447   struct ZoneAddPlaceRequest *preq;
2448   size_t name_size = strlen (name) + 1;
2449   size_t password_size = strlen (password) + 1;
2450   size_t relay_size = relay_count * sizeof (*relays);
2451   size_t payload_size = name_size + password_size + relay_size;
2452
2453   if (GNUNET_MAX_MESSAGE_SIZE < sizeof (*preq) + payload_size)
2454     return GNUNET_SYSERR;
2455
2456   struct GNUNET_MQ_Envelope *
2457     env = GNUNET_MQ_msg_extra (preq, payload_size,
2458                                GNUNET_MESSAGE_TYPE_SOCIAL_ZONE_ADD_PLACE);
2459   preq->expiration_time = GNUNET_htonll (expiration_time.abs_value_us);
2460   preq->ego_pub_key = ego->pub_key;
2461   preq->place_pub_key = *place_pub_key;
2462   preq->origin = *origin;
2463   preq->relay_count = htonl (relay_count);
2464
2465   char *p = (char *) &preq[1];
2466   GNUNET_memcpy (p, name, name_size);
2467   p += name_size;
2468   GNUNET_memcpy (p, password, password_size);
2469   p += password_size;
2470   GNUNET_memcpy (p, relays, relay_size);
2471
2472   struct ZoneAddPlaceHandle * add_plc = GNUNET_malloc (sizeof (*add_plc));
2473   add_plc->result_cb = result_cb;
2474   add_plc->result_cls = result_cls;
2475
2476   preq->op_id = GNUNET_htonll (GNUNET_OP_add (app->op,
2477                                               op_recv_zone_add_place_result,
2478                                               add_plc, NULL));
2479
2480   GNUNET_MQ_send (app->mq, env);
2481   return GNUNET_OK;
2482 }
2483
2484
2485 static void
2486 op_recv_zone_add_nym_result (void *cls, int64_t result,
2487                              const void *err_msg, uint16_t err_msg_size)
2488 {
2489   LOG (GNUNET_ERROR_TYPE_DEBUG,
2490        "Received zone add nym result: %" PRId64 ".\n", result);
2491
2492   struct ZoneAddNymHandle *add_nym = cls;
2493   if (NULL != add_nym->result_cb)
2494     add_nym->result_cb (add_nym->result_cls, result, err_msg, err_msg_size);
2495
2496   GNUNET_free (add_nym);
2497 }
2498
2499
2500 /**
2501  * Add nym to the GNS zone of @e ego.
2502  *
2503  * @param cfg
2504  *        Configuration.
2505  * @param ego
2506  *        Ego.
2507  * @param name
2508  *        The name for the PKEY record to put in the zone.
2509  * @param nym_pub_key
2510  *        Public key of nym to add.
2511  * @param expiration_time
2512  *        Expiration time of the record, use 0 to remove the record.
2513  * @param result_cb
2514  *        Function called with the result of the operation.
2515  * @param result_cls
2516  *        Closure for @a result_cb
2517  *
2518  * @return #GNUNET_OK if the request was sent,
2519  *         #GNUNET_SYSERR on error, e.g. the name is too long.
2520  */
2521 int
2522 GNUNET_SOCIAL_zone_add_nym (const struct GNUNET_SOCIAL_App *app,
2523                             const struct GNUNET_SOCIAL_Ego *ego,
2524                             const char *name,
2525                             const struct GNUNET_CRYPTO_EcdsaPublicKey *nym_pub_key,
2526                             struct GNUNET_TIME_Absolute expiration_time,
2527                             GNUNET_ResultCallback result_cb,
2528                             void *result_cls)
2529 {
2530   struct ZoneAddNymRequest *nreq;
2531
2532   size_t name_size = strlen (name) + 1;
2533   if (GNUNET_MAX_MESSAGE_SIZE < sizeof (*nreq) + name_size)
2534     return GNUNET_SYSERR;
2535
2536   struct GNUNET_MQ_Envelope *
2537     env = GNUNET_MQ_msg_extra (nreq, name_size,
2538                                GNUNET_MESSAGE_TYPE_SOCIAL_ZONE_ADD_NYM);
2539   nreq->expiration_time = GNUNET_htonll (expiration_time.abs_value_us);
2540   nreq->ego_pub_key = ego->pub_key;
2541   nreq->nym_pub_key = *nym_pub_key;
2542   GNUNET_memcpy (&nreq[1], name, name_size);
2543
2544   struct ZoneAddNymHandle *add_nym = GNUNET_malloc (sizeof (*add_nym));
2545   add_nym->result_cb = result_cb;
2546   add_nym->result_cls = result_cls;
2547
2548   nreq->op_id = GNUNET_htonll (GNUNET_OP_add (app->op,
2549                                               op_recv_zone_add_nym_result,
2550                                               add_nym, NULL));
2551
2552   GNUNET_MQ_send (app->mq, env);
2553   return GNUNET_OK;
2554 }
2555
2556
2557 /*** APP ***/
2558
2559
2560 static void
2561 app_connect (struct GNUNET_SOCIAL_App *app);
2562
2563
2564 static void
2565 app_reconnect (void *cls)
2566 {
2567   app_connect (cls);
2568 }
2569
2570
2571 /**
2572  * App client disconnected from service.
2573  *
2574  * Reconnect after backoff period.
2575  */
2576 static void
2577 app_disconnected (void *cls, enum GNUNET_MQ_Error error)
2578 {
2579   struct GNUNET_SOCIAL_App *app = cls;
2580
2581   LOG (GNUNET_ERROR_TYPE_DEBUG,
2582        "App client disconnected (%d), re-connecting\n",
2583        (int) error);
2584   if (NULL != app->mq)
2585   {
2586     GNUNET_MQ_destroy (app->mq);
2587     app->mq = NULL;
2588   }
2589
2590   app->reconnect_task = GNUNET_SCHEDULER_add_delayed (app->reconnect_delay,
2591                                                       app_reconnect,
2592                                                       app);
2593   app->reconnect_delay = GNUNET_TIME_STD_BACKOFF (app->reconnect_delay);
2594 }
2595
2596
2597 static void
2598 app_connect (struct GNUNET_SOCIAL_App *app)
2599 {
2600   struct GNUNET_MQ_MessageHandler handlers[] = {
2601     GNUNET_MQ_hd_var_size (app_ego,
2602                            GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO,
2603                            struct AppEgoMessage,
2604                            app),
2605     GNUNET_MQ_hd_fixed_size (app_ego_end,
2606                              GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO_END,
2607                              struct GNUNET_MessageHeader,
2608                              app),
2609     GNUNET_MQ_hd_var_size (app_place,
2610                            GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE,
2611                            struct AppPlaceMessage,
2612                            app),
2613     GNUNET_MQ_hd_fixed_size (app_place_end,
2614                              GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE_END,
2615                              struct GNUNET_MessageHeader,
2616                              app),
2617     GNUNET_MQ_hd_var_size (app_result,
2618                            GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE,
2619                            struct GNUNET_OperationResultMessage,
2620                            app),
2621     GNUNET_MQ_handler_end ()
2622   };
2623
2624   app->mq = GNUNET_CLIENT_connect (app->cfg, "social",
2625                                    handlers, app_disconnected, app);
2626   GNUNET_assert (NULL != app->mq);
2627   GNUNET_MQ_send_copy (app->mq, app->connect_env);
2628 }
2629
2630
2631 /**
2632  * Connect application to the social service.
2633  *
2634  * The @host_place_cb and @guest_place_cb functions are
2635  * initially called for each entered places,
2636  * then later each time a new place is entered with the current application ID.
2637  *
2638  * @param cfg
2639  *        Configuration.
2640  * @param id
2641  *        Application ID.
2642  * @param ego_cb
2643  *        Function to notify about an available ego.
2644  * @param host_cb
2645  *        Function to notify about a place entered as host.
2646  * @param guest_cb
2647  *        Function to notify about a place entered as guest.
2648  * @param cls
2649  *        Closure for the callbacks.
2650  *
2651  * @return Handle that can be used to stop listening.
2652  */
2653 struct GNUNET_SOCIAL_App *
2654 GNUNET_SOCIAL_app_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
2655                            const char *id,
2656                            GNUNET_SOCIAL_AppEgoCallback ego_cb,
2657                            GNUNET_SOCIAL_AppHostPlaceCallback host_cb,
2658                            GNUNET_SOCIAL_AppGuestPlaceCallback guest_cb,
2659                            GNUNET_SOCIAL_AppConnectedCallback connected_cb,
2660                            void *cls)
2661 {
2662   uint16_t app_id_size = strnlen (id, GNUNET_SOCIAL_APP_MAX_ID_SIZE);
2663   if (GNUNET_SOCIAL_APP_MAX_ID_SIZE == app_id_size)
2664     return NULL;
2665   app_id_size++;
2666
2667   struct GNUNET_SOCIAL_App *app = GNUNET_malloc (sizeof *app);
2668   app->cfg = cfg;
2669   app->ego_cb = ego_cb;
2670   app->host_cb = host_cb;
2671   app->guest_cb = guest_cb;
2672   app->connected_cb = connected_cb;
2673   app->cb_cls = cls;
2674   app->egos = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
2675   app->op = GNUNET_OP_create ();
2676   app->id = GNUNET_malloc (app_id_size);
2677   GNUNET_memcpy (app->id, id, app_id_size);
2678
2679   struct AppConnectRequest *creq;
2680   app->connect_env = GNUNET_MQ_msg_extra (creq, app_id_size,
2681                                           GNUNET_MESSAGE_TYPE_SOCIAL_APP_CONNECT);
2682   GNUNET_memcpy (&creq[1], app->id, app_id_size);
2683
2684   app_connect (app);
2685   return app;
2686 }
2687
2688
2689 static void
2690 app_cleanup (struct GNUNET_SOCIAL_App *app)
2691 {
2692   if (NULL != app->mq)
2693   {
2694     GNUNET_MQ_destroy (app->mq);
2695     app->mq = NULL;
2696   }
2697   if (NULL != app->disconnect_cb)
2698   {
2699     app->disconnect_cb (app->disconnect_cls);
2700     app->disconnect_cb = NULL;
2701   }
2702   GNUNET_free (app);
2703 }
2704
2705 /**
2706  * Disconnect application.
2707  *
2708  * @param app
2709  *        Application handle.
2710  * @param disconnect_cb
2711  *        Disconnect callback.
2712  * @param disconnect_cls
2713  *        Disconnect closure.
2714  */
2715 void
2716 GNUNET_SOCIAL_app_disconnect (struct GNUNET_SOCIAL_App *app,
2717                               GNUNET_ContinuationCallback disconnect_cb,
2718                               void *disconnect_cls)
2719 {
2720   app->disconnect_cb = disconnect_cb;
2721   app->disconnect_cls = disconnect_cls;
2722
2723   if (NULL != app->mq)
2724   {
2725     struct GNUNET_MQ_Envelope *env = GNUNET_MQ_get_last_envelope (app->mq);
2726     if (NULL != env)
2727     {
2728       GNUNET_MQ_notify_sent (env, (GNUNET_SCHEDULER_TaskCallback) app_cleanup, app);
2729     }
2730     else
2731     {
2732       app_cleanup (app);
2733     }
2734   }
2735   else
2736   {
2737     app_cleanup (app);
2738   }
2739 }
2740
2741
2742 /**
2743  * Detach application from a place.
2744  *
2745  * Removes the place from the entered places list for this application.
2746  * Note: this does not disconnect from the place.
2747  *
2748  * @see GNUNET_SOCIAL_host_disconnect() and GNUNET_SOCIAL_guest_disconnect()
2749  *
2750  * @param app
2751  *        Application.
2752  * @param plc
2753  *        Place.
2754  */
2755 void
2756 GNUNET_SOCIAL_app_detach (struct GNUNET_SOCIAL_App *app,
2757                           struct GNUNET_SOCIAL_Place *plc)
2758 {
2759   struct AppDetachRequest *dreq;
2760   struct GNUNET_MQ_Envelope *
2761     env = GNUNET_MQ_msg (dreq, GNUNET_MESSAGE_TYPE_SOCIAL_APP_DETACH);
2762   dreq->place_pub_key = plc->pub_key;
2763   dreq->ego_pub_key = plc->ego_pub_key;
2764
2765   GNUNET_MQ_send (app->mq, env);
2766 }
2767
2768
2769 /* end of social_api.c */