X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=lib%2Fsilcutil%2Funix%2Fsilcunixnet.c;h=15720dcd53691f8903f6141776aaf7ac636fbb7f;hb=e7b6c157b80152bf9fb9266e6bdd93f9fb0db776;hp=a1326253710703c23ef7ce5eee4b6cdbbfb8d410;hpb=15d9facc2aab647996d927b15dc7b67e6011e971;p=silc.git

diff --git a/lib/silcutil/unix/silcunixnet.c b/lib/silcutil/unix/silcunixnet.c
index a1326253..15720dcd 100644
--- a/lib/silcutil/unix/silcunixnet.c
+++ b/lib/silcutil/unix/silcunixnet.c
@@ -4,7 +4,7 @@
 
   Author: Pekka Riikonen <priikone@silcnet.org>
 
-  Copyright (C) 1997 - 2006 Pekka Riikonen
+  Copyright (C) 1997 - 2007 Pekka Riikonen
 
   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
@@ -21,6 +21,8 @@
 #include "silc.h"
 #include "silcnet.h"
 
+/************************** Types and definitions ***************************/
+
 #ifdef HAVE_IPV6
 #define SIZEOF_SOCKADDR(so) ((so).sa.sa_family == AF_INET6 ?	\
   sizeof(so.sin6) : sizeof(so.sin))
@@ -36,6 +38,8 @@ typedef union {
 #endif
 } SilcSockaddr;
 
+/************************ Static utility functions **************************/
+
 static SilcBool silc_net_set_sockaddr(SilcSockaddr *addr, const char *ip_addr,
 				      int port)
 {
@@ -47,26 +51,31 @@ 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;
     }
 
     if (silc_net_is_ip4(ip_addr)) {
       /* IPv4 address */
       len = sizeof(addr->sin.sin_addr);
-      silc_net_addr2bin(ip_addr,
-			(unsigned char *)&addr->sin.sin_addr.s_addr, len);
+      if (!silc_net_addr2bin(ip_addr,
+			     (unsigned char *)&addr->sin.sin_addr.s_addr, len))
+	return FALSE;
       addr->sin.sin_family = AF_INET;
       addr->sin.sin_port = port ? htons(port) : 0;
     } else {
 #ifdef HAVE_IPV6
       /* IPv6 address */
       len = sizeof(addr->sin6.sin6_addr);
-      silc_net_addr2bin(ip_addr,
-			(unsigned char *)&addr->sin6.sin6_addr, len);
+      if (!silc_net_addr2bin(ip_addr,
+			     (unsigned char *)&addr->sin6.sin6_addr, len))
+	return FALSE;
       addr->sin6.sin6_family = AF_INET6;
       addr->sin6.sin6_port = port ? htons(port) : 0;
 #else
       SILC_LOG_ERROR(("IPv6 support is not compiled in"));
+      silc_set_errno(SILC_ERR_NOT_SUPPORTED);
       return FALSE;
 #endif
     }
@@ -81,17 +90,19 @@ static SilcBool silc_net_set_sockaddr(SilcSockaddr *addr, const char *ip_addr,
   return TRUE;
 }
 
+/****************************** TCP Listener ********************************/
+
 /* 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 */
@@ -108,7 +119,6 @@ SILC_TASK_CALLBACK(silc_net_accept)
     return;
 
   /* Set socket options */
-  silc_net_set_socket_nonblock(sock);
   silc_net_set_socket_opt(sock, SOL_SOCKET, SO_REUSEADDR, 1);
 
   /* Create socket stream */
@@ -133,14 +143,22 @@ silc_net_tcp_create_listener(const char **local_ip_addr,
 
   SILC_LOG_DEBUG(("Creating TCP listener"));
 
-  if (port < 1 || !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) {
-    callback(SILC_NET_NO_MEMORY, NULL, context);
+  if (!listener)
     return NULL;
-  }
   listener->schedule = schedule;
   listener->callback = callback;
   listener->context = context;
@@ -149,24 +167,20 @@ silc_net_tcp_create_listener(const char **local_ip_addr,
 
   if (local_ip_count > 0) {
     listener->socks = silc_calloc(local_ip_count, sizeof(*listener->socks));
-    if (!listener->socks) {
-      callback(SILC_NET_NO_MEMORY, NULL, context);
+    if (!listener->socks)
       return NULL;
-    }
   } else {
     listener->socks = silc_calloc(1, sizeof(*listener->socks));
-    if (!listener->socks) {
-      callback(SILC_NET_NO_MEMORY, NULL, context);
+    if (!listener->socks)
       return NULL;
-    }
 
     local_ip_count = 1;
   }
 
   /* Bind to local addresses */
   for (i = 0; i < local_ip_count; i++) {
-    SILC_LOG_DEBUG(("Binding to local address %s",
-		    local_ip_addr ? local_ip_addr[i] : ipany));
+    SILC_LOG_DEBUG(("Binding to local address %s:%d",
+		    local_ip_addr ? local_ip_addr[i] : ipany, port));
 
     /* Set sockaddr for server */
     if (!silc_net_set_sockaddr(&server,
@@ -177,7 +191,9 @@ silc_net_tcp_create_listener(const char **local_ip_addr,
     /* Create the socket */
     sock = socket(server.sin.sin_family, SOCK_STREAM, 0);
     if (sock < 0) {
-      SILC_LOG_ERROR(("Cannot create socket: %s", strerror(errno)));
+      silc_set_errno_posix(errno);
+      SILC_LOG_ERROR(("Cannot create socket: %s",
+		      silc_errno_string(silc_errno)));
       goto err;
     }
 
@@ -185,20 +201,27 @@ silc_net_tcp_create_listener(const char **local_ip_addr,
     rval = silc_net_set_socket_opt(sock, SOL_SOCKET, SO_REUSEADDR, 1);
     if (rval < 0) {
       SILC_LOG_ERROR(("Cannot set socket options: %s", strerror(errno)));
+      close(sock);
       goto err;
     }
 
     /* Bind the listener socket */
     rval = bind(sock, &server.sa, SIZEOF_SOCKADDR(server));
     if (rval < 0) {
-      SILC_LOG_DEBUG(("Cannot bind socket: %s", strerror(errno)));
+      silc_set_errno_posix(errno);
+      SILC_LOG_ERROR(("Cannot bind socket: %s",
+		      silc_errno_string(silc_errno)));
+      close(sock);
       goto err;
     }
 
     /* Specify that we are listenning */
-    rval = listen(sock, 5);
+    rval = listen(sock, 64);
     if (rval < 0) {
-      SILC_LOG_ERROR(("Cannot set socket listenning: %s", strerror(errno)));
+      silc_set_errno_posix(errno);
+      SILC_LOG_ERROR(("Cannot set socket listenning: %s",
+		      silc_errno_string(silc_errno)));
+      close(sock);
       goto err;
     }
 
@@ -216,8 +239,140 @@ silc_net_tcp_create_listener(const char **local_ip_addr,
   return listener;
 
  err:
-  if (callback)
-    callback(SILC_NET_ERROR, NULL, context);
+  if (listener)
+    silc_net_close_listener(listener);
+  return NULL;
+}
+
+/* Create TCP listener, 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;
+  SilcSockaddr server;
+  int i, sock, 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 ports */
+  for (i = 0; i < port_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 < 0) {
+      if (ignore_port_error)
+	continue;
+      silc_set_errno_posix(errno);
+      SILC_LOG_ERROR(("Cannot create socket: %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 < 0) {
+      close(sock);
+      if (ignore_port_error)
+	continue;
+      SILC_LOG_ERROR(("Cannot set socket options: %s",
+		      silc_errno_string(silc_errno)));
+      goto err;
+    }
+
+    /* Bind the listener socket */
+    rval = bind(sock, &server.sa, SIZEOF_SOCKADDR(server));
+    if (rval < 0) {
+      close(sock);
+      if (ignore_port_error)
+	continue;
+      silc_set_errno_posix(errno);
+      SILC_LOG_ERROR(("Cannot bind socket: %s",
+		      silc_errno_string(silc_errno)));
+      goto err;
+    }
+
+    /* Specify that we are listenning */
+    rval = listen(sock, 64);
+    if (rval < 0) {
+      close(sock);
+      if (ignore_port_error)
+	continue;
+      silc_set_errno_posix(errno);
+      SILC_LOG_ERROR(("Cannot set socket listenning: %s",
+		      silc_errno_string(silc_errno)));
+      goto err;
+    }
+
+    /* Set the server socket to non-blocking mode */
+    silc_net_set_socket_nonblock(sock);
+
+    /* 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++;
+  }
+
+  if (ignore_port_error && !listener->socks_count)
+    goto err;
+
+  return listener;
+
+ err:
   if (listener)
     silc_net_close_listener(listener);
   return NULL;
@@ -241,6 +396,8 @@ void silc_net_close_listener(SilcNetListener listener)
   silc_free(listener);
 }
 
+/******************************* UDP Stream *********************************/
+
 /* Create UDP stream */
 
 SilcStream
@@ -255,8 +412,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",
@@ -270,20 +432,24 @@ silc_net_udp_connect(const char *local_ip_addr, int local_port,
   /* Create the socket */
   sock = socket(server.sin.sin_family, SOCK_DGRAM, 0);
   if (sock < 0) {
-    SILC_LOG_ERROR(("Cannot create socket: %s", strerror(errno)));
+    silc_set_errno_posix(errno);
+    SILC_LOG_ERROR(("Cannot create socket: %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 < 0) {
-    SILC_LOG_ERROR(("Cannot set socket options: %s", strerror(errno)));
+    SILC_LOG_ERROR(("Cannot set socket options: %s",
+		    silc_errno_string(silc_errno)));
     goto err;
   }
 #ifdef SO_REUSEPORT
   rval = silc_net_set_socket_opt(sock, SOL_SOCKET, SO_REUSEPORT, 1);
   if (rval < 0) {
-    SILC_LOG_ERROR(("Cannot set socket options: %s", strerror(errno)));
+    SILC_LOG_ERROR(("Cannot set socket options: %s",
+		    silc_errno_string(silc_errno)));
     goto err;
   }
 #endif /* SO_REUSEPORT */
@@ -291,13 +457,11 @@ silc_net_udp_connect(const char *local_ip_addr, int local_port,
   /* Bind the listener socket */
   rval = bind(sock, &server.sa, SIZEOF_SOCKADDR(server));
   if (rval < 0) {
-    SILC_LOG_DEBUG(("Cannot bind socket: %s", strerror(errno)));
+    silc_set_errno_posix(errno);
+    SILC_LOG_DEBUG(("Cannot bind socket: %s", silc_errno_string(silc_errno)));
     goto err;
   }
 
-  /* Set socket to non-blocking mode */
-  silc_net_set_socket_nonblock(sock);
-
   /* Set to connected state if remote address is provided. */
   if (remote_ip_addr && remote_port) {
     if (!silc_net_set_sockaddr(&server, remote_ip_addr, remote_port))
@@ -305,24 +469,32 @@ silc_net_udp_connect(const char *local_ip_addr, int local_port,
 
     rval = connect(sock, &server.sa, SIZEOF_SOCKADDR(server));
     if (rval < 0) {
-      SILC_LOG_DEBUG(("Cannot connect UDP stream: %s", strerror(errno)));
+      silc_set_errno_posix(errno);
+      SILC_LOG_DEBUG(("Cannot connect UDP stream: %s",
+		      silc_errno_string(silc_errno)));
       goto err;
     }
   }
 
   /* Set send and receive buffer size */
 #ifdef SO_SNDBUF
-  rval = silc_net_set_socket_opt(sock, SOL_SOCKET, SO_SNDBUF, 65535);
+  rval = silc_net_set_socket_opt(sock, SOL_SOCKET, SO_SNDBUF, 765535);
   if (rval < 0) {
-    SILC_LOG_ERROR(("Cannot set socket options: %s", strerror(errno)));
-    goto err;
+    rval = silc_net_set_socket_opt(sock, SOL_SOCKET, SO_SNDBUF, 65535);
+    if (rval < 0) {
+      SILC_LOG_ERROR(("Cannot set socket options: %s", strerror(errno)));
+      goto err;
+    }
   }
 #endif /* SO_SNDBUF */
 #ifdef SO_RCVBUF
-  rval = silc_net_set_socket_opt(sock, SOL_SOCKET, SO_RCVBUF, 65535);
+  rval = silc_net_set_socket_opt(sock, SOL_SOCKET, SO_RCVBUF, 765535);
   if (rval < 0) {
-    SILC_LOG_ERROR(("Cannot set socket options: %s", strerror(errno)));
-    goto err;
+    rval = silc_net_set_socket_opt(sock, SOL_SOCKET, SO_RCVBUF, 65535);
+    if (rval < 0) {
+      SILC_LOG_ERROR(("Cannot set socket options: %s", strerror(errno)));
+      goto err;
+    }
   }
 #endif /* SO_RCVBUF */
 
@@ -330,7 +502,7 @@ silc_net_udp_connect(const char *local_ip_addr, int local_port,
   stream =
     silc_socket_udp_stream_create(sock, local_ip_addr ?
 				  silc_net_is_ip6(local_ip_addr) : FALSE,
-				  schedule);
+				  remote_ip_addr ? TRUE : FALSE, schedule);
   if (!stream)
     goto err;
 
@@ -358,8 +530,10 @@ int silc_net_udp_receive(SilcStream stream, char *remote_ip_addr,
 
   if (remote_ip_addr && remote_port) {
     if (sock->ipv6) {
+#ifdef HAVE_IPV6
       from = (struct sockaddr *)&s.sin6;
       flen = sizeof(s.sin6);
+#endif /* HAVE_IPV6 */
     } else {
       from = (struct sockaddr *)&s.sin;
       flen = sizeof(s.sin);
@@ -369,6 +543,7 @@ int silc_net_udp_receive(SilcStream stream, char *remote_ip_addr,
     len = recv(sock->sock, ret_data, data_size, 0);
 
   if (len < 0) {
+    silc_set_errno_posix(errno);
     if (errno == EAGAIN || errno == EINTR) {
       SILC_LOG_DEBUG(("Could not read immediately, will do it later"));
       silc_schedule_set_listen_fd(sock->schedule, sock->sock,
@@ -378,7 +553,6 @@ int silc_net_udp_receive(SilcStream stream, char *remote_ip_addr,
     SILC_LOG_DEBUG(("Cannot read from UDP socket: %d:%s",
 		    sock->sock, strerror(errno)));
     silc_schedule_unset_listen_fd(sock->schedule, sock->sock);
-    sock->sock_error = errno;
     return -2;
   }
 
@@ -390,14 +564,20 @@ int silc_net_udp_receive(SilcStream stream, char *remote_ip_addr,
   /* Return remote address */
   if (remote_ip_addr && remote_port) {
     if (sock->ipv6) {
+#ifdef HAVE_IPV6
       *remote_port = ntohs(s.sin6.sin6_port);
       inet_ntop(AF_INET6, &s.sin6.sin6_addr, remote_ip_addr,
 		remote_ip_addr_size);
+#else
+      *remote_port = 0;
+#endif /* HAVE_IPV6 */
     } else {
       *remote_port = ntohs(s.sin.sin_port);
       inet_ntop(AF_INET, &s.sin.sin_addr, remote_ip_addr,
 		remote_ip_addr_size);
     }
+
+    SILC_LOG_DEBUG(("UDP packet from %s:%d", remote_ip_addr, *remote_port));
   }
 
   return len;
@@ -405,31 +585,54 @@ int silc_net_udp_receive(SilcStream stream, char *remote_ip_addr,
 
 /* Send UDP packet */
 
-void silc_net_udp_send(SilcStream stream,
-		       const char *remote_ip_addr, int remote_port,
-		       const unsigned char *data, SilcUInt32 data_len)
+int silc_net_udp_send(SilcStream stream,
+		      const char *remote_ip_addr, int remote_port,
+		      const unsigned char *data, SilcUInt32 data_len)
 {
   SilcSocketStream sock = stream;
   SilcSockaddr remote;
+  int ret;
 
-  SILC_LOG_DEBUG(("Writing data to UDP socket %d", sock->sock));
+  SILC_LOG_DEBUG(("Sending data to UDP socket %d", sock->sock));
 
-  /* Set sockaddr for server */
+  /* Set sockaddr */
   if (!silc_net_set_sockaddr(&remote, remote_ip_addr, remote_port))
-    return;
+    return -2;
 
   /* Send */
-  sendto(sock->sock, data, data_len, 0, &remote.sa, SIZEOF_SOCKADDR(remote));
+  ret = sendto(sock->sock, data, data_len, 0, &remote.sa,
+	       SIZEOF_SOCKADDR(remote));
+  if (ret < 0) {
+    silc_set_errno_posix(errno);
+    if (errno == EAGAIN || errno == EINTR) {
+      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_schedule_unset_listen_fd(sock->schedule, sock->sock);
+    return -2;
+  }
+
+  SILC_LOG_DEBUG(("Sent data %d bytes", ret));
+  if (silc_schedule_get_fd_events(sock->schedule, sock->sock) &
+      SILC_TASK_WRITE)
+    silc_schedule_set_listen_fd(sock->schedule, sock->sock,
+				SILC_TASK_READ, FALSE);
+
+  return ret;
 }
 
+/******************************* TCP Stream *********************************/
+
 /* Asynchronous TCP/IP connecting */
 
 typedef struct {
-  SilcNetStatus status;
-  SilcSocketStreamStatus stream_status;
+  SilcResult status;
   SilcStream stream;
   SilcFSMStruct fsm;
-  SilcFSMSemaStruct sema;
+  SilcFSMEventStruct event;
   SilcAsyncOperation op;
   SilcAsyncOperation sop;
   char *local_ip;
@@ -451,8 +654,7 @@ SILC_FSM_STATE(silc_net_connect_st_finish);
 SILC_TASK_CALLBACK(silc_net_connect_wait)
 {
   SilcNetConnect conn = context;
-  SILC_FSM_SEMA_POST(&conn->sema);
-  silc_schedule_task_del_by_fd(schedule, conn->sock);
+  SILC_FSM_EVENT_SIGNAL(&conn->event);
 }
 
 SILC_FSM_STATE(silc_net_connect_st_start)
@@ -476,7 +678,7 @@ SILC_FSM_STATE(silc_net_connect_st_start)
 		    "host", conn->remote));
 
     /** Network unreachable */
-    conn->status = SILC_NET_HOST_UNREACHABLE;
+    conn->status = SILC_ERR_UNREACHABLE;
     silc_fsm_next(fsm, silc_net_connect_st_finish);
     return SILC_FSM_CONTINUE;
   }
@@ -499,6 +701,7 @@ SILC_FSM_STATE(silc_net_connect_st_start)
     }
 
     /** Cannot create socket */
+    silc_set_errno_posix(errno);
     SILC_LOG_ERROR(("Cannot create socket: %s", strerror(errno)));
     silc_fsm_next(fsm, silc_net_connect_st_finish);
     return SILC_FSM_CONTINUE;
@@ -520,20 +723,19 @@ SILC_FSM_STATE(silc_net_connect_st_start)
   rval = connect(sock, &desthost.sa, SIZEOF_SOCKADDR(desthost));
   if (rval < 0) {
     if (errno != EINPROGRESS) {
-      /* retry using an IPv4 adress, if IPv6 didn't work */
-      if (prefer_ipv6 && silc_net_is_ip6(conn->ip_addr)) {
-        shutdown(sock, 2);
-        close(sock);
+      silc_set_errno_posix(errno);
+      shutdown(sock, 2);
+      close(sock);
 
+      /* Retry using an IPv4 adress, if IPv6 didn't work */
+      if (prefer_ipv6 && silc_net_is_ip6(conn->ip_addr)) {
         prefer_ipv6 = FALSE;
         goto retry;
       }
 
-      shutdown(sock, 2);
-      close(sock);
-
       /** Cannot connect to remote host */
-      SILC_LOG_ERROR(("Cannot connect to remote host: %s", strerror(errno)));
+      SILC_LOG_ERROR(("Cannot connect to remote host: %s",
+		      silc_errno_string(silc_errno)));
       silc_fsm_next(fsm, silc_net_connect_st_finish);
       return SILC_FSM_CONTINUE;
     }
@@ -551,20 +753,21 @@ SILC_FSM_STATE(silc_net_connect_st_start)
 
   /** Wait for connection */
   silc_fsm_next(fsm, silc_net_connect_st_connected);
-  silc_fsm_sema_init(&conn->sema, fsm, 0);
+  silc_fsm_event_init(&conn->event, fsm);
   silc_schedule_task_add_fd(silc_fsm_get_schedule(fsm), sock,
 			    silc_net_connect_wait, conn);
   silc_schedule_set_listen_fd(silc_fsm_get_schedule(fsm), sock,
 			      SILC_TASK_WRITE, FALSE);
-  SILC_FSM_SEMA_WAIT(&conn->sema);
+  SILC_FSM_EVENT_WAIT(&conn->event);
   return SILC_FSM_CONTINUE;
 }
 
-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->stream_status = status;
+  conn->sop = NULL;
+  conn->status = status;
   conn->stream = stream;
   SILC_FSM_CALL_CONTINUE(&conn->fsm);
 }
@@ -577,6 +780,8 @@ SILC_FSM_STATE(silc_net_connect_st_connected)
 
   if (conn->aborted) {
     /** Aborted */
+    silc_schedule_unset_listen_fd(schedule, conn->sock);
+    silc_schedule_task_del_by_fd(schedule, conn->sock);
     silc_fsm_next(fsm, silc_net_connect_st_finish);
     return SILC_FSM_CONTINUE;
   }
@@ -584,8 +789,8 @@ SILC_FSM_STATE(silc_net_connect_st_connected)
   ret = silc_net_get_socket_opt(conn->sock, SOL_SOCKET, SO_ERROR,
 				&opt, &optlen);
 
-  silc_schedule_task_del_by_fd(schedule, conn->sock);
   silc_schedule_unset_listen_fd(schedule, conn->sock);
+  silc_schedule_task_del_by_fd(schedule, conn->sock);
 
   if (ret != 0 || opt != 0) {
     if (conn->retry) {
@@ -597,30 +802,23 @@ SILC_FSM_STATE(silc_net_connect_st_connected)
       return SILC_FSM_CONTINUE;
     }
 
-#if defined(ECONNREFUSED)
-    if (errno == ECONNREFUSED)
-      conn->status = SILC_NET_CONNECTION_REFUSED;
-#endif /* ECONNREFUSED */
-#if defined(ETIMEDOUT)
-    if (errno == ETIMEDOUT)
-      conn->status = SILC_NET_CONNECTION_TIMEOUT;
-#endif /* ETIMEDOUT */
-#if defined(ENETUNREACH)
-    if (errno == ENETUNREACH)
-      conn->status = SILC_NET_HOST_UNREACHABLE;
-#endif /* ENETUNREACH */
+    /* Set error */
+    silc_set_errno_posix(opt);
+    conn->status = silc_errno;
 
     /** Connecting failed */
-    SILC_LOG_DEBUG(("Connecting failed"));
+    SILC_LOG_DEBUG(("Connecting failed, error %s",
+		    silc_errno_string(silc_errno)));
     silc_fsm_next(fsm, silc_net_connect_st_finish);
     return SILC_FSM_CONTINUE;
   }
 
+  SILC_LOG_DEBUG(("TCP connection established"));
+
   /** Connection created */
   silc_fsm_next(fsm, silc_net_connect_st_stream);
   SILC_FSM_CALL((conn->sop = silc_socket_tcp_stream_create(
-				     conn->sock, FALSE, FALSE,
-				     schedule,
+				     conn->sock, TRUE, FALSE, schedule,
 				     silc_net_connect_wait_stream, conn)));
 }
 
@@ -634,26 +832,15 @@ SILC_FSM_STATE(silc_net_connect_st_stream)
     return SILC_FSM_CONTINUE;
   }
 
-  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;
     silc_fsm_next(fsm, silc_net_connect_st_finish);
     return SILC_FSM_CONTINUE;
   }
 
-  /* Set stream information */
-  silc_socket_stream_set_info(conn->stream,
-			      !silc_net_is_ip(conn->remote) ? conn->remote :
-			      conn->ip_addr, conn->ip_addr, conn->port);
-
   /** Stream created successfully */
-  SILC_LOG_DEBUG(("Connected successfully"));
-  conn->status = SILC_NET_OK;
+  SILC_LOG_DEBUG(("Connected successfully, sock %d", conn->sock));
+  conn->status = SILC_OK;
   silc_fsm_next(fsm, silc_net_connect_st_finish);
   return SILC_FSM_CONTINUE;
 }
@@ -667,8 +854,6 @@ SILC_FSM_STATE(silc_net_connect_st_finish)
     conn->callback(conn->status, conn->stream, conn->context);
     if (conn->op)
       silc_async_free(conn->op);
-    if (conn->sop)
-      silc_async_free(conn->sop);
   }
 
   return SILC_FSM_FINISH;
@@ -680,8 +865,10 @@ static void silc_net_connect_abort(SilcAsyncOperation op, void *context)
   conn->aborted = TRUE;
 
   /* Abort underlaying stream creation too */
-  if (conn->sop)
-    silc_async_abort(conn->op, NULL, NULL);
+  if (conn->sop) {
+    silc_async_abort(conn->sop, NULL, NULL);
+    conn->sop = NULL;
+  }
 }
 
 static void silc_net_connect_destructor(SilcFSM fsm, void *fsm_context,
@@ -704,37 +891,51 @@ 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_errno, NULL, context);
     return NULL;
   }
 
   /* Start async operation */
   conn->op = silc_async_alloc(silc_net_connect_abort, NULL, conn);
   if (!conn->op) {
-    callback(SILC_NET_NO_MEMORY, NULL, context);
+    silc_free(conn);
+    callback(silc_errno, 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) {
-    callback(SILC_NET_NO_MEMORY, NULL, context);
+    silc_async_free(conn->op);
+    silc_free(conn->local_ip);
+    silc_free(conn);
+    callback(silc_errno, 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_start);
@@ -746,14 +947,18 @@ SilcAsyncOperation silc_net_tcp_connect(const char *local_ip_addr,
 
 void silc_net_close_connection(int sock)
 {
+  SILC_LOG_DEBUG(("Closing sock %d", sock));
   close(sock);
 }
 
 /* Set's the socket to non-blocking mode. */
 
-int silc_net_set_socket_nonblock(int sock)
+int silc_net_set_socket_nonblock(SilcSocket sock)
 {
-  return fcntl(sock, F_SETFL, fcntl(sock, F_GETFL, 0) | O_NONBLOCK);
+  int ret = fcntl((int)sock, F_SETFL, fcntl(sock, F_GETFL, 0) | O_NONBLOCK);
+  if (ret)
+    silc_set_errno_posix(errno);
+  return ret;
 }
 
 /* Converts the IP number string from numbers-and-dots notation to
@@ -766,9 +971,17 @@ SilcBool silc_net_addr2bin(const char *addr, void *bin, SilcUInt32 bin_len)
   if (silc_net_is_ip4(addr)) {
     /* IPv4 address */
     struct in_addr tmp;
+
+    if (bin_len < 4) {
+      silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+      return FALSE;
+    }
+
     ret = inet_aton(addr, &tmp);
-    if (bin_len < 4)
+    if (!ret) {
+      silc_set_errno_posix(errno);
       return FALSE;
+    }
 
     memcpy(bin, (unsigned char *)&tmp.s_addr, 4);
 #ifdef HAVE_IPV6
@@ -777,8 +990,10 @@ SilcBool silc_net_addr2bin(const char *addr, void *bin, SilcUInt32 bin_len)
     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;