-/*\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();
+}
-/*\r
-\r
- silcsymbianthread.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 <e32std.h>\r
-\r
-/**************************** SILC Thread API *******************************/\r
-\r
-/* Thread structure for Symbian */\r
-typedef struct {\r
-#ifdef SILC_THREADS\r
- RThread *thread;\r
- SilcThreadStart start_func;\r
- void *context;\r
- bool waitable;\r
-#else\r
- void *tmp;\r
-#endif\r
-} *SilcSymbianThread;\r
-\r
-/* The actual thread function */\r
-\r
-TInt silc_thread_epoc_start(TAny *context)\r
-{\r
-#ifdef SILC_THREADS\r
- SilcSymbianThread thread = (SilcSymbianThread)context;\r
- void *ret;\r
-\r
- ret = thread->start_func(thread->context);\r
- silc_thread_exit(ret);\r
-\r
-#endif\r
- return 0;\r
-}\r
-\r
-SilcThread silc_thread_create(SilcThreadStart start_func, void *context,\r
- bool waitable)\r
-{\r
-#ifdef SILC_THREADS\r
- SilcSymbianThread thread;\r
- TInt ret;\r
- TBuf<32> name;\r
-\r
- SILC_LOG_DEBUG(("Creating new thread"));\r
-\r
- thread = (SilcSymbianThread)silc_calloc(1, sizeof(*thread));\r
- if (!thread)\r
- return NULL;\r
- thread->start_func = start_func;\r
- thread->context = context;\r
- thread->waitable = waitable;\r
-\r
- /* Create the thread */\r
- /* XXX Unique name should be given for the thread */\r
- thread->thread = new RThread();\r
- if (!thread->thread) {\r
- silc_free(thread);\r
- return NULL;\r
- }\r
-\r
- name = (TText *)"silc" + time(NULL);\r
- ret = thread->thread->Create(name, silc_thread_epoc_start,\r
- 8192, 4096, 1024 * 1024, (TAny *)thread);\r
- if (ret != KErrNone) {\r
- SILC_LOG_ERROR(("Could not create new thread"));\r
- delete thread->thread;\r
- silc_free(thread);\r
- return NULL;\r
- }\r
- thread->thread->Resume();\r
-\r
- return (SilcThread)thread;\r
-#else\r
- /* Call thread callback immediately */\r
- (*start_func)(context);\r
- return NULL;\r
-#endif\r
-}\r
-\r
-void silc_thread_exit(void *exit_value)\r
-{\r
-#ifdef SILC_THREADS\r
- /* XXX */\r
-#endif\r
-}\r
-\r
-SilcThread silc_thread_self(void)\r
-{\r
-#ifdef SILC_THREADS\r
- /* XXX */\r
- return NULL;\r
-#else\r
- return NULL;\r
-#endif\r
-}\r
-\r
-SilcBool silc_thread_wait(SilcThread thread, void **exit_value)\r
-{\r
-#ifdef SILC_THREADS\r
- /* XXX */\r
- return TRUE;\r
-#else\r
- return FALSE;\r
-#endif\r
-}\r
-\r
-/***************************** SILC Mutex API *******************************/\r
-\r
-/* SILC Mutex structure */\r
-struct SilcMutexStruct {\r
-#ifdef SILC_THREADS\r
- RMutex *mutex;\r
-#endif /* SILC_THREADS */\r
- unsigned int locked : 1;\r
-};\r
-\r
-SilcBool silc_mutex_alloc(SilcMutex *mutex)\r
-{\r
-#ifdef SILC_THREADS\r
- *mutex = (SilcMutex)silc_calloc(1, sizeof(**mutex));\r
- if (*mutex == NULL)\r
- return FALSE;\r
- (*mutex)->mutex = new RMutex();\r
- if (!(*mutex)->mutex) {\r
- silc_free(*mutex);\r
- return FALSE;\r
- }\r
- if ((*mutex)->mutex->CreateLocal() != KErrNone) {\r
- delete (*mutex)->mutex;\r
- silc_free(*mutex);\r
- return FALSE;\r
- }\r
- (*mutex)->locked = FALSE;\r
- return TRUE;\r
-#else\r
- return FALSE;\r
-#endif /* SILC_THREADS */\r
-}\r
-\r
-void silc_mutex_free(SilcMutex mutex)\r
-{\r
-#ifdef SILC_THREADS\r
- if (mutex) {\r
- mutex->mutex->Close();\r
- delete mutex->mutex;\r
- silc_free(mutex);\r
- }\r
-#endif /* SILC_THREADS */\r
-}\r
-\r
-void silc_mutex_lock(SilcMutex mutex)\r
-{\r
-#ifdef SILC_THREADS\r
- if (mutex) {\r
- mutex->mutex->Wait();\r
- mutex->locked = TRUE;\r
- }\r
-#endif /* SILC_THREADS */\r
-}\r
-\r
-void silc_mutex_unlock(SilcMutex mutex)\r
-{\r
-#ifdef SILC_THREADS\r
- if (mutex) {\r
- mutex->mutex->Signal();\r
- mutex->locked = FALSE;\r
- }\r
-#endif /* SILC_THREADS */\r
-}\r
-\r
-void silc_mutex_assert_locked(SilcMutex mutex)\r
-{\r
-#ifdef SILC_THREADS\r
- if (mutex)\r
- SILC_ASSERT(mutex->locked);\r
-#endif /* SILC_THREADS */\r
-}\r
-\r
-\r
-/****************************** SILC Cond API *******************************/\r
-\r
-/* SILC Conditional Variable context */\r
-struct SilcCondStruct {\r
-#ifdef SILC_THREADS\r
- RCondVar *cond;\r
-#else\r
- void *tmp;\r
-#endif /* SILC_THREADS*/\r
-};\r
-\r
-SilcBool silc_cond_alloc(SilcCond *cond)\r
-{\r
-#ifdef SILC_THREADS\r
- *cond = (SilcCond)silc_calloc(1, sizeof(**cond));\r
- if (*cond == NULL)\r
- return FALSE;\r
- (*cond)->cond = new RCondVar();\r
- if (!(*cond)->cond) {\r
- silc_free(*cond);\r
- return FALSE;\r
- }\r
- if ((*cond)->cond->CreateLocal() != KErrNone) {\r
- delete (*cond)->cond;\r
- silc_free(*cond);\r
- return FALSE;\r
- }\r
- return TRUE;\r
-#else\r
- return FALSE;\r
-#endif /* SILC_THREADS*/\r
-}\r
-\r
-void silc_cond_free(SilcCond cond)\r
-{\r
-#ifdef SILC_THREADS\r
- cond->cond->Close();\r
- delete cond->cond;\r
- silc_free(cond);\r
-#endif /* SILC_THREADS*/\r
-}\r
-\r
-void silc_cond_signal(SilcCond cond)\r
-{\r
-#ifdef SILC_THREADS\r
- cond->cond->Signal();\r
-#endif /* SILC_THREADS*/\r
-}\r
-\r
-void silc_cond_broadcast(SilcCond cond)\r
-{\r
-#ifdef SILC_THREADS\r
- cond->cond->Broadcast();\r
-#endif /* SILC_THREADS*/\r
-}\r
-\r
-void silc_cond_wait(SilcCond cond, SilcMutex mutex)\r
-{\r
-#ifdef SILC_THREADS\r
- cond->cond->Wait(*mutex->mutex);\r
-#endif /* SILC_THREADS*/\r
-}\r
-\r
-SilcBool silc_cond_timedwait(SilcCond cond, SilcMutex mutex,\r
- int timeout)\r
-{\r
-#ifdef SILC_THREADS\r
- if (timeout)\r
- return (cond->cond->TimedWait(*mutex->mutex, (TInt)timeout * 1000) ==\r
- KErrNone);\r
- return (cond->cond->Wait(*mutex->mutex) == KErrNone);\r
-#else\r
- return FALSE;\r
-#endif /* SILC_THREADS*/\r
-}\r
+/*
+
+ silcsymbianthread.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 <e32std.h>
+
+/**************************** SILC Thread API *******************************/
+
+/* Thread structure for Symbian */
+typedef struct {
+#ifdef SILC_THREADS
+ SilcThreadStart start_func;
+ void *context;
+ SilcBool waitable;
+#else
+ void *tmp;
+#endif
+} *SilcSymbianThread;
+
+/* The actual thread function */
+
+static TInt silc_thread_start(TAny *context)
+{
+#ifdef SILC_THREADS
+ SilcSymbianThread tc = (SilcSymbianThread)context;
+ SilcThreadStart start_func = tc->start_func;
+ void *context = tc->context;
+ SilcBool waitable = tc->waitable;
+
+ silc_free(tc);
+
+ /* Call the thread function */
+ if (waitable)
+ silc_thread_exit(start_func(context));
+ else
+ start_func(context);
+
+#endif
+ return KErrNone;
+}
+
+/* Executed new thread */
+
+SilcThread silc_thread_create(SilcThreadStart start_func, void *context,
+ bool waitable)
+{
+#ifdef SILC_THREADS
+ SilcSymbianThread tc;
+ RThread *thread;
+ TInt ret;
+ TBuf<32> name;
+
+ SILC_LOG_DEBUG(("Creating new thread"));
+
+ tc = (SilcSymbianThread)silc_calloc(1, sizeof(*thread));
+ if (!tc)
+ return NULL;
+ tc->start_func = start_func;
+ tc->context = context;
+ tc->waitable = waitable;
+
+ /* Allocate thread */
+ thread = new RThread();
+ if (!thread) {
+ silc_free(tc);
+ return NULL;
+ }
+
+ /* Create the thread */
+ name = (TText *)silc_time_string(0);
+ ret = thread->Create(name, silc_thread_start, 8192, 4096, 1024 * 1024,
+ (TAny *)tc);
+ if (ret != KErrNone) {
+ SILC_LOG_ERROR(("Could not create new thread"));
+ delete thread;
+ silc_free(tc);
+ return NULL;
+ }
+
+ /* Start the thread */
+ thread->Resume();
+
+ /* Close our instance to the thread */
+ thread->Close();
+
+ return (SilcThread)thread;
+#else
+ /* Call thread callback immediately */
+ (*start_func)(context);
+ return NULL;
+#endif
+}
+
+/* Exits current thread */
+
+void silc_thread_exit(void *exit_value)
+{
+#ifdef SILC_THREADS
+ RThread().Kill((Tint)exit_value);
+#endif
+}
+
+/* Returns current thread context */
+
+SilcThread silc_thread_self(void)
+{
+#ifdef SILC_THREADS
+ return (SilcThread)&RThread();
+#else
+ return NULL;
+#endif
+}
+
+/* Blocks calling thread to wait for `thread' to finish. */
+
+SilcBool silc_thread_wait(SilcThread thread, void **exit_value)
+{
+#ifdef SILC_THREADS
+ TRequestStatus req;
+ RThread *t = (RThread *)thread;
+ t->Logon(req);
+ User::WaitForAnyRequest();
+ return TRUE;
+#else
+ return FALSE;
+#endif
+}
+
+/***************************** SILC Mutex API *******************************/
+
+/* SILC Mutex structure */
+struct SilcMutexStruct {
+#ifdef SILC_THREADS
+ RMutex *mutex;
+#endif /* SILC_THREADS */
+ unsigned int locked : 1;
+};
+
+SilcBool silc_mutex_alloc(SilcMutex *mutex)
+{
+#ifdef SILC_THREADS
+ *mutex = (SilcMutex)silc_calloc(1, sizeof(**mutex));
+ if (*mutex == NULL)
+ return FALSE;
+ (*mutex)->mutex = new RMutex();
+ if (!(*mutex)->mutex) {
+ silc_free(*mutex);
+ return FALSE;
+ }
+ if ((*mutex)->mutex->CreateLocal() != KErrNone) {
+ delete (*mutex)->mutex;
+ silc_free(*mutex);
+ return FALSE;
+ }
+ (*mutex)->locked = FALSE;
+ return TRUE;
+#else
+ return FALSE;
+#endif /* SILC_THREADS */
+}
+
+void silc_mutex_free(SilcMutex mutex)
+{
+#ifdef SILC_THREADS
+ if (mutex) {
+ mutex->mutex->Close();
+ delete mutex->mutex;
+ silc_free(mutex);
+ }
+#endif /* SILC_THREADS */
+}
+
+void silc_mutex_lock(SilcMutex mutex)
+{
+#ifdef SILC_THREADS
+ if (mutex) {
+ mutex->mutex->Wait();
+ mutex->locked = TRUE;
+ }
+#endif /* SILC_THREADS */
+}
+
+void silc_mutex_unlock(SilcMutex mutex)
+{
+#ifdef SILC_THREADS
+ if (mutex) {
+ mutex->mutex->Signal();
+ mutex->locked = FALSE;
+ }
+#endif /* SILC_THREADS */
+}
+
+void silc_mutex_assert_locked(SilcMutex mutex)
+{
+#ifdef SILC_THREADS
+ if (mutex)
+ SILC_ASSERT(mutex->locked);
+#endif /* SILC_THREADS */
+}
+
+
+/****************************** SILC Cond API *******************************/
+
+/* SILC Conditional Variable context */
+struct SilcCondStruct {
+#ifdef SILC_THREADS
+ RCondVar *cond;
+#else
+ void *tmp;
+#endif /* SILC_THREADS*/
+};
+
+SilcBool silc_cond_alloc(SilcCond *cond)
+{
+#ifdef SILC_THREADS
+ *cond = (SilcCond)silc_calloc(1, sizeof(**cond));
+ if (*cond == NULL)
+ return FALSE;
+ (*cond)->cond = new RCondVar();
+ if (!(*cond)->cond) {
+ silc_free(*cond);
+ return FALSE;
+ }
+ if ((*cond)->cond->CreateLocal() != KErrNone) {
+ delete (*cond)->cond;
+ silc_free(*cond);
+ return FALSE;
+ }
+ return TRUE;
+#else
+ return FALSE;
+#endif /* SILC_THREADS*/
+}
+
+void silc_cond_free(SilcCond cond)
+{
+#ifdef SILC_THREADS
+ cond->cond->Close();
+ delete cond->cond;
+ silc_free(cond);
+#endif /* SILC_THREADS*/
+}
+
+void silc_cond_signal(SilcCond cond)
+{
+#ifdef SILC_THREADS
+ cond->cond->Signal();
+#endif /* SILC_THREADS*/
+}
+
+void silc_cond_broadcast(SilcCond cond)
+{
+#ifdef SILC_THREADS
+ cond->cond->Broadcast();
+#endif /* SILC_THREADS*/
+}
+
+void silc_cond_wait(SilcCond cond, SilcMutex mutex)
+{
+#ifdef SILC_THREADS
+ cond->cond->Wait(*mutex->mutex);
+#endif /* SILC_THREADS*/
+}
+
+SilcBool silc_cond_timedwait(SilcCond cond, SilcMutex mutex,
+ int timeout)
+{
+#ifdef SILC_THREADS
+ if (timeout)
+ return (cond->cond->TimedWait(*mutex->mutex, (TInt)timeout * 1000) ==
+ KErrNone);
+ return (cond->cond->Wait(*mutex->mutex) == KErrNone);
+#else
+ return FALSE;
+#endif /* SILC_THREADS*/
+}