rtcp2json: 136| 375|{ 137| 375| const rtcp_t *r; /* RTCP header */ 138| 375| int i; 139| |#if 0 140| | const char *cp; 141| |#endif 142| | 143| 375| if (len < sizeof(rtcp_common_t)) { ------------------ | Branch (143:7): [True: 2, False: 373] ------------------ 144| 2| return -1; 145| 2| } 146| 373| r = (rtcp_t *)buf; 147| | /* Backwards compatibility: VAT header. */ 148| 373| if (r->common.version != RTP_VERSION) { ------------------ | | 41| 373|#define RTP_VERSION 2 ------------------ | Branch (148:7): [True: 5, False: 368] ------------------ 149| |#if 0 150| | fprintf(out, "invalid version %d\n", r->common.version); 151| |#endif 152| 5| return -1; 153| 5| } 154| | 155| |#if 0 156| | fprintf(out, "\n"); 157| |#endif 158| 6.49k| while (len > 0) { ------------------ | Branch (158:10): [True: 6.21k, False: 279] ------------------ 159| 6.21k| if (len < sizeof(rtcp_common_t)) { ------------------ | Branch (159:9): [True: 4, False: 6.21k] ------------------ 160| 4| return -1; 161| 4| } 162| 6.21k| size_t bincr = sizeof(uint32_t) * (ntohs(r->common.length) + 1); 163| | 164| 6.21k| switch (r->common.pt) { 165| 2.76k| case RTCP_SR: ------------------ | Branch (165:5): [True: 2.76k, False: 3.45k] ------------------ 166| 2.76k| 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: 36, False: 2.72k] | Branch (166:26): [True: 10, False: 2.71k] ------------------ 167| 46| goto invallen; 168| 2.71k| RSW_REST(-1, out, "{\n \"ssrc\": %lu,\n", ------------------ | | 117| 2.71k| { \ | | 118| 2.71k| int rval; \ | | 119| 2.73k| for (;;) { \ | | 120| 2.73k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 169| 2.73k| (unsigned long)ntohl(r->r.sr.ssrc)); | | ------------------ | | 121| 2.73k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.73k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.71k, False: 21] | | ------------------ | | 122| 2.73k| break; \ | | 123| 2.73k| 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| 2.71k| } ------------------ 169| 2.71k| (unsigned long)ntohl(r->r.sr.ssrc)); 170| 2.71k| 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| 2.71k| { \ | | 118| 2.71k| int rval; \ | | 119| 2.78k| for (;;) { \ | | 120| 2.78k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 171| 13.9k| (unsigned long)ntohl(r->r.sr.ntp_sec), | | | | 172| 13.9k| (unsigned long)ntohl(r->r.sr.ntp_frac), | | | | 173| 13.9k| (unsigned long)ntohl(r->r.sr.rtp_ts), | | | | 174| 13.9k| (unsigned long)ntohl(r->r.sr.psent), | | | | 175| 13.9k| (unsigned long)ntohl(r->r.sr.osent)); | | ------------------ | | 121| 2.78k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.78k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.71k, False: 68] | | ------------------ | | 122| 2.78k| break; \ | | 123| 2.78k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 68|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 68] | | ------------------ | | 124| 68| return (exitcode); \ | | 125| 68| assert(rval == SBW_SHRT); \ | | 126| 68| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 68] | | ------------------ | | 127| 68| return (exitcode); \ | | 128| 68| } \ | | 129| 2.71k| } ------------------ 171| 2.71k| (unsigned long)ntohl(r->r.sr.ntp_sec), 172| 2.71k| (unsigned long)ntohl(r->r.sr.ntp_frac), 173| 2.71k| (unsigned long)ntohl(r->r.sr.rtp_ts), 174| 2.71k| (unsigned long)ntohl(r->r.sr.psent), 175| 2.71k| (unsigned long)ntohl(r->r.sr.osent)); 176| 2.71k| RSW_REST(-1, out, " \"type\": %lu,\n", (unsigned long)r->common.pt); ------------------ | | 117| 2.71k| { \ | | 118| 2.71k| int rval; \ | | 119| 2.73k| for (;;) { \ | | 120| 2.73k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 2.73k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.73k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.71k, False: 19] | | ------------------ | | 122| 2.73k| break; \ | | 123| 2.73k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 19|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 19] | | ------------------ | | 124| 19| return (exitcode); \ | | 125| 19| assert(rval == SBW_SHRT); \ | | 126| 19| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 19] | | ------------------ | | 127| 19| return (exitcode); \ | | 128| 19| } \ | | 129| 2.71k| } ------------------ 177| 2.71k| if (r->common.count > 0) ------------------ | Branch (177:11): [True: 1.54k, False: 1.17k] ------------------ 178| 2.71k| RSW_REST(-1, out, " \"report_blocks\": [\n"); ------------------ | | 117| 1.54k| { \ | | 118| 1.54k| int rval; \ | | 119| 1.55k| for (;;) { \ | | 120| 1.55k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 1.55k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 1.55k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 1.54k, False: 10] | | ------------------ | | 122| 1.55k| break; \ | | 123| 1.55k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 10|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 10] | | ------------------ | | 124| 10| return (exitcode); \ | | 125| 10| assert(rval == SBW_SHRT); \ | | 126| 10| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 10] | | ------------------ | | 127| 10| return (exitcode); \ | | 128| 10| } \ | | 129| 1.54k| } ------------------ 179| 5.02k| for (i = 0; i < r->common.count; i++) { ------------------ | Branch (179:19): [True: 2.31k, False: 2.71k] ------------------ 180| 2.31k| if (i > 0) ------------------ | Branch (180:13): [True: 765, False: 1.54k] ------------------ 181| 2.31k| RSW_REST(-1, out, " ,\n"); ------------------ | | 117| 765| { \ | | 118| 765| int rval; \ | | 119| 785| for (;;) { \ | | 120| 785| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 785| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 785|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 765, False: 20] | | ------------------ | | 122| 785| break; \ | | 123| 785| 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| 765| } ------------------ 182| 2.31k| 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.31k| { \ | | 118| 2.31k| int rval; \ | | 119| 2.42k| for (;;) { \ | | 120| 2.42k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 183| 14.5k| (unsigned long)ntohl(r->r.sr.rr[i].ssrc), | | | | 184| 14.5k| (unsigned long)r->r.sr.rr[i].fraction, | | | | 185| 14.5k| (long)RTCP_GET_LOST(&r->r.sr.rr[i]), | | | | ------------------ | | | | | | 106| 2.42k|#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: 1.04k, False: 1.38k] | | | | | | ------------------ | | | | ------------------ | | | | 186| 14.5k| (unsigned long)ntohl(r->r.sr.rr[i].last_seq), | | | | 187| 14.5k| (unsigned long)ntohl(r->r.sr.rr[i].jitter), | | | | 188| 14.5k| (unsigned long)ntohl(r->r.sr.rr[i].lsr), | | | | 189| 14.5k| (unsigned long)ntohl(r->r.sr.rr[i].dlsr)); | | ------------------ | | 121| 2.42k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.42k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.31k, False: 119] | | ------------------ | | 122| 2.42k| break; \ | | 123| 2.42k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 119|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 119] | | ------------------ | | 124| 119| return (exitcode); \ | | 125| 119| assert(rval == SBW_SHRT); \ | | 126| 119| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 119] | | ------------------ | | 127| 119| return (exitcode); \ | | 128| 119| } \ | | 129| 2.31k| } ------------------ 183| 2.31k| (unsigned long)ntohl(r->r.sr.rr[i].ssrc), 184| 2.31k| (unsigned long)r->r.sr.rr[i].fraction, 185| 2.31k| (long)RTCP_GET_LOST(&r->r.sr.rr[i]), 186| 2.31k| (unsigned long)ntohl(r->r.sr.rr[i].last_seq), 187| 2.31k| (unsigned long)ntohl(r->r.sr.rr[i].jitter), 188| 2.31k| (unsigned long)ntohl(r->r.sr.rr[i].lsr), 189| 2.31k| (unsigned long)ntohl(r->r.sr.rr[i].dlsr)); 190| 2.31k| } 191| 2.71k| if (r->common.count > 0) ------------------ | Branch (191:11): [True: 1.54k, False: 1.17k] ------------------ 192| 2.71k| RSW_REST(-1, out, " ],\n"); ------------------ | | 117| 1.54k| { \ | | 118| 1.54k| int rval; \ | | 119| 1.55k| for (;;) { \ | | 120| 1.55k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 1.55k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 1.55k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 1.54k, False: 10] | | ------------------ | | 122| 1.55k| break; \ | | 123| 1.55k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 10|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 10] | | ------------------ | | 124| 10| return (exitcode); \ | | 125| 10| assert(rval == SBW_SHRT); \ | | 126| 10| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 10] | | ------------------ | | 127| 10| return (exitcode); \ | | 128| 10| } \ | | 129| 1.54k| } ------------------ 193| 2.71k| RSW_REST(-1, out, " \"report_count\": %lu\n", (unsigned long)r->common.count); ------------------ | | 117| 2.71k| { \ | | 118| 2.71k| int rval; \ | | 119| 2.74k| for (;;) { \ | | 120| 2.74k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 2.74k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.74k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.71k, False: 29] | | ------------------ | | 122| 2.74k| break; \ | | 123| 2.74k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 29|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 29] | | ------------------ | | 124| 29| return (exitcode); \ | | 125| 29| assert(rval == SBW_SHRT); \ | | 126| 29| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 29] | | ------------------ | | 127| 29| return (exitcode); \ | | 128| 29| } \ | | 129| 2.71k| } ------------------ 194| 2.71k| RSW_REST(-1, out, "}"); ------------------ | | 117| 2.71k| { \ | | 118| 2.71k| int rval; \ | | 119| 2.74k| for (;;) { \ | | 120| 2.74k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 2.74k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.74k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.71k, False: 24] | | ------------------ | | 122| 2.74k| break; \ | | 123| 2.74k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 24|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 24] | | ------------------ | | 124| 24| return (exitcode); \ | | 125| 24| assert(rval == SBW_SHRT); \ | | 126| 24| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 24] | | ------------------ | | 127| 24| return (exitcode); \ | | 128| 24| } \ | | 129| 2.71k| } ------------------ 195| 2.71k| break; 196| | 197| 3.12k| case RTCP_RR: ------------------ | Branch (197:5): [True: 3.12k, False: 3.09k] ------------------ 198| 3.12k| 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: 3.09k] | Branch (198:26): [True: 8, False: 3.08k] ------------------ 199| 39| goto invallen; 200| 3.08k| RSW_REST(-1, out, "{\n \"ssrc\": %lu,\n", ------------------ | | 117| 3.08k| { \ | | 118| 3.08k| int rval; \ | | 119| 3.11k| for (;;) { \ | | 120| 3.11k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 201| 3.11k| (unsigned long)ntohl(r->r.rr.ssrc)); | | ------------------ | | 121| 3.11k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 3.11k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 3.08k, False: 32] | | ------------------ | | 122| 3.11k| break; \ | | 123| 3.11k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 32|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 32] | | ------------------ | | 124| 32| return (exitcode); \ | | 125| 32| assert(rval == SBW_SHRT); \ | | 126| 32| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 32] | | ------------------ | | 127| 32| return (exitcode); \ | | 128| 32| } \ | | 129| 3.08k| } ------------------ 201| 3.08k| (unsigned long)ntohl(r->r.rr.ssrc)); 202| 3.08k| RSW_REST(-1, out, " \"type\": %lu,\n", (unsigned long)r->common.pt); ------------------ | | 117| 3.08k| { \ | | 118| 3.08k| int rval; \ | | 119| 3.11k| for (;;) { \ | | 120| 3.11k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 3.11k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 3.11k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 3.08k, False: 31] | | ------------------ | | 122| 3.11k| break; \ | | 123| 3.11k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 31|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 31] | | ------------------ | | 124| 31| return (exitcode); \ | | 125| 31| assert(rval == SBW_SHRT); \ | | 126| 31| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 31] | | ------------------ | | 127| 31| return (exitcode); \ | | 128| 31| } \ | | 129| 3.08k| } ------------------ 203| 3.08k| if (r->common.count > 0) ------------------ | Branch (203:11): [True: 2.32k, False: 754] ------------------ 204| 3.08k| RSW_REST(-1, out, " \"report_blocks\": [\n"); ------------------ | | 117| 2.32k| { \ | | 118| 2.32k| int rval; \ | | 119| 2.34k| for (;;) { \ | | 120| 2.34k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 2.34k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.34k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.32k, False: 19] | | ------------------ | | 122| 2.34k| break; \ | | 123| 2.34k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 19|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 19] | | ------------------ | | 124| 19| return (exitcode); \ | | 125| 19| assert(rval == SBW_SHRT); \ | | 126| 19| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 19] | | ------------------ | | 127| 19| return (exitcode); \ | | 128| 19| } \ | | 129| 2.32k| } ------------------ 205| 6.26k| for (i = 0; i < r->common.count; i++) { ------------------ | Branch (205:19): [True: 3.18k, False: 3.08k] ------------------ 206| 3.18k| if (i > 0) ------------------ | Branch (206:13): [True: 855, False: 2.32k] ------------------ 207| 3.18k| RSW_REST(-1, out, " ,\n"); ------------------ | | 117| 855| { \ | | 118| 855| int rval; \ | | 119| 870| for (;;) { \ | | 120| 870| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 870| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 870|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 855, False: 15] | | ------------------ | | 122| 870| break; \ | | 123| 870| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 15|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 15] | | ------------------ | | 124| 15| return (exitcode); \ | | 125| 15| assert(rval == SBW_SHRT); \ | | 126| 15| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 15] | | ------------------ | | 127| 15| return (exitcode); \ | | 128| 15| } \ | | 129| 855| } ------------------ 208| 3.18k| 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.18k| { \ | | 118| 3.18k| int rval; \ | | 119| 3.33k| for (;;) { \ | | 120| 3.33k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 209| 20.0k| (unsigned long)ntohl(r->r.rr.rr[i].ssrc), | | | | 210| 20.0k| (unsigned long)r->r.rr.rr[i].fraction, | | | | 211| 20.0k| (long)RTCP_GET_LOST(&r->r.rr.rr[i]), | | | | ------------------ | | | | | | 106| 3.33k|#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: 563, False: 2.77k] | | | | | | ------------------ | | | | ------------------ | | | | 212| 20.0k| (unsigned long)ntohl(r->r.rr.rr[i].last_seq), | | | | 213| 20.0k| (unsigned long)ntohl(r->r.rr.rr[i].jitter), | | | | 214| 20.0k| (unsigned long)ntohl(r->r.rr.rr[i].lsr), | | | | 215| 20.0k| (unsigned long)ntohl(r->r.rr.rr[i].dlsr)); | | ------------------ | | 121| 3.33k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 3.33k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 3.18k, False: 153] | | ------------------ | | 122| 3.33k| break; \ | | 123| 3.33k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 153|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 153] | | ------------------ | | 124| 153| return (exitcode); \ | | 125| 153| assert(rval == SBW_SHRT); \ | | 126| 153| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 153] | | ------------------ | | 127| 153| return (exitcode); \ | | 128| 153| } \ | | 129| 3.18k| } ------------------ 209| 3.18k| (unsigned long)ntohl(r->r.rr.rr[i].ssrc), 210| 3.18k| (unsigned long)r->r.rr.rr[i].fraction, 211| 3.18k| (long)RTCP_GET_LOST(&r->r.rr.rr[i]), 212| 3.18k| (unsigned long)ntohl(r->r.rr.rr[i].last_seq), 213| 3.18k| (unsigned long)ntohl(r->r.rr.rr[i].jitter), 214| 3.18k| (unsigned long)ntohl(r->r.rr.rr[i].lsr), 215| 3.18k| (unsigned long)ntohl(r->r.rr.rr[i].dlsr)); 216| 3.18k| } 217| 3.08k| if (r->common.count > 0) ------------------ | Branch (217:11): [True: 2.32k, False: 754] ------------------ 218| 3.08k| RSW_REST(-1, out, " ],\n"); ------------------ | | 117| 2.32k| { \ | | 118| 2.32k| int rval; \ | | 119| 2.36k| for (;;) { \ | | 120| 2.36k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 2.36k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.36k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.32k, False: 32] | | ------------------ | | 122| 2.36k| break; \ | | 123| 2.36k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 32|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 32] | | ------------------ | | 124| 32| return (exitcode); \ | | 125| 32| assert(rval == SBW_SHRT); \ | | 126| 32| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 32] | | ------------------ | | 127| 32| return (exitcode); \ | | 128| 32| } \ | | 129| 2.32k| } ------------------ 219| 3.08k| RSW_REST(-1, out, " \"report_count\": %lu\n", (unsigned long)r->common.count); ------------------ | | 117| 3.08k| { \ | | 118| 3.08k| int rval; \ | | 119| 3.12k| for (;;) { \ | | 120| 3.12k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 3.12k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 3.12k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 3.08k, False: 40] | | ------------------ | | 122| 3.12k| break; \ | | 123| 3.12k| 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| 3.08k| } ------------------ 220| 3.08k| RSW_REST(-1, out, "}"); ------------------ | | 117| 3.08k| { \ | | 118| 3.08k| int rval; \ | | 119| 3.10k| for (;;) { \ | | 120| 3.10k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 3.10k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 3.10k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 3.08k, False: 18] | | ------------------ | | 122| 3.10k| break; \ | | 123| 3.10k| 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.08k| } ------------------ 221| 3.08k| break; 222| | 223| 1| case RTCP_SDES: ------------------ | Branch (223:5): [True: 1, False: 6.21k] ------------------ 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| 1| break; 246| | 247| 0| case RTCP_BYE: ------------------ | Branch (247:5): [True: 0, False: 6.21k] ------------------ 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| 0| break; 263| | 264| | /* invalid type */ 265| 329| default: ------------------ | Branch (265:5): [True: 329, False: 5.88k] ------------------ 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| 329| break; 271| 6.21k| } 272| 6.13k| len -= bincr; 273| 6.13k| r = (const rtcp_t *)((const char *)r + bincr); 274| 6.13k| } 275| | 276| 279| return len; 277| | 278| 85|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| 85| return -1; 285| 368|} rtpp_sbuf_write: 43| 41.4k|{ 44| 41.4k| va_list ap; 45| 41.4k| int rlen, len; 46| | 47| 41.4k| len = sbp->alen - RS_ULEN(sbp); ------------------ | | 38| 41.4k|#define RS_ULEN(sbp) ((int)((sbp)->cp - (sbp)->bp)) ------------------ 48| 41.4k| assert(len > 0); 49| 0| va_start(ap, format); 50| 41.4k| rlen = vsnprintf(sbp->cp, len, format, ap); 51| 41.4k| va_end(ap); 52| 41.4k| if (rlen < 0) ------------------ | Branch (52:9): [True: 0, False: 41.4k] ------------------ 53| 0| return (SBW_ERR); ------------------ | | 35| 0|#define SBW_ERR (-1) ------------------ 54| 41.4k| if (rlen >= len) { ------------------ | Branch (54:9): [True: 660, False: 40.7k] ------------------ 55| 660| sbp->cp[0] = '\0'; 56| 660| return (SBW_SHRT); ------------------ | | 36| 660|#define SBW_SHRT (-2) ------------------ 57| 660| } 58| 40.7k| sbp->cp += rlen; 59| 40.7k| return (SBW_OK); ------------------ | | 34| 40.7k|#define SBW_OK (0) ------------------ 60| 41.4k|} rtpp_sbuf_ctor: 64| 375|{ 65| 375| struct rtpp_sbuf *sbp; 66| | 67| 375| sbp = malloc(sizeof(struct rtpp_sbuf)); 68| 375| if (sbp == NULL) ------------------ | Branch (68:9): [True: 0, False: 375] ------------------ 69| 0| return (NULL); 70| 375| memset(sbp, '\0', sizeof(struct rtpp_sbuf)); 71| 375| sbp->bp = sbp->cp = malloc(ilen); 72| 375| if (sbp->bp == NULL) { ------------------ | Branch (72:9): [True: 0, False: 375] ------------------ 73| 0| free(sbp); 74| 0| return (NULL); 75| 0| } 76| 375| sbp->cp[0] = '\0'; 77| 375| sbp->alen = ilen; 78| 375| return(sbp); 79| 375|} rtpp_sbuf_dtor: 83| 375|{ 84| | 85| 375| free(sbp->bp); 86| 375| free(sbp); 87| 375|} rtpp_sbuf_extend: 91| 660|{ 92| 660| void *nbp, *ncp; 93| | 94| 660| assert(nlen > sbp->alen); 95| 0| nbp = realloc(sbp->bp, nlen); 96| 660| if (nbp == NULL) ------------------ | Branch (96:9): [True: 0, False: 660] ------------------ 97| 0| return (-1); 98| 660| sbp->alen = nlen; 99| 660| if (sbp->bp != nbp) { ------------------ | Branch (99:9): [True: 301, False: 359] ------------------ 100| 301| ncp = nbp + RS_ULEN(sbp); ------------------ | | 38| 301|#define RS_ULEN(sbp) ((int)((sbp)->cp - (sbp)->bp)) ------------------ 101| 301| sbp->cp = ncp; 102| 301| sbp->bp = nbp; 103| 301| } 104| 660| return (0); 105| 660|} 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| 384|{ 30| 384| struct rtpp_sbuf *sbp; 31| | 32| 384| if (rtcp_dlen > MAX_RPKT_LEN) ------------------ | | 38| 384|#define MAX_RPKT_LEN 8192 ------------------ | Branch (32:9): [True: 9, False: 375] ------------------ 33| 9| return (0); 34| | 35| 375| sbp = rtpp_sbuf_ctor(512); 36| 375| 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| 375| rtcp2json(sbp, rtcp_data, rtcp_dlen); 47| 375| rtpp_sbuf_dtor(sbp); 48| | 49| 375| return (0); 50| 375|} 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|}