home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume16 / ecu3 / part22 < prev    next >
Encoding:
Internet Message Format  |  1991-01-06  |  30.2 KB

  1. From: wht@n4hgf.uucp (Warren Tucker)
  2. Newsgroups: comp.sources.misc
  3. Subject: v16i046:  ECU async comm package rev 3.0, Part22/35
  4. Message-ID: <1991Jan6.052511.28426@sparky.IMD.Sterling.COM>
  5. Date: 6 Jan 91 05:25:11 GMT
  6. Approved: kent@sparky.imd.sterling.com
  7. X-Checksum-Snefru: 6becbbd6 68a865c7 07f8e1b3 21e97136
  8.  
  9. Submitted-by: wht@n4hgf.uucp (Warren Tucker)
  10. Posting-number: Volume 16, Issue 46
  11. Archive-name: ecu3/part22
  12.  
  13. ---- Cut Here and feed the following to sh ----
  14. #!/bin/sh
  15. # This is part 22 of ecu3
  16. if touch 2>&1 | fgrep 'amc' > /dev/null
  17.  then TOUCH=touch
  18.  else TOUCH=true
  19. fi
  20. # ============= z/zlint.h ==============
  21. if test ! -d 'z'; then
  22.     echo 'x - creating directory z'
  23.     mkdir 'z'
  24. fi
  25. echo 'x - extracting z/zlint.h (Text)'
  26. sed 's/^X//' << 'SHAR_EOF' > 'z/zlint.h' &&
  27. X/*+-----------------------------------------------------------------------
  28. X    zlint.h
  29. X------------------------------------------------------------------------*/
  30. X/*+:EDITS:*/
  31. X/*:09-06-1990-22:42-afterlint-creation */
  32. X
  33. X#ifndef BUILDING_LINT_ARGS
  34. X#ifdef LINT_ARGS
  35. X
  36. X/* zcommon.c */
  37. Xint get_home_dir(char *);
  38. Xint mode(int );
  39. Xint sendbrk(void );
  40. Xint zmputs(char *);
  41. Xstatic  unsigned int getspeed(int );
  42. Xvoid get_curr_dir(char *,int );
  43. X/* zcurses.c */
  44. Xchar *get_elapsed_time(long );
  45. Xchar *get_tod(int ,char *);
  46. Xchar *mode_map(unsigned short ,char *);
  47. Xint clear_area(struct _win_st *,int ,int ,int );
  48. Xint clear_area_char(struct _win_st *,int ,int ,int ,char );
  49. Xint report_comm_baud_rate(unsigned int );
  50. Xint report_error_count(void );
  51. Xint report_file_byte_io(long );
  52. Xint report_file_open_length(long );
  53. Xint report_file_open_mode(unsigned short );
  54. Xint report_file_rcv_started(char *,long ,long ,unsigned short );
  55. Xint report_protocol_crc_type(char *);
  56. Xint report_protocol_type(char *);
  57. Xint report_rx_tx_count(void );
  58. Xint report_xfer_mode(char *);
  59. Xvoid report_file_close(void );
  60. Xvoid report_file_open_tod(void );
  61. Xvoid report_file_send_open(char *,struct stat *);
  62. Xvoid report_init(char *);
  63. Xvoid report_last_rxhdr(char *,int );
  64. Xvoid report_last_txhdr(char *,int );
  65. Xvoid report_mode(int );
  66. Xvoid report_rx_ind(int );
  67. Xvoid report_rxblklen(int );
  68. Xvoid report_rxpos(long );
  69. Xvoid report_str(char *,int );
  70. Xvoid report_top_line(char *);
  71. Xvoid report_transaction(char *);
  72. Xvoid report_tx_ind(int );
  73. Xvoid report_txblklen(int );
  74. Xvoid report_txpos(long );
  75. Xvoid report_uninit(int );
  76. Xvoid report_window(void );
  77. X/* zdebug.c */
  78. X/* zmodem.c */
  79. Xint noxrd7(void );
  80. Xint stohdr(long );
  81. Xint zdlread(void );
  82. Xint zgeth1(void );
  83. Xint zgethdr(char *,int );
  84. Xint zgethex(void );
  85. Xint zputhex(int );
  86. Xint zrbhdr(char *);
  87. Xint zrbhdr32(char *);
  88. Xint zrdat32(char *,int );
  89. Xint zrdata(char *,int );
  90. Xint zrhhdr(char *);
  91. Xint zsbh32(char *,int );
  92. Xint zsbhdr(int ,unsigned char *);
  93. Xint zsda32(char *,int ,int );
  94. Xint zsdata(unsigned char *,int ,int );
  95. Xint zsendline(int );
  96. Xint zshhdr(int ,unsigned char *);
  97. Xlong rclhdr(char *);
  98. X
  99. X#else        /* compiler doesn't know about prototyping */
  100. X
  101. X/* zcommon.c */
  102. Xstatic  unsigned int getspeed();
  103. Xvoid get_curr_dir();
  104. X/* zcurses.c */
  105. Xchar *get_elapsed_time();
  106. Xchar *get_tod();
  107. Xchar *mode_map();
  108. Xvoid report_file_close();
  109. Xvoid report_file_open_tod();
  110. Xvoid report_file_send_open();
  111. Xvoid report_init();
  112. Xvoid report_last_rxhdr();
  113. Xvoid report_last_txhdr();
  114. Xvoid report_mode();
  115. Xvoid report_rx_ind();
  116. Xvoid report_rxblklen();
  117. Xvoid report_rxpos();
  118. Xvoid report_str();
  119. Xvoid report_top_line();
  120. Xvoid report_transaction();
  121. Xvoid report_tx_ind();
  122. Xvoid report_txblklen();
  123. Xvoid report_txpos();
  124. Xvoid report_uninit();
  125. Xvoid report_window();
  126. X/* zdebug.c */
  127. X/* zmodem.c */
  128. Xlong rclhdr();
  129. X
  130. X#endif /* LINT_ARGS */
  131. X#endif /* BUILDING_LINT_ARGS */
  132. X
  133. X/* end of zlint.h */
  134. SHAR_EOF
  135. $TOUCH -am 0919224990 'z/zlint.h' &&
  136. chmod 0644 z/zlint.h ||
  137. echo 'restore of z/zlint.h failed'
  138. Wc_c="`wc -c < 'z/zlint.h'`"
  139. test 2818 -eq "$Wc_c" ||
  140.     echo 'z/zlint.h: original size 2818, current size' "$Wc_c"
  141. # ============= z/zmodem.c ==============
  142. echo 'x - extracting z/zmodem.c (Text)'
  143. sed 's/^X//' << 'SHAR_EOF' > 'z/zmodem.c' &&
  144. X/*+-------------------------------------------------------------------------
  145. X    zmodem.c - ZMODEM protocol primitives
  146. X    based on code by Chuck Forsberg
  147. X
  148. X  Entry point Functions:
  149. X    zsbhdr(type,hdr) send binary header
  150. X    zshhdr(type,hdr) send hex header
  151. X    zgethdr(hdr,eflag) receive header - binary or hex
  152. X    zsdata(buf,len,frameend) send data
  153. X    zrdata(buf,len) receive data
  154. X    stohdr(pos) store position data in Txhdr
  155. X    long rclhdr(hdr) recover position offset from header
  156. X
  157. X  Defined functions:
  158. X    noxrd7()
  159. X    rclhdr(hdr)
  160. X    stohdr(pos)
  161. X    zdlread()
  162. X    zgeth1()
  163. X    zgethdr(hdr,eflag)
  164. X    zgethex()
  165. X    zputhex(c)
  166. X    zrbhdr(hdr)
  167. X    zrbhdr32(hdr)
  168. X    zrdat32(buf,length)
  169. X    zrdata(buf,length)
  170. X    zrhhdr(hdr)
  171. X    zsbh32(hdr,type)
  172. X    zsbhdr(type,hdr)
  173. X    zsda32(buf,length,frameend)
  174. X    zsdata(buf,length,frameend)
  175. X    zsendline(c)
  176. X    zshhdr(type,hdr)
  177. X
  178. X--------------------------------------------------------------------------*/
  179. X/*+:EDITS:*/
  180. X/*:08-14-1990-20:41-wht@n4hgf-ecu3.00-flush old edit history */
  181. X
  182. X#include "zmodem.h"            /* wht */
  183. X#include "zlint.h"
  184. X
  185. Xextern char s128[];                /* wht */
  186. Xextern int Zctlesc;                /* wht */
  187. Xextern int Zmodem;                /* wht */
  188. Xextern long cr3tab[];            /* wht */
  189. Xextern unsigned Baudrate;        /* wht */
  190. Xextern unsigned short crctab[];    /* wht */
  191. X
  192. Xint Rxtimeout = 100;        /* Tenths of seconds to wait for something */
  193. X
  194. X#if !defined(UNSL)
  195. X#define UNSL
  196. X#endif
  197. X
  198. X
  199. X
  200. Xstatic lastsent;    /* Last char we sent */
  201. Xstatic evenp;        /* Even parity seen on header */
  202. X
  203. X/* Globals used by ZMODEM functions */
  204. Xchar Attn[ZATTNLEN+1];    /* Attention string rx sends to tx on err */
  205. Xchar Rxhdr[4];        /* Received header */
  206. Xchar Txhdr[4];        /* Transmitted header */
  207. Xint Crc32;        /* Display flag indicating 32 bit CRC being received */
  208. Xint Crc32t;        /* Display flag indicating 32 bit CRC being sent */
  209. Xint Rxcount;        /* Count of data bytes received */
  210. Xint Rxframeind;        /* ZBIN ZBIN32,or ZHEX type of frame received */
  211. Xint Rxtimeout;    /* Tenths of seconds to wait for something */
  212. Xint Rxtype;        /* Type of header received */
  213. Xint Txfcs32;        /* TURE means send binary frames with 32 bit FCS */
  214. Xint Zrwindow;    /* RX window size (controls garbage count) */
  215. Xlong Rxpos;    /* Received file position */
  216. Xlong Txpos;    /* Transmitted file position */
  217. X
  218. Xchar *frametypes[] = 
  219. X{
  220. X    "Carrier Lost",        /* -3 */
  221. X    "TIMEOUT",            /* -2 */
  222. X    "ERROR",            /* -1 */
  223. X/* #define FTOFFSET 3 moved to zmodem.h */
  224. X    "ZRQINIT",
  225. X    "ZRINIT",
  226. X    "ZSINIT",
  227. X    "ZACK ",
  228. X    "ZFILE",
  229. X    "ZSKIP",
  230. X    "ZNAK ",
  231. X    "ZABORT",
  232. X    "ZFIN ",
  233. X    "ZRPOS",
  234. X    "ZDATA",
  235. X    "ZEOF ",
  236. X    "ZFERR",
  237. X    "ZCRC ",
  238. X    "ZCHALLENGE",
  239. X    "ZCOMPL",
  240. X    "ZCAN ",
  241. X    "ZFREECNT",
  242. X    "ZCOMMAND",
  243. X    "ZSTDERR",
  244. X    "xxxxx"
  245. X#define FRTYPES 22    /* Total number of frame types in this array */
  246. X    /*  not including psuedo negative entries */
  247. X};
  248. X
  249. Xstatic char masked[] = "8 bit transparent path required";
  250. Xstatic char badcrc[] = "Bad CRC";
  251. X
  252. X/* Send ZMODEM binary header hdr of type type */
  253. Xzsbhdr(type,hdr)
  254. Xregister unsigned char *hdr;
  255. X{
  256. X    register int n;
  257. X    register unsigned crc;
  258. X
  259. X    report_tx_ind(1);
  260. X    sprintf(s128,"hdr %s %ld",frametypes[type+FTOFFSET],rclhdr(hdr));
  261. X    report_last_txhdr(s128,0);
  262. X
  263. X    xsendline(ZPAD); 
  264. X    xsendline(ZDLE);
  265. X
  266. X    if(Crc32t=Txfcs32)
  267. X        zsbh32(hdr,type);
  268. X    else 
  269. X    {
  270. X        xsendline(ZBIN); 
  271. X        zsendline(type); 
  272. X        crc = updcrc(type,0);
  273. X
  274. X        for(n=4; --n >= 0; ++hdr)
  275. X        {
  276. X            zsendline(*hdr);
  277. X            crc = updcrc(*hdr,crc);
  278. X        }
  279. X        crc = updcrc(0,updcrc(0,crc));
  280. X        zsendline(crc>>8);
  281. X        zsendline(crc);
  282. X    }
  283. X    if(type != ZDATA)
  284. X        flushline();
  285. X    report_tx_ind(0);
  286. X}
  287. X
  288. X
  289. X/* Send ZMODEM binary header hdr of type type */
  290. Xzsbh32(hdr,type)
  291. Xregister char *hdr;
  292. X{
  293. X    register int n;
  294. X    register UNSL long crc;
  295. X
  296. X    report_tx_ind(1);
  297. X    xsendline(ZBIN32);  
  298. X    zsendline(type);
  299. X    crc = 0xFFFFFFFFL; 
  300. X    crc = UPDC32(type,crc);
  301. X
  302. X    for(n=4; --n >= 0; ++hdr)
  303. X    {
  304. X        crc = UPDC32((0377 & *hdr),crc);
  305. X        zsendline(*hdr);
  306. X    }
  307. X    crc = ~crc;
  308. X    for(n=4; --n >= 0;)
  309. X    {
  310. X        zsendline((int)crc);
  311. X        crc >>= 8;
  312. X    }
  313. X    report_tx_ind(0);
  314. X}
  315. X
  316. X/* Send ZMODEM HEX header hdr of type type */
  317. Xzshhdr(type,hdr)
  318. Xregister unsigned char *hdr;
  319. X{
  320. X    register int n;
  321. X    register unsigned short crc;
  322. X
  323. X    report_tx_ind(1);
  324. X
  325. X    sprintf(s128,"hdr %s %ld",frametypes[type+FTOFFSET],rclhdr(hdr));
  326. X    report_last_txhdr(s128,0);
  327. X    sendline(ZPAD); 
  328. X    sendline(ZPAD); 
  329. X    sendline(ZDLE); 
  330. X    sendline(ZHEX);
  331. X    zputhex(type);
  332. X    Crc32t = 0;
  333. X
  334. X    crc = updcrc(type,0);
  335. X    for(n=4; --n >= 0; ++hdr)
  336. X    {
  337. X        zputhex(*hdr); 
  338. X        crc = updcrc(*hdr,crc);
  339. X/*        crc = updcrc((0377 & *hdr),crc);  original - wht */
  340. X    }
  341. X    crc = updcrc(0,updcrc(0,crc));
  342. X    zputhex(crc>>8); 
  343. X    zputhex(crc);
  344. X
  345. X    /* Make it printable on remote machine */
  346. X    sendline(015); 
  347. X    sendline(012);
  348. X    /*
  349. X     * Uncork the remote in case a fake XOFF has stopped data flow
  350. X     */
  351. X    if(type != ZFIN && type != ZACK)
  352. X        sendline(021);
  353. X    flushline();
  354. X    report_tx_ind(0);
  355. X}
  356. X
  357. X/*
  358. X * Send binary array buf of length length,with ending ZDLE sequence frameend
  359. X */
  360. Xstatic char *Zendnames[] = { "ZCRCE","ZCRCG","ZCRCQ","ZCRCW"};
  361. X
  362. Xzsdata(buf,length,frameend)
  363. Xregister unsigned char *buf;
  364. X{
  365. X    register unsigned short crc;
  366. X
  367. X    report_tx_ind(1);
  368. X
  369. X    sprintf(s128,"data %s %d bytes",Zendnames[frameend-ZCRCE&3],length);
  370. X    report_last_txhdr(s128,0);
  371. X    if(Crc32t)
  372. X        zsda32(buf,length,frameend);
  373. X    else 
  374. X    {
  375. X        crc = 0;
  376. X        for(;--length >= 0; ++buf)
  377. X        {
  378. X            zsendline(*buf); 
  379. X            crc = updcrc(*buf,crc);
  380. X        }
  381. X        xsendline(ZDLE); 
  382. X        xsendline(frameend);
  383. X        crc = updcrc(frameend,crc);
  384. X
  385. X        crc = updcrc(0,updcrc(0,crc));
  386. X        zsendline(crc>>8); 
  387. X        zsendline(crc);
  388. X    }
  389. X    if(frameend == ZCRCW)
  390. X    {
  391. X        xsendline(XON);  
  392. X        flushline();
  393. X    }
  394. X    report_tx_ind(0);
  395. X
  396. X}
  397. X
  398. Xzsda32(buf,length,frameend)
  399. Xregister char *buf;
  400. X{
  401. X    register int c;
  402. X    register UNSL long crc;
  403. X
  404. X    report_tx_ind(1);
  405. X
  406. X    crc = 0xFFFFFFFFL;
  407. X    for(;--length >= 0; ++buf)
  408. X    {
  409. X        c = *buf & 0377;
  410. X        if(c & 0140)
  411. X            xsendline(lastsent = c);
  412. X        else
  413. X            zsendline(c);
  414. X        crc = UPDC32(c,crc);
  415. X    }
  416. X    xsendline(ZDLE); 
  417. X    xsendline(frameend);
  418. X    crc = UPDC32(frameend,crc);
  419. X
  420. X    crc = ~crc;
  421. X    for(length=4; --length >= 0;)
  422. X    {
  423. X        zsendline((int)crc);  
  424. X        crc >>= 8;
  425. X    }
  426. X    report_tx_ind(0);
  427. X}
  428. X
  429. X/*
  430. X * Receive array buf of max length with ending ZDLE sequence
  431. X *  and CRC.  Returns the ending character or error code.
  432. X *  NB: On errors may store length+1 bytes!
  433. X */
  434. Xzrdata(buf,length)
  435. Xregister char *buf;
  436. X{
  437. X    register int c;
  438. X    register unsigned short crc;
  439. X    register char *end;
  440. X    register int d;
  441. X
  442. X    report_rx_ind(1);
  443. X
  444. X    if(Rxframeind == ZBIN32)
  445. X    {
  446. X        report_rx_ind(0);
  447. X        return(zrdat32(buf,length));
  448. X    }
  449. X
  450. X    crc = Rxcount = 0;  
  451. X    end = buf + length;
  452. X    while(buf <= end)
  453. X    {
  454. X        if((c = zdlread()) & ~0377)
  455. X        {
  456. Xcrcfoo:
  457. X            switch(c)
  458. X            {
  459. X            case GOTCRCE:
  460. X            case GOTCRCG:
  461. X            case GOTCRCQ:
  462. X            case GOTCRCW:
  463. X                crc = updcrc(((d=c)&0377),crc);
  464. X                if((c = zdlread()) & ~0377)
  465. X                    goto crcfoo;
  466. X                crc = updcrc(c,crc);
  467. X                if((c = zdlread()) & ~0377)
  468. X                    goto crcfoo;
  469. X                crc = updcrc(c,crc);
  470. X                if(crc & 0xFFFF)
  471. X                {
  472. X                    report_str(badcrc,0);
  473. X                    report_rx_ind(0);
  474. X                    return(ERROR);
  475. X                }
  476. X                Rxcount = length - (end - buf);
  477. X                report_rxblklen(Rxcount);
  478. X                sprintf(s128,"data %s %d bytes",
  479. X                    Zendnames[d-GOTCRCE&3],Rxcount);
  480. X                report_last_rxhdr(s128,0);
  481. X                report_rx_ind(0);
  482. X                return(d);
  483. X            case GOTCAN:
  484. X                report_str("Sender Cancelled",1);
  485. X                report_rx_ind(0);
  486. X                return(ZCAN);
  487. X            case TIMEOUT:
  488. X                report_str("TIMEOUT",1);
  489. X                report_rx_ind(0);
  490. X                return(c);
  491. X            default:
  492. X                report_str("Bad data subpacket",1);
  493. X                report_rx_ind(0);
  494. X                return(c);
  495. X            }
  496. X        }
  497. X        *buf++ = c;
  498. X        crc = updcrc(c,crc);
  499. X    }
  500. X    report_str("Data subpacket too long",1);
  501. X    report_rx_ind(0);
  502. X    return(ERROR);
  503. X}
  504. X
  505. Xzrdat32(buf,length)
  506. Xregister char *buf;
  507. X{
  508. X    register int c;
  509. X    register UNSL long crc;
  510. X    register char *end;
  511. X    register int d;
  512. X
  513. X    report_rx_ind(1);
  514. X    crc = 0xFFFFFFFFL;  
  515. X    Rxcount = 0;  
  516. X    end = buf + length;
  517. X    while(buf <= end)
  518. X    {
  519. X        if((c = zdlread()) & ~0377)
  520. X        {
  521. Xcrcfoo:
  522. X            switch(c)
  523. X            {
  524. X            case GOTCRCE:
  525. X            case GOTCRCG:
  526. X            case GOTCRCQ:
  527. X            case GOTCRCW:
  528. X                d = c;  
  529. X                c &= 0377;
  530. X                crc = UPDC32(c,crc);
  531. X                if((c = zdlread()) & ~0377)
  532. X                    goto crcfoo;
  533. X                crc = UPDC32(c,crc);
  534. X                if((c = zdlread()) & ~0377)
  535. X                    goto crcfoo;
  536. X                crc = UPDC32(c,crc);
  537. X                if((c = zdlread()) & ~0377)
  538. X                    goto crcfoo;
  539. X                crc = UPDC32(c,crc);
  540. X                if((c = zdlread()) & ~0377)
  541. X                    goto crcfoo;
  542. X                crc = UPDC32(c,crc);
  543. X                if(crc != 0xDEBB20E3)
  544. X                {
  545. X                    report_str(badcrc,0);
  546. X                    report_rx_ind(0);
  547. X                    return(ERROR);
  548. X                }
  549. X                Rxcount = length - (end - buf);
  550. X                report_rxblklen(Rxcount);
  551. X                sprintf(s128,"data %s %d bytes",
  552. X                    Zendnames[d-GOTCRCE&3],Rxcount);
  553. X                report_last_rxhdr(s128,0);
  554. X                report_rx_ind(0);
  555. X                return(d);
  556. X            case GOTCAN:
  557. X                report_str("Sender Canceled",1);
  558. X                report_rx_ind(0);
  559. X                return(ZCAN);
  560. X            case TIMEOUT:
  561. X                report_str("TIMEOUT",1);
  562. X                report_rx_ind(0);
  563. X                return(c);
  564. X            default:
  565. X                report_str("Bad data subpacket",1);
  566. X                report_rx_ind(0);
  567. X                return(c);
  568. X            }
  569. X        }
  570. X        *buf++ = c;
  571. X        crc = UPDC32(c,crc);
  572. X    }
  573. X    report_str("Data subpacket too long",1);
  574. X    report_rx_ind(0);
  575. X    return(ERROR);
  576. X}
  577. X
  578. X
  579. X/*
  580. X * Read a ZMODEM header to hdr,either binary or hex.
  581. X *  eflag controls local display of non zmodem characters:
  582. X *    0:  no display
  583. X *    1:  display printing characters only
  584. X *    2:  display all non ZMODEM characters
  585. X *  On success,set Zmodem to 1,set Rxpos and return type of header.
  586. X *   Otherwise return negative on error.
  587. X *   Return ERROR instantly if ZCRCW sequence,for fast error recovery.
  588. X */
  589. Xzgethdr(hdr,eflag)
  590. Xchar *hdr;
  591. X{
  592. Xregister int c,n,cancount;
  593. X
  594. X    report_rx_ind(1);
  595. X    n = Zrwindow + Baudrate;    /* Max bytes before start of frame */
  596. X    Rxframeind = Rxtype = 0;
  597. X
  598. Xstartover:
  599. X    cancount = 5;
  600. Xagain:
  601. X    /* Return immediate ERROR if ZCRCW sequence seen */
  602. X    switch(c = readline(Rxtimeout))
  603. X    {
  604. X    case RCDO:
  605. X    case TIMEOUT:
  606. X        goto fifi;
  607. X    case CAN:
  608. Xgotcan:
  609. X        if(--cancount <= 0)
  610. X        {
  611. X            c = ZCAN; 
  612. X            goto fifi;
  613. X        }
  614. X        switch(c = readline(1))
  615. X        {
  616. X        case TIMEOUT:
  617. X            goto again;
  618. X        case ZCRCW:
  619. X            c = ERROR;
  620. X            /* **** FALL THRU TO **** */
  621. X        case RCDO:
  622. X            goto fifi;
  623. X        default:
  624. X            break;
  625. X        case CAN:
  626. X            if(--cancount <= 0)
  627. X            {
  628. X                c = ZCAN; 
  629. X                goto fifi;
  630. X            }
  631. X            goto again;
  632. X        }
  633. X        /* **** FALL THRU TO **** */
  634. X    default:
  635. Xagn2:
  636. X        if( --n == 0)
  637. X        {
  638. X            report_str("Garbage count exceeded",1);
  639. X            report_last_rxhdr("Noise",0);
  640. X            report_rx_ind(0);
  641. X            return(ERROR);
  642. X        }
  643. X        goto startover;
  644. X    case ZPAD|0200:        /* This is what we want. */
  645. X    case ZPAD:        /* This is what we want. */
  646. X        evenp = c & 0200;
  647. X        break;
  648. X    }
  649. X    cancount = 5;
  650. Xsplat:
  651. X    switch(c = noxrd7())
  652. X    {
  653. X    case ZPAD:
  654. X        goto splat;
  655. X    case RCDO:
  656. X    case TIMEOUT:
  657. X        goto fifi;
  658. X    default:
  659. X        goto agn2;
  660. X    case ZDLE:        /* This is what we want. */
  661. X        break;
  662. X    }
  663. X
  664. X    switch(c = noxrd7())
  665. X    {
  666. X    case RCDO:
  667. X    case TIMEOUT:
  668. X        goto fifi;
  669. X    case ZBIN:
  670. X        Rxframeind = ZBIN;  
  671. X        Crc32 = FALSE;
  672. X        c =  zrbhdr(hdr);
  673. X        break;
  674. X    case ZBIN32:
  675. X        Crc32 = Rxframeind = ZBIN32;
  676. X        c =  zrbhdr32(hdr);
  677. X        break;
  678. X    case ZHEX:
  679. X        Rxframeind = ZHEX;  
  680. X        Crc32 = FALSE;
  681. X        c =  zrhhdr(hdr);
  682. X        break;
  683. X    case CAN:
  684. X        goto gotcan;
  685. X    default:
  686. X        goto agn2;
  687. X    }
  688. X    Rxpos = hdr[ZP3] & 0377;
  689. X    Rxpos = (Rxpos<<8) + (hdr[ZP2] & 0377);
  690. X    Rxpos = (Rxpos<<8) + (hdr[ZP1] & 0377);
  691. X    Rxpos = (Rxpos<<8) + (hdr[ZP0] & 0377);
  692. Xfifi:
  693. X    switch(c)
  694. X    {
  695. X    case GOTCAN:
  696. X        c = ZCAN;
  697. X        /* **** FALL THRU TO **** */
  698. X    case ZNAK:
  699. X    case ZCAN:
  700. X    case ERROR:
  701. X    case TIMEOUT:
  702. X    case RCDO:
  703. X        sprintf(s128,"Got %s",frametypes[c+FTOFFSET]);
  704. X        report_str(s128,1);
  705. X        /* **** FALL THRU TO **** */
  706. X    default:
  707. X        if(c >= -3 && c <= FRTYPES)
  708. X            sprintf(s128,"hdr %s %ld",frametypes[c+FTOFFSET],Rxpos);
  709. X        else
  710. X            sprintf(s128,"hdr 0x%02x? %ld",c,Rxpos);
  711. X        report_last_rxhdr(s128,0);
  712. X    }
  713. X    report_rx_ind(0);
  714. X    return(c);
  715. X}
  716. X
  717. X/* Receive a binary style header (type and position) */
  718. Xzrbhdr(hdr)
  719. Xregister char *hdr;
  720. X{
  721. X    register int c,n;
  722. X    register unsigned short crc;
  723. X
  724. X    if((c = zdlread()) & ~0377)
  725. X        return(c);
  726. X    Rxtype = c;
  727. X    crc = updcrc(c,0);
  728. X
  729. X    for(n=4; --n >= 0; ++hdr)
  730. X    {
  731. X        if((c = zdlread()) & ~0377)
  732. X            return(c);
  733. X        crc = updcrc(c,crc);
  734. X        *hdr = c;
  735. X    }
  736. X    if((c = zdlread()) & ~0377)
  737. X        return(c);
  738. X    crc = updcrc(c,crc);
  739. X    if((c = zdlread()) & ~0377)
  740. X        return(c);
  741. X    crc = updcrc(c,crc);
  742. X    if(crc & 0xFFFF)
  743. X    {
  744. X        if(evenp)
  745. X            report_str(masked,1);
  746. X        report_str(badcrc,0);
  747. X        return(ERROR);
  748. X    }
  749. X#if defined(ZMODEM)
  750. X    Protocol = ZMODEM;
  751. X#endif
  752. X    Zmodem = 1;
  753. X    return(Rxtype);
  754. X}
  755. X
  756. X/* Receive a binary style header (type and position) with 32 bit FCS */
  757. Xzrbhdr32(hdr)
  758. Xregister char *hdr;
  759. X{
  760. X    register int c,n;
  761. X    register UNSL long crc;
  762. X
  763. X    if((c = zdlread()) & ~0377)
  764. X        return(c);
  765. X    Rxtype = c;
  766. X    crc = 0xFFFFFFFFL; 
  767. X    crc = UPDC32(c,crc);
  768. X
  769. X    for(n=4; --n >= 0; ++hdr)
  770. X    {
  771. X        if((c = zdlread()) & ~0377)
  772. X            return(c);
  773. X        crc = UPDC32(c,crc);
  774. X        *hdr = c;
  775. X    }
  776. X    for(n=4; --n >= 0;)
  777. X    {
  778. X        if((c = zdlread()) & ~0377)
  779. X            return(c);
  780. X        crc = UPDC32(c,crc);
  781. X    }
  782. X    if(crc != 0xDEBB20E3)
  783. X    {
  784. X        if(evenp)
  785. X            report_str(masked,1);
  786. X        report_str(badcrc,0);
  787. X        return(ERROR);
  788. X    }
  789. X#if defined(ZMODEM)
  790. X    Protocol = ZMODEM;
  791. X#endif
  792. X    Zmodem = 1;
  793. X    return(Rxtype);
  794. X}
  795. X
  796. X
  797. X/* Receive a hex style header (type and position) */
  798. Xzrhhdr(hdr)
  799. Xchar *hdr;
  800. X{
  801. X    register int c;
  802. X    register unsigned short crc;
  803. X    register int n;
  804. X
  805. X    if((c = zgethex()) < 0)
  806. X        return(c);
  807. X    Rxtype = c;
  808. X    crc = updcrc(c,0);
  809. X
  810. X    for(n=4; --n >= 0; ++hdr)
  811. X    {
  812. X        if((c = zgethex()) < 0)
  813. X            return(c);
  814. X        crc = updcrc(c,crc);
  815. X        *hdr = c;
  816. X    }
  817. X    if((c = zgethex()) < 0)
  818. X        return(c);
  819. X    crc = updcrc(c,crc);
  820. X    if((c = zgethex()) < 0)
  821. X        return(c);
  822. X    crc = updcrc(c,crc);
  823. X    if(crc & 0xFFFF)
  824. X    {
  825. X        report_str(badcrc,0); 
  826. X        return(ERROR);
  827. X    }
  828. X    if(readline(1) == '\r')    /* Throw away possible cr/lf */
  829. X        readline(1);
  830. X#if defined(ZMODEM)
  831. X    Protocol = ZMODEM;
  832. X#endif
  833. X    Zmodem = 1; 
  834. X    return(Rxtype);
  835. X}
  836. X
  837. X/* Send a byte as two hex digits */
  838. Xzputhex(c)
  839. Xregister int c;
  840. X{
  841. X    static char digits[]    = "0123456789abcdef";
  842. X
  843. X    sendline(digits[(c&0xF0)>>4]);
  844. X    sendline(digits[(c)&0xF]);
  845. X}
  846. X
  847. X/*
  848. X * Send character c with ZMODEM escape sequence encoding.
  849. X *  Escape XON,XOFF. Escape CR following @ (Telenet net escape)
  850. X */
  851. Xzsendline(c)
  852. X{
  853. X
  854. X    /* Quick check for non control characters */
  855. X    if(c & 0140)
  856. X        xsendline(lastsent = c);
  857. X    else 
  858. X    {
  859. X        switch(c &= 0377)
  860. X        {
  861. X        case ZDLE:
  862. X            xsendline(ZDLE);
  863. X            xsendline(lastsent = (c ^= 0100));
  864. X            break;
  865. X        case 015:
  866. X        case 0215:
  867. X            if(!Zctlesc && (lastsent & 0177) != '@')
  868. X                goto sendit;
  869. X            /* **** FALL THRU TO **** */
  870. X        case 020:
  871. X        case 021:
  872. X        case 023:
  873. X        case 0220:
  874. X        case 0221:
  875. X        case 0223:
  876. X            xsendline(ZDLE);
  877. X            c ^= 0100;
  878. Xsendit:
  879. X            xsendline(lastsent = c);
  880. X            break;
  881. X        default:
  882. X            if(Zctlesc && ! (c & 0140))
  883. X            {
  884. X                xsendline(ZDLE);
  885. X                c ^= 0100;
  886. X            }
  887. X            xsendline(lastsent = c);
  888. X        }
  889. X    }
  890. X}
  891. X
  892. X/* Decode two lower case hex digits into an 8 bit byte value */
  893. Xzgethex()
  894. X{
  895. X    register int c;
  896. X
  897. X    c = zgeth1();
  898. X    return(c);
  899. X}
  900. Xzgeth1()
  901. X{
  902. X    register int c,n;
  903. X
  904. X    if((c = noxrd7()) < 0)
  905. X        return(c);
  906. X    n = c - '0';
  907. X    if(n > 9)
  908. X        n -= ('a' - ':');
  909. X    if(n & ~0xF)
  910. X        return(ERROR);
  911. X    if((c = noxrd7()) < 0)
  912. X        return(c);
  913. X    c -= '0';
  914. X    if(c > 9)
  915. X        c -= ('a' - ':');
  916. X    if(c & ~0xF)
  917. X        return(ERROR);
  918. X    c += (n<<4);
  919. X    return(c);
  920. X}
  921. X
  922. X/*
  923. X * Read a byte,checking for ZMODEM escape encoding
  924. X *  including CAN*5 which represents a quick abort
  925. X */
  926. Xzdlread()
  927. X{
  928. X    register int c;
  929. X
  930. Xagain:
  931. X    /* Quick check for non control characters */
  932. X    if((c = readline(Rxtimeout)) & 0140)
  933. X        return(c);
  934. X    switch(c)
  935. X    {
  936. X    case ZDLE:
  937. X        break;
  938. X    case 023:
  939. X    case 0223:
  940. X    case 021:
  941. X    case 0221:
  942. X        goto again;
  943. X    default:
  944. X        if(Zctlesc && !(c & 0140))
  945. X        {
  946. X            goto again;
  947. X        }
  948. X        return(c);
  949. X    }
  950. Xagain2:
  951. X    if((c = readline(Rxtimeout)) < 0)
  952. X        return(c);
  953. X    if(c == CAN && (c = readline(Rxtimeout)) < 0)
  954. X        return(c);
  955. X    if(c == CAN && (c = readline(Rxtimeout)) < 0)
  956. X        return(c);
  957. X    if(c == CAN && (c = readline(Rxtimeout)) < 0)
  958. X        return(c);
  959. X    switch(c)
  960. X    {
  961. X    case CAN:
  962. X        return(GOTCAN);
  963. X    case ZCRCE:
  964. X    case ZCRCG:
  965. X    case ZCRCQ:
  966. X    case ZCRCW:
  967. X        return(c | GOTOR);
  968. X    case ZRUB0:
  969. X        return(0177);
  970. X    case ZRUB1:
  971. X        return(0377);
  972. X    case 023:
  973. X    case 0223:
  974. X    case 021:
  975. X    case 0221:
  976. X        goto again2;
  977. X    default:
  978. X        if(Zctlesc && ! (c & 0140))
  979. X        {
  980. X            goto again2;
  981. X        }
  982. X        if((c & 0140) ==  0100)
  983. X            return(c ^ 0100);
  984. X        break;
  985. X    }
  986. X    sprintf(s128,"Bad escape sequence %x",c);
  987. X    report_str(s128,1);
  988. X    return(ERROR);
  989. X}
  990. X
  991. X/*
  992. X * Read a character from the modem line with timeout.
  993. X *  Eat parity,XON and XOFF characters.
  994. X */
  995. Xnoxrd7()
  996. X{
  997. X    register int c;
  998. X
  999. X    for(;;)
  1000. X    {
  1001. X        if((c = readline(Rxtimeout)) < 0)
  1002. X            return(c);
  1003. X        switch(c &= 0177)
  1004. X        {
  1005. X        case XON:
  1006. X        case XOFF:
  1007. X            continue;
  1008. X        default:
  1009. X            if(Zctlesc && !(c & 0140))
  1010. X                continue;
  1011. X        case '\r':
  1012. X        case '\n':
  1013. X        case ZDLE:
  1014. X            return(c);
  1015. X        }
  1016. X    }
  1017. X}
  1018. X
  1019. X/* Store long integer pos in Txhdr */
  1020. Xstohdr(pos)
  1021. Xlong pos;
  1022. X{
  1023. X    Txhdr[ZP0] = pos;
  1024. X    Txhdr[ZP1] = pos>>8;
  1025. X    Txhdr[ZP2] = pos>>16;
  1026. X    Txhdr[ZP3] = pos>>24;
  1027. X}
  1028. X
  1029. X/* Recover a long integer from a header */
  1030. Xlong
  1031. Xrclhdr(hdr)
  1032. Xregister char *hdr;
  1033. X{
  1034. X    register long l;
  1035. X
  1036. X    l = (hdr[ZP3] & 0377);
  1037. X    l = (l << 8) | (hdr[ZP2] & 0377);
  1038. X    l = (l << 8) | (hdr[ZP1] & 0377);
  1039. X    l = (l << 8) | (hdr[ZP0] & 0377);
  1040. X    return(l);
  1041. X}
  1042. X
  1043. X/* end of zmodem.c */
  1044. X/* vi: set tabstop=4 shiftwidth=4: */
  1045. SHAR_EOF
  1046. $TOUCH -am 0814204290 'z/zmodem.c' &&
  1047. chmod 0644 z/zmodem.c ||
  1048. echo 'restore of z/zmodem.c failed'
  1049. Wc_c="`wc -c < 'z/zmodem.c'`"
  1050. test 16442 -eq "$Wc_c" ||
  1051.     echo 'z/zmodem.c: original size 16442, current size' "$Wc_c"
  1052. # ============= z/zmodem.h ==============
  1053. echo 'x - extracting z/zmodem.h (Text)'
  1054. sed 's/^X//' << 'SHAR_EOF' > 'z/zmodem.h' &&
  1055. X/*+-------------------------------------------------------------------------
  1056. X    zmodem.h -- common include filefor ecurz/ecusz
  1057. X--------------------------------------------------------------------------*/
  1058. X/*+:EDITS:*/
  1059. X/*:08-14-1990-20:41-wht@n4hgf-ecu3.00-flush old edit history */
  1060. X
  1061. X#if defined(pyr)
  1062. X#include <sys/types.h>
  1063. X#include <sys/stat.h>
  1064. X#include <sgtty.h>
  1065. X#define OS "BSD4.x"
  1066. X#if defined(LLITOUT)
  1067. X#include <strings.h>
  1068. X#endif
  1069. X#endif
  1070. X
  1071. X#if defined(M_UNIX)
  1072. X#define OS "UNIX"
  1073. X#undef M_XENIX
  1074. X#endif
  1075. X
  1076. X#if !defined(OS)
  1077. X#if !defined(M_XENIX)
  1078. X#define XENIX
  1079. X#endif
  1080. X#endif
  1081. X
  1082. X#if defined(M_XENIX) || defined(M_UNIX)
  1083. X#include <sys/types.h>
  1084. X#include <sys/stat.h>
  1085. X#include <termio.h>
  1086. X#include <sys/ioctl.h>
  1087. X#include <string.h>
  1088. X#define MODE2OK
  1089. X#endif
  1090. X
  1091. X#if defined(pyr)
  1092. X#if defined(TIOCSBRK)
  1093. X#define CANBREAK
  1094. X#endif
  1095. X#endif
  1096. X#if defined(M_XENIX) || defined(M_UNIX)
  1097. X#define CANBREAK
  1098. X#endif
  1099. X
  1100. X#if !defined(READCHECK)
  1101. X#if defined(FIONREAD)
  1102. X#define READCHECK
  1103. X#endif
  1104. X#if defined(SV)
  1105. X#define READCHECK
  1106. X#endif
  1107. X#endif
  1108. X
  1109. X#define ACK 6
  1110. X#define CAN ('X'&037)
  1111. X#define CPMEOF 032
  1112. X#define ENQ 005
  1113. X#define EOT 4
  1114. X#define ERROR (-1)
  1115. X#define ERRORMAX 5
  1116. X#define FALSE 0
  1117. X#define NAK 025
  1118. X#define OK 0
  1119. X#define PATHLEN 257    /* ready for 4.2 bsd ? */
  1120. X#define RCDO (-3)
  1121. X#define SOH 1
  1122. X#define STX 2
  1123. X#define TIMEOUT (-2)
  1124. X#define TRUE 1
  1125. X#define UNIXFILE 0xF000    /* The S_IFMT file mask bit for stat */
  1126. X#define WANTCRC 0103    /* send C not NAK to get crc not checksum */
  1127. X
  1128. X#define WANTG 0107    /* Send G not NAK to get nonstop batch xmsn */
  1129. X#define WCEOT (-10)
  1130. X#define XOFF ('s'&037)
  1131. X#define XON ('q'&037)
  1132. X
  1133. X/*
  1134. X * updcrc macro derived from article Copyright (C) 1986 Stephen Satchell. 
  1135. X *  NOTE: First argument must be in range 0 to 255.
  1136. X *        Second argument is referenced twice.
  1137. X * 
  1138. X * Programmers may incorporate any or all code into their programs, 
  1139. X * giving proper credit within the source. Publication of the 
  1140. X * source routines is permitted so long as proper credit is given 
  1141. X * to Stephen Satchell, Satchell Evaluations and Chuck Forsberg, 
  1142. X * Omen Technology.
  1143. X */
  1144. X
  1145. X#define updcrc(cp, crc) ( crctab[((crc >> 8) & 255)] ^ (crc << 8) ^ (cp))
  1146. X#define UPDC32(b, c) (cr3tab[((int)c ^ b) & 0xff] ^ ((c >> 8) & 0x00FFFFFF))
  1147. X
  1148. X
  1149. X#define ZPAD '*'    /* 052 Padding character begins frames */
  1150. X#define ZDLE 030    /* Ctrl-X Zmodem escape - `ala BISYNC DLE */
  1151. X#define ZDLEE (ZDLE^0100)    /* Escaped ZDLE as transmitted */
  1152. X#define ZBIN 'A'    /* Binary frame indicator */
  1153. X#define ZHEX 'B'    /* HEX frame indicator */
  1154. X#define ZBIN32 'C'    /* Binary frame with 32 bit FCS */
  1155. X
  1156. X/* Frame types (see array "frametypes" in zm.c) */
  1157. X#define ZRQINIT    0    /* Request receive init */
  1158. X#define ZRINIT    1    /* Receive init */
  1159. X#define ZSINIT 2    /* Send init sequence (optional) */
  1160. X#define ZACK 3        /* ACK to above */
  1161. X#define ZFILE 4        /* File name from sender */
  1162. X#define ZSKIP 5        /* To sender: skip this file */
  1163. X#define ZNAK 6        /* Last packet was garbled */
  1164. X#define ZABORT 7    /* Abort batch transfers */
  1165. X#define ZFIN 8        /* Finish session */
  1166. X#define ZRPOS 9        /* Resume data trans at this position */
  1167. X#define ZDATA 10    /* Data packet(s) follow */
  1168. X#define ZEOF 11        /* End of file */
  1169. X#define ZFERR 12    /* Fatal Read or Write error Detected */
  1170. X#define ZCRC 13        /* Request for file CRC and response */
  1171. X#define ZCHALLENGE 14    /* Receiver's Challenge */
  1172. X#define ZCOMPL 15    /* Request is complete */
  1173. X#define ZCAN 16        /* Other end canned session with CAN*5 */
  1174. X#define ZFREECNT 17    /* Request for free bytes on filesystem */
  1175. X#define ZCOMMAND 18    /* Command from sending program */
  1176. X#define ZSTDERR 19    /* Output to standard error, data follows */
  1177. X
  1178. X/* ZDLE sequences */
  1179. X#define ZCRCE 'h'    /* CRC next, frame ends, header packet follows */
  1180. X#define ZCRCG 'i'    /* CRC next, frame continues nonstop */
  1181. X#define ZCRCQ 'j'    /* CRC next, frame continues, ZACK expected */
  1182. X#define ZCRCW 'k'    /* CRC next, ZACK expected, end of frame */
  1183. X#define ZRUB0 'l'    /* Translate to rubout 0177 */
  1184. X#define ZRUB1 'm'    /* Translate to rubout 0377 */
  1185. X
  1186. X/* zdlread return values (internal) */
  1187. X/* -1 is general error, -2 is timeout */
  1188. X#define GOTOR 0400
  1189. X#define GOTCRCE (ZCRCE|GOTOR)    /* ZDLE-ZCRCE received */
  1190. X#define GOTCRCG (ZCRCG|GOTOR)    /* ZDLE-ZCRCG received */
  1191. X#define GOTCRCQ (ZCRCQ|GOTOR)    /* ZDLE-ZCRCQ received */
  1192. X#define GOTCRCW (ZCRCW|GOTOR)    /* ZDLE-ZCRCW received */
  1193. X#define GOTCAN    (GOTOR|030)    /* CAN*5 seen */
  1194. X
  1195. X/* Byte positions within header array */
  1196. X#define ZF0    3    /* First flags byte */
  1197. X#define ZF1    2
  1198. X#define ZF2    1
  1199. X#define ZF3    0
  1200. X#define ZP0    0    /* Low order 8 bits of position */
  1201. X#define ZP1    1
  1202. X#define ZP2    2
  1203. X#define ZP3    3    /* High order 8 bits of file position */
  1204. X
  1205. X/* Bit Masks for ZRINIT flags byte ZF0 */
  1206. X#define CANFDX    01    /* Rx can send and receive true FDX */
  1207. X#define CANOVIO    02    /* Rx can receive data during disk I/O */
  1208. X#define CANBRK    04    /* Rx can send a break signal */
  1209. X#define CANCRY    010    /* Receiver can decrypt */
  1210. X#define CANLZW    020    /* Receiver can uncompress */
  1211. X#define CANFC32    040    /* Receiver can use 32 bit Frame Check */
  1212. X#define ESCCTL 0100    /* Receiver expects ctl chars to be escaped */
  1213. X#define ESC8   0200    /* Receiver expects 8th bit to be escaped */
  1214. X
  1215. X/* Parameters for ZSINIT frame */
  1216. X#define ZATTNLEN 32    /* Max length of attention string */
  1217. X/* Bit Masks for ZSINIT flags byte ZF0 */
  1218. X#define TESCCTL 0100    /* Transmitter expects ctl chars to be escaped */
  1219. X#define TESC8   0200    /* Transmitter expects 8th bit to be escaped */
  1220. X
  1221. X/* Parameters for ZFILE frame */
  1222. X/* Conversion options one of these in ZF0 */
  1223. X#define ZCBIN    1    /* Binary transfer - inhibit conversion */
  1224. X#define ZCNL    2    /* Convert NL to local end of line convention */
  1225. X#define ZCRESUM    3    /* Resume interrupted file transfer */
  1226. X/* Management include options, one of these ored in ZF1 */
  1227. X#define ZMSKNOLOC    0200    /* Skip file if not present at rx */
  1228. X/* Management options, one of these ored in ZF1 */
  1229. X#define ZMMASK    037    /* Mask for the choices below */
  1230. X#define ZMNEWL    1    /* Transfer if source newer or longer */
  1231. X#define ZMCRC    2    /* Transfer if different file CRC or length */
  1232. X#define ZMAPND    3    /* Append contents to existing file (if any) */
  1233. X#define ZMCLOB    4    /* Replace existing file */
  1234. X#define ZMNEW    5    /* Transfer if source newer */
  1235. X    /* Number 5 is alive ... */
  1236. X#define ZMDIFF    6    /* Transfer if dates or lengths different */
  1237. X#define ZMPROT    7    /* Protect destination file */
  1238. X/* Transport options, one of these in ZF2 */
  1239. X#define ZTLZW    1    /* Lempel-Ziv compression */
  1240. X#define ZTCRYPT    2    /* Encryption */
  1241. X#define ZTRLE    3    /* Run Length encoding */
  1242. X/* Extended options for ZF3, bit encoded */
  1243. X#define ZXSPARS    64    /* Encoding for sparse file operations */
  1244. X
  1245. X/* Parameters for ZCOMMAND frame ZF0 (otherwise 0) */
  1246. X#define ZCACK1    1    /* Acknowledge, then do command */
  1247. X
  1248. X/* FTOFFSET is offset for frametypes array in ecuzm.c */
  1249. X#define FTOFFSET 3
  1250. X
  1251. Xlong rclhdr();
  1252. X
  1253. X#include "zlint.h"
  1254. X/* vi: set tabstop=4 shiftwidth=4: */
  1255. SHAR_EOF
  1256. $TOUCH -am 0919224990 'z/zmodem.h' &&
  1257. chmod 0644 z/zmodem.h ||
  1258. echo 'restore of z/zmodem.h failed'
  1259. Wc_c="`wc -c < 'z/zmodem.h'`"
  1260. test 6728 -eq "$Wc_c" ||
  1261.     echo 'z/zmodem.h: original size 6728, current size' "$Wc_c"
  1262. # ============= sea/Makefile ==============
  1263. if test ! -d 'sea'; then
  1264.     echo 'x - creating directory sea'
  1265.     mkdir 'sea'
  1266. fi
  1267. echo 'x - extracting sea/Makefile (Text)'
  1268. sed 's/^X//' << 'SHAR_EOF' > 'sea/Makefile' &&
  1269. X#  CHK=0x8F7A
  1270. X#+----------------------------------------------------------
  1271. X# Makefile for ecusea
  1272. X#-----------------------------------------------------------
  1273. X#+:EDITS:*/
  1274. X#:05-07-1990-21:21-wht@n4hgf-omit fcrc usage in release makes
  1275. X#:01-03-1990-15:30-wht-quit using -Ox --- Oi screws up too much
  1276. X#:11-23-1989-02:37-wht-start support for UNIX V/386
  1277. X#:11-19-1989-00:21-wht-model mismatch on 286 fixed
  1278. X#:10-11-1989-18:46-wht-needed more work to get makes to work away from my system
  1279. X#:07-03-1989-22:58-wht------ x2.00 -----
  1280. X
  1281. XCFLAGS = -i -K -DLINT_ARGS `sysdep =M_I386 -DM_TERMCAP -Oactl =M_I286 -M2 -O`
  1282. XLFLAGS = -lx -ltcap -ltermlib
  1283. X
  1284. XSRC = \
  1285. X    ecusea.c\
  1286. X    scurses.c
  1287. X
  1288. XOBJ = \
  1289. X    ecusea.o\
  1290. X    scurses.o
  1291. X
  1292. Xecusea: $(OBJ) Makefile
  1293. X    cc $(CFLAGS) $(OBJ) $(LFLAGS) -o ecusea
  1294. X
  1295. Xecusea.fls: $(SRC)
  1296. X    ls $(SRC) >ecusea.fls
  1297. X
  1298. Xlint: lint_args.h
  1299. X
  1300. Xlint_args.h : ecusea.fls
  1301. X    echo > lint_args.h
  1302. X    csh ../zgcc ecusea.fls lint_args.h $(CFLAGS)
  1303. X
  1304. SHAR_EOF
  1305. $TOUCH -am 0817114990 'sea/Makefile' &&
  1306. chmod 0644 sea/Makefile ||
  1307. echo 'restore of sea/Makefile failed'
  1308. Wc_c="`wc -c < 'sea/Makefile'`"
  1309. test 913 -eq "$Wc_c" ||
  1310.     echo 'sea/Makefile: original size 913, current size' "$Wc_c"
  1311. true || echo 'restore of sea/ecusea.c failed'
  1312. echo End of part 22, continue with part 23
  1313. exit 0
  1314. --------------------------------------------------------------------
  1315. Warren Tucker, TuckerWare emory!n4hgf!wht or wht@n4hgf.Mt-Park.GA.US
  1316. Hacker Extraordinaire  d' async PADs,  pods,  proteins and protocols
  1317.  
  1318. exit 0 # Just in case...
  1319. -- 
  1320. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  1321. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  1322. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  1323. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  1324.