netcall debug

CMakeLists.txt

@@ -0,0 +1,117 @@
+# DOS utilities for mars-nwe.
+#
+# Default mode: install a prebuilt net.exe from this source tree. This keeps the
+# normal mars-nwe build independent from Open Watcom.
+#
+# Maintainer mode: configure with -DMARS_NWE_BUILD_DOSUTILS=ON to rebuild
+# net.exe with Open Watcom v2 on Linux.
+
+set(MARS_DOSUTILS_NET_EXE
+    "${CMAKE_CURRENT_SOURCE_DIR}/net.exe"
+    CACHE FILEPATH "Prebuilt DOS net.exe used for installation when MARS_NWE_BUILD_DOSUTILS is OFF"
+)
+
+set(MARS_DOSUTILS_PUBLIC_TOOLS
+    net
+    login
+    profile
+    spawn
+    passwd
+    path
+    pathins
+    pathdel
+    map
+    mapdel
+    logout
+    capture
+    endcap
+)
+
+# Do not install slist.exe yet: func_slist() is empty and SLIST is disabled in net.c.
+# Do not install tests/debug by default either; they are developer-only helpers.
+
+if(MARS_NWE_BUILD_DOSUTILS)
+    find_package(OpenWatcom REQUIRED)
+
+    set(DOSUTILS_C_SOURCES
+        net.c
+        tools.c
+        netcall.c
+        ncpcall.c
+        login.c
+        map.c
+        nwcrypt.c
+        nwdebug.c
+        nwtests.c
+        capture.c
+    )
+
+    add_custom_command(
+        OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/kern.obj"
+        COMMAND "${CMAKE_COMMAND}" -E env ${OPENWATCOM_ENV}
+                "${OPENWATCOM_WASM}"
+                -q
+                -zq
+                -fo="${CMAKE_CURRENT_BINARY_DIR}/kern.obj"
+                "${CMAKE_CURRENT_SOURCE_DIR}/kern_wasm.asm"
+        DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/kern_wasm.asm"
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        VERBATIM
+    )
+
+    add_custom_command(
+        OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/net.exe"
+        COMMAND "${CMAKE_COMMAND}" -E env ${OPENWATCOM_ENV}
+                "${OPENWATCOM_WCL}"
+                -q
+                -zq
+                -bt=dos
+                -ml
+                -0
+                -k32768
+                -fe="${CMAKE_CURRENT_BINARY_DIR}/net.exe"
+                ${DOSUTILS_C_SOURCES}
+                "${CMAKE_CURRENT_BINARY_DIR}/kern.obj"
+        DEPENDS
+                ${DOSUTILS_C_SOURCES}
+                "${CMAKE_CURRENT_BINARY_DIR}/kern.obj"
+                net.h
+                kern.h
+                nwcrypt.h
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        VERBATIM
+    )
+
+    add_custom_target(dosutils_net ALL
+        DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/net.exe"
+    )
+
+    set(MARS_DOSUTILS_NET_EXE "${CMAKE_CURRENT_BINARY_DIR}/net.exe")
+else()
+    if(NOT EXISTS "${MARS_DOSUTILS_NET_EXE}")
+        message(FATAL_ERROR
+            "Prebuilt DOS utility missing: ${MARS_DOSUTILS_NET_EXE}. "
+            "Either commit net.exe into dosutils or configure with "
+            "-DMARS_NWE_BUILD_DOSUTILS=ON and Open Watcom installed."
+        )
+    endif()
+endif()
+
+foreach(tool IN LISTS MARS_DOSUTILS_PUBLIC_TOOLS)
+    if(tool STREQUAL "net")
+        install(FILES "${MARS_DOSUTILS_NET_EXE}"
+            DESTINATION "${MARS_NWE_INSTALL_FULL_FILEDIR}/SYS/public")
+    else()
+        install(FILES "${MARS_DOSUTILS_NET_EXE}"
+            DESTINATION "${MARS_NWE_INSTALL_FULL_FILEDIR}/SYS/public"
+            RENAME "${tool}.exe")
+    endif()
+endforeach()
+
+install(FILES "${MARS_DOSUTILS_NET_EXE}"
+    DESTINATION "${MARS_NWE_INSTALL_FULL_FILEDIR}/SYS/login"
+    RENAME login.exe)
+
+install(FILES "${MARS_DOSUTILS_NET_EXE}"
+    DESTINATION "${MARS_NWE_INSTALL_FULL_FILEDIR}/SYS/login"
+    RENAME map.exe)

README.md

@@ -0,0 +1,331 @@
+# mars_dosutils
+
+DOS client-side utilities for **mars_nwe** and compatible NetWare-style NCP environments.
+
+This repository contains the source for a small DOS utility suite built around a **single multi-call executable**, `net.exe`. The program can be used either as:
+
+- `net <command> [args...]`, or
+- a renamed executable such as `login.exe`, `map.exe`, `capture.exe`, or `logout.exe`
+
+That design is explicit in the command table in `net.c`, and the install rules also deploy the same binary under multiple command names. The original project documentation describes it as a “simple DOS-client program to allow standard NCP network actions, mainly for mars_nwe,” and also notes that it was still incomplete at the time of writing. 
+
+## Features
+
+- Login and logout against an NCP server
+- Password change support
+- DOS drive mapping and unmapping
+- Search-path management (`PATH`, `PATHINS`, `PATHDEL`)
+- Printer capture and release (`CAPTURE`, `ENDCAP`)
+- Scripted session setup through command files
+- External program execution via `SPAWN` and `EXEC`
+- Optional mars_nwe debug control hooks
+
+## Available commands
+
+The current command dispatcher includes these built-ins:
+
+- `LOGIN`
+- `LOGOUT`
+- `PASSWD`
+- `PROFILE`
+- `SPAWN`
+- `EXEC`
+- `MAP`
+- `MAPDEL`
+- `PATH`
+- `PATHINS`
+- `PATHDEL`
+- `CAPTURE`
+- `ENDCAP`
+- `DEBUG`
+- `ECHO`
+- `CD`
+- `TESTS` (developer/testing only)
+
+`SLIST` is present in the historical build/install metadata, but the command is disabled in the dispatcher and the provided `slist.c` is only a stub in this source snapshot. 
+
+## How it works
+
+The program resolves the command from either:
+
+1. the executable name itself, or
+2. the first command-line argument
+
+That means all of the following styles are valid:
+
+```text
+NET LOGIN alice secret
+NET MAP F:=SYS:
+LOGIN.EXE alice secret
+MAP.EXE F:=SYS:
+CAPTURE.EXE LPT1 Q1
+```
+
+This is one of the key design ideas of the project, and the original README specifically recommends copying or linking `net.exe` to `login.exe` for convenience. 
+
+## Command reference
+
+### `LOGIN`
+
+Authenticate to an NCP server as a user.
+
+```text
+LOGIN [-u] [user | user password]
+```
+
+- `-u` forces the older unencrypted login path.
+- If no username is provided, the tool prompts interactively. 
+- If no password is provided, it prompts for one after the username. 
+- Successful login clears and rebuilds NetWare search-path state before running a local post-login script named `login` from the executable directory. 
+
+### `LOGOUT`
+
+Log out from the current NCP session.
+
+The implementation also removes configured network search paths before performing logout. 
+
+### `PASSWD`
+
+Change a user password.
+
+```text
+PASSWD [user]
+```
+
+Notes:
+
+- If no username is supplied, the tool attempts to resolve the currently logged-in user. fileciteturn1file2L162-L190
+- The source comments note that password changes currently use the older unencrypted password-change call. 
+
+### `PROFILE`
+
+Execute a command script.
+
+```text
+PROFILE <filename>
+```
+
+This is a central part of the workflow. The command reader parses non-empty lines, ignores `#` comments, uppercases the command token, and dispatches it through the same internal command table used for direct invocation. `ECHO` is treated specially so the rest of the line is preserved as a single string. 
+
+### `SPAWN`
+
+Run an external program and wait for it to finish.
+
+### `EXEC`
+
+Execute an external program using overlay-style execution.
+
+Both commands share the same implementation and differ only in whether they use `spawnvp(..., P_WAIT, ...)` or `execvp(...)`. 
+
+### `MAP`
+
+List current drive mappings or map a DOS drive letter to a network path.
+
+```text
+MAP [d:[=[path]]]
+```
+
+Examples:
+
+```text
+MAP
+MAP F:=SYS:
+MAP H:=HOME:
+```
+
+The implementation lists active mappings, distinguishes local vs. redirected drives, and uses DOS-style drive letters. 
+
+### `MAPDEL`
+
+Remove an existing drive mapping.
+
+```text
+MAPDEL d:
+```
+
+Example:
+
+```text
+MAPDEL F:
+```
+
+### `PATH`
+
+List or set a search-path entry.
+
+```text
+PATH sn:[=[path]]
+```
+
+Where `sn` is `s1` through `s16`. The original documentation notes that this updates the path environment rather than directly creating a drive mapping. 
+
+### `PATHINS`
+
+Insert a search-path entry instead of overwriting one.
+
+```text
+PATHINS sn:[=[path]]
+```
+
+### `PATHDEL`
+
+Delete a search-path entry.
+
+```text
+PATHDEL sn:
+```
+
+### `CAPTURE`
+
+List printer captures or redirect a local printer device to a queue.
+
+Typical usage:
+
+```text
+CAPTURE [device [queue]]
+```
+
+Examples:
+
+```text
+CAPTURE
+CAPTURE LPT1 Q1
+CAPTURE PRN Q1
+```
+
+`PRN` is normalized to `LPT1` internally. The command can also display existing captures. 
+
+### `ENDCAP`
+
+Cancel a printer redirection.
+
+Typical usage:
+
+```text
+ENDCAP device
+```
+
+Example:
+
+```text
+ENDCAP LPT1
+```
+
+### `DEBUG`
+
+Set mars_nwe debug levels for selected server-side modules.
+
+```text
+DEBUG NCPSERV|NWCONN|NWBIND level
+```
+
+- `level` must be between `0` and `99`. 
+- The original docs say this requires `FUNC_17_02_IS_DEBUG` to be enabled in `mars_nwe/config.h`. 
+
+### `ECHO`
+
+Print a string, mainly for use inside profile/login scripts. 
+
+### `CD`
+
+Change the current DOS directory. It also adjusts the active drive if a drive-qualified path is supplied. 
+
+### `TESTS`
+
+Internal developer test routines. Not intended as a regular end-user command. 
+
+## Login script workflow
+
+A particularly important feature is the automatic execution of a file named `login` located beside the executable after a successful login. The historical README gives this example:
+
+```text
+map     f:=SYS:
+map     h:=home:
+map     z:=SYS:PUBLIC
+path    s16:=z:.
+capture lpt1 q1
+profile h:\profile
+```
+
+This makes the tool suite useful not just for authentication, but for setting up a full DOS network session: drive mappings, search paths, printer capture, and then a user-specific profile script. 
+
+## Building
+
+### Historical DOS build
+
+The included `makefile.bcc` is the primary historical build file and targets **Borland C / Borland tools** on DOS.
+
+Key settings from the makefile:
+
+- compiler: `bcc`
+- linker: `bcc`
+- assembler: `tasm`
+- memory model: `-ml`
+- define: `-Dmsdos`
+- output: `net.exe`
+
+The object list includes:
+
+- `net.c`
+- `tools.c`
+- `netcall.c`
+- `ncpcall.c`
+- `login.c`
+- `map.c`
+- `slist.c`
+- `nwcrypt.c`
+- `nwdebug.c`
+- `nwtests.c`
+- `capture.c`
+- `kern.asm`
+
+
+### CMake status
+
+A `CMakeLists.txt` is present, but in this snapshot it is only a **partial modern build description**. It defines include paths, version-related macros, and install rules, while the actual `add_executable(...)` line is still commented out. That means it is better understood as packaging metadata than a ready-to-use complete build system. 
+
+## Installation layout
+
+The CMake install rules deploy the same binary multiple times into `SYS/public`:
+
+- `net.exe`
+- `login.exe`
+- `profile.exe`
+- `spawn.exe`
+- `passwd.exe`
+- `path.exe`
+- `pathins.exe`
+- `pathdel.exe`
+- `map.exe`
+- `mapdel.exe`
+- `logout.exe`
+- `slist.exe`
+- `capture.exe`
+- `endcap.exe`
+
+They also install minimal `login.exe` and `map.exe` copies into `SYS/login`. 
+
+## Project status and limitations
+
+This is legacy DOS networking code from the mid-1990s, and a few caveats are worth keeping in mind:
+
+- The original README explicitly says the program was still incomplete. 
+- `SLIST` is not implemented in the provided source snapshot. 
+- Parts of the authentication and password-change path still rely on older unencrypted operations when the newer keyed flow is unavailable or disabled. 
+- The code is tightly coupled to DOS, IPX/NCP behavior, and mars_nwe-specific expectations.
+
+## Historical metadata
+
+From the included project metadata:
+
+- project: `mars_dosutils`
+- version: `0.10`
+- entered: `21-May-96`
+- keywords: `mars_nwe`, `dos`, `dosemu`
+- platforms: `DOS`, `DOSEMU`
+- author/maintainer: Martin Stover
+
+
+## License
+
+No standalone license file is included in the provided snapshot. The source files do contain copyright notices naming **Martin Stover**. Anyone planning to redistribute or modernize the project should verify licensing status before publishing derivative releases. 

capture.c

@@ -0,0 +1,80 @@
+/* capture.c 05-Apr-96 */
+
+/****************************************************************
+ * (C)opyright (C) 1993,1996  Martin Stover, Marburg, Germany   *
+ ****************************************************************/
+
+#include "net.h"
+
+static int usage(void)
+{
+  fprintf(stderr, "usage:\t%s  level\n", funcname);
+  fprintf(stderr, "\tlevel=0 .. 99\n" );
+  return(-1);
+}
+
+static int parse_argv(uint8 *devname, uint8 *queuename,
+                  int argc, char *argv[], int parsemode)
+{
+  int  k      = 0;
+  *devname    = '\0';
+  *queuename  = '\0';
+  while (++k < argc) {
+    uint8 *p  = argv[k];
+    if (k == 1) {
+      strmaxcpy(devname,   p, 20);
+      upstr(devname);
+      if (!strcmp(devname, "PRN"))
+        strcpy(devname, "LPT1");
+    } else if (k == 2) {
+      strmaxcpy(queuename, p, 20);
+      upstr(queuename);
+    }
+  }
+  return(0);
+}
+
+static int do_capture(uint8 *drvstr, uint8 *queuestr, int delete)
+{
+  int result = redir_device_drive(delete ? -1 : 0x3, drvstr, queuestr);
+  return(result);
+}
+
+static int show_capture(uint8 *drvstr)
+{
+  int result;
+  int k =-1;
+  uint8 devname[20];
+  uint8 remotename[130];
+  int  devicetyp;
+  while ((result = list_redir(++k, &devicetyp, devname, remotename)) > -1){
+    if (result > -1 && devicetyp == 0x3) {
+      upstr(devname);
+      upstr(remotename);
+      if (!drvstr || !*drvstr || !strcmp(devname, drvstr))
+        fprintf(stdout, "%-10s captured to %s\n", devname, remotename);
+    }
+  }
+  return(result);
+}
+
+int func_capture(int argc, char *argv[], int mode)
+{
+  uint8  devname [22];
+  uint8  queuestr[22];
+  if (!parse_argv(devname, queuestr, argc, argv, mode)) {
+    int result=0;
+    if (*queuestr || mode == 1) {
+      result=do_capture(devname, queuestr, mode);
+      if (result< 0)
+        fprintf(stderr, "capture error:%d, device:%s \n", result, devname);
+    }
+    if (mode != 1)
+      show_capture(devname);
+    else if (result > -1)
+      fprintf(stdout, "Capture of %s removed\n", devname);
+    return(result);
+  }
+  return(1);
+}
+

doc

@@ -1,46 +0,0 @@
-/* DOC for NET.EXE */
-This is a short description of net.exe which is a simple DOS-client
-programm to allow standard NCP network actions, mainly for mars_nwe.
-All functions are called as a second parameter.
-This programm is very incomplete till now, but some functions
-works well with mars_nwe.
-
-LOGOUT:
-Logout from a NCP Server.
-
-LOGIN:
-usage: LOGIN [-u] [user | user password]
--u = use unencrypted password.
-With this function you can log into a NCP Server.
-Its only make a login, no mappings or something else.
-
-If you want a login similar to NOVELL's login.exe you should
-do it with a batch job.
-
-example:
-[\LOGIN\LOGIN.BAT]
-@echo OFF
-net logout
-net login %1 %2 %3
-if errorlevel 1 goto :end
-map h:=HOME:
-if not exist h:\profile.bat goto :end
-h:
-profile.bat
-:end
-
-PASSWD:
-usage: PASSWD [user]
-With this function you are able to change a users password.
-This call uses the old unencryted change password call !!
-
-
-PATH:
-usage: PATH sn:[=[path]]
-       sn = 's1' .. 's16'
-
-With this function a new path element can be created.
-Its only sets the path environment.
-
-
-

doc/README

@@ -0,0 +1,93 @@
+/* DOC for NET.EXE */
+/* last updated: 21-May-96 */
+This is a short description of net.exe which is a simple DOS-client
+program to allow standard NCP network actions, mainly for mars_nwe.
+All functions are called as a second parameter, or if the program
+is renamed to a guilty function like login.exe then the function
+will be the progname. This is very usefull for login.exe.
+
+This program is very incomplete till now, but some functions
+works well with mars_nwe.
+
+
+LOGIN:
+usage: LOGIN [-u] [user | user password]
+-u = use unencrypted password.
+With this function you can log into a NCP Server.
+If there exists a 'login' file in the same directory as
+net.exe resides then this file will be interpreted as a
+command file. You also can use command files with
+the PROFILE command.
+It is usefull to copy (or do a Linux link) net.exe to login.exe.
+
+example for a 'login' script (resides in same directory as net.exe)
+
+map     f:=SYS:
+map     h:=home:
+map     z:=SYS:PUBLIC
+path    s16:=z:.
+capture lpt1 q1
+profile h:\profile      # will call users home 'profile'
+
+if not exist h:\profile.bat goto :end
+
+
+PROFILE:
+usage: PROFILE filename
+With this function you are able to run a command script.
+In this command script you can use every net.exe command.
+
+SPAWN:
+With SPAWN you can start external programs.
+
+PASSWD:
+usage: PASSWD [user]
+With this function you are able to change a users password.
+This call uses the old unencryted change password call !!
+
+PATH:
+usage: PATH sn:[=[path]]
+       sn = 's1' .. 's16'
+
+With this function a new path element can be created.
+Its only sets the path environment !
+
+PATHINS:
+usage: PATHINS sn:[=[path]]
+       sn = 's1' .. 's16'
+like PATH, but inserts PATH, not overwrites.
+
+PATHDEL:
+usage: PATHDEL sn:
+       sn = 's1' .. 's16'
+deletes PATH element
+
+MAP:
+usage: MAP [d:[=[path]]]
+       d = 'A' .. 'Z'
+Maps a drive to a volume or volume/path.
+
+
+MAPDEL:
+usage: MAPDEL d:
+       d = 'A' .. 'Z'
+Removes a map.
+
+
+LOGOUT:
+Logout from a NCP Server.
+
+DEBUG:
+For setting debug flag in mars_nwe processes.
+If you want to use this, you must set
+mars_nwe/config.h: FUNC_17_02_IS_DEBUG to '1'
+
+
+SPAWN:
+EXEC:
+external program execution spawning or overlayed.
+
+
+
+
+

doc/mars_dosutils.lsm

@@ -0,0 +1,16 @@
+Begin3
+Title:          mars_dosutils
+Version:        0.10
+Entered-date:   21-May-96
+
+Description:    Simple DOS client program specially
+                for mars_nwe.
+                Supports login, map, capture, passwd
+                Binary + sourcen
+Keywords:       novell, netware, client, ipx, ncp, mars_nwe
+Author:         mstover@freeway.de  (Martin Stover)
+Maintained-by:  mstover@freeway.de  (Martin Stover)
+Primary-site:   ftp.gwdg.de:/pub/linux/misc/ncpfs
+                60kB mars_dosutils-0.10.tgz
+Platforms:      DOS, DOSEMU
+End

kern.h

@@ -1,12 +1,20 @@
-/* kern.h  Assembler Routinen 20-Nov-93 */
+/* kern.h  Assembler Routinen 20-Nov-93 */
-extern int   IPXinit(void);
+#if defined(__WATCOMC__)
-extern int   IPXopen_socket(UI sock, int live);
+#define KERN_CALL _Cdecl
-extern void  IPXclose_socket(UI sock);
+#else
-extern int   IPXlisten(ECB *ecb);
+#define KERN_CALL
-extern void  asm_esr_routine(void);
+#endif
-extern void  esr_routine(ECB *ecb);
+
-extern void  xmemmove(void *ziel, void *quelle, UI anz);
+extern int   KERN_CALL IPXinit(void);
-extern int   Net_Call(UI func, void *req, void *repl);
+extern int   KERN_CALL IPXopen_socket(UI sock, int live);
-
+extern void  KERN_CALL IPXclose_socket(UI sock);
-
+extern int   KERN_CALL IPXlisten(ECB *ecb);
-
+extern void  asm_esr_routine(void);
+extern void  esr_routine(ECB *ecb);
+extern void  KERN_CALL xmemmove(void *ziel, void *quelle, UI anz);
+extern int   KERN_CALL Net_Call(UI func, void *req, void *repl);
+
+#undef KERN_CALL
+
+
+

kern.lst

@@ -1,317 +0,0 @@
-Turbo Assembler	 Version 3.1	    28/04/96 13:28:50	    Page 1
-kern.asm
-
-
-
-      1				     ; kern.asm: 20-Nov-93, 21:52
-      2				     IDEAL
-      3				     P286
-      4	0000			     MODEL LARGE
-      5				     ; Fuer Turboc gerettet werden muessen folgende Register:
-      6				     ; BP, SS, SP, DS, CS u. SI, DI
-      7
-      8				     MACRO P_START
-      9					push	bp
-     10					mov	bp, sp
-     11				     ENDM
-     12
-     13				     MACRO P_END
-     14					pop	bp
-     15				     ENDM
-     16
-     17				     MACRO PUSH_REGS
-     18					push	ds
-     19					push	si
-     20					push	di
-     21				     ENDM
-     22
-     23				     MACRO POP_REGS
-     24					pop	di
-     25					pop	si
-     26					pop	ds
-     27				     ENDM
-     28
-     29				     ;;	EXTRN	_esr_routine:FAR
-     30
-     31				     PUBLIC  _IPXinit;
-     32				     PUBLIC  _IPXopen_socket;
-     33				     PUBLIC  _IPXclose_socket;
-     34				     PUBLIC  _IPXlisten;
-     35				     ;;	PUBLIC	_asm_esr_routine;
-     36				     PUBLIC  _xmemmove;
-     37				     PUBLIC  _Net_Call;
-     38
-     39	0000			     DATASEG
-     40	0000  0000FFFE		     enterIPX  DD FAR
-     41
-     42	0004			     CODESEG
-     43	0000			     PROC _IPXinit;
-     44					P_START
-1    45	0000  55			push	bp
-1    46	0001  8B EC			mov	bp, sp
-     47					PUSH_REGS
-1    48	0003  1E			push	ds
-1    49	0004  56			push	si
-1    50	0005  57			push	di
-     51	0006  B8 7A00			mov	ax,  7A00h
-     52	0009  CD 2F			int	2Fh
-     53	000B  3C FF			cmp	al,  0FFh
-     54	000D  75 10			jne	@@fertig
-     55	000F  B9 0000s			mov	cx, @data
-     56	0012  8E D9			mov	ds, cx
-     57	0014  89 3E 0000r		mov	[WORD PTR enterIPX],   di
-Turbo Assembler	 Version 3.1	    28/04/96 13:28:50	    Page 2
-kern.asm
-
-
-
-     58	0018  8C C0			mov	ax, es
-     59	001A  A3 0002r			mov	[WORD PTR enterIPX+2], ax
-     60	001D  B0 01			mov	al, 1 ;	OK
-     61	001F			     @@fertig:
-     62	001F  B4 00			mov    ah, 0
-     63					POP_REGS
-1    64	0021  5F			pop	di
-1    65	0022  5E			pop	si
-1    66	0023  1F			pop	ds
-     67					P_END
-1    68	0024  5D			pop	bp
-     69	0025  CB			ret	    ;  OK = 1 ;	nicht ok = 0
-     70	0026			     ENDP
-     71
-     72	0026			     PROC  _xmemmove;
-     73					   ARG	   z:DATAPTR, q:DATAPTR, nmbr:WORD; Argumente
-     74	0026  FA			   cli		   ; Disable Interrupts
-     75	0027  55			   push	   bp
-     76	0028  8B EC			   mov	   bp,sp
-     77	002A  8B 4E 0E			   mov	   cx, [nmbr];
-     78	002D  0B C9			   or	   cx, cx;
-     79	002F  74 1F			   jz	   @@fertig; Anzahl ist	0;
-     80	0031  1E			   push	   ds;
-     81	0032  56			   push	   si;
-     82	0033  57			   push	   di;
-     83	0034  9C			   pushf
-     84	0035  C5 76 0A			   lds	   si, [q] ; Quelle
-     85	0038  C4 7E 06			   les	   di, [z] ; Ziel
-     86	003B  3B FE			   cmp	   di, si  ;
-     87	003D  7C 0A			   jl	   @@L1	   ; Ziel ist kleiner
-     88	003F  FD			   std		   ; Richtungsflag setzen
-     89	0040  49			   dec	   cx
-     90	0041  03 F9			   add	   di, cx  ; Von oben nach unten kopieren
-     91	0043  03 F1			   add	   si, cx  ;
-     92	0045  41			   inc	   cx	   ; alten Wert	wiederherstellen
-     93	0046  EB 02 90			   jmp	   @@L2;
-     94	0049				   @@L1:
-     95	0049  FC			   cld		   ; Richtungsflag loeschen
-     96	004A				   @@L2:	   ; und nun das eigentliche kopieren
-     97	004A  F3> A4			   REP	   movsb   ;
-     98	004C  9D			   popf
-     99	004D  5F			   pop	   di;
-    100	004E  5E			   pop	   si;
-    101	004F  1F			   pop	   ds;
-    102	0050				   @@fertig:
-    103	0050  5D			   pop	   bp;
-    104	0051  FB			   sti		   ; enable Interrupts
-    105	0052  CB			   ret
-    106	0053			     ENDP
-    107
-    108	0053			     PROC  _IPXopen_socket;
-    109					   ARG	sock:WORD, live:WORD
-    110					   P_START
-1   111	0053  55			push	bp
-1   112	0054  8B EC			mov	bp, sp
-    113					   PUSH_REGS
-1   114	0056  1E			push	ds
-Turbo Assembler	 Version 3.1	    28/04/96 13:28:50	    Page 3
-kern.asm
-
-
-
-1   115	0057  56			push	si
-1   116	0058  57			push	di
-    117	0059  8B 46 08			   mov	   ax, [live]
-    118	005C  8B 56 06			   mov	   dx, [sock]
-    119	005F  BB 0000s			   mov	   bx, @data
-    120	0062  8E DB			   mov	   ds, bx
-    121	0064  BB 0000			   mov	   bx, 0
-    122	0067  FF 1E 0000r		   call	   [enterIPX]
-    123	006B  3C FF			   cmp	   al,	0FFh
-    124	006D  75 06			   jne	   @@L1
-    125	006F  B8 FFFF			   mov	   ax, -1 ; Socket already open
-    126	0072  EB 0D 90			   jmp	   @@L3
-    127	0075			     @@L1:
-    128	0075  3C FE			   cmp	   al,	0FEh
-    129	0077  75 06			   jne	   @@L2
-    130	0079  B8 FFFE			   mov	   ax, -2 ; Socket Table full
-    131	007C  EB 03 90			   jmp	   @@L3
-    132	007F			     @@L2:
-    133	007F  8B C2			   mov	   ax, dx
-    134	0081			     @@L3:
-    135					   POP_REGS
-1   136	0081  5F			pop	di
-1   137	0082  5E			pop	si
-1   138	0083  1F			pop	ds
-    139					   P_END
-1   140	0084  5D			pop	bp
-    141	0085  CB			   ret
-    142	0086			     ENDP
-    143
-    144	0086			     PROC  _IPXclose_socket;
-    145					   ARG	sock:WORD
-    146					   P_START
-1   147	0086  55			push	bp
-1   148	0087  8B EC			mov	bp, sp
-    149					   PUSH_REGS
-1   150	0089  1E			push	ds
-1   151	008A  56			push	si
-1   152	008B  57			push	di
-    153	008C  8B 56 06			   mov	   dx, [sock]
-    154	008F  BB 0000s			   mov	   bx, @data
-    155	0092  8E DB			   mov	   ds, bx
-    156	0094  BB 0001			   mov	   bx, 1
-    157	0097  FF 1E 0000r		   call	   [enterIPX]
-    158					   POP_REGS
-1   159	009B  5F			pop	di
-1   160	009C  5E			pop	si
-1   161	009D  1F			pop	ds
-    162					   P_END
-1   163	009E  5D			pop	bp
-    164	009F  CB			   ret
-    165	00A0			     ENDP
-    166
-    167	00A0			     PROC  _IPXlisten;
-    168					   ARG	ecb:DATAPTR
-    169					   P_START
-1   170	00A0  55			push	bp
-1   171	00A1  8B EC			mov	bp, sp
-Turbo Assembler	 Version 3.1	    28/04/96 13:28:50	    Page 4
-kern.asm
-
-
-
-    172					   PUSH_REGS
-1   173	00A3  1E			push	ds
-1   174	00A4  56			push	si
-1   175	00A5  57			push	di
-    176	00A6  C4 76 06			   les	   si, [ecb] ; Adresse ecb
-    177	00A9  BB 0000s			   mov	   bx, @data
-    178	00AC  8E DB			   mov	   ds, bx
-    179	00AE  BB 0004			   mov	   bx, 4
-    180	00B1  FF 1E 0000r		   call	   [enterIPX]
-    181					   POP_REGS
-1   182	00B5  5F			pop	di
-1   183	00B6  5E			pop	si
-1   184	00B7  1F			pop	ds
-    185					   P_END
-1   186	00B8  5D			pop	bp
-    187	00B9  B4 00			   mov	ah, 0
-    188	00BB  CB			   ret
-    189	00BC			     ENDP
-    190
-    191				     ;;	PROC  _asm_esr_routine;
-    192				     ;;	      push    bp;
-    193				     ;;	      PUSH_REGS;
-    194				     ;;	      mov     ax, @data
-    195				     ;;	      mov     ds, ax	 ;  F<>r	C PROGRAMM
-    196				     ;;	      push    es; Adressegment vom EBC
-    197				     ;;	      push    si; Adressoffset vom ECB
-    198				     ;;	      call    _esr_routine;  C ROUTINE
-    199				     ;;	      pop     si;
-    200				     ;;	      pop     es;
-    201				     ;;	      POP_REGS;
-    202				     ;;	      pop     bp;
-    203				     ;;	      cli   ; no Interrupt says	NOVELL
-    204				     ;;	      ret
-    205				     ;;	ENDP
-    206
-    207
-    208	00BC			     PROC  _Net_Call;
-    209					   ARG	   func:WORD, req:DATAPTR, repl:DATAPTR; Argumente
-    210	00BC  55			   push	   bp
-    211	00BD  8B EC			   mov	   bp, sp
-    212	00BF  8B 46 06			   mov	   ax, [func];
-    213	00C2  1E			   push	   ds;
-    214	00C3  56			   push	   si;
-    215	00C4  57			   push	   di;
-    216	00C5  9C			   pushf
-    217	00C6  C5 76 08			   lds	   si, [req]  ;	Request
-    218	00C9  C4 7E 0C			   les	   di, [repl] ;	Reply
-    219	00CC  CD 21			   int	   21h
-    220	00CE  9D			   popf
-    221	00CF  5F			   pop	   di;
-    222	00D0  5E			   pop	   si;
-    223	00D1  1F			   pop	   ds;
-    224	00D2  5D			   pop	   bp;
-    225	00D3  B4 00			   mov	   ah, 0
-    226	00D5  CB			   ret
-    227	00D6			     ENDP
-    228
-Turbo Assembler	 Version 3.1	    28/04/96 13:28:50	    Page 5
-kern.asm
-
-
-
-    229				     END
-Turbo Assembler	 Version 3.1	    28/04/96 13:28:50	    Page 6
-Symbol Table
-
-
-
-
-Symbol Name			  Type	 Value
-
-??DATE				  Text	 "28/04/96"
-??FILENAME			  Text	 "kern	  "
-??TIME				  Text	 "13:28:50"
-??VERSION			  Number 030A
-@32BIT				  Text	 0
-@@FERTIG			  Near	 KERN_TEXT:001F
-@@FERTIG			  Near	 KERN_TEXT:0050
-@@L1				  Near	 KERN_TEXT:0049
-@@L1				  Near	 KERN_TEXT:0075
-@@L2				  Near	 KERN_TEXT:004A
-@@L2				  Near	 KERN_TEXT:007F
-@@L3				  Near	 KERN_TEXT:0081
-@CODE				  Text	 KERN_TEXT
-@CODESIZE			  Text	 1
-@CPU				  Text	 0787H
-@CURSEG				  Text	 KERN_TEXT
-@DATA				  Text	 DGROUP
-@DATASIZE			  Text	 1
-@FILENAME			  Text	 KERN
-@INTERFACE			  Text	 00H
-@MODEL				  Text	 5
-@STACK				  Text	 DGROUP
-@WORDSIZE			  Text	 2
-ECB				  Number [DGROUP:BP+0006]
-ENTERIPX			  Dword	 DGROUP:0000
-FUNC				  Number [DGROUP:BP+0006]
-LIVE				  Number [DGROUP:BP+0008]
-NMBR				  Number [DGROUP:BP+000E]
-Q				  Number [DGROUP:BP+000A]
-REPL				  Number [DGROUP:BP+000C]
-REQ				  Number [DGROUP:BP+0008]
-SOCK				  Number [DGROUP:BP+0006]
-Z				  Number [DGROUP:BP+0006]
-_IPXCLOSE_SOCKET	       +  Far	 KERN_TEXT:0086
-(_IPXclose_socket)
-_IPXINIT (_IPXinit)		  Far	 KERN_TEXT:0000
-_IPXLISTEN (_IPXlisten)		  Far	 KERN_TEXT:00A0
-_IPXOPEN_SOCKET		       +  Far	 KERN_TEXT:0053
-(_IPXopen_socket)
-_NET_CALL (_Net_Call)		  Far	 KERN_TEXT:00BC
-_XMEMMOVE (_xmemmove)		  Far	 KERN_TEXT:0026
-
-Macro Name
-
-POP_REGS
-PUSH_REGS
-P_END
-P_START
-
-Groups & Segments		  Bit Size Align  Combine Class
-
-DGROUP				  Group
-  _DATA				  16  0004 Word	  Public  DATA
-KERN_TEXT			  16  00D6 Word	  Public  CODE
-

kern_wasm.asm

@@ -0,0 +1,216 @@
+; kern_wasm.asm
+;
+; Open Watcom WASM/MASM-syntax port of the old TASM IDEAL kern.asm.
+; Intended for 16-bit DOS large memory model builds on Linux with Open Watcom v2.
+;
+; Keep kern.asm as the historical TASM source and use this file for the
+; reproducible Open Watcom build.
+
+.286
+.model large
+
+.data
+enterIPX dd 0
+
+.code
+
+public  _IPXinit
+public  _IPXopen_socket
+public  _IPXclose_socket
+public  _IPXlisten
+public  _xmemmove
+public  _Net_Call
+
+_IPXinit proc far
+        push    bp
+        mov     bp, sp
+        push    ds
+        push    si
+        push    di
+
+        mov     ax, 7A00h
+        int     2Fh
+        cmp     al, 0FFh
+        jne     ipxinit_done
+
+        mov     cx, @data
+        mov     ds, cx
+        mov     word ptr enterIPX, di
+        mov     ax, es
+        mov     word ptr enterIPX+2, ax
+        mov     al, 1
+
+ipxinit_done:
+        mov     ah, 0
+
+        pop     di
+        pop     si
+        pop     ds
+        pop     bp
+        ret
+_IPXinit endp
+
+_xmemmove proc far
+        push    bp
+        mov     bp, sp
+
+        ; far procedure stack layout, large model:
+        ; [bp+0]  old bp
+        ; [bp+2]  return offset
+        ; [bp+4]  return segment
+        ; [bp+6]  z offset
+        ; [bp+8]  z segment
+        ; [bp+10] q offset
+        ; [bp+12] q segment
+        ; [bp+14] nmbr
+
+        cli
+        mov     cx, [bp+14]
+        or      cx, cx
+        jz      xmem_done
+
+        push    ds
+        push    si
+        push    di
+        pushf
+
+        lds     si, dword ptr [bp+10]
+        les     di, dword ptr [bp+6]
+        cmp     di, si
+        jl      xmem_forward
+
+        std
+        dec     cx
+        add     di, cx
+        add     si, cx
+        inc     cx
+        jmp     xmem_copy
+
+xmem_forward:
+        cld
+
+xmem_copy:
+        rep     movsb
+
+        popf
+        pop     di
+        pop     si
+        pop     ds
+
+xmem_done:
+        pop     bp
+        sti
+        ret
+_xmemmove endp
+
+_IPXopen_socket proc far
+        push    bp
+        mov     bp, sp
+        push    ds
+        push    si
+        push    di
+
+        ; int IPXopen_socket(UI sock, int live)
+        mov     ax, [bp+8]       ; live
+        mov     dx, [bp+6]       ; sock
+        mov     bx, @data
+        mov     ds, bx
+        mov     bx, 0
+        call    dword ptr enterIPX
+
+        cmp     al, 0FFh
+        jne     ipxopen_not_already
+        mov     ax, -1           ; socket already open
+        jmp     ipxopen_done
+
+ipxopen_not_already:
+        cmp     al, 0FEh
+        jne     ipxopen_ok
+        mov     ax, -2           ; socket table full
+        jmp     ipxopen_done
+
+ipxopen_ok:
+        mov     ax, dx
+
+ipxopen_done:
+        pop     di
+        pop     si
+        pop     ds
+        pop     bp
+        ret
+_IPXopen_socket endp
+
+_IPXclose_socket proc far
+        push    bp
+        mov     bp, sp
+        push    ds
+        push    si
+        push    di
+
+        ; void IPXclose_socket(UI sock)
+        mov     dx, [bp+6]
+        mov     bx, @data
+        mov     ds, bx
+        mov     bx, 1
+        call    dword ptr enterIPX
+
+        pop     di
+        pop     si
+        pop     ds
+        pop     bp
+        ret
+_IPXclose_socket endp
+
+_IPXlisten proc far
+        push    bp
+        mov     bp, sp
+        push    ds
+        push    si
+        push    di
+
+        ; int IPXlisten(ECB *ecb)
+        les     si, dword ptr [bp+6]
+        mov     bx, @data
+        mov     ds, bx
+        mov     bx, 4
+        call    dword ptr enterIPX
+
+        pop     di
+        pop     si
+        pop     ds
+        pop     bp
+        mov     ah, 0
+        ret
+_IPXlisten endp
+
+_Net_Call proc far
+        push    bp
+        mov     bp, sp
+
+        ; int Net_Call(UI func, void *req, void *repl)
+        ; [bp+6]  func
+        ; [bp+8]  req offset
+        ; [bp+10] req segment
+        ; [bp+12] repl offset
+        ; [bp+14] repl segment
+        mov     ax, [bp+6]
+
+        push    ds
+        push    si
+        push    di
+        pushf
+
+        lds     si, dword ptr [bp+8]
+        les     di, dword ptr [bp+12]
+        int     21h
+
+        popf
+        pop     di
+        pop     si
+        pop     ds
+        pop     bp
+        mov     ah, 0
+        ret
+_Net_Call endp
+
+end

login.bat

@@ -1,4 +0,0 @@
-c:\net logout
-c:\net login %1 %2 %3
-map h:=HOME:
-

login.c

@@ -1,4 +1,4 @@
-/* login.c 05-Apr-96 */
+/* login.c 21-May-96 */
 
 /****************************************************************
  * (C)opyright (C) 1993,1996  Martin Stover, Marburg, Germany   *
@@ -7,7 +7,6 @@
 #include "net.h"
 #include "nwcrypt.h"
 
-
 static int do_change_object_passwd(char *name,
                                    uint16 objtyp,
                                    char *oldpassword,
@@ -104,6 +103,7 @@ static int get_raw_str(uint8 *s, int maxlen, int doecho)
 static void getstr(char *what, char *str, int rsize, int doecho)
 {
   fprintf(stdout, "%s: ", what);
+  fflush(stdout);
   get_raw_str(str, rsize, doecho);
   fprintf(stdout, "\n");
 }
@@ -115,12 +115,13 @@ static int login_usage(void)
   return(-1);
 }
 
-int func_login(int argc, char *argv[])
+int func_login(int argc, char *argv[], int mode)
 {
   int result=-1;
   int option=0;
   uint8 uname[200];
   uint8 upasswd[200];
+  SEARCH_VECTOR  save_drives;
 
   if (argc > 1) {
     if (argv[1][0] == '-') {
@@ -130,13 +131,15 @@ int func_login(int argc, char *argv[])
       argv++;
     }
   }
-
+  get_search_drive_vektor(save_drives);
+  remove_nwpathes();
   if (argc > 1) strmaxcpy(uname, argv[1], sizeof(uname) -1);
   else uname[0]='\0';
   if (argc > 2) strmaxcpy(upasswd, argv[2], sizeof(upasswd) -1);
   else upasswd[0]='\0';
+
   while (result) {
-    if (!uname[0]) getstr("login", uname, sizeof(uname)-1, 1);
+    if (!uname[0]) getstr("Login", uname, sizeof(uname)-1, 1);
     if (uname[0]) {
       upstr(uname);
       upstr(upasswd);
@@ -152,16 +155,29 @@ int func_login(int argc, char *argv[])
       }
     } else break;
   }
+  if (result > -1) {
+    char profile[200];
+    remove_nwpathes();
+    sprintf(profile, "%slogin", prgpath);
+    read_command_file(profile);
+  } else {
+    (void)set_search_drive_vektor(save_drives);
+  }
   return(result);
 }
 
-int func_logout(int argc, char *argv[])
+int func_logout(int argc, char *argv[], int mode)
 {
-  if (logout()) fprintf(stderr, "logout=%d", neterrno);
+  remove_nwpathes();
+  if (logout()) {
+    fprintf(stderr, "logout=%d\n", neterrno);
+    return(1);
+  }
+  return(0);
 }
 
 
-int func_passwd(int argc, char *argv[])
+int func_passwd(int argc, char *argv[], int mode)
 {
   int result=0;
   uint8 uname[100];
@@ -169,7 +185,7 @@ int func_passwd(int argc, char *argv[])
   uint32 my_obj_id;
 
   if (ncp_14_46(&my_obj_id) < 0 || my_obj_id == MAX_U32 || !my_obj_id) {
-    fprintf(stderr, "Cannot get actual User ID\n");
+    fprintf(stderr, "Cannot get actual user id\n");
     result = -1;
   }
 
@@ -179,13 +195,13 @@ int func_passwd(int argc, char *argv[])
     upstr(uname);
     obj_id = ncp_17_35(uname,  1);
     if (!obj_id) {
-      fprintf(stderr, "Unkwown User: %s\n", uname);
+      fprintf(stderr, "Unkwown user: %s\n", uname);
       return(-1);
     }
   } else if (!result) {
     uint16 obj_typ;
     if (ncp_17_36(my_obj_id, uname, &obj_typ) || obj_typ != 1) {
-      fprintf(stderr, "Cannot get actual Username\n");
+      fprintf(stderr, "Cannot get actual username\n");
       result=-1;
     }
   }
@@ -194,11 +210,11 @@ int func_passwd(int argc, char *argv[])
     uint8 newpasswd2[130];
     if (my_obj_id == 1L) *upasswd='\0';
     else {
-      getstr("Old Password", upasswd, sizeof(upasswd)-1, 0);
+      getstr("Old password", upasswd, sizeof(upasswd)-1, 0);
       upstr(upasswd);
     }
-    getstr("New Password", newpasswd, sizeof(newpasswd)-1, 0);
+    getstr("New password", newpasswd, sizeof(newpasswd)-1, 0);
-    getstr("New Password again", newpasswd2, sizeof(newpasswd2)-1, 0);
+    getstr("New password again", newpasswd2, sizeof(newpasswd2)-1, 0);
     if (!strcmp(newpasswd, newpasswd2)) {
       upstr(uname);
       upstr(newpasswd);
@@ -213,3 +229,175 @@ int func_passwd(int argc, char *argv[])
   return(result);
 }
 
+static int get_line(FILE *f, char *buff, int bufsize, uint8 *str, int strsize)
+/* returns command line or -1 if ends */
+{
+  if ((FILE*) NULL != f) {
+    while (fgets(buff, bufsize, f) != NULL){
+      char *p       = buff;
+      char *beg     = NULL;
+      char c;
+      int  len=0;
+      while (0 != (c = *p++) && c != '\n' && c != '\r' && c != '#') {
+        if (!beg){
+          if (c != '\t' && c != 32) {
+            beg = p - 1;
+            len = 1;
+          }
+        } else ++len;
+      }
+      if (len) {
+        strmaxcpy((uint8*)str, (uint8*)beg, min(len, strsize-1));
+        return(0);
+      }
+    }
+  }
+  return(-1);
+}
+
+
+
+static char **build_argv(char *buf, int bufsize, char *command)
+/* routine returns **argv for use with execv routines */
+/* buf will contain the path component 	     	      */
+{
+  int len        = strlen(command);
+  int offset     = ((len+4) / 4) * 4; /* aligned offset for **argv */
+  int components = (bufsize - offset) / 4;
+  if (components > 1) {  /* minimal argv[0] + NULL */
+    char **argv  = (char **)(buf+offset);
+    char **pp    = argv;
+    char  *p     = buf;
+    char  c;
+    int   i=0;
+    --components;
+    memcpy(buf, command, len);
+    memset(buf+len, 0, bufsize - len);
+    *pp    = p;
+    while ((0 != (c = *p++)) && i < components) {
+      if (c == 32 || c == '\t') {
+        *(p-1) = '\0';
+        if (*p != 32 && *p != '\t') {
+          *(++pp)=p;
+          i++;
+        }
+      } else if (!i && c == '/') {  /* here i must get argv[0] */
+        *pp=p;
+      }
+    }
+    return(argv);
+  }
+  return(NULL);
+}
+
+int read_command_file(char *fstr)
+{
+  FILE *f=fopen(fstr, "r");
+  int  result=-1;
+  if (f != NULL) {
+    char *linebuf= xmalloc(512);
+    char *buf    = xmalloc(512);
+
+    while (get_line(f, buf, 512, linebuf, 512) > -1) {
+      char **argv=build_argv(buf, 512, linebuf);
+      if (argv != NULL) {
+        int argc=0;
+        char **pp=argv;
+        while (*pp) {
+          argc++;
+          pp++;
+        }
+        upstr(argv[0]);
+        if (argc > 2 && !strcmp(argv[0], "ECHO")) {
+          char *p=argv[argc-1];
+          while (p-- > argv[1]) {
+            if (*p=='\0') *p=32;
+          }
+          argc=2;
+        }
+        call_func_entry(argc, argv);
+        result = 0;
+      }
+    }
+
+    fclose(f);
+    xfree(linebuf);
+    xfree(buf);
+  } else result=-2;
+  return(result);
+}
+
+int func_profile(int argc, char *argv[], int mode)
+{
+  if (argc < 2) {
+    fprintf(stderr, "usage:\t%s fn\n", funcname);
+    return(-1);
+  }
+  if (read_command_file(argv[1]) == -2) {
+    fprintf(stderr, "command file %s not found\n", argv[1]);
+  }
+  return(0);
+}
+
+int func_cwd(int argc, char *argv[], int mode)
+{
+  char pathname[65];
+  int  len;
+  if (argc < 2) {
+    fprintf(stderr, "usage:\t%s path\n", funcname);
+    return(-1);
+  }
+  strmaxcpy(pathname, argv[1], sizeof(pathname) -1);
+  korrpath(pathname);
+  if (0 != (len = strlen(pathname))) {
+    char *p=pathname+len-1;
+    if (*p == '/' || *p == ':') {
+      *(++p) = '.';
+      *(++p) = '\0';
+      len++;
+    }
+    if (!chdir(pathname)) {
+      if (len > 2 && *(pathname+1) == ':')   /* device changed */
+        setdisk(*pathname - 'a' );
+    } else {
+      fprintf(stderr, "cannot chdir to %s\n", pathname);
+      return(1);
+    }
+    return(0);
+  } else return(-1);
+}
+
+int func_echo(int argc, char *argv[], int mode)
+{
+  if (argc > 1)
+    fprintf(stdout, "%s\n", argv[1]);
+  return(0);
+}
+
+int func_exec(int argc, char *argv[], int mode)
+{
+  if (argc > 1)  {
+    char *buf   = xmalloc(512);
+    char *buff  = xmalloc(512);
+    char *p     = buff;
+    int   k     = 0;
+    char **nargv;
+    while (++k < argc) {
+      strcpy(p, argv[k]);
+      p    += strlen(argv[k]);
+      *p++  = 32;
+      *p    = '\0';
+    }
+    nargv=build_argv(buf, 512, buff);
+    xfree(buff);
+    if (nargv != NULL) {
+      if (!mode)
+        spawnvp(P_WAIT, buf, nargv);
+      else
+        execvp(buf, nargv);
+    }
+    xfree(buf);
+  }
+  return(0);
+}
+

makefile.bcc

@@ -21,7 +21,7 @@ RM = del
 ASMODS=  kern$(O)
 CCMODS=  tools$(O) netcall$(O) ncpcall$(O) \
          login$(O) map$(O) slist$(O) nwcrypt$(O) \
-         nwdebug$(O) nwtests$(O)
+         nwdebug$(O) nwtests$(O) capture$(O)
 
 all:      net$(E)
 

map.c

@@ -24,6 +24,7 @@ static void show_map(uint8 *drvstr)
     if ((!get_drive_info(j, &connid, &dhandle, &flags)) && flags){
       char  servern[52];
       char  path[256];
+      servern[0]='\0';
       if (flags & 0x80) { /* lokal DRIVE */
         path[0]= '\\';
         if (j < 2){
@@ -35,11 +36,11 @@ static void show_map(uint8 *drvstr)
         if (get_dir_path(dhandle, path)) {
           strcpy(path, "DHANDLE !OK");
         }
+        if (connid) {
+          get_fs_name(connid, servern);
+          strcat(servern, "\\");
+        } else servern[0]='\0';
       }
-      if (connid) {
-        get_fs_name(connid, servern);
-        strcat(servern, "\\");
-      } else servern[0]='\0';
       printf("MAP %c: = %s%s\n", (char)j+'A', servern, path);
     }
   }
@@ -76,22 +77,27 @@ static void do_map(int drive, NWPATH *nwp)
 }
 #endif
 
-static int do_map(int drive, NWPATH *nwp)
+static int do_map(int drive, NWPATH *nwp, int delete)
 {
   int result = -1;
   if (drive > -1 && drive < 32) {
-    uint8 nmdrive[3];
+    uint8 connid;
-    nmdrive[0] = drive+'A';
+    uint8 dhandle;
-    nmdrive[1] = ':';
+    uint8 flags;
-    nmdrive[2] = '\0';
+    if (!delete ||
-    result = redir_device_drive(0x4, nmdrive, nwp->path);
+      (!get_drive_info(drive, &connid, &dhandle, &flags) && flags && connid)){
+      uint8 nmdrive[3];
+      nmdrive[0] = drive+'A';
+      nmdrive[1] = ':';
+      nmdrive[2] = '\0';
+      result = redir_device_drive(delete ? -1 : 0x4, nmdrive, nwp->path);
+    }
   }
   return(result);
 }
 
-
 static int parse_argv(uint8 *drvstr, NWPATH *nwpath,
-                  int argc, char *argv[], int smode)
+                  int argc, char *argv[], int smode, int argvmode)
 {
   int k     = 0;
   int mode  = 0;
@@ -149,7 +155,8 @@ static int parse_argv(uint8 *drvstr, NWPATH *nwpath,
     } /* while *p */
   } /* while k */
   if (mode == 30) {
-    getcwd((char *)nwpath->buff, sizeof(nwpath->buff));
+    if (argvmode != 1)
+       getcwd((char *)nwpath->buff, sizeof(nwpath->buff));
     mode = 40;
   }
   if (mode && mode != 20 && mode != 40) {
@@ -159,21 +166,27 @@ static int parse_argv(uint8 *drvstr, NWPATH *nwpath,
   return(0);
 }
 
-int func_map(int argc, char *argv[])
+int func_map(int argc, char *argv[], int mode)
 {
   uint8  drvstr[22];
   NWPATH nwpath;
   if (!ipx_init()) argc = 1;
-  if (!parse_argv(drvstr, &nwpath, argc, argv, 0)) {
+  if (!parse_argv(drvstr, &nwpath, argc, argv, 0, mode)) {
-    if (*(nwpath.path)) {
+    if (*(nwpath.path) || mode==1) {
-      if (do_map(*drvstr - 'A', &nwpath)< 0)
+      {
-        fprintf(stderr, "MAP Error\n");
+        int rc = do_map(*drvstr - 'A', &nwpath, mode);
+        if (rc < 0)
+          fprintf(stderr, "MAP Error rc=%d\n", rc);
+      }
     }
-    show_map(drvstr);
+    if (mode != 1)
+      show_map(drvstr);
     return(0);
   }
   return(1);
 }
+
+
 /* ------------------------------------------------- */
 static int show_search(uint8 *drvstr)
 {
@@ -183,38 +196,42 @@ static int show_search(uint8 *drvstr)
   get_search_drive_vektor(drives);
   while (p->drivenummer != 0xff && j++ < 16) {
     char  path[256];
-    char  nwname[256];
+    char  nwname_path[300];
+
+
     if ( !*drvstr || j == *(drvstr+1)) {
-      if (p->flags && !(p->flags & 0x80)){
+
-        get_fs_name(p->u.fs.connid, nwname);
+      if (p->drivenummer == 0xfe){
-        if (get_dir_path(p->u.fs.dhandle, path)) {
+        strcpy(path, p->dospath);
-          strcpy(path, "ERROR NW");
-        }
-        (void)xadd_char(nwname, '\\', 20);
       } else {
-        nwname[0] = '\0';
+        *path      = p->drivenummer+'A';
-        /*
+        *(path+1)  = ':';
-        nwname[0] = '<';
+        strcpy(path+2, p->dospath);
-        strcpy(nwname+1, "LOCAL");
-        */
-        if (p->drivenummer == 0xfe){
-          strcpy(path, p->u.d.dospath);
-        } else if (getcurdir((int)(p->drivenummer)+1, path)) {
-          strcpy(path, "ERROR DOS");
-        }
-        /*
-        (void)xadd_char(nwname, '>', 20);
-        */
       }
-      strcat(nwname, path);
+
-      printf("SEARCH%2d = %c: %s\n", j, (char)(p->drivenummer)+'A', nwname);
+      if (p->flags && !(p->flags & 0x80)){
+        char *pp=nwname_path;
+        *pp++ = '[';
+        get_fs_name(p->connid, pp);
+        pp   +=strlen(pp);
+        *pp++='\\';
+        if (get_dir_path(p->dhandle, pp)) {
+          strcpy(pp, "ERROR NW");
+        }
+        pp   += strlen(pp);
+        *pp ++= ']';
+        *pp   = '\0';
+      } else {
+        *nwname_path  = '\0';
+      }
+      printf("SEARCH%2d = %s %s\n", j,  path, nwname_path);
     }
     p++;
   }
   return(0);
 }
 
-static int set_search(uint8 *drvstr, NWPATH *nwp)
+static int set_search(uint8 *drvstr, NWPATH *nwp, int pathmode)
 {
   int result=-1;
   SEARCH_VECTOR          drives;
@@ -222,31 +239,78 @@ static int set_search(uint8 *drvstr, NWPATH *nwp)
   int j=0;
   int entry = (*drvstr=='s') ? *(drvstr+1) : 0;
   get_search_drive_vektor(drives);
+
   while (p->drivenummer != 0xff && j++ < 16) {
     if (!entry && (p->drivenummer + 'A' == *drvstr)) entry=j;
+    if (p->drivenummer + 'A' == nwp->path[0] && nwp->path[1] == ':'
+         && !strcmp(nwp->path+2, p->dospath)) {
+      p->drivenummer=0xfe;
+      *(p->dospath) = '\0';
+    }
     p++;
   }
+
   if (entry > 0) {
     if (entry > 16)  entry = 16;
-    if (--entry < j) p = drives+entry;
+    if (pathmode == 2 && entry <= j && entry < 16) {  /* insert modus */
+      int k=j+1-entry;
+      if (j < 16) {
+        p++;
+        k++;
+        j++;
+      }
+      while (k--) {
+        memcpy(p, p-1, sizeof(SEARCH_VECTOR_ENTRY));
+        --p;
+      }
+    }
+    if (--entry < j)
+      p = drives+entry;
     else (p+1)->drivenummer = 0xff;
+    p->flags       = 0;
     p->drivenummer = 0xfe;
-    strcpy(p->u.d.dospath, nwp->path);
+    if (pathmode==1)
+      *(p->dospath) = '\0';
+    else
+      strcpy(p->dospath, nwp->path);
     result = set_search_drive_vektor(drives);
   }
   return(result);
 }
 
-int func_path(int argc, char *argv[])
+int func_path(int argc, char *argv[], int mode)
 {
   uint8  drvstr[22];
   NWPATH nwpath;
-  if (!parse_argv(drvstr, &nwpath, argc, argv, 1)) {
+  if (!parse_argv(drvstr, &nwpath, argc, argv, 1, mode)) {
     int result=0;
-    if (*(nwpath.path)) result=set_search(drvstr, &nwpath);
+    if (*(nwpath.path) || mode==1)
-    show_search(drvstr);
+       result=set_search(drvstr, &nwpath, mode);
+    if (mode != 1)
+      show_search(drvstr);
     return(result);
   }
   return(1);
 }
 
+void remove_nwpathes(void)
+{
+  SEARCH_VECTOR          drives;
+  SEARCH_VECTOR_ENTRY *p=drives;
+  int j=0;
+  get_search_drive_vektor(drives);
+  while (p->drivenummer != 0xff && j++ < 16) {
+    if (p->flags && !(p->flags & 0x80)){
+      p->flags=0;
+      p->drivenummer=0xfe;
+      *(p->dospath) ='\0';
+    }
+    ++p;
+  }
+  set_search_drive_vektor(drives);
+}
+
+
+
+
+

mk.bat

@@ -1,4 +0,0 @@
-maker %1 %2 %3 %4  > err
-type err
-copy net.exe c:\
-del net.exe

net.c

@@ -1,74 +1,123 @@
-/* net.c 14-Mar-96 */
+/* net.c */
-/* simple client programm to act with mars_nwe */
+#define VERS_DATE "21-May-96"
-
+/* simple client program to act with mars_nwe */
-/****************************************************************
+
- * (C)opyright (C) 1993,1996  Martin Stover, Marburg, Germany   *
+/****************************************************************
- ****************************************************************/
+ * (C)opyright (C) 1993,1996  Martin Stover, Marburg, Germany   *
-
+ ****************************************************************/
-#include "net.h"
+
-char *funcname=NULL;
+#include "net.h"
-typedef int (*NET_FUNC)(int argc, char *argv[]);
+
-
+char *funcname=NULL;
-static struct s_net_functions {
+char  prgpath[65];
- char      *name;
+
- char      *description;
+typedef int (*NET_FUNC)(int argc, char *argv[], int mode);
- NET_FUNC  func;
+
-} net_functions[] = {
+static struct s_net_functions {
-{"LOGIN",  "login to Server as User" ,              func_login  },
+ char      *name;
-{"MAP",    "list maps and map drives" ,             func_map    },
+ char      *description;
-{"PATH",   "list and set search path" ,             func_path   },
+ NET_FUNC  func;
-{"LOGOUT", "logout from Server",       		    func_logout },
+ int       mode;
-#if 0
+} net_functions[] = {
-{"SLIST",  "list Servers",          		    func_slist  },
+
-#endif
+{"SPAWN",  "spawn program(command file)" ,          func_exec   , 0},
-{"PASSWD", "change password",          		    func_passwd },
+{"EXEC",   "execute program(command file)",         func_exec   , 1},
-#if 1
+{"ECHO",   "echoes string (command file)" ,         func_echo   , 0},
-{"TESTS",  "only testroutines!",                    func_tests  },
+{"CD",     "change directory (command file)" ,      func_cwd    , 0},
-#endif
+{"LOGIN",  "login to server as user" ,              func_login  , 0},
-{"DEBUG",  "set debug level, for mars_nwe only !",  func_debug  }
+{"PROFILE","read command file" ,                    func_profile, 0},
-};
+{"CAPTURE","list and redirect printers" ,           func_capture, 0},
-
+{"ENDCAP", "cancel redirect printers" ,             func_capture, 1},
-#define MAX_FUNCS  (sizeof(net_functions) / sizeof(struct s_net_functions))
+{"MAP",    "list maps and map drives" ,             func_map    , 0},
-
+{"MAPDEL", "removes maps" ,                         func_map    , 1},
-int main(int argc, char *argv[])
+{"PATH",   "list and set search path" ,             func_path   , 0},
-{
+{"PATHDEL","removes search path" ,                  func_path   , 1},
-  NET_FUNC  func    = NULL;
+{"PATHINS","insert search path" ,                   func_path   , 2},
-  int       result  = -1;
+{"LOGOUT", "logout from server",       		    func_logout , 0},
-  if (argc > 1) {
+#if 0
-    char funcn[200];
+{"SLIST",  "list servers",          		    func_slist  , 0},
-    int  k= MAX_FUNCS;
+#endif
-    strmaxcpy(funcn, argv[1], sizeof(funcn)-1);
+{"PASSWD", "change password",          		    func_passwd , 0},
-    upstr(funcn);
+#if 1
-    while (k--) {
+{"TESTS",  "only testroutines!",                    func_tests  , 0},
-      if (!strcmp(funcn, net_functions[k].name)) {
+#endif
-        func=net_functions[k].func;
+{"DEBUG",  "set debug level, for mars_nwe only !",  func_debug  , 0}
-        funcname=net_functions[k].name;
+};
-        break;
+
-      }
+#define MAX_FUNCS  (sizeof(net_functions) / sizeof(struct s_net_functions))
-    }
+
-  }
+static int get_entry_nr(char *fstr)
-  if (func != NULL) {
+{
-    if (ipx_init() || func == func_map) {
+  int       entry    = MAX_FUNCS;
-      result = (*func) (argc-1, &(argv[1]));
+  char      buff[200];
-    }
+  char      funcn[100];
-  } else {
+  char      *pp;
-    int  k= MAX_FUNCS;
+  strmaxcpy(buff, fstr, sizeof(buff)-1);
-    char progname[256];
+  korrpath(buff);
-    strmaxcpy(progname, argv[0], sizeof(progname)-1);
+  get_path_fn(buff, NULL, funcn);
-    upstr(progname);
+  pp=strrchr(funcn, '.');
-    fprintf(stderr, "\n"
+  if (NULL != pp) *pp = '\0';
-     "****************************************************************\n"
+  upstr(funcn);
-     "* (C)opyright (C) 1993,1996  Martin Stover, Marburg, Germany   *\n"
+  while (entry--) {
-     "****************************************************************\n\n" );
+    if (!strcmp(funcn, net_functions[entry].name)) return(entry);
-    fprintf(stderr, "Usage:\t%s func ... \nfuncs:", progname);
+  }
-    while (k--) {
+  return(-1);
-      if (net_functions[k].func) {
+}
-        fprintf(stderr, "\t%s\t: %s\n",
+
-           net_functions[k].name, net_functions[k].description);
+int call_func_entry(int argc, char *argv[])
-      }
+{
-    }
+  int       funcmode;
-  }
+  int       result   = -1;
-  return(result);
+  NET_FUNC  func     = NULL;
-}
+  int       entry = get_entry_nr(argv[0]);
-
+  if (entry > -1) {
-
+    func     = net_functions[entry].func;
+    funcmode = net_functions[entry].mode;
+    funcname = net_functions[entry].name;
+  }
+  if (NULL != func) {
+    if (ipx_init() || func == func_map) {
+      result = (*func)(argc, argv, funcmode);
+    } else {
+      fprintf(stderr, "Cannot init IPX\n");
+    }
+  } else result = -0xff;
+  return(result);
+}
+
+static void get_path(char *path)
+{
+  char buf[100];
+  strmaxcpy(buf, path, sizeof(buf)-1);
+  korrpath(buf);
+  get_path_fn(buf, prgpath, NULL);
+}
+
+int main(int argc, char *argv[])
+{
+  int result = -0xff;
+  get_path(argv[0]);
+  result = call_func_entry(argc, argv);
+  if (result == -0xff)
+    result = call_func_entry(argc-1, argv+1);
+  if (result == -0xff) {
+    int  k= MAX_FUNCS;
+    char progname[256];
+    strmaxcpy(progname, argv[0], sizeof(progname)-1);
+    upstr(progname);
+    fprintf(stderr, "\n"
+     "* (C)opyright (C) 1993,1996  Martin Stover, Marburg, Germany *\n"
+     "  Version: %s\n\n", VERS_DATE);
+
+    fprintf(stderr, "Usage:\t%s func ... \nfuncs:", progname);
+    while (k--) {
+      if (net_functions[k].func) {
+        fprintf(stderr, "\t%s\t: %s\n",
+           net_functions[k].name, net_functions[k].description);
+      }
+    }
+  }
+  return(result);
+}
+
+

net.h

@@ -1,4 +1,4 @@
-/* net.h: 01-Feb-96 */
+/* net.h: 20-May-96 */
 
 /****************************************************************
  * (C)opyright (C) 1993,1996  Martin Stover, Marburg, Germany   *
@@ -15,8 +15,12 @@
 #include <dos.h>
 #include <process.h>
 #include <stdarg.h>
+#ifdef __WATCOMC__
+#include <direct.h>
+#endif
 
 typedef unsigned int       UI;
+typedef unsigned int       uint;
 typedef unsigned char      UC;
 typedef unsigned char      uint8;
 typedef unsigned short int uint16;
@@ -103,38 +107,54 @@ typedef struct {
 #define NWBIND   5
 
 /* net.c */
-extern char *funcname;
+extern char  *funcname;
+extern char   prgpath[];
+
+extern int   call_func_entry(int argc, char *argv[]);
 
 /* tools.c */
 extern void  clear_kb(void);
 extern int   key_pressed(void);
 extern int   ask_user(char *p, ...);
+#define xfree(p)      x_x_xfree((char **)&(p))
+extern  void x_x_xfree(char **p);
+extern char  *xmalloc(uint  size);
+extern char  *xcmalloc(uint size);
+
 extern int   strmaxcpy(char *dest, char *source, int len);
 extern char  *xadd_char(char *s, int c, int maxlen);
 extern uint8 *upstr(uint8 *s);
+extern void korrpath(char *s);
+extern void get_path_fn(char *s, char *p, char *fn);
+
+#define reb(s) deb((s)),leb((s))
+
+extern void  deb(uint8 *s);
+extern void  leb(uint8 *s);
+
 
 #define add_char(s, c) xadd_char((s), (c), -1)
 
 extern char *getglobenv(char *option);
 extern int  putglobenv(char  *option);
 
+#ifdef __WATCOMC__
+/* Borland C compatibility wrappers implemented in tools.c. */
+extern int  getcurdir(int drive, char *directory);
+extern void setdisk(int drive);
+#endif
+
 /* NETCALLS */
 #define DRIVE_ADD     1
 #define DRIVE_INSERT  2
 #define DRIVE_DELETE  3
 
 typedef struct {
-  uint8  drivenummer;  /* 0xff, 0xfe f<EFBFBD>r DOSPATH mit Pfad */
+  uint8  drivenummer;   /* 0xff=last of list,  0xfe only DOSPATH */
-  uint8  flags;
+  uint8  flags;         /* 0x80 = local drive */
-  union {
+  char   dospath[65];
-    struct {
+  uint8  connid;
-      char   dospath[65];
+  uint8  dhandle;
-    } d;
-    struct fs {
-      uint8  connid;
-      uint8  dhandle;
-    } fs;
-  } u;
 } SEARCH_VECTOR_ENTRY;
 
 typedef SEARCH_VECTOR_ENTRY  SEARCH_VECTOR[17];
@@ -148,6 +168,12 @@ extern int neterrno;
   alloc_dir_handle(0x13, (dhandle), (path), (drive), (rights))
 
 extern int ipx_init(void);
+extern int logout(void);
+extern int redir_device_drive(int devicetyp, uint8 *devname, uint8 *remotename);
+extern int list_redir(int index, int *devicetyp, uint8 *devname, uint8 *remotename);
+extern int get_drive_info(uint8 drivenumber, uint8 *connid,
+                          uint8 *dhandle, uint8 *statusflags);
+extern int get_fs_name(int connid, char *name);
 
 extern int alloc_dir_handle(int func, int dhandle, char *path,
                             int driveletter, uint8 *effrights);
@@ -168,11 +194,13 @@ extern  int   ncp_16_02(int dirhandle,
               uint32 *creattime,
               uint32 *owner_id);
 
+extern int    ncp_14_46(uint32 *obj_id);
 extern int    ncp_17_02(int   module, int debuglevel);
 extern int    ncp_17_14(uint8 *objname, uint16 objtyp, uint8 *password);
 extern int    ncp_17_17(uint8 *key);
 extern int    ncp_17_18(uint8 *cryptkey, uint8 *objname, uint16 objtyp);
 extern uint32 ncp_17_35(uint8 *objname, uint16 objtyp);
+extern int    ncp_17_36(uint32 obj_id, uint8 *objname, uint16 *objtyp);
 extern int    ncp_17_40(uint8 *objname, uint16 objtyp, uint8 *password,
                                                        uint8 *newpassword);
 
@@ -180,23 +208,31 @@ extern int    ncp_17_4b(uint8 *cryptkey, uint8 *objname, uint16 objtyp,
                                int passwx, uint8 *newpassword);
 
 /* map.c */
-extern int func_map(int argc, char *argv[]);
+extern int func_map   (int argc, char *argv[], int mode);
-extern int func_path(int argc, char *argv[]);
+extern int func_path  (int argc, char *argv[], int mode);
+extern void remove_nwpathes(void);
 
 /* login.c */
-extern int func_login(int argc, char *argv[]);
+extern int func_login  (int argc, char *argv[], int mode);
-extern int func_logout(int argc, char *argv[]);
+extern int func_logout (int argc, char *argv[], int mode);
-extern int func_passwd(int argc, char *argv[]);
+extern int func_passwd (int argc, char *argv[], int mode);
+extern int func_profile(int argc, char *argv[], int mode);
+extern int func_cwd    (int argc, char *argv[], int mode);
+extern int func_echo   (int argc, char *argv[], int mode);
+extern int func_exec   (int argc, char *argv[], int mode);
+extern int read_command_file(char *fstr);
 
 /* slist.c */
-extern int func_slist(int argc, char *argv[]);
+extern int func_slist (int argc, char *argv[], int mode);
 
 /* nwdebug.c */
-extern int func_debug(int argc, char *argv[]);
+extern int func_debug (int argc, char *argv[], int mode);
 
 /* nwtests.c */
-extern int func_tests(int argc, char *argv[]);
+extern int func_tests (int argc, char *argv[], int mode);
-
+
+/* capture.c */
+extern int func_capture(int argc, char *argv[], int mode);
 
 
 

netcall.c

@@ -49,27 +49,43 @@ int logout(void)
 
 int redir_device_drive(int devicetyp, uint8 *devname, uint8 *remotename)
 /* if devicetyp == -1, the redir is canceled */
+/* devicetyp 3 = printer    */
+/* devicetyp 4 = disk drive */
 {
    REGS    regs;
    SREGS   sregs;
-   int     result;
    uint8   buff1[16];
    uint8   buff2[128];
    uint8   *ldevname    = buff1;
    uint8   *lremotename = buff2;
-   strncpy(ldevname,    devname,    16);
+
+   memset(&regs,  0, sizeof(regs));
+   memset(&sregs, 0, sizeof(sregs));
+   memset(buff1,  0, sizeof(buff1));
+   memset(buff2,  0, sizeof(buff2));
+
+   strmaxcpy(ldevname, devname, sizeof(buff1) - 1);
+
    regs.x.ax = (devicetyp == -1) ? 0x5f04 : 0x5f03;
    regs.h.bl = (uint8)devicetyp;
    regs.x.cx = 0x574e; /* user sign 'NW' */
    sregs.ds  = FP_SEG(ldevname);
    regs.x.si = FP_OFF(ldevname);
+
    if (devicetyp > -1) {
-     strncpy(lremotename, remotename, 128);
+     strmaxcpy(lremotename, remotename, sizeof(buff2) - 1);
      sregs.es  = FP_SEG(lremotename);
      regs.x.di = FP_OFF(lremotename);
    }
-   result = intdosx(&regs, &regs, &sregs);
+
-   return(regs.x.cflag ? -result : 0);
+   intdosx(&regs, &regs, &sregs);
+
+   /*
+    * Return the actual DOS/redirector error code from AX when carry is set.
+    * The old code returned the intdosx() function result.  With OpenWatcom
+    * this can hide which redirector error happened.
+    */
+   return(regs.x.cflag ? -(int)regs.x.ax : 0);
 }
 
 int list_redir(int index, int *devicetyp, uint8 *devname, uint8 *remotename)
@@ -157,16 +173,15 @@ int get_search_drive_vektor(SEARCH_VECTOR_ENTRY *vec)
       char *p1 = path;
       int  len = 0;
       while (*path && *path++ !=';') len++;
-      if (*(p1+1) == ':'
+      if (*(p1+1) == ':' && *p1 >= 'A' &&  *p1 <= 'Z') {
-          && *p1 >= 'A' &&  *p1 <= 'Z' &&
-           (len==2 || (len == 3 && *(p1+2) == '.'))) {
         v->drivenummer =  *p1 - 'A';
-        get_drive_info(v->drivenummer, &(v->u.fs.connid),
+        get_drive_info(v->drivenummer, &(v->connid),
-           &(v->u.fs.dhandle), &(v->flags));
+           &(v->dhandle), &(v->flags));
+        strmaxcpy(v->dospath, p1+2, min(len-2, sizeof(v->dospath)-1));
       } else {
         v->flags       = 0;
         v->drivenummer = 0xfe;  /* ergibt ? */
-        strmaxcpy(v->u.d.dospath, p1, len);
+        strmaxcpy(v->dospath, p1, min(len, sizeof(v->dospath)-1));
       }
       (++v)->drivenummer =  0xff;
       if (*path == ';') path++;
@@ -181,20 +196,29 @@ int set_search_drive_vektor(SEARCH_VECTOR_ENTRY *vec)
   char *p=path;
   SEARCH_VECTOR_ENTRY *v;
   int  plen=strlen(path_env_name);
+  int  maxcount=16;
   strcpy(path, path_env_name);
   path[plen]   = '=';
   path[++plen] = '\0';
-  while ((NULL != (v = vec++)) && v->drivenummer != 0xff){
+
-    if (p > path) *p++=';';
+  while (maxcount-- && (NULL != (v = vec++)) && v->drivenummer != 0xff){
-    else p+=plen;
+    if (v->drivenummer < 26 || *(v->dospath)) {
-    if (v->drivenummer < 26) {
+      if (p > path) *p++=';';
-      *p++ = (char) v->drivenummer + 'A';
+      else p+=plen;
-      *p++ = ':';
+      if (v->drivenummer < 26) {
-      *p++ = '.';
+        *p++ = (char) v->drivenummer + 'A';
-      *p   = '\0';
+        *p++ = ':';
-    } else {
+        if (*v->dospath) {
-      strcpy(p,  v->u.d.dospath);
+          strcpy(p,  v->dospath);
-      p+= strlen(v->u.d.dospath);
+          p+= strlen(v->dospath);
+        } else {
+          *p++='.';
+          *p  ='\0';
+        }
+      } else {
+        strcpy(p,  v->dospath);
+        p+= strlen(v->dospath);
+      }
     }
   }
   return(putglobenv(path));

nwdebug.c

@@ -1,4 +1,4 @@
-/* nwdebug.c 04-Apr-96 */
+/* nwdebug.c 21-May-96 */
 
 /****************************************************************
  * (C)opyright (C) 1993,1996  Martin Stover, Marburg, Germany   *
@@ -13,7 +13,7 @@ static int usage(void)
   return(-1);
 }
 
-int func_debug(int argc, char *argv[])
+int func_debug(int argc, char *argv[], int mode)
 {
   uint8 s[200];
   int   module;
@@ -29,8 +29,11 @@ int func_debug(int argc, char *argv[])
   level = atoi(argv[2]);
   if (level < 0 || level > 99) return(usage());
   result = ncp_17_02(module, level);
-  if (result < 0) fprintf(stderr, "set debug failed\n");
+  if (result < 0) {
-  else fprintf(stdout, "Debug level for %s changed from %d to %d\n",
+    fprintf(stderr, "set debug failed\n");
+    fprintf(stderr, "perhaps you did not enable FUNC_17_02_IS_DEBUG\n");
+    fprintf(stderr, "in mars_nwe/config.h ?!");
+  } else fprintf(stdout, "Debug level for %s changed from %d to %d\n",
              s, result, level);
   return(result < 0 ? result : 0);
 }

nwtests.c

@@ -1,4 +1,4 @@
-/* nwtests.c 14-Mar-96 */
+/* nwtests.c 20-May-96 */
 
 /****************************************************************
  * (C)opyright (C) 1993,1996  Martin Stover, Marburg, Germany   *
@@ -8,12 +8,10 @@
 
 static int usage(void)
 {
-  fprintf(stderr, "usage:\t%s NCPSERV|NWCONN level\n", funcname);
-  fprintf(stderr, "\tlevel=0 .. 99\n" );
   return(-1);
 }
 
-int func_tests(int argc, char *argv[])
+int func_tests(int argc, char *argv[], int mode)
 {
   int level     = ncp_17_02(NWCONN, 6);
   int dirhandle = alloc_temp_dir_handle(0, "SYS:", 'd', NULL);

slist.c

@@ -6,7 +6,7 @@
 
 #include "net.h"
 
-int func_slist(int argc, char *argv[])
+int func_slist(int argc, char *argv[], int mode)
 {
 
 

teste.c

@@ -1,95 +1,95 @@
-int main()
+int main()
-{
+{
-   char *fn="F.$LN";
+   char *fn="F.$LN";
-   char *string="ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijklmnopqrstuvwxyz";
+   char *string="ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijklmnopqrstuvwxyz";
-   int  result;
+   int  result;
-   struct stat stbuff;
+   struct stat stbuff;
-   long offset;
+   long offset;
-   char buff[1024];
+   char buff[1024];
-   char readbuff[500];
+   char readbuff[500];
-   int j;
+   int j;
-   int  fd=creatnew(fn, S_IREAD |S_IWRITE);
+   int  fd=creatnew(fn, S_IREAD |S_IWRITE);
-   if (fd > -1) {
+   if (fd > -1) {
-     printf("Konnte Date erzeugen\n");
+     printf("Konnte Date erzeugen\n");
-     close(fd);
+     close(fd);
-   } else {
+   } else {
-     printf("Konnte Datei nicht erzeugen\n");
+     printf("Konnte Datei nicht erzeugen\n");
-   }
+   }
-   fd = open(fn, O_RDWR|O_CREAT|O_TRUNC|O_DENYNONE, 0666);
+   fd = open(fn, O_RDWR|O_CREAT|O_TRUNC|O_DENYNONE, 0666);
-   memset(buff, 0, sizeof(buff) );
+   memset(buff, 0, sizeof(buff) );
-   strcpy(buff, string);
+   strcpy(buff, string);
-   write(fd, buff, strlen(buff));
+   write(fd, buff, strlen(buff));
-   close(fd);
+   close(fd);
-   _chmod(fn, 1, _chmod(fn, 0) | 0x80 );
+   _chmod(fn, 1, _chmod(fn, 0) | 0x80 );
-   stat(fn, &stbuff);
+   stat(fn, &stbuff);
-   printf("Filesize <20>ber stat =%ld\n", stbuff.st_size);
+   printf("Filesize <20>ber stat =%ld\n", stbuff.st_size);
-   fd = open(fn, O_RDWR | O_BINARY |O_DENYNONE);
+   fd = open(fn, O_RDWR | O_BINARY |O_DENYNONE);
-
+
-   offset = lseek(fd, 0L, SEEK_END);
+   offset = lseek(fd, 0L, SEEK_END);
-   printf("Filesize <20>ber lseek =%ld\n", offset);
+   printf("Filesize <20>ber lseek =%ld\n", offset);
-   write(fd, buff, strlen(buff));
+   write(fd, buff, strlen(buff));
-
+
-   lseek(fd, 0L, SEEK_SET);
+   lseek(fd, 0L, SEEK_SET);
-   for (j=0; j < strlen(buff)*2; j++){
+   for (j=0; j < strlen(buff)*2; j++){
-     read(fd, readbuff, 1);
+     read(fd, readbuff, 1);
-     printf("BUFF = %c\n",  readbuff[0]);
+     printf("BUFF = %c\n",  readbuff[0]);
-   }
+   }
-   lseek(fd, 1L, SEEK_SET);
+   lseek(fd, 1L, SEEK_SET);
-   for (j = 0; j < 20; j++){
+   for (j = 0; j < 20; j++){
-     write(fd, buff+j, 1);
+     write(fd, buff+j, 1);
-   }
+   }
-
+
-   for (j=0; j <60; j++){
+   for (j=0; j <60; j++){
-     lseek(fd, (long) j, SEEK_SET);
+     lseek(fd, (long) j, SEEK_SET);
-     read(fd, readbuff, 2);
+     read(fd, readbuff, 2);
-     printf("BUFF = %c, %c \n", readbuff[0], readbuff[1]);
+     printf("BUFF = %c, %c \n", readbuff[0], readbuff[1]);
-   }
+   }
-
+
-   lseek(fd, 10L, SEEK_SET);
+   lseek(fd, 10L, SEEK_SET);
-   read(fd, buff, 1);
+   read(fd, buff, 1);
-   printf("BUFF[10] = %c\n", buff[0]);
+   printf("BUFF[10] = %c\n", buff[0]);
-   result=lock(fd,  100L, 1L);
+   result=lock(fd,  100L, 1L);
-   printf("lock result = %d\n", result);
+   printf("lock result = %d\n", result);
-   result=unlock(fd,  100L, 1L);
+   result=unlock(fd,  100L, 1L);
-   printf("unlock result = %d\n", result);
+   printf("unlock result = %d\n", result);
-   close(fd);
+   close(fd);
-
+
-   fd = open(fn, O_BINARY|O_RDWR|O_CREAT|O_TRUNC|O_DENYNONE, 0666);
+   fd = open(fn, O_BINARY|O_RDWR|O_CREAT|O_TRUNC|O_DENYNONE, 0666);
-   if (fd > -1) {
+   if (fd > -1) {
-     int bufflen;
+     int bufflen;
-     strcpy(buff, "d:..\\marlib\\c0l.obj+");
+     strcpy(buff, "d:..\\marlib\\c0l.obj+");
-     strcat(buff, "\r\n");
+     strcat(buff, "\r\n");
-     strcat(buff, "x");
+     strcat(buff, "x");
-     strcat(buff, "\r\n");
+     strcat(buff, "\r\n");
-     strcat(buff, "x");
+     strcat(buff, "x");
-     strcat(buff, "\r\n");
+     strcat(buff, "\r\n");
-     strcat(buff, "/c/x");
+     strcat(buff, "/c/x");
-     strcat(buff, "\r\n");
+     strcat(buff, "\r\n");
-     strcat(buff, "d:..\\marlib\\EMU.LIB+");
+     strcat(buff, "d:..\\marlib\\EMU.LIB+");
-     strcat(buff, "\r\n");
+     strcat(buff, "\r\n");
-     strcat(buff, "d:..\\marlib\\mathl.lib+");
+     strcat(buff, "d:..\\marlib\\mathl.lib+");
-     strcat(buff, "\r\n");
+     strcat(buff, "\r\n");
-     strcat(buff, "d:..\\marlib\\cl.lib");
+     strcat(buff, "d:..\\marlib\\cl.lib");
-     bufflen=strlen(buff);
+     bufflen=strlen(buff);
-     printf("bufflen = %d, buff=%s\n", bufflen, buff);
+     printf("bufflen = %d, buff=%s\n", bufflen, buff);
-     write(fd, buff, bufflen);
+     write(fd, buff, bufflen);
-     close(fd);
+     close(fd);
-     fd = open(fn, O_TEXT|O_RDONLY);
+     fd = open(fn, O_TEXT|O_RDONLY);
-     if (fd > -1) {
+     if (fd > -1) {
-       char *p=readbuff;
+       char *p=readbuff;
-       int  anz = 0;
+       int  anz = 0;
-       memset(readbuff, 0, sizeof(readbuff) );
+       memset(readbuff, 0, sizeof(readbuff) );
-       while (read(fd, p, 1) == 1){
+       while (read(fd, p, 1) == 1){
-         anz++;
+         anz++;
-         p++;
+         p++;
-       }
+       }
-       printf("read = %d, buff=%s\n", anz, readbuff);
+       printf("read = %d, buff=%s\n", anz, readbuff);
-       close(fd);
+       close(fd);
-     }
+     }
-   }
+   }
-  /*
+  /*
-  result = detach(1);
+  result = detach(1);
-  printf("Detach result=0x%x", result);
+  printf("Detach result=0x%x", result);
-  */
+  */
-  return(0);
+  return(0);
-}
+}

tools.c

@@ -5,21 +5,66 @@
  * (C)opyright (C) 1993,1996  Martin Stover, Marburg, Germany   *
  ****************************************************************/
 
+
+#ifdef __WATCOMC__
+/*
+ * Borland C compatibility wrappers used by the historical mars-nwe DOS tools.
+ * Open Watcom does not provide getcurdir()/setdisk() under these Borland names.
+ */
+int getcurdir(int drive, char *directory)
+{
+  REGS regs;
+  SREGS sregs;
+
+  regs.h.ah = 0x47;      /* DOS: get current directory */
+  regs.h.dl = (unsigned char)drive; /* 0=current, 1=A:, 2=B:, ... */
+  sregs.ds  = FP_SEG(directory);
+  regs.x.si = FP_OFF(directory);
+  intdosx(&regs, &regs, &sregs);
+  return(regs.x.cflag ? -1 : 0);
+}
+
+void setdisk(int drive)
+{
+  REGS regs;
+
+  regs.h.ah = 0x0e;      /* DOS: select default drive */
+  regs.h.dl = (unsigned char)drive; /* 0=A:, 1=B:, ... */
+  intdos(&regs, &regs);
+}
+#endif
+
 int key_pressed(void)
 {
+#ifdef __WATCOMC__
+  /*
+   * Open Watcom's WORDREGS does not expose x.flags.  The old Borland
+   * code checked the BIOS INT 16h ZF bit after AH=01h.  Open Watcom's
+   * bios.h provides _bios_keybrd(), which wraps the same BIOS keyboard
+   * service and returns 0 when no key is waiting.
+   */
+  return(_bios_keybrd(_KEYBRD_READY) != 0);
+#else
   REGS regsin, regsout;
   regsin.h.ah = 0x01; /* read key-press */
   int86(0x16, &regsin, &regsout);
   return((regsout.x.flags & 0x40) ? 0 : 1); /* zeroflag != 0 */
+#endif
 }
 
 void clear_kb(void)
 {
+#ifdef __WATCOMC__
+  while (key_pressed()) {
+    (void)_bios_keybrd(_KEYBRD_READ);
+  }
+#else
   REGS regsin, regsout;
   while (key_pressed()) {    /* zeroflag != 0 */
     regsin.h.ah = 0x00;      /* read key-press */
     int86(0x16, &regsin, &regsout);
   }
+#endif
 }
 
 int ask_user(char *p, ...)
@@ -48,6 +93,31 @@ int ask_user(char *p, ...)
    return(flag);
 }
 
+char *xmalloc(uint size)
+{
+  char *p = (size) ? (char *)malloc(size) : (char*)NULL;
+  if (p == (char *)NULL && size){
+    fprintf(stderr, "not enough core, need %d Bytes\n", size);
+    exit(1);
+  }
+  return(p);
+}
+
+char *xcmalloc(uint size)
+{
+  char *p = xmalloc(size);
+  if (size) memset(p, 0, size);
+  return(p);
+}
+
+void x_x_xfree(char **p)
+{
+  if (*p != (char *)NULL){
+    free(*p);
+    *p = (char*)NULL;
+  }
+}
+
 int strmaxcpy(char *dest, char *source, int len)
 /* copied max. len chars + '\0' Byte */
 {
@@ -69,6 +139,18 @@ char *xadd_char(char *s, int c, int maxlen)
   return(s);
 }
 
+static uint8 down_char(uint8 ch)
+{
+  if (ch > 64 && ch < 91) return(ch + 32);
+  switch(ch){
+    case 142:  ch =  132; break;
+    case 153:  ch =  148; break;
+    case 154:  ch =  129; break;
+    default :break;
+  }
+  return(ch);
+}
+
 static uint8 up_char(uint8 ch)
 {
   if (ch > 96 && ch < 123) return(ch - 32);
@@ -88,6 +170,64 @@ uint8 *upstr(uint8 *s)
   return(s);
 }
 
+void deb(uint8 *s)
+{
+  if (!s || !*s) return;
+  else {
+    uint8 *p = s + strlen(s);
+    while (p > s && (*--p==32 || *p==9));;
+    if (*p==32 || *p==9) *p='\0';
+    else *(p+1) = '\0';
+  }
+}
+
+void leb(uint8 *s)
+{
+  if (!s || !*s || (*s != 32 && *s != 9)) return;
+  else {
+    uint8 *p = s;
+    for (;*p && *p!=32 && *p!=9;p++);;
+    strcpy(s, p);
+  }
+}
+
+void korrpath(char *s)
+{
+  if (!s) return;
+  for (;*s;s++) {
+    if (*s=='\\') *s='/';
+    else *s=down_char(*s);
+  }
+}
+
+void get_path_fn(char *s, char *p, char *fn)
+{
+  int j= strlen(s);
+  if (p  != (char *)NULL)  p[0]  = 0;
+  if (fn != (char*) NULL)  fn[0] = 0;
+  if (!j) return;
+  if (s[0] == '.' && (s[1] == 0 || (s[1] == '.' && s[2] == 0) ) ) {
+    if (p != (char *)NULL) {
+      strcpy(p, s);
+      strcat(p, "/");
+    }
+    if (fn != (char *)NULL) fn[0] = 0;
+    return;
+  }
+  while (j--){
+    if ((s[j] == '/') || (s[j] == ':') ) {
+      if (fn != (char *)NULL) strcpy(fn, s+j+1);
+      if (p != (char *)NULL) {
+        strncpy(p, s, j+1);
+        p[j+1] = 0;
+      }
+      return;
+    }
+  }
+  if (fn != (char *)NULL) strcpy(fn, s);  /* no path */
+}
+
+
 typedef struct {
   uint16  adr1;
   uint16  adr2;