rtcp2json: 137| 380|{ 138| 380| const rtcp_t *r; /* RTCP header */ 139| 380| int i; 140| |#if 0 141| | const char *cp; 142| |#endif 143| | 144| 380| if (len < sizeof(rtcp_common_t)) { ------------------ | Branch (144:7): [True: 2, False: 378] ------------------ 145| 2| return -1; 146| 2| } 147| 378| r = (rtcp_t *)buf; 148| | /* Backwards compatibility: VAT header. */ 149| 378| if (r->common.version != RTP_VERSION) { ------------------ | | 41| 378|#define RTP_VERSION 2 ------------------ | Branch (149:7): [True: 3, False: 375] ------------------ 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.89k| while (len > 0) { ------------------ | Branch (159:10): [True: 6.60k, False: 283] ------------------ 160| 6.60k| if (len < sizeof(rtcp_common_t)) { ------------------ | Branch (160:9): [True: 6, False: 6.60k] ------------------ 161| 6| return -1; 162| 6| } 163| 6.60k| size_t bincr = sizeof(uint32_t) * (ntohs(r->common.length) + 1); 164| | 165| 6.60k| switch (r->common.pt) { 166| 3.83k| case RTCP_SR: ------------------ | Branch (166:5): [True: 3.83k, False: 2.76k] ------------------ 167| 3.83k| 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.79k] | Branch (167:26): [True: 11, False: 3.78k] ------------------ 168| 49| goto invallen; 169| 3.78k| RSW_REST(-1, out, "{\n \"ssrc\": %lu,\n", ------------------ | | 118| 3.78k| { \ | | 119| 3.78k| int rval; \ | | 120| 3.83k| for (;;) { \ | | 121| 3.83k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 170| 3.83k| (unsigned long)ntohl(r->r.sr.ssrc)); | | ------------------ | | 122| 3.83k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.83k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.78k, False: 51] | | ------------------ | | 123| 3.83k| break; \ | | 124| 3.83k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 51|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 51] | | ------------------ | | 125| 51| return (exitcode); \ | | 126| 51| assert(rval == SBW_SHRT); \ | | 127| 51| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 51] | | ------------------ | | 128| 51| return (exitcode); \ | | 129| 51| } \ | | 130| 3.78k| } ------------------ | Branch (169:7): [True: 51, False: 0] ------------------ 170| 3.78k| (unsigned long)ntohl(r->r.sr.ssrc)); 171| 3.78k| 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.78k| { \ | | 119| 3.78k| int rval; \ | | 120| 3.86k| for (;;) { \ | | 121| 3.86k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 172| 19.3k| (unsigned long)ntohl(r->r.sr.ntp_sec), | | | | 173| 19.3k| (unsigned long)ntohl(r->r.sr.ntp_frac), | | | | 174| 19.3k| (unsigned long)ntohl(r->r.sr.rtp_ts), | | | | 175| 19.3k| (unsigned long)ntohl(r->r.sr.psent), | | | | 176| 19.3k| (unsigned long)ntohl(r->r.sr.osent)); | | ------------------ | | 122| 3.86k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.86k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.78k, False: 79] | | ------------------ | | 123| 3.86k| break; \ | | 124| 3.86k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 79|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 79] | | ------------------ | | 125| 79| return (exitcode); \ | | 126| 79| assert(rval == SBW_SHRT); \ | | 127| 79| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 79] | | ------------------ | | 128| 79| return (exitcode); \ | | 129| 79| } \ | | 130| 3.78k| } ------------------ | Branch (171:7): [True: 79, False: 0] ------------------ 172| 3.78k| (unsigned long)ntohl(r->r.sr.ntp_sec), 173| 3.78k| (unsigned long)ntohl(r->r.sr.ntp_frac), 174| 3.78k| (unsigned long)ntohl(r->r.sr.rtp_ts), 175| 3.78k| (unsigned long)ntohl(r->r.sr.psent), 176| 3.78k| (unsigned long)ntohl(r->r.sr.osent)); 177| 3.78k| RSW_REST(-1, out, " \"type\": %lu,\n", (unsigned long)r->common.pt); ------------------ | | 118| 3.78k| { \ | | 119| 3.78k| int rval; \ | | 120| 3.80k| for (;;) { \ | | 121| 3.80k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.80k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.80k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.78k, False: 18] | | ------------------ | | 123| 3.80k| break; \ | | 124| 3.80k| 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.78k| } ------------------ | Branch (177:7): [True: 18, False: 0] ------------------ 178| 3.78k| if (r->common.count > 0) ------------------ | Branch (178:11): [True: 2.99k, False: 789] ------------------ 179| 3.78k| RSW_REST(-1, out, " \"report_blocks\": [\n"); ------------------ | | 118| 2.99k| { \ | | 119| 2.99k| int rval; \ | | 120| 3.03k| for (;;) { \ | | 121| 3.03k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.03k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.03k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.99k, False: 34] | | ------------------ | | 123| 3.03k| break; \ | | 124| 3.03k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 34|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 34] | | ------------------ | | 125| 34| return (exitcode); \ | | 126| 34| assert(rval == SBW_SHRT); \ | | 127| 34| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 34] | | ------------------ | | 128| 34| return (exitcode); \ | | 129| 34| } \ | | 130| 2.99k| } ------------------ | Branch (179:9): [True: 34, False: 0] ------------------ 180| 7.87k| for (i = 0; i < r->common.count; i++) { ------------------ | Branch (180:19): [True: 4.08k, False: 3.78k] ------------------ 181| 4.08k| if (i > 0) ------------------ | Branch (181:13): [True: 1.08k, False: 2.99k] ------------------ 182| 4.08k| RSW_REST(-1, out, " ,\n"); ------------------ | | 118| 1.08k| { \ | | 119| 1.08k| int rval; \ | | 120| 1.10k| for (;;) { \ | | 121| 1.10k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 1.10k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 1.10k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 1.08k, False: 20] | | ------------------ | | 123| 1.10k| break; \ | | 124| 1.10k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 20|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 20] | | ------------------ | | 125| 20| return (exitcode); \ | | 126| 20| assert(rval == SBW_SHRT); \ | | 127| 20| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 20] | | ------------------ | | 128| 20| return (exitcode); \ | | 129| 20| } \ | | 130| 1.08k| } ------------------ | Branch (182:11): [True: 20, False: 0] ------------------ 183| 4.08k| 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| 4.08k| { \ | | 119| 4.08k| int rval; \ | | 120| 4.20k| for (;;) { \ | | 121| 4.20k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 184| 25.2k| (unsigned long)ntohl(r->r.sr.rr[i].ssrc), | | | | 185| 25.2k| (unsigned long)r->r.sr.rr[i].fraction, | | | | 186| 25.2k| (long)RTCP_GET_LOST(&r->r.sr.rr[i]), | | | | ------------------ | | | | | | 106| 4.20k|#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: 748, False: 3.45k] | | | | | | ------------------ | | | | ------------------ | | | | 187| 25.2k| (unsigned long)ntohl(r->r.sr.rr[i].last_seq), | | | | 188| 25.2k| (unsigned long)ntohl(r->r.sr.rr[i].jitter), | | | | 189| 25.2k| (unsigned long)ntohl(r->r.sr.rr[i].lsr), | | | | 190| 25.2k| (unsigned long)ntohl(r->r.sr.rr[i].dlsr)); | | ------------------ | | 122| 4.20k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 4.20k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 4.08k, False: 118] | | ------------------ | | 123| 4.20k| break; \ | | 124| 4.20k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 118|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 118] | | ------------------ | | 125| 118| return (exitcode); \ | | 126| 118| assert(rval == SBW_SHRT); \ | | 127| 118| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 118] | | ------------------ | | 128| 118| return (exitcode); \ | | 129| 118| } \ | | 130| 4.08k| } ------------------ | Branch (183:9): [True: 118, False: 0] ------------------ 184| 4.08k| (unsigned long)ntohl(r->r.sr.rr[i].ssrc), 185| 4.08k| (unsigned long)r->r.sr.rr[i].fraction, 186| 4.08k| (long)RTCP_GET_LOST(&r->r.sr.rr[i]), 187| 4.08k| (unsigned long)ntohl(r->r.sr.rr[i].last_seq), 188| 4.08k| (unsigned long)ntohl(r->r.sr.rr[i].jitter), 189| 4.08k| (unsigned long)ntohl(r->r.sr.rr[i].lsr), 190| 4.08k| (unsigned long)ntohl(r->r.sr.rr[i].dlsr)); 191| 4.08k| } 192| 3.78k| if (r->common.count > 0) ------------------ | Branch (192:11): [True: 2.99k, False: 789] ------------------ 193| 3.78k| RSW_REST(-1, out, " ],\n"); ------------------ | | 118| 2.99k| { \ | | 119| 2.99k| int rval; \ | | 120| 3.01k| for (;;) { \ | | 121| 3.01k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.01k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.01k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.99k, False: 19] | | ------------------ | | 123| 3.01k| break; \ | | 124| 3.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| 2.99k| } ------------------ | Branch (193:9): [True: 19, False: 0] ------------------ 194| 3.78k| RSW_REST(-1, out, " \"report_count\": %lu\n", (unsigned long)r->common.count); ------------------ | | 118| 3.78k| { \ | | 119| 3.78k| int rval; \ | | 120| 3.82k| for (;;) { \ | | 121| 3.82k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.82k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.82k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.78k, False: 39] | | ------------------ | | 123| 3.82k| break; \ | | 124| 3.82k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 39|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 39] | | ------------------ | | 125| 39| return (exitcode); \ | | 126| 39| assert(rval == SBW_SHRT); \ | | 127| 39| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 39] | | ------------------ | | 128| 39| return (exitcode); \ | | 129| 39| } \ | | 130| 3.78k| } ------------------ | Branch (194:7): [True: 39, False: 0] ------------------ 195| 3.78k| RSW_REST(-1, out, "}"); ------------------ | | 118| 3.78k| { \ | | 119| 3.78k| int rval; \ | | 120| 3.81k| for (;;) { \ | | 121| 3.81k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 3.81k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 3.81k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 3.78k, False: 28] | | ------------------ | | 123| 3.81k| break; \ | | 124| 3.81k| 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.78k| } ------------------ | Branch (195:7): [True: 28, False: 0] ------------------ 196| 3.78k| break; 197| | 198| 2.47k| case RTCP_RR: ------------------ | Branch (198:5): [True: 2.47k, False: 4.12k] ------------------ 199| 2.47k| 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: 29, False: 2.45k] | Branch (199:26): [True: 8, False: 2.44k] ------------------ 200| 37| goto invallen; 201| 2.44k| RSW_REST(-1, out, "{\n \"ssrc\": %lu,\n", ------------------ | | 118| 2.44k| { \ | | 119| 2.44k| int rval; \ | | 120| 2.47k| for (;;) { \ | | 121| 2.47k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 202| 2.47k| (unsigned long)ntohl(r->r.rr.ssrc)); | | ------------------ | | 122| 2.47k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.47k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.44k, False: 29] | | ------------------ | | 123| 2.47k| break; \ | | 124| 2.47k| 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.44k| } ------------------ | Branch (201:7): [True: 29, False: 0] ------------------ 202| 2.44k| (unsigned long)ntohl(r->r.rr.ssrc)); 203| 2.44k| RSW_REST(-1, out, " \"type\": %lu,\n", (unsigned long)r->common.pt); ------------------ | | 118| 2.44k| { \ | | 119| 2.44k| int rval; \ | | 120| 2.47k| for (;;) { \ | | 121| 2.47k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.47k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.47k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.44k, False: 35] | | ------------------ | | 123| 2.47k| break; \ | | 124| 2.47k| 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.44k| } ------------------ | Branch (203:7): [True: 35, False: 0] ------------------ 204| 2.44k| if (r->common.count > 0) ------------------ | Branch (204:11): [True: 1.28k, False: 1.15k] ------------------ 205| 2.44k| RSW_REST(-1, out, " \"report_blocks\": [\n"); ------------------ | | 118| 1.28k| { \ | | 119| 1.28k| int rval; \ | | 120| 1.30k| for (;;) { \ | | 121| 1.30k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 1.30k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 1.30k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 1.28k, False: 19] | | ------------------ | | 123| 1.30k| break; \ | | 124| 1.30k| 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.28k| } ------------------ | Branch (205:9): [True: 19, False: 0] ------------------ 206| 4.63k| for (i = 0; i < r->common.count; i++) { ------------------ | Branch (206:19): [True: 2.19k, False: 2.44k] ------------------ 207| 2.19k| if (i > 0) ------------------ | Branch (207:13): [True: 913, False: 1.28k] ------------------ 208| 2.19k| RSW_REST(-1, out, " ,\n"); ------------------ | | 118| 913| { \ | | 119| 913| int rval; \ | | 120| 932| for (;;) { \ | | 121| 932| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 932| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 932|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 913, False: 19] | | ------------------ | | 123| 932| break; \ | | 124| 932| 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| 913| } ------------------ | Branch (208:11): [True: 19, False: 0] ------------------ 209| 2.19k| 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.19k| { \ | | 119| 2.19k| int rval; \ | | 120| 2.32k| for (;;) { \ | | 121| 2.32k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | ------------------ | | | | 210| 13.9k| (unsigned long)ntohl(r->r.rr.rr[i].ssrc), | | | | 211| 13.9k| (unsigned long)r->r.rr.rr[i].fraction, | | | | 212| 13.9k| (long)RTCP_GET_LOST(&r->r.rr.rr[i]), | | | | ------------------ | | | | | | 106| 2.32k|#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: 588, False: 1.74k] | | | | | | ------------------ | | | | ------------------ | | | | 213| 13.9k| (unsigned long)ntohl(r->r.rr.rr[i].last_seq), | | | | 214| 13.9k| (unsigned long)ntohl(r->r.rr.rr[i].jitter), | | | | 215| 13.9k| (unsigned long)ntohl(r->r.rr.rr[i].lsr), | | | | 216| 13.9k| (unsigned long)ntohl(r->r.rr.rr[i].dlsr)); | | ------------------ | | 122| 2.32k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.32k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.19k, False: 133] | | ------------------ | | 123| 2.32k| break; \ | | 124| 2.32k| if (rval == SBW_ERR) \ | | ------------------ | | | | 37| 133|#define SBW_ERR (-1) | | ------------------ | | | Branch (124:11): [True: 0, False: 133] | | ------------------ | | 125| 133| return (exitcode); \ | | 126| 133| assert(rval == SBW_SHRT); \ | | 127| 133| if (rtpp_sbuf_extend((sbc), (sbc)->alen * 2) != 0) \ | | ------------------ | | | Branch (127:11): [True: 0, False: 133] | | ------------------ | | 128| 133| return (exitcode); \ | | 129| 133| } \ | | 130| 2.19k| } ------------------ | Branch (209:9): [True: 133, False: 0] ------------------ 210| 2.19k| (unsigned long)ntohl(r->r.rr.rr[i].ssrc), 211| 2.19k| (unsigned long)r->r.rr.rr[i].fraction, 212| 2.19k| (long)RTCP_GET_LOST(&r->r.rr.rr[i]), 213| 2.19k| (unsigned long)ntohl(r->r.rr.rr[i].last_seq), 214| 2.19k| (unsigned long)ntohl(r->r.rr.rr[i].jitter), 215| 2.19k| (unsigned long)ntohl(r->r.rr.rr[i].lsr), 216| 2.19k| (unsigned long)ntohl(r->r.rr.rr[i].dlsr)); 217| 2.19k| } 218| 2.44k| if (r->common.count > 0) ------------------ | Branch (218:11): [True: 1.28k, False: 1.15k] ------------------ 219| 2.44k| RSW_REST(-1, out, " ],\n"); ------------------ | | 118| 1.28k| { \ | | 119| 1.28k| int rval; \ | | 120| 1.31k| for (;;) { \ | | 121| 1.31k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 1.31k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 1.31k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 1.28k, False: 27] | | ------------------ | | 123| 1.31k| break; \ | | 124| 1.31k| 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| 1.28k| } ------------------ | Branch (219:9): [True: 27, False: 0] ------------------ 220| 2.44k| RSW_REST(-1, out, " \"report_count\": %lu\n", (unsigned long)r->common.count); ------------------ | | 118| 2.44k| { \ | | 119| 2.44k| int rval; \ | | 120| 2.47k| for (;;) { \ | | 121| 2.47k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.47k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.47k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.44k, False: 32] | | ------------------ | | 123| 2.47k| break; \ | | 124| 2.47k| 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.44k| } ------------------ | Branch (220:7): [True: 32, False: 0] ------------------ 221| 2.44k| RSW_REST(-1, out, "}"); ------------------ | | 118| 2.44k| { \ | | 119| 2.44k| int rval; \ | | 120| 2.47k| for (;;) { \ | | 121| 2.47k| rval = rtpp_sbuf_write((sbc), (format), ## args); \ | | 122| 2.47k| if (rval == SBW_OK) \ | | ------------------ | | | | 36| 2.47k|#define SBW_OK (0) | | ------------------ | | | Branch (122:11): [True: 2.44k, False: 28] | | ------------------ | | 123| 2.47k| break; \ | | 124| 2.47k| 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| 2.44k| } ------------------ | Branch (221:7): [True: 28, False: 0] ------------------ 222| 2.44k| break; 223| | 224| 1| case RTCP_SDES: ------------------ | Branch (224:5): [True: 1, False: 6.60k] ------------------ 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: 6.60k] ------------------ 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: 6.31k] ------------------ 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.60k| } 273| 6.51k| len -= bincr; 274| 6.51k| r = (const rtcp_t *)((const char *)r + bincr); 275| 6.51k| } 276| | 277| 283| 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| 375|} 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| 380|{ 35| 380| struct rtpp_sbuf *sbp; 36| | 37| 380| if (rtcp_dlen > MAX_RPKT_LEN) ------------------ | | 37| 380|#define MAX_RPKT_LEN 8192 ------------------ | Branch (37:9): [True: 0, False: 380] ------------------ 38| 0| return (0); 39| | 40| 380| sbp = rtpp_sbuf_ctor(512); 41| 380| assert (sbp != NULL); ------------------ | Branch (41:5): [True: 0, False: 380] | Branch (41:5): [True: 380, 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| 380| rtcp2json(sbp, rtcp_data, rtcp_dlen); 52| 380| rtpp_sbuf_dtor(sbp); 53| | 54| 380| return (0); 55| 380|} 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.2k|{ 43| 46.2k| va_list ap; 44| 46.2k| int rlen, len; 45| | 46| 46.2k| len = sbp->alen - RS_ULEN(sbp); ------------------ | | 40| 46.2k|#define RS_ULEN(sbp) ((int)((sbp)->cp - (sbp)->bp)) ------------------ 47| 46.2k| assert(len > 0); ------------------ | Branch (47:5): [True: 0, False: 46.2k] | Branch (47:5): [True: 46.2k, False: 0] ------------------ 48| 46.2k| va_start(ap, format); 49| 46.2k| rlen = vsnprintf(sbp->cp, len, format, ap); 50| 46.2k| va_end(ap); 51| 46.2k| if (rlen < 0) ------------------ | Branch (51:9): [True: 0, False: 46.2k] ------------------ 52| 0| return (SBW_ERR); ------------------ | | 37| 0|#define SBW_ERR (-1) ------------------ 53| 46.2k| if (rlen >= len) { ------------------ | Branch (53:9): [True: 728, False: 45.5k] ------------------ 54| 728| sbp->cp[0] = '\0'; 55| 728| return (SBW_SHRT); ------------------ | | 38| 728|#define SBW_SHRT (-2) ------------------ 56| 728| } 57| 45.5k| sbp->cp += rlen; 58| 45.5k| return (SBW_OK); ------------------ | | 36| 45.5k|#define SBW_OK (0) ------------------ 59| 46.2k|} rtpp_sbuf_ctor: 67| 380|{ 68| 380| struct rtpp_sbuf *sbp; 69| | 70| 380|#if !defined(RTPP_CHECK_LEAKS) 71| 380| sbp = malloc(sizeof(struct rtpp_sbuf)); 72| |#else 73| | sbp = rtpp_memdeb_malloc(sizeof(struct rtpp_sbuf), memdeb_p, mlp); 74| |#endif 75| 380| if (sbp == NULL) ------------------ | Branch (75:9): [True: 0, False: 380] ------------------ 76| 0| return (NULL); 77| 380| memset(sbp, '\0', sizeof(struct rtpp_sbuf)); 78| 380|#if !defined(RTPP_CHECK_LEAKS) 79| 380| sbp->bp = sbp->cp = malloc(ilen); 80| |#else 81| | sbp->bp = sbp->cp = rtpp_memdeb_malloc(ilen, memdeb_p, mlp); 82| |#endif 83| 380| if (sbp->bp == NULL) { ------------------ | Branch (83:9): [True: 0, False: 380] ------------------ 84| 0| free(sbp); 85| 0| return (NULL); 86| 0| } 87| 380| sbp->cp[0] = '\0'; 88| 380| sbp->alen = ilen; 89| 380| return(sbp); 90| 380|} rtpp_sbuf_dtor: 98| 380|{ 99| | 100| 380|#if !defined(RTPP_CHECK_LEAKS) 101| 380| free(sbp->bp); 102| 380| free(sbp); 103| |#else 104| | rtpp_memdeb_free(sbp->bp, memdeb_p, mlp); 105| | rtpp_memdeb_free(sbp, memdeb_p, mlp); 106| |#endif 107| 380|} rtpp_sbuf_extend: 115| 728|{ 116| 728| void *nbp, *ncp; 117| | 118| 728| assert(nlen > sbp->alen); ------------------ | Branch (118:5): [True: 0, False: 728] | Branch (118:5): [True: 728, False: 0] ------------------ 119| 728|#if !defined(RTPP_CHECK_LEAKS) 120| 728| nbp = realloc(sbp->bp, nlen); 121| |#else 122| | nbp = rtpp_memdeb_realloc(sbp->bp, nlen, memdeb_p, mlp); 123| |#endif 124| 728| if (nbp == NULL) ------------------ | Branch (124:9): [True: 0, False: 728] ------------------ 125| 0| return (-1); 126| 728| sbp->alen = nlen; 127| 728| if (sbp->bp != nbp) { ------------------ | Branch (127:9): [True: 340, False: 388] ------------------ 128| 340| ncp = nbp + RS_ULEN(sbp); ------------------ | | 40| 340|#define RS_ULEN(sbp) ((int)((sbp)->cp - (sbp)->bp)) ------------------ 129| 340| sbp->cp = ncp; 130| 340| sbp->bp = nbp; 131| 340| } 132| 728| return (0); 133| 728|}