rtcp2json: 136| 377|{ 137| 377| const rtcp_t *r; /* RTCP header */ 138| 377| int i; 139| |#if 0 140| | const char *cp; 141| |#endif 142| | 143| 377| if (len < sizeof(rtcp_common_t)) { ------------------ | Branch (143:7): [True: 2, False: 375] ------------------ 144| 2| return -1; 145| 2| } 146| 375| r = (rtcp_t *)buf; 147| | /* Backwards compatibility: VAT header. */ 148| 375| if (r->common.version != RTP_VERSION) { ------------------ | | 41| 375|#define RTP_VERSION 2 ------------------ | Branch (148:7): [True: 3, False: 372] ------------------ 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| 6.37k| while (len > 0) { ------------------ | Branch (158:10): [True: 6.09k, False: 281] ------------------ 159| 6.09k| if (len < sizeof(rtcp_common_t)) { ------------------ | Branch (159:9): [True: 7, False: 6.09k] ------------------ 160| 7| return -1; 161| 7| } 162| 6.09k| size_t bincr = sizeof(uint32_t) * (ntohs(r->common.length) + 1); 163| | 164| 6.09k| switch (r->common.pt) { 165| 2.68k| case RTCP_SR: ------------------ | Branch (165:5): [True: 2.68k, False: 3.40k] ------------------ 166| 2.68k| 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: 33, False: 2.65k] | Branch (166:26): [True: 10, False: 2.64k] ------------------ 167| 43| goto invallen; 168| 2.64k| RSW_REST(-1, out, "{\n \"ssrc\": %lu,\n", ------------------ | | 117| 2.64k| { \ | | 118| 2.64k| int rval; \ | | 119| 2.66k| for (;;) { \ | | 120| 2.66k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 169| 2.66k| (unsigned long)ntohl(r->r.sr.ssrc)); | | ------------------ | | 121| 2.66k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.66k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.64k, False: 23] | | ------------------ | | 122| 2.66k| break; \ | | 123| 2.66k| 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| 2.64k| } ------------------ 169| 2.64k| (unsigned long)ntohl(r->r.sr.ssrc)); 170| 2.64k| 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.64k| { \ | | 118| 2.64k| int rval; \ | | 119| 2.72k| for (;;) { \ | | 120| 2.72k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 171| 13.6k| (unsigned long)ntohl(r->r.sr.ntp_sec), | | | | 172| 13.6k| (unsigned long)ntohl(r->r.sr.ntp_frac), | | | | 173| 13.6k| (unsigned long)ntohl(r->r.sr.rtp_ts), | | | | 174| 13.6k| (unsigned long)ntohl(r->r.sr.psent), | | | | 175| 13.6k| (unsigned long)ntohl(r->r.sr.osent)); | | ------------------ | | 121| 2.72k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.72k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.64k, False: 78] | | ------------------ | | 122| 2.72k| break; \ | | 123| 2.72k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 78|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 78] | | ------------------ | | 124| 78| return (exitcode); \ | | 125| 78| assert(rval == SBW_SHRT); \ | | 126| 78| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 78] | | ------------------ | | 127| 78| return (exitcode); \ | | 128| 78| } \ | | 129| 2.64k| } ------------------ 171| 2.64k| (unsigned long)ntohl(r->r.sr.ntp_sec), 172| 2.64k| (unsigned long)ntohl(r->r.sr.ntp_frac), 173| 2.64k| (unsigned long)ntohl(r->r.sr.rtp_ts), 174| 2.64k| (unsigned long)ntohl(r->r.sr.psent), 175| 2.64k| (unsigned long)ntohl(r->r.sr.osent)); 176| 2.64k| RSW_REST(-1, out, " \"type\": %lu,\n", (unsigned long)r->common.pt); ------------------ | | 117| 2.64k| { \ | | 118| 2.64k| int rval; \ | | 119| 2.67k| for (;;) { \ | | 120| 2.67k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 2.67k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.67k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.64k, False: 29] | | ------------------ | | 122| 2.67k| break; \ | | 123| 2.67k| 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.64k| } ------------------ 177| 2.64k| if (r->common.count > 0) ------------------ | Branch (177:11): [True: 1.27k, False: 1.37k] ------------------ 178| 2.64k| RSW_REST(-1, out, " \"report_blocks\": [\n"); ------------------ | | 117| 1.27k| { \ | | 118| 1.27k| int rval; \ | | 119| 1.28k| for (;;) { \ | | 120| 1.28k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 1.28k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 1.28k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 1.27k, False: 10] | | ------------------ | | 122| 1.28k| break; \ | | 123| 1.28k| 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.27k| } ------------------ 179| 4.78k| for (i = 0; i < r->common.count; i++) { ------------------ | Branch (179:19): [True: 2.13k, False: 2.64k] ------------------ 180| 2.13k| if (i > 0) ------------------ | Branch (180:13): [True: 865, False: 1.27k] ------------------ 181| 2.13k| RSW_REST(-1, out, " ,\n"); ------------------ | | 117| 865| { \ | | 118| 865| int rval; \ | | 119| 890| for (;;) { \ | | 120| 890| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 890| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 890|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 865, False: 25] | | ------------------ | | 122| 890| break; \ | | 123| 890| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 25|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 25] | | ------------------ | | 124| 25| return (exitcode); \ | | 125| 25| assert(rval == SBW_SHRT); \ | | 126| 25| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 25] | | ------------------ | | 127| 25| return (exitcode); \ | | 128| 25| } \ | | 129| 865| } ------------------ 182| 2.13k| 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.13k| { \ | | 118| 2.13k| int rval; \ | | 119| 2.26k| for (;;) { \ | | 120| 2.26k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 183| 13.5k| (unsigned long)ntohl(r->r.sr.rr[i].ssrc), | | | | 184| 13.5k| (unsigned long)r->r.sr.rr[i].fraction, | | | | 185| 13.5k| (long)RTCP_GET_LOST(&r->r.sr.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: 915, False: 1.34k] | | | | | | ------------------ | | | | ------------------ | | | | 186| 13.5k| (unsigned long)ntohl(r->r.sr.rr[i].last_seq), | | | | 187| 13.5k| (unsigned long)ntohl(r->r.sr.rr[i].jitter), | | | | 188| 13.5k| (unsigned long)ntohl(r->r.sr.rr[i].lsr), | | | | 189| 13.5k| (unsigned long)ntohl(r->r.sr.rr[i].dlsr)); | | ------------------ | | 121| 2.26k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.26k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.13k, False: 125] | | ------------------ | | 122| 2.26k| break; \ | | 123| 2.26k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 125|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 125] | | ------------------ | | 124| 125| return (exitcode); \ | | 125| 125| assert(rval == SBW_SHRT); \ | | 126| 125| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 125] | | ------------------ | | 127| 125| return (exitcode); \ | | 128| 125| } \ | | 129| 2.13k| } ------------------ 183| 2.13k| (unsigned long)ntohl(r->r.sr.rr[i].ssrc), 184| 2.13k| (unsigned long)r->r.sr.rr[i].fraction, 185| 2.13k| (long)RTCP_GET_LOST(&r->r.sr.rr[i]), 186| 2.13k| (unsigned long)ntohl(r->r.sr.rr[i].last_seq), 187| 2.13k| (unsigned long)ntohl(r->r.sr.rr[i].jitter), 188| 2.13k| (unsigned long)ntohl(r->r.sr.rr[i].lsr), 189| 2.13k| (unsigned long)ntohl(r->r.sr.rr[i].dlsr)); 190| 2.13k| } 191| 2.64k| if (r->common.count > 0) ------------------ | Branch (191:11): [True: 1.27k, False: 1.37k] ------------------ 192| 2.64k| RSW_REST(-1, out, " ],\n"); ------------------ | | 117| 1.27k| { \ | | 118| 1.27k| int rval; \ | | 119| 1.28k| for (;;) { \ | | 120| 1.28k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 1.28k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 1.28k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 1.27k, False: 13] | | ------------------ | | 122| 1.28k| break; \ | | 123| 1.28k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 13|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 13] | | ------------------ | | 124| 13| return (exitcode); \ | | 125| 13| assert(rval == SBW_SHRT); \ | | 126| 13| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 13] | | ------------------ | | 127| 13| return (exitcode); \ | | 128| 13| } \ | | 129| 1.27k| } ------------------ 193| 2.64k| RSW_REST(-1, out, " \"report_count\": %lu\n", (unsigned long)r->common.count); ------------------ | | 117| 2.64k| { \ | | 118| 2.64k| int rval; \ | | 119| 2.67k| for (;;) { \ | | 120| 2.67k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 2.67k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.67k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.64k, False: 26] | | ------------------ | | 122| 2.67k| break; \ | | 123| 2.67k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 26|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 26] | | ------------------ | | 124| 26| return (exitcode); \ | | 125| 26| assert(rval == SBW_SHRT); \ | | 126| 26| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 26] | | ------------------ | | 127| 26| return (exitcode); \ | | 128| 26| } \ | | 129| 2.64k| } ------------------ 194| 2.64k| RSW_REST(-1, out, "}"); ------------------ | | 117| 2.64k| { \ | | 118| 2.64k| int rval; \ | | 119| 2.66k| for (;;) { \ | | 120| 2.66k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 2.66k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.66k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.64k, False: 18] | | ------------------ | | 122| 2.66k| break; \ | | 123| 2.66k| 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| 2.64k| } ------------------ 195| 2.64k| break; 196| | 197| 3.11k| case RTCP_RR: ------------------ | Branch (197:5): [True: 3.11k, False: 2.97k] ------------------ 198| 3.11k| 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: 32, False: 3.08k] | Branch (198:26): [True: 9, False: 3.07k] ------------------ 199| 41| goto invallen; 200| 3.07k| RSW_REST(-1, out, "{\n \"ssrc\": %lu,\n", ------------------ | | 117| 3.07k| { \ | | 118| 3.07k| int rval; \ | | 119| 3.10k| for (;;) { \ | | 120| 3.10k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 201| 3.10k| (unsigned long)ntohl(r->r.rr.ssrc)); | | ------------------ | | 121| 3.10k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 3.10k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 3.07k, False: 29] | | ------------------ | | 122| 3.10k| break; \ | | 123| 3.10k| 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| 3.07k| } ------------------ 201| 3.07k| (unsigned long)ntohl(r->r.rr.ssrc)); 202| 3.07k| RSW_REST(-1, out, " \"type\": %lu,\n", (unsigned long)r->common.pt); ------------------ | | 117| 3.07k| { \ | | 118| 3.07k| int rval; \ | | 119| 3.09k| for (;;) { \ | | 120| 3.09k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 3.09k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 3.09k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 3.07k, False: 23] | | ------------------ | | 122| 3.09k| break; \ | | 123| 3.09k| 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| 3.07k| } ------------------ 203| 3.07k| if (r->common.count > 0) ------------------ | Branch (203:11): [True: 2.30k, False: 770] ------------------ 204| 3.07k| RSW_REST(-1, out, " \"report_blocks\": [\n"); ------------------ | | 117| 2.30k| { \ | | 118| 2.30k| int rval; \ | | 119| 2.32k| for (;;) { \ | | 120| 2.32k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 2.32k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 2.32k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 2.30k, False: 19] | | ------------------ | | 122| 2.32k| break; \ | | 123| 2.32k| 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.30k| } ------------------ 205| 6.25k| for (i = 0; i < r->common.count; i++) { ------------------ | Branch (205:19): [True: 3.18k, False: 3.07k] ------------------ 206| 3.18k| if (i > 0) ------------------ | Branch (206:13): [True: 884, False: 2.30k] ------------------ 207| 3.18k| RSW_REST(-1, out, " ,\n"); ------------------ | | 117| 884| { \ | | 118| 884| int rval; \ | | 119| 896| for (;;) { \ | | 120| 896| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 896| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 896|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 884, False: 12] | | ------------------ | | 122| 896| break; \ | | 123| 896| 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| 884| } ------------------ 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: 592, False: 2.74k] | | | | | | ------------------ | | | | ------------------ | | | | 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: 149] | | ------------------ | | 122| 3.33k| break; \ | | 123| 3.33k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 149|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 149] | | ------------------ | | 124| 149| return (exitcode); \ | | 125| 149| assert(rval == SBW_SHRT); \ | | 126| 149| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 149] | | ------------------ | | 127| 149| return (exitcode); \ | | 128| 149| } \ | | 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.07k| if (r->common.count > 0) ------------------ | Branch (217:11): [True: 2.30k, False: 770] ------------------ 218| 3.07k| RSW_REST(-1, out, " ],\n"); ------------------ | | 117| 2.30k| { \ | | 118| 2.30k| 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.30k, False: 39] | | ------------------ | | 122| 2.34k| break; \ | | 123| 2.34k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 39|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 39] | | ------------------ | | 124| 39| return (exitcode); \ | | 125| 39| assert(rval == SBW_SHRT); \ | | 126| 39| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 39] | | ------------------ | | 127| 39| return (exitcode); \ | | 128| 39| } \ | | 129| 2.30k| } ------------------ 219| 3.07k| RSW_REST(-1, out, " \"report_count\": %lu\n", (unsigned long)r->common.count); ------------------ | | 117| 3.07k| { \ | | 118| 3.07k| 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.07k, False: 34] | | ------------------ | | 122| 3.10k| break; \ | | 123| 3.10k| if (rval == SBW_ERR) \ | | ------------------ | | | | 35| 34|#define SBW_ERR (-1) | | ------------------ | | | Branch (123:11): [True: 0, False: 34] | | ------------------ | | 124| 34| return (exitcode); \ | | 125| 34| assert(rval == SBW_SHRT); \ | | 126| 34| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (126:11): [True: 0, False: 34] | | ------------------ | | 127| 34| return (exitcode); \ | | 128| 34| } \ | | 129| 3.07k| } ------------------ 220| 3.07k| RSW_REST(-1, out, "}"); ------------------ | | 117| 3.07k| { \ | | 118| 3.07k| int rval; \ | | 119| 3.09k| for (;;) { \ | | 120| 3.09k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 121| 3.09k| if (rval == SBW_OK) \ | | ------------------ | | | | 34| 3.09k|#define SBW_OK (0) | | ------------------ | | | Branch (121:11): [True: 3.07k, False: 22] | | ------------------ | | 122| 3.09k| break; \ | | 123| 3.09k| 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| 3.07k| } ------------------ 221| 3.07k| break; 222| | 223| 2| case RTCP_SDES: ------------------ | Branch (223:5): [True: 2, False: 6.08k] ------------------ 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| 2| break; 246| | 247| 0| case RTCP_BYE: ------------------ | Branch (247:5): [True: 0, False: 6.09k] ------------------ 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| 288| default: ------------------ | Branch (265:5): [True: 288, False: 5.80k] ------------------ 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| 288| break; 271| 6.09k| } 272| 6.00k| len -= bincr; 273| 6.00k| r = (const rtcp_t *)((const char *)r + bincr); 274| 6.00k| } 275| | 276| 281| return len; 277| | 278| 84|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| 84| return -1; 285| 372|} rtpp_sbuf_write: 43| 40.4k|{ 44| 40.4k| va_list ap; 45| 40.4k| int rlen, len; 46| | 47| 40.4k| len = sbp->alen - RS_ULEN(sbp); ------------------ | | 38| 40.4k|#define RS_ULEN(sbp) ((int)((sbp)->cp - (sbp)->bp)) ------------------ 48| 40.4k| assert(len > 0); 49| 0| va_start(ap, format); 50| 40.4k| rlen = vsnprintf(sbp->cp, len, format, ap); 51| 40.4k| va_end(ap); 52| 40.4k| if (rlen < 0) ------------------ | Branch (52:9): [True: 0, False: 40.4k] ------------------ 53| 0| return (SBW_ERR); ------------------ | | 35| 0|#define SBW_ERR (-1) ------------------ 54| 40.4k| if (rlen >= len) { ------------------ | Branch (54:9): [True: 674, False: 39.7k] ------------------ 55| 674| sbp->cp[0] = '\0'; 56| 674| return (SBW_SHRT); ------------------ | | 36| 674|#define SBW_SHRT (-2) ------------------ 57| 674| } 58| 39.7k| sbp->cp += rlen; 59| 39.7k| return (SBW_OK); ------------------ | | 34| 39.7k|#define SBW_OK (0) ------------------ 60| 40.4k|} rtpp_sbuf_ctor: 64| 377|{ 65| 377| struct rtpp_sbuf *sbp; 66| | 67| 377| sbp = malloc(sizeof(struct rtpp_sbuf)); 68| 377| if (sbp == NULL) ------------------ | Branch (68:9): [True: 0, False: 377] ------------------ 69| 0| return (NULL); 70| 377| memset(sbp, '\0', sizeof(struct rtpp_sbuf)); 71| 377| sbp->bp = sbp->cp = malloc(ilen); 72| 377| if (sbp->bp == NULL) { ------------------ | Branch (72:9): [True: 0, False: 377] ------------------ 73| 0| free(sbp); 74| 0| return (NULL); 75| 0| } 76| 377| sbp->cp[0] = '\0'; 77| 377| sbp->alen = ilen; 78| 377| return(sbp); 79| 377|} rtpp_sbuf_dtor: 83| 377|{ 84| | 85| 377| free(sbp->bp); 86| 377| free(sbp); 87| 377|} rtpp_sbuf_extend: 91| 674|{ 92| 674| void *nbp, *ncp; 93| | 94| 674| assert(nlen > sbp->alen); 95| 0| nbp = realloc(sbp->bp, nlen); 96| 674| if (nbp == NULL) ------------------ | Branch (96:9): [True: 0, False: 674] ------------------ 97| 0| return (-1); 98| 674| sbp->alen = nlen; 99| 674| if (sbp->bp != nbp) { ------------------ | Branch (99:9): [True: 317, False: 357] ------------------ 100| 317| ncp = nbp + RS_ULEN(sbp); ------------------ | | 38| 317|#define RS_ULEN(sbp) ((int)((sbp)->cp - (sbp)->bp)) ------------------ 101| 317| sbp->cp = ncp; 102| 317| sbp->bp = nbp; 103| 317| } 104| 674| return (0); 105| 674|} 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| 386|{ 30| 386| struct rtpp_sbuf *sbp; 31| | 32| 386| if (rtcp_dlen > MAX_RPKT_LEN) ------------------ | | 38| 386|#define MAX_RPKT_LEN 8192 ------------------ | Branch (32:9): [True: 9, False: 377] ------------------ 33| 9| return (0); 34| | 35| 377| sbp = rtpp_sbuf_ctor(512); 36| 377| 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| 377| rtcp2json(sbp, rtcp_data, rtcp_dlen); 47| 377| rtpp_sbuf_dtor(sbp); 48| | 49| 377| return (0); 50| 377|} 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|}