libc/inet/socketcalls.c

   1 /*
   2  * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org>
   3  *
   4  * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball.
   5  */
   6
   7 #include <stddef.h>
   8 #include <sys/syscall.h>
   9 #include <sys/socket.h>
  10 #include <cancel.h>
  11
  12 #ifdef __NR_socketcall
  13 /* Various socketcall numbers */
  14 #define SYS_SOCKET      1
  15 #define SYS_BIND        2
  16 #define SYS_CONNECT     3
  17 #define SYS_LISTEN      4
  18 #define SYS_ACCEPT      5
  19 #define SYS_GETSOCKNAME 6
  20 #define SYS_GETPEERNAME 7
  21 #define SYS_SOCKETPAIR  8
  22 #define SYS_SEND        9
  23 #define SYS_RECV        10
  24 #define SYS_SENDTO      11
  25 #define SYS_RECVFROM    12
  26 #define SYS_SHUTDOWN    13
  27 #define SYS_SETSOCKOPT  14
  28 #define SYS_GETSOCKOPT  15
  29 #define SYS_SENDMSG     16
  30 #define SYS_RECVMSG     17
  31 #define SYS_ACCEPT4     18
  32 #endif
  33
  34 /* exposed on x86 since Linux commit 9dea5dc921b5f4045a18c63eb92e84dc274d17eb */
  35 #if defined(__sparc__) || defined(__i386__)
  36 #undef __NR_accept
  37 #undef __NR_accept4
  38 #undef __NR_bind
  39 #undef __NR_connect
  40 #undef __NR_getpeername
  41 #undef __NR_getsockname
  42 #undef __NR_getsockopt
  43 #undef __NR_listen
  44 #undef __NR_recv
  45 #undef __NR_recvfrom
  46 #undef __NR_recvmsg
  47 #undef __NR_send
  48 #undef __NR_sendmsg
  49 #undef __NR_sendto
  50 #undef __NR_setsockopt
  51 #undef __NR_shutdown
  52 #undef __NR_socket
  53 #undef __NR_socketpair
  54 #endif
  55
  56 #ifdef L_accept
  57 static int __NC(accept)(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
  58 {
  59 # ifdef __NR_accept
  60         return INLINE_SYSCALL(accept, 3, sockfd, addr, addrlen);
  61 # else
  62         unsigned long args[3];
  63
  64         args[0] = sockfd;
  65         args[1] = (unsigned long) addr;
  66         args[2] = (unsigned long) addrlen;
  67
  68         return __socketcall(SYS_ACCEPT, args);
  69 # endif
  70 }
  71 CANCELLABLE_SYSCALL(int, accept, (int sockfd, struct sockaddr *addr, socklen_t *addrlen),
  72                     (sockfd, addr, addrlen))
  73 lt_libc_hidden(accept)
  74 #endif
  75
  76 #ifdef L_accept4
  77 #ifdef __NR_accept4
  78 # define __NR___sys_accept4  __NR_accept4
  79 static _syscall4(int, __sys_accept4, int, fd, struct sockaddr *, addr, socklen_t *, addrlen, int, flags)
  80 int accept4(int fd, struct sockaddr *addr, socklen_t * addrlen, int flags)
  81 {
  82         if (SINGLE_THREAD_P)
  83                 return __sys_accept4(fd, addr, addrlen, flags);
  84 #ifdef __UCLIBC_HAS_THREADS_NATIVE__
  85         else {
  86                 int oldtype = LIBC_CANCEL_ASYNC ();
  87                 int result = __sys_accept4(fd, addr, addrlen, flags);
  88                 LIBC_CANCEL_RESET (oldtype);
  89                 return result;
  90         }
  91 #endif
  92 }
  93 #elif defined(__NR_socketcall)
  94 int accept4(int fd, struct sockaddr *addr, socklen_t *addrlen, int flags)
  95 {
  96         unsigned long args[4];
  97
  98         args[0] = fd;
  99         args[1] = (unsigned long) addr;
 100         args[2] = (unsigned long) addrlen;
 101         args[3] = flags;
 102         if (SINGLE_THREAD_P)
 103                 return __socketcall(SYS_ACCEPT4, args);
 104 #ifdef __UCLIBC_HAS_THREADS_NATIVE__
 105         else {
 106                 int oldtype = LIBC_CANCEL_ASYNC ();
 107                 int result = __socketcall(SYS_ACCEPT4, args);
 108                 LIBC_CANCEL_RESET (oldtype);
 109                 return result;
 110         }
 111 #endif
 112 }
 113 #endif
 114 #endif
 115
 116 #ifdef L_bind
 117 int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen)
 118 {
 119 # ifdef __NR_bind
 120         return INLINE_SYSCALL(bind, 3, sockfd, myaddr, addrlen);
 121 # else
 122         unsigned long args[3];
 123
 124         args[0] = sockfd;
 125         args[1] = (unsigned long) myaddr;
 126         args[2] = addrlen;
 127         return __socketcall(SYS_BIND, args);
 128 # endif
 129 }
 130 libc_hidden_def(bind)
 131 #endif
 132
 133 #ifdef L_connect
 134 static int __NC(connect)(int sockfd, const struct sockaddr *saddr, socklen_t addrlen)
 135 {
 136 # ifdef __NR_connect
 137         return INLINE_SYSCALL(connect, 3, sockfd, saddr, addrlen);
 138 # else
 139         unsigned long args[3];
 140
 141         args[0] = sockfd;
 142         args[1] = (unsigned long) saddr;
 143         args[2] = addrlen;
 144         return __socketcall(SYS_CONNECT, args);
 145 # endif
 146 }
 147 CANCELLABLE_SYSCALL(int, connect, (int sockfd, const struct sockaddr *saddr, socklen_t addrlen),
 148                     (sockfd, saddr, addrlen))
 149 lt_libc_hidden(connect)
 150 #endif
 151
 152 #ifdef L_getpeername
 153 int getpeername(int sockfd, struct sockaddr *addr, socklen_t *paddrlen)
 154 {
 155 # ifdef __NR_getpeername
 156         return INLINE_SYSCALL(getpeername, 3, sockfd, addr, paddrlen);
 157 # else
 158         unsigned long args[3];
 159
 160         args[0] = sockfd;
 161         args[1] = (unsigned long) addr;
 162         args[2] = (unsigned long) paddrlen;
 163         return __socketcall(SYS_GETPEERNAME, args);
 164 # endif
 165 }
 166 #endif
 167
 168 #ifdef L_getsockname
 169 int getsockname(int sockfd, struct sockaddr *addr, socklen_t * paddrlen)
 170 {
 171 # ifdef __NR_getsockname
 172         return INLINE_SYSCALL(getsockname, 3, sockfd, addr, paddrlen);
 173 # else
 174         unsigned long args[3];
 175
 176         args[0] = sockfd;
 177         args[1] = (unsigned long) addr;
 178         args[2] = (unsigned long) paddrlen;
 179         return __socketcall(SYS_GETSOCKNAME, args);
 180 # endif
 181 }
 182 libc_hidden_def(getsockname)
 183 #endif
 184
 185 #ifdef L_getsockopt
 186 int getsockopt(int fd, int level, int optname, void *optval,
 187                socklen_t *optlen)
 188 {
 189 # ifdef __NR_getsockopt
 190         return INLINE_SYSCALL(getsockopt, 5, fd, level, optname, optval, optlen);
 191 # else
 192         unsigned long args[5];
 193
 194         args[0] = fd;
 195         args[1] = level;
 196         args[2] = optname;
 197         args[3] = (unsigned long) optval;
 198         args[4] = (unsigned long) optlen;
 199         return (__socketcall(SYS_GETSOCKOPT, args));
 200 # endif
 201 }
 202 #endif
 203
 204 #ifdef L_listen
 205 int listen(int sockfd, int backlog)
 206 {
 207 # ifdef __NR_listen
 208         return INLINE_SYSCALL(listen, 2, sockfd, backlog);
 209 # else
 210         unsigned long args[2];
 211
 212         args[0] = sockfd;
 213         args[1] = backlog;
 214         return __socketcall(SYS_LISTEN, args);
 215 # endif
 216 }
 217 libc_hidden_def(listen)
 218 #endif
 219
 220 #ifdef L_recv
 221 static ssize_t __NC(recv)(int sockfd, void *buffer, size_t len, int flags)
 222 {
 223 # ifdef __NR_recv
 224         return (ssize_t)INLINE_SYSCALL(recv, 4, sockfd, buffer, len, flags);
 225 # elif defined __NR_recvfrom && defined _syscall6
 226         return __NC(recvfrom)(sockfd, buffer, len, flags, NULL, NULL);
 227 # else
 228         unsigned long args[4];
 229
 230         args[0] = sockfd;
 231         args[1] = (unsigned long) buffer;
 232         args[2] = len;
 233         args[3] = flags;
 234         return (ssize_t)__socketcall(SYS_RECV, args);
 235 # endif
 236 }
 237 CANCELLABLE_SYSCALL(ssize_t, recv, (int sockfd, void *buffer, size_t len, int flags),
 238                     (sockfd, buffer, len, flags))
 239 lt_libc_hidden(recv)
 240 #endif
 241
 242 #ifdef L_recvfrom
 243 ssize_t __NC(recvfrom)(int sockfd, void *buffer, size_t len, int flags,
 244                        struct sockaddr *to, socklen_t *tolen)
 245 {
 246 # if defined __NR_recvfrom && defined _syscall6
 247         return (ssize_t)INLINE_SYSCALL(recvfrom, 6, sockfd, buffer, len,
 248                                        flags, to, tolen);
 249 # else
 250         unsigned long args[6];
 251
 252         args[0] = sockfd;
 253         args[1] = (unsigned long) buffer;
 254         args[2] = len;
 255         args[3] = flags;
 256         args[4] = (unsigned long) to;
 257         args[5] = (unsigned long) tolen;
 258         return (ssize_t)__socketcall(SYS_RECVFROM, args);
 259 # endif
 260 }
 261 CANCELLABLE_SYSCALL(ssize_t, recvfrom, (int sockfd, void *buffer, size_t len,
 262                                         int flags, struct sockaddr *to, socklen_t *tolen),
 263                     (sockfd, buffer, len, flags, to, tolen))
 264 lt_libc_hidden(recvfrom)
 265 #endif
 266
 267 #ifdef L_recvmsg
 268 static ssize_t __NC(recvmsg)(int sockfd, struct msghdr *msg, int flags)
 269 {
 270 # ifdef __NR_recvmsg
 271         return (ssize_t)INLINE_SYSCALL(recvmsg, 3, sockfd, msg, flags);
 272 # else
 273         unsigned long args[3];
 274
 275         args[0] = sockfd;
 276         args[1] = (unsigned long) msg;
 277         args[2] = flags;
 278         return (ssize_t)__socketcall(SYS_RECVMSG, args);
 279 # endif
 280 }
 281 CANCELLABLE_SYSCALL(ssize_t, recvmsg, (int sockfd, struct msghdr *msg, int flags),
 282                     (sockfd, msg, flags))
 283 lt_libc_hidden(recvmsg)
 284 #endif
 285
 286 #ifdef L_send
 287 static ssize_t __NC(send)(int sockfd, const void *buffer, size_t len, int flags)
 288 {
 289 # ifdef __NR_send
 290         return (ssize_t)INLINE_SYSCALL(send, 4, sockfd, buffer, len, flags);
 291 # elif defined __NR_sendto && defined _syscall6
 292         return __NC(sendto)(sockfd, buffer, len, flags, NULL, 0);
 293 # else
 294         unsigned long args[4];
 295
 296         args[0] = sockfd;
 297         args[1] = (unsigned long) buffer;
 298         args[2] = len;
 299         args[3] = flags;
 300         return (ssize_t)__socketcall(SYS_SEND, args);
 301 # endif
 302 }
 303 CANCELLABLE_SYSCALL(ssize_t, send, (int sockfd, const void *buffer, size_t len, int flags),
 304                     (sockfd, buffer, len, flags))
 305 lt_libc_hidden(send)
 306 #endif
 307
 308 #ifdef L_sendmsg
 309 static ssize_t __NC(sendmsg)(int sockfd, const struct msghdr *msg, int flags)
 310 {
 311 # ifdef __NR_sendmsg
 312         return (ssize_t)INLINE_SYSCALL(sendmsg, 3, sockfd, msg, flags);
 313 # else
 314         unsigned long args[3];
 315
 316         args[0] = sockfd;
 317         args[1] = (unsigned long) msg;
 318         args[2] = flags;
 319         return (ssize_t)__socketcall(SYS_SENDMSG, args);
 320 # endif
 321 }
 322 CANCELLABLE_SYSCALL(ssize_t, sendmsg, (int sockfd, const struct msghdr *msg, int flags),
 323                     (sockfd, msg, flags))
 324 lt_libc_hidden(sendmsg)
 325 #endif
 326
 327 #ifdef L_sendto
 328 ssize_t __NC(sendto)(int sockfd, const void *buffer, size_t len, int flags,
 329                      const struct sockaddr *to, socklen_t tolen)
 330 {
 331 # if defined __NR_sendto && defined _syscall6
 332         return (ssize_t)INLINE_SYSCALL(sendto, 6, sockfd, buffer, len, flags, to, tolen);
 333 # else
 334         unsigned long args[6];
 335
 336         args[0] = sockfd;
 337         args[1] = (unsigned long) buffer;
 338         args[2] = len;
 339         args[3] = flags;
 340         args[4] = (unsigned long) to;
 341         args[5] = tolen;
 342         return (ssize_t)__socketcall(SYS_SENDTO, args);
 343 # endif
 344 }
 345 CANCELLABLE_SYSCALL(ssize_t, sendto, (int sockfd, const void *buffer, size_t len,
 346                                       int flags, const struct sockaddr *to, socklen_t tolen),
 347                     (sockfd, buffer, len, flags, to, tolen))
 348 lt_libc_hidden(sendto)
 349 #endif
 350
 351 #ifdef L_setsockopt
 352 int setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen)
 353 {
 354 # ifdef __NR_setsockopt
 355         return INLINE_SYSCALL(setsockopt, 5, fd, level, optname, optval, optlen);
 356 # else
 357         unsigned long args[5];
 358
 359         args[0] = fd;
 360         args[1] = level;
 361         args[2] = optname;
 362         args[3] = (unsigned long) optval;
 363         args[4] = optlen;
 364         return __socketcall(SYS_SETSOCKOPT, args);
 365 # endif
 366 }
 367 libc_hidden_def(setsockopt)
 368 #endif
 369
 370 #ifdef L_shutdown
 371 int shutdown(int sockfd, int how)
 372 {
 373 # ifdef __NR_shutdown
 374         return INLINE_SYSCALL(shutdown, 2, sockfd, how);
 375 # else
 376         unsigned long args[2];
 377
 378         args[0] = sockfd;
 379         args[1] = how;
 380         return __socketcall(SYS_SHUTDOWN, args);
 381 # endif
 382 }
 383 #endif
 384
 385 #ifdef L_socket
 386 int socket(int family, int type, int protocol)
 387 {
 388 # ifdef __NR_socket
 389         return INLINE_SYSCALL(socket, 3, family, type, protocol);
 390 # else
 391         unsigned long args[3];
 392
 393         args[0] = family;
 394         args[1] = type;
 395         args[2] = (unsigned long) protocol;
 396         return __socketcall(SYS_SOCKET, args);
 397 # endif
 398 }
 399 libc_hidden_def(socket)
 400 #endif
 401
 402 #ifdef L_socketpair
 403 int socketpair(int family, int type, int protocol, int sockvec[2])
 404 {
 405 # ifdef __NR_socketpair
 406         return INLINE_SYSCALL(socketpair, 4, family, type, protocol, sockvec);
 407 # else
 408         unsigned long args[4];
 409
 410         args[0] = family;
 411         args[1] = type;
 412         args[2] = protocol;
 413         args[3] = (unsigned long) sockvec;
 414         return __socketcall(SYS_SOCKETPAIR, args);
 415 # endif
 416 }
 417 #endif