evbuffer_new: 372| 25.9k|{ 373| 25.9k| struct evbuffer *buffer; 374| | 375| 25.9k| buffer = mm_calloc(1, sizeof(struct evbuffer)); ------------------ | | 77| 25.9k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ 376| 25.9k| if (buffer == NULL) ------------------ | Branch (376:6): [True: 0, False: 25.9k] ------------------ 377| 0| return (NULL); 378| | 379| 25.9k| LIST_INIT(&buffer->callbacks); ------------------ | | 170| 25.9k|#define LIST_INIT(head) do { \ | | 171| 25.9k| LIST_FIRST(head) = LIST_END(head); \ | | ------------------ | | | | 157| 25.9k|#define LIST_FIRST(head) ((head)->lh_first) | | ------------------ | | LIST_FIRST(head) = LIST_END(head); \ | | ------------------ | | | | 158| 25.9k|#define LIST_END(head) NULL | | ------------------ | | 172| 25.9k|} while (0) | | ------------------ | | | Branch (172:10): [Folded, False: 25.9k] | | ------------------ ------------------ 380| 25.9k| buffer->refcnt = 1; 381| 25.9k| buffer->last_with_datap = &buffer->first; 382| 25.9k| buffer->max_read = EVBUFFER_MAX_READ_DEFAULT; ------------------ | | 137| 25.9k|#define EVBUFFER_MAX_READ_DEFAULT 4096 ------------------ 383| | 384| 25.9k| return (buffer); 385| 25.9k|} evbuffer_set_parent_: 459| 4.06k|{ 460| 4.06k| EVBUFFER_LOCK(buf); ------------------ | | 288| 4.06k| do { \ | | 289| 4.06k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 4.06k| do { \ | | | | 95| 4.06k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 4.06k] | | | | ------------------ | | | | 96| 4.06k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 4.06k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 4.06k] | | | | ------------------ | | ------------------ | | 290| 4.06k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 4.06k] | | ------------------ ------------------ 461| 4.06k| buf->parent = bev; 462| 4.06k| EVBUFFER_UNLOCK(buf); ------------------ | | 292| 4.06k| do { \ | | 293| 4.06k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 4.06k| do { \ | | | | 102| 4.06k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 4.06k] | | | | ------------------ | | | | 103| 4.06k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 4.06k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 4.06k] | | | | ------------------ | | ------------------ | | 294| 4.06k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 4.06k] | | ------------------ ------------------ 463| 4.06k|} evbuffer_invoke_callbacks_: 525| 5.01M|{ 526| 5.01M| if (LIST_EMPTY(&buffer->callbacks)) { ------------------ | | 159| 5.01M|#define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head)) | | ------------------ | | | | 157| 5.01M|#define LIST_FIRST(head) ((head)->lh_first) | | ------------------ | | #define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head)) | | ------------------ | | | | 158| 5.01M|#define LIST_END(head) NULL | | ------------------ | | | Branch (159:27): [True: 5.01M, False: 7.70k] | | ------------------ ------------------ 527| 5.01M| buffer->n_add_for_cb = buffer->n_del_for_cb = 0; 528| 5.01M| return; 529| 5.01M| } 530| | 531| 7.70k| if (buffer->deferred_cbs) { ------------------ | Branch (531:6): [True: 0, False: 7.70k] ------------------ 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); ------------------ | | 378| 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.70k| evbuffer_run_callbacks(buffer, 0); 541| 7.70k|} evbuffer_decref_and_unlock_: 572| 25.9k|{ 573| 25.9k| struct evbuffer_chain *chain, *next; 574| 25.9k| ASSERT_EVBUFFER_LOCKED(buffer); ------------------ | | 285| 25.9k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 25.9k| do { \ | | | | 131| 25.9k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 25.9k] | | | | | 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| 25.9k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 25.9k] | | | | ------------------ | | ------------------ ------------------ 575| | 576| 25.9k| EVUTIL_ASSERT(buffer->refcnt > 0); ------------------ | | 368| 25.9k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 25.9k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 25.9k| (void)sizeof(!(condition)); \ | | | | 98| 25.9k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 25.9k] | | | | ------------------ | | ------------------ ------------------ 577| | 578| 25.9k| if (--buffer->refcnt > 0) { ------------------ | Branch (578:6): [True: 0, False: 25.9k] ------------------ 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| 49.0k| for (chain = buffer->first; chain != NULL; chain = next) { ------------------ | Branch (583:30): [True: 23.0k, False: 25.9k] ------------------ 584| 23.0k| next = chain->next; 585| 23.0k| evbuffer_chain_free(chain); 586| 23.0k| } 587| 25.9k| evbuffer_remove_all_callbacks(buffer); 588| 25.9k| if (buffer->deferred_cbs) ------------------ | Branch (588:6): [True: 0, False: 25.9k] ------------------ 589| 0| event_deferred_cb_cancel_(buffer->cb_queue, &buffer->deferred); 590| | 591| 25.9k| EVBUFFER_UNLOCK(buffer); ------------------ | | 292| 25.9k| do { \ | | 293| 25.9k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 25.9k| do { \ | | | | 102| 25.9k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 25.9k] | | | | ------------------ | | | | 103| 25.9k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 25.9k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 25.9k] | | | | ------------------ | | ------------------ | | 294| 25.9k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 25.9k] | | ------------------ ------------------ 592| 25.9k| if (buffer->own_lock) ------------------ | Branch (592:6): [True: 0, False: 25.9k] ------------------ 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| 25.9k| mm_free(buffer); ------------------ | | 80| 25.9k|#define mm_free(p) event_mm_free_(p) ------------------ 595| 25.9k|} evbuffer_free: 599| 25.9k|{ 600| 25.9k| EVBUFFER_LOCK(buffer); ------------------ | | 288| 25.9k| do { \ | | 289| 25.9k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 25.9k| do { \ | | | | 95| 25.9k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 25.9k] | | | | ------------------ | | | | 96| 25.9k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 25.9k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 25.9k] | | | | ------------------ | | ------------------ | | 290| 25.9k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 25.9k] | | ------------------ ------------------ 601| 25.9k| evbuffer_decref_and_unlock_(buffer); 602| 25.9k|} evbuffer_set_max_read: 605| 2.03k|{ 606| 2.03k| if (max > INT_MAX) { ------------------ | Branch (606:6): [True: 0, False: 2.03k] ------------------ 607| 0| return -1; 608| 0| } 609| | 610| 2.03k| EVBUFFER_LOCK(buf); ------------------ | | 288| 2.03k| do { \ | | 289| 2.03k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 2.03k| do { \ | | | | 95| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 96| 2.03k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 290| 2.03k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 2.03k] | | ------------------ ------------------ 611| 2.03k| buf->max_read = max; 612| 2.03k| EVBUFFER_UNLOCK(buf); ------------------ | | 292| 2.03k| do { \ | | 293| 2.03k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 2.03k| do { \ | | | | 102| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 103| 2.03k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 294| 2.03k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 2.03k] | | ------------------ ------------------ 613| 2.03k| return 0; 614| 2.03k|} evbuffer_get_length: 638| 6.94M|{ 639| 6.94M| size_t result; 640| 6.94M| EVBUFFER_LOCK(buffer); ------------------ | | 288| 6.94M| do { \ | | 289| 6.94M| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 6.94M| do { \ | | | | 95| 6.94M| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 6.94M] | | | | ------------------ | | | | 96| 6.94M| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 6.94M| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 6.94M] | | | | ------------------ | | ------------------ | | 290| 6.94M| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 6.94M] | | ------------------ ------------------ 641| 6.94M| result = buffer->total_len; 642| 6.94M| EVBUFFER_UNLOCK(buffer); ------------------ | | 292| 6.94M| do { \ | | 293| 6.94M| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 6.94M| do { \ | | | | 102| 6.94M| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 6.94M] | | | | ------------------ | | | | 103| 6.94M| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 6.94M| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 6.94M] | | | | ------------------ | | ------------------ | | 294| 6.94M| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 6.94M] | | ------------------ ------------------ 643| 6.94M| return result; 644| 6.94M|} evbuffer_add_buffer: 993| 1.10k|{ 994| 1.10k| struct evbuffer_chain *pinned, *last; 995| 1.10k| size_t in_total_len, out_total_len; 996| 1.10k| int result = 0; 997| | 998| 1.10k| EVBUFFER_LOCK2(inbuf, outbuf); ------------------ | | 296| 1.10k| do { \ | | 297| 1.10k| EVLOCK_LOCK2((buffer1)->lock, (buffer2)->lock, 0, 0); \ | | ------------------ | | | | 351| 1.10k| do { \ | | | | 352| 1.10k| void *lock1_tmplock_ = (lock1); \ | | | | 353| 1.10k| void *lock2_tmplock_ = (lock2); \ | | | | 354| 1.10k| EVLOCK_SORTLOCKS_(lock1_tmplock_,lock2_tmplock_); \ | | | | ------------------ | | | | | | 340| 1.10k| do { \ | | | | | | 341| 1.10k| if (lockvar1 && lockvar2 && lockvar1 > lockvar2) { \ | | | | | | ------------------ | | | | | | | Branch (341:7): [True: 0, False: 1.10k] | | | | | | | 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.10k| } while (0) | | | | | | ------------------ | | | | | | | Branch (346:11): [Folded, False: 1.10k] | | | | | | ------------------ | | | | ------------------ | | | | 355| 1.10k| EVLOCK_LOCK(lock1_tmplock_,mode1); \ | | | | ------------------ | | | | | | 94| 1.10k| do { \ | | | | | | 95| 1.10k| if (lockvar) \ | | | | | | ------------------ | | | | | | | Branch (95:7): [True: 0, False: 1.10k] | | | | | | ------------------ | | | | | | 96| 1.10k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | | | 97| 1.10k| } while (0) | | | | | | ------------------ | | | | | | | Branch (97:11): [Folded, False: 1.10k] | | | | | | ------------------ | | | | ------------------ | | | | 356| 1.10k| if (lock2_tmplock_ != lock1_tmplock_) \ | | | | ------------------ | | | | | Branch (356:7): [True: 0, False: 1.10k] | | | | ------------------ | | | | 357| 1.10k| 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.10k| } while (0) | | | | ------------------ | | | | | Branch (358:11): [Folded, False: 1.10k] | | | | ------------------ | | ------------------ | | 298| 1.10k| } while (0) | | ------------------ | | | Branch (298:11): [Folded, False: 1.10k] | | ------------------ ------------------ 999| 1.10k| in_total_len = inbuf->total_len; 1000| 1.10k| out_total_len = outbuf->total_len; 1001| | 1002| 1.10k| if (in_total_len == 0 || outbuf == inbuf) ------------------ | Branch (1002:6): [True: 0, False: 1.10k] | Branch (1002:27): [True: 0, False: 1.10k] ------------------ 1003| 0| goto done; 1004| | 1005| 1.10k| if (outbuf->freeze_end || inbuf->freeze_start) { ------------------ | Branch (1005:6): [True: 0, False: 1.10k] | Branch (1005:28): [True: 0, False: 1.10k] ------------------ 1006| 0| result = -1; 1007| 0| goto done; 1008| 0| } 1009| | 1010| 1.10k| if (PRESERVE_PINNED(inbuf, &pinned, &last) < 0) { ------------------ | Branch (1010:6): [True: 0, False: 1.10k] ------------------ 1011| 0| result = -1; 1012| 0| goto done; 1013| 0| } 1014| | 1015| 1.10k| if (out_total_len == 0) { ------------------ | Branch (1015:6): [True: 1.05k, False: 48] ------------------ 1016| | /* There might be an empty chain at the start of outbuf; free 1017| | * it. */ 1018| 1.05k| evbuffer_free_all_chains(outbuf->first); 1019| 1.05k| COPY_CHAIN(outbuf, inbuf); 1020| 1.05k| } else { 1021| 48| APPEND_CHAIN(outbuf, inbuf); 1022| 48| } 1023| | 1024| 1.10k| RESTORE_PINNED(inbuf, pinned, last); 1025| | 1026| 1.10k| inbuf->n_del_for_cb += in_total_len; 1027| 1.10k| outbuf->n_add_for_cb += in_total_len; 1028| | 1029| 1.10k| evbuffer_invoke_callbacks_(inbuf); 1030| 1.10k| evbuffer_invoke_callbacks_(outbuf); 1031| | 1032| 1.10k|done: 1033| 1.10k| EVBUFFER_UNLOCK2(inbuf, outbuf); ------------------ | | 300| 1.10k| do { \ | | 301| 1.10k| EVLOCK_UNLOCK2((buffer1)->lock, (buffer2)->lock, 0, 0); \ | | ------------------ | | | | 361| 1.10k| do { \ | | | | 362| 1.10k| void *lock1_tmplock_ = (lock1); \ | | | | 363| 1.10k| void *lock2_tmplock_ = (lock2); \ | | | | 364| 1.10k| EVLOCK_SORTLOCKS_(lock1_tmplock_,lock2_tmplock_); \ | | | | ------------------ | | | | | | 340| 1.10k| do { \ | | | | | | 341| 1.10k| if (lockvar1 && lockvar2 && lockvar1 > lockvar2) { \ | | | | | | ------------------ | | | | | | | Branch (341:7): [True: 0, False: 1.10k] | | | | | | | 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.10k| } while (0) | | | | | | ------------------ | | | | | | | Branch (346:11): [Folded, False: 1.10k] | | | | | | ------------------ | | | | ------------------ | | | | 365| 1.10k| if (lock2_tmplock_ != lock1_tmplock_) \ | | | | ------------------ | | | | | Branch (365:7): [True: 0, False: 1.10k] | | | | ------------------ | | | | 366| 1.10k| 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.10k| EVLOCK_UNLOCK(lock1_tmplock_,mode1); \ | | | | ------------------ | | | | | | 101| 1.10k| do { \ | | | | | | 102| 1.10k| if (lockvar) \ | | | | | | ------------------ | | | | | | | Branch (102:7): [True: 0, False: 1.10k] | | | | | | ------------------ | | | | | | 103| 1.10k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | | | 104| 1.10k| } while (0) | | | | | | ------------------ | | | | | | | Branch (104:11): [Folded, False: 1.10k] | | | | | | ------------------ | | | | ------------------ | | | | 368| 1.10k| } while (0) | | | | ------------------ | | | | | Branch (368:11): [Folded, False: 1.10k] | | | | ------------------ | | ------------------ | | 302| 1.10k| } while (0) | | ------------------ | | | Branch (302:11): [Folded, False: 1.10k] | | ------------------ ------------------ 1034| 1.10k| return result; 1035| 1.10k|} evbuffer_drain: 1133| 3.87M|{ 1134| 3.87M| struct evbuffer_chain *chain, *next; 1135| 3.87M| size_t remaining, old_len; 1136| 3.87M| int result = 0; 1137| | 1138| 3.87M| EVBUFFER_LOCK(buf); ------------------ | | 288| 3.87M| do { \ | | 289| 3.87M| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 3.87M| do { \ | | | | 95| 3.87M| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 3.87M] | | | | ------------------ | | | | 96| 3.87M| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 3.87M| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 3.87M] | | | | ------------------ | | ------------------ | | 290| 3.87M| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 3.87M] | | ------------------ ------------------ 1139| 3.87M| old_len = buf->total_len; 1140| | 1141| 3.87M| if (old_len == 0) ------------------ | Branch (1141:6): [True: 249, False: 3.87M] ------------------ 1142| 249| goto done; 1143| | 1144| 3.87M| if (buf->freeze_start) { ------------------ | Branch (1144:6): [True: 0, False: 3.87M] ------------------ 1145| 0| result = -1; 1146| 0| goto done; 1147| 0| } 1148| | 1149| 3.87M| if (len >= old_len && !HAS_PINNED_R(buf)) { ------------------ | Branch (1149:6): [True: 413, False: 3.87M] | Branch (1149:24): [True: 413, False: 0] ------------------ 1150| 413| len = old_len; 1151| 826| for (chain = buf->first; chain != NULL; chain = next) { ------------------ | Branch (1151:28): [True: 413, False: 413] ------------------ 1152| 413| next = chain->next; 1153| 413| evbuffer_chain_free(chain); 1154| 413| } 1155| | 1156| 413| ZERO_CHAIN(buf); 1157| 3.87M| } else { 1158| 3.87M| if (len >= old_len) ------------------ | Branch (1158:7): [True: 0, False: 3.87M] ------------------ 1159| 0| len = old_len; 1160| | 1161| 3.87M| buf->total_len -= len; 1162| 3.87M| remaining = len; 1163| 3.87M| for (chain = buf->first; 1164| 3.87M| remaining >= chain->off; ------------------ | Branch (1164:8): [True: 0, False: 3.87M] ------------------ 1165| 3.87M| chain = next) { 1166| 0| next = chain->next; 1167| 0| remaining -= chain->off; 1168| | 1169| 0| if (chain == *buf->last_with_datap) { ------------------ | Branch (1169:8): [True: 0, False: 0] ------------------ 1170| 0| buf->last_with_datap = &buf->first; 1171| 0| } 1172| 0| if (&chain->next == buf->last_with_datap) ------------------ | Branch (1172:8): [True: 0, False: 0] ------------------ 1173| 0| buf->last_with_datap = &buf->first; 1174| | 1175| 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] | | ------------------ ------------------ 1176| 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] | | | | ------------------ | | ------------------ ------------------ 1177| 0| chain->misalign += chain->off; 1178| 0| chain->off = 0; 1179| 0| break; 1180| 0| } else 1181| 0| evbuffer_chain_free(chain); 1182| 0| } 1183| | 1184| 3.87M| buf->first = chain; 1185| 3.87M| EVUTIL_ASSERT(remaining <= chain->off); ------------------ | | 368| 3.87M|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 3.87M|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 3.87M| (void)sizeof(!(condition)); \ | | | | 98| 3.87M|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 3.87M] | | | | ------------------ | | ------------------ ------------------ 1186| 3.87M| chain->misalign += remaining; 1187| 3.87M| chain->off -= remaining; 1188| 3.87M| } 1189| | 1190| 3.87M| buf->n_del_for_cb += len; 1191| | /* Tell someone about changes in this buffer */ 1192| 3.87M| evbuffer_invoke_callbacks_(buf); 1193| | 1194| 3.87M|done: 1195| 3.87M| EVBUFFER_UNLOCK(buf); ------------------ | | 292| 3.87M| do { \ | | 293| 3.87M| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 3.87M| do { \ | | | | 102| 3.87M| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 3.87M] | | | | ------------------ | | | | 103| 3.87M| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 3.87M| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 3.87M] | | | | ------------------ | | ------------------ | | 294| 3.87M| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 3.87M] | | ------------------ ------------------ 1196| 3.87M| return result; 1197| 3.87M|} evbuffer_remove_buffer: 1293| 3.30M|{ 1294| | /*XXX We should have an option to force this to be zero-copy.*/ 1295| | 1296| | /*XXX can fail badly on sendfile case. */ 1297| 3.30M| struct evbuffer_chain *chain, *previous; 1298| 3.30M| size_t nread = 0; 1299| 3.30M| int result; 1300| | 1301| 3.30M| EVBUFFER_LOCK2(src, dst); ------------------ | | 296| 3.30M| do { \ | | 297| 3.30M| EVLOCK_LOCK2((buffer1)->lock, (buffer2)->lock, 0, 0); \ | | ------------------ | | | | 351| 3.30M| do { \ | | | | 352| 3.30M| void *lock1_tmplock_ = (lock1); \ | | | | 353| 3.30M| void *lock2_tmplock_ = (lock2); \ | | | | 354| 3.30M| EVLOCK_SORTLOCKS_(lock1_tmplock_,lock2_tmplock_); \ | | | | ------------------ | | | | | | 340| 3.30M| do { \ | | | | | | 341| 3.30M| if (lockvar1 && lockvar2 && lockvar1 > lockvar2) { \ | | | | | | ------------------ | | | | | | | Branch (341:7): [True: 0, False: 3.30M] | | | | | | | 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| 3.30M| } while (0) | | | | | | ------------------ | | | | | | | Branch (346:11): [Folded, False: 3.30M] | | | | | | ------------------ | | | | ------------------ | | | | 355| 3.30M| EVLOCK_LOCK(lock1_tmplock_,mode1); \ | | | | ------------------ | | | | | | 94| 3.30M| do { \ | | | | | | 95| 3.30M| if (lockvar) \ | | | | | | ------------------ | | | | | | | Branch (95:7): [True: 0, False: 3.30M] | | | | | | ------------------ | | | | | | 96| 3.30M| evthread_lock_fns_.lock(mode, lockvar); \ | | | | | | 97| 3.30M| } while (0) | | | | | | ------------------ | | | | | | | Branch (97:11): [Folded, False: 3.30M] | | | | | | ------------------ | | | | ------------------ | | | | 356| 3.30M| if (lock2_tmplock_ != lock1_tmplock_) \ | | | | ------------------ | | | | | Branch (356:7): [True: 0, False: 3.30M] | | | | ------------------ | | | | 357| 3.30M| 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| 3.30M| } while (0) | | | | ------------------ | | | | | Branch (358:11): [Folded, False: 3.30M] | | | | ------------------ | | ------------------ | | 298| 3.30M| } while (0) | | ------------------ | | | Branch (298:11): [Folded, False: 3.30M] | | ------------------ ------------------ 1302| | 1303| 3.30M| chain = previous = src->first; 1304| | 1305| 3.30M| if (datlen == 0 || dst == src) { ------------------ | Branch (1305:6): [True: 2.93M, False: 370k] | Branch (1305:21): [True: 0, False: 370k] ------------------ 1306| 2.93M| result = 0; 1307| 2.93M| goto done; 1308| 2.93M| } 1309| | 1310| 370k| if (dst->freeze_end || src->freeze_start) { ------------------ | Branch (1310:6): [True: 0, False: 370k] | Branch (1310:25): [True: 0, False: 370k] ------------------ 1311| 0| result = -1; 1312| 0| goto done; 1313| 0| } 1314| | 1315| | /* short-cut if there is no more data buffered */ 1316| 370k| if (datlen >= src->total_len) { ------------------ | Branch (1316:6): [True: 87, False: 370k] ------------------ 1317| 87| datlen = src->total_len; 1318| 87| evbuffer_add_buffer(dst, src); 1319| 87| result = (int)datlen; /*XXXX should return ev_ssize_t*/ 1320| 87| goto done; 1321| 87| } 1322| | 1323| | /* removes chains if possible */ 1324| 370k| while (chain->off <= datlen) { ------------------ | Branch (1324:9): [True: 0, False: 370k] ------------------ 1325| | /* We can't remove the last with data from src unless we 1326| | * remove all chains, in which case we would have done the if 1327| | * block above */ 1328| 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] | | | | ------------------ | | ------------------ ------------------ 1329| 0| nread += chain->off; 1330| 0| datlen -= chain->off; 1331| 0| previous = chain; 1332| 0| if (src->last_with_datap == &chain->next) ------------------ | Branch (1332:7): [True: 0, False: 0] ------------------ 1333| 0| src->last_with_datap = &src->first; 1334| 0| chain = chain->next; 1335| 0| } 1336| | 1337| 370k| if (chain != src->first) { ------------------ | Branch (1337:6): [True: 0, False: 370k] ------------------ 1338| | /* we can remove the chain */ 1339| 0| struct evbuffer_chain **chp; 1340| 0| chp = evbuffer_free_trailing_empty_chains(dst); 1341| | 1342| 0| if (dst->first == NULL) { ------------------ | Branch (1342:7): [True: 0, False: 0] ------------------ 1343| 0| dst->first = src->first; 1344| 0| } else { 1345| 0| *chp = src->first; 1346| 0| } 1347| 0| dst->last = previous; 1348| 0| previous->next = NULL; 1349| 0| src->first = chain; 1350| 0| advance_last_with_data(dst); 1351| | 1352| 0| dst->total_len += nread; 1353| 0| dst->n_add_for_cb += nread; 1354| 0| } 1355| | 1356| | /* we know that there is more data in the src buffer than 1357| | * we want to read, so we manually drain the chain */ 1358| 370k| evbuffer_add(dst, chain->buffer + chain->misalign, datlen); 1359| 370k| chain->misalign += datlen; 1360| 370k| chain->off -= datlen; 1361| 370k| nread += datlen; 1362| | 1363| | /* You might think we would want to increment dst->n_add_for_cb 1364| | * here too. But evbuffer_add above already took care of that. 1365| | */ 1366| 370k| src->total_len -= nread; 1367| 370k| src->n_del_for_cb += nread; 1368| | 1369| 370k| if (nread) { ------------------ | Branch (1369:6): [True: 370k, False: 0] ------------------ 1370| 370k| evbuffer_invoke_callbacks_(dst); 1371| 370k| evbuffer_invoke_callbacks_(src); 1372| 370k| } 1373| 370k| result = (int)nread;/*XXXX should change return type */ 1374| | 1375| 3.30M|done: 1376| 3.30M| EVBUFFER_UNLOCK2(src, dst); ------------------ | | 300| 3.30M| do { \ | | 301| 3.30M| EVLOCK_UNLOCK2((buffer1)->lock, (buffer2)->lock, 0, 0); \ | | ------------------ | | | | 361| 3.30M| do { \ | | | | 362| 3.30M| void *lock1_tmplock_ = (lock1); \ | | | | 363| 3.30M| void *lock2_tmplock_ = (lock2); \ | | | | 364| 3.30M| EVLOCK_SORTLOCKS_(lock1_tmplock_,lock2_tmplock_); \ | | | | ------------------ | | | | | | 340| 3.30M| do { \ | | | | | | 341| 3.30M| if (lockvar1 && lockvar2 && lockvar1 > lockvar2) { \ | | | | | | ------------------ | | | | | | | Branch (341:7): [True: 0, False: 3.30M] | | | | | | | 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| 3.30M| } while (0) | | | | | | ------------------ | | | | | | | Branch (346:11): [Folded, False: 3.30M] | | | | | | ------------------ | | | | ------------------ | | | | 365| 3.30M| if (lock2_tmplock_ != lock1_tmplock_) \ | | | | ------------------ | | | | | Branch (365:7): [True: 0, False: 3.30M] | | | | ------------------ | | | | 366| 3.30M| 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| 3.30M| EVLOCK_UNLOCK(lock1_tmplock_,mode1); \ | | | | ------------------ | | | | | | 101| 3.30M| do { \ | | | | | | 102| 3.30M| if (lockvar) \ | | | | | | ------------------ | | | | | | | Branch (102:7): [True: 0, False: 3.30M] | | | | | | ------------------ | | | | | | 103| 3.30M| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | | | 104| 3.30M| } while (0) | | | | | | ------------------ | | | | | | | Branch (104:11): [Folded, False: 3.30M] | | | | | | ------------------ | | | | ------------------ | | | | 368| 3.30M| } while (0) | | | | ------------------ | | | | | Branch (368:11): [Folded, False: 3.30M] | | | | ------------------ | | ------------------ | | 302| 3.30M| } while (0) | | ------------------ | | | Branch (302:11): [Folded, False: 3.30M] | | ------------------ ------------------ 1377| 3.30M| return result; 1378| 370k|} evbuffer_pullup: 1382| 7.20M|{ 1383| 7.20M| struct evbuffer_chain *chain, *next, *tmp, *last_with_data; 1384| 7.20M| unsigned char *buffer, *result = NULL; 1385| 7.20M| ev_ssize_t remaining; ------------------ | | 213| 7.20M|#define ev_ssize_t EVENT__ssize_t | | ------------------ | | | | 473| 7.20M|#define EVENT__ssize_t ssize_t | | ------------------ ------------------ 1386| 7.20M| int removed_last_with_data = 0; 1387| 7.20M| int removed_last_with_datap = 0; 1388| | 1389| 7.20M| EVBUFFER_LOCK(buf); ------------------ | | 288| 7.20M| do { \ | | 289| 7.20M| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 7.20M| do { \ | | | | 95| 7.20M| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 7.20M] | | | | ------------------ | | | | 96| 7.20M| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 7.20M| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 7.20M] | | | | ------------------ | | ------------------ | | 290| 7.20M| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 7.20M] | | ------------------ ------------------ 1390| | 1391| 7.20M| chain = buf->first; 1392| | 1393| 7.20M| if (size < 0) ------------------ | Branch (1393:6): [True: 3.61M, False: 3.59M] ------------------ 1394| 3.61M| size = buf->total_len; 1395| | /* if size > buf->total_len, we cannot guarantee to the user that she 1396| | * is going to have a long enough buffer afterwards; so we return 1397| | * NULL */ 1398| 7.20M| if (size == 0 || (size_t)size > buf->total_len) ------------------ | Branch (1398:6): [True: 11.4k, False: 7.19M] | Branch (1398:19): [True: 0, False: 7.19M] ------------------ 1399| 11.4k| goto done; 1400| | 1401| | /* No need to pull up anything; the first size bytes are 1402| | * already here. */ 1403| 7.19M| if (chain->off >= (size_t)size) { ------------------ | Branch (1403:6): [True: 7.19M, False: 1.97k] ------------------ 1404| 7.19M| result = chain->buffer + chain->misalign; 1405| 7.19M| goto done; 1406| 7.19M| } 1407| | 1408| | /* Make sure that none of the chains we need to copy from is pinned. */ 1409| 1.97k| remaining = size - chain->off; 1410| 1.97k| EVUTIL_ASSERT(remaining >= 0); ------------------ | | 368| 1.97k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 1.97k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 1.97k| (void)sizeof(!(condition)); \ | | | | 98| 1.97k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 1.97k] | | | | ------------------ | | ------------------ ------------------ 1411| 3.29k| for (tmp=chain->next; tmp; tmp=tmp->next) { ------------------ | Branch (1411:24): [True: 3.29k, False: 0] ------------------ 1412| 3.29k| if (CHAIN_PINNED(tmp)) ------------------ | | 127| 3.29k|#define CHAIN_PINNED(ch) (((ch)->flags & EVBUFFER_MEM_PINNED_ANY) != 0) | | ------------------ | | | | 199| 3.29k|#define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 197| 3.29k|#define EVBUFFER_MEM_PINNED_R 0x0010 | | | | ------------------ | | | | #define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 198| 3.29k|#define EVBUFFER_MEM_PINNED_W 0x0020 | | | | ------------------ | | ------------------ | | | Branch (127:27): [True: 0, False: 3.29k] | | ------------------ ------------------ 1413| 0| goto done; 1414| 3.29k| if (tmp->off >= (size_t)remaining) ------------------ | Branch (1414:7): [True: 1.97k, False: 1.31k] ------------------ 1415| 1.97k| break; 1416| 1.31k| remaining -= tmp->off; 1417| 1.31k| } 1418| | 1419| 1.97k| if (CHAIN_PINNED(chain)) { ------------------ | | 127| 1.97k|#define CHAIN_PINNED(ch) (((ch)->flags & EVBUFFER_MEM_PINNED_ANY) != 0) | | ------------------ | | | | 199| 1.97k|#define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 197| 1.97k|#define EVBUFFER_MEM_PINNED_R 0x0010 | | | | ------------------ | | | | #define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 198| 1.97k|#define EVBUFFER_MEM_PINNED_W 0x0020 | | | | ------------------ | | ------------------ | | | Branch (127:27): [True: 0, False: 1.97k] | | ------------------ ------------------ 1420| 0| size_t old_off = chain->off; 1421| 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 (1421:7): [True: 0, False: 0] ------------------ 1422| | /* not enough room at end of chunk. */ 1423| 0| goto done; 1424| 0| } 1425| 0| buffer = CHAIN_SPACE_PTR(chain); ------------------ | | 123| 0|#define CHAIN_SPACE_PTR(ch) ((ch)->buffer + (ch)->misalign + (ch)->off) ------------------ 1426| 0| tmp = chain; 1427| 0| tmp->off = size; 1428| 0| size -= old_off; 1429| 0| chain = chain->next; 1430| 1.97k| } else if (chain->buffer_len - chain->misalign >= (size_t)size) { ------------------ | Branch (1430:13): [True: 0, False: 1.97k] ------------------ 1431| | /* already have enough space in the first chain */ 1432| 0| size_t old_off = chain->off; 1433| 0| buffer = chain->buffer + chain->misalign + chain->off; 1434| 0| tmp = chain; 1435| 0| tmp->off = size; 1436| 0| size -= old_off; 1437| 0| chain = chain->next; 1438| 1.97k| } else { 1439| 1.97k| if ((tmp = evbuffer_chain_new_membuf(size)) == NULL) { ------------------ | Branch (1439:7): [True: 0, False: 1.97k] ------------------ 1440| 0| event_warn("%s: out of memory", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 1441| 0| goto done; 1442| 0| } 1443| 1.97k| buffer = tmp->buffer; 1444| 1.97k| tmp->off = size; 1445| 1.97k| buf->first = tmp; 1446| 1.97k| } 1447| | 1448| | /* TODO(niels): deal with buffers that point to NULL like sendfile */ 1449| | 1450| | /* Copy and free every chunk that will be entirely pulled into tmp */ 1451| 1.97k| last_with_data = *buf->last_with_datap; 1452| 7.25k| for (; chain != NULL && (size_t)size >= chain->off; chain = next) { ------------------ | Branch (1452:9): [True: 5.27k, False: 1.97k] | Branch (1452:26): [True: 5.27k, False: 0] ------------------ 1453| 5.27k| next = chain->next; 1454| | 1455| 5.27k| if (chain->buffer) { ------------------ | Branch (1455:7): [True: 5.27k, False: 0] ------------------ 1456| 5.27k| memcpy(buffer, chain->buffer + chain->misalign, chain->off); 1457| 5.27k| size -= chain->off; 1458| 5.27k| buffer += chain->off; 1459| 5.27k| } 1460| 5.27k| if (chain == last_with_data) ------------------ | Branch (1460:7): [True: 1.97k, False: 3.29k] ------------------ 1461| 1.97k| removed_last_with_data = 1; 1462| 5.27k| if (&chain->next == buf->last_with_datap) ------------------ | Branch (1462:7): [True: 1.97k, False: 3.29k] ------------------ 1463| 1.97k| removed_last_with_datap = 1; 1464| | 1465| 5.27k| evbuffer_chain_free(chain); 1466| 5.27k| } 1467| | 1468| 1.97k| if (chain != NULL) { ------------------ | Branch (1468:6): [True: 0, False: 1.97k] ------------------ 1469| 0| memcpy(buffer, chain->buffer + chain->misalign, size); 1470| 0| chain->misalign += size; 1471| 0| chain->off -= size; 1472| 1.97k| } else { 1473| 1.97k| buf->last = tmp; 1474| 1.97k| } 1475| | 1476| 1.97k| tmp->next = chain; 1477| | 1478| 1.97k| if (removed_last_with_data) { ------------------ | Branch (1478:6): [True: 1.97k, False: 0] ------------------ 1479| 1.97k| buf->last_with_datap = &buf->first; 1480| 1.97k| } else if (removed_last_with_datap) { ------------------ | Branch (1480:13): [True: 0, False: 0] ------------------ 1481| 0| if (buf->first->next && buf->first->next->off) ------------------ | Branch (1481:7): [True: 0, False: 0] | Branch (1481:27): [True: 0, False: 0] ------------------ 1482| 0| buf->last_with_datap = &buf->first->next; 1483| 0| else 1484| 0| buf->last_with_datap = &buf->first; 1485| 0| } 1486| | 1487| 1.97k| result = (tmp->buffer + tmp->misalign); 1488| | 1489| 7.20M|done: 1490| 7.20M| EVBUFFER_UNLOCK(buf); ------------------ | | 292| 7.20M| do { \ | | 293| 7.20M| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 7.20M| do { \ | | | | 102| 7.20M| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 7.20M] | | | | ------------------ | | | | 103| 7.20M| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 7.20M| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 7.20M] | | | | ------------------ | | ------------------ | | 294| 7.20M| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 7.20M] | | ------------------ ------------------ 1491| 7.20M| return result; 1492| 1.97k|} evbuffer_add: 1762| 392k|{ 1763| 392k| struct evbuffer_chain *chain, *tmp; 1764| 392k| const unsigned char *data = data_in; 1765| 392k| size_t remain, to_alloc; 1766| 392k| int result = -1; 1767| | 1768| 392k| EVBUFFER_LOCK(buf); ------------------ | | 288| 392k| do { \ | | 289| 392k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 392k| do { \ | | | | 95| 392k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 392k] | | | | ------------------ | | | | 96| 392k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 392k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 392k] | | | | ------------------ | | ------------------ | | 290| 392k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 392k] | | ------------------ ------------------ 1769| | 1770| 392k| if (buf->freeze_end) { ------------------ | Branch (1770:6): [True: 0, False: 392k] ------------------ 1771| 0| goto done; 1772| 0| } 1773| | /* Prevent buf->total_len overflow */ 1774| 392k| if (datlen > EV_SIZE_MAX - buf->total_len) { ------------------ | | 289| 392k|#define EV_SIZE_MAX EV_UINT64_MAX | | ------------------ | | | | 267| 392k|#define EV_UINT64_MAX UINT64_MAX | | ------------------ ------------------ | Branch (1774:6): [True: 0, False: 392k] ------------------ 1775| 0| goto done; 1776| 0| } 1777| | 1778| 392k| if (*buf->last_with_datap == NULL) { ------------------ | Branch (1778:6): [True: 20.6k, False: 371k] ------------------ 1779| 20.6k| chain = buf->last; 1780| 371k| } else { 1781| 371k| chain = *buf->last_with_datap; 1782| 371k| } 1783| | 1784| | /* If there are no chains allocated for this buffer, allocate one 1785| | * big enough to hold all the data. */ 1786| 392k| if (chain == NULL) { ------------------ | Branch (1786:6): [True: 20.6k, False: 371k] ------------------ 1787| 20.6k| chain = evbuffer_chain_insert_new(buf, datlen); 1788| 20.6k| if (!chain) ------------------ | Branch (1788:7): [True: 0, False: 20.6k] ------------------ 1789| 0| goto done; 1790| 20.6k| } 1791| | 1792| 392k| if ((chain->flags & EVBUFFER_IMMUTABLE) == 0) { ------------------ | | 194| 392k|#define EVBUFFER_IMMUTABLE 0x0008 /**< read-only chain */ ------------------ | Branch (1792:6): [True: 392k, False: 0] ------------------ 1793| | /* Always true for mutable buffers */ 1794| 392k| EVUTIL_ASSERT(chain->misalign >= 0 && ------------------ | | 368| 392k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 392k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 392k| (void)sizeof(!(condition)); \ | | | | ------------------ | | | | | Branch (97:17): [True: 0, False: 392k] | | | | | Branch (97:17): [True: 0, False: 0] | | | | ------------------ | | | | 98| 392k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 392k] | | | | ------------------ | | ------------------ ------------------ 1795| 392k| (ev_uint64_t)chain->misalign <= EVBUFFER_CHAIN_MAX); 1796| 392k| remain = chain->buffer_len - (size_t)chain->misalign - chain->off; 1797| 392k| if (remain >= datlen) { ------------------ | Branch (1797:7): [True: 387k, False: 5.07k] ------------------ 1798| | /* there's enough space to hold all the data in the 1799| | * current last chain */ 1800| 387k| memcpy(chain->buffer + chain->misalign + chain->off, 1801| 387k| data, datlen); 1802| 387k| chain->off += datlen; 1803| 387k| buf->total_len += datlen; 1804| 387k| buf->n_add_for_cb += datlen; 1805| 387k| goto out; 1806| 387k| } else if (!CHAIN_PINNED(chain) && ------------------ | | 127| 10.1k|#define CHAIN_PINNED(ch) (((ch)->flags & EVBUFFER_MEM_PINNED_ANY) != 0) | | ------------------ | | | | 199| 5.07k|#define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 197| 5.07k|#define EVBUFFER_MEM_PINNED_R 0x0010 | | | | ------------------ | | | | #define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 198| 5.07k|#define EVBUFFER_MEM_PINNED_W 0x0020 | | | | ------------------ | | ------------------ ------------------ | Branch (1806:14): [True: 5.07k, False: 0] ------------------ 1807| 5.07k| evbuffer_chain_should_realign(chain, datlen)) { ------------------ | Branch (1807:7): [True: 0, False: 5.07k] ------------------ 1808| | /* we can fit the data into the misalignment */ 1809| 0| evbuffer_chain_align(chain); 1810| | 1811| 0| memcpy(chain->buffer + chain->off, data, datlen); 1812| 0| chain->off += datlen; 1813| 0| buf->total_len += datlen; 1814| 0| buf->n_add_for_cb += datlen; 1815| 0| goto out; 1816| 0| } 1817| 392k| } else { 1818| | /* we cannot write any data to the last chain */ 1819| 0| remain = 0; 1820| 0| } 1821| | 1822| | /* we need to add another chain */ 1823| 5.07k| to_alloc = chain->buffer_len; 1824| 5.07k| if (to_alloc <= EVBUFFER_CHAIN_MAX_AUTO_SIZE/2) ------------------ | | 1756| 5.07k|#define EVBUFFER_CHAIN_MAX_AUTO_SIZE 4096 ------------------ | Branch (1824:6): [True: 2.68k, False: 2.38k] ------------------ 1825| 2.68k| to_alloc <<= 1; 1826| 5.07k| if (datlen > to_alloc) ------------------ | Branch (1826:6): [True: 489, False: 4.58k] ------------------ 1827| 489| to_alloc = datlen; 1828| 5.07k| tmp = evbuffer_chain_new_membuf(to_alloc); 1829| 5.07k| if (tmp == NULL) ------------------ | Branch (1829:6): [True: 0, False: 5.07k] ------------------ 1830| 0| goto done; 1831| | 1832| 5.07k| if (remain) { ------------------ | Branch (1832:6): [True: 4.63k, False: 442] ------------------ 1833| 4.63k| memcpy(chain->buffer + chain->misalign + chain->off, 1834| 4.63k| data, remain); 1835| 4.63k| chain->off += remain; 1836| 4.63k| buf->total_len += remain; 1837| 4.63k| buf->n_add_for_cb += remain; 1838| 4.63k| } 1839| | 1840| 5.07k| data += remain; 1841| 5.07k| datlen -= remain; 1842| | 1843| 5.07k| memcpy(tmp->buffer, data, datlen); 1844| 5.07k| tmp->off = datlen; 1845| 5.07k| evbuffer_chain_insert(buf, tmp); 1846| 5.07k| buf->n_add_for_cb += datlen; 1847| | 1848| 392k|out: 1849| 392k| evbuffer_invoke_callbacks_(buf); 1850| 392k| result = 0; 1851| 392k|done: 1852| 392k| EVBUFFER_UNLOCK(buf); ------------------ | | 292| 392k| do { \ | | 293| 392k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 392k| do { \ | | | | 102| 392k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 392k] | | | | ------------------ | | | | 103| 392k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 392k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 392k] | | | | ------------------ | | ------------------ | | 294| 392k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 392k] | | ------------------ ------------------ 1853| 392k| return result; 1854| 392k|} evbuffer_add_vprintf: 2878| 4.06k|{ 2879| 4.06k| char *buffer; 2880| 4.06k| size_t space; 2881| 4.06k| int sz, result = -1; 2882| 4.06k| va_list aq; 2883| 4.06k| struct evbuffer_chain *chain; 2884| | 2885| | 2886| 4.06k| EVBUFFER_LOCK(buf); ------------------ | | 288| 4.06k| do { \ | | 289| 4.06k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 4.06k| do { \ | | | | 95| 4.06k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 4.06k] | | | | ------------------ | | | | 96| 4.06k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 4.06k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 4.06k] | | | | ------------------ | | ------------------ | | 290| 4.06k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 4.06k] | | ------------------ ------------------ 2887| | 2888| 4.06k| if (buf->freeze_end) { ------------------ | Branch (2888:6): [True: 0, False: 4.06k] ------------------ 2889| 0| goto done; 2890| 0| } 2891| | 2892| | /* make sure that at least some space is available */ 2893| 4.06k| if ((chain = evbuffer_expand_singlechain(buf, 64)) == NULL) ------------------ | Branch (2893:6): [True: 0, False: 4.06k] ------------------ 2894| 0| goto done; 2895| | 2896| 4.06k| for (;;) { 2897| |#if 0 2898| | size_t used = chain->misalign + chain->off; 2899| | buffer = (char *)chain->buffer + chain->misalign + chain->off; 2900| | EVUTIL_ASSERT(chain->buffer_len >= used); 2901| | space = chain->buffer_len - used; 2902| |#endif 2903| 4.06k| buffer = (char*) CHAIN_SPACE_PTR(chain); ------------------ | | 123| 4.06k|#define CHAIN_SPACE_PTR(ch) ((ch)->buffer + (ch)->misalign + (ch)->off) ------------------ 2904| 4.06k| space = (size_t) CHAIN_SPACE_LEN(chain); ------------------ | | 124| 4.06k|#define CHAIN_SPACE_LEN(ch) ((ch)->flags & EVBUFFER_IMMUTABLE ? \ | | ------------------ | | | | 194| 4.06k|#define EVBUFFER_IMMUTABLE 0x0008 /**< read-only chain */ | | ------------------ | | | Branch (124:30): [True: 0, False: 4.06k] | | ------------------ | | 125| 4.06k| 0 : (ch)->buffer_len - ((ch)->misalign + (ch)->off)) ------------------ 2905| | 2906| |#ifndef va_copy 2907| |#define va_copy(dst, src) memcpy(&(dst), &(src), sizeof(va_list)) 2908| |#endif 2909| 4.06k| va_copy(aq, ap); 2910| | 2911| 4.06k| sz = evutil_vsnprintf(buffer, space, fmt, aq); 2912| | 2913| 4.06k| va_end(aq); 2914| | 2915| 4.06k| if (sz < 0) ------------------ | Branch (2915:7): [True: 0, False: 4.06k] ------------------ 2916| 0| goto done; 2917| 4.06k| if (INT_MAX >= EVBUFFER_CHAIN_MAX && ------------------ | | 168| 8.13k|#define EVBUFFER_CHAIN_MAX ((size_t)EV_SSIZE_MAX) | | ------------------ | | | | 290| 4.06k|#define EV_SSIZE_MAX EV_INT64_MAX | | | | ------------------ | | | | | | 268| 4.06k|#define EV_INT64_MAX INT64_MAX | | | | ------------------ | | ------------------ ------------------ | Branch (2917:7): [Folded, False: 4.06k] ------------------ 2918| 0| (size_t)sz >= EVBUFFER_CHAIN_MAX) ------------------ | | 168| 4.06k|#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 (2918:7): [True: 0, False: 0] ------------------ 2919| 0| goto done; 2920| 4.06k| if ((size_t)sz < space) { ------------------ | Branch (2920:7): [True: 4.06k, False: 0] ------------------ 2921| 4.06k| chain->off += sz; 2922| 4.06k| buf->total_len += sz; 2923| 4.06k| buf->n_add_for_cb += sz; 2924| | 2925| 4.06k| advance_last_with_data(buf); 2926| 4.06k| evbuffer_invoke_callbacks_(buf); 2927| 4.06k| result = sz; 2928| 4.06k| goto done; 2929| 4.06k| } 2930| 0| if ((chain = evbuffer_expand_singlechain(buf, sz + 1)) == NULL) ------------------ | Branch (2930:7): [True: 0, False: 0] ------------------ 2931| 0| goto done; 2932| 0| } 2933| | /* NOTREACHED */ 2934| | 2935| 4.06k|done: 2936| 4.06k| EVBUFFER_UNLOCK(buf); ------------------ | | 292| 4.06k| do { \ | | 293| 4.06k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 4.06k| do { \ | | | | 102| 4.06k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 4.06k] | | | | ------------------ | | | | 103| 4.06k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 4.06k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 4.06k] | | | | ------------------ | | ------------------ | | 294| 4.06k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 4.06k] | | ------------------ ------------------ 2937| 4.06k| return result; 2938| 4.06k|} evbuffer_add_printf: 2942| 4.06k|{ 2943| 4.06k| int res = -1; 2944| 4.06k| va_list ap; 2945| | 2946| 4.06k| va_start(ap, fmt); 2947| 4.06k| res = evbuffer_add_vprintf(buf, fmt, ap); 2948| 4.06k| va_end(ap); 2949| | 2950| 4.06k| return (res); 2951| 4.06k|} evbuffer_add_cb: 3392| 2.03k|{ 3393| 2.03k| struct evbuffer_cb_entry *e; 3394| 2.03k| if (! (e = mm_calloc(1, sizeof(struct evbuffer_cb_entry)))) ------------------ | | 77| 2.03k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ | Branch (3394:6): [True: 0, False: 2.03k] ------------------ 3395| 0| return NULL; 3396| 2.03k| EVBUFFER_LOCK(buffer); ------------------ | | 288| 2.03k| do { \ | | 289| 2.03k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 2.03k| do { \ | | | | 95| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 96| 2.03k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 290| 2.03k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 2.03k] | | ------------------ ------------------ 3397| 2.03k| e->cb.cb_func = cb; 3398| 2.03k| e->cbarg = cbarg; 3399| 2.03k| e->flags = EVBUFFER_CB_ENABLED; ------------------ | | 982| 2.03k|#define EVBUFFER_CB_ENABLED 1 ------------------ 3400| 2.03k| LIST_INSERT_HEAD(&buffer->callbacks, e, next); ------------------ | | 189| 2.03k|#define LIST_INSERT_HEAD(head, elm, field) do { \ | | 190| 2.03k| if (((elm)->field.le_next = (head)->lh_first) != NULL) \ | | ------------------ | | | Branch (190:6): [True: 0, False: 2.03k] | | ------------------ | | 191| 2.03k| (head)->lh_first->field.le_prev = &(elm)->field.le_next;\ | | 192| 2.03k| (head)->lh_first = (elm); \ | | 193| 2.03k| (elm)->field.le_prev = &(head)->lh_first; \ | | 194| 2.03k|} while (0) | | ------------------ | | | Branch (194:10): [Folded, False: 2.03k] | | ------------------ ------------------ 3401| 2.03k| EVBUFFER_UNLOCK(buffer); ------------------ | | 292| 2.03k| do { \ | | 293| 2.03k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 2.03k| do { \ | | | | 102| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 103| 2.03k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 294| 2.03k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 2.03k] | | ------------------ ------------------ 3402| 2.03k| return e; 3403| 2.03k|} evbuffer_freeze: 3459| 6.10k|{ 3460| 6.10k| EVBUFFER_LOCK(buffer); ------------------ | | 288| 6.10k| do { \ | | 289| 6.10k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 6.10k| do { \ | | | | 95| 6.10k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 6.10k] | | | | ------------------ | | | | 96| 6.10k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 6.10k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 6.10k] | | | | ------------------ | | ------------------ | | 290| 6.10k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 6.10k] | | ------------------ ------------------ 3461| 6.10k| if (start) ------------------ | Branch (3461:6): [True: 3.05k, False: 3.05k] ------------------ 3462| 3.05k| buffer->freeze_start = 1; 3463| 3.05k| else 3464| 3.05k| buffer->freeze_end = 1; 3465| 6.10k| EVBUFFER_UNLOCK(buffer); ------------------ | | 292| 6.10k| do { \ | | 293| 6.10k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 6.10k| do { \ | | | | 102| 6.10k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 6.10k] | | | | ------------------ | | | | 103| 6.10k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 6.10k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 6.10k] | | | | ------------------ | | ------------------ | | 294| 6.10k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 6.10k] | | ------------------ ------------------ 3466| 6.10k| return 0; 3467| 6.10k|} evbuffer_unfreeze: 3471| 2.03k|{ 3472| 2.03k| EVBUFFER_LOCK(buffer); ------------------ | | 288| 2.03k| do { \ | | 289| 2.03k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 2.03k| do { \ | | | | 95| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 96| 2.03k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 290| 2.03k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 2.03k] | | ------------------ ------------------ 3473| 2.03k| if (start) ------------------ | Branch (3473:6): [True: 1.01k, False: 1.01k] ------------------ 3474| 1.01k| buffer->freeze_start = 0; 3475| 1.01k| else 3476| 1.01k| buffer->freeze_end = 0; 3477| 2.03k| EVBUFFER_UNLOCK(buffer); ------------------ | | 292| 2.03k| do { \ | | 293| 2.03k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 2.03k| do { \ | | | | 102| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 103| 2.03k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 294| 2.03k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 2.03k] | | ------------------ ------------------ 3478| 2.03k| return 0; 3479| 2.03k|} evbuffer_get_callbacks_: 3510| 4.06k|{ 3511| 4.06k| int r = 0; 3512| 4.06k| EVBUFFER_LOCK(buffer); ------------------ | | 288| 4.06k| do { \ | | 289| 4.06k| EVLOCK_LOCK((buffer)->lock, 0); \ | | ------------------ | | | | 94| 4.06k| do { \ | | | | 95| 4.06k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 4.06k] | | | | ------------------ | | | | 96| 4.06k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 4.06k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 4.06k] | | | | ------------------ | | ------------------ | | 290| 4.06k| } while (0) | | ------------------ | | | Branch (290:11): [Folded, False: 4.06k] | | ------------------ ------------------ 3513| 4.06k| if (buffer->deferred_cbs) { ------------------ | Branch (3513:6): [True: 0, False: 4.06k] ------------------ 3514| 0| if (max_cbs < 1) { ------------------ | Branch (3514:7): [True: 0, False: 0] ------------------ 3515| 0| r = -1; 3516| 0| goto done; 3517| 0| } 3518| 0| cbs[0] = &buffer->deferred; 3519| 0| r = 1; 3520| 0| } 3521| 4.06k|done: 3522| 4.06k| EVBUFFER_UNLOCK(buffer); ------------------ | | 292| 4.06k| do { \ | | 293| 4.06k| EVLOCK_UNLOCK((buffer)->lock, 0); \ | | ------------------ | | | | 101| 4.06k| do { \ | | | | 102| 4.06k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 4.06k] | | | | ------------------ | | | | 103| 4.06k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 4.06k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 4.06k] | | | | ------------------ | | ------------------ | | 294| 4.06k| } while (0) | | ------------------ | | | Branch (294:11): [Folded, False: 4.06k] | | ------------------ ------------------ 3523| 4.06k| return r; 3524| 4.06k|} buffer.c:evbuffer_chain_free: 206| 28.7k|{ 207| 28.7k| EVUTIL_ASSERT(chain->refcnt > 0); ------------------ | | 368| 28.7k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 28.7k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 28.7k| (void)sizeof(!(condition)); \ | | | | 98| 28.7k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 28.7k] | | | | ------------------ | | ------------------ ------------------ 208| 28.7k| if (--chain->refcnt > 0) { ------------------ | Branch (208:6): [True: 0, False: 28.7k] ------------------ 209| | /* chain is still referenced by other chains */ 210| 0| return; 211| 0| } 212| | 213| 28.7k| if (CHAIN_PINNED(chain)) { ------------------ | | 127| 28.7k|#define CHAIN_PINNED(ch) (((ch)->flags & EVBUFFER_MEM_PINNED_ANY) != 0) | | ------------------ | | | | 199| 28.7k|#define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 197| 28.7k|#define EVBUFFER_MEM_PINNED_R 0x0010 | | | | ------------------ | | | | #define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | | | ------------------ | | | | | | 198| 28.7k|#define EVBUFFER_MEM_PINNED_W 0x0020 | | | | ------------------ | | ------------------ | | | Branch (127:27): [True: 0, False: 28.7k] | | ------------------ ------------------ 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| 28.7k| if (chain->flags & EVBUFFER_REFERENCE) { ------------------ | | 193| 28.7k|#define EVBUFFER_REFERENCE 0x0004 /**< a chain with a mem reference */ ------------------ | Branch (222:6): [True: 0, False: 28.7k] ------------------ 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| 28.7k| if (chain->flags & EVBUFFER_FILESEGMENT) { ------------------ | | 191| 28.7k|#define EVBUFFER_FILESEGMENT 0x0001 /**< A chain used for a file segment */ ------------------ | Branch (232:6): [True: 0, False: 28.7k] ------------------ 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| 28.7k| if (chain->flags & EVBUFFER_MULTICAST) { ------------------ | | 204| 28.7k|#define EVBUFFER_MULTICAST 0x0080 ------------------ | Branch (245:6): [True: 0, False: 28.7k] ------------------ 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| 28.7k| mm_free(chain); ------------------ | | 80| 28.7k|#define mm_free(p) event_mm_free_(p) ------------------ 262| 28.7k|} buffer.c:evbuffer_run_callbacks: 467| 7.70k|{ 468| 7.70k| struct evbuffer_cb_entry *cbent, *next; 469| 7.70k| struct evbuffer_cb_info info; 470| 7.70k| size_t new_size; 471| 7.70k| ev_uint32_t mask, masked_val; ------------------ | | 148| 7.70k|#define ev_uint32_t uint32_t ------------------ 472| 7.70k| int clear = 1; 473| | 474| 7.70k| if (running_deferred) { ------------------ | Branch (474:6): [True: 0, False: 7.70k] ------------------ 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.70k| } else if (buffer->deferred_cbs) { ------------------ | Branch (477:13): [True: 0, False: 7.70k] ------------------ 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.70k| } else { 484| 7.70k| mask = EVBUFFER_CB_ENABLED; ------------------ | | 982| 7.70k|#define EVBUFFER_CB_ENABLED 1 ------------------ 485| 7.70k| masked_val = EVBUFFER_CB_ENABLED; ------------------ | | 982| 7.70k|#define EVBUFFER_CB_ENABLED 1 ------------------ 486| 7.70k| } 487| | 488| 7.70k| ASSERT_EVBUFFER_LOCKED(buffer); ------------------ | | 285| 7.70k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 7.70k| do { \ | | | | 131| 7.70k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 7.70k] | | | | | 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.70k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 489| | 490| 7.70k| if (LIST_EMPTY(&buffer->callbacks)) { ------------------ | | 159| 7.70k|#define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head)) | | ------------------ | | | | 157| 7.70k|#define LIST_FIRST(head) ((head)->lh_first) | | ------------------ | | #define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head)) | | ------------------ | | | | 158| 7.70k|#define LIST_END(head) NULL | | ------------------ | | | Branch (159:27): [True: 0, False: 7.70k] | | ------------------ ------------------ 491| 0| buffer->n_add_for_cb = buffer->n_del_for_cb = 0; 492| 0| return; 493| 0| } 494| 7.70k| if (buffer->n_add_for_cb == 0 && buffer->n_del_for_cb == 0) ------------------ | Branch (494:6): [True: 1.01k, False: 6.68k] | Branch (494:35): [True: 0, False: 1.01k] ------------------ 495| 0| return; 496| | 497| 7.70k| new_size = buffer->total_len; 498| 7.70k| info.orig_size = new_size + buffer->n_del_for_cb - buffer->n_add_for_cb; 499| 7.70k| info.n_added = buffer->n_add_for_cb; 500| 7.70k| info.n_deleted = buffer->n_del_for_cb; 501| 7.70k| if (clear) { ------------------ | Branch (501:6): [True: 7.70k, False: 0] ------------------ 502| 7.70k| buffer->n_add_for_cb = 0; 503| 7.70k| buffer->n_del_for_cb = 0; 504| 7.70k| } 505| 7.70k| for (cbent = LIST_FIRST(&buffer->callbacks); ------------------ | | 157| 7.70k|#define LIST_FIRST(head) ((head)->lh_first) ------------------ 506| 15.4k| cbent != LIST_END(&buffer->callbacks); ------------------ | | 158| 15.4k|#define LIST_END(head) NULL ------------------ | Branch (506:7): [True: 7.70k, False: 7.70k] ------------------ 507| 7.70k| cbent = next) { 508| | /* Get the 'next' pointer now in case this callback decides 509| | * to remove itself or something. */ 510| 7.70k| next = LIST_NEXT(cbent, next); ------------------ | | 160| 7.70k|#define LIST_NEXT(elm, field) ((elm)->field.le_next) ------------------ 511| | 512| 7.70k| if ((cbent->flags & mask) != masked_val) ------------------ | Branch (512:7): [True: 0, False: 7.70k] ------------------ 513| 0| continue; 514| | 515| 7.70k| if ((cbent->flags & EVBUFFER_CB_OBSOLETE)) ------------------ | | 120| 7.70k|#define EVBUFFER_CB_OBSOLETE 0x00040000 ------------------ | Branch (515:7): [True: 0, False: 7.70k] ------------------ 516| 0| cbent->cb.cb_obsolete(buffer, 517| 0| info.orig_size, new_size, cbent->cbarg); 518| 7.70k| else 519| 7.70k| cbent->cb.cb_func(buffer, &info, cbent->cbarg); 520| 7.70k| } 521| 7.70k|} buffer.c:evbuffer_remove_all_callbacks: 561| 25.9k|{ 562| 25.9k| struct evbuffer_cb_entry *cbent; 563| | 564| 27.9k| while ((cbent = LIST_FIRST(&buffer->callbacks))) { ------------------ | | 157| 27.9k|#define LIST_FIRST(head) ((head)->lh_first) ------------------ | Branch (564:9): [True: 2.03k, False: 25.9k] ------------------ 565| 2.03k| LIST_REMOVE(cbent, next); ------------------ | | 196| 2.03k|#define LIST_REMOVE(elm, field) do { \ | | 197| 2.03k| if ((elm)->field.le_next != NULL) \ | | ------------------ | | | Branch (197:6): [True: 0, False: 2.03k] | | ------------------ | | 198| 2.03k| (elm)->field.le_next->field.le_prev = \ | | 199| 0| (elm)->field.le_prev; \ | | 200| 2.03k| *(elm)->field.le_prev = (elm)->field.le_next; \ | | 201| 2.03k|} while (0) | | ------------------ | | | Branch (201:10): [Folded, False: 2.03k] | | ------------------ ------------------ 566| 2.03k| mm_free(cbent); ------------------ | | 80| 2.03k|#define mm_free(p) event_mm_free_(p) ------------------ 567| 2.03k| } 568| 25.9k|} buffer.c:advance_last_with_data: 731| 4.06k|{ 732| 4.06k| int n = 0; 733| 4.06k| struct evbuffer_chain **chainp = buf->last_with_datap; 734| | 735| 4.06k| ASSERT_EVBUFFER_LOCKED(buf); ------------------ | | 285| 4.06k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 4.06k| do { \ | | | | 131| 4.06k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 4.06k] | | | | | 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| 4.06k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 4.06k] | | | | ------------------ | | ------------------ ------------------ 736| | 737| 4.06k| if (!*chainp) ------------------ | Branch (737:6): [True: 0, False: 4.06k] ------------------ 738| 0| return 0; 739| | 740| 4.06k| while ((*chainp)->next) { ------------------ | Branch (740:9): [True: 0, False: 4.06k] ------------------ 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| 4.06k| return n; 747| 4.06k|} buffer.c:PRESERVE_PINNED: 842| 1.10k|{ 843| 1.10k| struct evbuffer_chain *chain, **pinned; 844| | 845| 1.10k| ASSERT_EVBUFFER_LOCKED(src); ------------------ | | 285| 1.10k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 1.10k| do { \ | | | | 131| 1.10k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 1.10k] | | | | | 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.10k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 1.10k] | | | | ------------------ | | ------------------ ------------------ 846| | 847| 1.10k| if (!HAS_PINNED_R(src)) { ------------------ | Branch (847:6): [True: 1.10k, False: 0] ------------------ 848| 1.10k| *first = *last = NULL; 849| 1.10k| return 0; 850| 1.10k| } 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| 1.05k|{ 267| 1.05k| struct evbuffer_chain *next; 268| 1.05k| for (; chain; chain = next) { ------------------ | Branch (268:9): [True: 0, False: 1.05k] ------------------ 269| 0| next = chain->next; 270| 0| evbuffer_chain_free(chain); 271| 0| } 272| 1.05k|} buffer.c:COPY_CHAIN: 902| 1.05k|{ 903| 1.05k| ASSERT_EVBUFFER_LOCKED(dst); ------------------ | | 285| 1.05k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 1.05k| do { \ | | | | 131| 1.05k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 1.05k] | | | | | 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.05k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 1.05k] | | | | ------------------ | | ------------------ ------------------ 904| 1.05k| ASSERT_EVBUFFER_LOCKED(src); ------------------ | | 285| 1.05k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 1.05k| do { \ | | | | 131| 1.05k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 1.05k] | | | | | 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.05k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 1.05k] | | | | ------------------ | | ------------------ ------------------ 905| 1.05k| dst->first = src->first; 906| 1.05k| if (src->last_with_datap == &src->first) ------------------ | Branch (906:6): [True: 1.05k, False: 0] ------------------ 907| 1.05k| dst->last_with_datap = &dst->first; 908| 0| else 909| 0| dst->last_with_datap = src->last_with_datap; 910| 1.05k| dst->last = src->last; 911| 1.05k| dst->total_len = src->total_len; 912| 1.05k|} buffer.c:APPEND_CHAIN: 916| 48|{ 917| 48| struct evbuffer_chain **chp; 918| | 919| 48| ASSERT_EVBUFFER_LOCKED(dst); ------------------ | | 285| 48| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 48| do { \ | | | | 131| 48| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 48] | | | | | 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| 48| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 48] | | | | ------------------ | | ------------------ ------------------ 920| 48| ASSERT_EVBUFFER_LOCKED(src); ------------------ | | 285| 48| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 48| do { \ | | | | 131| 48| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 48] | | | | | 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| 48| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 48] | | | | ------------------ | | ------------------ ------------------ 921| | 922| 48| chp = evbuffer_free_trailing_empty_chains(dst); 923| 48| *chp = src->first; 924| | 925| 48| if (src->last_with_datap == &src->first) ------------------ | Branch (925:6): [True: 48, False: 0] ------------------ 926| 48| dst->last_with_datap = chp; 927| 0| else 928| 0| dst->last_with_datap = src->last_with_datap; 929| 48| dst->last = src->last; 930| 48| dst->total_len += src->total_len; 931| 48|} buffer.c:RESTORE_PINNED: 886| 1.10k|{ 887| 1.10k| ASSERT_EVBUFFER_LOCKED(src); ------------------ | | 285| 1.10k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 1.10k| do { \ | | | | 131| 1.10k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 1.10k] | | | | | 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.10k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 1.10k] | | | | ------------------ | | ------------------ ------------------ 888| | 889| 1.10k| if (!pinned) { ------------------ | Branch (889:6): [True: 1.10k, False: 0] ------------------ 890| 1.10k| ZERO_CHAIN(src); 891| 1.10k| return; 892| 1.10k| } 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.51k|{ 822| 1.51k| return (buf->last && CHAIN_PINNED_R(buf->last)); ------------------ | | 128| 1.51k|#define CHAIN_PINNED_R(ch) (((ch)->flags & EVBUFFER_MEM_PINNED_R) != 0) | | ------------------ | | | | 197| 1.51k|#define EVBUFFER_MEM_PINNED_R 0x0010 | | ------------------ | | | Branch (128:29): [True: 0, False: 1.51k] | | ------------------ ------------------ | Branch (822:10): [True: 1.51k, False: 0] ------------------ 823| 1.51k|} buffer.c:ZERO_CHAIN: 827| 1.51k|{ 828| 1.51k| ASSERT_EVBUFFER_LOCKED(dst); ------------------ | | 285| 1.51k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 1.51k| do { \ | | | | 131| 1.51k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 1.51k] | | | | | 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.51k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 1.51k] | | | | ------------------ | | ------------------ ------------------ 829| 1.51k| dst->first = NULL; 830| | dst->last = NULL; 831| 1.51k| dst->last_with_datap = &(dst)->first; 832| 1.51k| dst->total_len = 0; 833| 1.51k|} buffer.c:evbuffer_free_trailing_empty_chains: 301| 5.12k|{ 302| 5.12k| struct evbuffer_chain **ch = buf->last_with_datap; 303| | /* Find the first victim chain. It might be *last_with_datap */ 304| 10.2k| 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: 5.12k, False: 5.12k] | Branch (304:19): [True: 5.12k, False: 0] ------------------ 305| 5.12k| ch = &(*ch)->next; 306| 5.12k| if (*ch) { ------------------ | Branch (306:6): [True: 0, False: 5.12k] ------------------ 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| 5.12k| return ch; 312| 5.12k|} buffer.c:evbuffer_chain_new_membuf: 183| 28.7k|{ 184| 28.7k| size_t to_alloc; 185| | 186| 28.7k| if (size > EVBUFFER_CHAIN_MAX - EVBUFFER_CHAIN_SIZE) ------------------ | | 168| 28.7k|#define EVBUFFER_CHAIN_MAX ((size_t)EV_SSIZE_MAX) | | ------------------ | | | | 290| 28.7k|#define EV_SSIZE_MAX EV_INT64_MAX | | | | ------------------ | | | | | | 268| 28.7k|#define EV_INT64_MAX INT64_MAX | | | | ------------------ | | ------------------ ------------------ if (size > EVBUFFER_CHAIN_MAX - EVBUFFER_CHAIN_SIZE) ------------------ | | 279| 28.7k|#define EVBUFFER_CHAIN_SIZE sizeof(struct evbuffer_chain) ------------------ | Branch (186:6): [True: 0, False: 28.7k] ------------------ 187| 0| return (NULL); 188| | 189| 28.7k| size += EVBUFFER_CHAIN_SIZE; ------------------ | | 279| 28.7k|#define EVBUFFER_CHAIN_SIZE sizeof(struct evbuffer_chain) ------------------ 190| | 191| | /* get the next largest memory that can hold the buffer */ 192| 28.7k| if (size < EVBUFFER_CHAIN_MAX / 2) { ------------------ | | 168| 28.7k|#define EVBUFFER_CHAIN_MAX ((size_t)EV_SSIZE_MAX) | | ------------------ | | | | 290| 28.7k|#define EV_SSIZE_MAX EV_INT64_MAX | | | | ------------------ | | | | | | 268| 28.7k|#define EV_INT64_MAX INT64_MAX | | | | ------------------ | | ------------------ ------------------ | Branch (192:6): [True: 28.7k, False: 0] ------------------ 193| 28.7k| to_alloc = MIN_BUFFER_SIZE; ------------------ | | 57| 28.7k|#define MIN_BUFFER_SIZE 1024 ------------------ 194| 43.9k| while (to_alloc < size) { ------------------ | Branch (194:10): [True: 15.2k, False: 28.7k] ------------------ 195| 15.2k| to_alloc <<= 1; 196| 15.2k| } 197| 28.7k| } else { 198| 0| to_alloc = size; 199| 0| } 200| | 201| 28.7k| return evbuffer_chain_new(to_alloc - EVBUFFER_CHAIN_SIZE); ------------------ | | 279| 28.7k|#define EVBUFFER_CHAIN_SIZE sizeof(struct evbuffer_chain) ------------------ 202| 28.7k|} buffer.c:evbuffer_chain_insert_new: 340| 21.7k|{ 341| 21.7k| struct evbuffer_chain *chain; 342| 21.7k| if ((chain = evbuffer_chain_new_membuf(datlen)) == NULL) ------------------ | Branch (342:6): [True: 0, False: 21.7k] ------------------ 343| 0| return NULL; 344| 21.7k| evbuffer_chain_insert(buf, chain); 345| 21.7k| return chain; 346| 21.7k|} buffer.c:evbuffer_chain_insert: 320| 26.7k|{ 321| 26.7k| ASSERT_EVBUFFER_LOCKED(buf); ------------------ | | 285| 26.7k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 26.7k| do { \ | | | | 131| 26.7k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 26.7k] | | | | | 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| 26.7k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 26.7k] | | | | ------------------ | | ------------------ ------------------ 322| 26.7k| if (*buf->last_with_datap == NULL) { ------------------ | Branch (322:6): [True: 21.7k, False: 5.07k] ------------------ 323| | /* There are no chains data on the buffer at all. */ 324| 21.7k| EVUTIL_ASSERT(buf->last_with_datap == &buf->first); ------------------ | | 368| 21.7k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 21.7k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 21.7k| (void)sizeof(!(condition)); \ | | | | 98| 21.7k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 21.7k] | | | | ------------------ | | ------------------ ------------------ 325| 21.7k| EVUTIL_ASSERT(buf->first == NULL); ------------------ | | 368| 21.7k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 21.7k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 21.7k| (void)sizeof(!(condition)); \ | | | | 98| 21.7k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 21.7k] | | | | ------------------ | | ------------------ ------------------ 326| 21.7k| buf->first = buf->last = chain; 327| 21.7k| } else { 328| 5.07k| struct evbuffer_chain **chp; 329| 5.07k| chp = evbuffer_free_trailing_empty_chains(buf); 330| 5.07k| *chp = chain; 331| 5.07k| if (chain->off) ------------------ | Branch (331:7): [True: 5.07k, False: 0] ------------------ 332| 5.07k| buf->last_with_datap = chp; 333| 5.07k| buf->last = chain; 334| 5.07k| } 335| 26.7k| buf->total_len += chain->off; 336| 26.7k|} buffer.c:evbuffer_chain_should_realign: 1959| 5.07k|{ 1960| 5.07k| return chain->buffer_len - chain->off >= datlen && ------------------ | Branch (1960:9): [True: 0, False: 5.07k] ------------------ 1961| 0| (chain->off < chain->buffer_len / 2) && ------------------ | Branch (1961:6): [True: 0, False: 0] ------------------ 1962| 0| (chain->off <= MAX_TO_REALIGN_IN_EXPAND); ------------------ | | 1952| 0|#define MAX_TO_REALIGN_IN_EXPAND 2048 ------------------ | Branch (1962:6): [True: 0, False: 0] ------------------ 1963| 5.07k|} buffer.c:evbuffer_expand_singlechain: 1969| 4.06k|{ 1970| 4.06k| struct evbuffer_chain *chain, **chainp; 1971| 4.06k| struct evbuffer_chain *result = NULL; 1972| 4.06k| ASSERT_EVBUFFER_LOCKED(buf); ------------------ | | 285| 4.06k| EVLOCK_ASSERT_LOCKED((buffer)->lock) | | ------------------ | | | | 130| 4.06k| do { \ | | | | 131| 4.06k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 4.06k] | | | | | 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| 4.06k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 4.06k] | | | | ------------------ | | ------------------ ------------------ 1973| | 1974| 4.06k| chainp = buf->last_with_datap; 1975| | 1976| | /* XXX If *chainp is no longer writeable, but has enough space in its 1977| | * misalign, this might be a bad idea: we could still use *chainp, not 1978| | * (*chainp)->next. */ 1979| 4.06k| if (*chainp && CHAIN_SPACE_LEN(*chainp) == 0) ------------------ | | 124| 3.05k|#define CHAIN_SPACE_LEN(ch) ((ch)->flags & EVBUFFER_IMMUTABLE ? \ | | ------------------ | | | | 194| 3.05k|#define EVBUFFER_IMMUTABLE 0x0008 /**< read-only chain */ | | ------------------ | | | Branch (124:30): [True: 0, False: 3.05k] | | ------------------ | | 125| 3.05k| 0 : (ch)->buffer_len - ((ch)->misalign + (ch)->off)) ------------------ | Branch (1979:6): [True: 3.05k, False: 1.01k] | Branch (1979:17): [True: 0, False: 3.05k] ------------------ 1980| 0| chainp = &(*chainp)->next; 1981| | 1982| | /* 'chain' now points to the first chain with writable space (if any) 1983| | * We will either use it, realign it, replace it, or resize it. */ 1984| 4.06k| chain = *chainp; 1985| | 1986| 4.06k| if (chain == NULL || ------------------ | Branch (1986:6): [True: 1.01k, False: 3.05k] ------------------ 1987| 3.05k| (chain->flags & (EVBUFFER_IMMUTABLE|EVBUFFER_MEM_PINNED_ANY))) { ------------------ | | 194| 3.05k|#define EVBUFFER_IMMUTABLE 0x0008 /**< read-only chain */ ------------------ (chain->flags & (EVBUFFER_IMMUTABLE|EVBUFFER_MEM_PINNED_ANY))) { ------------------ | | 199| 3.05k|#define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | ------------------ | | | | 197| 3.05k|#define EVBUFFER_MEM_PINNED_R 0x0010 | | ------------------ | | #define EVBUFFER_MEM_PINNED_ANY (EVBUFFER_MEM_PINNED_R|EVBUFFER_MEM_PINNED_W) | | ------------------ | | | | 198| 3.05k|#define EVBUFFER_MEM_PINNED_W 0x0020 | | ------------------ ------------------ | Branch (1987:6): [True: 0, False: 3.05k] ------------------ 1988| | /* We can't use the last_with_data chain at all. Just add a 1989| | * new one that's big enough. */ 1990| 1.01k| goto insert_new; 1991| 1.01k| } 1992| | 1993| | /* If we can fit all the data, then we don't have to do anything */ 1994| 3.05k| if (CHAIN_SPACE_LEN(chain) >= datlen) { ------------------ | | 124| 3.05k|#define CHAIN_SPACE_LEN(ch) ((ch)->flags & EVBUFFER_IMMUTABLE ? \ | | ------------------ | | | | 194| 3.05k|#define EVBUFFER_IMMUTABLE 0x0008 /**< read-only chain */ | | ------------------ | | | Branch (124:30): [True: 0, False: 3.05k] | | ------------------ | | 125| 3.05k| 0 : (ch)->buffer_len - ((ch)->misalign + (ch)->off)) ------------------ | Branch (1994:6): [True: 3.05k, False: 0] ------------------ 1995| 3.05k| result = chain; 1996| 3.05k| goto ok; 1997| 3.05k| } 1998| | 1999| | /* If the chain is completely empty, just replace it by adding a new 2000| | * empty chain. */ 2001| 0| if (chain->off == 0) { ------------------ | Branch (2001:6): [True: 0, False: 0] ------------------ 2002| 0| goto insert_new; 2003| 0| } 2004| | 2005| | /* If the misalignment plus the remaining space fulfills our data 2006| | * needs, we could just force an alignment to happen. Afterwards, we 2007| | * have enough space. But only do this if we're saving a lot of space 2008| | * and not moving too much data. Otherwise the space savings are 2009| | * probably offset by the time lost in copying. 2010| | */ 2011| 0| if (evbuffer_chain_should_realign(chain, datlen)) { ------------------ | Branch (2011:6): [True: 0, False: 0] ------------------ 2012| 0| evbuffer_chain_align(chain); 2013| 0| result = chain; 2014| 0| goto ok; 2015| 0| } 2016| | 2017| | /* At this point, we can either resize the last chunk with space in 2018| | * it, use the next chunk after it, or If we add a new chunk, we waste 2019| | * CHAIN_SPACE_LEN(chain) bytes in the former last chunk. If we 2020| | * resize, we have to copy chain->off bytes. 2021| | */ 2022| | 2023| | /* Would expanding this chunk be affordable and worthwhile? */ 2024| 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 (2024:6): [True: 0, False: 0] ------------------ 2025| 0| chain->off > MAX_TO_COPY_IN_EXPAND || ------------------ | | 1951| 0|#define MAX_TO_COPY_IN_EXPAND 4096 ------------------ | Branch (2025:6): [True: 0, False: 0] ------------------ 2026| 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 (2026:3): [True: 0, False: 0] ------------------ 2027| | /* It's not worth resizing this chain. Can the next one be 2028| | * used? */ 2029| 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 (2029:7): [True: 0, False: 0] | Branch (2029:22): [True: 0, False: 0] ------------------ 2030| | /* Yes, we can just use the next chain (which should 2031| | * be empty. */ 2032| 0| result = chain->next; 2033| 0| goto ok; 2034| 0| } else { 2035| | /* No; append a new chain (which will free all 2036| | * terminal empty chains.) */ 2037| 0| goto insert_new; 2038| 0| } 2039| 0| } else { 2040| | /* Okay, we're going to try to resize this chain: Not doing so 2041| | * would waste at least 1/8 of its current allocation, and we 2042| | * can do so without having to copy more than 2043| | * MAX_TO_COPY_IN_EXPAND bytes. */ 2044| | /* figure out how much space we need */ 2045| 0| size_t length = chain->off + datlen; 2046| 0| struct evbuffer_chain *tmp = evbuffer_chain_new_membuf(length); 2047| 0| if (tmp == NULL) ------------------ | Branch (2047:7): [True: 0, False: 0] ------------------ 2048| 0| goto err; 2049| | 2050| | /* copy the data over that we had so far */ 2051| 0| tmp->off = chain->off; 2052| 0| memcpy(tmp->buffer, chain->buffer + chain->misalign, 2053| 0| chain->off); 2054| | /* fix up the list */ 2055| 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] | | | | ------------------ | | ------------------ ------------------ 2056| 0| result = *chainp = tmp; 2057| | 2058| 0| if (buf->last == chain) ------------------ | Branch (2058:7): [True: 0, False: 0] ------------------ 2059| 0| buf->last = tmp; 2060| | 2061| 0| tmp->next = chain->next; 2062| 0| evbuffer_chain_free(chain); 2063| 0| goto ok; 2064| 0| } 2065| | 2066| 1.01k|insert_new: 2067| 1.01k| result = evbuffer_chain_insert_new(buf, datlen); 2068| 1.01k| if (!result) ------------------ | Branch (2068:6): [True: 0, False: 1.01k] ------------------ 2069| 0| goto err; 2070| 4.06k|ok: 2071| 4.06k| EVUTIL_ASSERT(result); ------------------ | | 368| 4.06k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 4.06k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 4.06k| (void)sizeof(!(condition)); \ | | | | 98| 4.06k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 4.06k] | | | | ------------------ | | ------------------ ------------------ 2072| 4.06k| EVUTIL_ASSERT(CHAIN_SPACE_LEN(result) >= datlen); ------------------ | | 368| 4.06k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 4.06k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 8.13k| (void)sizeof(!(condition)); \ | | | | ------------------ | | | | | Branch (97:17): [True: 0, False: 4.06k] | | | | ------------------ | | | | 98| 4.06k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 4.06k] | | | | ------------------ | | ------------------ ------------------ 2073| 4.06k|err: 2074| 4.06k| return result; 2075| 4.06k|} buffer.c:evbuffer_chain_new: 154| 28.7k|{ 155| 28.7k| struct evbuffer_chain *chain; 156| 28.7k| size_t to_alloc; 157| | 158| 28.7k| if (size > EVBUFFER_CHAIN_MAX - EVBUFFER_CHAIN_SIZE) ------------------ | | 168| 28.7k|#define EVBUFFER_CHAIN_MAX ((size_t)EV_SSIZE_MAX) | | ------------------ | | | | 290| 28.7k|#define EV_SSIZE_MAX EV_INT64_MAX | | | | ------------------ | | | | | | 268| 28.7k|#define EV_INT64_MAX INT64_MAX | | | | ------------------ | | ------------------ ------------------ if (size > EVBUFFER_CHAIN_MAX - EVBUFFER_CHAIN_SIZE) ------------------ | | 279| 28.7k|#define EVBUFFER_CHAIN_SIZE sizeof(struct evbuffer_chain) ------------------ | Branch (158:6): [True: 0, False: 28.7k] ------------------ 159| 0| return (NULL); 160| | 161| 28.7k| to_alloc = size + EVBUFFER_CHAIN_SIZE; ------------------ | | 279| 28.7k|#define EVBUFFER_CHAIN_SIZE sizeof(struct evbuffer_chain) ------------------ 162| | 163| | /* we get everything in one chunk */ 164| 28.7k| if ((chain = mm_malloc(to_alloc)) == NULL) ------------------ | | 76| 28.7k|#define mm_malloc(sz) event_mm_malloc_(sz) ------------------ | Branch (164:6): [True: 0, False: 28.7k] ------------------ 165| 0| return (NULL); 166| | 167| 28.7k| memset(chain, 0, EVBUFFER_CHAIN_SIZE); ------------------ | | 279| 28.7k|#define EVBUFFER_CHAIN_SIZE sizeof(struct evbuffer_chain) ------------------ 168| | 169| 28.7k| chain->buffer_len = to_alloc - EVBUFFER_CHAIN_SIZE; ------------------ | | 279| 28.7k|#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| 28.7k| chain->buffer = EVBUFFER_CHAIN_EXTRA(unsigned char, chain); ------------------ | | 281| 28.7k|#define EVBUFFER_CHAIN_EXTRA(t, c) (t *)((struct evbuffer_chain *)(c) + 1) ------------------ 175| | 176| 28.7k| chain->refcnt = 1; 177| | 178| 28.7k| return (chain); 179| 28.7k|} bufferevent_pair.c:bufferevent_trigger_nolock_: 417| 2.03k|{ 418| 2.03k| if ((iotype & EV_READ) && ((options & BEV_TRIG_IGNORE_WATERMARKS) || ------------------ | | 957| 2.03k|#define EV_READ 0x02 ------------------ | Branch (418:6): [True: 1.01k, False: 1.01k] | Branch (418:29): [True: 0, False: 1.01k] ------------------ 419| 1.01k| evbuffer_get_length(bufev->input) >= bufev->wm_read.low)) ------------------ | Branch (419:6): [True: 1.01k, False: 0] ------------------ 420| 1.01k| bufferevent_run_readcb_(bufev, options); 421| 2.03k| if ((iotype & EV_WRITE) && ((options & BEV_TRIG_IGNORE_WATERMARKS) || ------------------ | | 959| 2.03k|#define EV_WRITE 0x04 ------------------ | Branch (421:6): [True: 1.01k, False: 1.01k] | Branch (421:30): [True: 0, False: 1.01k] ------------------ 422| 1.01k| evbuffer_get_length(bufev->output) <= bufev->wm_write.low)) ------------------ | Branch (422:6): [True: 1.01k, False: 0] ------------------ 423| 1.01k| bufferevent_run_writecb_(bufev, options); 424| 2.03k|} bufferevent_run_readcb_: 242| 1.01k|{ 243| | /* Requires that we hold the lock and a reference */ 244| 1.01k| struct bufferevent_private *p = BEV_UPCAST(bufev); ------------------ | | 487| 1.01k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | ------------------ | | | | 289| 1.01k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | ------------------ | | | | | | 625| 1.01k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | ------------------ | | ------------------ ------------------ 245| 1.01k| if (bufev->readcb == NULL) ------------------ | Branch (245:6): [True: 0, False: 1.01k] ------------------ 246| 0| return; 247| 1.01k| if ((p->options|options) & BEV_OPT_DEFER_CALLBACKS) { ------------------ | Branch (247:6): [True: 1.01k, False: 0] ------------------ 248| 1.01k| p->readcb_pending = 1; 249| 1.01k| SCHEDULE_DEFERRED(p); ------------------ | | 232| 1.01k| do { \ | | 233| 1.01k| if (event_deferred_cb_schedule_( \ | | ------------------ | | | Branch (233:7): [True: 1.01k, False: 0] | | ------------------ | | 234| 1.01k| (bevp)->bev.ev_base, \ | | 235| 1.01k| &(bevp)->deferred)) \ | | 236| 1.01k| bufferevent_incref_(&(bevp)->bev); \ | | ------------------ | | | | 378| 1.01k|#define bufferevent_incref_(bufev) bufferevent_incref(bufev) | | ------------------ | | 237| 1.01k| } while (0) | | ------------------ | | | Branch (237:11): [Folded, False: 1.01k] | | ------------------ ------------------ 250| 1.01k| } else { 251| 0| bufev->readcb(bufev, bufev->cbarg); 252| 0| bufferevent_inbuf_wm_check(bufev); 253| 0| } 254| 1.01k|} bufferevent_run_writecb_: 258| 1.01k|{ 259| | /* Requires that we hold the lock and a reference */ 260| 1.01k| struct bufferevent_private *p = BEV_UPCAST(bufev); ------------------ | | 487| 1.01k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | ------------------ | | | | 289| 1.01k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | ------------------ | | | | | | 625| 1.01k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | ------------------ | | ------------------ ------------------ 261| 1.01k| if (bufev->writecb == NULL) ------------------ | Branch (261:6): [True: 1.01k, False: 0] ------------------ 262| 1.01k| 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); \ | | ------------------ | | | | 378| 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| 2.03k|{ 314| 2.03k| struct bufferevent *bufev = &bufev_private->bev; 315| | 316| 2.03k| if (!bufev->input) { ------------------ | Branch (316:6): [True: 2.03k, False: 0] ------------------ 317| 2.03k| if ((bufev->input = evbuffer_new()) == NULL) ------------------ | Branch (317:7): [True: 0, False: 2.03k] ------------------ 318| 0| goto err; 319| 2.03k| } 320| | 321| 2.03k| if (!bufev->output) { ------------------ | Branch (321:6): [True: 2.03k, False: 0] ------------------ 322| 2.03k| if ((bufev->output = evbuffer_new()) == NULL) ------------------ | Branch (322:7): [True: 0, False: 2.03k] ------------------ 323| 0| goto err; 324| 2.03k| } 325| | 326| 2.03k| bufev_private->refcnt = 1; 327| 2.03k| bufev->ev_base = base; 328| | 329| | /* Disable timeouts. */ 330| 2.03k| evutil_timerclear(&bufev->timeout_read); ------------------ | | 604| 2.03k|#define evutil_timerclear(tvp) timerclear(tvp) ------------------ 331| 2.03k| evutil_timerclear(&bufev->timeout_write); ------------------ | | 604| 2.03k|#define evutil_timerclear(tvp) timerclear(tvp) ------------------ 332| | 333| 2.03k| bufev->be_ops = ops; 334| | 335| 2.03k| if (bufferevent_ratelim_init_(bufev_private)) ------------------ | Branch (335:6): [True: 0, False: 2.03k] ------------------ 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| 2.03k| bufev->enabled = EV_WRITE; ------------------ | | 959| 2.03k|#define EV_WRITE 0x04 ------------------ 344| | 345| 2.03k|#ifndef EVENT__DISABLE_THREAD_SUPPORT 346| 2.03k| if (options & BEV_OPT_THREADSAFE) { ------------------ | Branch (346:6): [True: 0, False: 2.03k] ------------------ 347| 0| if (bufferevent_enable_locking_(bufev, NULL) < 0) ------------------ | Branch (347:7): [True: 0, False: 0] ------------------ 348| 0| goto err; 349| 0| } 350| 2.03k|#endif 351| 2.03k| if ((options & (BEV_OPT_DEFER_CALLBACKS|BEV_OPT_UNLOCK_CALLBACKS)) ------------------ | Branch (351:6): [True: 0, False: 2.03k] ------------------ 352| 2.03k| == BEV_OPT_UNLOCK_CALLBACKS) { 353| 0| event_warnx("UNLOCK_CALLBACKS requires DEFER_CALLBACKS"); 354| 0| goto err; 355| 0| } 356| 2.03k| if (options & BEV_OPT_UNLOCK_CALLBACKS) ------------------ | Branch (356:6): [True: 0, False: 2.03k] ------------------ 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| 2.03k| else 363| 2.03k| event_deferred_cb_init_( 364| 2.03k| &bufev_private->deferred, 365| 2.03k| event_base_get_npriorities(base) / 2, 366| 2.03k| bufferevent_run_deferred_callbacks_locked, 367| 2.03k| bufev_private); 368| | 369| 2.03k| bufev_private->options = options; 370| | 371| 2.03k| evbuffer_set_parent_(bufev->input, bufev); 372| 2.03k| evbuffer_set_parent_(bufev->output, bufev); 373| | 374| 2.03k| 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| 2.03k|} bufferevent_setcb: 392| 5.66k|{ 393| 5.66k| BEV_LOCK(bufev); ------------------ | | 494| 5.66k|#define BEV_LOCK(b) do { \ | | 495| 5.66k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 487| 5.66k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 5.66k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 5.66k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 496| 5.66k| EVLOCK_LOCK(locking->lock, 0); \ | | ------------------ | | | | 94| 5.66k| do { \ | | | | 95| 5.66k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 5.66k] | | | | ------------------ | | | | 96| 5.66k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 5.66k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 5.66k] | | | | ------------------ | | ------------------ | | 497| 5.66k| } while (0) | | ------------------ | | | Branch (497:11): [Folded, False: 5.66k] | | ------------------ ------------------ 394| | 395| 5.66k| bufev->readcb = readcb; 396| 5.66k| bufev->writecb = writecb; 397| 5.66k| bufev->errorcb = eventcb; 398| | 399| 5.66k| bufev->cbarg = cbarg; 400| | BEV_UNLOCK(bufev); ------------------ | | 500| 5.66k|#define BEV_UNLOCK(b) do { \ | | 501| 5.66k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 487| 5.66k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 5.66k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 5.66k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 502| 5.66k| EVLOCK_UNLOCK(locking->lock, 0); \ | | ------------------ | | | | 101| 5.66k| do { \ | | | | 102| 5.66k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 5.66k] | | | | ------------------ | | | | 103| 5.66k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 5.66k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 5.66k] | | | | ------------------ | | ------------------ | | 503| 5.66k| } while (0) | | ------------------ | | | Branch (503:11): [Folded, False: 5.66k] | | ------------------ ------------------ 401| 5.66k|} bufferevent_get_input: 425| 1.01k|{ 426| 1.01k| return bufev->input; 427| 1.01k|} bufferevent_get_output: 431| 3.63k|{ 432| 3.63k| return bufev->output; 433| 3.63k|} bufferevent_get_base: 437| 1.01k|{ 438| 1.01k| return bufev->ev_base; 439| 1.01k|} bufferevent_get_priority: 443| 1.01k|{ 444| 1.01k| if (event_initialized(&bufev->ev_read)) { ------------------ | Branch (444:6): [True: 1.01k, False: 0] ------------------ 445| 1.01k| return event_get_priority(&bufev->ev_read); 446| 1.01k| } else { 447| 0| return event_base_get_npriorities(bufev->ev_base) / 2; 448| 0| } 449| 1.01k|} bufferevent_enable: 488| 1.01k|{ 489| 1.01k| struct bufferevent_private *bufev_private = BEV_UPCAST(bufev); ------------------ | | 487| 1.01k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | ------------------ | | | | 289| 1.01k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | ------------------ | | | | | | 625| 1.01k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | ------------------ | | ------------------ ------------------ 490| 1.01k| short impl_events = event; 491| 1.01k| int r = 0; 492| | 493| 1.01k| bufferevent_incref_and_lock_(bufev); 494| 1.01k| if (bufev_private->read_suspended) ------------------ | Branch (494:6): [True: 0, False: 1.01k] ------------------ 495| 0| impl_events &= ~EV_READ; ------------------ | | 957| 0|#define EV_READ 0x02 ------------------ 496| 1.01k| if (bufev_private->write_suspended) ------------------ | Branch (496:6): [True: 0, False: 1.01k] ------------------ 497| 0| impl_events &= ~EV_WRITE; ------------------ | | 959| 0|#define EV_WRITE 0x04 ------------------ 498| | 499| 1.01k| bufev->enabled |= event; 500| | 501| 1.01k| if (impl_events && bufev->be_ops->enable(bufev, impl_events) < 0) ------------------ | Branch (501:6): [True: 1.01k, False: 0] | Branch (501:21): [True: 0, False: 1.01k] ------------------ 502| 0| r = -1; 503| 1.01k| if (r) ------------------ | Branch (503:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| bufferevent_decref_and_unlock_(bufev); 507| 1.01k| return r; 508| 1.01k|} bufferevent_incref_and_lock_: 686| 19.4k|{ 687| 19.4k| struct bufferevent_private *bufev_private = BEV_UPCAST(bufev); ------------------ | | 487| 19.4k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | ------------------ | | | | 289| 19.4k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | ------------------ | | | | | | 625| 19.4k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | ------------------ | | ------------------ ------------------ 688| | BEV_LOCK(bufev); ------------------ | | 494| 19.4k|#define BEV_LOCK(b) do { \ | | 495| 19.4k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 487| 19.4k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 19.4k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 19.4k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 496| 19.4k| EVLOCK_LOCK(locking->lock, 0); \ | | ------------------ | | | | 94| 19.4k| do { \ | | | | 95| 19.4k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 19.4k] | | | | ------------------ | | | | 96| 19.4k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 19.4k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 19.4k] | | | | ------------------ | | ------------------ | | 497| 19.4k| } while (0) | | ------------------ | | | Branch (497:11): [Folded, False: 19.4k] | | ------------------ ------------------ 689| 19.4k| ++bufev_private->refcnt; 690| 19.4k|} bufferevent_decref_and_unlock_: 712| 22.5k|{ 713| 22.5k| struct bufferevent_private *bufev_private = BEV_UPCAST(bufev); ------------------ | | 487| 22.5k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | ------------------ | | | | 289| 22.5k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | ------------------ | | | | | | 625| 22.5k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | ------------------ | | ------------------ ------------------ 714| 22.5k| int n_cbs = 0; 715| 22.5k|#define MAX_CBS 16 716| 22.5k| struct event_callback *cbs[MAX_CBS]; 717| | 718| 22.5k| EVUTIL_ASSERT(bufev_private->refcnt > 0); ------------------ | | 368| 22.5k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 22.5k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 22.5k| (void)sizeof(!(condition)); \ | | | | 98| 22.5k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 22.5k] | | | | ------------------ | | ------------------ ------------------ 719| | 720| 22.5k| if (--bufev_private->refcnt) { ------------------ | Branch (720:6): [True: 20.4k, False: 2.03k] ------------------ 721| 20.4k| BEV_UNLOCK(bufev); ------------------ | | 500| 20.4k|#define BEV_UNLOCK(b) do { \ | | 501| 20.4k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 487| 20.4k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 20.4k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 20.4k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 502| 20.4k| EVLOCK_UNLOCK(locking->lock, 0); \ | | ------------------ | | | | 101| 20.4k| do { \ | | | | 102| 20.4k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 20.4k] | | | | ------------------ | | | | 103| 20.4k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 20.4k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 20.4k] | | | | ------------------ | | ------------------ | | 503| 20.4k| } while (0) | | ------------------ | | | Branch (503:11): [Folded, False: 20.4k] | | ------------------ ------------------ 722| 20.4k| return 0; 723| 20.4k| } 724| | 725| 2.03k| if (bufev->be_ops->unlink) ------------------ | Branch (725:6): [True: 2.03k, False: 0] ------------------ 726| 2.03k| 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| 2.03k| cbs[0] = &bufev->ev_read.ev_evcallback; 731| 2.03k| cbs[1] = &bufev->ev_write.ev_evcallback; 732| 2.03k| cbs[2] = &bufev_private->deferred; 733| 2.03k| n_cbs = 3; 734| 2.03k| if (bufev_private->rate_limiting) { ------------------ | Branch (734:6): [True: 0, False: 2.03k] ------------------ 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| 2.03k| n_cbs += evbuffer_get_callbacks_(bufev->input, cbs+n_cbs, MAX_CBS-n_cbs); ------------------ | | 715| 2.03k|#define MAX_CBS 16 ------------------ 740| 2.03k| n_cbs += evbuffer_get_callbacks_(bufev->output, cbs+n_cbs, MAX_CBS-n_cbs); ------------------ | | 715| 2.03k|#define MAX_CBS 16 ------------------ 741| | 742| 2.03k| event_callback_finalize_many_(bufev->ev_base, n_cbs, cbs, 743| 2.03k| bufferevent_finalize_cb_); 744| | 745| 2.03k|#undef MAX_CBS 746| 2.03k| BEV_UNLOCK(bufev); ------------------ | | 500| 2.03k|#define BEV_UNLOCK(b) do { \ | | 501| 2.03k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 487| 2.03k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 2.03k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 2.03k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 502| 2.03k| EVLOCK_UNLOCK(locking->lock, 0); \ | | ------------------ | | | | 101| 2.03k| do { \ | | | | 102| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 103| 2.03k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 503| 2.03k| } while (0) | | ------------------ | | | Branch (503:11): [Folded, False: 2.03k] | | ------------------ ------------------ 747| | 748| 2.03k| return 1; 749| 22.5k|} bufferevent_free: 812| 2.03k|{ 813| 2.03k| BEV_LOCK(bufev); ------------------ | | 494| 2.03k|#define BEV_LOCK(b) do { \ | | 495| 2.03k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 487| 2.03k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 2.03k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 2.03k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 496| 2.03k| EVLOCK_LOCK(locking->lock, 0); \ | | ------------------ | | | | 94| 2.03k| do { \ | | | | 95| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 96| 2.03k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 497| 2.03k| } while (0) | | ------------------ | | | Branch (497:11): [Folded, False: 2.03k] | | ------------------ ------------------ 814| 2.03k| bufferevent_setcb(bufev, NULL, NULL, NULL, NULL); 815| 2.03k| bufferevent_cancel_all_(bufev); 816| 2.03k| bufferevent_decref_and_unlock_(bufev); 817| 2.03k|} bufferevent_incref: 821| 1.01k|{ 822| 1.01k| struct bufferevent_private *bufev_private = BEV_UPCAST(bufev); ------------------ | | 487| 1.01k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | ------------------ | | | | 289| 1.01k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | ------------------ | | | | | | 625| 1.01k|#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| 1.01k| BEV_LOCK(bufev); ------------------ | | 494| 1.01k|#define BEV_LOCK(b) do { \ | | 495| 1.01k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 487| 1.01k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 1.01k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 1.01k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 496| 1.01k| EVLOCK_LOCK(locking->lock, 0); \ | | ------------------ | | | | 94| 1.01k| do { \ | | | | 95| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 96| 1.01k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ | | 497| 1.01k| } while (0) | | ------------------ | | | Branch (497:11): [Folded, False: 1.01k] | | ------------------ ------------------ 829| 1.01k| ++bufev_private->refcnt; 830| | BEV_UNLOCK(bufev); ------------------ | | 500| 1.01k|#define BEV_UNLOCK(b) do { \ | | 501| 1.01k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 487| 1.01k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 1.01k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 1.01k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 502| 1.01k| EVLOCK_UNLOCK(locking->lock, 0); \ | | ------------------ | | | | 101| 1.01k| do { \ | | | | 102| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 103| 1.01k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ | | 503| 1.01k| } while (0) | | ------------------ | | | Branch (503:11): [Folded, False: 1.01k] | | ------------------ ------------------ 831| 1.01k|} bufferevent_get_underlying: 963| 2.03k|{ 964| 2.03k| union bufferevent_ctrl_data d; 965| 2.03k| int res = -1; 966| 2.03k| d.ptr = NULL; 967| 2.03k| BEV_LOCK(bev); ------------------ | | 494| 2.03k|#define BEV_LOCK(b) do { \ | | 495| 2.03k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 487| 2.03k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 2.03k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 2.03k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 496| 2.03k| EVLOCK_LOCK(locking->lock, 0); \ | | ------------------ | | | | 94| 2.03k| do { \ | | | | 95| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 96| 2.03k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 497| 2.03k| } while (0) | | ------------------ | | | Branch (497:11): [Folded, False: 2.03k] | | ------------------ ------------------ 968| 2.03k| if (bev->be_ops->ctrl) ------------------ | Branch (968:6): [True: 0, False: 2.03k] ------------------ 969| 0| res = bev->be_ops->ctrl(bev, BEV_CTRL_GET_UNDERLYING, &d); 970| 2.03k| BEV_UNLOCK(bev); ------------------ | | 500| 2.03k|#define BEV_UNLOCK(b) do { \ | | 501| 2.03k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 487| 2.03k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 2.03k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 2.03k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 502| 2.03k| EVLOCK_UNLOCK(locking->lock, 0); \ | | ------------------ | | | | 101| 2.03k| do { \ | | | | 102| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 103| 2.03k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 503| 2.03k| } while (0) | | ------------------ | | | Branch (503:11): [Folded, False: 2.03k] | | ------------------ ------------------ 971| 2.03k| return (res<0) ? NULL : d.ptr; ------------------ | Branch (971:9): [True: 2.03k, False: 0] ------------------ 972| 2.03k|} bufferevent_init_generic_timeout_cbs_: 995| 2.03k|{ 996| 2.03k| event_assign(&bev->ev_read, bev->ev_base, -1, EV_FINALIZE, ------------------ | | 979| 2.03k|#define EV_FINALIZE 0x40 ------------------ 997| 2.03k| bufferevent_generic_read_timeout_cb, bev); 998| 2.03k| event_assign(&bev->ev_write, bev->ev_base, -1, EV_FINALIZE, ------------------ | | 979| 2.03k|#define EV_FINALIZE 0x40 ------------------ 999| 2.03k| bufferevent_generic_write_timeout_cb, bev); 1000| 2.03k|} bufferevent.c:bufferevent_inbuf_wm_check: 122| 1.01k|{ 123| 1.01k| if (!bev->wm_read.high) ------------------ | Branch (123:6): [True: 1.01k, False: 0] ------------------ 124| 1.01k| 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| 1.01k|{ 154| 1.01k| struct bufferevent_private *bufev_private = arg; 155| 1.01k| struct bufferevent *bufev = &bufev_private->bev; 156| | 157| 1.01k| BEV_LOCK(bufev); ------------------ | | 494| 1.01k|#define BEV_LOCK(b) do { \ | | 495| 1.01k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 487| 1.01k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 1.01k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 1.01k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 496| 1.01k| EVLOCK_LOCK(locking->lock, 0); \ | | ------------------ | | | | 94| 1.01k| do { \ | | | | 95| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 96| 1.01k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ | | 497| 1.01k| } while (0) | | ------------------ | | | Branch (497:11): [Folded, False: 1.01k] | | ------------------ ------------------ 158| 1.01k| if ((bufev_private->eventcb_pending & BEV_EVENT_CONNECTED) && ------------------ | | 106| 1.01k|#define BEV_EVENT_CONNECTED 0x80 /**< connect operation finished. */ ------------------ | Branch (158:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| if (bufev_private->readcb_pending && bufev->readcb) { ------------------ | Branch (165:6): [True: 1.01k, False: 0] | Branch (165:39): [True: 1.01k, False: 0] ------------------ 166| 1.01k| bufev_private->readcb_pending = 0; 167| 1.01k| bufev->readcb(bufev, bufev->cbarg); 168| 1.01k| bufferevent_inbuf_wm_check(bufev); 169| 1.01k| } 170| 1.01k| if (bufev_private->writecb_pending && bufev->writecb) { ------------------ | Branch (170:6): [True: 0, False: 1.01k] | Branch (170:40): [True: 0, False: 0] ------------------ 171| 0| bufev_private->writecb_pending = 0; 172| 0| bufev->writecb(bufev, bufev->cbarg); 173| 0| } 174| 1.01k| if (bufev_private->eventcb_pending && bufev->errorcb) { ------------------ | Branch (174:6): [True: 0, False: 1.01k] | 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| 1.01k| bufferevent_decref_and_unlock_(bufev); 183| 1.01k|} bufferevent.c:bufferevent_finalize_cb_: 753| 2.03k|{ 754| 2.03k| struct bufferevent *bufev = arg_; 755| 2.03k| struct bufferevent *underlying; 756| 2.03k| struct bufferevent_private *bufev_private = BEV_UPCAST(bufev); ------------------ | | 487| 2.03k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | ------------------ | | | | 289| 2.03k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | ------------------ | | | | | | 625| 2.03k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | ------------------ | | ------------------ ------------------ 757| | 758| 2.03k| BEV_LOCK(bufev); ------------------ | | 494| 2.03k|#define BEV_LOCK(b) do { \ | | 495| 2.03k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 487| 2.03k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 2.03k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 2.03k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 496| 2.03k| EVLOCK_LOCK(locking->lock, 0); \ | | ------------------ | | | | 94| 2.03k| do { \ | | | | 95| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 96| 2.03k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 497| 2.03k| } while (0) | | ------------------ | | | Branch (497:11): [Folded, False: 2.03k] | | ------------------ ------------------ 759| 2.03k| underlying = bufferevent_get_underlying(bufev); 760| | 761| | /* Clean up the shared info */ 762| 2.03k| if (bufev->be_ops->destruct) ------------------ | Branch (762:6): [True: 2.03k, False: 0] ------------------ 763| 2.03k| 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| 2.03k| evbuffer_free(bufev->input); 770| 2.03k| evbuffer_free(bufev->output); 771| | 772| 2.03k| if (bufev_private->rate_limiting) { ------------------ | Branch (772:6): [True: 0, False: 2.03k] ------------------ 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| 2.03k| BEV_UNLOCK(bufev); ------------------ | | 500| 2.03k|#define BEV_UNLOCK(b) do { \ | | 501| 2.03k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 487| 2.03k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 2.03k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 2.03k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 502| 2.03k| EVLOCK_UNLOCK(locking->lock, 0); \ | | ------------------ | | | | 101| 2.03k| do { \ | | | | 102| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 103| 2.03k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 503| 2.03k| } while (0) | | ------------------ | | | Branch (503:11): [Folded, False: 2.03k] | | ------------------ ------------------ 781| | 782| 2.03k| if (bufev_private->own_lock) ------------------ | Branch (782:6): [True: 0, False: 2.03k] ------------------ 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| 2.03k| EVTHREAD_LOCKTYPE_RECURSIVE); 785| | 786| | /* Free the actual allocated memory. */ 787| 2.03k| mm_free(((char*)bufev) - bufev->be_ops->mem_offset); ------------------ | | 80| 2.03k|#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| 2.03k| if (underlying) ------------------ | Branch (799:6): [True: 0, False: 2.03k] ------------------ 800| 0| bufferevent_decref_(underlying); ------------------ | | 386| 0|#define bufferevent_decref_(bufev) bufferevent_decref(bufev) ------------------ 801| 2.03k|} bufferevent.c:bufferevent_cancel_all_: 942| 2.03k|{ 943| 2.03k| union bufferevent_ctrl_data d; 944| 2.03k| memset(&d, 0, sizeof(d)); 945| 2.03k| BEV_LOCK(bev); ------------------ | | 494| 2.03k|#define BEV_LOCK(b) do { \ | | 495| 2.03k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 487| 2.03k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 2.03k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 2.03k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 496| 2.03k| EVLOCK_LOCK(locking->lock, 0); \ | | ------------------ | | | | 94| 2.03k| do { \ | | | | 95| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 96| 2.03k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 497| 2.03k| } while (0) | | ------------------ | | | Branch (497:11): [Folded, False: 2.03k] | | ------------------ ------------------ 946| 2.03k| if (bev->be_ops->ctrl) ------------------ | Branch (946:6): [True: 0, False: 2.03k] ------------------ 947| 0| bev->be_ops->ctrl(bev, BEV_CTRL_CANCEL_ALL, &d); 948| | BEV_UNLOCK(bev); ------------------ | | 500| 2.03k|#define BEV_UNLOCK(b) do { \ | | 501| 2.03k| struct bufferevent_private *locking = BEV_UPCAST(b); \ | | ------------------ | | | | 487| 2.03k|#define BEV_UPCAST(b) EVUTIL_UPCAST((b), struct bufferevent_private, bev) | | | | ------------------ | | | | | | 289| 2.03k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | | | | | ------------------ | | | | | | | | 625| 2.03k|#define evutil_offsetof(type, field) offsetof(type, field) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 502| 2.03k| EVLOCK_UNLOCK(locking->lock, 0); \ | | ------------------ | | | | 101| 2.03k| do { \ | | | | 102| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 103| 2.03k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 503| 2.03k| } while (0) | | ------------------ | | | Branch (503:11): [Folded, False: 2.03k] | | ------------------ ------------------ 949| 2.03k|} bufferevent_pair_new: 115| 1.01k|{ 116| 1.01k| struct bufferevent_pair *bufev1 = NULL, *bufev2 = NULL; 117| 1.01k| int tmp_options; 118| | 119| 1.01k| options |= BEV_OPT_DEFER_CALLBACKS; 120| 1.01k| tmp_options = options & ~BEV_OPT_THREADSAFE; 121| | 122| 1.01k| bufev1 = bufferevent_pair_elt_new(base, options); 123| 1.01k| if (!bufev1) ------------------ | Branch (123:6): [True: 0, False: 1.01k] ------------------ 124| 0| return -1; 125| 1.01k| bufev2 = bufferevent_pair_elt_new(base, tmp_options); 126| 1.01k| if (!bufev2) { ------------------ | Branch (126:6): [True: 0, False: 1.01k] ------------------ 127| 0| bufferevent_free(downcast(bufev1)); ------------------ | | 64| 0|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 128| 0| return -1; 129| 0| } 130| | 131| 1.01k| if (options & BEV_OPT_THREADSAFE) { ------------------ | Branch (131:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| bufev1->partner = bufev2; 137| 1.01k| bufev2->partner = bufev1; 138| | 139| 1.01k| evbuffer_freeze(downcast(bufev1)->input, 0); ------------------ | | 64| 1.01k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 140| 1.01k| evbuffer_freeze(downcast(bufev1)->output, 1); ------------------ | | 64| 1.01k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 141| 1.01k| evbuffer_freeze(downcast(bufev2)->input, 0); ------------------ | | 64| 1.01k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 142| 1.01k| evbuffer_freeze(downcast(bufev2)->output, 1); ------------------ | | 64| 1.01k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 143| | 144| 1.01k| pair[0] = downcast(bufev1); ------------------ | | 64| 1.01k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 145| 1.01k| pair[1] = downcast(bufev2); ------------------ | | 64| 1.01k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 146| | 147| 1.01k| return 0; 148| 1.01k|} bufferevent_pair.c:bufferevent_pair_elt_new: 93| 2.03k|{ 94| 2.03k| struct bufferevent_pair *bufev; 95| 2.03k| if (! (bufev = mm_calloc(1, sizeof(struct bufferevent_pair)))) ------------------ | | 77| 2.03k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ | Branch (95:6): [True: 0, False: 2.03k] ------------------ 96| 0| return NULL; 97| 2.03k| if (bufferevent_init_common_(&bufev->bev, base, &bufferevent_ops_pair, ------------------ | Branch (97:6): [True: 0, False: 2.03k] ------------------ 98| 2.03k| options)) { 99| 0| mm_free(bufev); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 100| 0| return NULL; 101| 0| } 102| 2.03k| if (!evbuffer_add_cb(bufev->bev.bev.output, be_pair_outbuf_cb, bufev)) { ------------------ | Branch (102:6): [True: 0, False: 2.03k] ------------------ 103| 0| bufferevent_free(downcast(bufev)); ------------------ | | 64| 0|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 104| 0| return NULL; 105| 0| } 106| | 107| 2.03k| bufferevent_init_generic_timeout_cbs_(&bufev->bev.bev); 108| | 109| 2.03k| return bufev; 110| 2.03k|} bufferevent_pair.c:be_pair_outbuf_cb: 205| 7.70k|{ 206| 7.70k| struct bufferevent_pair *bev_pair = arg; 207| 7.70k| struct bufferevent_pair *partner = bev_pair->partner; 208| | 209| 7.70k| incref_and_lock(downcast(bev_pair)); ------------------ | | 64| 7.70k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 210| | 211| 7.70k| if (info->n_added > info->n_deleted && partner) { ------------------ | Branch (211:6): [True: 6.68k, False: 1.01k] | Branch (211:41): [True: 6.68k, False: 0] ------------------ 212| | /* We got more data. If the other side's reading, then 213| | hand it over. */ 214| 6.68k| if (be_pair_wants_to_talk(bev_pair, partner)) { ------------------ | Branch (214:7): [True: 1.01k, False: 5.66k] ------------------ 215| 1.01k| be_pair_transfer(downcast(bev_pair), downcast(partner), 0); ------------------ | | 64| 1.01k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ be_pair_transfer(downcast(bev_pair), downcast(partner), 0); ------------------ | | 64| 1.01k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 216| 1.01k| } 217| 6.68k| } 218| | 219| 7.70k| decref_and_unlock(downcast(bev_pair)); ------------------ | | 64| 7.70k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 220| 7.70k|} bufferevent_pair.c:be_pair_wants_to_talk: 195| 8.71k|{ 196| 8.71k| return (downcast(src)->enabled & EV_WRITE) && ------------------ | | 64| 8.71k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ return (downcast(src)->enabled & EV_WRITE) && ------------------ | | 959| 8.71k|#define EV_WRITE 0x04 ------------------ | Branch (196:9): [True: 8.71k, False: 0] ------------------ 197| 8.71k| (downcast(dst)->enabled & EV_READ) && ------------------ | | 64| 8.71k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ (downcast(dst)->enabled & EV_READ) && ------------------ | | 957| 8.71k|#define EV_READ 0x02 ------------------ | Branch (197:6): [True: 2.03k, False: 6.68k] ------------------ 198| 2.03k| !dst->bev.read_suspended && ------------------ | Branch (198:6): [True: 2.03k, False: 0] ------------------ 199| 2.03k| evbuffer_get_length(downcast(src)->output); ------------------ | | 64| 2.03k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ | Branch (199:6): [True: 1.01k, False: 1.01k] ------------------ 200| 8.71k|} bufferevent_pair.c:be_pair_transfer: 153| 1.01k|{ 154| 1.01k| size_t dst_size; 155| 1.01k| size_t n; 156| | 157| 1.01k| evbuffer_unfreeze(src->output, 1); 158| 1.01k| evbuffer_unfreeze(dst->input, 0); 159| | 160| 1.01k| if (dst->wm_read.high) { ------------------ | Branch (160:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| } else { 172| 1.01k| n = evbuffer_get_length(src->output); 173| 1.01k| evbuffer_add_buffer(dst->input, src->output); 174| 1.01k| } 175| | 176| 1.01k| if (n) { ------------------ | Branch (176:6): [True: 1.01k, False: 0] ------------------ 177| 1.01k| BEV_RESET_GENERIC_READ_TIMEOUT(dst); ------------------ | | 468| 1.01k| do { \ | | 469| 1.01k| if (evutil_timerisset(&(bev)->timeout_read)) \ | | ------------------ | | | | 618| 1.01k|#define evutil_timerisset(tvp) timerisset(tvp) | | ------------------ | | 470| 1.01k| event_add(&(bev)->ev_read, &(bev)->timeout_read); \ | | 471| 1.01k| } while (0) | | ------------------ | | | Branch (471:11): [Folded, False: 1.01k] | | ------------------ ------------------ | Branch (177:3): [True: 0, False: 1.01k] ------------------ 178| | 179| 1.01k| if (evbuffer_get_length(dst->output)) ------------------ | Branch (179:7): [True: 1.01k, False: 0] ------------------ 180| 1.01k| BEV_RESET_GENERIC_WRITE_TIMEOUT(dst); ------------------ | | 475| 1.01k| do { \ | | 476| 1.01k| if (evutil_timerisset(&(bev)->timeout_write)) \ | | ------------------ | | | | 618| 1.01k|#define evutil_timerisset(tvp) timerisset(tvp) | | ------------------ | | 477| 1.01k| event_add(&(bev)->ev_write, &(bev)->timeout_write); \ | | 478| 1.01k| } while (0) | | ------------------ | | | Branch (478:11): [Folded, False: 1.01k] | | ------------------ ------------------ | Branch (180:4): [True: 0, False: 1.01k] ------------------ 181| 0| else 182| 0| BEV_DEL_GENERIC_WRITE_TIMEOUT(dst); ------------------ | | 482| 0| event_del(&(bev)->ev_write) ------------------ 183| 1.01k| } 184| | 185| 1.01k| bufferevent_trigger_nolock_(dst, EV_READ, 0); ------------------ | | 957| 1.01k|#define EV_READ 0x02 ------------------ 186| 1.01k| bufferevent_trigger_nolock_(src, EV_WRITE, 0); ------------------ | | 959| 1.01k|#define EV_WRITE 0x04 ------------------ 187| 1.01k|done: 188| 1.01k| evbuffer_freeze(src->output, 1); 189| 1.01k| evbuffer_freeze(dst->input, 0); 190| 1.01k|} bufferevent_pair.c:upcast: 57| 22.5k|{ 58| 22.5k| struct bufferevent_pair *bev_p; 59| 22.5k| bev_p = EVUTIL_UPCAST(bev, struct bufferevent_pair, bev.bev); ------------------ | | 289| 22.5k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | ------------------ | | | | 625| 22.5k|#define evutil_offsetof(type, field) offsetof(type, field) | | ------------------ ------------------ 60| 22.5k| EVUTIL_ASSERT(BEV_IS_PAIR(&bev_p->bev.bev)); ------------------ | | 368| 22.5k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 22.5k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 22.5k| (void)sizeof(!(condition)); \ | | | | 98| 22.5k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 22.5k] | | | | ------------------ | | ------------------ ------------------ 61| 22.5k| return bev_p; 62| 22.5k|} bufferevent_pair.c:incref_and_lock: 68| 8.71k|{ 69| 8.71k| struct bufferevent_pair *bevp; 70| 8.71k| bufferevent_incref_and_lock_(b); 71| 8.71k| bevp = upcast(b); 72| 8.71k| if (bevp->partner) ------------------ | Branch (72:6): [True: 8.71k, False: 0] ------------------ 73| 8.71k| bufferevent_incref_and_lock_(downcast(bevp->partner)); ------------------ | | 64| 8.71k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 74| 8.71k|} bufferevent_pair.c:decref_and_unlock: 78| 8.71k|{ 79| 8.71k| struct bufferevent_pair *bevp = upcast(b); 80| 8.71k| if (bevp->partner) ------------------ | Branch (80:6): [True: 8.71k, False: 0] ------------------ 81| 8.71k| bufferevent_decref_and_unlock_(downcast(bevp->partner)); ------------------ | | 64| 8.71k|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 82| 8.71k| bufferevent_decref_and_unlock_(b); 83| 8.71k|} bufferevent_pair.c:be_pair_enable: 224| 1.01k|{ 225| 1.01k| struct bufferevent_pair *bev_p = upcast(bufev); 226| 1.01k| struct bufferevent_pair *partner = bev_p->partner; 227| | 228| 1.01k| incref_and_lock(bufev); 229| | 230| 1.01k| if (events & EV_READ) { ------------------ | | 957| 1.01k|#define EV_READ 0x02 ------------------ | Branch (230:6): [True: 1.01k, False: 0] ------------------ 231| 1.01k| BEV_RESET_GENERIC_READ_TIMEOUT(bufev); ------------------ | | 468| 1.01k| do { \ | | 469| 1.01k| if (evutil_timerisset(&(bev)->timeout_read)) \ | | ------------------ | | | | 618| 1.01k|#define evutil_timerisset(tvp) timerisset(tvp) | | ------------------ | | 470| 1.01k| event_add(&(bev)->ev_read, &(bev)->timeout_read); \ | | 471| 1.01k| } while (0) | | ------------------ | | | Branch (471:11): [Folded, False: 1.01k] | | ------------------ ------------------ | Branch (231:3): [True: 0, False: 1.01k] ------------------ 232| 1.01k| } 233| 1.01k| if ((events & EV_WRITE) && evbuffer_get_length(bufev->output)) ------------------ | | 959| 1.01k|#define EV_WRITE 0x04 ------------------ | Branch (233:6): [True: 1.01k, False: 0] | Branch (233:29): [True: 1.01k, False: 0] ------------------ 234| 1.01k| BEV_RESET_GENERIC_WRITE_TIMEOUT(bufev); ------------------ | | 475| 1.01k| do { \ | | 476| 1.01k| if (evutil_timerisset(&(bev)->timeout_write)) \ | | ------------------ | | | | 618| 1.01k|#define evutil_timerisset(tvp) timerisset(tvp) | | ------------------ | | 477| 1.01k| event_add(&(bev)->ev_write, &(bev)->timeout_write); \ | | 478| 1.01k| } while (0) | | ------------------ | | | Branch (478:11): [Folded, False: 1.01k] | | ------------------ ------------------ | Branch (234:3): [True: 0, False: 1.01k] ------------------ 235| | 236| | /* We're starting to read! Does the other side have anything to write?*/ 237| 1.01k| if ((events & EV_READ) && partner && ------------------ | | 957| 1.01k|#define EV_READ 0x02 ------------------ | Branch (237:6): [True: 1.01k, False: 0] | Branch (237:28): [True: 1.01k, False: 0] ------------------ 238| 1.01k| be_pair_wants_to_talk(partner, bev_p)) { ------------------ | Branch (238:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| if ((events & EV_WRITE) && partner && ------------------ | | 959| 1.01k|#define EV_WRITE 0x04 ------------------ | Branch (242:6): [True: 1.01k, False: 0] | Branch (242:29): [True: 1.01k, False: 0] ------------------ 243| 1.01k| be_pair_wants_to_talk(bev_p, partner)) { ------------------ | Branch (243:6): [True: 0, False: 1.01k] ------------------ 244| 0| be_pair_transfer(bufev, downcast(partner), 0); ------------------ | | 64| 0|#define downcast(bev_pair) (&(bev_pair)->bev.bev) ------------------ 245| 0| } 246| 1.01k| decref_and_unlock(bufev); 247| 1.01k| return 0; 248| 1.01k|} bufferevent_pair.c:be_pair_unlink: 264| 2.03k|{ 265| 2.03k| struct bufferevent_pair *bev_p = upcast(bev); 266| | 267| 2.03k| if (bev_p->partner) { ------------------ | Branch (267:6): [True: 1.01k, False: 1.01k] ------------------ 268| 1.01k| bev_p->unlinked_partner = bev_p->partner; 269| 1.01k| bev_p->partner->partner = NULL; 270| | bev_p->partner = NULL; 271| 1.01k| } 272| 2.03k|} bufferevent_pair.c:be_pair_destruct: 277| 2.03k|{ 278| 2.03k| 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| 2.03k| if (bev_p->unlinked_partner && bev_p->bev.own_lock) { ------------------ | Branch (295:6): [True: 1.01k, False: 1.01k] | Branch (295:33): [True: 0, False: 1.01k] ------------------ 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| 2.03k|} bufferevent_ratelim_init_: 1102| 2.03k|{ 1103| 2.03k| bev->rate_limiting = NULL; 1104| 2.03k| bev->max_single_read = MAX_SINGLE_READ_DEFAULT; ------------------ | | 199| 2.03k|#define MAX_SINGLE_READ_DEFAULT 16384 ------------------ 1105| 2.03k| bev->max_single_write = MAX_SINGLE_WRITE_DEFAULT; ------------------ | | 200| 2.03k|#define MAX_SINGLE_WRITE_DEFAULT 16384 ------------------ 1106| | 1107| 2.03k| if (evbuffer_set_max_read(bev->bev.input, bev->max_single_read)) ------------------ | Branch (1107:6): [True: 0, False: 2.03k] ------------------ 1108| 0| return -1; 1109| | 1110| 2.03k| return 0; 1111| 2.03k|} epoll.c:epoll_init: 175| 1.01k|{ 176| 1.01k| epoll_handle epfd = INVALID_EPOLL_HANDLE; ------------------ | | 100| 1.01k|#define INVALID_EPOLL_HANDLE -1 ------------------ 177| 1.01k| struct epollop *epollop; 178| | 179| 1.01k|#ifdef EVENT__HAVE_EPOLL_CREATE1 180| | /* First, try the shiny new epoll_create1 interface, if we have it. */ 181| 1.01k| epfd = epoll_create1(EPOLL_CLOEXEC); 182| 1.01k|#endif 183| 1.01k| if (epfd == INVALID_EPOLL_HANDLE) { ------------------ | | 100| 1.01k|#define INVALID_EPOLL_HANDLE -1 ------------------ | Branch (183:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| if (!(epollop = mm_calloc(1, sizeof(struct epollop)))) { ------------------ | | 77| 1.01k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ | Branch (196:6): [True: 0, False: 1.01k] ------------------ 197| 0| close_epoll_handle(epfd); 198| 0| return (NULL); 199| 0| } 200| | 201| 1.01k| epollop->epfd = epfd; 202| | 203| | /* Initialize fields */ 204| 1.01k| epollop->events = mm_calloc(INITIAL_NEVENT, sizeof(struct epoll_event)); ------------------ | | 77| 1.01k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ 205| 1.01k| if (epollop->events == NULL) { ------------------ | Branch (205:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| epollop->nevents = INITIAL_NEVENT; ------------------ | | 162| 1.01k|#define INITIAL_NEVENT 32 ------------------ 211| | 212| 1.01k|#ifndef EVENT__HAVE_WEPOLL 213| 1.01k| if ((base->flags & EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST) != 0 || ------------------ | Branch (213:6): [True: 0, False: 1.01k] ------------------ 214| 1.01k| ((base->flags & EVENT_BASE_FLAG_IGNORE_ENV) == 0 && ------------------ | Branch (214:7): [True: 1.01k, False: 0] ------------------ 215| 1.01k| evutil_getenv_("EVENT_EPOLL_USE_CHANGELIST") != NULL)) { ------------------ | Branch (215:3): [True: 0, False: 1.01k] ------------------ 216| | 217| 0| base->evsel = &epollops_changelist; 218| 0| } 219| 1.01k|#endif 220| | 221| 1.01k|#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| 1.01k| if ((base->flags & EVENT_BASE_FLAG_PRECISE_TIMER) && ------------------ | Branch (228:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| } else { 254| 1.01k| epollop->timerfd = -1; 255| 1.01k| } 256| 1.01k|#endif 257| | 258| 1.01k| if (sigfd_init_(base) < 0) ------------------ | Branch (258:6): [True: 1.01k, False: 0] ------------------ 259| 1.01k| evsig_init_(base); 260| | 261| 1.01k| return (epollop); 262| 1.01k|} epoll.c:close_epoll_handle: 101| 1.01k|static void close_epoll_handle(int h) { close(h); } epoll.c:epoll_dispatch: 461| 1.01k|{ 462| 1.01k| struct epollop *epollop = base->evbase; 463| 1.01k| struct epoll_event *events = epollop->events; 464| 1.01k| int i, res; 465| |#if defined(EVENT__HAVE_EPOLL_PWAIT2) 466| | struct timespec ts = { 0, 0 }; 467| |#else /* no epoll_pwait2() */ 468| 1.01k| long timeout = -1; 469| 1.01k|#endif /* EVENT__HAVE_EPOLL_PWAIT2 */ 470| | 471| 1.01k|#ifdef USING_TIMERFD 472| 1.01k| if (epollop->timerfd >= 0) { ------------------ | Branch (472:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k|#endif 498| 1.01k| if (tv != NULL) { ------------------ | Branch (498:6): [True: 1.01k, False: 0] ------------------ 499| |#if defined(EVENT__HAVE_EPOLL_PWAIT2) 500| | TIMEVAL_TO_TIMESPEC(tv, &ts); 501| |#else /* no epoll_pwait2() */ 502| 1.01k| timeout = evutil_tv_to_msec_(tv); 503| 1.01k| if (timeout < 0 || timeout > MAX_EPOLL_TIMEOUT_MSEC) { ------------------ | | 171| 1.01k|#define MAX_EPOLL_TIMEOUT_MSEC (35*60*1000) ------------------ | Branch (503:7): [True: 0, False: 1.01k] | Branch (503:22): [True: 0, False: 1.01k] ------------------ 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| 1.01k|#endif /* EVENT__HAVE_EPOLL_PWAIT2 */ 509| 1.01k| } 510| | 511| 1.01k| epoll_apply_changes(base); 512| 1.01k| event_changelist_remove_all_(&base->changelist, base); 513| | 514| 1.01k| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 1.01k|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 1.01k| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 1.01k| do { \ | | | | 102| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 103| 1.01k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ | | 125| 1.01k| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 1.01k] | | ------------------ ------------------ 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| 1.01k| res = epoll_wait(epollop->epfd, events, epollop->nevents, timeout); 520| 1.01k|#endif /* EVENT__HAVE_EPOLL_PWAIT2 */ 521| | 522| 1.01k| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 1.01k|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 1.01k| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 1.01k| do { \ | | | | 95| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 96| 1.01k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ | | 120| 1.01k| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 1.01k] | | ------------------ ------------------ 523| | 524| 1.01k| if (res == -1) { ------------------ | Branch (524:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| event_debug(("%s: epoll_wait reports %d", __func__, res)); ------------------ | | 79| 1.01k|#define event_debug(x) do { \ | | 80| 1.01k| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 1.01k|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 1.01k] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 1.01k| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 1.01k] | | ------------------ ------------------ 534| 1.01k| EVUTIL_ASSERT(res <= epollop->nevents); ------------------ | | 368| 1.01k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 1.01k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 1.01k| (void)sizeof(!(condition)); \ | | | | 98| 1.01k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ ------------------ 535| | 536| 1.01k| for (i = 0; i < res; i++) { ------------------ | Branch (536:14): [True: 0, False: 1.01k] ------------------ 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| 1.01k| if (res == epollop->nevents && epollop->nevents < MAX_NEVENT) { ------------------ | | 163| 0|#define MAX_NEVENT 4096 ------------------ | Branch (567:6): [True: 0, False: 1.01k] | 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| 1.01k| return (0); 582| 1.01k|} epoll.c:epoll_apply_changes: 400| 1.01k|{ 401| 1.01k| struct event_changelist *changelist = &base->changelist; 402| 1.01k| struct epollop *epollop = base->evbase; 403| 1.01k| struct event_change *ch; 404| | 405| 1.01k| int r = 0; 406| 1.01k| int i; 407| | 408| 1.01k| for (i = 0; i < changelist->n_changes; ++i) { ------------------ | Branch (408:14): [True: 0, False: 1.01k] ------------------ 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| 1.01k| return (r); 415| 1.01k|} epoll.c:epoll_dealloc: 587| 1.01k|{ 588| 1.01k| struct epollop *epollop = base->evbase; 589| | 590| 1.01k| evsig_dealloc_(base); 591| 1.01k| if (epollop->events) ------------------ | Branch (591:6): [True: 1.01k, False: 0] ------------------ 592| 1.01k| mm_free(epollop->events); ------------------ | | 80| 1.01k|#define mm_free(p) event_mm_free_(p) ------------------ 593| 1.01k| if (epollop->epfd != INVALID_EPOLL_HANDLE) ------------------ | | 100| 1.01k|#define INVALID_EPOLL_HANDLE -1 ------------------ | Branch (593:6): [True: 1.01k, False: 0] ------------------ 594| 1.01k| close_epoll_handle(epollop->epfd); 595| 1.01k|#ifdef USING_TIMERFD 596| 1.01k| if (epollop->timerfd >= 0) ------------------ | Branch (596:6): [True: 0, False: 1.01k] ------------------ 597| 0| close(epollop->timerfd); 598| 1.01k|#endif 599| | 600| 1.01k| memset(epollop, 0, sizeof(struct epollop)); 601| 1.01k| mm_free(epollop); ------------------ | | 80| 1.01k|#define mm_free(p) event_mm_free_(p) ------------------ 602| 1.01k|} event_base_new: 541| 1.01k|{ 542| 1.01k| struct event_base *base = NULL; 543| 1.01k| struct event_config *cfg = event_config_new(); 544| 1.01k| if (cfg) { ------------------ | Branch (544:6): [True: 1.01k, False: 0] ------------------ 545| 1.01k| base = event_base_new_with_config(cfg); 546| 1.01k| event_config_free(cfg); 547| 1.01k| } 548| 1.01k| return base; 549| 1.01k|} event_base_new_with_config: 626| 1.01k|{ 627| 1.01k| int i; 628| 1.01k| struct event_base *base; 629| 1.01k| int should_check_environment; 630| | /* event_base_new_with_config() should always be first to set event_debug_mode_too_late */ 631| 1.01k|#ifndef EVENT__DISABLE_DEBUG_MODE 632| 1.01k| EVLOCK_LOCK(event_debug_map_lock_, 0); ------------------ | | 94| 1.01k| do { \ | | 95| 1.01k| if (lockvar) \ | | ------------------ | | | Branch (95:7): [True: 0, False: 1.01k] | | ------------------ | | 96| 1.01k| evthread_lock_fns_.lock(mode, lockvar); \ | | 97| 1.01k| } while (0) | | ------------------ | | | Branch (97:11): [Folded, False: 1.01k] | | ------------------ ------------------ 633| 1.01k| if (!event_debug_mode_too_late) ------------------ | Branch (633:6): [True: 1, False: 1.01k] ------------------ 634| 1| event_debug_mode_too_late = 1; 635| 1.01k| EVLOCK_UNLOCK(event_debug_map_lock_, 0); ------------------ | | 101| 1.01k| do { \ | | 102| 1.01k| if (lockvar) \ | | ------------------ | | | Branch (102:7): [True: 0, False: 1.01k] | | ------------------ | | 103| 1.01k| evthread_lock_fns_.unlock(mode, lockvar); \ | | 104| 1.01k| } while (0) | | ------------------ | | | Branch (104:11): [Folded, False: 1.01k] | | ------------------ ------------------ 636| 1.01k|#endif 637| | 638| 1.01k| if ((base = mm_calloc(1, sizeof(struct event_base))) == NULL) { ------------------ | | 77| 1.01k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ | Branch (638:6): [True: 0, False: 1.01k] ------------------ 639| 0| event_warn("%s: calloc", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 640| 0| return NULL; 641| 0| } 642| | 643| 1.01k| if (cfg) ------------------ | Branch (643:6): [True: 1.01k, False: 0] ------------------ 644| 1.01k| base->flags = cfg->flags; 645| | 646| 1.01k| should_check_environment = 647| 1.01k| !(cfg && (cfg->flags & EVENT_BASE_FLAG_IGNORE_ENV)); ------------------ | Branch (647:8): [True: 1.01k, False: 0] | Branch (647:15): [True: 0, False: 1.01k] ------------------ 648| | 649| 1.01k| { 650| 1.01k| struct timeval tmp; 651| 1.01k| int precise_time = 652| 1.01k| cfg && (cfg->flags & EVENT_BASE_FLAG_PRECISE_TIMER); ------------------ | Branch (652:7): [True: 1.01k, False: 0] | Branch (652:14): [True: 0, False: 1.01k] ------------------ 653| 1.01k| int flags; 654| 1.01k| if (should_check_environment && !precise_time) { ------------------ | Branch (654:7): [True: 1.01k, False: 0] | Branch (654:35): [True: 1.01k, False: 0] ------------------ 655| 1.01k| precise_time = evutil_getenv_("EVENT_PRECISE_TIMER") != NULL; 656| 1.01k| if (precise_time) { ------------------ | Branch (656:8): [True: 0, False: 1.01k] ------------------ 657| 0| base->flags |= EVENT_BASE_FLAG_PRECISE_TIMER; 658| 0| } 659| 1.01k| } 660| 1.01k| flags = precise_time ? EV_MONOT_PRECISE : 0; ------------------ | | 346| 0|#define EV_MONOT_PRECISE 1 ------------------ | Branch (660:11): [True: 0, False: 1.01k] ------------------ 661| 1.01k| evutil_configure_monotonic_time_(&base->monotonic_timer, flags); 662| | 663| 1.01k| gettime(base, &tmp); 664| 1.01k| } 665| | 666| 1.01k| min_heap_ctor_(&base->timeheap); 667| | 668| 1.01k| base->sig.ev_signal_pair[0] = -1; 669| 1.01k| base->sig.ev_signal_pair[1] = -1; 670| 1.01k| base->th_notify_fd[0] = -1; 671| 1.01k| base->th_notify_fd[1] = -1; 672| | 673| 1.01k| TAILQ_INIT(&base->active_later_queue); ------------------ | | 317| 1.01k|#define TAILQ_INIT(head) do { \ | | 318| 1.01k| (head)->tqh_first = NULL; \ | | 319| 1.01k| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 1.01k|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 1.01k] | | ------------------ ------------------ 674| | 675| 1.01k| evmap_io_initmap_(&base->io); 676| 1.01k| evmap_signal_initmap_(&base->sigmap); 677| 1.01k| event_changelist_init_(&base->changelist); 678| | 679| 1.01k| base->evbase = NULL; 680| | 681| 1.01k| if (cfg) { ------------------ | Branch (681:6): [True: 1.01k, False: 0] ------------------ 682| 1.01k| memcpy(&base->max_dispatch_time, 683| 1.01k| &cfg->max_dispatch_interval, sizeof(struct timeval)); 684| 1.01k| base->limit_callbacks_after_prio = 685| 1.01k| cfg->limit_callbacks_after_prio; 686| 1.01k| } else { 687| 0| base->max_dispatch_time.tv_sec = -1; 688| 0| base->limit_callbacks_after_prio = 1; 689| 0| } 690| 1.01k| if (cfg && cfg->max_dispatch_callbacks >= 0) { ------------------ | Branch (690:6): [True: 1.01k, False: 0] | Branch (690:13): [True: 1.01k, False: 0] ------------------ 691| 1.01k| base->max_dispatch_callbacks = cfg->max_dispatch_callbacks; 692| 1.01k| } else { 693| 0| base->max_dispatch_callbacks = INT_MAX; 694| 0| } 695| 1.01k| if (base->max_dispatch_callbacks == INT_MAX && ------------------ | Branch (695:6): [True: 1.01k, False: 0] ------------------ 696| 1.01k| base->max_dispatch_time.tv_sec == -1) ------------------ | Branch (696:6): [True: 1.01k, False: 0] ------------------ 697| 1.01k| base->limit_callbacks_after_prio = INT_MAX; 698| | 699| 2.03k| for (i = 0; eventops[i] && !base->evbase; i++) { ------------------ | Branch (699:14): [True: 2.03k, False: 0] | Branch (699:29): [True: 1.01k, False: 1.01k] ------------------ 700| 1.01k| if (cfg != NULL) { ------------------ | Branch (700:7): [True: 1.01k, False: 0] ------------------ 701| | /* determine if this backend should be avoided */ 702| 1.01k| if (event_config_is_avoided_method(cfg, ------------------ | Branch (702:8): [True: 0, False: 1.01k] ------------------ 703| 1.01k| eventops[i]->name)) 704| 0| continue; 705| 1.01k| if ((eventops[i]->features & cfg->require_features) ------------------ | Branch (705:8): [True: 0, False: 1.01k] ------------------ 706| 1.01k| != cfg->require_features) 707| 0| continue; 708| 1.01k| } 709| | 710| | /* also obey the environment variables */ 711| 1.01k| if (should_check_environment && ------------------ | Branch (711:7): [True: 1.01k, False: 0] ------------------ 712| 1.01k| event_is_method_disabled(eventops[i]->name)) ------------------ | Branch (712:7): [True: 0, False: 1.01k] ------------------ 713| 0| continue; 714| | 715| 1.01k| base->evsel = eventops[i]; 716| | 717| 1.01k| base->evbase = base->evsel->init(base); 718| 1.01k| } 719| | 720| 1.01k| if (base->evbase == NULL) { ------------------ | Branch (720:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| if (evutil_getenv_("EVENT_SHOW_METHOD")) ------------------ | Branch (728:6): [True: 0, False: 1.01k] ------------------ 729| 0| event_msgx("libevent using: %s", base->evsel->name); 730| | 731| | /* allocate a single active event queue */ 732| 1.01k| if (event_base_priority_init(base, 1) < 0) { ------------------ | Branch (732:6): [True: 0, False: 1.01k] ------------------ 733| 0| event_base_free(base); 734| 0| return NULL; 735| 0| } 736| | 737| | /* prepare for threading */ 738| | 739| 1.01k|#if !defined(EVENT__DISABLE_THREAD_SUPPORT) && !defined(EVENT__DISABLE_DEBUG_MODE) 740| 1.01k| event_debug_created_threadable_ctx_ = 1; 741| 1.01k|#endif 742| | 743| 1.01k|#ifndef EVENT__DISABLE_THREAD_SUPPORT 744| 1.01k| if (EVTHREAD_LOCKING_ENABLED() && ------------------ | | 183| 2.03k| (evthread_lock_fns_.lock != NULL) | | ------------------ | | | Branch (183:2): [True: 0, False: 1.01k] | | ------------------ ------------------ 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| 1.01k|#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| 3.05k| for (i = 0; i < EVWATCH_MAX; ++i) ------------------ | | 229| 3.05k|#define EVWATCH_MAX 2 ------------------ | Branch (764:14): [True: 2.03k, False: 1.01k] ------------------ 765| 2.03k| TAILQ_INIT(&base->watchers[i]); ------------------ | | 317| 3.05k|#define TAILQ_INIT(head) do { \ | | 318| 2.03k| (head)->tqh_first = NULL; \ | | 319| 2.03k| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 2.03k|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 2.03k] | | ------------------ ------------------ 766| | 767| 1.01k| return (base); 768| 1.01k|} event_base_free: 994| 1.01k|{ 995| 1.01k| event_base_free_(base, 1); 996| 1.01k|} event_config_new: 1175| 1.01k|{ 1176| 1.01k| struct event_config *cfg = mm_calloc(1, sizeof(*cfg)); ------------------ | | 77| 1.01k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ 1177| | 1178| 1.01k| if (cfg == NULL) ------------------ | Branch (1178:6): [True: 0, False: 1.01k] ------------------ 1179| 0| return (NULL); 1180| | 1181| 1.01k| TAILQ_INIT(&cfg->entries); ------------------ | | 317| 1.01k|#define TAILQ_INIT(head) do { \ | | 318| 1.01k| (head)->tqh_first = NULL; \ | | 319| 1.01k| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 1.01k|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 1.01k] | | ------------------ ------------------ 1182| 1.01k| cfg->max_dispatch_interval.tv_sec = -1; 1183| 1.01k| cfg->max_dispatch_callbacks = INT_MAX; 1184| 1.01k| cfg->limit_callbacks_after_prio = 1; 1185| | 1186| 1.01k| return (cfg); 1187| 1.01k|} event_config_free: 1199| 1.01k|{ 1200| 1.01k| struct event_config_entry *entry; 1201| | 1202| 1.01k| while ((entry = TAILQ_FIRST(&cfg->entries)) != NULL) { ------------------ | | 293| 1.01k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (1202:9): [True: 0, False: 1.01k] ------------------ 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| 1.01k| mm_free(cfg); ------------------ | | 80| 1.01k|#define mm_free(p) event_mm_free_(p) ------------------ 1207| 1.01k|} event_base_priority_init: 1279| 1.01k|{ 1280| 1.01k| int i, r; 1281| 1.01k| r = -1; 1282| | 1283| 1.01k| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 1.01k|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 1.01k| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 1.01k| do { \ | | | | 95| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 96| 1.01k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ | | 120| 1.01k| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 1.01k] | | ------------------ ------------------ 1284| | 1285| 1.01k| if (N_ACTIVE_CALLBACKS(base) || npriorities < 1 ------------------ | | 451| 2.03k| ((base)->event_count_active) | | ------------------ | | | Branch (451:2): [True: 0, False: 1.01k] | | ------------------ ------------------ | Branch (1285:34): [True: 0, False: 1.01k] ------------------ 1286| 1.01k| || npriorities >= EVENT_MAX_PRIORITIES) ------------------ | | 1477| 1.01k|#define EVENT_MAX_PRIORITIES 256 ------------------ | Branch (1286:9): [True: 0, False: 1.01k] ------------------ 1287| 0| goto err; 1288| | 1289| 1.01k| if (npriorities == base->nactivequeues) ------------------ | Branch (1289:6): [True: 0, False: 1.01k] ------------------ 1290| 0| goto ok; 1291| | 1292| 1.01k| if (base->nactivequeues) { ------------------ | Branch (1292:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| base->activequeues = (struct evcallback_list *) 1299| 1.01k| mm_calloc(npriorities, sizeof(struct evcallback_list)); ------------------ | | 77| 1.01k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ 1300| 1.01k| if (base->activequeues == NULL) { ------------------ | Branch (1300:6): [True: 0, False: 1.01k] ------------------ 1301| 0| event_warn("%s: calloc", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 1302| 0| goto err; 1303| 0| } 1304| 1.01k| base->nactivequeues = npriorities; 1305| | 1306| 2.03k| for (i = 0; i < base->nactivequeues; ++i) { ------------------ | Branch (1306:14): [True: 1.01k, False: 1.01k] ------------------ 1307| 1.01k| TAILQ_INIT(&base->activequeues[i]); ------------------ | | 317| 1.01k|#define TAILQ_INIT(head) do { \ | | 318| 1.01k| (head)->tqh_first = NULL; \ | | 319| 1.01k| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 1.01k|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 1.01k] | | ------------------ ------------------ 1308| 1.01k| } 1309| | 1310| 1.01k|ok: 1311| 1.01k| r = 0; 1312| 1.01k|err: 1313| 1.01k| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 1.01k|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 1.01k| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 1.01k| do { \ | | | | 102| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 103| 1.01k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ | | 125| 1.01k| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 1.01k] | | ------------------ ------------------ 1314| 1.01k| return (r); 1315| 1.01k|} event_base_get_npriorities: 1319| 2.03k|{ 1320| | 1321| 2.03k| int n; 1322| 2.03k| if (base == NULL) ------------------ | Branch (1322:6): [True: 0, False: 2.03k] ------------------ 1323| 0| base = current_base; ------------------ | | 138| 0|#define current_base event_global_current_base_ ------------------ 1324| | 1325| 2.03k| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 2.03k|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 2.03k| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 2.03k| do { \ | | | | 95| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 96| 2.03k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 120| 2.03k| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 2.03k] | | ------------------ ------------------ 1326| 2.03k| n = base->nactivequeues; 1327| 2.03k| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 2.03k|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 2.03k| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 2.03k| do { \ | | | | 102| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 103| 2.03k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 125| 2.03k| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 2.03k] | | ------------------ ------------------ 1328| 2.03k| return (n); 1329| 2.03k|} event_base_loop: 1992| 1.01k|{ 1993| 1.01k| const struct eventop *evsel = base->evsel; 1994| 1.01k| struct timeval *tv_p; 1995| 1.01k| int res, done, retval = 0; 1996| 1.01k| struct evwatch_prepare_cb_info prepare_info; 1997| 1.01k| struct evwatch_check_cb_info check_info = { NULL }; 1998| 1.01k| 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| 1.01k| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 1.01k|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 1.01k| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 1.01k| do { \ | | | | 95| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 96| 1.01k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ | | 120| 1.01k| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 1.01k] | | ------------------ ------------------ 2003| | 2004| 1.01k| if (base->running_loop) { ------------------ | Branch (2004:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| base->running_loop = 1; 2012| | 2013| 1.01k| clear_time_cache(base); 2014| | 2015| 1.01k| if (base->sig.ev_signal_added && base->sig.ev_n_signals_added) ------------------ | Branch (2015:6): [True: 0, False: 1.01k] | Branch (2015:35): [True: 0, False: 0] ------------------ 2016| 0| evsig_set_base_(base); 2017| | 2018| 1.01k| done = 0; 2019| | 2020| 1.01k|#ifndef EVENT__DISABLE_THREAD_SUPPORT 2021| 1.01k| base->th_owner_id = EVTHREAD_GET_ID(); ------------------ | | 62| 1.01k| (evthread_id_fn_ ? evthread_id_fn_() : 1) | | ------------------ | | | Branch (62:3): [True: 0, False: 1.01k] | | ------------------ ------------------ 2022| 1.01k|#endif 2023| | 2024| 1.01k| base->event_gotterm = base->event_break = 0; 2025| | 2026| 2.03k| while (!done) { ------------------ | Branch (2026:9): [True: 2.03k, False: 0] ------------------ 2027| 2.03k| struct timeval tv; 2028| | 2029| 2.03k| base->event_continue = 0; 2030| 2.03k| base->n_deferreds_queued = 0; 2031| | 2032| | /* Terminate the loop if we have been asked to */ 2033| 2.03k| if (base->event_gotterm) { ------------------ | Branch (2033:7): [True: 0, False: 2.03k] ------------------ 2034| 0| break; 2035| 0| } 2036| | 2037| 2.03k| if (base->event_break) { ------------------ | Branch (2037:7): [True: 0, False: 2.03k] ------------------ 2038| 0| break; 2039| 0| } 2040| | 2041| 2.03k| tv_p = &tv; 2042| 2.03k| if (!N_ACTIVE_CALLBACKS(base) && !(flags & EVLOOP_NONBLOCK)) { ------------------ | | 451| 4.06k| ((base)->event_count_active) ------------------ if (!N_ACTIVE_CALLBACKS(base) && !(flags & EVLOOP_NONBLOCK)) { ------------------ | | 832| 1.01k|#define EVLOOP_NONBLOCK 0x02 ------------------ | Branch (2042:7): [True: 1.01k, False: 1.01k] | Branch (2042:36): [True: 0, False: 1.01k] ------------------ 2043| 0| timeout_next(base, &tv_p); 2044| 2.03k| } else { 2045| | /* 2046| | * if we have active events, we just poll new events 2047| | * without waiting. 2048| | */ 2049| 2.03k| evutil_timerclear(&tv); ------------------ | | 604| 2.03k|#define evutil_timerclear(tvp) timerclear(tvp) ------------------ 2050| 2.03k| } 2051| | 2052| | /* If we have no events, we just exit */ 2053| 2.03k| if (0==(flags&EVLOOP_NO_EXIT_ON_EMPTY) && ------------------ | | 837| 2.03k|#define EVLOOP_NO_EXIT_ON_EMPTY 0x04 ------------------ | Branch (2053:7): [True: 2.03k, False: 0] ------------------ 2054| 2.03k| !event_haveevents(base) && !N_ACTIVE_CALLBACKS(base)) { ------------------ | | 451| 1.01k| ((base)->event_count_active) ------------------ | Branch (2054:7): [True: 1.01k, False: 1.01k] | Branch (2054:34): [True: 1.01k, False: 0] ------------------ 2055| 1.01k| event_debug(("%s: no events registered.", __func__)); ------------------ | | 79| 1.01k|#define event_debug(x) do { \ | | 80| 1.01k| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 1.01k|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 1.01k] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 1.01k| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 1.01k] | | ------------------ ------------------ 2056| 1.01k| retval = 1; 2057| 1.01k| goto done; 2058| 1.01k| } 2059| | 2060| 1.01k| event_queue_make_later_events_active(base); 2061| | 2062| | /* Invoke prepare watchers before polling for events */ 2063| 1.01k| prepare_info.timeout = tv_p; 2064| 1.01k| TAILQ_FOREACH(watcher, &base->watchers[EVWATCH_PREPARE], next) { ------------------ | | 305| 1.01k| for((var) = TAILQ_FIRST(head); \ | | ------------------ | | | | 293| 1.01k|#define TAILQ_FIRST(head) ((head)->tqh_first) | | ------------------ | | 306| 1.01k| (var) != TAILQ_END(head); \ | | ------------------ | | | | 294| 1.01k|#define TAILQ_END(head) NULL | | ------------------ | | | Branch (306:6): [True: 0, False: 1.01k] | | ------------------ | | 307| 1.01k| (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| 1.01k| clear_time_cache(base); 2071| | 2072| 1.01k| res = evsel->dispatch(base, tv_p); 2073| | 2074| 1.01k| if (res == -1) { ------------------ | Branch (2074:7): [True: 0, False: 1.01k] ------------------ 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| 1.01k| update_time_cache(base); 2082| | 2083| | /* Invoke check watchers after polling for events, and before 2084| | * processing them */ 2085| 1.01k| TAILQ_FOREACH(watcher, &base->watchers[EVWATCH_CHECK], next) { ------------------ | | 305| 1.01k| for((var) = TAILQ_FIRST(head); \ | | ------------------ | | | | 293| 1.01k|#define TAILQ_FIRST(head) ((head)->tqh_first) | | ------------------ | | 306| 1.01k| (var) != TAILQ_END(head); \ | | ------------------ | | | | 294| 1.01k|#define TAILQ_END(head) NULL | | ------------------ | | | Branch (306:6): [True: 0, False: 1.01k] | | ------------------ | | 307| 1.01k| (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| 1.01k| timeout_process(base); 2092| | 2093| 1.01k| if (N_ACTIVE_CALLBACKS(base)) { ------------------ | | 451| 1.01k| ((base)->event_count_active) | | ------------------ | | | Branch (451:2): [True: 1.01k, False: 0] | | ------------------ ------------------ 2094| 1.01k| int n = event_process_active(base); 2095| 1.01k| if ((flags & EVLOOP_ONCE) ------------------ | | 829| 1.01k|#define EVLOOP_ONCE 0x01 ------------------ | Branch (2095:8): [True: 0, False: 1.01k] ------------------ 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| 1.01k| } else if (flags & EVLOOP_NONBLOCK) ------------------ | | 832| 0|#define EVLOOP_NONBLOCK 0x02 ------------------ | Branch (2099:14): [True: 0, False: 0] ------------------ 2100| 0| done = 1; 2101| 1.01k| } 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| 1.01k|done: 2105| 1.01k| clear_time_cache(base); 2106| 1.01k| base->running_loop = 0; 2107| | 2108| 1.01k| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 1.01k|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 1.01k| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 1.01k| do { \ | | | | 102| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 103| 1.01k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ | | 125| 1.01k| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 1.01k] | | ------------------ ------------------ 2109| | 2110| 1.01k| return (retval); 2111| 0|} event_assign: 2205| 5.08k|{ 2206| 5.08k| if (!base) ------------------ | Branch (2206:6): [True: 0, False: 5.08k] ------------------ 2207| 0| base = current_base; ------------------ | | 138| 0|#define current_base event_global_current_base_ ------------------ 2208| 5.08k| if (arg == &event_self_cbarg_ptr_) ------------------ | Branch (2208:6): [True: 0, False: 5.08k] ------------------ 2209| 0| arg = ev; 2210| | 2211| 5.08k| if (!(events & EV_SIGNAL)) ------------------ | | 961| 5.08k|#define EV_SIGNAL 0x08 ------------------ | Branch (2211:6): [True: 5.08k, False: 0] ------------------ 2212| 5.08k| event_debug_assert_socket_nonblocking_(fd); 2213| 5.08k| event_debug_assert_not_added_(ev); 2214| | 2215| 5.08k| ev->ev_base = base; 2216| | 2217| 5.08k| ev->ev_callback = callback; ------------------ | | 60| 5.08k|#define ev_callback ev_evcallback.evcb_cb_union.evcb_callback ------------------ 2218| 5.08k| ev->ev_arg = arg; ------------------ | | 61| 5.08k|#define ev_arg ev_evcallback.evcb_arg ------------------ 2219| 5.08k| ev->ev_fd = fd; 2220| 5.08k| ev->ev_events = events; 2221| 5.08k| ev->ev_res = 0; 2222| 5.08k| ev->ev_flags = EVLIST_INIT; ------------------ | | 58| 5.08k|#define ev_flags ev_evcallback.evcb_flags ------------------ ev->ev_flags = EVLIST_INIT; ------------------ | | 64| 5.08k|#define EVLIST_INIT 0x80 ------------------ 2223| 5.08k| ev->ev_ncalls = 0; ------------------ | | 54| 5.08k|#define ev_ncalls ev_.ev_signal.ev_ncalls ------------------ 2224| 5.08k| ev->ev_pncalls = NULL; ------------------ | | 55| 5.08k|#define ev_pncalls ev_.ev_signal.ev_pncalls ------------------ 2225| | 2226| 5.08k| if (events & EV_SIGNAL) { ------------------ | | 961| 5.08k|#define EV_SIGNAL 0x08 ------------------ | Branch (2226:6): [True: 0, False: 5.08k] ------------------ 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| 5.08k| } else { 2234| 5.08k| if (events & EV_PERSIST) { ------------------ | | 968| 5.08k|#define EV_PERSIST 0x10 ------------------ | Branch (2234:7): [True: 1.01k, False: 4.06k] ------------------ 2235| 1.01k| evutil_timerclear(&ev->ev_io_timeout); ------------------ | | 604| 1.01k|#define evutil_timerclear(tvp) timerclear(tvp) ------------------ 2236| 1.01k| ev->ev_closure = EV_CLOSURE_EVENT_PERSIST; ------------------ | | 59| 1.01k|#define ev_closure ev_evcallback.evcb_closure ------------------ ev->ev_closure = EV_CLOSURE_EVENT_PERSIST; ------------------ | | 74| 1.01k|#define EV_CLOSURE_EVENT_PERSIST 2 ------------------ 2237| 4.06k| } else { 2238| 4.06k| ev->ev_closure = EV_CLOSURE_EVENT; ------------------ | | 59| 4.06k|#define ev_closure ev_evcallback.evcb_closure ------------------ ev->ev_closure = EV_CLOSURE_EVENT; ------------------ | | 70| 4.06k|#define EV_CLOSURE_EVENT 0 ------------------ 2239| 4.06k| } 2240| 5.08k| } 2241| | 2242| 5.08k| min_heap_elem_init_(ev); 2243| | 2244| 5.08k| if (base != NULL) { ------------------ | Branch (2244:6): [True: 5.08k, False: 0] ------------------ 2245| | /* by default, we put new events into the middle priority */ 2246| 5.08k| ev->ev_pri = base->nactivequeues / 2; ------------------ | | 57| 5.08k|#define ev_pri ev_evcallback.evcb_pri ------------------ 2247| 5.08k| } 2248| | 2249| 5.08k| event_debug_note_setup_(ev); 2250| | 2251| 5.08k| return 0; 2252| 5.08k|} event_debug_unassign: 2329| 1.01k|{ 2330| 1.01k| event_debug_assert_not_added_(ev); 2331| 1.01k| event_debug_note_teardown_(ev); 2332| | 2333| 1.01k| ev->ev_flags &= ~EVLIST_INIT; ------------------ | | 58| 1.01k|#define ev_flags ev_evcallback.evcb_flags ------------------ ev->ev_flags &= ~EVLIST_INIT; ------------------ | | 64| 1.01k|#define EVLIST_INIT 0x80 ------------------ 2334| 1.01k|} event_callback_finalize_nolock_: 2381| 2.03k|{ 2382| 2.03k| struct event *ev = NULL; 2383| 2.03k| if (evcb->evcb_flags & EVLIST_INIT) { ------------------ | | 64| 2.03k|#define EVLIST_INIT 0x80 ------------------ | Branch (2383:6): [True: 2.03k, False: 0] ------------------ 2384| 2.03k| ev = event_callback_to_event(evcb); 2385| 2.03k| event_del_nolock_(ev, EVENT_DEL_NOBLOCK); ------------------ | | 461| 2.03k|#define EVENT_DEL_NOBLOCK 0 ------------------ 2386| 2.03k| } else { 2387| 0| event_callback_cancel_nolock_(base, evcb, 0); /*XXX can this fail?*/ 2388| 0| } 2389| | 2390| 2.03k| evcb->evcb_closure = EV_CLOSURE_CB_FINALIZE; ------------------ | | 78| 2.03k|#define EV_CLOSURE_CB_FINALIZE 4 ------------------ 2391| 2.03k| evcb->evcb_cb_union.evcb_cbfinalize = cb; 2392| 2.03k| event_callback_activate_nolock_(base, evcb); /* XXX can this really fail?*/ 2393| 2.03k| evcb->evcb_flags |= EVLIST_FINALIZING; ------------------ | | 63| 2.03k|#define EVLIST_FINALIZING 0x40 ------------------ 2394| 2.03k|} event_callback_finalize_many_: 2409| 2.03k|{ 2410| 2.03k| int n_pending = 0, i; 2411| | 2412| 2.03k| if (base == NULL) ------------------ | Branch (2412:6): [True: 0, False: 2.03k] ------------------ 2413| 0| base = current_base; ------------------ | | 138| 0|#define current_base event_global_current_base_ ------------------ 2414| | 2415| 2.03k| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 2.03k|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 2.03k| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 2.03k| do { \ | | | | 95| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 96| 2.03k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 120| 2.03k| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 2.03k] | | ------------------ ------------------ 2416| | 2417| 2.03k| event_debug(("%s: %d events finalizing", __func__, n_cbs)); ------------------ | | 79| 2.03k|#define event_debug(x) do { \ | | 80| 2.03k| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 2.03k|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 2.03k] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 2.03k| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 2.03k] | | ------------------ ------------------ 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| 8.13k| for (i = 0; i < n_cbs; ++i) { ------------------ | Branch (2422:14): [True: 6.10k, False: 2.03k] ------------------ 2423| 6.10k| struct event_callback *evcb = evcbs[i]; 2424| 6.10k| if (evcb == base->current_event) { ------------------ | Branch (2424:7): [True: 0, False: 6.10k] ------------------ 2425| 0| event_callback_finalize_nolock_(base, 0, evcb, cb); 2426| 0| ++n_pending; 2427| 6.10k| } else { 2428| 6.10k| event_callback_cancel_nolock_(base, evcb, 0); 2429| 6.10k| } 2430| 6.10k| } 2431| | 2432| 2.03k| if (n_pending == 0) { ------------------ | Branch (2432:6): [True: 2.03k, False: 0] ------------------ 2433| | /* Just do the first one. */ 2434| 2.03k| event_callback_finalize_nolock_(base, 0, evcbs[0], cb); 2435| 2.03k| } 2436| | 2437| 2.03k| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 2.03k|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 2.03k| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 2.03k| do { \ | | | | 102| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 103| 2.03k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 125| 2.03k| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 2.03k] | | ------------------ ------------------ 2438| 2.03k| return 0; 2439| 2.03k|} event_priority_set: 2448| 1.01k|{ 2449| 1.01k| event_debug_assert_is_setup_(ev); 2450| | 2451| 1.01k| if (ev->ev_flags & EVLIST_ACTIVE) ------------------ | | 58| 1.01k|#define ev_flags ev_evcallback.evcb_flags ------------------ if (ev->ev_flags & EVLIST_ACTIVE) ------------------ | | 60| 1.01k|#define EVLIST_ACTIVE 0x08 ------------------ | Branch (2451:6): [True: 0, False: 1.01k] ------------------ 2452| 0| return (-1); 2453| 1.01k| if (pri < 0 || pri >= ev->ev_base->nactivequeues) ------------------ | Branch (2453:6): [True: 0, False: 1.01k] | Branch (2453:17): [True: 1.01k, False: 0] ------------------ 2454| 1.01k| return (-1); 2455| | 2456| 0| ev->ev_pri = pri; ------------------ | | 57| 0|#define ev_pri ev_evcallback.evcb_pri ------------------ 2457| | 2458| 0| return (0); 2459| 1.01k|} event_initialized: 2502| 2.03k|{ 2503| 2.03k| if (!(ev->ev_flags & EVLIST_INIT)) ------------------ | | 58| 2.03k|#define ev_flags ev_evcallback.evcb_flags ------------------ if (!(ev->ev_flags & EVLIST_INIT)) ------------------ | | 64| 2.03k|#define EVLIST_INIT 0x80 ------------------ | Branch (2503:6): [True: 1.01k, False: 1.01k] ------------------ 2504| 1.01k| return 0; 2505| | 2506| 1.01k| return 1; 2507| 2.03k|} event_get_priority: 2569| 1.01k|{ 2570| 1.01k| event_debug_assert_is_setup_(ev); 2571| 1.01k| return ev->ev_pri; ------------------ | | 57| 1.01k|#define ev_pri ev_evcallback.evcb_pri ------------------ 2572| 1.01k|} event_del_nolock_: 2918| 8.13k|{ 2919| 8.13k| struct event_base *base; 2920| 8.13k| int res = 0, notify = 0; 2921| | 2922| 8.13k| event_debug(("event_del: %p (fd "EV_SOCK_FMT"), callback %p", ------------------ | | 79| 8.13k|#define event_debug(x) do { \ | | 80| 8.13k| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 8.13k|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 8.13k] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 8.13k| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 8.13k] | | ------------------ ------------------ 2923| 8.13k| (void *)ev, EV_SOCK_ARG(ev->ev_fd), (void *)ev->ev_callback)); 2924| | 2925| | /* An event without a base has not been added */ 2926| 8.13k| if (ev->ev_base == NULL) ------------------ | Branch (2926:6): [True: 0, False: 8.13k] ------------------ 2927| 0| return (-1); 2928| | 2929| 8.13k| EVENT_BASE_ASSERT_LOCKED(ev->ev_base); ------------------ | | 421| 8.13k| EVLOCK_ASSERT_LOCKED((base)->th_base_lock) | | ------------------ | | | | 130| 8.13k| do { \ | | | | 131| 8.13k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 8.13k] | | | | | 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| 8.13k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 8.13k] | | | | ------------------ | | ------------------ ------------------ 2930| | 2931| 8.13k| if (blocking != EVENT_DEL_EVEN_IF_FINALIZING) { ------------------ | | 472| 8.13k|#define EVENT_DEL_EVEN_IF_FINALIZING 3 ------------------ | Branch (2931:6): [True: 6.10k, False: 2.03k] ------------------ 2932| 6.10k| if (ev->ev_flags & EVLIST_FINALIZING) { ------------------ | | 58| 6.10k|#define ev_flags ev_evcallback.evcb_flags ------------------ if (ev->ev_flags & EVLIST_FINALIZING) { ------------------ | | 63| 6.10k|#define EVLIST_FINALIZING 0x40 ------------------ | Branch (2932:7): [True: 0, False: 6.10k] ------------------ 2933| | /* XXXX Debug */ 2934| 0| return 0; 2935| 0| } 2936| 6.10k| } 2937| | 2938| 8.13k| base = ev->ev_base; 2939| | 2940| 8.13k| EVUTIL_ASSERT(!(ev->ev_flags & ~EVLIST_ALL)); ------------------ | | 368| 8.13k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 8.13k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 8.13k| (void)sizeof(!(condition)); \ | | | | 98| 8.13k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 8.13k] | | | | ------------------ | | ------------------ ------------------ 2941| | 2942| | /* See if we are just active executing this event in a loop */ 2943| 8.13k| if (ev->ev_events & EV_SIGNAL) { ------------------ | | 961| 8.13k|#define EV_SIGNAL 0x08 ------------------ | Branch (2943:6): [True: 0, False: 8.13k] ------------------ 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| 8.13k| if (ev->ev_flags & EVLIST_TIMEOUT) { ------------------ | | 58| 8.13k|#define ev_flags ev_evcallback.evcb_flags ------------------ if (ev->ev_flags & EVLIST_TIMEOUT) { ------------------ | | 57| 8.13k|#define EVLIST_TIMEOUT 0x01 ------------------ | Branch (2950:6): [True: 0, False: 8.13k] ------------------ 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| 8.13k| if (ev->ev_flags & EVLIST_ACTIVE) ------------------ | | 58| 8.13k|#define ev_flags ev_evcallback.evcb_flags ------------------ if (ev->ev_flags & EVLIST_ACTIVE) ------------------ | | 60| 8.13k|#define EVLIST_ACTIVE 0x08 ------------------ | Branch (2957:6): [True: 2.03k, False: 6.10k] ------------------ 2958| 2.03k| event_queue_remove_active(base, event_to_event_callback(ev)); 2959| 6.10k| else if (ev->ev_flags & EVLIST_ACTIVE_LATER) ------------------ | | 58| 6.10k|#define ev_flags ev_evcallback.evcb_flags ------------------ else if (ev->ev_flags & EVLIST_ACTIVE_LATER) ------------------ | | 62| 6.10k|#define EVLIST_ACTIVE_LATER 0x20 ------------------ | Branch (2959:11): [True: 0, False: 6.10k] ------------------ 2960| 0| event_queue_remove_active_later(base, event_to_event_callback(ev)); 2961| | 2962| 8.13k| if (ev->ev_flags & EVLIST_INSERTED) { ------------------ | | 58| 8.13k|#define ev_flags ev_evcallback.evcb_flags ------------------ if (ev->ev_flags & EVLIST_INSERTED) { ------------------ | | 58| 8.13k|#define EVLIST_INSERTED 0x02 ------------------ | Branch (2962:6): [True: 0, False: 8.13k] ------------------ 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| 8.13k| 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: 8.13k, False: 0] | Branch (2980:19): [True: 0, False: 8.13k] ------------------ 2981| 0| evthread_notify_base(base); 2982| | 2983| 8.13k| 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| 8.13k|#ifndef EVENT__DISABLE_THREAD_SUPPORT 2991| 8.13k| if (blocking != EVENT_DEL_NOBLOCK && ------------------ | | 461| 16.2k|#define EVENT_DEL_NOBLOCK 0 ------------------ | Branch (2991:6): [True: 6.10k, False: 2.03k] ------------------ 2992| 6.10k| base->current_event == event_to_event_callback(ev) && ------------------ | Branch (2992:6): [True: 0, False: 6.10k] ------------------ 2993| 0| !EVBASE_IN_THREAD(base) && ------------------ | | 67| 8.13k| (evthread_id_fn_ == NULL || \ | | ------------------ | | | Branch (67:3): [True: 0, False: 0] | | ------------------ | | 68| 8.13k| (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| 8.13k|#endif 2999| | 3000| 8.13k| return (res); 3001| 8.13k|} event_callback_activate_nolock_: 3111| 3.05k|{ 3112| 3.05k| int r = 1; 3113| | 3114| 3.05k| if (evcb->evcb_flags & EVLIST_FINALIZING) ------------------ | | 63| 3.05k|#define EVLIST_FINALIZING 0x40 ------------------ | Branch (3114:6): [True: 0, False: 3.05k] ------------------ 3115| 0| return 0; 3116| | 3117| 3.05k| switch (evcb->evcb_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER)) { ------------------ | | 60| 3.05k|#define EVLIST_ACTIVE 0x08 ------------------ switch (evcb->evcb_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER)) { ------------------ | | 62| 3.05k|#define EVLIST_ACTIVE_LATER 0x20 ------------------ 3118| 0| default: ------------------ | Branch (3118:2): [True: 0, False: 3.05k] ------------------ 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: 3.05k] ------------------ 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: 3.05k] ------------------ 3126| 0| return 0; 3127| 3.05k| case 0: ------------------ | Branch (3127:2): [True: 3.05k, False: 0] ------------------ 3128| 3.05k| break; 3129| 3.05k| } 3130| | 3131| 3.05k| event_queue_insert_active(base, evcb); 3132| | 3133| 3.05k| if (EVBASE_NEED_NOTIFY(base)) ------------------ | | 74| 3.05k| (evthread_id_fn_ != NULL && \ | | ------------------ | | | Branch (74:3): [True: 0, False: 3.05k] | | ------------------ | | 75| 3.05k| (base)->running_loop && \ | | ------------------ | | | Branch (75:6): [True: 0, False: 0] | | ------------------ | | 76| 3.05k| (base)->th_owner_id != evthread_id_fn_()) | | ------------------ | | | Branch (76:6): [True: 0, False: 0] | | ------------------ ------------------ 3134| 0| evthread_notify_base(base); 3135| | 3136| 3.05k| return r; 3137| 3.05k|} event_callback_cancel_: 3163| 1.01k|{ 3164| 1.01k| int r; 3165| 1.01k| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 1.01k|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 1.01k| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 1.01k| do { \ | | | | 95| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 96| 1.01k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ | | 120| 1.01k| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 1.01k] | | ------------------ ------------------ 3166| 1.01k| r = event_callback_cancel_nolock_(base, evcb, 0); 3167| 1.01k| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 1.01k|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 1.01k| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 1.01k| do { \ | | | | 102| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 103| 1.01k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ | | 125| 1.01k| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 1.01k] | | ------------------ ------------------ 3168| 1.01k| return r; 3169| 1.01k|} event_callback_cancel_nolock_: 3174| 7.11k|{ 3175| 7.11k| if ((evcb->evcb_flags & EVLIST_FINALIZING) && !even_if_finalizing) ------------------ | | 63| 7.11k|#define EVLIST_FINALIZING 0x40 ------------------ | Branch (3175:6): [True: 0, False: 7.11k] | Branch (3175:48): [True: 0, False: 0] ------------------ 3176| 0| return 0; 3177| | 3178| 7.11k| if (evcb->evcb_flags & EVLIST_INIT) ------------------ | | 64| 7.11k|#define EVLIST_INIT 0x80 ------------------ | Branch (3178:6): [True: 4.06k, False: 3.05k] ------------------ 3179| 4.06k| return event_del_nolock_(event_callback_to_event(evcb), 3180| 4.06k| 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| 4.06k|#define EVENT_DEL_AUTOBLOCK 2 ------------------ | Branch (3180:7): [True: 0, False: 4.06k] ------------------ 3181| | 3182| 3.05k| switch ((evcb->evcb_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER))) { ------------------ | | 60| 3.05k|#define EVLIST_ACTIVE 0x08 ------------------ switch ((evcb->evcb_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER))) { ------------------ | | 62| 3.05k|#define EVLIST_ACTIVE_LATER 0x20 ------------------ 3183| 0| default: ------------------ | Branch (3183:2): [True: 0, False: 3.05k] ------------------ 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: 3.05k] ------------------ 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: 3.05k] ------------------ 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: 3.05k] ------------------ 3192| 0| event_queue_remove_active_later(base, evcb); 3193| 0| break; 3194| 3.05k| case 0: ------------------ | Branch (3194:2): [True: 3.05k, False: 0] ------------------ 3195| 3.05k| break; 3196| 3.05k| } 3197| | 3198| 3.05k| return 0; 3199| 3.05k|} event_deferred_cb_init_: 3203| 3.05k|{ 3204| 3.05k| memset(cb, 0, sizeof(*cb)); 3205| 3.05k| cb->evcb_cb_union.evcb_selfcb = fn; 3206| 3.05k| cb->evcb_arg = arg; 3207| 3.05k| cb->evcb_pri = priority; 3208| 3.05k| cb->evcb_closure = EV_CLOSURE_CB_SELF; ------------------ | | 76| 3.05k|#define EV_CLOSURE_CB_SELF 3 ------------------ 3209| 3.05k|} event_deferred_cb_cancel_: 3219| 1.01k|{ 3220| 1.01k| if (!base) ------------------ | Branch (3220:6): [True: 0, False: 1.01k] ------------------ 3221| 0| base = current_base; ------------------ | | 138| 0|#define current_base event_global_current_base_ ------------------ 3222| 1.01k| event_callback_cancel_(base, cb); 3223| 1.01k|} event_deferred_cb_schedule_: 3228| 1.01k|{ 3229| 1.01k| int r = 1; 3230| 1.01k| if (!base) ------------------ | Branch (3230:6): [True: 0, False: 1.01k] ------------------ 3231| 0| base = current_base; ------------------ | | 138| 0|#define current_base event_global_current_base_ ------------------ 3232| 1.01k| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 1.01k|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 1.01k| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 1.01k| do { \ | | | | 95| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 96| 1.01k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ | | 120| 1.01k| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 1.01k] | | ------------------ ------------------ 3233| 1.01k| if (base->n_deferreds_queued > MAX_DEFERREDS_QUEUED) { ------------------ | | 3225| 1.01k|#define MAX_DEFERREDS_QUEUED 32 ------------------ | Branch (3233:6): [True: 0, False: 1.01k] ------------------ 3234| 0| r = event_callback_activate_later_nolock_(base, cb); 3235| 1.01k| } else { 3236| 1.01k| r = event_callback_activate_nolock_(base, cb); 3237| 1.01k| if (r) { ------------------ | Branch (3237:7): [True: 1.01k, False: 0] ------------------ 3238| 1.01k| ++base->n_deferreds_queued; 3239| 1.01k| } 3240| 1.01k| } 3241| 1.01k| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 1.01k|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 1.01k| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 1.01k| do { \ | | | | 102| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 103| 1.01k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ | | 125| 1.01k| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 1.01k] | | ------------------ ------------------ 3242| 1.01k| return r; 3243| 1.01k|} event_mm_malloc_: 3592| 28.7k|{ 3593| 28.7k| if (sz == 0) ------------------ | Branch (3593:6): [True: 0, False: 28.7k] ------------------ 3594| 0| return NULL; 3595| | 3596| 28.7k| if (mm_malloc_fn_) ------------------ | Branch (3596:6): [True: 0, False: 28.7k] ------------------ 3597| 0| return mm_malloc_fn_(sz); 3598| 28.7k| else 3599| 28.7k| return malloc(sz); 3600| 28.7k|} event_mm_calloc_: 3604| 47.2k|{ 3605| 47.2k| if (count == 0 || size == 0) ------------------ | Branch (3605:6): [True: 0, False: 47.2k] | Branch (3605:20): [True: 0, False: 47.2k] ------------------ 3606| 0| return NULL; 3607| | 3608| 47.2k| if (mm_malloc_fn_) { ------------------ | Branch (3608:6): [True: 0, False: 47.2k] ------------------ 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| 47.2k| } else { 3617| 47.2k| 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| 47.2k| return p; 3624| 47.2k| } 3625| | 3626| 0|error: 3627| 0| errno = ENOMEM; 3628| | return NULL; 3629| 47.2k|} event_mm_strdup_: 3633| 14.2k|{ 3634| 14.2k| if (!str) { ------------------ | Branch (3634:6): [True: 0, False: 14.2k] ------------------ 3635| 0| errno = EINVAL; 3636| 0| return NULL; 3637| 0| } 3638| | 3639| 14.2k| if (mm_malloc_fn_) { ------------------ | Branch (3639:6): [True: 0, False: 14.2k] ------------------ 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| 14.2k| return strdup(str); 3652| 0|#endif 3653| | 3654| 0|error: 3655| 0| errno = ENOMEM; 3656| | return NULL; 3657| 14.2k|} event_mm_free_: 3670| 90.2k|{ 3671| 90.2k| if (mm_free_fn_) ------------------ | Branch (3671:6): [True: 0, False: 90.2k] ------------------ 3672| 0| mm_free_fn_(ptr); 3673| 90.2k| else 3674| 90.2k| free(ptr); 3675| 90.2k|} event.c:update_time_cache: 488| 1.01k|{ 489| 1.01k| base->tv_cache.tv_sec = 0; 490| 1.01k| if (!(base->flags & EVENT_BASE_FLAG_NO_CACHE_TIME)) ------------------ | Branch (490:6): [True: 1.01k, False: 0] ------------------ 491| 1.01k| gettime(base, &base->tv_cache); 492| 1.01k|} event.c:gettime: 434| 2.03k|{ 435| 2.03k| EVENT_BASE_ASSERT_LOCKED(base); ------------------ | | 421| 2.03k| EVLOCK_ASSERT_LOCKED((base)->th_base_lock) | | ------------------ | | | | 130| 2.03k| do { \ | | | | 131| 2.03k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 2.03k] | | | | | 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.03k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ ------------------ 436| | 437| 2.03k| if (base->tv_cache.tv_sec) { ------------------ | Branch (437:6): [True: 0, False: 2.03k] ------------------ 438| 0| *tp = base->tv_cache; 439| 0| return (0); 440| 0| } 441| | 442| 2.03k| if (evutil_gettime_monotonic_(&base->monotonic_timer, tp) == -1) { ------------------ | Branch (442:6): [True: 0, False: 2.03k] ------------------ 443| 0| return -1; 444| 0| } 445| | 446| 2.03k| if (base->last_updated_clock_diff + CLOCK_SYNC_INTERVAL ------------------ | | 425| 2.03k|#define CLOCK_SYNC_INTERVAL -1 ------------------ | Branch (446:6): [True: 2.03k, False: 0] ------------------ 447| 2.03k| < tp->tv_sec) { 448| 2.03k| struct timeval tv; 449| 2.03k| evutil_gettimeofday(&tv,NULL); ------------------ | | 637| 2.03k|#define evutil_gettimeofday(tv, tz) gettimeofday((tv), (tz)) ------------------ 450| 2.03k| evutil_timersub(&tv, tp, &base->tv_clock_diff); ------------------ | | 581| 2.03k|#define evutil_timersub(tvp, uvp, vvp) timersub((tvp), (uvp), (vvp)) ------------------ | Branch (450:3): [True: 1.99k, False: 40] | Branch (450:3): [Folded, False: 2.03k] ------------------ 451| 2.03k| base->last_updated_clock_diff = tp->tv_sec; 452| 2.03k| } 453| | 454| 2.03k| return 0; 455| 2.03k|} event.c:event_config_is_avoided_method: 556| 1.01k|{ 557| 1.01k| struct event_config_entry *entry; 558| | 559| 1.01k| TAILQ_FOREACH(entry, &cfg->entries, next) { ------------------ | | 305| 1.01k| for((var) = TAILQ_FIRST(head); \ | | ------------------ | | | | 293| 1.01k|#define TAILQ_FIRST(head) ((head)->tqh_first) | | ------------------ | | 306| 1.01k| (var) != TAILQ_END(head); \ | | ------------------ | | | | 294| 1.01k|#define TAILQ_END(head) NULL | | ------------------ | | | Branch (306:6): [True: 0, False: 1.01k] | | ------------------ | | 307| 1.01k| (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| 1.01k| return (0); 566| 1.01k|} event.c:event_is_method_disabled: 571| 1.01k|{ 572| 1.01k| char environment[64]; 573| 1.01k| int i; 574| | 575| 1.01k| evutil_snprintf(environment, sizeof(environment), "EVENT_NO%s", name); 576| 6.10k| for (i = 8; environment[i] != '\0'; ++i) ------------------ | Branch (576:14): [True: 5.08k, False: 1.01k] ------------------ 577| 5.08k| 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| 1.01k|} event.c:event_base_free_: 866| 1.01k|{ 867| 1.01k| int i; 868| 1.01k| size_t n_deleted=0; 869| 1.01k| struct event *ev; 870| 1.01k| 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| 1.01k| 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: 1.01k] ------------------ 877| 0| base = current_base; ------------------ | | 138| 0|#define current_base event_global_current_base_ ------------------ 878| | /* Don't actually free NULL. */ 879| 1.01k| if (base == NULL) { ------------------ | Branch (879:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| if (base->th_notify_fd[0] != -1) { ------------------ | Branch (890:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| evmap_delete_all_(base); 902| | 903| 1.01k| while ((ev = min_heap_top_(&base->timeheap)) != NULL) { ------------------ | Branch (903:9): [True: 0, False: 1.01k] ------------------ 904| 0| event_del(ev); 905| 0| ++n_deleted; 906| 0| } 907| 1.01k| for (i = 0; i < base->n_common_timeouts; ++i) { ------------------ | Branch (907:14): [True: 0, False: 1.01k] ------------------ 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| 1.01k| if (base->common_timeout_queues) ------------------ | Branch (923:6): [True: 0, False: 1.01k] ------------------ 924| 0| mm_free(base->common_timeout_queues); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 925| | 926| 2.03k| 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| 2.03k| int i = event_base_free_queues_(base, run_finalizers); 936| 2.03k| event_debug(("%s: %d events freed", __func__, i)); ------------------ | | 79| 2.03k|#define event_debug(x) do { \ | | 80| 2.03k| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 2.03k|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 2.03k] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 2.03k| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 2.03k] | | ------------------ ------------------ 937| 2.03k| if (!i) { ------------------ | Branch (937:7): [True: 1.01k, False: 1.01k] ------------------ 938| 1.01k| break; 939| 1.01k| } 940| 1.01k| n_deleted += i; 941| 1.01k| } 942| | 943| 1.01k| if (n_deleted) ------------------ | Branch (943:6): [True: 1.01k, False: 0] ------------------ 944| 1.01k| event_debug(("%s: "EV_SIZE_FMT" events were still set in base", ------------------ | | 79| 1.01k|#define event_debug(x) do { \ | | 80| 1.01k| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 1.01k|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 1.01k] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 1.01k| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 1.01k] | | ------------------ ------------------ 945| 1.01k| __func__, n_deleted)); 946| | 947| 1.01k| while (LIST_FIRST(&base->once_events)) { ------------------ | | 157| 1.01k|#define LIST_FIRST(head) ((head)->lh_first) | | ------------------ | | | Branch (157:27): [True: 0, False: 1.01k] | | ------------------ ------------------ 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| 1.01k| if (base->evsel != NULL && base->evsel->dealloc != NULL) ------------------ | Branch (953:6): [True: 1.01k, False: 0] | Branch (953:29): [True: 1.01k, False: 0] ------------------ 954| 1.01k| base->evsel->dealloc(base); 955| | 956| 2.03k| for (i = 0; i < base->nactivequeues; ++i) ------------------ | Branch (956:14): [True: 1.01k, False: 1.01k] ------------------ 957| 1.01k| EVUTIL_ASSERT(TAILQ_EMPTY(&base->activequeues[i])); ------------------ | | 368| 1.01k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 2.03k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 1.01k| (void)sizeof(!(condition)); \ | | | | 98| 1.01k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ ------------------ 958| | 959| 1.01k| EVUTIL_ASSERT(min_heap_empty_(&base->timeheap)); ------------------ | | 368| 1.01k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 1.01k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 1.01k| (void)sizeof(!(condition)); \ | | | | 98| 1.01k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ ------------------ 960| 1.01k| min_heap_dtor_(&base->timeheap); 961| | 962| 1.01k| mm_free(base->activequeues); ------------------ | | 80| 1.01k|#define mm_free(p) event_mm_free_(p) ------------------ 963| | 964| 1.01k| evmap_io_clear_(&base->io); 965| 1.01k| evmap_signal_clear_(&base->sigmap); 966| 1.01k| event_changelist_freemem_(&base->changelist); 967| | 968| 1.01k| EVTHREAD_FREE_LOCK(base->th_base_lock, 0); ------------------ | | 86| 1.01k| do { \ | | 87| 1.01k| void *lock_tmp_ = (lockvar); \ | | 88| 1.01k| if (lock_tmp_ && evthread_lock_fns_.free) \ | | ------------------ | | | Branch (88:7): [True: 0, False: 1.01k] | | | Branch (88:20): [True: 0, False: 0] | | ------------------ | | 89| 1.01k| evthread_lock_fns_.free(lock_tmp_, (locktype)); \ | | 90| 1.01k| } while (0) | | ------------------ | | | Branch (90:11): [Folded, False: 1.01k] | | ------------------ ------------------ 969| 1.01k| EVTHREAD_FREE_COND(base->current_event_cond); ------------------ | | 160| 1.01k| do { \ | | 161| 1.01k| if (cond) \ | | ------------------ | | | Branch (161:7): [True: 0, False: 1.01k] | | ------------------ | | 162| 1.01k| evthread_cond_fns_.free_condition((cond)); \ | | 163| 1.01k| } while (0) | | ------------------ | | | Branch (163:11): [Folded, False: 1.01k] | | ------------------ ------------------ 970| | 971| | /* Free all event watchers */ 972| 3.05k| for (i = 0; i < EVWATCH_MAX; ++i) { ------------------ | | 229| 3.05k|#define EVWATCH_MAX 2 ------------------ | Branch (972:14): [True: 2.03k, False: 1.01k] ------------------ 973| 2.03k| while (!TAILQ_EMPTY(&base->watchers[i])) { ------------------ | | 302| 2.03k| (TAILQ_FIRST(head) == TAILQ_END(head)) | | ------------------ | | | | 293| 2.03k|#define TAILQ_FIRST(head) ((head)->tqh_first) | | ------------------ | | (TAILQ_FIRST(head) == TAILQ_END(head)) | | ------------------ | | | | 294| 2.03k|#define TAILQ_END(head) NULL | | ------------------ ------------------ | Branch (973:10): [True: 0, False: 2.03k] ------------------ 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| 2.03k| } 979| | 980| | /* If we're freeing current_base, there won't be a current_base. */ 981| 1.01k| if (base == current_base) ------------------ | | 138| 1.01k|#define current_base event_global_current_base_ ------------------ | Branch (981:6): [True: 0, False: 1.01k] ------------------ 982| 0| current_base = NULL; ------------------ | | 138| 0|#define current_base event_global_current_base_ ------------------ 983| 1.01k| mm_free(base); ------------------ | | 80| 1.01k|#define mm_free(p) event_mm_free_(p) ------------------ 984| 1.01k|} event.c:event_base_free_queues_: 842| 2.03k|{ 843| 2.03k| int deleted = 0, i; 844| | 845| 4.06k| for (i = 0; i < base->nactivequeues; ++i) { ------------------ | Branch (845:14): [True: 2.03k, False: 2.03k] ------------------ 846| 2.03k| struct event_callback *evcb, *next; 847| 4.06k| for (evcb = TAILQ_FIRST(&base->activequeues[i]); evcb; ) { ------------------ | | 293| 2.03k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (847:52): [True: 2.03k, False: 2.03k] ------------------ 848| 2.03k| next = TAILQ_NEXT(evcb, evcb_active_next); ------------------ | | 295| 2.03k|#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) ------------------ 849| 2.03k| deleted += event_base_cancel_single_callback_(base, evcb, run_finalizers); 850| 2.03k| evcb = next; 851| 2.03k| } 852| 2.03k| } 853| | 854| 2.03k| { 855| 2.03k| struct event_callback *evcb; 856| 2.03k| while ((evcb = TAILQ_FIRST(&base->active_later_queue))) { ------------------ | | 293| 2.03k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (856:10): [True: 0, False: 2.03k] ------------------ 857| 0| deleted += event_base_cancel_single_callback_(base, evcb, run_finalizers); 858| 0| } 859| 2.03k| } 860| | 861| 2.03k| return deleted; 862| 2.03k|} event.c:event_base_cancel_single_callback_: 805| 2.03k|{ 806| 2.03k| int result = 0; 807| | 808| 2.03k| if (evcb->evcb_flags & EVLIST_INIT) { ------------------ | | 64| 2.03k|#define EVLIST_INIT 0x80 ------------------ | Branch (808:6): [True: 2.03k, False: 0] ------------------ 809| 2.03k| struct event *ev = event_callback_to_event(evcb); 810| 2.03k| if (!(ev->ev_flags & EVLIST_INTERNAL)) { ------------------ | | 58| 2.03k|#define ev_flags ev_evcallback.evcb_flags ------------------ if (!(ev->ev_flags & EVLIST_INTERNAL)) { ------------------ | | 61| 2.03k|#define EVLIST_INTERNAL 0x10 ------------------ | Branch (810:7): [True: 2.03k, False: 0] ------------------ 811| 2.03k| event_del_(ev, EVENT_DEL_EVEN_IF_FINALIZING); ------------------ | | 472| 2.03k|#define EVENT_DEL_EVEN_IF_FINALIZING 3 ------------------ 812| 2.03k| result = 1; 813| 2.03k| } 814| 2.03k| } 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| 2.03k| if (run_finalizers && (evcb->evcb_flags & EVLIST_FINALIZING)) { ------------------ | | 63| 2.03k|#define EVLIST_FINALIZING 0x40 ------------------ | Branch (821:6): [True: 2.03k, False: 0] | Branch (821:24): [True: 2.03k, False: 0] ------------------ 822| 2.03k| 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: 2.03k] ------------------ 824| 0| case EV_CLOSURE_EVENT_FINALIZE_FREE: { ------------------ | | 83| 0|#define EV_CLOSURE_EVENT_FINALIZE_FREE 6 ------------------ | Branch (824:3): [True: 0, False: 2.03k] ------------------ 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| 2.03k| case EV_CLOSURE_CB_FINALIZE: ------------------ | | 78| 2.03k|#define EV_CLOSURE_CB_FINALIZE 4 ------------------ | Branch (831:3): [True: 2.03k, False: 0] ------------------ 832| 2.03k| evcb->evcb_cb_union.evcb_cbfinalize(evcb, evcb->evcb_arg); 833| 2.03k| break; 834| 0| default: ------------------ | Branch (834:3): [True: 0, False: 2.03k] ------------------ 835| 0| break; 836| 2.03k| } 837| 2.03k| } 838| 2.03k| return result; 839| 2.03k|} event.c:clear_time_cache: 481| 3.05k|{ 482| 3.05k| base->tv_cache.tv_sec = 0; 483| 3.05k|} event.c:event_haveevents: 1385| 2.03k|{ 1386| | /* Caller must hold th_base_lock */ 1387| 2.03k| return (base->virtual_event_count > 0 || base->event_count > 0); ------------------ | Branch (1387:10): [True: 0, False: 2.03k] | Branch (1387:43): [True: 1.01k, False: 1.01k] ------------------ 1388| 2.03k|} event.c:event_process_active: 1822| 1.01k|{ 1823| | /* Caller must hold th_base_lock */ 1824| 1.01k| struct evcallback_list *activeq = NULL; 1825| 1.01k| int i, c = 0; 1826| 1.01k| const struct timeval *endtime; 1827| 1.01k| struct timeval tv; 1828| 1.01k| const int maxcb = base->max_dispatch_callbacks; 1829| 1.01k| const int limit_after_prio = base->limit_callbacks_after_prio; 1830| 1.01k| if (base->max_dispatch_time.tv_sec >= 0) { ------------------ | Branch (1830:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| } else { 1836| 1.01k| endtime = NULL; 1837| 1.01k| } 1838| | 1839| 1.01k| for (i = 0; i < base->nactivequeues; ++i) { ------------------ | Branch (1839:14): [True: 1.01k, False: 0] ------------------ 1840| 1.01k| if (TAILQ_FIRST(&base->activequeues[i]) != NULL) { ------------------ | | 293| 1.01k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (1840:7): [True: 1.01k, False: 0] ------------------ 1841| 1.01k| base->event_running_priority = i; 1842| 1.01k| activeq = &base->activequeues[i]; 1843| 1.01k| if (i < limit_after_prio) ------------------ | Branch (1843:8): [True: 1.01k, False: 0] ------------------ 1844| 1.01k| c = event_process_active_single_queue(base, activeq, 1845| 1.01k| INT_MAX, NULL); 1846| 0| else 1847| 0| c = event_process_active_single_queue(base, activeq, 1848| 0| maxcb, endtime); 1849| 1.01k| if (c < 0) { ------------------ | Branch (1849:8): [True: 0, False: 1.01k] ------------------ 1850| 0| goto done; 1851| 1.01k| } else if (c > 0) ------------------ | Branch (1851:15): [True: 1.01k, False: 0] ------------------ 1852| 1.01k| 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| 1.01k| } 1857| 1.01k| } 1858| | 1859| 1.01k|done: 1860| 1.01k| base->event_running_priority = -1; 1861| | 1862| 1.01k| return c; 1863| 1.01k|} event.c:event_process_active_single_queue: 1695| 1.01k|{ 1696| 1.01k| struct event_callback *evcb; 1697| 1.01k| int count = 0; 1698| | 1699| 1.01k| EVUTIL_ASSERT(activeq != NULL); ------------------ | | 368| 1.01k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 1.01k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 1.01k| (void)sizeof(!(condition)); \ | | | | 98| 1.01k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ ------------------ 1700| | 1701| 2.03k| for (evcb = TAILQ_FIRST(activeq); evcb; evcb = TAILQ_FIRST(activeq)) { ------------------ | | 293| 1.01k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ for (evcb = TAILQ_FIRST(activeq); evcb; evcb = TAILQ_FIRST(activeq)) { ------------------ | | 293| 1.01k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (1701:36): [True: 1.01k, False: 1.01k] ------------------ 1702| 1.01k| struct event *ev = NULL; 1703| 1.01k| if (evcb->evcb_flags & EVLIST_INIT) { ------------------ | | 64| 1.01k|#define EVLIST_INIT 0x80 ------------------ | Branch (1703:7): [True: 0, False: 1.01k] ------------------ 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| 1.01k| } else { 1718| 1.01k| event_queue_remove_active(base, evcb); 1719| 1.01k| event_debug(("event_process_active: event_callback %p, " ------------------ | | 79| 1.01k|#define event_debug(x) do { \ | | 80| 1.01k| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 1.01k|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 1.01k] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 1.01k| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 1.01k] | | ------------------ ------------------ 1720| 1.01k| "closure %d, call %p", 1721| 1.01k| (void *)evcb, evcb->evcb_closure, (void *)evcb->evcb_cb_union.evcb_callback)); 1722| 1.01k| } 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| 1.01k| EVUTIL_ASSERT(evcb != TAILQ_FIRST(activeq)); ------------------ | | 368| 1.01k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 1.01k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 1.01k| (void)sizeof(!(condition)); \ | | | | 98| 1.01k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ ------------------ 1726| | 1727| 1.01k| if (!(evcb->evcb_flags & EVLIST_INTERNAL)) ------------------ | | 61| 1.01k|#define EVLIST_INTERNAL 0x10 ------------------ | Branch (1727:7): [True: 1.01k, False: 0] ------------------ 1728| 1.01k| ++count; 1729| | 1730| | 1731| 1.01k| base->current_event = evcb; 1732| 1.01k|#ifndef EVENT__DISABLE_THREAD_SUPPORT 1733| 1.01k| base->current_event_waiters = 0; 1734| 1.01k|#endif 1735| | 1736| 1.01k| 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: 1.01k] ------------------ 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: 1.01k] ------------------ 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: 1.01k] ------------------ 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| 1.01k| case EV_CLOSURE_CB_SELF: { ------------------ | | 76| 1.01k|#define EV_CLOSURE_CB_SELF 3 ------------------ | Branch (1755:3): [True: 1.01k, False: 0] ------------------ 1756| 1.01k| void (*evcb_selfcb)(struct event_callback *, void *) = evcb->evcb_cb_union.evcb_selfcb; 1757| 1.01k| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 1.01k|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 1.01k| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 1.01k| do { \ | | | | 102| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 103| 1.01k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ | | 125| 1.01k| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 1.01k] | | ------------------ ------------------ 1758| 1.01k| evcb_selfcb(evcb, evcb->evcb_arg); 1759| 1.01k| } 1760| 1.01k| break; 1761| 0| case EV_CLOSURE_EVENT_FINALIZE: ------------------ | | 80| 0|#define EV_CLOSURE_EVENT_FINALIZE 5 ------------------ | Branch (1761:3): [True: 0, False: 1.01k] ------------------ 1762| 0| case EV_CLOSURE_EVENT_FINALIZE_FREE: { ------------------ | | 83| 0|#define EV_CLOSURE_EVENT_FINALIZE_FREE 6 ------------------ | Branch (1762:3): [True: 0, False: 1.01k] ------------------ 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: 1.01k] ------------------ 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: 1.01k] ------------------ 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| 1.01k| } 1787| | 1788| 1.01k| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 1.01k|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 1.01k| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 1.01k| do { \ | | | | 95| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 96| 1.01k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ | | 120| 1.01k| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 1.01k] | | ------------------ ------------------ 1789| 1.01k| base->current_event = NULL; 1790| 1.01k|#ifndef EVENT__DISABLE_THREAD_SUPPORT 1791| 1.01k| if (base->current_event_waiters) { ------------------ | Branch (1791:7): [True: 0, False: 1.01k] ------------------ 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| 1.01k|#endif 1796| | 1797| 1.01k| if (base->event_break) ------------------ | Branch (1797:7): [True: 0, False: 1.01k] ------------------ 1798| 0| return -1; 1799| 1.01k| if (count >= max_to_process) ------------------ | Branch (1799:7): [True: 0, False: 1.01k] ------------------ 1800| 0| return count; 1801| 1.01k| if (count && endtime) { ------------------ | Branch (1801:7): [True: 1.01k, False: 0] | Branch (1801:16): [True: 0, False: 1.01k] ------------------ 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| 1.01k| if (base->event_continue) ------------------ | Branch (1808:7): [True: 0, False: 1.01k] ------------------ 1809| 0| break; 1810| 1.01k| } 1811| 1.01k| return count; 1812| 1.01k|} event.c:event_debug_assert_socket_nonblocking_: 395| 5.08k|{ 396| 5.08k| if (!event_debug_mode_on_) ------------------ | Branch (396:6): [True: 5.08k, False: 0] ------------------ 397| 5.08k| 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| 6.10k|{ 376| 6.10k| struct event_debug_entry *dent, find; 377| | 378| 6.10k| if (!event_debug_mode_on_) ------------------ | Branch (378:6): [True: 6.10k, False: 0] ------------------ 379| 6.10k| 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| 5.08k|{ 258| 5.08k| struct event_debug_entry *dent, find; 259| | 260| 5.08k| if (!event_debug_mode_on_) ------------------ | Branch (260:6): [True: 5.08k, False: 0] ------------------ 261| 5.08k| 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| 5.08k|out: 280| 5.08k| event_debug_mode_too_late_set(); 281| 5.08k|} event.c:event_debug_mode_too_late_set: 243| 14.2k|{ 244| | /* event_base_new_with_config() should have already set event_debug_mode_too_late under lock */ 245| 14.2k|#ifndef EVENT__DISABLE_DEBUG_MODE 246| 14.2k| if (!event_debug_mode_too_late) { ------------------ | Branch (246:6): [True: 0, False: 14.2k] ------------------ 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| 14.2k|#endif 253| 14.2k|} event.c:event_debug_assert_is_setup_: 354| 2.03k|{ 355| 2.03k| struct event_debug_entry *dent, find; 356| | 357| 2.03k| if (!event_debug_mode_on_) ------------------ | Branch (357:6): [True: 2.03k, False: 0] ------------------ 358| 2.03k| 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| 8.13k|{ 514| 8.13k| EVUTIL_ASSERT((evcb->evcb_flags & EVLIST_INIT)); ------------------ | | 368| 8.13k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 8.13k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 8.13k| (void)sizeof(!(condition)); \ | | | | 98| 8.13k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 8.13k] | | | | ------------------ | | ------------------ ------------------ 515| | return EVUTIL_UPCAST(evcb, struct event, ev_evcallback); ------------------ | | 289| 8.13k| ((type *)(((char*)(ptr)) - evutil_offsetof(type, field))) | | ------------------ | | | | 625| 8.13k|#define evutil_offsetof(type, field) offsetof(type, field) | | ------------------ ------------------ 516| 8.13k|} event.c:event_debug_note_teardown_: 284| 1.01k|{ 285| 1.01k| struct event_debug_entry *dent, find; 286| | 287| 1.01k| if (!event_debug_mode_on_) ------------------ | Branch (287:6): [True: 1.01k, False: 0] ------------------ 288| 1.01k| 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| 1.01k|out: 298| 1.01k| event_debug_mode_too_late_set(); 299| 1.01k|} event.c:event_to_event_callback: 520| 8.13k|{ 521| 8.13k| return &ev->ev_evcallback; 522| 8.13k|} event.c:event_del_: 2877| 2.03k|{ 2878| 2.03k| int res; 2879| 2.03k| struct event_base *base = ev->ev_base; 2880| | 2881| 2.03k| if (EVUTIL_FAILURE_CHECK(!base)) { ------------------ | | 369| 2.03k|#define EVUTIL_FAILURE_CHECK(cond) 0 | | ------------------ | | | Branch (369:36): [Folded, False: 2.03k] | | ------------------ ------------------ 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| 2.03k| EVBASE_ACQUIRE_LOCK(base, th_base_lock); ------------------ | | 118| 2.03k|#define EVBASE_ACQUIRE_LOCK(base, lockvar) do { \ | | 119| 2.03k| EVLOCK_LOCK((base)->lockvar, 0); \ | | ------------------ | | | | 94| 2.03k| do { \ | | | | 95| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 96| 2.03k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 120| 2.03k| } while (0) | | ------------------ | | | Branch (120:11): [Folded, False: 2.03k] | | ------------------ ------------------ 2887| 2.03k| res = event_del_nolock_(ev, blocking); 2888| 2.03k| EVBASE_RELEASE_LOCK(base, th_base_lock); ------------------ | | 123| 2.03k|#define EVBASE_RELEASE_LOCK(base, lockvar) do { \ | | 124| 2.03k| EVLOCK_UNLOCK((base)->lockvar, 0); \ | | ------------------ | | | | 101| 2.03k| do { \ | | | | 102| 2.03k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 2.03k] | | | | ------------------ | | | | 103| 2.03k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 2.03k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 2.03k] | | | | ------------------ | | ------------------ | | 125| 2.03k| } while (0) | | ------------------ | | | Branch (125:11): [Folded, False: 2.03k] | | ------------------ ------------------ 2889| | 2890| 2.03k| return (res); 2891| 2.03k|} event.c:event_debug_note_del_: 328| 8.13k|{ 329| 8.13k| struct event_debug_entry *dent, find; 330| | 331| 8.13k| if (!event_debug_mode_on_) ------------------ | Branch (331:6): [True: 8.13k, False: 0] ------------------ 332| 8.13k| 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| 8.13k|out: 350| 8.13k| event_debug_mode_too_late_set(); 351| 8.13k|} event.c:timeout_process: 3285| 1.01k|{ 3286| | /* Caller must hold lock. */ 3287| 1.01k| struct timeval now; 3288| 1.01k| struct event *ev; 3289| | 3290| 1.01k| if (min_heap_empty_(&base->timeheap)) { ------------------ | Branch (3290:6): [True: 1.01k, False: 0] ------------------ 3291| 1.01k| return; 3292| 1.01k| } 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| 3.05k|{ 3345| 3.05k| EVENT_BASE_ASSERT_LOCKED(base); ------------------ | | 421| 3.05k| EVLOCK_ASSERT_LOCKED((base)->th_base_lock) | | ------------------ | | | | 130| 3.05k| do { \ | | | | 131| 3.05k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 3.05k] | | | | | 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.05k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 3.05k] | | | | ------------------ | | ------------------ ------------------ 3346| 3.05k| if (EVUTIL_FAILURE_CHECK(!(evcb->evcb_flags & EVLIST_ACTIVE))) { ------------------ | | 369| 3.05k|#define EVUTIL_FAILURE_CHECK(cond) 0 | | ------------------ | | | Branch (369:36): [Folded, False: 3.05k] | | ------------------ ------------------ 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| 3.05k| DECR_EVENT_COUNT(base, evcb->evcb_flags); ------------------ | | 3324| 3.05k| ((base)->event_count -= !((flags) & EVLIST_INTERNAL)) | | ------------------ | | | | 61| 3.05k|#define EVLIST_INTERNAL 0x10 | | ------------------ ------------------ 3352| 3.05k| evcb->evcb_flags &= ~EVLIST_ACTIVE; ------------------ | | 60| 3.05k|#define EVLIST_ACTIVE 0x08 ------------------ 3353| 3.05k| base->event_count_active--; 3354| | 3355| | TAILQ_REMOVE(&base->activequeues[evcb->evcb_pri], ------------------ | | 356| 3.05k|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 3.05k| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 1.01k, False: 2.03k] | | ------------------ | | 358| 3.05k| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 1.01k| (elm)->field.tqe_prev; \ | | 360| 3.05k| else \ | | 361| 3.05k| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 3.05k| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 3.05k|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 3.05k] | | ------------------ ------------------ 3356| 3.05k| evcb, evcb_active_next); 3357| 3.05k|} event.c:event_queue_insert_active: 3485| 3.05k|{ 3486| 3.05k| EVENT_BASE_ASSERT_LOCKED(base); ------------------ | | 421| 3.05k| EVLOCK_ASSERT_LOCKED((base)->th_base_lock) | | ------------------ | | | | 130| 3.05k| do { \ | | | | 131| 3.05k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 3.05k] | | | | | 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.05k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 3.05k] | | | | ------------------ | | ------------------ ------------------ 3487| | 3488| 3.05k| if (evcb->evcb_flags & EVLIST_ACTIVE) { ------------------ | | 60| 3.05k|#define EVLIST_ACTIVE 0x08 ------------------ | Branch (3488:6): [True: 0, False: 3.05k] ------------------ 3489| | /* Double insertion is possible for active events */ 3490| 0| return; 3491| 0| } 3492| | 3493| 3.05k| INCR_EVENT_COUNT(base, evcb->evcb_flags); ------------------ | | 3325| 3.05k|#define INCR_EVENT_COUNT(base,flags) do { \ | | 3326| 3.05k| ((base)->event_count += !((flags) & EVLIST_INTERNAL)); \ | | ------------------ | | | | 61| 3.05k|#define EVLIST_INTERNAL 0x10 | | ------------------ | | 3327| 3.05k| MAX_EVENT_COUNT((base)->event_count_max, (base)->event_count); \ | | ------------------ | | | | 3317| 3.05k|#define MAX_EVENT_COUNT(var, v) var = MAX(var, v) | | | | ------------------ | | | | | | 3314| 3.05k|#define MAX(a,b) (((a)>(b))?(a):(b)) | | | | | | ------------------ | | | | | | | Branch (3314:19): [True: 0, False: 3.05k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 3328| 3.05k|} while (0) | | ------------------ | | | Branch (3328:10): [Folded, False: 3.05k] | | ------------------ ------------------ 3494| | 3495| 3.05k| evcb->evcb_flags |= EVLIST_ACTIVE; ------------------ | | 60| 3.05k|#define EVLIST_ACTIVE 0x08 ------------------ 3496| | 3497| 3.05k| base->event_count_active++; 3498| 3.05k| MAX_EVENT_COUNT(base->event_count_active_max, base->event_count_active); ------------------ | | 3317| 3.05k|#define MAX_EVENT_COUNT(var, v) var = MAX(var, v) | | ------------------ | | | | 3314| 3.05k|#define MAX(a,b) (((a)>(b))?(a):(b)) | | | | ------------------ | | | | | Branch (3314:19): [True: 0, False: 3.05k] | | | | ------------------ | | ------------------ ------------------ 3499| 3.05k| EVUTIL_ASSERT(evcb->evcb_pri < base->nactivequeues); ------------------ | | 368| 3.05k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 3.05k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 3.05k| (void)sizeof(!(condition)); \ | | | | 98| 3.05k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 3.05k] | | | | ------------------ | | ------------------ ------------------ 3500| | TAILQ_INSERT_TAIL(&base->activequeues[evcb->evcb_pri], ------------------ | | 332| 3.05k|#define TAILQ_INSERT_TAIL(head, elm, field) do { \ | | 333| 3.05k| (elm)->field.tqe_next = NULL; \ | | 334| 3.05k| (elm)->field.tqe_prev = (head)->tqh_last; \ | | 335| 3.05k| *(head)->tqh_last = (elm); \ | | 336| 3.05k| (head)->tqh_last = &(elm)->field.tqe_next; \ | | 337| 3.05k|} while (0) | | ------------------ | | | Branch (337:10): [Folded, False: 3.05k] | | ------------------ ------------------ 3501| 3.05k| evcb, evcb_active_next); 3502| 3.05k|} event.c:event_queue_make_later_events_active: 3547| 1.01k|{ 3548| 1.01k| struct event_callback *evcb; 3549| 1.01k| EVENT_BASE_ASSERT_LOCKED(base); ------------------ | | 421| 1.01k| EVLOCK_ASSERT_LOCKED((base)->th_base_lock) | | ------------------ | | | | 130| 1.01k| do { \ | | | | 131| 1.01k| if ((lock) && evthread_lock_debugging_enabled_) { \ | | | | ------------------ | | | | | Branch (131:7): [True: 0, False: 1.01k] | | | | | 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.01k| } while (0) | | | | ------------------ | | | | | Branch (134:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ ------------------ 3550| | 3551| 1.01k| while ((evcb = TAILQ_FIRST(&base->active_later_queue))) { ------------------ | | 293| 1.01k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (3551:9): [True: 0, False: 1.01k] ------------------ 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| 1.01k|} evmap_io_initmap_: 190| 1.01k|{ 191| 1.01k| evmap_signal_initmap_(ctx); 192| 1.01k|} evmap_io_clear_: 195| 1.01k|{ 196| 1.01k| evmap_signal_clear_(ctx); 197| 1.01k|} evmap_signal_initmap_: 236| 2.03k|{ 237| 2.03k| ctx->nentries = 0; 238| | ctx->entries = NULL; 239| 2.03k|} evmap_signal_clear_: 243| 2.03k|{ 244| 2.03k| if (ctx->entries != NULL) { ------------------ | Branch (244:6): [True: 0, False: 2.03k] ------------------ 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| 2.03k| ctx->nentries = 0; 254| 2.03k|} evmap_delete_all_: 695| 1.01k|{ 696| 1.01k| 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| 1.01k|} event_changelist_init_: 710| 2.03k|{ 711| | changelist->changes = NULL; 712| 2.03k| changelist->changes_size = 0; 713| 2.03k| changelist->n_changes = 0; 714| 2.03k|} event_changelist_remove_all_: 782| 1.01k|{ 783| 1.01k| int i; 784| | 785| 1.01k| event_changelist_check(base); ------------------ | | 776| 1.01k|#define event_changelist_check(base) ((void)0) ------------------ 786| | 787| 1.01k| for (i = 0; i < changelist->n_changes; ++i) { ------------------ | Branch (787:14): [True: 0, False: 1.01k] ------------------ 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| 1.01k| changelist->n_changes = 0; 796| | 797| 1.01k| event_changelist_check(base); ------------------ | | 776| 1.01k|#define event_changelist_check(base) ((void)0) ------------------ 798| 1.01k|} event_changelist_freemem_: 802| 1.01k|{ 803| 1.01k| if (changelist->changes) ------------------ | Branch (803:6): [True: 0, False: 1.01k] ------------------ 804| 0| mm_free(changelist->changes); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 805| 1.01k| event_changelist_init_(changelist); /* zero it all out. */ 806| 1.01k|} evmap.c:evmap_io_foreach_fd: 549| 1.01k|{ 550| 1.01k| evutil_socket_t fd; ------------------ | | 325| 1.01k|#define evutil_socket_t int ------------------ 551| 1.01k| struct event_io_map *iomap = &base->io; 552| 1.01k| 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| 1.01k| for (fd = 0; fd < iomap->nentries; ++fd) { ------------------ | Branch (559:15): [True: 0, False: 1.01k] ------------------ 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| 1.01k| return r; 568| 1.01k|} evmap.c:evmap_signal_foreach_signal: 588| 1.01k|{ 589| 1.01k| struct event_signal_map *sigmap = &base->sigmap; 590| 1.01k| int r = 0; 591| 1.01k| int signum; 592| | 593| 1.01k| for (signum = 0; signum < sigmap->nentries; ++signum) { ------------------ | Branch (593:19): [True: 0, False: 1.01k] ------------------ 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| 1.01k| return r; 601| 1.01k|} evutil_closesocket: 615| 2.03k|{ 616| 2.03k|#ifndef _WIN32 617| 2.03k| return close(sock); 618| |#else 619| | return closesocket(sock); 620| |#endif 621| 2.03k|} evutil_snprintf: 2090| 43.0k|{ 2091| 43.0k| int r; 2092| 43.0k| va_list ap; 2093| 43.0k| va_start(ap, format); 2094| 43.0k| r = evutil_vsnprintf(buf, buflen, format, ap); 2095| | va_end(ap); 2096| 43.0k| return r; 2097| 43.0k|} evutil_vsnprintf: 2101| 89.2k|{ 2102| 89.2k| int r; 2103| 89.2k| if (!buflen) ------------------ | Branch (2103:6): [True: 0, False: 89.2k] ------------------ 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| 89.2k| r = vsnprintf(buf, buflen, format, ap); 2118| 89.2k|#endif 2119| | // If r >= buflen, the output is truncated, and it is manually guaranteed to end with '\0' 2120| 89.2k| if (r >= 0 && (size_t)r >= buflen) { ------------------ | Branch (2120:6): [True: 89.2k, False: 0] | Branch (2120:16): [True: 0, False: 89.2k] ------------------ 2121| 0| buf[buflen - 1] = '\0'; 2122| 0| } 2123| 89.2k| return r; 2124| 89.2k|} EVUTIL_TOLOWER_: 2617| 203k|{ 2618| 203k| return ((char)EVUTIL_TOLOWER_TABLE[(ev_uint8_t)c]); 2619| 203k|} EVUTIL_TOUPPER_: 2621| 5.08k|{ 2622| 5.08k| return ((char)EVUTIL_TOUPPER_TABLE[(ev_uint8_t)c]); 2623| 5.08k|} evutil_ascii_strcasecmp: 2626| 15.2k|{ 2627| 15.2k| char c1, c2; 2628| 93.5k| while (1) { ------------------ | Branch (2628:9): [True: 93.5k, Folded] ------------------ 2629| 93.5k| c1 = EVUTIL_TOLOWER_(*s1++); 2630| 93.5k| c2 = EVUTIL_TOLOWER_(*s2++); 2631| 93.5k| if (c1 < c2) ------------------ | Branch (2631:7): [True: 3.05k, False: 90.5k] ------------------ 2632| 3.05k| return -1; 2633| 90.5k| else if (c1 > c2) ------------------ | Branch (2633:12): [True: 6.10k, False: 84.4k] ------------------ 2634| 6.10k| return 1; 2635| 84.4k| else if (c1 == 0) ------------------ | Branch (2635:12): [True: 6.10k, False: 78.3k] ------------------ 2636| 6.10k| return 0; 2637| 93.5k| } 2638| 15.2k|} evutil_ascii_strncasecmp: 2640| 2.03k|{ 2641| 2.03k| char c1, c2; 2642| 8.13k| while (n--) { ------------------ | Branch (2642:9): [True: 7.11k, False: 1.01k] ------------------ 2643| 7.11k| c1 = EVUTIL_TOLOWER_(*s1++); 2644| 7.11k| c2 = EVUTIL_TOLOWER_(*s2++); 2645| 7.11k| if (c1 < c2) ------------------ | Branch (2645:7): [True: 0, False: 7.11k] ------------------ 2646| 0| return -1; 2647| 7.11k| else if (c1 > c2) ------------------ | Branch (2647:12): [True: 1.01k, False: 6.10k] ------------------ 2648| 1.01k| return 1; 2649| 6.10k| else if (c1 == 0) ------------------ | Branch (2649:12): [True: 0, False: 6.10k] ------------------ 2650| 0| return 0; 2651| 7.11k| } 2652| 1.01k| return 0; 2653| 2.03k|} evutil_ascii_strcasestr: 2656| 1.01k|{ 2657| 1.01k| char c, sc; 2658| 1.01k| size_t len; 2659| | 2660| 1.01k| if ((c = *find++) != 0) { ------------------ | Branch (2660:6): [True: 1.01k, False: 0] ------------------ 2661| 1.01k| c = EVUTIL_TOLOWER_(c); 2662| 1.01k| len = strlen(find); 2663| 1.01k| do { 2664| 1.01k| do { 2665| 1.01k| if ((sc = *s++) == 0) ------------------ | Branch (2665:9): [True: 0, False: 1.01k] ------------------ 2666| 0| return (NULL); 2667| 1.01k| } while ((char)EVUTIL_TOLOWER_(sc) != c); ------------------ | Branch (2667:13): [True: 0, False: 1.01k] ------------------ 2668| 1.01k| } while (evutil_ascii_strncasecmp(s, find, len) != 0); ------------------ | Branch (2668:12): [True: 0, False: 1.01k] ------------------ 2669| 1.01k| s--; 2670| 1.01k| } 2671| 1.01k| return s; 2672| 1.01k|} evutil_getenv_: 2718| 4.06k|{ 2719| 4.06k| if (evutil_issetugid()) ------------------ | Branch (2719:6): [True: 0, False: 4.06k] ------------------ 2720| 0| return NULL; 2721| | 2722| 4.06k| return getenv(varname); 2723| 4.06k|} evutil_memclear_: 2781| 4.06k|{ 2782| 4.06k| evutil_memset_volatile_(mem, 0, len); 2783| 4.06k|} evutil_make_internal_pipe_: 3099| 1.01k|{ 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| 1.01k|#if defined(EVENT__HAVE_PIPE2) 3110| 1.01k| if (pipe2(fd, O_NONBLOCK|O_CLOEXEC) == 0) ------------------ | Branch (3110:6): [True: 1.01k, False: 0] ------------------ 3111| 1.01k| 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| 4.06k|{ 2698| |#ifdef EVENT__HAVE_ISSETUGID 2699| | return issetugid(); 2700| |#elif defined(EVENT__HAVE_SYS_AUXV_H) && defined(AT_SECURE) 2701| 4.06k| 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| 4.06k|} evutil_tv_to_msec_: 129| 1.01k|{ 130| 1.01k| if (tv->tv_usec > 1000000 || tv->tv_sec > MAX_SECONDS_IN_MSEC_LONG) ------------------ | | 125| 1.01k| (((LONG_MAX) - 999) / 1000) ------------------ | Branch (130:6): [True: 0, False: 1.01k] | Branch (130:31): [True: 0, False: 1.01k] ------------------ 131| 0| return -1; 132| | 133| 1.01k| return (tv->tv_sec * 1000) + ((tv->tv_usec + 999) / 1000); 134| 1.01k|} evutil_configure_monotonic_time_: 309| 1.01k|{ 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| 1.01k|#ifdef CLOCK_MONOTONIC_COARSE 314| 1.01k| const int precise = flags & EV_MONOT_PRECISE; ------------------ | | 346| 1.01k|#define EV_MONOT_PRECISE 1 ------------------ 315| 1.01k|#endif 316| 1.01k| const int fallback = flags & EV_MONOT_FALLBACK; ------------------ | | 347| 1.01k|#define EV_MONOT_FALLBACK 2 ------------------ 317| 1.01k| struct timespec ts; 318| | 319| 1.01k| memset(base, 0, sizeof(*base)); 320| | 321| 1.01k|#ifdef CLOCK_MONOTONIC_COARSE 322| 1.01k| if (CLOCK_MONOTONIC_COARSE < 0) { ------------------ | Branch (322:6): [Folded, False: 1.01k] ------------------ 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| 1.01k| if (! precise && ! fallback) { ------------------ | Branch (329:6): [True: 1.01k, False: 0] | Branch (329:19): [True: 1.01k, False: 0] ------------------ 330| 1.01k| if (clock_gettime(CLOCK_MONOTONIC_COARSE, &ts) == 0) { ------------------ | Branch (330:7): [True: 1.01k, False: 0] ------------------ 331| 1.01k| base->monotonic_clock = CLOCK_MONOTONIC_COARSE; 332| 1.01k| return 0; 333| 1.01k| } 334| 1.01k| } 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| 2.03k|{ 353| 2.03k| struct timespec ts; 354| | 355| 2.03k| if (base->monotonic_clock < 0) { ------------------ | Branch (355:6): [True: 0, False: 2.03k] ------------------ 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| 2.03k| if (clock_gettime(base->monotonic_clock, &ts) == -1) ------------------ | Branch (362:6): [True: 0, False: 2.03k] ------------------ 363| 0| return -1; 364| 2.03k| tp->tv_sec = ts.tv_sec; 365| 2.03k| tp->tv_usec = ts.tv_nsec / 1000; 366| | 367| 2.03k| return 0; 368| 2.03k|} evhttp_connection_free: 1349| 1.01k|{ 1350| 1.01k| struct evhttp_request *req; 1351| | 1352| | /* notify interested parties that this connection is going down */ 1353| 1.01k| if (evhttp_connected(evcon) && evcon->closecb != NULL) ------------------ | Branch (1353:6): [True: 0, False: 1.01k] | Branch (1353:33): [True: 0, False: 0] ------------------ 1354| 0| (*evcon->closecb)(evcon, evcon->closecb_arg); 1355| | 1356| | /* remove all requests that might be queued on this 1357| | * connection. for server connections, this should be empty. 1358| | * because it gets dequeued either in evhttp_connection_done or 1359| | * evhttp_connection_fail_. 1360| | */ 1361| 1.01k| while ((req = TAILQ_FIRST(&evcon->requests)) != NULL) { ------------------ | | 293| 1.01k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (1361:9): [True: 0, False: 1.01k] ------------------ 1362| 0| evhttp_request_free_(evcon, req); 1363| 0| } 1364| | 1365| 1.01k| if (evcon->http_server != NULL) { ------------------ | Branch (1365:6): [True: 1.01k, False: 0] ------------------ 1366| 1.01k| struct evhttp *http = evcon->http_server; 1367| 1.01k| TAILQ_REMOVE(&http->connections, evcon, next); ------------------ | | 356| 1.01k|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 1.01k| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 0, False: 1.01k] | | ------------------ | | 358| 1.01k| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 0| (elm)->field.tqe_prev; \ | | 360| 1.01k| else \ | | 361| 1.01k| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 1.01k| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 1.01k|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 1.01k] | | ------------------ ------------------ 1368| 1.01k| http->connection_cnt--; 1369| 1.01k| } 1370| | 1371| 1.01k| if (event_initialized(&evcon->retry_ev)) { ------------------ | Branch (1371:6): [True: 0, False: 1.01k] ------------------ 1372| 0| event_del(&evcon->retry_ev); 1373| 0| event_debug_unassign(&evcon->retry_ev); 1374| 0| } 1375| | 1376| 1.01k| event_deferred_cb_cancel_(get_deferred_queue(evcon), ------------------ | | 1252| 1.01k| ((evcon)->base) ------------------ 1377| 1.01k| &evcon->read_more_deferred_cb); 1378| | 1379| 1.01k| if (evcon->bufev != NULL) { ------------------ | Branch (1379:6): [True: 0, False: 1.01k] ------------------ 1380| 0| bufferevent_free(evcon->bufev); 1381| 0| } 1382| | 1383| 1.01k| if (evcon->bind_address != NULL) ------------------ | Branch (1383:6): [True: 0, False: 1.01k] ------------------ 1384| 0| mm_free(evcon->bind_address); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 1385| | 1386| 1.01k| if (evcon->address != NULL) ------------------ | Branch (1386:6): [True: 1.01k, False: 0] ------------------ 1387| 1.01k| mm_free(evcon->address); ------------------ | | 80| 1.01k|#define mm_free(p) event_mm_free_(p) ------------------ 1388| | 1389| 1.01k|#ifndef _WIN32 1390| 1.01k| if (evcon->unixsocket != NULL) ------------------ | Branch (1390:6): [True: 0, False: 1.01k] ------------------ 1391| 0| mm_free(evcon->unixsocket); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 1392| 1.01k|#endif 1393| | 1394| 1.01k| mm_free(evcon); ------------------ | | 80| 1.01k|#define mm_free(p) event_mm_free_(p) ------------------ 1395| 1.01k|} evhttp_find_header: 2075| 6.10k|{ 2076| 6.10k| struct evkeyval *header; 2077| | 2078| 13.2k| TAILQ_FOREACH(header, headers, next) { ------------------ | | 305| 6.10k| for((var) = TAILQ_FIRST(head); \ | | ------------------ | | | | 293| 6.10k|#define TAILQ_FIRST(head) ((head)->tqh_first) | | ------------------ | | 306| 14.2k| (var) != TAILQ_END(head); \ | | ------------------ | | | | 294| 14.2k|#define TAILQ_END(head) NULL | | ------------------ | | | Branch (306:6): [True: 13.2k, False: 1.01k] | | ------------------ | | 307| 8.13k| (var) = TAILQ_NEXT(var, field)) | | ------------------ | | | | 295| 8.13k|#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) | | ------------------ ------------------ 2079| 13.2k| if (evutil_ascii_strcasecmp(header->key, key) == 0) ------------------ | Branch (2079:7): [True: 5.08k, False: 8.13k] ------------------ 2080| 5.08k| return (header->value); 2081| 13.2k| } 2082| | 2083| 1.01k| return (NULL); 2084| 6.10k|} evhttp_clear_headers: 2114| 2.03k|{ 2115| 2.03k| struct evkeyval *header; 2116| | 2117| 2.03k| for (header = TAILQ_FIRST(headers); ------------------ | | 293| 2.03k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ 2118| 8.13k| header != NULL; ------------------ | Branch (2118:6): [True: 6.10k, False: 2.03k] ------------------ 2119| 6.10k| header = TAILQ_FIRST(headers)) { ------------------ | | 293| 6.10k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ 2120| 6.10k| TAILQ_REMOVE(headers, header, next); ------------------ | | 356| 6.10k|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 6.10k| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 4.06k, False: 2.03k] | | ------------------ | | 358| 6.10k| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 4.06k| (elm)->field.tqe_prev; \ | | 360| 6.10k| else \ | | 361| 6.10k| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 6.10k| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 6.10k|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 6.10k] | | ------------------ ------------------ 2121| 6.10k| mm_free(header->key); ------------------ | | 80| 6.10k|#define mm_free(p) event_mm_free_(p) ------------------ 2122| 6.10k| mm_free(header->value); ------------------ | | 80| 6.10k|#define mm_free(p) event_mm_free_(p) ------------------ 2123| 6.10k| mm_free(header); ------------------ | | 80| 6.10k|#define mm_free(p) event_mm_free_(p) ------------------ 2124| 6.10k| } 2125| 2.03k|} evhttp_add_header: 2170| 6.10k|{ 2171| 6.10k| event_debug(("%s: key: %s val: %s\n", __func__, key, value)); ------------------ | | 79| 6.10k|#define event_debug(x) do { \ | | 80| 6.10k| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 6.10k|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 6.10k] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 6.10k| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 6.10k] | | ------------------ ------------------ 2172| | 2173| | /* RFC 9110 defines field-names as case-sensitive non-empty strings made of the following characters */ 2174| | // field-name = 1*tchar 2175| | // tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~" / 0-9 / A-Z / a-z 2176| | /* For simplicity, we'll reject field-names containing the documented most dangerous characters */ 2177| | // "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." 2178| 6.10k| if (strchr(key, '\r') != NULL || strchr(key, '\n') != NULL || key[0] == '\0') { ------------------ | Branch (2178:6): [True: 0, False: 6.10k] | Branch (2178:35): [True: 0, False: 6.10k] | Branch (2178:64): [True: 0, False: 6.10k] ------------------ 2179| | /* drop illegal headers */ 2180| 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] | | ------------------ ------------------ 2181| 0| return (-1); 2182| 0| } 2183| | 2184| 6.10k| if (!evhttp_header_is_valid_value(value)) { ------------------ | Branch (2184:6): [True: 0, False: 6.10k] ------------------ 2185| 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] | | ------------------ ------------------ 2186| 0| return (-1); 2187| 0| } 2188| | 2189| 6.10k| return (evhttp_add_header_internal(headers, key, value)); 2190| 6.10k|} evhttp_connection_base_bufferevent_new: 2831| 1.01k|{ 2832| 1.01k| struct evhttp_connection *evcon; 2833| | 2834| 1.01k| event_debug(("Attempting connection to %s:%d\n", address, port)); ------------------ | | 79| 1.01k|#define event_debug(x) do { \ | | 80| 1.01k| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 1.01k|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 1.01k] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 1.01k| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 1.01k] | | ------------------ ------------------ 2835| | 2836| 1.01k| evcon = evhttp_connection_new_(base, bev); 2837| 1.01k| if (evcon == NULL) ------------------ | Branch (2837:6): [True: 0, False: 1.01k] ------------------ 2838| 0| goto error; 2839| | 2840| 1.01k| if ((evcon->address = mm_strdup(address)) == NULL) { ------------------ | | 78| 1.01k|#define mm_strdup(s) event_mm_strdup_(s) ------------------ | Branch (2840:6): [True: 0, False: 1.01k] ------------------ 2841| 0| event_warn("%s: strdup failed", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 2842| 0| goto error; 2843| 0| } 2844| 1.01k| evcon->port = port; 2845| 1.01k| evcon->dns_base = dnsbase; 2846| | 2847| 1.01k| return (evcon); 2848| 0|error: 2849| 0| if (evcon != NULL) ------------------ | Branch (2849:6): [True: 0, False: 0] ------------------ 2850| 0| evhttp_connection_free(evcon); 2851| | return (NULL); 2852| 1.01k|} evhttp_start_ws_: 3415| 1.01k|{ 3416| 1.01k| struct evhttp_connection *evcon = req->evcon; 3417| 1.01k| struct bufferevent *bufev; 3418| | 3419| 1.01k| evhttp_response_code_(req, HTTP_SWITCH_PROTOCOLS, "Switching Protocols"); ------------------ | | 57| 1.01k|#define HTTP_SWITCH_PROTOCOLS 101 /**< switching to another protocol */ ------------------ 3420| | 3421| 1.01k| if (req->evcon == NULL) ------------------ | Branch (3421:6): [True: 0, False: 1.01k] ------------------ 3422| 0| return NULL; 3423| | 3424| 1.01k| evhttp_make_header(req->evcon, req); 3425| 1.01k| evhttp_write_buffer(req->evcon, NULL, NULL); 3426| | 3427| 1.01k| TAILQ_REMOVE(&evcon->requests, req, next); ------------------ | | 356| 1.01k|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 1.01k| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 0, False: 1.01k] | | ------------------ | | 358| 1.01k| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 0| (elm)->field.tqe_prev; \ | | 360| 1.01k| else \ | | 361| 1.01k| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 1.01k| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 1.01k|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 1.01k] | | ------------------ ------------------ 3428| | 3429| 1.01k| bufev = evcon->bufev; 3430| 1.01k| evcon->bufev = NULL; 3431| 1.01k| evcon->closecb = NULL; 3432| | 3433| 1.01k| evhttp_request_free(req); 3434| 1.01k| evhttp_connection_free(evcon); 3435| 1.01k| return bufev; 3436| 1.01k|} evhttp_response_code_: 3565| 1.01k|{ 3566| 1.01k| req->kind = EVHTTP_RESPONSE; 3567| 1.01k| req->response_code = code; 3568| 1.01k| if (req->response_code_line != NULL) ------------------ | Branch (3568:6): [True: 0, False: 1.01k] ------------------ 3569| 0| mm_free(req->response_code_line); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 3570| 1.01k| if (reason == NULL) ------------------ | Branch (3570:6): [True: 0, False: 1.01k] ------------------ 3571| 0| reason = evhttp_response_phrase_internal(code); 3572| 1.01k| req->response_code_line = mm_strdup(reason); ------------------ | | 78| 1.01k|#define mm_strdup(s) event_mm_strdup_(s) ------------------ 3573| 1.01k| if (req->response_code_line == NULL) { ------------------ | Branch (3573:6): [True: 0, False: 1.01k] ------------------ 3574| 0| event_warn("%s: strdup", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 3575| | /* XXX what else can we do? */ 3576| 0| } 3577| 1.01k|} evhttp_new: 4211| 1.01k|{ 4212| 1.01k| struct evhttp *http = NULL; 4213| | 4214| 1.01k| http = evhttp_new_object(); 4215| 1.01k| if (http == NULL) ------------------ | Branch (4215:6): [True: 0, False: 1.01k] ------------------ 4216| 0| return (NULL); 4217| 1.01k| http->base = base; 4218| | 4219| 1.01k| return (http); 4220| 1.01k|} evhttp_free: 4244| 1.01k|{ 4245| 1.01k| struct evhttp_cb *http_cb; 4246| 1.01k| struct evhttp_connection *evcon; 4247| 1.01k| struct evws_connection *evws; 4248| 1.01k| struct evhttp_bound_socket *bound; 4249| 1.01k| struct evhttp* vhost; 4250| 1.01k| struct evhttp_server_alias *alias; 4251| | 4252| | /* Remove the accepting part */ 4253| 1.01k| while ((bound = TAILQ_FIRST(&http->sockets)) != NULL) { ------------------ | | 293| 1.01k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (4253:9): [True: 0, False: 1.01k] ------------------ 4254| 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] | | ------------------ ------------------ 4255| | 4256| 0| evconnlistener_free(bound->listener); 4257| | 4258| 0| mm_free(bound); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4259| 0| } 4260| | 4261| 1.01k| while ((evcon = TAILQ_FIRST(&http->connections)) != NULL) { ------------------ | | 293| 1.01k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (4261:9): [True: 0, False: 1.01k] ------------------ 4262| | /* evhttp_connection_free removes the connection */ 4263| 0| evhttp_connection_free(evcon); 4264| 0| } 4265| | 4266| 1.01k| while ((evws = TAILQ_FIRST(&http->ws_sessions)) != NULL) { ------------------ | | 293| 1.01k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (4266:9): [True: 0, False: 1.01k] ------------------ 4267| 0| evws_connection_free(evws); 4268| 0| } 4269| | 4270| 1.01k| while ((http_cb = TAILQ_FIRST(&http->callbacks)) != NULL) { ------------------ | | 293| 1.01k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (4270:9): [True: 0, False: 1.01k] ------------------ 4271| 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] | | ------------------ ------------------ 4272| 0| mm_free(http_cb->what); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4273| 0| mm_free(http_cb); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4274| 0| } 4275| | 4276| 1.01k| while ((vhost = TAILQ_FIRST(&http->virtualhosts)) != NULL) { ------------------ | | 293| 1.01k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (4276:9): [True: 0, False: 1.01k] ------------------ 4277| 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] | | ------------------ ------------------ 4278| | 4279| 0| evhttp_free(vhost); 4280| 0| } 4281| | 4282| 1.01k| if (http->vhost_pattern != NULL) ------------------ | Branch (4282:6): [True: 0, False: 1.01k] ------------------ 4283| 0| mm_free(http->vhost_pattern); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4284| | 4285| 1.01k| while ((alias = TAILQ_FIRST(&http->aliases)) != NULL) { ------------------ | | 293| 1.01k|#define TAILQ_FIRST(head) ((head)->tqh_first) ------------------ | Branch (4285:9): [True: 0, False: 1.01k] ------------------ 4286| 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] | | ------------------ ------------------ 4287| 0| mm_free(alias->alias); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4288| 0| mm_free(alias); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4289| 0| } 4290| | 4291| 1.01k| mm_free(http); ------------------ | | 80| 1.01k|#define mm_free(p) event_mm_free_(p) ------------------ 4292| 1.01k|} evhttp_set_max_headers_size: 4402| 1.01k|{ 4403| 1.01k| if (max_headers_size < 0) ------------------ | Branch (4403:6): [True: 1.01k, False: 0] ------------------ 4404| 1.01k| http->default_max_headers_size = EV_SIZE_MAX; ------------------ | | 289| 1.01k|#define EV_SIZE_MAX EV_UINT64_MAX | | ------------------ | | | | 267| 1.01k|#define EV_UINT64_MAX UINT64_MAX | | ------------------ ------------------ 4405| 0| else 4406| 0| http->default_max_headers_size = max_headers_size; 4407| 1.01k|} evhttp_set_max_body_size: 4411| 1.01k|{ 4412| 1.01k| if (max_body_size < 0) ------------------ | Branch (4412:6): [True: 1.01k, False: 0] ------------------ 4413| 1.01k| http->default_max_body_size = EV_UINT64_MAX; ------------------ | | 267| 1.01k|#define EV_UINT64_MAX UINT64_MAX ------------------ 4414| 0| else 4415| 0| http->default_max_body_size = max_body_size; 4416| 1.01k|} evhttp_set_default_content_type: 4435| 1.01k| const char *content_type) { 4436| 1.01k| http->default_content_type = content_type; 4437| 1.01k|} evhttp_set_allowed_methods: 4441| 1.01k|{ 4442| 1.01k| http->allowed_methods = methods; 4443| 1.01k|} evhttp_request_new: 4538| 1.01k|{ 4539| 1.01k| struct evhttp_request *req = NULL; 4540| | 4541| | /* Allocate request structure */ 4542| 1.01k| if ((req = mm_calloc(1, sizeof(struct evhttp_request))) == NULL) { ------------------ | | 77| 1.01k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ | Branch (4542:6): [True: 0, False: 1.01k] ------------------ 4543| 0| event_warn("%s: calloc", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 4544| 0| goto error; 4545| 0| } 4546| | 4547| 1.01k| req->headers_size = 0; 4548| 1.01k| req->body_size = 0; 4549| | 4550| 1.01k| req->kind = EVHTTP_RESPONSE; 4551| 1.01k| req->input_headers = mm_calloc(1, sizeof(struct evkeyvalq)); ------------------ | | 77| 1.01k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ 4552| 1.01k| if (req->input_headers == NULL) { ------------------ | Branch (4552:6): [True: 0, False: 1.01k] ------------------ 4553| 0| event_warn("%s: calloc", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 4554| 0| goto error; 4555| 0| } 4556| 1.01k| TAILQ_INIT(req->input_headers); ------------------ | | 317| 1.01k|#define TAILQ_INIT(head) do { \ | | 318| 1.01k| (head)->tqh_first = NULL; \ | | 319| 1.01k| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 1.01k|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 1.01k] | | ------------------ ------------------ 4557| | 4558| 1.01k| req->output_headers = mm_calloc(1, sizeof(struct evkeyvalq)); ------------------ | | 77| 1.01k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ 4559| 1.01k| if (req->output_headers == NULL) { ------------------ | Branch (4559:6): [True: 0, False: 1.01k] ------------------ 4560| 0| event_warn("%s: calloc", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 4561| 0| goto error; 4562| 0| } 4563| 1.01k| TAILQ_INIT(req->output_headers); ------------------ | | 317| 1.01k|#define TAILQ_INIT(head) do { \ | | 318| 1.01k| (head)->tqh_first = NULL; \ | | 319| 1.01k| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 1.01k|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 1.01k] | | ------------------ ------------------ 4564| | 4565| 1.01k| if ((req->input_buffer = evbuffer_new()) == NULL) { ------------------ | Branch (4565:6): [True: 0, False: 1.01k] ------------------ 4566| 0| event_warn("%s: evbuffer_new", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 4567| 0| goto error; 4568| 0| } 4569| | 4570| 1.01k| if ((req->output_buffer = evbuffer_new()) == NULL) { ------------------ | Branch (4570:6): [True: 0, False: 1.01k] ------------------ 4571| 0| event_warn("%s: evbuffer_new", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 4572| 0| goto error; 4573| 0| } 4574| | 4575| 1.01k| req->cb = cb; 4576| 1.01k| req->cb_arg = arg; 4577| | 4578| 1.01k| return (req); 4579| | 4580| 0| error: 4581| 0| if (req != NULL) ------------------ | Branch (4581:6): [True: 0, False: 0] ------------------ 4582| 0| evhttp_request_free(req); 4583| | return (NULL); 4584| 1.01k|} evhttp_request_free: 4588| 1.01k|{ 4589| 1.01k| if ((req->flags & EVHTTP_REQ_DEFER_FREE) != 0) { ------------------ | | 188| 1.01k|#define EVHTTP_REQ_DEFER_FREE 0x0008 ------------------ | Branch (4589:6): [True: 0, False: 1.01k] ------------------ 4590| 0| req->flags |= EVHTTP_REQ_NEEDS_FREE; ------------------ | | 190| 0|#define EVHTTP_REQ_NEEDS_FREE 0x0010 ------------------ 4591| 0| return; 4592| 0| } 4593| | 4594| 1.01k| if (req->remote_host != NULL) ------------------ | Branch (4594:6): [True: 0, False: 1.01k] ------------------ 4595| 0| mm_free(req->remote_host); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4596| 1.01k| if (req->uri != NULL) ------------------ | Branch (4596:6): [True: 0, False: 1.01k] ------------------ 4597| 0| mm_free(req->uri); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4598| 1.01k| if (req->uri_elems != NULL) ------------------ | Branch (4598:6): [True: 0, False: 1.01k] ------------------ 4599| 0| evhttp_uri_free(req->uri_elems); 4600| 1.01k| if (req->response_code_line != NULL) ------------------ | Branch (4600:6): [True: 1.01k, False: 0] ------------------ 4601| 1.01k| mm_free(req->response_code_line); ------------------ | | 80| 1.01k|#define mm_free(p) event_mm_free_(p) ------------------ 4602| 1.01k| if (req->host_cache != NULL) ------------------ | Branch (4602:6): [True: 0, False: 1.01k] ------------------ 4603| 0| mm_free(req->host_cache); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 4604| | 4605| 1.01k| evhttp_clear_headers(req->input_headers); 4606| 1.01k| mm_free(req->input_headers); ------------------ | | 80| 1.01k|#define mm_free(p) event_mm_free_(p) ------------------ 4607| | 4608| 1.01k| evhttp_clear_headers(req->output_headers); 4609| 1.01k| mm_free(req->output_headers); ------------------ | | 80| 1.01k|#define mm_free(p) event_mm_free_(p) ------------------ 4610| | 4611| 1.01k| if (req->input_buffer != NULL) ------------------ | Branch (4611:6): [True: 1.01k, False: 0] ------------------ 4612| 1.01k| evbuffer_free(req->input_buffer); 4613| | 4614| 1.01k| if (req->output_buffer != NULL) ------------------ | Branch (4614:6): [True: 1.01k, False: 0] ------------------ 4615| 1.01k| evbuffer_free(req->output_buffer); 4616| | 4617| 1.01k| mm_free(req); ------------------ | | 80| 1.01k|#define mm_free(p) event_mm_free_(p) ------------------ 4618| 1.01k|} evhttp_request_get_connection: 4634| 1.01k|{ 4635| 1.01k| return req->evcon; 4636| 1.01k|} evhttp_request_get_input_headers: 4749| 2.03k|{ 4750| 2.03k| return (req->input_headers); 4751| 2.03k|} evhttp_request_get_output_headers: 4755| 1.01k|{ 4756| 1.01k| return (req->output_headers); 4757| 1.01k|} http.c:evhttp_connected: 494| 1.01k|{ 495| 1.01k| switch (evcon->state) { 496| 1.01k| case EVCON_DISCONNECTED: ------------------ | Branch (496:2): [True: 1.01k, False: 0] ------------------ 497| 1.01k| case EVCON_CONNECTING: ------------------ | Branch (497:2): [True: 0, False: 1.01k] ------------------ 498| 1.01k| return (0); 499| 0| case EVCON_IDLE: ------------------ | Branch (499:2): [True: 0, False: 1.01k] ------------------ 500| 0| case EVCON_READING_FIRSTLINE: ------------------ | Branch (500:2): [True: 0, False: 1.01k] ------------------ 501| 0| case EVCON_READING_HEADERS: ------------------ | Branch (501:2): [True: 0, False: 1.01k] ------------------ 502| 0| case EVCON_READING_BODY: ------------------ | Branch (502:2): [True: 0, False: 1.01k] ------------------ 503| 0| case EVCON_READING_TRAILER: ------------------ | Branch (503:2): [True: 0, False: 1.01k] ------------------ 504| 0| case EVCON_WRITING: ------------------ | Branch (504:2): [True: 0, False: 1.01k] ------------------ 505| 0| default: ------------------ | Branch (505:2): [True: 0, False: 1.01k] ------------------ 506| 0| return (1); 507| 1.01k| } 508| 1.01k|} http.c:evhttp_header_is_valid_value: 2156| 6.10k|{ 2157| 6.10k| const char *p = value; 2158| | 2159| 6.10k| if (strpbrk(p, "\r\n") != NULL) { ------------------ | Branch (2159:6): [True: 0, False: 6.10k] ------------------ 2160| | /* Reject any header containing CR or LF. */ 2161| 0| return (0); 2162| 0| } 2163| | 2164| 6.10k| return (1); 2165| 6.10k|} http.c:evhttp_add_header_internal: 2195| 6.10k|{ 2196| 6.10k| struct evkeyval *header = mm_calloc(1, sizeof(struct evkeyval)); ------------------ | | 77| 6.10k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ 2197| 6.10k| if (header == NULL) { ------------------ | Branch (2197:6): [True: 0, False: 6.10k] ------------------ 2198| 0| event_warn("%s: calloc", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 2199| 0| return (-1); 2200| 0| } 2201| 6.10k| if ((header->key = mm_strdup(key)) == NULL) { ------------------ | | 78| 6.10k|#define mm_strdup(s) event_mm_strdup_(s) ------------------ | Branch (2201:6): [True: 0, False: 6.10k] ------------------ 2202| 0| mm_free(header); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 2203| 0| event_warn("%s: strdup", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 2204| 0| return (-1); 2205| 0| } 2206| 6.10k| if ((header->value = mm_strdup(value)) == NULL) { ------------------ | | 78| 6.10k|#define mm_strdup(s) event_mm_strdup_(s) ------------------ | Branch (2206:6): [True: 0, False: 6.10k] ------------------ 2207| 0| mm_free(header->key); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 2208| 0| mm_free(header); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 2209| 0| event_warn("%s: strdup", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 2210| 0| return (-1); 2211| 0| } 2212| | 2213| 6.10k| TAILQ_INSERT_TAIL(headers, header, next); ------------------ | | 332| 6.10k|#define TAILQ_INSERT_TAIL(head, elm, field) do { \ | | 333| 6.10k| (elm)->field.tqe_next = NULL; \ | | 334| 6.10k| (elm)->field.tqe_prev = (head)->tqh_last; \ | | 335| 6.10k| *(head)->tqh_last = (elm); \ | | 336| 6.10k| (head)->tqh_last = &(elm)->field.tqe_next; \ | | 337| 6.10k|} while (0) | | ------------------ | | | Branch (337:10): [Folded, False: 6.10k] | | ------------------ ------------------ 2214| | 2215| 6.10k| return (0); 2216| 6.10k|} http.c:evhttp_connection_new_: 2717| 1.01k|{ 2718| 1.01k| struct evhttp_connection *evcon; 2719| | 2720| 1.01k| if ((evcon = mm_calloc(1, sizeof(struct evhttp_connection))) == NULL) { ------------------ | | 77| 1.01k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ | Branch (2720:6): [True: 0, False: 1.01k] ------------------ 2721| 0| event_warn("%s: calloc failed", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 2722| 0| goto error; 2723| 0| } 2724| | 2725| 1.01k| evcon->max_headers_size = EV_SIZE_MAX; ------------------ | | 289| 1.01k|#define EV_SIZE_MAX EV_UINT64_MAX | | ------------------ | | | | 267| 1.01k|#define EV_UINT64_MAX UINT64_MAX | | ------------------ ------------------ 2726| 1.01k| evcon->max_body_size = EV_SIZE_MAX; ------------------ | | 289| 1.01k|#define EV_SIZE_MAX EV_UINT64_MAX | | ------------------ | | | | 267| 1.01k|#define EV_UINT64_MAX UINT64_MAX | | ------------------ ------------------ 2727| | 2728| 1.01k| evcon->timeout_connect.tv_sec = HTTP_CONNECT_TIMEOUT; ------------------ | | 17| 1.01k|#define HTTP_CONNECT_TIMEOUT 45 ------------------ 2729| 1.01k| evcon->timeout_read.tv_sec = HTTP_READ_TIMEOUT; ------------------ | | 19| 1.01k|#define HTTP_READ_TIMEOUT 50 ------------------ 2730| 1.01k| evcon->timeout_write.tv_sec = HTTP_WRITE_TIMEOUT; ------------------ | | 18| 1.01k|#define HTTP_WRITE_TIMEOUT 50 ------------------ 2731| 1.01k| evcon->initial_retry_timeout.tv_sec = HTTP_INITIAL_RETRY_TIMEOUT; ------------------ | | 20| 1.01k|#define HTTP_INITIAL_RETRY_TIMEOUT 2 ------------------ 2732| | 2733| 1.01k| evcon->retry_cnt = evcon->retry_max = 0; 2734| | 2735| 1.01k| if (bev == NULL) { ------------------ | Branch (2735:6): [True: 0, False: 1.01k] ------------------ 2736| 0| if (!(bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE))) { ------------------ | Branch (2736:7): [True: 0, False: 0] ------------------ 2737| 0| event_warn("%s: bufferevent_socket_new failed", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 2738| 0| goto error; 2739| 0| } 2740| 0| } 2741| | 2742| 1.01k| bufferevent_setcb(bev, evhttp_read_cb, evhttp_write_cb, evhttp_error_cb, evcon); 2743| 1.01k| evcon->bufev = bev; 2744| | 2745| 1.01k| evcon->state = EVCON_DISCONNECTED; 2746| 1.01k| TAILQ_INIT(&evcon->requests); ------------------ | | 317| 1.01k|#define TAILQ_INIT(head) do { \ | | 318| 1.01k| (head)->tqh_first = NULL; \ | | 319| 1.01k| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 1.01k|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 1.01k] | | ------------------ ------------------ 2747| | 2748| 1.01k| if (base != NULL) { ------------------ | Branch (2748:6): [True: 1.01k, False: 0] ------------------ 2749| 1.01k| evcon->base = base; 2750| 1.01k| if (bufferevent_get_base(bev) != base) ------------------ | Branch (2750:7): [True: 0, False: 1.01k] ------------------ 2751| 0| bufferevent_base_set(base, evcon->bufev); 2752| 1.01k| } 2753| | 2754| 1.01k| event_deferred_cb_init_( 2755| 1.01k| &evcon->read_more_deferred_cb, 2756| 1.01k| bufferevent_get_priority(bev), 2757| 1.01k| evhttp_deferred_read_cb, evcon); 2758| | 2759| 1.01k| evcon->ai_family = AF_UNSPEC; 2760| | 2761| 1.01k| return (evcon); 2762| | 2763| 0| error: 2764| 0| if (evcon != NULL) ------------------ | Branch (2764:6): [True: 0, False: 0] ------------------ 2765| 0| evhttp_connection_free(evcon); 2766| | return (NULL); 2767| 1.01k|} http.c:evhttp_have_expect: 661| 1.01k|{ 662| 1.01k| const char *expect; 663| 1.01k| struct evkeyvalq *h = input ? req->input_headers : req->output_headers; ------------------ | Branch (663:24): [True: 0, False: 1.01k] ------------------ 664| | 665| 1.01k| if (!(req->kind == EVHTTP_REQUEST) || !REQ_VERSION_ATLEAST(req, 1, 1)) ------------------ | | 176| 0| ((req)->major > (major_v) || \ | | ------------------ | | | Branch (176:3): [True: 0, False: 0] | | ------------------ | | 177| 0| ((req)->major == (major_v) && (req)->minor >= (minor_v))) | | ------------------ | | | Branch (177:7): [True: 0, False: 0] | | | Branch (177:36): [True: 0, False: 0] | | ------------------ ------------------ | Branch (665:6): [True: 1.01k, False: 0] ------------------ 666| 1.01k| return NO; 667| | 668| 0| expect = evhttp_find_header(h, "Expect"); 669| 0| if (!expect) ------------------ | Branch (669:6): [True: 0, False: 0] ------------------ 670| 0| return NO; 671| | 672| 0| return !evutil_ascii_strcasecmp(expect, "100-continue") ? CONTINUE : OTHER; ------------------ | Branch (672:9): [True: 0, False: 0] ------------------ 673| 0|} http.c:evhttp_is_connection_close: 549| 1.01k|{ 550| 1.01k| const char *connection = evhttp_find_header(headers, "Connection"); 551| 1.01k| return (connection != NULL && evutil_ascii_strcasecmp(connection, "close") == 0); ------------------ | Branch (551:10): [True: 1.01k, False: 0] | Branch (551:32): [True: 0, False: 1.01k] ------------------ 552| 1.01k|} http.c:evhttp_write_buffer: 449| 1.01k|{ 450| 1.01k| event_debug(("%s: preparing to write buffer\n", __func__)); ------------------ | | 79| 1.01k|#define event_debug(x) do { \ | | 80| 1.01k| if (event_debug_get_logging_mask_()) { \ | | ------------------ | | | | 52| 1.01k|#define event_debug_get_logging_mask_() (event_debug_logging_mask_) | | | | ------------------ | | | | | Branch (52:41): [True: 0, False: 1.01k] | | | | ------------------ | | ------------------ | | 81| 0| event_debugx_ x; \ | | 82| 0| } \ | | 83| 1.01k| } while (0) | | ------------------ | | | Branch (83:11): [Folded, False: 1.01k] | | ------------------ ------------------ 451| | 452| | /* Set call back */ 453| 1.01k| evcon->cb = cb; 454| 1.01k| evcon->cb_arg = arg; 455| | 456| | /* Disable the read callback: we don't actually care about data; 457| | * we only care about close detection. (We don't disable reading -- 458| | * EV_READ, since we *do* want to learn about any close events.) */ 459| 1.01k| bufferevent_setcb(evcon->bufev, 460| 1.01k| NULL, /*read*/ 461| 1.01k| evhttp_write_cb, 462| 1.01k| evhttp_error_cb, 463| 1.01k| evcon); 464| | 465| 1.01k| bufferevent_enable(evcon->bufev, EV_READ|EV_WRITE); ------------------ | | 957| 1.01k|#define EV_READ 0x02 ------------------ bufferevent_enable(evcon->bufev, EV_READ|EV_WRITE); ------------------ | | 959| 1.01k|#define EV_WRITE 0x04 ------------------ 466| 1.01k|} http.c:evhttp_response_needs_body: 434| 1.01k|{ 435| 1.01k| return (req->response_code != HTTP_NOCONTENT && ------------------ | | 64| 2.03k|#define HTTP_NOCONTENT 204 /**< request does not have content */ ------------------ | Branch (435:10): [True: 1.01k, False: 0] ------------------ 436| 1.01k| req->response_code != HTTP_NOTMODIFIED && ------------------ | | 67| 2.03k|#define HTTP_NOTMODIFIED 304 /**< page was not modified from last */ ------------------ | Branch (436:3): [True: 1.01k, False: 0] ------------------ 437| 1.01k| (req->response_code < 100 || req->response_code >= 200) && ------------------ | Branch (437:4): [True: 0, False: 1.01k] | Branch (437:32): [True: 0, False: 1.01k] ------------------ 438| 0| req->type != EVHTTP_REQ_CONNECT && ------------------ | Branch (438:3): [True: 0, False: 0] ------------------ 439| 0| req->type != EVHTTP_REQ_HEAD); ------------------ | Branch (439:3): [True: 0, False: 0] ------------------ 440| 1.01k|} http.c:evhttp_make_header: 681| 1.01k|{ 682| 1.01k| struct evkeyval *header; 683| 1.01k| struct evbuffer *output = bufferevent_get_output(evcon->bufev); 684| | 685| | /* 686| | * Depending if this is a HTTP request or response, we might need to 687| | * add some new headers or remove existing headers. 688| | */ 689| 1.01k| if (req->kind == EVHTTP_REQUEST) { ------------------ | Branch (689:6): [True: 0, False: 1.01k] ------------------ 690| 0| evhttp_make_header_request(evcon, req); 691| 1.01k| } else { 692| 1.01k| evhttp_make_header_response(evcon, req); 693| 1.01k| } 694| | 695| 3.05k| TAILQ_FOREACH(header, req->output_headers, next) { ------------------ | | 305| 1.01k| for((var) = TAILQ_FIRST(head); \ | | ------------------ | | | | 293| 1.01k|#define TAILQ_FIRST(head) ((head)->tqh_first) | | ------------------ | | 306| 4.06k| (var) != TAILQ_END(head); \ | | ------------------ | | | | 294| 4.06k|#define TAILQ_END(head) NULL | | ------------------ | | | Branch (306:6): [True: 3.05k, False: 1.01k] | | ------------------ | | 307| 3.05k| (var) = TAILQ_NEXT(var, field)) | | ------------------ | | | | 295| 3.05k|#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) | | ------------------ ------------------ 696| 3.05k| evbuffer_add_printf(output, "%s: %s\r\n", 697| 3.05k| header->key, header->value); 698| 3.05k| } 699| 1.01k| evbuffer_add(output, "\r\n", 2); 700| | 701| 1.01k| if (evhttp_have_expect(req, 0) != CONTINUE && ------------------ | Branch (701:6): [True: 1.01k, False: 0] ------------------ 702| 1.01k| evbuffer_get_length(req->output_buffer)) { ------------------ | Branch (702:3): [True: 0, False: 1.01k] ------------------ 703| | /* 704| | * For a request, we add the POST data, for a reply, this 705| | * is the regular data. 706| | */ 707| 0| evbuffer_add_buffer(output, req->output_buffer); 708| 0| } 709| 1.01k|} http.c:evhttp_make_header_response: 608| 1.01k|{ 609| 1.01k| int is_keepalive = evhttp_is_connection_keepalive(req->input_headers); 610| 1.01k| int need_body = evhttp_response_needs_body(req); 611| | 612| 1.01k| evbuffer_add_printf(bufferevent_get_output(evcon->bufev), 613| 1.01k| "HTTP/%d.%d %d %s\r\n", 614| 1.01k| req->major, req->minor, req->response_code, 615| 1.01k| req->response_code_line); 616| | 617| 1.01k| if (req->major == 1) { ------------------ | Branch (617:6): [True: 0, False: 1.01k] ------------------ 618| 0| if (req->minor >= 1) ------------------ | Branch (618:7): [True: 0, False: 0] ------------------ 619| 0| evhttp_maybe_add_date_header(req->output_headers); 620| | 621| | /* 622| | * if the protocol is 1.0; and the connection was keep-alive 623| | * we need to add a keep-alive header, too. 624| | */ 625| 0| if (req->minor == 0 && is_keepalive) ------------------ | Branch (625:7): [True: 0, False: 0] | Branch (625:26): [True: 0, False: 0] ------------------ 626| 0| evhttp_add_header(req->output_headers, 627| 0| "Connection", "keep-alive"); 628| | 629| 0| if ((req->minor >= 1 || is_keepalive) && need_body) { ------------------ | Branch (629:8): [True: 0, False: 0] | Branch (629:27): [True: 0, False: 0] | Branch (629:44): [True: 0, False: 0] ------------------ 630| | /* 631| | * we need to add the content length if the 632| | * user did not give it, this is required for 633| | * persistent connections to work. 634| | */ 635| 0| evhttp_maybe_add_content_length_header( 636| 0| req->output_headers, 637| 0| evbuffer_get_length(req->output_buffer)); 638| 0| } 639| 0| } 640| | 641| | /* Potentially add headers for unidentified content. */ 642| 1.01k| if (need_body) { ------------------ | Branch (642:6): [True: 0, False: 1.01k] ------------------ 643| 0| if (evhttp_find_header(req->output_headers, ------------------ | Branch (643:7): [True: 0, False: 0] ------------------ 644| 0| "Content-Type") == NULL 645| 0| && evcon->http_server->default_content_type) { ------------------ | Branch (645:10): [True: 0, False: 0] ------------------ 646| 0| evhttp_add_header(req->output_headers, 647| 0| "Content-Type", 648| 0| evcon->http_server->default_content_type); 649| 0| } 650| 0| } 651| | 652| | /* if the request asked for a close, we send a close, too */ 653| 1.01k| if (evhttp_is_connection_close(req->flags, req->input_headers)) { ------------------ | Branch (653:6): [True: 0, False: 1.01k] ------------------ 654| 0| evhttp_remove_header(req->output_headers, "Connection"); 655| 0| evhttp_add_header(req->output_headers, "Connection", "close"); 656| 0| } 657| 1.01k|} http.c:evhttp_is_connection_keepalive: 568| 1.01k|{ 569| 1.01k| const char *connection = evhttp_find_header(headers, "Connection"); 570| 1.01k| return (connection != NULL ------------------ | Branch (570:10): [True: 1.01k, False: 0] ------------------ 571| 1.01k| && evutil_ascii_strncasecmp(connection, "keep-alive", 10) == 0); ------------------ | Branch (571:9): [True: 0, False: 1.01k] ------------------ 572| 1.01k|} http.c:evhttp_new_object: 4178| 1.01k|{ 4179| 1.01k| struct evhttp *http = NULL; 4180| | 4181| 1.01k| if ((http = mm_calloc(1, sizeof(struct evhttp))) == NULL) { ------------------ | | 77| 1.01k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ | Branch (4181:6): [True: 0, False: 1.01k] ------------------ 4182| 0| event_warn("%s: calloc", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 4183| 0| return (NULL); 4184| 0| } 4185| | 4186| 1.01k| evutil_timerclear(&http->timeout_read); ------------------ | | 604| 1.01k|#define evutil_timerclear(tvp) timerclear(tvp) ------------------ 4187| 1.01k| evutil_timerclear(&http->timeout_write); ------------------ | | 604| 1.01k|#define evutil_timerclear(tvp) timerclear(tvp) ------------------ 4188| | 4189| 1.01k| evhttp_set_max_headers_size(http, EV_SIZE_MAX); ------------------ | | 289| 1.01k|#define EV_SIZE_MAX EV_UINT64_MAX | | ------------------ | | | | 267| 1.01k|#define EV_UINT64_MAX UINT64_MAX | | ------------------ ------------------ 4190| 1.01k| evhttp_set_max_body_size(http, EV_SIZE_MAX); ------------------ | | 289| 1.01k|#define EV_SIZE_MAX EV_UINT64_MAX | | ------------------ | | | | 267| 1.01k|#define EV_UINT64_MAX UINT64_MAX | | ------------------ ------------------ 4191| 1.01k| evhttp_set_default_content_type(http, "text/html; charset=ISO-8859-1"); 4192| 1.01k| evhttp_set_allowed_methods(http, 4193| 1.01k| EVHTTP_REQ_GET | 4194| 1.01k| EVHTTP_REQ_POST | 4195| 1.01k| EVHTTP_REQ_HEAD | 4196| 1.01k| EVHTTP_REQ_PUT | 4197| 1.01k| EVHTTP_REQ_DELETE); 4198| | 4199| 1.01k| TAILQ_INIT(&http->sockets); ------------------ | | 317| 1.01k|#define TAILQ_INIT(head) do { \ | | 318| 1.01k| (head)->tqh_first = NULL; \ | | 319| 1.01k| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 1.01k|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 1.01k] | | ------------------ ------------------ 4200| 1.01k| TAILQ_INIT(&http->callbacks); ------------------ | | 317| 1.01k|#define TAILQ_INIT(head) do { \ | | 318| 1.01k| (head)->tqh_first = NULL; \ | | 319| 1.01k| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 1.01k|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 1.01k] | | ------------------ ------------------ 4201| 1.01k| TAILQ_INIT(&http->connections); ------------------ | | 317| 1.01k|#define TAILQ_INIT(head) do { \ | | 318| 1.01k| (head)->tqh_first = NULL; \ | | 319| 1.01k| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 1.01k|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 1.01k] | | ------------------ ------------------ 4202| 1.01k| TAILQ_INIT(&http->ws_sessions); ------------------ | | 317| 1.01k|#define TAILQ_INIT(head) do { \ | | 318| 1.01k| (head)->tqh_first = NULL; \ | | 319| 1.01k| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 1.01k|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 1.01k] | | ------------------ ------------------ 4203| 1.01k| TAILQ_INIT(&http->virtualhosts); ------------------ | | 317| 1.01k|#define TAILQ_INIT(head) do { \ | | 318| 1.01k| (head)->tqh_first = NULL; \ | | 319| 1.01k| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 1.01k|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 1.01k] | | ------------------ ------------------ 4204| 1.01k| TAILQ_INIT(&http->aliases); ------------------ | | 317| 1.01k|#define TAILQ_INIT(head) do { \ | | 318| 1.01k| (head)->tqh_first = NULL; \ | | 319| 1.01k| (head)->tqh_last = &(head)->tqh_first; \ | | 320| 1.01k|} while (0) | | ------------------ | | | Branch (320:10): [Folded, False: 1.01k] | | ------------------ ------------------ 4205| | 4206| 1.01k| return (http); 4207| 1.01k|} event_warn: 114| 42.0k|{ 115| 42.0k| va_list ap; 116| | 117| 42.0k| va_start(ap, fmt); 118| 42.0k| event_logv_(EVENT_LOG_WARN, strerror(errno), fmt, ap); ------------------ | | 738| 42.0k|#define EVENT_LOG_WARN 2 ------------------ 119| | va_end(ap); 120| 42.0k|} event_logv_: 188| 42.0k|{ 189| 42.0k| char buf[1024]; 190| 42.0k| size_t len; 191| | 192| 42.0k| if (severity == EVENT_LOG_DEBUG && !event_debug_get_logging_mask_()) ------------------ | | 736| 84.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: 42.0k] | Branch (192:37): [True: 0, False: 0] ------------------ 193| 0| return; 194| | 195| 42.0k| if (fmt != NULL) ------------------ | Branch (195:6): [True: 42.0k, False: 0] ------------------ 196| 42.0k| evutil_vsnprintf(buf, sizeof(buf), fmt, ap); 197| 0| else 198| 0| buf[0] = '\0'; 199| | 200| 42.0k| if (errstr) { ------------------ | Branch (200:6): [True: 42.0k, False: 0] ------------------ 201| 42.0k| len = strlen(buf); 202| 42.0k| if (len < sizeof(buf) - 3) { ------------------ | Branch (202:7): [True: 42.0k, False: 0] ------------------ 203| 42.0k| evutil_snprintf(buf + len, sizeof(buf) - len, ": %s", errstr); 204| 42.0k| } 205| 42.0k| } 206| | 207| 42.0k| event_log(severity, buf); 208| 42.0k|} log.c:event_log: 220| 42.0k|{ 221| 42.0k| if (log_fn) ------------------ | Branch (221:6): [True: 0, False: 42.0k] ------------------ 222| 0| log_fn(severity, msg); 223| 42.0k| else { 224| 42.0k| const char *severity_str; 225| 42.0k| switch (severity) { 226| 0| case EVENT_LOG_DEBUG: ------------------ | | 736| 0|#define EVENT_LOG_DEBUG 0 ------------------ | Branch (226:3): [True: 0, False: 42.0k] ------------------ 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: 42.0k] ------------------ 230| 0| severity_str = "msg"; 231| 0| break; 232| 42.0k| case EVENT_LOG_WARN: ------------------ | | 738| 42.0k|#define EVENT_LOG_WARN 2 ------------------ | Branch (232:3): [True: 42.0k, False: 0] ------------------ 233| 42.0k| severity_str = "warn"; 234| 42.0k| break; 235| 0| case EVENT_LOG_ERR: ------------------ | | 739| 0|#define EVENT_LOG_ERR 3 ------------------ | Branch (235:3): [True: 0, False: 42.0k] ------------------ 236| 0| severity_str = "err"; 237| 0| break; 238| 0| default: ------------------ | Branch (238:3): [True: 0, False: 42.0k] ------------------ 239| 0| severity_str = "???"; 240| 0| break; 241| 42.0k| } 242| 42.0k| (void)fprintf(stderr, "[%s] %s\n", severity_str, msg); 243| 42.0k| } 244| 42.0k|} event.c:min_heap_ctor_: 64| 1.01k|void min_heap_ctor_(min_heap_t* s) { s->p = 0; s->n = 0; s->a = 0; } event.c:min_heap_dtor_: 65| 1.01k|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: 1.01k] ------------------ event.c:min_heap_elem_init_: 66| 5.08k|void min_heap_elem_init_(struct event* e) { e->ev_timeout_pos.min_heap_idx = EV_SIZE_MAX; } ------------------ | | 289| 5.08k|#define EV_SIZE_MAX EV_UINT64_MAX | | ------------------ | | | | 267| 5.08k|#define EV_UINT64_MAX UINT64_MAX | | ------------------ ------------------ event.c:min_heap_top_: 69| 1.01k|struct event* min_heap_top_(min_heap_t* s) { return s->n ? *s->p : 0; } ------------------ | Branch (69:53): [True: 0, False: 1.01k] ------------------ event.c:min_heap_empty_: 67| 1.01k|int min_heap_empty_(min_heap_t* s) { return 0 == s->n; } builtin_SHA1: 293| 1.01k|void builtin_SHA1(char *hash_out, const char *str, int len) { 294| 1.01k| SHA1_CTX ctx; 295| 1.01k| int ii; 296| | 297| 1.01k| SHA1Init(&ctx); 298| 62.0k| for (ii = 0; ii < len; ii += 1) ------------------ | Branch (298:18): [True: 61.0k, False: 1.01k] ------------------ 299| 61.0k| SHA1Update(&ctx, (const unsigned char *)str + ii, 1); 300| 1.01k| SHA1Final((unsigned char *)hash_out, &ctx); 301| 1.01k|} sha1.c:SHA1Init: 210| 1.01k|static void SHA1Init(SHA1_CTX *context) { 211| | /* SHA1 initialization constants */ 212| 1.01k| context->state[0] = 0x67452301; 213| 1.01k| context->state[1] = 0xEFCDAB89; 214| 1.01k| context->state[2] = 0x98BADCFE; 215| 1.01k| context->state[3] = 0x10325476; 216| 1.01k| context->state[4] = 0xC3D2E1F0; 217| 1.01k| context->count[0] = context->count[1] = 0; 218| 1.01k|} sha1.c:SHA1Update: 222| 123k|static void SHA1Update(SHA1_CTX *context, const unsigned char *data, uint32_t len) { 223| 123k| uint32_t i; 224| | 225| 123k| uint32_t j; 226| | 227| 123k| j = context->count[0]; 228| 123k| if ((context->count[0] += len << 3) < j) ------------------ | Branch (228:9): [True: 0, False: 123k] ------------------ 229| 0| context->count[1]++; 230| 123k| context->count[1] += (len >> 29); 231| 123k| j = (j >> 3) & 63; 232| 123k| if ((j + len) > 63) { ------------------ | Branch (232:9): [True: 2.03k, False: 121k] ------------------ 233| 2.03k| memcpy(&context->buffer[j], data, (i = 64 - j)); 234| 2.03k| SHA1Transform(context->state, context->buffer); 235| 2.03k| for (; i + 63 < len; i += 64) { ------------------ | Branch (235:16): [True: 0, False: 2.03k] ------------------ 236| 0| SHA1Transform(context->state, &data[i]); 237| 0| } 238| 2.03k| j = 0; 239| 2.03k| } else 240| 121k| i = 0; 241| 123k| memcpy(&context->buffer[j], &data[i], len - i); 242| 123k|} sha1.c:SHA1Transform: 90| 2.03k|static void SHA1Transform(uint32_t state[5], const unsigned char buffer[64]) { 91| 2.03k| uint32_t a, b, c, d, e; 92| | 93| 2.03k| typedef union { 94| 2.03k| unsigned char c[64]; 95| 2.03k| uint32_t l[16]; 96| 2.03k| } CHAR64LONG16; 97| | 98| 2.03k|#ifdef SHA1HANDSOFF 99| 2.03k| CHAR64LONG16 block[1]; /* use array to appear as a pointer */ 100| | 101| 2.03k| memcpy(block, buffer, 64); 102| |#else 103| | /* The following had better never be used because it causes the 104| | * pointer-to-const buffer to be cast into a pointer to non-const. 105| | * And the result is written through. I threw a "const" in, hoping 106| | * this will cause a diagnostic. 107| | */ 108| | CHAR64LONG16 *block = (const CHAR64LONG16 *)buffer; 109| |#endif 110| | /* Copy context->state[] to working vars */ 111| 2.03k| a = state[0]; 112| 2.03k| b = state[1]; 113| 2.03k| c = state[2]; 114| 2.03k| d = state[3]; 115| 2.03k| e = state[4]; 116| | /* 4 rounds of 20 operations each. Loop unrolled. */ 117| 2.03k| R0(a, b, c, d, e, 0); ------------------ | | 58| 2.03k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 44| 2.03k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 45| 2.03k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 59| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 118| 2.03k| R0(e, a, b, c, d, 1); ------------------ | | 58| 2.03k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 44| 2.03k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 45| 2.03k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 59| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 119| 2.03k| R0(d, e, a, b, c, 2); ------------------ | | 58| 2.03k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 44| 2.03k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 45| 2.03k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 59| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 120| 2.03k| R0(c, d, e, a, b, 3); ------------------ | | 58| 2.03k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 44| 2.03k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 45| 2.03k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 59| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 121| 2.03k| R0(b, c, d, e, a, 4); ------------------ | | 58| 2.03k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 44| 2.03k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 45| 2.03k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 59| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 122| 2.03k| R0(a, b, c, d, e, 5); ------------------ | | 58| 2.03k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 44| 2.03k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 45| 2.03k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 59| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 123| 2.03k| R0(e, a, b, c, d, 6); ------------------ | | 58| 2.03k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 44| 2.03k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 45| 2.03k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 59| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 124| 2.03k| R0(d, e, a, b, c, 7); ------------------ | | 58| 2.03k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 44| 2.03k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 45| 2.03k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 59| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 125| 2.03k| R0(c, d, e, a, b, 8); ------------------ | | 58| 2.03k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 44| 2.03k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 45| 2.03k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 59| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 126| 2.03k| R0(b, c, d, e, a, 9); ------------------ | | 58| 2.03k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 44| 2.03k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 45| 2.03k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 59| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 127| 2.03k| R0(a, b, c, d, e, 10); ------------------ | | 58| 2.03k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 44| 2.03k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 45| 2.03k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 59| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 128| 2.03k| R0(e, a, b, c, d, 11); ------------------ | | 58| 2.03k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 44| 2.03k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 45| 2.03k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 59| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 129| 2.03k| R0(d, e, a, b, c, 12); ------------------ | | 58| 2.03k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 44| 2.03k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 45| 2.03k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 59| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 130| 2.03k| R0(c, d, e, a, b, 13); ------------------ | | 58| 2.03k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 44| 2.03k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 45| 2.03k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 59| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 131| 2.03k| R0(b, c, d, e, a, 14); ------------------ | | 58| 2.03k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 44| 2.03k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 45| 2.03k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 59| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 132| 2.03k| R0(a, b, c, d, e, 15); ------------------ | | 58| 2.03k| z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 44| 2.03k| (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 45| 2.03k| (rol(block->l[i], 8) & 0x00FF00FF)) | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 59| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 133| 2.03k| R1(e, a, b, c, d, 16); ------------------ | | 61| 2.03k| z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 62| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 134| 2.03k| R1(d, e, a, b, c, 17); ------------------ | | 61| 2.03k| z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 62| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 135| 2.03k| R1(c, d, e, a, b, 18); ------------------ | | 61| 2.03k| z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 62| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 136| 2.03k| R1(b, c, d, e, a, 19); ------------------ | | 61| 2.03k| z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 62| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 137| 2.03k| R2(a, b, c, d, e, 20); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 138| 2.03k| R2(e, a, b, c, d, 21); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 139| 2.03k| R2(d, e, a, b, c, 22); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 140| 2.03k| R2(c, d, e, a, b, 23); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 141| 2.03k| R2(b, c, d, e, a, 24); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 142| 2.03k| R2(a, b, c, d, e, 25); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 143| 2.03k| R2(e, a, b, c, d, 26); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 144| 2.03k| R2(d, e, a, b, c, 27); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 145| 2.03k| R2(c, d, e, a, b, 28); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 146| 2.03k| R2(b, c, d, e, a, 29); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 147| 2.03k| R2(a, b, c, d, e, 30); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 148| 2.03k| R2(e, a, b, c, d, 31); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 149| 2.03k| R2(d, e, a, b, c, 32); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 150| 2.03k| R2(c, d, e, a, b, 33); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 151| 2.03k| R2(b, c, d, e, a, 34); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 152| 2.03k| R2(a, b, c, d, e, 35); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 153| 2.03k| R2(e, a, b, c, d, 36); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 154| 2.03k| R2(d, e, a, b, c, 37); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 155| 2.03k| R2(c, d, e, a, b, 38); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 156| 2.03k| R2(b, c, d, e, a, 39); ------------------ | | 64| 2.03k| z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 65| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 157| 2.03k| R3(a, b, c, d, e, 40); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 158| 2.03k| R3(e, a, b, c, d, 41); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 159| 2.03k| R3(d, e, a, b, c, 42); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 160| 2.03k| R3(c, d, e, a, b, 43); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 161| 2.03k| R3(b, c, d, e, a, 44); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 162| 2.03k| R3(a, b, c, d, e, 45); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 163| 2.03k| R3(e, a, b, c, d, 46); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 164| 2.03k| R3(d, e, a, b, c, 47); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 165| 2.03k| R3(c, d, e, a, b, 48); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 166| 2.03k| R3(b, c, d, e, a, 49); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 167| 2.03k| R3(a, b, c, d, e, 50); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 168| 2.03k| R3(e, a, b, c, d, 51); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 169| 2.03k| R3(d, e, a, b, c, 52); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 170| 2.03k| R3(c, d, e, a, b, 53); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 171| 2.03k| R3(b, c, d, e, a, 54); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 172| 2.03k| R3(a, b, c, d, e, 55); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 173| 2.03k| R3(e, a, b, c, d, 56); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 174| 2.03k| R3(d, e, a, b, c, 57); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 175| 2.03k| R3(c, d, e, a, b, 58); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 176| 2.03k| R3(b, c, d, e, a, 59); ------------------ | | 67| 2.03k| z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 68| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 177| 2.03k| R4(a, b, c, d, e, 60); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 178| 2.03k| R4(e, a, b, c, d, 61); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 179| 2.03k| R4(d, e, a, b, c, 62); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 180| 2.03k| R4(c, d, e, a, b, 63); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 181| 2.03k| R4(b, c, d, e, a, 64); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 182| 2.03k| R4(a, b, c, d, e, 65); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 183| 2.03k| R4(e, a, b, c, d, 66); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 184| 2.03k| R4(d, e, a, b, c, 67); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 185| 2.03k| R4(c, d, e, a, b, 68); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 186| 2.03k| R4(b, c, d, e, a, 69); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 187| 2.03k| R4(a, b, c, d, e, 70); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 188| 2.03k| R4(e, a, b, c, d, 71); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 189| 2.03k| R4(d, e, a, b, c, 72); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 190| 2.03k| R4(c, d, e, a, b, 73); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 191| 2.03k| R4(b, c, d, e, a, 74); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 192| 2.03k| R4(a, b, c, d, e, 75); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 193| 2.03k| R4(e, a, b, c, d, 76); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 194| 2.03k| R4(d, e, a, b, c, 77); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 195| 2.03k| R4(c, d, e, a, b, 78); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 196| 2.03k| R4(b, c, d, e, a, 79); ------------------ | | 70| 2.03k| z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 52| 2.03k| (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \ | | | | ------------------ | | | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | | | ------------------ | | | | 53| 2.03k| block->l[(i + 2) & 15] ^ block->l[i & 15], \ | | | | 54| 2.03k| 1)) | | ------------------ | | z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \ | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ | | 71| 2.03k| w = rol(w, 30); | | ------------------ | | | | 38| 2.03k|#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) | | ------------------ ------------------ 197| | /* Add the working vars back into context.state[] */ 198| 2.03k| state[0] += a; 199| 2.03k| state[1] += b; 200| 2.03k| state[2] += c; 201| 2.03k| state[3] += d; 202| 2.03k| state[4] += e; 203| 2.03k|#ifdef SHA1HANDSOFF 204| 2.03k| evutil_memclear_(block, sizeof(block)); 205| 2.03k|#endif 206| 2.03k|} sha1.c:SHA1Final: 246| 1.01k|static void SHA1Final(unsigned char digest[20], SHA1_CTX *context) { 247| 1.01k| unsigned i; 248| | 249| 1.01k| unsigned char finalcount[8]; 250| | 251| 1.01k| unsigned char c; 252| | 253| |#if 0 /* untested "improvement" by DHR */ 254| | /* Convert context->count to a sequence of bytes 255| | * in finalcount. Second element first, but 256| | * big-endian order within element. 257| | * But we do it all backwards. 258| | */ 259| | unsigned char *fcp = &finalcount[8]; 260| | 261| | for (i = 0; i < 2; i++) 262| | { 263| | uint32_t t = context->count[i]; 264| | 265| | int j; 266| | 267| | for (j = 0; j < 4; t >>= 8, j++) 268| | *--fcp = (unsigned char) t} 269| |#else 270| 9.15k| for (i = 0; i < 8; i++) { ------------------ | Branch (270:17): [True: 8.13k, False: 1.01k] ------------------ 271| 8.13k| finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)] >> ------------------ | Branch (271:58): [True: 4.06k, False: 4.06k] ------------------ 272| 8.13k| ((3 - (i & 3)) * 8)) & 273| 8.13k| 255); /* Endian independent */ 274| 8.13k| } 275| 1.01k|#endif 276| 1.01k| c = 0200; 277| 1.01k| SHA1Update(context, &c, 1); 278| 61.0k| while ((context->count[0] & 504) != 448) { ------------------ | Branch (278:12): [True: 60.0k, False: 1.01k] ------------------ 279| 60.0k| c = 0000; 280| 60.0k| SHA1Update(context, &c, 1); 281| 60.0k| } 282| 1.01k| SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */ 283| 21.3k| for (i = 0; i < 20; i++) { ------------------ | Branch (283:17): [True: 20.3k, False: 1.01k] ------------------ 284| 20.3k| digest[i] = 285| 20.3k| (unsigned char)((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 286| 20.3k| 255); 287| 20.3k| } 288| | /* Wipe variables */ 289| 1.01k| evutil_memclear_(context, sizeof(*context)); 290| 1.01k| evutil_memclear_(&finalcount, sizeof(finalcount)); 291| 1.01k|} evsig_init_: 177| 1.01k|{ 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| 1.01k| if (evutil_make_internal_pipe_(base->sig.ev_signal_pair) == -1) { ------------------ | Branch (183:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| if (base->sig.sh_old) { ------------------ | Branch (194:6): [True: 0, False: 1.01k] ------------------ 195| 0| mm_free(base->sig.sh_old); ------------------ | | 80| 0|#define mm_free(p) event_mm_free_(p) ------------------ 196| 0| } 197| 1.01k| base->sig.sh_old = NULL; 198| 1.01k| base->sig.sh_old_max = 0; 199| | 200| 1.01k| event_assign(&base->sig.ev_signal, base, base->sig.ev_signal_pair[0], 201| 1.01k| EV_READ | EV_PERSIST, evsig_cb, base); ------------------ | | 957| 1.01k|#define EV_READ 0x02 ------------------ EV_READ | EV_PERSIST, evsig_cb, base); ------------------ | | 968| 1.01k|#define EV_PERSIST 0x10 ------------------ 202| | 203| 1.01k| base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL; ------------------ | | 58| 1.01k|#define ev_flags ev_evcallback.evcb_flags ------------------ base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL; ------------------ | | 61| 1.01k|#define EVLIST_INTERNAL 0x10 ------------------ 204| 1.01k| event_priority_set(&base->sig.ev_signal, 0); 205| | 206| 1.01k| base->evsigsel = &evsigops; 207| | 208| 1.01k| return 0; 209| 1.01k|} evsig_dealloc_: 441| 1.01k|{ 442| 1.01k| int i = 0; 443| 1.01k| if (base->sig.ev_signal_added) { ------------------ | Branch (443:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k| event_debug_unassign(&base->sig.ev_signal); 450| | 451| 67.1k| for (i = 0; i < NSIG; ++i) { ------------------ | Branch (451:14): [True: 66.1k, False: 1.01k] ------------------ 452| 66.1k| if (i < base->sig.sh_old_max && base->sig.sh_old[i] != NULL) ------------------ | Branch (452:7): [True: 0, False: 66.1k] | Branch (452:35): [True: 0, False: 0] ------------------ 453| 0| evsig_restore_handler_(base, i); 454| 66.1k| } 455| 1.01k| EVSIGBASE_LOCK(); ------------------ | | 118| 1.01k|#define EVSIGBASE_LOCK() EVLOCK_LOCK(evsig_base_lock, 0) | | ------------------ | | | | 94| 1.01k| do { \ | | | | 95| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (95:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 96| 1.01k| evthread_lock_fns_.lock(mode, lockvar); \ | | | | 97| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ ------------------ 456| 1.01k| if (base == evsig_base) { ------------------ | Branch (456:6): [True: 0, False: 1.01k] ------------------ 457| 0| evsig_base = NULL; 458| 0| evsig_base_n_signals_added = 0; 459| 0| evsig_base_fd = -1; 460| 0| } 461| 1.01k| EVSIGBASE_UNLOCK(); ------------------ | | 119| 1.01k|#define EVSIGBASE_UNLOCK() EVLOCK_UNLOCK(evsig_base_lock, 0) | | ------------------ | | | | 101| 1.01k| do { \ | | | | 102| 1.01k| if (lockvar) \ | | | | ------------------ | | | | | Branch (102:7): [True: 0, False: 1.01k] | | | | ------------------ | | | | 103| 1.01k| evthread_lock_fns_.unlock(mode, lockvar); \ | | | | 104| 1.01k| } while (0) | | | | ------------------ | | | | | Branch (104:11): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ ------------------ 462| | 463| 1.01k| if (base->sig.ev_signal_pair[0] != -1) { ------------------ | Branch (463:6): [True: 1.01k, False: 0] ------------------ 464| 1.01k| evutil_closesocket(base->sig.ev_signal_pair[0]); 465| 1.01k| base->sig.ev_signal_pair[0] = -1; 466| 1.01k| } 467| 1.01k| if (base->sig.ev_signal_pair[1] != -1) { ------------------ | Branch (467:6): [True: 1.01k, False: 0] ------------------ 468| 1.01k| evutil_closesocket(base->sig.ev_signal_pair[1]); 469| 1.01k| base->sig.ev_signal_pair[1] = -1; 470| 1.01k| } 471| 1.01k| base->sig.sh_old_max = 0; 472| | 473| | /* per index frees are handled in evsig_del() */ 474| 1.01k| if (base->sig.sh_old) { ------------------ | Branch (474:6): [True: 0, False: 1.01k] ------------------ 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| 1.01k|} sigfd_init_: 207| 1.01k|{ 208| 1.01k| EVUTIL_ASSERT(base != NULL); ------------------ | | 368| 1.01k|#define EVUTIL_ASSERT(cond) EVUTIL_NIL_CONDITION_(cond) | | ------------------ | | | | 96| 1.01k|#define EVUTIL_NIL_CONDITION_(condition) do { \ | | | | 97| 1.01k| (void)sizeof(!(condition)); \ | | | | 98| 1.01k|} while(0) | | | | ------------------ | | | | | Branch (98:9): [Folded, False: 1.01k] | | | | ------------------ | | ------------------ ------------------ 209| 1.01k| if (!(base->flags & EVENT_BASE_FLAG_USE_SIGNALFD) && ------------------ | Branch (209:6): [True: 1.01k, False: 0] ------------------ 210| 1.01k| !getenv("EVENT_USE_SIGNALFD")) ------------------ | Branch (210:6): [True: 1.01k, False: 0] ------------------ 211| 1.01k| return -1; 212| 0| base->evsigsel = &sigfdops; 213| 0| return 0; 214| 1.01k|} evws_connection_free: 95| 1.01k|{ 96| | /* notify interested parties that this connection is going down */ 97| 1.01k| if (evws->cbclose != NULL) ------------------ | Branch (97:6): [True: 0, False: 1.01k] ------------------ 98| 0| (*evws->cbclose)(evws, evws->cbclose_arg); 99| | 100| 1.01k| if (evws->http_server != NULL) { ------------------ | Branch (100:6): [True: 1.01k, False: 0] ------------------ 101| 1.01k| struct evhttp *http = evws->http_server; 102| 1.01k| TAILQ_REMOVE(&http->ws_sessions, evws, next); ------------------ | | 356| 1.01k|#define TAILQ_REMOVE(head, elm, field) do { \ | | 357| 1.01k| if (((elm)->field.tqe_next) != NULL) \ | | ------------------ | | | Branch (357:6): [True: 0, False: 1.01k] | | ------------------ | | 358| 1.01k| (elm)->field.tqe_next->field.tqe_prev = \ | | 359| 0| (elm)->field.tqe_prev; \ | | 360| 1.01k| else \ | | 361| 1.01k| (head)->tqh_last = (elm)->field.tqe_prev; \ | | 362| 1.01k| *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ | | 363| 1.01k|} while (0) | | ------------------ | | | Branch (363:10): [Folded, False: 1.01k] | | ------------------ ------------------ 103| 1.01k| http->connection_cnt--; 104| 1.01k| } 105| | 106| 1.01k| if (evws->bufev != NULL) { ------------------ | Branch (106:6): [True: 1.01k, False: 0] ------------------ 107| 1.01k| bufferevent_free(evws->bufev); 108| 1.01k| } 109| 1.01k| if (evws->incomplete_frames != NULL) { ------------------ | Branch (109:6): [True: 515, False: 502] ------------------ 110| 515| evbuffer_free(evws->incomplete_frames); 111| 515| } 112| | 113| 1.01k| mm_free(evws); ------------------ | | 80| 1.01k|#define mm_free(p) event_mm_free_(p) ------------------ 114| 1.01k|} evws_close: 180| 196k|{ 181| 196k| uint8_t fr[4] = {0x8 | 0x80, 2, 0}; 182| 196k| struct evbuffer *output; 183| 196k| uint16_t *u16; 184| | 185| 196k| if (evws->closed) ------------------ | Branch (185:6): [True: 195k, False: 582] ------------------ 186| 195k| return; 187| 582| evws->closed = true; 188| | 189| 582| u16 = (uint16_t *)&fr[2]; 190| 582| *u16 = htons((int16_t)reason); 191| 582| output = bufferevent_get_output(evws->bufev); 192| 582| evbuffer_add(output, fr, 4); 193| | 194| | /* wait for close frame writing complete and close connection */ 195| 582| bufferevent_setcb( 196| | evws->bufev, NULL, close_after_write_cb, close_event_cb, evws); 197| 582|} evws_new_session: 408| 1.01k|{ 409| 1.01k| struct evws_connection *evws = NULL; 410| 1.01k| struct evkeyvalq *in_hdrs; 411| 1.01k| const char *upgrade, *connection, *ws_key, *ws_protocol; 412| 1.01k| struct evkeyvalq *out_hdrs; 413| 1.01k| struct evhttp_connection *evcon; 414| 1.01k| struct evhttp *ws_http_server; 415| 1.01k| int req_owned = 1; 416| | 417| 1.01k| in_hdrs = evhttp_request_get_input_headers(req); 418| 1.01k| upgrade = evhttp_find_header(in_hdrs, "Upgrade"); 419| 1.01k| if (upgrade == NULL || evutil_ascii_strcasecmp(upgrade, "websocket")) ------------------ | Branch (419:6): [True: 0, False: 1.01k] | Branch (419:25): [True: 0, False: 1.01k] ------------------ 420| 0| goto error; 421| | 422| 1.01k| connection = evhttp_find_header(in_hdrs, "Connection"); 423| 1.01k| if (connection == NULL || evutil_ascii_strcasestr(connection, "Upgrade") == NULL) ------------------ | Branch (423:6): [True: 0, False: 1.01k] | Branch (423:28): [True: 0, False: 1.01k] ------------------ 424| 0| goto error; 425| | 426| 1.01k| ws_key = evhttp_find_header(in_hdrs, "Sec-WebSocket-Key"); 427| 1.01k| if (ws_key == NULL) ------------------ | Branch (427:6): [True: 0, False: 1.01k] ------------------ 428| 0| goto error; 429| | 430| 1.01k| out_hdrs = evhttp_request_get_output_headers(req); 431| 1.01k| evhttp_add_header(out_hdrs, "Upgrade", "websocket"); 432| 1.01k| evhttp_add_header(out_hdrs, "Connection", "Upgrade"); 433| | 434| 1.01k| evhttp_add_header(out_hdrs, "Sec-WebSocket-Accept", 435| 1.01k| ws_gen_accept_key(ws_key, (char[32]){0})); 436| | 437| 1.01k| ws_protocol = evhttp_find_header(in_hdrs, "Sec-WebSocket-Protocol"); 438| 1.01k| if (ws_protocol != NULL) ------------------ | Branch (438:6): [True: 0, False: 1.01k] ------------------ 439| 0| evhttp_add_header(out_hdrs, "Sec-WebSocket-Protocol", ws_protocol); 440| | 441| 1.01k| if ((evws = mm_calloc(1, sizeof(struct evws_connection))) == NULL) { ------------------ | | 77| 1.01k|#define mm_calloc(count, size) event_mm_calloc_((count), (size)) ------------------ | Branch (441:6): [True: 0, False: 1.01k] ------------------ 442| 0| event_warn("%s: calloc failed", __func__); ------------------ | | 81| 0|# define __func__ __func__ ------------------ 443| 0| goto error; 444| 0| } 445| | 446| 1.01k| evws->cb = cb; 447| 1.01k| evws->cb_arg = arg; 448| | 449| 1.01k| evcon = evhttp_request_get_connection(req); 450| 1.01k| ws_http_server = evcon->http_server; 451| | 452| | /* evhttp_start_ws_ frees both req and evcon on success */ 453| 1.01k| evws->bufev = evhttp_start_ws_(req); 454| 1.01k| if (evws->bufev == NULL) { ------------------ | Branch (454:6): [True: 0, False: 1.01k] ------------------ 455| 0| goto error; 456| 0| } 457| 1.01k| req_owned = 0; 458| | 459| 1.01k| if (options & BEV_OPT_THREADSAFE) { ------------------ | Branch (459:6): [True: 0, False: 1.01k] ------------------ 460| 0| if (bufferevent_enable_locking_(evws->bufev, NULL) < 0) ------------------ | Branch (460:7): [True: 0, False: 0] ------------------ 461| 0| goto error; 462| 0| } 463| | 464| 1.01k| bufferevent_setcb( 465| 1.01k| evws->bufev, ws_evhttp_read_cb, NULL, ws_evhttp_error_cb, evws); 466| | 467| 1.01k| evws->http_server = ws_http_server; 468| 1.01k| TAILQ_INSERT_TAIL(&evws->http_server->ws_sessions, evws, next); ------------------ | | 332| 1.01k|#define TAILQ_INSERT_TAIL(head, elm, field) do { \ | | 333| 1.01k| (elm)->field.tqe_next = NULL; \ | | 334| 1.01k| (elm)->field.tqe_prev = (head)->tqh_last; \ | | 335| 1.01k| *(head)->tqh_last = (elm); \ | | 336| 1.01k| (head)->tqh_last = &(elm)->field.tqe_next; \ | | 337| 1.01k|} while (0) | | ------------------ | | | Branch (337:10): [Folded, False: 1.01k] | | ------------------ ------------------ 469| 1.01k| evws->http_server->connection_cnt++; 470| | 471| 1.01k| return evws; 472| | 473| 0|error: 474| 0| if (evws) ------------------ | Branch (474:6): [True: 0, False: 0] ------------------ 475| 0| evws_connection_free(evws); 476| | 477| 0| if (req_owned) ------------------ | Branch (477:6): [True: 0, False: 0] ------------------ 478| 0| evhttp_send_reply(req, HTTP_BADREQUEST, NULL, NULL); ------------------ | | 68| 0|#define HTTP_BADREQUEST 400 /**< invalid http request was made */ ------------------ 479| | return NULL; 480| 1.01k|} ws.c:ws_gen_accept_key: 153| 1.01k|{ 154| 1.01k| char buf[1024]; 155| 1.01k| char digest[20]; 156| | 157| 1.01k| snprintf(buf, sizeof(buf), "%s" WS_UUID, ws_key); ------------------ | | 40| 1.01k|#define WS_UUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" ------------------ 158| | 159| 1.01k| builtin_SHA1(digest, buf, strlen(buf)); 160| 1.01k| Base64encode(out, digest, sizeof(digest)); 161| 1.01k| return out; 162| 1.01k|} ws.c:Base64encode: 121| 1.01k|{ 122| 1.01k| int i; 123| 1.01k| char *p; 124| | 125| 1.01k| p = encoded; 126| 7.11k| for (i = 0; i < len - 2; i += 3) { ------------------ | Branch (126:14): [True: 6.10k, False: 1.01k] ------------------ 127| 6.10k| *p++ = basis_64[(string[i] >> 2) & 0x3F]; 128| 6.10k| *p++ = basis_64[((string[i] & 0x3) << 4) | 129| 6.10k| ((int)(string[i + 1] & 0xF0) >> 4)]; 130| 6.10k| *p++ = basis_64[((string[i + 1] & 0xF) << 2) | 131| 6.10k| ((int)(string[i + 2] & 0xC0) >> 6)]; 132| 6.10k| *p++ = basis_64[string[i + 2] & 0x3F]; 133| 6.10k| } 134| 1.01k| if (i < len) { ------------------ | Branch (134:6): [True: 1.01k, False: 0] ------------------ 135| 1.01k| *p++ = basis_64[(string[i] >> 2) & 0x3F]; 136| 1.01k| if (i == (len - 1)) { ------------------ | Branch (136:7): [True: 0, False: 1.01k] ------------------ 137| 0| *p++ = basis_64[((string[i] & 0x3) << 4)]; 138| 0| *p++ = '='; 139| 1.01k| } else { 140| 1.01k| *p++ = basis_64[((string[i] & 0x3) << 4) | 141| 1.01k| ((int)(string[i + 1] & 0xF0) >> 4)]; 142| 1.01k| *p++ = basis_64[((string[i + 1] & 0xF) << 2)]; 143| 1.01k| } 144| 1.01k| *p++ = '='; 145| 1.01k| } 146| | 147| 1.01k| *p++ = '\0'; 148| 1.01k| return p - encoded; 149| 1.01k|} ws.c:ws_evhttp_read_cb: 318| 1.01k|{ 319| 1.01k| struct evws_connection *evws = arg; 320| 1.01k| unsigned char *payload; 321| 1.01k| enum WebSocketFrameType type; 322| 1.01k| size_t msg_len, in_len, header_sz; 323| 1.01k| struct evbuffer *input = bufferevent_get_input(evws->bufev); 324| | 325| 1.01k| bufferevent_incref_and_lock_(evws->bufev); 326| 3.59M| while ((in_len = evbuffer_get_length(input))) { ------------------ | Branch (326:9): [True: 3.59M, False: 500] ------------------ 327| 3.59M| unsigned char *data = evbuffer_pullup(input, in_len); 328| 3.59M| if (data == NULL) { ------------------ | Branch (328:7): [True: 0, False: 3.59M] ------------------ 329| 0| goto bailout; 330| 0| } 331| | 332| 3.59M| type = get_ws_frame(data, in_len, &payload, &msg_len); 333| 3.59M| if (type == INCOMPLETE_DATA) { ------------------ | Branch (333:7): [True: 517, False: 3.59M] ------------------ 334| | /* incomplete data received, wait for next chunk */ 335| 517| goto bailout; 336| 517| } 337| 3.59M| header_sz = payload - data; 338| 3.59M| evbuffer_drain(input, header_sz); 339| 3.59M| data = evbuffer_pullup(input, -1); 340| | 341| 3.59M| switch (type) { 342| 19.4k| case TEXT_FRAME: ------------------ | Branch (342:3): [True: 19.4k, False: 3.57M] ------------------ 343| 25.9k| case BINARY_FRAME: ------------------ | Branch (343:3): [True: 6.45k, False: 3.58M] ------------------ 344| 25.9k| if (evws->incomplete_frames != NULL) { ------------------ | Branch (344:8): [True: 19.3k, False: 6.62k] ------------------ 345| 19.3k| if (ws_message_limit_exceeded_(evws, msg_len)) { ------------------ | Branch (345:9): [True: 0, False: 19.3k] ------------------ 346| 0| break; 347| 0| } 348| | /* we already have incomplete frames in internal buffer 349| | * and need to concatenate them with final one */ 350| 19.3k| evbuffer_add(evws->incomplete_frames, data, msg_len); 351| | 352| 19.3k| data = evbuffer_pullup(evws->incomplete_frames, -1); 353| | 354| 19.3k| evws->cb(evws, type, data, 355| 19.3k| evbuffer_get_length(evws->incomplete_frames), evws->cb_arg); 356| 19.3k| evbuffer_free(evws->incomplete_frames); 357| 19.3k| evws->incomplete_frames = NULL; 358| 19.3k| } else { 359| 6.62k| evws->cb(evws, type, data, msg_len, evws->cb_arg); 360| 6.62k| } 361| 25.9k| break; 362| 3.30M| case INCOMPLETE_FRAME: ------------------ | Branch (362:3): [True: 3.30M, False: 285k] ------------------ 363| | /* we received full frame until get fin and need to 364| | * postpone callback until all data arrives */ 365| 3.30M| if (evws->incomplete_frames == NULL) { ------------------ | Branch (365:8): [True: 19.8k, False: 3.28M] ------------------ 366| 19.8k| evws->incomplete_frames = evbuffer_new(); 367| 19.8k| } 368| 3.30M| if (evws->incomplete_frames == NULL) { ------------------ | Branch (368:8): [True: 0, False: 3.30M] ------------------ 369| 0| evws_force_disconnect_(evws); 370| 0| break; 371| 0| } 372| 3.30M| if (ws_message_limit_exceeded_(evws, msg_len)) { ------------------ | Branch (372:8): [True: 0, False: 3.30M] ------------------ 373| 0| break; 374| 0| } 375| 3.30M| evbuffer_remove_buffer(input, evws->incomplete_frames, msg_len); 376| 3.30M| continue; 377| 40.7k| case CLOSING_FRAME: ------------------ | Branch (377:3): [True: 40.7k, False: 3.55M] ------------------ 378| 190k| case ERROR_FRAME: ------------------ | Branch (378:3): [True: 149k, False: 3.44M] ------------------ 379| 190k| evws_force_disconnect_(evws); 380| 190k| break; 381| 29.5k| case PING_FRAME: ------------------ | Branch (381:3): [True: 29.5k, False: 3.56M] ------------------ 382| 63.7k| case PONG_FRAME: ------------------ | Branch (382:3): [True: 34.2k, False: 3.55M] ------------------ 383| | /* ping or pong frame */ 384| 63.7k| break; 385| 5.55k| default: ------------------ | Branch (385:3): [True: 5.55k, False: 3.58M] ------------------ 386| 5.55k| event_warn("%s: unexpected frame type %d\n", __func__, type); ------------------ | | 81| 5.55k|# define __func__ __func__ ------------------ 387| 5.55k| evws_force_disconnect_(evws); 388| 3.59M| } 389| 285k| evbuffer_drain(input, msg_len); 390| 285k| } 391| | 392| 1.01k|bailout: 393| 1.01k| bufferevent_decref_and_unlock_(evws->bufev); 394| 1.01k|} ws.c:get_ws_frame: 228| 3.59M|{ 229| 3.59M| unsigned char opcode; 230| 3.59M| unsigned char fin; 231| 3.59M| unsigned char masked; 232| 3.59M| size_t payload_len; 233| 3.59M| size_t pos; 234| 3.59M| int length_field; 235| | 236| 3.59M| if (buf_len < 2) { ------------------ | Branch (236:6): [True: 227, False: 3.59M] ------------------ 237| 227| return INCOMPLETE_DATA; 238| 227| } 239| | 240| 3.59M| opcode = in_buffer[0] & 0x0F; 241| 3.59M| fin = (in_buffer[0] >> 7) & 0x01; 242| 3.59M| masked = (in_buffer[1] >> 7) & 0x01; 243| | 244| 3.59M| payload_len = 0; 245| 3.59M| pos = 2; 246| 3.59M| length_field = in_buffer[1] & (~0x80); 247| | 248| 3.59M| if (length_field <= 125) { ------------------ | Branch (248:6): [True: 3.54M, False: 44.0k] ------------------ 249| 3.54M| payload_len = length_field; 250| 3.54M| } else if (length_field == 126) { /* msglen is 16bit */ ------------------ | Branch (250:13): [True: 5.47k, False: 38.5k] ------------------ 251| 5.47k| uint16_t tmp16; 252| 5.47k| if (buf_len < 4) ------------------ | Branch (252:7): [True: 2, False: 5.47k] ------------------ 253| 2| return INCOMPLETE_DATA; 254| 5.47k| memcpy(&tmp16, in_buffer + pos, 2); 255| 5.47k| payload_len = ntohs(tmp16); 256| 5.47k| pos += 2; 257| 38.5k| } else if (length_field == 127) { /* msglen is 64bit */ ------------------ | Branch (257:13): [True: 38.5k, False: 0] ------------------ 258| 38.5k| int i; 259| 38.5k| uint64_t tmp64 = 0; 260| 38.5k| if (buf_len < 10) ------------------ | Branch (260:7): [True: 13, False: 38.5k] ------------------ 261| 13| return INCOMPLETE_DATA; 262| | /* swap bytes from big endian to host byte order */ 263| 347k| for (i = 56; i >= 0; i -= 8) { ------------------ | Branch (263:16): [True: 308k, False: 38.5k] ------------------ 264| 308k| tmp64 |= (uint64_t)in_buffer[pos++] << i; 265| 308k| } 266| 38.5k| if (tmp64 > WS_MAX_RECV_FRAME_SZ) { ------------------ | Branch (266:7): [True: 36.5k, False: 2.05k] ------------------ 267| | /* Implementation limitation, we support up to 10 MiB 268| | * length, as a DoS prevention measure. 269| | */ 270| 36.5k| event_warn("%s: frame length %" PRIu64 " exceeds %" PRIu64 "\n", 271| 36.5k| __func__, tmp64, (uint64_t)WS_MAX_RECV_FRAME_SZ); ------------------ | | 81| 36.5k|# define __func__ __func__ ------------------ 272| | /* Calling code needs these values; do the best we can here. 273| | * Caller will close the connection anyway. 274| | */ 275| 36.5k| *payload_ptr = in_buffer + pos; 276| 36.5k| *out_len = 0; 277| 36.5k| return ERROR_FRAME; 278| 36.5k| } 279| 2.05k| payload_len = (size_t)tmp64; 280| 2.05k| } 281| 3.55M| if (buf_len < payload_len + pos + (masked ? 4u : 0u)) { ------------------ | Branch (281:6): [True: 275, False: 3.55M] | Branch (281:37): [True: 62.5k, False: 3.49M] ------------------ 282| 275| return INCOMPLETE_DATA; 283| 275| } 284| | 285| | /* According to RFC it seems that unmasked data should be prohibited 286| | * but we support it for nonconformant clients 287| | */ 288| 3.55M| if (masked) { ------------------ | Branch (288:6): [True: 62.3k, False: 3.49M] ------------------ 289| 62.3k| unsigned char *c, *mask; 290| 62.3k| size_t i; 291| | 292| 62.3k| mask = in_buffer + pos; /* first 4 bytes are mask bytes */ 293| 62.3k| pos += 4; 294| | 295| | /* unmask data */ 296| 62.3k| c = in_buffer + pos; 297| 24.9M| for (i = 0; i < payload_len; i++) { ------------------ | Branch (297:15): [True: 24.8M, False: 62.3k] ------------------ 298| 24.8M| c[i] = c[i] ^ mask[i % 4u]; 299| 24.8M| } 300| 62.3k| } 301| | 302| 3.55M| *payload_ptr = in_buffer + pos; 303| 3.55M| *out_len = payload_len; 304| | 305| | /* are reserved for further frames */ 306| 3.55M| if ((opcode >= 3 && opcode <= 7) || (opcode >= 0xb)) ------------------ | Branch (306:7): [True: 217k, False: 3.33M] | Branch (306:22): [True: 87.5k, False: 130k] | Branch (306:38): [True: 25.9k, False: 3.44M] ------------------ 307| 113k| return ERROR_FRAME; 308| | 309| 3.44M| if (opcode <= 0x3 && !fin) { ------------------ | Branch (309:6): [True: 3.33M, False: 104k] | Branch (309:23): [True: 3.30M, False: 31.4k] ------------------ 310| 3.30M| return INCOMPLETE_FRAME; 311| 3.30M| } 312| 135k| return opcode; 313| 3.44M|} ws.c:ws_message_limit_exceeded_: 207| 3.32M|{ 208| 3.32M| size_t buffered = 0; 209| | 210| 3.32M| if (evws->incomplete_frames != NULL) { ------------------ | Branch (210:6): [True: 3.32M, False: 0] ------------------ 211| 3.32M| buffered = evbuffer_get_length(evws->incomplete_frames); 212| 3.32M| } 213| | 214| 3.32M| if (msg_len > WS_MAX_RECV_MSG_SZ - buffered) { ------------------ | Branch (214:6): [True: 0, False: 3.32M] ------------------ 215| 0| evws_close(evws, WS_CR_DATA_TOO_BIG); ------------------ | | 17| 0|#define WS_CR_DATA_TOO_BIG 1009 ------------------ 216| 0| return 1; 217| 0| } 218| | 219| 3.32M| return 0; 220| 3.32M|} ws.c:evws_force_disconnect_: 201| 196k|{ 202| 196k| evws_close(evws, WS_CR_NONE); ------------------ | | 14| 196k|#define WS_CR_NONE 0 ------------------ 203| 196k|} LLVMFuzzerTestOneInput: 32| 1.01k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 33| 1.01k| struct event_base *base = event_base_new(); 34| 1.01k| if (!base) return 0; ------------------ | Branch (34:9): [True: 0, False: 1.01k] ------------------ 35| | 36| 1.01k| struct evhttp *http = evhttp_new(base); 37| 1.01k| struct bufferevent *bev[2]; 38| 1.01k| if (bufferevent_pair_new(base, 0, bev) != 0) { ------------------ | Branch (38:9): [True: 0, False: 1.01k] ------------------ 39| 0| evhttp_free(http); 40| 0| event_base_free(base); 41| 0| return 0; 42| 0| } 43| | 44| 1.01k| 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| 1.01k| evcon->http_server = http; 48| 1.01k| TAILQ_INSERT_TAIL(&http->connections, evcon, next); ------------------ | Branch (48:5): [Folded, False: 1.01k] ------------------ 49| | 50| 1.01k| struct evhttp_request *req = evhttp_request_new(NULL, NULL); 51| 1.01k| if (!req) { ------------------ | Branch (51:9): [True: 0, False: 1.01k] ------------------ 52| 0| evhttp_connection_free(evcon); 53| 0| evhttp_free(http); 54| 0| bufferevent_free(bev[1]); 55| 0| return 0; 56| 0| } 57| 1.01k| req->evcon = evcon; 58| 1.01k| req->kind = EVHTTP_REQUEST; 59| 1.01k| TAILQ_INSERT_TAIL(&evcon->requests, req, next); ------------------ | Branch (59:5): [Folded, False: 1.01k] ------------------ 60| | 61| | /* Add required headers for WebSocket handshake */ 62| 1.01k| struct evkeyvalq *in_hdrs = evhttp_request_get_input_headers(req); 63| 1.01k| evhttp_add_header(in_hdrs, "Upgrade", "websocket"); 64| 1.01k| evhttp_add_header(in_hdrs, "Connection", "Upgrade"); 65| 1.01k| evhttp_add_header(in_hdrs, "Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ=="); 66| | 67| | /* evws_new_session takes 4 arguments in this version of libevent */ 68| 1.01k| struct evws_connection *ws = evws_new_session(req, on_msg, NULL, 0); 69| 1.01k| if (ws) { ------------------ | Branch (69:9): [True: 1.01k, False: 0] ------------------ 70| 1.01k| struct evbuffer *output = bufferevent_get_output(bev[1]); 71| 1.01k| evbuffer_add(output, data, size); 72| | 73| 1.01k| event_base_loop(base, EVLOOP_NONBLOCK); 74| | 75| 1.01k| evws_connection_free(ws); 76| 1.01k| } 77| 1.01k| evhttp_free(http); 78| 1.01k| bufferevent_free(bev[1]); 79| 1.01k| event_base_free(base); 80| | 81| 1.01k| return 0; 82| 1.01k|} ws_fuzzer.cc:_ZL6on_msgP15evws_connectioniPKhmPv: 29| 25.9k|static void on_msg(struct evws_connection *ws, int type, const uint8_t *data, size_t len, void *arg) { 30| 25.9k|}