开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet客户端 > 查看源码
xtb+.c
资源名称：xt-1.2-src.tar.gz　[点击查看]
上传用户：duobangkj
上传日期：2007-01-07
资源大小：70k
文件大小：25k
源码类别：

Telnet客户端

开发平台：

Unix_Linux

xtb+.c：源码内容
  1. /* xtb+.c -- CIS B+ Protocol module for XT
  2. This file uses 4-character tabstops
  3.  */
  5. #include <stdio.h>
  6. #include <string.h>
  7. #include <sys/types.h>
  8. #include <sys/stat.h>
  9. #include <signal.h>
  10. #include <fcntl.h>
  11. #include <ctype.h>
  12. #define NOREDEF 1 /* prevents xt.h from redefining fprint, fputc, fputs */
  13. #include "xt.h"
  15. #define min(x,y) ((int)(x)<(int)(y)?(x):(y))
  16. #define max(x,y) ((int)(x)>(int)(y)?(x):(y))
  17. #define MaskLowRange 0x01
  18. #define MaskHiRange 0x10
  19. #define Send_Ahead_Buffers 5
  20. #define ETX 0x3 /* ^C */
  21. #define DLE 0x10 /* ^P */
  22. #define XON 0x11 /* ^Q */
  23. #define XOFF 0x13 /* ^S */
  24. #define NAK   0x15 /* ^U */
  26. enum {
  27. Check_B,
  28. Check_CRC
  29. } ;
  31. enum {
  32. Quote_Default,
  33. Quote_Not_NULL,
  34. Quote_Extended,
  35. Quote_Full,
  36. Quote_Mask
  37. } ;
  39. enum {
  40. Overwrite,
  41. Resume
  42. } ;
  44. enum {
  45. Resume_Allowed,
  46. Resume_Not_Allowed,
  47. Resume_Failed,
  48. Resume_Denied
  49. } ;
  51. typedef enum {
  52. S_Get_DLE,
  53. S_DLE_Seen,
  54. S_DLE_B_Seen,
  55. S_Get_Data,
  56. S_Get_check,
  57. S_Get_CRC,
  58. S_Verify_CRC,
  59. S_Verify_CKS,
  60. S_Verify_Packet,
  61. S_Send_NAK,
  62. S_Send_ACK,
  63. S_Send_ENQ,
  64. S_Resend_Packets
  65. } Sender_Action;
  67. #define LOC_BUF 2064
  68. extern short cr_add;
  69. extern void cl_line();
  70. static char S_Buffer[LOC_BUF], R_Buffer[LOC_BUF], O_Buffer[2 * LOC_BUF],
  71. tdir[32];
  72. char Name[SM_BUFF];
  73. static unchar Mask[32];
  74. static unsigned Checksum;
  75. static int Ch, /* last char read from remote */
  76. Quoting, /* quoting level requested by the user */
  77. Window_Size, /* Send size of send ahead window */
  78. Packet_Size, /* Maximum block size. */
  79. R_Buffer_Len, O_Buffer_Len, Seq_Num, Pending_Count,
  80. Next_Packet, Packets_Btwn_ACKs, Last_ACK, textmode, Last_Chr,
  81. Send_Errors, Read_Errors;
  82. static short Max_Errors=10, Abort_Flag, Not_Masked, Sent_ENQ, Actual_Check,
  83. Valid_To_Resume_Download, Valid_To_Resume_Upload,
  84. Send_File_Information, Packet_Received, Result;
  85. static long already_have, data, total_read, total_sent,
  86. fsize, carriage_return;
  87. static time_t start;
  88. static FILE *Data_File;
  90. struct {
  91. int Seq;
  92. int Packet_Size;
  93. char *packet;
  94. } Pending[Send_Ahead_Buffers];
  96. /* crc_xmodem_tab calculated by Mark G. Mendel, Network Systems Corporation */
  97. ushort crc_xmodem_tab[256] = {
  98.  0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
  99.  0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
  100.  0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
  101.  0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
  102.  0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
  103.  0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
  104.  0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
  105.  0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
  106.  0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
  107.  0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
  108.  0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
  109.  0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
  110.  0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
  111.  0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
  112.  0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
  113.  0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
  114.  0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
  115.  0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
  116.  0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
  117.  0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
  118.  0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
  119.  0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
  120.  0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
  121.  0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
  122.  0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
  123.  0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
  124.  0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
  125.  0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
  126.  0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
  127.  0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
  128.  0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
  129.  0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
  130. };
  132. static void
  133. init_check()
  134. {
  135. Checksum=Actual_Check ? 0xffff : 0;
  136. }
  138. static void
  139. do_checksum(ch)
  140. unsigned ch;
  141. {
  142. if (Actual_Check==Check_B){
  143. Checksum<<=1;
  144. if (Checksum>255)
  145. Checksum=(Checksum&0xff)+1;
  146. Checksum+=ch&0xFF;
  147. if (Checksum>255)
  148. Checksum=(Checksum&0xff)+1;
  149. } else
  150. Checksum=(crc_xmodem_tab[((Checksum>>8)^ch)&0xff]^(Checksum<<8))&0xffff;
  151. }
  153. /* #define CIS_DEBUG*/ /* for B+ logging */
  155. #ifdef CIS_DEBUG
  156. static FILE *bfp;
  157. static void
  158. xtlog(dir, val)
  159. char dir;
  160. int val;
  161. {
  162. static int cnt, lastdir;
  164. if (!bfp)
  165. bfp=fopen("xtb+log","w"),
  166. cnt=0,
  167. lastdir=dir;
  169. if (++cnt>20||lastdir!=dir)
  170. fputc('n',bfp),
  171. cnt=1;
  173. if (lastdir!=dir)
  174. fputc('n',bfp);
  176. if (val>'~'||val<' ')
  177. fprintf(bfp,"%c%1x%1x ",dir,val/16,val%16);
  178. else
  179. fprintf(bfp,"%c%c  ",dir,val);
  181. lastdir=dir;
  182. }
  184. static void
  185. Why_NAK(reason)
  186. char *reason;
  187. {
  188. sprintf(Msg,"Sending NAK, %s",reason);
  189. S0(Msg);
  190. }
  192. #else
  193. #define xtlog(dir,val)
  194. #define Why_NAK(reason)
  195. #endif
  197. static void
  198. stats(count)
  199. int count;
  200. {
  201. int rate, minutes, sec, data_percent;
  202. long chars, rem;
  203. time_t elapsed, now;
  205. data+=count;
  207. if (!fsize)
  208. data_percent=0;
  209. else
  210. data_percent=100*(data+carriage_return)/fsize;
  212. if (data_percent>100)
  213. data_percent=100;
  215. now=mtime();
  216. elapsed=now-start;
  218. chars=data+carriage_return-already_have-(tdir[0]=='T'?Packet_Size:0);
  219. if (elapsed<1000 || !chars)
  220. ttgoto(LI-6,26),
  221. fputs("estimating",tfp);
  222. else
  223. rate=100*chars/elapsed,
  224. rate*=10,
  225. rem=(fsize-(data+carriage_return-already_have))/rate,
  226. minutes=rem/60,
  227. sec=rem%60,
  229. ttgoto(LI-6,26),
  230. fprintf(tfp,"%8.1d:%2.2d",minutes,sec),
  232. elapsed/=1000,
  233. minutes=elapsed/60,
  234. sec=elapsed%60,
  235. ttgoto(LI-6,61),
  236. fprintf(tfp,"%8.1d:%2.2d",minutes,sec),
  238. ttgoto(LI-4,23),
  239. fprintf(tfp,"Rate: %d characters per second ", rate);
  241. ttgoto(LI-8,0),
  242. fprintf(tfp,"%8.1ld",total_sent),
  243. ttgoto(LI-8,20),
  244. fprintf(tfp,"%8.1ld",total_read),
  245. ttgoto(LI-8,40);
  246. if (!data_percent)
  247. fprintf(tfp,"%8.1ld",data);
  248. else
  249. fprintf(tfp,"%8.1ld %3.1u %%",data,data_percent);
  250. if (carriage_return)
  251. ttgoto(LI-8,60),
  252. fprintf(tfp,"%+7.1ld",carriage_return);
  253. }
  255. static void
  256. showmode()
  257. {
  258. int l;
  260. sprintf(Msg,"%s %s (%ld bytes) as %s",tdir,Name,fsize,
  261. textmode?"ASCII":"BINARY");
  263. ttgoto(LI-12,0);
  264. cl_line();
  265. if ((l=strlen(Msg)) < CO)
  266. ttgoto(LI-12,(CO-l)/2 -1);
  267. fputs(Msg,tfp);
  269. start=mtime();
  270. }
  272. static void
  273. Discard_ACKed_Packets()
  274. {
  275. int i, n;
  276. short Packet_Acked=FALSE;
  278. Last_ACK=Ch;
  279. n=(Next_Packet+Pending_Count)%Send_Ahead_Buffers;
  281. for (i=Pending_Count;i>0;i--){
  282. n--;
  283. if (n<0)
  284. n+=5;
  286. if (Pending[n].Seq==Ch-'0')
  287. Packet_Acked=TRUE,
  288. Next_Packet=(n+1)%Send_Ahead_Buffers;
  290. if (Packet_Acked==TRUE)
  291. free(Pending[n].packet),
  292. Pending[n].packet=NIL(char),
  293. Pending_Count--;
  294. }
  295. }
  297. static void
  298. Send_Byte(ch)
  299. int ch;
  300. {
  301. sendbyte(ch);
  302. total_sent++;
  303. xtlog('>',ch);
  304. }
  306. static void
  307. Add_Masked_Byte(ch)
  308. int ch;
  309. {
  310. if (ch<0x20 &&
  311. (Quoting==Quote_Full||(Mask[ch]&MaskLowRange)))
  312. O_Buffer[O_Buffer_Len++]=(char) DLE,
  313. ch+='@';
  314. else if (ch>=0x80 && ch<0xA0 &&
  315. (Quoting==Quote_Full||(Mask[ch-0x80]&MaskHiRange)))
  316. O_Buffer[O_Buffer_Len++]=(char) DLE,
  317. ch=ch+'`'-0x80;
  318. else if (ch==0xff)
  319. O_Buffer[O_Buffer_Len++]=(char) ch;
  321. O_Buffer[O_Buffer_Len++]=(char) ch;
  322. }
  324. static
  325. Read_Byte()
  326. {
  327. if ((Ch=readbyte(10))== -1)
  328. return FAILURE;
  329. total_read++;
  330. xtlog('<',Ch);
  331. return SUCCESS;
  332. }
  334. static
  335. Read_Masked_Byte()
  336. {
  337. Not_Masked=TRUE;
  339. if (!Read_Byte())
  340. return FAILURE;
  342. if (Ch==DLE){
  343. if (!Read_Byte())
  344. return FAILURE;
  346. Not_Masked=FALSE;
  348. if (Ch>='`')
  349. Ch+=0x80;
  351. Ch&=0x9F;
  352. }
  354. if (Ch==0xff)
  355. if (!Read_Byte())
  356. return FAILURE;
  358. return SUCCESS;
  359. }
  361. static void
  362. Send_ACK()
  363. {
  364. Send_Byte(DLE);
  365. Send_Byte(Seq_Num+'0');
  366. }
  368. static void
  369. Init()
  370. {
  371. int i;
  373. R_Buffer_Len=Window_Size=Pending_Count=Next_Packet=
  374. Seq_Num=Packets_Btwn_ACKs=Last_ACK=0;
  376. Packet_Size=LG_BUFF;
  377. Quoting=Quote_Mask;
  379. for (i=0;i<Send_Ahead_Buffers;i++)
  380. Pending[i].packet=NIL(char);
  382. Actual_Check=Check_B;
  383. Abort_Flag=Sent_ENQ=FALSE;
  385. memset(Mask,0,32);
  387. Mask[ETX]=Mask[ENQ]=Mask[DLE]=Mask[NAK]=Mask[XON]=Mask[XOFF]=MaskLowRange;
  389. total_sent=total_read=data=fsize=Read_Errors=Send_Errors=
  390. already_have=carriage_return=0;
  391. fputs("nnnnnnnnnnnnnnn",tfp);
  392. ttgoto(LI-14,25);
  393. S1("CIS B-Plus Protocol Transfer");
  395. ttgoto(LI-10,0);
  396. fputs("B+ Bytes Sent       B+ Bytes Rcvd",tfp);
  397. ttgoto(LI-10,40);
  398. fputs("Data Bytes          Carriage Returns",tfp);
  399. ttgoto(LI-6,10);
  400. fputs("Time Remaining:",tfp);
  401. ttgoto(LI-6,48);
  402. fputs("Elapsed Time:",tfp);
  403. }
  405. static void
  406. Xmit_Packet(Size, Seq, Packet)
  407. int Size, Seq;
  408. unchar *Packet;
  409. {
  410. register int I;
  412. init_check();
  413. O_Buffer_Len=0;
  414. O_Buffer[O_Buffer_Len++]=(char) DLE;
  415. O_Buffer[O_Buffer_Len++]=(char) 'B';
  416. O_Buffer[O_Buffer_Len++]=(char) Seq+'0';
  417. do_checksum(Seq+'0');
  419. for (I=0;I<Size;I++)
  420. Add_Masked_Byte(Packet[I]),
  421. do_checksum(Packet[I]);
  423. O_Buffer[O_Buffer_Len++]=(char) ETX;
  424. do_checksum(ETX);
  425. if (Actual_Check==Check_B)
  426. Add_Masked_Byte(Checksum);
  427. else
  428. Add_Masked_Byte(Checksum>>8),
  429. Add_Masked_Byte(Checksum&0xff);
  431. send_string(O_Buffer, O_Buffer_Len);
  432. total_sent += O_Buffer_Len;
  433. for (I=0;I<O_Buffer_Len;I++)
  434. xtlog('>',O_Buffer[I]&0xff);
  435. }
  437. static
  438. Wait_For_ACK(Have_DLE_B, Acknowledge, Resend)
  439. short Have_DLE_B, Acknowledge, Resend;
  440. {
  441. Sender_Action Action;
  443. int i=0, n, RCV_Num, Errors=0;
  445. R_Buffer_Len=0;
  446. Packet_Received=FALSE;
  448. if (Have_DLE_B)
  449. Action=S_DLE_B_Seen;
  450. else
  451. Action=S_Get_DLE;
  453. while (Errors<Max_Errors)
  454. switch (Action){
  455. case S_Get_Data:
  456. if (Read_Masked_Byte()==FAILURE){
  457. Action=S_Send_NAK;
  458. Why_NAK("couldn't read next data byte");
  459. } else if (Not_Masked && Ch==ETX)
  460. Action=S_Get_check;
  461. else if (Not_Masked && Ch==ENQ)
  462. Action=S_Send_ACK;
  463. else if (i>Packet_Size){
  464. Action=S_Send_NAK;
  465. Why_NAK("incoming buffer overflow");
  466. } else
  467. R_Buffer[i++]=Ch,
  468. do_checksum(Ch);
  469. break;
  471. case S_Get_DLE:
  472. if (Packets_Btwn_ACKs>Window_Size+2&&Pending_Count){
  473. Packets_Btwn_ACKs=0;
  474. Action=S_Send_ENQ;
  475. continue;
  476. }
  477. if (!Read_Byte())
  478. Action=S_Send_ENQ;
  479. else if (Ch==DLE)
  480. Action=S_DLE_Seen;
  481. else if (Ch==NAK)
  482. Action=S_Send_ENQ;
  483. else if (Ch==ENQ)
  484. Action=S_Send_ACK;
  485. else if (Ch==ETX){
  486. Action=S_Send_NAK;
  487. Why_NAK("awaiting DLE, got ETX");
  488. }
  489. break;
  491. case S_DLE_Seen:
  492. if (!Read_Byte())
  493. Action=S_Send_ENQ;
  494. else if (Ch>='0'&&Ch<='9')
  495. if (Sent_ENQ&&Ch==Last_ACK){
  496. Sent_ENQ=FALSE;
  498. if (!Pending_Count)
  499. return SUCCESS;
  500. else
  501. Action=S_Resend_Packets;
  502. } else {
  503. Discard_ACKed_Packets();
  504. if (Sent_ENQ)
  505. Action=S_Get_DLE;
  506. else
  507. return SUCCESS;
  508. }
  509. else if (Ch==';')
  510. Action=S_Get_DLE;
  511. else if (Ch=='B')
  512. Action=S_DLE_B_Seen;
  513. else if (Ch==ENQ)
  514. Action=S_Send_ACK;
  515. else
  516. Action=S_Get_DLE;
  517. break;
  519. case S_DLE_B_Seen:
  520. if (!Read_Byte()){
  521. Action=S_Send_NAK;
  522. Why_NAK("no data byte after DLE-B");
  523. } else if (Ch==ENQ)
  524. Action=S_Send_ACK;
  525. else {
  526. init_check();
  527. RCV_Num=Ch-'0';
  528. do_checksum(Ch);
  529. i=0;
  530. Action=S_Get_Data;
  531. }
  532. break;
  534. case S_Get_check:
  535. do_checksum(ETX);
  537. if (Read_Masked_Byte()==FAILURE){
  538. Action=S_Send_NAK;
  539. Why_NAK("no incoming checksum");
  540. } else if (Not_Masked&&Ch==ENQ)
  541. Action=S_Send_ACK;
  542. else if (Actual_Check==Check_CRC)
  543. Action=S_Get_CRC;
  544. else
  545. Action=S_Verify_CKS;
  546. break;
  548. case S_Get_CRC:
  549. do_checksum(Ch);
  551. if (Read_Masked_Byte()==FAILURE){
  552. Action=S_Send_NAK;
  553. Why_NAK("no incoming CRC value");
  554. } else if (Not_Masked&&Ch==ENQ)
  555. Action=S_Send_ACK;
  556. else
  557. Action=S_Verify_CRC;
  558. break;
  560. case S_Verify_CRC:
  561. do_checksum(Ch);
  563. if (!Checksum)
  564. Action=S_Verify_Packet;
  565. else {
  566. Action=S_Send_NAK;
  567. Why_NAK("CRC error");
  568. }
  569. break;
  571. case S_Verify_CKS:
  572. if (Checksum==Ch)
  573. Action=S_Verify_Packet;
  574. else {
  575. Action=S_Send_NAK;
  576. Why_NAK("Checksum error");
  577. }
  578. break;
  580. case S_Verify_Packet:
  581. if (RCV_Num==((Seq_Num+1)%10)||R_Buffer[0]=='F'){
  582. Packets_Btwn_ACKs++;
  583. Seq_Num=RCV_Num;
  584. if (Acknowledge)
  585. Send_ACK();
  586. R_Buffer_Len=i;
  587. Packet_Received=TRUE;
  588. return FAILURE;
  589. } else if (RCV_Num==Seq_Num)
  590. Action=S_Send_ACK;
  591. else {
  592. Action=S_Send_NAK;
  593. Why_NAK("packet out of sequence");
  594. }
  595. break;
  597. case S_Send_NAK:
  598. ttgoto(LI-2,20);
  599. sprintf(Msg,"Read Errors: %2.1d",++Read_Errors);
  600. S;
  601. Errors++;
  602. Send_Byte(NAK);
  603. Action=S_Get_DLE;
  604. break;
  606. case S_Send_ACK:
  607. Send_ACK();
  608. Action=S_Get_DLE;
  609. break;
  611. case S_Send_ENQ:
  612. ttgoto(LI-2,40);
  613. sprintf(Msg,"Send Errors: %2.1d",++Send_Errors);
  614. S;
  615. Errors++;
  616. Sent_ENQ=TRUE;
  617. Send_Byte(ENQ);
  618. Send_Byte(ENQ);
  619. Action=S_Get_DLE;
  620. break;
  622. case S_Resend_Packets:
  623. if (Resend)
  624. for (i=0;i<Pending_Count;i++)
  625. n=(Next_Packet+i)%Send_Ahead_Buffers,
  626. Xmit_Packet(
  627. Pending[n].Packet_Size,
  628. Pending[n].Seq,
  629. Pending[n].packet);
  630. else
  631. return FAILURE;
  633. Action=S_Get_DLE;
  634. break;
  635. }
  636. return FAILURE;
  637. }
  639. static void
  640. Send_Failure(Code, Text)
  641. char Code;
  642. char *Text;
  643. {
  644. int Len, Seq;
  646. S_Buffer[0]='F';
  647. S_Buffer[1]=Code;
  648. Len=2;
  649. while (*Text)
  650. S_Buffer[Len++]= *Text++;
  652. Seq=(Seq_Num+1)%10;
  654. while (Pending_Count&&Wait_For_ACK(FALSE,FALSE,FALSE))
  655. ;
  657. Xmit_Packet(Len,Seq,S_Buffer);
  659. do
  660. Wait_For_ACK(FALSE,FALSE,FALSE);
  661. while (Packet_Received);
  662. }
  664. static
  665. Flush_Pending()
  666. {
  667. while (Pending_Count)
  668. if (!Wait_For_ACK(FALSE,TRUE,TRUE))
  669. return FAILURE;
  671. return SUCCESS;
  672. }
  674. static void
  675. Send_Abort()
  676. {
  677. fclose(Data_File);
  678. sprintf(Msg,"Transfer abort requested");
  679. S0(Msg);
  680. Send_Failure('A',Msg);
  681. }
  683. static
  684. Send_Packet(Size)
  685. int Size;
  686. {
  687. int Next, Next_Seq;
  688. char *ptr = S_Buffer;
  690. while ((Pending_Count>Window_Size))
  691. if (!Wait_For_ACK(FALSE,TRUE,TRUE)){
  692. Send_Abort();
  693. return FAILURE;
  694. }
  696. Next=(Next_Packet+Pending_Count)%Send_Ahead_Buffers;
  697. Pending_Count++;
  699. Next_Seq=Seq_Num=(Seq_Num+1)%10;
  700. Pending[Next].Seq=Next_Seq;
  701. Pending[Next].packet=(char *) malloc(Size);
  702. memcpy(Pending[Next].packet,ptr,Size);
  703. Pending[Next].Packet_Size=Size;
  704. Packets_Btwn_ACKs=0;
  706. Xmit_Packet(Size,Next_Seq,S_Buffer);
  708. return SUCCESS;
  709. }
  711. static ulong
  712. cnvAtoL(ptr)
  713. char *ptr;
  714. {
  715. ushort sign=FALSE;
  716. char ch;
  717. ulong result=0;
  719. ch= *ptr++;
  721. if (ch=='-')
  722. sign=TRUE,
  723. ch= *ptr++;
  725. while (ch>='0'&&ch<='9')
  726. result=result*10+(ch-'0'),
  727. ch= *ptr++;
  729. return(sign?-result:result);
  730. }
  732. static
  733. char *cnvLtoA(ptr, n)
  734. char *ptr;
  735. ulong n;
  736. {
  737. char tmp1[11], *tmp2=tmp1;
  739. if (!n){
  740. *ptr++ ='0';
  741. return ptr;
  742. }
  744. *tmp2++ =0;
  745. do 
  746. *tmp2++ =((char)(n%10))+'0',
  747. n/=10;
  748. while (n>0);
  750. tmp2--;
  751. while (*tmp2)
  752. *ptr++ = *tmp2--;
  754. return ptr;
  755. }
  757. static void
  758. Send_Unexpected_Packet()
  759. {
  760. sprintf(Msg,"Unexpected packet type");
  761. S0(Msg);
  762. Send_Failure('N',Msg);
  763. }
  765. FILE *
  766. QueryCreate(Offer_Resume)
  767. short Offer_Resume;
  768. {
  769. int key;
  770. short Condition;
  771. FILE *fileptr;
  773. Condition = isregfile(Name) ? Offer_Resume : Resume_Denied;
  775. if (access(Name,0)&&(fileptr=fopen(Name,"w"))){
  776. Result=Overwrite;
  777. return fileptr;
  778. } else if (access(Name,2))
  779. Condition = Resume_Denied;
  781. switch(Condition){
  782. case Resume_Allowed:
  783. sprintf(Msg,"'%s' exists; Overwrite, Resume, reName, or Abort?",Name);
  784. break;
  786. case Resume_Not_Allowed:
  787. sprintf(Msg,"'%s' exists; Overwrite, reName, or Abort?",Name);
  788. break;
  790. case Resume_Failed:
  791. sprintf(Msg,"'%s' CRC error; Overwrite, reName or Abort?",Name);
  792. break;
  794. case Resume_Denied:
  795. sprintf(Msg,"Permission denied for '%s'; reName, or Abort?",Name);
  796. break;
  797. }
  798. if (cismode)
  799. S0(Msg);
  800. else
  801. S2(Msg);
  803. for (;;){
  804. beep();
  805. key=toupper(fgetc(stdin));
  806. if (isupper(key)){
  807. fputc(key,tfp);
  809. switch(key){
  810. case 'O':
  811. if (Condition!=Resume_Denied){
  812. Result=Overwrite;
  813. return fopen(Name,"w");
  814. }
  815. break;
  817. case 'N':
  818. fputc('r',tfp);
  819. cl_line();
  820. show(-1,"Enter New Name:");
  821. getline();
  822. getword();
  823. strcpy(Name,word);
  824. return QueryCreate(Offer_Resume);
  826. case 'A':
  827. return NIL(FILE);
  829. case 'R':
  830. if (Condition==Resume_Allowed){
  831. Result=Resume;
  832. return fopen(Name,"r+");
  833. }
  834. break;
  835. }
  836. fputc('b',tfp);
  837. }
  838. }
  839. }
  841. static
  842. Read(fp, buf, want)
  843. FILE *fp;
  844. char *buf;
  845. register int want;
  846. {
  847. register int c;
  848. int read=0;
  850. while (want--)
  851. switch(c=getc(fp)){
  852. case EOF:
  853. return read;
  855. case 'n':
  856. if (cr_add&&textmode&&Last_Chr!='r')
  857. ungetc(c,fp),
  858. carriage_return++,
  859. c='r';
  861. default:
  862. Last_Chr= *buf++ =c;
  863. read++;
  864. }
  866. return read;
  867. }
  869. static
  870. Write(fp, buf, want)
  871. FILE *fp;
  872. char *buf;
  873. register int want;
  874. {
  875. int written=0;
  877. for (;want-->0;buf++){
  878. if (textmode){
  879. if (*buf=='r'){
  880. Last_Chr= *buf;
  881. continue;
  882. }
  883. if (Last_Chr=='r')
  884. if (*buf=='n')
  885. carriage_return--;
  886. else
  887. if (fputc('r',fp)== -1)
  888. return -1;
  889. else
  890. written++;
  892. Last_Chr= *buf;
  893. }
  895. if (fputc(*buf,fp)== -1)
  896. return -1;
  897. else
  898. written++;
  899. }
  901. return written;
  902. }
  904. static
  905. Receive_File()
  906. {
  907. char *ptr;
  908. int N, i;
  909. short Request_Resume;
  911. Result=Overwrite;
  912. if (Valid_To_Resume_Download==2)
  913. Request_Resume=Resume_Allowed;
  914. else
  915. Request_Resume=Resume_Not_Allowed;
  917. if (!(Data_File=QueryCreate(Request_Resume))){
  918. Send_Abort();
  919. return FAILURE;
  920. }
  922. if (Result==Resume){
  923. strcpy(tdir,"Attempting receive resume of");
  925. init_check();
  927. do {
  928. S_Buffer[0]='N';
  929. N=Read(Data_File,&S_Buffer[0],Packet_Size);
  931. if (N>0){
  932. for (i=0;i<N;i++)
  933. do_checksum(S_Buffer[i]);
  934. if (Abort_Flag){
  935. Send_Abort();
  936. return FAILURE;
  937. }
  939. already_have+=N;
  940. }
  941. } while (N>0);
  943. ptr= &S_Buffer[0];
  945. *ptr++ ='T';
  946. *ptr++ ='r';
  948. ptr=cnvLtoA(ptr,already_have);
  949. *ptr++ =' ';
  950. ptr=cnvLtoA(ptr,Checksum);
  952. if (!Send_Packet(ptr- &S_Buffer[0])||!Flush_Pending()){
  953. fclose(Data_File);
  954. S0("Can't resume transfer");
  955. return FAILURE;
  956. }
  958. fseek(Data_File,0L,2);
  960. strcpy(tdir,"Resuming receive of");
  961. data=already_have-carriage_return;
  962. carriage_return= -carriage_return;
  963. showmode();
  964. } else
  965. Send_ACK(),
  966. strcpy(tdir,"Receiving"),
  967. already_have=0;
  969. for (;;){
  970. if (Abort_Flag){
  971. Send_Abort();
  972. return FAILURE;
  973. }
  975. Wait_For_ACK(FALSE,TRUE,TRUE);
  977. if (Packet_Received)
  978. switch(R_Buffer[0]){
  979. case 'N':
  980. if ((N=Write(Data_File,&R_Buffer[1],R_Buffer_Len-1))== -1){
  981. sprintf(Msg,"Disk write error");
  982. S0(Msg);
  983. Send_Failure('I',Msg);
  984. fclose(Data_File);
  985. return FAILURE;
  986. }
  988. stats(N);
  989. break;
  991. case 'T':
  992. switch(R_Buffer[1]){
  993. case 'I':
  994. fsize=cnvAtoL(&R_Buffer[4]);
  995. showmode();
  996. break;
  998. case 'C':
  999. fclose(Data_File);
  1000. return SUCCESS;
  1002. case 'f':
  1003. fclose(Data_File);
  1005. if (!(Data_File=QueryCreate(Resume_Failed))){
  1006. Send_Abort();
  1007. return FAILURE;
  1008. }
  1010. strcpy(tdir,"Receiving");
  1011. data=already_have=carriage_return=0;
  1012. showmode();
  1013. break;
  1015. default:
  1016. Send_Unexpected_Packet();
  1017. fclose(Data_File);
  1018. return FAILURE;
  1019. }
  1020. break;
  1022. case 'F':
  1023. fclose(Data_File);
  1024. R_Buffer[R_Buffer_Len]=0;
  1026. if (Result==Resume)
  1027. sprintf(Msg,"Can't resume transfer: %s",&R_Buffer[3]);
  1028. else
  1029. sprintf(Msg,"B protocol Failure: %s",&R_Buffer[3]);
  1031. S0(Msg);
  1032. return FAILURE;
  1034. default:
  1035. Send_Unexpected_Packet();
  1036. fclose(Data_File);
  1037. return FAILURE;
  1038. }
  1039. else {
  1040. fclose(Data_File);
  1041. return FAILURE;
  1042. }
  1043. }
  1044. }
  1046. static char *
  1047. Handle_Send_Failure()
  1048. {
  1049. if (!R_Buffer_Len)
  1050. return("Remote is not responding");
  1051. else {
  1052. if (R_Buffer[0]=='F'){
  1053. if (R_Buffer_Len>=2){
  1054. R_Buffer[min(81,R_Buffer_Len)]='';
  1055. return(&R_Buffer[1]);
  1056. } else
  1057. return("No reason given by remote");
  1058. } else {
  1059. Send_Failure('E',"Unexpected packet type");
  1060. return("Unexpected packet type");
  1061. }
  1062. }
  1063. }
  1065. static
  1066. Send_File()
  1067. {
  1068. int N;
  1069. struct stat statbuf;
  1071. if (!(Data_File=fopen(Name,"r"))){
  1072. sprintf(Msg,"Can't access '%s'",Name);
  1073. S0(Msg);
  1074. Send_Failure('M',Msg);
  1075. return FAILURE;
  1076. }
  1078. fstat(fileno(Data_File),&statbuf);
  1079. fsize=statbuf.st_size;
  1081. strcpy(tdir,"Transmitting");
  1082. showmode();
  1083. do {
  1084. S_Buffer[0]='N';
  1085. N=Read(Data_File,&S_Buffer[1],Packet_Size);
  1087. if (N>0){
  1088. if (!Send_Packet(N+1)){
  1089. fclose(Data_File);
  1090. S0(Handle_Send_Failure());
  1091. return FAILURE;
  1092. }
  1094. if (Abort_Flag){
  1095. Send_Abort();
  1096. return FAILURE;
  1097. }
  1099. stats(N);
  1100. }
  1101. } while (N>0);
  1103. if (!N){
  1104. fclose(Data_File);
  1105. S_Buffer[0]='T';
  1106. S_Buffer[1]='C';
  1108. if (!Send_Packet(2)){
  1109. S0(Handle_Send_Failure());
  1110. return FAILURE;
  1111. }
  1113. return Flush_Pending();
  1114. } else {
  1115. sprintf(Msg,"Disk read error");
  1116. S0(Msg);
  1117. Send_Failure('I',Msg);
  1118. return FAILURE;
  1119. }
  1120. }
  1122. #define Plus_Packet_Size 18
  1123. #define LowRange 7
  1124. #define HiRange 11
  1126. #define My_Send_Window_Size 1
  1127. #define My_Recv_Window_Size 1
  1128. #define My_Buffer_Size 8
  1129. #define My_Check_Method Check_CRC
  1130. #define My_Download_Resume 2
  1131. #define My_Upload_Resume 0
  1132. #define My_File_Information 1
  1134. static char Quote_Level_Select_Low[]={
  1135. 1, 3, 3, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  1136. 0, 0, 3, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
  1137. };
  1140. static char QuotE_Level_select_Hi[]={
  1141. 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  1142. 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
  1143. };
  1145. static char QUote_Level_Mapping[]={
  1146. Quote_Not_NULL,
  1147. Quote_Default,
  1148. Quote_Extended,
  1149. Quote_Full
  1150. };
  1152. static
  1153. Plus_Respond()
  1154. {
  1155. int Status, temp_window_size, temp_method, temp_size, MaskByte, Bit, i;
  1156. char Estimated_Quote_Level=0;
  1158. S_Buffer[0]='+';
  1159. S_Buffer[1]=My_Send_Window_Size;
  1160. S_Buffer[2]=My_Recv_Window_Size;
  1162. S_Buffer[3]=Packet_Size/128;
  1164. S_Buffer[4]=My_Check_Method;
  1166. S_Buffer[5]=Quote_Default;
  1167. S_Buffer[6]=FALSE;
  1169. S_Buffer[15]=My_Download_Resume;
  1170. S_Buffer[16]=My_Upload_Resume;
  1171. S_Buffer[17]=My_File_Information;
  1173. for (i=0;i<8;i++)
  1174. S_Buffer[i+LowRange]=0;
  1176. for (MaskByte=0;MaskByte<4;MaskByte++)
  1177. for (Bit=0;Bit<8;Bit++){
  1178. if (Mask[MaskByte*8+Bit]&MaskLowRange)
  1179. S_Buffer[MaskByte+LowRange]|=0x80>>Bit;
  1181. if (Mask[MaskByte*8+Bit]&MaskHiRange)
  1182. S_Buffer[MaskByte+HiRange]|=0x80>>Bit;
  1183. }
  1185. for (i=R_Buffer_Len;i<Plus_Packet_Size;i++)
  1186. R_Buffer[i]=0;
  1188. if (R_Buffer[3]<S_Buffer[3])
  1189. temp_size=(R_Buffer[3]*128);
  1190. else
  1191. temp_size=(S_Buffer[3]*128);
  1194. temp_window_size=min(R_Buffer[2],My_Send_Window_Size);
  1195. temp_method=min(R_Buffer[4],My_Check_Method);
  1196. Valid_To_Resume_Download=min(R_Buffer[15],My_Download_Resume);
  1197. Valid_To_Resume_Upload=min(R_Buffer[16],My_Upload_Resume);
  1198. Send_File_Information=min(R_Buffer[17],My_File_Information);
  1200. if (R_Buffer_Len>=Plus_Packet_Size)
  1201. for (MaskByte=0;MaskByte<4;MaskByte++)
  1202. for (Bit=0;Bit<8;Bit++){
  1203. if (R_Buffer[LowRange+MaskByte]&(0x80>>Bit))
  1204. Mask[MaskByte*8+Bit]|=MaskLowRange;
  1206. if (R_Buffer[HiRange+MaskByte]&(0x80>>Bit))
  1207. Mask[MaskByte*8+Bit]|=MaskHiRange;
  1208. }
  1209. else {
  1210. for (i=0;i<32&&Estimated_Quote_Level<3;i++){
  1211. if (Mask[i]&MaskLowRange)
  1212. Estimated_Quote_Level=
  1213. max(Quote_Level_Select_Low[i],Estimated_Quote_Level);
  1215. if (Mask[i]&MaskHiRange)
  1216. Estimated_Quote_Level=
  1217. max(QuotE_Level_select_Hi[i],Estimated_Quote_Level);
  1218. }
  1219. }
  1221. Quoting=Quote_Full;
  1222. S_Buffer[5]=QUote_Level_Mapping[Estimated_Quote_Level];
  1224. if (Status=Send_Packet(Plus_Packet_Size))
  1225. if (Status=Flush_Pending()){
  1226. Actual_Check=temp_method;
  1227. Packet_Size=temp_size;
  1228. Window_Size=temp_window_size;
  1229. }
  1230. Quoting=Quote_Mask;
  1232. return Status;
  1233. }
  1235. static
  1236. Do_Transfer()
  1237. {
  1238. int I, N;
  1239. short Have_DLE_B=TRUE;
  1241. for (;;){
  1242. Wait_For_ACK(Have_DLE_B,FALSE,TRUE);
  1243. if (Packet_Received){
  1244. if (R_Buffer[0]=='T'){
  1245. if (R_Buffer[1]!='D'&&R_Buffer[1]!='U'){
  1246. S0("Invalid transfer direction");
  1247. Send_Failure('N',"Not implemented");
  1248. return FAILURE;
  1249. }
  1250. if (R_Buffer[2]!='A'&&R_Buffer[2]!='B'){
  1251. S0("Invalid transfer type");
  1252. Send_Failure('N',"Not implemented");
  1253. return FAILURE;
  1254. }
  1255. N=min(R_Buffer_Len-3,SM_BUFF-1);
  1256. for (I=0;I<N;I++)
  1257. Name[I]=R_Buffer[I+3];
  1258. Name[I]='';
  1259. textmode=(R_Buffer[2]=='A');
  1261. if (R_Buffer[1]=='U'){
  1262. Send_ACK();
  1263. return Send_File();
  1264. } else
  1265. return Receive_File();
  1267. } else if (R_Buffer[0]=='+'){
  1268. if (Plus_Respond())
  1269. Have_DLE_B=FALSE;
  1270. else {
  1271. S0("Could not negotiate B-Plus parameters");
  1272. return FAILURE;
  1273. }
  1274. } else {
  1275. Send_Unexpected_Packet();
  1276. return FAILURE;
  1277. }
  1278. } else {
  1279. S0("Remote is not responding");
  1280. return FAILURE;
  1281. }
  1282. }
  1283. }
  1285. static
  1286. RETSIGTYPE cisbsigint(junk)
  1287. int junk;
  1288. {
  1289. signal(SIGINT,cisbsigint);
  1290. Abort_Flag=TRUE;
  1291. }
  1293. void
  1294. B_Transfer()
  1295. {
  1296. short Status=FALSE;
  1297. RETSIGTYPE (*oldvec)();
  1299. oldvec = signal(SIGINT,cisbsigint);
  1300. cur_off();
  1301. Init();
  1302. while (readbyte(1) != -1)
  1303. ;
  1305. Send_Byte(DLE);
  1306. Send_Byte('+');
  1307. Send_Byte('+');
  1308. Send_ACK();
  1310. Read_Byte();
  1311. switch(Ch){
  1312. case DLE:
  1313. Read_Byte();
  1314. if (Ch=='B')
  1315. Status=Do_Transfer();
  1316. break;
  1318. default:
  1319. fputc(Ch,tfp);
  1320. break;
  1321. }
  1323. sprintf(Msg,"File Transfer %s",Status?"Succeeded":"Failed");
  1324. S0(Msg);
  1325. beep();
  1327. if (Abort_Flag){
  1328. while (Read_Byte() && Ch==ENQ){
  1329. Seq_Num=0;
  1330. Send_Byte(DLE);
  1331. Send_Byte('+');
  1332. Send_Byte('+');
  1333. Send_ACK();
  1334. }
  1335. }
  1337. cur_on();
  1338. signal(SIGINT,oldvec);
  1339. }