Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
BEGIN LICENSE BLOCK ***** Version: CPL 1.0/GPL 2.0/LGPL 2.1 The contents of this file are subject to the Common Public License Version 1.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.eclipse.org/legal/cpl-v10.html Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License. Copyright (C) 2007 Damian Steer <pldms@mac.com> Alternatively, the contents of this file may be used under the terms of either of the GNU General Public License Version 2 or later (the "GPL"), or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), in which case the provisions of the GPL or the LGPL are applicable instead of those above. If you wish to allow use of your version of this file only under the terms of either the GPL or the LGPL, and not to allow others to use your version of this file under the terms of the CPL, indicate your decision by deleting the provisions above and replace them with the notice and other provisions required by the GPL or the LGPL. If you do not delete the provisions above, a recipient may use your version of this file under the terms of any one of the CPL, the GPL or the LGPL. END LICENSE BLOCK ***
27
 
28
 package org.jruby.ext.socket;
29
 
44
 
46
 import org.jruby.Ruby;

Author(s):
Damian Steer
66
 
67
 @JRubyClass(name="UDPSocket", parent="IPSocket")
68
 public class RubyUDPSocket extends RubyIPSocket {
69
 
70
     static void createUDPSocket(Ruby runtime) {
71
         RubyClass rb_cUDPSocket = runtime.defineClass("UDPSocket", runtime.getClass("IPSocket"), );
72
         
73
         rb_cUDPSocket.includeModule(runtime.getClass("Socket").getConstant("Constants"));
74
 
75
         rb_cUDPSocket.defineAnnotatedMethods(RubyUDPSocket.class);
76
 
77
         runtime.getObject().setConstant("UDPsocket", rb_cUDPSocket);
78
     }
79
 
80
     private static ObjectAllocator UDPSOCKET_ALLOCATOR = new ObjectAllocator() {
81
 
82
         public IRubyObject allocate(Ruby runtime, RubyClass klass) {
83
             return new RubyUDPSocket(runtime, klass);
84
         }
85
     };
86
 
87
     public RubyUDPSocket(Ruby runtime, RubyClass type) {
88
         super(runtime, type);
89
     }
90
 
91
     @JRubyMethod(visibility = .)
92
     public IRubyObject initialize(ThreadContext context) {
93
         Ruby runtime = context.runtime;
94
 
95
         try {
96
             DatagramChannel channel = DatagramChannel.open();
97
             initSocket(runtime, new ChannelDescriptor(channel, newModeFlags(runtime, .)));
98
 
99
         } catch (ConnectException e) {
100
            throw runtime.newErrnoECONNREFUSEDError();
102
        } catch (UnknownHostException e) {
103
            throw SocketUtils.sockerr(runtime, "initialize: name or service not known");
105
        } catch (IOException e) {
106
            throw SocketUtils.sockerr(runtime, "initialize: name or service not known");
107
        }
109
        return this;
110
    }
112
    @JRubyMethod(visibility = .)
113
    public IRubyObject initialize(ThreadContext context, IRubyObject protocol) {
114
        // we basically ignore protocol. let someone report it...
115
        return initialize(context);
116
    }
119
    public IRubyObject bind(ThreadContext context, IRubyObject host, IRubyObject _port) {
120
        Ruby runtime = context.runtime;
121
        InetSocketAddress addr = null;
123
        try {
124
            Channel channel = getChannel();
125
            int port = SocketUtils.portToInt(_port);
127
            if (host.isNil()
128
                || ((host instanceof RubyString)
129
                && ((RubyString) host).isEmpty())) {
131
                // host is nil or the empty string, bind to INADDR_ANY
132
                addr = new InetSocketAddress(port);
134
            } else if (host instanceof RubyFixnum) {
136
                // passing in something like INADDR_ANY
137
                int intAddr = RubyNumeric.fix2int(host);
138
                RubyModule socketMod = runtime.getModule("Socket");
139
                if (intAddr == RubyNumeric.fix2int(socketMod.getConstant("INADDR_ANY"))) {
140
                    addr = new InetSocketAddress(InetAddress.getByName("0.0.0.0"), port);
141
                }
143
            } else {
144
                // passing in something like INADDR_ANY
145
                addr = new InetSocketAddress(InetAddress.getByName(host.convertToString().toString()), port);
146
            }
148
            if ( == null) {
149
                ((DatagramChannel) channel).socket().bind(addr);
150
            } else {
151
                .rebindToPort(port);
152
            }
154
            return RubyFixnum.zero(runtime);
156
        } catch (UnknownHostException e) {
157
            throw SocketUtils.sockerr(runtime, "bind: name or service not known");
159
        } catch (SocketException e) {
160
            throw SocketUtils.sockerr(runtime, "bind: name or service not known");
162
        } catch (IOException e) {
163
            throw SocketUtils.sockerr(runtime, "bind: name or service not known");
165
        } catch (Error e) {
167
            // Workaround for a bug in Sun's JDK 1.5.x, see
168
            // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6303753
169
            if (e.getCause() instanceof SocketException) {
170
                throw SocketUtils.sockerr(runtime, "bind: name or service not known");
171
            } else {
172
                throw e;
173
            }
175
        }
176
    }
179
    public IRubyObject connect(ThreadContext context, IRubyObject host, IRubyObject port) {
180
        Ruby runtime = context.runtime;
182
        try {
183
            InetSocketAddress addr = new InetSocketAddress(InetAddress.getByName(host.convertToString().toString()), SocketUtils.portToInt(port));
185
            ((DatagramChannel) this.getChannel()).connect(addr);
187
            return RubyFixnum.zero(runtime);
189
        } catch (UnknownHostException e) {
190
            throw SocketUtils.sockerr(runtime, "connect: name or service not known");
191
            
192
        } catch (IOException e) {
193
            throw SocketUtils.sockerr(runtime, "connect: name or service not known");
194
        }
195
    }
198
    public IRubyObject recvfrom_nonblock(ThreadContext context, IRubyObject _length) {
199
        Ruby runtime = context.runtime;
201
        try {
202
            int length = RubyNumeric.fix2int(_length);
204
            ReceiveTuple tuple = doReceiveNonblockTuple(runtime, length);
206
            IRubyObject addressArray = addrFor(context, tuple.sender, false);
208
            return runtime.newArray(tuple.result, addressArray);
210
        } catch (UnknownHostException e) {
211
            throw SocketUtils.sockerr(runtime, "recvfrom: name or service not known");
213
        } catch (PortUnreachableException e) {
214
            throw runtime.newErrnoECONNREFUSEDError();
216
        } catch (IOException e) {
217
            throw SocketUtils.sockerr(runtime, "recvfrom: name or service not known");
218
        }
219
    }
222
    public IRubyObject recvfrom_nonblock(ThreadContext context, IRubyObject _length, IRubyObject _flags) {
223
        // TODO: handle flags
224
        return recvfrom_nonblock(context, _length);
225
    }
228
    public IRubyObject send(ThreadContext context, IRubyObject _mesg, IRubyObject _flags) {
229
        // TODO: implement flags
230
        Ruby runtime = context.runtime;
232
        try {
233
            int written;
235
            RubyString data = _mesg.convertToString();
236
            ByteBuffer buf = ByteBuffer.wrap(data.getBytes());
238
            written = ((DatagramChannel) this.getChannel()).write(buf);
240
            return runtime.newFixnum(written);
242
        } catch (NotYetConnectedException nyce) {
243
            throw runtime.newErrnoEDESTADDRREQError("send(2)");
245
        } catch (UnknownHostException e) {
246
            throw SocketUtils.sockerr(runtime, "send: name or service not known");
248
        } catch (IOException e) {
249
            throw SocketUtils.sockerr(runtime, "send: name or service not known");
250
        }
251
    }
254
    public IRubyObject send(ThreadContext context, IRubyObject _mesg, IRubyObject _flags, IRubyObject _to) {
255
        return send(context, _mesg, _flags);
256
    }
258
    @JRubyMethod(required = 2, optional = 2)
259
    public IRubyObject send(ThreadContext context, IRubyObject[] args) {
260
        // TODO: implement flags
261
        Ruby runtime = context.runtime;
262
        IRubyObject _mesg = args[0];
263
        IRubyObject _flags = args[1];
265
        try {
266
            int written;
268
            if (args.length == 2 || args.length == 3) {
269
                return send(context, _mesg, _flags);
270
            }
271
            
272
            IRubyObject _host = args[2];
273
            IRubyObject _port = args[3];
275
            RubyString nameStr = _host.convertToString();
276
            RubyString data = _mesg.convertToString();
277
            ByteBuffer buf = ByteBuffer.wrap(data.getBytes());
279
            byte[] buf2 = data.getBytes();
280
            DatagramPacket sendDP = null;
282
            int port;
283
            if (_port instanceof RubyString) {
285
                Service service = Service.getServiceByName(_port.asJavaString(), "udp");
287
                if (service != null) {
288
                    port = service.getPort();
289
                } else {
290
                    port = (int)_port.convertToInteger("to_i").getLongValue();
291
                }
293
            } else {
294
                port = (int)_port.convertToInteger().getLongValue();
295
            }
297
            InetAddress address = SocketUtils.getRubyInetAddress(nameStr.getByteList());
298
            InetSocketAddress addr = new InetSocketAddress(address, port);
300
            if (this. == null) {
301
                written = ((DatagramChannel) this.getChannel()).send(buf, addr);
303
            } else {
304
                sendDP = new DatagramPacket(buf2, buf2.length, address, port);
305
                .rebindToPort(port);
306
                MulticastSocket ms = this..getMulticastSocket();
308
                ms.send(sendDP);
309
                written = sendDP.getLength();
310
            }
312
            return runtime.newFixnum(written);
314
        } catch (UnknownHostException e) {
315
            throw SocketUtils.sockerr(runtime, "send: name or service not known");
317
        } catch (IOException e) {
318
            throw SocketUtils.sockerr(runtime, "send: name or service not known");
319
        }
320
    }
322
    @JRubyMethod(rest = true, meta = true)
323
    public static IRubyObject open(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {
324
        RubyUDPSocket sock = (RubyUDPSocket) recv.callMethod(context, "new", args);
326
        if (!block.isGiven()) {
327
            return sock;
328
        }
330
        try {
331
            return block.yield(context, sock);
333
        } finally {
334
            if (sock.openFile.isOpen()) {
335
                sock.close();
336
            }
337
        }
338
    }

    
Overrides IPSocket#recvfrom 
343
    @Override
344
    public IRubyObject recvfrom(ThreadContext context, IRubyObject _length) {
345
        Ruby runtime = context.runtime;
347
        try {
348
            int length = RubyNumeric.fix2int(_length);
350
            ReceiveTuple tuple = doReceiveTuple(runtime, length);
352
            IRubyObject addressArray = addrFor(context, tuple.sender, false);
354
            return runtime.newArray(tuple.result, addressArray);
356
        } catch (UnknownHostException e) {
357
            throw SocketUtils.sockerr(runtime, "recvfrom: name or service not known");
359
        } catch (PortUnreachableException e) {
360
            throw runtime.newErrnoECONNREFUSEDError();
362
        } catch (IOException e) {
363
            throw SocketUtils.sockerr(runtime, "recvfrom: name or service not known");
364
        }
365
    }

    
Overrides IPSocket#recvfrom 
370
    @Override
371
    public IRubyObject recvfrom(ThreadContext context, IRubyObject _length, IRubyObject _flags) {
372
        // TODO: handle flags
373
        return recvfrom(context, _length);
374
    }

    
Overrides BasicSocket#recv 
379
    @Override
380
    public IRubyObject recv(ThreadContext context, IRubyObject _length) {
381
        Ruby runtime = context.runtime;
383
        try {
384
            return doReceive(runtime, RubyNumeric.fix2int(_length));
386
        } catch (IOException e) {
387
            throw SocketUtils.sockerr(runtime, "recv: name or service not known");
389
        }
390
    }

    
Overrides BasicSocket#recv 
395
    @Override
396
    public IRubyObject recv(ThreadContext context, IRubyObject _length, IRubyObject _flags) {
397
        // TODO: implement flags
398
        return recv(context, _length);
399
    }
401
    private ReceiveTuple doReceiveTuple(Ruby runtime, int length) throws IOException {
402
        ReceiveTuple tuple = new ReceiveTuple();
404
        if (this. == null) {
405
            doReceive(runtime, length, tuple);
406
        } else {
407
            doReceiveMulticast(runtime, length, tuple);
408
        }
410
        return tuple;
411
    }
413
    private ReceiveTuple doReceiveNonblockTuple(Ruby runtime, int length) throws IOException {
414
        DatagramChannel channel = (DatagramChannel)getChannel();
416
        synchronized (channel.blockingLock()) {
417
            boolean oldBlocking = channel.isBlocking();
419
            channel.configureBlocking(false);
421
            try {
422
                return doReceiveTuple(runtime, length);
424
            } finally {
425
                channel.configureBlocking(oldBlocking);
426
            }
427
        }
428
    }
430
    private static class ReceiveTuple {
431
        ReceiveTuple() {}
432
        ReceiveTuple(RubyString result, InetSocketAddress sender) {
433
            this. = result;
434
            this. = sender;
435
        }
437
        RubyString result;
438
        InetSocketAddress sender;
439
    }
441
    private IRubyObject doReceive(Ruby runtime, int length) throws IOException {
442
        return doReceive(runtime, length, null);
443
    }
445
    private IRubyObject doReceive(Ruby runtime, int length, ReceiveTuple tuple) throws IOException {
446
        DatagramChannel channel = (DatagramChannel)getChannel();
448
        ByteBuffer buf = ByteBuffer.allocate(length);
450
        InetSocketAddress sender = (InetSocketAddress)channel.receive(buf);
452
        if (sender == null) {
453
            // noblocking receive
454
            if (runtime.is1_9()) {
455
                throw runtime.newErrnoEAGAINReadableError("recvfrom(2) would block");
456
            } else {
457
                throw runtime.newErrnoEAGAINError("recvfrom(2) would block");
458
            }
459
        }
461
        // see JRUBY-4678
462
        if (sender == null) {
463
            throw runtime.newErrnoECONNRESETError();
464
        }
466
        RubyString result = runtime.newString(new ByteList(buf.array(), 0, buf.position()));
468
        if (tuple != null) {
469
            tuple.result = result;
470
            tuple.sender = sender;
471
        }
473
        return result;
474
    }
476
    private IRubyObject doReceiveMulticast(Ruby runtime, int length, ReceiveTuple tuple) throws IOException {
477
        byte[] buf2 = new byte[length];
478
        DatagramPacket recv = new DatagramPacket(buf2, buf2.length);
482
        try {
483
            ms.receive(recv);
484
        } catch (IllegalBlockingModeException ibme) {
485
            // MulticastSocket does not support nonblocking
486
            // TODO: Use Java 7 NIO.2 DatagramChannel to do multicast
487
            if (runtime.is1_9()) {
488
                throw runtime.newErrnoEAGAINReadableError("multicast UDP does not support nonblocking");
489
            } else {
490
                throw runtime.newErrnoEAGAINError("multicast UDP does not support nonblocking");
491
            }
492
        }
494
        InetSocketAddress sender = (InetSocketAddress) recv.getSocketAddress();
496
        // see JRUBY-4678
497
        if (sender == null) {
498
            throw runtime.newErrnoECONNRESETError();
499
        }
501
        RubyString result = runtime.newString(new ByteList(recv.getData(), 0, recv.getLength()));
503
        if (tuple != null) {
504
            tuple.result = result;
505
            tuple.sender = sender;
506
        }
508
        return result;
509
    }
511
    @Deprecated
512
    public IRubyObject bind(IRubyObject host, IRubyObject port) {
513
        return bind(getRuntime().getCurrentContext(), host, port);
514
    }
516
    @Deprecated
517
    public IRubyObject connect(IRubyObject host, IRubyObject port) {
518
        return connect(getRuntime().getCurrentContext(), host, port);
519
    }
521
    @Deprecated
522
    public IRubyObject recvfrom(IRubyObject[] args) {
523
        return recvfrom(getRuntime().getCurrentContext(), args);
524
    }
526
    @Deprecated
527
    public IRubyObject send(IRubyObject[] args) {
528
        return send(getRuntime().getCurrentContext(), args);
529
    }
531
    @Deprecated
532
    public static IRubyObject open(IRubyObject recv, IRubyObject[] args, Block block) {
533
        return open(recv.getRuntime().getCurrentContext(), recv, args, block);
534
    }
535
}// RubyUDPSocket