Commit adf1add2 authored by Marc-André Lureau's avatar Marc-André Lureau Committed by Samuel Thibault
Browse files

slirp: wrap the remaining socket functions 



QEMU wraps the socket functions in os-win32.h, but in commit
a9d8b3ec, the header inclusion was dropped,
breaking libslirp on Windows.

Wrap the missing functions.

Rename the wrapped function with "slirp_" prefix and "_wrap" suffix,
for consistency and to avoid a clash with existing function (such as
"slirp_socket").

Fixes: a9d8b3ec ("slirp: replace remaining qemu headers dependency")
Signed-off-by: default avatarMarc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <20190212160953.29051-3-marcandre.lureau@redhat.com>
Signed-off-by: default avatarSamuel Thibault <samuel.thibault@ens-lyon.org>
Tested-by: Howard Spoelstra
parent fdbfba8c

slirp/util.c

+162 −2
Original line number Diff line number Diff line
@@ -167,7 +167,7 @@ static int socket_error(void) 
}



#undef ioctlsocket

int slirp_ioctlsocket(int fd, int req, void *val)

int slirp_ioctlsocket_wrap(int fd, int req, void *val)

{

    int ret;

    ret = ioctlsocket(fd, req, val);
@@ -178,7 +178,7 @@ int slirp_ioctlsocket(int fd, int req, void *val) 
}



#undef closesocket

int slirp_closesocket(int fd)

int slirp_closesocket_wrap(int fd)

{

    int ret;

    ret = closesocket(fd);
@@ -187,6 +187,166 @@ int slirp_closesocket(int fd) 
    }

    return ret;

}



#undef connect

int slirp_connect_wrap(int sockfd, const struct sockaddr *addr, int addrlen)

{

    int ret;

    ret = connect(sockfd, addr, addrlen);

    if (ret < 0) {

        errno = socket_error();

    }

    return ret;

}



#undef listen

int slirp_listen_wrap(int sockfd, int backlog)

{

    int ret;

    ret = listen(sockfd, backlog);

    if (ret < 0) {

        errno = socket_error();

    }

    return ret;

}



#undef bind

int slirp_bind_wrap(int sockfd, const struct sockaddr *addr, int addrlen)

{

    int ret;

    ret = bind(sockfd, addr, addrlen);

    if (ret < 0) {

        errno = socket_error();

    }

    return ret;

}



#undef socket

int slirp_socket_wrap(int domain, int type, int protocol)

{

    int ret;

    ret = socket(domain, type, protocol);

    if (ret < 0) {

        errno = socket_error();

    }

    return ret;

}



#undef accept

int slirp_accept_wrap(int sockfd, struct sockaddr *addr, int *addrlen)

{

    int ret;

    ret = accept(sockfd, addr, addrlen);

    if (ret < 0) {

        errno = socket_error();

    }

    return ret;

}



#undef shutdown

int slirp_shutdown_wrap(int sockfd, int how)

{

    int ret;

    ret = shutdown(sockfd, how);

    if (ret < 0) {

        errno = socket_error();

    }

    return ret;

}



#undef getsockopt

int slirp_getsockopt_wrap(int sockfd, int level, int optname,

                          void *optval, int *optlen)

{

    int ret;

    ret = getsockopt(sockfd, level, optname, optval, optlen);

    if (ret < 0) {

        errno = socket_error();

    }

    return ret;

}



#undef setsockopt

int slirp_setsockopt_wrap(int sockfd, int level, int optname,

                          const void *optval, int optlen)

{

    int ret;

    ret = setsockopt(sockfd, level, optname, optval, optlen);

    if (ret < 0) {

        errno = socket_error();

    }

    return ret;

}



#undef getpeername

int slirp_getpeername_wrap(int sockfd, struct sockaddr *addr,

                           int *addrlen)

{

    int ret;

    ret = getpeername(sockfd, addr, addrlen);

    if (ret < 0) {

        errno = socket_error();

    }

    return ret;

}



#undef getsockname

int slirp_getsockname_wrap(int sockfd, struct sockaddr *addr,

                           int *addrlen)

{

    int ret;

    ret = getsockname(sockfd, addr, addrlen);

    if (ret < 0) {

        errno = socket_error();

    }

    return ret;

}



#undef send

ssize_t slirp_send_wrap(int sockfd, const void *buf, size_t len, int flags)

{

    int ret;

    ret = send(sockfd, buf, len, flags);

    if (ret < 0) {

        errno = socket_error();

    }

    return ret;

}



#undef sendto

ssize_t slirp_sendto_wrap(int sockfd, const void *buf, size_t len, int flags,

                     const struct sockaddr *addr, int addrlen)

{

    int ret;

    ret = sendto(sockfd, buf, len, flags, addr, addrlen);

    if (ret < 0) {

        errno = socket_error();

    }

    return ret;

}



#undef recv

ssize_t slirp_recv_wrap(int sockfd, void *buf, size_t len, int flags)

{

    int ret;

    ret = recv(sockfd, buf, len, flags);

    if (ret < 0) {

        errno = socket_error();

    }

    return ret;

}



#undef recvfrom

ssize_t slirp_recvfrom_wrap(int sockfd, void *buf, size_t len, int flags,

                            struct sockaddr *addr, int *addrlen)

{

    int ret;

    ret = recvfrom(sockfd, buf, len, flags, addr, addrlen);

    if (ret < 0) {

        errno = socket_error();

    }

    return ret;

}

#endif /* WIN32 */



void slirp_pstrcpy(char *buf, int buf_size, const char *str)

slirp/util.h

+47 −9
Original line number Diff line number Diff line
@@ -83,23 +83,61 @@ struct iovec { 


/* FIXME: remove me when made standalone */

#ifdef _WIN32

#undef accept

#undef bind

#undef closesocket

#undef connect

#undef getpeername

#undef getsockname

#undef getsockopt

#undef ioctlsocket

#undef listen

#undef recv

#undef recvfrom

#undef send

#undef sendto

#undef setsockopt

#undef shutdown

#undef socket

#endif



#ifdef _WIN32

#define closesocket slirp_closesocket

int slirp_closesocket(int fd);

#define ioctlsocket slirp_ioctlsocket

int slirp_ioctlsocket(int fd, int req, void *val);

#define getsockopt(sockfd, level, optname, optval, optlen) \

    getsockopt(sockfd, level, optname, (void *)optval, optlen)

#define setsockopt(sockfd, level, optname, optval, optlen)        \

    setsockopt(sockfd, level, optname, (const void *)optval, optlen)

#define recv(sockfd, buf, len, flags) recv(sockfd, (void *)buf, len, flags)

#define connect slirp_connect_wrap

int slirp_connect_wrap(int fd, const struct sockaddr *addr, int addrlen);

#define listen slirp_listen_wrap

int slirp_listen_wrap(int fd, int backlog);

#define bind slirp_bind_wrap

int slirp_bind_wrap(int fd, const struct sockaddr *addr, int addrlen);

#define socket slirp_socket_wrap

int slirp_socket_wrap(int domain, int type, int protocol);

#define accept slirp_accept_wrap

int slirp_accept_wrap(int fd, struct sockaddr *addr, int *addrlen);

#define shutdown slirp_shutdown_wrap

int slirp_shutdown_wrap(int fd, int how);

#define getpeername slirp_getpeername_wrap

int slirp_getpeername_wrap(int fd, struct sockaddr *addr, int *addrlen);

#define getsockname slirp_getsockname_wrap

int slirp_getsockname_wrap(int fd, struct sockaddr *addr, int *addrlen);

#define send slirp_send_wrap

ssize_t slirp_send_wrap(int fd, const void *buf, size_t len, int flags);

#define sendto slirp_sendto_wrap

ssize_t slirp_sendto_wrap(int fd, const void *buf, size_t len, int flags,

                          const struct sockaddr *dest_addr, int addrlen);

#define recv slirp_recv_wrap

ssize_t slirp_recv_wrap(int fd, void *buf, size_t len, int flags);

#define recvfrom slirp_recvfrom_wrap

ssize_t slirp_recvfrom_wrap(int fd, void *buf, size_t len, int flags,

                            struct sockaddr *src_addr, int *addrlen);

#define closesocket slirp_closesocket_wrap

int slirp_closesocket_wrap(int fd);

#define ioctlsocket slirp_ioctlsocket_wrap

int slirp_ioctlsocket_wrap(int fd, int req, void *val);

#define getsockopt slirp_getsockopt_wrap

int slirp_getsockopt_wrap(int sockfd, int level, int optname,

                     void *optval, int *optlen);

#define setsockopt slirp_setsockopt_wrap

int slirp_setsockopt_wrap(int sockfd, int level, int optname,

                          const void *optval, int optlen);



int inet_aton(const char *cp, struct in_addr *ia);

#else