AF_UNIX/SOCK_DGRAM is dropping messages

[Kristian Ivarsson via Cygwin]

Hi all

Using AF_UNIX/SOCK_DGRAM with current version (3.2.0) seems to drop messages or 
at least they are not received in the same order they are sent

Attached C:ish (with C++ threads though) sample program that essentially 
creates a "client" that writes as much as possible and a "server" that consumes 
as much as possible

It seems like some buffer is filled and then messages are dropped (or at least 
it appears so) (if someone is about to test this, the "sleep" might need to be 
adjusted in order to make this happen)

Hopefully it's just a flaw in our application (and sample), but as far as we 
can see, this should work


Does anyone, perhaps named Ken, have any insightful thoughts about this ?


Best regards,
Kristian

#include <sys/socket.h>
#include <sys/un.h>

#include <unistd.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <thread>
#include <chrono>


// $ g++ --std=gnu++17 af_unix.cpp

const char* const path = "address";
const int count = 1000;
const int size = BUFSIZ * 2;

int client()
{
    const int fd = socket( AF_UNIX, SOCK_DGRAM, 0);

    if( fd == -1)
    {
        perror( "socket error");
        return -1;
    }

    struct sockaddr_un address{};

    strcpy( address.sun_path, path);
    address.sun_family = AF_UNIX;

    char buffer[size] = {};

    for( int idx = 0; idx < count; ++idx)
    {
        memcpy( buffer, &idx, sizeof idx);

        const ssize_t result = sendto( fd, buffer, size, 0, (struct 
sockaddr*)&address, sizeof address);

        if( result == -1)
        {
            perror( "sendto error");
            return -1;
        }
    }

    close( fd);
    return 0;
}

int server()
{
    const int fd = socket( AF_UNIX, SOCK_DGRAM, 0);

    if( fd == -1)
    {
        perror( "socket error");
        return -1;
    }

    struct sockaddr_un address{};

    strcpy( address.sun_path, path);
    address.sun_family = AF_UNIX;

    const int result = bind( fd, (struct sockaddr*)&address, sizeof address);

    if( result == -1)
    {
        perror( "bind error");
        return -1;
    }

    return fd;
}

int main( int argc, char* argv[])
{
    const int fd = server( );

    if( fd != -1)
    {
        fprintf( stdout, "%d\tnumber of packages\n", count);
        fprintf( stdout, "%d\tbytes per package\n", size);

        std::thread c{ [&](){client( );}};

        std::this_thread::sleep_for( std::chrono::microseconds( 500));
    
        char buffer[size] = {};

        for( int idx = 0; idx < count; ++idx)
        {
            const ssize_t result = recv( fd, buffer, size, 0);

            if( result == -1)
            {
                perror("recv error");
                c.join();
                unlink( path);
                return -1;
            }

            int index = 0;
            memcpy( &index, buffer, sizeof idx);

            if( index != idx)
            {
                fprintf( stderr, "expected %d but got %d\n", idx, index);
                c.join();
                unlink( path);
                return -1;
            }
        }

        c.join();
        close( fd);
        unlink( path);
    }

    return 0;
}
--
Problem reports:      https://cygwin.com/problems.html
FAQ:                  https://cygwin.com/faq/
Documentation:        https://cygwin.com/docs.html
Unsubscribe info:     https://cygwin.com/ml/#unsubscribe-simple