WebSVN – Kolibri OS – Diff – /programs/other/archer/trunk/parser.inc


; @RCHER parser and filter routines
; Written in pure assembler by Ivushkin Andrey aka Willow
 
  fhs_local   equ 0x04034b50
  fhs_central equ 0x02014b50
  fhs_end     equ 0x06054b50
  fhs_enc     equ 0x08074b50
 
SkipASCIIZ:
    xor  eax,eax
    mov  ecx,255
    mov  edi,esi
    repne scasb
    mov  esi,edi
    ret
 
PrintFilename:
    pusha
    mov  esi,edx
    mov  edi,os_work
    mov  edx,edi
    rep  movsb
    mov  dword[edi],0x00a0d
    call DebugPrint
 
 
    popa
    call Add2Fat
    ret
 
Add2Fat:
; edx - ptr, ecx - len
 
    pusha
    test [Flags],LIST_MODE
    jz   .ex
    mov  ebp,8
    mov  edi,edx
    lea  ebx,[edx+ecx]
    mov  ecx,[lpath_len]
    cmp  ecx,1
    je   .lbl
    mov  esi,[lpath]
    repe cmpsb
    jne  .full
    mov  eax,[lpath_len]
    sub  dword[esp+24],eax;path_len-path
    cmp  edi,ebx
    je   .full
    mov  edx,edi
  .lbl:
    mov  ecx,[esp+24]
    mov  al,'/'
    repne scasb
    mov  eax,[fat_]
    mov  ecx,[esp+24]
    jne  .nofol
    cmp  edi,ebx
    jne  .full
    lea  ecx,[edi-1]
    sub  ecx,edx
    or   byte[eax+11],0x10
;    sub  edx,ecx
  .nofol:
 
    push [fat_fnum]
    pop  dword[eax+12]
    mov  edi,eax
    mov  esi,edx
  .lp1:
 
    mov  bl,[esi]
    lea  edx,[eax+ebp]
    inc  esi
    cmp  bl,'.'
    jne  .nodot
    lea  edi,[eax+ebp]
    mov  ebp,11
    jmp  .ll
  .nodot:
    cmp  edi,edx
    jae  .ll
    mov  [edi],bl
    inc  edi
  .ll:
    loop .lp1
    mov  ecx,11
    dec  eax
  .lp2:
    cmp  byte[eax+ecx],0
    jne  .no0
    mov  byte[eax+ecx],' '
  .no0:
    loop .lp2
    cmp  eax,child_stack-1
    jae  .full
    add  [fat_],32
  .full:
    inc  [fat_fnum]
  .ex:
    popa
    ret
 
;path db '/';'fasm/examples/elfexe/'
;path_len:
 
; Parse routines:
;   out: edx= 0 if all ok, 1 - central dir, 2-EOD
;             50 - encrypted
;             51 - not deflated
;             52 - invalid format
;             53 - dir skipped
;             1 - encrypted
 
; ****************************************************
ZipParse:
 
    call ResetFile
  .nxt:
    call ZipCrawl
 
    cmp  edx,3
    je  .ex
    cmp  edx,1
    je   .skipinc
if  IGNORE_DIRS eq 1
    cmp  edx,53
    jne  .skipinc
end if
    inc  [file_count]
  .skipinc:
    cmp  edx,52
    je   .er1
    cmp  edx,50
    jne   .seek
  .er1:
    Msg  edx
    ret
  .seek:
    add  eax,ecx
    mov  ebx,1
    call FileSeek
    jmp  .nxt
  .ex:
    Msg  2
    mov  eax,[file_count]
 if ~ SYS eq win
    dpd  eax
 else
    pusha
    call  int2str
    mov   edx,os_work
   	call  DebugPrint
   	popa
 end if
    Newline
;    Dump fat,160,os_work
    ret
 
ZipFindN:
; ecx - file #
    Msg 33
    or   [Flags],FIND_MODE
    cmp  ecx,[file_count]
    jae  .err
    push ecx
    call ResetFile
  .nxt:
 
    call ZipCrawl
    cmp  edx,51
    je   .ok2
  .noenc:
    test edx,edx
    jnz  .err
  .ok2:
    add  eax,ecx
    cmp  dword[esp],0
    jz   .ok
    dec  dword[esp]
    mov  ebx,1
    call FileSeek
    jmp  .nxt
  .err:
    mov  edx,4
    jmp  .ex
  .ok:
    pop  ecx
    sub  eax,[esi+18]
    add  esi,eax
    mov  edx,5
  .ex:
    and   [Flags],-1-FIND_MODE
    push edx
    Msg  edx
    pop  edx
    ret
 
ZipCrawl:
    mov  edx,52
    cmp  dword[esi],fhs_central
    jne  .noc
    mov  eax,46
    movzx ecx,word[esi+28]
    add  eax,ecx
    movzx ecx,word[esi+30]
    add  eax,ecx
    movzx ecx,word[esi+32]
    mov  edx,1
    ret
  .noc:
    cmp  dword[esi],fhs_end
    jne  .noe
  .edx3:
    Msg 3
    mov  edx,3
    ret
  .noe:
    cmp  dword[esi],fhs_local
    je   .loc
    cmp  dword[esi],fhs_enc
    jne  .err
    mov  eax,16
    xor  ecx,ecx
    mov  edx,1
    ret
  .loc:
    push word[esi+6]
    pop  [gpbf]
    push dword[esi+14]
    pop  [CRC_check]
    push dword[esi+22]
    pop  [unp_size]
    movzx ecx,word[esi+26]
    mov  eax,30
    lea  edx,[esi+eax]
    add  eax,ecx
if  IGNORE_DIRS eq 1
    cmp  byte[edx+ecx-1],'/'
    je   .skipdp
end if
    test [Flags],FIND_MODE
    jnz  .skipdp
    call PrintFilename
  .skipdp:
    movzx ecx,word[esi+28]
    add  eax,[esi+18]
    test [gpbf],1
    jz   .no_enc
    or   [Flags],DECRYPT_MODE  ; encrypted
    mov  edx,51
    jmp  .err
  .no_enc:
    test word[esi+8],7
    rep_err z,50
  .ok:
    xor  edx,edx
  .err:
    ret
 
; ***********************************************
GzipParse:
    ID1ID2 equ 0x8b1f
    FTEXT equ 1b
    FHCRC equ 10b
    FEXTRA equ 100b
    FNAME equ 1000b
    FCOMMENT equ 10000b
    mov  eax,7
    mov  ebx,2
    call FileSeek
    push dword[esi]
    pop  [CRC_check]
    push dword[esi+4]
    pop  [unp_size]
    call ResetFile
    xor  edx,edx
    cmp  word[esi],ID1ID2
    rep_err e, 52, 15
    cmp  byte[esi+2],8
    rep_err e, 52, 50
    mov  bl,[esi+3]  ; bl - FLG
    add  esi,10 ; esi->extra
    test bl,FEXTRA
    jz   .noextr
    movzx eax,word[esi]
    lea  esi,[esi+eax+2] ; esi->FNAME
  .noextr:
    test bl,FNAME
    jz   .nofname
    mov  edx,esi
    call DebugPrint
    call SkipASCIIZ
    cmp  dword[esi-5],'.tar'
    jne  .nofname
    or   [Flags],TAR_MODE
  .nofname:     ; esi->FCOMMENT
    test bl,FCOMMENT
    jz   .nocomm
    call SkipASCIIZ
  .nocomm:      ; esi->HCRC
    test bl,FHCRC
    jz   .noCRC16
    add  esi,2
  .noCRC16:
    cmp  [unp_size],OUTBUF
    jb   .sizeok2
    Msg  16
    mov  edx,15
    ret
  .sizeok2:
    xor  edx,edx
  .err:
    ret
 
PngParse:
    ID1 equ 0x474e5089
    ID2 equ 0x0a1a0a0d
    FDICT equ 100000b
    InitIDAT equ 2
    mov  [IDATcount],InitIDAT
    call ResetFile
    cmp  dword[esi],ID1
    rep_err e, 52, 18
    cmp  dword[esi+4],ID2
    rep_err e, 52, 18
    add  esi,8
    cmp  dword[esi+4],'IHDR'
    rep_err e,52, 18
    or   [Flags],PNG_MODE
    memcpy_esi PNG_info,13,8
    mov  eax,[PNG_info.Width]
    bswap eax
    mov  [PNG_info.Width],eax
    mov  eax,[PNG_info.Height]
    bswap eax
    mov  ebx,eax
    mov  [PNG_info.Height],eax
    call scanline_calc
;    dps  'All='
    cmp  [PNG_info.Color_type],3
    jne  .nopal
    shl  eax,3
    inc  eax
  .nopal:
    inc  eax
    imul eax,ebx
    mov  [unp_size],eax
;    dpd  eax
    add  esi,25
    cmp  byte[esi-5],0
    rep_err e,52,29
  .nxt_sec:
    lodsd
    bswap eax ; eax - section size
    push eax
    lodsd
    mov  edi,Png_ch
    mov  ecx,(E_ch-Png_ch) / 4
    repne scasd
    pop  eax
    mov  ebx,[esi-4]
    mov  edx,os_work
    mov  [edx],ebx
    mov  dword[edx+4],0x0a0d
  .dp:
    sub  edi,Png_ch
    shr  edi,2  ; edi- chunk #
 if SHOW_PNG_SEC eq 1
    call DebugPrint
 end if
    cmp  edi,1
    jne  .noend
    mov  edx,21
    jmp  .err
  .noend:
    cmp  edi,2
    jne  .noplte
    memcpy_esi PNG_info.Palette,eax
    jmp  .noidat
   .noplte:
    cmp  edi,3
    jne  .noidat
    mov  [IDATsize],eax
    cmp  [IDATcount],InitIDAT
    jne  .ex
    mov  [bits],8
  if RBLOCK eq 4
    lodsd
  else
    lodsb
  end if
    call setcurb
    rbits 0,16
    test ah,FDICT
    jz   .ex
    rbits 0,32
    add  [IDATcount],4
    jmp  .ex
   .noidat:
    add  eax,4
    mov  ebx,1
    call FileSeek
    jmp  .nxt_sec
   .ex:
    xor  edx,edx
   .err:
    ret
 
Png_ch:
    dd 'IEND','PLTE','IDAT','????'
E_ch:
 
ZipDecrypt:
    push edi
    mov  ecx,3
    mov  edi,Dheader
    rep  movsd
    pop  edi
    call QueryPwd
    jecxz .ex
    push esi
    mov  [DKeys],  305419896
    mov  [DKeys+4],591751049
    mov  [DKeys+8],878082192
    xor  eax,eax
    mov  esi,Dpassword
  .enc_init:
    lodsb
    call UKeys
    loop .enc_init
    mov  ecx,12
    mov  esi,Dheader
  .dec_header:
    call decrypt_byte
    xor  al,[esi]
    call UKeys
    mov  [esi],al
    inc  esi
    loop .dec_header
    mov  eax,[CRC_check]
    pop  esi
  .ex:
    ret
 
QueryPwd:
; out: ecx - passwd len
if  SYS eq win
    Msg 32
    invoke ReadConsole,[cons_in],Dpassword,PASSW_LEN,cparam1,NULL
    test eax,eax
    jnz  .inp_ok
    xor  ecx,ecx
    jmp  .ex
  .inp_ok:
    mov  ecx,[cparam1]
    cmp  ecx,PASSW_LEN
    je   .ex
    sub  ecx,2
else
end if
  .ex:
    ret
 
UKeys:
; in: al - char
    pusha
    mov  edi,134775813
    mov  ebx,DKeys
    mov  esi,os_work
    mov  byte[esi],al
    mov  ecx,1
    push dword[ebx]
    pop  [CRC32]
    call UCRC
    push [CRC32]
    pop  dword[ebx]
    mov  eax,[ebx]
    and  eax,0xff
    add  eax,[ebx+4]
    mul  edi
    inc  eax
    mov  [ebx+4],eax
    shr  eax,24
    mov  byte[esi],al
    push dword[ebx+8]
    pop  [CRC32]
    call UCRC
    push [CRC32]
    pop  dword[ebx+8]
    popa
    ret
 
decrypt_byte:
; out: al
    push ebx edx
    movzx ebx,word[DKeys+8]
    or   ebx,2
    mov  eax,ebx
    xor  eax,1
    mul  ebx
    shr  eax,8
    pop  edx ebx
    ret
 
setcurb:
; in: eax
    test [Flags],DECRYPT_MODE
    jz   .noenc
    push eax
    call decrypt_byte
    xor  al,byte[esp]
    add  esp,4
    call UKeys
  .noenc:
    mov  [cur_byte],eax
    ret
 
TarParse:
    mov  esi,output
;    call ResetFile
  .nxt:
    call TarCrawl
;    wait
    cmp  edx,3
    je   ZipParse.ex
if  IGNORE_DIRS eq 1
    cmp  edx,53
    jne  .skipinc
end if
    inc  [file_count]
  .skipinc:
    add  eax,ecx
;    mov  ebx,1
    add  esi,eax
;    call FileSeek
    jmp  .nxt
 
TarFindN:
; in:  ecx - file number
; ecx - file #
    Msg 33
    cmp  ecx,[file_count]
    jae  .err
    push ecx
    mov  esi,output
;    call ResetFile
  .nxt:
    call TarCrawl
if  IGNORE_DIRS eq 1
    cmp  edx,53
    je  .seek
end if
    test edx,edx
    jnz  .err
    cmp  dword[esp],0
    jz   .ok
    dec  dword[esp]
  .seek:
    add  eax,ecx
;    mov  ebx,1
    add  esi,eax
;    call FileSeek
    jmp  .nxt
  .err:
    mov  edx,4
    jmp  .ex
  .ok:
    pop  ecx
    add  esi,eax
    mov  edx,5
  .ex:
    Msg  edx
    ret
 
TarCrawl:
    cmp  byte[esi],0
    jz   ZipCrawl.edx3
    push esi
    mov  ecx,11
    add  esi,0x7c
    call Octal_str
    mov  esi,[esp]
    mov  [outfile.size],eax
    call SkipASCIIZ
if  IGNORE_DIRS eq 1
    cmp  byte[esi-2],'/'
    je   .skipdp
end if
    mov  edx,[esp]
    lea  ecx,[esi-1]
    sub  ecx,edx
    call PrintFilename
  .skipdp:
    mov  ecx,[outfile.size]
    jecxz .zerolen
    shr  ecx,9
    inc  ecx
    shl  ecx,9
  .zerolen:
    mov  eax,512
    pop  esi
    jmp  ZipCrawl.ok
 
Octal_str:
; in:  esi - ASCIIZ octal string
;      ecx - its length
; out: eax - value
    push esi ebx ecx
    xor  ebx,ebx
    xor  eax,eax
  .jec:
    jecxz .zero
    cmp  byte[esi+ecx-1],' '
    jne  .lp
    dec  ecx
    jmp  .jec
  .lp:
    lodsb
    shl  ebx,3
    cmp  eax,' '
    je   .space
    lea  ebx,[ebx+eax-'0']
  .space:
    loop .lp
    mov  eax,ebx
  .zero:
    pop  ecx ebx esi
    ret
 
TRAILING_BUF equ 2048
SfxParse:
    call ResetFile
    cmp  word[esi],'MZ'
    rep_err e, 34
    mov  eax,TRAILING_BUF
    mov  ecx,eax
    mov  ebx,2
    call FileSeek
    mov  edi,esi
    mov  al,'P'
  .lp:
    repne scasb
    cmp  dword[edi-1],fhs_end
    je   .end_found
    jecxz .err
    jmp   .lp
  .end_found:
    dec   edi
    mov   esi,edi
    mov   eax,[edi+12]
    neg   eax
    mov   ebx,1
    call  FileSeek
    push  dword[esi+42]
    pop   [arc_base]
  .err:
    ret
 
 
 
 
 
 
scanline_calc:
    movzx ecx,byte[PNG_info.Color_type]
    mov  eax,1
    cmp  cl,3
    je   .palette
    test cl,2
    jz  .notriple
    add  eax,2
  .notriple:
    test cl,4
    jz   .calc_bpp
    inc  eax
  .calc_bpp:
    mul  [PNG_info.Bit_depth]
  .palette:
    mov  ecx,eax   ; in bits
    shr  eax,3     ; in bytes
    test eax,eax
    jnz  .noz
    inc  eax
  .noz:
    mov  [png_bpp],eax
    mov  eax,[PNG_info.Width]
    mov  ebp,eax
    imul ecx
    shr  eax,3
    test eax,eax
    jnz  .noz2
    inc  eax
  .noz2:
    ret
 
; Created:  May 31, 2005
FiltCall:
dd PngFilter.nofilt,Filt_sub,Filt_up,Filt_av,Filt_paeth,PngFilter.nofilt
PngFilter:
; esi - filtered uncompressed image data
; edi - destination
    call scanline_calc
    mov  [sline_len],eax   ; scanline length
    push edi
    and  [Flags],not 1
    mov  ecx,[PNG_info.Height]
  .scanline:
;    Msg 9,1
    push ecx
    lodsb
    movzx eax,al
    cmp  eax,5
    jb   .f_ok
    mov  eax,5
  .f_ok:
    inc  dword[filters+eax*4]
    jmp  dword[FiltCall+eax*4]
  .nofilt:
    mov  dl,[PNG_info.Color_type]
    cmp  dl,3
    jne  .nopalette
    lodsb
    mov  [cur_byte],eax
    mov  [bits],8
    mov  ecx,ebp
  .pixel:
    push ecx
    movzx ecx,[PNG_info.Bit_depth]
    call rb_png
    push esi
    lea  esi,[eax+eax*2]
    add  esi,PNG_info.Palette
    call PngStore
    pop  esi
    pop  ecx
    loop .pixel
    cmp  [bits],8
    jne  .lp
    dec  esi
  .lp:
    pop  ecx
    loop .sl
    jmp  .sl2
  .sl:
;//
MV equ 1
;    mov  eax,ecx
;    and  eax,1 shl MOVE_SLINE_LEV-1
;    jnz  .scanline
;stop
if MV eq 0
    push ecx
    mov  ecx,edi
    sub  ecx,esi
    sub  [outp],esi
    mov  edi,output
    add  [outp],edi
    rep  movsb
    mov  esi,output
    pop  ecx
    pop  eax
    push [outp]
end if
;;//
    jmp  .scanline
  .sl2:
;//
;    call MoveScanline
    sub  edi,[outp]
;//
;    sub  edi,[esp]
    pop  eax
    ret
 
  .nopalette:
    test  dl,2
    jz   .notriple1
  .__:
    mov  ecx,[PNG_info.Width]
  .RGBcp:
    call PngStore
    add  esi,[png_bpp]
    loop .RGBcp
    jmp  .lp
  .notriple1:
    test dl,dl
    jz  .gray
    cmp  dl,4
    jne .__
;    Msg 31
;    ud2
  .gray:
;    stop
    push ecx
    mov  ecx,[PNG_info.Width]
    mov  [bits],8
    lodsb
    mov  [cur_byte],eax
  .gray2:
    push ecx
    movzx ecx,[PNG_info.Bit_depth]
    push ecx
    call rb_png
    pop  ecx
    cmp  ecx,8
    jbe  .lo
    add  esi,2
    shr  eax,8
    jmp  .stsb
  .lo:
    neg  ecx
    add  ecx,8
    shl  eax,cl
  .stsb:
    mov  ecx,3
    rep  stosb
    pop  ecx
    loop .gray2
    dec  esi
    pop  ecx
    jmp  .lp
 
Filt_sub:
;    dps  '-'
    mov  ecx,[sline_len]
    sub  ecx,[png_bpp]
    push esi edi
    mov  edi,esi
    add  edi,[png_bpp]
  .scan:    ; esi - previous, edi - current
    lodsb
    add  [edi],al
    inc  edi
    loop .scan
 
    pop  edi esi
;    dps  '-'
    jmp  PngFilter.nofilt
 
Filt_up:
    cmp  ecx,[PNG_info.Height]
    je   PngFilter.nofilt
    push esi edi
    mov  ecx,[sline_len]
    mov  edi,esi
    sub  esi,ecx
    dec  esi
    jmp  Filt_sub.scan
 
Filt_av:
    pusha
    mov  ecx,[sline_len]
    mov  ebp,[PNG_info.Height]
    mov  edx,[png_bpp] ; edx-raw
    neg  edx
    mov  ebx,ecx
    sub  ebx,[png_bpp]
    mov  edi,esi
    sub  esi,ecx
    dec  esi           ; esi-prior
  .lpavg:
    xor  eax,eax
    cmp  [esp+24h],ebp
    je   .1stl
    movzx eax,byte[esi]
  .1stl:
    cmp  ecx,ebx
    ja   .leftbad
    push ecx
    movzx ecx,byte[edi+edx]
    add  eax,ecx
    pop  ecx
  .leftbad:
    shr  eax,1
    add  [edi],al
    inc  esi
    inc  edi
    loop .lpavg
    popa
    jmp  PngFilter.nofilt
 
Filt_paeth:
    pusha
    mov  ecx,[sline_len]
    mov  edx,[png_bpp]
    neg  edx
    lea  ebp,[ecx+edx] ; left edge
    mov  edi,esi
    sub  esi,ecx
    dec  esi
  .lpaeth:
    push ecx
    movzx eax,byte[edi+edx]
    movzx ebx,byte[esi]
    movzx ecx,byte[esi+edx]
    push eax
    mov  eax,[esp+28h]
    cmp  eax,[PNG_info.Height] ; 1st line
    jne  .no1stlineok
    xor  ebx,ebx
    xor  ecx,ecx
  .no1stlineok:
    pop  eax
    cmp  [esp],ebp     ; ecx
    jbe  .leftok      ; x-bpp>=0
    xor  eax,eax
    xor  ecx,ecx
  .leftok:
    pusha   ; eax-28, ebx-16, ecx-24
    lea  edx,[eax+ebx]
    sub  edx,ecx        ; p=edx
    sub  eax,edx        ; pa := abs(p - a)
    jge  .eaxp
    neg  eax
  .eaxp:
    sub  ebx,edx        ; pb := abs(p - b)
    jge  .ebxp
    neg  ebx
  .ebxp:
    sub  ecx,edx        ; pc := abs(p - c)
    jge  .ecxp
    neg  ecx
  .ecxp:
    cmp  eax,ebx
    ja   .noa
    cmp  eax,ecx
    jbe  .ex            ; pa-min
  .noa:
    cmp  ebx,ecx
    ja   .nob
    mov  eax,[esp+16]
    jmp  .ex2
  .nob:
    mov  eax,[esp+24]
  .ex2:
    mov  [esp+28],eax
  .ex:
    popa
    add  [edi],al
    inc  esi
    inc  edi
    pop  ecx
    loop .lpaeth
    popa
    jmp  PngFilter.nofilt
 
rb_png: ; eax-dest; ecx-count
    push ecx
    xor  eax,eax
  .shift:
    rol  byte[cur_byte],1
    rcl  eax,1
  .dec:
    dec  [bits]
    jnz  .loop1
  .push:
    push dword[esi]
    pop  [cur_byte]
    mov  [bits],8
    inc  esi
  .loop1:
    loop .shift
    pop  ecx
    ret
 
PngStore:
    push esi
    cmp  [PNG_info.Bit_depth],8
    jbe  .lo
    add  esi,3
  .lo:
  if ~ SYS eq win
    mov  esi,[esi]
    bswap esi
    shr  esi,8
    mov  [edi],esi
    add  edi,3
  else
    movsw
    movsb
  end if
    pop  esi
    ret
 
FiltStats:
    pusha
    xor  ebx,ebx
    mov  edx,23
    mov  ecx,6
  .lp:
    push ecx edx
    Msg  edx
    mov  eax,[filters+ebx*4]
    DebugPrintDec
    pop  edx ecx
    inc  edx
    inc  ebx
    loop .lp
    Newline
    popa
    ret

Rev 111	Rev 131
1	; @RCHER parser and filter routines	1	; @RCHER parser and filter routines
2	; Written in pure assembler by Ivushkin Andrey aka Willow	2	; Written in pure assembler by Ivushkin Andrey aka Willow
3		3
4	fhs_local equ 0x04034b50	4	fhs_local equ 0x04034b50
5	fhs_central equ 0x02014b50	5	fhs_central equ 0x02014b50
6	fhs_end equ 0x06054b50	6	fhs_end equ 0x06054b50
7	fhs_enc equ 0x08074b50	7	fhs_enc equ 0x08074b50
8		8
9	SkipASCIIZ:	9	SkipASCIIZ:
10	xor eax,eax	10	xor eax,eax
11	mov ecx,255	11	mov ecx,255
12	mov edi,esi	12	mov edi,esi
13	repne scasb	13	repne scasb
14	mov esi,edi	14	mov esi,edi
15	ret	15	ret
16		16
17	PrintFilename:	17	PrintFilename:
18	pusha	18	pusha
19	mov esi,edx	19	mov esi,edx
20	mov edi,os_work	20	mov edi,os_work
21	mov edx,edi	21	mov edx,edi
22	rep movsb	22	rep movsb
23	mov dword[edi],0x00a0d	23	mov dword[edi],0x00a0d
24	call DebugPrint	24	call DebugPrint
25	; mcall 10	-
26	; mcall 2	-
27	popa	25	popa
-		26	call Add2Fat
28	ret	27	ret
-		28
-		29	Add2Fat:
-		30	; edx - ptr, ecx - len
-		31
-		32	pusha
-		33	test [Flags],LIST_MODE
-		34	jz .ex
-		35	mov ebp,8
-		36	mov edi,edx
-		37	lea ebx,[edx+ecx]
-		38	mov ecx,[lpath_len]
-		39	cmp ecx,1
-		40	je .lbl
-		41	mov esi,[lpath]
-		42	repe cmpsb
-		43	jne .full
-		44	mov eax,[lpath_len]
-		45	sub dword[esp+24],eax;path_len-path
-		46	cmp edi,ebx
-		47	je .full
-		48	mov edx,edi
-		49	.lbl:
-		50	mov ecx,[esp+24]
-		51	mov al,'/'
-		52	repne scasb
-		53	mov eax,[fat_]
-		54	mov ecx,[esp+24]
-		55	jne .nofol
-		56	cmp edi,ebx
-		57	jne .full
-		58	lea ecx,[edi-1]
-		59	sub ecx,edx
-		60	or byte[eax+11],0x10
-		61	; sub edx,ecx
-		62	.nofol:
-		63
-		64	push [fat_fnum]
-		65	pop dword[eax+12]
-		66	mov edi,eax
-		67	mov esi,edx
-		68	.lp1:
-		69
-		70	mov bl,[esi]
-		71	lea edx,[eax+ebp]
-		72	inc esi
-		73	cmp bl,'.'
-		74	jne .nodot
-		75	lea edi,[eax+ebp]
-		76	mov ebp,11
-		77	jmp .ll
-		78	.nodot:
-		79	cmp edi,edx
-		80	jae .ll
-		81	mov [edi],bl
-		82	inc edi
-		83	.ll:
-		84	loop .lp1
-		85	mov ecx,11
-		86	dec eax
-		87	.lp2:
-		88	cmp byte[eax+ecx],0
-		89	jne .no0
-		90	mov byte[eax+ecx],' '
-		91	.no0:
-		92	loop .lp2
-		93	cmp eax,child_stack-1
-		94	jae .full
-		95	add [fat_],32
-		96	.full:
-		97	inc [fat_fnum]
-		98	.ex:
-		99	popa
-		100	ret
-		101
-		102	;path db '/';'fasm/examples/elfexe/'
29		103	;path_len:
30		104
31	; Parse routines:	105	; Parse routines:
32	; out: edx= 0 if all ok, 1 - central dir, 2-EOD	106	; out: edx= 0 if all ok, 1 - central dir, 2-EOD
33	; 50 - encrypted	107	; 50 - encrypted
34	; 51 - not deflated	108	; 51 - not deflated
35	; 52 - invalid format	109	; 52 - invalid format
36	; 53 - dir skipped	110	; 53 - dir skipped
37	; 1 - encrypted	111	; 1 - encrypted
38		112
39	; ****************************************************	113	; ****************************************************
40	ZipParse:	114	ZipParse:
41		115
42	call ResetFile	116	call ResetFile
43	.nxt:	117	.nxt:
44	call ZipCrawl	118	call ZipCrawl
45		119
46	cmp edx,3	120	cmp edx,3
47	je .ex	121	je .ex
48	cmp edx,1	122	cmp edx,1
49	je .skipinc	123	je .skipinc
50	if IGNORE_DIRS eq 1	124	if IGNORE_DIRS eq 1
51	cmp edx,53	125	cmp edx,53
52	jne .skipinc	126	jne .skipinc
53	end if	127	end if
54	inc [file_count]	128	inc [file_count]
55	.skipinc:	129	.skipinc:
56	cmp edx,52	130	cmp edx,52
57	je .er1	131	je .er1
58	cmp edx,50	132	cmp edx,50
59	jne .seek	133	jne .seek
60	.er1:	134	.er1:
61	Msg edx	135	Msg edx
62	ret	136	ret
63	.seek:	137	.seek:
64	add eax,ecx	138	add eax,ecx
65	mov ebx,1	139	mov ebx,1
66	call FileSeek	140	call FileSeek
67	jmp .nxt	141	jmp .nxt
68	.ex:	142	.ex:
69	Msg 2	143	Msg 2
70	mov eax,[file_count]	144	mov eax,[file_count]
71	if ~ SYS eq win	145	if ~ SYS eq win
72	dpd eax	146	dpd eax
73	else	147	else
74	pusha	148	pusha
75	call int2str	149	call int2str
76	mov edx,os_work	150	mov edx,os_work
77	call DebugPrint	151	call DebugPrint
78	popa	152	popa
79	end if	153	end if
80	Newline	154	Newline
-		155	; Dump fat,160,os_work
81	ret	156	ret
82		157
83	ZipFindN:	158	ZipFindN:
84	; ecx - file #	159	; ecx - file #
85	Msg 33	160	Msg 33
-		161	or [Flags],FIND_MODE
86	cmp ecx,[file_count]	162	cmp ecx,[file_count]
87	jae .err	163	jae .err
88	push ecx	164	push ecx
89	call ResetFile	165	call ResetFile
90	.nxt:	166	.nxt:
-		167
91	call ZipCrawl	168	call ZipCrawl
92	cmp edx,51	169	cmp edx,51
93	je .ok2	170	je .ok2
94	.noenc:	171	.noenc:
95	test edx,edx	172	test edx,edx
96	jnz .err	173	jnz .err
97	.ok2:	174	.ok2:
98	add eax,ecx	175	add eax,ecx
99	cmp dword[esp],0	176	cmp dword[esp],0
100	jz .ok	177	jz .ok
101	dec dword[esp]	178	dec dword[esp]
102	mov ebx,1	179	mov ebx,1
103	call FileSeek	180	call FileSeek
104	jmp .nxt	181	jmp .nxt
105	.err:	182	.err:
106	mov edx,4	183	mov edx,4
107	jmp .ex	184	jmp .ex
108	.ok:	185	.ok:
109	pop ecx	186	pop ecx
110	sub eax,[esi+18]	187	sub eax,[esi+18]
111	add esi,eax	188	add esi,eax
112	mov edx,5	189	mov edx,5
113	.ex:	190	.ex:
-		191	and [Flags],-1-FIND_MODE
114	push edx	192	push edx
115	Msg edx	193	Msg edx
116	pop edx	194	pop edx
117	ret	195	ret
118		196
119	ZipCrawl:	197	ZipCrawl:
120	mov edx,52	198	mov edx,52
121	cmp dword[esi],fhs_central	199	cmp dword[esi],fhs_central
122	jne .noc	200	jne .noc
123	mov eax,46	201	mov eax,46
124	movzx ecx,word[esi+28]	202	movzx ecx,word[esi+28]
125	add eax,ecx	203	add eax,ecx
126	movzx ecx,word[esi+30]	204	movzx ecx,word[esi+30]
127	add eax,ecx	205	add eax,ecx
128	movzx ecx,word[esi+32]	206	movzx ecx,word[esi+32]
129	mov edx,1	207	mov edx,1
130	ret	208	ret
131	.noc:	209	.noc:
132	cmp dword[esi],fhs_end	210	cmp dword[esi],fhs_end
133	jne .noe	211	jne .noe
134	.edx3:	212	.edx3:
135	Msg 3	213	Msg 3
136	mov edx,3	214	mov edx,3
137	ret	215	ret
138	.noe:	216	.noe:
139	cmp dword[esi],fhs_local	217	cmp dword[esi],fhs_local
140	je .loc	218	je .loc
141	cmp dword[esi],fhs_enc	219	cmp dword[esi],fhs_enc
142	jne .err	220	jne .err
143	mov eax,16	221	mov eax,16
144	xor ecx,ecx	222	xor ecx,ecx
145	mov edx,1	223	mov edx,1
146	ret	224	ret
147	.loc:	225	.loc:
148	push word[esi+6]	226	push word[esi+6]
149	pop [gpbf]	227	pop [gpbf]
150	push dword[esi+14]	228	push dword[esi+14]
151	pop [CRC_check]	229	pop [CRC_check]
152	push dword[esi+22]	230	push dword[esi+22]
153	pop [unp_size]	231	pop [unp_size]
154	movzx ecx,word[esi+26]	232	movzx ecx,word[esi+26]
155	mov eax,30	233	mov eax,30
156	lea edx,[esi+eax]	234	lea edx,[esi+eax]
157	add eax,ecx	235	add eax,ecx
158	if IGNORE_DIRS eq 1	236	if IGNORE_DIRS eq 1
159	cmp byte[edx+ecx-1],'/'	237	cmp byte[edx+ecx-1],'/'
160	je .skipdp	238	je .skipdp
161	end if	239	end if
-		240	test [Flags],FIND_MODE
-		241	jnz .skipdp
162	call PrintFilename	242	call PrintFilename
163	.skipdp:	243	.skipdp:
164	movzx ecx,word[esi+28]	244	movzx ecx,word[esi+28]
165	add eax,[esi+18]	245	add eax,[esi+18]
166	test [gpbf],1	246	test [gpbf],1
167	jz .no_enc	247	jz .no_enc
168	or [Flags],DECRYPT_MODE ; encrypted	248	or [Flags],DECRYPT_MODE ; encrypted
169	mov edx,51	249	mov edx,51
170	jmp .err	250	jmp .err
171	.no_enc:	251	.no_enc:
172	test word[esi+8],7	252	test word[esi+8],7
173	rep_err z,50	253	rep_err z,50
174	.ok:	254	.ok:
175	xor edx,edx	255	xor edx,edx
176	.err:	256	.err:
177	ret	257	ret
178		258
179	; ***********************************************	259	; ***********************************************
180	GzipParse:	260	GzipParse:
181	ID1ID2 equ 0x8b1f	261	ID1ID2 equ 0x8b1f
182	FTEXT equ 1b	262	FTEXT equ 1b
183	FHCRC equ 10b	263	FHCRC equ 10b
184	FEXTRA equ 100b	264	FEXTRA equ 100b
185	FNAME equ 1000b	265	FNAME equ 1000b
186	FCOMMENT equ 10000b	266	FCOMMENT equ 10000b
187	mov eax,7	267	mov eax,7
188	mov ebx,2	268	mov ebx,2
189	call FileSeek	269	call FileSeek
190	push dword[esi]	270	push dword[esi]
191	pop [CRC_check]	271	pop [CRC_check]
192	push dword[esi+4]	272	push dword[esi+4]
193	pop [unp_size]	273	pop [unp_size]
194	call ResetFile	274	call ResetFile
195	xor edx,edx	275	xor edx,edx
196	cmp word[esi],ID1ID2	276	cmp word[esi],ID1ID2
197	rep_err e, 52, 15	277	rep_err e, 52, 15
198	cmp byte[esi+2],8	278	cmp byte[esi+2],8
199	rep_err e, 52, 50	279	rep_err e, 52, 50
200	mov bl,[esi+3] ; bl - FLG	280	mov bl,[esi+3] ; bl - FLG
201	add esi,10 ; esi->extra	281	add esi,10 ; esi->extra
202	test bl,FEXTRA	282	test bl,FEXTRA
203	jz .noextr	283	jz .noextr
204	movzx eax,word[esi]	284	movzx eax,word[esi]
205	lea esi,[esi+eax+2] ; esi->FNAME	285	lea esi,[esi+eax+2] ; esi->FNAME
206	.noextr:	286	.noextr:
207	test bl,FNAME	287	test bl,FNAME
208	jz .nofname	288	jz .nofname
209	mov edx,esi	289	mov edx,esi
210	call DebugPrint	290	call DebugPrint
211	call SkipASCIIZ	291	call SkipASCIIZ
212	cmp dword[esi-5],'.tar'	292	cmp dword[esi-5],'.tar'
213	jne .nofname	293	jne .nofname
214	or [Flags],TAR_MODE	294	or [Flags],TAR_MODE
215	.nofname: ; esi->FCOMMENT	295	.nofname: ; esi->FCOMMENT
216	test bl,FCOMMENT	296	test bl,FCOMMENT
217	jz .nocomm	297	jz .nocomm
218	call SkipASCIIZ	298	call SkipASCIIZ
219	.nocomm: ; esi->HCRC	299	.nocomm: ; esi->HCRC
220	test bl,FHCRC	300	test bl,FHCRC
221	jz .noCRC16	301	jz .noCRC16
222	add esi,2	302	add esi,2
223	.noCRC16:	303	.noCRC16:
224	cmp [unp_size],OUTBUF	304	cmp [unp_size],OUTBUF
225	jb .sizeok2	305	jb .sizeok2
226	Msg 16	306	Msg 16
227	mov edx,15	307	mov edx,15
228	ret	308	ret
229	.sizeok2:	309	.sizeok2:
230	xor edx,edx	310	xor edx,edx
231	.err:	311	.err:
232	ret	312	ret
233		313
234	PngParse:	314	PngParse:
235	ID1 equ 0x474e5089	315	ID1 equ 0x474e5089
236	ID2 equ 0x0a1a0a0d	316	ID2 equ 0x0a1a0a0d
237	FDICT equ 100000b	317	FDICT equ 100000b
238	InitIDAT equ 2	318	InitIDAT equ 2
239	mov [IDATcount],InitIDAT	319	mov [IDATcount],InitIDAT
240	call ResetFile	320	call ResetFile
241	cmp dword[esi],ID1	321	cmp dword[esi],ID1
242	rep_err e, 52, 18	322	rep_err e, 52, 18
243	cmp dword[esi+4],ID2	323	cmp dword[esi+4],ID2
244	rep_err e, 52, 18	324	rep_err e, 52, 18
245	add esi,8	325	add esi,8
246	cmp dword[esi+4],'IHDR'	326	cmp dword[esi+4],'IHDR'
247	rep_err e,52, 18	327	rep_err e,52, 18
248	or [Flags],PNG_MODE	328	or [Flags],PNG_MODE
249	memcpy_esi PNG_info,13,8	329	memcpy_esi PNG_info,13,8
250	mov eax,[PNG_info.Width]	330	mov eax,[PNG_info.Width]
251	bswap eax	331	bswap eax
252	mov [PNG_info.Width],eax	332	mov [PNG_info.Width],eax
253	mov eax,[PNG_info.Height]	333	mov eax,[PNG_info.Height]
254	bswap eax	334	bswap eax
-		335	mov ebx,eax
255	mov [PNG_info.Height],eax	336	mov [PNG_info.Height],eax
-		337	call scanline_calc
-		338	; dps 'All='
-		339	cmp [PNG_info.Color_type],3
-		340	jne .nopal
-		341	shl eax,3
-		342	inc eax
-		343	.nopal:
-		344	inc eax
-		345	imul eax,ebx
-		346	mov [unp_size],eax
-		347	; dpd eax
256	add esi,25	348	add esi,25
257	cmp byte[esi-5],0	349	cmp byte[esi-5],0
258	rep_err e,52,29	350	rep_err e,52,29
259	.nxt_sec:	351	.nxt_sec:
260	lodsd	352	lodsd
261	bswap eax ; eax - section size	353	bswap eax ; eax - section size
262	push eax	354	push eax
263	lodsd	355	lodsd
264	mov edi,Png_ch	356	mov edi,Png_ch
265	mov ecx,(E_ch-Png_ch) / 4	357	mov ecx,(E_ch-Png_ch) / 4
266	repne scasd	358	repne scasd
267	pop eax	359	pop eax
268	mov ebx,[esi-4]	360	mov ebx,[esi-4]
269	mov edx,os_work	361	mov edx,os_work
270	mov [edx],ebx	362	mov [edx],ebx
271	mov dword[edx+4],0x0a0d	363	mov dword[edx+4],0x0a0d
272	.dp:	364	.dp:
273	sub edi,Png_ch	365	sub edi,Png_ch
274	shr edi,2 ; edi- chunk #	366	shr edi,2 ; edi- chunk #
275	if SHOW_PNG_SEC eq 1	367	if SHOW_PNG_SEC eq 1
276	call DebugPrint	368	call DebugPrint
277	end if	369	end if
278	cmp edi,1	370	cmp edi,1
279	jne .noend	371	jne .noend
280	mov edx,21	372	mov edx,21
281	jmp .err	373	jmp .err
282	.noend:	374	.noend:
283	cmp edi,2	375	cmp edi,2
284	jne .noplte	376	jne .noplte
285	memcpy_esi PNG_info.Palette,eax	377	memcpy_esi PNG_info.Palette,eax
286	jmp .noidat	378	jmp .noidat
287	.noplte:	379	.noplte:
288	cmp edi,3	380	cmp edi,3
289	jne .noidat	381	jne .noidat
290	mov [IDATsize],eax	382	mov [IDATsize],eax
291	cmp [IDATcount],InitIDAT	383	cmp [IDATcount],InitIDAT
292	jne .ex	384	jne .ex
293	mov [bits],8	385	mov [bits],8
294	if RBLOCK eq 4	386	if RBLOCK eq 4
295	lodsd	387	lodsd
296	else	388	else
297	lodsb	389	lodsb
298	end if	390	end if
299	call setcurb	391	call setcurb
300	rbits 0,16	392	rbits 0,16
301	test ah,FDICT	393	test ah,FDICT
302	jz .ex	394	jz .ex
303	rbits 0,32	395	rbits 0,32
304	add [IDATcount],4	396	add [IDATcount],4
305	jmp .ex	397	jmp .ex
306	.noidat:	398	.noidat:
307	add eax,4	399	add eax,4
308	mov ebx,1	400	mov ebx,1
309	call FileSeek	401	call FileSeek
310	jmp .nxt_sec	402	jmp .nxt_sec
311	.ex:	403	.ex:
312	xor edx,edx	404	xor edx,edx
313	.err:	405	.err:
314	ret	406	ret
315		407
316	Png_ch:	408	Png_ch:
317	dd 'IEND','PLTE','IDAT','????'	409	dd 'IEND','PLTE','IDAT','????'
318	E_ch:	410	E_ch:
319		411
320	ZipDecrypt:	412	ZipDecrypt:
321	push edi	413	push edi
322	mov ecx,3	414	mov ecx,3
323	mov edi,Dheader	415	mov edi,Dheader
324	rep movsd	416	rep movsd
325	pop edi	417	pop edi
326	call QueryPwd	418	call QueryPwd
327	jecxz .ex	419	jecxz .ex
328	push esi	420	push esi
329	mov [DKeys], 305419896	421	mov [DKeys], 305419896
330	mov [DKeys+4],591751049	422	mov [DKeys+4],591751049
331	mov [DKeys+8],878082192	423	mov [DKeys+8],878082192
332	xor eax,eax	424	xor eax,eax
333	mov esi,Dpassword	425	mov esi,Dpassword
334	.enc_init:	426	.enc_init:
335	lodsb	427	lodsb
336	call UKeys	428	call UKeys
337	loop .enc_init	429	loop .enc_init
338	mov ecx,12	430	mov ecx,12
339	mov esi,Dheader	431	mov esi,Dheader
340	.dec_header:	432	.dec_header:
341	call decrypt_byte	433	call decrypt_byte
342	xor al,[esi]	434	xor al,[esi]
343	call UKeys	435	call UKeys
344	mov [esi],al	436	mov [esi],al
345	inc esi	437	inc esi
346	loop .dec_header	438	loop .dec_header
347	mov eax,[CRC_check]	439	mov eax,[CRC_check]
348	pop esi	440	pop esi
349	.ex:	441	.ex:
350	ret	442	ret
351		443
352	QueryPwd:	444	QueryPwd:
353	; out: ecx - passwd len	445	; out: ecx - passwd len
354	if SYS eq win	446	if SYS eq win
355	Msg 32	447	Msg 32
356	invoke ReadConsole,[cons_in],Dpassword,PASSW_LEN,cparam1,NULL	448	invoke ReadConsole,[cons_in],Dpassword,PASSW_LEN,cparam1,NULL
357	test eax,eax	449	test eax,eax
358	jnz .inp_ok	450	jnz .inp_ok
359	xor ecx,ecx	451	xor ecx,ecx
360	jmp .ex	452	jmp .ex
361	.inp_ok:	453	.inp_ok:
362	mov ecx,[cparam1]	454	mov ecx,[cparam1]
363	cmp ecx,PASSW_LEN	455	cmp ecx,PASSW_LEN
364	je .ex	456	je .ex
365	sub ecx,2	457	sub ecx,2
366	else	458	else
367	end if	459	end if
368	.ex:	460	.ex:
369	ret	461	ret
370		462
371	UKeys:	463	UKeys:
372	; in: al - char	464	; in: al - char
373	pusha	465	pusha
374	mov edi,134775813	466	mov edi,134775813
375	mov ebx,DKeys	467	mov ebx,DKeys
376	mov esi,os_work	468	mov esi,os_work
377	mov byte[esi],al	469	mov byte[esi],al
378	mov ecx,1	470	mov ecx,1
379	push dword[ebx]	471	push dword[ebx]
380	pop [CRC32]	472	pop [CRC32]
381	call UCRC	473	call UCRC
382	push [CRC32]	474	push [CRC32]
383	pop dword[ebx]	475	pop dword[ebx]
384	mov eax,[ebx]	476	mov eax,[ebx]
385	and eax,0xff	477	and eax,0xff
386	add eax,[ebx+4]	478	add eax,[ebx+4]
387	mul edi	479	mul edi
388	inc eax	480	inc eax
389	mov [ebx+4],eax	481	mov [ebx+4],eax
390	shr eax,24	482	shr eax,24
391	mov byte[esi],al	483	mov byte[esi],al
392	push dword[ebx+8]	484	push dword[ebx+8]
393	pop [CRC32]	485	pop [CRC32]
394	call UCRC	486	call UCRC
395	push [CRC32]	487	push [CRC32]
396	pop dword[ebx+8]	488	pop dword[ebx+8]
397	popa	489	popa
398	ret	490	ret
399		491
400	decrypt_byte:	492	decrypt_byte:
401	; out: al	493	; out: al
402	push ebx edx	494	push ebx edx
403	movzx ebx,word[DKeys+8]	495	movzx ebx,word[DKeys+8]
404	or ebx,2	496	or ebx,2
405	mov eax,ebx	497	mov eax,ebx
406	xor eax,1	498	xor eax,1

Subversion Repositories Kolibri OS

(root)/programs/other/archer/trunk/parser.inc – Rev 111 → 131