home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / archives / krt11.zip / krtrec.min < prev    next >
Text File  |  1997-10-17  |  8KB  |  555 lines
  1.     .title    KRTREC.MIN  Receive file processing
  2.     .ident    "V03.62"
  3.  
  4. ; /62/    31-May-93  Billy Youdelman
  5.  
  6. ;    Copyright 1983,1984  Change Software, Inc.
  7. ;
  8. ;    This software is furnished under a license and may
  9. ;    be  used  and  copied  only in accordance with the
  10. ;    terms of such license and with  the  inclusion  of
  11. ;    the  above copyright notice.  This software or any
  12. ;    other copies thereof may not be provided or other-
  13. ;    wise made available to any other person.  No title
  14. ;    to and ownership of the software is hereby  trans-
  15. ;    ferred.
  16. ;
  17. ;    The information in this  software  is  subject  to
  18. ;    change  without notice and should not be construed
  19. ;    as a commitment by the author.
  20.  
  21.     .include "IN:KRTMAC.MIN"
  22.     .iif ndf  KRTINC  .error    <; .include for IN:KRTMAC.MIN failed>
  23.     .include "IN:KRTDEF.MIN"
  24.     .iif ndf  MSG$DA  .error    <; .include for IN:KRTDEF.MIN failed>
  25.  
  26.     .mcall    .PURGE
  27.  
  28.  
  29.     .sbttl    Local data
  30.  
  31.     .psect    $pdata
  32. RD22$:    .byte    abt$cur    ,0
  33. RE2$:    .asciz    "REC.SW"
  34.     .even
  35.  
  36.  
  37.     .psect    $code
  38.     .sbttl    Receive file(s)
  39.  
  40. c$rec::    call    opentt
  41.     tst    outopn
  42.     beq    10$
  43.     calls    close    ,<#lun.ou>
  44. 10$:    calls    recsw    ,<#sta.rin>
  45.     tst    r0
  46.     beq    100$
  47.     inc    status
  48. 100$:    call    clostt
  49.     jmp    clrcns
  50.  
  51.  
  52.     .sbttl    State controller for receive file processing
  53.     .enabl    lsb
  54.  
  55. recsw::    clr    paknum
  56. rec.sw::movb    @r5    ,state
  57.     mov    $image    ,image
  58.     movb    #defchk    ,chktyp
  59.     mov    #1    ,chksiz
  60.     clr    numtry
  61.     clr    outopn
  62.     call    rechdr
  63.     movb    rectim    ,senpar+p.time
  64.  
  65. 10$:    call    recdeb
  66.     scan    state    ,#200$
  67.     asl    r0
  68.     jsr    pc    ,@210$(r0)
  69.     bcc    10$
  70.  
  71. 100$:    movb    #defchk    ,chktyp
  72.     mov    #1    ,chksiz
  73.     save    <r0>
  74.     tst    outopn
  75.     bpl    110$
  76.     calls    close    ,<#lun.ou>
  77. 110$:    clr    outopn
  78.     .purge    #lun.sr
  79.     unsave    <r0>
  80.     return
  81.  
  82.     .save
  83.     .psect    $pdata
  84. 200$:    .byte    sta.abo    ,sta.com,sta.dat,sta.fil,sta.rin
  85.     .byte    0
  86.     .even
  87. 210$:    .word    recs.$
  88.     .word    recs$$    ,recs.c    ,recs.d    ,recs.f    ,recs.r
  89.     .restore
  90.  
  91.     .dsabl    lsb
  92.  
  93.  
  94.     .sbttl    State routines for RECSW
  95.     .enabl    lsb
  96.  
  97. recs$$:    tst    outopn
  98.     bge    80$
  99.     mov    incfile    ,skipfile
  100. 80$:    mov    sp    ,r0
  101.     br    90$
  102.  
  103. recs.$:    call    recx.$
  104.     br    100$
  105.  
  106. recs.c:    clr    r0
  107. 90$:    sec
  108.     return
  109.  
  110. recs.d:    call    rdata
  111.     br    100$
  112.  
  113. recs.f:    call    rfile
  114.     br    100$
  115.  
  116. recs.r:    call    rinit
  117. 100$:    movb    r1    ,state
  118.     clc
  119.     return
  120.  
  121.     .dsabl    lsb
  122.  
  123.  
  124.     .sbttl    Received bad ACK/NAK and error handling
  125.  
  126. recx.e:
  127. r$sync:
  128. r$retry:
  129. rabort:    movb    #sta.abo,r1
  130.     return
  131.  
  132. recx$$:    spack    #msg$nak,paknum
  133.     br    deja$$
  134. deja$vu:spack    #msg$ack,r3
  135. recx.$:
  136. deja$$:    movb    state    ,r1
  137.     return
  138.  
  139.  
  140.     .sbttl    Receive debugging and logging
  141.  
  142. recdeb:    bit    #log$pa    ,trace
  143.     beq    50$
  144.     save    <r1,r2>
  145.     sub    #100.    ,sp
  146.     mov    sp    ,r1
  147.     mov    #RE2$    ,r2
  148.     call    paksta
  149.     sub    sp    ,r1
  150.     mov    sp    ,r2
  151.     calls    putrec    ,<r2,r1,#lun.lo>
  152.     tst    r0
  153.     beq    30$
  154.     call    logerr
  155. 30$:    add    #100.    ,sp
  156.     unsave    <r2,r1>
  157. 50$:    return
  158.  
  159.  
  160.     .sbttl    Receive file initialization
  161.     .enabl    lsb
  162.  
  163. rinit:    inc    numtry
  164.     cmp    numtry    ,initry
  165.     blos    10$
  166.      jmp    r$retry
  167.  
  168. 10$:    rpack    r2 ,r3    ,#packet,#maxlng
  169.     scan    r1    ,#200$
  170.     asl    r0
  171.     jmp    @210$(r0)
  172.  
  173.     .save
  174.     .psect    $pdata
  175. 200$:    .byte    msg$err    ,msg$snd,timout    ,badchk
  176.     .byte    0
  177.     .even
  178. 210$:    .word    recx.$
  179.     .word    recx.e    ,rini.s    ,recx$$    ,recx$$
  180.     .restore
  181.  
  182.     .dsabl    lsb
  183.  
  184.  
  185.     .sbttl    Process response to RINIT
  186.  
  187. rini.s:    calls    rpar    ,<#packet,r2>
  188.     calls    spar    ,<#packet>
  189.     spack    #msg$ack,paknum,sparsz,#packet
  190.     clr    numtry
  191.     incm64    paknum
  192.     movb    #sta.fil,r1
  193.     jmp    inirepeat
  194.  
  195.  
  196.     .sbttl    Receive file header
  197.     .enabl    lsb
  198.  
  199. rfile:    inc    numtry
  200.     cmp    numtry    ,maxtry
  201.     blos    5$
  202.      jmp    r$retry
  203.  
  204. 5$:    call    clratr
  205.     movb    conpar+p.chkt,chktyp
  206.     movb    chktyp    ,chksiz
  207.     sub    #'0    ,chksiz
  208.     mov    $image    ,image
  209.     tst    xgottn
  210.     beq    10$
  211.     movb    #sta.typ,r1
  212.     br    20$
  213. 10$:    rpack    r2 ,r3    ,#packet,#maxlng
  214. 20$:    scan    r1    ,#200$
  215.     asl    r0
  216.     jmp    @210$(r0)
  217.  
  218.     .save
  219.     .psect    $pdata
  220. 200$:    .byte    msg$bre    ,msg$err,msg$fil,msg$snd,msg$tex,msg$eof
  221.     .byte    timout    ,badchk
  222.     .byte    0
  223.     .even
  224. 210$:    .word    recx.$
  225.     .word    rfil.b    ,recx.e    ,rfil.f    ,rfil.s    ,rfil.x    ,rfil.z
  226.     .word    recx$$    ,recx$$
  227.     .restore
  228.  
  229.     .dsabl    lsb
  230.  
  231.  
  232.     .sbttl    Process response to RFILE
  233.  
  234. rfil.b:    cmp    r3    ,paknum
  235.     beq    10$
  236.      jmp    r$sync
  237.  
  238. 10$:    spack    #msg$ack,paknum
  239.     movb    #sta.com,r1
  240.     return
  241.  
  242.  
  243.     .sbttl    Receive file name
  244.  
  245. rfil.f:    cmp    r3    ,paknum
  246.     beq    10$
  247.      jmp    r$sync
  248.  
  249. 10$:    calls    bufunp    ,<#packet,#spare1>
  250.     calls    namcvt    ,<#spare1,#packet>
  251.     calls    fixfil    ,<#packet,#srcnam>
  252.     mov    #asname    ,r1
  253.     tstb    (r1)
  254.     bne    15$
  255.     mov    #srcnam    ,r1
  256.  
  257. 15$:    upcase    r1
  258.     calls    fparse    ,<r1,#filnam>
  259.     clrb    asname
  260.     tst    r0
  261.     bne    100$
  262.     tst    outopn
  263.     bpl    20$
  264.     calls    close    ,<#lun.ou>
  265. 20$:    clr    outopn
  266.     spack    #msg$ack,paknum
  267.     clr    numtry
  268.     incm64    paknum
  269.     movb    #sta.dat,r1
  270.     return
  271.  
  272. 100$:    calls    syserr    ,<r0,#errtxt>
  273.     calls    error    ,<#3,#errtxt,#aspace,r1>
  274.     jmp    rabort
  275.  
  276.  
  277. rfil.s:    inc    numtry
  278.     cmp    numtry    ,maxtry
  279.     blos    10$
  280.      jmp    r$retry
  281.  
  282. 10$:    mov    paknum    ,r1
  283.     dec    r1
  284.     bge    11$
  285.     mov    #63    ,r1
  286. 11$:    cmp    r3    ,r1
  287.     bne    20$
  288.      calls    spar    ,<#packet>
  289.      spack    #msg$ack,r3,sparsz,#packet
  290.      jmp    deja$$
  291.  
  292. 20$:     jmp    r$sync
  293.  
  294.  
  295. rfil.x:    jmp    rabort
  296.  
  297.  
  298. rfil.z:    inc    numtry
  299.     cmp    numtry    ,maxtry
  300.     blos    10$
  301.      jmp    r$retry
  302.  
  303. 10$:    mov    paknum    ,r1
  304.     dec    r1
  305.     bge    11$
  306.     mov    #63    ,r1
  307. 11$:    cmp    r3    ,r1
  308.     bne    20$
  309.      jmp    deja$vu
  310.  
  311. 20$:     jmp    r$retry
  312.  
  313.  
  314.     .sbttl    Receive file data
  315.     .enabl    lsb
  316.  
  317. rdata:    inc    numtry
  318.     cmp    numtry    ,maxtry
  319.     blos    10$
  320.      jmp    r$retry
  321.  
  322. 10$:    rpack    r2 ,r3  ,#packet,#maxlng
  323.     scan    r1    ,#200$
  324.     asl    r0
  325.     jmp    @210$(r0)
  326.  
  327.     .save
  328.     .psect    $pdata
  329. 200$:    .byte    msg$atr    ,msg$dat,msg$err,msg$fil,msg$tex,msg$eof
  330.     .byte    timout    ,badchk
  331.     .byte    0
  332.     .even
  333. 210$:    .word    recx.$
  334.     .word    rdat.a    ,rdat.d    ,recx.e    ,rdat.f    ,rdat.x    ,rdat.z
  335.     .word    recx$$    ,recx$$
  336.     .restore
  337.  
  338.     .dsabl    lsb
  339.  
  340.     .sbttl    Process response to RDATA
  341.  
  342. rdat.a:    cmp    r3    ,paknum
  343.     beq    40$
  344.     inc    numtry
  345.     cmp    numtry    ,maxtry
  346.     blos    20$
  347.      jmp    r$retry
  348.  
  349. 20$:    mov    paknum    ,r1
  350.     dec    r1
  351.     bge    21$
  352.     mov    #63    ,r1
  353. 21$:    cmp    r3    ,r1
  354.     bne    30$
  355.      jmp    deja$vu
  356.  
  357. 30$:     jmp    rabort
  358.  
  359. 40$:    calls    r$attr    ,<#packet>
  360.     tst    r0
  361.     bne    30$
  362.     spack    #msg$ack,paknum
  363.     clr    numtry
  364.     incm64    paknum
  365.     movb    state    ,r1
  366.     return
  367.  
  368.  
  369. rdat.d:    tst    xmode
  370.     bne    1$
  371.     tst    outopn
  372.     bne    1$
  373.     tst    filprot
  374.     beq    2$
  375.     clr    index
  376.     calls    lookup,<#filnam,#srcnam>
  377.     tst    r0
  378.     bne    2$
  379.     .purge    #lun.sr
  380.     spack    #msg$ack,paknum,#1,#RD22$
  381.     incm64    paknum
  382.     clr    numtry
  383.     mov    #1    ,outopn
  384.     movb    #sta.dat,r1
  385.     return
  386.  
  387. 1$:    br    10$
  388.  
  389. 2$:    mov    #filnam    ,r4
  390.     calls    create    ,<r4,#lun.ou,image>
  391.     mov    #lun.ou    ,outlun
  392.     tst    r0
  393.     beq    5$
  394.     calls    syserr    ,<r0,#errtxt>
  395.     calls    error    ,<#3,#errtxt,#aspace,r4>
  396.     jmp    rabort
  397.  
  398. 5$:    mov    #-1    ,outopn
  399.  
  400. 10$:    cmp    r3    ,paknum
  401.     beq    40$
  402.     inc    numtry
  403.     cmp    numtry    ,maxtry
  404.     blos    20$
  405.      jmp    r$retry
  406.  
  407. 20$:    mov    paknum    ,r1
  408.     dec    r1
  409.     bge    21$
  410.     mov    #63    ,r1
  411. 21$:    cmp    r3    ,r1
  412.     bne    30$
  413.      jmp    deja$vu
  414.  
  415. 30$:     jmp    r$sync
  416.  
  417. 40$:    add    r2    ,charin+2
  418.     adc    charin+0
  419.     calls    bufemp    ,<#packet,r2>
  420.     tst    r0
  421.     beq    70$
  422.     calls    syserr    ,<r0,#errtxt>
  423.     calls    error    ,<#1,#errtxt>
  424.     jmp    100$
  425.  
  426. 70$:    spack    #msg$ack,paknum
  427. 80$:    clr    numtry
  428.     incm64    paknum
  429.     movb    #sta.dat,r1
  430.     return
  431.  
  432. 100$:    mov    #sta.abo,r1
  433.     return
  434.  
  435.  
  436. rdat.f:
  437. rdat.x:    inc    numtry
  438.     cmp    numtry    ,maxtry
  439.     blos    10$
  440.      jmp    r$retry
  441.  
  442. 10$:    mov    paknum    ,r1
  443.     dec    r1
  444.     bge    11$
  445.     mov    #63    ,r1
  446. 11$:    cmp    r3    ,r1
  447.     bne    20$
  448.      jmp    deja$vu
  449.  
  450. 20$:     jmp    r$sync
  451.  
  452.  
  453. rdat.z:    cmp    paknum    ,r3
  454.     beq    10$
  455.      jmp    r$sync
  456.  
  457. 10$:    mov    #lun.ou    ,r2
  458.     tst    outopn
  459.     beq    18$
  460.     bgt    30$
  461.  
  462.     cmpb    #eof$dis,packet
  463.     bne    20$
  464.     mov    incfile    ,skipfile
  465.     br    20$
  466.  
  467. 18$:    clr    r2
  468. 20$:    calls    close    ,<r2>
  469. 30$:    call    clratr
  470.     clr    outopn
  471.     spack    #msg$ack,r3
  472.     clr    numtry
  473.     incm64    paknum
  474.     movb    #sta.fil,r1
  475.     clr    xgottn
  476.     return
  477.  
  478.  
  479.     .sbttl    Dump a buffer out to disk
  480.  
  481. bufemp:    mov    @r5    ,r2
  482.     mov    2(r5)    ,r3
  483.     clr    r0
  484.  
  485. 10$:    tst    r3
  486.     ble    100$
  487. 20$:    clr    r0
  488.     bisb    (r2)+    ,r0
  489.     dec    r3
  490.  
  491.     mov    #1    ,r4
  492.     tst    dorpt
  493.     beq    30$
  494.     cmpb    r0    ,rptquo
  495.     bne    30$
  496.     dec    r3
  497.     clr    r4
  498.     bisb    (r2)+    ,r4
  499.     bic    #^c177    ,r4
  500.     unchar    r4    ,r4
  501.     clr    r0
  502.     bisb    (r2)+    ,r0
  503.     dec    r3
  504.     tst    r4
  505.     bgt    30$
  506.     mov    #1    ,r4
  507.  
  508. 30$:    clr    set8bit
  509.     tst    do8bit
  510.     beq    60$
  511.     cmpb    r0    ,ebquot
  512.     bne    60$
  513.     mov    sp    ,set8bit
  514.     clr    r0
  515.     bisb    (r2)+    ,r0
  516.     dec    r3
  517.  
  518. 60$:    cmpb    r0    ,conpar+p.qctl
  519.     bne    70$
  520.     clr    r0
  521.     bisb    (r2)+    ,r0
  522.     dec    r3
  523.     clr    r1
  524.     bisb    r0    ,r1
  525.     bic    #^c177    ,r1
  526.     cmpb    r1    ,conpar+p.qctl
  527.     beq    70$
  528.     cmpb    r1    ,#77
  529.     blo    70$
  530.     cmpb    r1    ,#137
  531.     bhi    70$
  532.     ctl    r0    ,r0
  533.  
  534. 70$:    tst    set8bit
  535.     beq    74$
  536.     bisb    #200    ,r0
  537. 74$:    mov    r0    ,-(sp)
  538. 75$:    mov    #lun.ou    ,r1
  539.     tst    outopn
  540.     bne    80$
  541.     clr    r1
  542. 80$:    mov    @sp    ,r0
  543.     call    putcr0
  544.     tst    r0
  545.     bne    100$
  546.     add    #1    ,filein+2
  547.     adc    filein+0
  548.     sob    r4    ,75$
  549.     tst    (sp)+
  550.     br    10$
  551.  
  552. 100$:    return
  553.  
  554.     .end
  555.