1 /*
2 * Copyright (c) 1998, 2008, 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 <stdlib.h>
27 #include <sys/types.h>
28 #include <sys/socket.h>
29 #include <netinet/in.h>
30 #include <arpa/inet.h>
31 #include <unistd.h>
32 #include <fcntl.h>
33 #include <errno.h>
34 #include <string.h>
35 #include <sys/time.h>
36 #ifdef __solaris__
37 #include <thread.h>
38 #endif
39 #if defined(__linux__) || defined(_ALLBSD_SOURCE)
40 #include <pthread.h>
41 #include <sys/poll.h>
42 #endif
43
44 #include "socket_md.h"
45 #include "sysSocket.h"
46
47 int
48 dbgsysListen(int fd, int backlog) {
49 return listen(fd, backlog);
50 }
51
52 int
53 dbgsysConnect(int fd, struct sockaddr *name, int namelen) {
54 int rv = connect(fd, name, namelen);
55 if (rv < 0 && (errno == EINPROGRESS || errno == EINTR)) {
56 return DBG_EINPROGRESS;
57 } else {
58 return rv;
59 }
60 }
61
62 int
63 dbgsysFinishConnect(int fd, long timeout) {
64 int rv = dbgsysPoll(fd, 0, 1, timeout);
65 if (rv == 0) {
66 return DBG_ETIMEOUT;
67 }
68 if (rv > 0) {
69 return 0;
70 }
71 return rv;
72 }
73
74 int
75 dbgsysAccept(int fd, struct sockaddr *name, int *namelen) {
76 int rv;
77 for (;;) {
78 rv = accept(fd, name, namelen);
79 if (rv >= 0) {
80 return rv;
81 }
82 if (errno != ECONNABORTED && errno != EINTR) {
83 return rv;
84 }
85 }
86 }
87
88 int
89 dbgsysRecvFrom(int fd, char *buf, int nBytes,
90 int flags, struct sockaddr *from, int *fromlen) {
91 int rv;
92 do {
93 rv = recvfrom(fd, buf, nBytes, flags, from, fromlen);
94 } while (rv == -1 && errno == EINTR);
95
96 return rv;
97 }
98
99 int
100 dbgsysSendTo(int fd, char *buf, int len,
101 int flags, struct sockaddr *to, int tolen) {
102 int rv;
103 do {
104 rv = sendto(fd, buf, len, flags, to, tolen);
105 } while (rv == -1 && errno == EINTR);
106
107 return rv;
108 }
109
110 int
111 dbgsysRecv(int fd, char *buf, int nBytes, int flags) {
112 int rv;
113 do {
114 rv = recv(fd, buf, nBytes, flags);
115 } while (rv == -1 && errno == EINTR);
116
117 return rv;
118 }
119
120 int
121 dbgsysSend(int fd, char *buf, int nBytes, int flags) {
122 int rv;
123 do {
124 rv = send(fd, buf, nBytes, flags);
125 } while (rv == -1 && errno == EINTR);
126
127 return rv;
128 }
129
130 struct hostent *
131 dbgsysGetHostByName(char *hostname) {
132 return gethostbyname(hostname);
133 }
134
135 unsigned short
136 dbgsysHostToNetworkShort(unsigned short hostshort) {
137 return htons(hostshort);
138 }
139
140 int
141 dbgsysSocket(int domain, int type, int protocol) {
142 return socket(domain, type, protocol);
143 }
144
145 int dbgsysSocketClose(int fd) {
146 int rv;
147 do {
148 rv = close(fd);
149 } while (rv == -1 && errno == EINTR);
150
151 return rv;
152 }
153
154 int
155 dbgsysBind(int fd, struct sockaddr *name, int namelen) {
156 return bind(fd, name, namelen);
157 }
158
159 uint32_t
160 dbgsysInetAddr(const char* cp) {
161 return (uint32_t)inet_addr(cp);
162 }
163
164 uint32_t
165 dbgsysHostToNetworkLong(uint32_t hostlong) {
166 return htonl(hostlong);
167 }
168
169 unsigned short
170 dbgsysNetworkToHostShort(unsigned short netshort) {
171 return ntohs(netshort);
172 }
173
174 int
175 dbgsysGetSocketName(int fd, struct sockaddr *name, int *namelen) {
176 return getsockname(fd, name, namelen);
177 }
178
179 uint32_t
180 dbgsysNetworkToHostLong(uint32_t netlong) {
181 return ntohl(netlong);
182 }
183
184
185 int
186 dbgsysSetSocketOption(int fd, jint cmd, jboolean on, jvalue value)
187 {
188 if (cmd == TCP_NODELAY) {
189 struct protoent *proto = getprotobyname("TCP");
190 int tcp_level = (proto == 0 ? IPPROTO_TCP: proto->p_proto);
191 uint32_t onl = (uint32_t)on;
192
193 if (setsockopt(fd, tcp_level, TCP_NODELAY,
194 (char *)&onl, sizeof(uint32_t)) < 0) {
195 return SYS_ERR;
196 }
197 } else if (cmd == SO_LINGER) {
198 struct linger arg;
199 arg.l_onoff = on;
200
201 if(on) {
202 arg.l_linger = (unsigned short)value.i;
203 if(setsockopt(fd, SOL_SOCKET, SO_LINGER,
204 (char*)&arg, sizeof(arg)) < 0) {
205 return SYS_ERR;
206 }
207 } else {
208 if (setsockopt(fd, SOL_SOCKET, SO_LINGER,
209 (char*)&arg, sizeof(arg)) < 0) {
210 return SYS_ERR;
211 }
212 }
213 } else if (cmd == SO_SNDBUF) {
214 jint buflen = value.i;
215 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF,
216 (char *)&buflen, sizeof(buflen)) < 0) {
217 return SYS_ERR;
218 }
219 } else if (cmd == SO_REUSEADDR) {
220 int oni = (int)on;
221 if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
222 (char *)&oni, sizeof(oni)) < 0) {
223 return SYS_ERR;
224
225 }
226 } else {
227 return SYS_ERR;
228 }
229 return SYS_OK;
230 }
231
232 int
233 dbgsysConfigureBlocking(int fd, jboolean blocking) {
234 int flags = fcntl(fd, F_GETFL);
235
236 if ((blocking == JNI_FALSE) && !(flags & O_NONBLOCK)) {
237 return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
238 }
239 if ((blocking == JNI_TRUE) && (flags & O_NONBLOCK)) {
240 return fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
241 }
242 return 0;
243 }
244
245 int
246 dbgsysPoll(int fd, jboolean rd, jboolean wr, long timeout) {
247 struct pollfd fds[1];
248 int rv;
249
250 fds[0].fd = fd;
251 fds[0].events = 0;
252 if (rd) {
253 fds[0].events |= POLLIN;
254 }
255 if (wr) {
256 fds[0].events |= POLLOUT;
257 }
258 fds[0].revents = 0;
259
260 rv = poll(&fds[0], 1, timeout);
261 if (rv >= 0) {
262 rv = 0;
263 if (fds[0].revents & POLLIN) {
264 rv |= DBG_POLLIN;
265 }
266 if (fds[0].revents & POLLOUT) {
267 rv |= DBG_POLLOUT;
268 }
269 }
270 return rv;
271 }
272
273 int
274 dbgsysGetLastIOError(char *buf, jint size) {
275 char *msg = strerror(errno);
276 strncpy(buf, msg, size-1);
277 buf[size-1] = '\0';
278 return 0;
279 }
280
281 #ifdef __solaris__
282 int
283 dbgsysTlsAlloc() {
284 thread_key_t tk;
285 if (thr_keycreate(&tk, NULL)) {
286 perror("thr_keycreate");
287 exit(-1);
288 }
289 return (int)tk;
290 }
291
292 void
293 dbgsysTlsFree(int index) {
294 /* no-op */
295 }
296
297 void
298 dbgsysTlsPut(int index, void *value) {
299 thr_setspecific((thread_key_t)index, value) ;
300 }
301
302 void *
303 dbgsysTlsGet(int index) {
304 void* r = NULL;
305 thr_getspecific((thread_key_t)index, &r);
306 return r;
307 }
308
309 #endif
310
311 #if defined(__linux__) || defined(_ALLBSD_SOURCE)
312 int
313 dbgsysTlsAlloc() {
314 pthread_key_t key;
315 if (pthread_key_create(&key, NULL)) {
316 perror("pthread_key_create");
317 exit(-1);
318 }
319 return (int)key;
320 }
321
322 void
323 dbgsysTlsFree(int index) {
324 pthread_key_delete((pthread_key_t)index);
325 }
326
327 void
328 dbgsysTlsPut(int index, void *value) {
329 pthread_setspecific((pthread_key_t)index, value) ;
330 }
331
332 void *
333 dbgsysTlsGet(int index) {
334 return pthread_getspecific((pthread_key_t)index);
335 }
336
337 #endif
338
339 long
340 dbgsysCurrentTimeMillis() {
341 struct timeval t;
342 gettimeofday(&t, 0);
343 return ((jlong)t.tv_sec) * 1000 + (jlong)(t.tv_usec/1000);
344 }