COHERENT manpages
This page displays the COHERENT manpage for libsocket [Library of communications routines].
List of available manpages
Index
libsocket -- Library
Library of communications routines
libsocket is a library of routines that emulate the Berkeley sockets
library. It includes the following functions:
accept().............. Accept a connection on a socket
bind()................ Bind a name to a socket
bitcount()............ Count bits in a bit-mask
connect()............. Connect to a socket
endhostent().......... Close file /etc/hosts
endnetent()........... Close network file
endprotoent()......... Close protocols file
endservent().......... Close protocols file
ffs()................. Translate a bit mask into an integer value
getdtablesize()....... Get the number of files a process can open
gethostbyaddr()....... Retrieve host information by address
gethostbyname()....... Retrieve host information by name
gethostname()......... Get the name of the local host
getnetbyaddr()........ Get a network entry by address
getnetbyname()........ Get a network entry by address
getnetent()........... Fetch a network entry
getpeername()......... Get name of connected peer
getprotobyname()...... Get protocol entry by protocol name
getprotobynumb()...... Get protocol entry by protocol number
getprotoent()......... Get protocol entry
getservbyname()....... Get a service entry by name
getservbyport()....... Get a service entry by port number
getservent().......... Get a service entry
getsockname()......... Get the name of a socket
getsockopt().......... Read a socket option
gettimeofday()........ Berkeley time function
inet_addr()........... Transform an IP address from text to binary
inet_network()........ Transform an IP address from text to an integer
listen().............. Listen for a connection on a socket
random().............. Return a random number
recv()................ Receive a message from a connected socket
recvfrom()............ Receive a message from a socket
select().............. Check whether sockets are ready for activity
send()................ Send a message to a connected socket
sendto().............. Send a message to a socket
sethostent().......... Open and rewind file /etc/hosts
setnetent()........... Open and rewind file /etc/networks
sethostent().......... Open and rewind file /etc/hosts
setprotoent()......... Open the protocols file
setservent().......... Open the services file
setsockopt().......... Set a socket option
shutdown()............ Replace function to shut down system
SOCKADDRLEN()......... Return length of an address
socket().............. Create a socket
socketpair().......... Create a pair of sockets
srandom()............. Seed the random-number generator
strcasecmp().......... Case-insensitive string comparison
strcasencmp()......... Case-insensitive string comparison
usleep().............. Sleep briefly
Function socket() creates a socket; the caller dictates the type of socket
to be created, and the communications protocol that it comprehends.
socket() returns a descriptor, which resembles a file descriptor and which
can be passed to the system calls read() and write() to exchange
information with whatever plugs itself into that socket. (For details, see
the Notes section at the end of this article.)
Function bind() binds the newly created socket to a file that you name. To
await a connection with another process, invoke the function listen(); this
alerts the system to the fact that you (via your socket) await messages of
a given type. Function select() checks whether one or more sockets are
ready to be written to, or hold data that need to be read. When a message
becomes available, invoke function accept() to accept communication with
the process that wishes to connect to your socket. These functions
generally are used by ``server'' sockets.
Function connect() directly establishes connection with a server socket via
its name (that is, via the file to which it is bound). Once connection is
established, information can be exchanged via the COHERENT system calls
read() and write().
System Files
The socket library manipulates the following files. Each is described in
its own Lexicon entry:
hosts................. Names and addresses of hosts on the local network
hosts.equiv........... Name equivalent hosts
hosts.lpd............. Local system name and domain
inetd.conf............ Configure the Internet daemons
networks.............. Name remote networks
protocols............. Name supported protocols
services.............. List supported TCP/IP services
Example
For following gives a pair of programs that demonstrate sockets. They were
written by John Dhuse (jdhuse@sedona.intel.com).
The example consists of two programs, server.c and client.c. Compile each
with the switch -lsocket. To see how they work, run each in its own virtual
console or xterm window. Do not run them in the background; otherwise, you
will not be able to work with them interactively. Be sure to start up
server first, as it creates the socket into which client plugs itself.
Each process gives you a prompt; you can type commands into each. server
recognizes the following commands:
? Print the command menu
c Call select() to check the socket. client displays the status of the
socket.
s Send a string to server. client prompts for the string, reads up to 20
characters, and writes it to the socket.
r Read from the socket. client prompts for the number of bytes to read,
and clips any response to a maximum of 20.
q Close the socket and terminate the server process.
server recognizes the following commands:
? Print the command menu.
c Call select() to check the socket.
r Read from the socket. server does not prompt for the number of bytes to
read, but tries to read the entire contents of the socket, up to a
maximum of 20 bytes.
e Echo the read message back to the client. The server cannot send its
own message the client, just echo what it received.
q Close the socket, terminate the server, and unlink() the socket file.
The following gives the source for server.c:
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/un.h>
main()
{
int sd, nsd, err,i,j,rdfds[2],wrtfds[2];
int efds[2],done,r;
int arg=1;
struct sockaddr_un server;
char *sock_name = "u0";
char buf[20];
char command,line[80];
struct timeval timeout;
/* clear our address */
bzero((char *)&server, sizeof(server));
/* create socket */
if ((sd = socket(AF_UNIX, SOCK_STREAM, 0)) <= 0) {
err = errno;
fprintf(stderr, "server: can't create socket\n");
fprintf(stderr, "server: errno = %d\n", err);
exit(EXIT_FAILURE);
}
server.sun_family = AF_UNIX;
bcopy(sock_name,server.sun_path,strlen(sock_name));
/* bind the socket */
if ((bind(sd, (struct sockaddr *)&server, sizeof(server))) != 0) {
err = errno;
fprintf(stderr, "server: can't bind socket\n");
fprintf(stderr, "server: errno = %d\n", err);
close(sd);
exit(EXIT_FAILURE);
}
/* listen on the socket */
if ((listen(sd, 1)) != 0) {
err = errno;
fprintf(stderr, "server: can't listen on socket\n");
fprintf(stderr, "server: errno = %d\n", err);
close(sd);
exit(EXIT_FAILURE);
}
/* accept connections on the socket */
if ((nsd = accept(sd, (struct sockaddr*)0, (int *)0)) == -1) {
err = errno;
fprintf(stderr, "server: can't accept connection\n");
fprintf(stderr, "server: errno = %d\n", err);
close(sd);
exit(EXIT_FAILURE);
}
printf("accepted client connection fd %d\n",nsd);
/* set to non-blocking io */
ioctl(nsd,FIOSNBIO,&arg);
/* echo every message back to client, exit on terminate string */
printf("entering command loop\n");
command = 'a';
while (command != 'q') {
printf("server> ");
scanf("%s",line);
sscanf(line,"%c", &command);
switch (command) {
case 'c' :
/* set up for select */
rdfds[0] = 1 << nsd; rdfds[1] = 0;
wrtfds[0] = 1 << nsd; wrtfds[1] = 0;
efds[0] = 1 << nsd; efds[1] = 0;
timeout.tv_sec = 0; timeout.tv_usec = 0;
r = select(nsd+1,rdfds,wrtfds,efds,(struct timeval *)NULL);
err = errno;
if (r < 0)
printf("select() returned errno %d\n",err);
else {
if (rdfds[0] & (1 << nsd))
printf("socket has data to be read\n");
if (wrtfds[0] & (1 << nsd))
printf("data can be written to socket\n");
if (efds[0] & (1 << nsd))
printf("select reports exception on socket\n");
}
break;
case 'r' :
bzero(&buf[0], sizeof(buf));
j = read(nsd,buf,sizeof(buf));
err = errno;
if (j < 0)
printf("read() returned errno %d\n",err);
else
printf("got %d bytes, msg is >%s<\n",j,buf);
break;
case 'e' :
printf("echoing >%s< (%d bytes) to client\n",buf,j);
write(nsd,&buf[0],j);
break;
case 'q' :
close(nsd);
close(sd);
unlink(sock_name);
break;
case '?' :
printf("commands:\n");
printf(" c - check the socket\n");
printf(" ? - this help message\n");
printf(" r - read from socket\n");
printf(" e - echo received message to client\n");
printf(" q - close socket and quit\n");
break;
default :
printf("\n");
break;
}
}
}
The following gives the source for client.c:
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/un.h>
main()
{
int sd, err, i, j, flags;
int arg=1;
struct sockaddr_un client;
char *address="u0";
char buf[20];
char command,line[80];
int rdfds[2],wrtfds[2];
struct timeval timeout;
/* clear our address */
memset((char *)&client,0, sizeof(client));
/* create socket */
if ((sd = socket(AF_UNIX, SOCK_STREAM, 0)) <= 0) {
err = errno;
fprintf(stderr, "client: can't create socket\n");
fprintf(stderr, "client: errno = %d\n", err);
exit(EXIT_FAILURE);
}
/* set to blocking so connect hangs, waiting for connect */
arg = 0;
i = ioctl(sd,FIOSNBIO,&arg);
client.sun_family = AF_UNIX;
memcpy(client.sun_path,address,2);
/* connect to the socket */
if (connect(sd, (struct sockaddr *)&client, sizeof(client))) {
err = errno;
fprintf(stderr, "client: can't connect socket\n");
fprintf(stderr, "client: errno = %d\n", err);
close(sd);
exit(EXIT_FAILURE);
}
printf("connected socket fd = %d\n",sd);
arg = 1;
i = ioctl(sd,FIOSNBIO,&arg);
printf("entering command loop\n");
command = 'a';
while (command != 'q') {
printf("client> ");
scanf("%s",line);
sscanf(line,"%c",&command);
switch (command) {
case 's' :
printf("message to send: ");
scanf("%s",buf);
i = write(sd,buf,strlen(buf));
err = errno;
if (i < 0)
printf("write() returned errno %d\n", err);
else printf("sent >%s< (%d bytes) to server\n",
buf,strlen(buf));
break;
case '?' :
printf("commands:\n");
printf(" s - send a message\n");
printf(" ? - this help messge\n");
printf(" c - check the socket\n");
printf(" r - read from socket\n");
printf(" b - set to blocking I/O\n");
printf(" n - set to non-blocking I/O\n");
printf(" q - close socket and quit\n");
break;
case 'b' :
arg = 0;
ioctl(sd,FIOSNBIO,&arg);
printf("I/O is blocking\n");
break;
case 'n' :
arg = 1;
ioctl(sd,FIOSNBIO,&arg);
printf("I/O is non-blocking\n");
break;
case 'c' :
/* setup query fields */
rdfds[0] = 1 << sd; rdfds[1] = 0;
wrtfds[0] = 1 << sd; wrtfds[1] = 0;
timeout.tv_sec = 0; timeout.tv_usec = 0;
i = select(sd+1,rdfds,wrtfds,(int *)NULL,
&timeout);
err = errno;
if (i < 0)
printf("select() returned error %d\n",err);
else {
if (rdfds[0] & (1 << sd))
printf("socket has data to be read\n");
if (wrtfds[0] & (1 << sd))
printf("data can be written to socket\n");
}
break;
case 'r' :
printf("number of bytes to read > ");
scanf("%d",&i);
if (i > sizeof(buf)) i = sizeof(buf);
memset(&buf[0],0, sizeof(buf));
j = read(sd,buf,i);
err = errno;
if (j < 0)
printf("read() returned errno %d\n",err);
else
printf("got %d bytes, msg is >%s<\n",j,buf);
break;
case 'q' :
close(sd);
break;
default:
printf("\n");
break;
}
}
exit(EXIT_SUCCESS);
}
See Also
device driver,
hosts,
hosts.equiv,
hosts.lpd,
inetd.conf,
libraries,
msgget(),
named pipes,
networks,
pipe(),
protocols,
semget(),
services,
shmget(),
STREAMS
Notes
The version of sockets included with COHERENT is not built into the kernel.
Rather, it uses a library of routines that use named pipes to emulate
sockets. You should not invoke the system calls read() or write() to
manipulate directly any descriptor returned by a call to socket(), because
this descriptor defines only one of a set of named pipes required to mimic
a true kernel-level socket. Header file <sys/socket.h> replaces
these with the macros that perform the task correctly. This means that in
every C file where you perform a read(), write(), ioctl(), or close() on a
socket, you must include <sys/socket.h>.
This library was adapted from Berkeley sources by P.Garbha
(pgd@compuram.bbt.se), and was extensively revised by Mark Williams
Company.
This product includes software developed by the University of California,
Berkeley, and its contributors.
