lib/tevent/tevent_req.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Infrastructure for async requests
   4    Copyright (C) Volker Lendecke 2008
   5    Copyright (C) Stefan Metzmacher 2009
   6
   7      ** NOTE! The following LGPL license applies to the tevent
   8      ** library. This does NOT imply that all of Samba is released
   9      ** under the LGPL
  10
  11    This library is free software; you can redistribute it and/or
  12    modify it under the terms of the GNU Lesser General Public
  13    License as published by the Free Software Foundation; either
  14    version 3 of the License, or (at your option) any later version.
  15
  16    This library is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19    Lesser General Public License for more details.
  20
  21    You should have received a copy of the GNU Lesser General Public
  22    License along with this library; if not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25 #include "replace.h"
  26 #include "tevent.h"
  27 #include "tevent_internal.h"
  28 #include "tevent_util.h"
  29
  30 char *tevent_req_default_print(struct tevent_req *req, TALLOC_CTX *mem_ctx)
  31 {
  32         return talloc_asprintf(mem_ctx,
  33                                "tevent_req[%p/%s]: state[%d] error[%lld (0x%llX)] "
  34                                " state[%s (%p)] timer[%p] finish[%s]",
  35                                req, req->internal.create_location,
  36                                req->internal.state,
  37                                (unsigned long long)req->internal.error,
  38                                (unsigned long long)req->internal.error,
  39                                req->internal.private_type,
  40                                req->data,
  41                                req->internal.timer,
  42                                req->internal.finish_location
  43                                );
  44 }
  45
  46 char *tevent_req_print(TALLOC_CTX *mem_ctx, struct tevent_req *req)
  47 {
  48         if (req == NULL) {
  49                 return talloc_strdup(mem_ctx, "tevent_req[NULL]");
  50         }
  51
  52         if (!req->private_print) {
  53                 return tevent_req_default_print(req, mem_ctx);
  54         }
  55
  56         return req->private_print(req, mem_ctx);
  57 }
  58
  59 static int tevent_req_destructor(struct tevent_req *req);
  60
  61 struct tevent_req *_tevent_req_create(TALLOC_CTX *mem_ctx,
  62                                     void *pdata,
  63                                     size_t data_size,
  64                                     const char *type,
  65                                     const char *location)
  66 {
  67         struct tevent_req *req;
  68         struct tevent_req *parent;
  69         void **ppdata = (void **)pdata;
  70         void *data;
  71         size_t payload;
  72
  73         payload = sizeof(struct tevent_immediate) + data_size;
  74         if (payload < sizeof(struct tevent_immediate)) {
  75                 /* overflow */
  76                 return NULL;
  77         }
  78
  79         req = talloc_pooled_object(
  80                 mem_ctx, struct tevent_req, 2,
  81                 sizeof(struct tevent_immediate) + data_size);
  82         if (req == NULL) {
  83                 return NULL;
  84         }
  85
  86         *req = (struct tevent_req) {
  87                 .internal = {
  88                         .private_type           = type,
  89                         .create_location        = location,
  90                         .state                  = TEVENT_REQ_IN_PROGRESS,
  91                         .trigger                = tevent_create_immediate(req),
  92                 },
  93         };
  94
  95         data = talloc_zero_size(req, data_size);
  96
  97         /*
  98          * No need to check for req->internal.trigger!=NULL or
  99          * data!=NULL, this can't fail: talloc_pooled_object has
 100          * already allocated sufficient memory.
 101          */
 102
 103         talloc_set_name_const(data, type);
 104
 105         req->data = data;
 106
 107         talloc_set_destructor(req, tevent_req_destructor);
 108
 109         parent = talloc_get_type(talloc_parent(mem_ctx), struct tevent_req);
 110         if ((parent != NULL) && (parent->internal.profile != NULL)) {
 111                 bool ok = tevent_req_set_profile(req);
 112
 113                 if (!ok) {
 114                         TALLOC_FREE(req);
 115                         return NULL;
 116                 }
 117                 req->internal.profile->parent = parent->internal.profile;
 118                 DLIST_ADD_END(parent->internal.profile->subprofiles,
 119                               req->internal.profile);
 120         }
 121
 122         *ppdata = data;
 123         return req;
 124 }
 125
 126 static int tevent_req_destructor(struct tevent_req *req)
 127 {
 128         tevent_req_received(req);
 129         return 0;
 130 }
 131
 132 void _tevent_req_notify_callback(struct tevent_req *req, const char *location)
 133 {
 134         req->internal.finish_location = location;
 135         if (req->internal.defer_callback_ev) {
 136                 (void)tevent_req_post(req, req->internal.defer_callback_ev);
 137                 req->internal.defer_callback_ev = NULL;
 138                 return;
 139         }
 140         if (req->async.fn != NULL) {
 141                 req->async.fn(req);
 142         }
 143 }
 144
 145 static void tevent_req_cleanup(struct tevent_req *req)
 146 {
 147         if (req->private_cleanup.fn == NULL) {
 148                 return;
 149         }
 150
 151         if (req->private_cleanup.state >= req->internal.state) {
 152                 /*
 153                  * Don't call the cleanup_function multiple times for the same
 154                  * state recursively
 155                  */
 156                 return;
 157         }
 158
 159         req->private_cleanup.state = req->internal.state;
 160         req->private_cleanup.fn(req, req->internal.state);
 161 }
 162
 163 static void tevent_req_finish(struct tevent_req *req,
 164                               enum tevent_req_state state,
 165                               const char *location)
 166 {
 167         struct tevent_req_profile *p;
 168         /*
 169          * make sure we do not timeout after
 170          * the request was already finished
 171          */
 172         TALLOC_FREE(req->internal.timer);
 173
 174         req->internal.state = state;
 175         req->internal.finish_location = location;
 176
 177         tevent_req_cleanup(req);
 178
 179         p = req->internal.profile;
 180
 181         if (p != NULL) {
 182                 p->stop_location = location;
 183                 p->stop_time = tevent_timeval_current();
 184                 p->state = state;
 185                 p->user_error = req->internal.error;
 186
 187                 if (p->parent != NULL) {
 188                         talloc_steal(p->parent, p);
 189                         req->internal.profile = NULL;
 190                 }
 191         }
 192
 193         _tevent_req_notify_callback(req, location);
 194 }
 195
 196 void _tevent_req_done(struct tevent_req *req,
 197                       const char *location)
 198 {
 199         tevent_req_finish(req, TEVENT_REQ_DONE, location);
 200 }
 201
 202 bool _tevent_req_error(struct tevent_req *req,
 203                        uint64_t error,
 204                        const char *location)
 205 {
 206         if (error == 0) {
 207                 return false;
 208         }
 209
 210         req->internal.error = error;
 211         tevent_req_finish(req, TEVENT_REQ_USER_ERROR, location);
 212         return true;
 213 }
 214
 215 void _tevent_req_oom(struct tevent_req *req, const char *location)
 216 {
 217         tevent_req_finish(req, TEVENT_REQ_NO_MEMORY, location);
 218 }
 219
 220 bool _tevent_req_nomem(const void *p,
 221                        struct tevent_req *req,
 222                        const char *location)
 223 {
 224         if (p != NULL) {
 225                 return false;
 226         }
 227         _tevent_req_oom(req, location);
 228         return true;
 229 }
 230
 231 /**
 232  * @internal
 233  *
 234  * @brief Immediate event callback.
 235  *
 236  * @param[in]  ev       The event context to use.
 237  *
 238  * @param[in]  im       The immediate event.
 239  *
 240  * @param[in]  priv     The async request to be finished.
 241  */
 242 static void tevent_req_trigger(struct tevent_context *ev,
 243                                struct tevent_immediate *im,
 244                                void *private_data)
 245 {
 246         struct tevent_req *req =
 247                 talloc_get_type_abort(private_data,
 248                 struct tevent_req);
 249
 250         tevent_req_finish(req, req->internal.state,
 251                           req->internal.finish_location);
 252 }
 253
 254 struct tevent_req *tevent_req_post(struct tevent_req *req,
 255                                    struct tevent_context *ev)
 256 {
 257         tevent_schedule_immediate(req->internal.trigger,
 258                                   ev, tevent_req_trigger, req);
 259         return req;
 260 }
 261
 262 void tevent_req_defer_callback(struct tevent_req *req,
 263                                struct tevent_context *ev)
 264 {
 265         req->internal.defer_callback_ev = ev;
 266 }
 267
 268 bool tevent_req_is_in_progress(struct tevent_req *req)
 269 {
 270         if (req->internal.state == TEVENT_REQ_IN_PROGRESS) {
 271                 return true;
 272         }
 273
 274         return false;
 275 }
 276
 277 void tevent_req_received(struct tevent_req *req)
 278 {
 279         talloc_set_destructor(req, NULL);
 280
 281         req->private_print = NULL;
 282         req->private_cancel = NULL;
 283
 284         TALLOC_FREE(req->internal.trigger);
 285         TALLOC_FREE(req->internal.timer);
 286
 287         req->internal.state = TEVENT_REQ_RECEIVED;
 288
 289         tevent_req_cleanup(req);
 290
 291         TALLOC_FREE(req->data);
 292 }
 293
 294 bool tevent_req_poll(struct tevent_req *req,
 295                      struct tevent_context *ev)
 296 {
 297         while (tevent_req_is_in_progress(req)) {
 298                 int ret;
 299
 300                 ret = tevent_loop_once(ev);
 301                 if (ret != 0) {
 302                         return false;
 303                 }
 304         }
 305
 306         return true;
 307 }
 308
 309 bool tevent_req_is_error(struct tevent_req *req, enum tevent_req_state *state,
 310                         uint64_t *error)
 311 {
 312         if (req->internal.state == TEVENT_REQ_DONE) {
 313                 return false;
 314         }
 315         if (req->internal.state == TEVENT_REQ_USER_ERROR) {
 316                 *error = req->internal.error;
 317         }
 318         *state = req->internal.state;
 319         return true;
 320 }
 321
 322 static void tevent_req_timedout(struct tevent_context *ev,
 323                                struct tevent_timer *te,
 324                                struct timeval now,
 325                                void *private_data)
 326 {
 327         struct tevent_req *req =
 328                 talloc_get_type_abort(private_data,
 329                 struct tevent_req);
 330
 331         TALLOC_FREE(req->internal.timer);
 332
 333         tevent_req_finish(req, TEVENT_REQ_TIMED_OUT, __FUNCTION__);
 334 }
 335
 336 bool tevent_req_set_endtime(struct tevent_req *req,
 337                             struct tevent_context *ev,
 338                             struct timeval endtime)
 339 {
 340         TALLOC_FREE(req->internal.timer);
 341
 342         req->internal.timer = tevent_add_timer(ev, req, endtime,
 343                                                tevent_req_timedout,
 344                                                req);
 345         if (tevent_req_nomem(req->internal.timer, req)) {
 346                 return false;
 347         }
 348
 349         return true;
 350 }
 351
 352 void tevent_req_reset_endtime(struct tevent_req *req)
 353 {
 354         TALLOC_FREE(req->internal.timer);
 355 }
 356
 357 void tevent_req_set_callback(struct tevent_req *req, tevent_req_fn fn, void *pvt)
 358 {
 359         req->async.fn = fn;
 360         req->async.private_data = pvt;
 361 }
 362
 363 void *_tevent_req_callback_data(struct tevent_req *req)
 364 {
 365         return req->async.private_data;
 366 }
 367
 368 void *_tevent_req_data(struct tevent_req *req)
 369 {
 370         return req->data;
 371 }
 372
 373 void tevent_req_set_print_fn(struct tevent_req *req, tevent_req_print_fn fn)
 374 {
 375         req->private_print = fn;
 376 }
 377
 378 void tevent_req_set_cancel_fn(struct tevent_req *req, tevent_req_cancel_fn fn)
 379 {
 380         req->private_cancel = fn;
 381 }
 382
 383 bool _tevent_req_cancel(struct tevent_req *req, const char *location)
 384 {
 385         if (req->private_cancel == NULL) {
 386                 return false;
 387         }
 388
 389         return req->private_cancel(req);
 390 }
 391
 392 void tevent_req_set_cleanup_fn(struct tevent_req *req, tevent_req_cleanup_fn fn)
 393 {
 394         req->private_cleanup.state = req->internal.state;
 395         req->private_cleanup.fn = fn;
 396 }
 397
 398 static int tevent_req_profile_destructor(struct tevent_req_profile *p);
 399
 400 bool tevent_req_set_profile(struct tevent_req *req)
 401 {
 402         struct tevent_req_profile *p;
 403
 404         if (req->internal.profile != NULL) {
 405                 tevent_req_error(req, EINVAL);
 406                 return false;
 407         }
 408
 409         p = tevent_req_profile_create(req);
 410
 411         if (tevent_req_nomem(p, req)) {
 412                 return false;
 413         }
 414
 415         p->req_name = talloc_get_name(req->data);
 416         p->start_location = req->internal.create_location;
 417         p->start_time = tevent_timeval_current();
 418
 419         req->internal.profile = p;
 420
 421         return true;
 422 }
 423
 424 static int tevent_req_profile_destructor(struct tevent_req_profile *p)
 425 {
 426         if (p->parent != NULL) {
 427                 DLIST_REMOVE(p->parent->subprofiles, p);
 428                 p->parent = NULL;
 429         }
 430
 431         while (p->subprofiles != NULL) {
 432                 p->subprofiles->parent = NULL;
 433                 DLIST_REMOVE(p->subprofiles, p->subprofiles);
 434         }
 435
 436         return 0;
 437 }
 438
 439 struct tevent_req_profile *tevent_req_move_profile(struct tevent_req *req,
 440                                                    TALLOC_CTX *mem_ctx)
 441 {
 442         return talloc_move(mem_ctx, &req->internal.profile);
 443 }
 444
 445 const struct tevent_req_profile *tevent_req_get_profile(
 446         struct tevent_req *req)
 447 {
 448         return req->internal.profile;
 449 }
 450
 451 void tevent_req_profile_get_name(const struct tevent_req_profile *profile,
 452                                  const char **req_name)
 453 {
 454         if (req_name != NULL) {
 455                 *req_name = profile->req_name;
 456         }
 457 }
 458
 459 void tevent_req_profile_get_start(const struct tevent_req_profile *profile,
 460                                   const char **start_location,
 461                                   struct timeval *start_time)
 462 {
 463         if (start_location != NULL) {
 464                 *start_location = profile->start_location;
 465         }
 466         if (start_time != NULL) {
 467                 *start_time = profile->start_time;
 468         }
 469 }
 470
 471 void tevent_req_profile_get_stop(const struct tevent_req_profile *profile,
 472                                  const char **stop_location,
 473                                  struct timeval *stop_time)
 474 {
 475         if (stop_location != NULL) {
 476                 *stop_location = profile->stop_location;
 477         }
 478         if (stop_time != NULL) {
 479                 *stop_time = profile->stop_time;
 480         }
 481 }
 482
 483 void tevent_req_profile_get_status(const struct tevent_req_profile *profile,
 484                                    pid_t *pid,
 485                                    enum tevent_req_state *state,
 486                                    uint64_t *user_error)
 487 {
 488         if (pid != NULL) {
 489                 *pid = profile->pid;
 490         }
 491         if (state != NULL) {
 492                 *state = profile->state;
 493         }
 494         if (user_error != NULL) {
 495                 *user_error = profile->user_error;
 496         }
 497 }
 498
 499 const struct tevent_req_profile *tevent_req_profile_get_subprofiles(
 500         const struct tevent_req_profile *profile)
 501 {
 502         return profile->subprofiles;
 503 }
 504
 505 const struct tevent_req_profile *tevent_req_profile_next(
 506         const struct tevent_req_profile *profile)
 507 {
 508         return profile->next;
 509 }
 510
 511 struct tevent_req_profile *tevent_req_profile_create(TALLOC_CTX *mem_ctx)
 512 {
 513         struct tevent_req_profile *result;
 514
 515         result = talloc_zero(mem_ctx, struct tevent_req_profile);
 516         if (result == NULL) {
 517                 return NULL;
 518         }
 519         talloc_set_destructor(result, tevent_req_profile_destructor);
 520
 521         return result;
 522 }
 523
 524 bool tevent_req_profile_set_name(struct tevent_req_profile *profile,
 525                                  const char *req_name)
 526 {
 527         profile->req_name = talloc_strdup(profile, req_name);
 528         return (profile->req_name != NULL);
 529 }
 530
 531 bool tevent_req_profile_set_start(struct tevent_req_profile *profile,
 532                                   const char *start_location,
 533                                   struct timeval start_time)
 534 {
 535         profile->start_time = start_time;
 536
 537         profile->start_location = talloc_strdup(profile, start_location);
 538         return (profile->start_location != NULL);
 539 }
 540
 541 bool tevent_req_profile_set_stop(struct tevent_req_profile *profile,
 542                                  const char *stop_location,
 543                                  struct timeval stop_time)
 544 {
 545         profile->stop_time = stop_time;
 546
 547         profile->stop_location = talloc_strdup(profile, stop_location);
 548         return (profile->stop_location != NULL);
 549 }
 550
 551 void tevent_req_profile_set_status(struct tevent_req_profile *profile,
 552                                    pid_t pid,
 553                                    enum tevent_req_state state,
 554                                    uint64_t user_error)
 555 {
 556         profile->pid = pid;
 557         profile->state = state;
 558         profile->user_error = user_error;
 559 }
 560
 561 void tevent_req_profile_append_sub(struct tevent_req_profile *parent_profile,
 562                                    struct tevent_req_profile **sub_profile)
 563 {
 564         struct tevent_req_profile *sub;
 565
 566         sub = talloc_move(parent_profile, sub_profile);
 567
 568         sub->parent = parent_profile;
 569         DLIST_ADD_END(parent_profile->subprofiles, sub);
 570 }