ProfitPress Mega CDROM2 Shareware Freeware (MSDOS)(1992)(Eng)

home *** CD-ROM | disk | FTP | other *** search

/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / BBS / RBBS_PC / MSGTOS2B.ZIP / SPAZ_150.ZIP / SPAZ.ASM next >

Wrap

Assembly Source File | 1990-10-07 | 65.5 KB | 2,044 lines

;---------------------------------------------------------------------; ; ; ; SPAZ 1.50 ; ; October 7, 1990 ; ; ; ; By Dan Thomson, Andrew Farmer and Jeffrey Nonken. ; ; ; ; ; ; SOURCE CODE ; ; ; ; ; ; Copyright (c) 1989-1990 Dan Thomson and Andrew Farmer. ; ; All Rights Reserved. ; ; ; ;---------------------------------------------------------------------; name SPAZ page 60,132 title Smart Pak, Arc and Zoo Shell false equ 00h tab equ 09h ;ASCII tab lf equ 0ah ;ASCII line feed cr equ 0dh ;ASCII carriage return blank equ 20h ;ASCII blank arc_len equ 21h ;Only save info for sort DOS equ 21h ;DOS int call CntrolC equ 23h ;Control C checking... cmdtail equ 80h ;Offset to command tail true equ 255 bsize equ 4096 ;Size of copy buffer ; If you have lots of memory, (Not running a multi-tasker) then the ; following variables can be changed to allow running SPAZ a little ; faster, but using alot more memory.... ; 1. Entries is the number of members in a standard ARC file that ; can be stored for sorting. If an ARC has more than 150, the ; file is not sorted. This can be increased until buffers reach ; (64K - code size). Each entry needs 29 bytes of buffer space. Entries equ 150 ; 2. This entry controls how many file names will be stored in ; memory. This is used during wild card processing to run ; SPAZ on each individual name. It has been set at 30 to ; allow most systems to run without writing to disk. If you ; run a busy mail system or process alot of archives, this ; can be increased (at the cost of memory) for faster processing. NamesFound equ 30 ;DOS interupt equates... CharacterOutput equ 02h OutputString equ 09h SetDTA equ 1ah SetVector equ 25h GetVector equ 35h CreateFile equ 3ch OpenFile equ 3dh CloseFile equ 3eh ReadFile equ 3fh WriteFile equ 40h DeleteFile equ 41h MoveFilePointer equ 42h GetOrSetAttribute equ 43h ModifyMemory equ 4ah ExecuteProgram equ 4bh ExitWithCode equ 4ch GetReturnCode equ 4dh SearchForFirst equ 4eh SearchForNext equ 4fh RenameFile equ 56h cseg segment para public 'code' assume cs:cseg,ds:cseg,es:cseg,ss:cseg org 100h ;Skip to end of the PSP entry: jmp start ;comm file entry always 0100H TitleScreen db cr,lf,'SPAZ 1.50; Written by Dan Thomson, Andrew Farmer and Jeffrey Nonken.',cr,lf db 'Copyright (c) 1989-1990 Dan Thomson & Andrew Farmer. All Rights Reserved.',cr,lf TitleLength equ $-TitleScreen Usage db cr,lf,'Syntax/Usage: SPAZ [switches] Path\Archive [switches] [files....]' db cr,lf,'Square brackets indicate optionals. Switches are set with - or /.' db cr,lf,cr,lf,'Switches:',cr,lf,cr,lf db ' -A Will use ONLY "ARCE" on standard (ARC Style) archives.',cr,lf db ' -D Will delete the archive if the extract was successful.',cr,lf db ' -F Will process all Compressed Mail bundles found in Dir.',cr,lf db ' -Maddr Will calculate Compressed Mail bundle name to show the',cr,lf db ' sending Net Address. "addr" is YOUR Net/Node address.',cr,lf db ' -N Will NOT attempt to sort the archive prior to extract.',cr,lf db ' -O|-R Overwrite. Will NOT prompt if existing file is found.',cr,lf db ' -V Verbose Mode. Will display the runtime configuration.',cr,lf,cr,lf db 'If -F is used then "Archive" MUST be a Path ONLY, not a Filename.',cr,lf db 'Use of -F forces -D and -O to be set TRUE and -N to be set False.',cr,lf UsageLength equ $-Usage even errmsg dw err2,err2,err2,err4,err5,err13 dw err13,err8,err8,err10,err11,err5 dw err13,err15,err15,err2,err2,err2 dw err20,err20,err21,err22,err23,err24,err25 err2 db cr,lf,'File not found: ',0 err4 db cr,lf,'Too many open files.',cr,lf,0 err5 db cr,lf,'Access denied.',cr,lf,0 err8 db cr,lf,'Insufficient memory.',cr,lf,0 err10 db cr,lf,'Invalid environment.',cr,lf,0 err11 db cr,lf,'Invalid format.',cr,lf,0 err13 db cr,lf,'Invalid data.',cr,lf,0 err15 db cr,lf,'Invalid drive was specified.',cr,lf,0 err20 db cr,lf,'Invalid file format, not changed.',cr,lf,0 err21 db cr,lf,'Too many archive entries.',cr,lf,0 err22 db cr,lf,'Unarchiver not found on path.',cr,lf,0 err23 db cr,lf,'Invalid Command Line Option used.',cr,lf,0 err24 db cr,lf,'Archive name not specified!',cr,lf,0 err25 db cr,lf,'Invalid directory specified.',cr,lf,'$' NoMail db cr,lf,'No Compressed Mail Bundles Found in Directory!',cr,lf,cr,lf,'$' SortErr db 'Sort failed, attempting extract anyway...',cr,lf,0 zerr db 'Problem reading archive for type check.',cr,lf,0 crlf equ $-3 TempErr db 'Unable to process temporary file, aborting.',cr,lf,'$' del_msg db cr,lf,'Extract successful - Unlinking ',0 will db cr,lf,'Will ',0 wont db cr,lf,'Will NOT ',0 info1 db 'use ARCE on standard (ARC style) archives.',0 info2 db 'delete the archives if extract was successful.',0 info3 db 'attempt to sort the archives.',cr,lf,0 info4 db ' - From: ',0 info5 db 'expand network addresses.',0 info6 db 'process Compressed Mail bundles ONLY.',0 info7 db 'operate in overwrite mode.',0 msg1 db ' Adjusting: ',0 msg2 db '- Location = ',0 msg3 db ' Length = ',0 msg4 db 'Searching: ',0 UnArc1 db 'PKXARC.EXE',0 UnArc2 db 'PKXARC.COM',0 UnArc3 db 'PKUNPAK.EXE',0 UnArc4 db 'LOOZ.EXE',0 UnArc5 db 'PAK.EXE',0 UnArc6 db 'ARCE.COM',0 UnArc7 db 'ZOO.EXE',0 UnArc8 db 'DWC.EXE',0 UnArc9 db 'PKUNZIP.EXE',0 UnArc10 db 'LHARC.EXE',0 on_disk db 0 ;True if names on disk .jjn num_names db 0 ;# of filenames in buffer .jjn num_hdr db 0 ;Number of headers input first db true ;Flag for search first/next flag db false ;Show sort done on pass Zooflag db false ;Flag to signify zoo file Crushed db false ;Flag to signify crushed files A_Flag db false ;Set no default archiver D_Flag db false ;Set no delete when finished F_Flag db false ;Set no mail only stuff M_Flag db false ;Show net/node on extract? N_Flag db true ;Set default sort performed O_Flag db false ;Set default to non-overwrite Q_Flag db true ;Set default to quiet IsZip db false ;Flag to show ZIP file IsDWC db false ;Flag to show DWC file IsLZH db false ;Flag to show LZH file Parsed db false ;Flag to show names were parsed Got_name db false ;Cmd line fname is OK... Characters db false ;Print string char counter Last_Chance db false ;Flag for Arce useage elevel db 0 ;Last reported error level count db 0 ;Number of passes complete order db 0 ;Flag to show archive in order temp db 'SpazTmp1.$$$',0 ;Temp filename to use thomlen equ $-temp ; .jjn filename_file db 'SpazTmp2.$$$',0 ;Filename for list of files end_arc db 1Ah,0 ;Mark to show end of arc even arg_len dw 0 ;Length of command line arg buf_pos dw 0 ;Position in header buffer endpath dw 0 ;Holds end of path address pathlen dw 0 ;Holds length of path .jjn files_handle dw 0 ;Handle for filespec file .jjn name_count dw 0 ;Number of filenames found .jjn names_used dw 0 ;Number of names used after.jjn ; all the names were found .jjn fname_ptr dw 0 ;Point into filename buffer.jjn Opt_Address dw false ;Pointer to cmd line fname Opt_Length dw false ;Address of cmd line fname high_pos dw 0 ;High byte of file pointer low_pos dw 0 ;Low byte of file pointer in_handle dw 0 ;Handle for read file out_handle dw 0 ;Handle for write file par_blk dw 0 ;Copy of parent's environment dw offset cmd_cnt ;Pointer to command line sg1 dw 0 dw offset fcb1 sg2 dw 0 dw offset fcb2 sg3 dw 0 stk_seg dw 0 ;Saved stack segment stk_ptr dw 0 ;Saved stack pointer dir dw 0 ;Pointer for PATH search enddir dw 0 ;End address of PATH variable cmd1_cnt dw 0 ;Length of wildcard filename env_len dw 0 ;Length of PATH in Environment BundlePosition dw offset BundleNames ;Current position for mail env db 'PATH',0 ;Environment variable to find DefaultBundle db '*.MO?',0 ;First mail type to look for BundleNames db 'TUWETHFRSASU' ; and the rest of 'em.... Spaz proc near ;Entry point from MS-DOS start: mov AX,CS mov sg1,AX mov sg2,AX mov sg3,AX mov AH,SetDTA ;AH = Set Disk Tranfer Area mov DX,offset dta_buf ;Address of scratch space int DOS ;Give it to DOS xor AX,AX mov word ptr Names_Count,AX cli ;Disable interupts lea sp,bottom-1 ;Move stack to save position sti ;OK for interups now... mov DX,offset bottom ;Point DX to end of Spaz mov BX,DX ;Info needed in BX add BX,0fh ;Add 1 paragraph to it mov CL,4 ;CL = counter for shift shr BX,CL ;= BX/16 (# of paras needed) mov AH,ModifyMemory ;AH = Modify memory block int DOS ;Extra memory released... ; First, identify self and examine parameters... mov DX,offset TitleScreen ;DX points to message mov BX,2 ;Output to standard error mov CX,TitleLength ;Length of header string mov AH,WriteFile ;Output to handle int DOS ;Call DOS to do it mov SI,offset env ;Search for 'PATH' mov es,es:[2ch] ;Get environment segment call getenv ;Read in PATH string mov BX,cmdtail ;ES:BX = command parameters call argc ;Get number of arguments cmp AX,2 ;At least 1 argument? jae args_ok ;If yes, keep going Syntax: mov DX,offset Usage ;DX points to usage string mov BX,2 ;Output to standard error mov CX,UsageLength ;Length of usage string mov AH,WriteFile ;Output to handle int DOS ;Call DOS to do it mov AL,0 ;Errorlevel 0 exit mov AH,ExitWithCode ;AH = Terminate to DOS int DOS ;Transfer to DOS (for good) args_ok: call options ;Scan off any options ; Here, ES:BX = argument address and AX = argument length cld ;Direction register increments mov SI,BX ;Point SI to argument lea DI,cmd1 ;DI = destination mov CX,AX ;Put character count in CX mov cmd1_cnt,AX ;And save it for later! rep movsb ;Move argument to buffer ; End the filename (or PATH if -F used) with a zip. mov byte ptr [DI],0 ; Here, we check for a -F option. If it is true, we tack on the ; default filename (*.MO?) and start a mail run. cmp F_Flag,true ;Is this a mail run? jne NotAMailRun ;Nope, continue cmp byte ptr [DI-1],'\' ;Did they have backslash? je AddName ;If yes, do the name mov byte ptr [DI],'\' ;Else add a slash inc word ptr cmd1_cnt ;And bump counter inc DI ;Adjust pointer AddName: mov byte ptr [DI-1],0 ;Make it ASCIIZ mov DX,offset cmd1 ;Point to filename/path mov AX,4300h ;Get attribute int DOS ;Call DOS to do it mov byte ptr [DI-1],'\' ;Restore back slash and CX,00010000b ;Is this a directory? jnz DirectoryFound ;Go if yes. mov DX,offset err25 ;Invalid directory message mov AH,OutputString ;DOS print string function int DOS ;Call DOS to do it jmp syntax ;Display syntax screen DirectoryFound: mov SI,offset DefaultBundle ;Point to bundle name mov CX,3 ;Count for name length rep movsw ;Stuff name in buffer add cmd1_cnt,6 ;Fix the counter jmp short Isolate ;No need to check it now ; Here, we will check to make sure there is a valid extension. ; If none was given, a default extention of '.*' will be added. NotAMailRun: std ;Set up to move backwards mov SI,offset cmd1 ;Get address of filename mov DI,SI ;So we can check for end mov AX,cmd1_cnt ;Get length in AX add SI,AX ;Point to end of filename push SI ;Save end address scan: lodsb ;Get a character cmp AL,'.' ;Is it a period? je ExtentionIsOk ;If yes, extention OK cmp AL,'\' ;Is it filename separater? je UseDefault ;Stop if yes cmp DI,SI ;Scanned whole name? jne scan ;No, go get more UseDefault: pop DI ;DI = end address of filename mov byte ptr [DI],'*' ;Add full wildcard search mov byte ptr [DI+1],'.' ;Add a dot to filename mov byte ptr [DI+2],'*' ;Add wildcard extension mov byte ptr [DI+3],0 ;End it with a zip add word ptr cmd1_cnt,3 ;Adjust length count push DI ;Maintain stack balance ; Next, we isolate the path from the filename so that successive ; filenames can be tacked onto it in case wildcards are used... public ExtentionIsOk ExtentionIsOk: add SP,2 ;Remove garbage from stack Isolate: call show_opt ;Display option info std ;Set up to move backwards mov SI,offset cmd1 ;Get address of filename ;so we can check for a path.jjn mov CX,cmd1_cnt ;Get length in CX .jjn add SI,CX ;SI = end of filename .jjn dec SI ; .jjn public path1 path1: lodsb ;Get a character cmp AL,'\' ;Filename separator? je save_path ;Stop if yes cmp AL,':' ;Drive separator? je save_path ;Stop if yes loop path1 ;Decrement and loop .jjn inc SI mov endpath,SI ;Save address mov pathlen,CX ;Save path length (0) .jjn jmp short _end_p ;Skip double save .jjn public save_path save_path: inc SI ;Adjust past \ character inc SI ;Need 2 for auto dec... mov endpath,SI ;Save address of end of path mov pathlen,CX ;Save path length .jjn _end_p: ; .jjn cld ;Set direction forward ; ; Now we call the wildcard expander. This creates a list of filenames that ; match the filespec so we can retrieve them later. If there are more than ; 'NamesFound' matches, it will save them on disk. ; mov on_disk,0 ;List of files is not on disk mov Name_count,0 ;No names found yet mov num_names,0 DoAllMail: call FindNames ; Find all matching files .jjn cmp F_Flag,true ;Are we doing a mail run? jne NotDoingMail ;Go if not mov SI,BundlePosition ;Get address for bundle name cmp SI,offset SPAZ ;No more names to do? je NotDoingMail ;If not, we're done... lodsw ;Get next bundle name mov DI,EndPath ;End of path to filename add DI,2 ;Adjust to right spot stosw ;And stuff in new name mov BundlePosition,SI ;Save new name offset jmp short DoAllMail ;And get more filenames NotDoingMail: cmp on_disk,0 ;Is stuff on disk? jz NothingOnDisk ;Nope skip pointer adjust mov AH,MoveFilePointer ;Move pointer DOS function xor CX,CX ;Offset from beginning of file mov DX,CX ;32 bit mov AL,CL ;Mark for 'beginning' mov BX,files_handle ;Get the file handle int DOS ;Call DOS to do it NothingOnDisk: mov AX,name_count ; number of names found or AX,AX ; return with zero flag set jnz Main ; skip error stuff .jjn ; If we got here, there were no names found. ; (Moved from the old wild_card procedure. .jjn) cmp F_Flag,true ;Was this a mail run? jne NormalNotFound ;If not, do normal exit mov DX,offset NoMail ;Mail run error message mov AH,OutputString ;DOS print string function int DOS ;Call DOS to do it jmp short DoneTotally ;Denis Miller time NormalNotFound: mov AX,2 ;Change error to file not found call err_msg ;Display error in english push AX ;Save error code mov SI,offset cmd1 ;Point to filename call upper ;Convert to upper case call ShowIt ;Show it (not found) mov SI,offset crlf ;CR,LF call ShowIt ;On screen pop AX ;Restore error code DoneTotally: mov AH,ExitWithCode ;Terminate with code int DOS ;Exit program ; This is the main loop of the program. It is run once for every ; matching filename found from the command line. Needed variables ; are reset each time through. Main: mov zooflag,false ;Reset variables mov byte ptr cmd_cnt,9 mov crushed,false mov word ptr buf_pos,0 mov flag,false mov count,false mov order,false mov num_hdr,false mov IsZip,false mov IsDWC,false mov IsLZH,false mov Last_Chance,false mov DI,offset ExtractOptions ;Point to last set of options mov CX,9 ;Max options set at 5 bytes mov AL,blank ;Blank them out (spaces) rep stosb mov SI,offset crlf ;Cr,Lf between runs call ShowIt call wild_card ;Grab a filename to work on ; If we return from wild_card, at least 1 matching filename was found. ; Otherwise the program reports its status and quits. If a wild card ; was used, it has now been extended to a fully qualified filename. Now ; it has to be checked for archive type etc. etc. mov SI,offset msg4 ;SI = 'Searching:' call ShowIt ;Put it on screen mov SI,offset cmd1 ;SI = filename call upper ;Convert it to upper case call ShowIt ;Put it on screen cmp M_Flag,true ;Displaying net/node? jne NoAddress ;Skip next part if not call DisplayNode ;Figure out the info mov SI,offset info4 ;From message call ShowIt ;Display it mov SI,offset BuildNet ;Our ASCII info call ShowIt ;Display it NoAddress: mov SI,offset crlf ;SI = cr/lf call ShowIt ;On screen mov SI,offset cmd1 ;SI = full filename mov DI,offset pakfile ;DI = new command line do_count: lodsb ;Get a character from line cmp AL,0 ;End of filename? je done ;yes, we are finished cmp AL,cr je done1 inc byte ptr cmd_cnt ;Else, bump character counter stosb ;Save char in command line jmp short do_count ;and loop back... done: mov AL,cr ;Cmd line must end with cr done1: stosb ;Stuff final character mov byte ptr [DI],0 ;make it ASCIIZ *** ; This little section adds any unique file names that are to be ; extracted from the archive. If this option is used in conjunction ; with /d, the archive will be deleted after extraction. BE CAREFUL cmp Parsed,true ;Were filenames specified? jne No_Parsed ;Skip this if not dec DI ;Back up destination pointer mov SI,offset Extract_Names ;SI = extract name buffer mov CX,word ptr Names_Count ;Get length of names add byte ptr cmd_cnt,CL rep movsb ;Set up the line mov byte ptr [DI],cr ;End it all with a cr mov byte ptr [DI+1],0 ;Make it ASCIIZ ; Here is where we check the archive type. If it is a zoo file, it is ; extracted as is. If it is an ARC/PAK/PK file, it is first checked to ; ensure that it is in proper order by date time... No_Parsed: call ArchiveCheck ;Check the archive type jnc Zoo_Check_OK ;If all is well, continue jmp main ;Else, try to do the next one Zoo_Check_OK: mov DX,offset UnArc4 ;Point to LOOZ.EXE cmp zooflag,true ;Is this a zoo file? jne no_zoo call find ;Does LOOZ exist? jc no_looz ;Nope, check for zoo ; If execution falls here, LOOZ was found on the path. We have to change ; the extract option to 'x' as looz does not understand 'e' cmp O_Flag,true ;Do we want forced overwrite? jne DontForceLooz ;Go if not jmp short no_looz ;If we do, call zoo instead DontForceLooz: mov byte ptr ExtractOptions + 1,'x' ;Change extract option jmp X_OK ;Go execute looz ; If we get here, a zoo archive was detected, and LOOZ was not found. ; Check for ZOO.EXE and quit if not found... no_looz: mov DX,offset UnArc7 ;DX = zoo.exe cmp O_Flag,true ;Do we want forced overwrite? jne DoNotForceZoo ;Exit if not, else mov byte ptr ExtractOptions +2,'S' ;This will force overwrite mov byte ptr ExtractOptions +3,'O' ;This is needed too DoNotForceZoo: mov byte ptr ExtractOptions +1,'x' ;Change extract option jmp zoo ;Go hunt for it no_zoo: cmp IsDWC,true ;Is this a DWC file? jne TryZIP ;Nope, check for ZIP mov DX,offset UnArc8 ;Point to 'DWC.EXE' cmp O_Flag,true ;Overwrite mode? jne DoNotForceDwc ;If not, exit mov byte ptr ExtractOptions + 1,'x' ;This will allow DWC mov byte ptr ExtractOptions + 2,'w' ;to overwrite existing files jmp Zoo ;Try to run it DoNotForceDwc: mov byte ptr ExtractOptions + 1,'e' ;Normal extract mode jmp Zoo ;Try to run it TryZIP: cmp IsZIP,true ;Is this a ZIP file? jne TryLZH ;If not, check for LHArc mov DX,offset UnArc9 ;Point to 'PKUNZIP.EXE' cmp O_Flag,true ;Overwrite mode? jne DoNotForceZIP ;Exit if not mov byte ptr ExtractOptions + 1,'-' ;This will allow Zip mov byte ptr ExtractOptions + 2,'o' ;to overwrite existing files jmp Zoo ;Try to run it DoNotForceZIP: jmp Zoo ;Try to run it TryLZH: cmp IsLZH,true ;Is this an LHZ file? jne TryNormal ;Must be an ARC mov DX,offset UnArc10 ;Point to 'LHARC.EXE' mov byte ptr ExtractOptions,'e' ;Must have extract option cmp O_Flag,true ;Overwrite mode? jne DoNotForceLZH ;Exit if not mov byte ptr ExtractOptions + 2,'/' ;This will allow LHArc mov byte ptr ExtractOptions + 3,'m' ;to overwrite existing files mov byte ptr ExtractOptions + 4,'c' ;Not very exotic.... jmp Zoo ;Try to run it DoNotForceLZH: jmp Zoo ;Try to run it TryNormal: call Sort_It jnc part2 ;Sort was good, go unarc mov SI,offset sorterr ;Point to error message call ShowIt ;Put it on screen Part2: mov byte ptr ExtractOptions + 1,'e' ;Normal extract option cmp Crushed,true ;Crushed files? jne part3 ;Nope, check for ARCE Part2a: mov DX,offset UnArc5 ;Point to PAK.EXE cmp O_Flag,true ;Overwrite mode? jne DoNotForcePak ;Exit if not mov byte ptr ExtractOptions + 2,' ' ;A space for the new PAK mov byte ptr ExtractOptions + 3,'/' ;A hyphen for the new PAK mov byte ptr ExtractOptions + 4,'w' ;This tells pak to force mov byte ptr ExtractOptions + 5,'a' ; overwrites always DoNotForcePak: cmp byte ptr D_flag,true ;Was delete flag set? jne NoDelete ;Nope, continue... mov byte ptr ExtractOptions + 1,'x' ;Delete archive when done NoDelete: jmp zoo ;Do PAK and PAK only. part3: cmp byte ptr A_Flag,true ;Default to ARCE? jne Xarc ;Go if not NoneFound: cmp Crushed,true ;Crushed files? jne OkForArce ;Nope, keep going jmp Give_Up ;If yes, just quit OkForArce: cmp O_Flag,true ;Force overwrite mode? jne DontForceArce ;Go if not mov SI,offset pakfile ;Point to command line goagain: lodsb or AL,AL jnz goagain mov DI,SI ;Get address in DI mov byte ptr [DI-2],Blank ;Put in a space mov byte ptr [DI-1],'/' ;and an Option delimiter mov byte ptr [DI],'R' ;and Force overwrites... mov byte ptr [DI+1],cr mov byte ptr [DI+2],0 add byte ptr cmd_cnt,3 ;Fix the count up DontForceArce: mov DX,offset UnArc6 ;Else point to it mov byte ptr ExtractOptions + 1,' ' ;This removes any options mov byte ptr ExtractOptions + 2,' ' ; that may have been put mov byte ptr ExtractOptions + 3,' ' ; in by other un-archers jmp short zoo ;Go try to run it Xarc: mov DX,offset UnArc1 ;Point to PKXARC.EXE mov byte ptr ExtractOptions + 1,' ' ;Remove 'e' option cmp O_Flag,true ;Overwrite mode? jne DoNotForceXarc ;Exit if not mov byte ptr ExtractOptions + 1,'-' ;This forces PKWare to use mov byte ptr ExtractOptions + 2,'r' ; it's overwrite mode DoNotForceXarc: call find ;See if it exists jnc X_OK ;Got it! mov DX,offset UnArc2 ;Point to PKXARC.COM call find ;See if it exists jnc X_OK ;Got it! mov DX,offset UnArc3 ;Point to PKUNPAK.EXE call find ;See if it exists jnc X_OK ;Got it, keep going mov DX,offset UnArc5 ;Point to PAK.EXE mov byte ptr ExtractOptions + 1,'e' ;Set up extract for pak cmp O_Flag,true ;Overwrite mode? jne DontForcePak ;Exit if not mov byte ptr ExtractOptions + 2,' ' ;A space for the new PAK mov byte ptr ExtractOptions + 3,'/' ;A hyphen for the new PAK mov byte ptr ExtractOptions + 4,'w' ;This tells pak to force mov byte ptr ExtractOptions + 5,'a' ;overwrite always DontForcePak: cmp byte ptr D_flag,true ;Was delete flag set? jne part3a ;Nope, continue... mov byte ptr ExtractOptions + 1,'x' ;Delete archive when done part3a: call find ;See if it exists jnc X_OK ;Got it, continue jmp NoneFound ;Try Arce.... Zoo: call find ;See if it exists jnc X_OK ;Got it! ; If this code is executed, then no Un-Arc program was found on the ; path. It reports the error and aborts... Give_Up: mov AX,22 ;Unarcher not found call err_msg ;Report error in english mov AH,ExitWithCode ;Exit with code int DOS ;Back to DOS (for good) X_OK: mov BX,offset par_blk ;BX points to spawn info mov AL,0 ;AL = load and execute push DS push ES cli ;Disable interupts mov stk_seg,SS ;Save the Stack mov stk_ptr,SP ;Both parts... sti ;Enable inerupts mov AH,ExecuteProgram ;AH = MSDOS exec function int DOS ;Transfer to DOS cli ;disable interupts mov SS,stk_seg ;Restore stack segment mov SP,stk_ptr ;Restore stack pointer sti ;Enable interupts pop ES pop DS mov AH,GetReturnCode ;Get return code from Un-Arcer int DOS ;Transfer to DOS mov elevel,AL ;Save errorlevel for later cmp byte ptr crushed,true ;Did we use PAK? jne normal ;Nope, check for delete flag cmp byte ptr D_Flag,true ;Did we mark for delete? jne main_loop ;Exit if no mov SI,offset del_msg ;SI = 'Unlinking...' call ShowIt mov SI,offset cmd1 ;SI = filename call ShowIt mov SI,offset crlf call ShowIt jmp short main_loop ;Go do next file normal: or AL,AL ;Make sure all is well jnz main_loop ;Before allowing a delete cmp byte ptr D_Flag,true ;Should we delete arc file? jne main_loop ;Skip if not mov SI,offset del_msg ;SI = 'Unlinking...' call ShowIt mov SI,offset cmd1 ;SI = filename call ShowIt mov SI,offset crlf call ShowIt mov AH,DeleteFile ;AH = delete file mov DX,offset cmd1 ;DX = archive name int DOS ;Call DOS to do it jnc main_loop ;Go if no errors call err_msg ;Show errors but continue... main_loop: jmp main ;Go get next file ; Print ASCIIZ string pointed to by SI ShowIt: mov AH,CharacterOutput ;Function = console out mov byte ptr Characters,0 ;Set count to zip show_loop: lodsb ;Get a character or AL,AL ;Is it a 0? jz ShowIt_exit ;If yes, exit inc byte ptr Characters ;Bump char counter mov DL,AL ;ASCII char in DL int DOS ;Call DOS to print it jmp short show_loop ;Go get more ShowIt_exit: ret ;Return to caller Spaz endp argc proc near ;count command line arguments push BX ;save original BX and CX push CX ; for later mov AX,1 ;force count >= 1 argc1: mov CX,-1 ;set flag = outside argument argc2: inc BX ;point to next character cmp byte ptr [BX],cr je argc3 ;exit if carriage return cmp byte ptr [BX],blank je argc1 ;out of argument if blank cmp byte ptr [BX],tab je argc1 ;outside argument if ASCII tab ;otherwise not blank or tab, jcxz argc2 ;jump if already in argument inc AX ;else found argument, count it not CX ;set flag = inside argument jmp argc2 ;and look at next character argc3: pop CX ;restore original BX and CX pop BX ret ;return AX = argument count argc endp argv proc near ;get address & length of ;command tail argument xor AH,AH ;initialize argument countef argv1: mov CX,-1 ;set flag = outside argument argv2: inc BX ;point to next character cmp byte ptr [BX],cr je argv7 ;exit if carriage return cmp byte ptr [BX],blank je argv1 ;outside argument if ASCII blank cmp byte ptr [BX],tab je argv1 ;outside argument if ASCII tab ;if not blank or tab... jcxz argv2 ;jump if already inside argument inc AH ;else count arguments found cmp AH,AL ;is this the one we're looking for? je argv4 ;yes, go find its length not CX ;no, set flag = inside argument jmp argv2 ;and look at next character argv4: ;found desired argument, now ;determine its length... mov AX,BX ;save param, starting address argv5: inc BX ;point to next character cmp byte ptr [BX],cr je argv6 ;found end if carriage return cmp byte ptr [BX],blank je argv6 ;found end if ASCII blank cmp byte ptr [BX],tab jne argv5 ;found end if ASCII tab argv6: xchg BX,AX ;set ES:BX = argument address sub AX,BX ;and AX = argument length jmp short argvx ;return to caller argv7: xor AX,AX ;set AX = 0, argument not found argvx: ret ;return to caller argv endp getenv proc near ; return address and length ; of environment variable push CX ; save registers push SI mov CX,8000h ; assume max env. = 32 KB xor DI,DI ; initial env. offset xor AX,AX ; default length result get1: cmp byte ptr ES:[DI],0 ; check for end of environment je get4 ; end reached, return AX = 0 pop SI ; initialize address of target push SI ; variable to be found repe cmpsb ;Compare target and env. strings cmp byte ptr [SI-1],0 jne get2 ;Jump if incomplete match cmp byte ptr ES:[DI-1],'=' je get3 ;Jump if match was complete get2: repne scasb ;No match, scan for end string jmp get1 ;Try again to match get3: push DI ;Save address after = sign repne scasb ;Look for end of this string pop AX ;Get back starting address xchg DI,AX ;Find string length sub AX,DI dec AX ;Don't include null byte get4: pop SI ;Common exit point pop CX mov CS:env_len,AX ;Save PATH length or AX,AX ;Null PATH? jz get5 ;Exit if yes push ES ;Get path segment into pop DS ; DX for string move push CS ;Now ES points to data pop ES ; in our code segment mov CX,AX ;Get length of path in CX mov SI,DI ;Path is now source mov DI,offset saved ;Destination is our area rep movsb ;Move path into this segment get5: push CS ;Now we have to restore pop DS ; the original DS push CS pop ES ret ;Return to caller getenv endp ; This routine searches the current directory, and (if needed), the ; entire PATH, looking for an unarchiver to use. It is called with ; DX pointing to an ASCIIZ filename to look for and returns with ; carry clear if it is found. Carry Set if not found. find proc near push DX ;Save pointer to filename mov AH,SearchForFirst ;Search for first pop DX ;Get filename address push DX ;Save it again xor CX,CX ;Normal attribute int DOS ;Give it to DOS jc find1 ;Not found, search path pop DX ;Point DX to filename ret ;exit Find... find1: mov AX,env_len ;Get PATH length or AX,AX ;Did we find a path? jnz find2 ;Keep going if yes no_exist: pop DX ;Point DX to filename stc ;Carry set to show error ret ;Exit Find find2: mov DI,offset saved ;Point to the path string mov dir,DI ;dir = start of path string add DI,AX ;AX = end of path string mov enddir,DI ;save it mov byte ptr [DI],0 ;Null terminator for path find3: mov DI,offset new ;Area for path\filename mov SI,dir ;Get current address in path cmp [enddir],SI ;End of path variable? jbe no_exist ;Not found, exit find4: lodsb ;Get a character cmp AL,';' ;Seperator? je find5 ;Yes, go tack on filename cmp AL,0 ;Are we finished? je find5 ;Yes, go stosb ;Stuff character jmp short find4 ;and go for another find5: mov dir,SI ;Save current path address cmp byte ptr [DI-1],'\' ;Path separator? je find6 ;Yup, keep goin mov byte ptr [DI],'\' ;Else, put one in inc DI ;Bump the pointer find6: pop SI ;Get filename address push SI ;Save it back again find7: lodsb ;Get character from filename cmp AL,0 ;Got whole filename? je find8 ;Go if yes stosb ;Else put character in buffer jmp find7 ;Go get the rest find8: stosb ;Save the null (ASCIIZ) mov AH,SearchForFirst ;Search for first mov DX,offset new ;Point to path\filename xor CX,CX ;Normal attribute int DOS ;Give it to DOS jc find3 ;Not found try next path pop DX ;Clear junk off stack mov DX,offset new ;DX = full path\filename clc ;Show no errors ret ;Exit (so we can exec it) find endp ; This routine determines what type of archive is being worked on. ; It will set a flag to tell SPAZ which un-archiver to try and use. ArchiveCheck proc near mov AH,OpenFile ;AH = open file request mov AL,0 ;read access only mov DX,offset cmd1 ;Point to archive name int DOS ;Call DOS to open it jc probs xchg AX,BX ;Handle in BX mov AH,ReadFile ;AH = read file mov CX,4 ;Read first 4 bytes mov DX,offset Usage ;Read byte into usage area int DOS ;Call DOS to do it jc probs mov AH,MoveFilePointer ;Get ready to adjust mov AL,2 ;From end of file mov CX,0ffffh ;2 spaces mov DX,0fffeh int DOS ;Call DOS to do it jc probs mov AH,ReadFile ;Read last 2 bytes mov CX,2 mov DX,offset Usage + 4 ;Buffer for save int DOS ;Call DOS to do it jc probs mov AH,CloseFile ;AH = close file int DOS ;Call DOS to do it jc probs mov AX,word ptr Usage + 4 ;Get DWC bytes cmp AX,4357h ;Is it a DWC file? jne IsItZoo ;Go, if not mov IsDWC,true ;Else set flag jmp short EndCheck ;And exit IsItZoo: mov AX,word ptr Usage ;Get value cmp AX,4f5ah ;Is it a zoo file? jne IsItZip ;Go if not, else mov zooflag,true ;Mark for zoo jmp short EndCheck IsItZip: cmp AX,4b50h ;Is it a ZIP file? jne IsItArc ;Go, if not mov IsZip,true ;Set flag jmp short EndCheck ;We're outa here IsItArc: cmp AL,1Ah ;Is it a normal Arc/Pak? jne IsItLZH ;Skip this file if not jmp short EndCheck ;We're outa here IsItLZH: mov AX,word ptr Usage + 2 ;Get LH's ID bytes cmp AX,6C2Dh ;Is this an LH Arc? jne NotAnArchive ;Report error if not mov IsLZH,true ;Mark for LHArc EndCheck: clc ;Show no errors ret probs: push AX ;Save error code call err_msg ;Report error in english mov SI,offset zerr ;SI = Zoo check error message call ShowIt ;Display it pop AX ;Restore error code NotAnArchive: stc ;Show error ret ;Return to caller ArchiveCheck endp ; This routine is responsible for sorting ARCType bundles into proper ; FidoNet Mail format. i.e. Sorted by date/time. It is accomplished ; by sorting all the headers and re-writting the entire archive... Sort_It proc near cld ;Move forward again... xor AL,AL mov num_hdr,AL ;Init header counter mov flag,false mov DX,offset cmd1 ;DX = Archive filename mov AH,OpenFile ;AX = Open file xor AL,AL ;Normal Attribute int DOS ;Give it to DOS jnc open_ok ;Continue if it worked jmp short inv_hdr ;Go report errors ; This routine will read in the archive file headers so that they ; can be sorted. open_ok: mov in_handle,AX ;Save file handle mov buf_pos,0 ;Init buffer position call read_hdr ;Read in first header jnc got_1st ;If clear, we're OK ; Truncated file. Somethings weird in Denmark! mov AX,19 ;Truncated file inv_hdr: call err_msg ;Put it on screen stc ret ;Exit Sort_It with error ; If we get this far, the first header has been read in. Stuff it in ; the buffer and go for the rest... got_1st: mov SI,cmdtail ;Point to arc data cmp byte ptr [SI+1],0 ;End of Archive? jne Chk_Crushed ;Exit for sort jmp got_em Chk_Crushed: cmp byte ptr [SI+1],10 ;Crushed file? jb Not_Crushed ;Nope, continue mov Crushed,true ;Else, show crushed Not_Crushed: cmp byte ptr [SI],1ah ;Do we have a PAK file? je pak_ok ;If yes, keep going mov AX,20 ;Invalid header call err_msg ;Report error in english add sp,2 ;Remove return address mov AH,CloseFile ;Close the file mov BX,in_handle int DOS ;Call DOS to close file mov byte ptr elevel,1 ;Report error for no delete jmp main ;Bad file, try the next one pak_ok: mov DI,offset hdr_buf ;Get buffer address add DI,[buf_pos] ;Adjust to current pos mov AX,low_pos ;Get file pointer low word mov [DI],AX ;Stuff it in buffer mov AX,high_pos ;Get file pointer high word mov [DI+2],AX ;Stuff it in buffer add DI,4 ;Adjust the pointer mov CX,29 ;Length of archive header rep movsb ;Put info in buffer add buf_pos,arc_len ;Bump the buffer pointer inc num_hdr cmp num_hdr,Entries ;Have we got too many? jb room ;Nope, continue... mov AX,21 ;Too many archive entries jmp nope ;Report and exit room: call read_next ;Get next header jnc got_1st ;Go stuff it in buffer jmp short got_em ;Got all headers, exit read_next: mov DI,cmdtail ;DI = start of header mov DX,word ptr [DI+15] ;DX = low byte of arc size mov CX,word ptr [DI+17] ;CX = high byte of arc size mov BX,in_handle ;BX = opened file handle mov AH,MoveFilePointer ;AH = move file pointer mov AL,1 ;AL = from current position int DOS ;Give it to DOS read_hdr: mov BX,in_handle ;Get opened file handle xor CX,CX ;Set offset for search xor DX,DX ; to zero bytes mov AH,MoveFilePointer ;AH = move file pointrr mov AL,1 ;AL = from currcnt position int DOS ;Call DOS to do it mov high_pos,DX ;Save the high word mov low_pos,AX ;Save the low word mov BX,in_handle ;Get opened file handle mov CX,29 ;Read in 29 bytes mov DX,cmdtail ;Buffer for read... mov AH,ReadFile ;Read from file int DOS ;Give it to DOS ret got_em: mov Order,true ;Archive already in order cmp byte ptr N_Flag,false ;Skip sort? jne sort ;If yes, exit mov BX,in_handle ;Get the file handle mov AH,CloseFile ;So we can close it int DOS ;Call DOS to do it jmp Back_to_main ;Exit sort sort: mov flag,false ;Show no changes made mov count,1 ;To prevent sort past end mov AH,num_hdr ;Get number of entrys cmp AH,1 ;Is there only 1 entry? jbe sort_exit ;No sort if 0 or 1 entry mov SI,offset hdr_buf ;SI = start of header buffer mov DI,offset hdr_buf+arc_len ;DI = 2nd entry in buffer sort1: mov BX,23 ;BX = offset to header date mov AX,[SI+BX] ;Get date from 1st entry mov DX,[DI+BX] ;Got date from 2nd entry cmp AX,DX ;Which is higher? ja change ;Swap if 1st > 2nd jne sort2 ;If not = get next entry mov BX,25 ; else get offset to time mov AX,[SI+BX] ;Get time from 1st entry mov DX,[DI+BX] ;Get time from 2nd entry cmp AX,DX ;Which is higher? ja change ;Swap if 1st > 2nd ; If Date and Time are identical, no changes are made sort2: add SI,arc_len ;Point to next entry add DI,arc_len ;Point to next entry inc count ;Bump # of entries completed mov AH,count ;Get the number cmp AH,num_hdr ;Done all entries? je pass ;End of this pass if yes jmp short sort1 ;Else do next entry ; This section will swap the entry pointed to by SI with the entry ; pointed to by DI... change: push SI ;Save pointer to 1st entry push DI ;Save pointer to 2nd entry mov CX,arc_len ;# of bytes in an entry chg1: mov AL,[DI] ;Get byte from destination movsb ;Move Source to Destination mov [SI-1],AL ;Move Destination to Source loop chg1 ;Loop back for more pop DI ;Restore 2nd entry address pop SI ;Restore 1st entry address mov flag,true ;A swap has been made (pass) mov Order,false ;Show swap made (constant) jmp sort2 ;Do next entry ; Here we check if a change was made. If no changes were made ; then the archive was already in order... pass: mov AH,flag ;Get the sort flag cmp AH,true ;Was a change made? je sort ;Go again if change was made sort_exit: mov AL,Order ;Was archive in order? cmp AL,true ;If yes, do not write jne write mov BX,in_handle ;Get the file handle mov AH,CloseFile ;So we can close it int DOS ;Call DOS to do it jmp Back_to_main ;The file out again. write: mov DI,offset tempspec ;point to temp filespec .jjn mov SI,offset cmd1 ;get location of command .jjn mov CX,pathlen ;get path length .jjn rep movsb ;make a copy .jjn mov SI,offset temp ;Point to temp filename .jjn mov CX,thomlen ;get length of filename .jjn rep movsb ;copy it after the path .jjn mov DX,offset tempspec ;Point to temp filespec .jjn xor CX,CX ;Use normal attribute mov AH,CreateFile ;AH = create or truncate int DOS ;Call DOS to do it jnc create_ok ;Go if all is well nope: call err_msg ;Report error in english stc ;Carry = Sort failed ret ;Back to main section ; Here, the temp file has been created and the handle for that file is ; in AX. create_ok: mov out_handle,AX ;Save handle for write file ; Now, we have to read in the sorted entry info, and gather more stuff ; from the archive headers mov SI,offset hdr_buf ;Point to the sorted info mov AL,num_hdr ;Get number of entries nxt_hdr: mov flag,false ;Use flag for eof check push AX ;Save # of entries for later push SI ;Save buffer pointer mov DX,[SI] ;Get low word of file position mov CX,[SI+2] ;Get high word of position mov low_pos,DX mov high_pos,CX clc add DX,29 ;Adjust for arc header adc CX,0 ;Include carry if any mov BX,in_handle ;Get read file handle mov AL,0 ;Offset is from beginning mov AH,MoveFilePointer ;AH = move file pointer int DOS ;Call DOS to do it ; The file pointer has been set to the read location. First we ; write the header. Then we read and write the archive data. hdr_in: call info ;Print the copy info pop DX ;Get buffer pointer push DX ;And save it again add DX,4 ;Skip past file location mov CX,29 ;Number of bytes to write mov BX,out_handle ;Get the write file handle mov AH,WriteFile ;AH = write to file int DOS ;Call DOS to write the header jnc hdr_out ;Header written ... go add sp,4 ;Get rid of stack junk jmp short nope ;Exit, we had problems hdr_out: pop SI ;Point to the header push SI ;Save it back mov DX,[SI+21] ;Get high word of entry size mov AX,[SI+19] ;Get low word of entry size ; DX:AX contains the number of bytes that have to be read/written. xor CX,CX ;High word of buffer size mov BX,bsize ;Low word of buffer size ; CX:BX contains the number of bytes we can do at one time. cont: clc ;Get ready for subtract sub AX,BX ;Subtract low word sbb DX,CX ;Subtract high word push AX push DX push BX push CX jae more1 ;There's still more to go clc add BX,AX ;Add back last result mov flag,true ;Show end of data reached ; Here BX contains the remaining number of bytes to read write. ; So we have to put it in CX more1: xchg BX,CX ;Get count in CX mov DX,offset cpy_buf ;Point to our buffer mov BX,in_handle ;Handle for read mov AH,ReadFile ;AH = read file ; Note: CX should contain [bsize] OR the remaining bytes to go... int DOS ;Call DOS to read file jnc data_ok ;Got the data add sp,12 ;Remove stack junk jmp nope ;Exit, we had probs... data_ok: mov BX,out_handle ;Handle for write mov AH,WriteFile ;AH = write to file int DOS ;Call DOS to write out buffer jnc write_ok ;Go if all is well, else add sp,12 ;Remove junk from stack jmp nope ;Exit... write_ok: cmp flag,true ;Was this end of arc data? je do_next ;Get next header if yes pop CX ;Low word buffer size pop BX ;Low word file size pop DX ;High word file size pop AX ;Low word buffer size jmp cont ;Continue with this entry do_next: add SP,8 ;Clear junk off stack pop SI ;Get back buffer position add SI,33 ;Adjust to next entry pop AX ;Get back number of entrys dec AL ;Subtract 1 from it jz no_more ;We're done with data jmp nxt_hdr ;Else go get the next one no_more: ; Before we quit, we have to write out a 1A 00 to show the end of ; the archive. mov AH,WriteFile ;AH = write to file mov BX,out_handle ;Handle for write file mov CX,2 ;Number of bytes to write mov DX,offset end_arc ;Point to the data int DOS ;Call DOS to do it jnc delete ;We're finished ! jmp nope ;Exit sort routine ; Now that the meat of the work is done, we have to delete the old ; arc file and rename the new one. delete: mov BX,in_handle mov AH,CloseFile int DOS mov BX,out_handle mov AH,CloseFile int DOS mov DX,offset cmd1 ;Point to original name mov AH,DeleteFile ;AH = delete file int DOS ;Call DOS to do it jnc del_ok jmp nope del_ok: mov AH,RenameFile ;AH = rename file mov DI,offset cmd1 ;Original filename mov DX,offset tempspec ;Temporary filename .jjn int DOS ;Call DOS to do it jnc Back_to_main ;Go if no problems jmp nope ;Exit program... Back_to_main: clc ;Sort done. No errors ret ;Return to main section ; Convert double word to ascii decimal. Uses divide instruction ; Parameters passed in registers as follows: ; DX:AX = binary word to be converted DecimalOut: push DI push AX mov DI,offset decbuf ; address of output buffer mov CX,7 ; buffer length-1 mov AL,' ' ; pad character rep stosb ; clear buffer & point to end mov byte ptr [DI], 0 ; init end of string dec DI pop AX ;Get low word back xchg BP,DX ;Save high word mov BX,10 ;Use base 10 for decimal mov CL,30h ;For conversion to ASCII HighWordLoop: or BP,BP ;Are we done with high words? jz LowWordLoop ;Yes xchg AX,BP ;No, get high word xor DX,DX ;Clear DX div BX xchg BP,AX ;Save new high word div BX ;Divide low word + remainder or DL,CL ;Convert hex value to ASCII mov [DI],DL ;Save decimal character dec DI ;Back up in the buffer jmp HighWordLoop ;Repeat until done LowWordLoop: xor DX,DX ;Clear DX div BX or DL,CL ;Convert hex value to ASCII mov [DI],DL ;Save decimal character dec DI ;Back up in the buffer or AX,AX ;Are we done? jnz LowWordLoop ;No pop DI ret Sort_It endp ;Convert an ASCIIZ string to upper case. ; Call with SI pointing to string to be converted upper proc near push SI ; save string address up1: lodsb ; next character or AL,AL ; found end (null byte) ? jz up2 ; yes, jump cmp AL,'a' ; test if in range 'a'-'z' jb up1 ; skip it if not >= a cmp AL,'z' ja up1 ; skip it if not <= z sub byte ptr [SI-1],'a'-'A' ; change char to upper case jmp up1 ; get another char up2: pop SI ; restore original string ret ; address and return upper endp ; This routine is called by the sort. It prints a line of information ; for every entry in the archive detailing its size, filename, and ; new locatio in the archive.... info proc near mov SI,offset msg1 ;SI = 'Adjusting' call ShowIt ;Put it on screen mov BP,SP ;Get stack pointer mov SI,[BP+2] ;SI = address of arc entry add SI,6 ;Now SI points to filename push SI ;Save address for later call ShowIt ;Put it on screen mov CX,14 ;Tab length for info screen sub CL,Characters ;Subtract # of chars printed mov DL,blank ;AL = space mov AH,CharacterOutput ;Function = console out info_loop: int DOS ;Call DOS to print space loop info_loop ;Loop till tab is complete mov SI,offset msg2 ;SI = 'Location =' call ShowIt ;Put it on screen mov DX,high_pos ;High word file position mov AX,low_pos ;Low word file position call DecimalOut ;Convert to ASCII and print mov SI,offset decbuf ;Yes, String address to SI call ShowIt ; Output it mov SI,offset msg3 ;SI = 'Length =' call ShowIt ;Put it on screen pop SI ;Restore Arc filename address mov AX,[SI+13] ;Low word file size mov DX,[SI+15] ;High word file size clc ;Get ready for addition add AX,29 ;Add in length of header adc DX,0 ;Add in any carry call DecimalOut ;Convert to ASCII and print mov SI,offset decbuf ;Yes, String address to SI call ShowIt ; Output it mov SI,offset crlf ;SI = cr/lf call ShowIt ;Put it on screen ret ;Return to caller info endp ; This routine prints one of DOS's error messages and returns to ; which ever section of the code called it... err_msg proc near push AX ;Save errorlevel dec AX ;Adjust for beginning of table add AX,AX ; * 2 for DW variables mov SI,AX ;Get offset in SI mov SI,errmsg[SI] ;Now SI = address of string call ShowIt ;Put it on screen pop AX ;Restore errorlevel ret err_msg endp ;************************************************************************ ; FindNames: find all file names matching the file specification in cmd1. ; REGISTERS ON EXIT: ; AX = number of files found (may be 0). ; ZF = reset if files found, set if no files found. ; This procedure written by Jeffrey J Nonken. (Modified by Dan) ;************************************************************************ public FindNames FindNames proc near mov DI,offset save_buf ;Get dest addresm of filename mov AL,num_names ;Get # of names already there mov CL,13 ;Length of 1 entry mul CL ;Names * 13 add DI,AX ;Now DI points into buffer mov AH,SearchForFirst ;AH = Search for first xor CX,CX ;Attribute = 'normal' mov DX,offset cmd1 ;Point to ASCIIZ filename int DOS ;Give it to DOS jnc get1fname ; Found a file, process it jmp no_files ;Finished with search ; Loop to here if buffer was written to disk. clean_buf: mov num_names,0 ; no more names in the buffer mov DI,offset save_buf ;Get dest address of filename ; Loop to here after each file name, look for the next one. next: mov AH,SearchForNext ;AH = Search for next int DOS ;Give it to DOS jnc get1fname ; Found a file, process it jmp short NoMoreFiles ; If not, quit now. get1fname: ;Now we move the filename.ext up to our own ASCIIZ string ;so that open can use the correct path to the file. mov SI,offset dta_buf+30 ;SI = filename found mov CX,6 ; Name is <= 13 bytes ; (including trailing null) rep movsw ; Move 12 bytes (6 words) movsb ; Move the last byte inc name_count ; Count up (total count) inc num_names ; Count up (buffer count) cmp num_names,NamesFound ; See if we have names yet jb next ; Just repeat if not ; If we got here, there were at least 'NamesFound' names. ; Start writing them to disk. cmp on_disk,0 ; See if there's a file open jnz already_open ; If so, skip the open step mov DX,offset filename_file ; Get the file's name mov AH,CreateFile ; Open the file xor CX,CX ;No attributes int DOS ; Do it mov files_handle,AX ; Save the file handle(error) jnc already_open ; If no errors, write to file call err_msg ;Report error in english mov DX,offset TempErr ;Unable to create file mov AH,OutputString ;DOS print string function int DOS ;Display error jmp short NoMoreFiles ;Continue on ; If the temporary file can't be created, we exit here. This will allow ; SPAZ to process at least 'NamesFound' archives before quitting. If this ; is a disk full condition, it will be reported by the un-archiver. already_open: mov DX,offset save_buf ; point to buffer mov BX,files_handle ; get the file handle mov CX,13 * NamesFound ; number of file names to write mov AH,WriteFile ; write to the file int DOS mov on_disk,1 ; say it's on disk jmp clean_buf ; loop around and clear buffer ; No more files found. Clean up and exit. NoMoreFiles: ; Last file was found cmp on_disk,0 ; see if there is a files file jz no_files ; if not, just return cmp num_names,0 ; see if any left in buffer jz no_files mov AL,num_names ; Yes, get the number of names mov BL,13 ; length of a name mul BL ; how many bytes to write mov DX,offset save_buf ; point to buffer mov BX,files_handle ; get the file handle mov CX,AX ; number of bytes to write mov AH,WriteFile ; write to the file int DOS ; Hmmmmm. If disk is full, un-archiver will report error. If it's just ; a bad read/write, DOS's abort, retry, ignore will display. Don't ; think we have to check? ; All files (if any) have been found and buffered or written to disk. Save ; the address of the buffer in case we have files in the buffer. Restore the ; DTA. no_files: mov fname_ptr,offset save_buf ;Address of scratch space mov names_used,0 ; No names used yet ret FindNames endp ;**************************************************************************** ; wild_card: Each time called this returns the next name in the list, if any. ; It 'returns' it by copying it into the end of the command line buffer ; after the path so it can be used immediatly. If it has no more names, ; it exits the program. ; This procedure written by Jeffrey J. Nonken (and mangled by Dan) ;**************************************************************************** public wild_card wild_card proc near mov AX,names_used ; Get number of names returned cmp AX,name_count ; Compare to total # of names jb more_names ; If less, we still have some ; We have no names left to return. See if they were on disk. If so, close up. cmp on_disk,0 ; see if on disk jz w_skip_close ; if not, skip over the close mov AH,CloseFile ; close file command mov BX,files_handle ; get the file handle int DOS mov AH,DeleteFile ; Delete file command mov DX,offset filename_file ; Name of file to delete int DOS ; Delete our scratch file w_skip_close: mov AL,elevel ;Get last reported errorlevel mov AH,ExitWithCode ;Terminate with return code int DOS ;Exit program ; We still have names left. Let's see if they're on disk. more_names: cmp on_disk,0 ; Are they stored on disk? jz not_on_disk ; If not, get from the buffer. ; If we got here, the files are stored on disk. Read one name, 13 bytes, right ; into the file spec. The name was originally null terminated, so extra junk ; on the end won't matter. mov AH,ReadFile ; Read file command mov BX,files_handle ; get the file handle mov DX,endpath ;Get end address of path mov CX,13 ; Read 1 filename int DOS jnc w_got1 ; If no carry, we got it ; If we can't process the temp file, SPAZ has no filenames to work with. ; The only safe thing to do, is exit with the errorlevel. This will leave ; any archives intact so they can be handled later. call err_msg ;Report error in english mov DX,offset TempErr ;Error processing temp file mov AH,OutputString ;DOS print string function int DOS ;Display error mov AH,ExitWithCode ;Terminate SPAZ int DOS ;Tell DOS to do it ; If we got here, there are four or fewer filenames, and they are in the ; scratch buffer. fname_ptr points to the current filename. Just copy all ; 13 bytes in; as before, the name was already null terminated. not_on_disk: push SI ; Save the index registers push DI mov SI,fname_ptr ; get the current source ptr mov DI,endpath ; Get end address of path mov CX,6 ; copy 12 bytes (6 words) rep movsw movsb ; copy the 13th byte mov fname_ptr,SI ; save the new pointer pop DI ; restore the index registers pop SI ; One way or another, we copied a filename. w_got1: inc names_used ; Note that we used a name clc ; Clear the carry flag ret wild_card endp ; The following routine scans each command line option and sets various ; flags according to options used. options proc near cld ;Ensure forward movements xor AX,AX ;Start with argument 1 Opt0: inc AX ;Bump argument number push AX ;Save argument number mov BX,cmdtail ;Point BX to command line call argv ;Get info on argument or AX,AX ;Did we find an argument? jnz StillMore jmp end_Opts ;Nope, we must be done... StillMore: push AX ;Save argument length mov SI,BX ;Address in SI call upper ;Convert to upper case lodsb ;Get first character cmp AL,'/' ;Is this an option? je Opt1 ;Go get it if yes cmp AL,'-' ;Option? jne arc_name ;Get archive name Opt1: pop AX ;Get argument length back push AX ;Maintain stack balance cmp AX,2 ;Check for valid size jne bad_opt ;Report bad option lodsb ;Get option ID cmp AL,'D' ;Delete flag? jne Opt2 ;Next check if not mov byte ptr D_Flag,true ;Set flag to delete arc's jmp short nxt_opt ;Do next option Opt2: cmp AL,'N' ;Sort flag? jne Opt3 ;Next check if not mov byte ptr N_Flag,false ;Set flag for no sort jmp short nxt_opt ;Do next option Opt3: cmp AL,'A' ;Default arc program flag? jne Opt4 ;Next check if not mov byte ptr A_Flag,true ;Set flag to show default set jmp short nxt_opt ;Do next option Opt4: cmp AL,'V' ;Verbose mode desired? jne Opt5 ;Next check if not mov byte ptr Q_Flag,false ;**Kludge** inverted quiet jmp short nxt_opt ;Do next option Opt5: cmp AL,'F' ;Is this a mail run? jne Opt6 ;Report bad option if not mov byte ptr F_Flag,true ;Set up for mail run jmp short nxt_opt ;Do next option Opt6: cmp AL,'O' ;Overwrite mode? jne Opt7 ;Make 1 more check mov byte ptr O_Flag,true ;Set overwrite mode jmp short nxt_opt Opt7: cmp AL,'R' ;For Opus compatibility jne bad_opt ;Report bad option if not mov byte ptr O_Flag,true ;Set overwrite mode jmp short nxt_opt bad_opt: call CheckMFlag ;Are we expanding addresses? jnc Nxt_Opt ;It's Ok, keep going mov AX,23 ;Unknow option used... call err_msg ;Report it jmp syntax ;Show syntax screen and exit arc_name: pop AX ;Get length back push AX ;Maintain stack balance cmp byte ptr Got_name,true ;Do we have an archive name? jne arc_name1 ;Nope, go get it call parse_line ;Yup, pass it the filenames... jmp short nxt_opt ;Continue with options arc_name1: mov Opt_Address,BX ;Save address of file name mov Opt_Length,AX ;Save length of file name mov byte ptr Got_name,true ;Set flag to show we got it! nxt_opt: pop AX ;Remove argument length pop AX ;Get arg number to work on jmp Opt0 ;Continue... end_Opts: add SP,2 ;Clean off stack junk cmp byte ptr Got_name,true ;Did we get a filename? jne bad_line ;Report error if not cmp F_Flag,true ;Is this a mail run? jne RestoreArg ;Go if not mov byte ptr D_Flag,true ;Set auto delete mov byte ptr N_Flag,true ;Force an archive sort mov byte ptr O_Flag,true ;Force overwrite mode RestoreArg: mov AX,Opt_Length ;Get length of argument mov BX,Opt_Address ;Get address of argument ret ;And we are outa' here.. ;If the program falls through to here, all arguments were examined and ;an archive name was NOT found. Report an error, show the syntax screen ;and quit. What else can we do? bad_line: mov AX,24 call err_msg jmp syntax options endp CheckMFlag proc near lodsb ;Get next character cmp AL,'M' ;Is this the M flag? jne NotTheMFlag ;Exit if no call DecimalIn ;Get net number mov word ptr OurNet,DX ;Save it call DecimalIn ;Get node number mov word ptr OurNode,DX ;Save it mov M_Flag,true ;Set our flag clc ;Show we processed it ret ;And exit NotTheMFlag: stc ;Oops, a boo-boo... ret ;Back to caller CheckMFlag endp ; This routine displays the current settings of the command line ; parameters. i.e. will sort, will not delete etc... show_opt proc near push AX push BX cmp byte ptr Q_Flag,true ;Quiet mode? jne NotQuietMode jmp show_x ;Exit if yes NotQuietMode: cld ;Ensure forward movements mov SI,offset will ;Point to will message cmp byte ptr A_Flag,true ;Use Arce? je show1 mov SI,offset wont show1: call ShowIt mov SI,offset info1 call ShowIt mov SI,offset will cmp byte ptr D_Flag,true ;Delete archives? je show2 mov SI,offset wont show2: call ShowIt mov SI,offset info2 call ShowIt mov SI,offset will cmp M_Flag,true ;Expand net address? je show3 mov SI,offset wont show3: call ShowIt mov SI,offset info5 call ShowIt mov SI,offset will cmp F_Flag,true ;A mail run? je show4 mov SI,offset wont show4: call ShowIt mov SI,offset info6 call ShowIt mov SI,offset will cmp byte ptr O_Flag,true ;Force overwrite mode? je show5 mov SI,offset wont show5: call ShowIt mov SI,offset info7 call ShowIt mov SI,offset will cmp byte ptr N_Flag,true ;Sort archive? je show6 mov SI,offset wont show6: call ShowIt mov SI,offset info3 call ShowIt show_x: pop BX pop AX ret show_opt endp ; This procedure converts an ASCII number to it's binary form. The ; routine will exit when the first non-ascii-number is reached. The ; binary value is returned in DX. DecimalIn proc near xor DX,DX ;Initialize variable DecimalLoop: lodsb ;Get first character sub AL,30h ;Subtract ASCII base jl DecimalExit ;If too low, we're finished cmp AL,9 jg DecimalExit ;If too high, we're finished cbw ;Convert to word value push AX ;Save digit mov AX,DX mov CX,10 ;Working with base 10 mul CX ; 10 * digit mov DX,AX ;Result in DX pop AX ;Get number back add DX,AX ;Add number in jmp short DecimalLoop ;Get next digit DecimalExit: ret ;Back to main section DecimalIn endp ; This routine parses filenames from the command line that must be passed ; to the unarchive program. parse_line proc near cld ;Go in the right direction! mov Parsed,true ;Show names were parsed mov CX,word ptr Names_Count ;Get current character count push AX ;Save argument length add AX,CX ;AX = new length total mov SI,BX ;Argument address to source mov DI,offset Extract_Names ;DI = buffer address add DI,CX ;Adjust to current position mov byte ptr [DI],blank ;Add in a space inc DI ;Adjust pointer inc AX ;Add 1 to total length mov word ptr Names_Count,AX ;Save new total length pop CX ;Get argument length in CX rep movsb ;Move extract name into buffer mov byte ptr [DI],0 ;End it with a null ret parse_line endp DisplayNode proc near cmp M_Flag,true ;Should we do this? jne ExitDisplayNode ;Exit if not mov SI,endpath ;Point to bundle name call GetFromAddress ;Decode the Address mov DI,offset BuildNet ;Where to store it mov AX,word ptr FromNet ;Get the Senders net mov DX,word ptr OurNet ;Get our own net add AX,DX ;Figure out the difference xor DX,DX ;Get ready for conversion call DecimalOut ;Convert to ASCII call InsertAddress ;Add Net number to string mov AL,'/' ;Address delimiter stosb ;Stuff it in mov AX,word ptr FromNode ;Get the Senders node mov DX,word ptr OurNode ;Get our node address add AX,DX ;Figure out the difference xor DX,DX ;Get ready for conversion call DecimalOut ;Convert to ASCII call InsertAddress ;Add node number to string mov byte ptr [DI],0 ;Make it ASCIIZ ExitDisplayNode: ret ;Back to main DisplayNode endp InsertAddress proc near mov SI,offset DecBuf ;Point to ASCII buffer Insert1: lodsb ;Get a byte cmp AL,blank ;Is it ASCII space? je Insert1 ;Loop if yes Insert2: stosb ;Not 0, we keep it... lodsb ;And get another or AL,AL ;Check for end jnz Insert2 ;Loop till finished ret ;Back to caller InsertAddress endp GetFromAddress proc near call GetNet ;Get the net bundle is from mov word ptr FromNet,DX ;And save it call GetNet ;Get the node number mov word ptr FromNode,DX ;And save it ret ;That's it! GetNet: xor DX,DX ;Start with 0 mov CX,4 ;Counter for Hex number Net1: lodsb ;Grab a byte sub AL,30h ;Mask off the ASCII jl Net3 ;Too low, exit cmp AL,9 ;0 to 9? jle Net2 ;If yes, no adjustment and AL,5fh ;Mask off the casing sub AL,7 ;Adjust for A-F jl Net3 ;Quit if too low cmp AL,15 ;Higher than F? jg Net3 ;Quit if too high Net2: push CX ;Save character counter cbw ;Sign extend our number mov CL,4 ;4 bits per hex character sal DX,CL ;Shift over previous value add DX,AX ;And add in the new pop CX ;Restore character counter loop Net1 ;Do 4 characters Net3: ret ;And then exit GetFromAddress endp BuildNet equ $ ;Buffer for Net/Node FromNet equ BuildNet + 12 ;Sending Net FromNode equ FromNet + 2 ;Sending Node OurNet equ FromNode + 2 ;Our Net OurNode equ OurNet + 2 ;Our Node cpy_buf equ OurNode + 2 ;Storage for copy buffer hdr_buf equ cpy_buf + bsize ;Buffer to hold headers cmd1 equ hdr_buf + entries * arc_len ;Buffer for wildcard filenames new equ cmd1 + 80 ;Buffer for Arc path search saved equ new + 80 ;Buffer for Arc exec decbuf equ saved + 192 ;Buffer for decimal conversions dta_buf equ decbuf + 8 ;Disk Transfer Area Def_Arc equ dta_buf + 43 ;Default Archive Name Fcb1 equ Def_Arc + 13 ;File Control Block 1 Fcb2 equ Fcb1 + 37 ;File control Block 2 Cmd_Cnt equ Fcb2 + 37 ;Command Line Char Counter ExtractOptions equ Cmd_Cnt + 1 ;Options to pass to Un-Archer Pakfile equ ExtractOptions + 9 ;Filenames to pass to Un-Archer Extract_Names equ Pakfile + 160 ;Buffer for names to extract Names_Count equ Extract_Names + 128 ;Count for names to extract tempspec equ Names_Count + 2 ;Scratch for temp filespec .jjn save_buf equ tempspec + 80 ; Filename buffer .jjn stk equ save_buf + (13 * NamesFound) ;Stack Area .jjn bottom equ stk + 200 ;End of code and data cseg ends end entry