man7/unix.7

   1 .\" This man page is Copyright (C) 1999 Andi Kleen <ak@muc.de>,
   2 .\" Copyright (C) 2008-2014, Michael Kerrisk <mtk.manpages@gmail.com>,
   3 .\" and Copyright (C) 2016, Heinrich Schuchardt <xypron.glpk@gmx.de>
   4 .\"
   5 .\" %%%LICENSE_START(VERBATIM_ONE_PARA)
   6 .\" Permission is granted to distribute possibly modified copies
   7 .\" of this page provided the header is included verbatim,
   8 .\" and in case of nontrivial modification author and date
   9 .\" of the modification is added to the header.
  10 .\" %%%LICENSE_END
  11 .\"
  12 .\" Modified, 2003-12-02, Michael Kerrisk, <mtk.manpages@gmail.com>
  13 .\" Modified, 2003-09-23, Adam Langley
  14 .\" Modified, 2004-05-27, Michael Kerrisk, <mtk.manpages@gmail.com>
  15 .\"     Added SOCK_SEQPACKET
  16 .\" 2008-05-27, mtk, Provide a clear description of the three types of
  17 .\"     address that can appear in the sockaddr_un structure: pathname,
  18 .\"     unnamed, and abstract.
  19 .\"
  20 .TH UNIX  7 2016-07-17 "Linux" "Linux Programmer's Manual"
  21 .SH NAME
  22 unix \- sockets for local interprocess communication
  23 .SH SYNOPSIS
  24 .B #include <sys/socket.h>
  25 .br
  26 .B #include <sys/un.h>
  27
  28 .IB unix_socket " = socket(AF_UNIX, type, 0);"
  29 .br
  30 .IB error " = socketpair(AF_UNIX, type, 0, int *" sv ");"
  31 .SH DESCRIPTION
  32 The
  33 .B AF_UNIX
  34 (also known as
  35 .BR AF_LOCAL )
  36 socket family is used to communicate between processes on the same machine
  37 efficiently.
  38 Traditionally, UNIX domain sockets can be either unnamed,
  39 or bound to a filesystem pathname (marked as being of type socket).
  40 Linux also supports an abstract namespace which is independent of the
  41 filesystem.
  42
  43 Valid socket types in the UNIX domain are:
  44 .BR SOCK_STREAM ,
  45 for a stream-oriented socket;
  46 .BR SOCK_DGRAM ,
  47 for a datagram-oriented socket that preserves message boundaries
  48 (as on most UNIX implementations, UNIX domain datagram
  49 sockets are always reliable and don't reorder datagrams);
  50 and (since Linux 2.6.4)
  51 .BR SOCK_SEQPACKET ,
  52 for a sequenced-packet socket that is connection-oriented,
  53 preserves message boundaries,
  54 and delivers messages in the order that they were sent.
  55
  56 UNIX domain sockets support passing file descriptors or process credentials
  57 to other processes using ancillary data.
  58 .SS Address format
  59 A UNIX domain socket address is represented in the following structure:
  60 .in +4n
  61 .nf
  62
  63 .\" #define UNIX_PATH_MAX    108
  64 .\"
  65 struct sockaddr_un {
  66     sa_family_t sun_family;               /* AF_UNIX */
  67     char        sun_path[108];            /* pathname */
  68 };
  69 .fi
  70 .in
  71 .PP
  72 The
  73 .I sun_family
  74 field always contains
  75 .BR AF_UNIX .
  76 On Linux
  77 .I sun_path
  78 is 108 bytes in size; see also NOTES, below.
  79
  80 Various systems calls (for example,
  81 .BR bind (2),
  82 .BR connect (2),
  83 and
  84 .BR sendto (2))
  85 take a
  86 .I sockaddr_un
  87 argument as input.
  88 Some other system calls (for example,
  89 .BR getsockname (2),
  90 .BR getpeername (2),
  91 .BR recvfrom (2),
  92 and
  93 .BR accept (2))
  94 return an argument of this type.
  95
  96 Three types of address are distinguished in the
  97 .I sockaddr_un
  98 structure:
  99 .IP * 3
 100 .IR pathname :
 101 a UNIX domain socket can be bound to a null-terminated
 102 filesystem pathname using
 103 .BR bind (2).
 104 When the address of a pathname socket is returned
 105 (by one of the system calls noted above),
 106 its length is
 107
 108     offsetof(struct sockaddr_un, sun_path) + strlen(sun_path) + 1
 109
 110 and
 111 .I sun_path
 112 contains the null-terminated pathname.
 113 (On Linux, the above
 114 .BR offsetof ()
 115 expression equates to the same value as
 116 .IR sizeof(sa_family_t) ,
 117 but some other implementations include other fields before
 118 .IR sun_path ,
 119 so the
 120 .BR offsetof ()
 121 expression more portably describes the size of the address structure.)
 122 .IP
 123 For further details of pathname sockets, see below.
 124 .IP *
 125 .IR unnamed :
 126 A stream socket that has not been bound to a pathname using
 127 .BR bind (2)
 128 has no name.
 129 Likewise, the two sockets created by
 130 .BR socketpair (2)
 131 are unnamed.
 132 When the address of an unnamed socket is returned,
 133 its length is
 134 .IR "sizeof(sa_family_t)" ,
 135 and
 136 .I sun_path
 137 should not be inspected.
 138 .\" There is quite some variation across implementations: FreeBSD
 139 .\" says the length is 16 bytes, HP-UX 11 says it's zero bytes.
 140 .IP *
 141 .IR abstract :
 142 an abstract socket address is distinguished (from a pathname socket)
 143 by the fact that
 144 .IR sun_path[0]
 145 is a null byte (\(aq\\0\(aq).
 146 The socket's address in this namespace is given by the additional
 147 bytes in
 148 .IR sun_path
 149 that are covered by the specified length of the address structure.
 150 (Null bytes in the name have no special significance.)
 151 The name has no connection with filesystem pathnames.
 152 When the address of an abstract socket is returned,
 153 the returned
 154 .I addrlen
 155 is greater than
 156 .IR "sizeof(sa_family_t)"
 157 (i.e., greater than 2), and the name of the socket is contained in
 158 the first
 159 .IR "(addrlen \- sizeof(sa_family_t))"
 160 bytes of
 161 .IR sun_path .
 162 .SS Pathname sockets
 163 When binding a socket to a pathname, a few rules should be observed
 164 for maximum portability and ease of coding:
 165 .IP * 3
 166 The pathname in
 167 .I sun_path
 168 should be null-terminated.
 169 .IP *
 170 The length of the pathname, including the terminating null byte,
 171 should not exceed the size of
 172 .IR sun_path .
 173 .IP *
 174 The
 175 .I addrlen
 176 argument that describes the enclosing
 177 .I sockaddr_un
 178 structure should have a value of at least:
 179
 180 .nf
 181     offsetof(struct sockaddr_un, sun_path)+strlen(addr.sun_path)+1
 182 .fi
 183 .IP
 184 or, more simply,
 185 .I addrlen
 186 can be specified as
 187 .IR "sizeof(struct sockaddr_un)" .
 188 .PP
 189 There is some variation in how implementations handle UNIX domain
 190 socket addresses that do not follow the above rules.
 191 For example, some (but not all) implementations
 192 .\" Linux does this, including for the case where the supplied path
 193 .\" is 108 bytes
 194 append a null terminator if none is present in the supplied
 195 .IR sun_path .
 196
 197 When coding portable applications,
 198 keep in mind that some implementations
 199 .\" HP-UX
 200 have
 201 .I sun_path
 202 as short as 92 bytes.
 203 .\" Modern BSDs generally have 104, Tru64 and AIX have 104,
 204 .\" Solaris and Irix have 108
 205
 206 Various system calls
 207 .RB ( accept (2),
 208 .BR recvfrom (2),
 209 .BR getsockname (2),
 210 .BR getpeername (2))
 211 return socket address structures.
 212 When applied to UNIX domain sockets, the value-result
 213 .I addrlen
 214 argument supplied to the call should be initialized as above.
 215 Upon return, the argument is set to indicate the
 216 .I actual
 217 size of the address structure.
 218 The caller should check the value returned in this argument:
 219 if the output value exceeds the input value,
 220 then there is no guarantee that a null terminator is present in
 221 .IR sun_path .
 222 (See BUGS.)
 223 .\"
 224 .SS Pathname socket ownership and permissions
 225 In the Linux implementation,
 226 pathname sockets honor the permissions of the directory they are in.
 227 Creation of a new socket will fail if the process does not have write and
 228 search (execute) permission on the directory in which the socket is created.
 229
 230 On Linux,
 231 connecting to a stream socket object requires write permission on that socket;
 232 sending a datagram to a datagram socket likewise
 233 requires write permission on that socket.
 234 POSIX does not make any statement about the effect of the permissions
 235 on a socket file, and on some systems (e.g., older BSDs),
 236 the socket permissions are ignored.
 237 Portable programs should not rely on
 238 this feature for security.
 239
 240 When creating a new socket, the owner and group of the socket file
 241 are set according to the usual rules.
 242 The socket file has all permissions enabled,
 243 other than those that are turned off by the process
 244 .BR umask (2).
 245
 246 The owner, group, and permissions of a pathname socket can be changed (using
 247 .BR chown (2)
 248 and
 249 .BR chmod (2)).
 250 .\" However, fchown() and fchmod() do not seem to have an effect
 251 .\"
 252 .SS Abstract sockets
 253 Socket permissions have no meaning for abstract sockets:
 254 the process
 255 .BR umask (2)
 256 has no effect when binding an abstract socket,
 257 and changing the ownership and permissions of the object (via
 258 .BR fchown (2)
 259 and
 260 .BR fchmod (2))
 261 has no effect on the accessibility of the socket.
 262
 263 Abstract sockets automatically disappear when all open references
 264 to the socket are closed.
 265
 266 The abstract socket namespace is a nonportable Linux extension.
 267 .\"
 268 .SS Socket options
 269 For historical reasons, these socket options are specified with a
 270 .B SOL_SOCKET
 271 type even though they are
 272 .B AF_UNIX
 273 specific.
 274 They can be set with
 275 .BR setsockopt (2)
 276 and read with
 277 .BR getsockopt (2)
 278 by specifying
 279 .B SOL_SOCKET
 280 as the socket family.
 281 .TP
 282 .B SO_PASSCRED
 283 Enables the receiving of the credentials of the sending process in an
 284 ancillary message.
 285 When this option is set and the socket is not yet connected
 286 a unique name in the abstract namespace will be generated automatically.
 287 Expects an integer boolean flag.
 288 .SS Autobind feature
 289 If a
 290 .BR bind (2)
 291 call specifies
 292 .I addrlen
 293 as
 294 .IR sizeof(sa_family_t) ,
 295 .\" i.e., sizeof(short)
 296 or the
 297 .BR SO_PASSCRED
 298 socket option was specified for a socket that was
 299 not explicitly bound to an address,
 300 then the socket is autobound to an abstract address.
 301 The address consists of a null byte
 302 followed by 5 bytes in the character set
 303 .IR [0-9a-f] .
 304 Thus, there is a limit of 2^20 autobind addresses.
 305 (From Linux 2.1.15, when the autobind feature was added,
 306 8 bytes were used, and the limit was thus 2^32 autobind addresses.
 307 The change to 5 bytes came in Linux 2.3.15.)
 308 .SS Sockets API
 309 The following paragraphs describe domain-specific details and
 310 unsupported features of the sockets API for UNIX domain sockets on Linux.
 311
 312 UNIX domain sockets do not support the transmission of
 313 out-of-band data (the
 314 .B MSG_OOB
 315 flag for
 316 .BR send (2)
 317 and
 318 .BR recv (2)).
 319
 320 The
 321 .BR send (2)
 322 .B MSG_MORE
 323 flag is not supported by UNIX domain sockets.
 324
 325 The use of
 326 .B MSG_TRUNC
 327 in the
 328 .I flags
 329 argument of
 330 .BR recv (2)
 331 is not supported by UNIX domain sockets.
 332
 333 The
 334 .B SO_SNDBUF
 335 socket option does have an effect for UNIX domain sockets, but the
 336 .B SO_RCVBUF
 337 option does not.
 338 For datagram sockets, the
 339 .B SO_SNDBUF
 340 value imposes an upper limit on the size of outgoing datagrams.
 341 This limit is calculated as the doubled (see
 342 .BR socket (7))
 343 option value less 32 bytes used for overhead.
 344 .SS Ancillary messages
 345 Ancillary data is sent and received using
 346 .BR sendmsg (2)
 347 and
 348 .BR recvmsg (2).
 349 For historical reasons the ancillary message types listed below
 350 are specified with a
 351 .B SOL_SOCKET
 352 type even though they are
 353 .B AF_UNIX
 354 specific.
 355 To send them set the
 356 .I cmsg_level
 357 field of the struct
 358 .I cmsghdr
 359 to
 360 .B SOL_SOCKET
 361 and the
 362 .I cmsg_type
 363 field to the type.
 364 For more information see
 365 .BR cmsg (3).
 366 .TP
 367 .B SCM_RIGHTS
 368 Send or receive a set of open file descriptors from another process.
 369 The data portion contains an integer array of the file descriptors.
 370 The passed file descriptors behave as though they have been created with
 371 .BR dup (2).
 372 .TP
 373 .B SCM_CREDENTIALS
 374 Send or receive UNIX credentials.
 375 This can be used for authentication.
 376 The credentials are passed as a
 377 .I struct ucred
 378 ancillary message.
 379 Thus structure is defined in
 380 .I <sys/socket.h>
 381 as follows:
 382
 383 .in +4n
 384 .nf
 385 struct ucred {
 386     pid_t pid;    /* process ID of the sending process */
 387     uid_t uid;    /* user ID of the sending process */
 388     gid_t gid;    /* group ID of the sending process */
 389 };
 390 .fi
 391 .in
 392
 393 Since glibc 2.8, the
 394 .B _GNU_SOURCE
 395 feature test macro must be defined (before including
 396 .I any
 397 header files) in order to obtain the definition
 398 of this structure.
 399
 400 The credentials which the sender specifies are checked by the kernel.
 401 A process with effective user ID 0 is allowed to specify values that do
 402 not match its own.
 403 The sender must specify its own process ID (unless it has the capability
 404 .BR CAP_SYS_ADMIN ),
 405 its user ID, effective user ID, or saved set-user-ID (unless it has
 406 .BR CAP_SETUID ),
 407 and its group ID, effective group ID, or saved set-group-ID
 408 (unless it has
 409 .BR CAP_SETGID ).
 410 To receive a
 411 .I struct ucred
 412 message the
 413 .B SO_PASSCRED
 414 option must be enabled on the socket.
 415 .SS Ioctls
 416 The following
 417 .BR ioctl (2)
 418 calls return information in
 419 .IR value .
 420 The correct syntax is:
 421 .PP
 422 .RS
 423 .nf
 424 .BI int " value";
 425 .IB error " = ioctl(" unix_socket ", " ioctl_type ", &" value ");"
 426 .fi
 427 .RE
 428 .PP
 429 .I ioctl_type
 430 can be:
 431 .TP
 432 .B SIOCINQ
 433 For
 434 .B SOCK_STREAM
 435 socket the function returns the amount of queued unread data in the receive buffer.
 436 The socket must not be in LISTEN state, otherwise an error
 437 .RB ( EINVAL )
 438 is returned.
 439 .B SIOCINQ
 440 is defined in
 441 .IR <linux/sockios.h> .
 442 .\" FIXME . http://sources.redhat.com/bugzilla/show_bug.cgi?id=12002,
 443 .\" filed 2010-09-10, may cause SIOCINQ to be defined in glibc headers
 444 Alternatively,
 445 you can use the synonymous
 446 .BR FIONREAD ,
 447 defined in
 448 .IR <sys/ioctl.h> .
 449 .\" SIOCOUTQ also has an effect for UNIX domain sockets, but not
 450 .\" quite what userland might expect. It seems to return the number
 451 .\" of bytes allocated for buffers containing pending output.
 452 .\" That number is normally larger than the number of bytes of pending
 453 .\" output. Since this info is, from userland's point of view, imprecise,
 454 .\" and it may well change, probably best not to document this now.
 455 For
 456 .B SOCK_DGRAM
 457 socket,
 458 the returned value is the same as
 459 for Internet domain datagram socket;
 460 see
 461 .BR udp (7).
 462 .SH ERRORS
 463 .TP
 464 .B EADDRINUSE
 465 The specified local address is already in use or the filesystem socket
 466 object already exists.
 467 .TP
 468 .B ECONNREFUSED
 469 The remote address specified by
 470 .BR connect (2)
 471 was not a listening socket.
 472 This error can also occur if the target pathname is not a socket.
 473 .TP
 474 .B ECONNRESET
 475 Remote socket was unexpectedly closed.
 476 .TP
 477 .B EFAULT
 478 User memory address was not valid.
 479 .TP
 480 .B EINVAL
 481 Invalid argument passed.
 482 A common cause is that the value
 483 .B AF_UNIX
 484 was not specified in the
 485 .I sun_type
 486 field of passed addresses, or the socket was in an
 487 invalid state for the applied operation.
 488 .TP
 489 .B EISCONN
 490 .BR connect (2)
 491 called on an already connected socket or a target address was
 492 specified on a connected socket.
 493 .TP
 494 .B ENOENT
 495 The pathname in the remote address specified to
 496 .BR connect (2)
 497 did not exist.
 498 .TP
 499 .B ENOMEM
 500 Out of memory.
 501 .TP
 502 .B ENOTCONN
 503 Socket operation needs a target address, but the socket is not connected.
 504 .TP
 505 .B EOPNOTSUPP
 506 Stream operation called on non-stream oriented socket or tried to
 507 use the out-of-band data option.
 508 .TP
 509 .B EPERM
 510 The sender passed invalid credentials in the
 511 .IR "struct ucred" .
 512 .TP
 513 .B EPIPE
 514 Remote socket was closed on a stream socket.
 515 If enabled, a
 516 .B SIGPIPE
 517 is sent as well.
 518 This can be avoided by passing the
 519 .B MSG_NOSIGNAL
 520 flag to
 521 .BR send (2)
 522 or
 523 .BR sendmsg (2).
 524 .TP
 525 .B EPROTONOSUPPORT
 526 Passed protocol is not
 527 .BR AF_UNIX .
 528 .TP
 529 .B EPROTOTYPE
 530 Remote socket does not match the local socket type
 531 .RB ( SOCK_DGRAM
 532 versus
 533 .BR SOCK_STREAM )
 534 .TP
 535 .B ESOCKTNOSUPPORT
 536 Unknown socket type.
 537 .PP
 538 Other errors can be generated by the generic socket layer or
 539 by the filesystem while generating a filesystem socket object.
 540 See the appropriate manual pages for more information.
 541 .SH VERSIONS
 542 .B SCM_CREDENTIALS
 543 and the abstract namespace were introduced with Linux 2.2 and should not
 544 be used in portable programs.
 545 (Some BSD-derived systems also support credential passing,
 546 but the implementation details differ.)
 547 .SH NOTES
 548 Binding to a socket with a filename creates a socket
 549 in the filesystem that must be deleted by the caller when it is no
 550 longer needed (using
 551 .BR unlink (2)).
 552 The usual UNIX close-behind semantics apply; the socket can be unlinked
 553 at any time and will be finally removed from the filesystem when the last
 554 reference to it is closed.
 555
 556 To pass file descriptors or credentials over a
 557 .BR SOCK_STREAM ,
 558 you need
 559 to send or receive at least one byte of nonancillary data in the same
 560 .BR sendmsg (2)
 561 or
 562 .BR recvmsg (2)
 563 call.
 564
 565 UNIX domain stream sockets do not support the notion of out-of-band data.
 566 .\"
 567 .SH BUGS
 568 When binding a socket to an address,
 569 Linux is one of the implementations that appends a null terminator
 570 if none is supplied in
 571 .IR sun_path .
 572 In most cases this is unproblematic:
 573 when the socket address is retrieved,
 574 it will be one byte longer than that supplied when the socket was bound.
 575 However, there is one case where confusing behavior can result:
 576 if 108 non-null bytes are supplied when a socket is bound,
 577 then the addition of the null terminator takes the length of
 578 the pathname beyond
 579 .IR sizeof(sun_path) .
 580 Consequently, when retrieving the socket address
 581 (for example, via
 582 .BR accept (2)),
 583 .\" The behavior on Solaris is quite similar.
 584 if the input
 585 .I addrlen
 586 argument for the retrieving call is specified as
 587 .IR "sizeof(struct sockaddr_un)" ,
 588 then the returned address structure
 589 .I won't
 590 have a null terminator in
 591 .IR sun_path .
 592
 593 In addition, some implementations
 594 .\" i.e., traditional BSD
 595 don't require a null terminator when binding a socket (the
 596 .I addrlen
 597 argument is used to determine the length of
 598 .IR sun_path )
 599 and when the socket address is retrieved on these implementations,
 600 there is no null terminator in
 601 .IR sun_path .
 602
 603 Applications that retrieve socket addresses can (portably) code
 604 to handle the possibility that there is no null terminator in
 605 .IR sun_path
 606 by respecting the fact that the number of valid bytes in the pathname is:
 607
 608     strnlen(addr.sun_path, addrlen \- offsetof(sockaddr_un, sun_path))
 609 .\" The following patch to amend kernel behavior was rejected:
 610 .\" http://thread.gmane.org/gmane.linux.kernel.api/2437
 611 .\" Subject: [patch] Fix handling of overlength pathname in AF_UNIX sun_path
 612 .\" 2012-04-17
 613 .\" And there was a related discussion in the Austin list:
 614 .\" http://thread.gmane.org/gmane.comp.standards.posix.austin.general/5735
 615 .\" Subject: Having a sun_path with no null terminator
 616 .\" 2012-04-18
 617 .\"
 618 .\" FIXME . Track http://austingroupbugs.net/view.php?id=561
 619
 620 Alternatively, an application can retrieve
 621 the socket address by allocating a buffer of size
 622 .I "sizeof(struct sockaddr_un)+1"
 623 that is zeroed out before the retrieval.
 624 The retrieving call can specify
 625 .I addrlen
 626 as
 627 .IR "sizeof(struct sockaddr_un)" ,
 628 and the extra zero byte ensures that there will be
 629 a null terminator for the string returned in
 630 .IR sun_path :
 631
 632 .nf
 633 .in +3
 634 void *addrp;
 635
 636 addrlen = sizeof(struct sockaddr_un);
 637 addrp = malloc(addrlen + 1);
 638 if (addrp == NULL)
 639     /* Handle error */ ;
 640 memset(addrp, 0, addrlen + 1);
 641
 642 if (getsockname(sfd, (struct sockaddr *) addrp, &addrlen)) == \-1)
 643     /* handle error */ ;
 644
 645 printf("sun_path = %s\\n", ((struct sockaddr_un *) addrp)\->sun_path);
 646 .in
 647 .fi
 648
 649 This sort of messiness can be avoided if it is guaranteed
 650 that the applications that
 651 .I create
 652 pathname sockets follow the rules outlined above under
 653 .IR "Pathname sockets" .
 654 .SH EXAMPLE
 655 The following code demonstrates the use of sequenced-packet
 656 sockets for local interprocess communication.
 657 It consists of two programs.
 658 The server program waits for a connection from the client program.
 659 The client sends each of its command-line arguments in separate messages.
 660 The server treats the incoming messages as integers and adds them up.
 661 The client sends the command string "END".
 662 The server sends back a message containing the sum of the client's integers.
 663 The client prints the sum and exits.
 664 The server waits for the next client to connect.
 665 To stop the server, the client is called with the command-line argument "DOWN".
 666 .PP
 667 The following output was recorded while running the server in the background
 668 and repeatedly executing the client.
 669 Execution of the server program ends when it receives the "DOWN" command.
 670 .SS Example output
 671 .in +4n
 672 .nf
 673 $ \fB./server &\fP
 674 [1] 25887
 675 $ \fB./client 3 4\fP
 676 Result = 7
 677 $ \fB./client 11 \-5\fP
 678 Result = 6
 679 $ \fB./client DOWN\fP
 680 Result = 0
 681 [1]+  Done                    ./server
 682 $
 683 .fi
 684 .in
 685 .SS Program source
 686 .nf
 687 /*
 688  * File connection.h
 689  */
 690
 691 #define SOCKET_NAME "/tmp/9Lq7BNBnBycd6nxy.socket"
 692 #define BUFFER_SIZE 12
 693
 694 /*
 695  * File server.c
 696  */
 697
 698 #include <stdio.h>
 699 #include <stdlib.h>
 700 #include <string.h>
 701 #include <sys/socket.h>
 702 #include <sys/un.h>
 703 #include <unistd.h>
 704 #include "connection.h"
 705
 706 int
 707 main(int argc, char *argv[])
 708 {
 709     struct sockaddr_un name;
 710     int down_flag = 0;
 711     int ret;
 712     int connection_socket;
 713     int data_socket;
 714     int result;
 715     char buffer[BUFFER_SIZE];
 716
 717     /*
 718      * In case the program exited inadvertently on the last run,
 719      * remove the socket.
 720      */
 721
 722     unlink(SOCKET_NAME);
 723
 724     /* Create local socket. */
 725
 726     connection_socket = socket(AF_UNIX, SOCK_SEQPACKET, 0);
 727     if (connection_socket == \-1) {
 728         perror("socket");
 729         exit(EXIT_FAILURE);
 730     }
 731
 732     /*
 733      * For portability clear the whole structure, since some
 734      * implementations have additional (nonstandard) fields in
 735      * the structure.
 736      */
 737
 738     memset(&name, 0, sizeof(struct sockaddr_un));
 739
 740     /* Bind socket to socket name. */
 741
 742     name.sun_family = AF_UNIX;
 743     strncpy(name.sun_path, SOCKET_NAME, sizeof(name.sun_path) \- 1);
 744
 745     ret = bind(connection_socket, (const struct sockaddr *) &name,
 746                sizeof(struct sockaddr_un));
 747     if (ret == \-1) {
 748         perror("bind");
 749         exit(EXIT_FAILURE);
 750     }
 751
 752     /*
 753      * Prepare for accepting connections. The backlog size is set
 754      * to 20. So while one request is being processed other requests
 755      * can be waiting.
 756      */
 757
 758     ret = listen(connection_socket, 20);
 759     if (ret == \-1) {
 760         perror("listen");
 761         exit(EXIT_FAILURE);
 762     }
 763
 764     /* This is the main loop for handling connections. */
 765
 766     for (;;) {
 767
 768         /* Wait for incoming connection. */
 769
 770         data_socket = accept(connection_socket, NULL, NULL);
 771         if (data_socket == \-1) {
 772             perror("accept");
 773             exit(EXIT_FAILURE);
 774         }
 775
 776         result = 0;
 777         for(;;) {
 778
 779             /* Wait for next data packet. */
 780
 781             ret = read(data_socket, buffer, BUFFER_SIZE);
 782             if (ret == \-1) {
 783                 perror("read");
 784                 exit(EXIT_FAILURE);
 785             }
 786
 787             /* Ensure buffer is 0\-terminated. */
 788
 789             buffer[BUFFER_SIZE \- 1] = 0;
 790
 791             /* Handle commands. */
 792
 793             if (!strncmp(buffer, "DOWN", BUFFER_SIZE)) {
 794                 down_flag = 1;
 795                 break;
 796             }
 797
 798             if (!strncmp(buffer, "END", BUFFER_SIZE)) {
 799                 break;
 800             }
 801
 802             /* Add received summand. */
 803
 804             result += atoi(buffer);
 805         }
 806
 807         /* Send result. */
 808
 809         sprintf(buffer, "%d", result);
 810         ret = write(data_socket, buffer, BUFFER_SIZE);
 811
 812         if (ret == \-1) {
 813             perror("write");
 814             exit(EXIT_FAILURE);
 815         }
 816
 817         /* Close socket. */
 818
 819         close(data_socket);
 820
 821         /* Quit on DOWN command. */
 822
 823         if (down_flag) {
 824             break;
 825         }
 826     }
 827
 828     close(connection_socket);
 829
 830     /* Unlink the socket. */
 831
 832     unlink(SOCKET_NAME);
 833
 834     exit(EXIT_SUCCESS);
 835 }
 836
 837 /*
 838  * File client.c
 839  */
 840
 841 #include <errno.h>
 842 #include <stdio.h>
 843 #include <stdlib.h>
 844 #include <string.h>
 845 #include <sys/socket.h>
 846 #include <sys/un.h>
 847 #include <unistd.h>
 848 #include "connection.h"
 849
 850 int
 851 main(int argc, char *argv[])
 852 {
 853     struct sockaddr_un addr;
 854     int i;
 855     int ret;
 856     int data_socket;
 857     char buffer[BUFFER_SIZE];
 858
 859     /* Create local socket. */
 860
 861     data_socket = socket(AF_UNIX, SOCK_SEQPACKET, 0);
 862     if (data_socket == \-1) {
 863         perror("socket");
 864         exit(EXIT_FAILURE);
 865     }
 866
 867     /*
 868      * For portability clear the whole structure, since some
 869      * implementations have additional (nonstandard) fields in
 870      * the structure.
 871      */
 872
 873     memset(&addr, 0, sizeof(struct sockaddr_un));
 874
 875     /* Connect socket to socket address */
 876
 877     addr.sun_family = AF_UNIX;
 878     strncpy(addr.sun_path, SOCKET_NAME, sizeof(addr.sun_path) \- 1);
 879
 880     ret = connect (data_socket, (const struct sockaddr *) &addr,
 881                    sizeof(struct sockaddr_un));
 882     if (ret == \-1) {
 883         fprintf(stderr, "The server is down.\\n");
 884         exit(EXIT_FAILURE);
 885     }
 886
 887     /* Send arguments. */
 888
 889     for (i = 1; i < argc; ++i) {
 890         ret = write(data_socket, argv[i], strlen(argv[i]) + 1);
 891         if (ret == \-1) {
 892             perror("write");
 893             break;
 894         }
 895     }
 896
 897     /* Request result. */
 898
 899     strcpy (buffer, "END");
 900     ret = write(data_socket, buffer, strlen(buffer) + 1);
 901     if (ret == \-1) {
 902         perror("write");
 903         exit(EXIT_FAILURE);
 904     }
 905
 906     /* Receive result. */
 907
 908     ret = read(data_socket, buffer, BUFFER_SIZE);
 909     if (ret == \-1) {
 910         perror("read");
 911         exit(EXIT_FAILURE);
 912     }
 913
 914     /* Ensure buffer is 0\-terminated. */
 915
 916     buffer[BUFFER_SIZE \- 1] = 0;
 917
 918     printf("Result = %s\\n", buffer);
 919
 920     /* Close socket. */
 921
 922     close(data_socket);
 923
 924     exit(EXIT_SUCCESS);
 925 }
 926 .fi
 927 .PP
 928 For an example of the use of
 929 .BR SCM_RIGHTS
 930 see
 931 .BR cmsg (3).
 932 .SH SEE ALSO
 933 .BR recvmsg (2),
 934 .BR sendmsg (2),
 935 .BR socket (2),
 936 .BR socketpair (2),
 937 .BR cmsg (3),
 938 .BR capabilities (7),
 939 .BR credentials (7),
 940 .BR socket (7),
 941 .BR udp (7)