lib/tevent/tevent_port.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Main select loop and event handling - Solaris port implementation.
   5    Losely based on the Linux epoll backend.
   6
   7    Copyright (C) Jeremy Allison         2013
   8
   9      ** NOTE! The following LGPL license applies to the tevent
  10      ** library. This does NOT imply that all of Samba is released
  11      ** under the LGPL
  12
  13    This library is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU Lesser General Public
  15    License as published by the Free Software Foundation; either
  16    version 3 of the License, or (at your option) any later version.
  17
  18    This library is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21    Lesser General Public License for more details.
  22
  23    You should have received a copy of the GNU Lesser General Public
  24    License along with this library; if not, see <http://www.gnu.org/licenses/>.
  25 */
  26
  27 #include "replace.h"
  28 #include "system/filesys.h"
  29 #include "system/select.h"
  30 #include "tevent.h"
  31 #include "tevent_internal.h"
  32 #include "tevent_util.h"
  33
  34 struct port_associate_vals {
  35         struct port_associate_vals *prev, *next;
  36         struct port_event_context *port_ev;
  37         int events;
  38         struct tevent_fd *fde;
  39         bool associated_event;
  40 };
  41
  42 struct port_event_context {
  43         /* a pointer back to the generic event_context */
  44         struct tevent_context *ev;
  45
  46         /* This is the handle from port_create */
  47         int port_fd;
  48
  49         pid_t pid;
  50
  51         /* List of associations. */
  52         struct port_associate_vals *po_vals;
  53 };
  54
  55 #define PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION (1<<0)
  56 #define PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR    (1<<1)
  57 #define PORT_ADDITIONAL_FD_FLAG_GOT_ERROR       (1<<2)
  58 #define PORT_ADDITIONAL_FD_FLAG_HAS_MPX         (1<<3)
  59
  60 /*
  61   Map from TEVENT_FD_* to POLLIN/POLLOUT
  62 */
  63 static int port_map_flags(uint16_t flags)
  64 {
  65         int ret = 0;
  66         if (flags & TEVENT_FD_READ) ret |= (POLLIN | POLLERR | POLLHUP);
  67         if (flags & TEVENT_FD_WRITE) ret |= (POLLOUT | POLLERR | POLLHUP);
  68         return ret;
  69 }
  70
  71 /*
  72  Free the port fd
  73 */
  74 static int port_ctx_destructor(struct port_event_context *port_ev)
  75 {
  76         close(port_ev->port_fd);
  77         port_ev->port_fd = -1;
  78         return 0;
  79 }
  80
  81 /*
  82  Init the port fd
  83 */
  84 static int port_init_ctx(struct port_event_context *port_ev)
  85 {
  86         port_ev->port_fd = port_create();
  87         if (port_ev->port_fd == -1) {
  88                 tevent_debug(port_ev->ev, TEVENT_DEBUG_FATAL,
  89                              "Failed to create port handle.\n");
  90                 return -1;
  91         }
  92
  93         if (!ev_set_close_on_exec(port_ev->port_fd)) {
  94                 tevent_debug(port_ev->ev, TEVENT_DEBUG_WARNING,
  95                              "Failed to set close-on-exec, file descriptor may be leaked to children.\n");
  96         }
  97
  98         port_ev->pid = getpid();
  99         talloc_set_destructor(port_ev, port_ctx_destructor);
 100
 101         return 0;
 102 }
 103
 104 /*
 105  Functions to manage the lower level cache of associated events on the port_fd.
 106 */
 107
 108 static int port_associate_vals_destructor(struct port_associate_vals *val)
 109 {
 110         DLIST_REMOVE(val->port_ev->po_vals, val);
 111         memset(val, '\0', sizeof(struct port_associate_vals));
 112         return 0;
 113 }
 114
 115 /*
 116  * TODO: As the port_association is per-fde, it should be possible to store it
 117  * directly in fde->additional_data, alongside any multiplexed-fde. That way the
 118  * lookup on store and delete would be avoided, and associate_all_events() could
 119  * walk the ev->fd_events list.
 120  */
 121 static bool store_port_association(struct port_event_context *port_ev,
 122                                 struct tevent_fd *fde,
 123                                 int events)
 124 {
 125         struct port_associate_vals *val;
 126
 127         for (val = port_ev->po_vals; val; val = val->next) {
 128                 if (val->fde->fd == fde->fd) {
 129                         /* Association already attached to fd. */
 130                         if (val->events != events) {
 131                                 val->events = events;
 132                                 val->associated_event = false;
 133                         }
 134                         return true;
 135                 }
 136         }
 137
 138         val = talloc_zero(port_ev, struct port_associate_vals);
 139         if (val == NULL) {
 140                 return false;
 141         }
 142
 143         val->port_ev = port_ev;
 144         val->fde = fde;
 145         val->events = events;
 146         val->associated_event = false;
 147
 148         DLIST_ADD(port_ev->po_vals, val);
 149         talloc_set_destructor(val, port_associate_vals_destructor);
 150
 151         return true;
 152 }
 153
 154 static void delete_port_association(struct port_event_context *port_ev,
 155                                 struct tevent_fd *fde)
 156 {
 157         struct port_associate_vals *val;
 158
 159         for (val = port_ev->po_vals; val; val = val->next) {
 160                 if (val->fde == fde) {
 161                         if (val->associated_event) {
 162                                 (void)port_dissociate(port_ev->port_fd,
 163                                                         PORT_SOURCE_FD,
 164                                                         fde->fd);
 165                         }
 166                         talloc_free(val);
 167                         return;
 168                 }
 169         }
 170 }
 171
 172 static int associate_all_events(struct port_event_context *port_ev)
 173 {
 174         struct port_associate_vals *val;
 175
 176         for (val = port_ev->po_vals; val; val = val->next) {
 177                 int ret;
 178                 if (val->associated_event) {
 179                         continue;
 180                 }
 181                 ret = port_associate(port_ev->port_fd,
 182                                         PORT_SOURCE_FD,
 183                                         (uintptr_t)val->fde->fd,
 184                                         val->events,
 185                                         (void *)val);
 186                 if (ret != 0) {
 187                         return -1;
 188                 }
 189                 val->associated_event = true;
 190         }
 191         return 0;
 192 }
 193
 194 static int port_update_event(struct port_event_context *port_ev, struct tevent_fd *fde);
 195
 196 /*
 197   Reopen the port handle when our pid changes.
 198  */
 199 static int port_check_reopen(struct port_event_context *port_ev)
 200 {
 201         struct tevent_fd *fde;
 202
 203         if (port_ev->pid == getpid()) {
 204                 return 0;
 205         }
 206
 207         close(port_ev->port_fd);
 208         port_ev->port_fd = port_create();
 209         if (port_ev->port_fd == -1) {
 210                 tevent_debug(port_ev->ev, TEVENT_DEBUG_FATAL,
 211                                 "port_create() failed");
 212                 return -1;
 213         }
 214
 215         if (!ev_set_close_on_exec(port_ev->port_fd)) {
 216                 tevent_debug(port_ev->ev, TEVENT_DEBUG_WARNING,
 217                              "Failed to set close-on-exec, file descriptor may be leaked to children.\n");
 218         }
 219
 220         port_ev->pid = getpid();
 221         for (fde=port_ev->ev->fd_events;fde;fde=fde->next) {
 222                 fde->additional_flags &= PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
 223                 if (port_update_event(port_ev, fde) != 0) {
 224                         return -1;
 225                 }
 226         }
 227         return 0;
 228 }
 229
 230 /*
 231  * Solaris ports cannot add the same file descriptor twice, once
 232  * with read, once with write which is allowed by the tevent backend.
 233  * Multiplex the existing fde, flag it as such so we can search for the
 234  * correct fde on event triggering.
 235  */
 236
 237 static void port_setup_multiplex_fd(struct port_event_context *port_ev,
 238                                 struct tevent_fd *add_fde,
 239                                 struct tevent_fd *mpx_fde)
 240 {
 241         /*
 242          * Make each fde->additional_data pointers point at each other
 243          * so we can look them up from each other. They are now paired.
 244          */
 245         mpx_fde->additional_data = add_fde;
 246         add_fde->additional_data = mpx_fde;
 247
 248         /* Now flag both fde's as being multiplexed. */
 249         mpx_fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_HAS_MPX;
 250         add_fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_HAS_MPX;
 251
 252         /* We need to keep the GOT_ERROR flag. */
 253         if (mpx_fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_GOT_ERROR) {
 254                 add_fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_GOT_ERROR;
 255         }
 256 }
 257
 258 /*
 259  Add the port event to the given fd_event,
 260  Or modify an existing event.
 261 */
 262
 263 static int port_add_event(struct port_event_context *port_ev, struct tevent_fd *fde)
 264 {
 265         int flags = port_map_flags(fde->flags);
 266         struct tevent_fd *mpx_fde = NULL;
 267
 268         fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
 269         fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 270
 271         if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
 272                 /*
 273                  * This is already a multiplexed fde, we need to include both
 274                  * flags in the modified event.
 275                  */
 276                 mpx_fde = talloc_get_type_abort(fde->additional_data,
 277                                                 struct tevent_fd);
 278
 279                 mpx_fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
 280                 mpx_fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 281
 282                 flags |= port_map_flags(mpx_fde->flags);
 283         } else {
 284                 /*
 285                  * Not (yet) a multiplexed event. See if there
 286                  * is already an event with the same fd.
 287                  */
 288                 for (mpx_fde = port_ev->ev->fd_events; mpx_fde; mpx_fde = mpx_fde->next) {
 289                         if (mpx_fde->fd != fde->fd) {
 290                                 continue;
 291                         }
 292                         if (mpx_fde == fde) {
 293                                 continue;
 294                         }
 295                         /* Same fd. */
 296                         break;
 297                 }
 298                 if (mpx_fde) {
 299                         if (mpx_fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
 300                                 /* Logic error. Can't have more then 2 multiplexed fde's. */
 301                                 tevent_debug(port_ev->ev, TEVENT_DEBUG_FATAL,
 302                                         "multiplex fde for fd[%d] is already multiplexed\n",
 303                                         mpx_fde->fd);
 304                                 return -1;
 305                         }
 306                         flags |= port_map_flags(mpx_fde->flags);
 307                 }
 308         }
 309
 310         if (!store_port_association(port_ev,
 311                                 fde,
 312                                 flags)) {
 313                 tevent_debug(port_ev->ev, TEVENT_DEBUG_FATAL,
 314                         "store_port_association failed for fd[%d]\n",
 315                         fde->fd);
 316                 return -1;
 317         }
 318
 319         /* Note we have an association now. */
 320         fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
 321         /* Only if we want to read do we tell the event handler about errors. */
 322         if (fde->flags & TEVENT_FD_READ) {
 323                 fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 324         }
 325         if (mpx_fde == NULL) {
 326                 return 0;
 327         }
 328         /* Set up the multiplex pointer. Does no harm if already multiplexed. */
 329         port_setup_multiplex_fd(port_ev,
 330                                 fde,
 331                                 mpx_fde);
 332
 333         mpx_fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
 334         /* Only if we want to read do we tell the event handler about errors. */
 335         if (mpx_fde->flags & TEVENT_FD_READ) {
 336                 mpx_fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 337         }
 338
 339         return 0;
 340 }
 341
 342 /*
 343  Delete the port association for the given fd_event.
 344 */
 345
 346 static void port_del_event(struct port_event_context *port_ev, struct tevent_fd *fde)
 347 {
 348         struct tevent_fd *mpx_fde = NULL;
 349
 350         fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
 351         fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 352
 353         if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
 354                 /*
 355                  * This is a multiplexed fde, we need to remove
 356                  * both associations.
 357                  */
 358                 mpx_fde = talloc_get_type_abort(fde->additional_data,
 359                                                 struct tevent_fd);
 360
 361                 mpx_fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
 362                 mpx_fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 363                 mpx_fde->additional_data = NULL;
 364
 365                 fde->additional_data = NULL;
 366         }
 367         delete_port_association(port_ev, fde);
 368 }
 369
 370 /*
 371  Add or remove the port event from the given fd_event
 372 */
 373 static int port_update_event(struct port_event_context *port_ev, struct tevent_fd *fde)
 374 {
 375         bool got_error = (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_GOT_ERROR);
 376         bool want_read = (fde->flags & TEVENT_FD_READ);
 377         bool want_write = (fde->flags & TEVENT_FD_WRITE);
 378         struct tevent_fd *mpx_fde = NULL;
 379
 380         if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
 381                 /*
 382                  * work out what the multiplexed fde wants.
 383                  */
 384                 mpx_fde = talloc_get_type_abort(fde->additional_data,
 385                                                 struct tevent_fd);
 386                 if (mpx_fde->flags & TEVENT_FD_READ) {
 387                         want_read = true;
 388                 }
 389                 if (mpx_fde->flags & TEVENT_FD_WRITE) {
 390                         want_write = true;
 391                 }
 392         }
 393
 394         if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION) {
 395                 /* There's already an association. */
 396                 if (want_read || (want_write && !got_error)) {
 397                         return port_add_event(port_ev, fde);
 398                 }
 399                 /*
 400                  * If we want to match the select behavior, we need to remove the port event
 401                  * when the caller isn't interested in events.
 402                  */
 403                 port_del_event(port_ev, fde);
 404                 return 0;
 405         }
 406
 407         /* There's no port event attached to the fde. */
 408         if (want_read || (want_write && !got_error)) {
 409                 return port_add_event(port_ev, fde);
 410         }
 411         return 0;
 412 }
 413
 414 /*
 415  Cope with port_get returning EPOLLHP|EPOLLERR on an association.
 416  Return true if there's nothing else to do, false if this event
 417  needs further handling.
 418 */
 419
 420 static bool port_handle_hup_or_err(struct port_event_context *port_ev,
 421                                 struct tevent_fd *fde)
 422 {
 423         if (fde == NULL) {
 424                 return true;
 425         }
 426
 427         fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_GOT_ERROR;
 428         /*
 429          * If we only wait for TEVENT_FD_WRITE, we should not tell the
 430          * event handler about it, and remove the port association,
 431          * as we only report error when waiting for read events,
 432          * to match the select() behavior.
 433          */
 434         if (!(fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR)) {
 435                 /*
 436                  * Do the same as the poll backend and
 437                  * remove the writable flag.
 438                  */
 439                 fde->flags &= ~TEVENT_FD_WRITE;
 440                 return true;
 441         }
 442         /* This has TEVENT_FD_READ set, we're not finished. */
 443         return false;
 444 }
 445
 446 /*
 447   Event loop handling using Solaris ports.
 448 */
 449 static int port_event_loop(struct port_event_context *port_ev, struct timeval *tvalp)
 450 {
 451         int ret;
 452 #define MAXEVENTS 1
 453         port_event_t events[MAXEVENTS];
 454         uint_t nget = 1;
 455         uint_t max_events = MAXEVENTS;
 456         uint_t i;
 457         int port_errno;
 458         struct timespec ts;
 459         struct tevent_context *ev = port_ev->ev;
 460
 461         if (tvalp) {
 462                 ts.tv_sec = tvalp->tv_sec;
 463                 ts.tv_nsec = tvalp->tv_usec * 1000;
 464         }
 465
 466         if (port_ev->ev->signal_events &&
 467             tevent_common_check_signal(ev)) {
 468                 return 0;
 469         }
 470
 471         /*
 472          * Solaris triggers sending the event to the port
 473          * at the time the port association is done. Postpone
 474          * associating fd's until just before we get the events,
 475          * otherwise we can deadlock.
 476          */
 477
 478         if (associate_all_events(port_ev) != 0) {
 479                 return -1;
 480         }
 481
 482         tevent_trace_point_callback(ev, TEVENT_TRACE_BEFORE_WAIT);
 483         ret = port_getn(port_ev->port_fd, events, max_events, &nget, &ts);
 484         port_errno = errno;
 485         tevent_trace_point_callback(ev, TEVENT_TRACE_AFTER_WAIT);
 486
 487         if (ret == -1 && port_errno == EINTR) {
 488                 if (ev->signal_events) {
 489                         tevent_common_check_signal(ev);
 490                 }
 491                 /*
 492                  * If no signal handlers we got an unsolicited
 493                  * signal wakeup. This can happen with epoll
 494                  * too. Just return and ignore.
 495                  */
 496                 return 0;
 497         }
 498
 499         if (ret == -1 && port_errno == ETIME) {
 500                 /*
 501                  * If errno is set to ETIME it is possible that we still got an event.
 502                  * In that case we need to go through the processing loop so that we
 503                  * reassociate the received event with the port or the association will
 504                  * be lost so check the value of nget is 0 before returning.
 505                  */
 506                 if (nget == 0) {
 507                         /* we don't care about a possible delay here */
 508                         tevent_common_loop_timer_delay(ev);
 509                         return 0;
 510                 }
 511                 /*
 512                  * Set the return value to 0 since we do not actually have an error and we
 513                  * do have events that need to be processed.  This keeps us from getting
 514                  * caught in the generic error test.
 515                  */
 516                 ret = 0;
 517         }
 518
 519         if (ret == -1) {
 520                 tevent_debug(ev, TEVENT_DEBUG_ERROR,
 521                                 "port_get failed (%s)\n",
 522                                 strerror(errno));
 523                 return -1;
 524         }
 525
 526         for (i = 0; i < nget; i++) {
 527                 struct tevent_fd *mpx_fde = NULL;
 528                 struct tevent_fd *fde = NULL;
 529                 uint16_t flags = 0;
 530                 struct port_associate_vals *val = talloc_get_type(events[i].portev_user,
 531                                                         struct port_associate_vals);
 532                 if (val == NULL) {
 533                         tevent_debug(ev, TEVENT_DEBUG_ERROR,
 534                                 "port_getn() gave bad data");
 535                         return -1;
 536                 }
 537
 538                 /* Mark this event as needing to be re-associated. */
 539                 val->associated_event = false;
 540
 541                 fde = val->fde;
 542
 543                 if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
 544                         /*
 545                          * Save off the multiplexed event in case we need
 546                          * to use it to call the handler function.
 547                          */
 548                         mpx_fde = talloc_get_type_abort(fde->additional_data,
 549                                                 struct tevent_fd);
 550                 }
 551
 552                 if (events[i].portev_events & (POLLHUP|POLLERR)) {
 553                         bool handled_fde = port_handle_hup_or_err(port_ev, fde);
 554                         bool handled_mpx = port_handle_hup_or_err(port_ev, mpx_fde);
 555
 556                         if (handled_fde && handled_mpx) {
 557                                 return port_update_event(port_ev, fde);
 558                         }
 559
 560                         if (!handled_mpx) {
 561                                 /*
 562                                  * If the mpx event was the one that needs
 563                                  * further handling, it's the TEVENT_FD_READ
 564                                  * event so switch over and call that handler.
 565                                  */
 566                                 fde = mpx_fde;
 567                                 mpx_fde = NULL;
 568                         }
 569                         flags |= TEVENT_FD_READ;
 570                 }
 571
 572                 if (events[i].portev_events & POLLIN) {
 573                         flags |= TEVENT_FD_READ;
 574                 }
 575                 if (events[i].portev_events & POLLOUT) {
 576                         flags |= TEVENT_FD_WRITE;
 577                 }
 578
 579                 if (flags & TEVENT_FD_WRITE) {
 580                         if (fde->flags & TEVENT_FD_WRITE) {
 581                                 mpx_fde = NULL;
 582                         }
 583                         if (mpx_fde && (mpx_fde->flags & TEVENT_FD_WRITE)) {
 584                                 fde = mpx_fde;
 585                                 mpx_fde = NULL;
 586                         }
 587
 588                         if (mpx_fde) {
 589                                 /* Ensure we got the right fde. */
 590                                 if ((flags & fde->flags) == 0) {
 591                                         fde = mpx_fde;
 592                                         mpx_fde = NULL;
 593                                 }
 594                         }
 595                 }
 596
 597                 /*
 598                  * Make sure we only pass the flags
 599                  * the handler is expecting.
 600                  */
 601                 flags &= fde->flags;
 602                 if (flags) {
 603                         return tevent_common_invoke_fd_handler(fde, flags, NULL);
 604                 }
 605         }
 606
 607         return 0;
 608 }
 609
 610
 611 /*
 612   create a port_event_context structure.
 613 */
 614 static int port_event_context_init(struct tevent_context *ev)
 615 {
 616         int ret;
 617         struct port_event_context *port_ev;
 618
 619         /*
 620          * We might be called during tevent_re_initialise()
 621          * which means we need to free our old additional_data.
 622          */
 623         TALLOC_FREE(ev->additional_data);
 624
 625         port_ev = talloc_zero(ev, struct port_event_context);
 626         if (!port_ev) {
 627                 return -1;
 628         }
 629         port_ev->ev = ev;
 630         port_ev->port_fd = -1;
 631         port_ev->pid = (pid_t)-1;
 632
 633         ret = port_init_ctx(port_ev);
 634         if (ret != 0) {
 635                 talloc_free(port_ev);
 636                 return ret;
 637         }
 638
 639         ev->additional_data = port_ev;
 640         return 0;
 641 }
 642
 643 /*
 644   destroy an fd_event
 645 */
 646 static int port_event_fd_destructor(struct tevent_fd *fde)
 647 {
 648         struct tevent_context *ev = fde->event_ctx;
 649         struct port_event_context *port_ev = NULL;
 650         struct tevent_fd *mpx_fde = NULL;
 651         int flags = (int)fde->flags;
 652
 653         if (ev == NULL) {
 654                 return tevent_common_fd_destructor(fde);
 655         }
 656
 657         port_ev = talloc_get_type_abort(ev->additional_data,
 658                                          struct port_event_context);
 659
 660         DLIST_REMOVE(ev->fd_events, fde);
 661
 662         if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
 663                 mpx_fde = talloc_get_type_abort(fde->additional_data,
 664                                                 struct tevent_fd);
 665
 666                 fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_MPX;
 667                 mpx_fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_MPX;
 668
 669                 fde->additional_data = NULL;
 670                 mpx_fde->additional_data = NULL;
 671
 672                 fde->additional_flags &= PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
 673         }
 674
 675         (void)port_check_reopen(port_ev);
 676
 677         if (mpx_fde != NULL) {
 678                 (void)port_update_event(port_ev, mpx_fde);
 679         }
 680
 681         fde->flags = 0;
 682         (void)port_update_event(port_ev, fde);
 683         fde->flags = flags;
 684
 685         return tevent_common_fd_destructor(fde);
 686 }
 687
 688 /*
 689   add a fd based event
 690   return NULL on failure (memory allocation error)
 691 */
 692 static struct tevent_fd *port_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
 693                                             int fd, uint16_t flags,
 694                                             tevent_fd_handler_t handler,
 695                                             void *private_data,
 696                                             const char *handler_name,
 697                                             const char *location)
 698 {
 699         struct port_event_context *port_ev =
 700                                 talloc_get_type_abort(ev->additional_data,
 701                                 struct port_event_context);
 702         struct tevent_fd *fde;
 703
 704         fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
 705                                    handler, private_data,
 706                                    handler_name, location);
 707         if (!fde) {
 708                 return NULL;
 709         }
 710
 711         talloc_set_destructor(fde, port_event_fd_destructor);
 712
 713         if (port_check_reopen(port_ev) != 0) {
 714                 TALLOC_FREE(fde);
 715                 return NULL;
 716         }
 717
 718         if (port_update_event(port_ev, fde) != 0) {
 719                 TALLOC_FREE(fde);
 720                 return NULL;
 721         }
 722
 723         return fde;
 724 }
 725
 726 /*
 727   set the fd event flags
 728 */
 729 static void port_event_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
 730 {
 731         struct tevent_context *ev;
 732         struct port_event_context *port_ev;
 733
 734         if (fde->flags == flags) {
 735                 return;
 736         }
 737
 738         ev = fde->event_ctx;
 739         port_ev = talloc_get_type_abort(ev->additional_data,
 740                                 struct port_event_context);
 741
 742         fde->flags = flags;
 743
 744         (void)port_check_reopen(port_ev);
 745         (void)port_update_event(port_ev, fde);
 746 }
 747
 748 /*
 749   do a single event loop using the events defined in ev
 750 */
 751 static int port_event_loop_once(struct tevent_context *ev, const char *location)
 752 {
 753         struct port_event_context *port_ev = talloc_get_type(ev->additional_data,
 754                                                            struct port_event_context);
 755         struct timeval tval;
 756
 757         if (ev->signal_events &&
 758             tevent_common_check_signal(ev)) {
 759                 return 0;
 760         }
 761
 762         if (ev->threaded_contexts != NULL) {
 763                 tevent_common_threaded_activate_immediate(ev);
 764         }
 765
 766         if (ev->immediate_events &&
 767             tevent_common_loop_immediate(ev)) {
 768                 return 0;
 769         }
 770
 771         tval = tevent_common_loop_timer_delay(ev);
 772         if (tevent_timeval_is_zero(&tval)) {
 773                 return 0;
 774         }
 775
 776         if (port_check_reopen(port_ev) != 0) {
 777                 errno = EINVAL;
 778                 return -1;
 779         }
 780         return port_event_loop(port_ev, &tval);
 781 }
 782
 783 static const struct tevent_ops port_event_ops = {
 784         .context_init           = port_event_context_init,
 785         .add_fd                 = port_event_add_fd,
 786         .set_fd_close_fn        = tevent_common_fd_set_close_fn,
 787         .get_fd_flags           = tevent_common_fd_get_flags,
 788         .set_fd_flags           = port_event_set_fd_flags,
 789         .add_timer              = tevent_common_add_timer_v2,
 790         .schedule_immediate     = tevent_common_schedule_immediate,
 791         .add_signal             = tevent_common_add_signal,
 792         .loop_once              = port_event_loop_once,
 793         .loop_wait              = tevent_common_loop_wait,
 794 };
 795
 796 _PRIVATE_ bool tevent_port_init(void)
 797 {
 798         if (!tevent_register_backend("port", &port_event_ops)) {
 799                 return false;
 800         }
 801         tevent_set_default_backend("port");
 802         return true;
 803 }