datagram + write size limit

write.c

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <netdb.h>
#include <string.h>
#include <errno.h>

ssize_t getSndBufSize(sockfd)
{
    int size;
    int valSize = sizeof(size);
    ssize_t res = getsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, (void*)&size, (socklen_t*)&valSize);

    if (res == 0)
    {
        res = size;
    } 
}
int main(int argc, char **argv)
{
    int sock = socket(AF_INET, SOCK_DGRAM, 0);

    if (sock > 0)
    {
        ssize_t maxSize = getSndBufSize(sock);
        
        printf("max size: %d\n", maxSize);

        if (maxSize < 0)
        {
            perror(NULL);
            return 2;
        }

        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(6585);
        
        struct hostent *server = gethostbyname("127.0.0.1");
        memcpy((char *)&addr.sin_addr.s_addr, (char *)server->h_addr, server->h_length);

        int ret = connect(sock, (const struct sockaddr*)&addr, sizeof(addr));

        if (ret == 0)
        {
            printf("connected\n");

            const ssize_t writeSize = atoi(argv[1]);

            char bigdata[writeSize];

            memset(bigdata, '0', writeSize);

            ssize_t size = 0;
            while(size != writeSize)
            {
                ssize_t ret = write(sock, &bigdata[size], writeSize-size);

                if (ret == EFBIG || ret == ENOSPC)
                {
                    return 1;
                }
                else if (ret < 0)
                {
                    printf("ret: %d\n", ret);
                    perror(NULL);
                    return ret;
                }
                else
                {
                    size += ret;
                }

                printf("write: %d\n", size);
                sleep(1);
            }
        }
    }

    return 0;
}