NAME

IO::Lambda::Socket - wrapper condition for socket functions

DESCRIPTION

This module provides a set of convenient wrapper conditions for sockets that function as sources of asynchronous events. The condition names are homonyms of the underlying socket functions: accept, connect, recv, and send. The module doesn't account for much lower-lever socket machinery, the programmer is expected to create non-blocking sockets using IO::Socket or Socket modules.

SYNOPSIS

        use IO::Socket;
        use IO::Lambda qw(:all);
        use IO::Lambda::Socket qw(:all);

TCP

        my $server = IO::Socket::INET-> new(
                Listen    => 5,
                LocalPort => 10000,
                Blocking  => 0,
                ReuseAddr => 1,
        );
        die $! unless $server;

        my $serv = lambda {
                context $server;
                accept {
                        my $conn = shift;
                        die "error:$conn\n" unless ref($conn);
                        again;
                        context getline, $conn, \(my $buf = '');
                tail {
                        next unless defined $_[0];
                        print "you said: $_[0]";
                        again;
                }}
        };

        sub connector 
        {
                my $id = shift;
                lambda {
                        my $client = IO::Socket::INET-> new(
                                PeerAddr  => 'localhost',
                                PeerPort => 10000,
                                Blocking  => 0,
                        );
                        context $client;
                connect {
                        die "error:$_[0]\n" if @_;
                        print $client "hello from $id\n";
                }}
        }

        $serv-> wait_for_all( map { connector($_) } 1..5);

UDP

        my $server = IO::Socket::INET-> new(
                LocalPort => 10000,
                Blocking  => 0,
                Proto     => 'udp',
        );
        die $! unless $server;

        my $serv = lambda {
                context $server, 256;
                recv {
                        my ($addr, $msg) = @_;
                        my ($port, $iaddr) = sockaddr_in($addr);
                        my $host = inet_ntoa($iaddr);
                        die "error:$msg\n" unless defined $addr;
                        print "udp_recv($host:$port): $msg\n";
                        again;
                }
        };

        sub connector 
        {
                my $id = shift;
                lambda {
                        my $client = IO::Socket::INET-> new(
                                PeerAddr  => 'localhost',
                                PeerPort  => 10000,
                                Proto     => 'udp',
                                Blocking  => 0,
                        );
                        context $client, "hello from $id";
                send {
                        die "send error:$_[1]\n" unless $_[0];
                }}
        }

        $serv-> wait_for_all( map { connector($_) } 1..3);

API

accept($socket, $deadline=undef) -> ($new_socket | undef,$error)

Expects a stream $socket in a non-blocking listening state. Finishes either after a new connection arrives, or after $deadline is expired. Returns a new socket serving the new connection on success, undef and an error string on failure. The error string is either timeout or $!.

See also "accept" in perlfunc.

connect($socket, $deadline=undef) -> (()|$error)

Expects stream $socket in a non-blocking connect state. Finishes either after the connection succeeds, or after $deadline is expired. Returns no parameters on success, and an error string on failure. The error string is either timeout or $! (or $^E on win32).

See also "connect" in perlfunc.

recv($socket, $length, $flags=0, $deadline=undef) -> ($addr,$msg | undef,$error)

Expects a non-blocking datagram $socket. After the socket becomes readable, tries to read $length bytes using CORE::recv call. Returns remote address (packed) and the received message on success. Returns undef and an error string on failure. The error string is either timeout or $!.

See also "recv" in perlfunc.

send($socket, $msg, $flags, $to=undef, $deadline=undef) -> ($nbytes | undef,$error)

Expects a non-blocking datagram $socket. After the socket becomes writable, tries to write $msg using CORE::send call. Depending whether $to is defined or not, 4- or 3- parameter version of CORE::send is used. Returns number of bytes sent on success. On failure returns undef and an error string. The error string is either timeout or $!.

See also "send" in perlfunc.

LICENSE AND COPYRIGHT

This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

AUTHOR

Dmitry Karasik, <dmitry@karasik.eu.org>.