开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
net_udp.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：26k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

net_udp.c：源码内容
  1. /*
  2.  * FILE:     net_udp.c
  3.  * AUTHOR:   Colin Perkins 
  4.  * MODIFIED: Orion Hodson & Piers O'Hanlon
  5.  * 
  6.  * Copyright (c) 1998-2000 University College London
  7.  * All rights reserved.
  8.  *
  9.  * Redistribution and use in source and binary forms, with or without
  10.  * modification, is permitted provided that the following conditions 
  11.  * are met:
  12.  * 1. Redistributions of source code must retain the above copyright
  13.  *    notice, this list of conditions and the following disclaimer.
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in the
  16.  *    documentation and/or other materials provided with the distribution.
  17.  * 3. All advertising materials mentioning features or use of this software
  18.  *    must display the following acknowledgement:
  19.  *      This product includes software developed by the Computer Science
  20.  *      Department at University College London
  21.  * 4. Neither the name of the University nor of the Department may be used
  22.  *    to endorse or promote products derived from this software without
  23.  *    specific prior written permission.
  24.  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  25.  * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  28.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34.  * SUCH DAMAGE.
  35.  */
  37. /* If this machine supports IPv6 the symbol HAVE_IPv6 should */
  38. /* be defined in either config_unix.h or config_win32.h. The */
  39. /* appropriate system header files should also be included   */
  40. /* by those files.                                           */
  42. #include "config_unix.h"
  43. #include "config_win32.h"
  44. #include "debug.h"
  45. #include "memory.h"
  46. #include "inet_pton.h"
  47. #include "inet_ntop.h"
  48. #include "vsnprintf.h"
  49. #include "net_udp.h"
  51. #ifdef NEED_ADDRINFO_H
  52. #include "addrinfo.h"
  53. #endif
  55. #define IPv4 4
  56. #define IPv6 6
  58. #ifdef WIN2K_IPV6
  59. const struct in6_addr in6addr_any = {IN6ADDR_ANY_INIT};
  60. #endif
  62. /* This is pretty nasty but it's the simplest way to get round */
  63. /* the Detexis bug that means their MUSICA IPv6 stack uses     */
  64. /* IPPROTO_IP instead of IPPROTO_IPV6 in setsockopt calls      */
  65. /* We also need to define in6addr_any */
  66. #ifdef  MUSICA_IPV6
  67. #define IPPROTO_IPV6 IPPROTO_IP
  68. struct in6_addr in6addr_any = {IN6ADDR_ANY_INIT};
  70. /* These DEF's are required as MUSICA's winsock6.h causes a clash with some of the 
  71.  * standard ws2tcpip.h definitions (eg struct in_addr6).
  72.  * Note: winsock6.h defines AF_INET6 as 24 NOT 23 as in winsock2.h - I have left it
  73.  * set to the MUSICA value as this is used in some of their function calls. 
  74.  */
  75. //#define AF_INET6        23
  76. #define IP_MULTICAST_LOOP      11 /*set/get IP multicast loopback */
  77. #define IP_MULTICAST_IF 9 /* set/get IP multicast i/f  */
  78. #define IP_MULTICAST_TTL       10 /* set/get IP multicast ttl */
  79. #define IP_MULTICAST_LOOP      11 /*set/get IP multicast loopback */
  80. #define IP_ADD_MEMBERSHIP      12 /* add an IP group membership */
  81. #define IP_DROP_MEMBERSHIP     13/* drop an IP group membership */
  83. #define IN6_IS_ADDR_UNSPECIFIED(a) (((a)->s6_addr32[0] == 0) && 
  84. ((a)->s6_addr32[1] == 0) && 
  85. ((a)->s6_addr32[2] == 0) && 
  86. ((a)->s6_addr32[3] == 0))
  87. struct ip_mreq {
  88. struct in_addr imr_multiaddr; /* IP multicast address of group */
  89. struct in_addr imr_interface; /* local IP address of interface */
  90. };
  91. #endif
  93. #ifndef INADDR_NONE
  94. #define INADDR_NONE 0xffffffff
  95. #endif
  97. struct _socket_udp {
  98. int    mode; /* IPv4 or IPv6 */
  99.         char         *addr;
  100. uint16_t  rx_port;
  101. uint16_t  tx_port;
  102. ttl_t    ttl;
  103. fd_t    fd;
  104. struct in_addr  addr4;
  105. #ifdef HAVE_IPv6
  106. struct in6_addr  addr6;
  107. #endif /* HAVE_IPv6 */
  108. };
  110. #ifdef WIN32
  111. /* Want to use both Winsock 1 and 2 socket options, but since
  112. * IPv6 support requires Winsock 2 we have to add own backwards
  113. * compatibility for Winsock 1.
  114. */
  115. #define SETSOCKOPT winsock_versions_setsockopt
  116. #else
  117. #define SETSOCKOPT setsockopt
  118. #endif /* WIN32 */
  120. /*****************************************************************************/
  121. /* Support functions...                                                      */
  122. /*****************************************************************************/
  124. static void
  125. socket_error(const char *msg, ...)
  126. {
  127. char buffer[255];
  128. uint32_t blen = sizeof(buffer) / sizeof(buffer[0]);
  129. va_list ap;
  131. #ifdef WIN32
  132. #define WSERR(x) {#x,x}
  133. struct wse {
  134. char  errname[20];
  135. int my_errno;
  136. };
  137. struct wse ws_errs[] = {
  138. WSERR(WSANOTINITIALISED), WSERR(WSAENETDOWN),     WSERR(WSAEACCES),
  139. WSERR(WSAEINVAL),         WSERR(WSAEINTR),        WSERR(WSAEINPROGRESS),
  140. WSERR(WSAEFAULT),         WSERR(WSAENETRESET),    WSERR(WSAENOBUFS),
  141. WSERR(WSAENOTCONN),       WSERR(WSAENOTSOCK),     WSERR(WSAEOPNOTSUPP),
  142. WSERR(WSAESHUTDOWN),      WSERR(WSAEWOULDBLOCK),  WSERR(WSAEMSGSIZE),
  143. WSERR(WSAEHOSTUNREACH),   WSERR(WSAECONNABORTED), WSERR(WSAECONNRESET),
  144. WSERR(WSAEADDRNOTAVAIL),  WSERR(WSAEAFNOSUPPORT), WSERR(WSAEDESTADDRREQ),
  145. WSERR(WSAENETUNREACH),    WSERR(WSAETIMEDOUT),    WSERR(0)
  146. };
  148. int i, e = WSAGetLastError();
  149. i = 0;
  150. while(ws_errs[i].my_errno && ws_errs[i].my_errno != e) {
  151. i++;
  152. }
  153. va_start(ap, msg);
  154. _vsnprintf(buffer, blen, msg, ap);
  155. va_end(ap);
  156. printf("ERROR: %s, (%d - %s)n", msg, e, ws_errs[i].errname);
  157. #else
  158. uint32_t retlen;
  159. va_start(ap, msg);
  160. retlen = vsnprintf(buffer, blen, msg, ap);
  161. va_end(ap);
  162. blen -= retlen;
  163. snprintf(buffer + retlen, blen, ":%s", strerror(errno));
  164. rtp_message(LOG_ALERT, buffer);
  165. #endif
  166. }
  168. #ifdef WIN32
  169. /* ws2tcpip.h defines these constants with different values from
  170. * winsock.h so files that use winsock 2 values but try to use 
  171. * winsock 1 fail.  So what was the motivation in changing the
  172. * constants ?
  173. */
  174. #define WS1_IP_MULTICAST_IF     2 /* set/get IP multicast interface   */
  175. #define WS1_IP_MULTICAST_TTL    3 /* set/get IP multicast timetolive  */
  176. #define WS1_IP_MULTICAST_LOOP   4 /* set/get IP multicast loopback    */
  177. #define WS1_IP_ADD_MEMBERSHIP   5 /* add  an IP group membership      */
  178. #define WS1_IP_DROP_MEMBERSHIP  6 /* drop an IP group membership      */
  180. /* winsock_versions_setsockopt tries 1 winsock version of option 
  181. * optname and then winsock 2 version if that failed.
  182. */
  184. static int
  185. winsock_versions_setsockopt(SOCKET s, int level, int optname, const char FAR * optval, int optlen)
  186. {
  187. int success = -1;
  188. switch (optname) {
  189. case IP_MULTICAST_IF:
  190. success = setsockopt(s, level, WS1_IP_MULTICAST_IF, optval, optlen);
  191. break;
  192. case IP_MULTICAST_TTL:
  193. success = setsockopt(s, level, WS1_IP_MULTICAST_TTL, optval, optlen);
  194. break;
  195. case IP_MULTICAST_LOOP:
  196. success = setsockopt(s, level, WS1_IP_MULTICAST_LOOP, optval, optlen);
  197. break;
  198. case IP_ADD_MEMBERSHIP: 
  199. success = setsockopt(s, level, WS1_IP_ADD_MEMBERSHIP, optval, optlen);
  200. break;
  201. case IP_DROP_MEMBERSHIP: 
  202. success = setsockopt(s, level, WS1_IP_DROP_MEMBERSHIP, optval, optlen);
  203. break;
  204. }
  205. if (success != -1) {
  206. return success;
  207. }
  208. return setsockopt(s, level, optname, optval, optlen);
  209. }
  210. #endif
  212. #ifdef NEED_INET_ATON
  213. #ifdef NEED_INET_ATON_STATIC
  214. static 
  215. #endif
  216. int inet_aton(const char *name, struct in_addr *addr)
  217. {
  218. addr->s_addr = inet_addr(name);
  219. return (addr->s_addr != (in_addr_t) INADDR_NONE);
  220. }
  221. #endif
  223. #ifdef NEED_IN6_IS_ADDR_MULTICAST
  224. #define IN6_IS_ADDR_MULTICAST(addr) ((addr)->s6_addr[0] == 0xffU)
  225. #endif
  227. #if defined(NEED_IN6_IS_ADDR_UNSPECIFIED) && defined(MUSICA_IPV6)
  228. #define IN6_IS_ADDR_UNSPECIFIED(addr) IS_UNSPEC_IN6_ADDR(*addr)
  229. #endif
  233. /*****************************************************************************/
  234. /* IPv4 specific functions...                                                */
  235. /*****************************************************************************/
  237. static int udp_addr_valid4(const char *dst)
  238. {
  239.         struct in_addr addr4;
  240. struct hostent *h;
  242. if (inet_pton(AF_INET, dst, &addr4)) {
  243. return TRUE;
  244. } 
  246. h = gethostbyname(dst);
  247. if (h != NULL) {
  248. return TRUE;
  249. }
  250. socket_error("Can't resolve IP address for %s", dst);
  252.         return FALSE;
  253. }
  255. static socket_udp *udp_init4(const char *addr, const char *iface, uint16_t rx_port, uint16_t tx_port, int ttl)
  256. {
  257. int                   reuse = 1;
  258. struct sockaddr_in    s_in;
  259. struct in_addr  iface_addr;
  260. #ifdef WIN32
  261. int recv_buf_size = 65536;
  262. #endif
  263. socket_udp          *s = (socket_udp *)malloc(sizeof(socket_udp));
  264. s->mode    = IPv4;
  265. s->addr    = NULL;
  266. s->rx_port = rx_port;
  267. s->tx_port = tx_port;
  268. s->ttl     = ttl;
  269. if (inet_pton(AF_INET, addr, &s->addr4) != 1) {
  270. struct hostent *h = gethostbyname(addr);
  271. if (h == NULL) {
  272. socket_error("Can't resolve IP address for %s", addr);
  273.                         free(s);
  274. return NULL;
  275. }
  276. memcpy(&(s->addr4), h->h_addr_list[0], sizeof(s->addr4));
  277. }
  278. if (iface != NULL) {
  279. if (inet_pton(AF_INET, iface, &iface_addr) != 1) {
  280. rtp_message(LOG_ERR, "Illegal interface specification");
  281.                         free(s);
  282. return NULL;
  283. }
  284. } else {
  285. iface_addr.s_addr = 0;
  286. }
  287. s->fd = socket(AF_INET, SOCK_DGRAM, 0);
  288. if (s->fd < 0) {
  289. socket_error("socket");
  290. return NULL;
  291. }
  292. #ifdef WIN32
  293. if (SETSOCKOPT(s->fd, SOL_SOCKET, SO_RCVBUF, (char *)&recv_buf_size, sizeof(int)) != 0) {
  294.   socket_error("setsockopt SO_RCVBUF");
  295.   return NULL;
  296. }
  297. #endif
  299. if (SETSOCKOPT(s->fd, SOL_SOCKET, SO_REUSEADDR, (char *) &reuse, sizeof(reuse)) != 0) {
  300. socket_error("setsockopt SO_REUSEADDR");
  301. return NULL;
  302. }
  303. #ifdef SO_REUSEPORT
  304. if (SETSOCKOPT(s->fd, SOL_SOCKET, SO_REUSEPORT, (char *) &reuse, sizeof(reuse)) != 0) {
  305. socket_error("setsockopt SO_REUSEPORT");
  306. return NULL;
  307. }
  308. #endif
  309. s_in.sin_family      = AF_INET;
  310. s_in.sin_addr.s_addr = INADDR_ANY;
  311. s_in.sin_port        = htons(rx_port);
  312. if (bind(s->fd, (struct sockaddr *) &s_in, sizeof(s_in)) != 0) {
  313. socket_error("bind: port %d", rx_port);
  314. return NULL;
  315. }
  316. if (IN_MULTICAST(ntohl(s->addr4.s_addr))) {
  317. char            loop = 1;
  318. struct ip_mreq  imr;
  320. imr.imr_multiaddr.s_addr = s->addr4.s_addr;
  321. imr.imr_interface.s_addr = iface_addr.s_addr;
  323. if (SETSOCKOPT(s->fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) &imr, sizeof(struct ip_mreq)) != 0) {
  324. socket_error("setsockopt IP_ADD_MEMBERSHIP");
  325. return NULL;
  326. }
  327. #ifndef WIN32
  328. if (SETSOCKOPT(s->fd, IPPROTO_IP, IP_MULTICAST_LOOP, &loop, sizeof(loop)) != 0) {
  329. socket_error("setsockopt IP_MULTICAST_LOOP");
  330. return NULL;
  331. }
  332. #endif
  333. if (SETSOCKOPT(s->fd, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &s->ttl, sizeof(s->ttl)) != 0) {
  334. socket_error("setsockopt IP_MULTICAST_TTL");
  335. return NULL;
  336. }
  337. if (iface_addr.s_addr != 0) {
  338. if (SETSOCKOPT(s->fd, IPPROTO_IP, IP_MULTICAST_IF, (char *) &iface_addr, sizeof(iface_addr)) != 0) {
  339. socket_error("setsockopt IP_MULTICAST_IF");
  340. return NULL;
  341. }
  342. }
  343. }
  344.         s->addr = strdup(addr);
  345. return s;
  346. }
  348. static void udp_exit4(socket_udp *s)
  349. {
  350. if (IN_MULTICAST(ntohl(s->addr4.s_addr))) {
  351. struct ip_mreq  imr;
  352. imr.imr_multiaddr.s_addr = s->addr4.s_addr;
  353. imr.imr_interface.s_addr = INADDR_ANY;
  354. if (SETSOCKOPT(s->fd, IPPROTO_IP, IP_DROP_MEMBERSHIP, (char *) &imr, sizeof(struct ip_mreq)) != 0) {
  355. socket_error("setsockopt IP_DROP_MEMBERSHIP");
  356. abort();
  357. }
  358. rtp_message(LOG_INFO,  "Dropped membership of multicast group");
  359. }
  360. close(s->fd);
  361.         free(s->addr);
  362. free(s);
  363. }
  365. static int udp_send4(socket_udp *s, uint8_t *buffer, int buflen)
  366. {
  367. struct sockaddr_in s_in;
  369. ASSERT(s != NULL);
  370. ASSERT(s->mode == IPv4);
  371. ASSERT(buffer != NULL);
  372. ASSERT(buflen > 0);
  374. s_in.sin_family      = AF_INET;
  375. s_in.sin_addr.s_addr = s->addr4.s_addr;
  376. s_in.sin_port        = htons(s->tx_port);
  377. return sendto(s->fd, buffer, buflen, 0, (struct sockaddr *) &s_in, sizeof(s_in));
  378. }
  380. #ifndef _WIN32
  381. static int udp_send_iov4(socket_udp *s, struct iovec *iov, int count)
  382. {
  383. struct sockaddr_in s_in;
  384. struct msghdr  msg;
  386. ASSERT(s != NULL);
  387. ASSERT(s->mode == IPv4);
  388. ASSERT(iov != NULL);
  389. ASSERT(count > 0);
  391. s_in.sin_family      = AF_INET;
  392. s_in.sin_addr.s_addr = s->addr4.s_addr;
  393. s_in.sin_port        = htons(s->tx_port);
  395. memset(&msg, 0, sizeof(msg));
  396. msg.msg_name   = (void *)&s_in;
  397. msg.msg_namelen   = sizeof(s_in);
  398. msg.msg_iov   = iov;
  399. msg.msg_iovlen   = count;
  401. return sendmsg(s->fd, &msg, 0);
  402. }
  403. #endif
  405. static char *udp_host_addr4(void)
  406. {
  407.   char      hname[MAXHOSTNAMELEN];
  408.   struct hostent  *hent;
  409.   struct in_addr    iaddr;
  411. if (gethostname(hname, MAXHOSTNAMELEN) != 0) {
  412. rtp_message(LOG_ERR, "Cannot get hostname!");
  413. abort();
  414. }
  415. hent = gethostbyname(hname);
  416. if (hent == NULL) {
  417. socket_error("Can't resolve IP address for %s", hname);
  418. return NULL;
  419. }
  420. ASSERT(hent->h_addrtype == AF_INET);
  421. memcpy(&iaddr.s_addr, hent->h_addr, sizeof(iaddr.s_addr));
  422. strncpy(hname, inet_ntoa(iaddr), MAXHOSTNAMELEN);
  423. return xstrdup(hname);
  424. }
  426. /*****************************************************************************/
  427. /* IPv6 specific functions...                                                */
  428. /*****************************************************************************/
  430. static int udp_addr_valid6(const char *dst)
  431. {
  432. #ifdef HAVE_IPv6
  433.         struct in6_addr addr6;
  434. switch (inet_pton(AF_INET6, dst, &addr6)) {
  435.         case 1:  
  436.                 return TRUE;
  437.                 break;
  438.         case 0: 
  439.                 return FALSE;
  440.                 break;
  441.         case -1: 
  442.                 rtp_message(LOG_ERR, "inet_pton failed");
  443.                 errno = 0;
  444.         }
  445. #endif /* HAVE_IPv6 */
  446.         UNUSED(dst);
  447.         return FALSE;
  448. }
  450. static socket_udp *udp_init6(const char *addr, const char *iface, uint16_t rx_port, uint16_t tx_port, int ttl)
  451. {
  452. #ifdef HAVE_IPv6
  453. int                 reuse = 1;
  454. struct sockaddr_in6 s_in;
  455. socket_udp         *s = (socket_udp *) malloc(sizeof(socket_udp));
  456. s->mode    = IPv6;
  457. s->addr    = NULL;
  458. s->rx_port = rx_port;
  459. s->tx_port = tx_port;
  460. s->ttl     = ttl;
  462. if (iface != NULL) {
  463. debug_msg("Not yet implementedn");
  464. abort();
  465. }
  467. if (inet_pton(AF_INET6, addr, &s->addr6) != 1) {
  468. /* We should probably try to do a DNS lookup on the name */
  469. /* here, but I'm trying to get the basics going first... */
  470. debug_msg("IPv6 address conversion failedn");
  471.                 free(s);
  472. return NULL;
  473. }
  474. s->fd = socket(AF_INET6, SOCK_DGRAM, 0);
  475. if (s->fd < 0) {
  476. socket_error("socket");
  477. return NULL;
  478. }
  479. if (SETSOCKOPT(s->fd, SOL_SOCKET, SO_REUSEADDR, (char *) &reuse, sizeof(reuse)) != 0) {
  480. socket_error("setsockopt SO_REUSEADDR");
  481. return NULL;
  482. }
  483. #ifdef SO_REUSEPORT
  484. if (SETSOCKOPT(s->fd, SOL_SOCKET, SO_REUSEPORT, (char *) &reuse, sizeof(reuse)) != 0) {
  485. socket_error("setsockopt SO_REUSEPORT");
  486. return NULL;
  487. }
  488. #endif
  490. memset((char *)&s_in, 0, sizeof(s_in));
  491. s_in.sin6_family = AF_INET6;
  492. s_in.sin6_port   = htons(rx_port);
  493. #ifdef HAVE_SIN6_LEN
  494. s_in.sin6_len    = sizeof(s_in);
  495. #endif
  496. s_in.sin6_addr = in6addr_any;
  497. if (bind(s->fd, (struct sockaddr *) &s_in, sizeof(s_in)) != 0) {
  498. socket_error("bind");
  499. return NULL;
  500. }
  502. if (IN6_IS_ADDR_MULTICAST(&(s->addr6))) {
  503. unsigned int      loop = 1;
  504. struct ipv6_mreq  imr;
  505. #ifdef MUSICA_IPV6
  506. imr.i6mr_interface = 1;
  507. imr.i6mr_multiaddr = s->addr6;
  508. #else
  509. imr.ipv6mr_multiaddr = s->addr6;
  510. imr.ipv6mr_interface = 0;
  511. #endif
  513. if (SETSOCKOPT(s->fd, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, (char *) &imr, sizeof(struct ipv6_mreq)) != 0) {
  514. socket_error("setsockopt IPV6_ADD_MEMBERSHIP");
  515. return NULL;
  516. }
  518. if (SETSOCKOPT(s->fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *) &loop, sizeof(loop)) != 0) {
  519. socket_error("setsockopt IPV6_MULTICAST_LOOP");
  520. return NULL;
  521. }
  522. if (SETSOCKOPT(s->fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *) &ttl, sizeof(ttl)) != 0) {
  523. socket_error("setsockopt IPV6_MULTICAST_HOPS");
  524. return NULL;
  525. }
  526. }
  528. ASSERT(s != NULL);
  530.         s->addr = strdup(addr);
  531. return s;
  532. #else
  533. UNUSED(addr);
  534. UNUSED(iface);
  535. UNUSED(rx_port);
  536. UNUSED(tx_port);
  537. UNUSED(ttl);
  538. return NULL;
  539. #endif
  540. }
  542. static void udp_exit6(socket_udp *s)
  543. {
  544. #ifdef HAVE_IPv6
  545. if (IN6_IS_ADDR_MULTICAST(&(s->addr6))) {
  546. struct ipv6_mreq  imr;
  547. #ifdef MUSICA_IPV6
  548. imr.i6mr_interface = 1;
  549. imr.i6mr_multiaddr = s->addr6;
  550. #else
  551. imr.ipv6mr_multiaddr = s->addr6;
  552. imr.ipv6mr_interface = 0;
  553. #endif
  555. if (SETSOCKOPT(s->fd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, (char *) &imr, sizeof(struct ipv6_mreq)) != 0) {
  556. socket_error("setsockopt IPV6_DROP_MEMBERSHIP");
  557. abort();
  558. }
  559. }
  560. close(s->fd);
  561.         free(s->addr);
  562. free(s);
  563. #else
  564. UNUSED(s);
  565. #endif  /* HAVE_IPv6 */
  566. }
  568. static int udp_send6(socket_udp *s, uint8_t *buffer, int buflen)
  569. {
  570. #ifdef HAVE_IPv6
  571. struct sockaddr_in6 s_in;
  573. ASSERT(s != NULL);
  574. ASSERT(s->mode == IPv6);
  575. ASSERT(buffer != NULL);
  576. ASSERT(buflen > 0);
  578. memset((char *)&s_in, 0, sizeof(s_in));
  579. s_in.sin6_family = AF_INET6;
  580. s_in.sin6_addr   = s->addr6;
  581. s_in.sin6_port   = htons(s->tx_port);
  582. #ifdef HAVE_SIN6_LEN
  583. s_in.sin6_len    = sizeof(s_in);
  584. #endif
  585. return sendto(s->fd, buffer, buflen, 0, (struct sockaddr *) &s_in, sizeof(s_in));
  586. #else
  587. UNUSED(s);
  588. UNUSED(buffer);
  589. UNUSED(buflen);
  590. return -1;
  591. #endif
  592. }
  594. #ifndef _WIN32
  595. static int udp_send_iov6(socket_udp *s, struct iovec *iov, int count)
  596. {
  597. #ifdef HAVE_IPv6
  598. struct sockaddr_in6 s_in;
  599. struct msghdr msg;
  601. ASSERT(s != NULL);
  602. ASSERT(s->mode == IPv6);
  604. memset((char *)&s_in, 0, sizeof(s_in));
  605. s_in.sin6_family = AF_INET6;
  606. s_in.sin6_addr   = s->addr6;
  607. s_in.sin6_port   = htons(s->tx_port);
  608. #ifdef HAVE_SIN6_LEN
  609. s_in.sin6_len    = sizeof(s_in);
  610. #endif
  612. msg.msg_name   = &s_in;
  613. msg.msg_namelen   = sizeof(s_in);
  614. msg.msg_iov   = iov;
  615. msg.msg_iovlen   = count;
  616. msg.msg_control   = NULL;
  617. msg.msg_controllen   = 0;
  618. msg.msg_flags   = 0;
  620. return sendmsg(s->fd, &msg, 0);
  621. #else
  622. UNUSED(s);
  623. UNUSED(iov);
  624. UNUSED(count);
  625. return -1;
  626. #endif
  627. }
  628. #endif
  630. static char *udp_host_addr6(socket_udp *s)
  631. {
  632. #ifdef HAVE_IPv6
  633. char  hname[MAXHOSTNAMELEN];
  634. int   gai_err, newsock;
  635. struct addrinfo   hints, *ai;
  636. struct sockaddr_in6   local, addr6;
  637. int len = sizeof(local), result = 0;
  639. newsock=socket(AF_INET6, SOCK_DGRAM,0);
  640.     memset ((char *)&addr6, 0, len);
  641.     addr6.sin6_family = AF_INET6;
  642. #ifdef HAVE_SIN6_LEN
  643.     addr6.sin6_len    = len;
  644. #endif
  645.     bind (newsock, (struct sockaddr *) &addr6, len);
  646.     addr6.sin6_addr = s->addr6;
  647.     addr6.sin6_port = htons (s->rx_port);
  648.     connect (newsock, (struct sockaddr *) &addr6, len);
  650.     memset ((char *)&local, 0, len);
  651. if ((result = getsockname(newsock,(struct sockaddr *)&local, &len)) < 0){
  652. local.sin6_addr = in6addr_any;
  653. local.sin6_port = 0;
  654. debug_msg("getsockname failedn");
  655. }
  657. close (newsock);
  659. if (IN6_IS_ADDR_UNSPECIFIED(&local.sin6_addr) || IN6_IS_ADDR_MULTICAST(&local.sin6_addr)) {
  660. if (gethostname(hname, MAXHOSTNAMELEN) != 0) {
  661. debug_msg("gethostname failedn");
  662. abort();
  663. }
  665. hints.ai_protocol  = 0;
  666. hints.ai_flags     = 0;
  667. hints.ai_family    = AF_INET6;
  668. hints.ai_socktype  = SOCK_DGRAM;
  669. hints.ai_addrlen   = 0;
  670. hints.ai_canonname = NULL;
  671. hints.ai_addr      = NULL;
  672. hints.ai_next      = NULL;
  674. if ((gai_err = getaddrinfo(hname, NULL, &hints, &ai))) {
  675. debug_msg("getaddrinfo: %s: %sn", hname, gai_strerror(gai_err));
  676. abort();
  677. }
  679. if (inet_ntop(AF_INET6, &(((struct sockaddr_in6 *)(ai->ai_addr))->sin6_addr), hname, MAXHOSTNAMELEN) == NULL) {
  680. debug_msg("inet_ntop: %s: n", hname);
  681. abort();
  682. }
  683. freeaddrinfo(ai);
  684. return xstrdup(hname);
  685. }
  686. if (inet_ntop(AF_INET6, &local.sin6_addr, hname, MAXHOSTNAMELEN) == NULL) {
  687. debug_msg("inet_ntop: %s: n", hname);
  688. abort();
  689. }
  690. return xstrdup(hname);
  691. #else  /* HAVE_IPv6 */
  692. UNUSED(s);
  693. return xstrdup("::"); /* The unspecified address... */
  694. #endif /* HAVE_IPv6 */
  695. }
  697. /*****************************************************************************/
  698. /* Generic functions, which call the appropriate protocol specific routines. */
  699. /*****************************************************************************/
  701. /**
  702.  * udp_addr_valid:
  703.  * @addr: string representation of IPv4 or IPv6 network address.
  704.  *
  705.  * Returns TRUE if @addr is valid, FALSE otherwise.
  706.  **/
  708. int udp_addr_valid(const char *addr)
  709. {
  710.         return udp_addr_valid4(addr) | udp_addr_valid6(addr);
  711. }
  713. /**
  714.  * udp_init:
  715.  * @addr: character string containing an IPv4 or IPv6 network address.
  716.  * @rx_port: receive port.
  717.  * @tx_port: transmit port.
  718.  * @ttl: time-to-live value for transmitted packets.
  719.  *
  720.  * Creates a session for sending and receiving UDP datagrams over IP
  721.  * networks. 
  722.  *
  723.  * Returns: a pointer to a valid socket_udp structure on success, NULL otherwise.
  724.  **/
  725. socket_udp *udp_init(const char *addr, uint16_t rx_port, uint16_t tx_port, int ttl)
  726. {
  727. return udp_init_if(addr, NULL, rx_port, tx_port, ttl);
  728. }
  730. /**
  731.  * udp_init_if:
  732.  * @addr: character string containing an IPv4 or IPv6 network address.
  733.  * @iface: character string containing an interface name.
  734.  * @rx_port: receive port.
  735.  * @tx_port: transmit port.
  736.  * @ttl: time-to-live value for transmitted packets.
  737.  *
  738.  * Creates a session for sending and receiving UDP datagrams over IP
  739.  * networks.  The session uses @iface as the interface to send and
  740.  * receive datagrams on.
  741.  * 
  742.  * Return value: a pointer to a socket_udp structure on success, NULL otherwise.
  743.  **/
  744. socket_udp *udp_init_if(const char *addr, const char *iface, uint16_t rx_port, uint16_t tx_port, int ttl)
  745. {
  746. socket_udp *res;
  748. if (strchr(addr, ':') == NULL) {
  749. res = udp_init4(addr, iface, rx_port, tx_port, ttl);
  750. } else {
  751. res = udp_init6(addr, iface, rx_port, tx_port, ttl);
  752. }
  753. return res;
  754. }
  756. /**
  757.  * udp_exit:
  758.  * @s: UDP session to be terminated.
  759.  *
  760.  * Closes UDP session.
  761.  * 
  762.  **/
  763. void udp_exit(socket_udp *s)
  764. {
  765.     switch(s->mode) {
  766.     case IPv4 : udp_exit4(s); break;
  767.     case IPv6 : udp_exit6(s); break;
  768.     default   : abort();
  769.     }
  770. }
  772. /**
  773.  * udp_send:
  774.  * @s: UDP session.
  775.  * @buffer: pointer to buffer to be transmitted.
  776.  * @buflen: length of @buffer.
  777.  * 
  778.  * Transmits a UDP datagram containing data from @buffer.
  779.  * 
  780.  * Return value: 0 on success, -1 on failure.
  781.  **/
  782. int udp_send(socket_udp *s, uint8_t *buffer, int buflen)
  783. {
  784. switch (s->mode) {
  785. case IPv4 : return udp_send4(s, buffer, buflen);
  786. case IPv6 : return udp_send6(s, buffer, buflen);
  787. default   : abort(); /* Yuk! */
  788. }
  789. return -1;
  790. }
  792. #ifndef _WIN32
  793. int udp_send_iov(socket_udp *s, struct iovec *iov, int count)
  794. {
  795. switch (s->mode) {
  796. case IPv4 : return udp_send_iov4(s, iov, count);
  797. case IPv6 : return udp_send_iov6(s, iov, count);
  798. default   : abort();
  799. }
  800. return -1;
  801. }
  802. #endif
  804. /**
  805.  * udp_recv:
  806.  * @s: UDP session.
  807.  * @buffer: buffer to read data into.
  808.  * @buflen: length of @buffer.
  809.  * 
  810.  * Reads from datagram queue associated with UDP session.
  811.  *
  812.  * Return value: number of bytes read, returns 0 if no data is available.
  813.  **/
  814. int udp_recv(socket_udp *s, uint8_t *buffer, int buflen)
  815. {
  816. /* Reads data into the buffer, returning the number of bytes read.   */
  817. /* If no data is available, this returns the value zero immediately. */
  818. /* Note: since we don't care about the source address of the packet  */
  819. /* we receive, this function becomes protocol independent.           */
  820. int len;
  822. ASSERT(buffer != NULL);
  823. ASSERT(buflen > 0);
  825. len = recvfrom(s->fd, buffer, buflen, 0, 0, 0);
  826. if (len > 0) {
  827. return len;
  828. }
  829. if (errno != ECONNREFUSED) {
  830. socket_error("recvfrom");
  831. }
  832. return 0;
  833. }
  835. static fd_set rfd;
  836. static fd_t max_fd;
  838. /**
  839.  * udp_fd_zero:
  840.  * 
  841.  * Clears file descriptor from set associated with UDP sessions (see select(2)).
  842.  * 
  843.  **/
  844. void udp_fd_zero(void)
  845. {
  846. FD_ZERO(&rfd);
  847. max_fd = 0;
  848. }
  850. /**
  851.  * udp_fd_set:
  852.  * @s: UDP session.
  853.  * 
  854.  * Adds file descriptor associated of @s to set associated with UDP sessions.
  855.  **/
  856. void udp_fd_set(socket_udp *s)
  857. {
  858. FD_SET(s->fd, &rfd);
  859. if (s->fd > (fd_t)max_fd) {
  860. max_fd = s->fd;
  861. }
  862. }
  864. /**
  865.  * udp_fd_isset:
  866.  * @s: UDP session.
  867.  * 
  868.  * Checks if file descriptor associated with UDP session is ready for
  869.  * reading.  This function should be called after udp_select().
  870.  *
  871.  * Returns: non-zero if set, zero otherwise.
  872.  **/
  873. int udp_fd_isset(socket_udp *s)
  874. {
  875. return FD_ISSET(s->fd, &rfd);
  876. }
  878. /**
  879.  * udp_select:
  880.  * @timeout: maximum period to wait for data to arrive.
  881.  * 
  882.  * Waits for data to arrive for UDP sessions.
  883.  * 
  884.  * Return value: number of UDP sessions ready for reading.
  885.  **/
  886. int udp_select(struct timeval *timeout)
  887. {
  888. return select(max_fd + 1, &rfd, NULL, NULL, timeout);
  889. }
  891. /**
  892.  * udp_host_addr:
  893.  * @s: UDP session.
  894.  * 
  895.  * Return value: character string containing network address
  896.  * associated with session @s.
  897.  **/
  898. char *udp_host_addr(socket_udp *s)
  899. {
  900.   if (s && s->mode == IPv6) {
  901.     return udp_host_addr6(s);
  902.   } 
  903.   return udp_host_addr4();
  904. }
  906. /**
  907.  * udp_fd:
  908.  * @s: UDP session.
  909.  * 
  910.  * This function allows applications to apply their own socketopt()'s
  911.  * and ioctl()'s to the UDP session.
  912.  * 
  913.  * Return value: file descriptor of socket used by session @s.
  914.  **/
  915. int udp_fd(socket_udp *s)
  916. {
  917. if (s && s->fd > 0) {
  918. return s->fd;
  919. } 
  920. return 0;
  921. }