Sockets
(Part II)
LESSON 22

Outline:
Sockets (Part II)

Iterative / Concurrent Servers:

• A server can handle requests (after setup) either iteratively or concurrently.
• A new socket is created, the destination is the new client, and a socket descriptor is returned.
• Iterative:
  • Server handles the request itself,
  • Closes the new socket,
  • Then calls Accept to get the next request.
• Concurrent:
  • Master server process creates a slave process to handle the request (with the Fork() command).
  • It passes control of the new socket to the slave.
  • Then calls Accept to process the next request.
• Allocated processes:
  • One process per client is used.
  • One additional process that accepts connections.

Socket System Calls:
Select

• Select: This system call allows a single process to wait for connections on multiple sockets (I/O and communication).

Obtaining Local and Remote
Socket Addresses:

• Getpeername (socket, destaddr, addrlen):
  • used to get the address of the connected peer process.
• Getsockname (socket, localaddr, addrlen):
  • Returns the local address associated with the socket descriptor specified.

Obtaining and Setting
Socket Options:

• Getsockopt(socket, level, optionid, optionval, length):
  • Gets the socket option values that are set for the socket specified.
• Setsockopt(socket, level,optionid, optionval, length):
  • Sets the socket options for the socket specified.
• Options are to:
  • Obtain and set time-out parameters (retransmission).
  • Control allocation of buffer space.
  • Determine if the socket allows transmission of broadcast messages.
  • Control processing of out-of-band data.

Obtaining and Setting
Host Names:

• The internal name chosen to be the domain name of the host, can be changed.
  • Gethostname(name, length)
  • Sethostname (name, length)

Obtaining and Setting
Internal Host Domain:

• Similar to gethostname, these commands are used to set and get the internal domain.
  • Setdomainname (name, length)
  • Getdomainname (name, length)

Obtaining and Setting
The Time of Day:

• Gettimeofday extracts the current time and date from the system along with information about the local time zone.
• Conversely, settimeofday allows the process to set these values accordingly.
  • Gettimeofday (tm, tmzone)
  • Settimeofday (tm, tmzone)
    • Tm - timeval structure.
    • Tmzone - timezone structure.

System Calls vs. Network Library Calls:

• In addition to system calls, BSD UNIX operating systems use a set of library routines which perform useful functions related to networking.
• System vs. Library Calls:
  • System calls pass control to the computer’s operating system.
  • Library routines are similar to other procedures that a programmer binds into an executable program.

Accessing the Domain Naming System:

• 4.3 BSD UNIX provides several interface library procedures to access TCP/IP's Domain Naming System.
• The communication between clients and domain name servers can include many options and parameters. To generalize, they all use the res global data structure.
• When using these procedures, a program must first call res_init() to initialize the res global info.
• Several of the procedures to access the DNS include:
  • res_mkquery - forms a DNS query and puts it in a memory buffer.
  • res_send - sends the query to the name server and obtains the response.
  • dn_expand - expands a compressed domain name into a full ASCII version.
  • dn_comp - compresses full domain names.

Obtaining Information about
Hosts:

• When library procedures are used on a system that does not have access to the DNS, they use the following commands to obtain information about hosts.
  • Gethostbyname (namestr) - uses (/etc/hosts) file.
  • Gethostbyaddr (addr, len, type).

Obtaining Information about
Networks:

• Two network library routines exist that allow a process to access the network information database.
  • Getnetbyname (domain name)
  • Getnetbyaddr (netaddr, addrtype) - NetID

Obtaining Information about
Protocols:

• Getprotobyname (name) - uses (/etc/protocols) file.
• Getprotobynumber (number) - assigned by the database.

Obtaining Information about
Network Services:

• Library routines to provide information about services and the protocol ports they use.
  • Getservbyname (name, proto) - uses (/etc/services) file.
  • Getservbyport (port, proto)

Routines for Integer Conversions:

• Hosts use different native byte orderings> to represent binary integer values.
• Applications at those sites that use TCP/IP must convert to and from network standard byte order (Big Endian).
• Doing so makes source code portable to any machine, regardless of it's native byte order.
• Four conversion routines exist:

  htons (host to network short) - ntohs (network to host short) - htonl (host to network long) - ntohl (network to host long) -

  16 bit. 16 bit. 32 bit. 32 bit.

IP-Address Manipulation Routines:

• Inet_addr and Inet_network:
  • Both translate an domain name from dotted decimal format to a 32-bit IP address (taking strings as input).
• Inet_ntoa:
  • Does just the opposite (32-bit IP address to dotted decimal format).
• Inet_makeaddr:
  • Combines a network address with the local address of a host on that network.
• Inet_netof:
  • Gets the NetID (network portion) of a full address.
• Inet_lnaof:
  • Gets the HostID (host portion) of a full address.

Socket Call Traces:
Trumpet WinSock

• HTTP call to Dan's home-page on the WWW:
  • socket (2,1,6)
  • WSAAsyncSelect (1,268C,D28C,3F)
  • setsockopt (1,-1,128,27FF:9BA4,4)
  • connect (1,<2,128.235.35.70:800,16)
  • select (2,27FF:A204,27FF:A182,27FF:A100, 27FF:A286)
  • connect (1,<2,128.235.35.70:800,16)
  • send (1,1BFF:C8B8,299,0)
  • recv (1,27FF:9EA0,260,0)
  • select (2,27FF:A204,27FF:A182,27FF:A100, 27FF:A286)
  • recv (1,27FF:9EA0,260,0)
  • closesocket (1)
• Link to an external image on Dan’s home-page:
  • socket (2,1,6)
  • WSAAsyncSelect (1,268C,D28C,3F)
  • setsockopt (1,-1,128,27FF:9A40,4)
  • connect (1,<2,204.217.174.42:80,16)
  • select (2,27FF:A204,27FF:A182,27FF:A100, 27FF:A286)
  • connect (1,<2,204.217.174.42:80,16)
  • send (1,1BFF:BCB6,297,0)
  • recv (1,27FF:9EA0,260,0)
  • select (2,27FF:A204,27FF:A182,27FF:A100, 27FF:A286)
  • recv (1,27FF:9EA0,260,0)
  • closesocket (1)

Recommend Socket Programming Steps for
Client Side "Whois":

• gethostbyname (host)
• getservbyname ("whois", "TCP")
• Fill in structure:

  sockaddr_in (sa).

• Create a socket:

  s = socket (addr type, SOC_STREAM, 0)

• connect (s, &sa, sizeof (sa))
• Send request:

  write (s, username, strlen (username))

• Read response:

  len = read (s, buf, BUFSIZE)

• Print response:

  write (l, buf, len)

Recommend Socket Programming Steps for:
Server Side "Whois":

• getservbyname ("whois", "TCP")
• gethostname (localhost, MAXHOSTNAME)
• gethostbyname (localhost)
• Fill in structure:

  sockaddr_in (sa).

• Create a socket:

  s = socket (addr type, SOC_STREAM, 0)

• Bind socket:

  bind (s, &sa, sizeof (sa))

• listen (s, BACKLOG)
• t = accept (s, &isa, sizeof (isa))
• Wait for a request. If it arrives:
  • Create a new socket t.
  • Fill in structure isa with information about the client.
  • Return t to the client.
  • Call whois (t):

    read (t, buf, BUFSIZE)

    p = getpwnam (buf)

    sprintf (buf, p->pw_name, p->pw_gecos)

    write (t, buf, strlen (buf))

    return

  • close (t)

Socket Structures:
Sockaddr_in

Socket Structures:
Hostent

struct hostent {

char char int int char }

*h_name; **h_aliases; h_addrtype; h_length; **h_addr_list;

/* official host name */ /* other aliases */ /* address type */ /* address length */ /* list of addresses */

#define

h_addr

h_addr_list[0]

Socket Structures:
Servent

struct servent {

char char int char

*s_name; **s_aliases; s_port; *s_proto;

/* official service name */ /* other aliases */ /* port for this service */ /* protocol to use */

};

Socket Structures:
Protoent

struct protoent {

char char int

*p_name; **p_aliases; *p_proto;

/* official protocol name */ /* list of aliases allowed */ *p_proto; /* official protocol # */

};

Sample Socket Program:
Client-side

#include <stdio.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <netdb.h>

/* Define the port number for client/server */

#define SERV_TCP_PORT #define BSIZE

6305 256

main (argc, argv)

int argc;

char *argv[];

{

int int FILE char char char

i, j, s; len, readin; *fp; *myname, c; *host; *fname;

char	buf[BUFSIZ+1];

struct sockaddr_in sa; struct hostent *hp;

/* socket addr. structure */ /* host name lookup */

myname = argv[0];

if (argc != 3)

{	fprintf(stderr, "Usage: %s host username.\n", myname); exit(1);
}

host = argv[1];

fname = argv[2];

/* Get host information from "hosts" database, such

as, h_addr: address, h_addrtype: host address type */

if ((hp = gethostbyname(host)) == NULL)

{	fprintf(stderr, "%s: %s: no such host!\n", myname, host); exit( 1 );
}

/* Open the input file */

if ( (fp = fopen(fname, "r")) == NULL )

{	fprintf(stderr, "%s: %s: no such file!\n", myname, fname);
exit( 1 );	}

/* Get data from the input file */

j = 0;

while ((c = fgetc(fp)) != EOF)

{

buf [j++] = c;

}

buf [j] = EOF;

/* Fill in the "sockaddr_in" structure with some

information from "hostent" structure. */

sa.sin_family = hp->h_addrtype;

sa.sin_port = htons(SERV_TCP_PORT);

bcopy ((char *)hp->h_addr, (char *)&sa.sin_addr, hp- >h_length );

/* Open a TCP/STREAM socket */

if ( (s = socket(hp->h_addrtype, SOCK_STREAM, 0)) < 0)

{	perror("socket");
exit(1)	}

/* Setup connection to the remote server */

if (connect(s, &sa, sizeof sa) < 0)

{	perror("connect");
exit(1)	}

/* Send the messages */

write(s, buf, strlen(buf), 0);

/* Receive the reply and print it out */

bzero((char *) buf, sizeof(buf));

while ( (len = read(s, buf, BUFSIZ)) > 0)

{

printf("Receiving from server: %s\n", host);

printf(">>> %s\n", buf);

}

/* Close the socket */

close(s);

exit(0);

}

Last Modification: (Sunday, August 25, 1996)

All work was written, produced, and is copyrighted by Daniel Z. Tabor Jr.
Page created by Daniel Z. Tabor Jr. Copyright ©1996 Illusion Industries Inc.