event.c

   1 /*
   2 Copyright (c) 2003-2006 by Juliusz Chroboczek
   3
   4 Permission is hereby granted, free of charge, to any person obtaining a copy
   5 of this software and associated documentation files (the "Software"), to deal
   6 in the Software without restriction, including without limitation the rights
   7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8 copies of the Software, and to permit persons to whom the Software is
   9 furnished to do so, subject to the following conditions:
  10
  11 The above copyright notice and this permission notice shall be included in
  12 all copies or substantial portions of the Software.
  13
  14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20 THE SOFTWARE.
  21 */
  22
  23 #include "polipo.h"
  24
  25 #ifdef HAVE_FORK
  26 static volatile sig_atomic_t exitFlag = 0;
  27 #else
  28 static int exitFlag = 0;
  29 #endif
  30 static int in_signalCondition = 0;
  31
  32 static TimeEventHandlerPtr timeEventQueue;
  33 static TimeEventHandlerPtr timeEventQueueLast;
  34
  35 struct timeval current_time;
  36 struct timeval null_time = {0,0};
  37
  38 static int fdEventSize = 0;
  39 static int fdEventNum = 0;
  40 static struct pollfd *poll_fds = NULL;
  41 static FdEventHandlerPtr *fdEvents = NULL, *fdEventsLast = NULL;
  42 int diskIsClean = 1;
  43
  44 static int fds_invalid = 0;
  45
  46 static inline int
  47 timeval_cmp(struct timeval *t1, struct timeval *t2)
  48 {
  49     if(t1->tv_sec < t2->tv_sec)
  50         return -1;
  51     else if(t1->tv_sec > t2->tv_sec)
  52         return +1;
  53     else if(t1->tv_usec < t2->tv_usec)
  54         return -1;
  55     else if(t1->tv_usec > t2->tv_usec)
  56         return +1;
  57     else
  58         return 0;
  59 }
  60
  61 static inline void
  62 timeval_minus(struct timeval *d,
  63               const struct timeval *s1, const struct timeval *s2)
  64 {
  65     if(s1->tv_usec >= s2->tv_usec) {
  66         d->tv_usec = s1->tv_usec - s2->tv_usec;
  67         d->tv_sec = s1->tv_sec - s2->tv_sec;
  68     } else {
  69         d->tv_usec = s1->tv_usec + 1000000 - s2->tv_usec;
  70         d->tv_sec = s1->tv_sec - s2->tv_sec - 1;
  71     }
  72 }
  73
  74 int
  75 timeval_minus_usec(const struct timeval *s1, const struct timeval *s2)
  76 {
  77     return (s1->tv_sec - s2->tv_sec) * 1000000 + s1->tv_usec - s2->tv_usec;
  78 }
  79
  80 #ifdef HAVE_FORK
  81 static void
  82 sigexit(int signo)
  83 {
  84     if(signo == SIGUSR1)
  85         exitFlag = 1;
  86     else if(signo == SIGUSR2)
  87         exitFlag = 2;
  88     else
  89         exitFlag = 3;
  90 }
  91 #endif
  92
  93 void
  94 initEvents()
  95 {
  96 #ifdef HAVE_FORK
  97     struct sigaction sa;
  98     sigset_t ss;
  99
 100     sigemptyset(&ss);
 101     sa.sa_handler = SIG_IGN;
 102     sa.sa_mask = ss;
 103     sa.sa_flags = 0;
 104     sigaction(SIGPIPE, &sa, NULL);
 105
 106     sigemptyset(&ss);
 107     sa.sa_handler = sigexit;
 108     sa.sa_mask = ss;
 109     sa.sa_flags = 0;
 110     sigaction(SIGTERM, &sa, NULL);
 111
 112     sigemptyset(&ss);
 113     sa.sa_handler = sigexit;
 114     sa.sa_mask = ss;
 115     sa.sa_flags = 0;
 116     sigaction(SIGHUP, &sa, NULL);
 117
 118     sigemptyset(&ss);
 119     sa.sa_handler = sigexit;
 120     sa.sa_mask = ss;
 121     sa.sa_flags = 0;
 122     sigaction(SIGINT, &sa, NULL);
 123
 124     sigemptyset(&ss);
 125     sa.sa_handler = sigexit;
 126     sa.sa_mask = ss;
 127     sa.sa_flags = 0;
 128     sigaction(SIGUSR1, &sa, NULL);
 129
 130     sigemptyset(&ss);
 131     sa.sa_handler = sigexit;
 132     sa.sa_mask = ss;
 133     sa.sa_flags = 0;
 134     sigaction(SIGUSR2, &sa, NULL);
 135 #endif
 136
 137     timeEventQueue = NULL;
 138     timeEventQueueLast = NULL;
 139     fdEventSize = 0;
 140     fdEventNum = 0;
 141     poll_fds = NULL;
 142     fdEvents = NULL;
 143     fdEventsLast = NULL;
 144 }
 145
 146 void
 147 uninitEvents(void)
 148 {
 149 #ifdef HAVE_FORK
 150     struct sigaction sa;
 151     sigset_t ss;
 152
 153     sigemptyset(&ss);
 154     sa.sa_handler = SIG_DFL;
 155     sa.sa_mask = ss;
 156     sa.sa_flags = 0;
 157     sigaction(SIGTERM, &sa, NULL);
 158
 159     sigemptyset(&ss);
 160     sa.sa_handler = SIG_DFL;
 161     sa.sa_mask = ss;
 162     sa.sa_flags = 0;
 163     sigaction(SIGHUP, &sa, NULL);
 164
 165     sigemptyset(&ss);
 166     sa.sa_handler = SIG_DFL;
 167     sa.sa_mask = ss;
 168     sa.sa_flags = 0;
 169     sigaction(SIGINT, &sa, NULL);
 170
 171     sigemptyset(&ss);
 172     sa.sa_handler = SIG_DFL;
 173     sa.sa_mask = ss;
 174     sa.sa_flags = 0;
 175     sigaction(SIGUSR1, &sa, NULL);
 176
 177     sigemptyset(&ss);
 178     sa.sa_handler = SIG_DFL;
 179     sa.sa_mask = ss;
 180     sa.sa_flags = 0;
 181     sigaction(SIGUSR2, &sa, NULL);
 182 #endif
 183 }
 184
 185 #ifdef HAVE_FORK
 186 void
 187 interestingSignals(sigset_t *ss)
 188 {
 189     sigemptyset(ss);
 190     sigaddset(ss, SIGTERM);
 191     sigaddset(ss, SIGHUP);
 192     sigaddset(ss, SIGINT);
 193     sigaddset(ss, SIGUSR1);
 194     sigaddset(ss, SIGUSR2);
 195 }
 196 #endif
 197
 198 void
 199 timeToSleep(struct timeval *time)
 200 {
 201     if(!timeEventQueue) {
 202         time->tv_sec = ~0L;
 203         time->tv_usec = ~0L;
 204     } else {
 205         *time = timeEventQueue->time;
 206     }
 207 }
 208
 209 static TimeEventHandlerPtr
 210 enqueueTimeEvent(TimeEventHandlerPtr event)
 211 {
 212     TimeEventHandlerPtr otherevent;
 213
 214     /* We try to optimise two cases -- the event happens very soon, or
 215        it happens after most of the other events. */
 216     if(timeEventQueue == NULL ||
 217        timeval_cmp(&event->time, &timeEventQueue->time) < 0) {
 218         /* It's the first event */
 219         event->next = timeEventQueue;
 220         event->previous = NULL;
 221         if(timeEventQueue) {
 222             timeEventQueue->previous = event;
 223         } else {
 224             timeEventQueueLast = event;
 225         }
 226         timeEventQueue = event;
 227     } else if(timeval_cmp(&event->time, &timeEventQueueLast->time) >= 0) {
 228         /* It's the last one */
 229         event->next = NULL;
 230         event->previous = timeEventQueueLast;
 231         timeEventQueueLast->next = event;
 232         timeEventQueueLast = event;
 233     } else {
 234         /* Walk from the end */
 235         otherevent = timeEventQueueLast;
 236         while(otherevent->previous &&
 237               timeval_cmp(&event->time, &otherevent->previous->time) < 0) {
 238             otherevent = otherevent->previous;
 239         }
 240         event->next = otherevent;
 241         event->previous = otherevent->previous;
 242         if(otherevent->previous) {
 243             otherevent->previous->next = event;
 244         } else {
 245             timeEventQueue = event;
 246         }
 247         otherevent->previous = event;
 248     }
 249     return event;
 250 }
 251
 252 TimeEventHandlerPtr
 253 scheduleTimeEvent(int seconds,
 254                   int (*handler)(TimeEventHandlerPtr), int dsize, void *data)
 255 {
 256     struct timeval when;
 257     TimeEventHandlerPtr event;
 258
 259     if(seconds >= 0) {
 260         when = current_time;
 261         when.tv_sec += seconds;
 262     } else {
 263         when.tv_sec = 0;
 264         when.tv_usec = 0;
 265     }
 266
 267     event = malloc(sizeof(TimeEventHandlerRec) - 1 + dsize);
 268     if(event == NULL) {
 269         do_log(L_ERROR, "Couldn't allocate time event handler -- "
 270                "discarding all objects.\n");
 271         exitFlag = 2;
 272         return NULL;
 273     }
 274
 275     event->time = when;
 276     event->handler = handler;
 277     /* Let the compiler optimise the common case */
 278     if(dsize == sizeof(void*))
 279         memcpy(event->data, data, sizeof(void*));
 280     else if(dsize > 0)
 281         memcpy(event->data, data, dsize);
 282
 283     return enqueueTimeEvent(event);
 284 }
 285
 286 void
 287 cancelTimeEvent(TimeEventHandlerPtr event)
 288 {
 289     if(event == timeEventQueue)
 290         timeEventQueue = event->next;
 291     if(event == timeEventQueueLast)
 292         timeEventQueueLast = event->previous;
 293     if(event->next)
 294         event->next->previous = event->previous;
 295     if(event->previous)
 296         event->previous->next = event->next;
 297     free(event);
 298 }
 299
 300 int
 301 allocateFdEventNum(int fd)
 302 {
 303     int i;
 304     if(fdEventNum < fdEventSize) {
 305         i = fdEventNum;
 306         fdEventNum++;
 307     } else {
 308         struct pollfd *new_poll_fds;
 309         FdEventHandlerPtr *new_fdEvents, *new_fdEventsLast;
 310         int new_size = 3 * fdEventSize / 2 + 1;
 311
 312         new_poll_fds = realloc(poll_fds, new_size * sizeof(struct pollfd));
 313         if(!new_poll_fds)
 314             return -1;
 315         new_fdEvents = realloc(fdEvents, new_size * sizeof(FdEventHandlerPtr));
 316         if(!new_fdEvents)
 317             return -1;
 318         new_fdEventsLast = realloc(fdEventsLast,
 319                                    new_size * sizeof(FdEventHandlerPtr));
 320         if(!new_fdEventsLast)
 321             return -1;
 322
 323         poll_fds = new_poll_fds;
 324         fdEvents = new_fdEvents;
 325         fdEventsLast = new_fdEventsLast;
 326         fdEventSize = new_size;
 327         i = fdEventNum;
 328         fdEventNum++;
 329     }
 330
 331     poll_fds[i].fd = fd;
 332     poll_fds[i].events = POLLERR | POLLHUP | POLLNVAL;
 333     poll_fds[i].revents = 0;
 334     fdEvents[i] = NULL;
 335     fdEventsLast[i] = NULL;
 336     fds_invalid = 1;
 337     return i;
 338 }
 339
 340 void
 341 deallocateFdEventNum(int i)
 342 {
 343     if(i < fdEventNum - 1) {
 344         memmove(&poll_fds[i], &poll_fds[i + 1],
 345                 (fdEventNum - i - 1) * sizeof(struct pollfd));
 346         memmove(&fdEvents[i], &fdEvents[i + 1],
 347                 (fdEventNum - i - 1) * sizeof(FdEventHandlerPtr));
 348         memmove(&fdEventsLast[i], &fdEventsLast[i + 1],
 349                 (fdEventNum - i - 1) * sizeof(FdEventHandlerPtr));
 350     }
 351     fdEventNum--;
 352     fds_invalid = 1;
 353 }
 354
 355 FdEventHandlerPtr
 356 makeFdEvent(int fd, int poll_events,
 357             int (*handler)(int, FdEventHandlerPtr), int dsize, void *data)
 358 {
 359     FdEventHandlerPtr event;
 360
 361     event = malloc(sizeof(FdEventHandlerRec) - 1 + dsize);
 362     if(event == NULL) {
 363         do_log(L_ERROR, "Couldn't allocate fd event handler -- "
 364                "discarding all objects.\n");
 365         exitFlag = 2;
 366         return NULL;
 367     }
 368     event->fd = fd;
 369     event->poll_events = poll_events;
 370     event->handler = handler;
 371     /* Let the compiler optimise the common cases */
 372     if(dsize == sizeof(void*))
 373         memcpy(event->data, data, sizeof(void*));
 374     else if(dsize == sizeof(StreamRequestRec))
 375         memcpy(event->data, data, sizeof(StreamRequestRec));
 376     else if(dsize > 0)
 377         memcpy(event->data, data, dsize);
 378     return event;
 379 }
 380
 381 FdEventHandlerPtr
 382 registerFdEventHelper(FdEventHandlerPtr event)
 383 {
 384     int i;
 385     int fd = event->fd;
 386
 387     for(i = 0; i < fdEventNum; i++)
 388         if(poll_fds[i].fd == fd)
 389             break;
 390
 391     if(i >= fdEventNum)
 392         i = allocateFdEventNum(fd);
 393     if(i < 0) {
 394         free(event);
 395         return NULL;
 396     }
 397
 398     event->next = NULL;
 399     event->previous = fdEventsLast[i];
 400     if(fdEvents[i] == NULL) {
 401         fdEvents[i] = event;
 402     } else {
 403         fdEventsLast[i]->next = event;
 404     }
 405     fdEventsLast[i] = event;
 406     poll_fds[i].events |= event->poll_events;
 407
 408     return event;
 409 }
 410
 411 FdEventHandlerPtr
 412 registerFdEvent(int fd, int poll_events,
 413                 int (*handler)(int, FdEventHandlerPtr), int dsize, void *data)
 414 {
 415     FdEventHandlerPtr event;
 416
 417     event = makeFdEvent(fd, poll_events, handler, dsize, data);
 418     if(event == NULL)
 419         return NULL;
 420
 421     return registerFdEventHelper(event);
 422 }
 423
 424 static int
 425 recomputePollEvents(FdEventHandlerPtr event)
 426 {
 427     int pe = 0;
 428     while(event) {
 429         pe |= event->poll_events;
 430         event = event->next;
 431     }
 432     return pe | POLLERR | POLLHUP | POLLNVAL;
 433 }
 434
 435 static void
 436 unregisterFdEventI(FdEventHandlerPtr event, int i)
 437 {
 438     assert(i < fdEventNum && poll_fds[i].fd == event->fd);
 439
 440     if(fdEvents[i] == event) {
 441         assert(!event->previous);
 442         fdEvents[i] = event->next;
 443     } else {
 444         event->previous->next = event->next;
 445     }
 446
 447     if(fdEventsLast[i] == event) {
 448         assert(!event->next);
 449         fdEventsLast[i] = event->previous;
 450     } else {
 451         event->next->previous = event->previous;
 452     }
 453
 454     free(event);
 455
 456     if(fdEvents[i] == NULL) {
 457         deallocateFdEventNum(i);
 458     } else {
 459         poll_fds[i].events = recomputePollEvents(fdEvents[i]) |
 460             POLLERR | POLLHUP | POLLNVAL;
 461     }
 462 }
 463
 464 void
 465 unregisterFdEvent(FdEventHandlerPtr event)
 466 {
 467     int i;
 468
 469     for(i = 0; i < fdEventNum; i++) {
 470         if(poll_fds[i].fd == event->fd) {
 471             unregisterFdEventI(event, i);
 472             return;
 473         }
 474     }
 475     abort();
 476 }
 477
 478 void
 479 runTimeEventQueue()
 480 {
 481     TimeEventHandlerPtr event;
 482     int done;
 483
 484     while(timeEventQueue &&
 485           timeval_cmp(&timeEventQueue->time, &current_time) <= 0) {
 486         event = timeEventQueue;
 487         timeEventQueue = event->next;
 488         if(timeEventQueue)
 489             timeEventQueue->previous = NULL;
 490         else
 491             timeEventQueueLast = NULL;
 492         done = event->handler(event);
 493         assert(done);
 494         free(event);
 495     }
 496 }
 497
 498 static FdEventHandlerPtr
 499 findEventHelper(int revents, FdEventHandlerPtr events)
 500 {
 501     FdEventHandlerPtr event = events;
 502     while(event) {
 503         if(revents & event->poll_events)
 504             return event;
 505         event = event->next;
 506     }
 507     return NULL;
 508 }
 509
 510
 511
 512 static FdEventHandlerPtr
 513 findEvent(int revents, FdEventHandlerPtr events)
 514 {
 515     FdEventHandlerPtr event;
 516
 517     assert(!(revents & POLLNVAL));
 518
 519     if((revents & POLLHUP) || (revents & POLLERR)) {
 520         event = findEventHelper(POLLOUT, events);
 521         if(event) return event;
 522
 523         event = findEventHelper(POLLIN, events);
 524         if(event) return event;
 525         return NULL;
 526     }
 527
 528     if(revents & POLLOUT) {
 529         event = findEventHelper(POLLOUT, events);
 530         if(event) return event;
 531     }
 532
 533     if(revents & POLLIN) {
 534         event = findEventHelper(POLLIN, events);
 535         if(event) return event;
 536     }
 537     return NULL;
 538 }
 539
 540 typedef struct _FdEventHandlerPoke {
 541     int fd;
 542     int what;
 543     int status;
 544 } FdEventHandlerPokeRec, *FdEventHandlerPokePtr;
 545
 546 static int
 547 pokeFdEventHandler(TimeEventHandlerPtr tevent)
 548 {
 549     FdEventHandlerPokePtr poke = (FdEventHandlerPokePtr)tevent->data;
 550     int fd = poke->fd;
 551     int what = poke->what;
 552     int status = poke->status;
 553     int done;
 554     FdEventHandlerPtr event, next;
 555     int i;
 556
 557     for(i = 0; i < fdEventNum; i++) {
 558         if(poll_fds[i].fd == fd)
 559             break;
 560     }
 561
 562     if(i >= fdEventNum)
 563         return 1;
 564
 565     event = fdEvents[i];
 566     while(event) {
 567         next = event->next;
 568         if(event->poll_events & what) {
 569             done = event->handler(status, event);
 570             if(done) {
 571                 if(fds_invalid)
 572                     unregisterFdEvent(event);
 573                 else
 574                     unregisterFdEventI(event, i);
 575             }
 576             if(fds_invalid)
 577                 break;
 578         }
 579         event = next;
 580     }
 581     return 1;
 582 }
 583
 584 void
 585 pokeFdEvent(int fd, int status, int what)
 586 {
 587     TimeEventHandlerPtr handler;
 588     FdEventHandlerPokeRec poke;
 589
 590     poke.fd = fd;
 591     poke.status = status;
 592     poke.what = what;
 593
 594     handler = scheduleTimeEvent(0, pokeFdEventHandler,
 595                                 sizeof(poke), &poke);
 596     if(!handler) {
 597         do_log(L_ERROR, "Couldn't allocate handler.\n");
 598     }
 599 }
 600
 601 int
 602 workToDo()
 603 {
 604     struct timeval sleep_time;
 605     int rc;
 606
 607     if(exitFlag)
 608         return 1;
 609
 610     timeToSleep(&sleep_time);
 611     gettimeofday(&current_time, NULL);
 612     if(timeval_cmp(&sleep_time, &current_time) <= 0)
 613         return 1;
 614     rc = poll(poll_fds, fdEventNum, 0);
 615     if(rc < 0) {
 616         do_log_error(L_ERROR, errno, "Couldn't poll");
 617         return 1;
 618     }
 619     return(rc >= 1);
 620 }
 621
 622 void
 623 eventLoop()
 624 {
 625     struct timeval sleep_time, timeout;
 626     int rc, i, done, n;
 627     FdEventHandlerPtr event;
 628     int fd0;
 629
 630     gettimeofday(&current_time, NULL);
 631
 632     while(1) {
 633     again:
 634         if(exitFlag) {
 635             if(exitFlag < 3)
 636                 reopenLog();
 637             if(exitFlag >= 2) {
 638                 discardObjects(1, 0);
 639                 if(exitFlag >= 3)
 640                     return;
 641                 free_chunk_arenas();
 642             } else {
 643                 writeoutObjects(1);
 644             }
 645             initForbidden();
 646             exitFlag = 0;
 647         }
 648
 649         timeToSleep(&sleep_time);
 650         if(sleep_time.tv_sec == -1) {
 651             rc = poll(poll_fds, fdEventNum,
 652                       diskIsClean ? -1 : idleTime * 1000);
 653         } else if(timeval_cmp(&sleep_time, &current_time) <= 0) {
 654             runTimeEventQueue();
 655             continue;
 656         } else {
 657             gettimeofday(&current_time, NULL);
 658             if(timeval_cmp(&sleep_time, &current_time) <= 0) {
 659                 runTimeEventQueue();
 660                 continue;
 661             } else {
 662                 int t;
 663                 timeval_minus(&timeout, &sleep_time, &current_time);
 664                 t = timeout.tv_sec * 1000 + (timeout.tv_usec + 999) / 1000;
 665                 rc = poll(poll_fds, fdEventNum,
 666                           diskIsClean ? t : MIN(idleTime * 1000, t));
 667             }
 668         }
 669
 670         gettimeofday(&current_time, NULL);
 671
 672         if(rc < 0) {
 673             if(errno == EINTR) {
 674                 continue;
 675             } else if(errno == ENOMEM) {
 676                 free_chunk_arenas();
 677                 do_log(L_ERROR,
 678                        "Couldn't poll: out of memory.  "
 679                        "Sleeping for one second.\n");
 680                 sleep(1);
 681             } else {
 682                 do_log_error(L_ERROR, errno, "Couldn't poll");
 683                 exitFlag = 3;
 684             }
 685             continue;
 686         }
 687
 688         if(rc == 0) {
 689             if(!diskIsClean) {
 690                 timeToSleep(&sleep_time);
 691                 if(timeval_cmp(&sleep_time, &current_time) > 0)
 692                     writeoutObjects(0);
 693             }
 694             continue;
 695         }
 696
 697         /* Rather than tracking all changes to the in-memory cache, we
 698            assume that something changed whenever we see any activity. */
 699         diskIsClean = 0;
 700
 701         fd0 =
 702             (current_time.tv_usec ^ (current_time.tv_usec >> 16)) % fdEventNum;
 703         n = rc;
 704         for(i = 0; i < fdEventNum; i++) {
 705             int j = (i + fd0) % fdEventNum;
 706             if(n <= 0)
 707                 break;
 708             if(poll_fds[j].revents) {
 709                 n--;
 710                 event = findEvent(poll_fds[j].revents, fdEvents[j]);
 711                 if(!event)
 712                     continue;
 713                 done = event->handler(0, event);
 714                 if(done) {
 715                     if(fds_invalid)
 716                         unregisterFdEvent(event);
 717                     else
 718                         unregisterFdEventI(event, j);
 719                 }
 720                 if(fds_invalid) {
 721                     fds_invalid = 0;
 722                     goto again;
 723                 }
 724             }
 725         }
 726     }
 727 }
 728
 729 void
 730 initCondition(ConditionPtr condition)
 731 {
 732     condition->handlers = NULL;
 733 }
 734
 735 ConditionPtr
 736 makeCondition(void)
 737 {
 738     ConditionPtr condition;
 739     condition = malloc(sizeof(ConditionRec));
 740     if(condition == NULL)
 741         return NULL;
 742     initCondition(condition);
 743     return condition;
 744 }
 745
 746 ConditionHandlerPtr
 747 conditionWait(ConditionPtr condition,
 748               int (*handler)(int, ConditionHandlerPtr),
 749               int dsize, void *data)
 750 {
 751     ConditionHandlerPtr chandler;
 752
 753     assert(!in_signalCondition);
 754
 755     chandler = malloc(sizeof(ConditionHandlerRec) - 1 + dsize);
 756     if(!chandler)
 757         return NULL;
 758
 759     chandler->condition = condition;
 760     chandler->handler = handler;
 761     /* Let the compiler optimise the common case */
 762     if(dsize == sizeof(void*))
 763         memcpy(chandler->data, data, sizeof(void*));
 764     else if(dsize > 0)
 765         memcpy(chandler->data, data, dsize);
 766
 767     if(condition->handlers)
 768         condition->handlers->previous = chandler;
 769     chandler->next = condition->handlers;
 770     chandler->previous = NULL;
 771     condition->handlers = chandler;
 772     return chandler;
 773 }
 774
 775 void
 776 unregisterConditionHandler(ConditionHandlerPtr handler)
 777 {
 778     ConditionPtr condition = handler->condition;
 779
 780     assert(!in_signalCondition);
 781
 782     if(condition->handlers == handler)
 783         condition->handlers = condition->handlers->next;
 784     if(handler->next)
 785         handler->next->previous = handler->previous;
 786     if(handler->previous)
 787         handler->previous->next = handler->next;
 788
 789     free(handler);
 790 }
 791
 792 void
 793 abortConditionHandler(ConditionHandlerPtr handler)
 794 {
 795     int done;
 796     done = handler->handler(-1, handler);
 797     assert(done);
 798     unregisterConditionHandler(handler);
 799 }
 800
 801 void
 802 signalCondition(ConditionPtr condition)
 803 {
 804     ConditionHandlerPtr handler;
 805     int done;
 806
 807     assert(!in_signalCondition);
 808     in_signalCondition++;
 809
 810     handler = condition->handlers;
 811     while(handler) {
 812         ConditionHandlerPtr next = handler->next;
 813         done = handler->handler(0, handler);
 814         if(done) {
 815             if(handler == condition->handlers)
 816                 condition->handlers = next;
 817             if(next)
 818                 next->previous = handler->previous;
 819             if(handler->previous)
 820                 handler->previous->next = next;
 821             else
 822                 condition->handlers = next;
 823             free(handler);
 824         }
 825         handler = next;
 826     }
 827     in_signalCondition--;
 828 }
 829
 830 void
 831 polipoExit()
 832 {
 833     exitFlag = 3;
 834 }