← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to external/ikvm/openjdk/sun/nio/ch/Net.java

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
external/ikvm/openjdk/sun/nio/ch/Net.java
 
1
/*
 
2
 * Copyright (c) 2000, 2011, 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
package sun.nio.ch;
 
27
 
 
28
import java.io.*;
 
29
import java.net.*;
 
30
import java.nio.channels.*;
 
31
import java.util.*;
 
32
import java.security.AccessController;
 
33
import java.security.PrivilegedAction;
 
34
 
 
35
 
 
36
class Net {                                             // package-private
 
37
 
 
38
    private Net() { }
 
39
 
 
40
    // unspecified protocol family
 
41
    static final ProtocolFamily UNSPEC = new ProtocolFamily() {
 
42
        public String name() {
 
43
            return "UNSPEC";
 
44
        }
 
45
    };
 
46
 
 
47
    // -- Miscellaneous utilities --
 
48
 
 
49
    private static volatile boolean checkedIPv6 = false;
 
50
    private static volatile boolean isIPv6Available;
 
51
 
 
52
    /**
 
53
     * Tells whether dual-IPv4/IPv6 sockets should be used.
 
54
     */
 
55
    static boolean isIPv6Available() {
 
56
        if (!checkedIPv6) {
 
57
            isIPv6Available = isIPv6Available0();
 
58
            checkedIPv6 = true;
 
59
        }
 
60
        return isIPv6Available;
 
61
    }
 
62
 
 
63
    /**
 
64
     * Tells whether IPv6 sockets can join IPv4 multicast groups
 
65
     */
 
66
    static boolean canIPv6SocketJoinIPv4Group() {
 
67
        return canIPv6SocketJoinIPv4Group0();
 
68
    }
 
69
 
 
70
    /**
 
71
     * Tells whether {@link #join6} can be used to join an IPv4
 
72
     * multicast group (IPv4 group as IPv4-mapped IPv6 address)
 
73
     */
 
74
    static boolean canJoin6WithIPv4Group() {
 
75
        return canJoin6WithIPv4Group0();
 
76
    }
 
77
 
 
78
    static InetSocketAddress checkAddress(SocketAddress sa) {
 
79
        if (sa == null)
 
80
            throw new NullPointerException();
 
81
        if (!(sa instanceof InetSocketAddress))
 
82
            throw new UnsupportedAddressTypeException(); // ## needs arg
 
83
        InetSocketAddress isa = (InetSocketAddress)sa;
 
84
        if (isa.isUnresolved())
 
85
            throw new UnresolvedAddressException(); // ## needs arg
 
86
        InetAddress addr = isa.getAddress();
 
87
        if (!(addr instanceof Inet4Address || addr instanceof Inet6Address))
 
88
            throw new IllegalArgumentException("Invalid address type");
 
89
        return isa;
 
90
    }
 
91
 
 
92
    static InetSocketAddress asInetSocketAddress(SocketAddress sa) {
 
93
        if (!(sa instanceof InetSocketAddress))
 
94
            throw new UnsupportedAddressTypeException();
 
95
        return (InetSocketAddress)sa;
 
96
    }
 
97
 
 
98
    static void translateToSocketException(Exception x)
 
99
        throws SocketException
 
100
    {
 
101
        if (x instanceof SocketException)
 
102
            throw (SocketException)x;
 
103
        Exception nx = x;
 
104
        if (x instanceof ClosedChannelException)
 
105
            nx = new SocketException("Socket is closed");
 
106
        else if (x instanceof NotYetConnectedException)
 
107
            nx = new SocketException("Socket is not connected");
 
108
        else if (x instanceof AlreadyBoundException)
 
109
            nx = new SocketException("Already bound");
 
110
        else if (x instanceof NotYetBoundException)
 
111
            nx = new SocketException("Socket is not bound yet");
 
112
        else if (x instanceof UnsupportedAddressTypeException)
 
113
            nx = new SocketException("Unsupported address type");
 
114
        else if (x instanceof UnresolvedAddressException) {
 
115
            nx = new SocketException("Unresolved address");
 
116
        }
 
117
        if (nx != x)
 
118
            nx.initCause(x);
 
119
 
 
120
        if (nx instanceof SocketException)
 
121
            throw (SocketException)nx;
 
122
        else if (nx instanceof RuntimeException)
 
123
            throw (RuntimeException)nx;
 
124
        else
 
125
            throw new Error("Untranslated exception", nx);
 
126
    }
 
127
 
 
128
    static void translateException(Exception x,
 
129
                                   boolean unknownHostForUnresolved)
 
130
        throws IOException
 
131
    {
 
132
        if (x instanceof IOException)
 
133
            throw (IOException)x;
 
134
        // Throw UnknownHostException from here since it cannot
 
135
        // be thrown as a SocketException
 
136
        if (unknownHostForUnresolved &&
 
137
            (x instanceof UnresolvedAddressException))
 
138
        {
 
139
             throw new UnknownHostException();
 
140
        }
 
141
        translateToSocketException(x);
 
142
    }
 
143
 
 
144
    static void translateException(Exception x)
 
145
        throws IOException
 
146
    {
 
147
        translateException(x, false);
 
148
    }
 
149
 
 
150
    /**
 
151
     * Returns any IPv4 address of the given network interface, or
 
152
     * null if the interface does not have any IPv4 addresses.
 
153
     */
 
154
    static Inet4Address anyInet4Address(final NetworkInterface interf) {
 
155
        return AccessController.doPrivileged(new PrivilegedAction<Inet4Address>() {
 
156
            public Inet4Address run() {
 
157
                Enumeration<InetAddress> addrs = interf.getInetAddresses();
 
158
                while (addrs.hasMoreElements()) {
 
159
                    InetAddress addr = addrs.nextElement();
 
160
                    if (addr instanceof Inet4Address) {
 
161
                        return (Inet4Address)addr;
 
162
                    }
 
163
                }
 
164
                return null;
 
165
            }
 
166
        });
 
167
    }
 
168
 
 
169
    /**
 
170
     * Returns an IPv4 address as an int.
 
171
     */
 
172
    static int inet4AsInt(InetAddress ia) {
 
173
        if (ia instanceof Inet4Address) {
 
174
            byte[] addr = ia.getAddress();
 
175
            int address  = addr[3] & 0xFF;
 
176
            address |= ((addr[2] << 8) & 0xFF00);
 
177
            address |= ((addr[1] << 16) & 0xFF0000);
 
178
            address |= ((addr[0] << 24) & 0xFF000000);
 
179
            return address;
 
180
        }
 
181
        throw new AssertionError("Should not reach here");
 
182
    }
 
183
 
 
184
    /**
 
185
     * Returns an InetAddress from the given IPv4 address
 
186
     * represented as an int.
 
187
     */
 
188
    static InetAddress inet4FromInt(int address) {
 
189
        byte[] addr = new byte[4];
 
190
        addr[0] = (byte) ((address >>> 24) & 0xFF);
 
191
        addr[1] = (byte) ((address >>> 16) & 0xFF);
 
192
        addr[2] = (byte) ((address >>> 8) & 0xFF);
 
193
        addr[3] = (byte) (address & 0xFF);
 
194
        try {
 
195
            return InetAddress.getByAddress(addr);
 
196
        } catch (UnknownHostException uhe) {
 
197
            throw new AssertionError("Should not reach here");
 
198
        }
 
199
    }
 
200
 
 
201
    /**
 
202
     * Returns an IPv6 address as a byte array
 
203
     */
 
204
    static byte[] inet6AsByteArray(InetAddress ia) {
 
205
        if (ia instanceof Inet6Address) {
 
206
            return ia.getAddress();
 
207
        }
 
208
 
 
209
        // need to construct IPv4-mapped address
 
210
        if (ia instanceof Inet4Address) {
 
211
            byte[] ip4address = ia.getAddress();
 
212
            byte[] address = new byte[16];
 
213
            address[10] = (byte)0xff;
 
214
            address[11] = (byte)0xff;
 
215
            address[12] = ip4address[0];
 
216
            address[13] = ip4address[1];
 
217
            address[14] = ip4address[2];
 
218
            address[15] = ip4address[3];
 
219
            return address;
 
220
        }
 
221
 
 
222
        throw new AssertionError("Should not reach here");
 
223
    }
 
224
 
 
225
    // -- Socket options
 
226
 
 
227
    static void setSocketOption(FileDescriptor fd, ProtocolFamily family,
 
228
                                SocketOption<?> name, Object value)
 
229
        throws IOException
 
230
    {
 
231
        if (value == null)
 
232
            throw new IllegalArgumentException("Invalid option value");
 
233
 
 
234
        // only simple values supported by this method
 
235
        Class<?> type = name.type();
 
236
        if (type != Integer.class && type != Boolean.class)
 
237
            throw new AssertionError("Should not reach here");
 
238
 
 
239
        // special handling
 
240
        if (name == StandardSocketOptions.SO_RCVBUF ||
 
241
            name == StandardSocketOptions.SO_SNDBUF)
 
242
        {
 
243
            int i = ((Integer)value).intValue();
 
244
            if (i < 0)
 
245
                throw new IllegalArgumentException("Invalid send/receive buffer size");
 
246
        }
 
247
        if (name == StandardSocketOptions.SO_LINGER) {
 
248
            int i = ((Integer)value).intValue();
 
249
            if (i < 0)
 
250
                value = Integer.valueOf(-1);
 
251
            if (i > 65535)
 
252
                value = Integer.valueOf(65535);
 
253
        }
 
254
        if (name == StandardSocketOptions.IP_TOS) {
 
255
            int i = ((Integer)value).intValue();
 
256
            if (i < 0 || i > 255)
 
257
                throw new IllegalArgumentException("Invalid IP_TOS value");
 
258
        }
 
259
        if (name == StandardSocketOptions.IP_MULTICAST_TTL) {
 
260
            int i = ((Integer)value).intValue();
 
261
            if (i < 0 || i > 255)
 
262
                throw new IllegalArgumentException("Invalid TTL/hop value");
 
263
        }
 
264
 
 
265
        // map option name to platform level/name
 
266
        OptionKey key = SocketOptionRegistry.findOption(name, family);
 
267
        if (key == null)
 
268
            throw new AssertionError("Option not found");
 
269
 
 
270
        int arg;
 
271
        if (type == Integer.class) {
 
272
            arg = ((Integer)value).intValue();
 
273
        } else {
 
274
            boolean b = ((Boolean)value).booleanValue();
 
275
            arg = (b) ? 1 : 0;
 
276
        }
 
277
 
 
278
        boolean mayNeedConversion = (family == UNSPEC);
 
279
        setIntOption0(fd, mayNeedConversion, key.level(), key.name(), arg);
 
280
    }
 
281
 
 
282
    static Object getSocketOption(FileDescriptor fd, ProtocolFamily family,
 
283
                                  SocketOption<?> name)
 
284
        throws IOException
 
285
    {
 
286
        Class<?> type = name.type();
 
287
 
 
288
        // only simple values supported by this method
 
289
        if (type != Integer.class && type != Boolean.class)
 
290
            throw new AssertionError("Should not reach here");
 
291
 
 
292
        // map option name to platform level/name
 
293
        OptionKey key = SocketOptionRegistry.findOption(name, family);
 
294
        if (key == null)
 
295
            throw new AssertionError("Option not found");
 
296
 
 
297
        boolean mayNeedConversion = (family == UNSPEC);
 
298
        int value = getIntOption0(fd, mayNeedConversion, key.level(), key.name());
 
299
 
 
300
        if (type == Integer.class) {
 
301
            return Integer.valueOf(value);
 
302
        } else {
 
303
            return (value == 0) ? Boolean.FALSE : Boolean.TRUE;
 
304
        }
 
305
    }
 
306
 
 
307
    // -- Socket operations --
 
308
 
 
309
    private static native boolean isIPv6Available0();
 
310
 
 
311
    private static native boolean canIPv6SocketJoinIPv4Group0();
 
312
 
 
313
    private static native boolean canJoin6WithIPv4Group0();
 
314
 
 
315
    static FileDescriptor socket(boolean stream) throws IOException {
 
316
        return socket(UNSPEC, stream);
 
317
    }
 
318
 
 
319
    static FileDescriptor socket(ProtocolFamily family, boolean stream)
 
320
        throws IOException {
 
321
        boolean preferIPv6 = isIPv6Available() &&
 
322
            (family != StandardProtocolFamily.INET);
 
323
        return socket0(preferIPv6, stream, false);
 
324
    }
 
325
 
 
326
    static FileDescriptor serverSocket(boolean stream) {
 
327
        return socket0(isIPv6Available(), stream, true);
 
328
    }
 
329
 
 
330
    // Due to oddities SO_REUSEADDR on windows reuse is ignored
 
331
    private static native FileDescriptor socket0(boolean preferIPv6, boolean stream, boolean reuse);
 
332
 
 
333
    static void bind(FileDescriptor fd, InetAddress addr, int port)
 
334
        throws IOException
 
335
    {
 
336
        bind(UNSPEC, fd, addr, port);
 
337
    }
 
338
 
 
339
    static void bind(ProtocolFamily family, FileDescriptor fd,
 
340
                     InetAddress addr, int port) throws IOException
 
341
    {
 
342
        boolean preferIPv6 = isIPv6Available() &&
 
343
            (family != StandardProtocolFamily.INET);
 
344
        bind0(preferIPv6, fd, addr, port);
 
345
    }
 
346
 
 
347
    private static native void bind0(boolean preferIPv6, FileDescriptor fd,
 
348
                                     InetAddress addr, int port)
 
349
        throws IOException;
 
350
 
 
351
    static native void listen(FileDescriptor fd, int backlog) throws IOException;
 
352
 
 
353
    static int connect(FileDescriptor fd, InetAddress remote, int remotePort)
 
354
        throws IOException
 
355
    {
 
356
        return connect(UNSPEC, fd, remote, remotePort);
 
357
    }
 
358
 
 
359
    static int connect(ProtocolFamily family, FileDescriptor fd, InetAddress remote, int remotePort)
 
360
        throws IOException
 
361
    {
 
362
        boolean preferIPv6 = isIPv6Available() &&
 
363
            (family != StandardProtocolFamily.INET);
 
364
        return connect0(preferIPv6, fd, remote, remotePort);
 
365
    }
 
366
 
 
367
    private static native int connect0(boolean preferIPv6,
 
368
                                       FileDescriptor fd,
 
369
                                       InetAddress remote,
 
370
                                       int remotePort)
 
371
        throws IOException;
 
372
 
 
373
 
 
374
    public final static int SHUT_RD = 0;
 
375
    public final static int SHUT_WR = 1;
 
376
    public final static int SHUT_RDWR = 2;
 
377
 
 
378
    static native void shutdown(FileDescriptor fd, int how) throws IOException;
 
379
 
 
380
    private static native int localPort(FileDescriptor fd)
 
381
        throws IOException;
 
382
 
 
383
    private static native InetAddress localInetAddress(FileDescriptor fd)
 
384
        throws IOException;
 
385
 
 
386
    static InetSocketAddress localAddress(FileDescriptor fd)
 
387
        throws IOException
 
388
    {
 
389
        return new InetSocketAddress(localInetAddress(fd), localPort(fd));
 
390
    }
 
391
 
 
392
    private static native int remotePort(FileDescriptor fd)
 
393
        throws IOException;
 
394
 
 
395
    private static native InetAddress remoteInetAddress(FileDescriptor fd)
 
396
        throws IOException;
 
397
 
 
398
    static InetSocketAddress remoteAddress(FileDescriptor fd)
 
399
        throws IOException
 
400
    {
 
401
        return new InetSocketAddress(remoteInetAddress(fd), remotePort(fd));
 
402
    }
 
403
 
 
404
    private static native int getIntOption0(FileDescriptor fd, boolean mayNeedConversion,
 
405
                                            int level, int opt)
 
406
        throws IOException;
 
407
 
 
408
    private static native void setIntOption0(FileDescriptor fd, boolean mayNeedConversion,
 
409
                                             int level, int opt, int arg)
 
410
        throws IOException;
 
411
 
 
412
    // -- Multicast support --
 
413
 
 
414
 
 
415
    /**
 
416
     * Join IPv4 multicast group
 
417
     */
 
418
    static int join4(FileDescriptor fd, int group, int interf, int source)
 
419
        throws IOException
 
420
    {
 
421
        return joinOrDrop4(true, fd, group, interf, source);
 
422
    }
 
423
 
 
424
    /**
 
425
     * Drop membership of IPv4 multicast group
 
426
     */
 
427
    static void drop4(FileDescriptor fd, int group, int interf, int source)
 
428
        throws IOException
 
429
    {
 
430
        joinOrDrop4(false, fd, group, interf, source);
 
431
    }
 
432
 
 
433
    private static native int joinOrDrop4(boolean join, FileDescriptor fd, int group, int interf, int source)
 
434
        throws IOException;
 
435
 
 
436
    /**
 
437
     * Block IPv4 source
 
438
     */
 
439
    static int block4(FileDescriptor fd, int group, int interf, int source)
 
440
        throws IOException
 
441
    {
 
442
        return blockOrUnblock4(true, fd, group, interf, source);
 
443
    }
 
444
 
 
445
    /**
 
446
     * Unblock IPv6 source
 
447
     */
 
448
    static void unblock4(FileDescriptor fd, int group, int interf, int source)
 
449
        throws IOException
 
450
    {
 
451
        blockOrUnblock4(false, fd, group, interf, source);
 
452
    }
 
453
 
 
454
    private static native int blockOrUnblock4(boolean block, FileDescriptor fd, int group,
 
455
                                              int interf, int source)
 
456
        throws IOException;
 
457
 
 
458
    /**
 
459
     * Join IPv6 multicast group
 
460
     */
 
461
    static int join6(FileDescriptor fd, byte[] group, int index, byte[] source)
 
462
        throws IOException
 
463
    {
 
464
        return joinOrDrop6(true, fd, group, index, source);
 
465
    }
 
466
 
 
467
    /**
 
468
     * Drop membership of IPv6 multicast group
 
469
     */
 
470
    static void drop6(FileDescriptor fd, byte[] group, int index, byte[] source)
 
471
        throws IOException
 
472
    {
 
473
        joinOrDrop6(false, fd, group, index, source);
 
474
    }
 
475
 
 
476
    private static native int joinOrDrop6(boolean join, FileDescriptor fd, byte[] group, int index, byte[] source)
 
477
        throws IOException;
 
478
 
 
479
    /**
 
480
     * Block IPv6 source
 
481
     */
 
482
    static int block6(FileDescriptor fd, byte[] group, int index, byte[] source)
 
483
        throws IOException
 
484
    {
 
485
        return blockOrUnblock6(true, fd, group, index, source);
 
486
    }
 
487
 
 
488
    /**
 
489
     * Unblock IPv6 source
 
490
     */
 
491
    static void unblock6(FileDescriptor fd, byte[] group, int index, byte[] source)
 
492
        throws IOException
 
493
    {
 
494
        blockOrUnblock6(false, fd, group, index, source);
 
495
    }
 
496
 
 
497
    static native int blockOrUnblock6(boolean block, FileDescriptor fd, byte[] group, int index, byte[] source)
 
498
        throws IOException;
 
499
 
 
500
    static native void setInterface4(FileDescriptor fd, int interf) throws IOException;
 
501
 
 
502
    static native int getInterface4(FileDescriptor fd) throws IOException;
 
503
 
 
504
    static native void setInterface6(FileDescriptor fd, int index) throws IOException;
 
505
 
 
506
    static native int getInterface6(FileDescriptor fd) throws IOException;
 
507
 
 
508
}