/* connectTCP.

c - connectTCP */
int connectsock(const char *host, const char *service,
const char *transport);
/*-----------------------------------------------------------------------* connectTCP - connect to a specified TCP service on a specified host
*-----------------------------------------------------------------------*/
int
connectTCP(const char *host, const char *service )
/*
* Arguments:
* host - name of host to which connection is desired
* service - service associated with the desired port
*/
{
return connectsock( host, service, "tcp");
}
/* connectUDP.c - connectUDP */
int connectsock(const char *host, const char *service,
const char *transport);
/*-----------------------------------------------------------------------* connectUDP - connect to a specified UDP service on a specified host
*-----------------------------------------------------------------------*/
int
connectUDP(const char *host, const char *service )
/*
* Arguments:
* host - name of host to which connection is desired
* service - service associated with the desired port
*/
{
return connectsock(host, service, "udp");
}
/* connectsock.c - connectsock */
#define __USE_BSD 1
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <string.h>
#include <stdlib.h>
#ifndef INADDR_NONE
#define INADDR_NONE 0xffffffff
#endif /* INADDR_NONE */
typedef unsigned short u_short;
extern int errno;
int errexit(const char *format, ...);
/*-----------------------------------------------------------------------* connectsock - allocate & connect a socket using TCP or UDP
*-----------------------------------------------------------------------*/
int
connectsock(const char *host, const char *service, const char *transport )
/*
* Arguments:
* host - name of host to which connection is desired
* service - service associated with the desired port
* transport - name of transport protocol to use ("tcp" or "udp")
*/

{
struct hostent *phe; /* pointer to host information entry */
struct servent *pse; /* pointer to service information entry */
struct protoent *ppe; /* pointer to protocol information entry*/
struct sockaddr_in sin; /* an Internet endpoint address */
int s, type; /* socket descriptor and socket type */
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
/* Map service name to port number */
if ( pse = getservbyname(service, transport) )
sin.sin_port = pse->s_port;
else if ( (sin.sin_port = htons((u_short)atoi(service))) == 0 )
errexit("can't get \"%s\" service entry\n", service);
/* Map host name to IP address, allowing for dotted decimal */
if ( phe = gethostbyname(host) )
memcpy(&sin.sin_addr, phe->h_addr, phe->h_length);

64
else if ( (sin.sin_addr.s_addr = inet_addr(host)) == INADDR_NONE )
errexit("can't get \"%s\" host entry\n", host);
/* Map transport protocol name to protocol number */
if ( (ppe = getprotobyname(transport)) == 0)
errexit("can't get \"%s\" protocol entry\n", transport);
/* Use protocol to choose a socket type */
if (strcmp(transport, "udp") == 0)
type = SOCK_DGRAM;
else
type = SOCK_STREAM;
/* Allocate a socket */
s = socket(PF_INET, type, ppe->p_proto);
if (s < 0)
errexit("can't create socket: %s\n", strerror(errno));
/* Connect the socket */
if (connect(s, (struct sockaddr *)&sin, sizeof(sin)) < 0)
errexit("can't connect to %s.%s: %s\n", host, service,
strerror(errno));
return s;
}
/* errexit.c - errexit */
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
/*-----------------------------------------------------------------------* errexit - print an error message and exit
*-----------------------------------------------------------------------*/
/*VARARGS1*/
int
errexit(const char *format, ...)
{
va_list args;
va_start(args, format);
vfprintf(stderr, format, args);
va_end(args);
exit(1);
}

/* TCPdaytime.c - TCPdaytime, main */

#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
extern int errno;
int TCPdaytime(const char *host, const char *service);
int TCPecho(const char *host, const char *service);
int errexit(const char *format, ...);
int connectTCP(const char *host, const char *service);
#define UNIXEPOCH 2208988800 /* UNIX epoch, in UCT secs */
#define LINELEN 128
#define MSG "what time is it?\n"
/*-----------------------------------------------------------------------* main - TCP client for DAYTIME service
*-----------------------------------------------------------------------*/
int
main(int argc, char *argv[])
{
char *host = "localhost"; /* host to use if none supplied */
char *service = "daytime"; /* default service port */
//char *service = "echo"; /* default service name */
//char *service = "time"; /* default service name */
switch (argc) {
case 1:
host = "localhost";
break;
case 3:
service = argv[2];
/* FALL THROUGH */
case 2:
host = argv[1];
break;
default:
fprintf(stderr, "usage: TCPdaytime [host [port]]\n");
exit(1);
}
TCPdaytime(host, service);
//TCPecho(host, service);
//TCPtime(host, service);
//UDPdaytime(host, service);
//UDPecho(host, service);
//UDPtime(host, service);
exit(0);
}

/*-----------------------------------------------------------------------* TCPdaytime - invoke Daytime on specified host and print results

*-----------------------------------------------------------------------*/
TCPdaytime(const char *host, const char *service)
{
char buf[LINELEN+1]; /* buffer for one line of text */
int s, n; /* socket, read count */
s = connectTCP(host, service);
while( (n = read(s, buf, LINELEN)) > 0) {
buf[n] = '\0'; /* ensure null-terminated */
(void) fputs( buf, stdout );
}
/*-----------------------------------------------------------------------* TCPecho - send input to ECHO service on specified host and print reply
*-----------------------------------------------------------------------*/
int
TCPecho(const char *host, const char *service)
{
char buf[LINELEN+1]; /* buffer for one line of text */
int s, n; /* socket descriptor, read count*/
int outchars, inchars; /* characters sent and received */
s = connectTCP(host, service);
while (fgets(buf, sizeof(buf), stdin)) {
buf[LINELEN] = '\0'; /* insure line null-terminated */
outchars = strlen(buf);
(void) write(s, buf, outchars);
/* read it back */
for (inchars = 0; inchars < outchars; inchars+=n ) {
n = read(s, &buf[inchars], outchars - inchars);
if (n < 0)
errexit("socket read failed: %s\n",
strerror(errno));
}
fputs(buf, stdout);
}
}
/*-----------------------------------------------------------------------* TCPtime - invoke time on specified host and print results
*-----------------------------------------------------------------------*/
int
TCPtime (const char *host, const char *service)
{
time_t now; /* 32-bit integer to hold time */
int s, n; /* socket descriptor, read count*/
s = connectTCP(host, service);
/* Read the time */
n = read(s, (char *)&now, sizeof(now));
if (n < 0)
errexit("read failed: %s\n", strerror(errno));
now = ntohl((u_long)now); /* put in host byte order */
now -= UNIXEPOCH; /* convert UCT to UNIX epoch */
printf("%s", ctime(&now));
}

/*-----------------------------------------------------------------------* UDPtime - invoke time on specified host and prints resulting time
*-----------------------------------------------------------------------*/
int
UDPtime(const char *host, const char *service)
{
time_t now; /* 32-bit integer to hold time */
int s, n; /* socket descriptor, read count*/
s = connectUDP(host, service);
(void) write(s, MSG, strlen(MSG));
/* Read the time */
n = read(s, (char *)&now, sizeof(now));
if (n < 0)
errexit("read failed: %s\n", strerror(errno));
now = ntohl((u_long)now); /* put in host byte order */
now -= UNIXEPOCH; /* convert UCT to UNIX epoch */
printf("%s", ctime(&now));
}
/*-----------------------------------------------------------------------* UDPecho - send input to ECHO service on specified host and print reply
*-----------------------------------------------------------------------*/
int
UDPecho(const char *host, const char *service)
{
char buf[LINELEN+1]; /* buffer for one line of text */
int s, nchars; /* socket descriptor, read count*/
s = connectUDP(host, service);
while (fgets(buf, sizeof(buf), stdin)) {
buf[LINELEN] = '\0'; /* insure null-terminated */
nchars = strlen(buf);
(void) write(s, buf, nchars);
if (read(s, buf, nchars) < 0)
errexit("socket read failed: %s\n",
strerror(errno));
fputs(buf, stdout);
}
}
/*-----------------------------------------------------------------------* UDPdaytime - invoke Daytime on specified host and print results
*-----------------------------------------------------------------------*/
int
UDPdaytime(const char *host, const char *service)
{
char buf[LINELEN+1]; /* buffer for one line of text */
int s, nchars; /* socket descriptor, read count*/
s = connectUDP(host, service);
(void) write(s, MSG, strlen(MSG));
n=read(s, buf, LINELEN );
if (n< 0) errexit("socket read failed: %s\n",strerror(errno));
buf[n]=\n;
fputs(buf, stdout);
}
}

/* passiveUDP.c - passiveUDP */
int passivesock(const char *service, const char *transport,
int qlen);
/*-----------------------------------------------------------------------* passiveUDP - create a passive socket for use in a UDP server
*-----------------------------------------------------------------------*/
int
passiveUDP(const char *service)
/*
* Arguments:
* service - service associated with the desired port
*/
{
return passivesock(service, "udp", 0);
}
/* passiveTCP.c - passiveTCP */
int passivesock(const char *service, const char *transport,int qlen);
/*-----------------------------------------------------------------------* passiveTCP - create a passive socket for use in a TCP server
*-----------------------------------------------------------------------*/
int
passiveTCP(const char *service, int qlen)
/*
* Arguments:
* service - service associated with the desired port
* qlen - maximum server request queue length
*/
{
return passivesock(service, "tcp", qlen);
}
/* passivesock.c - passivesock */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
#include <netdb.h>
extern int errno;
typedef unsigned short u_short;
int errexit(const char *format, ...);
u_short portbase = 0; /* port base, for non-root servers */
/*-----------------------------------------------------------------------* passivesock - allocate & bind a server socket using TCP or UDP
*-----------------------------------------------------------------------*/
int
passivesock(const char *service, const char *transport, int qlen)
/*
* Arguments:
* service - service associated with the desired port
* transport - transport protocol to use ("tcp" or "udp")
* qlen - maximum server request queue length
*/
{
struct servent *pse; /* pointer to service information entry */
struct protoent *ppe; /* pointer to protocol information entry*/
struct sockaddr_in sin; /* an Internet endpoint address */
int s, type; /* socket descriptor and socket type */
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;

sin.sin_addr.s_addr = INADDR_ANY;
/* Map service name to port number */
if ( pse = getservbyname(service, transport) )
sin.sin_port = htons(ntohs((u_short)pse->s_port)
+ portbase);
else if ( (sin.sin_port = htons((u_short)atoi(service))) == 0 )
errexit("can't get \"%s\" service entry\n", service);
/* Map protocol name to protocol number */
if ( (ppe = getprotobyname(transport)) == 0)
errexit("can't get \"%s\" protocol entry\n", transport);
/* Use protocol to choose a socket type */
if (strcmp(transport, "udp") == 0)
type = SOCK_DGRAM;
else
type = SOCK_STREAM;
/* Allocate a socket */
s = socket(PF_INET, type, ppe->p_proto);
if (s < 0)
errexit("can't create socket: %s\n", strerror(errno));
/* Bind the socket */
if (bind(s, (struct sockaddr *)&sin, sizeof(sin)) < 0)
errexit("can't bind to %s port: %s\n", service,
strerror(errno));
if (type == SOCK_STREAM && listen(s, qlen) < 0)
errexit("can't listen on %s port: %s\n", service,
strerror(errno));
return s;
}
/* UDPtimed.c - main */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
typedef unsigned long u_long;
extern int errno;
int passiveUDP(const char *service);
int errexit(const char *format, ...);
#define UNIXEPOCH 2208988800 /* UNIX epoch, in UCT secs */
/*-----------------------------------------------------------------------* main - Iterative UDP server for TIME service
*-----------------------------------------------------------------------*/
int
main(int argc, char *argv[])
{
struct sockaddr_in fsin; /* the from address of a client */
char *service = "time"; /* service name or port number */
//char *service = "echo"; /* default service name */
//char *service = "daytime"; /* default service port */
char buf[1]; /* "input" buffer; any size > 0 */
int sock; /* server socket */
time_t now; /* current time */
int alen; /* from-address length */
switch (argc) {
case 1:
break;

case 2:
service = argv[1];
break;
default:
errexit("usage: UDPtimed [port]\n");
}
sock = passiveUDP(service);
while (1) {
alen = sizeof(fsin);
if (recvfrom(sock, buf, sizeof(buf), 0,(struct sockaddr *)&fsin, &alen) < 0)
errexit("recvfrom: %s\n", strerror(errno));
(void) time(&now);
now = htonl((u_long)(now + UNIXEPOCH));
(void) sendto(sock, (char *)&now, sizeof(now), 0,(struct sockaddr *)&fsin,
sizeof(fsin));
}
}