2 * This file is part of GNUnet
3 * Copyright (C) 2013 GNUnet e.V.
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.
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.
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.
22 * @file social/gnunet-service-social.c
23 * @brief Social service
24 * @author Gabor X Toth
31 #include "gnunet_util_lib.h"
32 #include "gnunet_constants.h"
33 #include "gnunet_protocols.h"
34 #include "gnunet_core_service.h"
35 #include "gnunet_identity_service.h"
36 #include "gnunet_namestore_service.h"
37 #include "gnunet_gns_service.h"
38 #include "gnunet_statistics_service.h"
39 #include "gnunet_psyc_service.h"
40 #include "gnunet_psyc_util_lib.h"
41 #include "gnunet_social_service.h"
46 * Handle to our current configuration.
48 static const struct GNUNET_CONFIGURATION_Handle *cfg;
50 /* Handles to other services */
51 static struct GNUNET_CORE_Handle *core;
52 static struct GNUNET_IDENTITY_Handle *id;
53 static struct GNUNET_GNS_Handle *gns;
54 static struct GNUNET_NAMESTORE_Handle *namestore;
55 static struct GNUNET_STATISTICS_Handle *stats;
60 static struct GNUNET_PeerIdentity this_peer;
63 * Notification context, simplifies client broadcasts.
65 static struct GNUNET_SERVER_NotificationContext *nc;
68 * All connected hosts.
69 * H(place_pub_key) -> struct Host
71 static struct GNUNET_CONTAINER_MultiHashMap *hosts;
74 * All connected guests.
75 * H(place_pub_key) -> struct Guest
77 static struct GNUNET_CONTAINER_MultiHashMap *guests;
80 * Connected guests per place.
81 * H(place_pub_key) -> ego_pub_key -> struct Guest
83 static struct GNUNET_CONTAINER_MultiHashMap *place_guests;
86 * Places entered as host or guest.
87 * H(place_pub_key) -> struct HostEnterRequest OR struct GuestEnterRequest
89 static struct GNUNET_CONTAINER_MultiHashMap *places;
92 * Places entered per application.
93 * H(app_id) -> H(place_pub_key) -> NULL
95 static struct GNUNET_CONTAINER_MultiHashMap *apps_places;
98 * Application subscriptions per place.
99 * H(place_pub_key) -> H(app_id)
101 static struct GNUNET_CONTAINER_MultiHashMap *places_apps;
104 * Connected applications.
105 * H(app_id) -> struct Application
107 static struct GNUNET_CONTAINER_MultiHashMap *apps;
111 * H(ego_pub_key) -> struct Ego
113 static struct GNUNET_CONTAINER_MultiHashMap *egos;
116 * Directory for storing social data.
117 * Default: $GNUNET_DATA_HOME/social
119 static char *dir_social;
122 * Directory for storing place data.
125 static char *dir_places;
128 * Directory for storing app data.
131 static char *dir_apps;
135 * Message fragment transmission queue.
137 struct FragmentTransmitQueue
139 struct FragmentTransmitQueue *prev;
140 struct FragmentTransmitQueue *next;
142 struct GNUNET_SERVER_Client *client;
145 * Pointer to the next message part inside the data after this struct.
147 struct GNUNET_MessageHeader *next_part;
155 * @see enum GNUNET_PSYC_MessageState
159 /* Followed by one or more message parts. */
164 * Message transmission queue.
166 struct MessageTransmitQueue
168 struct MessageTransmitQueue *prev;
169 struct MessageTransmitQueue *next;
171 struct FragmentTransmitQueue *frags_head;
172 struct FragmentTransmitQueue *frags_tail;
174 struct GNUNET_SERVER_Client *client;
178 * List of connected clients.
180 struct ClientListItem
182 struct ClientListItem *prev;
183 struct ClientListItem *next;
185 struct GNUNET_SERVER_Client *client;
190 * Common part of the client context for both a host and guest.
194 struct ClientListItem *clients_head;
195 struct ClientListItem *clients_tail;
197 struct MessageTransmitQueue *tmit_msgs_head;
198 struct MessageTransmitQueue *tmit_msgs_tail;
200 struct GNUNET_PSYC_Channel *channel;
203 * Private key of home in case of a host.
205 struct GNUNET_CRYPTO_EddsaPublicKey key;
208 * Public key of place.
210 struct GNUNET_CRYPTO_EddsaPublicKey pub_key;
213 * Hash of @a pub_key.
215 struct GNUNET_HashCode pub_key_hash;
218 * Private key of ego.
220 struct GNUNET_CRYPTO_EcdsaPrivateKey ego_key;
225 struct GNUNET_CRYPTO_EcdsaPublicKey ego_pub_key;
228 * Hash of @a ego_pub_key.
230 struct GNUNET_HashCode ego_pub_hash;
233 * Slicer for processing incoming messages.
235 struct GNUNET_PSYC_Slicer *slicer;
238 * Last message ID received for the place.
239 * 0 if there is no such message.
241 uint64_t max_message_id;
244 * Offset where the file is currently being written.
246 uint64_t file_offset;
249 * Whether or not to save the file (#GNUNET_YES or #GNUNET_NO)
254 * Is this a host (#GNUNET_YES), or guest (#GNUNET_NO)?
259 * Is this place ready to receive messages from client?
260 * #GNUNET_YES or #GNUNET_NO
265 * Is the client disconnected?
266 * #GNUNET_YES or #GNUNET_NO
268 uint8_t is_disconnected;
273 * Client context for a host.
278 * Place struct common for Host and Guest
283 * Handle for the multicast origin.
285 struct GNUNET_PSYC_Master *master;
288 * Transmit handle for multicast.
290 struct GNUNET_PSYC_MasterTransmitHandle *tmit_handle;
293 * Incoming join requests.
294 * guest_key -> struct GNUNET_PSYC_JoinHandle *
296 struct GNUNET_CONTAINER_MultiHashMap *join_reqs;
299 * Messages being relayed.
301 struct GNUNET_CONTAINER_MultiHashMap *relay_msgs;
304 * @see enum GNUNET_PSYC_Policy
306 enum GNUNET_PSYC_Policy policy;
311 * Client context for a guest.
316 * Place struct common for Host and Guest.
321 * Handle for the PSYC slave.
323 struct GNUNET_PSYC_Slave *slave;
326 * Transmit handle for multicast.
328 struct GNUNET_PSYC_SlaveTransmitHandle *tmit_handle;
331 * Peer identity of the origin.
333 struct GNUNET_PeerIdentity origin;
336 * Number of items in @a relays.
338 uint32_t relay_count;
341 * Relays that multicast can use to connect.
343 struct GNUNET_PeerIdentity *relays;
346 * Join request to be transmitted to the master on join.
348 struct GNUNET_MessageHeader *join_req;
351 * Join decision received from PSYC.
353 struct GNUNET_PSYC_JoinDecisionMessage *join_dcsn;
356 * Join flags for the PSYC service.
358 enum GNUNET_PSYC_SlaveJoinFlags join_flags;
363 * Context for a client.
368 * Place where the client entered.
373 * Message queue for the message currently being transmitted
376 struct MessageTransmitQueue *tmit_msg;
379 * ID for application clients.
387 struct ClientListItem *clients_head;
388 struct ClientListItem *clients_tail;
393 struct GNUNET_CRYPTO_EcdsaPrivateKey key;
398 struct OperationClosure
400 struct GNUNET_SERVER_Client *client;
408 psyc_transmit_message (struct Place *plc);
412 * Clean up place data structures after a client disconnected.
414 * @param cls the `struct Place` to clean up
417 cleanup_place (void *cls);
420 static struct MessageTransmitQueue *
421 psyc_transmit_queue_message (struct Place *plc,
422 struct GNUNET_SERVER_Client *client,
425 uint16_t first_ptype, uint16_t last_ptype,
426 struct MessageTransmitQueue *tmit_msg);
430 place_entry_cleanup (void *cls,
431 const struct GNUNET_HashCode *key,
434 struct Place *plc = value;
442 * Task run during shutdown.
447 shutdown_task (void *cls)
449 GNUNET_CONTAINER_multihashmap_iterate (hosts, place_entry_cleanup, NULL);
450 GNUNET_CONTAINER_multihashmap_iterate (guests, place_entry_cleanup, NULL);
454 GNUNET_SERVER_notification_context_destroy (nc);
459 GNUNET_CORE_disconnecT (core);
464 GNUNET_IDENTITY_disconnect (id);
467 if (NULL != namestore)
469 GNUNET_NAMESTORE_disconnect (namestore);
474 GNUNET_GNS_disconnect (gns);
479 GNUNET_STATISTICS_destroy (stats, GNUNET_YES);
486 * Clean up host data structures after a client disconnected.
489 cleanup_host (struct Host *hst)
491 struct Place *plc = &hst->plc;
493 if (NULL != hst->master)
494 GNUNET_PSYC_master_stop (hst->master, GNUNET_NO, NULL, NULL); // FIXME
495 GNUNET_CONTAINER_multihashmap_destroy (hst->join_reqs);
496 GNUNET_CONTAINER_multihashmap_destroy (hst->relay_msgs);
497 GNUNET_CONTAINER_multihashmap_remove (hosts, &plc->pub_key_hash, plc);
502 * Clean up guest data structures after a client disconnected.
505 cleanup_guest (struct Guest *gst)
507 struct Place *plc = &gst->plc;
508 struct GNUNET_CONTAINER_MultiHashMap *
509 plc_gst = GNUNET_CONTAINER_multihashmap_get (place_guests,
511 GNUNET_assert (NULL != plc_gst); // FIXME
512 GNUNET_CONTAINER_multihashmap_remove (plc_gst, &plc->ego_pub_hash, gst);
514 if (0 == GNUNET_CONTAINER_multihashmap_size (plc_gst))
516 GNUNET_CONTAINER_multihashmap_remove (place_guests, &plc->pub_key_hash,
518 GNUNET_CONTAINER_multihashmap_destroy (plc_gst);
520 GNUNET_CONTAINER_multihashmap_remove (guests, &plc->pub_key_hash, gst);
522 if (NULL != gst->join_req)
523 GNUNET_free (gst->join_req);
524 if (NULL != gst->relays)
525 GNUNET_free (gst->relays);
526 if (NULL != gst->slave)
527 GNUNET_PSYC_slave_part (gst->slave, GNUNET_NO, NULL, NULL); // FIXME
528 GNUNET_CONTAINER_multihashmap_remove (guests, &plc->pub_key_hash, plc);
533 * Clean up place data structures after a client disconnected.
535 * @param cls the `struct Place` to clean up
538 cleanup_place (void *cls)
540 struct Place *plc = cls;
542 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
543 "%p Cleaning up place %s\n",
544 plc, GNUNET_h2s (&plc->pub_key_hash));
546 (GNUNET_YES == plc->is_host)
547 ? cleanup_host ((struct Host *) plc)
548 : cleanup_guest ((struct Guest *) plc);
550 GNUNET_PSYC_slicer_destroy (plc->slicer);
556 * Called whenever a client is disconnected.
557 * Frees our resources associated with that client.
559 * @param cls Closure.
560 * @param client Identification of the client.
563 client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
569 ctx = GNUNET_SERVER_client_get_user_context (client, struct Client);
572 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
573 "%p User context is NULL in client_disconnect()\n", ctx);
577 struct Place *plc = ctx->plc;
579 if (NULL != ctx->app_id)
580 GNUNET_free (ctx->app_id);
585 return; // application client, nothing to do
587 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
588 "%p Client (%s) disconnected from place %s\n",
589 plc, (GNUNET_YES == plc->is_host) ? "host" : "guest",
590 GNUNET_h2s (&plc->pub_key_hash));
592 struct ClientListItem *cli = plc->clients_head;
595 if (cli->client == client)
597 GNUNET_CONTAINER_DLL_remove (plc->clients_head, plc->clients_tail, cli);
607 * Send message to a client.
610 client_send_msg (struct GNUNET_SERVER_Client *client,
611 const struct GNUNET_MessageHeader *msg)
613 GNUNET_SERVER_notification_context_add (nc, client);
614 GNUNET_SERVER_notification_context_unicast (nc, client, msg, GNUNET_NO);
619 * Send message to all clients connected to a place.
622 place_send_msg (const struct Place *plc,
623 const struct GNUNET_MessageHeader *msg)
625 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
626 "%p Sending message to clients of place.\n", plc);
628 struct ClientListItem *cli = plc->clients_head;
631 client_send_msg (cli->client, msg);
638 * Send a result code back to the client.
641 * Client that should receive the result code.
645 * Operation ID in network byte order.
647 * Data payload or NULL.
652 client_send_result (struct GNUNET_SERVER_Client *client, uint64_t op_id,
653 int64_t result_code, const void *data, uint16_t data_size)
655 struct GNUNET_OperationResultMessage *res;
657 res = GNUNET_malloc (sizeof (*res) + data_size);
658 res->header.type = htons (GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE);
659 res->header.size = htons (sizeof (*res) + data_size);
660 res->result_code = GNUNET_htonll (result_code);
663 GNUNET_memcpy (&res[1], data, data_size);
665 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
666 "%p Sending result to client for operation #%" PRIu64 ": "
667 "%" PRId64 " (size: %u)\n",
668 client, GNUNET_ntohll (op_id), result_code, data_size);
670 client_send_msg (client, &res->header);
676 client_send_host_enter_ack (struct GNUNET_SERVER_Client *client,
677 struct Host *hst, uint32_t result)
679 struct Place *plc = &hst->plc;
681 struct HostEnterAck hack;
682 hack.header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER_ACK);
683 hack.header.size = htons (sizeof (hack));
684 hack.result_code = htonl (result);
685 hack.max_message_id = GNUNET_htonll (plc->max_message_id);
686 hack.place_pub_key = plc->pub_key;
689 client_send_msg (client, &hack.header);
691 place_send_msg (plc, &hack.header);
696 * Called after a PSYC master is started.
699 psyc_master_started (void *cls, int result, uint64_t max_message_id)
701 struct Host *hst = cls;
702 struct Place *plc = &hst->plc;
703 plc->max_message_id = max_message_id;
704 plc->is_ready = GNUNET_YES;
706 client_send_host_enter_ack (NULL, hst, result);
711 * Called when a PSYC master receives a join request.
714 psyc_recv_join_request (void *cls,
715 const struct GNUNET_PSYC_JoinRequestMessage *req,
716 const struct GNUNET_CRYPTO_EcdsaPublicKey *slave_key,
717 const struct GNUNET_PSYC_Message *join_msg,
718 struct GNUNET_PSYC_JoinHandle *jh)
720 struct Host *hst = cls;
721 struct GNUNET_HashCode slave_key_hash;
722 GNUNET_CRYPTO_hash (slave_key, sizeof (*slave_key), &slave_key_hash);
723 GNUNET_CONTAINER_multihashmap_put (hst->join_reqs, &slave_key_hash, jh,
724 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
725 place_send_msg (&hst->plc, &req->header);
730 * Called after a PSYC slave is connected.
733 psyc_slave_connected (void *cls, int result, uint64_t max_message_id)
735 struct Guest *gst = cls;
736 struct Place *plc = &gst->plc;
737 plc->max_message_id = max_message_id;
738 plc->is_ready = GNUNET_YES;
740 struct GNUNET_PSYC_CountersResultMessage res;
741 res.header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_ACK);
742 res.header.size = htons (sizeof (res));
743 res.result_code = htonl (result);
744 res.max_message_id = GNUNET_htonll (plc->max_message_id);
746 place_send_msg (plc, &res.header);
751 * Called when a PSYC slave receives a join decision.
754 psyc_recv_join_dcsn (void *cls,
755 const struct GNUNET_PSYC_JoinDecisionMessage *dcsn,
757 const struct GNUNET_PSYC_Message *join_msg)
759 struct Guest *gst = cls;
760 place_send_msg (&gst->plc, &dcsn->header);
765 * Called when a PSYC master or slave receives a message.
768 psyc_recv_message (void *cls,
769 const struct GNUNET_PSYC_MessageHeader *msg)
771 struct Place *plc = cls;
773 char *str = GNUNET_CRYPTO_ecdsa_public_key_to_string (&msg->slave_pub_key);
774 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
775 "%p Received PSYC message of size %u from %s.\n",
776 plc, ntohs (msg->header.size), str);
779 GNUNET_PSYC_slicer_message (plc->slicer, msg);
781 place_send_msg (plc, &msg->header);
786 * Relay a message part received from a guest to the the place.
793 * Nym the message is received from.
796 host_relay_message_part (struct Host *hst,
797 const struct GNUNET_MessageHeader *pmsg,
798 const struct GNUNET_CRYPTO_EcdsaPublicKey *nym_pub_key)
800 /* separate queue per nym */
801 struct GNUNET_HashCode nym_pub_hash;
802 GNUNET_CRYPTO_hash (nym_pub_key, sizeof (*nym_pub_key), &nym_pub_hash);
804 struct MessageTransmitQueue *
805 tmit_msg = GNUNET_CONTAINER_multihashmap_get (hst->relay_msgs, &nym_pub_hash);
807 uint16_t ptype = ntohs (pmsg->type);
809 if (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD == ptype)
811 /* FIXME: last message was unfinished, cancel & remove from queue */
812 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
813 "FIXME: last message was unfinished.\n");
816 tmit_msg = psyc_transmit_queue_message (&hst->plc, NULL, ntohs (pmsg->size),
817 pmsg, ptype, ptype, tmit_msg);
821 case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD:
822 GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multihashmap_put
823 (hst->relay_msgs, &nym_pub_hash, tmit_msg,
824 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
826 case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END:
827 case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL:
828 GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove
829 (hst->relay_msgs, &nym_pub_hash, tmit_msg));
836 * Received a method to be relayed from a guest.
839 place_recv_relay_method (void *cls,
840 const struct GNUNET_PSYC_MessageHeader *msg,
841 const struct GNUNET_PSYC_MessageMethod *meth,
843 const char *method_name)
845 struct Place *plc = cls;
847 if (GNUNET_PSYC_MESSAGE_REQUEST & ntohs (msg->flags)
848 && GNUNET_YES == plc->is_host)
850 struct Host *hst = cls;
851 host_relay_message_part (hst, &meth->header, &msg->slave_pub_key);
857 * Received a modifier to be relayed from a guest.
860 place_recv_relay_modifier (void *cls,
861 const struct GNUNET_PSYC_MessageHeader *msg,
862 const struct GNUNET_MessageHeader *pmsg,
864 enum GNUNET_PSYC_Operator oper,
868 uint16_t full_value_size)
870 struct Place *plc = cls;
872 if (GNUNET_PSYC_MESSAGE_REQUEST & ntohs (msg->flags)
873 && GNUNET_YES == plc->is_host)
875 struct Host *hst = cls;
876 host_relay_message_part (hst, pmsg, &msg->slave_pub_key);
881 * Received a data fragment to be relayed from a guest.
884 place_recv_relay_data (void *cls,
885 const struct GNUNET_PSYC_MessageHeader *msg,
886 const struct GNUNET_MessageHeader *pmsg,
891 struct Place *plc = cls;
893 if (GNUNET_PSYC_MESSAGE_REQUEST & ntohs (msg->flags)
894 && GNUNET_YES == plc->is_host)
896 struct Host *hst = cls;
897 host_relay_message_part (hst, pmsg, &msg->slave_pub_key);
903 * Received end of message to be relayed from a guest.
906 place_recv_relay_eom (void *cls,
907 const struct GNUNET_PSYC_MessageHeader *msg,
908 const struct GNUNET_MessageHeader *pmsg,
910 uint8_t is_cancelled)
912 struct Place *plc = cls;
914 if (GNUNET_PSYC_MESSAGE_REQUEST & ntohs (msg->flags)
915 && GNUNET_YES == plc->is_host)
917 struct Host *hst = cls;
918 host_relay_message_part (hst, pmsg, &msg->slave_pub_key);
924 * Received a method to be saved to disk.
926 * Create a new file for writing the data part of the message into,
927 * if the file does not yet exist.
930 place_recv_save_method (void *cls,
931 const struct GNUNET_PSYC_MessageHeader *msg,
932 const struct GNUNET_PSYC_MessageMethod *meth,
934 const char *method_name)
936 struct Place *plc = cls;
937 plc->file_offset = 0;
938 plc->file_save = GNUNET_NO;
940 char *place_pub_str = GNUNET_CRYPTO_eddsa_public_key_to_string (&plc->pub_key);
941 char *filename = NULL;
942 GNUNET_asprintf (&filename, "%s%c" "%s%c" "%s%c" "%" PRIu64 ".part",
943 dir_social, DIR_SEPARATOR,
944 "files", DIR_SEPARATOR,
945 place_pub_str, DIR_SEPARATOR,
946 GNUNET_ntohll (msg->message_id));
947 GNUNET_free (place_pub_str);
949 /* save if does not already exist */
950 if (GNUNET_YES != GNUNET_DISK_file_test (filename))
952 if (0 == GNUNET_DISK_fn_write (filename, NULL, 0,
953 GNUNET_DISK_PERM_USER_READ
954 | GNUNET_DISK_PERM_USER_WRITE))
956 plc->file_save = GNUNET_YES;
963 GNUNET_free (filename);
968 * Received a data fragment to be saved to disk.
970 * Append data fragment to the file.
973 place_recv_save_data (void *cls,
974 const struct GNUNET_PSYC_MessageHeader *msg,
975 const struct GNUNET_MessageHeader *pmsg,
980 struct Place *plc = cls;
981 if (GNUNET_YES != plc->file_save)
984 char *place_pub_str = GNUNET_CRYPTO_eddsa_public_key_to_string (&plc->pub_key);
985 char *filename = NULL;
986 GNUNET_asprintf (&filename, "%s%c" "%s%c" "%s%c" "%" PRIu64 ".part",
987 dir_social, DIR_SEPARATOR,
988 "files", DIR_SEPARATOR,
989 place_pub_str, DIR_SEPARATOR,
990 GNUNET_ntohll (msg->message_id));
991 GNUNET_free (place_pub_str);
992 if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename))
994 GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "create", filename);
995 GNUNET_free (filename);
999 struct GNUNET_DISK_FileHandle *
1000 fh = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_WRITE,
1001 GNUNET_DISK_PERM_NONE);
1004 if (plc->file_offset != GNUNET_DISK_file_seek
1005 (fh, plc->file_offset, GNUNET_DISK_SEEK_SET)) {
1006 GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "seek", filename);
1007 GNUNET_DISK_file_close (fh);
1008 GNUNET_free (filename);
1011 GNUNET_DISK_file_write (fh, data, data_size);
1012 GNUNET_DISK_file_close (fh);
1013 GNUNET_free (filename);
1017 GNUNET_free (filename);
1020 plc->file_offset += data_size;
1025 * Received end of message to be saved to disk.
1027 * Remove .part ending from the filename.
1030 place_recv_save_eom (void *cls,
1031 const struct GNUNET_PSYC_MessageHeader *msg,
1032 const struct GNUNET_MessageHeader *pmsg,
1033 uint64_t message_id,
1034 uint8_t is_cancelled)
1036 struct Place *plc = cls;
1037 if (GNUNET_YES != plc->file_save)
1040 char *place_pub_str = GNUNET_CRYPTO_eddsa_public_key_to_string (&plc->pub_key);
1042 GNUNET_asprintf (&fn, "%s%c%s%c%s%c%" PRIu64,
1043 dir_social, DIR_SEPARATOR,
1044 "files", DIR_SEPARATOR,
1045 place_pub_str, DIR_SEPARATOR,
1046 GNUNET_ntohll (msg->message_id));
1047 GNUNET_free (place_pub_str);
1048 char *fn_part = NULL;
1049 GNUNET_asprintf (&fn_part, "%s.part", fn);
1051 if (rename (fn_part, fn)) {
1052 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1053 "Failed to rename %s into %s: %s (%d)\n",
1054 fn_part, fn, strerror (errno), errno);
1058 GNUNET_free (fn_part);
1063 * Initialize place data structure.
1066 place_init (struct Place *plc)
1068 plc->slicer = GNUNET_PSYC_slicer_create ();
1073 * Add a place to the @e places hash map.
1078 * @return #GNUNET_OK if the place was added
1079 * #GNUNET_NO if the place already exists in the hash map
1080 * #GNUNET_SYSERR on error
1083 place_add (const struct PlaceEnterRequest *ereq)
1085 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1086 "Adding place to hashmap:\n");
1088 struct EgoPlacePublicKey ego_place_pub_key = {
1089 .ego_pub_key = ereq->ego_pub_key,
1090 .place_pub_key = ereq->place_pub_key,
1092 struct GNUNET_HashCode ego_place_pub_hash;
1093 GNUNET_CRYPTO_hash (&ego_place_pub_key, sizeof (ego_place_pub_key), &ego_place_pub_hash);
1095 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1096 " ego_place_pub_hash = %s\n", GNUNET_h2s (&ego_place_pub_hash));
1098 struct GNUNET_MessageHeader *
1099 place_msg = GNUNET_CONTAINER_multihashmap_get (places, &ego_place_pub_hash);
1100 if (NULL != place_msg)
1103 place_msg = GNUNET_copy_message (&ereq->header);
1104 if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (places, &ego_place_pub_hash, place_msg,
1105 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
1108 GNUNET_free (place_msg);
1109 return GNUNET_SYSERR;
1116 * Add a place to the @e app_places hash map.
1123 * @return #GNUNET_OK if the place was added
1124 * #GNUNET_NO if the place already exists in the hash map
1125 * #GNUNET_SYSERR on error
1128 app_place_add (const char *app_id,
1129 const struct PlaceEnterRequest *ereq)
1131 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1132 "Adding app place to hashmap:\n");
1133 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1134 " app_id = %s\n", app_id);
1136 struct GNUNET_HashCode app_id_hash;
1137 GNUNET_CRYPTO_hash (app_id, strlen (app_id) + 1, &app_id_hash);
1139 struct EgoPlacePublicKey ego_place_pub_key = {
1140 .ego_pub_key = ereq->ego_pub_key,
1141 .place_pub_key = ereq->place_pub_key,
1143 struct GNUNET_HashCode ego_place_pub_hash;
1144 GNUNET_CRYPTO_hash (&ego_place_pub_key, sizeof (ego_place_pub_key), &ego_place_pub_hash);
1146 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1147 " ego_place_pub_hash = %s\n", GNUNET_h2s (&ego_place_pub_hash));
1149 struct GNUNET_CONTAINER_MultiHashMap *
1150 app_places = GNUNET_CONTAINER_multihashmap_get (apps_places, &app_id_hash);
1151 if (NULL == app_places)
1153 app_places = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
1154 GNUNET_CONTAINER_multihashmap_put (apps_places, &app_id_hash, app_places,
1155 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
1158 if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (app_places, &ego_place_pub_hash))
1161 if (GNUNET_SYSERR == place_add (ereq))
1162 return GNUNET_SYSERR;
1164 if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (app_places, &ego_place_pub_hash, NULL,
1165 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
1168 return GNUNET_SYSERR;
1171 struct GNUNET_HashCode place_pub_hash;
1172 GNUNET_CRYPTO_hash (&ereq->place_pub_key, sizeof (ereq->place_pub_key), &place_pub_hash);
1174 struct GNUNET_CONTAINER_MultiHashMap *
1175 place_apps = GNUNET_CONTAINER_multihashmap_get (places_apps, &place_pub_hash);
1176 if (NULL == place_apps)
1178 place_apps = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
1179 if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (places_apps, &place_pub_hash, place_apps,
1180 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
1186 size_t app_id_size = strlen (app_id) + 1;
1187 void *app_id_value = GNUNET_malloc (app_id_size);
1188 GNUNET_memcpy (app_id_value, app_id, app_id_size);
1190 if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (place_apps, &app_id_hash, app_id_value,
1191 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
1201 * Save place entry message to disk.
1206 * Entry request message.
1209 app_place_save (const char *app_id,
1210 const struct PlaceEnterRequest *ereq)
1212 app_place_add (app_id, ereq);
1214 if (NULL == dir_places)
1215 return GNUNET_SYSERR;
1217 char *ego_pub_str = GNUNET_CRYPTO_ecdsa_public_key_to_string (&ereq->ego_pub_key);
1218 char *place_pub_str = GNUNET_CRYPTO_eddsa_public_key_to_string (&ereq->place_pub_key);
1219 char *filename = NULL;
1220 GNUNET_asprintf (&filename, "%s%c" "%s%c" "%s%c" "%s",
1221 dir_social, DIR_SEPARATOR,
1222 "places", DIR_SEPARATOR,
1223 ego_pub_str, DIR_SEPARATOR,
1225 int ret = GNUNET_DISK_directory_create_for_file (filename);
1226 if (GNUNET_OK != ret
1227 || 0 > GNUNET_DISK_fn_write (filename, ereq, ntohs (ereq->header.size),
1228 GNUNET_DISK_PERM_USER_READ
1229 | GNUNET_DISK_PERM_USER_WRITE))
1232 ret = GNUNET_SYSERR;
1234 GNUNET_free (filename);
1236 if (ret == GNUNET_OK)
1238 GNUNET_asprintf (&filename, "%s%c" "%s%c" "%s%c" "%s%c" "%s",
1239 dir_social, DIR_SEPARATOR,
1240 "apps", DIR_SEPARATOR,
1241 app_id, DIR_SEPARATOR,
1242 ego_pub_str, DIR_SEPARATOR,
1244 ret = GNUNET_DISK_directory_create_for_file (filename);
1245 if (GNUNET_OK != ret
1246 || 0 > GNUNET_DISK_fn_write (filename, "", 0,
1247 GNUNET_DISK_PERM_USER_READ
1248 | GNUNET_DISK_PERM_USER_WRITE))
1251 ret = GNUNET_SYSERR;
1253 GNUNET_free (filename);
1255 GNUNET_free (ego_pub_str);
1256 GNUNET_free (place_pub_str);
1262 app_place_remove (const char *app_id,
1263 const struct GNUNET_CRYPTO_EcdsaPublicKey *ego_pub_key,
1264 const struct GNUNET_CRYPTO_EddsaPublicKey *place_pub_key)
1266 struct GNUNET_HashCode ego_pub_hash;
1267 struct GNUNET_HashCode place_pub_hash;
1268 GNUNET_CRYPTO_hash (ego_pub_key, sizeof (*ego_pub_key), &ego_pub_hash);
1269 GNUNET_CRYPTO_hash (place_pub_key, sizeof (*place_pub_key), &place_pub_hash);
1271 char *ego_pub_str = GNUNET_CRYPTO_ecdsa_public_key_to_string (ego_pub_key);
1272 char *place_pub_str = GNUNET_CRYPTO_eddsa_public_key_to_string (place_pub_key);
1273 char *app_place_filename = NULL;
1274 GNUNET_asprintf (&app_place_filename,
1275 "%s%c" "%s%c" "%s%c" "%s%c" "%s",
1276 dir_social, DIR_SEPARATOR,
1277 "apps", DIR_SEPARATOR,
1278 app_id, DIR_SEPARATOR,
1279 ego_pub_str, DIR_SEPARATOR,
1281 GNUNET_free (ego_pub_str);
1282 GNUNET_free (place_pub_str);
1284 struct GNUNET_HashCode app_id_hash;
1285 GNUNET_CRYPTO_hash (app_id, strlen (app_id) + 1, &app_id_hash);
1287 struct GNUNET_CONTAINER_MultiHashMap *
1288 app_places = GNUNET_CONTAINER_multihashmap_get (apps_places, &app_id_hash);
1290 if (NULL != app_places)
1291 GNUNET_CONTAINER_multihashmap_remove (app_places, &place_pub_hash, NULL);
1293 struct GNUNET_CONTAINER_MultiHashMap *
1294 place_apps = GNUNET_CONTAINER_multihashmap_get (places_apps, &place_pub_hash);
1295 if (NULL != place_apps)
1297 void *app_id_value = GNUNET_CONTAINER_multihashmap_get (place_apps, &app_id_hash);
1298 if (NULL != app_id_value)
1300 GNUNET_CONTAINER_multihashmap_remove (place_apps, &app_id_hash, app_id_value);
1301 GNUNET_free (app_id_value);
1305 int ret = GNUNET_OK;
1307 if (0 != unlink (app_place_filename))
1310 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1311 "Error removing app place file: %s: %s (%d)\n",
1312 app_place_filename, strerror (errno), errno);
1313 ret = GNUNET_SYSERR;
1315 GNUNET_free (app_place_filename);
1322 * Enter place as host.
1325 * Host entry request.
1326 * @param[out] ret_hst
1327 * Returned Host struct.
1329 * @return #GNUNET_YES if the host entered the place just now,
1330 * #GNUNET_NO if the place is already entered,
1331 * #GNUNET_SYSERR if place_pub_key was set
1332 * but its private key was not found
1335 host_enter (const struct HostEnterRequest *hreq, struct Host **ret_hst)
1337 int ret = GNUNET_NO;
1338 struct GNUNET_HashCode place_pub_hash;
1339 GNUNET_CRYPTO_hash (&hreq->place_pub_key, sizeof (hreq->place_pub_key),
1341 struct Host *hst = GNUNET_CONTAINER_multihashmap_get (hosts, &place_pub_hash);
1345 hst = GNUNET_new (struct Host);
1346 hst->policy = hreq->policy;
1347 hst->join_reqs = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
1348 hst->relay_msgs = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
1350 struct Place *plc = &hst->plc;
1352 plc->is_host = GNUNET_YES;
1353 plc->pub_key = hreq->place_pub_key;
1354 plc->pub_key_hash = place_pub_hash;
1356 GNUNET_CONTAINER_multihashmap_put (hosts, &plc->pub_key_hash, plc,
1357 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
1358 hst->master = GNUNET_PSYC_master_start (cfg, &hreq->place_key, hst->policy,
1359 &psyc_master_started,
1360 &psyc_recv_join_request,
1361 &psyc_recv_message, NULL, hst);
1362 plc->channel = GNUNET_PSYC_master_get_channel (hst->master);
1366 if (NULL != ret_hst)
1372 const struct MsgProcRequest *
1373 msg_proc_parse (const struct GNUNET_MessageHeader *msg,
1375 const char **method_prefix,
1376 struct GNUNET_HashCode *method_hash)
1378 const struct MsgProcRequest *mpreq = (const struct MsgProcRequest *) msg;
1379 uint8_t method_size = ntohs (mpreq->header.size) - sizeof (*mpreq);
1380 uint16_t offset = GNUNET_STRINGS_buffer_tokenize ((const char *) &mpreq[1],
1381 method_size, 1, method_prefix);
1383 if (0 == offset || offset != method_size || *method_prefix == NULL)
1385 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1386 "offset = %u, method_size = %u, method_name = %s\n",
1387 offset, method_size, *method_prefix);
1391 GNUNET_CRYPTO_hash (*method_prefix, method_size, method_hash);
1392 *flags = ntohl (mpreq->flags);
1398 * Handle a client setting message proccesing flags for a method prefix.
1401 client_recv_msg_proc_set (void *cls, struct GNUNET_SERVER_Client *client,
1402 const struct GNUNET_MessageHeader *msg)
1405 ctx = GNUNET_SERVER_client_get_user_context (client, struct Client);
1406 GNUNET_assert (NULL != ctx);
1407 struct Place *plc = ctx->plc;
1409 const char *method_prefix = NULL;
1411 struct GNUNET_HashCode method_hash;
1412 const struct MsgProcRequest *
1413 mpreq = msg_proc_parse (msg, &flags, &method_prefix, &method_hash);
1415 if (NULL == mpreq) {
1417 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1421 GNUNET_PSYC_slicer_method_remove (plc->slicer, method_prefix,
1422 place_recv_relay_method,
1423 place_recv_relay_modifier,
1424 place_recv_relay_data,
1425 place_recv_relay_eom);
1426 GNUNET_PSYC_slicer_method_remove (plc->slicer, method_prefix,
1427 place_recv_save_method,
1429 place_recv_save_data,
1430 place_recv_save_eom);
1432 if (flags & GNUNET_SOCIAL_MSG_PROC_RELAY)
1434 GNUNET_PSYC_slicer_method_add (plc->slicer, method_prefix, NULL,
1435 place_recv_relay_method,
1436 place_recv_relay_modifier,
1437 place_recv_relay_data,
1438 place_recv_relay_eom,
1441 if (flags & GNUNET_SOCIAL_MSG_PROC_SAVE)
1443 GNUNET_PSYC_slicer_method_add (plc->slicer, method_prefix, NULL,
1444 place_recv_save_method,
1446 place_recv_save_data,
1447 place_recv_save_eom,
1451 /** @todo Save flags to be able to resume relaying/saving after restart */
1453 GNUNET_SERVER_receive_done (client, GNUNET_OK);
1458 * Handle a connecting client requesting to clear all relay rules.
1461 client_recv_msg_proc_clear (void *cls, struct GNUNET_SERVER_Client *client,
1462 const struct GNUNET_MessageHeader *msg)
1465 ctx = GNUNET_SERVER_client_get_user_context (client, struct Client);
1466 GNUNET_assert (NULL != ctx);
1467 struct Place *plc = ctx->plc;
1468 if (GNUNET_YES != plc->is_host) {
1470 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1473 GNUNET_PSYC_slicer_clear (plc->slicer);
1475 GNUNET_SERVER_receive_done (client, GNUNET_OK);
1480 * Handle a connecting client entering a place as host.
1483 client_recv_host_enter (void *cls, struct GNUNET_SERVER_Client *client,
1484 const struct GNUNET_MessageHeader *msg)
1486 struct HostEnterRequest *hreq
1487 = (struct HostEnterRequest *) GNUNET_copy_message (msg);
1489 uint8_t app_id_size = ntohs (hreq->header.size) - sizeof (*hreq);
1490 const char *app_id = NULL;
1491 uint16_t offset = GNUNET_STRINGS_buffer_tokenize ((const char *) &hreq[1],
1492 app_id_size, 1, &app_id);
1493 if (0 == offset || offset != app_id_size || app_id == NULL)
1495 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1496 "offset = %u, app_id_size = %u, app_id = %s\n",
1497 offset, app_id_size, app_id);
1499 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1503 struct Host *hst = NULL;
1504 struct Place *plc = NULL;
1505 int ret = GNUNET_OK;
1507 struct GNUNET_CRYPTO_EddsaPublicKey empty_pub_key;
1508 memset (&empty_pub_key, 0, sizeof (empty_pub_key));
1510 if (0 == memcmp (&hreq->place_pub_key, &empty_pub_key, sizeof (empty_pub_key)))
1511 { // no public key set: create new private key & save the place
1512 struct GNUNET_CRYPTO_EddsaPrivateKey *
1513 place_key = GNUNET_CRYPTO_eddsa_key_create ();
1514 hreq->place_key = *place_key;
1515 GNUNET_CRYPTO_eddsa_key_get_public (place_key, &hreq->place_pub_key);
1516 GNUNET_CRYPTO_eddsa_key_clear (place_key);
1517 GNUNET_free (place_key);
1519 app_place_save (app_id, (const struct PlaceEnterRequest *) hreq);
1522 switch (host_enter (hreq, &hst))
1531 client_send_host_enter_ack (client, hst, GNUNET_OK);
1535 ret = GNUNET_SYSERR;
1538 if (ret != GNUNET_SYSERR)
1541 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1542 "%p Client connected as host to place %s.\n",
1543 hst, GNUNET_h2s (&plc->pub_key_hash));
1545 struct ClientListItem *cli = GNUNET_new (struct ClientListItem);
1546 cli->client = client;
1547 GNUNET_CONTAINER_DLL_insert (plc->clients_head, plc->clients_tail, cli);
1549 struct Client *ctx = GNUNET_new (struct Client);
1551 GNUNET_SERVER_client_set_user_context (client, ctx);
1554 GNUNET_CRYPTO_eddsa_key_clear (&hreq->place_key);
1556 GNUNET_SERVER_receive_done (client, ret);
1561 * Enter place as guest.
1564 * Guest entry request.
1565 * @param[out] ret_gst
1566 * Returned Guest struct.
1568 * @return #GNUNET_YES if the guest entered the place just now,
1569 * #GNUNET_NO if the place is already entered,
1570 * #GNUNET_SYSERR on error.
1573 guest_enter (const struct GuestEnterRequest *greq, struct Guest **ret_gst)
1575 int ret = GNUNET_NO;
1576 uint16_t greq_size = ntohs (greq->header.size);
1578 struct GNUNET_CRYPTO_EcdsaPublicKey ego_pub_key = greq->ego_pub_key;
1579 struct GNUNET_HashCode ego_pub_hash;
1580 GNUNET_CRYPTO_hash (&ego_pub_key, sizeof (ego_pub_key), &ego_pub_hash);
1581 struct Ego *ego = GNUNET_CONTAINER_multihashmap_get (egos, &ego_pub_hash);
1584 return GNUNET_SYSERR;
1586 struct GNUNET_HashCode place_pub_hash;
1587 GNUNET_CRYPTO_hash (&greq->place_pub_key, sizeof (greq->place_pub_key),
1590 struct GNUNET_CONTAINER_MultiHashMap *
1591 plc_gst = GNUNET_CONTAINER_multihashmap_get (place_guests, &place_pub_hash);
1592 struct Guest *gst = NULL;
1594 if (NULL != plc_gst)
1595 gst = GNUNET_CONTAINER_multihashmap_get (plc_gst, &ego_pub_hash);
1597 if (NULL == gst || NULL == gst->slave)
1599 gst = GNUNET_new (struct Guest);
1600 gst->origin = greq->origin;
1601 gst->relay_count = ntohl (greq->relay_count);
1604 uint16_t remaining = ntohs (greq->header.size) - sizeof (*greq);
1605 const char *app_id = (const char *) &greq[1];
1606 const char *p = app_id;
1608 len = strnlen (app_id, remaining);
1609 if (len == remaining)
1613 return GNUNET_SYSERR;
1616 remaining -= len + 1;
1618 const struct GNUNET_PeerIdentity *relays = NULL;
1619 uint16_t relay_size = gst->relay_count * sizeof (*relays);
1620 if (remaining < relay_size)
1624 return GNUNET_SYSERR;
1627 relays = (const struct GNUNET_PeerIdentity *) p;
1629 remaining -= relay_size;
1631 struct GNUNET_PSYC_Message *join_msg = NULL;
1632 uint16_t join_msg_size = 0;
1634 if (sizeof (struct GNUNET_MessageHeader) <= remaining)
1636 join_msg = (struct GNUNET_PSYC_Message *) p;
1637 join_msg_size = ntohs (join_msg->header.size);
1639 remaining -= join_msg_size;
1643 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1644 "%zu + %u + %u != %u\n",
1645 sizeof (*greq), relay_size, join_msg_size, greq_size);
1648 return GNUNET_SYSERR;
1652 gst->relays = GNUNET_malloc (relay_size);
1653 GNUNET_memcpy (gst->relays, relays, relay_size);
1656 gst->join_flags = ntohl (greq->flags);
1658 struct Place *plc = &gst->plc;
1660 plc->is_host = GNUNET_NO;
1661 plc->pub_key = greq->place_pub_key;
1662 plc->pub_key_hash = place_pub_hash;
1663 plc->ego_pub_key = ego_pub_key;
1664 plc->ego_pub_hash = ego_pub_hash;
1665 plc->ego_key = ego->key;
1667 if (NULL == plc_gst)
1669 plc_gst = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
1670 (void) GNUNET_CONTAINER_multihashmap_put (place_guests, &plc->pub_key_hash, plc_gst,
1671 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
1673 (void) GNUNET_CONTAINER_multihashmap_put (plc_gst, &plc->ego_pub_hash, gst,
1674 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
1675 (void) GNUNET_CONTAINER_multihashmap_put (guests, &plc->pub_key_hash, gst,
1676 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
1678 = GNUNET_PSYC_slave_join (cfg, &plc->pub_key, &plc->ego_key,
1679 gst->join_flags, &gst->origin,
1680 gst->relay_count, gst->relays,
1681 &psyc_recv_message, NULL,
1682 &psyc_slave_connected,
1683 &psyc_recv_join_dcsn,
1685 plc->channel = GNUNET_PSYC_slave_get_channel (gst->slave);
1689 if (NULL != ret_gst)
1696 * Handle a connecting client entering a place as guest.
1699 client_recv_guest_enter (void *cls, struct GNUNET_SERVER_Client *client,
1700 const struct GNUNET_MessageHeader *msg)
1702 const struct GuestEnterRequest *
1703 greq = (const struct GuestEnterRequest *) msg;
1705 uint16_t remaining = ntohs (greq->header.size) - sizeof (*greq);
1706 const char *app_id = NULL;
1707 uint16_t offset = GNUNET_STRINGS_buffer_tokenize ((const char *) &greq[1],
1708 remaining, 1, &app_id);
1712 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1716 struct Guest *gst = NULL;
1717 struct Place *plc = NULL;
1719 switch (guest_enter (greq, &gst))
1723 app_place_save (app_id, (const struct PlaceEnterRequest *) greq);
1730 struct GNUNET_PSYC_CountersResultMessage res;
1731 res.header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_ACK);
1732 res.header.size = htons (sizeof (res));
1733 res.result_code = htonl (GNUNET_OK);
1734 res.max_message_id = GNUNET_htonll (plc->max_message_id);
1736 client_send_msg (client, &res.header);
1737 if (NULL != gst->join_dcsn)
1738 client_send_msg (client, &gst->join_dcsn->header);
1744 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1748 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1749 "%p Client connected as guest to place %s.\n",
1750 gst, GNUNET_h2s (&plc->pub_key_hash));
1752 struct ClientListItem *cli = GNUNET_new (struct ClientListItem);
1753 cli->client = client;
1754 GNUNET_CONTAINER_DLL_insert (plc->clients_head, plc->clients_tail, cli);
1756 struct Client *ctx = GNUNET_new (struct Client);
1758 GNUNET_SERVER_client_set_user_context (client, ctx);
1759 GNUNET_SERVER_receive_done (client, GNUNET_OK);
1763 struct GuestEnterByNameClosure
1765 struct GNUNET_SERVER_Client *client;
1768 struct GNUNET_CRYPTO_EcdsaPublicKey ego_pub_key;
1769 struct GNUNET_MessageHeader *join_msg;
1774 * Result of a GNS name lookup for entering a place.
1776 * @see GNUNET_SOCIAL_guest_enter_by_name
1779 gns_result_guest_enter (void *cls, uint32_t rd_count,
1780 const struct GNUNET_GNSRECORD_Data *rd)
1782 struct GuestEnterByNameClosure *gcls = cls;
1783 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1784 "%p GNS result: %u records.\n", gcls->client, rd_count);
1786 const struct GNUNET_GNSRECORD_PlaceData *
1787 rec = (const struct GNUNET_GNSRECORD_PlaceData *) rd->data;
1789 if (0 == rd_count || rd->data_size < sizeof (*rec))
1792 GNUNET_SERVER_receive_done (gcls->client, GNUNET_SYSERR);
1796 uint16_t relay_count = ntohl (rec->relay_count);
1797 struct GNUNET_PeerIdentity *relays = NULL;
1799 if (0 < relay_count)
1801 if (rd->data_size == sizeof (*rec) + relay_count * sizeof (struct GNUNET_PeerIdentity))
1803 relays = (struct GNUNET_PeerIdentity *) &rec[1];
1808 GNUNET_break_op (0);
1812 uint16_t app_id_size = strlen (gcls->app_id) + 1;
1813 uint16_t relay_size = relay_count * sizeof (*relays);
1814 uint16_t join_msg_size = 0;
1815 if (NULL != gcls->join_msg)
1816 join_msg_size = ntohs (gcls->join_msg->size);
1817 uint16_t greq_size = sizeof (struct GuestEnterRequest)
1818 + app_id_size + relay_size + join_msg_size;
1819 struct GuestEnterRequest *greq = GNUNET_malloc (greq_size);
1820 greq->header.size = htons (greq_size);
1821 greq->header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER);
1822 greq->ego_pub_key = gcls->ego_pub_key;
1823 greq->place_pub_key = rec->place_pub_key;
1824 greq->origin = rec->origin;
1825 greq->relay_count = rec->relay_count;
1828 GNUNET_memcpy (p, gcls->app_id, app_id_size);
1830 GNUNET_memcpy (p, relays, relay_size);
1832 GNUNET_memcpy (p, gcls->join_msg, join_msg_size);
1834 client_recv_guest_enter (NULL, gcls->client, &greq->header);
1836 GNUNET_free (gcls->app_id);
1837 if (NULL != gcls->password)
1838 GNUNET_free (gcls->password);
1839 if (NULL != gcls->join_msg)
1840 GNUNET_free (gcls->join_msg);
1847 * Handle a connecting client entering a place as guest using a GNS address.
1849 * Look up GNS address and generate a GuestEnterRequest from that.
1852 client_recv_guest_enter_by_name (void *cls, struct GNUNET_SERVER_Client *client,
1853 const struct GNUNET_MessageHeader *msg)
1855 const struct GuestEnterByNameRequest *
1856 greq = (const struct GuestEnterByNameRequest *) msg;
1858 struct GuestEnterByNameClosure *gcls = GNUNET_malloc (sizeof (*gcls));
1859 gcls->client = client;
1860 gcls->ego_pub_key = greq->ego_pub_key;
1862 const char *p = (const char *) &greq[1];
1863 const char *app_id = NULL, *password = NULL, *gns_name = NULL;
1864 uint16_t remaining = ntohs (greq->header.size) - sizeof (*greq);
1865 uint16_t offset = GNUNET_STRINGS_buffer_tokenize (p, remaining, 3,
1870 remaining -= offset;
1872 if (0 != offset && sizeof (*gcls->join_msg) <= remaining)
1874 gcls->join_msg = GNUNET_copy_message ((struct GNUNET_MessageHeader *) p);
1875 remaining -= ntohs (gcls->join_msg->size);
1878 if (0 == offset || 0 != remaining)
1880 if (NULL != gcls->join_msg)
1881 GNUNET_free (gcls->join_msg);
1884 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1888 uint16_t app_id_size = strlen (app_id) + 1;
1889 gcls->app_id = GNUNET_malloc (app_id_size);
1890 GNUNET_memcpy (gcls->app_id, app_id, app_id_size);
1892 uint16_t password_size = strlen (password);
1893 if (0 < password_size++)
1895 gcls->password = GNUNET_malloc (password_size);
1896 GNUNET_memcpy (gcls->password, password, password_size);
1899 GNUNET_GNS_lookup (gns, gns_name, &greq->ego_pub_key,
1900 GNUNET_GNSRECORD_TYPE_PLACE, GNUNET_GNS_LO_DEFAULT,
1901 NULL, gns_result_guest_enter, gcls);
1906 app_notify_place (struct GNUNET_MessageHeader *msg,
1907 struct GNUNET_SERVER_Client *client)
1909 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1910 "%p Sending place notification of type %u to client.\n",
1911 client, ntohs (msg->type));
1913 uint16_t msg_size = ntohs (msg->size);
1914 struct AppPlaceMessage amsg;
1915 amsg.header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE);
1916 amsg.header.size = htons (sizeof (amsg));
1917 // FIXME: also notify about not entered places
1918 amsg.place_state = GNUNET_SOCIAL_PLACE_STATE_ENTERED;
1920 switch (ntohs (msg->type))
1922 case GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER:
1923 if (msg_size < sizeof (struct HostEnterRequest))
1925 struct HostEnterRequest *hreq = (struct HostEnterRequest *) msg;
1926 amsg.is_host = GNUNET_YES;
1927 amsg.ego_pub_key = hreq->ego_pub_key;
1928 amsg.place_pub_key = hreq->place_pub_key;
1931 case GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER:
1932 if (msg_size < sizeof (struct GuestEnterRequest))
1934 struct GuestEnterRequest *greq = (struct GuestEnterRequest *) msg;
1935 amsg.is_host = GNUNET_NO;
1936 amsg.ego_pub_key = greq->ego_pub_key;
1937 amsg.place_pub_key = greq->place_pub_key;
1944 client_send_msg (client, &amsg.header);
1949 app_notify_place_end (struct GNUNET_SERVER_Client *client)
1951 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1952 "%p Sending end of place list notification to client\n",
1955 struct GNUNET_MessageHeader msg;
1956 msg.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_APP_PLACE_END);
1957 msg.size = htons (sizeof (msg));
1959 client_send_msg (client, &msg);
1964 app_notify_ego (struct Ego *ego, struct GNUNET_SERVER_Client *client)
1966 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1967 "%p Sending ego notification to client: %s\n",
1970 size_t name_size = strlen (ego->name) + 1;
1971 struct AppEgoMessage *emsg = GNUNET_malloc (sizeof (*emsg) + name_size);
1972 emsg->header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO);
1973 emsg->header.size = htons (sizeof (*emsg) + name_size);
1975 GNUNET_CRYPTO_ecdsa_key_get_public (&ego->key, &emsg->ego_pub_key);
1976 GNUNET_memcpy (&emsg[1], ego->name, name_size);
1978 client_send_msg (client, &emsg->header);
1984 app_notify_ego_end (struct GNUNET_SERVER_Client *client)
1986 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1987 "%p Sending end of ego list notification to client\n",
1990 struct GNUNET_MessageHeader msg;
1991 msg.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_APP_EGO_END);
1992 msg.size = htons (sizeof (msg));
1994 client_send_msg (client, &msg);
1999 app_place_entry_notify (void *cls, const struct GNUNET_HashCode *key, void *value)
2001 struct GNUNET_MessageHeader *
2002 msg = GNUNET_CONTAINER_multihashmap_get (places, key);
2004 app_notify_place (msg, cls);
2010 ego_entry (void *cls, const struct GNUNET_HashCode *key, void *value)
2012 app_notify_ego (value, cls);
2018 * Handle application connection.
2021 client_recv_app_connect (void *cls, struct GNUNET_SERVER_Client *client,
2022 const struct GNUNET_MessageHeader *msg)
2024 const struct AppConnectRequest *creq
2025 = (const struct AppConnectRequest *) msg;
2027 uint8_t app_id_size = ntohs (creq->header.size) - sizeof (*creq);
2028 const char *app_id = NULL;
2029 uint16_t offset = GNUNET_STRINGS_buffer_tokenize ((const char *) &creq[1],
2030 app_id_size, 1, &app_id);
2031 if (0 == offset || offset != app_id_size)
2034 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
2038 struct GNUNET_HashCode app_id_hash;
2039 GNUNET_CRYPTO_hash (app_id, app_id_size, &app_id_hash);
2041 GNUNET_CONTAINER_multihashmap_iterate (egos, ego_entry, client);
2042 app_notify_ego_end (client);
2044 struct GNUNET_CONTAINER_MultiHashMap *
2045 app_places = GNUNET_CONTAINER_multihashmap_get (apps_places, &app_id_hash);
2046 if (NULL != app_places)
2047 GNUNET_CONTAINER_multihashmap_iterate (app_places, app_place_entry_notify, client);
2048 app_notify_place_end (client);
2050 struct ClientListItem *cli = GNUNET_new (struct ClientListItem);
2051 cli->client = client;
2052 struct Application *app = GNUNET_CONTAINER_multihashmap_get (apps,
2055 app = GNUNET_malloc (sizeof (*app));
2056 (void) GNUNET_CONTAINER_multihashmap_put (apps, &app_id_hash, app,
2057 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
2059 GNUNET_CONTAINER_DLL_insert (app->clients_head, app->clients_tail, cli);
2061 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2062 "%p Application %s connected.\n", app, app_id);
2064 struct Client *ctx = GNUNET_new (struct Client);
2065 ctx->app_id = GNUNET_malloc (app_id_size);
2066 GNUNET_memcpy (ctx->app_id, app_id, app_id_size);
2068 GNUNET_SERVER_client_set_user_context (client, ctx);
2069 GNUNET_SERVER_receive_done (client, GNUNET_OK);
2074 * Handle application detach request.
2077 client_recv_app_detach (void *cls, struct GNUNET_SERVER_Client *client,
2078 const struct GNUNET_MessageHeader *msg)
2081 ctx = GNUNET_SERVER_client_get_user_context (client, struct Client);
2082 GNUNET_assert (NULL != ctx);
2084 struct Place *plc = ctx->plc;
2086 const struct AppDetachRequest *req
2087 = (const struct AppDetachRequest *) msg;
2089 int ret = app_place_remove (ctx->app_id, &plc->ego_pub_key, &req->place_pub_key);
2090 client_send_result (client, req->op_id, ret, NULL, 0);
2092 GNUNET_SERVER_receive_done (client, GNUNET_OK);
2097 app_places_entry_remove (void *cls, const struct GNUNET_HashCode *key, void *value)
2099 struct Place *plc = cls;
2100 const char *app_id = value;
2101 app_place_remove (app_id, &plc->ego_pub_key, &plc->pub_key);
2107 * Handle application detach request.
2110 client_recv_place_leave (void *cls, struct GNUNET_SERVER_Client *client,
2111 const struct GNUNET_MessageHeader *msg)
2114 ctx = GNUNET_SERVER_client_get_user_context (client, struct Client);
2115 GNUNET_assert (NULL != ctx);
2116 struct Place *plc = ctx->plc;
2118 /* FIXME: remove all app subscriptions and leave this place */
2120 struct GNUNET_CONTAINER_MultiHashMap *
2121 place_apps = GNUNET_CONTAINER_multihashmap_get (places_apps, &plc->pub_key_hash);
2122 if (NULL != place_apps)
2124 GNUNET_CONTAINER_multihashmap_iterate (place_apps, app_places_entry_remove, plc);
2127 /* FIXME: disconnect from the network, but keep local connection for history access */
2129 /* Disconnect all clients connected to the place */
2130 struct ClientListItem *cli = plc->clients_head, *next;
2133 GNUNET_CONTAINER_DLL_remove (plc->clients_head, plc->clients_tail, cli);
2134 GNUNET_SERVER_client_disconnect (cli->client);
2140 if (GNUNET_YES != plc->is_disconnected)
2142 plc->is_disconnected = GNUNET_YES;
2143 if (NULL != plc->tmit_msgs_head)
2144 { /* Send pending messages to PSYC before cleanup. */
2145 psyc_transmit_message (plc);
2149 cleanup_place (plc);
2155 struct JoinDecisionClosure
2157 int32_t is_admitted;
2158 struct GNUNET_PSYC_Message *msg;
2163 * Iterator callback for responding to join requests.
2166 psyc_send_join_decision (void *cls, const struct GNUNET_HashCode *pub_key_hash,
2169 struct JoinDecisionClosure *jcls = cls;
2170 struct GNUNET_PSYC_JoinHandle *jh = value;
2171 // FIXME: add relays
2172 GNUNET_PSYC_join_decision (jh, jcls->is_admitted, 0, NULL, jcls->msg);
2178 * Handle an entry decision from a host client.
2181 client_recv_join_decision (void *cls, struct GNUNET_SERVER_Client *client,
2182 const struct GNUNET_MessageHeader *msg)
2185 ctx = GNUNET_SERVER_client_get_user_context (client, struct Client);
2186 GNUNET_assert (NULL != ctx);
2187 struct Place *plc = ctx->plc;
2188 if (GNUNET_YES != plc->is_host) {
2190 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
2193 struct Host *hst = (struct Host *) plc;
2195 struct GNUNET_PSYC_JoinDecisionMessage *
2196 dcsn = (struct GNUNET_PSYC_JoinDecisionMessage *) msg;
2197 struct JoinDecisionClosure jcls;
2198 jcls.is_admitted = ntohl (dcsn->is_admitted);
2200 = (sizeof (*dcsn) + sizeof (*jcls.msg) <= ntohs (msg->size))
2201 ? (struct GNUNET_PSYC_Message *) &dcsn[1]
2204 struct GNUNET_HashCode slave_pub_hash;
2205 GNUNET_CRYPTO_hash (&dcsn->slave_pub_key, sizeof (dcsn->slave_pub_key),
2208 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2209 "%p Got join decision (%d) from client for place %s..\n",
2210 hst, jcls.is_admitted, GNUNET_h2s (&plc->pub_key_hash));
2211 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2212 "%p ..and slave %s.\n",
2213 hst, GNUNET_h2s (&slave_pub_hash));
2215 GNUNET_CONTAINER_multihashmap_get_multiple (hst->join_reqs, &slave_pub_hash,
2216 &psyc_send_join_decision, &jcls);
2217 GNUNET_CONTAINER_multihashmap_remove_all (hst->join_reqs, &slave_pub_hash);
2218 GNUNET_SERVER_receive_done (client, GNUNET_OK);
2223 * Send acknowledgement to a client.
2225 * Sent after a message fragment has been passed on to multicast.
2227 * @param plc The place struct for the client.
2230 send_message_ack (struct Place *plc, struct GNUNET_SERVER_Client *client)
2232 struct GNUNET_MessageHeader res;
2233 res.size = htons (sizeof (res));
2234 res.type = htons (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_ACK);
2235 client_send_msg (client, &res);
2240 * Proceed to the next message part in the transmission queue.
2243 * Place where the transmission is going on.
2245 * Currently transmitted message.
2247 * Currently transmitted message fragment.
2249 * @return @a tmit_frag, or NULL if reached the end of fragment.
2251 static struct FragmentTransmitQueue *
2252 psyc_transmit_queue_next_part (struct Place *plc,
2253 struct MessageTransmitQueue *tmit_msg,
2254 struct FragmentTransmitQueue *tmit_frag)
2256 uint16_t psize = ntohs (tmit_frag->next_part->size);
2257 if ((char *) tmit_frag->next_part + psize - ((char *) &tmit_frag[1])
2260 tmit_frag->next_part
2261 = (struct GNUNET_MessageHeader *) ((char *) tmit_frag->next_part + psize);
2263 else /* Reached end of current fragment. */
2265 if (NULL != tmit_frag->client)
2266 send_message_ack (plc, tmit_frag->client);
2267 GNUNET_CONTAINER_DLL_remove (tmit_msg->frags_head, tmit_msg->frags_tail, tmit_frag);
2268 GNUNET_free (tmit_frag);
2276 * Proceed to next message in transmission queue.
2279 * Place where the transmission is going on.
2281 * Currently transmitted message.
2283 * @return The next message in queue, or NULL if queue is empty.
2285 static struct MessageTransmitQueue *
2286 psyc_transmit_queue_next_msg (struct Place *plc,
2287 struct MessageTransmitQueue *tmit_msg)
2289 GNUNET_CONTAINER_DLL_remove (plc->tmit_msgs_head, plc->tmit_msgs_tail, tmit_msg);
2290 GNUNET_free (tmit_msg);
2291 return plc->tmit_msgs_head;
2296 * Callback for data transmission to PSYC.
2299 psyc_transmit_notify_data (void *cls, uint16_t *data_size, void *data)
2301 struct Place *plc = cls;
2302 struct MessageTransmitQueue *tmit_msg = plc->tmit_msgs_head;
2303 GNUNET_assert (NULL != tmit_msg);
2304 struct FragmentTransmitQueue *tmit_frag = tmit_msg->frags_head;
2305 if (NULL == tmit_frag)
2306 { /* Rest of the message have not arrived yet, pause transmission */
2310 struct GNUNET_MessageHeader *pmsg = tmit_frag->next_part;
2313 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2314 "%p psyc_transmit_notify_data: nothing to send.\n", plc);
2319 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2320 "%p psyc_transmit_notify_data()\n", plc);
2321 GNUNET_PSYC_log_message (GNUNET_ERROR_TYPE_DEBUG, pmsg);
2323 uint16_t ptype = ntohs (pmsg->type);
2324 uint16_t pdata_size = ntohs (pmsg->size) - sizeof (*pmsg);
2329 case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA:
2330 if (*data_size < pdata_size)
2332 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2333 "%p psyc_transmit_notify_data: buffer size too small for data.\n", plc);
2337 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2338 "%p psyc_transmit_notify_data: sending %u bytes.\n",
2341 *data_size = pdata_size;
2342 GNUNET_memcpy (data, &pmsg[1], *data_size);
2346 case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END:
2351 case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL:
2353 ret = GNUNET_SYSERR;
2357 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2358 "%p psyc_transmit_notify_data: unexpected message part of type %u.\n",
2360 ret = GNUNET_SYSERR;
2363 if (GNUNET_SYSERR == ret && GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL != ptype)
2366 tmit_msg = psyc_transmit_queue_next_msg (plc, tmit_msg);
2367 plc->is_disconnected = GNUNET_YES;
2368 GNUNET_SERVER_client_disconnect (tmit_frag->client);
2369 GNUNET_SCHEDULER_add_now (&cleanup_place, plc);
2374 tmit_frag = psyc_transmit_queue_next_part (plc, tmit_msg, tmit_frag);
2375 if (NULL != tmit_frag)
2377 struct GNUNET_MessageHeader *pmsg = tmit_frag->next_part;
2378 ptype = ntohs (pmsg->type);
2381 case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END:
2384 case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL:
2385 ret = GNUNET_SYSERR;
2390 case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END:
2391 case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL:
2392 tmit_frag = psyc_transmit_queue_next_part (plc, tmit_msg, tmit_frag);
2396 if (NULL == tmit_msg->frags_head
2397 && GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END <= ptype)
2398 { /* Reached end of current message. */
2399 tmit_msg = psyc_transmit_queue_next_msg (plc, tmit_msg);
2403 if (ret != GNUNET_NO)
2405 if (NULL != tmit_msg)
2407 psyc_transmit_message (plc);
2409 else if (GNUNET_YES == plc->is_disconnected)
2411 /* FIXME: handle partial message (when still in_transmit) */
2412 cleanup_place (plc);
2420 * Callback for modifier transmission to PSYC.
2423 psyc_transmit_notify_mod (void *cls, uint16_t *data_size, void *data,
2424 uint8_t *oper, uint32_t *full_value_size)
2426 struct Place *plc = cls;
2427 struct MessageTransmitQueue *tmit_msg = plc->tmit_msgs_head;
2428 GNUNET_assert (NULL != tmit_msg);
2429 struct FragmentTransmitQueue *tmit_frag = tmit_msg->frags_head;
2430 if (NULL == tmit_frag)
2431 { /* Rest of the message have not arrived yet, pause transmission */
2435 struct GNUNET_MessageHeader *pmsg = tmit_frag->next_part;
2438 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2439 "%p psyc_transmit_notify_mod: nothing to send.\n", plc);
2444 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2445 "%p psyc_transmit_notify_mod()\n", plc);
2446 GNUNET_PSYC_log_message (GNUNET_ERROR_TYPE_DEBUG, pmsg);
2448 uint16_t ptype = ntohs (pmsg->type);
2453 case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MODIFIER:
2457 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2458 "%p psyc_transmit_notify_mod: oper is NULL.\n", plc);
2459 ret = GNUNET_SYSERR;
2462 struct GNUNET_PSYC_MessageModifier *
2463 pmod = (struct GNUNET_PSYC_MessageModifier *) tmit_frag->next_part;
2464 uint16_t mod_size = ntohs (pmod->header.size) - sizeof (*pmod);
2466 if (*data_size < mod_size)
2468 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2469 "%p psyc_transmit_notify_mod: buffer size too small for data.\n", plc);
2474 *full_value_size = ntohl (pmod->value_size);
2476 *data_size = mod_size;
2477 GNUNET_memcpy (data, &pmod[1], mod_size);
2482 case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MOD_CONT:
2486 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2487 "%p psyc_transmit_notify_mod: oper is not NULL.\n", plc);
2488 ret = GNUNET_SYSERR;
2491 uint16_t mod_size = ntohs (pmsg->size) - sizeof (*pmsg);
2492 if (*data_size < mod_size)
2494 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2495 "%p psyc_transmit_notify_mod: buffer size too small for data.\n", plc);
2499 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2500 "%p psyc_transmit_notify_mod: sending %u bytes.\n", plc, mod_size);
2502 *data_size = mod_size;
2503 GNUNET_memcpy (data, &pmsg[1], *data_size);
2508 case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA:
2509 case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END:
2510 case GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL:
2516 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2517 "%p psyc_transmit_notify_mod: unexpected message part of type %u.\n",
2519 ret = GNUNET_SYSERR;
2522 if (GNUNET_SYSERR == ret)
2525 ret = GNUNET_SYSERR;
2526 tmit_msg = psyc_transmit_queue_next_msg (plc, tmit_msg);
2527 plc->is_disconnected = GNUNET_YES;
2528 GNUNET_SERVER_client_disconnect (tmit_frag->client);
2529 GNUNET_SCHEDULER_add_now (&cleanup_place, plc);
2533 if (GNUNET_YES != ret)
2534 psyc_transmit_queue_next_part (plc, tmit_msg, tmit_frag);
2536 if (NULL == tmit_msg->frags_head
2537 && GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END <= ptype)
2538 { /* Reached end of current message. */
2539 tmit_msg = psyc_transmit_queue_next_msg (plc, tmit_msg);
2546 * Callback for data transmission from a host to PSYC.
2549 host_transmit_notify_data (void *cls, uint16_t *data_size, void *data)
2551 int ret = psyc_transmit_notify_data (cls, data_size, data);
2553 if (GNUNET_NO != ret)
2555 struct Host *hst = cls;
2556 hst->tmit_handle = NULL;
2563 * Callback for the transmit functions of multicast.
2566 guest_transmit_notify_data (void *cls, uint16_t *data_size, void *data)
2568 int ret = psyc_transmit_notify_data (cls, data_size, data);
2570 if (GNUNET_NO != ret)
2572 struct Guest *gst = cls;
2573 gst->tmit_handle = NULL;
2580 * Callback for modifier transmission from a host to PSYC.
2583 host_transmit_notify_mod (void *cls, uint16_t *data_size, void *data,
2584 uint8_t *oper, uint32_t *full_value_size)
2586 int ret = psyc_transmit_notify_mod (cls, data_size, data,
2587 oper, full_value_size);
2588 if (GNUNET_SYSERR == ret)
2590 struct Host *hst = cls;
2591 hst->tmit_handle = NULL;
2598 * Callback for modifier transmission from a guest to PSYC.
2601 guest_transmit_notify_mod (void *cls, uint16_t *data_size, void *data,
2602 uint8_t *oper, uint32_t *full_value_size)
2604 int ret = psyc_transmit_notify_mod (cls, data_size, data,
2605 oper, full_value_size);
2606 if (GNUNET_SYSERR == ret)
2608 struct Guest *gst = cls;
2609 gst->tmit_handle = NULL;
2616 * Get method part of next message from transmission queue.
2621 * @return #GNUNET_OK on success
2622 * #GNUNET_NO if there are no more messages in queue.
2623 * #GNUNET_SYSERR if the next message is malformed.
2625 static struct GNUNET_PSYC_MessageMethod *
2626 psyc_transmit_queue_next_method (struct Place *plc)
2628 struct MessageTransmitQueue *tmit_msg = plc->tmit_msgs_head;
2629 if (NULL == tmit_msg)
2632 struct FragmentTransmitQueue *tmit_frag = tmit_msg->frags_head;
2633 if (NULL == tmit_frag)
2639 struct GNUNET_MessageHeader *pmsg = tmit_frag->next_part;
2641 || GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD != ntohs (pmsg->type))
2643 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2644 "%p psyc_transmit_queue_next_method: unexpected message part of type %u.\n",
2645 plc, NULL != pmsg ? ntohs (pmsg->type) : 0);
2650 uint16_t psize = ntohs (pmsg->size);
2651 struct GNUNET_PSYC_MessageMethod *
2652 pmeth = (struct GNUNET_PSYC_MessageMethod *) GNUNET_copy_message (pmsg);
2654 if (psize < sizeof (*pmeth) + 1 || '\0' != *((char *) pmeth + psize - 1))
2656 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2657 "%p psyc_transmit_queue_next_method: invalid method name.\n",
2659 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2660 "%zu <= %u || NUL != %u\n",
2661 sizeof (*pmeth), psize, *((char *) pmeth + psize - 1));
2663 GNUNET_free (pmeth);
2667 psyc_transmit_queue_next_part (plc, tmit_msg, tmit_frag);
2673 * Transmit the next message in queue from the host to the PSYC channel.
2676 psyc_master_transmit_message (struct Host *hst)
2678 struct Place *plc = &hst->plc;
2680 if (NULL == hst->tmit_handle)
2682 struct GNUNET_PSYC_MessageMethod *
2683 pmeth = psyc_transmit_queue_next_method (plc);
2685 return GNUNET_SYSERR;
2687 hst->tmit_handle = (void *) &hst->tmit_handle;
2688 struct GNUNET_PSYC_MasterTransmitHandle *
2689 tmit_handle = GNUNET_PSYC_master_transmit (hst->master, (const char *) &pmeth[1],
2690 &host_transmit_notify_mod,
2691 &host_transmit_notify_data, hst,
2693 if (NULL != hst->tmit_handle)
2694 hst->tmit_handle = tmit_handle;
2695 GNUNET_free (pmeth);
2699 GNUNET_PSYC_master_transmit_resume (hst->tmit_handle);
2706 * Transmit the next message in queue from a guest to the PSYC channel.
2709 psyc_slave_transmit_message (struct Guest *gst)
2711 struct Place *plc = &gst->plc;
2713 if (NULL == gst->tmit_handle)
2715 struct GNUNET_PSYC_MessageMethod *
2716 pmeth = psyc_transmit_queue_next_method (plc);
2718 return GNUNET_SYSERR;
2720 gst->tmit_handle = (void *) &gst->tmit_handle;
2721 struct GNUNET_PSYC_SlaveTransmitHandle *
2722 tmit_handle = GNUNET_PSYC_slave_transmit (gst->slave, (const char *) &pmeth[1],
2723 &guest_transmit_notify_mod,
2724 &guest_transmit_notify_data, gst,
2726 if (NULL != gst->tmit_handle)
2727 gst->tmit_handle = tmit_handle;
2728 GNUNET_free (pmeth);
2732 GNUNET_PSYC_slave_transmit_resume (gst->tmit_handle);
2739 * Transmit a message to PSYC.
2742 psyc_transmit_message (struct Place *plc)
2746 ? psyc_master_transmit_message ((struct Host *) plc)
2747 : psyc_slave_transmit_message ((struct Guest *) plc);
2752 * Queue message parts for sending to PSYC.
2754 * @param plc Place to send to.
2755 * @param client Client the message originates from.
2756 * @param data_size Size of @a data.
2757 * @param data Concatenated message parts.
2758 * @param first_ptype First message part type in @a data.
2759 * @param last_ptype Last message part type in @a data.
2761 static struct MessageTransmitQueue *
2762 psyc_transmit_queue_message (struct Place *plc,
2763 struct GNUNET_SERVER_Client *client,
2766 uint16_t first_ptype, uint16_t last_ptype,
2767 struct MessageTransmitQueue *tmit_msg)
2769 if (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD == first_ptype)
2771 tmit_msg = GNUNET_malloc (sizeof (*tmit_msg));
2772 GNUNET_CONTAINER_DLL_insert_tail (plc->tmit_msgs_head, plc->tmit_msgs_tail, tmit_msg);
2774 else if (NULL == tmit_msg)
2779 struct FragmentTransmitQueue *
2780 tmit_frag = GNUNET_malloc (sizeof (*tmit_frag) + data_size);
2781 GNUNET_memcpy (&tmit_frag[1], data, data_size);
2782 tmit_frag->next_part = (struct GNUNET_MessageHeader *) &tmit_frag[1];
2783 tmit_frag->client = client;
2784 tmit_frag->size = data_size;
2786 GNUNET_CONTAINER_DLL_insert_tail (tmit_msg->frags_head, tmit_msg->frags_tail, tmit_frag);
2787 tmit_msg->client = client;
2793 * Cancel transmission of current message to PSYC.
2795 * @param plc Place to send to.
2796 * @param client Client the message originates from.
2799 psyc_transmit_cancel (struct Place *plc, struct GNUNET_SERVER_Client *client)
2801 uint16_t type = GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_CANCEL;
2803 struct GNUNET_MessageHeader msg;
2804 msg.size = htons (sizeof (msg));
2805 msg.type = htons (type);
2807 psyc_transmit_queue_message (plc, client, sizeof (msg), &msg, type, type, NULL);
2808 psyc_transmit_message (plc);
2810 /* FIXME: cleanup */
2815 * Handle an incoming message from a client, to be transmitted to the place.
2818 client_recv_psyc_message (void *cls, struct GNUNET_SERVER_Client *client,
2819 const struct GNUNET_MessageHeader *msg)
2822 ctx = GNUNET_SERVER_client_get_user_context (client, struct Client);
2823 GNUNET_assert (NULL != ctx);
2824 struct Place *plc = ctx->plc;
2825 int ret = GNUNET_SYSERR;
2827 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2828 "%p Received message from client.\n", plc);
2829 GNUNET_PSYC_log_message (GNUNET_ERROR_TYPE_DEBUG, msg);
2831 if (GNUNET_YES != plc->is_ready)
2833 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2834 "%p Place is not ready yet, disconnecting client.\n", plc);
2836 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
2840 uint16_t size = ntohs (msg->size);
2841 uint16_t psize = size - sizeof (*msg);
2842 if (psize < sizeof (struct GNUNET_MessageHeader)
2843 || GNUNET_MULTICAST_FRAGMENT_MAX_PAYLOAD < psize)
2845 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2846 "%p Received message with invalid payload size (%u) from client.\n",
2849 psyc_transmit_cancel (plc, client);
2850 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
2854 uint16_t first_ptype = 0, last_ptype = 0;
2856 == GNUNET_PSYC_receive_check_parts (psize, (const char *) &msg[1],
2857 &first_ptype, &last_ptype))
2859 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2860 "%p Received invalid message part from client.\n", plc);
2862 psyc_transmit_cancel (plc, client);
2863 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
2866 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2867 "%p Received message with first part type %u and last part type %u.\n",
2868 plc, first_ptype, last_ptype);
2871 = psyc_transmit_queue_message (plc, client, psize, &msg[1],
2872 first_ptype, last_ptype, ctx->tmit_msg);
2873 if (NULL != ctx->tmit_msg)
2875 if (GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END <= last_ptype)
2876 ctx->tmit_msg = NULL;
2877 ret = psyc_transmit_message (plc);
2880 if (GNUNET_OK != ret)
2882 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2883 "%p Received invalid message part from client.\n", plc);
2885 psyc_transmit_cancel (plc, client);
2886 ret = GNUNET_SYSERR;
2888 GNUNET_SERVER_receive_done (client, ret);
2893 * A historic message arrived from PSYC.
2896 psyc_recv_history_message (void *cls, const struct GNUNET_PSYC_MessageHeader *msg)
2898 struct OperationClosure *opcls = cls;
2899 struct Place *plc = opcls->plc;
2901 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2902 "%p Received historic message #%" PRId64 " (flags: %x)\n",
2903 plc, GNUNET_ntohll (msg->message_id), ntohl (msg->flags));
2905 uint16_t size = ntohs (msg->header.size);
2907 struct GNUNET_OperationResultMessage *
2908 res = GNUNET_malloc (sizeof (*res) + size);
2909 res->header.size = htons (sizeof (*res) + size);
2910 res->header.type = htons (GNUNET_MESSAGE_TYPE_PSYC_HISTORY_RESULT);
2911 res->op_id = opcls->op_id;
2912 res->result_code = GNUNET_htonll (GNUNET_OK);
2914 GNUNET_memcpy (&res[1], msg, size);
2916 /** @todo FIXME: send only to requesting client */
2917 place_send_msg (plc, &res->header);
2924 * Result of message history replay from PSYC.
2927 psyc_recv_history_result (void *cls, int64_t result,
2928 const void *err_msg, uint16_t err_msg_size)
2930 struct OperationClosure *opcls = cls;
2931 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2932 "%p History replay #%" PRIu64 ": "
2933 "PSYCstore returned %" PRId64 " (%.*s)\n",
2934 opcls->plc, GNUNET_ntohll (opcls->op_id), result,
2935 err_msg_size, (const char *) err_msg);
2937 // FIXME: place might have been destroyed
2938 client_send_result (opcls->client, opcls->op_id, result, err_msg, err_msg_size);
2943 * Client requests channel history.
2946 client_recv_history_replay (void *cls, struct GNUNET_SERVER_Client *client,
2947 const struct GNUNET_MessageHeader *msg)
2950 ctx = GNUNET_SERVER_client_get_user_context (client, struct Client);
2951 GNUNET_assert (NULL != ctx);
2952 struct Place *plc = ctx->plc;
2954 const struct GNUNET_PSYC_HistoryRequestMessage *
2955 req = (const struct GNUNET_PSYC_HistoryRequestMessage *) msg;
2956 uint16_t size = ntohs (msg->size);
2957 const char *method_prefix = (const char *) &req[1];
2959 if (size < sizeof (*req) + 1
2960 || '\0' != method_prefix[size - sizeof (*req) - 1])
2962 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2963 "%p History replay #%" PRIu64 ": "
2964 "invalid method prefix. size: %u < %zu?\n",
2965 plc, GNUNET_ntohll (req->op_id), size, sizeof (*req) + 1);
2967 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
2971 struct OperationClosure *opcls = GNUNET_malloc (sizeof (*opcls));
2972 opcls->client = client;
2974 opcls->op_id = req->op_id;
2975 opcls->flags = ntohl (req->flags);
2977 if (0 == req->message_limit)
2978 GNUNET_PSYC_channel_history_replay (plc->channel,
2979 GNUNET_ntohll (req->start_message_id),
2980 GNUNET_ntohll (req->end_message_id),
2981 method_prefix, opcls->flags,
2982 psyc_recv_history_message, NULL,
2983 psyc_recv_history_result, opcls);
2985 GNUNET_PSYC_channel_history_replay_latest (plc->channel,
2986 GNUNET_ntohll (req->message_limit),
2987 method_prefix, opcls->flags,
2988 psyc_recv_history_message, NULL,
2989 psyc_recv_history_result, opcls);
2991 GNUNET_SERVER_receive_done (client, GNUNET_OK);
2996 * A state variable part arrived from PSYC.
2999 psyc_recv_state_var (void *cls,
3000 const struct GNUNET_MessageHeader *mod,
3003 uint32_t value_size,
3004 uint32_t full_value_size)
3006 struct OperationClosure *opcls = cls;
3007 struct Place *plc = opcls->plc;
3009 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3010 "%p Received state variable %s from PSYC\n",
3013 uint16_t size = ntohs (mod->size);
3015 struct GNUNET_OperationResultMessage *
3016 res = GNUNET_malloc (sizeof (*res) + size);
3017 res->header.size = htons (sizeof (*res) + size);
3018 res->header.type = htons (GNUNET_MESSAGE_TYPE_PSYC_STATE_RESULT);
3019 res->op_id = opcls->op_id;
3020 res->result_code = GNUNET_htonll (GNUNET_OK);
3022 GNUNET_memcpy (&res[1], mod, size);
3024 /** @todo FIXME: send only to requesting client */
3025 place_send_msg (plc, &res->header);
3032 * Result of retrieving state variable from PSYC.
3035 psyc_recv_state_result (void *cls, int64_t result,
3036 const void *err_msg, uint16_t err_msg_size)
3038 struct OperationClosure *opcls = cls;
3039 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3040 "%p State get #%" PRIu64 ": "
3041 "PSYCstore returned %" PRId64 " (%.*s)\n",
3042 opcls->plc, GNUNET_ntohll (opcls->op_id), result,
3043 err_msg_size, (const char *) err_msg);
3045 // FIXME: place might have been destroyed
3046 client_send_result (opcls->client, opcls->op_id, result, err_msg, err_msg_size);
3051 * Client requests channel history.
3054 client_recv_state_get (void *cls, struct GNUNET_SERVER_Client *client,
3055 const struct GNUNET_MessageHeader *msg)
3058 ctx = GNUNET_SERVER_client_get_user_context (client, struct Client);
3059 GNUNET_assert (NULL != ctx);
3060 struct Place *plc = ctx->plc;
3062 const struct GNUNET_PSYC_StateRequestMessage *
3063 req = (const struct GNUNET_PSYC_StateRequestMessage *) msg;
3064 uint16_t size = ntohs (msg->size);
3065 const char *name = (const char *) &req[1];
3067 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3068 "%p State get #%" PRIu64 ": %s\n",
3069 plc, GNUNET_ntohll (req->op_id), name);
3071 if (size < sizeof (*req) + 1
3072 || '\0' != name[size - sizeof (*req) - 1])
3074 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3075 "%p State get #%" PRIu64 ": "
3076 "invalid name. size: %u < %zu?\n",
3077 plc, GNUNET_ntohll (req->op_id), size, sizeof (*req) + 1);
3079 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3083 struct OperationClosure *opcls = GNUNET_malloc (sizeof (*opcls));
3084 opcls->client = client;
3086 opcls->op_id = req->op_id;
3088 switch (ntohs (msg->type))
3090 case GNUNET_MESSAGE_TYPE_PSYC_STATE_GET:
3091 GNUNET_PSYC_channel_state_get (plc->channel, name,
3092 psyc_recv_state_var,
3093 psyc_recv_state_result, opcls);
3096 case GNUNET_MESSAGE_TYPE_PSYC_STATE_GET_PREFIX:
3097 GNUNET_PSYC_channel_state_get_prefix (plc->channel, name,
3098 psyc_recv_state_var,
3099 psyc_recv_state_result, opcls);
3106 GNUNET_SERVER_receive_done (client, GNUNET_OK);
3111 namestore_recv_records_store_result (void *cls, int32_t result,
3112 const char *err_msg)
3114 struct OperationClosure *ocls = cls;
3115 client_send_result (ocls->client, ocls->op_id, result, err_msg,
3116 (NULL != err_msg) ? strlen (err_msg) : 0);
3122 * Handle request to add PLACE record to GNS zone.
3125 client_recv_zone_add_place (void *cls, struct GNUNET_SERVER_Client *client,
3126 const struct GNUNET_MessageHeader *msg)
3128 const struct ZoneAddPlaceRequest *preq
3129 = (const struct ZoneAddPlaceRequest *) msg;
3131 uint16_t remaining = ntohs (preq->header.size) - sizeof (*preq);
3132 const char *p = (const char *) &preq[1];
3133 const char *name = NULL, *password = NULL;
3134 uint16_t offset = GNUNET_STRINGS_buffer_tokenize (p, remaining, 2,
3136 remaining -= offset;
3138 const struct GNUNET_PeerIdentity *
3139 relays = (const struct GNUNET_PeerIdentity *) p;
3140 uint16_t relay_size = ntohl (preq->relay_count) * sizeof (*relays);
3142 if (0 == offset || remaining != relay_size)
3145 client_send_result (client, preq->op_id, GNUNET_SYSERR, NULL, 0);
3146 GNUNET_SERVER_receive_done (client, GNUNET_OK);
3150 struct GNUNET_GNSRECORD_Data rd = { };
3151 rd.record_type = GNUNET_GNSRECORD_TYPE_PLACE;
3152 rd.flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
3153 rd.expiration_time = GNUNET_ntohll (preq->expiration_time);
3155 struct GNUNET_GNSRECORD_PlaceData *
3156 rec = GNUNET_malloc (sizeof (*rec) + relay_size);
3157 rec->place_pub_key = preq->place_pub_key;
3158 rec->origin = this_peer;
3159 rec->relay_count = preq->relay_count;
3160 GNUNET_memcpy (&rec[1], relays, relay_size);
3163 rd.data_size = sizeof (*rec) + relay_size;
3165 struct GNUNET_HashCode ego_pub_hash;
3166 GNUNET_CRYPTO_hash (&preq->ego_pub_key, sizeof (preq->ego_pub_key), &ego_pub_hash);
3167 struct Ego *ego = GNUNET_CONTAINER_multihashmap_get (egos, &ego_pub_hash);
3170 client_send_result (client, preq->op_id, GNUNET_SYSERR, NULL, 0);
3174 struct OperationClosure *ocls = GNUNET_malloc (sizeof (*ocls));
3175 ocls->client = client;
3176 ocls->op_id = preq->op_id;
3177 GNUNET_NAMESTORE_records_store (namestore, &ego->key,
3179 namestore_recv_records_store_result, ocls);
3180 /** @todo refresh stored records later */
3182 GNUNET_SERVER_receive_done (client, GNUNET_OK);
3187 * Handle request to add PLACE record to GNS zone.
3190 client_recv_zone_add_nym (void *cls, struct GNUNET_SERVER_Client *client,
3191 const struct GNUNET_MessageHeader *msg)
3193 const struct ZoneAddNymRequest *nreq
3194 = (const struct ZoneAddNymRequest *) msg;
3196 uint16_t name_size = ntohs (nreq->header.size) - sizeof (*nreq);
3197 const char *name = NULL;
3198 uint16_t offset = GNUNET_STRINGS_buffer_tokenize ((const char *) &nreq[1],
3199 name_size, 1, &name);
3200 if (0 == offset || offset != name_size)
3203 client_send_result (client, nreq->op_id, GNUNET_SYSERR, NULL, 0);
3204 GNUNET_SERVER_receive_done (client, GNUNET_OK);
3208 struct GNUNET_GNSRECORD_Data rd = { };
3209 rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
3210 rd.flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
3211 rd.expiration_time = GNUNET_ntohll (nreq->expiration_time);
3212 rd.data = &nreq->nym_pub_key;
3213 rd.data_size = sizeof (nreq->nym_pub_key);
3215 struct GNUNET_HashCode ego_pub_hash;
3216 GNUNET_CRYPTO_hash (&nreq->ego_pub_key, sizeof (nreq->ego_pub_key), &ego_pub_hash);
3217 struct Ego *ego = GNUNET_CONTAINER_multihashmap_get (egos, &ego_pub_hash);
3220 client_send_result (client, nreq->op_id, GNUNET_SYSERR, NULL, 0);
3224 struct OperationClosure *ocls = GNUNET_malloc (sizeof (*ocls));
3225 ocls->client = client;
3226 ocls->op_id = nreq->op_id;
3227 GNUNET_NAMESTORE_records_store (namestore, &ego->key,
3229 namestore_recv_records_store_result, ocls);
3230 /** @todo refresh stored records later */
3232 GNUNET_SERVER_receive_done (client, GNUNET_OK);
3236 static const struct GNUNET_SERVER_MessageHandler handlers[] = {
3237 { client_recv_host_enter, NULL,
3238 GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER, 0 },
3240 { client_recv_guest_enter, NULL,
3241 GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER, 0 },
3243 { client_recv_guest_enter_by_name, NULL,
3244 GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER_BY_NAME, 0 },
3246 { client_recv_join_decision, NULL,
3247 GNUNET_MESSAGE_TYPE_PSYC_JOIN_DECISION, 0 },
3249 { client_recv_psyc_message, NULL,
3250 GNUNET_MESSAGE_TYPE_PSYC_MESSAGE, 0 },
3252 { client_recv_history_replay, NULL,
3253 GNUNET_MESSAGE_TYPE_PSYC_HISTORY_REPLAY, 0 },
3255 { client_recv_state_get, NULL,
3256 GNUNET_MESSAGE_TYPE_PSYC_STATE_GET, 0 },
3258 { client_recv_state_get, NULL,
3259 GNUNET_MESSAGE_TYPE_PSYC_STATE_GET_PREFIX, 0 },
3261 { client_recv_zone_add_place, NULL,
3262 GNUNET_MESSAGE_TYPE_SOCIAL_ZONE_ADD_PLACE, 0 },
3264 { client_recv_zone_add_nym, NULL,
3265 GNUNET_MESSAGE_TYPE_SOCIAL_ZONE_ADD_NYM, 0 },
3267 { client_recv_app_connect, NULL,
3268 GNUNET_MESSAGE_TYPE_SOCIAL_APP_CONNECT, 0 },
3270 { client_recv_app_detach, NULL,
3271 GNUNET_MESSAGE_TYPE_SOCIAL_APP_DETACH, 0 },
3273 { client_recv_place_leave, NULL,
3274 GNUNET_MESSAGE_TYPE_SOCIAL_PLACE_LEAVE, 0 },
3276 { client_recv_msg_proc_set, NULL,
3277 GNUNET_MESSAGE_TYPE_SOCIAL_MSG_PROC_SET, 0 },
3279 { client_recv_msg_proc_clear, NULL,
3280 GNUNET_MESSAGE_TYPE_SOCIAL_MSG_PROC_CLEAR, 0 },
3282 { NULL, NULL, 0, 0 }
3287 path_basename (const char *path)
3289 const char *basename = strrchr (path, DIR_SEPARATOR);
3290 if (NULL != basename)
3293 if (NULL == basename || '\0' == basename)
3300 struct PlaceLoadClosure
3303 const char *ego_pub_str;
3307 /** Load a place file */
3309 file_place_load (void *cls, const char *place_filename)
3311 struct PlaceLoadClosure *plcls = cls;
3313 const char *place_pub_str = path_basename (place_filename);
3314 if (NULL == place_pub_str)
3320 char *filename = NULL;
3321 GNUNET_asprintf (&filename, "%s%c" "%s%c" "%s%c" "%s",
3322 dir_social, DIR_SEPARATOR,
3323 "places", DIR_SEPARATOR,
3324 plcls->ego_pub_str, DIR_SEPARATOR,
3327 uint64_t file_size = 0;
3329 GNUNET_DISK_file_size (filename, &file_size, GNUNET_YES, GNUNET_YES)
3330 || file_size < sizeof (struct PlaceEnterRequest))
3332 GNUNET_free (filename);
3336 struct PlaceEnterRequest *ereq = GNUNET_malloc (file_size);
3337 ssize_t read_size = GNUNET_DISK_fn_read (filename, ereq, file_size);
3338 GNUNET_free (filename);
3339 if (read_size < 0 || read_size < sizeof (*ereq))
3345 uint16_t ereq_size = ntohs (ereq->header.size);
3346 if (read_size != ereq_size)
3352 switch (ntohs (ereq->header.type))
3354 case GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER:
3355 if (ereq_size < sizeof (struct HostEnterRequest))
3360 struct HostEnterRequest *hreq = (struct HostEnterRequest *) ereq;
3361 host_enter (hreq, NULL);
3364 case GNUNET_MESSAGE_TYPE_SOCIAL_GUEST_ENTER:
3365 if (ereq_size < sizeof (struct GuestEnterRequest))
3370 struct GuestEnterRequest *greq = (struct GuestEnterRequest *) ereq;
3371 guest_enter (greq, NULL);
3379 app_place_add (plcls->app_id, ereq);
3386 * Read @e place_pub_str entries in @a dir_ego
3389 * Data directory of an application ego.
3390 * $GNUNET_DATA_HOME/social/apps/$app_id/$ego_pub_str/
3393 scan_app_ego_dir (void *cls, const char *dir_ego)
3395 struct PlaceLoadClosure *plcls = cls;
3396 plcls->ego_pub_str = path_basename (dir_ego);
3398 if (NULL != plcls->ego_pub_str)
3399 GNUNET_DISK_directory_scan (dir_ego, file_place_load, plcls);
3405 * Read @e ego_pub_str entries in @a dir_app
3408 * Data directory of an application.
3409 * $GNUNET_DATA_HOME/social/apps/$app_id/
3412 scan_app_dir (void *cls, const char *dir_app)
3414 if (GNUNET_YES != GNUNET_DISK_directory_test (dir_app, GNUNET_YES))
3417 struct PlaceLoadClosure plcls;
3418 plcls.app_id = path_basename (dir_app);
3420 if (NULL != plcls.app_id)
3421 GNUNET_DISK_directory_scan (dir_app, scan_app_ego_dir, &plcls);
3428 identity_recv_ego (void *cls, struct GNUNET_IDENTITY_Ego *id_ego,
3429 void **ctx, const char *name)
3431 if (NULL == id_ego) // end of initial list of egos
3434 struct GNUNET_CRYPTO_EcdsaPublicKey ego_pub_key;
3435 GNUNET_IDENTITY_ego_get_public_key (id_ego, &ego_pub_key);
3437 struct GNUNET_HashCode ego_pub_hash;
3438 GNUNET_CRYPTO_hash (&ego_pub_key, sizeof (ego_pub_key), &ego_pub_hash);
3440 struct Ego *ego = GNUNET_CONTAINER_multihashmap_get (egos, &ego_pub_hash);
3443 GNUNET_free (ego->name);
3444 if (NULL == name) // deleted
3446 GNUNET_CONTAINER_multihashmap_remove (egos, &ego_pub_hash, ego);
3453 ego = GNUNET_malloc (sizeof (*ego));
3457 ego->key = *(GNUNET_IDENTITY_ego_get_private_key (id_ego));
3458 size_t name_size = strlen (name) + 1;
3459 ego->name = GNUNET_malloc (name_size);
3460 GNUNET_memcpy (ego->name, name, name_size);
3462 GNUNET_CONTAINER_multihashmap_put (egos, &ego_pub_hash, ego,
3463 GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
3466 // FIXME: notify clients about changed ego
3471 * Connected to core service.
3474 core_connected (void *cls, const struct GNUNET_PeerIdentity *my_identity)
3476 this_peer = *my_identity;
3481 * Initialize the PSYC service.
3483 * @param cls Closure.
3484 * @param server The initialized server.
3485 * @param c Configuration to use.
3488 run (void *cls, struct GNUNET_SERVER_Handle *server,
3489 const struct GNUNET_CONFIGURATION_Handle *c)
3493 hosts = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
3494 guests = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
3495 place_guests = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
3497 egos = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
3498 apps = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
3499 places = GNUNET_CONTAINER_multihashmap_create(1, GNUNET_NO);
3500 apps_places = GNUNET_CONTAINER_multihashmap_create(1, GNUNET_NO);
3501 places_apps = GNUNET_CONTAINER_multihashmap_create(1, GNUNET_NO);
3503 core = GNUNET_CORE_connecT (cfg, NULL, core_connected, NULL, NULL, NULL);
3504 id = GNUNET_IDENTITY_connect (cfg, &identity_recv_ego, NULL);
3505 gns = GNUNET_GNS_connect (cfg);
3506 namestore = GNUNET_NAMESTORE_connect (cfg);
3507 stats = GNUNET_STATISTICS_create ("social", cfg);
3510 GNUNET_CONFIGURATION_get_value_filename (cfg, "social", "DATA_HOME",
3513 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
3514 "social", "DATA_HOME");
3518 GNUNET_asprintf (&dir_places, "%s%c%s",
3519 dir_social, DIR_SEPARATOR, "places");
3520 GNUNET_asprintf (&dir_apps, "%s%c%s",
3521 dir_social, DIR_SEPARATOR, "apps");
3523 GNUNET_DISK_directory_scan (dir_apps, scan_app_dir, NULL);
3525 nc = GNUNET_SERVER_notification_context_create (server, 1);
3526 GNUNET_SERVER_add_handlers (server, handlers);
3527 GNUNET_SERVER_disconnect_notify (server, &client_disconnect, NULL);
3528 GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
3533 * The main function for the service.
3535 * @param argc number of arguments from the command line
3536 * @param argv command line arguments
3537 * @return 0 ok, 1 on error
3540 main (int argc, char *const *argv)
3542 return (GNUNET_OK ==
3543 GNUNET_SERVICE_run (argc, argv, "social",
3544 GNUNET_SERVICE_OPTION_NONE,
3545 &run, NULL)) ? 0 : 1;
3548 /* end of gnunet-service-social.c */