* #27232: jni: added pjproject checkout as regular git content
We will remove it once the next release of pjsip (with Android support)
comes out and is merged into SFLphone.
diff --git a/jni/pjproject-android/.svn/pristine/4e/4e6f1a43accab0c3308f63592db2a7ac45a0976d.svn-base b/jni/pjproject-android/.svn/pristine/4e/4e6f1a43accab0c3308f63592db2a7ac45a0976d.svn-base
new file mode 100644
index 0000000..09239b0
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/4e/4e6f1a43accab0c3308f63592db2a7ac45a0976d.svn-base
@@ -0,0 +1,1021 @@
+/* $Id$ */
+/*
+ * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
+ * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#include <pj/sock.h>
+#include <pj/addr_resolv.h>
+#include <pj/assert.h>
+#include <pj/errno.h>
+#include <pj/os.h>
+#include <pj/string.h>
+#include <pj/unicode.h>
+
+#include "os_symbian.h"
+
+
+/*
+ * Address families.
+ */
+const pj_uint16_t PJ_AF_UNSPEC = KAFUnspec;
+const pj_uint16_t PJ_AF_UNIX = 0xFFFF;
+const pj_uint16_t PJ_AF_INET = KAfInet;
+const pj_uint16_t PJ_AF_INET6 = KAfInet6;
+const pj_uint16_t PJ_AF_PACKET = 0xFFFF;
+const pj_uint16_t PJ_AF_IRDA = 0xFFFF;
+
+/*
+ * Socket types conversion.
+ * The values here are indexed based on pj_sock_type
+ */
+const pj_uint16_t PJ_SOCK_STREAM= KSockStream;
+const pj_uint16_t PJ_SOCK_DGRAM = KSockDatagram;
+const pj_uint16_t PJ_SOCK_RAW = 0xFFFF;
+const pj_uint16_t PJ_SOCK_RDM = 0xFFFF;
+
+/* we don't support setsockopt(), these are just dummy values */
+const pj_uint16_t PJ_SOL_SOCKET = 0xFFFF;
+const pj_uint16_t PJ_SOL_IP = 0xFFFF;
+const pj_uint16_t PJ_SOL_TCP = 0xFFFF;
+const pj_uint16_t PJ_SOL_UDP = 0xFFFF;
+const pj_uint16_t PJ_SOL_IPV6 = 0xFFFF;
+const pj_uint16_t PJ_SO_NOSIGPIPE = 0xFFFF;
+
+/* TOS */
+const pj_uint16_t PJ_IP_TOS = 0;
+const pj_uint16_t PJ_IPTOS_LOWDELAY = 0;
+const pj_uint16_t PJ_IPTOS_THROUGHPUT = 0;
+const pj_uint16_t PJ_IPTOS_RELIABILITY = 0;
+const pj_uint16_t PJ_IPTOS_MINCOST = 0;
+
+/* Misc */
+const pj_uint16_t PJ_TCP_NODELAY = 0xFFFF;
+const pj_uint16_t PJ_SO_REUSEADDR = 0xFFFF;
+const pj_uint16_t PJ_SO_PRIORITY = 0xFFFF;
+
+/* ioctl() is also not supported. */
+const pj_uint16_t PJ_SO_TYPE = 0xFFFF;
+const pj_uint16_t PJ_SO_RCVBUF = 0xFFFF;
+const pj_uint16_t PJ_SO_SNDBUF = 0xFFFF;
+
+/* IP multicast is also not supported. */
+const pj_uint16_t PJ_IP_MULTICAST_IF = 0xFFFF;
+const pj_uint16_t PJ_IP_MULTICAST_TTL = 0xFFFF;
+const pj_uint16_t PJ_IP_MULTICAST_LOOP = 0xFFFF;
+const pj_uint16_t PJ_IP_ADD_MEMBERSHIP = 0xFFFF;
+const pj_uint16_t PJ_IP_DROP_MEMBERSHIP = 0xFFFF;
+
+/* Flags */
+const int PJ_MSG_OOB = 0;
+const int PJ_MSG_PEEK = KSockReadPeek;
+const int PJ_MSG_DONTROUTE = 0;
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// CPjSocket implementation.
+// (declaration is in os_symbian.h)
+//
+
+CPjSocket::~CPjSocket()
+{
+ DestroyReader();
+ sock_.Close();
+}
+
+
+// Create socket reader.
+CPjSocketReader *CPjSocket::CreateReader(unsigned max_len)
+{
+ pj_assert(sockReader_ == NULL);
+ return sockReader_ = CPjSocketReader::NewL(*this, max_len);
+}
+
+// Delete socket reader when it's not wanted.
+void CPjSocket::DestroyReader()
+{
+ if (sockReader_) {
+ sockReader_->Cancel();
+ delete sockReader_;
+ sockReader_ = NULL;
+ }
+}
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// CPjSocketReader implementation
+// (declaration in os_symbian.h)
+//
+
+
+CPjSocketReader::CPjSocketReader(CPjSocket &sock)
+: CActive(EPriorityStandard),
+ sock_(sock), buffer_(NULL, 0), readCb_(NULL), key_(NULL)
+{
+}
+
+
+void CPjSocketReader::ConstructL(unsigned max_len)
+{
+ isDatagram_ = sock_.IsDatagram();
+
+ TUint8 *ptr = new TUint8[max_len];
+ buffer_.Set(ptr, 0, (TInt)max_len);
+ CActiveScheduler::Add(this);
+}
+
+CPjSocketReader *CPjSocketReader::NewL(CPjSocket &sock, unsigned max_len)
+{
+ CPjSocketReader *self = new (ELeave) CPjSocketReader(sock);
+ CleanupStack::PushL(self);
+ self->ConstructL(max_len);
+ CleanupStack::Pop(self);
+
+ return self;
+}
+
+
+CPjSocketReader::~CPjSocketReader()
+{
+ const TUint8 *data = buffer_.Ptr();
+ delete [] data;
+}
+
+void CPjSocketReader::StartRecv(void (*cb)(void *key),
+ void *key,
+ TDes8 *aDesc,
+ TUint flags)
+{
+ StartRecvFrom(cb, key, aDesc, flags, NULL);
+}
+
+void CPjSocketReader::StartRecvFrom(void (*cb)(void *key),
+ void *key,
+ TDes8 *aDesc,
+ TUint flags,
+ TSockAddr *fromAddr)
+{
+ readCb_ = cb;
+ key_ = key;
+
+ if (aDesc == NULL) aDesc = &buffer_;
+ if (fromAddr == NULL) fromAddr = &recvAddr_;
+
+ sock_.Socket().RecvFrom(*aDesc, *fromAddr, flags, iStatus);
+ SetActive();
+}
+
+void CPjSocketReader::DoCancel()
+{
+ sock_.Socket().CancelRecv();
+}
+
+void CPjSocketReader::RunL()
+{
+ void (*old_cb)(void *key) = readCb_;
+ void *old_key = key_;
+
+ readCb_ = NULL;
+ key_ = NULL;
+
+ if (old_cb) {
+ (*old_cb)(old_key);
+ }
+}
+
+// Append data to aDesc, up to aDesc's maximum size.
+// If socket is datagram based, buffer_ will be clared.
+void CPjSocketReader::ReadData(TDes8 &aDesc, TInetAddr *addr)
+{
+ if (isDatagram_)
+ aDesc.Zero();
+
+ if (buffer_.Length() == 0)
+ return;
+
+ TInt size_to_copy = aDesc.MaxLength() - aDesc.Length();
+ if (size_to_copy > buffer_.Length())
+ size_to_copy = buffer_.Length();
+
+ aDesc.Append(buffer_.Ptr(), size_to_copy);
+
+ if (isDatagram_)
+ buffer_.Zero();
+ else
+ buffer_.Delete(0, size_to_copy);
+
+ if (addr)
+ *addr = recvAddr_;
+}
+
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// PJLIB's sock.h implementation
+//
+
+/*
+ * Convert 16-bit value from network byte order to host byte order.
+ */
+PJ_DEF(pj_uint16_t) pj_ntohs(pj_uint16_t netshort)
+{
+#if PJ_IS_LITTLE_ENDIAN
+ return pj_swap16(netshort);
+#else
+ return netshort;
+#endif
+}
+
+/*
+ * Convert 16-bit value from host byte order to network byte order.
+ */
+PJ_DEF(pj_uint16_t) pj_htons(pj_uint16_t hostshort)
+{
+#if PJ_IS_LITTLE_ENDIAN
+ return pj_swap16(hostshort);
+#else
+ return hostshort;
+#endif
+}
+
+/*
+ * Convert 32-bit value from network byte order to host byte order.
+ */
+PJ_DEF(pj_uint32_t) pj_ntohl(pj_uint32_t netlong)
+{
+#if PJ_IS_LITTLE_ENDIAN
+ return pj_swap32(netlong);
+#else
+ return netlong;
+#endif
+}
+
+/*
+ * Convert 32-bit value from host byte order to network byte order.
+ */
+PJ_DEF(pj_uint32_t) pj_htonl(pj_uint32_t hostlong)
+{
+#if PJ_IS_LITTLE_ENDIAN
+ return pj_swap32(hostlong);
+#else
+ return netlong;
+#endif
+}
+
+/*
+ * Convert an Internet host address given in network byte order
+ * to string in standard numbers and dots notation.
+ */
+PJ_DEF(char*) pj_inet_ntoa(pj_in_addr inaddr)
+{
+ static char str8[PJ_INET_ADDRSTRLEN];
+ TBuf<PJ_INET_ADDRSTRLEN> str16(0);
+
+ /* (Symbian IP address is in host byte order) */
+ TInetAddr temp_addr((TUint32)pj_ntohl(inaddr.s_addr), (TUint)0);
+ temp_addr.Output(str16);
+
+ return pj_unicode_to_ansi((const wchar_t*)str16.PtrZ(), str16.Length(),
+ str8, sizeof(str8));
+}
+
+/*
+ * This function converts the Internet host address cp from the standard
+ * numbers-and-dots notation into binary data and stores it in the structure
+ * that inp points to.
+ */
+PJ_DEF(int) pj_inet_aton(const pj_str_t *cp, struct pj_in_addr *inp)
+{
+ enum { MAXIPLEN = PJ_INET_ADDRSTRLEN };
+
+ /* Initialize output with PJ_INADDR_NONE.
+ * Some apps relies on this instead of the return value
+ * (and anyway the return value is quite confusing!)
+ */
+ inp->s_addr = PJ_INADDR_NONE;
+
+ /* Caution:
+ * this function might be called with cp->slen >= 16
+ * (i.e. when called with hostname to check if it's an IP addr).
+ */
+ PJ_ASSERT_RETURN(cp && cp->slen && inp, 0);
+ if (cp->slen >= 16) {
+ return 0;
+ }
+
+ char tempaddr8[MAXIPLEN];
+ pj_memcpy(tempaddr8, cp->ptr, cp->slen);
+ tempaddr8[cp->slen] = '\0';
+
+ wchar_t tempaddr16[MAXIPLEN];
+ pj_ansi_to_unicode(tempaddr8, pj_ansi_strlen(tempaddr8),
+ tempaddr16, sizeof(tempaddr16));
+
+ TBuf<MAXIPLEN> ip_addr((const TText*)tempaddr16);
+
+ TInetAddr addr;
+ addr.Init(KAfInet);
+ if (addr.Input(ip_addr) == KErrNone) {
+ /* Success (Symbian IP address is in host byte order) */
+ inp->s_addr = pj_htonl(addr.Address());
+ return 1;
+ } else {
+ /* Error */
+ return 0;
+ }
+}
+
+/*
+ * Convert text to IPv4/IPv6 address.
+ */
+PJ_DEF(pj_status_t) pj_inet_pton(int af, const pj_str_t *src, void *dst)
+{
+ char tempaddr[PJ_INET6_ADDRSTRLEN];
+
+ PJ_ASSERT_RETURN(af==PJ_AF_INET || af==PJ_AF_INET6, PJ_EINVAL);
+ PJ_ASSERT_RETURN(src && src->slen && dst, PJ_EINVAL);
+
+ /* Initialize output with PJ_IN_ADDR_NONE for IPv4 (to be
+ * compatible with pj_inet_aton()
+ */
+ if (af==PJ_AF_INET) {
+ ((pj_in_addr*)dst)->s_addr = PJ_INADDR_NONE;
+ }
+
+ /* Caution:
+ * this function might be called with cp->slen >= 46
+ * (i.e. when called with hostname to check if it's an IP addr).
+ */
+ if (src->slen >= PJ_INET6_ADDRSTRLEN) {
+ return PJ_ENAMETOOLONG;
+ }
+
+ pj_memcpy(tempaddr, src->ptr, src->slen);
+ tempaddr[src->slen] = '\0';
+
+
+ wchar_t tempaddr16[PJ_INET6_ADDRSTRLEN];
+ pj_ansi_to_unicode(tempaddr, pj_ansi_strlen(tempaddr),
+ tempaddr16, sizeof(tempaddr16));
+
+ TBuf<PJ_INET6_ADDRSTRLEN> ip_addr((const TText*)tempaddr16);
+
+ TInetAddr addr;
+ addr.Init(KAfInet6);
+ if (addr.Input(ip_addr) == KErrNone) {
+ if (af==PJ_AF_INET) {
+ /* Success (Symbian IP address is in host byte order) */
+ pj_uint32_t ip = pj_htonl(addr.Address());
+ pj_memcpy(dst, &ip, 4);
+ } else if (af==PJ_AF_INET6) {
+ const TIp6Addr & ip6 = addr.Ip6Address();
+ pj_memcpy(dst, ip6.u.iAddr8, 16);
+ } else {
+ pj_assert(!"Unexpected!");
+ return PJ_EBUG;
+ }
+ return PJ_SUCCESS;
+ } else {
+ /* Error */
+ return PJ_EINVAL;
+ }
+}
+
+/*
+ * Convert IPv4/IPv6 address to text.
+ */
+PJ_DEF(pj_status_t) pj_inet_ntop(int af, const void *src,
+ char *dst, int size)
+
+{
+ PJ_ASSERT_RETURN(src && dst && size, PJ_EINVAL);
+
+ *dst = '\0';
+
+ if (af==PJ_AF_INET) {
+
+ TBuf<PJ_INET_ADDRSTRLEN> str16;
+ pj_in_addr inaddr;
+
+ if (size < PJ_INET_ADDRSTRLEN)
+ return PJ_ETOOSMALL;
+
+ pj_memcpy(&inaddr, src, 4);
+
+ /* Symbian IP address is in host byte order */
+ TInetAddr temp_addr((TUint32)pj_ntohl(inaddr.s_addr), (TUint)0);
+ temp_addr.Output(str16);
+
+ pj_unicode_to_ansi((const wchar_t*)str16.PtrZ(), str16.Length(),
+ dst, size);
+ return PJ_SUCCESS;
+
+ } else if (af==PJ_AF_INET6) {
+ TBuf<PJ_INET6_ADDRSTRLEN> str16;
+
+ if (size < PJ_INET6_ADDRSTRLEN)
+ return PJ_ETOOSMALL;
+
+ TIp6Addr ip6;
+ pj_memcpy(ip6.u.iAddr8, src, 16);
+
+ TInetAddr temp_addr(ip6, (TUint)0);
+ temp_addr.Output(str16);
+
+ pj_unicode_to_ansi((const wchar_t*)str16.PtrZ(), str16.Length(),
+ dst, size);
+ return PJ_SUCCESS;
+
+ } else {
+ pj_assert(!"Unsupport address family");
+ return PJ_EINVAL;
+ }
+
+}
+
+/*
+ * Get hostname.
+ */
+PJ_DEF(const pj_str_t*) pj_gethostname(void)
+{
+ static char buf[PJ_MAX_HOSTNAME];
+ static pj_str_t hostname;
+
+ PJ_CHECK_STACK();
+
+ if (hostname.ptr == NULL) {
+ RHostResolver &resv = PjSymbianOS::Instance()->GetResolver(PJ_AF_INET);
+ TRequestStatus reqStatus;
+ THostName tmpName;
+
+ // Return empty hostname if access point is marked as down by app.
+ PJ_SYMBIAN_CHECK_CONNECTION2(&hostname);
+
+ resv.GetHostName(tmpName, reqStatus);
+ User::WaitForRequest(reqStatus);
+
+ hostname.ptr = pj_unicode_to_ansi((const wchar_t*)tmpName.Ptr(), tmpName.Length(),
+ buf, sizeof(buf));
+ hostname.slen = tmpName.Length();
+ }
+ return &hostname;
+}
+
+/*
+ * Create new socket/endpoint for communication and returns a descriptor.
+ */
+PJ_DEF(pj_status_t) pj_sock_socket(int af,
+ int type,
+ int proto,
+ pj_sock_t *p_sock)
+{
+ TInt rc;
+
+ PJ_CHECK_STACK();
+
+ /* Sanity checks. */
+ PJ_ASSERT_RETURN(p_sock!=NULL, PJ_EINVAL);
+
+ // Return failure if access point is marked as down by app.
+ PJ_SYMBIAN_CHECK_CONNECTION();
+
+ /* Set proto if none is specified. */
+ if (proto == 0) {
+ if (type == pj_SOCK_STREAM())
+ proto = KProtocolInetTcp;
+ else if (type == pj_SOCK_DGRAM())
+ proto = KProtocolInetUdp;
+ }
+
+ /* Create Symbian RSocket */
+ RSocket rSock;
+ if (PjSymbianOS::Instance()->Connection())
+ rc = rSock.Open(PjSymbianOS::Instance()->SocketServ(),
+ af, type, proto,
+ *PjSymbianOS::Instance()->Connection());
+ else
+ rc = rSock.Open(PjSymbianOS::Instance()->SocketServ(),
+ af, type, proto);
+
+ if (rc != KErrNone)
+ return PJ_RETURN_OS_ERROR(rc);
+
+
+ /* Wrap Symbian RSocket into PJLIB's CPjSocket, and return to caller */
+ CPjSocket *pjSock = new CPjSocket(af, type, rSock);
+ *p_sock = (pj_sock_t)pjSock;
+
+ return PJ_SUCCESS;
+}
+
+
+/*
+ * Bind socket.
+ */
+PJ_DEF(pj_status_t) pj_sock_bind( pj_sock_t sock,
+ const pj_sockaddr_t *addr,
+ int len)
+{
+ pj_status_t status;
+ TInt rc;
+
+ PJ_CHECK_STACK();
+
+ PJ_ASSERT_RETURN(sock != 0, PJ_EINVAL);
+ PJ_ASSERT_RETURN(addr && len>=(int)sizeof(pj_sockaddr_in), PJ_EINVAL);
+
+ // Convert PJLIB's pj_sockaddr into Symbian's TInetAddr
+ TInetAddr inetAddr;
+ status = PjSymbianOS::pj2Addr(*(pj_sockaddr*)addr, len, inetAddr);
+ if (status != PJ_SUCCESS)
+ return status;
+
+ // Get the RSocket instance
+ RSocket &rSock = ((CPjSocket*)sock)->Socket();
+
+ // Bind
+ rc = rSock.Bind(inetAddr);
+
+ return (rc==KErrNone) ? PJ_SUCCESS : PJ_RETURN_OS_ERROR(rc);
+}
+
+
+/*
+ * Bind socket.
+ */
+PJ_DEF(pj_status_t) pj_sock_bind_in( pj_sock_t sock,
+ pj_uint32_t addr32,
+ pj_uint16_t port)
+{
+ pj_sockaddr_in addr;
+
+ PJ_CHECK_STACK();
+
+ pj_bzero(&addr, sizeof(addr));
+ addr.sin_family = PJ_AF_INET;
+ addr.sin_addr.s_addr = pj_htonl(addr32);
+ addr.sin_port = pj_htons(port);
+
+ return pj_sock_bind(sock, &addr, sizeof(pj_sockaddr_in));
+}
+
+
+/*
+ * Close socket.
+ */
+PJ_DEF(pj_status_t) pj_sock_close(pj_sock_t sock)
+{
+ PJ_CHECK_STACK();
+
+ PJ_ASSERT_RETURN(sock != 0, PJ_EINVAL);
+
+ CPjSocket *pjSock = (CPjSocket*)sock;
+
+ // This will close the socket.
+ delete pjSock;
+
+ return PJ_SUCCESS;
+}
+
+/*
+ * Get remote's name.
+ */
+PJ_DEF(pj_status_t) pj_sock_getpeername( pj_sock_t sock,
+ pj_sockaddr_t *addr,
+ int *namelen)
+{
+ PJ_CHECK_STACK();
+
+ PJ_ASSERT_RETURN(sock && addr && namelen &&
+ *namelen>=(int)sizeof(pj_sockaddr_in), PJ_EINVAL);
+
+ CPjSocket *pjSock = (CPjSocket*)sock;
+ RSocket &rSock = pjSock->Socket();
+
+ // Socket must be connected.
+ PJ_ASSERT_RETURN(pjSock->IsConnected(), PJ_EINVALIDOP);
+
+ TInetAddr inetAddr;
+ rSock.RemoteName(inetAddr);
+
+ return PjSymbianOS::Addr2pj(inetAddr, *(pj_sockaddr*)addr, namelen);
+}
+
+/*
+ * Get socket name.
+ */
+PJ_DEF(pj_status_t) pj_sock_getsockname( pj_sock_t sock,
+ pj_sockaddr_t *addr,
+ int *namelen)
+{
+ PJ_CHECK_STACK();
+
+ PJ_ASSERT_RETURN(sock && addr && namelen &&
+ *namelen>=(int)sizeof(pj_sockaddr_in), PJ_EINVAL);
+
+ CPjSocket *pjSock = (CPjSocket*)sock;
+ RSocket &rSock = pjSock->Socket();
+
+ TInetAddr inetAddr;
+ rSock.LocalName(inetAddr);
+
+ return PjSymbianOS::Addr2pj(inetAddr, *(pj_sockaddr*)addr, namelen);
+}
+
+/*
+ * Send data
+ */
+PJ_DEF(pj_status_t) pj_sock_send(pj_sock_t sock,
+ const void *buf,
+ pj_ssize_t *len,
+ unsigned flags)
+{
+ PJ_CHECK_STACK();
+ PJ_ASSERT_RETURN(sock && buf && len, PJ_EINVAL);
+
+ // Return failure if access point is marked as down by app.
+ PJ_SYMBIAN_CHECK_CONNECTION();
+
+ CPjSocket *pjSock = (CPjSocket*)sock;
+ RSocket &rSock = pjSock->Socket();
+
+ // send() should only be called to connected socket
+ PJ_ASSERT_RETURN(pjSock->IsConnected(), PJ_EINVALIDOP);
+
+ TPtrC8 data((const TUint8*)buf, (TInt)*len);
+ TRequestStatus reqStatus;
+ TSockXfrLength sentLen;
+
+ rSock.Send(data, flags, reqStatus, sentLen);
+ User::WaitForRequest(reqStatus);
+
+ if (reqStatus.Int()==KErrNone) {
+ //*len = (TInt) sentLen.Length();
+ return PJ_SUCCESS;
+ } else
+ return PJ_RETURN_OS_ERROR(reqStatus.Int());
+}
+
+
+/*
+ * Send data.
+ */
+PJ_DEF(pj_status_t) pj_sock_sendto(pj_sock_t sock,
+ const void *buf,
+ pj_ssize_t *len,
+ unsigned flags,
+ const pj_sockaddr_t *to,
+ int tolen)
+{
+ pj_status_t status;
+
+ PJ_CHECK_STACK();
+ PJ_ASSERT_RETURN(sock && buf && len, PJ_EINVAL);
+
+ // Return failure if access point is marked as down by app.
+ PJ_SYMBIAN_CHECK_CONNECTION();
+
+ CPjSocket *pjSock = (CPjSocket*)sock;
+ RSocket &rSock = pjSock->Socket();
+
+ // Only supports AF_INET for now
+ PJ_ASSERT_RETURN(tolen>=(int)sizeof(pj_sockaddr_in), PJ_EINVAL);
+
+ TInetAddr inetAddr;
+ status = PjSymbianOS::pj2Addr(*(pj_sockaddr*)to, tolen, inetAddr);
+ if (status != PJ_SUCCESS)
+ return status;
+
+ TPtrC8 data((const TUint8*)buf, (TInt)*len);
+ TRequestStatus reqStatus;
+ TSockXfrLength sentLen;
+
+ rSock.SendTo(data, inetAddr, flags, reqStatus, sentLen);
+ User::WaitForRequest(reqStatus);
+
+ if (reqStatus.Int()==KErrNone) {
+ //For some reason TSockXfrLength is not returning correctly!
+ //*len = (TInt) sentLen.Length();
+ return PJ_SUCCESS;
+ } else
+ return PJ_RETURN_OS_ERROR(reqStatus.Int());
+}
+
+/*
+ * Receive data.
+ */
+PJ_DEF(pj_status_t) pj_sock_recv(pj_sock_t sock,
+ void *buf,
+ pj_ssize_t *len,
+ unsigned flags)
+{
+ PJ_CHECK_STACK();
+
+ PJ_ASSERT_RETURN(sock && buf && len, PJ_EINVAL);
+ PJ_ASSERT_RETURN(*len > 0, PJ_EINVAL);
+
+ // Return failure if access point is marked as down by app.
+ PJ_SYMBIAN_CHECK_CONNECTION();
+
+ CPjSocket *pjSock = (CPjSocket*)sock;
+
+ if (pjSock->Reader()) {
+ CPjSocketReader *reader = pjSock->Reader();
+
+ while (reader->IsActive() && !reader->HasData()) {
+ User::WaitForAnyRequest();
+ }
+
+ if (reader->HasData()) {
+ TPtr8 data((TUint8*)buf, (TInt)*len);
+ TInetAddr inetAddr;
+
+ reader->ReadData(data, &inetAddr);
+
+ *len = data.Length();
+ return PJ_SUCCESS;
+ }
+ }
+
+ TRequestStatus reqStatus;
+ TSockXfrLength recvLen;
+ TPtr8 data((TUint8*)buf, (TInt)*len, (TInt)*len);
+
+ if (pjSock->IsDatagram()) {
+ pjSock->Socket().Recv(data, flags, reqStatus);
+ } else {
+ // Using static like this is not pretty, but we don't need to use
+ // the value anyway, hence doing it like this is probably most
+ // optimal.
+ static TSockXfrLength len;
+ pjSock->Socket().RecvOneOrMore(data, flags, reqStatus, len);
+ }
+ User::WaitForRequest(reqStatus);
+
+ if (reqStatus == KErrNone) {
+ //*len = (TInt)recvLen.Length();
+ *len = data.Length();
+ return PJ_SUCCESS;
+ } else {
+ *len = -1;
+ return PJ_RETURN_OS_ERROR(reqStatus.Int());
+ }
+}
+
+/*
+ * Receive data.
+ */
+PJ_DEF(pj_status_t) pj_sock_recvfrom(pj_sock_t sock,
+ void *buf,
+ pj_ssize_t *len,
+ unsigned flags,
+ pj_sockaddr_t *from,
+ int *fromlen)
+{
+ PJ_CHECK_STACK();
+
+ PJ_ASSERT_RETURN(sock && buf && len && from && fromlen, PJ_EINVAL);
+ PJ_ASSERT_RETURN(*len > 0, PJ_EINVAL);
+ PJ_ASSERT_RETURN(*fromlen >= (int)sizeof(pj_sockaddr_in), PJ_EINVAL);
+
+ // Return failure if access point is marked as down by app.
+ PJ_SYMBIAN_CHECK_CONNECTION();
+
+ CPjSocket *pjSock = (CPjSocket*)sock;
+ RSocket &rSock = pjSock->Socket();
+
+ if (pjSock->Reader()) {
+ CPjSocketReader *reader = pjSock->Reader();
+
+ while (reader->IsActive() && !reader->HasData()) {
+ User::WaitForAnyRequest();
+ }
+
+ if (reader->HasData()) {
+ TPtr8 data((TUint8*)buf, (TInt)*len);
+ TInetAddr inetAddr;
+
+ reader->ReadData(data, &inetAddr);
+
+ *len = data.Length();
+
+ if (from && fromlen) {
+ return PjSymbianOS::Addr2pj(inetAddr, *(pj_sockaddr*)from,
+ fromlen);
+ } else {
+ return PJ_SUCCESS;
+ }
+ }
+ }
+
+ TInetAddr inetAddr;
+ TRequestStatus reqStatus;
+ TSockXfrLength recvLen;
+ TPtr8 data((TUint8*)buf, (TInt)*len, (TInt)*len);
+
+ rSock.RecvFrom(data, inetAddr, flags, reqStatus, recvLen);
+ User::WaitForRequest(reqStatus);
+
+ if (reqStatus == KErrNone) {
+ //*len = (TInt)recvLen.Length();
+ *len = data.Length();
+ return PjSymbianOS::Addr2pj(inetAddr, *(pj_sockaddr*)from, fromlen);
+ } else {
+ *len = -1;
+ *fromlen = -1;
+ return PJ_RETURN_OS_ERROR(reqStatus.Int());
+ }
+}
+
+/*
+ * Get socket option.
+ */
+PJ_DEF(pj_status_t) pj_sock_getsockopt( pj_sock_t sock,
+ pj_uint16_t level,
+ pj_uint16_t optname,
+ void *optval,
+ int *optlen)
+{
+ // Not supported for now.
+ PJ_UNUSED_ARG(sock);
+ PJ_UNUSED_ARG(level);
+ PJ_UNUSED_ARG(optname);
+ PJ_UNUSED_ARG(optval);
+ PJ_UNUSED_ARG(optlen);
+ return PJ_EINVALIDOP;
+}
+
+/*
+ * Set socket option.
+ */
+PJ_DEF(pj_status_t) pj_sock_setsockopt( pj_sock_t sock,
+ pj_uint16_t level,
+ pj_uint16_t optname,
+ const void *optval,
+ int optlen)
+{
+ // Not supported for now.
+ PJ_UNUSED_ARG(sock);
+ PJ_UNUSED_ARG(level);
+ PJ_UNUSED_ARG(optname);
+ PJ_UNUSED_ARG(optval);
+ PJ_UNUSED_ARG(optlen);
+ return PJ_EINVALIDOP;
+}
+
+/*
+ * Connect socket.
+ */
+PJ_DEF(pj_status_t) pj_sock_connect( pj_sock_t sock,
+ const pj_sockaddr_t *addr,
+ int namelen)
+{
+ pj_status_t status;
+
+ PJ_CHECK_STACK();
+
+ PJ_ASSERT_RETURN(sock && addr && namelen, PJ_EINVAL);
+ PJ_ASSERT_RETURN(((pj_sockaddr*)addr)->addr.sa_family == PJ_AF_INET,
+ PJ_EINVAL);
+
+ // Return failure if access point is marked as down by app.
+ PJ_SYMBIAN_CHECK_CONNECTION();
+
+ CPjSocket *pjSock = (CPjSocket*)sock;
+ RSocket &rSock = pjSock->Socket();
+
+ TInetAddr inetAddr;
+ TRequestStatus reqStatus;
+
+ status = PjSymbianOS::pj2Addr(*(pj_sockaddr*)addr, namelen, inetAddr);
+ if (status != PJ_SUCCESS)
+ return status;
+
+ rSock.Connect(inetAddr, reqStatus);
+ User::WaitForRequest(reqStatus);
+
+ if (reqStatus == KErrNone) {
+ pjSock->SetConnected(true);
+ return PJ_SUCCESS;
+ } else {
+ return PJ_RETURN_OS_ERROR(reqStatus.Int());
+ }
+}
+
+
+/*
+ * Shutdown socket.
+ */
+#if PJ_HAS_TCP
+PJ_DEF(pj_status_t) pj_sock_shutdown( pj_sock_t sock,
+ int how)
+{
+ PJ_CHECK_STACK();
+
+ PJ_ASSERT_RETURN(sock, PJ_EINVAL);
+
+ CPjSocket *pjSock = (CPjSocket*)sock;
+ RSocket &rSock = pjSock->Socket();
+
+ RSocket::TShutdown aHow;
+ if (how == PJ_SD_RECEIVE)
+ aHow = RSocket::EStopInput;
+ else if (how == PJ_SHUT_WR)
+ aHow = RSocket::EStopOutput;
+ else
+ aHow = RSocket::ENormal;
+
+ TRequestStatus reqStatus;
+
+ rSock.Shutdown(aHow, reqStatus);
+ User::WaitForRequest(reqStatus);
+
+ if (reqStatus == KErrNone) {
+ return PJ_SUCCESS;
+ } else {
+ return PJ_RETURN_OS_ERROR(reqStatus.Int());
+ }
+}
+
+/*
+ * Start listening to incoming connections.
+ */
+PJ_DEF(pj_status_t) pj_sock_listen( pj_sock_t sock,
+ int backlog)
+{
+ PJ_CHECK_STACK();
+
+ PJ_ASSERT_RETURN(sock && backlog, PJ_EINVAL);
+
+ CPjSocket *pjSock = (CPjSocket*)sock;
+ RSocket &rSock = pjSock->Socket();
+
+ TInt rc = rSock.Listen((TUint)backlog);
+
+ if (rc == KErrNone) {
+ return PJ_SUCCESS;
+ } else {
+ return PJ_RETURN_OS_ERROR(rc);
+ }
+}
+
+/*
+ * Accept incoming connections
+ */
+PJ_DEF(pj_status_t) pj_sock_accept( pj_sock_t serverfd,
+ pj_sock_t *newsock,
+ pj_sockaddr_t *addr,
+ int *addrlen)
+{
+ PJ_CHECK_STACK();
+
+ PJ_ASSERT_RETURN(serverfd && newsock, PJ_EINVAL);
+
+ CPjSocket *pjSock = (CPjSocket*)serverfd;
+ RSocket &rSock = pjSock->Socket();
+
+ // Create a 'blank' socket
+ RSocket newSock;
+ newSock.Open(PjSymbianOS::Instance()->SocketServ());
+
+ // Call Accept()
+ TRequestStatus reqStatus;
+
+ rSock.Accept(newSock, reqStatus);
+ User::WaitForRequest(reqStatus);
+
+ if (reqStatus != KErrNone) {
+ return PJ_RETURN_OS_ERROR(reqStatus.Int());
+ }
+
+ // Create PJ socket
+ CPjSocket *newPjSock = new CPjSocket(pjSock->GetAf(), pjSock->GetSockType(),
+ newSock);
+ newPjSock->SetConnected(true);
+
+ *newsock = (pj_sock_t) newPjSock;
+
+ if (addr && addrlen) {
+ return pj_sock_getpeername(*newsock, addr, addrlen);
+ }
+
+ return PJ_SUCCESS;
+}
+#endif /* PJ_HAS_TCP */
+
+