Android LocalServerSocket

后端未结

关注

 4  1516

In android, there are two classes LocalServerSocket and LocalSocket. I think they are something like AF_LOCAL in unix socket (I am not sure it is correct or not).

My que

相关标签:

4条回答

死守一世寂寞

2021-02-02 02:15
Thanks for the answers here. Piecing people's responses together, the things to be careful about are

On the native side:
1. the name of the socket must have a 0-byte value as the first character
2. The linux man page is right in that 0 bytes are NOT treated as a null terminator.
3. The man page is not clear in its meaning when it states that "the rest of the bytes in sunpath" are used. "Rest of bytes" is determined by the length passed in for sockaddr_len and Android sets this per the recommended file-system sockets of sizeof(sa_family_t) + strlen(sun_path) + 1. This is important when making calls to bind, connect, etc!
On the Java side:

Android defines the conventions it uses under the covers but are consistent with above.
0 讨论(0)
发布评论:

提交评论
- 加载中...

庸人自扰

2021-02-02 02:19

The following code might not be perfect but it works !!! Thanks for Mike.

Java part (Socket Server) :

package test.socket;

import java.io.IOException;
import java.io.InputStream;

import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.content.Intent;
import android.net.LocalServerSocket;
import android.net.LocalSocket;
import android.net.LocalSocketAddress;
import android.os.Bundle;
import android.util.Log;
import android.view.View;

public class TestSocketActivity extends Activity {

    public static String SOCKET_ADDRESS = "/test/socket/localServer";
    public String TAG = "Socket_Test";


    static{System.loadLibrary("testSocket");}
    private native void clientSocketThreadNative();
    private native void setStopThreadNative();
    localSocketServer mLocalSocketServer;
    localSocketClient mLocalSocketClient;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mLocalSocketServer = new localSocketServer();

        mLocalSocketClient = new localSocketClient();
    }

    /* LocalSocketServer */
    public class localSocketServer extends Thread {

        int bufferSize = 32;
        byte[] buffer;
        int bytesRead;
        int totalBytesRead;
        int posOffset;
        LocalServerSocket server;
        LocalSocket receiver;
        InputStream input;
        private volatile boolean stopThread;

        public localSocketServer() {
            Log.d(TAG, " +++ Begin of localSocketServer() +++ ");
            buffer = new byte[bufferSize];
            bytesRead = 0;
            totalBytesRead = 0;
            posOffset = 0;

            try {
                server = new LocalServerSocket(SOCKET_ADDRESS);
            } catch (IOException e) {
                // TODO Auto-generated catch block
                Log.d(TAG, "The localSocketServer created failed !!!");
                e.printStackTrace();
            }

             LocalSocketAddress localSocketAddress; 
             localSocketAddress = server.getLocalSocketAddress();
             String str = localSocketAddress.getName();

             Log.d(TAG, "The LocalSocketAddress = " + str);

            stopThread = false;
        }

        public void run() {             
            Log.d(TAG, " +++ Begin of run() +++ ");
                while (!stopThread) {

                    if (null == server){
                        Log.d(TAG, "The localSocketServer is NULL !!!");
                        stopThread = true;
                        break;
                    }

                    try {
                        Log.d(TAG, "localSocketServer begins to accept()");
                        receiver = server.accept();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        Log.d(TAG, "localSocketServer accept() failed !!!");
                        e.printStackTrace();
                        continue;
                    }                   

                    try {
                        input = receiver.getInputStream();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        Log.d(TAG, "getInputStream() failed !!!");
                        e.printStackTrace();
                        continue;
                    }

                    Log.d(TAG, "The client connect to LocalServerSocket");

                    while (receiver != null) {

                        try {
                            bytesRead = input.read(buffer, posOffset,
                                    (bufferSize - totalBytesRead));
                        } catch (IOException e) {
                            // TODO Auto-generated catch block
                            Log.d(TAG, "There is an exception when reading socket");
                            e.printStackTrace();
                            break;
                        }

                        if (bytesRead >= 0) {
                            Log.d(TAG, "Receive data from socket, bytesRead = "
                                    + bytesRead);
                            posOffset += bytesRead;
                            totalBytesRead += bytesRead;
                        }

                        if (totalBytesRead == bufferSize) {
                            Log.d(TAG, "The buffer is full !!!");
                            String str = new String(buffer);
                            Log.d(TAG, "The context of buffer is : " + str);

                            bytesRead = 0;
                            totalBytesRead = 0;
                            posOffset = 0;
                        }

                    }
                    Log.d(TAG, "The client socket is NULL !!!");
                }
                Log.d(TAG, "The LocalSocketServer thread is going to stop !!!");
                if (receiver != null){
                    try {
                        receiver.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                if (server != null){
                    try {
                        server.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
        }

        public void setStopThread(boolean value){
            stopThread = value;
            Thread.currentThread().interrupt(); // TODO : Check
        }

    }

    /* Client native socket */
    public class localSocketClient extends Thread {

        private volatile boolean stopThread;

        public localSocketClient(){
            Log.d(TAG, " +++ Begin of localSocketClient() +++ ");
            stopThread = false;
        }

        public void run(){
            Log.d(TAG, " +++ Begin of run() +++ ");
            while(!stopThread){
                clientSocketThreadNative();
            }
        }

        public void setStopThread(boolean value){
            stopThread = value;
            setStopThreadNative();
            Thread.currentThread().interrupt(); // TODO : Check
        }
    }


    public void bt_startServerOnClick(View v) {
        mLocalSocketServer.start();
    }

    public void bt_startClientOnClick(View v) {
        mLocalSocketClient.start();
    }

    public void bt_stopOnClick(View v) {
        mLocalSocketClient.setStopThread(true);
        mLocalSocketServer.setStopThread(true);
    }

}

Native C part (Client)

#include <stdlib.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/un.h>


#include "test_socket_TestSocketActivity.h"

#define LOCAL_SOCKET_SERVER_NAME "/test/socket/localServer"

volatile int stopThread;

#ifndef __JNILOGGER_H_
#define __JNILOGGER_H_ 
#include <android/log.h> 
#ifdef __cplusplus
extern "C" {
#endif
#ifndef LOG_TAG
#define LOG_TAG "NativeSocket"
#endif
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG,LOG_TAG,__VA_ARGS__)
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
#define LOGW(...) __android_log_print(ANDROID_LOG_WARN,LOG_TAG,__VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
#define LOGF(...) __android_log_print(ANDROID_LOG_FATAL,LOG_TAG,__VA_ARGS__)
#define LOGS(...) __android_log_print(ANDROID_LOG_SILENT,LOG_TAG,__VA_ARGS__)
#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE,LOG_TAG,__VA_ARGS__)
#ifdef __cplusplus
}
#endif
#endif /* __JNILOGGER_H_ */ 


JNIEXPORT void JNICALL Java_test_socket_TestSocketActivity_clientSocketThreadNative
  (JNIEnv *env, jobject object){

    LOGD("In clientSocketThreadNative() : Begin");

    stopThread = 0;

    int sk, result;
    int count = 1;
    int err;

    char *buffer = malloc(8);

    int i;
    for(i = 0; i<8; i++){
        buffer[i] = (i+1);
    }

    struct sockaddr_un addr;
    socklen_t len;
    addr.sun_family = AF_LOCAL;
    /* use abstract namespace for socket path */
    addr.sun_path[0] = '\0';
    strcpy(&addr.sun_path[1], LOCAL_SOCKET_SERVER_NAME );
    len = offsetof(struct sockaddr_un, sun_path) + 1 + strlen(&addr.sun_path[1]);

    LOGD("In clientSocketThreadNative() : Before creating socket");
    sk = socket(PF_LOCAL, SOCK_STREAM, 0);
    if (sk < 0) {
        err = errno;
        LOGD("%s: Cannot open socket: %s (%d)\n",
            __FUNCTION__, strerror(err), err);
        errno = err;
        return;
    }

    LOGD("In clientSocketThreadNative() : Before connecting to Java LocalSocketServer");
    if (connect(sk, (struct sockaddr *) &addr, len) < 0) {
        err = errno;
        LOGD("%s: connect() failed: %s (%d)\n",
            __FUNCTION__, strerror(err), err);
        close(sk);
        errno = err;
        return;
    }

    LOGD("In clientSocketThreadNative() : Connecting to Java LocalSocketServer succeed");
    while(!stopThread){
        result = write(sk, buffer, 8);
        LOGD("In clientSocketThreadNative() : Total write = %d", result);
        count++;
        if(4 == count){
            sleep(1);
            count = 0;
        } 
    }


    LOGD("In clientSocketThreadNative() : End");
}


JNIEXPORT void JNICALL Java_test_socket_TestSocketActivity_setStopThreadNative
  (JNIEnv *env, jobject object){

    stopThread = 1;

}

0 讨论(0)

攒了一身酷

2021-02-02 02:21
Looking at local_socket_client.c in the Android source, it looks like they do this:
```
int socket_make_sockaddr_un(const char *name, int namespaceId, 
        struct sockaddr_un *p_addr, socklen_t *alen)
{
    memset (p_addr, 0, sizeof (*p_addr));
    size_t namelen;

    switch (namespaceId) {
        case ANDROID_SOCKET_NAMESPACE_ABSTRACT:
            namelen  = strlen(name);

            // Test with length +1 for the *initial* '\0'.
            if ((namelen + 1) > sizeof(p_addr->sun_path)) {
                goto error;
            }

            /*
             * Note: The path in this case is *not* supposed to be
             * '\0'-terminated. ("man 7 unix" for the gory details.)
             */

            p_addr->sun_path[0] = 0;
            memcpy(p_addr->sun_path + 1, name, namelen);

            ...
    p_addr->sun_family = AF_LOCAL;
    *alen = namelen + offsetof(struct sockaddr_un, sun_path) + 1;
```
It seems like the memset() is important because the entire sun_path is relevant. (looks like you cover that part with your structure initialization, though.) And it's not "0" plus the original name, it's an actual zero byte! (its value is all binary zeroes, not an ascii '0')

Try following more closely what they're doing, including the leading '\0' byte and the AF_LOCAL family.

If you have updated code (whether it works or not) please post it! I'm interested in your results. Did you ever get this to work?

If it doesn't work, find out what errno is and either call perror() to print it to stderr, or call strerror() and log the output. Let us know what error you get.

Edit

I recently solved this problem in a project of my own. I found that the key was to specify the correct length when calling connect() and bind(). In the code I posted above, it calculates the length by using the offset of the sun_path in the structure, plus the length of the name, plus one for the leading '\0' byte. If you specify any other length, Java code might not be able to connect to the socket.
0 讨论(0)
发布评论:

提交评论
- 加载中...

萌比男神i

2021-02-02 02:28

Confirmed that the above works properly. The following examples will not only work together, but will work with the corresponding Android LocalSocket and LocalServerSocket classes:

Client side (Android is server using LocalServerSocket):

#include <stdio.h>      /* for printf() and fprintf() */
#include <sys/socket.h> /* for socket(), connect(), send(), and recv() */
#include <sys/un.h>     /* struct sockaddr_un */
#include <stdlib.h>     /* for atoi() and exit() */
#include <string.h>     /* for memset() */
#include <unistd.h>     /* for close() */
#include <errno.h>
#include <stddef.h>

#define RCVBUFSIZE 2048   /* Size of receive buffer */

void DieWithError(char *errorMessage)  /* Error handling function */
{
    fprintf(stderr, "Error: %s - %s\n", errorMessage, strerror(errno));
    exit(errno);
}

int main(int argc, char *argv[])
{
    int sock;                        /* Socket descriptor */
    struct sockaddr_un echoServAddr; /* Echo server address */
    unsigned char *localSocketName = "MyTestSocket";
    static unsigned char echoString[] = {0x80, 0x00, 0x0e, 0x10, 0x00, 0x9c, 0x40, 0xc9, 0x20, 0x20, 0x20, 0x32, 0x00, 0x00};
    static unsigned int echoStringLen = sizeof(echoString); /* Length of string to echo */
    unsigned char echoBuffer[RCVBUFSIZE]; /* Buffer for echo string */
    int bytesRcvd, totalBytesRcvd;   /* Bytes read in single recv() 
                                    and total bytes read */
    int size;
    int i;

    /* Create a reliable, stream socket using Local Sockets */
    if ((sock = socket(PF_LOCAL, SOCK_STREAM, 0)) < 0)
        DieWithError("socket() failed");

    /* Construct the server address structure */
    memset(&echoServAddr, 0, sizeof(echoServAddr));     /* Zero out structure */
    echoServAddr.sun_family      = AF_LOCAL;            /* Local socket address family */
    /**
     * Tricky and obscure! For a local socket to be in the "Android name space":
     * - The name of the socket must have a 0-byte value as the first character
     * - The linux man page is right in that 0 bytes are NOT treated as a null terminator.
     * - The man page is not clear in its meaning when it states that "the rest of the bytes in
     *        sunpath" are used. "Rest of bytes" is determined by the length passed in for
     *        sockaddr_len and Android sets this per the recommended file-system sockets of
     *        sizeof(sa_family_t) + strlen(sun_path) + 1. This is important when making calls
     *        to bind, connect, etc!
     * We have initialized the struct sockaddr_un to zero already, so all that is needed is to
     * begin the name copy at sun_path[1] and restrict its length to sizeof(echoServAddr.sun_path)-2
     **/
    strncpy(echoServAddr.sun_path + 1, localSocketName, sizeof(echoServAddr.sun_path) - 2); 
    size = sizeof(echoServAddr) - sizeof(echoServAddr.sun_path) + strlen(echoServAddr.sun_path+1) + 1;

    /* Establish the connection to the echo server */
    if (connect(sock, (struct sockaddr *) &echoServAddr, size) < 0)
        DieWithError("connect() failed");

    /* Send the string to the server */
    if (send(sock, echoString, echoStringLen, 0) != echoStringLen)
        DieWithError("send() sent a different number of bytes than expected");

    /* Receive the same string back from the server */
    totalBytesRcvd = 0;
    printf("Sent:     ");
    for (i = 0; i < echoStringLen; i++)
        printf("%02X ", echoString[i]);
    printf("\n");    /* Print a final linefeed */

    printf("Received: ");                /* Setup to print the echoed string */
    if ((bytesRcvd = recv(sock, echoBuffer, RCVBUFSIZE - 1, 0)) <= 0)
        DieWithError("recv() failed or connection closed prematurely");
    for (i = 0; i < bytesRcvd; i++)
        printf("%02X ", echoBuffer[i]);
    printf("\n");    /* Print a final linefeed */

    close(sock);
    exit(0);
}

Server side (Android is client using LocalSocket):

#include <stdio.h>      /* for printf() and fprintf() */
#include <sys/socket.h> /* for socket(), connect(), send(), and recv() */
#include <sys/un.h>     /* struct sockaddr_un */
#include <stdlib.h>     /* for atoi() and exit() */
#include <string.h>     /* for memset() */
#include <unistd.h>     /* for close() */
#include <errno.h>
#include <stddef.h>

#define RCVBUFSIZE 2048   /* Size of receive buffer */

void DieWithError(char *errorMessage)  /* Error handling function */
{
    fprintf(stderr, "Error: %s - %s\n", errorMessage, strerror(errno));
    exit(errno);
}

void HandleLocalClient(int clntSocket)
{
    char echoBuffer[RCVBUFSIZE];        /* Buffer for echo string */
    int recvMsgSize;                    /* Size of received message */

    /* Receive message from client */
    if ((recvMsgSize = recv(clntSocket, echoBuffer, RCVBUFSIZE, 0)) < 0)
        DieWithError("recv() failed");

    /* Send received string and receive again until end of transmission */
    while (recvMsgSize > 0)      /* zero indicates end of transmission */
    {
        /* Echo message back to client */
        if (send(clntSocket, echoBuffer, recvMsgSize, 0) != recvMsgSize)
            DieWithError("send() failed");

        /* See if there is more data to receive */
        if ((recvMsgSize = recv(clntSocket, echoBuffer, RCVBUFSIZE, 0)) < 0)
            DieWithError("recv() failed");
    }

    close(clntSocket);    /* Close client socket */
}

#define MAXPENDING 5    /* Maximum outstanding connection requests */

void DieWithError(char *errorMessage);  /* Error handling function */
void HandleLocalClient(int clntSocket);   /* TCP client handling function */

int main(int argc, char *argv[])
{
    int servSock;                    /* Socket descriptor for server */
    int clntSock;                    /* Socket descriptor for client */
    struct sockaddr_un echoClntAddr; /* Client address */
    unsigned int clntLen;            /* Length of client address data structure */
    struct sockaddr_un echoServAddr; /* Echo server address */
    unsigned char *localSocketName = "MyTestSocket";
    static unsigned int echoStringLen = 14;      /* Length of string to echo */
    unsigned char echoBuffer[RCVBUFSIZE];     /* Buffer for echo string */
    int bytesRcvd, totalBytesRcvd;   /* Bytes read in single recv() 
                                    and total bytes read */
    int size;
    int i;

    /* Create a reliable, stream socket using Local Sockets */
    if ((servSock = socket(PF_LOCAL, SOCK_STREAM, 0)) < 0)
        DieWithError("socket() failed");

    /* Construct the server address structure */
    memset(&echoServAddr, 0, sizeof(echoServAddr));     /* Zero out structure */
    echoServAddr.sun_family      = AF_LOCAL;            /* Local socket address family */
    /**
     * Tricky and obscure! For a local socket to be in the "Android name space":
     * - The name of the socket must have a 0-byte value as the first character
     * - The linux man page is right in that 0 bytes are NOT treated as a null terminator.
     * - The man page is not clear in its meaning when it states that "the rest of the bytes in
     *        sunpath" are used. "Rest of bytes" is determined by the length passed in for
     *        sockaddr_len and Android sets this per the recommended file-system sockets of
     *        sizeof(sa_family_t) + strlen(sun_path) + 1. This is important when making calls
     *        to bind, connect, etc!
     * We have initialized the struct sockaddr_un to zero already, so all that is needed is to
     * begin the name copy at sun_path[1] and restrict its length to sizeof(echoServAddr.sun_path)-2
     **/
    strncpy(echoServAddr.sun_path + 1, localSocketName, sizeof(echoServAddr.sun_path) - 2); 
    size = sizeof(echoServAddr) - sizeof(echoServAddr.sun_path) + strlen(echoServAddr.sun_path+1) + 1;

    /* Bind to the local address */
    if (bind(servSock, (struct sockaddr *) &echoServAddr, size) < 0)
        DieWithError("bind() failed");

    /* Mark the socket so it will listen for incoming connections */
    if (listen(servSock, MAXPENDING) < 0)
        DieWithError("listen() failed");

    for (;;) /* Run forever */
    {
        /* Set the size of the in-out parameter */
        clntLen = sizeof(echoClntAddr);

        /* Wait for a client to connect */
        if ((clntSock = accept(servSock, (struct sockaddr *) &echoClntAddr, &clntLen)) < 0)
            DieWithError("accept() failed");

        /* clntSock is connected to a client! */

        printf("Handling client\n");

        HandleLocalClient(clntSock);
    }
    /* NOT REACHED */
    return 0;
}

Tested with Android 4.0.3 ICS 03/15

0 讨论(0)