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

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
BEGIN LICENSE BLOCK ***** Version: EPL 1.0/GPL 2.0/LGPL 2.1 The contents of this file are subject to the Eclipse 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/epl-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 Ola Bini <ola@ologix.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 EPL, 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 EPL, the GPL or the LGPL. END LICENSE BLOCK ***
27
 
28
 package org.jruby.ext.socket;
29
 
43
 import org.jruby.Ruby;
56
 

Author(s):
Ola Bini
75
 
76
 @JRubyClass(name="Socket", parent="BasicSocket", include="Socket::Constants")
77
 public class RubySocket extends RubyBasicSocket {
78
     static void createSocket(Ruby runtime) {
79
         RubyClass rb_cSocket = runtime.defineClass("Socket", runtime.getClass("BasicSocket"), );
80
 
81
         RubyModule rb_mConstants = rb_cSocket.defineModuleUnder("Constants");
82
         // we don't have to define any that we don't support; see socket.c
83
 
84
         runtime.loadConstantSet(rb_mConstants, Sock.class);
85
         runtime.loadConstantSet(rb_mConstants, SocketOption.class);
86
         runtime.loadConstantSet(rb_mConstants, SocketLevel.class);
87
         runtime.loadConstantSet(rb_mConstants, ProtocolFamily.class);
88
         runtime.loadConstantSet(rb_mConstants, AddressFamily.class);
89
         runtime.loadConstantSet(rb_mConstants, INAddr.class);
90
         runtime.loadConstantSet(rb_mConstants, IPProto.class);
91
         runtime.loadConstantSet(rb_mConstants, Shutdown.class);
92
         runtime.loadConstantSet(rb_mConstants, TCP.class);
93
         runtime.loadConstantSet(rb_mConstants, NameInfo.class);
94
 
95
         // this value seems to be hardcoded in MRI to 5 when not defined, but
96
         // it is 128 on OS X. We use 128 for now until we can get it added to
97
         // jnr-constants.
98
         rb_mConstants.setConstant("SOMAXCONN", RubyFixnum.newFixnum(runtime, 128));
99
 
100
        // mandatory constants we haven't implemented
101
        rb_mConstants.setConstant("MSG_OOB", runtime.newFixnum());
102
        rb_mConstants.setConstant("MSG_PEEK", runtime.newFixnum());
103
        rb_mConstants.setConstant("MSG_DONTROUTE", runtime.newFixnum());
104
        rb_mConstants.setConstant("MSG_WAITALL", runtime.newFixnum());
106
        // constants webrick crashes without
107
        rb_mConstants.setConstant("AI_PASSIVE", runtime.newFixnum(1));
109
        // More constants needed by specs
110
        rb_mConstants.setConstant("IP_MULTICAST_TTL", runtime.newFixnum(10));
111
        rb_mConstants.setConstant("IP_MULTICAST_LOOP", runtime.newFixnum(11));
112
        rb_mConstants.setConstant("IP_ADD_MEMBERSHIP", runtime.newFixnum(12));
113
        rb_mConstants.setConstant("IP_MAX_MEMBERSHIPS", runtime.newFixnum(20));
114
        rb_mConstants.setConstant("IP_DEFAULT_MULTICAST_LOOP", runtime.newFixnum(1));
115
        rb_mConstants.setConstant("IP_DEFAULT_MULTICAST_TTL", runtime.newFixnum(1));
117
        rb_cSocket.includeModule(rb_mConstants);
119
        rb_cSocket.defineAnnotatedMethods(RubySocket.class);
120
    }
122
    private static ObjectAllocator SOCKET_ALLOCATOR = new ObjectAllocator() {
123
        @Override
124
        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
125
            return new RubySocket(runtime, klass);
126
        }
127
    };
129
    public RubySocket(Ruby runtime, RubyClass type) {
130
        super(runtime, type);
131
    }
133
    @JRubyMethod(meta = true)
134
    public static IRubyObject for_fd(ThreadContext context, IRubyObject socketClass, IRubyObject fd) {
135
        Ruby runtime = context.runtime;
137
        if (fd instanceof RubyFixnum) {
138
            int intFD = (int)((RubyFixnum)fd).getLongValue();
140
            ChannelDescriptor descriptor = ChannelDescriptor.getDescriptorByFileno(intFD);
142
            if (descriptor == null) {
143
                throw runtime.newErrnoEBADFError();
144
            }
146
            RubySocket socket = (RubySocket)((RubyClass)socketClass).allocate();
148
            socket.initFieldsFromDescriptor(runtime, descriptor);
150
            socket.initSocket(runtime, descriptor);
152
            return socket;
153
        } else {
154
            throw runtime.newTypeError(fd, context.runtime.getFixnum());
155
        }
156
    }
158
    @JRubyMethod(compat = .)
159
    public IRubyObject initialize(ThreadContext context, IRubyObject domain, IRubyObject type, IRubyObject protocol) {
160
        Ruby runtime = context.runtime;
162
        initFieldsFromArgs(runtime, domain, type, protocol);
164
        ChannelDescriptor descriptor = initChannel(runtime);
166
        initSocket(runtime, descriptor);
168
        return this;
169
    }
171
    @JRubyMethod(name = "initialize", compat = .)
172
    public IRubyObject initialize19(ThreadContext context, IRubyObject domain, IRubyObject type) {
173
        Ruby runtime = context.runtime;
175
        initFieldsFromArgs(runtime, domain, type);
177
        ChannelDescriptor descriptor = initChannel(runtime);
179
        initSocket(runtime, descriptor);
181
        return this;
182
    }
184
    @JRubyMethod(name = "initialize", compat = .)
185
    public IRubyObject initialize19(ThreadContext context, IRubyObject domain, IRubyObject type, IRubyObject protocol) {
186
        Ruby runtime = context.runtime;
188
        initFieldsFromArgs(runtime, domain, type, protocol);
190
        ChannelDescriptor descriptor = initChannel(runtime);
192
        initSocket(runtime, descriptor);
194
        return this;
195
    }
197
    @JRubyMethod()
198
    public IRubyObject connect_nonblock(ThreadContext context, IRubyObject arg) {
199
        SocketAddress addr = addressForChannel(context, arg);
201
        doConnectNonblock(context, getChannel(), addr);
203
        return RubyFixnum.zero(context.runtime);
204
    }
206
    @JRubyMethod()
207
    public IRubyObject connect(ThreadContext context, IRubyObject arg) {
208
        SocketAddress addr = addressForChannel(context, arg);
210
        doConnect(context, getChannel(), addr);
212
        return RubyFixnum.zero(context.runtime);
213
    }
215
    @JRubyMethod()
216
    public IRubyObject bind(ThreadContext context, IRubyObject arg) {
217
        InetSocketAddress iaddr = Sockaddr.addressFromArg(context, arg);
219
        doBind(context, getChannel(), iaddr);
221
        return RubyFixnum.zero(context.runtime);
222
    }
225
    public IRubyObject recvfrom(ThreadContext context, IRubyObject length) {
226
        return super.recv(context, length);
227
    }
230
    public IRubyObject recvfrom(ThreadContext context, IRubyObject length, IRubyObject flags) {
231
        return super.recv(context, length, flags);
232
    }
235
    public IRubyObject recvfrom_nonblock(ThreadContext context, IRubyObject length) {
236
        return super.recv_nonblock(context, length);
237
    }
240
    public IRubyObject recvfrom_nonblock(ThreadContext context, IRubyObject length, IRubyObject flags) {
241
        return super.recv_nonblock(context, length, flags);
242
    }
244
    @JRubyMethod(notImplemented = true)
245
    public IRubyObject listen(ThreadContext context, IRubyObject backlog) {
246
        throw SocketUtils.sockerr(context.runtime, );
247
    }
249
    @JRubyMethod(notImplemented = true)
250
    public IRubyObject accept(ThreadContext context) {
251
        throw SocketUtils.sockerr(context.runtime, );
252
    }
254
    @JRubyMethod(meta = true)
255
    public static IRubyObject gethostname(ThreadContext context, IRubyObject recv) {
256
        return SocketUtils.gethostname(context);
257
    }
259
    @JRubyMethod(required = 1, rest = true, meta = true)
260
    public static IRubyObject gethostbyaddr(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
261
        return SocketUtils.gethostbyaddr(context, args);
262
    }
264
    @JRubyMethod(required = 1, optional = 1, meta = true)
265
    public static IRubyObject getservbyname(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
266
        return SocketUtils.getservbyname(context, args);
267
    }
269
    @JRubyMethod(name = {"pack_sockaddr_in", "sockaddr_in"}, meta = true)
270
    public static IRubyObject pack_sockaddr_in(ThreadContext context, IRubyObject recv, IRubyObject port, IRubyObject host) {
271
        return SocketUtils.pack_sockaddr_in(context, port, host);
272
    }
274
    @JRubyMethod(meta = true)
275
    public static IRubyObject unpack_sockaddr_in(ThreadContext context, IRubyObject recv, IRubyObject addr) {
276
        return Sockaddr.unpack_sockaddr_in(context, addr);
277
    }
279
    @JRubyMethod(name = {"pack_sockaddr_un", "sockaddr_un"}, meta = true)
280
    public static IRubyObject pack_sockaddr_un(ThreadContext context, IRubyObject recv, IRubyObject filename) {
281
        return SocketUtils.pack_sockaddr_un(context, filename);
282
    }
284
    @JRubyMethod(meta = true)
285
    public static IRubyObject gethostbyname(ThreadContext context, IRubyObject recv, IRubyObject hostname) {
286
        return SocketUtils.gethostbyname(context, hostname);
287
    }
289
    @JRubyMethod(required = 2, optional = 4, meta = true)
290
    public static IRubyObject getaddrinfo(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
291
        return SocketUtils.getaddrinfo(context, args);
292
    }
294
    @JRubyMethod(required = 1, optional = 1, meta = true)
295
    public static IRubyObject getnameinfo(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
296
        return SocketUtils.getnameinfo(context, args);
297
    }
299
    @JRubyMethod(meta = true, compat = .)
300
    public static IRubyObject ip_address_list(ThreadContext context, IRubyObject self) {
301
        return SocketUtils.ip_address_list(context);
302
    }
304
    @Override
305
    protected Sock getDefaultSocketType() {
306
        return ;
307
    }
309
    private void initFieldsFromDescriptor(Ruby runtime, ChannelDescriptor descriptor) {
310
        Channel mainChannel = descriptor.getChannel();
312
        if (mainChannel instanceof SocketChannel) {
313
            // ok, it's a socket...set values accordingly
314
            // just using AF_INET since we can't tell from SocketChannel...
315
             = .;
316
             = .;
317
             = .;
319
        } else if (mainChannel instanceof UnixSocketChannel) {
320
             = .;
321
             = .;
322
             = .;
324
        } else if (mainChannel instanceof DatagramChannel) {
325
            // datagram, set accordingly
326
            // again, AF_INET
327
             = .;
328
             = .;
329
             = .;
331
        } else {
332
            throw runtime.newErrnoENOTSOCKError("can't Socket.new/for_fd against a non-socket");
333
        }
334
    }
336
    private void initFieldsFromArgs(Ruby runtime, IRubyObject domain, IRubyObject type, IRubyObject protocol) {
337
        initDomain(runtime, domain);
339
        initType(runtime, type);
341
        initProtocol(runtime, protocol);
342
    }
344
    private void initFieldsFromArgs(Ruby runtime, IRubyObject domain, IRubyObject type) {
345
        initDomain(runtime, domain);
347
        initType(runtime, type);
348
    }
350
    protected void initFromServer(Ruby runtime, RubyServerSocket serverSocket, SocketChannel socketChannel) {
351
         = serverSocket.soDomain;
352
         = serverSocket.soType;
353
         = serverSocket.soProtocol;
355
        initSocket(runtime, newChannelDescriptor(runtime, socketChannel));
356
    }
358
    protected ChannelDescriptor initChannel(Ruby runtime) {
359
        Channel channel;
361
        try {
362
            if( == .) {
364
                if ( == . ||
365
                         == .) {
366
                    channel = UnixSocketChannel.open();
367
                } else if ( == . ||
368
                         == . ||
369
                         == .) {
370
                    channel = SocketChannel.open();
371
                } else {
372
                    throw runtime.newArgumentError("unsupported protocol family `" +  + "'");
373
                }
375
            } else if( == .) {
376
                channel = DatagramChannel.open();
378
            } else {
379
                throw runtime.newArgumentError("unsupported socket type `" +  + "'");
381
            }
383
            return newChannelDescriptor(runtime, channel);
385
        } catch(IOException e) {
386
            throw SocketUtils.sockerr(runtime, "initialize: " + e.toString());
388
        }
389
    }
391
    protected static ChannelDescriptor newChannelDescriptor(Ruby runtime, Channel channel) {
392
        ModeFlags modeFlags = newModeFlags(runtime, .);
394
        return new ChannelDescriptor(channel, modeFlags);
395
    }
397
    private void initProtocol(Ruby runtime, IRubyObject protocol) {
398
        ProtocolFamily protocolFamily = SocketUtils.protocolFamilyFromArg(protocol);
400
        if (protocolFamily == null) {
401
            return; // no protocol specified, ignore it
402
        }
404
         = protocolFamily;
405
    }
407
    private void initType(Ruby runtime, IRubyObject type) {
408
        Sock sockType = SocketUtils.sockFromArg(type);
410
        if (sockType == null) {
411
            throw SocketUtils.sockerr(runtime, "unknown socket type " + type);
412
        }
414
         = sockType;
415
    }
417
    private void initDomain(Ruby runtime, IRubyObject domain) {
418
        AddressFamily family = SocketUtils.addressFamilyFromArg(domain);
420
        if (family == null) {
421
            throw SocketUtils.sockerr(runtime, "unknown socket domain " + domain);
422
        }
424
         = family;
425
         = ProtocolFamily.valueOf("PF" + .name().substring(2));
426
    }
428
    private void doConnectNonblock(ThreadContext context, Channel channel, SocketAddress addr) {
429
        if (!(channel instanceof SelectableChannel)) {
430
            throw getRuntime().newErrnoENOPROTOOPTError();
431
        }
433
        SelectableChannel selectable = (SelectableChannel)channel;
434
        synchronized (selectable.blockingLock()) {
435
            boolean oldBlocking = selectable.isBlocking();
436
            try {
437
                selectable.configureBlocking(false);
439
                try {
440
                    doConnect(context, channel, addr);
442
                } finally {
443
                    selectable.configureBlocking(oldBlocking);
444
                }
446
            } catch(ClosedChannelException e) {
447
                throw context.runtime.newErrnoECONNREFUSEDError();
449
            } catch(IOException e) {
450
                throw SocketUtils.sockerr(context.runtime, "connect(2): name or service not known");
451
            }
452
        }
453
    }
455
    protected void doConnect(ThreadContext context, Channel channel, SocketAddress addr) {
456
        Ruby runtime = context.runtime;
458
        try {
459
            if (channel instanceof SocketChannel) {
460
                SocketChannel socket = (SocketChannel)channel;
461
                boolean result;
462
                
463
                if (socket.isConnectionPending()) {
464
                    // connection initiated but not finished
465
                    result = socket.finishConnect();
466
                } else {
467
                    result = socket.connect(addr);
468
                }
470
                if(!result) {
471
                    if (runtime.is1_9()) {
472
                        throw runtime.newErrnoEINPROGRESSWritableError();
473
                    } else {
474
                        throw runtime.newErrnoEINPROGRESSError();
475
                    }
476
                }
478
            } else if (channel instanceof UnixSocketChannel) {
479
                ((UnixSocketChannel)channel).connect((UnixSocketAddress)addr);
481
            } else if (channel instanceof DatagramChannel) {
482
                ((DatagramChannel)channel).connect(addr);
484
            } else {
485
                throw runtime.newErrnoENOPROTOOPTError();
487
            }
489
        } catch(AlreadyConnectedException e) {
490
            throw runtime.newErrnoEISCONNError();
492
        } catch(ConnectionPendingException e) {
493
            if (runtime.is1_9()) {
494
                throw runtime.newErrnoEINPROGRESSWritableError();
495
            } else {
496
                throw runtime.newErrnoEINPROGRESSError();
497
            }
499
        } catch(UnknownHostException e) {
500
            throw SocketUtils.sockerr(runtime, "connect(2): unknown host");
502
        } catch(SocketException e) {
503
            handleSocketException(runtime, "connect", e);
505
        } catch(IOException e) {
506
            throw SocketUtils.sockerr(runtime, "connect(2): name or service not known");
508
        } catch (IllegalArgumentException iae) {
509
            throw SocketUtils.sockerr(runtime, iae.getMessage());
511
        }
512
    }
514
    protected void doBind(ThreadContext context, Channel channel, InetSocketAddress iaddr) {
515
        Ruby runtime = context.runtime;
517
        try {
518
            if (channel instanceof SocketChannel) {
519
                Socket socket = ((SocketChannel)channel).socket();
520
                socket.bind(iaddr);
522
            } else if (channel instanceof UnixSocketChannel) {
523
                // do nothing
525
            } else if (channel instanceof DatagramChannel) {
526
                DatagramSocket socket = ((DatagramChannel)channel).socket();
527
                socket.bind(iaddr);
529
            } else {
530
                throw runtime.newErrnoENOPROTOOPTError();
531
            }
533
        } catch(UnknownHostException e) {
534
            throw SocketUtils.sockerr(runtime, "bind(2): unknown host");
536
        } catch(SocketException e) {
537
            handleSocketException(runtime, "bind", e);
539
        } catch(IOException e) {
540
            throw SocketUtils.sockerr(runtime, "bind(2): name or service not known");
542
        } catch (IllegalArgumentException iae) {
543
            throw SocketUtils.sockerr(runtime, iae.getMessage());
545
        }
546
    }
548
    protected void handleSocketException(Ruby runtime, String caller, SocketException e) {
549
        String msg = formatMessage(e, "bind");
551
        // This is ugly, but what can we do, Java provides the same exception type
552
        // for different situations, so we differentiate the errors
553
        // based on the exception's message.
554
        if (.matcher(msg).find()) {
555
            throw runtime.newErrnoEINVALError(msg);
556
        } else if (.matcher(msg).find()) {
557
            throw runtime.newErrnoEADDRNOTAVAILError(msg);
558
        } else if (.matcher(msg).find()) {
559
            throw runtime.newErrnoEACCESError(msg);
560
        } else {
561
            throw runtime.newErrnoEADDRINUSEError(msg);
562
        }
563
    }
565
    private static String formatMessage(Throwable e, String defaultMsg) {
566
        String msg = e.getMessage();
567
        if (msg == null) {
568
            msg = defaultMsg;
569
        } else {
570
            msg = defaultMsg + " - " + msg;
571
        }
572
        return msg;
573
    }
575
    private SocketAddress addressForChannel(ThreadContext context, IRubyObject arg) {
576
        if (arg instanceof Addrinfo) return Sockaddr.addressFromArg(context, arg);
578
        switch () {
579
            case :
580
            case :
581
                return Sockaddr.addressFromSockaddr_un(context, arg);
583
            case :
584
            case :
585
            case :
586
                return Sockaddr.addressFromSockaddr_in(context, arg);
588
            default:
589
                throw context.runtime.newArgumentError("unsupported protocol family `" +  + "'");
590
        }
591
    }
593
    @Deprecated
594
    public static RuntimeException sockerr(Ruby runtime, String msg) {
595
        return new RaiseException(runtime, runtime.getClass("SocketError"), msg, true);
596
    }
598
    private static final Pattern ALREADY_BOUND_PATTERN = Pattern.compile("[Aa]lready.*bound");
599
    private static final Pattern ADDR_NOT_AVAIL_PATTERN = Pattern.compile("assign.*address");
600
    private static final Pattern PERM_DENIED_PATTERN = Pattern.compile("[Pp]ermission.*denied");
602
    public static final int MSG_OOB = 0x1;
603
    public static final int MSG_PEEK = 0x2;
604
    public static final int MSG_DONTROUTE = 0x4;
605
    public static final int MSG_WAITALL = 0x100;
607
    protected AddressFamily soDomain;
608
    protected Sock soType;
609
    protected ProtocolFamily soProtocol;
611
    private static final String JRUBY_SERVER_SOCKET_ERROR =
612
            "use ServerSocket for servers (http://wiki.jruby.org/ServerSocket)";
613
}// RubySocket