> 
> I am working with UNIX Sockets and have some questions that I 
> cant seem to find answers to on the web.
> 
> 1: Are UNIX sockets bi-directional?
> 
> 2: If so, what is the proper way to 'setup' the connection? 
> (will post what I have below)
> 
> 3: Do UNIX sockets have less overhead than INET sockets?
> 
> Here is what I have for the OO connections:
> 
> Server:
> 
> my $server = IO::Socket::UNIX->new(Local => "/tmp/mysock",
>                                    Type      => SOCK_DGRAM,
>                                    Listen    => 5 )
>   or die $@;
> 
> Client:
> 
> my $client = IO::Socket::UNIX->new (
>                                    Type  => SOCK_DGRAM,
>                                    Peer  => "/tmp/mysock",
>                                    )
> or die $@;
> 
> Right now, I am able to send information from the client to 
> the server, but not the other way around. When I try this, I 
> get:send: 
> 
> Cannot determine peer address at server.pl line 21
> 
> Here are lines 17-22:
> 
>   if($text ne 'exit')
>   {
>     print "\nReceived message '", $text,"'\n";
>     my $send = "I got: $text\n";
>     $server->send($send,128);        # <------- Line 21
>   }
> 
> I have tried multiple things with the creation of the socket, 
> but cant get the right combination. I am beginning to think 
> that UNIX sockets are not bi-directional, but I hope someone 
> proves me wrong.
> 
> If more information is needed, let me know.
> 
> Thanks for the help,
> 
> Dave Kettmann
> NetLogic
> 636-561-0680
> 

Hi Dave
I pasted some example code I have played with a while ago and it does work.
I can't rember which perldoc or perl book I got it from. 

#### SERVER
use IO::Socket;
use POSIX ":sys_wait_h";   # (for WNOHANG)

# example using unix domain socks
# once the file is created as a socket, any client can
# interact with it

my $sockname = "/tmp/unixsockd.sock";

start_daemon();

sub start_daemon {
    my $pid;
    if ($pid = fork()) {  
        # wait for child proc to die and do a non blocking wait for pending
zombies
        waitpid($pid, 0);
    } else {
        if ($pid = fork()) { exit; }
        $0 = "unixsockd: accepting connections on $sockname";  
        service_clients( get_sock() );       # wait for incoming requests
    }
}

sub get_sock {
    unlink $sockname;
    my $sock = IO::Socket::UNIX->new(
                   Local  => $sockname,
                   Type   => SOCK_STREAM,
                   Listen => SOMAXCONN,
               ) or die "$0: error starting daemon on '$sockname': [EMAIL 
PROTECTED]";
    # you might want to change permissions and ownership, e.g.:
    #chmod 0600, $sockname;
    #chown scalar getpwnam('nobody'), 0, $sockname;
    return $sock;
}

sub service_clients {
    my $sock = shift;
    $SIG{CHLD} = \&reaper;
    
    my $client;
    while ( $client = $sock->accept() ) {
        # fork yet another process to prevent buffer deadlock. one proc
writes to
        # the sock, the other reads the deamons response
        my $pid = fork();  die "Cannot fork\n" unless defined $pid;
        if ($pid) {                   # parent
            close $client;            # no use to parent
            next;                     # be ready for another client
        }
        # child
        close $sock;                  # no use to child
        process_requests($client);
        exit;                         # terminate child
    }
}

sub process_requests {
    my $client = shift;
    $0 = "unixsockd: handling requests...";  
    # read from client until empty line which causes it to close connection
    while ( my $line = <$client> ) {  # read line from socket
        last if $line =~ /^\s$/;      # exit on empty line
        chomp $line;
        # put some more useful code here to read each line or whatever...
        printf $client "%s: %s, handled by PID %d\n",
                       scalar localtime(time), $line, $$;
                                      # return something to client
    }
}

sub reaper { 
    while (waitpid(-1,WNOHANG) > 0) {}
    $SIG{CHLD} = \&reaper; 
}


## CLIENT

use IO::Socket;
my $sockname = "/tmp/unixsockd.sock";

my $client = IO::Socket::UNIX->new(
                 Peer    => $sockname,
                 Type    => SOCK_STREAM,
                 Timeout => 5,
             ) or die "$0: error connecting to '$sockname': [EMAIL PROTECTED]";

my $pid = fork();  die "Cannot fork\n" unless defined $pid;

if ($pid) {
    write_sock();
    waitpid($pid, 0);
} else {
    read_sock();
}

sub write_sock {
    for (1..10) {            
        print $client "testline number $_\n";    # print to socket
    }
    print $client "\n";        # empty line causes server
                               # to terminate connection
    print "Done writing.\n";  # (goes to stdout, not socket)
}

sub read_sock {
    while (my $line = <$client>) {
        print $line;           # report to stdout
        # simulate someone reading slooowly (50ms/line):
        select(undef, undef, undef, 0.05);
    }
}



-- 
No virus found in this outgoing message.
Checked by AVG Anti-Virus.
Version: 7.0.296 / Virus Database: 265.6.7 - Release Date: 12/30/2004
 


-- 
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
<http://learn.perl.org/> <http://learn.perl.org/first-response>


Reply via email to