rtcp2json: 137| 382|{ 138| 382| const rtcp_t *r; /* RTCP header */ 139| 382| int i; 140| |#if 0 141| | const char *cp; 142| |#endif 143| | 144| 382| if (len < sizeof(rtcp_common_t)) { ------------------ | Branch (144:7): [True: 2, False: 380] ------------------ 145| 2| return -1; 146| 2| } 147| 380| r = (rtcp_t *)buf; 148| | /* Backwards compatibility: VAT header. */ 149| 380| if (r->common.version != RTP_VERSION) { ------------------ | | 41| 380|#define RTP_VERSION 2 ------------------ | Branch (149:7): [True: 5, False: 375] ------------------ 150| |#if 0 151| | fprintf(out, "invalid version %d\n", r->common.version); 152| |#endif 153| 5| return -1; 154| 5| } 155| | 156| |#if 0 157| | fprintf(out, "\n"); 158| |#endif 159| 6.65k| while (len > 0) { ------------------ | Branch (159:10): [True: 6.37k, False: 281] ------------------ 160| 6.37k| if (len < sizeof(rtcp_common_t)) { ------------------ | Branch (160:9): [True: 5, False: 6.36k] ------------------ 161| 5| return -1; 162| 5| } 163| 6.36k| size_t bincr = sizeof(uint32_t) * (ntohs(r->common.length) + 1); 164| | 165| 6.36k| switch (r->common.pt) { 166| 3.72k| case RTCP_SR: ------------------ | Branch (166:5): [True: 3.72k, False: 2.64k] ------------------ 167| 3.72k| 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: 37, False: 3.68k] | Branch (167:26): [True: 11, False: 3.67k] ------------------ 168| 48| goto invallen; 169| 3.67k| RSW_REST(-1, out, "{\n \"ssrc\": %lu,\n", ------------------ | | 118| 3.67k| { \ | | 119| 3.67k| int rval; \ | | 120| 3.71k| for (;;) { \ | | 121| 3.71k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 170| 3.71k| (unsigned long)ntohl(r->r.sr.ssrc)); | | ------------------ | | 122| 3.71k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.71k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.67k, False: 37] | | ------------------ | | 123| 3.71k| break; \ | | 124| 3.71k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 37|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 37] | | ------------------ | | 125| 37| return (exitcode); \ | | 126| 37| assert(rval == SBW_SHRT); \ | | 127| 37| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 37] | | ------------------ | | 128| 37| return (exitcode); \ | | 129| 37| } \ | | 130| 3.67k| } ------------------ | Branch (169:7): [True: 37, False: 0] ------------------ 170| 3.67k| (unsigned long)ntohl(r->r.sr.ssrc)); 171| 3.67k| 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.67k| { \ | | 119| 3.67k| int rval; \ | | 120| 3.75k| for (;;) { \ | | 121| 3.75k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 172| 18.7k| (unsigned long)ntohl(r->r.sr.ntp_sec), | | | | 173| 18.7k| (unsigned long)ntohl(r->r.sr.ntp_frac), | | | | 174| 18.7k| (unsigned long)ntohl(r->r.sr.rtp_ts), | | | | 175| 18.7k| (unsigned long)ntohl(r->r.sr.psent), | | | | 176| 18.7k| (unsigned long)ntohl(r->r.sr.osent)); | | ------------------ | | 122| 3.75k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.75k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.67k, False: 80] | | ------------------ | | 123| 3.75k| break; \ | | 124| 3.75k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 80|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 80] | | ------------------ | | 125| 80| return (exitcode); \ | | 126| 80| assert(rval == SBW_SHRT); \ | | 127| 80| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 80] | | ------------------ | | 128| 80| return (exitcode); \ | | 129| 80| } \ | | 130| 3.67k| } ------------------ | Branch (171:7): [True: 80, False: 0] ------------------ 172| 3.67k| (unsigned long)ntohl(r->r.sr.ntp_sec), 173| 3.67k| (unsigned long)ntohl(r->r.sr.ntp_frac), 174| 3.67k| (unsigned long)ntohl(r->r.sr.rtp_ts), 175| 3.67k| (unsigned long)ntohl(r->r.sr.psent), 176| 3.67k| (unsigned long)ntohl(r->r.sr.osent)); 177| 3.67k| RSW_REST(-1, out, " \"type\": %lu,\n", (unsigned long)r->common.pt); ------------------ | | 118| 3.67k| { \ | | 119| 3.67k| int rval; \ | | 120| 3.69k| for (;;) { \ | | 121| 3.69k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.69k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.69k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.67k, False: 19] | | ------------------ | | 123| 3.69k| break; \ | | 124| 3.69k| 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.67k| } ------------------ | Branch (177:7): [True: 19, False: 0] ------------------ 178| 3.67k| if (r->common.count > 0) ------------------ | Branch (178:11): [True: 2.79k, False: 887] ------------------ 179| 3.67k| RSW_REST(-1, out, " \"report_blocks\": [\n"); ------------------ | | 118| 2.79k| { \ | | 119| 2.79k| int rval; \ | | 120| 2.82k| for (;;) { \ | | 121| 2.82k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.82k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.82k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.79k, False: 38] | | ------------------ | | 123| 2.82k| break; \ | | 124| 2.82k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 38|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 38] | | ------------------ | | 125| 38| return (exitcode); \ | | 126| 38| assert(rval == SBW_SHRT); \ | | 127| 38| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 38] | | ------------------ | | 128| 38| return (exitcode); \ | | 129| 38| } \ | | 130| 2.79k| } ------------------ | Branch (179:9): [True: 38, False: 0] ------------------ 180| 7.36k| for (i = 0; i < r->common.count; i++) { ------------------ | Branch (180:19): [True: 3.68k, False: 3.67k] ------------------ 181| 3.68k| if (i > 0) ------------------ | Branch (181:13): [True: 896, False: 2.79k] ------------------ 182| 3.68k| RSW_REST(-1, out, " ,\n"); ------------------ | | 118| 896| { \ | | 119| 896| int rval; \ | | 120| 908| for (;;) { \ | | 121| 908| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 908| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 908|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 896, False: 12] | | ------------------ | | 123| 908| break; \ | | 124| 908| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 12|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 12] | | ------------------ | | 125| 12| return (exitcode); \ | | 126| 12| assert(rval == SBW_SHRT); \ | | 127| 12| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 12] | | ------------------ | | 128| 12| return (exitcode); \ | | 129| 12| } \ | | 130| 896| } ------------------ | Branch (182:11): [True: 12, False: 0] ------------------ 183| 3.68k| 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.68k| { \ | | 119| 3.68k| int rval; \ | | 120| 3.80k| for (;;) { \ | | 121| 3.80k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 184| 22.8k| (unsigned long)ntohl(r->r.sr.rr[i].ssrc), | | | | 185| 22.8k| (unsigned long)r->r.sr.rr[i].fraction, | | | | 186| 22.8k| (long)RTCP_GET_LOST(&r->r.sr.rr[i]), | | | | ------------------ | | | | | | 106| 3.80k|#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: 753, False: 3.05k] | | | | | | ------------------ | | | | ------------------ | | | | 187| 22.8k| (unsigned long)ntohl(r->r.sr.rr[i].last_seq), | | | | 188| 22.8k| (unsigned long)ntohl(r->r.sr.rr[i].jitter), | | | | 189| 22.8k| (unsigned long)ntohl(r->r.sr.rr[i].lsr), | | | | 190| 22.8k| (unsigned long)ntohl(r->r.sr.rr[i].dlsr)); | | ------------------ | | 122| 3.80k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.80k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.68k, False: 117] | | ------------------ | | 123| 3.80k| break; \ | | 124| 3.80k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 117|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 117] | | ------------------ | | 125| 117| return (exitcode); \ | | 126| 117| assert(rval == SBW_SHRT); \ | | 127| 117| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 117] | | ------------------ | | 128| 117| return (exitcode); \ | | 129| 117| } \ | | 130| 3.68k| } ------------------ | Branch (183:9): [True: 117, False: 0] ------------------ 184| 3.68k| (unsigned long)ntohl(r->r.sr.rr[i].ssrc), 185| 3.68k| (unsigned long)r->r.sr.rr[i].fraction, 186| 3.68k| (long)RTCP_GET_LOST(&r->r.sr.rr[i]), 187| 3.68k| (unsigned long)ntohl(r->r.sr.rr[i].last_seq), 188| 3.68k| (unsigned long)ntohl(r->r.sr.rr[i].jitter), 189| 3.68k| (unsigned long)ntohl(r->r.sr.rr[i].lsr), 190| 3.68k| (unsigned long)ntohl(r->r.sr.rr[i].dlsr)); 191| 3.68k| } 192| 3.67k| if (r->common.count > 0) ------------------ | Branch (192:11): [True: 2.79k, False: 887] ------------------ 193| 3.67k| RSW_REST(-1, out, " ],\n"); ------------------ | | 118| 2.79k| { \ | | 119| 2.79k| int rval; \ | | 120| 2.81k| for (;;) { \ | | 121| 2.81k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.81k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.81k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.79k, False: 19] | | ------------------ | | 123| 2.81k| break; \ | | 124| 2.81k| 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| 2.79k| } ------------------ | Branch (193:9): [True: 19, False: 0] ------------------ 194| 3.67k| RSW_REST(-1, out, " \"report_count\": %lu\n", (unsigned long)r->common.count); ------------------ | | 118| 3.67k| { \ | | 119| 3.67k| 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.67k, False: 42] | | ------------------ | | 123| 3.72k| break; \ | | 124| 3.72k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 42|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 42] | | ------------------ | | 125| 42| return (exitcode); \ | | 126| 42| assert(rval == SBW_SHRT); \ | | 127| 42| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 42] | | ------------------ | | 128| 42| return (exitcode); \ | | 129| 42| } \ | | 130| 3.67k| } ------------------ | Branch (194:7): [True: 42, False: 0] ------------------ 195| 3.67k| RSW_REST(-1, out, "}"); ------------------ | | 118| 3.67k| { \ | | 119| 3.67k| int rval; \ | | 120| 3.69k| for (;;) { \ | | 121| 3.69k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.69k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.69k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.67k, False: 21] | | ------------------ | | 123| 3.69k| break; \ | | 124| 3.69k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 21|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 21] | | ------------------ | | 125| 21| return (exitcode); \ | | 126| 21| assert(rval == SBW_SHRT); \ | | 127| 21| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 21] | | ------------------ | | 128| 21| return (exitcode); \ | | 129| 21| } \ | | 130| 3.67k| } ------------------ | Branch (195:7): [True: 21, False: 0] ------------------ 196| 3.67k| break; 197| | 198| 2.32k| case RTCP_RR: ------------------ | Branch (198:5): [True: 2.32k, False: 4.04k] ------------------ 199| 2.32k| 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: 32, False: 2.29k] | Branch (199:26): [True: 9, False: 2.28k] ------------------ 200| 41| goto invallen; 201| 2.28k| RSW_REST(-1, out, "{\n \"ssrc\": %lu,\n", ------------------ | | 118| 2.28k| { \ | | 119| 2.28k| int rval; \ | | 120| 2.31k| for (;;) { \ | | 121| 2.31k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 202| 2.31k| (unsigned long)ntohl(r->r.rr.ssrc)); | | ------------------ | | 122| 2.31k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.31k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.28k, False: 28] | | ------------------ | | 123| 2.31k| break; \ | | 124| 2.31k| 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.28k| } ------------------ | Branch (201:7): [True: 28, False: 0] ------------------ 202| 2.28k| (unsigned long)ntohl(r->r.rr.ssrc)); 203| 2.28k| RSW_REST(-1, out, " \"type\": %lu,\n", (unsigned long)r->common.pt); ------------------ | | 118| 2.28k| { \ | | 119| 2.28k| int rval; \ | | 120| 2.32k| for (;;) { \ | | 121| 2.32k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.32k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.32k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.28k, False: 38] | | ------------------ | | 123| 2.32k| break; \ | | 124| 2.32k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 38|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 38] | | ------------------ | | 125| 38| return (exitcode); \ | | 126| 38| assert(rval == SBW_SHRT); \ | | 127| 38| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 38] | | ------------------ | | 128| 38| return (exitcode); \ | | 129| 38| } \ | | 130| 2.28k| } ------------------ | Branch (203:7): [True: 38, False: 0] ------------------ 204| 2.28k| if (r->common.count > 0) ------------------ | Branch (204:11): [True: 1.25k, False: 1.02k] ------------------ 205| 2.28k| RSW_REST(-1, out, " \"report_blocks\": [\n"); ------------------ | | 118| 1.25k| { \ | | 119| 1.25k| int rval; \ | | 120| 1.27k| for (;;) { \ | | 121| 1.27k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 1.27k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 1.27k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 1.25k, False: 19] | | ------------------ | | 123| 1.27k| break; \ | | 124| 1.27k| 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| 1.25k| } ------------------ | Branch (205:9): [True: 19, False: 0] ------------------ 206| 4.42k| for (i = 0; i < r->common.count; i++) { ------------------ | Branch (206:19): [True: 2.14k, False: 2.28k] ------------------ 207| 2.14k| if (i > 0) ------------------ | Branch (207:13): [True: 884, False: 1.25k] ------------------ 208| 2.14k| RSW_REST(-1, out, " ,\n"); ------------------ | | 118| 884| { \ | | 119| 884| int rval; \ | | 120| 900| for (;;) { \ | | 121| 900| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 900| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 900|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 884, False: 16] | | ------------------ | | 123| 900| break; \ | | 124| 900| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 16|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 16] | | ------------------ | | 125| 16| return (exitcode); \ | | 126| 16| assert(rval == SBW_SHRT); \ | | 127| 16| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 16] | | ------------------ | | 128| 16| return (exitcode); \ | | 129| 16| } \ | | 130| 884| } ------------------ | Branch (208:11): [True: 16, False: 0] ------------------ 209| 2.14k| 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| 2.14k| { \ | | 119| 2.14k| int rval; \ | | 120| 2.26k| for (;;) { \ | | 121| 2.26k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 210| 13.6k| (unsigned long)ntohl(r->r.rr.rr[i].ssrc), | | | | 211| 13.6k| (unsigned long)r->r.rr.rr[i].fraction, | | | | 212| 13.6k| (long)RTCP_GET_LOST(&r->r.rr.rr[i]), | | | | ------------------ | | | | | | 106| 2.26k|#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: 585, False: 1.68k] | | | | | | ------------------ | | | | ------------------ | | | | 213| 13.6k| (unsigned long)ntohl(r->r.rr.rr[i].last_seq), | | | | 214| 13.6k| (unsigned long)ntohl(r->r.rr.rr[i].jitter), | | | | 215| 13.6k| (unsigned long)ntohl(r->r.rr.rr[i].lsr), | | | | 216| 13.6k| (unsigned long)ntohl(r->r.rr.rr[i].dlsr)); | | ------------------ | | 122| 2.26k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.26k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.14k, False: 127] | | ------------------ | | 123| 2.26k| break; \ | | 124| 2.26k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 127|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 127] | | ------------------ | | 125| 127| return (exitcode); \ | | 126| 127| assert(rval == SBW_SHRT); \ | | 127| 127| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 127] | | ------------------ | | 128| 127| return (exitcode); \ | | 129| 127| } \ | | 130| 2.14k| } ------------------ | Branch (209:9): [True: 127, False: 0] ------------------ 210| 2.14k| (unsigned long)ntohl(r->r.rr.rr[i].ssrc), 211| 2.14k| (unsigned long)r->r.rr.rr[i].fraction, 212| 2.14k| (long)RTCP_GET_LOST(&r->r.rr.rr[i]), 213| 2.14k| (unsigned long)ntohl(r->r.rr.rr[i].last_seq), 214| 2.14k| (unsigned long)ntohl(r->r.rr.rr[i].jitter), 215| 2.14k| (unsigned long)ntohl(r->r.rr.rr[i].lsr), 216| 2.14k| (unsigned long)ntohl(r->r.rr.rr[i].dlsr)); 217| 2.14k| } 218| 2.28k| if (r->common.count > 0) ------------------ | Branch (218:11): [True: 1.25k, False: 1.02k] ------------------ 219| 2.28k| RSW_REST(-1, out, " ],\n"); ------------------ | | 118| 1.25k| { \ | | 119| 1.25k| int rval; \ | | 120| 1.28k| for (;;) { \ | | 121| 1.28k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 1.28k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 1.28k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 1.25k, False: 27] | | ------------------ | | 123| 1.28k| break; \ | | 124| 1.28k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 27|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 27] | | ------------------ | | 125| 27| return (exitcode); \ | | 126| 27| assert(rval == SBW_SHRT); \ | | 127| 27| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 27] | | ------------------ | | 128| 27| return (exitcode); \ | | 129| 27| } \ | | 130| 1.25k| } ------------------ | Branch (219:9): [True: 27, False: 0] ------------------ 220| 2.28k| RSW_REST(-1, out, " \"report_count\": %lu\n", (unsigned long)r->common.count); ------------------ | | 118| 2.28k| { \ | | 119| 2.28k| int rval; \ | | 120| 2.31k| for (;;) { \ | | 121| 2.31k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.31k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.31k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.28k, False: 29] | | ------------------ | | 123| 2.31k| break; \ | | 124| 2.31k| 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.28k| } ------------------ | Branch (220:7): [True: 29, False: 0] ------------------ 221| 2.28k| RSW_REST(-1, out, "}"); ------------------ | | 118| 2.28k| { \ | | 119| 2.28k| int rval; \ | | 120| 2.32k| for (;;) { \ | | 121| 2.32k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.32k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.32k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.28k, False: 40] | | ------------------ | | 123| 2.32k| break; \ | | 124| 2.32k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 40|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 40] | | ------------------ | | 125| 40| return (exitcode); \ | | 126| 40| assert(rval == SBW_SHRT); \ | | 127| 40| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 40] | | ------------------ | | 128| 40| return (exitcode); \ | | 129| 40| } \ | | 130| 2.28k| } ------------------ | Branch (221:7): [True: 40, False: 0] ------------------ 222| 2.28k| break; 223| | 224| 1| case RTCP_SDES: ------------------ | Branch (224:5): [True: 1, False: 6.36k] ------------------ 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| 1| break; 247| | 248| 0| case RTCP_BYE: ------------------ | Branch (248:5): [True: 0, False: 6.36k] ------------------ 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| 0| break; 264| | 265| | /* invalid type */ 266| 314| default: ------------------ | Branch (266:5): [True: 314, False: 6.05k] ------------------ 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| 314| break; 272| 6.36k| } 273| 6.27k| len -= bincr; 274| 6.27k| r = (const rtcp_t *)((const char *)r + bincr); 275| 6.27k| } 276| | 277| 281| return len; 278| | 279| 89|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| 89| return -1; 286| 375|} 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| 382|{ 35| 382| struct rtpp_sbuf *sbp; 36| | 37| 382| if (rtcp_dlen > MAX_RPKT_LEN) ------------------ | | 37| 382|#define MAX_RPKT_LEN 8192 ------------------ | Branch (37:9): [True: 0, False: 382] ------------------ 38| 0| return (0); 39| | 40| 382| sbp = rtpp_sbuf_ctor(512); 41| 382| assert (sbp != NULL); ------------------ | Branch (41:5): [True: 0, False: 382] | Branch (41:5): [True: 382, 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| 382| rtcp2json(sbp, rtcp_data, rtcp_dlen); 52| 382| rtpp_sbuf_dtor(sbp); 53| | 54| 382| return (0); 55| 382|} 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.9k|{ 43| 43.9k| va_list ap; 44| 43.9k| int rlen, len; 45| | 46| 43.9k| len = sbp->alen - RS_ULEN(sbp); ------------------ | | 40| 43.9k|#define RS_ULEN(sbp) ((int)((sbp)->cp - (sbp)->bp)) ------------------ 47| 43.9k| assert(len > 0); ------------------ | Branch (47:5): [True: 0, False: 43.9k] | Branch (47:5): [True: 43.9k, False: 0] ------------------ 48| 43.9k| va_start(ap, format); 49| 43.9k| rlen = vsnprintf(sbp->cp, len, format, ap); 50| 43.9k| va_end(ap); 51| 43.9k| if (rlen < 0) ------------------ | Branch (51:9): [True: 0, False: 43.9k] ------------------ 52| 0| return (SBW_ERR); ------------------ | | 37| 0|#define SBW_ERR (-1) ------------------ 53| 43.9k| if (rlen >= len) { ------------------ | Branch (53:9): [True: 709, False: 43.2k] ------------------ 54| 709| sbp->cp[0] = '\0'; 55| 709| return (SBW_SHRT); ------------------ | | 38| 709|#define SBW_SHRT (-2) ------------------ 56| 709| } 57| 43.2k| sbp->cp += rlen; 58| 43.2k| return (SBW_OK); ------------------ | | 36| 43.2k|#define SBW_OK (0) ------------------ 59| 43.9k|} rtpp_sbuf_ctor: 67| 382|{ 68| 382| struct rtpp_sbuf *sbp; 69| | 70| 382|#if !defined(RTPP_CHECK_LEAKS) 71| 382| sbp = malloc(sizeof(struct rtpp_sbuf)); 72| |#else 73| | sbp = rtpp_memdeb_malloc(sizeof(struct rtpp_sbuf), memdeb_p, mlp); 74| |#endif 75| 382| if (sbp == NULL) ------------------ | Branch (75:9): [True: 0, False: 382] ------------------ 76| 0| return (NULL); 77| 382| memset(sbp, '\0', sizeof(struct rtpp_sbuf)); 78| 382|#if !defined(RTPP_CHECK_LEAKS) 79| 382| sbp->bp = sbp->cp = malloc(ilen); 80| |#else 81| | sbp->bp = sbp->cp = rtpp_memdeb_malloc(ilen, memdeb_p, mlp); 82| |#endif 83| 382| if (sbp->bp == NULL) { ------------------ | Branch (83:9): [True: 0, False: 382] ------------------ 84| 0| free(sbp); 85| 0| return (NULL); 86| 0| } 87| 382| sbp->cp[0] = '\0'; 88| 382| sbp->alen = ilen; 89| 382| return(sbp); 90| 382|} rtpp_sbuf_dtor: 98| 382|{ 99| | 100| 382|#if !defined(RTPP_CHECK_LEAKS) 101| 382| free(sbp->bp); 102| 382| free(sbp); 103| |#else 104| | rtpp_memdeb_free(sbp->bp, memdeb_p, mlp); 105| | rtpp_memdeb_free(sbp, memdeb_p, mlp); 106| |#endif 107| 382|} rtpp_sbuf_extend: 115| 709|{ 116| 709| void *nbp, *ncp; 117| | 118| 709| assert(nlen > sbp->alen); ------------------ | Branch (118:5): [True: 0, False: 709] | Branch (118:5): [True: 709, False: 0] ------------------ 119| 709|#if !defined(RTPP_CHECK_LEAKS) 120| 709| nbp = realloc(sbp->bp, nlen); 121| |#else 122| | nbp = rtpp_memdeb_realloc(sbp->bp, nlen, memdeb_p, mlp); 123| |#endif 124| 709| if (nbp == NULL) ------------------ | Branch (124:9): [True: 0, False: 709] ------------------ 125| 0| return (-1); 126| 709| sbp->alen = nlen; 127| 709| if (sbp->bp != nbp) { ------------------ | Branch (127:9): [True: 336, False: 373] ------------------ 128| 336| ncp = nbp + RS_ULEN(sbp); ------------------ | | 40| 336|#define RS_ULEN(sbp) ((int)((sbp)->cp - (sbp)->bp)) ------------------ 129| 336| sbp->cp = ncp; 130| 336| sbp->bp = nbp; 131| 336| } 132| 709| return (0); 133| 709|}