static int tcp_perf_test(void) { enum { COUNT=10000 }; pj_pool_t *pool = NULL; pj_ioqueue_t *ioqueue = NULL; pj_sock_t sock1=PJ_INVALID_SOCKET, sock2=PJ_INVALID_SOCKET; pj_activesock_t *asock1 = NULL, *asock2 = NULL; pj_activesock_cb cb; struct tcp_state *state1, *state2; unsigned i; pj_status_t status; pool = pj_pool_create(mem, "tcpperf", 256, 256, NULL); status = app_socketpair(pj_AF_INET(), pj_SOCK_STREAM(), 0, &sock1, &sock2); if (status != PJ_SUCCESS) { status = -100; goto on_return; } status = pj_ioqueue_create(pool, 4, &ioqueue); if (status != PJ_SUCCESS) { status = -110; goto on_return; } pj_bzero(&cb, sizeof(cb)); cb.on_data_read = &tcp_on_data_read; cb.on_data_sent = &tcp_on_data_sent; state1 = PJ_POOL_ZALLOC_T(pool, struct tcp_state); status = pj_activesock_create(pool, sock1, pj_SOCK_STREAM(), NULL, ioqueue, &cb, state1, &asock1); if (status != PJ_SUCCESS) { status = -120; goto on_return; } state2 = PJ_POOL_ZALLOC_T(pool, struct tcp_state); status = pj_activesock_create(pool, sock2, pj_SOCK_STREAM(), NULL, ioqueue, &cb, state2, &asock2); if (status != PJ_SUCCESS) { status = -130; goto on_return; } status = pj_activesock_start_read(asock1, pool, 1000, 0); if (status != PJ_SUCCESS) { status = -140; goto on_return; } /* Send packet as quickly as possible */ for (i=0; i<COUNT && !state1->err && !state2->err; ++i) { struct tcp_pkt *pkt; struct send_key send_key[2], *op_key; pj_ssize_t len; pkt = (struct tcp_pkt*)state2->pkt; pkt->signature = SIGNATURE; pkt->seq = i; pj_memset(pkt->fill, 'a', sizeof(pkt->fill)); op_key = &send_key[i%2]; pj_ioqueue_op_key_init(&op_key->op_key, sizeof(*op_key)); state2->sent = PJ_FALSE; len = sizeof(*pkt); status = pj_activesock_send(asock2, &op_key->op_key, pkt, &len, 0); if (status == PJ_EPENDING) { do { #if PJ_SYMBIAN pj_symbianos_poll(-1, -1); #else pj_ioqueue_poll(ioqueue, NULL); #endif } while (!state2->sent); } else { #if PJ_SYMBIAN /* The Symbian socket always returns PJ_SUCCESS for TCP send, * eventhough the remote end hasn't received the data yet. * If we continue sending, eventually send() will block, * possibly because the send buffer is full. So we need to * poll the ioqueue periodically, to let receiver gets the * data. */ pj_symbianos_poll(-1, 0); #endif if (status != PJ_SUCCESS) { PJ_LOG(1,("", " err: send status=%d", status)); status = -180; break; } else if (status == PJ_SUCCESS) { if (len != sizeof(*pkt)) { PJ_LOG(1,("", " err: shouldn't report partial sent")); status = -190; break; } } } #ifndef PJ_SYMBIAN for (;;) { pj_time_val timeout = {0, 10}; if (pj_ioqueue_poll(ioqueue, &timeout) < 1) break; } #endif } /* Wait until everything has been sent/received */ if (state1->next_recv_seq < COUNT) { #ifdef PJ_SYMBIAN while (pj_symbianos_poll(-1, 1000) == PJ_TRUE) ; #else pj_time_val delay = {0, 100}; while (pj_ioqueue_poll(ioqueue, &delay) > 0) ; #endif } if (status == PJ_EPENDING) status = PJ_SUCCESS; if (status != 0) goto on_return; if (state1->err) { status = -183; goto on_return; } if (state2->err) { status = -186; goto on_return; } if (state1->next_recv_seq != COUNT) { PJ_LOG(3,("", " err: only %u packets received, expecting %u", state1->next_recv_seq, COUNT)); status = -195; goto on_return; } on_return: if (asock2) pj_activesock_close(asock2); if (asock1) pj_activesock_close(asock1); if (ioqueue) pj_ioqueue_destroy(ioqueue); if (pool) pj_pool_release(pool); return status; }
static int fingerprint_test_vector() { pj_pool_t *pool; pj_status_t status; unsigned i; int rc = 0; /* To avoid function not referenced warnings */ (void)create_msgint2; (void)create_msgint3; PJ_LOG(3,(THIS_FILE, " draft-denis-behave-rfc3489bis-test-vectors-02")); pool = pj_pool_create(mem, "fingerprint", 1024, 1024, NULL); for (i=0; i<PJ_ARRAY_SIZE(test_vectors); ++i) { struct test_vector *v; pj_stun_msg *ref_msg, *msg; pj_size_t parsed_len; pj_size_t len; unsigned pos; pj_uint8_t buf[1500]; char print[1500]; pj_str_t key; PJ_LOG(3,(THIS_FILE, " Running test %d/%d", i, PJ_ARRAY_SIZE(test_vectors))); v = &test_vectors[i]; /* Print reference message */ PJ_LOG(4,(THIS_FILE, "Reference message PDU:\n%s", print_binary((pj_uint8_t*)v->pdu, v->pdu_len))); /* Try to parse the reference message first */ status = pj_stun_msg_decode(pool, (pj_uint8_t*)v->pdu, v->pdu_len, PJ_STUN_IS_DATAGRAM | PJ_STUN_CHECK_PACKET, &ref_msg, &parsed_len, NULL); if (status != PJ_SUCCESS) { PJ_LOG(1,(THIS_FILE, " Error decoding reference message")); rc = -1010; goto on_return; } if (parsed_len != v->pdu_len) { PJ_LOG(1,(THIS_FILE, " Parsed len error")); rc = -1020; goto on_return; } /* Print the reference message */ pj_stun_msg_dump(ref_msg, print, sizeof(print), NULL); PJ_LOG(4,(THIS_FILE, "Reference message:\n%s", print)); /* Create our message */ msg = v->create(pool, v); if (msg == NULL) { PJ_LOG(1,(THIS_FILE, " Error creating stun message")); rc = -1030; goto on_return; } /* Encode message */ if (v->options & USE_MESSAGE_INTEGRITY) { pj_str_t s1, s2, r; pj_stun_create_key(pool, &key, pj_cstr(&r, v->realm), pj_cstr(&s1, v->username), PJ_STUN_PASSWD_PLAIN, pj_cstr(&s2, v->password)); pj_stun_msg_encode(msg, buf, sizeof(buf), 0, &key, &len); } else { pj_stun_msg_encode(msg, buf, sizeof(buf), 0, NULL, &len); } /* Print our raw message */ PJ_LOG(4,(THIS_FILE, "Message PDU:\n%s", print_binary((pj_uint8_t*)buf, (unsigned)len))); /* Print our message */ pj_stun_msg_dump(msg, print, sizeof(print), NULL); PJ_LOG(4,(THIS_FILE, "Message is:\n%s", print)); /* Compare message length */ if (len != v->pdu_len) { PJ_LOG(1,(THIS_FILE, " Message length mismatch")); rc = -1050; goto on_return; } pos = cmp_buf(buf, (const pj_uint8_t*)v->pdu, (unsigned)len); if (pos != (unsigned)-1) { PJ_LOG(1,(THIS_FILE, " Message mismatch at byte %d", pos)); rc = -1060; goto on_return; } /* Authenticate the request/response */ if (v->options & USE_MESSAGE_INTEGRITY) { if (PJ_STUN_IS_REQUEST(msg->hdr.type)) { pj_stun_auth_cred cred; pj_status_t status; pj_bzero(&cred, sizeof(cred)); cred.type = PJ_STUN_AUTH_CRED_STATIC; cred.data.static_cred.realm = pj_str(v->realm); cred.data.static_cred.username = pj_str(v->username); cred.data.static_cred.data = pj_str(v->password); cred.data.static_cred.nonce = pj_str(v->nonce); status = pj_stun_authenticate_request(buf, (unsigned)len, msg, &cred, pool, NULL, NULL); if (status != PJ_SUCCESS) { char errmsg[PJ_ERR_MSG_SIZE]; pj_strerror(status, errmsg, sizeof(errmsg)); PJ_LOG(1,(THIS_FILE, " Request authentication failed: %s", errmsg)); rc = -1070; goto on_return; } } else if (PJ_STUN_IS_RESPONSE(msg->hdr.type)) { pj_status_t status; status = pj_stun_authenticate_response(buf, (unsigned)len, msg, &key); if (status != PJ_SUCCESS) { char errmsg[PJ_ERR_MSG_SIZE]; pj_strerror(status, errmsg, sizeof(errmsg)); PJ_LOG(1,(THIS_FILE, " Response authentication failed: %s", errmsg)); rc = -1080; goto on_return; } } } } on_return: pj_pool_release(pool); return rc; }
/* API: refresh the device list */ static pj_status_t alsa_factory_refresh(pjmedia_aud_dev_factory *f) { struct alsa_factory *af = (struct alsa_factory*)f; char **hints, **n; int err; TRACE_((THIS_FILE, "pjmedia_snd_init: Enumerate sound devices")); if (af->pool != NULL) { pj_pool_release(af->pool); af->pool = NULL; } af->pool = pj_pool_create(af->pf, "alsa_aud", 256, 256, NULL); af->dev_cnt = 0; /* Enumerate sound devices */ err = snd_device_name_hint(-1, "pcm", (void***)&hints); if (err != 0) return PJMEDIA_EAUD_SYSERR; /* Set a null error handler prior to enumeration to suppress errors */ snd_lib_error_set_handler(null_alsa_error_handler); n = hints; while (*n != NULL) { char *name = snd_device_name_get_hint(*n, "NAME"); char *desc = snd_device_name_get_hint(*n, "DESC"); if (name != NULL) { if (strncmp("null", name, 4) == 0 || strncmp("front", name, 5) == 0 || strncmp("rear", name, 4) == 0 || strncmp("side", name, 4) == 0 || strncmp("dmix", name, 4) == 0 || strncmp("dsnoop", name, 6) == 0 || strncmp("hw", name, 2) == 0 || strncmp("plughw", name, 6) == 0 || strncmp("center_lfe", name, 10) == 0 || strncmp("surround40", name, 10) == 0 || strncmp("surround41", name, 10) == 0 || strncmp("surround50", name, 10) == 0 || strncmp("surround51", name, 10) == 0 || strncmp("surround71", name, 10) == 0 || (strncmp("default", name, 7) == 0 && strstr(name, ":CARD=") != NULL)) { /* skip these devices, 'sysdefault' always contains the relevant information */ ; } else { add_dev(af, name, desc); } free(name); free(desc); } n++; } /* Install error handler after enumeration, otherwise we'll get many * error messages about invalid card/device ID. */ snd_lib_error_set_handler(alsa_error_handler); err = snd_device_name_free_hint((void**)hints); PJ_LOG(4,(THIS_FILE, "ALSA driver found %d devices", af->dev_cnt)); return PJ_SUCCESS; }
pj_status_t session_test (pj_pool_factory *pf) { pj_med_mgr_t *mm; pj_media_session_t *s1, *s2; pj_pool_t *pool; pjsdp_session_desc *sdp; pj_media_stream_info sd_info; char buf[1024]; int len; pj_media_stream_stat tx_stat, rx_stat; pool = pj_pool_create(pf, "test", 4096, 1024, NULL); // Init media manager. mm = pj_med_mgr_create ( pf ); // Create caller session. // THIS WILL DEFINITELY CRASH (NULL as argument)! s1 = pj_media_session_create (mm, NULL); // Set caller's media to send-only. sd_info.dir = PJMEDIA_DIR_ENCODING; pj_media_session_modify_stream (s1, 0, PJMEDIA_STREAM_MODIFY_DIR, &sd_info); // Create caller SDP. sdp = pj_media_session_create_sdp (s1, pool, 0); len = pjsdp_print (sdp, buf, sizeof(buf)); buf[len] = '\0'; printf("Caller's initial SDP:\n<BEGIN>\n%s\n<END>\n", buf); // Parse SDP from caller. sdp = pjsdp_parse (buf, len, pool); // Create callee session based on caller's SDP. // THIS WILL DEFINITELY CRASH (NULL as argument)! s2 = pj_media_session_create_from_sdp (mm, sdp, NULL); // Create callee SDP sdp = pj_media_session_create_sdp (s2, pool, 0); len = pjsdp_print (sdp, buf, sizeof(buf)); buf[len] = '\0'; printf("Callee's SDP:\n<BEGIN>\n%s\n<END>\n", buf); // Parse SDP from callee. sdp = pjsdp_parse (buf, len, pool); // Update caller pj_media_session_update (s1, sdp); sdp = pj_media_session_create_sdp (s1, pool, 0); pjsdp_print (sdp, buf, sizeof(buf)); printf("Caller's SDP after update:\n<BEGIN>\n%s\n<END>\n", buf); // Now start media. pj_media_session_activate (s2); pj_media_session_activate (s1); // Wait for (;;) { int has_stat; printf("Enter q to exit, 1 or 2 to print statistics.\n"); fgets (buf, 10, stdin); has_stat = 0; switch (buf[0]) { case 'q': case 'Q': goto done; break; case '1': pj_media_session_get_stat (s1, 0, &tx_stat, &rx_stat); has_stat = 1; break; case '2': pj_media_session_get_stat (s2, 0, &tx_stat, &rx_stat); has_stat = 1; break; } if (has_stat) { pj_media_stream_stat *stat[2] = { &tx_stat, &rx_stat }; const char *statname[2] = { "TX", "RX" }; int i; for (i=0; i<2; ++i) { printf("%s statistics:\n", statname[i]); printf(" Pkt TX=%d RX=%d\n", stat[i]->pkt_tx, stat[i]->pkt_rx); printf(" Octets TX=%d RX=%d\n", stat[i]->oct_tx, stat[i]->oct_rx); printf(" Jitter %d ms\n", stat[i]->jitter); printf(" Pkt lost %d\n", stat[i]->pkt_lost); } printf("\n"); } } done: // Done. pj_pool_release (pool); pj_media_session_destroy (s2); pj_media_session_destroy (s1); pj_med_mgr_destroy (mm); return 0; }
static pj_bool_t srv_on_data_recvfrom(pj_activesock_t *asock, void *data, pj_size_t size, const pj_sockaddr_t *src_addr, int addr_len, pj_status_t status) { struct stun_srv *srv; pj_ssize_t sent; srv = (struct stun_srv*) pj_activesock_get_user_data(asock); /* Ignore error */ if (status != PJ_SUCCESS) return PJ_TRUE; ++srv->rx_cnt; /* Ignore if we're not responding */ if (srv->flag & RESPOND_STUN) { pj_pool_t *pool; pj_stun_msg *req_msg, *res_msg; pool = pj_pool_create(mem, "stunsrv", 512, 512, NULL); /* Parse request */ status = pj_stun_msg_decode(pool, (pj_uint8_t*)data, size, PJ_STUN_IS_DATAGRAM | PJ_STUN_CHECK_PACKET, &req_msg, NULL, NULL); if (status != PJ_SUCCESS) { app_perror(" pj_stun_msg_decode()", status); pj_pool_release(pool); return PJ_TRUE; } /* Create response */ status = pj_stun_msg_create(pool, PJ_STUN_BINDING_RESPONSE, PJ_STUN_MAGIC, req_msg->hdr.tsx_id, &res_msg); if (status != PJ_SUCCESS) { app_perror(" pj_stun_msg_create()", status); pj_pool_release(pool); return PJ_TRUE; } /* Add MAPPED-ADDRESS or XOR-MAPPED-ADDRESS (or don't add) */ if (srv->flag & WITH_MAPPED) { pj_sockaddr_in addr; pj_sockaddr_in_init(&addr, &srv->ip_to_send, srv->port_to_send); pj_stun_msg_add_sockaddr_attr(pool, res_msg, PJ_STUN_ATTR_MAPPED_ADDR, PJ_FALSE, &addr, sizeof(addr)); } else if (srv->flag & WITH_XOR_MAPPED) { pj_sockaddr_in addr; pj_sockaddr_in_init(&addr, &srv->ip_to_send, srv->port_to_send); pj_stun_msg_add_sockaddr_attr(pool, res_msg, PJ_STUN_ATTR_XOR_MAPPED_ADDR, PJ_TRUE, &addr, sizeof(addr)); } /* Encode */ status = pj_stun_msg_encode(res_msg, (pj_uint8_t*)data, 100, 0, NULL, &size); if (status != PJ_SUCCESS) { app_perror(" pj_stun_msg_encode()", status); pj_pool_release(pool); return PJ_TRUE; } /* Send back */ sent = size; pj_activesock_sendto(asock, &srv->send_key, data, &sent, 0, src_addr, addr_len); pj_pool_release(pool); } else if (srv->flag & ECHO) { /* Send back */ sent = size; pj_activesock_sendto(asock, &srv->send_key, data, &sent, 0, src_addr, addr_len); } return PJ_TRUE; }
PJ_DEF(pj_status_t) pjmedia_vid_port_create( pj_pool_t *pool, const pjmedia_vid_port_param *prm, pjmedia_vid_port **p_vid_port) { pjmedia_vid_port *vp; const pjmedia_video_format_detail *vfd; char dev_name[64]; char fmt_name[5]; pjmedia_vid_dev_cb vid_cb; pj_bool_t need_frame_buf = PJ_FALSE; pj_status_t status; unsigned ptime_usec; pjmedia_vid_dev_param vparam; pjmedia_vid_dev_info di; unsigned i; PJ_ASSERT_RETURN(pool && prm && p_vid_port, PJ_EINVAL); PJ_ASSERT_RETURN(prm->vidparam.fmt.type == PJMEDIA_TYPE_VIDEO && prm->vidparam.dir != PJMEDIA_DIR_NONE && prm->vidparam.dir != PJMEDIA_DIR_CAPTURE_RENDER, PJ_EINVAL); /* Retrieve the video format detail */ vfd = pjmedia_format_get_video_format_detail(&prm->vidparam.fmt, PJ_TRUE); if (!vfd) return PJ_EINVAL; PJ_ASSERT_RETURN(vfd->fps.num, PJ_EINVAL); /* Allocate videoport */ vp = PJ_POOL_ZALLOC_T(pool, pjmedia_vid_port); vp->pool = pj_pool_create(pool->factory, "video port", 500, 500, NULL); vp->role = prm->active ? ROLE_ACTIVE : ROLE_PASSIVE; vp->dir = prm->vidparam.dir; // vp->cap_size = vfd->size; vparam = prm->vidparam; dev_name[0] = '\0'; /* Get device info */ if (vp->dir & PJMEDIA_DIR_CAPTURE) status = pjmedia_vid_dev_get_info(prm->vidparam.cap_id, &di); else status = pjmedia_vid_dev_get_info(prm->vidparam.rend_id, &di); if (status != PJ_SUCCESS) return status; pj_ansi_snprintf(dev_name, sizeof(dev_name), "%s [%s]", di.name, di.driver); for (i = 0; i < di.fmt_cnt; ++i) { if (prm->vidparam.fmt.id == di.fmt[i].id) break; } if (i == di.fmt_cnt) { /* The device has no no matching format. Pick one from * the supported formats, and later use converter to * convert it to the required format. */ pj_assert(di.fmt_cnt != 0); vparam.fmt.id = di.fmt[0].id; } pj_strdup2_with_null(pool, &vp->dev_name, di.name); vp->stream_role = di.has_callback ? ROLE_ACTIVE : ROLE_PASSIVE; pjmedia_fourcc_name(vparam.fmt.id, fmt_name); PJ_LOG(4,(THIS_FILE, "Opening device %s for %s: format=%s, size=%dx%d @%d:%d fps", dev_name, vid_dir_name(prm->vidparam.dir), fmt_name, vfd->size.w, vfd->size.h, vfd->fps.num, vfd->fps.denum)); ptime_usec = PJMEDIA_PTIME(&vfd->fps); pjmedia_clock_src_init(&vp->clocksrc, PJMEDIA_TYPE_VIDEO, prm->vidparam.clock_rate, ptime_usec); vp->sync_clocksrc.max_sync_ticks = PJMEDIA_CLOCK_SYNC_MAX_RESYNC_DURATION * 1000 / vp->clocksrc.ptime_usec; /* Create the video stream */ pj_bzero(&vid_cb, sizeof(vid_cb)); vid_cb.capture_cb = &vidstream_cap_cb; vid_cb.render_cb = &vidstream_render_cb; status = pjmedia_vid_dev_stream_create(&vparam, &vid_cb, vp, &vp->strm); if (status != PJ_SUCCESS) goto on_error; PJ_LOG(4,(THIS_FILE, "Device %s opened: format=%s, size=%dx%d @%d:%d fps", dev_name, fmt_name, vparam.fmt.det.vid.size.w, vparam.fmt.det.vid.size.h, vparam.fmt.det.vid.fps.num, vparam.fmt.det.vid.fps.denum)); /* Subscribe to device's events */ pjmedia_event_subscribe(NULL, &vidstream_event_cb, vp, vp->strm); if (vp->dir & PJMEDIA_DIR_CAPTURE) { pjmedia_format_copy(&vp->conv.conv_param.src, &vparam.fmt); pjmedia_format_copy(&vp->conv.conv_param.dst, &prm->vidparam.fmt); } else { pjmedia_format_copy(&vp->conv.conv_param.src, &prm->vidparam.fmt); pjmedia_format_copy(&vp->conv.conv_param.dst, &vparam.fmt); } status = create_converter(vp); if (status != PJ_SUCCESS) goto on_error; if (vp->role==ROLE_ACTIVE && ((vp->dir & PJMEDIA_DIR_ENCODING) || vp->stream_role==ROLE_PASSIVE)) { pjmedia_clock_param param; /* Active role is wanted, but our device is passive, so create * master clocks to run the media flow. For encoding direction, * we also want to create our own clock since the device's clock * may run at a different rate. */ need_frame_buf = PJ_TRUE; param.usec_interval = PJMEDIA_PTIME(&vfd->fps); param.clock_rate = prm->vidparam.clock_rate; status = pjmedia_clock_create2(pool, ¶m, PJMEDIA_CLOCK_NO_HIGHEST_PRIO, (vp->dir & PJMEDIA_DIR_ENCODING) ? &enc_clock_cb: &dec_clock_cb, vp, &vp->clock); if (status != PJ_SUCCESS) goto on_error; } else if (vp->role==ROLE_PASSIVE) { vid_pasv_port *pp; /* Always need to create media port for passive role */ vp->pasv_port = pp = PJ_POOL_ZALLOC_T(pool, vid_pasv_port); pp->vp = vp; pp->base.get_frame = &vid_pasv_port_get_frame; pp->base.put_frame = &vid_pasv_port_put_frame; pjmedia_port_info_init2(&pp->base.info, &vp->dev_name, PJMEDIA_SIG_VID_PORT, prm->vidparam.dir, &prm->vidparam.fmt); if (vp->stream_role == ROLE_ACTIVE) { need_frame_buf = PJ_TRUE; } } if (need_frame_buf) { const pjmedia_video_format_info *vfi; pjmedia_video_apply_fmt_param vafp; vfi = pjmedia_get_video_format_info(NULL, vparam.fmt.id); if (!vfi) { status = PJ_ENOTFOUND; goto on_error; } pj_bzero(&vafp, sizeof(vafp)); vafp.size = vparam.fmt.det.vid.size; status = vfi->apply_fmt(vfi, &vafp); if (status != PJ_SUCCESS) goto on_error; vp->frm_buf = PJ_POOL_ZALLOC_T(pool, pjmedia_frame); vp->frm_buf_size = vafp.framebytes; vp->frm_buf->buf = pj_pool_alloc(pool, vafp.framebytes); vp->frm_buf->size = vp->frm_buf_size; vp->frm_buf->type = PJMEDIA_FRAME_TYPE_NONE; status = pj_mutex_create_simple(pool, vp->dev_name.ptr, &vp->frm_mutex); if (status != PJ_SUCCESS) goto on_error; } *p_vid_port = vp; return PJ_SUCCESS; on_error: pjmedia_vid_port_destroy(vp); return status; }
static pj_status_t factory_create_streamBDIMAD(pjmedia_aud_dev_factory *f, const pjmedia_aud_param *param, pjmedia_aud_rec_cb rec_cb, pjmedia_aud_play_cb play_cb, void *user_data, pjmedia_aud_stream **p_aud_strm) { struct bd_factory *wf = (struct bd_factory*)f; pj_pool_t *pool; struct bd_stream *strm; pj_uint8_t silence_char; pj_status_t status; switch (param->ext_fmt.id) { case PJMEDIA_FORMAT_L16: silence_char = '\0'; break; default: return PJMEDIA_EAUD_BADFORMAT; } /* Create and Initialize stream descriptor */ pool = pj_pool_create(wf->pf, "BDIMAD_STREAM", 1000, 1000, NULL); PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM); strm = PJ_POOL_ZALLOC_T(pool, struct bd_stream); pj_memcpy(&strm->param, param, sizeof(*param)); strm->pool = pool; strm->rec_cb = rec_cb; strm->play_cb = play_cb; strm->user_data = user_data; strm->fmt_id = (pjmedia_format_id)param->ext_fmt.id; strm->silence_char = silence_char; strm->channel_count = param->channel_count; strm->samples_per_frame = param->samples_per_frame; if (param->dir & PJMEDIA_DIR_CAPTURE_PLAYBACK) { status = init_streams(wf, strm, param); if (status != PJ_SUCCESS) { stream_destroyBDIMAD(&strm->base); return status; } } else { stream_destroyBDIMAD(&strm->base); return PJMEDIA_EAUD_ERR; } strm->rec_buf = (pj_int16_t*)pj_pool_alloc(pool, strm->bytes_per_frame); if (!strm->rec_buf) { pj_pool_release(pool); return PJ_ENOMEM; } strm->rec_buf_count = 0; strm->play_buf = (pj_int16_t*)pj_pool_alloc(pool, strm->bytes_per_frame); if (!strm->play_buf) { pj_pool_release(pool); return PJ_ENOMEM; } strm->play_buf_count = 0; /* Apply the remaining settings */ if(param->flags & PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING) { stream_set_capBDIMAD(&strm->base, PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING, ¶m->output_vol); } if(param->flags & PJMEDIA_AUD_DEV_CAP_INPUT_VOLUME_SETTING) { stream_set_capBDIMAD(&strm->base, PJMEDIA_AUD_DEV_CAP_INPUT_VOLUME_SETTING, ¶m->input_vol); } if(param->flags & PJMEDIA_AUD_DEV_CAP_EC) { stream_set_capBDIMAD(&strm->base, PJMEDIA_AUD_DEV_CAP_EC, ¶m->ec_enabled); } strm->base.op = &stream_op; *p_aud_strm = &strm->base; return PJ_SUCCESS; }
int string_test(void) { const pj_str_t hello_world = { HELLO_WORLD, HELLO_WORLD_LEN }; const pj_str_t just_hello = { JUST_HELLO, JUST_HELLO_LEN }; pj_str_t s1, s2, s3, s4, s5; enum { RCOUNT = 10, RLEN = 16 }; pj_str_t random[RCOUNT]; pj_pool_t *pool; int i; pool = pj_pool_create(mem, SNULL, 4096, 0, SNULL); if (!pool) return -5; /* * pj_str(), pj_strcmp(), pj_stricmp(), pj_strlen(), * pj_strncmp(), pj_strchr() */ s1 = pj_str(HELLO_WORLD); if (pj_strcmp(&s1, &hello_world) != 0) return -10; if (pj_stricmp(&s1, &hello_world) != 0) return -20; if (pj_strcmp(&s1, &just_hello) <= 0) return -30; if (pj_stricmp(&s1, &just_hello) <= 0) return -40; if (pj_strlen(&s1) != strlen(HELLO_WORLD)) return -50; if (pj_strncmp(&s1, &hello_world, 5) != 0) return -60; if (pj_strnicmp(&s1, &hello_world, 5) != 0) return -70; if (pj_strchr(&s1, HELLO_WORLD[1]) != s1.ptr+1) return -80; /* * pj_strdup() */ if (!pj_strdup(pool, &s2, &s1)) return -100; if (pj_strcmp(&s1, &s2) != 0) return -110; /* * pj_strcpy(), pj_strcat() */ s3.ptr = (char*) pj_pool_alloc(pool, 256); if (!s3.ptr) return -200; pj_strcpy(&s3, &s2); pj_strcat(&s3, &just_hello); if (pj_strcmp2(&s3, HELLO_WORLD JUST_HELLO) != 0) return -210; /* * pj_strdup2(), pj_strtrim(). */ pj_strdup2(pool, &s4, " " HELLO_WORLD "\t "); pj_strtrim(&s4); if (pj_strcmp2(&s4, HELLO_WORLD) != 0) return -250; /* * pj_utoa() */ s5.ptr = (char*) pj_pool_alloc(pool, 16); if (!s5.ptr) return -270; s5.slen = pj_utoa(UL_VALUE, s5.ptr); /* * pj_strtoul() */ if (pj_strtoul(&s5) != UL_VALUE) return -280; /* * pj_strtoul2() */ s5 = pj_str("123456"); pj_strtoul2(&s5, SNULL, 10); /* Crash test */ if (pj_strtoul2(&s5, &s4, 10) != 123456UL) return -290; if (s4.slen != 0) return -291; if (pj_strtoul2(&s5, &s4, 16) != 0x123456UL) return -292; s5 = pj_str("0123ABCD"); if (pj_strtoul2(&s5, &s4, 10) != 123) return -293; if (s4.slen != 4) return -294; if (s4.ptr == SNULL || *s4.ptr != 'A') return -295; if (pj_strtoul2(&s5, &s4, 16) != 0x123ABCDUL) return -296; if (s4.slen != 0) return -297; /* * pj_create_random_string() * Check that no duplicate strings are returned. */ for (i=0; i<RCOUNT; ++i) { int j; random[i].ptr = (char*) pj_pool_alloc(pool, RLEN); if (!random[i].ptr) return -320; random[i].slen = RLEN; pj_create_random_string(random[i].ptr, RLEN); for (j=0; j<i; ++j) { if (pj_strcmp(&random[i], &random[j])==0) return -330; } } /* Done. */ pj_pool_release(pool); /* Case sensitive comparison test. */ i = strcmp_test(); if (i != 0) return i; /* Caseless comparison test. */ i = stricmp_test(); if (i != 0) return i; return 0; }
/* API: create stream */ static pj_status_t bb10_factory_create_stream(pjmedia_aud_dev_factory *f, const pjmedia_aud_param *param, pjmedia_aud_rec_cb rec_cb, pjmedia_aud_play_cb play_cb, void *user_data, pjmedia_aud_stream **p_strm) { struct bb10_factory *af = (struct bb10_factory*)f; pj_status_t status; pj_pool_t* pool; struct bb10_stream* stream; pool = pj_pool_create (af->pf, "bb10%p", 1024, 1024, NULL); if (!pool) return PJ_ENOMEM; /* Allocate and initialize comon stream data */ stream = PJ_POOL_ZALLOC_T (pool, struct bb10_stream); stream->base.op = &bb10_stream_op; stream->pool = pool; stream->af = af; stream->user_data = user_data; stream->pb_cb = play_cb; stream->ca_cb = rec_cb; stream->quit = 0; pj_memcpy(&stream->param, param, sizeof(*param)); /* Init playback */ if (param->dir & PJMEDIA_DIR_PLAYBACK) { status = bb10_open_playback (stream, param); if (status != PJ_SUCCESS) { pj_pool_release (pool); return status; } } /* Init capture */ if (param->dir & PJMEDIA_DIR_CAPTURE) { status = bb10_open_capture (stream, param); if (status != PJ_SUCCESS) { if (param->dir & PJMEDIA_DIR_PLAYBACK) { close_play_pcm(stream); } pj_pool_release (pool); return status; } } /* Set the audio routing ONLY if app explicitly asks one */ if ((param->dir & PJMEDIA_DIR_PLAYBACK) && (param->flags & PJMEDIA_AUD_DEV_CAP_OUTPUT_ROUTE)) { status = bb10_stream_set_cap(&stream->base, PJMEDIA_AUD_DEV_CAP_OUTPUT_ROUTE, ¶m->output_route); if (status != PJ_SUCCESS) { TRACE_((THIS_FILE, "Error setting output route")); bb10_stream_destroy(&stream->base); return status; } } else { /* Legacy behavior: if none specified, set to speaker */ status = bb10_initialize_playback_ctrl(stream, false); } *p_strm = &stream->base; return PJ_SUCCESS; }
/* API: refresh the device list */ static pj_status_t factory_refresh(pjmedia_aud_dev_factory *f) { struct bd_factory *wf = (struct bd_factory*)f; unsigned int i = 0; wchar_t *deviceNamep=NULL; wchar_t captureDevName[BD_IMAD_MAX_DEV_COUNT][BD_IMAD_MAX_DEV_LENGTH_NAME]; unsigned int captureDeviceCount = 0; wchar_t playbackDevName[BD_IMAD_MAX_DEV_COUNT][BD_IMAD_MAX_DEV_LENGTH_NAME]; unsigned int playbackDeviceCount = 0; if(wf->pool != NULL) { pj_pool_release(wf->pool); wf->pool = NULL; } // Enumerate capture sound devices while(bdIMADpj_getDeviceName(BD_IMAD_CAPTURE_DEVICES, &deviceNamep) != BD_PJ_ERROR_IMAD_DEVICE_LIST_EMPTY) { wcscpy(captureDevName[captureDeviceCount], deviceNamep); captureDeviceCount++; } // Enumerate playback sound devices while(bdIMADpj_getDeviceName(BD_IMAD_PLAYBACK_DEVICES, &deviceNamep) != BD_PJ_ERROR_IMAD_DEVICE_LIST_EMPTY) { wcscpy(playbackDevName[playbackDeviceCount], deviceNamep); playbackDeviceCount++; } // Set devices info wf->dev_count = captureDeviceCount + playbackDeviceCount; wf->pool = pj_pool_create(wf->pf, "BD_IMAD_DEVICES", 1000, 1000, NULL); wf->dev_info = (struct bddev_info*)pj_pool_calloc(wf->pool, wf->dev_count, sizeof(struct bddev_info)); // Capture device properties for(i=0;i<captureDeviceCount;i++) { wf->dev_info[i].deviceId = i; wf->dev_info[i].info.caps = PJMEDIA_AUD_DEV_CAP_INPUT_VOLUME_SETTING | PJMEDIA_AUD_DEV_CAP_EC; wf->dev_info[i].info.default_samples_per_sec = BD_IMAD_DEFAULT_FREQ; strcpy(wf->dev_info[i].info.driver, "BD_IMAD"); wf->dev_info[i].info.ext_fmt_cnt = 0; wf->dev_info[i].info.input_count = BD_IMAD_MAX_CHANNELS; wf->dev_info[i].info.output_count = 0; strcpy(wf->dev_info[i].info.name, BD_IMAD_PJ_WCHARtoCHAR(captureDevName[i])); wf->dev_info[i].info.routes = 0; } // Playback device properties for(i=0;i<playbackDeviceCount;i++) { wf->dev_info[captureDeviceCount+i].deviceId = captureDeviceCount+i; wf->dev_info[captureDeviceCount+i].info.caps = PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING; wf->dev_info[captureDeviceCount+i].info.default_samples_per_sec = BD_IMAD_DEFAULT_FREQ; strcpy(wf->dev_info[captureDeviceCount+i].info.driver, "BD_IMAD"); wf->dev_info[captureDeviceCount+i].info.ext_fmt_cnt = 0; wf->dev_info[captureDeviceCount+i].info.input_count = 0; wf->dev_info[captureDeviceCount+i].info.output_count = BD_IMAD_MAX_CHANNELS; strcpy(wf->dev_info[captureDeviceCount+i].info.name, BD_IMAD_PJ_WCHARtoCHAR(playbackDevName[i])); wf->dev_info[captureDeviceCount+i].info.routes = 0; } PJ_LOG(4, (THIS_FILE, "BDIMAD found %d devices:", wf->dev_count)); for(i=0; i<wf->dev_count; i++) { PJ_LOG(4, (THIS_FILE, " dev_id %d: %s (in=%d, out=%d)", i, wf->dev_info[i].info.name, wf->dev_info[i].info.input_count, wf->dev_info[i].info.output_count)); } return PJ_SUCCESS; }
/* * Create the STUN transport using the specified configuration. */ PJ_DEF(pj_status_t) pj_stun_sock_create( pj_stun_config *stun_cfg, const char *name, int af, const pj_stun_sock_cb *cb, const pj_stun_sock_cfg *cfg, void *user_data, pj_stun_sock **p_stun_sock) { pj_pool_t *pool; pj_stun_sock *stun_sock; pj_stun_sock_cfg default_cfg; pj_sockaddr bound_addr; unsigned i; pj_uint16_t max_bind_retry; pj_status_t status; PJ_ASSERT_RETURN(stun_cfg && cb && p_stun_sock, PJ_EINVAL); PJ_ASSERT_RETURN(af==pj_AF_INET()||af==pj_AF_INET6(), PJ_EAFNOTSUP); PJ_ASSERT_RETURN(!cfg || pj_stun_sock_cfg_is_valid(cfg), PJ_EINVAL); PJ_ASSERT_RETURN(cb->on_status, PJ_EINVAL); status = pj_stun_config_check_valid(stun_cfg); if (status != PJ_SUCCESS) return status; if (name == NULL) name = "stuntp%p"; if (cfg == NULL) { pj_stun_sock_cfg_default(&default_cfg); cfg = &default_cfg; } /* Create structure */ pool = pj_pool_create(stun_cfg->pf, name, 256, 512, NULL); stun_sock = PJ_POOL_ZALLOC_T(pool, pj_stun_sock); stun_sock->pool = pool; stun_sock->obj_name = pool->obj_name; stun_sock->user_data = user_data; stun_sock->af = af; stun_sock->sock_fd = PJ_INVALID_SOCKET; pj_memcpy(&stun_sock->stun_cfg, stun_cfg, sizeof(*stun_cfg)); pj_memcpy(&stun_sock->cb, cb, sizeof(*cb)); stun_sock->ka_interval = cfg->ka_interval; if (stun_sock->ka_interval == 0) stun_sock->ka_interval = PJ_STUN_KEEP_ALIVE_SEC; if (cfg && cfg->grp_lock) { stun_sock->grp_lock = cfg->grp_lock; } else { status = pj_grp_lock_create(pool, NULL, &stun_sock->grp_lock); if (status != PJ_SUCCESS) { pj_pool_release(pool); return status; } } pj_grp_lock_add_ref(stun_sock->grp_lock); pj_grp_lock_add_handler(stun_sock->grp_lock, pool, stun_sock, &stun_sock_destructor); /* Create socket and bind socket */ status = pj_sock_socket(af, pj_SOCK_DGRAM(), 0, &stun_sock->sock_fd); if (status != PJ_SUCCESS) goto on_error; /* Apply QoS, if specified */ status = pj_sock_apply_qos2(stun_sock->sock_fd, cfg->qos_type, &cfg->qos_params, 2, stun_sock->obj_name, NULL); if (status != PJ_SUCCESS && !cfg->qos_ignore_error) goto on_error; /* Apply socket buffer size */ if (cfg->so_rcvbuf_size > 0) { unsigned sobuf_size = cfg->so_rcvbuf_size; status = pj_sock_setsockopt_sobuf(stun_sock->sock_fd, pj_SO_RCVBUF(), PJ_TRUE, &sobuf_size); if (status != PJ_SUCCESS) { pj_perror(3, stun_sock->obj_name, status, "Failed setting SO_RCVBUF"); } else { if (sobuf_size < cfg->so_rcvbuf_size) { PJ_LOG(4, (stun_sock->obj_name, "Warning! Cannot set SO_RCVBUF as configured, " "now=%d, configured=%d", sobuf_size, cfg->so_rcvbuf_size)); } else { PJ_LOG(5, (stun_sock->obj_name, "SO_RCVBUF set to %d", sobuf_size)); } } } if (cfg->so_sndbuf_size > 0) { unsigned sobuf_size = cfg->so_sndbuf_size; status = pj_sock_setsockopt_sobuf(stun_sock->sock_fd, pj_SO_SNDBUF(), PJ_TRUE, &sobuf_size); if (status != PJ_SUCCESS) { pj_perror(3, stun_sock->obj_name, status, "Failed setting SO_SNDBUF"); } else { if (sobuf_size < cfg->so_sndbuf_size) { PJ_LOG(4, (stun_sock->obj_name, "Warning! Cannot set SO_SNDBUF as configured, " "now=%d, configured=%d", sobuf_size, cfg->so_sndbuf_size)); } else { PJ_LOG(5, (stun_sock->obj_name, "SO_SNDBUF set to %d", sobuf_size)); } } } /* Bind socket */ max_bind_retry = MAX_BIND_RETRY; if (cfg->port_range && cfg->port_range < max_bind_retry) max_bind_retry = cfg->port_range; pj_sockaddr_init(af, &bound_addr, NULL, 0); if (cfg->bound_addr.addr.sa_family == pj_AF_INET() || cfg->bound_addr.addr.sa_family == pj_AF_INET6()) { pj_sockaddr_cp(&bound_addr, &cfg->bound_addr); } status = pj_sock_bind_random(stun_sock->sock_fd, &bound_addr, cfg->port_range, max_bind_retry); if (status != PJ_SUCCESS) goto on_error; /* Create more useful information string about this transport */ #if 0 { pj_sockaddr bound_addr; int addr_len = sizeof(bound_addr); status = pj_sock_getsockname(stun_sock->sock_fd, &bound_addr, &addr_len); if (status != PJ_SUCCESS) goto on_error; stun_sock->info = pj_pool_alloc(pool, PJ_INET6_ADDRSTRLEN+10); pj_sockaddr_print(&bound_addr, stun_sock->info, PJ_INET6_ADDRSTRLEN, 3); } #endif /* Init active socket configuration */ { pj_activesock_cfg activesock_cfg; pj_activesock_cb activesock_cb; pj_activesock_cfg_default(&activesock_cfg); activesock_cfg.grp_lock = stun_sock->grp_lock; activesock_cfg.async_cnt = cfg->async_cnt; activesock_cfg.concurrency = 0; /* Create the active socket */ pj_bzero(&activesock_cb, sizeof(activesock_cb)); activesock_cb.on_data_recvfrom = &on_data_recvfrom; activesock_cb.on_data_sent = &on_data_sent; status = pj_activesock_create(pool, stun_sock->sock_fd, pj_SOCK_DGRAM(), &activesock_cfg, stun_cfg->ioqueue, &activesock_cb, stun_sock, &stun_sock->active_sock); if (status != PJ_SUCCESS) goto on_error; /* Start asynchronous read operations */ status = pj_activesock_start_recvfrom(stun_sock->active_sock, pool, cfg->max_pkt_size, 0); if (status != PJ_SUCCESS) goto on_error; /* Init send keys */ pj_ioqueue_op_key_init(&stun_sock->send_key, sizeof(stun_sock->send_key)); pj_ioqueue_op_key_init(&stun_sock->int_send_key, sizeof(stun_sock->int_send_key)); } /* Create STUN session */ { pj_stun_session_cb sess_cb; pj_bzero(&sess_cb, sizeof(sess_cb)); sess_cb.on_request_complete = &sess_on_request_complete; sess_cb.on_send_msg = &sess_on_send_msg; status = pj_stun_session_create(&stun_sock->stun_cfg, stun_sock->obj_name, &sess_cb, PJ_FALSE, stun_sock->grp_lock, &stun_sock->stun_sess); if (status != PJ_SUCCESS) goto on_error; } /* Associate us with the STUN session */ pj_stun_session_set_user_data(stun_sock->stun_sess, stun_sock); /* Initialize random numbers to be used as STUN transaction ID for * outgoing Binding request. We use the 80bit number to distinguish * STUN messages we sent with STUN messages that the application sends. * The last 16bit value in the array is a counter. */ for (i=0; i<PJ_ARRAY_SIZE(stun_sock->tsx_id); ++i) { stun_sock->tsx_id[i] = (pj_uint16_t) pj_rand(); } stun_sock->tsx_id[5] = 0; /* Init timer entry */ stun_sock->ka_timer.cb = &ka_timer_cb; stun_sock->ka_timer.user_data = stun_sock; /* Done */ *p_stun_sock = stun_sock; return PJ_SUCCESS; on_error: pj_stun_sock_destroy(stun_sock); return status; }
/* * Encode test. Read input from WAV file, encode to temporary output file, * and compare the temporary output file to the reference file. */ static int codec_test_encode(pjmedia_codec_mgr *mgr, char *codec_name, unsigned bitrate, const char *wav_file, const char *ref_encoded_file) { pj_str_t codec_id = pj_str(codec_name); pj_pool_t *pool = NULL; unsigned count, samples_per_frame, encoded_frame_len = 0, pos; pjmedia_codec *codec = NULL; const pjmedia_codec_info *ci[1]; pjmedia_codec_param codec_param; pjmedia_port *wav_port = NULL; pjmedia_frame in_frame, out_frame; FILE *output = NULL, *fref = NULL; int rc = 0; pj_status_t status; pool = pj_pool_create(mem, "codec-vectors", 512, 512, NULL); if (!pool) { rc = -20; goto on_return; } /* Find and open the codec */ count = 1; status = pjmedia_codec_mgr_find_codecs_by_id(mgr, &codec_id, &count, ci, NULL); if (status != PJ_SUCCESS) { rc = -30; goto on_return; } status = pjmedia_codec_mgr_alloc_codec(mgr, ci[0], &codec); if (status != PJ_SUCCESS) { rc = -40; goto on_return; } status = pjmedia_codec_mgr_get_default_param(mgr, ci[0], &codec_param); if (status != PJ_SUCCESS) { rc = -50; goto on_return; } codec_param.info.avg_bps = bitrate; codec_param.setting.vad = 0; status = codec->op->init(codec, pool); if (status != PJ_SUCCESS) { rc = -60; goto on_return; } status = codec->op->open(codec, &codec_param); if (status != PJ_SUCCESS) { rc = -70; goto on_return; } /* Open WAV file */ status = pjmedia_wav_player_port_create(pool, wav_file, codec_param.info.frm_ptime, PJMEDIA_FILE_NO_LOOP, 0, &wav_port); if (status != PJ_SUCCESS) { rc = -80; goto on_return; } /* Open output file */ output = fopen(TMP_OUT, "wb"); if (!output) { rc = -90; goto on_return; } /* Allocate buffer for PCM and encoded frames */ samples_per_frame = codec_param.info.clock_rate * codec_param.info.frm_ptime / 1000; in_frame.buf = pj_pool_alloc(pool, samples_per_frame * 2); out_frame.buf = (pj_uint8_t*) pj_pool_alloc(pool, samples_per_frame); /* Loop read WAV file and encode and write to output file */ for (;;) { in_frame.size = samples_per_frame * 2; in_frame.type = PJMEDIA_FRAME_TYPE_AUDIO; status = pjmedia_port_get_frame(wav_port, &in_frame); if (status != PJ_SUCCESS || in_frame.type != PJMEDIA_FRAME_TYPE_AUDIO) break; out_frame.size = samples_per_frame; status = codec->op->encode(codec, &in_frame, samples_per_frame, &out_frame); if (status != PJ_SUCCESS) { rc = -95; goto on_return; } if (out_frame.size) { int cnt; cnt = fwrite(out_frame.buf, out_frame.size, 1, output); if (encoded_frame_len == 0) encoded_frame_len = out_frame.size; } } fclose(output); output = NULL; /* Compare encoded files */ fref = fopen(ref_encoded_file, "rb"); if (!fref) { rc = -100; goto on_return; } output = fopen(TMP_OUT, "rb"); if (!output) { rc = -110; goto on_return; } pos = 0; for (;;) { int count; count = fread(in_frame.buf, encoded_frame_len, 1, fref); if (count != 1) break; count = fread(out_frame.buf, encoded_frame_len, 1, output); if (count != 1) break; if (memcmp(in_frame.buf, out_frame.buf, encoded_frame_len)) { unsigned i; pj_uint8_t *in = (pj_uint8_t*)in_frame.buf; pj_uint8_t *out = (pj_uint8_t*)out_frame.buf; for (i=0; i<encoded_frame_len; ++i) { if (in[i] != out[i]) break; } PJ_LOG(1,(THIS_FILE," failed: mismatch at pos %d", pos+i)); rc = -200; break; } pos += encoded_frame_len; } on_return: if (output) fclose(output); if (fref) fclose(fref); if (codec) { codec->op->close(codec); pjmedia_codec_mgr_dealloc_codec(mgr, codec); } if (wav_port) pjmedia_port_destroy(wav_port); if (pool) pj_pool_release(pool); return rc; }
/* * Decode test * * Decode the specified encoded file in "in_encoded_file" into temporary * PCM output file, and compare the temporary PCM output file with * the PCM reference file. * * Some reference file requires manipulation to the PCM output * before comparison, such manipulation can be done by supplying * this function with the "manip" function. */ static int codec_test_decode(pjmedia_codec_mgr *mgr, char *codec_name, unsigned bitrate, unsigned encoded_len, const char *in_encoded_file, const char *ref_pcm_file, void (*manip)(short *pcm, unsigned count)) { pj_str_t codec_id = pj_str(codec_name); pj_pool_t *pool = NULL; unsigned count, samples_per_frame, pos; pjmedia_codec *codec = NULL; const pjmedia_codec_info *ci[1]; pjmedia_codec_param codec_param; pjmedia_frame out_frame; void *pkt; FILE *input = NULL, *output = NULL, *fref = NULL; pj_bool_t is_itu_format = PJ_FALSE; int rc = 0; pj_status_t status; pool = pj_pool_create(mem, "codec-vectors", 512, 512, NULL); if (!pool) { rc = -20; goto on_return; } /* Find and open the codec */ count = 1; status = pjmedia_codec_mgr_find_codecs_by_id(mgr, &codec_id, &count, ci, NULL); if (status != PJ_SUCCESS) { rc = -30; goto on_return; } status = pjmedia_codec_mgr_alloc_codec(mgr, ci[0], &codec); if (status != PJ_SUCCESS) { rc = -40; goto on_return; } status = pjmedia_codec_mgr_get_default_param(mgr, ci[0], &codec_param); if (status != PJ_SUCCESS) { rc = -50; goto on_return; } codec_param.info.avg_bps = bitrate; codec_param.setting.vad = 0; status = codec->op->init(codec, pool); if (status != PJ_SUCCESS) { rc = -60; goto on_return; } status = codec->op->open(codec, &codec_param); if (status != PJ_SUCCESS) { rc = -70; goto on_return; } /* Open input file */ input = fopen(in_encoded_file, "rb"); if (!input) { rc = -80; goto on_return; } /* Is the file in ITU format? */ is_itu_format = pj_ansi_stricmp(in_encoded_file+strlen(in_encoded_file)-4, ".itu")==0; /* Open output file */ output = fopen(TMP_OUT, "wb"); if (!output) { rc = -90; goto on_return; } /* Allocate buffer for PCM and encoded frames */ samples_per_frame = codec_param.info.clock_rate * codec_param.info.frm_ptime / 1000; pkt = pj_pool_alloc(pool, samples_per_frame * 2); out_frame.buf = (pj_uint8_t*) pj_pool_alloc(pool, samples_per_frame * 2); /* Loop read WAV file and encode and write to output file */ for (;;) { pjmedia_frame in_frame[2]; pj_timestamp ts; unsigned count; pj_bool_t has_frame; if (is_itu_format) { int nsamp; short frame_err = 0; nsamp = read_ITU_format(input, (short*)pkt, &frame_err, encoded_len / 2, PJ_TRUE); if (nsamp != (int)encoded_len / 2) break; has_frame = !frame_err; } else { if (fread(pkt, encoded_len, 1, input) != 1) break; has_frame = PJ_TRUE; } if (has_frame) { count = 2; if (codec->op->parse(codec, pkt, encoded_len, &ts, &count, in_frame) != PJ_SUCCESS) { rc = -100; goto on_return; } if (count != 1) { rc = -110; goto on_return; } if (codec->op->decode(codec, &in_frame[0], samples_per_frame*2, &out_frame) != PJ_SUCCESS) { rc = -120; goto on_return; } } else { if (codec->op->recover(codec, samples_per_frame*2, &out_frame) != PJ_SUCCESS) { rc = -125; goto on_return; } } if (manip) manip((short*)out_frame.buf, samples_per_frame); if (fwrite(out_frame.buf, out_frame.size, 1, output) != 1) { rc = -130; goto on_return; } } fclose(input); input = NULL; fclose(output); output = NULL; /* Compare encoded files */ fref = fopen(ref_pcm_file, "rb"); if (!fref) { rc = -140; goto on_return; } output = fopen(TMP_OUT, "rb"); if (!output) { rc = -110; goto on_return; } pos = 0; for (;;) { int count; count = fread(pkt, samples_per_frame*2, 1, fref); if (count != 1) break; count = fread(out_frame.buf, samples_per_frame*2, 1, output); if (count != 1) break; if (memcmp(pkt, out_frame.buf, samples_per_frame*2)) { unsigned i; pj_int16_t *in = (pj_int16_t*)pkt; pj_int16_t *out = (pj_int16_t*)out_frame.buf; for (i=0; i<samples_per_frame; ++i) { if (in[i] != out[i]) break; } PJ_LOG(1,(THIS_FILE," failed: mismatch at samples %d", pos+i)); rc = -200; break; } pos += samples_per_frame; } on_return: if (output) fclose(output); if (fref) fclose(fref); if (input) fclose(input); if (codec) { codec->op->close(codec); pjmedia_codec_mgr_dealloc_codec(mgr, codec); } if (pool) pj_pool_release(pool); return rc; }
/* SSL socket try to connect to raw TCP socket server, once * connection established, SSL socket will try to perform SSL * handshake. SSL client socket should be able to close the * connection after specified timeout period (set ms_timeout to * 0 to disable timer). */ static int server_non_ssl(unsigned ms_timeout) { pj_pool_t *pool = NULL; pj_ioqueue_t *ioqueue = NULL; pj_timer_heap_t *timer = NULL; pj_activesock_t *asock_serv = NULL; pj_ssl_sock_t *ssock_cli = NULL; pj_activesock_cb asock_cb = { 0 }; pj_sock_t sock = PJ_INVALID_SOCKET; pj_ssl_sock_param param; struct test_state state_serv = { 0 }; struct test_state state_cli = { 0 }; pj_sockaddr addr, listen_addr; pj_status_t status; pool = pj_pool_create(mem, "ssl_connect_raw_tcp", 256, 256, NULL); status = pj_ioqueue_create(pool, 4, &ioqueue); if (status != PJ_SUCCESS) { goto on_return; } status = pj_timer_heap_create(pool, 4, &timer); if (status != PJ_SUCCESS) { goto on_return; } /* SERVER */ state_serv.pool = pool; state_serv.ioqueue = ioqueue; status = pj_sock_socket(pj_AF_INET(), pj_SOCK_STREAM(), 0, &sock); if (status != PJ_SUCCESS) { goto on_return; } /* Init bind address */ { pj_str_t tmp_st; pj_sockaddr_init(PJ_AF_INET, &listen_addr, pj_strset2(&tmp_st, "127.0.0.1"), 0); } status = pj_sock_bind(sock, (pj_sockaddr_t*)&listen_addr, pj_sockaddr_get_len((pj_sockaddr_t*)&listen_addr)); if (status != PJ_SUCCESS) { goto on_return; } status = pj_sock_listen(sock, PJ_SOMAXCONN); if (status != PJ_SUCCESS) { goto on_return; } asock_cb.on_accept_complete = &asock_on_accept_complete; status = pj_activesock_create(pool, sock, pj_SOCK_STREAM(), NULL, ioqueue, &asock_cb, &state_serv, &asock_serv); if (status != PJ_SUCCESS) { goto on_return; } status = pj_activesock_start_accept(asock_serv, pool); if (status != PJ_SUCCESS) goto on_return; /* Update listener address */ { int addr_len; addr_len = sizeof(listen_addr); pj_sock_getsockname(sock, (pj_sockaddr_t*)&listen_addr, &addr_len); } /* CLIENT */ pj_ssl_sock_param_default(¶m); param.cb.on_connect_complete = &ssl_on_connect_complete; param.cb.on_data_read = &ssl_on_data_read; param.cb.on_data_sent = &ssl_on_data_sent; param.ioqueue = ioqueue; param.timer_heap = timer; param.timeout.sec = 0; param.timeout.msec = ms_timeout; pj_time_val_normalize(¶m.timeout); param.user_data = &state_cli; state_cli.pool = pool; state_cli.is_server = PJ_FALSE; state_cli.is_verbose = PJ_TRUE; status = pj_ssl_sock_create(pool, ¶m, &ssock_cli); if (status != PJ_SUCCESS) { goto on_return; } /* Init default bind address */ { pj_str_t tmp_st; pj_sockaddr_init(PJ_AF_INET, &addr, pj_strset2(&tmp_st, "127.0.0.1"), 0); } status = pj_ssl_sock_start_connect(ssock_cli, pool, (pj_sockaddr_t*)&addr, (pj_sockaddr_t*)&listen_addr, pj_sockaddr_get_len(&listen_addr)); if (status != PJ_EPENDING) { goto on_return; } /* Wait until everything has been sent/received or error */ while ((!state_serv.err && !state_serv.done) || (!state_cli.err && !state_cli.done)) { #ifdef PJ_SYMBIAN pj_symbianos_poll(-1, 1000); #else pj_time_val delay = {0, 100}; pj_ioqueue_poll(ioqueue, &delay); pj_timer_heap_poll(timer, &delay); #endif } if (state_serv.err || state_cli.err) { if (state_cli.err != PJ_SUCCESS) status = state_cli.err; else status = state_serv.err; goto on_return; } PJ_LOG(3, ("", "...Done!")); on_return: if (asock_serv) pj_activesock_close(asock_serv); if (ssock_cli && !state_cli.err && !state_cli.done) pj_ssl_sock_close(ssock_cli); if (timer) pj_timer_heap_destroy(timer); if (ioqueue) pj_ioqueue_destroy(ioqueue); if (pool) pj_pool_release(pool); return status; }
int main(int argc, char *argv[]) { pj_str_t input, output, srtp_crypto, srtp_key, codec; pjmedia_aud_dev_index dev_id = PJMEDIA_AUD_DEFAULT_PLAYBACK_DEV; pj_pcap_filter filter; pj_status_t status; enum { OPT_SRC_IP = 1, OPT_DST_IP, OPT_SRC_PORT, OPT_DST_PORT, OPT_CODEC, OPT_PLAY_DEV_ID }; struct pj_getopt_option long_options[] = { { "srtp-crypto", 1, 0, 'c' }, { "srtp-key", 1, 0, 'k' }, { "src-ip", 1, 0, OPT_SRC_IP }, { "dst-ip", 1, 0, OPT_DST_IP }, { "src-port", 1, 0, OPT_SRC_PORT }, { "dst-port", 1, 0, OPT_DST_PORT }, { "codec", 1, 0, OPT_CODEC }, { "play-dev-id", 1, 0, OPT_PLAY_DEV_ID }, { NULL, 0, 0, 0} }; int c; int option_index; char key_bin[32]; srtp_crypto.slen = srtp_key.slen = 0; codec.slen = 0; pj_pcap_filter_default(&filter); filter.link = PJ_PCAP_LINK_TYPE_ETH; filter.proto = PJ_PCAP_PROTO_TYPE_UDP; /* Parse arguments */ pj_optind = 0; while((c=pj_getopt_long(argc,argv, "c:k:", long_options, &option_index))!=-1) { switch (c) { case 'c': srtp_crypto = pj_str(pj_optarg); break; case 'k': { int key_len = sizeof(key_bin); srtp_key = pj_str(pj_optarg); if (pj_base64_decode(&srtp_key, (pj_uint8_t*)key_bin, &key_len)) { puts("Error: invalid key"); return 1; } srtp_key.ptr = key_bin; srtp_key.slen = key_len; } break; case OPT_SRC_IP: { pj_str_t t = pj_str(pj_optarg); pj_in_addr a = pj_inet_addr(&t); filter.ip_src = a.s_addr; } break; case OPT_DST_IP: { pj_str_t t = pj_str(pj_optarg); pj_in_addr a = pj_inet_addr(&t); filter.ip_dst = a.s_addr; } break; case OPT_SRC_PORT: filter.src_port = pj_htons((pj_uint16_t)atoi(pj_optarg)); break; case OPT_DST_PORT: filter.dst_port = pj_htons((pj_uint16_t)atoi(pj_optarg)); break; case OPT_CODEC: codec = pj_str(pj_optarg); break; case OPT_PLAY_DEV_ID: dev_id = atoi(pj_optarg); break; default: puts("Error: invalid option"); return 1; } } if (pj_optind != argc - 2) { puts(USAGE); return 1; } if (!(srtp_crypto.slen) != !(srtp_key.slen)) { puts("Error: both SRTP crypto and key must be specified"); puts(USAGE); return 1; } input = pj_str(argv[pj_optind]); output = pj_str(argv[pj_optind+1]); T( pj_init() ); pj_caching_pool_init(&app.cp, NULL, 0); app.pool = pj_pool_create(&app.cp.factory, "pcaputil", 1000, 1000, NULL); T( pjlib_util_init() ); T( pjmedia_endpt_create(&app.cp.factory, NULL, 0, &app.mept) ); T( pj_pcap_open(app.pool, input.ptr, &app.pcap) ); T( pj_pcap_set_filter(app.pcap, &filter) ); pcap2wav(&codec, &output, dev_id, &srtp_crypto, &srtp_key); cleanup(); return 0; }
/* * main() * */ int main(int argc, char *argv[]) { pj_caching_pool cp; pj_pool_t *pool = NULL; pjsip_module mod_app = { NULL, NULL, /* prev, next. */ { "mod-app", 7 }, /* Name. */ -1, /* Id */ PJSIP_MOD_PRIORITY_APPLICATION, /* Priority */ NULL, /* load() */ NULL, /* start() */ NULL, /* stop() */ NULL, /* unload() */ &on_rx_request, /* on_rx_request() */ NULL, /* on_rx_response() */ NULL, /* on_tx_request. */ NULL, /* on_tx_response() */ NULL, /* on_tsx_state() */ }; int c; pj_status_t status; /* Must init PJLIB first: */ status = pj_init(); PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1); /* Then init PJLIB-UTIL: */ status = pjlib_util_init(); PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1); /* Must create a pool factory before we can allocate any memory. */ pj_caching_pool_init(&cp, &pj_pool_factory_default_policy, 0); /* Create global endpoint: */ { /* Endpoint MUST be assigned a globally unique name. * Ideally we should put hostname or public IP address, but * we'll just use an arbitrary name here. */ /* Create the endpoint: */ status = pjsip_endpt_create(&cp.factory, "sipstateless", &sip_endpt); PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1); } /* Parse arguments */ pj_optind = 0; pj_list_init(&hdr_list); while ((c=pj_getopt(argc, argv , "H:")) != -1) { switch (c) { case 'H': if (pool == NULL) { pool = pj_pool_create(&cp.factory, "sipstateless", 1000, 1000, NULL); } if (pool) { char *name; name = strtok(pj_optarg, ":"); if (name == NULL) { puts("Error: invalid header format"); return 1; } else { char *val = strtok(NULL, "\r\n"); pjsip_generic_string_hdr *h; pj_str_t hname, hvalue; hname = pj_str(name); hvalue = pj_str(val); h = pjsip_generic_string_hdr_create(pool, &hname, &hvalue); pj_list_push_back(&hdr_list, h); PJ_LOG(4,(THIS_FILE, "Header %s: %s added", name, val)); } } break; default: puts("Error: invalid argument"); usage(); return 1; } } if (pj_optind != argc) { code = atoi(argv[pj_optind]); if (code < 200 || code > 699) { puts("Error: invalid status code"); usage(); return 1; } } PJ_LOG(4,(THIS_FILE, "Returning %d to incoming requests", code)); /* * Add UDP transport, with hard-coded port */ #ifdef HAS_UDP_TRANSPORT { pj_sockaddr_in addr; addr.sin_family = pj_AF_INET(); addr.sin_addr.s_addr = 0; addr.sin_port = pj_htons(5060); status = pjsip_udp_transport_start( sip_endpt, &addr, NULL, 1, NULL); if (status != PJ_SUCCESS) { PJ_LOG(3,(THIS_FILE, "Error starting UDP transport (port in use?)")); return 1; } } #endif #if HAS_TCP_TRANSPORT /* * Add UDP transport, with hard-coded port */ { pj_sockaddr_in addr; addr.sin_family = pj_AF_INET(); addr.sin_addr.s_addr = 0; addr.sin_port = pj_htons(5060); status = pjsip_tcp_transport_start(sip_endpt, &addr, 1, NULL); if (status != PJ_SUCCESS) { PJ_LOG(3,(THIS_FILE, "Error starting TCP transport (port in use?)")); return 1; } } #endif /* * Register our module to receive incoming requests. */ status = pjsip_endpt_register_module( sip_endpt, &mod_app); PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1); /* Done. Loop forever to handle incoming events. */ PJ_LOG(3,(THIS_FILE, "Press Ctrl-C to quit..")); for (;;) { pjsip_endpt_handle_events(sip_endpt, NULL); } }
int fifobuf_test() { enum { SIZE = 1024, MAX_ENTRIES = 128, MIN_SIZE = 4, MAX_SIZE = 64, LOOP=10000 }; pj_pool_t *pool; pj_fifobuf_t fifo; unsigned available = SIZE; void *entries[MAX_ENTRIES]; void *buffer; int i; pool = pj_pool_create(mem, NULL, SIZE+256, 0, NULL); if (!pool) return -10; buffer = pj_pool_alloc(pool, SIZE); if (!buffer) return -20; pj_fifobuf_init (&fifo, buffer, SIZE); // Test 1 for (i=0; i<LOOP*MAX_ENTRIES; ++i) { int size; int c, f; c = i%2; f = (i+1)%2; do { size = MIN_SIZE+(pj_rand() % MAX_SIZE); entries[c] = pj_fifobuf_alloc (&fifo, size); } while (entries[c] == 0); if ( i!=0) { pj_fifobuf_free(&fifo, entries[f]); } } if (entries[(i+1)%2]) pj_fifobuf_free(&fifo, entries[(i+1)%2]); if (pj_fifobuf_max_size(&fifo) < SIZE-4) { pj_assert(0); return -1; } // Test 2 entries[0] = pj_fifobuf_alloc (&fifo, MIN_SIZE); if (!entries[0]) return -1; for (i=0; i<LOOP*MAX_ENTRIES; ++i) { int size = MIN_SIZE+(pj_rand() % MAX_SIZE); entries[1] = pj_fifobuf_alloc (&fifo, size); if (entries[1]) pj_fifobuf_unalloc(&fifo, entries[1]); } pj_fifobuf_unalloc(&fifo, entries[0]); if (pj_fifobuf_max_size(&fifo) < SIZE-4) { pj_assert(0); return -2; } // Test 3 for (i=0; i<LOOP; ++i) { int count, j; for (count=0; available>=MIN_SIZE+4 && count < MAX_ENTRIES;) { int size = MIN_SIZE+(pj_rand() % MAX_SIZE); entries[count] = pj_fifobuf_alloc (&fifo, size); if (entries[count]) { available -= (size+4); ++count; } } for (j=0; j<count; ++j) { pj_fifobuf_free (&fifo, entries[j]); } available = SIZE; } if (pj_fifobuf_max_size(&fifo) < SIZE-4) { pj_assert(0); return -3; } pj_pool_release(pool); return 0; }
/* * Create server. */ PJ_DEF(pj_status_t) pj_turn_srv_create(pj_pool_factory *pf, pj_turn_srv **p_srv) { pj_pool_t *pool; pj_stun_session_cb sess_cb; pj_turn_srv *srv; unsigned i; pj_status_t status; PJ_ASSERT_RETURN(pf && p_srv, PJ_EINVAL); /* Create server and init core settings */ pool = pj_pool_create(pf, "srv%p", 1000, 1000, NULL); srv = PJ_POOL_ZALLOC_T(pool, pj_turn_srv); srv->obj_name = pool->obj_name; srv->core.pf = pf; srv->core.pool = pool; srv->core.tls_key = srv->core.tls_data = -1; /* Create ioqueue */ status = pj_ioqueue_create(pool, MAX_HANDLES, &srv->core.ioqueue); if (status != PJ_SUCCESS) goto on_error; /* Server mutex */ status = pj_lock_create_recursive_mutex(pool, srv->obj_name, &srv->core.lock); if (status != PJ_SUCCESS) goto on_error; /* Allocate TLS */ status = pj_thread_local_alloc(&srv->core.tls_key); if (status != PJ_SUCCESS) goto on_error; status = pj_thread_local_alloc(&srv->core.tls_data); if (status != PJ_SUCCESS) goto on_error; /* Create timer heap */ status = pj_timer_heap_create(pool, MAX_TIMER, &srv->core.timer_heap); if (status != PJ_SUCCESS) goto on_error; /* Configure lock for the timer heap */ pj_timer_heap_set_lock(srv->core.timer_heap, srv->core.lock, PJ_FALSE); /* Array of listeners */ srv->core.listener = (pj_turn_listener**) pj_pool_calloc(pool, MAX_LISTENERS, sizeof(srv->core.listener[0])); /* Create hash tables */ srv->tables.alloc = pj_hash_create(pool, MAX_CLIENTS); srv->tables.res = pj_hash_create(pool, MAX_CLIENTS); /* Init ports settings */ srv->ports.min_udp = srv->ports.next_udp = MIN_PORT; srv->ports.max_udp = MAX_PORT; srv->ports.min_tcp = srv->ports.next_tcp = MIN_PORT; srv->ports.max_tcp = MAX_PORT; /* Init STUN config */ pj_stun_config_init(&srv->core.stun_cfg, pf, 0, srv->core.ioqueue, srv->core.timer_heap); /* Init STUN credential */ srv->core.cred.type = PJ_STUN_AUTH_CRED_DYNAMIC; srv->core.cred.data.dyn_cred.user_data = srv; srv->core.cred.data.dyn_cred.get_auth = &pj_turn_get_auth; srv->core.cred.data.dyn_cred.get_password = &pj_turn_get_password; srv->core.cred.data.dyn_cred.verify_nonce = &pj_turn_verify_nonce; /* Create STUN session to handle new allocation */ pj_bzero(&sess_cb, sizeof(sess_cb)); sess_cb.on_rx_request = &on_rx_stun_request; sess_cb.on_send_msg = &on_tx_stun_msg; status = pj_stun_session_create(&srv->core.stun_cfg, srv->obj_name, &sess_cb, PJ_FALSE, NULL, &srv->core.stun_sess); if (status != PJ_SUCCESS) { goto on_error; } pj_stun_session_set_user_data(srv->core.stun_sess, srv); pj_stun_session_set_credential(srv->core.stun_sess, PJ_STUN_AUTH_LONG_TERM, &srv->core.cred); /* Array of worker threads */ srv->core.thread_cnt = MAX_THREADS; srv->core.thread = (pj_thread_t**) pj_pool_calloc(pool, srv->core.thread_cnt, sizeof(pj_thread_t*)); /* Start the worker threads */ for (i=0; i<srv->core.thread_cnt; ++i) { status = pj_thread_create(pool, srv->obj_name, &server_thread_proc, srv, 0, 0, &srv->core.thread[i]); if (status != PJ_SUCCESS) goto on_error; } /* We're done. Application should add listeners now */ PJ_LOG(4,(srv->obj_name, "TURN server v%s is running", pj_get_version())); *p_srv = srv; return PJ_SUCCESS; on_error: pj_turn_srv_destroy(srv); return status; }
/* * sock_producer_consumer() * * Simple producer-consumer benchmarking. Send loop number of * buf_size size packets as fast as possible. */ static int sock_producer_consumer(int sock_type, unsigned buf_size, unsigned loop, unsigned *p_bandwidth) { pj_sock_t consumer, producer; pj_pool_t *pool; char *outgoing_buffer, *incoming_buffer; pj_timestamp start, stop; unsigned i; pj_highprec_t elapsed, bandwidth; pj_size_t total_received; pj_status_t rc; /* Create pool. */ pool = pj_pool_create(mem, NULL, 4096, 4096, NULL); if (!pool) return -10; /* Create producer-consumer pair. */ rc = app_socketpair(pj_AF_INET(), sock_type, 0, &consumer, &producer); if (rc != PJ_SUCCESS) { app_perror("...error: create socket pair", rc); return -20; } /* Create buffers. */ outgoing_buffer = (char*) pj_pool_alloc(pool, buf_size); incoming_buffer = (char*) pj_pool_alloc(pool, buf_size); /* Start loop. */ pj_get_timestamp(&start); total_received = 0; for (i=0; i<loop; ++i) { pj_ssize_t sent, part_received, received; pj_time_val delay; sent = buf_size; rc = pj_sock_send(producer, outgoing_buffer, &sent, 0); if (rc != PJ_SUCCESS || sent != (pj_ssize_t)buf_size) { app_perror("...error: send()", rc); return -61; } /* Repeat recv() until all data is part_received. * This applies only for non-UDP of course, since for UDP * we would expect all data to be part_received in one packet. */ received = 0; do { part_received = buf_size-received; rc = pj_sock_recv(consumer, incoming_buffer+received, &part_received, 0); if (rc != PJ_SUCCESS) { app_perror("...recv error", rc); return -70; } if (part_received <= 0) { PJ_LOG(3,("", "...error: socket has closed (part_received=%d)!", part_received)); return -73; } if ((pj_size_t)part_received != buf_size-received) { if (sock_type != pj_SOCK_STREAM()) { PJ_LOG(3,("", "...error: expecting %u bytes, got %u bytes", buf_size-received, part_received)); return -76; } } received += part_received; } while ((pj_size_t)received < buf_size); total_received += received; /* Stop test if it's been runnign for more than 10 secs. */ pj_get_timestamp(&stop); delay = pj_elapsed_time(&start, &stop); if (delay.sec > 10) break; } /* Stop timer. */ pj_get_timestamp(&stop); elapsed = pj_elapsed_usec(&start, &stop); /* bandwidth = total_received * 1000 / elapsed */ bandwidth = total_received; pj_highprec_mul(bandwidth, 1000); pj_highprec_div(bandwidth, elapsed); *p_bandwidth = (pj_uint32_t)bandwidth; /* Close sockets. */ pj_sock_close(consumer); pj_sock_close(producer); /* Done */ pj_pool_release(pool); return 0; }
int jbuf_main(void) { FILE *input; pj_bool_t data_eof = PJ_FALSE; int old_log_level; int rc = 0; const char* input_filename = "Jbtest.dat"; const char* input_search_path[] = { "../build", "pjmedia/build", "build" }; /* Try to open test data file in the working directory */ input = fopen(input_filename, "rt"); /* If that fails, try to open test data file in specified search paths */ if (input == NULL) { char input_path[PJ_MAXPATH]; int i; for (i = 0; !input && i < PJ_ARRAY_SIZE(input_search_path); ++i) { pj_ansi_snprintf(input_path, PJ_MAXPATH, "%s/%s", input_search_path[i], input_filename); input = fopen(input_path, "rt"); } } /* Failed to open test data file. */ if (input == NULL) { printf("Failed to open test data file, Jbtest.dat\n"); return -1; } old_log_level = pj_log_get_level(); pj_log_set_level(5); while (rc == 0 && !data_eof) { pj_str_t jb_name = {"JBTEST", 6}; pjmedia_jbuf *jb; pj_pool_t *pool; pjmedia_jb_state state; pj_uint16_t last_seq = 0; pj_uint16_t seq = 1; char line[1024], *p = NULL; test_param_t param; test_cond_t cond; param.adaptive = PJ_TRUE; param.init_prefetch = JB_INIT_PREFETCH; param.min_prefetch = JB_MIN_PREFETCH; param.max_prefetch = JB_MAX_PREFETCH; cond.burst = -1; cond.delay = -1; cond.delay_min = -1; cond.discard = -1; cond.empty = -1; cond.lost = -1; printf("\n\n"); /* Parse test session title, param, and conditions */ do { p = fgets(line, sizeof(line), input); } while (p && parse_test_headers(line, ¶m, &cond)); /* EOF test data */ if (p == NULL) break; //printf("======================================================\n"); /* Initialize test session */ pool = pj_pool_create(mem, "JBPOOL", 256*16, 256*16, NULL); pjmedia_jbuf_create(pool, &jb_name, 1, JB_PTIME, JB_BUF_SIZE, &jb); pjmedia_jbuf_reset(jb); if (param.adaptive) { pjmedia_jbuf_set_adaptive(jb, param.init_prefetch, param.min_prefetch, param.max_prefetch); } else { pjmedia_jbuf_set_fixed(jb, param.init_prefetch); } #ifdef REPORT pjmedia_jbuf_get_state(jb, &state); printf("Initial\tsize=%d\tprefetch=%d\tmin.pftch=%d\tmax.pftch=%d\n", state.size, state.prefetch, state.min_prefetch, state.max_prefetch); #endif /* Test session start */ while (1) { char c; /* Get next line of test data */ if (!p || *p == 0) { p = fgets(line, sizeof(line), input); if (p == NULL) { data_eof = PJ_TRUE; break; } } /* Get next char of test data */ c = *p++; /* Skip spaces */ if (isspace(c)) continue; /* Print comment line */ if (c == '#') { #ifdef PRINT_COMMENT while (*p && isspace(*p)) ++p; if (*p) printf("..%s", p); #endif *p = 0; continue; } /* Process test data */ if (!process_test_data(c, jb, &seq, &last_seq)) break; } /* Print JB states */ pjmedia_jbuf_get_state(jb, &state); printf("------------------------------------------------------\n"); printf("Summary:\n"); printf(" size=%d prefetch=%d\n", state.size, state.prefetch); printf(" delay (min/max/avg/dev)=%d/%d/%d/%d ms\n", state.min_delay, state.max_delay, state.avg_delay, state.dev_delay); printf(" lost=%d discard=%d empty=%d burst(avg)=%d\n", state.lost, state.discard, state.empty, state.avg_burst); /* Evaluate test session */ if (cond.burst >= 0 && (int)state.avg_burst > cond.burst) { printf("! 'Burst' should be %d, it is %d\n", cond.burst, state.avg_burst); rc |= 1; } if (cond.delay >= 0 && (int)state.avg_delay/JB_PTIME > cond.delay) { printf("! 'Delay' should be %d, it is %d\n", cond.delay, state.avg_delay/JB_PTIME); rc |= 2; } if (cond.delay_min >= 0 && (int)state.min_delay/JB_PTIME > cond.delay_min) { printf("! 'Minimum delay' should be %d, it is %d\n", cond.delay_min, state.min_delay/JB_PTIME); rc |= 32; } if (cond.discard >= 0 && (int)state.discard > cond.discard) { printf("! 'Discard' should be %d, it is %d\n", cond.discard, state.discard); rc |= 4; } if (cond.empty >= 0 && (int)state.empty > cond.empty) { printf("! 'Empty' should be %d, it is %d\n", cond.empty, state.empty); rc |= 8; } if (cond.lost >= 0 && (int)state.lost > cond.lost) { printf("! 'Lost' should be %d, it is %d\n", cond.lost, state.lost); rc |= 16; } pjmedia_jbuf_destroy(jb); pj_pool_release(pool); } fclose(input); pj_log_set_level(old_log_level); return rc; }
/* Test will perform multiple clients trying to connect to single server. * Once SSL connection established, echo test will be performed. */ static int perf_test(unsigned clients, unsigned ms_handshake_timeout) { pj_pool_t *pool = NULL; pj_ioqueue_t *ioqueue = NULL; pj_timer_heap_t *timer = NULL; pj_ssl_sock_t *ssock_serv = NULL; pj_ssl_sock_t **ssock_cli = NULL; pj_ssl_sock_param param; struct test_state state_serv = { 0 }; struct test_state *state_cli = NULL; pj_sockaddr addr, listen_addr; pj_ssl_cert_t *cert = NULL; pj_status_t status; unsigned i, cli_err = 0; pj_size_t tot_sent = 0, tot_recv = 0; pj_time_val start; pool = pj_pool_create(mem, "ssl_perf", 256, 256, NULL); status = pj_ioqueue_create(pool, PJ_IOQUEUE_MAX_HANDLES, &ioqueue); if (status != PJ_SUCCESS) { goto on_return; } status = pj_timer_heap_create(pool, PJ_IOQUEUE_MAX_HANDLES, &timer); if (status != PJ_SUCCESS) { goto on_return; } /* Set cert */ { pj_str_t tmp1, tmp2, tmp3, tmp4; status = pj_ssl_cert_load_from_files(pool, pj_strset2(&tmp1, (char*)CERT_CA_FILE), pj_strset2(&tmp2, (char*)CERT_FILE), pj_strset2(&tmp3, (char*)CERT_PRIVKEY_FILE), pj_strset2(&tmp4, (char*)CERT_PRIVKEY_PASS), &cert); if (status != PJ_SUCCESS) { goto on_return; } } pj_ssl_sock_param_default(¶m); param.cb.on_accept_complete = &ssl_on_accept_complete; param.cb.on_connect_complete = &ssl_on_connect_complete; param.cb.on_data_read = &ssl_on_data_read; param.cb.on_data_sent = &ssl_on_data_sent; param.ioqueue = ioqueue; param.timer_heap = timer; param.timeout.sec = 0; param.timeout.msec = ms_handshake_timeout; pj_time_val_normalize(¶m.timeout); /* Init default bind address */ { pj_str_t tmp_st; pj_sockaddr_init(PJ_AF_INET, &addr, pj_strset2(&tmp_st, "127.0.0.1"), 0); } /* SERVER */ param.user_data = &state_serv; state_serv.pool = pool; state_serv.echo = PJ_TRUE; state_serv.is_server = PJ_TRUE; status = pj_ssl_sock_create(pool, ¶m, &ssock_serv); if (status != PJ_SUCCESS) { goto on_return; } status = pj_ssl_sock_set_certificate(ssock_serv, pool, cert); if (status != PJ_SUCCESS) { goto on_return; } status = pj_ssl_sock_start_accept(ssock_serv, pool, &addr, pj_sockaddr_get_len(&addr)); if (status != PJ_SUCCESS) { goto on_return; } /* Get listening address for clients to connect to */ { pj_ssl_sock_info info; char buf[64]; pj_ssl_sock_get_info(ssock_serv, &info); pj_sockaddr_cp(&listen_addr, &info.local_addr); pj_sockaddr_print((pj_sockaddr_t*)&listen_addr, buf, sizeof(buf), 1); PJ_LOG(3, ("", "...Listener ready at %s", buf)); } /* CLIENTS */ clients_num = clients; param.timeout.sec = 0; param.timeout.msec = 0; /* Init random seed */ { pj_time_val now; pj_gettimeofday(&now); pj_srand((unsigned)now.sec); } /* Allocate SSL socket pointers and test state */ ssock_cli = (pj_ssl_sock_t**)pj_pool_calloc(pool, clients, sizeof(pj_ssl_sock_t*)); state_cli = (struct test_state*)pj_pool_calloc(pool, clients, sizeof(struct test_state)); /* Get start timestamp */ pj_gettimeofday(&start); /* Setup clients */ for (i = 0; i < clients; ++i) { param.user_data = &state_cli[i]; state_cli[i].pool = pool; state_cli[i].check_echo = PJ_TRUE; state_cli[i].send_str_len = (pj_rand() % 5 + 1) * 1024 + pj_rand() % 1024; state_cli[i].send_str = (char*)pj_pool_alloc(pool, state_cli[i].send_str_len); { unsigned j; for (j = 0; j < state_cli[i].send_str_len; ++j) state_cli[i].send_str[j] = (char)(pj_rand() % 256); } status = pj_ssl_sock_create(pool, ¶m, &ssock_cli[i]); if (status != PJ_SUCCESS) { app_perror("...ERROR pj_ssl_sock_create()", status); cli_err++; clients_num--; continue; } status = pj_ssl_sock_start_connect(ssock_cli[i], pool, &addr, &listen_addr, pj_sockaddr_get_len(&addr)); if (status == PJ_SUCCESS) { ssl_on_connect_complete(ssock_cli[i], PJ_SUCCESS); } else if (status == PJ_EPENDING) { status = PJ_SUCCESS; } else { app_perror("...ERROR pj_ssl_sock_create()", status); pj_ssl_sock_close(ssock_cli[i]); ssock_cli[i] = NULL; clients_num--; cli_err++; continue; } /* Give chance to server to accept this client */ { unsigned n = 5; #ifdef PJ_SYMBIAN while(n && pj_symbianos_poll(-1, 1000)) n--; #else pj_time_val delay = {0, 100}; while(n && pj_ioqueue_poll(ioqueue, &delay) > 0) n--; #endif } } /* Wait until everything has been sent/received or error */ while (clients_num) { #ifdef PJ_SYMBIAN pj_symbianos_poll(-1, 1000); #else pj_time_val delay = {0, 100}; pj_ioqueue_poll(ioqueue, &delay); pj_timer_heap_poll(timer, &delay); #endif } /* Clean up sockets */ { pj_time_val delay = {0, 500}; while (pj_ioqueue_poll(ioqueue, &delay) > 0); } if (state_serv.err != PJ_SUCCESS) { status = state_serv.err; goto on_return; } PJ_LOG(3, ("", "...Done!")); /* SSL setup and data transfer duration */ { pj_time_val stop; pj_gettimeofday(&stop); PJ_TIME_VAL_SUB(stop, start); PJ_LOG(3, ("", ".....Setup & data transfer duration: %d.%03ds", stop.sec, stop.msec)); } /* Check clients status */ for (i = 0; i < clients; ++i) { if (state_cli[i].err != PJ_SUCCESS) cli_err++; tot_sent += state_cli[1].sent; tot_recv += state_cli[1].recv; } PJ_LOG(3, ("", ".....Clients: %d (%d errors)", clients, cli_err)); PJ_LOG(3, ("", ".....Total sent/recv: %d/%d bytes", tot_sent, tot_recv)); on_return: if (ssock_serv) pj_ssl_sock_close(ssock_serv); for (i = 0; i < clients; ++i) { if (ssock_cli[i] && !state_cli[i].err && !state_cli[i].done) pj_ssl_sock_close(ssock_cli[i]); } if (ioqueue) pj_ioqueue_destroy(ioqueue); if (pool) pj_pool_release(pool); return status; }
static int create_ses_by_remote_sdp(int local_port, char *sdp) { pj_media_session_t *ses = NULL; pjsdp_session_desc *sdp_ses; pj_media_sock_info skinfo; pj_pool_t *pool; char s[4]; const pj_media_stream_info *info[2]; int i, count; pool = pj_pool_create(pf, "sdp", 1024, 0, NULL); if (!pool) { PJ_LOG(1,(THIS_FILE, "Unable to create pool")); return -1; } pj_bzero(&skinfo, sizeof(skinfo)); skinfo.rtp_sock = skinfo.rtcp_sock = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, 0); if (skinfo.rtp_sock == PJ_INVALID_SOCKET) { PJ_LOG(1,(THIS_FILE, "Unable to create socket")); goto on_error; } pj_sockaddr_init2(&skinfo.rtp_addr_name, "0.0.0.0", local_port); if (pj_sock_bind(skinfo.rtp_sock, (struct pj_sockaddr*)&skinfo.rtp_addr_name, sizeof(pj_sockaddr_in)) != 0) { PJ_LOG(1,(THIS_FILE, "Unable to bind socket")); goto on_error; } sdp_ses = pjsdp_parse(sdp, strlen(sdp), pool); if (!sdp_ses) { PJ_LOG(1,(THIS_FILE, "Error parsing SDP")); goto on_error; } ses = pj_media_session_create_from_sdp(mm, sdp_ses, &skinfo); if (!ses) { PJ_LOG(1,(THIS_FILE, "Unable to create session from SDP")); goto on_error; } if (pj_media_session_activate(ses) != 0) { PJ_LOG(1,(THIS_FILE, "Error activating session")); goto on_error; } count = pj_media_session_enum_streams(ses, 2, info); printf("\nDumping streams: \n"); for (i=0; i<count; ++i) { const char *dir; char *local_ip; switch (info[i]->dir) { case PJMEDIA_DIR_NONE: dir = "- NONE -"; break; case PJMEDIA_DIR_ENCODING: dir = "SENDONLY"; break; case PJMEDIA_DIR_DECODING: dir = "RECVONLY"; break; case PJMEDIA_DIR_ENCODING_DECODING: dir = "SENDRECV"; break; default: dir = "?UNKNOWN"; break; } local_ip = pj_sockaddr_get_str_addr(&info[i]->sock_info.rtp_addr_name); printf(" Stream %d: %.*s %s local=%s:%d remote=%.*s:%d\n", i, info[i]->type.slen, info[i]->type.ptr, dir, local_ip, pj_sockaddr_get_port(&info[i]->sock_info.rtp_addr_name), info[i]->rem_addr.slen, info[i]->rem_addr.ptr, info[i]->rem_port); } puts("Press <ENTER> to quit"); fgets(s, sizeof(s), stdin); pj_media_session_destroy(ses); pj_sock_close(skinfo.rtp_sock); pj_pool_release(pool); return 0; on_error: if (ses) pj_media_session_destroy(ses); if (skinfo.rtp_sock != PJ_INVALID_SOCKET) pj_sock_close(skinfo.rtp_sock); if (pool) pj_pool_release(pool); return -1; }
static int https_client_test(unsigned ms_timeout) { pj_pool_t *pool = NULL; pj_ioqueue_t *ioqueue = NULL; pj_timer_heap_t *timer = NULL; pj_ssl_sock_t *ssock = NULL; pj_ssl_sock_param param; pj_status_t status; struct test_state state = {0}; pj_sockaddr local_addr, rem_addr; pj_str_t tmp_st; pool = pj_pool_create(mem, "https_get", 256, 256, NULL); status = pj_ioqueue_create(pool, 4, &ioqueue); if (status != PJ_SUCCESS) { goto on_return; } status = pj_timer_heap_create(pool, 4, &timer); if (status != PJ_SUCCESS) { goto on_return; } state.pool = pool; state.send_str = HTTP_REQ; state.send_str_len = pj_ansi_strlen(state.send_str); state.is_verbose = PJ_TRUE; pj_ssl_sock_param_default(¶m); param.cb.on_connect_complete = &ssl_on_connect_complete; param.cb.on_data_read = &ssl_on_data_read; param.cb.on_data_sent = &ssl_on_data_sent; param.ioqueue = ioqueue; param.user_data = &state; param.server_name = pj_str((char*)HTTP_SERVER_ADDR); param.timer_heap = timer; param.timeout.sec = 0; param.timeout.msec = ms_timeout; param.proto = PJ_SSL_SOCK_PROTO_SSL23; pj_time_val_normalize(¶m.timeout); status = pj_ssl_sock_create(pool, ¶m, &ssock); if (status != PJ_SUCCESS) { goto on_return; } pj_sockaddr_init(PJ_AF_INET, &local_addr, pj_strset2(&tmp_st, "0.0.0.0"), 0); pj_sockaddr_init(PJ_AF_INET, &rem_addr, pj_strset2(&tmp_st, HTTP_SERVER_ADDR), HTTP_SERVER_PORT); status = pj_ssl_sock_start_connect(ssock, pool, &local_addr, &rem_addr, sizeof(rem_addr)); if (status == PJ_SUCCESS) { ssl_on_connect_complete(ssock, PJ_SUCCESS); } else if (status == PJ_EPENDING) { status = PJ_SUCCESS; } else { goto on_return; } /* Wait until everything has been sent/received */ while (state.err == PJ_SUCCESS && !state.done) { #ifdef PJ_SYMBIAN pj_symbianos_poll(-1, 1000); #else pj_time_val delay = {0, 100}; pj_ioqueue_poll(ioqueue, &delay); pj_timer_heap_poll(timer, &delay); #endif } if (state.err) { status = state.err; goto on_return; } PJ_LOG(3, ("", "...Done!")); PJ_LOG(3, ("", ".....Sent/recv: %d/%d bytes", state.sent, state.recv)); on_return: if (ssock && !state.err && !state.done) pj_ssl_sock_close(ssock); if (ioqueue) pj_ioqueue_destroy(ioqueue); if (timer) pj_timer_heap_destroy(timer); if (pool) pj_pool_release(pool); return status; }
pj_status_t UE::init_int(pj_log_func* logger, std::string realm, std::string myurl, std::string username, std::string password, std::string outbound_proxy) { pj_status_t status; char errmsg[PJ_ERR_MSG_SIZE]; pj_sockaddr addr; pj_str_t remote; pj_sockaddr remote_addr; init_pjsip(logger); std::string server_uri = std::string("sip:") + realm + std::string(";lr;transport=tcp"); _pool = pj_pool_create(get_global_pool_factory(), "a", 256, 256, NULL); pj_sockaddr_init(pj_AF_INET(), &addr, NULL, (pj_uint16_t)0); //status = pjsip_udp_transport_start(get_global_endpoint(), &addr.ipv4, NULL, 1, &_transport); //assert(status == PJ_SUCCESS); if (outbound_proxy.empty()) { outbound_proxy = realm; } pj_cstr(&remote, outbound_proxy.c_str()); pj_sockaddr_init(pj_AF_INET(), &remote_addr, &remote, (pj_uint16_t)5060); pjsip_tpselector sel2; sel2.type = PJSIP_TPSELECTOR_LISTENER; sel2.u.listener = get_global_tcp_factory(); status = pjsip_endpt_acquire_transport(get_global_endpoint(), PJSIP_TRANSPORT_TCP, &remote_addr, pj_sockaddr_get_len(&remote_addr), &sel2, &_transport); if (status != PJ_SUCCESS) { pj_strerror(status, errmsg, sizeof(errmsg)); PJ_LOG(1, (__FILE__, "TCP connection to %s failed: %s (%d)", outbound_proxy.c_str(), errmsg, status)); return status; } transport_mapping[_transport] = this; status = pjsip_regc_create(get_global_endpoint(), this, ®c_cb, &_regc); if (status != PJ_SUCCESS) { pj_strerror(status, errmsg, sizeof(errmsg)); PJ_LOG(1, (__FILE__, "Creating the REGISTER session failed: %s (%d)", errmsg, status)); return status; } pjsip_regc_set_reg_tsx_cb(_regc, ®_tsx_cb); pjsip_tpselector sel; sel.type = PJSIP_TPSELECTOR_TRANSPORT; sel.u.transport = _transport; pjsip_regc_set_transport(_regc, &sel); pjsip_auth_clt_pref prefs = {}; prefs.initial_auth = PJ_TRUE; pjsip_regc_set_prefs(_regc, &prefs); pjsip_cred_info cred; stra(&cred.realm, realm.c_str()); stra(&cred.scheme, "Digest"); stra(&cred.username, username.c_str()); stra(&cred.data, password.c_str()); cred.data_type = 0; // Plaintext password pjsip_cred_info creds[1] = {cred}; pjsip_regc_set_credentials(_regc, 1, creds); char contact[32]; snprintf(contact, 32, "sip:phone@%.*s:%d", (int)_transport->local_name.host.slen, _transport->local_name.host.ptr, _transport->local_name.port); stra(&_realm, realm.c_str()); stra(&_server, server_uri.c_str()); _server_uri = pjsip_parse_uri(_pool, _server.ptr, _server.slen, 0); stra(&_my_uri, myurl.c_str()); stra(&_username, username.c_str()); stra(&_contact, contact); return PJ_SUCCESS; }
static int echo_test(pj_ssl_sock_proto srv_proto, pj_ssl_sock_proto cli_proto, pj_ssl_cipher srv_cipher, pj_ssl_cipher cli_cipher, pj_bool_t req_client_cert, pj_bool_t client_provide_cert) { pj_pool_t *pool = NULL; pj_ioqueue_t *ioqueue = NULL; pj_ssl_sock_t *ssock_serv = NULL; pj_ssl_sock_t *ssock_cli = NULL; pj_ssl_sock_param param; struct test_state state_serv = { 0 }; struct test_state state_cli = { 0 }; pj_sockaddr addr, listen_addr; pj_ssl_cipher ciphers[1]; pj_ssl_cert_t *cert = NULL; pj_status_t status; pool = pj_pool_create(mem, "ssl_echo", 256, 256, NULL); status = pj_ioqueue_create(pool, 4, &ioqueue); if (status != PJ_SUCCESS) { goto on_return; } pj_ssl_sock_param_default(¶m); param.cb.on_accept_complete = &ssl_on_accept_complete; param.cb.on_connect_complete = &ssl_on_connect_complete; param.cb.on_data_read = &ssl_on_data_read; param.cb.on_data_sent = &ssl_on_data_sent; param.ioqueue = ioqueue; param.ciphers = ciphers; /* Init default bind address */ { pj_str_t tmp_st; pj_sockaddr_init(PJ_AF_INET, &addr, pj_strset2(&tmp_st, "127.0.0.1"), 0); } /* === SERVER === */ param.proto = srv_proto; param.user_data = &state_serv; param.ciphers_num = (srv_cipher == -1)? 0 : 1; param.require_client_cert = req_client_cert; ciphers[0] = srv_cipher; state_serv.pool = pool; state_serv.echo = PJ_TRUE; state_serv.is_server = PJ_TRUE; state_serv.is_verbose = PJ_TRUE; status = pj_ssl_sock_create(pool, ¶m, &ssock_serv); if (status != PJ_SUCCESS) { goto on_return; } /* Set server cert */ { pj_str_t tmp1, tmp2, tmp3, tmp4; status = pj_ssl_cert_load_from_files(pool, pj_strset2(&tmp1, (char*)CERT_CA_FILE), pj_strset2(&tmp2, (char*)CERT_FILE), pj_strset2(&tmp3, (char*)CERT_PRIVKEY_FILE), pj_strset2(&tmp4, (char*)CERT_PRIVKEY_PASS), &cert); if (status != PJ_SUCCESS) { goto on_return; } status = pj_ssl_sock_set_certificate(ssock_serv, pool, cert); if (status != PJ_SUCCESS) { goto on_return; } } status = pj_ssl_sock_start_accept(ssock_serv, pool, &addr, pj_sockaddr_get_len(&addr)); if (status != PJ_SUCCESS) { goto on_return; } /* Get listener address */ { pj_ssl_sock_info info; pj_ssl_sock_get_info(ssock_serv, &info); pj_sockaddr_cp(&listen_addr, &info.local_addr); } /* === CLIENT === */ param.proto = cli_proto; param.user_data = &state_cli; param.ciphers_num = (cli_cipher == -1)? 0 : 1; ciphers[0] = cli_cipher; state_cli.pool = pool; state_cli.check_echo = PJ_TRUE; state_cli.is_verbose = PJ_TRUE; { pj_time_val now; pj_gettimeofday(&now); pj_srand((unsigned)now.sec); state_cli.send_str_len = (pj_rand() % 5 + 1) * 1024 + pj_rand() % 1024; } state_cli.send_str = (char*)pj_pool_alloc(pool, state_cli.send_str_len); { unsigned i; for (i = 0; i < state_cli.send_str_len; ++i) state_cli.send_str[i] = (char)(pj_rand() % 256); } status = pj_ssl_sock_create(pool, ¶m, &ssock_cli); if (status != PJ_SUCCESS) { goto on_return; } /* Set cert for client */ { if (!client_provide_cert) { pj_str_t tmp1, tmp2; pj_strset2(&tmp1, (char*)CERT_CA_FILE); pj_strset2(&tmp2, NULL); status = pj_ssl_cert_load_from_files(pool, &tmp1, &tmp2, &tmp2, &tmp2, &cert); if (status != PJ_SUCCESS) { goto on_return; } } status = pj_ssl_sock_set_certificate(ssock_cli, pool, cert); if (status != PJ_SUCCESS) { goto on_return; } } status = pj_ssl_sock_start_connect(ssock_cli, pool, &addr, &listen_addr, pj_sockaddr_get_len(&addr)); if (status == PJ_SUCCESS) { ssl_on_connect_complete(ssock_cli, PJ_SUCCESS); } else if (status == PJ_EPENDING) { status = PJ_SUCCESS; } else { goto on_return; } /* Wait until everything has been sent/received or error */ while (!state_serv.err && !state_cli.err && !state_serv.done && !state_cli.done) { #ifdef PJ_SYMBIAN pj_symbianos_poll(-1, 1000); #else pj_time_val delay = {0, 100}; pj_ioqueue_poll(ioqueue, &delay); #endif } /* Clean up sockets */ { pj_time_val delay = {0, 100}; while (pj_ioqueue_poll(ioqueue, &delay) > 0); } if (state_serv.err || state_cli.err) { if (state_serv.err != PJ_SUCCESS) status = state_serv.err; else status = state_cli.err; goto on_return; } PJ_LOG(3, ("", "...Done!")); PJ_LOG(3, ("", ".....Sent/recv: %d/%d bytes", state_cli.sent, state_cli.recv)); on_return: if (ssock_serv) pj_ssl_sock_close(ssock_serv); if (ssock_cli && !state_cli.err && !state_cli.done) pj_ssl_sock_close(ssock_cli); if (ioqueue) pj_ioqueue_destroy(ioqueue); if (pool) pj_pool_release(pool); return status; }
/******************************************************************* * UDP ping pong test (send packet back and forth between two UDP echo * servers. */ static int udp_ping_pong_test(void) { pj_ioqueue_t *ioqueue = NULL; pj_pool_t *pool = NULL; struct udp_echo_srv *srv1=NULL, *srv2=NULL; pj_bool_t need_send = PJ_TRUE; unsigned data = 0; int count, ret; pj_status_t status; pool = pj_pool_create(mem, "pingpong", 512, 512, NULL); if (!pool) return -10; status = pj_ioqueue_create(pool, 4, &ioqueue); if (status != PJ_SUCCESS) { ret = -20; udp_echo_err("pj_ioqueue_create()", status); goto on_return; } status = udp_echo_srv_create(pool, ioqueue, PJ_TRUE, &srv1); if (status != PJ_SUCCESS) { ret = -30; goto on_return; } status = udp_echo_srv_create(pool, ioqueue, PJ_TRUE, &srv2); if (status != PJ_SUCCESS) { ret = -40; goto on_return; } /* initiate the first send */ for (count=0; count<1000; ++count) { unsigned last_rx1, last_rx2; unsigned i; if (need_send) { pj_str_t loopback; pj_sockaddr_in addr; pj_ssize_t sent; ++data; sent = sizeof(data); loopback = pj_str("127.0.0.1"); pj_sockaddr_in_init(&addr, &loopback, srv2->port); status = pj_activesock_sendto(srv1->asock, &srv1->send_key, &data, &sent, 0, &addr, sizeof(addr)); if (status != PJ_SUCCESS && status != PJ_EPENDING) { ret = -50; udp_echo_err("sendto()", status); goto on_return; } need_send = PJ_FALSE; } last_rx1 = srv1->rx_cnt; last_rx2 = srv2->rx_cnt; for (i=0; i<10 && last_rx1 == srv1->rx_cnt && last_rx2 == srv2->rx_cnt; ++i) { pj_time_val delay = {0, 10}; #ifdef PJ_SYMBIAN PJ_UNUSED_ARG(delay); pj_symbianos_poll(-1, 100); #else pj_ioqueue_poll(ioqueue, &delay); #endif } if (srv1->rx_err_cnt+srv1->tx_err_cnt != 0 || srv2->rx_err_cnt+srv2->tx_err_cnt != 0) { /* Got error */ ret = -60; goto on_return; } if (last_rx1 == srv1->rx_cnt && last_rx2 == srv2->rx_cnt) { /* Packet lost */ ret = -70; udp_echo_err("packets have been lost", PJ_ETIMEDOUT); goto on_return; } } ret = 0; on_return: if (srv2) udp_echo_srv_destroy(srv2); if (srv1) udp_echo_srv_destroy(srv1); if (ioqueue) pj_ioqueue_destroy(ioqueue); if (pool) pj_pool_release(pool); return ret; }
/* Raw TCP socket try to connect to SSL socket server, once * connection established, it will just do nothing, SSL socket * server should be able to close the connection after specified * timeout period (set ms_timeout to 0 to disable timer). */ static int client_non_ssl(unsigned ms_timeout) { pj_pool_t *pool = NULL; pj_ioqueue_t *ioqueue = NULL; pj_timer_heap_t *timer = NULL; pj_ssl_sock_t *ssock_serv = NULL; pj_activesock_t *asock_cli = NULL; pj_activesock_cb asock_cb = { 0 }; pj_sock_t sock = PJ_INVALID_SOCKET; pj_ssl_sock_param param; struct test_state state_serv = { 0 }; struct test_state state_cli = { 0 }; pj_sockaddr listen_addr; pj_ssl_cert_t *cert = NULL; pj_status_t status; pool = pj_pool_create(mem, "ssl_accept_raw_tcp", 256, 256, NULL); status = pj_ioqueue_create(pool, 4, &ioqueue); if (status != PJ_SUCCESS) { goto on_return; } status = pj_timer_heap_create(pool, 4, &timer); if (status != PJ_SUCCESS) { goto on_return; } /* Set cert */ { pj_str_t tmp1, tmp2, tmp3, tmp4; status = pj_ssl_cert_load_from_files(pool, pj_strset2(&tmp1, (char*)CERT_CA_FILE), pj_strset2(&tmp2, (char*)CERT_FILE), pj_strset2(&tmp3, (char*)CERT_PRIVKEY_FILE), pj_strset2(&tmp4, (char*)CERT_PRIVKEY_PASS), &cert); if (status != PJ_SUCCESS) { goto on_return; } } pj_ssl_sock_param_default(¶m); param.cb.on_accept_complete = &ssl_on_accept_complete; param.cb.on_data_read = &ssl_on_data_read; param.cb.on_data_sent = &ssl_on_data_sent; param.ioqueue = ioqueue; param.timer_heap = timer; param.timeout.sec = 0; param.timeout.msec = ms_timeout; pj_time_val_normalize(¶m.timeout); /* SERVER */ param.user_data = &state_serv; state_serv.pool = pool; state_serv.is_server = PJ_TRUE; state_serv.is_verbose = PJ_TRUE; status = pj_ssl_sock_create(pool, ¶m, &ssock_serv); if (status != PJ_SUCCESS) { goto on_return; } status = pj_ssl_sock_set_certificate(ssock_serv, pool, cert); if (status != PJ_SUCCESS) { goto on_return; } /* Init bind address */ { pj_str_t tmp_st; pj_sockaddr_init(PJ_AF_INET, &listen_addr, pj_strset2(&tmp_st, "127.0.0.1"), 0); } status = pj_ssl_sock_start_accept(ssock_serv, pool, &listen_addr, pj_sockaddr_get_len(&listen_addr)); if (status != PJ_SUCCESS) { goto on_return; } /* Update listener address */ { pj_ssl_sock_info info; pj_ssl_sock_get_info(ssock_serv, &info); pj_sockaddr_cp(&listen_addr, &info.local_addr); } /* CLIENT */ state_cli.pool = pool; status = pj_sock_socket(pj_AF_INET(), pj_SOCK_STREAM(), 0, &sock); if (status != PJ_SUCCESS) { goto on_return; } asock_cb.on_connect_complete = &asock_on_connect_complete; asock_cb.on_data_read = &asock_on_data_read; status = pj_activesock_create(pool, sock, pj_SOCK_STREAM(), NULL, ioqueue, &asock_cb, &state_cli, &asock_cli); if (status != PJ_SUCCESS) { goto on_return; } status = pj_activesock_start_connect(asock_cli, pool, (pj_sockaddr_t*)&listen_addr, pj_sockaddr_get_len(&listen_addr)); if (status == PJ_SUCCESS) { asock_on_connect_complete(asock_cli, PJ_SUCCESS); } else if (status == PJ_EPENDING) { status = PJ_SUCCESS; } else { goto on_return; } /* Wait until everything has been sent/received or error */ while (!state_serv.err && !state_cli.err && !state_serv.done && !state_cli.done) { #ifdef PJ_SYMBIAN pj_symbianos_poll(-1, 1000); #else pj_time_val delay = {0, 100}; pj_ioqueue_poll(ioqueue, &delay); pj_timer_heap_poll(timer, &delay); #endif } if (state_serv.err || state_cli.err) { if (state_serv.err != PJ_SUCCESS) status = state_serv.err; else status = state_cli.err; goto on_return; } PJ_LOG(3, ("", "...Done!")); on_return: if (ssock_serv) pj_ssl_sock_close(ssock_serv); if (asock_cli && !state_cli.err && !state_cli.done) pj_activesock_close(asock_cli); if (timer) pj_timer_heap_destroy(timer); if (ioqueue) pj_ioqueue_destroy(ioqueue); if (pool) pj_pool_release(pool); return status; }
/* Instantiate standard server */ static int create_std_server(pj_stun_auth_type auth_type, pj_bool_t responding, pj_bool_t use_ipv6) { pj_pool_t *pool; pj_stun_session_cb sess_cb; pj_stun_auth_cred cred; pj_status_t status; /* Create server */ pool = pj_pool_create(mem, "server", 1000, 1000, NULL); server = PJ_POOL_ZALLOC_T(pool, struct server); server->pool = pool; server->auth_type = auth_type; server->responding = responding; /* Create STUN session */ pj_bzero(&sess_cb, sizeof(sess_cb)); sess_cb.on_rx_request = &server_on_rx_request; sess_cb.on_send_msg = &server_send_msg; status = pj_stun_session_create(&stun_cfg, "server", &sess_cb, PJ_FALSE, NULL, &server->sess); if (status != PJ_SUCCESS) { destroy_server(); return -10; } /* Configure credential */ pj_bzero(&cred, sizeof(cred)); cred.type = PJ_STUN_AUTH_CRED_DYNAMIC; cred.data.dyn_cred.get_auth = &server_get_auth; cred.data.dyn_cred.get_password = &server_get_password; cred.data.dyn_cred.verify_nonce = &server_verify_nonce; status = pj_stun_session_set_credential(server->sess, auth_type, &cred); if (status != PJ_SUCCESS) { destroy_server(); return -20; } /* Create socket */ status = pj_sock_socket(GET_AF(use_ipv6), pj_SOCK_DGRAM(), 0, &server->sock); if (status != PJ_SUCCESS) { destroy_server(); return -30; } /* Bind */ pj_sockaddr_init(GET_AF(use_ipv6), &server->addr, NULL, 0); status = pj_sock_bind(server->sock, &server->addr, pj_sockaddr_get_len(&server->addr)); if (status != PJ_SUCCESS) { destroy_server(); return -40; } else { /* Get the bound IP address */ int namelen = sizeof(server->addr); pj_sockaddr addr; status = pj_sock_getsockname(server->sock, &server->addr, &namelen); if (status != PJ_SUCCESS) { destroy_server(); return -43; } if (use_ipv6) { /* pj_gethostip() may return IPv6 link-local and currently it will cause * 'no route to host' error, so let's just hardcode to [::1] */ pj_sockaddr_init(pj_AF_INET6(), &addr, NULL, 0); addr.ipv6.sin6_addr.s6_addr[15] = 1; } else { status = pj_gethostip(GET_AF(use_ipv6), &addr); if (status != PJ_SUCCESS) { destroy_server(); return -45; } } pj_sockaddr_copy_addr(&server->addr, &addr); } /* Create worker thread */ status = pj_thread_create(pool, "server", &server_thread, 0, 0, 0, &server->thread); if (status != PJ_SUCCESS) { destroy_server(); return -30; } return 0; }
static int decode_test(void) { unsigned i; pj_pool_t *pool; int rc = 0; pool = pj_pool_create(mem, "decode_test", 1024, 1024, NULL); PJ_LOG(3,(THIS_FILE, " STUN decode test")); for (i=0; i<PJ_ARRAY_SIZE(tests); ++i) { struct test *t = &tests[i]; pj_stun_msg *msg, *msg2; pj_uint8_t buf[1500]; pj_str_t key; pj_size_t len; pj_status_t status; PJ_LOG(3,(THIS_FILE, " %s", t->title)); if (t->pdu) { status = pj_stun_msg_decode(pool, (pj_uint8_t*)t->pdu, t->pdu_len, PJ_STUN_IS_DATAGRAM | PJ_STUN_CHECK_PACKET, &msg, NULL, NULL); /* Check expected decode result */ if (t->expected_status != status) { PJ_LOG(1,(THIS_FILE, " expecting status %d, got %d", t->expected_status, status)); rc = -10; goto on_return; } } else { msg = t->create(pool); status = PJ_SUCCESS; } if (status != PJ_SUCCESS) continue; /* Try to encode message */ pj_stun_create_key(pool, &key, NULL, &USERNAME, PJ_STUN_PASSWD_PLAIN, &PASSWORD); status = pj_stun_msg_encode(msg, buf, sizeof(buf), 0, &key, &len); if (status != PJ_SUCCESS) { PJ_LOG(1,(THIS_FILE, " encode error: %s", err(status))); rc = -40; goto on_return; } /* Try to decode it once more */ status = pj_stun_msg_decode(pool, buf, len, PJ_STUN_IS_DATAGRAM | PJ_STUN_CHECK_PACKET, &msg2, NULL, NULL); if (status != PJ_SUCCESS) { PJ_LOG(1,(THIS_FILE, " subsequent decoding failed: %s", err(status))); rc = -50; goto on_return; } /* Verify */ if (t->verify) { rc = t->verify(msg); if (rc != 0) { goto on_return; } } } on_return: pj_pool_release(pool); if (rc == 0) PJ_LOG(3,(THIS_FILE, "...success!")); return rc; }