/*---------------------------------------------------------------------+
| Copyright (c) 1995, SAS Institute Inc. |
| Unpublished - All Rights Reserved |
| S A S / C S A M P L E |
| |
| NAME: TCPLISTN |
| LANGUAGE: C |
| PURPOSE: Demonstrate a TCP listener application that "attaches" |
| a TCP Server, TCPTSERV, on MVS. TCPLISTN details the |
| following socket calls: |
| socket(), bind(), listen(), accept(), read(), |
| givesocket(), takesocket(), select() and close(). |
| MVS - |
| COMPILE, LINK: SUBMIT prefix.SAMPLE.AUX(TCPLISTN) |
| EXECUTE: prefix.SAMPLE.AUX(TCPLSGO) |
| where "prefix" is the installation defined high-level- |
| qualifier for the SAS/C product. |
| NOTES: TCPLISTN assumes a working TCP/IP environment on both |
| the local and remote hosts, refer to MISC NOTES. |
| TSO - |
| COMPILE: LC370 CLIST - options ENXREF EXTNAME RENT |
| LINK: CLK370 CLIST |
| EXECUTE: call 'your.local.load(TCPLISTN)' |
| NOTES: TCPLISTN assumes a working TCP/IP environment on both |
| the local and remote hosts. Refer to MISC NOTES: |
| CMS - N/A - Multi-tasking is NOT supported w/in CMS |
| MISC NOTES: TCPLISTN needs to be customized for the local TCP/IP |
| environment. The local information required by |
| TCPLISTN is: |
| LISTENPORT - defines the port TCPLISTN will do a |
| listen(). Default is port 13. |
| QUITSTRING - used as a method to terminate TCPLISTN. |
| TCPLISTN will read the message from the |
| client application, if the message is: |
| QUITSTRING, then TCPLISTN terminates. |
| MAXSOCKETS - defines the maximum number of sockets |
| for the select() socket array. |
| MISC NOTES: Use TCPCLNT to test the TCPLISTN listener. |
| MISC NOTES: TCPLISTN uses the following environment variables: |
| TCP_SOCK - Socket descriptor passed to TCPTSERV |
| TCP_DOMAIN - AF_INET = 2, passed to TCPTSERV |
| TCP_NAME - Listener Jobname, passed to TCPTSERV |
| TCP_SUBTASKNAME - taskname from getclientid() passed |
| to TCPTSERV. On the givesocket() call, |
| sub-taskname is set to: ' ' |
| MISC NOTES: Telnet may be used to terminate the TCPLISTN. Telnet |
| to the HOST and PORT for TCPLISTN, and then enter the |
| QUITSTRING as defined below. |
| |
+---------------------------------------------------------------------*/
#define LISTENPORT 13 /* Set default listen port */
#define QUITSTRING "LSNRQUIT" /* If the recv() message is QUITSTRING */
/* terminate TCPLISTN */
#define MAXSOCKETS 50 /* max sockets opened at once */
/*-------------------------------------------------------------------+
| Includes for socket calls. |
+-------------------------------------------------------------------*/
#include <sys/types.h>
#include <ctype.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#if __SASC__ == 550
#include <fcntl.h>
#else
#include <unistd.h>
#endif
/*-------------------------------------------------------------------+
| Include for ATTACH. |
+-------------------------------------------------------------------*/
#include <ostask.h>
/*-------------------------------------------------------------------+
| Miscellaneous includes. |
+-------------------------------------------------------------------*/
#include <lclib.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <lcstring.h>
#define TRUE 1
#define FALSE 0
#define MAXREQLEN 256 /* max length of request, in chars */
/*-------------------------------------------------------------------+
| Macros for converting EBCDIC <-> ASCII. |
+-------------------------------------------------------------------*/
#define convFromAscii(str) {cp=(str); while(*cp = ntohcs(*cp)) cp++;}
#define convToAscii(str) {cp=(str); while(*cp = htoncs(*cp)) cp++;}
int setupSocket(void);
int acceptRequest(void);
int closeSockets(int);
void Quit(void);
struct Argument {
short len;
char parms[1000];
};
struct socklist { /* linked list of socket file descriptors */
int sock;
int domain; /* so that it can issue takesocket() */
char name[8]; /* so that it can issue takesocket() */
char subtaskname[8];
char pgmname[8];
void *subtcb; /* Handle for ATTACHed program */
void *plist[1]; /* pointer to argument structure for ATTACH */
struct socklist *next;
} *servlist;
char *cp; /* char pointer for EBCDIC<->ASCII macros */
int listensock, /* socket on which we listen for requests */
numsockets, /* number of sockets opened by listener */
highsocket, /* highest socket number */
holdrequests; /* flag: listener cannot handle any more */
/* requests right now (all sockets used) */
fd_set pending, /* list of sockets waiting to be taken */
taken; /* list of sockets which have been taken */
struct clientid myid, /* clientid of listener for argument struct */
giveid; /* generic clientid used for givesocket() */
void main()
{
int ns; /* number of sockets with action */
fd_set incoming; /* bound socket description for select() */
struct timeval timeout;
/*----------------------------------------------------------------+
| Set up a socket, initialize list of pending servers to none, |
| and set timeout for select() call. |
+----------------------------------------------------------------*/
if (setupSocket() == -1)
exit(EXIT_FAILURE);
FD_ZERO(&pending);
holdrequests = FALSE;
timeout.tv_sec = 60;
timeout.tv_usec = 0;
while (TRUE)
{
do {
/*----------------------------------------------------------+
| Check for action on sockets given to ATTACHed programs, |
| as well as incoming socket (unless all sockets are used). |
+----------------------------------------------------------*/
FD_ZERO(&incoming);
if ((!holdrequests) && (numsockets < MAXSOCKETS))
FD_SET(listensock, &incoming);
taken = pending;
ns = select(highsocket+1, &incoming, NULL, &taken, &timeout);
} while (ns == 0);
if (ns == -1)
{
perror("select() call failed");
Quit();
}
/*-------------------------------------------------------------+
| If there was action on listensock, then handle the incoming |
| request. |
+-------------------------------------------------------------*/
if (FD_ISSET(listensock, &incoming))
{
ns--;
acceptRequest();
}
/*-------------------------------------------------------------+
| If there was action on any other sockets, then release the |
| sockets of those programs which have taken them. |
+-------------------------------------------------------------*/
if (ns > 0)
closeSockets(ns);
}
}
/*-------------------------------------------------------------------+
| Open a socket and set it up to accept requests. Return -1 if error.|
+-------------------------------------------------------------------*/
int setupSocket()
{
struct sockaddr_in sa_serv; /* socket address for server */
int sa_len = sizeof(sa_serv);
char hostname[72];
/*----------------------------------------------------------------+
| Get a socket of the proper type. |
+----------------------------------------------------------------*/
listensock = socket(AF_INET, SOCK_STREAM, 0);
if (listensock == -1)
{
perror("socket() call failed in setupSocket()");
return -1;
}
numsockets = 1;
/*----------------------------------------------------------------+
| Get information about listener to pass to ATTACHed servers. |
| Clientid used for givesocket() should be the same but with a |
| subtaskname of all blanks. |
+----------------------------------------------------------------*/
if (getclientid(AF_INET, &myid) == -1)
{
perror("getclientid() call failed in setupSocket()");
close(listensock);
return -1;
}
giveid = myid;
memset(giveid.subtaskname, ' ', 8);
/*----------------------------------------------------------------+
| Prepare a socket address for the server. We will request the |
| port number LISTENPORT, unless LISTENPORT is 0, in which case |
| we are assigned the next available port number. |
+----------------------------------------------------------------*/
memset(&sa_serv, '\0', sizeof(sa_serv));
sa_serv.sin_family = AF_INET;
sa_serv.sin_addr.s_addr = htonl(INADDR_ANY);
sa_serv.sin_port = htons(LISTENPORT);
/*----------------------------------------------------------------+
| Bind our socket to the desired address so clients may reach us. |
+----------------------------------------------------------------*/
if (bind(listensock, &sa_serv, sizeof(sa_serv)) == -1)
{
perror("bind() call failed in setupSocket()");
close(listensock);
return -1;
}
/*----------------------------------------------------------------+
| Print listener information. |
+----------------------------------------------------------------*/
if (getsockname(listensock, &sa_serv, &sa_len) == -1)
{
perror("getsockname() failed in setupSocket()");
close(listensock);
return -1;
}
if (gethostname(hostname, sizeof(hostname)))
{
perror("gethostname() failed in setupSocket()");
close(listensock);
return -1;
}
printf("Listener is on Host: %.64s Port#: %d.\n",
hostname, (int) ntohs(sa_serv.sin_port));
printf("Request server name '" QUITSTRING "' to quit.\n");
/*----------------------------------------------------------------+
| Set up a queue for incoming requests. SOMAXCONN is maximum |
| size of queue. |
+----------------------------------------------------------------*/
listen(listensock, SOMAXCONN);
highsocket = listensock;
return 0;
}
/*-------------------------------------------------------------------+
| A request has been detected--accept it, givesocket(), and ATTACH |
| program. Return -1 if error. |
+-------------------------------------------------------------------*/
int acceptRequest()
{
int numchars, /* number of chars read from socket */
rc, /* rc from MVS ATTACH function */
pos, /* index variable */
reqsock, /* request socket */
i; /* index variable */
char req[MAXREQLEN+1], /* buffer for reading in request */
errstring[MAXREQLEN+80];/* error message sent to client */
struct socklist *new; /* new node in list of open sockets */
struct sockaddr_in sa_client;/* socket address of client */
int sa_len = sizeof(sa_client);
char Env_buff[256];
struct Argument *args;
char *valid = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
"abcdefghijklmnopqrstuvwxyz" \
"0123456789@$#";
/*----------------------------------------------------------------+
| Allocate space for a new addtion to the socklist |
+----------------------------------------------------------------*/
new = (struct socklist *)malloc(sizeof(struct socklist));
if (new == NULL)
{
perror("malloc() for new failed in acceptRequest()");
return -1;
}
memset(new, 0, sizeof(struct socklist));
args = (struct Argument *)malloc(sizeof(struct Argument));
if (args == NULL)
{
perror("malloc() for args failed in acceptRequest()");
return -1;
}
memset(args, 0, sizeof(struct Argument));
/*----------------------------------------------------------------+
| Divert incoming request to its own socket. If accept() call |
| fails, then all sockets are being used, so hold off requests. |
+----------------------------------------------------------------*/
reqsock = accept(listensock, &sa_client, &sa_len);
if (reqsock == -1)
{
perror("accept() failed in acceptRequest()");
holdrequests = TRUE;
return -1;
}
/*----------------------------------------------------------------+
| Read request from socket and convert from ASCII to EBCDIC. |
+----------------------------------------------------------------*/
numchars = read(reqsock, req, MAXREQLEN);
if (numchars < 0)
{
perror("socket read() failed in acceptRequest()");
close(reqsock);
return -1;
}
req[numchars] = '\0';
convFromAscii(req);
/*----------------------------------------------------------------+
| Check request for validity (a pretty lax check, admittedly). |
+----------------------------------------------------------------*/
if (req[0] == '\0')
{
strcpy(errstring, "MVS listener: empty request received.\n");
convToAscii(errstring);
write(reqsock, errstring, strlen(errstring));
close(reqsock);
return -1;
}
/*----------------------------------------------------------------+
| Set up the Env vars string for subtaskname, name, sock, etc. |
+----------------------------------------------------------------*/
new->domain = AF_INET;
memcpy(new->name, myid.name, 8);
memcpy(new->subtaskname, myid.subtaskname, 8);
sprintf(Env_buff, " =TCP_SOCK=%d =TCP_DOMAIN=%d " \
"=TCP_NAME=%s =TCP_SUBTASKNAME=%s",
reqsock, new->domain, new->name, new->subtaskname);
/*----------------------------------------------------------------+
| Separate the command from the parmameters |
+----------------------------------------------------------------*/
pos = strspn(req, valid);
req[pos] = '\0';
strcpy(new->pgmname, req);
strcpy(args->parms, (req+pos+1));
/*----------------------------------------------------------------+
| Clean up the Program name. |
+----------------------------------------------------------------*/
for (i = 0; i < sizeof(new->pgmname); i++)
{
if (new->pgmname[i] < ' ')
new->pgmname[i] = ' ';
else new->pgmname[i] = toupper(new->pgmname[i]);
}
/*----------------------------------------------------------------+
| Check for QUIT request. |
+----------------------------------------------------------------*/
if (strcmp(new->pgmname, QUITSTRING) == 0)
{
close(reqsock);
Quit();
}
/*----------------------------------------------------------------+
| Combine the Program parms and the environment vars and assign |
| to the plist pointer in new. |
+----------------------------------------------------------------*/
strcat(args->parms, Env_buff);
args->len = strlen(args->parms);
for (i = 0; i < args->len; i++)
{
if (args->parms[i] < ' ')
args->parms[i] = ' ';
}
new->plist [0] = (void *) (0x80000000 | (unsigned) args);
/*----------------------------------------------------------------+
| Give the socket and then attach the new subtask. |
+----------------------------------------------------------------*/
givesocket(reqsock, &giveid);
rc = ATTACH(&(new->subtcb), _Aep, new->pgmname, _Aparam,
new->plist, _Aend);
/*----------------------------------------------------------------+
| Check return code from ATTACH. |
+----------------------------------------------------------------*/
if (rc != 0)
{
fprintf(stderr, "ATTACH for server '%s' failed with rc = %d.\n",
new->pgmname, rc);
close(reqsock);
return -1;
}
/*----------------------------------------------------------------+
| Add this server to lists of pending programs. |
+----------------------------------------------------------------*/
new->sock = reqsock;
new->next = servlist;
servlist = new;
FD_SET(reqsock, &pending);
if (reqsock > highsocket)
highsocket = reqsock;
numsockets++;
return 0;
}
/*-------------------------------------------------------------------+
| Close sockets taken by ATTACHed servers. Return -1 if error. |
+-------------------------------------------------------------------*/
int closeSockets(nt)
int nt; /* number of sockets taken by ATTACHed servers */
{
struct socklist *servptr, /* list of file descriptors of */
*next, *prev; /* sockets given to servers */
int nr = nt; /* number of sockets left to close */
prev = servptr = servlist; /* point to first socket in list */
while ((nr > 0) && (servptr != NULL))
{
/*-------------------------------------------------------------+
| If this socket was taken by an ATTACHed server, then close |
| the socket, remove it from our lists, and signal that another|
| socket is free for use. |
+-------------------------------------------------------------*/
if (FD_ISSET(servptr->sock, &taken))
{
close(servptr->sock);
nr--;
numsockets--;
holdrequests = FALSE;
FD_CLR(servptr->sock, &pending);
next = servptr->next;
if (servptr == servlist)
servlist = next;
else
prev->next = next;
free((char *) servptr->plist[0]);
free((char *) servptr);
servptr = next;
}
else
{
prev = servptr;
servptr = servptr->next;
}
}
return 0;
}
/*-------------------------------------------------------------------+
| Close all sockets and quit. |
+-------------------------------------------------------------------*/
void Quit()
{
struct socklist *servptr, *next;
next = servlist;
while (next != NULL)
{
servptr = next;
next = servptr->next;
close(servptr->sock);
free((char *) servptr->plist[0]);
free((char *) servptr);
}
close(listensock);
exit(EXIT_SUCCESS);
}
|
