src/misc/interrupt.c

   1 /*****************************************************************************
   2  * interrupt.c:
   3  *****************************************************************************
   4  * Copyright (C) 2015 Rémi Denis-Courmont
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published by
   8  * the Free Software Foundation; either version 2.1 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  19  *****************************************************************************/
  20
  21 /** @ingroup interrupt */
  22 #ifdef HAVE_CONFIG_H
  23 # include <config.h>
  24 #endif
  25
  26 #include <assert.h>
  27 #include <errno.h>
  28 #include <limits.h>
  29 #include <stdbool.h>
  30 #include <stdlib.h>
  31
  32 #ifdef HAVE_POLL
  33 #include <poll.h>
  34 #endif
  35 #ifdef HAVE_SYS_EVENTFD_H
  36 # include <sys/eventfd.h>
  37 #endif
  38
  39 #include <vlc_common.h>
  40 #include <vlc_fs.h> /* vlc_pipe */
  41 #include <vlc_network.h> /* vlc_accept */
  42
  43 #include "interrupt.h"
  44 #include "libvlc.h"
  45
  46 static thread_local vlc_interrupt_t *vlc_interrupt_var;
  47
  48 /**
  49  * Initializes an interruption context.
  50  */
  51 void vlc_interrupt_init(vlc_interrupt_t *ctx)
  52 {
  53     vlc_mutex_init(&ctx->lock);
  54     ctx->interrupted = false;
  55     atomic_init(&ctx->killed, false);
  56     ctx->callback = NULL;
  57 }
  58
  59 vlc_interrupt_t *vlc_interrupt_create(void)
  60 {
  61     vlc_interrupt_t *ctx = malloc(sizeof (*ctx));
  62     if (likely(ctx != NULL))
  63         vlc_interrupt_init(ctx);
  64     return ctx;
  65 }
  66
  67 /**
  68  * Deinitializes an interruption context.
  69  * The context shall no longer be used by any thread.
  70  */
  71 void vlc_interrupt_deinit(vlc_interrupt_t *ctx)
  72 {
  73     assert(ctx->callback == NULL);
  74     vlc_mutex_destroy(&ctx->lock);
  75 }
  76
  77 void vlc_interrupt_destroy(vlc_interrupt_t *ctx)
  78 {
  79     assert(ctx != NULL);
  80     vlc_interrupt_deinit(ctx);
  81     free(ctx);
  82 }
  83
  84 void vlc_interrupt_raise(vlc_interrupt_t *ctx)
  85 {
  86     assert(ctx != NULL);
  87
  88     /* This function must be reentrant. But the callback typically is not
  89      * reentrant. The lock ensures that all calls to the callback for a given
  90      * context are serialized. The lock also protects against invalid memory
  91      * accesses to the callback pointer proper, and the interrupted flag. */
  92     vlc_mutex_lock(&ctx->lock);
  93     ctx->interrupted = true;
  94     if (ctx->callback != NULL)
  95         ctx->callback(ctx->data);
  96     vlc_mutex_unlock(&ctx->lock);
  97 }
  98
  99 vlc_interrupt_t *vlc_interrupt_set(vlc_interrupt_t *newctx)
 100 {
 101     vlc_interrupt_t *oldctx = vlc_interrupt_var;
 102
 103     vlc_interrupt_var = newctx;
 104     return oldctx;
 105 }
 106
 107 /**
 108  * Prepares to enter interruptible wait.
 109  * @param cb callback to interrupt the wait (i.e. wake up the thread)
 110  * @param data opaque data pointer for the callback
 111  * @note Any <b>successful</b> call <b>must</b> be paired with a call to
 112  * vlc_interrupt_finish().
 113  */
 114 static void vlc_interrupt_prepare(vlc_interrupt_t *ctx,
 115                                   void (*cb)(void *), void *data)
 116 {
 117     assert(ctx != NULL);
 118     assert(ctx == vlc_interrupt_var);
 119
 120     vlc_mutex_lock(&ctx->lock);
 121     assert(ctx->callback == NULL);
 122     ctx->callback = cb;
 123     ctx->data = data;
 124
 125     if (unlikely(ctx->interrupted))
 126         cb(data);
 127     vlc_mutex_unlock(&ctx->lock);
 128 }
 129
 130 /**
 131  * Cleans up after an interruptible wait: waits for any pending invocations of
 132  * the callback previously registed with vlc_interrupt_prepare(), and rechecks
 133  * for any pending interruption.
 134  *
 135  * @warning As this function waits for ongoing callback invocation to complete,
 136  * the caller must not hold any resource necessary for the callback to run.
 137  * Otherwise a deadlock may occur.
 138  *
 139  * @return EINTR if an interruption occurred, zero otherwise
 140  */
 141 static int vlc_interrupt_finish(vlc_interrupt_t *ctx)
 142 {
 143     int ret = 0;
 144
 145     assert(ctx != NULL);
 146     assert(ctx == vlc_interrupt_var);
 147
 148     /* Wait for pending callbacks to prevent access by other threads. */
 149     vlc_mutex_lock(&ctx->lock);
 150     ctx->callback = NULL;
 151     if (ctx->interrupted)
 152     {
 153         ret = EINTR;
 154         ctx->interrupted = false;
 155     }
 156     vlc_mutex_unlock(&ctx->lock);
 157     return ret;
 158 }
 159
 160 void vlc_interrupt_register(void (*cb)(void *), void *opaque)
 161 {
 162     vlc_interrupt_t *ctx = vlc_interrupt_var;
 163     if (ctx != NULL)
 164         vlc_interrupt_prepare(ctx, cb, opaque);
 165 }
 166
 167 int vlc_interrupt_unregister(void)
 168 {
 169     vlc_interrupt_t *ctx = vlc_interrupt_var;
 170     return (ctx != NULL) ? vlc_interrupt_finish(ctx) : 0;
 171 }
 172
 173 static void vlc_interrupt_cleanup(void *opaque)
 174 {
 175     vlc_interrupt_finish(opaque);
 176 }
 177
 178 void vlc_interrupt_kill(vlc_interrupt_t *ctx)
 179 {
 180     assert(ctx != NULL);
 181
 182     atomic_store(&ctx->killed, true);
 183     vlc_interrupt_raise(ctx);
 184 }
 185
 186 bool vlc_killed(void)
 187 {
 188     vlc_interrupt_t *ctx = vlc_interrupt_var;
 189
 190     return (ctx != NULL) && atomic_load(&ctx->killed);
 191 }
 192
 193 static void vlc_interrupt_sem(void *opaque)
 194 {
 195     vlc_sem_post(opaque);
 196 }
 197
 198 int vlc_sem_wait_i11e(vlc_sem_t *sem)
 199 {
 200     vlc_interrupt_t *ctx = vlc_interrupt_var;
 201     if (ctx == NULL)
 202         return vlc_sem_wait(sem), 0;
 203
 204     vlc_interrupt_prepare(ctx, vlc_interrupt_sem, sem);
 205
 206     vlc_cleanup_push(vlc_interrupt_cleanup, ctx);
 207     vlc_sem_wait(sem);
 208     vlc_cleanup_pop();
 209
 210     return vlc_interrupt_finish(ctx);
 211 }
 212
 213 static void vlc_mwait_i11e_wake(void *opaque)
 214 {
 215     vlc_cond_signal(opaque);
 216 }
 217
 218 static void vlc_mwait_i11e_cleanup(void *opaque)
 219 {
 220     vlc_interrupt_t *ctx = opaque;
 221     vlc_cond_t *cond = ctx->data;
 222
 223     vlc_mutex_unlock(&ctx->lock);
 224     vlc_interrupt_finish(ctx);
 225     vlc_cond_destroy(cond);
 226 }
 227
 228 int vlc_mwait_i11e(vlc_tick_t deadline)
 229 {
 230     vlc_interrupt_t *ctx = vlc_interrupt_var;
 231     if (ctx == NULL)
 232         return vlc_tick_wait(deadline), 0;
 233
 234     vlc_cond_t wait;
 235     vlc_cond_init(&wait);
 236
 237     vlc_interrupt_prepare(ctx, vlc_mwait_i11e_wake, &wait);
 238
 239     vlc_mutex_lock(&ctx->lock);
 240     vlc_cleanup_push(vlc_mwait_i11e_cleanup, ctx);
 241     while (!ctx->interrupted
 242         && vlc_cond_timedwait(&wait, &ctx->lock, deadline) == 0);
 243     vlc_cleanup_pop();
 244     vlc_mutex_unlock(&ctx->lock);
 245
 246     int ret = vlc_interrupt_finish(ctx);
 247     vlc_cond_destroy(&wait);
 248     return ret;
 249 }
 250
 251 static void vlc_interrupt_forward_wake(void *opaque)
 252 {
 253     void **data = opaque;
 254     vlc_interrupt_t *to = data[0];
 255     vlc_interrupt_t *from = data[1];
 256
 257     (atomic_load(&from->killed) ? vlc_interrupt_kill
 258                                 : vlc_interrupt_raise)(to);
 259 }
 260
 261 void vlc_interrupt_forward_start(vlc_interrupt_t *to, void *data[2])
 262 {
 263     data[0] = data[1] = NULL;
 264
 265     vlc_interrupt_t *from = vlc_interrupt_var;
 266     if (from == NULL)
 267         return;
 268
 269     assert(from != to);
 270     data[0] = to;
 271     data[1] = from;
 272     vlc_interrupt_prepare(from, vlc_interrupt_forward_wake, data);
 273 }
 274
 275 int vlc_interrupt_forward_stop(void *const data[2])
 276 {
 277     vlc_interrupt_t *from = data[1];
 278     if (from == NULL)
 279         return 0;
 280
 281     assert(from->callback == vlc_interrupt_forward_wake);
 282     assert(from->data == data);
 283     return vlc_interrupt_finish(from);
 284 }
 285
 286 #ifndef _WIN32
 287 static void vlc_poll_i11e_wake(void *opaque)
 288 {
 289     uint64_t value = 1;
 290     int *fd = opaque;
 291     int canc;
 292
 293     canc = vlc_savecancel();
 294     write(fd[1], &value, sizeof (value));
 295     vlc_restorecancel(canc);
 296 }
 297
 298 static void vlc_poll_i11e_cleanup(void *opaque)
 299 {
 300     vlc_interrupt_t *ctx = opaque;
 301     int *fd = ctx->data;
 302
 303     vlc_interrupt_finish(ctx);
 304     if (fd[1] != fd[0])
 305         vlc_close(fd[1]);
 306     vlc_close(fd[0]);
 307 }
 308
 309 static int vlc_poll_i11e_inner(struct pollfd *restrict fds, unsigned nfds,
 310                                int timeout, vlc_interrupt_t *ctx,
 311                                struct pollfd *restrict ufd)
 312 {
 313     int fd[2];
 314     int ret = -1;
 315     int canc;
 316
 317     /* TODO: cache this */
 318 # if defined (HAVE_EVENTFD) && defined (EFD_CLOEXEC)
 319     canc = vlc_savecancel();
 320     fd[0] = eventfd(0, EFD_CLOEXEC);
 321     vlc_restorecancel(canc);
 322     if (fd[0] != -1)
 323         fd[1] = fd[0];
 324     else
 325 # endif
 326     if (vlc_pipe(fd))
 327     {
 328         vlc_testcancel();
 329         errno = ENOMEM;
 330         return -1;
 331     }
 332
 333     for (unsigned i = 0; i < nfds; i++)
 334     {
 335         ufd[i].fd = fds[i].fd;
 336         ufd[i].events = fds[i].events;
 337     }
 338     ufd[nfds].fd = fd[0];
 339     ufd[nfds].events = POLLIN;
 340
 341     vlc_interrupt_prepare(ctx, vlc_poll_i11e_wake, fd);
 342
 343     vlc_cleanup_push(vlc_poll_i11e_cleanup, ctx);
 344     ret = poll(ufd, nfds + 1, timeout);
 345
 346     for (unsigned i = 0; i < nfds; i++)
 347         fds[i].revents = ufd[i].revents;
 348
 349     if (ret > 0 && ufd[nfds].revents)
 350     {
 351         uint64_t dummy;
 352
 353         read(fd[0], &dummy, sizeof (dummy));
 354         ret--;
 355     }
 356     vlc_cleanup_pop();
 357
 358     if (vlc_interrupt_finish(ctx))
 359     {
 360         errno = EINTR;
 361         ret = -1;
 362     }
 363
 364     canc = vlc_savecancel();
 365     if (fd[1] != fd[0])
 366         vlc_close(fd[1]);
 367     vlc_close(fd[0]);
 368     vlc_restorecancel(canc);
 369     return ret;
 370 }
 371
 372 int vlc_poll_i11e(struct pollfd *fds, unsigned nfds, int timeout)
 373 {
 374     vlc_interrupt_t *ctx = vlc_interrupt_var;
 375     if (ctx == NULL)
 376         return poll(fds, nfds, timeout);
 377
 378     int ret;
 379
 380     if (likely(nfds < 255))
 381     {   /* Fast path with stack allocation */
 382         struct pollfd ufd[nfds + 1];
 383
 384         ret = vlc_poll_i11e_inner(fds, nfds, timeout, ctx, ufd);
 385     }
 386     else
 387     {   /* Slow path but poll() is slow with large nfds anyway. */
 388         struct pollfd *ufd = vlc_alloc(nfds + 1, sizeof (*ufd));
 389         if (unlikely(ufd == NULL))
 390             return -1; /* ENOMEM */
 391
 392         vlc_cleanup_push(free, ufd);
 393         ret = vlc_poll_i11e_inner(fds, nfds, timeout, ctx, ufd);
 394         vlc_cleanup_pop();
 395         free(ufd);
 396     }
 397     return ret;
 398 }
 399
 400 # include <fcntl.h>
 401 # include <sys/uio.h>
 402 # ifdef HAVE_SYS_SOCKET_H
 403 #  include <sys/socket.h>
 404 # endif
 405
 406
 407 /* There are currently no ways to atomically force a non-blocking read or write
 408  * operations. Even for sockets, the MSG_DONTWAIT flag is non-standard.
 409  *
 410  * So in the event that more than one thread tries to read or write on the same
 411  * file at the same time, there is a race condition where these functions might
 412  * block in spite of an interruption. This should never happen in practice.
 413  */
 414
 415 /**
 416  * Wrapper for readv() that returns the EINTR error upon VLC I/O interruption.
 417  * @warning This function ignores the non-blocking file flag.
 418  */
 419 ssize_t vlc_readv_i11e(int fd, struct iovec *iov, int count)
 420 {
 421     struct pollfd ufd;
 422
 423     ufd.fd = fd;
 424     ufd.events = POLLIN;
 425
 426     if (vlc_poll_i11e(&ufd, 1, -1) < 0)
 427         return -1;
 428     return readv(fd, iov, count);
 429 }
 430
 431 /**
 432  * Wrapper for writev() that returns the EINTR error upon VLC I/O interruption.
 433  *
 434  * @note Like writev(), once some but not all bytes are written, the function
 435  * might wait for write completion, regardless of signals and interruptions.
 436  * @warning This function ignores the non-blocking file flag.
 437  */
 438 ssize_t vlc_writev_i11e(int fd, const struct iovec *iov, int count)
 439 {
 440     struct pollfd ufd;
 441
 442     ufd.fd = fd;
 443     ufd.events = POLLOUT;
 444
 445     if (vlc_poll_i11e(&ufd, 1, -1) < 0)
 446         return -1;
 447     return writev(fd, iov, count);
 448 }
 449
 450 /**
 451  * Wrapper for read() that returns the EINTR error upon VLC I/O interruption.
 452  * @warning This function ignores the non-blocking file flag.
 453  */
 454 ssize_t vlc_read_i11e(int fd, void *buf, size_t count)
 455 {
 456     struct iovec iov = { .iov_base = buf, .iov_len = count };
 457     return vlc_readv_i11e(fd, &iov, 1);
 458 }
 459
 460 /**
 461  * Wrapper for write() that returns the EINTR error upon VLC I/O interruption.
 462  *
 463  * @note Like write(), once some but not all bytes are written, the function
 464  * might wait for write completion, regardless of signals and interruptions.
 465  * @warning This function ignores the non-blocking file flag.
 466  */
 467 ssize_t vlc_write_i11e(int fd, const void *buf, size_t count)
 468 {
 469     struct iovec iov = { .iov_base = (void*)buf, .iov_len = count };
 470     return vlc_writev_i11e(fd, &iov, 1);
 471 }
 472
 473 ssize_t vlc_recvmsg_i11e(int fd, struct msghdr *msg, int flags)
 474 {
 475     struct pollfd ufd;
 476
 477     ufd.fd = fd;
 478     ufd.events = POLLIN;
 479
 480     if (vlc_poll_i11e(&ufd, 1, -1) < 0)
 481         return -1;
 482     /* NOTE: MSG_OOB and MSG_PEEK should work fine here.
 483      * MSG_WAITALL is not supported at this point. */
 484     return recvmsg(fd, msg, flags);
 485 }
 486
 487 ssize_t vlc_recvfrom_i11e(int fd, void *buf, size_t len, int flags,
 488                         struct sockaddr *addr, socklen_t *addrlen)
 489 {
 490     struct iovec iov = { .iov_base = buf, .iov_len = len };
 491     struct msghdr msg = {
 492         .msg_name = addr,
 493         .msg_namelen = (addrlen != NULL) ? *addrlen : 0,
 494         .msg_iov = &iov,
 495         .msg_iovlen = 1,
 496     };
 497
 498     ssize_t ret = vlc_recvmsg_i11e(fd, &msg, flags);
 499     if (ret >= 0 && addrlen != NULL)
 500         *addrlen = msg.msg_namelen;
 501     return ret;
 502 }
 503
 504 ssize_t vlc_sendmsg_i11e(int fd, const struct msghdr *msg, int flags)
 505 {
 506     struct pollfd ufd;
 507
 508     ufd.fd = fd;
 509     ufd.events = POLLOUT;
 510
 511     if (vlc_poll_i11e(&ufd, 1, -1) < 0)
 512         return -1;
 513     /* NOTE: MSG_EOR, MSG_OOB and MSG_NOSIGNAL should all work fine here. */
 514     return sendmsg(fd, msg, flags);
 515 }
 516
 517 ssize_t vlc_sendto_i11e(int fd, const void *buf, size_t len, int flags,
 518                       const struct sockaddr *addr, socklen_t addrlen)
 519 {
 520     struct iovec iov = { .iov_base = (void *)buf, .iov_len = len };
 521     struct msghdr msg = {
 522         .msg_name = (struct sockaddr *)addr,
 523         .msg_namelen = addrlen,
 524         .msg_iov = &iov,
 525         .msg_iovlen = 1,
 526     };
 527
 528     return vlc_sendmsg_i11e(fd, &msg, flags);
 529 }
 530
 531 int vlc_accept_i11e(int fd, struct sockaddr *addr, socklen_t *addrlen,
 532                   bool blocking)
 533 {
 534     struct pollfd ufd;
 535
 536     ufd.fd = fd;
 537     ufd.events = POLLIN;
 538
 539     if (vlc_poll_i11e(&ufd, 1, -1) < 0)
 540         return -1;
 541
 542     return vlc_accept(fd, addr, addrlen, blocking);
 543 }
 544
 545 #else /* _WIN32 */
 546
 547 static void CALLBACK vlc_poll_i11e_wake_self(ULONG_PTR data)
 548 {
 549     (void) data; /* Nothing to do */
 550 }
 551
 552 static void vlc_poll_i11e_wake(void *opaque)
 553 {
 554 #if !VLC_WINSTORE_APP || _WIN32_WINNT >= 0x0A00
 555     HANDLE th = opaque;
 556     QueueUserAPC(vlc_poll_i11e_wake_self, th, 0);
 557 #else
 558     (void) opaque;
 559 #endif
 560 }
 561
 562 static void vlc_poll_i11e_cleanup(void *opaque)
 563 {
 564     vlc_interrupt_t *ctx = opaque;
 565     HANDLE th = ctx->data;
 566
 567     vlc_interrupt_finish(ctx);
 568     CloseHandle(th);
 569 }
 570
 571 int vlc_poll_i11e(struct pollfd *fds, unsigned nfds, int timeout)
 572 {
 573     vlc_interrupt_t *ctx = vlc_interrupt_var;
 574     if (ctx == NULL)
 575         return vlc_poll(fds, nfds, timeout);
 576
 577     int ret = -1;
 578     HANDLE th;
 579
 580     if (!DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
 581                          GetCurrentProcess(), &th, 0, FALSE,
 582                          DUPLICATE_SAME_ACCESS))
 583     {
 584         errno = ENOMEM;
 585         return -1;
 586     }
 587
 588     vlc_interrupt_prepare(ctx, vlc_poll_i11e_wake, th);
 589
 590     vlc_cleanup_push(vlc_poll_i11e_cleanup, ctx);
 591     ret = vlc_poll(fds, nfds, timeout);
 592     vlc_cleanup_pop();
 593
 594     if (vlc_interrupt_finish(ctx))
 595     {
 596         errno = EINTR;
 597         ret = -1;
 598     }
 599
 600     CloseHandle(th);
 601     return ret;
 602 }
 603
 604 ssize_t vlc_readv_i11e(int fd, struct iovec *iov, int count)
 605 {
 606     (void) fd; (void) iov; (void) count;
 607     vlc_assert_unreachable();
 608 }
 609
 610 ssize_t vlc_writev_i11e(int fd, const struct iovec *iov, int count)
 611 {
 612     (void) fd; (void) iov; (void) count;
 613     vlc_assert_unreachable();
 614 }
 615
 616 ssize_t vlc_read_i11e(int fd, void *buf, size_t count)
 617 {
 618     return read(fd, buf, count);
 619 }
 620
 621 ssize_t vlc_write_i11e(int fd, const void *buf, size_t count)
 622 {
 623     return write(fd, buf, count);
 624 }
 625
 626 ssize_t vlc_recvmsg_i11e(int fd, struct msghdr *msg, int flags)
 627 {
 628     (void) fd; (void) msg; (void) flags;
 629     vlc_assert_unreachable();
 630 }
 631
 632 ssize_t vlc_recvfrom_i11e(int fd, void *buf, size_t len, int flags,
 633                         struct sockaddr *addr, socklen_t *addrlen)
 634 {
 635     struct pollfd ufd;
 636
 637     ufd.fd = fd;
 638     ufd.events = POLLIN;
 639
 640     if (vlc_poll_i11e(&ufd, 1, -1) < 0)
 641         return -1;
 642
 643     ssize_t ret = recvfrom(fd, buf, len, flags, addr, addrlen);
 644     if (ret < 0 && WSAGetLastError() == WSAEWOULDBLOCK)
 645         errno = EAGAIN;
 646     return ret;
 647 }
 648
 649 ssize_t vlc_sendmsg_i11e(int fd, const struct msghdr *msg, int flags)
 650 {
 651     (void) fd; (void) msg; (void) flags;
 652     vlc_assert_unreachable();
 653 }
 654
 655 ssize_t vlc_sendto_i11e(int fd, const void *buf, size_t len, int flags,
 656                       const struct sockaddr *addr, socklen_t addrlen)
 657 {
 658     struct pollfd ufd;
 659
 660     ufd.fd = fd;
 661     ufd.events = POLLOUT;
 662
 663     if (vlc_poll_i11e(&ufd, 1, -1) < 0)
 664         return -1;
 665
 666     ssize_t ret = sendto(fd, buf, len, flags, addr, addrlen);
 667     if (ret < 0 && WSAGetLastError() == WSAEWOULDBLOCK)
 668         errno = EAGAIN;
 669     return ret;
 670 }
 671
 672 int vlc_accept_i11e(int fd, struct sockaddr *addr, socklen_t *addrlen,
 673                   bool blocking)
 674 {
 675     struct pollfd ufd;
 676
 677     ufd.fd = fd;
 678     ufd.events = POLLIN;
 679
 680     if (vlc_poll_i11e(&ufd, 1, -1) < 0)
 681         return -1;
 682
 683     int cfd = vlc_accept(fd, addr, addrlen, blocking);
 684     if (cfd < 0 && WSAGetLastError() == WSAEWOULDBLOCK)
 685         errno = EAGAIN;
 686     return cfd;
 687 }
 688
 689 #endif