home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Columbia Kermit
/
kermit.zip
/
ccdos
/
ccsfil.asm
< prev
next >
Wrap
Assembly Source File
|
2020-01-01
|
99KB
|
2,134 lines
NAME ccsfil
; Fle CCSFIL.ASM
;CHINESE
ifdef MSDOS
include mssfil.dat
else
include ccsfil.dat
endif
code segment public 'code'
extrn spack:near, cmblnk:near, locate:near, decout:near, comnd:near
extrn putmod:near, poscur:near, clearl:near, isfile:near
assume cs:code, ds:datas
; Position cursor for an error message
ERPOS PROC NEAR
test flags.remflg,dquiet ; quiet screen?
jnz erpx ; nz = yes
push dx ; save any preexisting message pointer
test flags.remflg,dserial ; serial mode display?
jnz erpo1 ; nz = yes
test flags.remflg,dserver ; are we a server
jnz erp0 ; nz = yes, and display is regular
cmp flags.xflg,1 ; Packet header seen?
jne erp0 ; No, do as normal
erpo1: mov dx,offset crlf
mov ah,prstr
int dos
mcmsg erword ,cerword ; put out word Error
int dos
pop dx ; restore old pointer
ret
erp0:
; mov dx,screrr
mcscr screrr,cscrerr
call poscur
pop dx ; restore old pointer
erpx: ret
ERPOS ENDP
; Position cursor for number of retries message
RTPOS PROC NEAR
test flags.remflg,dquiet ; quiet display mode?
jnz rtpx ; nz = yes
test flags.remflg,dserver ; in server mode?
jnz rtp0 ; nz = yes
cmp flags.xflg,1 ; Packet header seen?
jne rtp0 ; No, do as normal
ret
rtp0: test flags.remflg,dserial ; serial mode display?
jnz rtp1 ; nz = yes
; mov dx,scrnrt
mcscr scrnrt,cscrnrt
call poscur
jmp clearl
rtp1: mcmsg rtword,crtword ; display word Retry
mov ah,prstr
int dos
rtpx: ret
RTPOS ENDP
; Reassure user that we acknowledge his ^X/^Z
INTMSG PROC NEAR
cmp fmtdsp,0 ; non-formatted screen?
je int5 ; e = yes
test flags.remflg,dserver ; server mode?
jnz int4 ; nz = yes
cmp flags.xflg,0 ; Writing to screen?
jne int1 ; Yes. Don't do anything
int4: test flags.remflg,dquiet ; quiet screen?
jnz int1 ; yes, supress msg
test flags.remflg,dserial ; serial mode display?
jz int2 ; ne = no
int5: mov dx,offset crlf ; yes. output initial cr/lf
mov ah,prstr
int dos
jmp int3 ; display the message
int2:
; mov dx,scrint
mcscr scrint,cscrint
call poscur
call clearl
int3: mcmsg infms7,cinfms7 ; File interrupted?
cmp flags.cxzflg,'X' ; Yes.
je int0
mcmsg infms8,cinfms8 ; File group interrupted?
cmp flags.cxzflg,'Z'
je int0
cmp flags.cxzflg,'C' ; just a control-C?
je int1 ; e = yes, suppress msg
mov dl,flags.cxzflg
mov infms9+6,dl ; store interrupt code letter
mcmsg infms9, cinfms9
int0: mov ah,prstr
int dos
int1: ret
INTMSG ENDP
; Print error message that a high bit set char was found in the file
BITERR PROC NEAR
test flags.remflg,dquiet ; remote mode?
jnz biter1 ; nz = yes, no printing
push bx
cmp fmtdsp,0 ; non-formatted display?
je biter3 ; e = yes
test flags.remflg,dserial ; serial mode display?
jz biter2 ; z = no
mov ah,prstr ; display an initial cr/lf
mov dx,offset crlf
int dos
jmp biter3
biter2:
; mov dx,scrhi
mcscr scrhi,cscrhi
call poscur
call clearl
biter3: mov ah,prstr
mcmsg hibit,chibit
int dos
pop bx
biter1: ret
BITERR ENDP
; Clear out message about interrupted file
CXMSG PROC NEAR
test flags.remflg,dserver ; server mode?
jnz cxm1 ; nz = yes
cmp flags.xflg,0 ; Writing to screen?
jne cxm0 ; Yes. Don't do anything
cxm1: test flags.remflg,dquiet+dserial ; quiet or serial display?
jnz cxm0 ; nz = yes
; mov dx,scrint
mcscr scrint,cscrint
call poscur
call clearl
cxm0: ret
CXMSG ENDP
; Clear out the old filename on the screen.
CLRFLN PROC NEAR
test flags.remflg,dquiet ; quiet display?
jnz clrflnx ; nz = yes
test flags.remflg,dserial ; serial display mode?
jnz clrfln1 ; nz = yes, use just cr/lf
; mov dx,scrfln
mcscr scrfln,cscrfln
call poscur
call clearl ; Clear to end of line
ret
clrfln1:push ax ; for serial display, does cr/lf
mov ah,prstr
mov dx,offset crlf
int dos
pop ax
clrflnx:ret
CLRFLN ENDP
PKTSIZE PROC NEAR ; display packet size
cmp fmtdsp,0 ; formatted display?
je pktsiz3 ; e = no, no display
push ax
push dx
mov ax,pack.datlen ; packet size (data part)
add al,trans.chklen ; plus checksum
adc ah,0
add ax,3 ; plus LEN, SEQ, TYPE
cmp ax,94 ; larger than Regular?
jbe pktsiz1 ; be = no
add ax,3 ; add Long Packet len and chksum
pktsiz1:cmp ax,prepksz ; same as previous packet?
je pktsiz2 ; e = yes, skip display
mov prepksz,ax ; remember new value
push ax
; mov dx,scrsz ; position cursor
mcscr scrsz,cscrsz
call poscur
call clearl ; clear to end of line
pop ax
call decout ; show packet length
pktsiz2:pop dx
pop ax
pktsiz3:ret
PKTSIZE ENDP
; some random screen positioning functions
kbpos:
; mov dx,scrkb ; KBytes transferred
mcscr scrkb,cscrkb
test flags.remflg,dquiet+dserial ; quiet or serial display mode?
jnz kbpos1
jmp setup2 ; z = no
kbpos1: ret ; else ignore postioning request
perpos:
; mov dx,scrper ; Percent transferred
mcscr scrper,cscrper
test flags.remflg,dquiet+dserial ; quiet or serial display mode?
jnz perpos1
jmp setup2 ; z = no
perpos1: ret ; else ignore postioning request
frpos:
; mov dx,scrfr ; Say renamed file
mcscr scrfr,cscrfr
jmp setup2
stpos:
; mov dx,scrst ; Print status of file transfer
mcscr scrst,cscrst
jmp setup2
nppos:
; mov dx,scrnp ; Number of packets sent
mcscr scrnp,cscrnp
test flags.remflg,dquiet+dserial ; quiet or serial display mode?
jz setup1 ; z = no
ret
rprpos:
; mov dx,scrrpr ; Reprompt position
mcscr scrrpr,cscrrpr
call setup1 ; position cursor
mov fmtdsp,0 ; turn off formatted display flag
ret
nrtpos:
; mov dx,scrnrt ; Number of retries
mcscr scrnrt,cscrnrt
jmp short setup2
sppos:
; mov dx,scrsp ; Send packet location
mcscr scrsp,cscrsp
jmp short setup1
rppos:
; mov dx,scrrp ; Receive packet location
mcscr scrrp,cscrrp
jmp short setup1
; common service routines for positioning
setup1: test flags.remflg,dquiet+dserial; quiet or serial display mode?
jnz setupa ; nz = yes
cmp fmtdsp,0 ; non-formatted display?
je setupa ; e = yes
jmp poscur
setup2: test flags.remflg,dquiet+dserial; quiet or serial display mode?
jnz setupa ; nz = yes
cmp fmtdsp,0 ; non-formatted display?
je setupa ; e = yes
call poscur ; no
jmp clearl
setupa: test flags.remflg,dquiet ; quiet mode?
jnz setupx ; nz = yes, do nothing
push ax ; display cr/lf and return
push dx
mov dx,offset crlf
mov ah,prstr
int dos
pop dx
pop ax
setupx: ret
; Start recording of statistics for this operation. [jrd]
begtim proc near
test sflag,80h ; is this a duplicate call?
jz begtim1 ; z = no
ret ; else just return
begtim1:push ax
push cx
push dx
xor ax,ax ; clear statistics counters for this file
mov fsta.prbyte,ax ; bytes received from serial port
mov fsta.prbyte+2,ax
mov fsta.psbyte,ax ; bytes sent out serial port
mov fsta.psbyte+2,ax
mov fsta.frbyte,ax ; bytes received for this file
mov fsta.frbyte+2,ax
mov fsta.fsbyte,ax ; bytes sent for this file
mov fsta.fsbyte+2,ax
mov fsta.prpkt,ax ; packets received for this file
mov fsta.prpkt+2,ax
mov fsta.pspkt,ax ; packets sent for this file
mov fsta.pspkt+2,ax
mov fsta.nakrcnt,ax ; NAKs received for this file
mov fsta.nakscnt,ax ; NAKs sent for this file
mov fsta.xstatus,al ; clear status byte
mov ah,getdate ; get current date, convert to ascii
int dos
mov date+9,'0' ; init day of month
begtim2:cmp dl,10 ; day of month. Ten or more days?
jl begtim3 ; l = no
sub dl,10
inc date+9 ; add up tens of days
jmp short begtim2 ; repeat for higher order
begtim3:add dl,'0' ; ascii bias
mov date+10,dl ; day units
mov dl,dh ; months (1-12)
dec dl ; start at zero to index table
mov dh,0
mov di,dx ; months
shl di,1
add di,dx ; times three chars/month
mov al,months[di] ; get text string for month
mov date+12,al
mov ax,word ptr months[di+1]
mov word ptr date+13,ax
mov ax,cx ; year since 1980
mov dx,0
mov di,offset date+16 ; destination
call lnout ; convert number to asciiz in buffer
; start time
mov ah,gettim ; DOS time of day, convert to ascii
int dos
mov fsta.btime,dx ; store ss.s low word of seconds
mov fsta.btime+2,cx ; store hhmm high word of seconds
mov date,'0' ; init begin hours field
begtim4:cmp ch,10 ; ten or more hours?
jl begtim5 ; l = no
sub ch,10
inc date ; add up tens of hours
jmp short begtim4 ; repeat for twenties
begtim5:add ch,'0' ; ascii bias
mov date+1,ch ; store units of hours
mov date+3,'0' ; minutes field
begtim6:cmp cl,10 ; ten or more minutes?
jl begtim7 ; l = no
sub cl,10
inc date+3 ; add up tens of minutes
jmp short begtim6 ; repeat for higher orders
begtim7:add cl,'0' ; ascii bias
mov date+4,cl ; store units of minutes
mov date+6,'0' ; seconds field
begtim8:cmp dh,10 ; ten or more seconds?
jl begtim9 ; l = no
sub dh,10
inc date+6 ; add up tens of seconds
jmp short begtim8 ; repeat for higher orders
begtim9:add dh,'0' ; ascii bias
mov date+7,dh
mov sflag,80h ; say begtim has been run
pop dx
pop cx
pop ax
ret
begtim endp
; Take snapshot of statistics counters at end of an operation
; Enter with ax = 0 for a receive operation, ax = 1 for a send. [jrd]
endtim proc near
test sflag,80h ; called more than once without calling begtim?
jnz endtim1 ; ne = no, so do statistics snapshot
ret ; yes, do nothing
endtim1:and sflag,not (1) ; assume receive operation
or ax,ax ; send (ax > 0), receive (ax = 0) flag
jz endtim2 ; z = receive opeation
or sflag,1 ; say send operation
endtim2:
push ax
push cx
push dx
mov ah,gettim ; get DOS time of day
int dos
mov fsta.etime,dx ; store ss. s
mov fsta.etime+2,cx ; hhmm
cmp cx,fsta.btime+2 ; end time less than start time?
ja endtim2a ; a = above (no need to test low order word)
cmp dx,fsta.btime ; be. How about low order word
jae endtim2a ; ae = no wrap around of time
add ch,24 ; add one day to hours field
endtim2a:sub dl,byte ptr fsta.btime ; 0.01 sec difference
jns endtim2b
dec dh ; borrow a second
add dl,100 ; make difference positive
endtim2b:sub dh,byte ptr fsta.btime+1; seconds difference
jns endtim2c
dec cl ; borrow a minute
add dh,60 ; make difference positive
endtim2c:mov bh,0
mov bl,dh ; bx has seconds difference
sub cl,byte ptr fsta.btime+2 ; minutes
jns endtim2d
dec ch ; borrow an hour
add cl,60
endtim2d:mov al,cl
mov ah,0
mul sixty ; minutes to seconds
add bx,ax ; seconds to bx
sub ch,byte ptr fsta.btime+3 ; hours difference
jns endtim2e
add ch,24
endtim2e:mov al,ch
mov ah,0
mul sixty ; hours to minutes in ax
mul sixty ; minutes to seconds in dx,ax
add ax,bx ; ax = seconds
adc dx,0 ; dx = high word of seconds
mov fsta.etime,ax ; store elapsed time, seconds, low wd
mov fsta.etime+2,dx ; high word
add ssta.etime,ax ; add to session time, low word
adc ssta.etime+2,dx ; add to session time, high word
mov ax,fsta.prbyte ; port bytes received for this file
add ssta.prbyte,ax ; port bytes received for this session
mov ax,fsta.prbyte+2 ; high word
adc ssta.prbyte+2,ax
mov ax,fsta.psbyte ; port bytes sent for this file, low word
add ssta.psbyte,ax ; port bytes sent for this session, low word
mov ax,fsta.psbyte+2 ; high word
adc ssta.psbyte+2,ax
test sflag,1 ; completing a receive operation?
jnz endtim3 ; nz = no, a send operation
mov ax,tfilsz+2 ; file bytes received, low word
mov fsta.frbyte,ax
add ssta.frbyte,ax ; session received file bytes, low word
mov ax,tfilsz ; high word
mov fsta.frbyte+2,ax
adc ssta.frbyte+2,ax
jmp short endtim4
endtim3:mov ax,tfilsz+2 ; file bytes sent, low word
mov fsta.fsbyte,ax ; file bytes sent
add ssta.fsbyte,ax ; session sent file bytes, low word
mov ax,tfilsz ; high word
mov fsta.fsbyte+2,ax
adc ssta.fsbyte+2,ax
endtim4:mov ax,fsta.prpkt ; packets received for this file
add ssta.prpkt,ax ; session received packets
mov ax,fsta.prpkt+2
adc ssta.prpkt+2,ax
mov ax,fsta.pspkt ; packets sent for this file
add ssta.pspkt,ax ; session sent packets
mov ax,fsta.pspkt+2
adc ssta.pspkt+2,ax
mov ax,fsta.nakrcnt ; NAKs received for this file
add ssta.nakrcnt,ax ; session received NAKs
mov ax,fsta.nakscnt ; NAKs sent for this file
add ssta.nakscnt,ax ; session sent NAKs
; do transaction logging
cmp tloghnd,0 ; logging transaction? -1 = not opened
jg endtim5 ; g = logging
jmp endtim12 ; skip logging
endtim5:push di ; kind of transaction
push bx ; save these registers
mov bx,tloghnd ; handle for transaction log
mov dx,offset rcvmsg ; assume receive message
test sflag,1 ; 1 for send, 0 for receive
jz endtim6 ; z = receive
mov dx,offset sndmsg ; send message
endtim6:call strlen ; length of message to cx
mov ah,write2
int dos ; write kind of transfer
; File names
cmp diskio.string,0 ; local filename
je endtim9 ; e = no filename
test sflag,1 ; a send operation?
jnz endtim8 ; nz = yes
; Receive
mov dx,offset fsta.xname ; remote name
call strlen ; length to cx
jcxz endtim7 ; no name
mov ah,write2
int dos
mov dx,offset diskio.string ; local name
call strlen ; length to cx
mov si,offset fsta.xname ; compare these two names
mov di,dx
push ds
pop es
repe cmpsb ; compare
je endtim9 ; e = same, so no 'as' msg
mcmsg fasmsg,cfasmsg ; give 'as' message
mov cx,faslen ; length
mov ah,write2
int dos
endtim7:mov dx,offset diskio.string ; local name
call strlen ; get length
mov ah,write2 ; write local name
int dos
jmp short endtim9
endtim8:mov dx,offset diskio.string ; Send. local name
call strlen
mov ah,write2
int dos
cmp fsta.xname,0 ; using an alias?
je endtim9 ; e = no
; mov dx,offset fasmsg ; give 'as' message
mcmsg fasmsg,cfasmsg
mov cx,faslen
mov ah,write2
int dos
mov dx,offset fsta.xname ; get alias
call strlen
mov ah,write2
int dos
; status of transfer
endtim9:mov dx,offset atmsg ; say At
mov cx,atlen ; length
mov bx,tloghnd ; handle
mov ah,write2
int dos
mov dx,offset date ; write time and date field
mov cx,datelen ; length
mov ah,write2
int dos
mcmsg fsucmsg ,cfsucmsg ; assume success message
cmp fsta.xstatus,0 ; 0 = completed?
je endtim10 ; e = completed
mcmsg fbadmsg,cfbadmsg ; failed message
test fsta.xstatus,80h ; interrupted?
jz endtim10 ; z = no
mcmsg fintmsg, cfintmsg ; interrupted message
endtim10:call strlen ; get length to cx
mov ah,write2
int dos
; file bytes transferred
mov ax,tfilsz+2 ; file bytes, low word
mov dx,tfilsz ; high word
mov di,offset temprp ; work buffer
call lnout ; transform to ascii
mov [di],0a0dh ; append cr/lf
add di,2 ; count them
mov dx,offset temprp ; start of work buffer
mov cx,di ; next free byte
sub cx,dx ; compute length
mov ah,write2
int dos
pop bx
pop di
endtim12:mov tfilsz,0 ; clear file size area
mov tfilsz+2,0
mov sflag,0 ; say have done ending once already
mov fsta.xname,0 ; clear statistics "as" name
pop dx
pop cx
pop ax
ret
endtim endp
; SHOW STATISTICS command. Displays last operation and session statistics
; 9 March 1987 [jrd]
shosta proc near ; show file transfer statistics
mov ah,cmcfm ; confirm with carriage return
call comnd
ret ; not confirmed
nop
nop
call endtim ; update statistics, just in case
push bx
push cx
push dx
mov bx,offset fsta ; pointer to file (Last op) statistics
mov cx,2 ; two sets to display
shosta0:push cx ; save loop counter
cmp cx,2 ; doing Last operation set?
;--Pay attention to the next instructon ' je ... '(eflag), Sept.14,1990[zqf]
; mov cx,offset lastmsg ; totals for last transfer
pushf
mcmsgc lastmsg,clastmsg
popf
je shosta1 ; e = yes
;-----------
mov bx,offset ssta ; point to Session statistics area
; mov cx,offset sessmsg ; totals for whole session
mcmsgc sessmsg,csessmsg
shosta1:
mov ax,[bx].etime ; elapsed time of operation
mov dx,[bx].etime+2
call shoprt ; show result
; mov cx,offset pinmsg ; port bytes received
mcmsgc pinmsg,cpinmsg
mov ax,[bx].prbyte
mov dx,[bx].prbyte+2
call shoprt ; show result
; mov cx,offset poutmsg ; port bytes sent
mcmsgc poutmsg,cpoutmsg
mov ax,[bx].psbyte
mov dx,[bx].psbyte+2
call shoprt ; show result
; mov cx,offset finmsg ; file bytes received
mcmsgc finmsg,cfinmsg
mov ax,[bx].frbyte
mov dx,[bx].frbyte+2
call shoprt ; show result
; mov cx,offset foutmsg ; file bytes sent
mcmsgc foutmsg,cfoutmsg
mov ax,[bx].fsbyte
mov dx,[bx].fsbyte+2
call shoprt ; show result
; mov cx,offset pkimsg ; packets received
mcmsgc pkimsg,cpkimsg
mov ax,[bx].prpkt
mov dx,[bx].prpkt+2
call shoprt ; show result
; mov cx,offset pkomsg ; packets sent
mcmsgc pkomsg,cpkomsg
mov ax,[bx].pspkt
mov dx,[bx].pspkt+2
call shoprt ; show result
; mov cx,offset nakimsg ; naks received
mcmsgc nakimsg,cnakimsg
mov ax,[bx].nakrcnt
xor dx,dx
call shoprt ; show result
; mov cx,offset nakomsg ; naks sent
mcmsgc nakomsg,cnakomsg
mov ax,[bx].nakscnt
xor dx,dx
call shoprt
; compute baud rate as 10 * total port bytes / elapsed time
mov ax,[bx].prbyte ; port bytes received, low
mov dx,[bx].prbyte+2 ; port bytes received, high
add ax,[bx].psbyte ; port bytes sent, low
adc dx,[bx].psbyte+2 ; high. [dx,ax] = total port bytes
mov cx,[bx].etime ; low word of sec in cx
cmp [bx].etime+2,0 ; is high word of sec zero (e.t. < 65536 sec)?
jz shosta3 ; z = yes, ready for arithmetic
push ax ; else scale values, save byte count
push dx
mov ax,[bx].etime ; elapsed time for file, low word
mov dx,[bx].etime+2 ; high word
shr ax,1 ; divide seconds by two, low word
ror dx,1 ; get low bit of high word
and dx,8000 ; pick out just that bit
or ax,dx ; mask in that bit, new time in ax (dx = 0)
mov cx,ax ; save elapsed time (double-seconds)
pop dx ; get byte count again
pop ax
shr ax,1 ; divide byte count by two also
push dx
ror dx,1 ; rotate low bit to high position
and dx,8000h ; get low bit of high word
or ax,dx ; byte count divided by two, low word
pop dx
shr dx,1 ; and high word
shosta3:or cx,cx ; is elapsed time (in cx) zero seconds?
jnz shosta4 ; nz = no
inc cx ; set time to one second (no div by 0)
shosta4:div cx ; bytes div seconds, ax = quo, dx = rem
push dx ; save remainder of bytes/second
mul ten ; quotient times ten to dx,ax
pop dx ; discard overflow, recover remainder
push ax ; save partial baud rate
xchg ax,dx ; remainder to ax
xor dx,dx ; clear extension
mul ten ; remainder times ten too (keep only overflow)
pop ax ; recover main partial result
add ax,dx ; add two partial results
xor dx,dx ; clear extension ( < 65536 baud )
; mov cx,offset baudmsg
mcmsgc baudmsg,cbaudmsg
call shoprt ; show result
pop cx ; recover loop counter
dec cx
jcxz shostax ; cx = 0 means we are done
jmp shosta0 ; do next set of statistics (session stuff)
shostax:
pop dx
pop cx
pop bx
jmp rskp
shosta endp
; Print show statistics line. Enter with CX=offset of initial message,
; dx,ax with long value
shoprt proc near
push ax
push dx
mov dx,cx ; setput initial print
mov ah,prstr ; display title line (dx is ptr)
int dos
pop dx
pop ax
push di
mov di,offset temprp ; work space for output
call lnout ; show long integer
pop di
mov dx,offset temprp
call prtasz ; print asciiz string
ret
shoprt endp
; LNOUT - Table driven unsigned long integer (32 bit) display
; Register dx holds high order word and ax holds low order word of unsigned
; long integer to be stored in decimal. Storage area is given by DS:[DI]
; DI is incremented for each storage, null terminated
; Table TENS holds set of double word values of ten raised to powers 0 to 9
; TENSLEN holds the number of these double words
; All registers preserved. 8 March 1987 [jrd]
lnout proc near
push ax
push bx
push cx
push dx
push si
xor si,si ; flag to say start printing (no leading 0's)
mov cx,tenslen ; number of table entries
lnout1: push cx ; save loop counter
mov bx,cx ; index into tens double word table
dec bx ; index starts at zero
add bx,bx
add bx,bx ; bx times four (double words to bytes)
xor cx,cx ; cx is now a counter of subtractions
lnout2: cmp dx,word ptr tens[bx+2] ; pattern 10**(bx/4), high order part
jb lnout4 ; b = present number is less than pattern
ja lnout3 ; a = present number is larger than pattern
cmp ax,word ptr tens[bx] ; high words match, how about lows
jb lnout4 ; b = present number is smaller than pattern
lnout3: sub ax,word ptr tens[bx] ; subtract low order words
sbb dx,word ptr tens[bx+2] ; subtract high order words, w/borrow
inc cl ; count number of subtractions
inc si ; flag to indicate printing needed
jmp lnout2 ; try again to deduct present test pattern
lnout4: or bx,bx ; doing least significant digit?
jz lnout5 ; z = yes, always print this one
or si,si ; should we print?
jz lnout6 ; z = no, not yet
lnout5: add cl,'0' ; get number of subtractions
mov [di],cx ; store it (ch is still zero), asciiz
inc di
lnout6: pop cx ; recover loop counter
loop lnout1
pop si
pop dx
pop cx
pop bx
pop ax
ret
lnout endp
; Initialize buffers and clear line
INIT PROC NEAR
mov hierr,0 ; clear high-bit-seen flag
test flags.remflg,dquiet ; quiet display mode?
jnz init3 ; nz = yes
test flags.remflg,dserial ; serial mode display?
jnz init2 ; nz = yes
call cmblnk
mcmsg cxzhlp,ccxzhlp
call putmod ; write mode line
mov fmtdsp,1 ; say doing formatted display
test flags.remflg,dserver ; server mode?
jz init1 ; z = no
; mov dx,scrser ; move cursor to top of screen
mcscr scrser,cscrser
call poscur
mov ah,prstr
mcmsg infms1,cinfms1 ; say now in server mode
int dos
init1: call locate
mov ah,prstr ; Put statistics headers on the screen
mcmsg outlin, coutlin
int dos
mov wrpmsg,0 ; haven't printed the messsage yet
mov prepksz,0 ; set previous packet size to zero
ret
init2: mov ah,prstr ; print string
mcmsg cxzser,ccxzser ; status line as a text string
int dos
init3: mov wrpmsg,1 ; suppress display of percentage msg
mov fmtdsp,0 ; say doing unformatted display
ret
INIT ENDP
; Output the chars in a packet
; Called with AX = size of the data, BX = address of source
FILEIO PROC NEAR
ptchr: mov cx,ax
mov ax,offset outbuf ; routine to call when buffer gets full
mov chrcnt,maxpack ; size of buffer Data
mov bufpnt,offset decbuf ; decoded data placed here pending output
mov bx,offset data ; source of data
jmp short decode
; CX = Size of data, BX = Address of data, AX = Routine to call to
; dump data
decode: push si
push di
push es
push dx
push ax
mov ax,ds
mov es,ax
pop ax
mov si,bx ; Source of data
mov bx,ax ; Coroutine to call
mov di,bufpnt ; Destination of data
mov dh,0 ; assume no quote char
cmp trans.ebquot,'N' ; no quoting?
je decod1 ; yes, keep going
cmp trans.ebquot,'Y' ; or not doing it?
je decod1 ; yes, keep going
mov dh,trans.ebquot ; otherwise use quote char
decod1: mov rptct,0 ; Reset repeat count
cmp cx,0 ; any more chars in source?
jg decod2 ; g = yes
jmp decod6 ; Else, we're through
decod2: cld ; forward direction
lodsb ; Pick up a char
dec cx ; count number left
cmp rptq,0 ; Doing repeat quoting?
je dcod21 ; Nope, skip this part
cmp al,rptq ; Did we pick up the repeat quote char?
jne dcod21 ; No, continue processing it
lodsb ; Get the size
dec cx ; Modify buffer count
sub al,20H ; Was made printable
mov rptct,al ; Remember how many repetitions
lodsb ; Get the char to repeat
dec cx ; Modify buffer count
dcod21: mov ah,0 ; Assume no 8-bit quote char
cmp al,dh ; This the 8-bit quot char?
jne decod3 ; ne = no
lodsb ; Get the real character
dec cx ; Decrement # chars in packet
mov ah,80H ; Turn on 8-bit quot char flag
decod3: cmp al,trans.squote ; Is it the quote char?
jne decod4 ; ne = no, proceed
lodsb ; Get the quoted character
dec cx ; Decrement # of chars in packet
or ah,al ; save parity (combine with prefix)
and ah,80h ; only parity
and al,7FH ; Turn off the parity bit
cmp al,trans.squote ; Is it the quote char?
je decod4 ; If so just go write it out
cmp al,dh ; This the 8-bit quot char?
je decod4 ; If so, just go write it out
cmp al,rptq ; Is is the repeat quote character?
je decod4 ; If so, just write it out
cmp al,3fh ; char less than '?' ?
jl decod4 ; l = yes; leave it intact
cmp al,5fh ; char greater than '_' ?
jg decod4 ; g = yes; leave it alone
add al,40H ; Make it a control char again
and al,7FH ; Modulo 128
decod4: or al,ah ; or in parity
dcod41: stosb ; store the character
dec rptct ; Repeat counter
dec chrcnt ; Decrement number of chars in dta
cmp chrcnt,0 ; space left in output buffer?
jg dcod42 ; g = yes
push ax ; Save the char
push cx ; flush output buffer
push dx
push bx
call bx ; Output it if full
jmp decod5 ; Error return if disk is full
nop
pop bx
pop dx
pop cx
mov di,bufpnt
pop ax ; recover repeated char
dcod42: cmp rptct,0 ; Write out char again?
jg dcod41 ; g = yes
jmp decod1 ; No, get next char
decod5: pop bx
pop dx ; dx is pushed twice (really)
pop cx
pop dx
pop es
pop di
pop si
ret
decod6: mov bufpnt,di ; store address for next output char
push cx
push dx
push bx
call bx ; flush output buffer before final ret
jmp decod5 ; Error return if disk is full
nop
pop bx
pop dx
pop cx
pop dx
pop es
pop di
pop si
jmp rskp ; Return successfully if done
; output the buffer, reset bufpnt and chrcnt
outbuf: mov cx,maxpack ; get full size of buffer
sub cx,chrcnt ; minus space remaining = # to write
jnc outbu7
jmp outbf0 ; c = bad buffer pointers
outbu7: jnz outbu6
jmp outb11 ; cx = 0 means nothing to do
outbu6: cmp flags.xflg,1 ; Writing to screen?
jne outbu0
jmp outbf2 ; Yes, handle specially
outbu0:
mov cx,maxpack ; get full size of buffer
sub cx,chrcnt ; minus space remaining = # to write
jc outbf0 ; c = bad buffer pointers
jnz outbu1
jmp outb11 ; cx = 0 means nothing to do
outbu1: push bx
mov dx,offset decbuf ; address of buffer
cmp flags.destflg,1 ; disk destination?
je outbu5 ; e = yes
cmp flags.eofcz,0 ; end on Control-Z?
jne outbu5 ; ne = yes, let DOS do it
push cx ; else map Control-Z to space
push di
push es
push ds
pop es ; datas to es
mov di,dx ; scan buffer es:di, cx chars worth
mov al,ctlz ; look for Control-Z
cld
outbu3: repne scasb
jne outbu4 ; ne = found no Control-Z's
mov byte ptr [di-1],' ' ; replace Control-Z with space
jcxz outbu4 ; z = examined all chars
jmp short outbu3 ; until examined everything
outbu4: pop es
pop di
pop cx
outbu5: mov bx,diskio.handle ; file handle
mov ah,write2 ; DOS 2.0 write
int dos ; Write the record
pop bx
jc outbf0 ; c set means disk writing error
cmp ax,cx ; did we write all the bytes?
je outbf1 ; e = yes
call erpos ; no
mcmsg erms11,erms11 ; Disk full error
cmp flags.destflg,1 ; writing to disk?
je outbu0a ; e = yes
push bx
mov bx,offset decbuf
add bx,ax ; look at break character
cmp byte ptr [bx],ctlz ; ended on Control-Z?
pop bx
je outbf1 ; e = yes, say no error
mcmsg ermes9,cermes9 ; Printer not ready message
outbu0a:mov ah,prstr ; Tell about it
int dos
jmp abfil ; Fix things up before aborting
outbf0: call erpos
mov ah,prstr ; Tell about it
mcmsg erms13,cerms13 ; Disk writing error
cmp flags.destflg,0 ; writing to printer?
jne outbf0a ; ne = no
; mov dx,offset ermes9 ; Printer not ready message
mcmsg ermes9,cermes9
outbf0a:int dos
jmp abfil ; Fix things up before aborting
outbf1: add tfilsz+2,cx ; count received chars
adc tfilsz,0
test flags.remflg,dserial ; serial mode display?
jnz outb11 ; nz = yes, skip kbyte and % displays
call kbpr ; Print the kilobytes received
call perpr ; Print the percent
outb11: mov bufpnt,offset decbuf ; Addr for beginning
mov chrcnt,maxpack ; size of empty buffer
jmp rskp
outbf2: ; writing to screen
mov cx,maxpack ; size of full buffer
sub cx,chrcnt ; minus # of unused in buffer
jle outb11 ; none to print, don't try
add tfilsz+2,cx ; count received chars
adc tfilsz,0
mov di,offset decbuf ; Where they are
call prtscr ; Output buffer to screen
jmp outb11 ; Reset counter & pointer
; Tidy up before aborting. Retidied by [jrd]
ABFIL PROC NEAR
cmp flags.xflg,1 ; Writing to screen?
je abfil1 ; Yes don't delete "file"
mov bx,diskio.handle ; get file handle
cmp bx,4 ; writing to DOS set of files?
jbe abfil1 ; be = yes, never close them
mov ah,close2 ; DOS 2.0 file close
int dos
cmp flags.abfflg,1 ; Delete what got across or keep it?
jne abfil1 ; Nope, keep it
push dx
mov dx,offset diskio.string ; the full file name
mov ah,del2 ; DOS 2.0 file delete
int dos
pop dx
abfil1: mcmsg erms10, cerms10 ; Text of message to send
call errpack ; Send an error packet
ret
ABFIL ENDP
; General routine for sending an error packet. Register BX should
; point to the text of the message being sent in the packet
ERRPACK PROC NEAR
push di
mov di,offset data ; Where to put the message
mov al,0
errp1: mov ah,[bx]
cmp ah,'$' ; At end of message?
je errp2
inc al ; Remember number of chars in msg
mov [di],ah
inc bx
inc di
jmp errp1
errp2: pop di
mov ah,0
mov pack.datlen,ax
mov ah,'E' ; And send an error packet
call spack
nop ; Return if succeed or fail
nop
nop
ret
ERRPACK ENDP
; Get the chars from the file
gtchr: cmp flags.filflg,0 ; Is there anything in the DMA?
je gtchr0 ; e = yes, proceed
mov ah,rptq
mov origr,ah ; Save repeat prefix here
mov rptct,1 ; Number of times char is repeated
mov rptval,0 ; Value of repeated char
call inbuf
jmp gtchr1 ; No more chars, go return EOF
nop ; Make three bytes long
gtchr0: mov bx,offset inbuf
jmp encode
gtchr1: mov ax,0ffffh
ret
; encode - writes data portion of kermit packet into filbuf
; expects BX to contain the address of a routine to refill the buffer,
; chrcnt to be the # of chars in the buffer, trans.maxdat to contain
; the maximum size of the data packet, bufpnt to contain a pointer to
; the source of the characters
; Returns: AX/ the number of characters actually written to the buffer
encode: mov cx,trans.maxdat ; Maximum packet size
push ds
pop es ; make es:di point to datas segment
mov di,offset filbuf ; Where to put the data
mov si,bufpnt ; pointer into source buffer
mov dl,trans.rquote ; send quote char
mov dh,0 ; assume no 8-bit quoting
cmp trans.ebquot,'N' ; not doing 8-bit quoting
je encod1
cmp trans.ebquot,'Y' ; or can but won't?
je encod1
mov dh,0ffh ; remember we have to do it
encod1: cmp cx,0 ; any space left in output buffer?
jg encod2 ; g = yes
sub di,offset filbuf
mov ax,di
mov bufpnt,si ; update pointer into DMA
jmp rskp
encod2: cmp chrcnt,0 ; Any data in buffer?
jg encod3 ; yes, skip over buffer refill
call bx ; Get another buffer full
jmp encod8
mov si,bufpnt ; update position in DMA
cmp chrcnt,0 ; no characters returned?
jne encod3 ; Got some, keep going
jmp encod8 ; none, assume eof
encod3: dec chrcnt ; Decrement input count
cld ; forward direction
lodsb
cmp flags.eofcz,0 ; Is a control-z an end of file?
je encd30 ; No, don't have to look for one
cmp al,'Z'-40H ; Is this a control-Z?
jne encd30 ; No, skip eof-processing
mov flags.eoflag,0FFH ; Yes, set eof flag
mov flags.filflg,0FFH ; No more input in buffer
mov chrcnt,0 ; Ditto
jmp encod8 ; Go set character count and return
encd30: cmp rptq,0 ; Are we doing repeat prefixing?
je encd3x ; Nope, skip next part
cmp chrcnt,0 ; Are we on the last character?
jle encd31 ; Yes, so there's no next character
cmp rptct,94 ; Max number that we can put in a byte
je encd31 ; Then that's it
mov ah,[si] ; Get the next character
cmp al,ah ; Is current char == next char?
jne encd31
inc rptct ; Number of times char appears
mov rptval,al ; Remember the character
jmp encod1 ; Keep checking for more
encd31: cmp rptct,1 ; Were previous characters repeats?
je encd3x ; No, so just add this char
cmp rptct,rptmin ; Are we within bounds for repeat prefixing?
jge encd32 ; Yes, use repeat prefixing
mov al,rptct
mov ah,0
sub si,ax ; Not enough characters to warrant it
mov rptval,0 ; Clear out this value
mov al,rptq
mov origr,al ; Save original repeat prefix
mov rptq,0 ; Pretend we're not doing prefixing
mov al,rptct
mov ah,0
add chrcnt,ax ; Adjust input buffer pointer
jmp encod1 ; Reprocess those characters
encd32: push ax ; Do repeat prefixing - save data
mov al,rptq ; Add repeat prefix char
stosb
dec cx ; Account for it in buffer size
mov al,rptct ; Get the repeat count
add al,20H ; Make it printable
stosb ; Add to buffer
dec cx
pop ax ; Get back the actual character
mov rptct,1 ; Reset repeat count
mov rptval,0 ; And this
encd3x: cmp dh,0 ; are we doing 8-bit quoting?
je encod4 ; e = no, forget this
test al,80h ; parity on?
je encod4 ; no, don't bother with this
and al,7fh ; turn off parity
mov ah,trans.ebquot ; get quote char
mov [di],ah ; put in packet
inc di
dec cx ; decrement # of chars left
encod4: mov ah,al ; save character
and ah,80h ; only parity
and al,7fh ; turn off parity in character
cmp al,' ' ; Compare to a space
jl encod5 ; If less then its a control char
cmp al,del ; Is the char a delete?
je encod5 ; e = yes, go quote it
cmp al,dl ; Is it the quote char?
je encod6 ; e = yes, go add it
cmp dh,0 ; are we doing 8-bit quoting?
je encd41 ; e = no, don't translate it
cmp al,trans.ebquot ; Is it the 8-bit quote char?
je encod6 ; e = yes, just output with quote
encd41: cmp origr,0 ; Doing repeat prefixing?
je encod7 ; e = no, don't check for quote char
cmp al,origr ; Is this the repeat quote character
je encod6 ; e = yes, then quote it
jmp short encod7 ; else don't quote it
encod5: xor al,40h ; control char, uncontrollify
encod6: mov [di],dl ; insert control quote char
inc di
dec cx
encod7: or al,ah ; put parity back
stosb
dec cx ; Decrement output buffer counter
cmp rptct,1 ; One occurence of this char?
jne encd7x
mov al,origr
mov rptq,al ; Restore repeat quote char
jmp encod1 ; Yes, so loop around for some more
encd7x: dec rptct ; Add another entry of this char
jmp encod1 ; With quoting and all
encod8: sub di,offset filbuf
or di,di ; buffer empty?
je encod9 ; e = yes
mov ax,di ; report size encoded
jmp rskp ; return success
encod9: mov ax,-1 ; Get a minus one
ret ; return failure
inbuf: cmp flags.eoflag,0 ; Have we reached the end?
jz inbuf0
ret ; Return if set
inbuf0: push si
push dx
push bx
push cx
mov bx,offset buff ; Set the r/w buffer pointer
mov bufpnt,bx
mov bx,diskio.handle ; get file handle
mov cx,buffsz ; record size
mov dx,bufpnt ; buffer address
mov ah,readf2 ; DOS 2.0 read a record
int dos
jc inbuf1 ; c = error, ie file not open
or ax,ax ; any bytes read?
jne inbuf2 ; ne = yes (the number read)
inbuf1: mov flags.eoflag,0FFH ; Set End-of-file
mov flags.filflg,0ffh ; Buffer empty
mov chrcnt,0 ; zero bytes left in buffer
pop cx
pop bx
pop dx
pop si
ret
inbuf2: add tfilsz+2,ax ; total the # bytes transferred so far
adc tfilsz,0 ; it's a double word
mov chrcnt,ax ; Number of chars read from file
mov flags.filflg,0 ; Buffer not empty
test flags.remflg,dserial ; serial display mode?
jnz inbuf3 ; nz = yes, skip kbyte and % display
push ax
call kbpr ; Print the kilobytes sent
call perpr ; Print the percent sent
pop ax
inbuf3: pop cx
pop bx
pop dx
pop si
jmp rskp
nulref: mov chrcnt,0 ; No data to return
jmp rskp
nulr: ret ; dummy buffer emptier
; Print the number of Kilobytes transferred
kbpr: test flags.remflg,dquiet ; quiet display mode?
jnz kbpr1 ; nz = yes, no printing
push bx
mov ax,tfilsz+2 ; low order word
mov bx,tfilsz ; high order word
add ax,512 ; round up, add half the denominator
adc bx,0
mov al,ah ; divide double word by 1024, in steps
mov ah,bl
shr ax,1
shr ax,1
ror bh,1
ror bh,1
and bh,not (3fh)
or ah,bh ; ax has the result
pop bx
cmp ax,oldkbt ; is it the same?
je kbpr1 ; yes, skip printing
mov oldkbt,ax ; save new # of kb
push ax
call kbpos ; Postion the cursor
pop ax
call decout ; Print number of KBytes transferred
kbpr1: ret
; Print the percent transferred
perpr: test flags.remflg,dquiet ; quiet display mode?
jz perpr1 ; z = no. allow printing
ret ; skip printing in remote mode
perpr1: cmp ofilsz,0 ; high word of original file size > 0 ?
jne perpr3 ; ne = yes, use big file code
cmp ofilsz+2,0 ; anything here at all?
jne perpr2 ; ne = yes, use small file code
ret ; otherwise, quit now
perpr2: push dx ; case for files < 64 Kb
mov ax,ofilsz+2 ; original size (low word)
mov denom,ax
mov dx,tfilsz ;transferred size times 256 in [dx,ax]
mov ax,tfilsz+2
mov dh,dl ; whole value multiplied by 256
mov dl,ah
mov ah,al
mov al,0
mov cx,denom ; round up, add half the denominator
shr cx,1
add ax,cx
adc dx,0
div denom ; (256*xfer)/orig. ax = quo, dx = rem
mul onehun ; multiply quotient above by 100
mov al,ah ; divide result (ax) by 256
mov ah,0 ; percentage is in ax
jmp perpr4 ; finish in common code
perpr3: push dx ; case for file size > 64 KB
mov ax,ofilsz+2 ; original file size low order word
shr ax,1 ; divide by 2
mov al,ah ; divide again by 256 for total of 512
mov ah,0 ; clear ah
mov dx,ofilsz ; high order word
xchg dh,dl ; do shl dx,cl=7
ror dx,1 ; old low bit of dh to high bit of dh
and dl,80h ; clear lower bits. divided by two
or ax,dx ; paste together the two parts into ax
mov denom,ax ; denom = original size divided by 512
mov dx,tfilsz ; high order word of transferred size
mov ax,tfilsz+2 ; low order word
mov cx,denom ; round up, add half the denominator
shr cx,1
add ax,cx
adc dx,0
div denom ; xfer/(512*orig). ax=quot, dx=rem
mul onehun ; times 100 for 512*percentage, in ax
mov al,ah ; divide ax by 512
mov ah,0
shr ax,1 ; final percentage, in ax
perpr4: pop dx
cmp ax,oldper ; same as it was before?
je perpr7 ; yes, don't bother printing
mov oldper,ax ; remember this for next time
cmp wrpmsg,0 ; did we write the percentage message?
jne perpr5 ; ne = yes, skip this part
push ax
call perpos ; position cursor
mcmsg permsg,cpermsg
mov ah,prstr
int dos ; write out message
pop ax
mov wrpmsg,1 ; init flag so we don't do it again
perpr5: push ax
call perpos ; Position the cursor
pop ax
cmp ax,onehun ; > 100% ?
jle perpr6 ; no, accept it
mov ax,onehun ; else just use 100
perpr6: call decout
mov dl,25h ; Load a percent sign
mov ah,conout ; Print the character
int dos
perpr7: ret
; GETFIL, called only by send code
getfil: mov flags.filflg,0ffh ; Say nothing is in the buffer
mov flags.eoflag,0 ; Not the end of file
mov dx,offset diskio.dta ; data transfer address
mov ah,setdma ; set disk transfer address
int dos ; do it
mov cx,0 ; attributes: find only normal files
mov dx,offset diskio.string ; filename string (may have wild cards)
mov ah,first2 ; DOS 2.0 search for first
int dos ; get file's characteristics
pushf ; save c flag
mov ah,setdma ; reset dta address
mov dx,offset buff ; restore dta
int dos
popf ; restore status of search for first
jnc getfi1 ; nc = ok so far
ret ; else take error exit
getfi1:
mov dx,offset diskio.string ; original file spec (may be wild)
mov di,offset templp ; place for path part
mov si,offset templf ; place for filename part
call fparse ; split them
mov si,offset diskio.fname ; current filename from DOS
call strcat ; local path + diskio.fname
mov si,di ; make it a source
mov di,offset diskio.string ; new destination
call strcpy ; new string = old path + DOS's filename
mov ah,open2 ; DOS 2.0 file open
mov al,0 ; open readonly
cmp dosnum,2 ; above DOS 2?
jna getfi1a ; na = no, so no shared access
mov al,0+40h ; open readonly, deny none
getfi1a:mov dx,offset diskio.string ; filename string
int dos
jnc getfi2 ; nc = opened the file
ret ; else take error return
getfi2: mov diskio.handle,ax ; save file handle
mov ax,diskio.sizehi ; get file size (high order word)
mov ofilsz,ax ; new form
mov ax,diskio.sizelo ; low order word
mov ofilsz+2,ax ; new form
mov ax,0
mov tfilsz,ax ; Set bytes sent to zero
mov tfilsz+2,ax
mov ax,-1 ; get a minus one
mov oldkbt,ax
mov oldper,ax
cmp ofilsz,0 ; Null file?
jne getfl0 ; Nope
cmp ofilsz+2,0 ; Null file?
jne getfl0 ; Nope
mov flags.eoflag,0FFH ; yes. Set EOF
getfl0: jmp rskp
; GTNFIL called by send code to get next file. Rewritten by [jrd]
gtnfil: cmp flags.cxzflg,'Z' ; Did we have a ^Z?
jne gtn1 ; ne = no, else done sending files
ret ; take failure exit
gtn1: mov flags.filflg,0ffh ; Nothing in the DMA
mov flags.eoflag,0 ; Not the end of file
mov dx,offset diskio.dta ; point at dta
mov ah,setdma ; set the dta address
int dos
mov ah,next2 ; DOS 2.0 search for next
int dos
pushf ; save carry flag
mov ah,setdma ; restore dta
mov dx,offset buff
int dos
popf ; recover carry flag
jc gtn4 ; carry set means no more files found
call endtim ; get tod of end of file transfer
mov di,offset templp ; place for path part
mov si,offset templf ; place for filename part
mov dx,offset diskio.string ; current full filename
call fparse ; split them
mov si,offset diskio.fname ; new filename part from DOS
call strcat ; rejoin path and new filename
mov si,di ; new source
mov di,offset diskio.string ; place for whole new name
call strcpy ; copy new string
mov dx,offset diskio.string ; address of new string
mov ah,open2 ; DOS 2.0 file open
mov al,0 ; open readonly
cmp dosnum,2 ; above DOS 2?
jna gtn3 ; na = no, so no shared access
mov al,0+40h ; open readonly, deny none
gtn3: int dos
jc gtn4 ; c = could not open the file
mov diskio.handle,ax ; save file handle
call begtim ; start statistics counter
mov ax,diskio.sizehi ; get file size (high order word)
mov ofilsz,ax ; save as original file size
mov ax,diskio.sizelo ; low order word
mov ofilsz+2,ax
mov tfilsz,0 ; Set bytes sent to zero
mov tfilsz+2,0
mov oldkbt,-1
mov oldper,-1
mov ax,1 ; tell statistics this was a send operation
cmp ofilsz,0 ; Null file?
jne gtn2 ; Nope
cmp ofilsz+2,0 ; Null file?
jne gtn2 ; Nope
mov flags.eoflag,0FFH ; Set EOF
gtn2: jmp rskp ; set success condition
gtn4: ret ; set failure condition
; Get the file name from the data portion of the F packet or from locally
; specified override filename (in locfil)
; prints the filename, handles any manipulation of the filename
; necessary, including changing the name to prevent collisions
; Called by READ (receive a file, at rfil32)
gofil: push si
push di
mov si,offset data ; filename in packet
cmp flags.xflg,0 ; receiving to screen
je gofil0a ; e = no
mov diskio.handle,1 ; screen is stdout, handle 1
cmp data,0 ; filename given?
jne gofil0a ; ne = yes
mov si,offset toscreen ; then use this dummy name
gofil0a:mov di,offset diskio.string ; place where prtfn prints name
call strcpy ; copy pkt filename to diskio.string
mov di,offset fsta.xname ; statistics filespec save area
call strcpy ; record external name
pop di
pop si
cmp flags.xflg,0 ; Receiving to screen? (X versus F)
je gofil1 ; e = no
jmp gofi20 ; Yes. so skip this stuff
gofil0: cmp flags.destflg,2 ; file destination = screen?
jne gofil1 ; ne = no
jmp gofi20 ; yes
gofil1: test flags.remflg,dquiet ; quiet display mode?
jnz gofi1c ; nz = yes, don't display filename
call prtfn ; display the packet's filename
gofi1c: mov byte ptr diskio.string,0 ; clear final filename
cmp flags.destflg,0 ; writing to printer?
jne gofi1a ; ne = no, go on
mov ax,offset printer ; this is filename now
mov diskio.handle,4 ; system printer is handle 4
jmp gofi16 ; and do it directly
gofi1a: mov flags.nmoflg,0 ; assume no override name
cmp byte ptr locfil,0 ; overriding name from other side?
jne gofi1e ; ne = yes
jmp gofil4 ; e = No. get the other end's filename
gofi1e: mov flags.nmoflg,0ffh ; say using an override name
mov ax,offset locfil ; get local override filename
cmp word ptr locfil+1,003ah ; colon+null?(primative drive spec A:)
je gofil3 ; e = yes, skip screwy DOS response (No Path)
cmp word ptr locfil,'..' ; parent directory?
jne gofi1g ; ne = noo
cmp word ptr locfil+1,002eh ; dot dot + null?
je gofi1b ; e = yes, process as directory
gofi1g: cmp word ptr locfil,002eh ; dot + null (parent dir)?
je gofi1b ; e = yes, process as directory
call isfile ; does it exist?
jnc gofi1f ; nc = file exists
test filtst.fstat,80h ; serious error?
jz gofil3 ; z = no, just no such file
jmp gofi18a ; else quit here
gofi1f: test byte ptr filtst.dta+21,10H ; subdirectory name?
jnz gofi1b ; nz = yes
cmp byte ptr locfil+2,5ch ; could it be a root directory like b:\?
jne gofi1d ; ne = no. (DOS is not helpful with roots)
cmp byte ptr locfil+3,0 ; and is it terminated in a null?
je gofi1b ; e = yes, so it is a root spec
gofi1d: test byte ptr filtst.dta+21,0fh ; r/o, hidden, system, vol label?
jz gofil3 ; z = no
jmp gofi18a ; yes. Complain and don't transfer file
gofi1b: mov dx,offset locfil ; locfil is a subdirectory name
call strlen ; get its length w/o terminator
jcxz gofil2 ; zero length
dec cx ; examine last char
push bx ; save bx
mov bx,cx
add bx,dx
cmp byte ptr [bx],5ch ; ends in backslash?
je gofil2 ; e = yes
cmp byte ptr [bx],2fh ; maybe forward slash?
je gofil2 ; e = yes
mov byte ptr [bx + 1],5ch ; no slash yet. use backslash
mov byte ptr [bx + 2],0 ; plant new terminator
gofil2: pop bx
gofil3: mov di,offset templp ; local path
mov si,offset templf ; local filename
mov dx,offset locfil ; local string
call fparse ; split local string
mov di,offset temprp ; remote path
mov si,offset temprf ; remote file
mov dx,offset data ; remote string
push bx ; guard against long filenames
mov bx,offset data
mov byte ptr [bx+64],0 ; force filename to be <= 64 text chars
pop bx
call fparse ; split remote string
mov si,offset templp ; copy local path to
mov di,offset data ; final filename
call strcpy ; do the copy
gofi3a: mov si,offset templf ; assume using local file name
cmp byte ptr templf,0 ; local file name given?
jne gofi3b ; ne = yes
mov si,offset temprf ; else use remote file name
gofi3b: call strcat ; do the append
; now offset data holds the new filename
;
gofil4: mov ax,offset data ; assume we're writing to disk
push bx ; guard against long filenames
mov bx,offset data
mov byte ptr [bx+64],0 ; force filename to be <= 64 text char
pop bx
; recheck legality of filename in 'data'
gofil5: mov di,offset temprp ; remote path
mov si,offset temprf ; remote file
mov dx,offset data ; remote string
call strlen ; get original size
push cx ; remember it
call fparse ; further massage filename
push si ; put pieces back together
call verfil ; verify each char in temprf string
mov si,di ; get path part first
mov di,dx ; set destination
call strcpy ; copy in path part
pop si ; recover (new) filename
cmp byte ptr [si],'.' ; does filename part start with a dot?
jne gofil5a ; ne = no
push di ; save regs
push si
mov di,offset rdbuf ; a work area
mov byte ptr [di],'X' ; start name with letter X
inc di
call strcpy ; copy rest of filename
mov di,si
mov si,offset rdbuf ; copy new name back to original location
call strcpy
pop si ; restore regs
pop di
gofil5a:call strcat ; append it
call strlen ; see if we chopped out something
pop si ; get original length (from push cx above)
cmp cx,si ; same size?
je gofil9 ; e = yes
mov flags.nmoflg,0ffh ; say that we have a replacement name
; filename is now in 'data', all converted
gofil9: test flags.remflg,dquiet ; quiet display mode?
jnz gofi10 ; nz = yes, don't print it
cmp flags.nmoflg,0 ; using local override name?
je gofi10 ; e = no
mov ah,prstr
; mov dx,offset asmsg ; print " as "
mcmsg asmsg,casmsg
int dos
mov dx,offset data ; plus the local filename
call prtasz ; print asciiz string
gofi10: mov ax,offset data ; point to name
cmp flags.flwflg,0 ; Is file warning on?
jne gofi100
jmp gofi16 ; e = no, just proceed
gofi100:call isfile ; does it exist?
mov ax,offset data ; reload ptr in case
jc gofi16 ; carry set = no, just proceed
mov ah,open2 ; could it be a device name?
mov al,0 ; open readonly
cmp dosnum,2 ; above DOS 2?
jna gofi10a ; na = no, so no shared access
mov al,0+40h ; open for reading, deny none
gofi10a:mov dx,offset data ; the filename
int dos
jc gofi11 ; c = cannot open so just proceed
mov bx,ax ; file handle
mov ah,ioctl
mov al,0 ; get info
int dos
mov ah,close2 ; close it
int dos
mov ax,offset data ; point to filename again
test dl,80h ; ISDEV bit set?
jz gofi11 ; z = no, not a device
jmp gofi16 ; device, use name as given
gofi11: call unique ; generate unique name
jc gofi14 ; could not generate a unique name
test flags.remflg,dquiet ; quiet display mode?
jnz gofi13 ; nz = yes, skip printing
push ax ; save unique name again
call frpos ; Position cursor.
mov ah,prstr ; Inform the user we are renaming the file
mcmsg infms5,cinfms5
int dos
pop ax ; get name back into ax again
push ax ; save around these calls
mov dx,ax ; print current filename
call prtasz ; display filename
pop ax ; pointer to name, again
gofi13: jmp gofi16 ; and go handle file
gofi14: mcmsg ermes4, cermes4
test flags.remflg,dquiet ; quiet display mode?
jnz gofi15 ; nz = yes, no printing
call erpos ; Position cursor
mov ah,prstr ; Tell the user we can't rename it
int dos
gofi15: mov bx,dx ; Tell host can't rename
call errpack ; Send error packet before abort
ret
gofi16: mov si,ax ; pointer to (maybe new) name
mov di,offset diskio.string ; filename, used in open
mov dx,di ; for isfile and open below
call strcpy ; copy name to diskio.string
mov ax,0
mov ofilsz,ax ; original file size is unknown
mov ofilsz+2,ax ; double word
mov tfilsz,ax ; Set bytes received to zero
mov tfilsz+2,ax
mov ax,-1 ; get a minus one
mov oldkbt,ax
mov oldper,ax
mov diskio.handle,ax ; clear handle of previous usage
mov ax,dx ; filename for isfile
call isfile ; check for read-only/system/vol-label/dir
jc gofi16a ; c = file does not exist
test byte ptr filtst.dta+21,1fh ; the no-no file attributes
jz gofi16b ; z = ok
jmp gofi18 ; nz = shouldn't write over one of these
gofi16a:test filtst.fstat,80h ; access problem?
jnz gofi18 ; nz = yes, quit here
mov diskio.handle,-1 ; clear handle of previous usage
mov ah,creat2 ; DOS 2.0 create file
mov cx,0 ; attributes bits
int dos
jc gofi16b ; c = did not work, try regular open
mov diskio.handle,ax ; save file handle here
call begtim ; start file loggging
jmp rskp
gofi16b:test byte ptr filtst.dta+21,1bh ; r/o, hidden, volume label?
jnz gofi18 ; we won't touch these
mov ah,open2 ; open existing file (usually a device)
mov al,1+1 ; open for writing
int dos
jc gofi18 ; carry set means can't open
mov diskio.handle,ax ; file handle
call begtim ; start file loggging
jmp rskp
gofi18a:mov si,ax ; pointer to local override name
mov di,offset diskio.string ; filename, used in open
call strcpy ; copy name to diskio.string
; fall through to gofi18
gofi18: test flags.remflg,dquiet ; quiet display mode?
jnz gofi19 ; nz = yes, don't try printing
call erpos ; Position cursor
mov ah,prstr ; tell the user
mcmsg erms12,cerms12
int dos
mov dx,offset diskio.string ; print offending name
call prtasz ; display filename
gofi19:
;mov dx,offset erms12 ; reset error message for packet
mcmsg erms12,cerms12
mov bx,dx
call errpack ; Send an error packet
ret
gofi20: cmp pack.datlen,0 ; Any data in "X" packet?
je gofi21 ; Nothing to print.
mov ah,prstr
mov dx,offset crlf
int dos
int dos ; Print another crlf
mov di,offset data ; Where data is
mov cx,pack.datlen ; How much data we have
call prtscr ; Print it on the screen
mov ah,prstr
mov dx,offset crlf
int dos
gofi21: jmp rskp ; And done
FILEIO ENDP
; Given incoming filename in 'data'. Verify that each char is legal
; (if not change it to an "X"), force max of three chars after a period (dot)
; Source is at ds:si (si is changed here). [jrd]
VERFIL PROC NEAR
push es ; verify each char in 'data'
push cx
mov ax,ds
mov es,ax
mov havdot,0 ; say no dot found in name yet
cld
verfi1: lodsb ; get a byte of name from si
and al,7fH ; strip any eight bit
cmp al,0 ; end of name?
je verfi5 ; e = yes
cmp al,'.' ; a dot?
jne verfi2 ; ne = no
cmp havdot,0 ; have one dot already?
jne verfi3 ; ne = yes, change to X
mov byte ptr [si+3],0 ; forceably end filename after 3 char ext
mov havdot,1 ; say have a dot now
jmp verfi4 ; continue
verfi2: cmp al,3ah ; colon?
je verfi4
cmp al,5ch ; backslash path separator?
je verfi4
cmp al,2fh ; or forward slash?
je verfi4
cmp al,'0'
jb verfi3 ; See if it's a legal char < '0'
cmp al,'9'
jbe verfi4 ; It's between 0-9 so it's OK
cmp al,'A'
jb verfi3 ; Check for a legal punctuation char
cmp al,'Z'
jbe verfi4 ; It's A-Z so it's OK
cmp al,'a'
jb verfi3 ; Check for a legal punctuation char
cmp al,'z'
ja verfi3
and al,5FH ; It's a-z, capitalize
jmp verfi4 ; continue with no change
verfi3: push di ; special char. Is it on the list?
mov di,offset spchar2 ; list of acceptable special chars
mov cx,spc2len
cld
repne scasb ; Search string for input char
pop di
je verfi4 ; e = in table, return it
mov al,'X' ; else illegal, replace with "X"
mov flags.nmoflg,0FFH ; say we have a replacement filename
verfi4: mov [si-1],al ; update name
jmp verfi1 ; loop thru rest of name
verfi5: mov byte ptr[si-1],0 ; make sure it's null terminated
pop cx
pop es
ret
VERFIL ENDP
; find a unique filename... Upgraded by [jrd]
; Enter with a pointer to a (null-terminated) filename in ax
; Return with same pointer but with a new name (or old if failure)
; Success = carry clear; failure = carry set
; The idea is to pad out the main name part (8 chars) with ascii zeros and
; then change the last chars successively to a 1, 2, etc. until
; a unique name is found. All registers are preserved
; Add patch to make empty main name fields start with letter X, not digit 0
; 23 March 1986 [jrd]
unique proc near
push bx
push cx
push dx
push si
push di
push es
push ax ; save address of source string
mov dx,ds ; make es use ds segment
mov es,dx
mov dx,ax ; point at original filename string
mov di,offset templp ; place for path
mov si,offset templf ; place for filename
call fparse ; separate path (di) and filename (si)
mov dx,di ; point at path part
call strlen ; put length in cx
mov si,ax ; point to original string
add si,cx ; point to filename part
mov di,offset templf ; destination is temporary location
mov cx,0 ; a counter
cld ; set direction to be forward
uniq1: lodsb ; get a byte
cmp al,'.' ; have a dot?
je uniq2 ; e = yes
cmp al,0 ; maybe null at end?
jne uniq3 ; ne = no. continue loop
uniq2: cmp cl,8 ; have we copied any chars before dot?
jge uniq3 ; ge = all 8
mov byte ptr [di],'0' ; avoid clobbers; pad with 0's
cmp cl,0 ; first char of filename?
jne uniq2a ; ne = no
mov byte ptr [di],'X' ; start name with letter X, not 0
uniq2a: inc di ; and count the output chars
inc cl ; and this counter too
jmp uniq2 ; continue until filled 8 slots
uniq3: inc cl ; cl = # char in destination
stosb ; store the char
cmp al,0 ; null at end?
jne uniq1 ; ne = no, continue copying
mov di,offset templf
add di,7 ; address of last name char
mov byte ptr [di],'1' ; put '1' in last name char
mov unum,1 ; start with this generation digit
uniq4: mov di,offset rdbuf ; build a temporary full filename
mov si,offset templp ; path part
call strcpy ; copy that much
mov si,offset templf ; get rebuilt filename part
call strcat ; paste that to the end
mov ax,offset rdbuf ; point to full name
call isfile ; does it exist?
jc uniq6 ; c = no, succeed now
inc unum ; move to next generation
mov di,offset templf ; position for characters
add di,7 ; point to last name char
mov cx,7 ; max # of digits to play with
mov bx,10 ; divisor (16 bits)
mov ax,unum ; low order part of generation #
uniq5: mov dx,0 ; high order part of generation #
div bx ; compute digit (unum / 10)
add dl,'0' ; make remainder part printable
mov byte ptr [di],dl ; put into right place
cmp ax,0 ; any more to do? (quotient nonzero)
jz uniq4 ; z = no, try this name
dec di ; else decrement char position
loop uniq5 ; and keep making a number
stc ; failure: set carry, keep old name
jmp short uniq7 ; and exit
uniq6: pop di ; address of original filename
push ax ; save for exit clean up
mov si,offset rdbuf
call strcpy ; copy new filename over old
clc ; success: clear carry flag
uniq7: pop ax
pop es
pop di
pop si
pop dx
pop cx
pop bx
ret
unique endp
; [jrd]
; strlen -- computes the length, excluding the terminator, of an asciiz
; string. Input: dx = offset of the string
; Output: cx = the byte count
; Normal 'ret' return. All registers except cx are preserved
;
STRLEN PROC NEAR
push di
push es
push ax
mov ax,ds ; use proper segment address
mov es,ax
mov di,dx
mov cx,0ffffh ; large byte count
cld ; set direction to be forward
mov al,0 ; item sought is a null
repne scasb ; search for it
add cx,2 ; add for -1 and auto dec in scasb
neg cx ; convert to count, excluding terminator
pop ax
pop es
pop di
ret
STRLEN ENDP
; [jrd]
; strcat -- concatenates asciiz string 2 to the end of asciiz string 1
; offset of string 1 is expected to be in ds:di. input & output
; offset of string 2 is expected to be in ds:si. input only (unchanged)
; Preserves all registers. No error returns, returns normally via ret
;
STRCAT PROC NEAR
push di ; save work registers
push si
push es
push dx
push cx
push ax
mov ax,ds ; get data segment value
mov es,ax ; set es to ds for implied es:di usage
mov dx,di
call strlen ; get length (w/o terminator) of dest string
add di,cx ; address of first terminator
mov dx,si ; start offset of source string
call strlen ; find its length too (in cx)
inc cx ; include its terminator in the count
rep movsb ; copy source string to end of output string
pop ax
pop cx
pop dx
pop es
pop si
pop di
ret
STRCAT ENDP
; [jrd]
; strcpy -- copies asciiz string pointed to by ds:si into area pointed to by
; ds:di. Returns via ret. All registers are preserved
;
STRCPY PROC NEAR
mov byte ptr [di],0 ; clear destination string
call strcat ; let strcat do the real work
ret
STRCPY ENDP
; [jrd]
; fparse -- separate the drive:path part from the filename.ext part of an
; asciiz string. Characters separating parts are \ or / or :
; Inputs: asciiz input full filename string offset in ds:dx
; asciiz path offset in ds:di
; asciiz filename offset in ds:si
; Outputs: the above strings in the indicated spots
; Strategy is simple. Reverse scan input string until one of the
; three separators is encountered and then cleave at that point
; Simple filename construction restrictions added 30 Dec 1985;
; to wit: mainname limited to 8 chars or less,
; extension field limited to 3 chars or less and is found by searching
; for first occurence of a dot in the filename field. Thus the whole
; filename part is restricted to 12 (8+dot+3) chars plus a null
; All registers are preserved. Return is always via ret
; (Microsoft should have written this for DOS 2.x et seq.)
FPARSE PROC NEAR
push cx ; local counter
push ax ; local work area
push es ; implied segment register for di
push di ; offset of path part of output
push si ; offset of file name part of output
mov ax,ds ; get data segment value
mov es,ax ; set es to ds for implied es:di usage
mov byte ptr [si],0 ; clear outputs
mov byte ptr [di],0
push si ; save original file name address
mov si,dx ; get original string address
call strcpy ; copy string to original di
call strlen ; find length (w/o terminator), in cx
mov si,di ; address of string start
add si,cx
dec si ; si = address of last non-null char
jcxz fpars5 ; if null skip the path scan
; now find last path char, if any
; start at the end of input string
std ; set direction to be backward
fpars4: lodsb ; get a byte (dec's si afterward)
cmp al,5ch ; is it a backslash ('\')?
je fpars6 ; e = yes
cmp al,2fh ; or forward slash ('/')?
je fpars6 ; e = yes
cmp al,3ah ; or even the drive terminator colon?
je fpars6 ; e = yes
loop fpars4 ; else keep looking until cx == 0
; si is at beginning of file name
fpars5: dec si ; dec for inc below
fpars6: inc si
inc si ; si now points at first filename char
; cx holds number of path chars
; get original file name address (si)
pop di ; and make it place to copy filename
cld ; reset direction to be forward
mov ax,si ; ax holds filename address for awhile
push dx
mov dx,si ; strlen wants string pointer in dx
call strlen ; get length of filename part into cx
pop dx
jcxz fpar7a ; any chars to look at? z = no
fpars7: cmp byte ptr [si],'.' ; look for a dot in filename
je fpars8 ; e = found one
inc si ; look at next filename char
loop fpars7 ; keep looking until cx = zero
fpar7a: mov si,ax ; no dot. recover starting address
mov byte ptr [si+8],0 ; forcably truncate mainname to 8 char
call strcpy ; copy this part to filename field
jmp fparsx ; and exit
fpars8: mov byte ptr [si+4],0 ; plant terminator after dot + 3 ext chars
mov cx,si
sub cx,ax ; cx now = number of chars in mainname field
cmp cx,9 ; more than 8?
jb fpars9 ; b = no, we're safe
mov cx,8 ; limit ourselves to 8 chars in mainname
fpars9: push si ; remember address of dot and extension
mov si,ax ; point to start of input filename
rep movsb ; copy cx chars from si to di (output)
mov byte ptr [di],0 ; plant terminator where dot goes
pop si ; source = dot and extension address
call strcat ; append the dot & ext to the filename field
fparsx: mov si,ax ; recover start of filename in input string
mov byte ptr [si],0 ; terminate path field
pop si
pop di
pop es
pop ax
pop cx
ret
FPARSE ENDP
; Print filename in offset data. Shortened by [jrd]
PRTFN PROC NEAR
push ax ; saves for messy clrfln routine
push bx
push cx
push dx
push di
call clrfln ; Position cursor & blank out the line
mov dx,offset diskio.string
call strlen ; compute length of asciiz string in cx
mov di,dx ; where prtscr wants its string
call prtscr
pop di
pop dx
pop cx
pop bx
pop ax
ret
PRTFN ENDP
; Print string to screen from offset ds:di for # bytes given in cx,
; regardless of $'s. All registers are preserved. [jrd]
PRTSCR PROC NEAR
jcxz prtscr4 ; cx = zero means nothing to show
push ax
push bx
push dx
mov dx,di ; source ptr for DOS
cmp flags.eofcz,0 ; end on Control-Z?
jne prtscr3 ; ne = yes, let DOS do it
push cx ; else map Control-Z to space
push di
push es
push ds
pop es ; datas to es
mov al,ctlz ; look for Control-Z
cld ; scan buffer es:di, cx chars worth
prtscr1:repne scasb
jne prtscr2 ; ne = found no Control-Z's
mov byte ptr [di-1],' ' ; replace Control-Z with space
jcxz prtscr2 ; z = examined all chars
jmp short prtscr1 ; until examined everything
prtscr2:pop es
pop di
pop cx
prtscr3:mov bx,1 ; stdout file handle
mov ah,write2
int dos
pop dx
pop bx
pop ax
prtscr4:ret
PRTSCR ENDP
; Print to screen asciiz string given in ds:dx. Everything preserved. [jrd]
PRTASZ PROC NEAR
push cx
push di
call strlen ; get length of asciiz string
mov di,dx ; where prtscr looks
call prtscr ; print counted string
pop di
pop cx
ret
PRTASZ ENDP
; Jumping to this location is like retskp. It assumes the instruction
; after the call is a jmp addr
RSKP PROC NEAR
pop bp
add bp,3
push bp
ret
RSKP ENDP
code ends
end
