/*---------------------------------------------------------------------+
| Copyright (c) 1995, SAS Institute Inc. |
| Unpublished - All Rights Reserved |
| S A S / C S A M P L E |
| |
| NAME: RECEIVER |
| LANGUAGE: C |
| PURPOSE: This application demonstrates IUCV communications in |
| CMS environments. RECEIVER works in conjunction with |
| the SAS/C SENDER sample. Refer to the SAS/C Library |
| Reference, Volume 2, Third Edition, Version 6.00 for |
| additional information. |
| MVS - N/A - SAS/C IUCV functions are only supported in CMS. |
| CMS - |
| COMPILE: LC370 RECEIVER |
| LINK: CLINK RECEIVER (genmod |
| EXECUTE: RECEIVER |
| MISC NOTES: RECEIVER must be started prior to SENDER, or SENDER |
| will terminate with an IUCV error. |
+---------------------------------------------------------------------*/
#include <lcsignal.h>
#include <lcstring.h>
#include <cmsiucv.h>
#include <lcio.h>
void iucvtrap(void); /* Declare SIGIUCV signal handler.*/
/* Establish stdin prompt string. */
char *_stdiamp = "prompt=What do I reply to SENDER?\n";
int connects = 0; /* Number of connections made. */
/*-------------------------------------------------------------------+
| Declare internal functions. |
+-------------------------------------------------------------------*/
static void rcvrply(iucv_msg_data *);
void main()
{
int maxconns, /* Number of IUCV connections */
/* allowed. */
rc; /* Return code from IUCV functions*/
/*----------------------------------------------------------------+
| Initialize IUCV signal processing and establish a handler. |
| Block IUCV signals until we're ready to handle them. |
+----------------------------------------------------------------*/
signal(SIGIUCV,(_HANDLER) &iucvtrap);
sigblock(1 << (SIGIUCV-1));
/*----------------------------------------------------------------+
| Identify this program as RECEIVER. |
+----------------------------------------------------------------*/
if ((rc = iucvset("RECEIVER",&maxconns)) != 0) {
printf("Return code from iucvset was %d\n",rc);
exit(4);
}
printf("Maximum IUCV connections: %d\n",maxconns);
/*----------------------------------------------------------------+
| This call waits for the initial CONNECTION PENDING interrupt. |
+----------------------------------------------------------------*/
sigpause(0);
/*----------------------------------------------------------------+
| As long as some SENDER is connected, wait for incoming messages.|
+----------------------------------------------------------------*/
while (connects > 0) sigpause(0);
/*----------------------------------------------------------------+
| All paths have been terminated. Terminate IUCV processing. |
+----------------------------------------------------------------*/
iucvclr("RECEIVER");
exit(0);
}
#eject
/*-------------------------------------------------------------------+
| SIGIUCV signal handler. Signals are blocked until return. |
+-------------------------------------------------------------------*/
void iucvtrap()
{
iucv_path_data *XID; /* Pointer to external interrupt */
/* data returned by siginfo. The */
/* type is arbitrarily chosen */
/* since it can point to any of */
/* the IUCV structures. */
int rc; /* Return code from iucvacc. */
/*----------------------------------------------------------------+
| Get a pointer to the external interrupt data. Use the interrupt|
| type to determine what to do. |
+----------------------------------------------------------------*/
XID = (iucv_path_data *) siginfo();
switch (XID->ip.type)
{
case CONNECTION_PENDING: /* Issue ACCEPT. */
XID->ip.type = 0;
if ((rc = iucvacc("RECEIVER",XID)) != 0) {
printf("Return code from iucvacc = %d\n",rc);
if (rc == 1)
printf("IPRCODE = %d\n",XID->ip.rcode);
exit(8);
}
connects++; /* Keep track of the number of */
break; /* connections made. */
case INCOMING_MSG: /* Call function to get message */
/* and send reply. */
rcvrply((iucv_msg_data *)XID);
break;
case PATH_SEVERED: /* SENDER decided to stop. */
if ((rc = iucvsevr("RECEIVER",XID,"ONE")) != 0) {
printf("Return code from iucvsevr = %d\n",rc);
exit(8);
}
connects--; /* Update number of connections. */
break;
default: /* Handle other interrupt types. */
printf("Unexpected interrupt type %d\n",XID->ip.type);
fflush(stdout);
abort();
}
/*----------------------------------------------------------------+
| Re-establish this function as the SIGIUCV signal handler. |
+----------------------------------------------------------------*/
signal(SIGIUCV,(_HANDLER) &iucvtrap);
return;
}
#eject
/*-------------------------------------------------------------------+
| Function to issue IUCV RECIEVE and print the message. |
+-------------------------------------------------------------------*/
static void rcvrply(m_data)
iucv_msg_data *m_data;
{
int msg_len; /* Incoming message length. */
char msg_buffer(|120|); /* Message buffer. */
/*----------------------------------------------------------------+
| Create IUCV RECEIVE parameter list using the external |
| interrupt data area. Issue the IUCV RECEIVE. |
+----------------------------------------------------------------*/
m_data->msg.bf1.adr = msg_buffer;
m_data->msg.bf1.ln = sizeof(msg_buffer);
iucvrecv(m_data);
/*----------------------------------------------------------------+
| Upon return, m_data->msg.bf1.ln contains the number of unused |
| bytes in the message buffer. Print the message. |
+----------------------------------------------------------------*/
msg_len = sizeof(msg_buffer) - m_data->msg.bf1.ln;
printf("SENDER says \"%.*s\"\n",msg_len,msg_buffer);
/*----------------------------------------------------------------+
| Prompt for a reply message. If EOF, quit. |
+----------------------------------------------------------------*/
fgets(msg_buffer,sizeof(msg_buffer),stdin);
if (feof(stdin)) {
puts("Terminating due to end-of-file.");
exit(12);
}
/*----------------------------------------------------------------+
| Fill in IUCV REPLY parameter list with buffer address/length. |
| Send REPLY. |
+----------------------------------------------------------------*/
m_data->bf2.adr = msg_buffer;
m_data->bf2.ln = strlen(msg_buffer) - 1;
iucvrply(m_data);
}
|
