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                 if (val->associated_event) {
 178                         continue;
 179                 }
 180                 int ret = port_associate(port_ev->port_fd,
 181                                         PORT_SOURCE_FD,
 182                                         (uintptr_t)val->fde->fd,
 183                                         val->events,
 184                                         (void *)val);
 185                 if (ret != 0) {
 186                         return -1;
 187                 }
 188                 val->associated_event = true;
 189         }
 190         return 0;
 191 }
 192
 193 static int port_update_event(struct port_event_context *port_ev, struct tevent_fd *fde);
 194
 195 /*
 196   Reopen the port handle when our pid changes.
 197  */
 198 static int port_check_reopen(struct port_event_context *port_ev)
 199 {
 200         struct tevent_fd *fde;
 201
 202         if (port_ev->pid == getpid()) {
 203                 return 0;
 204         }
 205
 206         close(port_ev->port_fd);
 207         port_ev->port_fd = port_create();
 208         if (port_ev->port_fd == -1) {
 209                 tevent_debug(port_ev->ev, TEVENT_DEBUG_FATAL,
 210                                 "port_create() failed");
 211                 return -1;
 212         }
 213
 214         if (!ev_set_close_on_exec(port_ev->port_fd)) {
 215                 tevent_debug(port_ev->ev, TEVENT_DEBUG_WARNING,
 216                              "Failed to set close-on-exec, file descriptor may be leaked to children.\n");
 217         }
 218
 219         port_ev->pid = getpid();
 220         for (fde=port_ev->ev->fd_events;fde;fde=fde->next) {
 221                 fde->additional_flags &= PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
 222                 if (port_update_event(port_ev, fde) != 0) {
 223                         return -1;
 224                 }
 225         }
 226         return 0;
 227 }
 228
 229 /*
 230  * Solaris ports cannot add the same file descriptor twice, once
 231  * with read, once with write which is allowed by the tevent backend.
 232  * Multiplex the existing fde, flag it as such so we can search for the
 233  * correct fde on event triggering.
 234  */
 235
 236 static void port_setup_multiplex_fd(struct port_event_context *port_ev,
 237                                 struct tevent_fd *add_fde,
 238                                 struct tevent_fd *mpx_fde)
 239 {
 240         /*
 241          * Make each fde->additional_data pointers point at each other
 242          * so we can look them up from each other. They are now paired.
 243          */
 244         mpx_fde->additional_data = add_fde;
 245         add_fde->additional_data = mpx_fde;
 246
 247         /* Now flag both fde's as being multiplexed. */
 248         mpx_fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_HAS_MPX;
 249         add_fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_HAS_MPX;
 250
 251         /* We need to keep the GOT_ERROR flag. */
 252         if (mpx_fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_GOT_ERROR) {
 253                 add_fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_GOT_ERROR;
 254         }
 255 }
 256
 257 /*
 258  Add the port event to the given fd_event,
 259  Or modify an existing event.
 260 */
 261
 262 static int port_add_event(struct port_event_context *port_ev, struct tevent_fd *fde)
 263 {
 264         int flags = port_map_flags(fde->flags);
 265         struct tevent_fd *mpx_fde = NULL;
 266
 267         fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
 268         fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 269
 270         if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
 271                 /*
 272                  * This is already a multiplexed fde, we need to include both
 273                  * flags in the modified event.
 274                  */
 275                 mpx_fde = talloc_get_type_abort(fde->additional_data,
 276                                                 struct tevent_fd);
 277
 278                 mpx_fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
 279                 mpx_fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 280
 281                 flags |= port_map_flags(mpx_fde->flags);
 282         } else {
 283                 /*
 284                  * Not (yet) a multiplexed event. See if there
 285                  * is already an event with the same fd.
 286                  */
 287                 for (mpx_fde = port_ev->ev->fd_events; mpx_fde; mpx_fde = mpx_fde->next) {
 288                         if (mpx_fde->fd != fde->fd) {
 289                                 continue;
 290                         }
 291                         if (mpx_fde == fde) {
 292                                 continue;
 293                         }
 294                         /* Same fd. */
 295                         break;
 296                 }
 297                 if (mpx_fde) {
 298                         if (mpx_fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
 299                                 /* Logic error. Can't have more then 2 multiplexed fde's. */
 300                                 tevent_debug(port_ev->ev, TEVENT_DEBUG_FATAL,
 301                                         "multiplex fde for fd[%d] is already multiplexed\n",
 302                                         mpx_fde->fd);
 303                                 return -1;
 304                         }
 305                         flags |= port_map_flags(mpx_fde->flags);
 306                 }
 307         }
 308
 309         if (!store_port_association(port_ev,
 310                                 fde,
 311                                 flags)) {
 312                 tevent_debug(port_ev->ev, TEVENT_DEBUG_FATAL,
 313                         "store_port_association failed for fd[%d]\n",
 314                         fde->fd);
 315                 return -1;
 316         }
 317
 318         /* Note we have an association now. */
 319         fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
 320         /* Only if we want to read do we tell the event handler about errors. */
 321         if (fde->flags & TEVENT_FD_READ) {
 322                 fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 323         }
 324         if (mpx_fde == NULL) {
 325                 return 0;
 326         }
 327         /* Set up the multiplex pointer. Does no harm if already multiplexed. */
 328         port_setup_multiplex_fd(port_ev,
 329                                 fde,
 330                                 mpx_fde);
 331
 332         mpx_fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
 333         /* Only if we want to read do we tell the event handler about errors. */
 334         if (mpx_fde->flags & TEVENT_FD_READ) {
 335                 mpx_fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 336         }
 337
 338         return 0;
 339 }
 340
 341 /*
 342  Delete the port association for the given fd_event.
 343 */
 344
 345 static void port_del_event(struct port_event_context *port_ev, struct tevent_fd *fde)
 346 {
 347         struct tevent_fd *mpx_fde = NULL;
 348
 349         fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
 350         fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 351
 352         if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
 353                 /*
 354                  * This is a multiplexed fde, we need to remove
 355                  * both associations.
 356                  */
 357                 mpx_fde = talloc_get_type_abort(fde->additional_data,
 358                                                 struct tevent_fd);
 359
 360                 mpx_fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
 361                 mpx_fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 362                 mpx_fde->additional_data = NULL;
 363
 364                 fde->additional_data = NULL;
 365         }
 366         delete_port_association(port_ev, fde);
 367 }
 368
 369 /*
 370  Add or remove the port event from the given fd_event
 371 */
 372 static int port_update_event(struct port_event_context *port_ev, struct tevent_fd *fde)
 373 {
 374         bool got_error = (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_GOT_ERROR);
 375         bool want_read = (fde->flags & TEVENT_FD_READ);
 376         bool want_write = (fde->flags & TEVENT_FD_WRITE);
 377         struct tevent_fd *mpx_fde = NULL;
 378
 379         if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
 380                 /*
 381                  * work out what the multiplexed fde wants.
 382                  */
 383                 mpx_fde = talloc_get_type_abort(fde->additional_data,
 384                                                 struct tevent_fd);
 385                 if (mpx_fde->flags & TEVENT_FD_READ) {
 386                         want_read = true;
 387                 }
 388                 if (mpx_fde->flags & TEVENT_FD_WRITE) {
 389                         want_write = true;
 390                 }
 391         }
 392
 393         if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION) {
 394                 /* There's already an association. */
 395                 if (want_read || (want_write && !got_error)) {
 396                         return port_add_event(port_ev, fde);
 397                 }
 398                 /*
 399                  * If we want to match the select behavior, we need to remove the port event
 400                  * when the caller isn't interested in events.
 401                  */
 402                 port_del_event(port_ev, fde);
 403                 return 0;
 404         }
 405
 406         /* There's no port event attached to the fde. */
 407         if (want_read || (want_write && !got_error)) {
 408                 return port_add_event(port_ev, fde);
 409         }
 410         return 0;
 411 }
 412
 413 /*
 414  Cope with port_get returning EPOLLHP|EPOLLERR on an association.
 415  Return true if there's nothing else to do, false if this event
 416  needs further handling.
 417 */
 418
 419 static bool port_handle_hup_or_err(struct port_event_context *port_ev,
 420                                 struct tevent_fd *fde)
 421 {
 422         if (fde == NULL) {
 423                 return true;
 424         }
 425
 426         fde->additional_flags |= PORT_ADDITIONAL_FD_FLAG_GOT_ERROR;
 427         /*
 428          * If we only wait for TEVENT_FD_WRITE, we should not tell the
 429          * event handler about it, and remove the port association,
 430          * as we only report error when waiting for read events,
 431          * to match the select() behavior.
 432          */
 433         if (!(fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_REPORT_ERROR)) {
 434                 /*
 435                  * Do the same as the poll backend and
 436                  * remove the writable flag.
 437                  */
 438                 fde->flags &= ~TEVENT_FD_WRITE;
 439                 return true;
 440         }
 441         /* This has TEVENT_FD_READ set, we're not finished. */
 442         return false;
 443 }
 444
 445 /*
 446   Event loop handling using Solaris ports.
 447 */
 448 static int port_event_loop(struct port_event_context *port_ev, struct timeval *tvalp)
 449 {
 450         int ret;
 451 #define MAXEVENTS 1
 452         port_event_t events[MAXEVENTS];
 453         uint_t nget = 1;
 454         uint_t max_events = MAXEVENTS;
 455         uint_t i;
 456         int port_errno;
 457         struct timespec ts;
 458         struct tevent_context *ev = port_ev->ev;
 459
 460         if (tvalp) {
 461                 ts.tv_sec = tvalp->tv_sec;
 462                 ts.tv_nsec = tvalp->tv_usec * 1000;
 463         }
 464
 465         if (port_ev->ev->signal_events &&
 466             tevent_common_check_signal(ev)) {
 467                 return 0;
 468         }
 469
 470         /*
 471          * Solaris triggers sending the event to the port
 472          * at the time the port association is done. Postpone
 473          * associating fd's until just before we get the events,
 474          * otherwise we can deadlock.
 475          */
 476
 477         if (associate_all_events(port_ev) != 0) {
 478                 return -1;
 479         }
 480
 481         tevent_trace_point_callback(ev, TEVENT_TRACE_BEFORE_WAIT);
 482         ret = port_getn(port_ev->port_fd, events, max_events, &nget, &ts);
 483         port_errno = errno;
 484         tevent_trace_point_callback(ev, TEVENT_TRACE_AFTER_WAIT);
 485
 486         if (ret == -1 && port_errno == EINTR) {
 487                 if (ev->signal_events) {
 488                         tevent_common_check_signal(ev);
 489                 }
 490                 /*
 491                  * If no signal handlers we got an unsolicited
 492                  * signal wakeup. This can happen with epoll
 493                  * too. Just return and ignore.
 494                  */
 495                 return 0;
 496         }
 497
 498         if (ret == -1 && port_errno == ETIME && tvalp) {
 499                 /* we don't care about a possible delay here */
 500                 tevent_common_loop_timer_delay(ev);
 501                 return 0;
 502         }
 503
 504         if (ret == -1) {
 505                 tevent_debug(ev, TEVENT_DEBUG_ERROR,
 506                                 "port_get failed (%s)\n",
 507                                 strerror(errno));
 508                 return -1;
 509         }
 510
 511         for (i = 0; i < nget; i++) {
 512                 struct tevent_fd *mpx_fde = NULL;
 513                 struct tevent_fd *fde = NULL;
 514                 uint16_t flags = 0;
 515                 struct port_associate_vals *val = talloc_get_type(events[i].portev_user,
 516                                                         struct port_associate_vals);
 517                 if (val == NULL) {
 518                         tevent_debug(ev, TEVENT_DEBUG_ERROR,
 519                                 "port_getn() gave bad data");
 520                         return -1;
 521                 }
 522
 523                 /* Mark this event as needing to be re-associated. */
 524                 val->associated_event = false;
 525
 526                 fde = val->fde;
 527
 528                 if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
 529                         /*
 530                          * Save off the multiplexed event in case we need
 531                          * to use it to call the handler function.
 532                          */
 533                         mpx_fde = talloc_get_type_abort(fde->additional_data,
 534                                                 struct tevent_fd);
 535                 }
 536
 537                 if (events[i].portev_events & (POLLHUP|POLLERR)) {
 538                         bool handled_fde = port_handle_hup_or_err(port_ev, fde);
 539                         bool handled_mpx = port_handle_hup_or_err(port_ev, mpx_fde);
 540
 541                         if (handled_fde && handled_mpx) {
 542                                 return port_update_event(port_ev, fde);
 543                         }
 544
 545                         if (!handled_mpx) {
 546                                 /*
 547                                  * If the mpx event was the one that needs
 548                                  * further handling, it's the TEVENT_FD_READ
 549                                  * event so switch over and call that handler.
 550                                  */
 551                                 fde = mpx_fde;
 552                                 mpx_fde = NULL;
 553                         }
 554                         flags |= TEVENT_FD_READ;
 555                 }
 556
 557                 if (events[i].portev_events & POLLIN) {
 558                         flags |= TEVENT_FD_READ;
 559                 }
 560                 if (events[i].portev_events & POLLOUT) {
 561                         flags |= TEVENT_FD_WRITE;
 562                 }
 563
 564                 if (flags & TEVENT_FD_WRITE) {
 565                         if (fde->flags & TEVENT_FD_WRITE) {
 566                                 mpx_fde = NULL;
 567                         }
 568                         if (mpx_fde && (mpx_fde->flags & TEVENT_FD_WRITE)) {
 569                                 fde = mpx_fde;
 570                                 mpx_fde = NULL;
 571                         }
 572
 573                         if (mpx_fde) {
 574                                 /* Ensure we got the right fde. */
 575                                 if ((flags & fde->flags) == 0) {
 576                                         fde = mpx_fde;
 577                                         mpx_fde = NULL;
 578                                 }
 579                         }
 580                 }
 581
 582                 /*
 583                  * Make sure we only pass the flags
 584                  * the handler is expecting.
 585                  */
 586                 flags &= fde->flags;
 587                 if (flags) {
 588                         fde->handler(ev, fde, flags, fde->private_data);
 589                         break;
 590                 }
 591         }
 592
 593         return 0;
 594 }
 595
 596
 597 /*
 598   create a port_event_context structure.
 599 */
 600 static int port_event_context_init(struct tevent_context *ev)
 601 {
 602         int ret;
 603         struct port_event_context *port_ev;
 604
 605         /*
 606          * We might be called during tevent_re_initialise()
 607          * which means we need to free our old additional_data.
 608          */
 609         TALLOC_FREE(ev->additional_data);
 610
 611         port_ev = talloc_zero(ev, struct port_event_context);
 612         if (!port_ev) {
 613                 return -1;
 614         }
 615         port_ev->ev = ev;
 616         port_ev->port_fd = -1;
 617         port_ev->pid = (pid_t)-1;
 618
 619         ret = port_init_ctx(port_ev);
 620         if (ret != 0) {
 621                 talloc_free(port_ev);
 622                 return ret;
 623         }
 624
 625         ev->additional_data = port_ev;
 626         return 0;
 627 }
 628
 629 /*
 630   destroy an fd_event
 631 */
 632 static int port_event_fd_destructor(struct tevent_fd *fde)
 633 {
 634         struct tevent_context *ev = fde->event_ctx;
 635         struct port_event_context *port_ev = NULL;
 636         struct tevent_fd *mpx_fde = NULL;
 637         int flags = (int)fde->flags;
 638
 639         if (ev == NULL) {
 640                 return tevent_common_fd_destructor(fde);
 641         }
 642
 643         port_ev = talloc_get_type_abort(ev->additional_data,
 644                                          struct port_event_context);
 645
 646         DLIST_REMOVE(ev->fd_events, fde);
 647
 648         if (fde->additional_flags & PORT_ADDITIONAL_FD_FLAG_HAS_MPX) {
 649                 mpx_fde = talloc_get_type_abort(fde->additional_data,
 650                                                 struct tevent_fd);
 651
 652                 fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_MPX;
 653                 mpx_fde->additional_flags &= ~PORT_ADDITIONAL_FD_FLAG_HAS_MPX;
 654
 655                 fde->additional_data = NULL;
 656                 mpx_fde->additional_data = NULL;
 657
 658                 fde->additional_flags &= PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
 659         }
 660
 661         (void)port_check_reopen(port_ev);
 662
 663         if (mpx_fde != NULL) {
 664                 (void)port_update_event(port_ev, mpx_fde);
 665         }
 666
 667         fde->flags = 0;
 668         (void)port_update_event(port_ev, fde);
 669         fde->flags = flags;
 670
 671         return tevent_common_fd_destructor(fde);
 672 }
 673
 674 /*
 675   add a fd based event
 676   return NULL on failure (memory allocation error)
 677 */
 678 static struct tevent_fd *port_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
 679                                             int fd, uint16_t flags,
 680                                             tevent_fd_handler_t handler,
 681                                             void *private_data,
 682                                             const char *handler_name,
 683                                             const char *location)
 684 {
 685         struct port_event_context *port_ev =
 686                                 talloc_get_type_abort(ev->additional_data,
 687                                 struct port_event_context);
 688         struct tevent_fd *fde;
 689
 690         fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
 691                                    handler, private_data,
 692                                    handler_name, location);
 693         if (!fde) {
 694                 return NULL;
 695         }
 696
 697         talloc_set_destructor(fde, port_event_fd_destructor);
 698
 699         if (port_check_reopen(port_ev) != 0) {
 700                 TALLOC_FREE(fde);
 701                 return NULL;
 702         }
 703
 704         if (port_update_event(port_ev, fde) != 0) {
 705                 TALLOC_FREE(fde);
 706                 return NULL;
 707         }
 708
 709         return fde;
 710 }
 711
 712 /*
 713   set the fd event flags
 714 */
 715 static void port_event_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
 716 {
 717         struct tevent_context *ev;
 718         struct port_event_context *port_ev;
 719
 720         if (fde->flags == flags) {
 721                 return;
 722         }
 723
 724         ev = fde->event_ctx;
 725         port_ev = talloc_get_type_abort(ev->additional_data,
 726                                 struct port_event_context);
 727
 728         fde->flags = flags;
 729
 730         (void)port_check_reopen(port_ev);
 731         (void)port_update_event(port_ev, fde);
 732 }
 733
 734 /*
 735   do a single event loop using the events defined in ev
 736 */
 737 static int port_event_loop_once(struct tevent_context *ev, const char *location)
 738 {
 739         struct port_event_context *port_ev = talloc_get_type(ev->additional_data,
 740                                                            struct port_event_context);
 741         struct timeval tval;
 742
 743         if (ev->signal_events &&
 744             tevent_common_check_signal(ev)) {
 745                 return 0;
 746         }
 747
 748         if (ev->immediate_events &&
 749             tevent_common_loop_immediate(ev)) {
 750                 return 0;
 751         }
 752
 753         tval = tevent_common_loop_timer_delay(ev);
 754         if (tevent_timeval_is_zero(&tval)) {
 755                 return 0;
 756         }
 757
 758         if (port_check_reopen(port_ev) != 0) {
 759                 errno = EINVAL;
 760                 return -1;
 761         }
 762         return port_event_loop(port_ev, &tval);
 763 }
 764
 765 static const struct tevent_ops port_event_ops = {
 766         .context_init           = port_event_context_init,
 767         .add_fd                 = port_event_add_fd,
 768         .set_fd_close_fn        = tevent_common_fd_set_close_fn,
 769         .get_fd_flags           = tevent_common_fd_get_flags,
 770         .set_fd_flags           = port_event_set_fd_flags,
 771         .add_timer              = tevent_common_add_timer_v2,
 772         .schedule_immediate     = tevent_common_schedule_immediate,
 773         .add_signal             = tevent_common_add_signal,
 774         .loop_once              = port_event_loop_once,
 775         .loop_wait              = tevent_common_loop_wait,
 776 };
 777
 778 _PRIVATE_ bool tevent_port_init(void)
 779 {
 780         if (!tevent_register_backend("port", &port_event_ops)) {
 781                 return false;
 782         }
 783         tevent_set_default_backend("port");
 784         return true;
 785 }