Administration	Version 6.2.1	SEARCH   INDEX   CONTENTS   |   PDF PAGE   PDF BOOKS   |   HOME   UP   PREV   NEXT

The Entire Net-Work Programmable Command Interface (PCI) is a callable interface that allows application programs to issue Entire Net-Work operator commands and process results from the commands.

• For 3GL applications, the Entire Net-Work subroutine NETPCI is provided. 3GL applications must be linked with both NETPCI and the ADAUSER module.

• For Natural applications, the CALLNAT subroutine USR1070N and the sample program USR1070P are provided in the library SYSEXT.

• For C applications, a sample program is provided.

This section covers the following topics:

• NODE Statement Parameters

• Calling the PCI from a 3GL Program

• Sample C Program

NODE Statement Parameters

The PCI is controlled using the following NODE statement parameters (for more information, see the section Entire Net-Work NODE Statement):

Calling the PCI from a 3GL Program

3GL programs use the NETPCI subroutine to communicate with the PCI. Each call must provide the following ten parameters:

TARGET

PASSWORD

FUNCTION

The following functions can be specified and are described in this section:

• LOGON
• COMMAND
• CONSOLE

LOGON

The LOGON function can be used by an application to verify a user-supplied password or determine an Entire Net-Work node ID for a given node name.

• A logon request is accepted by any Entire Net-Work Version 5.7 or later node, regardless of its PASSWORD setting.

• The request is then forwarded to the target node whose node name is specified by PARM.

• After successful logon, the node ID of the responding Entire Net-Work node is returned as the value of TARGET.

The return code (RC) is one of the following:

COMMAND

The COMMAND function causes the operator command specified by PARM to be executed on the node specified by TARGET.

Output generated during command execution that would normally be written to the local system console is placed in the RESULT output parameter. Each output line is followed by X`15'.

Output generated asynchronous to command execution is not included. For example, in response to a PROBE command, RESULT may contain the following message:

NET0136I: PROBE MESSAGE SENT

The message is followed by X`15'. However, no indication of the failure or success of the probe message is returned (i.e., no message NET0135.)

The length of the response is returned in RLEN. The return code (RC) is one of the following:

CONSOLE

The CONSOLE function causes lines from the wrap-around log buffer to be returned in the RESULT parameter.

• Each line is followed by X`15'.

• As many lines are returned as fit into RESULT of length RLEN.

• Output parameter LINENO contains the line number of the first line in RESULT.

• Output parameter RLEN contains the length of the data returned.

The return code (RC) is one of the following:

PLEN

PARM

LINENO

RLEN

RESULT

RC

REASON

Sample C Program

The following C program calls the NETPCI subroutine.

/*    This program is a sample application demonstrating the use      */
/* of function 'netpci' as Programmable Command Interface for         */
/* Entire Entire Net-Work V5.7 or later. This interface allows the         */
/* programmer to 'logon' to a Net-work node, issue                    */ 
/* operator commands and receive the reply in a buffer.               */
/* Multiple output lines in the reply buffer are separated by         */
/* logical line-end X'15'. Also, a function is provided to retrieve   */
/* a wrap-around buffer that mirrors recent output to DDPRINT.        */
/*                                                                    */
/*                                                                    */
/* Programming Note:                                                  */
/*    In the data definition below, variable 'target' is initialized  */
/*    to zero.                                  */
/*                                                                    */
#include <stdio.h>
#define BEGIN (<
#define DO    (<
#define END   >)
#define NE    !=

main (int argc, char *argv(||))

BEGIN

void netpci(unsigned short*, /* Target ID of Entire Net-Work node    */
             char*,           /* Password from NODE statement         */
             char*,           /* Function (COMMAND, CONSOLE, or LOGON)*/
             short*,          /* Length of function parameter         */
             char*,           /* Parameter for function               */
             int*,            /* CONSOLE line number                  */
             short*,          /* Length of reply buffer ( <32768 )    */
             char*,           /* Reply buffer                         */
             int*,            /* Response code                        */
             int*);           /* Reason code                          */

void neterr(int*,int*);

unsigned short target = 0;    /* Zero denotes the local Entire Net-Work node */
                              /* See programming note above.          */
char password (|9|)   = "FIVEFOUR";
char function (|9|)   = "LOGON   ";
short int  plen       = 8;
char parm (|81|)      = "DAEFNODE";
long int   lineno     = 0;
short int  rlen       = 0;
char result (|2001|);
long int  rc, reason;

char *p, *q;

/*-------------------------------------------------------------------*/
/*   Have the local Entire Net-Work forward our logon request to     */
/*   node DAEFNODE, and find out about DAEFNODE's target id.         */
/*-------------------------------------------------------------------*/
netpci(&target,password,function,&plen,parm,&lineno,&rlen,
        result,&rc,&reason);
if (rc NE 0)
   DO                      /* It didn't work, let's find out why */
      neterr(&rc,&reason) ;
      return rc;           /* ...and give up */
   END

/*-------------------------------------------------------------------*/
/*   Variable 'target' is now set to DAEFNODE's node-ID. Send it a   */
/*   HELP command to see what operator commands are available.       */
/*-------------------------------------------------------------------*/
plen = 4;                  /* length of HELP command (excluding NULL)*/
rlen = 2000;               /* usable length of our reply buffer      */

netpci(&target,password,"COMMAND ",&plen,"HELP",
        &lineno,&rlen,result,&rc,&reason);
if (rc NE 0)
   DO                      /* It didn't work, let's find out why */
      neterr(&rc,&reason) ;
      return rc;           /* ...and give up */
   END

/*-------------------------------------------------------------------*/
/*   In character string 'result' we now find the help information,  */
/*   each line followed by 0x15. Note that function 'netpci' does   */
/*   not supply a NULL at the end of the result, so if we wanted     */
/*   to use C string functions against 'result', we must set         */
/*   result(|rlen|) to NULL ourselves.                               */
/*-------------------------------------------------------------------*/
p = result;
for (q=p; p < &result(|rlen|); p=++q)
   DO
      while(*++q NE 0x15);          /* find end of a line */
      *q = NULL;                    /* terminate character string */
      printf("%s\n",p);             /* print a line */
   END
END

/*-------------------------------------------------------------------*/
/*   The error routine. Print an explanation of response code and    */
/*   reason code.                                                    */
/*-------------------------------------------------------------------*/
void neterr(int* nrc,int* nreason)
BEGIN
char *p;

switch (*nrc)
BEGIN
   case 22:                         /* command rejected */
      switch (*nreason)
      BEGIN
         case 101:
            p = "Remote commands not accepted";
            break;
         case 102:
            p = "Invalid cypher code in ACB";
            break;
         case 103:
            p = "Programmable Command Interface disabled";
            break;
         case 104:
            p = "Invalid password";
            break;
         case 105:
            p = "Invalid PCI function";
            break;
         case 106:
            p = "Invalid length of operator command";
            break;
         default:
            p = "Not an Entire Net-Work V5.7 or later node";
      END
      printf("Command rejected: %s\n",p);
      break;
   case 53:                         /* reply buffer too short */
      printf("Reply buffer length needed is %d\n",*nreason);
      break;
   default:
      printf("Response code %d, generated on Entire Net-Work node %d\n",
             *nrc,*nreason);
END
return;
END

www.softwareag.com

Copyright © 2014 Software AG, Darmstadt, Germany.

SEARCH   INDEX   CONTENTS   |   PDF PAGE   PDF BOOKS   |   HOME   UP   PREV   NEXT