1 /*

     2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Contains JNI calls made by ServerSocketConnectionImpl

    15 *

    16 */

    17 

    18 

    19 #include "com_nokia_mj_impl_socket_ServerSocketConnectionImpl.h"

    20 #include "socketserverconnectionfactory.h"

    21 #include "socketserverconnection.h"

    22 #include "javacommonutils.h"

    23 #include "logger.h"

    24 #include <stdio.h>

    25 #include <errno.h>

    26 #include <fcntl.h>

    27 #include <unistd.h>

    28 #include <sys/stat.h>

    29 #include <sys/types.h>

    30 #include <stdlib.h>

    31 #include <sys/socket.h>

    32 #include <netinet/in.h>

    33 #include <netdb.h>

    34 #include <unistd.h>

    35 #include <arpa/inet.h>

    36 #include <string.h>

    37 #include <wchar.h>

    38 #include <dirent.h>

    39 

    40 #ifdef __SYMBIAN32__

    41 #include <e32def.h>

    42 #include <e32cmn.h>

    43 #endif // __SYMBIAN32__

    44 

    45 #ifndef __SYMBIAN32__

    46 #include <netinet/tcp.h>

    47 #endif

    48 

    49 #include "pushexception.h"

    50 #include "pusherrorcodes.h"

    51 #include "socketlocalhostinfo.h"

    52 using namespace java::util;

    53 using namespace java;

    54 

    55 JNIEXPORT jint JNICALL

    56 Java_com_nokia_mj_impl_socket_ServerSocketConnectionImpl__1createSocketServerNativePeer

    57 (JNIEnv *aJni, jobject /*peer*/, jstring aUrl, jint /*aMode*/, jint /*aPort*/, jintArray aFactoryHandle)

    58 {

    59     JELOG2(ESOCKET);

    60     LOG(ESOCKET, EInfo, "+SocketServerConnectionJNI::createSocketServerNativePeer");

    61     const char* name = (aJni)->GetStringUTFChars(aUrl, 0);

    62 

    63     SocketServerConnectionFactory * scf = NULL;

    64     SocketServerConnection *iSocketServerPtr;

    65     std::wstring Url = JavaCommonUtils::utf8ToWstring((const char *)name);

    66     //NativeSocketServerConnection* nativeConn = new NativeSocketServerConnection(name, aMode, aPort);

    67     try

    68     {

    69         scf = &SocketServerConnectionFactory::getFactory();

    70         LOG(ESOCKET, EInfo, "-SocketServerConnectionJNI - getfactory created");

    71         iSocketServerPtr = reinterpret_cast<SocketServerConnection*>(scf->create(Url));

    72     }

    73     catch (PushException& ex)

    74     {

    75         ELOG(ESOCKET,"ERROR!!! CreateConnection() PushException was caught");

    76         int handle = reinterpret_cast<jint>(scf);

    77         aJni->SetIntArrayRegion(aFactoryHandle,0,1,&handle);

    78         if (scf != NULL)

    79         {

    80             // scf->releaseConnection(Url);

    81             scf = NULL;

    82             iSocketServerPtr = NULL;

    83         }

    84         (aJni)->ReleaseStringUTFChars(aUrl, name);

    85         return 0;

    86     }

    87     LOG(ESOCKET, EInfo, "-SocketServerConnectionJNI::createSocketServerNativePeer");

    88     int handle = reinterpret_cast<jint>(scf);

    89     aJni->SetIntArrayRegion(aFactoryHandle,0,1,&handle);

    90     (aJni)->ReleaseStringUTFChars(aUrl, name);

    91 

    92     return reinterpret_cast<jint>(iSocketServerPtr);

    93 }

    94 

    95 JNIEXPORT jint JNICALL

    96 Java_com_nokia_mj_impl_socket_ServerSocketConnectionImpl__1openServerSocket

    97 (JNIEnv *aJni, jobject /*peer*/, jint nativePeerHandle, jint /*aSocketServerFactoryHandle*/, jstring aUrl)

    98 {

    99     LOG(ESOCKET, EInfo, "+SocketServerConnectionJNI::openServerSocket");

   100     SocketServerConnection * iSocketServerPtr = reinterpret_cast<SocketServerConnection* >(nativePeerHandle);

   101     int retVal = -1;

   102     try

   103     {

   104         if (iSocketServerPtr != NULL)

   105         {

   106             int mSD = iSocketServerPtr->open();

   107 

   108             if (mSD < 0)

   109             {

   110                 return -1;

   111             }

   112             retVal = mSD;

   113         }

   114     }

   115     catch (PushException& ex)

   116     {

   117         ELOG(ESOCKET,"ERROR!!! CreateConnection() PushException was caught");

   118         SocketServerConnectionFactory * SocketServerFactoryPtr = reinterpret_cast<SocketServerConnectionFactory* >(nativePeerHandle);

   119         const char* name = (aJni)->GetStringUTFChars(aUrl, 0);

   120         std::wstring Url = JavaCommonUtils::utf8ToWstring((const char *)name);

   121         if (SocketServerFactoryPtr != NULL)

   122         {

   123             //SocketServerFactoryPtr->releaseConnection(Url);

   124             SocketServerFactoryPtr = NULL;

   125             iSocketServerPtr = NULL;

   126         }

   127         (aJni)->ReleaseStringUTFChars(aUrl, name);

   128         if (PUSH_CONNECTION_ALREADY_EXISTS == ex.mErrCode)

   129         {

   130             LOG1(ESOCKET,EInfo,"PushConnection already Exists : %d",ex.mErrCode);

   131             retVal = ex.mErrCode;

   132         }

   133         if (COMMON_SRV_CONN_PLUGIN_ERROR == ex.mErrCode)

   134         {

   135             LOG1(ESOCKET,EInfo,"Common pushConnection error : %d",ex.mErrCode);

   136             retVal = ex.mErrCode;

   137         }

   138         else

   139         {

   140             retVal = -1;

   141         }

   142     }

   143     return retVal;

   144 }

   145 

   146 JNIEXPORT jint JNICALL

   147 Java_com_nokia_mj_impl_socket_ServerSocketConnectionImpl__1getLocalAddress

   148 (JNIEnv *aJni, jobject /*peer*/, jint /*nativePeerHandle*/, jint aSockDesc, jint aMidletIapId, jint aApType, jobjectArray address)

   149 {

   150     JELOG2(ESOCKET);

   151     char *addr = new char[50];

   152     int err = SocketLocalHostInfo::getLocalAddress(aSockDesc,addr,aMidletIapId,aApType);

   153     PLOG2(ESOCKET, "getLocalAddress, ret = %d, addr = %s" , err, addr);

   154     jstring jnistring = aJni->NewStringUTF(addr);

   155     aJni->SetObjectArrayElement(address, 0, jnistring);

   156     return err;

   157 }

   158 

   159 JNIEXPORT jint JNICALL

   160 Java_com_nokia_mj_impl_socket_ServerSocketConnectionImpl__1getLocalPort

   161 (JNIEnv* /*aJni*/, jobject /*peer*/, jint /*nativePeerHandle*/, jint aSockDesc)

   162 {

   163     JELOG2(ESOCKET);

   164     //NativeSocketServerConnection* nativeConn    =  reinterpret_cast<NativeSocketServerConnection* > (nativePeerHandle);

   165 

   166     //return nativeConn->getLocalPort();

   167 

   168     struct sockaddr_in addr;

   169     socklen_t len = sizeof(addr);

   170 

   171     if (getsockname(aSockDesc, (struct sockaddr*)&addr, &len) == -1)

   172     {

   173         LOG1(ESOCKET, EInfo, "SocketServerConnectionJNI::getLocalPort() : getlocalport failed : %d", errno);

   174         return -errno;

   175     }

   176 

   177     return ntohs(addr.sin_port);

   178 }

   179 

   180 JNIEXPORT jint JNICALL

   181 Java_com_nokia_mj_impl_socket_ServerSocketConnectionImpl__1accept

   182 (JNIEnv* /*aJni*/, jobject /*peer*/, jint nativePeerHandle)

   183 {

   184     JELOG2(ESOCKET);

   185     LOG(ESOCKET, EInfo, "+SocketServerConnectionJNI::_accept");

   186     //NativeSocketServerConnection* nativeConn = reinterpret_cast<NativeSocketServerConnection* > (nativePeerHandle);

   187     //return nativeConn->accept();

   188     SocketServerConnection * iSocketServerPtr = reinterpret_cast<SocketServerConnection* >(nativePeerHandle);

   189     LOG(ESOCKET, EInfo, "-SocketServerConnectionJNI::_accept");

   190     if (iSocketServerPtr != NULL)

   191     {

   192         return iSocketServerPtr->accept();

   193     }

   194     return -1;

   195 }

   196 

   197 JNIEXPORT jint JNICALL

   198 Java_com_nokia_mj_impl_socket_ServerSocketConnectionImpl__1close

   199 (JNIEnv *aJni, jobject /*peer*/, jint nativePeerHandle, jint aSocketServerFactoryHandle, jstring aUrl, jint aSockDesc)

   200 {

   201     JELOG2(ESOCKET);

   202     LOG(ESOCKET, EInfo, "+SocketServerConnectionJNI::_close");

   203 

   204     const char* name = (aJni)->GetStringUTFChars(aUrl, 0);

   205     std::wstring Url = JavaCommonUtils::utf8ToWstring((const char *)name);

   206     SocketServerConnectionFactory * SocketServerFactoryPtr = reinterpret_cast<SocketServerConnectionFactory* >(aSocketServerFactoryHandle);

   207     if (SocketServerFactoryPtr != NULL)

   208     {

   209         if (Url.length() != 10) // not dynamic url case

   210         {

   211             SocketServerFactoryPtr->releaseConnection(Url);

   212             SocketServerFactoryPtr = NULL;

   213         }

   214         else  // dynamic url case, dont release socket://: url

   215         {

   216             SocketServerConnection * iSocketServerPtr = reinterpret_cast<SocketServerConnection* >(nativePeerHandle);

   217             if (iSocketServerPtr != NULL)

   218             {

   219                 if (iSocketServerPtr->isNormalServerConnection() == true)

   220                 {

   221                     iSocketServerPtr->close(aSockDesc); // just close the socket in case of normal connection

   222                 }

   223                 else // in case the dynamic url is registered for push, then release the connection

   224                 {

   225                     SocketServerFactoryPtr->releaseConnection(Url);

   226                     SocketServerFactoryPtr = NULL;

   227                     iSocketServerPtr = NULL;

   228                 }

   229             }

   230         }

   231 

   232     }

   233     (aJni)->ReleaseStringUTFChars(aUrl, name);

   234     return 0;

   235 }