/*	$OpenBSD: virtual.c,v 1.32 2015/08/20 22:02:21 deraadt Exp $	*/

/*

 * Copyright (c) 2004 Håkan Olsson.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include <sys/types.h>

#include <sys/ioctl.h>

#include <sys/socket.h>

#include <sys/sockio.h>

#include <net/if.h>

#include <netinet/in.h>

#include <netinet6/in6_var.h>

#include <arpa/inet.h>

#include <ctype.h>

#include <limits.h>

#include <netdb.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include "conf.h"

#include "if.h"

#include "exchange.h"

#include "log.h"

#include "message.h"

#include "nat_traversal.h"

#include "transport.h"

#include "virtual.h"

#include "udp.h"

#include "util.h"

#include "udp_encap.h"

static struct transport	*virtual_bind(const struct sockaddr *);

static struct transport	*virtual_bind_ADDR_ANY(sa_family_t);

static int		 virtual_bind_if(char *, struct sockaddr *, void *);

static struct transport	*virtual_clone(struct transport *, struct sockaddr *);

static struct transport	*virtual_create(char *);

static char		*virtual_decode_ids (struct transport *);

static void		 virtual_get_dst(struct transport *,

			     struct sockaddr **);

static struct msg_head	*virtual_get_queue(struct message *);

static void		 virtual_get_src(struct transport *,

			     struct sockaddr **);

static void		 virtual_handle_message(struct transport *);

static void		 virtual_reinit(void);

static void		 virtual_remove(struct transport *);

static void		 virtual_report(struct transport *);

static int		 virtual_send_message(struct message *,

			     struct transport *);

static struct transport_vtbl virtual_transport_vtbl = {

	{ 0 }, "udp",

	virtual_create,

	virtual_reinit,

	virtual_remove,

	virtual_report,

	0,

	0,

	virtual_handle_message,

	virtual_send_message,

	virtual_get_dst,

	virtual_get_src,

	virtual_decode_ids,

	virtual_clone,

	virtual_get_queue

};

static LIST_HEAD (virtual_listen_list, virtual_transport) virtual_listen_list;

static struct transport *default_transport, *default_transport6;

void

virtual_init(void)

{

	struct conf_list *listen_on;

	/* Bind the ISAKMP port(s) on all network interfaces we have.  */

		    "could not bind the ISAKMP port(s) on all interfaces");

	/* Only listen to the specified address if Listen-on is configured */

		    "virtual_init: not binding ISAKMP port(s) to ADDR_ANY"));

	}

	/*

	 * Bind to INADDR_ANY in case of new addresses popping up.

	 * Packet reception on this transport is taken as a hint to reprobe the

	 * interface list.

	 */

		    (struct virtual_transport *)default_transport, link);

	}

		    (struct virtual_transport *)default_transport6, link);

	}

}

struct virtual_transport *

virtual_get_default(sa_family_t af)

{

	case AF_INET:

	case AF_INET6:

	default:

	}

}

/*

 * Probe the interface list and determine what new interfaces have

 * appeared.

 *

 * At the same time, we try to determine whether existing interfaces have

 * been rendered invalid; we do this by marking all virtual transports before

 * we call virtual_bind_if() through if_map(), and then releasing those

 * transports that have not been unmarked.

 */

void

virtual_reinit(void)

{

	struct virtual_transport *v, *v2;

	/* Mark all UDP transports, except the default ones. */

		    &v->transport != default_transport6)

	/* Re-probe interface list.  */

		    "could not bind the ISAKMP port(s) on all interfaces");

	/*

	 * Release listening transports for local addresses that no

	 * longer exist. virtual_bind_if () will have left those still marked.

	 */

		}

	}

}

struct virtual_transport *

virtual_listen_lookup(struct sockaddr *addr)

{

	struct virtual_transport *v;

	struct udp_transport	 *u;

				    "virtual %p has no low-level transports",

				    v);

			}

		    sockaddr_addrlen(u->src) == sockaddr_addrlen(addr) &&

		    memcmp(sockaddr_addrdata (u->src), sockaddr_addrdata(addr),

		    sockaddr_addrlen(addr)) == 0)

	}

}

/*

 * Initialize an object of the VIRTUAL transport class.

 */

static struct transport *

virtual_bind(const struct sockaddr *addr)

{

	struct virtual_transport *v;

	struct sockaddr_storage	  tmp_sa;

	char	*stport;

	in_port_t port;

		    (unsigned long)sizeof *v);

	}

	/* Get port. */

	}

	}

		/* Get port. */

		    ? udp_encap_default_port : UDP_ENCAP_DEFAULT_PORT_STR;

			    stport);

		}

		}

	}

}

static struct transport *

virtual_bind_ADDR_ANY(sa_family_t af)

{

	struct sockaddr_storage dflt_stor;

	struct transport	*t;

	case AF_INET:

	case AF_INET6:

		    sizeof in6addr_any);

		break;

	}

		    "could not allocate default IPv%s ISAKMP port(s)",

		    af == AF_INET ? "4" : "6");

}

static int

virtual_bind_if(char *ifname, struct sockaddr *if_addr, void *arg)

{

	struct conf_list	*listen_on;

	struct virtual_transport *v;

	struct conf_list_node	*address;

	struct sockaddr		*addr;

	struct transport	*t;

	struct ifreq		flags_ifr;

	struct in6_ifreq	flags_ifr6;

	char	*addr_str;

	int	 s, error;

	    "virtual_bind_if: interface %s family %s address %s",

	    ifname ? ifname : "<unknown>",

	    if_addr->sa_family == AF_INET ? "v4" :

	    (if_addr->sa_family == AF_INET6 ? "v6" : "<unknown>"),

	    addr_str ? addr_str : "<invalid>"));

	/*

	 * Drop non-Internet stuff.

	 */

	    SA_LEN(if_addr) != sizeof (struct sockaddr_in)) &&

	    (if_addr->sa_family != AF_INET6 ||

	    SA_LEN(if_addr) != sizeof (struct sockaddr_in6)))

	/*

	 * Only create sockets for families we should listen to.

	 */

		case AF_INET:

			break;

		case AF_INET6:

			break;

		default:

		}

	/*

	 * These special addresses are not useable as they have special meaning

	 * in the IP stack.

	 */

	    (((struct sockaddr_in *)if_addr)->sin_addr.s_addr == INADDR_ANY ||

	    (((struct sockaddr_in *)if_addr)->sin_addr.s_addr == INADDR_NONE)))

	/*

	 * Go through the list of transports and see if we already have this

	 * address bound. If so, unmark the transport and skip it; this allows

	 * us to call this function when we suspect a new address has appeared.

	 */

		    "already bound"));

	}

	/*

	 * Don't bother with interfaces that are down.

	 * Note: This socket is only used to collect the interface status,

	 * rtables and inet6 addresses.

	 */

		    "socket (%d, SOCK_DGRAM, 0) failed", if_addr->sa_family);

	}

		    "ioctl (%d, SIOCGIFFLAGS, ...) failed", s);

	}

	}

	/* Also skip tentative addresses during DAD since bind(2) would fail. */

			    "ioctl (%d, SIOCGIFAFLAG_IN6, ...) failed", s);

		}

		    IN6_IFF_TENTATIVE|IN6_IFF_DUPLICATED|IN6_IFF_DETACHED)) {

			    "IPv6 address %s not ready (flags 0x%x)",

			    error ? "unknown" : addr_str,

			    flags_ifr6.ifr_ifru.ifru_flags6);

			/* XXX schedule an interface rescan */

		}

	}

		    "ioctl (%d, SIOCGIFRDOMAIN, ...) failed", s);

	}

	/*

	 * Ignore interfaces outside of our rtable

	 */

	}

	/* Set the port number to zero.  */

	case AF_INET:

	case AF_INET6:

	default:

		    if_addr->sa_family);

		break;

	}

	/*

	 * If we are explicit about what addresses we can listen to, be sure

	 * to respect that option.

	 * This is quite wasteful redoing the list-run for every interface,

	 * but who cares?  This is not an operation that needs to be fast.

	 */

				    "invalid address %s in \"Listen-on\"",

				    address->field);

			}

			/* If found, take the easy way out. */

			}

		}

		/*

		 * If address is zero then we did not find the address among

		 * the ones we should listen to.

		 * XXX We do not discover if we do not find our listen

		 * addresses. Maybe this should be the other way round.

		 */

	}

		    error ? "unknown" : addr_str);

	}

	    link);

}

static struct transport *

virtual_clone(struct transport *vt, struct sockaddr *raddr)

{

	struct virtual_transport *v2;

	struct transport	 *t;

	char			 *stport;

	in_port_t		  port;

		    (unsigned long)sizeof *v);

	}

	/* Remove the copy's links into virtual_listen_list.  */

	else {

	}

		    UDP_ENCAP_DEFAULT_PORT_STR;

			    "to in_port_t", stport);

		}

	}

	    v, t, v->encap_is_active ? "encap" : "main",

	    v->encap_is_active ? v2->encap : v2->main));

}

static struct transport *

virtual_create(char *name)

{

	struct virtual_transport *v;

		}

	}

		    (unsigned long)sizeof *v);

	}

}

static void

virtual_remove(struct transport *t)

{

		;

}

static void

virtual_report(struct transport *t)

{

}

static void

virtual_handle_message(struct transport *t)

{

	/*

	 * As per the NAT-T draft, in case we have already switched ports,

	 * any messages received on the old (500) port SHOULD be discarded.

	 * (Actually, while phase 1 messages should be discarded,

	 *  informational exchanges MAY be processed normally. For now, we

	 *  discard them all.)

	 */

	    ((struct virtual_transport *)t->virtual)->main == t) {

		    "message on old port discarded"));

	}

}

static int

virtual_send_message(struct message *msg, struct transport *t)

{

	struct virtual_transport *v =

	struct sockaddr *dst;

	in_port_t port, default_port;

	/*

	 * Activate NAT-T Encapsulation if

	 *   - the exchange says we can, and

	 *   - in ID_PROT, after step 4 (draft-ietf-ipsec-nat-t-ike-03), or

	 *   - in other exchange (Aggressive, ), asap

	 * XXX ISAKMP_EXCH_BASE etc?

	 */

	}

	    (msg->exchange->flags & EXCHANGE_FLAG_NAT_T_ENABLE) &&

	    (msg->exchange->type != ISAKMP_EXCH_ID_PROT ||

		msg->exchange->step > 4)) || (msg->flags & MSG_NATT)) {

		    "enabling NAT-T encapsulation for this exchange"));

		/* Copy destination port if it is translated (NAT).  */

		else

		}

	}

	else

}

static void

virtual_get_src(struct transport *t, struct sockaddr **s)

{

	else

}

static void

virtual_get_dst(struct transport *t, struct sockaddr **s)

{

	else

}

static char *

virtual_decode_ids(struct transport *t)

{

	else

}

static struct msg_head *

virtual_get_queue(struct message *msg)

{

	else

}