/*
* Check if sockaddr contains a non-zero address
*/
PJ_DEF(pj_bool_t) pj_sockaddr_has_addr(const pj_sockaddr_t *addr)
{
const pj_sockaddr *a = (const pj_sockaddr*)addr;
/* It's probably not wise to raise assertion here if
* the address doesn't contain a valid address family, and
* just return PJ_FALSE instead.
*
* The reason is because application may need to distinguish
* these three conditions with sockaddr:
* a) sockaddr is not initialized. This is by convention
* indicated by sa_family==0.
* b) sockaddr is initialized with zero address. This is
* indicated with the address field having zero address.
* c) sockaddr is initialized with valid address/port.
*
* If we enable this assertion, then application will loose
* the capability to specify condition a), since it will be
* forced to always initialize sockaddr (even with zero address).
* This may break some parts of upper layer libraries.
*/
//PJ_ASSERT_RETURN(a->addr.sa_family == PJ_AF_INET ||
// a->addr.sa_family == PJ_AF_INET6, PJ_FALSE);
if (a->addr.sa_family!=PJ_AF_INET && a->addr.sa_family!=PJ_AF_INET6) {
return PJ_FALSE;
} else if (a->addr.sa_family == PJ_AF_INET6) {
pj_uint8_t zero[24];
pj_bzero(zero, sizeof(zero));
return pj_memcmp(a->ipv6.sin6_addr.s6_addr, zero,
sizeof(pj_in6_addr)) != 0;
} else
return a->ipv4.sin_addr.s_addr != PJ_INADDR_ANY;
}
/* Get the default IP interface */
PJ_DEF(pj_status_t) pj_getdefaultipinterface(int af, pj_sockaddr *addr)
{
pj_sock_t fd;
pj_str_t cp;
pj_sockaddr a;
int len;
pj_uint8_t zero[64];
pj_status_t status;
addr->addr.sa_family = (pj_uint16_t)af;
status = pj_sock_socket(af, pj_SOCK_DGRAM(), 0, &fd);
if (status != PJ_SUCCESS) {
return status;
}
PJ_LOG(4, ("sock_common.c", "pj_getdefaultipinterface() pj_sock_socket."));
if (af == PJ_AF_INET) {
cp = pj_str("1.1.1.1");
} else {
cp = pj_str("1::1");
}
status = pj_sockaddr_init(af, &a, &cp, 53);
if (status != PJ_SUCCESS) {
pj_sock_close(fd);
return status;
}
PJ_LOG(4, ("sock_common.c", "pj_getdefaultipinterface() pj_sockaddr_init."));
status = pj_sock_connect(fd, &a, pj_sockaddr_get_len(&a));
if (status != PJ_SUCCESS) {
pj_sock_close(fd);
return status;
}
PJ_LOG(4, ("sock_common.c", "pj_getdefaultipinterface() pj_sock_connect."));
len = sizeof(a);
status = pj_sock_getsockname(fd, &a, &len);
if (status != PJ_SUCCESS) {
pj_sock_close(fd);
return status;
}
PJ_LOG(4, ("sock_common.c", "pj_getdefaultipinterface() pj_sock_getsockname."));
pj_sock_close(fd);
/* Check that the address returned is not zero */
pj_bzero(zero, sizeof(zero));
if (pj_memcmp(pj_sockaddr_get_addr(&a), zero,
pj_sockaddr_get_addr_len(&a))==0)
{
PJ_LOG(4, ("sock_common.c", "pj_getdefaultipinterface() interface not found."));
return PJ_ENOTFOUND;
}
pj_sockaddr_copy_addr(addr, &a);
/* Success */
return PJ_SUCCESS;
}
/* Compare two messages */
static int cmp_msg(const pj_stun_msg *msg1, const pj_stun_msg *msg2)
{
unsigned i;
if (msg1->hdr.type != msg2->hdr.type)
return -10;
if (msg1->hdr.length != msg2->hdr.length)
return -20;
if (msg1->hdr.magic != msg2->hdr.magic)
return -30;
if (pj_memcmp(msg1->hdr.tsx_id, msg2->hdr.tsx_id, sizeof(msg1->hdr.tsx_id)))
return -40;
if (msg1->attr_count != msg2->attr_count)
return -50;
for (i=0; i<msg1->attr_count; ++i) {
const pj_stun_attr_hdr *a1 = msg1->attr[i];
const pj_stun_attr_hdr *a2 = msg2->attr[i];
if (a1->type != a2->type)
return -60;
if (a1->length != a2->length)
return -70;
}
return 0;
}
/* DirectSound enum device callback */
static BOOL CALLBACK DSEnumCallback( LPGUID lpGuid, LPCTSTR lpcstrDescription,
LPCTSTR lpcstrModule, LPVOID lpContext)
{
unsigned index, max = sizeof(dev_info[index].info.name);
pj_bool_t is_capture_device = (lpContext != NULL);
PJ_UNUSED_ARG(lpcstrModule);
/* Put the capture and playback of the same devices to the same
* dev_info item, by looking at the GUID.
*/
for (index=0; index<dev_count; ++index) {
if ((dev_info[index].lpGuid==NULL && lpGuid==NULL) ||
pj_memcmp(&dev_info[index].guid, lpGuid, sizeof(GUID))==0)
{
break;
}
}
if (index == dev_count)
++dev_count;
else if (dev_count >= MAX_HARDWARE) {
pj_assert(!"Too many DirectSound hardware found");
PJ_LOG(4,(THIS_FILE, "Too many hardware found, some devices will "
"not be listed"));
return FALSE;
}
#ifdef UNICODE
WideCharToMultiByte(CP_ACP, 0, lpcstrDescription, wcslen(lpcstrDescription),
dev_info[index].info.name, max, NULL, NULL);
#else
strncpy(dev_info[index].info.name, lpcstrDescription, max);
#endif
dev_info[index].info.name[max-1] = '\0';
if (lpGuid == NULL) {
dev_info[index].lpGuid = NULL;
} else {
pj_memcpy(&dev_info[index].guid, lpGuid, sizeof(GUID));
dev_info[index].lpGuid = &dev_info[index].guid;
}
dev_info[index].info.default_samples_per_sec = 44100;
/* Just assumed that device supports stereo capture/playback */
if (is_capture_device)
dev_info[index].info.input_count+=2;
else
dev_info[index].info.output_count+=2;
return TRUE;
}
static int format_test(void)
{
pj_str_t s = pj_str(ADDRESS);
unsigned char *p;
pj_in_addr addr;
char zero[64];
pj_sockaddr_in addr2;
const pj_str_t *hostname;
PJ_LOG(3,("test", "...format_test()"));
/* pj_inet_aton() */
if (pj_inet_aton(&s, &addr) != 1)
return -10;
/* Check the result. */
p = (unsigned char*)&addr;
if (p[0]!=A0 || p[1]!=A1 || p[2]!=A2 || p[3]!=A3) {
PJ_LOG(3,("test", " error: mismatched address. p0=%d, p1=%d, "
"p2=%d, p3=%d", p[0] & 0xFF, p[1] & 0xFF,
p[2] & 0xFF, p[3] & 0xFF));
return -15;
}
/* pj_inet_ntoa() */
p = (unsigned char*) pj_inet_ntoa(addr);
if (!p)
return -20;
if (pj_strcmp2(&s, (char*)p) != 0)
return -30;
/* Test that pj_sockaddr_in_init() initialize the whole structure,
* including sin_zero.
*/
pj_sockaddr_in_init(&addr2, 0, 1000);
pj_bzero(zero, sizeof(zero));
if (pj_memcmp(addr2.sin_zero, zero, sizeof(addr2.sin_zero)) != 0)
return -35;
/* pj_gethostname() */
hostname = pj_gethostname();
if (!hostname || !hostname->ptr || !hostname->slen)
return -40;
PJ_LOG(3,("test", "....hostname is %.*s",
(int)hostname->slen, hostname->ptr));
/* pj_gethostaddr() */
return 0;
}
/*! \brief Helper function which determines if a transport is bound to any */
static int multihomed_bound_any(pjsip_transport *transport)
{
pj_uint32_t loop6[4] = {0, 0, 0, 0};
if ((transport->local_addr.addr.sa_family == pj_AF_INET() &&
transport->local_addr.ipv4.sin_addr.s_addr == PJ_INADDR_ANY) ||
(transport->local_addr.addr.sa_family == pj_AF_INET6() &&
!pj_memcmp(&transport->local_addr.ipv6.sin6_addr, loop6, sizeof(loop6)))) {
return 1;
}
return 0;
}
/*! \brief Helper function which determines if the existing address has priority over new one */
static int multihomed_rewrite_header(pj_str_t *source, pjsip_transport *transport)
{
pj_uint32_t loop6[4] = {0, 0, 0, 0};
/* If the transport is bound to any it should always rewrite */
if ((transport->local_addr.addr.sa_family == pj_AF_INET() &&
transport->local_addr.ipv4.sin_addr.s_addr == PJ_INADDR_ANY) ||
(transport->local_addr.addr.sa_family == pj_AF_INET6() &&
!pj_memcmp(&transport->local_addr.ipv6.sin6_addr, loop6, sizeof(loop6)))) {
return 1;
}
/* If the transport is explicitly bound but the determined source differs favor the transport */
if (!pj_strcmp(source, &transport->local_name.host)) {
return 1;
}
return 0;
}
static pj_stun_tx_data* tsx_lookup(pj_stun_session *sess,
const pj_stun_msg *msg)
{
pj_stun_tx_data *tdata;
tdata = sess->pending_request_list.next;
while (tdata != &sess->pending_request_list) {
pj_assert(sizeof(tdata->msg_key)==sizeof(msg->hdr.tsx_id));
if (tdata->msg_magic == msg->hdr.magic &&
pj_memcmp(tdata->msg_key, msg->hdr.tsx_id,
sizeof(msg->hdr.tsx_id))==0)
{
return tdata;
}
tdata = tdata->next;
}
return NULL;
}
/*
* Compare two socket addresses.
*/
PJ_DEF(int) pj_sockaddr_cmp( const pj_sockaddr_t *addr1,
const pj_sockaddr_t *addr2)
{
const pj_sockaddr *a1 = (const pj_sockaddr*) addr1;
const pj_sockaddr *a2 = (const pj_sockaddr*) addr2;
int port1, port2;
int result;
/* Compare address family */
if (a1->addr.sa_family < a2->addr.sa_family)
return -1;
else if (a1->addr.sa_family > a2->addr.sa_family)
return 1;
/* Compare addresses */
result = pj_memcmp(pj_sockaddr_get_addr(a1),
pj_sockaddr_get_addr(a2),
pj_sockaddr_get_addr_len(a1));
if (result != 0)
return result;
/* Compare port number */
port1 = pj_sockaddr_get_port(a1);
port2 = pj_sockaddr_get_port(a2);
if (port1 < port2)
return -1;
else if (port1 > port2)
return 1;
/* TODO:
* Do we need to compare flow label and scope id in IPv6?
*/
/* Looks equal */
return 0;
}
/*
* Create MD5-AKA1 digest response.
*/
PJ_DEF(pj_status_t) pjsip_auth_create_aka_response(
pj_pool_t *pool,
const pjsip_digest_challenge*chal,
const pjsip_cred_info *cred,
const pj_str_t *method,
pjsip_digest_credential *auth)
{
pj_str_t nonce_bin;
int aka_version;
const pj_str_t pjsip_AKAv1_MD5 = { "AKAv1-MD5", 9 };
const pj_str_t pjsip_AKAv2_MD5 = { "AKAv2-MD5", 9 };
pj_uint8_t *chal_rand, *chal_sqnxoraka, *chal_mac;
pj_uint8_t k[PJSIP_AKA_KLEN];
pj_uint8_t op[PJSIP_AKA_OPLEN];
pj_uint8_t amf[PJSIP_AKA_AMFLEN];
pj_uint8_t res[PJSIP_AKA_RESLEN];
pj_uint8_t ck[PJSIP_AKA_CKLEN];
pj_uint8_t ik[PJSIP_AKA_IKLEN];
pj_uint8_t ak[PJSIP_AKA_AKLEN];
pj_uint8_t sqn[PJSIP_AKA_SQNLEN];
pj_uint8_t xmac[PJSIP_AKA_MACLEN];
pjsip_cred_info aka_cred;
int i, len;
pj_status_t status;
/* Check the algorithm is supported. */
if (chal->algorithm.slen==0 || pj_stricmp2(&chal->algorithm, "md5") == 0) {
/*
* A normal MD5 authentication is requested. Fallbackt to the usual
* MD5 digest creation.
*/
pjsip_auth_create_digest(&auth->response, &auth->nonce, &auth->nc,
&auth->cnonce, &auth->qop, &auth->uri,
&auth->realm, cred, method);
return PJ_SUCCESS;
} else if (pj_stricmp(&chal->algorithm, &pjsip_AKAv1_MD5) == 0) {
/*
* AKA version 1 is requested.
*/
aka_version = 1;
} else if (pj_stricmp(&chal->algorithm, &pjsip_AKAv2_MD5) == 0) {
/*
* AKA version 2 is requested.
*/
aka_version = 2;
} else {
/* Unsupported algorithm */
return PJSIP_EINVALIDALGORITHM;
}
/* Decode nonce */
nonce_bin.slen = len = PJ_BASE64_TO_BASE256_LEN(chal->nonce.slen);
nonce_bin.ptr = pj_pool_alloc(pool, nonce_bin.slen + 1);
status = pj_base64_decode(&chal->nonce, (pj_uint8_t*)nonce_bin.ptr, &len);
nonce_bin.slen = len;
if (status != PJ_SUCCESS)
return PJSIP_EAUTHINNONCE;
if (nonce_bin.slen < PJSIP_AKA_RANDLEN + PJSIP_AKA_AUTNLEN)
return PJSIP_EAUTHINNONCE;
/* Get RAND, AUTN, and MAC */
chal_rand = (pj_uint8_t*)(nonce_bin.ptr + 0);
chal_sqnxoraka = (pj_uint8_t*) (nonce_bin.ptr + PJSIP_AKA_RANDLEN);
chal_mac = (pj_uint8_t*) (nonce_bin.ptr + PJSIP_AKA_RANDLEN +
PJSIP_AKA_SQNLEN + PJSIP_AKA_AMFLEN);
/* Copy k. op, and amf */
pj_bzero(k, sizeof(k));
pj_bzero(op, sizeof(op));
pj_bzero(amf, sizeof(amf));
if (cred->ext.aka.k.slen)
pj_memcpy(k, cred->ext.aka.k.ptr, cred->ext.aka.k.slen);
if (cred->ext.aka.op.slen)
pj_memcpy(op, cred->ext.aka.op.ptr, cred->ext.aka.op.slen);
if (cred->ext.aka.amf.slen)
pj_memcpy(amf, cred->ext.aka.amf.ptr, cred->ext.aka.amf.slen);
/* Given key K and random challenge RAND, compute response RES,
* confidentiality key CK, integrity key IK and anonymity key AK.
*/
f2345(k, chal_rand, res, ck, ik, ak, op);
/* Compute sequence number SQN */
for (i=0; i<PJSIP_AKA_SQNLEN; ++i)
sqn[i] = (pj_uint8_t) (chal_sqnxoraka[i] ^ ak[i]);
/* Verify MAC in the challenge */
/* Compute XMAC */
f1(k, chal_rand, sqn, amf, xmac, op);
if (pj_memcmp(chal_mac, xmac, PJSIP_AKA_MACLEN) != 0) {
return PJSIP_EAUTHINNONCE;
}
/* Build a temporary credential info to create MD5 digest, using
* "res" as the password.
*/
pj_memcpy(&aka_cred, cred, sizeof(aka_cred));
aka_cred.data_type = PJSIP_CRED_DATA_PLAIN_PASSWD;
/* Create a response */
if (aka_version == 1) {
/*
* For AKAv1, the password is RES
*/
aka_cred.data.ptr = (char*)res;
aka_cred.data.slen = PJSIP_AKA_RESLEN;
pjsip_auth_create_digest(&auth->response, &chal->nonce,
&auth->nc, &auth->cnonce, &auth->qop,
&auth->uri, &chal->realm, &aka_cred, method);
} else if (aka_version == 2) {
/*
* For AKAv2, password is base64 encoded [1] parameters:
* PRF(RES||IK||CK,"http-digest-akav2-password")
*
* The pseudo-random function (PRF) is HMAC-MD5 in this case.
*/
pj_str_t resikck;
const pj_str_t AKAv2_Passwd = { "http-digest-akav2-password", 26 };
pj_uint8_t hmac_digest[16];
char tmp_buf[48];
int hmac64_len;
resikck.slen = PJSIP_AKA_RESLEN + PJSIP_AKA_IKLEN + PJSIP_AKA_CKLEN;
pj_assert(resikck.slen <= PJ_ARRAY_SIZE(tmp_buf));
resikck.ptr = tmp_buf;
pj_memcpy(resikck.ptr + 0, res, PJSIP_AKA_RESLEN);
pj_memcpy(resikck.ptr + PJSIP_AKA_RESLEN, ik, PJSIP_AKA_IKLEN);
pj_memcpy(resikck.ptr + PJSIP_AKA_RESLEN + PJSIP_AKA_IKLEN,
ck, PJSIP_AKA_CKLEN);
pj_hmac_md5((const pj_uint8_t*)AKAv2_Passwd.ptr, AKAv2_Passwd.slen,
(const pj_uint8_t*)resikck.ptr, resikck.slen,
hmac_digest);
aka_cred.data.slen = hmac64_len =
PJ_BASE256_TO_BASE64_LEN(PJ_ARRAY_SIZE(hmac_digest));
pj_assert(aka_cred.data.slen+1 <= PJ_ARRAY_SIZE(tmp_buf));
aka_cred.data.ptr = tmp_buf;
pj_base64_encode(hmac_digest, PJ_ARRAY_SIZE(hmac_digest),
aka_cred.data.ptr, &len);
aka_cred.data.slen = hmac64_len;
pjsip_auth_create_digest(&auth->response, &chal->nonce,
&auth->nc, &auth->cnonce, &auth->qop,
&auth->uri, &chal->realm, &aka_cred, method);
} else {
pj_assert(!"Bug!");
return PJ_EBUG;
}
/* Done */
return PJ_SUCCESS;
}
/* On received data from peer */
static pj_bool_t alloc_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)
{
turn_allocation *alloc;
pj_stun_xor_peer_addr_attr *pa;
pj_stun_data_attr *da;
char peer_info[PJ_INET6_ADDRSTRLEN+10];
char client_info[PJ_INET6_ADDRSTRLEN+10];
pj_uint8_t buffer[1500];
pj_ssize_t sent;
unsigned i;
if (status != PJ_SUCCESS)
return PJ_TRUE;
alloc = (turn_allocation*) pj_activesock_get_user_data(asock);
pj_sockaddr_print(&alloc->client_addr, client_info, sizeof(client_info), 3);
pj_sockaddr_print(src_addr, peer_info, sizeof(peer_info), 3);
/* Check that this peer has a permission */
for (i=0; i<alloc->perm_cnt; ++i) {
if (pj_sockaddr_get_len(&alloc->perm[i]) == (unsigned)addr_len &&
pj_memcmp(pj_sockaddr_get_addr(&alloc->perm[i]),
pj_sockaddr_get_addr(src_addr),
addr_len) == 0)
{
break;
}
}
if (i==alloc->perm_cnt) {
PJ_LOG(5,("", "Client %s received %d bytes unauthorized data from peer %s",
client_info, size, peer_info));
if (alloc->perm_cnt == 0)
PJ_LOG(5,("", "Client %s has no permission", client_info));
return PJ_TRUE;
}
/* Format a Data indication */
pa = (pj_stun_xor_peer_addr_attr*)
pj_stun_msg_find_attr(alloc->data_ind, PJ_STUN_ATTR_XOR_PEER_ADDR, 0);
da = (pj_stun_data_attr*)
pj_stun_msg_find_attr(alloc->data_ind, PJ_STUN_ATTR_DATA, 0);
pj_assert(pa && da);
pj_sockaddr_cp(&pa->sockaddr, src_addr);
da->data = (pj_uint8_t*)data;
da->length = size;
/* Encode Data indication */
status = pj_stun_msg_encode(alloc->data_ind, buffer, sizeof(buffer), 0,
NULL, &size);
if (status != PJ_SUCCESS)
return PJ_TRUE;
/* Send */
sent = size;
PJ_LOG(5,("", "Forwarding %d bytes data from peer %s to client %s",
sent, peer_info, client_info));
pj_activesock_sendto(alloc->test_srv->turn_sock, &alloc->send_key, buffer,
&sent, 0, &alloc->client_addr,
pj_sockaddr_get_len(&alloc->client_addr));
return PJ_TRUE;
}
/* Generate transport's published address */
static pj_status_t get_published_name(pj_sock_t sock,
char hostbuf[],
int hostbufsz,
pjsip_host_port *bound_name)
{
pj_sockaddr tmp_addr;
int addr_len;
pj_status_t status;
addr_len = sizeof(tmp_addr);
status = pj_sock_getsockname(sock, &tmp_addr, &addr_len);
if (status != PJ_SUCCESS)
return status;
bound_name->host.ptr = hostbuf;
if (tmp_addr.addr.sa_family == pj_AF_INET()) {
bound_name->port = pj_ntohs(tmp_addr.ipv4.sin_port);
/* If bound address specifies "0.0.0.0", get the IP address
* of local hostname.
*/
if (tmp_addr.ipv4.sin_addr.s_addr == PJ_INADDR_ANY) {
pj_sockaddr hostip;
status = pj_gethostip(pj_AF_INET(), &hostip);
if (status != PJ_SUCCESS)
return status;
pj_strcpy2(&bound_name->host, pj_inet_ntoa(hostip.ipv4.sin_addr));
} else {
/* Otherwise use bound address. */
pj_strcpy2(&bound_name->host,
pj_inet_ntoa(tmp_addr.ipv4.sin_addr));
status = PJ_SUCCESS;
}
} else {
/* If bound address specifies "INADDR_ANY" (IPv6), get the
* IP address of local hostname
*/
pj_uint32_t loop6[4] = { 0, 0, 0, 0};
bound_name->port = pj_ntohs(tmp_addr.ipv6.sin6_port);
if (pj_memcmp(&tmp_addr.ipv6.sin6_addr, loop6, sizeof(loop6))==0) {
status = pj_gethostip(tmp_addr.addr.sa_family, &tmp_addr);
if (status != PJ_SUCCESS)
return status;
}
status = pj_inet_ntop(tmp_addr.addr.sa_family,
pj_sockaddr_get_addr(&tmp_addr),
hostbuf, hostbufsz);
if (status == PJ_SUCCESS) {
bound_name->host.slen = pj_ansi_strlen(hostbuf);
}
}
return status;
}
static pj_bool_t ssl_on_data_read(pj_ssl_sock_t *ssock,
void *data,
pj_size_t size,
pj_status_t status,
pj_size_t *remainder)
{
struct test_state *st = (struct test_state*)
pj_ssl_sock_get_user_data(ssock);
PJ_UNUSED_ARG(remainder);
PJ_UNUSED_ARG(data);
if (size > 0) {
pj_size_t consumed;
/* Set random remainder */
*remainder = pj_rand() % 100;
/* Apply zero remainder if:
* - remainder is less than size, or
* - connection closed/error
* - echo/check_eco set
*/
if (*remainder > size || status != PJ_SUCCESS || st->echo || st->check_echo)
*remainder = 0;
consumed = size - *remainder;
st->recv += consumed;
//printf("%.*s", consumed, (char*)data);
pj_memmove(data, (char*)data + consumed, *remainder);
/* Echo data when specified to */
if (st->echo) {
pj_ssize_t size_ = consumed;
status = pj_ssl_sock_send(ssock, (pj_ioqueue_op_key_t*)&st->send_key, data, &size_, 0);
if (status != PJ_SUCCESS && status != PJ_EPENDING) {
app_perror("...ERROR pj_ssl_sock_send()", status);
goto on_return;
}
if (status == PJ_SUCCESS)
st->sent += size_;
}
/* Verify echoed data when specified to */
if (st->check_echo) {
if (!st->check_echo_ptr)
st->check_echo_ptr = st->send_str;
if (pj_memcmp(st->check_echo_ptr, data, consumed)) {
status = PJ_EINVAL;
app_perror("...ERROR echoed data not exact", status);
goto on_return;
}
st->check_echo_ptr += consumed;
/* Echo received completely */
if (st->send_str_len == st->recv) {
pj_ssl_sock_info info;
char buf[64];
status = pj_ssl_sock_get_info(ssock, &info);
if (status != PJ_SUCCESS) {
app_perror("...ERROR pj_ssl_sock_get_info()", status);
goto on_return;
}
pj_sockaddr_print((pj_sockaddr_t*)&info.local_addr, buf, sizeof(buf), 1);
PJ_LOG(3, ("", "...%s successfully recv %d bytes echo", buf, st->recv));
st->done = PJ_TRUE;
}
}
}
if (status != PJ_SUCCESS) {
if (status == PJ_EEOF) {
status = PJ_SUCCESS;
st->done = PJ_TRUE;
} else {
app_perror("...ERROR ssl_on_data_read()", status);
}
}
on_return:
st->err = status;
if (st->err != PJ_SUCCESS || st->done) {
pj_ssl_sock_close(ssock);
if (!st->is_server)
clients_num--;
return PJ_FALSE;
}
return PJ_TRUE;
}
/*
* compliance_test()
* To test that the basic IOQueue functionality works. It will just exchange
* data between two sockets.
*/
static int compliance_test(pj_bool_t allow_concur)
{
pj_sock_t ssock=-1, csock=-1;
pj_sockaddr_in addr, dst_addr;
int addrlen;
pj_pool_t *pool = NULL;
char *send_buf, *recv_buf;
pj_ioqueue_t *ioque = NULL;
pj_ioqueue_key_t *skey = NULL, *ckey = NULL;
pj_ioqueue_op_key_t read_op, write_op;
int bufsize = BUF_MIN_SIZE;
pj_ssize_t bytes;
int status = -1;
pj_str_t temp;
pj_bool_t send_pending, recv_pending;
pj_status_t rc;
pj_set_os_error(PJ_SUCCESS);
// Create pool.
pool = pj_pool_create(mem, NULL, POOL_SIZE, 4000, NULL);
// Allocate buffers for send and receive.
send_buf = (char*)pj_pool_alloc(pool, bufsize);
recv_buf = (char*)pj_pool_alloc(pool, bufsize);
// Allocate sockets for sending and receiving.
TRACE_("creating sockets...");
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &ssock);
if (rc==PJ_SUCCESS)
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &csock);
else
csock = PJ_INVALID_SOCKET;
if (rc != PJ_SUCCESS) {
app_perror("...ERROR in pj_sock_socket()", rc);
status=-1; goto on_error;
}
// Bind server socket.
TRACE_("bind socket...");
pj_bzero(&addr, sizeof(addr));
addr.sin_family = pj_AF_INET();
addr.sin_port = pj_htons(PORT);
if (pj_sock_bind(ssock, &addr, sizeof(addr))) {
status=-10; goto on_error;
}
// Create I/O Queue.
TRACE_("create ioqueue...");
rc = pj_ioqueue_create(pool, PJ_IOQUEUE_MAX_HANDLES, &ioque);
if (rc != PJ_SUCCESS) {
status=-20; goto on_error;
}
// Set concurrency
TRACE_("set concurrency...");
rc = pj_ioqueue_set_default_concurrency(ioque, allow_concur);
if (rc != PJ_SUCCESS) {
status=-21; goto on_error;
}
// Register server and client socket.
// We put this after inactivity socket, hopefully this can represent the
// worst waiting time.
TRACE_("registering first sockets...");
rc = pj_ioqueue_register_sock(pool, ioque, ssock, NULL,
&test_cb, &skey);
if (rc != PJ_SUCCESS) {
app_perror("...error(10): ioqueue_register error", rc);
status=-25; goto on_error;
}
TRACE_("registering second sockets...");
rc = pj_ioqueue_register_sock( pool, ioque, csock, NULL,
&test_cb, &ckey);
if (rc != PJ_SUCCESS) {
app_perror("...error(11): ioqueue_register error", rc);
status=-26; goto on_error;
}
// Randomize send_buf.
pj_create_random_string(send_buf, bufsize);
// Register reading from ioqueue.
TRACE_("start recvfrom...");
pj_bzero(&addr, sizeof(addr));
addrlen = sizeof(addr);
bytes = bufsize;
rc = pj_ioqueue_recvfrom(skey, &read_op, recv_buf, &bytes, 0,
&addr, &addrlen);
if (rc != PJ_SUCCESS && rc != PJ_EPENDING) {
app_perror("...error: pj_ioqueue_recvfrom", rc);
status=-28; goto on_error;
} else if (rc == PJ_EPENDING) {
recv_pending = 1;
PJ_LOG(3, (THIS_FILE,
"......ok: recvfrom returned pending"));
} else {
PJ_LOG(3, (THIS_FILE,
"......error: recvfrom returned immediate ok!"));
status=-29; goto on_error;
}
// Set destination address to send the packet.
TRACE_("set destination address...");
temp = pj_str("127.0.0.1");
if ((rc=pj_sockaddr_in_init(&dst_addr, &temp, PORT)) != 0) {
app_perror("...error: unable to resolve 127.0.0.1", rc);
status=-290; goto on_error;
}
// Write must return the number of bytes.
TRACE_("start sendto...");
bytes = bufsize;
rc = pj_ioqueue_sendto(ckey, &write_op, send_buf, &bytes, 0, &dst_addr,
sizeof(dst_addr));
if (rc != PJ_SUCCESS && rc != PJ_EPENDING) {
app_perror("...error: pj_ioqueue_sendto", rc);
status=-30; goto on_error;
} else if (rc == PJ_EPENDING) {
send_pending = 1;
PJ_LOG(3, (THIS_FILE,
"......ok: sendto returned pending"));
} else {
send_pending = 0;
PJ_LOG(3, (THIS_FILE,
"......ok: sendto returned immediate success"));
}
// reset callback variables.
callback_read_size = callback_write_size = 0;
callback_accept_status = callback_connect_status = -2;
callback_read_key = callback_write_key =
callback_accept_key = callback_connect_key = NULL;
callback_read_op = callback_write_op = NULL;
// Poll if pending.
while (send_pending || recv_pending) {
int rc;
pj_time_val timeout = { 5, 0 };
TRACE_("poll...");
#ifdef PJ_SYMBIAN
rc = pj_symbianos_poll(-1, PJ_TIME_VAL_MSEC(timeout));
#else
rc = pj_ioqueue_poll(ioque, &timeout);
#endif
if (rc == 0) {
PJ_LOG(1,(THIS_FILE, "...ERROR: timed out..."));
status=-45; goto on_error;
} else if (rc < 0) {
app_perror("...ERROR in ioqueue_poll()", -rc);
status=-50; goto on_error;
}
if (callback_read_key != NULL) {
if (callback_read_size != bufsize) {
status=-61; goto on_error;
}
if (callback_read_key != skey) {
status=-65; goto on_error;
}
if (callback_read_op != &read_op) {
status=-66; goto on_error;
}
if (pj_memcmp(send_buf, recv_buf, bufsize) != 0) {
status=-67; goto on_error;
}
if (addrlen != sizeof(pj_sockaddr_in)) {
status=-68; goto on_error;
}
if (addr.sin_family != pj_AF_INET()) {
status=-69; goto on_error;
}
recv_pending = 0;
}
if (callback_write_key != NULL) {
if (callback_write_size != bufsize) {
status=-73; goto on_error;
}
if (callback_write_key != ckey) {
status=-75; goto on_error;
}
if (callback_write_op != &write_op) {
status=-76; goto on_error;
}
send_pending = 0;
}
}
// Success
status = 0;
on_error:
if (skey)
pj_ioqueue_unregister(skey);
else if (ssock != -1)
pj_sock_close(ssock);
if (ckey)
pj_ioqueue_unregister(ckey);
else if (csock != -1)
pj_sock_close(csock);
if (ioque != NULL)
pj_ioqueue_destroy(ioque);
pj_pool_release(pool);
return status;
}
/*
* Benchmarking IOQueue
*/
static int bench_test(pj_bool_t allow_concur, int bufsize,
int inactive_sock_count)
{
pj_sock_t ssock=-1, csock=-1;
pj_sockaddr_in addr;
pj_pool_t *pool = NULL;
pj_sock_t *inactive_sock=NULL;
pj_ioqueue_op_key_t *inactive_read_op;
char *send_buf, *recv_buf;
pj_ioqueue_t *ioque = NULL;
pj_ioqueue_key_t *skey, *ckey, *keys[SOCK_INACTIVE_MAX+2];
pj_timestamp t1, t2, t_elapsed;
int rc=0, i; /* i must be signed */
pj_str_t temp;
char errbuf[PJ_ERR_MSG_SIZE];
TRACE__((THIS_FILE, " bench test %d", inactive_sock_count));
// Create pool.
pool = pj_pool_create(mem, NULL, POOL_SIZE, 4000, NULL);
// Allocate buffers for send and receive.
send_buf = (char*)pj_pool_alloc(pool, bufsize);
recv_buf = (char*)pj_pool_alloc(pool, bufsize);
// Allocate sockets for sending and receiving.
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &ssock);
if (rc == PJ_SUCCESS) {
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &csock);
} else
csock = PJ_INVALID_SOCKET;
if (rc != PJ_SUCCESS) {
app_perror("...error: pj_sock_socket()", rc);
goto on_error;
}
// Bind server socket.
pj_bzero(&addr, sizeof(addr));
addr.sin_family = pj_AF_INET();
addr.sin_port = pj_htons(PORT);
if (pj_sock_bind(ssock, &addr, sizeof(addr)))
goto on_error;
pj_assert(inactive_sock_count+2 <= PJ_IOQUEUE_MAX_HANDLES);
// Create I/O Queue.
rc = pj_ioqueue_create(pool, PJ_IOQUEUE_MAX_HANDLES, &ioque);
if (rc != PJ_SUCCESS) {
app_perror("...error: pj_ioqueue_create()", rc);
goto on_error;
}
// Set concurrency
rc = pj_ioqueue_set_default_concurrency(ioque, allow_concur);
if (rc != PJ_SUCCESS) {
app_perror("...error: pj_ioqueue_set_default_concurrency()", rc);
goto on_error;
}
// Allocate inactive sockets, and bind them to some arbitrary address.
// Then register them to the I/O queue, and start a read operation.
inactive_sock = (pj_sock_t*)pj_pool_alloc(pool,
inactive_sock_count*sizeof(pj_sock_t));
inactive_read_op = (pj_ioqueue_op_key_t*)pj_pool_alloc(pool,
inactive_sock_count*sizeof(pj_ioqueue_op_key_t));
pj_bzero(&addr, sizeof(addr));
addr.sin_family = pj_AF_INET();
for (i=0; i<inactive_sock_count; ++i) {
pj_ssize_t bytes;
rc = pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &inactive_sock[i]);
if (rc != PJ_SUCCESS || inactive_sock[i] < 0) {
app_perror("...error: pj_sock_socket()", rc);
goto on_error;
}
if ((rc=pj_sock_bind(inactive_sock[i], &addr, sizeof(addr))) != 0) {
pj_sock_close(inactive_sock[i]);
inactive_sock[i] = PJ_INVALID_SOCKET;
app_perror("...error: pj_sock_bind()", rc);
goto on_error;
}
rc = pj_ioqueue_register_sock(pool, ioque, inactive_sock[i],
NULL, &test_cb, &keys[i]);
if (rc != PJ_SUCCESS) {
pj_sock_close(inactive_sock[i]);
inactive_sock[i] = PJ_INVALID_SOCKET;
app_perror("...error(1): pj_ioqueue_register_sock()", rc);
PJ_LOG(3,(THIS_FILE, "....i=%d", i));
goto on_error;
}
bytes = bufsize;
rc = pj_ioqueue_recv(keys[i], &inactive_read_op[i], recv_buf, &bytes, 0);
if (rc != PJ_EPENDING) {
pj_sock_close(inactive_sock[i]);
inactive_sock[i] = PJ_INVALID_SOCKET;
app_perror("...error: pj_ioqueue_read()", rc);
goto on_error;
}
}
// Register server and client socket.
// We put this after inactivity socket, hopefully this can represent the
// worst waiting time.
rc = pj_ioqueue_register_sock(pool, ioque, ssock, NULL,
&test_cb, &skey);
if (rc != PJ_SUCCESS) {
app_perror("...error(2): pj_ioqueue_register_sock()", rc);
goto on_error;
}
rc = pj_ioqueue_register_sock(pool, ioque, csock, NULL,
&test_cb, &ckey);
if (rc != PJ_SUCCESS) {
app_perror("...error(3): pj_ioqueue_register_sock()", rc);
goto on_error;
}
// Set destination address to send the packet.
pj_sockaddr_in_init(&addr, pj_cstr(&temp, "127.0.0.1"), PORT);
// Test loop.
t_elapsed.u64 = 0;
for (i=0; i<LOOP; ++i) {
pj_ssize_t bytes;
pj_ioqueue_op_key_t read_op, write_op;
// Randomize send buffer.
pj_create_random_string(send_buf, bufsize);
// Start reading on the server side.
bytes = bufsize;
rc = pj_ioqueue_recv(skey, &read_op, recv_buf, &bytes, 0);
if (rc != PJ_EPENDING) {
app_perror("...error: pj_ioqueue_read()", rc);
break;
}
// Starts send on the client side.
bytes = bufsize;
rc = pj_ioqueue_sendto(ckey, &write_op, send_buf, &bytes, 0,
&addr, sizeof(addr));
if (rc != PJ_SUCCESS && rc != PJ_EPENDING) {
app_perror("...error: pj_ioqueue_write()", rc);
break;
}
if (rc == PJ_SUCCESS) {
if (bytes < 0) {
app_perror("...error: pj_ioqueue_sendto()",(pj_status_t)-bytes);
break;
}
}
// Begin time.
pj_get_timestamp(&t1);
// Poll the queue until we've got completion event in the server side.
callback_read_key = NULL;
callback_read_size = 0;
TRACE__((THIS_FILE, " waiting for key = %p", skey));
do {
pj_time_val timeout = { 1, 0 };
#ifdef PJ_SYMBIAN
rc = pj_symbianos_poll(-1, PJ_TIME_VAL_MSEC(timeout));
#else
rc = pj_ioqueue_poll(ioque, &timeout);
#endif
TRACE__((THIS_FILE, " poll rc=%d", rc));
} while (rc >= 0 && callback_read_key != skey);
// End time.
pj_get_timestamp(&t2);
t_elapsed.u64 += (t2.u64 - t1.u64);
if (rc < 0) {
app_perror(" error: pj_ioqueue_poll", -rc);
break;
}
// Compare recv buffer with send buffer.
if (callback_read_size != bufsize ||
pj_memcmp(send_buf, recv_buf, bufsize))
{
rc = -10;
PJ_LOG(3,(THIS_FILE, " error: size/buffer mismatch"));
break;
}
// Poll until all events are exhausted, before we start the next loop.
do {
pj_time_val timeout = { 0, 10 };
#ifdef PJ_SYMBIAN
PJ_UNUSED_ARG(timeout);
rc = pj_symbianos_poll(-1, 100);
#else
rc = pj_ioqueue_poll(ioque, &timeout);
#endif
} while (rc>0);
rc = 0;
}
// Print results
if (rc == 0) {
pj_timestamp tzero;
pj_uint32_t usec_delay;
tzero.u32.hi = tzero.u32.lo = 0;
usec_delay = pj_elapsed_usec( &tzero, &t_elapsed);
PJ_LOG(3, (THIS_FILE, "...%10d %15d % 9d",
bufsize, inactive_sock_count, usec_delay));
} else {
PJ_LOG(2, (THIS_FILE, "...ERROR rc=%d (buf:%d, fds:%d)",
rc, bufsize, inactive_sock_count+2));
}
// Cleaning up.
for (i=inactive_sock_count-1; i>=0; --i) {
pj_ioqueue_unregister(keys[i]);
}
pj_ioqueue_unregister(skey);
pj_ioqueue_unregister(ckey);
pj_ioqueue_destroy(ioque);
pj_pool_release( pool);
return rc;
on_error:
PJ_LOG(1,(THIS_FILE, "...ERROR: %s",
pj_strerror(pj_get_netos_error(), errbuf, sizeof(errbuf))));
if (ssock)
pj_sock_close(ssock);
if (csock)
pj_sock_close(csock);
for (i=0; i<inactive_sock_count && inactive_sock &&
inactive_sock[i]!=PJ_INVALID_SOCKET; ++i)
{
pj_sock_close(inactive_sock[i]);
}
if (ioque != NULL)
pj_ioqueue_destroy(ioque);
pj_pool_release( pool);
return -1;
}
/* Resolve the IP address of local machine */
PJ_DEF(pj_status_t) pj_gethostip(int af, pj_sockaddr *addr)
{
unsigned i, count, cand_cnt;
enum {
CAND_CNT = 8,
/* Weighting to be applied to found addresses */
WEIGHT_HOSTNAME = 1, /* hostname IP is not always valid! */
WEIGHT_DEF_ROUTE = 2,
WEIGHT_INTERFACE = 1,
WEIGHT_LOOPBACK = -5,
WEIGHT_LINK_LOCAL = -4,
WEIGHT_DISABLED = -50,
MIN_WEIGHT = WEIGHT_DISABLED+1 /* minimum weight to use */
};
/* candidates: */
pj_sockaddr cand_addr[CAND_CNT];
int cand_weight[CAND_CNT];
int selected_cand;
char strip[PJ_INET6_ADDRSTRLEN+10];
/* Special IPv4 addresses. */
struct spec_ipv4_t
{
pj_uint32_t addr;
pj_uint32_t mask;
int weight;
} spec_ipv4[] =
{
/* 127.0.0.0/8, loopback addr will be used if there is no other
* addresses.
*/
{ 0x7f000000, 0xFF000000, WEIGHT_LOOPBACK },
/* 0.0.0.0/8, special IP that doesn't seem to be practically useful */
{ 0x00000000, 0xFF000000, WEIGHT_DISABLED },
/* 169.254.0.0/16, a zeroconf/link-local address, which has higher
* priority than loopback and will be used if there is no other
* valid addresses.
*/
{ 0xa9fe0000, 0xFFFF0000, WEIGHT_LINK_LOCAL }
};
/* Special IPv6 addresses */
struct spec_ipv6_t
{
pj_uint8_t addr[16];
pj_uint8_t mask[16];
int weight;
} spec_ipv6[] =
{
/* Loopback address, ::1/128 */
{ {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff},
WEIGHT_LOOPBACK
},
/* Link local, fe80::/10 */
{ {0xfe,0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0xff,0xc0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
WEIGHT_LINK_LOCAL
},
/* Disabled, ::/128 */
{ {0x0,0x0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{ 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff},
WEIGHT_DISABLED
}
};
pj_addrinfo ai;
pj_status_t status;
/* May not be used if TRACE_ is disabled */
PJ_UNUSED_ARG(strip);
#ifdef _MSC_VER
/* Get rid of "uninitialized he variable" with MS compilers */
pj_bzero(&ai, sizeof(ai));
#endif
cand_cnt = 0;
pj_bzero(cand_addr, sizeof(cand_addr));
pj_bzero(cand_weight, sizeof(cand_weight));
for (i=0; i<PJ_ARRAY_SIZE(cand_addr); ++i) {
cand_addr[i].addr.sa_family = (pj_uint16_t)af;
PJ_SOCKADDR_RESET_LEN(&cand_addr[i]);
}
addr->addr.sa_family = (pj_uint16_t)af;
PJ_SOCKADDR_RESET_LEN(addr);
#if !defined(PJ_GETHOSTIP_DISABLE_LOCAL_RESOLUTION) || \
PJ_GETHOSTIP_DISABLE_LOCAL_RESOLUTION == 0
TRACE_((THIS_FILE, "pj_gethostip() pj_getaddrinfo1"));
/* Get hostname's IP address */
count = 1;
status = pj_getaddrinfo(af, pj_gethostname(), &count, &ai);
if (status == PJ_SUCCESS) {
pj_assert(ai.ai_addr.addr.sa_family == (pj_uint16_t)af);
pj_sockaddr_copy_addr(&cand_addr[cand_cnt], &ai.ai_addr);
pj_sockaddr_set_port(&cand_addr[cand_cnt], 0);
cand_weight[cand_cnt] += WEIGHT_HOSTNAME;
++cand_cnt;
TRACE_((THIS_FILE, "hostname IP is %s",
pj_sockaddr_print(&ai.ai_addr, strip, sizeof(strip), 0)));
}
TRACE_((THIS_FILE, "pj_gethostip() pj_getaddrinfo2"));
#else
PJ_UNUSED_ARG(ai);
PJ_UNUSED_ARG(count);
#endif
/* Get default interface (interface for default route) */
if (cand_cnt < PJ_ARRAY_SIZE(cand_addr)) {
status = pj_getdefaultipinterface(af, addr);
if (status == PJ_SUCCESS) {
TRACE_((THIS_FILE, "default IP is %s",
pj_sockaddr_print(addr, strip, sizeof(strip), 0)));
pj_sockaddr_set_port(addr, 0);
for (i=0; i<cand_cnt; ++i) {
if (pj_sockaddr_cmp(&cand_addr[i], addr)==0)
break;
}
cand_weight[i] += WEIGHT_DEF_ROUTE;
if (i >= cand_cnt) {
pj_sockaddr_copy_addr(&cand_addr[i], addr);
++cand_cnt;
}
}
}
/* Enumerate IP interfaces */
if (cand_cnt < PJ_ARRAY_SIZE(cand_addr)) {
unsigned start_if = cand_cnt;
unsigned count = PJ_ARRAY_SIZE(cand_addr) - start_if;
status = pj_enum_ip_interface(af, &count, &cand_addr[start_if]);
if (status == PJ_SUCCESS && count) {
/* Clear the port number */
for (i=0; i<count; ++i)
pj_sockaddr_set_port(&cand_addr[start_if+i], 0);
/* For each candidate that we found so far (that is the hostname
* address and default interface address, check if they're found
* in the interface list. If found, add the weight, and if not,
* decrease the weight.
*/
for (i=0; i<cand_cnt; ++i) {
unsigned j;
for (j=0; j<count; ++j) {
if (pj_sockaddr_cmp(&cand_addr[i],
&cand_addr[start_if+j])==0)
break;
}
if (j == count) {
/* Not found */
cand_weight[i] -= WEIGHT_INTERFACE;
} else {
cand_weight[i] += WEIGHT_INTERFACE;
}
}
/* Add remaining interface to candidate list. */
for (i=0; i<count; ++i) {
unsigned j;
for (j=0; j<cand_cnt; ++j) {
if (pj_sockaddr_cmp(&cand_addr[start_if+i],
&cand_addr[j])==0)
break;
}
if (j == cand_cnt) {
pj_sockaddr_copy_addr(&cand_addr[cand_cnt],
&cand_addr[start_if+i]);
cand_weight[cand_cnt] += WEIGHT_INTERFACE;
++cand_cnt;
}
}
}
}
/* Apply weight adjustment for special IPv4/IPv6 addresses
* See http://trac.pjsip.org/repos/ticket/1046
*/
if (af == PJ_AF_INET) {
for (i=0; i<cand_cnt; ++i) {
unsigned j;
for (j=0; j<PJ_ARRAY_SIZE(spec_ipv4); ++j) {
pj_uint32_t a = pj_ntohl(cand_addr[i].ipv4.sin_addr.s_addr);
pj_uint32_t pa = spec_ipv4[j].addr;
pj_uint32_t pm = spec_ipv4[j].mask;
if ((a & pm) == pa) {
cand_weight[i] += spec_ipv4[j].weight;
break;
}
}
}
} else if (af == PJ_AF_INET6) {
for (i=0; i<PJ_ARRAY_SIZE(spec_ipv6); ++i) {
unsigned j;
for (j=0; j<cand_cnt; ++j) {
pj_uint8_t *a = cand_addr[j].ipv6.sin6_addr.s6_addr;
pj_uint8_t am[16];
pj_uint8_t *pa = spec_ipv6[i].addr;
pj_uint8_t *pm = spec_ipv6[i].mask;
unsigned k;
for (k=0; k<16; ++k) {
am[k] = (pj_uint8_t)((a[k] & pm[k]) & 0xFF);
}
if (pj_memcmp(am, pa, 16)==0) {
cand_weight[j] += spec_ipv6[i].weight;
}
}
}
} else {
return PJ_EAFNOTSUP;
}
/* Enumerate candidates to get the best IP address to choose */
selected_cand = -1;
for (i=0; i<cand_cnt; ++i) {
TRACE_((THIS_FILE, "Checking candidate IP %s, weight=%d",
pj_sockaddr_print(&cand_addr[i], strip, sizeof(strip), 0),
cand_weight[i]));
if (cand_weight[i] < MIN_WEIGHT) {
continue;
}
if (selected_cand == -1)
selected_cand = i;
else if (cand_weight[i] > cand_weight[selected_cand])
selected_cand = i;
}
/* If else fails, returns loopback interface as the last resort */
if (selected_cand == -1) {
if (af==PJ_AF_INET) {
addr->ipv4.sin_addr.s_addr = pj_htonl (0x7f000001);
} else {
pj_in6_addr *s6_addr;
s6_addr = (pj_in6_addr*) pj_sockaddr_get_addr(addr);
pj_bzero(s6_addr, sizeof(pj_in6_addr));
s6_addr->s6_addr[15] = 1;
}
TRACE_((THIS_FILE, "Loopback IP %s returned",
pj_sockaddr_print(addr, strip, sizeof(strip), 0)));
} else {
pj_sockaddr_copy_addr(addr, &cand_addr[selected_cand]);
TRACE_((THIS_FILE, "Candidate %s selected",
pj_sockaddr_print(addr, strip, sizeof(strip), 0)));
}
return PJ_SUCCESS;
}
/* Get IP interface for sending to the specified destination */
PJ_DEF(pj_status_t) pj_getipinterface(int af,
const pj_str_t *dst,
pj_sockaddr *itf_addr,
pj_bool_t allow_resolve,
pj_sockaddr *p_dst_addr)
{
pj_sockaddr dst_addr;
pj_sock_t fd;
int len;
pj_uint8_t zero[64];
pj_status_t status;
pj_sockaddr_init(af, &dst_addr, NULL, 53);
status = pj_inet_pton(af, dst, pj_sockaddr_get_addr(&dst_addr));
if (status != PJ_SUCCESS) {
/* "dst" is not an IP address. */
if (allow_resolve) {
status = pj_sockaddr_init(af, &dst_addr, dst, 53);
} else {
pj_str_t cp;
if (af == PJ_AF_INET) {
cp = pj_str("1.1.1.1");
} else {
cp = pj_str("1::1");
}
status = pj_sockaddr_init(af, &dst_addr, &cp, 53);
}
if (status != PJ_SUCCESS)
return status;
}
/* Create UDP socket and connect() to the destination IP */
status = pj_sock_socket(af, pj_SOCK_DGRAM(), 0, &fd);
if (status != PJ_SUCCESS) {
return status;
}
status = pj_sock_connect(fd, &dst_addr, pj_sockaddr_get_len(&dst_addr));
if (status != PJ_SUCCESS) {
pj_sock_close(fd);
return status;
}
len = sizeof(*itf_addr);
status = pj_sock_getsockname(fd, itf_addr, &len);
if (status != PJ_SUCCESS) {
pj_sock_close(fd);
return status;
}
pj_sock_close(fd);
/* Check that the address returned is not zero */
pj_bzero(zero, sizeof(zero));
if (pj_memcmp(pj_sockaddr_get_addr(itf_addr), zero,
pj_sockaddr_get_addr_len(itf_addr))==0)
{
return PJ_ENOTFOUND;
}
if (p_dst_addr)
*p_dst_addr = dst_addr;
return PJ_SUCCESS;
}
/*
* Callback upon request completion.
*/
static void on_request_complete(pj_stun_session *stun_sess,
pj_status_t status,
void *token,
pj_stun_tx_data *tdata,
const pj_stun_msg *response,
const pj_sockaddr_t *src_addr,
unsigned src_addr_len)
{
nat_detect_session *sess;
pj_stun_sockaddr_attr *mattr = NULL;
pj_stun_changed_addr_attr *ca = NULL;
pj_uint32_t *tsx_id;
int cmp;
unsigned test_id;
PJ_UNUSED_ARG(token);
PJ_UNUSED_ARG(tdata);
PJ_UNUSED_ARG(src_addr);
PJ_UNUSED_ARG(src_addr_len);
sess = (nat_detect_session*) pj_stun_session_get_user_data(stun_sess);
pj_grp_lock_acquire(sess->grp_lock);
/* Find errors in the response */
if (status == PJ_SUCCESS) {
/* Check error message */
if (PJ_STUN_IS_ERROR_RESPONSE(response->hdr.type)) {
pj_stun_errcode_attr *eattr;
int err_code;
eattr = (pj_stun_errcode_attr*)
pj_stun_msg_find_attr(response, PJ_STUN_ATTR_ERROR_CODE, 0);
if (eattr != NULL)
err_code = eattr->err_code;
else
err_code = PJ_STUN_SC_SERVER_ERROR;
status = PJ_STATUS_FROM_STUN_CODE(err_code);
} else {
/* Get MAPPED-ADDRESS or XOR-MAPPED-ADDRESS */
mattr = (pj_stun_sockaddr_attr*)
pj_stun_msg_find_attr(response, PJ_STUN_ATTR_XOR_MAPPED_ADDR, 0);
if (mattr == NULL) {
mattr = (pj_stun_sockaddr_attr*)
pj_stun_msg_find_attr(response, PJ_STUN_ATTR_MAPPED_ADDR, 0);
}
if (mattr == NULL) {
status = PJNATH_ESTUNNOMAPPEDADDR;
}
/* Get CHANGED-ADDRESS attribute */
ca = (pj_stun_changed_addr_attr*)
pj_stun_msg_find_attr(response, PJ_STUN_ATTR_CHANGED_ADDR, 0);
if (ca == NULL) {
status = PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_SERVER_ERROR);
}
}
}
/* Save the result */
tsx_id = (pj_uint32_t*) tdata->msg->hdr.tsx_id;
test_id = tsx_id[2];
if (test_id >= ST_MAX) {
PJ_LOG(4,(sess->pool->obj_name, "Invalid transaction ID %u in response",
test_id));
end_session(sess, PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_SERVER_ERROR),
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
goto on_return;
}
PJ_LOG(5,(sess->pool->obj_name, "Completed %s, status=%d",
test_names[test_id], status));
sess->result[test_id].complete = PJ_TRUE;
sess->result[test_id].status = status;
if (status == PJ_SUCCESS) {
pj_memcpy(&sess->result[test_id].ma, &mattr->sockaddr.ipv4,
sizeof(pj_sockaddr_in));
pj_memcpy(&sess->result[test_id].ca, &ca->sockaddr.ipv4,
sizeof(pj_sockaddr_in));
}
/* Send Test 1B only when Test 2 completes. Must not send Test 1B
* before Test 2 completes to avoid creating mapping on the NAT.
*/
if (!sess->result[ST_TEST_1B].executed &&
sess->result[ST_TEST_2].complete &&
sess->result[ST_TEST_2].status != PJ_SUCCESS &&
sess->result[ST_TEST_1].complete &&
sess->result[ST_TEST_1].status == PJ_SUCCESS)
{
cmp = pj_memcmp(&sess->local_addr, &sess->result[ST_TEST_1].ma,
sizeof(pj_sockaddr_in));
if (cmp != 0)
send_test(sess, ST_TEST_1B, &sess->result[ST_TEST_1].ca, 0);
}
if (test_completed(sess)<3 || test_completed(sess)!=test_executed(sess))
goto on_return;
/* Handle the test result according to RFC 3489 page 22:
+--------+
| Test |
| 1 |
+--------+
|
|
V
/\ /\
N / \ Y / \ Y +--------+
UDP <-------/Resp\--------->/ IP \------------->| Test |
Blocked \ ? / \Same/ | 2 |
\ / \? / +--------+
\/ \/ |
| N |
| V
V /\
+--------+ Sym. N / \
| Test | UDP <---/Resp\
| 2 | Firewall \ ? /
+--------+ \ /
| \/
V |Y
/\ /\ |
Symmetric N / \ +--------+ N / \ V
NAT <--- / IP \<-----| Test |<--- /Resp\ Open
\Same/ | 1B | \ ? / Internet
\? / +--------+ \ /
\/ \/
| |Y
| |
| V
| Full
| Cone
V /\
+--------+ / \ Y
| Test |------>/Resp\---->Restricted
| 3 | \ ? /
+--------+ \ /
\/
|N
| Port
+------>Restricted
Figure 2: Flow for type discovery process
*/
switch (sess->result[ST_TEST_1].status) {
case PJNATH_ESTUNTIMEDOUT:
/*
* Test 1 has timed-out. Conclude with NAT_TYPE_BLOCKED.
*/
end_session(sess, PJ_SUCCESS, PJ_STUN_NAT_TYPE_BLOCKED);
break;
case PJ_SUCCESS:
/*
* Test 1 is successful. Further tests are needed to detect
* NAT type. Compare the MAPPED-ADDRESS with the local address.
*/
cmp = pj_memcmp(&sess->local_addr, &sess->result[ST_TEST_1].ma,
sizeof(pj_sockaddr_in));
if (cmp==0) {
/*
* MAPPED-ADDRESS and local address is equal. Need one more
* test to determine NAT type.
*/
switch (sess->result[ST_TEST_2].status) {
case PJ_SUCCESS:
/*
* Test 2 is also successful. We're in the open.
*/
end_session(sess, PJ_SUCCESS, PJ_STUN_NAT_TYPE_OPEN);
break;
case PJNATH_ESTUNTIMEDOUT:
/*
* Test 2 has timed out. We're behind somekind of UDP
* firewall.
*/
end_session(sess, PJ_SUCCESS, PJ_STUN_NAT_TYPE_SYMMETRIC_UDP);
break;
default:
/*
* We've got other error with Test 2.
*/
end_session(sess, sess->result[ST_TEST_2].status,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
} else {
/*
* MAPPED-ADDRESS is different than local address.
* We're behind NAT.
*/
switch (sess->result[ST_TEST_2].status) {
case PJ_SUCCESS:
/*
* Test 2 is successful. We're behind a full-cone NAT.
*/
end_session(sess, PJ_SUCCESS, PJ_STUN_NAT_TYPE_FULL_CONE);
break;
case PJNATH_ESTUNTIMEDOUT:
/*
* Test 2 has timed-out Check result of test 1B..
*/
switch (sess->result[ST_TEST_1B].status) {
case PJ_SUCCESS:
/*
* Compare the MAPPED-ADDRESS of test 1B with the
* MAPPED-ADDRESS returned in test 1..
*/
cmp = pj_memcmp(&sess->result[ST_TEST_1].ma,
&sess->result[ST_TEST_1B].ma,
sizeof(pj_sockaddr_in));
if (cmp != 0) {
/*
* MAPPED-ADDRESS is different, we're behind a
* symmetric NAT.
*/
end_session(sess, PJ_SUCCESS,
PJ_STUN_NAT_TYPE_SYMMETRIC);
} else {
/*
* MAPPED-ADDRESS is equal. We're behind a restricted
* or port-restricted NAT, depending on the result of
* test 3.
*/
switch (sess->result[ST_TEST_3].status) {
case PJ_SUCCESS:
/*
* Test 3 is successful, we're behind a restricted
* NAT.
*/
end_session(sess, PJ_SUCCESS,
PJ_STUN_NAT_TYPE_RESTRICTED);
break;
case PJNATH_ESTUNTIMEDOUT:
/*
* Test 3 failed, we're behind a port restricted
* NAT.
*/
end_session(sess, PJ_SUCCESS,
PJ_STUN_NAT_TYPE_PORT_RESTRICTED);
break;
default:
/*
* Got other error with test 3.
*/
end_session(sess, sess->result[ST_TEST_3].status,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
}
break;
case PJNATH_ESTUNTIMEDOUT:
/*
* Strangely test 1B has failed. Maybe connectivity was
* lost? Or perhaps port 3489 (the usual port number in
* CHANGED-ADDRESS) is blocked?
*/
switch (sess->result[ST_TEST_3].status) {
case PJ_SUCCESS:
/* Although test 1B failed, test 3 was successful.
* It could be that port 3489 is blocked, while the
* NAT itself looks to be a Restricted one.
*/
end_session(sess, PJ_SUCCESS,
PJ_STUN_NAT_TYPE_RESTRICTED);
break;
default:
/* Can't distinguish between Symmetric and Port
* Restricted, so set the type to Unknown
*/
end_session(sess, PJ_SUCCESS,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
break;
default:
/*
* Got other error with test 1B.
*/
end_session(sess, sess->result[ST_TEST_1B].status,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
break;
default:
/*
* We've got other error with Test 2.
*/
end_session(sess, sess->result[ST_TEST_2].status,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
}
break;
default:
/*
* We've got other error with Test 1.
*/
end_session(sess, sess->result[ST_TEST_1].status,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
on_return:
pj_grp_lock_release(sess->grp_lock);
}
/* Callback from active socket when incoming packet is received */
static pj_bool_t 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)
{
pj_stun_sock *stun_sock;
pj_stun_msg_hdr *hdr;
pj_uint16_t type;
stun_sock = (pj_stun_sock*) pj_activesock_get_user_data(asock);
/* Log socket error */
if (status != PJ_SUCCESS) {
PJ_PERROR(2,(stun_sock->obj_name, status, "recvfrom() error"));
return PJ_TRUE;
}
/* Check that this is STUN message */
status = pj_stun_msg_check((const pj_uint8_t*)data, size,
PJ_STUN_IS_DATAGRAM | PJ_STUN_CHECK_PACKET);
if (status != PJ_SUCCESS) {
/* Not STUN -- give it to application */
goto process_app_data;
}
/* Treat packet as STUN header and copy the STUN message type.
* We don't want to access the type directly from the header
* since it may not be properly aligned.
*/
hdr = (pj_stun_msg_hdr*) data;
pj_memcpy(&type, &hdr->type, 2);
type = pj_ntohs(type);
/* If the packet is a STUN Binding response and part of the
* transaction ID matches our internal ID, then this is
* our internal STUN message (Binding request or keep alive).
* Give it to our STUN session.
*/
if (!PJ_STUN_IS_RESPONSE(type) ||
PJ_STUN_GET_METHOD(type) != PJ_STUN_BINDING_METHOD ||
pj_memcmp(hdr->tsx_id, stun_sock->tsx_id, 10) != 0)
{
/* Not STUN Binding response, or STUN transaction ID mismatch.
* This is not our message too -- give it to application.
*/
goto process_app_data;
}
/* This is our STUN Binding response. Give it to the STUN session */
status = pj_stun_session_on_rx_pkt(stun_sock->stun_sess, data, size,
PJ_STUN_IS_DATAGRAM, NULL, NULL,
src_addr, addr_len);
return status!=PJNATH_ESTUNDESTROYED ? PJ_TRUE : PJ_FALSE;
process_app_data:
if (stun_sock->cb.on_rx_data) {
pj_bool_t ret;
ret = (*stun_sock->cb.on_rx_data)(stun_sock, data, size,
src_addr, addr_len);
return ret;
}
return PJ_TRUE;
}
static int send_recv_test(pj_ioqueue_t *ioque,
pj_ioqueue_key_t *skey,
pj_ioqueue_key_t *ckey,
void *send_buf,
void *recv_buf,
pj_ssize_t bufsize,
pj_timestamp *t_elapsed)
{
pj_status_t status;
pj_ssize_t bytes;
pj_time_val timeout;
pj_timestamp t1, t2;
int pending_op = 0;
pj_ioqueue_op_key_t read_op, write_op;
// Start reading on the server side.
bytes = bufsize;
status = pj_ioqueue_recv(skey, &read_op, recv_buf, &bytes, 0);
if (status != PJ_SUCCESS && status != PJ_EPENDING) {
app_perror("...pj_ioqueue_recv error", status);
return -100;
}
if (status == PJ_EPENDING)
++pending_op;
else {
/* Does not expect to return error or immediate data. */
return -115;
}
// Randomize send buffer.
pj_create_random_string((char*)send_buf, bufsize);
// Starts send on the client side.
bytes = bufsize;
status = pj_ioqueue_send(ckey, &write_op, send_buf, &bytes, 0);
if (status != PJ_SUCCESS && bytes != PJ_EPENDING) {
return -120;
}
if (status == PJ_EPENDING) {
++pending_op;
}
// Begin time.
pj_get_timestamp(&t1);
// Reset indicators
callback_read_size = callback_write_size = 0;
callback_read_key = callback_write_key = NULL;
callback_read_op = callback_write_op = NULL;
// Poll the queue until we've got completion event in the server side.
status = 0;
while (pending_op > 0) {
timeout.sec = 1; timeout.msec = 0;
#ifdef PJ_SYMBIAN
PJ_UNUSED_ARG(ioque);
status = pj_symbianos_poll(-1, 1000);
#else
status = pj_ioqueue_poll(ioque, &timeout);
#endif
if (status > 0) {
if (callback_read_size) {
if (callback_read_size != bufsize)
return -160;
if (callback_read_key != skey)
return -161;
if (callback_read_op != &read_op)
return -162;
}
if (callback_write_size) {
if (callback_write_key != ckey)
return -163;
if (callback_write_op != &write_op)
return -164;
}
pending_op -= status;
}
if (status == 0) {
PJ_LOG(3,("", "...error: timed out"));
}
if (status < 0) {
return -170;
}
}
// Pending op is zero.
// Subsequent poll should yield zero too.
timeout.sec = timeout.msec = 0;
#ifdef PJ_SYMBIAN
status = pj_symbianos_poll(-1, 1);
#else
status = pj_ioqueue_poll(ioque, &timeout);
#endif
if (status != 0)
return -173;
// End time.
pj_get_timestamp(&t2);
t_elapsed->u32.lo += (t2.u32.lo - t1.u32.lo);
// Compare recv buffer with send buffer.
if (pj_memcmp(send_buf, recv_buf, bufsize) != 0) {
return -180;
}
// Success
return 0;
}
static int format_test(void)
{
pj_str_t s = pj_str(ADDRESS);
unsigned char *p;
pj_in_addr addr;
char zero[64];
pj_sockaddr_in addr2;
const pj_str_t *hostname;
const unsigned char A[] = {127, 0, 0, 1};
PJ_LOG(3,("test", "...format_test()"));
/* pj_inet_aton() */
if (pj_inet_aton(&s, &addr) != 1)
return -10;
/* Check the result. */
p = (unsigned char*)&addr;
if (p[0]!=A[0] || p[1]!=A[1] || p[2]!=A[2] || p[3]!=A[3]) {
PJ_LOG(3,("test", " error: mismatched address. p0=%d, p1=%d, "
"p2=%d, p3=%d", p[0] & 0xFF, p[1] & 0xFF,
p[2] & 0xFF, p[3] & 0xFF));
return -15;
}
/* pj_inet_ntoa() */
p = (unsigned char*) pj_inet_ntoa(addr);
if (!p)
return -20;
if (pj_strcmp2(&s, (char*)p) != 0)
return -22;
#if defined(PJ_HAS_IPV6) && PJ_HAS_IPV6!=0
/* pj_inet_pton() */
/* pj_inet_ntop() */
{
const pj_str_t s_ipv4 = pj_str("127.0.0.1");
const pj_str_t s_ipv6 = pj_str("fe80::2ff:83ff:fe7c:8b42");
char buf_ipv4[PJ_INET_ADDRSTRLEN];
char buf_ipv6[PJ_INET6_ADDRSTRLEN];
pj_in_addr ipv4;
pj_in6_addr ipv6;
if (pj_inet_pton(pj_AF_INET(), &s_ipv4, &ipv4) != PJ_SUCCESS)
return -24;
p = (unsigned char*)&ipv4;
if (p[0]!=A[0] || p[1]!=A[1] || p[2]!=A[2] || p[3]!=A[3]) {
return -25;
}
if (pj_inet_pton(pj_AF_INET6(), &s_ipv6, &ipv6) != PJ_SUCCESS)
return -26;
p = (unsigned char*)&ipv6;
if (p[0] != 0xfe || p[1] != 0x80 || p[2] != 0 || p[3] != 0 ||
p[4] != 0 || p[5] != 0 || p[6] != 0 || p[7] != 0 ||
p[8] != 0x02 || p[9] != 0xff || p[10] != 0x83 || p[11] != 0xff ||
p[12]!=0xfe || p[13]!=0x7c || p[14] != 0x8b || p[15]!=0x42)
{
return -27;
}
if (pj_inet_ntop(pj_AF_INET(), &ipv4, buf_ipv4, sizeof(buf_ipv4)) != PJ_SUCCESS)
return -28;
if (pj_stricmp2(&s_ipv4, buf_ipv4) != 0)
return -29;
if (pj_inet_ntop(pj_AF_INET6(), &ipv6, buf_ipv6, sizeof(buf_ipv6)) != PJ_SUCCESS)
return -30;
if (pj_stricmp2(&s_ipv6, buf_ipv6) != 0)
return -31;
}
#endif /* PJ_HAS_IPV6 */
/* Test that pj_sockaddr_in_init() initialize the whole structure,
* including sin_zero.
*/
pj_sockaddr_in_init(&addr2, 0, 1000);
pj_bzero(zero, sizeof(zero));
if (pj_memcmp(addr2.sin_zero, zero, sizeof(addr2.sin_zero)) != 0)
return -35;
/* pj_gethostname() */
hostname = pj_gethostname();
if (!hostname || !hostname->ptr || !hostname->slen)
return -40;
PJ_LOG(3,("test", "....hostname is %.*s",
(int)hostname->slen, hostname->ptr));
/* pj_gethostaddr() */
return 0;
}
static int send_recv_test(int sock_type,
pj_sock_t ss, pj_sock_t cs,
pj_sockaddr_in *dstaddr, pj_sockaddr_in *srcaddr,
int addrlen)
{
enum { DATA_LEN = 16 };
char senddata[DATA_LEN+4], recvdata[DATA_LEN+4];
pj_ssize_t sent, received, total_received;
pj_status_t rc;
TRACE_(("test", "....create_random_string()"));
pj_create_random_string(senddata, DATA_LEN);
senddata[DATA_LEN-1] = '\0';
/*
* Test send/recv small data.
*/
TRACE_(("test", "....sendto()"));
if (dstaddr) {
sent = DATA_LEN;
rc = pj_sock_sendto(cs, senddata, &sent, 0, dstaddr, addrlen);
if (rc != PJ_SUCCESS || sent != DATA_LEN) {
app_perror("...sendto error", rc);
rc = -140; goto on_error;
}
} else {
sent = DATA_LEN;
rc = pj_sock_send(cs, senddata, &sent, 0);
if (rc != PJ_SUCCESS || sent != DATA_LEN) {
app_perror("...send error", rc);
rc = -145; goto on_error;
}
}
TRACE_(("test", "....recv()"));
if (srcaddr) {
pj_sockaddr_in addr;
int srclen = sizeof(addr);
pj_bzero(&addr, sizeof(addr));
received = DATA_LEN;
rc = pj_sock_recvfrom(ss, recvdata, &received, 0, &addr, &srclen);
if (rc != PJ_SUCCESS || received != DATA_LEN) {
app_perror("...recvfrom error", rc);
rc = -150; goto on_error;
}
if (srclen != addrlen)
return -151;
if (pj_sockaddr_cmp(&addr, srcaddr) != 0) {
char srcaddr_str[32], addr_str[32];
strcpy(srcaddr_str, pj_inet_ntoa(srcaddr->sin_addr));
strcpy(addr_str, pj_inet_ntoa(addr.sin_addr));
PJ_LOG(3,("test", "...error: src address mismatch (original=%s, "
"recvfrom addr=%s)",
srcaddr_str, addr_str));
return -152;
}
} else {
/* Repeat recv() until all data is received.
* This applies only for non-UDP of course, since for UDP
* we would expect all data to be received in one packet.
*/
total_received = 0;
do {
received = DATA_LEN-total_received;
rc = pj_sock_recv(ss, recvdata+total_received, &received, 0);
if (rc != PJ_SUCCESS) {
app_perror("...recv error", rc);
rc = -155; goto on_error;
}
if (received <= 0) {
PJ_LOG(3,("", "...error: socket has closed! (received=%d)",
received));
rc = -156; goto on_error;
}
if (received != DATA_LEN-total_received) {
if (sock_type != pj_SOCK_STREAM()) {
PJ_LOG(3,("", "...error: expecting %u bytes, got %u bytes",
DATA_LEN-total_received, received));
rc = -157; goto on_error;
}
}
total_received += received;
} while (total_received < DATA_LEN);
}
TRACE_(("test", "....memcmp()"));
if (pj_memcmp(senddata, recvdata, DATA_LEN) != 0) {
PJ_LOG(3,("","...error: received data mismatch "
"(got:'%s' expecting:'%s'",
recvdata, senddata));
rc = -160; goto on_error;
}
/*
* Test send/recv big data.
*/
TRACE_(("test", "....sendto()"));
if (dstaddr) {
sent = BIG_DATA_LEN;
rc = pj_sock_sendto(cs, bigdata, &sent, 0, dstaddr, addrlen);
if (rc != PJ_SUCCESS || sent != BIG_DATA_LEN) {
app_perror("...sendto error", rc);
rc = -161; goto on_error;
}
} else {
sent = BIG_DATA_LEN;
rc = pj_sock_send(cs, bigdata, &sent, 0);
if (rc != PJ_SUCCESS || sent != BIG_DATA_LEN) {
app_perror("...send error", rc);
rc = -165; goto on_error;
}
}
TRACE_(("test", "....recv()"));
/* Repeat recv() until all data is received.
* This applies only for non-UDP of course, since for UDP
* we would expect all data to be received in one packet.
*/
total_received = 0;
do {
received = BIG_DATA_LEN-total_received;
rc = pj_sock_recv(ss, bigbuffer+total_received, &received, 0);
if (rc != PJ_SUCCESS) {
app_perror("...recv error", rc);
rc = -170; goto on_error;
}
if (received <= 0) {
PJ_LOG(3,("", "...error: socket has closed! (received=%d)",
received));
rc = -173; goto on_error;
}
if (received != BIG_DATA_LEN-total_received) {
if (sock_type != pj_SOCK_STREAM()) {
PJ_LOG(3,("", "...error: expecting %u bytes, got %u bytes",
BIG_DATA_LEN-total_received, received));
rc = -176; goto on_error;
}
}
total_received += received;
} while (total_received < BIG_DATA_LEN);
TRACE_(("test", "....memcmp()"));
if (pj_memcmp(bigdata, bigbuffer, BIG_DATA_LEN) != 0) {
PJ_LOG(3,("", "...error: received data has been altered!"));
rc = -180; goto on_error;
}
rc = 0;
on_error:
return rc;
}
static int file_test_internal(void)
{
enum { FILE_MAX_AGE = 1000 };
pj_oshandle_t fd = 0;
pj_status_t status;
char readbuf[sizeof(buffer)+16];
pj_file_stat stat;
pj_time_val start_time;
pj_ssize_t size;
pj_off_t pos;
PJ_LOG(3,("", "..file io test.."));
/* Get time. */
pj_gettimeofday(&start_time);
/* Delete original file if exists. */
if (pj_file_exists(FILENAME))
pj_file_delete(FILENAME);
/*
* Write data to the file.
*/
status = pj_file_open(NULL, FILENAME, PJ_O_WRONLY, &fd);
if (status != PJ_SUCCESS) {
app_perror("...file_open() error", status);
return -10;
}
size = sizeof(buffer);
status = pj_file_write(fd, buffer, &size);
if (status != PJ_SUCCESS) {
app_perror("...file_write() error", status);
pj_file_close(fd);
return -20;
}
if (size != sizeof(buffer))
return -25;
status = pj_file_close(fd);
if (status != PJ_SUCCESS) {
app_perror("...file_close() error", status);
return -30;
}
/* Check the file existance and size. */
if (!pj_file_exists(FILENAME))
return -40;
if (pj_file_size(FILENAME) != sizeof(buffer))
return -50;
/* Get file stat. */
status = pj_file_getstat(FILENAME, &stat);
if (status != PJ_SUCCESS)
return -60;
/* Check stat size. */
if (stat.size != sizeof(buffer))
return -70;
#if INCLUDE_FILE_TIME_TEST
/* Check file creation time >= start_time. */
if (!PJ_TIME_VAL_GTE(stat.ctime, start_time))
return -80;
/* Check file creation time is not much later. */
PJ_TIME_VAL_SUB(stat.ctime, start_time);
if (stat.ctime.sec > FILE_MAX_AGE)
return -90;
/* Check file modification time >= start_time. */
if (!PJ_TIME_VAL_GTE(stat.mtime, start_time))
return -80;
/* Check file modification time is not much later. */
PJ_TIME_VAL_SUB(stat.mtime, start_time);
if (stat.mtime.sec > FILE_MAX_AGE)
return -90;
/* Check file access time >= start_time. */
if (!PJ_TIME_VAL_GTE(stat.atime, start_time))
return -80;
/* Check file access time is not much later. */
PJ_TIME_VAL_SUB(stat.atime, start_time);
if (stat.atime.sec > FILE_MAX_AGE)
return -90;
#endif
/*
* Re-open the file and read data.
*/
status = pj_file_open(NULL, FILENAME, PJ_O_RDONLY, &fd);
if (status != PJ_SUCCESS) {
app_perror("...file_open() error", status);
return -100;
}
size = 0;
while (size < (pj_ssize_t)sizeof(readbuf)) {
pj_ssize_t read;
read = 1;
status = pj_file_read(fd, &readbuf[size], &read);
if (status != PJ_SUCCESS) {
PJ_LOG(3,("", "...error reading file after %d bytes (error follows)",
size));
app_perror("...error", status);
return -110;
}
if (read == 0) {
// EOF
break;
}
size += read;
}
if (size != sizeof(buffer))
return -120;
/*
if (!pj_file_eof(fd, PJ_O_RDONLY))
return -130;
*/
if (pj_memcmp(readbuf, buffer, size) != 0)
return -140;
/* Seek test. */
status = pj_file_setpos(fd, 4, PJ_SEEK_SET);
if (status != PJ_SUCCESS) {
app_perror("...file_setpos() error", status);
return -141;
}
/* getpos test. */
status = pj_file_getpos(fd, &pos);
if (status != PJ_SUCCESS) {
app_perror("...file_getpos() error", status);
return -142;
}
if (pos != 4)
return -143;
status = pj_file_close(fd);
if (status != PJ_SUCCESS) {
app_perror("...file_close() error", status);
return -150;
}
/*
* Rename test.
*/
status = pj_file_move(FILENAME, NEWNAME);
if (status != PJ_SUCCESS) {
app_perror("...file_move() error", status);
return -160;
}
if (pj_file_exists(FILENAME))
return -170;
if (!pj_file_exists(NEWNAME))
return -180;
if (pj_file_size(NEWNAME) != sizeof(buffer))
return -190;
/* Delete test. */
status = pj_file_delete(NEWNAME);
if (status != PJ_SUCCESS) {
app_perror("...file_delete() error", status);
return -200;
}
if (pj_file_exists(NEWNAME))
return -210;
PJ_LOG(3,("", "...success"));
return PJ_SUCCESS;
}
static int format_test(void)
{
pj_str_t s = pj_str(ADDRESS);
unsigned char *p;
pj_in_addr addr;
char zero[64];
pj_sockaddr_in addr2;
const pj_str_t *hostname;
const unsigned char A[] = {127, 0, 0, 1};
PJ_LOG(3,("test", "...format_test()"));
/* pj_inet_aton() */
if (pj_inet_aton(&s, &addr) != 1)
return -10;
/* Check the result. */
p = (unsigned char*)&addr;
if (p[0]!=A[0] || p[1]!=A[1] || p[2]!=A[2] || p[3]!=A[3]) {
PJ_LOG(3,("test", " error: mismatched address. p0=%d, p1=%d, "
"p2=%d, p3=%d", p[0] & 0xFF, p[1] & 0xFF,
p[2] & 0xFF, p[3] & 0xFF));
return -15;
}
/* pj_inet_ntoa() */
p = (unsigned char*) pj_inet_ntoa(addr);
if (!p)
return -20;
if (pj_strcmp2(&s, (char*)p) != 0)
return -22;
#if defined(PJ_HAS_IPV6) && PJ_HAS_IPV6!=0
/* pj_inet_pton() */
/* pj_inet_ntop() */
{
const pj_str_t s_ipv4 = pj_str("127.0.0.1");
const pj_str_t s_ipv6 = pj_str("fe80::2ff:83ff:fe7c:8b42");
char buf_ipv4[PJ_INET_ADDRSTRLEN];
char buf_ipv6[PJ_INET6_ADDRSTRLEN];
pj_in_addr ipv4;
pj_in6_addr ipv6;
if (pj_inet_pton(pj_AF_INET(), &s_ipv4, &ipv4) != PJ_SUCCESS)
return -24;
p = (unsigned char*)&ipv4;
if (p[0]!=A[0] || p[1]!=A[1] || p[2]!=A[2] || p[3]!=A[3]) {
return -25;
}
if (pj_inet_pton(pj_AF_INET6(), &s_ipv6, &ipv6) != PJ_SUCCESS)
return -26;
p = (unsigned char*)&ipv6;
if (p[0] != 0xfe || p[1] != 0x80 || p[2] != 0 || p[3] != 0 ||
p[4] != 0 || p[5] != 0 || p[6] != 0 || p[7] != 0 ||
p[8] != 0x02 || p[9] != 0xff || p[10] != 0x83 || p[11] != 0xff ||
p[12]!=0xfe || p[13]!=0x7c || p[14] != 0x8b || p[15]!=0x42)
{
return -27;
}
if (pj_inet_ntop(pj_AF_INET(), &ipv4, buf_ipv4, sizeof(buf_ipv4)) != PJ_SUCCESS)
return -28;
if (pj_stricmp2(&s_ipv4, buf_ipv4) != 0)
return -29;
if (pj_inet_ntop(pj_AF_INET6(), &ipv6, buf_ipv6, sizeof(buf_ipv6)) != PJ_SUCCESS)
return -30;
if (pj_stricmp2(&s_ipv6, buf_ipv6) != 0)
return -31;
}
#endif /* PJ_HAS_IPV6 */
/* Test that pj_sockaddr_in_init() initialize the whole structure,
* including sin_zero.
*/
pj_sockaddr_in_init(&addr2, 0, 1000);
pj_bzero(zero, sizeof(zero));
if (pj_memcmp(addr2.sin_zero, zero, sizeof(addr2.sin_zero)) != 0)
return -35;
/* pj_gethostname() */
hostname = pj_gethostname();
if (!hostname || !hostname->ptr || !hostname->slen)
return -40;
PJ_LOG(3,("test", "....hostname is %.*s",
(int)hostname->slen, hostname->ptr));
/* pj_gethostaddr() */
/* Various constants */
#if !defined(PJ_SYMBIAN) || PJ_SYMBIAN==0
if (PJ_AF_INET==0xFFFF) return -5500;
if (PJ_AF_INET6==0xFFFF) return -5501;
/* 0xFFFF could be a valid SOL_SOCKET (e.g: on some Win or Mac) */
//if (PJ_SOL_SOCKET==0xFFFF) return -5503;
if (PJ_SOL_IP==0xFFFF) return -5502;
if (PJ_SOL_TCP==0xFFFF) return -5510;
if (PJ_SOL_UDP==0xFFFF) return -5520;
if (PJ_SOL_IPV6==0xFFFF) return -5530;
if (PJ_SO_TYPE==0xFFFF) return -5540;
if (PJ_SO_RCVBUF==0xFFFF) return -5550;
if (PJ_SO_SNDBUF==0xFFFF) return -5560;
if (PJ_TCP_NODELAY==0xFFFF) return -5570;
if (PJ_SO_REUSEADDR==0xFFFF) return -5580;
if (PJ_MSG_OOB==0xFFFF) return -5590;
if (PJ_MSG_PEEK==0xFFFF) return -5600;
#endif
return 0;
}
