├── COPYING
├── Makefile
├── Makefile.kernel
├── Makefile.module
├── Makefile.win2k
├── README
├── README.md
├── alloc.c
├── async.c
├── bit.c
├── block.c
├── build
├── cluster.c
├── console.c
├── create.c
├── date.c
├── dir.c
├── disk.c
├── dos.bat
├── dos.mak
├── dos2unix.c
├── dump.c
├── fat.c
├── file.c
├── fileutil.c
├── fileutil.h
├── filter.c
├── globals.c
├── globals.h
├── hash.c
├── image.h
├── imghelp.h
├── inode.c
├── ioctl.c
├── lock.c
├── lru.c
├── mmap.c
├── nofilt.c
├── nwbackup.c
├── nwconfig.c
├── nwcreate.c
├── nwdir.c
├── nwdir.h
├── nwdisk.c
├── nwdismnt.c
├── nwdump.c
├── nwerror.h
├── nwext.c
├── nwfile.c
├── nwfix.c
├── nwfs
├── nwfs.h
├── nwfs.mak
├── nwfsmod.mak
├── nwfssmp.mak
├── nwhash.h
├── nwhelp.h
├── nwimage.c
├── nwioctl.h
├── nwmenu.c
├── nwmenu.h
├── nwmodsmp.mak
├── nwmount.c
├── nwntfs.c
├── nwpart.c
├── nwproc.h
├── nwrepair.c
├── nwrestor.c
├── nwrwlock.c
├── nwstruct.h
├── nwtool.c
├── nwvfs.c
├── nwvfs.h
├── nwview.c
├── nwvol.c
├── nwvp.c
├── nwvp.h
├── nwvpcmd.h
├── nwvpext.h
├── nwvphal.c
├── nwvphal.h
├── nwvpmain.c
├── rapidfat.c
├── sources
├── sources.nt5
├── suballoc.c
├── super.c
├── symlink.c
├── trustee.c
├── util.mak
├── utilms.bat
├── utilms.mak
├── vcommand.c
├── vconsole.c
├── vconsole.h
├── volume.c
└── windows-src
    ├── cachesup.c
    ├── cleanup.c
    ├── close.c
    ├── create.c
    ├── devctrl.c
    ├── deviosup.c
    ├── dirctrl.c
    ├── fenris.h
    ├── fileinfo.c
    ├── filobsup.c
    ├── fsctrl.c
    ├── fspdisp.c
    ├── lockctrl.c
    ├── makefile
    ├── namesup.c
    ├── nodetype.h
    ├── nw.h
    ├── nwdata.c
    ├── nwdata.h
    ├── nwfsro.rc
    ├── nwinit.c
    ├── nwprocs.h
    ├── nwstruc.h
    ├── nwsup.c
    ├── read.c
    ├── resrcsup.c
    ├── sources
    ├── sources.nt5
    ├── strucsup.c
    ├── volinfo.c
    └── workque.c


/COPYING:
--------------------------------------------------------------------------------
 1 | 
 2 | /***************************************************************************
 3 | *
 4 | *   Copyright (c) 1998, 2022 Jeff V. Merkey
 5 | *   7260 SE Tenino St.
 6 | *   Portland, Oregon 97206
 7 | *   jeffmerkey@gmail.com
 8 | *
 9 | *   This program is free software; you can redistribute it and/or modify it
10 | *   under the terms of the Lesser GNU Public License as published by the
11 | *   Free Software Foundation, version 2.1, or any later version.
12 | *
13 | *   This program is distributed in the hope that it will be useful, but
14 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
15 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 | *   General Public License for more details.
17 | *
18 | ****************************************************************************/    
19 | 
20 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
  1 | 
  2 | #
  3 | # Makefile for the NWFS module For Linux.
  4 | #
  5 | 
  6 | CC = gcc
  7 | LINK = ld
  8 | CFLAGS = -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O2 \
  9 | 	-fomit-frame-pointer -fno-strength-reduce -pipe -m386 -DCPU=386 \
 10 | 	-I/usr/src/linux/include -c
 11 | 
 12 | ifdef MODVERSIONS
 13 | CFLAGS+=-DMODVERSIONS
 14 | endif
 15 | 
 16 | ifdef SMP
 17 | CFLAGS+=-D__SMP__
 18 | endif
 19 | 
 20 | ifdef LINUX_DRIVER
 21 | CFLAGS+=-DLINUX_DRIVER=1
 22 | CFLAGS+=-DOVERRIDE=1
 23 | endif
 24 | 
 25 | LFLAGS = -m elf_i386 -Map nwfs.map -r -o 
 26 | 
 27 | incdeps = nwfs.h nwstruct.h nwdir.h nwhash.h nwproc.h nwvfs.h nwerror.h \
 28 | 	  globals.h
 29 | 
 30 | objects = nwvfs.o alloc.o disk.o nwpart.o volume.o globals.o lru.o  \
 31 | 	  lock.o hash.o async.o fat.o bit.o block.o cluster.o dir.o      \
 32 | 	  mmap.o inode.o super.o file.o ioctl.o nwdir.o nwfile.o nwfix.o  \
 33 | 	  trustee.o nwext.o suballoc.o create.o date.o                    \
 34 | 	  nwcreate.o symlink.o nwvp.o nwvphal.o 
 35 | 
 36 | all: nwfs.o
 37 | 
 38 | nwfs.o: $(objects) 
 39 | 	$(LINK) $(LFLAGS) nwfs.o $(objects)
 40 | 
 41 | nwvfs.o: nwvfs.c     $(incdeps)
 42 | 	$(CC) $(CFLAGS) nwvfs.c
 43 | nwvp.o: nwvp.c       $(incdeps)
 44 | 	$(CC) $(CFLAGS) nwvp.c
 45 | nwvphal.o: nwvphal.c $(incdeps)
 46 | 	$(CC) $(CFLAGS) nwvphal.c
 47 | alloc.o: alloc.c     $(incdeps)
 48 | 	$(CC) $(CFLAGS) alloc.c
 49 | disk.o: disk.c       $(incdeps)
 50 | 	$(CC) $(CFLAGS) disk.c
 51 | nwpart.o: nwpart.c   $(incdeps)
 52 | 	$(CC) $(CFLAGS) nwpart.c
 53 | volume.o: volume.c   $(incdeps)
 54 | 	$(CC) $(CFLAGS) volume.c
 55 | fat.o: fat.c         $(incdeps)
 56 | 	$(CC) $(CFLAGS) fat.c
 57 | globals.o: globals.c $(incdeps)
 58 | 	$(CC) $(CFLAGS) globals.c
 59 | lock.o: lock.c       $(incdeps)
 60 | 	$(CC) $(CFLAGS) lock.c
 61 | hash.o: hash.c       $(incdeps)
 62 | 	$(CC) $(CFLAGS) hash.c
 63 | string.o: string.c   $(incdeps)
 64 | 	$(CC) $(CFLAGS) string.c
 65 | lru.o: lru.c         $(incdeps)
 66 | 	$(CC) $(CFLAGS) lru.c
 67 | bit.o: bit.c         $(incdeps)
 68 | 	$(CC) $(CFLAGS) bit.c
 69 | block.o: block.c     $(incdeps)
 70 | 	$(CC) $(CFLAGS) block.c
 71 | cluster.o: cluster.c $(incdeps)
 72 | 	$(CC) $(CFLAGS) cluster.c
 73 | dir.o: dir.c         $(incdeps)
 74 | 	$(CC) $(CFLAGS) dir.c
 75 | mmap.o: mmap.c       $(incdeps)
 76 | 	$(CC) $(CFLAGS) mmap.c
 77 | inode.o: inode.c     $(incdeps)
 78 | 	$(CC) $(CFLAGS) inode.c
 79 | super.o: super.c     $(incdeps)
 80 | 	$(CC) $(CFLAGS) super.c
 81 | file.o: file.c       $(incdeps)
 82 | 	$(CC) $(CFLAGS) file.c
 83 | ioctl.o: ioctl.c     $(incdeps)
 84 | 	$(CC) $(CFLAGS) ioctl.c
 85 | nwdir.o: nwdir.c     $(incdeps)
 86 | 	$(CC) $(CFLAGS) nwdir.c
 87 | nwfile.o: nwfile.c   $(incdeps)
 88 | 	$(CC) $(CFLAGS) nwfile.c
 89 | trustee.o: trustee.c   $(incdeps)
 90 | 	$(CC) $(CFLAGS) trustee.c
 91 | nwext.o: nwext.c   $(incdeps)
 92 | 	$(CC) $(CFLAGS) nwext.c
 93 | suballoc.o: suballoc.c   $(incdeps)
 94 | 	$(CC) $(CFLAGS) suballoc.c
 95 | create.o: create.c   $(incdeps)
 96 | 	$(CC) $(CFLAGS) create.c
 97 | date.o: date.c       $(incdeps)
 98 | 	$(CC) $(CFLAGS) date.c
 99 | nwcreate.o: nwcreate.c   $(incdeps)
100 | 	$(CC) $(CFLAGS) nwcreate.c
101 | symlink.o: symlink.c   $(incdeps)
102 | 	$(CC) $(CFLAGS) symlink.c
103 | async.o: async.c   $(incdeps)
104 | 	$(CC) $(CFLAGS) async.c
105 | nwfix.o: nwfix.c   $(incdeps)
106 | 	$(CC) $(CFLAGS) nwfix.c
107 | 
108 | clean:
109 | 	rm -f nwvol nwvp nwview nwdump nwdisk nwconfig nwrepair nwfsinfo \
110 | 	nwimage nwbackup nwrestor *.o *.map *.log *.LOG 
111 | 
112 | 
113 | 


--------------------------------------------------------------------------------
/Makefile.kernel:
--------------------------------------------------------------------------------
 1 | #
 2 | # Makefile for the Linux nwfs filesystem routines.
 3 | #
 4 | # Note! Dependencies are done automagically by 'make dep', which also
 5 | # removes any old dependencies. DON'T put your own dependencies here
 6 | # unless it's something special (not a .c file).
 7 | #
 8 | # Note 2! The CFLAGS definitions are now in the main makefile.
 9 | 
10 | O_TARGET := nwfs.o
11 | O_OBJS   := nwvfs.o alloc.o disk.o nwpart.o volume.o globals.o lru.o  \
12 | 	    lock.o hash.o async.o fat.o bit.o block.o cluster.o dir.o         \
13 | 	    mmap.o inode.o super.o file.o ioctl.o nwdir.o nwfile.o nwfix.o \
14 | 	    trustee.o nwext.o suballoc.o create.o date.o              \
15 | 	    nwcreate.o symlink.o nwvp.o nwvphal.o 
16 | M_OBJS   := $(O_TARGET)
17 | 
18 | include $(TOPDIR)/Rules.make
19 | 


--------------------------------------------------------------------------------
/Makefile.module:
--------------------------------------------------------------------------------
  1 | 
  2 | #
  3 | # Makefile for the NWFS module For Linux.
  4 | #
  5 | 
  6 | CC = gcc
  7 | LINK = ld
  8 | CFLAGS = -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O2 \
  9 | 	 -fomit-frame-pointer -fno-strength-reduce -pipe -m386 -DCPU=386 \
 10 | 	 -I/usr/src/linux/include -c
 11 | 
 12 | ifdef MODVERSIONS
 13 | CFLAGS+=-DMODVERSIONS
 14 | endif
 15 | 
 16 | ifdef SMP
 17 | CFLAGS+=-D__SMP__
 18 | endif
 19 | 
 20 | LFLAGS = -m elf_i386 -Map nwfs.map -r -o 
 21 | 
 22 | incdeps = nwfs.h nwstruct.h nwdir.h nwhash.h nwproc.h nwvfs.h nwerror.h \
 23 | 	  globals.h
 24 | 
 25 | objects = nwvfs.o alloc.o disk.o nwpart.o volume.o globals.o lru.o  \
 26 | 	  lock.o hash.o async.o fat.o bit.o block.o cluster.o dir.o      \
 27 | 	  mmap.o inode.o super.o file.o ioctl.o nwdir.o nwfile.o nwfix.o  \
 28 | 	  trustee.o nwext.o suballoc.o create.o date.o                    \
 29 | 	  nwcreate.o symlink.o nwvp.o nwvphal.o 
 30 | 
 31 | nwfs.o: $(objects) 
 32 | 	$(LINK) $(LFLAGS) nwfs.o $(objects)
 33 | 
 34 | nwvfs.o: nwvfs.c     $(incdeps)
 35 | 	$(CC) $(CFLAGS) nwvfs.c
 36 | nwvp.o: nwvp.c       $(incdeps)
 37 | 	$(CC) $(CFLAGS) nwvp.c
 38 | nwvphal.o: nwvphal.c $(incdeps)
 39 | 	$(CC) $(CFLAGS) nwvphal.c
 40 | alloc.o: alloc.c     $(incdeps)
 41 | 	$(CC) $(CFLAGS) alloc.c
 42 | disk.o: disk.c       $(incdeps)
 43 | 	$(CC) $(CFLAGS) disk.c
 44 | nwpart.o: nwpart.c   $(incdeps)
 45 | 	$(CC) $(CFLAGS) nwpart.c
 46 | volume.o: volume.c   $(incdeps)
 47 | 	$(CC) $(CFLAGS) volume.c
 48 | fat.o: fat.c         $(incdeps)
 49 | 	$(CC) $(CFLAGS) fat.c
 50 | globals.o: globals.c $(incdeps)
 51 | 	$(CC) $(CFLAGS) globals.c
 52 | lock.o: lock.c       $(incdeps)
 53 | 	$(CC) $(CFLAGS) lock.c
 54 | hash.o: hash.c       $(incdeps)
 55 | 	$(CC) $(CFLAGS) hash.c
 56 | string.o: string.c   $(incdeps)
 57 | 	$(CC) $(CFLAGS) string.c
 58 | lru.o: lru.c         $(incdeps)
 59 | 	$(CC) $(CFLAGS) lru.c
 60 | bit.o: bit.c         $(incdeps)
 61 | 	$(CC) $(CFLAGS) bit.c
 62 | block.o: block.c     $(incdeps)
 63 | 	$(CC) $(CFLAGS) block.c
 64 | cluster.o: cluster.c $(incdeps)
 65 | 	$(CC) $(CFLAGS) cluster.c
 66 | dir.o: dir.c         $(incdeps)
 67 | 	$(CC) $(CFLAGS) dir.c
 68 | mmap.o: mmap.c       $(incdeps)
 69 | 	$(CC) $(CFLAGS) mmap.c
 70 | inode.o: inode.c     $(incdeps)
 71 | 	$(CC) $(CFLAGS) inode.c
 72 | super.o: super.c     $(incdeps)
 73 | 	$(CC) $(CFLAGS) super.c
 74 | file.o: file.c       $(incdeps)
 75 | 	$(CC) $(CFLAGS) file.c
 76 | ioctl.o: ioctl.c     $(incdeps)
 77 | 	$(CC) $(CFLAGS) ioctl.c
 78 | nwdir.o: nwdir.c     $(incdeps)
 79 | 	$(CC) $(CFLAGS) nwdir.c
 80 | nwfile.o: nwfile.c   $(incdeps)
 81 | 	$(CC) $(CFLAGS) nwfile.c
 82 | trustee.o: trustee.c   $(incdeps)
 83 | 	$(CC) $(CFLAGS) trustee.c
 84 | nwext.o: nwext.c   $(incdeps)
 85 | 	$(CC) $(CFLAGS) nwext.c
 86 | suballoc.o: suballoc.c   $(incdeps)
 87 | 	$(CC) $(CFLAGS) suballoc.c
 88 | create.o: create.c   $(incdeps)
 89 | 	$(CC) $(CFLAGS) create.c
 90 | date.o: date.c       $(incdeps)
 91 | 	$(CC) $(CFLAGS) date.c
 92 | nwcreate.o: nwcreate.c   $(incdeps)
 93 | 	$(CC) $(CFLAGS) nwcreate.c
 94 | symlink.o: symlink.c   $(incdeps)
 95 | 	$(CC) $(CFLAGS) symlink.c
 96 | async.o: async.c   $(incdeps)
 97 | 	$(CC) $(CFLAGS) async.c
 98 | nwfix.o: nwfix.c   $(incdeps)
 99 | 	$(CC) $(CFLAGS) nwfix.c
100 | 
101 | clean:
102 | 	rm -f *.o
103 | 
104 | 


--------------------------------------------------------------------------------
/Makefile.win2k:
--------------------------------------------------------------------------------
1 | #
2 | # DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
3 | # file to this component.  This file merely indirects to the real make file
4 | # that is shared by all the driver components of the Windows NT DDK
5 | #
6 | 
7 | !INCLUDE $(NTMAKEENV)\makefile.def
8 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | NETWARE-FILE-SYSTEM
  4 | 
  5 | 
  6 | NetWare SMP File System for Linux, Windows, and DOS
  7 | 
  8 | 
  9 | Table of Contents
 10 | 
 11 | -   Using the Build Script
 12 | -   Building with Manual Make Files
 13 | -   Windows File System Driver Components
 14 | -   Linux File System Driver Components
 15 | -   MS-DOS and DR-DOS File System Components
 16 | 
 17 | 
 18 | Using the Build Script
 19 | 
 20 |     #
 21 |     # ./build <option>
 22 |     #
 23 | 
 24 | from the directory where you install the NWFS sources. This newer model
 25 | auto detects modversioning, smp, etc. There is an assumption made that a
 26 | symbolic link to /usr/src/linux ->
 27 | 
 28 | newer Red Hat kernels no longer use this syntax. For the NWFS build to
 29 | work properly, you will need to have a pre-configured Linux source tree
 30 | present with a symbolic link to the /usr/src/linux directory.
 31 | 
 32 | Simply type ./build for a list of build options.
 33 | 
 34 | 
 35 | Building with Manual Make Files
 36 | 
 37 | The globals.h file contains the following table of options:
 38 | 
 39 |     #define  WINDOWS_NT_RO    0
 40 |     #define  WINDOWS_NT       0
 41 |     #define  WINDOWS_NT_UTIL  0
 42 |     #define  WINDOWS_CONVERT  0
 43 |     #define  WINDOWS_98_UTIL  0
 44 |     #define  LINUX_20         0
 45 |     #define  LINUX_22         1
 46 |     #define  LINUX_24         0
 47 |     #define  LINUX_UTIL       0
 48 |     #define  DOS_UTIL         0
 49 | 
 50 | select build environment (you can only select one at a time).
 51 | 
 52 | There are makefiles included for different kernel configurations. To
 53 | make the NWFS driver for Linux, select one of the following. The
 54 | makefiles support modversioned kernels and naked kernels.
 55 | 
 56 |     #define  LINUX_20         0
 57 |     #define  LINUX_22         1
 58 |     #define  LINUX_24         0
 59 | 
 60 | -   make -f nwfs.mak This will make an NWFS driver SMP-no MODVER-no
 61 | -   make -f nwfsmod.mak This will make an NWFS driver SMP-no MODVER-yes
 62 | -   make -f nwfssmp.mak This will make an NWFS driver SMP-yes MODVER-no
 63 | -   make -f nwmodsmp.mak This will make an NWFS driver SMP-yes
 64 |     MODVER-yes
 65 | 
 66 | The Linux versions are supported under the GCC Linux compiler To make
 67 | the Linux tools:
 68 | 
 69 |     #define  LINUX_UTIL       1
 70 | 
 71 | make -f util.mak
 72 | 
 73 | The DOS versions are supported under the DJ Delorie GCC MS-DOS compiler.
 74 | To make the MS-DOS tools:
 75 | 
 76 |     #define  DOS_UTIL       1
 77 | 
 78 | make -f dos.mak
 79 | 
 80 | The Windows NT/2000 versions are supported under Microsoft C++ 5.0 or
 81 | higher To make the WIndows NT/2000 tools:
 82 | 
 83 |     #define  WINDOWS_NT_UTIL       1
 84 | 
 85 | nmake /f utilms.mak
 86 | 
 87 | 
 88 | Windows File System Driver Components
 89 | 
 90 | -   NWFSRO.SYS Windows NT/2000 File System Driver
 91 | -   NWFSRO.INI Regini.exe import file
 92 | -   NWMOUNT.EXE Volume Mount Utility
 93 | -   NWDISMNT.EXE Volume Dismount Utility
 94 | -   NWVOL.EXE Volume Display Utility
 95 | -   NWCONFIG.EXE Volume Create/Mirroring/Namespace/Partition Manager
 96 |     (CWorthy)
 97 | -   NWDISK.EXE Volume Create/Mirroring/Namespace/Partition Manager
 98 |     (terminal)
 99 | -   NWVIEW.EXE Volume Directory Viewer
100 | -   NWREPAIR.EXE Volume Repair Utility
101 | 
102 | To install the Windows NT/2000 version, copy the NWFSRO.SYS driver to
103 | the %SYSTEM_ROOT%32directory (WINNT is the name of the %SYSTEM_ROOT% on
104 | most systems) and run regini.exe (which comes with the Windows NT/2000
105 | DDK) to add the registry entries to your system that will allow the
106 | driver to load at the next reboot.
107 | 
108 | Command syntax for regini.exe is:
109 | 
110 |     C:\>regini nwfsro.ini <enter>
111 | 
112 | To query available volumes on this machine that can be mounted, invoke
113 | NWVOL.EXE by typing:
114 | 
115 |     C:\>NWVOL
116 | 
117 | NWVOL will list all volumes detected on this server.
118 | 
119 |     NetWare Volume(s)
120 |     [SYS            ] sz-00003751 blk-65536  F/D-0000/0001  (OK)
121 |      NAMESPACES  [ DOS   LONG  NFS  ]
122 |      COMPRESS-YES SUBALLOC-YES MIGRATE-NO  AUDIT-NO
123 |       segment #0 Start-00000000 size-00001BA9
124 |       segment #1 Start-00001BA9 size-00001BA8
125 | 
126 | To mount a NetWare volume, type:
127 | 
128 |     C:\>nwmount *
129 | 
130 | This will mount all NetWare volumes on an NT/2000 server as Native
131 | Windows NT File Systems. You can also mount a specific volume by typing
132 | “nwmount VOLUME_NAME”.
133 | 
134 | Simply type NWMOUNT.EXE or NWDISMNT.EXE with no arguments and these
135 | programs will display additional help information.
136 | 
137 | You should copy the utilities into the /WINNT/System32 directory. If you
138 | want to change any volume configurations, you should only do so with the
139 | driver unloaded and all volumes dismounted. See NWCONFIG.EXE for very
140 | complete help on how to manage NetWare volumes.
141 | 
142 | 
143 | Linux File System Driver Components)
144 | 
145 | -   NWFS.O Linux NWFS 2.0 File System Driver
146 | -   NWVOL Volume Display Utility
147 | -   NWCONFIG Volume Create/Mirroring/Namespace/Partition Manager
148 |     (ncurses)
149 | -   NWDISK Volume Create/Mirroring/Namespace/Partition Manager
150 |     (terminal)
151 | -   NWVIEW Volume Directory Viewer
152 | -   NWREPAIR Volume Repair Utility
153 | 
154 | To install the Linux version of NWFS 2.0, copy the NWFS.O driver to the
155 | directory. Load the driver by typing:
156 | 
157 |     [root@localhost]#
158 |     [root@localhost]# insmod nwfs
159 |     [root@localhost]#
160 | 
161 | To query available volumes on this machine that can be mounted, invoke
162 | NWVOL by typing:
163 | 
164 |     [root@localhost]# NWVOL
165 | 
166 | NWVOL will list all volumes detected on this server.
167 | 
168 |     NetWare Volume(s)
169 |     [SYS            ] sz-00003751 blk-65536  F/D-0000/0001  (OK)
170 |      NAMESPACES  [ DOS   LONG  NFS  ]
171 |      COMPRESS-YES SUBALLOC-YES MIGRATE-NO  AUDIT-NO
172 |       segment #0 Start-00000000 size-00001BA9
173 |       segment #1 Start-00001BA9 size-00001BA8
174 | 
175 | To mount a NetWare Volume named “SYS” to a pre-exisitng mount point
176 | (directory) called /SYS, type:
177 | 
178 |     [root@localhost]#
179 |     [root@localhost]# mount sys /SYS -t nwfs -o SYS
180 |     [root@localhost]#
181 | 
182 | To dismount, type:
183 | 
184 |     [root@localhost]#
185 |     [root@localhost]# umount /SYS -t
186 |     [root@localhost]#
187 | 
188 | You should copy the utilities into the /usr/bin directory. If you want
189 | to change any volume configurations, you should only do so with the
190 | driver unloaded and all volumes dismounted. See NWCONFIG for very
191 | complete help on how to manage NetWare volumes.
192 | 
193 | 
194 | DOS File System Components
195 | 
196 | -   NWVOL.EXE Volume Display Utility
197 | -   NWCONFIG.EXE Volume Create/Mirroring/Namespace/Partition Manager
198 |     (CWorthy)
199 | -   NWDISK.EXE Volume Create/Mirroring/Namespace/Partition Manager
200 |     (terminal)
201 | -   NWVIEW.EXE Volume Directory Viewer
202 | -   NWREPAIR.EXE Volume Repair Utility
203 | 
204 | You should copy the utilities into the /DOS directory on your machine.
205 | See NWCONFIG.EXE for very complete help on how to manage NetWare volumes
206 | from DOS.
207 | 
208 | To query available volumes on this machine that can be mounted, invoke
209 | NWVOL.EXE by typing:
210 | 
211 |     C:\>NWVOL
212 | 
213 | NWVOL will list all volumes detected on this server.
214 | 
215 |     NetWare Volume(s)
216 |     [SYS            ] sz-00003751 blk-65536  F/D-0000/0001  (OK)
217 |      NAMESPACES  [ DOS   LONG  NFS  ]
218 |      COMPRESS-YES SUBALLOC-YES MIGRATE-NO  AUDIT-NO
219 |       segment #0 Start-00000000 size-00001BA9
220 |       segment #1 Start-00001BA9 size-00001BA8
221 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | NOTE:  This code project is very old and requires cleanup and was last maintained
  2 | in 2001.  When I get some time, I will update this project to the newer gcc compilers 
  3 | and modernize and test it.  This project is primarily provided for people who need to 
  4 | migrate data from old netware servers to linux or windows, and to provide a reference 
  5 | code set that describes the old netware filesystem on disk structures and namespaces
  6 | for the sake of history.  There is also a bug in the linux SMP code sections that 
  7 | creates problems for writing this filesystem due to how spinlocks are being used.  
  8 | This bug does not affect the windows or DOS builds, and is easily fixed.  The bug
  9 | deals with how spinlocks are used due to subtle changes between linux versions in 
 10 | how linux preserves flags using spinlocks that fails to properly restore interrupt
 11 | flags states.  I will add that fix to the TODO list.  Anyone who wants to help 
 12 | cleanup this old project is welcome just submit a pull request if you make some 
 13 | useful changes.  
 14 | For the Windows build, the nwfsro.ini file is missing from the main tree and was 
 15 | lost over time from the backups.  This file is used to install the nwfsro.sys driver
 16 | on Windows server.  This is added to the TODO list as well. 
 17 | 
 18 | # netware-file-system 
 19 | 
 20 | NetWare SMP File System for Linux, Windows, and DOS
 21 | 
 22 | ## Table of Contents 
 23 | - [Using the Build Script](using-the-build-script)
 24 | - [Building with Manual Make Files](building-with-manual-make-files)
 25 | - [Windows File System Driver Components](windows-file-system-driver-components)
 26 | - [Linux File System Driver Components](linux-file-system-driver-components)
 27 | - [MS-DOS and DR-DOS File System Components](dos-file-system-components)
 28 | 
 29 | ## Using the Build Script
 30 | 
 31 | ```sh
 32 | #
 33 | # ./build <option>
 34 | #
 35 | ```
 36 | 
 37 | from the directory where you install the NWFS sources.  This 
 38 | newer model auto detects modversioning, smp, etc.  There is 
 39 | an assumption made that a symbolic link to /usr/src/linux ->
 40 | 
 41 | newer Red Hat kernels no longer use this syntax.  For the 
 42 | NWFS build to work properly, you will need to have a 
 43 | pre-configured Linux source tree present with a symbolic 
 44 | link to the /usr/src/linux directory.
 45 | 
 46 | Simply type ./build for a list of build options.
 47 | 
 48 |  
 49 | ## Building with Manual Make Files
 50 | 
 51 | The globals.h file contains the following table of options:
 52 | 
 53 | ```sh
 54 | #define  WINDOWS_NT_RO    0
 55 | #define  WINDOWS_NT       0
 56 | #define  WINDOWS_NT_UTIL  0
 57 | #define  WINDOWS_CONVERT  0
 58 | #define  WINDOWS_98_UTIL  0
 59 | #define  LINUX_20         0
 60 | #define  LINUX_22         1
 61 | #define  LINUX_24         0
 62 | #define  LINUX_UTIL       0
 63 | #define  DOS_UTIL         0
 64 | ```
 65 | 
 66 | select build environment (you can only select one at a time).  
 67 | 
 68 | There are makefiles included for different kernel configurations.  To
 69 | make the NWFS driver for Linux, select one of the following.  The
 70 | makefiles support modversioned kernels and naked kernels.
 71 | 
 72 | ```sh
 73 | #define  LINUX_20         0
 74 | #define  LINUX_22         1
 75 | #define  LINUX_24         0
 76 | ```
 77 | - make -f nwfs.mak         This will make an NWFS driver SMP-no  MODVER-no
 78 | - make -f nwfsmod.mak      This will make an NWFS driver SMP-no  MODVER-yes
 79 | - make -f nwfssmp.mak      This will make an NWFS driver SMP-yes MODVER-no
 80 | - make -f nwmodsmp.mak     This will make an NWFS driver SMP-yes MODVER-yes
 81 | 
 82 | The Linux versions are supported under the GCC Linux compiler
 83 | To make the Linux tools:
 84 | ```sh
 85 | #define  LINUX_UTIL       1
 86 | ```
 87 | make -f util.mak
 88 | 
 89 | The DOS versions are supported under the DJ Delorie GCC MS-DOS compiler.
 90 | To make the MS-DOS tools:
 91 | ```sh
 92 | #define  DOS_UTIL       1
 93 | ```
 94 | make -f dos.mak
 95 | 
 96 | The Windows NT/2000 versions are supported under Microsoft C++ 5.0 or higher
 97 | To make the WIndows NT/2000 tools:
 98 | ```sh
 99 | #define  WINDOWS_NT_UTIL       1
100 | ```
101 | nmake /f utilms.mak
102 | 
103 | ## Windows File System Driver Components
104 | 
105 | - NWFSRO.SYS     Windows NT/2000 File System Driver
106 | - NWFSRO.INI     Regini.exe import file
107 | - NWMOUNT.EXE    Volume Mount Utility
108 | - NWDISMNT.EXE   Volume Dismount Utility
109 | - NWVOL.EXE      Volume Display Utility
110 | - NWCONFIG.EXE   Volume Create/Mirroring/Namespace/Partition Manager (CWorthy)
111 | - NWDISK.EXE     Volume Create/Mirroring/Namespace/Partition Manager (terminal)
112 | - NWVIEW.EXE     Volume Directory Viewer
113 | - NWREPAIR.EXE   Volume Repair Utility
114 | 
115 | To install the Windows NT/2000 version, copy the NWFSRO.SYS driver
116 | to the \%SYSTEM_ROOT%\System32\drivers directory (WINNT is the name of
117 | the %SYSTEM_ROOT% on most systems) and run regini.exe (which comes with
118 | the Windows NT/2000 DDK) to add the registry entries to your system
119 | that will allow the driver to load at the next reboot.
120 | 
121 | Command syntax for regini.exe is:
122 | ```sh
123 | C:\>regini nwfsro.ini <enter>
124 | ```
125 | To query available volumes on this machine that can be mounted, invoke
126 | NWVOL.EXE by typing:
127 | ```sh
128 | C:\>NWVOL
129 | ```
130 | NWVOL will list all volumes detected on this server.
131 | ```sh
132 | NetWare Volume(s)
133 | [SYS            ] sz-00003751 blk-65536  F/D-0000/0001  (OK)
134 |  NAMESPACES  [ DOS   LONG  NFS  ]
135 |  COMPRESS-YES SUBALLOC-YES MIGRATE-NO  AUDIT-NO
136 |   segment #0 Start-00000000 size-00001BA9
137 |   segment #1 Start-00001BA9 size-00001BA8
138 | ```
139 | To mount a NetWare volume, type:
140 | ```sh
141 | C:\>nwmount *
142 | ```
143 | This will mount all NetWare volumes on an NT/2000 server as Native Windows
144 | NT File Systems.  You can also mount a specific volume by typing "nwmount
145 | VOLUME_NAME".
146 | 
147 | Simply type NWMOUNT.EXE or NWDISMNT.EXE with no arguments and these
148 | programs will display additional help information.  
149 | 
150 | You should copy the utilities into the /WINNT/System32 directory.  If
151 | you want to change any volume configurations, you should only do so
152 | with the driver unloaded and all volumes dismounted.  See NWCONFIG.EXE
153 | for very complete help on how to manage NetWare volumes.
154 | 
155 | 
156 | ## Linux File System Driver Components)
157 | 
158 | - NWFS.O         Linux NWFS 2.0 File System Driver
159 | - NWVOL          Volume Display Utility
160 | - NWCONFIG       Volume Create/Mirroring/Namespace/Partition Manager (ncurses)
161 | - NWDISK         Volume Create/Mirroring/Namespace/Partition Manager (terminal)
162 | - NWVIEW         Volume Directory Viewer
163 | - NWREPAIR       Volume Repair Utility
164 | 
165 | To install the Linux version of NWFS 2.0, copy the NWFS.O driver
166 | to the \lib\modules\misc directory.  Load the driver by typing:
167 | ```sh
168 | [root@localhost]#
169 | [root@localhost]# insmod nwfs
170 | [root@localhost]#
171 | ```
172 | To query available volumes on this machine that can be mounted, invoke
173 | NWVOL by typing:
174 | ```sh
175 | [root@localhost]# NWVOL
176 | ```
177 | NWVOL will list all volumes detected on this server.
178 | ```sh
179 | NetWare Volume(s)
180 | [SYS            ] sz-00003751 blk-65536  F/D-0000/0001  (OK)
181 |  NAMESPACES  [ DOS   LONG  NFS  ]
182 |  COMPRESS-YES SUBALLOC-YES MIGRATE-NO  AUDIT-NO
183 |   segment #0 Start-00000000 size-00001BA9
184 |   segment #1 Start-00001BA9 size-00001BA8
185 | ```
186 | 
187 | To mount a NetWare Volume named "SYS" to a pre-exisitng mount point
188 | (directory) called /SYS, type:
189 | ```sh
190 | [root@localhost]#
191 | [root@localhost]# mount sys /SYS -t nwfs -o SYS
192 | [root@localhost]#
193 | ```
194 | To dismount, type:
195 | ```sh
196 | [root@localhost]#
197 | [root@localhost]# umount /SYS -t
198 | [root@localhost]#
199 | ```
200 | You should copy the utilities into the /usr/bin directory.  If you want to
201 | change any volume configurations, you should only do so with the driver
202 | unloaded and all volumes dismounted.  See NWCONFIG
203 | for very complete help on how to manage NetWare volumes.
204 | 
205 | 
206 | ## DOS File System Components
207 | 
208 | - NWVOL.EXE      Volume Display Utility
209 | - NWCONFIG.EXE   Volume Create/Mirroring/Namespace/Partition Manager (CWorthy)
210 | - NWDISK.EXE     Volume Create/Mirroring/Namespace/Partition Manager (terminal)
211 | - NWVIEW.EXE     Volume Directory Viewer
212 | - NWREPAIR.EXE   Volume Repair Utility
213 | 
214 | You should copy the utilities into the /DOS directory on your machine.
215 | See NWCONFIG.EXE for very complete help on how to manage NetWare volumes
216 | from DOS.
217 | 
218 | To query available volumes on this machine that can be mounted, invoke
219 | NWVOL.EXE by typing:
220 | ```sh
221 | C:\>NWVOL
222 | ```
223 | NWVOL will list all volumes detected on this server.
224 | ```sh
225 | NetWare Volume(s)
226 | [SYS            ] sz-00003751 blk-65536  F/D-0000/0001  (OK)
227 |  NAMESPACES  [ DOS   LONG  NFS  ]
228 |  COMPRESS-YES SUBALLOC-YES MIGRATE-NO  AUDIT-NO
229 |   segment #0 Start-00000000 size-00001BA9
230 |   segment #1 Start-00001BA9 size-00001BA8
231 | ```
232 | 


--------------------------------------------------------------------------------
/build:
--------------------------------------------------------------------------------
  1 | #!/bin/sh
  2 | 
  3 | if [ "$1" = "help" -o "$1" = "HELP" ]; then
  4 |    echo "./build help         - this help screen" 
  5 |    echo "./build clean        - do a clean build" 
  6 |    echo "./build all          - build everything" 
  7 |    echo "./build util         - build linux NWFS utilities" 
  8 |    echo "./build driver       - build linux NWFS file system" 
  9 |    echo "./build install      - install NWFS file system/utils" 
 10 |    echo ""
 11 | 
 12 | elif [ "$1" = "install" -o "$1" = "install" ]; then
 13 |    install -m 755 nwvol /usr/sbin
 14 |    install -m 755 nwvp /usr/sbin
 15 |    install -m 755 nwdisk /usr/sbin
 16 |    install -m 755 nwdump /usr/sbin
 17 |    install -m 755 nwview /usr/sbin
 18 |    install -m 755 nwconfig /usr/sbin
 19 |    install -m 755 nwrepair /usr/sbin
 20 | 
 21 | elif [ "$1" = "clean" -o "$1" = "CLEAN" ]; then
 22 |    make clean 
 23 | 
 24 | elif [ "$1" = "all" -o "$1" = "ALL" ]; then
 25 |    echo "performing a build clean"
 26 |    make clean 
 27 | 
 28 |    echo "building NWFS utilities"
 29 |    LINUX_UTILITY="1"
 30 |    export LINUX_UTILITY
 31 | 
 32 |    make -f util.mak
 33 | 
 34 |    echo "building NWFS driver"
 35 |    
 36 |    echo "performing a build clean"
 37 |    make clean 
 38 |    
 39 |    LINUX_DRIVER="1"
 40 |    export LINUX_DRIVER
 41 |    
 42 |    if grep "CONFIG_MODVERSIONS=y" /usr/src/linux/.config; then
 43 |        MODVERSIONS="1"
 44 |        echo "MODVERSIONING support is present"
 45 |    else
 46 |        MODVERSIONS=""
 47 |        echo "MODVERSIONING support not present"
 48 |    fi
 49 | 
 50 |    if grep "CONFIG_SMP=y" /usr/src/linux/.config; then
 51 |        SMP="1"
 52 |        echo "SMP support detected"
 53 |    else
 54 |        SMP=""
 55 |        echo "UP support detected"
 56 |    fi
 57 | 
 58 |    export MODVERSIONS
 59 |    export SMP
 60 | 
 61 |    make 
 62 | 
 63 | elif [ "$1" = "util" -o "$1" = "UTIL" ]; then
 64 |    LINUX_UTILITY="1"
 65 |    export LINUX_UTILITY
 66 | 
 67 |    make -f util.mak
 68 | 
 69 | elif [ "$1" = "driver" -o "$1" = "DRIVER" ]; then
 70 |    LINUX_DRIVER="1"
 71 |    export LINUX_DRIVER
 72 |    
 73 |    if grep "CONFIG_MODVERSIONS=y" /usr/src/linux/.config; then
 74 |        MODVERSIONS="1"
 75 |        echo "MODVERSIONING support is present"
 76 |    else
 77 |        MODVERSIONS=""
 78 |        echo "MODVERSIONING support not present"
 79 |    fi
 80 | 
 81 |    if grep "CONFIG_SMP=y" /usr/src/linux/.config; then
 82 |        SMP="1"
 83 |        echo "SMP support detected"
 84 |    else
 85 |        SMP=""
 86 |        echo "UP support detected"
 87 |    fi
 88 | 
 89 |    export MODVERSIONS
 90 |    export SMP
 91 | 
 92 |    make 
 93 | 
 94 | else
 95 |    echo "./build help         - this help screen" 
 96 |    echo "./build clean        - do a clean build" 
 97 |    echo "./build all          - build everything" 
 98 |    echo "./build util         - build linux NWFS utilities" 
 99 |    echo "./build driver       - build linux NWFS file system" 
100 |    echo "./build install      - install NWFS file system/utils" 
101 |    echo ""
102 | 
103 | fi
104 | 
105 | 
106 | 


--------------------------------------------------------------------------------
/console.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /***************************************************************************
  3 | *
  4 | *   Copyright (c) 1997-2022 Jeff V. Merkey
  5 | *   7260 SE Tenino St.
  6 | *   Portland, Oregon 97206
  7 | *   jeffmerkey@gmail.com
  8 | *
  9 | *   This program is free software; you can redistribute it and/or modify it
 10 | *   under the terms of the Lesser GNU Public License as published by the
 11 | *   Free Software Foundation, version 2.1, or any later version.
 12 | *
 13 | *   This program is distributed in the hope that it will be useful, but
 14 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
 15 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 16 | *   General Public License for more details.
 17 | *
 18 | *   Original Authorship      :
 19 | *      source code written by Jeff V. Merkey
 20 | *
 21 | *   Original Contributors    :
 22 | *      Jeff V. Merkey
 23 | *      
 24 | *      
 25 | *
 26 | ****************************************************************************
 27 | *
 28 | *
 29 | *   AUTHOR   :  Jeff V. Merkey (jeffmerkey@gmail.com)
 30 | *   FILE     :  CONSOLE.C
 31 | *   DESCRIP  :  Console Abstraction Layer
 32 | *   DATE     :  November 1, 1998
 33 | *
 34 | *
 35 | ***************************************************************************/
 36 | 
 37 | #include "globals.h"
 38 | 
 39 | 
 40 | #if (WINDOWS_NT_UTIL)
 41 | 
 42 | void cls(void)
 43 | {
 44 |    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
 45 | 
 46 |    COORD coordScreen = { 0, 0 };    /* here's where we'll home the
 47 | 				       cursor */
 48 |    BOOL bSuccess;
 49 |    DWORD cCharsWritten;
 50 |    CONSOLE_SCREEN_BUFFER_INFO csbi; /* to get buffer info */
 51 |    DWORD dwConSize;                 /* number of character cells in
 52 | 				       the current buffer */
 53 | 
 54 |    /* get the number of character cells in the current buffer */
 55 | 
 56 |    bSuccess = GetConsoleScreenBufferInfo( hConsole, &csbi );
 57 |    dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
 58 | 
 59 |    /* fill the entire screen with blanks */
 60 | 
 61 |    bSuccess = FillConsoleOutputCharacter( hConsole, (TCHAR) ' ',
 62 |       dwConSize, coordScreen, &cCharsWritten );
 63 | 
 64 |    /* get the current text attribute */
 65 | 
 66 |    bSuccess = GetConsoleScreenBufferInfo( hConsole, &csbi );
 67 | 
 68 |    /* now set the buffer's attributes accordingly */
 69 | 
 70 |    bSuccess = FillConsoleOutputAttribute( hConsole, csbi.wAttributes,
 71 |       dwConSize, coordScreen, &cCharsWritten );
 72 | 
 73 |    /* put the cursor at (0, 0) */
 74 | 
 75 |    bSuccess = SetConsoleCursorPosition( hConsole, coordScreen );
 76 | 
 77 |    return;
 78 | }
 79 | 
 80 | void ClearScreen(ULONG context)
 81 | {
 82 |     cls();
 83 | }
 84 | 
 85 | void WaitForKey()
 86 | {
 87 |     NWFSPrint("        Press Any Key To Continue ...");
 88 |     getc(stdin);
 89 | }
 90 | 
 91 | ULONG Pause(void)
 92 | {
 93 |     BYTE ch;
 94 | 
 95 |     ch = getc(stdin);
 96 |     if (ch == 0x27)
 97 |        return 1;
 98 |     return 0;
 99 | }
100 | 
101 | #endif
102 | 
103 | 
104 | #if (LINUX_UTIL)
105 | 
106 | void ClearScreen(ULONG context)
107 | {
108 |     printf("%c%c", 0x1B, 'c'); // Reset Console
109 | }
110 | 
111 | void WaitForKey()
112 | {
113 |     NWFSPrint("        Press Any Key To Continue ...");
114 |     getc(stdin);
115 | }
116 | 
117 | ULONG Pause(void)
118 | {
119 |     BYTE ch;
120 | 
121 |     ch = getc(stdin);
122 |     if (ch == 0x27)
123 |        return 1;
124 |     return 0;
125 | }
126 | 
127 | #endif
128 | 
129 | 
130 | #if (DOS_UTIL)
131 | 
132 | void ClearScreen(ULONG context)
133 | {
134 |     union REGS r;
135 | 
136 |     // clear the screen
137 | 
138 |     r.h.ah = 6;  // scroll command
139 |     r.h.al = 0;  // clear screen code
140 |     r.h.ch = 0;  // start row
141 |     r.h.cl = 0;  // start column
142 |     r.h.dh = 24; // end row
143 |     r.h.dl = 79; // end column
144 |     r.h.bh = 7;  // blank line is blank
145 | 
146 |     int86(0x10, &r, &r);  // go to real mode
147 | 
148 |     // goto_xy (0, 0)
149 | 
150 |     r.h.ah = 2;  // cursor address command
151 |     r.h.bh = 0;  // code page 0
152 |     r.h.dh = 0;  // x = 0
153 |     r.h.dl = 0;  // y = 0
154 | 
155 |     int86(0x10, &r, &r);  // go to real mode
156 | 
157 | }
158 | 
159 | void WaitForKey()
160 | {
161 |     NWFSPrint("        Press Any Key To Continue ...");
162 |     getc(stdin);
163 | }
164 | 
165 | ULONG Pause(void)
166 | {
167 |     BYTE ch;
168 | 
169 |     ch = getc(stdin);
170 |     if (ch == 0x27)
171 |        return 1;
172 |     return 0;
173 | }
174 | 
175 | #endif
176 | 
177 | 


--------------------------------------------------------------------------------
/dos.bat:
--------------------------------------------------------------------------------
1 | make -f dos.mak
2 | 


--------------------------------------------------------------------------------
/dos.mak:
--------------------------------------------------------------------------------
  1 | 
  2 | CC = gcc
  3 | LINK = ld
  4 | CFLAGS = -Wall -Wstrict-prototypes -c -g
  5 | 
  6 | LFLAGS = -Map nwfs.map -r -o
  7 | 
  8 | incdeps = nwfs.h nwstruct.h nwdir.h nwhash.h nwproc.h nwvfs.h nwerror.h \
  9 | 	  globals.h nwmenu.h
 10 | 
 11 | objects = nwvfs.o alloc.o disk.o nwpart.o volume.o globals.o lru.o  \
 12 | 	  lock.o hash.o fat.o bit.o block.o cluster.o dir.o         \
 13 | 	  mmap.o inode.o super.o file.o ioctl.o nwdir.o nwfile.o    \
 14 | 	  trustee.o nwext.o suballoc.o create.o date.o nwfix.o      \
 15 | 	  nwcreate.o symlink.o nwvp.o nwvphal.o fileutil.o     \
 16 | 	  console.o async.o nwmenu.o nwtool.o
 17 | 
 18 | all: nwfs.o nwvol.exe nwdisk.exe nwvp.exe \
 19 |      nwdump.exe nwview.exe nwconfig.exe nwrepair.exe
 20 | 
 21 | nwconfig.exe: $(objects) nwfs.o nwconfig.o filter.o
 22 | 	$(CC) nwconfig.o filter.o nwfs.o -o nwconfig.exe
 23 | 
 24 | nwrepair.exe:  $(objects) nwfs.o nwrepair.o nofilt.o
 25 | 	$(CC) nwrepair.o nofilt.o nwfs.o -o nwrepair.exe
 26 | 
 27 | nwvol.exe:  $(objects) nwfs.o nwvol.o nofilt.o
 28 | 	$(CC) nwvol.o nofilt.o nwfs.o -o nwvol.exe
 29 | 
 30 | nwdisk.exe:  $(objects) nwfs.o nwdisk.o nofilt.o
 31 | 	$(CC) nwdisk.o nofilt.o nwfs.o -o nwdisk.exe
 32 | 
 33 | nwvp.exe: $(objects) nwvpmain.o vcommand.o vconsole.o nwfs.o nofilt.o
 34 | 	$(CC) nwvpmain.o vcommand.o vconsole.o nofilt.o nwfs.o -o nwvp.exe
 35 | 
 36 | nwdump.exe:  $(objects) nwfs.o nwdump.o nofilt.o
 37 | 	$(CC) nwdump.o nofilt.o nwfs.o -o nwdump.exe
 38 | 
 39 | nwview.exe:  $(objects) nwfs.o nwview.o nofilt.o
 40 | 	$(CC) nwview.o nofilt.o nwfs.o -o nwview.exe
 41 | 
 42 | #
 43 | #
 44 | #
 45 | 
 46 | nwfs.o: $(objects)
 47 | 	$(LINK) $(LFLAGS) nwfs.o $(objects)
 48 | 
 49 | nwconfig.o : nwconfig.c $(incdeps) nwhelp.h
 50 | 	$(CC) $(CFLAGS) nwconfig.c
 51 | 
 52 | nwimage.o : nwimage.c $(incdeps) nwconfig.c nwhelp.h
 53 | 	$(CC) $(CFLAGS) nwimage.c
 54 | 
 55 | nwbackup.o : nwbackup.c $(incdeps)
 56 | 	$(CC) $(CFLAGS) nwbackup.c
 57 | 
 58 | nwrestor.o : nwrestor.c $(incdeps)
 59 | 	$(CC) $(CFLAGS) nwrestor.c
 60 | 
 61 | nwrepair.o : nwrepair.c $(incdeps)
 62 | 	$(CC) $(CFLAGS) nwrepair.c
 63 | 
 64 | nwvol.o : nwvol.c $(incdeps)
 65 | 	$(CC) $(CFLAGS) nwvol.c
 66 | 
 67 | nwdisk.o : nwdisk.c $(incdeps)
 68 | 	$(CC) $(CFLAGS) nwdisk.c
 69 | 
 70 | nwdump.o : nwdump.c $(incdeps)
 71 | 	$(CC) $(CFLAGS) nwdump.c
 72 | 
 73 | nwview.o : nwview.c $(incdeps)
 74 | 	$(CC) $(CFLAGS) nwview.c
 75 | 
 76 | vcommand.o: vcommand.c $(incdeps)
 77 | 	$(CC) $(CFLAGS) vcommand.c
 78 | vconsole.o: vconsole.c $(incdeps)
 79 | 	$(CC) $(CFLAGS) vconsole.c
 80 | nwvpmain.o: nwvpmain.c $(incdeps)
 81 | 	$(CC) $(CFLAGS) nwvpmain.c
 82 | 
 83 | #
 84 | #
 85 | #
 86 | 
 87 | nwvfs.o: nwvfs.c     $(incdeps)
 88 | 	$(CC) $(CFLAGS) nwvfs.c
 89 | nwformat.o: nwformat.c $(incdeps)
 90 | 	$(CC) $(CFLAGS) nwformat.c
 91 | nwvp.o:	nwvp.c    $(incdeps)
 92 | 	$(CC) $(CFLAGS) nwvp.c
 93 | nwvphal.o: nwvphal.c $(incdeps)
 94 | 	$(CC) $(CFLAGS) nwvphal.c
 95 | alloc.o: alloc.c     $(incdeps)
 96 | 	$(CC) $(CFLAGS) alloc.c
 97 | disk.o: disk.c       $(incdeps)
 98 | 	$(CC) $(CFLAGS) disk.c
 99 | nwpart.o: nwpart.c   $(incdeps)
100 | 	$(CC) $(CFLAGS) nwpart.c
101 | volume.o: volume.c   $(incdeps)
102 | 	$(CC) $(CFLAGS) volume.c
103 | fat.o: fat.c         $(incdeps)
104 | 	$(CC) $(CFLAGS) fat.c
105 | globals.o: globals.c $(incdeps)
106 | 	$(CC) $(CFLAGS) globals.c
107 | lock.o: lock.c       $(incdeps)
108 | 	$(CC) $(CFLAGS) lock.c
109 | hash.o: hash.c       $(incdeps)
110 | 	$(CC) $(CFLAGS) hash.c
111 | string.o: string.c   $(incdeps)
112 | 	$(CC) $(CFLAGS) string.c
113 | lru.o: lru.c         $(incdeps)
114 | 	$(CC) $(CFLAGS) lru.c
115 | bit.o: bit.c         $(incdeps)
116 | 	$(CC) $(CFLAGS) bit.c
117 | block.o: block.c     $(incdeps)
118 | 	$(CC) $(CFLAGS) block.c
119 | cluster.o: cluster.c $(incdeps)
120 | 	$(CC) $(CFLAGS) cluster.c
121 | dir.o: dir.c         $(incdeps)
122 | 	$(CC) $(CFLAGS) dir.c
123 | mmap.o: mmap.c       $(incdeps)
124 | 	$(CC) $(CFLAGS) mmap.c
125 | inode.o: inode.c     $(incdeps)
126 | 	$(CC) $(CFLAGS) inode.c
127 | super.o: super.c     $(incdeps)
128 | 	$(CC) $(CFLAGS) super.c
129 | file.o: file.c       $(incdeps)
130 | 	$(CC) $(CFLAGS) file.c
131 | ioctl.o: ioctl.c     $(incdeps)
132 | 	$(CC) $(CFLAGS) ioctl.c
133 | nwdir.o: nwdir.c     $(incdeps)
134 | 	$(CC) $(CFLAGS) nwdir.c
135 | nwfile.o: nwfile.c   $(incdeps)
136 | 	$(CC) $(CFLAGS) nwfile.c
137 | trustee.o: trustee.c   $(incdeps)
138 | 	$(CC) $(CFLAGS) trustee.c
139 | nwext.o: nwext.c   $(incdeps)
140 | 	$(CC) $(CFLAGS) nwext.c
141 | suballoc.o: suballoc.c   $(incdeps)
142 | 	$(CC) $(CFLAGS) suballoc.c
143 | create.o: create.c   $(incdeps)
144 | 	$(CC) $(CFLAGS) create.c
145 | date.o: date.c       $(incdeps)
146 | 	$(CC) $(CFLAGS) date.c
147 | nwcreate.o: nwcreate.c   $(incdeps)
148 | 	$(CC) $(CFLAGS) nwcreate.c
149 | symlink.o: symlink.c   $(incdeps)
150 | 	$(CC) $(CFLAGS) symlink.c
151 | fileutil.o: fileutil.c   $(incdeps)
152 | 	$(CC) $(CFLAGS) fileutil.c
153 | console.o: console.c   $(incdeps)
154 | 	$(CC) $(CFLAGS) console.c
155 | nwmenu.o: nwmenu.c   $(incdeps)
156 | 	$(CC) $(CFLAGS) nwmenu.c
157 | filter.o: filter.c   $(incdeps)
158 | 	$(CC) $(CFLAGS) filter.c
159 | nofilt.o: nofilt.c   $(incdeps)
160 | 	$(CC) $(CFLAGS) nofilt.c
161 | async.o: async.c   $(incdeps)
162 | 	$(CC) $(CFLAGS) async.c
163 | nwtool.o: nwtool.c   $(incdeps)
164 | 	$(CC) $(CFLAGS) nwtool.c
165 | nwfix.o: nwfix.c   $(incdeps)
166 | 	$(CC) $(CFLAGS) nwfix.c
167 | 
168 | clean:
169 | 	del *.o
170 | 	del *.exe
171 | 
172 | 


--------------------------------------------------------------------------------
/dos2unix.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <stdio.h>
 3 | #include <stdlib.h>
 4 | 
 5 | int main(int argc, char *argv[])
 6 | {
 7 |     unsigned char ch;
 8 |     FILE *fp, *fl;
 9 | 
10 |     if (argc < 3)
11 |     {
12 |        printf("USAGE:  dos2unix <input> <output>\n");
13 |        exit(0);
14 |     }
15 | 
16 |     fp = fopen(argv[1], "rb");
17 |     if (!fp)
18 |     {
19 |        printf("error opening input file %s\n", argv[1]);
20 |        exit(0);
21 |     }
22 | 
23 |     fl = fopen(argv[2], "wb");
24 |     if (!fl)
25 |     {
26 |        printf("error opening ouput file %s\n", argv[2]);
27 |        fclose(fp);
28 |        exit(0);
29 |     }
30 | 
31 |     while (!feof(fp))
32 |     {
33 |        ch = getc(fp);
34 |        if (ch == '\r')
35 |           continue;
36 |        putc(ch, fl);
37 |     }
38 |     fclose(fp);
39 |     fclose(fl);
40 | 
41 |     exit(0);
42 | }
43 | 


--------------------------------------------------------------------------------
/dump.c:
--------------------------------------------------------------------------------
  1 | 
  2 | #include <stdio.h>
  3 | #include <stdlib.h>
  4 | #include <fcntl.h>
  5 | 
  6 | unsigned char *dumpAsBytes(unsigned char *p, unsigned long size, unsigned long base)
  7 | {
  8 |    register unsigned long i, r, total, count;
  9 |    register unsigned char *op = p;
 10 | 
 11 |    count = size / 16;
 12 | 
 13 |    printf("           0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F\n");
 14 | 
 15 |    for (r=0; r < count; r++)
 16 |    {
 17 |       printf("%08X ", (p - op) + base);
 18 |       for (total = 0, i=0; i < 16; i++, total++)
 19 |       {
 20 | 	 printf(" %02X", (unsigned char) p[i]);
 21 |       }
 22 |       printf("  ");
 23 |       for (i=0; i < total; i++)
 24 |       {
 25 | 	 if (p[i] < 32 || p[i] > 126)
 26 | 	    printf(".");
 27 | 	 else printf("%c", p[i]);
 28 |       }
 29 |       printf("\n");
 30 | 
 31 |       p = (void *)((unsigned long) p + (unsigned long) total);
 32 |    }
 33 |    return p;
 34 | 
 35 | }
 36 | 
 37 | unsigned char *dumpAsLong(unsigned char *p, unsigned long size, unsigned long base)
 38 | {
 39 |    register int i, r, count;
 40 |    register unsigned char *op = p;
 41 |    unsigned long *lp;
 42 | 
 43 |    count = size / 16;
 44 | 
 45 |    lp = (unsigned long *) p;
 46 | 
 47 |    for (r=0; r < count; r++)
 48 |    {
 49 |       printf("%08X ", (p - op) + base);
 50 |       for (i=0; i < (16 / 4); i++)
 51 |       {
 52 | 	 printf(" %08X", (unsigned long) lp[i]);
 53 |       }
 54 |       printf("  ");
 55 |       for (i=0; i < 16; i++)
 56 |       {
 57 | 	 if (p[i] < 32 || p[i] > 126) printf(".");
 58 | 	 else printf("%c", p[i]);
 59 |       }
 60 |       printf("\n");
 61 | 
 62 |       p = (void *)((unsigned long) p + (unsigned long) 16);
 63 |       lp = (unsigned long *) p;
 64 |    }
 65 |    return p;
 66 | 
 67 | }
 68 | 
 69 | int getch(void)
 70 | {
 71 |    return getc(stdin);
 72 | }
 73 | 
 74 | unsigned long pause(void)
 75 | {
 76 |    extern int getch(void);
 77 |    register unsigned long key;
 78 | 
 79 |    printf(" --- More --- ");
 80 |    key = getch();
 81 |    printf("%c              %c", '\r', '\r');
 82 |    if (key == 0x1B) // ESCAPE
 83 |       return 1;
 84 |    else
 85 |       return 0;
 86 | 
 87 | }
 88 | unsigned char buffer[512];
 89 | 
 90 | 
 91 | int main(int argc, char *argv[])
 92 | {
 93 |     long rc, total = 0, offset = 0;
 94 |     FILE *fp;
 95 | 
 96 |     if (argc < 2)
 97 |     {
 98 |        printf("USAGE:  dump <filename.ext> <offset>\n");
 99 |        return 1;
100 |     }
101 | 
102 |     if (argc == 3)
103 |        offset = atol(argv[2]);
104 | 
105 | 
106 |     fp = fopen(argv[1], "rb");
107 |     if (!fp)
108 |     {
109 |        printf("error opening file [%s]\n", argv[1]);
110 |        return 1;
111 |     }
112 | 
113 |     rc = fseek(fp, offset, SEEK_SET);
114 |     if (rc == -1)
115 |     {
116 |        printf("error seeking file offset %d\n", offset);
117 |        return 1;
118 |     }
119 | 
120 |     total = offset;
121 |     while (!feof(fp))
122 |     {
123 |        rc = fread(buffer, 256, 1, fp);
124 |        dumpAsBytes(buffer, 256, total);
125 |        total += 256;
126 | 
127 |        if (pause())
128 | 	  break;
129 |     }
130 | 
131 |     fclose(fp);
132 |     return 0;
133 | }
134 | 


--------------------------------------------------------------------------------
/fileutil.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /***************************************************************************
  3 | *
  4 | *   Copyright (c) 1997-2022 Jeff V. Merkey  All Rights
  5 | *			    Reserved.
  6 | *
  7 | *   Original Authorship      :
  8 | *      source code written by Jeff V. Merkey
  9 | *
 10 | *   Original Contributors    :
 11 | *      Jeff V. Merkey
 12 | *
 13 | ***************************************************************************/
 14 | 
 15 | #include "globals.h"
 16 | 
 17 | #if (WINDOWS_NT_UTIL)
 18 | 
 19 | #include "fileutil.h"
 20 | 
 21 | #include <string.h>     // for strncpy
 22 | #ifdef UNICODE
 23 | #define _tcsrchr	wcsrchr
 24 | #else
 25 | #define _tcsrchr	strrchr
 26 | #endif
 27 | 
 28 | #define DRIVE_DELIMITER          TEXT(':')
 29 | #define DIRECTORY_DELIMITER      TEXT('\\')
 30 | #define EXTENSION_DELIMITER      TEXT('.')
 31 | 
 32 | #if 0
 33 | VOID FileErrorMessageBox(HWND hWnd, LPTSTR lpszFileName, DWORD ErrorCode)
 34 |    {
 35 |    TCHAR szErrorMessage[FILE_ERROR_MESSAGE_SIZE] ;
 36 |    TCHAR szErrorMessageTemplate[FILE_ERROR_MESSAGE_SIZE] ;
 37 | 
 38 |    StringLoad (IDS_FILE_ERROR, szErrorMessageTemplate) ;
 39 |    TSPRINTF((LPTSTR)szErrorMessage,
 40 |             (LPTSTR)szErrorMessageTemplate,
 41 |             lpszFileName,
 42 |             ErrorCode) ;
 43 | 
 44 |    MessageBox (hWnd, (LPTSTR)szErrorMessage, NULL,
 45 |               MB_OK | MB_ICONSTOP | MB_TASKMODAL);
 46 |    return ;
 47 |    }
 48 | #endif
 49 | 
 50 | 
 51 | BOOL FileRead (HANDLE hFile,
 52 | 	       VOID *lpMemory,
 53 | 	       DWORD nAmtToRead)
 54 | {
 55 |    BOOL           bSuccess ;
 56 |    DWORD          nAmtRead ;
 57 | 
 58 |    bSuccess = ReadFile (hFile, lpMemory, nAmtToRead, &nAmtRead, NULL) ;
 59 |    return (bSuccess && (nAmtRead == nAmtToRead)) ;
 60 | 
 61 | }
 62 | 
 63 | BOOL FileWrite (HANDLE hFile,
 64 | 		VOID * lpMemory,
 65 |                 DWORD nAmtToWrite)
 66 |    {  // FileWrite
 67 |    BOOL           bSuccess ;
 68 |    DWORD          nAmtWritten ;
 69 | 
 70 |    bSuccess = WriteFile (hFile, lpMemory, nAmtToWrite, &nAmtWritten, NULL) ;
 71 |    return (bSuccess && (nAmtWritten == nAmtToWrite)) ;
 72 |    }  // FileWrite
 73 | 
 74 |                 
 75 | #if 0
 76 | HANDLE FileHandleOpen (LPTSTR lpszFilePath)
 77 |    {  // FileHandleOpen
 78 |    return ((HANDLE) CreateFile (lpszFilePath,
 79 |                                 GENERIC_READ |
 80 |                                 GENERIC_WRITE,
 81 |                                 FILE_SHARE_READ |
 82 |                                 FILE_SHARE_WRITE,
 83 |                                 NULL, 
 84 |                                 OPEN_EXISTING,
 85 |                                 0,
 86 |                                 NULL)) ;
 87 |    }  // FileHandleOpen
 88 | 
 89 | 
 90 | HANDLE FileHandleCreate (LPTSTR lpszFilePath)
 91 |    {  // FileHandleCreate
 92 |    return ((HANDLE) CreateFile (lpszFilePath, 
 93 |                                GENERIC_READ | GENERIC_WRITE,
 94 | 			       FILE_SHARE_READ,
 95 | 			       NULL,
 96 | 			       CREATE_ALWAYS,
 97 |                                FILE_ATTRIBUTE_NORMAL,
 98 |                                NULL)) ;
 99 |    }  // FileHandleCreate
100 | 
101 | 
102 | long FileSeekEnd (HANDLE hFile,
103 | 		  long lAmtToMove,
104 | 		  long lAmountToMoveHigh)
105 |    {  // FileSeekEnd
106 |    return (SetFilePointer (hFile, lAmtToMove, &lAmountToMoveHigh, FILE_END)) ;
107 |    }  // FileSeekEnd
108 | 
109 | 
110 | long FileSeekBegin (HANDLE hFile,
111 | 		    long lAmtToMove,
112 | 		    long lAmountToMoveHigh)
113 |    {  // FileSeekBegin
114 |    return (SetFilePointer (hFile, lAmtToMove, &lAmountToMoveHigh, FILE_BEGIN)) ;
115 |    }  // FileSeekBegin
116 | 
117 | 
118 | long FileSeekCurrent (HANDLE hFile,
119 | 		      long lAmtToMove,
120 | 		      long lAmountToMoveHigh)
121 |    {  // FileSeekCurrent
122 |    return  (SetFilePointer (hFile, lAmtToMove, &lAmountToMoveHigh, FILE_CURRENT)) ;
123 |    }  // FileSeekCurrent
124 | 
125 | 
126 | 
127 | long FileTell (HANDLE hFile)
128 |    {  // FileTell
129 |    return (SetFilePointer (hFile, 0, NULL, FILE_CURRENT)) ;
130 |    }  // FileTell
131 | #endif
132 | 
133 | 
134 | 
135 | VOID * FileMap (HANDLE hFile, HANDLE *phMapHandle)
136 | /*
137 |    To Do:         Error reporting!!
138 | */
139 |    {  // FileMap
140 |    HANDLE         hMapping ;
141 | 
142 | 
143 |    *phMapHandle = 0 ;
144 |    hMapping = CreateFileMapping (hFile, NULL, PAGE_READONLY,
145 |                                  0, 0, NULL) ;
146 |    if (!hMapping)
147 |       return (NULL) ;
148 | 
149 |    *phMapHandle = hMapping ;
150 |    return (MapViewOfFile (hMapping, FILE_MAP_READ, 0, 0, 0)) ;
151 |    }  // FileMap
152 | 
153 | 
154 | 
155 | BOOL FileUnMap (VOID *pBase, HANDLE hMapping)
156 | /*
157 |    To Do:         Error reporting!!
158 | */
159 |    {  // FileUnMap
160 |    UnmapViewOfFile(pBase) ;
161 |    CloseHandle (hMapping) ;
162 |    return (TRUE) ;
163 |    }  // FileUnMap
164 | 
165 | 
166 | 
167 | void FileNameExtension (LPTSTR lpszSpec,
168 |                         LPTSTR lpszFileNameExtension)
169 | /*
170 |    Effect:        Return the name and extension portion only of lpszSpec
171 |                   int lpszFileNameExtension.
172 | 
173 |    Assert:        lpszFileNameExtension is large enough to hold a name,
174 |                   delimiter, extension, and terminating null character.
175 | */
176 |    {  // FileNameExtension
177 |    LPTSTR          lpszDelimiter ;
178 | 
179 |    lpszDelimiter = _tcsrchr ((LPCTSTR)lpszSpec, (TCHAR)DIRECTORY_DELIMITER) ;
180 |    if (!lpszDelimiter)
181 |       lpszDelimiter = _tcsrchr ((LPCTSTR)lpszSpec, (TCHAR)DRIVE_DELIMITER) ;
182 | 
183 |    lstrcpy (lpszFileNameExtension, 
184 |            lpszDelimiter ? ++lpszDelimiter : lpszSpec) ;
185 |    }  // FileNameExtension
186 | 
187 | 
188 | 
189 | void FileDriveDirectory (LPTSTR lpszFileSpec,
190 |                          LPTSTR lpszDirectory)
191 | /*
192 |    Effect:        Extract the drive and directory from the file 
193 |                   specification lpszFileSpec, and return the it in
194 |                   lpszDirectory.
195 | 
196 |    Internals:     Copy the the whole spec to lpszDirectory. Use lstrrchr
197 |                   to find the *last* directory delimiter ('\') and 
198 |                   truncate the string right after that. 
199 | 
200 |    Note:          This function assumes that the specification lpszFileSpec
201 |                   is fairly complete, in that it contains both a directory
202 |                   and a file name.
203 | */
204 |    {  // FileDriveDirectory
205 |    LPTSTR          lpszDelimiter ;
206 | 
207 |    lstrcpy (lpszDirectory, lpszFileSpec) ;
208 |    lpszDelimiter = _tcsrchr ((LPCTSTR)lpszDirectory, (TCHAR)DIRECTORY_DELIMITER) ;
209 |    if (lpszDelimiter)
210 |       *(++lpszDelimiter) = TEXT('\0') ;
211 |    }  // FileDriveDirectory
212 | 
213 | 
214 | #endif
215 | 
216 | 


--------------------------------------------------------------------------------
/fileutil.h:
--------------------------------------------------------------------------------
 1 | 
 2 | //==========================================================================//
 3 | //                             Exported Functions                           //
 4 | //==========================================================================//
 5 | 
 6 | #if (WINDOWS_NT_UTIL)
 7 | 
 8 | #define FILE_ERROR_MESSAGE_SIZE 256
 9 | 
10 | 
11 | VOID FileErrorMessageBox(HWND hWnd,
12 | 			 LPTSTR lpszFileName,
13 | 			 DWORD ErrorCode) ;
14 | 
15 | 
16 | BOOL FileRead (HANDLE hFile,
17 | 	       VOID * lpMemory,
18 | 	       DWORD nAmtToRead) ;
19 | 
20 | BOOL FileWrite (HANDLE hFile,
21 | 		VOID * lpMemory,
22 | 		DWORD nAmtToWrite) ;
23 | 
24 | 
25 | #define FileSeekBegin(hFile, lAmtToMove, lAmtToMoveHigh) \
26 |    SetFilePointer (hFile, lAmtToMove, &lAmtToMoveHigh, FILE_BEGIN)
27 | 
28 | #define FileSeekEnd(hFile, lAmtToMove, lAmtToMoveHigh) \
29 |    SetFilePointer (hFile, lAmtToMove, &lAmtToMoveHigh, FILE_END)
30 | 
31 | #define FileSeekCurrent(hFile, lAmtToMove, lAmtToMoveHigh) \
32 |    SetFilePointer (hFile, lAmtToMove, &lAmtToMoveHigh, FILE_CURRENT)
33 | 
34 | #define FileTell(hFile) \
35 |    SetFilePointer (hFile, 0, NULL, FILE_CURRENT)
36 | 
37 | #define FileHandleOpen(lpszFilePath)         \
38 |    (HANDLE) CreateFile (lpszFilePath,        \
39 |       GENERIC_READ | GENERIC_WRITE,          \
40 |       FILE_SHARE_READ,                       \
41 |       NULL, OPEN_EXISTING,                   \
42 |       FILE_ATTRIBUTE_NORMAL, NULL)
43 | 
44 | #define FileHandleReadOnly(lpszFilePath)     \
45 |    (HANDLE) CreateFile (lpszFilePath,        \
46 |       GENERIC_READ ,                         \
47 |       FILE_SHARE_READ,                       \
48 |       NULL, OPEN_EXISTING,                   \
49 |       FILE_ATTRIBUTE_NORMAL, NULL)
50 | 
51 | #define FileHandleCreate(lpszFilePath)       \
52 |    (HANDLE) CreateFile (lpszFilePath,        \
53 |       GENERIC_READ | GENERIC_WRITE,          \
54 |       FILE_SHARE_READ,                       \
55 |       NULL, CREATE_ALWAYS,                   \
56 |       FILE_ATTRIBUTE_NORMAL, NULL)
57 | 
58 | int FileHandleSeekCurrent (HANDLE hFile,
59 | 			   int iAmtToMove,
60 | 			   LPTSTR lpszFilePath) ;
61 | 
62 | 
63 | int FileHandleSeekStart (HANDLE hFile,
64 | 			 int iAmtToMove,
65 | 			 LPTSTR lpszFilePath) ;
66 | 
67 | 
68 | BOOL FileHandleWrite (HANDLE hFile,
69 | 		      VOID * lpBuffer,
70 | 		      int cbWrite,
71 | 		      LPTSTR lpszFilePath) ;
72 | 
73 | 
74 | VOID * FileMap (HANDLE hFile, HANDLE *phMapHandle) ;
75 | 
76 | 
77 | BOOL FileUnMap (VOID * pBase, HANDLE hMapHandle) ;
78 | 
79 | 
80 | void FileDriveDirectory (LPTSTR lpszFileSpec,
81 | 			 LPTSTR lpszDirectory) ;
82 | 
83 | 
84 | void FileNameExtension (LPTSTR lpszSpec,
85 | 			LPTSTR lpszFileNameExtension) ;
86 | 
87 | 
88 | #endif
89 | 
90 | 


--------------------------------------------------------------------------------
/filter.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /***************************************************************************
  3 | *
  4 | *   Copyright (c) 1997-2022 Jeff V. Merkey
  5 | *   7260 SE Tenino St.
  6 | *   Portland, Oregon 97206
  7 | *   jeffmerkey@gmail.com
  8 | *
  9 | *   This program is free software; you can redistribute it and/or modify it
 10 | *   under the terms of the Lesser GNU Public License as published by the
 11 | *   Free Software Foundation, version 2.1, or any later version.
 12 | *
 13 | *   This program is distributed in the hope that it will be useful, but
 14 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
 15 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 16 | *   General Public License for more details.
 17 | *
 18 | *   Original Authorship      :
 19 | *      source code written by Jeff V. Merkey
 20 | *
 21 | *   Original Contributors    :
 22 | *      Jeff V. Merkey
 23 | *      
 24 | *      
 25 | *
 26 | ****************************************************************************
 27 | *
 28 | *
 29 | *   AUTHOR   :  Jeff V. Merkey (jeffmerkey@gmail.com)
 30 | *   FILE     :  FILTER.C
 31 | *   DESCRIP  :  printf() suppression object file
 32 | *   DATE     :  December 27, 2022
 33 | *
 34 | *
 35 | ***************************************************************************/
 36 | 
 37 | #include "globals.h"
 38 | 
 39 | BYTE LogFileName[20] = "NWFS.LOG";
 40 | FILE *logfp = 0;
 41 | ULONG EnableLogging = 0;
 42 | 
 43 | int log_sprintf(char *buffer, char *format, ...)
 44 | {
 45 |     int ccode;
 46 |     va_list args;
 47 | 
 48 |     if (!EnableLogging)
 49 |     {
 50 |        if (logfp)
 51 | 	  fclose(logfp);
 52 |        logfp = 0;
 53 | 
 54 |        logfp = fopen(LogFileName, "a+");
 55 |        if (logfp)
 56 |        {
 57 | 	  va_start(args, format);
 58 | 	  vfprintf(logfp, format, args);
 59 | 	  fprintf(logfp, "\r\n");
 60 | 	  va_end(args);
 61 | 
 62 | 	  fclose(logfp);
 63 | 	  logfp = 0;
 64 |        }
 65 |     }
 66 | 
 67 |     va_start(args, format);
 68 |     ccode = vsprintf(buffer, format, args);
 69 |     va_end(args);
 70 |     return ccode;
 71 | }
 72 | 
 73 | int log_printf(char *format, ...)
 74 | {
 75 |     va_list args;
 76 | 
 77 |     if (!EnableLogging)
 78 |     {
 79 |        if (logfp)
 80 | 	  fclose(logfp);
 81 |        logfp = 0;
 82 | 
 83 |        logfp = fopen(LogFileName, "a+");
 84 |        if (logfp)
 85 |        {
 86 | 	  va_start(args, format);
 87 | 	  vfprintf(logfp, format, args);
 88 | 	  va_end(args);
 89 | 
 90 | 	  fclose(logfp);
 91 | 	  logfp = 0;
 92 |        }
 93 |     }
 94 |     return 0;
 95 | }
 96 | 
 97 | int printk(char *format, ...)
 98 | {
 99 |     return 0;
100 | }
101 | 
102 | int DbgPrint(char *format, ...)
103 | {
104 |     return 0;
105 | }
106 | 


--------------------------------------------------------------------------------
/image.h:
--------------------------------------------------------------------------------
  1 | 
  2 | /***************************************************************************
  3 | *
  4 | *   Copyright (c) 1997-2001 Jeff V. Merkey  All Rights
  5 | *			    Reserved.
  6 | *
  7 | *   This program is an unpublished work of Jeff V. Merkey and contains
  8 | *   trade secrets and other proprietary information.  Unauthorized
  9 | *   use, copying, disclosure, or distribution of this file without the
 10 | *   consent of Jeff V. Merkey can subject the offender to severe criminal
 11 | *   and/or civil penalities.
 12 | *
 13 | *
 14 | *   AUTHORS  :  Jeff V. Merkey, J. 
 15 | *   FILE     :  IMAGE.H
 16 | *   DESCRIP  :  NWFS Imaging Utility Includes
 17 | *   DATE     :  August 5, 2022
 18 | *
 19 | *
 20 | ***************************************************************************/
 21 | 
 22 | #ifndef _IMAGE_INCLUDE_
 23 | #define _IMAGE_INCLUDE_
 24 | 
 25 | #define	IMAGE_SET_STAMP			0x44447777
 26 | #define	IMAGE_FILE_STAMP		0x77774444
 27 | #define	IMAGE_TABLE_SIZE		64
 28 | #define	IMAGE_SET_TABLE_SIZE	        256
 29 | 
 30 | #if (LINUX_UTIL | DOS_UTIL)
 31 | 
 32 | typedef struct _IMAGE_HEADER
 33 | {
 34 |    ULONG Stamp                      __attribute__ ((packed));
 35 |    ULONG CheckSum                   __attribute__ ((packed));
 36 |    ULONG Filler[2]                  __attribute__ ((packed));
 37 |    BYTE DateTimeString[32]          __attribute__ ((packed));
 38 |    BYTE VolumeName[20]              __attribute__ ((packed));
 39 |    BYTE ImageSetName[20]            __attribute__ ((packed));
 40 | 
 41 |    ULONG VolumeClusterSize          __attribute__ ((packed));
 42 |    ULONG LogicalVolumeClusters      __attribute__ ((packed));
 43 |    ULONG AllocatedVolumeClusters    __attribute__ ((packed));
 44 |    ULONG FilesInDataSet             __attribute__ ((packed));
 45 |    ULONG SegmentCount               __attribute__ ((packed));
 46 |    ULONG MirrorFlag                 __attribute__ ((packed));
 47 |    BYTE VolumeFile[20]              __attribute__ ((packed));
 48 | } IMAGE;
 49 | 
 50 | typedef struct _IMAGE_SET_HEADER
 51 | {
 52 |    ULONG Stamp                      __attribute__ ((packed));
 53 |    ULONG CheckSum                   __attribute__ ((packed));
 54 |    ULONG VolumeCount                __attribute__ ((packed));
 55 |    ULONG Filler                     __attribute__ ((packed));
 56 |    BYTE DateTimeString[32]          __attribute__ ((packed));
 57 |    BYTE VolumeFile[IMAGE_TABLE_SIZE][16] __attribute__ ((packed));
 58 | } IMAGE_SET;
 59 | 
 60 | typedef struct _FILE_DATA_
 61 | {
 62 |    LONGLONG FileSize                __attribute__ ((packed));
 63 |    LONGLONG FileCompressed          __attribute__ ((packed));
 64 |    LONGLONG FileOffset              __attribute__ ((packed));
 65 |    ULONG Checksum                   __attribute__ ((packed));
 66 | } FILE_DATA;
 67 | 
 68 | #endif
 69 | 
 70 | #if (WINDOWS_NT_UTIL)
 71 | 
 72 | typedef struct _IMAGE_HEADER
 73 | {
 74 |    ULONG Stamp;
 75 |    ULONG CheckSum;
 76 |    ULONG Filler[2];
 77 |    BYTE DateTimeString[32];
 78 |    BYTE VolumeName[20];
 79 |    BYTE ImageSetName[20];
 80 | 
 81 |    ULONG VolumeClusterSize;
 82 |    ULONG LogicalVolumeClusters;
 83 |    ULONG AllocatedVolumeClusters;
 84 |    ULONG FilesInDataSet;
 85 |    ULONG SegmentCount;
 86 |    ULONG MirrorFlag;
 87 |    BYTE VolumeFile[20];
 88 | } IMAGE;
 89 | 
 90 | typedef struct _IMAGE_SET_HEADER
 91 | {
 92 |    ULONG Stamp;
 93 |    ULONG CheckSum;
 94 |    ULONG VolumeCount;
 95 |    ULONG Filler;
 96 |    BYTE DateTimeString[32];
 97 |    BYTE VolumeFile[IMAGE_TABLE_SIZE][16];
 98 | } IMAGE_SET;
 99 | 
100 | typedef struct _FILE_DATA_
101 | {
102 |    LONGLONG FileSize;
103 |    LONGLONG FileCompressed;
104 |    LONGLONG FileOffset;
105 |    ULONG Checksum;
106 | } FILE_DATA;
107 | 
108 | #endif
109 | 
110 | #endif
111 | 
112 | 
113 | 


--------------------------------------------------------------------------------
/ioctl.c:
--------------------------------------------------------------------------------
 1 | 
 2 | /***************************************************************************
 3 | *
 4 | *   Copyright (c) 1997-2022 Jeff V. Merkey
 5 | *   7260 SE Tenino St.
 6 | *   Portland, Oregon 97206
 7 | *   jeffmerkey@gmail.com
 8 | *
 9 | *   This program is free software; you can redistribute it and/or modify it
10 | *   under the terms of the Lesser GNU Public License as published by the
11 | *   Free Software Foundation, version 2.1, or any later version.
12 | *
13 | *   This program is distributed in the hope that it will be useful, but
14 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
15 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 | *   General Public License for more details.
17 | *
18 | *   Original Authorship      :
19 | *      source code written by Jeff V. Merkey
20 | *
21 | *   Original Contributors    :
22 | *      Jeff V. Merkey
23 | *      
24 | *      
25 | *
26 | ****************************************************************************
27 | *
28 | *
29 | *   AUTHOR   :  Jeff V. Merkey (jeffmerkey@gmail.com)
30 | *   FILE     :  IOCTL.C
31 | *   DESCRIP  :  VFS IOCTL Module for Linux
32 | *   DATE     :  December 6, 1998
33 | *
34 | *
35 | ***************************************************************************/
36 | 
37 | #include "globals.h"
38 | 
39 | #if (LINUX_20 | LINUX_22 | LINUX_24)
40 | 
41 | int nwfs_ioctl(struct inode *inode, struct file *filp,
42 | 		 unsigned int cmd, unsigned long arg)
43 | {
44 | //    DOS DOS_S;
45 | //    register DOS *dos = &DOS_S;
46 |     ULONG Attributes;
47 |     
48 | #if (VERBOSE)
49 |     NWFSPrint("nwfs-ioctl\n");
50 | #endif
51 | 
52 |     switch (cmd)
53 |     {
54 |        case NWFS_GET_ATTRIBUTES:
55 | 	  if (NWFSCopyToUserSpace((void *)arg, (void *)&Attributes, 4)) 
56 |              return -EFAULT;
57 | 	  return 0;
58 | 
59 |        case NWFS_SET_ATTRIBUTES:
60 | 	  if (NWFSCopyFromUserSpace((void *)&Attributes, (void *)arg, 4))
61 | 	     return -EFAULT;
62 | 	  return 0;
63 |        
64 |        case NWFS_GET_TRUSTEES:
65 |        case NWFS_GET_QUOTA:
66 |        case NWFS_SET_TRUSTEES:
67 |        case NWFS_SET_QUOTA:
68 | 	  return 0;
69 | 
70 |        default:
71 |           return -EINVAL;
72 |     }
73 | }
74 | 
75 | #endif
76 | 


--------------------------------------------------------------------------------
/lock.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /***************************************************************************
  3 | *
  4 | *   Copyright (c) 1997-2022 Jeff V. Merkey
  5 | *   7260 SE Tenino St.
  6 | *   Portland, Oregon 97206
  7 | *   jeffmerkey@gmail.com
  8 | *
  9 | *   This program is free software; you can redistribute it and/or modify it
 10 | *   under the terms of the Lesser GNU Public License as published by the
 11 | *   Free Software Foundation, version 2.1, or any later version.
 12 | *
 13 | *   This program is distributed in the hope that it will be useful, but
 14 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
 15 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 16 | *   General Public License for more details.
 17 | *
 18 | *   Original Authorship      :
 19 | *      source code written by Jeff V. Merkey
 20 | *
 21 | *   Original Contributors    :
 22 | *      Jeff V. Merkey
 23 | *      
 24 | *      
 25 | *
 26 | ****************************************************************************
 27 | *
 28 | *
 29 | *   AUTHOR   :  Jeff V. Merkey (jeffmerkey@gmail.com)
 30 | *   FILE     :  LOCK.C
 31 | *   DESCRIP  :  Atomic Locking Functions
 32 | *   DATE     :  November 1, 1998
 33 | *
 34 | *
 35 | ***************************************************************************/
 36 | 
 37 | #include "globals.h"
 38 | 
 39 | #if (WINDOWS_NT | WINDOWS_NT_RO)
 40 | 
 41 | //
 42 | //   returns 0 - lock acquired (was unlocked) or -1 - deadlock
 43 | //
 44 | 
 45 | ULONG spin_lock(ULONG *value)
 46 | {
 47 |    register ULONG retCode, counter = 0;
 48 | 
 49 |    retCode = InterlockedExchange(value, 1);
 50 |    if (!retCode)
 51 |       return 0;
 52 | 
 53 |    while (1)
 54 |    {
 55 |       if (!*value)
 56 |       {
 57 | 	 retCode = InterlockedExchange(value, 1);
 58 | 	 if (!retCode)
 59 | 	    return 0;
 60 |       }
 61 |       if (counter++ > 0x4FFFFFF)
 62 |       {
 63 | 	 NWFSPrint("error: deadlock detected in spin_lock\n");
 64 | 	 return -1;
 65 |       }
 66 |    }
 67 | }
 68 | 
 69 | //
 70 | // returns 0 on success or -1 on failure
 71 | //
 72 | 
 73 | ULONG spin_unlock(ULONG *value)
 74 | {
 75 |    if (*value)
 76 |    {
 77 |       *value = 0;
 78 |       return 0;
 79 |    }
 80 |    else
 81 |    {
 82 |       NWFSPrint("error: spin_unlock called with lock open (???)\n");
 83 |       return -1;
 84 |    }
 85 | }
 86 | 
 87 | //
 88 | //   returns 0 - lock acquired (was unlocked) or 1 - failure
 89 | //
 90 | 
 91 | ULONG spin_try_lock(ULONG *value)
 92 | {
 93 |    register ULONG retCode;
 94 | 
 95 |    retCode = InterlockedExchange(value, 1);
 96 |    return retCode;
 97 | 
 98 | }
 99 | 
100 | #endif
101 | 
102 | 
103 | #if (LINUX)
104 | #endif
105 | 
106 | 
107 | 
108 | 


--------------------------------------------------------------------------------
/nofilt.c:
--------------------------------------------------------------------------------
 1 | 
 2 | /***************************************************************************
 3 | *
 4 | *   Copyright (c) 1997-2022 Jeff V. Merkey
 5 | *   7260 SE Tenino St.
 6 | *   Portland, Oregon 97206
 7 | *   jeffmerkey@gmail.com
 8 | *
 9 | *   This program is free software; you can redistribute it and/or modify it
10 | *   under the terms of the Lesser GNU Public License as published by the
11 | *   Free Software Foundation, version 2.1, or any later version.
12 | *
13 | *   This program is distributed in the hope that it will be useful, but
14 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
15 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 | *   General Public License for more details.
17 | *
18 | *   Original Authorship      :
19 | *      source code written by Jeff V. Merkey
20 | *
21 | *   Original Contributors    :
22 | *      Jeff V. Merkey
23 | *      
24 | *      
25 | *
26 | ****************************************************************************
27 | *
28 | *
29 | *   AUTHOR   :  Jeff V. Merkey (jeffmerkey@gmail.com)
30 | *   FILE     :  FILTER.C
31 | *   DESCRIP  :  printf() redirection object file
32 | *   DATE     :  December 27, 2022
33 | *
34 | *
35 | ***************************************************************************/
36 | 
37 | #include "globals.h"
38 | 
39 | int log_printf(char *format, ...)
40 | {
41 |     va_list args;
42 |     va_start(args, format);
43 | 
44 |     return (vprintf(format, args));
45 | }
46 | 
47 | int printk(char *format, ...)
48 | {
49 |     return 0;
50 | }
51 | 
52 | int DbgPrint(char *format, ...)
53 | {
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/nwdisk.c:
--------------------------------------------------------------------------------
 1 | 
 2 | /***************************************************************************
 3 | *
 4 | *   Copyright (c) 1997-2022 Jeff V. Merkey  All Rights
 5 | *			    Reserved.
 6 | *
 7 | *   AUTHOR   :  Jeff V. Merkey (jeffmerkey@gmail.com)
 8 | *   FILE     :  NWDISK.C
 9 | *   DESCRIP  :  NWDISK Utility
10 | *   DATE     :  September 23, 2022
11 | *
12 | *
13 | ***************************************************************************/
14 | 
15 | #include "globals.h"
16 | 
17 | int main(int argc, char *argv[])
18 | {
19 |     InitNWFS();
20 |     NWEditVolumes();
21 |     ClearScreen(0);
22 | 
23 |     NWFSVolumeClose();
24 |     RemoveDiskDevices();
25 |     FreePartitionResources();
26 |     return 0;
27 | 
28 | }
29 | 
30 | 
31 | 
32 | 
33 | 


--------------------------------------------------------------------------------
/nwdismnt.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /***************************************************************************
  3 | *
  4 | *   Copyright (c) 1999-2000 Jeff V. Merkey
  5 | *   7260 SE Tenino St.
  6 | *   Portland, Oregon 97206
  7 | *   jeffmerkey@gmail.com
  8 | *
  9 | ****************************************************************************
 10 | *
 11 | *  Module Name:
 12 | *
 13 | *    NwDismount.c
 14 | *
 15 | *  Abstract:
 16 | *
 17 | *    This little command line APP attempts to dismount a previously mounted
 18 | *    read-only netware volume.
 19 | *
 20 | *  Authors:
 21 | *
 22 | *    David Goebel (davidg@balder.com) 11-Mar-1999
 23 | *
 24 | *
 25 | ***************************************************************************/
 26 | 
 27 | #include "stdio.h"
 28 | #include "windows.h"
 29 | #include "winioctl.h"
 30 | 
 31 | void __cdecl main(int argc, char **argv)
 32 | {
 33 |     HANDLE Volume;
 34 |     PUCHAR Drive = "\\\\.\\c:\\";
 35 |     ULONG DontCare;
 36 |     PUCHAR FileSystemName = "NWFSRO";
 37 |     BOOLEAN Worked;
 38 | 
 39 |     if (argc != 2)
 40 |     {
 41 | 	printf("USAGE: %s X: (attempts to dismount drive X:)\n\n", argv[0]);
 42 | 	exit(EXIT_FAILURE);
 43 |     }
 44 | 
 45 |     Drive[4] = argv[1][0];
 46 | 
 47 |     if (!GetVolumeInformation( Drive,
 48 | 			       NULL,
 49 | 			       0,
 50 | 			       &DontCare,
 51 | 			       &DontCare,
 52 | 			       &DontCare,
 53 | 			       FileSystemName,
 54 | 			       7 ) ||
 55 | 	(memcmp(FileSystemName, "NWFSRO", 6) != 0))
 56 |     {
 57 | 	printf("%s is only to be used on read-only netware partitions.\n", argv[0]);
 58 | 	exit(EXIT_FAILURE);
 59 |     }
 60 | 
 61 |     Drive[6] = 0;
 62 | 
 63 |     if ((Volume = CreateFile( Drive,
 64 | 			      GENERIC_READ,
 65 | 			      0,
 66 | 			      NULL,
 67 | 			      OPEN_EXISTING,
 68 | 			      FILE_ATTRIBUTE_NORMAL,
 69 | 			      NULL)) == ((HANDLE)-1))
 70 |     {
 71 | 	printf("Could not open and/or get a lock on drive %s, error %d\n",
 72 | 	       Drive, GetLastError());
 73 | 
 74 |         exit(EXIT_FAILURE);
 75 |     }
 76 | 
 77 |     printf("Attempting dismount on drive %s.\n", &Drive[4]);
 78 | 
 79 |     Worked = DeviceIoControl( Volume,
 80 | 			      FSCTL_DISMOUNT_VOLUME,
 81 | 			      NULL,
 82 | 			      0,
 83 | 			      NULL,
 84 | 			      0,
 85 | 			      &DontCare,
 86 | 			      NULL );
 87 |     if (!Worked)
 88 |     {
 89 | 	printf("DeviceIoControl() returned error %d.\n", GetLastError());
 90 | 	CloseHandle(Volume);
 91 | 	exit(EXIT_FAILURE);
 92 |     }
 93 | 
 94 |     if (!DefineDosDevice(DDD_REMOVE_DEFINITION, &Drive[4], NULL))
 95 |     {
 96 | 	printf("DefineDosDevice() returned error %d.\n", GetLastError());
 97 | 	CloseHandle(Volume);
 98 | 	exit(EXIT_FAILURE);
 99 |     }
100 | 
101 |     CloseHandle(Volume);
102 |     exit(EXIT_SUCCESS);
103 | }
104 | 


--------------------------------------------------------------------------------
/nwdump.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /***************************************************************************
  3 | *
  4 | *   Copyright (c) 1997-2022 Jeff V. Merkey  All Rights
  5 | *			    Reserved.
  6 | *
  7 | *   AUTHOR   :  Jeff V. Merkey (jeffmerkey@gmail.com)
  8 | *   FILE     :  NWVOL.C
  9 | *   DESCRIP  :  NWVOL Utility
 10 | *   DATE     :  November 23, 1998
 11 | *
 12 | *
 13 | ***************************************************************************/
 14 | 
 15 | #include "globals.h"
 16 | 
 17 | BYTE Sector[IO_BLOCK_SIZE];
 18 | WORD partitionSignature;
 19 | WORD stamp;
 20 | 
 21 | ULONG atox(BYTE *p)
 22 | {
 23 |     register ULONG c = 0;
 24 | 
 25 |     if (!p)
 26 |        return 0;
 27 | 
 28 |     while (*p)
 29 |     {
 30 |        if (*p >= '0' && *p <= '9')
 31 | 	  c = (c << 4) | (*p - '0');
 32 |        else
 33 |        if (*p >= 'A' && *p <= 'F')
 34 | 	  c = (c << 4) | (*p - 'A' + 10);
 35 |        else
 36 |        if (*p >= 'a' && *p <= 'f')
 37 | 	  c = (c << 4) | (*p - 'a' + 10);
 38 |        else
 39 | 	  break;
 40 |        p++;
 41 |     }
 42 |     return (c);
 43 | }
 44 | 
 45 | unsigned long ipause(void)
 46 | {
 47 |    register unsigned long key;
 48 | #if (DOS_UTIL)
 49 |    extern int getch(void);
 50 | #endif
 51 | 
 52 |    printf(" --- More --- ");
 53 |    key = getch();
 54 |    printf("%c              %c", '\r', '\r');
 55 |    if (key == 0x1B) // ESCAPE
 56 |       return 1;
 57 |    else
 58 |       return 0;
 59 | 
 60 | }
 61 | 
 62 | int main(int argc, char *argv[])
 63 | {
 64 |     register ULONG retCode, total, lba, disk;
 65 |     extern BYTE *dumpRecordBytes(BYTE *, ULONG);
 66 |     extern void UtilScanVolumes(void);
 67 |     
 68 |     if (argc < 2)
 69 |     {
 70 |        NWFSPrint("USAGE:  nwdump <sector> <disk>\n");
 71 |        return 0;
 72 |     }
 73 | 
 74 |     lba = atox(argv[1]);
 75 | 
 76 |     if (argc > 2)
 77 |        disk = atol(argv[2]);
 78 |     else
 79 |        disk = 0;
 80 | 
 81 |     if (disk > 128)
 82 |     {
 83 |        NWFSPrint("invalid disk-%d\n", (int)disk);
 84 |        return 0;
 85 |     }
 86 | 
 87 |     InitNWFS();
 88 |     UtilScanVolumes();
 89 | 
 90 |     if (!SystemDisk[disk])
 91 |        return 0;
 92 | 
 93 |     total = (ULONG)(SystemDisk[disk]->Cylinders *
 94 | 		   SystemDisk[disk]->TracksPerCylinder *
 95 | 		   SystemDisk[disk]->SectorsPerTrack);
 96 | 
 97 |     retCode = ReadDiskSectors(disk, lba, Sector, 1, 1);
 98 |     if (!retCode)
 99 |        return 0;
100 | 
101 |     dumpRecordBytes(Sector, 256);
102 |     ipause();
103 |     dumpRecordBytes(&Sector[256], 256);
104 | 
105 |     NWFSVolumeClose();
106 |     RemoveDiskDevices();
107 |     FreePartitionResources();
108 | 
109 |     return 0;
110 | 
111 | }
112 | 
113 | 
114 | 
115 | 
116 | 


--------------------------------------------------------------------------------
/nwerror.h:
--------------------------------------------------------------------------------
 1 | 
 2 | /***************************************************************************
 3 | *
 4 | *   Copyright (c) 1997-2022 Jeff V. Merkey
 5 | *   7260 SE Tenino St.
 6 | *   Portland, Oregon 97206
 7 | *   jeffmerkey@gmail.com
 8 | *
 9 | *   This program is free software; you can redistribute it and/or modify it
10 | *   under the terms of the Lesser GNU Public License as published by the
11 | *   Free Software Foundation, version 2.1, or any later version.
12 | *
13 | *   This program is distributed in the hope that it will be useful, but
14 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
15 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 | *   General Public License for more details.
17 | *
18 | *   Original Authorship      :
19 | *      source code written by Jeff V. Merkey
20 | *
21 | *   Original Contributors    :
22 | *      Jeff V. Merkey
23 | *      
24 | *      
25 | *
26 | ****************************************************************************
27 | *
28 | *   AUTHOR   :  Jeff V. Merkey (jeffmerkey@gmail.com)
29 | *   FILE     :  NWERROR.H
30 | *   DESCRIP  :  Error Codes
31 | *   DATE     :  April 3, 2022
32 | *
33 | *
34 | ***************************************************************************/
35 | 
36 | #ifndef _NWFS_ERROR_
37 | #define _NWFS_ERROR_
38 | 
39 | /**********************************************************************
40 | *
41 | *   NWFS Error Codes
42 | *
43 | ***********************************************************************/
44 | 
45 | typedef enum _NW_STATUS
46 | {
47 |    NwSuccess,                     // 0
48 |    NwFileCorrupt,                 // 1
49 |    NwDirectoryCorrupt,            // 2
50 |    NwVolumeCorrupt,               // 3
51 |    NwHashCorrupt,                 // 4
52 |    NwHashError,                   // 5
53 |    NwDiskIoError,                 // 6
54 |    NwInsufficientResources,       // 7
55 |    NwInvalidParameter,            // 8
56 |    NwNoMoreMirrors,               // 9
57 |    NwOtherError,                  // 10
58 |    NwEndOfFile,                   // 11
59 |    NwFileExists,                  // 12
60 |    NwBadName,                     // 13
61 |    NwVolumeFull,                  // 14
62 |    NwFatCorrupt,                  // 15
63 |    NwAccessError,                 // 16
64 |    NwMissingSegment,              // 17
65 |    NwMirrorGroupFailure,          // 18
66 |    NwNotEmpty,                    // 19
67 |    NwNoEntry,                     // 20
68 |    NwNotPermitted,                // 21
69 |    NwSuballocMissing,             // 22
70 |    NwSuballocExceeded,            // 23
71 |    NwMemoryFault,                 // 24
72 |    NwChainBad                     // 25	   
73 | } NW_STATUS;
74 | 
75 | 
76 | #endif
77 | 
78 | 


--------------------------------------------------------------------------------
/nwfs:
--------------------------------------------------------------------------------
1 | make -f nwfs.mak
2 | 


--------------------------------------------------------------------------------
/nwfs.mak:
--------------------------------------------------------------------------------
 1 | 
 2 | CC = gcc
 3 | LINK = ld
 4 | CFLAGS = -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O2 \
 5 | 	 -fomit-frame-pointer -fno-strength-reduce -pipe -m386 -DCPU=386 \
 6 | 	 -I/usr/src/linux/include -c
 7 | 
 8 | LFLAGS = -m elf_i386 -Map nwfs.map -r -o 
 9 | 
10 | incdeps = nwfs.h nwstruct.h nwdir.h nwhash.h nwproc.h nwvfs.h nwerror.h \
11 | 	  globals.h
12 | 
13 | objects = nwvfs.o alloc.o disk.o nwpart.o volume.o globals.o lru.o  \
14 | 	  lock.o hash.o async.o fat.o bit.o block.o cluster.o dir.o      \
15 | 	  mmap.o inode.o super.o file.o ioctl.o nwdir.o nwfile.o nwfix.o  \
16 | 	  trustee.o nwext.o suballoc.o create.o date.o                    \
17 | 	  nwcreate.o symlink.o nwvp.o nwvphal.o 
18 | 
19 | nwfs.o: $(objects) 
20 | 	$(LINK) $(LFLAGS) nwfs.o $(objects)
21 | 
22 | nwvfs.o: nwvfs.c     $(incdeps)
23 | 	$(CC) $(CFLAGS) nwvfs.c
24 | nwvp.o: nwvp.c       $(incdeps)
25 | 	$(CC) $(CFLAGS) nwvp.c
26 | nwvphal.o: nwvphal.c $(incdeps)
27 | 	$(CC) $(CFLAGS) nwvphal.c
28 | alloc.o: alloc.c     $(incdeps)
29 | 	$(CC) $(CFLAGS) alloc.c
30 | disk.o: disk.c       $(incdeps)
31 | 	$(CC) $(CFLAGS) disk.c
32 | nwpart.o: nwpart.c   $(incdeps)
33 | 	$(CC) $(CFLAGS) nwpart.c
34 | volume.o: volume.c   $(incdeps)
35 | 	$(CC) $(CFLAGS) volume.c
36 | fat.o: fat.c         $(incdeps)
37 | 	$(CC) $(CFLAGS) fat.c
38 | globals.o: globals.c $(incdeps)
39 | 	$(CC) $(CFLAGS) globals.c
40 | lock.o: lock.c       $(incdeps)
41 | 	$(CC) $(CFLAGS) lock.c
42 | hash.o: hash.c       $(incdeps)
43 | 	$(CC) $(CFLAGS) hash.c
44 | string.o: string.c   $(incdeps)
45 | 	$(CC) $(CFLAGS) string.c
46 | lru.o: lru.c         $(incdeps)
47 | 	$(CC) $(CFLAGS) lru.c
48 | bit.o: bit.c         $(incdeps)
49 | 	$(CC) $(CFLAGS) bit.c
50 | block.o: block.c     $(incdeps)
51 | 	$(CC) $(CFLAGS) block.c
52 | cluster.o: cluster.c $(incdeps)
53 | 	$(CC) $(CFLAGS) cluster.c
54 | dir.o: dir.c         $(incdeps)
55 | 	$(CC) $(CFLAGS) dir.c
56 | mmap.o: mmap.c       $(incdeps)
57 | 	$(CC) $(CFLAGS) mmap.c
58 | inode.o: inode.c     $(incdeps)
59 | 	$(CC) $(CFLAGS) inode.c
60 | super.o: super.c     $(incdeps)
61 | 	$(CC) $(CFLAGS) super.c
62 | file.o: file.c       $(incdeps)
63 | 	$(CC) $(CFLAGS) file.c
64 | ioctl.o: ioctl.c     $(incdeps)
65 | 	$(CC) $(CFLAGS) ioctl.c
66 | nwdir.o: nwdir.c     $(incdeps)
67 | 	$(CC) $(CFLAGS) nwdir.c
68 | nwfile.o: nwfile.c   $(incdeps)
69 | 	$(CC) $(CFLAGS) nwfile.c
70 | trustee.o: trustee.c   $(incdeps)
71 | 	$(CC) $(CFLAGS) trustee.c
72 | nwext.o: nwext.c   $(incdeps)
73 | 	$(CC) $(CFLAGS) nwext.c
74 | suballoc.o: suballoc.c   $(incdeps)
75 | 	$(CC) $(CFLAGS) suballoc.c
76 | create.o: create.c   $(incdeps)
77 | 	$(CC) $(CFLAGS) create.c
78 | date.o: date.c       $(incdeps)
79 | 	$(CC) $(CFLAGS) date.c
80 | nwcreate.o: nwcreate.c   $(incdeps)
81 | 	$(CC) $(CFLAGS) nwcreate.c
82 | symlink.o: symlink.c   $(incdeps)
83 | 	$(CC) $(CFLAGS) symlink.c
84 | async.o: async.c   $(incdeps)
85 | 	$(CC) $(CFLAGS) async.c
86 | nwfix.o: nwfix.c   $(incdeps)
87 | 	$(CC) $(CFLAGS) nwfix.c
88 | 
89 | clean:
90 | 	rm -f *.o
91 | 
92 | 


--------------------------------------------------------------------------------
/nwfsmod.mak:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | CC = gcc
 4 | LINK = ld
 5 | CFLAGS = -DMODVERSIONS -DMODULE -D__KERNEL__ -Wall \
 6 | 	 -Wstrict-prototypes -O2 -fomit-frame-pointer -fno-strength-reduce \
 7 | 	 -pipe -m386 -DCPU=386 -I/usr/src/linux/include -c
 8 | 
 9 | LFLAGS = -m elf_i386 -Map nwfs.map -r -o 
10 | 
11 | incdeps = nwfs.h nwstruct.h nwdir.h nwhash.h nwproc.h nwvfs.h nwerror.h \
12 | 	  globals.h
13 | 
14 | objects = nwvfs.o alloc.o disk.o nwpart.o volume.o globals.o lru.o  \
15 | 	  lock.o hash.o async.o fat.o bit.o block.o cluster.o dir.o         \
16 | 	  mmap.o inode.o super.o file.o ioctl.o nwdir.o nwfile.o nwfix.o  \
17 | 	  trustee.o nwext.o suballoc.o create.o date.o              \
18 | 	  nwcreate.o symlink.o nwvp.o nwvphal.o
19 | 
20 | nwfs.o: $(objects) 
21 | 	$(LINK) $(LFLAGS) nwfs.o $(objects)
22 | 
23 | nwvfs.o: nwvfs.c     $(incdeps)
24 | 	$(CC) $(CFLAGS) nwvfs.c
25 | nwvp.o: nwvp.c       $(incdeps)
26 | 	$(CC) $(CFLAGS) nwvp.c
27 | nwvphal.o: nwvphal.c $(incdeps)
28 | 	$(CC) $(CFLAGS) nwvphal.c
29 | alloc.o: alloc.c     $(incdeps)
30 | 	$(CC) $(CFLAGS) alloc.c
31 | disk.o: disk.c       $(incdeps)
32 | 	$(CC) $(CFLAGS) disk.c
33 | nwpart.o: nwpart.c   $(incdeps)
34 | 	$(CC) $(CFLAGS) nwpart.c
35 | volume.o: volume.c   $(incdeps)
36 | 	$(CC) $(CFLAGS) volume.c
37 | fat.o: fat.c         $(incdeps)
38 | 	$(CC) $(CFLAGS) fat.c
39 | globals.o: globals.c $(incdeps)
40 | 	$(CC) $(CFLAGS) globals.c
41 | lock.o: lock.c       $(incdeps)
42 | 	$(CC) $(CFLAGS) lock.c
43 | hash.o: hash.c       $(incdeps)
44 | 	$(CC) $(CFLAGS) hash.c
45 | string.o: string.c   $(incdeps)
46 | 	$(CC) $(CFLAGS) string.c
47 | lru.o: lru.c         $(incdeps)
48 | 	$(CC) $(CFLAGS) lru.c
49 | bit.o: bit.c         $(incdeps)
50 | 	$(CC) $(CFLAGS) bit.c
51 | block.o: block.c     $(incdeps)
52 | 	$(CC) $(CFLAGS) block.c
53 | cluster.o: cluster.c $(incdeps)
54 | 	$(CC) $(CFLAGS) cluster.c
55 | dir.o: dir.c         $(incdeps)
56 | 	$(CC) $(CFLAGS) dir.c
57 | mmap.o: mmap.c       $(incdeps)
58 | 	$(CC) $(CFLAGS) mmap.c
59 | inode.o: inode.c     $(incdeps)
60 | 	$(CC) $(CFLAGS) inode.c
61 | super.o: super.c     $(incdeps)
62 | 	$(CC) $(CFLAGS) super.c
63 | file.o: file.c       $(incdeps)
64 | 	$(CC) $(CFLAGS) file.c
65 | ioctl.o: ioctl.c     $(incdeps)
66 | 	$(CC) $(CFLAGS) ioctl.c
67 | nwdir.o: nwdir.c     $(incdeps)
68 | 	$(CC) $(CFLAGS) nwdir.c
69 | nwfile.o: nwfile.c   $(incdeps)
70 | 	$(CC) $(CFLAGS) nwfile.c
71 | trustee.o: trustee.c   $(incdeps)
72 | 	$(CC) $(CFLAGS) trustee.c
73 | nwext.o: nwext.c   $(incdeps)
74 | 	$(CC) $(CFLAGS) nwext.c
75 | suballoc.o: suballoc.c   $(incdeps)
76 | 	$(CC) $(CFLAGS) suballoc.c
77 | create.o: create.c   $(incdeps)
78 | 	$(CC) $(CFLAGS) create.c
79 | date.o: date.c       $(incdeps)
80 | 	$(CC) $(CFLAGS) date.c
81 | nwcreate.o: nwcreate.c   $(incdeps)
82 | 	$(CC) $(CFLAGS) nwcreate.c
83 | symlink.o: symlink.c   $(incdeps)
84 | 	$(CC) $(CFLAGS) symlink.c
85 | async.o: async.c   $(incdeps)
86 | 	$(CC) $(CFLAGS) async.c
87 | nwfix.o: nwfix.c   $(incdeps)
88 | 	$(CC) $(CFLAGS) nwfix.c
89 | 
90 | clean:
91 | 	rm -f *.o
92 | 
93 | 


--------------------------------------------------------------------------------
/nwfssmp.mak:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | CC = gcc
 4 | LINK = ld
 5 | CFLAGS = -D__SMP__ -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O2 \
 6 | 	 -fomit-frame-pointer -fno-strength-reduce -pipe -m386 -DCPU=386 \
 7 | 	 -I/usr/src/linux/include -c
 8 | 
 9 | LFLAGS = -m elf_i386 -Map nwfs.map -r -o 
10 | 
11 | incdeps = nwfs.h nwstruct.h nwdir.h nwhash.h nwproc.h nwvfs.h nwerror.h \
12 | 	  globals.h
13 | 
14 | objects = nwvfs.o alloc.o disk.o nwpart.o volume.o globals.o lru.o  \
15 | 	  lock.o hash.o async.o fat.o bit.o block.o cluster.o dir.o      \
16 | 	  mmap.o inode.o super.o file.o ioctl.o nwdir.o nwfile.o nwfix.o \
17 | 	  trustee.o nwext.o suballoc.o create.o date.o                    \
18 | 	  nwcreate.o symlink.o nwvp.o nwvphal.o
19 | 
20 | nwfs.o: $(objects) 
21 | 	$(LINK) $(LFLAGS) nwfs.o $(objects)
22 | 
23 | nwvfs.o: nwvfs.c     $(incdeps)
24 | 	$(CC) $(CFLAGS) nwvfs.c
25 | nwvp.o: nwvp.c       $(incdeps)
26 | 	$(CC) $(CFLAGS) nwvp.c
27 | nwvphal.o: nwvphal.c $(incdeps)
28 | 	$(CC) $(CFLAGS) nwvphal.c
29 | alloc.o: alloc.c     $(incdeps)
30 | 	$(CC) $(CFLAGS) alloc.c
31 | disk.o: disk.c       $(incdeps)
32 | 	$(CC) $(CFLAGS) disk.c
33 | nwpart.o: nwpart.c   $(incdeps)
34 | 	$(CC) $(CFLAGS) nwpart.c
35 | volume.o: volume.c   $(incdeps)
36 | 	$(CC) $(CFLAGS) volume.c
37 | fat.o: fat.c         $(incdeps)
38 | 	$(CC) $(CFLAGS) fat.c
39 | globals.o: globals.c $(incdeps)
40 | 	$(CC) $(CFLAGS) globals.c
41 | lock.o: lock.c       $(incdeps)
42 | 	$(CC) $(CFLAGS) lock.c
43 | hash.o: hash.c       $(incdeps)
44 | 	$(CC) $(CFLAGS) hash.c
45 | string.o: string.c   $(incdeps)
46 | 	$(CC) $(CFLAGS) string.c
47 | lru.o: lru.c         $(incdeps)
48 | 	$(CC) $(CFLAGS) lru.c
49 | bit.o: bit.c         $(incdeps)
50 | 	$(CC) $(CFLAGS) bit.c
51 | block.o: block.c     $(incdeps)
52 | 	$(CC) $(CFLAGS) block.c
53 | cluster.o: cluster.c $(incdeps)
54 | 	$(CC) $(CFLAGS) cluster.c
55 | dir.o: dir.c         $(incdeps)
56 | 	$(CC) $(CFLAGS) dir.c
57 | mmap.o: mmap.c       $(incdeps)
58 | 	$(CC) $(CFLAGS) mmap.c
59 | inode.o: inode.c     $(incdeps)
60 | 	$(CC) $(CFLAGS) inode.c
61 | super.o: super.c     $(incdeps)
62 | 	$(CC) $(CFLAGS) super.c
63 | file.o: file.c       $(incdeps)
64 | 	$(CC) $(CFLAGS) file.c
65 | ioctl.o: ioctl.c     $(incdeps)
66 | 	$(CC) $(CFLAGS) ioctl.c
67 | nwdir.o: nwdir.c     $(incdeps)
68 | 	$(CC) $(CFLAGS) nwdir.c
69 | nwfile.o: nwfile.c   $(incdeps)
70 | 	$(CC) $(CFLAGS) nwfile.c
71 | trustee.o: trustee.c   $(incdeps)
72 | 	$(CC) $(CFLAGS) trustee.c
73 | nwext.o: nwext.c   $(incdeps)
74 | 	$(CC) $(CFLAGS) nwext.c
75 | suballoc.o: suballoc.c   $(incdeps)
76 | 	$(CC) $(CFLAGS) suballoc.c
77 | create.o: create.c   $(incdeps)
78 | 	$(CC) $(CFLAGS) create.c
79 | date.o: date.c       $(incdeps)
80 | 	$(CC) $(CFLAGS) date.c
81 | nwcreate.o: nwcreate.c   $(incdeps)
82 | 	$(CC) $(CFLAGS) nwcreate.c
83 | symlink.o: symlink.c   $(incdeps)
84 | 	$(CC) $(CFLAGS) symlink.c
85 | async.o: async.c $(incdeps)
86 | 	$(CC) $(CFLAGS) async.c
87 | nwfix.o: nwfix.c $(incdeps)
88 | 	$(CC) $(CFLAGS) nwfix.c
89 | 
90 | clean:
91 | 	rm -f *.o
92 | 
93 | 


--------------------------------------------------------------------------------
/nwioctl.h:
--------------------------------------------------------------------------------
  1 | /*++
  2 | 
  3 | Copyright (c) 1989-1999  Microsoft Corporation
  4 | Copyright (c) 1998-1999  Jeff V. Merkey
  5 | 
  6 | Module Name:
  7 | 
  8 |     NwIoctl.h
  9 | 
 10 | Abstract:
 11 | 
 12 |     This module defines the data structures used to communicate the
 13 |     Disk/Segment/Volume relationships of Netware volumes, Trustee Database
 14 |     information, and NetWare Name Space Information from User Mode
 15 |     to Kernel Mode.
 16 | 
 17 |     It is included by both the user mode MountVolume tool and the kernel
 18 |     NwfsRo.sys driver.
 19 | 
 20 | Authors:
 21 | 
 22 |     David Goebel (davidg@balder.com) 19-Jan-1999
 23 |     Jeff Merkey (jeffmerkey@gmail.com) 19-Jan-1999
 24 | 
 25 | --*/
 26 | 
 27 | #ifndef _NWIOCTL_
 28 | #define _NWIOCTL_
 29 | 
 30 | //
 31 | //  First define the name of the file system device.
 32 | //
 33 | 
 34 | #define NWFS_DEVICE_NAME        L"NwFsRo"
 35 | #define NWFS_DEVICE_NAME_W32    "\\\\.\\NwFsRo"
 36 | 
 37 | //
 38 | //  These are the current versions that must be in sync.
 39 | //
 40 | 
 41 | #define NWFSRO_MAJOR_VERSION    2
 42 | #define NWFSRO_MINOR_VERSION    0
 43 | 
 44 | //
 45 | //  First define the Ioctl code to be used to transmit the information
 46 | //  from user mode to kernel mode.  Note that we need hooks for both
 47 | //  IRP_MJ_DEVICE_CONTROL and IRP_MJ_FILE_SYSTEM_CONTROL as the former
 48 | //  gets invoked on NT 4 and the later on NT 5.
 49 | //
 50 | 
 51 | #define IOCTL_QUERY_ALL_DISKS   CTL_CODE(FILE_DEVICE_DISK_FILE_SYSTEM, \
 52 |                          0xD414,                   \
 53 |                          METHOD_BUFFERED,          \
 54 |                          FILE_READ_ACCESS)
 55 | #define FSCTL_QUERY_ALL_DISKS    IOCTL_QUERY_ALL_DISKS
 56 | 
 57 | #define IOCTL_MOUNT_VOLUME          CTL_CODE(FILE_DEVICE_DISK_FILE_SYSTEM, \
 58 |                          0xD415,                       \
 59 |                          METHOD_BUFFERED,              \
 60 |                          FILE_READ_ACCESS)
 61 | #define FSCTL_MOUNT_VOLUME          IOCTL_MOUNT_VOLUME
 62 | 
 63 | #define IOCTL_VOLUME_TRUSTEE_INFO   CTL_CODE(FILE_DEVICE_DISK_FILE_SYSTEM, \
 64 |                          0xD416,                       \
 65 |                          METHOD_BUFFERED,              \
 66 |                          FILE_READ_ACCESS)
 67 | #define FSCTL_VOLUME_TRUSTEE_INFO   IOCTL_VOLUME_TRUSTEE_INFO
 68 | 
 69 | #define IOCTL_VOLUME_USER_RESTRICT  CTL_CODE(FILE_DEVICE_DISK_FILE_SYSTEM, \
 70 |                          0xD417,                       \
 71 |                          METHOD_BUFFERED,              \
 72 |                          FILE_READ_ACCESS)
 73 | #define FSCTL_VOLUME_USER_RESTRICT  IOCTL_VOLUME_USER_RESTRICT
 74 | 
 75 | #define IOCTL_VOLUME_NAME_SPACE     CTL_CODE(FILE_DEVICE_DISK_FILE_SYSTEM, \
 76 |                          0xD418,                       \
 77 |                          METHOD_BUFFERED,              \
 78 |                          FILE_READ_ACCESS)
 79 | #define FSCTL_VOLUME_NAME_SPACE     IOCTL_VOLUME_NAME_SPACE
 80 | 
 81 | //
 82 | //  The following structues passed in to IOCTL_QUERY_ALL_DISKS
 83 | //
 84 | 
 85 | typedef struct _DISK_HANDLES
 86 | {
 87 |     HANDLE Partition0Handle;  // disk
 88 |     HANDLE PartitionHandle;   // partition
 89 | } DISK_HANDLES, *PDISK_HANDLES;
 90 | 
 91 | typedef struct _DISK_POINTERS
 92 | {
 93 |     PVOID Partition0Pointer;  // disk
 94 |     PVOID PartitionPointer;   // partition
 95 | } DISK_POINTERS, *PDISK_POINTERS;
 96 | 
 97 | typedef struct _DISK_ARRAY
 98 | {
 99 |     //
100 |     //  Version info so that the file system can detect a mis-match.
101 |     //
102 | 
103 |     USHORT MajorVersion;
104 |     USHORT MinorVersion;
105 | 
106 |     //
107 |     //  The total size of the structure.  Used for sanity checking when
108 |     //  enumerating through the segment layout records.
109 |     //
110 | 
111 |     ULONG StructureSize;
112 | 
113 |     //
114 |     //  Function code to enhace functionality for the future.  Currently
115 |     //  only two values are legal.
116 |     //
117 | 
118 |     ULONG FunctionCode;
119 |     ULONG PartitionCount;
120 | 
121 |     //
122 |     //  If mounting a volume, here is the label
123 |     //
124 | 
125 |     UCHAR VolumeLabel[16];
126 | 
127 |     union {
128 | 
129 |         DISK_HANDLES Handles[1];
130 |         DISK_POINTERS Pointers[1];
131 |     };
132 | 
133 | } DISK_ARRAY, *PDISK_ARRAY;
134 | 
135 | #define NWFS_MOUNT_VOLUME       0x00000101
136 | #define NWFS_MOUNT_ALL_VOLUMES  0x00000102
137 | 
138 | #endif // _NWIOCTL_
139 | 


--------------------------------------------------------------------------------
/nwmodsmp.mak:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | CC = gcc
 4 | LINK = ld
 5 | CFLAGS = -D__SMP__ -DMODVERSIONS -DMODULE -D__KERNEL__ -Wall \
 6 | 	 -Wstrict-prototypes -O2 -fomit-frame-pointer -fno-strength-reduce \
 7 | 	 -pipe -m386 -DCPU=386 -I/usr/src/linux/include -c 
 8 | 
 9 | LFLAGS = -m elf_i386 -Map nwfs.map -r -o 
10 | 
11 | incdeps = nwfs.h nwstruct.h nwdir.h nwhash.h nwproc.h nwvfs.h nwerror.h \
12 | 	  globals.h
13 | 
14 | objects = nwvfs.o alloc.o disk.o nwpart.o volume.o globals.o lru.o  \
15 | 	  lock.o hash.o async.o fat.o bit.o block.o cluster.o dir.o         \
16 | 	  mmap.o inode.o super.o file.o ioctl.o nwdir.o nwfile.o nwfix.o \
17 | 	  trustee.o nwext.o suballoc.o create.o date.o              \
18 | 	  nwcreate.o symlink.o nwvp.o nwvphal.o
19 | 
20 | nwfs.o: $(objects) 
21 | 	$(LINK) $(LFLAGS) nwfs.o $(objects)
22 | 
23 | nwvfs.o: nwvfs.c     $(incdeps)
24 | 	$(CC) $(CFLAGS) nwvfs.c
25 | nwvp.o: nwvp.c       $(incdeps)
26 | 	$(CC) $(CFLAGS) nwvp.c
27 | nwvphal.o: nwvphal.c $(incdeps)
28 | 	$(CC) $(CFLAGS) nwvphal.c
29 | alloc.o: alloc.c     $(incdeps)
30 | 	$(CC) $(CFLAGS) alloc.c
31 | disk.o: disk.c       $(incdeps)
32 | 	$(CC) $(CFLAGS) disk.c
33 | nwpart.o: nwpart.c   $(incdeps)
34 | 	$(CC) $(CFLAGS) nwpart.c
35 | volume.o: volume.c   $(incdeps)
36 | 	$(CC) $(CFLAGS) volume.c
37 | fat.o: fat.c         $(incdeps)
38 | 	$(CC) $(CFLAGS) fat.c
39 | globals.o: globals.c $(incdeps)
40 | 	$(CC) $(CFLAGS) globals.c
41 | lock.o: lock.c       $(incdeps)
42 | 	$(CC) $(CFLAGS) lock.c
43 | hash.o: hash.c       $(incdeps)
44 | 	$(CC) $(CFLAGS) hash.c
45 | string.o: string.c   $(incdeps)
46 | 	$(CC) $(CFLAGS) string.c
47 | lru.o: lru.c         $(incdeps)
48 | 	$(CC) $(CFLAGS) lru.c
49 | bit.o: bit.c         $(incdeps)
50 | 	$(CC) $(CFLAGS) bit.c
51 | block.o: block.c     $(incdeps)
52 | 	$(CC) $(CFLAGS) block.c
53 | cluster.o: cluster.c $(incdeps)
54 | 	$(CC) $(CFLAGS) cluster.c
55 | dir.o: dir.c         $(incdeps)
56 | 	$(CC) $(CFLAGS) dir.c
57 | mmap.o: mmap.c       $(incdeps)
58 | 	$(CC) $(CFLAGS) mmap.c
59 | inode.o: inode.c     $(incdeps)
60 | 	$(CC) $(CFLAGS) inode.c
61 | super.o: super.c     $(incdeps)
62 | 	$(CC) $(CFLAGS) super.c
63 | file.o: file.c       $(incdeps)
64 | 	$(CC) $(CFLAGS) file.c
65 | ioctl.o: ioctl.c     $(incdeps)
66 | 	$(CC) $(CFLAGS) ioctl.c
67 | nwdir.o: nwdir.c     $(incdeps)
68 | 	$(CC) $(CFLAGS) nwdir.c
69 | nwfile.o: nwfile.c   $(incdeps)
70 | 	$(CC) $(CFLAGS) nwfile.c
71 | trustee.o: trustee.c   $(incdeps)
72 | 	$(CC) $(CFLAGS) trustee.c
73 | nwext.o: nwext.c   $(incdeps)
74 | 	$(CC) $(CFLAGS) nwext.c
75 | suballoc.o: suballoc.c   $(incdeps)
76 | 	$(CC) $(CFLAGS) suballoc.c
77 | create.o: create.c   $(incdeps)
78 | 	$(CC) $(CFLAGS) create.c
79 | date.o: date.c       $(incdeps)
80 | 	$(CC) $(CFLAGS) date.c
81 | nwcreate.o: nwcreate.c   $(incdeps)
82 | 	$(CC) $(CFLAGS) nwcreate.c
83 | symlink.o: symlink.c   $(incdeps)
84 | 	$(CC) $(CFLAGS) symlink.c
85 | async.o: async.c   $(incdeps)
86 | 	$(CC) $(CFLAGS) async.c
87 | nwfix.o: nwfix.c   $(incdeps)
88 | 	$(CC) $(CFLAGS) nwfix.c
89 | 
90 | clean:
91 | 	rm -f *.o
92 | 
93 | 


--------------------------------------------------------------------------------
/nwntfs.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /***************************************************************************
  3 | *
  4 | *   Copyright (c) 1997-2022 Jeff V. Merkey
  5 | *   7260 SE Tenino St.
  6 | *   Portland, Oregon 97206
  7 | *   jeffmerkey@gmail.com
  8 | *
  9 | *   This program is free software; you can redistribute it and/or modify it
 10 | *   under the terms of the Lesser GNU Public License as published by the
 11 | *   Free Software Foundation, version 2.1, or any later version.
 12 | *
 13 | *   This program is distributed in the hope that it will be useful, but
 14 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
 15 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 16 | *   General Public License for more details.
 17 | *
 18 | *   Original Authorship      :
 19 | *      source code written by Jeff V. Merkey
 20 | *
 21 | *   Original Contributors    :
 22 | *      Jeff V. Merkey
 23 | *      
 24 | *      
 25 | *
 26 | ****************************************************************************
 27 | *
 28 | *
 29 | *   AUTHOR   :  Jeff V. Merkey (jeffmerkey@gmail.com)
 30 | *   FILE     :  NWNTFS.C
 31 | *   DESCRIP  :  NTFS Conversion Utility
 32 | *   DATE     :  November 23, 2022
 33 | *
 34 | *
 35 | ***************************************************************************/
 36 | 
 37 | #include "globals.h"
 38 | #include "goebel.h"
 39 | #include "common.h"
 40 | 
 41 | extern	W_VOLUME_INFO	structNetwareVolumesToConvert[MAX_VOLUMES];
 42 | extern	ULONG	convert_handle;
 43 | 
 44 | extern NWSCREEN ConsoleScreen;
 45 | ULONG ntfs_menu = 0;
 46 | ULONG	map_table[MAX_VOLUMES];
 47 | BYTE	volume_display_buffer[MAX_VOLUMES][80];
 48 | 
 49 | ULONG ntfs_menuAction(NWSCREEN *screen, ULONG value, BYTE *option, ULONG index)
 50 | {
 51 | 	ULONG	i, j, k;
 52 | 	ULONG	rpart_count;
 53 | 	ULONG	rpart_handles[32];
 54 | 	ULONG	temp_count;
 55 | 	ULONG	temp_handles[32];
 56 | 
 57 | 	if (value < MAX_VOLUMES)
 58 | 	{
 59 | 		nwvp_get_physical_partitions(VolumeTable[value]->nwvp_handle, &rpart_count, &rpart_handles[0]);
 60 | 		if (map_table[value] == 0)
 61 | 		{
 62 | 			for (i=0; i<MaximumNumberOfVolumes; i++)
 63 | 			{
 64 | 				if (VolumeTable[i] != 0)
 65 | 				{
 66 | 					nwvp_get_physical_partitions(VolumeTable[i]->nwvp_handle, &temp_count, &temp_handles[0]);
 67 | 					for (j=0; j<rpart_count; j++)
 68 | 					{
 69 | 						for (k=0; k<temp_count; k++)
 70 | 						{
 71 | 							if (rpart_handles[j] == temp_handles[k])
 72 | 							{
 73 | 								map_table[i] = 0xFFFFFFFF;
 74 | 								volume_display_buffer[i][2] = 'X';
 75 | 								volume_display_buffer[i][3] = 'X';
 76 | 								volume_display_buffer[i][4] = 'X';
 77 | 								break;
 78 | 							}
 79 | 						}
 80 | 					}
 81 | 				}
 82 | 			}
 83 | 		}
 84 | 		else
 85 | 		{
 86 | 			for (i=0; i<MaximumNumberOfVolumes; i++)
 87 | 			{
 88 | 				if (VolumeTable[i] != 0)
 89 | 				{
 90 | 					nwvp_get_physical_partitions(VolumeTable[i]->nwvp_handle, &temp_count, &temp_handles[0]);
 91 | 					for (j=0; j<rpart_count; j++)
 92 | 					{
 93 | 						for (k=0; k<temp_count; k++)
 94 | 						{
 95 | 							if (rpart_handles[j] == temp_handles[k])
 96 | 							{
 97 | 								map_table[i] = 0;
 98 | 								volume_display_buffer[i][2] = ' ';
 99 | 								volume_display_buffer[i][3] = ' ';
100 | 								volume_display_buffer[i][4] = ' ';
101 | 								break;
102 | 							}
103 | 						}
104 | 					}
105 | 				}
106 | 			}
107 | 
108 | 		}
109 | 	}
110 | 	display_menu(ntfs_menu);
111 |    return 0;
112 | }
113 | 
114 | ULONG netmigKeyPart(NWSCREEN *screen, ULONG key, ULONG index)
115 | {
116 | 	ULONG	i;
117 | 	ULONG	number_of_netware_volumes_selected;
118 | 
119 | 
120 |     switch (key)
121 |     {
122 |        case F2:
123 | 		number_of_netware_volumes_selected = 0;
124 | 		for (i=0; i<MaximumNumberOfVolumes; i++)
125 | 		{
126 | 			if (map_table[i] != 0)
127 | 			{
128 | 				if ((structNetwareVolumesToConvert[number_of_netware_volumes_selected].volume = VolumeTable[i]) != 0)
129 | 				{
130 | 					if (nwvp_get_physical_partitions(structNetwareVolumesToConvert[number_of_netware_volumes_selected].volume->nwvp_handle,
131 | 						&structNetwareVolumesToConvert[number_of_netware_volumes_selected].rpart_count,
132 | 						&structNetwareVolumesToConvert[number_of_netware_volumes_selected].rpart_handle[0]) == 0)
133 | 					{
134 | 						number_of_netware_volumes_selected ++;
135 | 					}
136 | 				}
137 | 			}
138 | 		}
139 | 		if (number_of_netware_volumes_selected > 0)
140 | 		{
141 | 			if (NTFSConvert(number_of_netware_volumes_selected) == 0)
142 | 				ntfs_convert_commit(convert_handle);
143 | 			ntfs_convert_end(convert_handle);
144 | 		}
145 | 		break;
146 |     }
147 |     return 0;
148 | }
149 | 
150 | #ifndef NWNTFS_LIB
151 | int main(void)
152 | #else
153 | int NWNTFS(void)
154 | #endif
155 | {
156 |     register ULONG i, retCode;
157 |     BYTE displayBuffer[255];
158 | 
159 |     InitNWFS();
160 |     NWFSVolumeScan();
161 | 
162 | #ifndef NWNTFS_LIB
163 |     if (InitConsole())
164 |        return 0;
165 | #endif
166 | 
167 | #if (LINUX_UTIL)
168 |     for (i=0; i < ConsoleScreen.nLines - 1; i++)
169 |        put_char_cleol(&ConsoleScreen, ' ', i, CYAN | BGBLUE);
170 | #endif
171 | 
172 | #if (DOS_UTIL | WINDOWS_NT_UTIL)
173 |     for (i=0; i < ConsoleScreen.nLines - 1; i++)
174 |        put_char_cleol(&ConsoleScreen, 0xB0, i, CYAN | BGBLUE);
175 | #endif
176 | 
177 | #if (WINDOWS_NT_UTIL)
178 |     sprintf(displayBuffer, "  NetMigrate for Windows NT");
179 |     put_string_cleol(&ConsoleScreen, displayBuffer, 0, BLUE | BGCYAN);
180 | #endif
181 | 
182 | #if (DOS_UTIL)
183 |     sprintf(displayBuffer, "  NetMigrate for DOS");
184 |     put_string_cleol(&ConsoleScreen, displayBuffer, 0, BLUE | BGCYAN);
185 | #endif
186 | 
187 | #if (LINUX_UTIL)
188 |     sprintf(displayBuffer, "  NetMigrate for Linux");
189 |     put_string_cleol(&ConsoleScreen, displayBuffer, 0, BLUE | BGCYAN);
190 | #endif
191 | 
192 |     sprintf(displayBuffer,
193 | 	   "  Copyright (c) 1999, 2000 Jeff V. Merkey  All Rights Reserved.");
194 |     put_string_cleol(&ConsoleScreen, displayBuffer, 1, BLUE | BGCYAN);
195 | 
196 | 
197 | #if (LINUX_UTIL)
198 |     sprintf(displayBuffer, "  F1-Help  F2-Convert ENTER-Mark F3-Exit ");
199 | #else
200 |     sprintf(displayBuffer, "  F1-Help  F2-Convert ENTER-Mark ESC-Exit");
201 | #endif
202 |     write_screen_comment_line(&ConsoleScreen, displayBuffer, BLUE | BGWHITE);
203 | 
204 |     ntfs_menu = make_menu(&ConsoleScreen,
205 | 		     "   Mark  Volume Name                          ",
206 | 		     3,
207 | 		     4,
208 | 		     5,
209 | 		     BORDER_DOUBLE,
210 | 		     YELLOW | BGBLUE,
211 | 		     YELLOW | BGBLUE,
212 | 		     BRITEWHITE | BGBLUE,
213 | 		     BRITEWHITE | BGBLUE,
214 | 		     ntfs_menuAction,
215 | 		     0,
216 | 		     netmigKeyPart,
217 | 		     TRUE,
218 | 		     MAX_VOLUMES);
219 | 
220 |     if (!ntfs_menu)
221 | 	  goto ErrorExit;
222 | 
223 |     for (i=0; i<MaximumNumberOfVolumes; i++)
224 |     {
225 | 	if (VolumeTable[i] != 0)
226 | 	{
227 | 		if (MountUtilityVolume(VolumeTable[i]) == 0)
228 | 		{
229 | 		    sprintf(&volume_display_buffer[i][0], " %s   %s ", ((map_table[i] & 0x80000000) != 0) ? "XXX" : "   ", VolumeTable[i]->VolumeName);
230 | 		    add_item_to_menu(ntfs_menu, &volume_display_buffer[i][0], i);
231 |                 }
232 | 	}
233 |     }
234 | 
235 |     retCode = activate_menu(ntfs_menu);
236 | 
237 | ErrorExit:;
238 |     sprintf(displayBuffer, " Exiting ... ");
239 |     write_screen_comment_line(&ConsoleScreen, displayBuffer, BLUE | BGWHITE);
240 | 
241 |     if (ntfs_menu)
242 |        free_menu(ntfs_menu);
243 | 
244 | #ifndef NWNTFS_LIB
245 |     ReleaseConsole();
246 | #endif
247 | 
248 |     return 0;
249 | 
250 | }
251 | 
252 | 
253 | 
254 | 
255 | 
256 | 


--------------------------------------------------------------------------------
/nwpart.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /***************************************************************************
  3 | *
  4 | *   Copyright (c) 1997-2022 Jeff V. Merkey
  5 | *   7260 SE Tenino St.
  6 | *   Portland, Oregon 97206
  7 | *   jeffmerkey@gmail.com
  8 | *
  9 | *   This program is free software; you can redistribute it and/or modify it
 10 | *   under the terms of the Lesser GNU Public License as published by the
 11 | *   Free Software Foundation, version 2.1, or any later version.
 12 | *
 13 | *   This program is distributed in the hope that it will be useful, but
 14 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
 15 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 16 | *   General Public License for more details.
 17 | *
 18 | *   Original Authorship      :
 19 | *      source code written by Jeff V. Merkey
 20 | *
 21 | *   Original Contributors    :
 22 | *      Jeff V. Merkey
 23 | *      
 24 | *      
 25 | *
 26 | ****************************************************************************
 27 | *
 28 | *
 29 | *   AUTHOR   :  Jeff V. Merkey (jeffmerkey@gmail.com)
 30 | *   FILE     :  NWPART.C
 31 | *   DESCRIP  :  Netware Partition Module
 32 | *   DATE     :  November 1, 1998
 33 | *
 34 | *
 35 | ***************************************************************************/
 36 | 
 37 | #include "globals.h"
 38 | 
 39 | ULONG segment_table_count;
 40 | segment_info_table segment_table[256];
 41 | ULONG segment_mark_table[256];
 42 | ULONG hotfix_table_count;
 43 | hotfix_info_table hotfix_table[256];
 44 | 
 45 | BYTE NwPartSignature[16] = { 0, 'N', 'w', '_', 'P', 'a', 'R', 't', 'I',
 46 | 			     't', 'I', 'o', 'N', 0, 0, 0 };
 47 | 
 48 | BYTE NetwareBootSector[512] =
 49 | {
 50 |    0xFA, 0xEB, 0x74, 0x43, 0x4F, 0x50, 0x59, 0x52,
 51 |    0x49, 0x47, 0x48, 0x54, 0x20, 0x28, 0x43, 0x29,
 52 |    0x20, 0x32, 0x30, 0x30, 0x30, 0x20, 0x54, 0x52,
 53 |    0x47, 0x2C, 0x20, 0x49, 0x4E, 0x43, 0x20, 0x00,
 54 |    0x1A, 0x54, 0x52, 0x47, 0x00, 0x1A, 0x18, 0x49,
 55 |    0x4E, 0x56, 0x41, 0x4C, 0x49, 0x44, 0x20, 0x50,
 56 |    0x41, 0x52, 0x54, 0x49, 0x54, 0x49, 0x4F, 0x4E,
 57 |    0x20, 0x54, 0x41, 0x42, 0x4C, 0x45, 0x00, 0x4D,
 58 |    0x49, 0x53, 0x53, 0x49, 0x4E, 0x47, 0x20, 0x4F,
 59 |    0x50, 0x45, 0x52, 0x41, 0x54, 0x49, 0x4E, 0x47,
 60 |    0x20, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4D, 0x00,
 61 |    0x45, 0x52, 0x52, 0x4F, 0x52, 0x20, 0x4C, 0x4F,
 62 |    0x41, 0x44, 0x49, 0x4E, 0x47, 0x20, 0x4F, 0x50,
 63 |    0x45, 0x52, 0x41, 0x54, 0x49, 0x4E, 0x47, 0x20,
 64 |    0x53, 0x59, 0x53, 0x54, 0x45, 0x4D, 0x00, 0x33,
 65 |    0xC0, 0x8E, 0xC0, 0x8E, 0xD8, 0x8E, 0xD0, 0xBC,
 66 |    0x00, 0x7C, 0xFB, 0xBE, 0x00, 0x7C, 0xBF, 0x00,
 67 |    0x06, 0xB9, 0x00, 0x02, 0xFC, 0xF3, 0xA4, 0xEA,
 68 |    0x94, 0x06, 0x00, 0x00, 0xB9, 0x04, 0x00, 0xBE,
 69 |    0xBE, 0x07, 0x80, 0x3C, 0x80, 0x74, 0x16, 0x83,
 70 |    0xC6, 0x10, 0xE2, 0xF6, 0xBE, 0x27, 0x06, 0xAC,
 71 |    0x0A, 0xC0, 0x74, 0x06, 0xB4, 0x0E, 0xCD, 0x10,
 72 |    0xEB, 0xF5, 0xFB, 0xEB, 0xFE, 0x8B, 0xFE, 0x49,
 73 |    0x74, 0x0D, 0x83, 0xC6, 0x10, 0x80, 0x3C, 0x80,
 74 |    0x75, 0xF5, 0xBE, 0x27, 0x06, 0xEB, 0xE0, 0xBE,
 75 |    0x05, 0x00, 0x8B, 0x15, 0x8B, 0x4D, 0x02, 0xBB,
 76 |    0x00, 0x7C, 0xB8, 0x01, 0x02, 0xCD, 0x13, 0x73,
 77 |    0x0C, 0x33, 0xC0, 0xCD, 0x13, 0x4E, 0x75, 0xEF,
 78 |    0xBE, 0x58, 0x06, 0xEB, 0xC2, 0x59, 0x81, 0x3E,
 79 |    0xFE, 0x7D, 0x55, 0xAA, 0x74, 0x05, 0xBE, 0x3F,
 80 |    0x06, 0xEB, 0xB4, 0x8B, 0xF7, 0xEA, 0x00, 0x7C,
 81 |    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 82 | };
 83 | 
 84 | void SyncDisks(void)
 85 | {
 86 | #if (LINUX_UTIL)
 87 |     register ULONG j;
 88 | 
 89 |     for (j=0; j < MAX_DISKS; j++)
 90 |     {
 91 |        if (SystemDisk[j] && SystemDisk[j]->PhysicalDiskHandle)
 92 | 	  SyncDevice((ULONG)SystemDisk[j]->PhysicalDiskHandle);
 93 |     }
 94 | #endif
 95 | }
 96 | 
 97 | BYTE *get_block_descrip(ULONG Type)
 98 | {
 99 |     switch(Type)
100 |     {
101 |        case FOUR_K_BLOCK:       return "4K ClusterSize";
102 |        case EIGHT_K_BLOCK:      return "8K ClusterSize";
103 |        case SIXTEEN_K_BLOCK:    return "16K ClusterSize";
104 |        case THIRTYTWO_K_BLOCK:  return "32K ClusterSize";
105 |        case SIXTYFOUR_K_BLOCK:  return "64K ClusterSize";
106 |        default:                 return "??? ClusterSize";
107 |     }
108 | }
109 | 
110 | ULONG get_block_value(ULONG Type)
111 | {
112 |     switch(Type)
113 |     {
114 |        case FOUR_K_BLOCK:       return 4096;
115 |        case EIGHT_K_BLOCK:      return 8192;
116 |        case SIXTEEN_K_BLOCK:    return 16384;
117 |        case THIRTYTWO_K_BLOCK:  return 32768;
118 |        case SIXTYFOUR_K_BLOCK:  return 65536;
119 |        default:                 return 0;
120 |     }
121 | }
122 | 
123 | // hotfix tables are laid out at 20 sector intervals
124 | // starting at offset 20 (dec) from the start of a Netware partition
125 | // mirroring tables follow the same layout rules, except these tables
126 | // start at sector 21 (dec) from the start of the partition and continue
127 | // at 20 sector intervals.  There are four copies of these tables.
128 | //
129 | // The current layout of hotfixing is in fact a remnant of the days
130 | // of legacy disk drives.  In the early days of PC architecture devices,
131 | // using this layout guaranteed that at least one copy of these tables
132 | // would be recoverable because this addressing insured that multiple
133 | // copies of the hot fix and mirroring tables would reside on separate
134 | // spindles of an HDD device.  Today, drives are all translated and
135 | // sector:head:cylinder addressing is now logical rather than physical.
136 | // Modern HDD devices also provide internal hot fix support for
137 | // redirection of defective sectors.  Hotfixing does, however, still
138 | // provide an excellent mechanism for performing sector error
139 | // redirection as an internal file system component for those systems
140 | // with older or less sophisticated hardware, and may on some
141 | // manufacturers hardware provide some benefit.  With most modern
142 | // disk devices, however, hotfixing just wastes disk space.
143 | //
144 | 
145 | void FreePartitionResources(void)
146 | {
147 |     register ULONG i;
148 |     extern void displayMemoryList(void);
149 |     extern void free_bh_list(void);
150 |     extern BYTE *LRUBlockHash;
151 |     extern ULONG LRUBlockHashLimit;
152 | 
153 |     for (i=0; i < MAX_VOLUMES; i++)
154 |     {
155 |        if (VolumeTable[i])
156 | 	  NWFSFree(VolumeTable[i]);
157 |        VolumeTable[i] = 0;
158 |     }
159 | 
160 |     if (LRUBlockHash)
161 |        NWFSFree(LRUBlockHash);
162 |     LRUBlockHash = 0;
163 |     LRUBlockHashLimit = 0;
164 | 
165 |     FreeLRU();
166 | 
167 |     if (ZeroBuffer)
168 |        NWFSFree(ZeroBuffer);
169 |     ZeroBuffer = 0;
170 | 
171 |     // release hash node free list
172 |     FreeHashNodes();
173 | 
174 | #if (LINUX_20 | LINUX_22 | LINUX_24)
175 |     // release IO buffer heads
176 |     free_bh_list();
177 | #endif
178 | 
179 |     if (MemoryAllocated != MemoryFreed)
180 |     {
181 |        NWFSPrint("nwfs:  %d bytes of memory leaked!!!  alloc-%d free-%d\n",
182 | 		(int)(MemoryAllocated - MemoryFreed),
183 | 		(int)MemoryAllocated, (int)MemoryFreed);
184 |        displayMemoryList();
185 |     }
186 |     else
187 |     {
188 | #if (VERBOSE)
189 |        NWFSPrint("nwfs:  physical memory  allocated-%d freed-%d inuse-%d\n",
190 | 		(int)MemoryAllocated, (int)MemoryFreed, (int)MemoryInUse);
191 | #endif
192 |     }
193 | 
194 |     if (PagedMemoryAllocated != PagedMemoryFreed)
195 |     {
196 |        NWFSPrint("nwfs:  %d bytes of paged memory leaked!!!  alloc-%d free-%d\n",
197 | 		(int)(PagedMemoryAllocated - PagedMemoryFreed),
198 | 		(int)PagedMemoryAllocated, (int)PagedMemoryFreed);
199 |        displayMemoryList();
200 |     }
201 |     else
202 |     {
203 | #if (VERBOSE)
204 |        NWFSPrint("nwfs:  virtual memory   allocated-%d freed-%d inuse-%d\n",
205 | 		(int)PagedMemoryAllocated, (int)PagedMemoryFreed,
206 | 		(int)PagedMemoryInUse);
207 | #endif
208 |     }
209 |     return;
210 | 
211 | }
212 | 
213 | 


--------------------------------------------------------------------------------
/nwrepair.c:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | /***************************************************************************
  4 | *
  5 | *   Copyright (c) 1997-2022 Jeff V. Merkey
  6 | *   7260 SE Tenino St.
  7 | *   Portland, Oregon 97206
  8 | *   jeffmerkey@gmail.com
  9 | *
 10 | *   This program is free software; you can redistribute it and/or modify it
 11 | *   under the terms of the Lesser GNU Public License as published by the
 12 | *   Free Software Foundation, version 2.1, or any later version.
 13 | *
 14 | *   This program is distributed in the hope that it will be useful, but
 15 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
 16 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 17 | *   General Public License for more details.
 18 | *
 19 | *   Original Authorship      :
 20 | *      source code written by Jeff V. Merkey
 21 | *
 22 | *   Original Contributors    :
 23 | *      Jeff V. Merkey
 24 | *      
 25 | *      
 26 | *
 27 | ****************************************************************************
 28 | *
 29 | *
 30 | *   AUTHOR   :  , Jeff V. Merkey
 31 | *   FILE     :  NWREPAIR.C
 32 | *   DESCRIP  :  NetWare File System Repair Tool
 33 | *   DATE     :  December 10, 2022
 34 | *
 35 | *
 36 | ***************************************************************************/
 37 | 
 38 | #include "globals.h"
 39 | 
 40 | 
 41 | extern	ULONG input_get_number(ULONG *new_value);
 42 | 
 43 | int main(int argc, char *argv[])
 44 | {
 45 | 
 46 |     ULONG i;
 47 |     ULONG index;
 48 |     ULONG display_base = 0;
 49 |     BYTE input_buffer[20] = { "" };
 50 |     nwvp_fat_fix_info   fix_info;
 51 |     extern void UtilScanVolumes(void);
 52 |     
 53 |     InitNWFS();
 54 |     UtilScanVolumes();
 55 | 
 56 |     while (TRUE)
 57 |     {
 58 |        SyncDisks();
 59 | 
 60 |        ClearScreen(consoleHandle);
 61 |        NWFSPrint("NetWare Volume Repair Utility\n");
 62 |        NWFSPrint("Copyright (c) 1999, 2000 Jeffrey V. Merkey.  All Rights Reserved.\n");
 63 | 
 64 |        NWFSPrint("\n  #        Volume Name   Segment   FAT Mirror  FAT Table  Dir Table \n");
 65 | 
 66 |        for (i=0; i < 8; i++)
 67 |        {
 68 | 	  if ((index = (display_base + i)) < MaximumNumberOfVolumes)
 69 | 	  {
 70 | 		NWFSPrint("\n %3d ", (int) index);
 71 | 		if (VolumeTable[index] != 0)
 72 | 		{
 73 | 			NWFSPrint(" %16s ", VolumeTable[index]->VolumeName);
 74 | 			if (VolumeTable[index]->volume_segments_ok_flag == 0)
 75 | 			{
 76 | 				NWFSPrint("  MISSING ");
 77 | 				NWFSPrint("    ****   ");
 78 | 				NWFSPrint("    ****   ");
 79 | 				NWFSPrint("    ****   ");
 80 | 
 81 | 			}
 82 | 			else
 83 | 			{
 84 | 				NWFSPrint("  COMPLETE ");
 85 | 				if (VolumeTable[index]->fat_mirror_ok_flag == 0)
 86 | 				{
 87 | 					NWFSPrint("  MISMATCH ");
 88 | 					NWFSPrint("    ****   ");
 89 | 					NWFSPrint("    ****   ");
 90 | 				}
 91 | 				else
 92 | 				{
 93 | 					NWFSPrint("     OK    ");
 94 | 					if (VolumeTable[index]->fat_table_ok_flag == 0)
 95 | 					{
 96 | 						NWFSPrint("   INVALID ");
 97 | 						NWFSPrint("    ****   ");
 98 | 					}
 99 | 					else
100 | 					{
101 | 						NWFSPrint("     OK    ");
102 | 						if (VolumeTable[index]->directory_table_ok_flag == 0)
103 | 						{
104 | 							NWFSPrint("   INVALID ");
105 | 						}
106 | 						else
107 | 						{
108 | 							NWFSPrint("     OK    ");
109 | 						}
110 | 					}
111 | 
112 | 				}
113 | 			}
114 | 		}
115 | 		else
116 | 		{
117 | 			NWFSPrint(" EMPTY ");
118 | 		}
119 | 	  }
120 | 	  else
121 | 	     NWFSPrint("\n");
122 |        }
123 | 
124 |        NWFSPrint("\n\n\n");
125 |        NWFSPrint("               1. Fix FAT Mirrors/Table\n");
126 |        NWFSPrint("               2. Fix Volume Mirrors/Tables\n");
127 |        NWFSPrint("               3. Scroll Segment List\n");
128 |        NWFSPrint("               4. Exit Menu\n");
129 |        NWFSPrint("        Enter a Menu Option: ");
130 |        fgets(input_buffer, sizeof(input_buffer), stdin);
131 |        switch (input_buffer[0])
132 |        {
133 | 	  case '1':
134 | 	     NWFSPrint("    Enter Volume Number: ");
135 | 	     if (input_get_number(&index) == 0)
136 | 	     {
137 | 		if ((index < MaximumNumberOfVolumes) && (VolumeTable[index] != 0))
138 | 		{
139 | 			if (nwvp_vpartition_fat_fix(VolumeTable[index]->nwvp_handle, &fix_info, 1) == 0)
140 | 			{
141 | 				VolumeTable[index]->fat_mirror_ok_flag = 0xFFFFFFFF;
142 |                                 FlushLRU();
143 | 				break;
144 | 			}
145 | 			NWFSPrint("       *********  Error Fixing Fat Mirrors **********\n");
146 | 			WaitForKey();
147 | 			break;
148 | 		}
149 | 	     }
150 | 	     NWFSPrint("       *********  Invalid Volume Number **********\n");
151 | 	     WaitForKey();
152 | 	     break;
153 | 	     
154 | 	  case '2':
155 | 	     NWFSPrint("    Enter Volume Number: ");
156 | 	     if (input_get_number(&index) == 0)
157 | 	     {
158 | 		if ((index < MaximumNumberOfVolumes) && (VolumeTable[index] != 0))
159 | 		{
160 |                         extern ULONG NWRepairVolume(VOLUME *, ULONG);
161 | 			
162 |                         ClearScreen(consoleHandle);
163 | 			NWRepairVolume(VolumeTable[index], TRUE);
164 |                         FlushLRU();
165 | 	                WaitForKey();
166 | 			break;
167 | 		}
168 | 	     }
169 | 	     NWFSPrint("       *********  Invalid Volume Number **********\n");
170 | 	     WaitForKey();
171 | 	     break;
172 | 
173 | 	  case '3':
174 | 	     display_base += 8;
175 | 	     if (display_base >= MaximumNumberOfVolumes)
176 | 		display_base = 0;
177 | 	     break;
178 | 
179 | 	  case '4':
180 | 	    NWFSVolumeClose();
181 | 	    RemoveDiskDevices();
182 | 	    FreePartitionResources();
183 | 	    return 0;
184 |        }
185 |     }
186 | }
187 | 
188 | 
189 | 
190 | 
191 | 


--------------------------------------------------------------------------------
/nwrwlock.c:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | /***************************************************************************
  4 | *
  5 | *   Copyright (c) 1997-2022 Jeff V. Merkey
  6 | *   7260 SE Tenino St.
  7 | *   Portland, Oregon 97206
  8 | *   jeffmerkey@gmail.com
  9 | *
 10 | *   This program is free software; you can redistribute it and/or modify it
 11 | *   under the terms of the Lesser GNU Public License as published by the
 12 | *   Free Software Foundation, version 2.1, or any later version.
 13 | *
 14 | *   This program is distributed in the hope that it will be useful, but
 15 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
 16 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 17 | *   General Public License for more details.
 18 | *
 19 | *   Original Authorship      :
 20 | *      source code written by Jeff V. Merkey
 21 | *
 22 | *   Original Contributors    :
 23 | *      Jeff V. Merkey
 24 | *      
 25 | *      
 26 | *
 27 | ****************************************************************************
 28 | *
 29 | *
 30 | *   AUTHOR   :  Jeff V. Merkey (jeffmerkey@gmail.com)
 31 | *   FILE     :  RWLOCK.C
 32 | *   DESCRIP  :  Reader Writer Locks
 33 | *   DATE     :  April 2, 2000
 34 | *
 35 | *
 36 | ***************************************************************************/
 37 | 
 38 | #include "globals.h"
 39 | 
 40 | 
 41 | //
 42 | //  SMP Reader Writer Locks for the File FAT List Heads.
 43 | //
 44 | 
 45 | void NWLockRW(HASH *hash)
 46 | {
 47 | #if (LINUX_SLEEP)
 48 |    if (WaitOnSemaphore((struct semaphore *)&hash->RWSemaphore) == -EINTR)
 49 |        NWFSPrint("LockRW (%s) was interrupted\n", hash->Name);
 50 | #endif
 51 | }
 52 | 
 53 | void NWUnlockRW(HASH *hash)
 54 | {
 55 | #if (LINUX_SLEEP)
 56 |     SignalSemaphore(&hash->RWSemaphore);
 57 | #endif
 58 | }
 59 | 
 60 | ULONG SleepOnReadersQueue(HASH *hash)
 61 | {
 62 |     hash->readers_pending++;
 63 |     NWUnlockRW(hash);
 64 | 
 65 | #if (LINUX_SLEEP)
 66 |     WaitOnSemaphore(&hash->ReadersSemaphore);
 67 | #endif
 68 | 
 69 |     NWLockRW(hash);
 70 |     // handle is invalid
 71 |     if (hash->Signature != (ULONG)"HASH")
 72 |        return -1;
 73 |     return 0;
 74 | }
 75 | 
 76 | ULONG SleepOnWritersQueue(HASH *hash)
 77 | {
 78 |     hash->writers_pending++;
 79 |     NWUnlockRW(hash);
 80 | 
 81 | #if (LINUX_SLEEP)
 82 |     WaitOnSemaphore(&hash->WritersSemaphore);
 83 | #endif
 84 | 
 85 |     NWLockRW(hash);
 86 |     // handle is invalid
 87 |     if (hash->Signature != (ULONG)"HASH")
 88 |        return -1;
 89 |     return 0;
 90 | }
 91 | 
 92 | void ReleaseNextReader(HASH *hash)
 93 | {
 94 |    if (hash->readers_pending)
 95 |    {
 96 |       hash->readers_pending--;
 97 | #if (LINUX_SLEEP)
 98 |       SignalSemaphore(&hash->ReadersSemaphore);
 99 | #endif
100 |    }
101 | }
102 | 
103 | void ReleaseNextWriter(HASH *hash)
104 | {
105 |    if (hash->writers_pending)
106 |    {
107 |       hash->writers_pending--;
108 | #if (LINUX_SLEEP)
109 |       SignalSemaphore(&hash->WritersSemaphore);
110 | #endif
111 |    }
112 | }
113 | 
114 | void ReleaseReaders(HASH *hash)
115 | {
116 |    while (hash->readers_pending)
117 |    {
118 |       hash->readers_pending--;
119 | #if (LINUX_SLEEP)
120 |       SignalSemaphore(&hash->ReadersSemaphore);
121 | #endif
122 |    }
123 | }
124 | 
125 | void ReleaseWriters(HASH *hash)
126 | {
127 |    while (hash->writers_pending)
128 |    {
129 |       hash->writers_pending--;
130 | #if (LINUX_SLEEP)
131 |       SignalSemaphore(&hash->WritersSemaphore);
132 | #endif
133 |    }
134 | }
135 | 
136 | ULONG NWReaderWriterLock(HASH *hash, ULONG which)
137 | {
138 |     register ULONG ccode;
139 | 
140 |     which = which % WRITER;
141 |     NWLockRW(hash);
142 |     switch (hash->rw_state)
143 |     {
144 |        case READER_OWNER:
145 |           switch (which)
146 |           {
147 |              case READER:
148 |                 if (hash->writers_pending)
149 |                 {
150 |                    ccode = SleepOnReadersQueue(hash);
151 |                    hash->readers++;
152 |                    NWUnlockRW(hash);
153 |                    return ccode;
154 |                 }
155 |                 hash->readers++;
156 |                 NWUnlockRW(hash);
157 |                 return 0;
158 | 
159 |              case WRITER:
160 |                 if (hash->readers)
161 |                 {
162 |                    ccode = SleepOnWritersQueue(hash);
163 |                    hash->writers++;
164 |                    hash->writers_count++;
165 |                    NWUnlockRW(hash);
166 |                    return ccode;
167 |                 }
168 |                 hash->rw_state = WRITER_OWNER;
169 |                 hash->writers++;
170 |                 hash->writers_count++;
171 |                 NWUnlockRW(hash);
172 |                 return 0;
173 | 
174 |              default:
175 |                 return -2;
176 |           }
177 |           break;
178 | 
179 |        case WRITER_OWNER:
180 |           switch (which)
181 |           {
182 |              case READER:
183 |                 ccode = SleepOnReadersQueue(hash);
184 |                 hash->readers++;
185 |                 NWUnlockRW(hash);
186 |                 return ccode;
187 | 
188 |              case WRITER:
189 |                 ccode = SleepOnWritersQueue(hash);
190 |                 hash->writers++;
191 |                 hash->writers_count++;
192 |                 NWUnlockRW(hash);
193 |                 return ccode;
194 | 
195 |              default:
196 |                 return -2;
197 |           }
198 |           break;
199 | 
200 |        default:
201 |           NWUnlockRW(hash);
202 |           return -3;   // bad hash structure
203 |     }
204 |     NWUnlockRW(hash);
205 |     return 0;
206 | }
207 | 
208 | ULONG NWReaderWriterUnlock(HASH *hash, ULONG which)
209 | {
210 |     which = which % WRITER;
211 |     NWLockRW(hash);
212 |     switch (hash->rw_state)
213 |     {
214 |        case READER_OWNER:
215 |           if (which == WRITER)
216 |           {
217 |              NWFSPrint("nwfs:  fatal -- rwlock state mismatch (r-%d/c-%d)\n",
218 | 	               (int)which, (int)hash->rw_state);
219 |              return -1;
220 |           }
221 | 
222 |           if (hash->readers)
223 |              hash->readers--;
224 | 
225 |           if (!hash->readers)
226 | 	  {
227 | 	     if (hash->writers_pending)
228 |                 ReleaseNextWriter(hash);
229 |           }
230 |           NWUnlockRW(hash);
231 |           return 0;
232 | 
233 |        case WRITER_OWNER:
234 |           if (which == READER)
235 |           {
236 |              NWFSPrint("nwfs:  fatal -- rwlock state mismatch (r-%d/c-%d)\n",
237 | 	               (int)which, (int)hash->rw_state);
238 |              return -1;
239 |           }
240 | 
241 |           if (hash->writers_pending)
242 |           {
243 |              ReleaseNextWriter(hash);
244 |              NWUnlockRW(hash);
245 |              return 0;
246 |           }
247 | 
248 |           hash->rw_state = READER_OWNER;
249 |           if (hash->readers_pending)
250 |           {
251 |              ReleaseReaders(hash); // release all the readers.
252 |              NWUnlockRW(hash);
253 |              return 0;
254 |           }
255 |           break;
256 | 
257 |        default:
258 |           NWUnlockRW(hash);
259 |           return -2;   // bad hash structure
260 |     }
261 |     NWUnlockRW(hash);
262 |     return 0;
263 | }
264 | 
265 | 


--------------------------------------------------------------------------------
/nwvol.c:
--------------------------------------------------------------------------------
 1 | 
 2 | /***************************************************************************
 3 | *
 4 | *   Copyright (c) 1997-2022 Jeff V. Merkey
 5 | *   7260 SE Tenino St.
 6 | *   Portland, Oregon 97206
 7 | *   jeffmerkey@gmail.com
 8 | *
 9 | *   This program is free software; you can redistribute it and/or modify it
10 | *   under the terms of the Lesser GNU Public License as published by the
11 | *   Free Software Foundation, version 2.1, or any later version.
12 | *
13 | *   This program is distributed in the hope that it will be useful, but
14 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
15 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 | *   General Public License for more details.
17 | *
18 | *   Original Authorship      :
19 | *      source code written by Jeff V. Merkey
20 | *
21 | *   Original Contributors    :
22 | *      Jeff V. Merkey
23 | *      
24 | *      
25 | *
26 | *
27 | ****************************************************************************
28 | *
29 | *
30 | *   AUTHOR   :  Jeff V. Merkey (jeffmerkey@gmail.com)
31 | *   FILE     :  NWVOL.C
32 | *   DESCRIP  :  VOlume DIsplay Utility
33 | *   DATE     :  November 1, 1998
34 | *
35 | *
36 | ***************************************************************************/
37 | 
38 | #include "globals.h"
39 | 
40 | int main(int argc, char *argv[])
41 | {
42 |     extern void UtilScanVolumes(void);
43 |     
44 |     printf("NWVOL\n");
45 |     printf("Copyright (C) 1998-1999 Jeff V. Merkey\n");
46 |     printf("All Rights Reserved\n\n");
47 | 
48 |     InitNWFS();
49 |     UtilScanVolumes();
50 |     displayNetwareVolumes();
51 |     NWFSVolumeClose();
52 |     RemoveDiskDevices();
53 |     FreePartitionResources();
54 |     printf("\n");
55 |     return 0;
56 | 
57 | }
58 | 
59 | 
60 | 
61 | 
62 | 


--------------------------------------------------------------------------------
/nwvpcmd.h:
--------------------------------------------------------------------------------
 1 | /***************************************************************************
 2 | *
 3 | *   Copyright (c) 1997, 1998 Jeff V. Merkey  All Rights
 4 | *			    Reserved.
 5 | *
 6 | *   AUTHOR   :  Doug Ward
 7 | *   FILE     :  NWVPCMD.H
 8 | *   DESCRIP  :  NWVP command function prototypes and datastructures
 9 | *   DATE     :  May 17, 1998
10 | *
11 | *
12 | ***************************************************************************/
13 | 
14 | #ifndef NWVPCMD_H
15 | #define NWVPCMD_H
16 | 
17 | //=====================================
18 | //	PROTOTYPES
19 | //=====================================
20 | 
21 | void    raw_create_routine(
22 | 	vndi_console    *console);
23 | 
24 | void    raw_delete_routine(
25 | 	vndi_console    *console);
26 | 
27 | void    raw_online_routine(
28 | 	vndi_console    *console);
29 | 
30 | void    raw_offline_routine(
31 | 	vndi_console    *console);
32 | 
33 | void    raw_scan_routine(
34 | 	vndi_console    *console);
35 | 
36 | void    raw_scana_routine(
37 | 	vndi_console    *console);
38 | 
39 | void    raw_show_error_routine(
40 | 	vndi_console    *console);
41 | 
42 | void    raw_scans_routine(
43 | 	vndi_console    *console);
44 | 
45 | void    raw_error_routine(
46 | 	vndi_console    *console);
47 | 
48 | void    raw_clear_error_routine(
49 | 	vndi_console    *console);
50 | 
51 | void    raw_read_routine(
52 | 	vndi_console    *console);
53 | 
54 | void    raw_write_routine(
55 | 	vndi_console    *console);
56 | 
57 | void    display_buffer_routine(
58 | 	vndi_console            *console);
59 | 
60 | void    set_buffer_routine(
61 | 	vndi_console            *console);
62 | 
63 | void 	blank_help_routine (
64 | 	vndi_console		*console);
65 | 
66 | void    vndi_add_commands(
67 | 	vndi_console            *console);
68 | 
69 | BOOL	vndi_validate_params( 
70 | 	vndi_console		*console,
71 | 	int32			min_number_of_params,
72 | 	int32			max_number_of_params,
73 | 	char 			*param_types,
74 | 	void			(*help_routine)(vndi_console *));
75 | 
76 | void    do_nothing(
77 | 	vndi_console		*console);
78 | 
79 | #endif
80 | 


--------------------------------------------------------------------------------
/nwvpext.h:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | /***************************************************************************
 4 | *
 5 | *   Copyright (c) 1997-2022 Jeff V. Merkey
 6 | *   7260 SE Tenino St.
 7 | *   Portland, Oregon 97206
 8 | *
 9 | ****************************************************************************
10 | *
11 | *   AUTHOR   :  
12 | *   FILE     :  NWVP1.H
13 | *   DESCRIP  :  NetWare Virtual Partition
14 | *   DATE     :  August 1, 2022
15 | *
16 | ***************************************************************************/
17 | 
18 | 
19 | #define		NWVP_HOTFIX_FOUND		1
20 | #define		NWVP_VOLUMES_FOUND		2
21 | #define		NWVP_FIRST_FAT_FOUND	3
22 | 
23 | typedef	struct	nwvp_hotfix_scan_info_def
24 | {
25 | 	ULONG	hotfix_partition_offset;
26 | 	ULONG	hotfix_data_offset;
27 | 	ULONG	hotfix_data_size;
28 | } nwvp_hotfix_scan_info;
29 | 
30 | typedef	struct	nwvp_volume_scan_info_def
31 | {
32 | 	ULONG	volume_sector_offset;
33 | 	ULONG	volume_segment_count;
34 | 	struct
35 | 	{
36 |     	ULONG	total_cluster_count;
37 | 		ULONG	segment_sector_offset;
38 | 		ULONG	segment_sector_count;
39 | 		ULONG	segment_info;
40 | 	} segments[8];
41 | } nwvp_volume_scan_info;
42 | 
43 | typedef	struct	nwvp_fat_scan_info_def
44 | {
45 | 	ULONG	complete_flag;
46 | 	ULONG	blocks_per_cluster;
47 | 	ULONG	DIR_cluster_count;
48 | 	ULONG	DIR1_cluster_offset;
49 | 	ULONG	DIR2_cluster_offset;
50 | 	ULONG	FAT_sector_offset;
51 | 	ULONG	FAT_cluster_count;
52 | 	ULONG	FAT1_cluster_offset;
53 | 	ULONG	FAT2_cluster_offset;
54 | } nwvp_fat_scan_info;
55 | 
56 | ULONG	nwvp_FAT_compare(
57 | 	FAT_ENTRY	*fat1,
58 | 	FAT_ENTRY	*fat2,
59 | 	ULONG		mismatch_count);
60 | 
61 | ULONG	nwvp_recover_nwpart_info(
62 | 	ULONG			lpart_handle,
63 | 	ULONG			total_sector_count,
64 | 	ULONG			block_offset,
65 | 	ULONG			block_count,
66 | 	nwvp_hotfix_scan_info	*hotfix_info,
67 | 	nwvp_volume_scan_info	*volume_info,
68 | 	nwvp_fat_scan_info		*fat_info);
69 | 
70 | ULONG	inwvp_lpartition_block_map(
71 | 	nwvp_lpart	*original_part,
72 | 	ULONG		block_number,
73 | 	ULONG		block_count,
74 | 	ULONG		mirror_index,
75 | 	nwvp_block_map	*bmap);
76 | 
77 | ULONG	nwvp_vpartition_block_map(
78 | 	ULONG		vpart_handle,
79 | 	ULONG		block_number,
80 | 	ULONG		block_count,
81 | 	ULONG		mirror_index,
82 | 	nwvp_block_map	*bmap);
83 | 
84 | 


--------------------------------------------------------------------------------
/nwvphal.h:
--------------------------------------------------------------------------------
  1 | /***************************************************************************
  2 | *
  3 | *   Copyright (c) 1997, 1997-2022 Jeff V. Merkey  All Rights
  4 | *                           Reserved.
  5 | *
  6 | *
  7 | *   AUTHOR   :  
  8 | *   FILE     :  NWVPHAL.H
  9 | *   DESCRIP  :  NetWare Virtual Partition
 10 | *   DATE     :  August 1, 2022
 11 | *
 12 | ***************************************************************************/
 13 | 
 14 | #ifndef _NWVPHAL_
 15 | #define _NWVPHAL_
 16 | 
 17 | #define	vndi_console	nwvp_console
 18 | #define	vndi_payload	nwvp_payload
 19 | 
 20 | typedef	struct	nwvp_payload_def
 21 | {
 22 | 	ULONG		payload_index;
 23 | 	ULONG		payload_object_count; 				// return value
 24 | 	ULONG		payload_object_size_buffer_size;
 25 | 	BYTE		*payload_buffer;
 26 | } nwvp_payload;
 27 | 
 28 | typedef	struct	nwvp_part_info_def
 29 | {
 30 | 	ULONG	partition_type;
 31 | 	ULONG	sector_size_shift;
 32 | 	ULONG	sector_count;
 33 | 	ULONG	low_level_handle;
 34 | } nwvp_part_info;
 35 | 
 36 | typedef	struct	nwvp_rpart_def
 37 | {
 38 | 	ULONG	vndi_type;
 39 | 	ULONG	vndi_handle;
 40 | 	ULONG	rpart_table_index;
 41 | 	ULONG	scan_field;
 42 | 
 43 | 	BYTE	filename[32];
 44 | 	
 45 | 	ULONG	capacity;
 46 | 	ULONG	sector_size_shift;
 47 | 	ULONG	online_flag;
 48 | 	ULONG    error_flag;
 49 | 	
 50 | 	ULONG	f_handle;
 51 | 	ULONG	errors[32];
 52 | 	ULONG	error_param[32];
 53 | 	ULONG	index;
 54 | } nwvp_part;
 55 | 
 56 | typedef struct nwvp_entry_def
 57 | {
 58 | 	ULONG	vndi_type;
 59 | 	ULONG	index;
 60 | 	BYTE	filename[32];
 61 | } nwvp_entry;
 62 | 
 63 | #define		RPART_ERROR_IO				1
 64 | #define		RPART_ONLINE				1
 65 | #define		RPART_OFFLINE				0	
 66 | #define		NWVP_READWRITE_BUFFER_SIZE	16384
 67 | 
 68 | void	nwvp_part_unscan(void);
 69 | 
 70 | ULONG	nwvp_part_scan(
 71 | 	nwvp_payload	*req_payload);
 72 | 
 73 | ULONG	nwvp_part_scan_specific(
 74 | 	ULONG	handle,
 75 | 	nwvp_part_info	*part_info);
 76 | 
 77 | ULONG	nwvp_part_read(
 78 | 	ULONG	handle,
 79 | 	ULONG	sector_offset,
 80 | 	ULONG	sector_count,
 81 | 	BYTE	*data_buffer);
 82 | 
 83 | ULONG	nwvp_raw_read (
 84 | 	nwvp_part				*rpart,
 85 | 	ULONG					sector_offset,
 86 | 	ULONG					sector_count,
 87 | 	BYTE					*data_buffer);
 88 | 
 89 | ULONG	nwvp_part_write(
 90 | 	ULONG	handle,
 91 | 	ULONG	sector_offset,
 92 | 	ULONG	sector_count,
 93 | 	BYTE	*data_buffer);
 94 | 
 95 | ULONG	nwvp_raw_write (
 96 | 	nwvp_part				*rpart,
 97 | 	ULONG					sector_offset,
 98 | 	ULONG					sector_count,
 99 | 	BYTE					*data_buffer);
100 | 
101 | ULONG	dbase_write(void);
102 | 
103 | ULONG	rpart_open(
104 | 	BYTE					*filename,
105 | 	ULONG					index);
106 | 
107 | 
108 | ULONG	nwvp_get_date_and_time(void);
109 | 
110 | ULONG	nwvp_thread_get_id(void);
111 | 
112 | void	nwvp_thread_delay(
113 | 	ULONG	amount);
114 | 
115 | void	nwvp_thread_sleep(void);
116 | 
117 | void	nwvp_thread_wakeup(
118 | 	ULONG	thread_id);
119 | 
120 | void	nwvp_thread_kill(
121 | 	ULONG	thread_id);
122 | 
123 | void	nwvp_thread_yield(void);
124 | 
125 | ULONG	nwvp_thread_create(
126 | 	BYTE		*name,
127 | 	ULONG		(*start_routine)(ULONG),
128 | 	ULONG		start_parameter);
129 | 
130 | ULONG    nwvp_memset(void *p, int c, long size);
131 | 
132 | ULONG    nwvp_memcpy(void *d, void *s, long size);
133 | 
134 | ULONG    nwvp_memcomp(void *d, void *s, long size);
135 | 
136 | ULONG    nwvp_memmove(void *d, void *s, long size);
137 | 
138 | ULONG	nwvp_init_partitions (void);
139 | 
140 | ULONG	nwvp_uninit_partitions (void);
141 | 
142 | ULONG	nwvp_create_file_partition (
143 | 	ULONG					sector_size_shift,
144 | 	ULONG					capacity);
145 | 
146 | ULONG	nwvp_delete_file_partition (
147 | 	ULONG					rpart_handle);
148 | 
149 | ULONG	partition_online (
150 | 	ULONG					part_handle);
151 | 
152 | ULONG	partition_offline (
153 | 	ULONG					part_handle);
154 | 
155 | //void    raw_offline_routine(
156 | //	vndi_console    		*console);
157 | 
158 | ULONG	nwvp_part_scan_all(
159 | 	vndi_payload			*req_payload);
160 | 	
161 | ULONG	inject_error (
162 | 	ULONG					rpart_handle,
163 | 	ULONG					error,
164 | 	ULONG					param);
165 | 
166 | ULONG	remove_error (
167 | 	ULONG					rpart_handle,
168 | 	ULONG					error,
169 | 	ULONG					param);
170 | 
171 | ULONG	nwvp_ascii_to_int(
172 | 	ULONG	*value,
173 | 	BYTE	*string);
174 | 
175 | ULONG	nwvp_int_to_ascii(
176 | 	ULONG	value,
177 | 	ULONG	base,
178 | 	BYTE	*string);
179 | 
180 | #endif
181 | 
182 | void NWLockNWVP(void);
183 | void NWUnlockNWVP(void);
184 | void NWLockHOTFIX(void);
185 | void NWUnlockHOTFIX(void);
186 | void NWLockREMIRROR(void);
187 | void NWUnlockREMIRROR(void);
188 | 


--------------------------------------------------------------------------------
/nwvpmain.c:
--------------------------------------------------------------------------------
 1 | /***************************************************************************
 2 | *
 3 | *   Copyright (c) 1997, 1998 Jeff V. Merkey  All Rights
 4 | *			    Reserved.
 5 | *
 6 | *   AUTHOR   :  
 7 | *   FILE     :  NWVPMAIN.C
 8 | *   DESCRIP  :  NWVPMAIN
 9 | *   DATE     :  November 3, 1998
10 | *
11 | *
12 | ***************************************************************************/
13 | 
14 | #include "globals.h"
15 | #if !MANOS
16 | #include "vconsole.h"
17 | #else
18 | #include "lru.h"
19 | #endif
20 | extern	ULONG	consoleHandle;
21 | 
22 | extern	ULONG	current_vdevice;
23 | 
24 | int	main(void)
25 | {
26 | 	nwvp_console	*console;
27 | 
28 | #if (LINUX_UTIL)
29 | 	sync();
30 | #endif
31 | //	mem_check_init();
32 | 	nwvp_alloc((void **) &console, sizeof(nwvp_console));
33 | 	nwvp_create_console(console, "\x4NWVP");
34 | 	nwvp_add_commands(console);
35 | #if MANOS
36 |     InitializeLRU();
37 | #endif
38 | 	nwvp_start_console(console);
39 | #if MANOS
40 |     FreeLRU();
41 | #endif
42 | 	nwvp_unscan_routine();
43 | 	nwvp_delete_console(console);
44 | 	nwvp_free(console);
45 | //	RemoveDiskDevices();
46 | //	FreePartitionResources();
47 | //    ClearScreen(consoleHandle);
48 | 
49 | //	mem_check_uninit();
50 | 	return(0);
51 | }
52 | 


--------------------------------------------------------------------------------
/rapidfat.c:
--------------------------------------------------------------------------------
 1 | 
 2 | /***************************************************************************
 3 | *
 4 | *   Copyright (c) 1997-2022 Jeff V. Merkey
 5 | *   7260 SE Tenino St.
 6 | *   Portland, Oregon 97206
 7 | *   jeffmerkey@gmail.com
 8 | *
 9 | *   This program is free software; you can redistribute it and/or modify it
10 | *   under the terms of the Lesser GNU Public License as published by the
11 | *   Free Software Foundation, version 2.1, or any later version.
12 | *
13 | *   This program is distributed in the hope that it will be useful, but
14 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
15 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 | *   General Public License for more details.
17 | *
18 | *   Original Authorship      :
19 | *      source code written by Jeff V. Merkey
20 | *
21 | *   Original Contributors    :
22 | *      Jeff V. Merkey
23 | *      
24 | *      
25 | *
26 | ****************************************************************************
27 | *
28 | *
29 | *   AUTHOR   :  Jeff V. Merkey (jeffmerkey@gmail.com)
30 | *   FILE     :  RAPIDFAT.C
31 | *   DESCRIP  :  Rapid FAT Module
32 | *   DATE     :  July 11, 2022
33 | *
34 | *
35 | ***************************************************************************/
36 | 
37 | #include "globals.h"
38 | 
39 | void NWLockFCB(FCB *fcb)
40 | {
41 | #if (LINUX)
42 |     if (WaitOnSemaphore(&fcb->Semaphore) == -EINTR)
43 |        NWFSPrint("lock fcb was interrupted\n");
44 | #endif
45 | }
46 | 
47 | void NWUnlockFCB(FCB *fcb)
48 | {
49 | #if (LINUX)
50 |     SignalSemaphore(&fcb->Semaphore);
51 | #endif
52 | }
53 | 
54 | 


--------------------------------------------------------------------------------
/sources:
--------------------------------------------------------------------------------
 1 | MAJORCOMP=ntos
 2 | MINORCOMP=nwfs
 3 | 
 4 | TARGETNAME=nwfs
 5 | TARGETPATH=$(BASEDIR)\lib
 6 | TARGETTYPE=LIBRARY
 7 | INCLUDES=$(BASEDIR)\SRC\FILESYS\INC
 8 | 
 9 | MSC_WARNING_LEVEL=/WX
10 | 
11 | SOURCES=nwvfs.c          \
12 | 	alloc.c          \
13 | 	disk.c           \
14 | 	nwpart.c         \
15 | 	volume.c         \
16 | 	globals.c        \
17 | 	lru.c            \
18 | 	lock.c           \
19 | 	hash.c           \
20 | 	fat.c            \
21 | 	bit.c            \
22 | 	block.c          \
23 | 	cluster.c        \
24 | 	dir.c            \
25 | 	mmap.c           \
26 | 	inode.c          \
27 | 	super.c          \
28 | 	file.c           \
29 | 	ioctl.c          \
30 | 	nwdir.c          \
31 | 	nwfile.c         \
32 | 	trustee.c        \
33 | 	nwext.c          \
34 | 	suballoc.c       \
35 | 	create.c         \
36 | 	date.c           \
37 | 	nwcreate.c       \
38 | 	symlink.c        \
39 | 	nwvp.c           \
40 | 	nwvphal.c        \
41 | 	console.c
42 | 


--------------------------------------------------------------------------------
/sources.nt5:
--------------------------------------------------------------------------------
 1 | MAJORCOMP=ntos
 2 | MINORCOMP=nwfs
 3 | 
 4 | TARGETNAME=nwfs
 5 | TARGETPATH=..
 6 | TARGETTYPE=LIBRARY
 7 | INCLUDES=..\inc;$(BASEDIR)\SRC\FILESYS\INC
 8 | 
 9 | MSC_WARNING_LEVEL=/WX
10 | 
11 | SOURCES=nwvfs.c          \
12 |         alloc.c          \
13 |         disk.c           \
14 |         nwpart.c         \
15 |         volume.c         \
16 |         globals.c        \
17 |         lru.c            \
18 |         lock.c           \
19 |         hash.c           \
20 |         fat.c            \
21 |         bit.c            \
22 |         block.c          \
23 |         cluster.c        \
24 |         dir.c            \
25 |         mmap.c           \
26 |         inode.c          \
27 |         super.c          \
28 |         file.c           \
29 |         ioctl.c          \
30 |         nwdir.c          \
31 |         nwfile.c         \
32 |         trustee.c        \
33 |         nwext.c          \
34 |         suballoc.c       \
35 |         create.c         \
36 |         date.c           \
37 |         nwcreate.c       \
38 |         symlink.c        \
39 |         nwvp.c           \
40 |         nwvphal.c        \
41 |         console.c
42 | 


--------------------------------------------------------------------------------
/trustee.c:
--------------------------------------------------------------------------------
 1 | 
 2 | /***************************************************************************
 3 | *
 4 | *   Copyright (c) 1997-2022 Jeff V. Merkey
 5 | *   7260 SE Tenino St.
 6 | *   Portland, Oregon 97206
 7 | *   jeffmerkey@gmail.com
 8 | *
 9 | *   This program is free software; you can redistribute it and/or modify it
10 | *   under the terms of the Lesser GNU Public License as published by the
11 | *   Free Software Foundation, version 2.1, or any later version.
12 | *
13 | *   This program is distributed in the hope that it will be useful, but
14 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
15 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 | *   General Public License for more details.
17 | *
18 | *   Original Authorship      :
19 | *      source code written by Jeff V. Merkey
20 | *
21 | *   Original Contributors    :
22 | *      Jeff V. Merkey
23 | *      
24 | *      
25 | *
26 | ****************************************************************************
27 | *
28 | *
29 | *   AUTHOR   :  Jeff V. Merkey (jeffmerkey@gmail.com)
30 | *   FILE     :  TRUSTEE.C
31 | *   DESCRIP  :  Trustee Hashing Functions
32 | *   DATE     :  November 1, 1998
33 | *
34 | *
35 | ***************************************************************************/
36 | 
37 | #include "globals.h"
38 | 
39 | THASH *GetTrusteeEntry(VOLUME *volume, ULONG entry, ULONG Directory)
40 | {
41 |     register THASH *tname;
42 |     register THASH_LIST *HashTable;
43 |     register ULONG Value, pos;
44 | 
45 |     Value = (Directory & (volume->TrusteeHashLimit - 1));
46 |     HashTable = (THASH_LIST *) volume->TrusteeHash;
47 |     if (!HashTable)
48 |        return 0;
49 | 
50 |     tname = (THASH *) HashTable[Value].head;
51 |     pos = 0;
52 |     while (tname)
53 |     {
54 |        if (tname->Parent == Directory)
55 |        {
56 | 	  if (entry == pos)
57 | 	     return tname;
58 | 	  pos++;
59 |        }
60 |        tname = tname->next;
61 |     }
62 |     return 0;
63 | 
64 | }
65 | 
66 | UHASH *GetUserQuotaEntry(VOLUME *volume, ULONG entry, ULONG Directory)
67 | {
68 |     register UHASH *uname;
69 |     register UHASH_LIST *HashTable;
70 |     register ULONG Value, pos;
71 | 
72 |     Value = (Directory & (volume->UserQuotaHashLimit - 1));
73 |     HashTable = (UHASH_LIST *) volume->UserQuotaHash;
74 |     if (!HashTable)
75 |        return 0;
76 | 
77 |     uname = (UHASH *) HashTable[Value].head;
78 |     pos = 0;
79 |     while (uname)
80 |     {
81 |        if (uname->Parent == Directory)
82 |        {
83 | 	  if (entry == pos)
84 | 	     return uname;
85 | 	  pos++;
86 |        }
87 |        uname = uname->next;
88 |     }
89 |     return 0;
90 | 
91 | }
92 | 


--------------------------------------------------------------------------------
/util.mak:
--------------------------------------------------------------------------------
  1 | 
  2 | CC = gcc
  3 | LINK = ld
  4 | CFLAGS = -Wall -Wstrict-prototypes -O2 -fno-strength-reduce -pipe -m386 \
  5 | 	-DCPU=386 -I/usr/src/linux -c -g 
  6 | 
  7 | CTERM  = -c -Wall -Wstrict-prototypes -fno-strength-reduce -pipe -DCPU=386 
  8 | 
  9 | LFLAGS = -m elf_i386 -Map nwfs.map -r -o
 10 | 
 11 | incdeps = nwfs.h nwstruct.h nwdir.h nwhash.h nwproc.h nwvfs.h nwerror.h \
 12 | 	  globals.h nwmenu.h
 13 | 
 14 | objects = nwvfs.o alloc.o disk.o nwpart.o volume.o globals.o lru.o  \
 15 | 	  lock.o async.o hash.o fat.o bit.o block.o cluster.o dir.o       \
 16 | 	  mmap.o inode.o super.o file.o ioctl.o nwdir.o nwfile.o nwfix.o  \
 17 | 	  trustee.o nwext.o suballoc.o create.o date.o                    \
 18 | 	  nwcreate.o symlink.o nwvp.o nwvphal.o fileutil.o     \
 19 | 	  console.o nwmenu.o nwtool.o
 20 | 
 21 | all: nwfs.o nwvol nwvp nwdisk nwview nwconfig \
 22 |      nwrepair nwimage nwbackup nwrestor 
 23 | 
 24 | nwconfig: $(objects) nwfs.o nwconfig.o filter.o
 25 | 	$(CC) nwconfig.o filter.o nwfs.o -o nwconfig -lncurses
 26 | 
 27 | nwimage: $(objects) nwfs.o nwimage.o filter.o
 28 | 	$(CC) nwimage.o filter.o nwfs.o -o nwimage -lncurses
 29 | 
 30 | nwbackup: $(objects) nwfs.o nwbackup.o nofilt.o
 31 | 	$(CC) nwbackup.o nofilt.o nwfs.o -o nwbackup -lncurses
 32 | 
 33 | nwrestor: $(objects) nwfs.o nwrestor.o nofilt.o
 34 | 	$(CC) nwrestor.o nofilt.o nwfs.o -o nwrestor -lncurses
 35 | 
 36 | nwrepair:  $(objects) nwfs.o nwrepair.o nofilt.o
 37 | 	$(CC) nwrepair.o nofilt.o nwfs.o -o nwrepair -lncurses
 38 | 
 39 | nwvol:  $(objects) nwfs.o nwvol.o nofilt.o
 40 | 	$(CC) nwvol.o nofilt.o nwfs.o -o nwvol -lncurses
 41 | 
 42 | nwdisk:  $(objects) nwfs.o nwdisk.o nofilt.o
 43 | 	$(CC) nwdisk.o nofilt.o nwfs.o -o nwdisk -lncurses
 44 | 
 45 | nwview:  $(objects) nwfs.o nwview.o nofilt.o
 46 | 	$(CC) nwview.o nofilt.o nwfs.o -o nwview -lncurses
 47 | 
 48 | nwvp: $(objects) nwvpmain.o vcommand.o vconsole.o nwfs.o nofilt.o
 49 | 	$(CC) nwvpmain.o vcommand.o vconsole.o nofilt.o nwfs.o -o nwvp -lncurses
 50 | 
 51 | nwfs.o: $(objects)
 52 | 	$(LINK) $(LFLAGS) nwfs.o $(objects)
 53 | 
 54 | nwconfig.o: nwconfig.c $(incdeps) nwhelp.h
 55 | 	$(CC) $(CFLAGS) nwconfig.c
 56 | 
 57 | nwimage.o: nwimage.c $(incdeps) nwconfig.c
 58 | 	$(CC) $(CFLAGS) nwimage.c
 59 | 
 60 | nwbackup.o : nwbackup.c $(incdeps)
 61 | 	$(CC) $(CFLAGS) nwbackup.c
 62 | 
 63 | nwrestor.o : nwrestor.c $(incdeps)
 64 | 	$(CC) $(CFLAGS) nwrestor.c
 65 | 
 66 | nwdisk.o : nwdisk.c $(incdeps)
 67 | 	$(CC) $(CFLAGS) nwdisk.c
 68 | 
 69 | nwrepair.o : nwrepair.c $(incdeps)
 70 | 	$(CC) $(CFLAGS) nwrepair.c
 71 | 
 72 | nwvol.o : nwvol.c $(incdeps)
 73 | 	$(CC) $(CFLAGS) nwvol.c
 74 | 
 75 | nwview.o : nwview.c $(incdeps)
 76 | 	$(CC) $(CFLAGS) nwview.c
 77 | 
 78 | nwvfs.o: nwvfs.c     $(incdeps)
 79 | 	$(CC) $(CFLAGS) nwvfs.c
 80 | vcommand.o: vcommand.c $(incdeps)
 81 | 	$(CC) $(CFLAGS) vcommand.c
 82 | vconsole.o: vconsole.c $(incdeps)
 83 | 	$(CC) $(CFLAGS) vconsole.c
 84 | nwvpmain.o: nwvpmain.c $(incdeps)
 85 | 	$(CC) $(CFLAGS) nwvpmain.c
 86 | nwformat.o: nwformat.c $(incdeps)
 87 | 	$(CC) $(CFLAGS) nwformat.c
 88 | nwvp.o: nwvp.c    $(incdeps)
 89 | 	$(CC) $(CFLAGS) nwvp.c
 90 | nwvphal.o: nwvphal.c $(incdeps)
 91 | 	$(CC) $(CFLAGS) nwvphal.c
 92 | alloc.o: alloc.c     $(incdeps)
 93 | 	$(CC) $(CFLAGS) alloc.c
 94 | disk.o: disk.c       $(incdeps)
 95 | 	$(CC) $(CFLAGS) disk.c
 96 | nwpart.o: nwpart.c   $(incdeps)
 97 | 	$(CC) $(CFLAGS) nwpart.c
 98 | volume.o: volume.c   $(incdeps)
 99 | 	$(CC) $(CFLAGS) volume.c
100 | fat.o: fat.c         $(incdeps)
101 | 	$(CC) $(CFLAGS) fat.c
102 | globals.o: globals.c $(incdeps)
103 | 	$(CC) $(CFLAGS) globals.c
104 | lock.o: lock.c       $(incdeps)
105 | 	$(CC) $(CFLAGS) lock.c
106 | hash.o: hash.c       $(incdeps)
107 | 	$(CC) $(CFLAGS) hash.c
108 | string.o: string.c   $(incdeps)
109 | 	$(CC) $(CFLAGS) string.c
110 | lru.o: lru.c         $(incdeps)
111 | 	$(CC) $(CFLAGS) lru.c
112 | bit.o: bit.c         $(incdeps)
113 | 	$(CC) $(CFLAGS) bit.c
114 | block.o: block.c     $(incdeps)
115 | 	$(CC) $(CFLAGS) block.c
116 | cluster.o: cluster.c $(incdeps)
117 | 	$(CC) $(CFLAGS) cluster.c
118 | dir.o: dir.c         $(incdeps)
119 | 	$(CC) $(CFLAGS) dir.c
120 | mmap.o: mmap.c       $(incdeps)
121 | 	$(CC) $(CFLAGS) mmap.c
122 | inode.o: inode.c     $(incdeps)
123 | 	$(CC) $(CFLAGS) inode.c
124 | super.o: super.c     $(incdeps)
125 | 	$(CC) $(CFLAGS) super.c
126 | file.o: file.c       $(incdeps)
127 | 	$(CC) $(CFLAGS) file.c
128 | ioctl.o: ioctl.c     $(incdeps)
129 | 	$(CC) $(CFLAGS) ioctl.c
130 | nwdir.o: nwdir.c     $(incdeps)
131 | 	$(CC) $(CFLAGS) nwdir.c
132 | nwfile.o: nwfile.c   $(incdeps)
133 | 	$(CC) $(CFLAGS) nwfile.c
134 | trustee.o: trustee.c   $(incdeps)
135 | 	$(CC) $(CFLAGS) trustee.c
136 | nwext.o: nwext.c   $(incdeps)
137 | 	$(CC) $(CFLAGS) nwext.c
138 | suballoc.o: suballoc.c   $(incdeps)
139 | 	$(CC) $(CFLAGS) suballoc.c
140 | create.o: create.c   $(incdeps)
141 | 	$(CC) $(CFLAGS) create.c
142 | date.o: date.c       $(incdeps)
143 | 	$(CC) $(CFLAGS) date.c
144 | nwcreate.o: nwcreate.c   $(incdeps)
145 | 	$(CC) $(CFLAGS) nwcreate.c
146 | symlink.o: symlink.c   $(incdeps)
147 | 	$(CC) $(CFLAGS) symlink.c
148 | fileutil.o: fileutil.c   $(incdeps)
149 | 	$(CC) $(CFLAGS) fileutil.c
150 | console.o: console.c   $(incdeps)
151 | 	$(CC) $(CFLAGS) console.c
152 | nwmenu.o: nwmenu.c   $(incdeps)
153 | 	$(CC) $(CFLAGS) nwmenu.c
154 | filter.o: filter.c   $(incdeps)
155 | 	$(CC) $(CFLAGS) filter.c
156 | async.o: async.c   $(incdeps)
157 | 	$(CC) $(CFLAGS) async.c
158 | nwtool.o: nwtool.c   $(incdeps)
159 | 	$(CC) $(CFLAGS) nwtool.c
160 | nwfix.o: nwfix.c   $(incdeps)
161 | 	$(CC) $(CFLAGS) nwfix.c
162 | 
163 | 
164 | clean:
165 | 	rm -f nwvol nwimage nwrestor nwvp nwview nwdisk \
166 | 	nwconfig nwbackup nwrepair *.o 
167 | 
168 | 


--------------------------------------------------------------------------------
/utilms.bat:
--------------------------------------------------------------------------------
1 | nmake /f utilms.mak
2 | 


--------------------------------------------------------------------------------
/utilms.mak:
--------------------------------------------------------------------------------
  1 | 
  2 | !include <win32.mak>
  3 | 
  4 | CC = $(cc)
  5 | LINK = $(link)
  6 | CFLAGS = $(cdebug) $(cflags) $(cvars) /Zp1
  7 | LFLAGS = $(linkdebug)
  8 | 
  9 | #CFLAGS = $(cflags) $(cvars) /Zp1
 10 | #LFLAGS =
 11 | 
 12 | incdeps = nwfs.h nwstruct.h nwdir.h nwhash.h nwproc.h nwvfs.h nwerror.h \
 13 | 	  globals.h nwmenu.h
 14 | 
 15 | objects = nwvfs.obj alloc.obj disk.obj nwpart.obj volume.obj globals.obj \
 16 | 	  lru.obj lock.obj hash.obj fat.obj bit.obj \
 17 | 	  block.obj cluster.obj dir.obj mmap.obj inode.obj super.obj file.obj \
 18 | 	  ioctl.obj nwdir.obj nwfile.obj trustee.obj nwext.obj suballoc.obj \
 19 | 	  create.obj date.obj nwcreate.obj symlink.obj nwvp.obj nwfix.obj \
 20 | 	  nwvphal.obj fileutil.obj console.obj nwmenu.obj async.obj \
 21 |           nwtool.obj
 22 | 
 23 | all: nwvol.exe nwdisk.exe nwvp.exe nwdump.exe \
 24 |      nwview.exe nwconfig.exe nwrepair.exe nwmount.exe \
 25 |      nwdismnt.exe nwfs.lib
 26 | 
 27 | nwfs.lib: $(objects)
 28 | 	lib $(objects) /out:nwfs.lib
 29 | 
 30 | nwmount.exe: nwmount.obj
 31 | 	$(LINK) $(linkdebug) nwmount.obj -out:nwmount.exe $(MAPFILE)
 32 | 
 33 | nwdismnt.exe: nwdismnt.obj
 34 | 	$(LINK) $(linkdebug) nwdismnt.obj -out:nwdismnt.exe $(MAPFILE)
 35 | 
 36 | nwconfig.exe: $(objects) nwconfig.obj filter.obj
 37 | 	$(LINK) $(linkdebug) nwconfig.obj filter.obj \
 38 | 	$(objects) user32.lib -out:nwconfig.exe $(MAPFILE)
 39 | 
 40 | nwrepair.exe:  $(objects) nwrepair.obj nofilt.obj
 41 | 	$(LINK) $(linkdebug) nwrepair.obj nofilt.obj \
 42 | 	$(objects) -out:nwrepair.exe $(MAPFILE)
 43 | 
 44 | nwvol.exe:  $(objects) nwvol.obj nofilt.obj
 45 | 	$(LINK) $(linkdebug) nwvol.obj nofilt.obj \
 46 | 	$(objects) -out:nwvol.exe $(MAPFILE)
 47 | 
 48 | nwdisk.exe:  $(objects) nwdisk.obj nofilt.obj
 49 | 	$(LINK) $(linkdebug) nwdisk.obj nofilt.obj \
 50 | 	$(objects) -out:nwdisk.exe $(MAPFILE)
 51 | 
 52 | nwvp.exe: $(objects) nwvpmain.obj vcommand.obj vconsole.obj nofilt.obj
 53 | 	$(LINK) $(linkdebug) nwvpmain.obj vcommand.obj vconsole.obj \
 54 | 	$(objects) nofilt.obj -out:nwvp.exe $(MAPFILE)
 55 | 
 56 | nwdump.exe:  $(objects) nwdump.obj nofilt.obj
 57 | 	$(LINK) $(linkdebug) nwdump.obj nofilt.obj \
 58 | 	$(objects) -out:nwdump.exe $(MAPFILE)
 59 | 
 60 | nwview.exe:  $(objects) nwview.obj nofilt.obj
 61 | 	$(LINK) $(linkdebug) nwview.obj nofilt.obj \
 62 | 	$(objects) -out:nwview.exe $(MAPFILE)
 63 | 
 64 | #
 65 | #  NWFS Utility Files
 66 | #
 67 | 
 68 | nwconfig.obj: nwconfig.c $(incdeps) nwhelp.h
 69 | 	$(CC) $(CFLAGS) nwconfig.c
 70 | 
 71 | nwdisk.obj: nwdisk.c $(incdeps)
 72 | 	$(CC) $(CFLAGS) nwdisk.c
 73 | 
 74 | nwrepair.obj: nwrepair.c $(incdeps)
 75 | 	$(CC) $(CFLAGS) nwrepair.c
 76 | 
 77 | nwvol.obj: nwvol.c $(incdeps)
 78 | 	$(CC) $(CFLAGS) nwvol.c
 79 | 
 80 | nwdump.obj: nwdump.c $(incdeps)
 81 | 	$(CC) $(CFLAGS) nwdump.c
 82 | 
 83 | nwview.obj: nwview.c $(incdeps)
 84 | 	$(CC) $(CFLAGS) nwview.c
 85 | 
 86 | vcommand.obj: vcommand.c $(incdeps)
 87 | 	$(CC) $(CFLAGS) vcommand.c
 88 | vconsole.obj: vconsole.c $(incdeps)
 89 | 	$(CC) $(CFLAGS) vconsole.c
 90 | nwvpmain.obj: nwvpmain.c $(incdeps)
 91 | 	$(CC) $(CFLAGS) nwvpmain.c
 92 | 
 93 | nwformat.obj: nwformat.c $(incdeps)
 94 | 	$(CC) $(CFLAGS) nwformat.c
 95 | nwvp.obj:	nwvp.c    $(incdeps)
 96 | 	$(CC) $(CFLAGS) nwvp.c
 97 | nwvphal.obj: nwvphal.c $(incdeps)
 98 | 	$(CC) $(CFLAGS) nwvphal.c
 99 | 
100 | #
101 | #  NWFS Library Files
102 | #
103 | 
104 | nwvfs.obj: nwvfs.c     $(incdeps)
105 | 	$(CC) $(CFLAGS) nwvfs.c
106 | alloc.obj: alloc.c     $(incdeps)
107 | 	$(CC) $(CFLAGS) alloc.c
108 | disk.obj: disk.c       $(incdeps)
109 | 	$(CC) $(CFLAGS) disk.c
110 | nwpart.obj: nwpart.c   $(incdeps)
111 | 	$(CC) $(CFLAGS) nwpart.c
112 | volume.obj: volume.c   $(incdeps)
113 | 	$(CC) $(CFLAGS) volume.c
114 | fat.obj: fat.c         $(incdeps)
115 | 	$(CC) $(CFLAGS) fat.c
116 | globals.obj: globals.c $(incdeps)
117 | 	$(CC) $(CFLAGS) globals.c
118 | lock.obj: lock.c       $(incdeps)
119 | 	$(CC) $(CFLAGS) lock.c
120 | hash.obj: hash.c       $(incdeps)
121 | 	$(CC) $(CFLAGS) hash.c
122 | string.obj: string.c   $(incdeps)
123 | 	$(CC) $(CFLAGS) string.c
124 | lru.obj: lru.c         $(incdeps)
125 | 	$(CC) $(CFLAGS) lru.c
126 | bit.obj: bit.c         $(incdeps)
127 | 	$(CC) $(CFLAGS) bit.c
128 | block.obj: block.c     $(incdeps)
129 | 	$(CC) $(CFLAGS) block.c
130 | cluster.obj: cluster.c $(incdeps)
131 | 	$(CC) $(CFLAGS) cluster.c
132 | dir.obj: dir.c         $(incdeps)
133 | 	$(CC) $(CFLAGS) dir.c
134 | mmap.obj: mmap.c       $(incdeps)
135 | 	$(CC) $(CFLAGS) mmap.c
136 | inode.obj: inode.c     $(incdeps)
137 | 	$(CC) $(CFLAGS) inode.c
138 | super.obj: super.c     $(incdeps)
139 | 	$(CC) $(CFLAGS) super.c
140 | file.obj: file.c       $(incdeps)
141 | 	$(CC) $(CFLAGS) file.c
142 | ioctl.obj: ioctl.c     $(incdeps)
143 | 	$(CC) $(CFLAGS) ioctl.c
144 | nwdir.obj: nwdir.c     $(incdeps)
145 | 	$(CC) $(CFLAGS) nwdir.c
146 | nwfile.obj: nwfile.c   $(incdeps)
147 | 	$(CC) $(CFLAGS) nwfile.c
148 | trustee.obj: trustee.c   $(incdeps)
149 | 	$(CC) $(CFLAGS) trustee.c
150 | nwext.obj: nwext.c   $(incdeps)
151 | 	$(CC) $(CFLAGS) nwext.c
152 | suballoc.obj: suballoc.c   $(incdeps)
153 | 	$(CC) $(CFLAGS) suballoc.c
154 | create.obj: create.c   $(incdeps)
155 | 	$(CC) $(CFLAGS) create.c
156 | date.obj: date.c       $(incdeps)
157 | 	$(CC) $(CFLAGS) date.c
158 | nwcreate.obj: nwcreate.c   $(incdeps)
159 | 	$(CC) $(CFLAGS) nwcreate.c
160 | symlink.obj: symlink.c   $(incdeps)
161 | 	$(CC) $(CFLAGS) symlink.c
162 | fileutil.obj: fileutil.c   $(incdeps)
163 | 	$(CC) $(CFLAGS) fileutil.c
164 | console.obj: console.c   $(incdeps)
165 | 	$(CC) $(CFLAGS) console.c
166 | nwmenu.obj: nwmenu.c   $(incdeps)
167 | 	$(CC) $(CFLAGS) nwmenu.c
168 | filter.obj: filter.c   $(incdeps)
169 | 	$(CC) $(CFLAGS) filter.c
170 | nofilt.obj: nofilt.c   $(incdeps)
171 | 	$(CC) $(CFLAGS) nofilt.c
172 | async.obj: async.c   $(incdeps)
173 | 	$(CC) $(CFLAGS) async.c
174 | nwtool.obj: nwtool.c   $(incdeps)
175 | 	$(CC) $(CFLAGS) nwtool.c
176 | nwfix.obj: nwfix.c   $(incdeps)
177 | 	$(CC) $(CFLAGS) nwfix.c
178 | nwmount.obj: nwmount.c   $(incdeps)
179 | 	$(CC) $(CFLAGS) nwmount.c
180 | nwdismnt.obj: nwdismnt.c   $(incdeps)
181 | 	$(CC) $(CFLAGS) nwdismnt.c
182 | 
183 | clean:
184 |     del *.obj
185 |     del *.exe
186 |     del *.ilk
187 |     del *.pdb
188 |     del *.opt
189 |     del *.lib
190 | 
191 | 


--------------------------------------------------------------------------------
/vconsole.h:
--------------------------------------------------------------------------------
 1 | /***************************************************************************
 2 | *
 3 | *   Copyright (c) 1997, 1998 Jeff V. Merkey  All Rights
 4 | *			    Reserved.
 5 | *
 6 | *
 7 | *   AUTHOR   :  
 8 | *   FILE     :  VNCONSOL.H
 9 | *   DESCRIP  :  console files
10 | *   DATE     :  November 3, 1998
11 | *
12 | *
13 | ***************************************************************************/
14 | 
15 | #ifndef _VCONSOLE_H_
16 | #define _VCONSOLE_H_
17 | 
18 | struct	nwvp_console_def;
19 | 
20 | typedef	struct	nwvp_console_command_def
21 | {
22 | 	struct	nwvp_console_command_def	*next_link;
23 | 	struct	nwvp_console_command_def	*last_link;
24 | 	BYTE			*command_name;
25 | 	void			(*routine)(struct nwvp_console_def *console);
26 | 	BYTE			*help_string;
27 | } nwvp_console_command;
28 | 
29 | typedef	struct	nwvp_console_def
30 | {
31 | 	int		screen_handle;
32 | 	ULONG	token_count;
33 | 	ULONG	quit_flag;
34 | 	struct	pmachine_def		*machine_link;
35 | //	struct	pmedia_def		*device_link;
36 | //	struct	vgroup_def		*group_link;
37 | //	struct	vdevice_def		*vdevice_link;
38 | 
39 | 	BYTE	*screen_name;
40 | 	BYTE	*prompt;
41 | 	struct	nwvp_console_command_def	*command_list_head;
42 | 
43 | 	BYTE	*token_table[20];
44 | 	BYTE	token_size_table[20];
45 | 	BYTE	token_delimitor_table[20];
46 | 	ULONG	token_value_table[20];
47 | 	BYTE	command_line[100];
48 | } nwvp_console;
49 | 
50 | int	nwvp_create_console(
51 | 	nwvp_console *console,
52 | 	char *name);
53 | 
54 | int	nwvp_delete_console(
55 | 	nwvp_console	*console);
56 | 
57 | int	nwvp_add_console_command(
58 | 	nwvp_console	*console,
59 | 	BYTE	*name,
60 | 	void	(*routine)(nwvp_console *),
61 | 	BYTE	*help_string);
62 | 
63 | int	nwvp_start_console(
64 | 	nwvp_console	*console);
65 | 
66 | void    nwvp_add_commands(
67 | 	nwvp_console            *console);
68 | 
69 | void    nwvp_init_command_strings(void);
70 | 
71 | 
72 | #endif
73 | 
74 | 


--------------------------------------------------------------------------------
/windows-src/cachesup.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /***************************************************************************
  3 | *
  4 | *   Copyright (c) 1999-2022 Jeffrey V. Merkey
  5 | *   7260 SE Tenino St.
  6 | *   Portland, Oregon 97206
  7 | *   jeffmerkey@gmail.com
  8 | *
  9 | *   This program is free software; you can redistribute it and/or modify it
 10 | *   under the terms of the Lesser GNU Public License 2.1 as
 11 | *   published by the Free Software Foundation.  (Windows NT/2000
 12 | *   is a registered trademark of Microsoft Corporation).
 13 | *
 14 | *   This program is distributed in the hope that it will be useful, but
 15 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
 16 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 17 | *
 18 | ****************************************************************************
 19 | 
 20 |   Module Name:
 21 | 
 22 |     Cache.c
 23 | 
 24 |   Abstract:
 25 | 
 26 |     This module implements the cache management routines for the Nwfs
 27 |     FSD and FSP, by calling the Common Cache Manager.
 28 | 
 29 |   Authors:
 30 | 
 31 |     Jeff Merkey (jeffmerkey@gmail.com)
 32 |     David Goebel (davidg@balder.com) 11-Mar-1999
 33 | 
 34 | ***************************************************************************/
 35 | 
 36 | #include "NwProcs.h"
 37 | 
 38 | //
 39 | //  The Bug check file id for this module
 40 | //
 41 | 
 42 | #define BugCheckFileId                   (NWFS_BUG_CHECK_CACHESUP)
 43 | 
 44 | //
 45 | //  Local debug trace level
 46 | //
 47 | 
 48 | #ifdef ALLOC_PRAGMA
 49 | #pragma alloc_text(PAGE, NwCompleteMdl)
 50 | #pragma alloc_text(PAGE, NwPurgeVolume)
 51 | #endif
 52 | 
 53 | 
 54 | NTSTATUS
 55 | NwCompleteMdl (
 56 |     IN PIRP_CONTEXT IrpContext,
 57 |     IN PIRP Irp
 58 |     )
 59 | 
 60 | /*++
 61 | 
 62 | Routine Description:
 63 | 
 64 |     This routine performs the function of completing Mdl reads.
 65 |     It should be called only from NwFsdRead.
 66 | 
 67 | Arguments:
 68 | 
 69 |     Irp - Supplies the originating Irp.
 70 | 
 71 | Return Value:
 72 | 
 73 |     NTSTATUS - Will always be STATUS_SUCCESS.
 74 | 
 75 | --*/
 76 | 
 77 | {
 78 |     PFILE_OBJECT FileObject;
 79 | 
 80 |     PAGED_CODE();
 81 | 
 82 |     //
 83 |     // Do completion processing.
 84 |     //
 85 | 
 86 |     FileObject = IoGetCurrentIrpStackLocation( Irp )->FileObject;
 87 | 
 88 |     CcMdlReadComplete( FileObject, Irp->MdlAddress );
 89 | 
 90 |     //
 91 |     // Mdl is now deallocated.
 92 |     //
 93 | 
 94 |     Irp->MdlAddress = NULL;
 95 | 
 96 |     //
 97 |     // Complete the request and exit right away.
 98 |     //
 99 | 
100 |     NwCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
101 | 
102 |     return STATUS_SUCCESS;
103 | }
104 | 
105 | 
106 | NTSTATUS
107 | NwPurgeVolume (
108 |     IN PIRP_CONTEXT IrpContext,
109 |     IN PVCB Vcb
110 |     )
111 | 
112 | /*++
113 | 
114 | Routine Description:
115 | 
116 |     This routine is called to purge the volume.  The purpose is to make all the
117 |     stale file objects in the system go away in order to lock the volume.
118 | 
119 |     The Vcb is already acquired exclusively.  We will lock out all file
120 |     operations by acquiring the global file resource.  Then we will walk
121 |     through all of the Fcb's and perform the purge.
122 | 
123 | Arguments:
124 | 
125 |     Vcb - Vcb for the volume to purge.
126 | 
127 | Return Value:
128 | 
129 |     NTSTATUS - The first failure of the purge operation.
130 | 
131 | --*/
132 | 
133 | {
134 |     NTSTATUS Status = STATUS_SUCCESS;
135 | 
136 |     PFCB PrevFcb = NULL;
137 |     PFCB ThisFcb;
138 | 
139 |     PLIST_ENTRY Entry;
140 | 
141 |     LIST_ENTRY FcbsToDeleteList;
142 | 
143 |     PAGED_CODE();
144 | 
145 |     InitializeListHead( &FcbsToDeleteList );
146 | 
147 |     //
148 |     //  Lock to lookup the next Fcb.
149 |     //
150 | 
151 |     NwLock();
152 | 
153 |     //
154 |     //  Run through all the Fcbs on the volume.
155 |     //
156 | 
157 |     ThisFcb = CONTAINING_RECORD(Vcb->FcbList.Flink, FCB, FcbLinks);
158 | 
159 |     Entry = Vcb->FcbList.Flink;
160 | 
161 |     while (Entry != &Vcb->FcbList) {
162 | 
163 |         ThisFcb = CONTAINING_RECORD(Entry, FCB, FcbLinks);
164 | 
165 |         if (FlagOn(ThisFcb->FcbState, FCB_STATE_CLOSE_DELAYED)) {
166 | 
167 |             ASSERT( ThisFcb->FileObjectCount == 0 );
168 | 
169 |             //
170 |             //  We need to delete this Fcb, first take it out of view before
171 |             //  dropping the lock.
172 |             //
173 | 
174 |             Entry = Entry->Flink;
175 | 
176 |             NwUnlinkFcb( ThisFcb );
177 |             InsertTailList( &FcbsToDeleteList, &ThisFcb->FcbLinks );
178 | 
179 |             continue;
180 |         }
181 | 
182 |         ASSERT( ThisFcb->FileObjectCount != 0 );
183 | 
184 |         //
185 |         //  Bias this Fcb's FileObject count so that we know it won't be the
186 |         //  victim of a recursive close.
187 |         //
188 | 
189 |         NwIncrementObjectCounts(IrpContext, ThisFcb);
190 | 
191 |         //
192 |         //  Now release the Vcb lock.  We know ThisFcb cannot go away.
193 |         //
194 | 
195 |         NwUnlock();
196 | 
197 |         //
198 |         //  If there is a image section then see if that can be closed.
199 |         //
200 | 
201 |         if (ThisFcb->FcbNonpaged->SegmentObject.ImageSectionObject != NULL) {
202 | 
203 |             MmFlushImageSection( &ThisFcb->FcbNonpaged->SegmentObject, MmFlushForWrite );
204 |         }
205 | 
206 |         //
207 |         //  If there is a data section then purge this.  If there is an image
208 |         //  or user mapped section then we won't be able to.  Remember this
209 |         //  if it is our first error.
210 |         //
211 | 
212 |         if ((ThisFcb->FcbNonpaged->SegmentObject.DataSectionObject != NULL) &&
213 |             !CcPurgeCacheSection( &ThisFcb->FcbNonpaged->SegmentObject,
214 |                                    NULL,
215 |                                    0,
216 |                                    FALSE ) &&
217 |             (Status == STATUS_SUCCESS)) {
218 | 
219 |             Status = STATUS_UNABLE_TO_DELETE_SECTION;
220 |         }
221 | 
222 |         //
223 |         //  Now grab the Vcb lock again to get the next Fcb and to check
224 |         //  if we got a close.
225 |         //
226 | 
227 |         PrevFcb = ThisFcb;
228 | 
229 |         NwLock();
230 | 
231 |         Entry = Entry->Flink;
232 | 
233 |         //
234 |         //  Now unbias the FileObject count.
235 |         //
236 | 
237 |         NwDecrementObjectCounts( PrevFcb );
238 | 
239 |         if (PrevFcb->FileObjectCount == 0) {
240 | 
241 |             //
242 |             //  We need to delete this Fcb, first take it out of view before
243 |             //  dropping the lock.
244 |             //
245 | 
246 |             NwUnlinkFcb( PrevFcb );
247 |             InsertTailList( &FcbsToDeleteList, &PrevFcb->FcbLinks );
248 |         }
249 |     }
250 | 
251 |     NwUnlock();
252 | 
253 | 
254 |     //
255 |     //  Now walk through all the FCBs that we found to delete and do the deed.
256 |     //
257 | 
258 |     Entry = FcbsToDeleteList.Flink;
259 | 
260 |     while (Entry != &FcbsToDeleteList) {
261 | 
262 |         ThisFcb = CONTAINING_RECORD(Entry, FCB, FcbLinks);
263 | 
264 |         ASSERT( ThisFcb->FileObjectCount == 0 );
265 | 
266 |         Entry = Entry->Flink;
267 | 
268 |         NwDeleteFcb( ThisFcb );
269 |     }
270 | 
271 |     return Status;
272 | }
273 | 
274 | 


--------------------------------------------------------------------------------
/windows-src/cleanup.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /***************************************************************************
  3 | *
  4 | *   Copyright (c) 1999-2022 Jeffrey V. Merkey
  5 | *   7260 SE Tenino St.
  6 | *   Portland, Oregon 97206
  7 | *   jeffmerkey@gmail.com
  8 | *
  9 | *   This program is free software; you can redistribute it and/or modify it
 10 | *   under the terms of the Lesser GNU Public License 2.1 as
 11 | *   published by the Free Software Foundation.  (Windows NT/2000
 12 | *   is a registered trademark of Microsoft Corporation).
 13 | *
 14 | *   This program is distributed in the hope that it will be useful, but
 15 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
 16 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 17 | *
 18 | ****************************************************************************
 19 | 
 20 | Module Name:
 21 | 
 22 |     Cleanup.c
 23 | 
 24 | Abstract:
 25 | 
 26 |     This module implements the File Cleanup routine for Nwfs called by the
 27 |     dispatch driver.
 28 | 
 29 |   Authors:
 30 | 
 31 |     Jeff Merkey (jeffmerkey@gmail.com)
 32 |     David Goebel (davidg@balder.com) 11-Mar-1999
 33 | 
 34 | ****************************************************************************/
 35 | 
 36 | #include "NwProcs.h"
 37 | 
 38 | //
 39 | //  The Bug check file id for this module
 40 | //
 41 | 
 42 | #define BugCheckFileId                   (NWFS_BUG_CHECK_CLEANUP)
 43 | 
 44 | #ifdef ALLOC_PRAGMA
 45 | #pragma alloc_text(PAGE, NwCommonCleanup)
 46 | #endif
 47 | 
 48 | 
 49 | NTSTATUS
 50 | NwCommonCleanup (
 51 |     IN PIRP_CONTEXT IrpContext,
 52 |     IN PIRP Irp
 53 |     )
 54 | 
 55 | /*++
 56 | 
 57 | Routine Description:
 58 | 
 59 |     This is the common routine for cleanup of a file/directory called by both
 60 |     the fsd and fsp threads.
 61 | 
 62 |     Cleanup is invoked whenever the last handle to a file object is closed.
 63 |     This is different than the Close operation which is invoked when the last
 64 |     reference to a file object is deleted.
 65 | 
 66 |     The function of cleanup is to essentially "cleanup" the file/directory
 67 |     after a user is done with it.  The Fcb/Dcb remains around (because MM
 68 |     still has the file object referenced) but is now available for another
 69 |     user to open (i.e., as far as the user is concerned it is now closed).
 70 | 
 71 |     See close for a more complete description of what close does.
 72 | 
 73 | Arguments:
 74 | 
 75 |     Irp - Supplies the Irp to process
 76 | 
 77 | Return Value:
 78 | 
 79 |     NTSTATUS - The return status for the operation.
 80 | 
 81 | --*/
 82 | 
 83 | {
 84 |     PFILE_OBJECT FileObject;
 85 |     TYPE_OF_OPEN TypeOfOpen;
 86 | 
 87 |     PVCB Vcb;
 88 |     PFCB Fcb;
 89 |     PCCB Ccb;
 90 | 
 91 |     BOOLEAN NoCacheMap = TRUE;
 92 | 
 93 |     PAGED_CODE();
 94 | 
 95 |     ASSERT_IRP_CONTEXT( IrpContext );
 96 |     ASSERT_IRP( Irp );
 97 | 
 98 |     //
 99 |     //  If we were called with our file system device object instead of a
100 |     //  volume device object, just complete this request with STATUS_SUCCESS.
101 |     //
102 | 
103 |     if (IrpContext->Vcb == NULL) {
104 | 
105 |         NwCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
106 |         return STATUS_SUCCESS;
107 |     }
108 | 
109 |     //
110 |     //  Get the file object out of the Irp and decode the type of open.
111 |     //
112 | 
113 |     FileObject = IoGetCurrentIrpStackLocation( Irp )->FileObject;
114 | 
115 |     TypeOfOpen = NwDecodeFileObject( IrpContext,
116 |                                      FileObject,
117 |                                      &Fcb,
118 |                                      &Ccb );
119 | 
120 |     //
121 |     //  No work here for an UnopenedFile.
122 |     //
123 | 
124 |     if (TypeOfOpen == UnopenedFileObject) {
125 | 
126 |         NwCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
127 | 
128 |         return STATUS_SUCCESS;
129 |     }
130 | 
131 |     //
132 |     //  Keep a local pointer to the Vcb.
133 |     //
134 | 
135 |     Vcb = Fcb->Vcb;
136 | 
137 |     //
138 |     //  Acquire the current file.
139 |     //
140 | 
141 |     NwAcquireFcbExclusive( IrpContext, Fcb, FALSE );
142 | 
143 |     //
144 |     //  Use a try-finally to facilitate cleanup.
145 |     //
146 | 
147 |     try {
148 | 
149 |         //
150 |         //  Set the flag in the FileObject to indicate that cleanup is complete.
151 |         //
152 | 
153 |         SetFlag( FileObject->Flags, FO_CLEANUP_COMPLETE );
154 | 
155 |         //
156 |         //  Case on the type of open that we are trying to cleanup.
157 |         //
158 | 
159 |         switch (TypeOfOpen) {
160 | 
161 |         case UserDirectoryOpen:
162 | 
163 |             //
164 |             //  Check if we need to complete any dir notify Irps on this file object.
165 |             //
166 | 
167 |             FsRtlNotifyCleanup( Vcb->NotifySync,
168 |                                 &Vcb->DirNotifyList,
169 |                                 Ccb );
170 | 
171 |             break;
172 | 
173 |         case UserFileOpen:
174 | 
175 |             //
176 |             //  Coordinate the cleanup operation with the oplock state.
177 |             //  Oplock cleanup operations can always cleanup immediately so no
178 |             //  need to check for STATUS_PENDING.
179 |             //
180 | 
181 |             FsRtlCheckOplock( &Fcb->Oplock,
182 |                               Irp,
183 |                               IrpContext,
184 |                               NULL,
185 |                               NULL );
186 | 
187 |             //
188 |             //  Unlock all outstanding file locks.
189 |             //
190 | 
191 |             if (Fcb->FileLock != NULL) {
192 | 
193 |                 FsRtlFastUnlockAll( Fcb->FileLock,
194 |                                     FileObject,
195 |                                     IoGetRequestorProcess( Irp ),
196 |                                     NULL );
197 |             }
198 | 
199 |             //
200 |             //  Cleanup the cache map.
201 |             //
202 | 
203 |             NoCacheMap = (BOOLEAN)(Fcb->FcbNonpaged->SegmentObject.SharedCacheMap == NULL);
204 |             CcUninitializeCacheMap( FileObject, NULL, NULL );
205 | 
206 |             //
207 |             //  Check the fast io state.
208 |             //
209 | 
210 |             Fcb->IsFastIoPossible = NwIsFastIoPossible( Fcb );
211 | 
212 |             break;
213 | 
214 |         case UserVolumeOpen :
215 | 
216 |             break;
217 | 
218 |         default :
219 | 
220 |             NwBugCheck( TypeOfOpen, 0, 0 );
221 |         }
222 | 
223 |         //
224 |         //  We must clean up the share access at this time, since we may not
225 |         //  get a Close call for awhile if the file was mapped through this
226 |         //  File Object.
227 |         //
228 | 
229 |         IoRemoveShareAccess( FileObject, &Fcb->ShareAccess );
230 | 
231 |         //
232 |         //  If this file object has locked the volume then perform the unlock operation.
233 |         //
234 | 
235 |         if (FileObject == Vcb->VolumeLockFileObject) {
236 | 
237 |             ClearFlag( Vcb->VcbState, VCB_STATE_LOCKED );
238 |             ClearFlag( Vcb->Vpb->Flags, VPB_LOCKED );
239 |             Vcb->VolumeLockFileObject = NULL;
240 |         }
241 | 
242 |         //
243 |         //  Now acquire our global lock in order to modify the fields in the
244 |         //  in-memory structures.
245 |         //
246 | 
247 |         NwLock();
248 | 
249 |         //
250 |         //  Decrement the cleanup counts in the Vcb and Fcb.
251 |         //
252 | 
253 |         NwDecrementHandleCounts( IrpContext, Fcb );
254 | 
255 |         //
256 |         //  Decide here if we are to delay the close.
257 |         //
258 | 
259 |         if ((Fcb->FileHandleCount == 0) &&
260 |             (NoCacheMap) &&
261 |             (TypeOfOpen != UserVolumeOpen)) {
262 | 
263 |             SetFlag( Fcb->FcbState, FCB_STATE_DELAY_CLOSE );
264 |         }
265 | 
266 |         NwUnlock();
267 | 
268 |     } finally {
269 | 
270 |         NwReleaseFcb( IrpContext, Fcb );
271 |     }
272 | 
273 |     //
274 |     //  Since this is a normal termination then complete the request.
275 |     //
276 | 
277 |     NwCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
278 | 
279 |     return STATUS_SUCCESS;
280 | }
281 | 
282 | 


--------------------------------------------------------------------------------
/windows-src/fenris.h:
--------------------------------------------------------------------------------
  1 | /*++
  2 | 
  3 | Copyright (c) 1999-2022  Jeffrey V. Merkey
  4 | 
  5 | Module Name:
  6 | 
  7 |     StrucSup.c
  8 | 
  9 | Abstract:
 10 | 
 11 |     This module is just a hack include of Jeff's include files.
 12 | 
 13 | Author:
 14 | 
 15 |     David Goebel (davidg@balder.com) 11-Mar-1999
 16 | 
 17 | --*/
 18 | 
 19 | typedef UCHAR BYTE;
 20 | typedef USHORT WORD;
 21 | 
 22 | #undef _NWFS_  // this is needed to avoid some double defines
 23 | 
 24 | #include "..\nwfs\globals.h"
 25 | 
 26 | typedef HASH *PHASH;
 27 | 
 28 | extern PDISK_ARRAY PartitionArray;
 29 | 
 30 | extern
 31 | HASH *HashFindFile(IN ULONG VolumeNumber,
 32 |                    IN ULONG Parent,
 33 |                    IN POEM_STRING Name,
 34 |                    IN BOOLEAN IgnoreCase);
 35 | 
 36 | 
 37 | extern
 38 | HASH *HashFindNext(IN     ULONG VolumeNumber,
 39 |                    IN OUT ULONG *SlotNumber,
 40 |                    IN     ULONG Parent,
 41 |                    IN OUT PVOID *Context,
 42 |                    IN     BOOLEAN Current);
 43 | 
 44 | extern
 45 | NTSTATUS
 46 | NwMountAll (
 47 |     IN PDISK_ARRAY
 48 |     );
 49 | 
 50 | // this is the david goebel routine that calls from the NWFSRO code to
 51 | // mount all netware volumes on a system.
 52 | 
 53 | extern
 54 | ULONG NWFSConvertFromNetwareTime(IN ULONG DateAndTime,
 55 |                                  IN PTIME_FIELDS tf);
 56 | 
 57 | // this routine is specifically for Windows NT, and converts Netware
 58 | // date and time into something digestible by the Windows NT R/O
 59 | // driver.
 60 | 
 61 | extern
 62 | ULONG
 63 | DismountVolume(IN BYTE *VolumeName);
 64 | 
 65 | // this function will dismount a volume by name.  The name must be
 66 | // already uppercase, and no more than 15 characters in length.  This
 67 | // function is non-NT specific.
 68 | 
 69 | extern
 70 | VOID
 71 | AddDiskDevices(IN PDISK_ARRAY DiskArray);
 72 | 
 73 | //
 74 | // This is an NT specific entry point for passing a disk array
 75 | // table of pointers into the driver.  It exists because the
 76 | // ScanDiskDevices() has a standard interface semantic across
 77 | // multiple platforms, and we want to maintain this clean
 78 | // abstraction.  Since the NT R/O driver has special requirements,
 79 | // this function is used to map the NWFSRO driver to a semantic
 80 | // more natural to our ScanDiskDevices() interface.
 81 | //
 82 | 
 83 | extern
 84 | VOID
 85 | RemoveDiskDevices(VOID);
 86 | 
 87 | // this routine frees any geometry or disk related memory.  We have
 88 | // this lowest layer cleanup in the event there are dependencies
 89 | // on partition level memory objects needing to be free first.
 90 | // In the NT version of the driver, this distinction is not really
 91 | // needed, however, in the Linux version, it is needed since there
 92 | // can be sync objects blocked at the partition level that require
 93 | // all resources to be released clean prior to shutting dow the disk
 94 | // devices.  This is how we prevent someone from unloading a driver
 95 | // in Linux while folks at the VFS layer may hold resources.
 96 | 
 97 | extern
 98 | VOID
 99 | FreePartitionResources(VOID);
100 | 
101 | // this routine frees any geometry or disk related memory.  We have
102 | // this lowest layer cleanup in the event there are dependencies
103 | // on partition level memory objects needing to be free first.
104 | // In the NT version of the driver, this distinction is not really
105 | // needed, however, in the Linux version, it is needed since there
106 | // can be sync objects blocked at the partition level that require
107 | // all resources to be released clean prior to shutting dow the disk
108 | // devices.  This is how we prevent someone from unloading a driver
109 | // in Linux while folks at the VFS layer may hold resources.
110 | 
111 | extern
112 | ULONG MountVolume(BYTE *VolumeName);
113 | 
114 | // this routine mounts a specific volume by text name.
115 | // This routine is non-NT specific.  (NOTE:  the name must be
116 | // uppercase ENGLISH text and not more than 15 characters in
117 | // length.
118 | 
119 | extern
120 | ULONG DismountVolume(BYTE *VolumeName);
121 | 
122 | // this routine mounts a specific volume.  it takes the address of
123 | // the VolumeTable[i]->xxx pointer (non-NT specific).
124 | 
125 | extern
126 | ULONG MountAllVolumes();
127 | 
128 | // this routine mounts all volumes on a server and is called from the
129 | // NWFS library (non-NT specific)
130 | 
131 | extern
132 | NW_STATUS
133 | TrgGetPartitionInfoFromVolumeInfo (
134 |     IN ULONG VolumeNumber,
135 |     IN ULONG SectorOffsetInVolume,
136 |     IN ULONG DesiredSectorCount,
137 |     OUT void **PartitionPointer,
138 |     OUT ULONG *SectorOffsetInPartition,
139 |     OUT ULONG *SectorsAvailable
140 |     );
141 | 
142 | /*++
143 | 
144 | Routine Description:
145 | 
146 |     This routine maps volume information to partitions.  In the case of
147 |     mirrors, the most current mirror is used.
148 | 
149 | Arguments:
150 | 
151 |     VolumeNumber - The slot number in the volume table that contains the file.
152 | 
153 |     SectorOffsetInVolume - The starting sector offset into the volume for which
154 |         we want mapping information to a partition.
155 | 
156 |     DesiredSectorCount - The number of sectors for which information is desired.
157 | 
158 |     PartitionPointer - Receives the device object object pointer (supplied
159 |         during mount) of the partition that contains the supplied starting
160 |         sector in the volume.
161 | 
162 |     SectorOffsetInPartition - Receives the starting sector offset into the
163 |         partition corresponding to the starting sector offste in the volume.
164 | 
165 |     SectorsAvailable - Receives the number of sectors left in the segment
166 |         decribed by SectorOffsetInPartition, up to DesiredSectorCount.  This
167 |         will generally be DesiredSectorCount unless the request spans a
168 |         segment boundry or a hotfix region.
169 | 
170 | Return Value:
171 | 
172 |     NW_STATUS - NwSuccess if we processed the request without error.
173 |         NwFileCorrupt if the mapping information is malformed, or other
174 |         error as appropriate.
175 | 
176 | --*/
177 | 
178 | extern
179 | NW_STATUS TrgLookupFileAllocation(IN   ULONG VolumeNumber,
180 |                                   IN   HASH *hash,
181 |                                   IN   ULONG *StartingSector,
182 |                                   IN   ULONG *Context,
183 |                                   OUT  ULONG *SectorOffsetInVolume,
184 |                                   OUT  ULONG *SectorCount);
185 | /*++
186 | 
187 | Routine Description:
188 | 
189 |     This routine obtains the file mapping information for a file, that is,
190 |     where a file lives on the disk.  It is intended to be called in an
191 |     itterative fasion, thus uses Context to keep track of where it is.
192 | 
193 |     Each time this routine is called, it should return a 'run' of the file.
194 |     A run means a contiguous set of physical sectors containing the file.
195 |     By enumerating this function, the entire mapping for the file can be built.
196 | 
197 | Arguments:
198 | 
199 |     VolumeNumber - The slot number in the volume table that contains the file.
200 | 
201 |     Hash - Points to a file hash value.  Only the DOS hash and MAC hash are
202 |         valid input parameters, though a value of NULL means tha we want the
203 |         mapping information for the volume itself (i.e. for a DASD read).
204 | 
205 |     StartingSector - On input, contains the desired starting virtual offset
206 |         in the file for which we need mapping information.  On NwSuccess
207 |         return, receives the actual starting virtual offset of the returned run.
208 | 
209 |     Context - This parameter is treated as opaque by the caller and is used by
210 |         the routine to keep track of where it is in the file.
211 | 
212 |     SectorOffsetInVolume - On NwSuccess return, receives the offset into
213 |         the volume of the start of the run.
214 | 
215 |     SectorCount - On NwSuccess return, receives the number of contiguous
216 |         sectors in the run.
217 | 
218 | Return Value:
219 | 
220 |     NW_STATUS - NwSuccess if we processed the request without error.
221 |         NwFileCorrupt if the mapping information is malformed, or other
222 |         error as appropriate.
223 | 
224 | --*/
225 | 
226 | extern
227 | VOID
228 | NwReportDiskIoError(
229 |     IN void *FailedPartitionPointer,
230 |     IN BOOLEAN TotalDeviceFailure
231 |     );
232 | 
233 | /*++
234 | 
235 | Routine Description:
236 | 
237 |     This routine reports that we failed an I/O on a partition.  It allows us
238 |     to read from an alternate mirror.
239 | 
240 | Arguments:
241 | 
242 |     FailedPartitionPointer - The partition device object that failed.
243 | 
244 |     TotalDeviceFailure - If true, then the entire device appears to have
245 |         failed. If false, then individual sectors appear to have failed.
246 | 
247 | Return Value:
248 | 
249 |     None.
250 | 
251 | --*/
252 | 
253 | 


--------------------------------------------------------------------------------
/windows-src/filobsup.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /***************************************************************************
  3 | *
  4 | *   Copyright (c) 1999-2022 Jeffrey V. Merkey
  5 | *   7260 SE Tenino St.
  6 | *   Portland, Oregon 97206
  7 | *   jeffmerkey@gmail.com
  8 | *
  9 | *   This program is free software; you can redistribute it and/or modify it
 10 | *   under the terms of the Lesser GNU Public License 2.1 as
 11 | *   published by the Free Software Foundation.  (Windows NT/2000
 12 | *   is a registered trademark of Microsoft Corporation).
 13 | *
 14 | *   This program is distributed in the hope that it will be useful, but
 15 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
 16 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 17 | *
 18 | ****************************************************************************
 19 | 
 20 | Module Name:
 21 | 
 22 |     FilObSup.c
 23 | 
 24 | Abstract:
 25 | 
 26 |     This module implements the Nwfs File object support routines.
 27 | 
 28 |   Authors:
 29 | 
 30 |     Jeff Merkey (jeffmerkey@gmail.com)
 31 |     David Goebel (davidg@balder.com) 11-Mar-1999
 32 | 
 33 | ****************************************************************************/
 34 | 
 35 | #include "NwProcs.h"
 36 | 
 37 | //
 38 | //  The Bug check file id for this module
 39 | //
 40 | 
 41 | #define BugCheckFileId                   (NWFS_BUG_CHECK_FILOBSUP)
 42 | 
 43 | //
 44 | //  Local constants.
 45 | //
 46 | 
 47 | #define TYPE_OF_OPEN_MASK               (0x00000007)
 48 | 
 49 | #ifdef ALLOC_PRAGMA
 50 | #pragma alloc_text(PAGE, NwDecodeFileObject)
 51 | #pragma alloc_text(PAGE, NwFastDecodeFileObject)
 52 | #pragma alloc_text(PAGE, NwSetFileObject)
 53 | #endif
 54 | 
 55 | 
 56 | VOID
 57 | NwSetFileObject (
 58 |     IN PIRP_CONTEXT IrpContext,
 59 |     IN PFILE_OBJECT FileObject,
 60 |     IN TYPE_OF_OPEN TypeOfOpen,
 61 |     IN PFCB Fcb OPTIONAL,
 62 |     IN PCCB Ccb OPTIONAL
 63 |     )
 64 | 
 65 | /*++
 66 | 
 67 | Routine Description:
 68 | 
 69 |     This routine will initialize the FileObject context fields based on the
 70 |     input type and data structures.
 71 | 
 72 | Arguments:
 73 | 
 74 |     FileObject - Supplies the file object pointer being initialized.
 75 | 
 76 |     TypeOfOpen - Sets the type of open.
 77 | 
 78 |     Fcb - Fcb for this file object.  Ignored for UnopenedFileObject.
 79 | 
 80 |     Ccb - Ccb for the handle corresponding to this file object.  Will not
 81 |         be present for stream file objects.
 82 | 
 83 | Return Value:
 84 | 
 85 |     None.
 86 | 
 87 | --*/
 88 | 
 89 | {
 90 |     PAGED_CODE();
 91 | 
 92 |     //
 93 |     //  We only have values 0 to 7 available so make sure we didn't
 94 |     //  inadvertantly add a new type.
 95 |     //
 96 | 
 97 |     ASSERTMSG( "FileObject types exceed available bits\n", BeyondValidType <= 8 );
 98 | 
 99 |     //
100 |     //  Setting a file object to type UnopenedFileObject means just
101 |     //  clearing all of the context fields.  All the other input
102 |     //
103 | 
104 |     if (TypeOfOpen == UnopenedFileObject) {
105 | 
106 |         FileObject->FsContext =
107 |         FileObject->FsContext2 = NULL;
108 | 
109 |         return;
110 |     }
111 | 
112 |     //
113 |     //  Check that the 3 low-order bits of the Ccb are clear.
114 |     //
115 | 
116 |     ASSERTMSG( "Ccb is not quad-aligned\n", !FlagOn( ((ULONG_PTR) Ccb), TYPE_OF_OPEN_MASK ));
117 | 
118 |     //
119 |     //  We will or the type of open into the low order bits of FsContext2
120 |     //  along with the Ccb value.
121 |     //  The Fcb is stored into the FsContext field.
122 |     //
123 | 
124 |     FileObject->FsContext = Fcb;
125 |     FileObject->FsContext2 = Ccb;
126 | 
127 |     SetFlag( ((ULONG_PTR) FileObject->FsContext2), TypeOfOpen );
128 | 
129 |     //
130 |     //  Set the Vpb field in the file object.
131 |     //
132 | 
133 |     FileObject->Vpb = Fcb->Vcb->Vpb;
134 | 
135 |     //
136 |     //  Point to the section object pointer in the non-paged Fcb.
137 |     //
138 | 
139 |     FileObject->SectionObjectPointer = &Fcb->FcbNonpaged->SegmentObject;
140 | 
141 |     return;
142 | }
143 | 
144 | 
145 | 
146 | TYPE_OF_OPEN
147 | NwDecodeFileObject (
148 |     IN PIRP_CONTEXT IrpContext,
149 |     IN PFILE_OBJECT FileObject,
150 |     OUT PFCB *Fcb,
151 |     OUT PCCB *Ccb
152 |     )
153 | 
154 | /*++
155 | 
156 | Routine Description:
157 | 
158 |     This routine takes a file object and extracts the Fcb and Ccb (possibly NULL)
159 |     and returns the type of open.
160 | 
161 | Arguments:
162 | 
163 |     FileObject - Supplies the file object pointer being initialized.
164 | 
165 |     Fcb - Address to store the Fcb contained in the file object.
166 | 
167 |     Ccb - Address to store the Ccb contained in the file object.
168 | 
169 | Return Value:
170 | 
171 |     TYPE_OF_OPEN - Indicates the type of file object.
172 | 
173 | --*/
174 | 
175 | {
176 |     TYPE_OF_OPEN TypeOfOpen;
177 | 
178 |     PAGED_CODE();
179 | 
180 |     //
181 |     //  If this is an unopened file object then return NULL for the
182 |     //  Fcb/Ccb.  Don't trust any other values in the file object.
183 |     //
184 | 
185 |     TypeOfOpen = FlagOn( (ULONG_PTR) FileObject->FsContext2,
186 |                          TYPE_OF_OPEN_MASK );
187 | 
188 |     if (TypeOfOpen == UnopenedFileObject) {
189 | 
190 |         *Fcb = NULL;
191 |         *Ccb = NULL;
192 | 
193 |     } else {
194 | 
195 |         //
196 |         //  The Fcb is pointed to by the FsContext field.  The Ccb is in
197 |         //  FsContext2 (after clearing the low three bits).  The low three
198 |         //  bits are the file object type.
199 |         //
200 | 
201 |         *Fcb = FileObject->FsContext;
202 |         *Ccb = FileObject->FsContext2;
203 | 
204 |         ClearFlag( (ULONG_PTR) *Ccb, TYPE_OF_OPEN_MASK );
205 |     }
206 | 
207 |     //
208 |     //  Now return the type of open.
209 |     //
210 | 
211 |     return TypeOfOpen;
212 | }
213 | 
214 | 
215 | TYPE_OF_OPEN
216 | NwFastDecodeFileObject (
217 |     IN PFILE_OBJECT FileObject,
218 |     OUT PFCB *Fcb
219 |     )
220 | 
221 | /*++
222 | 
223 | Routine Description:
224 | 
225 |     This procedure takes a pointer to a file object, that has already been
226 |     opened by Nwfs and does a quick decode operation.  It will only return
227 |     a non null value if the file object is a user file open
228 | 
229 | Arguments:
230 | 
231 |     FileObject - Supplies the file object pointer being interrogated
232 | 
233 |     Fcb - Address to store Fcb if this is a user file object.  NULL
234 |         otherwise.
235 | 
236 | Return Value:
237 | 
238 |     TYPE_OF_OPEN - type of open of this file object.
239 | 
240 | --*/
241 | 
242 | {
243 |     TYPE_OF_OPEN TypeOfOpen;
244 | 
245 |     PAGED_CODE();
246 | 
247 |     ASSERT_FILE_OBJECT( FileObject );
248 | 
249 |     //
250 |     //  The Fcb is in the FsContext field.  The type of open is in the low
251 |     //  bits of the Ccb.
252 |     //
253 | 
254 |     *Fcb = FileObject->FsContext;
255 | 
256 |     return (TYPE_OF_OPEN)FlagOn( (ULONG_PTR)FileObject->FsContext2, TYPE_OF_OPEN_MASK );
257 | }
258 | 
259 | 
260 | 


--------------------------------------------------------------------------------
/windows-src/fspdisp.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /***************************************************************************
  3 | *
  4 | *   Copyright (c) 1999-2022 Jeffrey V. Merkey
  5 | *   7260 SE Tenino St.
  6 | *   Portland, Oregon 97206
  7 | *   jeffmerkey@gmail.com
  8 | *
  9 | *   This program is free software; you can redistribute it and/or modify it
 10 | *   under the terms of the Lesser GNU Public License 2.1 as
 11 | *   published by the Free Software Foundation.  (Windows NT/2000
 12 | *   is a registered trademark of Microsoft Corporation).
 13 | *
 14 | *   This program is distributed in the hope that it will be useful, but
 15 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
 16 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 17 | *
 18 | ****************************************************************************
 19 | 
 20 | Module Name:
 21 | 
 22 |     FspDisp.c
 23 | 
 24 | Abstract:
 25 | 
 26 |     This module implements the main dispatch procedure/thread for the Nwfs
 27 |     Fsp
 28 | 
 29 |   Authors:
 30 | 
 31 |     Jeff Merkey (jeffmerkey@gmail.com)
 32 |     David Goebel (davidg@balder.com) 11-Mar-1999
 33 | 
 34 | ***************************************************************************/
 35 | 
 36 | #include "NwProcs.h"
 37 | 
 38 | //
 39 | //  The Bug check file id for this module
 40 | //
 41 | 
 42 | #define BugCheckFileId                   (NWFS_BUG_CHECK_FSPDISP)
 43 | 
 44 | 
 45 | VOID
 46 | NwFspDispatch (
 47 |     IN PIRP_CONTEXT IrpContext
 48 |     )
 49 | 
 50 | /*++
 51 | 
 52 | Routine Description:
 53 | 
 54 |     This is the main FSP thread routine that is executed to receive
 55 |     and dispatch IRP requests.  Each FSP thread begins its execution here.
 56 |     There is one thread created at system initialization time and subsequent
 57 |     threads created as needed.
 58 | 
 59 | Arguments:
 60 | 
 61 |     IrpContext - IrpContext for a request to process.
 62 | 
 63 | Return Value:
 64 | 
 65 |     None
 66 | 
 67 | --*/
 68 | 
 69 | {
 70 |     THREAD_CONTEXT ThreadContext;
 71 |     NTSTATUS Status;
 72 | 
 73 |     PIRP Irp = IrpContext->Irp;
 74 |     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
 75 | 
 76 |     PVOLUME_DEVICE_OBJECT VolDo = NULL;
 77 | 
 78 |     //
 79 |     //  If this request has an associated volume device object, remember it.
 80 |     //
 81 | 
 82 |     if (IrpSp->FileObject != NULL) {
 83 | 
 84 |         VolDo = CONTAINING_RECORD( IrpSp->DeviceObject,
 85 |                                    VOLUME_DEVICE_OBJECT,
 86 |                                    DeviceObject );
 87 |     }
 88 | 
 89 |     //
 90 |     //  Now case on the function code.  For each major function code,
 91 |     //  either call the appropriate worker routine.  This routine that
 92 |     //  we call is responsible for completing the IRP, and not us.
 93 |     //  That way the routine can complete the IRP and then continue
 94 |     //  post processing as required.  For example, a read can be
 95 |     //  satisfied right away and then read can be done.
 96 |     //
 97 |     //  We'll do all of the work within an exception handler that
 98 |     //  will be invoked if ever some underlying operation gets into
 99 |     //  trouble.
100 |     //
101 | 
102 |     while ( TRUE ) {
103 | 
104 |         //
105 |         //  Set all the flags indicating we are in the Fsp.
106 |         //
107 | 
108 |         SetFlag( IrpContext->Flags, IRP_CONTEXT_FSP_FLAGS );
109 | 
110 |         FsRtlEnterFileSystem();
111 | 
112 |         NwSetThreadContext( IrpContext, &ThreadContext );
113 | 
114 |         while (TRUE) {
115 | 
116 |             try {
117 | 
118 |                 //
119 |                 //  Reinitialize for the next try at completing this
120 |                 //  request.
121 |                 //
122 | 
123 |                 Status = IrpContext->ExceptionStatus = STATUS_SUCCESS;
124 | 
125 |                 //
126 |                 //  Initialize the Io status field in the Irp.
127 |                 //
128 | 
129 |                 Irp->IoStatus.Status = STATUS_SUCCESS;
130 |                 Irp->IoStatus.Information = 0;
131 | 
132 |                 //
133 |                 //  Case on the major irp code.
134 |                 //
135 | 
136 |                 switch (IrpContext->MajorFunction) {
137 | 
138 |                 case IRP_MJ_CREATE :
139 | 
140 |                     NwCommonCreate( IrpContext, Irp );
141 |                     break;
142 | 
143 |                 case IRP_MJ_CLOSE :
144 | 
145 |                     ASSERT( FALSE );
146 |                     break;
147 | 
148 |                 case IRP_MJ_READ :
149 | 
150 |                     NwCommonRead( IrpContext, Irp );
151 |                     break;
152 | 
153 |                 case IRP_MJ_QUERY_INFORMATION :
154 | 
155 |                     NwCommonQueryInfo( IrpContext, Irp );
156 |                     break;
157 | 
158 |                 case IRP_MJ_SET_INFORMATION :
159 | 
160 |                     NwCommonSetInfo( IrpContext, Irp );
161 |                     break;
162 | 
163 |                 case IRP_MJ_QUERY_VOLUME_INFORMATION :
164 | 
165 |                     NwCommonQueryVolInfo( IrpContext, Irp );
166 |                     break;
167 | 
168 |                 case IRP_MJ_DIRECTORY_CONTROL :
169 | 
170 |                     NwCommonDirControl( IrpContext, Irp );
171 |                     break;
172 | 
173 |                 case IRP_MJ_FILE_SYSTEM_CONTROL :
174 | 
175 |                     NwCommonFsControl( IrpContext, Irp );
176 |                     break;
177 | 
178 |                 case IRP_MJ_DEVICE_CONTROL :
179 | 
180 |                     NwCommonDevControl( IrpContext, Irp );
181 |                     break;
182 | 
183 |                 case IRP_MJ_LOCK_CONTROL :
184 | 
185 |                     NwCommonLockControl( IrpContext, Irp );
186 |                     break;
187 | 
188 |                 case IRP_MJ_CLEANUP :
189 | 
190 |                     NwCommonCleanup( IrpContext, Irp );
191 |                     break;
192 | 
193 |                 default :
194 | 
195 |                     Status = STATUS_INVALID_DEVICE_REQUEST;
196 |                     NwCompleteRequest( IrpContext, Irp, Status );
197 |                 }
198 | 
199 |             } except( NwExceptionFilter( IrpContext, GetExceptionInformation() )) {
200 | 
201 |                 Status = NwProcessException( IrpContext, Irp, GetExceptionCode() );
202 |             }
203 | 
204 |             //
205 |             //  Break out of the loop if we didn't get CANT_WAIT.
206 |             //
207 | 
208 |             if (Status != STATUS_CANT_WAIT) { break; }
209 | 
210 |             //
211 |             //  We are retrying this request.  Cleanup the IrpContext for the retry.
212 |             //
213 | 
214 |             SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
215 |             NwCleanupIrpContext( IrpContext, FALSE );
216 |         }
217 | 
218 |         FsRtlExitFileSystem();
219 | 
220 |         //
221 |         //  If there are any entries on this volume's overflow queue, service
222 |         //  them.
223 |         //
224 | 
225 |         if (VolDo != NULL) {
226 | 
227 |             KIRQL SavedIrql;
228 |             PVOID Entry = NULL;
229 | 
230 |             //
231 |             //  We have a volume device object so see if there is any work
232 |             //  left to do in its overflow queue.
233 |             //
234 | 
235 |             NwLock();
236 | 
237 |             if (VolDo->OverflowQueueCount > 0) {
238 | 
239 |                 //
240 |                 //  There is overflow work to do in this volume so we'll
241 |                 //  decrement the Overflow count, dequeue the IRP, and release
242 |                 //  the Event
243 |                 //
244 | 
245 |                 VolDo->OverflowQueueCount -= 1;
246 | 
247 |                 Entry = RemoveHeadList( &VolDo->OverflowQueue );
248 |             }
249 | 
250 |             NwUnlock();
251 | 
252 |             //
253 |             //  There wasn't an entry, break out of the loop and return to
254 |             //  the Ex Worker thread.
255 |             //
256 | 
257 |             if (Entry == NULL) { break; }
258 | 
259 |             //
260 |             //  Extract the IrpContext , Irp, set wait to TRUE, and loop.
261 |             //
262 | 
263 |             IrpContext = CONTAINING_RECORD( Entry,
264 |                                             IRP_CONTEXT,
265 |                                             WorkQueueItem.List );
266 | 
267 |             Irp = IrpContext->Irp;
268 |             IrpSp = IoGetCurrentIrpStackLocation( Irp );
269 | 
270 |             continue;
271 |         }
272 | 
273 |         break;
274 |     }
275 | 
276 |     //
277 |     //  Decrement the PostedRequestCount if there was a volume device object.
278 |     //
279 | 
280 |     if (VolDo) {
281 | 
282 |         NwLock();
283 |         VolDo->PostedRequestCount--;
284 |         NwUnlock();
285 |     }
286 | 
287 |     return;
288 | }
289 | 
290 | 
291 | 
292 | 


--------------------------------------------------------------------------------
/windows-src/makefile:
--------------------------------------------------------------------------------
1 | #
2 | # DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
3 | # file to this component.  This file merely indirects to the real make file
4 | # that is shared by all the driver components of the Windows NT DDK
5 | #
6 | 
7 | !INCLUDE $(NTMAKEENV)\makefile.def
8 | 


--------------------------------------------------------------------------------
/windows-src/namesup.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /***************************************************************************
  3 | *
  4 | *   Copyright (c) 1999-2022 Jeffrey V. Merkey
  5 | *   7260 SE Tenino St.
  6 | *   Portland, Oregon 97206
  7 | *   jeffmerkey@gmail.com
  8 | *
  9 | *   This program is free software; you can redistribute it and/or modify it
 10 | *   under the terms of the Lesser GNU Public License 2.1 as
 11 | *   published by the Free Software Foundation.  (Windows NT/2000
 12 | *   is a registered trademark of Microsoft Corporation).
 13 | *
 14 | *   This program is distributed in the hope that it will be useful, but
 15 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
 16 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 17 | *
 18 | ****************************************************************************
 19 | 
 20 | Module Name:
 21 | 
 22 |     NameSup.c
 23 | 
 24 | Abstract:
 25 | 
 26 |     This module implements the Nwfs Name support routines
 27 | 
 28 |   Authors:
 29 | 
 30 |     Jeff Merkey (jeffmerkey@gmail.com)
 31 |     David Goebel (davidg@balder.com) 11-Mar-1999
 32 | 
 33 | ****************************************************************************/
 34 | 
 35 | #include "NwProcs.h"
 36 | 
 37 | //
 38 | //  The Bug check file id for this module
 39 | //
 40 | 
 41 | #define BugCheckFileId                   (NWFS_BUG_CHECK_NAMESUP)
 42 | 
 43 | #ifdef ALLOC_PRAGMA
 44 | #pragma alloc_text(PAGE, NwDissectName)
 45 | #pragma alloc_text(PAGE, NwIsNameInExpression)
 46 | #endif
 47 | 
 48 | 
 49 | VOID
 50 | NwDissectName (
 51 |     IN PIRP_CONTEXT IrpContext,
 52 |     IN OUT POEM_STRING RemainingName,
 53 |     OUT POEM_STRING FinalName
 54 |     )
 55 | 
 56 | /*++
 57 | 
 58 | Routine Description:
 59 | 
 60 |     This routine is called to strip off leading components of the name strings.
 61 |     We search for either the end of the string or separating characters.  The
 62 |     input remaining name strings should have neither a trailing or leading
 63 |     backslash.
 64 | 
 65 | Arguments:
 66 | 
 67 |     RemainingName - Remaining name.
 68 | 
 69 |     FinalName - Location to store next component of name.
 70 | 
 71 | Return Value:
 72 | 
 73 |     None.
 74 | 
 75 | --*/
 76 | 
 77 | {
 78 |     ULONG NameLength;
 79 |     PUCHAR NextChar;
 80 | 
 81 |     PAGED_CODE();
 82 | 
 83 |     //
 84 |     //  Find the offset of the next component separators.
 85 |     //
 86 | 
 87 |     for (NameLength = 0, NextChar = RemainingName->Buffer;
 88 |          (NameLength < RemainingName->Length) && (*NextChar != '\\');
 89 |          NameLength += 1, NextChar += 1);
 90 | 
 91 |     //
 92 |     //  Adjust all the strings by this amount.
 93 |     //
 94 | 
 95 |     FinalName->Buffer = RemainingName->Buffer;
 96 | 
 97 |     FinalName->MaximumLength = FinalName->Length = (USHORT) NameLength;
 98 | 
 99 |     //
100 |     //  If this is the last component then set the RemainingName lengths to zero.
101 |     //
102 | 
103 |     if (NameLength == RemainingName->Length) {
104 | 
105 |         RemainingName->Length = 0;
106 | 
107 |     //
108 |     //  Otherwise we adjust the string by this amount plus the separating character.
109 |     //
110 | 
111 |     } else {
112 | 
113 |         RemainingName->MaximumLength -= (USHORT) (NameLength + 1);
114 |         RemainingName->Length -= (USHORT) (NameLength + 1);
115 |         RemainingName->Buffer = Add2Ptr( RemainingName->Buffer,
116 |                                          NameLength + 1,
117 |                                          PUCHAR );
118 |     }
119 | 
120 |     return;
121 | }
122 | 
123 | 
124 | BOOLEAN
125 | NwIsNameInExpression (
126 |     IN PIRP_CONTEXT IrpContext,
127 |     IN PUNICODE_STRING CurrentName,
128 |     IN PUNICODE_STRING SearchExpression,
129 |     IN ULONG  WildcardFlags
130 |     )
131 | 
132 | /*++
133 | 
134 | Routine Description:
135 | 
136 |     This routine will compare two NwName strings.  We assume that if this
137 |     is to be a case-insensitive search then they are already upcased.
138 | 
139 |     We compare the filename portions of the name and if they match we
140 |     compare the version strings if requested.
141 | 
142 | Arguments:
143 | 
144 |     CurrentName - Filename from the disk.
145 | 
146 |     SearchExpression - Filename expression to use for match.
147 | 
148 |     WildcardFlags - Flags field which indicates which parts of the
149 |         search expression might have wildcards.  These flags are the
150 |         same as in the Ccb flags field.
151 | 
152 | Return Value:
153 | 
154 |     BOOLEAN - TRUE if the expressions match, FALSE otherwise.
155 | 
156 | --*/
157 | 
158 | {
159 |     PAGED_CODE();
160 | 
161 |     //
162 |     //  If there are wildcards in the expression then we call the
163 |     //  appropriate FsRtlRoutine.
164 |     //
165 | 
166 |     if (!FlagOn( WildcardFlags, CCB_FLAG_ENUM_CONSTANT )) {
167 | 
168 |         return FsRtlIsNameInExpression( SearchExpression,
169 |                                         CurrentName,
170 |                                         FALSE,
171 |                                         NULL );
172 | 
173 |     //
174 |     //  Otherwise do a direct memory comparison for the name string.
175 |     //
176 | 
177 |     } else {
178 | 
179 |         if ((CurrentName->Length == SearchExpression->Length) &&
180 |             RtlEqualMemory( CurrentName->Buffer,
181 |                             SearchExpression->Buffer,
182 |                             CurrentName->Length )) {
183 |             return TRUE;
184 | 
185 |         } else {
186 | 
187 |             return FALSE;
188 |         }
189 |     }
190 | }
191 | 
192 | 


--------------------------------------------------------------------------------
/windows-src/nodetype.h:
--------------------------------------------------------------------------------
 1 | /*++
 2 | 
 3 | Copyright (c) 1999-2022 Jeffrey V. Merkey
 4 | 
 5 | Module Name:
 6 | 
 7 |     NodeType.h
 8 | 
 9 | Abstract:
10 | 
11 |     This module defines all of the node type codes used in this development
12 |     shell.  Every major data structure in the file system is assigned a node
13 |     type code.  This code is the first CSHORT in the structure and is followed
14 |     by a CSHORT containing the size, in bytes, of the structure.
15 | 
16 | Author:
17 | 
18 |     David Goebel (davidg@balder.com) 11-Mar-1999
19 | 
20 | --*/
21 | 
22 | #ifndef _NWNODETYPE_
23 | #define _NWNODETYPE_
24 | 
25 | typedef CSHORT NODE_TYPE_CODE;
26 | typedef NODE_TYPE_CODE *PNODE_TYPE_CODE;
27 | 
28 | #define NTC_UNDEFINED                   ((NODE_TYPE_CODE)0x0000)
29 | 
30 | #define NWFS_NTC_DATA_HEADER            ((NODE_TYPE_CODE)0x0e01)
31 | #define NWFS_NTC_VCB                    ((NODE_TYPE_CODE)0x0e02)
32 | #define NWFS_NTC_DCB                    ((NODE_TYPE_CODE)0x0e03)
33 | #define NWFS_NTC_FCB                    ((NODE_TYPE_CODE)0x0e04)
34 | #define NWFS_NTC_FCB_NONPAGED           ((NODE_TYPE_CODE)0x0e05)
35 | #define NWFS_NTC_CCB                    ((NODE_TYPE_CODE)0x0e06)
36 | #define NWFS_NTC_IRP_CONTEXT            ((NODE_TYPE_CODE)0x0e07)
37 | 
38 | typedef CSHORT NODE_BYTE_SIZE;
39 | 
40 | //
41 | //  So all records start with
42 | //
43 | //  typedef struct _RECORD_NAME {
44 | //      NODE_TYPE_CODE NodeTypeCode;
45 | //      NODE_BYTE_SIZE NodeByteSize;
46 | //          :
47 | //  } RECORD_NAME;
48 | //  typedef RECORD_NAME *PRECORD_NAME;
49 | //
50 | 
51 | #define NodeType(P) ((P) != NULL ? (*((PNODE_TYPE_CODE)(P))) : NTC_UNDEFINED)
52 | #define SafeNodeType(Ptr) (*((PNODE_TYPE_CODE)(Ptr)))
53 | 
54 | 
55 | //
56 | //  The following definitions are used to generate meaningful blue bugcheck
57 | //  screens.  On a bugcheck the file system can output 4 ulongs of useful
58 | //  information.  The first ulong will have encoded in it a source file id
59 | //  (in the high word) and the line number of the bugcheck (in the low word).
60 | //  The other values can be whatever the caller of the bugcheck routine deems
61 | //  necessary.
62 | //
63 | //  Each individual file that calls bugcheck needs to have defined at the
64 | //  start of the file a constant called BugCheckFileId with one of the
65 | //  NWFS_BUG_CHECK_ values defined below and then use NwBugCheck to bugcheck
66 | //  the system.
67 | //
68 | 
69 | #define NWFS_BUG_CHECK_CACHESUP          (0x00010000)
70 | #define NWFS_BUG_CHECK_NWDATA            (0x00020000)
71 | #define NWFS_BUG_CHECK_NWINIT            (0x00030000)
72 | #define NWFS_BUG_CHECK_CLEANUP           (0x00040000)
73 | #define NWFS_BUG_CHECK_CLOSE             (0x00050000)
74 | #define NWFS_BUG_CHECK_CREATE            (0x00060000)
75 | #define NWFS_BUG_CHECK_DEVCTRL           (0x00070000)
76 | #define NWFS_BUG_CHECK_DEVIOSUP          (0x00080000)
77 | #define NWFS_BUG_CHECK_DIRCTRL           (0x00090000)
78 | #define NWFS_BUG_CHECK_DIRSUP            (0x000a0000)
79 | #define NWFS_BUG_CHECK_FILEINFO          (0x000b0000)
80 | #define NWFS_BUG_CHECK_FILOBSUP          (0x000c0000)
81 | #define NWFS_BUG_CHECK_FSCTRL            (0x000d0000)
82 | #define NWFS_BUG_CHECK_FSPDISP           (0x000e0000)
83 | #define NWFS_BUG_CHECK_LOCKCTRL          (0x000f0000)
84 | #define NWFS_BUG_CHECK_NAMESUP           (0x00100000)
85 | #define NWFS_BUG_CHECK_READ              (0x00110000)
86 | #define NWFS_BUG_CHECK_RESRCSUP          (0x00120000)
87 | #define NWFS_BUG_CHECK_STRUCSUP          (0x00130000)
88 | #define NWFS_BUG_CHECK_VERFYSUP          (0x00140000)
89 | #define NWFS_BUG_CHECK_VOLINFO           (0x00150000)
90 | #define NWFS_BUG_CHECK_WORKQUE           (0x00160000)
91 | #define NWFS_BUG_CHECK_NWSUP             (0x00170000)
92 | 
93 | #define NwBugCheck(A,B,C) { KeBugCheckEx(FILE_SYSTEM, BugCheckFileId | __LINE__, A, B, C ); }
94 | 
95 | #endif // _NWNODETYPE_
96 | 


--------------------------------------------------------------------------------
/windows-src/nw.h:
--------------------------------------------------------------------------------
 1 | /*++
 2 | 
 3 | Copyright (c) 1999-2022 Jeffrey V. Merkey
 4 | 
 5 | Module Name:
 6 | 
 7 |     nw.h
 8 | 
 9 | Abstract:
10 | 
11 |     This module defines the on-disk structure of the Netware file system. They
12 |     are mainly used to interpret data from the hash structure.
13 | 
14 | Author:
15 | 
16 |     David Goebel (davidg@balder.com) 11-Mar-1999
17 | 
18 | --*/
19 | 
20 | #ifndef _NWFS_
21 | #define _NWFS_
22 | 
23 | //
24 | //  Sector size on Netware disks is hard-coded to 512
25 | //
26 | 
27 | #define SECTOR_SIZE                 (0x200)
28 | #define SECTOR_SHIFT                (9)
29 | #define SECTOR_MASK                 (SECTOR_SIZE - 1)
30 | #define INVERSE_SECTOR_MASK         ~(SECTOR_SIZE - 1)
31 | 
32 | //
33 | //  Nwfs file id is a large integer.
34 | //
35 | 
36 | typedef LARGE_INTEGER               FILE_ID;
37 | typedef FILE_ID                     *PFILE_ID;
38 | 
39 | #define NETWARE_PARTITION_TYPE      0x65
40 | 
41 | #define NW_MAX_SEGMENTS_PER_VOLUME  0x20
42 | 
43 | //
44 | //  This is the maximum number of bad partitions that we can remember.
45 | //
46 | 
47 | #define MAX_BAD_PARTITIONS          0x100
48 | 
49 | //
50 | //  Define the various dirent attributes
51 | //
52 | 
53 | #define NETWARE_ATTR_READ_ONLY        0x01
54 | #define NETWARE_ATTR_HIDDEN           0x02
55 | #define NETWARE_ATTR_SYSTEM           0x04
56 | #define NETWARE_ATTR_DIRECTORY        0x10
57 | #define NETWARE_ATTR_ARCHIVE          0x20
58 | 
59 | #define NETWARE_ATTR_MASK  ( NETWARE_ATTR_READ_ONLY | \
60 |                              NETWARE_ATTR_HIDDEN    | \
61 |                              NETWARE_ATTR_SYSTEM    | \
62 |                              NETWARE_ATTR_DIRECTORY | \
63 |                              NETWARE_ATTR_ARCHIVE )
64 | 
65 | #endif // _NWFS_
66 | 
67 | 


--------------------------------------------------------------------------------
/windows-src/nwdata.h:
--------------------------------------------------------------------------------
  1 | /*++
  2 | 
  3 | Copyright (c) 1999-2022 Jeffrey V. Merkey
  4 | 
  5 | Module Name:
  6 | 
  7 |     NwData.h
  8 | 
  9 | Abstract:
 10 | 
 11 |     This module declares the global data used by the Nwfs file system.
 12 | 
 13 | Author:
 14 | 
 15 |     David Goebel (davidg@balder.com) 11-Mar-1999
 16 | 
 17 | --*/
 18 | 
 19 | #ifndef _NWDATA_
 20 | #define _NWDATA_
 21 | 
 22 | //
 23 | //  Global data structures
 24 | //
 25 | 
 26 | extern NW_DATA NwData;
 27 | extern FAST_IO_DISPATCH NwFastIoDispatch;
 28 | extern FILE_ID FileIdZero;
 29 | 
 30 | extern PUCHAR NwOemUpcaseTable;
 31 | 
 32 | //
 33 | //  Global constants
 34 | //
 35 | 
 36 | //
 37 | //  This is the number of times a mounted Vcb will be referenced on behalf
 38 | //  of the system.  The count includes one for the DasdFcb and one for the
 39 | //  RootDirDcb.
 40 | //
 41 | 
 42 | #define NWFS_RESIDUAL_FCB_COUNT                     (2)
 43 | 
 44 | #define NT_DEVICE_NAME  L"\\NwFsRo"
 45 | #define DOS_DEVICE_NAME L"\\??\\NwFsRo"
 46 | 
 47 | 
 48 | //
 49 | //  Turn on pseudo-asserts if NW_FREE_ASSERTS is defined.
 50 | //
 51 | 
 52 | #if !DBG
 53 | #ifdef NW_FREE_ASSERTS
 54 | #undef ASSERT
 55 | #undef ASSERTMSG
 56 | #define ASSERT(exp)        if (!(exp)) { extern BOOLEAN KdDebuggerEnabled; DbgPrint("%s:%d %s\n",__FILE__,__LINE__,#exp); if (KdDebuggerEnabled) { DbgBreakPoint(); } }
 57 | #define ASSERTMSG(msg,exp) if (!(exp)) { extern BOOLEAN KdDebuggerEnabled; DbgPrint("%s:%d %s %s\n",__FILE__,__LINE__,msg,#exp); if (KdDebuggerEnabled) { DbgBreakPoint(); } }
 58 | #endif
 59 | #endif
 60 | 
 61 | 
 62 | //
 63 | //  The following assertion macros ensure that the indicated structure
 64 | //  is valid
 65 | //
 66 | //      ASSERT_STRUCT( IN PVOID Struct, IN CSHORT NodeType );
 67 | //      ASSERT_OPTIONAL_STRUCT( IN PVOID Struct OPTIONAL, IN CSHORT NodeType );
 68 | //
 69 | //      ASSERT_VCB( IN PVCB Vcb );
 70 | //      ASSERT_OPTIONAL_VCB( IN PVCB Vcb OPTIONAL );
 71 | //
 72 | //      ASSERT_FCB( IN PFCB Fcb );
 73 | //      ASSERT_OPTIONAL_FCB( IN PFCB Fcb OPTIONAL );
 74 | //
 75 | //      ASSERT_FCB_NONPAGED( IN PFCB_NONPAGED FcbNonpaged );
 76 | //      ASSERT_OPTIONAL_FCB( IN PFCB_NONPAGED FcbNonpaged OPTIONAL );
 77 | //
 78 | //      ASSERT_CCB( IN PSCB Ccb );
 79 | //      ASSERT_OPTIONAL_CCB( IN PSCB Ccb OPTIONAL );
 80 | //
 81 | //      ASSERT_IRP_CONTEXT( IN PIRP_CONTEXT IrpContext );
 82 | //      ASSERT_OPTIONAL_IRP_CONTEXT( IN PIRP_CONTEXT IrpContext OPTIONAL );
 83 | //
 84 | //      ASSERT_IRP( IN PIRP Irp );
 85 | //      ASSERT_OPTIONAL_IRP( IN PIRP Irp OPTIONAL );
 86 | //
 87 | //      ASSERT_FILE_OBJECT( IN PFILE_OBJECT FileObject );
 88 | //      ASSERT_OPTIONAL_FILE_OBJECT( IN PFILE_OBJECT FileObject OPTIONAL );
 89 | //
 90 | //  The following macros are used to check the current thread owns
 91 | //  the indicated resource
 92 | //
 93 | //      ASSERT_EXCLUSIVE_RESOURCE( IN PERESOURCE Resource );
 94 | //
 95 | //      ASSERT_SHARED_RESOURCE( IN PERESOURCE Resource );
 96 | //
 97 | //      ASSERT_RESOURCE_NOT_MINE( IN PERESOURCE Resource );
 98 | //
 99 | //  The following macros are used to check whether the current thread
100 | //  owns the resoures in the given structures.
101 | //
102 | //      ASSERT_EXCLUSIVE_NWDATA
103 | //
104 | //      ASSERT_EXCLUSIVE_VCB( IN PVCB Vcb );
105 | //
106 | //      ASSERT_SHARED_VCB( IN PVCB Vcb );
107 | //
108 | //      ASSERT_EXCLUSIVE_FCB( IN PFCB Fcb );
109 | //
110 | //      ASSERT_SHARED_FCB( IN PFCB Fcb );
111 | //
112 | //      ASSERT_LOCKED_NW();
113 | //
114 | //      ASSERT_NOT_LOCKED_NW();
115 | //
116 | 
117 | //
118 | //  Turn on the sanity checks if this is DBG or NW_FREE_ASSERTS
119 | //
120 | 
121 | #if DBG
122 | #undef NW_SANITY
123 | #define NW_SANITY
124 | #endif
125 | 
126 | #ifdef NW_SANITY
127 | 
128 | #define ASSERT_STRUCT(S,T)                  ASSERT( SafeNodeType( S ) == (T) )
129 | #define ASSERT_OPTIONAL_STRUCT(S,T)         ASSERT( ((S) == NULL) ||  (SafeNodeType( S ) == (T)) )
130 | 
131 | #define ASSERT_VCB(V)                       ASSERT_STRUCT( (V), NWFS_NTC_VCB )
132 | #define ASSERT_OPTIONAL_VCB(V)              ASSERT_OPTIONAL_STRUCT( (V), NWFS_NTC_VCB )
133 | 
134 | #define ASSERT_FCB(F)                                \
135 |     ASSERT( (SafeNodeType( F ) == NWFS_NTC_FCB ) ||  \
136 |             (SafeNodeType( F ) == NWFS_NTC_DCB ) )
137 | 
138 | #define ASSERT_OPTIONAL_FCB(F)                       \
139 |     ASSERT( ((F) == NULL) ||                         \
140 |             (SafeNodeType( F ) == NWFS_NTC_FCB ) ||  \
141 |             (SafeNodeType( F ) == NWFS_NTC_DCB ) )
142 | 
143 | #define ASSERT_FCB_NONPAGED(FN)             ASSERT_STRUCT( (FN), NWFS_NTC_FCB_NONPAGED )
144 | #define ASSERT_OPTIONAL_FCB_NONPAGED(FN)    ASSERT_OPTIONAL_STRUCT( (FN), NWFS_NTC_FCB_NONPAGED )
145 | 
146 | #define ASSERT_CCB(C)                       ASSERT_STRUCT( (C), NWFS_NTC_CCB )
147 | #define ASSERT_OPTIONAL_CCB(C)              ASSERT_OPTIONAL_STRUCT( (C), NWFS_NTC_CCB )
148 | 
149 | #define ASSERT_IRP_CONTEXT(IC)              ASSERT_STRUCT( (IC), NWFS_NTC_IRP_CONTEXT )
150 | #define ASSERT_OPTIONAL_IRP_CONTEXT(IC)     ASSERT_OPTIONAL_STRUCT( (IC), NWFS_NTC_IRP_CONTEXT )
151 | 
152 | #define ASSERT_IRP(I)                       ASSERT_STRUCT( (I), IO_TYPE_IRP )
153 | #define ASSERT_OPTIONAL_IRP(I)              ASSERT_OPTIONAL_STRUCT( (I), IO_TYPE_IRP )
154 | 
155 | #define ASSERT_FILE_OBJECT(FO)              ASSERT_STRUCT( (FO), IO_TYPE_FILE )
156 | #define ASSERT_OPTIONAL_FILE_OBJECT(FO)     ASSERT_OPTIONAL_STRUCT( (FO), IO_TYPE_FILE )
157 | 
158 | #define ASSERT_EXCLUSIVE_RESOURCE(R)        ASSERT( ExIsResourceAcquiredExclusive( R ))
159 | 
160 | #define ASSERT_SHARED_RESOURCE(R)           ASSERT( ExIsResourceAcquiredShared( R ))
161 | 
162 | #define ASSERT_RESOURCE_NOT_MINE(R)         ASSERT( !ExIsResourceAcquiredShared( R ))
163 | 
164 | #define ASSERT_EXCLUSIVE_NWDATA             ASSERT( ExIsResourceAcquiredExclusive( &NwData.DataResource ))
165 | #define ASSERT_EXCLUSIVE_VCB(V)             ASSERT( ExIsResourceAcquiredExclusive( &(V)->VcbResource ))
166 | #define ASSERT_SHARED_VCB(V)                ASSERT( ExIsResourceAcquiredShared( &(V)->VcbResource ))
167 | 
168 | #define ASSERT_EXCLUSIVE_FCB(F)             ASSERT( ExIsResourceAcquiredExclusive( &(F)->FcbNonpaged->FcbResource ))
169 | #define ASSERT_SHARED_FCB(F)                ASSERT( ExIsResourceAcquiredShared( &(F)->FcbNonpaged->FcbResource ))
170 | 
171 | #define ASSERT_LOCKED_NW()                  ASSERT( NwData.NwDataLockThread == PsGetCurrentThread() )
172 | #define ASSERT_NOT_LOCKED_NW()              ASSERT( NwData.NwDataLockThread != PsGetCurrentThread() )
173 | 
174 | #else
175 | 
176 | #define ASSERT_STRUCT(S,T)              { NOTHING; }
177 | #define ASSERT_OPTIONAL_STRUCT(S,T)     { NOTHING; }
178 | #define ASSERT_VCB(V)                   { NOTHING; }
179 | #define ASSERT_OPTIONAL_VCB(V)          { NOTHING; }
180 | #define ASSERT_FCB(F)                   { NOTHING; }
181 | #define ASSERT_OPTIONAL_FCB(F)          { NOTHING; }
182 | #define ASSERT_FCB_NONPAGED(FN)         { NOTHING; }
183 | #define ASSERT_OPTIONAL_FCB(FN)         { NOTHING; }
184 | #define ASSERT_CCB(C)                   { NOTHING; }
185 | #define ASSERT_OPTIONAL_CCB(C)          { NOTHING; }
186 | #define ASSERT_IRP_CONTEXT(IC)          { NOTHING; }
187 | #define ASSERT_OPTIONAL_IRP_CONTEXT(IC) { NOTHING; }
188 | #define ASSERT_IRP(I)                   { NOTHING; }
189 | #define ASSERT_OPTIONAL_IRP(I)          { NOTHING; }
190 | #define ASSERT_FILE_OBJECT(FO)          { NOTHING; }
191 | #define ASSERT_OPTIONAL_FILE_OBJECT(FO) { NOTHING; }
192 | #define ASSERT_EXCLUSIVE_RESOURCE(R)    { NOTHING; }
193 | #define ASSERT_SHARED_RESOURCE(R)       { NOTHING; }
194 | #define ASSERT_RESOURCE_NOT_MINE(R)     { NOTHING; }
195 | #define ASSERT_EXCLUSIVE_NWDATA         { NOTHING; }
196 | #define ASSERT_EXCLUSIVE_VCB(V)         { NOTHING; }
197 | #define ASSERT_SHARED_VCB(V)            { NOTHING; }
198 | #define ASSERT_EXCLUSIVE_FCB(F)         { NOTHING; }
199 | #define ASSERT_SHARED_FCB(F)            { NOTHING; }
200 | #define ASSERT_LOCKED_NW()              { NOTHING; }
201 | #define ASSERT_NOT_LOCKED_NW()          { NOTHING; }
202 | 
203 | #endif
204 | 
205 | #endif // _NWDATA_
206 | 


--------------------------------------------------------------------------------
/windows-src/nwfsro.rc:
--------------------------------------------------------------------------------
 1 | #include <windows.h>
 2 | 
 3 | #define VER_COMPANYNAME_STR      "Leaf Linux DBA"
 4 | #define VER_PRODUCTNAME_STR      "NWFS Read-Only Driver"
 5 | #define VER_LEGALCOPYRIGHT_YEARS "1998-2022"
 6 | #define VER_LEGALCOPYRIGHT_STR  "Copyright \251 Leaf Linux DBA " VER_LEGALCOPYRIGHT_YEARS
 7 | #define VER_PRODUCTVERSION       2, 0, 0, 0
 8 | #define VER_PRODUCTVERSION_STR   "V2.0.0.0"
 9 | #define VER_FILEVERSION          2, 0, 0, 0
10 | #define VER_FILEVERSION_STR      "2.000"
11 | #define VER_FILEFLAGS            0
12 | #define VER_FILEFLAGSMASK        0
13 | #define VER_FILEOS               VOS_NT_WINDOWS32
14 | #define VER_FILETYPE             VFT_DRV
15 | #define VER_FILESUBTYPE          VFT2_UNKNOWN
16 | #define VER_FILEDESCRIPTION_STR  "file system driver"
17 | #define VER_ORIGINALFILENAME_STR "nwfsro.sys"
18 | #define VER_INTERNALNAME_STR     "nwfsro.sys"
19 | 
20 | #include "common.ver"
21 | 


--------------------------------------------------------------------------------
/windows-src/resrcsup.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /***************************************************************************
  3 | *
  4 | *   Copyright (c) 1999-2022 Jeffrey V. Merkey
  5 | *   7260 SE Tenino St.
  6 | *   Portland, Oregon 97206
  7 | *   jeffmerkey@gmail.com
  8 | *
  9 | *   This program is free software; you can redistribute it and/or modify it
 10 | *   under the terms of the Lesser GNU Public License 2.1 as
 11 | *   published by the Free Software Foundation.  (Windows NT/2000
 12 | *   is a registered trademark of Microsoft Corporation).
 13 | *
 14 | *   This program is distributed in the hope that it will be useful, but
 15 | *   WITHOUT ANY WARRANTY; without even the implied warranty of
 16 | *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 17 | *
 18 | ****************************************************************************
 19 | 
 20 | Module Name:
 21 | 
 22 |     ResrcSup.c
 23 | 
 24 | Abstract:
 25 | 
 26 |     This module implements the Nwfs Resource acquisition routines
 27 | 
 28 |   Authors:
 29 | 
 30 |     Jeff Merkey (jeffmerkey@gmail.com)
 31 |     David Goebel (davidg@balder.com) 11-Mar-1999
 32 | 
 33 | ****************************************************************************/
 34 | 
 35 | #include "NwProcs.h"
 36 | 
 37 | //
 38 | //  The Bug check file id for this module
 39 | //
 40 | 
 41 | #define BugCheckFileId                   (NWFS_BUG_CHECK_RESRCSUP)
 42 | 
 43 | #ifdef ALLOC_PRAGMA
 44 | #pragma alloc_text(PAGE, NwAcquireForCache)
 45 | #pragma alloc_text(PAGE, NwAcquireForCreateSection)
 46 | #pragma alloc_text(PAGE, NwAcquireResource)
 47 | #pragma alloc_text(PAGE, NwNoopAcquire)
 48 | #pragma alloc_text(PAGE, NwNoopRelease)
 49 | #pragma alloc_text(PAGE, NwReleaseForCreateSection)
 50 | #pragma alloc_text(PAGE, NwReleaseFromCache)
 51 | #endif
 52 | 
 53 | 
 54 | BOOLEAN
 55 | NwAcquireResource (
 56 |     IN PIRP_CONTEXT IrpContext,
 57 |     IN PERESOURCE Resource,
 58 |     IN BOOLEAN IgnoreWait,
 59 |     IN TYPE_OF_ACQUIRE Type
 60 |     )
 61 | 
 62 | /*++
 63 | 
 64 | Routine Description:
 65 | 
 66 |     This is the single routine used to acquire file system resources.  It
 67 |     looks at the IgnoreWait flag to determine whether to try to acquire the
 68 |     resource without waiting.  Returning TRUE/FALSE to indicate success or
 69 |     failure.  Otherwise it is driven by the WAIT flag in the IrpContext and
 70 |     will raise CANT_WAIT on a failure.
 71 | 
 72 | Arguments:
 73 | 
 74 |     Resource - This is the resource to try and acquire.
 75 | 
 76 |     IgnoreWait - If TRUE then this routine will not wait to acquire the
 77 |         resource and will return a boolean indicating whether the resource was
 78 |         acquired.  Otherwise we use the flag in the IrpContext and raise
 79 |         if the resource is not acquired.
 80 | 
 81 |     Type - Indicates how we should try to get the resource.
 82 | 
 83 | Return Value:
 84 | 
 85 |     BOOLEAN - TRUE if the resource is acquired.  FALSE if not acquired and
 86 |         IgnoreWait is specified.  Otherwise we raise CANT_WAIT.
 87 | 
 88 | --*/
 89 | 
 90 | {
 91 |     BOOLEAN Wait = FALSE;
 92 |     BOOLEAN Acquired;
 93 |     PAGED_CODE();
 94 | 
 95 |     //
 96 |     //  We look first at the IgnoreWait flag, next at the flag in the Irp
 97 |     //  Context to decide how to acquire this resource.
 98 |     //
 99 | 
100 |     if (!IgnoreWait && FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
101 | 
102 |         Wait = TRUE;
103 |     }
104 | 
105 |     //
106 |     //  Attempt to acquire the resource either shared or exclusively.
107 |     //
108 | 
109 |     switch (Type) {
110 |         case AcquireExclusive:
111 | 
112 |             Acquired = ExAcquireResourceExclusive( Resource, Wait );
113 |             break;
114 | 
115 |         case AcquireShared:
116 | 
117 |             Acquired = ExAcquireResourceShared( Resource, Wait );
118 |             break;
119 | 
120 |         case AcquireSharedStarveExclusive:
121 | 
122 |             Acquired = ExAcquireSharedStarveExclusive( Resource, Wait );
123 |             break;
124 | 
125 |         default:
126 |             ASSERT( FALSE );
127 |     }
128 | 
129 |     //
130 |     //  If not acquired and the user didn't specifiy IgnoreWait then
131 |     //  raise CANT_WAIT.
132 |     //
133 | 
134 |     if (!Acquired && !IgnoreWait) {
135 | 
136 |         NwRaiseStatus( IrpContext, STATUS_CANT_WAIT );
137 |     }
138 | 
139 |     return Acquired;
140 | }
141 | 
142 | 
143 | BOOLEAN
144 | NwAcquireForCache (
145 |     IN PFCB Fcb,
146 |     IN BOOLEAN Wait
147 |     )
148 | 
149 | /*++
150 | 
151 | Routine Description:
152 | 
153 |     The address of this routine is specified when creating a CacheMap for
154 |     a file.  It is subsequently called by the Lazy Writer for synchronization.
155 | 
156 | Arguments:
157 | 
158 |     Fcb -  The pointer supplied as context to the cache initialization
159 |            routine.
160 | 
161 |     Wait - TRUE if the caller is willing to block.
162 | 
163 | Return Value:
164 | 
165 |     None
166 | 
167 | --*/
168 | 
169 | {
170 |     PAGED_CODE();
171 | 
172 |     return ExAcquireResourceShared( Fcb->Resource, Wait );
173 | }
174 | 
175 | 
176 | VOID
177 | NwReleaseFromCache (
178 |     IN PFCB Fcb
179 |     )
180 | 
181 | /*++
182 | 
183 | Routine Description:
184 | 
185 |     The address of this routine is specified when creating a CacheMap for
186 |     a virtual file.  It is subsequently called by the Lazy Writer to release
187 |     a resource acquired above.
188 | 
189 | Arguments:
190 | 
191 |     Fcb -  The pointer supplied as context to the cache initialization
192 |            routine.
193 | 
194 | Return Value:
195 | 
196 |     None
197 | 
198 | --*/
199 | 
200 | {
201 |     PAGED_CODE();
202 | 
203 |     ExReleaseResource( Fcb->Resource );
204 | 
205 |     return;
206 | }
207 | 
208 | 
209 | BOOLEAN
210 | NwNoopAcquire (
211 |     IN PVOID Fcb,
212 |     IN BOOLEAN Wait
213 |     )
214 | 
215 | /*++
216 | 
217 | Routine Description:
218 | 
219 |     This routine does nothing.
220 | 
221 | Arguments:
222 | 
223 |     Fcb - The Fcb/Vcb which was specified as a context parameter for this
224 |           routine.
225 | 
226 |     Wait - TRUE if the caller is willing to block.
227 | 
228 | Return Value:
229 | 
230 |     TRUE
231 | 
232 | --*/
233 | 
234 | {
235 |     PAGED_CODE();
236 |     return TRUE;
237 | }
238 | 
239 | 
240 | VOID
241 | NwNoopRelease (
242 |     IN PVOID Fcb
243 |     )
244 | 
245 | /*++
246 | 
247 | Routine Description:
248 | 
249 |     This routine does nothing.
250 | 
251 | Arguments:
252 | 
253 |     Fcb - The Fcb/Vcb which was specified as a context parameter for this
254 |           routine.
255 | 
256 | Return Value:
257 | 
258 |     None
259 | 
260 | --*/
261 | 
262 | {
263 |     PAGED_CODE();
264 |     return;
265 | }
266 | 
267 | 
268 | VOID
269 | NwAcquireForCreateSection (
270 |     IN PFILE_OBJECT FileObject
271 |     )
272 | 
273 | /*++
274 | 
275 | Routine Description:
276 | 
277 |     This is the callback routine for MM to use to acquire the file exclusively.
278 | 
279 | Arguments:
280 | 
281 |     FileObject - File object for a Nwfs stream.
282 | 
283 | Return Value:
284 | 
285 |     None
286 | 
287 | --*/
288 | 
289 | {
290 |     PAGED_CODE();
291 | 
292 |     //
293 |     //  Get the file resource exclusively.
294 |     //
295 | 
296 |     ExAcquireResourceExclusive( ((PFCB)FileObject->FsContext)->Resource,
297 |                                 TRUE );
298 | 
299 |     return;
300 | }
301 | 
302 | 
303 | VOID
304 | NwReleaseForCreateSection (
305 |     IN PFILE_OBJECT FileObject
306 |     )
307 | 
308 | /*++
309 | 
310 | Routine Description:
311 | 
312 |     This is the callback routine for MM to use to release a file acquired with
313 |     the AcquireForCreateSection call above.
314 | 
315 | Arguments:
316 | 
317 |     FileObject - File object for a Nwfs stream.
318 | 
319 | Return Value:
320 | 
321 |     None
322 | 
323 | --*/
324 | 
325 | {
326 |     PAGED_CODE();
327 | 
328 |     //
329 |     //  Release the resource in the Fcb.
330 |     //
331 | 
332 |     ExReleaseResource( ((PFCB) FileObject->FsContext)->Resource );
333 | 
334 |     return;
335 | }
336 | 


--------------------------------------------------------------------------------
/windows-src/sources:
--------------------------------------------------------------------------------
 1 | MAJORCOMP=ntos
 2 | MINORCOMP=nwfsro
 3 | 
 4 | TARGETNAME=nwfsro
 5 | TARGETPATH=$(BASEDIR)\lib
 6 | TARGETTYPE=DRIVER
 7 | TARGETLIBS=$(BASEDIR)\lib\i386\$(DDKBUILDENV)\nwfs.lib
 8 | INCLUDES=..;..\inc;$(BASEDIR)\inc;$(BASEDIR)\src\filesys\inc
 9 | 
10 | MSC_WARNING_LEVEL=/W3 /WX
11 | 
12 | SOURCES=nwfsro.rc  \
13 |         CacheSup.c \
14 |         Cleanup.c  \
15 |         Close.c    \
16 |         Create.c   \
17 |         DevCtrl.c  \
18 |         DevioSup.c \
19 |         DirCtrl.c  \
20 |         FileInfo.c \
21 |         FilObSup.c \
22 |         FsCtrl.c   \
23 |         FspDisp.c  \
24 |         LockCtrl.c \
25 |         NameSup.c  \
26 |         NwData.c   \
27 |         NwInit.c   \
28 |         NwSup.c    \
29 |         Read.c     \
30 |         ResrcSup.c \
31 |         Strucsup.c \
32 |         VolInfo.c  \
33 |         WorkQue.c
34 | 


--------------------------------------------------------------------------------
/windows-src/sources.nt5:
--------------------------------------------------------------------------------
 1 | MAJORCOMP=ntos
 2 | MINORCOMP=nwfsro
 3 | 
 4 | TARGETNAME=nwfsro
 5 | TARGETTYPE=DRIVER
 6 | TARGETPATH=..
 7 | TARGETLIBS=..\i386\nwfs.lib
 8 | INCLUDES=..\inc;$(BASEDIR)\inc;$(BASEDIR)\src\filesys\inc
 9 | 
10 | MSC_WARNING_LEVEL=/W3 /WX
11 | 
12 | SOURCES=nwfsro.rc  \
13 |         CacheSup.c \
14 |         Cleanup.c  \
15 |         Close.c    \
16 |         Create.c   \
17 |         DevCtrl.c  \
18 |         DevioSup.c \
19 |         DirCtrl.c  \
20 |         FileInfo.c \
21 |         FilObSup.c \
22 |         FsCtrl.c   \
23 |         FspDisp.c  \
24 |         LockCtrl.c \
25 |         NameSup.c  \
26 |         NwData.c   \
27 |         NwInit.c   \
28 |         NwSup.c    \
29 |         Read.c     \
30 |         ResrcSup.c \
31 |         Strucsup.c \
32 |         VolInfo.c  \
33 |         WorkQue.c
34 | 


--------------------------------------------------------------------------------