/*
 *  OpenVPN -- An application to securely tunnel IP networks
 *             over a single TCP/UDP port, with support for SSL/TLS-based
 *             session authentication and key exchange,
 *             packet encryption, packet authentication, and
 *             packet compression.
 *
 *  Copyright (C) 2002-2010 OpenVPN Technologies, Inc. <sales@openvpn.net>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2
 *  as published by the Free Software Foundation.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program (see the file COPYING included with this
 *  distribution); if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef TUN_H
#define TUN_H

#ifdef WIN32
#include <winioctl.h>
#include "tap-win32/common.h"
#endif

#include "buffer.h"
#include "error.h"
#include "mtu.h"
#include "win32.h"
#include "event.h"
#include "proto.h"
#include "misc.h"

#ifdef WIN32

/* time constants for --ip-win32 adaptive */
#define IPW32_SET_ADAPTIVE_DELAY_WINDOW 300
#define IPW32_SET_ADAPTIVE_TRY_NETSH    20

struct tuntap_options {
  /* --ip-win32 options */
  bool ip_win32_defined;

# define IPW32_SET_MANUAL       0  /* "--ip-win32 manual" */
# define IPW32_SET_NETSH        1  /* "--ip-win32 netsh" */
# define IPW32_SET_IPAPI        2  /* "--ip-win32 ipapi" */
# define IPW32_SET_DHCP_MASQ    3  /* "--ip-win32 dynamic" */
# define IPW32_SET_ADAPTIVE     4  /* "--ip-win32 adaptive" */
# define IPW32_SET_N            5
  int ip_win32_type;

  /* --ip-win32 dynamic options */
  bool dhcp_masq_custom_offset;
  int dhcp_masq_offset;
  int dhcp_lease_time;

  /* --tap-sleep option */
  int tap_sleep;

  /* --dhcp-option options */

  bool dhcp_options;

  const char *domain;        /* DOMAIN (15) */

  const char *netbios_scope; /* NBS (47) */

  int netbios_node_type;     /* NBT 1,2,4,8 (46) */

#define N_DHCP_ADDR 4        /* Max # of addresses allowed for
			        DNS, WINS, etc. */

  /* DNS (6) */
  in_addr_t dns[N_DHCP_ADDR];
  int dns_len;

  /* WINS (44) */
  in_addr_t wins[N_DHCP_ADDR];
  int wins_len;

  /* NTP (42) */
  in_addr_t ntp[N_DHCP_ADDR];
  int ntp_len;

  /* NBDD (45) */
  in_addr_t nbdd[N_DHCP_ADDR];
  int nbdd_len;

  /* DISABLE_NBT (43, Vendor option 001) */
  bool disable_nbt;

  bool dhcp_renew;
  bool dhcp_pre_release;
  bool dhcp_release;

  bool register_dns;
};

#elif TARGET_LINUX

struct tuntap_options {
  int txqueuelen;
};

#else

struct tuntap_options {
  int dummy; /* not used */
};

#endif

/*
 * Define a TUN/TAP dev.
 */

struct tuntap
{
# define TUNNEL_TYPE(tt) ((tt) ? ((tt)->type) : DEV_TYPE_UNDEF)
  int type; /* DEV_TYPE_x as defined in proto.h */

# define TUNNEL_TOPOLOGY(tt) ((tt) ? ((tt)->topology) : TOP_UNDEF)
  int topology; /* one of the TOP_x values */

  bool did_ifconfig_setup;
  bool did_ifconfig;

  bool ipv6;

  struct tuntap_options options; /* options set on command line */

  char *actual_name; /* actual name of TUN/TAP dev, usually including unit number */

  /* number of TX buffers */
  int txqueuelen;

  /* ifconfig parameters */
  in_addr_t local;
  in_addr_t remote_netmask;
  in_addr_t broadcast;

#ifdef WIN32
  HANDLE hand;
  struct overlapped_io reads;
  struct overlapped_io writes;
  struct rw_handle rw_handle;

  /* used for setting interface address via IP Helper API
     or DHCP masquerade */
  bool ipapi_context_defined;
  ULONG ipapi_context;
  ULONG ipapi_instance;
  in_addr_t adapter_netmask;

  /* Windows adapter index for TAP-Win32 adapter,
     ~0 if undefined */
  DWORD adapter_index;

  int standby_iter;
#else
  int fd;   /* file descriptor for TUN/TAP dev */
#endif

#ifdef TARGET_SOLARIS
  int ip_fd;
#endif

  /* used for printing status info only */
  unsigned int rwflags_debug;

  /* Some TUN/TAP drivers like to be ioctled for mtu
     after open */
  int post_open_mtu;
};

static inline bool
tuntap_defined (const struct tuntap *tt)
{
#ifdef WIN32
  return tt && tt->hand != NULL;
#else
  return tt && tt->fd >= 0;
#endif
}

/*
 * Function prototypes
 */

void clear_tuntap (struct tuntap *tuntap);

void open_tun (const char *dev, const char *dev_type, const char *dev_node,
	       bool ipv6, struct tuntap *tt);

void close_tun (struct tuntap *tt);

int write_tun (struct tuntap* tt, uint8_t *buf, int len);

int read_tun (struct tuntap* tt, uint8_t *buf, int len);

void tuncfg (const char *dev, const char *dev_type, const char *dev_node,
	     bool ipv6, int persist_mode, const char *username,
	     const char *groupname, const struct tuntap_options *options);

const char *guess_tuntap_dev (const char *dev,
			      const char *dev_type,
			      const char *dev_node,
			      struct gc_arena *gc);

struct tuntap *init_tun (const char *dev,       /* --dev option */
			 const char *dev_type,  /* --dev-type option */
			 int topology,          /* one of the TOP_x values */
			 const char *ifconfig_local_parm,          /* --ifconfig parm 1 */
			 const char *ifconfig_remote_netmask_parm, /* --ifconfig parm 2 */
			 in_addr_t local_public,
			 in_addr_t remote_public,
			 const bool strict_warn,
			 struct env_set *es);

void init_tun_post (struct tuntap *tt,
		    const struct frame *frame,
		    const struct tuntap_options *options);

void do_ifconfig (struct tuntap *tt,
		  const char *actual,    /* actual device name */
		  int tun_mtu,
		  const struct env_set *es);

bool is_dev_type (const char *dev, const char *dev_type, const char *match_type);
int dev_type_enum (const char *dev, const char *dev_type);
const char *dev_type_string (const char *dev, const char *dev_type);

const char *ifconfig_options_string (const struct tuntap* tt, bool remote, bool disable, struct gc_arena *gc);

bool is_tun_p2p (const struct tuntap *tt);

void check_subnet_conflict (const in_addr_t ip,
			    const in_addr_t netmask,
			    const char *prefix);

void warn_on_use_of_common_subnets (void);

/*
 * Inline functions
 */

static inline void
tun_adjust_frame_parameters (struct frame* frame, int size)
{
  frame_add_to_extra_tun (frame, size);
}

/*
 * Should ifconfig be called before or after
 * tun dev open?
 */

#define IFCONFIG_BEFORE_TUN_OPEN 0
#define IFCONFIG_AFTER_TUN_OPEN  1

#define IFCONFIG_DEFAULT         IFCONFIG_AFTER_TUN_OPEN

static inline int
ifconfig_order(void)
{
#if defined(TARGET_LINUX)
  return IFCONFIG_AFTER_TUN_OPEN;
#elif defined(TARGET_SOLARIS)
  return IFCONFIG_AFTER_TUN_OPEN;
#elif defined(TARGET_OPENBSD)
  return IFCONFIG_BEFORE_TUN_OPEN;
#elif defined(TARGET_DARWIN)
  return IFCONFIG_AFTER_TUN_OPEN;
#elif defined(TARGET_NETBSD)
  return IFCONFIG_AFTER_TUN_OPEN;
#elif defined(WIN32)
  return IFCONFIG_BEFORE_TUN_OPEN;
#else
  return IFCONFIG_DEFAULT;
#endif
}

#ifdef WIN32

#define TUN_PASS_BUFFER

struct tap_reg
{
  const char *guid;
  struct tap_reg *next;
};

struct panel_reg
{
  const char *name;
  const char *guid;
  struct panel_reg *next;
};

int ascii2ipset (const char* name);
const char *ipset2ascii (int index);
const char *ipset2ascii_all (struct gc_arena *gc);

void verify_255_255_255_252 (in_addr_t local, in_addr_t remote);

const IP_ADAPTER_INFO *get_adapter_info_list (struct gc_arena *gc);
const IP_ADAPTER_INFO *get_tun_adapter (const struct tuntap *tt, const IP_ADAPTER_INFO *list);

const IP_ADAPTER_INFO *get_adapter_info (DWORD index, struct gc_arena *gc);
const IP_PER_ADAPTER_INFO *get_per_adapter_info (const DWORD index, struct gc_arena *gc);
const IP_ADAPTER_INFO *get_adapter (const IP_ADAPTER_INFO *ai, DWORD index);

bool is_adapter_up (const struct tuntap *tt, const IP_ADAPTER_INFO *list);
bool is_ip_in_adapter_subnet (const IP_ADAPTER_INFO *ai, const in_addr_t ip, in_addr_t *highest_netmask);

DWORD adapter_index_of_ip (const IP_ADAPTER_INFO *list,
			   const in_addr_t ip,
			   int *count,
			   in_addr_t *netmask);

void show_tap_win32_adapters (int msglev, int warnlev);
void show_adapters (int msglev);

void tap_allow_nonadmin_access (const char *dev_node);

void show_valid_win32_tun_subnets (void);
const char *tap_win32_getinfo (const struct tuntap *tt, struct gc_arena *gc);
void tun_show_debug (struct tuntap *tt);

bool dhcp_release_by_adapter_index(const DWORD adapter_index);
bool dhcp_renew_by_adapter_index (const DWORD adapter_index);

void fork_register_dns_action (struct tuntap *tt);
void ipconfig_register_dns (const struct env_set *es);

void tun_standby_init (struct tuntap *tt);
bool tun_standby (struct tuntap *tt);

int tun_read_queue (struct tuntap *tt, int maxsize);
int tun_write_queue (struct tuntap *tt, struct buffer *buf);
int tun_finalize (HANDLE h, struct overlapped_io *io, struct buffer *buf);

static inline bool
tuntap_stop (int status)
{
  /*
   * This corresponds to the STATUS_NO_SUCH_DEVICE
   * error in tapdrvr.c.
   */
  if (status < 0)
    {
      return openvpn_errno () == ERROR_FILE_NOT_FOUND;
    }
  return false;
}

static inline int
tun_write_win32 (struct tuntap *tt, struct buffer *buf)
{
  int err = 0;
  int status = 0;
  if (overlapped_io_active (&tt->writes))
    {
      status = tun_finalize (tt->hand, &tt->writes, NULL);
      if (status < 0)
	err = GetLastError ();
    }
  tun_write_queue (tt, buf);
  if (status < 0)
    {
      SetLastError (err);
      return status;
    }
  else
    return BLEN (buf);
}

static inline int
read_tun_buffered (struct tuntap *tt, struct buffer *buf, int maxsize)
{
  return tun_finalize (tt->hand, &tt->reads, buf);
}

static inline int
write_tun_buffered (struct tuntap *tt, struct buffer *buf)
{
  return tun_write_win32 (tt, buf);
}

#else

static inline bool
tuntap_stop (int status)
{
  return false;
}

static inline void
tun_standby_init (struct tuntap *tt)
{
}

static inline bool
tun_standby (struct tuntap *tt)
{
  return true;
}

#endif

/*
 * TUN/TAP I/O wait functions
 */

static inline event_t
tun_event_handle (const struct tuntap *tt)
{
#ifdef WIN32
  return &tt->rw_handle;
#else
  return tt->fd;
#endif
}

static inline unsigned int
tun_set (struct tuntap *tt,
	 struct event_set *es,
	 unsigned int rwflags,
	 void *arg,
	 unsigned int *persistent)
{
  if (tuntap_defined (tt))
    {
      /* if persistent is defined, call event_ctl only if rwflags has changed since last call */
      if (!persistent || *persistent != rwflags)
	{
	  event_ctl (es, tun_event_handle (tt), rwflags, arg);
	  if (persistent)
	    *persistent = rwflags;
	}
#ifdef WIN32
      if (rwflags & EVENT_READ)
	tun_read_queue (tt, 0);
#endif
      tt->rwflags_debug = rwflags;
    }
  return rwflags;
}

const char *tun_stat (const struct tuntap *tt, unsigned int rwflags, struct gc_arena *gc);

#endif /* TUN_H */
