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_NonBlockingRead(int s, void* buf, size_t len) { 48 RESTARTABLE_RETURN_INT(recv(s, buf, len, MSG_DONTWAIT)); 49 } 50 51 int NET_RecvFrom(int s, void *buf, int len, unsigned int flags, 52 struct sockaddr *from, socklen_t *fromlen) { 53 RESTARTABLE_RETURN_INT(recvfrom(s, buf, len, flags, from, fromlen)); 54 } 55 56 int NET_ReadV(int s, const struct iovec * vector, int count) { 57 RESTARTABLE_RETURN_INT(readv(s, vector, count)); 58 } 59 60 int NET_WriteV(int s, const struct iovec * vector, int count) { 61 RESTARTABLE_RETURN_INT(writev(s, vector, count)); 62 } 63 64 int NET_Send(int s, void *msg, int len, unsigned int flags) { 65 RESTARTABLE_RETURN_INT(send(s, msg, len, flags)); 66 } 67 68 int NET_SendTo(int s, const void *msg, int len, unsigned int flags, 69 const struct sockaddr *to, int tolen) { 70 RESTARTABLE_RETURN_INT(sendto(s, msg, len, flags, to, tolen)); 71 } 72 73 int NET_Connect(int s, struct sockaddr *addr, int addrlen) { 74 RESTARTABLE_RETURN_INT(connect(s, addr, addrlen)); 75 } 76 77 int NET_Accept(int s, struct sockaddr *addr, socklen_t *addrlen) { 78 RESTARTABLE_RETURN_INT(accept(s, addr, addrlen)); 79 } 80 81 int NET_SocketClose(int fd) { 82 return close(fd); 83 } 84 85 int NET_Dup2(int fd, int fd2) { 86 return dup2(fd, fd2); 87 } 88 89 int NET_Poll(struct pollfd *ufds, unsigned int nfds, int timeout) { 90 RESTARTABLE_RETURN_INT(poll(ufds, nfds, timeout)); 91 } 92 93 int NET_Timeout(int s, long timeout) { 94 int result; 95 struct timeval t; 96 long prevtime, newtime; 97 struct pollfd pfd; 98 pfd.fd = s; 99 pfd.events = POLLIN; 100 101 if (timeout > 0) { 102 gettimeofday(&t, NULL); 103 prevtime = (t.tv_sec * 1000) + t.tv_usec / 1000; 104 } 105 106 for(;;) { 107 result = poll(&pfd, 1, timeout); 108 if (result < 0 && errno == EINTR) { 109 if (timeout > 0) { 110 gettimeofday(&t, NULL); 111 newtime = (t.tv_sec * 1000) + t.tv_usec /1000; 112 timeout -= newtime - prevtime; 113 if (timeout <= 0) 114 return 0; 115 prevtime = newtime; 116 } 117 } else { 118 return result; 119 } 120 } 121 }