--- /dev/null
+/*\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
projects / silc.git / blobdiff