--- /dev/null
+/*
+* FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
+* Copyright (C) 2005-2021, Anthony Minessale II <anthm@freeswitch.org>
+*
+* Version: MPL 1.1
+*
+* The contents of this file are subject to the Mozilla Public License Version
+* 1.1 (the "License"); you may not use this file except in compliance with
+* the License. You may obtain a copy of the License at
+* http://www.mozilla.org/MPL/
+*
+* Software distributed under the License is distributed on an "AS IS" basis,
+* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+* for the specific language governing rights and limitations under the
+* License.
+*
+* The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
+*
+* The Initial Developer of the Original Code is
+* Anthony Minessale II <anthm@freeswitch.org>
+* Portions created by the Initial Developer are Copyright (C)
+* the Initial Developer. All Rights Reserved.
+*
+* Contributor(s):
+* Dragos Oancea <dragos@signalwire.com>
+*
+* switch_rtp_pcap.c -- tests RTP stack using PCAP.
+*/
+
+
+#include <switch.h>
+#include <test/switch_test.h>
+
+/* before adding a pcap file: tcprewrite --dstipmap=X.X.X.X/32:192.168.0.1/32 --srcipmap=X.X.X.X/32:192.168.0.2/32 -i in.pcap -o out.pcap */
+
+#include <pcap.h>
+
+#ifndef MSG_CONFIRM
+#define MSG_CONFIRM 0
+#endif
+
+static const char *rx_host = "127.0.0.1";
+static const char *tx_host = "127.0.0.1";
+static switch_rtp_t *rtp_session = NULL;
+const char *err = NULL;
+switch_rtp_packet_t rtp_packet;
+switch_frame_flag_t *frame_flags;
+switch_io_flag_t io_flags;
+switch_payload_t read_pt;
+static switch_port_t audio_rx_port = 1234;
+
+static int got_media_timeout = 0;
+
+//#define USE_RTCP_PCAP
+
+#define NTP_TIME_OFFSET 2208988800UL
+
+/* https://www.tcpdump.org/pcap.html */
+/* IP header */
+struct sniff_ip {
+ u_char ip_vhl; /* version << 4 | header length >> 2 */
+ u_char ip_tos; /* type of service */
+ u_short ip_len; /* total length */
+ u_short ip_id; /* identification */
+ u_short ip_off; /* fragment offset field */
+#define IP_RF 0x8000 /* reserved fragment flag */
+#define IP_DF 0x4000 /* dont fragment flag */
+#define IP_MF 0x2000 /* more fragments flag */
+#define IP_OFFMASK 0x1fff /* mask for fragmenting bits */
+ u_char ip_ttl; /* time to live */
+ u_char ip_p; /* protocol */
+ u_short ip_sum; /* checksum */
+ struct in_addr ip_src,ip_dst; /* source and dest address */
+};
+
+#define IP_HL(ip) (((ip)->ip_vhl) & 0x0f)
+
+/* switch_rtp.c - calc_local_lsr_now() */
+static inline uint32_t test_calc_local_lsr_now(switch_time_t now, uint32_t past /*milliseconds*/)
+{
+// switch_time_t now;
+ uint32_t ntp_sec, ntp_usec, lsr_now, sec;
+// now = switch_micro_time_now() - (past * 1000);
+ now = now - (past * 1000);
+ sec = (uint32_t)(now/1000000); /* convert to seconds */
+ ntp_sec = sec+NTP_TIME_OFFSET; /* convert to NTP seconds */
+ ntp_usec = (uint32_t)(now - ((switch_time_t) sec*1000000)); /* remove seconds to keep only the microseconds */
+
+ lsr_now = (uint32_t)(ntp_usec*0.065536) | (ntp_sec&0x0000ffff)<<16; /* 0.065536 is used for convertion from useconds to fraction of 65536 (x65536/1000000) */
+ return lsr_now;
+}
+
+#if 0
+static void test_prepare_rtcp(void *rtcp_packet, float est_last, uint32_t rtt, uint8_t loss)
+{
+ /* taken from switch_rtp.c, rtcp_generate_sender_info() */
+ /* === */
+ char *rtcp_sr_trigger = rtcp_packet;
+ switch_time_t now;
+ uint32_t sec, ntp_sec, ntp_usec;
+ uint32_t ntp_msw;
+ uint32_t ntp_lsw;
+ uint32_t *ptr_msw;
+ uint32_t *ptr_lsw;
+ uint32_t lsr;
+ uint32_t *ptr_lsr;
+ uint32_t dlsr = 0;
+ uint32_t *ptr_dlsr;
+ uint8_t *ptr_loss;
+
+ now = switch_micro_time_now();
+ sec = (uint32_t)(now/1000000); /* convert to seconds */
+ ntp_sec = sec+NTP_TIME_OFFSET; /* convert to NTP seconds */
+ ntp_msw = htonl(ntp_sec); /* store result in "most significant word" */
+ ntp_usec = (uint32_t)(now - (sec*1000000)); /* remove seconds to keep only the microseconds */
+ ntp_lsw = htonl((u_long)(ntp_usec*(double)(((uint64_t)1)<<32)*1.0e-6));
+
+ /* === */
+
+ /*patch the RTCP payload to set the RTT we want */
+
+ ptr_msw = (uint32_t *)rtcp_sr_trigger + 2;
+ *ptr_msw = ntp_msw;
+
+ ptr_lsw = (uint32_t *)rtcp_sr_trigger + 3;
+ *ptr_lsw = ntp_lsw;
+
+ lsr = test_calc_local_lsr_now(now, est_last * 1000 + rtt /*ms*/);
+
+ ptr_lsr = (uint32_t *)rtcp_sr_trigger + 11;
+ *ptr_lsr = htonl(lsr);
+
+ ptr_dlsr = (uint32_t *)rtcp_sr_trigger + 12;
+ *ptr_dlsr = htonl(dlsr);
+
+ ptr_loss = (uint8_t *)rtcp_sr_trigger + 32;
+ *ptr_loss = loss;
+}
+#endif
+
+static switch_status_t rtp_test_start_call(switch_core_session_t **psession)
+{
+ char *r_sdp;
+ uint8_t match = 0, p = 0;
+ switch_core_session_t *session;
+ switch_channel_t *channel = NULL;
+ switch_status_t status;
+ switch_media_handle_t *media_handle;
+ switch_core_media_params_t *mparams;
+ switch_stream_handle_t stream = { 0 };
+ switch_call_cause_t cause;
+
+ /*tone stream extension*/
+ status = switch_ivr_originate(NULL, psession, &cause, "null/+1234", 2, NULL, NULL, NULL, NULL, NULL, SOF_NONE, NULL, NULL);
+ session = *psession;
+
+ if (!(session)) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "no session\n");
+ return SWITCH_STATUS_FALSE;
+ }
+
+ if (status != SWITCH_STATUS_SUCCESS) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "switch_ivr_originate() failed\n");
+ return SWITCH_STATUS_FALSE;
+ }
+
+ channel = switch_core_session_get_channel(session);
+ if (!channel) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "switch_core_session_get_channel() failed\n");
+ return SWITCH_STATUS_FALSE;
+ }
+ mparams = switch_core_session_alloc(session, sizeof(switch_core_media_params_t));
+ mparams->inbound_codec_string = switch_core_session_strdup(session, "PCMU");
+ mparams->outbound_codec_string = switch_core_session_strdup(session, "PCMU");
+ mparams->rtpip = switch_core_session_strdup(session, (char *)rx_host);
+
+ status = switch_media_handle_create(&media_handle, session, mparams);
+ if (status != SWITCH_STATUS_SUCCESS) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "switch_media_handle_create() failed\n");
+ return SWITCH_STATUS_FALSE;
+ }
+
+ switch_channel_set_variable(channel, "absolute_codec_string", "PCMU");
+ switch_channel_set_variable(channel, "send_silence_when_idle", "-1");
+ switch_channel_set_variable(channel, "rtp_timer_name", "soft");
+ switch_channel_set_variable(channel, "media_timeout", "1000");
+
+ switch_channel_set_variable(channel, SWITCH_LOCAL_MEDIA_IP_VARIABLE, rx_host);
+ switch_channel_set_variable_printf(channel, SWITCH_LOCAL_MEDIA_PORT_VARIABLE, "%d", audio_rx_port);
+
+ r_sdp = switch_core_session_sprintf(session,
+ "v=0\n"
+ "o=FreeSWITCH 1632033305 1632033306 IN IP4 %s\n"
+ "s=-\n"
+ "c=IN IP4 %s\n"
+ "t=0 0\n"
+ "m=audio 11114 RTP/AVP 0 101\n"
+ "a=rtpmap:0 PCMU/8000\n"
+ "a=rtpmap:101 telephone-event/8000\n"
+ "a=rtcp-mux\n",
+ tx_host, tx_host);
+
+ status = switch_core_media_prepare_codecs(session, SWITCH_FALSE);
+ if (status != SWITCH_STATUS_SUCCESS) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "switch_core_media_prepare_codecs() failed\n");
+ return SWITCH_STATUS_FALSE;
+ }
+
+ match = switch_core_media_negotiate_sdp(session, r_sdp, &p, SDP_TYPE_REQUEST);
+ if (match != 1) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "switch_core_media_negotiate_sdp() failed\n");
+ return SWITCH_STATUS_FALSE;
+ }
+
+ status = switch_core_media_choose_ports(session, SWITCH_TRUE, SWITCH_FALSE);
+ if (status != SWITCH_STATUS_SUCCESS) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "switch_core_media_choose_ports() failed\n");
+ return SWITCH_STATUS_FALSE;
+ }
+
+ status = switch_core_media_activate_rtp(session);
+ if (status != SWITCH_STATUS_SUCCESS) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "switch_core_media_activate_rtp() failed\n");
+ return SWITCH_STATUS_FALSE;
+ }
+
+ switch_core_media_set_rtp_flag(session, SWITCH_MEDIA_TYPE_AUDIO, SWITCH_RTP_FLAG_DEBUG_RTP_READ);
+ switch_core_media_set_rtp_flag(session, SWITCH_MEDIA_TYPE_AUDIO, SWITCH_RTP_FLAG_DEBUG_RTP_WRITE);
+
+ SWITCH_STANDARD_STREAM(stream);
+ switch_api_execute("fsctl", "debug_level 10", session, &stream);
+ switch_safe_free(stream.data);
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+static switch_status_t rtp_test_end_call(switch_core_session_t **psession)
+{
+ switch_channel_t *channel = NULL;
+ switch_core_session_t *session = *psession;
+
+ channel = switch_core_session_get_channel(session);
+ if (!channel) {
+ return SWITCH_STATUS_FALSE;
+ }
+ switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING);
+ switch_media_handle_destroy(session);
+ switch_core_session_rwunlock(session);
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+static void rtp_test_init_frame(switch_frame_t **pwrite_frame, switch_core_session_t **psession)
+{
+ const unsigned char hdr_packet[]="\x80\x00\xcd\x15\xfd\x86\x00\x00\x61\x5a\xe1\x37";
+
+ switch_frame_alloc(pwrite_frame, SWITCH_RECOMMENDED_BUFFER_SIZE);
+ (*pwrite_frame)->codec = switch_core_session_get_write_codec(*psession);
+
+ (*pwrite_frame)->datalen = SWITCH_RTP_HEADER_LEN; /*init with dummy RTP header*/
+ memcpy((*pwrite_frame)->data, &hdr_packet, SWITCH_RTP_HEADER_LEN);
+}
+
+static void show_event(switch_event_t *event) {
+ char *str;
+ /*print the event*/
+ switch_event_serialize_json(event, &str);
+ if (str) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s\n", str);
+ switch_safe_free(str);
+ }
+}
+
+static void event_handler(switch_event_t *event)
+{
+ const char *new_ev = switch_event_get_header(event, "Event-Name");
+
+ if (new_ev && !strcmp(new_ev, "CHANNEL_HANGUP")) {
+ if (!strcmp(switch_event_get_header(event, "Hangup-Cause"), "MEDIA_TIMEOUT")) {
+ got_media_timeout = 1;
+ }
+ }
+
+ show_event(event);
+}
+
+FST_CORE_DB_BEGIN("./conf_rtp")
+{
+FST_SUITE_BEGIN(switch_rtp_pcap)
+{
+
+FST_SETUP_BEGIN()
+{
+ fst_requires_module("mod_loopback");
+}
+FST_SETUP_END()
+
+FST_TEARDOWN_BEGIN()
+{
+}
+FST_TEARDOWN_END()
+#if 0
+ FST_TEST_BEGIN(test_rtp_stall_with_rtcp_muxed_with_timer)
+ {
+ switch_core_session_t *session = NULL;
+ switch_status_t status;
+ uint32_t plen = SWITCH_RTP_HEADER_LEN;
+ char rpacket[SWITCH_RECOMMENDED_BUFFER_SIZE];
+ switch_payload_t pt = { 0 };
+ switch_frame_flag_t frameflags = { 0 };
+ int x = 0;
+ switch_frame_t *write_frame;
+ pcap_t *pcap;
+ const unsigned char *packet;
+ char errbuf[PCAP_ERRBUF_SIZE];
+ struct pcap_pkthdr pcap_header;
+ char rtcp_sr_trigger[] = "\x81\xc8\x00\x0c\x78\x9d\xac\x45\xe2\x67\xa5\x74\x30\x60\x56\x81\x00\x19"
+ "\xaa\x00\x00\x00\x06\xd7\x00\x01\x2c\x03\x5e\xbd\x2f\x0b\x00"
+ "\x00\x00\x00\x00\x00\x57\xc4\x00\x00\x00\x39\xa5\x73\xfe\x90\x00\x00\x2c\x87"
+ "\x81\xca\x00\x0c\x78\x9d\xac\x45\x01\x18\x73\x69\x70\x3a\x64\x72\x40\x31\x39\x32\x2e"
+ "\x31\x36\x38\x2e\x30\x2e\x31\x33\x3a\x37\x30\x36\x30\x06\x0e\x4c\x69\x6e\x70\x68\x6f"
+ "\x6e\x65\x2d\x33\x2e\x36\x2e\x31\x00\x00";
+ const struct sniff_ip *ip; /* The IP header */
+ int size_ip, jump_over;
+ struct timeval prev_ts = { 0 };
+ switch_time_t time_nowpacket = 0, time_prevpacket = 0;
+ switch_socket_t *sock_rtp = NULL;
+ switch_sockaddr_t *sock_addr = NULL;
+ const char *str_err;
+ switch_size_t rough_add = 0;
+
+ status = rtp_test_start_call(&session);
+ fst_requires(status == SWITCH_STATUS_SUCCESS);
+ fst_requires(session);
+
+ pcap = pcap_open_offline_with_tstamp_precision("pcap/milliwatt.long.pcmu.rtp.pcap", PCAP_TSTAMP_PRECISION_MICRO, errbuf);
+ fst_requires(pcap);
+
+ switch_core_media_set_rtp_flag(session, SWITCH_MEDIA_TYPE_AUDIO, SWITCH_RTP_FLAG_ENABLE_RTCP);
+
+ rtp_session = switch_core_media_get_rtp_session(session, SWITCH_MEDIA_TYPE_AUDIO);
+
+ rtp_test_init_frame(&write_frame, &session);
+
+ switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_PAUSE);
+
+ if (switch_socket_create(&sock_rtp, AF_INET, SOCK_DGRAM, 0, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
+ fst_requires(0); /*exit*/
+ }
+
+ switch_sockaddr_new(&sock_addr, rx_host, audio_rx_port, switch_core_session_get_pool(session));
+ fst_requires(sock_addr);
+
+ switch_rtp_set_remote_address(rtp_session, tx_host, switch_sockaddr_get_port(sock_addr), 0, SWITCH_FALSE, &str_err);
+ switch_rtp_reset(rtp_session);
+
+ while ((packet = pcap_next(pcap, &pcap_header))) {
+ /*assume only UDP/RTP packets in the pcap*/
+ uint32_t rcvd_datalen = pcap_header.caplen;
+ size_t len;
+ switch_size_t tmp_len;
+
+ int diff_us = (pcap_header.ts.tv_sec-prev_ts.tv_sec)*1000000+(pcap_header.ts.tv_usec-prev_ts.tv_usec);
+
+ if (diff_us > 0) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "SENT pkt diff: %d us\n", diff_us);
+ usleep(diff_us);
+ }
+
+ prev_ts = pcap_header.ts;
+
+ len = pcap_header.caplen;
+
+ if (len <= 42) {
+ continue;
+ }
+
+ ip = (struct sniff_ip*)(packet + 14);
+ size_ip = IP_HL(ip) * 4;
+
+ jump_over = 14 /*SIZE_ETHERNET*/ + size_ip /*IP HDR size*/ + 8 /* UDP HDR SIZE */; /* jump 42 bytes over network layers/headers */
+ packet += jump_over;
+ x++;
+
+ if (!(x%10)) { /* send a RTCP SR packet every 10th RTP packet */
+ int add_rtt = 200;
+ test_prepare_rtcp(&rtcp_sr_trigger, 2, add_rtt, 0xa0);
+ tmp_len = sizeof(rtcp_sr_trigger);
+ /*RTCP muxed*/
+ if (switch_socket_sendto(sock_rtp, sock_addr, MSG_CONFIRM, (const char*)rtcp_sr_trigger, &tmp_len) != SWITCH_STATUS_SUCCESS) {
+ fst_requires(0);
+ }
+
+ plen = sizeof(rtcp_sr_trigger);
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Sent RTCP. Packet size = [%u]\n", plen);
+ status = switch_rtp_read(rtp_session, (void *)rpacket, &rcvd_datalen, &pt, &frameflags, io_flags);
+ if (pt == SWITCH_RTP_CNG_PAYLOAD /*timeout*/) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "read CNG/RTCP, skip\n");
+ while (1) {
+ status = switch_rtp_read(rtp_session, (void *)&rpacket, &rcvd_datalen, &pt, &frameflags, io_flags);
+ if (frameflags || SFF_RTCP) break;
+ }
+ }
+ fst_requires(status == SWITCH_STATUS_SUCCESS);
+ }
+
+ if (packet[0] == 0x80 && packet[1] == 0 /*PCMU*/) {
+ int16_t *seq = (int16_t *)packet + 1;
+ plen = len - jump_over;
+ tmp_len = plen;
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Sent RTP. Packet size = [%u] seq = [%d]\n", plen, htons(*seq));
+ if (switch_socket_sendto(sock_rtp, sock_addr, MSG_CONFIRM, (const char*)packet, &tmp_len) != SWITCH_STATUS_SUCCESS) {
+ fst_requires(0);
+ }
+ }
+
+ status = switch_rtp_read(rtp_session, (void *)&rpacket, &rcvd_datalen, &pt, &frameflags, io_flags);
+ if (pt == SWITCH_RTP_CNG_PAYLOAD /*timeout*/) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "read CNG, skip\n");
+ continue;
+ }
+ time_prevpacket = time_nowpacket;
+ time_nowpacket = switch_time_now();
+ if (time_prevpacket) { // skip init.
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "RECV pkt diff: %ld us\n", time_nowpacket - time_prevpacket);
+
+ fst_requires((time_nowpacket - time_prevpacket) < 80000);
+ rough_add += time_nowpacket - time_prevpacket; /* just add to var for visual comparison */
+ }
+ fst_requires(status == SWITCH_STATUS_SUCCESS);
+ if (pt == SWITCH_RTP_CNG_PAYLOAD /*timeout*/) continue;
+ fst_requires(rcvd_datalen == plen - SWITCH_RTP_HEADER_LEN);
+ }
+
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "RECV total delay: %lu\n", rough_add); /*around 17092408 us*/
+ switch_yield(1000 * 1000);
+
+ if (write_frame) switch_frame_free(&write_frame);
+
+ switch_rtp_destroy(&rtp_session);
+
+ rtp_test_end_call(&session);
+
+ switch_socket_close(sock_rtp);
+
+ pcap_close(pcap);
+
+ switch_yield(1000 * 1000);
+ }
+ FST_TEST_END()
+#endif
+
+ FST_TEST_BEGIN(test_rtp_media_timeout)
+ {
+ switch_core_session_t *session = NULL;
+ switch_status_t status;
+ uint32_t plen = SWITCH_RTP_HEADER_LEN;
+ char rpacket[SWITCH_RECOMMENDED_BUFFER_SIZE];
+ switch_payload_t pt = { 0 };
+ switch_frame_flag_t frameflags = { 0 };
+ int x = 0;
+ switch_frame_t *write_frame;
+ pcap_t *pcap;
+ const unsigned char *packet;
+ char errbuf[PCAP_ERRBUF_SIZE];
+ struct pcap_pkthdr pcap_header;
+ const struct sniff_ip *ip; /* The IP header */
+ int size_ip, jump_over;
+ struct timeval prev_ts = { 0 };
+ switch_socket_t *sock_rtp = NULL;
+ switch_sockaddr_t *sock_addr = NULL;
+ const char *str_err;
+
+ status = rtp_test_start_call(&session);
+ fst_requires(status == SWITCH_STATUS_SUCCESS);
+ fst_requires(session);
+
+ switch_event_bind("", SWITCH_EVENT_ALL, SWITCH_EVENT_SUBCLASS_ANY, event_handler, NULL);
+
+ pcap = pcap_open_offline_with_tstamp_precision("pcap/milliwatt.pcmu.rtp.pcap", PCAP_TSTAMP_PRECISION_MICRO, errbuf);
+ fst_requires(pcap);
+
+ switch_core_media_set_rtp_flag(session, SWITCH_MEDIA_TYPE_AUDIO, SWITCH_RTP_FLAG_ENABLE_RTCP);
+
+ rtp_session = switch_core_media_get_rtp_session(session, SWITCH_MEDIA_TYPE_AUDIO);
+ fst_requires(rtp_session);
+
+ rtp_test_init_frame(&write_frame, &session);
+
+ switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_PAUSE);
+
+ if (switch_socket_create(&sock_rtp, AF_INET, SOCK_DGRAM, 0, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
+ fst_requires(0); /*exit*/
+ }
+
+ switch_sockaddr_new(&sock_addr, rx_host, audio_rx_port, switch_core_session_get_pool(session));
+ fst_requires(sock_addr);
+
+ switch_rtp_set_remote_address(rtp_session, tx_host, switch_sockaddr_get_port(sock_addr), 0, SWITCH_FALSE, &str_err);
+ switch_rtp_reset(rtp_session);
+
+ /* send 3 packets then wait and expect RTP timeout */
+ while ((packet = pcap_next(pcap, &pcap_header)) && x < 3) {
+ /*assume only UDP/RTP packets in the pcap*/
+ uint32_t rcvd_datalen = pcap_header.caplen;
+ size_t len;
+ switch_size_t tmp_len;
+
+ int diff_us = (pcap_header.ts.tv_sec-prev_ts.tv_sec)*1000000+(pcap_header.ts.tv_usec-prev_ts.tv_usec);
+ if (diff_us > 0) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "SENT pkt diff: %d us\n", diff_us);
+ usleep(diff_us);
+ }
+
+ x++;
+
+ prev_ts = pcap_header.ts;
+
+ len = pcap_header.caplen;
+
+ if (len <= 42) {
+ continue;
+ }
+
+ ip = (struct sniff_ip*)(packet + 14);
+ size_ip = IP_HL(ip) * 4;
+
+ jump_over = 14 /*SIZE_ETHERNET*/ + size_ip /*IP HDR size*/ + 8 /* UDP HDR SIZE */; /* jump 42 bytes over network layers/headers */
+ packet += jump_over;
+
+ if (packet[0] == 0x80 && packet[1] == 0 /*PCMU*/) {
+ int16_t *seq = (int16_t *)packet + 1;
+ plen = len - jump_over;
+ tmp_len = plen;
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Sent RTP. Packet size = [%u] seq = [%d]\n", plen, htons(*seq));
+ if (switch_socket_sendto(sock_rtp, sock_addr, MSG_CONFIRM, (const char*)packet, &tmp_len) != SWITCH_STATUS_SUCCESS) {
+ fst_requires(0);
+ }
+ }
+
+ status = switch_rtp_read(rtp_session, (void *)&rpacket, &rcvd_datalen, &pt, &frameflags, io_flags);
+ if (pt == SWITCH_RTP_CNG_PAYLOAD /*timeout*/) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "read CNG, skip\n");
+ continue;
+ }
+
+ fst_requires(status == SWITCH_STATUS_SUCCESS);
+ fst_requires(rcvd_datalen == plen - SWITCH_RTP_HEADER_LEN);
+ }
+
+ x = 150; /* 3 seconds max */
+ while (x || !got_media_timeout) {
+ uint32_t rcvd_datalen;
+ status = switch_rtp_read(rtp_session, (void *)&rpacket, &rcvd_datalen, &pt, &frameflags, io_flags);
+ if (pt == SWITCH_RTP_CNG_PAYLOAD /*timeout*/) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "read CNG, skip\n");
+ }
+ switch_yield(20 * 1000);
+ fst_requires(status == SWITCH_STATUS_SUCCESS);
+ x--;
+ }
+
+ if (write_frame) switch_frame_free(&write_frame);
+
+ switch_rtp_destroy(&rtp_session);
+
+ rtp_test_end_call(&session);
+
+ switch_socket_close(sock_rtp);
+
+ pcap_close(pcap);
+
+ fst_check(got_media_timeout);
+ }
+ FST_TEST_END()
+}
+FST_SUITE_END()
+}
+FST_CORE_END()
+
projects / thirdparty / freeswitch.git / commitdiff
