1 /*

     2  * Copyright (C) 2009 The Sipdroid Open Source Project

     3  * Copyright (C) 2007 The Android Open Source Project

     4  * 

     5  * This file is part of Sipdroid (http://www.sipdroid.org)

     6  * 

     7  * Sipdroid is free software; you can redistribute it and/or modify

     8  * it under the terms of the GNU General Public License as published by

     9  * the Free Software Foundation; either version 3 of the License, or

    10  * (at your option) any later version.

    11  * 

    12  * This source code is distributed in the hope that it will be useful,

    13  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15  * GNU General Public License for more details.

    16  * 

    17  * You should have received a copy of the GNU General Public License

    18  * along with this source code; if not, write to the Free Software

    19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    20  */

    21 

    22 #define LOG_TAG "OSNetworkSystem"

    23 

    24 #include <android/log.h>

    25 #include "jni.h"

    26 #include "errno.h"

    27 

    28 #include <unistd.h>

    29 #include <stdio.h>

    30 #include <sys/socket.h>

    31 #include <netinet/in.h>

    32 #include <netinet/tcp.h>

    33 #include <netdb.h>

    34 #include <sys/time.h>

    35 #include <stdlib.h>

    36 #include <sys/ioctl.h>

    37 #include <sys/un.h>

    38 

    39 //#include <cutils/properties.h>

    40 //#include <cutils/adb_networking.h>

    41 //#include <utils/LogSocket.h>

    42 //#include "AndroidSystemNatives.h"

    43 

    44 /**

    45  * @name Socket Errors

    46  * Error codes for socket operations

    47  *

    48  * @internal SOCKERR* range from -200 to -299 avoid overlap

    49  */

    50 #define SOCKERR_BADSOCKET          -200 /* generic error */

    51 #define SOCKERR_NOTINITIALIZED     -201 /* socket library uninitialized */

    52 #define SOCKERR_BADAF              -202 /* bad address family */

    53 #define SOCKERR_BADPROTO           -203 /* bad protocol */

    54 #define SOCKERR_BADTYPE            -204 /* bad type */

    55 #define SOCKERR_SYSTEMBUSY         -205 /* system busy handling requests */

    56 #define SOCKERR_SYSTEMFULL         -206 /* too many sockets */

    57 #define SOCKERR_NOTCONNECTED       -207 /* socket is not connected */

    58 #define SOCKERR_INTERRUPTED        -208 /* the call was cancelled */

    59 #define SOCKERR_TIMEOUT            -209 /* the operation timed out */

    60 #define SOCKERR_CONNRESET          -210 /* the connection was reset */

    61 #define SOCKERR_WOULDBLOCK         -211 /* the socket is marked as nonblocking operation would block */

    62 #define SOCKERR_ADDRNOTAVAIL       -212 /* address not available */

    63 #define SOCKERR_ADDRINUSE          -213 /* address already in use */

    64 #define SOCKERR_NOTBOUND           -214 /* the socket is not bound */

    65 #define SOCKERR_UNKNOWNSOCKET      -215 /* resolution of fileDescriptor to socket failed */

    66 #define SOCKERR_INVALIDTIMEOUT     -216 /* the specified timeout is invalid */

    67 #define SOCKERR_FDSETFULL          -217 /* Unable to create an FDSET */

    68 #define SOCKERR_TIMEVALFULL        -218 /* Unable to create a TIMEVAL */

    69 #define SOCKERR_REMSOCKSHUTDOWN    -219 /* The remote socket has shutdown gracefully */

    70 #define SOCKERR_NOTLISTENING       -220 /* listen() was not invoked prior to accept() */

    71 #define SOCKERR_NOTSTREAMSOCK      -221 /* The socket does not support connection-oriented service */

    72 #define SOCKERR_ALREADYBOUND       -222 /* The socket is already bound to an address */

    73 #define SOCKERR_NBWITHLINGER       -223 /* The socket is marked non-blocking & SO_LINGER is non-zero */

    74 #define SOCKERR_ISCONNECTED        -224 /* The socket is already connected */

    75 #define SOCKERR_NOBUFFERS          -225 /* No buffer space is available */

    76 #define SOCKERR_HOSTNOTFOUND       -226 /* Authoritative Answer Host not found */

    77 #define SOCKERR_NODATA             -227 /* Valid name, no data record of requested type */

    78 #define SOCKERR_BOUNDORCONN        -228 /* The socket has not been bound or is already connected */

    79 #define SOCKERR_OPNOTSUPP          -229 /* The socket does not support the operation */

    80 #define SOCKERR_OPTUNSUPP          -230 /* The socket option is not supported */

    81 #define SOCKERR_OPTARGSINVALID     -231 /* The socket option arguments are invalid */

    82 #define SOCKERR_SOCKLEVELINVALID   -232 /* The socket level is invalid */

    83 #define SOCKERR_TIMEOUTFAILURE     -233

    84 #define SOCKERR_SOCKADDRALLOCFAIL  -234 /* Unable to allocate the sockaddr structure */

    85 #define SOCKERR_FDSET_SIZEBAD      -235 /* The calculated maximum size of the file descriptor set is bad */

    86 #define SOCKERR_UNKNOWNFLAG        -236 /* The flag is unknown */

    87 #define SOCKERR_MSGSIZE            -237 /* The datagram was too big to fit the specified buffer & was truncated. */

    88 #define SOCKERR_NORECOVERY         -238 /* The operation failed with no recovery possible */

    89 #define SOCKERR_ARGSINVALID        -239 /* The arguments are invalid */

    90 #define SOCKERR_BADDESC            -240 /* The socket argument is not a valid file descriptor */

    91 #define SOCKERR_NOTSOCK            -241 /* The socket argument is not a socket */

    92 #define SOCKERR_HOSTENTALLOCFAIL   -242 /* Unable to allocate the hostent structure */

    93 #define SOCKERR_TIMEVALALLOCFAIL   -243 /* Unable to allocate the timeval structure */

    94 #define SOCKERR_LINGERALLOCFAIL    -244 /* Unable to allocate the linger structure */

    95 #define SOCKERR_IPMREQALLOCFAIL    -245 /* Unable to allocate the ipmreq structure */

    96 #define SOCKERR_FDSETALLOCFAIL     -246 /* Unable to allocate the fdset structure */

    97 #define SOCKERR_OPFAILED           -247 /* Operation failed */

    98 #define SOCKERR_VALUE_NULL         -248 /* The value indexed was NULL */

    99 #define SOCKERR_CONNECTION_REFUSED -249 /* connection was refused */

   100 #define SOCKERR_ENETUNREACH        -250 /* network is not reachable */

   101 #define SOCKERR_EACCES             -251 /* permissions do not allow action on socket */

   102 #define SOCKERR_EHOSTUNREACH       -252 /* no route to host */

   103 #define SOCKERR_EPIPE              -253 /* broken pipe */

   104 

   105 #define JAVASOCKOPT_TCP_NODELAY 1

   106 #define JAVASOCKOPT_IP_TOS 3

   107 #define JAVASOCKOPT_SO_REUSEADDR 4

   108 #define JAVASOCKOPT_SO_KEEPALIVE 8

   109 #define JAVASOCKOPT_MCAST_TIME_TO_LIVE 10 /* Currently unused */

   110 #define JAVASOCKOPT_SO_BINDADDR 15

   111 #define JAVASOCKOPT_MCAST_INTERFACE 16

   112 #define JAVASOCKOPT_MCAST_TTL 17

   113 #define JAVASOCKOPT_IP_MULTICAST_LOOP 18

   114 #define JAVASOCKOPT_MCAST_ADD_MEMBERSHIP 19

   115 #define JAVASOCKOPT_MCAST_DROP_MEMBERSHIP 20

   116 #define JAVASOCKOPT_IP_MULTICAST_IF2 31

   117 #define JAVASOCKOPT_SO_BROADCAST 32

   118 #define JAVASOCKOPT_SO_LINGER 128

   119 #define JAVASOCKOPT_REUSEADDR_AND_REUSEPORT  10001

   120 #define JAVASOCKOPT_SO_SNDBUF 4097

   121 #define JAVASOCKOPT_SO_RCVBUF 4098

   122 #define JAVASOCKOPT_SO_RCVTIMEOUT  4102

   123 #define JAVASOCKOPT_SO_OOBINLINE  4099

   124 

   125 /* constants for calling multi-call functions */

   126 #define SOCKET_STEP_START 10

   127 #define SOCKET_STEP_CHECK 20

   128 #define SOCKET_STEP_DONE 30

   129 

   130 #define BROKEN_MULTICAST_IF 1

   131 #define BROKEN_MULTICAST_TTL 2

   132 #define BROKEN_TCP_NODELAY 4

   133 

   134 #define SOCKET_CONNECT_STEP_START 0

   135 #define SOCKET_CONNECT_STEP_CHECK 1

   136 

   137 #define SOCKET_OP_NONE 0

   138 #define SOCKET_OP_READ 1

   139 #define SOCKET_OP_WRITE 2

   140 #define SOCKET_READ_WRITE 3

   141 

   142 #define SOCKET_MSG_PEEK 1

   143 #define SOCKET_MSG_OOB 2

   144 

   145 #define SOCKET_NOFLAGS 0

   146 

   147 #undef BUFFERSIZE

   148 #define BUFFERSIZE 2048

   149 

   150 // wait for 500000 usec = 0.5 second

   151 #define SEND_RETRY_TIME 500000

   152 

   153 

   154 struct CachedFields {

   155     jfieldID fd_descriptor;

   156     jclass iaddr_class;

   157     jmethodID iaddr_class_init;

   158     jmethodID iaddr_getbyaddress;

   159     jfieldID iaddr_ipaddress;

   160     jclass genericipmreq_class;

   161     jclass integer_class;

   162     jmethodID integer_class_init;

   163     jfieldID integer_class_value;

   164     jclass boolean_class;

   165     jmethodID boolean_class_init;

   166     jfieldID boolean_class_value;

   167     jclass byte_class;

   168     jmethodID byte_class_init;

   169     jfieldID byte_class_value;

   170     jclass string_class;

   171     jmethodID string_class_init;

   172     jfieldID socketimpl_address;

   173     jfieldID socketimpl_port;

   174     jclass dpack_class;

   175     jfieldID dpack_address;

   176     jfieldID dpack_port;

   177     jfieldID dpack_length;

   178     jclass fd_class;

   179     jfieldID descriptor;

   180 } gCachedFields;

   181 

   182 static int useAdbNetworking = 0;

   183 

   184 /* needed for connecting with timeout */

   185 typedef struct selectFDSet {

   186   int nfds;

   187   int sock;

   188   fd_set writeSet;

   189   fd_set readSet;

   190   fd_set exceptionSet;

   191 } selectFDSet;

   192 

   193 static const char * netLookupErrorString(int anErrorNum);

   194 

   195 #define log_socket_close(a,b)

   196 #define log_socket_connect(a,b,c)

   197 #define add_send_stats(a,b)

   198 #define add_recv_stats(a,b)

   199 #define adb_networking_connect_fd(a,b) 0

   200 #define adb_networking_gethostbyname(a,b) 0

   201 #define PROPERTY_VALUE_MAX 1

   202 #define property_get(a,b,c)

   203 #define assert(a)

   204 /*

   205  * Throw an exception with the specified class and an optional message.

   206  */

   207 int jniThrowException(JNIEnv* env, const char* className, const char* msg)

   208 {

   209     jclass exceptionClass;

   210 

   211     exceptionClass = env->FindClass(className);

   212     if (exceptionClass == NULL) {

   213 //        LOGE("Unable to find exception class %s\n", className);

   214         assert(0);      /* fatal during dev; should always be fatal? */

   215         return -1;

   216     }

   217 

   218     if (env->ThrowNew(exceptionClass, msg) != JNI_OK) {

   219 //        LOGE("Failed throwing '%s' '%s'\n", className, msg);

   220         assert(!"failed to throw");

   221     }

   222     return 0;

   223 }

   224 

   225 /*

   226  * Internal helper function.

   227  *

   228  * Get the file descriptor.

   229  */

   230 static inline int getFd(JNIEnv* env, jobject obj)

   231 {

   232     return env->GetIntField(obj, gCachedFields.descriptor);

   233 }

   234 

   235 /*

   236  * Internal helper function.

   237  *

   238  * Set the file descriptor.

   239  */

   240 static inline void setFd(JNIEnv* env, jobject obj, jint value)

   241 {

   242     env->SetIntField(obj, gCachedFields.descriptor, value);

   243 }

   244 

   245 /* 

   246  * For JNIHelp.c

   247  * Get an int file descriptor from a java.io.FileDescriptor

   248  */

   249 

   250 static int jniGetFDFromFileDescriptor (JNIEnv* env, jobject fileDescriptor) {

   251 

   252     return getFd(env, fileDescriptor);

   253 }

   254 

   255 /*

   256  * For JNIHelp.c

   257  * Set the descriptor of a java.io.FileDescriptor

   258  */

   259 

   260 static void jniSetFileDescriptorOfFD (JNIEnv* env, jobject fileDescriptor, int value) {

   261 

   262     setFd(env, fileDescriptor, value);

   263 }

   264 

   265 /**

   266  * Throws an SocketException with the message affiliated with the errorCode.

   267  */

   268 static void throwSocketException(JNIEnv *env, int errorCode) {

   269     jniThrowException(env, "java/net/SocketException",

   270         netLookupErrorString(errorCode));

   271 }

   272 

   273 /**

   274  * Throws an IOException with the given message.

   275  */

   276 static void throwIOExceptionStr(JNIEnv *env, const char *message) {

   277     jniThrowException(env, "java/io/IOException", message);

   278 }

   279 

   280 /**

   281  * Throws a NullPointerException.

   282  */

   283 static void throwNullPointerException(JNIEnv *env) {

   284     jniThrowException(env, "java/lang/NullPointerException", NULL);

   285 }

   286 

   287 /**

   288  * Converts a 4-byte array to a native address structure. Throws a

   289  * NullPointerException or an IOException in case of error. This is

   290  * signaled by a return value of -1. The normal return value is 0.

   291  */

   292 static int javaAddressToStructIn(

   293         JNIEnv *env, jbyteArray java_address, struct in_addr *address) {

   294 

   295     memset(address, 0, sizeof(address));

   296 

   297     if (java_address == NULL) {

   298         return -1;

   299     }

   300 

   301     if (env->GetArrayLength(java_address) != sizeof(address->s_addr)) {

   302         return -1;

   303     }

   304 

   305     jbyte * java_address_bytes

   306         =  env->GetByteArrayElements(java_address, NULL);

   307 

   308     memcpy(&(address->s_addr),

   309         java_address_bytes,

   310         sizeof(address->s_addr));

   311 

   312     env->ReleaseByteArrayElements(java_address, java_address_bytes, JNI_ABORT);

   313 

   314     return 0;

   315 }

   316 

   317 /**

   318  * Converts a native address structure to a 4-byte array. Throws a

   319  * NullPointerException or an IOException in case of error. This is

   320  * signaled by a return value of -1. The normal return value is 0.

   321  */

   322 static int structInToJavaAddress(

   323         JNIEnv *env, struct in_addr *address, jbyteArray java_address) {

   324 

   325     if (java_address == NULL) {

   326         return -1;

   327     }

   328 

   329     if (env->GetArrayLength(java_address) != sizeof(address->s_addr)) {

   330         return -1;

   331     }

   332 

   333     jbyte *java_address_bytes;

   334 

   335     java_address_bytes = env->GetByteArrayElements(java_address, NULL);

   336 

   337     memcpy(java_address_bytes, &(address->s_addr), sizeof(address->s_addr));

   338 

   339     env->ReleaseByteArrayElements(java_address, java_address_bytes, 0);

   340 

   341     return 0;

   342 }

   343 

   344 /**

   345  * Converts a native address structure to an InetAddress object.

   346  * Throws a NullPointerException or an IOException in case of

   347  * error. This is signaled by a return value of -1. The normal

   348  * return value is 0.

   349  */

   350 static int socketAddressToInetAddress(JNIEnv *env,

   351         struct sockaddr_in *sockaddress, jobject inetaddress, int *port) {

   352 

   353     jbyteArray ipaddress;

   354     int result;

   355 

   356     ipaddress = (jbyteArray)env->GetObjectField(inetaddress,

   357             gCachedFields.iaddr_ipaddress);

   358 

   359     if (structInToJavaAddress(env, &sockaddress->sin_addr, ipaddress) < 0) {

   360         return -1;

   361     }

   362 

   363     *port = ntohs(sockaddress->sin_port);

   364 

   365     return 0;

   366 }

   367 

   368 /**

   369  * Converts an InetAddress object to a native address structure.

   370  * Throws a NullPointerException or an IOException in case of

   371  * error. This is signaled by a return value of -1. The normal

   372  * return value is 0.

   373  */

   374 static int inetAddressToSocketAddress(JNIEnv *env,

   375         jobject inetaddress, int port, struct sockaddr_in *sockaddress) {

   376 

   377     jbyteArray ipaddress;

   378     int result;

   379 

   380     ipaddress = (jbyteArray)env->GetObjectField(inetaddress,

   381             gCachedFields.iaddr_ipaddress);

   382 

   383     memset(sockaddress, 0, sizeof(sockaddress));

   384 

   385     sockaddress->sin_family = AF_INET;

   386     sockaddress->sin_port = htons(port);

   387 

   388     if (javaAddressToStructIn(env, ipaddress, &(sockaddress->sin_addr)) < 0) {

   389         return -1;

   390     }

   391 

   392     return 0;

   393 }

   394 

   395 static jobject structInToInetAddress(JNIEnv *env, struct in_addr *address) {

   396     jbyteArray bytes;

   397     int success;

   398 

   399     bytes = env->NewByteArray(4);

   400 

   401     if (bytes == NULL) {

   402         return NULL;

   403     }

   404 

   405     if (structInToJavaAddress(env, address, bytes) < 0) {

   406         return NULL;

   407     }

   408 

   409     return env->CallStaticObjectMethod(gCachedFields.iaddr_class,

   410             gCachedFields.iaddr_getbyaddress, bytes);

   411 }

   412 

   413 /**

   414  * Answer a new java.lang.Boolean object.

   415  *

   416  * @param env   pointer to the JNI library

   417  * @param anInt the Boolean constructor argument

   418  *

   419  * @return  the new Boolean

   420  */

   421 

   422 static jobject newJavaLangBoolean(JNIEnv * env, jint anInt) {

   423     jclass tempClass;

   424     jmethodID tempMethod;

   425 

   426     tempClass = gCachedFields.boolean_class;

   427     tempMethod = gCachedFields.boolean_class_init;

   428     return env->NewObject(tempClass, tempMethod, (jboolean) (anInt != 0));

   429 }

   430 

   431 /**

   432  * Answer a new java.lang.Byte object.

   433  *

   434  * @param env   pointer to the JNI library

   435  * @param anInt the Byte constructor argument

   436  *

   437  * @return  the new Byte

   438  */

   439 

   440 static jobject newJavaLangByte(JNIEnv * env, jbyte val) {

   441     jclass tempClass;

   442     jmethodID tempMethod;

   443 

   444     tempClass = gCachedFields.byte_class;

   445     tempMethod = gCachedFields.byte_class_init;

   446     return env->NewObject(tempClass, tempMethod, val);

   447 }

   448 

   449 /**

   450  * Answer a new java.lang.Integer object.

   451  *

   452  * @param env   pointer to the JNI library

   453  * @param anInt the Integer constructor argument

   454  *

   455  * @return  the new Integer

   456  */

   457 

   458 static jobject newJavaLangInteger(JNIEnv * env, jint anInt) {

   459     jclass tempClass;

   460     jmethodID tempMethod;

   461 

   462     tempClass = gCachedFields.integer_class;

   463     tempMethod = gCachedFields.integer_class_init;

   464     return env->NewObject(tempClass, tempMethod, anInt);

   465 }

   466 

   467 /**

   468  * Answer a new java.lang.String object.

   469  *

   470  * @param env   pointer to the JNI library

   471  * @param anInt the byte[] constructor argument

   472  *

   473  * @return  the new String

   474  */

   475 

   476 static jobject newJavaLangString(JNIEnv * env, jbyteArray bytes) {

   477     jclass tempClass;

   478     jmethodID tempMethod;

   479 

   480     tempClass = gCachedFields.string_class;

   481     tempMethod = gCachedFields.string_class_init;

   482     return env->NewObject(tempClass, tempMethod, (jbyteArray) bytes);

   483 }

   484 

   485 /**

   486  * Query OS for timestamp.

   487  * Retrieve the current value of system clock and convert to milliseconds.

   488  *

   489  * @param[in] portLibrary The port library.

   490  *

   491  * @return 0 on failure, time value in milliseconds on success.

   492  * @deprecated Use @ref time_hires_clock and @ref time_hires_delta

   493  *

   494  * technically, this should return I_64 since both timeval.tv_sec and

   495  * timeval.tv_usec are long

   496  */

   497 

   498 static int time_msec_clock() {

   499     struct timeval tp;

   500     struct timezone tzp;

   501 

   502     gettimeofday(&tp, &tzp);

   503     return (tp.tv_sec * 1000) + (tp.tv_usec / 1000);

   504 }

   505 

   506 /**

   507  * check if the passed sockaddr_in struct contains a localhost address

   508  *

   509  * @param[in] address pointer to the address to check

   510  *

   511  * @return 0 if the passed address isn't a localhost address

   512  */

   513 static int isLocalhost(struct sockaddr_in *address) {

   514     // return address == 127.0.0.1

   515     return (unsigned int) address->sin_addr.s_addr == 16777343;

   516 }

   517 

   518 /**

   519  * Answer the errorString corresponding to the errorNumber, if available.

   520  * This function will answer a default error string, if the errorNumber is not

   521  * recognized.

   522  *

   523  * This function will have to be reworked to handle internationalization

   524  * properly, removing the explicit strings.

   525  *

   526  * @param anErrorNum    the error code to resolve to a human readable string

   527  *

   528  * @return  a human readable error string

   529  */

   530 

   531 static const char * netLookupErrorString(int anErrorNum) {

   532     switch (anErrorNum) {

   533         case SOCKERR_BADSOCKET:

   534             return "Bad socket";

   535         case SOCKERR_NOTINITIALIZED:

   536             return "Socket library uninitialized";

   537         case SOCKERR_BADAF:

   538             return "Bad address family";

   539         case SOCKERR_BADPROTO:

   540             return "Bad protocol";

   541         case SOCKERR_BADTYPE:

   542             return "Bad type";

   543         case SOCKERR_SYSTEMBUSY:

   544             return "System busy handling requests";

   545         case SOCKERR_SYSTEMFULL:

   546             return "Too many sockets allocated";

   547         case SOCKERR_NOTCONNECTED:

   548             return "Socket is not connected";

   549         case SOCKERR_INTERRUPTED:

   550             return "The system call was cancelled";

   551         case SOCKERR_TIMEOUT:

   552             return "The operation timed out";

   553         case SOCKERR_CONNRESET:

   554             return "The connection was reset";

   555         case SOCKERR_WOULDBLOCK:

   556             return "The nonblocking operation would block";

   557         case SOCKERR_ADDRNOTAVAIL:

   558             return "The address is not available";

   559         case SOCKERR_ADDRINUSE:

   560             return "The address is already in use";

   561         case SOCKERR_NOTBOUND:

   562             return "The socket is not bound";

   563         case SOCKERR_UNKNOWNSOCKET:

   564             return "Resolution of the FileDescriptor to socket failed";

   565         case SOCKERR_INVALIDTIMEOUT:

   566             return "The specified timeout is invalid";

   567         case SOCKERR_FDSETFULL:

   568             return "Unable to create an FDSET";

   569         case SOCKERR_TIMEVALFULL:

   570             return "Unable to create a TIMEVAL";

   571         case SOCKERR_REMSOCKSHUTDOWN:

   572             return "The remote socket has shutdown gracefully";

   573         case SOCKERR_NOTLISTENING:

   574             return "Listen() was not invoked prior to accept()";

   575         case SOCKERR_NOTSTREAMSOCK:

   576             return "The socket does not support connection-oriented service";

   577         case SOCKERR_ALREADYBOUND:

   578             return "The socket is already bound to an address";

   579         case SOCKERR_NBWITHLINGER:

   580             return "The socket is marked non-blocking & SO_LINGER is non-zero";

   581         case SOCKERR_ISCONNECTED:

   582             return "The socket is already connected";

   583         case SOCKERR_NOBUFFERS:

   584             return "No buffer space is available";

   585         case SOCKERR_HOSTNOTFOUND:

   586             return "Authoritative Answer Host not found";

   587         case SOCKERR_NODATA:

   588             return "Valid name, no data record of requested type";

   589         case SOCKERR_BOUNDORCONN:

   590             return "The socket has not been bound or is already connected";

   591         case SOCKERR_OPNOTSUPP:

   592             return "The socket does not support the operation";

   593         case SOCKERR_OPTUNSUPP:

   594             return "The socket option is not supported";

   595         case SOCKERR_OPTARGSINVALID:

   596             return "The socket option arguments are invalid";

   597         case SOCKERR_SOCKLEVELINVALID:

   598             return "The socket level is invalid";

   599         case SOCKERR_TIMEOUTFAILURE:

   600             return "The timeout operation failed";

   601         case SOCKERR_SOCKADDRALLOCFAIL:

   602             return "Failed to allocate address structure";

   603         case SOCKERR_FDSET_SIZEBAD:

   604             return "The calculated maximum size of the file descriptor set is bad";

   605         case SOCKERR_UNKNOWNFLAG:

   606             return "The flag is unknown";

   607         case SOCKERR_MSGSIZE:

   608             return "The datagram was too big to fit the specified buffer, so truncated";

   609         case SOCKERR_NORECOVERY:

   610             return "The operation failed with no recovery possible";

   611         case SOCKERR_ARGSINVALID:

   612             return "The arguments are invalid";

   613         case SOCKERR_BADDESC:

   614             return "The socket argument is not a valid file descriptor";

   615         case SOCKERR_NOTSOCK:

   616             return "The socket argument is not a socket";

   617         case SOCKERR_HOSTENTALLOCFAIL:

   618             return "Unable to allocate the hostent structure";

   619         case SOCKERR_TIMEVALALLOCFAIL:

   620             return "Unable to allocate the timeval structure";

   621         case SOCKERR_LINGERALLOCFAIL:

   622             return "Unable to allocate the linger structure";

   623         case SOCKERR_IPMREQALLOCFAIL:

   624             return "Unable to allocate the ipmreq structure";

   625         case SOCKERR_FDSETALLOCFAIL:

   626             return "Unable to allocate the fdset structure";

   627         case SOCKERR_OPFAILED:

   628             return "Operation failed";

   629         case SOCKERR_CONNECTION_REFUSED:

   630             return "Connection refused";

   631         case SOCKERR_ENETUNREACH:

   632             return "Network unreachable";

   633         case SOCKERR_EHOSTUNREACH:

   634             return "No route to host";

   635         case SOCKERR_EPIPE:

   636             return "Broken pipe";

   637         case SOCKERR_EACCES:

   638             return "Permission denied (maybe missing INTERNET permission)";

   639 

   640         default:

   641 //            LOGE("unknown socket error %d", anErrorNum);

   642             return "unknown error";

   643     }

   644 }

   645 

   646 static int convertError(int errorCode) {

   647     switch (errorCode) {

   648         case EBADF:

   649             return SOCKERR_BADDESC;

   650         case ENOBUFS:

   651             return SOCKERR_NOBUFFERS;

   652         case EOPNOTSUPP:

   653             return SOCKERR_OPNOTSUPP;

   654         case ENOPROTOOPT:

   655             return SOCKERR_OPTUNSUPP;

   656         case EINVAL:

   657             return SOCKERR_SOCKLEVELINVALID;

   658         case ENOTSOCK:

   659             return SOCKERR_NOTSOCK;

   660         case EINTR:

   661             return SOCKERR_INTERRUPTED;

   662         case ENOTCONN:

   663             return SOCKERR_NOTCONNECTED;

   664         case EAFNOSUPPORT:

   665             return SOCKERR_BADAF;

   666             /* note: CONNRESET not included because it has the same

   667              * value as ECONNRESET and they both map to SOCKERR_CONNRESET */

   668         case ECONNRESET:

   669             return SOCKERR_CONNRESET;

   670         case EAGAIN:

   671             return SOCKERR_WOULDBLOCK;

   672         case EPROTONOSUPPORT:

   673             return SOCKERR_BADPROTO;

   674         case EFAULT:

   675             return SOCKERR_ARGSINVALID;

   676         case ETIMEDOUT:

   677             return SOCKERR_TIMEOUT;

   678         case ECONNREFUSED:

   679             return SOCKERR_CONNECTION_REFUSED;

   680         case ENETUNREACH:

   681             return SOCKERR_ENETUNREACH;

   682         case EACCES:

   683             return SOCKERR_EACCES;

   684         case EPIPE:

   685             return SOCKERR_EPIPE;

   686         case EHOSTUNREACH:

   687             return SOCKERR_EHOSTUNREACH;

   688         case EADDRINUSE:

   689             return SOCKERR_ADDRINUSE;

   690         case EADDRNOTAVAIL:

   691             return SOCKERR_ADDRNOTAVAIL;

   692         case EMSGSIZE:

   693             return SOCKERR_MSGSIZE;

   694         default:

   695 //            LOGE("unclassified errno %d (%s)", errorCode, strerror(errorCode));

   696             return SOCKERR_OPFAILED;

   697     }

   698 }

   699 

   700 static int sockSelect(int nfds, fd_set *readfds, fd_set *writefds,

   701         fd_set *exceptfds, struct timeval *timeout) {

   702 

   703     int result = select(nfds, readfds, writefds, exceptfds, timeout);

   704 

   705     if (result < 0) {

   706         if (errno == EINTR) {

   707             result = SOCKERR_INTERRUPTED;

   708         } else {

   709             result = SOCKERR_OPFAILED;

   710         }

   711     } else if (result == 0) {

   712         result = SOCKERR_TIMEOUT;

   713     }

   714     return result;

   715 }

   716 

   717 #define SELECT_READ_TYPE 0

   718 #define SELECT_WRITE_TYPE 1

   719 

   720 static int selectWait(int handle, int uSecTime, int type) {

   721     fd_set fdset;

   722     struct timeval time, *timePtr;

   723     int result = 0;

   724     int size = handle + 1;

   725 

   726     FD_ZERO(&fdset);

   727     FD_SET(handle, &fdset);

   728 

   729     if (0 <= uSecTime) {

   730         /* Use a timeout if uSecTime >= 0 */

   731         memset(&time, 0, sizeof(time));

   732         time.tv_usec = uSecTime;

   733         timePtr = &time;

   734     } else {

   735         /* Infinite timeout if uSecTime < 0 */

   736         timePtr = NULL;

   737     }

   738 

   739     if (type == SELECT_READ_TYPE) {

   740         result = sockSelect(size, &fdset, NULL, NULL, timePtr);

   741     } else {

   742         result = sockSelect(size, NULL, &fdset, NULL, timePtr);

   743     }

   744     return result;

   745 }

   746 

   747 static int pollSelectWait(JNIEnv *env, jobject fileDescriptor, int timeout, int type) {

   748     /* now try reading the socket for the timespan timeout.

   749      * if timeout is 0 try forever until the soclets gets ready or until an

   750      * exception occurs.

   751      */

   752     int pollTimeoutUSec = 100000, pollMsec = 100;

   753     int finishTime = 0;

   754     int timeLeft = timeout;

   755     int hasTimeout = timeout > 0 ? 1 : 0;

   756     int result = 0;

   757     int handle;

   758 

   759     if (hasTimeout) {

   760         finishTime = time_msec_clock() + timeout;

   761     }

   762 

   763     int poll = 1;

   764 

   765     while (poll) { /* begin polling loop */

   766 

   767         /*

   768          * Fetch the handle every time in case the socket is closed.

   769          */

   770         handle = jniGetFDFromFileDescriptor(env, fileDescriptor);

   771 

   772         if (handle == 0 || handle == -1) {

   773             throwSocketException(env, SOCKERR_INTERRUPTED);

   774             return -1;

   775         }

   776 

   777         if (hasTimeout) {

   778 

   779             if (timeLeft - 10 < pollMsec) {

   780                 pollTimeoutUSec = timeLeft <= 0 ? 0 : (timeLeft * 1000);

   781             }

   782 

   783             result = selectWait(handle, pollTimeoutUSec, type);

   784 

   785             /*

   786              * because we are polling at a time smaller than timeout

   787              * (presumably) lets treat an interrupt and timeout the same - go

   788              * see if we're done timewise, and then just try again if not.

   789              */

   790             if (SOCKERR_TIMEOUT == result ||

   791                 SOCKERR_INTERRUPTED == result) {

   792 

   793                 timeLeft = finishTime - time_msec_clock();

   794 

   795                 if (timeLeft <= 0) {

   796                     /*

   797                      * Always throw the "timeout" message because that is

   798                      * effectively what has happened, even if we happen to

   799                      * have been interrupted.

   800                      */

   801                     jniThrowException(env, "java/net/SocketTimeoutException",

   802                             netLookupErrorString(SOCKERR_TIMEOUT));

   803                 } else {

   804                     continue; // try again

   805                 }

   806 

   807             } else if (0 > result) {

   808                 log_socket_close(handle, result);

   809                 throwSocketException(env, result);

   810             }

   811             poll = 0;

   812 

   813         } else { /* polling with no timeout (why would you do this?)*/

   814 

   815             result = selectWait(handle, pollTimeoutUSec, type);

   816 

   817             /*

   818              *  if interrupted (or a timeout) just retry

   819              */

   820             if (SOCKERR_TIMEOUT == result ||

   821                SOCKERR_INTERRUPTED == result) {

   822 

   823                 continue; // try again

   824             } else if (0 > result) {

   825                 log_socket_close(handle, result);

   826                 throwSocketException(env, result);

   827             }

   828             poll = 0;

   829         }

   830     } /* end polling loop */

   831 

   832     return result;

   833 }

   834 

   835 /**

   836  * A helper method, to set the connect context to a Long object.

   837  *

   838  * @param env  pointer to the JNI library

   839  * @param longclass Java Long Object

   840  */

   841 void setConnectContext(JNIEnv *env,jobject longclass,jbyte * context) {

   842     jclass descriptorCLS;

   843     jfieldID descriptorFID;

   844     descriptorCLS = env->FindClass("java/lang/Long");

   845     descriptorFID = env->GetFieldID(descriptorCLS, "value", "J");

   846     env->SetLongField(longclass, descriptorFID, (jlong)((jint)context));

   847 };

   848 

   849 /**

   850  * A helper method, to get the connect context.

   851  *

   852  * @param env  pointer to the JNI library

   853  * @param longclass Java Long Object

   854  */

   855 jbyte *getConnectContext(JNIEnv *env, jobject longclass) {

   856     jclass descriptorCLS;

   857     jfieldID descriptorFID;

   858     descriptorCLS = env->FindClass("java/lang/Long");

   859     descriptorFID = env->GetFieldID(descriptorCLS, "value", "J");

   860     return (jbyte*) ((jint)env->GetLongField(longclass, descriptorFID));

   861 };

   862 

   863 // typical ip checksum

   864 unsigned short ip_checksum(unsigned short* buffer, int size) {

   865     register unsigned short * buf = buffer;

   866     register int bufleft = size;

   867     register unsigned long sum = 0;

   868 

   869     while (bufleft > 1) {

   870         sum = sum + (*buf++);

   871         bufleft = bufleft - sizeof(unsigned short );

   872     }

   873     if (bufleft) {

   874         sum = sum + (*(unsigned char*)buf);

   875     }

   876     sum = (sum >> 16) + (sum & 0xffff);

   877     sum += (sum >> 16);

   878 

   879     return (unsigned short )(~sum);

   880 }

   881 

   882 /**

   883  * Establish a connection to a peer with a timeout.  This function is called

   884  * repeatedly in order to carry out the connect and to allow other tasks to

   885  * proceed on certain platforms. The caller must first call with

   886  * step = SOCKET_STEP_START, if the result is SOCKERR_NOTCONNECTED it will then

   887  * call it with step = CHECK until either another error or 0 is returned to

   888  * indicate the connect is complete.  Each time the function should sleep for no

   889  * more than timeout milliseconds.  If the connect succeeds or an error occurs,

   890  * the caller must always end the process by calling the function with

   891  * step = SOCKET_STEP_DONE

   892  *

   893  * @param[in] portLibrary The port library.

   894  * @param[in] sock pointer to the unconnected local socket.

   895  * @param[in] addr pointer to the sockaddr, specifying remote host/port.

   896  * @param[in] timeout the timeout in milliseconds. If timeout is negative,

   897  *         perform a block operation.

   898  * @param[in,out] pointer to context pointer. Filled in on first call and then

   899  *         to be passed into each subsequent call.

   900  *

   901  * @return 0, if no errors occurred, otherwise the (negative) error code.

   902  */

   903 static int sockConnectWithTimeout(int handle, struct sockaddr_in addr,

   904         unsigned int timeout, unsigned int step, jbyte *ctxt) {

   905     int rc = 0;

   906     struct timeval passedTimeout;

   907     int errorVal;

   908     socklen_t errorValLen = sizeof(int);

   909     struct selectFDSet *context = NULL;

   910 

   911     if (SOCKET_STEP_START == step) {

   912 

   913         context = (struct selectFDSet *) ctxt;

   914 

   915         context->sock = handle;

   916         context->nfds = handle + 1;

   917 

   918         if (useAdbNetworking && !isLocalhost(&addr)) {

   919 

   920             // LOGD("+connect to address 0x%08x (via adb)",

   921             //         addr.sin_addr.s_addr);

   922             rc = adb_networking_connect_fd(handle, &addr);

   923             // LOGD("-connect ret %d errno %d (via adb)", rc, errno);

   924 

   925         } else {

   926             log_socket_connect(handle, ntohl(addr.sin_addr.s_addr),

   927                     ntohs(addr.sin_port));

   928             /* set the socket to non-blocking */

   929             int block = JNI_TRUE;

   930             rc = ioctl(handle, FIONBIO, &block);

   931             if (0 != rc) {

   932                 return convertError(rc);

   933             }

   934 

   935             // LOGD("+connect to address 0x%08x (via normal) on handle %d",

   936             //         addr.sin_addr.s_addr, handle);

   937             do {

   938                 rc = connect(handle, (struct sockaddr *) &addr,

   939                         sizeof(struct sockaddr));

   940             } while (rc < 0 && errno == EINTR);

   941             // LOGD("-connect to address 0x%08x (via normal) returned %d",

   942             //         addr.sin_addr.s_addr, (int) rc);

   943 

   944         }

   945 

   946         if (rc == -1) {

   947             rc = errno;

   948             switch (rc) {

   949                 case EINTR:

   950                     return SOCKERR_ALREADYBOUND;

   951                 case EAGAIN:

   952                 case EINPROGRESS:

   953                     return SOCKERR_NOTCONNECTED;

   954                 default:

   955                     return convertError(rc);

   956             }

   957         }

   958 

   959         /* we connected right off the bat so just return */

   960         return rc;

   961 

   962     } else if (SOCKET_STEP_CHECK == step) {

   963         /* now check if we have connected yet */

   964 

   965         context = (struct selectFDSet *) ctxt;

   966 

   967         /*

   968          * set the timeout value to be used. Because on some unix platforms we

   969          * don't get notified when a socket is closed we only sleep for 100ms

   970          * at a time

   971          */

   972         passedTimeout.tv_sec = 0;

   973         if (timeout > 100) {

   974             passedTimeout.tv_usec = 100 * 1000;

   975         } else if ((int)timeout >= 0) {

   976           passedTimeout.tv_usec = timeout * 1000;

   977         }

   978 

   979         /* initialize the FD sets for the select */

   980         FD_ZERO(&(context->exceptionSet));

   981         FD_ZERO(&(context->writeSet));

   982         FD_ZERO(&(context->readSet));

   983         FD_SET(context->sock, &(context->writeSet));

   984         FD_SET(context->sock, &(context->readSet));

   985         FD_SET(context->sock, &(context->exceptionSet));

   986 

   987         rc = select(context->nfds,

   988                    &(context->readSet),

   989                    &(context->writeSet),

   990                    &(context->exceptionSet),

   991                    (int)timeout >= 0 ? &passedTimeout : NULL);

   992 

   993         /* if there is at least one descriptor ready to be checked */

   994         if (0 < rc) {

   995             /* if the descriptor is in the write set we connected or failed */

   996             if (FD_ISSET(context->sock, &(context->writeSet))) {

   997 

   998                 if (!FD_ISSET(context->sock, &(context->readSet))) {

   999                     /* ok we have connected ok */

  1000                     return 0;

  1001                 } else {

  1002                     /* ok we have more work to do to figure it out */

  1003                     if (getsockopt(context->sock, SOL_SOCKET, SO_ERROR,

  1004                             &errorVal, &errorValLen) >= 0) {

  1005                         return errorVal ? convertError(errorVal) : 0;

  1006                     } else {

  1007                         return convertError(errno);

  1008                     }

  1009                 }

  1010             }

  1011 

  1012             /* if the descriptor is in the exception set the connect failed */

  1013             if (FD_ISSET(context->sock, &(context->exceptionSet))) {

  1014                 if (getsockopt(context->sock, SOL_SOCKET, SO_ERROR, &errorVal,

  1015                         &errorValLen) >= 0) {

  1016                     return errorVal ? convertError(errorVal) : 0;

  1017                 }

  1018                 rc = errno;

  1019                 return convertError(rc);

  1020             }

  1021 

  1022         } else if (rc < 0) {

  1023             /* something went wrong with the select call */

  1024             rc = errno;

  1025 

  1026             /* if it was EINTR we can just try again. Return not connected */

  1027             if (EINTR == rc) {

  1028                 return SOCKERR_NOTCONNECTED;

  1029             }

  1030 

  1031             /* some other error occured so look it up and return */

  1032             return convertError(rc);

  1033         }

  1034 

  1035         /*

  1036          * if we get here the timeout expired or the connect had not yet

  1037          * completed just indicate that the connect is not yet complete

  1038          */

  1039         return SOCKERR_NOTCONNECTED;

  1040     } else if (SOCKET_STEP_DONE == step) {

  1041         /* we are done the connect or an error occured so clean up  */

  1042         if (handle != -1) {

  1043             int block = JNI_FALSE;

  1044             ioctl(handle, FIONBIO, &block);

  1045         }

  1046         return 0;

  1047     }

  1048     return SOCKERR_ARGSINVALID;

  1049 }

  1050 

  1051 /**

  1052  * Join/Leave the nominated multicast group on the specified socket.

  1053  * Implemented by setting the multicast 'add membership'/'drop membership'

  1054  * option at the HY_IPPROTO_IP level on the socket.

  1055  *

  1056  * Implementation note for multicast sockets in general:

  1057  *

  1058  * - This code is untested, because at the time of this writing multicast can't

  1059  * be properly tested on Android due to GSM routing restrictions. So it might

  1060  * or might not work.

  1061  *

  1062  * - The REUSEPORT socket option that Harmony employs is not supported on Linux

  1063  * and thus also not supported on Android. It's is not needed for multicast

  1064  * to work anyway (REUSEADDR should suffice).

  1065  *

  1066  * @param env pointer to the JNI library.

  1067  * @param socketP pointer to the hysocket to join/leave on.

  1068  * @param optVal pointer to the InetAddress, the multicast group to join/drop.

  1069  *

  1070  * @exception SocketException if an error occurs during the call

  1071  */

  1072 static void mcastAddDropMembership (JNIEnv * env, int handle, jobject optVal,

  1073         int ignoreIF, int setSockOptVal) {

  1074     int result;

  1075     struct ip_mreq ipmreqP;

  1076     struct sockaddr_in sockaddrP;

  1077     int length = sizeof(struct ip_mreq);

  1078     socklen_t lengthIF = sizeof(struct sockaddr_in);

  1079 

  1080     /*

  1081      * JNI objects needed to access the information in the optVal oject

  1082      * passed in. The object passed in is a GenericIPMreq object

  1083      */

  1084     jclass cls;

  1085     jfieldID multiaddrID;

  1086     jfieldID interfaceAddrID;

  1087     jobject multiaddr;

  1088     jobject interfaceAddr;

  1089 

  1090     /*

  1091      * check whether we are getting an InetAddress or an Generic IPMreq, for now

  1092      * we support both so that we will not break the tests

  1093      */

  1094     if (env->IsInstanceOf (optVal, gCachedFields.iaddr_class)) {

  1095 

  1096         ipmreqP.imr_interface.s_addr = htonl(INADDR_ANY);

  1097         if (!ignoreIF) {

  1098 

  1099             result = getsockopt(handle, IPPROTO_IP, IP_MULTICAST_IF, &sockaddrP,

  1100                     &lengthIF);

  1101 

  1102             if (0 != result) {

  1103                 throwSocketException (env, convertError(errno));

  1104                 return;

  1105             }

  1106 

  1107             memcpy(&(ipmreqP.imr_interface.s_addr), &(sockaddrP.sin_addr), 4);

  1108         }

  1109 

  1110         result = inetAddressToSocketAddress(env, optVal, 0, &sockaddrP);

  1111 

  1112         if (result < 0) {

  1113             throwSocketException(env, SOCKERR_BADSOCKET);

  1114             return;

  1115         }

  1116 

  1117         memcpy(&(ipmreqP.imr_multiaddr.s_addr), &(sockaddrP.sin_addr), 4);

  1118 

  1119         result = setsockopt(handle, IPPROTO_IP, setSockOptVal, &ipmreqP, length);

  1120         if (0 != result) {

  1121             throwSocketException (env, convertError(errno));

  1122             return;

  1123         }

  1124 

  1125     } else {

  1126 

  1127         /* we need the multicast address regardless of the type of address */

  1128         cls = env->GetObjectClass(optVal);

  1129         multiaddrID = env->GetFieldID(cls, "multiaddr", "Ljava/net/InetAddress;");

  1130         multiaddr = env->GetObjectField(optVal, multiaddrID);

  1131 

  1132         result = inetAddressToSocketAddress(env, multiaddr, 0, &sockaddrP);

  1133 

  1134         if (result < 0) {

  1135             throwSocketException(env, SOCKERR_BADSOCKET);