/**

 * @file network.c Network Implementation

 * @ingroup core

 */

/* purple

 *

 * Purple is the legal property of its developers, whose names are too numerous

 * to list here.  Please refer to the COPYRIGHT file distributed with this

 * source distribution.

 *

 * This program 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 of the License, or

 * (at your option) any later version.

 *

 * 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  02111-1301  USA

 */

#include "internal.h"

#ifndef _WIN32

#include <arpa/nameser.h>

#include <resolv.h>

#include <netinet/in.h>

#include <net/if.h>

#include <sys/ioctl.h>

#ifdef HAVE_GETIFADDRS

#include <ifaddrs.h>

#endif

#else

#include <nspapi.h>

#endif

/* Solaris */

#if defined (__SVR4) && defined (__sun)

#include <sys/sockio.h>

#endif

#include "debug.h"

#include "account.h"

#include "nat-pmp.h"

#include "network.h"

#include "prefs.h"

#include "stun.h"

#include "upnp.h"

#include "dnsquery.h"

#ifdef USE_IDN

#include <idna.h>

#endif

#ifdef __HAIKU__

#  ifndef SIOCGIFCONF

#    include <sys/sockio.h>

#  endif

#endif

/*

 * Calling sizeof(struct ifreq) isn't always correct on

 * Mac OS X (and maybe others).

 */

#ifdef _SIZEOF_ADDR_IFREQ

#  define HX_SIZE_OF_IFREQ(a) _SIZEOF_ADDR_IFREQ(a)

#else

#  define HX_SIZE_OF_IFREQ(a) sizeof(a)

#endif

#ifdef HAVE_NETWORKMANAGER

#include <dbus/dbus-glib.h>

#include <NetworkManager.h>

#if !defined(NM_CHECK_VERSION)

#define NM_CHECK_VERSION(x,y,z) 0

#endif

static DBusGConnection *nm_conn = NULL;

static DBusGProxy *nm_proxy = NULL;

static DBusGProxy *dbus_proxy = NULL;

static NMState nm_state = NM_STATE_UNKNOWN;

static gboolean have_nm_state = FALSE;

#elif defined _WIN32

static int current_network_count;

/* Mutex for the other global vars */

static GStaticMutex mutex = G_STATIC_MUTEX_INIT;

static gboolean network_initialized = FALSE;

static HANDLE network_change_handle = NULL;

static int (WSAAPI *MyWSANSPIoctl) (

    HANDLE hLookup, DWORD dwControlCode, LPVOID lpvInBuffer,

    DWORD cbInBuffer, LPVOID lpvOutBuffer, DWORD cbOutBuffer,

    LPDWORD lpcbBytesReturned, LPWSACOMPLETION lpCompletion) = NULL;

#endif

struct _PurpleNetworkListenData {

  int listenfd;

  int socket_type;

  gboolean retry;

  gboolean adding;

  PurpleNetworkListenCallback cb;

  gpointer cb_data;

  UPnPMappingAddRemove *mapping_data;

  int timer;

};

#ifdef HAVE_NETWORKMANAGER

static NMState nm_get_network_state(void);

#endif

#if defined(HAVE_NETWORKMANAGER) || defined(_WIN32)

static gboolean force_online;

#endif

/* Cached IP addresses for STUN and TURN servers (set globally in prefs) */

static gchar *stun_ip = NULL;

static gchar *turn_ip = NULL;

/* Keep track of port mappings done with UPnP and NAT-PMP */

static GHashTable *upnp_port_mappings = NULL;

static GHashTable *nat_pmp_port_mappings = NULL;

const unsigned char *

purple_network_ip_atoi(const char *ip)

{

  static unsigned char ret[4];

  gchar *delimiter = ".";

  gchar **split;

  int i;

  g_return_val_if_fail(ip != NULL, NULL);

  split = g_strsplit(ip, delimiter, 4);

  for (i = 0; split[i] != NULL; i++)

    ret[i] = atoi(split[i]);

  g_strfreev(split);

  /* i should always be 4 */

  if (i != 4)

    return NULL;

  return ret;

}

void

purple_network_set_public_ip(const char *ip)

{

  g_return_if_fail(ip != NULL);

  /* XXX - Ensure the IP address is valid */

  purple_prefs_set_string("/purple/network/public_ip", ip);

}

const char *

purple_network_get_public_ip(void)

{

  return purple_prefs_get_string("/purple/network/public_ip");

}

const char *

purple_network_get_local_system_ip(int fd)

{

  char buffer[1024];

  static char ip[16];

  char *tmp;

  struct ifconf ifc;

  struct ifreq *ifr;

  struct sockaddr_in *sinptr;

  guint32 lhost = htonl((127 << 24) + 1); /* 127.0.0.1 */

  long unsigned int add;

  int source = fd;

  if (fd < 0)

    source = socket(PF_INET,SOCK_STREAM, 0);

  ifc.ifc_len = sizeof(buffer);

  ifc.ifc_req = (struct ifreq *)buffer;

  ioctl(source, SIOCGIFCONF, &ifc);

  if (fd < 0 && source >= 0)

    close(source);

  tmp = buffer;

  while (tmp < buffer + ifc.ifc_len)

  {

    ifr = (struct ifreq *)tmp;

    tmp += HX_SIZE_OF_IFREQ(*ifr);

    if (ifr->ifr_addr.sa_family == AF_INET)

    {

      sinptr = (struct sockaddr_in *)&ifr->ifr_addr;

      if (sinptr->sin_addr.s_addr != lhost)

      {

        add = ntohl(sinptr->sin_addr.s_addr);

        g_snprintf(ip, 16, "%lu.%lu.%lu.%lu",

          ((add >> 24) & 255),

          ((add >> 16) & 255),

          ((add >> 8) & 255),

          add & 255);

        return ip;

      }

    }

  }

  return "0.0.0.0";

}

GList *

purple_network_get_all_local_system_ips(void)

{

#if defined(HAVE_GETIFADDRS) && defined(HAVE_INET_NTOP)

  GList *result = NULL;

  struct ifaddrs *start, *ifa;

  int ret;

  ret = getifaddrs(&start);

  if (ret < 0) {

    purple_debug_warning("network",

        "getifaddrs() failed: %s\n", g_strerror(errno));

    return NULL;

  }

  for (ifa = start; ifa; ifa = ifa->ifa_next) {

    int family = ifa->ifa_addr ? ifa->ifa_addr->sa_family : AF_UNSPEC;

    char host[INET6_ADDRSTRLEN];

    const char *tmp = NULL;

    if ((family != AF_INET && family != AF_INET6) || ifa->ifa_flags & IFF_LOOPBACK)

      continue;

    if (family == AF_INET)

      tmp = inet_ntop(family, &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr, host, sizeof(host));

    else {

      struct sockaddr_in6 *sockaddr = (struct sockaddr_in6 *)ifa->ifa_addr;

      /* Peer-peer link-local communication is a big TODO.  I am not sure

       * how communicating link-local addresses is supposed to work, and

       * it seems like it would require attempting the cartesian product

       * of the local and remote interfaces to see if any match (eww).

       */

      if (!IN6_IS_ADDR_LINKLOCAL(&sockaddr->sin6_addr))

        tmp = inet_ntop(family, &sockaddr->sin6_addr, host, sizeof(host));

    }

    if (tmp != NULL)

      result = g_list_prepend(result, g_strdup(tmp));

  }

  freeifaddrs(start);

  return g_list_reverse(result);

#else /* HAVE_GETIFADDRS && HAVE_INET_NTOP */

  GList *result = NULL;

  int source = socket(PF_INET,SOCK_STREAM, 0);

  char buffer[1024];

  char *tmp;

  struct ifconf ifc;

  struct ifreq *ifr;

  ifc.ifc_len = sizeof(buffer);

  ifc.ifc_req = (struct ifreq *)buffer;

  ioctl(source, SIOCGIFCONF, &ifc);

  close(source);

  tmp = buffer;

  while (tmp < buffer + ifc.ifc_len) {

    char dst[INET_ADDRSTRLEN];

    ifr = (struct ifreq *)tmp;

    tmp += HX_SIZE_OF_IFREQ(*ifr);

    if (ifr->ifr_addr.sa_family == AF_INET) {

      struct sockaddr_in *sinptr = (struct sockaddr_in *)&ifr->ifr_addr;

      inet_ntop(AF_INET, &sinptr->sin_addr, dst,

        sizeof(dst));

      purple_debug_info("network",

        "found local i/f with address %s on IPv4\n", dst);

      if (!purple_strequal(dst, "127.0.0.1")) {

        result = g_list_append(result, g_strdup(dst));

      }

    }

  }

  return result;

#endif /* HAVE_GETIFADDRS && HAVE_INET_NTOP */

}

const char *

purple_network_get_my_ip(int fd)

{

  const char *ip = NULL;

  PurpleStunNatDiscovery *stun;

  /* Check if the user specified an IP manually */

  if (!purple_prefs_get_bool("/purple/network/auto_ip")) {

    ip = purple_network_get_public_ip();

    /* Make sure the IP address entered by the user is valid */

    if ((ip != NULL) && (purple_network_ip_atoi(ip) != NULL))

      return ip;

  } else {

    /* Check if STUN discovery was already done */

    stun = purple_stun_discover(NULL);

    if ((stun != NULL) && (stun->status == PURPLE_STUN_STATUS_DISCOVERED))

      return stun->publicip;

    /* Attempt to get the IP from a NAT device using UPnP */

    ip = purple_upnp_get_public_ip();

    if (ip != NULL)

      return ip;

    /* Attempt to get the IP from a NAT device using NAT-PMP */

    ip = purple_pmp_get_public_ip();

    if (ip != NULL)

      return ip;

  }

  /* Just fetch the IP of the local system */

  return purple_network_get_local_system_ip(fd);

}

static void

purple_network_set_upnp_port_mapping_cb(gboolean success, gpointer data)

{

  PurpleNetworkListenData *listen_data;

  listen_data = data;

  /* TODO: Once we're keeping track of upnp requests... */

  /* listen_data->pnp_data = NULL; */

  if (!success) {

    purple_debug_warning("network", "Couldn't create UPnP mapping\n");

    if (listen_data->retry) {

      listen_data->retry = FALSE;

      listen_data->adding = FALSE;

      listen_data->mapping_data = purple_upnp_remove_port_mapping(

            purple_network_get_port_from_fd(listen_data->listenfd),

            (listen_data->socket_type == SOCK_STREAM) ? "TCP" : "UDP",

            purple_network_set_upnp_port_mapping_cb, listen_data);

      return;

    }

  } else if (!listen_data->adding) {

    /* We've tried successfully to remove the port mapping.

     * Try to add it again */

    listen_data->adding = TRUE;

    listen_data->mapping_data = purple_upnp_set_port_mapping(

          purple_network_get_port_from_fd(listen_data->listenfd),

          (listen_data->socket_type == SOCK_STREAM) ? "TCP" : "UDP",

          purple_network_set_upnp_port_mapping_cb, listen_data);

    return;

  }

  if (success) {

    /* add port mapping to hash table */

    gint key = purple_network_get_port_from_fd(listen_data->listenfd);

    gint value = listen_data->socket_type;

    g_hash_table_insert(upnp_port_mappings, GINT_TO_POINTER(key), GINT_TO_POINTER(value));

  }

  if (listen_data->cb)

    listen_data->cb(listen_data->listenfd, listen_data->cb_data);

  /* Clear the UPnP mapping data, since it's complete and purple_network_listen_cancel() will try to cancel

   * it otherwise. */

  listen_data->mapping_data = NULL;

  purple_network_listen_cancel(listen_data);

}

static gboolean

purple_network_finish_pmp_map_cb(gpointer data)

{

  PurpleNetworkListenData *listen_data;

  gint key;

  gint value;

  listen_data = data;

  listen_data->timer = 0;

  /* add port mapping to hash table */

  key = purple_network_get_port_from_fd(listen_data->listenfd);

  value = listen_data->socket_type;

  g_hash_table_insert(nat_pmp_port_mappings, GINT_TO_POINTER(key), GINT_TO_POINTER(value));

  if (listen_data->cb)

    listen_data->cb(listen_data->listenfd, listen_data->cb_data);

  purple_network_listen_cancel(listen_data);

  return FALSE;

}

static gboolean listen_map_external = TRUE;

void purple_network_listen_map_external(gboolean map_external)

{

  listen_map_external = map_external;

}

static PurpleNetworkListenData *

purple_network_do_listen(unsigned short port, int socket_family, int socket_type, PurpleNetworkListenCallback cb, gpointer cb_data)

{

  int listenfd = -1;

  const int on = 1;

  PurpleNetworkListenData *listen_data;

  unsigned short actual_port;

#ifdef HAVE_GETADDRINFO

  int errnum;

  struct addrinfo hints, *res, *next;

  char serv[6];

  /*

   * Get a list of addresses on this machine.

   */

  g_snprintf(serv, sizeof(serv), "%hu", port);

  memset(&hints, 0, sizeof(struct addrinfo));

  hints.ai_flags = AI_PASSIVE;

  hints.ai_family = socket_family;

  hints.ai_socktype = socket_type;

  errnum = getaddrinfo(NULL /* any IP */, serv, &hints, &res);

  if (errnum != 0) {

#ifndef _WIN32

    purple_debug_warning("network", "getaddrinfo: %s\n", purple_gai_strerror(errnum));

    if (errnum == EAI_SYSTEM)

      purple_debug_warning("network", "getaddrinfo: system error: %s\n", g_strerror(errno));

#else

    purple_debug_warning("network", "getaddrinfo: Error Code = %d\n", errnum);

#endif

    return NULL;

  }

  /*

   * Go through the list of addresses and attempt to listen on

   * one of them.

   * XXX - Try IPv6 addresses first?

   */

  for (next = res; next != NULL; next = next->ai_next) {

#if _WIN32

    /*

     * On Windows, the address family for the transport

     * address should always be set to AF_INET.

     */

    if(next->ai_family != AF_INET)

      continue;

#endif

    listenfd = socket(next->ai_family, next->ai_socktype, next->ai_protocol);

    if (listenfd < 0)

      continue;

    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) != 0)

      purple_debug_warning("network", "setsockopt(SO_REUSEADDR): %s\n", g_strerror(errno));

    if (bind(listenfd, next->ai_addr, next->ai_addrlen) == 0)

      break; /* success */

    /* XXX - It is unclear to me (datallah) whether we need to be

       using a new socket each time */

    close(listenfd);

  }

  freeaddrinfo(res);

  if (next == NULL)

    return NULL;

#else

  struct sockaddr_in sockin;

  if (socket_family != AF_INET && socket_family != AF_UNSPEC) {

    purple_debug_warning("network", "Address family %d only "

                         "supported when built with getaddrinfo() "

                         "support\n", socket_family);

    return NULL;

  }

  if ((listenfd = socket(AF_INET, socket_type, 0)) < 0) {

    purple_debug_warning("network", "socket: %s\n", g_strerror(errno));

    return NULL;

  }

  if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) != 0)

    purple_debug_warning("network", "setsockopt: %s\n", g_strerror(errno));

  memset(&sockin, 0, sizeof(struct sockaddr_in));

  sockin.sin_family = PF_INET;

  sockin.sin_port = htons(port);

  if (bind(listenfd, (struct sockaddr *)&sockin, sizeof(struct sockaddr_in)) != 0) {

    purple_debug_warning("network", "bind: %s\n", g_strerror(errno));

    close(listenfd);

    return NULL;

  }

#endif

  if (socket_type == SOCK_STREAM && listen(listenfd, 4) != 0) {

    purple_debug_warning("network", "listen: %s\n", g_strerror(errno));

    close(listenfd);

    return NULL;

  }

  _purple_network_set_common_socket_flags(listenfd);

  actual_port = purple_network_get_port_from_fd(listenfd);

  purple_debug_info("network", "Listening on port: %hu\n", actual_port);

  listen_data = g_new0(PurpleNetworkListenData, 1);

  listen_data->listenfd = listenfd;

  listen_data->adding = TRUE;

  listen_data->retry = TRUE;

  listen_data->cb = cb;

  listen_data->cb_data = cb_data;

  listen_data->socket_type = socket_type;

  if (!purple_socket_speaks_ipv4(listenfd) || !listen_map_external ||

      !purple_prefs_get_bool("/purple/network/map_ports"))

  {

    purple_debug_info("network", "Skipping external port mapping.\n");

    /* The pmp_map_cb does what we want to do */

    listen_data->timer = purple_timeout_add(0, purple_network_finish_pmp_map_cb, listen_data);

  }

  /* Attempt a NAT-PMP Mapping, which will return immediately */

  else if (purple_pmp_create_map(((socket_type == SOCK_STREAM) ? PURPLE_PMP_TYPE_TCP : PURPLE_PMP_TYPE_UDP),

                actual_port, actual_port, PURPLE_PMP_LIFETIME))

  {

    purple_debug_info("network", "Created NAT-PMP mapping on port %i\n", actual_port);

    /* We want to return listen_data now, and on the next run loop trigger the cb and destroy listen_data */

    listen_data->timer = purple_timeout_add(0, purple_network_finish_pmp_map_cb, listen_data);

  }

  else

  {

    /* Attempt a UPnP Mapping */

    listen_data->mapping_data = purple_upnp_set_port_mapping(

             actual_port,

             (socket_type == SOCK_STREAM) ? "TCP" : "UDP",

             purple_network_set_upnp_port_mapping_cb, listen_data);

  }

  return listen_data;

}

PurpleNetworkListenData *

purple_network_listen_family(unsigned short port, int socket_family,

                             int socket_type, PurpleNetworkListenCallback cb,

                             gpointer cb_data)

{

  g_return_val_if_fail(port != 0, NULL);

  return purple_network_do_listen(port, socket_family, socket_type,

                                  cb, cb_data);

}

PurpleNetworkListenData *

purple_network_listen(unsigned short port, int socket_type,

    PurpleNetworkListenCallback cb, gpointer cb_data)

{

  return purple_network_listen_family(port, AF_UNSPEC, socket_type,

                                      cb, cb_data);

}

PurpleNetworkListenData *

purple_network_listen_range_family(unsigned short start, unsigned short end,

                                   int socket_family, int socket_type,

                                   PurpleNetworkListenCallback cb,

                                   gpointer cb_data)

{

  PurpleNetworkListenData *ret = NULL;

  if (purple_prefs_get_bool("/purple/network/ports_range_use")) {

    start = purple_prefs_get_int("/purple/network/ports_range_start");

    end = purple_prefs_get_int("/purple/network/ports_range_end");

  } else {

    if (end < start)

      end = start;

  }

  for (; start <= end; start++) {

    ret = purple_network_do_listen(start, AF_UNSPEC, socket_type, cb, cb_data);

    if (ret != NULL)

      break;

  }

  return ret;

}

PurpleNetworkListenData *

purple_network_listen_range(unsigned short start, unsigned short end,

                            int socket_type, PurpleNetworkListenCallback cb,

                            gpointer cb_data)

{

  return purple_network_listen_range_family(start, end, AF_UNSPEC,

                                            socket_type, cb, cb_data);

}

void purple_network_listen_cancel(PurpleNetworkListenData *listen_data)

{

  if (listen_data->mapping_data != NULL)

    purple_upnp_cancel_port_mapping(listen_data->mapping_data);

  if (listen_data->timer > 0)

    purple_timeout_remove(listen_data->timer);

  g_free(listen_data);

}

unsigned short

purple_network_get_port_from_fd(int fd)

{

  common_sockaddr_t addr;

  socklen_t len;

  g_return_val_if_fail(fd >= 0, 0);

  len = sizeof(addr);

  if (getsockname(fd, (struct sockaddr *) &addr, &len) == -1) {

    purple_debug_warning("network", "getsockname: %s\n", g_strerror(errno));

    return 0;

  }

  return ntohs(addr.in.sin_port);

}

#ifdef _WIN32

#ifndef NS_NLA

#define NS_NLA 15

#endif

static gint

wpurple_get_connected_network_count(void)

{

  gint net_cnt = 0;

  WSAQUERYSET qs;

  HANDLE h;

  gint retval;

  int errorid;

  memset(&qs, 0, sizeof(WSAQUERYSET));

  qs.dwSize = sizeof(WSAQUERYSET);

  qs.dwNameSpace = NS_NLA;

  retval = WSALookupServiceBeginA(&qs, LUP_RETURN_ALL, &h);

  if (retval != ERROR_SUCCESS) {

    gchar *msg;

    errorid = WSAGetLastError();

    msg = g_win32_error_message(errorid);

    purple_debug_warning("network", "Couldn't retrieve NLA SP lookup handle. "

            "NLA service is probably not running. Message: %s (%d).\n",

            msg, errorid);

    g_free(msg);

    return -1;

  } else {

    gchar *buf = NULL;

    WSAQUERYSET *res = (LPWSAQUERYSET) buf;

    DWORD current_size = 0;

    int iteration_count = 0;

    while (iteration_count++ < 100) {

      DWORD size = current_size;

      retval = WSALookupServiceNextA(h, 0, &size, res);

      if (retval == ERROR_SUCCESS) {

        net_cnt++;

        purple_debug_info("network", "found network '%s'\n",

            res->lpszServiceInstanceName ? res->lpszServiceInstanceName : "(NULL)");

      } else {

        errorid = WSAGetLastError();

        if (errorid == WSAEFAULT) {

          if (size == 0 || size > 102400) {

            purple_debug_warning("network", "Got unexpected NLA buffer size %" G_GUINT32_FORMAT ".\n", (guint32) size);

            break;

          }

          buf = g_realloc(buf, size);

          res = (LPWSAQUERYSET) buf;

          current_size = size;

        } else {

          break;

        }

      }

    }

    g_free(buf);

    if (!(errorid == WSA_E_NO_MORE || errorid == WSAENOMORE)) {

      gchar *msg = g_win32_error_message(errorid);

      purple_debug_error("network", "got unexpected NLA response %s (%d)\n", msg, errorid);

      g_free(msg);

      net_cnt = -1;

    }

    retval = WSALookupServiceEnd(h);

  }

  return net_cnt;

}

static gboolean wpurple_network_change_thread_cb(gpointer data)

{

  gint new_count;

  PurpleConnectionUiOps *ui_ops = purple_connections_get_ui_ops();

  new_count = wpurple_get_connected_network_count();

  if (new_count < 0)

    return FALSE;

  purple_debug_info("network", "Received Network Change Notification. Current network count is %d, previous count was %d.\n", new_count, current_network_count);

  purple_signal_emit(purple_network_get_handle(), "network-configuration-changed", NULL);

  if (new_count > 0 && ui_ops != NULL && ui_ops->network_connected != NULL) {

    ui_ops->network_connected();

  } else if (new_count == 0 && current_network_count > 0 &&

         ui_ops != NULL && ui_ops->network_disconnected != NULL) {

    ui_ops->network_disconnected();

  }

  current_network_count = new_count;

  return FALSE;

}

static gboolean _print_debug_msg(gpointer data) {

  gchar *msg = data;

  purple_debug_warning("network", "%s", msg);

  g_free(msg);

  return FALSE;

}

static gpointer wpurple_network_change_thread(gpointer data)

{

  WSAQUERYSET qs;

  WSAEVENT *nla_event;

  time_t last_trigger = time(NULL) - 31;

  gchar *buf = NULL;

  WSAQUERYSET *res = (LPWSAQUERYSET) buf;

  DWORD current_size = 0;

  if ((nla_event = WSACreateEvent()) == WSA_INVALID_EVENT) {

    int errorid = WSAGetLastError();

    gchar *msg = g_win32_error_message(errorid);

    purple_timeout_add(0, _print_debug_msg,

               g_strdup_printf("Couldn't create WSA event. "

                       "Message: %s (%d).\n", msg, errorid));

    g_free(msg);

    g_thread_exit(NULL);

    return NULL;

  }

  while (TRUE) {

    int retval;

    int iteration_count;

    DWORD retLen = 0;

    WSACOMPLETION completion;

    WSAOVERLAPPED overlapped;

    g_static_mutex_lock(&mutex);

    if (network_initialized == FALSE) {

      /* purple_network_uninit has been called */

      WSACloseEvent(nla_event);

      g_static_mutex_unlock(&mutex);

      g_thread_exit(NULL);

      return NULL;

    }

    if (network_change_handle == NULL) {

      memset(&qs, 0, sizeof(WSAQUERYSET));

      qs.dwSize = sizeof(WSAQUERYSET);

      qs.dwNameSpace = NS_NLA;

      if (WSALookupServiceBeginA(&qs, 0, &network_change_handle) == SOCKET_ERROR) {

        int errorid = WSAGetLastError();

        gchar *msg = g_win32_error_message(errorid);

        purple_timeout_add(0, _print_debug_msg,

                   g_strdup_printf("Couldn't retrieve NLA SP lookup handle. "

                           "NLA service is probably not running. Message: %s (%d).\n",

                          msg, errorid));

        g_free(msg);

        WSACloseEvent(nla_event);

        g_static_mutex_unlock(&mutex);

        g_thread_exit(NULL);

        return NULL;

      }

    }

    g_static_mutex_unlock(&mutex);

    memset(&completion, 0, sizeof(WSACOMPLETION));

    completion.Type = NSP_NOTIFY_EVENT;

    overlapped.hEvent = nla_event;

    completion.Parameters.Event.lpOverlapped = &overlapped;

    if (MyWSANSPIoctl(network_change_handle, SIO_NSP_NOTIFY_CHANGE, NULL, 0, NULL, 0, &retLen, &completion) == SOCKET_ERROR) {

      int errorid = WSAGetLastError();

      if (errorid == WSA_INVALID_HANDLE) {

        purple_timeout_add(0, _print_debug_msg,

                   g_strdup("Invalid NLA handle; resetting.\n"));

        g_static_mutex_lock(&mutex);

        retval = WSALookupServiceEnd(network_change_handle);

        network_change_handle = NULL;

        g_static_mutex_unlock(&mutex);

        continue;

      /* WSA_IO_PENDING indicates successful async notification will happen */

      } else if (errorid != WSA_IO_PENDING) {

        gchar *msg = g_win32_error_message(errorid);

        purple_timeout_add(0, _print_debug_msg,

                   g_strdup_printf("Unable to wait for changes. Message: %s (%d).\n",

                           msg, errorid));

        g_free(msg);

      }

    }

    /* Make sure at least 30 seconds have elapsed since the last

     * notification so we don't peg the cpu if this keeps changing. */

    if ((time(NULL) - last_trigger) < 30)

      Sleep(30000);

    /* This will block until NLA notifies us */

    retval = WaitForSingleObjectEx(nla_event, WSA_INFINITE, TRUE);

    last_trigger = time(NULL);

    g_static_mutex_lock(&mutex);

    if (network_initialized == FALSE) {

      /* Time to die */

      WSACloseEvent(nla_event);

      g_static_mutex_unlock(&mutex);

      g_thread_exit(NULL);

      return NULL;

    }

    iteration_count = 0;

    while (iteration_count++ < 100) {

      DWORD size = current_size;

      retval = WSALookupServiceNextA(network_change_handle, 0, &size, res);

      if (retval == ERROR_SUCCESS) {

        /*purple_timeout_add(0, _print_debug_msg,

                 g_strdup_printf("thread found network '%s'\n",

                         res->lpszServiceInstanceName ? res->lpszServiceInstanceName : "(NULL)"));*/

      } else {

        int errorid = WSAGetLastError();

        if (errorid == WSAEFAULT) {

          if (size == 0 || size > 102400) {

            purple_timeout_add(0, _print_debug_msg,

                 g_strdup_printf("Thread got unexpected NLA buffer size %" G_GUINT32_FORMAT ".\n", (guint32) size));

            break;

          }

          buf = g_realloc(buf, size);

          res = (LPWSAQUERYSET) buf;

          current_size = size;

        } else {

          break;

        }

      }

    }

    g_free(buf);

    buf = NULL;

    current_size = 0;

    WSAResetEvent(nla_event);

    g_static_mutex_unlock(&mutex);

    purple_timeout_add(0, wpurple_network_change_thread_cb, NULL);

  }

  g_thread_exit(NULL);

  return NULL;

}

#endif

gboolean

purple_network_is_available(void)

{

#ifdef HAVE_NETWORKMANAGER

  if (force_online)

    return TRUE;

  if (!have_nm_state)

  {

    have_nm_state = TRUE;

    nm_state = nm_get_network_state();

    if (nm_state == NM_STATE_UNKNOWN)

      purple_debug_warning("network", "NetworkManager not active. Assuming connection exists.\n");

  }

  switch (nm_state)

  {

    case NM_STATE_UNKNOWN:

#if NM_CHECK_VERSION(0,8,992)

    case NM_STATE_CONNECTED_LOCAL:

    case NM_STATE_CONNECTED_SITE:

    case NM_STATE_CONNECTED_GLOBAL:

#else

    case NM_STATE_CONNECTED:

#endif

      return TRUE;

    default:

      break;

  }

  return FALSE;

#elif defined _WIN32

  return (current_network_count > 0 || force_online);

#else

  return TRUE;

#endif

}

void

purple_network_force_online()

{

#if defined(HAVE_NETWORKMANAGER) || defined(_WIN32)

  force_online = TRUE;

#endif

}

#ifdef HAVE_NETWORKMANAGER

static void

nm_update_state(NMState state)

{

  NMState prev = nm_state;

  PurpleConnectionUiOps *ui_ops = purple_connections_get_ui_ops();

  have_nm_state = TRUE;

  nm_state = state;

  purple_signal_emit(purple_network_get_handle(), "network-configuration-changed", NULL);

  switch(state)

  {

#if NM_CHECK_VERSION(0,8,992)

    case NM_STATE_CONNECTED_LOCAL:

    case NM_STATE_CONNECTED_SITE:

    case NM_STATE_CONNECTED_GLOBAL:

#else

    case NM_STATE_CONNECTED:

#endif

      /* Call res_init in case DNS servers have changed */

      res_init();

      /* update STUN IP in case we it changed (theoretically we could

         have gone from IPv4 to IPv6, f.ex. or we were previously

         offline */

      purple_network_set_stun_server(

        purple_prefs_get_string("/purple/network/stun_server"));

      purple_network_set_turn_server(

        purple_prefs_get_string("/purple/network/turn_server"));

      if (ui_ops != NULL && ui_ops->network_connected != NULL)

        ui_ops->network_connected();

      break;

    case NM_STATE_ASLEEP:

    case NM_STATE_CONNECTING:

    case NM_STATE_DISCONNECTED:

#if NM_CHECK_VERSION(0,8,992)

    case NM_STATE_DISCONNECTING:

#endif

#if NM_CHECK_VERSION(1,0,0)

      if (prev != NM_STATE_CONNECTED_GLOBAL && prev != NM_STATE_UNKNOWN)

        break;

#else

      if (prev != NM_STATE_CONNECTED && prev != NM_STATE_UNKNOWN)

        break;

#endif

      if (ui_ops != NULL && ui_ops->network_disconnected != NULL)

        ui_ops->network_disconnected();

      break;

    case NM_STATE_UNKNOWN:

    default:

      break;

  }

}

static void

nm_state_change_cb(DBusGProxy *proxy, NMState state, gpointer user_data)

{

  purple_debug_info("network", "Got StateChange from NetworkManager: %d.\n", state);

  nm_update_state(state);

}

static NMState

nm_get_network_state(void)

{

  GError *err = NULL;

  NMState state = NM_STATE_UNKNOWN;

  if (!nm_proxy)

    return NM_STATE_UNKNOWN;

  if (!dbus_g_proxy_call(nm_proxy, "state", &err, G_TYPE_INVALID, G_TYPE_UINT, &state, G_TYPE_INVALID)) {

    g_error_free(err);

    return NM_STATE_UNKNOWN;

  }

  return state;

}

static void

nm_dbus_name_owner_changed_cb(DBusGProxy *proxy, char *service, char *old_owner, char *new_owner, gpointer user_data)

{

  if (purple_strequal(service, NM_DBUS_SERVICE)) {

    gboolean old_owner_good = old_owner && (old_owner[0] != '\0');

    gboolean new_owner_good = new_owner && (new_owner[0] != '\0');

    purple_debug_info("network", "Got NameOwnerChanged signal, service = '%s', old_owner = '%s', new_owner = '%s'\n", service, old_owner, new_owner);

    if (!old_owner_good && new_owner_good) {  /* Equivalent to old ServiceCreated signal */

      purple_debug_info("network", "NetworkManager has started.\n");

      nm_update_state(nm_get_network_state());

    } else if (old_owner_good && !new_owner_good) { /* Equivalent to old ServiceDeleted signal */

      purple_debug_info("network", "NetworkManager has gone away.\n");