getsockopt on OSX returns incorrect value?

Question

I am using following program to debug a larger issue.

Now if I run same program on OSX, getopt never returns me 0 or 1, it always returns whatever value for optval I have set!!

There must be something obviously wrong in my program that is escaping me.

Example I have run this program as ./a.out 64.233.160.105

./a.out 64.233.160.105
getsockopt: Undefined error: 0
getsockopt returned 0 SO_REUSEPORT -> 199
setsockopt reuseport: Undefined error: 0
set ret = 0 SO_REUSEPORT -> 1
setsockopt linger: Undefined error: 0
set ret = 0 SO_LINGER -> 0
getsockopt: Undefined error: 0
getsockopt returned 0 SO_REUSEPORT -> 99
sendto: Undefined error: 0
send to sent 11 bytes

Here is the sample program I am using.

/* Sample UDP client */

#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <memory.h>
#include <arpa/inet.h>

int main(int argc, char **argv)
{
    int sockfd, n;
    struct sockaddr_in servaddr, cliaddr;
    char *sendline = "Hello World";
    char recvline[1000];
    int ret;
    extern int errno;
    uint32_t optval;
    socklen_t optlen;
    struct linger linger_opt;

    if (argc != 2) {
    printf("usage:  udpcli <IP address>\n");
    exit(1);
    }

    sockfd = socket(AF_INET, SOCK_DGRAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = inet_addr(argv[1]);
    servaddr.sin_port = htons(4500);

    errno = 0;
    optval = 199;
    ret = getsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, &optval,
           (socklen_t *) & optlen);
    perror("getsockopt");
    printf("getsockopt returned %d SO_REUSEPORT -> %d\n", ret, optval);

    errno = 0;
    optval = 1;
    ret = setsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof(optval));
    perror("setsockopt reuseport");
    printf("set ret = %d SO_REUSEPORT -> %d\n", ret, optval);

    errno = 0;
    optval = 0;
    linger_opt.l_onoff = 0;
    linger_opt.l_linger = 0;
    ret = setsockopt(sockfd, SOL_SOCKET, SO_LINGER, &linger_opt, sizeof(linger_opt));
    perror("setsockopt linger");
    printf("set ret = %d SO_LINGER -> %d\n", ret, optval);

    optval = 99;
    errno = 0;
    ret = getsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, &optval, &optlen);
    perror("getsockopt");
    printf("getsockopt returned %d SO_REUSEPORT -> %d\n", ret, optval);

    errno = 0;
    ret = sendto(sockfd, sendline, strlen(sendline), 0,
         (struct sockaddr *) &servaddr, sizeof(servaddr));
    perror("sendto");
    printf("send to sent %d bytes \n",ret);
    close(sockfd);
}

Answer 1

Recently I ran into the same problem.

Bug: The culprit was "sizeof". Sizeof is an operator that returns a constant int that gives the size of any given data element.The fifth argument of the setsockopt 'socklen_t *optlen' requires a value of type socklen_t. Eventhough socklen_t and int are used interchangeably most of the times. Such use can cause errors that are difficult to trace just like it did here.

ret = setsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof(optval));

Even though the setsockopt doesn't return an error or failure, the socket options are never actually set because of the usage of 'sizeof(optval)'. That is why the getsockopt was not able to return the changed value.

Fix: 1.assign size of optvalue to optlen. optlen= sizeof(optval); 2.set socket options with optlen as 5th argument. ret = setsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, &optval, optlen);

This fix worked for me on Linux with a gcc compiler. Hope it helps others.