aboutsummaryrefslogtreecommitdiffstats
path: root/test/test_ipsec_esp.py
blob: 58d159a721330f2eaa9ea27cbc7909aba43b011d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
import socket
import unittest
from scapy.layers.ipsec import ESP

from framework import VppTestRunner
from template_ipsec import IpsecTraTests, IpsecTunTests
from template_ipsec import TemplateIpsec, IpsecTcpTests


class TemplateIpsecEsp(TemplateIpsec):
    """
    Basic test for ipsec esp sanity - tunnel and transport modes.

    Below 4 cases are covered as part of this test
    1) ipsec esp v4 transport basic test  - IPv4 Transport mode
        scenario using HMAC-SHA1-96 intergrity algo
    2) ipsec esp v4 transport burst test
        Above test for 257 pkts
    3) ipsec esp 4o4 tunnel basic test    - IPv4 Tunnel mode
        scenario using HMAC-SHA1-96 intergrity algo
    4) ipsec esp 4o4 tunnel burst test
        Above test for 257 pkts

    TRANSPORT MODE:

     ---   encrypt   ---
    |pg2| <-------> |VPP|
     ---   decrypt   ---

    TUNNEL MODE:

     ---   encrypt   ---   plain   ---
    |pg0| <-------  |VPP| <------ |pg1|
     ---             ---           ---

     ---   decrypt   ---   plain   ---
    |pg0| ------->  |VPP| ------> |pg1|
     ---             ---           ---

    Note : IPv6 is not covered
    """

    encryption_type = ESP

    @classmethod
    def setUpClass(cls):
        super(TemplateIpsecEsp, cls).setUpClass()
        cls.tun_if = cls.pg0
        cls.tra_if = cls.pg2
        cls.logger.info(cls.vapi.ppcli("show int addr"))
        cls.config_esp_tra()
        cls.logger.info(cls.vapi.ppcli("show ipsec"))
        cls.config_esp_tun()
        cls.logger.info(cls.vapi.ppcli("show ipsec"))
        src4 = socket.inet_pton(socket.AF_INET, cls.remote_tun_if_host)
        cls.vapi.ip_add_del_route(src4, 32, cls.tun_if.remote_ip4n)

    @classmethod
    def config_esp_tun(cls):
        cls.vapi.ipsec_sad_add_del_entry(cls.scapy_tun_sa_id,
                                         cls.scapy_tun_spi,
                                         cls.auth_algo_vpp_id, cls.auth_key,
                                         cls.crypt_algo_vpp_id,
                                         cls.crypt_key, cls.vpp_esp_protocol,
                                         cls.tun_if.local_ip4n,
                                         cls.tun_if.remote_ip4n)
        cls.vapi.ipsec_sad_add_del_entry(cls.vpp_tun_sa_id,
                                         cls.vpp_tun_spi,
                                         cls.auth_algo_vpp_id, cls.auth_key,
                                         cls.crypt_algo_vpp_id,
                                         cls.crypt_key, cls.vpp_esp_protocol,
                                         cls.tun_if.remote_ip4n,
                                         cls.tun_if.local_ip4n)
        cls.vapi.ipsec_spd_add_del(cls.tun_spd_id)
        cls.vapi.ipsec_interface_add_del_spd(cls.tun_spd_id,
                                             cls.tun_if.sw_if_index)
        l_startaddr = r_startaddr = socket.inet_pton(socket.AF_INET,
                                                     "0.0.0.0")
        l_stopaddr = r_stopaddr = socket.inet_pton(socket.AF_INET,
                                                   "255.255.255.255")
        cls.vapi.ipsec_spd_add_del_entry(cls.tun_spd_id, cls.scapy_tun_sa_id,
                                         l_startaddr, l_stopaddr, r_startaddr,
                                         r_stopaddr,
                                         protocol=socket.IPPROTO_ESP)
        cls.vapi.ipsec_spd_add_del_entry(cls.tun_spd_id, cls.scapy_tun_sa_id,
                                         l_startaddr, l_stopaddr, r_startaddr,
                                         r_stopaddr, is_outbound=0,
                                         protocol=socket.IPPROTO_ESP)
        l_startaddr = l_stopaddr = socket.inet_pton(socket.AF_INET,
                                                    cls.remote_tun_if_host)
        r_startaddr = r_stopaddr = cls.pg1.remote_ip4n
        cls.vapi.ipsec_spd_add_del_entry(cls.tun_spd_id, cls.vpp_tun_sa_id,
                                         l_startaddr, l_stopaddr, r_startaddr,
                                         r_stopaddr, priority=10, policy=3,
                                         is_outbound=0)
        cls.vapi.ipsec_spd_add_del_entry(cls.tun_spd_id, cls.scapy_tun_sa_id,
                                         r_startaddr, r_stopaddr, l_startaddr,
                                         l_stopaddr, priority=10, policy=3)
        l_startaddr = l_stopaddr = socket.inet_pton(socket.AF_INET,
                                                    cls.remote_tun_if_host)
        r_startaddr = r_stopaddr = cls.pg0.local_ip4n
        cls.vapi.ipsec_spd_add_del_entry(cls.tun_spd_id, cls.vpp_tun_sa_id,
                                         l_startaddr, l_stopaddr, r_startaddr,
                                         r_stopaddr, priority=20, policy=3,
                                         is_outbound=0)
        cls.vapi.ipsec_spd_add_del_entry(cls.tun_spd_id, cls.scapy_tun_sa_id,
                                         r_startaddr, r_stopaddr, l_startaddr,
                                         l_stopaddr, priority=20, policy=3)

    @classmethod
    def config_esp_tra(cls):
        cls.vapi.ipsec_sad_add_del_entry(cls.scapy_tra_sa_id,
                                         cls.scapy_tra_spi,
                                         cls.auth_algo_vpp_id, cls.auth_key,
                                         cls.crypt_algo_vpp_id,
                                         cls.crypt_key, cls.vpp_esp_protocol,
                                         is_tunnel=0)
        cls.vapi.ipsec_sad_add_del_entry(cls.vpp_tra_sa_id,
                                         cls.vpp_tra_spi,
                                         cls.auth_algo_vpp_id, cls.auth_key,
                                         cls.crypt_algo_vpp_id,
                                         cls.crypt_key, cls.vpp_esp_protocol,
                                         is_tunnel=0)
        cls.vapi.ipsec_spd_add_del(cls.tra_spd_id)
        cls.vapi.ipsec_interface_add_del_spd(cls.tra_spd_id,
                                             cls.tra_if.sw_if_index)
        l_startaddr = r_startaddr = socket.inet_pton(socket.AF_INET,
                                                     "0.0.0.0")
        l_stopaddr = r_stopaddr = socket.inet_pton(socket.AF_INET,
                                                   "255.255.255.255")
        cls.vapi.ipsec_spd_add_del_entry(cls.tra_spd_id, cls.vpp_tra_sa_id,
                                         l_startaddr, l_stopaddr, r_startaddr,
                                         r_stopaddr,
                                         protocol=socket.IPPROTO_ESP)
        cls.vapi.ipsec_spd_add_del_entry(cls.tra_spd_id, cls.vpp_tra_sa_id,
                                         l_startaddr, l_stopaddr, r_startaddr,
                                         r_stopaddr, is_outbound=0,
                                         protocol=socket.IPPROTO_ESP)
        l_startaddr = l_stopaddr = cls.tra_if.local_ip4n
        r_startaddr = r_stopaddr = cls.tra_if.remote_ip4n
        cls.vapi.ipsec_spd_add_del_entry(cls.tra_spd_id, cls.vpp_tra_sa_id,
                                         l_startaddr, l_stopaddr, r_startaddr,
                                         r_stopaddr, priority=10, policy=3,
                                         is_outbound=0)
        cls.vapi.ipsec_spd_add_del_entry(cls.tra_spd_id, cls.scapy_tra_sa_id,
                                         l_startaddr, l_stopaddr, r_startaddr,
                                         r_stopaddr, priority=10, policy=3)


class TestIpsecEsp1(TemplateIpsecEsp, IpsecTraTests, IpsecTunTests):
    """ Ipsec ESP - TUN & TRA tests """
    pass


class TestIpsecEsp2(TemplateIpsecEsp, IpsecTcpTests):
    """ Ipsec ESP - TCP tests """
    pass


if __name__ == '__main__':
    unittest.main(testRunner=VppTestRunner)
D CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * */ /* Socket wrapper library. Passes all socket communication over unix domain sockets if the environment variable SOCKET_WRAPPER_DIR is set. */ #include <signal.h> #include <dlfcn.h> #include <stdio.h> #include <stdarg.h> #include <unistd.h> #include <pthread.h> #include <vcl/ldp_socket_wrapper.h> enum swrap_dbglvl_e { SWRAP_LOG_ERROR = 0, SWRAP_LOG_WARN, SWRAP_LOG_DEBUG, SWRAP_LOG_TRACE }; /* Macros for accessing mutexes */ #define SWRAP_LOCK(m) do { \ pthread_mutex_lock(&(m ## _mutex)); \ } while(0) #define SWRAP_UNLOCK(m) do { \ pthread_mutex_unlock(&(m ## _mutex)); \ } while(0) /* Add new global locks here please */ #define SWRAP_LOCK_ALL \ SWRAP_LOCK(libc_symbol_binding); \ #define SWRAP_UNLOCK_ALL \ SWRAP_UNLOCK(libc_symbol_binding); \ /* The mutex for accessing the global libc.symbols */ static pthread_mutex_t libc_symbol_binding_mutex = PTHREAD_MUTEX_INITIALIZER; /* Function prototypes */ #ifdef NDEBUG #define SWRAP_LOG(...) #else static unsigned int swrap_log_lvl = SWRAP_LOG_WARN; static void swrap_log (enum swrap_dbglvl_e dbglvl, const char *func, const char *format, ...) PRINTF_ATTRIBUTE (3, 4); #define SWRAP_LOG(dbglvl, ...) swrap_log((dbglvl), __func__, __VA_ARGS__) static void swrap_log (enum swrap_dbglvl_e dbglvl, const char *func, const char *format, ...) { char buffer[1024]; va_list va; va_start (va, format); vsnprintf (buffer, sizeof (buffer), format, va); va_end (va); if (dbglvl <= swrap_log_lvl) { switch (dbglvl) { case SWRAP_LOG_ERROR: fprintf (stderr, "SWRAP_ERROR(%d) - %s: %s\n", (int) getpid (), func, buffer); break; case SWRAP_LOG_WARN: fprintf (stderr, "SWRAP_WARN(%d) - %s: %s\n", (int) getpid (), func, buffer); break; case SWRAP_LOG_DEBUG: fprintf (stderr, "SWRAP_DEBUG(%d) - %s: %s\n", (int) getpid (), func, buffer); break; case SWRAP_LOG_TRACE: fprintf (stderr, "SWRAP_TRACE(%d) - %s: %s\n", (int) getpid (), func, buffer); break; } } } #endif /********************************************************* * SWRAP LOADING LIBC FUNCTIONS *********************************************************/ typedef int (*__libc_accept4) (int sockfd, struct sockaddr * addr, socklen_t * addrlen, int flags); typedef int (*__libc_accept) (int sockfd, struct sockaddr * addr, socklen_t * addrlen); typedef int (*__libc_bind) (int sockfd, const struct sockaddr * addr, socklen_t addrlen); typedef int (*__libc_close) (int fd); typedef int (*__libc_connect) (int sockfd, const struct sockaddr * addr, socklen_t addrlen); #if 0 /* TBD: dup and dup2 to be implemented later */ typedef int (*__libc_dup) (int fd); typedef int (*__libc_dup2) (int oldfd, int newfd); #endif typedef int (*__libc_fcntl) (int fd, int cmd, ...); #ifdef HAVE_FCNTL64 typedef int (*__libc_fcntl64) (int fd, int cmd, ...); #endif typedef FILE *(*__libc_fopen) (const char *name, const char *mode); #ifdef HAVE_FOPEN64 typedef FILE *(*__libc_fopen64) (const char *name, const char *mode); #endif #ifdef HAVE_EVENTFD typedef int (*__libc_eventfd) (int count, int flags); #endif typedef int (*__libc_getpeername) (int sockfd, struct sockaddr * addr, socklen_t * addrlen); typedef int (*__libc_getsockname) (int sockfd, struct sockaddr * addr, socklen_t * addrlen); typedef int (*__libc_getsockopt) (int sockfd, int level, int optname, void *optval, socklen_t * optlen); typedef int (*__libc_ioctl) (int d, unsigned long int request, ...); typedef int (*__libc_listen) (int sockfd, int backlog); typedef int (*__libc_open) (const char *pathname, int flags, mode_t mode); #ifdef HAVE_OPEN64 typedef int (*__libc_open64) (const char *pathname, int flags, mode_t mode); #endif /* HAVE_OPEN64 */ typedef int (*__libc_openat) (int dirfd, const char *path, int flags, ...); typedef int (*__libc_pipe) (int pipefd[2]); typedef int (*__libc_read) (int fd, void *buf, size_t count); typedef ssize_t (*__libc_readv) (int fd, const struct iovec * iov, int iovcnt); typedef int (*__libc_recv) (int sockfd, void *buf, size_t len, int flags); typedef int (*__libc_recvfrom) (int sockfd, void *buf, size_t len, int flags, struct sockaddr * src_addr, socklen_t * addrlen); typedef int (*__libc_recvmsg) (int sockfd, const struct msghdr * msg, int flags); typedef int (*__libc_send) (int sockfd, const void *buf, size_t len, int flags); typedef ssize_t (*__libc_sendfile) (int out_fd, int in_fd, off_t * offset, size_t len); typedef int (*__libc_sendmsg) (int sockfd, const struct msghdr * msg, int flags); typedef int (*__libc_sendto) (int sockfd, const void *buf, size_t len, int flags, const struct sockaddr * dst_addr, socklen_t addrlen); typedef int (*__libc_setsockopt) (int sockfd, int level, int optname, const void *optval, socklen_t optlen); #ifdef HAVE_SIGNALFD typedef int (*__libc_signalfd) (int fd, const sigset_t * mask, int flags); #endif typedef int (*__libc_socket) (int domain, int type, int protocol); typedef int (*__libc_socketpair) (int domain, int type, int protocol, int sv[2]); #ifdef HAVE_TIMERFD_CREATE typedef int (*__libc_timerfd_create) (int clockid, int flags); #endif typedef ssize_t (*__libc_write) (int fd, const void *buf, size_t count); typedef ssize_t (*__libc_writev) (int fd, const struct iovec * iov, int iovcnt); typedef int (*__libc_shutdown) (int fd, int how); typedef int (*__libc_select) (int __nfds, fd_set * __restrict __readfds, fd_set * __restrict __writefds, fd_set * __restrict __exceptfds, struct timeval * __restrict __timeout); #ifdef __USE_XOPEN2K typedef int (*__libc_pselect) (int __nfds, fd_set * __restrict __readfds, fd_set * __restrict __writefds, fd_set * __restrict __exceptfds, const struct timespec * __restrict __timeout, const __sigset_t * __restrict __sigmask); #endif typedef int (*__libc_epoll_create) (int __size); typedef int (*__libc_epoll_create1) (int __flags); typedef int (*__libc_epoll_ctl) (int __epfd, int __op, int __fd, struct epoll_event * __event); typedef int (*__libc_epoll_wait) (int __epfd, struct epoll_event * __events, int __maxevents, int __timeout); typedef int (*__libc_epoll_pwait) (int __epfd, struct epoll_event * __events, int __maxevents, int __timeout, const __sigset_t * __ss); typedef int (*__libc_poll) (struct pollfd * __fds, nfds_t __nfds, int __timeout); #ifdef __USE_GNU typedef int (*__libc_ppoll) (struct pollfd * __fds, nfds_t __nfds, const struct timespec * __timeout, const __sigset_t * __ss); #endif #define SWRAP_SYMBOL_ENTRY(i) \ union { \ __libc_##i f; \ void *obj; \ } _libc_##i struct swrap_libc_symbols { SWRAP_SYMBOL_ENTRY (accept4); SWRAP_SYMBOL_ENTRY (accept); SWRAP_SYMBOL_ENTRY (bind); SWRAP_SYMBOL_ENTRY (close); SWRAP_SYMBOL_ENTRY (connect); #if 0 /* TBD: dup and dup2 to be implemented later */ SWRAP_SYMBOL_ENTRY (dup); SWRAP_SYMBOL_ENTRY (dup2); #endif SWRAP_SYMBOL_ENTRY (fcntl); #ifdef HAVE_FCNTL64 SWRAP_SYMBOL_ENTRY (fcntl64); #endif SWRAP_SYMBOL_ENTRY (fopen); #ifdef HAVE_FOPEN64 SWRAP_SYMBOL_ENTRY (fopen64); #endif #ifdef HAVE_EVENTFD SWRAP_SYMBOL_ENTRY (eventfd); #endif SWRAP_SYMBOL_ENTRY (getpeername); SWRAP_SYMBOL_ENTRY (getsockname); SWRAP_SYMBOL_ENTRY (getsockopt); SWRAP_SYMBOL_ENTRY (ioctl); SWRAP_SYMBOL_ENTRY (listen); SWRAP_SYMBOL_ENTRY (open); #ifdef HAVE_OPEN64 SWRAP_SYMBOL_ENTRY (open64); #endif SWRAP_SYMBOL_ENTRY (openat); SWRAP_SYMBOL_ENTRY (pipe); SWRAP_SYMBOL_ENTRY (read); SWRAP_SYMBOL_ENTRY (readv); SWRAP_SYMBOL_ENTRY (recv); SWRAP_SYMBOL_ENTRY (recvfrom); SWRAP_SYMBOL_ENTRY (recvmsg); SWRAP_SYMBOL_ENTRY (send); SWRAP_SYMBOL_ENTRY (sendfile); SWRAP_SYMBOL_ENTRY (sendmsg); SWRAP_SYMBOL_ENTRY (sendto); SWRAP_SYMBOL_ENTRY (setsockopt); #ifdef HAVE_SIGNALFD SWRAP_SYMBOL_ENTRY (signalfd); #endif SWRAP_SYMBOL_ENTRY (socket); SWRAP_SYMBOL_ENTRY (socketpair); #ifdef HAVE_TIMERFD_CREATE SWRAP_SYMBOL_ENTRY (timerfd_create); #endif SWRAP_SYMBOL_ENTRY (write); SWRAP_SYMBOL_ENTRY (writev); SWRAP_SYMBOL_ENTRY (shutdown); SWRAP_SYMBOL_ENTRY (select); #ifdef __USE_XOPEN2K SWRAP_SYMBOL_ENTRY (pselect); #endif SWRAP_SYMBOL_ENTRY (epoll_create); SWRAP_SYMBOL_ENTRY (epoll_create1); SWRAP_SYMBOL_ENTRY (epoll_ctl); SWRAP_SYMBOL_ENTRY (epoll_wait); SWRAP_SYMBOL_ENTRY (epoll_pwait); SWRAP_SYMBOL_ENTRY (poll); #ifdef __USE_GNU SWRAP_SYMBOL_ENTRY (ppoll); #endif }; struct swrap { struct { void *handle; void *socket_handle; struct swrap_libc_symbols symbols; } libc; }; static struct swrap swrap; #define LIBC_NAME "libc.so" enum swrap_lib { SWRAP_LIBC, }; #ifndef NDEBUG static const char * swrap_str_lib (enum swrap_lib lib) { switch (lib) { case SWRAP_LIBC: return "libc"; } /* Compiler would warn us about unhandled enum value if we get here */ return "unknown"; } #endif static void * swrap_load_lib_handle (enum swrap_lib lib) { int flags = RTLD_LAZY; void *handle = NULL; int i; #if defined(RTLD_DEEPBIND) && !defined(CLIB_SANITIZE_ADDR) flags |= RTLD_DEEPBIND; #endif switch (lib) { case SWRAP_LIBC: handle = swrap.libc.handle; #ifdef LIBC_SO if (handle == NULL) { handle = dlopen (LIBC_SO, flags); swrap.libc.handle = handle; } #endif if (handle == NULL) { for (i = 10; i >= 0; i--) { char soname[256] = { 0 }; snprintf (soname, sizeof (soname), "libc.so.%d", i); handle = dlopen (soname, flags); if (handle != NULL) { break; } } swrap.libc.handle = handle; } break; } if (handle == NULL) { SWRAP_LOG (SWRAP_LOG_ERROR, "Failed to dlopen library: %s\n", dlerror ()); exit (-1); } return handle; } static void * _swrap_bind_symbol (enum swrap_lib lib, const char *fn_name) { void *handle; void *func; handle = swrap_load_lib_handle (lib); func = dlsym (handle, fn_name); if (func == NULL) { SWRAP_LOG (SWRAP_LOG_ERROR, "Failed to find %s: %s\n", fn_name, dlerror ()); exit (-1); } SWRAP_LOG (SWRAP_LOG_TRACE, "Loaded %s from %s", fn_name, swrap_str_lib (lib)); return func; } #define swrap_bind_symbol_libc(sym_name) \ SWRAP_LOCK(libc_symbol_binding); \ if (swrap.libc.symbols._libc_##sym_name.obj == NULL) { \ swrap.libc.symbols._libc_##sym_name.obj = \ _swrap_bind_symbol(SWRAP_LIBC, #sym_name); \ } \ SWRAP_UNLOCK(libc_symbol_binding) /* * IMPORTANT * * Functions especially from libc need to be loaded individually, you can't load * all at once or gdb will segfault at startup. The same applies to valgrind and * has probably something todo with with the linker. * So we need load each function at the point it is called the first time. */ int libc_accept4 (int sockfd, struct sockaddr *addr, socklen_t * addrlen, int flags) { swrap_bind_symbol_libc (accept4); return swrap.libc.symbols._libc_accept4.f (sockfd, addr, addrlen, flags); } int libc_accept (int sockfd, struct sockaddr *addr, socklen_t * addrlen) { swrap_bind_symbol_libc (accept); return swrap.libc.symbols._libc_accept.f (sockfd, addr, addrlen); } int libc_bind (int sockfd, const struct sockaddr *addr, socklen_t addrlen) { swrap_bind_symbol_libc (bind); return swrap.libc.symbols._libc_bind.f (sockfd, addr, addrlen); } int libc_close (int fd) { swrap_bind_symbol_libc (close); return swrap.libc.symbols._libc_close.f (fd); } int libc_connect (int sockfd, const struct sockaddr *addr, socklen_t addrlen) { swrap_bind_symbol_libc (connect); return swrap.libc.symbols._libc_connect.f (sockfd, addr, addrlen); } #if 0 /* TBD: dup and dup2 to be implemented later */ int libc_dup (int fd) { swrap_bind_symbol_libc (dup); return swrap.libc.symbols._libc_dup.f (fd); } int libc_dup2 (int oldfd, int newfd) { swrap_bind_symbol_libc (dup2); return swrap.libc.symbols._libc_dup2.f (oldfd, newfd); } #endif #ifdef HAVE_EVENTFD int libc_eventfd (int count, int flags) { swrap_bind_symbol_libc (eventfd); return swrap.libc.symbols._libc_eventfd.f (count, flags); } #endif int libc_vfcntl (int fd, int cmd, va_list ap) { long int args[4]; int rc; int i; swrap_bind_symbol_libc (fcntl); for (i = 0; i < 4; i++) { args[i] = va_arg (ap, long int); } rc = swrap.libc.symbols._libc_fcntl.f (fd, cmd, args[0], args[1], args[2], args[3]); return rc; } #ifdef HAVE_FCNTL64 int libc_vfcntl64 (int fd, int cmd, va_list ap) { long int args[4]; int rc; int i; swrap_bind_symbol_libc (fcntl64); for (i = 0; i < 4; i++) { args[i] = va_arg (ap, long int); } rc = swrap.libc.symbols._libc_fcntl64.f (fd, cmd, args[0], args[1], args[2], args[3]); return rc; } #endif int libc_vioctl (int fd, int cmd, va_list ap) { long int args[4]; int rc; int i; swrap_bind_symbol_libc (ioctl); for (i = 0; i < 4; i++) { args[i] = va_arg (ap, long int); } rc = swrap.libc.symbols._libc_ioctl.f (fd, cmd, args[0], args[1], args[2], args[3]); return rc; } int libc_getpeername (int sockfd, struct sockaddr *addr, socklen_t * addrlen) { swrap_bind_symbol_libc (getpeername); return swrap.libc.symbols._libc_getpeername.f (sockfd, addr, addrlen); } int libc_getsockname (int sockfd, struct sockaddr *addr, socklen_t * addrlen) { swrap_bind_symbol_libc (getsockname); return swrap.libc.symbols._libc_getsockname.f (sockfd, addr, addrlen); } int libc_getsockopt (int sockfd, int level, int optname, void *optval, socklen_t * optlen) { swrap_bind_symbol_libc (getsockopt); return swrap.libc.symbols._libc_getsockopt.f (sockfd, level, optname, optval, optlen); } int libc_listen (int sockfd, int backlog) { swrap_bind_symbol_libc (listen); return swrap.libc.symbols._libc_listen.f (sockfd, backlog); } /* TBD: libc_read() should return ssize_t not an int */ int libc_read (int fd, void *buf, size_t count) { swrap_bind_symbol_libc (read); return swrap.libc.symbols._libc_read.f (fd, buf, count); } ssize_t libc_readv (int fd, const struct iovec * iov, int iovcnt) { swrap_bind_symbol_libc (readv); return swrap.libc.symbols._libc_readv.f (fd, iov, iovcnt); } int libc_recv (int sockfd, void *buf, size_t len, int flags) { swrap_bind_symbol_libc (recv); return swrap.libc.symbols._libc_recv.f (sockfd, buf, len, flags); } int libc_recvfrom (int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t * addrlen) { swrap_bind_symbol_libc (recvfrom); return swrap.libc.symbols._libc_recvfrom.f (sockfd, buf, len, flags, src_addr, addrlen); } int libc_recvmsg (int sockfd, struct msghdr *msg, int flags) { swrap_bind_symbol_libc (recvmsg); return swrap.libc.symbols._libc_recvmsg.f (sockfd, msg, flags); } int libc_send (int sockfd, const void *buf, size_t len, int flags) { swrap_bind_symbol_libc (send); return swrap.libc.symbols._libc_send.f (sockfd, buf, len, flags); } ssize_t libc_sendfile (int out_fd, int in_fd, off_t * offset, size_t len) { swrap_bind_symbol_libc (sendfile); return swrap.libc.symbols._libc_sendfile.f (out_fd, in_fd, offset, len); } int libc_sendmsg (int sockfd, const struct msghdr *msg, int flags) { swrap_bind_symbol_libc (sendmsg); return swrap.libc.symbols._libc_sendmsg.f (sockfd, msg, flags); } int libc_sendto (int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dst_addr, socklen_t addrlen) { swrap_bind_symbol_libc (sendto); return swrap.libc.symbols._libc_sendto.f (sockfd, buf, len, flags, dst_addr, addrlen); } int libc_setsockopt (int sockfd, int level, int optname, const void *optval, socklen_t optlen) { swrap_bind_symbol_libc (setsockopt); return swrap.libc.symbols._libc_setsockopt.f (sockfd, level, optname, optval, optlen); } int libc_socket (int domain, int type, int protocol) { swrap_bind_symbol_libc (socket); return swrap.libc.symbols._libc_socket.f (domain, type, protocol); } int libc_socketpair (int domain, int type, int protocol, int sv[2]) { swrap_bind_symbol_libc (socketpair); return swrap.libc.symbols._libc_socketpair.f (domain, type, protocol, sv); } ssize_t libc_write (int fd, const void *buf, size_t count) { swrap_bind_symbol_libc (write); return swrap.libc.symbols._libc_write.f (fd, buf, count); } ssize_t libc_writev (int fd, const struct iovec * iov, int iovcnt) { swrap_bind_symbol_libc (writev); return swrap.libc.symbols._libc_writev.f (fd, iov, iovcnt); } int libc_shutdown (int fd, int how) { swrap_bind_symbol_libc (shutdown); return swrap.libc.symbols._libc_shutdown.f (fd, how); } int libc_select (int __nfds, fd_set * __restrict __readfds, fd_set * __restrict __writefds, fd_set * __restrict __exceptfds, struct timeval *__restrict __timeout) { swrap_bind_symbol_libc (select); return swrap.libc.symbols._libc_select.f (__nfds, __readfds, __writefds, __exceptfds, __timeout); } #ifdef __USE_XOPEN2K int libc_pselect (int __nfds, fd_set * __restrict __readfds, fd_set * __restrict __writefds, fd_set * __restrict __exceptfds, const struct timespec *__restrict __timeout, const __sigset_t * __restrict __sigmask) { swrap_bind_symbol_libc (pselect); return swrap.libc.symbols._libc_pselect.f (__nfds, __readfds, __writefds, __exceptfds, __timeout, __sigmask); } #endif int libc_epoll_create (int __size) { swrap_bind_symbol_libc (epoll_create); return swrap.libc.symbols._libc_epoll_create.f (__size); } int libc_epoll_create1 (int __flags) { swrap_bind_symbol_libc (epoll_create1); return swrap.libc.symbols._libc_epoll_create1.f (__flags); } int libc_epoll_ctl (int __epfd, int __op, int __fd, struct epoll_event *__event) { swrap_bind_symbol_libc (epoll_ctl); return swrap.libc.symbols._libc_epoll_ctl.f (__epfd, __op, __fd, __event); } int libc_epoll_wait (int __epfd, struct epoll_event *__events, int __maxevents, int __timeout) { swrap_bind_symbol_libc (epoll_wait); return swrap.libc.symbols._libc_epoll_wait.f (__epfd, __events, __maxevents, __timeout); } int libc_epoll_pwait (int __epfd, struct epoll_event *__events, int __maxevents, int __timeout, const __sigset_t * __ss) { swrap_bind_symbol_libc (epoll_pwait); return swrap.libc.symbols._libc_epoll_pwait.f (__epfd, __events, __maxevents, __timeout, __ss); } int libc_poll (struct pollfd *__fds, nfds_t __nfds, int __timeout) { swrap_bind_symbol_libc (poll); return swrap.libc.symbols._libc_poll.f (__fds, __nfds, __timeout); } #ifdef __USE_GNU int libc_ppoll (struct pollfd *__fds, nfds_t __nfds, const struct timespec *__timeout, const __sigset_t * __ss) { swrap_bind_symbol_libc (ppoll); return swrap.libc.symbols._libc_ppoll.f (__fds, __nfds, __timeout, __ss); } #endif static void swrap_thread_prepare (void) { SWRAP_LOCK_ALL; } static void swrap_thread_parent (void) { SWRAP_UNLOCK_ALL; } static void swrap_thread_child (void) { SWRAP_UNLOCK_ALL; } /**************************** * CONSTRUCTOR ***************************/ void swrap_constructor (void) { /* * If we hold a lock and the application forks, then the child * is not able to unlock the mutex and we are in a deadlock. * This should prevent such deadlocks. */ pthread_atfork (&swrap_thread_prepare, &swrap_thread_parent, &swrap_thread_child); } /**************************** * DESTRUCTOR ***************************/ /* * This function is called when the library is unloaded and makes sure that * sockets get closed and the unix file for the socket are unlinked. */ void swrap_destructor (void) { if (swrap.libc.handle != NULL) { dlclose (swrap.libc.handle); } if (swrap.libc.socket_handle) { dlclose (swrap.libc.socket_handle); } } /* * fd.io coding-style-patch-verification: ON * * Local Variables: * eval: (c-set-style "gnu") * End: */