rtcp2json: 137| 379|{ 138| 379| const rtcp_t *r; /* RTCP header */ 139| 379| int i; 140| |#if 0 141| | const char *cp; 142| |#endif 143| | 144| 379| if (len < sizeof(rtcp_common_t)) { ------------------ | Branch (144:7): [True: 2, False: 377] ------------------ 145| 2| return -1; 146| 2| } 147| 377| r = (rtcp_t *)buf; 148| | /* Backwards compatibility: VAT header. */ 149| 377| if (r->common.version != RTP_VERSION) { ------------------ | | 41| 377|#define RTP_VERSION 2 ------------------ | Branch (149:7): [True: 3, False: 374] ------------------ 150| |#if 0 151| | fprintf(out, "invalid version %d\n", r->common.version); 152| |#endif 153| 3| return -1; 154| 3| } 155| | 156| |#if 0 157| | fprintf(out, "\n"); 158| |#endif 159| 6.34k| while (len > 0) { ------------------ | Branch (159:10): [True: 6.07k, False: 278] ------------------ 160| 6.07k| if (len < sizeof(rtcp_common_t)) { ------------------ | Branch (160:9): [True: 3, False: 6.06k] ------------------ 161| 3| return -1; 162| 3| } 163| 6.06k| size_t bincr = sizeof(uint32_t) * (ntohs(r->common.length) + 1); 164| | 165| 6.06k| switch (r->common.pt) { 166| 3.56k| case RTCP_SR: ------------------ | Branch (166:5): [True: 3.56k, False: 2.50k] ------------------ 167| 3.56k| 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: 38, False: 3.52k] | Branch (167:26): [True: 10, False: 3.51k] ------------------ 168| 48| goto invallen; 169| 3.51k| RSW_REST(-1, out, "{\n \"ssrc\": %lu,\n", ------------------ | | 118| 3.51k| { \ | | 119| 3.51k| int rval; \ | | 120| 3.55k| for (;;) { \ | | 121| 3.55k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 170| 3.55k| (unsigned long)ntohl(r->r.sr.ssrc)); | | ------------------ | | 122| 3.55k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.55k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.51k, False: 33] | | ------------------ | | 123| 3.55k| break; \ | | 124| 3.55k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 33|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 33] | | ------------------ | | 125| 33| return (exitcode); \ | | 126| 33| assert(rval == SBW_SHRT); \ | | 127| 33| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 33] | | ------------------ | | 128| 33| return (exitcode); \ | | 129| 33| } \ | | 130| 3.51k| } ------------------ | Branch (169:7): [True: 33, False: 0] ------------------ 170| 3.51k| (unsigned long)ntohl(r->r.sr.ssrc)); 171| 3.51k| 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.51k| { \ | | 119| 3.51k| int rval; \ | | 120| 3.59k| for (;;) { \ | | 121| 3.59k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 172| 17.9k| (unsigned long)ntohl(r->r.sr.ntp_sec), | | | | 173| 17.9k| (unsigned long)ntohl(r->r.sr.ntp_frac), | | | | 174| 17.9k| (unsigned long)ntohl(r->r.sr.rtp_ts), | | | | 175| 17.9k| (unsigned long)ntohl(r->r.sr.psent), | | | | 176| 17.9k| (unsigned long)ntohl(r->r.sr.osent)); | | ------------------ | | 122| 3.59k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.59k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.51k, False: 81] | | ------------------ | | 123| 3.59k| break; \ | | 124| 3.59k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 81|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 81] | | ------------------ | | 125| 81| return (exitcode); \ | | 126| 81| assert(rval == SBW_SHRT); \ | | 127| 81| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 81] | | ------------------ | | 128| 81| return (exitcode); \ | | 129| 81| } \ | | 130| 3.51k| } ------------------ | Branch (171:7): [True: 81, False: 0] ------------------ 172| 3.51k| (unsigned long)ntohl(r->r.sr.ntp_sec), 173| 3.51k| (unsigned long)ntohl(r->r.sr.ntp_frac), 174| 3.51k| (unsigned long)ntohl(r->r.sr.rtp_ts), 175| 3.51k| (unsigned long)ntohl(r->r.sr.psent), 176| 3.51k| (unsigned long)ntohl(r->r.sr.osent)); 177| 3.51k| RSW_REST(-1, out, " \"type\": %lu,\n", (unsigned long)r->common.pt); ------------------ | | 118| 3.51k| { \ | | 119| 3.51k| int rval; \ | | 120| 3.53k| for (;;) { \ | | 121| 3.53k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.53k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.53k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.51k, False: 18] | | ------------------ | | 123| 3.53k| break; \ | | 124| 3.53k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 18|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 18] | | ------------------ | | 125| 18| return (exitcode); \ | | 126| 18| assert(rval == SBW_SHRT); \ | | 127| 18| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 18] | | ------------------ | | 128| 18| return (exitcode); \ | | 129| 18| } \ | | 130| 3.51k| } ------------------ | Branch (177:7): [True: 18, False: 0] ------------------ 178| 3.51k| if (r->common.count > 0) ------------------ | Branch (178:11): [True: 2.89k, False: 626] ------------------ 179| 3.51k| RSW_REST(-1, out, " \"report_blocks\": [\n"); ------------------ | | 118| 2.89k| { \ | | 119| 2.89k| int rval; \ | | 120| 2.92k| for (;;) { \ | | 121| 2.92k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.92k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.92k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.89k, False: 35] | | ------------------ | | 123| 2.92k| break; \ | | 124| 2.92k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 35|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 35] | | ------------------ | | 125| 35| return (exitcode); \ | | 126| 35| assert(rval == SBW_SHRT); \ | | 127| 35| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 35] | | ------------------ | | 128| 35| return (exitcode); \ | | 129| 35| } \ | | 130| 2.89k| } ------------------ | Branch (179:9): [True: 35, False: 0] ------------------ 180| 7.28k| for (i = 0; i < r->common.count; i++) { ------------------ | Branch (180:19): [True: 3.76k, False: 3.51k] ------------------ 181| 3.76k| if (i > 0) ------------------ | Branch (181:13): [True: 873, False: 2.89k] ------------------ 182| 3.76k| RSW_REST(-1, out, " ,\n"); ------------------ | | 118| 873| { \ | | 119| 873| int rval; \ | | 120| 898| for (;;) { \ | | 121| 898| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 898| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 898|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 873, False: 25] | | ------------------ | | 123| 898| break; \ | | 124| 898| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 25|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 25] | | ------------------ | | 125| 25| return (exitcode); \ | | 126| 25| assert(rval == SBW_SHRT); \ | | 127| 25| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 25] | | ------------------ | | 128| 25| return (exitcode); \ | | 129| 25| } \ | | 130| 873| } ------------------ | Branch (182:11): [True: 25, False: 0] ------------------ 183| 3.76k| 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.76k| { \ | | 119| 3.76k| int rval; \ | | 120| 3.85k| for (;;) { \ | | 121| 3.85k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 184| 23.1k| (unsigned long)ntohl(r->r.sr.rr[i].ssrc), | | | | 185| 23.1k| (unsigned long)r->r.sr.rr[i].fraction, | | | | 186| 23.1k| (long)RTCP_GET_LOST(&r->r.sr.rr[i]), | | | | ------------------ | | | | | | 106| 3.85k|#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: 668, False: 3.18k] | | | | | | ------------------ | | | | ------------------ | | | | 187| 23.1k| (unsigned long)ntohl(r->r.sr.rr[i].last_seq), | | | | 188| 23.1k| (unsigned long)ntohl(r->r.sr.rr[i].jitter), | | | | 189| 23.1k| (unsigned long)ntohl(r->r.sr.rr[i].lsr), | | | | 190| 23.1k| (unsigned long)ntohl(r->r.sr.rr[i].dlsr)); | | ------------------ | | 122| 3.85k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.85k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.76k, False: 91] | | ------------------ | | 123| 3.85k| break; \ | | 124| 3.85k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 91|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 91] | | ------------------ | | 125| 91| return (exitcode); \ | | 126| 91| assert(rval == SBW_SHRT); \ | | 127| 91| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 91] | | ------------------ | | 128| 91| return (exitcode); \ | | 129| 91| } \ | | 130| 3.76k| } ------------------ | Branch (183:9): [True: 91, False: 0] ------------------ 184| 3.76k| (unsigned long)ntohl(r->r.sr.rr[i].ssrc), 185| 3.76k| (unsigned long)r->r.sr.rr[i].fraction, 186| 3.76k| (long)RTCP_GET_LOST(&r->r.sr.rr[i]), 187| 3.76k| (unsigned long)ntohl(r->r.sr.rr[i].last_seq), 188| 3.76k| (unsigned long)ntohl(r->r.sr.rr[i].jitter), 189| 3.76k| (unsigned long)ntohl(r->r.sr.rr[i].lsr), 190| 3.76k| (unsigned long)ntohl(r->r.sr.rr[i].dlsr)); 191| 3.76k| } 192| 3.51k| if (r->common.count > 0) ------------------ | Branch (192:11): [True: 2.89k, False: 626] ------------------ 193| 3.51k| RSW_REST(-1, out, " ],\n"); ------------------ | | 118| 2.89k| { \ | | 119| 2.89k| int rval; \ | | 120| 2.90k| for (;;) { \ | | 121| 2.90k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.90k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.90k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.89k, False: 18] | | ------------------ | | 123| 2.90k| break; \ | | 124| 2.90k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 18|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 18] | | ------------------ | | 125| 18| return (exitcode); \ | | 126| 18| assert(rval == SBW_SHRT); \ | | 127| 18| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 18] | | ------------------ | | 128| 18| return (exitcode); \ | | 129| 18| } \ | | 130| 2.89k| } ------------------ | Branch (193:9): [True: 18, False: 0] ------------------ 194| 3.51k| RSW_REST(-1, out, " \"report_count\": %lu\n", (unsigned long)r->common.count); ------------------ | | 118| 3.51k| { \ | | 119| 3.51k| int rval; \ | | 120| 3.57k| for (;;) { \ | | 121| 3.57k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.57k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.57k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.51k, False: 55] | | ------------------ | | 123| 3.57k| break; \ | | 124| 3.57k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 55|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 55] | | ------------------ | | 125| 55| return (exitcode); \ | | 126| 55| assert(rval == SBW_SHRT); \ | | 127| 55| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 55] | | ------------------ | | 128| 55| return (exitcode); \ | | 129| 55| } \ | | 130| 3.51k| } ------------------ | Branch (194:7): [True: 55, False: 0] ------------------ 195| 3.51k| RSW_REST(-1, out, "}"); ------------------ | | 118| 3.51k| { \ | | 119| 3.51k| int rval; \ | | 120| 3.53k| for (;;) { \ | | 121| 3.53k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.53k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.53k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.51k, False: 18] | | ------------------ | | 123| 3.53k| break; \ | | 124| 3.53k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 18|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 18] | | ------------------ | | 125| 18| return (exitcode); \ | | 126| 18| assert(rval == SBW_SHRT); \ | | 127| 18| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 18] | | ------------------ | | 128| 18| return (exitcode); \ | | 129| 18| } \ | | 130| 3.51k| } ------------------ | Branch (195:7): [True: 18, False: 0] ------------------ 196| 3.51k| break; 197| | 198| 2.21k| case RTCP_RR: ------------------ | Branch (198:5): [True: 2.21k, False: 3.85k] ------------------ 199| 2.21k| 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: 36, False: 2.18k] | Branch (199:26): [True: 9, False: 2.17k] ------------------ 200| 45| goto invallen; 201| 2.17k| RSW_REST(-1, out, "{\n \"ssrc\": %lu,\n", ------------------ | | 118| 2.17k| { \ | | 119| 2.17k| int rval; \ | | 120| 2.19k| for (;;) { \ | | 121| 2.19k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 202| 2.19k| (unsigned long)ntohl(r->r.rr.ssrc)); | | ------------------ | | 122| 2.19k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.19k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.17k, False: 25] | | ------------------ | | 123| 2.19k| break; \ | | 124| 2.19k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 25|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 25] | | ------------------ | | 125| 25| return (exitcode); \ | | 126| 25| assert(rval == SBW_SHRT); \ | | 127| 25| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 25] | | ------------------ | | 128| 25| return (exitcode); \ | | 129| 25| } \ | | 130| 2.17k| } ------------------ | Branch (201:7): [True: 25, False: 0] ------------------ 202| 2.17k| (unsigned long)ntohl(r->r.rr.ssrc)); 203| 2.17k| RSW_REST(-1, out, " \"type\": %lu,\n", (unsigned long)r->common.pt); ------------------ | | 118| 2.17k| { \ | | 119| 2.17k| int rval; \ | | 120| 2.20k| for (;;) { \ | | 121| 2.20k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.20k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.20k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.17k, False: 32] | | ------------------ | | 123| 2.20k| break; \ | | 124| 2.20k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 32|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 32] | | ------------------ | | 125| 32| return (exitcode); \ | | 126| 32| assert(rval == SBW_SHRT); \ | | 127| 32| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 32] | | ------------------ | | 128| 32| return (exitcode); \ | | 129| 32| } \ | | 130| 2.17k| } ------------------ | Branch (203:7): [True: 32, False: 0] ------------------ 204| 2.17k| if (r->common.count > 0) ------------------ | Branch (204:11): [True: 995, False: 1.17k] ------------------ 205| 2.17k| RSW_REST(-1, out, " \"report_blocks\": [\n"); ------------------ | | 118| 995| { \ | | 119| 995| int rval; \ | | 120| 1.01k| for (;;) { \ | | 121| 1.01k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 1.01k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 1.01k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 995, False: 19] | | ------------------ | | 123| 1.01k| break; \ | | 124| 1.01k| 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| 995| } ------------------ | Branch (205:9): [True: 19, False: 0] ------------------ 206| 4.02k| for (i = 0; i < r->common.count; i++) { ------------------ | Branch (206:19): [True: 1.85k, False: 2.17k] ------------------ 207| 1.85k| if (i > 0) ------------------ | Branch (207:13): [True: 855, False: 995] ------------------ 208| 1.85k| RSW_REST(-1, out, " ,\n"); ------------------ | | 118| 855| { \ | | 119| 855| int rval; \ | | 120| 873| for (;;) { \ | | 121| 873| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 873| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 873|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 855, False: 18] | | ------------------ | | 123| 873| break; \ | | 124| 873| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 18|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 18] | | ------------------ | | 125| 18| return (exitcode); \ | | 126| 18| assert(rval == SBW_SHRT); \ | | 127| 18| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 18] | | ------------------ | | 128| 18| return (exitcode); \ | | 129| 18| } \ | | 130| 855| } ------------------ | Branch (208:11): [True: 18, False: 0] ------------------ 209| 1.85k| RSW_REST(-1, out, " {\n \"source_ssrc\": %lu,\n \"fraction_lost\": %lu,\n \"packets_lost\": %ld,\n \"highest_seq_no\": %lu,\n \"ia_jitter\": %lu,\n \"lsr\": %lu,\n \"dlsr\": %lu\n }\n", ------------------ | | 118| 1.85k| { \ | | 119| 1.85k| int rval; \ | | 120| 1.96k| for (;;) { \ | | 121| 1.96k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 210| 11.8k| (unsigned long)ntohl(r->r.rr.rr[i].ssrc), | | | | 211| 11.8k| (unsigned long)r->r.rr.rr[i].fraction, | | | | 212| 11.8k| (long)RTCP_GET_LOST(&r->r.rr.rr[i]), | | | | ------------------ | | | | | | 106| 1.96k|#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: 549, False: 1.42k] | | | | | | ------------------ | | | | ------------------ | | | | 213| 11.8k| (unsigned long)ntohl(r->r.rr.rr[i].last_seq), | | | | 214| 11.8k| (unsigned long)ntohl(r->r.rr.rr[i].jitter), | | | | 215| 11.8k| (unsigned long)ntohl(r->r.rr.rr[i].lsr), | | | | 216| 11.8k| (unsigned long)ntohl(r->r.rr.rr[i].dlsr)); | | ------------------ | | 122| 1.96k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 1.96k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 1.85k, False: 119] | | ------------------ | | 123| 1.96k| break; \ | | 124| 1.96k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 119|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 119] | | ------------------ | | 125| 119| return (exitcode); \ | | 126| 119| assert(rval == SBW_SHRT); \ | | 127| 119| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 119] | | ------------------ | | 128| 119| return (exitcode); \ | | 129| 119| } \ | | 130| 1.85k| } ------------------ | Branch (209:9): [True: 119, False: 0] ------------------ 210| 1.85k| (unsigned long)ntohl(r->r.rr.rr[i].ssrc), 211| 1.85k| (unsigned long)r->r.rr.rr[i].fraction, 212| 1.85k| (long)RTCP_GET_LOST(&r->r.rr.rr[i]), 213| 1.85k| (unsigned long)ntohl(r->r.rr.rr[i].last_seq), 214| 1.85k| (unsigned long)ntohl(r->r.rr.rr[i].jitter), 215| 1.85k| (unsigned long)ntohl(r->r.rr.rr[i].lsr), 216| 1.85k| (unsigned long)ntohl(r->r.rr.rr[i].dlsr)); 217| 1.85k| } 218| 2.17k| if (r->common.count > 0) ------------------ | Branch (218:11): [True: 995, False: 1.17k] ------------------ 219| 2.17k| RSW_REST(-1, out, " ],\n"); ------------------ | | 118| 995| { \ | | 119| 995| int rval; \ | | 120| 1.01k| for (;;) { \ | | 121| 1.01k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 1.01k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 1.01k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 995, False: 21] | | ------------------ | | 123| 1.01k| break; \ | | 124| 1.01k| 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| 995| } ------------------ | Branch (219:9): [True: 21, False: 0] ------------------ 220| 2.17k| RSW_REST(-1, out, " \"report_count\": %lu\n", (unsigned long)r->common.count); ------------------ | | 118| 2.17k| { \ | | 119| 2.17k| int rval; \ | | 120| 2.21k| for (;;) { \ | | 121| 2.21k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.21k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.21k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.17k, False: 41] | | ------------------ | | 123| 2.21k| break; \ | | 124| 2.21k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 41|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 41] | | ------------------ | | 125| 41| return (exitcode); \ | | 126| 41| assert(rval == SBW_SHRT); \ | | 127| 41| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 41] | | ------------------ | | 128| 41| return (exitcode); \ | | 129| 41| } \ | | 130| 2.17k| } ------------------ | Branch (220:7): [True: 41, False: 0] ------------------ 221| 2.17k| RSW_REST(-1, out, "}"); ------------------ | | 118| 2.17k| { \ | | 119| 2.17k| int rval; \ | | 120| 2.20k| for (;;) { \ | | 121| 2.20k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.20k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.20k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.17k, False: 29] | | ------------------ | | 123| 2.20k| break; \ | | 124| 2.20k| 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.17k| } ------------------ | Branch (221:7): [True: 29, False: 0] ------------------ 222| 2.17k| break; 223| | 224| 0| case RTCP_SDES: ------------------ | Branch (224:5): [True: 0, False: 6.06k] ------------------ 225| |#if 0 226| | fprintf(out, " (SDES p=%d count=%d len=%d\n", 227| | r->common.p, r->common.count, ntohs(r->common.length)); 228| | cp = (const char *)&r->r.sdes; 229| | for (i = 0; i < r->common.count; i++) { 230| | int remaining = (ntohs(r->common.length) << 2) - 231| | (cp - (const char *)&r->r.sdes); 232| | fprintf(out, " (src=0x%lx ", 233| | (unsigned long)ntohl(((struct rtcp_sdes *)cp)->src)); 234| | if (remaining > 0) { 235| | cp = rtp_read_sdes(out, cp, 236| | (ntohs(r->common.length) << 2) - (cp - (const char *)&r->r.sdes)); 237| | if (!cp) return -1; 238| | } else { 239| | fprintf(stderr, "Missing at least %d bytes.\n", -remaining); 240| | return -1; 241| | } 242| | fprintf(out, ")\n"); 243| | } 244| | fprintf(out, " )\n"); 245| |#endif 246| 0| break; 247| | 248| 0| case RTCP_BYE: ------------------ | Branch (248:5): [True: 0, False: 6.06k] ------------------ 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| 286| default: ------------------ | Branch (266:5): [True: 286, False: 5.78k] ------------------ 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| 286| break; 272| 6.06k| } 273| 5.97k| len -= bincr; 274| 5.97k| r = (const rtcp_t *)((const char *)r + bincr); 275| 5.97k| } 276| | 277| 278| return len; 278| | 279| 93|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| 93| return -1; 286| 374|} 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| 379|{ 35| 379| struct rtpp_sbuf *sbp; 36| | 37| 379| if (rtcp_dlen > MAX_RPKT_LEN) ------------------ | | 37| 379|#define MAX_RPKT_LEN 8192 ------------------ | Branch (37:9): [True: 0, False: 379] ------------------ 38| 0| return (0); 39| | 40| 379| sbp = rtpp_sbuf_ctor(512); 41| 379| assert (sbp != NULL); ------------------ | Branch (41:5): [True: 0, False: 379] | Branch (41:5): [True: 379, 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| 379| rtcp2json(sbp, rtcp_data, rtcp_dlen); 52| 379| rtpp_sbuf_dtor(sbp); 53| | 54| 379| return (0); 55| 379|} 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| 42.0k|{ 43| 42.0k| va_list ap; 44| 42.0k| int rlen, len; 45| | 46| 42.0k| len = sbp->alen - RS_ULEN(sbp); ------------------ | | 40| 42.0k|#define RS_ULEN(sbp) ((int)((sbp)->cp - (sbp)->bp)) ------------------ 47| 42.0k| assert(len > 0); ------------------ | Branch (47:5): [True: 0, False: 42.0k] | Branch (47:5): [True: 42.0k, False: 0] ------------------ 48| 42.0k| va_start(ap, format); 49| 42.0k| rlen = vsnprintf(sbp->cp, len, format, ap); 50| 42.0k| va_end(ap); 51| 42.0k| if (rlen < 0) ------------------ | Branch (51:9): [True: 0, False: 42.0k] ------------------ 52| 0| return (SBW_ERR); ------------------ | | 37| 0|#define SBW_ERR (-1) ------------------ 53| 42.0k| if (rlen >= len) { ------------------ | Branch (53:9): [True: 678, False: 41.3k] ------------------ 54| 678| sbp->cp[0] = '\0'; 55| 678| return (SBW_SHRT); ------------------ | | 38| 678|#define SBW_SHRT (-2) ------------------ 56| 678| } 57| 41.3k| sbp->cp += rlen; 58| 41.3k| return (SBW_OK); ------------------ | | 36| 41.3k|#define SBW_OK (0) ------------------ 59| 42.0k|} rtpp_sbuf_ctor: 67| 379|{ 68| 379| struct rtpp_sbuf *sbp; 69| | 70| 379|#if !defined(RTPP_CHECK_LEAKS) 71| 379| sbp = malloc(sizeof(struct rtpp_sbuf)); 72| |#else 73| | sbp = rtpp_memdeb_malloc(sizeof(struct rtpp_sbuf), memdeb_p, mlp); 74| |#endif 75| 379| if (sbp == NULL) ------------------ | Branch (75:9): [True: 0, False: 379] ------------------ 76| 0| return (NULL); 77| 379| memset(sbp, '\0', sizeof(struct rtpp_sbuf)); 78| 379|#if !defined(RTPP_CHECK_LEAKS) 79| 379| sbp->bp = sbp->cp = malloc(ilen); 80| |#else 81| | sbp->bp = sbp->cp = rtpp_memdeb_malloc(ilen, memdeb_p, mlp); 82| |#endif 83| 379| if (sbp->bp == NULL) { ------------------ | Branch (83:9): [True: 0, False: 379] ------------------ 84| 0| free(sbp); 85| 0| return (NULL); 86| 0| } 87| 379| sbp->cp[0] = '\0'; 88| 379| sbp->alen = ilen; 89| 379| return(sbp); 90| 379|} rtpp_sbuf_dtor: 98| 379|{ 99| | 100| 379|#if !defined(RTPP_CHECK_LEAKS) 101| 379| free(sbp->bp); 102| 379| free(sbp); 103| |#else 104| | rtpp_memdeb_free(sbp->bp, memdeb_p, mlp); 105| | rtpp_memdeb_free(sbp, memdeb_p, mlp); 106| |#endif 107| 379|} rtpp_sbuf_extend: 115| 678|{ 116| 678| void *nbp, *ncp; 117| | 118| 678| assert(nlen > sbp->alen); ------------------ | Branch (118:5): [True: 0, False: 678] | Branch (118:5): [True: 678, False: 0] ------------------ 119| 678|#if !defined(RTPP_CHECK_LEAKS) 120| 678| nbp = realloc(sbp->bp, nlen); 121| |#else 122| | nbp = rtpp_memdeb_realloc(sbp->bp, nlen, memdeb_p, mlp); 123| |#endif 124| 678| if (nbp == NULL) ------------------ | Branch (124:9): [True: 0, False: 678] ------------------ 125| 0| return (-1); 126| 678| sbp->alen = nlen; 127| 678| if (sbp->bp != nbp) { ------------------ | Branch (127:9): [True: 303, False: 375] ------------------ 128| 303| ncp = nbp + RS_ULEN(sbp); ------------------ | | 40| 303|#define RS_ULEN(sbp) ((int)((sbp)->cp - (sbp)->bp)) ------------------ 129| 303| sbp->cp = ncp; 130| 303| sbp->bp = nbp; 131| 303| } 132| 678| return (0); 133| 678|}