src/set/gnunet-service-set.h

   1 /*
   2       This file is part of GNUnet
   3       (C) 2013 Christian Grothoff (and other contributing authors)
   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 2, 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., 59 Temple Place - Suite 330,
  18       Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file set/gnunet-service-set.h
  23  * @brief common components for the implementation the different set operations
  24  * @author Florian Dold
  25  */
  26
  27 #ifndef GNUNET_SERVICE_SET_H_PRIVATE
  28 #define GNUNET_SERVICE_SET_H_PRIVATE
  29
  30 #include "platform.h"
  31 #include "gnunet_common.h"
  32 #include "gnunet_protocols.h"
  33 #include "gnunet_applications.h"
  34 #include "gnunet_util_lib.h"
  35 #include "gnunet_core_service.h"
  36 #include "gnunet_mesh2_service.h"
  37 #include "gnunet_set_service.h"
  38 #include "set.h"
  39
  40
  41 /* FIXME: cfuchs */
  42 struct IntersectionState;
  43
  44
  45 /**
  46  * Extra state required for set union.
  47  */
  48 struct UnionState;
  49
  50 struct UnionEvaluateOperation;
  51
  52
  53 /**
  54  * A set that supports a specific operation
  55  * with other peers.
  56  */
  57 struct Set
  58 {
  59   /**
  60    * Client that owns the set.
  61    * Only one client may own a set.
  62    */
  63   struct GNUNET_SERVER_Client *client;
  64
  65   /**
  66    * Message queue for the client
  67    */
  68   struct GNUNET_MQ_Handle *client_mq;
  69
  70   /**
  71    * Type of operation supported for this set
  72    */
  73   uint32_t operation; // use enum from API
  74
  75   /**
  76    * Sets are held in a doubly linked list.
  77    */
  78   struct Set *next;
  79
  80   /**
  81    * Sets are held in a doubly linked list.
  82    */
  83   struct Set *prev;
  84
  85   /**
  86    * Appropriate state for each type of
  87    * operation.
  88    */
  89   union {
  90     struct IntersectionState *i;
  91     struct UnionState *u;
  92   } state;
  93 };
  94
  95
  96 /**
  97  * A listener is inhabited by a client, and
  98  * waits for evaluation requests from remote peers.
  99  */
 100 struct Listener
 101 {
 102   /**
 103    * Listeners are held in a doubly linked list.
 104    */
 105   struct Listener *next;
 106
 107   /**
 108    * Listeners are held in a doubly linked list.
 109    */
 110   struct Listener *prev;
 111
 112   /**
 113    * Client that owns the listener.
 114    * Only one client may own a listener.
 115    */
 116   struct GNUNET_SERVER_Client *client;
 117
 118   /**
 119    * Message queue for the client
 120    */
 121   struct GNUNET_MQ_Handle *client_mq;
 122
 123   /**
 124    * Type of operation supported for this set
 125    */
 126   enum GNUNET_SET_OperationType operation;
 127
 128   /**
 129    * Application id of intereset for this listener.
 130    */
 131   struct GNUNET_HashCode app_id;
 132 };
 133
 134
 135 /**
 136  * Peer that has connected to us, but is not yet evaluating a set operation.
 137  * Once the peer has sent a request, and the client has
 138  * accepted or rejected it, this information will be deleted.
 139  */
 140 struct Incoming
 141 {
 142   /**
 143    * Incoming peers are held in a linked list
 144    */
 145   struct Incoming *next;
 146
 147   /**
 148    * Incoming peers are held in a linked list
 149    */
 150   struct Incoming *prev;
 151
 152   /**
 153    * Tunnel context, stores information about
 154    * the tunnel and its peer.
 155    */
 156   struct TunnelContext *tc;
 157
 158   /**
 159    * GNUNET_YES if the incoming peer has sent
 160    * an operation request (and we are waiting
 161    * for the client to ack/nack), GNUNET_NO otherwise.
 162    */
 163   int received_request;
 164
 165   /**
 166    * App code, set once the peer has
 167    * requested an operation
 168    */
 169   struct GNUNET_HashCode app_id;
 170
 171   /**
 172    * Context message, set once the peer
 173    * has requested an operation.
 174    */
 175   struct GNUNET_MessageHeader *context_msg;
 176
 177   /**
 178    * Salt the peer has requested to use for the
 179    * operation
 180    */
 181   uint16_t salt;
 182
 183   /**
 184    * Operation the other peer wants to do
 185    */
 186   enum GNUNET_SET_OperationType operation;
 187
 188   /**
 189    * Unique request id for the request from
 190    * a remote peer, sent to the client, which will
 191    * accept or reject the request.
 192    */
 193   uint32_t accept_id;
 194 };
 195
 196
 197 enum TunnelContextType {
 198   CONTEXT_INCOMING,
 199   CONTEXT_OPERATION_UNION,
 200   CONTEXT_OPERATION_INTERSECTION,
 201 };
 202
 203 struct TunnelContext
 204 {
 205   struct GNUNET_MESH_Tunnel *tunnel;
 206   struct GNUNET_PeerIdentity peer;
 207   struct GNUNET_MQ_Handle *mq;
 208   enum TunnelContextType type;
 209   void *data;
 210 };
 211
 212
 213
 214 /**
 215  * Configuration of the local peer
 216  */
 217 extern const struct GNUNET_CONFIGURATION_Handle *configuration;
 218
 219 extern struct GNUNET_MESH_Handle *mesh;
 220
 221
 222 /**
 223  * Create a new set supporting the union operation
 224  *
 225  * @return the newly created set
 226  */
 227 struct Set *
 228 _GSS_union_set_create (void);
 229
 230
 231 /**
 232  * Evaluate a union operation with
 233  * a remote peer.
 234  *
 235  * @param m the evaluate request message from the client
 236  * @parem set the set to evaluate the operation with
 237  */
 238 void
 239 _GSS_union_evaluate (struct GNUNET_SET_EvaluateMessage *m, struct Set *set);
 240
 241
 242 /**
 243  * Add the element from the given element message to the set.
 244  *
 245  * @param m message with the element
 246  * @param set set to add the element to
 247  */
 248 void
 249 _GSS_union_add (struct GNUNET_SET_ElementMessage *m, struct Set *set);
 250
 251
 252 /**
 253  * Remove the element given in the element message from the set.
 254  * Only marks the element as removed, so that older set operations can still exchange it.
 255  *
 256  * @param m message with the element
 257  * @param set set to remove the element from
 258  */
 259 void
 260 _GSS_union_remove (struct GNUNET_SET_ElementMessage *m, struct Set *set);
 261
 262
 263 /**
 264  * Destroy a set that supports the union operation
 265  *
 266  * @param the set to destroy, must be of type GNUNET_SET_OPERATION_UNION
 267  */
 268 void
 269 _GSS_union_set_destroy (struct Set *set);
 270
 271
 272 /**
 273  * Accept an union operation request from a remote peer
 274  *
 275  * @param m the accept message from the client
 276  * @param set the set of the client
 277  * @param incoming information about the requesting remote peer
 278  */
 279 void
 280 _GSS_union_accept (struct GNUNET_SET_AcceptRejectMessage *m, struct Set *set,
 281                    struct Incoming *incoming);
 282
 283
 284 /**
 285  * Destroy a union operation, and free all resources
 286  * associated with it.
 287  *
 288  * @param eo the union operation to destroy
 289  */
 290 void
 291 _GSS_union_operation_destroy (struct UnionEvaluateOperation *eo);
 292
 293
 294 /**
 295  * Dispatch messages for a union operation.
 296  *
 297  * @param cls closure
 298  * @param tunnel mesh tunnel
 299  * @param tunnel_ctx tunnel context
 300  * @param mh message to process
 301  * @return ???
 302  */
 303 int
 304 _GSS_union_handle_p2p_message (void *cls,
 305                                struct GNUNET_MESH_Tunnel *tunnel,
 306                                void **tunnel_ctx,
 307                                const struct GNUNET_MessageHeader *mh);
 308
 309
 310 #endif