# io_uring_prep_socket_direct_alloc

## NAME



           io_uring_prep_socket - prepare a socket creation request
    


## SYNOPSIS



           **#include <sys/socket.h>**
           **#include <liburing.h>**
    
           **void io_uring_prep_socket(struct io_uring_sqe ***_sqe_**,**
                                     **int** _domain_**,**
                                     **int** _type_**,**
                                     **int** _protocol_**,**
                                     **unsigned int** _flags_**);**
    
           **void io_uring_prep_socket_direct(struct io_uring_sqe ***_sqe_**,**
                                            **int** _domain_**,**
                                            **int** _type_**,**
                                            **int** _protocol_**,**
                                            **unsigned int** _file_index_**,**
                                            **unsigned int** _flags_**);**
    
           **void io_uring_prep_socket_direct_alloc(struct io_uring_sqe ***_sqe_**,**
                                            **int** _domain_**,**
                                            **int** _type_**,**
                                            **int** _protocol_**,**
                                            **unsigned int** _flags_**);**
    


## DESCRIPTION



           The io_uring_prep_socket(3) function prepares a socket creation
           request. The submission queue entry _sqe_ is setup to use the
           communication domain defined by _domain_ and use the communication
           type defined by _type_ and the protocol set by _protocol_.  The _flags_
           argument are currently unused.
    
           The io_uring_prep_socket_direct(3) helper works just like
           io_uring_prep_socket(3), except it maps the socket to a direct
           descriptor rather than return a normal file descriptor. The
           _file_index_ argument should be set to the slot that should be used
           for this socket.
    
           The io_uring_prep_socket_direct_alloc(3) helper works just like
           io_uring_prep_socket_direct(3), except it allocates a new direct
           descriptor rather than pass a free slot in. It is equivalent to
           using io_uring_prep_socket_direct(3) with **IORING_FILE_INDEX_ALLOC**
           as the _file_index ._  Upon completion, the _res_ field of the CQE
           will return the direct slot that was allocated for the socket.
    
           If the direct variants are used, the application must first have
           registered a file table using io_uring_register_files(3) of the
           appropriate size. Once registered, a direct socket request may use
           any entry in that table, as long as it is within the size of the
           registered table.  If a specified entry already contains a file,
           the file will first be removed from the table and closed. It's
           consistent with the behavior of updating an existing file with
           io_uring_register_files_update(3).
    
           For a direct descriptor socket request, the _file_index_ argument
           can be set to **IORING_FILE_INDEX_ALLOC** , In this case a free entry
           in io_uring file table will be used automatically and the file
           index will be returned as CQE _res_.  **-ENFILE** is otherwise returned
           if there is no free entries in the io_uring file table.
    
           These functions prepare an async socket(2) request. See that man
           page for details.
    


## RETURN VALUE



           None
    


## ERRORS



           The CQE _res_ field will contain the result of the operation. See
           the related man page for details on possible values. Note that
           where synchronous system calls will return **-1** on failure and set
           _errno_ to the actual error value, io_uring never uses _errno_.
           Instead it returns the negated _errno_ directly in the CQE _res_
           field.
    


* * *