rtcp2json: 136| 374|{ 137| 374| const rtcp_t *r; /* RTCP header */ 138| 374| int i; 139| |#if 0 140| | const char *cp; 141| |#endif 142| | 143| 374| if (len < sizeof(rtcp_common_t)) { ------------------ | Branch (143:7): [True: 2, False: 372] ------------------ 144| 2| return -1; 145| 2| } 146| 372| r = (rtcp_t *)buf; 147| | /* Backwards compatibility: VAT header. */ 148| 372| if (r->common.version != RTP_VERSION) { ------------------ | | 41| 372|#define RTP_VERSION 2 ------------------ | Branch (148:7): [True: 3, False: 369] ------------------ 149| |#if 0 150| | fprintf(out, "invalid version %d\n", r->common.version); 151| |#endif 152| 3| return -1; 153| 3| } 154| | 155| |#if 0 156| | fprintf(out, "\n"); 157| |#endif 158| 5.77k| while (len > 0) { ------------------ | Branch (158:10): [True: 5.49k, False: 283] ------------------ 159| 5.49k| if (len < sizeof(rtcp_common_t)) { ------------------ | Branch (159:9): [True: 3, False: 5.48k] ------------------ 160| 3| return -1; 161| 3| } 162| 5.48k| size_t bincr = sizeof(uint32_t) * (ntohs(r->common.length) + 1); 163| | 164| 5.48k| switch (r->common.pt) { 165| 3.21k| case RTCP_SR: ------------------ | Branch (165:5): [True: 3.21k, False: 2.27k] ------------------ 166| 3.21k| 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 (166:11): [True: 34, False: 3.17k] | Branch (166:26): [True: 10, False: 3.16k] ------------------ 167| 44| goto invallen; 168| 3.16k| RSW_REST(-1, out, "{\n \"ssrc\": %lu,\n", ------------------ | | 117| 3.16k| { \ | | 118| 3.16k| int rval; \ | | 119| 3.20k| for (;;) { \ | | 120| 3.20k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 169| 3.20k| (unsigned long)ntohl(r->r.sr.ssrc)); | | ------------------ | | 121| 3.20k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 3.20k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 3.16k, False: 41] | | ------------------ | | 122| 3.20k| break; \ | | 123| 3.20k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 41|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 41] | | ------------------ | | 124| 41| return (exitcode); \ | | 125| 41| assert(rval == SBW_SHRT); \ | | 126| 41| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 41] | | ------------------ | | 127| 41| return (exitcode); \ | | 128| 41| } \ | | 129| 3.16k| } ------------------ 169| 3.16k| (unsigned long)ntohl(r->r.sr.ssrc)); 170| 3.16k| 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", ------------------ | | 117| 3.16k| { \ | | 118| 3.16k| int rval; \ | | 119| 3.24k| for (;;) { \ | | 120| 3.24k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 171| 16.2k| (unsigned long)ntohl(r->r.sr.ntp_sec), | | | | 172| 16.2k| (unsigned long)ntohl(r->r.sr.ntp_frac), | | | | 173| 16.2k| (unsigned long)ntohl(r->r.sr.rtp_ts), | | | | 174| 16.2k| (unsigned long)ntohl(r->r.sr.psent), | | | | 175| 16.2k| (unsigned long)ntohl(r->r.sr.osent)); | | ------------------ | | 121| 3.24k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 3.24k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 3.16k, False: 74] | | ------------------ | | 122| 3.24k| break; \ | | 123| 3.24k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 74|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 74] | | ------------------ | | 124| 74| return (exitcode); \ | | 125| 74| assert(rval == SBW_SHRT); \ | | 126| 74| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 74] | | ------------------ | | 127| 74| return (exitcode); \ | | 128| 74| } \ | | 129| 3.16k| } ------------------ 171| 3.16k| (unsigned long)ntohl(r->r.sr.ntp_sec), 172| 3.16k| (unsigned long)ntohl(r->r.sr.ntp_frac), 173| 3.16k| (unsigned long)ntohl(r->r.sr.rtp_ts), 174| 3.16k| (unsigned long)ntohl(r->r.sr.psent), 175| 3.16k| (unsigned long)ntohl(r->r.sr.osent)); 176| 3.16k| RSW_REST(-1, out, " \"type\": %lu,\n", (unsigned long)r->common.pt); ------------------ | | 117| 3.16k| { \ | | 118| 3.16k| int rval; \ | | 119| 3.18k| for (;;) { \ | | 120| 3.18k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 3.18k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 3.18k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 3.16k, False: 18] | | ------------------ | | 122| 3.18k| break; \ | | 123| 3.18k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 18|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 18] | | ------------------ | | 124| 18| return (exitcode); \ | | 125| 18| assert(rval == SBW_SHRT); \ | | 126| 18| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 18] | | ------------------ | | 127| 18| return (exitcode); \ | | 128| 18| } \ | | 129| 3.16k| } ------------------ 177| 3.16k| if (r->common.count > 0) ------------------ | Branch (177:11): [True: 2.40k, False: 763] ------------------ 178| 3.16k| RSW_REST(-1, out, " \"report_blocks\": [\n"); ------------------ | | 117| 2.40k| { \ | | 118| 2.40k| int rval; \ | | 119| 2.43k| for (;;) { \ | | 120| 2.43k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 2.43k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.43k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.40k, False: 28] | | ------------------ | | 122| 2.43k| break; \ | | 123| 2.43k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 28|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 28] | | ------------------ | | 124| 28| return (exitcode); \ | | 125| 28| assert(rval == SBW_SHRT); \ | | 126| 28| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 28] | | ------------------ | | 127| 28| return (exitcode); \ | | 128| 28| } \ | | 129| 2.40k| } ------------------ 179| 6.50k| for (i = 0; i < r->common.count; i++) { ------------------ | Branch (179:19): [True: 3.34k, False: 3.16k] ------------------ 180| 3.34k| if (i > 0) ------------------ | Branch (180:13): [True: 938, False: 2.40k] ------------------ 181| 3.34k| RSW_REST(-1, out, " ,\n"); ------------------ | | 117| 938| { \ | | 118| 938| int rval; \ | | 119| 956| for (;;) { \ | | 120| 956| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 956| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 956|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 938, False: 18] | | ------------------ | | 122| 956| break; \ | | 123| 956| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 18|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 18] | | ------------------ | | 124| 18| return (exitcode); \ | | 125| 18| assert(rval == SBW_SHRT); \ | | 126| 18| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 18] | | ------------------ | | 127| 18| return (exitcode); \ | | 128| 18| } \ | | 129| 938| } ------------------ 182| 3.34k| 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", ------------------ | | 117| 3.34k| { \ | | 118| 3.34k| int rval; \ | | 119| 3.46k| for (;;) { \ | | 120| 3.46k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 183| 20.8k| (unsigned long)ntohl(r->r.sr.rr[i].ssrc), | | | | 184| 20.8k| (unsigned long)r->r.sr.rr[i].fraction, | | | | 185| 20.8k| (long)RTCP_GET_LOST(&r->r.sr.rr[i]), | | | | ------------------ | | | | | | 106| 3.46k|#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: 812, False: 2.65k] | | | | | | ------------------ | | | | ------------------ | | | | 186| 20.8k| (unsigned long)ntohl(r->r.sr.rr[i].last_seq), | | | | 187| 20.8k| (unsigned long)ntohl(r->r.sr.rr[i].jitter), | | | | 188| 20.8k| (unsigned long)ntohl(r->r.sr.rr[i].lsr), | | | | 189| 20.8k| (unsigned long)ntohl(r->r.sr.rr[i].dlsr)); | | ------------------ | | 121| 3.46k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 3.46k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 3.34k, False: 126] | | ------------------ | | 122| 3.46k| break; \ | | 123| 3.46k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 126|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 126] | | ------------------ | | 124| 126| return (exitcode); \ | | 125| 126| assert(rval == SBW_SHRT); \ | | 126| 126| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 126] | | ------------------ | | 127| 126| return (exitcode); \ | | 128| 126| } \ | | 129| 3.34k| } ------------------ 183| 3.34k| (unsigned long)ntohl(r->r.sr.rr[i].ssrc), 184| 3.34k| (unsigned long)r->r.sr.rr[i].fraction, 185| 3.34k| (long)RTCP_GET_LOST(&r->r.sr.rr[i]), 186| 3.34k| (unsigned long)ntohl(r->r.sr.rr[i].last_seq), 187| 3.34k| (unsigned long)ntohl(r->r.sr.rr[i].jitter), 188| 3.34k| (unsigned long)ntohl(r->r.sr.rr[i].lsr), 189| 3.34k| (unsigned long)ntohl(r->r.sr.rr[i].dlsr)); 190| 3.34k| } 191| 3.16k| if (r->common.count > 0) ------------------ | Branch (191:11): [True: 2.40k, False: 763] ------------------ 192| 3.16k| RSW_REST(-1, out, " ],\n"); ------------------ | | 117| 2.40k| { \ | | 118| 2.40k| int rval; \ | | 119| 2.41k| for (;;) { \ | | 120| 2.41k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 2.41k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.41k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.40k, False: 12] | | ------------------ | | 122| 2.41k| break; \ | | 123| 2.41k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 12|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 12] | | ------------------ | | 124| 12| return (exitcode); \ | | 125| 12| assert(rval == SBW_SHRT); \ | | 126| 12| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 12] | | ------------------ | | 127| 12| return (exitcode); \ | | 128| 12| } \ | | 129| 2.40k| } ------------------ 193| 3.16k| RSW_REST(-1, out, " \"report_count\": %lu\n", (unsigned long)r->common.count); ------------------ | | 117| 3.16k| { \ | | 118| 3.16k| int rval; \ | | 119| 3.20k| for (;;) { \ | | 120| 3.20k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 3.20k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 3.20k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 3.16k, False: 43] | | ------------------ | | 122| 3.20k| break; \ | | 123| 3.20k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 43|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 43] | | ------------------ | | 124| 43| return (exitcode); \ | | 125| 43| assert(rval == SBW_SHRT); \ | | 126| 43| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 43] | | ------------------ | | 127| 43| return (exitcode); \ | | 128| 43| } \ | | 129| 3.16k| } ------------------ 194| 3.16k| RSW_REST(-1, out, "}"); ------------------ | | 117| 3.16k| { \ | | 118| 3.16k| int rval; \ | | 119| 3.18k| for (;;) { \ | | 120| 3.18k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 3.18k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 3.18k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 3.16k, False: 20] | | ------------------ | | 122| 3.18k| break; \ | | 123| 3.18k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 20|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 20] | | ------------------ | | 124| 20| return (exitcode); \ | | 125| 20| assert(rval == SBW_SHRT); \ | | 126| 20| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 20] | | ------------------ | | 127| 20| return (exitcode); \ | | 128| 20| } \ | | 129| 3.16k| } ------------------ 195| 3.16k| break; 196| | 197| 2.00k| case RTCP_RR: ------------------ | Branch (197:5): [True: 2.00k, False: 3.48k] ------------------ 198| 2.00k| 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 (198:11): [True: 31, False: 1.97k] | Branch (198:26): [True: 8, False: 1.96k] ------------------ 199| 39| goto invallen; 200| 1.96k| RSW_REST(-1, out, "{\n \"ssrc\": %lu,\n", ------------------ | | 117| 1.96k| { \ | | 118| 1.96k| int rval; \ | | 119| 2.00k| for (;;) { \ | | 120| 2.00k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 201| 2.00k| (unsigned long)ntohl(r->r.rr.ssrc)); | | ------------------ | | 121| 2.00k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.00k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 1.96k, False: 40] | | ------------------ | | 122| 2.00k| break; \ | | 123| 2.00k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 40|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 40] | | ------------------ | | 124| 40| return (exitcode); \ | | 125| 40| assert(rval == SBW_SHRT); \ | | 126| 40| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 40] | | ------------------ | | 127| 40| return (exitcode); \ | | 128| 40| } \ | | 129| 1.96k| } ------------------ 201| 1.96k| (unsigned long)ntohl(r->r.rr.ssrc)); 202| 1.96k| RSW_REST(-1, out, " \"type\": %lu,\n", (unsigned long)r->common.pt); ------------------ | | 117| 1.96k| { \ | | 118| 1.96k| int rval; \ | | 119| 1.98k| for (;;) { \ | | 120| 1.98k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 1.98k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 1.98k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 1.96k, False: 23] | | ------------------ | | 122| 1.98k| break; \ | | 123| 1.98k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 23|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 23] | | ------------------ | | 124| 23| return (exitcode); \ | | 125| 23| assert(rval == SBW_SHRT); \ | | 126| 23| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 23] | | ------------------ | | 127| 23| return (exitcode); \ | | 128| 23| } \ | | 129| 1.96k| } ------------------ 203| 1.96k| if (r->common.count > 0) ------------------ | Branch (203:11): [True: 1.13k, False: 832] ------------------ 204| 1.96k| RSW_REST(-1, out, " \"report_blocks\": [\n"); ------------------ | | 117| 1.13k| { \ | | 118| 1.13k| int rval; \ | | 119| 1.15k| for (;;) { \ | | 120| 1.15k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 1.15k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 1.15k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 1.13k, False: 22] | | ------------------ | | 122| 1.15k| break; \ | | 123| 1.15k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 22|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 22] | | ------------------ | | 124| 22| return (exitcode); \ | | 125| 22| assert(rval == SBW_SHRT); \ | | 126| 22| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 22] | | ------------------ | | 127| 22| return (exitcode); \ | | 128| 22| } \ | | 129| 1.13k| } ------------------ 205| 4.05k| for (i = 0; i < r->common.count; i++) { ------------------ | Branch (205:19): [True: 2.09k, False: 1.96k] ------------------ 206| 2.09k| if (i > 0) ------------------ | Branch (206:13): [True: 958, False: 1.13k] ------------------ 207| 2.09k| RSW_REST(-1, out, " ,\n"); ------------------ | | 117| 958| { \ | | 118| 958| int rval; \ | | 119| 976| for (;;) { \ | | 120| 976| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 976| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 976|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 958, False: 18] | | ------------------ | | 122| 976| break; \ | | 123| 976| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 18|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 18] | | ------------------ | | 124| 18| return (exitcode); \ | | 125| 18| assert(rval == SBW_SHRT); \ | | 126| 18| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 18] | | ------------------ | | 127| 18| return (exitcode); \ | | 128| 18| } \ | | 129| 958| } ------------------ 208| 2.09k| 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", ------------------ | | 117| 2.09k| { \ | | 118| 2.09k| int rval; \ | | 119| 2.22k| for (;;) { \ | | 120| 2.22k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 209| 13.3k| (unsigned long)ntohl(r->r.rr.rr[i].ssrc), | | | | 210| 13.3k| (unsigned long)r->r.rr.rr[i].fraction, | | | | 211| 13.3k| (long)RTCP_GET_LOST(&r->r.rr.rr[i]), | | | | ------------------ | | | | | | 106| 2.22k|#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: 532, False: 1.68k] | | | | | | ------------------ | | | | ------------------ | | | | 212| 13.3k| (unsigned long)ntohl(r->r.rr.rr[i].last_seq), | | | | 213| 13.3k| (unsigned long)ntohl(r->r.rr.rr[i].jitter), | | | | 214| 13.3k| (unsigned long)ntohl(r->r.rr.rr[i].lsr), | | | | 215| 13.3k| (unsigned long)ntohl(r->r.rr.rr[i].dlsr)); | | ------------------ | | 121| 2.22k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.22k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.09k, False: 131] | | ------------------ | | 122| 2.22k| break; \ | | 123| 2.22k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 131|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 131] | | ------------------ | | 124| 131| return (exitcode); \ | | 125| 131| assert(rval == SBW_SHRT); \ | | 126| 131| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 131] | | ------------------ | | 127| 131| return (exitcode); \ | | 128| 131| } \ | | 129| 2.09k| } ------------------ 209| 2.09k| (unsigned long)ntohl(r->r.rr.rr[i].ssrc), 210| 2.09k| (unsigned long)r->r.rr.rr[i].fraction, 211| 2.09k| (long)RTCP_GET_LOST(&r->r.rr.rr[i]), 212| 2.09k| (unsigned long)ntohl(r->r.rr.rr[i].last_seq), 213| 2.09k| (unsigned long)ntohl(r->r.rr.rr[i].jitter), 214| 2.09k| (unsigned long)ntohl(r->r.rr.rr[i].lsr), 215| 2.09k| (unsigned long)ntohl(r->r.rr.rr[i].dlsr)); 216| 2.09k| } 217| 1.96k| if (r->common.count > 0) ------------------ | Branch (217:11): [True: 1.13k, False: 832] ------------------ 218| 1.96k| RSW_REST(-1, out, " ],\n"); ------------------ | | 117| 1.13k| { \ | | 118| 1.13k| int rval; \ | | 119| 1.15k| for (;;) { \ | | 120| 1.15k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 1.15k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 1.15k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 1.13k, False: 21] | | ------------------ | | 122| 1.15k| break; \ | | 123| 1.15k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 21|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 21] | | ------------------ | | 124| 21| return (exitcode); \ | | 125| 21| assert(rval == SBW_SHRT); \ | | 126| 21| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 21] | | ------------------ | | 127| 21| return (exitcode); \ | | 128| 21| } \ | | 129| 1.13k| } ------------------ 219| 1.96k| RSW_REST(-1, out, " \"report_count\": %lu\n", (unsigned long)r->common.count); ------------------ | | 117| 1.96k| { \ | | 118| 1.96k| int rval; \ | | 119| 1.99k| for (;;) { \ | | 120| 1.99k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 1.99k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 1.99k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 1.96k, False: 30] | | ------------------ | | 122| 1.99k| break; \ | | 123| 1.99k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 30|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 30] | | ------------------ | | 124| 30| return (exitcode); \ | | 125| 30| assert(rval == SBW_SHRT); \ | | 126| 30| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 30] | | ------------------ | | 127| 30| return (exitcode); \ | | 128| 30| } \ | | 129| 1.96k| } ------------------ 220| 1.96k| RSW_REST(-1, out, "}"); ------------------ | | 117| 1.96k| { \ | | 118| 1.96k| int rval; \ | | 119| 1.98k| for (;;) { \ | | 120| 1.98k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 1.98k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 1.98k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 1.96k, False: 21] | | ------------------ | | 122| 1.98k| break; \ | | 123| 1.98k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 21|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 21] | | ------------------ | | 124| 21| return (exitcode); \ | | 125| 21| assert(rval == SBW_SHRT); \ | | 126| 21| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 21] | | ------------------ | | 127| 21| return (exitcode); \ | | 128| 21| } \ | | 129| 1.96k| } ------------------ 221| 1.96k| break; 222| | 223| 0| case RTCP_SDES: ------------------ | Branch (223:5): [True: 0, False: 5.48k] ------------------ 224| |#if 0 225| | fprintf(out, " (SDES p=%d count=%d len=%d\n", 226| | r->common.p, r->common.count, ntohs(r->common.length)); 227| | cp = (const char *)&r->r.sdes; 228| | for (i = 0; i < r->common.count; i++) { 229| | int remaining = (ntohs(r->common.length) << 2) - 230| | (cp - (const char *)&r->r.sdes); 231| | fprintf(out, " (src=0x%lx ", 232| | (unsigned long)ntohl(((struct rtcp_sdes *)cp)->src)); 233| | if (remaining > 0) { 234| | cp = rtp_read_sdes(out, cp, 235| | (ntohs(r->common.length) << 2) - (cp - (const char *)&r->r.sdes)); 236| | if (!cp) return -1; 237| | } else { 238| | fprintf(stderr, "Missing at least %d bytes.\n", -remaining); 239| | return -1; 240| | } 241| | fprintf(out, ")\n"); 242| | } 243| | fprintf(out, " )\n"); 244| |#endif 245| 0| break; 246| | 247| 1| case RTCP_BYE: ------------------ | Branch (247:5): [True: 1, False: 5.48k] ------------------ 248| |#if 0 249| | fprintf(out, " (BYE p=%d count=%d len=%d\n", 250| | r->common.p, r->common.count, ntohs(r->common.length)); 251| | for (i = 0; i < r->common.count; i++) { 252| | fprintf(out, " (ssrc[%d]=0x%0lx ", i, 253| | (unsigned long)ntohl(r->r.bye.src[i])); 254| | } 255| | fprintf(out, ")\n"); 256| | if (ntohs(r->common.length) > r->common.count) { 257| | cp = (const char *)&r->r.bye.src[r->common.count]; 258| | fprintf(out, "reason=\"%*.*s\"", *cp, *cp, cp+1); 259| | } 260| | fprintf(out, " )\n"); 261| |#endif 262| 1| break; 263| | 264| | /* invalid type */ 265| 275| default: ------------------ | Branch (265:5): [True: 275, False: 5.21k] ------------------ 266| |#if 0 267| | fprintf(out, "(? pt=%d src=0x%lx)\n", r->common.pt, 268| | (unsigned long)ntohl(r->r.sdes.src)); 269| |#endif 270| 275| break; 271| 5.48k| } 272| 5.40k| len -= bincr; 273| 5.40k| r = (const rtcp_t *)((const char *)r + bincr); 274| 5.40k| } 275| | 276| 283| return len; 277| | 278| 83|invallen: 279| | /* something wrong with packet format */ 280| |#if 0 281| | fprintf(out, "Illegal RTCP packet length %d words.\n", 282| | ntohs(r->common.length)); 283| |#endif 284| 83| return -1; 285| 369|} rtpp_sbuf_write: 43| 38.7k|{ 44| 38.7k| va_list ap; 45| 38.7k| int rlen, len; 46| | 47| 38.7k| len = sbp->alen - RS_ULEN(sbp); ------------------ | | 38| 38.7k|#define RS_ULEN(sbp) ((int)((sbp)->cp - (sbp)->bp)) ------------------ 48| 38.7k| assert(len > 0); 49| 38.7k| va_start(ap, format); 50| 38.7k| rlen = vsnprintf(sbp->cp, len, format, ap); 51| 38.7k| va_end(ap); 52| 38.7k| if (rlen < 0) ------------------ | Branch (52:9): [True: 0, False: 38.7k] ------------------ 53| 0| return (SBW_ERR); ------------------ | | 35| 0|#define SBW_ERR (-1) ------------------ 54| 38.7k| if (rlen >= len) { ------------------ | Branch (54:9): [True: 686, False: 38.0k] ------------------ 55| 686| sbp->cp[0] = '\0'; 56| 686| return (SBW_SHRT); ------------------ | | 36| 686|#define SBW_SHRT (-2) ------------------ 57| 686| } 58| 38.0k| sbp->cp += rlen; 59| 38.0k| return (SBW_OK); ------------------ | | 34| 38.0k|#define SBW_OK (0) ------------------ 60| 38.7k|} rtpp_sbuf_ctor: 64| 374|{ 65| 374| struct rtpp_sbuf *sbp; 66| | 67| 374| sbp = malloc(sizeof(struct rtpp_sbuf)); 68| 374| if (sbp == NULL) ------------------ | Branch (68:9): [True: 0, False: 374] ------------------ 69| 0| return (NULL); 70| 374| memset(sbp, '\0', sizeof(struct rtpp_sbuf)); 71| 374| sbp->bp = sbp->cp = malloc(ilen); 72| 374| if (sbp->bp == NULL) { ------------------ | Branch (72:9): [True: 0, False: 374] ------------------ 73| 0| free(sbp); 74| 0| return (NULL); 75| 0| } 76| 374| sbp->cp[0] = '\0'; 77| 374| sbp->alen = ilen; 78| 374| return(sbp); 79| 374|} rtpp_sbuf_dtor: 83| 374|{ 84| | 85| 374| free(sbp->bp); 86| 374| free(sbp); 87| 374|} rtpp_sbuf_extend: 91| 686|{ 92| 686| void *nbp, *ncp; 93| | 94| 686| assert(nlen > sbp->alen); 95| 686| nbp = realloc(sbp->bp, nlen); 96| 686| if (nbp == NULL) ------------------ | Branch (96:9): [True: 0, False: 686] ------------------ 97| 0| return (-1); 98| 686| sbp->alen = nlen; 99| 686| if (sbp->bp != nbp) { ------------------ | Branch (99:9): [True: 345, False: 341] ------------------ 100| 345| ncp = nbp + RS_ULEN(sbp); ------------------ | | 38| 345|#define RS_ULEN(sbp) ((int)((sbp)->cp - (sbp)->bp)) ------------------ 101| 345| sbp->cp = ncp; 102| 345| sbp->bp = nbp; 103| 345| } 104| 686| return (0); 105| 686|} fuzz_rtcp_parser_init: 17| 2|{ 18| 2| struct rtpp_minfo *mip; 19| | 20| 2| mip = rtpp_static_modules_lookup("acct_rtcp_hep"); 21| 2| assert(mip != NULL); 22| 2| mip->_malloc = &malloc; 23| 2| mip->_realloc = &realloc; 24| 2| mip->_free = &free; 25| 2|} LLVMFuzzerTestOneInput: 29| 383|{ 30| 383| struct rtpp_sbuf *sbp; 31| | 32| 383| if (rtcp_dlen > MAX_RPKT_LEN) ------------------ | | 38| 383|#define MAX_RPKT_LEN 8192 ------------------ | Branch (32:9): [True: 9, False: 374] ------------------ 33| 9| return (0); 34| | 35| 374| sbp = rtpp_sbuf_ctor(512); 36| 374| assert (sbp != NULL); 37| |#if 0 38| | for (size_t i = 0; i < rtcp_dlen; i++) { 39| | char bf[3]; 40| | sprintf(bf, "%.2x", rtcp_data[i]); 41| | write(STDERR_FILENO, bf, 2); 42| | } 43| | write(STDERR_FILENO, "\n", 1); 44| | fsync(STDERR_FILENO); 45| |#endif 46| 374| rtcp2json(sbp, rtcp_data, rtcp_dlen); 47| 374| rtpp_sbuf_dtor(sbp); 48| | 49| 374| return (0); 50| 374|} rtpp_static_modules_lookup: 46| 2|{ 47| | 48| 4| for (int i = 0; rtpp_modules.all[i] != NULL; i++) { ------------------ | Branch (48:21): [True: 4, False: 0] ------------------ 49| 4| if (strcmp(rtpp_modules.all[i]->descr.name, name) == 0) { ------------------ | Branch (49:13): [True: 2, False: 2] ------------------ 50| 2| return (rtpp_modules.all[i]); 51| 2| } 52| 4| } 53| 0| return (NULL); 54| 2|}