HKDF (does not work yet)

[oweals/gnunet.git] / src / include / gnunet_client_lib.h

diff --git a/src/include/gnunet_client_lib.h b/src/include/gnunet_client_lib.h
index 20842de5c238be7458e8a4e2e44acee265cc10f6..49ccc6c6b11e9dacad3e403789363a71ccedaccd 100644 (file)
--- a/src/include/gnunet_client_lib.h
+++ b/src/include/gnunet_client_lib.h
@@ -63,13 +63,36 @@ struct GNUNET_CLIENT_Connection *GNUNET_CLIENT_connect (struct
                                                         GNUNET_CONFIGURATION_Handle
                                                         *cfg);
 
+
 /**
- * Destroy connection with the service.  This will
- * automatically cancel any pending "receive" request
- * (however, the handler will *NOT* be called, not
- * even with a NULL message).
+ * Configure this connection to ignore shutdown signals.
+ *
+ * @param h client handle
+ * @param do_ignore GNUNET_YES to ignore, GNUNET_NO to restore default
  */
-void GNUNET_CLIENT_disconnect (struct GNUNET_CLIENT_Connection *sock);
+void
+GNUNET_CLIENT_ignore_shutdown (struct GNUNET_CLIENT_Connection *h,
+                              int do_ignore);
+
+
+
+/**
+ * Destroy connection with the service.  This will automatically
+ * cancel any pending "receive" request (however, the handler will
+ * *NOT* be called, not even with a NULL message).  Any pending
+ * transmission request will also be cancelled UNLESS the callback for
+ * the transmission request has already been called, in which case the
+ * transmission 'finish_pending_write' argument determines whether or
+ * not the write is guaranteed to complete before the socket is fully
+ * destroyed (unless, of course, there is an error with the server in
+ * which case the message may still be lost).
+ *
+ * @param sock handle to the service connection
+ * @param finish_pending_write should a transmission already passed to the
+ *          handle be completed?
+ */
+void GNUNET_CLIENT_disconnect (struct GNUNET_CLIENT_Connection *sock,
+                              int finish_pending_write);
 
 /**
  * Type of a function to call when we receive a message
@@ -82,6 +105,19 @@ typedef void (*GNUNET_CLIENT_MessageHandler) (void *cls,
                                               const struct
                                               GNUNET_MessageHeader * msg);
 
+/**
+ * Type of a function to call when we have finished shutting
+ * down a service, or failed.
+ *
+ * @param cls closure
+ * @param reason what is the result of the shutdown
+ *        GNUNET_NO on shutdown (not running)
+ *        GNUNET_YES on running
+ *        GNUNET_SYSERR on failure to transmit message
+ */
+typedef void (*GNUNET_CLIENT_ShutdownTask) (void *cls,
+                                            int reason);
+
 /**
  * Read from the service.
  *
@@ -96,6 +132,12 @@ void GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock,
                            struct GNUNET_TIME_Relative timeout);
 
 
+/**
+ * Transmit handle for client connections.
+ */
+struct GNUNET_CLIENT_TransmitHandle;
+
+
 /**
  * Ask the client to call us once the specified number of bytes
  * are free in the transmission buffer.  May call the notify
@@ -105,19 +147,34 @@ void GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock,
  * @param size number of bytes to send
  * @param timeout after how long should we give up (and call
  *        notify with buf NULL and size 0)?
+ * @param auto_retry if the connection to the service dies, should we
+ *        automatically re-connect and retry (within the timeout period)
+ *        or should we immediately fail in this case?  Pass GNUNET_YES
+ *        if the caller does not care about temporary connection errors,
+ *        for example because the protocol is stateless
  * @param notify function to call
  * @param notify_cls closure for notify
  * @return NULL if someone else is already waiting to be notified
  *         non-NULL if the notify callback was queued (can be used to cancel
  *         using GNUNET_CONNECTION_notify_transmit_ready_cancel)
  */
-struct GNUNET_CONNECTION_TransmitHandle
+struct GNUNET_CLIENT_TransmitHandle
   *GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *sock,
                                         size_t size,
                                         struct GNUNET_TIME_Relative timeout,
+                                       int auto_retry,
                                         GNUNET_CONNECTION_TransmitReadyNotify
-                                        notify, void *notify_cls);
+                                        notify,
+                                       void *notify_cls);
+
 
+/**
+ * Cancel a request for notification.
+ * 
+ * @param th handle from the original request.
+ */
+void
+GNUNET_CLIENT_notify_transmit_ready_cancel (struct GNUNET_CLIENT_TransmitHandle *th);
 
 
 /**
@@ -131,27 +188,25 @@ struct GNUNET_CONNECTION_TransmitHandle
  * @param hdr message to transmit
  * @param timeout when to give up (for both transmission
  *         and for waiting for a response)
+ * @param auto_retry if the connection to the service dies, should we
+ *        automatically re-connect and retry (within the timeout period)
+ *        or should we immediately fail in this case?  Pass GNUNET_YES
+ *        if the caller does not care about temporary connection errors,
+ *        for example because the protocol is stateless
  * @param rn function to call with the response
  * @param rn_cls closure for rn 
+ * @return GNUNET_OK on success, GNUNET_SYSERR if a request
+ *         is already pending
  */
-void
+int
 GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection *sock,
                                         const struct GNUNET_MessageHeader *hdr,
                                         struct GNUNET_TIME_Relative timeout,
+                                        int auto_retry,
                                         GNUNET_CLIENT_MessageHandler rn,
                                         void *rn_cls);
 
 
-
-/**
- * Request that the service should shutdown.
- * Afterwards, the connection should be disconnected.
- *
- * @param sock the socket connected to the service
- */
-void GNUNET_CLIENT_service_shutdown (struct GNUNET_CLIENT_Connection *sock);
-
-
 /**
  * Wait until the service is running.
  *