套接字创建失败，但socket（）和bind（）方法不返回-1

Question

I working on network security based ios app. I am trying to create a local socket for communication between threads. I am doing this with the use of C language in ios app.

The problem is when I am creating and binding socket it does not gives any error. But when I try to send some data over this socket it fails. Code for create and bind of socket is as follows:

int open_and_bind_socket(int *sockfd, const char *sname)
{
  //sname is socket name with full path
    size_t len = strlen (sname);

    size_t bytes = sizeof (struct sockaddr_un) + len + 1 - sizeof (((struct sockaddr_un *)0)->sun_path);

    struct sockaddr_un *unaddr = (struct sockaddr_un *)malloc (bytes);

     size_t size;

    if((*sockfd = socket (AF_LOCAL, SOCK_DGRAM, 0)) < 0)
    {
        AGENT_DEBUG(LOG_ERR, "%s", "Failed to open socket");
        return ~0;
    }

    unaddr->sun_family = AF_UNIX;
    unaddr->sun_len = bytes;
    memcpy(unaddr->sun_path, sname,len+1);

    size = (offsetof (struct sockaddr_un, sun_path)
                + strlen (unaddr->sun_path));

    if( bind(*sockfd,(struct sockaddr*)unaddr,size ) < 0)
    {
        AGENT_DEBUG(LOG_ERR, "%s", "Failed to bind the socket");
        AGENT_DEBUG(LOG_ERR, "Recvfrom MSG_PEEK Failure: %s, Socket Fd = %d\n",
                    strerror(errno), sockfd);
        return ~0;
    }

    if(0 != chmod(sname, 0666))
    {
        AGENT_DEBUG(LOG_ERR, "%s", "Unable to chmod Socket");
        return ~0;
    }
     //unlink(sname);
    return 0;
}

The code for sending data on socket is as follows:

int data_send(int sockfd, tsIpcMsg *pMsgData)
{
    memset(x,'\0', sizeof(x));
    strcpy(x, buffer);
    strcat(x,"/AGENTSOCKET");
    size_t len = strlen (x);

    size_t bytes = sizeof (struct sockaddr_un) + len + 1 - sizeof (((struct sockaddr_un *)0)->sun_path);

    struct sockaddr_un *saun = (struct sockaddr_un *)malloc (bytes);

    memset(saun, 0, sizeof(*saun));
    saun->sun_family = AF_UNIX;    
    saun->sun_len=bytes;
    memcpy(saun->sun_path, x,len+1);
    memset(x,'\0', sizeof(x));

    if(-1 == (sendto(sockfd,(void*)pMsgData, sizeof(tsIpcMsg)+pMsgData->dataLen , 0, (struct sockaddr *)saun, sizeof(*saun))))
   {
        AGENT_DEBUG(LOG_ERR, "%s", "Failed to send message from thread to main");
        return ~0;
    }
    return 0;
}

When I log the errno returned by sendto() function it gives value '2' which means "No such file or directory exists: A component in pathname does not exist or is a dangling symbolic link, or pathname is empty."

So, I think the socket is not getting created properly that's why sendto() method fails, while the socket and bind method does not give any error.

I am running this app on ios simulator(iPhone 7 plus). The path to the socket is as follows: "/Users/Admin/Library/Developer/CoreSimulator/Devices/FC85979F-A627-4361-B4BD-DD794AB009C9/data/Containers/Data/Application/C45B9A05-F482-4011-8EA0-947A8C489367/Documents/app/AGENTSOCKET", where AGENTSOCKET is the name of the socket.

I am creating directory structure till app folder and then appending the socket name to it while creating socket in the following manner:

mkdir(path,0777);//path is till app directory
strcat(path, "/AGENTSOCKET");

Can anyone help me to fix this out.

Thanks.

Answer 1

The sun_path field is limited to anywhere from 92-108 characters (depending on platform), including the null terminator. The x string you have shown for data_send() is 185 characters without a null terminator. So, if it is getting truncated, that could account for the ENOENT error you are getting.

That being said, you are calculating the size of sockaddr_un incorrectly, and passing the wrong address size to bind() and sendto() . Also, open_and_bind_socket() and data_send() are leaking memory.

Try something more like this instead:

int open_and_bind_socket(int *sockfd, const char *sname)
{
    *sockfd = -1;

    //sname is socket name with full path
    size_t len = strlen (sname);

    size_t size = offsetof (struct sockaddr_un, sun_path) + len + 1;

    struct sockaddr_un *unaddr = (struct sockaddr_un *) malloc (size);
    if (!unaddr)
    {
        AGENT_DEBUG(LOG_ERR, "%s", "Failed to allocate memory\n");
        return ~0;
    }

    memset(unaddr, 0, size);
    unaddr->sun_family = AF_UNIX;
    memcpy(unaddr->sun_path, sname, len);
    unaddr->sun_len = SUN_LEN(unaddr);

    int sock = socket (AF_LOCAL, SOCK_DGRAM, 0);
    if (sock < 0)
    {
        AGENT_DEBUG(LOG_ERR, "%s", "Failed to create socket: %s\n", strerror(errno));
        free(unaddr);
        return ~0;
    }

    if (bind(sock, (struct sockaddr*)unaddr, unaddr->sun_len) < 0)
    {
        AGENT_DEBUG(LOG_ERR, "%s", "Failed to bind the socket: %s\n", strerror(errno));
        close(sock);
        free(unaddr);
        return ~0;
    }

    if (0 != chmod(sname, 0666))
    {
        AGENT_DEBUG(LOG_ERR, "%s", "Unable to chmod socket: %s\n", strerror(errno));
        close(sock);
        free(unaddr);
        return ~0;
    }

    free(unaddr);

    //unlink(sname);

    *sockfd = sock;

    return 0;
}

int data_send(int sockfd, tsIpcMsg *pMsgData)
{
    // this is a buffer overflow waiting to happen!
    memset(x, '\0', sizeof(x));
    strcpy(x, buffer);
    strcat(x, "/AGENTSOCKET");

    size_t len = strlen (x);

    size_t size = offsetof (struct sockaddr_un, sun_path) + len + 1;

    struct sockaddr_un *saun = (struct sockaddr_un *) malloc (size);
    if (!saun)
    {
        AGENT_DEBUG(LOG_ERR, "%s", "Failed to allocate memory\n");
        return ~0;
    }

    memset(saun, 0, size);
    saun->sun_family = AF_UNIX;    
    memcpy(saun->sun_path, x, len);
    saun->sun_len = SUN_LEN(saun);

    if (sendto(sockfd, (void*)pMsgData, sizeof(tsIpcMsg) + pMsgData->dataLen, 0, (struct sockaddr *)saun, saun->sun_len) < 0)
    {
        AGENT_DEBUG(LOG_ERR, "%s", "Failed to send message from thread to main: %s\n", strerror(errno));
        free(saun);
        return ~0;
    }

    free(saun);
    return 0;
}

Alternatively, you do not need to dynamically allocate the sockaddr_un at all:

int open_and_bind_socket(int *sockfd, const char *sname)
{
    *sockfd = -1;

    struct sockaddr_un unaddr;

    memset(&unaddr, 0, sizeof(unaddr));
    unaddr.sun_family = AF_UNIX;
    strncpy(unaddr.sun_path, sname, sizeof(unaddr.sun_path)-1);
    unaddr.sun_len = SUN_LEN(&unaddr);

    int sock = socket (AF_LOCAL, SOCK_DGRAM, 0);
    if (sock < 0)
    {
        AGENT_DEBUG(LOG_ERR, "%s", "Failed to create socket: %s\n", strerror(errno));
        return ~0;
    }

    if (bind(sock, (struct sockaddr*) &unaddr, unaddr.sun_len) < 0)
    {
        AGENT_DEBUG(LOG_ERR, "%s", "Failed to bind the socket: %s\n", strerror(errno));
        close(sock);
        return ~0;
    }

    if (0 != chmod(sname, 0666))
    {
        AGENT_DEBUG(LOG_ERR, "%s", "Unable to chmod socket: %s\n", strerror(errno));
        close(sock);
        return ~0;
    }

    //unlink(sname);

    *sockfd = sock;

    return 0;
}

int data_send(int sockfd, tsIpcMsg *pMsgData)
{
    // this is a buffer overflow waiting to happen!
    memset(x, '\0', sizeof(x));
    strcpy(x, buffer);
    strcat(x, "/AGENTSOCKET");

    struct sockaddr_un saun;

    memset(&saun, 0, sizeof(saun));
    saun.sun_family = AF_UNIX;    
    strncpy(saun.sun_path, x, sizeof(saun.sun_path)-1);
    // alternatively this is safer:
    // snprintf(saun.sun_path, sizeof(saun.sun_path), "%s/AGENTSOCKET", buffer); 
    saun.sun_len = SUN_LEN(&saun);

    if (sendto(sockfd, (void*)pMsgData, sizeof(*pMsgData) + pMsgData->dataLen, 0, (struct sockaddr *) &saun, saun.sun_len) < 0)
    {
        AGENT_DEBUG(LOG_ERR, "%s", "Failed to send message from thread to main: %s\n", strerror(errno));
        return ~0;
    }

    return 0;
}