X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=lib%2Fsilcutil%2Fwin32%2Fsilcwin32net.c;h=0501ab82d12b62873471491773133528edfc6164;hb=e7b6c157b80152bf9fb9266e6bdd93f9fb0db776;hp=7d4e7339d3f9f5942624f56043378677bdb6e1cc;hpb=01f30c58243cbd70424d650e50d8ea30f4ddf0fc;p=silc.git

diff --git a/lib/silcutil/win32/silcwin32net.c b/lib/silcutil/win32/silcwin32net.c
index 7d4e7339..0501ab82 100644
--- a/lib/silcutil/win32/silcwin32net.c
+++ b/lib/silcutil/win32/silcwin32net.c
@@ -51,6 +51,8 @@ static SilcBool silc_net_set_sockaddr(SilcSockaddr *addr, const char *ip_addr,
   if (ip_addr) {
     if (!silc_net_is_ip(ip_addr)) {
       SILC_LOG_ERROR(("%s is not IP address", ip_addr));
+      silc_set_errno_reason(SILC_ERR_BAD_IP, "%s is not an IP address",
+			    ip_addr);
       return FALSE;
     }
 
@@ -93,15 +95,15 @@ static SilcBool silc_net_set_sockaddr(SilcSockaddr *addr, const char *ip_addr,
 
 /* Deliver new stream to upper layer */
 
-static void silc_net_accept_stream(SilcSocketStreamStatus status,
+static void silc_net_accept_stream(SilcResult status,
 				   SilcStream stream, void *context)
 {
   SilcNetListener listener = context;
 
-  if (status != SILC_SOCKET_OK)
+  if (status != SILC_OK)
     return;
 
-  listener->callback(SILC_NET_OK, stream, listener->context);
+  listener->callback(SILC_OK, stream, listener->context);
 }
 
 /* Accept incoming connection and notify upper layer */
@@ -143,8 +145,18 @@ silc_net_tcp_create_listener(const char **local_ip_addr,
 
   SILC_LOG_DEBUG(("Creating TCP listener"));
 
-  if (port < 0 || !schedule || !callback)
+  if (!schedule) {
+    schedule = silc_schedule_get_global();
+    if (!schedule) {
+      silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+      goto err;
+    }
+  }
+
+  if (port < 0 || !callback) {
+    silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
     goto err;
+  }
 
   listener = silc_calloc(1, sizeof(*listener));
   if (!listener)
@@ -181,33 +193,167 @@ silc_net_tcp_create_listener(const char **local_ip_addr,
     /* Create the socket */
     sock = socket(server.sin.sin_family, SOCK_STREAM, 0);
     if (sock == INVALID_SOCKET) {
-      SILC_LOG_ERROR(("Cannot create socket, error %d", WSAGetLastError()));
+      silc_set_errno_posix(WSAGetLastError());
+      SILC_LOG_ERROR(("Cannot create socket, error %s",
+		      silc_errno_string(silc_errno)));
+      goto err;
+    }
+
+    /* Set the socket options */
+    rval = silc_net_set_socket_opt(sock, SOL_SOCKET, SO_REUSEADDR, 1);
+    if (rval == SOCKET_ERROR) {
+      SILC_LOG_ERROR(("Cannot set socket options, error %s",
+		      silc_errno_string(silc_errno)));
+      closesocket(sock);
+      goto err;
+    }
+
+    /* Bind the listener socket */
+    rval = bind(sock, &server.sa, SIZEOF_SOCKADDR(server));
+    if (rval == SOCKET_ERROR) {
+      silc_set_errno_posix(WSAGetLastError());
+      SILC_LOG_ERROR(("Cannot bind socket, error %s",
+		      silc_errno_string(silc_errno)));
+      closesocket(sock);
+      goto err;
+    }
+
+    /* Specify that we are listenning */
+    rval = listen(sock, SOMAXCONN);
+    if (rval == SOCKET_ERROR) {
+      silc_set_errno_posix(WSAGetLastError());
+      SILC_LOG_ERROR(("Cannot set socket listenning, error %s",
+		      silc_errno_string(silc_errno)));
+      closesocket(sock);
+      goto err;
+    }
+
+    /* Schedule for incoming connections */
+    silc_schedule_task_add_fd(schedule, sock, silc_net_accept, listener);
+
+    SILC_LOG_DEBUG(("TCP listener created, fd=%d", sock));
+    listener->socks[i] = sock;
+    listener->socks_count++;
+  }
+
+  return listener;
+
+ err:
+  if (listener)
+    silc_net_close_listener(listener);
+  return NULL;
+}
+
+/* Create TCP network, multiple ports */
+
+SilcNetListener
+silc_net_tcp_create_listener2(const char *local_ip_addr, int *ports,
+			      SilcUInt32 port_count,
+			      SilcBool ignore_port_error,
+			      SilcBool lookup, SilcBool require_fqdn,
+			      SilcSchedule schedule,
+			      SilcNetCallback callback, void *context)
+{
+  SilcNetListener listener = NULL;
+  SOCKET sock;
+  SilcSockaddr server;
+  int i, rval;
+  const char *ipany = "0.0.0.0";
+
+  SILC_LOG_DEBUG(("Creating TCP listener"));
+
+  if (!schedule) {
+    schedule = silc_schedule_get_global();
+    if (!schedule) {
+      silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+      goto err;
+    }
+  }
+
+  if (!callback) {
+    silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+    goto err;
+  }
+
+  listener = silc_calloc(1, sizeof(*listener));
+  if (!listener)
+    return NULL;
+  listener->schedule = schedule;
+  listener->callback = callback;
+  listener->context = context;
+  listener->require_fqdn = require_fqdn;
+  listener->lookup = lookup;
+
+  if (port_count > 0) {
+    listener->socks = silc_calloc(port_count, sizeof(*listener->socks));
+    if (!listener->socks)
+      return NULL;
+  } else {
+    listener->socks = silc_calloc(1, sizeof(*listener->socks));
+    if (!listener->socks)
+      return NULL;
+
+    port_count = 1;
+  }
+
+  /* Bind to local addresses */
+  for (i = 0; i < local_ip_count; i++) {
+    SILC_LOG_DEBUG(("Binding to local address %s:%d",
+		    local_ip_addr ? local_ip_addr : ipany,
+		    ports ? ports[i] : 0));
+
+    /* Set sockaddr for server */
+    if (!silc_net_set_sockaddr(&server,
+			       local_ip_addr ? local_ip_addr : ipany,
+			       ports ? ports[i] : 0)) {
+      if (ignore_port_error)
+	continue;
+      goto err;
+    }
+
+    /* Create the socket */
+    sock = socket(server.sin.sin_family, SOCK_STREAM, 0);
+    if (sock == INVALID_SOCKET) {
+      if (ignore_port_error)
+	continue;
+      silc_set_errno_posix(WSAGetLastError());
+      SILC_LOG_ERROR(("Cannot create socket, error %s",
+		      silc_errno_string(silc_errno)));
       goto err;
     }
 
     /* Set the socket options */
     rval = silc_net_set_socket_opt(sock, SOL_SOCKET, SO_REUSEADDR, 1);
     if (rval == SOCKET_ERROR) {
-      SILC_LOG_ERROR(("Cannot set socket options, error %d",
-		     WSAGetLastError()));
       closesocket(sock);
+      if (ignore_port_error)
+	continue;
+      SILC_LOG_ERROR(("Cannot set socket options, error %s",
+		      silc_errno_string(silc_errno)));
       goto err;
     }
 
     /* Bind the listener socket */
     rval = bind(sock, &server.sa, SIZEOF_SOCKADDR(server));
     if (rval == SOCKET_ERROR) {
-      SILC_LOG_ERROR(("Cannot bind socket, error %d", WSAGetLastError()));
       closesocket(sock);
+      if (ignore_port_error)
+	continue;
+      silc_set_errno_posix(WSAGetLastError());
+      SILC_LOG_ERROR(("Cannot bind socket, error %s",
+		      silc_errno_string(silc_errno)));
       goto err;
     }
 
     /* Specify that we are listenning */
     rval = listen(sock, SOMAXCONN);
     if (rval == SOCKET_ERROR) {
-      SILC_LOG_ERROR(("Cannot set socket listenning, error %d",
-		     WSAGetLastError()));
       closesocket(sock);
+      if (ignore_port_error)
+	continue;
+      silc_set_errno_posix(WSAGetLastError());
+      SILC_LOG_ERROR(("Cannot set socket listenning, error %s",
+		      silc_errno_string(silc_errno)));
       goto err;
     }
 
@@ -219,6 +365,9 @@ silc_net_tcp_create_listener(const char **local_ip_addr,
     listener->socks_count++;
   }
 
+  if (ignore_port_error && !listener->socks_count)
+    goto err;
+
   return listener;
 
  err:
@@ -265,8 +414,13 @@ silc_net_udp_connect(const char *local_ip_addr, int local_port,
 
   SILC_LOG_DEBUG(("Creating UDP stream"));
 
-  if (!schedule)
-    goto err;
+  if (!schedule) {
+    schedule = silc_schedule_get_global();
+    if (!schedule) {
+      silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+      goto err;
+    }
+  }
 
   /* Bind to local addresses */
   SILC_LOG_DEBUG(("Binding to local address %s",
@@ -281,6 +435,7 @@ silc_net_udp_connect(const char *local_ip_addr, int local_port,
   sock = socket(server.sin.sin_family, SOCK_DGRAM, 0);
   if (sock == INVALID_SOCKET) {
     SILC_LOG_ERROR(("Cannot create socket"));
+    silc_set_errno_posix(WSAGetLastError());
     goto err;
   }
 
@@ -302,6 +457,7 @@ silc_net_udp_connect(const char *local_ip_addr, int local_port,
   rval = bind(sock, &server.sa, SIZEOF_SOCKADDR(server));
   if (rval == SOCKET_ERROR) {
     SILC_LOG_DEBUG(("Cannot bind socket"));
+    silc_set_errno_posix(WSAGetLastError());
     goto err;
   }
 
@@ -313,6 +469,7 @@ silc_net_udp_connect(const char *local_ip_addr, int local_port,
     rval = connect(sock, &server.sa, SIZEOF_SOCKADDR(server));
     if (rval == SOCKET_ERROR) {
       SILC_LOG_DEBUG(("Cannot connect UDP stream"));
+      silc_set_errno_posix(WSAGetLastError());
       goto err;
     }
   }
@@ -363,15 +520,16 @@ int silc_net_udp_receive(SilcStream stream, char *remote_ip_addr,
 
   if (len == SOCKET_ERROR) {
     err = WSAGetLastError();
+    silc_set_errno_posix(err);
     if (err == WSAEWOULDBLOCK) {
       SILC_LOG_DEBUG(("Could not read immediately, will do it later"));
       silc_schedule_set_listen_fd(sock->schedule, sock->sock,
 				  SILC_TASK_READ, FALSE);
       return -1;
     }
-    SILC_LOG_DEBUG(("Cannot read from UDP socket: %d", sock->sock));
+    SILC_LOG_DEBUG(("Cannot read from UDP socket: %d: %s", sock->sock,
+		    silc_errno_string(silc_errno)));
     silc_schedule_unset_listen_fd(sock->schedule, sock->sock);
-    sock->sock_error = err;
     return -2;
   }
 
@@ -422,15 +580,16 @@ int silc_net_udp_send(SilcStream stream,
 	       SIZEOF_SOCKADDR(remote));
   if (ret == SOCKET_ERROR) {
     err = WSAGetLastError();
+    silc_set_errno_posix(err);
     if (err == WSAEWOULDBLOCK) {
       SILC_LOG_DEBUG(("Could not send immediately, will do it later"));
       silc_schedule_set_listen_fd(sock->schedule, sock->sock,
 				  SILC_TASK_READ | SILC_TASK_WRITE, FALSE);
       return -1;
     }
-    SILC_LOG_DEBUG(("Cannot send to UDP socket: %s", strerror(errno)));
+    SILC_LOG_DEBUG(("Cannot send to UDP socket: %s",
+		    silc_errno_string(silc_errno)));
     silc_schedule_unset_listen_fd(sock->schedule, sock->sock);
-    sock->sock_error = err;
     return -2;
   }
 
@@ -447,8 +606,7 @@ int silc_net_udp_send(SilcStream stream,
 /******************************* TCP Stream *********************************/
 
 typedef struct {
-  SilcNetStatus status;
-  SilcSocketStreamStatus stream_status;
+  SilcResult status;
   SilcStream stream;
   SilcFSMStruct fsm;
   SilcFSMThreadStruct thread;
@@ -469,12 +627,12 @@ SILC_FSM_STATE(silc_net_connect_st_start);
 SILC_FSM_STATE(silc_net_connect_st_stream);
 SILC_FSM_STATE(silc_net_connect_st_finish);
 
-static void silc_net_connect_wait_stream(SilcSocketStreamStatus status,
+static void silc_net_connect_wait_stream(SilcResult status,
 					 SilcStream stream, void *context)
 {
   SilcNetConnect conn = context;
   conn->sop = NULL;
-  conn->stream_status = status;
+  conn->status = status;
   conn->stream = stream;
   SILC_FSM_CALL_CONTINUE(&conn->thread);
 }
@@ -515,7 +673,7 @@ SILC_FSM_STATE(silc_net_connect_st_start)
 		    "host, error %d", conn->remote, WSAGetLastError()));
 
     /** Network unreachable */
-    conn->status = SILC_NET_HOST_UNREACHABLE;
+    conn->status = SILC_ERR_UNREACHABLE;
     return SILC_FSM_FINISH;
   }
 
@@ -534,7 +692,9 @@ SILC_FSM_STATE(silc_net_connect_st_start)
     }
 
     /** Cannot create socket */
-    SILC_LOG_ERROR(("Cannot create socket, error %d", WSAGetLastError()));
+    silc_set_errno_posix(err);
+    SILC_LOG_ERROR(("Cannot create socket, error %d",
+		    silc_errno_string(silc_errno)));
     return SILC_FSM_FINISH;
   }
 
@@ -561,22 +721,12 @@ SILC_FSM_STATE(silc_net_connect_st_start)
 	goto retry;
       }
 
-      switch (err) {
-      case WSAETIMEDOUT:
-	conn->status = SILC_NET_CONNECTION_TIMEOUT;
-	break;
-      case WSAECONNREFUSED:
-	conn->status = SILC_NET_CONNECTION_REFUSED;
-	break;
-      case WSAEHOSTUNREACH:
-	conn->status = SILC_NET_HOST_UNREACHABLE;
-	break;
-      default:
-	break;
-      }
+      /* Set error */
+      silc_set_errno_posix(err);
+      conn->status = silc_errno;
 
-      SILC_LOG_ERROR(("Cannot connect to remote host, error %d",
-		      WSAGetLastError()));
+      SILC_LOG_ERROR(("Cannot connect to remote host: %s",
+		      silc_errno_string(silc_errno)));
       return SILC_FSM_FINISH;
     }
   }
@@ -611,21 +761,14 @@ SILC_FSM_STATE(silc_net_connect_st_stream)
   if (conn->aborted)
     return SILC_FSM_FINISH;
 
-  if (conn->stream_status != SILC_SOCKET_OK) {
+  if (conn->status != SILC_OK) {
     /** Stream creation failed */
-    if (conn->stream_status == SILC_SOCKET_UNKNOWN_IP)
-      conn->status = SILC_NET_UNKNOWN_IP;
-    else if (conn->stream_status == SILC_SOCKET_UNKNOWN_HOST)
-      conn->status = SILC_NET_UNKNOWN_HOST;
-    else
-      conn->status = SILC_NET_ERROR;
-
     return SILC_FSM_FINISH;
   }
 
   /** Stream created successfully */
   SILC_LOG_DEBUG(("Connected successfully, sock %d", conn->sock));
-  conn->status = SILC_NET_OK;
+  conn->status = SILC_OK;
   return SILC_FSM_FINISH;
 }
 
@@ -675,15 +818,25 @@ SilcAsyncOperation silc_net_tcp_connect(const char *local_ip_addr,
 {
   SilcNetConnect conn;
 
-  if (!remote_ip_addr || remote_port < 1 || !schedule || !callback)
+  if (!schedule) {
+    schedule = silc_schedule_get_global();
+    if (!schedule) {
+      silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+      return NULL;
+    }
+  }
+
+  if (!remote_ip_addr || remote_port < 1 || !callback) {
+    silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
     return NULL;
+  }
 
   SILC_LOG_DEBUG(("Creating connection to host %s port %d",
 		  remote_ip_addr, remote_port));
 
   conn = silc_calloc(1, sizeof(*conn));
   if (!conn) {
-    callback(SILC_NET_NO_MEMORY, NULL, context);
+    callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
     return NULL;
   }
 
@@ -691,25 +844,25 @@ SilcAsyncOperation silc_net_tcp_connect(const char *local_ip_addr,
   conn->op = silc_async_alloc(silc_net_connect_abort, NULL, conn);
   if (!conn->op) {
     silc_free(conn);
-    callback(SILC_NET_NO_MEMORY, NULL, context);
+    callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
     return NULL;
   }
 
   if (local_ip_addr)
-    conn->local_ip = strdup(local_ip_addr);
-  conn->remote = strdup(remote_ip_addr);
+    conn->local_ip = silc_strdup(local_ip_addr);
+  conn->remote = silc_strdup(remote_ip_addr);
   if (!conn->remote) {
     silc_async_free(conn->op);
     silc_free(conn->local_ip);
     silc_free(conn);
-    callback(SILC_NET_NO_MEMORY, NULL, context);
+    callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
     return NULL;
   }
   conn->port = remote_port;
   conn->callback = callback;
   conn->context = context;
   conn->retry = 1;
-  conn->status = SILC_NET_ERROR;
+  conn->status = SILC_ERR;
 
   silc_fsm_init(&conn->fsm, conn, silc_net_connect_destructor, NULL, schedule);
   silc_fsm_start(&conn->fsm, silc_net_connect_st_thread);
@@ -741,34 +894,41 @@ SilcBool silc_net_addr2bin(const char *addr, void *bin, SilcUInt32 bin_len)
 	ret[c++] = d;
 	d = 0;
 	if (c > 3)
-	  return FALSE;
+	  goto err;
 	continue;
       }
 
       if (!isdigit((int)addr[i - 1]))
-	return FALSE;
+	goto err;
 
       d = 10 * d + addr[i - 1] - '0';
       if (d > 255)
-	return FALSE;
+	goto err;
     }
     if (c != 3)
-      return FALSE;
+      goto err;
     ret[c] = d;
 
-    if (bin_len < sizeof(ret))
+    if (bin_len < sizeof(ret)) {
+      silc_set_errno(SILC_ERR_OVERFLOW);
       return FALSE;
+    }
 
     memcpy(bin, ret, sizeof(ret));
     return TRUE;
+
+    err:
+    return FALSE;
   } else {
 #ifdef HAVE_IPV6
     struct addrinfo hints, *ai;
     SilcSockaddr *s;
 
     /* IPv6 address */
-    if (bin_len < 16)
+    if (bin_len < 16) {
+      silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
       return FALSE;
+    }
 
     memset(&hints, 0, sizeof(hints));
     hints.ai_family = AF_INET6;