1 /*

     2  * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 #include <errno.h>

    27 #include <sys/socket.h>

    28 #include <stropts.h>

    29 #include <unistd.h>

    30 

    31 /* Support for restartable system calls on Solaris. */

    32 

    33 #define RESTARTABLE_RETURN_INT(_cmd) do {             \

    34     int _result;                                      \

    35     if (1) {                                          \

    36         do {                                          \

    37             _result = _cmd;                           \

    38         } while((_result == -1) && (errno == EINTR)); \

    39         return _result;                               \

    40     }                                                 \

    41 } while(0)

    42 

    43 int NET_Read(int s, void* buf, size_t len) {

    44     RESTARTABLE_RETURN_INT(recv(s, buf, len, 0));

    45 }

    46 

    47 int NET_RecvFrom(int s, void *buf, int len, unsigned int flags,

    48                  struct sockaddr *from, socklen_t *fromlen) {

    49     RESTARTABLE_RETURN_INT(recvfrom(s, buf, len, flags, from, fromlen));

    50 }

    51 

    52 int NET_ReadV(int s, const struct iovec * vector, int count) {

    53     RESTARTABLE_RETURN_INT(readv(s, vector, count));

    54 }

    55 

    56 int NET_WriteV(int s, const struct iovec * vector, int count) {

    57     RESTARTABLE_RETURN_INT(writev(s, vector, count));

    58 }

    59 

    60 int NET_Send(int s, void *msg, int len, unsigned int flags) {

    61     RESTARTABLE_RETURN_INT(send(s, msg, len, flags));

    62 }

    63 

    64 int NET_SendTo(int s, const void *msg, int len,  unsigned  int flags,

    65                const struct sockaddr *to, int tolen) {

    66     RESTARTABLE_RETURN_INT(sendto(s, msg, len, flags, to, tolen));

    67 }

    68 

    69 int NET_Connect(int s, struct sockaddr *addr, int addrlen) {

    70     RESTARTABLE_RETURN_INT(connect(s, addr, addrlen));

    71 }

    72 

    73 int NET_Accept(int s, struct sockaddr *addr, socklen_t *addrlen) {

    74     RESTARTABLE_RETURN_INT(accept(s, addr, addrlen));

    75 }

    76 

    77 int NET_SocketClose(int fd) {

    78     return close(fd);

    79 }

    80 

    81 int NET_Dup2(int fd, int fd2) {

    82     return dup2(fd, fd2);

    83 }

    84 

    85 int NET_Poll(struct pollfd *ufds, unsigned int nfds, int timeout) {

    86     RESTARTABLE_RETURN_INT(poll(ufds, nfds, timeout));

    87 }

    88 

    89 int NET_Timeout(int s, long timeout) {

    90     int result;

    91     struct timeval t;

    92     long prevtime, newtime;

    93     struct pollfd pfd;

    94     pfd.fd = s;

    95     pfd.events = POLLIN;

    96 

    97     if (timeout > 0) {

    98         gettimeofday(&t, NULL);

    99         prevtime = (t.tv_sec * 1000)  +  t.tv_usec / 1000;

   100     }

   101 

   102     for(;;) {

   103         result = poll(&pfd, 1, timeout);

   104         if (result < 0 && errno == EINTR) {

   105             if (timeout > 0) {

   106                 gettimeofday(&t, NULL);

   107                 newtime = (t.tv_sec * 1000)  +  t.tv_usec /1000;

   108                 timeout -= newtime - prevtime;

   109                 if (timeout <= 0)

   110                     return 0;

   111                 prevtime = newtime;

   112             }

   113         } else {

   114             return result;

   115         }

   116     }

   117 }