On Thu, Sep 25, 2008 at 10:31 PM, Tom?? Valenta <vali at kamarad.cz> wrote: > Hello, > I would like to report an error in file sock_bsd.c version 1.0 rc3. On > lines 114--122 all constants should start with upper case PJ_IP_... If they > do not, build errors occur if building pjlib as DLL using Visual Studio. See > attached patched file. > Yep, I've registered this with this ticket http://trac.pjsip.org/repos/ticket/644. Will fix that asap! Thanks Benny > Cheers > Vali > > /* $Id: sock_bsd.c 2283 2008-09-16 16:11:44Z nanang $ */ > /* > * Copyright (C)2003-2008 Benny Prijono <benny at prijono.org> > * > * This program is free software; you can redistribute it and/or modify > * it under the terms of the GNU General Public License as published by > * the Free Software Foundation; either version 2 of the License, or > * (at your option) any later version. > * > * This program is distributed in the hope that it will be useful, > * but WITHOUT ANY WARRANTY; without even the implied warranty of > * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > * GNU General Public License for more details. > * > * You should have received a copy of the GNU General Public License > * along with this program; if not, write to the Free Software > * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 > USA > */ > #include <pj/sock.h> > #include <pj/os.h> > #include <pj/assert.h> > #include <pj/string.h> > #include <pj/compat/socket.h> > #include <pj/addr_resolv.h> > #include <pj/errno.h> > #include <pj/unicode.h> > > /* > * Address families conversion. > * The values here are indexed based on pj_addr_family. > */ > const pj_uint16_t PJ_AF_UNSPEC = AF_UNSPEC; > const pj_uint16_t PJ_AF_UNIX = AF_UNIX; > const pj_uint16_t PJ_AF_INET = AF_INET; > const pj_uint16_t PJ_AF_INET6 = AF_INET6; > #ifdef AF_PACKET > const pj_uint16_t PJ_AF_PACKET = AF_PACKET; > #else > const pj_uint16_t PJ_AF_PACKET = 0xFFFF; > #endif > #ifdef AF_IRDA > const pj_uint16_t PJ_AF_IRDA = AF_IRDA; > #else > const pj_uint16_t PJ_AF_IRDA = 0xFFFF; > #endif > > /* > * Socket types conversion. > * The values here are indexed based on pj_sock_type > */ > const pj_uint16_t PJ_SOCK_STREAM= SOCK_STREAM; > const pj_uint16_t PJ_SOCK_DGRAM = SOCK_DGRAM; > const pj_uint16_t PJ_SOCK_RAW = SOCK_RAW; > const pj_uint16_t PJ_SOCK_RDM = SOCK_RDM; > > /* > * Socket level values. > */ > const pj_uint16_t PJ_SOL_SOCKET = SOL_SOCKET; > #ifdef SOL_IP > const pj_uint16_t PJ_SOL_IP = SOL_IP; > #else > const pj_uint16_t PJ_SOL_IP = 0xFFFF; > #endif /* SOL_IP */ > #if defined(SOL_TCP) > const pj_uint16_t PJ_SOL_TCP = SOL_TCP; > #elif defined(IPPROTO_TCP) > const pj_uint16_t PJ_SOL_TCP = IPPROTO_TCP; > #else > const pj_uint16_t PJ_SOL_TCP = 0xFFFF; > #endif /* SOL_TCP */ > #ifdef SOL_UDP > const pj_uint16_t PJ_SOL_UDP = SOL_UDP; > #else > const pj_uint16_t PJ_SOL_UDP = 0xFFFF; > #endif > #ifdef SOL_IPV6 > const pj_uint16_t PJ_SOL_IPV6 = SOL_IPV6; > #else > const pj_uint16_t PJ_SOL_IPV6 = 0xFFFF; > #endif > > /* IP_TOS */ > #ifdef IP_TOS > const pj_uint16_t PJ_IP_TOS = IP_TOS; > #else > const pj_uint16_t PJ_IP_TOS = 1; > #endif > > > /* TOS settings (declared in netinet/ip.h) */ > #ifdef IPTOS_LOWDELAY > const pj_uint16_t PJ_IPTOS_LOWDELAY = IPTOS_LOWDELAY; > #else > const pj_uint16_t PJ_IPTOS_LOWDELAY = 0x10; > #endif > #ifdef IPTOS_THROUGHPUT > const pj_uint16_t PJ_IPTOS_THROUGHPUT = IPTOS_THROUGHPUT; > #else > const pj_uint16_t PJ_IPTOS_THROUGHPUT = 0x08; > #endif > #ifdef IPTOS_RELIABILITY > const pj_uint16_t PJ_IPTOS_RELIABILITY = IPTOS_RELIABILITY; > #else > const pj_uint16_t PJ_IPTOS_RELIABILITY = 0x04; > #endif > #ifdef IPTOS_MINCOST > const pj_uint16_t PJ_IPTOS_MINCOST = IPTOS_MINCOST; > #else > const pj_uint16_t PJ_IPTOS_MINCOST = 0x02; > #endif > > > /* optname values. */ > const pj_uint16_t PJ_SO_TYPE = SO_TYPE; > const pj_uint16_t PJ_SO_RCVBUF = SO_RCVBUF; > const pj_uint16_t PJ_SO_SNDBUF = SO_SNDBUF; > const pj_uint16_t PJ_IP_MULTICAST_IF = IP_MULTICAST_IF; > const pj_uint16_t PJ_IP_MULTICAST_TTL = IP_MULTICAST_TTL; > const pj_uint16_t PJ_IP_MULTICAST_LOOP = IP_MULTICAST_LOOP; > const pj_uint16_t PJ_IP_ADD_MEMBERSHIP = IP_ADD_MEMBERSHIP; > const pj_uint16_t PJ_IP_DROP_MEMBERSHIP = IP_DROP_MEMBERSHIP; > > > /* recv() and send() flags */ > const int PJ_MSG_OOB = MSG_OOB; > const int PJ_MSG_PEEK = MSG_PEEK; > const int PJ_MSG_DONTROUTE = MSG_DONTROUTE; > > > #if 0 > static void CHECK_ADDR_LEN(const pj_sockaddr *addr, int len) > { > pj_sockaddr *a = (pj_sockaddr*)addr; > pj_assert((a->addr.sa_family==PJ_AF_INET && len==sizeof(pj_sockaddr_in)) > || > (a->addr.sa_family==PJ_AF_INET6 && > len==sizeof(pj_sockaddr_in6))); > > } > #else > #define CHECK_ADDR_LEN(addr,len) > #endif > > /* > * Convert 16-bit value from network byte order to host byte order. > */ > PJ_DEF(pj_uint16_t) pj_ntohs(pj_uint16_t netshort) > { > return ntohs(netshort); > } > > /* > * Convert 16-bit value from host byte order to network byte order. > */ > PJ_DEF(pj_uint16_t) pj_htons(pj_uint16_t hostshort) > { > return htons(hostshort); > } > > /* > * Convert 32-bit value from network byte order to host byte order. > */ > PJ_DEF(pj_uint32_t) pj_ntohl(pj_uint32_t netlong) > { > return ntohl(netlong); > } > > /* > * Convert 32-bit value from host byte order to network byte order. > */ > PJ_DEF(pj_uint32_t) pj_htonl(pj_uint32_t hostlong) > { > return htonl(hostlong); > } > > /* > * Convert an Internet host address given in network byte order > * to string in standard numbers and dots notation. > */ > PJ_DEF(char*) pj_inet_ntoa(pj_in_addr inaddr) > { > #if !defined(PJ_LINUX) && !defined(PJ_LINUX_KERNEL) > return inet_ntoa(*(struct in_addr*)&inaddr); > #else > struct in_addr addr; > addr.s_addr = inaddr.s_addr; > return inet_ntoa(addr); > #endif > } > > /* > * This function converts the Internet host address cp from the standard > * numbers-and-dots notation into binary data and stores it in the > structure > * that inp points to. > */ > PJ_DEF(int) pj_inet_aton(const pj_str_t *cp, struct pj_in_addr *inp) > { > char tempaddr[PJ_INET_ADDRSTRLEN]; > > /* Initialize output with PJ_INADDR_NONE. > * Some apps relies on this instead of the return value > * (and anyway the return value is quite confusing!) > */ > inp->s_addr = PJ_INADDR_NONE; > > /* Caution: > * this function might be called with cp->slen >= 16 > * (i.e. when called with hostname to check if it's an IP addr). > */ > PJ_ASSERT_RETURN(cp && cp->slen && inp, 0); > if (cp->slen >= PJ_INET_ADDRSTRLEN) { > return 0; > } > > pj_memcpy(tempaddr, cp->ptr, cp->slen); > tempaddr[cp->slen] = '\0'; > > #if defined(PJ_SOCK_HAS_INET_ATON) && PJ_SOCK_HAS_INET_ATON != 0 > return inet_aton(tempaddr, (struct in_addr*)inp); > #else > inp->s_addr = inet_addr(tempaddr); > return inp->s_addr == PJ_INADDR_NONE ? 0 : 1; > #endif > } > > /* > * Convert text to IPv4/IPv6 address. > */ > PJ_DEF(pj_status_t) pj_inet_pton(int af, const pj_str_t *src, void *dst) > { > char tempaddr[PJ_INET6_ADDRSTRLEN]; > > PJ_ASSERT_RETURN(af==PJ_AF_INET || af==PJ_AF_INET6, PJ_EAFNOTSUP); > PJ_ASSERT_RETURN(src && src->slen && dst, PJ_EINVAL); > > /* Initialize output with PJ_IN_ADDR_NONE for IPv4 (to be > * compatible with pj_inet_aton() > */ > if (af==PJ_AF_INET) { > ((pj_in_addr*)dst)->s_addr = PJ_INADDR_NONE; > } > > /* Caution: > * this function might be called with cp->slen >= 46 > * (i.e. when called with hostname to check if it's an IP addr). > */ > if (src->slen >= PJ_INET6_ADDRSTRLEN) { > return PJ_ENAMETOOLONG; > } > > pj_memcpy(tempaddr, src->ptr, src->slen); > tempaddr[src->slen] = '\0'; > > #if defined(PJ_SOCK_HAS_INET_PTON) && PJ_SOCK_HAS_INET_PTON != 0 > /* > * Implementation using inet_pton() > */ > if (inet_pton(af, tempaddr, dst) != 1) { > pj_status_t status = pj_get_netos_error(); > if (status == PJ_SUCCESS) > status = PJ_EUNKNOWN; > > return status; > } > > return PJ_SUCCESS; > > #elif defined(PJ_WIN32) || defined(PJ_WIN32_WINCE) > /* > * Implementation on Windows, using WSAStringToAddress(). > * Should also work on Unicode systems. > */ > { > PJ_DECL_UNICODE_TEMP_BUF(wtempaddr,PJ_INET6_ADDRSTRLEN) > pj_sockaddr sock_addr; > int addr_len = sizeof(sock_addr); > int rc; > > sock_addr.addr.sa_family = (pj_uint16_t)af; > rc = WSAStringToAddress( > PJ_STRING_TO_NATIVE(tempaddr,wtempaddr,sizeof(wtempaddr)), > af, NULL, (LPSOCKADDR)&sock_addr, &addr_len); > if (rc != 0) { > pj_status_t status = pj_get_netos_error(); > if (status == PJ_SUCCESS) > status = PJ_EUNKNOWN; > > return status; > } > > if (sock_addr.addr.sa_family == PJ_AF_INET) { > pj_memcpy(dst, &sock_addr.ipv4.sin_addr, 4); > return PJ_SUCCESS; > } else if (sock_addr.addr.sa_family == PJ_AF_INET6) { > pj_memcpy(dst, &sock_addr.ipv6.sin6_addr, 16); > return PJ_SUCCESS; > } else { > pj_assert(!"Shouldn't happen"); > return PJ_EBUG; > } > } > #elif !defined(PJ_HAS_IPV6) || PJ_HAS_IPV6==0 > /* IPv6 support is disabled, just return error without raising assertion > */ > return PJ_EIPV6NOTSUP; > #else > pj_assert(!"Not supported"); > return PJ_EIPV6NOTSUP; > #endif > } > > /* > * Convert IPv4/IPv6 address to text. > */ > PJ_DEF(pj_status_t) pj_inet_ntop(int af, const void *src, > char *dst, int size) > > { > PJ_ASSERT_RETURN(src && dst && size, PJ_EINVAL); > > *dst = '\0'; > > PJ_ASSERT_RETURN(af==PJ_AF_INET || af==PJ_AF_INET6, PJ_EAFNOTSUP); > > #if defined(PJ_SOCK_HAS_INET_NTOP) && PJ_SOCK_HAS_INET_NTOP != 0 > /* > * Implementation using inet_ntop() > */ > if (inet_ntop(af, src, dst, size) == NULL) { > pj_status_t status = pj_get_netos_error(); > if (status == PJ_SUCCESS) > status = PJ_EUNKNOWN; > > return status; > } > > return PJ_SUCCESS; > > #elif defined(PJ_WIN32) || defined(PJ_WIN32_WINCE) > /* > * Implementation on Windows, using WSAAddressToString(). > * Should also work on Unicode systems. > */ > { > PJ_DECL_UNICODE_TEMP_BUF(wtempaddr,PJ_INET6_ADDRSTRLEN) > pj_sockaddr sock_addr; > DWORD addr_len, addr_str_len; > int rc; > > pj_bzero(&sock_addr, sizeof(sock_addr)); > sock_addr.addr.sa_family = (pj_uint16_t)af; > if (af == PJ_AF_INET) { > if (size < PJ_INET_ADDRSTRLEN) > return PJ_ETOOSMALL; > pj_memcpy(&sock_addr.ipv4.sin_addr, src, 4); > addr_len = sizeof(pj_sockaddr_in); > addr_str_len = PJ_INET_ADDRSTRLEN; > } else if (af == PJ_AF_INET6) { > if (size < PJ_INET6_ADDRSTRLEN) > return PJ_ETOOSMALL; > pj_memcpy(&sock_addr.ipv6.sin6_addr, src, 16); > addr_len = sizeof(pj_sockaddr_in6); > addr_str_len = PJ_INET6_ADDRSTRLEN; > } else { > pj_assert(!"Unsupported address family"); > return PJ_EAFNOTSUP; > } > > #if PJ_NATIVE_STRING_IS_UNICODE > rc = WSAAddressToString((LPSOCKADDR)&sock_addr, addr_len, > NULL, wtempaddr, &addr_str_len); > if (rc == 0) { > pj_unicode_to_ansi(wtempaddr, wcslen(wtempaddr), dst, size); > } > #else > rc = WSAAddressToString((LPSOCKADDR)&sock_addr, addr_len, > NULL, dst, &addr_str_len); > #endif > > if (rc != 0) { > pj_status_t status = pj_get_netos_error(); > if (status == PJ_SUCCESS) > status = PJ_EUNKNOWN; > > return status; > } > > return PJ_SUCCESS; > } > > #elif !defined(PJ_HAS_IPV6) || PJ_HAS_IPV6==0 > /* IPv6 support is disabled, just return error without raising assertion > */ > return PJ_EIPV6NOTSUP; > #else > pj_assert(!"Not supported"); > return PJ_EIPV6NOTSUP; > #endif > } > > /* > * Get hostname. > */ > PJ_DEF(const pj_str_t*) pj_gethostname(void) > { > static char buf[PJ_MAX_HOSTNAME]; > static pj_str_t hostname; > > PJ_CHECK_STACK(); > > if (hostname.ptr == NULL) { > hostname.ptr = buf; > if (gethostname(buf, sizeof(buf)) != 0) { > hostname.ptr[0] = '\0'; > hostname.slen = 0; > } else { > hostname.slen = strlen(buf); > } > } > return &hostname; > } > > #if defined(PJ_WIN32) > /* > * Create new socket/endpoint for communication and returns a descriptor. > */ > PJ_DEF(pj_status_t) pj_sock_socket(int af, > int type, > int proto, > pj_sock_t *sock) > { > PJ_CHECK_STACK(); > > /* Sanity checks. */ > PJ_ASSERT_RETURN(sock!=NULL, PJ_EINVAL); > PJ_ASSERT_RETURN((unsigned)PJ_INVALID_SOCKET==INVALID_SOCKET, > (*sock=PJ_INVALID_SOCKET, PJ_EINVAL)); > > *sock = WSASocket(af, type, proto, NULL, 0, WSA_FLAG_OVERLAPPED); > > if (*sock == PJ_INVALID_SOCKET) > return PJ_RETURN_OS_ERROR(pj_get_native_netos_error()); > else > return PJ_SUCCESS; > } > > #else > /* > * Create new socket/endpoint for communication and returns a descriptor. > */ > PJ_DEF(pj_status_t) pj_sock_socket(int af, > int type, > int proto, > pj_sock_t *sock) > { > > PJ_CHECK_STACK(); > > /* Sanity checks. */ > PJ_ASSERT_RETURN(sock!=NULL, PJ_EINVAL); > PJ_ASSERT_RETURN(PJ_INVALID_SOCKET==-1, > (*sock=PJ_INVALID_SOCKET, PJ_EINVAL)); > > *sock = socket(af, type, proto); > if (*sock == PJ_INVALID_SOCKET) > return PJ_RETURN_OS_ERROR(pj_get_native_netos_error()); > else > return PJ_SUCCESS; > } > #endif > > /* > * Bind socket. > */ > PJ_DEF(pj_status_t) pj_sock_bind( pj_sock_t sock, > const pj_sockaddr_t *addr, > int len) > { > PJ_CHECK_STACK(); > > PJ_ASSERT_RETURN(addr && len >= (int)sizeof(struct sockaddr_in), > PJ_EINVAL); > > CHECK_ADDR_LEN(addr, len); > > if (bind(sock, (struct sockaddr*)addr, len) != 0) > return PJ_RETURN_OS_ERROR(pj_get_native_netos_error()); > else > return PJ_SUCCESS; > } > > > /* > * Bind socket. > */ > PJ_DEF(pj_status_t) pj_sock_bind_in( pj_sock_t sock, > pj_uint32_t addr32, > pj_uint16_t port) > { > pj_sockaddr_in addr; > > PJ_CHECK_STACK(); > > PJ_SOCKADDR_SET_LEN(&addr, sizeof(pj_sockaddr_in)); > addr.sin_family = PJ_AF_INET; > pj_bzero(addr.sin_zero, sizeof(addr.sin_zero)); > addr.sin_addr.s_addr = pj_htonl(addr32); > addr.sin_port = pj_htons(port); > > return pj_sock_bind(sock, &addr, sizeof(pj_sockaddr_in)); > } > > > /* > * Close socket. > */ > PJ_DEF(pj_status_t) pj_sock_close(pj_sock_t sock) > { > int rc; > > PJ_CHECK_STACK(); > #if defined(PJ_WIN32) && PJ_WIN32!=0 || \ > defined(PJ_WIN32_WINCE) && PJ_WIN32_WINCE!=0 > rc = closesocket(sock); > #else > rc = close(sock); > #endif > > if (rc != 0) > return PJ_RETURN_OS_ERROR(pj_get_native_netos_error()); > else > return PJ_SUCCESS; > } > > /* > * Get remote's name. > */ > PJ_DEF(pj_status_t) pj_sock_getpeername( pj_sock_t sock, > pj_sockaddr_t *addr, > int *namelen) > { > PJ_CHECK_STACK(); > if (getpeername(sock, (struct sockaddr*)addr, (socklen_t*)namelen) != 0) > return PJ_RETURN_OS_ERROR(pj_get_native_netos_error()); > else { > PJ_SOCKADDR_RESET_LEN(addr); > return PJ_SUCCESS; > } > } > > /* > * Get socket name. > */ > PJ_DEF(pj_status_t) pj_sock_getsockname( pj_sock_t sock, > pj_sockaddr_t *addr, > int *namelen) > { > PJ_CHECK_STACK(); > if (getsockname(sock, (struct sockaddr*)addr, (socklen_t*)namelen) != 0) > return PJ_RETURN_OS_ERROR(pj_get_native_netos_error()); > else { > PJ_SOCKADDR_RESET_LEN(addr); > return PJ_SUCCESS; > } > } > > /* > * Send data > */ > PJ_DEF(pj_status_t) pj_sock_send(pj_sock_t sock, > const void *buf, > pj_ssize_t *len, > unsigned flags) > { > PJ_CHECK_STACK(); > PJ_ASSERT_RETURN(len, PJ_EINVAL); > > *len = send(sock, (const char*)buf, *len, flags); > > if (*len < 0) > return PJ_RETURN_OS_ERROR(pj_get_native_netos_error()); > else > return PJ_SUCCESS; > } > > > /* > * Send data. > */ > PJ_DEF(pj_status_t) pj_sock_sendto(pj_sock_t sock, > const void *buf, > pj_ssize_t *len, > unsigned flags, > const pj_sockaddr_t *to, > int tolen) > { > PJ_CHECK_STACK(); > PJ_ASSERT_RETURN(len, PJ_EINVAL); > > CHECK_ADDR_LEN(to, tolen); > > *len = sendto(sock, (const char*)buf, *len, flags, > (const struct sockaddr*)to, tolen); > > if (*len < 0) > return PJ_RETURN_OS_ERROR(pj_get_native_netos_error()); > else > return PJ_SUCCESS; > } > > /* > * Receive data. > */ > PJ_DEF(pj_status_t) pj_sock_recv(pj_sock_t sock, > void *buf, > pj_ssize_t *len, > unsigned flags) > { > PJ_CHECK_STACK(); > PJ_ASSERT_RETURN(buf && len, PJ_EINVAL); > > *len = recv(sock, (char*)buf, *len, flags); > > if (*len < 0) > return PJ_RETURN_OS_ERROR(pj_get_native_netos_error()); > else > return PJ_SUCCESS; > } > > /* > * Receive data. > */ > PJ_DEF(pj_status_t) pj_sock_recvfrom(pj_sock_t sock, > void *buf, > pj_ssize_t *len, > unsigned flags, > pj_sockaddr_t *from, > int *fromlen) > { > PJ_CHECK_STACK(); > PJ_ASSERT_RETURN(buf && len, PJ_EINVAL); > PJ_ASSERT_RETURN(from && fromlen, (*len=-1, PJ_EINVAL)); > > *len = recvfrom(sock, (char*)buf, *len, flags, > (struct sockaddr*)from, (socklen_t*)fromlen); > > if (*len < 0) > return PJ_RETURN_OS_ERROR(pj_get_native_netos_error()); > else { > PJ_SOCKADDR_RESET_LEN(from); > return PJ_SUCCESS; > } > } > > /* > * Get socket option. > */ > PJ_DEF(pj_status_t) pj_sock_getsockopt( pj_sock_t sock, > pj_uint16_t level, > pj_uint16_t optname, > void *optval, > int *optlen) > { > PJ_CHECK_STACK(); > PJ_ASSERT_RETURN(optval && optlen, PJ_EINVAL); > > if (getsockopt(sock, level, optname, (char*)optval, > (socklen_t*)optlen)!=0) > return PJ_RETURN_OS_ERROR(pj_get_native_netos_error()); > else > return PJ_SUCCESS; > } > > /* > * Set socket option. > */ > PJ_DEF(pj_status_t) pj_sock_setsockopt( pj_sock_t sock, > pj_uint16_t level, > pj_uint16_t optname, > const void *optval, > int optlen) > { > PJ_CHECK_STACK(); > if (setsockopt(sock, level, optname, (const char*)optval, optlen) != 0) > return PJ_RETURN_OS_ERROR(pj_get_native_netos_error()); > else > return PJ_SUCCESS; > } > > /* > * Connect socket. > */ > PJ_DEF(pj_status_t) pj_sock_connect( pj_sock_t sock, > const pj_sockaddr_t *addr, > int namelen) > { > PJ_CHECK_STACK(); > if (connect(sock, (struct sockaddr*)addr, namelen) != 0) > return PJ_RETURN_OS_ERROR(pj_get_native_netos_error()); > else > return PJ_SUCCESS; > } > > > /* > * Shutdown socket. > */ > #if PJ_HAS_TCP > PJ_DEF(pj_status_t) pj_sock_shutdown( pj_sock_t sock, > int how) > { > PJ_CHECK_STACK(); > if (shutdown(sock, how) != 0) > return PJ_RETURN_OS_ERROR(pj_get_native_netos_error()); > else > return PJ_SUCCESS; > } > > /* > * Start listening to incoming connections. > */ > PJ_DEF(pj_status_t) pj_sock_listen( pj_sock_t sock, > int backlog) > { > PJ_CHECK_STACK(); > if (listen(sock, backlog) != 0) > return PJ_RETURN_OS_ERROR(pj_get_native_netos_error()); > else > return PJ_SUCCESS; > } > > /* > * Accept incoming connections > */ > PJ_DEF(pj_status_t) pj_sock_accept( pj_sock_t serverfd, > pj_sock_t *newsock, > pj_sockaddr_t *addr, > int *addrlen) > { > PJ_CHECK_STACK(); > PJ_ASSERT_RETURN(newsock != NULL, PJ_EINVAL); > > #if defined(PJ_SOCKADDR_HAS_LEN) && PJ_SOCKADDR_HAS_LEN!=0 > if (addr) { > PJ_SOCKADDR_SET_LEN(addr, *addrlen); > } > #endif > > *newsock = accept(serverfd, (struct sockaddr*)addr, > (socklen_t*)addrlen); > if (*newsock==PJ_INVALID_SOCKET) > return PJ_RETURN_OS_ERROR(pj_get_native_netos_error()); > else { > > #if defined(PJ_SOCKADDR_HAS_LEN) && PJ_SOCKADDR_HAS_LEN!=0 > if (addr) { > PJ_SOCKADDR_RESET_LEN(addr); > } > #endif > > return PJ_SUCCESS; > } > } > #endif /* PJ_HAS_TCP */ > > > > _______________________________________________ > Visit our blog: http://blog.pjsip.org > > pjsip mailing list > pjsip at lists.pjsip.org > http://lists.pjsip.org/mailman/listinfo/pjsip_lists.pjsip.org > > -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.pjsip.org/pipermail/pjsip_lists.pjsip.org/attachments/20080925/ebcb273a/attachment-0001.html>
