src/social/gnunet-social.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2016 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  * CLI tool to interact with the social service.
  23  *
  24  * @author Gabor X Toth
  25  */
  26
  27 #include <inttypes.h>
  28
  29 #include "platform.h"
  30 #include "gnunet_util_lib.h"
  31 #include "gnunet_social_service.h"
  32 #include "gnunet_core_service.h"
  33
  34 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
  35
  36 #define DATA2ARG(data) data, sizeof (data)
  37
  38 /* operations corresponding to API calls */
  39
  40 /** --status */
  41 static int op_status;
  42
  43 /** --host-enter */
  44 static int op_host_enter;
  45
  46 /** --host-reconnect */
  47 static int op_host_reconnect;
  48
  49 /** --host-leave */
  50 static int op_host_leave;
  51
  52 /** --host-announce */
  53 static int op_host_announce;
  54
  55 /** --host-assign */
  56 static int op_host_assign;
  57
  58 /** --guest-enter */
  59 static int op_guest_enter;
  60
  61 /** --guest-reconnect */
  62 static int op_guest_reconnect;
  63
  64 /** --guest-leave */
  65 static int op_guest_leave;
  66
  67 /** --guest-talk */
  68 static int op_guest_talk;
  69
  70 /** --replay */
  71 static char *op_replay;
  72
  73 /** --replay-latest */
  74 static char *op_replay_latest;
  75
  76 /** --look-at */
  77 static int op_look_at;
  78
  79 /** --look-for */
  80 static int op_look_for;
  81
  82
  83 /* options */
  84
  85 /** --app */
  86 static char *opt_app = "cli";
  87
  88 /** --place */
  89 static char *opt_place;
  90
  91 /** --ego */
  92 static char *opt_ego;
  93
  94 /** --gns */
  95 static char *opt_gns;
  96
  97 /** --peer */
  98 static char *opt_peer;
  99
 100 /** --follow */
 101 static int opt_follow;
 102
 103 /** --welcome */
 104 static int opt_welcome;
 105
 106 /** --deny */
 107 static int opt_deny;
 108
 109 /** --method */
 110 static char *opt_method;
 111
 112 /** --data */
 113 // FIXME: should come from STDIN
 114 static char *opt_data;
 115
 116 /** --name */
 117 static char *opt_name;
 118
 119 /** --start */
 120 static uint64_t opt_start;
 121
 122 /** --until */
 123 static uint64_t opt_until;
 124
 125 /** --limit */
 126 static int opt_limit;
 127
 128
 129 /* global vars */
 130
 131 /** exit code */
 132 static int ret = 1;
 133
 134 /** are we waiting for service to close our connection */
 135 static char is_disconnecting = 0;
 136
 137 /** Task handle for timeout termination. */
 138 struct GNUNET_SCHEDULER_Task *timeout_task;
 139
 140 const struct GNUNET_CONFIGURATION_Handle *cfg;
 141
 142 struct GNUNET_CORE_Handle *core;
 143 struct GNUNET_PeerIdentity peer, this_peer;
 144
 145 struct GNUNET_SOCIAL_App *app;
 146
 147 /** public key of connected place */
 148 struct GNUNET_CRYPTO_EddsaPublicKey place_pub_key;
 149
 150 struct GNUNET_PSYC_Slicer *slicer;
 151
 152 struct GNUNET_SOCIAL_Ego *ego;
 153 struct GNUNET_CRYPTO_EcdsaPublicKey ego_pub_key;
 154
 155 struct GNUNET_SOCIAL_Host *hst;
 156 struct GNUNET_SOCIAL_Guest *gst;
 157 struct GNUNET_SOCIAL_Place *plc;
 158
 159
 160 /* DISCONNECT */
 161
 162
 163 /**
 164  * Callback called after the host or guest place disconnected.
 165  */
 166 static void
 167 disconnected (void *cls)
 168 {
 169   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "disconnected()\n");
 170   GNUNET_SCHEDULER_shutdown ();
 171 }
 172
 173
 174 /**
 175  * Callback called after the application disconnected.
 176  */
 177 static void
 178 app_disconnected (void *cls)
 179 {
 180   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "app_disconnected()\n");
 181   if (hst || gst)
 182   {
 183     if (hst)
 184     {
 185       GNUNET_SOCIAL_host_disconnect (hst, disconnected, NULL);
 186     }
 187     if (gst)
 188     {
 189       GNUNET_SOCIAL_guest_disconnect (gst, disconnected, NULL);
 190     }
 191   }
 192   else
 193   {
 194     GNUNET_SCHEDULER_shutdown ();
 195   }
 196 }
 197
 198
 199 /**
 200  * Disconnect from connected GNUnet services.
 201  */
 202 static void
 203 disconnect ()
 204 {
 205   // handle that we get called several times from several places, but should we?
 206   if (!is_disconnecting++) {
 207     GNUNET_SOCIAL_app_disconnect (app, app_disconnected, NULL);
 208   }
 209   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "disconnect() called for the #%d time\n", is_disconnecting);
 210 }
 211
 212
 213 static void
 214 scheduler_shutdown (void *cls)
 215 {
 216   disconnect ();
 217 }
 218
 219
 220 /**
 221  * Callback called when the program failed to finish the requested operation in time.
 222  */
 223 static void
 224 timeout (void *cls)
 225 {
 226   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "timeout()\n");
 227   disconnect ();
 228 }
 229
 230 static void
 231 schedule_success (void *cls)
 232 {
 233   ret = 0;
 234   disconnect ();
 235 }
 236
 237
 238 static void
 239 schedule_fail (void *cls)
 240 {
 241   disconnect ();
 242 }
 243
 244
 245 /**
 246  * Schedule exit with success result.
 247  */
 248 static void
 249 exit_success ()
 250 {
 251   if (timeout_task != NULL)
 252   {
 253     GNUNET_SCHEDULER_cancel (timeout_task);
 254     timeout_task = NULL;
 255   }
 256   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, schedule_success, NULL);
 257 }
 258
 259
 260 /**
 261  * Schedule exit with failure result.
 262  */
 263 static void
 264 exit_fail ()
 265 {
 266   if (timeout_task != NULL)
 267   {
 268     GNUNET_SCHEDULER_cancel (timeout_task);
 269     timeout_task = NULL;
 270   }
 271   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, schedule_fail, NULL);
 272 }
 273
 274
 275 /* LEAVE */
 276
 277
 278 /**
 279  * Callback notifying about the host has left and stopped hosting the place.
 280  *
 281  * This also indicates the end of the connection to the service.
 282  */
 283 static void
 284 host_left ()
 285 {
 286   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 287               "The host has left the place.\n");
 288   exit_success ();
 289 }
 290
 291
 292 /**
 293  * Leave a place permanently and stop hosting a place.
 294  */
 295 static void
 296 host_leave ()
 297 {
 298   GNUNET_SOCIAL_host_leave (hst, NULL, host_left, NULL);
 299   hst = NULL;
 300   plc = NULL;
 301 }
 302
 303
 304 /**
 305  * Callback notifying about the guest has left the place.
 306  *
 307  * This also indicates the end of the connection to the service.
 308  */
 309 static void
 310 guest_left (void *cls)
 311 {
 312   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 313               "The guest has left the place.\n");
 314 }
 315
 316
 317 /**
 318  * Leave a place permanently as guest.
 319  */
 320 static void
 321 guest_leave ()
 322 {
 323   struct GNUNET_PSYC_Environment *env = GNUNET_PSYC_env_create ();
 324   // FIXME: wrong use of vars
 325   GNUNET_PSYC_env_add (env, GNUNET_PSYC_OP_SET,
 326                        "_message", DATA2ARG ("Leaving."));
 327   GNUNET_SOCIAL_guest_leave (gst, env, guest_left, NULL);
 328   GNUNET_PSYC_env_destroy (env);
 329   gst = NULL;
 330   plc = NULL;
 331 }
 332
 333
 334 /* ANNOUNCE / ASSIGN / TALK */
 335
 336
 337 struct TransmitClosure
 338 {
 339   const char *data;
 340   size_t size;
 341 } tmit;
 342
 343
 344 /**
 345  * Callback notifying about available buffer space to write message data
 346  * when transmitting messages using host_announce() or guest_talk()
 347  */
 348 static int
 349 notify_data (void *cls, uint16_t *data_size, void *data)
 350 {
 351   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 352               "Transmit notify data: %u bytes available\n",
 353               *data_size);
 354
 355   struct TransmitClosure *tmit = cls;
 356   uint16_t size = tmit->size < *data_size ? tmit->size : *data_size;
 357   *data_size = size;
 358   GNUNET_memcpy (data, tmit->data, size);
 359
 360   tmit->size -= size;
 361   tmit->data += size;
 362
 363   if (0 == tmit->size)
 364   {
 365     if (op_host_announce || op_host_assign || op_guest_talk)
 366     {
 367       exit_success ();
 368     }
 369     return GNUNET_YES;
 370   }
 371   else
 372   {
 373     return GNUNET_NO;
 374   }
 375 }
 376
 377
 378 /**
 379  * Host announcement - send a message to the place.
 380  */
 381 static void
 382 host_announce (const char *method, const char *data, size_t data_size)
 383 {
 384   struct GNUNET_PSYC_Environment *env = GNUNET_PSYC_env_create ();
 385   GNUNET_PSYC_env_add (env, GNUNET_PSYC_OP_SET,
 386                        "_foo", DATA2ARG ("bar baz"));
 387
 388   tmit = (struct TransmitClosure) {};
 389   tmit.data = data;
 390   tmit.size = data_size;
 391
 392   GNUNET_SOCIAL_host_announce (hst, method, env,
 393                                notify_data, &tmit,
 394                                GNUNET_SOCIAL_ANNOUNCE_NONE);
 395   GNUNET_PSYC_env_destroy (env);
 396 }
 397
 398
 399 /**
 400  * Assign a state var of @a name to the value of @a data.
 401  */
 402 static void
 403 host_assign (const char *name, const char *data, size_t data_size)
 404 {
 405   struct GNUNET_PSYC_Environment *env = GNUNET_PSYC_env_create ();
 406   GNUNET_PSYC_env_add (env, GNUNET_PSYC_OP_ASSIGN,
 407                        name, data, data_size);
 408
 409   tmit = (struct TransmitClosure) {};
 410   GNUNET_SOCIAL_host_announce (hst, "_assign", env,
 411                                notify_data, &tmit,
 412                                GNUNET_SOCIAL_ANNOUNCE_NONE);
 413   GNUNET_PSYC_env_destroy (env);
 414 }
 415
 416
 417 /**
 418  * Guest talk request to host.
 419  */
 420 static void
 421 guest_talk (const char *method,
 422             const char *data, size_t data_size)
 423 {
 424   struct GNUNET_PSYC_Environment *env = GNUNET_PSYC_env_create ();
 425   GNUNET_PSYC_env_add (env, GNUNET_PSYC_OP_SET,
 426                        "_foo", DATA2ARG ("bar baz"));
 427
 428   tmit = (struct TransmitClosure) {};
 429   tmit.data = data;
 430   tmit.size = data_size;
 431
 432   GNUNET_SOCIAL_guest_talk (gst, method, env,
 433                             notify_data, &tmit,
 434                             GNUNET_SOCIAL_TALK_NONE);
 435   GNUNET_PSYC_env_destroy (env);
 436 }
 437
 438
 439 /* HISTORY REPLAY */
 440
 441
 442 /**
 443  * Callback notifying about the end of history replay results.
 444  */
 445 static void
 446 recv_history_replay_result (void *cls, int64_t result,
 447                             const void *data, uint16_t data_size)
 448 {
 449   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 450               "Received history replay result: %" PRId64 "\n"
 451               "%.*s\n",
 452               result, data_size, (const char *) data);
 453
 454   if (op_replay || op_replay_latest)
 455   {
 456     exit_success ();
 457   }
 458 }
 459
 460
 461 /**
 462  * Replay history between a given @a start and @a end message IDs,
 463  * optionally filtered by a method @a prefix.
 464  */
 465 static void
 466 history_replay (uint64_t start, uint64_t end, const char *prefix)
 467 {
 468   GNUNET_SOCIAL_place_history_replay (plc, start, end, prefix,
 469                                       GNUNET_PSYC_HISTORY_REPLAY_LOCAL,
 470                                       slicer,
 471                                       recv_history_replay_result,
 472                                       NULL);
 473 }
 474
 475
 476 /**
 477  * Replay latest @a limit messages.
 478  */
 479 static void
 480 history_replay_latest (uint64_t limit, const char *prefix)
 481 {
 482   GNUNET_SOCIAL_place_history_replay_latest (plc, limit, prefix,
 483                                              GNUNET_PSYC_HISTORY_REPLAY_LOCAL,
 484                                              slicer,
 485                                              recv_history_replay_result,
 486                                              NULL);
 487 }
 488
 489
 490 /* LOOK AT/FOR */
 491
 492
 493 /**
 494  * Callback notifying about the end of state var results.
 495  */
 496 static void
 497 look_result (void *cls, int64_t result_code,
 498              const void *data, uint16_t data_size)
 499 {
 500   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 501               "Received look result: %" PRId64 "\n", result_code);
 502
 503   if (op_look_at || op_look_for)
 504   {
 505     exit_success ();
 506   }
 507 }
 508
 509
 510 /**
 511  * Callback notifying about a state var result.
 512  */
 513 static void
 514 look_var (void *cls,
 515           const struct GNUNET_MessageHeader *mod,
 516           const char *name,
 517           const void *value,
 518           uint32_t value_size,
 519           uint32_t full_value_size)
 520 {
 521   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 522               "Received var: %s\n%.*s\n",
 523               name, value_size, (const char *) value);
 524 }
 525
 526
 527 /**
 528  * Look for a state var using exact match of the name.
 529  */
 530 static void
 531 look_at (const char *full_name)
 532 {
 533   GNUNET_SOCIAL_place_look_at (plc, full_name, look_var, look_result, NULL);
 534 }
 535
 536
 537 /**
 538  * Look for state vars by name prefix.
 539  */
 540 static void
 541 look_for (const char *name_prefix)
 542 {
 543   GNUNET_SOCIAL_place_look_for (plc, name_prefix, look_var, look_result, NULL);
 544 }
 545
 546
 547 /* SLICER */
 548
 549
 550 /**
 551  * Callback notifying about the start of a new incoming message.
 552  */
 553 static void
 554 slicer_recv_method (void *cls,
 555                     const struct GNUNET_PSYC_MessageHeader *msg,
 556                     const struct GNUNET_PSYC_MessageMethod *meth,
 557                     uint64_t message_id,
 558                     const char *method_name)
 559 {
 560   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 561               "Received method for message ID %" PRIu64 ":\n"
 562               "%s (flags: %x)\n",
 563               message_id, method_name, ntohl (meth->flags));
 564 }
 565
 566
 567 /**
 568  * Callback notifying about an incoming modifier.
 569  */
 570 static void
 571 slicer_recv_modifier (void *cls,
 572                       const struct GNUNET_PSYC_MessageHeader *msg,
 573                       const struct GNUNET_MessageHeader *pmsg,
 574                       uint64_t message_id,
 575                       enum GNUNET_PSYC_Operator oper,
 576                       const char *name,
 577                       const void *value,
 578                       uint16_t value_size,
 579                       uint16_t full_value_size)
 580 {
 581   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 582               "Received modifier for message ID %" PRIu64 ":\n"
 583               "%c%s: %.*s (size: %u)\n",
 584               message_id, oper, name, value_size, (const char *) value, value_size);
 585 }
 586
 587
 588 /**
 589  * Callback notifying about an incoming data fragment.
 590  */
 591 static void
 592 slicer_recv_data (void *cls,
 593                   const struct GNUNET_PSYC_MessageHeader *msg,
 594                   const struct GNUNET_MessageHeader *pmsg,
 595                   uint64_t message_id,
 596                   const void *data,
 597                   uint16_t data_size)
 598 {
 599   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 600               "Received data for message ID %" PRIu64 ":\n"
 601               "%.*s\n",
 602               message_id, data_size, (const char *) data);
 603 }
 604
 605
 606 /**
 607  * Callback notifying about the end of a message.
 608  */
 609 static void
 610 slicer_recv_eom (void *cls,
 611                 const struct GNUNET_PSYC_MessageHeader *msg,
 612                 const struct GNUNET_MessageHeader *pmsg,
 613                 uint64_t message_id,
 614                 uint8_t is_cancelled)
 615 {
 616   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 617               "Received end of message ID %" PRIu64
 618               ", cancelled: %u\n",
 619               message_id, is_cancelled);
 620 }
 621
 622
 623 /**
 624  * Create a slicer for receiving message parts.
 625  */
 626 static struct GNUNET_PSYC_Slicer *
 627 slicer_create ()
 628 {
 629   slicer = GNUNET_PSYC_slicer_create ();
 630
 631   /* register slicer to receive incoming messages with any method name */
 632   GNUNET_PSYC_slicer_method_add (slicer, "", NULL,
 633                                  slicer_recv_method, slicer_recv_modifier,
 634                                  slicer_recv_data, slicer_recv_eom, NULL);
 635   return slicer;
 636 }
 637
 638
 639 /* GUEST ENTER */
 640
 641
 642 /**
 643  * Callback called when the guest receives an entry decision from the host.
 644  *
 645  * It is called once after using guest_enter() or guest_enter_by_name(),
 646  * in case of a reconnection only the local enter callback is called.
 647  */
 648 static void
 649 guest_recv_entry_decision (void *cls,
 650                            int is_admitted,
 651                            const struct GNUNET_PSYC_Message *entry_msg)
 652 {
 653   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 654               "Guest received entry decision %d\n",
 655               is_admitted);
 656
 657   if (NULL != entry_msg)
 658   {
 659     struct GNUNET_PSYC_Environment *env = GNUNET_PSYC_env_create ();
 660     const char *method_name = NULL;
 661     const void *data = NULL;
 662     uint16_t data_size = 0;
 663     struct GNUNET_PSYC_MessageHeader *
 664       pmsg = GNUNET_PSYC_message_header_create_from_psyc (entry_msg);
 665     GNUNET_PSYC_message_parse (pmsg, &method_name, env, &data, &data_size);
 666     GNUNET_free (pmsg);
 667
 668     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 669                 "%s\n%.*s\n",
 670                 method_name, data_size, (const char *) data);
 671   }
 672
 673   if (op_guest_enter && !opt_follow)
 674   {
 675     exit_success ();
 676   }
 677 }
 678
 679
 680 /**
 681  * Callback called after a guest connection is established to the local service.
 682  */
 683 static void
 684 guest_recv_local_enter (void *cls, int result,
 685                         const struct GNUNET_CRYPTO_EddsaPublicKey *pub_key,
 686                         uint64_t max_message_id)
 687 {
 688   char *pub_str = GNUNET_CRYPTO_eddsa_public_key_to_string (pub_key);
 689   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 690               "Guest entered to local place: %s, max_message_id: %" PRIu64 "\n",
 691               pub_str, max_message_id);
 692   GNUNET_free (pub_str);
 693   GNUNET_assert (0 <= result);
 694
 695   if (op_guest_enter && !opt_follow)
 696   {
 697     exit_success ();
 698   }
 699 }
 700
 701
 702 /**
 703  * Create entry requset message.
 704  */
 705 static struct GNUNET_PSYC_Message *
 706 guest_enter_msg_create ()
 707 {
 708   const char *method_name = "_request_enter";
 709   struct GNUNET_PSYC_Environment *env = GNUNET_PSYC_env_create ();
 710   GNUNET_PSYC_env_add (env, GNUNET_PSYC_OP_SET,
 711                        "_foo", DATA2ARG ("bar"));
 712   void *data = "let me in";
 713   uint16_t data_size = strlen (data) + 1;
 714
 715   return GNUNET_PSYC_message_create (method_name, env, data, data_size);
 716 }
 717
 718
 719 /**
 720  * Enter a place as guest, using its public key and peer ID.
 721  */
 722 static void
 723 guest_enter (const struct GNUNET_CRYPTO_EddsaPublicKey *pub_key,
 724              const struct GNUNET_PeerIdentity *peer)
 725 {
 726   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 727               "Entering to place as guest.\n");
 728
 729   if (NULL == ego)
 730   {
 731     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "--ego missing or invalid\n");
 732     exit_fail ();
 733     return;
 734   }
 735
 736   struct GNUNET_PSYC_Message *join_msg = guest_enter_msg_create ();
 737   gst = GNUNET_SOCIAL_guest_enter (app, ego, pub_key,
 738                                    GNUNET_PSYC_SLAVE_JOIN_NONE,
 739                                    peer, 0, NULL, join_msg, slicer_create (),
 740                                    guest_recv_local_enter,
 741                                    guest_recv_entry_decision, NULL);
 742   GNUNET_free (join_msg);
 743   plc = GNUNET_SOCIAL_guest_get_place (gst);
 744 }
 745
 746
 747 /**
 748  * Enter a place as guest using its GNS address.
 749  */
 750 static void
 751 guest_enter_by_name (const char *gns_name)
 752 {
 753   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 754               "Entering to place by name as guest.\n");
 755
 756   struct GNUNET_PSYC_Message *join_msg = guest_enter_msg_create ();
 757   gst = GNUNET_SOCIAL_guest_enter_by_name (app, ego, gns_name, NULL,
 758                                            join_msg, slicer,
 759                                            guest_recv_local_enter,
 760                                            guest_recv_entry_decision, NULL);
 761   GNUNET_free (join_msg);
 762   plc = GNUNET_SOCIAL_guest_get_place (gst);
 763 }
 764
 765
 766 /* HOST ENTER */
 767
 768
 769 /**
 770  * Callback called when a @a nym wants to enter the place.
 771  *
 772  * The request needs to be replied with an entry decision.
 773  */
 774 static void
 775 host_answer_door (void *cls,
 776                   struct GNUNET_SOCIAL_Nym *nym,
 777                   const char *method_name,
 778                   struct GNUNET_PSYC_Environment *env,
 779                   const void *data,
 780                   size_t data_size)
 781 {
 782   const struct GNUNET_CRYPTO_EcdsaPublicKey *
 783     nym_key = GNUNET_SOCIAL_nym_get_pub_key (nym);
 784   char *
 785     nym_str = GNUNET_CRYPTO_ecdsa_public_key_to_string (nym_key);
 786
 787   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 788               "Entry request: %s\n", nym_str);
 789   GNUNET_free (nym_str);
 790
 791   if (opt_welcome)
 792   {
 793     struct GNUNET_PSYC_Message *
 794       resp = GNUNET_PSYC_message_create ("_notice_place_admit", env,
 795                                          DATA2ARG ("Welcome, nym!"));
 796     GNUNET_SOCIAL_host_entry_decision (hst, nym, GNUNET_YES, resp);
 797     GNUNET_free (resp);
 798   }
 799   else if (opt_deny)
 800   {
 801     struct GNUNET_PSYC_Message *
 802       resp = GNUNET_PSYC_message_create ("_notice_place_refuse", NULL,
 803                                          DATA2ARG ("Go away!"));
 804     GNUNET_SOCIAL_host_entry_decision (hst, nym, GNUNET_NO, resp);
 805     GNUNET_free (resp);
 806   }
 807
 808
 809 }
 810
 811
 812 /**
 813  * Callback called when a @a nym has left the place.
 814  */
 815 static void
 816 host_farewell (void *cls,
 817                const struct GNUNET_SOCIAL_Nym *nym,
 818                struct GNUNET_PSYC_Environment *env)
 819 {
 820   const struct GNUNET_CRYPTO_EcdsaPublicKey *
 821     nym_key = GNUNET_SOCIAL_nym_get_pub_key (nym);
 822   char *
 823     nym_str = GNUNET_CRYPTO_ecdsa_public_key_to_string (nym_key);
 824
 825   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 826               "Farewell: %s\n", nym_str);
 827   GNUNET_free (nym_str);
 828 }
 829
 830
 831 /**
 832  * Callback called after the host entered the place.
 833  */
 834 static void
 835 host_entered (void *cls, int result,
 836               const struct GNUNET_CRYPTO_EddsaPublicKey *pub_key,
 837               uint64_t max_message_id)
 838 {
 839   place_pub_key = *pub_key;
 840   char *pub_str = GNUNET_CRYPTO_eddsa_public_key_to_string (pub_key);
 841   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 842               "Host entered: %s, max_message_id: %" PRIu64 "\n",
 843               pub_str, max_message_id);
 844   GNUNET_free (pub_str);
 845
 846   if (op_host_enter && !opt_follow)
 847   {
 848     exit_success ();
 849   }
 850 }
 851
 852
 853 /**
 854  * Enter and start hosting a place.
 855  */
 856 static void
 857 host_enter ()
 858 {
 859   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "host_enter()\n");
 860
 861   if (NULL == ego)
 862   {
 863     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "--ego missing or invalid\n");
 864     exit_fail ();
 865     return;
 866   }
 867
 868   hst = GNUNET_SOCIAL_host_enter (app, ego,
 869                                   GNUNET_PSYC_CHANNEL_PRIVATE,
 870                                   slicer_create (), host_entered,
 871                                   host_answer_door, host_farewell, NULL);
 872   plc = GNUNET_SOCIAL_host_get_place (hst);
 873 }
 874
 875
 876 /* PLACE RECONNECT */
 877
 878
 879 /**
 880  * Perform operations common to both host & guest places.
 881  */
 882 static void
 883 place_reconnected ()
 884 {
 885   static int first_run = GNUNET_YES;
 886   if (GNUNET_NO == first_run)
 887     return;
 888   first_run = GNUNET_NO;
 889
 890   if (op_replay) {
 891     history_replay (opt_start, opt_until, opt_method);
 892   }
 893   else if (op_replay_latest) {
 894     history_replay_latest (opt_limit, opt_method);
 895   }
 896   else if (op_look_at) {
 897     look_at (opt_name);
 898   }
 899   else if (op_look_for) {
 900     look_for (opt_name);
 901   }
 902 }
 903
 904
 905 /**
 906  * Callback called after reconnecting to a host place.
 907  */
 908 static void
 909 host_reconnected (void *cls, int result,
 910                   const struct GNUNET_CRYPTO_EddsaPublicKey *place_pub_key,
 911                   uint64_t max_message_id)
 912 {
 913   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 914               "Host reconnected.\n");
 915
 916   if (op_host_leave) {
 917     host_leave ();
 918   }
 919   else if (op_host_announce) {
 920     host_announce (opt_method, opt_data, strlen (opt_data));
 921   }
 922   else if (op_host_assign) {
 923     host_assign (opt_name, opt_data, strlen (opt_data) + 1);
 924   }
 925   else {
 926     place_reconnected ();
 927   }
 928 }
 929
 930
 931 /**
 932  * Callback called after reconnecting to a guest place.
 933  */
 934 static void
 935 guest_reconnected (void *cls, int result,
 936                    const struct GNUNET_CRYPTO_EddsaPublicKey *place_pub_key,
 937                    uint64_t max_message_id)
 938 {
 939   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 940               "Guest reconnected to place %s.\n", GNUNET_CRYPTO_eddsa_public_key_to_string(place_pub_key));
 941
 942   if (op_guest_leave) {
 943     guest_leave ();
 944   }
 945   else if (op_guest_talk) {
 946     guest_talk (opt_method, opt_data, strlen (opt_data));
 947   }
 948   else {
 949     place_reconnected ();
 950   }
 951 }
 952
 953
 954 /* APP */
 955
 956
 957 /**
 958  * Callback called after the ego and place callbacks.
 959  */
 960 static void
 961 app_connected (void *cls)
 962 {
 963   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 964               "App connected: %p\n", cls);
 965
 966   if (op_status)
 967   {
 968     exit_success ();
 969   }
 970   else if (op_host_enter)
 971   {
 972     host_enter ();
 973   }
 974   else if (op_guest_enter)
 975   {
 976     if (opt_gns)
 977     {
 978       guest_enter_by_name (opt_gns);
 979     }
 980     else
 981     {
 982       if (opt_peer)
 983       {
 984         if (GNUNET_OK != GNUNET_CRYPTO_eddsa_public_key_from_string (opt_peer,
 985                                                                      strlen (opt_peer),
 986                                                                      &peer.public_key))
 987         {
 988           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 989                       "--peer invalid");
 990           exit_fail ();
 991           return;
 992         }
 993       }
 994       else
 995       {
 996         peer = this_peer;
 997       }
 998       guest_enter (&place_pub_key, &peer);
 999     }
1000   }
1001 }
1002
1003
1004 /**
1005  * Callback notifying about a host place available for reconnection.
1006  */
1007 static void
1008 app_recv_host (void *cls,
1009                struct GNUNET_SOCIAL_HostConnection *hconn,
1010                struct GNUNET_SOCIAL_Ego *ego,
1011                const struct GNUNET_CRYPTO_EddsaPublicKey *host_pub_key,
1012                enum GNUNET_SOCIAL_AppPlaceState place_state)
1013 {
1014   char *host_pub_str = GNUNET_CRYPTO_eddsa_public_key_to_string (host_pub_key);
1015   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1016               "Host:  %s\n", host_pub_str);
1017   GNUNET_free (host_pub_str);
1018
1019   if ((op_host_reconnect || op_host_leave || op_host_announce || op_host_assign
1020        || op_replay || op_replay_latest
1021        || op_look_at || op_look_for)
1022       && 0 == memcmp (&place_pub_key, host_pub_key, sizeof (*host_pub_key)))
1023   {
1024     hst = GNUNET_SOCIAL_host_enter_reconnect (hconn, slicer_create (), host_reconnected,
1025                                               host_answer_door, host_farewell, NULL);
1026     plc = GNUNET_SOCIAL_host_get_place (hst);
1027   }
1028 }
1029
1030
1031 /**
1032  * Callback notifying about a guest place available for reconnection.
1033  */
1034 static void
1035 app_recv_guest (void *cls,
1036                 struct GNUNET_SOCIAL_GuestConnection *gconn,
1037                 struct GNUNET_SOCIAL_Ego *ego,
1038                 const struct GNUNET_CRYPTO_EddsaPublicKey *guest_pub_key,
1039                 enum GNUNET_SOCIAL_AppPlaceState place_state)
1040 {
1041   char *guest_pub_str = GNUNET_CRYPTO_eddsa_public_key_to_string (guest_pub_key);
1042   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1043               "Guest: %s\n", guest_pub_str);
1044   GNUNET_free (guest_pub_str);
1045
1046   if ((op_guest_reconnect || op_guest_leave || op_guest_talk
1047        || op_replay || op_replay_latest
1048        || op_look_at || op_look_for)
1049       && 0 == memcmp (&place_pub_key, guest_pub_key, sizeof (*guest_pub_key)))
1050   {
1051     gst = GNUNET_SOCIAL_guest_enter_reconnect (gconn, GNUNET_PSYC_SLAVE_JOIN_NONE,
1052                                                slicer_create (), guest_reconnected, NULL);
1053     plc = GNUNET_SOCIAL_guest_get_place (gst);
1054   }
1055 }
1056
1057
1058 /**
1059  * Callback notifying about an available ego.
1060  */
1061 static void
1062 app_recv_ego (void *cls,
1063               struct GNUNET_SOCIAL_Ego *e,
1064               const struct GNUNET_CRYPTO_EcdsaPublicKey *pub_key,
1065               const char *name)
1066 {
1067   char *s = GNUNET_CRYPTO_ecdsa_public_key_to_string (pub_key);
1068   GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Ego:   %s\t%s\n", s, name);
1069   GNUNET_free (s);
1070
1071   if (0 == memcmp (&ego_pub_key, pub_key, sizeof (*pub_key))
1072       || (NULL != opt_ego && 0 == strcmp (opt_ego, name)))
1073   {
1074     ego = e;
1075   }
1076
1077 }
1078
1079
1080
1081 /**
1082  * Establish application connection to receive available egos and places.
1083  */
1084 static void
1085 app_connect (void *cls)
1086 {
1087   GNUNET_CORE_disconnect (core);
1088   core = NULL;
1089
1090   app = GNUNET_SOCIAL_app_connect (cfg, opt_app,
1091                                    app_recv_ego,
1092                                    app_recv_host,
1093                                    app_recv_guest,
1094                                    app_connected,
1095                                    NULL);
1096 }
1097
1098
1099 /* CORE */
1100
1101
1102 static void
1103 core_connected (void *cls, const struct GNUNET_PeerIdentity *my_identity)
1104 {
1105   this_peer = *my_identity;
1106   GNUNET_SCHEDULER_add_now (app_connect, NULL);
1107 }
1108
1109
1110 /* RUN */
1111
1112
1113 /**
1114  * Main function run by the scheduler.
1115  *
1116  * @param cls closure
1117  * @param args remaining command-line arguments
1118  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
1119  * @param c configuration
1120  */
1121 static void
1122 run (void *cls, char *const *args, const char *cfgfile,
1123      const struct GNUNET_CONFIGURATION_Handle *c)
1124 {
1125   cfg = c;
1126
1127   if (!opt_method)
1128     opt_method = "message";
1129   if (!opt_data)
1130     opt_data = "";
1131   if (!opt_name)
1132     opt_name = "";
1133
1134   if (! (op_status
1135          || op_host_enter || op_host_reconnect || op_host_leave
1136          || op_host_announce || op_host_assign
1137          || op_guest_enter || op_guest_reconnect
1138          || op_guest_leave || op_guest_talk
1139          || op_replay || op_replay_latest
1140          || op_look_at || op_look_for))
1141   {
1142     op_status = 1;
1143   }
1144
1145   GNUNET_SCHEDULER_add_shutdown (scheduler_shutdown, NULL);
1146   if (!opt_follow)
1147   {
1148     timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, timeout, NULL);
1149   }
1150
1151   if ((op_host_reconnect || op_host_leave || op_host_announce || op_host_assign
1152        || op_guest_reconnect || (op_guest_enter && !opt_gns)
1153        || op_guest_leave || op_guest_talk
1154        || op_replay || op_replay_latest
1155        || op_look_at || op_look_for)
1156       && (!opt_place
1157           || GNUNET_OK != GNUNET_CRYPTO_eddsa_public_key_from_string (opt_place,
1158                                                                       strlen (opt_place),
1159                                                                       &place_pub_key)))
1160   {
1161     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1162                 _("--place missing or invalid.\n"));
1163     exit_fail ();
1164     return;
1165   }
1166
1167   if (opt_ego)
1168   {
1169     if (GNUNET_OK !=
1170         GNUNET_CRYPTO_ecdsa_public_key_from_string (opt_ego,
1171                                                 strlen (opt_ego),
1172                                                 &ego_pub_key))
1173     {
1174       FPRINTF (stderr,
1175                _("Public key `%s' malformed\n"),
1176                opt_ego);
1177       exit_fail ();
1178       return;
1179     }
1180   }
1181
1182   core = GNUNET_CORE_connect (cfg, NULL, &core_connected, NULL, NULL,
1183                               NULL, GNUNET_NO, NULL, GNUNET_NO, NULL);
1184 }
1185
1186
1187 /**
1188  * The main function to obtain peer information.
1189  *
1190  * @param argc number of arguments from the command line
1191  * @param argv command line arguments
1192  * @return 0 ok, 1 on error
1193  */
1194 int
1195 main (int argc, char *const *argv)
1196 {
1197   int res;
1198   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
1199     /*
1200      * gnunet program options in addition to the ones below:
1201      *
1202      * -c, --config=FILENAME
1203      * -l, --logfile=LOGFILE
1204      * -L, --log=LOGLEVEL
1205      * -h, --help
1206      * -v, --version
1207      */
1208
1209     /* operations */
1210
1211     { 'A', "host-assign", NULL,
1212       gettext_noop ("assign --name in state to --data"),
1213       GNUNET_NO, &GNUNET_GETOPT_set_one, &op_host_assign },
1214
1215     { 'B', "guest-leave", NULL,
1216       gettext_noop ("say good-bye and leave somebody else's place"),
1217       GNUNET_NO, &GNUNET_GETOPT_set_one, &op_guest_leave },
1218
1219     { 'C', "host-enter", NULL,
1220       gettext_noop ("create a place"),
1221       GNUNET_NO, &GNUNET_GETOPT_set_one, &op_host_enter },
1222
1223     { 'D', "host-leave", NULL,
1224       gettext_noop ("destroy a place we were hosting"),
1225       GNUNET_NO, &GNUNET_GETOPT_set_one, &op_host_leave },
1226
1227     { 'E', "guest-enter", NULL,
1228       gettext_noop ("enter somebody else's place"),
1229       GNUNET_NO, &GNUNET_GETOPT_set_one, &op_guest_enter },
1230
1231     { 'F', "look-for", NULL,
1232       gettext_noop ("find state matching name prefix"),
1233       GNUNET_NO, &GNUNET_GETOPT_set_one, &op_look_for },
1234
1235     { 'H', "replay-latest", NULL,
1236       gettext_noop ("replay history of messages up to the given --limit"),
1237       GNUNET_NO, &GNUNET_GETOPT_set_one, &op_replay_latest },
1238
1239     { 'N', "host-reconnect", NULL,
1240       gettext_noop ("reconnect to a previously created place"),
1241       GNUNET_NO, &GNUNET_GETOPT_set_one, &op_host_reconnect },
1242
1243     { 'P', "host-announce", NULL,
1244       gettext_noop ("publish something to a place we are hosting"),
1245       GNUNET_NO, &GNUNET_GETOPT_set_one, &op_host_announce },
1246
1247     { 'R', "guest-reconnect", NULL,
1248       gettext_noop ("reconnect to a previously entered place"),
1249       GNUNET_NO, &GNUNET_GETOPT_set_one, &op_guest_reconnect },
1250
1251     { 'S', "look-at", NULL,
1252       gettext_noop ("search for state matching exact name"),
1253       GNUNET_NO, &GNUNET_GETOPT_set_one, &op_look_at },
1254
1255     { 'T', "guest-talk", NULL,
1256       gettext_noop ("submit something to somebody's place"),
1257       GNUNET_NO, &GNUNET_GETOPT_set_one, &op_guest_talk },
1258
1259     { 'U', "status", NULL,
1260       gettext_noop ("list of egos and subscribed places"),
1261       GNUNET_NO, &GNUNET_GETOPT_set_one, &op_status },
1262
1263     { 'X', "replay", NULL,
1264       gettext_noop ("extract and replay history between message IDs --start and --until"),
1265       GNUNET_NO, &GNUNET_GETOPT_set_one, &op_replay },
1266
1267
1268     /* options */
1269
1270     { 'a', "app", "APPLICATION_ID",
1271       gettext_noop ("application ID to use when connecting"),
1272       GNUNET_YES, &GNUNET_GETOPT_set_string, &opt_app },
1273
1274     { 'd', "data", "DATA",
1275       gettext_noop ("message body or state value"),
1276       GNUNET_YES, &GNUNET_GETOPT_set_string, &opt_data },
1277
1278     { 'e', "ego", "NAME|PUBKEY",
1279       gettext_noop ("name or public key of ego"),
1280       GNUNET_YES, &GNUNET_GETOPT_set_string, &opt_ego },
1281
1282     { 'f', "follow", NULL,
1283       gettext_noop ("wait for incoming messages"),
1284       GNUNET_NO, &GNUNET_GETOPT_set_one, &opt_follow },
1285
1286     { 'g', "gns", "GNS_NAME",
1287       gettext_noop ("GNS name"),
1288       GNUNET_YES, &GNUNET_GETOPT_set_string, &opt_gns },
1289
1290     { 'i', "peer", "PEER_ID",
1291       gettext_noop ("peer ID for --guest-enter"),
1292       GNUNET_YES, &GNUNET_GETOPT_set_string, &opt_peer },
1293
1294     { 'k', "name", "VAR_NAME",
1295       gettext_noop ("name (key) to query from state"),
1296       GNUNET_YES, &GNUNET_GETOPT_set_string, &opt_name },
1297
1298     { 'm', "method", "METHOD_NAME",
1299       gettext_noop ("method name"),
1300       GNUNET_YES, &GNUNET_GETOPT_set_string, &opt_method },
1301
1302     { 'n', "limit", NULL,
1303       gettext_noop ("number of messages to replay from history"),
1304       GNUNET_YES, &GNUNET_GETOPT_set_ulong, &opt_limit },
1305
1306     { 'p', "place", "PUBKEY",
1307       gettext_noop ("key address of place"),
1308       GNUNET_YES, &GNUNET_GETOPT_set_string, &opt_place },
1309
1310     { 's', "start", NULL,
1311       gettext_noop ("start message ID for history replay"),
1312       GNUNET_YES, &GNUNET_GETOPT_set_ulong, &opt_start },
1313
1314     { 'w', "welcome", NULL,
1315       gettext_noop ("respond to entry requests by admitting all guests"),
1316       GNUNET_NO, &GNUNET_GETOPT_set_one, &opt_welcome },
1317
1318     { 'u', "until", NULL,
1319       gettext_noop ("end message ID for history replay"),
1320       GNUNET_YES, &GNUNET_GETOPT_set_ulong, &opt_until },
1321
1322     { 'y', "deny", NULL,
1323       gettext_noop ("respond to entry requests by refusing all guests"),
1324       GNUNET_NO, &GNUNET_GETOPT_set_one, &opt_deny },
1325
1326     GNUNET_GETOPT_OPTION_END
1327   };
1328
1329   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
1330     return 2;
1331
1332   const char *help =
1333     _ ("gnunet-social - Interact with the social service: enter/leave, send/receive messages, access history and state.\n");
1334   const char *usage =
1335     "gnunet-social [--status]\n"
1336     "\n"
1337     "gnunet-social --host-enter --ego <NAME or PUBKEY> [--follow] [--welcome | --deny]\n"
1338     "gnunet-social --host-reconnect --place <PUBKEY> [--follow] [--welcome | --deny]\n"
1339     "gnunet-social --host-leave --place <PUBKEY>\n"
1340     "gnunet-social --host-assign --place <PUBKEY> --name <NAME> --data <VALUE>\n"
1341 // FIXME: some state ops not implemented yet (no hurry)
1342 //  "gnunet-social --host-augment --place <PUBKEY> --name <NAME> --data <VALUE>\n"
1343 //  "gnunet-social --host-diminish --place <PUBKEY> --name <NAME> --data <VALUE>\n"
1344 //  "gnunet-social --host-set --place <PUBKEY> --name <NAME> --data <VALUE>\n"
1345     "gnunet-social --host-announce --place <PUBKEY> --method <METHOD_NAME> --data <MESSAGE_BODY>\n"
1346     "\n"
1347     "gnunet-social --guest-enter --place <PUBKEY> --peer <PEERID> --ego <NAME or PUBKEY> [--follow]\n"
1348     "gnunet-social --guest-enter --gns <GNS_NAME> --ego <NAME or PUBKEY> [--follow]\n"
1349     "gnunet-social --guest-reconnect --place <PUBKEY> [--follow]\n"
1350     "gnunet-social --guest-leave --place <PUBKEY>\n"
1351     "gnunet-social --guest-talk --place <PUBKEY> --method <METHOD_NAME> --data <MESSAGE_BODY>\n"
1352     "\n"
1353     "gnunet-social --history-replay --place <PUBKEY> --start <MSGID> --until <MSGID>  [--method <METHOD_PREFIX>]\n"
1354     "gnunet-social --history-replay-latest --place <PUBKEY> --limit <MSG_LIMIT> [--method <METHOD_PREFIX>]\n"
1355     "\n"
1356     "gnunet-social --look-at --place <PUBKEY> --name <FULL_NAME>\n"
1357     "gnunet-social --look-for --place <PUBKEY> --name <NAME_PREFIX>\n";
1358
1359   res = GNUNET_PROGRAM_run (argc, argv, help, usage, options, &run, NULL);
1360
1361   GNUNET_free ((void *) argv);
1362
1363   if (GNUNET_OK == res)
1364     return ret;
1365   else
1366     return 1;
1367 }