rtcp2json: 137| 378|{ 138| 378| const rtcp_t *r; /* RTCP header */ 139| 378| int i; 140| |#if 0 141| | const char *cp; 142| |#endif 143| | 144| 378| if (len < sizeof(rtcp_common_t)) { ------------------ | Branch (144:7): [True: 2, False: 376] ------------------ 145| 2| return -1; 146| 2| } 147| 376| r = (rtcp_t *)buf; 148| | /* Backwards compatibility: VAT header. */ 149| 376| if (r->common.version != RTP_VERSION) { ------------------ | | 41| 376|#define RTP_VERSION 2 ------------------ | Branch (149:7): [True: 4, False: 372] ------------------ 150| |#if 0 151| | fprintf(out, "invalid version %d\n", r->common.version); 152| |#endif 153| 4| return -1; 154| 4| } 155| | 156| |#if 0 157| | fprintf(out, "\n"); 158| |#endif 159| 6.53k| while (len > 0) { ------------------ | Branch (159:10): [True: 6.24k, False: 285] ------------------ 160| 6.24k| if (len < sizeof(rtcp_common_t)) { ------------------ | Branch (160:9): [True: 3, False: 6.24k] ------------------ 161| 3| return -1; 162| 3| } 163| 6.24k| size_t bincr = sizeof(uint32_t) * (ntohs(r->common.length) + 1); 164| | 165| 6.24k| switch (r->common.pt) { 166| 3.74k| case RTCP_SR: ------------------ | Branch (166:5): [True: 3.74k, False: 2.50k] ------------------ 167| 3.74k| if (len < bincr || bincr < (char *)&(r->r.sr) - (char *)r + sizeof(r->r.sr) + (sizeof(r->r.sr.rr[0]) * (r->common.count - 1))) ------------------ | Branch (167:11): [True: 33, False: 3.70k] | Branch (167:26): [True: 9, False: 3.70k] ------------------ 168| 42| goto invallen; 169| 3.70k| RSW_REST(-1, out, "{\n \"ssrc\": %lu,\n", ------------------ | | 118| 3.70k| { \ | | 119| 3.70k| int rval; \ | | 120| 3.72k| for (;;) { \ | | 121| 3.72k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 170| 3.72k| (unsigned long)ntohl(r->r.sr.ssrc)); | | ------------------ | | 122| 3.72k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.72k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.70k, False: 26] | | ------------------ | | 123| 3.72k| break; \ | | 124| 3.72k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 26|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 26] | | ------------------ | | 125| 26| return (exitcode); \ | | 126| 26| assert(rval == SBW_SHRT); \ | | 127| 26| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 26] | | ------------------ | | 128| 26| return (exitcode); \ | | 129| 26| } \ | | 130| 3.70k| } ------------------ | Branch (169:7): [True: 26, False: 0] ------------------ 170| 3.70k| (unsigned long)ntohl(r->r.sr.ssrc)); 171| 3.70k| RSW_REST(-1, out, " \"sender_information\": {\n \"ntp_timestamp_sec\": %lu,\n \"ntp_timestamp_usec\": %lu,\n \"rtp_timestamp\": %lu,\n \"packets\": %lu,\n \"octets\": %lu\n },\n", ------------------ | | 118| 3.70k| { \ | | 119| 3.70k| int rval; \ | | 120| 3.79k| for (;;) { \ | | 121| 3.79k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 172| 18.9k| (unsigned long)ntohl(r->r.sr.ntp_sec), | | | | 173| 18.9k| (unsigned long)ntohl(r->r.sr.ntp_frac), | | | | 174| 18.9k| (unsigned long)ntohl(r->r.sr.rtp_ts), | | | | 175| 18.9k| (unsigned long)ntohl(r->r.sr.psent), | | | | 176| 18.9k| (unsigned long)ntohl(r->r.sr.osent)); | | ------------------ | | 122| 3.79k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.79k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.70k, False: 90] | | ------------------ | | 123| 3.79k| break; \ | | 124| 3.79k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 90|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 90] | | ------------------ | | 125| 90| return (exitcode); \ | | 126| 90| assert(rval == SBW_SHRT); \ | | 127| 90| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 90] | | ------------------ | | 128| 90| return (exitcode); \ | | 129| 90| } \ | | 130| 3.70k| } ------------------ | Branch (171:7): [True: 90, False: 0] ------------------ 172| 3.70k| (unsigned long)ntohl(r->r.sr.ntp_sec), 173| 3.70k| (unsigned long)ntohl(r->r.sr.ntp_frac), 174| 3.70k| (unsigned long)ntohl(r->r.sr.rtp_ts), 175| 3.70k| (unsigned long)ntohl(r->r.sr.psent), 176| 3.70k| (unsigned long)ntohl(r->r.sr.osent)); 177| 3.70k| RSW_REST(-1, out, " \"type\": %lu,\n", (unsigned long)r->common.pt); ------------------ | | 118| 3.70k| { \ | | 119| 3.70k| int rval; \ | | 120| 3.71k| for (;;) { \ | | 121| 3.71k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.71k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.71k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.70k, False: 19] | | ------------------ | | 123| 3.71k| break; \ | | 124| 3.71k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 19|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 19] | | ------------------ | | 125| 19| return (exitcode); \ | | 126| 19| assert(rval == SBW_SHRT); \ | | 127| 19| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 19] | | ------------------ | | 128| 19| return (exitcode); \ | | 129| 19| } \ | | 130| 3.70k| } ------------------ | Branch (177:7): [True: 19, False: 0] ------------------ 178| 3.70k| if (r->common.count > 0) ------------------ | Branch (178:11): [True: 3.08k, False: 615] ------------------ 179| 3.70k| RSW_REST(-1, out, " \"report_blocks\": [\n"); ------------------ | | 118| 3.08k| { \ | | 119| 3.08k| int rval; \ | | 120| 3.11k| for (;;) { \ | | 121| 3.11k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.11k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.11k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.08k, False: 33] | | ------------------ | | 123| 3.11k| break; \ | | 124| 3.11k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 33|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 33] | | ------------------ | | 125| 33| return (exitcode); \ | | 126| 33| assert(rval == SBW_SHRT); \ | | 127| 33| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 33] | | ------------------ | | 128| 33| return (exitcode); \ | | 129| 33| } \ | | 130| 3.08k| } ------------------ | Branch (179:9): [True: 33, False: 0] ------------------ 180| 7.69k| for (i = 0; i < r->common.count; i++) { ------------------ | Branch (180:19): [True: 3.99k, False: 3.70k] ------------------ 181| 3.99k| if (i > 0) ------------------ | Branch (181:13): [True: 908, False: 3.08k] ------------------ 182| 3.99k| RSW_REST(-1, out, " ,\n"); ------------------ | | 118| 908| { \ | | 119| 908| int rval; \ | | 120| 930| for (;;) { \ | | 121| 930| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 930| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 930|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 908, False: 22] | | ------------------ | | 123| 930| break; \ | | 124| 930| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 22|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 22] | | ------------------ | | 125| 22| return (exitcode); \ | | 126| 22| assert(rval == SBW_SHRT); \ | | 127| 22| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 22] | | ------------------ | | 128| 22| return (exitcode); \ | | 129| 22| } \ | | 130| 908| } ------------------ | Branch (182:11): [True: 22, False: 0] ------------------ 183| 3.99k| RSW_REST(-1, out, " {\n \"source_ssrc\": %lu,\n \"fraction_lost\": %lu,\n \"packets_lost\": %ld,\n \"highest_seq_no\": %lu,\n \"ia_jitter\": %lu,\n \"lsr\": %lu,\n \"dlsr\": %lu\n }\n", ------------------ | | 118| 3.99k| { \ | | 119| 3.99k| int rval; \ | | 120| 4.10k| for (;;) { \ | | 121| 4.10k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 184| 24.6k| (unsigned long)ntohl(r->r.sr.rr[i].ssrc), | | | | 185| 24.6k| (unsigned long)r->r.sr.rr[i].fraction, | | | | 186| 24.6k| (long)RTCP_GET_LOST(&r->r.sr.rr[i]), | | | | ------------------ | | | | | | 106| 4.10k|#define RTCP_GET_LOST(rp) ((rp)->lost_sb ? (-1) : (1) * (((rp)->lost_b2 << 16) | ((rp)->lost_b1 << 8) | (rp)->lost_b0)) | | | | | | ------------------ | | | | | | | Branch (106:28): [True: 683, False: 3.42k] | | | | | | ------------------ | | | | ------------------ | | | | 187| 24.6k| (unsigned long)ntohl(r->r.sr.rr[i].last_seq), | | | | 188| 24.6k| (unsigned long)ntohl(r->r.sr.rr[i].jitter), | | | | 189| 24.6k| (unsigned long)ntohl(r->r.sr.rr[i].lsr), | | | | 190| 24.6k| (unsigned long)ntohl(r->r.sr.rr[i].dlsr)); | | ------------------ | | 122| 4.10k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 4.10k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.99k, False: 111] | | ------------------ | | 123| 4.10k| break; \ | | 124| 4.10k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 111|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 111] | | ------------------ | | 125| 111| return (exitcode); \ | | 126| 111| assert(rval == SBW_SHRT); \ | | 127| 111| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 111] | | ------------------ | | 128| 111| return (exitcode); \ | | 129| 111| } \ | | 130| 3.99k| } ------------------ | Branch (183:9): [True: 111, False: 0] ------------------ 184| 3.99k| (unsigned long)ntohl(r->r.sr.rr[i].ssrc), 185| 3.99k| (unsigned long)r->r.sr.rr[i].fraction, 186| 3.99k| (long)RTCP_GET_LOST(&r->r.sr.rr[i]), 187| 3.99k| (unsigned long)ntohl(r->r.sr.rr[i].last_seq), 188| 3.99k| (unsigned long)ntohl(r->r.sr.rr[i].jitter), 189| 3.99k| (unsigned long)ntohl(r->r.sr.rr[i].lsr), 190| 3.99k| (unsigned long)ntohl(r->r.sr.rr[i].dlsr)); 191| 3.99k| } 192| 3.70k| if (r->common.count > 0) ------------------ | Branch (192:11): [True: 3.08k, False: 615] ------------------ 193| 3.70k| RSW_REST(-1, out, " ],\n"); ------------------ | | 118| 3.08k| { \ | | 119| 3.08k| int rval; \ | | 120| 3.10k| for (;;) { \ | | 121| 3.10k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.10k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.10k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.08k, False: 19] | | ------------------ | | 123| 3.10k| break; \ | | 124| 3.10k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 19|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 19] | | ------------------ | | 125| 19| return (exitcode); \ | | 126| 19| assert(rval == SBW_SHRT); \ | | 127| 19| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 19] | | ------------------ | | 128| 19| return (exitcode); \ | | 129| 19| } \ | | 130| 3.08k| } ------------------ | Branch (193:9): [True: 19, False: 0] ------------------ 194| 3.70k| RSW_REST(-1, out, " \"report_count\": %lu\n", (unsigned long)r->common.count); ------------------ | | 118| 3.70k| { \ | | 119| 3.70k| int rval; \ | | 120| 3.75k| for (;;) { \ | | 121| 3.75k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.75k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.75k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.70k, False: 58] | | ------------------ | | 123| 3.75k| break; \ | | 124| 3.75k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 58|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 58] | | ------------------ | | 125| 58| return (exitcode); \ | | 126| 58| assert(rval == SBW_SHRT); \ | | 127| 58| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 58] | | ------------------ | | 128| 58| return (exitcode); \ | | 129| 58| } \ | | 130| 3.70k| } ------------------ | Branch (194:7): [True: 58, False: 0] ------------------ 195| 3.70k| RSW_REST(-1, out, "}"); ------------------ | | 118| 3.70k| { \ | | 119| 3.70k| int rval; \ | | 120| 3.72k| for (;;) { \ | | 121| 3.72k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.72k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.72k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.70k, False: 24] | | ------------------ | | 123| 3.72k| break; \ | | 124| 3.72k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 24|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 24] | | ------------------ | | 125| 24| return (exitcode); \ | | 126| 24| assert(rval == SBW_SHRT); \ | | 127| 24| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 24] | | ------------------ | | 128| 24| return (exitcode); \ | | 129| 24| } \ | | 130| 3.70k| } ------------------ | Branch (195:7): [True: 24, False: 0] ------------------ 196| 3.70k| break; 197| | 198| 2.23k| case RTCP_RR: ------------------ | Branch (198:5): [True: 2.23k, False: 4.01k] ------------------ 199| 2.23k| if (len < bincr || bincr < (char *)&(r->r.rr) - (char *)r + sizeof(r->r.rr) + (sizeof(r->r.rr.rr[0]) * (r->common.count - 1))) ------------------ | Branch (199:11): [True: 34, False: 2.19k] | Branch (199:26): [True: 8, False: 2.19k] ------------------ 200| 42| goto invallen; 201| 2.19k| RSW_REST(-1, out, "{\n \"ssrc\": %lu,\n", ------------------ | | 118| 2.19k| { \ | | 119| 2.19k| int rval; \ | | 120| 2.22k| for (;;) { \ | | 121| 2.22k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 202| 2.22k| (unsigned long)ntohl(r->r.rr.ssrc)); | | ------------------ | | 122| 2.22k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.22k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.19k, False: 29] | | ------------------ | | 123| 2.22k| break; \ | | 124| 2.22k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 29|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 29] | | ------------------ | | 125| 29| return (exitcode); \ | | 126| 29| assert(rval == SBW_SHRT); \ | | 127| 29| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 29] | | ------------------ | | 128| 29| return (exitcode); \ | | 129| 29| } \ | | 130| 2.19k| } ------------------ | Branch (201:7): [True: 29, False: 0] ------------------ 202| 2.19k| (unsigned long)ntohl(r->r.rr.ssrc)); 203| 2.19k| RSW_REST(-1, out, " \"type\": %lu,\n", (unsigned long)r->common.pt); ------------------ | | 118| 2.19k| { \ | | 119| 2.19k| int rval; \ | | 120| 2.21k| for (;;) { \ | | 121| 2.21k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.21k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.21k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.19k, False: 24] | | ------------------ | | 123| 2.21k| break; \ | | 124| 2.21k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 24|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 24] | | ------------------ | | 125| 24| return (exitcode); \ | | 126| 24| assert(rval == SBW_SHRT); \ | | 127| 24| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 24] | | ------------------ | | 128| 24| return (exitcode); \ | | 129| 24| } \ | | 130| 2.19k| } ------------------ | Branch (203:7): [True: 24, False: 0] ------------------ 204| 2.19k| if (r->common.count > 0) ------------------ | Branch (204:11): [True: 978, False: 1.21k] ------------------ 205| 2.19k| RSW_REST(-1, out, " \"report_blocks\": [\n"); ------------------ | | 118| 978| { \ | | 119| 978| int rval; \ | | 120| 997| for (;;) { \ | | 121| 997| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 997| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 997|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 978, False: 19] | | ------------------ | | 123| 997| break; \ | | 124| 997| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 19|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 19] | | ------------------ | | 125| 19| return (exitcode); \ | | 126| 19| assert(rval == SBW_SHRT); \ | | 127| 19| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 19] | | ------------------ | | 128| 19| return (exitcode); \ | | 129| 19| } \ | | 130| 978| } ------------------ | Branch (205:9): [True: 19, False: 0] ------------------ 206| 4.05k| for (i = 0; i < r->common.count; i++) { ------------------ | Branch (206:19): [True: 1.86k, False: 2.19k] ------------------ 207| 1.86k| if (i > 0) ------------------ | Branch (207:13): [True: 882, False: 978] ------------------ 208| 1.86k| RSW_REST(-1, out, " ,\n"); ------------------ | | 118| 882| { \ | | 119| 882| int rval; \ | | 120| 899| for (;;) { \ | | 121| 899| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 899| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 899|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 882, False: 17] | | ------------------ | | 123| 899| break; \ | | 124| 899| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 17|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 17] | | ------------------ | | 125| 17| return (exitcode); \ | | 126| 17| assert(rval == SBW_SHRT); \ | | 127| 17| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 17] | | ------------------ | | 128| 17| return (exitcode); \ | | 129| 17| } \ | | 130| 882| } ------------------ | Branch (208:11): [True: 17, False: 0] ------------------ 209| 1.86k| RSW_REST(-1, out, " {\n \"source_ssrc\": %lu,\n \"fraction_lost\": %lu,\n \"packets_lost\": %ld,\n \"highest_seq_no\": %lu,\n \"ia_jitter\": %lu,\n \"lsr\": %lu,\n \"dlsr\": %lu\n }\n", ------------------ | | 118| 1.86k| { \ | | 119| 1.86k| int rval; \ | | 120| 1.98k| for (;;) { \ | | 121| 1.98k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 210| 11.8k| (unsigned long)ntohl(r->r.rr.rr[i].ssrc), | | | | 211| 11.8k| (unsigned long)r->r.rr.rr[i].fraction, | | | | 212| 11.8k| (long)RTCP_GET_LOST(&r->r.rr.rr[i]), | | | | ------------------ | | | | | | 106| 1.98k|#define RTCP_GET_LOST(rp) ((rp)->lost_sb ? (-1) : (1) * (((rp)->lost_b2 << 16) | ((rp)->lost_b1 << 8) | (rp)->lost_b0)) | | | | | | ------------------ | | | | | | | Branch (106:28): [True: 586, False: 1.39k] | | | | | | ------------------ | | | | ------------------ | | | | 213| 11.8k| (unsigned long)ntohl(r->r.rr.rr[i].last_seq), | | | | 214| 11.8k| (unsigned long)ntohl(r->r.rr.rr[i].jitter), | | | | 215| 11.8k| (unsigned long)ntohl(r->r.rr.rr[i].lsr), | | | | 216| 11.8k| (unsigned long)ntohl(r->r.rr.rr[i].dlsr)); | | ------------------ | | 122| 1.98k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 1.98k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 1.86k, False: 123] | | ------------------ | | 123| 1.98k| break; \ | | 124| 1.98k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 123|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 123] | | ------------------ | | 125| 123| return (exitcode); \ | | 126| 123| assert(rval == SBW_SHRT); \ | | 127| 123| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 123] | | ------------------ | | 128| 123| return (exitcode); \ | | 129| 123| } \ | | 130| 1.86k| } ------------------ | Branch (209:9): [True: 123, False: 0] ------------------ 210| 1.86k| (unsigned long)ntohl(r->r.rr.rr[i].ssrc), 211| 1.86k| (unsigned long)r->r.rr.rr[i].fraction, 212| 1.86k| (long)RTCP_GET_LOST(&r->r.rr.rr[i]), 213| 1.86k| (unsigned long)ntohl(r->r.rr.rr[i].last_seq), 214| 1.86k| (unsigned long)ntohl(r->r.rr.rr[i].jitter), 215| 1.86k| (unsigned long)ntohl(r->r.rr.rr[i].lsr), 216| 1.86k| (unsigned long)ntohl(r->r.rr.rr[i].dlsr)); 217| 1.86k| } 218| 2.19k| if (r->common.count > 0) ------------------ | Branch (218:11): [True: 978, False: 1.21k] ------------------ 219| 2.19k| RSW_REST(-1, out, " ],\n"); ------------------ | | 118| 978| { \ | | 119| 978| int rval; \ | | 120| 997| for (;;) { \ | | 121| 997| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 997| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 997|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 978, False: 19] | | ------------------ | | 123| 997| break; \ | | 124| 997| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 19|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 19] | | ------------------ | | 125| 19| return (exitcode); \ | | 126| 19| assert(rval == SBW_SHRT); \ | | 127| 19| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 19] | | ------------------ | | 128| 19| return (exitcode); \ | | 129| 19| } \ | | 130| 978| } ------------------ | Branch (219:9): [True: 19, False: 0] ------------------ 220| 2.19k| RSW_REST(-1, out, " \"report_count\": %lu\n", (unsigned long)r->common.count); ------------------ | | 118| 2.19k| { \ | | 119| 2.19k| int rval; \ | | 120| 2.22k| for (;;) { \ | | 121| 2.22k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.22k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.22k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.19k, False: 32] | | ------------------ | | 123| 2.22k| break; \ | | 124| 2.22k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 32|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 32] | | ------------------ | | 125| 32| return (exitcode); \ | | 126| 32| assert(rval == SBW_SHRT); \ | | 127| 32| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 32] | | ------------------ | | 128| 32| return (exitcode); \ | | 129| 32| } \ | | 130| 2.19k| } ------------------ | Branch (220:7): [True: 32, False: 0] ------------------ 221| 2.19k| RSW_REST(-1, out, "}"); ------------------ | | 118| 2.19k| { \ | | 119| 2.19k| int rval; \ | | 120| 2.21k| for (;;) { \ | | 121| 2.21k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.21k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.21k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.19k, False: 28] | | ------------------ | | 123| 2.21k| break; \ | | 124| 2.21k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 28|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 28] | | ------------------ | | 125| 28| return (exitcode); \ | | 126| 28| assert(rval == SBW_SHRT); \ | | 127| 28| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 28] | | ------------------ | | 128| 28| return (exitcode); \ | | 129| 28| } \ | | 130| 2.19k| } ------------------ | Branch (221:7): [True: 28, False: 0] ------------------ 222| 2.19k| break; 223| | 224| 0| case RTCP_SDES: ------------------ | Branch (224:5): [True: 0, False: 6.24k] ------------------ 225| |#if 0 226| | fprintf(out, " (SDES p=%d count=%d len=%d\n", 227| | r->common.p, r->common.count, ntohs(r->common.length)); 228| | cp = (const char *)&r->r.sdes; 229| | for (i = 0; i < r->common.count; i++) { 230| | int remaining = (ntohs(r->common.length) << 2) - 231| | (cp - (const char *)&r->r.sdes); 232| | fprintf(out, " (src=0x%lx ", 233| | (unsigned long)ntohl(((struct rtcp_sdes *)cp)->src)); 234| | if (remaining > 0) { 235| | cp = rtp_read_sdes(out, cp, 236| | (ntohs(r->common.length) << 2) - (cp - (const char *)&r->r.sdes)); 237| | if (!cp) return -1; 238| | } else { 239| | fprintf(stderr, "Missing at least %d bytes.\n", -remaining); 240| | return -1; 241| | } 242| | fprintf(out, ")\n"); 243| | } 244| | fprintf(out, " )\n"); 245| |#endif 246| 0| break; 247| | 248| 1| case RTCP_BYE: ------------------ | Branch (248:5): [True: 1, False: 6.24k] ------------------ 249| |#if 0 250| | fprintf(out, " (BYE p=%d count=%d len=%d\n", 251| | r->common.p, r->common.count, ntohs(r->common.length)); 252| | for (i = 0; i < r->common.count; i++) { 253| | fprintf(out, " (ssrc[%d]=0x%0lx ", i, 254| | (unsigned long)ntohl(r->r.bye.src[i])); 255| | } 256| | fprintf(out, ")\n"); 257| | if (ntohs(r->common.length) > r->common.count) { 258| | cp = (const char *)&r->r.bye.src[r->common.count]; 259| | fprintf(out, "reason=\"%*.*s\"", *cp, *cp, cp+1); 260| | } 261| | fprintf(out, " )\n"); 262| |#endif 263| 1| break; 264| | 265| | /* invalid type */ 266| 267| default: ------------------ | Branch (266:5): [True: 267, False: 5.97k] ------------------ 267| |#if 0 268| | fprintf(out, "(? pt=%d src=0x%lx)\n", r->common.pt, 269| | (unsigned long)ntohl(r->r.sdes.src)); 270| |#endif 271| 267| break; 272| 6.24k| } 273| 6.15k| len -= bincr; 274| 6.15k| r = (const rtcp_t *)((const char *)r + bincr); 275| 6.15k| } 276| | 277| 285| return len; 278| | 279| 84|invallen: 280| | /* something wrong with packet format */ 281| |#if 0 282| | fprintf(out, "Illegal RTCP packet length %d words.\n", 283| | ntohs(r->common.length)); 284| |#endif 285| 84| return -1; 286| 372|} fuzz_rtcp_parser_init: 24| 2|{ 25| 2| const struct rtpp_minfo *mip; 26| | 27| 2| mip = rtpp_static_modules_lookup("acct_rtcp_hep"); 28| 2| assert(mip != NULL); ------------------ | Branch (28:5): [True: 0, False: 2] | Branch (28:5): [True: 2, False: 0] ------------------ 29| 2| *mip->fn = minfo_fset; 30| 2|} LLVMFuzzerTestOneInput: 34| 378|{ 35| 378| struct rtpp_sbuf *sbp; 36| | 37| 378| if (rtcp_dlen > MAX_RPKT_LEN) ------------------ | | 37| 378|#define MAX_RPKT_LEN 8192 ------------------ | Branch (37:9): [True: 0, False: 378] ------------------ 38| 0| return (0); 39| | 40| 378| sbp = rtpp_sbuf_ctor(512); 41| 378| assert (sbp != NULL); ------------------ | Branch (41:5): [True: 0, False: 378] | Branch (41:5): [True: 378, False: 0] ------------------ 42| |#if 0 43| | for (size_t i = 0; i < rtcp_dlen; i++) { 44| | char bf[3]; 45| | sprintf(bf, "%.2x", rtcp_data[i]); 46| | write(STDERR_FILENO, bf, 2); 47| | } 48| | write(STDERR_FILENO, "\n", 1); 49| | fsync(STDERR_FILENO); 50| |#endif 51| 378| rtcp2json(sbp, rtcp_data, rtcp_dlen); 52| 378| rtpp_sbuf_dtor(sbp); 53| | 54| 378| return (0); 55| 378|} rtpp_static_modules_lookup: 39| 2|{ 40| 2| const struct rtpp_minfo **tp; 41| | 42| 6| SET_FOREACH(tp, rtpp_modules) { ------------------ | | 118| 6| for (pvar = SET_BEGIN(set); pvar < SET_LIMIT(set); pvar++) | | ------------------ | | | | 106| 2| (&__RTPP_CONCAT(__start_set_,set)) | | | | ------------------ | | | | | | 35| 2|#define __RTPP_CONCAT(x,y) __RTPP_CONCAT1(x,y) | | | | | | ------------------ | | | | | | | | 34| 2|#define __RTPP_CONCAT1(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ | | for (pvar = SET_BEGIN(set); pvar < SET_LIMIT(set); pvar++) | | ------------------ | | | | 108| 6| (&__RTPP_CONCAT(__stop_set_,set)) | | | | ------------------ | | | | | | 35| 6|#define __RTPP_CONCAT(x,y) __RTPP_CONCAT1(x,y) | | | | | | ------------------ | | | | | | | | 34| 6|#define __RTPP_CONCAT1(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (118:30): [True: 6, False: 0] | | ------------------ ------------------ 43| 6| const struct rtpp_minfo *mp = *tp; 44| 6| if (strcmp(mp->descr.name, name) == 0) { ------------------ | Branch (44:13): [True: 2, False: 4] ------------------ 45| 2| return (mp); 46| 2| } 47| 6| } 48| 0| return (NULL); 49| 2|} rtpp_sbuf_write: 42| 43.7k|{ 43| 43.7k| va_list ap; 44| 43.7k| int rlen, len; 45| | 46| 43.7k| len = sbp->alen - RS_ULEN(sbp); ------------------ | | 40| 43.7k|#define RS_ULEN(sbp) ((int)((sbp)->cp - (sbp)->bp)) ------------------ 47| 43.7k| assert(len > 0); ------------------ | Branch (47:5): [True: 0, False: 43.7k] | Branch (47:5): [True: 43.7k, False: 0] ------------------ 48| 43.7k| va_start(ap, format); 49| 43.7k| rlen = vsnprintf(sbp->cp, len, format, ap); 50| 43.7k| va_end(ap); 51| 43.7k| if (rlen < 0) ------------------ | Branch (51:9): [True: 0, False: 43.7k] ------------------ 52| 0| return (SBW_ERR); ------------------ | | 37| 0|#define SBW_ERR (-1) ------------------ 53| 43.7k| if (rlen >= len) { ------------------ | Branch (53:9): [True: 693, False: 43.0k] ------------------ 54| 693| sbp->cp[0] = '\0'; 55| 693| return (SBW_SHRT); ------------------ | | 38| 693|#define SBW_SHRT (-2) ------------------ 56| 693| } 57| 43.0k| sbp->cp += rlen; 58| 43.0k| return (SBW_OK); ------------------ | | 36| 43.0k|#define SBW_OK (0) ------------------ 59| 43.7k|} rtpp_sbuf_ctor: 67| 378|{ 68| 378| struct rtpp_sbuf *sbp; 69| | 70| 378|#if !defined(RTPP_CHECK_LEAKS) 71| 378| sbp = malloc(sizeof(struct rtpp_sbuf)); 72| |#else 73| | sbp = rtpp_memdeb_malloc(sizeof(struct rtpp_sbuf), memdeb_p, mlp); 74| |#endif 75| 378| if (sbp == NULL) ------------------ | Branch (75:9): [True: 0, False: 378] ------------------ 76| 0| return (NULL); 77| 378| memset(sbp, '\0', sizeof(struct rtpp_sbuf)); 78| 378|#if !defined(RTPP_CHECK_LEAKS) 79| 378| sbp->bp = sbp->cp = malloc(ilen); 80| |#else 81| | sbp->bp = sbp->cp = rtpp_memdeb_malloc(ilen, memdeb_p, mlp); 82| |#endif 83| 378| if (sbp->bp == NULL) { ------------------ | Branch (83:9): [True: 0, False: 378] ------------------ 84| 0| free(sbp); 85| 0| return (NULL); 86| 0| } 87| 378| sbp->cp[0] = '\0'; 88| 378| sbp->alen = ilen; 89| 378| return(sbp); 90| 378|} rtpp_sbuf_dtor: 98| 378|{ 99| | 100| 378|#if !defined(RTPP_CHECK_LEAKS) 101| 378| free(sbp->bp); 102| 378| free(sbp); 103| |#else 104| | rtpp_memdeb_free(sbp->bp, memdeb_p, mlp); 105| | rtpp_memdeb_free(sbp, memdeb_p, mlp); 106| |#endif 107| 378|} rtpp_sbuf_extend: 115| 693|{ 116| 693| void *nbp, *ncp; 117| | 118| 693| assert(nlen > sbp->alen); ------------------ | Branch (118:5): [True: 0, False: 693] | Branch (118:5): [True: 693, False: 0] ------------------ 119| 693|#if !defined(RTPP_CHECK_LEAKS) 120| 693| nbp = realloc(sbp->bp, nlen); 121| |#else 122| | nbp = rtpp_memdeb_realloc(sbp->bp, nlen, memdeb_p, mlp); 123| |#endif 124| 693| if (nbp == NULL) ------------------ | Branch (124:9): [True: 0, False: 693] ------------------ 125| 0| return (-1); 126| 693| sbp->alen = nlen; 127| 693| if (sbp->bp != nbp) { ------------------ | Branch (127:9): [True: 308, False: 385] ------------------ 128| 308| ncp = nbp + RS_ULEN(sbp); ------------------ | | 40| 308|#define RS_ULEN(sbp) ((int)((sbp)->cp - (sbp)->bp)) ------------------ 129| 308| sbp->cp = ncp; 130| 308| sbp->bp = nbp; 131| 308| } 132| 693| return (0); 133| 693|}