src/include/gnunet_server_lib.h

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009, 2010 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 include/gnunet_server_lib.h
  23  * @brief library for building GNUnet network servers
  24  *
  25  * @author Christian Grothoff
  26  */
  27
  28 #ifndef GNUNET_SERVER_LIB_H
  29 #define GNUNET_SERVER_LIB_H
  30
  31 #ifdef __cplusplus
  32 extern "C"
  33 {
  34 #if 0                           /* keep Emacsens' auto-indent happy */
  35 }
  36 #endif
  37 #endif
  38
  39 #include "gnunet_common.h"
  40 #include "gnunet_connection_lib.h"
  41
  42
  43 /**
  44  * Largest supported message.
  45  */
  46 #define GNUNET_SERVER_MAX_MESSAGE_SIZE 65536
  47
  48 /**
  49  * Smallest supported message.
  50  */
  51 #define GNUNET_SERVER_MIN_BUFFER_SIZE sizeof (struct GNUNET_MessageHeader)
  52
  53 /**
  54  * @brief handle for a server
  55  */
  56 struct GNUNET_SERVER_Handle;
  57
  58 /**
  59  * @brief opaque handle for a client of the server
  60  */
  61 struct GNUNET_SERVER_Client;
  62
  63 /**
  64  * @brief opaque handle server returns for aborting transmission to a client.
  65  */
  66 struct GNUNET_SERVER_TransmitHandle;
  67
  68
  69 /**
  70  * Functions with this signature are called whenever a message is
  71  * received.
  72  *
  73  * @param cls closure
  74  * @param client identification of the client
  75  * @param message the actual message
  76  */
  77 typedef void (*GNUNET_SERVER_MessageCallback) (void *cls,
  78                                                struct GNUNET_SERVER_Client *
  79                                                client,
  80                                                const struct GNUNET_MessageHeader
  81                                                * message);
  82
  83
  84
  85 /**
  86  * Message handler.  Each struct specifies how to handle on particular
  87  * type of message received.
  88  */
  89 struct GNUNET_SERVER_MessageHandler
  90 {
  91   /**
  92    * Function to call for messages of "type".
  93    */
  94   GNUNET_SERVER_MessageCallback callback;
  95
  96   /**
  97    * Closure argument for "callback".
  98    */
  99   void *callback_cls;
 100
 101   /**
 102    * Type of the message this handler covers.
 103    */
 104   uint16_t type;
 105
 106   /**
 107    * Expected size of messages of this type.  Use 0 for
 108    * variable-size.  If non-zero, messages of the given
 109    * type will be discarded (and the connection closed)
 110    * if they do not have the right size.
 111    */
 112   uint16_t expected_size;
 113
 114 };
 115
 116
 117 /**
 118  * Create a new server.
 119  *
 120  * @param access function for access control
 121  * @param access_cls closure for access
 122  * @param lsocks NULL-terminated array of listen sockets
 123  * @param idle_timeout after how long should we timeout idle connections?
 124  * @param require_found if YES, connections sending messages of unknown type
 125  *        will be closed
 126  * @return handle for the new server, NULL on error
 127  *         (typically, "port" already in use)
 128  */
 129 struct GNUNET_SERVER_Handle *
 130 GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access,
 131                                    void *access_cls,
 132                                    struct GNUNET_NETWORK_Handle **lsocks,
 133                                    struct GNUNET_TIME_Relative idle_timeout,
 134                                    int require_found);
 135
 136 /**
 137  * Create a new server.
 138  *
 139  * @param access function for access control
 140  * @param access_cls closure for access
 141  * @param serverAddr address toes listen on (including port), NULL terminated array
 142  * @param socklen lengths of respective serverAddr
 143  * @param idle_timeout after how long should we timeout idle connections?
 144  * @param require_found if YES, connections sending messages of unknown type
 145  *        will be closed
 146  * @return handle for the new server, NULL on error
 147  *         (typically, "port" already in use)
 148  */
 149 struct GNUNET_SERVER_Handle *
 150 GNUNET_SERVER_create (GNUNET_CONNECTION_AccessCheck access, void *access_cls,
 151                       struct sockaddr *const *serverAddr,
 152                       const socklen_t * socklen,
 153                       struct GNUNET_TIME_Relative idle_timeout,
 154                       int require_found);
 155
 156
 157 /**
 158  * Stop the listen socket and get ready to shutdown the server
 159  * once only 'monitor' clients are left.
 160  *
 161  * @param server server to stop listening on
 162  */
 163 void
 164 GNUNET_SERVER_stop_listening (struct GNUNET_SERVER_Handle *server);
 165
 166
 167 /**
 168  * Free resources held by this server.
 169  *
 170  * @param server server to destroy
 171  */
 172 void
 173 GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *server);
 174
 175
 176 /**
 177  * Add additional handlers to an existing server.
 178  *
 179  * @param server the server to add handlers to
 180  * @param handlers array of message handlers for
 181  *        incoming messages; the last entry must
 182  *        have "NULL" for the "callback"; multiple
 183  *        entries for the same type are allowed,
 184  *        they will be called in order of occurence.
 185  *        These handlers can be removed later;
 186  *        the handlers array must exist until removed
 187  *        (or server is destroyed).
 188  */
 189 void
 190 GNUNET_SERVER_add_handlers (struct GNUNET_SERVER_Handle *server,
 191                             const struct GNUNET_SERVER_MessageHandler
 192                             *handlers);
 193
 194
 195 /**
 196  * Notify us when the server has enough space to transmit
 197  * a message of the given size to the given client.
 198  *
 199  * @param client client to transmit message to
 200  * @param size requested amount of buffer space
 201  * @param timeout after how long should we give up (and call
 202  *        notify with buf NULL and size 0)?
 203  * @param callback function to call when space is available
 204  * @param callback_cls closure for callback
 205  * @return non-NULL if the notify callback was queued; can be used
 206  *           to cancel the request using
 207  *           GNUNET_SERVER_notify_transmit_ready_cancel.
 208  *         NULL if we are already going to notify someone else (busy)
 209  */
 210 struct GNUNET_SERVER_TransmitHandle *
 211 GNUNET_SERVER_notify_transmit_ready (struct GNUNET_SERVER_Client *client,
 212                                      size_t size,
 213                                      struct GNUNET_TIME_Relative timeout,
 214                                      GNUNET_CONNECTION_TransmitReadyNotify
 215                                      callback, void *callback_cls);
 216
 217
 218 /**
 219  * Abort transmission request.
 220  *
 221  * @param th request to abort
 222  */
 223 void
 224 GNUNET_SERVER_notify_transmit_ready_cancel (struct GNUNET_SERVER_TransmitHandle *th);
 225
 226
 227 /**
 228  * Set the 'monitor' flag on this client.  Clients which have been
 229  * marked as 'monitors' won't prevent the server from shutting down
 230  * once 'GNUNET_SERVER_stop_listening' has been invoked.  The idea is
 231  * that for "normal" clients we likely want to allow them to process
 232  * their requests; however, monitor-clients are likely to 'never'
 233  * disconnect during shutdown and thus will not be considered when
 234  * determining if the server should continue to exist after
 235  * 'GNUNET_SERVER_destroy' has been called.
 236  *
 237  * @param client the client to set the 'monitor' flag on
 238  */
 239 void
 240 GNUNET_SERVER_client_mark_monitor (struct GNUNET_SERVER_Client *client);
 241
 242
 243 /**
 244  * Set the persistent flag on this client, used to setup client connection
 245  * to only be killed when the service it's connected to is actually dead.
 246  *
 247  * @param client the client to set the persistent flag on
 248  */
 249 void
 250 GNUNET_SERVER_client_persist_ (struct GNUNET_SERVER_Client *client);
 251
 252
 253 /**
 254  * Resume receiving from this client, we are done processing the
 255  * current request.  This function must be called from within each
 256  * GNUNET_SERVER_MessageCallback (or its respective continuations).
 257  *
 258  * @param client client we were processing a message of
 259  * @param success GNUNET_OK to keep the connection open and
 260  *                          continue to receive
 261  *                GNUNET_NO to close the connection (normal behavior)
 262  *                GNUNET_SYSERR to close the connection (signal
 263  *                          serious error)
 264  */
 265 void
 266 GNUNET_SERVER_receive_done (struct GNUNET_SERVER_Client *client, int success);
 267
 268
 269 /**
 270  * Change the timeout for a particular client.  Decreasing the timeout
 271  * may not go into effect immediately (only after the previous timeout
 272  * times out or activity happens on the socket).
 273  *
 274  * @param client the client to update
 275  * @param timeout new timeout for activities on the socket
 276  */
 277 void
 278 GNUNET_SERVER_client_set_timeout (struct GNUNET_SERVER_Client *client,
 279                                   struct GNUNET_TIME_Relative timeout);
 280
 281
 282 /**
 283  * Disable the warning the server issues if a message is not acknowledged
 284  * in a timely fashion.  Use this call if a client is intentionally delayed
 285  * for a while.  Only applies to the current message.
 286  *
 287  * @param client client for which to disable the warning
 288  */
 289 void
 290 GNUNET_SERVER_disable_receive_done_warning (struct GNUNET_SERVER_Client
 291                                             *client);
 292
 293
 294 /**
 295  * Inject a message into the server, pretend it came
 296  * from the specified client.  Delivery of the message
 297  * will happen instantly (if a handler is installed;
 298  * otherwise the call does nothing).
 299  *
 300  * @param server the server receiving the message
 301  * @param sender the "pretended" sender of the message
 302  *        can be NULL!
 303  * @param message message to transmit
 304  * @return GNUNET_OK if the message was OK and the
 305  *                   connection can stay open
 306  *         GNUNET_SYSERR if the connection to the
 307  *         client should be shut down
 308  */
 309 int
 310 GNUNET_SERVER_inject (struct GNUNET_SERVER_Handle *server,
 311                       struct GNUNET_SERVER_Client *sender,
 312                       const struct GNUNET_MessageHeader *message);
 313
 314
 315 /**
 316  * Add a TCP socket-based connection to the set of handles managed by
 317  * this server.  Use this function for outgoing (P2P) connections that
 318  * we initiated (and where this server should process incoming
 319  * messages).
 320  *
 321  * @param server the server to use
 322  * @param connection the connection to manage (client must
 323  *        stop using this connection from now on)
 324  * @return the client handle (client should call
 325  *         "client_drop" on the return value eventually)
 326  */
 327 struct GNUNET_SERVER_Client *
 328 GNUNET_SERVER_connect_socket (struct GNUNET_SERVER_Handle *server,
 329                               struct GNUNET_CONNECTION_Handle *connection);
 330
 331
 332 /**
 333  * Notify the server that the given client handle should
 334  * be kept (keeps the connection up if possible, increments
 335  * the internal reference counter).
 336  *
 337  * @param client the client to keep
 338  */
 339 void
 340 GNUNET_SERVER_client_keep (struct GNUNET_SERVER_Client *client);
 341
 342
 343 /**
 344  * Notify the server that the given client handle is no
 345  * longer required.  Decrements the reference counter.  If
 346  * that counter reaches zero an inactive connection maybe
 347  * closed.
 348  *
 349  * @param client the client to drop
 350  */
 351 void
 352 GNUNET_SERVER_client_drop (struct GNUNET_SERVER_Client *client);
 353
 354
 355 /**
 356  * Obtain the network address of the other party.
 357  *
 358  * @param client the client to get the address for
 359  * @param addr where to store the address
 360  * @param addrlen where to store the length of the address
 361  * @return GNUNET_OK on success
 362  */
 363 int
 364 GNUNET_SERVER_client_get_address (struct GNUNET_SERVER_Client *client,
 365                                   void **addr, size_t * addrlen);
 366
 367
 368 /**
 369  * Functions with this signature are called whenever a client
 370  * is disconnected on the network level.
 371  *
 372  * @param cls closure
 373  * @param client identification of the client; NULL
 374  *        for the last call when the server is destroyed
 375  */
 376 typedef void (*GNUNET_SERVER_DisconnectCallback) (void *cls,
 377                                                   struct GNUNET_SERVER_Client *
 378                                                   client);
 379
 380
 381 /**
 382  * Ask the server to notify us whenever a client disconnects.
 383  * This function is called whenever the actual network connection
 384  * is closed; the reference count may be zero or larger than zero
 385  * at this point.  If the server is destroyed before this
 386  * notification is explicitly cancelled, the 'callback' will
 387  * once be called with a 'client' argument of NULL to indicate
 388  * that the server itself is now gone (and that the callback
 389  * won't be called anymore and also can no longer be cancelled).
 390  *
 391  * @param server the server manageing the clients
 392  * @param callback function to call on disconnect
 393  * @param callback_cls closure for callback
 394  */
 395 void
 396 GNUNET_SERVER_disconnect_notify (struct GNUNET_SERVER_Handle *server,
 397                                  GNUNET_SERVER_DisconnectCallback callback,
 398                                  void *callback_cls);
 399
 400
 401 /**
 402  * Ask the server to stop notifying us whenever a client disconnects.
 403  *
 404  * @param server the server manageing the clients
 405  * @param callback function to call on disconnect
 406  * @param callback_cls closure for callback
 407  */
 408 void
 409 GNUNET_SERVER_disconnect_notify_cancel (struct GNUNET_SERVER_Handle *server,
 410                                         GNUNET_SERVER_DisconnectCallback
 411                                         callback, void *callback_cls);
 412
 413
 414 /**
 415  * Ask the server to disconnect from the given client.
 416  * This is the same as returning GNUNET_SYSERR from a message
 417  * handler, except that it allows dropping of a client even
 418  * when not handling a message from that client.
 419  *
 420  * @param client the client to disconnect from
 421  */
 422 void
 423 GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client);
 424
 425
 426 /**
 427  * Disable the "CORK" feature for communication with the given client,
 428  * forcing the OS to immediately flush the buffer on transmission
 429  * instead of potentially buffering multiple messages.
 430  *
 431  * @param client handle to the client
 432  * @return GNUNET_OK on success
 433  */
 434 int
 435 GNUNET_SERVER_client_disable_corking (struct GNUNET_SERVER_Client *client);
 436
 437
 438 /**
 439  * The tansmit context is the key datastructure for a conveniance API
 440  * used for transmission of complex results to the client followed
 441  * ONLY by signaling receive_done with success or error
 442  */
 443 struct GNUNET_SERVER_TransmitContext;
 444
 445
 446 /**
 447  * Create a new transmission context for the
 448  * given client.
 449  *
 450  * @param client client to create the context for.
 451  * @return NULL on error
 452  */
 453 struct GNUNET_SERVER_TransmitContext *
 454 GNUNET_SERVER_transmit_context_create (struct GNUNET_SERVER_Client *client);
 455
 456
 457 /**
 458  * Append a message to the transmission context.
 459  * All messages in the context will be sent by
 460  * the transmit_context_run method.
 461  *
 462  * @param tc context to use
 463  * @param data what to append to the result message
 464  * @param length length of data
 465  * @param type type of the message
 466  */
 467 void
 468 GNUNET_SERVER_transmit_context_append_data (struct GNUNET_SERVER_TransmitContext
 469                                             *tc, const void *data,
 470                                             size_t length, uint16_t type);
 471
 472
 473 /**
 474  * Append a message to the transmission context.
 475  * All messages in the context will be sent by
 476  * the transmit_context_run method.
 477  *
 478  * @param tc context to use
 479  * @param msg message to append
 480  */
 481 void
 482 GNUNET_SERVER_transmit_context_append_message (struct
 483                                                GNUNET_SERVER_TransmitContext
 484                                                *tc,
 485                                                const struct GNUNET_MessageHeader
 486                                                *msg);
 487
 488
 489 /**
 490  * Execute a transmission context.  If there is an error in the
 491  * transmission, the receive_done method will be called with an error
 492  * code (GNUNET_SYSERR), otherwise with GNUNET_OK.
 493  *
 494  * @param tc transmission context to use
 495  * @param timeout when to time out and abort the transmission
 496  */
 497 void
 498 GNUNET_SERVER_transmit_context_run (struct GNUNET_SERVER_TransmitContext *tc,
 499                                     struct GNUNET_TIME_Relative timeout);
 500
 501
 502 /**
 503  * Destroy a transmission context.  This function must not be called
 504  * after 'GNUNET_SERVER_transmit_context_run'.
 505  *
 506  * @param tc transmission context to destroy
 507  * @param success code to give to 'GNUNET_SERVER_receive_done' for
 508  *        the client:  GNUNET_OK to keep the connection open and
 509  *                          continue to receive
 510  *                GNUNET_NO to close the connection (normal behavior)
 511  *                GNUNET_SYSERR to close the connection (signal
 512  *                          serious error)
 513  */
 514 void
 515 GNUNET_SERVER_transmit_context_destroy (struct GNUNET_SERVER_TransmitContext
 516                                         *tc, int success);
 517
 518
 519 /**
 520  * The notification context is the key datastructure for a conveniance
 521  * API used for transmission of notifications to the client until the
 522  * client disconnects (or the notification context is destroyed, in
 523  * which case we disconnect these clients).  Essentially, all
 524  * (notification) messages are queued up until the client is able to
 525  * read them.
 526  */
 527 struct GNUNET_SERVER_NotificationContext;
 528
 529
 530 /**
 531  * Create a new notification context.
 532  *
 533  * @param server server for which this function creates the context
 534  * @param queue_length maximum number of messages to keep in
 535  *        the notification queue; optional messages are dropped
 536  *        if the queue gets longer than this number of messages
 537  * @return handle to the notification context
 538  */
 539 struct GNUNET_SERVER_NotificationContext *
 540 GNUNET_SERVER_notification_context_create (struct GNUNET_SERVER_Handle *server,
 541                                            unsigned int queue_length);
 542
 543
 544 /**
 545  * Destroy the context, force disconnect for all clients.
 546  *
 547  * @param nc context to destroy.
 548  */
 549 void
 550 GNUNET_SERVER_notification_context_destroy (struct
 551                                             GNUNET_SERVER_NotificationContext
 552                                             *nc);
 553
 554
 555 /**
 556  * Add a client to the notification context.
 557  *
 558  * @param nc context to modify
 559  * @param client client to add
 560  */
 561 void
 562 GNUNET_SERVER_notification_context_add (struct GNUNET_SERVER_NotificationContext
 563                                         *nc,
 564                                         struct GNUNET_SERVER_Client *client);
 565
 566
 567 /**
 568  * Send a message to a particular client; must have
 569  * already been added to the notification context.
 570  *
 571  * @param nc context to modify
 572  * @param client client to transmit to
 573  * @param msg message to send
 574  * @param can_drop can this message be dropped due to queue length limitations
 575  */
 576 void
 577 GNUNET_SERVER_notification_context_unicast (struct
 578                                             GNUNET_SERVER_NotificationContext
 579                                             *nc,
 580                                             struct GNUNET_SERVER_Client *client,
 581                                             const struct GNUNET_MessageHeader
 582                                             *msg, int can_drop);
 583
 584
 585 /**
 586  * Send a message to all clients of this context.
 587  *
 588  * @param nc context to modify
 589  * @param msg message to send
 590  * @param can_drop can this message be dropped due to queue length limitations
 591  */
 592 void
 593 GNUNET_SERVER_notification_context_broadcast (struct
 594                                               GNUNET_SERVER_NotificationContext
 595                                               *nc,
 596                                               const struct GNUNET_MessageHeader
 597                                               *msg, int can_drop);
 598
 599
 600
 601 /**
 602  * Handle to a message stream tokenizer.
 603  */
 604 struct GNUNET_SERVER_MessageStreamTokenizer;
 605
 606 /**
 607  * Functions with this signature are called whenever a
 608  * complete message is received by the tokenizer.
 609  *
 610  * Do not call GNUNET_SERVER_mst_destroy in callback
 611  *
 612  * @param cls closure
 613  * @param client identification of the client
 614  * @param message the actual message
 615  *
 616  * @return GNUNET_OK on success, GNUNET_SYSERR to stop further processing
 617  */
 618 typedef int (*GNUNET_SERVER_MessageTokenizerCallback) (void *cls, void *client,
 619                                                         const struct
 620                                                         GNUNET_MessageHeader *
 621                                                         message);
 622
 623
 624 /**
 625  * Create a message stream tokenizer.
 626  *
 627  * @param cb function to call on completed messages
 628  * @param cb_cls closure for cb
 629  * @return handle to tokenizer
 630  */
 631 struct GNUNET_SERVER_MessageStreamTokenizer *
 632 GNUNET_SERVER_mst_create (GNUNET_SERVER_MessageTokenizerCallback cb,
 633                           void *cb_cls);
 634
 635
 636 /**
 637  * Add incoming data to the receive buffer and call the
 638  * callback for all complete messages.
 639  *
 640  * @param mst tokenizer to use
 641  * @param client_identity ID of client for which this is a buffer,
 642  *        can be NULL (will be passed back to 'cb')
 643  * @param buf input data to add
 644  * @param size number of bytes in buf
 645  * @param purge should any excess bytes in the buffer be discarded
 646  *       (i.e. for packet-based services like UDP)
 647  * @param one_shot only call callback once, keep rest of message in buffer
 648  * @return GNUNET_OK if we are done processing (need more data)
 649  *         GNUNET_NO if one_shot was set and we have another message ready
 650  *         GNUNET_SYSERR if the data stream is corrupt
 651  */
 652 int
 653 GNUNET_SERVER_mst_receive (struct GNUNET_SERVER_MessageStreamTokenizer *mst,
 654                            void *client_identity, const char *buf, size_t size,
 655                            int purge, int one_shot);
 656
 657
 658 /**
 659  * Destroys a tokenizer.
 660  *
 661  * @param mst tokenizer to destroy
 662  */
 663 void
 664 GNUNET_SERVER_mst_destroy (struct GNUNET_SERVER_MessageStreamTokenizer *mst);
 665
 666
 667 /**
 668  * Signature of a function to create a custom tokenizer.
 669  *
 670  * @param cls closure from 'GNUNET_SERVER_set_callbacks'
 671  * @param client handle to client the tokenzier will be used for
 672  * @return handle to custom tokenizer ('mst')
 673  */
 674 typedef void* (*GNUNET_SERVER_MstCreateCallback) (void *cls,
 675                                                   struct GNUNET_SERVER_Client *client);
 676
 677 /**
 678  * Signature of a function to destroy a custom tokenizer.
 679  *
 680  * @param cls closure from 'GNUNET_SERVER_set_callbacks'
 681  * @param mst custom tokenizer handle
 682  */
 683 typedef void (*GNUNET_SERVER_MstDestroyCallback) (void *cls, void *mst);
 684
 685 /**
 686  * Signature of a function to destroy a custom tokenizer.
 687  *
 688  * @param cls closure from 'GNUNET_SERVER_set_callbacks'
 689  * @param mst custom tokenizer handle
 690  * @param client_identity ID of client for which this is a buffer,
 691  *        can be NULL (will be passed back to 'cb')
 692  * @param buf input data to add
 693  * @param size number of bytes in buf
 694  * @param purge should any excess bytes in the buffer be discarded
 695  *       (i.e. for packet-based services like UDP)
 696  * @param one_shot only call callback once, keep rest of message in buffer
 697  * @return GNUNET_OK if we are done processing (need more data)
 698  *         GNUNET_NO if one_shot was set and we have another message ready
 699  *         GNUNET_SYSERR if the data stream is corrupt
 700  */
 701 typedef int (*GNUNET_SERVER_MstReceiveCallback) (void *cls, void *mst,
 702                                                  struct GNUNET_SERVER_Client *client,
 703                                                  const char *buf, size_t size,
 704                                                  int purge, int one_shot);
 705
 706
 707 /**
 708  * Change functions used by the server to tokenize the message stream.
 709  * (very rarely used).
 710  *
 711  * @param server server to modify
 712  * @param create new tokenizer initialization function
 713  * @param destroy new tokenizer destruction function
 714  * @param receive new tokenizer receive function
 715  * @param cls closure for 'create', 'receive', 'destroy'
 716  */
 717 void
 718 GNUNET_SERVER_set_callbacks (struct GNUNET_SERVER_Handle *server,
 719                              GNUNET_SERVER_MstCreateCallback create,
 720                              GNUNET_SERVER_MstDestroyCallback destroy,
 721                              GNUNET_SERVER_MstReceiveCallback receive,
 722                              void *cls);
 723
 724
 725 #if 0                           /* keep Emacsens' auto-indent happy */
 726 {
 727 #endif
 728 #ifdef __cplusplus
 729 }
 730 #endif
 731
 732
 733 /* ifndef GNUNET_SERVER_LIB_H */
 734 #endif
 735 /* end of gnunet_server_lib.h */