mars_dosutils-0.01
This commit is contained in:
Mario Fetka
commit
5e6805dd31
|
|
@ -0,0 +1,46 @@
|
|||
/* DOC for NET.EXE */
|
||||
This is a short description of net.exe which is a simple DOS-client
|
||||
programm to allow standard NCP network actions, mainly for mars_nwe.
|
||||
All functions are called as a second parameter.
|
||||
This programm is very incomplete till now, but some functions
|
||||
works well with mars_nwe.
|
||||
|
||||
LOGOUT:
|
||||
Logout from a NCP Server.
|
||||
|
||||
LOGIN:
|
||||
usage: LOGIN [-u] [user | user password]
|
||||
-u = use unencrypted password.
|
||||
With this function you can log into a NCP Server.
|
||||
Its only make a login, no mappings or something else.
|
||||
|
||||
If you want a login similar to NOVELL's login.exe you should
|
||||
do it with a batch job.
|
||||
|
||||
example:
|
||||
[\LOGIN\LOGIN.BAT]
|
||||
@echo OFF
|
||||
net logout
|
||||
net login %1 %2 %3
|
||||
if errorlevel 1 goto :end
|
||||
map h:=HOME:
|
||||
if not exist h:\profile.bat goto :end
|
||||
h:
|
||||
profile.bat
|
||||
:end
|
||||
|
||||
PASSWD:
|
||||
usage: PASSWD [user]
|
||||
With this function you are able to change a users password.
|
||||
This call uses the old unencryted change password call !!
|
||||
|
||||
|
||||
PATH:
|
||||
usage: PATH sn:[=[path]]
|
||||
sn = 's1' .. 's16'
|
||||
|
||||
With this function a new path element can be created.
|
||||
Its only sets the path environment.
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,201 @@
|
|||
; kern.asm: 20-Nov-93, 21:52
|
||||
IDEAL
|
||||
P286
|
||||
MODEL LARGE
|
||||
; Fuer Turboc gerettet werden muessen folgende Register:
|
||||
; BP, SS, SP, DS, CS u. SI, DI
|
||||
|
||||
MACRO P_START
|
||||
push bp
|
||||
mov bp, sp
|
||||
ENDM
|
||||
|
||||
MACRO P_END
|
||||
pop bp
|
||||
ENDM
|
||||
|
||||
MACRO PUSH_REGS
|
||||
push ds
|
||||
push si
|
||||
push di
|
||||
ENDM
|
||||
|
||||
MACRO POP_REGS
|
||||
pop di
|
||||
pop si
|
||||
pop ds
|
||||
ENDM
|
||||
|
||||
;; EXTRN _esr_routine:FAR
|
||||
|
||||
PUBLIC _IPXinit;
|
||||
PUBLIC _IPXopen_socket;
|
||||
PUBLIC _IPXclose_socket;
|
||||
PUBLIC _IPXlisten;
|
||||
;; PUBLIC _asm_esr_routine;
|
||||
PUBLIC _xmemmove;
|
||||
PUBLIC _Net_Call;
|
||||
|
||||
DATASEG
|
||||
enterIPX DD FAR
|
||||
|
||||
CODESEG
|
||||
PROC _IPXinit;
|
||||
P_START
|
||||
PUSH_REGS
|
||||
mov ax, 7A00h
|
||||
int 2Fh
|
||||
cmp al, 0FFh
|
||||
jne @@fertig
|
||||
mov cx, @data
|
||||
mov ds, cx
|
||||
mov [WORD PTR enterIPX], di
|
||||
mov ax, es
|
||||
mov [WORD PTR enterIPX+2], ax
|
||||
mov al, 1 ; OK
|
||||
@@fertig:
|
||||
mov ah, 0
|
||||
POP_REGS
|
||||
P_END
|
||||
ret ; OK = 1 ; nicht ok = 0
|
||||
ENDP
|
||||
|
||||
PROC _xmemmove;
|
||||
ARG z:DATAPTR, q:DATAPTR, nmbr:WORD; Argumente
|
||||
cli ; Disable Interrupts
|
||||
push bp
|
||||
mov bp,sp
|
||||
mov cx, [nmbr];
|
||||
or cx, cx;
|
||||
jz @@fertig; Anzahl ist 0;
|
||||
push ds;
|
||||
push si;
|
||||
push di;
|
||||
pushf
|
||||
lds si, [q] ; Quelle
|
||||
les di, [z] ; Ziel
|
||||
cmp di, si ;
|
||||
jl @@L1 ; Ziel ist kleiner
|
||||
std ; Richtungsflag setzen
|
||||
dec cx
|
||||
add di, cx ; Von oben nach unten kopieren
|
||||
add si, cx ;
|
||||
inc cx ; alten Wert wiederherstellen
|
||||
jmp @@L2;
|
||||
@@L1:
|
||||
cld ; Richtungsflag loeschen
|
||||
@@L2: ; und nun das eigentliche kopieren
|
||||
REP movsb ;
|
||||
popf
|
||||
pop di;
|
||||
pop si;
|
||||
pop ds;
|
||||
@@fertig:
|
||||
pop bp;
|
||||
sti ; enable Interrupts
|
||||
ret
|
||||
ENDP
|
||||
|
||||
PROC _IPXopen_socket;
|
||||
ARG sock:WORD, live:WORD
|
||||
P_START
|
||||
PUSH_REGS
|
||||
mov ax, [live]
|
||||
mov dx, [sock]
|
||||
mov bx, @data
|
||||
mov ds, bx
|
||||
mov bx, 0
|
||||
call [enterIPX]
|
||||
cmp al, 0FFh
|
||||
jne @@L1
|
||||
mov ax, -1 ; Socket already open
|
||||
jmp @@L3
|
||||
@@L1:
|
||||
cmp al, 0FEh
|
||||
jne @@L2
|
||||
mov ax, -2 ; Socket Table full
|
||||
jmp @@L3
|
||||
@@L2:
|
||||
mov ax, dx
|
||||
@@L3:
|
||||
POP_REGS
|
||||
P_END
|
||||
ret
|
||||
ENDP
|
||||
|
||||
PROC _IPXclose_socket;
|
||||
ARG sock:WORD
|
||||
P_START
|
||||
PUSH_REGS
|
||||
mov dx, [sock]
|
||||
mov bx, @data
|
||||
mov ds, bx
|
||||
mov bx, 1
|
||||
call [enterIPX]
|
||||
POP_REGS
|
||||
P_END
|
||||
ret
|
||||
ENDP
|
||||
|
||||
PROC _IPXlisten;
|
||||
ARG ecb:DATAPTR
|
||||
P_START
|
||||
PUSH_REGS
|
||||
les si, [ecb] ; Adresse ecb
|
||||
mov bx, @data
|
||||
mov ds, bx
|
||||
mov bx, 4
|
||||
call [enterIPX]
|
||||
POP_REGS
|
||||
P_END
|
||||
mov ah, 0
|
||||
ret
|
||||
ENDP
|
||||
|
||||
;; PROC _asm_esr_routine;
|
||||
;; push bp;
|
||||
;; PUSH_REGS;
|
||||
;; mov ax, @data
|
||||
;; mov ds, ax ; F<>r C PROGRAMM
|
||||
;; push es; Adressegment vom EBC
|
||||
;; push si; Adressoffset vom ECB
|
||||
;; call _esr_routine; C ROUTINE
|
||||
;; pop si;
|
||||
;; pop es;
|
||||
;; POP_REGS;
|
||||
;; pop bp;
|
||||
;; cli ; no Interrupt says NOVELL
|
||||
;; ret
|
||||
;; ENDP
|
||||
|
||||
|
||||
PROC _Net_Call;
|
||||
ARG func:WORD, req:DATAPTR, repl:DATAPTR; Argumente
|
||||
push bp
|
||||
mov bp, sp
|
||||
mov ax, [func];
|
||||
push ds;
|
||||
push si;
|
||||
push di;
|
||||
pushf
|
||||
lds si, [req] ; Request
|
||||
les di, [repl] ; Reply
|
||||
int 21h
|
||||
popf
|
||||
pop di;
|
||||
pop si;
|
||||
pop ds;
|
||||
pop bp;
|
||||
mov ah, 0
|
||||
ret
|
||||
ENDP
|
||||
|
||||
END
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
/* kern.h Assembler Routinen 20-Nov-93 */
|
||||
extern int IPXinit(void);
|
||||
extern int IPXopen_socket(UI sock, int live);
|
||||
extern void IPXclose_socket(UI sock);
|
||||
extern int IPXlisten(ECB *ecb);
|
||||
extern void asm_esr_routine(void);
|
||||
extern void esr_routine(ECB *ecb);
|
||||
extern void xmemmove(void *ziel, void *quelle, UI anz);
|
||||
extern int Net_Call(UI func, void *req, void *repl);
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,317 @@
|
|||
Turbo Assembler Version 3.1 28/04/96 13:28:50 Page 1
|
||||
kern.asm
|
||||
|
||||
|
||||
|
||||
1 ; kern.asm: 20-Nov-93, 21:52
|
||||
2 IDEAL
|
||||
3 P286
|
||||
4 0000 MODEL LARGE
|
||||
5 ; Fuer Turboc gerettet werden muessen folgende Register:
|
||||
6 ; BP, SS, SP, DS, CS u. SI, DI
|
||||
7
|
||||
8 MACRO P_START
|
||||
9 push bp
|
||||
10 mov bp, sp
|
||||
11 ENDM
|
||||
12
|
||||
13 MACRO P_END
|
||||
14 pop bp
|
||||
15 ENDM
|
||||
16
|
||||
17 MACRO PUSH_REGS
|
||||
18 push ds
|
||||
19 push si
|
||||
20 push di
|
||||
21 ENDM
|
||||
22
|
||||
23 MACRO POP_REGS
|
||||
24 pop di
|
||||
25 pop si
|
||||
26 pop ds
|
||||
27 ENDM
|
||||
28
|
||||
29 ;; EXTRN _esr_routine:FAR
|
||||
30
|
||||
31 PUBLIC _IPXinit;
|
||||
32 PUBLIC _IPXopen_socket;
|
||||
33 PUBLIC _IPXclose_socket;
|
||||
34 PUBLIC _IPXlisten;
|
||||
35 ;; PUBLIC _asm_esr_routine;
|
||||
36 PUBLIC _xmemmove;
|
||||
37 PUBLIC _Net_Call;
|
||||
38
|
||||
39 0000 DATASEG
|
||||
40 0000 0000FFFE enterIPX DD FAR
|
||||
41
|
||||
42 0004 CODESEG
|
||||
43 0000 PROC _IPXinit;
|
||||
44 P_START
|
||||
1 45 0000 55 push bp
|
||||
1 46 0001 8B EC mov bp, sp
|
||||
47 PUSH_REGS
|
||||
1 48 0003 1E push ds
|
||||
1 49 0004 56 push si
|
||||
1 50 0005 57 push di
|
||||
51 0006 B8 7A00 mov ax, 7A00h
|
||||
52 0009 CD 2F int 2Fh
|
||||
53 000B 3C FF cmp al, 0FFh
|
||||
54 000D 75 10 jne @@fertig
|
||||
55 000F B9 0000s mov cx, @data
|
||||
56 0012 8E D9 mov ds, cx
|
||||
57 0014 89 3E 0000r mov [WORD PTR enterIPX], di
|
||||
Turbo Assembler Version 3.1 28/04/96 13:28:50 Page 2
|
||||
kern.asm
|
||||
|
||||
|
||||
|
||||
58 0018 8C C0 mov ax, es
|
||||
59 001A A3 0002r mov [WORD PTR enterIPX+2], ax
|
||||
60 001D B0 01 mov al, 1 ; OK
|
||||
61 001F @@fertig:
|
||||
62 001F B4 00 mov ah, 0
|
||||
63 POP_REGS
|
||||
1 64 0021 5F pop di
|
||||
1 65 0022 5E pop si
|
||||
1 66 0023 1F pop ds
|
||||
67 P_END
|
||||
1 68 0024 5D pop bp
|
||||
69 0025 CB ret ; OK = 1 ; nicht ok = 0
|
||||
70 0026 ENDP
|
||||
71
|
||||
72 0026 PROC _xmemmove;
|
||||
73 ARG z:DATAPTR, q:DATAPTR, nmbr:WORD; Argumente
|
||||
74 0026 FA cli ; Disable Interrupts
|
||||
75 0027 55 push bp
|
||||
76 0028 8B EC mov bp,sp
|
||||
77 002A 8B 4E 0E mov cx, [nmbr];
|
||||
78 002D 0B C9 or cx, cx;
|
||||
79 002F 74 1F jz @@fertig; Anzahl ist 0;
|
||||
80 0031 1E push ds;
|
||||
81 0032 56 push si;
|
||||
82 0033 57 push di;
|
||||
83 0034 9C pushf
|
||||
84 0035 C5 76 0A lds si, [q] ; Quelle
|
||||
85 0038 C4 7E 06 les di, [z] ; Ziel
|
||||
86 003B 3B FE cmp di, si ;
|
||||
87 003D 7C 0A jl @@L1 ; Ziel ist kleiner
|
||||
88 003F FD std ; Richtungsflag setzen
|
||||
89 0040 49 dec cx
|
||||
90 0041 03 F9 add di, cx ; Von oben nach unten kopieren
|
||||
91 0043 03 F1 add si, cx ;
|
||||
92 0045 41 inc cx ; alten Wert wiederherstellen
|
||||
93 0046 EB 02 90 jmp @@L2;
|
||||
94 0049 @@L1:
|
||||
95 0049 FC cld ; Richtungsflag loeschen
|
||||
96 004A @@L2: ; und nun das eigentliche kopieren
|
||||
97 004A F3> A4 REP movsb ;
|
||||
98 004C 9D popf
|
||||
99 004D 5F pop di;
|
||||
100 004E 5E pop si;
|
||||
101 004F 1F pop ds;
|
||||
102 0050 @@fertig:
|
||||
103 0050 5D pop bp;
|
||||
104 0051 FB sti ; enable Interrupts
|
||||
105 0052 CB ret
|
||||
106 0053 ENDP
|
||||
107
|
||||
108 0053 PROC _IPXopen_socket;
|
||||
109 ARG sock:WORD, live:WORD
|
||||
110 P_START
|
||||
1 111 0053 55 push bp
|
||||
1 112 0054 8B EC mov bp, sp
|
||||
113 PUSH_REGS
|
||||
1 114 0056 1E push ds
|
||||
Turbo Assembler Version 3.1 28/04/96 13:28:50 Page 3
|
||||
kern.asm
|
||||
|
||||
|
||||
|
||||
1 115 0057 56 push si
|
||||
1 116 0058 57 push di
|
||||
117 0059 8B 46 08 mov ax, [live]
|
||||
118 005C 8B 56 06 mov dx, [sock]
|
||||
119 005F BB 0000s mov bx, @data
|
||||
120 0062 8E DB mov ds, bx
|
||||
121 0064 BB 0000 mov bx, 0
|
||||
122 0067 FF 1E 0000r call [enterIPX]
|
||||
123 006B 3C FF cmp al, 0FFh
|
||||
124 006D 75 06 jne @@L1
|
||||
125 006F B8 FFFF mov ax, -1 ; Socket already open
|
||||
126 0072 EB 0D 90 jmp @@L3
|
||||
127 0075 @@L1:
|
||||
128 0075 3C FE cmp al, 0FEh
|
||||
129 0077 75 06 jne @@L2
|
||||
130 0079 B8 FFFE mov ax, -2 ; Socket Table full
|
||||
131 007C EB 03 90 jmp @@L3
|
||||
132 007F @@L2:
|
||||
133 007F 8B C2 mov ax, dx
|
||||
134 0081 @@L3:
|
||||
135 POP_REGS
|
||||
1 136 0081 5F pop di
|
||||
1 137 0082 5E pop si
|
||||
1 138 0083 1F pop ds
|
||||
139 P_END
|
||||
1 140 0084 5D pop bp
|
||||
141 0085 CB ret
|
||||
142 0086 ENDP
|
||||
143
|
||||
144 0086 PROC _IPXclose_socket;
|
||||
145 ARG sock:WORD
|
||||
146 P_START
|
||||
1 147 0086 55 push bp
|
||||
1 148 0087 8B EC mov bp, sp
|
||||
149 PUSH_REGS
|
||||
1 150 0089 1E push ds
|
||||
1 151 008A 56 push si
|
||||
1 152 008B 57 push di
|
||||
153 008C 8B 56 06 mov dx, [sock]
|
||||
154 008F BB 0000s mov bx, @data
|
||||
155 0092 8E DB mov ds, bx
|
||||
156 0094 BB 0001 mov bx, 1
|
||||
157 0097 FF 1E 0000r call [enterIPX]
|
||||
158 POP_REGS
|
||||
1 159 009B 5F pop di
|
||||
1 160 009C 5E pop si
|
||||
1 161 009D 1F pop ds
|
||||
162 P_END
|
||||
1 163 009E 5D pop bp
|
||||
164 009F CB ret
|
||||
165 00A0 ENDP
|
||||
166
|
||||
167 00A0 PROC _IPXlisten;
|
||||
168 ARG ecb:DATAPTR
|
||||
169 P_START
|
||||
1 170 00A0 55 push bp
|
||||
1 171 00A1 8B EC mov bp, sp
|
||||
Turbo Assembler Version 3.1 28/04/96 13:28:50 Page 4
|
||||
kern.asm
|
||||
|
||||
|
||||
|
||||
172 PUSH_REGS
|
||||
1 173 00A3 1E push ds
|
||||
1 174 00A4 56 push si
|
||||
1 175 00A5 57 push di
|
||||
176 00A6 C4 76 06 les si, [ecb] ; Adresse ecb
|
||||
177 00A9 BB 0000s mov bx, @data
|
||||
178 00AC 8E DB mov ds, bx
|
||||
179 00AE BB 0004 mov bx, 4
|
||||
180 00B1 FF 1E 0000r call [enterIPX]
|
||||
181 POP_REGS
|
||||
1 182 00B5 5F pop di
|
||||
1 183 00B6 5E pop si
|
||||
1 184 00B7 1F pop ds
|
||||
185 P_END
|
||||
1 186 00B8 5D pop bp
|
||||
187 00B9 B4 00 mov ah, 0
|
||||
188 00BB CB ret
|
||||
189 00BC ENDP
|
||||
190
|
||||
191 ;; PROC _asm_esr_routine;
|
||||
192 ;; push bp;
|
||||
193 ;; PUSH_REGS;
|
||||
194 ;; mov ax, @data
|
||||
195 ;; mov ds, ax ; F<>r C PROGRAMM
|
||||
196 ;; push es; Adressegment vom EBC
|
||||
197 ;; push si; Adressoffset vom ECB
|
||||
198 ;; call _esr_routine; C ROUTINE
|
||||
199 ;; pop si;
|
||||
200 ;; pop es;
|
||||
201 ;; POP_REGS;
|
||||
202 ;; pop bp;
|
||||
203 ;; cli ; no Interrupt says NOVELL
|
||||
204 ;; ret
|
||||
205 ;; ENDP
|
||||
206
|
||||
207
|
||||
208 00BC PROC _Net_Call;
|
||||
209 ARG func:WORD, req:DATAPTR, repl:DATAPTR; Argumente
|
||||
210 00BC 55 push bp
|
||||
211 00BD 8B EC mov bp, sp
|
||||
212 00BF 8B 46 06 mov ax, [func];
|
||||
213 00C2 1E push ds;
|
||||
214 00C3 56 push si;
|
||||
215 00C4 57 push di;
|
||||
216 00C5 9C pushf
|
||||
217 00C6 C5 76 08 lds si, [req] ; Request
|
||||
218 00C9 C4 7E 0C les di, [repl] ; Reply
|
||||
219 00CC CD 21 int 21h
|
||||
220 00CE 9D popf
|
||||
221 00CF 5F pop di;
|
||||
222 00D0 5E pop si;
|
||||
223 00D1 1F pop ds;
|
||||
224 00D2 5D pop bp;
|
||||
225 00D3 B4 00 mov ah, 0
|
||||
226 00D5 CB ret
|
||||
227 00D6 ENDP
|
||||
228
|
||||
Turbo Assembler Version 3.1 28/04/96 13:28:50 Page 5
|
||||
kern.asm
|
||||
|
||||
|
||||
|
||||
229 END
|
||||
Turbo Assembler Version 3.1 28/04/96 13:28:50 Page 6
|
||||
Symbol Table
|
||||
|
||||
|
||||
|
||||
|
||||
Symbol Name Type Value
|
||||
|
||||
??DATE Text "28/04/96"
|
||||
??FILENAME Text "kern "
|
||||
??TIME Text "13:28:50"
|
||||
??VERSION Number 030A
|
||||
@32BIT Text 0
|
||||
@@FERTIG Near KERN_TEXT:001F
|
||||
@@FERTIG Near KERN_TEXT:0050
|
||||
@@L1 Near KERN_TEXT:0049
|
||||
@@L1 Near KERN_TEXT:0075
|
||||
@@L2 Near KERN_TEXT:004A
|
||||
@@L2 Near KERN_TEXT:007F
|
||||
@@L3 Near KERN_TEXT:0081
|
||||
@CODE Text KERN_TEXT
|
||||
@CODESIZE Text 1
|
||||
@CPU Text 0787H
|
||||
@CURSEG Text KERN_TEXT
|
||||
@DATA Text DGROUP
|
||||
@DATASIZE Text 1
|
||||
@FILENAME Text KERN
|
||||
@INTERFACE Text 00H
|
||||
@MODEL Text 5
|
||||
@STACK Text DGROUP
|
||||
@WORDSIZE Text 2
|
||||
ECB Number [DGROUP:BP+0006]
|
||||
ENTERIPX Dword DGROUP:0000
|
||||
FUNC Number [DGROUP:BP+0006]
|
||||
LIVE Number [DGROUP:BP+0008]
|
||||
NMBR Number [DGROUP:BP+000E]
|
||||
Q Number [DGROUP:BP+000A]
|
||||
REPL Number [DGROUP:BP+000C]
|
||||
REQ Number [DGROUP:BP+0008]
|
||||
SOCK Number [DGROUP:BP+0006]
|
||||
Z Number [DGROUP:BP+0006]
|
||||
_IPXCLOSE_SOCKET + Far KERN_TEXT:0086
|
||||
(_IPXclose_socket)
|
||||
_IPXINIT (_IPXinit) Far KERN_TEXT:0000
|
||||
_IPXLISTEN (_IPXlisten) Far KERN_TEXT:00A0
|
||||
_IPXOPEN_SOCKET + Far KERN_TEXT:0053
|
||||
(_IPXopen_socket)
|
||||
_NET_CALL (_Net_Call) Far KERN_TEXT:00BC
|
||||
_XMEMMOVE (_xmemmove) Far KERN_TEXT:0026
|
||||
|
||||
Macro Name
|
||||
|
||||
POP_REGS
|
||||
PUSH_REGS
|
||||
P_END
|
||||
P_START
|
||||
|
||||
Groups & Segments Bit Size Align Combine Class
|
||||
|
||||
DGROUP Group
|
||||
_DATA 16 0004 Word Public DATA
|
||||
KERN_TEXT 16 00D6 Word Public CODE
|
||||
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
c:\net logout
|
||||
c:\net login %1 %2 %3
|
||||
map h:=HOME:
|
||||
|
||||
|
|
@ -0,0 +1,215 @@
|
|||
/* login.c 05-Apr-96 */
|
||||
|
||||
/****************************************************************
|
||||
* (C)opyright (C) 1993,1996 Martin Stover, Marburg, Germany *
|
||||
****************************************************************/
|
||||
|
||||
#include "net.h"
|
||||
#include "nwcrypt.h"
|
||||
|
||||
|
||||
static int do_change_object_passwd(char *name,
|
||||
uint16 objtyp,
|
||||
char *oldpassword,
|
||||
char *newpassword)
|
||||
|
||||
{
|
||||
uint8 key[8];
|
||||
if (0 && !ncp_17_17(key)) {
|
||||
uint32 objid = ncp_17_35(name, objtyp);
|
||||
if (objid) {
|
||||
uint8 buff[128];
|
||||
uint8 encrypted[8];
|
||||
uint8 newcryptpasswd[16];
|
||||
int passwdx=0;
|
||||
uint8 tmpid[4];
|
||||
U32_TO_BE32(objid, tmpid);
|
||||
shuffle(tmpid, oldpassword, strlen(oldpassword), buff);
|
||||
nw_encrypt(key, buff, encrypted);
|
||||
|
||||
shuffle(tmpid, newpassword, strlen(newpassword), buff);
|
||||
|
||||
if (!ncp_17_4b(encrypted, name, objtyp, passwdx, newcryptpasswd)) {
|
||||
;;
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
} else { /* now we use old unencrypted algorithmus */
|
||||
if (!ncp_17_40(name, objtyp, oldpassword, newpassword)) {
|
||||
;;
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
return(-1);
|
||||
}
|
||||
|
||||
static int do_object_login(char *name, uint16 objtyp, char *password, int option)
|
||||
{
|
||||
uint8 key[8];
|
||||
if (!(option & 1) && !ncp_17_17(key)) {
|
||||
uint32 objid = ncp_17_35(name, objtyp);
|
||||
if (objid) {
|
||||
uint8 buff[128];
|
||||
uint8 encrypted[8];
|
||||
uint8 tmpid[4];
|
||||
U32_TO_BE32(objid, tmpid);
|
||||
shuffle(tmpid, password, strlen(password), buff);
|
||||
nw_encrypt(key, buff, encrypted);
|
||||
if (!ncp_17_18(encrypted, name, objtyp)) {
|
||||
;;
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
} else { /* now we use old unencrypted algorithmus */
|
||||
if (!ncp_17_14(name, objtyp, password)) {
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
return(-1);
|
||||
}
|
||||
|
||||
static void beep(void)
|
||||
{
|
||||
fprintf(stdout, "\007");
|
||||
}
|
||||
|
||||
static int get_raw_str(uint8 *s, int maxlen, int doecho)
|
||||
/* returns len of readed str */
|
||||
{
|
||||
int len = 0;
|
||||
while (len < maxlen){
|
||||
int key = getch();
|
||||
if (key == '\r' || key == '\n') break;
|
||||
switch (key) {
|
||||
case 8 : if (len) {
|
||||
--len;
|
||||
--s;
|
||||
if (doecho) fprintf(stdout, "\010 \010");
|
||||
} else beep();
|
||||
continue;
|
||||
|
||||
case '\t': beep();
|
||||
continue;
|
||||
|
||||
default : *s++=(uint8)key;
|
||||
len++;
|
||||
break;
|
||||
} /* switch */
|
||||
if (doecho) fprintf(stdout, "%c", (uint8)key);
|
||||
}
|
||||
*s='\0';
|
||||
return(len);
|
||||
}
|
||||
|
||||
static void getstr(char *what, char *str, int rsize, int doecho)
|
||||
{
|
||||
fprintf(stdout, "%s: ", what);
|
||||
get_raw_str(str, rsize, doecho);
|
||||
fprintf(stdout, "\n");
|
||||
}
|
||||
|
||||
static int login_usage(void)
|
||||
{
|
||||
fprintf(stderr, "usage:\t%s [-u] [user | user password]\n", funcname);
|
||||
fprintf(stderr, "\t-u : use unecrypted password\n" );
|
||||
return(-1);
|
||||
}
|
||||
|
||||
int func_login(int argc, char *argv[])
|
||||
{
|
||||
int result=-1;
|
||||
int option=0;
|
||||
uint8 uname[200];
|
||||
uint8 upasswd[200];
|
||||
|
||||
if (argc > 1) {
|
||||
if (argv[1][0] == '-') {
|
||||
if (argv[1][1] == 'u') option |= 1;
|
||||
else return(login_usage());
|
||||
argc--;
|
||||
argv++;
|
||||
}
|
||||
}
|
||||
|
||||
if (argc > 1) strmaxcpy(uname, argv[1], sizeof(uname) -1);
|
||||
else uname[0]='\0';
|
||||
if (argc > 2) strmaxcpy(upasswd, argv[2], sizeof(upasswd) -1);
|
||||
else upasswd[0]='\0';
|
||||
while (result) {
|
||||
if (!uname[0]) getstr("login", uname, sizeof(uname)-1, 1);
|
||||
if (uname[0]) {
|
||||
upstr(uname);
|
||||
upstr(upasswd);
|
||||
if ((result = do_object_login(uname, 0x1, upasswd, option)) < 0 && !*upasswd) {
|
||||
getstr("Password", upasswd, sizeof(upasswd)-1, 0);
|
||||
upstr(upasswd);
|
||||
result = do_object_login(uname, 0x1, upasswd, option);
|
||||
}
|
||||
if (result < 0) {
|
||||
fprintf(stdout, "Login incorrect\n\n");
|
||||
uname[0] = '\0';
|
||||
upasswd[0] = '\0';
|
||||
}
|
||||
} else break;
|
||||
}
|
||||
return(result);
|
||||
}
|
||||
|
||||
int func_logout(int argc, char *argv[])
|
||||
{
|
||||
if (logout()) fprintf(stderr, "logout=%d", neterrno);
|
||||
}
|
||||
|
||||
|
||||
int func_passwd(int argc, char *argv[])
|
||||
{
|
||||
int result=0;
|
||||
uint8 uname[100];
|
||||
uint8 upasswd[130];
|
||||
uint32 my_obj_id;
|
||||
|
||||
if (ncp_14_46(&my_obj_id) < 0 || my_obj_id == MAX_U32 || !my_obj_id) {
|
||||
fprintf(stderr, "Cannot get actual User ID\n");
|
||||
result = -1;
|
||||
}
|
||||
|
||||
if (!result && argc > 1) {
|
||||
uint32 obj_id;
|
||||
strmaxcpy(uname, argv[1], sizeof(uname) -1);
|
||||
upstr(uname);
|
||||
obj_id = ncp_17_35(uname, 1);
|
||||
if (!obj_id) {
|
||||
fprintf(stderr, "Unkwown User: %s\n", uname);
|
||||
return(-1);
|
||||
}
|
||||
} else if (!result) {
|
||||
uint16 obj_typ;
|
||||
if (ncp_17_36(my_obj_id, uname, &obj_typ) || obj_typ != 1) {
|
||||
fprintf(stderr, "Cannot get actual Username\n");
|
||||
result=-1;
|
||||
}
|
||||
}
|
||||
if (!result && *uname) {
|
||||
uint8 newpasswd[130];
|
||||
uint8 newpasswd2[130];
|
||||
if (my_obj_id == 1L) *upasswd='\0';
|
||||
else {
|
||||
getstr("Old Password", upasswd, sizeof(upasswd)-1, 0);
|
||||
upstr(upasswd);
|
||||
}
|
||||
getstr("New Password", newpasswd, sizeof(newpasswd)-1, 0);
|
||||
getstr("New Password again", newpasswd2, sizeof(newpasswd2)-1, 0);
|
||||
if (!strcmp(newpasswd, newpasswd2)) {
|
||||
upstr(uname);
|
||||
upstr(newpasswd);
|
||||
if (do_change_object_passwd(uname, 1, upasswd, newpasswd) < 0)
|
||||
result = -1;
|
||||
} else {
|
||||
result = -1;
|
||||
fprintf(stderr, "Password misspelled\n");
|
||||
}
|
||||
}
|
||||
if (result < 0) fprintf(stderr, "Password not changed");
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
# makefile DOS BCC for simple NET Client for mars_nwe.
|
||||
# /****************************************************************
|
||||
# * (C)opyright (C) 1993,1996 Martin Stover, Marburg, Germany *
|
||||
# ****************************************************************/
|
||||
|
||||
O = .obj
|
||||
E = .exe
|
||||
A = .lib
|
||||
S = .asm
|
||||
C = .c
|
||||
|
||||
INCLUDE=$(BC4)\INCLUDE
|
||||
LIB=$(BC4)\LIB
|
||||
CC=bcc -ml -Dmsdos -I$(INCLUDE)
|
||||
LD=bcc -ml -L$(LIB)
|
||||
ASFLAGS= -la -mx
|
||||
AS = tasm
|
||||
AR = tlib
|
||||
RM = del
|
||||
|
||||
ASMODS= kern$(O)
|
||||
CCMODS= tools$(O) netcall$(O) ncpcall$(O) \
|
||||
login$(O) map$(O) slist$(O) nwcrypt$(O) \
|
||||
nwdebug$(O) nwtests$(O)
|
||||
|
||||
all: net$(E)
|
||||
|
||||
net$(E): net$(O) $(ASMODS) $(CCMODS)
|
||||
$(LD) net$(O) @&&|
|
||||
$(ASMODS)
|
||||
$(CCMODS)
|
||||
|
|
||||
|
||||
$(C)$(O):
|
||||
$(CC) -c $*$(C)
|
||||
|
||||
$(S)$(O):
|
||||
$(AS) $(ASFLAGS) $*$(S)
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,252 @@
|
|||
/* map.c 05-Apr-96 */
|
||||
|
||||
/****************************************************************
|
||||
* (C)opyright (C) 1993,1996 Martin Stover, Marburg, Germany *
|
||||
****************************************************************/
|
||||
|
||||
#include "net.h"
|
||||
|
||||
typedef struct {
|
||||
uint8 connection;
|
||||
uint8 volume;
|
||||
uint8 buff[512]; /* complete path */
|
||||
uint8 *path; /* points to path */
|
||||
} NWPATH;
|
||||
|
||||
static void show_map(uint8 *drvstr)
|
||||
{
|
||||
int j;
|
||||
for (j=0; j < 32; j++){
|
||||
uint8 connid;
|
||||
uint8 dhandle;
|
||||
uint8 flags;
|
||||
if (*drvstr && (j + 'A' != *drvstr)) continue;
|
||||
if ((!get_drive_info(j, &connid, &dhandle, &flags)) && flags){
|
||||
char servern[52];
|
||||
char path[256];
|
||||
if (flags & 0x80) { /* lokal DRIVE */
|
||||
path[0]= '\\';
|
||||
if (j < 2){
|
||||
strcpy(path, "DISK LW");
|
||||
} else if (getcurdir(j+1, path+1)) {
|
||||
strcpy(path, "LW !OK");
|
||||
}
|
||||
} else {
|
||||
if (get_dir_path(dhandle, path)) {
|
||||
strcpy(path, "DHANDLE !OK");
|
||||
}
|
||||
}
|
||||
if (connid) {
|
||||
get_fs_name(connid, servern);
|
||||
strcat(servern, "\\");
|
||||
} else servern[0]='\0';
|
||||
printf("MAP %c: = %s%s\n", (char)j+'A', servern, path);
|
||||
}
|
||||
}
|
||||
}
|
||||
#if 0
|
||||
static void do_map(int drive, NWPATH *nwp)
|
||||
{
|
||||
if (drive > -1 && drive < 32) {
|
||||
uint8 connid;
|
||||
uint8 dhandle;
|
||||
uint8 flags;
|
||||
if ((!get_drive_info(drive, &connid, &dhandle, &flags)) && flags){
|
||||
char servern[52];
|
||||
char path[256];
|
||||
if (flags & 0x80) { /* lokal DRIVE */
|
||||
path[0]= '\\';
|
||||
if (drive < 2){
|
||||
strcpy(path, "DISK LW");
|
||||
} else if (getcurdir(drive+1, path+1)) {
|
||||
strcpy(path, "LW !OK");
|
||||
}
|
||||
} else {
|
||||
if (get_dir_path(dhandle, path)) {
|
||||
strcpy(path, "DHANDLE !OK");
|
||||
}
|
||||
}
|
||||
if (connid) {
|
||||
get_fs_name(connid, servern);
|
||||
strcat(servern, "\\");
|
||||
} else servern[0]='\0';
|
||||
printf("DOMAP %c: = %s%s\n", (char)drive+'A', servern, path);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static int do_map(int drive, NWPATH *nwp)
|
||||
{
|
||||
int result = -1;
|
||||
if (drive > -1 && drive < 32) {
|
||||
uint8 nmdrive[3];
|
||||
nmdrive[0] = drive+'A';
|
||||
nmdrive[1] = ':';
|
||||
nmdrive[2] = '\0';
|
||||
result = redir_device_drive(0x4, nmdrive, nwp->path);
|
||||
}
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
static int parse_argv(uint8 *drvstr, NWPATH *nwpath,
|
||||
int argc, char *argv[], int smode)
|
||||
{
|
||||
int k = 0;
|
||||
int mode = 0;
|
||||
uint8 *pd = drvstr;
|
||||
*drvstr = '\0';
|
||||
memset(nwpath, 0, sizeof(NWPATH));
|
||||
*(nwpath->buff) = '\0';
|
||||
nwpath->path = nwpath->buff;
|
||||
|
||||
while (++k < argc && mode > -1) {
|
||||
uint8 *p = argv[k];
|
||||
while (*p && mode > -1) {
|
||||
if (!mode) {
|
||||
if (*p == ':') mode = -1;
|
||||
else if (smode && *p != 's' && *p != 'S') mode = -1;
|
||||
}
|
||||
if (mode < 0) break;
|
||||
else if (mode < 20) {
|
||||
if (*p == ':') {
|
||||
if (!mode || (mode > 1 && (*drvstr != 'S' || !smode)))
|
||||
mode = -1;
|
||||
else {
|
||||
*pd = '\0';
|
||||
if (mode > 1) {
|
||||
*drvstr='s';
|
||||
*(drvstr+1)=(uint8) atoi((char*)drvstr+1);
|
||||
}
|
||||
mode = 20;
|
||||
pd = nwpath->buff;
|
||||
}
|
||||
} else {
|
||||
if (++mode == 20) mode = -1;
|
||||
else {
|
||||
if (*p > 0x60 && *p < 0x7b)
|
||||
*pd++ = *p - 0x20; /* upshift */
|
||||
else
|
||||
*pd++ = *p;
|
||||
}
|
||||
}
|
||||
} else if (mode == 20) {
|
||||
if (*p == '=') mode = 30;
|
||||
else if (*p != ' ' && *p != '\t') mode = -2;
|
||||
} else if (mode == 30) {
|
||||
if (*p != ' ' && *p != '\t') {
|
||||
mode = 40;
|
||||
continue;
|
||||
}
|
||||
} else if (mode == 40) {
|
||||
if (*p > 0x60 && *p < 0x7b)
|
||||
*pd++ = *p - 0x20; /* upshift */
|
||||
else
|
||||
*pd++ = *p;
|
||||
}
|
||||
p++;
|
||||
} /* while *p */
|
||||
} /* while k */
|
||||
if (mode == 30) {
|
||||
getcwd((char *)nwpath->buff, sizeof(nwpath->buff));
|
||||
mode = 40;
|
||||
}
|
||||
if (mode && mode != 20 && mode != 40) {
|
||||
fprintf(stderr, "Cannot interpret line. errcode=%d\n", mode);
|
||||
return(mode < 0 ? mode : -3);
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
||||
int func_map(int argc, char *argv[])
|
||||
{
|
||||
uint8 drvstr[22];
|
||||
NWPATH nwpath;
|
||||
if (!ipx_init()) argc = 1;
|
||||
if (!parse_argv(drvstr, &nwpath, argc, argv, 0)) {
|
||||
if (*(nwpath.path)) {
|
||||
if (do_map(*drvstr - 'A', &nwpath)< 0)
|
||||
fprintf(stderr, "MAP Error\n");
|
||||
}
|
||||
show_map(drvstr);
|
||||
return(0);
|
||||
}
|
||||
return(1);
|
||||
}
|
||||
/* ------------------------------------------------- */
|
||||
static int show_search(uint8 *drvstr)
|
||||
{
|
||||
SEARCH_VECTOR drives;
|
||||
SEARCH_VECTOR_ENTRY *p=drives;
|
||||
int j=0;
|
||||
get_search_drive_vektor(drives);
|
||||
while (p->drivenummer != 0xff && j++ < 16) {
|
||||
char path[256];
|
||||
char nwname[256];
|
||||
if ( !*drvstr || j == *(drvstr+1)) {
|
||||
if (p->flags && !(p->flags & 0x80)){
|
||||
get_fs_name(p->u.fs.connid, nwname);
|
||||
if (get_dir_path(p->u.fs.dhandle, path)) {
|
||||
strcpy(path, "ERROR NW");
|
||||
}
|
||||
(void)xadd_char(nwname, '\\', 20);
|
||||
} else {
|
||||
nwname[0] = '\0';
|
||||
/*
|
||||
nwname[0] = '<';
|
||||
strcpy(nwname+1, "LOCAL");
|
||||
*/
|
||||
if (p->drivenummer == 0xfe){
|
||||
strcpy(path, p->u.d.dospath);
|
||||
} else if (getcurdir((int)(p->drivenummer)+1, path)) {
|
||||
strcpy(path, "ERROR DOS");
|
||||
}
|
||||
/*
|
||||
(void)xadd_char(nwname, '>', 20);
|
||||
*/
|
||||
}
|
||||
strcat(nwname, path);
|
||||
printf("SEARCH%2d = %c: %s\n", j, (char)(p->drivenummer)+'A', nwname);
|
||||
}
|
||||
p++;
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
||||
static int set_search(uint8 *drvstr, NWPATH *nwp)
|
||||
{
|
||||
int result=-1;
|
||||
SEARCH_VECTOR drives;
|
||||
SEARCH_VECTOR_ENTRY *p=drives;
|
||||
int j=0;
|
||||
int entry = (*drvstr=='s') ? *(drvstr+1) : 0;
|
||||
get_search_drive_vektor(drives);
|
||||
while (p->drivenummer != 0xff && j++ < 16) {
|
||||
if (!entry && (p->drivenummer + 'A' == *drvstr)) entry=j;
|
||||
p++;
|
||||
}
|
||||
if (entry > 0) {
|
||||
if (entry > 16) entry = 16;
|
||||
if (--entry < j) p = drives+entry;
|
||||
else (p+1)->drivenummer = 0xff;
|
||||
p->drivenummer = 0xfe;
|
||||
strcpy(p->u.d.dospath, nwp->path);
|
||||
result = set_search_drive_vektor(drives);
|
||||
}
|
||||
return(result);
|
||||
}
|
||||
|
||||
int func_path(int argc, char *argv[])
|
||||
{
|
||||
uint8 drvstr[22];
|
||||
NWPATH nwpath;
|
||||
if (!parse_argv(drvstr, &nwpath, argc, argv, 1)) {
|
||||
int result=0;
|
||||
if (*(nwpath.path)) result=set_search(drvstr, &nwpath);
|
||||
show_search(drvstr);
|
||||
return(result);
|
||||
}
|
||||
return(1);
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
maker %1 %2 %3 %4 > err
|
||||
type err
|
||||
copy net.exe c:\
|
||||
del net.exe
|
||||
|
|
@ -0,0 +1,285 @@
|
|||
/* ncpcall.c 14-Mar-96 */
|
||||
|
||||
/****************************************************************
|
||||
* (C)opyright (C) 1993,1996 Martin Stover, Marburg, Germany *
|
||||
****************************************************************/
|
||||
|
||||
#include "net.h"
|
||||
|
||||
/* ---------------- 0x16 ----------------------------------- */
|
||||
int ncp_16_02(int dirhandle,
|
||||
uint8 *path,
|
||||
int *sub_dir,
|
||||
uint8 *resultpath,
|
||||
uint32 *creattime,
|
||||
uint32 *owner_id)
|
||||
|
||||
/* returns max. rights or -1 if failed */
|
||||
{
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 func;
|
||||
uint8 dirhandle;
|
||||
uint8 sub_dir[2];
|
||||
uint8 pathlen;
|
||||
uint8 path[256];
|
||||
} req;
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 sub_dir_name[16];
|
||||
uint8 create_date_time[4];
|
||||
uint8 owner_id[4]; /* HI LOW */
|
||||
uint8 max_right_mask;
|
||||
uint8 reserved; /* Reserved by Novell */
|
||||
uint8 sub_dir_nmbr[2]; /* HI LOW */
|
||||
} repl = { sizeof(repl) - sizeof(uint16) };
|
||||
req.func = 0x02;
|
||||
U16_TO_BE16((sub_dir) ? *sub_dir : 1, req.sub_dir);
|
||||
req.dirhandle = (uint8) dirhandle;
|
||||
req.pathlen = (uint8) ((path) ? strlen(path) : 0);
|
||||
req.len = 5 + req.pathlen;
|
||||
strmaxcpy(req.path, path, req.pathlen);
|
||||
neterrno = Net_Call(0xE200, &req, &repl);
|
||||
if (neterrno) return(-1);
|
||||
if (resultpath) strmaxcpy(resultpath, repl.sub_dir_name, 16);
|
||||
if (sub_dir) *sub_dir = GET_BE16(repl.sub_dir_nmbr);
|
||||
if (creattime) *creattime = GET_BE32(repl.create_date_time);
|
||||
if (owner_id) *owner_id = GET_BE32(repl.owner_id);
|
||||
return((int) repl.max_right_mask);
|
||||
}
|
||||
|
||||
/* ---------------- 0x17 ----------------------------------- */
|
||||
int ncp_17_02(int module, int debuglevel)
|
||||
/* debuglevel fuer module setzen */
|
||||
{
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 func;
|
||||
uint8 module;
|
||||
uint8 debug;
|
||||
} req = { sizeof(req) - sizeof(uint16) };
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 olddebug;
|
||||
} repl = { sizeof(repl) - sizeof(uint16) };
|
||||
req.func = 0x2;
|
||||
req.module = (uint8) module;
|
||||
req.debug = (uint8) debuglevel;
|
||||
neterrno = Net_Call(0xE300, &req, &repl);
|
||||
if (neterrno) return(-1);
|
||||
return((int) repl.olddebug);
|
||||
}
|
||||
|
||||
int ncp_17_14(uint8 *objname, uint16 objtyp, uint8 *password)
|
||||
/* login unencreypted */
|
||||
{
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 func;
|
||||
uint8 typ[2];
|
||||
uint8 namlen;
|
||||
uint8 buff[48+1+128];
|
||||
} req;
|
||||
struct {
|
||||
uint16 len;
|
||||
} repl= { 0 };
|
||||
uint8 *p=req.buff;
|
||||
req.func = 0x14;
|
||||
U16_TO_BE16(objtyp, req.typ);
|
||||
req.namlen = min(47, strlen(objname));
|
||||
memcpy(p, objname, req.namlen);
|
||||
p += req.namlen;
|
||||
*p = (uint8) min(128, strlen(password));
|
||||
req.len = 4 + req.namlen + 1 + *p;
|
||||
memcpy(p+1, password, (int) *p);
|
||||
neterrno = Net_Call(0xE300, &req, &repl);
|
||||
if (neterrno) return(-1);
|
||||
return(0);
|
||||
}
|
||||
|
||||
int ncp_17_17(uint8 *key)
|
||||
/* get crypt key */
|
||||
{
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 func;
|
||||
} req;
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 key[8];
|
||||
} repl;
|
||||
req.len = 1;
|
||||
req.func = 0x17;
|
||||
repl.len = 8;
|
||||
neterrno = Net_Call(0xE300, &req, &repl);
|
||||
if (neterrno) return(-1);
|
||||
else {
|
||||
memcpy(key, repl.key, 8);
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
|
||||
int ncp_17_18(uint8 *cryptkey, uint8 *objname, uint16 objtyp)
|
||||
/* keyed login */
|
||||
{
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 func;
|
||||
uint8 key[8];
|
||||
uint8 typ[2];
|
||||
uint8 namlen;
|
||||
uint8 name[48];
|
||||
} req;
|
||||
struct {
|
||||
uint16 len;
|
||||
} repl={ 0 };
|
||||
req.len = sizeof(req) - sizeof(uint16);
|
||||
req.func = 0x18;
|
||||
U16_TO_BE16(objtyp, req.typ);
|
||||
req.namlen = min(sizeof(req.name), strlen(objname));
|
||||
memcpy(req.key, cryptkey, 8);
|
||||
memcpy(req.name, objname, (int) req.namlen);
|
||||
neterrno = Net_Call(0xE300, &req, &repl);
|
||||
if (neterrno) return(-1);
|
||||
return(0);
|
||||
}
|
||||
|
||||
uint32 ncp_17_35(uint8 *objname, uint16 objtyp)
|
||||
/* get bindery object id */
|
||||
{
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 func;
|
||||
uint8 typ[2];
|
||||
uint8 namlen;
|
||||
uint8 name[48];
|
||||
} req;
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 object_id[4];
|
||||
uint8 object_type[2];
|
||||
uint8 object_name[48];
|
||||
} repl;
|
||||
req.len = sizeof(req) - sizeof(uint16);
|
||||
repl.len = sizeof(repl) - sizeof(uint16);
|
||||
req.func = 0x35;
|
||||
U16_TO_BE16(objtyp, req.typ);
|
||||
req.namlen = min(sizeof(req.name), strlen(objname));
|
||||
memcpy(req.name, objname, (int) req.namlen);
|
||||
neterrno = Net_Call(0xE300, &req, &repl);
|
||||
if (neterrno) return(0L);
|
||||
strmaxcpy(objname, repl.object_name, 47);
|
||||
return(GET_BE32(repl.object_id));
|
||||
}
|
||||
|
||||
int ncp_17_36(uint32 obj_id, uint8 *objname, uint16 *objtyp)
|
||||
/* get bindery object name */
|
||||
{
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 func;
|
||||
uint8 id[4];
|
||||
} req;
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 object_id[4];
|
||||
uint8 object_type[2];
|
||||
uint8 object_name[48];
|
||||
} repl;
|
||||
req.len = sizeof(req) - sizeof(uint16);
|
||||
repl.len = sizeof(repl) - sizeof(uint16);
|
||||
req.func = 0x36;
|
||||
U32_TO_BE32(obj_id, req.id);
|
||||
neterrno = Net_Call(0xE300, &req, &repl);
|
||||
if (neterrno) return(-1);
|
||||
if (objname) strmaxcpy(objname, repl.object_name, 47);
|
||||
if (objtyp) *objtyp = GET_BE16(repl.object_type);
|
||||
return(0);
|
||||
}
|
||||
|
||||
|
||||
int ncp_17_40(uint8 *objname, uint16 objtyp,
|
||||
uint8 *password, uint8 *newpassword)
|
||||
/* change password unencreypted */
|
||||
{
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 func;
|
||||
uint8 typ[2];
|
||||
uint8 namlen;
|
||||
uint8 buff[48+1+128+1+128];
|
||||
} req;
|
||||
struct {
|
||||
uint16 len;
|
||||
} repl = { 0 };
|
||||
uint8 *p=req.buff;
|
||||
req.func = 0x40;
|
||||
U16_TO_BE16(objtyp, req.typ);
|
||||
req.namlen = min(47, strlen(objname));
|
||||
memcpy(p, objname, req.namlen);
|
||||
p += req.namlen;
|
||||
*p = (uint8) min(128, strlen(password));
|
||||
req.len = 4 + req.namlen + 1 + *p;
|
||||
memcpy(p+1, password, (int) *p);
|
||||
p += (1 + *p);
|
||||
*p = (uint8) min(128, strlen(newpassword));
|
||||
req.len += (1 + *p);
|
||||
memcpy(p+1, newpassword, (int) *p);
|
||||
neterrno = Net_Call(0xE300, &req, &repl);
|
||||
if (neterrno) return(-1);
|
||||
return(0);
|
||||
}
|
||||
|
||||
int ncp_14_46(uint32 *obj_id)
|
||||
/* get bindery access level & actual ID */
|
||||
{
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 func;
|
||||
} req;
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 access;
|
||||
uint8 id[4];
|
||||
} repl;
|
||||
req.len = 1;
|
||||
req.func = 0x46;
|
||||
repl.len = 5;
|
||||
neterrno = Net_Call(0xE300, &req, &repl);
|
||||
if (neterrno) return(-1);
|
||||
else {
|
||||
if (obj_id) *obj_id = GET_BE32(repl.id);
|
||||
return(repl.access);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int ncp_17_4b(uint8 *cryptkey, uint8 *objname, uint16 objtyp,
|
||||
int passwx, uint8 *newpassword)
|
||||
/* keyed change password */
|
||||
{
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 func;
|
||||
uint8 key[8];
|
||||
uint8 typ[2];
|
||||
uint8 namlen;
|
||||
uint8 buff[48+1+16];
|
||||
} req;
|
||||
struct {
|
||||
uint16 len;
|
||||
} repl = { 0 };
|
||||
uint8 *p = req.buff;
|
||||
req.func = 0x4b;
|
||||
memcpy(req.key, cryptkey, 8);
|
||||
U16_TO_BE16(objtyp, req.typ);
|
||||
req.namlen = (uint8) min(48, strlen(objname));
|
||||
req.len = 12 + req.namlen + 1 + 16;
|
||||
memcpy(p, objname, (int) req.namlen);
|
||||
p += req.namlen;
|
||||
*p++ = (uint8) passwx;
|
||||
memcpy(p, newpassword, 16);
|
||||
neterrno = Net_Call(0xE300, &req, &repl);
|
||||
if (neterrno) return(-1);
|
||||
return(0);
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
/* net.c 14-Mar-96 */
|
||||
/* simple client programm to act with mars_nwe */
|
||||
|
||||
/****************************************************************
|
||||
* (C)opyright (C) 1993,1996 Martin Stover, Marburg, Germany *
|
||||
****************************************************************/
|
||||
|
||||
#include "net.h"
|
||||
char *funcname=NULL;
|
||||
typedef int (*NET_FUNC)(int argc, char *argv[]);
|
||||
|
||||
static struct s_net_functions {
|
||||
char *name;
|
||||
char *description;
|
||||
NET_FUNC func;
|
||||
} net_functions[] = {
|
||||
{"LOGIN", "login to Server as User" , func_login },
|
||||
{"MAP", "list maps and map drives" , func_map },
|
||||
{"PATH", "list and set search path" , func_path },
|
||||
{"LOGOUT", "logout from Server", func_logout },
|
||||
#if 0
|
||||
{"SLIST", "list Servers", func_slist },
|
||||
#endif
|
||||
{"PASSWD", "change password", func_passwd },
|
||||
#if 1
|
||||
{"TESTS", "only testroutines!", func_tests },
|
||||
#endif
|
||||
{"DEBUG", "set debug level, for mars_nwe only !", func_debug }
|
||||
};
|
||||
|
||||
#define MAX_FUNCS (sizeof(net_functions) / sizeof(struct s_net_functions))
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
NET_FUNC func = NULL;
|
||||
int result = -1;
|
||||
if (argc > 1) {
|
||||
char funcn[200];
|
||||
int k= MAX_FUNCS;
|
||||
strmaxcpy(funcn, argv[1], sizeof(funcn)-1);
|
||||
upstr(funcn);
|
||||
while (k--) {
|
||||
if (!strcmp(funcn, net_functions[k].name)) {
|
||||
func=net_functions[k].func;
|
||||
funcname=net_functions[k].name;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (func != NULL) {
|
||||
if (ipx_init() || func == func_map) {
|
||||
result = (*func) (argc-1, &(argv[1]));
|
||||
}
|
||||
} else {
|
||||
int k= MAX_FUNCS;
|
||||
char progname[256];
|
||||
strmaxcpy(progname, argv[0], sizeof(progname)-1);
|
||||
upstr(progname);
|
||||
fprintf(stderr, "\n"
|
||||
"****************************************************************\n"
|
||||
"* (C)opyright (C) 1993,1996 Martin Stover, Marburg, Germany *\n"
|
||||
"****************************************************************\n\n" );
|
||||
fprintf(stderr, "Usage:\t%s func ... \nfuncs:", progname);
|
||||
while (k--) {
|
||||
if (net_functions[k].func) {
|
||||
fprintf(stderr, "\t%s\t: %s\n",
|
||||
net_functions[k].name, net_functions[k].description);
|
||||
}
|
||||
}
|
||||
}
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,202 @@
|
|||
/* net.h: 01-Feb-96 */
|
||||
|
||||
/****************************************************************
|
||||
* (C)opyright (C) 1993,1996 Martin Stover, Marburg, Germany *
|
||||
****************************************************************/
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <malloc.h>
|
||||
#include <string.h>
|
||||
#include <conio.h>
|
||||
#include <io.h>
|
||||
#include <bios.h>
|
||||
#include <dos.h>
|
||||
#include <process.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
typedef unsigned int UI;
|
||||
typedef unsigned char UC;
|
||||
typedef unsigned char uint8;
|
||||
typedef unsigned short int uint16;
|
||||
typedef unsigned long int uint32;
|
||||
|
||||
typedef union REGS REGS;
|
||||
typedef struct SREGS SREGS;
|
||||
|
||||
typedef void (*FUNC_VOID)();
|
||||
typedef int (*FUNC_INT)();
|
||||
|
||||
|
||||
typedef struct {
|
||||
uint8 checksum[2];
|
||||
uint16 packetlen;
|
||||
uint8 tcontrol;
|
||||
uint8 ptype;
|
||||
uint8 dest_net[4];
|
||||
uint8 dest_node[6];
|
||||
uint16 dest_sock; /* HI LOW */
|
||||
uint8 source_net[4];
|
||||
uint8 source_node[6];
|
||||
uint16 source_sock; /* HI LOW */
|
||||
} IPX_HEADER;
|
||||
|
||||
typedef struct {
|
||||
uint8 *link_address;
|
||||
FUNC_VOID esr_routine;
|
||||
uint8 in_use_flag;
|
||||
uint8 completition_code;
|
||||
uint16 socket; /* HI LOW */
|
||||
uint8 ipx_workspace[4]; /* interner Gebrauch */
|
||||
uint8 drv_workspace[4]; /* interner Gebrauch */
|
||||
uint8 immediate_address[6]; /* HI LOW Node Address */
|
||||
uint16 fragment_count; /* Anzahl Fragment Buffers */
|
||||
uint8 *fragment_1;
|
||||
uint16 fragment_1_size;
|
||||
/* K”nnen auch mehr sein */
|
||||
} ECB;
|
||||
|
||||
#include "kern.h"
|
||||
|
||||
#define UI2NET(i) ( ( (i) << 8) | ( ((i)>>8) & 0xFF) )
|
||||
#define NET2UI(i) ( ( (i) << 8) | ( ((i)>>8) & 0xFF) )
|
||||
|
||||
#define U16_TO_BE16(u, b) { uint16 a=(u); \
|
||||
*( (uint8*) (b) ) = *( ((uint8*) (&a)) +1); \
|
||||
*( ((uint8*) (b)) +1) = *( (uint8*) (&a)); }
|
||||
|
||||
|
||||
#define U32_TO_BE32(u, ar) { uint32 a= (u); uint8 *b= ((uint8*)(ar))+3; \
|
||||
*b-- = (uint8)a; a >>= 8; \
|
||||
*b-- = (uint8)a; a >>= 8; \
|
||||
*b-- = (uint8)a; a >>= 8; \
|
||||
*b = (uint8)a; }
|
||||
|
||||
#define U16_TO_16(u, b) { uint16 a=(u); memcpy(b, &a, 2); }
|
||||
#define U32_TO_32(u, b) { uint32 a=(u); memcpy(b, &a, 4); }
|
||||
|
||||
#define GET_BE16(b) ( (int) *(((uint8*)(b))+1) \
|
||||
| ( ( (int) *( (uint8*)(b) ) << 8) ) )
|
||||
|
||||
#define GET_BE32(b) ( (uint32) *(((uint8*)(b))+3) \
|
||||
| ( ((uint32) *(((uint8*)(b))+2) ) << 8) \
|
||||
| ( ((uint32) *(((uint8*)(b))+1) ) << 16) \
|
||||
| ( ((uint32) *( (uint8*)(b) ) ) << 24) )
|
||||
|
||||
|
||||
#define GET_16(b) ( (int) *( (uint8*)(b) ) \
|
||||
| ( ( (int) *(((uint8*)(b))+1) << 8) ) )
|
||||
|
||||
#define GET_32(b) ( (uint32) *( (uint8*)(b) ) \
|
||||
| ( ((uint32) *(((uint8*)(b))+1) ) << 8) \
|
||||
| ( ((uint32) *(((uint8*)(b))+2) ) << 16) \
|
||||
| ( ((uint32) *(((uint8*)(b))+3) ) << 24) )
|
||||
|
||||
#define MAX_U32 ((uint32)0xffffffffL)
|
||||
#define MAX_U16 ((uint16)0xffff)
|
||||
|
||||
#define NWSERV 1
|
||||
#define NCPSERV 2
|
||||
#define NWCONN 3
|
||||
#define NWCLIENT 4
|
||||
#define NWBIND 5
|
||||
|
||||
/* net.c */
|
||||
extern char *funcname;
|
||||
|
||||
/* tools.c */
|
||||
extern void clear_kb(void);
|
||||
extern int key_pressed(void);
|
||||
extern int ask_user(char *p, ...);
|
||||
extern int strmaxcpy(char *dest, char *source, int len);
|
||||
extern char *xadd_char(char *s, int c, int maxlen);
|
||||
extern uint8 *upstr(uint8 *s);
|
||||
|
||||
#define add_char(s, c) xadd_char((s), (c), -1)
|
||||
|
||||
extern char *getglobenv(char *option);
|
||||
extern int putglobenv(char *option);
|
||||
|
||||
/* NETCALLS */
|
||||
#define DRIVE_ADD 1
|
||||
#define DRIVE_INSERT 2
|
||||
#define DRIVE_DELETE 3
|
||||
|
||||
typedef struct {
|
||||
uint8 drivenummer; /* 0xff, 0xfe f<>r DOSPATH mit Pfad */
|
||||
uint8 flags;
|
||||
union {
|
||||
struct {
|
||||
char dospath[65];
|
||||
} d;
|
||||
struct fs {
|
||||
uint8 connid;
|
||||
uint8 dhandle;
|
||||
} fs;
|
||||
} u;
|
||||
} SEARCH_VECTOR_ENTRY;
|
||||
|
||||
typedef SEARCH_VECTOR_ENTRY SEARCH_VECTOR[17];
|
||||
|
||||
extern int neterrno;
|
||||
|
||||
#define alloc_permanent_dir_handle(dhandle, path, drive, rights) \
|
||||
alloc_dir_handle(0x12, (dhandle), (path), (drive), (rights))
|
||||
|
||||
#define alloc_temp_dir_handle(dhandle, path, drive, rights) \
|
||||
alloc_dir_handle(0x13, (dhandle), (path), (drive), (rights))
|
||||
|
||||
extern int ipx_init(void);
|
||||
|
||||
extern int alloc_dir_handle(int func, int dhandle, char *path,
|
||||
int driveletter, uint8 *effrights);
|
||||
|
||||
extern int dealloc_dir_handle(int dhandle);
|
||||
|
||||
extern int get_dir_path(uint8 dhandle, char *path);
|
||||
extern int get_volume_name(uint8 nr, char *name);
|
||||
|
||||
extern int get_search_drive_vektor(SEARCH_VECTOR_ENTRY *vec);
|
||||
extern int set_search_drive_vektor(SEARCH_VECTOR_ENTRY *vec);
|
||||
|
||||
/********* ncpcall.h ***********/
|
||||
extern int ncp_16_02(int dirhandle,
|
||||
uint8 *path,
|
||||
int *sub_dir,
|
||||
uint8 *resultpath,
|
||||
uint32 *creattime,
|
||||
uint32 *owner_id);
|
||||
|
||||
extern int ncp_17_02(int module, int debuglevel);
|
||||
extern int ncp_17_14(uint8 *objname, uint16 objtyp, uint8 *password);
|
||||
extern int ncp_17_17(uint8 *key);
|
||||
extern int ncp_17_18(uint8 *cryptkey, uint8 *objname, uint16 objtyp);
|
||||
extern uint32 ncp_17_35(uint8 *objname, uint16 objtyp);
|
||||
extern int ncp_17_40(uint8 *objname, uint16 objtyp, uint8 *password,
|
||||
uint8 *newpassword);
|
||||
|
||||
extern int ncp_17_4b(uint8 *cryptkey, uint8 *objname, uint16 objtyp,
|
||||
int passwx, uint8 *newpassword);
|
||||
|
||||
/* map.c */
|
||||
extern int func_map(int argc, char *argv[]);
|
||||
extern int func_path(int argc, char *argv[]);
|
||||
|
||||
/* login.c */
|
||||
extern int func_login(int argc, char *argv[]);
|
||||
extern int func_logout(int argc, char *argv[]);
|
||||
extern int func_passwd(int argc, char *argv[]);
|
||||
|
||||
/* slist.c */
|
||||
extern int func_slist(int argc, char *argv[]);
|
||||
|
||||
/* nwdebug.c */
|
||||
extern int func_debug(int argc, char *argv[]);
|
||||
|
||||
/* nwtests.c */
|
||||
extern int func_tests(int argc, char *argv[]);
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,408 @@
|
|||
/* netcall.c: 05-Apr-96 */
|
||||
|
||||
/****************************************************************
|
||||
* (C)opyright (C) 1993,1996 Martin Stover, Marburg, Germany *
|
||||
****************************************************************/
|
||||
|
||||
#include "net.h"
|
||||
|
||||
int neterrno=0;
|
||||
|
||||
int ipx_init(void)
|
||||
{
|
||||
static int ipx_is_init=0;
|
||||
static int ipx_is_ok =0;
|
||||
if (!ipx_is_init) {
|
||||
ipx_is_init++;
|
||||
ipx_is_ok = IPXinit();
|
||||
}
|
||||
return(ipx_is_ok);
|
||||
}
|
||||
|
||||
static void *get_shell_ptr(uint16 func)
|
||||
{
|
||||
if (ipx_init()) {
|
||||
void *p = NULL;
|
||||
REGS regs;
|
||||
SREGS sregs;
|
||||
regs.x.ax = func;
|
||||
if (!(intdosx(®s, ®s, &sregs) & 0xff))
|
||||
p = MK_FP(sregs.es, regs.x.si);
|
||||
return(p);
|
||||
} else return(NULL);
|
||||
}
|
||||
|
||||
int detach(int servernmbr)
|
||||
{
|
||||
REGS regsin, regsout;
|
||||
regsin.x.ax = 0xf101;
|
||||
regsin.x.dx = servernmbr;
|
||||
return(intdos(®sin, ®sout) & 0xff);
|
||||
}
|
||||
|
||||
int logout(void)
|
||||
{
|
||||
REGS regsin, regsout;
|
||||
regsin.x.ax = 0xd700;
|
||||
return(intdos(®sin, ®sout) & 0xff);
|
||||
}
|
||||
|
||||
int redir_device_drive(int devicetyp, uint8 *devname, uint8 *remotename)
|
||||
/* if devicetyp == -1, the redir is canceled */
|
||||
{
|
||||
REGS regs;
|
||||
SREGS sregs;
|
||||
int result;
|
||||
uint8 buff1[16];
|
||||
uint8 buff2[128];
|
||||
uint8 *ldevname = buff1;
|
||||
uint8 *lremotename = buff2;
|
||||
strncpy(ldevname, devname, 16);
|
||||
regs.x.ax = (devicetyp == -1) ? 0x5f04 : 0x5f03;
|
||||
regs.h.bl = (uint8)devicetyp;
|
||||
regs.x.cx = 0x574e; /* user sign 'NW' */
|
||||
sregs.ds = FP_SEG(ldevname);
|
||||
regs.x.si = FP_OFF(ldevname);
|
||||
if (devicetyp > -1) {
|
||||
strncpy(lremotename, remotename, 128);
|
||||
sregs.es = FP_SEG(lremotename);
|
||||
regs.x.di = FP_OFF(lremotename);
|
||||
}
|
||||
result = intdosx(®s, ®s, &sregs);
|
||||
return(regs.x.cflag ? -result : 0);
|
||||
}
|
||||
|
||||
int list_redir(int index, int *devicetyp, uint8 *devname, uint8 *remotename)
|
||||
{
|
||||
REGS regs;
|
||||
SREGS sregs;
|
||||
int result;
|
||||
uint8 buff1[16];
|
||||
uint8 buff2[128];
|
||||
uint8 *ldevname = buff1;
|
||||
uint8 *lremotename = buff2;
|
||||
memset(ldevname, 0, sizeof(buff1));
|
||||
memset(lremotename, 0, sizeof(buff2));
|
||||
regs.x.ax = 0x5f02;
|
||||
regs.x.bx = index;
|
||||
regs.x.cx = 0x574e; /* user sign 'NW' */
|
||||
sregs.ds = FP_SEG(ldevname);
|
||||
regs.x.si = FP_OFF(ldevname);
|
||||
sregs.es = FP_SEG(lremotename);
|
||||
regs.x.di = FP_OFF(lremotename);
|
||||
result = intdosx(®s, ®s, &sregs);
|
||||
if (!regs.x.cflag) {
|
||||
if (devname) strcpy(devname, ldevname);
|
||||
if (remotename) strcpy(remotename, lremotename);
|
||||
if (devicetyp) *devicetyp = (int)regs.h.bl;
|
||||
return((int)regs.h.bh);
|
||||
} else return(-result);
|
||||
}
|
||||
|
||||
int get_drive_info(uint8 drivenumber, uint8 *connid,
|
||||
uint8 *dhandle, uint8 *statusflags)
|
||||
|
||||
/* drivenumber 0 .. 31 */
|
||||
{
|
||||
uint8 *drive_handle_table = get_shell_ptr(0xef00);
|
||||
uint8 *drive_flag_table = get_shell_ptr(0xef01);
|
||||
uint8 *drive_conn_table = get_shell_ptr(0xef02);
|
||||
|
||||
if ( !drive_handle_table
|
||||
|| !drive_flag_table
|
||||
|| !drive_conn_table
|
||||
|| drivenumber > 31) {
|
||||
char path[100];
|
||||
if (drivenumber < 2 || !getcurdir(drivenumber+1, path)) {
|
||||
*dhandle = 0;
|
||||
*connid = 0;
|
||||
*statusflags = 0x80;
|
||||
return(0);
|
||||
}
|
||||
return(-1);
|
||||
}
|
||||
*dhandle = *(drive_handle_table+ drivenumber);
|
||||
*connid = *(drive_conn_table + drivenumber);
|
||||
*statusflags = *(drive_flag_table + drivenumber);
|
||||
return(0);
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
char fsname[8][48];
|
||||
} SERVER_NAME_TABLE;
|
||||
|
||||
int get_fs_name(int connid, char *name)
|
||||
/* Connection 1 .. 8 */
|
||||
{
|
||||
SERVER_NAME_TABLE *sf_t = get_shell_ptr(0xef04);
|
||||
if (sf_t && connid > 0 && connid-- < 8){
|
||||
strmaxcpy(name, sf_t->fsname[connid], 48);
|
||||
return(0);
|
||||
}
|
||||
name[0] = '\0';
|
||||
return(-11);
|
||||
}
|
||||
|
||||
static char *path_env_name="PATH";
|
||||
|
||||
int get_search_drive_vektor(SEARCH_VECTOR_ENTRY *vec)
|
||||
/* maximal 16 Entries */
|
||||
{
|
||||
char *path=getglobenv(path_env_name);
|
||||
SEARCH_VECTOR_ENTRY *v = vec;
|
||||
int anz=0;
|
||||
v->drivenummer = 0xff;
|
||||
if (path){
|
||||
while (*path && anz++ < 16){
|
||||
char *p1 = path;
|
||||
int len = 0;
|
||||
while (*path && *path++ !=';') len++;
|
||||
if (*(p1+1) == ':'
|
||||
&& *p1 >= 'A' && *p1 <= 'Z' &&
|
||||
(len==2 || (len == 3 && *(p1+2) == '.'))) {
|
||||
v->drivenummer = *p1 - 'A';
|
||||
get_drive_info(v->drivenummer, &(v->u.fs.connid),
|
||||
&(v->u.fs.dhandle), &(v->flags));
|
||||
} else {
|
||||
v->flags = 0;
|
||||
v->drivenummer = 0xfe; /* ergibt ? */
|
||||
strmaxcpy(v->u.d.dospath, p1, len);
|
||||
}
|
||||
(++v)->drivenummer = 0xff;
|
||||
if (*path == ';') path++;
|
||||
}
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
||||
int set_search_drive_vektor(SEARCH_VECTOR_ENTRY *vec)
|
||||
{
|
||||
char path[256];
|
||||
char *p=path;
|
||||
SEARCH_VECTOR_ENTRY *v;
|
||||
int plen=strlen(path_env_name);
|
||||
strcpy(path, path_env_name);
|
||||
path[plen] = '=';
|
||||
path[++plen] = '\0';
|
||||
while ((NULL != (v = vec++)) && v->drivenummer != 0xff){
|
||||
if (p > path) *p++=';';
|
||||
else p+=plen;
|
||||
if (v->drivenummer < 26) {
|
||||
*p++ = (char) v->drivenummer + 'A';
|
||||
*p++ = ':';
|
||||
*p++ = '.';
|
||||
*p = '\0';
|
||||
} else {
|
||||
strcpy(p, v->u.d.dospath);
|
||||
p+= strlen(v->u.d.dospath);
|
||||
}
|
||||
}
|
||||
return(putglobenv(path));
|
||||
}
|
||||
|
||||
int alloc_dir_handle(int func,
|
||||
int dhandle,
|
||||
char *path,
|
||||
int driveletter,
|
||||
uint8 *effrights)
|
||||
{
|
||||
int pathlen = (path == NULL) ? 0 : strlen(path);
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 func;
|
||||
uint8 dhandle;
|
||||
uint8 drive;
|
||||
uint8 pathlen;
|
||||
uint8 path[256];
|
||||
} req;
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 newhandle;
|
||||
uint8 effrights;
|
||||
} repl;
|
||||
req.func = (uint8)func;
|
||||
req.dhandle = (uint8)dhandle;
|
||||
req.drive = (uint8)driveletter;
|
||||
req.pathlen = (uint8)pathlen;
|
||||
xmemmove(req.path, path, pathlen);
|
||||
req.len = 4 + pathlen;
|
||||
repl.len = 2;
|
||||
/*
|
||||
printf("alloc_dir_handle, path=%s, len=%d, disk=%c\n", path, pathlen, driveletter);
|
||||
*/
|
||||
neterrno = Net_Call(0xE200, &req, &repl);
|
||||
fprintf(stderr, "neterrno=%d\n", neterrno);
|
||||
if (neterrno && neterrno != 0xff) return(-1);
|
||||
|
||||
if (effrights) *effrights = repl.effrights;
|
||||
return((int)repl.newhandle);
|
||||
}
|
||||
|
||||
int dealloc_dir_handle(int dhandle)
|
||||
{
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 func;
|
||||
uint8 dhandle;
|
||||
} req;
|
||||
struct {
|
||||
uint16 len;
|
||||
} repl;
|
||||
req.len = 2;
|
||||
req.func = 0x14;
|
||||
req.dhandle = (uint8)dhandle;
|
||||
repl.len = 0;
|
||||
neterrno = Net_Call(0xE200, &req, &repl);
|
||||
if (neterrno) return(-1);
|
||||
else return(0);
|
||||
}
|
||||
|
||||
int set_dir_path(uint8 desthandle, uint8 handle, char *path)
|
||||
/* Set Directory Handle */
|
||||
{
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 func;
|
||||
uint8 desth;
|
||||
uint8 sourceh;
|
||||
uint8 pathlen;
|
||||
uint8 path[256];
|
||||
} req;
|
||||
struct {
|
||||
uint16 len;
|
||||
} repl;
|
||||
req.pathlen = (path) ? strlen(path) : 0;
|
||||
if (req.pathlen) memcpy(req.path, path, (int)req.pathlen);
|
||||
req.len = 4+req.pathlen;
|
||||
req.func = 0;
|
||||
req.sourceh = handle;
|
||||
req.desth = desthandle;
|
||||
repl.len = 0;
|
||||
neterrno = Net_Call(0xE200, &req, &repl);
|
||||
return( (neterrno) ? -1 : 0);
|
||||
}
|
||||
|
||||
int get_dir_path(uint8 dhandle, char *path)
|
||||
{
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 data[2];
|
||||
} req;
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 pathlen;
|
||||
uint8 path[255];
|
||||
} repl;
|
||||
req.len = 2;
|
||||
req.data[0] = 0x1;
|
||||
req.data[1] = dhandle;
|
||||
repl.len = 256;
|
||||
neterrno = Net_Call(0xE200, &req, &repl);
|
||||
if (neterrno) return(-1);
|
||||
else {
|
||||
strmaxcpy(path, repl.path, (int)repl.pathlen);
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
|
||||
int get_volume_name(uint8 nr, char *name)
|
||||
{
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 func;
|
||||
uint8 nr;
|
||||
} req;
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 namlen;
|
||||
uint8 name[16];
|
||||
} repl;
|
||||
req.len = 2;
|
||||
req.func = 0x6;
|
||||
req.nr = nr;
|
||||
repl.len = 17;
|
||||
neterrno = Net_Call(0xE200, &req, &repl);
|
||||
if (neterrno) return(-1);
|
||||
else {
|
||||
strmaxcpy(name, repl.name, (int)repl.namlen);
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int save_dir_handle(uint8 dhandle, uint8 *savebuffer)
|
||||
{
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 func;
|
||||
uint8 dhandle;
|
||||
} req;
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 savebuffer[16];
|
||||
} repl;
|
||||
req.len = 2;
|
||||
req.func = 0x17;
|
||||
req.dhandle = dhandle;
|
||||
repl.len = 16;
|
||||
neterrno = Net_Call(0xE200, &req, &repl);
|
||||
if (neterrno) return(-1);
|
||||
else {
|
||||
xmemmove(savebuffer, repl.savebuffer, 16);
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
|
||||
int restore_dir_handle(uint8 *savebuffer, uint8 *dhandle, uint8 *effrights)
|
||||
{
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 func;
|
||||
uint8 savebuffer[16];
|
||||
} req;
|
||||
struct {
|
||||
uint16 len;
|
||||
uint8 dhandle;
|
||||
uint8 effrights;
|
||||
} repl;
|
||||
req.len = 17;
|
||||
req.func = 0x18;
|
||||
repl.len = 2;
|
||||
xmemmove(req.savebuffer, savebuffer, 16);
|
||||
neterrno = Net_Call(0xE200, &req, &repl);
|
||||
if (neterrno) return(-1);
|
||||
else {
|
||||
*dhandle = repl.dhandle;
|
||||
*effrights = repl.effrights;
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
int mapdrive(uint8 connection, uint8 dhandle, char *path,
|
||||
uint8 searchflag, uint8 searchorder,
|
||||
uint8 *driveletter, uint8 *newdhandle, uint8 *effrights)
|
||||
|
||||
/* Searchorder 0 normal Drive; 1..16 Searchdrives */
|
||||
/* searchflag only if Searchdrive : */
|
||||
/* DRIVE_ADD, DRIVE_INSERT, DRIVE_DELETE */
|
||||
{
|
||||
|
||||
|
||||
return(-1);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,213 @@
|
|||
/*$*********************************************************
|
||||
$*
|
||||
$* This code has been taken from DDJ 11/93, from an
|
||||
$* article by Pawel Szczerbina.
|
||||
$*
|
||||
$* Password encryption routines follow.
|
||||
$* Converted to C from Barry Nance's Pascal
|
||||
$* prog published in the March -93 issue of Byte.
|
||||
$*
|
||||
$* Adapted to be useable for ncpfs by
|
||||
$* Volker Lendecke <lendecke@namu01.gwdg.de> in
|
||||
$* October 1995.
|
||||
$*
|
||||
$* Stolen to be useable for mars_nwe by
|
||||
$* Martin Stover <mstover@freeway.de> in
|
||||
$* Dezember 1995.
|
||||
$**********************************************************/
|
||||
|
||||
/****************************************************************************
|
||||
|
||||
I read that Novell is not very open when it comes to technical details
|
||||
of the Netware Core Protocol. This might be especially true for the
|
||||
encryption stuff. I took the necessary code from Dr. Dobb's Journal
|
||||
11/93, Undocumented Corner. I asked Jon Erickson <jon@ddj.com> about
|
||||
the legal status of this piece of code:
|
||||
|
||||
|
||||
---
|
||||
Date: Thu, 12 Oct 1995 13:44:18 +0100
|
||||
From: Volker Lendecke <lendecke>
|
||||
To: jon@ddj.com
|
||||
Subject: legal status of your source code?
|
||||
|
||||
|
||||
Hello!
|
||||
|
||||
I hope that you're the right one to write to, you are the first on your WWW
|
||||
server. If you are not, could you please forward this message to the right
|
||||
person? Thanks.
|
||||
|
||||
I'm currently exploring the possibility to write a free (in the GNU GPL
|
||||
sense) NCP filesystem, which would allow me to access a novell server
|
||||
transparently. For that I would like to use the encryption functions you
|
||||
published in DDJ 11/93, Undocumented Corner. I would make some cosmetic
|
||||
changes, such as other indentations, minor code changes and so on. But I do
|
||||
not know if that allows me to publish this code under GPL. One alternative
|
||||
would be to publish a diff against your listing, but that would probably
|
||||
contain much of your code as well, and it would be very inconvenient for
|
||||
the average user.
|
||||
|
||||
I think that you have some kind of standard procedure for such a
|
||||
case. Please tell me what I should do.
|
||||
|
||||
Many thanks in advance,
|
||||
|
||||
Volker
|
||||
|
||||
+=================================================================+
|
||||
! Volker Lendecke Internet: lendecke@namu01.gwdg.de !
|
||||
! D-37081 Goettingen, Germany !
|
||||
+=================================================================+
|
||||
|
||||
--
|
||||
|
||||
|
||||
I got the following answer:
|
||||
|
||||
---
|
||||
From: Jon Erickson <jon@ddj.com>
|
||||
X-Mailer: SCO System V Mail (version 3.2)
|
||||
To: lendecke@namu01.gwdg.de
|
||||
Subject: Re: legal status of your source code?
|
||||
Date: Thu, 12 Oct 95 5:42:56 PDT
|
||||
|
||||
Volker,
|
||||
Code from Dr. Dobb's Journal related articles is provided for
|
||||
anyone to use. Clearly, the author of the article should be
|
||||
given credit.
|
||||
Jon Erickson
|
||||
|
||||
---
|
||||
|
||||
With this answer in mind, I took the code and made it a bit more
|
||||
C-like. The original seemed to be translated by a mechanical pascal->c
|
||||
translator. Jon's answer encouraged me to publish nwcrypt.c under the
|
||||
GPL. If anybody who knows more about copyright and sees any problems
|
||||
with this, please tell me.
|
||||
****************************************************************************/
|
||||
|
||||
/******************* Data types ***************************/
|
||||
typedef unsigned char buf32[32];
|
||||
typedef unsigned char buf16[16];
|
||||
typedef unsigned char buf8[8];
|
||||
typedef unsigned char buf4[4];
|
||||
typedef unsigned char u8;
|
||||
|
||||
static u8 encrypttable[256] =
|
||||
{0x7,0x8,0x0,0x8,0x6,0x4,0xE,0x4,0x5,0xC,0x1,0x7,0xB,0xF,0xA,0x8,
|
||||
0xF,0x8,0xC,0xC,0x9,0x4,0x1,0xE,0x4,0x6,0x2,0x4,0x0,0xA,0xB,0x9,
|
||||
0x2,0xF,0xB,0x1,0xD,0x2,0x1,0x9,0x5,0xE,0x7,0x0,0x0,0x2,0x6,0x6,
|
||||
0x0,0x7,0x3,0x8,0x2,0x9,0x3,0xF,0x7,0xF,0xC,0xF,0x6,0x4,0xA,0x0,
|
||||
0x2,0x3,0xA,0xB,0xD,0x8,0x3,0xA,0x1,0x7,0xC,0xF,0x1,0x8,0x9,0xD,
|
||||
0x9,0x1,0x9,0x4,0xE,0x4,0xC,0x5,0x5,0xC,0x8,0xB,0x2,0x3,0x9,0xE,
|
||||
0x7,0x7,0x6,0x9,0xE,0xF,0xC,0x8,0xD,0x1,0xA,0x6,0xE,0xD,0x0,0x7,
|
||||
0x7,0xA,0x0,0x1,0xF,0x5,0x4,0xB,0x7,0xB,0xE,0xC,0x9,0x5,0xD,0x1,
|
||||
0xB,0xD,0x1,0x3,0x5,0xD,0xE,0x6,0x3,0x0,0xB,0xB,0xF,0x3,0x6,0x4,
|
||||
0x9,0xD,0xA,0x3,0x1,0x4,0x9,0x4,0x8,0x3,0xB,0xE,0x5,0x0,0x5,0x2,
|
||||
0xC,0xB,0xD,0x5,0xD,0x5,0xD,0x2,0xD,0x9,0xA,0xC,0xA,0x0,0xB,0x3,
|
||||
0x5,0x3,0x6,0x9,0x5,0x1,0xE,0xE,0x0,0xE,0x8,0x2,0xD,0x2,0x2,0x0,
|
||||
0x4,0xF,0x8,0x5,0x9,0x6,0x8,0x6,0xB,0xA,0xB,0xF,0x0,0x7,0x2,0x8,
|
||||
0xC,0x7,0x3,0xA,0x1,0x4,0x2,0x5,0xF,0x7,0xA,0xC,0xE,0x5,0x9,0x3,
|
||||
0xE,0x7,0x1,0x2,0xE,0x1,0xF,0x4,0xA,0x6,0xC,0x6,0xF,0x4,0x3,0x0,
|
||||
0xC,0x0,0x3,0x6,0xF,0x8,0x7,0xB,0x2,0xD,0xC,0x6,0xA,0xA,0x8,0xD};
|
||||
|
||||
static buf32 encryptkeys =
|
||||
{0x48,0x93,0x46,0x67,0x98,0x3D,0xE6,0x8D,
|
||||
0xB7,0x10,0x7A,0x26,0x5A,0xB9,0xB1,0x35,
|
||||
0x6B,0x0F,0xD5,0x70,0xAE,0xFB,0xAD,0x11,
|
||||
0xF4,0x47,0xDC,0xA7,0xEC,0xCF,0x50,0xC0};
|
||||
|
||||
#include "nwcrypt.h"
|
||||
static void
|
||||
shuffle1(buf32 temp, unsigned char *target)
|
||||
{
|
||||
short b4;
|
||||
unsigned char b3;
|
||||
int s, b2, i;
|
||||
|
||||
b4 = 0;
|
||||
|
||||
for (b2 = 0; b2 <= 1; ++b2)
|
||||
{
|
||||
for (s = 0; s <= 31; ++s)
|
||||
{
|
||||
b3 = (temp[s]+b4) ^ (temp[(s+b4)&31] - encryptkeys[s]);
|
||||
b4 = b4 + b3;
|
||||
temp[s] = b3;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i <= 15; ++i) {
|
||||
target[i] = encrypttable[temp[ 2*i ]]
|
||||
| (encrypttable[temp[ 2*i + 1]] << 4);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
shuffle(unsigned char *lon, const unsigned char *buf, int buflen,
|
||||
unsigned char *target)
|
||||
{
|
||||
int b2, d, s;
|
||||
buf32 temp;
|
||||
|
||||
while ( (buflen > 0)
|
||||
&& (buf[buflen - 1] == 0)) {
|
||||
buflen = buflen - 1;
|
||||
}
|
||||
|
||||
for (s = 0; s < 32; s++) {
|
||||
temp[s] = 0;
|
||||
}
|
||||
|
||||
d = 0;
|
||||
while (buflen >= 32)
|
||||
{
|
||||
for (s = 0; s <= 31; ++s)
|
||||
{
|
||||
temp[s] = temp[s] ^ buf[d];
|
||||
d = d + 1;
|
||||
}
|
||||
buflen = buflen - 32;
|
||||
}
|
||||
b2 = d;
|
||||
if (buflen > 0)
|
||||
{
|
||||
for (s = 0; s <= 31; ++s)
|
||||
{
|
||||
if (d + buflen == b2)
|
||||
{
|
||||
b2 = d;
|
||||
temp[s] = temp[s] ^ encryptkeys[s];
|
||||
} else {
|
||||
temp[s] = temp[s] ^ buf[b2];
|
||||
b2 = b2 + 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (s = 0; s <= 31; ++s)
|
||||
temp[s] = temp[s] ^ lon[s & 3];
|
||||
|
||||
shuffle1(temp,target);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
nw_encrypt(unsigned char *fra,unsigned char *buf,unsigned char *til)
|
||||
{
|
||||
buf32 k;
|
||||
int s;
|
||||
|
||||
shuffle(&(fra[0]), buf, 16, &(k[ 0]));
|
||||
shuffle(&(fra[4]), buf, 16, &(k[16]));
|
||||
|
||||
for (s = 0; s <= 15; ++s)
|
||||
k[s] = k[s] ^ k[31 - s];
|
||||
|
||||
for (s = 0; s <= 7; ++s)
|
||||
til[s] = k[s] ^ k[15 - s];
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
/* nwcrypt.h */
|
||||
extern void shuffle(unsigned char *lon,
|
||||
const unsigned char *buf, int buflen,
|
||||
unsigned char *target);
|
||||
|
||||
extern void nw_encrypt(unsigned char *fra,
|
||||
unsigned char *buf,unsigned char *til);
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
/* nwdebug.c 04-Apr-96 */
|
||||
|
||||
/****************************************************************
|
||||
* (C)opyright (C) 1993,1996 Martin Stover, Marburg, Germany *
|
||||
****************************************************************/
|
||||
|
||||
#include "net.h"
|
||||
|
||||
static int usage(void)
|
||||
{
|
||||
fprintf(stderr, "usage:\t%s NCPSERV|NWCONN|NWBIND level\n", funcname);
|
||||
fprintf(stderr, "\tlevel=0 .. 99\n" );
|
||||
return(-1);
|
||||
}
|
||||
|
||||
int func_debug(int argc, char *argv[])
|
||||
{
|
||||
uint8 s[200];
|
||||
int module;
|
||||
int level;
|
||||
int result;
|
||||
if (argc < 3) return(usage());
|
||||
strmaxcpy(s, argv[1], sizeof(s) -1);
|
||||
upstr(s);
|
||||
if (!strcmp(s, "NCPSERV")) module=NCPSERV;
|
||||
else if (!strcmp(s, "NWCONN" )) module=NWCONN;
|
||||
else if (!strcmp(s, "NWBIND" )) module=NWBIND;
|
||||
else return(usage());
|
||||
level = atoi(argv[2]);
|
||||
if (level < 0 || level > 99) return(usage());
|
||||
result = ncp_17_02(module, level);
|
||||
if (result < 0) fprintf(stderr, "set debug failed\n");
|
||||
else fprintf(stdout, "Debug level for %s changed from %d to %d\n",
|
||||
s, result, level);
|
||||
return(result < 0 ? result : 0);
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
/* nwtests.c 14-Mar-96 */
|
||||
|
||||
/****************************************************************
|
||||
* (C)opyright (C) 1993,1996 Martin Stover, Marburg, Germany *
|
||||
****************************************************************/
|
||||
|
||||
#include "net.h"
|
||||
|
||||
static int usage(void)
|
||||
{
|
||||
fprintf(stderr, "usage:\t%s NCPSERV|NWCONN level\n", funcname);
|
||||
fprintf(stderr, "\tlevel=0 .. 99\n" );
|
||||
return(-1);
|
||||
}
|
||||
|
||||
int func_tests(int argc, char *argv[])
|
||||
{
|
||||
int level = ncp_17_02(NWCONN, 6);
|
||||
int dirhandle = alloc_temp_dir_handle(0, "SYS:", 'd', NULL);
|
||||
int result = -1;
|
||||
uint8 *path = (argc < 2) ? "SYS:\\TMP" : argv[1];
|
||||
if (dirhandle > -1) {
|
||||
result = ncp_16_02(dirhandle, "SYSTEM/", NULL, NULL, NULL, NULL);
|
||||
result = ncp_16_02(dirhandle, "SYSTEM", NULL, NULL, NULL, NULL);
|
||||
}
|
||||
fprintf(stdout, "dirhandle=%d, result=%d\n", dirhandle, result);
|
||||
result = redir_device_drive(0x4, "u:", path);
|
||||
fprintf(stdout, "redir path=%s, result=%d\n", path, result);
|
||||
|
||||
path="Q1";
|
||||
result = redir_device_drive(0x3, "LPT1", path);
|
||||
fprintf(stdout, "redir path=%s, result=%d\n", path, result);
|
||||
|
||||
{
|
||||
int k =-1;
|
||||
uint8 devname[20];
|
||||
uint8 remotename[130];
|
||||
int devicetyp;
|
||||
while ((result = list_redir(++k, &devicetyp, devname, remotename)) > -1){
|
||||
fprintf(stdout, "index=%d, dev=%s(%d), %s result=%d\n",
|
||||
k, devname, devicetyp, remotename, result);
|
||||
}
|
||||
}
|
||||
if (level > -1) (void) ncp_17_02(NWCONN, level);
|
||||
return(0);
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
/* map.c 12-Jan-96 */
|
||||
|
||||
/****************************************************************
|
||||
* (C)opyright (C) 1993,1996 Martin Stover, Marburg, Germany *
|
||||
****************************************************************/
|
||||
|
||||
#include "net.h"
|
||||
|
||||
int func_slist(int argc, char *argv[])
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,95 @@
|
|||
int main()
|
||||
{
|
||||
char *fn="F.$LN";
|
||||
char *string="ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijklmnopqrstuvwxyz";
|
||||
int result;
|
||||
struct stat stbuff;
|
||||
long offset;
|
||||
char buff[1024];
|
||||
char readbuff[500];
|
||||
int j;
|
||||
int fd=creatnew(fn, S_IREAD |S_IWRITE);
|
||||
if (fd > -1) {
|
||||
printf("Konnte Date erzeugen\n");
|
||||
close(fd);
|
||||
} else {
|
||||
printf("Konnte Datei nicht erzeugen\n");
|
||||
}
|
||||
fd = open(fn, O_RDWR|O_CREAT|O_TRUNC|O_DENYNONE, 0666);
|
||||
memset(buff, 0, sizeof(buff) );
|
||||
strcpy(buff, string);
|
||||
write(fd, buff, strlen(buff));
|
||||
close(fd);
|
||||
_chmod(fn, 1, _chmod(fn, 0) | 0x80 );
|
||||
stat(fn, &stbuff);
|
||||
printf("Filesize <20>ber stat =%ld\n", stbuff.st_size);
|
||||
fd = open(fn, O_RDWR | O_BINARY |O_DENYNONE);
|
||||
|
||||
offset = lseek(fd, 0L, SEEK_END);
|
||||
printf("Filesize <20>ber lseek =%ld\n", offset);
|
||||
write(fd, buff, strlen(buff));
|
||||
|
||||
lseek(fd, 0L, SEEK_SET);
|
||||
for (j=0; j < strlen(buff)*2; j++){
|
||||
read(fd, readbuff, 1);
|
||||
printf("BUFF = %c\n", readbuff[0]);
|
||||
}
|
||||
lseek(fd, 1L, SEEK_SET);
|
||||
for (j = 0; j < 20; j++){
|
||||
write(fd, buff+j, 1);
|
||||
}
|
||||
|
||||
for (j=0; j <60; j++){
|
||||
lseek(fd, (long) j, SEEK_SET);
|
||||
read(fd, readbuff, 2);
|
||||
printf("BUFF = %c, %c \n", readbuff[0], readbuff[1]);
|
||||
}
|
||||
|
||||
lseek(fd, 10L, SEEK_SET);
|
||||
read(fd, buff, 1);
|
||||
printf("BUFF[10] = %c\n", buff[0]);
|
||||
result=lock(fd, 100L, 1L);
|
||||
printf("lock result = %d\n", result);
|
||||
result=unlock(fd, 100L, 1L);
|
||||
printf("unlock result = %d\n", result);
|
||||
close(fd);
|
||||
|
||||
fd = open(fn, O_BINARY|O_RDWR|O_CREAT|O_TRUNC|O_DENYNONE, 0666);
|
||||
if (fd > -1) {
|
||||
int bufflen;
|
||||
strcpy(buff, "d:..\\marlib\\c0l.obj+");
|
||||
strcat(buff, "\r\n");
|
||||
strcat(buff, "x");
|
||||
strcat(buff, "\r\n");
|
||||
strcat(buff, "x");
|
||||
strcat(buff, "\r\n");
|
||||
strcat(buff, "/c/x");
|
||||
strcat(buff, "\r\n");
|
||||
strcat(buff, "d:..\\marlib\\EMU.LIB+");
|
||||
strcat(buff, "\r\n");
|
||||
strcat(buff, "d:..\\marlib\\mathl.lib+");
|
||||
strcat(buff, "\r\n");
|
||||
strcat(buff, "d:..\\marlib\\cl.lib");
|
||||
bufflen=strlen(buff);
|
||||
printf("bufflen = %d, buff=%s\n", bufflen, buff);
|
||||
write(fd, buff, bufflen);
|
||||
close(fd);
|
||||
fd = open(fn, O_TEXT|O_RDONLY);
|
||||
if (fd > -1) {
|
||||
char *p=readbuff;
|
||||
int anz = 0;
|
||||
memset(readbuff, 0, sizeof(readbuff) );
|
||||
while (read(fd, p, 1) == 1){
|
||||
anz++;
|
||||
p++;
|
||||
}
|
||||
printf("read = %d, buff=%s\n", anz, readbuff);
|
||||
close(fd);
|
||||
}
|
||||
}
|
||||
/*
|
||||
result = detach(1);
|
||||
printf("Detach result=0x%x", result);
|
||||
*/
|
||||
return(0);
|
||||
}
|
||||
|
|
@ -0,0 +1,201 @@
|
|||
/* tools.c: 12-Jan-96 */
|
||||
#include "net.h"
|
||||
|
||||
/****************************************************************
|
||||
* (C)opyright (C) 1993,1996 Martin Stover, Marburg, Germany *
|
||||
****************************************************************/
|
||||
|
||||
int key_pressed(void)
|
||||
{
|
||||
REGS regsin, regsout;
|
||||
regsin.h.ah = 0x01; /* read key-press */
|
||||
int86(0x16, ®sin, ®sout);
|
||||
return((regsout.x.flags & 0x40) ? 0 : 1); /* zeroflag != 0 */
|
||||
}
|
||||
|
||||
void clear_kb(void)
|
||||
{
|
||||
REGS regsin, regsout;
|
||||
while (key_pressed()) { /* zeroflag != 0 */
|
||||
regsin.h.ah = 0x00; /* read key-press */
|
||||
int86(0x16, ®sin, ®sout);
|
||||
}
|
||||
}
|
||||
|
||||
int ask_user(char *p, ...)
|
||||
{
|
||||
int key;
|
||||
int flag = 0;
|
||||
va_list argptr;
|
||||
va_start(argptr, p);
|
||||
vfprintf(stderr, p, argptr);
|
||||
va_end(argptr);
|
||||
fprintf(stderr, "\n Please answer: Y)es or N)o!");
|
||||
while (1) {
|
||||
key = getch();
|
||||
if (key == 'J' || key == 'j' || key== 'y' || key == 'Y') {
|
||||
fprintf(stderr, "Y\n\n");
|
||||
flag = 1;
|
||||
break;
|
||||
}
|
||||
if (key == 'N' || key == 'n') {
|
||||
fprintf(stderr, "N\n\n");
|
||||
flag = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
clear_kb();
|
||||
return(flag);
|
||||
}
|
||||
|
||||
int strmaxcpy(char *dest, char *source, int len)
|
||||
/* copied max. len chars + '\0' Byte */
|
||||
{
|
||||
int slen = (source != (char *)NULL) ? min(len, strlen(source)) : 0;
|
||||
if (dest == (char *)NULL) return(0);
|
||||
if (slen) memcpy(dest, source, slen);
|
||||
dest[slen] = '\0';
|
||||
return(slen);
|
||||
}
|
||||
|
||||
char *xadd_char(char *s, int c, int maxlen)
|
||||
{
|
||||
if (s && maxlen) {
|
||||
int namlen = strlen(s);
|
||||
if (maxlen > -1 && namlen >= maxlen) namlen=maxlen-1;
|
||||
s[namlen++] = c;
|
||||
s[namlen] = '\0';
|
||||
}
|
||||
return(s);
|
||||
}
|
||||
|
||||
static uint8 up_char(uint8 ch)
|
||||
{
|
||||
if (ch > 96 && ch < 123) return(ch - 32);
|
||||
switch(ch) {
|
||||
case 132: ch = 142; break;
|
||||
case 148: ch = 153; break;
|
||||
case 129: ch = 154; break;
|
||||
default : break;
|
||||
}
|
||||
return(ch);
|
||||
}
|
||||
|
||||
uint8 *upstr(uint8 *s)
|
||||
{
|
||||
if (!s) return((uint8*)NULL);
|
||||
for (;*s;s++) *s=up_char(*s);
|
||||
return(s);
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
uint16 adr1;
|
||||
uint16 adr2;
|
||||
char reserve[6];
|
||||
uint32 ladrs[3];
|
||||
uint16 father_psp_seg;
|
||||
char handles[20];
|
||||
uint16 environ_seg;
|
||||
} PROG_PSP;
|
||||
|
||||
typedef struct {
|
||||
uint8 kennung;
|
||||
uint16 prozess_seg;
|
||||
uint16 blocks;
|
||||
} SPEICH_BLOCK;
|
||||
|
||||
static char *getglobenvironment(uint16 *maxsize, uint16 *aktsize)
|
||||
{
|
||||
static uint16 globmaxenvsize=0;
|
||||
static char *globenviron=NULL;
|
||||
if (globenviron == (char *) NULL) {
|
||||
PROG_PSP *mypsp = MK_FP(_psp, 0);
|
||||
PROG_PSP *fatherpsp = MK_FP(mypsp->father_psp_seg, 0);
|
||||
SPEICH_BLOCK *spb = MK_FP(fatherpsp->environ_seg-1, 0);
|
||||
globenviron = (char *)MK_FP(fatherpsp->environ_seg, 0);
|
||||
globmaxenvsize = spb->blocks * 16;
|
||||
}
|
||||
if (globmaxenvsize){
|
||||
char *search = globenviron;
|
||||
char *maxsearch = search+globmaxenvsize;
|
||||
while (*search && search < maxsearch) {
|
||||
int slen=strlen(search);
|
||||
search+=(slen+1);
|
||||
}
|
||||
*aktsize = max(2, (uint16)(search+1 - globenviron));
|
||||
} else *aktsize=0;
|
||||
*maxsize = globmaxenvsize;
|
||||
/*
|
||||
printf("globenv=%p maxsize=%d, aktsize=%d\n", globenviron, globmaxenvsize, *aktsize);
|
||||
*/
|
||||
return(globenviron);
|
||||
}
|
||||
|
||||
char *getglobenv(char *option)
|
||||
{
|
||||
uint16 maxenvsize;
|
||||
uint16 aktenvsize;
|
||||
char *search = getglobenvironment(&maxenvsize, &aktenvsize);
|
||||
int length = (option == NULL) ? 0 : strlen(option);
|
||||
if (aktenvsize && length){
|
||||
char *maxsearch=search+aktenvsize;
|
||||
while (*search && search < maxsearch) {
|
||||
int slen=strlen(search);
|
||||
if (slen > length && (*(search + length) == '=')
|
||||
&& (strncmp(search, option, length) == 0)) {
|
||||
/*
|
||||
printf("GET GLOB %s=%s\n", option, search+length+1);
|
||||
*/
|
||||
return(search + length + 1);
|
||||
}
|
||||
search+=(slen+1);
|
||||
}
|
||||
}
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
int putglobenv(char *option)
|
||||
{
|
||||
uint16 maxenvsize;
|
||||
uint16 aktenvsize;
|
||||
char *search = getglobenvironment(&maxenvsize, &aktenvsize);
|
||||
int optionlen = (option == NULL) ? 0 : strlen(option);
|
||||
/*
|
||||
printf("PUT GLOB option=%s\n", option);
|
||||
*/
|
||||
if (optionlen && maxenvsize){
|
||||
int length;
|
||||
char *equal;
|
||||
for (equal = option; *equal && *equal != '='; equal++);;
|
||||
length = (int) (equal - option);
|
||||
if (length > 0 && *equal == '='){
|
||||
char *maxsearch=search+aktenvsize;
|
||||
while (*search && search < maxsearch) {
|
||||
int slen = strlen(search);
|
||||
char *nextp = search+slen+1;
|
||||
if (slen > length && (*(search + length) == '=')
|
||||
&& (strncmp(search, option, length) == 0)) { /* gefunden */
|
||||
int diffsize = optionlen-slen;
|
||||
if (diffsize){
|
||||
int movesize = (int)(maxsearch - nextp);
|
||||
if (diffsize > (int)(maxenvsize - aktenvsize))
|
||||
return(-1); /* Kein Platz mehr */
|
||||
if (!*(equal+1)) diffsize -= (length+2);
|
||||
xmemmove(nextp+diffsize, nextp, movesize);
|
||||
}
|
||||
if (*(equal+1)) strcpy(search, option);
|
||||
return(0);
|
||||
}
|
||||
search=nextp;
|
||||
}
|
||||
/* nicht gefunden , nun eintragen, falls m”glich */
|
||||
if (*(equal+1) && optionlen < maxenvsize - aktenvsize) {
|
||||
strcpy(search, option);
|
||||
*(search+optionlen+1) = '\0'; /* letzter Eintrag '\0' nicht vergessen */
|
||||
return(0);
|
||||
} else return(-1);
|
||||
}
|
||||
}
|
||||
return(-1);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue