summaryrefslogtreecommitdiff
path: root/lib/tevent
diff options
context:
space:
mode:
Diffstat (limited to 'lib/tevent')
-rw-r--r--lib/tevent/doc/mainpage.dox42
-rw-r--r--lib/tevent/tevent.h390
-rw-r--r--lib/tevent/tevent_req.c184
3 files changed, 426 insertions, 190 deletions
diff --git a/lib/tevent/doc/mainpage.dox b/lib/tevent/doc/mainpage.dox
new file mode 100644
index 0000000000..5cd3969c78
--- /dev/null
+++ b/lib/tevent/doc/mainpage.dox
@@ -0,0 +1,42 @@
+/**
+ * @mainpage
+ *
+ * Tevent is an event system based on the talloc memory management library. It
+ * is the core event system used in Samba.
+ *
+ * The low level tevent has support for many event types, including timers,
+ * signals, and the classic file descriptor events.
+ *
+ * Tevent also provide helpers to deal with asynchronous code providing the
+ * tevent_req (tevent tequest) functions.
+ *
+ * @section tevent_download Download
+ *
+ * You can download the latest releases of tevent from the
+ * <a href="http://samba.org/ftp/tevent" target="_blank">tevent directory</a>
+ * on the samba public source archive.
+ *
+ * @section tevent_bugs Discussion and bug reports
+ *
+ * tevent does not currently have its own mailing list or bug tracking system.
+ * For now, please use the
+ * <a href="https://lists.samba.org/mailman/listinfo/samba-technical" target="_blank">samba-technical</a>
+ * mailing list, and the
+ * <a href="http://bugzilla.samba.org/" target="_blank">Samba bugzilla</a>
+ * bug tracking system.
+ *
+ * @section tevent_devel Development
+ * You can download the latest code either via git or rsync.
+ *
+ * To fetch via git see the following guide:
+ *
+ * <a href="http://wiki.samba.org/index.php/Using_Git_for_Samba_Development" target="_blank">Using Git for Samba Development</a>
+ *
+ * Once you have cloned the tree switch to the master branch and cd into the
+ * lib/tevent directory.
+ *
+ * To fetch via rsync use this command:
+ *
+ * rsync -Pavz samba.org::ftp/unpacked/standalone_projects/lib/tevent .
+ *
+ */
diff --git a/lib/tevent/tevent.h b/lib/tevent/tevent.h
index ad1f2c9cc3..edddcdf1d5 100644
--- a/lib/tevent/tevent.h
+++ b/lib/tevent/tevent.h
@@ -40,6 +40,16 @@ struct tevent_timer;
struct tevent_immediate;
struct tevent_signal;
+/**
+ * @defgroup tevent The tevent API
+ *
+ * The tevent low-level API
+ *
+ * @todo description
+ *
+ * @{
+ */
+
/* event handler types */
typedef void (*tevent_fd_handler_t)(struct tevent_context *ev,
struct tevent_fd *fde,
@@ -63,11 +73,86 @@ typedef void (*tevent_signal_handler_t)(struct tevent_context *ev,
void *siginfo,
void *private_data);
+/**
+ * @brief Create a event_context structure.
+ *
+ * This must be the first events call, and all subsequent calls pass this
+ * event_context as the first element. Event handlers also receive this as
+ * their first argument.
+ *
+ * @param[in] mem_ctx The memory context to use.
+ *
+ * @return An allocated tevent context, NULL on error.
+ *
+ * @see tevent_context_init()
+ */
struct tevent_context *tevent_context_init(TALLOC_CTX *mem_ctx);
+
+/**
+ * @brief Create a event_context structure and name it.
+ *
+ * This must be the first events call, and all subsequent calls pass this
+ * event_context as the first element. Event handlers also receive this as
+ * their first argument.
+ *
+ * @param[in] mem_ctx The memory context to use.
+ *
+ * @param[in] name The name for the tevent context.
+ *
+ * @return An allocated tevent context, NULL on error.
+ */
struct tevent_context *tevent_context_init_byname(TALLOC_CTX *mem_ctx, const char *name);
+
+/**
+ * @brief List available backends.
+ *
+ * @param[in] mem_ctx The memory context to use.
+ *
+ * @return A string vector with a terminating NULL element, NULL
+ * on error.
+ */
const char **tevent_backend_list(TALLOC_CTX *mem_ctx);
+
+/**
+ * @brief Set the default tevent backent.
+ *
+ * @param[in] backend The name of the backend to set.
+ */
void tevent_set_default_backend(const char *backend);
+#if DOXYGEN
+/**
+ * @brief Add a file descriptor based event.
+ *
+ * If flags contains TEVENT_FD_AUTOCLOSE then the fd will be closed when
+ * the returned fd_event context is freed.
+ *
+ * @param[in] ev The event context to work on.
+ *
+ * @param[in] mem_ctx The talloc memory context to use.
+ *
+ * @param[in] fd The file descriptor to base the event on.
+ *
+ * @param[in] flags
+ *
+ * @param[in] handler The callback handler for the event.
+ *
+ * @param[in] private_data The private data passed to the callback handler.
+ *
+ * @param[in] handler_name The name to identify the callback handler.
+ *
+ * @return The file descriptor based event, NULL on error.
+ *
+ * @todo Document flags
+ */
+struct tevent_fd *tevent_add_fd(struct tevent_context *ev,
+ TALLOC_CTX *mem_ctx,
+ int fd,
+ uint16_t flags,
+ tevent_fd_handler_t handler,
+ void *private_data,
+ const char *handler_name);
+#else
struct tevent_fd *_tevent_add_fd(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
int fd,
@@ -79,6 +164,7 @@ struct tevent_fd *_tevent_add_fd(struct tevent_context *ev,
#define tevent_add_fd(ev, mem_ctx, fd, flags, handler, private_data) \
_tevent_add_fd(ev, mem_ctx, fd, flags, handler, private_data, \
#handler, __location__)
+#endif
struct tevent_timer *_tevent_add_timer(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
@@ -150,7 +236,9 @@ void tevent_set_abort_fn(void (*abort_fn)(const char *reason));
#define TEVENT_FD_NOT_READABLE(fde) \
tevent_fd_set_flags(fde, tevent_fd_get_flags(fde) & ~TEVENT_FD_READ)
-/* DEBUG */
+/**
+ * Debug level of tevent
+ */
enum tevent_debug_level {
TEVENT_DEBUG_FATAL,
TEVENT_DEBUG_ERROR,
@@ -167,6 +255,28 @@ int tevent_set_debug(struct tevent_context *ev,
int tevent_set_debug_stderr(struct tevent_context *ev);
/**
+ * @}
+ */
+
+/**
+ * @defgroup tevent_request The tevent request functions.
+ * @ingroup tevent
+ *
+ * This represents an async request being processed by callbacks via an event
+ * context. A user can issue for example a write request to a socket, giving
+ * an implementation function the fd, the buffer and the number of bytes to
+ * transfer. The function issuing the request will immediately return without
+ * blocking most likely without having sent anything. The API user then fills
+ * in req->async.fn and req->async.private_data, functions that are called
+ * when the request is finished.
+ *
+ * It is up to the user of the async request to talloc_free it after it has
+ * finished. This can happen while the completion function is called.
+ *
+ * @{
+ */
+
+/**
* An async request moves between the following 4 states:
*/
enum tevent_req_state {
@@ -202,50 +312,132 @@ enum tevent_req_state {
/**
* @brief An async request
- *
- * This represents an async request being processed by callbacks via an event
- * context. A user can issue for example a write request to a socket, giving
- * an implementation function the fd, the buffer and the number of bytes to
- * transfer. The function issuing the request will immediately return without
- * blocking most likely without having sent anything. The API user then fills
- * in req->async.fn and req->async.private_data, functions that are called
- * when the request is finished.
- *
- * It is up to the user of the async request to talloc_free it after it has
- * finished. This can happen while the completion function is called.
*/
-
struct tevent_req;
typedef void (*tevent_req_fn)(struct tevent_req *);
void tevent_req_set_callback(struct tevent_req *req, tevent_req_fn fn, void *pvt);
-void *_tevent_req_callback_data(struct tevent_req *req);
-void *_tevent_req_data(struct tevent_req *req);
+void *_tevent_req_callback_data(struct tevent_req *req);
#define tevent_req_callback_data(_req, _type) \
talloc_get_type_abort(_tevent_req_callback_data(_req), _type)
+
#define tevent_req_callback_data_void(_req) \
_tevent_req_callback_data(_req)
+
+void *_tevent_req_data(struct tevent_req *req);
#define tevent_req_data(_req, _type) \
talloc_get_type_abort(_tevent_req_data(_req), _type)
typedef char *(*tevent_req_print_fn)(struct tevent_req *, TALLOC_CTX *);
+/**
+ * @brief This function sets a print function for the given request.
+ *
+ * This function can be used to setup a print function for the given request.
+ * This will be triggered if the tevent_req_print() function was
+ * called on the given request.
+ *
+ * @param[in] req The request to use.
+ *
+ * @param[in] fn A pointer to the print function
+ *
+ * @note This function should only be used for debugging.
+ */
void tevent_req_set_print_fn(struct tevent_req *req, tevent_req_print_fn fn);
+/**
+ * @brief The default print function for creating debug messages.
+ *
+ * The function should not be used by users of the async API,
+ * but custom print function can use it and append custom text
+ * to the string.
+ *
+ * @param[in] req The request to be printed.
+ *
+ * @param[in] mem_ctx The memory context for the result.
+ *
+ * @return Text representation of request.
+ *
+ */
char *tevent_req_default_print(struct tevent_req *req, TALLOC_CTX *mem_ctx);
+/**
+ * @brief Print an tevent_req structure in debug messages.
+ *
+ * This function should be used by callers of the async API.
+ *
+ * @param[in] mem_ctx The memory context for the result.
+ *
+ * @param[in] req The request to be printed.
+ *
+ * @return Text representation of request.
+ */
char *tevent_req_print(TALLOC_CTX *mem_ctx, struct tevent_req *req);
typedef bool (*tevent_req_cancel_fn)(struct tevent_req *);
+/**
+ * @brief This function sets a cancel function for the given tevent request.
+ *
+ * This function can be used to setup a cancel function for the given request.
+ * This will be triggered if the tevent_req_cancel() function was
+ * called on the given request.
+ *
+ * @param[in] req The request to use.
+ *
+ * @param[in] fn A pointer to the cancel function.
+ */
void tevent_req_set_cancel_fn(struct tevent_req *req, tevent_req_cancel_fn fn);
+#ifdef DOXYGEN
+/**
+ * @brief Try to cancel the given tevent request.
+ *
+ * This function can be used to cancel the given request.
+ *
+ * It is only possible to cancel a request when the implementation
+ * has registered a cancel function via the tevent_req_set_cancel_fn().
+ *
+ * @param[in] req The request to use.
+ *
+ * @return This function returns true is the request is cancelable,
+ * othererwise false is returned.
+ *
+ * @note Even if the function returns true, the caller need to wait
+ * for the function to complete normally.
+ * Only the _recv() function of the given request indicates
+ * if the request was really canceled.
+ */
+bool tevent_req_cancel(struct tevent_req *req);
+#else
bool _tevent_req_cancel(struct tevent_req *req, const char *location);
#define tevent_req_cancel(req) \
_tevent_req_cancel(req, __location__)
+#endif
+#if DOXYGEN
+/**
+ * @brief Create an async tevent request.
+ *
+ * The new async request will be initialized in state ASYNC_REQ_IN_PROGRESS.
+ *
+ * @param[in] mem_ctx The memory context for the result.
+ *
+ * @param[in] pstate The private state of the request.
+ *
+ * @param[in] state_size The size of the private state of the request.
+ *
+ * @param[in] type The name of the request.
+ *
+ * @return A new async request. NULL on error.
+ */
+struct tevent_req *tevent_req_create(TALLOC_CTX *mem_ctx,
+ void *pstate,
+ size_t state_size,
+ const char *type);
+#else
struct tevent_req *_tevent_req_create(TALLOC_CTX *mem_ctx,
void *pstate,
size_t state_size,
@@ -255,6 +447,7 @@ struct tevent_req *_tevent_req_create(TALLOC_CTX *mem_ctx,
#define tevent_req_create(_mem_ctx, _pstate, _type) \
_tevent_req_create((_mem_ctx), (_pstate), sizeof(_type), \
#_type, __location__)
+#endif
bool tevent_req_set_endtime(struct tevent_req *req,
struct tevent_context *ev,
@@ -264,28 +457,152 @@ void _tevent_req_notify_callback(struct tevent_req *req, const char *location);
#define tevent_req_notify_callback(req) \
_tevent_req_notify_callback(req, __location__)
+#ifdef DOXYGEN
+/**
+ * @brief An async request has successfully finished.
+ *
+ * This function is to be used by implementors of async requests. When a
+ * request is successfully finished, this function calls the user's completion
+ * function.
+ *
+ * @param[in] req The finished request.
+ */
+void tevent_req_done(struct tevent_req *req);
+#else
void _tevent_req_done(struct tevent_req *req,
const char *location);
#define tevent_req_done(req) \
_tevent_req_done(req, __location__)
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief An async request has seen an error.
+ *
+ * This function is to be used by implementors of async requests. When a
+ * request can not successfully completed, the implementation should call this
+ * function with the appropriate status code.
+ *
+ * If error is 0 the function returns false and does nothing more.
+ *
+ * @param[in] req The request with an error.
+ *
+ * @param[in] error The error code.
+ *
+ * @return On success true is returned, false if error is 0.
+ *
+ * @code
+ * int error = first_function();
+ * if (tevent_req_error(req, error)) {
+ * return;
+ * }
+ *
+ * error = second_function();
+ * if (tevent_req_error(req, error)) {
+ * return;
+ * }
+ *
+ * tevent_req_done(req);
+ * return;
+ * @endcode
+ */
+bool tevent_req_error(struct tevent_req *req,
+ uint64_t error);
+#else
bool _tevent_req_error(struct tevent_req *req,
uint64_t error,
const char *location);
#define tevent_req_error(req, error) \
_tevent_req_error(req, error, __location__)
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Helper function for nomem check.
+ *
+ * Convenience helper to easily check alloc failure within a callback
+ * implementing the next step of an async request.
+ *
+ * @param[in] p The pointer to be checked.
+ *
+ * @param[in] req The request being processed.
+ *
+ * @code
+ * p = talloc(mem_ctx, bla);
+ * if (tevent_req_nomem(p, req)) {
+ * return;
+ * }
+ * @endcode
+ */
+bool tevent_req_nomem(const void *p,
+ struct tevent_req *req);
+#else
bool _tevent_req_nomem(const void *p,
struct tevent_req *req,
const char *location);
#define tevent_req_nomem(p, req) \
_tevent_req_nomem(p, req, __location__)
+#endif
+/**
+ * @brief Finish a request before the caller had the change to set the callback.
+ *
+ * An implementation of an async request might find that it can either finish
+ * the request without waiting for an external event, or it can't even start
+ * the engine. To present the illusion of a callback to the user of the API,
+ * the implementation can call this helper function which triggers an
+ * immediate timed event. This way the caller can use the same calling
+ * conventions, independent of whether the request was actually deferred.
+ *
+ * @param[in] req The finished request.
+ *
+ * @param[in] ev The tevent_context for the timed event.
+ *
+ * @return The given request will be returned.
+ */
struct tevent_req *tevent_req_post(struct tevent_req *req,
struct tevent_context *ev);
+/**
+ * @brief Check if the given request is still in progress.
+ *
+ * It is typically used by sync wrapper functions.
+ *
+ * This function destroys the attached private data.
+ *
+ * @param[in] req The request to poll.
+ *
+ * @return The boolean form of "is in progress".
+ */
bool tevent_req_is_in_progress(struct tevent_req *req);
+/**
+ * @brief Actively poll for the given request to finish.
+ *
+ * This function is typically used by sync wrapper functions.
+ *
+ * @param[in] req The request to poll.
+ *
+ * @param[in] ev The tevent_context to be used.
+ *
+ * @return On success true is returned. If a critical error has
+ * happened in the tevent loop layer false is returned.
+ * This is not the return value of the given request!
+ *
+ * @note This should only be used if the given tevent context was created by the
+ * caller, to avoid event loop nesting.
+ *
+ * @code
+ * req = tstream_writev_queue_send(mem_ctx,
+ * ev_ctx,
+ * tstream,
+ * send_queue,
+ * iov, 2);
+ * ok = tevent_req_poll(req, tctx->ev);
+ * rc = tstream_writev_queue_recv(req, &sys_errno);
+ * TALLOC_FREE(req);
+ * @endcode
+ */
bool tevent_req_poll(struct tevent_req *req,
struct tevent_context *ev);
@@ -293,6 +610,13 @@ bool tevent_req_is_error(struct tevent_req *req,
enum tevent_req_state *state,
uint64_t *error);
+/**
+ * @brief Use as the last action of a _recv() function.
+ *
+ * This function destroys the attached private data.
+ *
+ * @param[in] req The finished request.
+ */
void tevent_req_received(struct tevent_req *req);
struct tevent_req *tevent_wakeup_send(TALLOC_CTX *mem_ctx,
@@ -300,6 +624,17 @@ struct tevent_req *tevent_wakeup_send(TALLOC_CTX *mem_ctx,
struct timeval wakeup_time);
bool tevent_wakeup_recv(struct tevent_req *req);
+/* @} */
+
+/**
+ * @defgroup tevent_helpers The tevent helper functiions
+ * @ingroup tevent
+ *
+ * @todo description
+ *
+ * @{
+ */
+
int tevent_timeval_compare(const struct timeval *tv1,
const struct timeval *tv2);
@@ -319,6 +654,16 @@ struct timeval tevent_timeval_add(const struct timeval *tv, uint32_t secs,
struct timeval tevent_timeval_current_ofs(uint32_t secs, uint32_t usecs);
+/* @} */
+
+
+/**
+ * @defgroup tevent_queue The tevent queue functions
+ * @ingroup tevent
+ *
+ * @{
+ */
+
struct tevent_queue;
struct tevent_queue *_tevent_queue_create(TALLOC_CTX *mem_ctx,
@@ -368,11 +713,16 @@ int _tevent_loop_until(struct tevent_context *ev,
int tevent_re_initialise(struct tevent_context *ev);
+/* @} */
/**
+ * @defgroup tevent_ops The tevent operation functions
+ * @ingroup tevent
+ *
* The following structure and registration functions are exclusively
* needed for people writing and pluggin a different event engine.
* There is nothing useful for normal tevent user in here.
+ * @{
*/
struct tevent_ops {
@@ -425,11 +775,19 @@ struct tevent_ops {
bool tevent_register_backend(const char *name, const struct tevent_ops *ops);
+/* @} */
/**
+ * @defgroup tevent_compat The tevent compatibility functions
+ * @ingroup tevent
+ *
* The following definitions are usueful only for compatibility with the
* implementation originally developed within the samba4 code and will be
* soon removed. Please NEVER use in new code.
+ *
+ * @todo Ignore it?
+ *
+ * @{
*/
#ifdef TEVENT_COMPAT_DEFINES
@@ -506,4 +864,6 @@ bool tevent_register_backend(const char *name, const struct tevent_ops *ops);
#endif /* TEVENT_COMPAT_DEFINES */
+/* @} */
+
#endif /* __TEVENT_H__ */
diff --git a/lib/tevent/tevent_req.c b/lib/tevent/tevent_req.c
index f61ef53423..b0c9c57dde 100644
--- a/lib/tevent/tevent_req.c
+++ b/lib/tevent/tevent_req.c
@@ -27,17 +27,6 @@
#include "tevent_internal.h"
#include "tevent_util.h"
-/**
- * @brief The default print function for creating debug messages
- * @param[in] req The request to be printed
- * @param[in] mem_ctx The memory context for the result
- * @retval Text representation of req
- *
- * The function should not be used by users of the asynx API,
- * but custom print function can use it and append custom text
- * to the string.
- */
-
char *tevent_req_default_print(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
return talloc_asprintf(mem_ctx,
@@ -53,15 +42,6 @@ char *tevent_req_default_print(struct tevent_req *req, TALLOC_CTX *mem_ctx)
);
}
-/**
- * @brief Print an tevent_req structure in debug messages
- * @param[in] mem_ctx The memory context for the result
- * @param[in] req The request to be printed
- * @retval Text representation of req
- *
- * This function should be used by callers of the async API
- */
-
char *tevent_req_print(TALLOC_CTX *mem_ctx, struct tevent_req *req)
{
if (!req->private_print) {
@@ -71,15 +51,6 @@ char *tevent_req_print(TALLOC_CTX *mem_ctx, struct tevent_req *req)
return req->private_print(req, mem_ctx);
}
-/**
- * @brief Create an async request
- * @param[in] mem_ctx The memory context for the result
- * @param[in] ev The event context this async request will be driven by
- * @retval A new async request
- *
- * The new async request will be initialized in state ASYNC_REQ_IN_PROGRESS
- */
-
struct tevent_req *_tevent_req_create(TALLOC_CTX *mem_ctx,
void *pdata,
size_t data_size,
@@ -133,49 +104,12 @@ static void tevent_req_finish(struct tevent_req *req,
_tevent_req_notify_callback(req, location);
}
-/**
- * @brief An async request has successfully finished
- * @param[in] req The finished request
- *
- * tevent_req_done is to be used by implementors of async requests. When a
- * request is successfully finished, this function calls the user's completion
- * function.
- */
-
void _tevent_req_done(struct tevent_req *req,
const char *location)
{
tevent_req_finish(req, TEVENT_REQ_DONE, location);
}
-/**
- * @brief An async request has seen an error
- * @param[in] req The request with an error
- * @param[in] error The error code
- *
- * tevent_req_done is to be used by implementors of async requests. When a
- * request can not successfully completed, the implementation should call this
- * function with the appropriate status code.
- *
- * If error is 0 the function returns false and does nothing more.
- *
- * Call pattern would be
- * \code
- * int error = first_function();
- * if (tevent_req_error(req, error)) {
- * return;
- * }
- *
- * error = second_function();
- * if (tevent_req_error(req, error)) {
- * return;
- * }
- *
- * tevent_req_done(req);
- * return;
- * \endcode
- */
-
bool _tevent_req_error(struct tevent_req *req,
uint64_t error,
const char *location)
@@ -189,23 +123,6 @@ bool _tevent_req_error(struct tevent_req *req,
return true;
}
-/**
- * @brief Helper function for nomem check
- * @param[in] p The pointer to be checked
- * @param[in] req The request being processed
- *
- * Convenience helper to easily check alloc failure within a callback
- * implementing the next step of an async request.
- *
- * Call pattern would be
- * \code
- * p = talloc(mem_ctx, bla);
- * if (tevent_req_nomem(p, req)) {
- * return;
- * }
- * \endcode
- */
-
bool _tevent_req_nomem(const void *p,
struct tevent_req *req,
const char *location)
@@ -218,10 +135,15 @@ bool _tevent_req_nomem(const void *p,
}
/**
- * @brief Immediate event callback
- * @param[in] ev Event context
- * @param[in] im The immediate event
- * @param[in] priv The async request to be finished
+ * @internal
+ *
+ * @brief Immediate event callback.
+ *
+ * @param[in] ev The event context to use.
+ *
+ * @param[in] im The immediate event.
+ *
+ * @param[in] priv The async request to be finished.
*/
static void tevent_req_trigger(struct tevent_context *ev,
struct tevent_immediate *im,
@@ -234,20 +156,6 @@ static void tevent_req_trigger(struct tevent_context *ev,
req->internal.finish_location);
}
-/**
- * @brief Finish a request before the caller had the change to set the callback
- * @param[in] req The finished request
- * @param[in] ev The tevent_context for the timed event
- * @retval req will be returned
- *
- * An implementation of an async request might find that it can either finish
- * the request without waiting for an external event, or it can't even start
- * the engine. To present the illusion of a callback to the user of the API,
- * the implementation can call this helper function which triggers an
- * immediate timed event. This way the caller can use the same calling
- * conventions, independent of whether the request was actually deferred.
- */
-
struct tevent_req *tevent_req_post(struct tevent_req *req,
struct tevent_context *ev)
{
@@ -256,16 +164,6 @@ struct tevent_req *tevent_req_post(struct tevent_req *req,
return req;
}
-/**
- * @brief This function destroys the attached private data
- * @param[in] req The request to poll
- * @retval The boolean form of "is in progress".
- *
- * This function can be used to ask if the given request
- * is still in progress.
- *
- * This function is typically used by sync wrapper functions.
- */
bool tevent_req_is_in_progress(struct tevent_req *req)
{
if (req->internal.state == TEVENT_REQ_IN_PROGRESS) {
@@ -275,13 +173,6 @@ bool tevent_req_is_in_progress(struct tevent_req *req)
return false;
}
-/**
- * @brief This function destroys the attached private data
- * @param[in] req The finished request
- *
- * This function can be called as last action of a _recv()
- * function, it destroys the data attached to the tevent_req.
- */
void tevent_req_received(struct tevent_req *req)
{
TALLOC_FREE(req->data);
@@ -293,23 +184,6 @@ void tevent_req_received(struct tevent_req *req)
req->internal.state = TEVENT_REQ_RECEIVED;
}
-/**
- * @brief This function destroys the attached private data
- * @param[in] req The request to poll
- * @param[in] ev The tevent_context to be used
- * @retval If a critical error has happened in the
- * tevent loop layer false is returned.
- * Otherwise true is returned.
- * This is not the return value of the given request!
- *
- * This function can be used to actively poll for the
- * given request to finish.
- *
- * Note: this should only be used if the given tevent context
- * was created by the caller, to avoid event loop nesting.
- *
- * This function is typically used by sync wrapper functions.
- */
bool tevent_req_poll(struct tevent_req *req,
struct tevent_context *ev)
{
@@ -383,56 +257,16 @@ void *_tevent_req_data(struct tevent_req *req)
return req->data;
}
-/**
- * @brief This function sets a print function for the given request
- * @param[in] req The given request
- * @param[in] fn A pointer to the print function
- *
- * This function can be used to setup a print function for the given request.
- * This will be triggered if the tevent_req_print() function was
- * called on the given request.
- *
- * Note: this function should only be used for debugging.
- */
void tevent_req_set_print_fn(struct tevent_req *req, tevent_req_print_fn fn)
{
req->private_print = fn;
}
-/**
- * @brief This function sets a cancel function for the given request
- * @param[in] req The given request
- * @param[in] fn A pointer to the cancel function
- *
- * This function can be used to setup a cancel function for the given request.
- * This will be triggered if the tevent_req_cancel() function was
- * called on the given request.
- *
- */
void tevent_req_set_cancel_fn(struct tevent_req *req, tevent_req_cancel_fn fn)
{
req->private_cancel = fn;
}
-/**
- * @brief This function tries to cancel the given request
- * @param[in] req The given request
- * @param[in] location Automatically filled with the __location__ macro
- * via the tevent_req_cancel() macro. This is for debugging
- * only!
- * @retval This function returns true is the request is cancelable.
- * Otherwise false is returned.
- *
- * This function can be used to cancel the given request.
- *
- * It is only possible to cancel a request when the implementation
- * has registered a cancel function via the tevent_req_set_cancel_fn().
- *
- * Note: Even if the function returns true, the caller need to wait
- * for the function to complete normally.
- * Only the _recv() function of the given request indicates
- * if the request was really canceled.
- */
bool _tevent_req_cancel(struct tevent_req *req, const char *location)
{
if (req->private_cancel == NULL) {