flb_utils.c:flb_log_check: 102| 84.3k|static inline int flb_log_check(int l) { 103| 84.3k| struct flb_worker *w; 104| 84.3k| w = (struct flb_worker *) FLB_TLS_GET(flb_worker_ctx); ------------------ | | 34| 84.3k|#define FLB_TLS_GET(key) key ------------------ 105| 84.3k| if (!w && l <= 3) { ------------------ | Branch (105:9): [True: 84.3k, False: 0] | Branch (105:15): [True: 0, False: 84.3k] ------------------ 106| 0| return FLB_TRUE; ------------------ | | 26| 0|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 0|#define FLB_FALSE 0 | | ------------------ ------------------ 107| 0| } 108| | 109| 84.3k| if (w == NULL || flb_worker_log_level(w) < l) { ------------------ | Branch (109:9): [True: 84.3k, False: 0] | Branch (109:22): [True: 0, False: 0] ------------------ 110| 84.3k| return FLB_FALSE; ------------------ | | 25| 84.3k|#define FLB_FALSE 0 ------------------ 111| 84.3k| } 112| 0| return FLB_TRUE; ------------------ | | 26| 0|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 0|#define FLB_FALSE 0 | | ------------------ ------------------ 113| 84.3k|} flb_log.c:flb_log_check: 102| 2|static inline int flb_log_check(int l) { 103| 2| struct flb_worker *w; 104| 2| w = (struct flb_worker *) FLB_TLS_GET(flb_worker_ctx); ------------------ | | 34| 2|#define FLB_TLS_GET(key) key ------------------ 105| 2| if (!w && l <= 3) { ------------------ | Branch (105:9): [True: 2, False: 0] | Branch (105:15): [True: 2, False: 0] ------------------ 106| 2| return FLB_TRUE; ------------------ | | 26| 2|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 2|#define FLB_FALSE 0 | | ------------------ ------------------ 107| 2| } 108| | 109| 0| if (w == NULL || flb_worker_log_level(w) < l) { ------------------ | Branch (109:9): [True: 0, False: 0] | Branch (109:22): [True: 0, False: 0] ------------------ 110| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 111| 0| } 112| 0| return FLB_TRUE; ------------------ | | 26| 0|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 0|#define FLB_FALSE 0 | | ------------------ ------------------ 113| 0|} flb_sds.c:flb_malloc: 67| 827|void *flb_malloc(const size_t size) { 68| | 69| 827|#ifdef FLB_HAVE_TESTS_OSSFUZZ 70| | // 1% chance of failure 71| 827| if (flb_fuzz_get_probability(1)) { ------------------ | Branch (71:8): [True: 1, False: 826] ------------------ 72| 1| return NULL; 73| 1| } 74| 826|#endif 75| | 76| 826| if (size == 0) { ------------------ | Branch (76:9): [True: 0, False: 826] ------------------ 77| 0| return NULL; 78| 0| } 79| | 80| 826| return malloc(size); 81| 826|} flb_sds.c:flb_fuzz_get_probability: 56| 827|static inline int flb_fuzz_get_probability(int val) { 57| 827| flb_malloc_p += 1; 58| 827| flb_malloc_p = flb_malloc_p % flb_malloc_mod; 59| 827| if (val > flb_malloc_p) { ------------------ | Branch (59:7): [True: 1, False: 826] ------------------ 60| 1| return 1; 61| 1| } 62| 826| return 0; 63| 827|} flb_sds.c:flb_realloc: 100| 1.40k|{ 101| 1.40k| return realloc(ptr, size); 102| 1.40k|} flb_sds.c:flb_free: 126| 826|static inline void flb_free(void *ptr) { 127| 826| free(ptr); 128| 826|} flb_pack.c:flb_sds_len_set: 63| 347|{ 64| 347| FLB_SDS_HEADER(s)->len = len; ------------------ | | 46| 347|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 347|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 65| 347|} flb_sds.c:flb_sds_alloc: 68| 1.40k|{ 69| 1.40k| return (size_t) FLB_SDS_HEADER(s)->alloc; ------------------ | | 46| 1.40k|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 1.40k|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 70| 1.40k|} flb_utils.c:flb_utf8_len: 42| 93.1k|{ 43| 93.1k| return trailingBytesForUTF8[(unsigned int)(unsigned char)s[0]] + 1; 44| 93.1k|} flb_pack.c:msgpack_unpacked_init: 253| 826|{ 254| 826| memset(result, 0, sizeof(msgpack_unpacked)); 255| 826|} flb_pack.c:msgpack_unpacked_destroy: 258| 826|{ 259| 826| if(result->zone != NULL) { ------------------ | Branch (259:8): [True: 721, False: 105] ------------------ 260| 721| msgpack_zone_free(result->zone); 261| 721| result->zone = NULL; 262| 721| memset(&result->data, 0, sizeof(msgpack_object)); 263| 721| } 264| 826|} unpack.c:msgpack_unpacked_destroy: 258| 826|{ 259| 826| if(result->zone != NULL) { ------------------ | Branch (259:8): [True: 0, False: 826] ------------------ 260| 0| msgpack_zone_free(result->zone); 261| 0| result->zone = NULL; 262| 0| memset(&result->data, 0, sizeof(msgpack_object)); 263| 0| } 264| 826|} unpack.c:template_init: 68| 826|{ 69| 826| ctx->cs = MSGPACK_CS_HEADER; 70| 826| ctx->trail = 0; 71| 826| ctx->top = 0; 72| | /* 73| | ctx->stack = ctx->embed_stack; 74| | ctx->stack_size = MSGPACK_EMBED_STACK_SIZE; 75| | */ 76| 826| ctx->stack[0].obj = msgpack_unpack_callback(_root)(&ctx->user); ------------------ | | 33| 826| template_callback ## name ------------------ 77| 826|} unpack.c:template_execute: 95| 826|{ 96| 826| assert(len >= *off); 97| 826| { 98| 826| const unsigned char* p = (unsigned char*)data + *off; 99| 826| const unsigned char* const pe = (unsigned char*)data + len; 100| 826| const void* n = NULL; 101| | 102| 826| unsigned int trail = ctx->trail; 103| 826| unsigned int cs = ctx->cs; 104| 826| unsigned int top = ctx->top; 105| 826| msgpack_unpack_struct(_stack)* stack = ctx->stack; ------------------ | | 27| 826| struct template ## name ------------------ 106| | /* 107| | unsigned int stack_size = ctx->stack_size; 108| | */ 109| 826| msgpack_unpack_user* user = &ctx->user; ------------------ | | 37| 826|#define msgpack_unpack_user unpack_user ------------------ 110| | 111| 826| msgpack_unpack_object obj; ------------------ | | 35| 826|#define msgpack_unpack_object msgpack_object ------------------ 112| 826| msgpack_unpack_struct(_stack)* c = NULL; ------------------ | | 27| 826| struct template ## name ------------------ 113| | 114| 826| int ret; 115| | 116| 826|#define push_simple_value(func) \ 117| 826| ret = msgpack_unpack_callback(func)(user, &obj); \ 118| 826| if(ret < 0) { goto _failed; } \ 119| 826| goto _push 120| 826|#define push_fixed_value(func, arg) \ 121| 826| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ 122| 826| if(ret < 0) { goto _failed; } \ 123| 826| goto _push 124| 826|#define push_variable_value(func, base, pos, len) \ 125| 826| ret = msgpack_unpack_callback(func)(user, \ 126| 826| (const char*)base, (const char*)pos, len, &obj); \ 127| 826| if(ret < 0) { goto _failed; } \ 128| 826| goto _push 129| | 130| 826|#define again_fixed_trail(_cs, trail_len) \ 131| 826| trail = trail_len; \ 132| 826| cs = _cs; \ 133| 826| goto _fixed_trail_again 134| 826|#define again_fixed_trail_if_zero(_cs, trail_len, ifzero) \ 135| 826| trail = trail_len; \ 136| 826| if(trail == 0) { goto ifzero; } \ 137| 826| cs = _cs; \ 138| 826| goto _fixed_trail_again 139| | 140| 826|#define start_container(func, count_, ct_) \ 141| 826| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ 142| 826| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ 143| 826| goto _failed; \ 144| 826| } /* FIXME */ \ 145| 826| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ 146| 826| if(ret < 0) { goto _failed; } \ 147| 826| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ 148| 826| stack[top].ct = ct_; \ 149| 826| stack[top].count = count_; \ 150| 826| ++top; \ 151| 826| goto _header_again 152| | 153| 826|#define NEXT_CS(p) \ 154| 826| ((unsigned int)*p & 0x1f) 155| | 156| 826|#ifdef USE_CASE_RANGE 157| 826|#define SWITCH_RANGE_BEGIN switch(*p) { 158| 826|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: 159| 826|#define SWITCH_RANGE_DEFAULT default: 160| 826|#define SWITCH_RANGE_END } 161| |#else 162| |#define SWITCH_RANGE_BEGIN { if(0) { 163| |#define SWITCH_RANGE(FROM, TO) } else if(FROM <= *p && *p <= TO) { 164| |#define SWITCH_RANGE_DEFAULT } else { 165| |#define SWITCH_RANGE_END } } 166| |#endif 167| | 168| 826| if(p == pe) { goto _out; } ------------------ | Branch (168:12): [True: 0, False: 826] ------------------ 169| 142k| do { 170| 142k| switch(cs) { 171| 142k| case MSGPACK_CS_HEADER: ------------------ | Branch (171:13): [True: 142k, False: 0] ------------------ 172| 142k| SWITCH_RANGE_BEGIN ------------------ | | 157| 285k|#define SWITCH_RANGE_BEGIN switch(*p) { ------------------ 173| | SWITCH_RANGE(0x00, 0x7f) // Positive Fixnum ------------------ | | 158| 50.0k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 50.0k, False: 92.7k] | | ------------------ ------------------ 174| 50.0k| push_fixed_value(_uint8, *(uint8_t*)p); ------------------ | | 121| 50.0k| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 50.0k| template_callback ## name | | ------------------ | | 122| 50.0k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 50.0k] | | ------------------ | | 123| 50.0k| goto _push ------------------ 175| | SWITCH_RANGE(0xe0, 0xff) // Negative Fixnum ------------------ | | 158| 40.8k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 40.8k, False: 101k] | | ------------------ ------------------ 176| 40.8k| push_fixed_value(_int8, *(int8_t*)p); ------------------ | | 121| 40.8k| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 40.8k| template_callback ## name | | ------------------ | | 122| 40.8k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 40.8k] | | ------------------ | | 123| 40.8k| goto _push ------------------ 177| | SWITCH_RANGE(0xc0, 0xdf) // Variable ------------------ | | 158| 23.0k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 23.0k, False: 119k] | | ------------------ ------------------ 178| 23.0k| switch(*p) { 179| 2.27k| case 0xc0: // nil ------------------ | Branch (179:21): [True: 2.27k, False: 20.7k] ------------------ 180| 2.27k| push_simple_value(_nil); ------------------ | | 117| 2.27k| ret = msgpack_unpack_callback(func)(user, &obj); \ | | ------------------ | | | | 33| 2.27k| template_callback ## name | | ------------------ | | 118| 2.27k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (118:12): [True: 0, False: 2.27k] | | ------------------ | | 119| 2.27k| goto _push ------------------ 181| | //case 0xc1: // string 182| | // again_terminal_trail(NEXT_CS(p), p+1); 183| 2.27k| case 0xc2: // false ------------------ | Branch (183:21): [True: 2.21k, False: 20.8k] ------------------ 184| 2.21k| push_simple_value(_false); ------------------ | | 117| 2.21k| ret = msgpack_unpack_callback(func)(user, &obj); \ | | ------------------ | | | | 33| 2.21k| template_callback ## name | | ------------------ | | 118| 2.21k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (118:12): [True: 0, False: 2.21k] | | ------------------ | | 119| 2.21k| goto _push ------------------ 185| 2.21k| case 0xc3: // true ------------------ | Branch (185:21): [True: 1.44k, False: 21.6k] ------------------ 186| 1.44k| push_simple_value(_true); ------------------ | | 117| 1.44k| ret = msgpack_unpack_callback(func)(user, &obj); \ | | ------------------ | | | | 33| 1.44k| template_callback ## name | | ------------------ | | 118| 1.44k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (118:12): [True: 0, False: 1.44k] | | ------------------ | | 119| 1.44k| goto _push ------------------ 187| 1.44k| case 0xc4: // bin 8 ------------------ | Branch (187:21): [True: 1.25k, False: 21.7k] ------------------ 188| 1.68k| case 0xc5: // bin 16 ------------------ | Branch (188:21): [True: 429, False: 22.6k] ------------------ 189| 1.98k| case 0xc6: // bin 32 ------------------ | Branch (189:21): [True: 298, False: 22.7k] ------------------ 190| 1.98k| again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); ------------------ | | 131| 1.98k| trail = trail_len; \ | | 132| 1.98k| cs = _cs; \ | | 133| 1.98k| goto _fixed_trail_again ------------------ 191| 240| case 0xc7: // ext 8 ------------------ | Branch (191:21): [True: 240, False: 22.8k] ------------------ 192| 482| case 0xc8: // ext 16 ------------------ | Branch (192:21): [True: 242, False: 22.8k] ------------------ 193| 739| case 0xc9: // ext 32 ------------------ | Branch (193:21): [True: 257, False: 22.7k] ------------------ 194| 739| again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) + 1) & 0x03)); ------------------ | | 131| 739| trail = trail_len; \ | | 132| 739| cs = _cs; \ | | 133| 739| goto _fixed_trail_again ------------------ 195| 1.44k| case 0xca: // float ------------------ | Branch (195:21): [True: 1.44k, False: 21.6k] ------------------ 196| 1.63k| case 0xcb: // double ------------------ | Branch (196:21): [True: 190, False: 22.8k] ------------------ 197| 2.03k| case 0xcc: // unsigned int 8 ------------------ | Branch (197:21): [True: 404, False: 22.6k] ------------------ 198| 2.49k| case 0xcd: // unsigned int 16 ------------------ | Branch (198:21): [True: 463, False: 22.5k] ------------------ 199| 2.71k| case 0xce: // unsigned int 32 ------------------ | Branch (199:21): [True: 218, False: 22.8k] ------------------ 200| 2.89k| case 0xcf: // unsigned int 64 ------------------ | Branch (200:21): [True: 173, False: 22.8k] ------------------ 201| 3.58k| case 0xd0: // signed int 8 ------------------ | Branch (201:21): [True: 697, False: 22.3k] ------------------ 202| 4.53k| case 0xd1: // signed int 16 ------------------ | Branch (202:21): [True: 943, False: 22.1k] ------------------ 203| 5.18k| case 0xd2: // signed int 32 ------------------ | Branch (203:21): [True: 657, False: 22.3k] ------------------ 204| 6.11k| case 0xd3: // signed int 64 ------------------ | Branch (204:21): [True: 923, False: 22.1k] ------------------ 205| 6.11k| again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); ------------------ | | 131| 6.11k| trail = trail_len; \ | | 132| 6.11k| cs = _cs; \ | | 133| 6.11k| goto _fixed_trail_again ------------------ 206| 516| case 0xd4: // fixext 1 ------------------ | Branch (206:21): [True: 516, False: 22.5k] ------------------ 207| 887| case 0xd5: // fixext 2 ------------------ | Branch (207:21): [True: 371, False: 22.6k] ------------------ 208| 1.31k| case 0xd6: // fixext 4 ------------------ | Branch (208:21): [True: 432, False: 22.6k] ------------------ 209| 3.38k| case 0xd7: // fixext 8 ------------------ | Branch (209:21): [True: 2.06k, False: 20.9k] ------------------ 210| 3.38k| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, ------------------ | | 135| 3.38k| trail = trail_len; \ | | 136| 3.38k| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 3.38k] | | ------------------ | | 137| 3.38k| cs = _cs; \ | | 138| 3.38k| goto _fixed_trail_again ------------------ 211| 3.38k| (1 << (((unsigned int)*p) & 0x03)) + 1, _ext_zero); 212| 673| case 0xd8: // fixext 16 ------------------ | Branch (212:21): [True: 673, False: 22.3k] ------------------ 213| 673| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 16+1, _ext_zero); ------------------ | | 135| 673| trail = trail_len; \ | | 136| 673| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 673] | | ------------------ | | 137| 673| cs = _cs; \ | | 138| 673| goto _fixed_trail_again ------------------ 214| | 215| 621| case 0xd9: // str 8 ------------------ | Branch (215:21): [True: 621, False: 22.4k] ------------------ 216| 974| case 0xda: // str 16 ------------------ | Branch (216:21): [True: 353, False: 22.7k] ------------------ 217| 1.36k| case 0xdb: // str 32 ------------------ | Branch (217:21): [True: 389, False: 22.6k] ------------------ 218| 1.36k| again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) & 0x03) - 1)); ------------------ | | 131| 1.36k| trail = trail_len; \ | | 132| 1.36k| cs = _cs; \ | | 133| 1.36k| goto _fixed_trail_again ------------------ 219| 637| case 0xdc: // array 16 ------------------ | Branch (219:21): [True: 637, False: 22.4k] ------------------ 220| 1.27k| case 0xdd: // array 32 ------------------ | Branch (220:21): [True: 640, False: 22.4k] ------------------ 221| 2.28k| case 0xde: // map 16 ------------------ | Branch (221:21): [True: 1.01k, False: 22.0k] ------------------ 222| 2.85k| case 0xdf: // map 32 ------------------ | Branch (222:21): [True: 570, False: 22.4k] ------------------ 223| 2.85k| again_fixed_trail(NEXT_CS(p), 2u << (((unsigned int)*p) & 0x01)); ------------------ | | 131| 2.85k| trail = trail_len; \ | | 132| 2.85k| cs = _cs; \ | | 133| 2.85k| goto _fixed_trail_again ------------------ 224| 3| default: ------------------ | Branch (224:21): [True: 3, False: 23.0k] ------------------ 225| 3| ret = MSGPACK_UNPACK_PARSE_ERROR; 226| 3| goto _failed; 227| 23.0k| } 228| | SWITCH_RANGE(0xa0, 0xbf) // FixStr ------------------ | | 158| 10.0k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 10.0k, False: 132k] | | ------------------ ------------------ 229| 10.0k| again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, ((unsigned int)*p & 0x1f), _str_zero); ------------------ | | 135| 10.0k| trail = trail_len; \ | | 136| 10.0k| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 1.78k, False: 8.30k] | | ------------------ | | 137| 10.0k| cs = _cs; \ | | 138| 8.30k| goto _fixed_trail_again ------------------ 230| | SWITCH_RANGE(0x90, 0x9f) // FixArray ------------------ | | 158| 10.7k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 10.7k, False: 131k] | | ------------------ ------------------ 231| 21.4k| start_container(_array, ((unsigned int)*p) & 0x0f, MSGPACK_CT_ARRAY_ITEM); ------------------ | | 141| 10.7k| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 10.7k|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 16, False: 10.7k] | | ------------------ | | 142| 16| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 16| goto _failed; \ | | 144| 16| } /* FIXME */ \ | | 145| 10.7k| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 10.7k| template_callback ## name | | ------------------ | | 146| 10.7k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 0, False: 10.7k] | | ------------------ | | 147| 10.7k| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 2.74k, False: 7.97k] | | ------------------ | | 148| 10.7k| stack[top].ct = ct_; \ | | 149| 7.97k| stack[top].count = count_; \ | | 150| 7.97k| ++top; \ | | 151| 7.97k| goto _header_again ------------------ 232| | SWITCH_RANGE(0x80, 0x8f) // FixMap ------------------ | | 158| 7.95k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 7.95k, False: 134k] | | ------------------ ------------------ 233| 15.8k| start_container(_map, ((unsigned int)*p) & 0x0f, MSGPACK_CT_MAP_KEY); ------------------ | | 141| 7.95k| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 7.95k|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 14, False: 7.94k] | | ------------------ | | 142| 14| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 14| goto _failed; \ | | 144| 14| } /* FIXME */ \ | | 145| 7.95k| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 7.94k| template_callback ## name | | ------------------ | | 146| 7.94k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 0, False: 7.94k] | | ------------------ | | 147| 7.94k| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 2.85k, False: 5.08k] | | ------------------ | | 148| 7.94k| stack[top].ct = ct_; \ | | 149| 5.08k| stack[top].count = count_; \ | | 150| 5.08k| ++top; \ | | 151| 5.08k| goto _header_again ------------------ 234| | 235| 0| SWITCH_RANGE_DEFAULT ------------------ | | 159| 0|#define SWITCH_RANGE_DEFAULT default: | | ------------------ | | | Branch (159:32): [True: 0, False: 142k] | | ------------------ ------------------ 236| 0| ret = MSGPACK_UNPACK_PARSE_ERROR; 237| 0| goto _failed; 238| 142k| SWITCH_RANGE_END ------------------ | | 160| 142k|#define SWITCH_RANGE_END } ------------------ 239| | // end MSGPACK_CS_HEADER 240| | 241| | 242| 27.6k| _fixed_trail_again: 243| 27.6k| ++p; 244| | // fallthrough 245| | 246| 27.6k| default: ------------------ | Branch (246:13): [True: 0, False: 142k] ------------------ 247| 27.6k| if((size_t)(pe - p) < trail) { goto _out; } ------------------ | Branch (247:20): [True: 269, False: 27.3k] ------------------ 248| 27.3k| n = p; p += trail - 1; 249| 27.3k| switch(cs) { 250| | //case MSGPACK_CS_ 251| | //case MSGPACK_CS_ 252| 1.44k| case MSGPACK_CS_FLOAT: { ------------------ | Branch (252:17): [True: 1.44k, False: 25.9k] ------------------ 253| 1.44k| union { uint32_t i; float f; } mem; 254| 1.44k| _msgpack_load32(uint32_t, n, &mem.i); ------------------ | | 172| 1.44k|#define _msgpack_load32(cast, from, to) do { \ | | 173| 1.44k| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 1.44k| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 1.44k|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 1.44k| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 255| 1.44k| push_fixed_value(_float, mem.f); } ------------------ | | 121| 1.44k| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 1.44k| template_callback ## name | | ------------------ | | 122| 1.44k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 1.44k] | | ------------------ | | 123| 1.44k| goto _push ------------------ 256| 1.44k| case MSGPACK_CS_DOUBLE: { ------------------ | Branch (256:17): [True: 190, False: 27.1k] ------------------ 257| 190| union { uint64_t i; double f; } mem; 258| 190| _msgpack_load64(uint64_t, n, &mem.i); ------------------ | | 176| 190|#define _msgpack_load64(cast, from, to) do { \ | | 177| 190| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 178| 190| *(to) = (cast)_msgpack_be64(*(to)); \ | | ------------------ | | | | 142| 190|# define _msgpack_be64(x) bswap_64(x) | | ------------------ | | 179| 190| } while (0); | | ------------------ | | | Branch (179:14): [Folded - Ignored] | | ------------------ ------------------ 259| |#if defined(TARGET_OS_IPHONE) 260| | // ok 261| |#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi 262| | // https://github.com/msgpack/msgpack-perl/pull/1 263| | mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); 264| |#endif 265| 190| push_fixed_value(_double, mem.f); } ------------------ | | 121| 190| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 190| template_callback ## name | | ------------------ | | 122| 190| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 190] | | ------------------ | | 123| 190| goto _push ------------------ 266| 404| case MSGPACK_CS_UINT_8: ------------------ | Branch (266:17): [True: 404, False: 26.9k] ------------------ 267| 404| push_fixed_value(_uint8, *(uint8_t*)n); ------------------ | | 121| 404| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 404| template_callback ## name | | ------------------ | | 122| 404| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 404] | | ------------------ | | 123| 404| goto _push ------------------ 268| 463| case MSGPACK_CS_UINT_16:{ ------------------ | Branch (268:17): [True: 463, False: 26.9k] ------------------ 269| 463| uint16_t tmp; 270| 463| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 463|#define _msgpack_load16(cast, from, to) do { \ | | 168| 463| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 463| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 463|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 463| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 271| 463| push_fixed_value(_uint16, tmp); ------------------ | | 121| 463| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 463| template_callback ## name | | ------------------ | | 122| 463| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 463] | | ------------------ | | 123| 463| goto _push ------------------ 272| 463| } 273| 463| case MSGPACK_CS_UINT_32:{ ------------------ | Branch (273:17): [True: 217, False: 27.1k] ------------------ 274| 217| uint32_t tmp; 275| 217| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 217|#define _msgpack_load32(cast, from, to) do { \ | | 173| 217| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 217| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 217|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 217| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 276| 217| push_fixed_value(_uint32, tmp); ------------------ | | 121| 217| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 217| template_callback ## name | | ------------------ | | 122| 217| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 217] | | ------------------ | | 123| 217| goto _push ------------------ 277| 217| } 278| 217| case MSGPACK_CS_UINT_64:{ ------------------ | Branch (278:17): [True: 172, False: 27.2k] ------------------ 279| 172| uint64_t tmp; 280| 172| _msgpack_load64(uint64_t,n,&tmp); ------------------ | | 176| 172|#define _msgpack_load64(cast, from, to) do { \ | | 177| 172| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 178| 172| *(to) = (cast)_msgpack_be64(*(to)); \ | | ------------------ | | | | 142| 172|# define _msgpack_be64(x) bswap_64(x) | | ------------------ | | 179| 172| } while (0); | | ------------------ | | | Branch (179:14): [Folded - Ignored] | | ------------------ ------------------ 281| 172| push_fixed_value(_uint64, tmp); ------------------ | | 121| 172| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 172| template_callback ## name | | ------------------ | | 122| 172| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 172] | | ------------------ | | 123| 172| goto _push ------------------ 282| 172| } 283| 697| case MSGPACK_CS_INT_8: ------------------ | Branch (283:17): [True: 697, False: 26.6k] ------------------ 284| 697| push_fixed_value(_int8, *(int8_t*)n); ------------------ | | 121| 697| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 697| template_callback ## name | | ------------------ | | 122| 697| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 697] | | ------------------ | | 123| 697| goto _push ------------------ 285| 943| case MSGPACK_CS_INT_16:{ ------------------ | Branch (285:17): [True: 943, False: 26.4k] ------------------ 286| 943| int16_t tmp; 287| 943| _msgpack_load16(int16_t,n,&tmp); ------------------ | | 167| 943|#define _msgpack_load16(cast, from, to) do { \ | | 168| 943| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 943| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 943|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 943| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 288| 943| push_fixed_value(_int16, tmp); ------------------ | | 121| 943| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 943| template_callback ## name | | ------------------ | | 122| 943| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 943] | | ------------------ | | 123| 943| goto _push ------------------ 289| 943| } 290| 943| case MSGPACK_CS_INT_32:{ ------------------ | Branch (290:17): [True: 656, False: 26.7k] ------------------ 291| 656| int32_t tmp; 292| 656| _msgpack_load32(int32_t,n,&tmp); ------------------ | | 172| 656|#define _msgpack_load32(cast, from, to) do { \ | | 173| 656| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 656| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 656|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 656| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 293| 656| push_fixed_value(_int32, tmp); ------------------ | | 121| 656| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 656| template_callback ## name | | ------------------ | | 122| 656| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 656] | | ------------------ | | 123| 656| goto _push ------------------ 294| 656| } 295| 919| case MSGPACK_CS_INT_64:{ ------------------ | Branch (295:17): [True: 919, False: 26.4k] ------------------ 296| 919| int64_t tmp; 297| 919| _msgpack_load64(int64_t,n,&tmp); ------------------ | | 176| 919|#define _msgpack_load64(cast, from, to) do { \ | | 177| 919| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 178| 919| *(to) = (cast)_msgpack_be64(*(to)); \ | | ------------------ | | | | 142| 919|# define _msgpack_be64(x) bswap_64(x) | | ------------------ | | 179| 919| } while (0); | | ------------------ | | | Branch (179:14): [Folded - Ignored] | | ------------------ ------------------ 298| 919| push_fixed_value(_int64, tmp); ------------------ | | 121| 919| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 919| template_callback ## name | | ------------------ | | 122| 919| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 919] | | ------------------ | | 123| 919| goto _push ------------------ 299| 919| } 300| 919| case MSGPACK_CS_FIXEXT_1: ------------------ | Branch (300:17): [True: 0, False: 27.3k] ------------------ 301| 0| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 1+1, _ext_zero); ------------------ | | 135| 0| trail = trail_len; \ | | 136| 0| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 0] | | ------------------ | | 137| 0| cs = _cs; \ | | 138| 0| goto _fixed_trail_again ------------------ 302| 0| case MSGPACK_CS_FIXEXT_2: ------------------ | Branch (302:17): [True: 0, False: 27.3k] ------------------ 303| 0| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 2+1, _ext_zero); ------------------ | | 135| 0| trail = trail_len; \ | | 136| 0| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 0] | | ------------------ | | 137| 0| cs = _cs; \ | | 138| 0| goto _fixed_trail_again ------------------ 304| 0| case MSGPACK_CS_FIXEXT_4: ------------------ | Branch (304:17): [True: 0, False: 27.3k] ------------------ 305| 0| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 4+1, _ext_zero); ------------------ | | 135| 0| trail = trail_len; \ | | 136| 0| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 0] | | ------------------ | | 137| 0| cs = _cs; \ | | 138| 0| goto _fixed_trail_again ------------------ 306| 0| case MSGPACK_CS_FIXEXT_8: ------------------ | Branch (306:17): [True: 0, False: 27.3k] ------------------ 307| 0| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 8+1, _ext_zero); ------------------ | | 135| 0| trail = trail_len; \ | | 136| 0| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 0] | | ------------------ | | 137| 0| cs = _cs; \ | | 138| 0| goto _fixed_trail_again ------------------ 308| 0| case MSGPACK_CS_FIXEXT_16: ------------------ | Branch (308:17): [True: 0, False: 27.3k] ------------------ 309| 0| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 16+1, _ext_zero); ------------------ | | 135| 0| trail = trail_len; \ | | 136| 0| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 0] | | ------------------ | | 137| 0| cs = _cs; \ | | 138| 0| goto _fixed_trail_again ------------------ 310| 618| case MSGPACK_CS_STR_8: ------------------ | Branch (310:17): [True: 618, False: 26.7k] ------------------ 311| 618| again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, *(uint8_t*)n, _str_zero); ------------------ | | 135| 618| trail = trail_len; \ | | 136| 618| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 263, False: 355] | | ------------------ | | 137| 618| cs = _cs; \ | | 138| 355| goto _fixed_trail_again ------------------ 312| 1.25k| case MSGPACK_CS_BIN_8: ------------------ | Branch (312:17): [True: 1.25k, False: 26.1k] ------------------ 313| 1.25k| again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero); ------------------ | | 135| 1.25k| trail = trail_len; \ | | 136| 1.25k| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 800, False: 459] | | ------------------ | | 137| 1.25k| cs = _cs; \ | | 138| 459| goto _fixed_trail_again ------------------ 314| 240| case MSGPACK_CS_EXT_8: ------------------ | Branch (314:17): [True: 240, False: 27.1k] ------------------ 315| 240| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, (*(uint8_t*)n) + 1, _ext_zero); ------------------ | | 135| 240| trail = trail_len; \ | | 136| 240| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 240] | | ------------------ | | 137| 240| cs = _cs; \ | | 138| 240| goto _fixed_trail_again ------------------ 316| 353| case MSGPACK_CS_STR_16:{ ------------------ | Branch (316:17): [True: 353, False: 27.0k] ------------------ 317| 353| uint16_t tmp; 318| 353| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 353|#define _msgpack_load16(cast, from, to) do { \ | | 168| 353| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 353| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 353|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 353| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 319| 353| again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, tmp, _str_zero); ------------------ | | 135| 353| trail = trail_len; \ | | 136| 353| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 239, False: 114] | | ------------------ | | 137| 353| cs = _cs; \ | | 138| 114| goto _fixed_trail_again ------------------ 320| 353| } 321| 429| case MSGPACK_CS_BIN_16:{ ------------------ | Branch (321:17): [True: 429, False: 26.9k] ------------------ 322| 429| uint16_t tmp; 323| 429| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 429|#define _msgpack_load16(cast, from, to) do { \ | | 168| 429| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 429| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 429|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 429| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 324| 429| again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, tmp, _bin_zero); ------------------ | | 135| 429| trail = trail_len; \ | | 136| 429| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 205, False: 224] | | ------------------ | | 137| 429| cs = _cs; \ | | 138| 224| goto _fixed_trail_again ------------------ 325| 429| } 326| 241| case MSGPACK_CS_EXT_16:{ ------------------ | Branch (326:17): [True: 241, False: 27.1k] ------------------ 327| 241| uint16_t tmp; 328| 241| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 241|#define _msgpack_load16(cast, from, to) do { \ | | 168| 241| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 241| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 241|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 241| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 329| 241| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, tmp + 1, _ext_zero); ------------------ | | 135| 241| trail = trail_len; \ | | 136| 241| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 241] | | ------------------ | | 137| 241| cs = _cs; \ | | 138| 241| goto _fixed_trail_again ------------------ 330| 241| } 331| 389| case MSGPACK_CS_STR_32:{ ------------------ | Branch (331:17): [True: 389, False: 26.9k] ------------------ 332| 389| uint32_t tmp; 333| 389| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 389|#define _msgpack_load32(cast, from, to) do { \ | | 173| 389| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 389| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 389|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 389| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 334| 389| again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, tmp, _str_zero); ------------------ | | 135| 389| trail = trail_len; \ | | 136| 389| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 216, False: 173] | | ------------------ | | 137| 389| cs = _cs; \ | | 138| 173| goto _fixed_trail_again ------------------ 335| 389| } 336| 298| case MSGPACK_CS_BIN_32:{ ------------------ | Branch (336:17): [True: 298, False: 27.0k] ------------------ 337| 298| uint32_t tmp; 338| 298| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 298|#define _msgpack_load32(cast, from, to) do { \ | | 173| 298| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 298| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 298|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 298| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 339| 298| again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, tmp, _bin_zero); ------------------ | | 135| 298| trail = trail_len; \ | | 136| 298| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 139, False: 159] | | ------------------ | | 137| 298| cs = _cs; \ | | 138| 159| goto _fixed_trail_again ------------------ 340| 298| } 341| 257| case MSGPACK_CS_EXT_32:{ ------------------ | Branch (341:17): [True: 257, False: 27.1k] ------------------ 342| 257| uint32_t tmp; 343| 257| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 257|#define _msgpack_load32(cast, from, to) do { \ | | 173| 257| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 257| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 257|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 257| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 344| 257| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, tmp + 1, _ext_zero); ------------------ | | 135| 257| trail = trail_len; \ | | 136| 257| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 2, False: 255] | | ------------------ | | 137| 257| cs = _cs; \ | | 138| 255| goto _fixed_trail_again ------------------ 345| 257| } 346| 8.83k| case MSGPACK_ACS_STR_VALUE: ------------------ | Branch (346:17): [True: 8.83k, False: 18.5k] ------------------ 347| 11.3k| _str_zero: 348| 11.3k| push_variable_value(_str, data, n, trail); ------------------ | | 125| 11.3k| ret = msgpack_unpack_callback(func)(user, \ | | ------------------ | | | | 33| 11.3k| template_callback ## name | | ------------------ | | 126| 11.3k| (const char*)base, (const char*)pos, len, &obj); \ | | 127| 11.3k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (127:12): [True: 0, False: 11.3k] | | ------------------ | | 128| 11.3k| goto _push ------------------ 349| 11.3k| case MSGPACK_ACS_BIN_VALUE: ------------------ | Branch (349:17): [True: 773, False: 26.5k] ------------------ 350| 1.91k| _bin_zero: 351| 1.91k| push_variable_value(_bin, data, n, trail); ------------------ | | 125| 1.91k| ret = msgpack_unpack_callback(func)(user, \ | | ------------------ | | | | 33| 1.91k| template_callback ## name | | ------------------ | | 126| 1.91k| (const char*)base, (const char*)pos, len, &obj); \ | | 127| 1.91k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (127:12): [True: 0, False: 1.91k] | | ------------------ | | 128| 1.91k| goto _push ------------------ 352| 4.72k| case MSGPACK_ACS_EXT_VALUE: ------------------ | Branch (352:17): [True: 4.72k, False: 22.6k] ------------------ 353| 4.72k| _ext_zero: 354| 4.72k| push_variable_value(_ext, data, n, trail); ------------------ | | 125| 4.72k| ret = msgpack_unpack_callback(func)(user, \ | | ------------------ | | | | 33| 4.72k| template_callback ## name | | ------------------ | | 126| 4.72k| (const char*)base, (const char*)pos, len, &obj); \ | | 127| 4.72k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (127:12): [True: 2, False: 4.72k] | | ------------------ | | 128| 4.72k| goto _push ------------------ 355| | 356| 4.72k| case MSGPACK_CS_ARRAY_16:{ ------------------ | Branch (356:17): [True: 637, False: 26.7k] ------------------ 357| 637| uint16_t tmp; 358| 637| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 637|#define _msgpack_load16(cast, from, to) do { \ | | 168| 637| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 637| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 637|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 637| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 359| 1.26k| start_container(_array, tmp, MSGPACK_CT_ARRAY_ITEM); ------------------ | | 141| 637| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 637|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 7, False: 630] | | ------------------ | | 142| 7| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 7| goto _failed; \ | | 144| 7| } /* FIXME */ \ | | 145| 637| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 630| template_callback ## name | | ------------------ | | 146| 630| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 0, False: 630] | | ------------------ | | 147| 630| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 162, False: 468] | | ------------------ | | 148| 630| stack[top].ct = ct_; \ | | 149| 468| stack[top].count = count_; \ | | 150| 468| ++top; \ | | 151| 468| goto _header_again ------------------ 360| 1.26k| } 361| 638| case MSGPACK_CS_ARRAY_32:{ ------------------ | Branch (361:17): [True: 638, False: 26.7k] ------------------ 362| | /* FIXME security guard */ 363| 638| uint32_t tmp; 364| 638| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 638|#define _msgpack_load32(cast, from, to) do { \ | | 173| 638| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 638| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 638|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 638| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 365| 1.24k| start_container(_array, tmp, MSGPACK_CT_ARRAY_ITEM); ------------------ | | 141| 638| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 638|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 1, False: 637] | | ------------------ | | 142| 1| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 1| goto _failed; \ | | 144| 1| } /* FIXME */ \ | | 145| 638| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 637| template_callback ## name | | ------------------ | | 146| 637| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 26, False: 611] | | ------------------ | | 147| 637| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 247, False: 364] | | ------------------ | | 148| 611| stack[top].ct = ct_; \ | | 149| 364| stack[top].count = count_; \ | | 150| 364| ++top; \ | | 151| 364| goto _header_again ------------------ 366| 1.24k| } 367| | 368| 1.01k| case MSGPACK_CS_MAP_16:{ ------------------ | Branch (368:17): [True: 1.01k, False: 26.3k] ------------------ 369| 1.01k| uint16_t tmp; 370| 1.01k| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 1.01k|#define _msgpack_load16(cast, from, to) do { \ | | 168| 1.01k| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 1.01k| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 1.01k|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 1.01k| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 371| 2.01k| start_container(_map, tmp, MSGPACK_CT_MAP_KEY); ------------------ | | 141| 1.01k| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 1.01k|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 2, False: 1.00k] | | ------------------ | | 142| 2| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 2| goto _failed; \ | | 144| 2| } /* FIXME */ \ | | 145| 1.01k| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 1.00k| template_callback ## name | | ------------------ | | 146| 1.00k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 0, False: 1.00k] | | ------------------ | | 147| 1.00k| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 162, False: 846] | | ------------------ | | 148| 1.00k| stack[top].ct = ct_; \ | | 149| 846| stack[top].count = count_; \ | | 150| 846| ++top; \ | | 151| 846| goto _header_again ------------------ 372| 2.01k| } 373| 570| case MSGPACK_CS_MAP_32:{ ------------------ | Branch (373:17): [True: 570, False: 26.8k] ------------------ 374| | /* FIXME security guard */ 375| 570| uint32_t tmp; 376| 570| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 570|#define _msgpack_load32(cast, from, to) do { \ | | 173| 570| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 570| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 570|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 570| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 377| 1.10k| start_container(_map, tmp, MSGPACK_CT_MAP_KEY); ------------------ | | 141| 570| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 570|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 2, False: 568] | | ------------------ | | 142| 2| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 2| goto _failed; \ | | 144| 2| } /* FIXME */ \ | | 145| 570| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 568| template_callback ## name | | ------------------ | | 146| 568| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 31, False: 537] | | ------------------ | | 147| 568| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 269, False: 268] | | ------------------ | | 148| 537| stack[top].ct = ct_; \ | | 149| 268| stack[top].count = count_; \ | | 150| 268| ++top; \ | | 151| 268| goto _header_again ------------------ 378| 1.10k| } 379| | 380| 0| default: ------------------ | Branch (380:17): [True: 0, False: 27.3k] ------------------ 381| 0| ret = MSGPACK_UNPACK_PARSE_ERROR; 382| 0| goto _failed; 383| 27.3k| } 384| 142k| } 385| | 386| 136k| _push: 387| 136k| if(top == 0) { goto _finish; } ------------------ | Branch (387:12): [True: 347, False: 136k] ------------------ 388| 136k| c = &stack[top-1]; 389| 136k| switch(c->ct) { 390| 47.9k| case MSGPACK_CT_ARRAY_ITEM: ------------------ | Branch (390:9): [True: 47.9k, False: 88.4k] ------------------ 391| 47.9k| ret = msgpack_unpack_callback(_array_item)(user, &c->obj, obj); \ ------------------ | | 33| 47.9k| template_callback ## name ------------------ 392| 47.9k| if(ret < 0) { goto _failed; } ------------------ | Branch (392:16): [True: 0, False: 47.9k] ------------------ 393| 47.9k| if(--c->count == 0) { ------------------ | Branch (393:16): [True: 6.01k, False: 41.9k] ------------------ 394| 6.01k| obj = c->obj; 395| 6.01k| --top; 396| | /*printf("stack pop %d\n", top);*/ 397| 6.01k| goto _push; 398| 6.01k| } 399| 41.9k| goto _header_again; 400| 44.6k| case MSGPACK_CT_MAP_KEY: ------------------ | Branch (400:9): [True: 44.6k, False: 91.7k] ------------------ 401| 44.6k| c->map_key = obj; 402| 44.6k| c->ct = MSGPACK_CT_MAP_VALUE; 403| 44.6k| goto _header_again; 404| 43.7k| case MSGPACK_CT_MAP_VALUE: ------------------ | Branch (404:9): [True: 43.7k, False: 92.6k] ------------------ 405| 43.7k| ret = msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj); \ ------------------ | | 33| 43.7k| template_callback ## name ------------------ 406| 43.7k| if(ret < 0) { goto _failed; } ------------------ | Branch (406:16): [True: 0, False: 43.7k] ------------------ 407| 43.7k| if(--c->count == 0) { ------------------ | Branch (407:16): [True: 3.38k, False: 40.4k] ------------------ 408| 3.38k| obj = c->obj; 409| 3.38k| --top; 410| | /*printf("stack pop %d\n", top);*/ 411| 3.38k| goto _push; 412| 3.38k| } 413| 40.4k| c->ct = MSGPACK_CT_MAP_KEY; 414| 40.4k| goto _header_again; 415| | 416| 0| default: ------------------ | Branch (416:9): [True: 0, False: 136k] ------------------ 417| 0| ret = MSGPACK_UNPACK_PARSE_ERROR; 418| 0| goto _failed; 419| 136k| } 420| | 421| 142k| _header_again: 422| 142k| cs = MSGPACK_CS_HEADER; 423| 142k| ++p; 424| 142k| } while(p != pe); ------------------ | Branch (424:17): [True: 141k, False: 106] ------------------ 425| 106| goto _out; 426| | 427| | 428| 347| _finish: 429| 347| stack[0].obj = obj; 430| 347| ++p; 431| 347| ret = 1; 432| | /*printf("-- finish --\n"); */ 433| 347| goto _end; 434| | 435| 104| _failed: 436| | /*printf("** FAILED **\n"); */ 437| 104| goto _end; 438| | 439| 375| _out: 440| 375| ret = 0; 441| 375| goto _end; 442| | 443| 826| _end: 444| 826| ctx->cs = cs; 445| 826| ctx->trail = trail; 446| 826| ctx->top = top; 447| 826| *off = (size_t)(p - (const unsigned char*)data); 448| | 449| 826| return ret; 450| 826| } 451| 826|} unpack.c:template_data: 89| 347|{ 90| 347| return (ctx)->stack[0].obj; 91| 347|} unpack.c:msgpack_zone_malloc: 107| 21.5k|{ 108| 21.5k| char* aligned = 109| 21.5k| (char*)( 110| 21.5k| (size_t)( 111| 21.5k| zone->chunk_list.ptr + (MSGPACK_ZONE_ALIGN - 1) ------------------ | | 84| 21.5k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ 112| 21.5k| ) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN ------------------ | | 84| 21.5k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ ) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN ------------------ | | 84| 21.5k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ 113| 21.5k| ); 114| 21.5k| size_t adjusted_size = size + (size_t)(aligned - zone->chunk_list.ptr); 115| 21.5k| if(zone->chunk_list.free >= adjusted_size) { ------------------ | Branch (115:8): [True: 20.2k, False: 1.26k] ------------------ 116| 20.2k| zone->chunk_list.free -= adjusted_size; 117| 20.2k| zone->chunk_list.ptr += adjusted_size; 118| 20.2k| return aligned; 119| 20.2k| } 120| 1.26k| { 121| 1.26k| void* ptr = msgpack_zone_malloc_expand(zone, size + (MSGPACK_ZONE_ALIGN - 1)); ------------------ | | 84| 1.26k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ 122| 1.26k| if (ptr) { ------------------ | Branch (122:13): [True: 1.20k, False: 57] ------------------ 123| 1.20k| return (char*)((size_t)(ptr) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN); ------------------ | | 84| 1.20k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ return (char*)((size_t)(ptr) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN); ------------------ | | 84| 1.20k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ 124| 1.20k| } 125| 1.26k| } 126| 57| return NULL; 127| 1.26k|} msgpack_unpack_next: 659| 826|{ 660| 826| size_t noff = 0; 661| 826| msgpack_unpacked_destroy(result); 662| | 663| 826| if(off != NULL) { noff = *off; } ------------------ | Branch (663:8): [True: 826, False: 0] ------------------ 664| | 665| 826| if(len <= noff) { ------------------ | Branch (665:8): [True: 0, False: 826] ------------------ 666| 0| return MSGPACK_UNPACK_CONTINUE; 667| 0| } 668| | 669| 826| { 670| 826| int e; 671| 826| template_context ctx; 672| 826| template_init(&ctx); 673| | 674| 826| ctx.user.z = &result->zone; 675| 826| ctx.user.referenced = false; 676| | 677| 826| e = template_execute(&ctx, data, len, &noff); 678| | 679| 826| if(off != NULL) { *off = noff; } ------------------ | Branch (679:12): [True: 826, False: 0] ------------------ 680| | 681| 826| if(e < 0) { ------------------ | Branch (681:12): [True: 104, False: 722] ------------------ 682| 104| msgpack_zone_free(result->zone); 683| 104| result->zone = NULL; 684| 104| return (msgpack_unpack_return)e; 685| 104| } 686| | 687| 722| if(e == 0) { ------------------ | Branch (687:12): [True: 375, False: 347] ------------------ 688| 375| return MSGPACK_UNPACK_CONTINUE; 689| 375| } 690| | 691| 347| result->data = template_data(&ctx); 692| | 693| 347| return MSGPACK_UNPACK_SUCCESS; 694| 722| } 695| 722|} unpack.c:template_callback_root: 52| 826|{ 53| 826| msgpack_object o; 54| 826| MSGPACK_UNUSED(u); ------------------ | | 13| 826|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 55| 826| o.type = MSGPACK_OBJECT_NIL; 56| 826| return o; 57| 826|} unpack.c:template_callback_uint8: 60| 50.4k|{ 61| 50.4k| MSGPACK_UNUSED(u); ------------------ | | 13| 50.4k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 62| 50.4k| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 63| 50.4k| o->via.u64 = d; 64| 50.4k| return 0; 65| 50.4k|} unpack.c:template_callback_int8: 92| 41.5k|{ 93| 41.5k| MSGPACK_UNUSED(u); ------------------ | | 13| 41.5k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 94| 41.5k| if(d >= 0) { ------------------ | Branch (94:8): [True: 215, False: 41.3k] ------------------ 95| 215| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 96| 215| o->via.u64 = (uint64_t)d; 97| 215| return 0; 98| 215| } 99| 41.3k| else { 100| 41.3k| o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; 101| 41.3k| o->via.i64 = d; 102| 41.3k| return 0; 103| 41.3k| } 104| 41.5k|} unpack.c:template_callback_nil: 168| 2.27k|{ 169| 2.27k| MSGPACK_UNUSED(u); ------------------ | | 13| 2.27k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 170| 2.27k| o->type = MSGPACK_OBJECT_NIL; 171| 2.27k| return 0; 172| 2.27k|} unpack.c:template_callback_false: 183| 2.21k|{ 184| 2.21k| MSGPACK_UNUSED(u); ------------------ | | 13| 2.21k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 185| 2.21k| o->type = MSGPACK_OBJECT_BOOLEAN; 186| 2.21k| o->via.boolean = false; 187| 2.21k| return 0; 188| 2.21k|} unpack.c:template_callback_true: 175| 1.44k|{ 176| 1.44k| MSGPACK_UNUSED(u); ------------------ | | 13| 1.44k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 177| 1.44k| o->type = MSGPACK_OBJECT_BOOLEAN; 178| 1.44k| o->via.boolean = true; 179| 1.44k| return 0; 180| 1.44k|} unpack.c:template_callback_array: 191| 11.9k|{ 192| 11.9k| size_t size; 193| | // Let's leverage the fact that sizeof(msgpack_object) is a compile time constant 194| | // to check for int overflows. 195| | // Note - while n is constrained to 32-bit, the product of n * sizeof(msgpack_object) 196| | // might not be constrained to 4GB on 64-bit systems 197| |#if SIZE_MAX == UINT_MAX 198| | if (n > SIZE_MAX/sizeof(msgpack_object)) 199| | return MSGPACK_UNPACK_NOMEM_ERROR; 200| |#endif 201| | 202| 11.9k| o->type = MSGPACK_OBJECT_ARRAY; 203| 11.9k| o->via.array.size = 0; 204| | 205| 11.9k| size = n * sizeof(msgpack_object); 206| | 207| 11.9k| if (*u->z == NULL) { ------------------ | Branch (207:9): [True: 329, False: 11.6k] ------------------ 208| 329| *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); ------------------ | | 53| 329|#define MSGPACK_ZONE_CHUNK_SIZE 8192 ------------------ 209| 329| if(*u->z == NULL) { ------------------ | Branch (209:12): [True: 0, False: 329] ------------------ 210| 0| return MSGPACK_UNPACK_NOMEM_ERROR; 211| 0| } 212| 329| } 213| | 214| | // Unsure whether size = 0 should be an error, and if so, what to return 215| 11.9k| o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(*u->z, size); 216| 11.9k| if(o->via.array.ptr == NULL) { return MSGPACK_UNPACK_NOMEM_ERROR; } ------------------ | Branch (216:8): [True: 26, False: 11.9k] ------------------ 217| 11.9k| return 0; 218| 11.9k|} unpack.c:template_callback_map: 233| 9.51k|{ 234| 9.51k| size_t size; 235| | // Let's leverage the fact that sizeof(msgpack_object_kv) is a compile time constant 236| | // to check for int overflows 237| | // Note - while n is constrained to 32-bit, the product of n * sizeof(msgpack_object) 238| | // might not be constrained to 4GB on 64-bit systems 239| | 240| | // Note - this will always be false on 64-bit systems 241| |#if SIZE_MAX == UINT_MAX 242| | if (n > SIZE_MAX/sizeof(msgpack_object_kv)) 243| | return MSGPACK_UNPACK_NOMEM_ERROR; 244| |#endif 245| | 246| 9.51k| o->type = MSGPACK_OBJECT_MAP; 247| 9.51k| o->via.map.size = 0; 248| | 249| 9.51k| size = n * sizeof(msgpack_object_kv); 250| | 251| 9.51k| if (*u->z == NULL) { ------------------ | Branch (251:9): [True: 483, False: 9.03k] ------------------ 252| 483| *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); ------------------ | | 53| 483|#define MSGPACK_ZONE_CHUNK_SIZE 8192 ------------------ 253| 483| if(*u->z == NULL) { ------------------ | Branch (253:12): [True: 0, False: 483] ------------------ 254| 0| return MSGPACK_UNPACK_NOMEM_ERROR; 255| 0| } 256| 483| } 257| | 258| | // Should size = 0 be an error? If so, what error to return? 259| 9.51k| o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(*u->z, size); 260| 9.51k| if(o->via.map.ptr == NULL) { return MSGPACK_UNPACK_NOMEM_ERROR; } ------------------ | Branch (260:8): [True: 31, False: 9.48k] ------------------ 261| 9.48k| return 0; 262| 9.51k|} unpack.c:template_callback_float: 152| 1.44k|{ 153| 1.44k| MSGPACK_UNUSED(u); ------------------ | | 13| 1.44k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 154| 1.44k| o->type = MSGPACK_OBJECT_FLOAT32; 155| 1.44k| o->via.f64 = d; 156| 1.44k| return 0; 157| 1.44k|} unpack.c:template_callback_double: 160| 190|{ 161| 190| MSGPACK_UNUSED(u); ------------------ | | 13| 190|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 162| 190| o->type = MSGPACK_OBJECT_FLOAT64; 163| 190| o->via.f64 = d; 164| 190| return 0; 165| 190|} unpack.c:template_callback_uint16: 68| 463|{ 69| 463| MSGPACK_UNUSED(u); ------------------ | | 13| 463|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 70| 463| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 71| 463| o->via.u64 = d; 72| 463| return 0; 73| 463|} unpack.c:template_callback_uint32: 76| 217|{ 77| 217| MSGPACK_UNUSED(u); ------------------ | | 13| 217|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 78| 217| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 79| 217| o->via.u64 = d; 80| 217| return 0; 81| 217|} unpack.c:template_callback_uint64: 84| 172|{ 85| 172| MSGPACK_UNUSED(u); ------------------ | | 13| 172|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 86| 172| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 87| 172| o->via.u64 = d; 88| 172| return 0; 89| 172|} unpack.c:template_callback_int16: 107| 943|{ 108| 943| MSGPACK_UNUSED(u); ------------------ | | 13| 943|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 109| 943| if(d >= 0) { ------------------ | Branch (109:8): [True: 331, False: 612] ------------------ 110| 331| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 111| 331| o->via.u64 = (uint64_t)d; 112| 331| return 0; 113| 331| } 114| 612| else { 115| 612| o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; 116| 612| o->via.i64 = d; 117| 612| return 0; 118| 612| } 119| 943|} unpack.c:template_callback_int32: 122| 656|{ 123| 656| MSGPACK_UNUSED(u); ------------------ | | 13| 656|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 124| 656| if(d >= 0) { ------------------ | Branch (124:8): [True: 287, False: 369] ------------------ 125| 287| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 126| 287| o->via.u64 = (uint64_t)d; 127| 287| return 0; 128| 287| } 129| 369| else { 130| 369| o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; 131| 369| o->via.i64 = d; 132| 369| return 0; 133| 369| } 134| 656|} unpack.c:template_callback_int64: 137| 919|{ 138| 919| MSGPACK_UNUSED(u); ------------------ | | 13| 919|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 139| 919| if(d >= 0) { ------------------ | Branch (139:8): [True: 237, False: 682] ------------------ 140| 237| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 141| 237| o->via.u64 = (uint64_t)d; 142| 237| return 0; 143| 237| } 144| 682| else { 145| 682| o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; 146| 682| o->via.i64 = d; 147| 682| return 0; 148| 682| } 149| 919|} unpack.c:template_callback_str: 279| 11.3k|{ 280| 11.3k| MSGPACK_UNUSED(b); ------------------ | | 13| 11.3k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 281| 11.3k| if (*u->z == NULL) { ------------------ | Branch (281:9): [True: 2, False: 11.3k] ------------------ 282| 2| *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); ------------------ | | 53| 2|#define MSGPACK_ZONE_CHUNK_SIZE 8192 ------------------ 283| 2| if(*u->z == NULL) { ------------------ | Branch (283:12): [True: 0, False: 2] ------------------ 284| 0| return MSGPACK_UNPACK_NOMEM_ERROR; 285| 0| } 286| 2| } 287| 11.3k| o->type = MSGPACK_OBJECT_STR; 288| 11.3k| o->via.str.ptr = p; 289| 11.3k| o->via.str.size = l; 290| 11.3k| u->referenced = true; 291| 11.3k| return 0; 292| 11.3k|} unpack.c:template_callback_bin: 295| 1.91k|{ 296| 1.91k| MSGPACK_UNUSED(b); ------------------ | | 13| 1.91k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 297| 1.91k| if (*u->z == NULL) { ------------------ | Branch (297:9): [True: 9, False: 1.90k] ------------------ 298| 9| *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); ------------------ | | 53| 9|#define MSGPACK_ZONE_CHUNK_SIZE 8192 ------------------ 299| 9| if(*u->z == NULL) { ------------------ | Branch (299:12): [True: 0, False: 9] ------------------ 300| 0| return MSGPACK_UNPACK_NOMEM_ERROR; 301| 0| } 302| 9| } 303| 1.91k| o->type = MSGPACK_OBJECT_BIN; 304| 1.91k| o->via.bin.ptr = p; 305| 1.91k| o->via.bin.size = l; 306| 1.91k| u->referenced = true; 307| 1.91k| return 0; 308| 1.91k|} unpack.c:template_callback_ext: 311| 4.72k|{ 312| 4.72k| MSGPACK_UNUSED(b); ------------------ | | 13| 4.72k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 313| 4.72k| if (l == 0) { ------------------ | Branch (313:9): [True: 2, False: 4.72k] ------------------ 314| 2| return MSGPACK_UNPACK_PARSE_ERROR; 315| 2| } 316| 4.72k| if (*u->z == NULL) { ------------------ | Branch (316:9): [True: 1, False: 4.72k] ------------------ 317| 1| *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); ------------------ | | 53| 1|#define MSGPACK_ZONE_CHUNK_SIZE 8192 ------------------ 318| 1| if(*u->z == NULL) { ------------------ | Branch (318:12): [True: 0, False: 1] ------------------ 319| 0| return MSGPACK_UNPACK_NOMEM_ERROR; 320| 0| } 321| 1| } 322| 4.72k| o->type = MSGPACK_OBJECT_EXT; 323| 4.72k| o->via.ext.type = *p; 324| 4.72k| o->via.ext.ptr = p + 1; 325| 4.72k| o->via.ext.size = l - 1; 326| 4.72k| u->referenced = true; 327| 4.72k| return 0; 328| 4.72k|} unpack.c:template_callback_array_item: 221| 47.9k|{ 222| 47.9k| MSGPACK_UNUSED(u); ------------------ | | 13| 47.9k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 223| |#if defined(__GNUC__) && !defined(__clang__) 224| | memcpy(&c->via.array.ptr[c->via.array.size], &o, sizeof(msgpack_object)); 225| |#else /* __GNUC__ && !__clang__ */ 226| 47.9k| c->via.array.ptr[c->via.array.size] = o; 227| 47.9k|#endif /* __GNUC__ && !__clang__ */ 228| 47.9k| ++c->via.array.size; 229| 47.9k| return 0; 230| 47.9k|} unpack.c:template_callback_map_item: 265| 43.7k|{ 266| 43.7k| MSGPACK_UNUSED(u); ------------------ | | 13| 43.7k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 267| |#if defined(__GNUC__) && !defined(__clang__) 268| | memcpy(&c->via.map.ptr[c->via.map.size].key, &k, sizeof(msgpack_object)); 269| | memcpy(&c->via.map.ptr[c->via.map.size].val, &v, sizeof(msgpack_object)); 270| |#else /* __GNUC__ && !__clang__ */ 271| 43.7k| c->via.map.ptr[c->via.map.size].key = k; 272| 43.7k| c->via.map.ptr[c->via.map.size].val = v; 273| 43.7k|#endif /* __GNUC__ && !__clang__ */ 274| 43.7k| ++c->via.map.size; 275| 43.7k| return 0; 276| 43.7k|} fuzz_malloc: 14| 2.91k|void *fuzz_malloc(size_t size) {if (size > 0xa00000) return NULL; ------------------ | Branch (14:37): [True: 57, False: 2.85k] ------------------ 15| 2.85k|return malloc(size);} msgpack_zone_malloc_expand: 70| 1.26k|{ 71| 1.26k| msgpack_zone_chunk_list* const cl = &zone->chunk_list; 72| 1.26k| msgpack_zone_chunk* chunk; 73| | 74| 1.26k| size_t sz = zone->chunk_size; 75| | 76| 8.23k| while(sz < size) { ------------------ | Branch (76:11): [True: 6.97k, False: 1.26k] ------------------ 77| 6.97k| size_t tmp_sz = sz * 2; 78| 6.97k| if (tmp_sz <= sz) { ------------------ | Branch (78:13): [True: 0, False: 6.97k] ------------------ 79| 0| sz = size; 80| 0| break; 81| 0| } 82| 6.97k| sz = tmp_sz; 83| 6.97k| } 84| | 85| 1.26k| chunk = (msgpack_zone_chunk*)fuzz_malloc( 86| 1.26k| sizeof(msgpack_zone_chunk) + sz); 87| 1.26k| if (chunk == NULL) { ------------------ | Branch (87:9): [True: 57, False: 1.20k] ------------------ 88| 57| return NULL; 89| 57| } 90| 1.20k| else { 91| 1.20k| char* ptr = ((char*)chunk) + sizeof(msgpack_zone_chunk); 92| 1.20k| chunk->next = cl->head; 93| 1.20k| cl->head = chunk; 94| 1.20k| cl->free = sz - size; 95| 1.20k| cl->ptr = ptr + size; 96| | 97| 1.20k| return ptr; 98| 1.20k| } 99| 1.26k|} msgpack_zone_destroy: 175| 824|{ 176| 824| destroy_finalizer_array(&zone->finalizer_array); 177| 824| destroy_chunk_list(&zone->chunk_list); 178| 824|} msgpack_zone_new: 200| 824|{ 201| 824| msgpack_zone* zone = (msgpack_zone*)fuzz_malloc( 202| 824| sizeof(msgpack_zone)); 203| 824| if(zone == NULL) { ------------------ | Branch (203:8): [True: 0, False: 824] ------------------ 204| 0| return NULL; 205| 0| } 206| | 207| 824| zone->chunk_size = chunk_size; 208| | 209| 824| if(!init_chunk_list(&zone->chunk_list, chunk_size)) { ------------------ | Branch (209:8): [True: 0, False: 824] ------------------ 210| 0| free(zone); 211| 0| return NULL; 212| 0| } 213| | 214| 824| init_finalizer_array(&zone->finalizer_array); 215| | 216| 824| return zone; 217| 824|} msgpack_zone_free: 220| 825|{ 221| 825| if(zone == NULL) { return; } ------------------ | Branch (221:8): [True: 1, False: 824] ------------------ 222| 824| msgpack_zone_destroy(zone); 223| 824| free(zone); 224| 824|} zone.c:destroy_finalizer_array: 118| 824|{ 119| 824| call_finalizer_array(fa); 120| 824| free(fa->array); 121| 824|} zone.c:call_finalizer_array: 110| 824|{ 111| 824| msgpack_zone_finalizer* fin = fa->tail; 112| 824| for(; fin != fa->array; --fin) { ------------------ | Branch (112:11): [True: 0, False: 824] ------------------ 113| 0| (*(fin-1)->func)((fin-1)->data); 114| 0| } 115| 824|} zone.c:destroy_chunk_list: 38| 824|{ 39| 824| msgpack_zone_chunk* c = cl->head; 40| 2.02k| while(true) { 41| 2.02k| msgpack_zone_chunk* n = c->next; 42| 2.02k| free(c); 43| 2.02k| if(n != NULL) { ------------------ | Branch (43:12): [True: 1.20k, False: 824] ------------------ 44| 1.20k| c = n; 45| 1.20k| } else { 46| 824| break; 47| 824| } 48| 2.02k| } 49| 824|} zone.c:init_chunk_list: 22| 824|{ 23| 824| msgpack_zone_chunk* chunk = (msgpack_zone_chunk*)fuzz_malloc( 24| 824| sizeof(msgpack_zone_chunk) + chunk_size); 25| 824| if(chunk == NULL) { ------------------ | Branch (25:8): [True: 0, False: 824] ------------------ 26| 0| return false; 27| 0| } 28| | 29| 824| cl->head = chunk; 30| 824| cl->free = chunk_size; 31| 824| cl->ptr = ((char*)chunk) + sizeof(msgpack_zone_chunk); 32| 824| chunk->next = NULL; 33| | 34| 824| return true; 35| 824|} zone.c:init_finalizer_array: 103| 824|{ 104| 824| fa->tail = NULL; 105| 824| fa->end = NULL; 106| 824| fa->array = NULL; 107| 824|} flb_log_construct: 497| 2|{ 498| 2| int body_size; 499| 2| int ret; 500| 2| int len; 501| 2| int total; 502| 2| time_t now; 503| 2| const char *header_color = NULL; 504| 2| const char *header_title = NULL; 505| 2| const char *bold_color = ANSI_BOLD; ------------------ | | 47| 2|#define ANSI_BOLD "\033[1m" ------------------ 506| 2| const char *reset_color = ANSI_RESET; ------------------ | | 46| 2|#define ANSI_RESET "\033[0m" ------------------ 507| 2| struct tm result; 508| 2| struct tm *current; 509| | 510| 2| switch (type) { ------------------ | Branch (510:13): [True: 0, False: 2] ------------------ 511| 0| case FLB_LOG_HELP: ------------------ | | 44| 0|#define FLB_LOG_HELP 6 /* unused by log level */ ------------------ | Branch (511:5): [True: 0, False: 2] ------------------ 512| 0| header_title = "help"; 513| 0| header_color = ANSI_CYAN; ------------------ | | 48| 0|#define ANSI_CYAN "\033[96m" ------------------ 514| 0| break; 515| 0| case FLB_LOG_INFO: ------------------ | | 41| 0|#define FLB_LOG_INFO 3 /* default */ ------------------ | Branch (515:5): [True: 0, False: 2] ------------------ 516| 0| header_title = "info"; 517| 0| header_color = ANSI_GREEN; ------------------ | | 53| 0|#define ANSI_GREEN "\033[92m" ------------------ 518| 0| break; 519| 0| case FLB_LOG_WARN: ------------------ | | 40| 0|#define FLB_LOG_WARN 2 ------------------ | Branch (519:5): [True: 0, False: 2] ------------------ 520| 0| header_title = "warn"; 521| 0| header_color = ANSI_YELLOW; ------------------ | | 51| 0|#define ANSI_YELLOW "\033[93m" ------------------ 522| 0| break; 523| 2| case FLB_LOG_ERROR: ------------------ | | 39| 2|#define FLB_LOG_ERROR 1 ------------------ | Branch (523:5): [True: 2, False: 0] ------------------ 524| 2| header_title = "error"; 525| 2| header_color = ANSI_RED; ------------------ | | 50| 2|#define ANSI_RED "\033[91m" ------------------ 526| 2| break; 527| 0| case FLB_LOG_DEBUG: ------------------ | | 42| 0|#define FLB_LOG_DEBUG 4 ------------------ | Branch (527:5): [True: 0, False: 2] ------------------ 528| 0| header_title = "debug"; 529| 0| header_color = ANSI_YELLOW; ------------------ | | 51| 0|#define ANSI_YELLOW "\033[93m" ------------------ 530| 0| break; 531| 0| case FLB_LOG_IDEBUG: ------------------ | | 46| 0|#define FLB_LOG_IDEBUG 10 ------------------ | Branch (531:5): [True: 0, False: 2] ------------------ 532| 0| header_title = "debug"; 533| 0| header_color = ANSI_CYAN; ------------------ | | 48| 0|#define ANSI_CYAN "\033[96m" ------------------ 534| 0| break; 535| 0| case FLB_LOG_TRACE: ------------------ | | 43| 0|#define FLB_LOG_TRACE 5 ------------------ | Branch (535:5): [True: 0, False: 2] ------------------ 536| 0| header_title = "trace"; 537| 0| header_color = ANSI_BLUE; ------------------ | | 52| 0|#define ANSI_BLUE "\033[94m" ------------------ 538| 0| break; 539| 2| } 540| | 541| | #ifdef FLB_LOG_NO_CONTROL_CHARS 542| | header_color = ""; 543| | bold_color = ""; 544| | reset_color = ""; 545| | #else 546| | /* Only print colors to a terminal */ 547| 2| if (!isatty(STDOUT_FILENO)) { ------------------ | Branch (547:9): [True: 2, False: 0] ------------------ 548| 2| header_color = ""; 549| 2| bold_color = ""; 550| 2| reset_color = ""; 551| 2| } 552| 2| #endif // FLB_LOG_NO_CONTROL_CHARS 553| | 554| 2| now = time(NULL); 555| 2| current = localtime_r(&now, &result); 556| | 557| 2| if (current == NULL) { ------------------ | Branch (557:9): [True: 0, False: 2] ------------------ 558| 0| return -1; 559| 0| } 560| | 561| 2| len = snprintf(msg->msg, sizeof(msg->msg) - 1, 562| 2| "%s[%s%i/%02i/%02i %02i:%02i:%02i%s]%s [%s%5s%s] ", 563| | /* time */ /* type */ 564| | 565| | /* time variables */ 566| 2| bold_color, reset_color, 567| 2| current->tm_year + 1900, 568| 2| current->tm_mon + 1, 569| 2| current->tm_mday, 570| 2| current->tm_hour, 571| 2| current->tm_min, 572| 2| current->tm_sec, 573| 2| bold_color, reset_color, 574| | 575| | /* type format */ 576| 2| header_color, header_title, reset_color); 577| | 578| 2| body_size = (sizeof(msg->msg) - 2) - len; 579| 2| total = vsnprintf(msg->msg + len, 580| 2| body_size, 581| 2| fmt, *args); 582| 2| if (total < 0) { ------------------ | Branch (582:9): [True: 0, False: 2] ------------------ 583| 0| return -1; 584| 0| } 585| 2| ret = total; /* ret means a buffer size need to save log body */ 586| | 587| 2| total = strlen(msg->msg + len) + len; 588| 2| msg->msg[total++] = '\n'; 589| 2| msg->msg[total] = '\0'; 590| 2| msg->size = total; 591| | 592| 2| *ret_len = len; 593| | 594| 2| if (ret >= body_size) { ------------------ | Branch (594:9): [True: 0, False: 2] ------------------ 595| | /* log is truncated */ 596| 0| return ret - body_size; 597| 0| } 598| | 599| 2| return 0; 600| 2|} flb_log_print: 629| 2|{ 630| 2| int n; 631| 2| int len; 632| 2| int ret; 633| 2| struct log_message msg = {0}; 634| 2| va_list args; 635| | 636| 2| struct flb_worker *w; 637| | 638| 2| va_start(args, fmt); 639| 2| ret = flb_log_construct(&msg, &len, type, file, line, fmt, &args); 640| 2| va_end(args); 641| | 642| 2| if (ret < 0) { ------------------ | Branch (642:9): [True: 0, False: 2] ------------------ 643| 0| return; 644| 0| } 645| | 646| 2| w = flb_worker_get(); 647| 2| if (w) { ------------------ | Branch (647:9): [True: 0, False: 2] ------------------ 648| 0| n = flb_pipe_write_all(w->log[1], &msg, sizeof(msg)); 649| 0| if (n == -1) { ------------------ | Branch (649:13): [True: 0, False: 0] ------------------ 650| 0| fprintf(stderr, "%s", (char *) msg.msg); 651| 0| perror("write"); 652| 0| } 653| 0| } 654| 2| else { 655| 2| fprintf(stderr, "%s", (char *) msg.msg); 656| 2| } 657| | 658| | #ifdef FLB_HAVE_AWS_ERROR_REPORTER 659| | if (is_error_reporting_enabled()) { 660| | if (type == FLB_LOG_ERROR) { 661| | flb_aws_error_reporter_write(error_reporter, msg.msg + len); 662| | } 663| | 664| | flb_aws_error_reporter_clean(error_reporter); 665| | } 666| | #endif 667| 2|} flb_errno_print: 670| 2|{ 671| 2| char buf[256]; 672| | 673| 2| strerror_r(errnum, buf, sizeof(buf) - 1); 674| 2| flb_error("[%s:%i errno=%i] %s", file, line, errnum, buf); ------------------ | | 140| 2| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 39| 2|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (140:9): [True: 2, False: 0] | | ------------------ | | 141| 2| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 39| 2|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 675| 2| return 0; 676| 2|} flb_msgpack_to_json: 724| 1.75k|{ 725| 1.75k| int ret = -1; 726| 1.75k| int off = 0; 727| | 728| 1.75k| if (json_str == NULL || obj == NULL) { ------------------ | Branch (728:9): [True: 0, False: 1.75k] | Branch (728:29): [True: 0, False: 1.75k] ------------------ 729| 0| return -1; 730| 0| } 731| | 732| 1.75k| ret = msgpack2json(json_str, &off, json_size - 1, obj); 733| 1.75k| json_str[off] = '\0'; 734| 1.75k| return ret ? off: ret; ------------------ | Branch (734:12): [True: 347, False: 1.40k] ------------------ 735| 1.75k|} flb_msgpack_raw_to_json_sds: 738| 827|{ 739| 827| int ret; 740| 827| size_t off = 0; 741| 827| size_t out_size; 742| 827| size_t realloc_size; 743| | 744| 827| msgpack_unpacked result; 745| 827| msgpack_object *root; 746| 827| flb_sds_t out_buf; 747| 827| flb_sds_t tmp_buf; 748| | 749| | /* buffer size strategy */ 750| 827| out_size = in_size * FLB_MSGPACK_TO_JSON_INIT_BUFFER_SIZE; 751| 827| realloc_size = in_size * FLB_MSGPACK_TO_JSON_REALLOC_BUFFER_SIZE; 752| 827| if (realloc_size < 256) { ------------------ | Branch (752:9): [True: 827, False: 0] ------------------ 753| 827| realloc_size = 256; 754| 827| } 755| | 756| 827| out_buf = flb_sds_create_size(out_size); 757| 827| if (!out_buf) { ------------------ | Branch (757:9): [True: 1, False: 826] ------------------ 758| 1| flb_errno(); ------------------ | | 201| 1|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 759| 1| return NULL; 760| 1| } 761| | 762| 826| msgpack_unpacked_init(&result); 763| 826| ret = msgpack_unpack_next(&result, in_buf, in_size, &off); 764| 826| if (ret != MSGPACK_UNPACK_SUCCESS) { ------------------ | Branch (764:9): [True: 479, False: 347] ------------------ 765| 479| flb_sds_destroy(out_buf); 766| 479| msgpack_unpacked_destroy(&result); 767| 479| return NULL; 768| 479| } 769| | 770| 347| root = &result.data; 771| 1.75k| while (1) { ------------------ | Branch (771:12): [Folded - Ignored] ------------------ 772| 1.75k| ret = flb_msgpack_to_json(out_buf, out_size, root); 773| 1.75k| if (ret <= 0) { ------------------ | Branch (773:13): [True: 1.40k, False: 347] ------------------ 774| 1.40k| tmp_buf = flb_sds_increase(out_buf, realloc_size); 775| 1.40k| if (tmp_buf) { ------------------ | Branch (775:17): [True: 1.40k, False: 0] ------------------ 776| 1.40k| out_buf = tmp_buf; 777| 1.40k| out_size += realloc_size; 778| 1.40k| } 779| 0| else { 780| 0| flb_errno(); ------------------ | | 201| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 781| 0| flb_sds_destroy(out_buf); 782| 0| msgpack_unpacked_destroy(&result); 783| 0| return NULL; 784| 0| } 785| 1.40k| } 786| 347| else { 787| 347| break; 788| 347| } 789| 1.75k| } 790| | 791| 347| msgpack_unpacked_destroy(&result); 792| 347| flb_sds_len_set(out_buf, ret); 793| | 794| 347| return out_buf; 795| 347|} flb_pack.c:msgpack2json: 552| 181k|{ 553| 181k| int i; 554| 181k| int dup; 555| 181k| int ret = FLB_FALSE; ------------------ | | 25| 181k|#define FLB_FALSE 0 ------------------ 556| 181k| int loop; 557| 181k| int packed; 558| | 559| 181k| switch(o->type) { 560| 5.33k| case MSGPACK_OBJECT_NIL: ------------------ | Branch (560:5): [True: 5.33k, False: 175k] ------------------ 561| 5.33k| ret = try_to_write(buf, off, left, "null", 4); 562| 5.33k| break; 563| | 564| 4.89k| case MSGPACK_OBJECT_BOOLEAN: ------------------ | Branch (564:5): [True: 4.89k, False: 176k] ------------------ 565| 4.89k| ret = try_to_write(buf, off, left, 566| 4.89k| (o->via.boolean ? "true":"false"),0); ------------------ | Branch (566:29): [True: 977, False: 3.91k] ------------------ 567| | 568| 4.89k| break; 569| | 570| 65.0k| case MSGPACK_OBJECT_POSITIVE_INTEGER: ------------------ | Branch (570:5): [True: 65.0k, False: 116k] ------------------ 571| 65.0k| { 572| 65.0k| char temp[32] = {0}; 573| 65.0k| i = snprintf(temp, sizeof(temp)-1, "%"PRIu64, o->via.u64); 574| 65.0k| ret = try_to_write(buf, off, left, temp, i); 575| 65.0k| } 576| 65.0k| break; 577| | 578| 48.1k| case MSGPACK_OBJECT_NEGATIVE_INTEGER: ------------------ | Branch (578:5): [True: 48.1k, False: 132k] ------------------ 579| 48.1k| { 580| 48.1k| char temp[32] = {0}; 581| 48.1k| i = snprintf(temp, sizeof(temp)-1, "%"PRId64, o->via.i64); 582| 48.1k| ret = try_to_write(buf, off, left, temp, i); 583| 48.1k| } 584| 48.1k| break; 585| 3.43k| case MSGPACK_OBJECT_FLOAT32: ------------------ | Branch (585:5): [True: 3.43k, False: 177k] ------------------ 586| 3.83k| case MSGPACK_OBJECT_FLOAT64: ------------------ | Branch (586:5): [True: 398, False: 180k] ------------------ 587| 3.83k| { 588| 3.83k| char temp[512] = {0}; 589| 3.83k| if (o->via.f64 == (double)(long long int)o->via.f64) { ------------------ | Branch (589:17): [True: 841, False: 2.99k] ------------------ 590| 841| i = snprintf(temp, sizeof(temp)-1, "%.1f", o->via.f64); 591| 841| } 592| 2.99k| else if (convert_nan_to_null && isnan(o->via.f64) ) { ------------------ | Branch (592:22): [True: 0, False: 2.99k] ------------------ 593| 0| i = snprintf(temp, sizeof(temp)-1, "null"); 594| 0| } 595| 2.99k| else { 596| 2.99k| i = snprintf(temp, sizeof(temp)-1, "%.16g", o->via.f64); 597| 2.99k| } 598| 3.83k| ret = try_to_write(buf, off, left, temp, i); 599| 3.83k| } 600| 3.83k| break; 601| | 602| 14.6k| case MSGPACK_OBJECT_STR: ------------------ | Branch (602:5): [True: 14.6k, False: 166k] ------------------ 603| 14.6k| if (try_to_write(buf, off, left, "\"", 1) && ------------------ | Branch (603:13): [True: 14.6k, False: 33] ------------------ 604| 14.6k| (o->via.str.size > 0 ? ------------------ | Branch (604:13): [True: 14.3k, False: 231] | Branch (604:14): [True: 12.0k, False: 2.53k] ------------------ 605| 12.0k| try_to_write_str(buf, off, left, o->via.str.ptr, o->via.str.size) ------------------ | | 42| 12.0k|#define try_to_write_str flb_utils_write_str ------------------ 606| 14.6k| : 1/* nothing to do */) && 607| 14.6k| try_to_write(buf, off, left, "\"", 1)) { ------------------ | Branch (607:13): [True: 14.3k, False: 21] ------------------ 608| 14.3k| ret = FLB_TRUE; ------------------ | | 26| 14.3k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 14.3k|#define FLB_FALSE 0 | | ------------------ ------------------ 609| 14.3k| } 610| 14.6k| break; 611| | 612| 2.21k| case MSGPACK_OBJECT_BIN: ------------------ | Branch (612:5): [True: 2.21k, False: 178k] ------------------ 613| 2.21k| if (try_to_write(buf, off, left, "\"", 1) && ------------------ | Branch (613:13): [True: 2.19k, False: 13] ------------------ 614| 2.21k| (o->via.bin.size > 0 ? ------------------ | Branch (614:13): [True: 2.13k, False: 65] | Branch (614:14): [True: 1.12k, False: 1.07k] ------------------ 615| 1.12k| try_to_write_str(buf, off, left, o->via.bin.ptr, o->via.bin.size) ------------------ | | 42| 1.12k|#define try_to_write_str flb_utils_write_str ------------------ 616| 2.19k| : 1 /* nothing to do */) && 617| 2.21k| try_to_write(buf, off, left, "\"", 1)) { ------------------ | Branch (617:13): [True: 2.12k, False: 13] ------------------ 618| 2.12k| ret = FLB_TRUE; ------------------ | | 26| 2.12k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 2.12k|#define FLB_FALSE 0 | | ------------------ ------------------ 619| 2.12k| } 620| 2.21k| break; 621| | 622| 12.3k| case MSGPACK_OBJECT_EXT: ------------------ | Branch (622:5): [True: 12.3k, False: 168k] ------------------ 623| 12.3k| if (!try_to_write(buf, off, left, "\"", 1)) { ------------------ | Branch (623:13): [True: 20, False: 12.3k] ------------------ 624| 20| goto msg2json_end; 625| 20| } 626| | /* ext body. fortmat is similar to printf(1) */ 627| 12.3k| { 628| 12.3k| char temp[32] = {0}; 629| 12.3k| int len; 630| 12.3k| loop = o->via.ext.size; 631| 237k| for(i=0; ivia.ext.ptr[i]); 633| 225k| if (!try_to_write(buf, off, left, temp, len)) { ------------------ | Branch (633:21): [True: 533, False: 225k] ------------------ 634| 533| goto msg2json_end; 635| 533| } 636| 225k| } 637| 12.3k| } 638| 11.7k| if (!try_to_write(buf, off, left, "\"", 1)) { ------------------ | Branch (638:13): [True: 24, False: 11.7k] ------------------ 639| 24| goto msg2json_end; 640| 24| } 641| 11.7k| ret = FLB_TRUE; ------------------ | | 26| 11.7k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 11.7k|#define FLB_FALSE 0 | | ------------------ ------------------ 642| 11.7k| break; 643| | 644| 13.8k| case MSGPACK_OBJECT_ARRAY: ------------------ | Branch (644:5): [True: 13.8k, False: 167k] ------------------ 645| 13.8k| loop = o->via.array.size; 646| | 647| 13.8k| if (!try_to_write(buf, off, left, "[", 1)) { ------------------ | Branch (647:13): [True: 19, False: 13.7k] ------------------ 648| 19| goto msg2json_end; 649| 19| } 650| 13.7k| if (loop != 0) { ------------------ | Branch (650:13): [True: 10.1k, False: 3.67k] ------------------ 651| 10.1k| msgpack_object* p = o->via.array.ptr; 652| 10.1k| if (!msgpack2json(buf, off, left, p)) { ------------------ | Branch (652:17): [True: 1.61k, False: 8.49k] ------------------ 653| 1.61k| goto msg2json_end; 654| 1.61k| } 655| 58.7k| for (i=1; ivia.map.size; 668| 10.8k| if (!try_to_write(buf, off, left, "{", 1)) { ------------------ | Branch (668:13): [True: 25, False: 10.8k] ------------------ 669| 25| goto msg2json_end; 670| 25| } 671| 10.8k| if (loop != 0) { ------------------ | Branch (671:13): [True: 7.63k, False: 3.23k] ------------------ 672| 7.63k| msgpack_object k; 673| 7.63k| msgpack_object_kv *p = o->via.map.ptr; 674| | 675| 7.63k| packed = 0; 676| 7.63k| dup = FLB_FALSE; ------------------ | | 25| 7.63k|#define FLB_FALSE 0 ------------------ 677| | 678| 7.63k| k = o->via.map.ptr[0].key; 679| 65.9k| for (i = 0; i < loop; i++) { ------------------ | Branch (679:25): [True: 60.6k, False: 5.30k] ------------------ 680| 60.6k| k = o->via.map.ptr[i].key; 681| 60.6k| dup = key_exists_in_map(k, *o, i + 1); 682| 60.6k| if (dup == FLB_TRUE) { ------------------ | | 26| 60.6k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 60.6k|#define FLB_FALSE 0 | | ------------------ ------------------ | Branch (682:21): [True: 968, False: 59.6k] ------------------ 683| 968| continue; 684| 968| } 685| | 686| 59.6k| if (packed > 0) { ------------------ | Branch (686:21): [True: 52.0k, False: 7.63k] ------------------ 687| 52.0k| if (!try_to_write(buf, off, left, ",", 1)) { ------------------ | Branch (687:25): [True: 41, False: 51.9k] ------------------ 688| 41| goto msg2json_end; 689| 41| } 690| 52.0k| } 691| | 692| 59.6k| if ( 693| 59.6k| !msgpack2json(buf, off, left, &(p+i)->key) || ------------------ | Branch (693:21): [True: 1.27k, False: 58.3k] ------------------ 694| 59.6k| !try_to_write(buf, off, left, ":", 1) || ------------------ | Branch (694:21): [True: 48, False: 58.2k] ------------------ 695| 59.6k| !msgpack2json(buf, off, left, &(p+i)->val) ) { ------------------ | Branch (695:21): [True: 963, False: 57.3k] ------------------ 696| 2.28k| goto msg2json_end; 697| 2.28k| } 698| 57.3k| packed++; 699| 57.3k| } 700| 7.63k| } 701| | 702| 8.53k| ret = try_to_write(buf, off, left, "}", 1); 703| 8.53k| break; 704| | 705| 0| default: ------------------ | Branch (705:5): [True: 0, False: 181k] ------------------ 706| 0| flb_warn("[%s] unknown msgpack type %i", __FUNCTION__, o->type); ------------------ | | 149| 0| if (flb_log_check(FLB_LOG_WARN)) \ | | ------------------ | | | | 40| 0|#define FLB_LOG_WARN 2 | | ------------------ | | | Branch (149:9): [True: 0, False: 0] | | ------------------ | | 150| 0| flb_log_print(FLB_LOG_WARN, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 0|#define FLB_LOG_WARN 2 | | ------------------ ------------------ 707| 181k| } 708| | 709| 181k| msg2json_end: 710| 181k| return ret; 711| 181k|} flb_pack.c:try_to_write: 506| 616k|{ 507| 616k| if (str_len <= 0){ ------------------ | Branch (507:9): [True: 4.89k, False: 611k] ------------------ 508| 4.89k| str_len = strlen(str); 509| 4.89k| } 510| 616k| if (left <= *off+str_len) { ------------------ | Branch (510:9): [True: 1.10k, False: 615k] ------------------ 511| 1.10k| return FLB_FALSE; ------------------ | | 25| 1.10k|#define FLB_FALSE 0 ------------------ 512| 1.10k| } 513| 615k| memcpy(buf+*off, str, str_len); 514| 615k| *off += str_len; 515| 615k| return FLB_TRUE; ------------------ | | 26| 615k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 615k|#define FLB_FALSE 0 | | ------------------ ------------------ 516| 616k|} flb_pack.c:key_exists_in_map: 524| 60.6k|{ 525| 60.6k| int i; 526| 60.6k| msgpack_object p; 527| | 528| 60.6k| if (key.type != MSGPACK_OBJECT_STR) { ------------------ | Branch (528:9): [True: 53.3k, False: 7.22k] ------------------ 529| 53.3k| return FLB_FALSE; ------------------ | | 25| 53.3k|#define FLB_FALSE 0 ------------------ 530| 53.3k| } 531| | 532| 112k| for (i = offset; i < map.via.map.size; i++) { ------------------ | Branch (532:22): [True: 105k, False: 6.25k] ------------------ 533| 105k| p = map.via.map.ptr[i].key; 534| 105k| if (p.type != MSGPACK_OBJECT_STR) { ------------------ | Branch (534:13): [True: 93.6k, False: 12.2k] ------------------ 535| 93.6k| continue; 536| 93.6k| } 537| | 538| 12.2k| if (key.via.str.size != p.via.str.size) { ------------------ | Branch (538:13): [True: 8.17k, False: 4.04k] ------------------ 539| 8.17k| continue; 540| 8.17k| } 541| | 542| 4.04k| if (memcmp(key.via.str.ptr, p.via.str.ptr, p.via.str.size) == 0) { ------------------ | Branch (542:13): [True: 968, False: 3.08k] ------------------ 543| 968| return FLB_TRUE; ------------------ | | 26| 968|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 968|#define FLB_FALSE 0 | | ------------------ ------------------ 544| 968| } 545| 4.04k| } 546| | 547| 6.25k| return FLB_FALSE; ------------------ | | 25| 6.25k|#define FLB_FALSE 0 ------------------ 548| 7.22k|} flb_sds_create_size: 92| 827|{ 93| 827| return sds_alloc(size); 94| 827|} flb_sds_increase: 98| 1.40k|{ 99| 1.40k| size_t new_size; 100| 1.40k| struct flb_sds *head; 101| 1.40k| flb_sds_t out; 102| 1.40k| void *tmp; 103| | 104| 1.40k| out = s; 105| 1.40k| new_size = (FLB_SDS_HEADER_SIZE + flb_sds_alloc(s) + len + 1); ------------------ | | 34| 1.40k|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) ------------------ 106| 1.40k| head = FLB_SDS_HEADER(s); ------------------ | | 46| 1.40k|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 1.40k|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 107| 1.40k| tmp = flb_realloc(head, new_size); 108| 1.40k| if (!tmp) { ------------------ | Branch (108:9): [True: 0, False: 1.40k] ------------------ 109| 0| flb_errno(); ------------------ | | 201| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 110| 0| return NULL; 111| 0| } 112| 1.40k| head = (struct flb_sds *) tmp; 113| 1.40k| head->alloc += len; 114| 1.40k| out = head->buf; 115| | 116| 1.40k| return out; 117| 1.40k|} flb_sds_destroy: 462| 1.30k|{ 463| 1.30k| struct flb_sds *head; 464| | 465| 1.30k| if (!s) { ------------------ | Branch (465:9): [True: 480, False: 826] ------------------ 466| 480| return; 467| 480| } 468| | 469| 826| head = FLB_SDS_HEADER(s); ------------------ | | 46| 826|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 826|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 470| 826| flb_free(head); 471| 826|} flb_sds.c:sds_alloc: 36| 827|{ 37| 827| void *buf; 38| 827| flb_sds_t s; 39| 827| struct flb_sds *head; 40| | 41| 827| buf = flb_malloc(FLB_SDS_HEADER_SIZE + size + 1); ------------------ | | 34| 827|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) ------------------ 42| 827| if (!buf) { ------------------ | Branch (42:9): [True: 1, False: 826] ------------------ 43| 1| flb_errno(); ------------------ | | 201| 1|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 44| 1| return NULL; 45| 1| } 46| | 47| 826| head = buf; 48| 826| head->len = 0; 49| 826| head->alloc = size; 50| | 51| 826| s = head->buf; 52| 826| *s = '\0'; 53| | 54| 826| return s; 55| 827|} flb_utils_write_str: 638| 13.1k|{ 639| 13.1k| int i; 640| 13.1k| int b; 641| 13.1k| int ret; 642| 13.1k| int written = 0; 643| 13.1k| int required; 644| 13.1k| int len; 645| 13.1k| int hex_bytes; 646| 13.1k| int is_valid; 647| 13.1k| int utf_sequence_number; 648| 13.1k| int utf_sequence_length; 649| 13.1k| uint32_t codepoint; 650| 13.1k| uint32_t state = 0; 651| 13.1k| char tmp[16]; 652| 13.1k| size_t available; 653| 13.1k| uint32_t c; 654| 13.1k| char *p; 655| 13.1k| uint8_t *s; 656| | 657| 13.1k| available = (size - *off); 658| 13.1k| required = str_len; 659| 13.1k| if (available <= required) { ------------------ | Branch (659:9): [True: 90, False: 13.1k] ------------------ 660| 90| return FLB_FALSE; ------------------ | | 25| 90|#define FLB_FALSE 0 ------------------ 661| 90| } 662| | 663| 13.1k| p = buf + *off; 664| 163k| for (i = 0; i < str_len; i++) { ------------------ | Branch (664:17): [True: 156k, False: 7.41k] ------------------ 665| 156k| if ((available - written) < 2) { ------------------ | Branch (665:13): [True: 82, False: 156k] ------------------ 666| 82| return FLB_FALSE; ------------------ | | 25| 82|#define FLB_FALSE 0 ------------------ 667| 82| } 668| | 669| 156k| c = (uint32_t) str[i]; 670| 156k| if (c == '\"') { ------------------ | Branch (670:13): [True: 854, False: 155k] ------------------ 671| 854| *p++ = '\\'; 672| 854| *p++ = '\"'; 673| 854| } 674| 155k| else if (c == '\\') { ------------------ | Branch (674:18): [True: 463, False: 154k] ------------------ 675| 463| *p++ = '\\'; 676| 463| *p++ = '\\'; 677| 463| } 678| 154k| else if (c == '\n') { ------------------ | Branch (678:18): [True: 1.16k, False: 153k] ------------------ 679| 1.16k| *p++ = '\\'; 680| 1.16k| *p++ = 'n'; 681| 1.16k| } 682| 153k| else if (c == '\r') { ------------------ | Branch (682:18): [True: 1.29k, False: 152k] ------------------ 683| 1.29k| *p++ = '\\'; 684| 1.29k| *p++ = 'r'; 685| 1.29k| } 686| 152k| else if (c == '\t') { ------------------ | Branch (686:18): [True: 895, False: 151k] ------------------ 687| 895| *p++ = '\\'; 688| 895| *p++ = 't'; 689| 895| } 690| 151k| else if (c == '\b') { ------------------ | Branch (690:18): [True: 637, False: 150k] ------------------ 691| 637| *p++ = '\\'; 692| 637| *p++ = 'b'; 693| 637| } 694| 150k| else if (c == '\f') { ------------------ | Branch (694:18): [True: 497, False: 150k] ------------------ 695| 497| *p++ = '\\'; 696| 497| *p++ = 'f'; 697| 497| } 698| 150k| else if (c < 32 || c == 0x7f) { ------------------ | Branch (698:18): [True: 40.1k, False: 110k] | Branch (698:28): [True: 459, False: 109k] ------------------ 699| 40.5k| if ((available - written) < 6) { ------------------ | Branch (699:17): [True: 71, False: 40.5k] ------------------ 700| 71| return FLB_FALSE; ------------------ | | 25| 71|#define FLB_FALSE 0 ------------------ 701| 71| } 702| 40.5k| len = snprintf(tmp, sizeof(tmp) - 1, "\\u%.4hhx", (unsigned char) c); 703| 40.5k| if ((available - written) < len) { ------------------ | Branch (703:17): [True: 0, False: 40.5k] ------------------ 704| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 705| 0| } 706| 40.5k| encoded_to_buf(p, tmp, len); 707| 40.5k| p += len; 708| 40.5k| } 709| 109k| else if (c >= 0x80 && c <= 0xFFFF) { ------------------ | Branch (709:18): [True: 93.1k, False: 16.4k] | Branch (709:31): [True: 0, False: 93.1k] ------------------ 710| 0| hex_bytes = flb_utf8_len(str + i); 711| 0| if (available - written < 6) { ------------------ | Branch (711:17): [True: 0, False: 0] ------------------ 712| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 713| 0| } 714| | 715| 0| if (i + hex_bytes > str_len) { ------------------ | Branch (715:17): [True: 0, False: 0] ------------------ 716| 0| break; /* skip truncated UTF-8 */ 717| 0| } 718| | 719| 0| state = FLB_UTF8_ACCEPT; ------------------ | | 55| 0|#define FLB_UTF8_ACCEPT 0 ------------------ 720| 0| codepoint = 0; 721| | 722| 0| for (b = 0; b < hex_bytes; b++) { ------------------ | Branch (722:25): [True: 0, False: 0] ------------------ 723| 0| s = (unsigned char *) str + i + b; 724| 0| ret = flb_utf8_decode(&state, &codepoint, *s); 725| 0| if (ret == 0) { ------------------ | Branch (725:21): [True: 0, False: 0] ------------------ 726| 0| break; 727| 0| } 728| 0| } 729| | 730| 0| if (state != FLB_UTF8_ACCEPT) { ------------------ | | 55| 0|#define FLB_UTF8_ACCEPT 0 ------------------ | Branch (730:17): [True: 0, False: 0] ------------------ 731| | /* Invalid UTF-8 hex, just skip utf-8 bytes */ 732| 0| flb_warn("[pack] invalid UTF-8 bytes found, skipping bytes"); ------------------ | | 149| 0| if (flb_log_check(FLB_LOG_WARN)) \ | | ------------------ | | | | 40| 0|#define FLB_LOG_WARN 2 | | ------------------ | | | Branch (149:9): [True: 0, False: 0] | | ------------------ | | 150| 0| flb_log_print(FLB_LOG_WARN, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 0|#define FLB_LOG_WARN 2 | | ------------------ ------------------ 733| 0| } 734| 0| else { 735| 0| len = snprintf(tmp, sizeof(tmp) - 1, "\\u%.4x", codepoint); 736| 0| if ((available - written) < len) { ------------------ | Branch (736:21): [True: 0, False: 0] ------------------ 737| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 738| 0| } 739| 0| encoded_to_buf(p, tmp, len); 740| 0| p += len; 741| 0| } 742| 0| i += (hex_bytes - 1); 743| 0| } 744| 109k| else if (c > 0xFFFF) { ------------------ | Branch (744:18): [True: 93.1k, False: 16.4k] ------------------ 745| 93.1k| utf_sequence_length = flb_utf8_len(str + i); 746| | 747| 93.1k| if (i + utf_sequence_length > str_len) { ------------------ | Branch (747:17): [True: 5.49k, False: 87.6k] ------------------ 748| 5.49k| break; /* skip truncated UTF-8 */ 749| 5.49k| } 750| | 751| 87.6k| is_valid = FLB_TRUE; ------------------ | | 26| 87.6k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 87.6k|#define FLB_FALSE 0 | | ------------------ ------------------ 752| 128k| for (utf_sequence_number = 0; utf_sequence_number < utf_sequence_length; ------------------ | Branch (752:43): [True: 125k, False: 3.26k] ------------------ 753| 125k| utf_sequence_number++) { 754| | /* Leading characters must start with bits 11 */ 755| 125k| if (utf_sequence_number == 0 && ((str[i] & 0xC0) != 0xC0)) { ------------------ | Branch (755:21): [True: 87.6k, False: 37.4k] | Branch (755:49): [True: 53.6k, False: 33.9k] ------------------ 756| | /* Invalid unicode character. replace */ 757| 53.6k| flb_debug("[pack] unexpected UTF-8 leading byte, " ------------------ | | 167| 53.6k| if (flb_log_check(FLB_LOG_DEBUG)) \ | | ------------------ | | | | 42| 53.6k|#define FLB_LOG_DEBUG 4 | | ------------------ | | | Branch (167:9): [True: 0, False: 53.6k] | | ------------------ | | 168| 53.6k| flb_log_print(FLB_LOG_DEBUG, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 42| 0|#define FLB_LOG_DEBUG 4 | | ------------------ ------------------ 758| 53.6k| "substituting character with replacement character"); 759| 53.6k| tmp[utf_sequence_number] = str[i]; 760| 53.6k| ++i; /* Consume invalid leading byte */ 761| 53.6k| utf_sequence_length = utf_sequence_number + 1; 762| 53.6k| is_valid = FLB_FALSE; ------------------ | | 25| 53.6k|#define FLB_FALSE 0 ------------------ 763| 53.6k| break; 764| 53.6k| } 765| | /* Trailing characters must start with bits 10 */ 766| 71.4k| else if (utf_sequence_number > 0 && ((str[i] & 0xC0) != 0x80)) { ------------------ | Branch (766:26): [True: 37.4k, False: 33.9k] | Branch (766:53): [True: 30.6k, False: 6.73k] ------------------ 767| | /* Invalid unicode character. replace */ 768| 30.6k| flb_debug("[pack] unexpected UTF-8 continuation byte, " ------------------ | | 167| 30.6k| if (flb_log_check(FLB_LOG_DEBUG)) \ | | ------------------ | | | | 42| 30.6k|#define FLB_LOG_DEBUG 4 | | ------------------ | | | Branch (167:9): [True: 0, False: 30.6k] | | ------------------ | | 168| 30.6k| flb_log_print(FLB_LOG_DEBUG, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 42| 0|#define FLB_LOG_DEBUG 4 | | ------------------ ------------------ 769| 30.6k| "substituting character with replacement character"); 770| | /* This byte, i, is the start of the next unicode character */ 771| 30.6k| utf_sequence_length = utf_sequence_number; 772| 30.6k| is_valid = FLB_FALSE; ------------------ | | 25| 30.6k|#define FLB_FALSE 0 ------------------ 773| 30.6k| break; 774| 30.6k| } 775| | 776| 40.7k| tmp[utf_sequence_number] = str[i]; 777| 40.7k| ++i; 778| 40.7k| } 779| 87.6k| --i; 780| | 781| 87.6k| if (is_valid) { ------------------ | Branch (781:17): [True: 3.26k, False: 84.3k] ------------------ 782| 3.26k| if (available - written < utf_sequence_length) { ------------------ | Branch (782:21): [True: 13, False: 3.25k] ------------------ 783| 13| return FLB_FALSE; ------------------ | | 25| 13|#define FLB_FALSE 0 ------------------ 784| 13| } 785| | 786| 3.25k| encoded_to_buf(p, tmp, utf_sequence_length); 787| 3.25k| p += utf_sequence_length; 788| 3.25k| } 789| 84.3k| else { 790| 84.3k| if (available - written < utf_sequence_length * 3) { ------------------ | Branch (790:21): [True: 40, False: 84.3k] ------------------ 791| 40| return FLB_FALSE; ------------------ | | 25| 40|#define FLB_FALSE 0 ------------------ 792| 40| } 793| | 794| | /* 795| | * Utf-8 sequence is invalid. Map fragments to private use area 796| | * codepoints in range: 797| | * 0x00 to 798| | * 0xFF 799| | */ 800| 170k| for (b = 0; b < utf_sequence_length; ++b) { ------------------ | Branch (800:29): [True: 86.3k, False: 84.3k] ------------------ 801| | /* 802| | * Utf-8 private block invalid hex mapping. Format unicode charpoint 803| | * in the following format: 804| | * 805| | * +--------+--------+--------+ 806| | * |1110PPPP|10PPPPHH|10HHHHHH| 807| | * +--------+--------+--------+ 808| | * 809| | * Where: 810| | * P is FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR bits (1 byte) 811| | * H is Utf-8 fragment hex bits (1 byte) 812| | * 1 is bit 1 813| | * 0 is bit 0 814| | */ 815| | 816| | /* unicode codepoint start */ 817| 86.3k| *p = 0xE0; 818| | 819| | /* print unicode private block header first 4 bits */ 820| 86.3k| *p |= FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR >> 4; ------------------ | | 55| 86.3k|#define FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR 0xE0 ------------------ 821| 86.3k| ++p; 822| | 823| | /* unicode codepoint middle */ 824| 86.3k| *p = 0x80; 825| | 826| | /* print end of unicode private block header last 4 bits */ 827| 86.3k| *p |= ((FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR << 2) & 0x3f); ------------------ | | 55| 86.3k|#define FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR 0xE0 ------------------ 828| | 829| | /* print hex fragment first 2 bits */ 830| 86.3k| *p |= (tmp[b] >> 6) & 0x03; 831| 86.3k| ++p; 832| | 833| | /* unicode codepoint middle */ 834| 86.3k| *p = 0x80; 835| | 836| | /* print hex fragment last 6 bits */ 837| 86.3k| *p |= tmp[b] & 0x3f; 838| 86.3k| ++p; 839| 86.3k| } 840| 84.3k| } 841| 87.6k| } 842| 16.4k| else { 843| 16.4k| *p++ = c; 844| 16.4k| } 845| 150k| written = (p - (buf + *off)); 846| 150k| } 847| | 848| 12.9k| *off += written; 849| | 850| 12.9k| return FLB_TRUE; ------------------ | | 26| 12.9k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 12.9k|#define FLB_FALSE 0 | | ------------------ ------------------ 851| 13.1k|} flb_utils.c:encoded_to_buf: 622| 43.7k|{ 623| 43.7k| int i; 624| 43.7k| char *p = out; 625| | 626| 294k| for (i = 0; i < len; i++) { ------------------ | Branch (626:17): [True: 250k, False: 43.7k] ------------------ 627| 250k| *p++ = in[i]; 628| 250k| } 629| 43.7k|} flb_worker_get: 135| 2|{ 136| 2| return FLB_TLS_GET(flb_worker_ctx); ------------------ | | 34| 2|#define FLB_TLS_GET(key) key ------------------ 137| 2|} LLVMFuzzerTestOneInput: 6| 929|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size){ 7| | /* Set flb_malloc_mod to be fuzzer-data dependent */ 8| 929| if (size < 4) { ------------------ | Branch (8:9): [True: 2, False: 927] ------------------ 9| 2| return 0; 10| 2| } 11| 927| flb_malloc_p = 0; 12| 927| flb_malloc_mod = *(int*)data; 13| 927| data += 4; 14| 927| size -= 4; 15| | 16| | /* Avoid division by zero for modulo operations */ 17| 927| if (flb_malloc_mod == 0) { ------------------ | Branch (17:9): [True: 5, False: 922] ------------------ 18| 5| flb_malloc_mod = 1; 19| 5| } 20| | 21| 927| if (size != 512) ------------------ | Branch (21:9): [True: 100, False: 827] ------------------ 22| 100| return 0; 23| | 24| | /* target the conversion of raw msgpack to json */ 25| 827| flb_sds_t record; 26| 827| record = flb_msgpack_raw_to_json_sds(data, size); 27| 827| flb_sds_destroy(record); 28| | 29| 827| return 0; 30| 927|}