1IO::Socket(3pm) Perl Programmers Reference Guide IO::Socket(3pm)
2
6 IO::Socket - Object interface to socket communications
7
9 use strict;
10 use warnings;
11 use IO::Socket qw(AF_INET AF_UNIX);
13 # create a new AF_INET socket
15 my $sock = IO::Socket->new(Domain => AF_INET);
16 # which is the same as
17 $sock = IO::Socket::INET->new();
18 # create a new AF_UNIX socket
20 $sock = IO::Socket->new(Domain => AF_UNIX);
21 # which is the same as
22 $sock = IO::Socket::UNIX->new();
23
25 "IO::Socket" provides an object-oriented, IO::Handle-based interface to
26 creating and using sockets via Socket, which provides a near one-to-one
27 interface to the C socket library.
28 "IO::Socket" is a base class that really only defines methods for those
30 operations which are common to all types of sockets. Operations which
31 are specific to a particular socket domain have methods defined in
32 subclasses of "IO::Socket". See IO::Socket::INET, IO::Socket::UNIX, and
33 IO::Socket::IP for examples of such a subclass.
34 "IO::Socket" will export all functions (and constants) defined by
36 Socket.
37
39 Given that "IO::Socket" doesn't have attributes in the traditional
40 sense, the following arguments, rather than attributes, can be passed
41 into the constructor.
42 Constructor arguments should be passed in "Key => 'Value'" pairs.
44 The only required argument is "Domain" in IO::Socket.
46 Blocking
48 my $sock = IO::Socket->new(..., Blocking => 1);
49 $sock = IO::Socket->new(..., Blocking => 0);
50 If defined but false, the socket will be set to non-blocking mode. If
52 not specified it defaults to 1 (blocking mode).
53 Domain
55 my $sock = IO::Socket->new(Domain => IO::Socket::AF_INET);
56 $sock = IO::Socket->new(Domain => IO::Socket::AF_UNIX);
57 The socket domain will define which subclass of "IO::Socket" to use.
59 The two options available along with this distribution are "AF_INET"
60 and "AF_UNIX".
61 "AF_INET" is for the internet address family of sockets and is handled
63 via IO::Socket::INET. "AF_INET" sockets are bound to an internet
64 address and port.
65 "AF_UNIX" is for the unix domain socket and is handled via
67 IO::Socket::UNIX. "AF_UNIX" sockets are bound to the file system as
68 their address name space.
69 This argument is required. All other arguments are optional.
71 Listen
73 my $sock = IO::Socket->new(..., Listen => 5);
74 Listen should be an integer value or left unset.
76 If provided, this argument will place the socket into listening mode.
78 New connections can then be accepted using the "accept" in IO::Socket
79 method. The value given is used as the listen(2) queue size.
80 If the "Listen" argument is given, but false, the queue size will be
82 set to 5.
83 Timeout
85 my $sock = IO::Socket->new(..., Timeout => 5);
86 The timeout value, in seconds, for this socket connection. How exactly
88 this value is utilized is defined in the socket domain subclasses that
89 make use of the value.
90 Type
92 my $sock = IO::Socket->new(..., Type => IO::Socket::SOCK_STREAM);
93 The socket type that will be used. These are usually "SOCK_STREAM",
95 "SOCK_DGRAM", or "SOCK_RAW". If this argument is left undefined an
96 attempt will be made to infer the type from the service name.
97 For example, you'll usually use "SOCK_STREAM" with a "tcp" connection
99 and "SOCK_DGRAM" with a "udp" connection.
100
102 "IO::Socket" extends the IO::Handle constructor.
103 new
105 my $sock = IO::Socket->new();
106 # get a new IO::Socket::INET instance
108 $sock = IO::Socket->new(Domain => IO::Socket::AF_INET);
109 # get a new IO::Socket::UNIX instance
110 $sock = IO::Socket->new(Domain => IO::Socket::AF_UNIX);
111 # Domain is the only required argument
113 $sock = IO::Socket->new(
114 Domain => IO::Socket::AF_INET, # AF_INET, AF_UNIX
115 Type => IO::Socket::SOCK_STREAM, # SOCK_STREAM, SOCK_DGRAM, ...
116 Proto => 'tcp', # 'tcp', 'udp', IPPROTO_TCP, IPPROTO_UDP
117 # and so on...
118 );
119 Creates an "IO::Socket", which is a reference to a newly created symbol
121 (see the Symbol package). "new" optionally takes arguments, these
122 arguments are defined in "CONSTRUCTOR ARGUMENTS" in IO::Socket.
123 Any of the "CONSTRUCTOR ARGUMENTS" in IO::Socket may be passed to the
125 constructor, but if any arguments are provided, then one of them must
126 be the "Domain" in IO::Socket argument. The "Domain" in IO::Socket
127 argument can, by default, be either "AF_INET" or "AF_UNIX". Other
128 domains can be used if a proper subclass for the domain family is
129 registered. All other arguments will be passed to the "configuration"
130 method of the package for that domain.
131 If the constructor fails it will return "undef" and set the $errstr
133 package variable to contain an error message.
134 $sock = IO::Socket->new(...)
136 or die "Cannot create socket - $IO::Socket::errstr\n";
137 For legacy reasons the error message is also set into the global $@
139 variable, and you may still find older code which looks here instead.
140 $sock = IO::Socket->new(...)
142 or die "Cannot create socket - $@\n";
143
145 "IO::Socket" inherits all methods from IO::Handle and implements the
146 following new ones.
147 accept
149 my $client_sock = $sock->accept();
150 my $inet_sock = $sock->accept('IO::Socket::INET');
151 The accept method will perform the system call "accept" on the socket
153 and return a new object. The new object will be created in the same
154 class as the listen socket, unless a specific package name is
155 specified. This object can be used to communicate with the client that
156 was trying to connect.
157 This differs slightly from the "accept" function in perlfunc.
159 In a scalar context the new socket is returned, or "undef" upon
161 failure. In a list context a two-element array is returned containing
162 the new socket and the peer address; the list will be empty upon
163 failure.
164 atmark
166 my $integer = $sock->atmark();
167 # read in some data on a given socket
168 my $data;
169 $sock->read($data, 1024) until $sock->atmark;
170 # or, export the function to use:
172 use IO::Socket 'sockatmark';
173 $sock->read($data, 1024) until sockatmark($sock);
174 True if the socket is currently positioned at the urgent data mark,
176 false otherwise. If your system doesn't yet implement "sockatmark" this
177 will throw an exception.
178 If your system does not support "sockatmark", the "use" declaration
180 will fail at compile time.
181 autoflush
183 # by default, autoflush will be turned on when referenced
184 $sock->autoflush(); # turns on autoflush
185 # turn off autoflush
186 $sock->autoflush(0);
187 # turn on autoflush
188 $sock->autoflush(1);
189 This attribute isn't overridden from IO::Handle's implementation.
191 However, since we turn it on by default, it's worth mentioning here.
192 bind
194 use Socket qw(pack_sockaddr_in);
195 my $port = 3000;
196 my $ip_address = '0.0.0.0';
197 my $packed_addr = pack_sockaddr_in($port, $ip_address);
198 $sock->bind($packed_addr);
199 Binds a network address to a socket, just as bind(2) does. Returns true
201 if it succeeded, false otherwise. You should provide a packed address
202 of the appropriate type for the socket.
203 connected
205 my $peer_addr = $sock->connected();
206 if ($peer_addr) {
207 say "We're connected to $peer_addr";
208 }
209 If the socket is in a connected state, the peer address is returned. If
211 the socket is not in a connected state, "undef" is returned.
212 Note that this method considers a half-open TCP socket to be "in a
214 connected state". Specifically, it does not distinguish between the
215 ESTABLISHED and CLOSE-WAIT TCP states; it returns the peer address,
216 rather than "undef", in either case. Thus, in general, it cannot be
217 used to reliably learn whether the peer has initiated a graceful
218 shutdown because in most cases (see below) the local TCP state machine
219 remains in CLOSE-WAIT until the local application calls "shutdown" in
220 IO::Socket or "close". Only at that point does this function return
221 "undef".
222 The "in most cases" hedge is because local TCP state machine behavior
224 may depend on the peer's socket options. In particular, if the peer
225 socket has "SO_LINGER" enabled with a zero timeout, then the peer's
226 "close" will generate a "RST" segment. Upon receipt of that segment,
227 the local TCP transitions immediately to CLOSED, and in that state,
228 this method will return "undef".
229 getsockopt
231 my $value = $sock->getsockopt(SOL_SOCKET, SO_REUSEADDR);
232 my $buf = $socket->getsockopt(SOL_SOCKET, SO_RCVBUF);
233 say "Receive buffer is $buf bytes";
234 Get an option associated with the socket. Levels other than
236 "SOL_SOCKET" may be specified here. As a convenience, this method will
237 unpack a byte buffer of the correct size back into a number.
238 listen
240 $sock->listen(5);
241 Does the same thing that the listen(2) system call does. Returns true
243 if it succeeded, false otherwise. Listens to a socket with a given
244 queue size.
245 peername
247 my $sockaddr_in = $sock->peername();
248 Returns the packed "sockaddr" address of the other end of the socket
250 connection. It calls "getpeername".
251 protocol
253 my $proto = $sock->protocol();
254 Returns the number for the protocol being used on the socket, if known.
256 If the protocol is unknown, as with an "AF_UNIX" socket, zero is
257 returned.
258 recv
260 my $buffer = "";
261 my $length = 1024;
262 my $flags = 0; # default. optional
263 $sock->recv($buffer, $length);
264 $sock->recv($buffer, $length, $flags);
265 Similar in functionality to "recv" in perlfunc.
267 Receives a message on a socket. Attempts to receive $length characters
269 of data into $buffer from the specified socket. $buffer will be grown
270 or shrunk to the length actually read. Takes the same flags as the
271 system call of the same name. Returns the address of the sender if
272 socket's protocol supports this; returns an empty string otherwise. If
273 there's an error, returns "undef". This call is actually implemented in
274 terms of the recvfrom(2) system call.
275 Flags are ORed together values, such as "MSG_BCAST", "MSG_OOB",
277 "MSG_TRUNC". The default value for the flags is 0.
278 The cached value of "peername" in IO::Socket is updated with the result
280 of "recv".
281 Note: In Perl v5.30 and newer, if the socket has been marked as
283 ":utf8", "recv" will throw an exception. The ":encoding(...)" layer
284 implicitly introduces the ":utf8" layer. See "binmode" in perlfunc.
285 Note: In Perl versions older than v5.30, depending on the status of the
287 socket, either (8-bit) bytes or characters are received. By default all
288 sockets operate on bytes, but for example if the socket has been
289 changed using "binmode" in perlfunc to operate with the
290 ":encoding(UTF-8)" I/O layer (see the "open" in perlfunc pragma), the
291 I/O will operate on UTF8-encoded Unicode characters, not bytes.
292 Similarly for the ":encoding" layer: in that case pretty much any
293 characters can be read.
294 send
296 my $message = "Hello, world!";
297 my $flags = 0; # defaults to zero
298 my $to = '0.0.0.0'; # optional destination
299 my $sent = $sock->send($message);
300 $sent = $sock->send($message, $flags);
301 $sent = $sock->send($message, $flags, $to);
302 Similar in functionality to "send" in perlfunc.
304 Sends a message on a socket. Attempts to send the scalar message to the
306 socket. Takes the same flags as the system call of the same name. On
307 unconnected sockets, you must specify a destination to send to, in
308 which case it does a sendto(2) syscall. Returns the number of
309 characters sent, or "undef" on error. The sendmsg(2) syscall is
310 currently unimplemented.
311 The "flags" option is optional and defaults to 0.
313 After a successful send with $to, further calls to "send" on an
315 unconnected socket without $to will send to the same address, and $to
316 will be used as the result of "peername" in IO::Socket.
317 Note: In Perl v5.30 and newer, if the socket has been marked as
319 ":utf8", "send" will throw an exception. The ":encoding(...)" layer
320 implicitly introduces the ":utf8" layer. See "binmode" in perlfunc.
321 Note: In Perl versions older than v5.30, depending on the status of the
323 socket, either (8-bit) bytes or characters are sent. By default all
324 sockets operate on bytes, but for example if the socket has been
325 changed using "binmode" in perlfunc to operate with the
326 ":encoding(UTF-8)" I/O layer (see the "open" in perlfunc pragma), the
327 I/O will operate on UTF8-encoded Unicode characters, not bytes.
328 Similarly for the ":encoding" layer: in that case pretty much any
329 characters can be sent.
330 setsockopt
332 $sock->setsockopt(SOL_SOCKET, SO_REUSEADDR, 1);
333 $sock->setsockopt(SOL_SOCKET, SO_RCVBUF, 64*1024);
334 Set option associated with the socket. Levels other than "SOL_SOCKET"
336 may be specified here. As a convenience, this method will convert a
337 number into a packed byte buffer.
338 shutdown
340 $sock->shutdown(SHUT_RD); # we stopped reading data
341 $sock->shutdown(SHUT_WR); # we stopped writing data
342 $sock->shutdown(SHUT_RDWR); # we stopped using this socket
343 Shuts down a socket connection in the manner indicated by the value
345 passed in, which has the same interpretation as in the syscall of the
346 same name.
347 This is useful with sockets when you want to tell the other side you're
349 done writing but not done reading, or vice versa. It's also a more
350 insistent form of "close" because it also disables the file descriptor
351 in any forked copies in other processes.
352 Returns 1 for success; on error, returns "undef" if the socket is not a
354 valid filehandle, or returns 0 and sets $! for any other failure.
355 sockdomain
357 my $domain = $sock->sockdomain();
358 Returns the number for the socket domain type. For example, for an
360 "AF_INET" socket the value of &AF_INET will be returned.
361 socket
363 my $sock = IO::Socket->new(); # no values given
364 # now let's actually get a socket with the socket method
365 # domain, type, and protocol are required
366 $sock = $sock->socket(AF_INET, SOCK_STREAM, 'tcp');
367 Opens a socket of the specified kind and returns it. Domain, type, and
369 protocol are specified the same as for the syscall of the same name.
370 socketpair
372 my ($r, $w) = $sock->socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC);
373 ($r, $w) = IO::Socket::UNIX
374 ->socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC);
375 Will return a list of two sockets created (read and write), or an empty
377 list on failure.
378 Differs slightly from "socketpair" in perlfunc in that the argument
380 list is a bit simpler.
381 sockname
383 my $packed_addr = $sock->sockname();
384 Returns the packed "sockaddr" address of this end of the connection.
386 It's the same as getsockname(2).
387 sockopt
389 my $value = $sock->sockopt(SO_REUSEADDR);
390 $sock->sockopt(SO_REUSEADDR, 1);
391 Unified method to both set and get options in the "SOL_SOCKET" level.
393 If called with one argument then "getsockopt" in IO::Socket is called,
394 otherwise "setsockopt" in IO::Socket is called.
395 socktype
397 my $type = $sock->socktype();
398 Returns the number for the socket type. For example, for a
400 "SOCK_STREAM" socket the value of &SOCK_STREAM will be returned.
401 timeout
403 my $seconds = $sock->timeout();
404 my $old_val = $sock->timeout(5); # set new and return old value
405 Set or get the timeout value (in seconds) associated with this socket.
407 If called without any arguments then the current setting is returned.
408 If called with an argument the current setting is changed and the
409 previous value returned.
410 This method is available to all "IO::Socket" implementations but may or
412 may not be used by the individual domain subclasses.
413
415 Let's create a TCP server on "localhost:3333".
416 use strict;
418 use warnings;
419 use feature 'say';
420 use IO::Socket qw(AF_INET AF_UNIX SOCK_STREAM SHUT_WR);
422 my $server = IO::Socket->new(
424 Domain => AF_INET,
425 Type => SOCK_STREAM,
426 Proto => 'tcp',
427 LocalHost => '0.0.0.0',
428 LocalPort => 3333,
429 ReusePort => 1,
430 Listen => 5,
431 ) || die "Can't open socket: $IO::Socket::errstr";
432 say "Waiting on 3333";
433 while (1) {
435 # waiting for a new client connection
436 my $client = $server->accept();
437 # get information about a newly connected client
439 my $client_address = $client->peerhost();
440 my $client_port = $client->peerport();
441 say "Connection from $client_address:$client_port";
442 # read up to 1024 characters from the connected client
444 my $data = "";
445 $client->recv($data, 1024);
446 say "received data: $data";
447 # write response data to the connected client
449 $data = "ok";
450 $client->send($data);
451 # notify client that response has been sent
453 $client->shutdown(SHUT_WR);
454 }
455 $server->close();
457 A client for such a server could be
459 use strict;
461 use warnings;
462 use feature 'say';
463 use IO::Socket qw(AF_INET AF_UNIX SOCK_STREAM SHUT_WR);
465 my $client = IO::Socket->new(
467 Domain => AF_INET,
468 Type => SOCK_STREAM,
469 proto => 'tcp',
470 PeerPort => 3333,
471 PeerHost => '0.0.0.0',
472 ) || die "Can't open socket: $IO::Socket::errstr";
473 say "Sending Hello World!";
475 my $size = $client->send("Hello World!");
476 say "Sent data of length: $size";
477 $client->shutdown(SHUT_WR);
479 my $buffer;
481 $client->recv($buffer, 1024);
482 say "Got back $buffer";
483 $client->close();
485
487 On some systems, for an IO::Socket object created with "new_from_fd",
488 or created with "accept" in IO::Socket from such an object, the
489 "protocol" in IO::Socket, "sockdomain" in IO::Socket and "socktype" in
490 IO::Socket methods may return "undef".
491
493 Socket, IO::Handle, IO::Socket::INET, IO::Socket::UNIX, IO::Socket::IP
494
496 Graham Barr. atmark() by Lincoln Stein. Currently maintained by the
497 Perl 5 Porters. Please report all bugs at
498 <https://github.com/Perl/perl5/issues>.
499
501 Copyright (c) 1997-8 Graham Barr <gbarr@pobox.com>. All rights
502 reserved. This program is free software; you can redistribute it
503 and/or modify it under the same terms as Perl itself.
504 The atmark() implementation: Copyright 2001, Lincoln Stein
506 <lstein@cshl.org>. This module is distributed under the same terms as
507 Perl itself. Feel free to use, modify and redistribute it as long as
508 you retain the correct attribution.
509perl v5.36.3 2023-11-30 IO::Socket(3pm)