Class: Kgio::Socket

### Home Classes Methods

### In Files

- ext/kgio/accept.c

### Parent

cSocket

### Methods

- ::connect
- ::new
- ::start
- #kgio_fastopen

### Included Modules

- mSocketMethods

### Files

- HACKING
- ISSUES
- LATEST
- LICENSE
- NEWS
- README
- TODO

### Class/Module Index

Quicksearch

- Kgio
- Kgio::DefaultWaiters
- Kgio::File
- Kgio::Pipe
- Kgio::PipeMethods
- Kgio::Socket
- Kgio::SocketMethods
- Kgio::TCPServer
- Kgio::TCPSocket
- Kgio::UNIXServer
- Kgio::UNIXSocket

No matching classes.

# Kgio::Socket

A generic socket class with Kgio::SocketMethods included. This is returned by all Kgio methods that accept(2) a connected stream socket.

### Public Class Methods

addr = Socket.pack_sockaddr_in(80, 'example.com') click to toggle source
Kgio::Socket.connect(addr) → socket
addr = Socket.pack_sockaddr_un("/path/to/unix/socket")
Kgio::Socket.connect(addr) → socket

Creates a generic Kgio::Socket object and initiates a non-blocking connection.

This may block and call any method defined to `kgio_wait_writable` for the class.

    static VALUE kgio_connect(VALUE klass, VALUE addr)
    {
            return stream_connect(klass, addr, 1);
    }

new(*args) click to toggle source

If passed one argument, this is identical to Kgio::Socket.connect. If passed two or three arguments, it uses its superclass method:

    Socket.new(domain, socktype [, protocol ])

    static VALUE kgio_new(int argc, VALUE *argv, VALUE klass)
    {
            if (argc == 1)
                    /* backwards compat, the only way for kgio <= 2.7.4 */
                    return stream_connect(klass, argv[0], 1);

            return rb_call_super(argc, argv);
    }

addr = Socket.pack_sockaddr_in(80, 'example.com') click to toggle source
Kgio::Socket.start(addr) → socket
addr = Socket.pack_sockaddr_un("/path/to/unix/socket")
Kgio::Socket.start(addr) → socket

Creates a generic Kgio::Socket object and initiates a non-blocking connection. The caller should select/poll on the socket for writability before attempting to write or optimistically attempt a write and handle :wait_writable or Errno::EAGAIN.

    static VALUE kgio_start(VALUE klass, VALUE addr)
    {
            return stream_connect(klass, addr, 0);
    }

### Public Instance Methods

s = Kgio::Socket.new(:INET, :STREAM) click to toggle source
addr = Socket.pack_sockaddr_in(80, "example.com")
kgio_fastopen("hello world", addr) → nil

Starts a TCP connection using TCP Fast Open. This uses a blocking sendto() syscall and is only available on Ruby 1.9 or later. This raises exceptions (including Errno::EINPROGRESS/Errno::EAGAIN) on errors. Using this is only recommended for blocking sockets.

Timeouts may be set with setsockopt:

    s.setsockopt(:SOCKET, :SNDTIMEO, [1,0].pack("l_l_"))

    static VALUE fastopen(VALUE sock, VALUE buf, VALUE addr)
    {
            struct tfo_args a;
            VALUE str = (TYPE(buf) == T_STRING) ? buf : rb_obj_as_string(buf);
            ssize_t w;

            a.fd = my_fileno(sock);
            a.buf = RSTRING_PTR(str);
            a.buflen = (size_t)RSTRING_LEN(str);
            a.addr = sockaddr_from(&a.addrlen, addr);

            /* n.b. rb_thread_blocking_region preserves errno */
            w = (ssize_t)rb_thread_io_blocking_region(tfo_sendto, &a, a.fd);
            if (w < 0)
                    rb_sys_fail("sendto");
            if ((size_t)w == a.buflen)
                    return Qnil;

            return rb_str_subseq(str, w, a.buflen - w);
    }

[Validate]

Generated with the Darkfish Rdoc Generator 2.