[Chapter 7] 7.2.58 Socket - Load the C socket.h Defines and Structure Manipulators
Author: Larry Wall, Tom Christiansen & Randal L. Schwartz
Date: 1999-07-02T02:04:01Z

#

| Chapter 7 The Standard Perl Library |

### 7.2.58 Socket - Load the C socket.h Defines and Structure Manipulators

    use Socket;

    $proto = getprotobyname('udp');
    socket(Socket_Handle, PF_INET, SOCK_DGRAM, $proto);
    $iaddr = gethostbyname('hishost.com');
    $port = getservbyname('time', 'udp');
    $sin = sockaddr_in($port, $iaddr);
    send(Socket_Handle, 0, 0, $sin);

    $proto = getprotobyname('tcp');
    socket(Socket_Handle, PF_INET, SOCK_STREAM, $proto);
    $port = getservbyname('smtp');
    $sin = sockaddr_in($port, inet_aton("127.1"));
    $sin = sockaddr_in(7, inet_aton("localhost"));
    $sin = sockaddr_in(7, INADDR_LOOPBACK);
    connect(Socket_Handle, $sin);

    ($port, $iaddr) = sockaddr_in(getpeername(Socket_Handle));
    $peer_host = gethostbyaddr($iaddr, AF_INET);
    $peer_addr = inet_ntoa($iaddr);

    socket(Socket_Handle, PF_UNIX, SOCK_STREAM, 0);
    unlink('/tmp/usock');
    $sun = sockaddr_un('/tmp/usock');
    bind(Socket_Handle, $sun);

This module is just a translation of the C socket.h file. Unlike the old mechanism of requiring a translated socket.ph file, this uses the h2xs program (see the Perl source distribution) and your native C compiler. This means that it has a far more likely chance of getting the numbers right. This includes all of the commonly used preprocessor-defined constants like `AF_INET`, `SOCK_STREAM`, and so on.

In addition, some structure manipulation functions are available:

`inet_aton` `HOSTNAME`

  Takes a string giving the name of a host, and translates that to a four-byte, packed string (structure). Takes arguments of both the `rtfm.mit.edu` and `18.181.0.24` types. If the host name cannot be resolved, returns the undefined value.

`inet_ntoa` `IP_ADDRESS`

  Takes a four-byte IP address (as returned by `inet_aton()`) and translates it into a string of the form d.d.d.d where the ds are numbers less than 256 (the normal, readable, dotted-quad notation for Internet addresses).

`INADDR_ANY`

  Note: This function does not return a number, but a packed string. Returns the four-byte wildcard IP address that specifies any of the host's IP addresses. (A particular machine can have more than one IP address, each address corresponding to a particular network interface. This wildcard address allows you to bind to all of them simultaneously.) Normally equivalent to `inet_aton('0.0.0.0')`.

`INADDR_LOOPBACK`

  Note: does not return a number, but a packed string. Returns the four-byte loopback address. Normally equivalent to `inet_aton('localhost')`.

`INADDR_NONE`

  Note: does not return a number, but a packed string. Returns the four-byte invalid IP address. Normally equivalent to `inet_aton('255.255.255.255')`.

`sockaddr_in` `PORT, ADDRESS`

`sockaddr_in` `SOCKADDR_IN`

  In a list context, unpacks its `SOCKADDR_IN` argument and returns a list consisting of `(``PORT``,` `ADDRESS``)`. In a scalar context, packs its `(``PORT``,` `ADDRESS``)` arguments as a `SOCKADDR_IN` and returns it. If this is confusing, use `pack_sockaddr_in()` and `unpack_sockaddr_in()` explicitly.

`pack_sockaddr_in` `PORT, IP_ADDRESS`

  Takes two arguments, a port number and a four-byte `IP_ADDRESS` (as returned by `inet_aton()`). Returns the `sockaddr_in` structure with those arguments packed in with `AF_INET` filled in. For Internet domain sockets, this structure is normally what you need for the arguments in bind, connect, and send, and is also returned by getpeername, getsockname, and recv.

`unpack_sockaddr_in` `SOCKADDR_IN`

  Takes a `sockaddr_in` structure (as returned by `pack_sockaddr_in()`) and returns a list of two elements: the port and the four-byte IP address. This function will croak if the structure does not have `AF_INET` in the right place.

`sockaddr_un` `PATHNAME`

`sockaddr_un` `SOCKADDR_UN`

  In a list context, it unpacks its `SOCKADDR_UN` argument and returns a list consisting of `(``PATHNAME``)`. In a scalar context, it packs its `PATHNAME` argument as a `SOCKADDR_UN` and returns it. If this is confusing, use `pack_sockaddr_un()` and `unpack_sockaddr_un()` explicitly. These functions are only supported if your system has <sys/un.h>.

`pack_sockaddr_un` `PATH`

  Takes one argument, a pathname. Returns the `sockaddr_un` structure with that path packed in with `AF_UNIX` filled in. For UNIX domain sockets, this structure is normally what you need for the arguments in bind, connect, and send, and is also returned by getpeername, getsockname and recv.

`unpack_sockaddr_un` `SOCKADDR_UN`

  Takes a `sockaddr_un` structure (as returned by `pack_sockaddr_un()`) and returns the pathname. Will croak if the structure does not have `AF_UNIX` in the right place.

7.2.57 sigtrap - Enable Stack Backtrace on Unexpected Signals |  | 7.2.59 strict - Restrict Unsafe Constructs