/**
* Get a connection with a service.
*
- * @param sched scheduler to use
* @param service_name name of the service
* @param cfg configuration to use
* @return NULL on error (service unknown to configuration)
*/
-struct GNUNET_CLIENT_Connection *GNUNET_CLIENT_connect (struct
- GNUNET_SCHEDULER_Handle
- *sched,
- const char
- *service_name,
- const struct
- GNUNET_CONFIGURATION_Handle
- *cfg);
-
-
-/**
- * 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_ignore_shutdown (struct GNUNET_CLIENT_Connection *h,
- int do_ignore);
-
+struct GNUNET_CLIENT_Connection *
+GNUNET_CLIENT_connect (const char *service_name,
+ const struct GNUNET_CONFIGURATION_Handle *cfg);
/**
* 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?
+ * @param client handle to the service connection
*/
-void GNUNET_CLIENT_disconnect (struct GNUNET_CLIENT_Connection *sock,
- int finish_pending_write);
+void
+GNUNET_CLIENT_disconnect (struct GNUNET_CLIENT_Connection *client);
+
/**
* Type of a function to call when we receive a message
* @param msg message received, NULL on timeout or fatal error
*/
typedef void (*GNUNET_CLIENT_MessageHandler) (void *cls,
- const struct
- GNUNET_MessageHeader * msg);
+ 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.
*
- * @param sock the service
+ * @param client connection to the service
* @param handler function to call with the message
* @param handler_cls closure for handler
* @param timeout how long to wait until timing out
*/
-void GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock,
- GNUNET_CLIENT_MessageHandler handler,
- void *handler_cls,
- struct GNUNET_TIME_Relative timeout);
+void
+GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *client,
+ GNUNET_CLIENT_MessageHandler handler, void *handler_cls,
+ struct GNUNET_TIME_Relative timeout);
/**
* are free in the transmission buffer. May call the notify
* method immediately if enough space is available.
*
- * @param sock connection to the service
+ * @param client connection to the service
* @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)?
* non-NULL if the notify callback was queued (can be used to cancel
* using GNUNET_CONNECTION_notify_transmit_ready_cancel)
*/
-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);
+struct GNUNET_CLIENT_TransmitHandle *
+GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *client,
+ size_t size,
+ struct GNUNET_TIME_Relative timeout,
+ int auto_retry,
+ GNUNET_CONNECTION_TransmitReadyNotify
+ 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);
+GNUNET_CLIENT_notify_transmit_ready_cancel (struct GNUNET_CLIENT_TransmitHandle
+ *th);
/**
* will be called with a "NULL" response (in which
* case the connection should probably be destroyed).
*
- * @param sock connection to use
+ * @param client connection to use
* @param hdr message to transmit
* @param timeout when to give up (for both transmission
* and for waiting for a response)
* 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
+ * @param rn_cls closure for rn
* @return GNUNET_OK on success, GNUNET_SYSERR if a request
* is already pending
*/
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 will automatically be
- * disconnected. Hence the "sock" shoud not
- * be used by the caller after this call
- * (calling this function frees "sock" after a while).
- *
- * @param sock the socket connected to the service
- */
-void GNUNET_CLIENT_service_shutdown (struct GNUNET_CLIENT_Connection *sock);
+GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection *client,
+ const struct GNUNET_MessageHeader *hdr,
+ struct GNUNET_TIME_Relative timeout,
+ int auto_retry,
+ GNUNET_CLIENT_MessageHandler rn,
+ void *rn_cls);
/**
* Wait until the service is running.
*
- * @param sched scheduler to use
* @param service name of the service to wait for
* @param cfg configuration to use
* @param timeout how long to wait at most in ms
* or "TIMEOUT" (service not known to be running))
* @param task_cls closure for task
*/
-void GNUNET_CLIENT_service_test (struct GNUNET_SCHEDULER_Handle *sched,
- const char *service,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct GNUNET_TIME_Relative timeout,
- GNUNET_SCHEDULER_Task task, void *task_cls);
+void
+GNUNET_CLIENT_service_test (const char *service,
+ const struct GNUNET_CONFIGURATION_Handle *cfg,
+ struct GNUNET_TIME_Relative timeout,
+ GNUNET_SCHEDULER_Task task, void *task_cls);
#if 0 /* keep Emacsens' auto-indent happy */