home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / viscobv6.zip / vac22os2 / ibmcobol / samples / sdu / dfmacall.c < prev    next >
Text File  |  1997-03-19  |  61KB  |  1,253 lines
  1.  
  2. /**************************************************************************
  3. ****************************  DFMACALL.C  *********************************
  4. ***************************************************************************
  5. *
  6. *                         DFM DataAgent Sample
  7. *
  8. * Module Name: DFMACALL.C
  9. *   This module demonstrates the ability to invoke DFM DataAgent
  10. *   functions from C applications on workstations running SdU.
  11. *
  12. *   If modified, rename and compile it on a workstation using the header
  13. *   files distributed with SdU.
  14. *
  15. * SdU (program no. 5648-02011)
  16. *
  17. * Version: 1.0
  18. * Release: 1.0
  19. *
  20. * Copyright (C)
  21. * International Business Machines Corporation 1997
  22. *
  23. * DISCLAIMER OF WARRANTIES: The following (enclosed) code is sample code
  24. * created by the IBM Corporation.  This sample code is not a part of any
  25. * IBM product and is provided to you solely for the purpose of assisting
  26. * you in the development of your applications.  The code is provided
  27. * "AS IS", without warranty of any kind.  IBM shall not be liable for any
  28. * damages arising out of your use of the sample code, even if they have
  29. * been advised of the possibility of such damages.
  30. *
  31. * The sample program does the following:
  32. *
  33. * 1) Construct a filename and filename suffix from the input parameters.
  34. * 2) Do a DDMOpen for the file or directory to trigger MVS suffix
  35. *    processing.
  36. * 3) Do a DDMClose for the file or directory to terminate processing.
  37. * 4) Do a DDMUnLoadFileFirst and DDMUnLoadFileNext to display a server
  38. *    system file.
  39. *
  40. * COMMAND LINE INVOCATION:
  41. *
  42. *   Note:
  43. *     1. References to "driverletter" represents a driver letter that
  44. *        has been defined to be associated with a server system and optionally, 
  45. *        a logon userid of IBMUSER via the dfmdrive command. In the examples that
  46. *        follow, drive letters r: and s: have been defined by issuing the
  47. *        following dfmdrive commands.
  48. * 
  49. *        dfmdrive assign r: //MVS
  50. *
  51. *        dfmdrive assign s: IBMUSER //MVS
  52. *
  53. *        In this case, MVS is the remote server system, and IBMUSER is
  54. *        the logon userid to MVS. References to MVS and IBMUSER will be
  55. *        used in the following examples.
  56. *
  57. *     2. When the DISPLAY option is specified, the records of a server system
  58. *        file is displayed on the console. To ensure that the data to display
  59. *        is in ASCII format, a FILE_DESCRIPTOR_MAP statement for the server
  60. *        system file to display should be defined. For example, if the
  61. *        possible server system files to display are IBMUSER.DFMXTSO.SYSTSPRT
  62. *        and IBMUSER.DFMQTSO.SYSTSPRT, the following FILE_DESCRIPTOR_MAP
  63. *        statement may be created to ensure that data from these files are
  64. *        converted from EBCDIC to ASCII.
  65. *
  66. *                 FILE_DESCRIPTOR_MAP (
  67. *                      TARGET_SYSTEM (MVS)
  68. *                      TARGET_FILENAME (IBMUSER.DFM*.*)
  69. *                      BASE_DDF(base.ddf)
  70. *                      VIEW_DDF(view.ddf)
  71. *                      )
  72. *
  73. *        The last splat '*' character of the TARGET_FILENAME parameter
  74. *        ensures that the stream of data which represents a DataAgent
  75. *        request (ie. IBMUSER.DFMQTSO.SYSTSPRT,(dfmqtso,u=userID,pgm(dfmqtso),
  76. *        parm()) does not prevent DFM for Windows from converting the
  77. *        server system file data from EBCDIC to ASCII.
  78. *
  79. *        The view.adl and base.adl files are defined as follows:
  80. *
  81. *        view.adl
  82. *        ========  
  83. *            DECLARE
  84. *             BEGIN;
  85. *               ViewRec:
  86. *               SEQUENCE
  87. *                 BEGIN;
  88. *                   Localtxt: CHAR LENGTH (80) CCSID (437);
  89. *                 END;
  90. *             END;
  91. *
  92. *        base.adl
  93. *        ======== 
  94. *            DECLARE
  95. *             BEGIN;
  96. *               BaseRec:
  97. *               SEQUENCE
  98. *                 BEGIN;
  99. *                    Remotetxt: CHAR LENGTH (80) CCSID(500);
  100. *                 END;
  101. *             END;
  102. *
  103. *
  104. *     3. When issuing the TSO requests from dfmacall, data set IBMUSER.DFMXTSO.SYSTSPRT
  105. *        and IBMUSER.DFMXTSO.SYSTSIN should be predefined. Similarly, when issuing
  106. *        a QTSO request, IBMUSER.DFMQTSO.SYSTSPRT should be predefined. These
  107. *        datasets should be defined to have a logical record length of 80 to match
  108. *        the view and base adl record format descriptions examples described above. 
  109. *        Note: a record length mismatch condition between the base/view adl file
  110. *        record format description and the remote/local files may lead to a Translation
  111. *        Error (ie. XLATERM reply message).
  112. *
  113. *   This sample can be invoked in the following formats:
  114. *
  115. *  DFMACALL QTSO  driveletter:         TSOcommandline  [DISPLAY]
  116. *  DFMACALL TSO   driveletter:         [TSOcommandline]  [DISPLAY]
  117. *  DFMACALL AGENT driveletter:[filename]  MVSprocedure[,procedural_parameters]
  118. *         [PGM program_name] [PARM program-parameters] [DISPLAY]
  119. *  DFMACALL START driveletter:         MVSprocedure[,procedural_parameters]
  120. *  DFMACALL       driveletter:filename[,filename_suffix]  [DISPLAY]
  121. *
  122. * The last format is free-form in which MVS parameters can be specified
  123. * in the filename suffix.  Parameters that are relevant to DFM
  124. * DataAgent processing are the following:
  125. *   AGENT(agentname) - Specifies the name of a procedure in SYS1.PROCLIB
  126. *         that provides the JCL for agent processing and, if PGM is
  127. *         omitted, the name of the DataAgent routine (program) to run.
  128. *         Note that procedural parameters can also be specifed.  For
  129. *         example, AGENT(agentname,USER=userID,DSNAME=DS1,...).  If
  130. *         you use the free-form format, remember to specify PARM also.
  131. *   PGM(programname) - Specifies the name of the DataAgent routine.
  132. *   PARM(program_name) - Specifies input parameters to the DataAgent
  133. *                        routine.
  134. *   START(procedurename,procedure parameters) - Specifies the name of an
  135. *         MVS procedure to be started asynchronously.
  136. *   DISPLAY - Displays the result of the call to DFM DataAgent.  In the case of
  137. *         QTSO or TSO the result is the SYSTSPRT file.  In the case of other
  138. *         DataAgents it is the output name returned by the DataAgent routine
  139. *         after successful invocation.  See DFMXSORT for an example.
  140. *         (Note that DISPLAY can be used as a DataAgent name with DFMACALL
  141. *         but not as a TSO command.)
  142. *
  143. *   Examples:
  144. *
  145. *     dfmacall r:ibmuser.a.b
  146. *        ==> Opens and closes MVS file ibmuser.a.b on remote drive r.
  147. *
  148. *     dfmacall r:ibmuser.a.b,agent(dfmxagnt)
  149. *        ==> Opens and closes MVS file ibmuser.a.b invoking agent dfmxagnt.
  150. *
  151. *     dfmacall r:ibmuser.a.b,agent(dfmx0001),pgm(dfmxagnt)
  152. *        ==> Opens and closes MVS file ibmuser.a.b invoking agent dfmx0001
  153. *        ==> with program dfmxagnt.
  154. *
  155. *     dfmacall agent r:ibmuser.a.b dfmxagnt
  156. *        ==> Opens and closes MVS file ibmuser.a.b invoking agent dfmxagnt
  157. *        ==> with default program dfmxagnt and null parameters implied.
  158. *
  159. *     dfmacall agent r:ibmuser.a.b dfmxtso pgm ikjeft01
  160. *        ==> Opens and closes MVS file ibmuser.a.b invoking agent dfmxtso
  161. *        ==> with (APF-authorized) program ikjeft01.  (Equivalent to
  162. *        ==> DFMACALL TSO.)
  163. *
  164. *     dfmacall start s: dfmx0001,dfminit=iefbr14
  165. *        ==> Asynchronously starts procedure dfmx0001 with parameter
  166. *        ==> dfminit set to iefbr14.
  167. *
  168. *     dfmacall qtso   s:  listc   display
  169. *        ==> Calls TSO to list catalog entries and place the results
  170. *        ==> in IBMUSER.DFMQTSO.SYSTSPRT.  No SYSTSIN input file is
  171. *        ==> expected.  The SYSTSPRT file is displayed.
  172. *
  173. *     dfmacall tso   s:
  174. *        ==> Calls TSO to process input file IBMUSER.DFMXTSO.SYSTSIN
  175. *        ==> and put the results in IBMUSER.DFMXTSO.SYSTSPRT.
  176. *
  177. *     dfmacall tso   s:    "profile prefix(ibmuser)"  display
  178. *        ==> After running the command passed it (in this case "profile")
  179. *        ==> it calls TSO to process input file IBMUSER.DFMXTSO.SYSTSIN
  180. *        ==> and put the results in IBMUSER.DFMXTSO.SYSTSPRT. Display the
  181. *        ==> output file.
  182. *
  183. *
  184. * Change Summary:
  185. *  $L0,960724,SJPLMMR: Initial code for SdU support of DFM/MVS DataAgent
  186. *  $P1,970303,SJPLWBN: Increase buffer parameter size from 100 to 255
  187. *                      (PARMLEN).
  188. *  $P2,970314,SJPLTML: DataAgent request is nolonger suppressed when the
  189. *                      DISPLAY option is specified.
  190. *  $P3=970319,SJPLTML: Add missing RM table entries.
  191. *
  192. ***************************************************************************/
  193.  
  194.  
  195. #include  <os2.h>                       /* required for RLIO applications */
  196. #include  <stdio.h>
  197. #include  <string.h>
  198. #include  <memory.h>
  199. #include  <malloc.h>
  200. #include  "dub.h"        /* required master include for RLIO applications */
  201.  
  202. /*-------------------------------------------------------------------------
  203. --                       SYMBOLIC CONSTANTS
  204. --------------------------------------------------------------------------*/
  205. #define FILCLS_SIZE sizeof(OBJLENGTH) + (2 * sizeof(CODEPOINT))
  206. #define FILCLS_NAME ".DDM_FILCLS"
  207. #define RECDATALEN  100
  208. #define RPYMSBFLN   546                    /* reply message buffer length   */
  209. #define PATHLEN     300                    /* path with 45 extra bytes      */
  210. #define PARMLEN     255                    /* arbitrary maximum parm len@P1C*/
  211. #define USPARMLEN   255                    /* arbitrary max user parm len   */
  212. #define MINPQTSO    4                      /* minimum parameters for QTSO   */
  213. #define MAXPQTSO    5                      /* maximum parameters for QTSO   */
  214. #define MINPTSO     3                      /* minimum parameters for TSO    */
  215. #define MAXPTSO     5                      /* maximum parameters for TSO    */
  216. #define MINPAGENT   4                      /* minimum parameters for AGENT  */
  217. #define MAXPAGENT   9                      /* maximum parameters for AGENT  */
  218. #define MINPSTART   4                      /* minimum parameters for START  */
  219. #define MAXPSTART   4                      /* maximum parameters for START  */
  220. #define MINPFF      2                      /* minimum parameters for FF     */
  221. #define MAXPFF      3                      /* maximum parameters for FF     */
  222.  
  223. /*-------------------------------------------------------------------------
  224. --                     LOCAL FUNCTION DECLARATIONS
  225. --------------------------------------------------------------------------*/
  226. int  SpecialOptions(int index, int argc, char* argv[]);
  227. int  CheckRange(int min, int max, int argc, char uarg[PARMLEN]);
  228. VOID DumpBuffer(PDDMOBJECT pAttribute, USHORT Count);
  229. CODEPOINT  ReplyMsg(VOID);
  230. VOID OmitError(VOID);
  231. VOID GeneralError(VOID);
  232. VOID ValueError(char *value);
  233. VOID ParmLenError(char *value);
  234. int  strupper(char *out, char *in, int bufflen);
  235. VOID DisplayBuffer(ULONG count, PDDMRECORD pRcdarea);
  236. VOID DuplicateError(VOID);
  237. VOID HasFileNameError(VOID);
  238. VOID NoFileNameError(VOID);
  239. VOID TooManyError(VOID);
  240. VOID NotEnoughError(VOID);
  241. VOID DisplayHelp(char *helpflag);
  242.  
  243.  
  244. /*-------------------------------------------------------------------------
  245. --                             DFMACALL
  246. --------------------------------------------------------------------------*/
  247.  
  248.     int dummy_filename = 0;      /* Dummy filename flag               */
  249.     int display_filename = 0;    /* Display filename flag             */
  250.     int TSO_retry = 0;           /* TSO error retry flag              */
  251.     int debug = 1;               /* Debug flag: 0 = nothing displayed,*/
  252.                                  /* 1 = filename display, 2 = all of  */
  253.                                  /* the above plus major functions,   */
  254.                                  /* 5 = all the above plus data.      */
  255.     int display_counter = 0;     /* Record display counter            */
  256.     int intrc;                   /* internal return code              */
  257.  
  258.  
  259. main(int argc, char* argv[])
  260. {
  261.     int i;                       /* Loop counter                      */
  262.     int fnlen = 0;               /* Filename length                   */
  263.     int pgmcnt = 0;              /* Number of PGM parm occurrences    */
  264.     int parmcnt = 0;             /* Number of PARM parm occurrences   */
  265.     int data_follows;            /* Data follows in next arg          */
  266.     APIRET SevCode;              /* Severity code (see DUBDEFS.H)     */
  267.     CODEPOINT  LCodePoint;       /* Local Code Point for reply msg    */
  268.  
  269.  
  270.     PDDMRECORD pRecord;
  271.     RECLENGTH  RecordSize;
  272.     PDDMRECAL  pRecAL;
  273.     PDDMRECALK pRecALK;
  274.     RECLENGTH  RecALSize;
  275.     PBYTE      pData;
  276.     HDDMLOAD   UnLoad;            /* File handle for unload           */
  277.     ULONG      RecCount;
  278.     ULONG      DDMMoreDataFlag;
  279.     int        minparms;          /* minimum parameters current cmd   */
  280.     int        maxparms;          /* maximum parameters current cmd   */
  281.  
  282.  
  283.     HDDMFILE FileHandle;
  284.  
  285.  
  286.     /* Filename to be operated on                                     */
  287.     CHAR MVSFilename[PATHLEN];
  288.     CHAR RootName[PATHLEN];        /* Root name for TSO retry         */
  289.     CHAR dummy_name[9] = "NULLFILE";
  290.     CHAR display_name[PATHLEN];
  291.  
  292.     CHAR uarg[PARMLEN];            /* Upper case argument             */
  293.     CHAR usparg[USPARMLEN];        /* Upper case subparameter         */
  294.  
  295.     /******************************************************************/
  296.     /* Determine which command format was used and build the MVS      */
  297.     /* filename and filename suffix accordingly.                      */
  298.     /******************************************************************/
  299.  
  300.  
  301.     RootName[0] = 0;               /* Set TSO root name to null string*/
  302.     switch (argc)
  303.     {  case 1: /* no user arguments */
  304.           NotEnoughError();
  305.           DisplayHelp("N");
  306.           return(SC_SEVERE);
  307.        default:
  308.          /*************************************************************/
  309.          /* 1 or more user arguments--check further                   */
  310.          /*************************************************************/
  311.          /* Convert current user argument to upper case.              */
  312.          if (intrc = strupper(uarg, argv[1], PATHLEN))
  313.            return intrc;
  314.  
  315.  
  316.          if (strcmp(uarg,"QTSO") == 0 |
  317.              strcmp(uarg,"TSO") == 0 ) {
  318.              if (strcmp(uarg,"QTSO") == 0) {
  319.                 /******************************************************/
  320.                 /* QTSO format                                        */
  321.                 /******************************************************/
  322.                 minparms = MINPQTSO;
  323.                 maxparms = MAXPQTSO;
  324.               }
  325.               else {
  326.                 /******************************************************/
  327.                 /* TSO format                                         */
  328.                 /******************************************************/
  329.                 minparms = MINPTSO;
  330.                 maxparms = MAXPTSO;
  331.               }
  332.               if (intrc = CheckRange(minparms,maxparms,argc, uarg) > 0)
  333.                 return(intrc);
  334.  
  335.               /********************************************************/
  336.               /* Set special processing flags                         */
  337.               /********************************************************/
  338.               for (i=minparms; i < argc; i++) {
  339.                     if (intrc = SpecialOptions(i, argc, argv) > 0)
  340.                   return(intrc);
  341.               }
  342.  
  343.               /********************************************************/
  344.               /* Build filename in the format of                      */
  345.               /*  x:fn,agent(dfmqtso,u=userID),pgm(dfmqtso),          */
  346.               /*         parm(...)                                    */
  347.               /*                  -- OR --                            */
  348.               /*  x:fn,agent(dfmxtso,u=userID),pgm(ikjeft01),         */
  349.               /*         parm(...)                                    */
  350.               /* (Note that MVS will append u=userid)                 */
  351.               /********************************************************/
  352.               if (intrc = strupper(MVSFilename,argv[2],PATHLEN))
  353.                 return(intrc);
  354.               fnlen = strlen(MVSFilename);  /* Save true filename len */
  355.               if ( fnlen > 2 | strncmp(&MVSFilename[1],":",1) != 0  ) {
  356.                  HasFileNameError();
  357.                  DisplayHelp(&uarg[0]);
  358.                  return(SC_SEVERE);
  359.               }
  360.               /********************************************************/
  361.               /* Build root filename.                                 */
  362.               /********************************************************/
  363.               if (display_filename) {
  364.                 if (strcmp(uarg,"QTSO") == 0)
  365.                   strcat(MVSFilename,"DFMQTSO.SYSTSPRT");
  366.                 else
  367.                   strcat(MVSFilename,"DFMXTSO.SYSTSPRT");
  368.                 strcpy(RootName,MVSFilename);
  369.               } else {
  370.                 dummy_filename = 1;
  371.                 strcat(MVSFilename,dummy_name);
  372.               } /* endif */
  373.  
  374.               /********************************************************/
  375.               /* Attach filename suffix.                              */
  376.               /********************************************************/
  377.               if (strcmp(uarg,"QTSO") == 0)
  378.                 strcat(MVSFilename,",agent(dfmqtso),parm(");
  379.               else
  380.                 strcat(MVSFilename,",agent(dfmxtso),pgm(ikjeft01),parm(");
  381.  
  382.               /********************************************************/
  383.               /* Concatenate parm field                               */
  384.               /********************************************************/
  385.               if (argc >= 4 ) {
  386.                 if (intrc = strupper(usparg, argv[3], USPARMLEN))
  387.                   return (intrc);
  388.                 if (strcmp(usparg,"DISPLAY") != 0)
  389.                   strcat(MVSFilename,argv[3]);
  390.                 else if (strcmp(uarg,"QTSO") == 0) {
  391.                   /* DFMQTSO requires a parameter field               */
  392.                   OmitError();
  393.                   DisplayHelp(&uarg[0]);
  394.                   return(SC_SEVERE);
  395.                 }
  396.               }
  397.               strcat(MVSFilename,")");   /* Terminate parameter field */
  398.  
  399.          }                                /* End of QTSO/TSO case     */
  400.           else if (strcmp(uarg,"AGENT") == 0) {
  401.               /********************************************************/
  402.               /* AGENT format                                         */
  403.               /********************************************************/
  404.               minparms = MINPAGENT;
  405.               maxparms = MAXPAGENT;
  406.               if (intrc = CheckRange(minparms,maxparms,argc, uarg) > 0)
  407.                 return(intrc);
  408.  
  409.               /********************************************************/
  410.               /* Set special processing flags                         */
  411.               /********************************************************/
  412.               for (i=minparms; i < argc; i++) {
  413.                     if (intrc = SpecialOptions(i, argc, argv) > 0)
  414.                   return(intrc);
  415.               }
  416.  
  417.               /********************************************************/
  418.               /* Build filename in the format of                      */
  419.               /*  x:fn,agent(agentname),pgm(program_name),parm(parms) */
  420.               /********************************************************/
  421.               if (intrc = strupper(MVSFilename,argv[2], PATHLEN))
  422.                 return(intrc);
  423.               fnlen = strlen(MVSFilename);  /* Save true filename len */
  424.               /* Add dummy filename if one wasn't specified           */
  425.               if ( fnlen == 2  & strncmp(&MVSFilename[1],":",1) == 0  ) {
  426.                 dummy_filename = 1;
  427.                 strcat(MVSFilename,dummy_name);
  428.               }
  429.  
  430.               /* Check the filename format for obvious errors.        */
  431.               fnlen = strlen(MVSFilename);  /* Save true filename len */
  432.               if (fnlen < 3 ) {
  433.                 NoFileNameError();
  434.                 DisplayHelp(&uarg[0]);
  435.                 return(SC_SEVERE);
  436.                }
  437.  
  438.               strcat(MVSFilename,",agent(");
  439.               strcat(MVSFilename,argv[3]);
  440.               strcat(MVSFilename,")");
  441.               /********************************************************/
  442.               /* Concatenate optional fields                          */
  443.               /********************************************************/
  444.               if (argc > 4) {
  445.                 /******************************************************/
  446.                 /* Optional parameters are present                    */
  447.                 /******************************************************/
  448.  
  449.                 /******************************************************/
  450.                 /* All but DISPLAY are in format of keyword + value.  */
  451.                 /******************************************************/
  452.                 data_follows = 0;
  453.                 for (i=4; i < argc; i++) {
  454.                   if (!data_follows) {
  455.                     /* Not data object -- process the keyword.        */
  456.                     data_follows = 1;
  457.                     if (intrc = strupper(usparg, argv[i], USPARMLEN))
  458.                       return (intrc);
  459.                     if (strcmp(usparg,"PGM") == 0) {
  460.                          pgmcnt++;
  461.                          strcat(MVSFilename,",pgm(");
  462.                     }
  463.                     else if (strcmp(usparg,"PARM") == 0) {
  464.                          parmcnt++;
  465.                          strcat(MVSFilename,",parm(");
  466.                     }
  467.                     else {                    /* Unidentified keyword?*/
  468.                       /* Make sure it's not a display option          */
  469.                        if (strcmp(usparg,"DISPLAY") != 0 ) {
  470.                          GeneralError();
  471.                          DisplayHelp(&uarg[0]);
  472.                          return(SC_SEVERE);
  473.                        }
  474.                        else
  475.                          data_follows = 0;    /* No following data    */
  476.                     }                         /* End, unidentified kwd*/
  477.                   }                           /* End, even number     */
  478.                   else  {
  479.                     /* Process the keyword's data.                    */
  480.                     data_follows = 0;
  481.                     strcat(MVSFilename,argv[i]);
  482.                     strcat(MVSFilename,")");
  483.                   }                           /* End, data field      */
  484.                 }    /* End of for loop                               */
  485.               }
  486.               /********************************************************/
  487.               /* Ensure no duplicate parameters                       */
  488.               /********************************************************/
  489.               if ( pgmcnt > 1 | parmcnt > 1 ) {
  490.                 DuplicateError();
  491.                 DisplayHelp(&uarg[0]);
  492.                 return(SC_SEVERE);
  493.               }
  494.               /********************************************************/
  495.               /* Ensure AGENT is invoked with a PARM                  */
  496.               /********************************************************/
  497.               if (parmcnt == 0)
  498.                 strcat(MVSFilename,",parm()");
  499.          }                               /* End of AGENT              */
  500.  
  501.          else if (strcmp(uarg,"START") == 0) {
  502.               /********************************************************/
  503.               /* START format                                         */
  504.               /********************************************************/
  505.               minparms = MINPSTART;
  506.               maxparms = MAXPSTART;
  507.               if (intrc = CheckRange(minparms,maxparms,argc, uarg) > 0)
  508.                 return(intrc);
  509.  
  510.               /********************************************************/
  511.               /* Build filename in the format of                      */
  512.               /*     x:fn,start(proc,parms)                           */
  513.               /********************************************************/
  514.               if (intrc = strupper(MVSFilename,argv[2],PATHLEN))
  515.                 return(intrc);
  516.               fnlen = strlen(MVSFilename);
  517.               if ( (fnlen > 2) | (strncmp(&MVSFilename[1],":",1) != 0)  ) {
  518.                 HasFileNameError();
  519.                 DisplayHelp(&uarg[0]);
  520.                 return(SC_SEVERE);
  521.                }
  522.               dummy_filename = 1;
  523.               strcat(MVSFilename,dummy_name);
  524.               strcat(MVSFilename,",start(");
  525.               strcat(MVSFilename,argv[3]);
  526.               strcat(MVSFilename,")");
  527.          }                           /* End of START parameter        */
  528.          else {                      /* None of the above             */
  529.               /********************************************************/
  530.               /* Free-form command otherwise                          */
  531.               /********************************************************/
  532.               /********************************************************/
  533.               /* Check for help request.                              */
  534.               /********************************************************/
  535.               if (strncmp(uarg, "?",1) == 0) {
  536.                 DisplayHelp(&uarg[0]);
  537.                 return(SC_WARNING);
  538.                }
  539.  
  540.               minparms = MINPFF;
  541.               maxparms = MAXPFF;
  542.               if (intrc = CheckRange(minparms,maxparms,argc, uarg) > 0)
  543.                 return(intrc);
  544.               /********************************************************/
  545.               /* Set special processing flags                         */
  546.               /********************************************************/
  547.               for (i=minparms; i < argc; i++) {
  548.                     if (intrc = SpecialOptions(i, argc, argv) > 0)
  549.                   return(intrc);
  550.               }
  551.  
  552.  
  553.               if (intrc = strupper(MVSFilename,argv[1], PATHLEN))
  554.                 return(intrc);
  555.               fnlen = strlen(MVSFilename);  /* Save true filename len */
  556.               if (fnlen < 3) {
  557.                 NoFileNameError();
  558.                 DisplayHelp(&uarg[0]);
  559.                 return(SC_SEVERE);
  560.                }
  561.  
  562.          }                           /* End of free form parameters   */
  563.     }
  564.  
  565.     /******************************************************************/
  566.     /* Begin processing the MVS file                              @P2M*/
  567.     /******************************************************************/
  568.  
  569.     if (debug >= 1)  printf
  570.       ("DFMACALL: Processing filename and filename suffix of %s.\n",
  571.                  MVSFilename);
  572.  
  573.     /****************************************************************/
  574.     /* Open the file                                            @P2M*/
  575.     /****************************************************************/
  576.     SevCode = DDMOpen
  577.             (MVSFilename,                     /* FileName       @P2M*/
  578.              &FileHandle,                     /* FileHandle     @P2M*/
  579.              RELRNBAM,                        /* AccessMethod   @P2M*/
  580.              DDM_GETAI,                       /* AccIntList     @P2M*/
  581.              DDM_UPDATERS,                    /* FileShare      @P2M*/
  582.              NULL,                            /* EABuf          @P2M*/
  583.              NULL                             /* reserved       @P2M*/
  584.             );                                               /* @P2M*/
  585.  
  586.     if (SevCode != SC_NO_ERROR)                              /* @P2M*/
  587.     {                                                        /* @P2M*/
  588.        if (dummy_filename == 0)                              /* @P2M*/
  589.        {                                                     /* @P2M*/
  590.        printf("Error opening file %s\n",MVSFilename);        /* @P2M*/
  591.        printf("Severity code = %u\n",SevCode);               /* @P2M*/
  592.        }                                                     /* @P2M*/
  593.        ReplyMsg();                                           /* @P2M*/
  594.        return(SevCode);                                      /* @P2M*/
  595.  
  596.     }                                                        /* @P2M*/
  597.  
  598.  
  599.     /****************************************************************/
  600.     /* Close the file                                           @P2M*/
  601.     /****************************************************************/
  602.     SevCode = DDMClose                                       /* @P2M*/
  603.             (FileHandle                         /* FileHandle   @P2M*/
  604.             );                                               /* @P2M*/
  605.  
  606.     if (SevCode != SC_NO_ERROR)                              /* @P2M*/
  607.     {                                                        /* @P2M*/
  608.        if (dummy_filename == 0)                              /* @P2M*/
  609.        {                                                     /* @P2M*/
  610.        printf("Error closing file %s\n",MVSFilename);        /* @P2M*/
  611.        printf("Severity code = %u\n",SevCode);               /* @P2M*/
  612.        }                                                     /* @P2M*/
  613.        ReplyMsg();                                           /* @P2M*/
  614.        return(SevCode);                                      /* @P2M*/
  615.     }                                                        /* @P2M*/
  616.  
  617.  
  618.     if (display_filename) {
  619.       /****************************************************************/
  620.       /* Perform unload of records to satisfy display request         */
  621.       /****************************************************************/
  622.  
  623.       /****************************************************************/
  624.       /* Allocate a record buffer                                     */
  625.       /****************************************************************/
  626.       RecALSize = 64000;        /* Try to use a 64K Buffer for records*/
  627.       if ((pRecord = (PDDMRECORD)malloc(RecALSize)) == NULL) {
  628.          /* Not enough storage--make one last try for 32K             */
  629.          RecALSize = RecALSize / 2;                /* Try 32K Buffer  */
  630.          if ((pRecord = (PDDMRECORD)malloc(RecALSize)) == NULL) {
  631.            printf("DFMACALL: Out of memory\n");
  632.            return(SC_SEVERE);
  633.          }
  634.       }
  635.       /****************************************************************/
  636.       /* Unload the first batch of records in rcd number order        */
  637.       /****************************************************************/
  638.       SevCode = 1;
  639.       while (SevCode) {
  640.         SevCode = DDMUnLoadFileFirst
  641.                (MVSFilename,                /* FileName               */
  642.                 &UnLoad,                    /* UnLoadHandle           */
  643.                 0UL,                        /* AccessFlags            */
  644.                 &DDMMoreDataFlag,           /* Flags                  */
  645.                 pRecord,                    /* RecordBuf              */
  646.                 RecALSize,                  /* RecordBufLen           */
  647.                 (CODEPOINT) RECSEQ,         /* UnloadOrder=rcd number */
  648.                 &RecCount                   /* RecCount               */
  649.                );
  650.         if (SevCode > SC_WARNING) {
  651.            printf("DFMACALL: Error on DDMUnLoadFileFirst for %s.\n",
  652.                     MVSFilename);
  653.            printf("Severity code = %u\n",SevCode);
  654.            LCodePoint = ReplyMsg();
  655.            /* Retry TSO unload output file if not tried already.      */
  656.            if (strcmp(MVSFilename,RootName) != 0  &
  657.                LCodePoint == VALNSPRM ) {
  658.              TSO_retry = 1;
  659.              strcpy(MVSFilename,RootName);
  660.            }                                /* End, TSO retry         */
  661.            else {                           /* Permanent error        */
  662.              free(pRecord);
  663.              return(SevCode);
  664.            }                                /* End, permanent error   */
  665.         }     /* End of error from unload file first.                 */
  666.       }       /* End of while no error.                               */
  667.  
  668.       if (SevCode > SC_WARNING) {
  669.         free(pRecord);
  670.         return(SevCode);
  671.       }                                      /* End, unload first err */
  672.  
  673.       if (debug >= 2 )
  674.          printf ("DDMUnLoadFileFirst: %d records in buffer.\n",
  675.                   RecCount);
  676.       if (TSO_retry > 0 ) {
  677.          printf ("\n** The TSO Output File associated with the error is\
  678.  as follows: **\n");
  679.          printf ("**    (Note that its contents may be from a previou\
  680. s run.)      **\n");
  681.       }
  682.  
  683.       DisplayBuffer(RecCount,pRecord);
  684.  
  685.       /****************************************************************/
  686.       /* Unload remaining records in record number order.             */
  687.       /* When DDMMoreDataFlag is 0x00UL then the file handle is       */
  688.       /* invalid and the file will be closed.                         */
  689.       /****************************************************************/
  690.       while (DDMMoreDataFlag == 0x01UL)
  691.         {
  692.            SevCode = DDMUnLoadFileNext
  693.               (UnLoad,                          /* UnLoadHandle       */
  694.                0x0000UL,                        /* Flags              */
  695.                &DDMMoreDataFlag,                /* UnloadFlags        */
  696.                pRecord,                         /* RecordBuf          */
  697.                RecALSize,                       /* RecordBufLen       */
  698.                &RecCount                        /* RecCount           */
  699.               );
  700.           if (SevCode > SC_WARNING) {
  701.              printf("DFMACALL: Error on DDMUnLoadFileNext for %s.\n",
  702.                       MVSFilename);
  703.              printf("Severity code = %u\n",SevCode);
  704.              ReplyMsg();
  705.              free(pRecord);
  706.              return(SevCode);
  707.           }
  708.           if (debug >= 2)
  709.             printf ("DDMUnLoadFileNext: %d records in buffer.\n",
  710.               RecCount);
  711.           DisplayBuffer(RecCount,pRecord);
  712.  
  713.       }                                         /* End of WHILE loop  */
  714.    free(pRecord);
  715.  
  716.     } else {
  717.       /****************************************************************/
  718.       /* No display--just open to trigger DataAgent and then close    */
  719.       /****************************************************************/
  720.  
  721.  
  722.     }
  723.  
  724.  
  725.     return(SC_NO_ERROR);
  726.  
  727. } /* End--sample main */
  728.  
  729.  
  730. /**************************************************************************
  731. ****************************  ReplyMsg  ***********************************
  732. ***************************************************************************
  733. *   Process the reply message if there is a Severity Code other than
  734. *   SC_NO_ERROR;
  735. *
  736. ***************************************************************************/
  737. CODEPOINT   ReplyMsg(VOID)
  738. {
  739.     static BYTE pRpyMsgBuf[RPYMSBFLN];
  740.  
  741.     APIRET     rc;
  742.     CODEPOINT  CodePoint;
  743.     PDDMOBJECT pReplyObject;
  744.     USHORT     index;
  745.  
  746.     /*---------------------------------------------------------------------
  747.     --  The following table contains the count for the number of parameters
  748.     --  expected for each reply message (1st column), and it also contains
  749.     --  the expanded error messages
  750.     --
  751.     -- The first message in the table, KEYUDIRM, has the lowest
  752.     -- code point value.  It is also the first message in a block of
  753.     -- message code points that ends with RECNAVRM.
  754.     --
  755.     -- The next block of message code points (in ascending code point order)
  756.     -- begins with OS2ERRRM and ends with FILERRRM.
  757.     -- The low-order byte is used as the index into this block.
  758.     ----------------------------------------------------------------------*/
  759.     static struct
  760.     {  USHORT   Count;
  761.        BYTE     msg[52];
  762.     } ErrorMsgBuffer[] =
  763.       { 6, "Key Update Not Allowed by Different Index         \0",
  764.         0, "                                                  \0",
  765.         3, "System Command Reply Message                      \0",   /* SYSCMDRM */ /*@P3C*/
  766.         0, "Default Record Error                              \0",
  767.         5, "Cursor Not Selecting a Record Position            \0",
  768.         7, "Invalid Data Record                               \0",
  769.         3, "Duplicate File Name                               \0",
  770.         8, "Duplicate Key Different Index                     \0",
  771.         7, "Duplicate Key Same Index                          \0",
  772.         7, "Duplicate Record Number                           \0",
  773.         3, "End of File                                       \0",
  774.         7, "File is Full                                      \0",
  775.         4, "File in Use                                       \0",
  776.         3, "File Not Found                                    \0",
  777.         6, "File Space Not Available                          \0",
  778.         3, "Manager Level Conflict                            \0",   /* MGRLVLRM */ /*@P3C*/
  779.         4, "File Not Opened                                   \0",   /* FILNOPRM */ /*@P3C*/
  780.         3, "Invalid File Name                                 \0",
  781.         0, "                                                  \0",
  782.         3, "Shadow Exists                                     \0",   /* SHDEXSRM */ /*@P3C*/
  783.         7, "Record Length Mismatch                            \0",
  784.         3, "Storage Class Not Found                           \0",   /* STGNFNRM */ /*@P3C*/
  785.         3, "Management Class Not Found                        \0",   /* MGMNFNRM */ /*@P3C*/
  786.         4, "Manager Dependency Error                          \0",   /* MGRDEPRM */ /*@P3C*/
  787.         0, "                                                  \0",
  788.         3, "Not Authorized to Storage Class                   \0",   /* STGATHRM */ /*@P3C*/
  789.         3, "Not Authorized to Management Class                \0",   /* MGMATHRM */ /*@P3C*/
  790.         2, "Not Authorized to Function                        \0",
  791.         4, "File Open Lock Option Changed                     \0",   /* FILOLORM */ /*@P3C*/
  792.         4, "File Temporarily Not Available                    \0",
  793.         0, "                                                  \0",
  794.         2, "Declare Conflict                                  \0",   /* DCLCNFRM */ /*@P3C*/
  795.         3, "Directory is Temporarily Not Available            \0",   /* DRCTNARM */ /*@P3C*/
  796.         0, "                                                  \0",
  797.         0, "                                                  \0",
  798.         7, "Record Number Out of Bounds                       \0",
  799.         5, "Record Not Found                                  \0",
  800.         0, "                                                  \0",
  801.         0, "                                                  \0",
  802.         0, "                                                  \0",
  803.         0, "                                                  \0",
  804.         0, "                                                  \0",
  805.         0, "                                                  \0",
  806.         3, "Data Class Not Found                              \0",   /* DTANFNRM */ /*@P3C*/
  807.         3, "Invalid Key Length                                \0",
  808.         0, "                                                  \0",
  809.         0, "                                                  \0",
  810.         3, "Not Authorized to Access Method                   \0",
  811.         0, "Invalid Access Method                             \0",
  812.         3, "Permanent Agent Error                             \0",
  813.         6, "Resource Limits Reached on Target System          \0",
  814.         3, "Invalid Base File Name                            \0",
  815.         0, "                                                  \0",
  816.         0, "                                                  \0",
  817.         2, "Not Authorized to Directory                       \0",
  818.         0, "Management Class Conflict                         \0",
  819.         0, "Storage Class Conflict                            \0",
  820.         3, "Existing Condition                                \0",
  821.         4, "Not Authorized to File                            \0",
  822.         6, "Invalid Request                                   \0",
  823.         4, "Invalid Key Definition                            \0",
  824.         0, "                                                  \0",
  825.         5, "Key Update Not Allowed by Same Index              \0",
  826.         8, "Invalid Key Value                                 \0",
  827.         3, "Invalid User                                      \0",   /* INVUSRRM */ /*@P3C*/
  828.         3, "Open Conflict Error                               \0",   /* OPNCNFRM */ /*@P3C*/
  829.         3, "Open Exclusive by Same User                       \0",
  830.         4, "Concurrent Open Exceeds Maximum                   \0",
  831.         4, "Conversational Protocol Error                     \0",
  832.         0, "                                                  \0",
  833.         0, "                                                  \0",
  834.         0, "                                                  \0",
  835.         7, "Record Damaged                                    \0",
  836.         7, "Record in Use                                     \0",
  837.         2, "Command Processing Completed                      \0",   /* CMDCMPRM */ /*@P3C*/
  838.         5, "Data Stream Syntax Error                          \0",
  839.         7, "Update Cursor Error                               \0",
  840.         5, "No Update Intent on Record                        \0",
  841.         3, "Invalid New File Name                             \0",
  842.         3, "Function Not Supported                            \0",
  843.         3, "Parameter Not Supported                           \0",
  844.         4, "Parameter Value Not Supported                     \0",
  845.         4, "Object Not Supported                              \0",
  846.         5, "Command Check                                     \0",
  847.         2, "Duplicate Declared Name                           \0",   /* DUPDCLRM */ /*@P3C*/
  848.         2, "Invalid Declared Name                             \0",   /* DCLNAMRM */ /*@P3C*/
  849.         2, "File Handle Not Found                             \0",
  850.         3, "Directory Full                                    \0",
  851.         3, "Record Inactive                                   \0",
  852.         7, "File Damaged                                      \0",
  853.         4, "Load Records Count Mismatch                       \0",
  854.         3, "Not Authorized to Open Intent for Named File      \0",
  855.         5, "User Attribute Error                              \0",   /* USRATTRM */ /*@P3C*/
  856.         3, "File Closed with Damage                           \0",
  857.         2, "Target Not Supported                              \0",
  858.         5, "Key Value Modified after Cursor was Last Set      \0",
  859.         4, "Change File Attributes Rejected                   \0",   /* CHGFATRM */ /*@P3C*/
  860.         3, "Invalid Directory Name                            \0",   /* DRCNAMRM */ /*@P3C*/
  861.         3, "Directory Not Found                               \0",   /* DRCNFNRM */ /*@P3C*/
  862.         5, "Stream In Use Error                               \0",   /* STRIUSRM */ /*@P3C*/
  863.         7, "Invalid Substream                                 \0",   /* SUBSTRRM */ /*@P3C*/
  864.         0, "Access Intent List Error                          \0",
  865.         3, "Directory In Use                                  \0",   /* DRCIUSRM */ /*@P3C*/
  866.         7, "Stream Damaged                                    \0",   /* STRDMGRM */ /*@P3C*/
  867.         3, "Invalid Directory Entry                           \0",   /* DRCENTRM */ /*@P3C*/
  868.         3, "Duplicate Directory Name                          \0",   /* DUPDRCRM */ /*@P3C*/
  869.         3, "Directory Space Not Available                     \0",   /* DRCSNARM */ /*@P3C*/
  870.         7, "Data Mapping Error                                \0",   /* DTAMAPRM */ /*@P3C*/
  871.         0, "                                                  \0",
  872.         4, "Load Stream Count Mismatch                        \0",   /* LODSTRRM */ /*@P3C*/
  873.         5, "Record Not Available                              \0",
  874.  
  875.      /************ START OF SECOND CODE POINT RANGE *************/
  876.         0, "OS/2 Error                                        \0",
  877.         0, "Data Description File Not Found                   \0",
  878.         0, "Conversion Table Not Found                        \0",
  879.         2, "Translation Error                                 \0",
  880.         0, "                                                  \0",
  881.         2, "Invalid Flag                                      \0",
  882.         0, "                                                  \0",
  883.         2, "Communications Error                              \0",
  884.         0, "                                                  \0",
  885.         0, "                                                  \0",
  886.         0, "                                                  \0",
  887.         0, "                                                  \0",
  888.         0, "                                                  \0",
  889.         0, "                                                  \0",
  890.         0, "                                                  \0",
  891.         0, "                                                  \0",
  892.         2, "Resource Limit Reached in OS/2 V2.0 Source System \0",
  893.         2, "Field Length Error                                \0",
  894.         2, "Address Error                                     \0",
  895.         0, "                                                  \0",
  896.         2, "Function Continuation Error                       \0",
  897.         0, "                                                  \0",
  898.         2, "File Error                                        \0"
  899.       };
  900.  
  901.     /*---------------------------------------------------------------------
  902.     -- For each reply message available, retrieve and display it.
  903.     ----------------------------------------------------------------------*/
  904.     do
  905.     {  /*------------------------------------------------------------------
  906.        -- Get the reply message
  907.        -------------------------------------------------------------------*/
  908.        rc = DDMGetReplyMessage(pRpyMsgBuf, (ULONG)RPYMSBFLN, (ULONG)1);
  909.  
  910.        switch (rc)
  911.        {  case SC_NO_ERROR:      /* All reply messages have been received */
  912.           case SC_WARNING: /* There are more reply messages to be received*/
  913.              break;
  914.           case SC_ERROR:
  915.              printf("   ReplyMsg: reply message buffer is too small -\n");
  916.              printf("              enlarge and recompile ...\n");
  917.              return(rc);
  918.              break;
  919.           case SC_SEVERE:
  920.              printf("   ReplyMsg: Warning: A reply message was requested,\n");
  921.              printf("              but there are none available ...\n");
  922.              return(rc);
  923.              break;
  924.           case SC_ACCESSDAMAGE:
  925.              printf("   ReplyMsg: Error: An invalid reply message buffer\n");
  926.              printf("              address was specified ...\n");
  927.              return(rc);
  928.              break;
  929.           case SC_PERMDAMAGE:
  930.              printf("   ReplyMsg: Severe Error: An unarchitected reply message\n");
  931.              printf("              object was encountered ...\n");
  932.              return(rc);
  933.              break;
  934.           default:
  935.              printf("   ReplyMsg: Unknown return code from DDMGetReplyMessage\n");
  936.              return(rc);
  937.              break;
  938.        } /* endswitch */
  939.  
  940.        /*------------------------------------------------------------------
  941.        -- Get the reply message
  942.        -------------------------------------------------------------------*/
  943.        pReplyObject = (PDDMOBJECT)pRpyMsgBuf;
  944.  
  945.        CodePoint = pReplyObject->cpObject;              /* get code point */
  946.  
  947.  
  948.        /* reset pointer to first parm base */
  949.        pReplyObject = (PDDMOBJECT)((PBYTE)pReplyObject
  950.                                    + (sizeof(CODEPOINT)
  951.                                       + sizeof(OBJLENGTH))
  952.                                   );
  953.  
  954.        /*------------------------------------------------------------------
  955.        -- Calculate the index into the parameter/msg table based on
  956.        -- the codepoint.
  957.        -------------------------------------------------------------------*/
  958.        if (CodePoint <= RECNAVRM)         /* if code point in first block */
  959.           index = (USHORT)(CodePoint - KEYUDIRM);
  960.        else                               /* code point in second block */
  961.           index = (USHORT)
  962.                   ((RECNAVRM - KEYUDIRM + 1) /* number of entries in
  963.                                                 first block */
  964.                    + (CodePoint % 0x0100UL) /* index into second block */
  965.                   );
  966.  
  967.        /* If the index indicates "file not found" and a dummy filename    */
  968.        /* is being used, ignore the error.                                */
  969.        if (index == 13 & dummy_filename == 1 )
  970.          return(SC_NO_ERROR);
  971.  
  972.        /*------------------------------------------------------------------
  973.        -- Begin dissecting the reply message buffer
  974.        -------------------------------------------------------------------*/
  975.        if (ErrorMsgBuffer[index].Count > 0)
  976.        {  printf("RPYMSG: %s\n",ErrorMsgBuffer[index].msg);
  977.           DumpBuffer(pReplyObject, ErrorMsgBuffer[index].Count);
  978.           printf("\n");
  979.        }
  980.  
  981.     } while (rc == SC_WARNING); /* enddo */
  982.   return(CodePoint);
  983.  
  984. } /* ReplyMsg */
  985.  
  986. /**************************************************************************
  987. **************************  DumpBuffer  ***********************************
  988. ***************************************************************************
  989. *
  990. *   For each object in the reply message buffer, print out its contents.
  991. *
  992. ***************************************************************************/
  993. VOID DumpBuffer(PDDMOBJECT  pAttribute,
  994.                 USHORT      Count)
  995. {
  996.     int i;                                  /* Local loop counter  */
  997.     do
  998.     {  if (pAttribute->cbObject == (sizeof(CODEPOINT) + sizeof(OBJLENGTH)))
  999.        {  printf("Null object returned = %x\n",pAttribute->cbObject);
  1000.           pAttribute->cpObject = 0;
  1001.        }
  1002.        else
  1003.        {  switch(pAttribute->cpObject)
  1004.           {  case ACCMTHCL:                 /* Access Method Class */
  1005.                 printf("ACCMTHCL = 0x%X\n", *(PCODEPOINT)(pAttribute->pData));
  1006.                 break;
  1007.              case BASFILNM:                 /* Base File Name */
  1008.                printf("BASFILNM = %s\n", pAttribute->pData);
  1009.                 break;
  1010.              case CODPNT:                   /* Code Point */
  1011.                 printf("CODPNT = 0x%X\n", *(PCODEPOINT)(pAttribute->pData));
  1012.                 break;
  1013.              case CSRPOSST:                 /* Cursor Position Status */
  1014.                 printf("CSRPOSST = 0x%hX\n", *(PBYTE)(pAttribute->pData));
  1015.                 break;
  1016.              case DTALCKST:                 /* Data Lock Status */
  1017.                 printf("DTALCKST = 0x%hX\n", *(PBYTE)(pAttribute->pData));
  1018.                 break;
  1019.              case ERRFILNM:                 /* Error File Name */
  1020.                 printf("ERRFILNM = %s\n", pAttribute->pData);
  1021.                 break;
  1022.              case FILNAM:                   /* File Name */
  1023.                 printf("FILNAM = %s\n", pAttribute->pData);
  1024.                 break;
  1025.              case KEYDEFCD:                 /* Key Definition Error Code */
  1026.                 printf("KEYDEFCD = 0x%hX\n", *(PBYTE)(pAttribute->pData));
  1027.                 break;
  1028.              case MAXOPN:                   /* Maximum Number of File Extents
  1029.                                                 Concurrent Opens Allowed */
  1030.                 printf("MAXOPN = %d\n", *(PUSHORT)(pAttribute->pData));
  1031.                 break;
  1032.              case NEWFILNM:                 /* New File Name */
  1033.                 printf("NEWFILNM = %s\n", pAttribute->pData);
  1034.                 break;
  1035.              case PRCCNVCD:         /* Conversational Protocol Error Code */
  1036.                 printf("PRCCNVCD = 0x%hX\n", *(PBYTE)(pAttribute->pData));
  1037.                 break;
  1038.              case RECCNT:                   /* Record Count */
  1039.                 printf("RECCNT = %ld\n", *(PULONG)(pAttribute->pData));
  1040.                 break;
  1041.              case RECNBR:                   /* Record Number */
  1042.                 printf("RECNBR = %ld\n", *(PRECNUM)(pAttribute->pData));
  1043.                 break;
  1044.              case SRVDGN:      {            /* Server Diagnostic Information */
  1045.                 printf("SRVDGN = 0x\n");
  1046.                 for (i=1; i < (pAttribute->cbObject-5); i++) /* 2 byte len, 2 byte codept*/
  1047.                     { if (i % 16 ==0)
  1048.                                   printf("%02X\n", *(PBYTE)(pAttribute->pData+i-1));
  1049.                        else
  1050.                        if (i % 4 ==0)
  1051.                                   printf("%02X ", *(PBYTE)(pAttribute->pData+i-1));
  1052.                        else
  1053.                            printf("%02X", *(PBYTE)(pAttribute->pData+i-1));
  1054.                      }
  1055.                }
  1056.                 break;
  1057.              case SVRCOD:                   /* Severity Code */
  1058.                 printf("SVRCOD = 0x%X\n", *(PCODEPOINT)(pAttribute->pData));
  1059.                 break;
  1060.              case SYNERRCD:                 /* Syntax Error Code */
  1061.                 printf("SYNERRCD = 0x%hX\n", *(PBYTE)(pAttribute->pData));
  1062.                 break;
  1063.              default:
  1064.                 printf("Unknown code point - 0x%X\n",
  1065.                        *(PCODEPOINT)(pAttribute->pData));
  1066.                 break;
  1067.           } /* endswitch */
  1068.        } /* endif */
  1069.  
  1070.        /* go to next object */
  1071.        pAttribute = (PDDMOBJECT)((PBYTE)pAttribute + pAttribute->cbObject);
  1072.  
  1073.     } while(--Count > 0);
  1074.  
  1075. } /* DumpBuffer */
  1076.  
  1077. /**************************************************************************
  1078. ****************************  Error Routines ******************************
  1079. **************************************************************************/
  1080. VOID GeneralError()
  1081. {
  1082.   printf("DFMACALL: Incorrect command line syntax.\n");
  1083. } /* GeneralError */
  1084.  
  1085. VOID OmitError()
  1086. {
  1087.   printf("DFMACALL: A required parameter was omitted.\n");
  1088. }
  1089.  
  1090. VOID TooManyError()
  1091. {
  1092.   printf("DFMACALL: Too many parameters were on the command line.\n");
  1093. }
  1094.  
  1095. VOID NotEnoughError()
  1096. {
  1097.  printf("DFMACALL: Not enough parameters were on the command line.\n");
  1098. }
  1099.  
  1100. VOID HasFileNameError()
  1101. {
  1102.  printf("DFMACALL: Filename is not allowed for QTSO, TSO, or START.\n");
  1103. }
  1104.  
  1105. VOID NoFileNameError()
  1106. {
  1107.  printf("DFMACALL: A filename must be specified.\n");
  1108. }
  1109.  
  1110. VOID ValueError(char *value)
  1111. {
  1112.  printf("DFMACALL: Incorrect parameter value %s.\n",value);
  1113. }
  1114.  
  1115. VOID ParmLenError(char *value)
  1116. {
  1117.  printf("DFMACALL: Parameter %s is too long.\n",value);
  1118. }
  1119.  
  1120. int strupper(char *oarg, char *iarg, int bufflen)
  1121. {
  1122.  /* Convert string to upper case.                                     */
  1123.  int i;
  1124.  if (strlen(iarg) > bufflen) {
  1125.    ParmLenError(iarg);
  1126.    return(SC_SEVERE);
  1127.  }
  1128.  
  1129.  for (i=0; i < strlen(iarg); i++) {
  1130.     oarg[i] = toupper(iarg[i]);
  1131.  }
  1132.  oarg[i] = 0;
  1133.  return (0);
  1134.  
  1135. }
  1136.  
  1137. VOID DuplicateError()
  1138. {
  1139.  printf("DFMACALL: One or more parameters were duplicated.\n");
  1140. }
  1141.  
  1142. VOID  DisplayBuffer(ULONG count, PDDMRECORD pCurrentRecord)
  1143. {
  1144.     /* Display a buffer full of records                                       */
  1145.     ULONG i;                            /* record counter                     */
  1146.     int j;                              /* index to character in record       */
  1147.     int cRecLen;                        /* current record length              */
  1148.     UCHAR c;                            /* current converted character        */
  1149.     UCHAR savechar;                     /* savearea for trailing character    */
  1150.  
  1151.  
  1152.          for (i=1; i <= count; i++) {
  1153.            cRecLen = pCurrentRecord->cbRecord - sizeof(pCurrentRecord->cbRecord)
  1154.                           - sizeof(pCurrentRecord->cpRecord);
  1155.            /*******************************************************************/
  1156.            /* Replace all instances of non-printable characters,              */
  1157.            /*******************************************************************/
  1158.            /* Make sure the string is printable and                           */
  1159.            /* make sure that there is no 0 in the middle of string.           */
  1160.            for (j=0; j < cRecLen; j++) {
  1161.              if (!(c = pCurrentRecord->pRecord[j]))
  1162.                pCurrentRecord->pRecord[j] = ' ';  /* Replace x00 with blank   */
  1163.              else if (!isprint(c))
  1164.                pCurrentRecord->pRecord[j] = '.';  /* Make nonprintable a "."  */
  1165.            }                                      /* End of for j= loop       */
  1166.            savechar = pCurrentRecord->pRecord[cRecLen]; /* save trailing char */
  1167.            pCurrentRecord->pRecord[cRecLen] = '\0';
  1168.  
  1169.            if (debug >= 5) {
  1170.              display_counter++;
  1171.              printf ("Displaying record %d with length %d:\n",
  1172.                       display_counter,cRecLen);
  1173.            }
  1174.            printf ("%s\n",pCurrentRecord->pRecord);
  1175.            pCurrentRecord->pRecord[cRecLen] = savechar;  /* restore trailing   */
  1176.            pCurrentRecord = (PDDMRECORD)  (pCurrentRecord->pRecord + cRecLen);
  1177.          }
  1178.  
  1179. }
  1180.  
  1181.  
  1182.      SpecialOptions(int index, int argc, char  *argv[])
  1183. {
  1184.  CHAR uarg[PARMLEN];            /* Upper case argument               */
  1185.   /* Check for special processing options.                           */
  1186.   if (intrc = strupper(uarg, argv[index], PARMLEN))
  1187.     return(intrc);
  1188.   if (strcmp(uarg,"DISPLAY") == 0)
  1189.     display_filename = 1;
  1190.  
  1191.  return(0);
  1192. }         /* End of SpecialOptions  */
  1193.  
  1194.      CheckRange(int minparms, int maxparms, int argc, char uarg[PARMLEN])
  1195. {
  1196.  /* Ensure number of parameters is reasonable for the command   */
  1197.  
  1198.     /********************************************************/
  1199.     /* Ensure enough parameters                             */
  1200.     /********************************************************/
  1201.     if (argc < minparms) {
  1202.       NotEnoughError();
  1203.       DisplayHelp(&uarg[0]);
  1204.       return(SC_SEVERE);
  1205.     }
  1206.  
  1207.     /********************************************************/
  1208.     /* Ensure no leftover parameters                        */
  1209.     /********************************************************/
  1210.     if (argc > maxparms) {
  1211.       TooManyError();
  1212.       DisplayHelp(&uarg[0]);
  1213.       return(SC_SEVERE);
  1214.     }
  1215.  
  1216. return(0);
  1217.  
  1218. }
  1219.  
  1220.  
  1221. /**********************************************************************
  1222. ****************************  DisplayHelp *****************************
  1223. ***********************************************************************
  1224. *   Display the correct syntax for invoking this function.
  1225. *
  1226. **********************************************************************/
  1227. VOID DisplayHelp(char *fullhelp)
  1228. {
  1229. if (strncmp(fullhelp,"?",1) == 0) {
  1230.   /* Print full help text.                                           */
  1231.   printf("Correct syntax:                                             \n\n");
  1232.   printf("  DFMACALL QTSO  driveletter:  TSOcommandline  [DISPLAY]      \n");
  1233.   printf("  DFMACALL TSO   driveletter:  [TSOcommandline] [DISPLAY]     \n");
  1234.   printf("  DFMACALL AGENT driveletter:[filename] MVSproc[,proc_parms]  \n");
  1235.   printf("     [PGM prog_name] [PARM prog_parms] [DISPLAY]              \n");
  1236.   printf("  DFMACALL START driveletter:    MVSproc[,proc_parms]         \n");
  1237.   printf("  DFMACALL driveletter:filename[,filename_suffix] [DISPLAY] \n\n");
  1238.   printf(" Examples:                                             \n\n");
  1239.   printf("   dfmacall qtso  s: listc  display                      \n");
  1240.   printf("   dfmacall tso   s:        display                      \n");
  1241.   printf("   dfmacall agent r:ibmuser.a.b  dfmxagnt                \n");
  1242.   printf("   dfmacall agent r:ibmuser.a.b  dfmxtso                 \n");
  1243.   printf("           pgm ikjeft01 parm listc                       \n");
  1244.   printf("   dfmacall start s:          dfmx0001,dfminit=iefbr14   \n");
  1245.   printf("   dfmacall r:ibmuser.a.b,agent(dfmxagnt),parm(hello)    \n");
  1246.   printf("   dfmacall r:ibmuser.a.b,agent(dfmx0001),pgm(dfmxagnt)\n\n");
  1247. }
  1248. else {
  1249.   /* Print clue for getting correct help text.                          */
  1250.   printf("DFMACALL: Enter DFMACALL ? to get the correct command syntax. \n\n");
  1251. }
  1252. }
  1253.