X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=lib%2Fsilcutil%2Fsymbian%2Fsilcsymbiannet.cpp;h=c665b3d339632fb6655a6b0484f2e726c1e1def3;hb=e7b6c157b80152bf9fb9266e6bdd93f9fb0db776;hp=25e7ad2f7b2fdd840fa71fa44220bb2b226bfaae;hpb=196824372226561334cd638d6471267cbffb354c;p=silc.git

diff --git a/lib/silcutil/symbian/silcsymbiannet.cpp b/lib/silcutil/symbian/silcsymbiannet.cpp
index 25e7ad2f..c665b3d3 100644
--- a/lib/silcutil/symbian/silcsymbiannet.cpp
+++ b/lib/silcutil/symbian/silcsymbiannet.cpp
@@ -64,21 +64,25 @@ static SilcBool silc_net_set_sockaddr(TInetAddr *addr, const char *ip_addr,
 
 class SilcSymbianTCPListener;
 
+extern "C" {
+
 /* 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 = (SilcNetListener)context;
 
   /* In case of error, the socket has been destroyed already via
      silc_stream_destroy. */
-  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);
 }
 
+} /* extern "C" */
+
 /* TCP Listener class */
 
 class SilcSymbianTCPListener : public CActive {
@@ -177,12 +181,22 @@ 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 = (SilcNetListener)silc_calloc(1, sizeof(*listener));
   if (!listener) {
-    callback(SILC_NET_NO_MEMORY, NULL, context);
+    callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
     return NULL;
   }
   listener->schedule = schedule;
@@ -195,13 +209,13 @@ silc_net_tcp_create_listener(const char **local_ip_addr,
     listener->socks = (SilcSocket *)silc_calloc(local_ip_count,
 					        sizeof(*listener->socks));
     if (!listener->socks) {
-      callback(SILC_NET_NO_MEMORY, NULL, context);
+      callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
       return NULL;
     }
   } else {
     listener->socks = (SilcSocket *)silc_calloc(1, sizeof(*listener->socks));
     if (!listener->socks) {
-      callback(SILC_NET_NO_MEMORY, NULL, context);
+      callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
       return NULL;
     }
 
@@ -273,7 +287,164 @@ silc_net_tcp_create_listener(const char **local_ip_addr,
   if (l)
     delete l;
   if (callback)
-    callback(SILC_NET_ERROR, NULL, context);
+    callback(SILC_ERR, 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;
+  SilcSymbianTCPListener *l = NULL;
+  TInetAddr server;
+  TInt ret;
+  int i;
+
+  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 = (SilcNetListener)silc_calloc(1, sizeof(*listener));
+  if (!listener) {
+    callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
+    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 = (SilcSocket *)silc_calloc(port_count,
+					        sizeof(*listener->socks));
+    if (!listener->socks) {
+      callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
+      return NULL;
+    }
+  } else {
+    listener->socks = (SilcSocket *)silc_calloc(1, sizeof(*listener->socks));
+    if (!listener->socks) {
+      callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
+      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 : "0.0.0.0",
+		    ports ? ports[i] : 0));
+
+    l = new SilcSymbianTCPListener;
+    if (!l)
+      goto err;
+
+    /* Connect to socket server */
+    ret = l->ss.Connect();
+    if (ret != KErrNone)
+      goto err;
+
+#ifdef SILC_THREADS
+    /* Make our socket shareable between threads */
+    l->ss.ShareAuto();
+#endif /* SILC_THREADS */
+
+    /* Set listener address */
+    if (!silc_net_set_sockaddr(&server, local_ip_addr, ports ? ports[i] : 0)) {
+      if (ignore_port_error) {
+	delete l;
+	continue;
+      }
+      goto err;
+    }
+
+    /* Create the socket */
+    ret = l->sock.Open(l->ss, KAfInet, KSockStream, KProtocolInetTcp);
+    if (ret != KErrNone) {
+      if (ignore_port_error) {
+	delete l;
+	continue;
+      }
+      SILC_LOG_ERROR(("Cannot create socket, error %d", ret));
+      goto err;
+    }
+
+    /* Set the socket options */
+    ret = l->sock.SetOpt(KSoReuseAddr, KSolInetIp, 1);
+    if (ret != KErrNone) {
+      if (ignore_port_error) {
+	delete l;
+	continue;
+      }
+      SILC_LOG_ERROR(("Cannot set socket options, error %d", ret));
+      goto err;
+    }
+
+    /* Bind the listener socket */
+    ret = l->sock.Bind(server);
+    if (ret != KErrNone) {
+      if (ignore_port_error) {
+	delete l;
+	continue;
+      }
+      SILC_LOG_DEBUG(("Cannot bind socket, error %d", ret));
+      goto err;
+    }
+
+    /* Specify that we are listenning */
+    ret = l->sock.Listen(5);
+    if (ret != KErrNone) {
+      if (ignore_port_error) {
+	delete l;
+	continue;
+      }
+      SILC_LOG_ERROR(("Cannot set socket listenning, error %d", ret));
+      goto err;
+    }
+    l->Listen();
+
+    l->listener = listener;
+    listener->socks[i] = (SilcSocket)l;
+    listener->socks_count++;
+  }
+
+  if (ignore_port_error && !listener->socks_count) {
+    l = NULL;
+    goto err;
+  }
+
+  SILC_LOG_DEBUG(("TCP listener created"));
+
+  return listener;
+
+ err:
+  if (l)
+    delete l;
+  if (callback)
+    callback(SILC_ERR, NULL, context);
   if (listener)
     silc_net_close_listener(listener);
   return NULL;
@@ -304,12 +475,13 @@ void silc_net_close_listener(SilcNetListener listener)
   silc_free(listener);
 }
 
-} /* extern "C" */
 
 /**************************** TCP/IP connecting *****************************/
 
-static void silc_net_connect_stream(SilcSocketStreamStatus status,
-	    SilcStream stream, void *context);
+static void silc_net_connect_stream(SilcResult status,
+				    SilcStream stream, void *context);
+
+} /* extern "C" */
 
 /* TCP connecting class */
 
@@ -345,7 +517,7 @@ public:
 
     if (iStatus != KErrNone) {
       if (callback)
-	callback(SILC_NET_ERROR, NULL, context);
+	callback(SILC_ERR, NULL, context);
       sock->CancelConnect();
       delete sock;
       ss->Close();
@@ -405,28 +577,16 @@ extern "C" {
 
 /* TCP stream creation callback */
 
-static void silc_net_connect_stream(SilcSocketStreamStatus status,
+static void silc_net_connect_stream(SilcResult status,
 				    SilcStream stream, void *context)
 {
   SilcSymbianTCPConnect *conn = (SilcSymbianTCPConnect *)context;
-  SilcNetStatus net_status = SILC_NET_OK;
 
   SILC_LOG_DEBUG(("Socket stream creation status %d", status));
 
-  if (status != SILC_SOCKET_OK) {
-    /* In case of error, the socket has been destroyed already via
-       silc_stream_destroy. */
-    if (status == SILC_SOCKET_UNKNOWN_IP)
-      net_status = SILC_NET_UNKNOWN_IP;
-    else if (status == SILC_SOCKET_UNKNOWN_HOST)
-      net_status = SILC_NET_UNKNOWN_HOST;
-    else
-      net_status = SILC_NET_ERROR;
-  }
-
   /* Call connection callback */
   if (conn->callback)
-    conn->callback(net_status, stream, conn->context);
+    conn->callback(status, stream, conn->context);
   else if (stream)
     silc_stream_destroy(stream);
 
@@ -457,18 +617,28 @@ SilcAsyncOperation silc_net_tcp_connect(const char *local_ip_addr,
 {
   SilcSymbianTCPConnect *conn;
   TInetAddr local, remote;
-  SilcNetStatus status;
+  SilcResult status;
   TInt ret;
 
-  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 = new SilcSymbianTCPConnect;
   if (!conn) {
-    callback(SILC_NET_NO_MEMORY, NULL, context);
+    callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
     return NULL;
   }
   conn->schedule = schedule;
@@ -477,21 +647,21 @@ SilcAsyncOperation silc_net_tcp_connect(const char *local_ip_addr,
   conn->port = remote_port;
   conn->remote = strdup(remote_ip_addr);
   if (!conn->remote) {
-    status = SILC_NET_NO_MEMORY;
+    status = SILC_ERR_OUT_OF_MEMORY;
     goto err;
   }
 
   /* Allocate socket */
   conn->sock = new RSocket;
   if (!conn->sock) {
-    status = SILC_NET_NO_MEMORY;
+    status = SILC_ERR_OUT_OF_MEMORY;
     goto err;
   }
 
   /* Allocate socket server */
   conn->ss = new RSocketServ;
   if (!conn->ss) {
-    status = SILC_NET_NO_MEMORY;
+    status = SILC_ERR_OUT_OF_MEMORY;
     goto err;
   }
 
@@ -499,7 +669,7 @@ SilcAsyncOperation silc_net_tcp_connect(const char *local_ip_addr,
   ret = conn->ss->Connect();
   if (ret != KErrNone) {
     SILC_LOG_ERROR(("Error connecting to socket server, error %d", ret));
-    status = SILC_NET_ERROR;
+    status = SILC_ERR;
     goto err;
   }
 
@@ -511,7 +681,7 @@ SilcAsyncOperation silc_net_tcp_connect(const char *local_ip_addr,
   /* Start async operation */
   conn->op = silc_async_alloc(silc_net_connect_abort, NULL, (void *)conn);
   if (!conn->op) {
-    status = SILC_NET_NO_MEMORY;
+    status = SILC_ERR_OUT_OF_MEMORY;
     goto err;
   }
 
@@ -520,7 +690,7 @@ SilcAsyncOperation silc_net_tcp_connect(const char *local_ip_addr,
 			      sizeof(conn->remote_ip))) {
     SILC_LOG_ERROR(("Network (%s) unreachable: could not resolve the "
 		    "host", conn->remote));
-    status = SILC_NET_HOST_UNREACHABLE;
+    status = SILC_ERR_UNREACHABLE;
     goto err;
   }
 
@@ -528,7 +698,7 @@ SilcAsyncOperation silc_net_tcp_connect(const char *local_ip_addr,
   ret = conn->sock->Open(*conn->ss, KAfInet, KSockStream, KProtocolInetTcp);
   if (ret != KErrNone) {
     SILC_LOG_ERROR(("Cannot create socket, error %d", ret));
-    status = SILC_NET_ERROR;
+    status = SILC_ERR;
     goto err;
   }
 
@@ -544,7 +714,7 @@ SilcAsyncOperation silc_net_tcp_connect(const char *local_ip_addr,
   /* Connect to the host */
   if (!silc_net_set_sockaddr(&remote, conn->remote_ip, remote_port)) {
     SILC_LOG_ERROR(("Cannot connect (cannot set address)"));
-    status = SILC_NET_ERROR;
+    status = SILC_ERR;
     goto err;
   }
   conn->Connect(remote);
@@ -587,8 +757,13 @@ SilcStream 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;
+    }
+  }
 
   SILC_LOG_DEBUG(("Binding to local address %s",
 		  local_ip_addr ? local_ip_addr : "0.0.0.0"));