/*---------------------------------------------------------------------+
| Copyright (c) 1995, SAS Institute Inc. |
| Unpublished - All Rights Reserved |
| S A S / C S A M P L E |
| |
| NAME: SENDER |
| LANGUAGE: C |
| PURPOSE: This application demonstrates IUCV communications in |
| CMS environments. SENDER works in conjunction with |
| the SAS/C RECEIVER 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 SENDER |
| LINK: CLINK SENDER (genmod |
| EXECUTE: SENDER |
| NOTES: The target virtual machine, in this case the machine |
| running the RECEIVER module, must be identified. |
| Modify the: #define TARGET statement below. The default|
| value is: "SASCUSER". The value *is* case sensitive, |
| if less then eight characters, padded with blanks. |
| |
+---------------------------------------------------------------------*/
#include <lcsignal.h>
#include <lcstring.h>
#include <cmsiucv.h>
#include <lcio.h>
/*----------------------------------------------------------------+
| TARGET must customized to identify the virtual machine |
| running the RECEIVER module. The value should be the virtual |
| machine name. If the name is not correct or the RECEIVER is NOT |
| running, expect IUCV connect errors with non-zero IPRCODE's. |
+----------------------------------------------------------------*/
#define TARGET "SASCUSER"
void iucvtrap(void); /* Declare SIGIUCV handler. */
/* Set up stdin amparms. */
char *_stdiamp = "prompt=What message do I send?\n,eof=";
int rep_len = 0;
short pathid = 0;
void main()
{
struct iucv_path_plist path; /* IUCV plist for CONNECT, SEVER. */
struct iucv_msg_plist msg; /* IUCV plist for SEND. */
int maxconns, /* Maximum number of IUCV connec- */
/* tions for this virtual machine*/
rc; /* Return code from IUCV functions*/
char message(|120|), /* Message buffer. */
reply(|120|); /* Reply buffer. */
/*----------------------------------------------------------------+
| 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 SENDER. |
+----------------------------------------------------------------*/
if ((rc = iucvset("SENDER",&maxconns)) != 0) {
printf("Return code from iucvset was %d\n",rc);
exit(4);
}
printf("Maximum IUCV connections: %d\n",maxconns);
/*----------------------------------------------------------------+
| Fill in the IUCV "path" parameter list with the target userid |
| and the name of the target program. All of the other parameters|
| are superflous in this program. |
| |
| Note that the userid copied to path.vmid must be eight bytes |
| long, padded on the right with blanks if necessary. |
+----------------------------------------------------------------*/
memset((char *) &path,0,sizeof(path));
memcpy(path.vmid,TARGET,8);
memcpy(path.pgm,"RECEIVER",8);
/*----------------------------------------------------------------+
| Request an IUCV CONNECT to the userid/program pair named in the |
| parameter list. Check for an IUCV error (return code of 1) and |
| print the IUCV error code. |
+----------------------------------------------------------------*/
rc = iucvconn("SENDER",&path);
if (rc != 0) {
printf("Return code from iucvconn was %d\n",rc);
if (rc == 1)
printf("IPRCODE = %d\n",path.ip.rcode);
exit(8);
}
/*----------------------------------------------------------------+
| Now we're ready. The first interrupt we will receive is the |
| CONNECTION COMPLETE interrupt that occurs when RECEIVER |
| issues an IUCV ACCEPT. |
+----------------------------------------------------------------*/
sigpause(0);
/*----------------------------------------------------------------+
| Initialize the SEND parameter list with the pathid and buffer |
| addresses, and the length of the reply buffer. |
+----------------------------------------------------------------*/
memset((char *) &msg,'\0',sizeof(msg));
path.pathid = msg.pathid = pathid;
msg.msg.bf1.adr = message;
msg.bf2.adr = reply;
msg.bf2.ln = sizeof(reply);
/*----------------------------------------------------------------+
| Prompt for input messages and send until EOF. |
+----------------------------------------------------------------*/
fgets(message,sizeof(message),stdin);
while (!feof(stdin))
{
/*-------------------------------------------------------------+
| Put message length in the SEND parameter list. |
+-------------------------------------------------------------*/
msg.msg.bf1.ln = strlen(message) - 1;
/*-------------------------------------------------------------+
| Send message. Wait (via sigpause) for reply. Upon receipt |
| of reply, 'rep_len' contains the number of unused bytes in |
| the reply buffer. Print the reply and prompt for a new |
| message. |
+-------------------------------------------------------------*/
iucvsend(&msg);
sigpause(0);
rep_len = sizeof(reply) - rep_len;
printf("RECEIVER replies \"%.*s\"\n",rep_len,reply);
fgets(message,sizeof(message),stdin);
}
/*----------------------------------------------------------------+
| We're ready to quit. SEVER the IUCV path. Check for IUCV |
| errors as before. |
+----------------------------------------------------------------*/
if ((rc = iucvsevr("SENDER",&path,"ONE")) != 0) {
printf("Return code from iucvsever = %d\n",rc);
if (rc == 1)
printf("IPRCODE = %d\n",path.ip.rcode);
exit(10);
}
/*----------------------------------------------------------------+
| Terminate IUCV communications for SENDER. |
+----------------------------------------------------------------*/
iucvclr("SENDER");
exit(0);
}
#eject
/*-------------------------------------------------------------------+
| The 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 arbitrary since it */
/* can point to any of the */
/* IUCV structures. */
/*----------------------------------------------------------------+
| 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_COMPLETE: /* Save the pathid for SEND. */
pathid = XID->pathid;
break;
case INCOMING_REPLY: /* Extract the number of unused */
/* characters in the buffer. */
rep_len = ((iucv_msg_data *)XID)->bf2.ln;
break;
case PATH_SEVERED: /* Handle unexpected termination */
/* of RECEIVER. */
puts("Unexpected SEVER!");
exit(20);
default: /* Handle unexpected type of */
/* IUCV signal. */
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;
}
|
