/*
  *  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-2018 OpenVPN 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; if not, write to the Free Software Foundation, Inc.,
  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

  */
 
 #ifndef SOCKET_H
 #define SOCKET_H
 
 #include "buffer.h"
 #include "common.h"
 #include "error.h"
 #include "proto.h"
 #include "mtu.h"
 #include "win32.h"
 #include "event.h"
 #include "proxy.h"
 #include "socks.h"
 #include "misc.h"
 
 /*
  * OpenVPN's default port number as assigned by IANA.
  */

 #define OPENVPN_PORT "1194"

 
 /*
  * Number of seconds that "resolv-retry infinite"
  * represents.
  */
 #define RESOLV_RETRY_INFINITE 1000000000
 

 /*

  * packet_size_type is used to communicate packet size
  * over the wire when stream oriented protocols are
  * being used
  */
 
 typedef uint16_t packet_size_type;
 
 /* convert a packet_size_type from host to network order */
 #define htonps(x) htons(x)
 
 /* convert a packet_size_type from network to host order */
 #define ntohps(x) ntohs(x)
 

 /* OpenVPN sockaddr struct */
 struct openvpn_sockaddr
 {

     /*int dummy;*/ /* add offset to force a bug if sa not explicitly dereferenced */
     union {
         struct sockaddr sa;
         struct sockaddr_in in4;
         struct sockaddr_in6 in6;
     } addr;

 };
 

 /* struct to hold preresolved host names */
 struct cached_dns_entry {
     const char *hostname;
     const char *servname;
     int ai_family;
     int flags;
     struct addrinfo *ai;
     struct cached_dns_entry *next;
 };
 

 /* actual address of remote, based on source address of received packets */
 struct link_socket_actual
 {

     /*int dummy;*/ /* add offset to force a bug if dest not explicitly dereferenced */

     struct openvpn_sockaddr dest;

 #if ENABLE_IP_PKTINFO

     union {

 #if defined(HAVE_IN_PKTINFO) && defined(HAVE_IPI_SPEC_DST)

         struct in_pktinfo in4;

 #elif defined(IP_RECVDSTADDR)

         struct in_addr in4;

 #endif

         struct in6_pktinfo in6;
     } pi;

 #endif
 };
 

 /* IP addresses which are persistant across SIGUSR1s */
 struct link_socket_addr
 {

     struct addrinfo *bind_local;
     struct addrinfo *remote_list; /* complete remote list */
     struct addrinfo *current_remote; /* remote used in the
                                       * current connection attempt */
     struct link_socket_actual actual; /* reply to this address */

 };
 
 struct link_socket_info
 {

     struct link_socket_addr *lsa;
     bool connection_established;
     const char *ipchange_command;
     const struct plugin_list *plugins;
     bool remote_float;
     int proto;                  /* Protocol (PROTO_x defined below) */
     sa_family_t af;                     /* Address family like AF_INET, AF_INET6 or AF_UNSPEC*/
     bool bind_ipv6_only;
     int mtu_changed;            /* Set to true when mtu value is changed */

 };
 
 /*
  * Used to extract packets encapsulated in streams into a buffer,
  * in this case IP packets embedded in a TCP stream.
  */
 struct stream_buf
 {

     struct buffer buf_init;
     struct buffer residual;
     int maxlen;
     bool residual_fully_formed;

     struct buffer buf;
     struct buffer next;
     int len;   /* -1 if not yet known */

     bool error; /* if true, fatal TCP error has occurred,
                 *  requiring that connection be restarted */

 #if PORT_SHARE

 #define PS_DISABLED 0
 #define PS_ENABLED  1
 #define PS_FOREIGN  2
     int port_share_state;

 #endif

 };
 
 /*
  * Used to set socket buffer sizes
  */
 struct socket_buffer_size
 {

     int rcvbuf;
     int sndbuf;

 };
 
 /*
  * This is the main socket structure used by OpenVPN.  The SOCKET_
  * defines try to abstract away our implementation differences between
  * using sockets on Posix vs. Win32.
  */
 struct link_socket
 {

     struct link_socket_info info;

     socket_descriptor_t sd;
     socket_descriptor_t ctrl_sd; /* only used for UDP over Socks */

 #ifdef _WIN32

     struct overlapped_io reads;
     struct overlapped_io writes;
     struct rw_handle rw_handle;
     struct rw_handle listen_handle; /* For listening on TCP socket in server mode */

 #endif
 

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

     /* used for long-term queueing of pre-accepted socket listen */
     bool listen_persistent_queued;

     const char *remote_host;
     const char *remote_port;
     const char *local_host;
     const char *local_port;
     struct cached_dns_entry *dns_cache;
     bool bind_local;

 #define INETD_NONE   0
 #define INETD_WAIT   1
 #define INETD_NOWAIT 2
     int inetd;

 #define LS_MODE_DEFAULT           0
 #define LS_MODE_TCP_LISTEN        1
 #define LS_MODE_TCP_ACCEPT_FROM   2
     int mode;

     int resolve_retry_seconds;
     int mtu_discover_type;

     struct socket_buffer_size socket_buffer_sizes;

     int mtu;                    /* OS discovered MTU, or 0 if unknown */

 #define SF_USE_IP_PKTINFO (1<<0)
 #define SF_TCP_NODELAY (1<<1)
 #define SF_PORT_SHARE (1<<2)
 #define SF_HOST_RANDOMIZE (1<<3)
 #define SF_GETADDRINFO_DGRAM (1<<4)
     unsigned int sockflags;
     int mark;

     /* for stream sockets */
     struct stream_buf stream_buf;
     struct buffer stream_buf_data;
     bool stream_reset;

     /* HTTP proxy */
     struct http_proxy_info *http_proxy;

     /* Socks proxy */
     struct socks_proxy_info *socks_proxy;
     struct link_socket_actual socks_relay; /* Socks UDP relay address */

     /* The OpenVPN server we will use the proxy to connect to */
     const char *proxy_dest_host;
     const char *proxy_dest_port;

     /* Pointer to the server-poll to trigger the timeout in function which have
      * their own loop instead of using the main oop */
     struct event_timeout *server_poll_timeout;

 #if PASSTOS_CAPABILITY

     /* used to get/set TOS. */

 #if defined(TARGET_LINUX)

     uint8_t ptos;

 #else /* all the BSDs, Solaris, MacOS use plain "int" -> see "man ip" there */

     int ptos;

 #endif

     bool ptos_defined;

 #endif
 
 #ifdef ENABLE_DEBUG

     int gremlin; /* --gremlin bits */

 #endif
 };
 
 /*
  * Some Posix/Win32 differences.
  */
 
 #ifndef MSG_NOSIGNAL
 #define MSG_NOSIGNAL 0
 #endif
 

 #ifdef _WIN32

 
 #define openvpn_close_socket(s) closesocket(s)
 

 int socket_recv_queue(struct link_socket *sock, int maxsize);

 int socket_send_queue(struct link_socket *sock,
                       struct buffer *buf,
                       const struct link_socket_actual *to);

 int socket_finalize(
     SOCKET s,
     struct overlapped_io *io,
     struct buffer *buf,
     struct link_socket_actual *from);

 #else  /* ifdef _WIN32 */

 
 #define openvpn_close_socket(s) close(s)
 
 #endif
 

 struct link_socket *link_socket_new(void);

 void socket_bind(socket_descriptor_t sd,
                  struct addrinfo *local,
                  int af_family,
                  const char *prefix,
                  bool ipv6only);

 int openvpn_connect(socket_descriptor_t sd,
                     const struct sockaddr *remote,
                     int connect_timeout,
                     volatile int *signal_received);

 /*
  * Initialize link_socket object.
  */
 
 void

 link_socket_init_phase1(struct link_socket *sock,
                         const char *local_host,
                         const char *local_port,
                         const char *remote_host,
                         const char *remote_port,
                         struct cached_dns_entry *dns_cache,
                         int proto,
                         sa_family_t af,
                         bool bind_ipv6_only,
                         int mode,
                         const struct link_socket *accept_from,
                         struct http_proxy_info *http_proxy,
                         struct socks_proxy_info *socks_proxy,

 #ifdef ENABLE_DEBUG

                         int gremlin,

 #endif

                         bool bind_local,
                         bool remote_float,
                         int inetd,
                         struct link_socket_addr *lsa,
                         const char *ipchange_command,
                         const struct plugin_list *plugins,
                         int resolve_retry_seconds,
                         int mtu_discover_type,
                         int rcvbuf,
                         int sndbuf,
                         int mark,
                         struct event_timeout *server_poll_timeout,
                         unsigned int sockflags);
 
 void link_socket_init_phase2(struct link_socket *sock,
                              const struct frame *frame,
                              struct signal_info *sig_info);

 void do_preresolve(struct context *c);
 

 void socket_adjust_frame_parameters(struct frame *frame, int proto);

 void frame_adjust_path_mtu(struct frame *frame, int pmtu, int proto);

 void link_socket_close(struct link_socket *sock);

 void sd_close(socket_descriptor_t *sd);

 #define PS_SHOW_PORT_IF_DEFINED (1<<0)
 #define PS_SHOW_PORT            (1<<1)
 #define PS_SHOW_PKTINFO         (1<<2)

 #define PS_DONT_SHOW_ADDR       (1<<3)

 #define PS_DONT_SHOW_FAMILY     (1<<4)

 const char *print_sockaddr_ex(const struct sockaddr *addr,
                               const char *separator,
                               const unsigned int flags,
                               struct gc_arena *gc);

 static inline

 const char *
 print_openvpn_sockaddr_ex(const struct openvpn_sockaddr *addr,
                           const char *separator,
                           const unsigned int flags,
                           struct gc_arena *gc)

 {
     return print_sockaddr_ex(&addr->addr.sa, separator, flags, gc);
 }

 static inline

 const char *
 print_openvpn_sockaddr(const struct openvpn_sockaddr *addr,
                        struct gc_arena *gc)

 {

     return print_sockaddr_ex(&addr->addr.sa, ":", PS_SHOW_PORT, gc);

 }

 static inline

 const char *
 print_sockaddr(const struct sockaddr *addr,
                struct gc_arena *gc)

 {

     return print_sockaddr_ex(addr, ":", PS_SHOW_PORT, gc);

 }
 
 
 

 const char *print_link_socket_actual_ex(const struct link_socket_actual *act,
                                         const char *separator,
                                         const unsigned int flags,
                                         struct gc_arena *gc);

 const char *print_link_socket_actual(const struct link_socket_actual *act,
                                      struct gc_arena *gc);

 #define IA_EMPTY_IF_UNDEF (1<<0)
 #define IA_NET_ORDER      (1<<1)

 const char *print_in_addr_t(in_addr_t addr, unsigned int flags, struct gc_arena *gc);
 
 const char *print_in6_addr(struct in6_addr addr6, unsigned int flags, struct gc_arena *gc);
 

 struct in6_addr add_in6_addr( struct in6_addr base, uint32_t add );

 
 #define SA_IP_PORT        (1<<0)
 #define SA_SET_IF_NONZERO (1<<1)

 void setenv_sockaddr(struct env_set *es,
                      const char *name_prefix,
                      const struct openvpn_sockaddr *addr,
                      const unsigned int flags);

 void setenv_in_addr_t(struct env_set *es,

                       const char *name_prefix,

                       in_addr_t addr,

                       const unsigned int flags);
 

 void setenv_in6_addr(struct env_set *es,
                      const char *name_prefix,
                      const struct in6_addr *addr,
                      const unsigned int flags);
 
 void setenv_link_socket_actual(struct env_set *es,
                                const char *name_prefix,
                                const struct link_socket_actual *act,
                                const unsigned int flags);

 void bad_address_length(int actual, int expected);

 /* IPV4_INVALID_ADDR: returned by link_socket_current_remote()
  * to ease redirect-gateway logic for ipv4 tunnels on ipv6 endpoints
  */
 #define IPV4_INVALID_ADDR 0xffffffff

 in_addr_t link_socket_current_remote(const struct link_socket_info *info);
 
 const struct in6_addr *link_socket_current_remote_ipv6
     (const struct link_socket_info *info);

 void link_socket_connection_initiated(const struct buffer *buf,
                                       struct link_socket_info *info,
                                       const struct link_socket_actual *addr,
                                       const char *common_name,
                                       struct env_set *es);

 void link_socket_bad_incoming_addr(struct buffer *buf,
                                    const struct link_socket_info *info,
                                    const struct link_socket_actual *from_addr);

 void set_actual_address(struct link_socket_actual *actual,
                         struct addrinfo *ai);

 void link_socket_bad_outgoing_addr(void);

 void setenv_trusted(struct env_set *es, const struct link_socket_info *info);

 bool link_socket_update_flags(struct link_socket *ls, unsigned int sockflags);
 
 void link_socket_update_buffer_sizes(struct link_socket *ls, int rcvbuf, int sndbuf);

 /*
  * Low-level functions
  */
 
 /* return values of openvpn_inet_aton */
 #define OIA_HOSTNAME   0
 #define OIA_IP         1
 #define OIA_ERROR     -1

 int openvpn_inet_aton(const char *dotted_quad, struct in_addr *addr);

 
 /* integrity validation on pulled options */

 bool ip_addr_dotted_quad_safe(const char *dotted_quad);
 
 bool ip_or_dns_addr_safe(const char *addr, const bool allow_fqdn);
 
 bool mac_addr_safe(const char *mac_addr);

 bool ipv6_addr_safe(const char *ipv6_text_addr);
 
 socket_descriptor_t create_socket_tcp(struct addrinfo *);
 
 socket_descriptor_t socket_do_accept(socket_descriptor_t sd,
                                      struct link_socket_actual *act,
                                      const bool nowait);

 /*
  * proto related
  */
 bool proto_is_net(int proto);

 bool proto_is_dgram(int proto);

 bool proto_is_udp(int proto);

 bool proto_is_tcp(int proto);
 

 #if UNIX_SOCK_SUPPORT
 

 socket_descriptor_t create_socket_unix(void);

 void socket_bind_unix(socket_descriptor_t sd,
                       struct sockaddr_un *local,
                       const char *prefix);

 socket_descriptor_t socket_accept_unix(socket_descriptor_t sd,
                                        struct sockaddr_un *remote);

 int socket_connect_unix(socket_descriptor_t sd,
                         struct sockaddr_un *remote);

 void sockaddr_unix_init(struct sockaddr_un *local, const char *path);

 const char *sockaddr_unix_name(const struct sockaddr_un *local, const char *null);

 void socket_delete_unix(const struct sockaddr_un *local);

 bool unix_socket_get_peer_uid_gid(const socket_descriptor_t sd, int *uid, int *gid);

 #endif /* if UNIX_SOCK_SUPPORT */

 /*
  * DNS resolution
  */
 
 #define GETADDR_RESOLVE               (1<<0)
 #define GETADDR_FATAL                 (1<<1)
 #define GETADDR_HOST_ORDER            (1<<2)
 #define GETADDR_MENTION_RESOLVE_RETRY (1<<3)
 #define GETADDR_FATAL_ON_SIGNAL       (1<<4)
 #define GETADDR_WARN_ON_SIGNAL        (1<<5)
 #define GETADDR_MSG_VIRT_OUT          (1<<6)
 #define GETADDR_TRY_ONCE              (1<<7)

 #define GETADDR_UPDATE_MANAGEMENT_STATE (1<<8)

 #define GETADDR_RANDOMIZE             (1<<9)

 #define GETADDR_PASSIVE               (1<<10)

 #define GETADDR_DATAGRAM              (1<<11)

 #define GETADDR_CACHE_MASK              (GETADDR_DATAGRAM|GETADDR_PASSIVE)

 in_addr_t getaddr(unsigned int flags,
                   const char *hostname,
                   int resolve_retry_seconds,
                   bool *succeeded,
                   volatile int *signal_received);

 int openvpn_getaddrinfo(unsigned int flags,
                         const char *hostname,
                         const char *servname,
                         int resolve_retry_seconds,
                         volatile int *signal_received,
                         int ai_family,
                         struct addrinfo **res);

 /*
  * Transport protocol naming and other details.
  */
 

 /*

  * Use enum's instead of #define to allow for easier
  * optional proto support
  */
 enum proto_num {

     PROTO_NONE,     /* catch for uninitialized */
     PROTO_UDP,
     PROTO_TCP,
     PROTO_TCP_SERVER,
     PROTO_TCP_CLIENT,
     PROTO_N

 };

 int ascii2proto(const char *proto_name);
 
 sa_family_t ascii2af(const char *proto_name);
 
 const char *proto2ascii(int proto, sa_family_t af, bool display_form);
 
 const char *proto2ascii_all(struct gc_arena *gc);
 
 const char *proto_remote(int proto, bool remote);
 

 const char *addr_family_name(int af);

 
 /*
  * Overhead added to packets by various protocols.
  */
 #define IPv4_UDP_HEADER_SIZE              28
 #define IPv4_TCP_HEADER_SIZE              40

 #define IPv6_UDP_HEADER_SIZE              48
 #define IPv6_TCP_HEADER_SIZE              60

 extern const int proto_overhead[];

 
 static inline int

 datagram_overhead(int proto)

 {

     ASSERT(proto >= 0 && proto < PROTO_N);
     return proto_overhead [proto];

 }
 
 /*
  * Misc inline functions
  */
 
 static inline bool

 link_socket_proto_connection_oriented(int proto)

 {

     return !proto_is_dgram(proto);

 }
 
 static inline bool

 link_socket_connection_oriented(const struct link_socket *sock)

 {

     if (sock)
     {
         return link_socket_proto_connection_oriented(sock->info.proto);
     }
     else
     {
         return false;
     }

 }
 
 static inline bool

 addr_defined(const struct openvpn_sockaddr *addr)

 {

     if (!addr)
     {
         return 0;
     }

     switch (addr->addr.sa.sa_family)
     {

         case AF_INET: return addr->addr.in4.sin_addr.s_addr != 0;
 
         case AF_INET6: return !IN6_IS_ADDR_UNSPECIFIED(&addr->addr.in6.sin6_addr);
 
         default: return 0;
     }

 }

 
 static inline bool

 addr_local(const struct sockaddr *addr)

 {
     if (!addr)

     {
         return false;
     }

     switch (addr->sa_family)
     {

         case AF_INET:
             return ((const struct sockaddr_in *)addr)->sin_addr.s_addr == htonl(INADDR_LOOPBACK);
 
         case AF_INET6:
             return IN6_IS_ADDR_LOOPBACK(&((const struct sockaddr_in6 *)addr)->sin6_addr);
 
         default:
             return false;

     }
 }
 
 

 static inline bool

 addr_defined_ipi(const struct link_socket_actual *lsa)

 {
 #if ENABLE_IP_PKTINFO

     if (!lsa)
     {
         return 0;
     }

     switch (lsa->dest.addr.sa.sa_family)
     {

 #if defined(HAVE_IN_PKTINFO) && defined(HAVE_IPI_SPEC_DST)

         case AF_INET: return lsa->pi.in4.ipi_spec_dst.s_addr != 0;
 

 #elif defined(IP_RECVDSTADDR)

         case AF_INET: return lsa->pi.in4.s_addr != 0;
 

 #endif

         case AF_INET6: return !IN6_IS_ADDR_UNSPECIFIED(&lsa->pi.in6.ipi6_addr);
 
         default: return 0;
     }
 #else  /* if ENABLE_IP_PKTINFO */
     ASSERT(0);

 #endif

     return false;

 }
 
 static inline bool

 link_socket_actual_defined(const struct link_socket_actual *act)

 {

     return act && addr_defined(&act->dest);

 }
 
 static inline bool

 addr_match(const struct openvpn_sockaddr *a1, const struct openvpn_sockaddr *a2)

 {

     switch (a1->addr.sa.sa_family)
     {

         case AF_INET:
             return a1->addr.in4.sin_addr.s_addr == a2->addr.in4.sin_addr.s_addr;
 
         case AF_INET6:
             return IN6_ARE_ADDR_EQUAL(&a1->addr.in6.sin6_addr, &a2->addr.in6.sin6_addr);
     }
     ASSERT(0);
     return false;

 }
 

 static inline bool

 addrlist_match(const struct openvpn_sockaddr *a1, const struct addrinfo *addrlist)

 {

     const struct addrinfo *curele;
     for (curele = addrlist; curele; curele = curele->ai_next)

     {

         switch (a1->addr.sa.sa_family)

         {

             case AF_INET:
                 if (a1->addr.in4.sin_addr.s_addr == ((struct sockaddr_in *)curele->ai_addr)->sin_addr.s_addr)
                 {
                     return true;
                 }
                 break;
 
             case AF_INET6:
                 if (IN6_ARE_ADDR_EQUAL(&a1->addr.in6.sin6_addr, &((struct sockaddr_in6 *) curele->ai_addr)->sin6_addr))
                 {
                     return true;
                 }
                 break;
 
             default:
                 ASSERT(0);

         }
     }

     return false;

 }
 

 static inline in_addr_t

 addr_host(const struct openvpn_sockaddr *addr)

 {

     /*
      * "public" addr returned is checked against ifconfig for
      * possible clash: non sense for now given
      * that we do ifconfig only IPv4
      */
     if (addr->addr.sa.sa_family != AF_INET)
     {
         return 0;
     }
     return ntohl(addr->addr.in4.sin_addr.s_addr);

 }
 

 
 static inline bool

 addrlist_port_match(const struct openvpn_sockaddr *a1, const struct addrinfo *a2)

 {

     const struct addrinfo *curele;
     for (curele = a2; curele; curele = curele->ai_next)

     {

         switch (a1->addr.sa.sa_family)

         {

             case AF_INET:
                 if (curele->ai_family == AF_INET
                     && a1->addr.in4.sin_addr.s_addr == ((struct sockaddr_in *)curele->ai_addr)->sin_addr.s_addr
                     && a1->addr.in4.sin_port == ((struct sockaddr_in *)curele->ai_addr)->sin_port)
                 {
                     return true;
                 }

                 break;

 
             case AF_INET6:

                 if (curele->ai_family == AF_INET6

                     && IN6_ARE_ADDR_EQUAL(&a1->addr.in6.sin6_addr, &((struct sockaddr_in6 *) curele->ai_addr)->sin6_addr)
                     && a1->addr.in6.sin6_port == ((struct sockaddr_in6 *) curele->ai_addr)->sin6_port)
                 {

                     return true;

                 }

                 break;

 
             default:

                 ASSERT(0);
         }
     }

     return false;

 }
 
 
 

 static inline bool

 addr_port_match(const struct openvpn_sockaddr *a1, const struct openvpn_sockaddr *a2)

 {

     switch (a1->addr.sa.sa_family)
     {

         case AF_INET:
             return a1->addr.in4.sin_addr.s_addr == a2->addr.in4.sin_addr.s_addr
                    && a1->addr.in4.sin_port == a2->addr.in4.sin_port;
 
         case AF_INET6:
             return IN6_ARE_ADDR_EQUAL(&a1->addr.in6.sin6_addr, &a2->addr.in6.sin6_addr)
                    && a1->addr.in6.sin6_port == a2->addr.in6.sin6_port;
     }
     ASSERT(0);
     return false;

 }
 
 static inline bool

 addr_match_proto(const struct openvpn_sockaddr *a1,
                  const struct openvpn_sockaddr *a2,
                  const int proto)

 {

     return link_socket_proto_connection_oriented(proto)
            ? addr_match(a1, a2)
            : addr_port_match(a1, a2);

 }
 

 
 static inline bool

 addrlist_match_proto(const struct openvpn_sockaddr *a1,
                      struct addrinfo *addr_list,
                      const int proto)

 {

     return link_socket_proto_connection_oriented(proto)
            ? addrlist_match(a1, addr_list)
            : addrlist_port_match(a1, addr_list);

 }
 

 static inline void
 addr_zero_host(struct openvpn_sockaddr *addr)
 {

     switch (addr->addr.sa.sa_family)
     {

         case AF_INET:
             addr->addr.in4.sin_addr.s_addr = 0;
             break;
 
         case AF_INET6:
             memset(&addr->addr.in6.sin6_addr, 0, sizeof(struct in6_addr));
             break;
     }

 }
 
 static inline void
 addr_copy_sa(struct openvpn_sockaddr *dst, const struct openvpn_sockaddr *src)
 {

     dst->addr = src->addr;

 }
 
 static inline bool
 addr_inet4or6(struct sockaddr *addr)
 {

     return addr->sa_family == AF_INET || addr->sa_family == AF_INET6;

 }
 

 int addr_guess_family(sa_family_t af,const char *name);

 static inline int

 af_addr_size(sa_family_t af)

 {

     switch (af)
     {

         case AF_INET: return sizeof(struct sockaddr_in);
 
         case AF_INET6: return sizeof(struct sockaddr_in6);
 
         default:

 #if 0

             /* could be called from socket_do_accept() with empty addr */
             msg(M_ERR, "Bad address family: %d\n", af);
             ASSERT(0);

 #endif

             return 0;
     }

 }
 

 static inline bool

 link_socket_actual_match(const struct link_socket_actual *a1, const struct link_socket_actual *a2)

 {

     return addr_port_match(&a1->dest, &a2->dest);

 }
 

 #if PORT_SHARE
 
 static inline bool

 socket_foreign_protocol_detected(const struct link_socket *sock)

 {

     return link_socket_connection_oriented(sock)
            && sock->stream_buf.port_share_state == PS_FOREIGN;

 }
 
 static inline const struct buffer *

 socket_foreign_protocol_head(const struct link_socket *sock)

 {

     return &sock->stream_buf.buf;

 }
 
 static inline int

 socket_foreign_protocol_sd(const struct link_socket *sock)

 {

     return sock->sd;

 }
 

 #endif /* if PORT_SHARE */

 static inline bool

 socket_connection_reset(const struct link_socket *sock, int status)

 {

     if (link_socket_connection_oriented(sock))

     {

         if (sock->stream_reset || sock->stream_buf.error)
         {
             return true;
         }
         else if (status < 0)
         {
             const int err = openvpn_errno();

 #ifdef _WIN32

             return err == WSAECONNRESET || err == WSAECONNABORTED;

 #else

             return err == ECONNRESET;

 #endif

         }

     }

     return false;

 }
 
 static inline bool

 link_socket_verify_incoming_addr(struct buffer *buf,
                                  const struct link_socket_info *info,
                                  const struct link_socket_actual *from_addr)

 {

     if (buf->len > 0)

     {

         switch (from_addr->dest.addr.sa.sa_family)
         {

             case AF_INET6:
             case AF_INET:
                 if (!link_socket_actual_defined(from_addr))
                 {
                     return false;
                 }
                 if (info->remote_float || (!info->lsa->remote_list))
                 {
                     return true;
                 }
                 if (addrlist_match_proto(&from_addr->dest, info->lsa->remote_list, info->proto))
                 {
                     return true;
                 }
         }

     }

     return false;

 }
 
 static inline void

 link_socket_get_outgoing_addr(struct buffer *buf,
                               const struct link_socket_info *info,
                               struct link_socket_actual **act)

 {

     if (buf->len > 0)

     {

         struct link_socket_addr *lsa = info->lsa;
         if (link_socket_actual_defined(&lsa->actual))
         {
             *act = &lsa->actual;
         }
         else
         {
             link_socket_bad_outgoing_addr();
             buf->len = 0;
             *act = NULL;
         }

     }
 }
 
 static inline void

 link_socket_set_outgoing_addr(const struct buffer *buf,
                               struct link_socket_info *info,
                               const struct link_socket_actual *act,
                               const char *common_name,
                               struct env_set *es)

 {

     if (!buf || buf->len > 0)

     {

         struct link_socket_addr *lsa = info->lsa;
         if (
             /* new or changed address? */
             (!info->connection_established
              || !addr_match_proto(&act->dest, &lsa->actual.dest, info->proto)
             )
             &&
             /* address undef or address == remote or --float */
             (info->remote_float
              || (!lsa->remote_list || addrlist_match_proto(&act->dest, lsa->remote_list, info->proto))
             )
             )
         {
             link_socket_connection_initiated(buf, info, act, common_name, es);
         }

     }
 }
 
 static inline bool

 stream_buf_read_setup(struct link_socket *sock)

 {

     bool stream_buf_read_setup_dowork(struct link_socket *sock);
 
     if (link_socket_connection_oriented(sock))
     {
         return stream_buf_read_setup_dowork(sock);
     }
     else
     {
         return true;
     }

 }
 
 /*
  * Socket Read Routines
  */
 

 int link_socket_read_tcp(struct link_socket *sock,
                          struct buffer *buf);

 #ifdef _WIN32

 
 static inline int

 link_socket_read_udp_win32(struct link_socket *sock,
                            struct buffer *buf,
                            struct link_socket_actual *from)

 {

     return socket_finalize(sock->sd, &sock->reads, buf, from);

 }
 

 #else  /* ifdef _WIN32 */

 int link_socket_read_udp_posix(struct link_socket *sock,
                                struct buffer *buf,
                                struct link_socket_actual *from);

 
 #endif
 
 /* read a TCP or UDP packet from link */
 static inline int

 link_socket_read(struct link_socket *sock,
                  struct buffer *buf,
                  struct link_socket_actual *from)

 {

     if (proto_is_udp(sock->info.proto)) /* unified UDPv4 and UDPv6 */

     {

         int res;

 #ifdef _WIN32

         res = link_socket_read_udp_win32(sock, buf, from);

 #else

         res = link_socket_read_udp_posix(sock, buf, from);

 #endif

         return res;

     }

     else if (proto_is_tcp(sock->info.proto)) /* unified TCPv4 and TCPv6 */

     {

         /* from address was returned by accept */
         addr_copy_sa(&from->dest, &sock->info.lsa->actual.dest);
         return link_socket_read_tcp(sock, buf);

     }

     else

     {

         ASSERT(0);
         return -1; /* NOTREACHED */

     }
 }
 
 /*
  * Socket Write routines
  */
 

 int link_socket_write_tcp(struct link_socket *sock,
                           struct buffer *buf,
                           struct link_socket_actual *to);

 #ifdef _WIN32

 
 static inline int

 link_socket_write_win32(struct link_socket *sock,
                         struct buffer *buf,
                         struct link_socket_actual *to)

 {

     int err = 0;
     int status = 0;
     if (overlapped_io_active(&sock->writes))

     {

         status = socket_finalize(sock->sd, &sock->writes, NULL, NULL);
         if (status < 0)
         {
             err = WSAGetLastError();
         }

     }

     socket_send_queue(sock, buf, to);
     if (status < 0)

     {

         WSASetLastError(err);
         return status;
     }
     else
     {
         return BLEN(buf);

     }
 }
 

 #else  /* ifdef _WIN32 */

 static inline size_t

 link_socket_write_udp_posix(struct link_socket *sock,
                             struct buffer *buf,
                             struct link_socket_actual *to)

 {

 #if ENABLE_IP_PKTINFO

     size_t link_socket_write_udp_posix_sendmsg(struct link_socket *sock,
                                                struct buffer *buf,
                                                struct link_socket_actual *to);
 
     if (proto_is_udp(sock->info.proto) && (sock->sockflags & SF_USE_IP_PKTINFO)
         && addr_defined_ipi(to))
     {
         return link_socket_write_udp_posix_sendmsg(sock, buf, to);
     }
     else

 #endif

     return sendto(sock->sd, BPTR(buf), BLEN(buf), 0,
                   (struct sockaddr *) &to->dest.addr.sa,
                   (socklen_t) af_addr_size(to->dest.addr.sa.sa_family));

 }
 

 static inline size_t

 link_socket_write_tcp_posix(struct link_socket *sock,
                             struct buffer *buf,
                             struct link_socket_actual *to)

 {

     return send(sock->sd, BPTR(buf), BLEN(buf), MSG_NOSIGNAL);

 }
 

 #endif /* ifdef _WIN32 */

 static inline size_t

 link_socket_write_udp(struct link_socket *sock,
                       struct buffer *buf,
                       struct link_socket_actual *to)

 {

 #ifdef _WIN32

     return link_socket_write_win32(sock, buf, to);

 #else

     return link_socket_write_udp_posix(sock, buf, to);

 #endif
 }
 
 /* write a TCP or UDP packet to link */
 static inline int

 link_socket_write(struct link_socket *sock,
                   struct buffer *buf,
                   struct link_socket_actual *to)

 {

     if (proto_is_udp(sock->info.proto)) /* unified UDPv4 and UDPv6 */

     {

         return link_socket_write_udp(sock, buf, to);

     }

     else if (proto_is_tcp(sock->info.proto)) /* unified TCPv4 and TCPv6 */

     {

         return link_socket_write_tcp(sock, buf, to);

     }

     else

     {

         ASSERT(0);
         return -1; /* NOTREACHED */

     }
 }
 
 #if PASSTOS_CAPABILITY
 
 /*
  * Extract TOS bits.  Assumes that ipbuf is a valid IPv4 packet.
  */
 static inline void

 link_socket_extract_tos(struct link_socket *ls, const struct buffer *ipbuf)

 {

     if (ls && ipbuf)

     {

         struct openvpn_iphdr *iph = (struct openvpn_iphdr *) BPTR(ipbuf);
         ls->ptos = iph->tos;
         ls->ptos_defined = true;

     }
 }
 
 /*
  * Set socket properties to reflect TOS bits which were extracted
  * from tunnel packet.
  */
 static inline void

 link_socket_set_tos(struct link_socket *ls)

 {

     if (ls && ls->ptos_defined)
     {
         setsockopt(ls->sd, IPPROTO_IP, IP_TOS, (const void *)&ls->ptos, sizeof(ls->ptos));
     }

 }
 

 #endif /* if PASSTOS_CAPABILITY */

 
 /*
  * Socket I/O wait functions
  */
 
 static inline bool

 socket_read_residual(const struct link_socket *s)

 {

     return s && s->stream_buf.residual_fully_formed;

 }
 
 static inline event_t

 socket_event_handle(const struct link_socket *s)

 {

 #ifdef _WIN32

     return &s->rw_handle;

 #else

     return s->sd;

 #endif
 }
 

 event_t socket_listen_event_handle(struct link_socket *s);

 
 unsigned int

 socket_set(struct link_socket *s,
            struct event_set *es,
            unsigned int rwflags,
            void *arg,
            unsigned int *persistent);

 
 static inline void

 socket_set_listen_persistent(struct link_socket *s,
                              struct event_set *es,
                              void *arg)

 {

     if (s && !s->listen_persistent_queued)

     {

         event_ctl(es, socket_listen_event_handle(s), EVENT_READ, arg);
         s->listen_persistent_queued = true;

     }
 }
 
 static inline void

 socket_reset_listen_persistent(struct link_socket *s)

 {

 #ifdef _WIN32

     reset_net_event_win32(&s->listen_handle, s->sd);

 #endif
 }
 

 const char *socket_stat(const struct link_socket *s, unsigned int rwflags, struct gc_arena *gc);

 
 #endif /* SOCKET_H */