#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,
);
}
-/**
- * @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) {
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
- */
+static int tevent_req_destructor(struct tevent_req *req);
struct tevent_req *_tevent_req_create(TALLOC_CTX *mem_ctx,
void *pdata,
struct tevent_req *req;
void **ppdata = (void **)pdata;
void *data;
+ size_t payload;
- req = talloc_zero(mem_ctx, struct tevent_req);
- if (req == NULL) {
- return NULL;
- }
- req->internal.private_type = type;
- req->internal.create_location = location;
- req->internal.finish_location = NULL;
- req->internal.state = TEVENT_REQ_IN_PROGRESS;
- req->internal.trigger = tevent_create_immediate(req);
- if (!req->internal.trigger) {
- talloc_free(req);
+ payload = sizeof(struct tevent_immediate) + data_size;
+ if (payload < sizeof(struct tevent_immediate)) {
+ /* overflow */
return NULL;
}
- data = talloc_size(req, data_size);
- if (data == NULL) {
- talloc_free(req);
+ req = talloc_pooled_object(
+ mem_ctx, struct tevent_req, 2,
+ sizeof(struct tevent_immediate) + data_size);
+ if (req == NULL) {
return NULL;
}
+
+ *req = (struct tevent_req) {
+ .internal.private_type = type,
+ .internal.create_location = location,
+ .internal.state = TEVENT_REQ_IN_PROGRESS,
+ .internal.trigger = tevent_create_immediate(req)
+ };
+
+ data = talloc_zero_size(req, data_size);
+
+ /*
+ * No need to check for req->internal.trigger!=NULL or
+ * data!=NULL, this can't fail: talloc_pooled_object has
+ * already allocated sufficient memory.
+ */
+
talloc_set_name_const(data, type);
req->data = data;
+ talloc_set_destructor(req, tevent_req_destructor);
+
*ppdata = data;
return req;
}
-static void tevent_req_finish(struct tevent_req *req,
- enum tevent_req_state state,
- const char *location)
+static int tevent_req_destructor(struct tevent_req *req)
+{
+ tevent_req_received(req);
+ return 0;
+}
+
+void _tevent_req_notify_callback(struct tevent_req *req, const char *location)
{
- req->internal.state = state;
req->internal.finish_location = location;
+ if (req->internal.defer_callback_ev) {
+ (void)tevent_req_post(req, req->internal.defer_callback_ev);
+ req->internal.defer_callback_ev = NULL;
+ return;
+ }
if (req->async.fn != NULL) {
req->async.fn(req);
}
}
-/**
- * @brief An async request has successfully finished
- * @param[in] req The finished request
- *
- * async_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.
- */
+static void tevent_req_cleanup(struct tevent_req *req)
+{
+ if (req->private_cleanup.fn == NULL) {
+ return;
+ }
+
+ if (req->private_cleanup.state >= req->internal.state) {
+ /*
+ * Don't call the cleanup_function multiple times for the same
+ * state recursively
+ */
+ return;
+ }
+
+ req->private_cleanup.state = req->internal.state;
+ req->private_cleanup.fn(req, req->internal.state);
+}
+
+static void tevent_req_finish(struct tevent_req *req,
+ enum tevent_req_state state,
+ const char *location)
+{
+ /*
+ * make sure we do not timeout after
+ * the request was already finished
+ */
+ TALLOC_FREE(req->internal.timer);
+
+ req->internal.state = state;
+ req->internal.finish_location = location;
+
+ tevent_req_cleanup(req);
+
+ _tevent_req_notify_callback(req, location);
+}
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)
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
- */
+void _tevent_req_oom(struct tevent_req *req, const char *location)
+{
+ tevent_req_finish(req, TEVENT_REQ_NO_MEMORY, location);
+}
bool _tevent_req_nomem(const void *p,
struct tevent_req *req,
if (p != NULL) {
return false;
}
- tevent_req_finish(req, TEVENT_REQ_NO_MEMORY, location);
+ _tevent_req_oom(req, location);
return true;
}
/**
- * @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,
void *private_data)
{
- struct tevent_req *req = talloc_get_type(private_data,
- struct tevent_req);
+ struct tevent_req *req =
+ talloc_get_type_abort(private_data,
+ struct tevent_req);
tevent_req_finish(req, req->internal.state,
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)
{
return req;
}
+void tevent_req_defer_callback(struct tevent_req *req,
+ struct tevent_context *ev)
+{
+ req->internal.defer_callback_ev = ev;
+}
+
bool tevent_req_is_in_progress(struct tevent_req *req)
{
if (req->internal.state == TEVENT_REQ_IN_PROGRESS) {
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);
+ talloc_set_destructor(req, NULL);
+
req->private_print = NULL;
+ req->private_cancel = NULL;
TALLOC_FREE(req->internal.trigger);
TALLOC_FREE(req->internal.timer);
req->internal.state = TEVENT_REQ_RECEIVED;
+
+ tevent_req_cleanup(req);
+
+ TALLOC_FREE(req->data);
}
bool tevent_req_poll(struct tevent_req *req,
struct timeval now,
void *private_data)
{
- struct tevent_req *req = talloc_get_type(private_data,
- struct tevent_req);
+ struct tevent_req *req =
+ talloc_get_type_abort(private_data,
+ struct tevent_req);
TALLOC_FREE(req->internal.timer);
return true;
}
+void tevent_req_reset_endtime(struct tevent_req *req)
+{
+ TALLOC_FREE(req->internal.timer);
+}
+
void tevent_req_set_callback(struct tevent_req *req, tevent_req_fn fn, void *pvt)
{
req->async.fn = fn;
{
req->private_print = fn;
}
+
+void tevent_req_set_cancel_fn(struct tevent_req *req, tevent_req_cancel_fn fn)
+{
+ req->private_cancel = fn;
+}
+
+bool _tevent_req_cancel(struct tevent_req *req, const char *location)
+{
+ if (req->private_cancel == NULL) {
+ return false;
+ }
+
+ return req->private_cancel(req);
+}
+
+void tevent_req_set_cleanup_fn(struct tevent_req *req, tevent_req_cleanup_fn fn)
+{
+ req->private_cleanup.state = req->internal.state;
+ req->private_cleanup.fn = fn;
+}
git.samba.org / sfrench / samba-autobuild / .git / blobdiff