Changeset 16 for rxutilex/trunk/rxutilex.c

Timestamp:

Sep 20, 2014, 1:17:51 PM (11 years ago)

Author:

Alex Taylor

Message:

Added named-pipe and I/O functions (not yet fully tested).

File:

• rxutilex/trunk/rxutilex.c (modified) (10 diffs)

rxutilex/trunk/rxutilex.c

@@ -1 +1 @@
 /******************************************************************************
  * REXX Utility Functions - Extended (RXUTILEX.DLL)                           *
- * (C) 2011 Alex Taylor.                                                      *
+ * (C) 2011, 2014 Alex Taylor.                                                *
  *                                                                            *
  * LICENSE:                                                                   *
@@ -43 +43 @@
 #define INCL_WINCLIPBOARD
 #define INCL_WINERRORS
+#define INCL_DOSERRORS
 #define INCL_DOSMISC
+#define INCL_DOSMODULEMGR
+#define INCL_DOSNMPIPES
 #define INCL_DOSPROCESS
 #define INCL_DOSPROFILE
-#define INCL_DOSERRORS
-#define INCL_DOSMODULEMGR
 #ifndef OS2_INCLUDED
     #include <os2.h>
@@ -72 +73 @@
 #define SZ_LIBRARY_NAME         "RXUTILEX"  // Name of this library
 #define SZ_ERROR_NAME           "SYS2ERR"   // REXX variable used to store error codes
-#define SZ_VERSION              "0.0.4"     // Current version of this library
+#define SZ_VERSION              "0.0.5"     // Current version of this library
 
 // Maximum string lengths...
 #define US_COMPOUND_MAXZ        250                                  // ...of a compound variable
-#define US_INTEGER_MAXZ         12                                   // ...of an integer string
+#define US_INTEGER_MAXZ         12                                   // ...of a 32-bit integer string
+#define US_LONGLONG_MAXZ        21                                   // ...of a 64-bit integer string
 #define US_STEM_MAXZ          ( US_COMPOUND_MAXZ - US_INTEGER_MAXZ ) // ...of a stem
 #define US_ERRSTR_MAXZ          250                                  // ...of an error string
 #define US_PIDSTR_MAXZ        ( CCHMAXPATH + 100 )                   // ...of a process information string
 #define US_TIMESTR_MAXZ         256                                  // ...of a formatted time string
+#define US_PIPESTATUS_MAXZ      128                                  // ...of a pipe status string
 
 #define UL_SSBUFSIZE            0xFFFF      // Buffer size for the DosQuerySysState() data
@@ -104 +107 @@
     "Sys2ReplaceModule",
     "Sys2LocateDLL",
+    "Sys2CreateNamedPipe",
+    "Sys2ConnectNamedPipe",
+    "Sys2DisconnectNamedPipe",
+    "Sys2CheckNamedPipe",
+    "Sys2Open",
+    "Sys2Close",
+    "Sys2Seek",
+    "Sys2Read",
+    "Sys2Write",
     "Sys2Version"
 };
@@ -120 +132 @@
 RexxFunctionHandler Sys2GetClipboardText;
 RexxFunctionHandler Sys2PutClipboardText;
-// RexxFunctionHandler Sys2GetClipboardData;
-// RexxFunctionHandler Sys2PutClipboardData;
 
 RexxFunctionHandler Sys2QueryProcess;
@@ -133 +143 @@
 RexxFunctionHandler Sys2ReplaceModule;
 
-RexxFunctionHandler Sys2ReplaceObjectClass;
+// RexxFunctionHandler Sys2ReplaceObjectClass;
+
+RexxFunctionHandler Sys2CreateNamedPipe;
+RexxFunctionHandler Sys2ConnectNamedPipe;
+RexxFunctionHandler Sys2DisconnectNamedPipe;
+RexxFunctionHandler Sys2CheckNamedPipe;
+
+RexxFunctionHandler Sys2Open;
+RexxFunctionHandler Sys2Close;
+RexxFunctionHandler Sys2Seek;
+RexxFunctionHandler Sys2Read;
+RexxFunctionHandler Sys2Write;
 
 
@@ -301 +322 @@
         if ( ulRC == 0 ) {
             memset( pszShareMem, 0, ulBytes );
-            strncpy( pszShareMem, argv[0].strptr , ulBytes - 1 );
+            strncpy( pszShareMem, argv[0].strptr, ulBytes - 1 );
             if ( ! WinSetClipbrdData( hab, (ULONG) pszShareMem, CF_TEXT, CFI_POINTER ))
                 WriteErrorCode( ERRORIDERROR(WinGetLastError(hab)), "WinSetClipbrdData");
@@ -1137 +1158 @@
             WriteErrorCode( timeval, "time");
             MAKERXSTRING( *prsResult, "0", 1 );
+            free( pszSetTZ );
             return 0;
         }
@@ -1153 +1175 @@
             WriteErrorCode( timeval, "mktime");
             MAKERXSTRING( *prsResult, "0", 1 );
+            free( pszSetTZ );
             return 0;
         }
@@ -1224 +1247 @@
 }
 
+
+/* ------------------------------------------------------------------------- *
+ * Sys2CreateNamedPipe                                                       *
+ *                                                                           *
+ * Create a named pipe with the specified name and parameters.  Only byte    *
+ * mode is supported; message mode is not.                                   *
+ *                                                                           *
+ * REXX ARGUMENTS:                                                           *
+ *   1. The name of the pipe, in the form "\PIPE\something".      (REQUIRED) *
+ *   2. The size of the outbound buffer, in bytes.                (REQUIRED) *
+ *   3. The size of the inbound buffer, in bytes.                 (REQUIRED) *
+ *   4. The pipe's timeout value, in milliseconds.           (DEFAULT: 3000) *
+ *   5. The number of simultaneous instances of this pipe which are allowed. *
+ *      Must be between 1 and 254, or 0 indicating no limit.    (DEFAULT: 1) *
+ *   6. Pipe blocking mode, one of:                                          *
+ *        W = WAIT mode, read and write block waiting for data.    (DEFAULT) *
+ *        N = NOWAIT mode, read and write return immediately.                *
+ *   7. Pipe mode, one of:                                                   *
+ *        I = Inbound pipe                                         (DEFAULT) *
+ *        O = Outbound pipe                                                  *
+ *        D = Duplex (inbound/outbound) pipe                                 *
+ *   8. Privacy/inheritance flag, one of:                                    *
+ *        0 = The pipe handle is inherited by child processes.     (DEFAULT) *
+ *        1 = The pipe handle is private to the current process.             *
+ *   9. Write-through flag, one of:                                          *
+ *        0 = Allow delayed writes (write-behind) to remote pipes. (DEFAULT) *
+ *        1 = Force immediate writes (write-through) to remote pipes.        *
+ *                                                                           *
+ * REXX RETURN VALUE:                                                        *
+ *   A four-byte pipe handle.                                                *
+ * ------------------------------------------------------------------------- */
+ULONG APIENTRY Sys2CreateNamedPipe( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
+{
+    HPIPE   hp;
+    PSZ     pszNPName;
+    LONG    iLimit;
+    ULONG   ulBufOut,
+            ulBufIn,
+            ulTimeout = 3000,
+            flOpen    = 0,
+            flPipe    = 1;
+    CHAR    achHandle[ 9 ];
+    APIRET  rc;
+
+    // Reset the error indicator
+    WriteErrorCode( 0, NULL );
+
+    // Make sure we have at least three valid arguments (pipe name and sizes)
+    if ( argc < 3  || ( !RXVALIDSTRING(argv[0]) ) ||
+        ( !RXVALIDSTRING(argv[1]) ) || ( !RXVALIDSTRING(argv[2]) ))
+        return ( 40 );
+
+    // (Validate the first argument last to simplify error processing)
+
+    // Second argument: pipe outbound buffer size
+    if (( sscanf( argv[1].strptr, "%u", &ulBufOut )) != 1 ) return ( 40 );
+
+    // Third argument: pipe outbound buffer size
+    if (( sscanf( argv[2].strptr, "%u", &ulBufIn )) != 1 ) return ( 40 );
+
+    // Fourth argument: pipe timeout value
+    if ( argc >= 4 && RXVALIDSTRING(argv[3]) ) {
+        if (( sscanf( argv[3].strptr, "%u", &ulTimeout )) != 1 ) return ( 40 );
+    }
+
+    // Fifth argument: instances limit
+    if ( argc >= 5 && RXVALIDSTRING(argv[4]) ) {
+        if (( sscanf( argv[4].strptr, "%d", &iLimit )) != 1 ) return ( 40 );
+        if (( iLimit > 1 ) && ( iLimit < 255 ))
+            flPipe = iLimit;
+        else if ( !iLimit || ( iLimit == -1 ))
+            flPipe = NP_UNLIMITED_INSTANCES;
+        else
+            return ( 40 );
+    }
+
+    // Sixth argument: blocking mode
+    if ( argc >= 6 && RXVALIDSTRING(argv[5]) ) {
+        strupr( argv[5].strptr );
+        if ( argv[5].strptr[0] == 'N' )
+            flPipe |= NP_NOWAIT;
+        else if ( argv[5].strptr[0] != 'W' )
+            return ( 40 );
+    }
+
+    // Seventh argument: pipe mode (direction)
+    if ( argc >= 7 && RXVALIDSTRING(argv[6]) ) {
+        strupr( argv[6].strptr );
+        if (strcspn(argv[6].strptr, "IOD") > 0 ) return ( 40 );
+        switch ( argv[6].strptr[0] ) {
+            case 'O': flOpen |= NP_ACCESS_OUTBOUND; break;
+            case 'D': flOpen |= NP_ACCESS_DUPLEX;   break;
+            default : break;            // default is 0
+        }
+    }
+
+    // Eighth argument: inheritance mode
+    if ( argc >= 8 && RXVALIDSTRING(argv[7]) ) {
+        strupr( argv[7].strptr );
+        if ( argv[7].strptr[0] == '1' )
+            flOpen |= NP_NOINHERIT;
+        else if ( argv[7].strptr[0] != '0' )
+            return ( 40 );
+    }
+
+    // Ninth argument: write mode
+    if ( argc >= 9 && RXVALIDSTRING(argv[8]) ) {
+        strupr( argv[8].strptr );
+        if ( argv[8].strptr[0] == '1' )
+            flOpen |= NP_NOWRITEBEHIND;
+        else if ( argv[8].strptr[0] != '0' )
+            return ( 40 );
+    }
+
+    // Now the first argument: pipe name
+    pszNPName = (PSZ) calloc( RXSTRLEN(argv[0]) + 1, sizeof(UCHAR) );
+    if ( pszNPName == NULL ) {
+        WriteErrorCode( ERROR_NOT_ENOUGH_MEMORY, "calloc");
+        MAKERXSTRING( *prsResult, "0", 1 );
+        return ( 0 );
+    }
+    strncpy( pszNPName, argv[0].strptr, RXSTRLEN(argv[0]) );
+
+    // All good, now create the pipe
+    rc = DosCreateNPipe( pszNPName, &hp, flOpen, flPipe, ulBufOut, ulBufIn, ulTimeout );
+    if (rc) {
+        WriteErrorCode( rc, "DosCreateNPipe");
+        MAKERXSTRING( *prsResult, "", 0 );
+        return 0;
+    }
+
+    // Return the handle as the REXX result string
+    sprintf( achHandle, "%8X", hp );
+    MAKERXSTRING( *prsResult, achHandle, strlen( achHandle ));
+
+    free( pszNPName );
+    return ( 0 );
+}
+
+
+/* ------------------------------------------------------------------------- *
+ * Sys2ConnectNamedPipe                                                      *
+ *                                                                           *
+ * Start 'listening' by allowing clients to connect to a previously-created  *
+ * named pipe.                                                               *
+ *                                                                           *
+ * REXX ARGUMENTS:                                                           *
+ *   1. The pipe handle, as returned by Sys2CreateNamedPipe.      (REQUIRED) *
+ *                                                                           *
+ * REXX RETURN VALUE:                                                        *
+ *   1 on success, or 0 if an error occurred.                                *
+ * ------------------------------------------------------------------------- */
+ULONG APIENTRY Sys2ConnectNamedPipe( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
+{
+    HPIPE   hp;
+    APIRET  rc;
+
+    // Reset the error indicator
+    WriteErrorCode( 0, NULL );
+
+    // Parse the handle
+    if ( !(argc == 1 && RXVALIDSTRING(argv[0])) ) return ( 40 );
+    if (( sscanf( argv[0].strptr, "%8X", &hp )) != 1 ) return ( 40 );
+
+    // Connect the pipe
+    rc = DosConnectNPipe( hp );
+    if ( rc != NO_ERROR ) {
+        WriteErrorCode( rc, "DosConnectNPipe");
+        MAKERXSTRING( *prsResult, "0", 1 );
+        return ( 0 );
+    }
+
+    // Return 1 on success
+    MAKERXSTRING( *prsResult, "1", 1 );
+    return ( 0 );
+}
+
+
+/* ------------------------------------------------------------------------- *
+ * Sys2DisconnectNamedPipe                                                   *
+ *                                                                           *
+ * Unlocks a named pipe after a client has closed its connection.            *
+ *                                                                           *
+ * REXX ARGUMENTS:                                                           *
+ *   1. The pipe handle, as returned by Sys2CreateNamedPipe.      (REQUIRED) *
+ *                                                                           *
+ * REXX RETURN VALUE:                                                        *
+ *   1 on success, or 0 if an error occurred.                                *
+ * ------------------------------------------------------------------------- */
+ULONG APIENTRY Sys2DisconnectNamedPipe( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
+{
+    HPIPE   hp;
+    APIRET  rc;
+
+    // Reset the error indicator
+    WriteErrorCode( 0, NULL );
+
+    // Parse the handle
+    if ( !(argc == 1 && RXVALIDSTRING(argv[0])) ) return ( 40 );
+    if (( sscanf( argv[0].strptr, "%8X", &hp )) != 1 ) return ( 40 );
+
+    // Connect the pipe
+    rc = DosDisConnectNPipe( hp );
+    if ( rc != NO_ERROR ) {
+        WriteErrorCode( rc, "DosDisConnectNPipe");
+        MAKERXSTRING( *prsResult, "0", 1 );
+        return ( 0 );
+    }
+
+    // Return 1 on success
+    MAKERXSTRING( *prsResult, "1", 1 );
+    return ( 0 );
+}
+
+
+/* ------------------------------------------------------------------------- *
+ * Sys2CheckNamedPipe                                                        *
+ *                                                                           *
+ * Check the status of a named pipe.                                         *
+ *                                                                           *
+ * REXX ARGUMENTS:                                                           *
+ *   1. The pipe handle (from Sys2CreateNamedPipe or DosOpen).    (REQUIRED) *
+ *                                                                           *
+ * REXX RETURN VALUE:                                                        *
+ *   String of the format "bytes status", where bytes is the number of bytes *
+ *   currently waiting in the pipe, and status is one of: DISCONNECTED,      *
+ *   LISTENING, CONNECTED, or CLOSING.                                       *
+ * ------------------------------------------------------------------------- */
+ULONG APIENTRY Sys2CheckNamedPipe( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
+{
+    HPIPE     hp;
+    ULONG     cbActual, ulState;
+    AVAILDATA avd;
+    CHAR      szStatus[ US_PIPESTATUS_MAXZ ];
+    APIRET    rc;
+
+    // Reset the error indicator
+    WriteErrorCode( 0, NULL );
+
+    // Parse the handle
+    if ( !(argc == 1 && RXVALIDSTRING(argv[0])) ) return ( 40 );
+    if (( sscanf( argv[0].strptr, "%8X", &hp )) != 1 ) return ( 40 );
+
+    rc = DosPeekNPipe( hp, NULL, 0, &cbActual, &avd, &ulState );
+    if ( rc != NO_ERROR ) {
+        WriteErrorCode( rc, "DosPeekNPipe");
+        MAKERXSTRING( *prsResult, "", 0 );
+        return ( 0 );
+    }
+    sprintf( szStatus, "%u ", avd.cbpipe );
+    switch ( ulState ) {
+        case NP_STATE_DISCONNECTED: strncat( szStatus, "DISCONNECTED", US_PIPESTATUS_MAXZ-1 ); break;
+        case NP_STATE_LISTENING:    strncat( szStatus, "LISTENING",    US_PIPESTATUS_MAXZ-1 ); break;
+        case NP_STATE_CONNECTED:    strncat( szStatus, "CONNECTED",    US_PIPESTATUS_MAXZ-1 ); break;
+        case NP_STATE_CLOSING:      strncat( szStatus, "CLOSING",      US_PIPESTATUS_MAXZ-1 ); break;
+        default:                    strncat( szStatus, "UNKNOWN",      US_PIPESTATUS_MAXZ-1 ); break;
+    }
+
+    if ( ! SaveResultString( prsResult, szStatus, strlen( szStatus ))) {
+        MAKERXSTRING( *prsResult, "", 0 );
+    }
+    return ( 0 );
+}
+
+
+/* ------------------------------------------------------------------------- *
+ * Sys2Open                                                                  *
+ *                                                                           *
+ * Wrapper to DosOpenL: open a file or stream (with >2GB support).           *
+ * Direct-DASD mode is not supported by this function, nor is setting the    *
+ * initial extended attributes.                                              *
+ *                                                                           *
+ * REXX ARGUMENTS:                                                           *
+ *   1. Name of file or stream to open.                           (REQUIRED) *
+ *   2. Open action flags, must be either "O" (open if exists), "R" (replace *
+ *      if exists), or nothing (fail if exists), optionally followed by "C"  *
+ *      (create if file does not exist).  If "C" is not specified, the       *
+ *      operation will fail if the file does not exist.  Note that a value   *
+ *      of "" alone will therefore fail automatically.        (DEFAULT: "O") *
+ *      In summary, the possible combinations are:                           *
+ *        O = Open only (if file exists, open it; if not, fail)              *
+ *        OC= Open/create (if file exists, open it; if not, create it)       *
+ *        R = Replace only (if file exists, replace it; if not, fail)        *
+ *        RC= Replace/create (if file exists, replace it; if not, create it) *
+ *        C = Create only (if file exists, fail; if not, create it)          *
+ *        (empty) = No-op (if file exists, fail; if not, fail)               *
+ *   3. Access mode flags, one or both of:                   (DEFAULT: "RW") *
+ *        R = Open file with read access.                                    *
+ *        W = Open file with write access.                                   *
+ *   4. Sharing mode flags, any combination of:               (DEFAULT: "W") *
+ *        R = Deny read access to other processes                            *
+ *        W = Deny write access to other processes                           *
+ *   5. Deny legacy DosOpen access, one of:                                  *
+ *        0 = Allow DosOpen to access the file                     (DEFAULT) *
+ *        1 = Deny access using the DosOpen API                              *
+ *   6. Privacy/inheritance flag, one of:                                    *
+ *        0 = The file handle is inherited by child processes.     (DEFAULT) *
+ *        1 = The file handle is private to the current process.             *
+ *   7. Initial file attributes when creating a file:          (DEFAULT: "") *
+ *        A = Archive attribute set                                          *
+ *        D = Directory attribute set                                        *
+ *        S = System attribute set                                           *
+ *        H = Hidden attribute set                                           *
+ *        R = Read-only attribute set                                        *
+ *   8. Initial file size when creating or replacing a file; ignored if      *
+ *      access mode is read-only.                               (DEFAULT: 0) *
+ *   9. I/O mode flags, any or all of:                         (DEFAULT: "") *
+ *       T = Write-through mode (default is normal write)                    *
+ *       N = No-cache mode (default is to use filesystem cache)              *
+ *       S = Sequential access                                               *
+ *       R = Random access                                                   *
+ *          * S and R can combine as follows:                                *
+ *              Neither: No locality known (default)                         *
+ *              S only:  Mainly sequential access                            *
+ *              R only:  Mainly random access                                *
+ *              Both:    Random/sequential (i.e. random with some locality)  *
+ *                                                                           *
+ * REXX RETURN VALUE:                                                        *
+ *   File handle, or "" in case of error.                                    *
+ * ------------------------------------------------------------------------- */
+ULONG APIENTRY Sys2Open( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
+{
+    PSZ      pszFile;
+    HFILE    hf;
+    ULONG    fsAction = 0,
+             fsMode   = 0,
+             ulResult = 0,
+             ulAttr   = FILE_NORMAL;
+    LONGLONG llSize   = {0};
+    CHAR     achHandle[ 9 ];
+    APIRET   rc;
+
+
+    // Reset the error indicator
+    WriteErrorCode( 0, NULL );
+
+    // Make sure we have at least one valid argument (the file name)
+    if ( argc < 1  || ( !RXVALIDSTRING(argv[0]) ))
+        return ( 40 );
+
+    // (Validate the first argument last to simplify error processing)
+
+    // Second argument: open action
+    if ( argc >= 2 && RXVALIDSTRING(argv[1]) ) {
+        strupr( argv[1].strptr );
+        if ( strcspn(argv[1].strptr, "OCR") > 0 ) return ( 40 );
+        if ( strchr(argv[1].strptr, 'O'))
+            fsAction |= OPEN_ACTION_OPEN_IF_EXISTS;
+        else if ( strchr(argv[1].strptr, 'R'))
+            fsAction |= OPEN_ACTION_REPLACE_IF_EXISTS;
+        if ( strchr(argv[1].strptr, 'C'))
+            fsAction |= OPEN_ACTION_CREATE_IF_NEW;
+    }
+    else
+        fsAction = OPEN_ACTION_OPEN_IF_EXISTS;
+
+    // Third argument: access mode
+    if ( argc >= 3 && RXVALIDSTRING(argv[2]) ) {
+        strupr( argv[2].strptr );
+        if ( strcspn(argv[2].strptr, "RW") > 0 ) return ( 40 );
+        if ( strchr(argv[2].strptr, 'R')) {
+            if (strchr(argv[2].strptr, 'W'))
+                fsMode = OPEN_ACCESS_READWRITE;
+            else
+                fsMode = OPEN_ACCESS_READONLY;
+        }
+        else if (strchr(argv[2].strptr, 'W'))
+            fsMode = OPEN_ACCESS_WRITEONLY;
+        else
+            return ( 40 );
+    }
+    else
+        fsMode = OPEN_ACCESS_READWRITE;
+
+    // Fourth argument: sharing mode
+    if ( argc >= 4 && RXVALIDSTRING(argv[3]) ) {
+        strupr( argv[3].strptr );
+        if ( strcspn(argv[3].strptr, "RW") > 0 ) return ( 40 );
+        if ( strchr(argv[3].strptr, 'R')) {
+            if (strchr(argv[3].strptr, 'W'))
+                fsMode |= OPEN_SHARE_DENYREADWRITE;
+            else
+                fsMode |= OPEN_SHARE_DENYREAD;
+        }
+        else if (strchr(argv[3].strptr, 'W'))
+            fsMode |= OPEN_SHARE_DENYWRITE;
+        else
+            fsMode |= OPEN_SHARE_DENYNONE;
+    }
+    else
+        fsMode |= OPEN_SHARE_DENYWRITE;
+
+    // Fifth argument: deny legacy mode
+    if ( argc >= 5 && RXVALIDSTRING(argv[4]) ) {
+        strupr( argv[4].strptr );
+        if ( argv[4].strptr[0] == '1' )
+            fsMode |= OPEN_SHARE_DENYLEGACY;
+        else if ( argv[4].strptr[0] != '0' )
+            return ( 40 );
+    }
+
+    // Sixth argument: inheritance mode
+    if ( argc >= 6 && RXVALIDSTRING(argv[5]) ) {
+        strupr( argv[5].strptr );
+        if ( argv[5].strptr[0] == '1' )
+            fsMode |= OPEN_FLAGS_NOINHERIT;
+        else if ( argv[5].strptr[0] != '0' )
+            return ( 40 );
+    }
+
+    // Seventh argument: attributes
+    if ( argc >= 7 && RXVALIDSTRING(argv[6]) ) {
+        strupr( argv[6].strptr );
+        if (strcspn(argv[6].strptr, "ADSHR") > 0 ) return ( 40 );
+        if ( strchr(argv[6].strptr, 'A')) ulAttr |= FILE_ARCHIVED;
+        if ( strchr(argv[6].strptr, 'D')) ulAttr |= FILE_DIRECTORY;
+        if ( strchr(argv[6].strptr, 'S')) ulAttr |= FILE_SYSTEM;
+        if ( strchr(argv[6].strptr, 'H')) ulAttr |= FILE_HIDDEN;
+        if ( strchr(argv[6].strptr, 'R')) ulAttr |= FILE_READONLY;
+    }
+
+    // Eighth argument: initial size
+    if ( argc >= 8 && RXVALIDSTRING(argv[7]) ) {
+        if (( sscanf( argv[7].strptr, "%lld", &llSize )) != 1 ) return ( 40 );
+    }
+
+    // Ninth argument: I/O mode flags
+    if ( argc >= 9 && RXVALIDSTRING(argv[8]) ) {
+        strupr( argv[8].strptr );
+        if (strcspn(argv[8].strptr, "TNSR") > 0 ) return ( 40 );
+        if ( strchr(argv[8].strptr, 'T')) fsMode |= OPEN_FLAGS_WRITE_THROUGH;
+        if ( strchr(argv[8].strptr, 'N')) fsMode |= OPEN_FLAGS_NO_CACHE;
+        if ( strchr(argv[8].strptr, 'S')) fsMode |= OPEN_FLAGS_SEQUENTIAL;
+        if ( strchr(argv[8].strptr, 'R')) fsMode |= OPEN_FLAGS_RANDOM;
+    }
+
+    // Now the first argument: file name
+    pszFile = (PSZ) calloc( RXSTRLEN(argv[0]) + 1, sizeof(UCHAR) );
+    if ( pszFile == NULL ) {
+        WriteErrorCode( ERROR_NOT_ENOUGH_MEMORY, "calloc");
+        MAKERXSTRING( *prsResult, "0", 1 );
+        return ( 0 );
+    }
+    strncpy( pszFile, argv[0].strptr, RXSTRLEN(argv[0]) );
+
+    // Try and open the file
+    rc = DosOpenL( pszFile, &hf, &ulResult, llSize, ulAttr, fsAction, fsMode, NULL );
+    if (rc) {
+        WriteErrorCode( rc, "DosOpenL");
+        MAKERXSTRING( *prsResult, "", 0 );
+        free( pszFile );
+        return ( 0 );
+    }
+
+    // Return the handle as the REXX result string
+    sprintf( achHandle, "%8X", hf );
+    MAKERXSTRING( *prsResult, achHandle, strlen( achHandle ));
+
+    free( pszFile );
+    return ( 0 );
+}
+
+
+/* ------------------------------------------------------------------------- *
+ * Sys2Close                                                                 *
+ *                                                                           *
+ * Wrapper to DosWrite: write bytes to a previously-opened stream.           *
+ *                                                                           *
+ * REXX ARGUMENTS:                                                           *
+ *   1. File handle (returned by Sys2Open)                        (REQUIRED) *
+ *                                                                           *
+ * REXX RETURN VALUE:                                                        *
+ *   1 on success, or 0 if an error occurred.                                *
+ * ------------------------------------------------------------------------- */
+ULONG APIENTRY Sys2Close( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
+{
+    HFILE  hf;
+    APIRET rc;
+
+    // Reset the error indicator
+    WriteErrorCode( 0, NULL );
+
+    // Make sure we have exactly one valid argument (the file handle)
+    if ( argc != 1  || ( !RXVALIDSTRING(argv[0]) ))
+        return ( 40 );
+    if (( sscanf( argv[0].strptr, "%8X", &hf )) != 1 ) return ( 40 );
+
+    // Close the file
+    rc = DosClose( hf );
+    if ( rc != NO_ERROR ) {
+        WriteErrorCode( rc, "DosClose");
+        MAKERXSTRING( *prsResult, "0", 1 );
+    }
+    else {
+        MAKERXSTRING( *prsResult, "1", 1 );
+    }
+
+    return ( 0 );
+}
+
+
+/* ------------------------------------------------------------------------- *
+ * Sys2Seek                                                                  *
+ *                                                                           *
+ * Wrapper to DosSetFilePtrL: move the read/write pointer to the specified   *
+ * location in a stream.                                                     *
+ *                                                                           *
+ * REXX ARGUMENTS:                                                           *
+ *   1. File handle (returned by Sys2Open)                        (REQUIRED) *
+ *   2. The signed distance in bytes to move                      (REQUIRED) *
+ *   3. Move method, one of:                                                 *
+ *        B = Beginning of file                                              *
+ *        C = Current position (DEFAULT)                                     *
+ *        E = End of file                                                    *
+ *                                                                           *
+ * REXX RETURN VALUE:                                                        *
+ *   The new file position, in bytes.                                        *
+ * ------------------------------------------------------------------------- */
+ULONG APIENTRY Sys2Seek( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
+{
+    HFILE    hf;
+    LONGLONG llPos,
+             llActual;
+    ULONG    ulMethod = FILE_CURRENT;
+    CHAR     achActual[ US_LONGLONG_MAXZ ];
+    APIRET   rc;
+
+    // Reset the error indicator
+    WriteErrorCode( 0, NULL );
+
+    // Make sure we have at least two valid arguments
+    if ( argc < 2 || ( !RXVALIDSTRING(argv[0]) ) || ( !RXVALIDSTRING(argv[1]) ))
+        return ( 40 );
+
+    // First argument: file handle
+    if (( sscanf( argv[0].strptr, "%8X", &hf )) != 1 ) return ( 40 );
+
+    // Second argument: requested offset
+    if (( sscanf( argv[1].strptr, "%lld", &llPos )) != 1 ) return ( 40 );
+
+    // Third argument: starting position
+    if ( argc >= 3 && RXVALIDSTRING(argv[2]) ) {
+        strupr( argv[2].strptr );
+        if ( strcspn(argv[2].strptr, "BCE") > 0 ) return ( 40 );
+        switch ( argv[1].strptr[0] ) {
+            case 'B': ulMethod = FILE_BEGIN;   break;
+            case 'E': ulMethod = FILE_END;     break;
+            default : ulMethod = FILE_CURRENT; break;
+        }
+    }
+
+    rc = DosSetFilePtrL( hf, llPos, ulMethod, &llActual );
+    if ( rc != NO_ERROR ) {
+        WriteErrorCode( rc, "DosSetFilePtrL");
+        MAKERXSTRING( *prsResult, "", 0 );
+        return ( 0 );
+    }
+
+    // Return the new position as the REXX result string
+    sprintf( achActual, "%lld", llActual );
+    MAKERXSTRING( *prsResult, achActual, strlen( achActual ));
+
+    return ( 0 );
+}
+
+
+/* ------------------------------------------------------------------------- *
+ * Sys2Read                                                                  *
+ *                                                                           *
+ * Wrapper to DosRead: read bytes from a previously-opened stream.           *
+ *                                                                           *
+ * REXX ARGUMENTS:                                                           *
+ *   1. File handle (returned by Sys2Open or Sys2CreateNamedPipe) (REQUIRED) *
+ *   2. Number of bytes to read                                   (REQUIRED) *
+ *                                                                           *
+ * REXX RETURN VALUE:                                                        *
+ *   String containing the bytes read, or "" in case of error.               *
+ * ------------------------------------------------------------------------- */
+ULONG APIENTRY Sys2Read( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
+{
+    HFILE  hf;
+    ULONG  cb,
+           cbActual;
+    PSZ    pszData;
+    APIRET rc;
+
+    // Reset the error indicator
+    WriteErrorCode( 0, NULL );
+
+    // Make sure we have two valid arguments
+    if ( argc != 2  || ( !RXVALIDSTRING(argv[0]) ) || ( !RXVALIDSTRING(argv[1]) ))
+        return ( 40 );
+
+    // First argument: handle
+    if (( sscanf( argv[0].strptr, "%8X", &hf )) != 1 ) return ( 40 );
+
+    // Second argument: number of bytes to read
+    if (( sscanf( argv[1].strptr, "%u", &cb )) != 1 ) return ( 40 );
+    if ( cb < 1 ) return ( 40 );
+    pszData = (PSZ) malloc( cb );
+
+    rc = DosRead( hf, pszData, cb, &cbActual );
+    if ( rc || !cbActual ) {
+        WriteErrorCode( rc, "DosRead");
+        MAKERXSTRING( *prsResult, "", 0 );
+        goto cleanup;
+    }
+    if ( ! SaveResultString( prsResult, pszData, cbActual )) {
+        MAKERXSTRING( *prsResult, "", 0 );
+    }
+
+cleanup:
+    free( pszData );
+    return ( 0 );
+}
+
+
+/* ------------------------------------------------------------------------- *
+ * Sys2Write                                                                 *
+ *                                                                           *
+ * Wrapper to DosWrite: write bytes to a previously-opened stream.           *
+ *                                                                           *
+ * REXX ARGUMENTS:                                                           *
+ *   1. File handle (returned by Sys2Open or Sys2CreateNamedPipe) (REQUIRED) *
+ *   2. Data to be written                                        (REQUIRED) *
+ *                                                                           *
+ * REXX RETURN VALUE:                                                        *
+ *   1 on success, or 0 if an error occurred.                                *
+ * ------------------------------------------------------------------------- */
+ULONG APIENTRY Sys2Write( PSZ pszName, ULONG argc, RXSTRING argv[], PSZ pszQueue, PRXSTRING prsResult )
+{
+    HFILE  hf;
+    ULONG  cbActual;
+    APIRET rc;
+
+    // Reset the error indicator
+    WriteErrorCode( 0, NULL );
+
+    // Make sure we have two valid arguments
+    if ( argc != 2  || ( !RXVALIDSTRING(argv[0]) ) || ( !RXVALIDSTRING(argv[1]) ))
+        return ( 40 );
+
+    // First argument: handle
+    if (( sscanf( argv[0].strptr, "%8X", &hf )) != 1 ) return ( 40 );
+
+    // (Second argument can be left in standard RXSTRING form)
+
+    rc = DosWrite( hf, argv[0].strptr, argv[0].strlength, &cbActual );
+    if ( rc != NO_ERROR ) {
+        WriteErrorCode( rc, "DosWrite");
+        MAKERXSTRING( *prsResult, "0", 1 );
+    }
+    else {
+        MAKERXSTRING( *prsResult, "1", 1 );
+    }
+
+    return ( 0 );
+}