evbuffer_new: 372| 31.1k|{ 373| 31.1k| struct evbuffer *buffer; 374| | 375| 31.1k| buffer = mm_calloc(1, sizeof(struct evbuffer)); ------------------ | | 77| 31.1k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ 376| 31.1k| if (buffer == NULL) ------------------ | Branch (376:6): [True: 0, False: 31.1k] ------------------ 377| 0| return (NULL); 378| | 379| 31.1k| LIST_INIT(&buffer->callbacks); ------------------ | | 170| 31.1k|#define LIST_INIT(head) do { \ | | 171| 31.1k| LIST_FIRST(head) = LIST_END(head); \ | | ------------------ | | | | 157| 31.1k|#define LIST_FIRST(head) ((head)->lh_first) | | ------------------ | | LIST_FIRST(head) = LIST_END(head); \ | | ------------------ | | | | 158| 31.1k|#define LIST_END(head) NULL | | ------------------ | | 172| 31.1k|} while (0) | | ------------------ | | | Branch (172:10): [Folded, False: 31.1k] | | ------------------ ------------------ 380| 31.1k| buffer->refcnt = 1; 381| 31.1k| buffer->last_with_datap = &buffer->first; 382| 31.1k| buffer->max_read = EVBUFFER_MAX_READ_DEFAULT; ------------------ | | 137| 31.1k|#define EVBUFFER_MAX_READ_DEFAULT 4096 ------------------ 383| | 384| 31.1k| return (buffer); 385| 31.1k|} evbuffer_set_parent_: 459| 3.80k|{ 460| 3.80k| EVBUFFER_LOCK(buf); ------------------ | | 288| 3.80k| do { \ | | 289| 3.80k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 3.80k| do { \ | | | | 95| 3.80k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 3.80k] | | | | ------------------ | | | | 96| 3.80k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 3.80k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 3.80k] | | | | ------------------ | | ------------------ | | 290| 3.80k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 3.80k] | | ------------------ ------------------ 461| 3.80k| buf->parent = bev; 462| 3.80k| EVBUFFER_UNLOCK(buf); ------------------ | | 292| 3.80k| do { \ | | 293| 3.80k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 3.80k| do { \ | | | | 102| 3.80k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 3.80k] | | | | ------------------ | | | | 103| 3.80k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 3.80k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 3.80k] | | | | ------------------ | | ------------------ | | 294| 3.80k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 3.80k] | | ------------------ ------------------ 463| 3.80k|} evbuffer_invoke_callbacks_: 525| 3.16M|{ 526| 3.16M| if (LIST_EMPTY(&buffer->callbacks)) { ------------------ | | 159| 3.16M|#define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head)) | | ------------------ | | | | 157| 3.16M|#define LIST_FIRST(head) ((head)->lh_first) | | ------------------ | | #define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head)) | | ------------------ | | | | 158| 3.16M|#define LIST_END(head) NULL | | ------------------ | | | Branch (159:27): [True: 3.16M, False: 7.27k] | | ------------------ ------------------ 527| 3.16M| buffer->n_add_for_cb = buffer->n_del_for_cb = 0; 528| 3.16M| return; 529| 3.16M| } 530| | 531| 7.27k| if (buffer->deferred_cbs) { ------------------ | Branch (531:6): [True: 0, False: 7.27k] ------------------ 532| 0| if (event_deferred_cb_schedule_(buffer->cb_queue, &buffer->deferred)) { ------------------ | Branch (532:7): [True: 0, False: 0] ------------------ 533| 0| evbuffer_incref_and_lock_(buffer); 534| 0| if (buffer->parent) ------------------ | Branch (534:8): [True: 0, False: 0] ------------------ 535| 0| bufferevent_incref_(buffer->parent); ------------------ | | 377| 0|#define bufferevent_incref_(bufev) bufferevent_incref(bufev) ------------------ 536| 0| EVBUFFER_UNLOCK(buffer); ------------------ | | 292| 0| do { \ | | 293| 0| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 0| do { \ | | | | 102| 0| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 0] | | | | ------------------ | | | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 0| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 294| 0| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 0] | | ------------------ ------------------ 537| 0| } 538| 0| } 539| | 540| 7.27k| evbuffer_run_callbacks(buffer, 0); 541| 7.27k|} evbuffer_decref_and_unlock_: 572| 31.1k|{ 573| 31.1k| struct evbuffer_chain *chain, *next; 574| 31.1k| ASSERT_EVBUFFER_LOCKED(buffer); ------------------ | | 285| 31.1k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 31.1k| do { \ | | | | 131| 31.1k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 31.1k] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 31.1k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 31.1k] | | | | ------------------ | | ------------------ ------------------ 575| | 576| 31.1k| EVUTIL_ASSERT(buffer->refcnt > 0); ------------------ | | 368| 31.1k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 31.1k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 31.1k| (void)sizeof(!(condition)); \ | | | | 98| 31.1k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 31.1k] | | | | ------------------ | | ------------------ ------------------ 577| | 578| 31.1k| if (--buffer->refcnt > 0) { ------------------ | Branch (578:6): [True: 0, False: 31.1k] ------------------ 579| 0| EVBUFFER_UNLOCK(buffer); ------------------ | | 292| 0| do { \ | | 293| 0| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 0| do { \ | | | | 102| 0| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 0] | | | | ------------------ | | | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 0| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 294| 0| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 0] | | ------------------ ------------------ 580| 0| return; 581| 0| } 582| | 583| 60.1k| for (chain = buffer->first; chain != NULL; chain = next) { ------------------ | Branch (583:30): [True: 29.0k, False: 31.1k] ------------------ 584| 29.0k| next = chain->next; 585| 29.0k| evbuffer_chain_free(chain); 586| 29.0k| } 587| 31.1k| evbuffer_remove_all_callbacks(buffer); 588| 31.1k| if (buffer->deferred_cbs) ------------------ | Branch (588:6): [True: 0, False: 31.1k] ------------------ 589| 0| event_deferred_cb_cancel_(buffer->cb_queue, &buffer->deferred); 590| | 591| 31.1k| EVBUFFER_UNLOCK(buffer); ------------------ | | 292| 31.1k| do { \ | | 293| 31.1k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 31.1k| do { \ | | | | 102| 31.1k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 31.1k] | | | | ------------------ | | | | 103| 31.1k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 31.1k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 31.1k] | | | | ------------------ | | ------------------ | | 294| 31.1k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 31.1k] | | ------------------ ------------------ 592| 31.1k| if (buffer->own_lock) ------------------ | Branch (592:6): [True: 0, False: 31.1k] ------------------ 593| 0| EVTHREAD_FREE_LOCK(buffer->lock, EVTHREAD_LOCKTYPE_RECURSIVE); ------------------ | | 86| 0| do { \ | | 87| 0| void *lock_tmp_ = (lockvar); \ | | 88| 0| if (lock_tmp_ && evthread_lock_fns_.free) \ | | ------------------ | | | Branch (88:7): [True: 0, False: 0] | | | Branch (88:20): [True: 0, False: 0] | | ------------------ | | 89| 0| evthread_lock_fns_.free(lock_tmp_, (locktype)); \ | | 90| 0| } while (0) | | ------------------ | | | Branch (90:11): [Folded, False: 0] | | ------------------ ------------------ 594| 31.1k| mm_free(buffer); ------------------ | | 80| 31.1k|#define mm_free(p) event_mm_free_(p) ------------------ 595| 31.1k|} evbuffer_free: 599| 31.1k|{ 600| 31.1k| EVBUFFER_LOCK(buffer); ------------------ | | 288| 31.1k| do { \ | | 289| 31.1k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 31.1k| do { \ | | | | 95| 31.1k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 31.1k] | | | | ------------------ | | | | 96| 31.1k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 31.1k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 31.1k] | | | | ------------------ | | ------------------ | | 290| 31.1k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 31.1k] | | ------------------ ------------------ 601| 31.1k| evbuffer_decref_and_unlock_(buffer); 602| 31.1k|} evbuffer_set_max_read: 605| 1.90k|{ 606| 1.90k| if (max > INT_MAX) { ------------------ | Branch (606:6): [True: 0, False: 1.90k] ------------------ 607| 0| return -1; 608| 0| } 609| | 610| 1.90k| EVBUFFER_LOCK(buf); ------------------ | | 288| 1.90k| do { \ | | 289| 1.90k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 1.90k| do { \ | | | | 95| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 96| 1.90k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 290| 1.90k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 1.90k] | | ------------------ ------------------ 611| 1.90k| buf->max_read = max; 612| 1.90k| EVBUFFER_UNLOCK(buf); ------------------ | | 292| 1.90k| do { \ | | 293| 1.90k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 1.90k| do { \ | | | | 102| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 103| 1.90k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 294| 1.90k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 1.90k] | | ------------------ ------------------ 613| 1.90k| return 0; 614| 1.90k|} evbuffer_get_length: 638| 1.17M|{ 639| 1.17M| size_t result; 640| 1.17M| EVBUFFER_LOCK(buffer); ------------------ | | 288| 1.17M| do { \ | | 289| 1.17M| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 1.17M| do { \ | | | | 95| 1.17M| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.17M] | | | | ------------------ | | | | 96| 1.17M| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.17M| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.17M] | | | | ------------------ | | ------------------ | | 290| 1.17M| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 1.17M] | | ------------------ ------------------ 641| 1.17M| result = buffer->total_len; 642| 1.17M| EVBUFFER_UNLOCK(buffer); ------------------ | | 292| 1.17M| do { \ | | 293| 1.17M| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 1.17M| do { \ | | | | 102| 1.17M| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.17M] | | | | ------------------ | | | | 103| 1.17M| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.17M| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.17M] | | | | ------------------ | | ------------------ | | 294| 1.17M| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 1.17M] | | ------------------ ------------------ 643| 1.17M| return result; 644| 1.17M|} evbuffer_add_buffer: 993| 1.02k|{ 994| 1.02k| struct evbuffer_chain *pinned, *last; 995| 1.02k| size_t in_total_len, out_total_len; 996| 1.02k| int result = 0; 997| | 998| 1.02k| EVBUFFER_LOCK2(inbuf, outbuf); ------------------ | | 296| 1.02k| do { \ | | 297| 1.02k| EVLOCK_LOCK2((buffer1)->lock, (buffer2)->lock, 0, 0); \ | | ------------------ | | | | 351| 1.02k| do { \ | | | | 352| 1.02k| void *lock1_tmplock_ = (lock1); \ | | | | 353| 1.02k| void *lock2_tmplock_ = (lock2); \ | | | | 354| 1.02k| EVLOCK_SORTLOCKS_(lock1_tmplock_,lock2_tmplock_); \ | | | | ------------------ | | | | | | 340| 1.02k| do { \ | | | | | | 341| 1.02k| if (lockvar1 && lockvar2 && lockvar1 > lockvar2) { \ | | | | | | ------------------ | | | | | | | Branch (341:7): [True: 0, False: 1.02k] | | | | | | | Branch (341:19): [True: 0, False: 0] | | | | | | | Branch (341:31): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 342| 0| void *tmp = lockvar1; \ | | | | | | 343| 0| lockvar1 = lockvar2; \ | | | | | | 344| 0| lockvar2 = tmp; \ | | | | | | 345| 0| } \ | | | | | | 346| 1.02k| } while (0) | | | | | | ------------------ | | | | | | | Branch (346:11): [Folded, False: 1.02k] | | | | | | ------------------ | | | | ------------------ | | | | 355| 1.02k| EVLOCK_LOCK(lock1_tmplock_,mode1); \ | | | | ------------------ | | | | | | 94| 1.02k| do { \ | | | | | | 95| 1.02k| if (lockvar) \ | | | | | | ------------------ | | | | | | | Branch (95:7): [True: 0, False: 1.02k] | | | | | | ------------------ | | | | | | 96| 1.02k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | | | 97| 1.02k| } while (0) | | | | | | ------------------ | | | | | | | Branch (97:11): [Folded, False: 1.02k] | | | | | | ------------------ | | | | ------------------ | | | | 356| 1.02k| if (lock2_tmplock_ != lock1_tmplock_) \ | | | | ------------------ | | | | | Branch (356:7): [True: 0, False: 1.02k] | | | | ------------------ | | | | 357| 1.02k| EVLOCK_LOCK(lock2_tmplock_,mode2); \ | | | | ------------------ | | | | | | 94| 0| do { \ | | | | | | 95| 0| if (lockvar) \ | | | | | | ------------------ | | | | | | | Branch (95:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 96| 0| evthread_lock_fns_.lock(mode, lockvar); \ | | | | | | 97| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (97:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 358| 1.02k| } while (0) | | | | ------------------ | | | | | Branch (358:11): [Folded, False: 1.02k] | | | | ------------------ | | ------------------ | | 298| 1.02k| } while (0) | | ------------------ | | | Branch (298:11): [Folded, False: 1.02k] | | ------------------ ------------------ 999| 1.02k| in_total_len = inbuf->total_len; 1000| 1.02k| out_total_len = outbuf->total_len; 1001| | 1002| 1.02k| if (in_total_len == 0 || outbuf == inbuf) ------------------ | Branch (1002:6): [True: 0, False: 1.02k] | Branch (1002:27): [True: 0, False: 1.02k] ------------------ 1003| 0| goto done; 1004| | 1005| 1.02k| if (outbuf->freeze_end || inbuf->freeze_start) { ------------------ | Branch (1005:6): [True: 0, False: 1.02k] | Branch (1005:28): [True: 0, False: 1.02k] ------------------ 1006| 0| result = -1; 1007| 0| goto done; 1008| 0| } 1009| | 1010| 1.02k| if (PRESERVE_PINNED(inbuf, &pinned, &last) < 0) { ------------------ | Branch (1010:6): [True: 0, False: 1.02k] ------------------ 1011| 0| result = -1; 1012| 0| goto done; 1013| 0| } 1014| | 1015| 1.02k| if (out_total_len == 0) { ------------------ | Branch (1015:6): [True: 974, False: 54] ------------------ 1016| | /* There might be an empty chain at the start of outbuf; free 1017| | * it. */ 1018| 974| evbuffer_free_all_chains(outbuf->first); 1019| 974| COPY_CHAIN(outbuf, inbuf); 1020| 974| } else { 1021| 54| APPEND_CHAIN(outbuf, inbuf); 1022| 54| } 1023| | 1024| 1.02k| RESTORE_PINNED(inbuf, pinned, last); 1025| | 1026| 1.02k| inbuf->n_del_for_cb += in_total_len; 1027| 1.02k| outbuf->n_add_for_cb += in_total_len; 1028| | 1029| 1.02k| evbuffer_invoke_callbacks_(inbuf); 1030| 1.02k| evbuffer_invoke_callbacks_(outbuf); 1031| | 1032| 1.02k|done: 1033| 1.02k| EVBUFFER_UNLOCK2(inbuf, outbuf); ------------------ | | 300| 1.02k| do { \ | | 301| 1.02k| EVLOCK_UNLOCK2((buffer1)->lock, (buffer2)->lock, 0, 0); \ | | ------------------ | | | | 361| 1.02k| do { \ | | | | 362| 1.02k| void *lock1_tmplock_ = (lock1); \ | | | | 363| 1.02k| void *lock2_tmplock_ = (lock2); \ | | | | 364| 1.02k| EVLOCK_SORTLOCKS_(lock1_tmplock_,lock2_tmplock_); \ | | | | ------------------ | | | | | | 340| 1.02k| do { \ | | | | | | 341| 1.02k| if (lockvar1 && lockvar2 && lockvar1 > lockvar2) { \ | | | | | | ------------------ | | | | | | | Branch (341:7): [True: 0, False: 1.02k] | | | | | | | Branch (341:19): [True: 0, False: 0] | | | | | | | Branch (341:31): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 342| 0| void *tmp = lockvar1; \ | | | | | | 343| 0| lockvar1 = lockvar2; \ | | | | | | 344| 0| lockvar2 = tmp; \ | | | | | | 345| 0| } \ | | | | | | 346| 1.02k| } while (0) | | | | | | ------------------ | | | | | | | Branch (346:11): [Folded, False: 1.02k] | | | | | | ------------------ | | | | ------------------ | | | | 365| 1.02k| if (lock2_tmplock_ != lock1_tmplock_) \ | | | | ------------------ | | | | | Branch (365:7): [True: 0, False: 1.02k] | | | | ------------------ | | | | 366| 1.02k| EVLOCK_UNLOCK(lock2_tmplock_,mode2); \ | | | | ------------------ | | | | | | 101| 0| do { \ | | | | | | 102| 0| if (lockvar) \ | | | | | | ------------------ | | | | | | | Branch (102:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | | | 104| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (104:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 367| 1.02k| EVLOCK_UNLOCK(lock1_tmplock_,mode1); \ | | | | ------------------ | | | | | | 101| 1.02k| do { \ | | | | | | 102| 1.02k| if (lockvar) \ | | | | | | ------------------ | | | | | | | Branch (102:7): [True: 0, False: 1.02k] | | | | | | ------------------ | | | | | | 103| 1.02k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | | | 104| 1.02k| } while (0) | | | | | | ------------------ | | | | | | | Branch (104:11): [Folded, False: 1.02k] | | | | | | ------------------ | | | | ------------------ | | | | 368| 1.02k| } while (0) | | | | ------------------ | | | | | Branch (368:11): [Folded, False: 1.02k] | | | | ------------------ | | ------------------ | | 302| 1.02k| } while (0) | | ------------------ | | | Branch (302:11): [Folded, False: 1.02k] | | ------------------ ------------------ 1034| 1.02k| return result; 1035| 1.02k|} evbuffer_drain: 1128| 1.43M|{ 1129| 1.43M| struct evbuffer_chain *chain, *next; 1130| 1.43M| size_t remaining, old_len; 1131| 1.43M| int result = 0; 1132| | 1133| 1.43M| EVBUFFER_LOCK(buf); ------------------ | | 288| 1.43M| do { \ | | 289| 1.43M| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 1.43M| do { \ | | | | 95| 1.43M| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.43M] | | | | ------------------ | | | | 96| 1.43M| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.43M| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.43M] | | | | ------------------ | | ------------------ | | 290| 1.43M| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 1.43M] | | ------------------ ------------------ 1134| 1.43M| old_len = buf->total_len; 1135| | 1136| 1.43M| if (old_len == 0) ------------------ | Branch (1136:6): [True: 243, False: 1.43M] ------------------ 1137| 243| goto done; 1138| | 1139| 1.43M| if (buf->freeze_start) { ------------------ | Branch (1139:6): [True: 0, False: 1.43M] ------------------ 1140| 0| result = -1; 1141| 0| goto done; 1142| 0| } 1143| | 1144| 1.43M| if (len >= old_len && !HAS_PINNED_R(buf)) { ------------------ | Branch (1144:6): [True: 391, False: 1.43M] | Branch (1144:24): [True: 391, False: 0] ------------------ 1145| 391| len = old_len; 1146| 782| for (chain = buf->first; chain != NULL; chain = next) { ------------------ | Branch (1146:28): [True: 391, False: 391] ------------------ 1147| 391| next = chain->next; 1148| 391| evbuffer_chain_free(chain); 1149| 391| } 1150| | 1151| 391| ZERO_CHAIN(buf); 1152| 1.43M| } else { 1153| 1.43M| if (len >= old_len) ------------------ | Branch (1153:7): [True: 0, False: 1.43M] ------------------ 1154| 0| len = old_len; 1155| | 1156| 1.43M| buf->total_len -= len; 1157| 1.43M| remaining = len; 1158| 1.43M| for (chain = buf->first; 1159| 1.43M| remaining >= chain->off; ------------------ | Branch (1159:8): [True: 0, False: 1.43M] ------------------ 1160| 1.43M| chain = next) { 1161| 0| next = chain->next; 1162| 0| remaining -= chain->off; 1163| | 1164| 0| if (chain == *buf->last_with_datap) { ------------------ | Branch (1164:8): [True: 0, False: 0] ------------------ 1165| 0| buf->last_with_datap = &buf->first; 1166| 0| } 1167| 0| if (&chain->next == buf->last_with_datap) ------------------ | Branch (1167:8): [True: 0, False: 0] ------------------ 1168| 0| buf->last_with_datap = &buf->first; 1169| | 1170| 0| if (CHAIN_PINNED_R(chain)) { ------------------ | | 128| 0|#define CHAIN_PINNED_R(ch) (((ch)->flags & EVBUFFER_MEM_PINNED_R) != 0) | | ------------------ | | | | 197| 0|#define EVBUFFER_MEM_PINNED_R 0x0010 | | ------------------ | | | Branch (128:29): [True: 0, False: 0] | | ------------------ ------------------ 1171| 0| EVUTIL_ASSERT(remaining == 0); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1172| 0| chain->misalign += chain->off; 1173| 0| chain->off = 0; 1174| 0| break; 1175| 0| } else 1176| 0| evbuffer_chain_free(chain); 1177| 0| } 1178| | 1179| 1.43M| buf->first = chain; 1180| 1.43M| EVUTIL_ASSERT(remaining <= chain->off); ------------------ | | 368| 1.43M|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 1.43M|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 1.43M| (void)sizeof(!(condition)); \ | | | | 98| 1.43M|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 1.43M] | | | | ------------------ | | ------------------ ------------------ 1181| 1.43M| chain->misalign += remaining; 1182| 1.43M| chain->off -= remaining; 1183| 1.43M| } 1184| | 1185| 1.43M| buf->n_del_for_cb += len; 1186| | /* Tell someone about changes in this buffer */ 1187| 1.43M| evbuffer_invoke_callbacks_(buf); 1188| | 1189| 1.43M|done: 1190| 1.43M| EVBUFFER_UNLOCK(buf); ------------------ | | 292| 1.43M| do { \ | | 293| 1.43M| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 1.43M| do { \ | | | | 102| 1.43M| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.43M] | | | | ------------------ | | | | 103| 1.43M| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.43M| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.43M] | | | | ------------------ | | ------------------ | | 294| 1.43M| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 1.43M] | | ------------------ ------------------ 1191| 1.43M| return result; 1192| 1.43M|} evbuffer_remove_buffer: 1288| 855k|{ 1289| | /*XXX We should have an option to force this to be zero-copy.*/ 1290| | 1291| | /*XXX can fail badly on sendfile case. */ 1292| 855k| struct evbuffer_chain *chain, *previous; 1293| 855k| size_t nread = 0; 1294| 855k| int result; 1295| | 1296| 855k| EVBUFFER_LOCK2(src, dst); ------------------ | | 296| 855k| do { \ | | 297| 855k| EVLOCK_LOCK2((buffer1)->lock, (buffer2)->lock, 0, 0); \ | | ------------------ | | | | 351| 855k| do { \ | | | | 352| 855k| void *lock1_tmplock_ = (lock1); \ | | | | 353| 855k| void *lock2_tmplock_ = (lock2); \ | | | | 354| 855k| EVLOCK_SORTLOCKS_(lock1_tmplock_,lock2_tmplock_); \ | | | | ------------------ | | | | | | 340| 855k| do { \ | | | | | | 341| 855k| if (lockvar1 && lockvar2 && lockvar1 > lockvar2) { \ | | | | | | ------------------ | | | | | | | Branch (341:7): [True: 0, False: 855k] | | | | | | | Branch (341:19): [True: 0, False: 0] | | | | | | | Branch (341:31): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 342| 0| void *tmp = lockvar1; \ | | | | | | 343| 0| lockvar1 = lockvar2; \ | | | | | | 344| 0| lockvar2 = tmp; \ | | | | | | 345| 0| } \ | | | | | | 346| 855k| } while (0) | | | | | | ------------------ | | | | | | | Branch (346:11): [Folded, False: 855k] | | | | | | ------------------ | | | | ------------------ | | | | 355| 855k| EVLOCK_LOCK(lock1_tmplock_,mode1); \ | | | | ------------------ | | | | | | 94| 855k| do { \ | | | | | | 95| 855k| if (lockvar) \ | | | | | | ------------------ | | | | | | | Branch (95:7): [True: 0, False: 855k] | | | | | | ------------------ | | | | | | 96| 855k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | | | 97| 855k| } while (0) | | | | | | ------------------ | | | | | | | Branch (97:11): [Folded, False: 855k] | | | | | | ------------------ | | | | ------------------ | | | | 356| 855k| if (lock2_tmplock_ != lock1_tmplock_) \ | | | | ------------------ | | | | | Branch (356:7): [True: 0, False: 855k] | | | | ------------------ | | | | 357| 855k| EVLOCK_LOCK(lock2_tmplock_,mode2); \ | | | | ------------------ | | | | | | 94| 0| do { \ | | | | | | 95| 0| if (lockvar) \ | | | | | | ------------------ | | | | | | | Branch (95:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 96| 0| evthread_lock_fns_.lock(mode, lockvar); \ | | | | | | 97| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (97:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 358| 855k| } while (0) | | | | ------------------ | | | | | Branch (358:11): [Folded, False: 855k] | | | | ------------------ | | ------------------ | | 298| 855k| } while (0) | | ------------------ | | | Branch (298:11): [Folded, False: 855k] | | ------------------ ------------------ 1297| | 1298| 855k| chain = previous = src->first; 1299| | 1300| 855k| if (datlen == 0 || dst == src) { ------------------ | Branch (1300:6): [True: 288k, False: 566k] | Branch (1300:21): [True: 0, False: 566k] ------------------ 1301| 288k| result = 0; 1302| 288k| goto done; 1303| 288k| } 1304| | 1305| 566k| if (dst->freeze_end || src->freeze_start) { ------------------ | Branch (1305:6): [True: 0, False: 566k] | Branch (1305:25): [True: 0, False: 566k] ------------------ 1306| 0| result = -1; 1307| 0| goto done; 1308| 0| } 1309| | 1310| | /* short-cut if there is no more data buffered */ 1311| 566k| if (datlen >= src->total_len) { ------------------ | Branch (1311:6): [True: 76, False: 566k] ------------------ 1312| 76| datlen = src->total_len; 1313| 76| evbuffer_add_buffer(dst, src); 1314| 76| result = (int)datlen; /*XXXX should return ev_ssize_t*/ 1315| 76| goto done; 1316| 76| } 1317| | 1318| | /* removes chains if possible */ 1319| 566k| while (chain->off <= datlen) { ------------------ | Branch (1319:9): [True: 0, False: 566k] ------------------ 1320| | /* We can't remove the last with data from src unless we 1321| | * remove all chains, in which case we would have done the if 1322| | * block above */ 1323| 0| EVUTIL_ASSERT(chain != *src->last_with_datap); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1324| 0| nread += chain->off; 1325| 0| datlen -= chain->off; 1326| 0| previous = chain; 1327| 0| if (src->last_with_datap == &chain->next) ------------------ | Branch (1327:7): [True: 0, False: 0] ------------------ 1328| 0| src->last_with_datap = &src->first; 1329| 0| chain = chain->next; 1330| 0| } 1331| | 1332| 566k| if (chain != src->first) { ------------------ | Branch (1332:6): [True: 0, False: 566k] ------------------ 1333| | /* we can remove the chain */ 1334| 0| struct evbuffer_chain **chp; 1335| 0| chp = evbuffer_free_trailing_empty_chains(dst); 1336| | 1337| 0| if (dst->first == NULL) { ------------------ | Branch (1337:7): [True: 0, False: 0] ------------------ 1338| 0| dst->first = src->first; 1339| 0| } else { 1340| 0| *chp = src->first; 1341| 0| } 1342| 0| dst->last = previous; 1343| 0| previous->next = NULL; 1344| 0| src->first = chain; 1345| 0| advance_last_with_data(dst); 1346| | 1347| 0| dst->total_len += nread; 1348| 0| dst->n_add_for_cb += nread; 1349| 0| } 1350| | 1351| | /* we know that there is more data in the src buffer than 1352| | * we want to read, so we manually drain the chain */ 1353| 566k| evbuffer_add(dst, chain->buffer + chain->misalign, datlen); 1354| 566k| chain->misalign += datlen; 1355| 566k| chain->off -= datlen; 1356| 566k| nread += datlen; 1357| | 1358| | /* You might think we would want to increment dst->n_add_for_cb 1359| | * here too. But evbuffer_add above already took care of that. 1360| | */ 1361| 566k| src->total_len -= nread; 1362| 566k| src->n_del_for_cb += nread; 1363| | 1364| 566k| if (nread) { ------------------ | Branch (1364:6): [True: 566k, False: 0] ------------------ 1365| 566k| evbuffer_invoke_callbacks_(dst); 1366| 566k| evbuffer_invoke_callbacks_(src); 1367| 566k| } 1368| 566k| result = (int)nread;/*XXXX should change return type */ 1369| | 1370| 855k|done: 1371| 855k| EVBUFFER_UNLOCK2(src, dst); ------------------ | | 300| 855k| do { \ | | 301| 855k| EVLOCK_UNLOCK2((buffer1)->lock, (buffer2)->lock, 0, 0); \ | | ------------------ | | | | 361| 855k| do { \ | | | | 362| 855k| void *lock1_tmplock_ = (lock1); \ | | | | 363| 855k| void *lock2_tmplock_ = (lock2); \ | | | | 364| 855k| EVLOCK_SORTLOCKS_(lock1_tmplock_,lock2_tmplock_); \ | | | | ------------------ | | | | | | 340| 855k| do { \ | | | | | | 341| 855k| if (lockvar1 && lockvar2 && lockvar1 > lockvar2) { \ | | | | | | ------------------ | | | | | | | Branch (341:7): [True: 0, False: 855k] | | | | | | | Branch (341:19): [True: 0, False: 0] | | | | | | | Branch (341:31): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 342| 0| void *tmp = lockvar1; \ | | | | | | 343| 0| lockvar1 = lockvar2; \ | | | | | | 344| 0| lockvar2 = tmp; \ | | | | | | 345| 0| } \ | | | | | | 346| 855k| } while (0) | | | | | | ------------------ | | | | | | | Branch (346:11): [Folded, False: 855k] | | | | | | ------------------ | | | | ------------------ | | | | 365| 855k| if (lock2_tmplock_ != lock1_tmplock_) \ | | | | ------------------ | | | | | Branch (365:7): [True: 0, False: 855k] | | | | ------------------ | | | | 366| 855k| EVLOCK_UNLOCK(lock2_tmplock_,mode2); \ | | | | ------------------ | | | | | | 101| 0| do { \ | | | | | | 102| 0| if (lockvar) \ | | | | | | ------------------ | | | | | | | Branch (102:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | | | 104| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (104:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 367| 855k| EVLOCK_UNLOCK(lock1_tmplock_,mode1); \ | | | | ------------------ | | | | | | 101| 855k| do { \ | | | | | | 102| 855k| if (lockvar) \ | | | | | | ------------------ | | | | | | | Branch (102:7): [True: 0, False: 855k] | | | | | | ------------------ | | | | | | 103| 855k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | | | 104| 855k| } while (0) | | | | | | ------------------ | | | | | | | Branch (104:11): [Folded, False: 855k] | | | | | | ------------------ | | | | ------------------ | | | | 368| 855k| } while (0) | | | | ------------------ | | | | | Branch (368:11): [Folded, False: 855k] | | | | ------------------ | | ------------------ | | 302| 855k| } while (0) | | ------------------ | | | Branch (302:11): [Folded, False: 855k] | | ------------------ ------------------ 1372| 855k| return result; 1373| 566k|} evbuffer_pullup: 1377| 2.31M|{ 1378| 2.31M| struct evbuffer_chain *chain, *next, *tmp, *last_with_data; 1379| 2.31M| unsigned char *buffer, *result = NULL; 1380| 2.31M| ev_ssize_t remaining; ------------------ | | 213| 2.31M|#define ev_ssize_t EVENT__ssize_t | | ------------------ | | | | 470| 2.31M|#define EVENT__ssize_t ssize_t | | ------------------ ------------------ 1381| 2.31M| int removed_last_with_data = 0; 1382| 2.31M| int removed_last_with_datap = 0; 1383| | 1384| 2.31M| EVBUFFER_LOCK(buf); ------------------ | | 288| 2.31M| do { \ | | 289| 2.31M| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 2.31M| do { \ | | | | 95| 2.31M| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 2.31M] | | | | ------------------ | | | | 96| 2.31M| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 2.31M| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 2.31M] | | | | ------------------ | | ------------------ | | 290| 2.31M| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 2.31M] | | ------------------ ------------------ 1385| | 1386| 2.31M| chain = buf->first; 1387| | 1388| 2.31M| if (size < 0) ------------------ | Branch (1388:6): [True: 1.17M, False: 1.14M] ------------------ 1389| 1.17M| size = buf->total_len; 1390| | /* if size > buf->total_len, we cannot guarantee to the user that she 1391| | * is going to have a long enough buffer afterwards; so we return 1392| | * NULL */ 1393| 2.31M| if (size == 0 || (size_t)size > buf->total_len) ------------------ | Branch (1393:6): [True: 15.8k, False: 2.30M] | Branch (1393:19): [True: 0, False: 2.30M] ------------------ 1394| 15.8k| goto done; 1395| | 1396| | /* No need to pull up anything; the first size bytes are 1397| | * already here. */ 1398| 2.30M| if (chain->off >= (size_t)size) { ------------------ | Branch (1398:6): [True: 2.29M, False: 2.13k] ------------------ 1399| 2.29M| result = chain->buffer + chain->misalign; 1400| 2.29M| goto done; 1401| 2.29M| } 1402| | 1403| | /* Make sure that none of the chains we need to copy from is pinned. */ 1404| 2.13k| remaining = size - chain->off; 1405| 2.13k| EVUTIL_ASSERT(remaining >= 0); ------------------ | | 368| 2.13k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 2.13k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 2.13k| (void)sizeof(!(condition)); \ | | | | 98| 2.13k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 2.13k] | | | | ------------------ | | ------------------ ------------------ 1406| 3.82k| for (tmp=chain->next; tmp; tmp=tmp->next) { ------------------ | Branch (1406:24): [True: 3.82k, False: 0] ------------------ 1407| 3.82k| if (CHAIN_PINNED(tmp)) ------------------ | | 127| 3.82k|#define CHAIN_PINNED(ch) (((ch)->flags & EVBUFFER_MEM_PINNED_ANY) != 0) | | ------------------ | | | | 199| 3.82k|#define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 197| 3.82k|#define EVBUFFER_MEM_PINNED_R 0x0010 | | | | ------------------ | | | | #define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 198| 3.82k|#define EVBUFFER_MEM_PINNED_W 0x0020 | | | | ------------------ | | ------------------ | | | Branch (127:27): [True: 0, False: 3.82k] | | ------------------ ------------------ 1408| 0| goto done; 1409| 3.82k| if (tmp->off >= (size_t)remaining) ------------------ | Branch (1409:7): [True: 2.13k, False: 1.68k] ------------------ 1410| 2.13k| break; 1411| 1.68k| remaining -= tmp->off; 1412| 1.68k| } 1413| | 1414| 2.13k| if (CHAIN_PINNED(chain)) { ------------------ | | 127| 2.13k|#define CHAIN_PINNED(ch) (((ch)->flags & EVBUFFER_MEM_PINNED_ANY) != 0) | | ------------------ | | | | 199| 2.13k|#define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 197| 2.13k|#define EVBUFFER_MEM_PINNED_R 0x0010 | | | | ------------------ | | | | #define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 198| 2.13k|#define EVBUFFER_MEM_PINNED_W 0x0020 | | | | ------------------ | | ------------------ | | | Branch (127:27): [True: 0, False: 2.13k] | | ------------------ ------------------ 1415| 0| size_t old_off = chain->off; 1416| 0| if (CHAIN_SPACE_LEN(chain) < size - chain->off) { ------------------ | | 124| 0|#define CHAIN_SPACE_LEN(ch) ((ch)->flags & EVBUFFER_IMMUTABLE ? \ | | ------------------ | | | | 194| 0|#define EVBUFFER_IMMUTABLE 0x0008 /**< read-only chain */ | | ------------------ | | | Branch (124:30): [True: 0, False: 0] | | ------------------ | | 125| 0| 0 : (ch)->buffer_len - ((ch)->misalign + (ch)->off)) ------------------ | Branch (1416:7): [True: 0, False: 0] ------------------ 1417| | /* not enough room at end of chunk. */ 1418| 0| goto done; 1419| 0| } 1420| 0| buffer = CHAIN_SPACE_PTR(chain); ------------------ | | 123| 0|#define CHAIN_SPACE_PTR(ch) ((ch)->buffer + (ch)->misalign + (ch)->off) ------------------ 1421| 0| tmp = chain; 1422| 0| tmp->off = size; 1423| 0| size -= old_off; 1424| 0| chain = chain->next; 1425| 2.13k| } else if (chain->buffer_len - chain->misalign >= (size_t)size) { ------------------ | Branch (1425:13): [True: 0, False: 2.13k] ------------------ 1426| | /* already have enough space in the first chain */ 1427| 0| size_t old_off = chain->off; 1428| 0| buffer = chain->buffer + chain->misalign + chain->off; 1429| 0| tmp = chain; 1430| 0| tmp->off = size; 1431| 0| size -= old_off; 1432| 0| chain = chain->next; 1433| 2.13k| } else { 1434| 2.13k| if ((tmp = evbuffer_chain_new_membuf(size)) == NULL) { ------------------ | Branch (1434:7): [True: 0, False: 2.13k] ------------------ 1435| 0| event_warn("%s: out of memory", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 1436| 0| goto done; 1437| 0| } 1438| 2.13k| buffer = tmp->buffer; 1439| 2.13k| tmp->off = size; 1440| 2.13k| buf->first = tmp; 1441| 2.13k| } 1442| | 1443| | /* TODO(niels): deal with buffers that point to NULL like sendfile */ 1444| | 1445| | /* Copy and free every chunk that will be entirely pulled into tmp */ 1446| 2.13k| last_with_data = *buf->last_with_datap; 1447| 8.09k| for (; chain != NULL && (size_t)size >= chain->off; chain = next) { ------------------ | Branch (1447:9): [True: 5.95k, False: 2.13k] | Branch (1447:26): [True: 5.95k, False: 0] ------------------ 1448| 5.95k| next = chain->next; 1449| | 1450| 5.95k| if (chain->buffer) { ------------------ | Branch (1450:7): [True: 5.95k, False: 0] ------------------ 1451| 5.95k| memcpy(buffer, chain->buffer + chain->misalign, chain->off); 1452| 5.95k| size -= chain->off; 1453| 5.95k| buffer += chain->off; 1454| 5.95k| } 1455| 5.95k| if (chain == last_with_data) ------------------ | Branch (1455:7): [True: 2.13k, False: 3.82k] ------------------ 1456| 2.13k| removed_last_with_data = 1; 1457| 5.95k| if (&chain->next == buf->last_with_datap) ------------------ | Branch (1457:7): [True: 2.13k, False: 3.82k] ------------------ 1458| 2.13k| removed_last_with_datap = 1; 1459| | 1460| 5.95k| evbuffer_chain_free(chain); 1461| 5.95k| } 1462| | 1463| 2.13k| if (chain != NULL) { ------------------ | Branch (1463:6): [True: 0, False: 2.13k] ------------------ 1464| 0| memcpy(buffer, chain->buffer + chain->misalign, size); 1465| 0| chain->misalign += size; 1466| 0| chain->off -= size; 1467| 2.13k| } else { 1468| 2.13k| buf->last = tmp; 1469| 2.13k| } 1470| | 1471| 2.13k| tmp->next = chain; 1472| | 1473| 2.13k| if (removed_last_with_data) { ------------------ | Branch (1473:6): [True: 2.13k, False: 0] ------------------ 1474| 2.13k| buf->last_with_datap = &buf->first; 1475| 2.13k| } else if (removed_last_with_datap) { ------------------ | Branch (1475:13): [True: 0, False: 0] ------------------ 1476| 0| if (buf->first->next && buf->first->next->off) ------------------ | Branch (1476:7): [True: 0, False: 0] | Branch (1476:27): [True: 0, False: 0] ------------------ 1477| 0| buf->last_with_datap = &buf->first->next; 1478| 0| else 1479| 0| buf->last_with_datap = &buf->first; 1480| 0| } 1481| | 1482| 2.13k| result = (tmp->buffer + tmp->misalign); 1483| | 1484| 2.31M|done: 1485| 2.31M| EVBUFFER_UNLOCK(buf); ------------------ | | 292| 2.31M| do { \ | | 293| 2.31M| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 2.31M| do { \ | | | | 102| 2.31M| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 2.31M] | | | | ------------------ | | | | 103| 2.31M| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 2.31M| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 2.31M] | | | | ------------------ | | ------------------ | | 294| 2.31M| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 2.31M] | | ------------------ ------------------ 1486| 2.31M| return result; 1487| 2.13k|} evbuffer_add: 1757| 593k|{ 1758| 593k| struct evbuffer_chain *chain, *tmp; 1759| 593k| const unsigned char *data = data_in; 1760| 593k| size_t remain, to_alloc; 1761| 593k| int result = -1; 1762| | 1763| 593k| EVBUFFER_LOCK(buf); ------------------ | | 288| 593k| do { \ | | 289| 593k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 593k| do { \ | | | | 95| 593k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 593k] | | | | ------------------ | | | | 96| 593k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 593k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 593k] | | | | ------------------ | | ------------------ | | 290| 593k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 593k] | | ------------------ ------------------ 1764| | 1765| 593k| if (buf->freeze_end) { ------------------ | Branch (1765:6): [True: 0, False: 593k] ------------------ 1766| 0| goto done; 1767| 0| } 1768| | /* Prevent buf->total_len overflow */ 1769| 593k| if (datlen > EV_SIZE_MAX - buf->total_len) { ------------------ | | 289| 593k|#define EV_SIZE_MAX EV_UINT64_MAX | | ------------------ | | | | 267| 593k|#define EV_UINT64_MAX UINT64_MAX | | ------------------ ------------------ | Branch (1769:6): [True: 0, False: 593k] ------------------ 1770| 0| goto done; 1771| 0| } 1772| | 1773| 593k| if (*buf->last_with_datap == NULL) { ------------------ | Branch (1773:6): [True: 26.2k, False: 567k] ------------------ 1774| 26.2k| chain = buf->last; 1775| 567k| } else { 1776| 567k| chain = *buf->last_with_datap; 1777| 567k| } 1778| | 1779| | /* If there are no chains allocated for this buffer, allocate one 1780| | * big enough to hold all the data. */ 1781| 593k| if (chain == NULL) { ------------------ | Branch (1781:6): [True: 26.2k, False: 567k] ------------------ 1782| 26.2k| chain = evbuffer_chain_insert_new(buf, datlen); 1783| 26.2k| if (!chain) ------------------ | Branch (1783:7): [True: 0, False: 26.2k] ------------------ 1784| 0| goto done; 1785| 26.2k| } 1786| | 1787| 593k| if ((chain->flags & EVBUFFER_IMMUTABLE) == 0) { ------------------ | | 194| 593k|#define EVBUFFER_IMMUTABLE 0x0008 /**< read-only chain */ ------------------ | Branch (1787:6): [True: 593k, False: 0] ------------------ 1788| | /* Always true for mutable buffers */ 1789| 593k| EVUTIL_ASSERT(chain->misalign >= 0 && ------------------ | | 368| 593k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 593k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 593k| (void)sizeof(!(condition)); \ | | | | ------------------ | | | | | Branch (97:17): [True: 0, False: 593k] | | | | | Branch (97:17): [True: 0, False: 0] | | | | ------------------ | | | | 98| 593k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 593k] | | | | ------------------ | | ------------------ ------------------ 1790| 593k| (ev_uint64_t)chain->misalign <= EVBUFFER_CHAIN_MAX); 1791| 593k| remain = chain->buffer_len - (size_t)chain->misalign - chain->off; 1792| 593k| if (remain >= datlen) { ------------------ | Branch (1792:7): [True: 587k, False: 5.97k] ------------------ 1793| | /* there's enough space to hold all the data in the 1794| | * current last chain */ 1795| 587k| memcpy(chain->buffer + chain->misalign + chain->off, 1796| 587k| data, datlen); 1797| 587k| chain->off += datlen; 1798| 587k| buf->total_len += datlen; 1799| 587k| buf->n_add_for_cb += datlen; 1800| 587k| goto out; 1801| 587k| } else if (!CHAIN_PINNED(chain) && ------------------ | | 127| 11.9k|#define CHAIN_PINNED(ch) (((ch)->flags & EVBUFFER_MEM_PINNED_ANY) != 0) | | ------------------ | | | | 199| 5.97k|#define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 197| 5.97k|#define EVBUFFER_MEM_PINNED_R 0x0010 | | | | ------------------ | | | | #define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 198| 5.97k|#define EVBUFFER_MEM_PINNED_W 0x0020 | | | | ------------------ | | ------------------ ------------------ | Branch (1801:14): [True: 5.97k, False: 0] ------------------ 1802| 5.97k| evbuffer_chain_should_realign(chain, datlen)) { ------------------ | Branch (1802:7): [True: 0, False: 5.97k] ------------------ 1803| | /* we can fit the data into the misalignment */ 1804| 0| evbuffer_chain_align(chain); 1805| | 1806| 0| memcpy(chain->buffer + chain->off, data, datlen); 1807| 0| chain->off += datlen; 1808| 0| buf->total_len += datlen; 1809| 0| buf->n_add_for_cb += datlen; 1810| 0| goto out; 1811| 0| } 1812| 593k| } else { 1813| | /* we cannot write any data to the last chain */ 1814| 0| remain = 0; 1815| 0| } 1816| | 1817| | /* we need to add another chain */ 1818| 5.97k| to_alloc = chain->buffer_len; 1819| 5.97k| if (to_alloc <= EVBUFFER_CHAIN_MAX_AUTO_SIZE/2) ------------------ | | 1751| 5.97k|#define EVBUFFER_CHAIN_MAX_AUTO_SIZE 4096 ------------------ | Branch (1819:6): [True: 2.61k, False: 3.36k] ------------------ 1820| 2.61k| to_alloc <<= 1; 1821| 5.97k| if (datlen > to_alloc) ------------------ | Branch (1821:6): [True: 661, False: 5.31k] ------------------ 1822| 661| to_alloc = datlen; 1823| 5.97k| tmp = evbuffer_chain_new_membuf(to_alloc); 1824| 5.97k| if (tmp == NULL) ------------------ | Branch (1824:6): [True: 0, False: 5.97k] ------------------ 1825| 0| goto done; 1826| | 1827| 5.97k| if (remain) { ------------------ | Branch (1827:6): [True: 5.67k, False: 307] ------------------ 1828| 5.67k| memcpy(chain->buffer + chain->misalign + chain->off, 1829| 5.67k| data, remain); 1830| 5.67k| chain->off += remain; 1831| 5.67k| buf->total_len += remain; 1832| 5.67k| buf->n_add_for_cb += remain; 1833| 5.67k| } 1834| | 1835| 5.97k| data += remain; 1836| 5.97k| datlen -= remain; 1837| | 1838| 5.97k| memcpy(tmp->buffer, data, datlen); 1839| 5.97k| tmp->off = datlen; 1840| 5.97k| evbuffer_chain_insert(buf, tmp); 1841| 5.97k| buf->n_add_for_cb += datlen; 1842| | 1843| 593k|out: 1844| 593k| evbuffer_invoke_callbacks_(buf); 1845| 593k| result = 0; 1846| 593k|done: 1847| 593k| EVBUFFER_UNLOCK(buf); ------------------ | | 292| 593k| do { \ | | 293| 593k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 593k| do { \ | | | | 102| 593k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 593k] | | | | ------------------ | | | | 103| 593k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 593k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 593k] | | | | ------------------ | | ------------------ | | 294| 593k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 593k] | | ------------------ ------------------ 1848| 593k| return result; 1849| 593k|} evbuffer_add_vprintf: 2873| 3.80k|{ 2874| 3.80k| char *buffer; 2875| 3.80k| size_t space; 2876| 3.80k| int sz, result = -1; 2877| 3.80k| va_list aq; 2878| 3.80k| struct evbuffer_chain *chain; 2879| | 2880| | 2881| 3.80k| EVBUFFER_LOCK(buf); ------------------ | | 288| 3.80k| do { \ | | 289| 3.80k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 3.80k| do { \ | | | | 95| 3.80k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 3.80k] | | | | ------------------ | | | | 96| 3.80k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 3.80k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 3.80k] | | | | ------------------ | | ------------------ | | 290| 3.80k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 3.80k] | | ------------------ ------------------ 2882| | 2883| 3.80k| if (buf->freeze_end) { ------------------ | Branch (2883:6): [True: 0, False: 3.80k] ------------------ 2884| 0| goto done; 2885| 0| } 2886| | 2887| | /* make sure that at least some space is available */ 2888| 3.80k| if ((chain = evbuffer_expand_singlechain(buf, 64)) == NULL) ------------------ | Branch (2888:6): [True: 0, False: 3.80k] ------------------ 2889| 0| goto done; 2890| | 2891| 3.80k| for (;;) { 2892| |#if 0 2893| | size_t used = chain->misalign + chain->off; 2894| | buffer = (char *)chain->buffer + chain->misalign + chain->off; 2895| | EVUTIL_ASSERT(chain->buffer_len >= used); 2896| | space = chain->buffer_len - used; 2897| |#endif 2898| 3.80k| buffer = (char*) CHAIN_SPACE_PTR(chain); ------------------ | | 123| 3.80k|#define CHAIN_SPACE_PTR(ch) ((ch)->buffer + (ch)->misalign + (ch)->off) ------------------ 2899| 3.80k| space = (size_t) CHAIN_SPACE_LEN(chain); ------------------ | | 124| 3.80k|#define CHAIN_SPACE_LEN(ch) ((ch)->flags & EVBUFFER_IMMUTABLE ? \ | | ------------------ | | | | 194| 3.80k|#define EVBUFFER_IMMUTABLE 0x0008 /**< read-only chain */ | | ------------------ | | | Branch (124:30): [True: 0, False: 3.80k] | | ------------------ | | 125| 3.80k| 0 : (ch)->buffer_len - ((ch)->misalign + (ch)->off)) ------------------ 2900| | 2901| |#ifndef va_copy 2902| |#define va_copy(dst, src) memcpy(&(dst), &(src), sizeof(va_list)) 2903| |#endif 2904| 3.80k| va_copy(aq, ap); 2905| | 2906| 3.80k| sz = evutil_vsnprintf(buffer, space, fmt, aq); 2907| | 2908| 3.80k| va_end(aq); 2909| | 2910| 3.80k| if (sz < 0) ------------------ | Branch (2910:7): [True: 0, False: 3.80k] ------------------ 2911| 0| goto done; 2912| 3.80k| if (INT_MAX >= EVBUFFER_CHAIN_MAX && ------------------ | | 168| 7.61k|#define EVBUFFER_CHAIN_MAX ((size_t)EV_SSIZE_MAX) | | ------------------ | | | | 290| 3.80k|#define EV_SSIZE_MAX EV_INT64_MAX | | | | ------------------ | | | | | | 268| 3.80k|#define EV_INT64_MAX INT64_MAX | | | | ------------------ | | ------------------ ------------------ | Branch (2912:7): [Folded, False: 3.80k] ------------------ 2913| 0| (size_t)sz >= EVBUFFER_CHAIN_MAX) ------------------ | | 168| 3.80k|#define EVBUFFER_CHAIN_MAX ((size_t)EV_SSIZE_MAX) | | ------------------ | | | | 290| 0|#define EV_SSIZE_MAX EV_INT64_MAX | | | | ------------------ | | | | | | 268| 0|#define EV_INT64_MAX INT64_MAX | | | | ------------------ | | ------------------ ------------------ | Branch (2913:7): [True: 0, False: 0] ------------------ 2914| 0| goto done; 2915| 3.80k| if ((size_t)sz < space) { ------------------ | Branch (2915:7): [True: 3.80k, False: 0] ------------------ 2916| 3.80k| chain->off += sz; 2917| 3.80k| buf->total_len += sz; 2918| 3.80k| buf->n_add_for_cb += sz; 2919| | 2920| 3.80k| advance_last_with_data(buf); 2921| 3.80k| evbuffer_invoke_callbacks_(buf); 2922| 3.80k| result = sz; 2923| 3.80k| goto done; 2924| 3.80k| } 2925| 0| if ((chain = evbuffer_expand_singlechain(buf, sz + 1)) == NULL) ------------------ | Branch (2925:7): [True: 0, False: 0] ------------------ 2926| 0| goto done; 2927| 0| } 2928| | /* NOTREACHED */ 2929| | 2930| 3.80k|done: 2931| 3.80k| EVBUFFER_UNLOCK(buf); ------------------ | | 292| 3.80k| do { \ | | 293| 3.80k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 3.80k| do { \ | | | | 102| 3.80k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 3.80k] | | | | ------------------ | | | | 103| 3.80k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 3.80k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 3.80k] | | | | ------------------ | | ------------------ | | 294| 3.80k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 3.80k] | | ------------------ ------------------ 2932| 3.80k| return result; 2933| 3.80k|} evbuffer_add_printf: 2937| 3.80k|{ 2938| 3.80k| int res = -1; 2939| 3.80k| va_list ap; 2940| | 2941| 3.80k| va_start(ap, fmt); 2942| 3.80k| res = evbuffer_add_vprintf(buf, fmt, ap); 2943| 3.80k| va_end(ap); 2944| | 2945| 3.80k| return (res); 2946| 3.80k|} evbuffer_add_cb: 3387| 1.90k|{ 3388| 1.90k| struct evbuffer_cb_entry *e; 3389| 1.90k| if (! (e = mm_calloc(1, sizeof(struct evbuffer_cb_entry)))) ------------------ | | 77| 1.90k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ | Branch (3389:6): [True: 0, False: 1.90k] ------------------ 3390| 0| return NULL; 3391| 1.90k| EVBUFFER_LOCK(buffer); ------------------ | | 288| 1.90k| do { \ | | 289| 1.90k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 1.90k| do { \ | | | | 95| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 96| 1.90k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 290| 1.90k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 1.90k] | | ------------------ ------------------ 3392| 1.90k| e->cb.cb_func = cb; 3393| 1.90k| e->cbarg = cbarg; 3394| 1.90k| e->flags = EVBUFFER_CB_ENABLED; ------------------ | | 982| 1.90k|#define EVBUFFER_CB_ENABLED 1 ------------------ 3395| 1.90k| LIST_INSERT_HEAD(&buffer->callbacks, e, next); ------------------ | | 189| 1.90k|#define LIST_INSERT_HEAD(head, elm, field) do { \ | | 190| 1.90k| if (((elm)->field.le_next = (head)->lh_first) != NULL) \ | | ------------------ | | | Branch (190:6): [True: 0, False: 1.90k] | | ------------------ | | 191| 1.90k| (head)->lh_first->field.le_prev = &(elm)->field.le_next;\ | | 192| 1.90k| (head)->lh_first = (elm); \ | | 193| 1.90k| (elm)->field.le_prev = &(head)->lh_first; \ | | 194| 1.90k|} while (0) | | ------------------ | | | Branch (194:10): [Folded, False: 1.90k] | | ------------------ ------------------ 3396| 1.90k| EVBUFFER_UNLOCK(buffer); ------------------ | | 292| 1.90k| do { \ | | 293| 1.90k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 1.90k| do { \ | | | | 102| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 103| 1.90k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 294| 1.90k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 1.90k] | | ------------------ ------------------ 3397| 1.90k| return e; 3398| 1.90k|} evbuffer_freeze: 3454| 5.71k|{ 3455| 5.71k| EVBUFFER_LOCK(buffer); ------------------ | | 288| 5.71k| do { \ | | 289| 5.71k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 5.71k| do { \ | | | | 95| 5.71k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 5.71k] | | | | ------------------ | | | | 96| 5.71k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 5.71k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 5.71k] | | | | ------------------ | | ------------------ | | 290| 5.71k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 5.71k] | | ------------------ ------------------ 3456| 5.71k| if (start) ------------------ | Branch (3456:6): [True: 2.85k, False: 2.85k] ------------------ 3457| 2.85k| buffer->freeze_start = 1; 3458| 2.85k| else 3459| 2.85k| buffer->freeze_end = 1; 3460| 5.71k| EVBUFFER_UNLOCK(buffer); ------------------ | | 292| 5.71k| do { \ | | 293| 5.71k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 5.71k| do { \ | | | | 102| 5.71k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 5.71k] | | | | ------------------ | | | | 103| 5.71k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 5.71k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 5.71k] | | | | ------------------ | | ------------------ | | 294| 5.71k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 5.71k] | | ------------------ ------------------ 3461| 5.71k| return 0; 3462| 5.71k|} evbuffer_unfreeze: 3466| 1.90k|{ 3467| 1.90k| EVBUFFER_LOCK(buffer); ------------------ | | 288| 1.90k| do { \ | | 289| 1.90k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 1.90k| do { \ | | | | 95| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 96| 1.90k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 290| 1.90k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 1.90k] | | ------------------ ------------------ 3468| 1.90k| if (start) ------------------ | Branch (3468:6): [True: 952, False: 952] ------------------ 3469| 952| buffer->freeze_start = 0; 3470| 952| else 3471| 952| buffer->freeze_end = 0; 3472| 1.90k| EVBUFFER_UNLOCK(buffer); ------------------ | | 292| 1.90k| do { \ | | 293| 1.90k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 1.90k| do { \ | | | | 102| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 103| 1.90k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 294| 1.90k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 1.90k] | | ------------------ ------------------ 3473| 1.90k| return 0; 3474| 1.90k|} evbuffer_get_callbacks_: 3505| 3.80k|{ 3506| 3.80k| int r = 0; 3507| 3.80k| EVBUFFER_LOCK(buffer); ------------------ | | 288| 3.80k| do { \ | | 289| 3.80k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 3.80k| do { \ | | | | 95| 3.80k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 3.80k] | | | | ------------------ | | | | 96| 3.80k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 3.80k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 3.80k] | | | | ------------------ | | ------------------ | | 290| 3.80k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 3.80k] | | ------------------ ------------------ 3508| 3.80k| if (buffer->deferred_cbs) { ------------------ | Branch (3508:6): [True: 0, False: 3.80k] ------------------ 3509| 0| if (max_cbs < 1) { ------------------ | Branch (3509:7): [True: 0, False: 0] ------------------ 3510| 0| r = -1; 3511| 0| goto done; 3512| 0| } 3513| 0| cbs[0] = &buffer->deferred; 3514| 0| r = 1; 3515| 0| } 3516| 3.80k|done: 3517| 3.80k| EVBUFFER_UNLOCK(buffer); ------------------ | | 292| 3.80k| do { \ | | 293| 3.80k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 3.80k| do { \ | | | | 102| 3.80k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 3.80k] | | | | ------------------ | | | | 103| 3.80k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 3.80k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 3.80k] | | | | ------------------ | | ------------------ | | 294| 3.80k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 3.80k] | | ------------------ ------------------ 3518| 3.80k| return r; 3519| 3.80k|} buffer.c:evbuffer_chain_free: 206| 35.3k|{ 207| 35.3k| EVUTIL_ASSERT(chain->refcnt > 0); ------------------ | | 368| 35.3k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 35.3k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 35.3k| (void)sizeof(!(condition)); \ | | | | 98| 35.3k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 35.3k] | | | | ------------------ | | ------------------ ------------------ 208| 35.3k| if (--chain->refcnt > 0) { ------------------ | Branch (208:6): [True: 0, False: 35.3k] ------------------ 209| | /* chain is still referenced by other chains */ 210| 0| return; 211| 0| } 212| | 213| 35.3k| if (CHAIN_PINNED(chain)) { ------------------ | | 127| 35.3k|#define CHAIN_PINNED(ch) (((ch)->flags & EVBUFFER_MEM_PINNED_ANY) != 0) | | ------------------ | | | | 199| 35.3k|#define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 197| 35.3k|#define EVBUFFER_MEM_PINNED_R 0x0010 | | | | ------------------ | | | | #define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 198| 35.3k|#define EVBUFFER_MEM_PINNED_W 0x0020 | | | | ------------------ | | ------------------ | | | Branch (127:27): [True: 0, False: 35.3k] | | ------------------ ------------------ 214| | /* will get freed once no longer dangling */ 215| 0| chain->refcnt++; 216| 0| chain->flags |= EVBUFFER_DANGLING; ------------------ | | 202| 0|#define EVBUFFER_DANGLING 0x0040 ------------------ 217| 0| return; 218| 0| } 219| | 220| | /* safe to release chain, it's either a referencing 221| | * chain or all references to it have been freed */ 222| 35.3k| if (chain->flags & EVBUFFER_REFERENCE) { ------------------ | | 193| 35.3k|#define EVBUFFER_REFERENCE 0x0004 /**< a chain with a mem reference */ ------------------ | Branch (222:6): [True: 0, False: 35.3k] ------------------ 223| 0| struct evbuffer_chain_reference *info = 224| 0| EVBUFFER_CHAIN_EXTRA( ------------------ | | 281| 0|#define EVBUFFER_CHAIN_EXTRA(t, c) (t *)((struct evbuffer_chain *)(c) + 1) ------------------ 225| 0| struct evbuffer_chain_reference, 226| 0| chain); 227| 0| if (info->cleanupfn) ------------------ | Branch (227:7): [True: 0, False: 0] ------------------ 228| 0| (*info->cleanupfn)(chain->buffer, 229| 0| chain->buffer_len, 230| 0| info->extra); 231| 0| } 232| 35.3k| if (chain->flags & EVBUFFER_FILESEGMENT) { ------------------ | | 191| 35.3k|#define EVBUFFER_FILESEGMENT 0x0001 /**< A chain used for a file segment */ ------------------ | Branch (232:6): [True: 0, False: 35.3k] ------------------ 233| 0| struct evbuffer_chain_file_segment *info = 234| 0| EVBUFFER_CHAIN_EXTRA( ------------------ | | 281| 0|#define EVBUFFER_CHAIN_EXTRA(t, c) (t *)((struct evbuffer_chain *)(c) + 1) ------------------ 235| 0| struct evbuffer_chain_file_segment, 236| 0| chain); 237| 0| if (info->segment) { ------------------ | Branch (237:7): [True: 0, False: 0] ------------------ 238| |#ifdef _WIN32 239| | if (info->segment->is_mapping) 240| | UnmapViewOfFile(chain->buffer); 241| |#endif 242| 0| evbuffer_file_segment_free(info->segment); 243| 0| } 244| 0| } 245| 35.3k| if (chain->flags & EVBUFFER_MULTICAST) { ------------------ | | 204| 35.3k|#define EVBUFFER_MULTICAST 0x0080 ------------------ | Branch (245:6): [True: 0, False: 35.3k] ------------------ 246| 0| struct evbuffer_multicast_parent *info = 247| 0| EVBUFFER_CHAIN_EXTRA( ------------------ | | 281| 0|#define EVBUFFER_CHAIN_EXTRA(t, c) (t *)((struct evbuffer_chain *)(c) + 1) ------------------ 248| 0| struct evbuffer_multicast_parent, 249| 0| chain); 250| | /* referencing chain is being freed, decrease 251| | * refcounts of source chain and associated 252| | * evbuffer (which get freed once both reach 253| | * zero) */ 254| 0| EVUTIL_ASSERT(info->source != NULL); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 255| 0| EVUTIL_ASSERT(info->parent != NULL); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 256| 0| EVBUFFER_LOCK(info->source); ------------------ | | 288| 0| do { \ | | 289| 0| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 0| do { \ | | | | 95| 0| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 0] | | | | ------------------ | | | | 96| 0| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 0| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 290| 0| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 0] | | ------------------ ------------------ 257| 0| evbuffer_chain_free(info->parent); 258| 0| evbuffer_decref_and_unlock_(info->source); 259| 0| } 260| | 261| 35.3k| mm_free(chain); ------------------ | | 80| 35.3k|#define mm_free(p) event_mm_free_(p) ------------------ 262| 35.3k|} buffer.c:evbuffer_run_callbacks: 467| 7.27k|{ 468| 7.27k| struct evbuffer_cb_entry *cbent, *next; 469| 7.27k| struct evbuffer_cb_info info; 470| 7.27k| size_t new_size; 471| 7.27k| ev_uint32_t mask, masked_val; ------------------ | | 148| 7.27k|#define ev_uint32_t uint32_t ------------------ 472| 7.27k| int clear = 1; 473| | 474| 7.27k| if (running_deferred) { ------------------ | Branch (474:6): [True: 0, False: 7.27k] ------------------ 475| 0| mask = EVBUFFER_CB_NODEFER|EVBUFFER_CB_ENABLED; ------------------ | | 44| 0|#define EVBUFFER_CB_NODEFER 2 ------------------ mask = EVBUFFER_CB_NODEFER|EVBUFFER_CB_ENABLED; ------------------ | | 982| 0|#define EVBUFFER_CB_ENABLED 1 ------------------ 476| 0| masked_val = EVBUFFER_CB_ENABLED; ------------------ | | 982| 0|#define EVBUFFER_CB_ENABLED 1 ------------------ 477| 7.27k| } else if (buffer->deferred_cbs) { ------------------ | Branch (477:13): [True: 0, False: 7.27k] ------------------ 478| 0| mask = EVBUFFER_CB_NODEFER|EVBUFFER_CB_ENABLED; ------------------ | | 44| 0|#define EVBUFFER_CB_NODEFER 2 ------------------ mask = EVBUFFER_CB_NODEFER|EVBUFFER_CB_ENABLED; ------------------ | | 982| 0|#define EVBUFFER_CB_ENABLED 1 ------------------ 479| 0| masked_val = EVBUFFER_CB_NODEFER|EVBUFFER_CB_ENABLED; ------------------ | | 44| 0|#define EVBUFFER_CB_NODEFER 2 ------------------ masked_val = EVBUFFER_CB_NODEFER|EVBUFFER_CB_ENABLED; ------------------ | | 982| 0|#define EVBUFFER_CB_ENABLED 1 ------------------ 480| | /* Don't zero-out n_add/n_del, since the deferred callbacks 481| | will want to see them. */ 482| 0| clear = 0; 483| 7.27k| } else { 484| 7.27k| mask = EVBUFFER_CB_ENABLED; ------------------ | | 982| 7.27k|#define EVBUFFER_CB_ENABLED 1 ------------------ 485| 7.27k| masked_val = EVBUFFER_CB_ENABLED; ------------------ | | 982| 7.27k|#define EVBUFFER_CB_ENABLED 1 ------------------ 486| 7.27k| } 487| | 488| 7.27k| ASSERT_EVBUFFER_LOCKED(buffer); ------------------ | | 285| 7.27k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 7.27k| do { \ | | | | 131| 7.27k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 7.27k] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 7.27k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 7.27k] | | | | ------------------ | | ------------------ ------------------ 489| | 490| 7.27k| if (LIST_EMPTY(&buffer->callbacks)) { ------------------ | | 159| 7.27k|#define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head)) | | ------------------ | | | | 157| 7.27k|#define LIST_FIRST(head) ((head)->lh_first) | | ------------------ | | #define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head)) | | ------------------ | | | | 158| 7.27k|#define LIST_END(head) NULL | | ------------------ | | | Branch (159:27): [True: 0, False: 7.27k] | | ------------------ ------------------ 491| 0| buffer->n_add_for_cb = buffer->n_del_for_cb = 0; 492| 0| return; 493| 0| } 494| 7.27k| if (buffer->n_add_for_cb == 0 && buffer->n_del_for_cb == 0) ------------------ | Branch (494:6): [True: 952, False: 6.31k] | Branch (494:35): [True: 0, False: 952] ------------------ 495| 0| return; 496| | 497| 7.27k| new_size = buffer->total_len; 498| 7.27k| info.orig_size = new_size + buffer->n_del_for_cb - buffer->n_add_for_cb; 499| 7.27k| info.n_added = buffer->n_add_for_cb; 500| 7.27k| info.n_deleted = buffer->n_del_for_cb; 501| 7.27k| if (clear) { ------------------ | Branch (501:6): [True: 7.27k, False: 0] ------------------ 502| 7.27k| buffer->n_add_for_cb = 0; 503| 7.27k| buffer->n_del_for_cb = 0; 504| 7.27k| } 505| 7.27k| for (cbent = LIST_FIRST(&buffer->callbacks); ------------------ | | 157| 7.27k|#define LIST_FIRST(head) ((head)->lh_first) ------------------ 506| 14.5k| cbent != LIST_END(&buffer->callbacks); ------------------ | | 158| 14.5k|#define LIST_END(head) NULL ------------------ | Branch (506:7): [True: 7.27k, False: 7.27k] ------------------ 507| 7.27k| cbent = next) { 508| | /* Get the 'next' pointer now in case this callback decides 509| | * to remove itself or something. */ 510| 7.27k| next = LIST_NEXT(cbent, next); ------------------ | | 160| 7.27k|#define LIST_NEXT(elm, field) ((elm)->field.le_next) ------------------ 511| | 512| 7.27k| if ((cbent->flags & mask) != masked_val) ------------------ | Branch (512:7): [True: 0, False: 7.27k] ------------------ 513| 0| continue; 514| | 515| 7.27k| if ((cbent->flags & EVBUFFER_CB_OBSOLETE)) ------------------ | | 120| 7.27k|#define EVBUFFER_CB_OBSOLETE 0x00040000 ------------------ | Branch (515:7): [True: 0, False: 7.27k] ------------------ 516| 0| cbent->cb.cb_obsolete(buffer, 517| 0| info.orig_size, new_size, cbent->cbarg); 518| 7.27k| else 519| 7.27k| cbent->cb.cb_func(buffer, &info, cbent->cbarg); 520| 7.27k| } 521| 7.27k|} buffer.c:evbuffer_remove_all_callbacks: 561| 31.1k|{ 562| 31.1k| struct evbuffer_cb_entry *cbent; 563| | 564| 33.0k| while ((cbent = LIST_FIRST(&buffer->callbacks))) { ------------------ | | 157| 33.0k|#define LIST_FIRST(head) ((head)->lh_first) ------------------ | Branch (564:9): [True: 1.90k, False: 31.1k] ------------------ 565| 1.90k| LIST_REMOVE(cbent, next); ------------------ | | 196| 1.90k|#define LIST_REMOVE(elm, field) do { \ | | 197| 1.90k| if ((elm)->field.le_next != NULL) \ | | ------------------ | | | Branch (197:6): [True: 0, False: 1.90k] | | ------------------ | | 198| 1.90k| (elm)->field.le_next->field.le_prev = \ | | 199| 0| (elm)->field.le_prev; \ | | 200| 1.90k| *(elm)->field.le_prev = (elm)->field.le_next; \ | | 201| 1.90k|} while (0) | | ------------------ | | | Branch (201:10): [Folded, False: 1.90k] | | ------------------ ------------------ 566| 1.90k| mm_free(cbent); ------------------ | | 80| 1.90k|#define mm_free(p) event_mm_free_(p) ------------------ 567| 1.90k| } 568| 31.1k|} buffer.c:advance_last_with_data: 731| 3.80k|{ 732| 3.80k| int n = 0; 733| 3.80k| struct evbuffer_chain **chainp = buf->last_with_datap; 734| | 735| 3.80k| ASSERT_EVBUFFER_LOCKED(buf); ------------------ | | 285| 3.80k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 3.80k| do { \ | | | | 131| 3.80k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 3.80k] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 3.80k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 3.80k] | | | | ------------------ | | ------------------ ------------------ 736| | 737| 3.80k| if (!*chainp) ------------------ | Branch (737:6): [True: 0, False: 3.80k] ------------------ 738| 0| return 0; 739| | 740| 3.80k| while ((*chainp)->next) { ------------------ | Branch (740:9): [True: 0, False: 3.80k] ------------------ 741| 0| chainp = &(*chainp)->next; 742| 0| if ((*chainp)->off) ------------------ | Branch (742:7): [True: 0, False: 0] ------------------ 743| 0| buf->last_with_datap = chainp; 744| 0| ++n; 745| 0| } 746| 3.80k| return n; 747| 3.80k|} buffer.c:PRESERVE_PINNED: 842| 1.02k|{ 843| 1.02k| struct evbuffer_chain *chain, **pinned; 844| | 845| 1.02k| ASSERT_EVBUFFER_LOCKED(src); ------------------ | | 285| 1.02k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 1.02k| do { \ | | | | 131| 1.02k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 1.02k] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 1.02k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 1.02k] | | | | ------------------ | | ------------------ ------------------ 846| | 847| 1.02k| if (!HAS_PINNED_R(src)) { ------------------ | Branch (847:6): [True: 1.02k, False: 0] ------------------ 848| 1.02k| *first = *last = NULL; 849| 1.02k| return 0; 850| 1.02k| } 851| | 852| 0| pinned = src->last_with_datap; 853| 0| if (!CHAIN_PINNED_R(*pinned)) ------------------ | | 128| 0|#define CHAIN_PINNED_R(ch) (((ch)->flags & EVBUFFER_MEM_PINNED_R) != 0) | | ------------------ | | | | 197| 0|#define EVBUFFER_MEM_PINNED_R 0x0010 | | ------------------ ------------------ | Branch (853:6): [True: 0, False: 0] ------------------ 854| 0| pinned = &(*pinned)->next; 855| 0| EVUTIL_ASSERT(CHAIN_PINNED_R(*pinned)); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 856| 0| chain = *first = *pinned; 857| 0| *last = src->last; 858| | 859| | /* If there's data in the first pinned chain, we need to allocate 860| | * a new chain and copy the data over. */ 861| 0| if (chain->off) { ------------------ | Branch (861:6): [True: 0, False: 0] ------------------ 862| 0| struct evbuffer_chain *tmp; 863| | 864| 0| EVUTIL_ASSERT(pinned == src->last_with_datap); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 865| 0| tmp = evbuffer_chain_new_membuf(chain->off); 866| 0| if (!tmp) ------------------ | Branch (866:7): [True: 0, False: 0] ------------------ 867| 0| return -1; 868| 0| memcpy(tmp->buffer, chain->buffer + chain->misalign, 869| 0| chain->off); 870| 0| tmp->off = chain->off; 871| 0| *src->last_with_datap = tmp; 872| 0| src->last = tmp; 873| 0| chain->misalign += chain->off; 874| 0| chain->off = 0; 875| 0| } else { 876| 0| src->last = *src->last_with_datap; 877| 0| *pinned = NULL; 878| 0| } 879| | 880| 0| return 0; 881| 0|} buffer.c:evbuffer_free_all_chains: 266| 974|{ 267| 974| struct evbuffer_chain *next; 268| 974| for (; chain; chain = next) { ------------------ | Branch (268:9): [True: 0, False: 974] ------------------ 269| 0| next = chain->next; 270| 0| evbuffer_chain_free(chain); 271| 0| } 272| 974|} buffer.c:COPY_CHAIN: 902| 974|{ 903| 974| ASSERT_EVBUFFER_LOCKED(dst); ------------------ | | 285| 974| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 974| do { \ | | | | 131| 974| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 974] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 974| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 974] | | | | ------------------ | | ------------------ ------------------ 904| 974| ASSERT_EVBUFFER_LOCKED(src); ------------------ | | 285| 974| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 974| do { \ | | | | 131| 974| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 974] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 974| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 974] | | | | ------------------ | | ------------------ ------------------ 905| 974| dst->first = src->first; 906| 974| if (src->last_with_datap == &src->first) ------------------ | Branch (906:6): [True: 974, False: 0] ------------------ 907| 974| dst->last_with_datap = &dst->first; 908| 0| else 909| 0| dst->last_with_datap = src->last_with_datap; 910| 974| dst->last = src->last; 911| 974| dst->total_len = src->total_len; 912| 974|} buffer.c:APPEND_CHAIN: 916| 54|{ 917| 54| struct evbuffer_chain **chp; 918| | 919| 54| ASSERT_EVBUFFER_LOCKED(dst); ------------------ | | 285| 54| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 54| do { \ | | | | 131| 54| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 54] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 54| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 54] | | | | ------------------ | | ------------------ ------------------ 920| 54| ASSERT_EVBUFFER_LOCKED(src); ------------------ | | 285| 54| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 54| do { \ | | | | 131| 54| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 54] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 54| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 54] | | | | ------------------ | | ------------------ ------------------ 921| | 922| 54| chp = evbuffer_free_trailing_empty_chains(dst); 923| 54| *chp = src->first; 924| | 925| 54| if (src->last_with_datap == &src->first) ------------------ | Branch (925:6): [True: 54, False: 0] ------------------ 926| 54| dst->last_with_datap = chp; 927| 0| else 928| 0| dst->last_with_datap = src->last_with_datap; 929| 54| dst->last = src->last; 930| 54| dst->total_len += src->total_len; 931| 54|} buffer.c:RESTORE_PINNED: 886| 1.02k|{ 887| 1.02k| ASSERT_EVBUFFER_LOCKED(src); ------------------ | | 285| 1.02k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 1.02k| do { \ | | | | 131| 1.02k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 1.02k] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 1.02k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 1.02k] | | | | ------------------ | | ------------------ ------------------ 888| | 889| 1.02k| if (!pinned) { ------------------ | Branch (889:6): [True: 1.02k, False: 0] ------------------ 890| 1.02k| ZERO_CHAIN(src); 891| 1.02k| return; 892| 1.02k| } 893| | 894| 0| src->first = pinned; 895| 0| src->last = last; 896| 0| src->last_with_datap = &src->first; 897| 0| src->total_len = 0; 898| 0|} buffer.c:HAS_PINNED_R: 821| 1.41k|{ 822| 1.41k| return (buf->last && CHAIN_PINNED_R(buf->last)); ------------------ | | 128| 1.41k|#define CHAIN_PINNED_R(ch) (((ch)->flags & EVBUFFER_MEM_PINNED_R) != 0) | | ------------------ | | | | 197| 1.41k|#define EVBUFFER_MEM_PINNED_R 0x0010 | | ------------------ | | | Branch (128:29): [True: 0, False: 1.41k] | | ------------------ ------------------ | Branch (822:10): [True: 1.41k, False: 0] ------------------ 823| 1.41k|} buffer.c:ZERO_CHAIN: 827| 1.41k|{ 828| 1.41k| ASSERT_EVBUFFER_LOCKED(dst); ------------------ | | 285| 1.41k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 1.41k| do { \ | | | | 131| 1.41k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 1.41k] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 1.41k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 1.41k] | | | | ------------------ | | ------------------ ------------------ 829| 1.41k| dst->first = NULL; 830| | dst->last = NULL; 831| 1.41k| dst->last_with_datap = &(dst)->first; 832| 1.41k| dst->total_len = 0; 833| 1.41k|} buffer.c:evbuffer_free_trailing_empty_chains: 301| 6.03k|{ 302| 6.03k| struct evbuffer_chain **ch = buf->last_with_datap; 303| | /* Find the first victim chain. It might be *last_with_datap */ 304| 12.0k| while ((*ch) && ((*ch)->off != 0 || CHAIN_PINNED(*ch))) ------------------ | | 127| 0|#define CHAIN_PINNED(ch) (((ch)->flags & EVBUFFER_MEM_PINNED_ANY) != 0) | | ------------------ | | | | 199| 0|#define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 197| 0|#define EVBUFFER_MEM_PINNED_R 0x0010 | | | | ------------------ | | | | #define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 198| 0|#define EVBUFFER_MEM_PINNED_W 0x0020 | | | | ------------------ | | ------------------ | | | Branch (127:27): [True: 0, False: 0] | | ------------------ ------------------ | Branch (304:9): [True: 6.03k, False: 6.03k] | Branch (304:19): [True: 6.03k, False: 0] ------------------ 305| 6.03k| ch = &(*ch)->next; 306| 6.03k| if (*ch) { ------------------ | Branch (306:6): [True: 0, False: 6.03k] ------------------ 307| 0| EVUTIL_ASSERT(evbuffer_chains_all_empty(*ch)); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 308| 0| evbuffer_free_all_chains(*ch); 309| | *ch = NULL; 310| 0| } 311| 6.03k| return ch; 312| 6.03k|} buffer.c:evbuffer_chain_new_membuf: 183| 35.3k|{ 184| 35.3k| size_t to_alloc; 185| | 186| 35.3k| if (size > EVBUFFER_CHAIN_MAX - EVBUFFER_CHAIN_SIZE) ------------------ | | 168| 35.3k|#define EVBUFFER_CHAIN_MAX ((size_t)EV_SSIZE_MAX) | | ------------------ | | | | 290| 35.3k|#define EV_SSIZE_MAX EV_INT64_MAX | | | | ------------------ | | | | | | 268| 35.3k|#define EV_INT64_MAX INT64_MAX | | | | ------------------ | | ------------------ ------------------ if (size > EVBUFFER_CHAIN_MAX - EVBUFFER_CHAIN_SIZE) ------------------ | | 279| 35.3k|#define EVBUFFER_CHAIN_SIZE sizeof(struct evbuffer_chain) ------------------ | Branch (186:6): [True: 0, False: 35.3k] ------------------ 187| 0| return (NULL); 188| | 189| 35.3k| size += EVBUFFER_CHAIN_SIZE; ------------------ | | 279| 35.3k|#define EVBUFFER_CHAIN_SIZE sizeof(struct evbuffer_chain) ------------------ 190| | 191| | /* get the next largest memory that can hold the buffer */ 192| 35.3k| if (size < EVBUFFER_CHAIN_MAX / 2) { ------------------ | | 168| 35.3k|#define EVBUFFER_CHAIN_MAX ((size_t)EV_SSIZE_MAX) | | ------------------ | | | | 290| 35.3k|#define EV_SSIZE_MAX EV_INT64_MAX | | | | ------------------ | | | | | | 268| 35.3k|#define EV_INT64_MAX INT64_MAX | | | | ------------------ | | ------------------ ------------------ | Branch (192:6): [True: 35.3k, False: 0] ------------------ 193| 35.3k| to_alloc = MIN_BUFFER_SIZE; ------------------ | | 57| 35.3k|#define MIN_BUFFER_SIZE 1024 ------------------ 194| 52.5k| while (to_alloc < size) { ------------------ | Branch (194:10): [True: 17.2k, False: 35.3k] ------------------ 195| 17.2k| to_alloc <<= 1; 196| 17.2k| } 197| 35.3k| } else { 198| 0| to_alloc = size; 199| 0| } 200| | 201| 35.3k| return evbuffer_chain_new(to_alloc - EVBUFFER_CHAIN_SIZE); ------------------ | | 279| 35.3k|#define EVBUFFER_CHAIN_SIZE sizeof(struct evbuffer_chain) ------------------ 202| 35.3k|} buffer.c:evbuffer_chain_insert_new: 340| 27.2k|{ 341| 27.2k| struct evbuffer_chain *chain; 342| 27.2k| if ((chain = evbuffer_chain_new_membuf(datlen)) == NULL) ------------------ | Branch (342:6): [True: 0, False: 27.2k] ------------------ 343| 0| return NULL; 344| 27.2k| evbuffer_chain_insert(buf, chain); 345| 27.2k| return chain; 346| 27.2k|} buffer.c:evbuffer_chain_insert: 320| 33.2k|{ 321| 33.2k| ASSERT_EVBUFFER_LOCKED(buf); ------------------ | | 285| 33.2k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 33.2k| do { \ | | | | 131| 33.2k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 33.2k] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 33.2k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 33.2k] | | | | ------------------ | | ------------------ ------------------ 322| 33.2k| if (*buf->last_with_datap == NULL) { ------------------ | Branch (322:6): [True: 27.2k, False: 5.97k] ------------------ 323| | /* There are no chains data on the buffer at all. */ 324| 27.2k| EVUTIL_ASSERT(buf->last_with_datap == &buf->first); ------------------ | | 368| 27.2k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 27.2k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 27.2k| (void)sizeof(!(condition)); \ | | | | 98| 27.2k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 27.2k] | | | | ------------------ | | ------------------ ------------------ 325| 27.2k| EVUTIL_ASSERT(buf->first == NULL); ------------------ | | 368| 27.2k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 27.2k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 27.2k| (void)sizeof(!(condition)); \ | | | | 98| 27.2k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 27.2k] | | | | ------------------ | | ------------------ ------------------ 326| 27.2k| buf->first = buf->last = chain; 327| 27.2k| } else { 328| 5.97k| struct evbuffer_chain **chp; 329| 5.97k| chp = evbuffer_free_trailing_empty_chains(buf); 330| 5.97k| *chp = chain; 331| 5.97k| if (chain->off) ------------------ | Branch (331:7): [True: 5.97k, False: 0] ------------------ 332| 5.97k| buf->last_with_datap = chp; 333| 5.97k| buf->last = chain; 334| 5.97k| } 335| 33.2k| buf->total_len += chain->off; 336| 33.2k|} buffer.c:evbuffer_chain_should_realign: 1954| 5.97k|{ 1955| 5.97k| return chain->buffer_len - chain->off >= datlen && ------------------ | Branch (1955:9): [True: 0, False: 5.97k] ------------------ 1956| 0| (chain->off < chain->buffer_len / 2) && ------------------ | Branch (1956:6): [True: 0, False: 0] ------------------ 1957| 0| (chain->off <= MAX_TO_REALIGN_IN_EXPAND); ------------------ | | 1947| 0|#define MAX_TO_REALIGN_IN_EXPAND 2048 ------------------ | Branch (1957:6): [True: 0, False: 0] ------------------ 1958| 5.97k|} buffer.c:evbuffer_expand_singlechain: 1964| 3.80k|{ 1965| 3.80k| struct evbuffer_chain *chain, **chainp; 1966| 3.80k| struct evbuffer_chain *result = NULL; 1967| 3.80k| ASSERT_EVBUFFER_LOCKED(buf); ------------------ | | 285| 3.80k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 3.80k| do { \ | | | | 131| 3.80k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 3.80k] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 3.80k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 3.80k] | | | | ------------------ | | ------------------ ------------------ 1968| | 1969| 3.80k| chainp = buf->last_with_datap; 1970| | 1971| | /* XXX If *chainp is no longer writeable, but has enough space in its 1972| | * misalign, this might be a bad idea: we could still use *chainp, not 1973| | * (*chainp)->next. */ 1974| 3.80k| if (*chainp && CHAIN_SPACE_LEN(*chainp) == 0) ------------------ | | 124| 2.85k|#define CHAIN_SPACE_LEN(ch) ((ch)->flags & EVBUFFER_IMMUTABLE ? \ | | ------------------ | | | | 194| 2.85k|#define EVBUFFER_IMMUTABLE 0x0008 /**< read-only chain */ | | ------------------ | | | Branch (124:30): [True: 0, False: 2.85k] | | ------------------ | | 125| 2.85k| 0 : (ch)->buffer_len - ((ch)->misalign + (ch)->off)) ------------------ | Branch (1974:6): [True: 2.85k, False: 952] | Branch (1974:17): [True: 0, False: 2.85k] ------------------ 1975| 0| chainp = &(*chainp)->next; 1976| | 1977| | /* 'chain' now points to the first chain with writable space (if any) 1978| | * We will either use it, realign it, replace it, or resize it. */ 1979| 3.80k| chain = *chainp; 1980| | 1981| 3.80k| if (chain == NULL || ------------------ | Branch (1981:6): [True: 952, False: 2.85k] ------------------ 1982| 2.85k| (chain->flags & (EVBUFFER_IMMUTABLE|EVBUFFER_MEM_PINNED_ANY))) { ------------------ | | 194| 2.85k|#define EVBUFFER_IMMUTABLE 0x0008 /**< read-only chain */ ------------------ (chain->flags & (EVBUFFER_IMMUTABLE|EVBUFFER_MEM_PINNED_ANY))) { ------------------ | | 199| 2.85k|#define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | ------------------ | | | | 197| 2.85k|#define EVBUFFER_MEM_PINNED_R 0x0010 | | ------------------ | | #define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | ------------------ | | | | 198| 2.85k|#define EVBUFFER_MEM_PINNED_W 0x0020 | | ------------------ ------------------ | Branch (1982:6): [True: 0, False: 2.85k] ------------------ 1983| | /* We can't use the last_with_data chain at all. Just add a 1984| | * new one that's big enough. */ 1985| 952| goto insert_new; 1986| 952| } 1987| | 1988| | /* If we can fit all the data, then we don't have to do anything */ 1989| 2.85k| if (CHAIN_SPACE_LEN(chain) >= datlen) { ------------------ | | 124| 2.85k|#define CHAIN_SPACE_LEN(ch) ((ch)->flags & EVBUFFER_IMMUTABLE ? \ | | ------------------ | | | | 194| 2.85k|#define EVBUFFER_IMMUTABLE 0x0008 /**< read-only chain */ | | ------------------ | | | Branch (124:30): [True: 0, False: 2.85k] | | ------------------ | | 125| 2.85k| 0 : (ch)->buffer_len - ((ch)->misalign + (ch)->off)) ------------------ | Branch (1989:6): [True: 2.85k, False: 0] ------------------ 1990| 2.85k| result = chain; 1991| 2.85k| goto ok; 1992| 2.85k| } 1993| | 1994| | /* If the chain is completely empty, just replace it by adding a new 1995| | * empty chain. */ 1996| 0| if (chain->off == 0) { ------------------ | Branch (1996:6): [True: 0, False: 0] ------------------ 1997| 0| goto insert_new; 1998| 0| } 1999| | 2000| | /* If the misalignment plus the remaining space fulfills our data 2001| | * needs, we could just force an alignment to happen. Afterwards, we 2002| | * have enough space. But only do this if we're saving a lot of space 2003| | * and not moving too much data. Otherwise the space savings are 2004| | * probably offset by the time lost in copying. 2005| | */ 2006| 0| if (evbuffer_chain_should_realign(chain, datlen)) { ------------------ | Branch (2006:6): [True: 0, False: 0] ------------------ 2007| 0| evbuffer_chain_align(chain); 2008| 0| result = chain; 2009| 0| goto ok; 2010| 0| } 2011| | 2012| | /* At this point, we can either resize the last chunk with space in 2013| | * it, use the next chunk after it, or If we add a new chunk, we waste 2014| | * CHAIN_SPACE_LEN(chain) bytes in the former last chunk. If we 2015| | * resize, we have to copy chain->off bytes. 2016| | */ 2017| | 2018| | /* Would expanding this chunk be affordable and worthwhile? */ 2019| 0| if (CHAIN_SPACE_LEN(chain) < chain->buffer_len / 8 || ------------------ | | 124| 0|#define CHAIN_SPACE_LEN(ch) ((ch)->flags & EVBUFFER_IMMUTABLE ? \ | | ------------------ | | | | 194| 0|#define EVBUFFER_IMMUTABLE 0x0008 /**< read-only chain */ | | ------------------ | | | Branch (124:30): [True: 0, False: 0] | | ------------------ | | 125| 0| 0 : (ch)->buffer_len - ((ch)->misalign + (ch)->off)) ------------------ | Branch (2019:6): [True: 0, False: 0] ------------------ 2020| 0| chain->off > MAX_TO_COPY_IN_EXPAND || ------------------ | | 1946| 0|#define MAX_TO_COPY_IN_EXPAND 4096 ------------------ | Branch (2020:6): [True: 0, False: 0] ------------------ 2021| 0| datlen >= (EVBUFFER_CHAIN_MAX - chain->off)) { ------------------ | | 168| 0|#define EVBUFFER_CHAIN_MAX ((size_t)EV_SSIZE_MAX) | | ------------------ | | | | 290| 0|#define EV_SSIZE_MAX EV_INT64_MAX | | | | ------------------ | | | | | | 268| 0|#define EV_INT64_MAX INT64_MAX | | | | ------------------ | | ------------------ ------------------ | Branch (2021:3): [True: 0, False: 0] ------------------ 2022| | /* It's not worth resizing this chain. Can the next one be 2023| | * used? */ 2024| 0| if (chain->next && CHAIN_SPACE_LEN(chain->next) >= datlen) { ------------------ | | 124| 0|#define CHAIN_SPACE_LEN(ch) ((ch)->flags & EVBUFFER_IMMUTABLE ? \ | | ------------------ | | | | 194| 0|#define EVBUFFER_IMMUTABLE 0x0008 /**< read-only chain */ | | ------------------ | | | Branch (124:30): [True: 0, False: 0] | | ------------------ | | 125| 0| 0 : (ch)->buffer_len - ((ch)->misalign + (ch)->off)) ------------------ | Branch (2024:7): [True: 0, False: 0] | Branch (2024:22): [True: 0, False: 0] ------------------ 2025| | /* Yes, we can just use the next chain (which should 2026| | * be empty. */ 2027| 0| result = chain->next; 2028| 0| goto ok; 2029| 0| } else { 2030| | /* No; append a new chain (which will free all 2031| | * terminal empty chains.) */ 2032| 0| goto insert_new; 2033| 0| } 2034| 0| } else { 2035| | /* Okay, we're going to try to resize this chain: Not doing so 2036| | * would waste at least 1/8 of its current allocation, and we 2037| | * can do so without having to copy more than 2038| | * MAX_TO_COPY_IN_EXPAND bytes. */ 2039| | /* figure out how much space we need */ 2040| 0| size_t length = chain->off + datlen; 2041| 0| struct evbuffer_chain *tmp = evbuffer_chain_new_membuf(length); 2042| 0| if (tmp == NULL) ------------------ | Branch (2042:7): [True: 0, False: 0] ------------------ 2043| 0| goto err; 2044| | 2045| | /* copy the data over that we had so far */ 2046| 0| tmp->off = chain->off; 2047| 0| memcpy(tmp->buffer, chain->buffer + chain->misalign, 2048| 0| chain->off); 2049| | /* fix up the list */ 2050| 0| EVUTIL_ASSERT(*chainp == chain); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2051| 0| result = *chainp = tmp; 2052| | 2053| 0| if (buf->last == chain) ------------------ | Branch (2053:7): [True: 0, False: 0] ------------------ 2054| 0| buf->last = tmp; 2055| | 2056| 0| tmp->next = chain->next; 2057| 0| evbuffer_chain_free(chain); 2058| 0| goto ok; 2059| 0| } 2060| | 2061| 952|insert_new: 2062| 952| result = evbuffer_chain_insert_new(buf, datlen); 2063| 952| if (!result) ------------------ | Branch (2063:6): [True: 0, False: 952] ------------------ 2064| 0| goto err; 2065| 3.80k|ok: 2066| 3.80k| EVUTIL_ASSERT(result); ------------------ | | 368| 3.80k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 3.80k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 3.80k| (void)sizeof(!(condition)); \ | | | | 98| 3.80k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 3.80k] | | | | ------------------ | | ------------------ ------------------ 2067| 3.80k| EVUTIL_ASSERT(CHAIN_SPACE_LEN(result) >= datlen); ------------------ | | 368| 3.80k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 3.80k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 7.61k| (void)sizeof(!(condition)); \ | | | | ------------------ | | | | | Branch (97:17): [True: 0, False: 3.80k] | | | | ------------------ | | | | 98| 3.80k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 3.80k] | | | | ------------------ | | ------------------ ------------------ 2068| 3.80k|err: 2069| 3.80k| return result; 2070| 3.80k|} buffer.c:evbuffer_chain_new: 154| 35.3k|{ 155| 35.3k| struct evbuffer_chain *chain; 156| 35.3k| size_t to_alloc; 157| | 158| 35.3k| if (size > EVBUFFER_CHAIN_MAX - EVBUFFER_CHAIN_SIZE) ------------------ | | 168| 35.3k|#define EVBUFFER_CHAIN_MAX ((size_t)EV_SSIZE_MAX) | | ------------------ | | | | 290| 35.3k|#define EV_SSIZE_MAX EV_INT64_MAX | | | | ------------------ | | | | | | 268| 35.3k|#define EV_INT64_MAX INT64_MAX | | | | ------------------ | | ------------------ ------------------ if (size > EVBUFFER_CHAIN_MAX - EVBUFFER_CHAIN_SIZE) ------------------ | | 279| 35.3k|#define EVBUFFER_CHAIN_SIZE sizeof(struct evbuffer_chain) ------------------ | Branch (158:6): [True: 0, False: 35.3k] ------------------ 159| 0| return (NULL); 160| | 161| 35.3k| to_alloc = size + EVBUFFER_CHAIN_SIZE; ------------------ | | 279| 35.3k|#define EVBUFFER_CHAIN_SIZE sizeof(struct evbuffer_chain) ------------------ 162| | 163| | /* we get everything in one chunk */ 164| 35.3k| if ((chain = mm_malloc(to_alloc)) == NULL) ------------------ | | 76| 35.3k|#define mm_malloc(sz) event_mm_malloc_(sz) ------------------ | Branch (164:6): [True: 0, False: 35.3k] ------------------ 165| 0| return (NULL); 166| | 167| 35.3k| memset(chain, 0, EVBUFFER_CHAIN_SIZE); ------------------ | | 279| 35.3k|#define EVBUFFER_CHAIN_SIZE sizeof(struct evbuffer_chain) ------------------ 168| | 169| 35.3k| chain->buffer_len = to_alloc - EVBUFFER_CHAIN_SIZE; ------------------ | | 279| 35.3k|#define EVBUFFER_CHAIN_SIZE sizeof(struct evbuffer_chain) ------------------ 170| | 171| | /* this way we can manipulate the buffer to different addresses, 172| | * which is required for mmap for example. 173| | */ 174| 35.3k| chain->buffer = EVBUFFER_CHAIN_EXTRA(unsigned char, chain); ------------------ | | 281| 35.3k|#define EVBUFFER_CHAIN_EXTRA(t, c) (t *)((struct evbuffer_chain *)(c) + 1) ------------------ 175| | 176| 35.3k| chain->refcnt = 1; 177| | 178| 35.3k| return (chain); 179| 35.3k|} bufferevent_pair.c:bufferevent_trigger_nolock_: 416| 1.90k|{ 417| 1.90k| if ((iotype & EV_READ) && ((options & BEV_TRIG_IGNORE_WATERMARKS) || ------------------ | | 957| 1.90k|#define EV_READ 0x02 ------------------ | Branch (417:6): [True: 952, False: 952] | Branch (417:29): [True: 0, False: 952] ------------------ 418| 952| evbuffer_get_length(bufev->input) >= bufev->wm_read.low)) ------------------ | Branch (418:6): [True: 952, False: 0] ------------------ 419| 952| bufferevent_run_readcb_(bufev, options); 420| 1.90k| if ((iotype & EV_WRITE) && ((options & BEV_TRIG_IGNORE_WATERMARKS) || ------------------ | | 959| 1.90k|#define EV_WRITE 0x04 ------------------ | Branch (420:6): [True: 952, False: 952] | Branch (420:30): [True: 0, False: 952] ------------------ 421| 952| evbuffer_get_length(bufev->output) <= bufev->wm_write.low)) ------------------ | Branch (421:6): [True: 952, False: 0] ------------------ 422| 952| bufferevent_run_writecb_(bufev, options); 423| 1.90k|} bufferevent_run_readcb_: 242| 952|{ 243| | /* Requires that we hold the lock and a reference */ 244| 952| struct bufferevent_private *p = BEV_UPCAST(bufev); ------------------ | | 486| 952|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | ------------------ | | | | 289| 952| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | ------------------ | | | | | | 625| 952|#define evutil_offsetof(type, field) offsetof(type, field) | | | | ------------------ | | ------------------ ------------------ 245| 952| if (bufev->readcb == NULL) ------------------ | Branch (245:6): [True: 0, False: 952] ------------------ 246| 0| return; 247| 952| if ((p->options|options) & BEV_OPT_DEFER_CALLBACKS) { ------------------ | Branch (247:6): [True: 952, False: 0] ------------------ 248| 952| p->readcb_pending = 1; 249| 952| SCHEDULE_DEFERRED(p); ------------------ | | 232| 952| do { \ | | 233| 952| if (event_deferred_cb_schedule_( \ | | ------------------ | | | Branch (233:7): [True: 952, False: 0] | | ------------------ | | 234| 952| (bevp)->bev.ev_base, \ | | 235| 952| &(bevp)->deferred)) \ | | 236| 952| bufferevent_incref_(&(bevp)->bev); \ | | ------------------ | | | | 377| 952|#define bufferevent_incref_(bufev) bufferevent_incref(bufev) | | ------------------ | | 237| 952| } while (0) | | ------------------ | | | Branch (237:11): [Folded, False: 952] | | ------------------ ------------------ 250| 952| } else { 251| 0| bufev->readcb(bufev, bufev->cbarg); 252| 0| bufferevent_inbuf_wm_check(bufev); 253| 0| } 254| 952|} bufferevent_run_writecb_: 258| 952|{ 259| | /* Requires that we hold the lock and a reference */ 260| 952| struct bufferevent_private *p = BEV_UPCAST(bufev); ------------------ | | 486| 952|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | ------------------ | | | | 289| 952| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | ------------------ | | | | | | 625| 952|#define evutil_offsetof(type, field) offsetof(type, field) | | | | ------------------ | | ------------------ ------------------ 261| 952| if (bufev->writecb == NULL) ------------------ | Branch (261:6): [True: 952, False: 0] ------------------ 262| 952| return; 263| 0| if ((p->options|options) & BEV_OPT_DEFER_CALLBACKS) { ------------------ | Branch (263:6): [True: 0, False: 0] ------------------ 264| 0| p->writecb_pending = 1; 265| 0| SCHEDULE_DEFERRED(p); ------------------ | | 232| 0| do { \ | | 233| 0| if (event_deferred_cb_schedule_( \ | | ------------------ | | | Branch (233:7): [True: 0, False: 0] | | ------------------ | | 234| 0| (bevp)->bev.ev_base, \ | | 235| 0| &(bevp)->deferred)) \ | | 236| 0| bufferevent_incref_(&(bevp)->bev); \ | | ------------------ | | | | 377| 0|#define bufferevent_incref_(bufev) bufferevent_incref(bufev) | | ------------------ | | 237| 0| } while (0) | | ------------------ | | | Branch (237:11): [Folded, False: 0] | | ------------------ ------------------ 266| 0| } else { 267| 0| bufev->writecb(bufev, bufev->cbarg); 268| 0| } 269| 0|} bufferevent_init_common_: 313| 1.90k|{ 314| 1.90k| struct bufferevent *bufev = &bufev_private->bev; 315| | 316| 1.90k| if (!bufev->input) { ------------------ | Branch (316:6): [True: 1.90k, False: 0] ------------------ 317| 1.90k| if ((bufev->input = evbuffer_new()) == NULL) ------------------ | Branch (317:7): [True: 0, False: 1.90k] ------------------ 318| 0| goto err; 319| 1.90k| } 320| | 321| 1.90k| if (!bufev->output) { ------------------ | Branch (321:6): [True: 1.90k, False: 0] ------------------ 322| 1.90k| if ((bufev->output = evbuffer_new()) == NULL) ------------------ | Branch (322:7): [True: 0, False: 1.90k] ------------------ 323| 0| goto err; 324| 1.90k| } 325| | 326| 1.90k| bufev_private->refcnt = 1; 327| 1.90k| bufev->ev_base = base; 328| | 329| | /* Disable timeouts. */ 330| 1.90k| evutil_timerclear(&bufev->timeout_read); ------------------ | | 604| 1.90k|#define evutil_timerclear(tvp) timerclear(tvp) ------------------ 331| 1.90k| evutil_timerclear(&bufev->timeout_write); ------------------ | | 604| 1.90k|#define evutil_timerclear(tvp) timerclear(tvp) ------------------ 332| | 333| 1.90k| bufev->be_ops = ops; 334| | 335| 1.90k| if (bufferevent_ratelim_init_(bufev_private)) ------------------ | Branch (335:6): [True: 0, False: 1.90k] ------------------ 336| 0| goto err; 337| | 338| | /* 339| | * Set to EV_WRITE so that using bufferevent_write is going to 340| | * trigger a callback. Reading needs to be explicitly enabled 341| | * because otherwise no data will be available. 342| | */ 343| 1.90k| bufev->enabled = EV_WRITE; ------------------ | | 959| 1.90k|#define EV_WRITE 0x04 ------------------ 344| | 345| 1.90k|#ifndef EVENT__DISABLE_THREAD_SUPPORT 346| 1.90k| if (options & BEV_OPT_THREADSAFE) { ------------------ | Branch (346:6): [True: 0, False: 1.90k] ------------------ 347| 0| if (bufferevent_enable_locking_(bufev, NULL) < 0) ------------------ | Branch (347:7): [True: 0, False: 0] ------------------ 348| 0| goto err; 349| 0| } 350| 1.90k|#endif 351| 1.90k| if ((options & (BEV_OPT_DEFER_CALLBACKS|BEV_OPT_UNLOCK_CALLBACKS)) ------------------ | Branch (351:6): [True: 0, False: 1.90k] ------------------ 352| 1.90k| == BEV_OPT_UNLOCK_CALLBACKS) { 353| 0| event_warnx("UNLOCK_CALLBACKS requires DEFER_CALLBACKS"); 354| 0| goto err; 355| 0| } 356| 1.90k| if (options & BEV_OPT_UNLOCK_CALLBACKS) ------------------ | Branch (356:6): [True: 0, False: 1.90k] ------------------ 357| 0| event_deferred_cb_init_( 358| 0| &bufev_private->deferred, 359| 0| event_base_get_npriorities(base) / 2, 360| 0| bufferevent_run_deferred_callbacks_unlocked, 361| 0| bufev_private); 362| 1.90k| else 363| 1.90k| event_deferred_cb_init_( 364| 1.90k| &bufev_private->deferred, 365| 1.90k| event_base_get_npriorities(base) / 2, 366| 1.90k| bufferevent_run_deferred_callbacks_locked, 367| 1.90k| bufev_private); 368| | 369| 1.90k| bufev_private->options = options; 370| | 371| 1.90k| evbuffer_set_parent_(bufev->input, bufev); 372| 1.90k| evbuffer_set_parent_(bufev->output, bufev); 373| | 374| 1.90k| return 0; 375| | 376| 0|err: 377| 0| if (bufev->input) { ------------------ | Branch (377:6): [True: 0, False: 0] ------------------ 378| 0| evbuffer_free(bufev->input); 379| 0| bufev->input = NULL; 380| 0| } 381| 0| if (bufev->output) { ------------------ | Branch (381:6): [True: 0, False: 0] ------------------ 382| 0| evbuffer_free(bufev->output); 383| | bufev->output = NULL; 384| 0| } 385| 0| return -1; 386| 1.90k|} bufferevent_setcb: 392| 5.36k|{ 393| 5.36k| BEV_LOCK(bufev); ------------------ | | 493| 5.36k|#define BEV_LOCK(b) do { \ | | 494| 5.36k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 486| 5.36k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 5.36k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 5.36k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 495| 5.36k| EVLOCK_LOCK(locking->lock, 0); \ | | ------------------ | | | | 94| 5.36k| do { \ | | | | 95| 5.36k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 5.36k] | | | | ------------------ | | | | 96| 5.36k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 5.36k] | | | | ------------------ | | ------------------ | | 496| 5.36k| } while (0) | | ------------------ | | | Branch (496:11): [Folded, False: 5.36k] | | ------------------ ------------------ 394| | 395| 5.36k| bufev->readcb = readcb; 396| 5.36k| bufev->writecb = writecb; 397| 5.36k| bufev->errorcb = eventcb; 398| | 399| 5.36k| bufev->cbarg = cbarg; 400| | BEV_UNLOCK(bufev); ------------------ | | 499| 5.36k|#define BEV_UNLOCK(b) do { \ | | 500| 5.36k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 486| 5.36k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 5.36k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 5.36k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 501| 5.36k| EVLOCK_UNLOCK(locking->lock, 0); \ | | ------------------ | | | | 101| 5.36k| do { \ | | | | 102| 5.36k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 5.36k] | | | | ------------------ | | | | 103| 5.36k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 5.36k] | | | | ------------------ | | ------------------ | | 502| 5.36k| } while (0) | | ------------------ | | | Branch (502:11): [Folded, False: 5.36k] | | ------------------ ------------------ 401| 5.36k|} bufferevent_get_input: 425| 952|{ 426| 952| return bufev->input; 427| 952|} bufferevent_get_output: 431| 3.46k|{ 432| 3.46k| return bufev->output; 433| 3.46k|} bufferevent_get_base: 437| 952|{ 438| 952| return bufev->ev_base; 439| 952|} bufferevent_get_priority: 443| 952|{ 444| 952| if (event_initialized(&bufev->ev_read)) { ------------------ | Branch (444:6): [True: 952, False: 0] ------------------ 445| 952| return event_get_priority(&bufev->ev_read); 446| 952| } else { 447| 0| return event_base_get_npriorities(bufev->ev_base) / 2; 448| 0| } 449| 952|} bufferevent_enable: 488| 952|{ 489| 952| struct bufferevent_private *bufev_private = BEV_UPCAST(bufev); ------------------ | | 486| 952|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | ------------------ | | | | 289| 952| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | ------------------ | | | | | | 625| 952|#define evutil_offsetof(type, field) offsetof(type, field) | | | | ------------------ | | ------------------ ------------------ 490| 952| short impl_events = event; 491| 952| int r = 0; 492| | 493| 952| bufferevent_incref_and_lock_(bufev); 494| 952| if (bufev_private->read_suspended) ------------------ | Branch (494:6): [True: 0, False: 952] ------------------ 495| 0| impl_events &= ~EV_READ; ------------------ | | 957| 0|#define EV_READ 0x02 ------------------ 496| 952| if (bufev_private->write_suspended) ------------------ | Branch (496:6): [True: 0, False: 952] ------------------ 497| 0| impl_events &= ~EV_WRITE; ------------------ | | 959| 0|#define EV_WRITE 0x04 ------------------ 498| | 499| 952| bufev->enabled |= event; 500| | 501| 952| if (impl_events && bufev->be_ops->enable(bufev, impl_events) < 0) ------------------ | Branch (501:6): [True: 952, False: 0] | Branch (501:21): [True: 0, False: 952] ------------------ 502| 0| r = -1; 503| 952| if (r) ------------------ | Branch (503:6): [True: 0, False: 952] ------------------ 504| 0| event_debug(("%s: cannot enable 0x%hx on %p", __func__, event, (void *)bufev)); ------------------ | | 79| 0|#define event_debug(x) do { \ | | 80| 0| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 0|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 0| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 0] | | ------------------ ------------------ 505| | 506| 952| bufferevent_decref_and_unlock_(bufev); 507| 952| return r; 508| 952|} bufferevent_incref_and_lock_: 686| 18.3k|{ 687| 18.3k| struct bufferevent_private *bufev_private = BEV_UPCAST(bufev); ------------------ | | 486| 18.3k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | ------------------ | | | | 289| 18.3k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | ------------------ | | | | | | 625| 18.3k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | ------------------ | | ------------------ ------------------ 688| | BEV_LOCK(bufev); ------------------ | | 493| 18.3k|#define BEV_LOCK(b) do { \ | | 494| 18.3k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 486| 18.3k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 18.3k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 18.3k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 495| 18.3k| EVLOCK_LOCK(locking->lock, 0); \ | | ------------------ | | | | 94| 18.3k| do { \ | | | | 95| 18.3k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 18.3k] | | | | ------------------ | | | | 96| 18.3k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 18.3k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 18.3k] | | | | ------------------ | | ------------------ | | 496| 18.3k| } while (0) | | ------------------ | | | Branch (496:11): [Folded, False: 18.3k] | | ------------------ ------------------ 689| 18.3k| ++bufev_private->refcnt; 690| 18.3k|} bufferevent_decref_and_unlock_: 712| 21.2k|{ 713| 21.2k| struct bufferevent_private *bufev_private = BEV_UPCAST(bufev); ------------------ | | 486| 21.2k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | ------------------ | | | | 289| 21.2k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | ------------------ | | | | | | 625| 21.2k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | ------------------ | | ------------------ ------------------ 714| 21.2k| int n_cbs = 0; 715| 21.2k|#define MAX_CBS 16 716| 21.2k| struct event_callback *cbs[MAX_CBS]; 717| | 718| 21.2k| EVUTIL_ASSERT(bufev_private->refcnt > 0); ------------------ | | 368| 21.2k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 21.2k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 21.2k| (void)sizeof(!(condition)); \ | | | | 98| 21.2k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 21.2k] | | | | ------------------ | | ------------------ ------------------ 719| | 720| 21.2k| if (--bufev_private->refcnt) { ------------------ | Branch (720:6): [True: 19.3k, False: 1.90k] ------------------ 721| 19.3k| BEV_UNLOCK(bufev); ------------------ | | 499| 19.3k|#define BEV_UNLOCK(b) do { \ | | 500| 19.3k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 486| 19.3k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 19.3k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 19.3k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 501| 19.3k| EVLOCK_UNLOCK(locking->lock, 0); \ | | ------------------ | | | | 101| 19.3k| do { \ | | | | 102| 19.3k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 19.3k] | | | | ------------------ | | | | 103| 19.3k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 19.3k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 19.3k] | | | | ------------------ | | ------------------ | | 502| 19.3k| } while (0) | | ------------------ | | | Branch (502:11): [Folded, False: 19.3k] | | ------------------ ------------------ 722| 19.3k| return 0; 723| 19.3k| } 724| | 725| 1.90k| if (bufev->be_ops->unlink) ------------------ | Branch (725:6): [True: 1.90k, False: 0] ------------------ 726| 1.90k| bufev->be_ops->unlink(bufev); 727| | 728| | /* Okay, we're out of references. Let's finalize this once all the 729| | * callbacks are done running. */ 730| 1.90k| cbs[0] = &bufev->ev_read.ev_evcallback; 731| 1.90k| cbs[1] = &bufev->ev_write.ev_evcallback; 732| 1.90k| cbs[2] = &bufev_private->deferred; 733| 1.90k| n_cbs = 3; 734| 1.90k| if (bufev_private->rate_limiting) { ------------------ | Branch (734:6): [True: 0, False: 1.90k] ------------------ 735| 0| struct event *e = &bufev_private->rate_limiting->refill_bucket_event; 736| 0| if (event_initialized(e)) ------------------ | Branch (736:7): [True: 0, False: 0] ------------------ 737| 0| cbs[n_cbs++] = &e->ev_evcallback; 738| 0| } 739| 1.90k| n_cbs += evbuffer_get_callbacks_(bufev->input, cbs+n_cbs, MAX_CBS-n_cbs); ------------------ | | 715| 1.90k|#define MAX_CBS 16 ------------------ 740| 1.90k| n_cbs += evbuffer_get_callbacks_(bufev->output, cbs+n_cbs, MAX_CBS-n_cbs); ------------------ | | 715| 1.90k|#define MAX_CBS 16 ------------------ 741| | 742| 1.90k| event_callback_finalize_many_(bufev->ev_base, n_cbs, cbs, 743| 1.90k| bufferevent_finalize_cb_); 744| | 745| 1.90k|#undef MAX_CBS 746| 1.90k| BEV_UNLOCK(bufev); ------------------ | | 499| 1.90k|#define BEV_UNLOCK(b) do { \ | | 500| 1.90k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 486| 1.90k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 1.90k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 1.90k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 501| 1.90k| EVLOCK_UNLOCK(locking->lock, 0); \ | | ------------------ | | | | 101| 1.90k| do { \ | | | | 102| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 103| 1.90k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 502| 1.90k| } while (0) | | ------------------ | | | Branch (502:11): [Folded, False: 1.90k] | | ------------------ ------------------ 747| | 748| 1.90k| return 1; 749| 21.2k|} bufferevent_free: 812| 1.90k|{ 813| 1.90k| BEV_LOCK(bufev); ------------------ | | 493| 1.90k|#define BEV_LOCK(b) do { \ | | 494| 1.90k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 486| 1.90k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 1.90k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 1.90k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 495| 1.90k| EVLOCK_LOCK(locking->lock, 0); \ | | ------------------ | | | | 94| 1.90k| do { \ | | | | 95| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 96| 1.90k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 496| 1.90k| } while (0) | | ------------------ | | | Branch (496:11): [Folded, False: 1.90k] | | ------------------ ------------------ 814| 1.90k| bufferevent_setcb(bufev, NULL, NULL, NULL, NULL); 815| 1.90k| bufferevent_cancel_all_(bufev); 816| 1.90k| bufferevent_decref_and_unlock_(bufev); 817| 1.90k|} bufferevent_incref: 821| 952|{ 822| 952| struct bufferevent_private *bufev_private = BEV_UPCAST(bufev); ------------------ | | 486| 952|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | ------------------ | | | | 289| 952| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | ------------------ | | | | | | 625| 952|#define evutil_offsetof(type, field) offsetof(type, field) | | | | ------------------ | | ------------------ ------------------ 823| | 824| | /* XXX: now that this function is public, we might want to 825| | * - return the count from this function 826| | * - create a new function to atomically grab the current refcount 827| | */ 828| 952| BEV_LOCK(bufev); ------------------ | | 493| 952|#define BEV_LOCK(b) do { \ | | 494| 952| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 486| 952|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 952| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 952|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 495| 952| EVLOCK_LOCK(locking->lock, 0); \ | | ------------------ | | | | 94| 952| do { \ | | | | 95| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 952] | | | | ------------------ | | | | 96| 952| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 952| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 952] | | | | ------------------ | | ------------------ | | 496| 952| } while (0) | | ------------------ | | | Branch (496:11): [Folded, False: 952] | | ------------------ ------------------ 829| 952| ++bufev_private->refcnt; 830| | BEV_UNLOCK(bufev); ------------------ | | 499| 952|#define BEV_UNLOCK(b) do { \ | | 500| 952| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 486| 952|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 952| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 952|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 501| 952| EVLOCK_UNLOCK(locking->lock, 0); \ | | ------------------ | | | | 101| 952| do { \ | | | | 102| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 952] | | | | ------------------ | | | | 103| 952| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 952| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 952] | | | | ------------------ | | ------------------ | | 502| 952| } while (0) | | ------------------ | | | Branch (502:11): [Folded, False: 952] | | ------------------ ------------------ 831| 952|} bufferevent_get_underlying: 963| 1.90k|{ 964| 1.90k| union bufferevent_ctrl_data d; 965| 1.90k| int res = -1; 966| 1.90k| d.ptr = NULL; 967| 1.90k| BEV_LOCK(bev); ------------------ | | 493| 1.90k|#define BEV_LOCK(b) do { \ | | 494| 1.90k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 486| 1.90k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 1.90k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 1.90k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 495| 1.90k| EVLOCK_LOCK(locking->lock, 0); \ | | ------------------ | | | | 94| 1.90k| do { \ | | | | 95| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 96| 1.90k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 496| 1.90k| } while (0) | | ------------------ | | | Branch (496:11): [Folded, False: 1.90k] | | ------------------ ------------------ 968| 1.90k| if (bev->be_ops->ctrl) ------------------ | Branch (968:6): [True: 0, False: 1.90k] ------------------ 969| 0| res = bev->be_ops->ctrl(bev, BEV_CTRL_GET_UNDERLYING, &d); 970| 1.90k| BEV_UNLOCK(bev); ------------------ | | 499| 1.90k|#define BEV_UNLOCK(b) do { \ | | 500| 1.90k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 486| 1.90k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 1.90k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 1.90k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 501| 1.90k| EVLOCK_UNLOCK(locking->lock, 0); \ | | ------------------ | | | | 101| 1.90k| do { \ | | | | 102| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 103| 1.90k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 502| 1.90k| } while (0) | | ------------------ | | | Branch (502:11): [Folded, False: 1.90k] | | ------------------ ------------------ 971| 1.90k| return (res<0) ? NULL : d.ptr; ------------------ | Branch (971:9): [True: 1.90k, False: 0] ------------------ 972| 1.90k|} bufferevent_init_generic_timeout_cbs_: 995| 1.90k|{ 996| 1.90k| event_assign(&bev->ev_read, bev->ev_base, -1, EV_FINALIZE, ------------------ | | 979| 1.90k|#define EV_FINALIZE 0x40 ------------------ 997| 1.90k| bufferevent_generic_read_timeout_cb, bev); 998| 1.90k| event_assign(&bev->ev_write, bev->ev_base, -1, EV_FINALIZE, ------------------ | | 979| 1.90k|#define EV_FINALIZE 0x40 ------------------ 999| 1.90k| bufferevent_generic_write_timeout_cb, bev); 1000| 1.90k|} bufferevent.c:bufferevent_inbuf_wm_check: 122| 952|{ 123| 952| if (!bev->wm_read.high) ------------------ | Branch (123:6): [True: 952, False: 0] ------------------ 124| 952| return; 125| 0| if (!(bev->enabled & EV_READ)) ------------------ | | 957| 0|#define EV_READ 0x02 ------------------ | Branch (125:6): [True: 0, False: 0] ------------------ 126| 0| return; 127| 0| if (evbuffer_get_length(bev->input) < bev->wm_read.high) ------------------ | Branch (127:6): [True: 0, False: 0] ------------------ 128| 0| return; 129| | 130| 0| bufferevent_trigger(bev, EV_READ, BEV_OPT_DEFER_CALLBACKS); ------------------ | | 957| 0|#define EV_READ 0x02 ------------------ 131| 0|} bufferevent.c:bufferevent_run_deferred_callbacks_locked: 153| 952|{ 154| 952| struct bufferevent_private *bufev_private = arg; 155| 952| struct bufferevent *bufev = &bufev_private->bev; 156| | 157| 952| BEV_LOCK(bufev); ------------------ | | 493| 952|#define BEV_LOCK(b) do { \ | | 494| 952| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 486| 952|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 952| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 952|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 495| 952| EVLOCK_LOCK(locking->lock, 0); \ | | ------------------ | | | | 94| 952| do { \ | | | | 95| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 952] | | | | ------------------ | | | | 96| 952| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 952| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 952] | | | | ------------------ | | ------------------ | | 496| 952| } while (0) | | ------------------ | | | Branch (496:11): [Folded, False: 952] | | ------------------ ------------------ 158| 952| if ((bufev_private->eventcb_pending & BEV_EVENT_CONNECTED) && ------------------ | | 106| 952|#define BEV_EVENT_CONNECTED 0x80 /**< connect operation finished. */ ------------------ | Branch (158:6): [True: 0, False: 952] ------------------ 159| 0| bufev->errorcb) { ------------------ | Branch (159:6): [True: 0, False: 0] ------------------ 160| | /* The "connected" happened before any reads or writes, so 161| | send it first. */ 162| 0| bufev_private->eventcb_pending &= ~BEV_EVENT_CONNECTED; ------------------ | | 106| 0|#define BEV_EVENT_CONNECTED 0x80 /**< connect operation finished. */ ------------------ 163| 0| bufev->errorcb(bufev, BEV_EVENT_CONNECTED, bufev->cbarg); ------------------ | | 106| 0|#define BEV_EVENT_CONNECTED 0x80 /**< connect operation finished. */ ------------------ 164| 0| } 165| 952| if (bufev_private->readcb_pending && bufev->readcb) { ------------------ | Branch (165:6): [True: 952, False: 0] | Branch (165:39): [True: 952, False: 0] ------------------ 166| 952| bufev_private->readcb_pending = 0; 167| 952| bufev->readcb(bufev, bufev->cbarg); 168| 952| bufferevent_inbuf_wm_check(bufev); 169| 952| } 170| 952| if (bufev_private->writecb_pending && bufev->writecb) { ------------------ | Branch (170:6): [True: 0, False: 952] | Branch (170:40): [True: 0, False: 0] ------------------ 171| 0| bufev_private->writecb_pending = 0; 172| 0| bufev->writecb(bufev, bufev->cbarg); 173| 0| } 174| 952| if (bufev_private->eventcb_pending && bufev->errorcb) { ------------------ | Branch (174:6): [True: 0, False: 952] | Branch (174:40): [True: 0, False: 0] ------------------ 175| 0| short what = bufev_private->eventcb_pending; 176| 0| int err = bufev_private->errno_pending; 177| 0| bufev_private->eventcb_pending = 0; 178| 0| bufev_private->errno_pending = 0; 179| | EVUTIL_SET_SOCKET_ERROR(err); ------------------ | | 564| 0| do { errno = (errcode); } while (0) | | ------------------ | | | Branch (564:36): [Folded, False: 0] | | ------------------ ------------------ 180| 0| bufev->errorcb(bufev, what, bufev->cbarg); 181| 0| } 182| 952| bufferevent_decref_and_unlock_(bufev); 183| 952|} bufferevent.c:bufferevent_finalize_cb_: 753| 1.90k|{ 754| 1.90k| struct bufferevent *bufev = arg_; 755| 1.90k| struct bufferevent *underlying; 756| 1.90k| struct bufferevent_private *bufev_private = BEV_UPCAST(bufev); ------------------ | | 486| 1.90k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | ------------------ | | | | 289| 1.90k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | ------------------ | | | | | | 625| 1.90k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | ------------------ | | ------------------ ------------------ 757| | 758| 1.90k| BEV_LOCK(bufev); ------------------ | | 493| 1.90k|#define BEV_LOCK(b) do { \ | | 494| 1.90k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 486| 1.90k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 1.90k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 1.90k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 495| 1.90k| EVLOCK_LOCK(locking->lock, 0); \ | | ------------------ | | | | 94| 1.90k| do { \ | | | | 95| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 96| 1.90k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 496| 1.90k| } while (0) | | ------------------ | | | Branch (496:11): [Folded, False: 1.90k] | | ------------------ ------------------ 759| 1.90k| underlying = bufferevent_get_underlying(bufev); 760| | 761| | /* Clean up the shared info */ 762| 1.90k| if (bufev->be_ops->destruct) ------------------ | Branch (762:6): [True: 1.90k, False: 0] ------------------ 763| 1.90k| bufev->be_ops->destruct(bufev); 764| | 765| | /* XXX what happens if refcnt for these buffers is > 1? 766| | * The buffers can share a lock with this bufferevent object, 767| | * but the lock might be destroyed below. */ 768| | /* evbuffer will free the callbacks */ 769| 1.90k| evbuffer_free(bufev->input); 770| 1.90k| evbuffer_free(bufev->output); 771| | 772| 1.90k| if (bufev_private->rate_limiting) { ------------------ | Branch (772:6): [True: 0, False: 1.90k] ------------------ 773| 0| if (bufev_private->rate_limiting->group) ------------------ | Branch (773:7): [True: 0, False: 0] ------------------ 774| 0| bufferevent_remove_from_rate_limit_group_internal_(bufev,0); 775| 0| mm_free(bufev_private->rate_limiting); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 776| 0| bufev_private->rate_limiting = NULL; 777| 0| } 778| | 779| | 780| 1.90k| BEV_UNLOCK(bufev); ------------------ | | 499| 1.90k|#define BEV_UNLOCK(b) do { \ | | 500| 1.90k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 486| 1.90k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 1.90k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 1.90k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 501| 1.90k| EVLOCK_UNLOCK(locking->lock, 0); \ | | ------------------ | | | | 101| 1.90k| do { \ | | | | 102| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 103| 1.90k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 502| 1.90k| } while (0) | | ------------------ | | | Branch (502:11): [Folded, False: 1.90k] | | ------------------ ------------------ 781| | 782| 1.90k| if (bufev_private->own_lock) ------------------ | Branch (782:6): [True: 0, False: 1.90k] ------------------ 783| 0| EVTHREAD_FREE_LOCK(bufev_private->lock, ------------------ | | 86| 0| do { \ | | 87| 0| void *lock_tmp_ = (lockvar); \ | | 88| 0| if (lock_tmp_ && evthread_lock_fns_.free) \ | | ------------------ | | | Branch (88:7): [True: 0, False: 0] | | | Branch (88:20): [True: 0, False: 0] | | ------------------ | | 89| 0| evthread_lock_fns_.free(lock_tmp_, (locktype)); \ | | 90| 0| } while (0) | | ------------------ | | | Branch (90:11): [Folded, False: 0] | | ------------------ ------------------ 784| 1.90k| EVTHREAD_LOCKTYPE_RECURSIVE); 785| | 786| | /* Free the actual allocated memory. */ 787| 1.90k| mm_free(((char*)bufev) - bufev->be_ops->mem_offset); ------------------ | | 80| 1.90k|#define mm_free(p) event_mm_free_(p) ------------------ 788| | 789| | /* Release the reference to underlying now that we no longer need the 790| | * reference to it. We wait this long mainly in case our lock is 791| | * shared with underlying. 792| | * 793| | * The 'destruct' function will also drop a reference to underlying 794| | * if BEV_OPT_CLOSE_ON_FREE is set. 795| | * 796| | * XXX Should we/can we just refcount evbuffer/bufferevent locks? 797| | * It would probably save us some headaches. 798| | */ 799| 1.90k| if (underlying) ------------------ | Branch (799:6): [True: 0, False: 1.90k] ------------------ 800| 0| bufferevent_decref_(underlying); ------------------ | | 385| 0|#define bufferevent_decref_(bufev) bufferevent_decref(bufev) ------------------ 801| 1.90k|} bufferevent.c:bufferevent_cancel_all_: 942| 1.90k|{ 943| 1.90k| union bufferevent_ctrl_data d; 944| 1.90k| memset(&d, 0, sizeof(d)); 945| 1.90k| BEV_LOCK(bev); ------------------ | | 493| 1.90k|#define BEV_LOCK(b) do { \ | | 494| 1.90k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 486| 1.90k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 1.90k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 1.90k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 495| 1.90k| EVLOCK_LOCK(locking->lock, 0); \ | | ------------------ | | | | 94| 1.90k| do { \ | | | | 95| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 96| 1.90k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 496| 1.90k| } while (0) | | ------------------ | | | Branch (496:11): [Folded, False: 1.90k] | | ------------------ ------------------ 946| 1.90k| if (bev->be_ops->ctrl) ------------------ | Branch (946:6): [True: 0, False: 1.90k] ------------------ 947| 0| bev->be_ops->ctrl(bev, BEV_CTRL_CANCEL_ALL, &d); 948| | BEV_UNLOCK(bev); ------------------ | | 499| 1.90k|#define BEV_UNLOCK(b) do { \ | | 500| 1.90k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 486| 1.90k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 1.90k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 1.90k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 501| 1.90k| EVLOCK_UNLOCK(locking->lock, 0); \ | | ------------------ | | | | 101| 1.90k| do { \ | | | | 102| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 103| 1.90k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 502| 1.90k| } while (0) | | ------------------ | | | Branch (502:11): [Folded, False: 1.90k] | | ------------------ ------------------ 949| 1.90k|} bufferevent_pair_new: 115| 952|{ 116| 952| struct bufferevent_pair *bufev1 = NULL, *bufev2 = NULL; 117| 952| int tmp_options; 118| | 119| 952| options |= BEV_OPT_DEFER_CALLBACKS; 120| 952| tmp_options = options & ~BEV_OPT_THREADSAFE; 121| | 122| 952| bufev1 = bufferevent_pair_elt_new(base, options); 123| 952| if (!bufev1) ------------------ | Branch (123:6): [True: 0, False: 952] ------------------ 124| 0| return -1; 125| 952| bufev2 = bufferevent_pair_elt_new(base, tmp_options); 126| 952| if (!bufev2) { ------------------ | Branch (126:6): [True: 0, False: 952] ------------------ 127| 0| bufferevent_free(downcast(bufev1)); ------------------ | | 64| 0|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 128| 0| return -1; 129| 0| } 130| | 131| 952| if (options & BEV_OPT_THREADSAFE) { ------------------ | Branch (131:6): [True: 0, False: 952] ------------------ 132| | /*XXXX check return */ 133| 0| bufferevent_enable_locking_(downcast(bufev2), bufev1->bev.lock); ------------------ | | 64| 0|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 134| 0| } 135| | 136| 952| bufev1->partner = bufev2; 137| 952| bufev2->partner = bufev1; 138| | 139| 952| evbuffer_freeze(downcast(bufev1)->input, 0); ------------------ | | 64| 952|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 140| 952| evbuffer_freeze(downcast(bufev1)->output, 1); ------------------ | | 64| 952|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 141| 952| evbuffer_freeze(downcast(bufev2)->input, 0); ------------------ | | 64| 952|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 142| 952| evbuffer_freeze(downcast(bufev2)->output, 1); ------------------ | | 64| 952|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 143| | 144| 952| pair[0] = downcast(bufev1); ------------------ | | 64| 952|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 145| 952| pair[1] = downcast(bufev2); ------------------ | | 64| 952|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 146| | 147| 952| return 0; 148| 952|} bufferevent_pair.c:bufferevent_pair_elt_new: 93| 1.90k|{ 94| 1.90k| struct bufferevent_pair *bufev; 95| 1.90k| if (! (bufev = mm_calloc(1, sizeof(struct bufferevent_pair)))) ------------------ | | 77| 1.90k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ | Branch (95:6): [True: 0, False: 1.90k] ------------------ 96| 0| return NULL; 97| 1.90k| if (bufferevent_init_common_(&bufev->bev, base, &bufferevent_ops_pair, ------------------ | Branch (97:6): [True: 0, False: 1.90k] ------------------ 98| 1.90k| options)) { 99| 0| mm_free(bufev); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 100| 0| return NULL; 101| 0| } 102| 1.90k| if (!evbuffer_add_cb(bufev->bev.bev.output, be_pair_outbuf_cb, bufev)) { ------------------ | Branch (102:6): [True: 0, False: 1.90k] ------------------ 103| 0| bufferevent_free(downcast(bufev)); ------------------ | | 64| 0|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 104| 0| return NULL; 105| 0| } 106| | 107| 1.90k| bufferevent_init_generic_timeout_cbs_(&bufev->bev.bev); 108| | 109| 1.90k| return bufev; 110| 1.90k|} bufferevent_pair.c:be_pair_outbuf_cb: 205| 7.27k|{ 206| 7.27k| struct bufferevent_pair *bev_pair = arg; 207| 7.27k| struct bufferevent_pair *partner = bev_pair->partner; 208| | 209| 7.27k| incref_and_lock(downcast(bev_pair)); ------------------ | | 64| 7.27k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 210| | 211| 7.27k| if (info->n_added > info->n_deleted && partner) { ------------------ | Branch (211:6): [True: 6.31k, False: 952] | Branch (211:41): [True: 6.31k, False: 0] ------------------ 212| | /* We got more data. If the other side's reading, then 213| | hand it over. */ 214| 6.31k| if (be_pair_wants_to_talk(bev_pair, partner)) { ------------------ | Branch (214:7): [True: 952, False: 5.36k] ------------------ 215| 952| be_pair_transfer(downcast(bev_pair), downcast(partner), 0); ------------------ | | 64| 952|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ be_pair_transfer(downcast(bev_pair), downcast(partner), 0); ------------------ | | 64| 952|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 216| 952| } 217| 6.31k| } 218| | 219| 7.27k| decref_and_unlock(downcast(bev_pair)); ------------------ | | 64| 7.27k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 220| 7.27k|} bufferevent_pair.c:be_pair_wants_to_talk: 195| 8.22k|{ 196| 8.22k| return (downcast(src)->enabled & EV_WRITE) && ------------------ | | 64| 8.22k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ return (downcast(src)->enabled & EV_WRITE) && ------------------ | | 959| 8.22k|#define EV_WRITE 0x04 ------------------ | Branch (196:9): [True: 8.22k, False: 0] ------------------ 197| 8.22k| (downcast(dst)->enabled & EV_READ) && ------------------ | | 64| 8.22k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ (downcast(dst)->enabled & EV_READ) && ------------------ | | 957| 8.22k|#define EV_READ 0x02 ------------------ | Branch (197:6): [True: 1.90k, False: 6.31k] ------------------ 198| 1.90k| !dst->bev.read_suspended && ------------------ | Branch (198:6): [True: 1.90k, False: 0] ------------------ 199| 1.90k| evbuffer_get_length(downcast(src)->output); ------------------ | | 64| 1.90k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ | Branch (199:6): [True: 952, False: 952] ------------------ 200| 8.22k|} bufferevent_pair.c:be_pair_transfer: 153| 952|{ 154| 952| size_t dst_size; 155| 952| size_t n; 156| | 157| 952| evbuffer_unfreeze(src->output, 1); 158| 952| evbuffer_unfreeze(dst->input, 0); 159| | 160| 952| if (dst->wm_read.high) { ------------------ | Branch (160:6): [True: 0, False: 952] ------------------ 161| 0| dst_size = evbuffer_get_length(dst->input); 162| 0| if (dst_size < dst->wm_read.high) { ------------------ | Branch (162:7): [True: 0, False: 0] ------------------ 163| 0| n = dst->wm_read.high - dst_size; 164| 0| evbuffer_remove_buffer(src->output, dst->input, n); 165| 0| } else { 166| 0| if (!ignore_wm) ------------------ | Branch (166:8): [True: 0, False: 0] ------------------ 167| 0| goto done; 168| 0| n = evbuffer_get_length(src->output); 169| 0| evbuffer_add_buffer(dst->input, src->output); 170| 0| } 171| 952| } else { 172| 952| n = evbuffer_get_length(src->output); 173| 952| evbuffer_add_buffer(dst->input, src->output); 174| 952| } 175| | 176| 952| if (n) { ------------------ | Branch (176:6): [True: 952, False: 0] ------------------ 177| 952| BEV_RESET_GENERIC_READ_TIMEOUT(dst); ------------------ | | 467| 952| do { \ | | 468| 952| if (evutil_timerisset(&(bev)->timeout_read)) \ | | ------------------ | | | | 618| 952|#define evutil_timerisset(tvp) timerisset(tvp) | | ------------------ | | 469| 952| event_add(&(bev)->ev_read, &(bev)->timeout_read); \ | | 470| 952| } while (0) | | ------------------ | | | Branch (470:11): [Folded, False: 952] | | ------------------ ------------------ | Branch (177:3): [True: 0, False: 952] ------------------ 178| | 179| 952| if (evbuffer_get_length(dst->output)) ------------------ | Branch (179:7): [True: 952, False: 0] ------------------ 180| 952| BEV_RESET_GENERIC_WRITE_TIMEOUT(dst); ------------------ | | 474| 952| do { \ | | 475| 952| if (evutil_timerisset(&(bev)->timeout_write)) \ | | ------------------ | | | | 618| 952|#define evutil_timerisset(tvp) timerisset(tvp) | | ------------------ | | 476| 952| event_add(&(bev)->ev_write, &(bev)->timeout_write); \ | | 477| 952| } while (0) | | ------------------ | | | Branch (477:11): [Folded, False: 952] | | ------------------ ------------------ | Branch (180:4): [True: 0, False: 952] ------------------ 181| 0| else 182| 0| BEV_DEL_GENERIC_WRITE_TIMEOUT(dst); ------------------ | | 481| 0| event_del(&(bev)->ev_write) ------------------ 183| 952| } 184| | 185| 952| bufferevent_trigger_nolock_(dst, EV_READ, 0); ------------------ | | 957| 952|#define EV_READ 0x02 ------------------ 186| 952| bufferevent_trigger_nolock_(src, EV_WRITE, 0); ------------------ | | 959| 952|#define EV_WRITE 0x04 ------------------ 187| 952|done: 188| 952| evbuffer_freeze(src->output, 1); 189| 952| evbuffer_freeze(dst->input, 0); 190| 952|} bufferevent_pair.c:upcast: 57| 21.2k|{ 58| 21.2k| struct bufferevent_pair *bev_p; 59| 21.2k| bev_p = EVUTIL_UPCAST(bev, struct bufferevent_pair, bev.bev); ------------------ | | 289| 21.2k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | ------------------ | | | | 625| 21.2k|#define evutil_offsetof(type, field) offsetof(type, field) | | ------------------ ------------------ 60| 21.2k| EVUTIL_ASSERT(BEV_IS_PAIR(&bev_p->bev.bev)); ------------------ | | 368| 21.2k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 21.2k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 21.2k| (void)sizeof(!(condition)); \ | | | | 98| 21.2k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 21.2k] | | | | ------------------ | | ------------------ ------------------ 61| 21.2k| return bev_p; 62| 21.2k|} bufferevent_pair.c:incref_and_lock: 68| 8.22k|{ 69| 8.22k| struct bufferevent_pair *bevp; 70| 8.22k| bufferevent_incref_and_lock_(b); 71| 8.22k| bevp = upcast(b); 72| 8.22k| if (bevp->partner) ------------------ | Branch (72:6): [True: 8.22k, False: 0] ------------------ 73| 8.22k| bufferevent_incref_and_lock_(downcast(bevp->partner)); ------------------ | | 64| 8.22k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 74| 8.22k|} bufferevent_pair.c:decref_and_unlock: 78| 8.22k|{ 79| 8.22k| struct bufferevent_pair *bevp = upcast(b); 80| 8.22k| if (bevp->partner) ------------------ | Branch (80:6): [True: 8.22k, False: 0] ------------------ 81| 8.22k| bufferevent_decref_and_unlock_(downcast(bevp->partner)); ------------------ | | 64| 8.22k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 82| 8.22k| bufferevent_decref_and_unlock_(b); 83| 8.22k|} bufferevent_pair.c:be_pair_enable: 224| 952|{ 225| 952| struct bufferevent_pair *bev_p = upcast(bufev); 226| 952| struct bufferevent_pair *partner = bev_p->partner; 227| | 228| 952| incref_and_lock(bufev); 229| | 230| 952| if (events & EV_READ) { ------------------ | | 957| 952|#define EV_READ 0x02 ------------------ | Branch (230:6): [True: 952, False: 0] ------------------ 231| 952| BEV_RESET_GENERIC_READ_TIMEOUT(bufev); ------------------ | | 467| 952| do { \ | | 468| 952| if (evutil_timerisset(&(bev)->timeout_read)) \ | | ------------------ | | | | 618| 952|#define evutil_timerisset(tvp) timerisset(tvp) | | ------------------ | | 469| 952| event_add(&(bev)->ev_read, &(bev)->timeout_read); \ | | 470| 952| } while (0) | | ------------------ | | | Branch (470:11): [Folded, False: 952] | | ------------------ ------------------ | Branch (231:3): [True: 0, False: 952] ------------------ 232| 952| } 233| 952| if ((events & EV_WRITE) && evbuffer_get_length(bufev->output)) ------------------ | | 959| 952|#define EV_WRITE 0x04 ------------------ | Branch (233:6): [True: 952, False: 0] | Branch (233:29): [True: 952, False: 0] ------------------ 234| 952| BEV_RESET_GENERIC_WRITE_TIMEOUT(bufev); ------------------ | | 474| 952| do { \ | | 475| 952| if (evutil_timerisset(&(bev)->timeout_write)) \ | | ------------------ | | | | 618| 952|#define evutil_timerisset(tvp) timerisset(tvp) | | ------------------ | | 476| 952| event_add(&(bev)->ev_write, &(bev)->timeout_write); \ | | 477| 952| } while (0) | | ------------------ | | | Branch (477:11): [Folded, False: 952] | | ------------------ ------------------ | Branch (234:3): [True: 0, False: 952] ------------------ 235| | 236| | /* We're starting to read! Does the other side have anything to write?*/ 237| 952| if ((events & EV_READ) && partner && ------------------ | | 957| 952|#define EV_READ 0x02 ------------------ | Branch (237:6): [True: 952, False: 0] | Branch (237:28): [True: 952, False: 0] ------------------ 238| 952| be_pair_wants_to_talk(partner, bev_p)) { ------------------ | Branch (238:6): [True: 0, False: 952] ------------------ 239| 0| be_pair_transfer(downcast(partner), bufev, 0); ------------------ | | 64| 0|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 240| 0| } 241| | /* We're starting to write! Does the other side want to read? */ 242| 952| if ((events & EV_WRITE) && partner && ------------------ | | 959| 952|#define EV_WRITE 0x04 ------------------ | Branch (242:6): [True: 952, False: 0] | Branch (242:29): [True: 952, False: 0] ------------------ 243| 952| be_pair_wants_to_talk(bev_p, partner)) { ------------------ | Branch (243:6): [True: 0, False: 952] ------------------ 244| 0| be_pair_transfer(bufev, downcast(partner), 0); ------------------ | | 64| 0|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 245| 0| } 246| 952| decref_and_unlock(bufev); 247| 952| return 0; 248| 952|} bufferevent_pair.c:be_pair_unlink: 264| 1.90k|{ 265| 1.90k| struct bufferevent_pair *bev_p = upcast(bev); 266| | 267| 1.90k| if (bev_p->partner) { ------------------ | Branch (267:6): [True: 952, False: 952] ------------------ 268| 952| bev_p->unlinked_partner = bev_p->partner; 269| 952| bev_p->partner->partner = NULL; 270| | bev_p->partner = NULL; 271| 952| } 272| 1.90k|} bufferevent_pair.c:be_pair_destruct: 277| 1.90k|{ 278| 1.90k| struct bufferevent_pair *bev_p = upcast(bev); 279| | 280| | /* Transfer ownership of the lock into partner, otherwise we will use 281| | * already free'd lock during freeing second bev, see next example: 282| | * 283| | * bev1->own_lock = 1 284| | * bev2->own_lock = 0 285| | * bev2->lock = bev1->lock 286| | * 287| | * bufferevent_free(bev1) # refcnt == 0 -> unlink 288| | * bufferevent_free(bev2) # refcnt == 0 -> unlink 289| | * 290| | * event_base_free() -> finalizers -> EVTHREAD_FREE_LOCK(bev1->lock) 291| | * -> BEV_LOCK(bev2->lock) <-- already freed 292| | * 293| | * Where bev1 == pair[0], bev2 == pair[1]. 294| | */ 295| 1.90k| if (bev_p->unlinked_partner && bev_p->bev.own_lock) { ------------------ | Branch (295:6): [True: 952, False: 952] | Branch (295:33): [True: 0, False: 952] ------------------ 296| 0| bev_p->unlinked_partner->bev.own_lock = 1; 297| 0| bev_p->bev.own_lock = 0; 298| 0| } 299| | bev_p->unlinked_partner = NULL; 300| 1.90k|} bufferevent_ratelim_init_: 1102| 1.90k|{ 1103| 1.90k| bev->rate_limiting = NULL; 1104| 1.90k| bev->max_single_read = MAX_SINGLE_READ_DEFAULT; ------------------ | | 199| 1.90k|#define MAX_SINGLE_READ_DEFAULT 16384 ------------------ 1105| 1.90k| bev->max_single_write = MAX_SINGLE_WRITE_DEFAULT; ------------------ | | 200| 1.90k|#define MAX_SINGLE_WRITE_DEFAULT 16384 ------------------ 1106| | 1107| 1.90k| if (evbuffer_set_max_read(bev->bev.input, bev->max_single_read)) ------------------ | Branch (1107:6): [True: 0, False: 1.90k] ------------------ 1108| 0| return -1; 1109| | 1110| 1.90k| return 0; 1111| 1.90k|} epoll.c:epoll_init: 175| 952|{ 176| 952| epoll_handle epfd = INVALID_EPOLL_HANDLE; ------------------ | | 100| 952|#define INVALID_EPOLL_HANDLE -1 ------------------ 177| 952| struct epollop *epollop; 178| | 179| 952|#ifdef EVENT__HAVE_EPOLL_CREATE1 180| | /* First, try the shiny new epoll_create1 interface, if we have it. */ 181| 952| epfd = epoll_create1(EPOLL_CLOEXEC); 182| 952|#endif 183| 952| if (epfd == INVALID_EPOLL_HANDLE) { ------------------ | | 100| 952|#define INVALID_EPOLL_HANDLE -1 ------------------ | Branch (183:6): [True: 0, False: 952] ------------------ 184| | /* Initialize the kernel queue using the old interface. (The 185| | size field is ignored since 2.6.8.) */ 186| 0| if ((epfd = epoll_create(32000)) == INVALID_EPOLL_HANDLE) { ------------------ | | 100| 0|#define INVALID_EPOLL_HANDLE -1 ------------------ | Branch (186:7): [True: 0, False: 0] ------------------ 187| 0| if (errno != ENOSYS) ------------------ | Branch (187:8): [True: 0, False: 0] ------------------ 188| 0| event_warn("epoll_create"); 189| 0| return (NULL); 190| 0| } 191| 0|#ifndef EVENT__HAVE_WEPOLL 192| 0| evutil_make_socket_closeonexec(epfd); 193| 0|#endif 194| 0| } 195| | 196| 952| if (!(epollop = mm_calloc(1, sizeof(struct epollop)))) { ------------------ | | 77| 952|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ | Branch (196:6): [True: 0, False: 952] ------------------ 197| 0| close_epoll_handle(epfd); 198| 0| return (NULL); 199| 0| } 200| | 201| 952| epollop->epfd = epfd; 202| | 203| | /* Initialize fields */ 204| 952| epollop->events = mm_calloc(INITIAL_NEVENT, sizeof(struct epoll_event)); ------------------ | | 77| 952|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ 205| 952| if (epollop->events == NULL) { ------------------ | Branch (205:6): [True: 0, False: 952] ------------------ 206| 0| mm_free(epollop); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 207| 0| close_epoll_handle(epfd); 208| 0| return (NULL); 209| 0| } 210| 952| epollop->nevents = INITIAL_NEVENT; ------------------ | | 162| 952|#define INITIAL_NEVENT 32 ------------------ 211| | 212| 952|#ifndef EVENT__HAVE_WEPOLL 213| 952| if ((base->flags & EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST) != 0 || ------------------ | Branch (213:6): [True: 0, False: 952] ------------------ 214| 952| ((base->flags & EVENT_BASE_FLAG_IGNORE_ENV) == 0 && ------------------ | Branch (214:7): [True: 952, False: 0] ------------------ 215| 952| evutil_getenv_("EVENT_EPOLL_USE_CHANGELIST") != NULL)) { ------------------ | Branch (215:3): [True: 0, False: 952] ------------------ 216| | 217| 0| base->evsel = &epollops_changelist; 218| 0| } 219| 952|#endif 220| | 221| 952|#ifdef USING_TIMERFD 222| | /* 223| | The epoll interface ordinarily gives us one-millisecond precision, 224| | so on Linux it makes perfect sense to use the CLOCK_MONOTONIC_COARSE 225| | timer. But when the user has set the new PRECISE_TIMER flag for an 226| | event_base, we can try to use timerfd to give them finer granularity. 227| | */ 228| 952| if ((base->flags & EVENT_BASE_FLAG_PRECISE_TIMER) && ------------------ | Branch (228:6): [True: 0, False: 952] ------------------ 229| 0| !(base->flags & EVENT_BASE_FLAG_EPOLL_DISALLOW_TIMERFD) && ------------------ | Branch (229:6): [True: 0, False: 0] ------------------ 230| 0| base->monotonic_timer.monotonic_clock == CLOCK_MONOTONIC) { ------------------ | Branch (230:6): [True: 0, False: 0] ------------------ 231| 0| int fd; 232| 0| fd = epollop->timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC); 233| 0| if (epollop->timerfd >= 0) { ------------------ | Branch (233:7): [True: 0, False: 0] ------------------ 234| 0| struct epoll_event epev; 235| 0| memset(&epev, 0, sizeof(epev)); 236| 0| epev.data.fd = epollop->timerfd; 237| 0| epev.events = EPOLLIN; 238| 0| if (epoll_ctl(epollop->epfd, EPOLL_CTL_ADD, fd, &epev) < 0) { ------------------ | Branch (238:8): [True: 0, False: 0] ------------------ 239| 0| event_warn("epoll_ctl(timerfd)"); 240| 0| close(fd); 241| 0| epollop->timerfd = -1; 242| 0| } 243| 0| } else { 244| 0| if (errno != EINVAL && errno != ENOSYS) { ------------------ | Branch (244:8): [True: 0, False: 0] | Branch (244:27): [True: 0, False: 0] ------------------ 245| | /* These errors probably mean that we were 246| | * compiled with timerfd/TFD_* support, but 247| | * we're running on a kernel that lacks those. 248| | */ 249| 0| event_warn("timerfd_create"); 250| 0| } 251| 0| epollop->timerfd = -1; 252| 0| } 253| 952| } else { 254| 952| epollop->timerfd = -1; 255| 952| } 256| 952|#endif 257| | 258| 952| if (sigfd_init_(base) < 0) ------------------ | Branch (258:6): [True: 952, False: 0] ------------------ 259| 952| evsig_init_(base); 260| | 261| 952| return (epollop); 262| 952|} epoll.c:close_epoll_handle: 101| 952|static void close_epoll_handle(int h) { close(h); } epoll.c:epoll_dispatch: 461| 952|{ 462| 952| struct epollop *epollop = base->evbase; 463| 952| struct epoll_event *events = epollop->events; 464| 952| int i, res; 465| |#if defined(EVENT__HAVE_EPOLL_PWAIT2) 466| | struct timespec ts = { 0, 0 }; 467| |#else /* no epoll_pwait2() */ 468| 952| long timeout = -1; 469| 952|#endif /* EVENT__HAVE_EPOLL_PWAIT2 */ 470| | 471| 952|#ifdef USING_TIMERFD 472| 952| if (epollop->timerfd >= 0) { ------------------ | Branch (472:6): [True: 0, False: 952] ------------------ 473| 0| struct itimerspec is; 474| 0| is.it_interval.tv_sec = 0; 475| 0| is.it_interval.tv_nsec = 0; 476| 0| if (tv == NULL) { ------------------ | Branch (476:7): [True: 0, False: 0] ------------------ 477| | /* No timeout; disarm the timer. */ 478| 0| is.it_value.tv_sec = 0; 479| 0| is.it_value.tv_nsec = 0; 480| 0| } else { 481| 0| if (tv->tv_sec == 0 && tv->tv_usec == 0) { ------------------ | Branch (481:8): [True: 0, False: 0] | Branch (481:27): [True: 0, False: 0] ------------------ 482| | /* we need to exit immediately; timerfd can't 483| | * do that. */ 484| 0| timeout = 0; 485| 0| } 486| 0| is.it_value.tv_sec = tv->tv_sec; 487| 0| is.it_value.tv_nsec = tv->tv_usec * 1000; 488| 0| } 489| | /* TODO: we could avoid unnecessary syscalls here by only 490| | calling timerfd_settime when the top timeout changes, or 491| | when we're called with a different timeval. 492| | */ 493| 0| if (timerfd_settime(epollop->timerfd, 0, &is, NULL) < 0) { ------------------ | Branch (493:7): [True: 0, False: 0] ------------------ 494| 0| event_warn("timerfd_settime"); 495| 0| } 496| 0| } else 497| 952|#endif 498| 952| if (tv != NULL) { ------------------ | Branch (498:6): [True: 952, False: 0] ------------------ 499| |#if defined(EVENT__HAVE_EPOLL_PWAIT2) 500| | TIMEVAL_TO_TIMESPEC(tv, &ts); 501| |#else /* no epoll_pwait2() */ 502| 952| timeout = evutil_tv_to_msec_(tv); 503| 952| if (timeout < 0 || timeout > MAX_EPOLL_TIMEOUT_MSEC) { ------------------ | | 171| 952|#define MAX_EPOLL_TIMEOUT_MSEC (35*60*1000) ------------------ | Branch (503:7): [True: 0, False: 952] | Branch (503:22): [True: 0, False: 952] ------------------ 504| | /* Linux kernels can wait forever if the timeout is 505| | * too big; see comment on MAX_EPOLL_TIMEOUT_MSEC. */ 506| 0| timeout = MAX_EPOLL_TIMEOUT_MSEC; ------------------ | | 171| 0|#define MAX_EPOLL_TIMEOUT_MSEC (35*60*1000) ------------------ 507| 0| } 508| 952|#endif /* EVENT__HAVE_EPOLL_PWAIT2 */ 509| 952| } 510| | 511| 952| epoll_apply_changes(base); 512| 952| event_changelist_remove_all_(&base->changelist, base); 513| | 514| 952| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 952|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 952| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 952| do { \ | | | | 102| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 952] | | | | ------------------ | | | | 103| 952| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 952| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 952] | | | | ------------------ | | ------------------ | | 125| 952| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 952] | | ------------------ ------------------ 515| | 516| |#if defined(EVENT__HAVE_EPOLL_PWAIT2) 517| | res = epoll_pwait2(epollop->epfd, events, epollop->nevents, tv ? &ts : NULL, NULL); 518| |#else /* no epoll_pwait2() */ 519| 952| res = epoll_wait(epollop->epfd, events, epollop->nevents, timeout); 520| 952|#endif /* EVENT__HAVE_EPOLL_PWAIT2 */ 521| | 522| 952| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 952|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 952| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 952| do { \ | | | | 95| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 952] | | | | ------------------ | | | | 96| 952| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 952| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 952] | | | | ------------------ | | ------------------ | | 120| 952| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 952] | | ------------------ ------------------ 523| | 524| 952| if (res == -1) { ------------------ | Branch (524:6): [True: 0, False: 952] ------------------ 525| 0| if (errno != EINTR) { ------------------ | Branch (525:7): [True: 0, False: 0] ------------------ 526| 0| event_warn("epoll_wait"); 527| 0| return (-1); 528| 0| } 529| | 530| 0| return (0); 531| 0| } 532| | 533| 952| event_debug(("%s: epoll_wait reports %d", __func__, res)); ------------------ | | 79| 952|#define event_debug(x) do { \ | | 80| 952| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 952|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 952] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 952| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 952] | | ------------------ ------------------ 534| 952| EVUTIL_ASSERT(res <= epollop->nevents); ------------------ | | 368| 952|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 952|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 952| (void)sizeof(!(condition)); \ | | | | 98| 952|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 952] | | | | ------------------ | | ------------------ ------------------ 535| | 536| 952| for (i = 0; i < res; i++) { ------------------ | Branch (536:14): [True: 0, False: 952] ------------------ 537| 0| int what = events[i].events; 538| 0| short ev = 0; 539| 0|#ifdef USING_TIMERFD 540| 0| if (events[i].data.fd == epollop->timerfd) ------------------ | Branch (540:7): [True: 0, False: 0] ------------------ 541| 0| continue; 542| 0|#endif 543| | 544| 0| if (what & EPOLLERR) { ------------------ | Branch (544:7): [True: 0, False: 0] ------------------ 545| 0| ev = EV_READ | EV_WRITE; ------------------ | | 957| 0|#define EV_READ 0x02 ------------------ ev = EV_READ | EV_WRITE; ------------------ | | 959| 0|#define EV_WRITE 0x04 ------------------ 546| 0| } else if ((what & EPOLLHUP) && !(what & EPOLLRDHUP)) { ------------------ | Branch (546:14): [True: 0, False: 0] | Branch (546:35): [True: 0, False: 0] ------------------ 547| 0| ev = EV_READ | EV_WRITE; ------------------ | | 957| 0|#define EV_READ 0x02 ------------------ ev = EV_READ | EV_WRITE; ------------------ | | 959| 0|#define EV_WRITE 0x04 ------------------ 548| 0| } else { 549| 0| if (what & EPOLLIN) ------------------ | Branch (549:8): [True: 0, False: 0] ------------------ 550| 0| ev |= EV_READ; ------------------ | | 957| 0|#define EV_READ 0x02 ------------------ 551| 0| if (what & EPOLLOUT) ------------------ | Branch (551:8): [True: 0, False: 0] ------------------ 552| 0| ev |= EV_WRITE; ------------------ | | 959| 0|#define EV_WRITE 0x04 ------------------ 553| 0| if (what & EPOLLRDHUP) ------------------ | Branch (553:8): [True: 0, False: 0] ------------------ 554| 0| ev |= EV_CLOSED; ------------------ | | 988| 0|#define EV_CLOSED 0x80 ------------------ 555| 0| } 556| | 557| 0| if (!ev) ------------------ | Branch (557:7): [True: 0, False: 0] ------------------ 558| 0| continue; 559| | 560| |#ifdef EVENT__HAVE_WEPOLL 561| | evmap_io_active_(base, events[i].data.sock, ev); 562| |#else 563| 0| evmap_io_active_(base, events[i].data.fd, ev | EV_ET); ------------------ | | 970| 0|#define EV_ET 0x20 ------------------ 564| 0|#endif 565| 0| } 566| | 567| 952| if (res == epollop->nevents && epollop->nevents < MAX_NEVENT) { ------------------ | | 163| 0|#define MAX_NEVENT 4096 ------------------ | Branch (567:6): [True: 0, False: 952] | Branch (567:33): [True: 0, False: 0] ------------------ 568| | /* We used all of the event space this time. We should 569| | be ready for more events next time. */ 570| 0| int new_nevents = epollop->nevents * 2; 571| 0| struct epoll_event *new_events; 572| | 573| 0| new_events = mm_realloc(epollop->events, ------------------ | | 79| 0|#define mm_realloc(p, sz) event_mm_realloc_((p), (sz)) ------------------ 574| 0| new_nevents * sizeof(struct epoll_event)); 575| 0| if (new_events) { ------------------ | Branch (575:7): [True: 0, False: 0] ------------------ 576| 0| epollop->events = new_events; 577| 0| epollop->nevents = new_nevents; 578| 0| } 579| 0| } 580| | 581| 952| return (0); 582| 952|} epoll.c:epoll_apply_changes: 400| 952|{ 401| 952| struct event_changelist *changelist = &base->changelist; 402| 952| struct epollop *epollop = base->evbase; 403| 952| struct event_change *ch; 404| | 405| 952| int r = 0; 406| 952| int i; 407| | 408| 952| for (i = 0; i < changelist->n_changes; ++i) { ------------------ | Branch (408:14): [True: 0, False: 952] ------------------ 409| 0| ch = &changelist->changes[i]; 410| 0| if (epoll_apply_one_change(base, epollop, ch) < 0) ------------------ | Branch (410:7): [True: 0, False: 0] ------------------ 411| 0| r = -1; 412| 0| } 413| | 414| 952| return (r); 415| 952|} epoll.c:epoll_dealloc: 587| 952|{ 588| 952| struct epollop *epollop = base->evbase; 589| | 590| 952| evsig_dealloc_(base); 591| 952| if (epollop->events) ------------------ | Branch (591:6): [True: 952, False: 0] ------------------ 592| 952| mm_free(epollop->events); ------------------ | | 80| 952|#define mm_free(p) event_mm_free_(p) ------------------ 593| 952| if (epollop->epfd != INVALID_EPOLL_HANDLE) ------------------ | | 100| 952|#define INVALID_EPOLL_HANDLE -1 ------------------ | Branch (593:6): [True: 952, False: 0] ------------------ 594| 952| close_epoll_handle(epollop->epfd); 595| 952|#ifdef USING_TIMERFD 596| 952| if (epollop->timerfd >= 0) ------------------ | Branch (596:6): [True: 0, False: 952] ------------------ 597| 0| close(epollop->timerfd); 598| 952|#endif 599| | 600| 952| memset(epollop, 0, sizeof(struct epollop)); 601| 952| mm_free(epollop); ------------------ | | 80| 952|#define mm_free(p) event_mm_free_(p) ------------------ 602| 952|} event_base_new: 541| 952|{ 542| 952| struct event_base *base = NULL; 543| 952| struct event_config *cfg = event_config_new(); 544| 952| if (cfg) { ------------------ | Branch (544:6): [True: 952, False: 0] ------------------ 545| 952| base = event_base_new_with_config(cfg); 546| 952| event_config_free(cfg); 547| 952| } 548| 952| return base; 549| 952|} event_base_new_with_config: 626| 952|{ 627| 952| int i; 628| 952| struct event_base *base; 629| 952| int should_check_environment; 630| | /* event_base_new_with_config() should always be first to set event_debug_mode_too_late */ 631| 952|#ifndef EVENT__DISABLE_DEBUG_MODE 632| 952| EVLOCK_LOCK(event_debug_map_lock_, 0); ------------------ | | 94| 952| do { \ | | 95| 952| if (lockvar) \ | | ------------------ | | | Branch (95:7): [True: 0, False: 952] | | ------------------ | | 96| 952| evthread_lock_fns_.lock(mode, lockvar); \ | | 97| 952| } while (0) | | ------------------ | | | Branch (97:11): [Folded, False: 952] | | ------------------ ------------------ 633| 952| if (!event_debug_mode_too_late) ------------------ | Branch (633:6): [True: 1, False: 951] ------------------ 634| 1| event_debug_mode_too_late = 1; 635| 952| EVLOCK_UNLOCK(event_debug_map_lock_, 0); ------------------ | | 101| 952| do { \ | | 102| 952| if (lockvar) \ | | ------------------ | | | Branch (102:7): [True: 0, False: 952] | | ------------------ | | 103| 952| evthread_lock_fns_.unlock(mode, lockvar); \ | | 104| 952| } while (0) | | ------------------ | | | Branch (104:11): [Folded, False: 952] | | ------------------ ------------------ 636| 952|#endif 637| | 638| 952| if ((base = mm_calloc(1, sizeof(struct event_base))) == NULL) { ------------------ | | 77| 952|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ | Branch (638:6): [True: 0, False: 952] ------------------ 639| 0| event_warn("%s: calloc", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 640| 0| return NULL; 641| 0| } 642| | 643| 952| if (cfg) ------------------ | Branch (643:6): [True: 952, False: 0] ------------------ 644| 952| base->flags = cfg->flags; 645| | 646| 952| should_check_environment = 647| 952| !(cfg && (cfg->flags & EVENT_BASE_FLAG_IGNORE_ENV)); ------------------ | Branch (647:8): [True: 952, False: 0] | Branch (647:15): [True: 0, False: 952] ------------------ 648| | 649| 952| { 650| 952| struct timeval tmp; 651| 952| int precise_time = 652| 952| cfg && (cfg->flags & EVENT_BASE_FLAG_PRECISE_TIMER); ------------------ | Branch (652:7): [True: 952, False: 0] | Branch (652:14): [True: 0, False: 952] ------------------ 653| 952| int flags; 654| 952| if (should_check_environment && !precise_time) { ------------------ | Branch (654:7): [True: 952, False: 0] | Branch (654:35): [True: 952, False: 0] ------------------ 655| 952| precise_time = evutil_getenv_("EVENT_PRECISE_TIMER") != NULL; 656| 952| if (precise_time) { ------------------ | Branch (656:8): [True: 0, False: 952] ------------------ 657| 0| base->flags |= EVENT_BASE_FLAG_PRECISE_TIMER; 658| 0| } 659| 952| } 660| 952| flags = precise_time ? EV_MONOT_PRECISE : 0; ------------------ | | 346| 0|#define EV_MONOT_PRECISE 1 ------------------ | Branch (660:11): [True: 0, False: 952] ------------------ 661| 952| evutil_configure_monotonic_time_(&base->monotonic_timer, flags); 662| | 663| 952| gettime(base, &tmp); 664| 952| } 665| | 666| 952| min_heap_ctor_(&base->timeheap); 667| | 668| 952| base->sig.ev_signal_pair[0] = -1; 669| 952| base->sig.ev_signal_pair[1] = -1; 670| 952| base->th_notify_fd[0] = -1; 671| 952| base->th_notify_fd[1] = -1; 672| | 673| 952| TAILQ_INIT(&base->active_later_queue); ------------------ | | 317| 952|#define TAILQ_INIT(head) do { \ | | 318| 952| (head)->tqh_first = NULL; \ | | 319| 952| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 952|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 952] | | ------------------ ------------------ 674| | 675| 952| evmap_io_initmap_(&base->io); 676| 952| evmap_signal_initmap_(&base->sigmap); 677| 952| event_changelist_init_(&base->changelist); 678| | 679| 952| base->evbase = NULL; 680| | 681| 952| if (cfg) { ------------------ | Branch (681:6): [True: 952, False: 0] ------------------ 682| 952| memcpy(&base->max_dispatch_time, 683| 952| &cfg->max_dispatch_interval, sizeof(struct timeval)); 684| 952| base->limit_callbacks_after_prio = 685| 952| cfg->limit_callbacks_after_prio; 686| 952| } else { 687| 0| base->max_dispatch_time.tv_sec = -1; 688| 0| base->limit_callbacks_after_prio = 1; 689| 0| } 690| 952| if (cfg && cfg->max_dispatch_callbacks >= 0) { ------------------ | Branch (690:6): [True: 952, False: 0] | Branch (690:13): [True: 952, False: 0] ------------------ 691| 952| base->max_dispatch_callbacks = cfg->max_dispatch_callbacks; 692| 952| } else { 693| 0| base->max_dispatch_callbacks = INT_MAX; 694| 0| } 695| 952| if (base->max_dispatch_callbacks == INT_MAX && ------------------ | Branch (695:6): [True: 952, False: 0] ------------------ 696| 952| base->max_dispatch_time.tv_sec == -1) ------------------ | Branch (696:6): [True: 952, False: 0] ------------------ 697| 952| base->limit_callbacks_after_prio = INT_MAX; 698| | 699| 1.90k| for (i = 0; eventops[i] && !base->evbase; i++) { ------------------ | Branch (699:14): [True: 1.90k, False: 0] | Branch (699:29): [True: 952, False: 952] ------------------ 700| 952| if (cfg != NULL) { ------------------ | Branch (700:7): [True: 952, False: 0] ------------------ 701| | /* determine if this backend should be avoided */ 702| 952| if (event_config_is_avoided_method(cfg, ------------------ | Branch (702:8): [True: 0, False: 952] ------------------ 703| 952| eventops[i]->name)) 704| 0| continue; 705| 952| if ((eventops[i]->features & cfg->require_features) ------------------ | Branch (705:8): [True: 0, False: 952] ------------------ 706| 952| != cfg->require_features) 707| 0| continue; 708| 952| } 709| | 710| | /* also obey the environment variables */ 711| 952| if (should_check_environment && ------------------ | Branch (711:7): [True: 952, False: 0] ------------------ 712| 952| event_is_method_disabled(eventops[i]->name)) ------------------ | Branch (712:7): [True: 0, False: 952] ------------------ 713| 0| continue; 714| | 715| 952| base->evsel = eventops[i]; 716| | 717| 952| base->evbase = base->evsel->init(base); 718| 952| } 719| | 720| 952| if (base->evbase == NULL) { ------------------ | Branch (720:6): [True: 0, False: 952] ------------------ 721| 0| event_warnx("%s: no event mechanism available", 722| 0| __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 723| 0| base->evsel = NULL; 724| 0| event_base_free(base); 725| 0| return NULL; 726| 0| } 727| | 728| 952| if (evutil_getenv_("EVENT_SHOW_METHOD")) ------------------ | Branch (728:6): [True: 0, False: 952] ------------------ 729| 0| event_msgx("libevent using: %s", base->evsel->name); 730| | 731| | /* allocate a single active event queue */ 732| 952| if (event_base_priority_init(base, 1) < 0) { ------------------ | Branch (732:6): [True: 0, False: 952] ------------------ 733| 0| event_base_free(base); 734| 0| return NULL; 735| 0| } 736| | 737| | /* prepare for threading */ 738| | 739| 952|#if !defined(EVENT__DISABLE_THREAD_SUPPORT) && !defined(EVENT__DISABLE_DEBUG_MODE) 740| 952| event_debug_created_threadable_ctx_ = 1; 741| 952|#endif 742| | 743| 952|#ifndef EVENT__DISABLE_THREAD_SUPPORT 744| 952| if (EVTHREAD_LOCKING_ENABLED() && ------------------ | | 183| 1.90k| (evthread_lock_fns_.lock != NULL) | | ------------------ | | | Branch (183:2): [True: 0, False: 952] | | ------------------ ------------------ 745| 0| (!cfg || !(cfg->flags & EVENT_BASE_FLAG_NOLOCK))) { ------------------ | Branch (745:7): [True: 0, False: 0] | Branch (745:15): [True: 0, False: 0] ------------------ 746| 0| int r; 747| 0| EVTHREAD_ALLOC_LOCK(base->th_base_lock, 0); ------------------ | | 81| 0| ((lockvar) = evthread_lock_fns_.alloc ? \ | | ------------------ | | | Branch (81:15): [True: 0, False: 0] | | ------------------ | | 82| 0| evthread_lock_fns_.alloc(locktype) : NULL) ------------------ 748| 0| EVTHREAD_ALLOC_COND(base->current_event_cond); ------------------ | | 154| 0| do { \ | | 155| 0| (condvar) = evthread_cond_fns_.alloc_condition ? \ | | ------------------ | | | Branch (155:15): [True: 0, False: 0] | | ------------------ | | 156| 0| evthread_cond_fns_.alloc_condition(0) : NULL; \ | | 157| 0| } while (0) | | ------------------ | | | Branch (157:11): [Folded, False: 0] | | ------------------ ------------------ 749| 0| r = evthread_make_base_notifiable(base); 750| 0| if (r<0) { ------------------ | Branch (750:7): [True: 0, False: 0] ------------------ 751| 0| event_warnx("%s: Unable to make base notifiable.", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 752| 0| event_base_free(base); 753| 0| return NULL; 754| 0| } 755| 0| } 756| 952|#endif 757| | 758| |#ifdef _WIN32 759| | if (cfg && (cfg->flags & EVENT_BASE_FLAG_STARTUP_IOCP)) 760| | event_base_start_iocp_(base, cfg->n_cpus_hint); 761| |#endif 762| | 763| | /* initialize watcher lists */ 764| 2.85k| for (i = 0; i < EVWATCH_MAX; ++i) ------------------ | | 229| 2.85k|#define EVWATCH_MAX 2 ------------------ | Branch (764:14): [True: 1.90k, False: 952] ------------------ 765| 1.90k| TAILQ_INIT(&base->watchers[i]); ------------------ | | 317| 2.85k|#define TAILQ_INIT(head) do { \ | | 318| 1.90k| (head)->tqh_first = NULL; \ | | 319| 1.90k| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 1.90k|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 1.90k] | | ------------------ ------------------ 766| | 767| 952| return (base); 768| 952|} event_base_free: 994| 952|{ 995| 952| event_base_free_(base, 1); 996| 952|} event_config_new: 1175| 952|{ 1176| 952| struct event_config *cfg = mm_calloc(1, sizeof(*cfg)); ------------------ | | 77| 952|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ 1177| | 1178| 952| if (cfg == NULL) ------------------ | Branch (1178:6): [True: 0, False: 952] ------------------ 1179| 0| return (NULL); 1180| | 1181| 952| TAILQ_INIT(&cfg->entries); ------------------ | | 317| 952|#define TAILQ_INIT(head) do { \ | | 318| 952| (head)->tqh_first = NULL; \ | | 319| 952| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 952|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 952] | | ------------------ ------------------ 1182| 952| cfg->max_dispatch_interval.tv_sec = -1; 1183| 952| cfg->max_dispatch_callbacks = INT_MAX; 1184| 952| cfg->limit_callbacks_after_prio = 1; 1185| | 1186| 952| return (cfg); 1187| 952|} event_config_free: 1199| 952|{ 1200| 952| struct event_config_entry *entry; 1201| | 1202| 952| while ((entry = TAILQ_FIRST(&cfg->entries)) != NULL) { ------------------ | | 293| 952|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (1202:9): [True: 0, False: 952] ------------------ 1203| 0| TAILQ_REMOVE(&cfg->entries, entry, next); ------------------ | | 356| 0|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 0| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 0, False: 0] | | ------------------ | | 358| 0| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 0| (elm)->field.tqe_prev; \ | | 360| 0| else \ | | 361| 0| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 0| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 0|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 0] | | ------------------ ------------------ 1204| 0| event_config_entry_free(entry); 1205| 0| } 1206| 952| mm_free(cfg); ------------------ | | 80| 952|#define mm_free(p) event_mm_free_(p) ------------------ 1207| 952|} event_base_priority_init: 1279| 952|{ 1280| 952| int i, r; 1281| 952| r = -1; 1282| | 1283| 952| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 952|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 952| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 952| do { \ | | | | 95| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 952] | | | | ------------------ | | | | 96| 952| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 952| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 952] | | | | ------------------ | | ------------------ | | 120| 952| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 952] | | ------------------ ------------------ 1284| | 1285| 952| if (N_ACTIVE_CALLBACKS(base) || npriorities < 1 ------------------ | | 451| 1.90k| ((base)->event_count_active) | | ------------------ | | | Branch (451:2): [True: 0, False: 952] | | ------------------ ------------------ | Branch (1285:34): [True: 0, False: 952] ------------------ 1286| 952| || npriorities >= EVENT_MAX_PRIORITIES) ------------------ | | 1477| 952|#define EVENT_MAX_PRIORITIES 256 ------------------ | Branch (1286:9): [True: 0, False: 952] ------------------ 1287| 0| goto err; 1288| | 1289| 952| if (npriorities == base->nactivequeues) ------------------ | Branch (1289:6): [True: 0, False: 952] ------------------ 1290| 0| goto ok; 1291| | 1292| 952| if (base->nactivequeues) { ------------------ | Branch (1292:6): [True: 0, False: 952] ------------------ 1293| 0| mm_free(base->activequeues); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 1294| 0| base->nactivequeues = 0; 1295| 0| } 1296| | 1297| | /* Allocate our priority queues */ 1298| 952| base->activequeues = (struct evcallback_list *) 1299| 952| mm_calloc(npriorities, sizeof(struct evcallback_list)); ------------------ | | 77| 952|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ 1300| 952| if (base->activequeues == NULL) { ------------------ | Branch (1300:6): [True: 0, False: 952] ------------------ 1301| 0| event_warn("%s: calloc", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 1302| 0| goto err; 1303| 0| } 1304| 952| base->nactivequeues = npriorities; 1305| | 1306| 1.90k| for (i = 0; i < base->nactivequeues; ++i) { ------------------ | Branch (1306:14): [True: 952, False: 952] ------------------ 1307| 952| TAILQ_INIT(&base->activequeues[i]); ------------------ | | 317| 952|#define TAILQ_INIT(head) do { \ | | 318| 952| (head)->tqh_first = NULL; \ | | 319| 952| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 952|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 952] | | ------------------ ------------------ 1308| 952| } 1309| | 1310| 952|ok: 1311| 952| r = 0; 1312| 952|err: 1313| 952| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 952|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 952| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 952| do { \ | | | | 102| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 952] | | | | ------------------ | | | | 103| 952| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 952| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 952] | | | | ------------------ | | ------------------ | | 125| 952| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 952] | | ------------------ ------------------ 1314| 952| return (r); 1315| 952|} event_base_get_npriorities: 1319| 1.90k|{ 1320| | 1321| 1.90k| int n; 1322| 1.90k| if (base == NULL) ------------------ | Branch (1322:6): [True: 0, False: 1.90k] ------------------ 1323| 0| base = current_base; ------------------ | | 138| 0|#define current_base event_global_current_base_ ------------------ 1324| | 1325| 1.90k| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 1.90k|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 1.90k| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 1.90k| do { \ | | | | 95| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 96| 1.90k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 120| 1.90k| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 1.90k] | | ------------------ ------------------ 1326| 1.90k| n = base->nactivequeues; 1327| 1.90k| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 1.90k|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 1.90k| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 1.90k| do { \ | | | | 102| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 103| 1.90k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 125| 1.90k| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 1.90k] | | ------------------ ------------------ 1328| 1.90k| return (n); 1329| 1.90k|} event_base_loop: 1992| 952|{ 1993| 952| const struct eventop *evsel = base->evsel; 1994| 952| struct timeval *tv_p; 1995| 952| int res, done, retval = 0; 1996| 952| struct evwatch_prepare_cb_info prepare_info; 1997| 952| struct evwatch_check_cb_info check_info = { NULL }; 1998| 952| struct evwatch *watcher; 1999| | 2000| | /* Grab the lock. We will release it inside evsel.dispatch, and again 2001| | * as we invoke watchers and user callbacks. */ 2002| 952| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 952|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 952| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 952| do { \ | | | | 95| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 952] | | | | ------------------ | | | | 96| 952| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 952| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 952] | | | | ------------------ | | ------------------ | | 120| 952| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 952] | | ------------------ ------------------ 2003| | 2004| 952| if (base->running_loop) { ------------------ | Branch (2004:6): [True: 0, False: 952] ------------------ 2005| 0| event_warnx("%s: reentrant invocation. Only one event_base_loop" 2006| 0| " can run on each event_base at once.", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 2007| 0| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 0|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 0| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 0| do { \ | | | | 102| 0| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 0] | | | | ------------------ | | | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 0| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 125| 0| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 0] | | ------------------ ------------------ 2008| 0| return -1; 2009| 0| } 2010| | 2011| 952| base->running_loop = 1; 2012| | 2013| 952| clear_time_cache(base); 2014| | 2015| 952| if (base->sig.ev_signal_added && base->sig.ev_n_signals_added) ------------------ | Branch (2015:6): [True: 0, False: 952] | Branch (2015:35): [True: 0, False: 0] ------------------ 2016| 0| evsig_set_base_(base); 2017| | 2018| 952| done = 0; 2019| | 2020| 952|#ifndef EVENT__DISABLE_THREAD_SUPPORT 2021| 952| base->th_owner_id = EVTHREAD_GET_ID(); ------------------ | | 62| 952| (evthread_id_fn_ ? evthread_id_fn_() : 1) | | ------------------ | | | Branch (62:3): [True: 0, False: 952] | | ------------------ ------------------ 2022| 952|#endif 2023| | 2024| 952| base->event_gotterm = base->event_break = 0; 2025| | 2026| 1.90k| while (!done) { ------------------ | Branch (2026:9): [True: 1.90k, False: 0] ------------------ 2027| 1.90k| struct timeval tv; 2028| | 2029| 1.90k| base->event_continue = 0; 2030| 1.90k| base->n_deferreds_queued = 0; 2031| | 2032| | /* Terminate the loop if we have been asked to */ 2033| 1.90k| if (base->event_gotterm) { ------------------ | Branch (2033:7): [True: 0, False: 1.90k] ------------------ 2034| 0| break; 2035| 0| } 2036| | 2037| 1.90k| if (base->event_break) { ------------------ | Branch (2037:7): [True: 0, False: 1.90k] ------------------ 2038| 0| break; 2039| 0| } 2040| | 2041| 1.90k| tv_p = &tv; 2042| 1.90k| if (!N_ACTIVE_CALLBACKS(base) && !(flags & EVLOOP_NONBLOCK)) { ------------------ | | 451| 3.80k| ((base)->event_count_active) ------------------ if (!N_ACTIVE_CALLBACKS(base) && !(flags & EVLOOP_NONBLOCK)) { ------------------ | | 832| 952|#define EVLOOP_NONBLOCK 0x02 ------------------ | Branch (2042:7): [True: 952, False: 952] | Branch (2042:36): [True: 0, False: 952] ------------------ 2043| 0| timeout_next(base, &tv_p); 2044| 1.90k| } else { 2045| | /* 2046| | * if we have active events, we just poll new events 2047| | * without waiting. 2048| | */ 2049| 1.90k| evutil_timerclear(&tv); ------------------ | | 604| 1.90k|#define evutil_timerclear(tvp) timerclear(tvp) ------------------ 2050| 1.90k| } 2051| | 2052| | /* If we have no events, we just exit */ 2053| 1.90k| if (0==(flags&EVLOOP_NO_EXIT_ON_EMPTY) && ------------------ | | 837| 1.90k|#define EVLOOP_NO_EXIT_ON_EMPTY 0x04 ------------------ | Branch (2053:7): [True: 1.90k, False: 0] ------------------ 2054| 1.90k| !event_haveevents(base) && !N_ACTIVE_CALLBACKS(base)) { ------------------ | | 451| 952| ((base)->event_count_active) ------------------ | Branch (2054:7): [True: 952, False: 952] | Branch (2054:34): [True: 952, False: 0] ------------------ 2055| 952| event_debug(("%s: no events registered.", __func__)); ------------------ | | 79| 952|#define event_debug(x) do { \ | | 80| 952| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 952|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 952] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 952| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 952] | | ------------------ ------------------ 2056| 952| retval = 1; 2057| 952| goto done; 2058| 952| } 2059| | 2060| 952| event_queue_make_later_events_active(base); 2061| | 2062| | /* Invoke prepare watchers before polling for events */ 2063| 952| prepare_info.timeout = tv_p; 2064| 952| TAILQ_FOREACH(watcher, &base->watchers[EVWATCH_PREPARE], next) { ------------------ | | 305| 952| for((var) = TAILQ_FIRST(head); \ | | ------------------ | | | | 293| 952|#define TAILQ_FIRST(head) ((head)->tqh_first) | | ------------------ | | 306| 952| (var) != TAILQ_END(head); \ | | ------------------ | | | | 294| 952|#define TAILQ_END(head) NULL | | ------------------ | | | Branch (306:6): [True: 0, False: 952] | | ------------------ | | 307| 952| (var) = TAILQ_NEXT(var, field)) | | ------------------ | | | | 295| 0|#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) | | ------------------ ------------------ 2065| 0| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 0|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 0| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 0| do { \ | | | | 102| 0| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 0] | | | | ------------------ | | | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 0| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 125| 0| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 0] | | ------------------ ------------------ 2066| 0| (*watcher->callback.prepare)(watcher, &prepare_info, watcher->arg); 2067| 0| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 0|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 0| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 0| do { \ | | | | 95| 0| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 0] | | | | ------------------ | | | | 96| 0| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 0| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 120| 0| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 0] | | ------------------ ------------------ 2068| 0| } 2069| | 2070| 952| clear_time_cache(base); 2071| | 2072| 952| res = evsel->dispatch(base, tv_p); 2073| | 2074| 952| if (res == -1) { ------------------ | Branch (2074:7): [True: 0, False: 952] ------------------ 2075| 0| event_debug(("%s: dispatch returned unsuccessfully.", ------------------ | | 79| 0|#define event_debug(x) do { \ | | 80| 0| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 0|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 0| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 0] | | ------------------ ------------------ 2076| 0| __func__)); 2077| 0| retval = -1; 2078| 0| goto done; 2079| 0| } 2080| | 2081| 952| update_time_cache(base); 2082| | 2083| | /* Invoke check watchers after polling for events, and before 2084| | * processing them */ 2085| 952| TAILQ_FOREACH(watcher, &base->watchers[EVWATCH_CHECK], next) { ------------------ | | 305| 952| for((var) = TAILQ_FIRST(head); \ | | ------------------ | | | | 293| 952|#define TAILQ_FIRST(head) ((head)->tqh_first) | | ------------------ | | 306| 952| (var) != TAILQ_END(head); \ | | ------------------ | | | | 294| 952|#define TAILQ_END(head) NULL | | ------------------ | | | Branch (306:6): [True: 0, False: 952] | | ------------------ | | 307| 952| (var) = TAILQ_NEXT(var, field)) | | ------------------ | | | | 295| 0|#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) | | ------------------ ------------------ 2086| 0| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 0|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 0| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 0| do { \ | | | | 102| 0| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 0] | | | | ------------------ | | | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 0| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 125| 0| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 0] | | ------------------ ------------------ 2087| 0| (*watcher->callback.check)(watcher, &check_info, watcher->arg); 2088| 0| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 0|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 0| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 0| do { \ | | | | 95| 0| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 0] | | | | ------------------ | | | | 96| 0| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 0| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 120| 0| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 0] | | ------------------ ------------------ 2089| 0| } 2090| | 2091| 952| timeout_process(base); 2092| | 2093| 952| if (N_ACTIVE_CALLBACKS(base)) { ------------------ | | 451| 952| ((base)->event_count_active) | | ------------------ | | | Branch (451:2): [True: 952, False: 0] | | ------------------ ------------------ 2094| 952| int n = event_process_active(base); 2095| 952| if ((flags & EVLOOP_ONCE) ------------------ | | 829| 952|#define EVLOOP_ONCE 0x01 ------------------ | Branch (2095:8): [True: 0, False: 952] ------------------ 2096| 0| && N_ACTIVE_CALLBACKS(base) == 0 ------------------ | | 451| 0| ((base)->event_count_active) ------------------ | Branch (2096:11): [True: 0, False: 0] ------------------ 2097| 0| && n != 0) ------------------ | Branch (2097:11): [True: 0, False: 0] ------------------ 2098| 0| done = 1; 2099| 952| } else if (flags & EVLOOP_NONBLOCK) ------------------ | | 832| 0|#define EVLOOP_NONBLOCK 0x02 ------------------ | Branch (2099:14): [True: 0, False: 0] ------------------ 2100| 0| done = 1; 2101| 952| } 2102| 0| event_debug(("%s: asked to terminate loop.", __func__)); ------------------ | | 79| 0|#define event_debug(x) do { \ | | 80| 0| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 0|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 0| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 0] | | ------------------ ------------------ 2103| | 2104| 952|done: 2105| 952| clear_time_cache(base); 2106| 952| base->running_loop = 0; 2107| | 2108| 952| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 952|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 952| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 952| do { \ | | | | 102| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 952] | | | | ------------------ | | | | 103| 952| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 952| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 952] | | | | ------------------ | | ------------------ | | 125| 952| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 952] | | ------------------ ------------------ 2109| | 2110| 952| return (retval); 2111| 0|} event_assign: 2205| 4.76k|{ 2206| 4.76k| if (!base) ------------------ | Branch (2206:6): [True: 0, False: 4.76k] ------------------ 2207| 0| base = current_base; ------------------ | | 138| 0|#define current_base event_global_current_base_ ------------------ 2208| 4.76k| if (arg == &event_self_cbarg_ptr_) ------------------ | Branch (2208:6): [True: 0, False: 4.76k] ------------------ 2209| 0| arg = ev; 2210| | 2211| 4.76k| if (!(events & EV_SIGNAL)) ------------------ | | 961| 4.76k|#define EV_SIGNAL 0x08 ------------------ | Branch (2211:6): [True: 4.76k, False: 0] ------------------ 2212| 4.76k| event_debug_assert_socket_nonblocking_(fd); 2213| 4.76k| event_debug_assert_not_added_(ev); 2214| | 2215| 4.76k| ev->ev_base = base; 2216| | 2217| 4.76k| ev->ev_callback = callback; ------------------ | | 60| 4.76k|#define ev_callback ev_evcallback.evcb_cb_union.evcb_callback ------------------ 2218| 4.76k| ev->ev_arg = arg; ------------------ | | 61| 4.76k|#define ev_arg ev_evcallback.evcb_arg ------------------ 2219| 4.76k| ev->ev_fd = fd; 2220| 4.76k| ev->ev_events = events; 2221| 4.76k| ev->ev_res = 0; 2222| 4.76k| ev->ev_flags = EVLIST_INIT; ------------------ | | 58| 4.76k|#define ev_flags ev_evcallback.evcb_flags ------------------ ev->ev_flags = EVLIST_INIT; ------------------ | | 64| 4.76k|#define EVLIST_INIT 0x80 ------------------ 2223| 4.76k| ev->ev_ncalls = 0; ------------------ | | 54| 4.76k|#define ev_ncalls ev_.ev_signal.ev_ncalls ------------------ 2224| 4.76k| ev->ev_pncalls = NULL; ------------------ | | 55| 4.76k|#define ev_pncalls ev_.ev_signal.ev_pncalls ------------------ 2225| | 2226| 4.76k| if (events & EV_SIGNAL) { ------------------ | | 961| 4.76k|#define EV_SIGNAL 0x08 ------------------ | Branch (2226:6): [True: 0, False: 4.76k] ------------------ 2227| 0| if ((events & (EV_READ|EV_WRITE|EV_CLOSED)) != 0) { ------------------ | | 957| 0|#define EV_READ 0x02 ------------------ if ((events & (EV_READ|EV_WRITE|EV_CLOSED)) != 0) { ------------------ | | 959| 0|#define EV_WRITE 0x04 ------------------ if ((events & (EV_READ|EV_WRITE|EV_CLOSED)) != 0) { ------------------ | | 988| 0|#define EV_CLOSED 0x80 ------------------ | Branch (2227:7): [True: 0, False: 0] ------------------ 2228| 0| event_warnx("%s: EV_SIGNAL is not compatible with " 2229| 0| "EV_READ, EV_WRITE or EV_CLOSED", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 2230| 0| return -1; 2231| 0| } 2232| 0| ev->ev_closure = EV_CLOSURE_EVENT_SIGNAL; ------------------ | | 59| 0|#define ev_closure ev_evcallback.evcb_closure ------------------ ev->ev_closure = EV_CLOSURE_EVENT_SIGNAL; ------------------ | | 72| 0|#define EV_CLOSURE_EVENT_SIGNAL 1 ------------------ 2233| 4.76k| } else { 2234| 4.76k| if (events & EV_PERSIST) { ------------------ | | 968| 4.76k|#define EV_PERSIST 0x10 ------------------ | Branch (2234:7): [True: 952, False: 3.80k] ------------------ 2235| 952| evutil_timerclear(&ev->ev_io_timeout); ------------------ | | 604| 952|#define evutil_timerclear(tvp) timerclear(tvp) ------------------ 2236| 952| ev->ev_closure = EV_CLOSURE_EVENT_PERSIST; ------------------ | | 59| 952|#define ev_closure ev_evcallback.evcb_closure ------------------ ev->ev_closure = EV_CLOSURE_EVENT_PERSIST; ------------------ | | 74| 952|#define EV_CLOSURE_EVENT_PERSIST 2 ------------------ 2237| 3.80k| } else { 2238| 3.80k| ev->ev_closure = EV_CLOSURE_EVENT; ------------------ | | 59| 3.80k|#define ev_closure ev_evcallback.evcb_closure ------------------ ev->ev_closure = EV_CLOSURE_EVENT; ------------------ | | 70| 3.80k|#define EV_CLOSURE_EVENT 0 ------------------ 2239| 3.80k| } 2240| 4.76k| } 2241| | 2242| 4.76k| min_heap_elem_init_(ev); 2243| | 2244| 4.76k| if (base != NULL) { ------------------ | Branch (2244:6): [True: 4.76k, False: 0] ------------------ 2245| | /* by default, we put new events into the middle priority */ 2246| 4.76k| ev->ev_pri = base->nactivequeues / 2; ------------------ | | 57| 4.76k|#define ev_pri ev_evcallback.evcb_pri ------------------ 2247| 4.76k| } 2248| | 2249| 4.76k| event_debug_note_setup_(ev); 2250| | 2251| 4.76k| return 0; 2252| 4.76k|} event_debug_unassign: 2329| 952|{ 2330| 952| event_debug_assert_not_added_(ev); 2331| 952| event_debug_note_teardown_(ev); 2332| | 2333| 952| ev->ev_flags &= ~EVLIST_INIT; ------------------ | | 58| 952|#define ev_flags ev_evcallback.evcb_flags ------------------ ev->ev_flags &= ~EVLIST_INIT; ------------------ | | 64| 952|#define EVLIST_INIT 0x80 ------------------ 2334| 952|} event_callback_finalize_nolock_: 2381| 1.90k|{ 2382| 1.90k| struct event *ev = NULL; 2383| 1.90k| if (evcb->evcb_flags & EVLIST_INIT) { ------------------ | | 64| 1.90k|#define EVLIST_INIT 0x80 ------------------ | Branch (2383:6): [True: 1.90k, False: 0] ------------------ 2384| 1.90k| ev = event_callback_to_event(evcb); 2385| 1.90k| event_del_nolock_(ev, EVENT_DEL_NOBLOCK); ------------------ | | 461| 1.90k|#define EVENT_DEL_NOBLOCK 0 ------------------ 2386| 1.90k| } else { 2387| 0| event_callback_cancel_nolock_(base, evcb, 0); /*XXX can this fail?*/ 2388| 0| } 2389| | 2390| 1.90k| evcb->evcb_closure = EV_CLOSURE_CB_FINALIZE; ------------------ | | 78| 1.90k|#define EV_CLOSURE_CB_FINALIZE 4 ------------------ 2391| 1.90k| evcb->evcb_cb_union.evcb_cbfinalize = cb; 2392| 1.90k| event_callback_activate_nolock_(base, evcb); /* XXX can this really fail?*/ 2393| 1.90k| evcb->evcb_flags |= EVLIST_FINALIZING; ------------------ | | 63| 1.90k|#define EVLIST_FINALIZING 0x40 ------------------ 2394| 1.90k|} event_callback_finalize_many_: 2409| 1.90k|{ 2410| 1.90k| int n_pending = 0, i; 2411| | 2412| 1.90k| if (base == NULL) ------------------ | Branch (2412:6): [True: 0, False: 1.90k] ------------------ 2413| 0| base = current_base; ------------------ | | 138| 0|#define current_base event_global_current_base_ ------------------ 2414| | 2415| 1.90k| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 1.90k|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 1.90k| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 1.90k| do { \ | | | | 95| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 96| 1.90k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 120| 1.90k| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 1.90k] | | ------------------ ------------------ 2416| | 2417| 1.90k| event_debug(("%s: %d events finalizing", __func__, n_cbs)); ------------------ | | 79| 1.90k|#define event_debug(x) do { \ | | 80| 1.90k| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 1.90k|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 1.90k] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 1.90k| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 1.90k] | | ------------------ ------------------ 2418| | 2419| | /* At most one can be currently executing; the rest we just 2420| | * cancel... But we always make sure that the finalize callback 2421| | * runs. */ 2422| 7.61k| for (i = 0; i < n_cbs; ++i) { ------------------ | Branch (2422:14): [True: 5.71k, False: 1.90k] ------------------ 2423| 5.71k| struct event_callback *evcb = evcbs[i]; 2424| 5.71k| if (evcb == base->current_event) { ------------------ | Branch (2424:7): [True: 0, False: 5.71k] ------------------ 2425| 0| event_callback_finalize_nolock_(base, 0, evcb, cb); 2426| 0| ++n_pending; 2427| 5.71k| } else { 2428| 5.71k| event_callback_cancel_nolock_(base, evcb, 0); 2429| 5.71k| } 2430| 5.71k| } 2431| | 2432| 1.90k| if (n_pending == 0) { ------------------ | Branch (2432:6): [True: 1.90k, False: 0] ------------------ 2433| | /* Just do the first one. */ 2434| 1.90k| event_callback_finalize_nolock_(base, 0, evcbs[0], cb); 2435| 1.90k| } 2436| | 2437| 1.90k| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 1.90k|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 1.90k| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 1.90k| do { \ | | | | 102| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 103| 1.90k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 125| 1.90k| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 1.90k] | | ------------------ ------------------ 2438| 1.90k| return 0; 2439| 1.90k|} event_priority_set: 2448| 952|{ 2449| 952| event_debug_assert_is_setup_(ev); 2450| | 2451| 952| if (ev->ev_flags & EVLIST_ACTIVE) ------------------ | | 58| 952|#define ev_flags ev_evcallback.evcb_flags ------------------ if (ev->ev_flags & EVLIST_ACTIVE) ------------------ | | 60| 952|#define EVLIST_ACTIVE 0x08 ------------------ | Branch (2451:6): [True: 0, False: 952] ------------------ 2452| 0| return (-1); 2453| 952| if (pri < 0 || pri >= ev->ev_base->nactivequeues) ------------------ | Branch (2453:6): [True: 0, False: 952] | Branch (2453:17): [True: 952, False: 0] ------------------ 2454| 952| return (-1); 2455| | 2456| 0| ev->ev_pri = pri; ------------------ | | 57| 0|#define ev_pri ev_evcallback.evcb_pri ------------------ 2457| | 2458| 0| return (0); 2459| 952|} event_initialized: 2502| 1.90k|{ 2503| 1.90k| if (!(ev->ev_flags & EVLIST_INIT)) ------------------ | | 58| 1.90k|#define ev_flags ev_evcallback.evcb_flags ------------------ if (!(ev->ev_flags & EVLIST_INIT)) ------------------ | | 64| 1.90k|#define EVLIST_INIT 0x80 ------------------ | Branch (2503:6): [True: 952, False: 952] ------------------ 2504| 952| return 0; 2505| | 2506| 952| return 1; 2507| 1.90k|} event_get_priority: 2569| 952|{ 2570| 952| event_debug_assert_is_setup_(ev); 2571| 952| return ev->ev_pri; ------------------ | | 57| 952|#define ev_pri ev_evcallback.evcb_pri ------------------ 2572| 952|} event_del_nolock_: 2918| 7.61k|{ 2919| 7.61k| struct event_base *base; 2920| 7.61k| int res = 0, notify = 0; 2921| | 2922| 7.61k| event_debug(("event_del: %p (fd "EV_SOCK_FMT"), callback %p", ------------------ | | 79| 7.61k|#define event_debug(x) do { \ | | 80| 7.61k| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 7.61k|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 7.61k] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 7.61k| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 7.61k] | | ------------------ ------------------ 2923| 7.61k| (void *)ev, EV_SOCK_ARG(ev->ev_fd), (void *)ev->ev_callback)); 2924| | 2925| | /* An event without a base has not been added */ 2926| 7.61k| if (ev->ev_base == NULL) ------------------ | Branch (2926:6): [True: 0, False: 7.61k] ------------------ 2927| 0| return (-1); 2928| | 2929| 7.61k| EVENT_BASE_ASSERT_LOCKED(ev->ev_base); ------------------ | | 421| 7.61k| EVLOCK_ASSERT_LOCKED((base)->th_base_lock) | | ------------------ | | | | 130| 7.61k| do { \ | | | | 131| 7.61k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 7.61k] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 7.61k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 7.61k] | | | | ------------------ | | ------------------ ------------------ 2930| | 2931| 7.61k| if (blocking != EVENT_DEL_EVEN_IF_FINALIZING) { ------------------ | | 472| 7.61k|#define EVENT_DEL_EVEN_IF_FINALIZING 3 ------------------ | Branch (2931:6): [True: 5.71k, False: 1.90k] ------------------ 2932| 5.71k| if (ev->ev_flags & EVLIST_FINALIZING) { ------------------ | | 58| 5.71k|#define ev_flags ev_evcallback.evcb_flags ------------------ if (ev->ev_flags & EVLIST_FINALIZING) { ------------------ | | 63| 5.71k|#define EVLIST_FINALIZING 0x40 ------------------ | Branch (2932:7): [True: 0, False: 5.71k] ------------------ 2933| | /* XXXX Debug */ 2934| 0| return 0; 2935| 0| } 2936| 5.71k| } 2937| | 2938| 7.61k| base = ev->ev_base; 2939| | 2940| 7.61k| EVUTIL_ASSERT(!(ev->ev_flags & ~EVLIST_ALL)); ------------------ | | 368| 7.61k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 7.61k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 7.61k| (void)sizeof(!(condition)); \ | | | | 98| 7.61k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 7.61k] | | | | ------------------ | | ------------------ ------------------ 2941| | 2942| | /* See if we are just active executing this event in a loop */ 2943| 7.61k| if (ev->ev_events & EV_SIGNAL) { ------------------ | | 961| 7.61k|#define EV_SIGNAL 0x08 ------------------ | Branch (2943:6): [True: 0, False: 7.61k] ------------------ 2944| 0| if (ev->ev_ncalls && ev->ev_pncalls) { ------------------ | | 54| 0|#define ev_ncalls ev_.ev_signal.ev_ncalls ------------------ if (ev->ev_ncalls && ev->ev_pncalls) { ------------------ | | 55| 0|#define ev_pncalls ev_.ev_signal.ev_pncalls ------------------ | Branch (2944:7): [True: 0, False: 0] | Branch (2944:24): [True: 0, False: 0] ------------------ 2945| | /* Abort loop */ 2946| 0| *ev->ev_pncalls = 0; ------------------ | | 55| 0|#define ev_pncalls ev_.ev_signal.ev_pncalls ------------------ 2947| 0| } 2948| 0| } 2949| | 2950| 7.61k| if (ev->ev_flags & EVLIST_TIMEOUT) { ------------------ | | 58| 7.61k|#define ev_flags ev_evcallback.evcb_flags ------------------ if (ev->ev_flags & EVLIST_TIMEOUT) { ------------------ | | 57| 7.61k|#define EVLIST_TIMEOUT 0x01 ------------------ | Branch (2950:6): [True: 0, False: 7.61k] ------------------ 2951| | /* Notify the base if this was the minimal timeout */ 2952| 0| if (min_heap_top_(&base->timeheap) == ev) ------------------ | Branch (2952:7): [True: 0, False: 0] ------------------ 2953| 0| notify = 1; 2954| 0| event_queue_remove_timeout(base, ev); 2955| 0| } 2956| | 2957| 7.61k| if (ev->ev_flags & EVLIST_ACTIVE) ------------------ | | 58| 7.61k|#define ev_flags ev_evcallback.evcb_flags ------------------ if (ev->ev_flags & EVLIST_ACTIVE) ------------------ | | 60| 7.61k|#define EVLIST_ACTIVE 0x08 ------------------ | Branch (2957:6): [True: 1.90k, False: 5.71k] ------------------ 2958| 1.90k| event_queue_remove_active(base, event_to_event_callback(ev)); 2959| 5.71k| else if (ev->ev_flags & EVLIST_ACTIVE_LATER) ------------------ | | 58| 5.71k|#define ev_flags ev_evcallback.evcb_flags ------------------ else if (ev->ev_flags & EVLIST_ACTIVE_LATER) ------------------ | | 62| 5.71k|#define EVLIST_ACTIVE_LATER 0x20 ------------------ | Branch (2959:11): [True: 0, False: 5.71k] ------------------ 2960| 0| event_queue_remove_active_later(base, event_to_event_callback(ev)); 2961| | 2962| 7.61k| if (ev->ev_flags & EVLIST_INSERTED) { ------------------ | | 58| 7.61k|#define ev_flags ev_evcallback.evcb_flags ------------------ if (ev->ev_flags & EVLIST_INSERTED) { ------------------ | | 58| 7.61k|#define EVLIST_INSERTED 0x02 ------------------ | Branch (2962:6): [True: 0, False: 7.61k] ------------------ 2963| 0| event_queue_remove_inserted(base, ev); 2964| 0| if (ev->ev_events & (EV_READ|EV_WRITE|EV_CLOSED)) ------------------ | | 957| 0|#define EV_READ 0x02 ------------------ if (ev->ev_events & (EV_READ|EV_WRITE|EV_CLOSED)) ------------------ | | 959| 0|#define EV_WRITE 0x04 ------------------ if (ev->ev_events & (EV_READ|EV_WRITE|EV_CLOSED)) ------------------ | | 988| 0|#define EV_CLOSED 0x80 ------------------ | Branch (2964:7): [True: 0, False: 0] ------------------ 2965| 0| res = evmap_io_del_(base, ev->ev_fd, ev); 2966| 0| else 2967| 0| res = evmap_signal_del_(base, (int)ev->ev_fd, ev); 2968| 0| if (res == 1) { ------------------ | Branch (2968:7): [True: 0, False: 0] ------------------ 2969| | /* evmap says we need to notify the main thread. */ 2970| 0| notify = 1; 2971| 0| res = 0; 2972| 0| } 2973| | /* If we do not have events, let's notify event base so it can 2974| | * exit without waiting */ 2975| 0| if (!event_haveevents(base) && !N_ACTIVE_CALLBACKS(base)) ------------------ | | 451| 0| ((base)->event_count_active) ------------------ | Branch (2975:7): [True: 0, False: 0] | Branch (2975:34): [True: 0, False: 0] ------------------ 2976| 0| notify = 1; 2977| 0| } 2978| | 2979| | /* if we are not in the right thread, we need to wake up the loop */ 2980| 7.61k| if (res != -1 && notify && EVBASE_NEED_NOTIFY(base)) ------------------ | | 74| 0| (evthread_id_fn_ != NULL && \ | | ------------------ | | | Branch (74:3): [True: 0, False: 0] | | ------------------ | | 75| 0| (base)->running_loop && \ | | ------------------ | | | Branch (75:6): [True: 0, False: 0] | | ------------------ | | 76| 0| (base)->th_owner_id != evthread_id_fn_()) | | ------------------ | | | Branch (76:6): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2980:6): [True: 7.61k, False: 0] | Branch (2980:19): [True: 0, False: 7.61k] ------------------ 2981| 0| evthread_notify_base(base); 2982| | 2983| 7.61k| event_debug_note_del_(ev); 2984| | 2985| | /* If the main thread is currently executing this event's callback, 2986| | * and we are not the main thread, then we want to wait until the 2987| | * callback is done before returning. That way, when this function 2988| | * returns, it will be safe to free the user-supplied argument. 2989| | */ 2990| 7.61k|#ifndef EVENT__DISABLE_THREAD_SUPPORT 2991| 7.61k| if (blocking != EVENT_DEL_NOBLOCK && ------------------ | | 461| 15.2k|#define EVENT_DEL_NOBLOCK 0 ------------------ | Branch (2991:6): [True: 5.71k, False: 1.90k] ------------------ 2992| 5.71k| base->current_event == event_to_event_callback(ev) && ------------------ | Branch (2992:6): [True: 0, False: 5.71k] ------------------ 2993| 0| !EVBASE_IN_THREAD(base) && ------------------ | | 67| 7.61k| (evthread_id_fn_ == NULL || \ | | ------------------ | | | Branch (67:3): [True: 0, False: 0] | | ------------------ | | 68| 7.61k| (base)->th_owner_id == evthread_id_fn_()) | | ------------------ | | | Branch (68:2): [True: 0, False: 0] | | ------------------ ------------------ 2994| 0| (blocking == EVENT_DEL_BLOCK || !(ev->ev_events & EV_FINALIZE))) { ------------------ | | 465| 0|#define EVENT_DEL_BLOCK 1 ------------------ (blocking == EVENT_DEL_BLOCK || !(ev->ev_events & EV_FINALIZE))) { ------------------ | | 979| 0|#define EV_FINALIZE 0x40 ------------------ | Branch (2994:7): [True: 0, False: 0] | Branch (2994:38): [True: 0, False: 0] ------------------ 2995| 0| ++base->current_event_waiters; 2996| 0| EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock); ------------------ | | 175| 0| ( (cond) ? evthread_cond_fns_.wait_condition((cond), (lock), NULL) : 0 ) | | ------------------ | | | Branch (175:4): [True: 0, False: 0] | | ------------------ ------------------ 2997| 0| } 2998| 7.61k|#endif 2999| | 3000| 7.61k| return (res); 3001| 7.61k|} event_callback_activate_nolock_: 3111| 2.85k|{ 3112| 2.85k| int r = 1; 3113| | 3114| 2.85k| if (evcb->evcb_flags & EVLIST_FINALIZING) ------------------ | | 63| 2.85k|#define EVLIST_FINALIZING 0x40 ------------------ | Branch (3114:6): [True: 0, False: 2.85k] ------------------ 3115| 0| return 0; 3116| | 3117| 2.85k| switch (evcb->evcb_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER)) { ------------------ | | 60| 2.85k|#define EVLIST_ACTIVE 0x08 ------------------ switch (evcb->evcb_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER)) { ------------------ | | 62| 2.85k|#define EVLIST_ACTIVE_LATER 0x20 ------------------ 3118| 0| default: ------------------ | Branch (3118:2): [True: 0, False: 2.85k] ------------------ 3119| 0| EVUTIL_ASSERT(0); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 3120| 0| EVUTIL_FALLTHROUGH; ------------------ | | 361| 0|#define EVUTIL_FALLTHROUGH ; __attribute__((fallthrough)) ------------------ 3121| 0| case EVLIST_ACTIVE_LATER: ------------------ | | 62| 0|#define EVLIST_ACTIVE_LATER 0x20 ------------------ | Branch (3121:2): [True: 0, False: 2.85k] ------------------ 3122| 0| event_queue_remove_active_later(base, evcb); 3123| 0| r = 0; 3124| 0| break; 3125| 0| case EVLIST_ACTIVE: ------------------ | | 60| 0|#define EVLIST_ACTIVE 0x08 ------------------ | Branch (3125:2): [True: 0, False: 2.85k] ------------------ 3126| 0| return 0; 3127| 2.85k| case 0: ------------------ | Branch (3127:2): [True: 2.85k, False: 0] ------------------ 3128| 2.85k| break; 3129| 2.85k| } 3130| | 3131| 2.85k| event_queue_insert_active(base, evcb); 3132| | 3133| 2.85k| if (EVBASE_NEED_NOTIFY(base)) ------------------ | | 74| 2.85k| (evthread_id_fn_ != NULL && \ | | ------------------ | | | Branch (74:3): [True: 0, False: 2.85k] | | ------------------ | | 75| 2.85k| (base)->running_loop && \ | | ------------------ | | | Branch (75:6): [True: 0, False: 0] | | ------------------ | | 76| 2.85k| (base)->th_owner_id != evthread_id_fn_()) | | ------------------ | | | Branch (76:6): [True: 0, False: 0] | | ------------------ ------------------ 3134| 0| evthread_notify_base(base); 3135| | 3136| 2.85k| return r; 3137| 2.85k|} event_callback_cancel_: 3163| 952|{ 3164| 952| int r; 3165| 952| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 952|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 952| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 952| do { \ | | | | 95| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 952] | | | | ------------------ | | | | 96| 952| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 952| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 952] | | | | ------------------ | | ------------------ | | 120| 952| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 952] | | ------------------ ------------------ 3166| 952| r = event_callback_cancel_nolock_(base, evcb, 0); 3167| 952| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 952|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 952| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 952| do { \ | | | | 102| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 952] | | | | ------------------ | | | | 103| 952| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 952| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 952] | | | | ------------------ | | ------------------ | | 125| 952| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 952] | | ------------------ ------------------ 3168| 952| return r; 3169| 952|} event_callback_cancel_nolock_: 3174| 6.66k|{ 3175| 6.66k| if ((evcb->evcb_flags & EVLIST_FINALIZING) && !even_if_finalizing) ------------------ | | 63| 6.66k|#define EVLIST_FINALIZING 0x40 ------------------ | Branch (3175:6): [True: 0, False: 6.66k] | Branch (3175:48): [True: 0, False: 0] ------------------ 3176| 0| return 0; 3177| | 3178| 6.66k| if (evcb->evcb_flags & EVLIST_INIT) ------------------ | | 64| 6.66k|#define EVLIST_INIT 0x80 ------------------ | Branch (3178:6): [True: 3.80k, False: 2.85k] ------------------ 3179| 3.80k| return event_del_nolock_(event_callback_to_event(evcb), 3180| 3.80k| even_if_finalizing ? EVENT_DEL_EVEN_IF_FINALIZING : EVENT_DEL_AUTOBLOCK); ------------------ | | 472| 0|#define EVENT_DEL_EVEN_IF_FINALIZING 3 ------------------ even_if_finalizing ? EVENT_DEL_EVEN_IF_FINALIZING : EVENT_DEL_AUTOBLOCK); ------------------ | | 469| 3.80k|#define EVENT_DEL_AUTOBLOCK 2 ------------------ | Branch (3180:7): [True: 0, False: 3.80k] ------------------ 3181| | 3182| 2.85k| switch ((evcb->evcb_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER))) { ------------------ | | 60| 2.85k|#define EVLIST_ACTIVE 0x08 ------------------ switch ((evcb->evcb_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER))) { ------------------ | | 62| 2.85k|#define EVLIST_ACTIVE_LATER 0x20 ------------------ 3183| 0| default: ------------------ | Branch (3183:2): [True: 0, False: 2.85k] ------------------ 3184| 0| case EVLIST_ACTIVE|EVLIST_ACTIVE_LATER: ------------------ | | 60| 0|#define EVLIST_ACTIVE 0x08 ------------------ case EVLIST_ACTIVE|EVLIST_ACTIVE_LATER: ------------------ | | 62| 0|#define EVLIST_ACTIVE_LATER 0x20 ------------------ | Branch (3184:2): [True: 0, False: 2.85k] ------------------ 3185| 0| EVUTIL_ASSERT(0); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 3186| 0| break; 3187| 0| case EVLIST_ACTIVE: ------------------ | | 60| 0|#define EVLIST_ACTIVE 0x08 ------------------ | Branch (3187:2): [True: 0, False: 2.85k] ------------------ 3188| | /* We get different kinds of events, add them together */ 3189| 0| event_queue_remove_active(base, evcb); 3190| 0| return 0; 3191| 0| case EVLIST_ACTIVE_LATER: ------------------ | | 62| 0|#define EVLIST_ACTIVE_LATER 0x20 ------------------ | Branch (3191:2): [True: 0, False: 2.85k] ------------------ 3192| 0| event_queue_remove_active_later(base, evcb); 3193| 0| break; 3194| 2.85k| case 0: ------------------ | Branch (3194:2): [True: 2.85k, False: 0] ------------------ 3195| 2.85k| break; 3196| 2.85k| } 3197| | 3198| 2.85k| return 0; 3199| 2.85k|} event_deferred_cb_init_: 3203| 2.85k|{ 3204| 2.85k| memset(cb, 0, sizeof(*cb)); 3205| 2.85k| cb->evcb_cb_union.evcb_selfcb = fn; 3206| 2.85k| cb->evcb_arg = arg; 3207| 2.85k| cb->evcb_pri = priority; 3208| 2.85k| cb->evcb_closure = EV_CLOSURE_CB_SELF; ------------------ | | 76| 2.85k|#define EV_CLOSURE_CB_SELF 3 ------------------ 3209| 2.85k|} event_deferred_cb_cancel_: 3219| 952|{ 3220| 952| if (!base) ------------------ | Branch (3220:6): [True: 0, False: 952] ------------------ 3221| 0| base = current_base; ------------------ | | 138| 0|#define current_base event_global_current_base_ ------------------ 3222| 952| event_callback_cancel_(base, cb); 3223| 952|} event_deferred_cb_schedule_: 3228| 952|{ 3229| 952| int r = 1; 3230| 952| if (!base) ------------------ | Branch (3230:6): [True: 0, False: 952] ------------------ 3231| 0| base = current_base; ------------------ | | 138| 0|#define current_base event_global_current_base_ ------------------ 3232| 952| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 952|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 952| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 952| do { \ | | | | 95| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 952] | | | | ------------------ | | | | 96| 952| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 952| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 952] | | | | ------------------ | | ------------------ | | 120| 952| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 952] | | ------------------ ------------------ 3233| 952| if (base->n_deferreds_queued > MAX_DEFERREDS_QUEUED) { ------------------ | | 3225| 952|#define MAX_DEFERREDS_QUEUED 32 ------------------ | Branch (3233:6): [True: 0, False: 952] ------------------ 3234| 0| r = event_callback_activate_later_nolock_(base, cb); 3235| 952| } else { 3236| 952| r = event_callback_activate_nolock_(base, cb); 3237| 952| if (r) { ------------------ | Branch (3237:7): [True: 952, False: 0] ------------------ 3238| 952| ++base->n_deferreds_queued; 3239| 952| } 3240| 952| } 3241| 952| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 952|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 952| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 952| do { \ | | | | 102| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 952] | | | | ------------------ | | | | 103| 952| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 952| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 952] | | | | ------------------ | | ------------------ | | 125| 952| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 952] | | ------------------ ------------------ 3242| 952| return r; 3243| 952|} event_mm_malloc_: 3592| 35.3k|{ 3593| 35.3k| if (sz == 0) ------------------ | Branch (3593:6): [True: 0, False: 35.3k] ------------------ 3594| 0| return NULL; 3595| | 3596| 35.3k| if (mm_malloc_fn_) ------------------ | Branch (3596:6): [True: 0, False: 35.3k] ------------------ 3597| 0| return mm_malloc_fn_(sz); 3598| 35.3k| else 3599| 35.3k| return malloc(sz); 3600| 35.3k|} event_mm_calloc_: 3604| 51.1k|{ 3605| 51.1k| if (count == 0 || size == 0) ------------------ | Branch (3605:6): [True: 0, False: 51.1k] | Branch (3605:20): [True: 0, False: 51.1k] ------------------ 3606| 0| return NULL; 3607| | 3608| 51.1k| if (mm_malloc_fn_) { ------------------ | Branch (3608:6): [True: 0, False: 51.1k] ------------------ 3609| 0| size_t sz = count * size; 3610| 0| void *p = NULL; 3611| 0| if (count > EV_SIZE_MAX / size) ------------------ | | 289| 0|#define EV_SIZE_MAX EV_UINT64_MAX | | ------------------ | | | | 267| 0|#define EV_UINT64_MAX UINT64_MAX | | ------------------ ------------------ | Branch (3611:7): [True: 0, False: 0] ------------------ 3612| 0| goto error; 3613| 0| p = mm_malloc_fn_(sz); 3614| 0| if (p) ------------------ | Branch (3614:7): [True: 0, False: 0] ------------------ 3615| 0| return memset(p, 0, sz); 3616| 51.1k| } else { 3617| 51.1k| void *p = calloc(count, size); 3618| |#ifdef _WIN32 3619| | /* Windows calloc doesn't reliably set ENOMEM */ 3620| | if (p == NULL) 3621| | goto error; 3622| |#endif 3623| 51.1k| return p; 3624| 51.1k| } 3625| | 3626| 0|error: 3627| 0| errno = ENOMEM; 3628| | return NULL; 3629| 51.1k|} event_mm_strdup_: 3633| 13.3k|{ 3634| 13.3k| if (!str) { ------------------ | Branch (3634:6): [True: 0, False: 13.3k] ------------------ 3635| 0| errno = EINVAL; 3636| 0| return NULL; 3637| 0| } 3638| | 3639| 13.3k| if (mm_malloc_fn_) { ------------------ | Branch (3639:6): [True: 0, False: 13.3k] ------------------ 3640| 0| size_t ln = strlen(str); 3641| 0| void *p = NULL; 3642| 0| if (ln == EV_SIZE_MAX) ------------------ | | 289| 0|#define EV_SIZE_MAX EV_UINT64_MAX | | ------------------ | | | | 267| 0|#define EV_UINT64_MAX UINT64_MAX | | ------------------ ------------------ | Branch (3642:7): [True: 0, False: 0] ------------------ 3643| 0| goto error; 3644| 0| p = mm_malloc_fn_(ln+1); 3645| 0| if (p) ------------------ | Branch (3645:7): [True: 0, False: 0] ------------------ 3646| 0| return memcpy(p, str, ln+1); 3647| 0| } else 3648| |#ifdef _WIN32 3649| | return _strdup(str); 3650| |#else 3651| 13.3k| return strdup(str); 3652| 0|#endif 3653| | 3654| 0|error: 3655| 0| errno = ENOMEM; 3656| | return NULL; 3657| 13.3k|} event_mm_free_: 3670| 99.8k|{ 3671| 99.8k| if (mm_free_fn_) ------------------ | Branch (3671:6): [True: 0, False: 99.8k] ------------------ 3672| 0| mm_free_fn_(ptr); 3673| 99.8k| else 3674| 99.8k| free(ptr); 3675| 99.8k|} event.c:update_time_cache: 488| 952|{ 489| 952| base->tv_cache.tv_sec = 0; 490| 952| if (!(base->flags & EVENT_BASE_FLAG_NO_CACHE_TIME)) ------------------ | Branch (490:6): [True: 952, False: 0] ------------------ 491| 952| gettime(base, &base->tv_cache); 492| 952|} event.c:gettime: 434| 1.90k|{ 435| 1.90k| EVENT_BASE_ASSERT_LOCKED(base); ------------------ | | 421| 1.90k| EVLOCK_ASSERT_LOCKED((base)->th_base_lock) | | ------------------ | | | | 130| 1.90k| do { \ | | | | 131| 1.90k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 1.90k] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ ------------------ 436| | 437| 1.90k| if (base->tv_cache.tv_sec) { ------------------ | Branch (437:6): [True: 0, False: 1.90k] ------------------ 438| 0| *tp = base->tv_cache; 439| 0| return (0); 440| 0| } 441| | 442| 1.90k| if (evutil_gettime_monotonic_(&base->monotonic_timer, tp) == -1) { ------------------ | Branch (442:6): [True: 0, False: 1.90k] ------------------ 443| 0| return -1; 444| 0| } 445| | 446| 1.90k| if (base->last_updated_clock_diff + CLOCK_SYNC_INTERVAL ------------------ | | 425| 1.90k|#define CLOCK_SYNC_INTERVAL -1 ------------------ | Branch (446:6): [True: 1.90k, False: 0] ------------------ 447| 1.90k| < tp->tv_sec) { 448| 1.90k| struct timeval tv; 449| 1.90k| evutil_gettimeofday(&tv,NULL); ------------------ | | 637| 1.90k|#define evutil_gettimeofday(tv, tz) gettimeofday((tv), (tz)) ------------------ 450| 1.90k| evutil_timersub(&tv, tp, &base->tv_clock_diff); ------------------ | | 581| 1.90k|#define evutil_timersub(tvp, uvp, vvp) timersub((tvp), (uvp), (vvp)) ------------------ | Branch (450:3): [True: 947, False: 957] | Branch (450:3): [Folded, False: 1.90k] ------------------ 451| 1.90k| base->last_updated_clock_diff = tp->tv_sec; 452| 1.90k| } 453| | 454| 1.90k| return 0; 455| 1.90k|} event.c:event_config_is_avoided_method: 556| 952|{ 557| 952| struct event_config_entry *entry; 558| | 559| 952| TAILQ_FOREACH(entry, &cfg->entries, next) { ------------------ | | 305| 952| for((var) = TAILQ_FIRST(head); \ | | ------------------ | | | | 293| 952|#define TAILQ_FIRST(head) ((head)->tqh_first) | | ------------------ | | 306| 952| (var) != TAILQ_END(head); \ | | ------------------ | | | | 294| 952|#define TAILQ_END(head) NULL | | ------------------ | | | Branch (306:6): [True: 0, False: 952] | | ------------------ | | 307| 952| (var) = TAILQ_NEXT(var, field)) | | ------------------ | | | | 295| 0|#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) | | ------------------ ------------------ 560| 0| if (entry->avoid_method != NULL && ------------------ | Branch (560:7): [True: 0, False: 0] ------------------ 561| 0| strcmp(entry->avoid_method, method) == 0) ------------------ | Branch (561:7): [True: 0, False: 0] ------------------ 562| 0| return (1); 563| 0| } 564| | 565| 952| return (0); 566| 952|} event.c:event_is_method_disabled: 571| 952|{ 572| 952| char environment[64]; 573| 952| int i; 574| | 575| 952| evutil_snprintf(environment, sizeof(environment), "EVENT_NO%s", name); 576| 5.71k| for (i = 8; environment[i] != '\0'; ++i) ------------------ | Branch (576:14): [True: 4.76k, False: 952] ------------------ 577| 4.76k| environment[i] = EVUTIL_TOUPPER_(environment[i]); 578| | /* Note that evutil_getenv_() ignores the environment entirely if 579| | * we're setuid */ 580| | return (evutil_getenv_(environment) != NULL); 581| 952|} event.c:event_base_free_: 866| 952|{ 867| 952| int i; 868| 952| size_t n_deleted=0; 869| 952| struct event *ev; 870| 952| struct evwatch *watcher; 871| | /* XXXX grab the lock? If there is contention when one thread frees 872| | * the base, then the contending thread will be very sad soon. */ 873| | 874| | /* event_base_free(NULL) is how to free the current_base if we 875| | * made it with event_init and forgot to hold a reference to it. */ 876| 952| if (base == NULL && current_base) ------------------ | | 138| 0|#define current_base event_global_current_base_ | | ------------------ | | | Branch (138:22): [True: 0, False: 0] | | ------------------ ------------------ | Branch (876:6): [True: 0, False: 952] ------------------ 877| 0| base = current_base; ------------------ | | 138| 0|#define current_base event_global_current_base_ ------------------ 878| | /* Don't actually free NULL. */ 879| 952| if (base == NULL) { ------------------ | Branch (879:6): [True: 0, False: 952] ------------------ 880| 0| event_warnx("%s: no base to free", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 881| 0| return; 882| 0| } 883| | /* XXX(niels) - check for internal events first */ 884| | 885| |#ifdef _WIN32 886| | event_base_stop_iocp_(base); 887| |#endif 888| | 889| | /* threading fds if we have them */ 890| 952| if (base->th_notify_fd[0] != -1) { ------------------ | Branch (890:6): [True: 0, False: 952] ------------------ 891| 0| event_del(&base->th_notify); 892| 0| EVUTIL_CLOSESOCKET(base->th_notify_fd[0]); ------------------ | | 495| 0|#define EVUTIL_CLOSESOCKET(s) evutil_closesocket(s) ------------------ 893| 0| if (base->th_notify_fd[1] != -1) ------------------ | Branch (893:7): [True: 0, False: 0] ------------------ 894| 0| EVUTIL_CLOSESOCKET(base->th_notify_fd[1]); ------------------ | | 495| 0|#define EVUTIL_CLOSESOCKET(s) evutil_closesocket(s) ------------------ 895| 0| base->th_notify_fd[0] = -1; 896| 0| base->th_notify_fd[1] = -1; 897| 0| event_debug_unassign(&base->th_notify); 898| 0| } 899| | 900| | /* Delete all non-internal events. */ 901| 952| evmap_delete_all_(base); 902| | 903| 952| while ((ev = min_heap_top_(&base->timeheap)) != NULL) { ------------------ | Branch (903:9): [True: 0, False: 952] ------------------ 904| 0| event_del(ev); 905| 0| ++n_deleted; 906| 0| } 907| 952| for (i = 0; i < base->n_common_timeouts; ++i) { ------------------ | Branch (907:14): [True: 0, False: 952] ------------------ 908| 0| struct common_timeout_list *ctl = 909| 0| base->common_timeout_queues[i]; 910| 0| event_del(&ctl->timeout_event); /* Internal; doesn't count */ 911| 0| event_debug_unassign(&ctl->timeout_event); 912| 0| for (ev = TAILQ_FIRST(&ctl->events); ev; ) { ------------------ | | 293| 0|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (912:40): [True: 0, False: 0] ------------------ 913| 0| struct event *next = TAILQ_NEXT(ev, ------------------ | | 295| 0|#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) ------------------ 914| 0| ev_timeout_pos.ev_next_with_common_timeout); 915| 0| if (!(ev->ev_flags & EVLIST_INTERNAL)) { ------------------ | | 58| 0|#define ev_flags ev_evcallback.evcb_flags ------------------ if (!(ev->ev_flags & EVLIST_INTERNAL)) { ------------------ | | 61| 0|#define EVLIST_INTERNAL 0x10 ------------------ | Branch (915:8): [True: 0, False: 0] ------------------ 916| 0| event_del(ev); 917| 0| ++n_deleted; 918| 0| } 919| 0| ev = next; 920| 0| } 921| 0| mm_free(ctl); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 922| 0| } 923| 952| if (base->common_timeout_queues) ------------------ | Branch (923:6): [True: 0, False: 952] ------------------ 924| 0| mm_free(base->common_timeout_queues); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 925| | 926| 1.90k| for (;;) { 927| | /* For finalizers we can register yet another finalizer out from 928| | * finalizer, and iff finalizer will be in active_later_queue we can 929| | * add finalizer to activequeues, and we will have events in 930| | * activequeues after this function returns, which is not what we want 931| | * (we even have an assertion for this). 932| | * 933| | * A simple case is bufferevent with underlying (i.e. filters). 934| | */ 935| 1.90k| int i = event_base_free_queues_(base, run_finalizers); 936| 1.90k| event_debug(("%s: %d events freed", __func__, i)); ------------------ | | 79| 1.90k|#define event_debug(x) do { \ | | 80| 1.90k| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 1.90k|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 1.90k] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 1.90k| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 1.90k] | | ------------------ ------------------ 937| 1.90k| if (!i) { ------------------ | Branch (937:7): [True: 952, False: 952] ------------------ 938| 952| break; 939| 952| } 940| 952| n_deleted += i; 941| 952| } 942| | 943| 952| if (n_deleted) ------------------ | Branch (943:6): [True: 952, False: 0] ------------------ 944| 952| event_debug(("%s: "EV_SIZE_FMT" events were still set in base", ------------------ | | 79| 952|#define event_debug(x) do { \ | | 80| 952| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 952|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 952] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 952| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 952] | | ------------------ ------------------ 945| 952| __func__, n_deleted)); 946| | 947| 952| while (LIST_FIRST(&base->once_events)) { ------------------ | | 157| 952|#define LIST_FIRST(head) ((head)->lh_first) | | ------------------ | | | Branch (157:27): [True: 0, False: 952] | | ------------------ ------------------ 948| 0| struct event_once *eonce = LIST_FIRST(&base->once_events); ------------------ | | 157| 0|#define LIST_FIRST(head) ((head)->lh_first) ------------------ 949| 0| LIST_REMOVE(eonce, next_once); ------------------ | | 196| 0|#define LIST_REMOVE(elm, field) do { \ | | 197| 0| if ((elm)->field.le_next != NULL) \ | | ------------------ | | | Branch (197:6): [True: 0, False: 0] | | ------------------ | | 198| 0| (elm)->field.le_next->field.le_prev = \ | | 199| 0| (elm)->field.le_prev; \ | | 200| 0| *(elm)->field.le_prev = (elm)->field.le_next; \ | | 201| 0|} while (0) | | ------------------ | | | Branch (201:10): [Folded, False: 0] | | ------------------ ------------------ 950| 0| mm_free(eonce); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 951| 0| } 952| | 953| 952| if (base->evsel != NULL && base->evsel->dealloc != NULL) ------------------ | Branch (953:6): [True: 952, False: 0] | Branch (953:29): [True: 952, False: 0] ------------------ 954| 952| base->evsel->dealloc(base); 955| | 956| 1.90k| for (i = 0; i < base->nactivequeues; ++i) ------------------ | Branch (956:14): [True: 952, False: 952] ------------------ 957| 952| EVUTIL_ASSERT(TAILQ_EMPTY(&base->activequeues[i])); ------------------ | | 368| 952|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 1.90k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 952| (void)sizeof(!(condition)); \ | | | | 98| 952|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 952] | | | | ------------------ | | ------------------ ------------------ 958| | 959| 952| EVUTIL_ASSERT(min_heap_empty_(&base->timeheap)); ------------------ | | 368| 952|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 952|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 952| (void)sizeof(!(condition)); \ | | | | 98| 952|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 952] | | | | ------------------ | | ------------------ ------------------ 960| 952| min_heap_dtor_(&base->timeheap); 961| | 962| 952| mm_free(base->activequeues); ------------------ | | 80| 952|#define mm_free(p) event_mm_free_(p) ------------------ 963| | 964| 952| evmap_io_clear_(&base->io); 965| 952| evmap_signal_clear_(&base->sigmap); 966| 952| event_changelist_freemem_(&base->changelist); 967| | 968| 952| EVTHREAD_FREE_LOCK(base->th_base_lock, 0); ------------------ | | 86| 952| do { \ | | 87| 952| void *lock_tmp_ = (lockvar); \ | | 88| 952| if (lock_tmp_ && evthread_lock_fns_.free) \ | | ------------------ | | | Branch (88:7): [True: 0, False: 952] | | | Branch (88:20): [True: 0, False: 0] | | ------------------ | | 89| 952| evthread_lock_fns_.free(lock_tmp_, (locktype)); \ | | 90| 952| } while (0) | | ------------------ | | | Branch (90:11): [Folded, False: 952] | | ------------------ ------------------ 969| 952| EVTHREAD_FREE_COND(base->current_event_cond); ------------------ | | 160| 952| do { \ | | 161| 952| if (cond) \ | | ------------------ | | | Branch (161:7): [True: 0, False: 952] | | ------------------ | | 162| 952| evthread_cond_fns_.free_condition((cond)); \ | | 163| 952| } while (0) | | ------------------ | | | Branch (163:11): [Folded, False: 952] | | ------------------ ------------------ 970| | 971| | /* Free all event watchers */ 972| 2.85k| for (i = 0; i < EVWATCH_MAX; ++i) { ------------------ | | 229| 2.85k|#define EVWATCH_MAX 2 ------------------ | Branch (972:14): [True: 1.90k, False: 952] ------------------ 973| 1.90k| while (!TAILQ_EMPTY(&base->watchers[i])) { ------------------ | | 302| 1.90k| (TAILQ_FIRST(head) == TAILQ_END(head)) | | ------------------ | | | | 293| 1.90k|#define TAILQ_FIRST(head) ((head)->tqh_first) | | ------------------ | | (TAILQ_FIRST(head) == TAILQ_END(head)) | | ------------------ | | | | 294| 1.90k|#define TAILQ_END(head) NULL | | ------------------ ------------------ | Branch (973:10): [True: 0, False: 1.90k] ------------------ 974| 0| watcher = TAILQ_FIRST(&base->watchers[i]); ------------------ | | 293| 0|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ 975| 0| TAILQ_REMOVE(&base->watchers[i], watcher, next); ------------------ | | 356| 0|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 0| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 0, False: 0] | | ------------------ | | 358| 0| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 0| (elm)->field.tqe_prev; \ | | 360| 0| else \ | | 361| 0| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 0| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 0|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 0] | | ------------------ ------------------ 976| 0| mm_free(watcher); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 977| 0| } 978| 1.90k| } 979| | 980| | /* If we're freeing current_base, there won't be a current_base. */ 981| 952| if (base == current_base) ------------------ | | 138| 952|#define current_base event_global_current_base_ ------------------ | Branch (981:6): [True: 0, False: 952] ------------------ 982| 0| current_base = NULL; ------------------ | | 138| 0|#define current_base event_global_current_base_ ------------------ 983| 952| mm_free(base); ------------------ | | 80| 952|#define mm_free(p) event_mm_free_(p) ------------------ 984| 952|} event.c:event_base_free_queues_: 842| 1.90k|{ 843| 1.90k| int deleted = 0, i; 844| | 845| 3.80k| for (i = 0; i < base->nactivequeues; ++i) { ------------------ | Branch (845:14): [True: 1.90k, False: 1.90k] ------------------ 846| 1.90k| struct event_callback *evcb, *next; 847| 3.80k| for (evcb = TAILQ_FIRST(&base->activequeues[i]); evcb; ) { ------------------ | | 293| 1.90k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (847:52): [True: 1.90k, False: 1.90k] ------------------ 848| 1.90k| next = TAILQ_NEXT(evcb, evcb_active_next); ------------------ | | 295| 1.90k|#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) ------------------ 849| 1.90k| deleted += event_base_cancel_single_callback_(base, evcb, run_finalizers); 850| 1.90k| evcb = next; 851| 1.90k| } 852| 1.90k| } 853| | 854| 1.90k| { 855| 1.90k| struct event_callback *evcb; 856| 1.90k| while ((evcb = TAILQ_FIRST(&base->active_later_queue))) { ------------------ | | 293| 1.90k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (856:10): [True: 0, False: 1.90k] ------------------ 857| 0| deleted += event_base_cancel_single_callback_(base, evcb, run_finalizers); 858| 0| } 859| 1.90k| } 860| | 861| 1.90k| return deleted; 862| 1.90k|} event.c:event_base_cancel_single_callback_: 805| 1.90k|{ 806| 1.90k| int result = 0; 807| | 808| 1.90k| if (evcb->evcb_flags & EVLIST_INIT) { ------------------ | | 64| 1.90k|#define EVLIST_INIT 0x80 ------------------ | Branch (808:6): [True: 1.90k, False: 0] ------------------ 809| 1.90k| struct event *ev = event_callback_to_event(evcb); 810| 1.90k| if (!(ev->ev_flags & EVLIST_INTERNAL)) { ------------------ | | 58| 1.90k|#define ev_flags ev_evcallback.evcb_flags ------------------ if (!(ev->ev_flags & EVLIST_INTERNAL)) { ------------------ | | 61| 1.90k|#define EVLIST_INTERNAL 0x10 ------------------ | Branch (810:7): [True: 1.90k, False: 0] ------------------ 811| 1.90k| event_del_(ev, EVENT_DEL_EVEN_IF_FINALIZING); ------------------ | | 472| 1.90k|#define EVENT_DEL_EVEN_IF_FINALIZING 3 ------------------ 812| 1.90k| result = 1; 813| 1.90k| } 814| 1.90k| } else { 815| 0| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 0|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 0| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 0| do { \ | | | | 95| 0| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 0] | | | | ------------------ | | | | 96| 0| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 0| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 120| 0| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 0] | | ------------------ ------------------ 816| 0| event_callback_cancel_nolock_(base, evcb, 1); 817| 0| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 0|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 0| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 0| do { \ | | | | 102| 0| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 0] | | | | ------------------ | | | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 0| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 125| 0| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 0] | | ------------------ ------------------ 818| 0| result = 1; 819| 0| } 820| | 821| 1.90k| if (run_finalizers && (evcb->evcb_flags & EVLIST_FINALIZING)) { ------------------ | | 63| 1.90k|#define EVLIST_FINALIZING 0x40 ------------------ | Branch (821:6): [True: 1.90k, False: 0] | Branch (821:24): [True: 1.90k, False: 0] ------------------ 822| 1.90k| switch (evcb->evcb_closure) { 823| 0| case EV_CLOSURE_EVENT_FINALIZE: ------------------ | | 80| 0|#define EV_CLOSURE_EVENT_FINALIZE 5 ------------------ | Branch (823:3): [True: 0, False: 1.90k] ------------------ 824| 0| case EV_CLOSURE_EVENT_FINALIZE_FREE: { ------------------ | | 83| 0|#define EV_CLOSURE_EVENT_FINALIZE_FREE 6 ------------------ | Branch (824:3): [True: 0, False: 1.90k] ------------------ 825| 0| struct event *ev = event_callback_to_event(evcb); 826| 0| ev->ev_evcallback.evcb_cb_union.evcb_evfinalize(ev, ev->ev_arg); ------------------ | | 61| 0|#define ev_arg ev_evcallback.evcb_arg ------------------ 827| 0| if (evcb->evcb_closure == EV_CLOSURE_EVENT_FINALIZE_FREE) ------------------ | | 83| 0|#define EV_CLOSURE_EVENT_FINALIZE_FREE 6 ------------------ | Branch (827:8): [True: 0, False: 0] ------------------ 828| 0| mm_free(ev); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 829| 0| break; 830| 0| } 831| 1.90k| case EV_CLOSURE_CB_FINALIZE: ------------------ | | 78| 1.90k|#define EV_CLOSURE_CB_FINALIZE 4 ------------------ | Branch (831:3): [True: 1.90k, False: 0] ------------------ 832| 1.90k| evcb->evcb_cb_union.evcb_cbfinalize(evcb, evcb->evcb_arg); 833| 1.90k| break; 834| 0| default: ------------------ | Branch (834:3): [True: 0, False: 1.90k] ------------------ 835| 0| break; 836| 1.90k| } 837| 1.90k| } 838| 1.90k| return result; 839| 1.90k|} event.c:clear_time_cache: 481| 2.85k|{ 482| 2.85k| base->tv_cache.tv_sec = 0; 483| 2.85k|} event.c:event_haveevents: 1385| 1.90k|{ 1386| | /* Caller must hold th_base_lock */ 1387| 1.90k| return (base->virtual_event_count > 0 || base->event_count > 0); ------------------ | Branch (1387:10): [True: 0, False: 1.90k] | Branch (1387:43): [True: 952, False: 952] ------------------ 1388| 1.90k|} event.c:event_process_active: 1822| 952|{ 1823| | /* Caller must hold th_base_lock */ 1824| 952| struct evcallback_list *activeq = NULL; 1825| 952| int i, c = 0; 1826| 952| const struct timeval *endtime; 1827| 952| struct timeval tv; 1828| 952| const int maxcb = base->max_dispatch_callbacks; 1829| 952| const int limit_after_prio = base->limit_callbacks_after_prio; 1830| 952| if (base->max_dispatch_time.tv_sec >= 0) { ------------------ | Branch (1830:6): [True: 0, False: 952] ------------------ 1831| 0| update_time_cache(base); 1832| 0| gettime(base, &tv); 1833| 0| evutil_timeradd(&base->max_dispatch_time, &tv, &tv); ------------------ | | 580| 0|#define evutil_timeradd(tvp, uvp, vvp) timeradd((tvp), (uvp), (vvp)) ------------------ | Branch (1833:3): [True: 0, False: 0] | Branch (1833:3): [Folded, False: 0] ------------------ 1834| 0| endtime = &tv; 1835| 952| } else { 1836| 952| endtime = NULL; 1837| 952| } 1838| | 1839| 952| for (i = 0; i < base->nactivequeues; ++i) { ------------------ | Branch (1839:14): [True: 952, False: 0] ------------------ 1840| 952| if (TAILQ_FIRST(&base->activequeues[i]) != NULL) { ------------------ | | 293| 952|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (1840:7): [True: 952, False: 0] ------------------ 1841| 952| base->event_running_priority = i; 1842| 952| activeq = &base->activequeues[i]; 1843| 952| if (i < limit_after_prio) ------------------ | Branch (1843:8): [True: 952, False: 0] ------------------ 1844| 952| c = event_process_active_single_queue(base, activeq, 1845| 952| INT_MAX, NULL); 1846| 0| else 1847| 0| c = event_process_active_single_queue(base, activeq, 1848| 0| maxcb, endtime); 1849| 952| if (c < 0) { ------------------ | Branch (1849:8): [True: 0, False: 952] ------------------ 1850| 0| goto done; 1851| 952| } else if (c > 0) ------------------ | Branch (1851:15): [True: 952, False: 0] ------------------ 1852| 952| break; /* Processed a real event; do not 1853| | * consider lower-priority events */ 1854| | /* If we get here, all of the events we processed 1855| | * were internal. Continue. */ 1856| 952| } 1857| 952| } 1858| | 1859| 952|done: 1860| 952| base->event_running_priority = -1; 1861| | 1862| 952| return c; 1863| 952|} event.c:event_process_active_single_queue: 1695| 952|{ 1696| 952| struct event_callback *evcb; 1697| 952| int count = 0; 1698| | 1699| 952| EVUTIL_ASSERT(activeq != NULL); ------------------ | | 368| 952|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 952|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 952| (void)sizeof(!(condition)); \ | | | | 98| 952|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 952] | | | | ------------------ | | ------------------ ------------------ 1700| | 1701| 1.90k| for (evcb = TAILQ_FIRST(activeq); evcb; evcb = TAILQ_FIRST(activeq)) { ------------------ | | 293| 952|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ for (evcb = TAILQ_FIRST(activeq); evcb; evcb = TAILQ_FIRST(activeq)) { ------------------ | | 293| 952|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (1701:36): [True: 952, False: 952] ------------------ 1702| 952| struct event *ev = NULL; 1703| 952| if (evcb->evcb_flags & EVLIST_INIT) { ------------------ | | 64| 952|#define EVLIST_INIT 0x80 ------------------ | Branch (1703:7): [True: 0, False: 952] ------------------ 1704| 0| ev = event_callback_to_event(evcb); 1705| | 1706| 0| if (ev->ev_events & EV_PERSIST || ev->ev_flags & EVLIST_FINALIZING) ------------------ | | 968| 0|#define EV_PERSIST 0x10 ------------------ if (ev->ev_events & EV_PERSIST || ev->ev_flags & EVLIST_FINALIZING) ------------------ | | 58| 0|#define ev_flags ev_evcallback.evcb_flags ------------------ if (ev->ev_events & EV_PERSIST || ev->ev_flags & EVLIST_FINALIZING) ------------------ | | 63| 0|#define EVLIST_FINALIZING 0x40 ------------------ | Branch (1706:8): [True: 0, False: 0] | Branch (1706:38): [True: 0, False: 0] ------------------ 1707| 0| event_queue_remove_active(base, evcb); 1708| 0| else 1709| 0| event_del_nolock_(ev, EVENT_DEL_NOBLOCK); ------------------ | | 461| 0|#define EVENT_DEL_NOBLOCK 0 ------------------ 1710| 0| event_debug(( ------------------ | | 79| 0|#define event_debug(x) do { \ | | 80| 0| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 0|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | ------------------ | | | Branch (81:17): [True: 0, False: 0] | | | Branch (81:17): [True: 0, False: 0] | | | Branch (81:17): [True: 0, False: 0] | | ------------------ | | 82| 0| } \ | | 83| 0| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 0] | | ------------------ ------------------ 1711| 0| "event_process_active: event: %p, %s%s%scall %p", 1712| 0| (void *)ev, 1713| 0| ev->ev_res & EV_READ ? "EV_READ " : " ", 1714| 0| ev->ev_res & EV_WRITE ? "EV_WRITE " : " ", 1715| 0| ev->ev_res & EV_CLOSED ? "EV_CLOSED " : " ", 1716| 0| (void *)ev->ev_callback)); 1717| 952| } else { 1718| 952| event_queue_remove_active(base, evcb); 1719| 952| event_debug(("event_process_active: event_callback %p, " ------------------ | | 79| 952|#define event_debug(x) do { \ | | 80| 952| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 952|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 952] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 952| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 952] | | ------------------ ------------------ 1720| 952| "closure %d, call %p", 1721| 952| (void *)evcb, evcb->evcb_closure, (void *)evcb->evcb_cb_union.evcb_callback)); 1722| 952| } 1723| | // We don't want an infinite loop or use of memory after it is freed. 1724| | // Hence, for next loop iteration, it is expected that `event_queue_remove_active` or `event_del_nolock_` have removed current event from the queue at this point. 1725| 952| EVUTIL_ASSERT(evcb != TAILQ_FIRST(activeq)); ------------------ | | 368| 952|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 952|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 952| (void)sizeof(!(condition)); \ | | | | 98| 952|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 952] | | | | ------------------ | | ------------------ ------------------ 1726| | 1727| 952| if (!(evcb->evcb_flags & EVLIST_INTERNAL)) ------------------ | | 61| 952|#define EVLIST_INTERNAL 0x10 ------------------ | Branch (1727:7): [True: 952, False: 0] ------------------ 1728| 952| ++count; 1729| | 1730| | 1731| 952| base->current_event = evcb; 1732| 952|#ifndef EVENT__DISABLE_THREAD_SUPPORT 1733| 952| base->current_event_waiters = 0; 1734| 952|#endif 1735| | 1736| 952| switch (evcb->evcb_closure) { 1737| 0| case EV_CLOSURE_EVENT_SIGNAL: ------------------ | | 72| 0|#define EV_CLOSURE_EVENT_SIGNAL 1 ------------------ | Branch (1737:3): [True: 0, False: 952] ------------------ 1738| 0| EVUTIL_ASSERT(ev != NULL); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1739| 0| event_signal_closure(base, ev); 1740| 0| break; 1741| 0| case EV_CLOSURE_EVENT_PERSIST: ------------------ | | 74| 0|#define EV_CLOSURE_EVENT_PERSIST 2 ------------------ | Branch (1741:3): [True: 0, False: 952] ------------------ 1742| 0| EVUTIL_ASSERT(ev != NULL); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1743| 0| event_persist_closure(base, ev); 1744| 0| break; 1745| 0| case EV_CLOSURE_EVENT: { ------------------ | | 70| 0|#define EV_CLOSURE_EVENT 0 ------------------ | Branch (1745:3): [True: 0, False: 952] ------------------ 1746| 0| void (*evcb_callback)(evutil_socket_t, short, void *); 1747| 0| short res; 1748| 0| EVUTIL_ASSERT(ev != NULL); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1749| 0| evcb_callback = *ev->ev_callback; ------------------ | | 60| 0|#define ev_callback ev_evcallback.evcb_cb_union.evcb_callback ------------------ 1750| 0| res = ev->ev_res; 1751| 0| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 0|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 0| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 0| do { \ | | | | 102| 0| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 0] | | | | ------------------ | | | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 0| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 125| 0| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 0] | | ------------------ ------------------ 1752| 0| evcb_callback(ev->ev_fd, res, ev->ev_arg); ------------------ | | 61| 0|#define ev_arg ev_evcallback.evcb_arg ------------------ 1753| 0| } 1754| 0| break; 1755| 952| case EV_CLOSURE_CB_SELF: { ------------------ | | 76| 952|#define EV_CLOSURE_CB_SELF 3 ------------------ | Branch (1755:3): [True: 952, False: 0] ------------------ 1756| 952| void (*evcb_selfcb)(struct event_callback *, void *) = evcb->evcb_cb_union.evcb_selfcb; 1757| 952| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 952|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 952| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 952| do { \ | | | | 102| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 952] | | | | ------------------ | | | | 103| 952| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 952| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 952] | | | | ------------------ | | ------------------ | | 125| 952| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 952] | | ------------------ ------------------ 1758| 952| evcb_selfcb(evcb, evcb->evcb_arg); 1759| 952| } 1760| 952| break; 1761| 0| case EV_CLOSURE_EVENT_FINALIZE: ------------------ | | 80| 0|#define EV_CLOSURE_EVENT_FINALIZE 5 ------------------ | Branch (1761:3): [True: 0, False: 952] ------------------ 1762| 0| case EV_CLOSURE_EVENT_FINALIZE_FREE: { ------------------ | | 83| 0|#define EV_CLOSURE_EVENT_FINALIZE_FREE 6 ------------------ | Branch (1762:3): [True: 0, False: 952] ------------------ 1763| 0| void (*evcb_evfinalize)(struct event *, void *); 1764| 0| int evcb_closure = evcb->evcb_closure; 1765| 0| EVUTIL_ASSERT(ev != NULL); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1766| 0| base->current_event = NULL; 1767| 0| evcb_evfinalize = ev->ev_evcallback.evcb_cb_union.evcb_evfinalize; 1768| 0| EVUTIL_ASSERT((evcb->evcb_flags & EVLIST_FINALIZING)); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1769| 0| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 0|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 0| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 0| do { \ | | | | 102| 0| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 0] | | | | ------------------ | | | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 0| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 125| 0| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 0] | | ------------------ ------------------ 1770| 0| event_debug_note_teardown_(ev); 1771| 0| evcb_evfinalize(ev, ev->ev_arg); ------------------ | | 61| 0|#define ev_arg ev_evcallback.evcb_arg ------------------ 1772| 0| if (evcb_closure == EV_CLOSURE_EVENT_FINALIZE_FREE) ------------------ | | 83| 0|#define EV_CLOSURE_EVENT_FINALIZE_FREE 6 ------------------ | Branch (1772:8): [True: 0, False: 0] ------------------ 1773| 0| mm_free(ev); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 1774| 0| } 1775| 0| break; 1776| 0| case EV_CLOSURE_CB_FINALIZE: { ------------------ | | 78| 0|#define EV_CLOSURE_CB_FINALIZE 4 ------------------ | Branch (1776:3): [True: 0, False: 952] ------------------ 1777| 0| void (*evcb_cbfinalize)(struct event_callback *, void *) = evcb->evcb_cb_union.evcb_cbfinalize; 1778| 0| base->current_event = NULL; 1779| 0| EVUTIL_ASSERT((evcb->evcb_flags & EVLIST_FINALIZING)); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1780| 0| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 0|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 0| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 0| do { \ | | | | 102| 0| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 0] | | | | ------------------ | | | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 0| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 125| 0| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 0] | | ------------------ ------------------ 1781| 0| evcb_cbfinalize(evcb, evcb->evcb_arg); 1782| 0| } 1783| 0| break; 1784| 0| default: ------------------ | Branch (1784:3): [True: 0, False: 952] ------------------ 1785| 0| EVUTIL_ASSERT(0); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1786| 952| } 1787| | 1788| 952| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 952|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 952| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 952| do { \ | | | | 95| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 952] | | | | ------------------ | | | | 96| 952| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 952| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 952] | | | | ------------------ | | ------------------ | | 120| 952| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 952] | | ------------------ ------------------ 1789| 952| base->current_event = NULL; 1790| 952|#ifndef EVENT__DISABLE_THREAD_SUPPORT 1791| 952| if (base->current_event_waiters) { ------------------ | Branch (1791:7): [True: 0, False: 952] ------------------ 1792| 0| base->current_event_waiters = 0; 1793| 0| EVTHREAD_COND_BROADCAST(base->current_event_cond); ------------------ | | 169| 0| ( (cond) ? evthread_cond_fns_.signal_condition((cond), 1) : 0 ) | | ------------------ | | | Branch (169:4): [True: 0, False: 0] | | ------------------ ------------------ 1794| 0| } 1795| 952|#endif 1796| | 1797| 952| if (base->event_break) ------------------ | Branch (1797:7): [True: 0, False: 952] ------------------ 1798| 0| return -1; 1799| 952| if (count >= max_to_process) ------------------ | Branch (1799:7): [True: 0, False: 952] ------------------ 1800| 0| return count; 1801| 952| if (count && endtime) { ------------------ | Branch (1801:7): [True: 952, False: 0] | Branch (1801:16): [True: 0, False: 952] ------------------ 1802| 0| struct timeval now; 1803| 0| update_time_cache(base); 1804| 0| gettime(base, &now); 1805| 0| if (evutil_timercmp(&now, endtime, >=)) ------------------ | | 613| 0| (((tvp)->tv_sec == (uvp)->tv_sec) ? \ | | ------------------ | | | Branch (613:2): [True: 0, False: 0] | | | Branch (613:3): [True: 0, False: 0] | | ------------------ | | 614| 0| ((tvp)->tv_usec cmp (uvp)->tv_usec) : \ | | 615| 0| ((tvp)->tv_sec cmp (uvp)->tv_sec)) ------------------ 1806| 0| return count; 1807| 0| } 1808| 952| if (base->event_continue) ------------------ | Branch (1808:7): [True: 0, False: 952] ------------------ 1809| 0| break; 1810| 952| } 1811| 952| return count; 1812| 952|} event.c:event_debug_assert_socket_nonblocking_: 395| 4.76k|{ 396| 4.76k| if (!event_debug_mode_on_) ------------------ | Branch (396:6): [True: 4.76k, False: 0] ------------------ 397| 4.76k| return; 398| 0| if (fd < 0) ------------------ | Branch (398:6): [True: 0, False: 0] ------------------ 399| 0| return; 400| | 401| 0|#ifndef _WIN32 402| 0| { 403| 0| int flags; 404| 0| if ((flags = fcntl(fd, F_GETFL, NULL)) >= 0) { ------------------ | Branch (404:7): [True: 0, False: 0] ------------------ 405| 0| EVUTIL_ASSERT(flags & O_NONBLOCK); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 406| 0| } 407| 0| } 408| 0|#endif 409| 0|} event.c:event_debug_assert_not_added_: 375| 5.71k|{ 376| 5.71k| struct event_debug_entry *dent, find; 377| | 378| 5.71k| if (!event_debug_mode_on_) ------------------ | Branch (378:6): [True: 5.71k, False: 0] ------------------ 379| 5.71k| return; 380| | 381| 0| find.ptr = ev; 382| 0| EVLOCK_LOCK(event_debug_map_lock_, 0); ------------------ | | 94| 0| do { \ | | 95| 0| if (lockvar) \ | | ------------------ | | | Branch (95:7): [True: 0, False: 0] | | ------------------ | | 96| 0| evthread_lock_fns_.lock(mode, lockvar); \ | | 97| 0| } while (0) | | ------------------ | | | Branch (97:11): [Folded, False: 0] | | ------------------ ------------------ 383| 0| dent = HT_FIND(event_debug_map, &global_debug_map, &find); ------------------ | | 52| 0|#define HT_FIND(name, head, elm) name##_HT_FIND((head), (elm)) ------------------ 384| 0| if (dent && dent->added) { ------------------ | Branch (384:6): [True: 0, False: 0] | Branch (384:14): [True: 0, False: 0] ------------------ 385| 0| event_errx(EVENT_ERR_ABORT_, ------------------ | | 44| 0|#define EVENT_ERR_ABORT_ ((int)0xdeaddead) ------------------ 386| 0| "%s called on an already added event %p" 387| 0| " (events: 0x%x, fd: "EV_SOCK_FMT", " 388| 0| "flags: 0x%x)", 389| 0| __func__, (void *)ev, ev->ev_events, ------------------ | | 81| 0|# define __func__ __func__ ------------------ 390| 0| EV_SOCK_ARG(ev->ev_fd), ev->ev_flags); ------------------ | | 499| 0|#define EV_SOCK_ARG(x) (x) ------------------ EV_SOCK_ARG(ev->ev_fd), ev->ev_flags); ------------------ | | 58| 0|#define ev_flags ev_evcallback.evcb_flags ------------------ 391| 0| } 392| 0| EVLOCK_UNLOCK(event_debug_map_lock_, 0); ------------------ | | 101| 0| do { \ | | 102| 0| if (lockvar) \ | | ------------------ | | | Branch (102:7): [True: 0, False: 0] | | ------------------ | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | 104| 0| } while (0) | | ------------------ | | | Branch (104:11): [Folded, False: 0] | | ------------------ ------------------ 393| 0|} event.c:event_debug_note_setup_: 257| 4.76k|{ 258| 4.76k| struct event_debug_entry *dent, find; 259| | 260| 4.76k| if (!event_debug_mode_on_) ------------------ | Branch (260:6): [True: 4.76k, False: 0] ------------------ 261| 4.76k| goto out; 262| | 263| 0| find.ptr = ev; 264| 0| EVLOCK_LOCK(event_debug_map_lock_, 0); ------------------ | | 94| 0| do { \ | | 95| 0| if (lockvar) \ | | ------------------ | | | Branch (95:7): [True: 0, False: 0] | | ------------------ | | 96| 0| evthread_lock_fns_.lock(mode, lockvar); \ | | 97| 0| } while (0) | | ------------------ | | | Branch (97:11): [Folded, False: 0] | | ------------------ ------------------ 265| 0| dent = HT_FIND(event_debug_map, &global_debug_map, &find); ------------------ | | 52| 0|#define HT_FIND(name, head, elm) name##_HT_FIND((head), (elm)) ------------------ 266| 0| if (dent) { ------------------ | Branch (266:6): [True: 0, False: 0] ------------------ 267| 0| dent->added = 0; 268| 0| } else { 269| 0| dent = mm_malloc(sizeof(*dent)); ------------------ | | 76| 0|#define mm_malloc(sz) event_mm_malloc_(sz) ------------------ 270| 0| if (!dent) ------------------ | Branch (270:7): [True: 0, False: 0] ------------------ 271| 0| event_err(1, 272| 0| "Out of memory in debugging code"); 273| 0| dent->ptr = ev; 274| 0| dent->added = 0; 275| 0| HT_INSERT(event_debug_map, &global_debug_map, dent); ------------------ | | 53| 0|#define HT_INSERT(name, head, elm) name##_HT_INSERT((head), (elm)) ------------------ 276| 0| } 277| 0| EVLOCK_UNLOCK(event_debug_map_lock_, 0); ------------------ | | 101| 0| do { \ | | 102| 0| if (lockvar) \ | | ------------------ | | | Branch (102:7): [True: 0, False: 0] | | ------------------ | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | 104| 0| } while (0) | | ------------------ | | | Branch (104:11): [Folded, False: 0] | | ------------------ ------------------ 278| | 279| 4.76k|out: 280| 4.76k| event_debug_mode_too_late_set(); 281| 4.76k|} event.c:event_debug_mode_too_late_set: 243| 13.3k|{ 244| | /* event_base_new_with_config() should have already set event_debug_mode_too_late under lock */ 245| 13.3k|#ifndef EVENT__DISABLE_DEBUG_MODE 246| 13.3k| if (!event_debug_mode_too_late) { ------------------ | Branch (246:6): [True: 0, False: 13.3k] ------------------ 247| 0| EVLOCK_LOCK(event_debug_map_lock_, 0); ------------------ | | 94| 0| do { \ | | 95| 0| if (lockvar) \ | | ------------------ | | | Branch (95:7): [True: 0, False: 0] | | ------------------ | | 96| 0| evthread_lock_fns_.lock(mode, lockvar); \ | | 97| 0| } while (0) | | ------------------ | | | Branch (97:11): [Folded, False: 0] | | ------------------ ------------------ 248| 0| if (!event_debug_mode_too_late) ------------------ | Branch (248:7): [True: 0, False: 0] ------------------ 249| 0| event_debug_mode_too_late = 1; 250| 0| EVLOCK_UNLOCK(event_debug_map_lock_, 0); ------------------ | | 101| 0| do { \ | | 102| 0| if (lockvar) \ | | ------------------ | | | Branch (102:7): [True: 0, False: 0] | | ------------------ | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | 104| 0| } while (0) | | ------------------ | | | Branch (104:11): [Folded, False: 0] | | ------------------ ------------------ 251| 0| } 252| 13.3k|#endif 253| 13.3k|} event.c:event_debug_assert_is_setup_: 354| 1.90k|{ 355| 1.90k| struct event_debug_entry *dent, find; 356| | 357| 1.90k| if (!event_debug_mode_on_) ------------------ | Branch (357:6): [True: 1.90k, False: 0] ------------------ 358| 1.90k| return; 359| | 360| 0| find.ptr = ev; 361| 0| EVLOCK_LOCK(event_debug_map_lock_, 0); ------------------ | | 94| 0| do { \ | | 95| 0| if (lockvar) \ | | ------------------ | | | Branch (95:7): [True: 0, False: 0] | | ------------------ | | 96| 0| evthread_lock_fns_.lock(mode, lockvar); \ | | 97| 0| } while (0) | | ------------------ | | | Branch (97:11): [Folded, False: 0] | | ------------------ ------------------ 362| 0| dent = HT_FIND(event_debug_map, &global_debug_map, &find); ------------------ | | 52| 0|#define HT_FIND(name, head, elm) name##_HT_FIND((head), (elm)) ------------------ 363| 0| if (!dent) { ------------------ | Branch (363:6): [True: 0, False: 0] ------------------ 364| 0| event_errx(EVENT_ERR_ABORT_, ------------------ | | 44| 0|#define EVENT_ERR_ABORT_ ((int)0xdeaddead) ------------------ 365| 0| "%s called on a non-initialized event %p" 366| 0| " (events: 0x%x, fd: "EV_SOCK_FMT 367| 0| ", flags: 0x%x)", 368| 0| __func__, (void *)ev, ev->ev_events, ------------------ | | 81| 0|# define __func__ __func__ ------------------ 369| 0| EV_SOCK_ARG(ev->ev_fd), ev->ev_flags); ------------------ | | 499| 0|#define EV_SOCK_ARG(x) (x) ------------------ EV_SOCK_ARG(ev->ev_fd), ev->ev_flags); ------------------ | | 58| 0|#define ev_flags ev_evcallback.evcb_flags ------------------ 370| 0| } 371| 0| EVLOCK_UNLOCK(event_debug_map_lock_, 0); ------------------ | | 101| 0| do { \ | | 102| 0| if (lockvar) \ | | ------------------ | | | Branch (102:7): [True: 0, False: 0] | | ------------------ | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | 104| 0| } while (0) | | ------------------ | | | Branch (104:11): [Folded, False: 0] | | ------------------ ------------------ 372| 0|} event.c:event_callback_to_event: 513| 7.61k|{ 514| 7.61k| EVUTIL_ASSERT((evcb->evcb_flags & EVLIST_INIT)); ------------------ | | 368| 7.61k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 7.61k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 7.61k| (void)sizeof(!(condition)); \ | | | | 98| 7.61k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 7.61k] | | | | ------------------ | | ------------------ ------------------ 515| | return EVUTIL_UPCAST(evcb, struct event, ev_evcallback); ------------------ | | 289| 7.61k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | ------------------ | | | | 625| 7.61k|#define evutil_offsetof(type, field) offsetof(type, field) | | ------------------ ------------------ 516| 7.61k|} event.c:event_debug_note_teardown_: 284| 952|{ 285| 952| struct event_debug_entry *dent, find; 286| | 287| 952| if (!event_debug_mode_on_) ------------------ | Branch (287:6): [True: 952, False: 0] ------------------ 288| 952| goto out; 289| | 290| 0| find.ptr = ev; 291| 0| EVLOCK_LOCK(event_debug_map_lock_, 0); ------------------ | | 94| 0| do { \ | | 95| 0| if (lockvar) \ | | ------------------ | | | Branch (95:7): [True: 0, False: 0] | | ------------------ | | 96| 0| evthread_lock_fns_.lock(mode, lockvar); \ | | 97| 0| } while (0) | | ------------------ | | | Branch (97:11): [Folded, False: 0] | | ------------------ ------------------ 292| 0| dent = HT_REMOVE(event_debug_map, &global_debug_map, &find); ------------------ | | 55| 0|#define HT_REMOVE(name, head, elm) name##_HT_REMOVE((head), (elm)) ------------------ 293| 0| if (dent) ------------------ | Branch (293:6): [True: 0, False: 0] ------------------ 294| 0| mm_free(dent); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 295| 0| EVLOCK_UNLOCK(event_debug_map_lock_, 0); ------------------ | | 101| 0| do { \ | | 102| 0| if (lockvar) \ | | ------------------ | | | Branch (102:7): [True: 0, False: 0] | | ------------------ | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | 104| 0| } while (0) | | ------------------ | | | Branch (104:11): [Folded, False: 0] | | ------------------ ------------------ 296| | 297| 952|out: 298| 952| event_debug_mode_too_late_set(); 299| 952|} event.c:event_to_event_callback: 520| 7.61k|{ 521| 7.61k| return &ev->ev_evcallback; 522| 7.61k|} event.c:event_del_: 2877| 1.90k|{ 2878| 1.90k| int res; 2879| 1.90k| struct event_base *base = ev->ev_base; 2880| | 2881| 1.90k| if (EVUTIL_FAILURE_CHECK(!base)) { ------------------ | | 369| 1.90k|#define EVUTIL_FAILURE_CHECK(cond) 0 | | ------------------ | | | Branch (369:36): [Folded, False: 1.90k] | | ------------------ ------------------ 2882| 0| event_warnx("%s: event has no event_base set.", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 2883| 0| return -1; 2884| 0| } 2885| | 2886| 1.90k| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 1.90k|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 1.90k| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 1.90k| do { \ | | | | 95| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 96| 1.90k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 120| 1.90k| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 1.90k] | | ------------------ ------------------ 2887| 1.90k| res = event_del_nolock_(ev, blocking); 2888| 1.90k| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 1.90k|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 1.90k| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 1.90k| do { \ | | | | 102| 1.90k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.90k] | | | | ------------------ | | | | 103| 1.90k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.90k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.90k] | | | | ------------------ | | ------------------ | | 125| 1.90k| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 1.90k] | | ------------------ ------------------ 2889| | 2890| 1.90k| return (res); 2891| 1.90k|} event.c:event_debug_note_del_: 328| 7.61k|{ 329| 7.61k| struct event_debug_entry *dent, find; 330| | 331| 7.61k| if (!event_debug_mode_on_) ------------------ | Branch (331:6): [True: 7.61k, False: 0] ------------------ 332| 7.61k| goto out; 333| | 334| 0| find.ptr = ev; 335| 0| EVLOCK_LOCK(event_debug_map_lock_, 0); ------------------ | | 94| 0| do { \ | | 95| 0| if (lockvar) \ | | ------------------ | | | Branch (95:7): [True: 0, False: 0] | | ------------------ | | 96| 0| evthread_lock_fns_.lock(mode, lockvar); \ | | 97| 0| } while (0) | | ------------------ | | | Branch (97:11): [Folded, False: 0] | | ------------------ ------------------ 336| 0| dent = HT_FIND(event_debug_map, &global_debug_map, &find); ------------------ | | 52| 0|#define HT_FIND(name, head, elm) name##_HT_FIND((head), (elm)) ------------------ 337| 0| if (dent) { ------------------ | Branch (337:6): [True: 0, False: 0] ------------------ 338| 0| dent->added = 0; 339| 0| } else { 340| 0| event_errx(EVENT_ERR_ABORT_, ------------------ | | 44| 0|#define EVENT_ERR_ABORT_ ((int)0xdeaddead) ------------------ 341| 0| "%s: noting a del on a non-setup event %p" 342| 0| " (events: 0x%x, fd: "EV_SOCK_FMT 343| 0| ", flags: 0x%x)", 344| 0| __func__, (void *)ev, ev->ev_events, ------------------ | | 81| 0|# define __func__ __func__ ------------------ 345| 0| EV_SOCK_ARG(ev->ev_fd), ev->ev_flags); ------------------ | | 499| 0|#define EV_SOCK_ARG(x) (x) ------------------ EV_SOCK_ARG(ev->ev_fd), ev->ev_flags); ------------------ | | 58| 0|#define ev_flags ev_evcallback.evcb_flags ------------------ 346| 0| } 347| 0| EVLOCK_UNLOCK(event_debug_map_lock_, 0); ------------------ | | 101| 0| do { \ | | 102| 0| if (lockvar) \ | | ------------------ | | | Branch (102:7): [True: 0, False: 0] | | ------------------ | | 103| 0| evthread_lock_fns_.unlock(mode, lockvar); \ | | 104| 0| } while (0) | | ------------------ | | | Branch (104:11): [Folded, False: 0] | | ------------------ ------------------ 348| | 349| 7.61k|out: 350| 7.61k| event_debug_mode_too_late_set(); 351| 7.61k|} event.c:timeout_process: 3285| 952|{ 3286| | /* Caller must hold lock. */ 3287| 952| struct timeval now; 3288| 952| struct event *ev; 3289| | 3290| 952| if (min_heap_empty_(&base->timeheap)) { ------------------ | Branch (3290:6): [True: 952, False: 0] ------------------ 3291| 952| return; 3292| 952| } 3293| | 3294| 0| gettime(base, &now); 3295| | 3296| 0| while ((ev = min_heap_top_(&base->timeheap))) { ------------------ | Branch (3296:9): [True: 0, False: 0] ------------------ 3297| 0| int was_active = ev->ev_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER); ------------------ | | 58| 0|#define ev_flags ev_evcallback.evcb_flags ------------------ int was_active = ev->ev_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER); ------------------ | | 60| 0|#define EVLIST_ACTIVE 0x08 ------------------ int was_active = ev->ev_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER); ------------------ | | 62| 0|#define EVLIST_ACTIVE_LATER 0x20 ------------------ 3298| | 3299| 0| if (evutil_timercmp(&ev->ev_timeout, &now, >)) ------------------ | | 613| 0| (((tvp)->tv_sec == (uvp)->tv_sec) ? \ | | ------------------ | | | Branch (613:2): [True: 0, False: 0] | | | Branch (613:3): [True: 0, False: 0] | | ------------------ | | 614| 0| ((tvp)->tv_usec cmp (uvp)->tv_usec) : \ | | 615| 0| ((tvp)->tv_sec cmp (uvp)->tv_sec)) ------------------ 3300| 0| break; 3301| | 3302| 0| if (!was_active) ------------------ | Branch (3302:7): [True: 0, False: 0] ------------------ 3303| 0| event_del_nolock_(ev, EVENT_DEL_NOBLOCK); ------------------ | | 461| 0|#define EVENT_DEL_NOBLOCK 0 ------------------ 3304| 0| else 3305| 0| event_queue_remove_timeout(base, ev); 3306| | 3307| 0| event_debug(("timeout_process: event: %p, call %p (was active: %i)", ------------------ | | 79| 0|#define event_debug(x) do { \ | | 80| 0| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 0|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 0| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 0] | | ------------------ ------------------ 3308| 0| (void *)ev, (void *)ev->ev_callback, was_active)); 3309| 0| event_active_nolock_(ev, EV_TIMEOUT, 1); ------------------ | | 955| 0|#define EV_TIMEOUT 0x01 ------------------ 3310| 0| } 3311| 0|} event.c:event_queue_remove_active: 3344| 2.85k|{ 3345| 2.85k| EVENT_BASE_ASSERT_LOCKED(base); ------------------ | | 421| 2.85k| EVLOCK_ASSERT_LOCKED((base)->th_base_lock) | | ------------------ | | | | 130| 2.85k| do { \ | | | | 131| 2.85k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 2.85k] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 2.85k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 2.85k] | | | | ------------------ | | ------------------ ------------------ 3346| 2.85k| if (EVUTIL_FAILURE_CHECK(!(evcb->evcb_flags & EVLIST_ACTIVE))) { ------------------ | | 369| 2.85k|#define EVUTIL_FAILURE_CHECK(cond) 0 | | ------------------ | | | Branch (369:36): [Folded, False: 2.85k] | | ------------------ ------------------ 3347| 0| event_errx(1, "%s: %p not on queue %x", __func__, ------------------ | | 81| 0|# define __func__ __func__ ------------------ 3348| 0| (void *)evcb, EVLIST_ACTIVE); ------------------ | | 60| 0|#define EVLIST_ACTIVE 0x08 ------------------ 3349| 0| return; 3350| 0| } 3351| 2.85k| DECR_EVENT_COUNT(base, evcb->evcb_flags); ------------------ | | 3324| 2.85k| ((base)->event_count -= !((flags) & EVLIST_INTERNAL)) | | ------------------ | | | | 61| 2.85k|#define EVLIST_INTERNAL 0x10 | | ------------------ ------------------ 3352| 2.85k| evcb->evcb_flags &= ~EVLIST_ACTIVE; ------------------ | | 60| 2.85k|#define EVLIST_ACTIVE 0x08 ------------------ 3353| 2.85k| base->event_count_active--; 3354| | 3355| | TAILQ_REMOVE(&base->activequeues[evcb->evcb_pri], ------------------ | | 356| 2.85k|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 2.85k| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 952, False: 1.90k] | | ------------------ | | 358| 2.85k| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 952| (elm)->field.tqe_prev; \ | | 360| 2.85k| else \ | | 361| 2.85k| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 2.85k| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 2.85k|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 2.85k] | | ------------------ ------------------ 3356| 2.85k| evcb, evcb_active_next); 3357| 2.85k|} event.c:event_queue_insert_active: 3485| 2.85k|{ 3486| 2.85k| EVENT_BASE_ASSERT_LOCKED(base); ------------------ | | 421| 2.85k| EVLOCK_ASSERT_LOCKED((base)->th_base_lock) | | ------------------ | | | | 130| 2.85k| do { \ | | | | 131| 2.85k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 2.85k] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 2.85k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 2.85k] | | | | ------------------ | | ------------------ ------------------ 3487| | 3488| 2.85k| if (evcb->evcb_flags & EVLIST_ACTIVE) { ------------------ | | 60| 2.85k|#define EVLIST_ACTIVE 0x08 ------------------ | Branch (3488:6): [True: 0, False: 2.85k] ------------------ 3489| | /* Double insertion is possible for active events */ 3490| 0| return; 3491| 0| } 3492| | 3493| 2.85k| INCR_EVENT_COUNT(base, evcb->evcb_flags); ------------------ | | 3325| 2.85k|#define INCR_EVENT_COUNT(base,flags) do { \ | | 3326| 2.85k| ((base)->event_count += !((flags) & EVLIST_INTERNAL)); \ | | ------------------ | | | | 61| 2.85k|#define EVLIST_INTERNAL 0x10 | | ------------------ | | 3327| 2.85k| MAX_EVENT_COUNT((base)->event_count_max, (base)->event_count); \ | | ------------------ | | | | 3317| 2.85k|#define MAX_EVENT_COUNT(var, v) var = MAX(var, v) | | | | ------------------ | | | | | | 3314| 2.85k|#define MAX(a,b) (((a)>(b))?(a):(b)) | | | | | | ------------------ | | | | | | | Branch (3314:19): [True: 0, False: 2.85k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 3328| 2.85k|} while (0) | | ------------------ | | | Branch (3328:10): [Folded, False: 2.85k] | | ------------------ ------------------ 3494| | 3495| 2.85k| evcb->evcb_flags |= EVLIST_ACTIVE; ------------------ | | 60| 2.85k|#define EVLIST_ACTIVE 0x08 ------------------ 3496| | 3497| 2.85k| base->event_count_active++; 3498| 2.85k| MAX_EVENT_COUNT(base->event_count_active_max, base->event_count_active); ------------------ | | 3317| 2.85k|#define MAX_EVENT_COUNT(var, v) var = MAX(var, v) | | ------------------ | | | | 3314| 2.85k|#define MAX(a,b) (((a)>(b))?(a):(b)) | | | | ------------------ | | | | | Branch (3314:19): [True: 0, False: 2.85k] | | | | ------------------ | | ------------------ ------------------ 3499| 2.85k| EVUTIL_ASSERT(evcb->evcb_pri < base->nactivequeues); ------------------ | | 368| 2.85k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 2.85k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 2.85k| (void)sizeof(!(condition)); \ | | | | 98| 2.85k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 2.85k] | | | | ------------------ | | ------------------ ------------------ 3500| | TAILQ_INSERT_TAIL(&base->activequeues[evcb->evcb_pri], ------------------ | | 332| 2.85k|#define TAILQ_INSERT_TAIL(head, elm, field) do { \ | | 333| 2.85k| (elm)->field.tqe_next = NULL; \ | | 334| 2.85k| (elm)->field.tqe_prev = (head)->tqh_last; \ | | 335| 2.85k| *(head)->tqh_last = (elm); \ | | 336| 2.85k| (head)->tqh_last = &(elm)->field.tqe_next; \ | | 337| 2.85k|} while (0) | | ------------------ | | | Branch (337:10): [Folded, False: 2.85k] | | ------------------ ------------------ 3501| 2.85k| evcb, evcb_active_next); 3502| 2.85k|} event.c:event_queue_make_later_events_active: 3547| 952|{ 3548| 952| struct event_callback *evcb; 3549| 952| EVENT_BASE_ASSERT_LOCKED(base); ------------------ | | 421| 952| EVLOCK_ASSERT_LOCKED((base)->th_base_lock) | | ------------------ | | | | 130| 952| do { \ | | | | 131| 952| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 952] | | | | | Branch (131:17): [True: 0, False: 0] | | | | ------------------ | | | | 132| 0| EVUTIL_ASSERT(evthread_is_debug_lock_held_(lock)); \ | | | | ------------------ | | | | | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | | | | | ------------------ | | | | | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | | | | | 98| 0|} while(0) | | | | | | | | ------------------ | | | | | | | | | Branch (98:9): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 133| 0| } \ | | | | 134| 952| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 952] | | | | ------------------ | | ------------------ ------------------ 3550| | 3551| 952| while ((evcb = TAILQ_FIRST(&base->active_later_queue))) { ------------------ | | 293| 952|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (3551:9): [True: 0, False: 952] ------------------ 3552| 0| TAILQ_REMOVE(&base->active_later_queue, evcb, evcb_active_next); ------------------ | | 356| 0|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 0| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 0, False: 0] | | ------------------ | | 358| 0| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 0| (elm)->field.tqe_prev; \ | | 360| 0| else \ | | 361| 0| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 0| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 0|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 0] | | ------------------ ------------------ 3553| 0| evcb->evcb_flags = (evcb->evcb_flags & ~EVLIST_ACTIVE_LATER) | EVLIST_ACTIVE; ------------------ | | 62| 0|#define EVLIST_ACTIVE_LATER 0x20 ------------------ evcb->evcb_flags = (evcb->evcb_flags & ~EVLIST_ACTIVE_LATER) | EVLIST_ACTIVE; ------------------ | | 60| 0|#define EVLIST_ACTIVE 0x08 ------------------ 3554| 0| EVUTIL_ASSERT(evcb->evcb_pri < base->nactivequeues); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 3555| 0| TAILQ_INSERT_TAIL(&base->activequeues[evcb->evcb_pri], evcb, evcb_active_next); ------------------ | | 332| 0|#define TAILQ_INSERT_TAIL(head, elm, field) do { \ | | 333| 0| (elm)->field.tqe_next = NULL; \ | | 334| 0| (elm)->field.tqe_prev = (head)->tqh_last; \ | | 335| 0| *(head)->tqh_last = (elm); \ | | 336| 0| (head)->tqh_last = &(elm)->field.tqe_next; \ | | 337| 0|} while (0) | | ------------------ | | | Branch (337:10): [Folded, False: 0] | | ------------------ ------------------ 3556| 0| base->n_deferreds_queued += (evcb->evcb_closure == EV_CLOSURE_CB_SELF); ------------------ | | 76| 0|#define EV_CLOSURE_CB_SELF 3 ------------------ 3557| 0| } 3558| 952|} evmap_io_initmap_: 190| 952|{ 191| 952| evmap_signal_initmap_(ctx); 192| 952|} evmap_io_clear_: 195| 952|{ 196| 952| evmap_signal_clear_(ctx); 197| 952|} evmap_signal_initmap_: 236| 1.90k|{ 237| 1.90k| ctx->nentries = 0; 238| | ctx->entries = NULL; 239| 1.90k|} evmap_signal_clear_: 243| 1.90k|{ 244| 1.90k| if (ctx->entries != NULL) { ------------------ | Branch (244:6): [True: 0, False: 1.90k] ------------------ 245| 0| int i; 246| 0| for (i = 0; i < ctx->nentries; ++i) { ------------------ | Branch (246:15): [True: 0, False: 0] ------------------ 247| 0| if (ctx->entries[i] != NULL) ------------------ | Branch (247:8): [True: 0, False: 0] ------------------ 248| 0| mm_free(ctx->entries[i]); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 249| 0| } 250| 0| mm_free(ctx->entries); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 251| | ctx->entries = NULL; 252| 0| } 253| 1.90k| ctx->nentries = 0; 254| 1.90k|} evmap_delete_all_: 695| 952|{ 696| 952| evmap_signal_foreach_signal(base, evmap_signal_delete_all_iter_fn, NULL); 697| | evmap_io_foreach_fd(base, evmap_io_delete_all_iter_fn, NULL); 698| 952|} event_changelist_init_: 710| 1.90k|{ 711| | changelist->changes = NULL; 712| 1.90k| changelist->changes_size = 0; 713| 1.90k| changelist->n_changes = 0; 714| 1.90k|} event_changelist_remove_all_: 782| 952|{ 783| 952| int i; 784| | 785| 952| event_changelist_check(base); ------------------ | | 776| 952|#define event_changelist_check(base) ((void)0) ------------------ 786| | 787| 952| for (i = 0; i < changelist->n_changes; ++i) { ------------------ | Branch (787:14): [True: 0, False: 952] ------------------ 788| 0| struct event_change *ch = &changelist->changes[i]; 789| 0| struct event_changelist_fdinfo *fdinfo = 790| 0| event_change_get_fdinfo(base, ch); 791| 0| EVUTIL_ASSERT(fdinfo->idxplus1 == i + 1); ------------------ | | 368| 0|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 0|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 0| (void)sizeof(!(condition)); \ | | | | 98| 0|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 792| 0| fdinfo->idxplus1 = 0; 793| 0| } 794| | 795| 952| changelist->n_changes = 0; 796| | 797| 952| event_changelist_check(base); ------------------ | | 776| 952|#define event_changelist_check(base) ((void)0) ------------------ 798| 952|} event_changelist_freemem_: 802| 952|{ 803| 952| if (changelist->changes) ------------------ | Branch (803:6): [True: 0, False: 952] ------------------ 804| 0| mm_free(changelist->changes); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 805| 952| event_changelist_init_(changelist); /* zero it all out. */ 806| 952|} evmap.c:evmap_io_foreach_fd: 549| 952|{ 550| 952| evutil_socket_t fd; ------------------ | | 325| 952|#define evutil_socket_t int ------------------ 551| 952| struct event_io_map *iomap = &base->io; 552| 952| int r = 0; 553| |#ifdef EVMAP_USE_HT 554| | struct event_map_entry **mapent; 555| | HT_FOREACH(mapent, event_io_map, iomap) { 556| | struct evmap_io *ctx = &(*mapent)->ent.evmap_io; 557| | fd = (*mapent)->fd; 558| |#else 559| 952| for (fd = 0; fd < iomap->nentries; ++fd) { ------------------ | Branch (559:15): [True: 0, False: 952] ------------------ 560| 0| struct evmap_io *ctx = iomap->entries[fd]; 561| 0| if (!ctx) ------------------ | Branch (561:7): [True: 0, False: 0] ------------------ 562| 0| continue; 563| 0|#endif 564| 0| if ((r = fn(base, fd, ctx, arg))) ------------------ | Branch (564:7): [True: 0, False: 0] ------------------ 565| 0| break; 566| 0| } 567| 952| return r; 568| 952|} evmap.c:evmap_signal_foreach_signal: 588| 952|{ 589| 952| struct event_signal_map *sigmap = &base->sigmap; 590| 952| int r = 0; 591| 952| int signum; 592| | 593| 952| for (signum = 0; signum < sigmap->nentries; ++signum) { ------------------ | Branch (593:19): [True: 0, False: 952] ------------------ 594| 0| struct evmap_signal *ctx = sigmap->entries[signum]; 595| 0| if (!ctx) ------------------ | Branch (595:7): [True: 0, False: 0] ------------------ 596| 0| continue; 597| 0| if ((r = fn(base, signum, ctx, arg))) ------------------ | Branch (597:7): [True: 0, False: 0] ------------------ 598| 0| break; 599| 0| } 600| 952| return r; 601| 952|} evutil_closesocket: 615| 1.90k|{ 616| 1.90k|#ifndef _WIN32 617| 1.90k| return close(sock); 618| |#else 619| | return closesocket(sock); 620| |#endif 621| 1.90k|} evutil_snprintf: 2090| 34.5k|{ 2091| 34.5k| int r; 2092| 34.5k| va_list ap; 2093| 34.5k| va_start(ap, format); 2094| 34.5k| r = evutil_vsnprintf(buf, buflen, format, ap); 2095| | va_end(ap); 2096| 34.5k| return r; 2097| 34.5k|} evutil_vsnprintf: 2101| 71.8k|{ 2102| 71.8k| int r; 2103| 71.8k| if (!buflen) ------------------ | Branch (2103:6): [True: 0, False: 71.8k] ------------------ 2104| 0| return 0; 2105| |#if defined(_MSC_VER) || defined(_WIN32) 2106| | r = _vsnprintf(buf, buflen, format, ap); 2107| | if (r < 0) 2108| | r = _vscprintf(format, ap); 2109| |#elif defined(sgi) 2110| | /* Make sure we always use the correct vsnprintf on IRIX */ 2111| | extern int _xpg5_vsnprintf(char * __restrict, 2112| | __SGI_LIBC_NAMESPACE_QUALIFIER size_t, 2113| | const char * __restrict, /* va_list */ char *); 2114| | 2115| | r = _xpg5_vsnprintf(buf, buflen, format, ap); 2116| |#else 2117| 71.8k| r = vsnprintf(buf, buflen, format, ap); 2118| 71.8k|#endif 2119| | // If r >= buflen, the output is truncated, and it is manually guaranteed to end with '\0' 2120| 71.8k| if (r >= 0 && (size_t)r >= buflen) { ------------------ | Branch (2120:6): [True: 71.8k, False: 0] | Branch (2120:16): [True: 0, False: 71.8k] ------------------ 2121| 0| buf[buflen - 1] = '\0'; 2122| 0| } 2123| 71.8k| return r; 2124| 71.8k|} EVUTIL_TOLOWER_: 2617| 190k|{ 2618| 190k| return ((char)EVUTIL_TOLOWER_TABLE[(ev_uint8_t)c]); 2619| 190k|} EVUTIL_TOUPPER_: 2621| 4.76k|{ 2622| 4.76k| return ((char)EVUTIL_TOUPPER_TABLE[(ev_uint8_t)c]); 2623| 4.76k|} evutil_ascii_strcasecmp: 2626| 14.2k|{ 2627| 14.2k| char c1, c2; 2628| 87.5k| while (1) { ------------------ | Branch (2628:9): [True: 87.5k, Folded] ------------------ 2629| 87.5k| c1 = EVUTIL_TOLOWER_(*s1++); 2630| 87.5k| c2 = EVUTIL_TOLOWER_(*s2++); 2631| 87.5k| if (c1 < c2) ------------------ | Branch (2631:7): [True: 2.85k, False: 84.7k] ------------------ 2632| 2.85k| return -1; 2633| 84.7k| else if (c1 > c2) ------------------ | Branch (2633:12): [True: 5.71k, False: 79.0k] ------------------ 2634| 5.71k| return 1; 2635| 79.0k| else if (c1 == 0) ------------------ | Branch (2635:12): [True: 5.71k, False: 73.3k] ------------------ 2636| 5.71k| return 0; 2637| 87.5k| } 2638| 14.2k|} evutil_ascii_strncasecmp: 2640| 1.90k|{ 2641| 1.90k| char c1, c2; 2642| 7.61k| while (n--) { ------------------ | Branch (2642:9): [True: 6.66k, False: 952] ------------------ 2643| 6.66k| c1 = EVUTIL_TOLOWER_(*s1++); 2644| 6.66k| c2 = EVUTIL_TOLOWER_(*s2++); 2645| 6.66k| if (c1 < c2) ------------------ | Branch (2645:7): [True: 0, False: 6.66k] ------------------ 2646| 0| return -1; 2647| 6.66k| else if (c1 > c2) ------------------ | Branch (2647:12): [True: 952, False: 5.71k] ------------------ 2648| 952| return 1; 2649| 5.71k| else if (c1 == 0) ------------------ | Branch (2649:12): [True: 0, False: 5.71k] ------------------ 2650| 0| return 0; 2651| 6.66k| } 2652| 952| return 0; 2653| 1.90k|} evutil_ascii_strcasestr: 2656| 952|{ 2657| 952| char c, sc; 2658| 952| size_t len; 2659| | 2660| 952| if ((c = *find++) != 0) { ------------------ | Branch (2660:6): [True: 952, False: 0] ------------------ 2661| 952| c = EVUTIL_TOLOWER_(c); 2662| 952| len = strlen(find); 2663| 952| do { 2664| 952| do { 2665| 952| if ((sc = *s++) == 0) ------------------ | Branch (2665:9): [True: 0, False: 952] ------------------ 2666| 0| return (NULL); 2667| 952| } while ((char)EVUTIL_TOLOWER_(sc) != c); ------------------ | Branch (2667:13): [True: 0, False: 952] ------------------ 2668| 952| } while (evutil_ascii_strncasecmp(s, find, len) != 0); ------------------ | Branch (2668:12): [True: 0, False: 952] ------------------ 2669| 952| s--; 2670| 952| } 2671| 952| return s; 2672| 952|} evutil_getenv_: 2718| 3.80k|{ 2719| 3.80k| if (evutil_issetugid()) ------------------ | Branch (2719:6): [True: 0, False: 3.80k] ------------------ 2720| 0| return NULL; 2721| | 2722| 3.80k| return getenv(varname); 2723| 3.80k|} evutil_make_internal_pipe_: 3099| 952|{ 3100| | /* 3101| | Making the second socket nonblocking is a bit subtle, given that we 3102| | ignore any EAGAIN returns when writing to it, and you don't usually 3103| | do that for a nonblocking socket. But if the kernel gives us EAGAIN, 3104| | then there's no need to add any more data to the buffer, since 3105| | the main thread is already either about to wake up and drain it, 3106| | or woken up and in the process of draining it. 3107| | */ 3108| | 3109| 952|#if defined(EVENT__HAVE_PIPE2) 3110| 952| if (pipe2(fd, O_NONBLOCK|O_CLOEXEC) == 0) ------------------ | Branch (3110:6): [True: 952, False: 0] ------------------ 3111| 952| return 0; 3112| 0|#endif 3113| 0|#if defined(EVENT__HAVE_PIPE) 3114| 0| if (pipe(fd) == 0) { ------------------ | Branch (3114:6): [True: 0, False: 0] ------------------ 3115| 0| if (evutil_fast_socket_nonblocking(fd[0]) < 0 || ------------------ | Branch (3115:7): [True: 0, False: 0] ------------------ 3116| 0| evutil_fast_socket_nonblocking(fd[1]) < 0 || ------------------ | Branch (3116:7): [True: 0, False: 0] ------------------ 3117| 0| evutil_fast_socket_closeonexec(fd[0]) < 0 || ------------------ | Branch (3117:7): [True: 0, False: 0] ------------------ 3118| 0| evutil_fast_socket_closeonexec(fd[1]) < 0) { ------------------ | Branch (3118:7): [True: 0, False: 0] ------------------ 3119| 0| close(fd[0]); 3120| 0| close(fd[1]); 3121| 0| fd[0] = fd[1] = -1; 3122| 0| return -1; 3123| 0| } 3124| 0| return 0; 3125| 0| } else { 3126| 0| event_warn("%s: pipe", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 3127| 0| } 3128| 0|#endif 3129| | 3130| |#if defined(_WIN32) && !defined(EVENT__HAVE_AFUNIX_H) 3131| |#define LOCAL_SOCKETPAIR_AF AF_INET 3132| |#else 3133| 0|#define LOCAL_SOCKETPAIR_AF AF_UNIX 3134| 0|#endif 3135| 0| if (evutil_socketpair(LOCAL_SOCKETPAIR_AF, SOCK_STREAM|EVUTIL_SOCK_CLOEXEC|EVUTIL_SOCK_NONBLOCK, 0, fd)) { ------------------ | | 3133| 0|#define LOCAL_SOCKETPAIR_AF AF_UNIX ------------------ if (evutil_socketpair(LOCAL_SOCKETPAIR_AF, SOCK_STREAM|EVUTIL_SOCK_CLOEXEC|EVUTIL_SOCK_NONBLOCK, 0, fd)) { ------------------ | | 546| 0|#define EVUTIL_SOCK_CLOEXEC SOCK_CLOEXEC ------------------ if (evutil_socketpair(LOCAL_SOCKETPAIR_AF, SOCK_STREAM|EVUTIL_SOCK_CLOEXEC|EVUTIL_SOCK_NONBLOCK, 0, fd)) { ------------------ | | 541| 0|#define EVUTIL_SOCK_NONBLOCK SOCK_NONBLOCK ------------------ | Branch (3135:6): [True: 0, False: 0] ------------------ 3136| 0| fd[0] = fd[1] = -1; 3137| 0| return -1; 3138| 0| } 3139| 0| return 0; 3140| 0|} evutil.c:evutil_issetugid: 2697| 3.80k|{ 2698| |#ifdef EVENT__HAVE_ISSETUGID 2699| | return issetugid(); 2700| |#elif defined(EVENT__HAVE_SYS_AUXV_H) && defined(AT_SECURE) 2701| 3.80k| return getauxval(AT_SECURE); 2702| |#else 2703| | 2704| |#ifdef EVENT__HAVE_GETEUID 2705| | if (getuid() != geteuid()) 2706| | return 1; 2707| |#endif 2708| |#ifdef EVENT__HAVE_GETEGID 2709| | if (getgid() != getegid()) 2710| | return 1; 2711| |#endif 2712| | return 0; 2713| |#endif 2714| 3.80k|} evutil_tv_to_msec_: 129| 952|{ 130| 952| if (tv->tv_usec > 1000000 || tv->tv_sec > MAX_SECONDS_IN_MSEC_LONG) ------------------ | | 125| 952| (((LONG_MAX) - 999) / 1000) ------------------ | Branch (130:6): [True: 0, False: 952] | Branch (130:31): [True: 0, False: 952] ------------------ 131| 0| return -1; 132| | 133| 952| return (tv->tv_sec * 1000) + ((tv->tv_usec + 999) / 1000); 134| 952|} evutil_configure_monotonic_time_: 309| 952|{ 310| | /* CLOCK_MONOTONIC exists on FreeBSD, Linux, and Solaris. You need to 311| | * check for it at runtime, because some older kernel versions won't 312| | * have it working. */ 313| 952|#ifdef CLOCK_MONOTONIC_COARSE 314| 952| const int precise = flags & EV_MONOT_PRECISE; ------------------ | | 346| 952|#define EV_MONOT_PRECISE 1 ------------------ 315| 952|#endif 316| 952| const int fallback = flags & EV_MONOT_FALLBACK; ------------------ | | 347| 952|#define EV_MONOT_FALLBACK 2 ------------------ 317| 952| struct timespec ts; 318| | 319| 952| memset(base, 0, sizeof(*base)); 320| | 321| 952|#ifdef CLOCK_MONOTONIC_COARSE 322| 952| if (CLOCK_MONOTONIC_COARSE < 0) { ------------------ | Branch (322:6): [Folded, False: 952] ------------------ 323| | /* Technically speaking, nothing keeps CLOCK_* from being 324| | * negative (as far as I know). This check and the one below 325| | * make sure that it's safe for us to use -1 as an "unset" 326| | * value. */ 327| 0| event_errx(1,"I didn't expect CLOCK_MONOTONIC_COARSE to be < 0"); 328| 0| } 329| 952| if (! precise && ! fallback) { ------------------ | Branch (329:6): [True: 952, False: 0] | Branch (329:19): [True: 952, False: 0] ------------------ 330| 952| if (clock_gettime(CLOCK_MONOTONIC_COARSE, &ts) == 0) { ------------------ | Branch (330:7): [True: 952, False: 0] ------------------ 331| 952| base->monotonic_clock = CLOCK_MONOTONIC_COARSE; 332| 952| return 0; 333| 952| } 334| 952| } 335| 0|#endif 336| 0| if (!fallback && clock_gettime(CLOCK_MONOTONIC, &ts) == 0) { ------------------ | Branch (336:6): [True: 0, False: 0] | Branch (336:19): [True: 0, False: 0] ------------------ 337| 0| base->monotonic_clock = CLOCK_MONOTONIC; 338| 0| return 0; 339| 0| } 340| | 341| 0| if (CLOCK_MONOTONIC < 0) { ------------------ | Branch (341:6): [Folded, False: 0] ------------------ 342| 0| event_errx(1,"I didn't expect CLOCK_MONOTONIC to be < 0"); 343| 0| } 344| | 345| 0| base->monotonic_clock = -1; 346| 0| return 0; 347| 0|} evutil_gettime_monotonic_: 352| 1.90k|{ 353| 1.90k| struct timespec ts; 354| | 355| 1.90k| if (base->monotonic_clock < 0) { ------------------ | Branch (355:6): [True: 0, False: 1.90k] ------------------ 356| 0| if (evutil_gettimeofday(tp, NULL) < 0) ------------------ | | 637| 0|#define evutil_gettimeofday(tv, tz) gettimeofday((tv), (tz)) ------------------ | Branch (356:7): [True: 0, False: 0] ------------------ 357| 0| return -1; 358| 0| adjust_monotonic_time(base, tp); 359| 0| return 0; 360| 0| } 361| | 362| 1.90k| if (clock_gettime(base->monotonic_clock, &ts) == -1) ------------------ | Branch (362:6): [True: 0, False: 1.90k] ------------------ 363| 0| return -1; 364| 1.90k| tp->tv_sec = ts.tv_sec; 365| 1.90k| tp->tv_usec = ts.tv_nsec / 1000; 366| | 367| 1.90k| return 0; 368| 1.90k|} evhttp_connection_free: 1340| 952|{ 1341| 952| struct evhttp_request *req; 1342| | 1343| | /* notify interested parties that this connection is going down */ 1344| 952| if (evhttp_connected(evcon) && evcon->closecb != NULL) ------------------ | Branch (1344:6): [True: 0, False: 952] | Branch (1344:33): [True: 0, False: 0] ------------------ 1345| 0| (*evcon->closecb)(evcon, evcon->closecb_arg); 1346| | 1347| | /* remove all requests that might be queued on this 1348| | * connection. for server connections, this should be empty. 1349| | * because it gets dequeued either in evhttp_connection_done or 1350| | * evhttp_connection_fail_. 1351| | */ 1352| 952| while ((req = TAILQ_FIRST(&evcon->requests)) != NULL) { ------------------ | | 293| 952|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (1352:9): [True: 0, False: 952] ------------------ 1353| 0| evhttp_request_free_(evcon, req); 1354| 0| } 1355| | 1356| 952| if (evcon->http_server != NULL) { ------------------ | Branch (1356:6): [True: 952, False: 0] ------------------ 1357| 952| struct evhttp *http = evcon->http_server; 1358| 952| TAILQ_REMOVE(&http->connections, evcon, next); ------------------ | | 356| 952|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 952| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 0, False: 952] | | ------------------ | | 358| 952| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 0| (elm)->field.tqe_prev; \ | | 360| 952| else \ | | 361| 952| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 952| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 952|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 952] | | ------------------ ------------------ 1359| 952| http->connection_cnt--; 1360| 952| } 1361| | 1362| 952| if (event_initialized(&evcon->retry_ev)) { ------------------ | Branch (1362:6): [True: 0, False: 952] ------------------ 1363| 0| event_del(&evcon->retry_ev); 1364| 0| event_debug_unassign(&evcon->retry_ev); 1365| 0| } 1366| | 1367| 952| event_deferred_cb_cancel_(get_deferred_queue(evcon), ------------------ | | 1243| 952| ((evcon)->base) ------------------ 1368| 952| &evcon->read_more_deferred_cb); 1369| | 1370| 952| if (evcon->bufev != NULL) { ------------------ | Branch (1370:6): [True: 0, False: 952] ------------------ 1371| 0| bufferevent_free(evcon->bufev); 1372| 0| } 1373| | 1374| 952| if (evcon->bind_address != NULL) ------------------ | Branch (1374:6): [True: 0, False: 952] ------------------ 1375| 0| mm_free(evcon->bind_address); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 1376| | 1377| 952| if (evcon->address != NULL) ------------------ | Branch (1377:6): [True: 952, False: 0] ------------------ 1378| 952| mm_free(evcon->address); ------------------ | | 80| 952|#define mm_free(p) event_mm_free_(p) ------------------ 1379| | 1380| 952|#ifndef _WIN32 1381| 952| if (evcon->unixsocket != NULL) ------------------ | Branch (1381:6): [True: 0, False: 952] ------------------ 1382| 0| mm_free(evcon->unixsocket); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 1383| 952|#endif 1384| | 1385| 952| mm_free(evcon); ------------------ | | 80| 952|#define mm_free(p) event_mm_free_(p) ------------------ 1386| 952|} evhttp_find_header: 2066| 5.71k|{ 2067| 5.71k| struct evkeyval *header; 2068| | 2069| 12.3k| TAILQ_FOREACH(header, headers, next) { ------------------ | | 305| 5.71k| for((var) = TAILQ_FIRST(head); \ | | ------------------ | | | | 293| 5.71k|#define TAILQ_FIRST(head) ((head)->tqh_first) | | ------------------ | | 306| 13.3k| (var) != TAILQ_END(head); \ | | ------------------ | | | | 294| 13.3k|#define TAILQ_END(head) NULL | | ------------------ | | | Branch (306:6): [True: 12.3k, False: 952] | | ------------------ | | 307| 7.61k| (var) = TAILQ_NEXT(var, field)) | | ------------------ | | | | 295| 7.61k|#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) | | ------------------ ------------------ 2070| 12.3k| if (evutil_ascii_strcasecmp(header->key, key) == 0) ------------------ | Branch (2070:7): [True: 4.76k, False: 7.61k] ------------------ 2071| 4.76k| return (header->value); 2072| 12.3k| } 2073| | 2074| 952| return (NULL); 2075| 5.71k|} evhttp_clear_headers: 2079| 1.90k|{ 2080| 1.90k| struct evkeyval *header; 2081| | 2082| 1.90k| for (header = TAILQ_FIRST(headers); ------------------ | | 293| 1.90k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ 2083| 7.61k| header != NULL; ------------------ | Branch (2083:6): [True: 5.71k, False: 1.90k] ------------------ 2084| 5.71k| header = TAILQ_FIRST(headers)) { ------------------ | | 293| 5.71k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ 2085| 5.71k| TAILQ_REMOVE(headers, header, next); ------------------ | | 356| 5.71k|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 5.71k| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 3.80k, False: 1.90k] | | ------------------ | | 358| 5.71k| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 3.80k| (elm)->field.tqe_prev; \ | | 360| 5.71k| else \ | | 361| 5.71k| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 5.71k| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 5.71k|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 5.71k] | | ------------------ ------------------ 2086| 5.71k| mm_free(header->key); ------------------ | | 80| 5.71k|#define mm_free(p) event_mm_free_(p) ------------------ 2087| 5.71k| mm_free(header->value); ------------------ | | 80| 5.71k|#define mm_free(p) event_mm_free_(p) ------------------ 2088| 5.71k| mm_free(header); ------------------ | | 80| 5.71k|#define mm_free(p) event_mm_free_(p) ------------------ 2089| 5.71k| } 2090| 1.90k|} evhttp_add_header: 2137| 5.71k|{ 2138| 5.71k| event_debug(("%s: key: %s val: %s\n", __func__, key, value)); ------------------ | | 79| 5.71k|#define event_debug(x) do { \ | | 80| 5.71k| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 5.71k|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 5.71k] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 5.71k| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 5.71k] | | ------------------ ------------------ 2139| | 2140| | /* RFC 9110 defines field-names as case-sensitive non-empty strings made of the following characters */ 2141| | // field-name = 1*tchar 2142| | // tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~" / 0-9 / A-Z / a-z 2143| | /* For simplicity, we'll reject field-names containing the documented most dangerous characters */ 2144| | // "Field values containing CR, LF, or NUL characters are invalid and dangerous, due to the varying ways that implementations might parse and interpret those characters; a recipient of CR, LF, or NUL within a field value MUST either reject the message or replace each of those characters with SP before further processing or forwarding of that message." 2145| 5.71k| if (strchr(key, '\r') != NULL || strchr(key, '\n') != NULL || key[0] == '\0') { ------------------ | Branch (2145:6): [True: 0, False: 5.71k] | Branch (2145:35): [True: 0, False: 5.71k] | Branch (2145:64): [True: 0, False: 5.71k] ------------------ 2146| | /* drop illegal headers */ 2147| 0| event_debug(("%s: dropping illegal header key\n", __func__)); ------------------ | | 79| 0|#define event_debug(x) do { \ | | 80| 0| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 0|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 0| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 0] | | ------------------ ------------------ 2148| 0| return (-1); 2149| 0| } 2150| | 2151| 5.71k| if (!evhttp_header_is_valid_value(value)) { ------------------ | Branch (2151:6): [True: 0, False: 5.71k] ------------------ 2152| 0| event_debug(("%s: dropping illegal header value\n", __func__)); ------------------ | | 79| 0|#define event_debug(x) do { \ | | 80| 0| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 0|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 0| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 0] | | ------------------ ------------------ 2153| 0| return (-1); 2154| 0| } 2155| | 2156| 5.71k| return (evhttp_add_header_internal(headers, key, value)); 2157| 5.71k|} evhttp_connection_base_bufferevent_new: 2665| 952|{ 2666| 952| struct evhttp_connection *evcon; 2667| | 2668| 952| event_debug(("Attempting connection to %s:%d\n", address, port)); ------------------ | | 79| 952|#define event_debug(x) do { \ | | 80| 952| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 952|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 952] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 952| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 952] | | ------------------ ------------------ 2669| | 2670| 952| evcon = evhttp_connection_new_(base, bev); 2671| 952| if (evcon == NULL) ------------------ | Branch (2671:6): [True: 0, False: 952] ------------------ 2672| 0| goto error; 2673| | 2674| 952| if ((evcon->address = mm_strdup(address)) == NULL) { ------------------ | | 78| 952|#define mm_strdup(s) event_mm_strdup_(s) ------------------ | Branch (2674:6): [True: 0, False: 952] ------------------ 2675| 0| event_warn("%s: strdup failed", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 2676| 0| goto error; 2677| 0| } 2678| 952| evcon->port = port; 2679| 952| evcon->dns_base = dnsbase; 2680| | 2681| 952| return (evcon); 2682| 0|error: 2683| 0| if (evcon != NULL) ------------------ | Branch (2683:6): [True: 0, False: 0] ------------------ 2684| 0| evhttp_connection_free(evcon); 2685| | return (NULL); 2686| 952|} evhttp_start_ws_: 3249| 952|{ 3250| 952| struct evhttp_connection *evcon = req->evcon; 3251| 952| struct bufferevent *bufev; 3252| | 3253| 952| evhttp_response_code_(req, HTTP_SWITCH_PROTOCOLS, "Switching Protocols"); ------------------ | | 57| 952|#define HTTP_SWITCH_PROTOCOLS 101 /**< switching to another protocol */ ------------------ 3254| | 3255| 952| if (req->evcon == NULL) ------------------ | Branch (3255:6): [True: 0, False: 952] ------------------ 3256| 0| return NULL; 3257| | 3258| 952| evhttp_make_header(req->evcon, req); 3259| 952| evhttp_write_buffer(req->evcon, NULL, NULL); 3260| | 3261| 952| TAILQ_REMOVE(&evcon->requests, req, next); ------------------ | | 356| 952|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 952| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 0, False: 952] | | ------------------ | | 358| 952| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 0| (elm)->field.tqe_prev; \ | | 360| 952| else \ | | 361| 952| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 952| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 952|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 952] | | ------------------ ------------------ 3262| | 3263| 952| bufev = evcon->bufev; 3264| 952| evcon->bufev = NULL; 3265| 952| evcon->closecb = NULL; 3266| | 3267| 952| evhttp_request_free(req); 3268| 952| evhttp_connection_free(evcon); 3269| 952| return bufev; 3270| 952|} evhttp_response_code_: 3399| 952|{ 3400| 952| req->kind = EVHTTP_RESPONSE; 3401| 952| req->response_code = code; 3402| 952| if (req->response_code_line != NULL) ------------------ | Branch (3402:6): [True: 0, False: 952] ------------------ 3403| 0| mm_free(req->response_code_line); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 3404| 952| if (reason == NULL) ------------------ | Branch (3404:6): [True: 0, False: 952] ------------------ 3405| 0| reason = evhttp_response_phrase_internal(code); 3406| 952| req->response_code_line = mm_strdup(reason); ------------------ | | 78| 952|#define mm_strdup(s) event_mm_strdup_(s) ------------------ 3407| 952| if (req->response_code_line == NULL) { ------------------ | Branch (3407:6): [True: 0, False: 952] ------------------ 3408| 0| event_warn("%s: strdup", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 3409| | /* XXX what else can we do? */ 3410| 0| } 3411| 952|} evhttp_new: 4049| 952|{ 4050| 952| struct evhttp *http = NULL; 4051| | 4052| 952| http = evhttp_new_object(); 4053| 952| if (http == NULL) ------------------ | Branch (4053:6): [True: 0, False: 952] ------------------ 4054| 0| return (NULL); 4055| 952| http->base = base; 4056| | 4057| 952| return (http); 4058| 952|} evhttp_free: 4082| 952|{ 4083| 952| struct evhttp_cb *http_cb; 4084| 952| struct evhttp_connection *evcon; 4085| 952| struct evws_connection *evws; 4086| 952| struct evhttp_bound_socket *bound; 4087| 952| struct evhttp* vhost; 4088| 952| struct evhttp_server_alias *alias; 4089| | 4090| | /* Remove the accepting part */ 4091| 952| while ((bound = TAILQ_FIRST(&http->sockets)) != NULL) { ------------------ | | 293| 952|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (4091:9): [True: 0, False: 952] ------------------ 4092| 0| TAILQ_REMOVE(&http->sockets, bound, next); ------------------ | | 356| 0|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 0| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 0, False: 0] | | ------------------ | | 358| 0| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 0| (elm)->field.tqe_prev; \ | | 360| 0| else \ | | 361| 0| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 0| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 0|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 0] | | ------------------ ------------------ 4093| | 4094| 0| evconnlistener_free(bound->listener); 4095| | 4096| 0| mm_free(bound); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4097| 0| } 4098| | 4099| 952| while ((evcon = TAILQ_FIRST(&http->connections)) != NULL) { ------------------ | | 293| 952|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (4099:9): [True: 0, False: 952] ------------------ 4100| | /* evhttp_connection_free removes the connection */ 4101| 0| evhttp_connection_free(evcon); 4102| 0| } 4103| | 4104| 952| while ((evws = TAILQ_FIRST(&http->ws_sessions)) != NULL) { ------------------ | | 293| 952|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (4104:9): [True: 0, False: 952] ------------------ 4105| 0| evws_connection_free(evws); 4106| 0| } 4107| | 4108| 952| while ((http_cb = TAILQ_FIRST(&http->callbacks)) != NULL) { ------------------ | | 293| 952|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (4108:9): [True: 0, False: 952] ------------------ 4109| 0| TAILQ_REMOVE(&http->callbacks, http_cb, next); ------------------ | | 356| 0|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 0| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 0, False: 0] | | ------------------ | | 358| 0| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 0| (elm)->field.tqe_prev; \ | | 360| 0| else \ | | 361| 0| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 0| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 0|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 0] | | ------------------ ------------------ 4110| 0| mm_free(http_cb->what); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4111| 0| mm_free(http_cb); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4112| 0| } 4113| | 4114| 952| while ((vhost = TAILQ_FIRST(&http->virtualhosts)) != NULL) { ------------------ | | 293| 952|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (4114:9): [True: 0, False: 952] ------------------ 4115| 0| TAILQ_REMOVE(&http->virtualhosts, vhost, next_vhost); ------------------ | | 356| 0|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 0| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 0, False: 0] | | ------------------ | | 358| 0| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 0| (elm)->field.tqe_prev; \ | | 360| 0| else \ | | 361| 0| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 0| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 0|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 0] | | ------------------ ------------------ 4116| | 4117| 0| evhttp_free(vhost); 4118| 0| } 4119| | 4120| 952| if (http->vhost_pattern != NULL) ------------------ | Branch (4120:6): [True: 0, False: 952] ------------------ 4121| 0| mm_free(http->vhost_pattern); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4122| | 4123| 952| while ((alias = TAILQ_FIRST(&http->aliases)) != NULL) { ------------------ | | 293| 952|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (4123:9): [True: 0, False: 952] ------------------ 4124| 0| TAILQ_REMOVE(&http->aliases, alias, next); ------------------ | | 356| 0|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 0| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 0, False: 0] | | ------------------ | | 358| 0| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 0| (elm)->field.tqe_prev; \ | | 360| 0| else \ | | 361| 0| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 0| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 0|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 0] | | ------------------ ------------------ 4125| 0| mm_free(alias->alias); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4126| 0| mm_free(alias); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4127| 0| } 4128| | 4129| 952| mm_free(http); ------------------ | | 80| 952|#define mm_free(p) event_mm_free_(p) ------------------ 4130| 952|} evhttp_set_max_headers_size: 4240| 952|{ 4241| 952| if (max_headers_size < 0) ------------------ | Branch (4241:6): [True: 952, False: 0] ------------------ 4242| 952| http->default_max_headers_size = EV_SIZE_MAX; ------------------ | | 289| 952|#define EV_SIZE_MAX EV_UINT64_MAX | | ------------------ | | | | 267| 952|#define EV_UINT64_MAX UINT64_MAX | | ------------------ ------------------ 4243| 0| else 4244| 0| http->default_max_headers_size = max_headers_size; 4245| 952|} evhttp_set_max_body_size: 4249| 952|{ 4250| 952| if (max_body_size < 0) ------------------ | Branch (4250:6): [True: 952, False: 0] ------------------ 4251| 952| http->default_max_body_size = EV_UINT64_MAX; ------------------ | | 267| 952|#define EV_UINT64_MAX UINT64_MAX ------------------ 4252| 0| else 4253| 0| http->default_max_body_size = max_body_size; 4254| 952|} evhttp_set_default_content_type: 4273| 952| const char *content_type) { 4274| 952| http->default_content_type = content_type; 4275| 952|} evhttp_set_allowed_methods: 4279| 952|{ 4280| 952| http->allowed_methods = methods; 4281| 952|} evhttp_request_new: 4376| 952|{ 4377| 952| struct evhttp_request *req = NULL; 4378| | 4379| | /* Allocate request structure */ 4380| 952| if ((req = mm_calloc(1, sizeof(struct evhttp_request))) == NULL) { ------------------ | | 77| 952|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ | Branch (4380:6): [True: 0, False: 952] ------------------ 4381| 0| event_warn("%s: calloc", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 4382| 0| goto error; 4383| 0| } 4384| | 4385| 952| req->headers_size = 0; 4386| 952| req->body_size = 0; 4387| | 4388| 952| req->kind = EVHTTP_RESPONSE; 4389| 952| req->input_headers = mm_calloc(1, sizeof(struct evkeyvalq)); ------------------ | | 77| 952|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ 4390| 952| if (req->input_headers == NULL) { ------------------ | Branch (4390:6): [True: 0, False: 952] ------------------ 4391| 0| event_warn("%s: calloc", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 4392| 0| goto error; 4393| 0| } 4394| 952| TAILQ_INIT(req->input_headers); ------------------ | | 317| 952|#define TAILQ_INIT(head) do { \ | | 318| 952| (head)->tqh_first = NULL; \ | | 319| 952| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 952|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 952] | | ------------------ ------------------ 4395| | 4396| 952| req->output_headers = mm_calloc(1, sizeof(struct evkeyvalq)); ------------------ | | 77| 952|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ 4397| 952| if (req->output_headers == NULL) { ------------------ | Branch (4397:6): [True: 0, False: 952] ------------------ 4398| 0| event_warn("%s: calloc", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 4399| 0| goto error; 4400| 0| } 4401| 952| TAILQ_INIT(req->output_headers); ------------------ | | 317| 952|#define TAILQ_INIT(head) do { \ | | 318| 952| (head)->tqh_first = NULL; \ | | 319| 952| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 952|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 952] | | ------------------ ------------------ 4402| | 4403| 952| if ((req->input_buffer = evbuffer_new()) == NULL) { ------------------ | Branch (4403:6): [True: 0, False: 952] ------------------ 4404| 0| event_warn("%s: evbuffer_new", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 4405| 0| goto error; 4406| 0| } 4407| | 4408| 952| if ((req->output_buffer = evbuffer_new()) == NULL) { ------------------ | Branch (4408:6): [True: 0, False: 952] ------------------ 4409| 0| event_warn("%s: evbuffer_new", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 4410| 0| goto error; 4411| 0| } 4412| | 4413| 952| req->cb = cb; 4414| 952| req->cb_arg = arg; 4415| | 4416| 952| return (req); 4417| | 4418| 0| error: 4419| 0| if (req != NULL) ------------------ | Branch (4419:6): [True: 0, False: 0] ------------------ 4420| 0| evhttp_request_free(req); 4421| | return (NULL); 4422| 952|} evhttp_request_free: 4426| 952|{ 4427| 952| if ((req->flags & EVHTTP_REQ_DEFER_FREE) != 0) { ------------------ | | 187| 952|#define EVHTTP_REQ_DEFER_FREE 0x0008 ------------------ | Branch (4427:6): [True: 0, False: 952] ------------------ 4428| 0| req->flags |= EVHTTP_REQ_NEEDS_FREE; ------------------ | | 189| 0|#define EVHTTP_REQ_NEEDS_FREE 0x0010 ------------------ 4429| 0| return; 4430| 0| } 4431| | 4432| 952| if (req->remote_host != NULL) ------------------ | Branch (4432:6): [True: 0, False: 952] ------------------ 4433| 0| mm_free(req->remote_host); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4434| 952| if (req->uri != NULL) ------------------ | Branch (4434:6): [True: 0, False: 952] ------------------ 4435| 0| mm_free(req->uri); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4436| 952| if (req->uri_elems != NULL) ------------------ | Branch (4436:6): [True: 0, False: 952] ------------------ 4437| 0| evhttp_uri_free(req->uri_elems); 4438| 952| if (req->response_code_line != NULL) ------------------ | Branch (4438:6): [True: 952, False: 0] ------------------ 4439| 952| mm_free(req->response_code_line); ------------------ | | 80| 952|#define mm_free(p) event_mm_free_(p) ------------------ 4440| 952| if (req->host_cache != NULL) ------------------ | Branch (4440:6): [True: 0, False: 952] ------------------ 4441| 0| mm_free(req->host_cache); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4442| | 4443| 952| evhttp_clear_headers(req->input_headers); 4444| 952| mm_free(req->input_headers); ------------------ | | 80| 952|#define mm_free(p) event_mm_free_(p) ------------------ 4445| | 4446| 952| evhttp_clear_headers(req->output_headers); 4447| 952| mm_free(req->output_headers); ------------------ | | 80| 952|#define mm_free(p) event_mm_free_(p) ------------------ 4448| | 4449| 952| if (req->input_buffer != NULL) ------------------ | Branch (4449:6): [True: 952, False: 0] ------------------ 4450| 952| evbuffer_free(req->input_buffer); 4451| | 4452| 952| if (req->output_buffer != NULL) ------------------ | Branch (4452:6): [True: 952, False: 0] ------------------ 4453| 952| evbuffer_free(req->output_buffer); 4454| | 4455| 952| mm_free(req); ------------------ | | 80| 952|#define mm_free(p) event_mm_free_(p) ------------------ 4456| 952|} evhttp_request_get_connection: 4472| 952|{ 4473| 952| return req->evcon; 4474| 952|} evhttp_request_get_input_headers: 4587| 1.90k|{ 4588| 1.90k| return (req->input_headers); 4589| 1.90k|} evhttp_request_get_output_headers: 4593| 952|{ 4594| 952| return (req->output_headers); 4595| 952|} http.c:evhttp_connected: 489| 952|{ 490| 952| switch (evcon->state) { 491| 952| case EVCON_DISCONNECTED: ------------------ | Branch (491:2): [True: 952, False: 0] ------------------ 492| 952| case EVCON_CONNECTING: ------------------ | Branch (492:2): [True: 0, False: 952] ------------------ 493| 952| return (0); 494| 0| case EVCON_IDLE: ------------------ | Branch (494:2): [True: 0, False: 952] ------------------ 495| 0| case EVCON_READING_FIRSTLINE: ------------------ | Branch (495:2): [True: 0, False: 952] ------------------ 496| 0| case EVCON_READING_HEADERS: ------------------ | Branch (496:2): [True: 0, False: 952] ------------------ 497| 0| case EVCON_READING_BODY: ------------------ | Branch (497:2): [True: 0, False: 952] ------------------ 498| 0| case EVCON_READING_TRAILER: ------------------ | Branch (498:2): [True: 0, False: 952] ------------------ 499| 0| case EVCON_WRITING: ------------------ | Branch (499:2): [True: 0, False: 952] ------------------ 500| 0| default: ------------------ | Branch (500:2): [True: 0, False: 952] ------------------ 501| 0| return (1); 502| 952| } 503| 952|} http.c:evhttp_header_is_valid_value: 2121| 5.71k|{ 2122| 5.71k| const char *p = value; 2123| | 2124| 5.71k| while ((p = strpbrk(p, "\r\n")) != NULL) { ------------------ | Branch (2124:9): [True: 0, False: 5.71k] ------------------ 2125| | /* we really expect only one new line */ 2126| 0| p += strspn(p, "\r\n"); 2127| | /* we expect a space or tab for continuation */ 2128| 0| if (*p != ' ' && *p != '\t') ------------------ | Branch (2128:7): [True: 0, False: 0] | Branch (2128:20): [True: 0, False: 0] ------------------ 2129| 0| return (0); 2130| 0| } 2131| 5.71k| return (1); 2132| 5.71k|} http.c:evhttp_add_header_internal: 2162| 5.71k|{ 2163| 5.71k| struct evkeyval *header = mm_calloc(1, sizeof(struct evkeyval)); ------------------ | | 77| 5.71k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ 2164| 5.71k| if (header == NULL) { ------------------ | Branch (2164:6): [True: 0, False: 5.71k] ------------------ 2165| 0| event_warn("%s: calloc", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 2166| 0| return (-1); 2167| 0| } 2168| 5.71k| if ((header->key = mm_strdup(key)) == NULL) { ------------------ | | 78| 5.71k|#define mm_strdup(s) event_mm_strdup_(s) ------------------ | Branch (2168:6): [True: 0, False: 5.71k] ------------------ 2169| 0| mm_free(header); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 2170| 0| event_warn("%s: strdup", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 2171| 0| return (-1); 2172| 0| } 2173| 5.71k| if ((header->value = mm_strdup(value)) == NULL) { ------------------ | | 78| 5.71k|#define mm_strdup(s) event_mm_strdup_(s) ------------------ | Branch (2173:6): [True: 0, False: 5.71k] ------------------ 2174| 0| mm_free(header->key); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 2175| 0| mm_free(header); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 2176| 0| event_warn("%s: strdup", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 2177| 0| return (-1); 2178| 0| } 2179| | 2180| 5.71k| TAILQ_INSERT_TAIL(headers, header, next); ------------------ | | 332| 5.71k|#define TAILQ_INSERT_TAIL(head, elm, field) do { \ | | 333| 5.71k| (elm)->field.tqe_next = NULL; \ | | 334| 5.71k| (elm)->field.tqe_prev = (head)->tqh_last; \ | | 335| 5.71k| *(head)->tqh_last = (elm); \ | | 336| 5.71k| (head)->tqh_last = &(elm)->field.tqe_next; \ | | 337| 5.71k|} while (0) | | ------------------ | | | Branch (337:10): [Folded, False: 5.71k] | | ------------------ ------------------ 2181| | 2182| 5.71k| return (0); 2183| 5.71k|} http.c:evhttp_connection_new_: 2551| 952|{ 2552| 952| struct evhttp_connection *evcon; 2553| | 2554| 952| if ((evcon = mm_calloc(1, sizeof(struct evhttp_connection))) == NULL) { ------------------ | | 77| 952|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ | Branch (2554:6): [True: 0, False: 952] ------------------ 2555| 0| event_warn("%s: calloc failed", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 2556| 0| goto error; 2557| 0| } 2558| | 2559| 952| evcon->max_headers_size = EV_SIZE_MAX; ------------------ | | 289| 952|#define EV_SIZE_MAX EV_UINT64_MAX | | ------------------ | | | | 267| 952|#define EV_UINT64_MAX UINT64_MAX | | ------------------ ------------------ 2560| 952| evcon->max_body_size = EV_SIZE_MAX; ------------------ | | 289| 952|#define EV_SIZE_MAX EV_UINT64_MAX | | ------------------ | | | | 267| 952|#define EV_UINT64_MAX UINT64_MAX | | ------------------ ------------------ 2561| | 2562| 952| evcon->timeout_connect.tv_sec = HTTP_CONNECT_TIMEOUT; ------------------ | | 17| 952|#define HTTP_CONNECT_TIMEOUT 45 ------------------ 2563| 952| evcon->timeout_read.tv_sec = HTTP_READ_TIMEOUT; ------------------ | | 19| 952|#define HTTP_READ_TIMEOUT 50 ------------------ 2564| 952| evcon->timeout_write.tv_sec = HTTP_WRITE_TIMEOUT; ------------------ | | 18| 952|#define HTTP_WRITE_TIMEOUT 50 ------------------ 2565| 952| evcon->initial_retry_timeout.tv_sec = HTTP_INITIAL_RETRY_TIMEOUT; ------------------ | | 20| 952|#define HTTP_INITIAL_RETRY_TIMEOUT 2 ------------------ 2566| | 2567| 952| evcon->retry_cnt = evcon->retry_max = 0; 2568| | 2569| 952| if (bev == NULL) { ------------------ | Branch (2569:6): [True: 0, False: 952] ------------------ 2570| 0| if (!(bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE))) { ------------------ | Branch (2570:7): [True: 0, False: 0] ------------------ 2571| 0| event_warn("%s: bufferevent_socket_new failed", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 2572| 0| goto error; 2573| 0| } 2574| 0| } 2575| | 2576| 952| bufferevent_setcb(bev, evhttp_read_cb, evhttp_write_cb, evhttp_error_cb, evcon); 2577| 952| evcon->bufev = bev; 2578| | 2579| 952| evcon->state = EVCON_DISCONNECTED; 2580| 952| TAILQ_INIT(&evcon->requests); ------------------ | | 317| 952|#define TAILQ_INIT(head) do { \ | | 318| 952| (head)->tqh_first = NULL; \ | | 319| 952| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 952|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 952] | | ------------------ ------------------ 2581| | 2582| 952| if (base != NULL) { ------------------ | Branch (2582:6): [True: 952, False: 0] ------------------ 2583| 952| evcon->base = base; 2584| 952| if (bufferevent_get_base(bev) != base) ------------------ | Branch (2584:7): [True: 0, False: 952] ------------------ 2585| 0| bufferevent_base_set(base, evcon->bufev); 2586| 952| } 2587| | 2588| 952| event_deferred_cb_init_( 2589| 952| &evcon->read_more_deferred_cb, 2590| 952| bufferevent_get_priority(bev), 2591| 952| evhttp_deferred_read_cb, evcon); 2592| | 2593| 952| evcon->ai_family = AF_UNSPEC; 2594| | 2595| 952| return (evcon); 2596| | 2597| 0| error: 2598| 0| if (evcon != NULL) ------------------ | Branch (2598:6): [True: 0, False: 0] ------------------ 2599| 0| evhttp_connection_free(evcon); 2600| | return (NULL); 2601| 952|} http.c:evhttp_have_expect: 656| 952|{ 657| 952| const char *expect; 658| 952| struct evkeyvalq *h = input ? req->input_headers : req->output_headers; ------------------ | Branch (658:24): [True: 0, False: 952] ------------------ 659| | 660| 952| if (!(req->kind == EVHTTP_REQUEST) || !REQ_VERSION_ATLEAST(req, 1, 1)) ------------------ | | 175| 0| ((req)->major > (major_v) || \ | | ------------------ | | | Branch (175:3): [True: 0, False: 0] | | ------------------ | | 176| 0| ((req)->major == (major_v) && (req)->minor >= (minor_v))) | | ------------------ | | | Branch (176:7): [True: 0, False: 0] | | | Branch (176:36): [True: 0, False: 0] | | ------------------ ------------------ | Branch (660:6): [True: 952, False: 0] ------------------ 661| 952| return NO; 662| | 663| 0| expect = evhttp_find_header(h, "Expect"); 664| 0| if (!expect) ------------------ | Branch (664:6): [True: 0, False: 0] ------------------ 665| 0| return NO; 666| | 667| 0| return !evutil_ascii_strcasecmp(expect, "100-continue") ? CONTINUE : OTHER; ------------------ | Branch (667:9): [True: 0, False: 0] ------------------ 668| 0|} http.c:evhttp_is_connection_close: 544| 952|{ 545| 952| const char *connection = evhttp_find_header(headers, "Connection"); 546| 952| return (connection != NULL && evutil_ascii_strcasecmp(connection, "close") == 0); ------------------ | Branch (546:10): [True: 952, False: 0] | Branch (546:32): [True: 0, False: 952] ------------------ 547| 952|} http.c:evhttp_write_buffer: 444| 952|{ 445| 952| event_debug(("%s: preparing to write buffer\n", __func__)); ------------------ | | 79| 952|#define event_debug(x) do { \ | | 80| 952| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 952|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 952] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 952| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 952] | | ------------------ ------------------ 446| | 447| | /* Set call back */ 448| 952| evcon->cb = cb; 449| 952| evcon->cb_arg = arg; 450| | 451| | /* Disable the read callback: we don't actually care about data; 452| | * we only care about close detection. (We don't disable reading -- 453| | * EV_READ, since we *do* want to learn about any close events.) */ 454| 952| bufferevent_setcb(evcon->bufev, 455| 952| NULL, /*read*/ 456| 952| evhttp_write_cb, 457| 952| evhttp_error_cb, 458| 952| evcon); 459| | 460| 952| bufferevent_enable(evcon->bufev, EV_READ|EV_WRITE); ------------------ | | 957| 952|#define EV_READ 0x02 ------------------ bufferevent_enable(evcon->bufev, EV_READ|EV_WRITE); ------------------ | | 959| 952|#define EV_WRITE 0x04 ------------------ 461| 952|} http.c:evhttp_response_needs_body: 429| 952|{ 430| 952| return (req->response_code != HTTP_NOCONTENT && ------------------ | | 64| 1.90k|#define HTTP_NOCONTENT 204 /**< request does not have content */ ------------------ | Branch (430:10): [True: 952, False: 0] ------------------ 431| 952| req->response_code != HTTP_NOTMODIFIED && ------------------ | | 67| 1.90k|#define HTTP_NOTMODIFIED 304 /**< page was not modified from last */ ------------------ | Branch (431:3): [True: 952, False: 0] ------------------ 432| 952| (req->response_code < 100 || req->response_code >= 200) && ------------------ | Branch (432:4): [True: 0, False: 952] | Branch (432:32): [True: 0, False: 952] ------------------ 433| 0| req->type != EVHTTP_REQ_CONNECT && ------------------ | Branch (433:3): [True: 0, False: 0] ------------------ 434| 0| req->type != EVHTTP_REQ_HEAD); ------------------ | Branch (434:3): [True: 0, False: 0] ------------------ 435| 952|} http.c:evhttp_make_header: 676| 952|{ 677| 952| struct evkeyval *header; 678| 952| struct evbuffer *output = bufferevent_get_output(evcon->bufev); 679| | 680| | /* 681| | * Depending if this is a HTTP request or response, we might need to 682| | * add some new headers or remove existing headers. 683| | */ 684| 952| if (req->kind == EVHTTP_REQUEST) { ------------------ | Branch (684:6): [True: 0, False: 952] ------------------ 685| 0| evhttp_make_header_request(evcon, req); 686| 952| } else { 687| 952| evhttp_make_header_response(evcon, req); 688| 952| } 689| | 690| 2.85k| TAILQ_FOREACH(header, req->output_headers, next) { ------------------ | | 305| 952| for((var) = TAILQ_FIRST(head); \ | | ------------------ | | | | 293| 952|#define TAILQ_FIRST(head) ((head)->tqh_first) | | ------------------ | | 306| 3.80k| (var) != TAILQ_END(head); \ | | ------------------ | | | | 294| 3.80k|#define TAILQ_END(head) NULL | | ------------------ | | | Branch (306:6): [True: 2.85k, False: 952] | | ------------------ | | 307| 2.85k| (var) = TAILQ_NEXT(var, field)) | | ------------------ | | | | 295| 2.85k|#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) | | ------------------ ------------------ 691| 2.85k| evbuffer_add_printf(output, "%s: %s\r\n", 692| 2.85k| header->key, header->value); 693| 2.85k| } 694| 952| evbuffer_add(output, "\r\n", 2); 695| | 696| 952| if (evhttp_have_expect(req, 0) != CONTINUE && ------------------ | Branch (696:6): [True: 952, False: 0] ------------------ 697| 952| evbuffer_get_length(req->output_buffer)) { ------------------ | Branch (697:3): [True: 0, False: 952] ------------------ 698| | /* 699| | * For a request, we add the POST data, for a reply, this 700| | * is the regular data. 701| | */ 702| 0| evbuffer_add_buffer(output, req->output_buffer); 703| 0| } 704| 952|} http.c:evhttp_make_header_response: 603| 952|{ 604| 952| int is_keepalive = evhttp_is_connection_keepalive(req->input_headers); 605| 952| int need_body = evhttp_response_needs_body(req); 606| | 607| 952| evbuffer_add_printf(bufferevent_get_output(evcon->bufev), 608| 952| "HTTP/%d.%d %d %s\r\n", 609| 952| req->major, req->minor, req->response_code, 610| 952| req->response_code_line); 611| | 612| 952| if (req->major == 1) { ------------------ | Branch (612:6): [True: 0, False: 952] ------------------ 613| 0| if (req->minor >= 1) ------------------ | Branch (613:7): [True: 0, False: 0] ------------------ 614| 0| evhttp_maybe_add_date_header(req->output_headers); 615| | 616| | /* 617| | * if the protocol is 1.0; and the connection was keep-alive 618| | * we need to add a keep-alive header, too. 619| | */ 620| 0| if (req->minor == 0 && is_keepalive) ------------------ | Branch (620:7): [True: 0, False: 0] | Branch (620:26): [True: 0, False: 0] ------------------ 621| 0| evhttp_add_header(req->output_headers, 622| 0| "Connection", "keep-alive"); 623| | 624| 0| if ((req->minor >= 1 || is_keepalive) && need_body) { ------------------ | Branch (624:8): [True: 0, False: 0] | Branch (624:27): [True: 0, False: 0] | Branch (624:44): [True: 0, False: 0] ------------------ 625| | /* 626| | * we need to add the content length if the 627| | * user did not give it, this is required for 628| | * persistent connections to work. 629| | */ 630| 0| evhttp_maybe_add_content_length_header( 631| 0| req->output_headers, 632| 0| evbuffer_get_length(req->output_buffer)); 633| 0| } 634| 0| } 635| | 636| | /* Potentially add headers for unidentified content. */ 637| 952| if (need_body) { ------------------ | Branch (637:6): [True: 0, False: 952] ------------------ 638| 0| if (evhttp_find_header(req->output_headers, ------------------ | Branch (638:7): [True: 0, False: 0] ------------------ 639| 0| "Content-Type") == NULL 640| 0| && evcon->http_server->default_content_type) { ------------------ | Branch (640:10): [True: 0, False: 0] ------------------ 641| 0| evhttp_add_header(req->output_headers, 642| 0| "Content-Type", 643| 0| evcon->http_server->default_content_type); 644| 0| } 645| 0| } 646| | 647| | /* if the request asked for a close, we send a close, too */ 648| 952| if (evhttp_is_connection_close(req->flags, req->input_headers)) { ------------------ | Branch (648:6): [True: 0, False: 952] ------------------ 649| 0| evhttp_remove_header(req->output_headers, "Connection"); 650| 0| evhttp_add_header(req->output_headers, "Connection", "close"); 651| 0| } 652| 952|} http.c:evhttp_is_connection_keepalive: 563| 952|{ 564| 952| const char *connection = evhttp_find_header(headers, "Connection"); 565| 952| return (connection != NULL ------------------ | Branch (565:10): [True: 952, False: 0] ------------------ 566| 952| && evutil_ascii_strncasecmp(connection, "keep-alive", 10) == 0); ------------------ | Branch (566:9): [True: 0, False: 952] ------------------ 567| 952|} http.c:evhttp_new_object: 4016| 952|{ 4017| 952| struct evhttp *http = NULL; 4018| | 4019| 952| if ((http = mm_calloc(1, sizeof(struct evhttp))) == NULL) { ------------------ | | 77| 952|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ | Branch (4019:6): [True: 0, False: 952] ------------------ 4020| 0| event_warn("%s: calloc", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 4021| 0| return (NULL); 4022| 0| } 4023| | 4024| 952| evutil_timerclear(&http->timeout_read); ------------------ | | 604| 952|#define evutil_timerclear(tvp) timerclear(tvp) ------------------ 4025| 952| evutil_timerclear(&http->timeout_write); ------------------ | | 604| 952|#define evutil_timerclear(tvp) timerclear(tvp) ------------------ 4026| | 4027| 952| evhttp_set_max_headers_size(http, EV_SIZE_MAX); ------------------ | | 289| 952|#define EV_SIZE_MAX EV_UINT64_MAX | | ------------------ | | | | 267| 952|#define EV_UINT64_MAX UINT64_MAX | | ------------------ ------------------ 4028| 952| evhttp_set_max_body_size(http, EV_SIZE_MAX); ------------------ | | 289| 952|#define EV_SIZE_MAX EV_UINT64_MAX | | ------------------ | | | | 267| 952|#define EV_UINT64_MAX UINT64_MAX | | ------------------ ------------------ 4029| 952| evhttp_set_default_content_type(http, "text/html; charset=ISO-8859-1"); 4030| 952| evhttp_set_allowed_methods(http, 4031| 952| EVHTTP_REQ_GET | 4032| 952| EVHTTP_REQ_POST | 4033| 952| EVHTTP_REQ_HEAD | 4034| 952| EVHTTP_REQ_PUT | 4035| 952| EVHTTP_REQ_DELETE); 4036| | 4037| 952| TAILQ_INIT(&http->sockets); ------------------ | | 317| 952|#define TAILQ_INIT(head) do { \ | | 318| 952| (head)->tqh_first = NULL; \ | | 319| 952| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 952|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 952] | | ------------------ ------------------ 4038| 952| TAILQ_INIT(&http->callbacks); ------------------ | | 317| 952|#define TAILQ_INIT(head) do { \ | | 318| 952| (head)->tqh_first = NULL; \ | | 319| 952| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 952|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 952] | | ------------------ ------------------ 4039| 952| TAILQ_INIT(&http->connections); ------------------ | | 317| 952|#define TAILQ_INIT(head) do { \ | | 318| 952| (head)->tqh_first = NULL; \ | | 319| 952| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 952|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 952] | | ------------------ ------------------ 4040| 952| TAILQ_INIT(&http->ws_sessions); ------------------ | | 317| 952|#define TAILQ_INIT(head) do { \ | | 318| 952| (head)->tqh_first = NULL; \ | | 319| 952| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 952|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 952] | | ------------------ ------------------ 4041| 952| TAILQ_INIT(&http->virtualhosts); ------------------ | | 317| 952|#define TAILQ_INIT(head) do { \ | | 318| 952| (head)->tqh_first = NULL; \ | | 319| 952| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 952|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 952] | | ------------------ ------------------ 4042| 952| TAILQ_INIT(&http->aliases); ------------------ | | 317| 952|#define TAILQ_INIT(head) do { \ | | 318| 952| (head)->tqh_first = NULL; \ | | 319| 952| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 952|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 952] | | ------------------ ------------------ 4043| | 4044| 952| return (http); 4045| 952|} event_warn: 114| 33.5k|{ 115| 33.5k| va_list ap; 116| | 117| 33.5k| va_start(ap, fmt); 118| 33.5k| event_logv_(EVENT_LOG_WARN, strerror(errno), fmt, ap); ------------------ | | 738| 33.5k|#define EVENT_LOG_WARN 2 ------------------ 119| | va_end(ap); 120| 33.5k|} event_logv_: 188| 33.5k|{ 189| 33.5k| char buf[1024]; 190| 33.5k| size_t len; 191| | 192| 33.5k| if (severity == EVENT_LOG_DEBUG && !event_debug_get_logging_mask_()) ------------------ | | 736| 67.1k|#define EVENT_LOG_DEBUG 0 ------------------ if (severity == EVENT_LOG_DEBUG && !event_debug_get_logging_mask_()) ------------------ | | 52| 0|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) ------------------ | Branch (192:6): [True: 0, False: 33.5k] | Branch (192:37): [True: 0, False: 0] ------------------ 193| 0| return; 194| | 195| 33.5k| if (fmt != NULL) ------------------ | Branch (195:6): [True: 33.5k, False: 0] ------------------ 196| 33.5k| evutil_vsnprintf(buf, sizeof(buf), fmt, ap); 197| 0| else 198| 0| buf[0] = '\0'; 199| | 200| 33.5k| if (errstr) { ------------------ | Branch (200:6): [True: 33.5k, False: 0] ------------------ 201| 33.5k| len = strlen(buf); 202| 33.5k| if (len < sizeof(buf) - 3) { ------------------ | Branch (202:7): [True: 33.5k, False: 0] ------------------ 203| 33.5k| evutil_snprintf(buf + len, sizeof(buf) - len, ": %s", errstr); 204| 33.5k| } 205| 33.5k| } 206| | 207| 33.5k| event_log(severity, buf); 208| 33.5k|} log.c:event_log: 220| 33.5k|{ 221| 33.5k| if (log_fn) ------------------ | Branch (221:6): [True: 0, False: 33.5k] ------------------ 222| 0| log_fn(severity, msg); 223| 33.5k| else { 224| 33.5k| const char *severity_str; 225| 33.5k| switch (severity) { 226| 0| case EVENT_LOG_DEBUG: ------------------ | | 736| 0|#define EVENT_LOG_DEBUG 0 ------------------ | Branch (226:3): [True: 0, False: 33.5k] ------------------ 227| 0| severity_str = "debug"; 228| 0| break; 229| 0| case EVENT_LOG_MSG: ------------------ | | 737| 0|#define EVENT_LOG_MSG 1 ------------------ | Branch (229:3): [True: 0, False: 33.5k] ------------------ 230| 0| severity_str = "msg"; 231| 0| break; 232| 33.5k| case EVENT_LOG_WARN: ------------------ | | 738| 33.5k|#define EVENT_LOG_WARN 2 ------------------ | Branch (232:3): [True: 33.5k, False: 0] ------------------ 233| 33.5k| severity_str = "warn"; 234| 33.5k| break; 235| 0| case EVENT_LOG_ERR: ------------------ | | 739| 0|#define EVENT_LOG_ERR 3 ------------------ | Branch (235:3): [True: 0, False: 33.5k] ------------------ 236| 0| severity_str = "err"; 237| 0| break; 238| 0| default: ------------------ | Branch (238:3): [True: 0, False: 33.5k] ------------------ 239| 0| severity_str = "???"; 240| 0| break; 241| 33.5k| } 242| 33.5k| (void)fprintf(stderr, "[%s] %s\n", severity_str, msg); 243| 33.5k| } 244| 33.5k|} event.c:min_heap_ctor_: 64| 952|void min_heap_ctor_(min_heap_t* s) { s->p = 0; s->n = 0; s->a = 0; } event.c:min_heap_dtor_: 65| 952|void min_heap_dtor_(min_heap_t* s) { if (s->p) mm_free(s->p); } ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ | Branch (65:42): [True: 0, False: 952] ------------------ event.c:min_heap_elem_init_: 66| 4.76k|void min_heap_elem_init_(struct event* e) { e->ev_timeout_pos.min_heap_idx = EV_SIZE_MAX; } ------------------ | | 289| 4.76k|#define EV_SIZE_MAX EV_UINT64_MAX | | ------------------ | | | | 267| 4.76k|#define EV_UINT64_MAX UINT64_MAX | | ------------------ ------------------ event.c:min_heap_top_: 69| 952|struct event* min_heap_top_(min_heap_t* s) { return s->n ? *s->p : 0; } ------------------ | Branch (69:53): [True: 0, False: 952] ------------------ event.c:min_heap_empty_: 67| 952|int min_heap_empty_(min_heap_t* s) { return 0 == s->n; } builtin_SHA1: 291| 952|void builtin_SHA1(char *hash_out, const char *str, int len) { 292| 952| SHA1_CTX ctx; 293| 952| int ii; 294| | 295| 952| SHA1Init(&ctx); 296| 58.0k| for (ii = 0; ii < len; ii += 1) ------------------ | Branch (296:18): [True: 57.1k, False: 952] ------------------ 297| 57.1k| SHA1Update(&ctx, (const unsigned char *)str + ii, 1); 298| 952| SHA1Final((unsigned char *)hash_out, &ctx); 299| 952|} sha1.c:SHA1Init: 208| 952|static void SHA1Init(SHA1_CTX *context) { 209| | /* SHA1 initialization constants */ 210| 952| context->state[0] = 0x67452301; 211| 952| context->state[1] = 0xEFCDAB89; 212| 952| context->state[2] = 0x98BADCFE; 213| 952| context->state[3] = 0x10325476; 214| 952| context->state[4] = 0xC3D2E1F0; 215| 952| context->count[0] = context->count[1] = 0; 216| 952|} sha1.c:SHA1Update: 220| 115k|static void SHA1Update(SHA1_CTX *context, const unsigned char *data, uint32_t len) { 221| 115k| uint32_t i; 222| | 223| 115k| uint32_t j; 224| | 225| 115k| j = context->count[0]; 226| 115k| if ((context->count[0] += len << 3) < j) ------------------ | Branch (226:9): [True: 0, False: 115k] ------------------ 227| 0| context->count[1]++; 228| 115k| context->count[1] += (len >> 29); 229| 115k| j = (j >> 3) & 63; 230| 115k| if ((j + len) > 63) { ------------------ | Branch (230:9): [True: 1.90k, False: 113k] ------------------ 231| 1.90k| memcpy(&context->buffer[j], data, (i = 64 - j)); 232| 1.90k| SHA1Transform(context->state, context->buffer); 233| 1.90k| for (; i + 63 < len; i += 64) { ------------------ | Branch (233:16): [True: 0, False: 1.90k] ------------------ 234| 0| SHA1Transform(context->state, &data[i]); 235| 0| } 236| 1.90k| j = 0; 237| 1.90k| } else 238| 113k| i = 0; 239| 115k| memcpy(&context->buffer[j], &data[i], len - i); 240| 115k|} sha1.c:SHA1Transform: 88| 1.90k|static void SHA1Transform(uint32_t state[5], const unsigned char buffer[64]) { 89| 1.90k| uint32_t a, b, c, d, e; 90| | 91| 1.90k| typedef union { 92| 1.90k| unsigned char c[64]; 93| 1.90k| uint32_t l[16]; 94| 1.90k| } CHAR64LONG16; 95| | 96| 1.90k|#ifdef SHA1HANDSOFF 97| 1.90k| CHAR64LONG16 block[1]; /* use array to appear as a pointer */ 98| | 99| 1.90k| memcpy(block, buffer, 64); 100| |#else 101| | /* The following had better never be used because it causes the 102| | * pointer-to-const buffer to be cast into a pointer to non-const. 103| | * And the result is written through. I threw a "const" in, hoping 104| | * this will cause a diagnostic. 105| | */ 106| | CHAR64LONG16 *block = (const CHAR64LONG16 *)buffer; 107| |#endif 108| | /* Copy context->state[] to working vars */ 109| 1.90k| a = state[0]; 110| 1.90k| b = state[1]; 111| 1.90k| c = state[2]; 112| 1.90k| d = state[3]; 113| 1.90k| e = state[4]; 114| | /* 4 rounds of 20 operations each. Loop unrolled. */ 115| 1.90k| R0(a, b, c, d, e, 0); ------------------ | | 56| 1.90k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 42| 1.90k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 43| 1.90k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 57| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 116| 1.90k| R0(e, a, b, c, d, 1); ------------------ | | 56| 1.90k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 42| 1.90k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 43| 1.90k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 57| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 117| 1.90k| R0(d, e, a, b, c, 2); ------------------ | | 56| 1.90k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 42| 1.90k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 43| 1.90k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 57| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 118| 1.90k| R0(c, d, e, a, b, 3); ------------------ | | 56| 1.90k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 42| 1.90k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 43| 1.90k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 57| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 119| 1.90k| R0(b, c, d, e, a, 4); ------------------ | | 56| 1.90k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 42| 1.90k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 43| 1.90k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 57| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 120| 1.90k| R0(a, b, c, d, e, 5); ------------------ | | 56| 1.90k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 42| 1.90k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 43| 1.90k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 57| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 121| 1.90k| R0(e, a, b, c, d, 6); ------------------ | | 56| 1.90k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 42| 1.90k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 43| 1.90k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 57| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 122| 1.90k| R0(d, e, a, b, c, 7); ------------------ | | 56| 1.90k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 42| 1.90k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 43| 1.90k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 57| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 123| 1.90k| R0(c, d, e, a, b, 8); ------------------ | | 56| 1.90k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 42| 1.90k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 43| 1.90k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 57| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 124| 1.90k| R0(b, c, d, e, a, 9); ------------------ | | 56| 1.90k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 42| 1.90k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 43| 1.90k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 57| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 125| 1.90k| R0(a, b, c, d, e, 10); ------------------ | | 56| 1.90k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 42| 1.90k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 43| 1.90k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 57| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 126| 1.90k| R0(e, a, b, c, d, 11); ------------------ | | 56| 1.90k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 42| 1.90k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 43| 1.90k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 57| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 127| 1.90k| R0(d, e, a, b, c, 12); ------------------ | | 56| 1.90k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 42| 1.90k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 43| 1.90k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 57| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 128| 1.90k| R0(c, d, e, a, b, 13); ------------------ | | 56| 1.90k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 42| 1.90k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 43| 1.90k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 57| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 129| 1.90k| R0(b, c, d, e, a, 14); ------------------ | | 56| 1.90k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 42| 1.90k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 43| 1.90k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 57| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 130| 1.90k| R0(a, b, c, d, e, 15); ------------------ | | 56| 1.90k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 42| 1.90k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 43| 1.90k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 57| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 131| 1.90k| R1(e, a, b, c, d, 16); ------------------ | | 59| 1.90k| z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 60| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 132| 1.90k| R1(d, e, a, b, c, 17); ------------------ | | 59| 1.90k| z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 60| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 133| 1.90k| R1(c, d, e, a, b, 18); ------------------ | | 59| 1.90k| z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 60| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 134| 1.90k| R1(b, c, d, e, a, 19); ------------------ | | 59| 1.90k| z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 60| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 135| 1.90k| R2(a, b, c, d, e, 20); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 136| 1.90k| R2(e, a, b, c, d, 21); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 137| 1.90k| R2(d, e, a, b, c, 22); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 138| 1.90k| R2(c, d, e, a, b, 23); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 139| 1.90k| R2(b, c, d, e, a, 24); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 140| 1.90k| R2(a, b, c, d, e, 25); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 141| 1.90k| R2(e, a, b, c, d, 26); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 142| 1.90k| R2(d, e, a, b, c, 27); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 143| 1.90k| R2(c, d, e, a, b, 28); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 144| 1.90k| R2(b, c, d, e, a, 29); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 145| 1.90k| R2(a, b, c, d, e, 30); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 146| 1.90k| R2(e, a, b, c, d, 31); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 147| 1.90k| R2(d, e, a, b, c, 32); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 148| 1.90k| R2(c, d, e, a, b, 33); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 149| 1.90k| R2(b, c, d, e, a, 34); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 150| 1.90k| R2(a, b, c, d, e, 35); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 151| 1.90k| R2(e, a, b, c, d, 36); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 152| 1.90k| R2(d, e, a, b, c, 37); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 153| 1.90k| R2(c, d, e, a, b, 38); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 154| 1.90k| R2(b, c, d, e, a, 39); ------------------ | | 62| 1.90k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 63| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 155| 1.90k| R3(a, b, c, d, e, 40); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 156| 1.90k| R3(e, a, b, c, d, 41); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 157| 1.90k| R3(d, e, a, b, c, 42); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 158| 1.90k| R3(c, d, e, a, b, 43); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 159| 1.90k| R3(b, c, d, e, a, 44); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 160| 1.90k| R3(a, b, c, d, e, 45); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 161| 1.90k| R3(e, a, b, c, d, 46); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 162| 1.90k| R3(d, e, a, b, c, 47); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 163| 1.90k| R3(c, d, e, a, b, 48); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 164| 1.90k| R3(b, c, d, e, a, 49); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 165| 1.90k| R3(a, b, c, d, e, 50); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 166| 1.90k| R3(e, a, b, c, d, 51); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 167| 1.90k| R3(d, e, a, b, c, 52); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 168| 1.90k| R3(c, d, e, a, b, 53); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 169| 1.90k| R3(b, c, d, e, a, 54); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 170| 1.90k| R3(a, b, c, d, e, 55); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 171| 1.90k| R3(e, a, b, c, d, 56); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 172| 1.90k| R3(d, e, a, b, c, 57); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 173| 1.90k| R3(c, d, e, a, b, 58); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 174| 1.90k| R3(b, c, d, e, a, 59); ------------------ | | 65| 1.90k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 66| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 175| 1.90k| R4(a, b, c, d, e, 60); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 176| 1.90k| R4(e, a, b, c, d, 61); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 177| 1.90k| R4(d, e, a, b, c, 62); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 178| 1.90k| R4(c, d, e, a, b, 63); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 179| 1.90k| R4(b, c, d, e, a, 64); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 180| 1.90k| R4(a, b, c, d, e, 65); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 181| 1.90k| R4(e, a, b, c, d, 66); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 182| 1.90k| R4(d, e, a, b, c, 67); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 183| 1.90k| R4(c, d, e, a, b, 68); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 184| 1.90k| R4(b, c, d, e, a, 69); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 185| 1.90k| R4(a, b, c, d, e, 70); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 186| 1.90k| R4(e, a, b, c, d, 71); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 187| 1.90k| R4(d, e, a, b, c, 72); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 188| 1.90k| R4(c, d, e, a, b, 73); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 189| 1.90k| R4(b, c, d, e, a, 74); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 190| 1.90k| R4(a, b, c, d, e, 75); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 191| 1.90k| R4(e, a, b, c, d, 76); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 192| 1.90k| R4(d, e, a, b, c, 77); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 193| 1.90k| R4(c, d, e, a, b, 78); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 194| 1.90k| R4(b, c, d, e, a, 79); ------------------ | | 68| 1.90k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 50| 1.90k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 51| 1.90k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 52| 1.90k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 69| 1.90k| w = rol(w, 30); | | ------------------ | | | | 36| 1.90k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 195| | /* Add the working vars back into context.state[] */ 196| 1.90k| state[0] += a; 197| 1.90k| state[1] += b; 198| 1.90k| state[2] += c; 199| 1.90k| state[3] += d; 200| 1.90k| state[4] += e; 201| 1.90k|#ifdef SHA1HANDSOFF 202| 1.90k| memset(block, '\0', sizeof(block)); 203| 1.90k|#endif 204| 1.90k|} sha1.c:SHA1Final: 244| 952|static void SHA1Final(unsigned char digest[20], SHA1_CTX *context) { 245| 952| unsigned i; 246| | 247| 952| unsigned char finalcount[8]; 248| | 249| 952| unsigned char c; 250| | 251| |#if 0 /* untested "improvement" by DHR */ 252| | /* Convert context->count to a sequence of bytes 253| | * in finalcount. Second element first, but 254| | * big-endian order within element. 255| | * But we do it all backwards. 256| | */ 257| | unsigned char *fcp = &finalcount[8]; 258| | 259| | for (i = 0; i < 2; i++) 260| | { 261| | uint32_t t = context->count[i]; 262| | 263| | int j; 264| | 265| | for (j = 0; j < 4; t >>= 8, j++) 266| | *--fcp = (unsigned char) t} 267| |#else 268| 8.56k| for (i = 0; i < 8; i++) { ------------------ | Branch (268:17): [True: 7.61k, False: 952] ------------------ 269| 7.61k| finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)] >> ------------------ | Branch (269:58): [True: 3.80k, False: 3.80k] ------------------ 270| 7.61k| ((3 - (i & 3)) * 8)) & 271| 7.61k| 255); /* Endian independent */ 272| 7.61k| } 273| 952|#endif 274| 952| c = 0200; 275| 952| SHA1Update(context, &c, 1); 276| 57.1k| while ((context->count[0] & 504) != 448) { ------------------ | Branch (276:12): [True: 56.1k, False: 952] ------------------ 277| 56.1k| c = 0000; 278| 56.1k| SHA1Update(context, &c, 1); 279| 56.1k| } 280| 952| SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */ 281| 19.9k| for (i = 0; i < 20; i++) { ------------------ | Branch (281:17): [True: 19.0k, False: 952] ------------------ 282| 19.0k| digest[i] = 283| 19.0k| (unsigned char)((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 284| 19.0k| 255); 285| 19.0k| } 286| | /* Wipe variables */ 287| 952| memset(context, '\0', sizeof(*context)); 288| 952| memset(&finalcount, '\0', sizeof(finalcount)); 289| 952|} evsig_init_: 177| 952|{ 178| | /* 179| | * Our signal handler is going to write to one end of the socket 180| | * pair to wake up our event loop. The event loop then scans for 181| | * signals that got delivered. 182| | */ 183| 952| if (evutil_make_internal_pipe_(base->sig.ev_signal_pair) == -1) { ------------------ | Branch (183:6): [True: 0, False: 952] ------------------ 184| |#ifdef _WIN32 185| | /* Make this nonfatal on win32, where sometimes people 186| | have localhost firewalled. */ 187| | event_sock_warn(-1, "%s: socketpair", __func__); 188| |#else 189| 0| event_sock_err(1, -1, "%s: socketpair", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 190| 0|#endif 191| 0| return -1; 192| 0| } 193| | 194| 952| if (base->sig.sh_old) { ------------------ | Branch (194:6): [True: 0, False: 952] ------------------ 195| 0| mm_free(base->sig.sh_old); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 196| 0| } 197| 952| base->sig.sh_old = NULL; 198| 952| base->sig.sh_old_max = 0; 199| | 200| 952| event_assign(&base->sig.ev_signal, base, base->sig.ev_signal_pair[0], 201| 952| EV_READ | EV_PERSIST, evsig_cb, base); ------------------ | | 957| 952|#define EV_READ 0x02 ------------------ EV_READ | EV_PERSIST, evsig_cb, base); ------------------ | | 968| 952|#define EV_PERSIST 0x10 ------------------ 202| | 203| 952| base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL; ------------------ | | 58| 952|#define ev_flags ev_evcallback.evcb_flags ------------------ base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL; ------------------ | | 61| 952|#define EVLIST_INTERNAL 0x10 ------------------ 204| 952| event_priority_set(&base->sig.ev_signal, 0); 205| | 206| 952| base->evsigsel = &evsigops; 207| | 208| 952| return 0; 209| 952|} evsig_dealloc_: 441| 952|{ 442| 952| int i = 0; 443| 952| if (base->sig.ev_signal_added) { ------------------ | Branch (443:6): [True: 0, False: 952] ------------------ 444| 0| event_del(&base->sig.ev_signal); 445| 0| base->sig.ev_signal_added = 0; 446| 0| } 447| | /* debug event is created in evsig_init_/event_assign even when 448| | * ev_signal_added == 0, so unassign is required */ 449| 952| event_debug_unassign(&base->sig.ev_signal); 450| | 451| 62.8k| for (i = 0; i < NSIG; ++i) { ------------------ | Branch (451:14): [True: 61.8k, False: 952] ------------------ 452| 61.8k| if (i < base->sig.sh_old_max && base->sig.sh_old[i] != NULL) ------------------ | Branch (452:7): [True: 0, False: 61.8k] | Branch (452:35): [True: 0, False: 0] ------------------ 453| 0| evsig_restore_handler_(base, i); 454| 61.8k| } 455| 952| EVSIGBASE_LOCK(); ------------------ | | 118| 952|#define EVSIGBASE_LOCK() EVLOCK_LOCK(evsig_base_lock, 0) | | ------------------ | | | | 94| 952| do { \ | | | | 95| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 952] | | | | ------------------ | | | | 96| 952| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 952| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 952] | | | | ------------------ | | ------------------ ------------------ 456| 952| if (base == evsig_base) { ------------------ | Branch (456:6): [True: 0, False: 952] ------------------ 457| 0| evsig_base = NULL; 458| 0| evsig_base_n_signals_added = 0; 459| 0| evsig_base_fd = -1; 460| 0| } 461| 952| EVSIGBASE_UNLOCK(); ------------------ | | 119| 952|#define EVSIGBASE_UNLOCK() EVLOCK_UNLOCK(evsig_base_lock, 0) | | ------------------ | | | | 101| 952| do { \ | | | | 102| 952| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 952] | | | | ------------------ | | | | 103| 952| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 952| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 952] | | | | ------------------ | | ------------------ ------------------ 462| | 463| 952| if (base->sig.ev_signal_pair[0] != -1) { ------------------ | Branch (463:6): [True: 952, False: 0] ------------------ 464| 952| evutil_closesocket(base->sig.ev_signal_pair[0]); 465| 952| base->sig.ev_signal_pair[0] = -1; 466| 952| } 467| 952| if (base->sig.ev_signal_pair[1] != -1) { ------------------ | Branch (467:6): [True: 952, False: 0] ------------------ 468| 952| evutil_closesocket(base->sig.ev_signal_pair[1]); 469| 952| base->sig.ev_signal_pair[1] = -1; 470| 952| } 471| 952| base->sig.sh_old_max = 0; 472| | 473| | /* per index frees are handled in evsig_del() */ 474| 952| if (base->sig.sh_old) { ------------------ | Branch (474:6): [True: 0, False: 952] ------------------ 475| 0| mm_free(base->sig.sh_old); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 476| | base->sig.sh_old = NULL; 477| 0| } 478| 952|} sigfd_init_: 207| 952|{ 208| 952| EVUTIL_ASSERT(base != NULL); ------------------ | | 368| 952|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 952|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 952| (void)sizeof(!(condition)); \ | | | | 98| 952|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 952] | | | | ------------------ | | ------------------ ------------------ 209| 952| if (!(base->flags & EVENT_BASE_FLAG_USE_SIGNALFD) && ------------------ | Branch (209:6): [True: 952, False: 0] ------------------ 210| 952| !getenv("EVENT_USE_SIGNALFD")) ------------------ | Branch (210:6): [True: 952, False: 0] ------------------ 211| 952| return -1; 212| 0| base->evsigsel = &sigfdops; 213| 0| return 0; 214| 952|} evws_connection_free: 90| 952|{ 91| | /* notify interested parties that this connection is going down */ 92| 952| if (evws->cbclose != NULL) ------------------ | Branch (92:6): [True: 0, False: 952] ------------------ 93| 0| (*evws->cbclose)(evws, evws->cbclose_arg); 94| | 95| 952| if (evws->http_server != NULL) { ------------------ | Branch (95:6): [True: 952, False: 0] ------------------ 96| 952| struct evhttp *http = evws->http_server; 97| 952| TAILQ_REMOVE(&http->ws_sessions, evws, next); ------------------ | | 356| 952|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 952| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 0, False: 952] | | ------------------ | | 358| 952| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 0| (elm)->field.tqe_prev; \ | | 360| 952| else \ | | 361| 952| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 952| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 952|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 952] | | ------------------ ------------------ 98| 952| http->connection_cnt--; 99| 952| } 100| | 101| 952| if (evws->bufev != NULL) { ------------------ | Branch (101:6): [True: 952, False: 0] ------------------ 102| 952| bufferevent_free(evws->bufev); 103| 952| } 104| 952| if (evws->incomplete_frames != NULL) { ------------------ | Branch (104:6): [True: 484, False: 468] ------------------ 105| 484| evbuffer_free(evws->incomplete_frames); 106| 484| } 107| | 108| 952| mm_free(evws); ------------------ | | 80| 952|#define mm_free(p) event_mm_free_(p) ------------------ 109| 952|} evws_close: 175| 119k|{ 176| 119k| uint8_t fr[4] = {0x8 | 0x80, 2, 0}; 177| 119k| struct evbuffer *output; 178| 119k| uint16_t *u16; 179| | 180| 119k| if (evws->closed) ------------------ | Branch (180:6): [True: 118k, False: 607] ------------------ 181| 118k| return; 182| 607| evws->closed = true; 183| | 184| 607| u16 = (uint16_t *)&fr[2]; 185| 607| *u16 = htons((int16_t)reason); 186| 607| output = bufferevent_get_output(evws->bufev); 187| 607| evbuffer_add(output, fr, 4); 188| | 189| | /* wait for close frame writing complete and close connection */ 190| 607| bufferevent_setcb( 191| | evws->bufev, NULL, close_after_write_cb, close_event_cb, evws); 192| 607|} evws_new_session: 376| 952|{ 377| 952| struct evws_connection *evws = NULL; 378| 952| struct evkeyvalq *in_hdrs; 379| 952| const char *upgrade, *connection, *ws_key, *ws_protocol; 380| 952| struct evkeyvalq *out_hdrs; 381| 952| struct evhttp_connection *evcon; 382| | 383| 952| in_hdrs = evhttp_request_get_input_headers(req); 384| 952| upgrade = evhttp_find_header(in_hdrs, "Upgrade"); 385| 952| if (upgrade == NULL || evutil_ascii_strcasecmp(upgrade, "websocket")) ------------------ | Branch (385:6): [True: 0, False: 952] | Branch (385:25): [True: 0, False: 952] ------------------ 386| 0| goto error; 387| | 388| 952| connection = evhttp_find_header(in_hdrs, "Connection"); 389| 952| if (connection == NULL || evutil_ascii_strcasestr(connection, "Upgrade") == NULL) ------------------ | Branch (389:6): [True: 0, False: 952] | Branch (389:28): [True: 0, False: 952] ------------------ 390| 0| goto error; 391| | 392| 952| ws_key = evhttp_find_header(in_hdrs, "Sec-WebSocket-Key"); 393| 952| if (ws_key == NULL) ------------------ | Branch (393:6): [True: 0, False: 952] ------------------ 394| 0| goto error; 395| | 396| 952| out_hdrs = evhttp_request_get_output_headers(req); 397| 952| evhttp_add_header(out_hdrs, "Upgrade", "websocket"); 398| 952| evhttp_add_header(out_hdrs, "Connection", "Upgrade"); 399| | 400| 952| evhttp_add_header(out_hdrs, "Sec-WebSocket-Accept", 401| 952| ws_gen_accept_key(ws_key, (char[32]){0})); 402| | 403| 952| ws_protocol = evhttp_find_header(in_hdrs, "Sec-WebSocket-Protocol"); 404| 952| if (ws_protocol != NULL) ------------------ | Branch (404:6): [True: 0, False: 952] ------------------ 405| 0| evhttp_add_header(out_hdrs, "Sec-WebSocket-Protocol", ws_protocol); 406| | 407| 952| if ((evws = mm_calloc(1, sizeof(struct evws_connection))) == NULL) { ------------------ | | 77| 952|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ | Branch (407:6): [True: 0, False: 952] ------------------ 408| 0| event_warn("%s: calloc failed", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 409| 0| goto error; 410| 0| } 411| | 412| 952| evws->cb = cb; 413| 952| evws->cb_arg = arg; 414| | 415| 952| evcon = evhttp_request_get_connection(req); 416| 952| evws->http_server = evcon->http_server; 417| | 418| 952| evws->bufev = evhttp_start_ws_(req); 419| 952| if (evws->bufev == NULL) { ------------------ | Branch (419:6): [True: 0, False: 952] ------------------ 420| 0| goto error; 421| 0| } 422| | 423| 952| if (options & BEV_OPT_THREADSAFE) { ------------------ | Branch (423:6): [True: 0, False: 952] ------------------ 424| 0| if (bufferevent_enable_locking_(evws->bufev, NULL) < 0) ------------------ | Branch (424:7): [True: 0, False: 0] ------------------ 425| 0| goto error; 426| 0| } 427| | 428| 952| bufferevent_setcb( 429| 952| evws->bufev, ws_evhttp_read_cb, NULL, ws_evhttp_error_cb, evws); 430| | 431| 952| TAILQ_INSERT_TAIL(&evws->http_server->ws_sessions, evws, next); ------------------ | | 332| 952|#define TAILQ_INSERT_TAIL(head, elm, field) do { \ | | 333| 952| (elm)->field.tqe_next = NULL; \ | | 334| 952| (elm)->field.tqe_prev = (head)->tqh_last; \ | | 335| 952| *(head)->tqh_last = (elm); \ | | 336| 952| (head)->tqh_last = &(elm)->field.tqe_next; \ | | 337| 952|} while (0) | | ------------------ | | | Branch (337:10): [Folded, False: 952] | | ------------------ ------------------ 432| 952| evws->http_server->connection_cnt++; 433| | 434| 952| return evws; 435| | 436| 0|error: 437| 0| if (evws) ------------------ | Branch (437:6): [True: 0, False: 0] ------------------ 438| 0| evws_connection_free(evws); 439| | 440| 0| evhttp_send_reply(req, HTTP_BADREQUEST, NULL, NULL); ------------------ | | 68| 0|#define HTTP_BADREQUEST 400 /**< invalid http request was made */ ------------------ 441| | return NULL; 442| 952|} ws.c:ws_gen_accept_key: 148| 952|{ 149| 952| char buf[1024]; 150| 952| char digest[20]; 151| | 152| 952| snprintf(buf, sizeof(buf), "%s" WS_UUID, ws_key); ------------------ | | 40| 952|#define WS_UUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" ------------------ 153| | 154| 952| builtin_SHA1(digest, buf, strlen(buf)); 155| 952| Base64encode(out, digest, sizeof(digest)); 156| 952| return out; 157| 952|} ws.c:Base64encode: 116| 952|{ 117| 952| int i; 118| 952| char *p; 119| | 120| 952| p = encoded; 121| 6.66k| for (i = 0; i < len - 2; i += 3) { ------------------ | Branch (121:14): [True: 5.71k, False: 952] ------------------ 122| 5.71k| *p++ = basis_64[(string[i] >> 2) & 0x3F]; 123| 5.71k| *p++ = basis_64[((string[i] & 0x3) << 4) | 124| 5.71k| ((int)(string[i + 1] & 0xF0) >> 4)]; 125| 5.71k| *p++ = basis_64[((string[i + 1] & 0xF) << 2) | 126| 5.71k| ((int)(string[i + 2] & 0xC0) >> 6)]; 127| 5.71k| *p++ = basis_64[string[i + 2] & 0x3F]; 128| 5.71k| } 129| 952| if (i < len) { ------------------ | Branch (129:6): [True: 952, False: 0] ------------------ 130| 952| *p++ = basis_64[(string[i] >> 2) & 0x3F]; 131| 952| if (i == (len - 1)) { ------------------ | Branch (131:7): [True: 0, False: 952] ------------------ 132| 0| *p++ = basis_64[((string[i] & 0x3) << 4)]; 133| 0| *p++ = '='; 134| 952| } else { 135| 952| *p++ = basis_64[((string[i] & 0x3) << 4) | 136| 952| ((int)(string[i + 1] & 0xF0) >> 4)]; 137| 952| *p++ = basis_64[((string[i + 1] & 0xF) << 2)]; 138| 952| } 139| 952| *p++ = '='; 140| 952| } 141| | 142| 952| *p++ = '\0'; 143| 952| return p - encoded; 144| 952|} ws.c:ws_evhttp_read_cb: 296| 952|{ 297| 952| struct evws_connection *evws = arg; 298| 952| unsigned char *payload; 299| 952| enum WebSocketFrameType type; 300| 952| size_t msg_len, in_len, header_sz; 301| 952| struct evbuffer *input = bufferevent_get_input(evws->bufev); 302| | 303| 952| bufferevent_incref_and_lock_(evws->bufev); 304| 1.14M| while ((in_len = evbuffer_get_length(input))) { ------------------ | Branch (304:9): [True: 1.14M, False: 467] ------------------ 305| 1.14M| unsigned char *data = evbuffer_pullup(input, in_len); 306| 1.14M| if (data == NULL) { ------------------ | Branch (306:7): [True: 0, False: 1.14M] ------------------ 307| 0| goto bailout; 308| 0| } 309| | 310| 1.14M| type = get_ws_frame(data, in_len, &payload, &msg_len); 311| 1.14M| if (type == INCOMPLETE_DATA) { ------------------ | Branch (311:7): [True: 485, False: 1.14M] ------------------ 312| | /* incomplete data received, wait for next chunk */ 313| 485| goto bailout; 314| 485| } 315| 1.14M| header_sz = payload - data; 316| 1.14M| evbuffer_drain(input, header_sz); 317| 1.14M| data = evbuffer_pullup(input, -1); 318| | 319| 1.14M| switch (type) { 320| 21.0k| case TEXT_FRAME: ------------------ | Branch (320:3): [True: 21.0k, False: 1.12M] ------------------ 321| 31.1k| case BINARY_FRAME: ------------------ | Branch (321:3): [True: 10.1k, False: 1.13M] ------------------ 322| 31.1k| if (evws->incomplete_frames != NULL) { ------------------ | Branch (322:8): [True: 24.9k, False: 6.19k] ------------------ 323| | /* we already have incomplete frames in internal buffer 324| | * and need to concatenate them with final one */ 325| 24.9k| evbuffer_add(evws->incomplete_frames, data, msg_len); 326| | 327| 24.9k| data = evbuffer_pullup(evws->incomplete_frames, -1); 328| | 329| 24.9k| evws->cb(evws, type, data, 330| 24.9k| evbuffer_get_length(evws->incomplete_frames), evws->cb_arg); 331| 24.9k| evbuffer_free(evws->incomplete_frames); 332| 24.9k| evws->incomplete_frames = NULL; 333| 24.9k| } else { 334| 6.19k| evws->cb(evws, type, data, msg_len, evws->cb_arg); 335| 6.19k| } 336| 31.1k| break; 337| 855k| case INCOMPLETE_FRAME: ------------------ | Branch (337:3): [True: 855k, False: 290k] ------------------ 338| | /* we received full frame until get fin and need to 339| | * postpone callback until all data arrives */ 340| 855k| if (evws->incomplete_frames == NULL) { ------------------ | Branch (340:8): [True: 25.4k, False: 829k] ------------------ 341| 25.4k| evws->incomplete_frames = evbuffer_new(); 342| 25.4k| } 343| 855k| evbuffer_remove_buffer(input, evws->incomplete_frames, msg_len); 344| 855k| continue; 345| 57.2k| case CLOSING_FRAME: ------------------ | Branch (345:3): [True: 57.2k, False: 1.08M] ------------------ 346| 115k| case ERROR_FRAME: ------------------ | Branch (346:3): [True: 58.0k, False: 1.08M] ------------------ 347| 115k| evws_force_disconnect_(evws); 348| 115k| break; 349| 75.7k| case PING_FRAME: ------------------ | Branch (349:3): [True: 75.7k, False: 1.06M] ------------------ 350| 140k| case PONG_FRAME: ------------------ | Branch (350:3): [True: 64.3k, False: 1.08M] ------------------ 351| | /* ping or pong frame */ 352| 140k| break; 353| 3.81k| default: ------------------ | Branch (353:3): [True: 3.81k, False: 1.14M] ------------------ 354| 3.81k| event_warn("%s: unexpected frame type %d\n", __func__, type); ------------------ | | 81| 3.81k|# define __func__ __func__ ------------------ 355| 3.81k| evws_force_disconnect_(evws); 356| 1.14M| } 357| 290k| evbuffer_drain(input, msg_len); 358| 290k| } 359| | 360| 952|bailout: 361| 952| bufferevent_decref_and_unlock_(evws->bufev); 362| 952|} ws.c:get_ws_frame: 206| 1.14M|{ 207| 1.14M| unsigned char opcode; 208| 1.14M| unsigned char fin; 209| 1.14M| unsigned char masked; 210| 1.14M| size_t payload_len; 211| 1.14M| size_t pos; 212| 1.14M| int length_field; 213| | 214| 1.14M| if (buf_len < 2) { ------------------ | Branch (214:6): [True: 183, False: 1.14M] ------------------ 215| 183| return INCOMPLETE_DATA; 216| 183| } 217| | 218| 1.14M| opcode = in_buffer[0] & 0x0F; 219| 1.14M| fin = (in_buffer[0] >> 7) & 0x01; 220| 1.14M| masked = (in_buffer[1] >> 7) & 0x01; 221| | 222| 1.14M| payload_len = 0; 223| 1.14M| pos = 2; 224| 1.14M| length_field = in_buffer[1] & (~0x80); 225| | 226| 1.14M| if (length_field <= 125) { ------------------ | Branch (226:6): [True: 1.10M, False: 42.2k] ------------------ 227| 1.10M| payload_len = length_field; 228| 1.10M| } else if (length_field == 126) { /* msglen is 16bit */ ------------------ | Branch (228:13): [True: 9.27k, False: 32.9k] ------------------ 229| 9.27k| uint16_t tmp16; 230| 9.27k| if (buf_len < 4) ------------------ | Branch (230:7): [True: 3, False: 9.27k] ------------------ 231| 3| return INCOMPLETE_DATA; 232| 9.27k| memcpy(&tmp16, in_buffer + pos, 2); 233| 9.27k| payload_len = ntohs(tmp16); 234| 9.27k| pos += 2; 235| 32.9k| } else if (length_field == 127) { /* msglen is 64bit */ ------------------ | Branch (235:13): [True: 32.9k, False: 0] ------------------ 236| 32.9k| int i; 237| 32.9k| uint64_t tmp64 = 0; 238| 32.9k| if (buf_len < 10) ------------------ | Branch (238:7): [True: 22, False: 32.9k] ------------------ 239| 22| return INCOMPLETE_DATA; 240| | /* swap bytes from big endian to host byte order */ 241| 296k| for (i = 56; i >= 0; i -= 8) { ------------------ | Branch (241:16): [True: 263k, False: 32.9k] ------------------ 242| 263k| tmp64 |= (uint64_t)in_buffer[pos++] << i; 243| 263k| } 244| 32.9k| if (tmp64 > WS_MAX_RECV_FRAME_SZ) { ------------------ | Branch (244:7): [True: 29.7k, False: 3.17k] ------------------ 245| | /* Implementation limitation, we support up to 10 MiB 246| | * length, as a DoS prevention measure. 247| | */ 248| 29.7k| event_warn("%s: frame length %" PRIu64 " exceeds %" PRIu64 "\n", 249| 29.7k| __func__, tmp64, (uint64_t)WS_MAX_RECV_FRAME_SZ); ------------------ | | 81| 29.7k|# define __func__ __func__ ------------------ 250| | /* Calling code needs these values; do the best we can here. 251| | * Caller will close the connection anyway. 252| | */ 253| 29.7k| *payload_ptr = in_buffer + pos; 254| 29.7k| *out_len = 0; 255| 29.7k| return ERROR_FRAME; 256| 29.7k| } 257| 3.17k| payload_len = (size_t)tmp64; 258| 3.17k| } 259| 1.11M| if (buf_len < payload_len + pos + (masked ? 4u : 0u)) { ------------------ | Branch (259:6): [True: 277, False: 1.11M] | Branch (259:37): [True: 39.7k, False: 1.07M] ------------------ 260| 277| return INCOMPLETE_DATA; 261| 277| } 262| | 263| | /* According to RFC it seems that unmasked data should be prohibited 264| | * but we support it for nonconformant clients 265| | */ 266| 1.11M| if (masked) { ------------------ | Branch (266:6): [True: 39.6k, False: 1.07M] ------------------ 267| 39.6k| unsigned char *c, *mask; 268| 39.6k| size_t i; 269| | 270| 39.6k| mask = in_buffer + pos; /* first 4 bytes are mask bytes */ 271| 39.6k| pos += 4; 272| | 273| | /* unmask data */ 274| 39.6k| c = in_buffer + pos; 275| 14.5M| for (i = 0; i < payload_len; i++) { ------------------ | Branch (275:15): [True: 14.5M, False: 39.6k] ------------------ 276| 14.5M| c[i] = c[i] ^ mask[i % 4u]; 277| 14.5M| } 278| 39.6k| } 279| | 280| 1.11M| *payload_ptr = in_buffer + pos; 281| 1.11M| *out_len = payload_len; 282| | 283| | /* are reserved for further frames */ 284| 1.11M| if ((opcode >= 3 && opcode <= 7) || (opcode >= 0xb)) ------------------ | Branch (284:7): [True: 225k, False: 890k] | Branch (284:22): [True: 11.3k, False: 214k] | Branch (284:38): [True: 16.9k, False: 1.08M] ------------------ 285| 28.2k| return ERROR_FRAME; 286| | 287| 1.08M| if (opcode <= 0x3 && !fin) { ------------------ | Branch (287:6): [True: 890k, False: 197k] | Branch (287:23): [True: 855k, False: 34.9k] ------------------ 288| 855k| return INCOMPLETE_FRAME; 289| 855k| } 290| 232k| return opcode; 291| 1.08M|} ws.c:evws_force_disconnect_: 196| 119k|{ 197| 119k| evws_close(evws, WS_CR_NONE); ------------------ | | 14| 119k|#define WS_CR_NONE 0 ------------------ 198| 119k|} LLVMFuzzerTestOneInput: 32| 952|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 33| 952| struct event_base *base = event_base_new(); 34| 952| if (!base) return 0; ------------------ | Branch (34:9): [True: 0, False: 952] ------------------ 35| | 36| 952| struct evhttp *http = evhttp_new(base); 37| 952| struct bufferevent *bev[2]; 38| 952| if (bufferevent_pair_new(base, 0, bev) != 0) { ------------------ | Branch (38:9): [True: 0, False: 952] ------------------ 39| 0| evhttp_free(http); 40| 0| event_base_free(base); 41| 0| return 0; 42| 0| } 43| | 44| 952| struct evhttp_connection *evcon = evhttp_connection_base_bufferevent_new(base, NULL, bev[0], "127.0.0.1", 80); 45| | 46| | /* Associate evcon with http to satisfy evws_new_session requirements */ 47| 952| evcon->http_server = http; 48| 952| TAILQ_INSERT_TAIL(&http->connections, evcon, next); ------------------ | Branch (48:5): [Folded, False: 952] ------------------ 49| | 50| 952| struct evhttp_request *req = evhttp_request_new(NULL, NULL); 51| 952| if (!req) { ------------------ | Branch (51:9): [True: 0, False: 952] ------------------ 52| 0| evhttp_connection_free(evcon); 53| 0| evhttp_free(http); 54| 0| bufferevent_free(bev[1]); 55| 0| return 0; 56| 0| } 57| 952| req->evcon = evcon; 58| 952| req->kind = EVHTTP_REQUEST; 59| 952| TAILQ_INSERT_TAIL(&evcon->requests, req, next); ------------------ | Branch (59:5): [Folded, False: 952] ------------------ 60| | 61| | /* Add required headers for WebSocket handshake */ 62| 952| struct evkeyvalq *in_hdrs = evhttp_request_get_input_headers(req); 63| 952| evhttp_add_header(in_hdrs, "Upgrade", "websocket"); 64| 952| evhttp_add_header(in_hdrs, "Connection", "Upgrade"); 65| 952| evhttp_add_header(in_hdrs, "Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ=="); 66| | 67| | /* evws_new_session takes 4 arguments in this version of libevent */ 68| 952| struct evws_connection *ws = evws_new_session(req, on_msg, NULL, 0); 69| 952| if (ws) { ------------------ | Branch (69:9): [True: 952, False: 0] ------------------ 70| 952| struct evbuffer *output = bufferevent_get_output(bev[1]); 71| 952| evbuffer_add(output, data, size); 72| | 73| 952| event_base_loop(base, EVLOOP_NONBLOCK); 74| | 75| 952| evws_connection_free(ws); 76| 952| } 77| 952| evhttp_free(http); 78| 952| bufferevent_free(bev[1]); 79| 952| event_base_free(base); 80| | 81| 952| return 0; 82| 952|} ws_fuzzer.cc:_ZL6on_msgP15evws_connectioniPKhmPv: 29| 31.1k|static void on_msg(struct evws_connection *ws, int type, const uint8_t *data, size_t len, void *arg) { 30| 31.1k|}