-/*\r
-\r
- silcsymbiannet.cpp\r
-\r
- Author: Pekka Riikonen <priikone@silcnet.org>\r
-\r
- Copyright (C) 2006 Pekka Riikonen\r
-\r
- This program is free software; you can redistribute it and/or modify\r
- it under the terms of the GNU General Public License as published by\r
- the Free Software Foundation; version 2 of the License.\r
-\r
- This program is distributed in the hope that it will be useful,\r
- but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
- GNU General Public License for more details.\r
-\r
-*/\r
-\r
-#include "silc.h"\r
-#include "silcsymbiansocketstream.h"\r
-\r
-/****************************** TCP Listener ********************************/\r
-\r
-class SilcSymbianTCPListener;\r
-\r
-/* Deliver new stream to upper layer */\r
-\r
-static void silc_net_accept_stream(SilcSocketStreamStatus status,\r
- SilcStream stream, void *context)\r
-{\r
- SilcNetListener listener = (SilcNetListener)context;\r
-\r
- /* In case of error, the socket has been destroyed already */\r
- if (status != SILC_SOCKET_OK)\r
- return;\r
-\r
- listener->callback(SILC_NET_OK, stream, listener->context);\r
-}\r
-\r
-/* TCP Listener class */\r
-\r
-class SilcSymbianTCPListener : public CActive {\r
-public:\r
- /* Constructor */\r
- SilcSymbianTCPListener() : CActive(CActive::EPriorityStandard)\r
- {\r
- CActiveScheduler::Add(this);\r
- }\r
-\r
- /* Destructor */\r
- ~SilcSymbianTCPListener()\r
- {\r
- Cancel();\r
- }\r
-\r
- /* Listen for connection */\r
- void Listen()\r
- {\r
- new_conn = new RSocket;\r
- if (!new_conn)\r
- return;\r
- User::LeaveIfError(new_conn->Open(ss));\r
-\r
- /* Start listenning */\r
- sock.Accept(*new_conn, iStatus);\r
- SetActive();\r
- }\r
-\r
- /* Listener callback */\r
- void RunL()\r
- {\r
- if (iStatus != KErrNone) {\r
- if (new_conn)\r
- delete new_conn;\r
- new_conn = NULL;\r
- Listen();\r
- return;\r
- }\r
-\r
- /* Set socket options */\r
- new_conn->SetOpt(KSoReuseAddr, KSolInetIp, 1);\r
-\r
- /* Create socket stream */\r
- silc_socket_tcp_stream_create(\r
- (SilcSocket)silc_create_symbian_socket(new_conn, NULL),\r
- listener->lookup, listener->require_fqdn,\r
- listener->schedule, silc_net_accept_stream,\r
- (void *)listener);\r
-\r
- /* Continue listenning */\r
- Listen();\r
- }\r
-\r
- /* Cancel */\r
- void DoCancel()\r
- {\r
- sock.CancelAll();\r
- ss.Close();\r
- if (new_conn)\r
- delete new_conn;\r
- }\r
-\r
- RSocket *new_conn;\r
- RSocket sock;\r
- RSocketServ ss;\r
- SilcNetListener listener;\r
-};\r
-\r
-/* Create TCP listener */\r
-\r
-SilcNetListener\r
-silc_net_tcp_create_listener(const char **local_ip_addr,\r
- SilcUInt32 local_ip_count, int port,\r
- SilcBool lookup, SilcBool require_fqdn,\r
- SilcSchedule schedule,\r
- SilcNetCallback callback, void *context)\r
-{\r
- SilcNetListener listener = NULL;\r
- SilcSymbianTCPListener *l = NULL;\r
- TInetAddr server;\r
- TInt ret;\r
- TBuf<64> tmp;\r
- int i;\r
-\r
- SILC_LOG_DEBUG(("Creating TCP listener"));\r
-\r
- if (port < 0 || !schedule || !callback)\r
- goto err;\r
-\r
- listener = (SilcNetListener)silc_calloc(1, sizeof(*listener));\r
- if (!listener) {\r
- callback(SILC_NET_NO_MEMORY, NULL, context);\r
- return NULL;\r
- }\r
- listener->schedule = schedule;\r
- listener->callback = callback;\r
- listener->context = context;\r
- listener->require_fqdn = require_fqdn;\r
- listener->lookup = lookup;\r
-\r
- if (local_ip_count > 0) {\r
- listener->socks = (SilcSocket *)silc_calloc(local_ip_count,\r
- sizeof(*listener->socks));\r
- if (!listener->socks) {\r
- callback(SILC_NET_NO_MEMORY, NULL, context);\r
- return NULL;\r
- }\r
- } else {\r
- listener->socks = (SilcSocket *)silc_calloc(1, sizeof(*listener->socks));\r
- if (!listener->socks) {\r
- callback(SILC_NET_NO_MEMORY, NULL, context);\r
- return NULL;\r
- }\r
-\r
- local_ip_count = 1;\r
- }\r
-\r
- /* Bind to local addresses */\r
- for (i = 0; i < local_ip_count; i++) {\r
- SILC_LOG_DEBUG(("Binding to local address %s",\r
- local_ip_addr ? local_ip_addr[i] : "0.0.0.0"));\r
-\r
- l = new SilcSymbianTCPListener;\r
- if (!l)\r
- goto err;\r
-\r
- /* Connect to socket server */\r
- ret = l->ss.Connect();\r
- if (ret != KErrNone)\r
- goto err;\r
-\r
- /* Set listener address */\r
- if (local_ip_addr) {\r
- server = TInetAddr(port);\r
- tmp = (TText *)local_ip_addr[i];\r
- ret = server.Input(tmp);\r
- if (ret != KErrNone)\r
- goto err;\r
- } else {\r
- server = TInetAddr(KInetAddrAny, port);\r
- }\r
-\r
- /* Create the socket */\r
- ret = l->sock.Open(l->ss, KAfInet, KSockStream, KProtocolInetTcp);\r
- if (ret != KErrNone) {\r
- SILC_LOG_ERROR(("Cannot create socket"));\r
- goto err;\r
- }\r
-\r
- /* Set the socket options */\r
- ret = l->sock.SetOpt(KSoReuseAddr, KSolInetIp, 1);\r
- if (ret != KErrNone) {\r
- SILC_LOG_ERROR(("Cannot set socket options"));\r
- goto err;\r
- }\r
-\r
- /* Bind the listener socket */\r
- ret = l->sock.Bind(server);\r
- if (ret != KErrNone) {\r
- SILC_LOG_DEBUG(("Cannot bind socket"));\r
- goto err;\r
- }\r
-\r
- /* Specify that we are listenning */\r
- ret = l->sock.Listen(5);\r
- if (ret != KErrNone) {\r
- SILC_LOG_ERROR(("Cannot set socket listenning"));\r
- goto err;\r
- }\r
- l->Listen();\r
-\r
- l->listener = listener;\r
- listener->socks[i] = (SilcSocket)l;\r
- listener->socks_count++;\r
- }\r
-\r
- SILC_LOG_DEBUG(("TCP listener created"));\r
-\r
- return listener;\r
-\r
- err:\r
- if (l)\r
- delete l;\r
- if (callback)\r
- callback(SILC_NET_ERROR, NULL, context);\r
- if (listener)\r
- silc_net_close_listener(listener);\r
- return NULL;\r
-}\r
-\r
-/* Close network listener */\r
-\r
-void silc_net_close_listener(SilcNetListener listener)\r
-{\r
- int i;\r
-\r
- SILC_LOG_DEBUG(("Closing network listener"));\r
-\r
- for (i = 0; i < listener->socks_count; i++) {\r
- SilcSymbianTCPListener *l = (SilcSymbianTCPListener *)listener->socks[i];\r
- l->sock.CancelAll();\r
- l->sock.Close();\r
- l->ss.Close();\r
- if (l->new_conn)\r
- delete l->new_conn;\r
- delete l;\r
- }\r
-\r
- silc_free(listener->socks);\r
- silc_free(listener);\r
-}\r
-\r
-/**************************** TCP/IP connecting *****************************/\r
-\r
-static void silc_net_connect_stream(SilcSocketStreamStatus status,\r
- SilcStream stream, void *context);\r
-\r
-/* TCP connecting class */\r
-\r
-class SilcSymbianTCPConnect : public CActive {\r
-public:\r
- /* Constructor */\r
- SilcSymbianTCPConnect() : CActive(CActive::EPriorityStandard)\r
- {\r
- CActiveScheduler::Add(this);\r
- }\r
-\r
- /* Destructor */\r
- ~SilcSymbianTCPConnect()\r
- {\r
- silc_free(remote);\r
- if (op)\r
- silc_async_free(op);\r
- Cancel();\r
- }\r
-\r
- /* Connect to remote host */\r
- void Connect(TSockAddr &addr)\r
- {\r
- sock->Connect(addr, iStatus);\r
- SetActive();\r
- }\r
-\r
- /* Connection callback */\r
- void RunL()\r
- {\r
- if (iStatus != KErrNone) {\r
- if (callback)\r
- callback(SILC_NET_ERROR, NULL, context);\r
- sock->CancelConnect();\r
- delete sock;\r
- ss->Close();\r
- delete ss;\r
- delete this;\r
- }\r
-\r
- /* Create stream */\r
- if (callback) {\r
- silc_socket_tcp_stream_create(\r
- (SilcSocket)silc_create_symbian_socket(sock, ss),\r
- FALSE, FALSE, schedule, silc_net_connect_stream,\r
- (void *)this);\r
- } else {\r
- sock->Close();\r
- delete sock;\r
- ss->Close();\r
- delete ss;\r
- }\r
-\r
- delete this;\r
- }\r
-\r
- /* Cancel */\r
- void DoCancel()\r
- {\r
- sock->CancelConnect();\r
- ss->Close();\r
- delete ss;\r
- delete sock;\r
- delete this;\r
- }\r
-\r
- RSocket *sock;\r
- RSocketServ *ss;\r
- char *remote;\r
- char remote_ip[64];\r
- int port;\r
- SilcAsyncOperation op;\r
- SilcSchedule schedule;\r
- SilcNetCallback callback;\r
- void *context;\r
-};\r
-\r
-/* Stream creation callback */\r
-\r
-static void silc_net_connect_stream(SilcSocketStreamStatus status,\r
- SilcStream stream, void *context)\r
-{\r
- SilcSymbianTCPConnect *conn = (SilcSymbianTCPConnect *)context;\r
- SilcNetStatus net_status = SILC_NET_OK;\r
-\r
- if (status != SILC_SOCKET_OK) {\r
- /* In case of error, the socket has been destroyed already */\r
- if (status == SILC_SOCKET_UNKNOWN_IP)\r
- net_status = SILC_NET_UNKNOWN_IP;\r
- else if (status == SILC_SOCKET_UNKNOWN_HOST)\r
- net_status = SILC_NET_UNKNOWN_HOST;\r
- else\r
- net_status = SILC_NET_ERROR;\r
- }\r
-\r
- /* Set stream information */\r
- if (stream && conn->callback)\r
- silc_socket_stream_set_info(stream,\r
- !silc_net_is_ip(conn->remote) ? conn->remote :\r
- conn->remote_ip, conn->remote_ip, conn->port);\r
-\r
- /* Call connection callback */\r
- if (conn->callback)\r
- conn->callback(net_status, stream, conn->context);\r
- else if (stream)\r
- silc_stream_destroy(stream);\r
-\r
- delete conn;\r
-}\r
-\r
-/* Connecting abort callback */\r
-\r
-static void silc_net_connect_abort(SilcAsyncOperation op, void *context)\r
-{\r
- SilcSymbianTCPConnect *conn = (SilcSymbianTCPConnect *)context;\r
-\r
- /* Abort */\r
- conn->callback = NULL;\r
- conn->op = NULL;\r
- conn->DoCancel();\r
-}\r
-\r
-/* Create TCP/IP connection */\r
-\r
-SilcAsyncOperation silc_net_tcp_connect(const char *local_ip_addr,\r
- const char *remote_ip_addr,\r
- int remote_port,\r
- SilcSchedule schedule,\r
- SilcNetCallback callback,\r
- void *context)\r
-{\r
- SilcSymbianTCPConnect *conn;\r
- TInetAddr local, remote;\r
- SilcNetStatus status;\r
- TBuf<64> tmp;\r
- TInt ret;\r
-\r
- if (!remote_ip_addr || remote_port < 1 || !schedule || !callback)\r
- return NULL;\r
-\r
- SILC_LOG_DEBUG(("Creating connection to host %s port %d",\r
- remote_ip_addr, remote_port));\r
-\r
- conn = new SilcSymbianTCPConnect;\r
- if (!conn) {\r
- callback(SILC_NET_NO_MEMORY, NULL, context);\r
- return NULL;\r
- }\r
- conn->schedule = schedule;\r
- conn->callback = callback;\r
- conn->context = context;\r
- conn->port = remote_port;\r
- conn->remote = strdup(remote_ip_addr);\r
- if (!conn->remote) {\r
- status = SILC_NET_NO_MEMORY;\r
- goto err;\r
- }\r
-\r
- /* Allocate socket */\r
- conn->sock = new RSocket;\r
- if (!conn->sock) {\r
- status = SILC_NET_NO_MEMORY;\r
- goto err;\r
- }\r
-\r
- /* Allocate socket server */\r
- conn->ss = new RSocketServ;\r
- if (!conn->ss) {\r
- status = SILC_NET_NO_MEMORY;\r
- goto err;\r
- }\r
-\r
- /* Connect to socket server */\r
- ret = conn->ss->Connect();\r
- if (ret != KErrNone) {\r
- status = SILC_NET_ERROR;\r
- goto err;\r
- }\r
-\r
- /* Start async operation */\r
- conn->op = silc_async_alloc(silc_net_connect_abort, NULL, (void *)conn);\r
- if (!conn->op) {\r
- status = SILC_NET_NO_MEMORY;\r
- goto err;\r
- }\r
-\r
- /* Do host lookup */\r
- if (!silc_net_is_ip(remote_ip_addr)) {\r
- if (!silc_net_gethostbyname(remote_ip_addr, FALSE, conn->remote_ip,\r
- sizeof(conn->remote_ip))) {\r
- SILC_LOG_ERROR(("Network (%s) unreachable: could not resolve the "\r
- "host", conn->remote));\r
- status = SILC_NET_HOST_UNREACHABLE;\r
- goto err;\r
- }\r
- } else {\r
- strcpy(conn->remote_ip, remote_ip_addr);\r
- }\r
-\r
- /* Create the connection socket */\r
- ret = conn->sock->Open(*conn->ss, KAfInet, KSockStream, KProtocolInetTcp);\r
- if (ret != KErrNone) {\r
- SILC_LOG_ERROR(("Cannot create socket"));\r
- status = SILC_NET_ERROR;\r
- goto err;\r
- }\r
-\r
- /* Set appropriate options */\r
- conn->sock->SetOpt(KSoTcpNoDelay, KSolInetTcp, 1);\r
- conn->sock->SetOpt(KSoTcpKeepAlive, KSolInetTcp, 1);\r
-\r
- /* Bind to the local address if provided */\r
- if (local_ip_addr) {\r
- local = TInetAddr(0);\r
- tmp = (TText *)local_ip_addr;\r
- ret = local.Input(tmp);\r
- if (ret == KErrNone)\r
- ret = conn->sock->Bind(local);\r
- }\r
-\r
- /* Connect to the host */\r
- remote = TInetAddr(remote_port);\r
- tmp = (TText *)conn->remote_ip;\r
- ret = remote.Input(tmp);\r
- if (ret != KErrNone) {\r
- SILC_LOG_ERROR(("Cannot connect (cannot set address)"));\r
- status = SILC_NET_ERROR;\r
- goto err;\r
- }\r
- conn->Connect(remote);\r
-\r
- SILC_LOG_DEBUG(("Connection operation in progress"));\r
-\r
- return conn->op;\r
-\r
- err:\r
- if (conn->ss) {\r
- conn->ss->Close();\r
- delete conn->ss;\r
- }\r
- if (conn->sock)\r
- delete conn->sock;\r
- if (conn->remote)\r
- silc_free(conn->remote);\r
- if (conn->op)\r
- silc_async_free(conn->op);\r
- callback(status, NULL, context);\r
- delete conn;\r
- return NULL;\r
-}\r
-\r
-/****************************** UDP routines ********************************/\r
-\r
-/* Create UDP/IP connection */\r
-\r
-SilcStream silc_net_udp_connect(const char *local_ip_addr, int local_port,\r
- const char *remote_ip_addr, int remote_port,\r
- SilcSchedule schedule)\r
-{\r
- SilcSymbianSocket *s;\r
- SilcStream stream;\r
- TInetAddr local, remote;\r
- TRequestStatus status;\r
- RSocket *sock = NULL;\r
- RSocketServ *ss = NULL;\r
- TBuf<64> tmp;\r
- TInt ret;\r
-\r
- SILC_LOG_DEBUG(("Creating UDP stream"));\r
-\r
- if (!schedule)\r
- goto err;\r
-\r
- SILC_LOG_DEBUG(("Binding to local address %s",\r
- local_ip_addr ? local_ip_addr : "0.0.0.0"));\r
-\r
- sock = new RSocket;\r
- if (!sock)\r
- goto err;\r
-\r
- ss = new RSocketServ;\r
- if (!ss)\r
- goto err;\r
-\r
- /* Open socket server */\r
- ret = ss->Connect();\r
- if (ret != KErrNone)\r
- goto err;\r
-\r
- /* Get local bind address */\r
- if (local_ip_addr) {\r
- local = TInetAddr(local_port);\r
- tmp = (TText *)local_ip_addr;\r
- ret = local.Input(tmp);\r
- if (ret != KErrNone)\r
- goto err;\r
- } else {\r
- local = TInetAddr(KInetAddrAny, local_port);\r
- }\r
-\r
- /* Create the socket */\r
- ret = sock->Open(*ss, KAfInet, KSockDatagram, KProtocolInetUdp);\r
- if (ret != KErrNone) {\r
- SILC_LOG_ERROR(("Cannot create socket"));\r
- goto err;\r
- }\r
-\r
- /* Set the socket options */\r
- sock->SetOpt(KSoReuseAddr, KSolInetIp, 1);\r
-\r
- /* Bind the listener socket */\r
- ret = sock->Bind(local);\r
- if (ret != KErrNone) {\r
- SILC_LOG_DEBUG(("Cannot bind socket"));\r
- goto err;\r
- }\r
-\r
- /* Set to connected state if remote address is provided. */\r
- if (remote_ip_addr && remote_port) {\r
- remote = TInetAddr(remote_port);\r
- tmp = (TText *)remote_ip_addr;\r
- ret = remote.Input(tmp);\r
- if (ret != KErrNone)\r
- goto err;\r
-\r
- sock->Connect(remote, status);\r
- if (status != KErrNone) {\r
- SILC_LOG_DEBUG(("Cannot connect UDP stream"));\r
- goto err;\r
- }\r
- }\r
-\r
- /* Encapsulate into socket stream */\r
- s = silc_create_symbian_socket(sock, ss);\r
- if (!s)\r
- goto err;\r
- stream =\r
- silc_socket_udp_stream_create((SilcSocket)s, local_ip_addr ?\r
- silc_net_is_ip6(local_ip_addr) : FALSE,\r
- remote_ip_addr ? TRUE : FALSE, schedule);\r
- if (!stream)\r
- goto err;\r
-\r
- SILC_LOG_DEBUG(("UDP stream created, fd=%d", sock));\r
- return stream;\r
-\r
- err:\r
- if (sock)\r
- delete sock;\r
- if (ss) {\r
- ss->Close();\r
- delete ss;\r
- }\r
- return NULL;\r
-}\r
-\r
-/* Sets socket to non-blocking mode */\r
-\r
-int silc_net_set_socket_nonblock(SilcSocket sock)\r
-{\r
- /* Nothing to do in Symbian where blocking socket mode is asynchronous\r
- already (ie. non-blocking). */\r
- return 0;\r
-}\r
-\r
-/* Converts the IP number string from numbers-and-dots notation to\r
- binary form. */\r
-\r
-SilcBool silc_net_addr2bin(const char *addr, void *bin, SilcUInt32 bin_len)\r
-{\r
- int ret = 0;\r
-\r
- struct in_addr tmp;\r
- ret = inet_aton(addr, &tmp);\r
- if (bin_len < 4)\r
- return FALSE;\r
-\r
- memcpy(bin, (unsigned char *)&tmp.s_addr, 4);\r
-\r
- return ret != 0;\r
-}\r
-\r
-/* Get remote host and IP from socket */\r
-\r
-SilcBool silc_net_check_host_by_sock(SilcSocket sock, char **hostname,\r
- char **ip)\r
-{\r
- SilcSymbianSocket *s = (SilcSymbianSocket *)sock;\r
- TInetAddr addr;\r
- char host[256];\r
- TBuf<64> tmp;\r
-\r
- if (hostname)\r
- *hostname = NULL;\r
- *ip = NULL;\r
-\r
- s->sock->RemoteName(addr);\r
- addr.Output(tmp);\r
-\r
- *ip = (char *)silc_memdup(tmp.Ptr(), tmp.Length());\r
- if (*ip == NULL)\r
- return FALSE;\r
-\r
- /* Do reverse lookup if we want hostname too. */\r
- if (hostname) {\r
- /* Get host by address */\r
- if (!silc_net_gethostbyaddr(*ip, host, sizeof(host)))\r
- return FALSE;\r
-\r
- *hostname = (char *)silc_memdup(host, strlen(host));\r
- SILC_LOG_DEBUG(("Resolved hostname `%s'", *hostname));\r
-\r
- /* Reverse */\r
- if (!silc_net_gethostbyname(*hostname, TRUE, host, sizeof(host)))\r
- return FALSE;\r
-\r
- if (strcmp(*ip, host))\r
- return FALSE;\r
- }\r
-\r
- SILC_LOG_DEBUG(("Resolved IP address `%s'", *ip));\r
- return TRUE;\r
-}\r
-\r
-/* Get local host and IP from socket */\r
-\r
-SilcBool silc_net_check_local_by_sock(SilcSocket sock, char **hostname,\r
- char **ip)\r
-{\r
- SilcSymbianSocket *s = (SilcSymbianSocket *)sock;\r
- TInetAddr addr;\r
- char host[256];\r
- TBuf<64> tmp;\r
-\r
- if (hostname)\r
- *hostname = NULL;\r
- *ip = NULL;\r
-\r
- s->sock->LocalName(addr);\r
- addr.Output(tmp);\r
-\r
- *ip = (char *)silc_memdup(tmp.Ptr(), tmp.Length());\r
- if (*ip == NULL)\r
- return FALSE;\r
-\r
- /* Do reverse lookup if we want hostname too. */\r
- if (hostname) {\r
- /* Get host by address */\r
- if (!silc_net_gethostbyaddr(*ip, host, sizeof(host)))\r
- return FALSE;\r
-\r
- *hostname = (char *)silc_memdup(host, strlen(host));\r
- SILC_LOG_DEBUG(("Resolved hostname `%s'", *hostname));\r
-\r
- /* Reverse */\r
- if (!silc_net_gethostbyname(*hostname, TRUE, host, sizeof(host)))\r
- return FALSE;\r
-\r
- if (strcmp(*ip, host))\r
- return FALSE;\r
- }\r
-\r
- SILC_LOG_DEBUG(("Resolved IP address `%s'", *ip));\r
- return TRUE;\r
-}\r
-\r
-/* Get remote port from socket */\r
-\r
-SilcUInt16 silc_net_get_remote_port(SilcSocket sock)\r
-{\r
- SilcSymbianSocket *s = (SilcSymbianSocket *)sock;\r
- TInetAddr addr;\r
-\r
- s->sock->RemoteName(addr);\r
- return (SilcUInt16)addr.Port();\r
-}\r
-\r
-/* Get local port from socket */\r
-\r
-SilcUInt16 silc_net_get_local_port(SilcSocket sock)\r
-{\r
- SilcSymbianSocket *s = (SilcSymbianSocket *)sock;\r
- TInetAddr addr;\r
-\r
- s->sock->LocalName(addr);\r
- return (SilcUInt16)addr.Port();\r
-}\r
+/*
+
+ silcsymbiannet.cpp
+
+ Author: Pekka Riikonen <priikone@silcnet.org>
+
+ Copyright (C) 2006 - 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
+ the Free Software Foundation; version 2 of the License.
+
+ 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.
+
+*/
+
+#include "silc.h"
+#include "silcsymbiansocketstream.h"
+
+/****************************** TCP Listener ********************************/
+
+class SilcSymbianTCPListener;
+
+/* Deliver new stream to upper layer */
+
+static void silc_net_accept_stream(SilcSocketStreamStatus status,
+ SilcStream stream, void *context)
+{
+ SilcNetListener listener = (SilcNetListener)context;
+
+ /* In case of error, the socket has been destroyed already */
+ if (status != SILC_SOCKET_OK)
+ return;
+
+ listener->callback(SILC_NET_OK, stream, listener->context);
+}
+
+/* TCP Listener class */
+
+class SilcSymbianTCPListener : public CActive {
+public:
+ /* Constructor */
+ SilcSymbianTCPListener() : CActive(CActive::EPriorityStandard)
+ {
+ CActiveScheduler::Add(this);
+ }
+
+ /* Destructor */
+ ~SilcSymbianTCPListener()
+ {
+ Cancel();
+ }
+
+ /* Listen for connection */
+ void Listen()
+ {
+ new_conn = new RSocket;
+ if (!new_conn)
+ return;
+ if (new_conn->Open(ss) != KErrNone) {
+ Listen();
+ return;
+ }
+
+ /* Start listenning */
+ sock.Accept(*new_conn, iStatus);
+ SetActive();
+ }
+
+ /* Listener callback */
+ virtual void RunL()
+ {
+ if (iStatus != KErrNone) {
+ if (new_conn)
+ delete new_conn;
+ new_conn = NULL;
+ Listen();
+ return;
+ }
+
+ /* Set socket options */
+ new_conn->SetOpt(KSoReuseAddr, KSolInetIp, 1);
+
+ /* Create socket stream */
+ silc_socket_tcp_stream_create(
+ (SilcSocket)silc_create_symbian_socket(new_conn, NULL),
+ listener->lookup, listener->require_fqdn,
+ listener->schedule, silc_net_accept_stream,
+ (void *)listener);
+ new_conn = NULL;
+
+ /* Continue listenning */
+ Listen();
+ }
+
+ /* Cancel */
+ virtual void DoCancel()
+ {
+ sock.CancelAll();
+ ss.Close();
+ if (new_conn)
+ delete new_conn;
+ }
+
+ RSocket *new_conn;
+ RSocket sock;
+ RSocketServ ss;
+ SilcNetListener listener;
+};
+
+/* Create TCP listener */
+
+SilcNetListener
+silc_net_tcp_create_listener(const char **local_ip_addr,
+ SilcUInt32 local_ip_count, int port,
+ SilcBool lookup, SilcBool require_fqdn,
+ SilcSchedule schedule,
+ SilcNetCallback callback, void *context)
+{
+ SilcNetListener listener = NULL;
+ SilcSymbianTCPListener *l = NULL;
+ TInetAddr server;
+ TInt ret;
+ TBuf<64> tmp;
+ int i;
+
+ SILC_LOG_DEBUG(("Creating TCP listener"));
+
+ if (port < 0 || !schedule || !callback)
+ goto err;
+
+ listener = (SilcNetListener)silc_calloc(1, sizeof(*listener));
+ if (!listener) {
+ callback(SILC_NET_NO_MEMORY, NULL, context);
+ return NULL;
+ }
+ listener->schedule = schedule;
+ listener->callback = callback;
+ listener->context = context;
+ listener->require_fqdn = require_fqdn;
+ listener->lookup = lookup;
+
+ if (local_ip_count > 0) {
+ listener->socks = (SilcSocket *)silc_calloc(local_ip_count,
+ sizeof(*listener->socks));
+ if (!listener->socks) {
+ callback(SILC_NET_NO_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);
+ 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] : "0.0.0.0"));
+
+ l = new SilcSymbianTCPListener;
+ if (!l)
+ goto err;
+
+ /* Connect to socket server */
+ ret = l->ss.Connect();
+ if (ret != KErrNone)
+ goto err;
+
+ /* Set listener address */
+ if (local_ip_addr) {
+ server = TInetAddr(port);
+ tmp = (TText *)local_ip_addr[i];
+ ret = server.Input(tmp);
+ if (ret != KErrNone)
+ goto err;
+ } else {
+ server = TInetAddr(KInetAddrAny, port);
+ }
+
+ /* Create the socket */
+ ret = l->sock.Open(l->ss, KAfInet, KSockStream, KProtocolInetTcp);
+ if (ret != KErrNone) {
+ SILC_LOG_ERROR(("Cannot create socket"));
+ goto err;
+ }
+
+ /* Set the socket options */
+ ret = l->sock.SetOpt(KSoReuseAddr, KSolInetIp, 1);
+ if (ret != KErrNone) {
+ SILC_LOG_ERROR(("Cannot set socket options"));
+ goto err;
+ }
+
+ /* Bind the listener socket */
+ ret = l->sock.Bind(server);
+ if (ret != KErrNone) {
+ SILC_LOG_DEBUG(("Cannot bind socket"));
+ goto err;
+ }
+
+ /* Specify that we are listenning */
+ ret = l->sock.Listen(5);
+ if (ret != KErrNone) {
+ SILC_LOG_ERROR(("Cannot set socket listenning"));
+ goto err;
+ }
+ l->Listen();
+
+ l->listener = listener;
+ listener->socks[i] = (SilcSocket)l;
+ listener->socks_count++;
+ }
+
+ SILC_LOG_DEBUG(("TCP listener created"));
+
+ return listener;
+
+ err:
+ if (l)
+ delete l;
+ if (callback)
+ callback(SILC_NET_ERROR, NULL, context);
+ if (listener)
+ silc_net_close_listener(listener);
+ return NULL;
+}
+
+/* Close network listener */
+
+void silc_net_close_listener(SilcNetListener listener)
+{
+ int i;
+
+ SILC_LOG_DEBUG(("Closing network listener"));
+
+ for (i = 0; i < listener->socks_count; i++) {
+ SilcSymbianTCPListener *l = (SilcSymbianTCPListener *)listener->socks[i];
+ l->sock.CancelAll();
+ l->sock.Close();
+ l->ss.Close();
+ if (l->new_conn)
+ delete l->new_conn;
+ delete l;
+ }
+
+ silc_free(listener->socks);
+ silc_free(listener);
+}
+
+/**************************** TCP/IP connecting *****************************/
+
+static void silc_net_connect_stream(SilcSocketStreamStatus status,
+ SilcStream stream, void *context);
+
+/* TCP connecting class */
+
+class SilcSymbianTCPConnect : public CActive {
+public:
+ /* Constructor */
+ SilcSymbianTCPConnect() : CActive(CActive::EPriorityStandard)
+ {
+ CActiveScheduler::Add(this);
+ }
+
+ /* Destructor */
+ ~SilcSymbianTCPConnect()
+ {
+ silc_free(remote);
+ if (op)
+ silc_async_free(op);
+ Cancel();
+ }
+
+ /* Connect to remote host */
+ void Connect(TSockAddr &addr)
+ {
+ sock->Connect(addr, iStatus);
+ SetActive();
+ }
+
+ /* Connection callback */
+ virtual void RunL()
+ {
+ if (iStatus != KErrNone) {
+ if (callback)
+ callback(SILC_NET_ERROR, NULL, context);
+ sock->CancelConnect();
+ delete sock;
+ ss->Close();
+ delete ss;
+ sock = NULL;
+ ss = NULL;
+ delete this;
+ return;
+ }
+
+ /* Create stream */
+ if (callback) {
+ silc_socket_tcp_stream_create(
+ (SilcSocket)silc_create_symbian_socket(sock, ss),
+ FALSE, FALSE, schedule, silc_net_connect_stream,
+ (void *)this);
+ } else {
+ sock->Close();
+ delete sock;
+ ss->Close();
+ delete ss;
+ sock = NULL;
+ ss = NULL;
+ }
+
+ delete this;
+ }
+
+ /* Cancel */
+ virtual void DoCancel()
+ {
+ if (ss) {
+ ss->Close();
+ delete ss;
+ }
+ if (sock) {
+ sock->CancelConnect();
+ delete sock;
+ }
+ }
+
+ RSocket *sock;
+ RSocketServ *ss;
+ char *remote;
+ char remote_ip[64];
+ int port;
+ SilcAsyncOperation op;
+ SilcSchedule schedule;
+ SilcNetCallback callback;
+ void *context;
+};
+
+/* Stream creation callback */
+
+static void silc_net_connect_stream(SilcSocketStreamStatus status,
+ SilcStream stream, void *context)
+{
+ SilcSymbianTCPConnect *conn = (SilcSymbianTCPConnect *)context;
+ SilcNetStatus net_status = SILC_NET_OK;
+
+ if (status != SILC_SOCKET_OK) {
+ /* In case of error, the socket has been destroyed already */
+ 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;
+ }
+
+ /* Set stream information */
+ if (stream && conn->callback)
+ silc_socket_stream_set_info(stream,
+ !silc_net_is_ip(conn->remote) ? conn->remote :
+ conn->remote_ip, conn->remote_ip, conn->port);
+
+ /* Call connection callback */
+ if (conn->callback)
+ conn->callback(net_status, stream, conn->context);
+ else if (stream)
+ silc_stream_destroy(stream);
+
+ delete conn;
+}
+
+/* Connecting abort callback */
+
+static void silc_net_connect_abort(SilcAsyncOperation op, void *context)
+{
+ SilcSymbianTCPConnect *conn = (SilcSymbianTCPConnect *)context;
+
+ /* Abort */
+ conn->callback = NULL;
+ conn->op = NULL;
+ if (conn->sock)
+ sock->CancelConnect();
+}
+
+/* Create TCP/IP connection */
+
+SilcAsyncOperation silc_net_tcp_connect(const char *local_ip_addr,
+ const char *remote_ip_addr,
+ int remote_port,
+ SilcSchedule schedule,
+ SilcNetCallback callback,
+ void *context)
+{
+ SilcSymbianTCPConnect *conn;
+ TInetAddr local, remote;
+ SilcNetStatus status;
+ TBuf<64> tmp;
+ TInt ret;
+
+ if (!remote_ip_addr || remote_port < 1 || !schedule || !callback)
+ 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);
+ return NULL;
+ }
+ conn->schedule = schedule;
+ conn->callback = callback;
+ conn->context = context;
+ conn->port = remote_port;
+ conn->remote = strdup(remote_ip_addr);
+ if (!conn->remote) {
+ status = SILC_NET_NO_MEMORY;
+ goto err;
+ }
+
+ /* Allocate socket */
+ conn->sock = new RSocket;
+ if (!conn->sock) {
+ status = SILC_NET_NO_MEMORY;
+ goto err;
+ }
+
+ /* Allocate socket server */
+ conn->ss = new RSocketServ;
+ if (!conn->ss) {
+ status = SILC_NET_NO_MEMORY;
+ goto err;
+ }
+
+ /* Connect to socket server */
+ ret = conn->ss->Connect();
+ if (ret != KErrNone) {
+ status = SILC_NET_ERROR;
+ goto err;
+ }
+
+ /* Start async operation */
+ conn->op = silc_async_alloc(silc_net_connect_abort, NULL, (void *)conn);
+ if (!conn->op) {
+ status = SILC_NET_NO_MEMORY;
+ goto err;
+ }
+
+ /* Do host lookup */
+ if (!silc_net_is_ip(remote_ip_addr)) {
+ if (!silc_net_gethostbyname(remote_ip_addr, FALSE, conn->remote_ip,
+ sizeof(conn->remote_ip))) {
+ SILC_LOG_ERROR(("Network (%s) unreachable: could not resolve the "
+ "host", conn->remote));
+ status = SILC_NET_HOST_UNREACHABLE;
+ goto err;
+ }
+ } else {
+ strcpy(conn->remote_ip, remote_ip_addr);
+ }
+
+ /* Create the connection socket */
+ ret = conn->sock->Open(*conn->ss, KAfInet, KSockStream, KProtocolInetTcp);
+ if (ret != KErrNone) {
+ SILC_LOG_ERROR(("Cannot create socket"));
+ status = SILC_NET_ERROR;
+ goto err;
+ }
+
+ /* Set appropriate options */
+ conn->sock->SetOpt(KSoTcpNoDelay, KSolInetTcp, 1);
+ conn->sock->SetOpt(KSoTcpKeepAlive, KSolInetTcp, 1);
+
+ /* Bind to the local address if provided */
+ if (local_ip_addr) {
+ local = TInetAddr(0);
+ tmp = (TText *)local_ip_addr;
+ ret = local.Input(tmp);
+ if (ret == KErrNone)
+ ret = conn->sock->Bind(local);
+ }
+
+ /* Connect to the host */
+ remote = TInetAddr(remote_port);
+ tmp = (TText *)conn->remote_ip;
+ ret = remote.Input(tmp);
+ if (ret != KErrNone) {
+ SILC_LOG_ERROR(("Cannot connect (cannot set address)"));
+ status = SILC_NET_ERROR;
+ goto err;
+ }
+ conn->Connect(remote);
+
+ SILC_LOG_DEBUG(("Connection operation in progress"));
+
+ return conn->op;
+
+ err:
+ if (conn->ss) {
+ conn->ss->Close();
+ delete conn->ss;
+ }
+ if (conn->sock)
+ delete conn->sock;
+ if (conn->remote)
+ silc_free(conn->remote);
+ if (conn->op)
+ silc_async_free(conn->op);
+ callback(status, NULL, context);
+ delete conn;
+ return NULL;
+}
+
+/****************************** UDP routines ********************************/
+
+/* Create UDP/IP connection */
+
+SilcStream silc_net_udp_connect(const char *local_ip_addr, int local_port,
+ const char *remote_ip_addr, int remote_port,
+ SilcSchedule schedule)
+{
+ SilcSymbianSocket *s;
+ SilcStream stream;
+ TInetAddr local, remote;
+ TRequestStatus status;
+ RSocket *sock = NULL;
+ RSocketServ *ss = NULL;
+ TBuf<64> tmp;
+ TInt ret;
+
+ SILC_LOG_DEBUG(("Creating UDP stream"));
+
+ if (!schedule)
+ goto err;
+
+ SILC_LOG_DEBUG(("Binding to local address %s",
+ local_ip_addr ? local_ip_addr : "0.0.0.0"));
+
+ sock = new RSocket;
+ if (!sock)
+ goto err;
+
+ ss = new RSocketServ;
+ if (!ss)
+ goto err;
+
+ /* Open socket server */
+ ret = ss->Connect();
+ if (ret != KErrNone)
+ goto err;
+
+ /* Get local bind address */
+ if (local_ip_addr) {
+ local = TInetAddr(local_port);
+ tmp = (TText *)local_ip_addr;
+ ret = local.Input(tmp);
+ if (ret != KErrNone)
+ goto err;
+ } else {
+ local = TInetAddr(KInetAddrAny, local_port);
+ }
+
+ /* Create the socket */
+ ret = sock->Open(*ss, KAfInet, KSockDatagram, KProtocolInetUdp);
+ if (ret != KErrNone) {
+ SILC_LOG_ERROR(("Cannot create socket"));
+ goto err;
+ }
+
+ /* Set the socket options */
+ sock->SetOpt(KSoReuseAddr, KSolInetIp, 1);
+
+ /* Bind the listener socket */
+ ret = sock->Bind(local);
+ if (ret != KErrNone) {
+ SILC_LOG_DEBUG(("Cannot bind socket"));
+ goto err;
+ }
+
+ /* Set to connected state if remote address is provided. */
+ if (remote_ip_addr && remote_port) {
+ remote = TInetAddr(remote_port);
+ tmp = (TText *)remote_ip_addr;
+ ret = remote.Input(tmp);
+ if (ret != KErrNone)
+ goto err;
+
+ sock->Connect(remote, status);
+ if (status != KErrNone) {
+ SILC_LOG_DEBUG(("Cannot connect UDP stream"));
+ goto err;
+ }
+ }
+
+ /* Encapsulate into socket stream */
+ s = silc_create_symbian_socket(sock, ss);
+ if (!s)
+ goto err;
+ stream =
+ silc_socket_udp_stream_create((SilcSocket)s, local_ip_addr ?
+ silc_net_is_ip6(local_ip_addr) : FALSE,
+ remote_ip_addr ? TRUE : FALSE, schedule);
+ if (!stream)
+ goto err;
+
+ SILC_LOG_DEBUG(("UDP stream created, fd=%d", sock));
+ return stream;
+
+ err:
+ if (sock)
+ delete sock;
+ if (ss) {
+ ss->Close();
+ delete ss;
+ }
+ return NULL;
+}
+
+/* Sets socket to non-blocking mode */
+
+int silc_net_set_socket_nonblock(SilcSocket sock)
+{
+ /* Nothing to do in Symbian where blocking socket mode is asynchronous
+ already (ie. non-blocking). */
+ return 0;
+}
+
+/* Converts the IP number string from numbers-and-dots notation to
+ binary form. */
+
+SilcBool silc_net_addr2bin(const char *addr, void *bin, SilcUInt32 bin_len)
+{
+ int ret = 0;
+
+ struct in_addr tmp;
+ ret = inet_aton(addr, &tmp);
+ if (bin_len < 4)
+ return FALSE;
+
+ memcpy(bin, (unsigned char *)&tmp.s_addr, 4);
+
+ return ret != 0;
+}
+
+/* Get remote host and IP from socket */
+
+SilcBool silc_net_check_host_by_sock(SilcSocket sock, char **hostname,
+ char **ip)
+{
+ SilcSymbianSocket *s = (SilcSymbianSocket *)sock;
+ TInetAddr addr;
+ char host[256];
+ TBuf<64> tmp;
+
+ if (hostname)
+ *hostname = NULL;
+ *ip = NULL;
+
+ s->sock->RemoteName(addr);
+ addr.Output(tmp);
+
+ *ip = (char *)silc_memdup(tmp.Ptr(), tmp.Length());
+ if (*ip == NULL)
+ return FALSE;
+
+ /* Do reverse lookup if we want hostname too. */
+ if (hostname) {
+ /* Get host by address */
+ if (!silc_net_gethostbyaddr(*ip, host, sizeof(host)))
+ return FALSE;
+
+ *hostname = (char *)silc_memdup(host, strlen(host));
+ SILC_LOG_DEBUG(("Resolved hostname `%s'", *hostname));
+
+ /* Reverse */
+ if (!silc_net_gethostbyname(*hostname, TRUE, host, sizeof(host)))
+ return FALSE;
+
+ if (strcmp(*ip, host))
+ return FALSE;
+ }
+
+ SILC_LOG_DEBUG(("Resolved IP address `%s'", *ip));
+ return TRUE;
+}
+
+/* Get local host and IP from socket */
+
+SilcBool silc_net_check_local_by_sock(SilcSocket sock, char **hostname,
+ char **ip)
+{
+ SilcSymbianSocket *s = (SilcSymbianSocket *)sock;
+ TInetAddr addr;
+ char host[256];
+ TBuf<64> tmp;
+
+ if (hostname)
+ *hostname = NULL;
+ *ip = NULL;
+
+ s->sock->LocalName(addr);
+ addr.Output(tmp);
+
+ *ip = (char *)silc_memdup(tmp.Ptr(), tmp.Length());
+ if (*ip == NULL)
+ return FALSE;
+
+ /* Do reverse lookup if we want hostname too. */
+ if (hostname) {
+ /* Get host by address */
+ if (!silc_net_gethostbyaddr(*ip, host, sizeof(host)))
+ return FALSE;
+
+ *hostname = (char *)silc_memdup(host, strlen(host));
+ SILC_LOG_DEBUG(("Resolved hostname `%s'", *hostname));
+
+ /* Reverse */
+ if (!silc_net_gethostbyname(*hostname, TRUE, host, sizeof(host)))
+ return FALSE;
+
+ if (strcmp(*ip, host))
+ return FALSE;
+ }
+
+ SILC_LOG_DEBUG(("Resolved IP address `%s'", *ip));
+ return TRUE;
+}
+
+/* Get remote port from socket */
+
+SilcUInt16 silc_net_get_remote_port(SilcSocket sock)
+{
+ SilcSymbianSocket *s = (SilcSymbianSocket *)sock;
+ TInetAddr addr;
+
+ s->sock->RemoteName(addr);
+ return (SilcUInt16)addr.Port();
+}
+
+/* Get local port from socket */
+
+SilcUInt16 silc_net_get_local_port(SilcSocket sock)
+{
+ SilcSymbianSocket *s = (SilcSymbianSocket *)sock;
+ TInetAddr addr;
+
+ s->sock->LocalName(addr);
+ return (SilcUInt16)addr.Port();
+}
projects / silc.git / blobdiff