pjproject: Fix for Solaris builds. Do not undef s_addr.
[asterisk/asterisk.git] / res / pjproject / pjlib / src / pj / sock_bsd.c
1 /* $Id$ */
2 /* 
3  * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
4  * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
19  */
20 #include <pj/sock.h>
21 #include <pj/os.h>
22 #include <pj/assert.h>
23 #include <pj/string.h>
24 #include <pj/compat/socket.h>
25 #include <pj/addr_resolv.h>
26 #include <pj/errno.h>
27 #include <pj/unicode.h>
28
29 /*
30  * Address families conversion.
31  * The values here are indexed based on pj_addr_family.
32  */
33 const pj_uint16_t PJ_AF_UNSPEC  = AF_UNSPEC;
34 const pj_uint16_t PJ_AF_UNIX    = AF_UNIX;
35 const pj_uint16_t PJ_AF_INET    = AF_INET;
36 const pj_uint16_t PJ_AF_INET6   = AF_INET6;
37 #ifdef AF_PACKET
38 const pj_uint16_t PJ_AF_PACKET  = AF_PACKET;
39 #else
40 const pj_uint16_t PJ_AF_PACKET  = 0xFFFF;
41 #endif
42 #ifdef AF_IRDA
43 const pj_uint16_t PJ_AF_IRDA    = AF_IRDA;
44 #else
45 const pj_uint16_t PJ_AF_IRDA    = 0xFFFF;
46 #endif
47
48 /*
49  * Socket types conversion.
50  * The values here are indexed based on pj_sock_type
51  */
52 const pj_uint16_t PJ_SOCK_STREAM= SOCK_STREAM;
53 const pj_uint16_t PJ_SOCK_DGRAM = SOCK_DGRAM;
54 const pj_uint16_t PJ_SOCK_RAW   = SOCK_RAW;
55 const pj_uint16_t PJ_SOCK_RDM   = SOCK_RDM;
56
57 /*
58  * Socket level values.
59  */
60 const pj_uint16_t PJ_SOL_SOCKET = SOL_SOCKET;
61 #ifdef SOL_IP
62 const pj_uint16_t PJ_SOL_IP     = SOL_IP;
63 #elif defined(PJ_WIN32) && PJ_WIN32
64 const pj_uint16_t PJ_SOL_IP     = IPPROTO_IP;
65 #else
66 const pj_uint16_t PJ_SOL_IP     = 0;
67 #endif /* SOL_IP */
68
69 #if defined(SOL_TCP)
70 const pj_uint16_t PJ_SOL_TCP    = SOL_TCP;
71 #elif defined(IPPROTO_TCP)
72 const pj_uint16_t PJ_SOL_TCP    = IPPROTO_TCP;
73 #elif defined(PJ_WIN32) && PJ_WIN32
74 const pj_uint16_t PJ_SOL_TCP    = IPPROTO_TCP;
75 #else
76 const pj_uint16_t PJ_SOL_TCP    = 6;
77 #endif /* SOL_TCP */
78
79 #ifdef SOL_UDP
80 const pj_uint16_t PJ_SOL_UDP    = SOL_UDP;
81 #elif defined(IPPROTO_UDP)
82 const pj_uint16_t PJ_SOL_UDP    = IPPROTO_UDP;
83 #elif defined(PJ_WIN32) && PJ_WIN32
84 const pj_uint16_t PJ_SOL_UDP    = IPPROTO_UDP;
85 #else
86 const pj_uint16_t PJ_SOL_UDP    = 17;
87 #endif /* SOL_UDP */
88
89 #ifdef SOL_IPV6
90 const pj_uint16_t PJ_SOL_IPV6   = SOL_IPV6;
91 #elif defined(PJ_WIN32) && PJ_WIN32
92 #   if defined(IPPROTO_IPV6) || (_WIN32_WINNT >= 0x0501)
93         const pj_uint16_t PJ_SOL_IPV6   = IPPROTO_IPV6;
94 #   else
95         const pj_uint16_t PJ_SOL_IPV6   = 41;
96 #   endif
97 #else
98 const pj_uint16_t PJ_SOL_IPV6   = 41;
99 #endif /* SOL_IPV6 */
100
101 /* IP_TOS */
102 #ifdef IP_TOS
103 const pj_uint16_t PJ_IP_TOS     = IP_TOS;
104 #else
105 const pj_uint16_t PJ_IP_TOS     = 1;
106 #endif
107
108
109 /* TOS settings (declared in netinet/ip.h) */
110 #ifdef IPTOS_LOWDELAY
111 const pj_uint16_t PJ_IPTOS_LOWDELAY     = IPTOS_LOWDELAY;
112 #else
113 const pj_uint16_t PJ_IPTOS_LOWDELAY     = 0x10;
114 #endif
115 #ifdef IPTOS_THROUGHPUT
116 const pj_uint16_t PJ_IPTOS_THROUGHPUT   = IPTOS_THROUGHPUT;
117 #else
118 const pj_uint16_t PJ_IPTOS_THROUGHPUT   = 0x08;
119 #endif
120 #ifdef IPTOS_RELIABILITY
121 const pj_uint16_t PJ_IPTOS_RELIABILITY  = IPTOS_RELIABILITY;
122 #else
123 const pj_uint16_t PJ_IPTOS_RELIABILITY  = 0x04;
124 #endif
125 #ifdef IPTOS_MINCOST
126 const pj_uint16_t PJ_IPTOS_MINCOST      = IPTOS_MINCOST;
127 #else
128 const pj_uint16_t PJ_IPTOS_MINCOST      = 0x02;
129 #endif
130
131
132 /* optname values. */
133 const pj_uint16_t PJ_SO_TYPE    = SO_TYPE;
134 const pj_uint16_t PJ_SO_RCVBUF  = SO_RCVBUF;
135 const pj_uint16_t PJ_SO_SNDBUF  = SO_SNDBUF;
136 const pj_uint16_t PJ_TCP_NODELAY= TCP_NODELAY;
137 const pj_uint16_t PJ_SO_REUSEADDR= SO_REUSEADDR;
138 #ifdef SO_NOSIGPIPE
139 const pj_uint16_t PJ_SO_NOSIGPIPE = SO_NOSIGPIPE;
140 #else
141 const pj_uint16_t PJ_SO_NOSIGPIPE = 0xFFFF;
142 #endif
143 #if defined(SO_PRIORITY)
144 const pj_uint16_t PJ_SO_PRIORITY = SO_PRIORITY;
145 #else
146 /* This is from Linux, YMMV */
147 const pj_uint16_t PJ_SO_PRIORITY = 12;
148 #endif
149
150 /* Multicasting is not supported e.g. in PocketPC 2003 SDK */
151 #ifdef IP_MULTICAST_IF
152 const pj_uint16_t PJ_IP_MULTICAST_IF    = IP_MULTICAST_IF;
153 const pj_uint16_t PJ_IP_MULTICAST_TTL   = IP_MULTICAST_TTL;
154 const pj_uint16_t PJ_IP_MULTICAST_LOOP  = IP_MULTICAST_LOOP;
155 const pj_uint16_t PJ_IP_ADD_MEMBERSHIP  = IP_ADD_MEMBERSHIP;
156 const pj_uint16_t PJ_IP_DROP_MEMBERSHIP = IP_DROP_MEMBERSHIP;
157 #else
158 const pj_uint16_t PJ_IP_MULTICAST_IF    = 0xFFFF;
159 const pj_uint16_t PJ_IP_MULTICAST_TTL   = 0xFFFF;
160 const pj_uint16_t PJ_IP_MULTICAST_LOOP  = 0xFFFF;
161 const pj_uint16_t PJ_IP_ADD_MEMBERSHIP  = 0xFFFF;
162 const pj_uint16_t PJ_IP_DROP_MEMBERSHIP = 0xFFFF;
163 #endif
164
165 /* recv() and send() flags */
166 const int PJ_MSG_OOB            = MSG_OOB;
167 const int PJ_MSG_PEEK           = MSG_PEEK;
168 const int PJ_MSG_DONTROUTE      = MSG_DONTROUTE;
169
170
171 #if 0
172 static void CHECK_ADDR_LEN(const pj_sockaddr *addr, int len)
173 {
174     pj_sockaddr *a = (pj_sockaddr*)addr;
175     pj_assert((a->addr.sa_family==PJ_AF_INET && len==sizeof(pj_sockaddr_in)) ||
176               (a->addr.sa_family==PJ_AF_INET6 && len==sizeof(pj_sockaddr_in6)));
177
178 }
179 #else
180 #define CHECK_ADDR_LEN(addr,len)
181 #endif
182
183 /*
184  * Convert 16-bit value from network byte order to host byte order.
185  */
186 PJ_DEF(pj_uint16_t) pj_ntohs(pj_uint16_t netshort)
187 {
188     return ntohs(netshort);
189 }
190
191 /*
192  * Convert 16-bit value from host byte order to network byte order.
193  */
194 PJ_DEF(pj_uint16_t) pj_htons(pj_uint16_t hostshort)
195 {
196     return htons(hostshort);
197 }
198
199 /*
200  * Convert 32-bit value from network byte order to host byte order.
201  */
202 PJ_DEF(pj_uint32_t) pj_ntohl(pj_uint32_t netlong)
203 {
204     return ntohl(netlong);
205 }
206
207 /*
208  * Convert 32-bit value from host byte order to network byte order.
209  */
210 PJ_DEF(pj_uint32_t) pj_htonl(pj_uint32_t hostlong)
211 {
212     return htonl(hostlong);
213 }
214
215 /*
216  * Convert an Internet host address given in network byte order
217  * to string in standard numbers and dots notation.
218  */
219 PJ_DEF(char*) pj_inet_ntoa(pj_in_addr inaddr)
220 {
221 #if !defined(PJ_LINUX) && !defined(PJ_LINUX_KERNEL)
222     return inet_ntoa(*(struct in_addr*)&inaddr);
223 #else
224     struct in_addr addr;
225     addr.s_addr = inaddr.s_addr;
226     return inet_ntoa(addr);
227 #endif
228 }
229
230 /*
231  * This function converts the Internet host address cp from the standard
232  * numbers-and-dots notation into binary data and stores it in the structure
233  * that inp points to. 
234  */
235 PJ_DEF(int) pj_inet_aton(const pj_str_t *cp, pj_in_addr *inp)
236 {
237     char tempaddr[PJ_INET_ADDRSTRLEN];
238
239     /* Initialize output with PJ_INADDR_NONE.
240      * Some apps relies on this instead of the return value
241      * (and anyway the return value is quite confusing!)
242      */
243     inp->s_addr = PJ_INADDR_NONE;
244
245     /* Caution:
246      *  this function might be called with cp->slen >= 16
247      *  (i.e. when called with hostname to check if it's an IP addr).
248      */
249     PJ_ASSERT_RETURN(cp && cp->slen && inp, 0);
250     if (cp->slen >= PJ_INET_ADDRSTRLEN) {
251         return 0;
252     }
253
254     pj_memcpy(tempaddr, cp->ptr, cp->slen);
255     tempaddr[cp->slen] = '\0';
256
257 #if defined(PJ_SOCK_HAS_INET_ATON) && PJ_SOCK_HAS_INET_ATON != 0
258     return inet_aton(tempaddr, (struct in_addr*)inp);
259 #else
260     inp->s_addr = inet_addr(tempaddr);
261     return inp->s_addr == PJ_INADDR_NONE ? 0 : 1;
262 #endif
263 }
264
265 /*
266  * Convert text to IPv4/IPv6 address.
267  */
268 PJ_DEF(pj_status_t) pj_inet_pton(int af, const pj_str_t *src, void *dst)
269 {
270     char tempaddr[PJ_INET6_ADDRSTRLEN];
271
272     PJ_ASSERT_RETURN(af==PJ_AF_INET || af==PJ_AF_INET6, PJ_EAFNOTSUP);
273     PJ_ASSERT_RETURN(src && src->slen && dst, PJ_EINVAL);
274
275     /* Initialize output with PJ_IN_ADDR_NONE for IPv4 (to be 
276      * compatible with pj_inet_aton()
277      */
278     if (af==PJ_AF_INET) {
279         ((pj_in_addr*)dst)->s_addr = PJ_INADDR_NONE;
280     }
281
282     /* Caution:
283      *  this function might be called with cp->slen >= 46
284      *  (i.e. when called with hostname to check if it's an IP addr).
285      */
286     if (src->slen >= PJ_INET6_ADDRSTRLEN) {
287         return PJ_ENAMETOOLONG;
288     }
289
290     pj_memcpy(tempaddr, src->ptr, src->slen);
291     tempaddr[src->slen] = '\0';
292
293 #if defined(PJ_SOCK_HAS_INET_PTON) && PJ_SOCK_HAS_INET_PTON != 0
294     /*
295      * Implementation using inet_pton()
296      */
297     if (inet_pton(af, tempaddr, dst) != 1) {
298         pj_status_t status = pj_get_netos_error();
299         if (status == PJ_SUCCESS)
300             status = PJ_EUNKNOWN;
301
302         return status;
303     }
304
305     return PJ_SUCCESS;
306
307 #elif defined(PJ_WIN32) || defined(PJ_WIN32_WINCE)
308     /*
309      * Implementation on Windows, using WSAStringToAddress().
310      * Should also work on Unicode systems.
311      */
312     {
313         PJ_DECL_UNICODE_TEMP_BUF(wtempaddr,PJ_INET6_ADDRSTRLEN)
314         pj_sockaddr sock_addr;
315         int addr_len = sizeof(sock_addr);
316         int rc;
317
318         sock_addr.addr.sa_family = (pj_uint16_t)af;
319         rc = WSAStringToAddress(
320                 PJ_STRING_TO_NATIVE(tempaddr,wtempaddr,sizeof(wtempaddr)), 
321                 af, NULL, (LPSOCKADDR)&sock_addr, &addr_len);
322         if (rc != 0) {
323             /* If you get rc 130022 Invalid argument (WSAEINVAL) with IPv6,
324              * check that you have IPv6 enabled (install it in the network
325              * adapter).
326              */
327             pj_status_t status = pj_get_netos_error();
328             if (status == PJ_SUCCESS)
329                 status = PJ_EUNKNOWN;
330
331             return status;
332         }
333
334         if (sock_addr.addr.sa_family == PJ_AF_INET) {
335             pj_memcpy(dst, &sock_addr.ipv4.sin_addr, 4);
336             return PJ_SUCCESS;
337         } else if (sock_addr.addr.sa_family == PJ_AF_INET6) {
338             pj_memcpy(dst, &sock_addr.ipv6.sin6_addr, 16);
339             return PJ_SUCCESS;
340         } else {
341             pj_assert(!"Shouldn't happen");
342             return PJ_EBUG;
343         }
344     }
345 #elif !defined(PJ_HAS_IPV6) || PJ_HAS_IPV6==0
346     /* IPv6 support is disabled, just return error without raising assertion */
347     return PJ_EIPV6NOTSUP;
348 #else
349     pj_assert(!"Not supported");
350     return PJ_EIPV6NOTSUP;
351 #endif
352 }
353
354 /*
355  * Convert IPv4/IPv6 address to text.
356  */
357 PJ_DEF(pj_status_t) pj_inet_ntop(int af, const void *src,
358                                  char *dst, int size)
359
360 {
361     PJ_ASSERT_RETURN(src && dst && size, PJ_EINVAL);
362
363     *dst = '\0';
364
365     PJ_ASSERT_RETURN(af==PJ_AF_INET || af==PJ_AF_INET6, PJ_EAFNOTSUP);
366
367 #if defined(PJ_SOCK_HAS_INET_NTOP) && PJ_SOCK_HAS_INET_NTOP != 0
368     /*
369      * Implementation using inet_ntop()
370      */
371     if (inet_ntop(af, src, dst, size) == NULL) {
372         pj_status_t status = pj_get_netos_error();
373         if (status == PJ_SUCCESS)
374             status = PJ_EUNKNOWN;
375
376         return status;
377     }
378
379     return PJ_SUCCESS;
380
381 #elif defined(PJ_WIN32) || defined(PJ_WIN32_WINCE)
382     /*
383      * Implementation on Windows, using WSAAddressToString().
384      * Should also work on Unicode systems.
385      */
386     {
387         PJ_DECL_UNICODE_TEMP_BUF(wtempaddr,PJ_INET6_ADDRSTRLEN)
388         pj_sockaddr sock_addr;
389         DWORD addr_len, addr_str_len;
390         int rc;
391
392         pj_bzero(&sock_addr, sizeof(sock_addr));
393         sock_addr.addr.sa_family = (pj_uint16_t)af;
394         if (af == PJ_AF_INET) {
395             if (size < PJ_INET_ADDRSTRLEN)
396                 return PJ_ETOOSMALL;
397             pj_memcpy(&sock_addr.ipv4.sin_addr, src, 4);
398             addr_len = sizeof(pj_sockaddr_in);
399             addr_str_len = PJ_INET_ADDRSTRLEN;
400         } else if (af == PJ_AF_INET6) {
401             if (size < PJ_INET6_ADDRSTRLEN)
402                 return PJ_ETOOSMALL;
403             pj_memcpy(&sock_addr.ipv6.sin6_addr, src, 16);
404             addr_len = sizeof(pj_sockaddr_in6);
405             addr_str_len = PJ_INET6_ADDRSTRLEN;
406         } else {
407             pj_assert(!"Unsupported address family");
408             return PJ_EAFNOTSUP;
409         }
410
411 #if PJ_NATIVE_STRING_IS_UNICODE
412         rc = WSAAddressToString((LPSOCKADDR)&sock_addr, addr_len,
413                                 NULL, wtempaddr, &addr_str_len);
414         if (rc == 0) {
415             pj_unicode_to_ansi(wtempaddr, wcslen(wtempaddr), dst, size);
416         }
417 #else
418         rc = WSAAddressToString((LPSOCKADDR)&sock_addr, addr_len,
419                                 NULL, dst, &addr_str_len);
420 #endif
421
422         if (rc != 0) {
423             pj_status_t status = pj_get_netos_error();
424             if (status == PJ_SUCCESS)
425                 status = PJ_EUNKNOWN;
426
427             return status;
428         }
429
430         return PJ_SUCCESS;
431     }
432
433 #elif !defined(PJ_HAS_IPV6) || PJ_HAS_IPV6==0
434     /* IPv6 support is disabled, just return error without raising assertion */
435     return PJ_EIPV6NOTSUP;
436 #else
437     pj_assert(!"Not supported");
438     return PJ_EIPV6NOTSUP;
439 #endif
440 }
441
442 /*
443  * Get hostname.
444  */
445 PJ_DEF(const pj_str_t*) pj_gethostname(void)
446 {
447     static char buf[PJ_MAX_HOSTNAME];
448     static pj_str_t hostname;
449
450     PJ_CHECK_STACK();
451
452     if (hostname.ptr == NULL) {
453         hostname.ptr = buf;
454         if (gethostname(buf, sizeof(buf)) != 0) {
455             hostname.ptr[0] = '\0';
456             hostname.slen = 0;
457         } else {
458             hostname.slen = strlen(buf);
459         }
460     }
461     return &hostname;
462 }
463
464 #if defined(PJ_WIN32)
465 /*
466  * Create new socket/endpoint for communication and returns a descriptor.
467  */
468 PJ_DEF(pj_status_t) pj_sock_socket(int af, 
469                                    int type, 
470                                    int proto,
471                                    pj_sock_t *sock)
472 {
473     PJ_CHECK_STACK();
474
475     /* Sanity checks. */
476     PJ_ASSERT_RETURN(sock!=NULL, PJ_EINVAL);
477     PJ_ASSERT_RETURN((unsigned)PJ_INVALID_SOCKET==INVALID_SOCKET, 
478                      (*sock=PJ_INVALID_SOCKET, PJ_EINVAL));
479
480     *sock = WSASocket(af, type, proto, NULL, 0, WSA_FLAG_OVERLAPPED);
481
482     if (*sock == PJ_INVALID_SOCKET) 
483         return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
484     
485 #if PJ_SOCK_DISABLE_WSAECONNRESET && \
486     (!defined(PJ_WIN32_WINCE) || PJ_WIN32_WINCE==0)
487
488 #ifndef SIO_UDP_CONNRESET
489     #define SIO_UDP_CONNRESET _WSAIOW(IOC_VENDOR,12)
490 #endif
491
492     /* Disable WSAECONNRESET for UDP.
493      * See https://trac.pjsip.org/repos/ticket/1197
494      */
495     if (type==PJ_SOCK_DGRAM) {
496         DWORD dwBytesReturned = 0;
497         BOOL bNewBehavior = FALSE;
498         DWORD rc;
499
500         rc = WSAIoctl(*sock, SIO_UDP_CONNRESET,
501                       &bNewBehavior, sizeof(bNewBehavior),
502                       NULL, 0, &dwBytesReturned,
503                       NULL, NULL);
504
505         if (rc==SOCKET_ERROR) {
506             // Ignored..
507         }
508     }
509 #endif
510
511     return PJ_SUCCESS;
512 }
513
514 #else
515 /*
516  * Create new socket/endpoint for communication and returns a descriptor.
517  */
518 PJ_DEF(pj_status_t) pj_sock_socket(int af, 
519                                    int type, 
520                                    int proto, 
521                                    pj_sock_t *sock)
522 {
523
524     PJ_CHECK_STACK();
525
526     /* Sanity checks. */
527     PJ_ASSERT_RETURN(sock!=NULL, PJ_EINVAL);
528     PJ_ASSERT_RETURN(PJ_INVALID_SOCKET==-1, 
529                      (*sock=PJ_INVALID_SOCKET, PJ_EINVAL));
530     
531     *sock = socket(af, type, proto);
532     if (*sock == PJ_INVALID_SOCKET)
533         return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
534     else {
535         pj_int32_t val = 1;
536         if (type == pj_SOCK_STREAM()) {
537             pj_sock_setsockopt(*sock, pj_SOL_SOCKET(), pj_SO_NOSIGPIPE(),
538                                &val, sizeof(val));
539         }
540 #if defined(PJ_IPHONE_OS_HAS_MULTITASKING_SUPPORT) && \
541     PJ_IPHONE_OS_HAS_MULTITASKING_SUPPORT!=0
542         if (type == pj_SOCK_DGRAM()) {
543             pj_sock_setsockopt(*sock, pj_SOL_SOCKET(), SO_NOSIGPIPE, 
544                                &val, sizeof(val));
545         }
546 #endif
547         return PJ_SUCCESS;
548     }
549 }
550 #endif
551
552 /*
553  * Bind socket.
554  */
555 PJ_DEF(pj_status_t) pj_sock_bind( pj_sock_t sock, 
556                                   const pj_sockaddr_t *addr,
557                                   int len)
558 {
559     PJ_CHECK_STACK();
560
561     PJ_ASSERT_RETURN(addr && len >= (int)sizeof(struct sockaddr_in), PJ_EINVAL);
562
563     CHECK_ADDR_LEN(addr, len);
564
565     if (bind(sock, (struct sockaddr*)addr, len) != 0)
566         return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
567     else
568         return PJ_SUCCESS;
569 }
570
571
572 /*
573  * Bind socket.
574  */
575 PJ_DEF(pj_status_t) pj_sock_bind_in( pj_sock_t sock, 
576                                      pj_uint32_t addr32,
577                                      pj_uint16_t port)
578 {
579     pj_sockaddr_in addr;
580
581     PJ_CHECK_STACK();
582
583     PJ_SOCKADDR_SET_LEN(&addr, sizeof(pj_sockaddr_in));
584     addr.sin_family = PJ_AF_INET;
585     pj_bzero(addr.sin_zero, sizeof(addr.sin_zero));
586     addr.sin_addr.s_addr = pj_htonl(addr32);
587     addr.sin_port = pj_htons(port);
588
589     return pj_sock_bind(sock, &addr, sizeof(pj_sockaddr_in));
590 }
591
592
593 /*
594  * Close socket.
595  */
596 PJ_DEF(pj_status_t) pj_sock_close(pj_sock_t sock)
597 {
598     int rc;
599
600     PJ_CHECK_STACK();
601 #if defined(PJ_WIN32) && PJ_WIN32!=0 || \
602     defined(PJ_WIN32_WINCE) && PJ_WIN32_WINCE!=0
603     rc = closesocket(sock);
604 #else
605     rc = close(sock);
606 #endif
607
608     if (rc != 0)
609         return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
610     else
611         return PJ_SUCCESS;
612 }
613
614 /*
615  * Get remote's name.
616  */
617 PJ_DEF(pj_status_t) pj_sock_getpeername( pj_sock_t sock,
618                                          pj_sockaddr_t *addr,
619                                          int *namelen)
620 {
621     PJ_CHECK_STACK();
622     if (getpeername(sock, (struct sockaddr*)addr, (socklen_t*)namelen) != 0)
623         return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
624     else {
625         PJ_SOCKADDR_RESET_LEN(addr);
626         return PJ_SUCCESS;
627     }
628 }
629
630 /*
631  * Get socket name.
632  */
633 PJ_DEF(pj_status_t) pj_sock_getsockname( pj_sock_t sock,
634                                          pj_sockaddr_t *addr,
635                                          int *namelen)
636 {
637     PJ_CHECK_STACK();
638     if (getsockname(sock, (struct sockaddr*)addr, (socklen_t*)namelen) != 0)
639         return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
640     else {
641         PJ_SOCKADDR_RESET_LEN(addr);
642         return PJ_SUCCESS;
643     }
644 }
645
646 /*
647  * Send data
648  */
649 PJ_DEF(pj_status_t) pj_sock_send(pj_sock_t sock,
650                                  const void *buf,
651                                  pj_ssize_t *len,
652                                  unsigned flags)
653 {
654     PJ_CHECK_STACK();
655     PJ_ASSERT_RETURN(len, PJ_EINVAL);
656
657     *len = send(sock, (const char*)buf, *len, flags);
658
659     if (*len < 0)
660         return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
661     else
662         return PJ_SUCCESS;
663 }
664
665
666 /*
667  * Send data.
668  */
669 PJ_DEF(pj_status_t) pj_sock_sendto(pj_sock_t sock,
670                                    const void *buf,
671                                    pj_ssize_t *len,
672                                    unsigned flags,
673                                    const pj_sockaddr_t *to,
674                                    int tolen)
675 {
676     PJ_CHECK_STACK();
677     PJ_ASSERT_RETURN(len, PJ_EINVAL);
678     
679     CHECK_ADDR_LEN(to, tolen);
680
681     *len = sendto(sock, (const char*)buf, *len, flags, 
682                   (const struct sockaddr*)to, tolen);
683
684     if (*len < 0) 
685         return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
686     else 
687         return PJ_SUCCESS;
688 }
689
690 /*
691  * Receive data.
692  */
693 PJ_DEF(pj_status_t) pj_sock_recv(pj_sock_t sock,
694                                  void *buf,
695                                  pj_ssize_t *len,
696                                  unsigned flags)
697 {
698     PJ_CHECK_STACK();
699     PJ_ASSERT_RETURN(buf && len, PJ_EINVAL);
700
701     *len = recv(sock, (char*)buf, *len, flags);
702
703     if (*len < 0) 
704         return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
705     else
706         return PJ_SUCCESS;
707 }
708
709 /*
710  * Receive data.
711  */
712 PJ_DEF(pj_status_t) pj_sock_recvfrom(pj_sock_t sock,
713                                      void *buf,
714                                      pj_ssize_t *len,
715                                      unsigned flags,
716                                      pj_sockaddr_t *from,
717                                      int *fromlen)
718 {
719     PJ_CHECK_STACK();
720     PJ_ASSERT_RETURN(buf && len, PJ_EINVAL);
721     PJ_ASSERT_RETURN(from && fromlen, (*len=-1, PJ_EINVAL));
722
723     *len = recvfrom(sock, (char*)buf, *len, flags, 
724                     (struct sockaddr*)from, (socklen_t*)fromlen);
725
726     if (*len < 0) 
727         return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
728     else {
729         PJ_SOCKADDR_RESET_LEN(from);
730         return PJ_SUCCESS;
731     }
732 }
733
734 /*
735  * Get socket option.
736  */
737 PJ_DEF(pj_status_t) pj_sock_getsockopt( pj_sock_t sock,
738                                         pj_uint16_t level,
739                                         pj_uint16_t optname,
740                                         void *optval,
741                                         int *optlen)
742 {
743     PJ_CHECK_STACK();
744     PJ_ASSERT_RETURN(optval && optlen, PJ_EINVAL);
745
746     if (getsockopt(sock, level, optname, (char*)optval, (socklen_t*)optlen)!=0)
747         return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
748     else
749         return PJ_SUCCESS;
750 }
751
752 /*
753  * Set socket option.
754  */
755 PJ_DEF(pj_status_t) pj_sock_setsockopt( pj_sock_t sock,
756                                         pj_uint16_t level,
757                                         pj_uint16_t optname,
758                                         const void *optval,
759                                         int optlen)
760 {
761     PJ_CHECK_STACK();
762     if (setsockopt(sock, level, optname, (const char*)optval, optlen) != 0)
763         return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
764     else
765         return PJ_SUCCESS;
766 }
767
768 /*
769  * Connect socket.
770  */
771 PJ_DEF(pj_status_t) pj_sock_connect( pj_sock_t sock,
772                                      const pj_sockaddr_t *addr,
773                                      int namelen)
774 {
775     PJ_CHECK_STACK();
776     if (connect(sock, (struct sockaddr*)addr, namelen) != 0)
777         return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
778     else
779         return PJ_SUCCESS;
780 }
781
782
783 /*
784  * Shutdown socket.
785  */
786 #if PJ_HAS_TCP
787 PJ_DEF(pj_status_t) pj_sock_shutdown( pj_sock_t sock,
788                                       int how)
789 {
790     PJ_CHECK_STACK();
791     if (shutdown(sock, how) != 0)
792         return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
793     else
794         return PJ_SUCCESS;
795 }
796
797 /*
798  * Start listening to incoming connections.
799  */
800 PJ_DEF(pj_status_t) pj_sock_listen( pj_sock_t sock,
801                                     int backlog)
802 {
803     PJ_CHECK_STACK();
804     if (listen(sock, backlog) != 0)
805         return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
806     else
807         return PJ_SUCCESS;
808 }
809
810 /*
811  * Accept incoming connections
812  */
813 PJ_DEF(pj_status_t) pj_sock_accept( pj_sock_t serverfd,
814                                     pj_sock_t *newsock,
815                                     pj_sockaddr_t *addr,
816                                     int *addrlen)
817 {
818     PJ_CHECK_STACK();
819     PJ_ASSERT_RETURN(newsock != NULL, PJ_EINVAL);
820
821 #if defined(PJ_SOCKADDR_HAS_LEN) && PJ_SOCKADDR_HAS_LEN!=0
822     if (addr) {
823         PJ_SOCKADDR_SET_LEN(addr, *addrlen);
824     }
825 #endif
826     
827     *newsock = accept(serverfd, (struct sockaddr*)addr, (socklen_t*)addrlen);
828     if (*newsock==PJ_INVALID_SOCKET)
829         return PJ_RETURN_OS_ERROR(pj_get_native_netos_error());
830     else {
831         
832 #if defined(PJ_SOCKADDR_HAS_LEN) && PJ_SOCKADDR_HAS_LEN!=0
833         if (addr) {
834             PJ_SOCKADDR_RESET_LEN(addr);
835         }
836 #endif
837             
838         return PJ_SUCCESS;
839     }
840 }
841 #endif  /* PJ_HAS_TCP */
842
843