rtcp2json: 137| 382|{ 138| 382| const rtcp_t *r; /* RTCP header */ 139| 382| int i; 140| |#if 0 141| | const char *cp; 142| |#endif 143| | 144| 382| if (len < sizeof(rtcp_common_t)) { ------------------ | Branch (144:7): [True: 2, False: 380] ------------------ 145| 2| return -1; 146| 2| } 147| 380| r = (rtcp_t *)buf; 148| | /* Backwards compatibility: VAT header. */ 149| 380| if (r->common.version != RTP_VERSION) { ------------------ | | 41| 380|#define RTP_VERSION 2 ------------------ | Branch (149:7): [True: 6, False: 374] ------------------ 150| |#if 0 151| | fprintf(out, "invalid version %d\n", r->common.version); 152| |#endif 153| 6| return -1; 154| 6| } 155| | 156| |#if 0 157| | fprintf(out, "\n"); 158| |#endif 159| 7.42k| while (len > 0) { ------------------ | Branch (159:10): [True: 7.14k, False: 285] ------------------ 160| 7.14k| if (len < sizeof(rtcp_common_t)) { ------------------ | Branch (160:9): [True: 3, False: 7.13k] ------------------ 161| 3| return -1; 162| 3| } 163| 7.13k| size_t bincr = sizeof(uint32_t) * (ntohs(r->common.length) + 1); 164| | 165| 7.13k| switch (r->common.pt) { 166| 3.92k| case RTCP_SR: ------------------ | Branch (166:5): [True: 3.92k, False: 3.21k] ------------------ 167| 3.92k| 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: 31, False: 3.89k] | Branch (167:26): [True: 10, False: 3.88k] ------------------ 168| 41| goto invallen; 169| 3.88k| RSW_REST(-1, out, "{\n \"ssrc\": %lu,\n", ------------------ | | 118| 3.88k| { \ | | 119| 3.88k| int rval; \ | | 120| 3.91k| for (;;) { \ | | 121| 3.91k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 170| 3.91k| (unsigned long)ntohl(r->r.sr.ssrc)); | | ------------------ | | 122| 3.91k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.91k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.88k, False: 30] | | ------------------ | | 123| 3.91k| break; \ | | 124| 3.91k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 30|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 30] | | ------------------ | | 125| 30| return (exitcode); \ | | 126| 30| assert(rval == SBW_SHRT); \ | | 127| 30| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 30] | | ------------------ | | 128| 30| return (exitcode); \ | | 129| 30| } \ | | 130| 3.88k| } ------------------ | Branch (169:7): [True: 30, False: 0] ------------------ 170| 3.88k| (unsigned long)ntohl(r->r.sr.ssrc)); 171| 3.88k| 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.88k| { \ | | 119| 3.88k| int rval; \ | | 120| 3.96k| for (;;) { \ | | 121| 3.96k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 172| 19.8k| (unsigned long)ntohl(r->r.sr.ntp_sec), | | | | 173| 19.8k| (unsigned long)ntohl(r->r.sr.ntp_frac), | | | | 174| 19.8k| (unsigned long)ntohl(r->r.sr.rtp_ts), | | | | 175| 19.8k| (unsigned long)ntohl(r->r.sr.psent), | | | | 176| 19.8k| (unsigned long)ntohl(r->r.sr.osent)); | | ------------------ | | 122| 3.96k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.96k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.88k, False: 81] | | ------------------ | | 123| 3.96k| break; \ | | 124| 3.96k| 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.88k| } ------------------ | Branch (171:7): [True: 81, False: 0] ------------------ 172| 3.88k| (unsigned long)ntohl(r->r.sr.ntp_sec), 173| 3.88k| (unsigned long)ntohl(r->r.sr.ntp_frac), 174| 3.88k| (unsigned long)ntohl(r->r.sr.rtp_ts), 175| 3.88k| (unsigned long)ntohl(r->r.sr.psent), 176| 3.88k| (unsigned long)ntohl(r->r.sr.osent)); 177| 3.88k| RSW_REST(-1, out, " \"type\": %lu,\n", (unsigned long)r->common.pt); ------------------ | | 118| 3.88k| { \ | | 119| 3.88k| int rval; \ | | 120| 3.89k| for (;;) { \ | | 121| 3.89k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.89k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.89k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.88k, False: 18] | | ------------------ | | 123| 3.89k| break; \ | | 124| 3.89k| 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.88k| } ------------------ | Branch (177:7): [True: 18, False: 0] ------------------ 178| 3.88k| if (r->common.count > 0) ------------------ | Branch (178:11): [True: 3.11k, False: 762] ------------------ 179| 3.88k| RSW_REST(-1, out, " \"report_blocks\": [\n"); ------------------ | | 118| 3.11k| { \ | | 119| 3.11k| int rval; \ | | 120| 3.15k| for (;;) { \ | | 121| 3.15k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.15k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.15k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.11k, False: 31] | | ------------------ | | 123| 3.15k| break; \ | | 124| 3.15k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 31|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 31] | | ------------------ | | 125| 31| return (exitcode); \ | | 126| 31| assert(rval == SBW_SHRT); \ | | 127| 31| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 31] | | ------------------ | | 128| 31| return (exitcode); \ | | 129| 31| } \ | | 130| 3.11k| } ------------------ | Branch (179:9): [True: 31, False: 0] ------------------ 180| 7.86k| for (i = 0; i < r->common.count; i++) { ------------------ | Branch (180:19): [True: 3.98k, False: 3.88k] ------------------ 181| 3.98k| if (i > 0) ------------------ | Branch (181:13): [True: 867, False: 3.11k] ------------------ 182| 3.98k| RSW_REST(-1, out, " ,\n"); ------------------ | | 118| 867| { \ | | 119| 867| int rval; \ | | 120| 888| for (;;) { \ | | 121| 888| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 888| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 888|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 867, False: 21] | | ------------------ | | 123| 888| break; \ | | 124| 888| 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| 867| } ------------------ | Branch (182:11): [True: 21, False: 0] ------------------ 183| 3.98k| 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.98k| { \ | | 119| 3.98k| int rval; \ | | 120| 4.08k| for (;;) { \ | | 121| 4.08k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 184| 24.4k| (unsigned long)ntohl(r->r.sr.rr[i].ssrc), | | | | 185| 24.4k| (unsigned long)r->r.sr.rr[i].fraction, | | | | 186| 24.4k| (long)RTCP_GET_LOST(&r->r.sr.rr[i]), | | | | ------------------ | | | | | | 106| 4.08k|#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: 675, False: 3.40k] | | | | | | ------------------ | | | | ------------------ | | | | 187| 24.4k| (unsigned long)ntohl(r->r.sr.rr[i].last_seq), | | | | 188| 24.4k| (unsigned long)ntohl(r->r.sr.rr[i].jitter), | | | | 189| 24.4k| (unsigned long)ntohl(r->r.sr.rr[i].lsr), | | | | 190| 24.4k| (unsigned long)ntohl(r->r.sr.rr[i].dlsr)); | | ------------------ | | 122| 4.08k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 4.08k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.98k, False: 96] | | ------------------ | | 123| 4.08k| break; \ | | 124| 4.08k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 96|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 96] | | ------------------ | | 125| 96| return (exitcode); \ | | 126| 96| assert(rval == SBW_SHRT); \ | | 127| 96| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 96] | | ------------------ | | 128| 96| return (exitcode); \ | | 129| 96| } \ | | 130| 3.98k| } ------------------ | Branch (183:9): [True: 96, False: 0] ------------------ 184| 3.98k| (unsigned long)ntohl(r->r.sr.rr[i].ssrc), 185| 3.98k| (unsigned long)r->r.sr.rr[i].fraction, 186| 3.98k| (long)RTCP_GET_LOST(&r->r.sr.rr[i]), 187| 3.98k| (unsigned long)ntohl(r->r.sr.rr[i].last_seq), 188| 3.98k| (unsigned long)ntohl(r->r.sr.rr[i].jitter), 189| 3.98k| (unsigned long)ntohl(r->r.sr.rr[i].lsr), 190| 3.98k| (unsigned long)ntohl(r->r.sr.rr[i].dlsr)); 191| 3.98k| } 192| 3.88k| if (r->common.count > 0) ------------------ | Branch (192:11): [True: 3.11k, False: 762] ------------------ 193| 3.88k| RSW_REST(-1, out, " ],\n"); ------------------ | | 118| 3.11k| { \ | | 119| 3.11k| int rval; \ | | 120| 3.13k| for (;;) { \ | | 121| 3.13k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.13k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.13k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.11k, False: 18] | | ------------------ | | 123| 3.13k| break; \ | | 124| 3.13k| 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.11k| } ------------------ | Branch (193:9): [True: 18, False: 0] ------------------ 194| 3.88k| RSW_REST(-1, out, " \"report_count\": %lu\n", (unsigned long)r->common.count); ------------------ | | 118| 3.88k| { \ | | 119| 3.88k| int rval; \ | | 120| 3.94k| for (;;) { \ | | 121| 3.94k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.94k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.94k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.88k, False: 66] | | ------------------ | | 123| 3.94k| break; \ | | 124| 3.94k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 66|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 66] | | ------------------ | | 125| 66| return (exitcode); \ | | 126| 66| assert(rval == SBW_SHRT); \ | | 127| 66| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 66] | | ------------------ | | 128| 66| return (exitcode); \ | | 129| 66| } \ | | 130| 3.88k| } ------------------ | Branch (194:7): [True: 66, False: 0] ------------------ 195| 3.88k| RSW_REST(-1, out, "}"); ------------------ | | 118| 3.88k| { \ | | 119| 3.88k| int rval; \ | | 120| 3.90k| for (;;) { \ | | 121| 3.90k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.90k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.90k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.88k, False: 28] | | ------------------ | | 123| 3.90k| break; \ | | 124| 3.90k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 28|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 28] | | ------------------ | | 125| 28| return (exitcode); \ | | 126| 28| assert(rval == SBW_SHRT); \ | | 127| 28| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 28] | | ------------------ | | 128| 28| return (exitcode); \ | | 129| 28| } \ | | 130| 3.88k| } ------------------ | Branch (195:7): [True: 28, False: 0] ------------------ 196| 3.88k| break; 197| | 198| 2.58k| case RTCP_RR: ------------------ | Branch (198:5): [True: 2.58k, False: 4.55k] ------------------ 199| 2.58k| 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: 37, False: 2.55k] | Branch (199:26): [True: 8, False: 2.54k] ------------------ 200| 45| goto invallen; 201| 2.54k| RSW_REST(-1, out, "{\n \"ssrc\": %lu,\n", ------------------ | | 118| 2.54k| { \ | | 119| 2.54k| int rval; \ | | 120| 2.57k| for (;;) { \ | | 121| 2.57k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 202| 2.57k| (unsigned long)ntohl(r->r.rr.ssrc)); | | ------------------ | | 122| 2.57k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.57k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.54k, False: 27] | | ------------------ | | 123| 2.57k| break; \ | | 124| 2.57k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 27|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 27] | | ------------------ | | 125| 27| return (exitcode); \ | | 126| 27| assert(rval == SBW_SHRT); \ | | 127| 27| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 27] | | ------------------ | | 128| 27| return (exitcode); \ | | 129| 27| } \ | | 130| 2.54k| } ------------------ | Branch (201:7): [True: 27, False: 0] ------------------ 202| 2.54k| (unsigned long)ntohl(r->r.rr.ssrc)); 203| 2.54k| RSW_REST(-1, out, " \"type\": %lu,\n", (unsigned long)r->common.pt); ------------------ | | 118| 2.54k| { \ | | 119| 2.54k| int rval; \ | | 120| 2.56k| for (;;) { \ | | 121| 2.56k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.56k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.56k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.54k, False: 24] | | ------------------ | | 123| 2.56k| break; \ | | 124| 2.56k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 24|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 24] | | ------------------ | | 125| 24| return (exitcode); \ | | 126| 24| assert(rval == SBW_SHRT); \ | | 127| 24| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 24] | | ------------------ | | 128| 24| return (exitcode); \ | | 129| 24| } \ | | 130| 2.54k| } ------------------ | Branch (203:7): [True: 24, False: 0] ------------------ 204| 2.54k| if (r->common.count > 0) ------------------ | Branch (204:11): [True: 1.13k, False: 1.40k] ------------------ 205| 2.54k| RSW_REST(-1, out, " \"report_blocks\": [\n"); ------------------ | | 118| 1.13k| { \ | | 119| 1.13k| int rval; \ | | 120| 1.15k| for (;;) { \ | | 121| 1.15k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 1.15k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 1.15k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 1.13k, False: 19] | | ------------------ | | 123| 1.15k| break; \ | | 124| 1.15k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 19|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 19] | | ------------------ | | 125| 19| return (exitcode); \ | | 126| 19| assert(rval == SBW_SHRT); \ | | 127| 19| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 19] | | ------------------ | | 128| 19| return (exitcode); \ | | 129| 19| } \ | | 130| 1.13k| } ------------------ | Branch (205:9): [True: 19, False: 0] ------------------ 206| 4.56k| for (i = 0; i < r->common.count; i++) { ------------------ | Branch (206:19): [True: 2.02k, False: 2.54k] ------------------ 207| 2.02k| if (i > 0) ------------------ | Branch (207:13): [True: 886, False: 1.13k] ------------------ 208| 2.02k| RSW_REST(-1, out, " ,\n"); ------------------ | | 118| 886| { \ | | 119| 886| int rval; \ | | 120| 902| for (;;) { \ | | 121| 902| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 902| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 902|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 886, False: 16] | | ------------------ | | 123| 902| break; \ | | 124| 902| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 16|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 16] | | ------------------ | | 125| 16| return (exitcode); \ | | 126| 16| assert(rval == SBW_SHRT); \ | | 127| 16| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 16] | | ------------------ | | 128| 16| return (exitcode); \ | | 129| 16| } \ | | 130| 886| } ------------------ | Branch (208:11): [True: 16, False: 0] ------------------ 209| 2.02k| RSW_REST(-1, out, " {\n \"source_ssrc\": %lu,\n \"fraction_lost\": %lu,\n \"packets_lost\": %ld,\n \"highest_seq_no\": %lu,\n \"ia_jitter\": %lu,\n \"lsr\": %lu,\n \"dlsr\": %lu\n }\n", ------------------ | | 118| 2.02k| { \ | | 119| 2.02k| int rval; \ | | 120| 2.15k| for (;;) { \ | | 121| 2.15k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 210| 12.9k| (unsigned long)ntohl(r->r.rr.rr[i].ssrc), | | | | 211| 12.9k| (unsigned long)r->r.rr.rr[i].fraction, | | | | 212| 12.9k| (long)RTCP_GET_LOST(&r->r.rr.rr[i]), | | | | ------------------ | | | | | | 106| 2.15k|#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: 564, False: 1.58k] | | | | | | ------------------ | | | | ------------------ | | | | 213| 12.9k| (unsigned long)ntohl(r->r.rr.rr[i].last_seq), | | | | 214| 12.9k| (unsigned long)ntohl(r->r.rr.rr[i].jitter), | | | | 215| 12.9k| (unsigned long)ntohl(r->r.rr.rr[i].lsr), | | | | 216| 12.9k| (unsigned long)ntohl(r->r.rr.rr[i].dlsr)); | | ------------------ | | 122| 2.15k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.15k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.02k, False: 132] | | ------------------ | | 123| 2.15k| break; \ | | 124| 2.15k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 132|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 132] | | ------------------ | | 125| 132| return (exitcode); \ | | 126| 132| assert(rval == SBW_SHRT); \ | | 127| 132| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 132] | | ------------------ | | 128| 132| return (exitcode); \ | | 129| 132| } \ | | 130| 2.02k| } ------------------ | Branch (209:9): [True: 132, False: 0] ------------------ 210| 2.02k| (unsigned long)ntohl(r->r.rr.rr[i].ssrc), 211| 2.02k| (unsigned long)r->r.rr.rr[i].fraction, 212| 2.02k| (long)RTCP_GET_LOST(&r->r.rr.rr[i]), 213| 2.02k| (unsigned long)ntohl(r->r.rr.rr[i].last_seq), 214| 2.02k| (unsigned long)ntohl(r->r.rr.rr[i].jitter), 215| 2.02k| (unsigned long)ntohl(r->r.rr.rr[i].lsr), 216| 2.02k| (unsigned long)ntohl(r->r.rr.rr[i].dlsr)); 217| 2.02k| } 218| 2.54k| if (r->common.count > 0) ------------------ | Branch (218:11): [True: 1.13k, False: 1.40k] ------------------ 219| 2.54k| RSW_REST(-1, out, " ],\n"); ------------------ | | 118| 1.13k| { \ | | 119| 1.13k| int rval; \ | | 120| 1.15k| for (;;) { \ | | 121| 1.15k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 1.15k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 1.15k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 1.13k, False: 22] | | ------------------ | | 123| 1.15k| break; \ | | 124| 1.15k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 22|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 22] | | ------------------ | | 125| 22| return (exitcode); \ | | 126| 22| assert(rval == SBW_SHRT); \ | | 127| 22| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 22] | | ------------------ | | 128| 22| return (exitcode); \ | | 129| 22| } \ | | 130| 1.13k| } ------------------ | Branch (219:9): [True: 22, False: 0] ------------------ 220| 2.54k| RSW_REST(-1, out, " \"report_count\": %lu\n", (unsigned long)r->common.count); ------------------ | | 118| 2.54k| { \ | | 119| 2.54k| int rval; \ | | 120| 2.58k| for (;;) { \ | | 121| 2.58k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.58k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.58k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.54k, False: 44] | | ------------------ | | 123| 2.58k| break; \ | | 124| 2.58k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 44|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 44] | | ------------------ | | 125| 44| return (exitcode); \ | | 126| 44| assert(rval == SBW_SHRT); \ | | 127| 44| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 44] | | ------------------ | | 128| 44| return (exitcode); \ | | 129| 44| } \ | | 130| 2.54k| } ------------------ | Branch (220:7): [True: 44, False: 0] ------------------ 221| 2.54k| RSW_REST(-1, out, "}"); ------------------ | | 118| 2.54k| { \ | | 119| 2.54k| int rval; \ | | 120| 2.57k| for (;;) { \ | | 121| 2.57k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.57k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.57k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.54k, False: 27] | | ------------------ | | 123| 2.57k| break; \ | | 124| 2.57k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 27|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 27] | | ------------------ | | 125| 27| return (exitcode); \ | | 126| 27| assert(rval == SBW_SHRT); \ | | 127| 27| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 27] | | ------------------ | | 128| 27| return (exitcode); \ | | 129| 27| } \ | | 130| 2.54k| } ------------------ | Branch (221:7): [True: 27, False: 0] ------------------ 222| 2.54k| break; 223| | 224| 1| case RTCP_SDES: ------------------ | Branch (224:5): [True: 1, False: 7.13k] ------------------ 225| |#if 0 226| | fprintf(out, " (SDES p=%d count=%d len=%d\n", 227| | r->common.p, r->common.count, ntohs(r->common.length)); 228| | cp = (const char *)&r->r.sdes; 229| | for (i = 0; i < r->common.count; i++) { 230| | int remaining = (ntohs(r->common.length) << 2) - 231| | (cp - (const char *)&r->r.sdes); 232| | fprintf(out, " (src=0x%lx ", 233| | (unsigned long)ntohl(((struct rtcp_sdes *)cp)->src)); 234| | if (remaining > 0) { 235| | cp = rtp_read_sdes(out, cp, 236| | (ntohs(r->common.length) << 2) - (cp - (const char *)&r->r.sdes)); 237| | if (!cp) return -1; 238| | } else { 239| | fprintf(stderr, "Missing at least %d bytes.\n", -remaining); 240| | return -1; 241| | } 242| | fprintf(out, ")\n"); 243| | } 244| | fprintf(out, " )\n"); 245| |#endif 246| 1| break; 247| | 248| 0| case RTCP_BYE: ------------------ | Branch (248:5): [True: 0, False: 7.13k] ------------------ 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| 628| default: ------------------ | Branch (266:5): [True: 628, False: 6.51k] ------------------ 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| 628| break; 272| 7.13k| } 273| 7.05k| len -= bincr; 274| 7.05k| r = (const rtcp_t *)((const char *)r + bincr); 275| 7.05k| } 276| | 277| 285| return len; 278| | 279| 86|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| 86| 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| 382|{ 35| 382| struct rtpp_sbuf *sbp; 36| | 37| 382| if (rtcp_dlen > MAX_RPKT_LEN) ------------------ | | 37| 382|#define MAX_RPKT_LEN 8192 ------------------ | Branch (37:9): [True: 0, False: 382] ------------------ 38| 0| return (0); 39| | 40| 382| sbp = rtpp_sbuf_ctor(512); 41| 382| assert (sbp != NULL); ------------------ | Branch (41:5): [True: 0, False: 382] | Branch (41:5): [True: 382, False: 0] ------------------ 42| |#if 0 43| | for (size_t i = 0; i < rtcp_dlen; i++) { 44| | char bf[3]; 45| | sprintf(bf, "%.2x", rtcp_data[i]); 46| | write(STDERR_FILENO, bf, 2); 47| | } 48| | write(STDERR_FILENO, "\n", 1); 49| | fsync(STDERR_FILENO); 50| |#endif 51| 382| rtcp2json(sbp, rtcp_data, rtcp_dlen); 52| 382| rtpp_sbuf_dtor(sbp); 53| | 54| 382| return (0); 55| 382|} rtpp_static_modules_lookup: 39| 2|{ 40| 2| const struct rtpp_minfo **tp; 41| | 42| 6| SET_FOREACH(tp, rtpp_modules) { ------------------ | | 118| 6| for (pvar = SET_BEGIN(set); pvar < SET_LIMIT(set); pvar++) | | ------------------ | | | | 106| 2| (&__RTPP_CONCAT(__start_set_,set)) | | | | ------------------ | | | | | | 35| 2|#define __RTPP_CONCAT(x,y) __RTPP_CONCAT1(x,y) | | | | | | ------------------ | | | | | | | | 34| 2|#define __RTPP_CONCAT1(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ | | for (pvar = SET_BEGIN(set); pvar < SET_LIMIT(set); pvar++) | | ------------------ | | | | 108| 6| (&__RTPP_CONCAT(__stop_set_,set)) | | | | ------------------ | | | | | | 35| 6|#define __RTPP_CONCAT(x,y) __RTPP_CONCAT1(x,y) | | | | | | ------------------ | | | | | | | | 34| 6|#define __RTPP_CONCAT1(x,y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (118:30): [True: 6, False: 0] | | ------------------ ------------------ 43| 6| const struct rtpp_minfo *mp = *tp; 44| 6| if (strcmp(mp->descr.name, name) == 0) { ------------------ | Branch (44:13): [True: 2, False: 4] ------------------ 45| 2| return (mp); 46| 2| } 47| 6| } 48| 0| return (NULL); 49| 2|} rtpp_sbuf_write: 42| 46.5k|{ 43| 46.5k| va_list ap; 44| 46.5k| int rlen, len; 45| | 46| 46.5k| len = sbp->alen - RS_ULEN(sbp); ------------------ | | 40| 46.5k|#define RS_ULEN(sbp) ((int)((sbp)->cp - (sbp)->bp)) ------------------ 47| 46.5k| assert(len > 0); ------------------ | Branch (47:5): [True: 0, False: 46.5k] | Branch (47:5): [True: 46.5k, False: 0] ------------------ 48| 46.5k| va_start(ap, format); 49| 46.5k| rlen = vsnprintf(sbp->cp, len, format, ap); 50| 46.5k| va_end(ap); 51| 46.5k| if (rlen < 0) ------------------ | Branch (51:9): [True: 0, False: 46.5k] ------------------ 52| 0| return (SBW_ERR); ------------------ | | 37| 0|#define SBW_ERR (-1) ------------------ 53| 46.5k| if (rlen >= len) { ------------------ | Branch (53:9): [True: 700, False: 45.8k] ------------------ 54| 700| sbp->cp[0] = '\0'; 55| 700| return (SBW_SHRT); ------------------ | | 38| 700|#define SBW_SHRT (-2) ------------------ 56| 700| } 57| 45.8k| sbp->cp += rlen; 58| 45.8k| return (SBW_OK); ------------------ | | 36| 45.8k|#define SBW_OK (0) ------------------ 59| 46.5k|} rtpp_sbuf_ctor: 67| 382|{ 68| 382| struct rtpp_sbuf *sbp; 69| | 70| 382|#if !defined(RTPP_CHECK_LEAKS) 71| 382| sbp = malloc(sizeof(struct rtpp_sbuf)); 72| |#else 73| | sbp = rtpp_memdeb_malloc(sizeof(struct rtpp_sbuf), memdeb_p, mlp); 74| |#endif 75| 382| if (sbp == NULL) ------------------ | Branch (75:9): [True: 0, False: 382] ------------------ 76| 0| return (NULL); 77| 382| memset(sbp, '\0', sizeof(struct rtpp_sbuf)); 78| 382|#if !defined(RTPP_CHECK_LEAKS) 79| 382| sbp->bp = sbp->cp = malloc(ilen); 80| |#else 81| | sbp->bp = sbp->cp = rtpp_memdeb_malloc(ilen, memdeb_p, mlp); 82| |#endif 83| 382| if (sbp->bp == NULL) { ------------------ | Branch (83:9): [True: 0, False: 382] ------------------ 84| 0| free(sbp); 85| 0| return (NULL); 86| 0| } 87| 382| sbp->cp[0] = '\0'; 88| 382| sbp->alen = ilen; 89| 382| return(sbp); 90| 382|} rtpp_sbuf_dtor: 98| 382|{ 99| | 100| 382|#if !defined(RTPP_CHECK_LEAKS) 101| 382| free(sbp->bp); 102| 382| free(sbp); 103| |#else 104| | rtpp_memdeb_free(sbp->bp, memdeb_p, mlp); 105| | rtpp_memdeb_free(sbp, memdeb_p, mlp); 106| |#endif 107| 382|} rtpp_sbuf_extend: 115| 700|{ 116| 700| void *nbp, *ncp; 117| | 118| 700| assert(nlen > sbp->alen); ------------------ | Branch (118:5): [True: 0, False: 700] | Branch (118:5): [True: 700, False: 0] ------------------ 119| 700|#if !defined(RTPP_CHECK_LEAKS) 120| 700| nbp = realloc(sbp->bp, nlen); 121| |#else 122| | nbp = rtpp_memdeb_realloc(sbp->bp, nlen, memdeb_p, mlp); 123| |#endif 124| 700| if (nbp == NULL) ------------------ | Branch (124:9): [True: 0, False: 700] ------------------ 125| 0| return (-1); 126| 700| sbp->alen = nlen; 127| 700| if (sbp->bp != nbp) { ------------------ | Branch (127:9): [True: 313, False: 387] ------------------ 128| 313| ncp = nbp + RS_ULEN(sbp); ------------------ | | 40| 313|#define RS_ULEN(sbp) ((int)((sbp)->cp - (sbp)->bp)) ------------------ 129| 313| sbp->cp = ncp; 130| 313| sbp->bp = nbp; 131| 313| } 132| 700| return (0); 133| 700|}