[mirror_frr.git] / lib / sockunion.c

/* Socket union related function.
 * Copyright (c) 1997, 98 Kunihiro Ishiguro
 *
 * This file is part of GNU Zebra.
 *
 * GNU Zebra 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, or (at your option) any
 * later version.
 *
 * GNU Zebra 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 GNU Zebra; see the file COPYING.  If not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.  
 */

#include <zebra.h>

#include "prefix.h"
#include "vty.h"
#include "sockunion.h"
#include "memory.h"
#include "str.h"
#include "log.h"

#ifndef HAVE_INET_ATON
int
inet_aton (const char *cp, struct in_addr *inaddr)
{
  int dots = 0;
  register u_long addr = 0;
  register u_long val = 0, base = 10;

  do
    {
      register char c = *cp;

      switch (c)
	{
	case '0': case '1': case '2': case '3': case '4': case '5':
	case '6': case '7': case '8': case '9':
	  val = (val * base) + (c - '0');
	  break;
	case '.':
	  if (++dots > 3)
	    return 0;
	case '\0':
	  if (val > 255)
	    return 0;
	  addr = addr << 8 | val;
	  val = 0;
	  break;
	default:
	  return 0;
	}
    } while (*cp++) ;

  if (dots < 3)
    addr <<= 8 * (3 - dots);
  if (inaddr)
    inaddr->s_addr = htonl (addr);
  return 1;
}
#endif /* ! HAVE_INET_ATON */


#ifndef HAVE_INET_PTON
int
inet_pton (int family, const char *strptr, void *addrptr)
{
  if (family == AF_INET)
    {
      struct in_addr in_val;

      if (inet_aton (strptr, &in_val))
	{
	  memcpy (addrptr, &in_val, sizeof (struct in_addr));
	  return 1;
	}
      return 0;
    }
  errno = EAFNOSUPPORT;
  return -1;
}
#endif /* ! HAVE_INET_PTON */

#ifndef HAVE_INET_NTOP
const char *
inet_ntop (int family, const void *addrptr, char *strptr, size_t len)
{
  unsigned char *p = (unsigned char *) addrptr;

  if (family == AF_INET) 
    {
      char temp[INET_ADDRSTRLEN];

      snprintf(temp, sizeof(temp), "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);

      if (strlen(temp) >= len) 
	{
	  errno = ENOSPC;
	  return NULL;
	}
      strcpy(strptr, temp);
      return strptr;
    }

  errno = EAFNOSUPPORT;
  return NULL;
}
#endif /* ! HAVE_INET_NTOP */

const char *
inet_sutop (union sockunion *su, char *str)
{
  switch (su->sa.sa_family)
    {
    case AF_INET:
      inet_ntop (AF_INET, &su->sin.sin_addr, str, INET_ADDRSTRLEN);
      break;
#ifdef HAVE_IPV6
    case AF_INET6:
      inet_ntop (AF_INET6, &su->sin6.sin6_addr, str, INET6_ADDRSTRLEN);
      break;
#endif /* HAVE_IPV6 */
    }
  return str;
}

int
str2sockunion (const char *str, union sockunion *su)
{
  int ret;

  memset (su, 0, sizeof (union sockunion));

  ret = inet_pton (AF_INET, str, &su->sin.sin_addr);
  if (ret > 0)			/* Valid IPv4 address format. */
    {
      su->sin.sin_family = AF_INET;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
      su->sin.sin_len = sizeof(struct sockaddr_in);
#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
      return 0;
    }
#ifdef HAVE_IPV6
  ret = inet_pton (AF_INET6, str, &su->sin6.sin6_addr);
  if (ret > 0)			/* Valid IPv6 address format. */
    {
      su->sin6.sin6_family = AF_INET6;
#ifdef SIN6_LEN
      su->sin6.sin6_len = sizeof(struct sockaddr_in6);
#endif /* SIN6_LEN */
      return 0;
    }
#endif /* HAVE_IPV6 */
  return -1;
}

const char *
sockunion2str (union sockunion *su, char *buf, size_t len)
{
  if  (su->sa.sa_family == AF_INET)
    return inet_ntop (AF_INET, &su->sin.sin_addr, buf, len);
#ifdef HAVE_IPV6
  else if (su->sa.sa_family == AF_INET6)
    return inet_ntop (AF_INET6, &su->sin6.sin6_addr, buf, len);
#endif /* HAVE_IPV6 */
  return NULL;
}

union sockunion *
sockunion_str2su (const char *str)
{
  int ret;
  union sockunion *su;

  su = XMALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
  memset (su, 0, sizeof (union sockunion));

  ret = inet_pton (AF_INET, str, &su->sin.sin_addr);
  if (ret > 0)			/* Valid IPv4 address format. */
    {
      su->sin.sin_family = AF_INET;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
      su->sin.sin_len = sizeof(struct sockaddr_in);
#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
      return su;
    }
#ifdef HAVE_IPV6
  ret = inet_pton (AF_INET6, str, &su->sin6.sin6_addr);
  if (ret > 0)			/* Valid IPv6 address format. */
    {
      su->sin6.sin6_family = AF_INET6;
#ifdef SIN6_LEN
      su->sin6.sin6_len = sizeof(struct sockaddr_in6);
#endif /* SIN6_LEN */
      return su;
    }
#endif /* HAVE_IPV6 */

  XFREE (MTYPE_SOCKUNION, su);
  return NULL;
}

char *
sockunion_su2str (union sockunion *su)
{
  char str[SU_ADDRSTRLEN];

  switch (su->sa.sa_family)
    {
    case AF_INET:
      inet_ntop (AF_INET, &su->sin.sin_addr, str, sizeof (str));
      break;
#ifdef HAVE_IPV6
    case AF_INET6:
      inet_ntop (AF_INET6, &su->sin6.sin6_addr, str, sizeof (str));
      break;
#endif /* HAVE_IPV6 */
    }
  return XSTRDUP (MTYPE_TMP, str);
}

/* Return socket of sockunion. */
int
sockunion_socket (union sockunion *su)
{
  int sock;

  sock = socket (su->sa.sa_family, SOCK_STREAM, 0);
  if (sock < 0)
    {
      zlog (NULL, LOG_WARNING, "Can't make socket : %s", safe_strerror (errno));
      return -1;
    }

  return sock;
}

/* Return accepted new socket file descriptor. */
int
sockunion_accept (int sock, union sockunion *su)
{
  socklen_t len;
  int client_sock;

  len = sizeof (union sockunion);
  client_sock = accept (sock, (struct sockaddr *) su, &len);
  
  /* Convert IPv4 compatible IPv6 address to IPv4 address. */
#ifdef HAVE_IPV6
  if (su->sa.sa_family == AF_INET6)
    {
      if (IN6_IS_ADDR_V4MAPPED (&su->sin6.sin6_addr))
	{
	  struct sockaddr_in sin;

	  memset (&sin, 0, sizeof (struct sockaddr_in));
	  sin.sin_family = AF_INET;
	  memcpy (&sin.sin_addr, ((char *)&su->sin6.sin6_addr) + 12, 4);
	  memcpy (su, &sin, sizeof (struct sockaddr_in));
	}
    }
#endif /* HAVE_IPV6 */

  return client_sock;
}

/* Return sizeof union sockunion.  */
static int
sockunion_sizeof (union sockunion *su)
{
  int ret;

  ret = 0;
  switch (su->sa.sa_family)
    {
    case AF_INET:
      ret = sizeof (struct sockaddr_in);
      break;
#ifdef HAVE_IPV6
    case AF_INET6:
      ret = sizeof (struct sockaddr_in6);
      break;
#endif /* AF_INET6 */
    }
  return ret;
}

/* return sockunion structure : this function should be revised. */
static char *
sockunion_log (union sockunion *su)
{
  static char buf[SU_ADDRSTRLEN];

  switch (su->sa.sa_family) 
    {
    case AF_INET:
      snprintf (buf, SU_ADDRSTRLEN, "%s", inet_ntoa (su->sin.sin_addr));
      break;
#ifdef HAVE_IPV6
    case AF_INET6:
      snprintf (buf, SU_ADDRSTRLEN, "%s",
		inet_ntop (AF_INET6, &(su->sin6.sin6_addr), buf, SU_ADDRSTRLEN));
      break;
#endif /* HAVE_IPV6 */
    default:
      snprintf (buf, SU_ADDRSTRLEN, "af_unknown %d ", su->sa.sa_family);
      break;
    }
  return (XSTRDUP (MTYPE_TMP, buf));
}

/* sockunion_connect returns
   -1 : error occured
   0 : connect success
   1 : connect is in progress */
enum connect_result
sockunion_connect (int fd, union sockunion *peersu, unsigned short port,
		   unsigned int ifindex)
{
  int ret;
  int val;
  union sockunion su;

  memcpy (&su, peersu, sizeof (union sockunion));

  switch (su.sa.sa_family)
    {
    case AF_INET:
      su.sin.sin_port = port;
      break;
#ifdef HAVE_IPV6
    case AF_INET6:
      su.sin6.sin6_port  = port;
#ifdef KAME
      if (IN6_IS_ADDR_LINKLOCAL(&su.sin6.sin6_addr) && ifindex)
	{
#ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
	  /* su.sin6.sin6_scope_id = ifindex; */
#ifdef MUSICA
	  su.sin6.sin6_scope_id = ifindex; 
#endif
#endif /* HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID */
#ifndef MUSICA
	  SET_IN6_LINKLOCAL_IFINDEX (su.sin6.sin6_addr, ifindex);
#endif
	}
#endif /* KAME */
      break;
#endif /* HAVE_IPV6 */
    }      

  /* Make socket non-block. */
  val = fcntl (fd, F_GETFL, 0);
  fcntl (fd, F_SETFL, val|O_NONBLOCK);

  /* Call connect function. */
  ret = connect (fd, (struct sockaddr *) &su, sockunion_sizeof (&su));

  /* Immediate success */
  if (ret == 0)
    {
      fcntl (fd, F_SETFL, val);
      return connect_success;
    }

  /* If connect is in progress then return 1 else it's real error. */
  if (ret < 0)
    {
      if (errno != EINPROGRESS)
	{
	  zlog_info ("can't connect to %s fd %d : %s",
		     sockunion_log (&su), fd, safe_strerror (errno));
	  return connect_error;
	}
    }

  fcntl (fd, F_SETFL, val);

  return connect_in_progress;
}

/* Make socket from sockunion union. */
int
sockunion_stream_socket (union sockunion *su)
{
  int sock;

  if (su->sa.sa_family == 0)
    su->sa.sa_family = AF_INET_UNION;

  sock = socket (su->sa.sa_family, SOCK_STREAM, 0);

  if (sock < 0)
    zlog (NULL, LOG_WARNING, "can't make socket sockunion_stream_socket");

  return sock;
}

/* Bind socket to specified address. */
int
sockunion_bind (int sock, union sockunion *su, unsigned short port, 
		union sockunion *su_addr)
{
  int size = 0;
  int ret;

  if (su->sa.sa_family == AF_INET)
    {
      size = sizeof (struct sockaddr_in);
      su->sin.sin_port = htons (port);
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
      su->sin.sin_len = size;
#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
      if (su_addr == NULL)
	su->sin.sin_addr.s_addr = htonl (INADDR_ANY);
    }
#ifdef HAVE_IPV6
  else if (su->sa.sa_family == AF_INET6)
    {
      size = sizeof (struct sockaddr_in6);
      su->sin6.sin6_port = htons (port);
#ifdef SIN6_LEN
      su->sin6.sin6_len = size;
#endif /* SIN6_LEN */
      if (su_addr == NULL)
	{
#if defined(LINUX_IPV6) || defined(NRL)
	  memset (&su->sin6.sin6_addr, 0, sizeof (struct in6_addr));
#else
	  su->sin6.sin6_addr = in6addr_any;
#endif /* LINUX_IPV6 */
	}
    }
#endif /* HAVE_IPV6 */
  

  ret = bind (sock, (struct sockaddr *)su, size);
  if (ret < 0)
    zlog (NULL, LOG_WARNING, "can't bind socket : %s", safe_strerror (errno));

  return ret;
}

int
sockopt_reuseaddr (int sock)
{
  int ret;
  int on = 1;

  ret = setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, 
		    (void *) &on, sizeof (on));
  if (ret < 0)
    {
      zlog (NULL, LOG_WARNING, "can't set sockopt SO_REUSEADDR to socket %d", sock);
      return -1;
    }
  return 0;
}

#ifdef SO_REUSEPORT
int
sockopt_reuseport (int sock)
{
  int ret;
  int on = 1;

  ret = setsockopt (sock, SOL_SOCKET, SO_REUSEPORT, 
		    (void *) &on, sizeof (on));
  if (ret < 0)
    {
      zlog (NULL, LOG_WARNING, "can't set sockopt SO_REUSEPORT to socket %d", sock);
      return -1;
    }
  return 0;
}
#else
int
sockopt_reuseport (int sock)
{
  return 0;
}
#endif /* 0 */

int
sockopt_ttl (int family, int sock, int ttl)
{
  int ret;

#ifdef IP_TTL
  if (family == AF_INET)
    {
      ret = setsockopt (sock, IPPROTO_IP, IP_TTL, 
			(void *) &ttl, sizeof (int));
      if (ret < 0)
	{
	  zlog (NULL, LOG_WARNING, "can't set sockopt IP_TTL %d to socket %d", ttl, sock);
	  return -1;
	}
      return 0;
    }
#endif /* IP_TTL */
#ifdef HAVE_IPV6
  if (family == AF_INET6)
    {
      ret = setsockopt (sock, IPPROTO_IPV6, IPV6_UNICAST_HOPS, 
			(void *) &ttl, sizeof (int));
      if (ret < 0)
	{
	  zlog (NULL, LOG_WARNING, "can't set sockopt IPV6_UNICAST_HOPS %d to socket %d",
		    ttl, sock);
	  return -1;
	}
      return 0;
    }
#endif /* HAVE_IPV6 */
  return 0;
}

/* If same family and same prefix return 1. */
int
sockunion_same (union sockunion *su1, union sockunion *su2)
{
  int ret = 0;

  if (su1->sa.sa_family != su2->sa.sa_family)
    return 0;

  switch (su1->sa.sa_family)
    {
    case AF_INET:
      ret = memcmp (&su1->sin.sin_addr, &su2->sin.sin_addr,
		    sizeof (struct in_addr));
      break;
#ifdef HAVE_IPV6
    case AF_INET6:
      ret = memcmp (&su1->sin6.sin6_addr, &su2->sin6.sin6_addr,
		    sizeof (struct in6_addr));
      break;
#endif /* HAVE_IPV6 */
    }
  if (ret == 0)
    return 1;
  else
    return 0;
}

/* After TCP connection is established.  Get local address and port. */
union sockunion *
sockunion_getsockname (int fd)
{
  int ret;
  socklen_t len;
  union
  {
    struct sockaddr sa;
    struct sockaddr_in sin;
#ifdef HAVE_IPV6
    struct sockaddr_in6 sin6;
#endif /* HAVE_IPV6 */
    char tmp_buffer[128];
  } name;
  union sockunion *su;

  memset (&name, 0, sizeof name);
  len = sizeof name;

  ret = getsockname (fd, (struct sockaddr *)&name, &len);
  if (ret < 0)
    {
      zlog_warn ("Can't get local address and port by getsockname: %s",
		 safe_strerror (errno));
      return NULL;
    }

  if (name.sa.sa_family == AF_INET)
    {
      su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
      memcpy (su, &name, sizeof (struct sockaddr_in));
      return su;
    }
#ifdef HAVE_IPV6
  if (name.sa.sa_family == AF_INET6)
    {
      su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
      memcpy (su, &name, sizeof (struct sockaddr_in6));

      if (IN6_IS_ADDR_V4MAPPED (&su->sin6.sin6_addr))
	{
	  struct sockaddr_in sin;

	  sin.sin_family = AF_INET;
	  memcpy (&sin.sin_addr, ((char *)&su->sin6.sin6_addr) + 12, 4);
	  sin.sin_port = su->sin6.sin6_port;
	  memcpy (su, &sin, sizeof (struct sockaddr_in));
	}
      return su;
    }
#endif /* HAVE_IPV6 */
  return NULL;
}

/* After TCP connection is established.  Get remote address and port. */
union sockunion *
sockunion_getpeername (int fd)
{
  int ret;
  socklen_t len;
  union
  {
    struct sockaddr sa;
    struct sockaddr_in sin;
#ifdef HAVE_IPV6
    struct sockaddr_in6 sin6;
#endif /* HAVE_IPV6 */
    char tmp_buffer[128];
  } name;
  union sockunion *su;

  memset (&name, 0, sizeof name);
  len = sizeof name;
  ret = getpeername (fd, (struct sockaddr *)&name, &len);
  if (ret < 0)
    {
      zlog (NULL, LOG_WARNING, "Can't get remote address and port: %s",
	    safe_strerror (errno));
      return NULL;
    }

  if (name.sa.sa_family == AF_INET)
    {
      su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
      memcpy (su, &name, sizeof (struct sockaddr_in));
      return su;
    }
#ifdef HAVE_IPV6
  if (name.sa.sa_family == AF_INET6)
    {
      su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
      memcpy (su, &name, sizeof (struct sockaddr_in6));

      if (IN6_IS_ADDR_V4MAPPED (&su->sin6.sin6_addr))
	{
	  struct sockaddr_in sin;

	  sin.sin_family = AF_INET;
	  memcpy (&sin.sin_addr, ((char *)&su->sin6.sin6_addr) + 12, 4);
	  sin.sin_port = su->sin6.sin6_port;
	  memcpy (su, &sin, sizeof (struct sockaddr_in));
	}
      return su;
    }
#endif /* HAVE_IPV6 */
  return NULL;
}

/* Print sockunion structure */
static void __attribute__ ((unused))
sockunion_print (union sockunion *su)
{
  if (su == NULL)
    return;

  switch (su->sa.sa_family) 
    {
    case AF_INET:
      printf ("%s\n", inet_ntoa (su->sin.sin_addr));
      break;
#ifdef HAVE_IPV6
    case AF_INET6:
      {
	char buf [SU_ADDRSTRLEN];

	printf ("%s\n", inet_ntop (AF_INET6, &(su->sin6.sin6_addr),
				 buf, sizeof (buf)));
      }
      break;
#endif /* HAVE_IPV6 */

#ifdef AF_LINK
    case AF_LINK:
      {
	struct sockaddr_dl *sdl;

	sdl = (struct sockaddr_dl *)&(su->sa);
	printf ("link#%d\n", sdl->sdl_index);
      }
      break;
#endif /* AF_LINK */
    default:
      printf ("af_unknown %d\n", su->sa.sa_family);
      break;
    }
}

#ifdef HAVE_IPV6
static int
in6addr_cmp (struct in6_addr *addr1, struct in6_addr *addr2)
{
  unsigned int i;
  u_char *p1, *p2;

  p1 = (u_char *)addr1;
  p2 = (u_char *)addr2;

  for (i = 0; i < sizeof (struct in6_addr); i++)
    {
      if (p1[i] > p2[i])
	return 1;
      else if (p1[i] < p2[i])
	return -1;
    }
  return 0;
}
#endif /* HAVE_IPV6 */

int
sockunion_cmp (union sockunion *su1, union sockunion *su2)
{
  if (su1->sa.sa_family > su2->sa.sa_family)
    return 1;
  if (su1->sa.sa_family < su2->sa.sa_family)
    return -1;

  if (su1->sa.sa_family == AF_INET)
    {
      if (ntohl (su1->sin.sin_addr.s_addr) == ntohl (su2->sin.sin_addr.s_addr))
	return 0;
      if (ntohl (su1->sin.sin_addr.s_addr) > ntohl (su2->sin.sin_addr.s_addr))
	return 1;
      else
	return -1;
    }
#ifdef HAVE_IPV6
  if (su1->sa.sa_family == AF_INET6)
    return in6addr_cmp (&su1->sin6.sin6_addr, &su2->sin6.sin6_addr);
#endif /* HAVE_IPV6 */
  return 0;
}

/* Duplicate sockunion. */
union sockunion *
sockunion_dup (union sockunion *su)
{
  union sockunion *dup = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
  memcpy (dup, su, sizeof (union sockunion));
  return dup;
}

void
sockunion_free (union sockunion *su)
{
  XFREE (MTYPE_SOCKUNION, su);
}
Commit	Line	Data
718e3744	1	/* Socket union related function.
	2	* Copyright (c) 1997, 98 Kunihiro Ishiguro
	3	*
	4	* This file is part of GNU Zebra.
	5	*
	6	* GNU Zebra is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the
	8	* Free Software Foundation; either version 2, or (at your option) any
	9	* later version.
	10	*
	11	* GNU Zebra is distributed in the hope that it will be useful, but
	12	* WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with GNU Zebra; see the file COPYING. If not, write to the Free
	18	* Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
	19	* 02111-1307, USA.
	20	*/
	21
	22	#include <zebra.h>
	23
	24	#include "prefix.h"
	25	#include "vty.h"
	26	#include "sockunion.h"
	27	#include "memory.h"
	28	#include "str.h"
	29	#include "log.h"
	30
	31	#ifndef HAVE_INET_ATON
	32	int
	33	inet_aton (const char cp, struct in_addr inaddr)
	34	{
	35	int dots = 0;
	36	register u_long addr = 0;
	37	register u_long val = 0, base = 10;
	38
	39	do
	40	{
	41	register char c = *cp;
	42
	43	switch (c)
	44	{
	45	case '0': case '1': case '2': case '3': case '4': case '5':
	46	case '6': case '7': case '8': case '9':
	47	val = (val * base) + (c - '0');
	48	break;
	49	case '.':
	50	if (++dots > 3)
	51	return 0;
	52	case '\0':
	53	if (val > 255)
	54	return 0;
	55	addr = addr << 8 \| val;
	56	val = 0;
	57	break;
	58	default:
	59	return 0;
	60	}
	61	} while (*cp++) ;
	62
	63	if (dots < 3)
	64	addr <<= 8 * (3 - dots);
65	if (inaddr)
66	inaddr->s_addr = htonl (addr);
67	return 1;
68	}
69	#endif /* ! HAVE_INET_ATON */
70
71
72	#ifndef HAVE_INET_PTON
73	int
74	inet_pton (int family, const char strptr, void addrptr)
75	{
76	if (family == AF_INET)
77	{
78	struct in_addr in_val;
79
80	if (inet_aton (strptr, &in_val))
81	{
82	memcpy (addrptr, &in_val, sizeof (struct in_addr));
83	return 1;
84	}
85	return 0;
86	}
87	errno = EAFNOSUPPORT;
88	return -1;
89	}
90	#endif /* ! HAVE_INET_PTON */
91
92	#ifndef HAVE_INET_NTOP
93	const char *
94	inet_ntop (int family, const void addrptr, char strptr, size_t len)
95	{
96	unsigned char p = (unsigned char ) addrptr;
97
98	if (family == AF_INET)
99	{
100	char temp[INET_ADDRSTRLEN];
101
102	snprintf(temp, sizeof(temp), "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
103
104	if (strlen(temp) >= len)
105	{
106	errno = ENOSPC;
107	return NULL;
108	}
109	strcpy(strptr, temp);
110	return strptr;
111	}
112
113	errno = EAFNOSUPPORT;
114	return NULL;
115	}
116	#endif /* ! HAVE_INET_NTOP */
117
118	const char *
119	inet_sutop (union sockunion su, char str)
120	{
121	switch (su->sa.sa_family)
122	{
123	case AF_INET:
124	inet_ntop (AF_INET, &su->sin.sin_addr, str, INET_ADDRSTRLEN);
125	break;
126	#ifdef HAVE_IPV6
127	case AF_INET6:
128	inet_ntop (AF_INET6, &su->sin6.sin6_addr, str, INET6_ADDRSTRLEN);
129	break;
130	#endif /* HAVE_IPV6 */
131	}
132	return str;
133	}
134
135	int
a149411b	136	str2sockunion (const char str, union sockunion su)
718e3744	137	{
	138	int ret;
	139
	140	memset (su, 0, sizeof (union sockunion));
	141
	142	ret = inet_pton (AF_INET, str, &su->sin.sin_addr);
	143	if (ret > 0) /* Valid IPv4 address format. */
	144	{
	145	su->sin.sin_family = AF_INET;
6f0e3f6e	146	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
718e3744	147	su->sin.sin_len = sizeof(struct sockaddr_in);
6f0e3f6e	148	#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
718e3744	149	return 0;
	150	}
	151	#ifdef HAVE_IPV6
	152	ret = inet_pton (AF_INET6, str, &su->sin6.sin6_addr);
	153	if (ret > 0) /* Valid IPv6 address format. */
	154	{
	155	su->sin6.sin6_family = AF_INET6;
	156	#ifdef SIN6_LEN
	157	su->sin6.sin6_len = sizeof(struct sockaddr_in6);
	158	#endif /* SIN6_LEN */
	159	return 0;
	160	}
	161	#endif /* HAVE_IPV6 */
	162	return -1;
	163	}
	164
	165	const char *
	166	sockunion2str (union sockunion su, char buf, size_t len)
	167	{
	168	if (su->sa.sa_family == AF_INET)
	169	return inet_ntop (AF_INET, &su->sin.sin_addr, buf, len);
	170	#ifdef HAVE_IPV6
	171	else if (su->sa.sa_family == AF_INET6)
	172	return inet_ntop (AF_INET6, &su->sin6.sin6_addr, buf, len);
	173	#endif /* HAVE_IPV6 */
	174	return NULL;
	175	}
	176
	177	union sockunion *
42d49865	178	sockunion_str2su (const char *str)
718e3744	179	{
	180	int ret;
	181	union sockunion *su;
	182
	183	su = XMALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
	184	memset (su, 0, sizeof (union sockunion));
	185
	186	ret = inet_pton (AF_INET, str, &su->sin.sin_addr);
	187	if (ret > 0) /* Valid IPv4 address format. */
	188	{
	189	su->sin.sin_family = AF_INET;
6f0e3f6e	190	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
718e3744	191	su->sin.sin_len = sizeof(struct sockaddr_in);
6f0e3f6e	192	#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
718e3744	193	return su;
	194	}
	195	#ifdef HAVE_IPV6
	196	ret = inet_pton (AF_INET6, str, &su->sin6.sin6_addr);
	197	if (ret > 0) /* Valid IPv6 address format. */
	198	{
	199	su->sin6.sin6_family = AF_INET6;
	200	#ifdef SIN6_LEN
	201	su->sin6.sin6_len = sizeof(struct sockaddr_in6);
	202	#endif /* SIN6_LEN */
	203	return su;
	204	}
	205	#endif /* HAVE_IPV6 */
	206
	207	XFREE (MTYPE_SOCKUNION, su);
	208	return NULL;
	209	}
	210
	211	char *
	212	sockunion_su2str (union sockunion *su)
	213	{
42d49865	214	char str[SU_ADDRSTRLEN];
718e3744	215
	216	switch (su->sa.sa_family)
	217	{
	218	case AF_INET:
	219	inet_ntop (AF_INET, &su->sin.sin_addr, str, sizeof (str));
	220	break;
	221	#ifdef HAVE_IPV6
	222	case AF_INET6:
	223	inet_ntop (AF_INET6, &su->sin6.sin6_addr, str, sizeof (str));
	224	break;
	225	#endif /* HAVE_IPV6 */
	226	}
5a54df97	227	return XSTRDUP (MTYPE_TMP, str);
718e3744	228	}
	229
	230	/* Return socket of sockunion. */
	231	int
	232	sockunion_socket (union sockunion *su)
	233	{
	234	int sock;
	235
	236	sock = socket (su->sa.sa_family, SOCK_STREAM, 0);
	237	if (sock < 0)
	238	{
6099b3b5	239	zlog (NULL, LOG_WARNING, "Can't make socket : %s", safe_strerror (errno));
718e3744	240	return -1;
	241	}
	242
	243	return sock;
	244	}
	245
	246	/* Return accepted new socket file descriptor. */
	247	int
	248	sockunion_accept (int sock, union sockunion *su)
	249	{
	250	socklen_t len;
	251	int client_sock;
	252
	253	len = sizeof (union sockunion);
	254	client_sock = accept (sock, (struct sockaddr *) su, &len);
	255
	256	/* Convert IPv4 compatible IPv6 address to IPv4 address. */
	257	#ifdef HAVE_IPV6
	258	if (su->sa.sa_family == AF_INET6)
	259	{
	260	if (IN6_IS_ADDR_V4MAPPED (&su->sin6.sin6_addr))
	261	{
	262	struct sockaddr_in sin;
	263
	264	memset (&sin, 0, sizeof (struct sockaddr_in));
	265	sin.sin_family = AF_INET;
	266	memcpy (&sin.sin_addr, ((char *)&su->sin6.sin6_addr) + 12, 4);
	267	memcpy (su, &sin, sizeof (struct sockaddr_in));
	268	}
	269	}
	270	#endif /* HAVE_IPV6 */
	271
	272	return client_sock;
	273	}
	274
	275	/* Return sizeof union sockunion. */
8cc4198f	276	static int
718e3744	277	sockunion_sizeof (union sockunion *su)
	278	{
	279	int ret;
	280
	281	ret = 0;
	282	switch (su->sa.sa_family)
	283	{
	284	case AF_INET:
	285	ret = sizeof (struct sockaddr_in);
	286	break;
	287	#ifdef HAVE_IPV6
	288	case AF_INET6:
	289	ret = sizeof (struct sockaddr_in6);
	290	break;
	291	#endif /* AF_INET6 */
	292	}
	293	return ret;
	294	}
	295
	296	/* return sockunion structure : this function should be revised. */
8cc4198f	297	static char *
718e3744	298	sockunion_log (union sockunion *su)
	299	{
	300	static char buf[SU_ADDRSTRLEN];
	301
	302	switch (su->sa.sa_family)
	303	{
	304	case AF_INET:
239a6718	305	snprintf (buf, SU_ADDRSTRLEN, "%s", inet_ntoa (su->sin.sin_addr));
718e3744	306	break;
	307	#ifdef HAVE_IPV6
	308	case AF_INET6:
239a6718	309	snprintf (buf, SU_ADDRSTRLEN, "%s",
239a6718	310	inet_ntop (AF_INET6, &(su->sin6.sin6_addr), buf, SU_ADDRSTRLEN));
718e3744	311	break;
	312	#endif /* HAVE_IPV6 */
	313	default:
239a6718	314	snprintf (buf, SU_ADDRSTRLEN, "af_unknown %d ", su->sa.sa_family);
718e3744	315	break;
718e3744	316	}
5a54df97	317	return (XSTRDUP (MTYPE_TMP, buf));
718e3744	318	}
	319
	320	/* sockunion_connect returns
	321	-1 : error occured
	322	0 : connect success
	323	1 : connect is in progress */
	324	enum connect_result
	325	sockunion_connect (int fd, union sockunion *peersu, unsigned short port,
	326	unsigned int ifindex)
	327	{
	328	int ret;
	329	int val;
	330	union sockunion su;
	331
	332	memcpy (&su, peersu, sizeof (union sockunion));
	333
	334	switch (su.sa.sa_family)
	335	{
	336	case AF_INET:
	337	su.sin.sin_port = port;
	338	break;
	339	#ifdef HAVE_IPV6
	340	case AF_INET6:
	341	su.sin6.sin6_port = port;
	342	#ifdef KAME
	343	if (IN6_IS_ADDR_LINKLOCAL(&su.sin6.sin6_addr) && ifindex)
	344	{
6f0e3f6e	345	#ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
718e3744	346	/* su.sin6.sin6_scope_id = ifindex; */
726f9b2b	347	#ifdef MUSICA
	348	su.sin6.sin6_scope_id = ifindex;
	349	#endif
6f0e3f6e	350	#endif /* HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID */
726f9b2b	351	#ifndef MUSICA
718e3744	352	SET_IN6_LINKLOCAL_IFINDEX (su.sin6.sin6_addr, ifindex);
726f9b2b	353	#endif
718e3744	354	}
	355	#endif /* KAME */
	356	break;
	357	#endif /* HAVE_IPV6 */
	358	}
	359
	360	/* Make socket non-block. */
	361	val = fcntl (fd, F_GETFL, 0);
	362	fcntl (fd, F_SETFL, val\|O_NONBLOCK);
	363
	364	/* Call connect function. */
	365	ret = connect (fd, (struct sockaddr *) &su, sockunion_sizeof (&su));
	366
	367	/* Immediate success */
	368	if (ret == 0)
	369	{
	370	fcntl (fd, F_SETFL, val);
	371	return connect_success;
	372	}
	373
	374	/* If connect is in progress then return 1 else it's real error. */
	375	if (ret < 0)
	376	{
	377	if (errno != EINPROGRESS)
	378	{
	379	zlog_info ("can't connect to %s fd %d : %s",
6099b3b5	380	sockunion_log (&su), fd, safe_strerror (errno));
718e3744	381	return connect_error;
	382	}
	383	}
	384
	385	fcntl (fd, F_SETFL, val);
	386
	387	return connect_in_progress;
	388	}
	389
	390	/* Make socket from sockunion union. */
	391	int
	392	sockunion_stream_socket (union sockunion *su)
	393	{
	394	int sock;
	395
	396	if (su->sa.sa_family == 0)
	397	su->sa.sa_family = AF_INET_UNION;
	398
	399	sock = socket (su->sa.sa_family, SOCK_STREAM, 0);
	400
	401	if (sock < 0)
	402	zlog (NULL, LOG_WARNING, "can't make socket sockunion_stream_socket");
	403
	404	return sock;
	405	}
	406
	407	/* Bind socket to specified address. */
	408	int
	409	sockunion_bind (int sock, union sockunion *su, unsigned short port,
	410	union sockunion *su_addr)
	411	{
	412	int size = 0;
	413	int ret;
	414
	415	if (su->sa.sa_family == AF_INET)
	416	{
	417	size = sizeof (struct sockaddr_in);
	418	su->sin.sin_port = htons (port);
6f0e3f6e	419	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
718e3744	420	su->sin.sin_len = size;
6f0e3f6e	421	#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
718e3744	422	if (su_addr == NULL)
	423	su->sin.sin_addr.s_addr = htonl (INADDR_ANY);
	424	}
	425	#ifdef HAVE_IPV6
	426	else if (su->sa.sa_family == AF_INET6)
	427	{
	428	size = sizeof (struct sockaddr_in6);
	429	su->sin6.sin6_port = htons (port);
	430	#ifdef SIN6_LEN
	431	su->sin6.sin6_len = size;
	432	#endif /* SIN6_LEN */
	433	if (su_addr == NULL)
	434	{
	435	#if defined(LINUX_IPV6) \|\| defined(NRL)
	436	memset (&su->sin6.sin6_addr, 0, sizeof (struct in6_addr));
	437	#else
	438	su->sin6.sin6_addr = in6addr_any;
	439	#endif /* LINUX_IPV6 */
	440	}
	441	}
	442	#endif /* HAVE_IPV6 */
	443
	444
	445	ret = bind (sock, (struct sockaddr *)su, size);
	446	if (ret < 0)
6099b3b5	447	zlog (NULL, LOG_WARNING, "can't bind socket : %s", safe_strerror (errno));
718e3744	448
	449	return ret;
	450	}
	451
	452	int
	453	sockopt_reuseaddr (int sock)
	454	{
	455	int ret;
	456	int on = 1;
	457
	458	ret = setsockopt (sock, SOL_SOCKET, SO_REUSEADDR,
	459	(void *) &on, sizeof (on));
	460	if (ret < 0)
	461	{
	462	zlog (NULL, LOG_WARNING, "can't set sockopt SO_REUSEADDR to socket %d", sock);
	463	return -1;
	464	}
	465	return 0;
	466	}
	467
	468	#ifdef SO_REUSEPORT
	469	int
	470	sockopt_reuseport (int sock)
	471	{
	472	int ret;
	473	int on = 1;
	474
	475	ret = setsockopt (sock, SOL_SOCKET, SO_REUSEPORT,
	476	(void *) &on, sizeof (on));
	477	if (ret < 0)
	478	{
e7fe8c88	479	zlog (NULL, LOG_WARNING, "can't set sockopt SO_REUSEPORT to socket %d", sock);
718e3744	480	return -1;
	481	}
	482	return 0;
	483	}
	484	#else
	485	int
	486	sockopt_reuseport (int sock)
	487	{
	488	return 0;
	489	}
	490	#endif /* 0 */
	491
	492	int
	493	sockopt_ttl (int family, int sock, int ttl)
	494	{
	495	int ret;
	496
	497	#ifdef IP_TTL
	498	if (family == AF_INET)
	499	{
	500	ret = setsockopt (sock, IPPROTO_IP, IP_TTL,
	501	(void *) &ttl, sizeof (int));
	502	if (ret < 0)
	503	{
	504	zlog (NULL, LOG_WARNING, "can't set sockopt IP_TTL %d to socket %d", ttl, sock);
	505	return -1;
	506	}
	507	return 0;
	508	}
	509	#endif /* IP_TTL */
	510	#ifdef HAVE_IPV6
	511	if (family == AF_INET6)
	512	{
	513	ret = setsockopt (sock, IPPROTO_IPV6, IPV6_UNICAST_HOPS,
	514	(void *) &ttl, sizeof (int));
	515	if (ret < 0)
	516	{
	517	zlog (NULL, LOG_WARNING, "can't set sockopt IPV6_UNICAST_HOPS %d to socket %d",
	518	ttl, sock);
	519	return -1;
	520	}
	521	return 0;
	522	}
	523	#endif /* HAVE_IPV6 */
	524	return 0;
	525	}
	526
	527	/* If same family and same prefix return 1. */
	528	int
	529	sockunion_same (union sockunion su1, union sockunion su2)
	530	{
	531	int ret = 0;
	532
	533	if (su1->sa.sa_family != su2->sa.sa_family)
	534	return 0;
	535
	536	switch (su1->sa.sa_family)
	537	{
	538	case AF_INET:
	539	ret = memcmp (&su1->sin.sin_addr, &su2->sin.sin_addr,
	540	sizeof (struct in_addr));
	541	break;
	542	#ifdef HAVE_IPV6
	543	case AF_INET6:
544	ret = memcmp (&su1->sin6.sin6_addr, &su2->sin6.sin6_addr,
545	sizeof (struct in6_addr));
546	break;
547	#endif /* HAVE_IPV6 */
548	}
549	if (ret == 0)
550	return 1;
551	else
552	return 0;
553	}
554
555	/* After TCP connection is established. Get local address and port. */
556	union sockunion *
557	sockunion_getsockname (int fd)
558	{
559	int ret;
22528299	560	socklen_t len;
718e3744	561	union
	562	{
	563	struct sockaddr sa;
	564	struct sockaddr_in sin;
	565	#ifdef HAVE_IPV6
	566	struct sockaddr_in6 sin6;
	567	#endif /* HAVE_IPV6 */
	568	char tmp_buffer[128];
	569	} name;
	570	union sockunion *su;
	571
	572	memset (&name, 0, sizeof name);
	573	len = sizeof name;
	574
	575	ret = getsockname (fd, (struct sockaddr *)&name, &len);
	576	if (ret < 0)
	577	{
	578	zlog_warn ("Can't get local address and port by getsockname: %s",
6099b3b5	579	safe_strerror (errno));
718e3744	580	return NULL;
	581	}
	582
	583	if (name.sa.sa_family == AF_INET)
	584	{
2ba9a37a	585	su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
718e3744	586	memcpy (su, &name, sizeof (struct sockaddr_in));
	587	return su;
	588	}
	589	#ifdef HAVE_IPV6
	590	if (name.sa.sa_family == AF_INET6)
	591	{
2ba9a37a	592	su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
718e3744	593	memcpy (su, &name, sizeof (struct sockaddr_in6));
	594
	595	if (IN6_IS_ADDR_V4MAPPED (&su->sin6.sin6_addr))
	596	{
	597	struct sockaddr_in sin;
	598
	599	sin.sin_family = AF_INET;
	600	memcpy (&sin.sin_addr, ((char *)&su->sin6.sin6_addr) + 12, 4);
	601	sin.sin_port = su->sin6.sin6_port;
	602	memcpy (su, &sin, sizeof (struct sockaddr_in));
	603	}
	604	return su;
	605	}
	606	#endif /* HAVE_IPV6 */
	607	return NULL;
	608	}
	609
	610	/* After TCP connection is established. Get remote address and port. */
	611	union sockunion *
	612	sockunion_getpeername (int fd)
	613	{
	614	int ret;
22528299	615	socklen_t len;
718e3744	616	union
	617	{
	618	struct sockaddr sa;
	619	struct sockaddr_in sin;
	620	#ifdef HAVE_IPV6
	621	struct sockaddr_in6 sin6;
	622	#endif /* HAVE_IPV6 */
	623	char tmp_buffer[128];
	624	} name;
	625	union sockunion *su;
	626
	627	memset (&name, 0, sizeof name);
	628	len = sizeof name;
	629	ret = getpeername (fd, (struct sockaddr *)&name, &len);
	630	if (ret < 0)
	631	{
	632	zlog (NULL, LOG_WARNING, "Can't get remote address and port: %s",
6099b3b5	633	safe_strerror (errno));
718e3744	634	return NULL;
	635	}
	636
	637	if (name.sa.sa_family == AF_INET)
	638	{
2ba9a37a	639	su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
718e3744	640	memcpy (su, &name, sizeof (struct sockaddr_in));
	641	return su;
	642	}
	643	#ifdef HAVE_IPV6
	644	if (name.sa.sa_family == AF_INET6)
	645	{
2ba9a37a	646	su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
718e3744	647	memcpy (su, &name, sizeof (struct sockaddr_in6));
	648
	649	if (IN6_IS_ADDR_V4MAPPED (&su->sin6.sin6_addr))
	650	{
	651	struct sockaddr_in sin;
	652
	653	sin.sin_family = AF_INET;
	654	memcpy (&sin.sin_addr, ((char *)&su->sin6.sin6_addr) + 12, 4);
	655	sin.sin_port = su->sin6.sin6_port;
	656	memcpy (su, &sin, sizeof (struct sockaddr_in));
	657	}
	658	return su;
	659	}
	660	#endif /* HAVE_IPV6 */
	661	return NULL;
	662	}
	663
	664	/* Print sockunion structure */
8cc4198f	665	static void __attribute__ ((unused))
718e3744	666	sockunion_print (union sockunion *su)
	667	{
	668	if (su == NULL)
	669	return;
	670
	671	switch (su->sa.sa_family)
	672	{
	673	case AF_INET:
	674	printf ("%s\n", inet_ntoa (su->sin.sin_addr));
	675	break;
	676	#ifdef HAVE_IPV6
	677	case AF_INET6:
	678	{
42d49865	679	char buf [SU_ADDRSTRLEN];
718e3744	680
	681	printf ("%s\n", inet_ntop (AF_INET6, &(su->sin6.sin6_addr),
	682	buf, sizeof (buf)));
	683	}
	684	break;
	685	#endif /* HAVE_IPV6 */
	686
	687	#ifdef AF_LINK
	688	case AF_LINK:
	689	{
	690	struct sockaddr_dl *sdl;
	691
	692	sdl = (struct sockaddr_dl *)&(su->sa);
	693	printf ("link#%d\n", sdl->sdl_index);
	694	}
	695	break;
	696	#endif /* AF_LINK */
	697	default:
	698	printf ("af_unknown %d\n", su->sa.sa_family);
	699	break;
	700	}
	701	}
	702
	703	#ifdef HAVE_IPV6
8cc4198f	704	static int
718e3744	705	in6addr_cmp (struct in6_addr addr1, struct in6_addr addr2)
718e3744	706	{
8c328f11	707	unsigned int i;
718e3744	708	u_char p1, p2;
	709
	710	p1 = (u_char *)addr1;
	711	p2 = (u_char *)addr2;
	712
	713	for (i = 0; i < sizeof (struct in6_addr); i++)
	714	{
	715	if (p1[i] > p2[i])
	716	return 1;
	717	else if (p1[i] < p2[i])
	718	return -1;
	719	}
	720	return 0;
	721	}
	722	#endif /* HAVE_IPV6 */
	723
	724	int
	725	sockunion_cmp (union sockunion su1, union sockunion su2)
	726	{
	727	if (su1->sa.sa_family > su2->sa.sa_family)
	728	return 1;
	729	if (su1->sa.sa_family < su2->sa.sa_family)
	730	return -1;
	731
	732	if (su1->sa.sa_family == AF_INET)
	733	{
	734	if (ntohl (su1->sin.sin_addr.s_addr) == ntohl (su2->sin.sin_addr.s_addr))
	735	return 0;
	736	if (ntohl (su1->sin.sin_addr.s_addr) > ntohl (su2->sin.sin_addr.s_addr))
	737	return 1;
	738	else
	739	return -1;
	740	}
	741	#ifdef HAVE_IPV6
	742	if (su1->sa.sa_family == AF_INET6)
	743	return in6addr_cmp (&su1->sin6.sin6_addr, &su2->sin6.sin6_addr);
	744	#endif /* HAVE_IPV6 */
	745	return 0;
	746	}
	747
	748	/* Duplicate sockunion. */
	749	union sockunion *
	750	sockunion_dup (union sockunion *su)
	751	{
	752	union sockunion *dup = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
	753	memcpy (dup, su, sizeof (union sockunion));
	754	return dup;
	755	}
	756
	757	void
	758	sockunion_free (union sockunion *su)
	759	{
	760	XFREE (MTYPE_SOCKUNION, su);
	761	}