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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
XMODEM.C
资源名称：ertos.rar　[点击查看]
上传用户：sunrenlu
上传日期：2022-06-13
资源大小：1419k
文件大小：15k
源码类别：

操作系统开发

开发平台：

DOS

XMODEM.C：源码内容
  1. /*
  2.  * xmodem.exe - terminal session with XMODEM (xsum+CRC) up/download capabilities
  3.  *            - edit xmodem.ini to change desired COM port
  4.  *            - Keystrokes:
  5.  *                              Esc to exit terminal
  6.  *                              PgUp - upload a file (prompts for name)
  7.  *                              PgDn - download a file (prompts for name)
  8.  *
  9.  *            - download function could be shorter but more cryptic
  10.  */
  11. #include <rtos.h>
  12. #include <sio.h>
  13. #include <xmodem.h>
  14. #include <stdio.h>
  15. #include <mem.h>
  16. #include <bios.h>
  17. #include <inifile.h>
  18. #include <kconio.h>
  21. #define COMBASE1 0x3f8
  22. #define COMBASE2 0x2f8
  23. #define COMIRQ1  4
  24. #define COMIRQ2  3
  26. #define NUM_RETRIES 10      /* # of consecutive failures before abort xfer */
  28. int combuf = 256;
  29. /*********************************************************************/
  30. void get_userfilename( char *msg, char *buffer )
  31. {
  32.     cprintf("rn%s : ", msg );
  33.     *buffer = 255;
  34.     kgets( buffer );
  35. }
  37. /*********************************************************************/
  38. /* debug_getbyte - read serial byte if available
  39.  *               - break program if user hits esc
  40.  */
  41. int debug_getbyte( WORD port, BYTE *data )
  42. {
  43.     BYTE b;
  45.     if ( kbhit() ) {
  46.         b = getch();
  47.         if ( b == 27 ) {
  48.             sio_writebyte( port, XM_CAN );
  49.             sio_writebyte( port, 3 );       /* ctrl c */
  50.             rt_halt("user exit from XMODEM mode");
  51.         } else
  52.             sio_writebyte( port, b );
  53.     }
  54.     if ( sio_recv_waiting( port ) ) {
  55.         b = sio_readbyte( port );
  56.         *data = b;
  57.         return( 1 );
  58.     }
  59.     return( 0 );
  60. }
  61. /*********************************************************************/
  62. /* debug_readbyte - busy wait for data from a port
  63.  *                - inherits keyboard ESC feature from debug_getbyte
  64.  */
  65. BYTE debug_readbyte( int port )
  66. {
  67.     BYTE b;
  69.     while ( ! debug_getbyte( port, &b ) )
  70.         /* nothing to do */
  71.         rt_sleep( 0 );
  72.     return( b );
  73. }
  75. /*********************************************************************/
  76. temp_outbyte( int port, BYTE b )
  77. {
  78. //    while ( sio_tran_waiting( port )) rt_yield();
  79.     sio_writebyte( port, b );
  80. }
  81. /*********************************************************************/
  82. BYTE calc_xsum( BYTE *p, int count )
  83. {
  84.     BYTE xsum;
  85.     int i;
  87.     xsum = 0;
  88.     while ( count--  )
  89.         xsum += *p++;
  90.     return( xsum );
  91. }
  93. /*********************************************************************/
  94. WORD calc_crc( BYTE *p, int count )
  95. {
  96.     WORD crc;
  97.     int i;
  99.     crc = 0;
  100.     while ( count--  ) {
  101.         crc = crc ^ ((*p++) <<8);
  102.         for ( i = 0 ; i < 8 ; ++i )
  103.             if ( crc & 0x8000 )
  104.                 crc = crc << 1 ^ 0x1021;
  105.             else
  106.                 crc = crc << 1;
  107.     }
  108.     return( crc );
  109. }
  110. /*********************************************************************/
  111. void upload(WORD port, char *fname)
  112. {
  113.     int  i, count;
  114.     BYTE b;
  115.     char *buffer = NULL;
  116.     FILE *f = NULL;
  117.     BYTE seq;   /* XMODEM sequence number, */
  118.     BYTE xsum;  /* 8 bit checksum */
  119.     WORD xcrc;  /* 16 bit CRC */
  120.     int use_crc = 0;
  121.     DWORD bytes = 0;
  122.     DWORD timer;
  124.     timer = ktime;          /* note start time */
  126.     b = debug_readbyte( port );
  128.     if ( b == XM_CRC ) {
  129.         use_crc = 1;
  130.         b = XM_NAK;     /* start the syphon */
  131.     }
  132.     do {    /* structured exception handler-like */
  133.         /* need a NAK from receiver to start this going */
  134.         if ( b != XM_NAK) {
  135.             cprintf("ERROR: receiver is not listenningrn");
  136.             break;
  137.         }
  138.         if ( ( f = fopen( fname, "rb" ))== NULL ) {
  139.             cprintf("ERROR: cannot open file: %srn", fname );
  140.             /* inform our peer */
  141.             break;
  142.         }
  144.         if ( ( buffer = kcalloc( 1, XM_BUFSIZE)) == NULL ) {
  145.             cprintf("ERROR: out of memoryrn" );
  146.             break;
  147.         }
  149.         seq = 1;
  150.         do {
  151.             /* read some of the file from disk */
  152.             count = fread( buffer, 1, XM_BUFSIZE, f );
  154.             /* reached end of file */
  155.             if ( count == 0 ) break;
  157.             /* set any unread bytes to zero */
  158.             if ( count < XM_BUFSIZE )
  159.                 memset( buffer + count, 26, XM_BUFSIZE - count );   /* Ctrl Z */
  161.             /* look for errors while disk reading */
  162.             while ( debug_getbyte( port, &b ));
  164.             /* next part may have to be retried - communications are not perfect */
  165.             do {
  166.                 cprintf("data packet # %i ", (WORD) seq );
  167.                 temp_outbyte( port, XM_SOH );       /* start */
  168.                 temp_outbyte( port, seq );          /* sequence number */
  169.                 temp_outbyte( port, seq ^ 0xff );   /* and its complement */
  171.                 /* write bytes and compute checksum */
  172.                 if ( use_crc )
  173.                     xcrc = calc_crc( buffer, XM_BUFSIZE);
  174.                 else
  175.                     xsum = calc_xsum( buffer, XM_BUFSIZE);
  177.                 for ( i = 0 ; i < XM_BUFSIZE ; ++i ) {
  178.                     b = buffer[i];
  179.                     temp_outbyte( port, b );
  180.                 }
  181.                 /* write the CRC or checksum */
  182.                 if ( use_crc ) {
  183.                     temp_outbyte( port, xcrc >> 8 );
  184.                     temp_outbyte( port, xcrc & 255 );
  185.                 } else
  186.                     temp_outbyte( port, xsum );
  188.                 /* and now we get the news */
  189.                 b = debug_readbyte( port );
  191.                 switch ( b ) {
  192.                     case XM_NAK : cprintf("NAKrn"); break;
  193.                     case XM_ACK : cprintf("ACKrn"); break;
  194.                     default     : cprintf("%02xrn", b ); break;
  195.                 }
  196.             } while ( b == XM_NAK );
  197.             bytes += XM_BUFSIZE;
  198.             /* now advance to the next packet */
  199.             ++seq;
  200.         } while ( 1 );
  201.     } while ( 0 );
  203.     do {
  204.         temp_outbyte( port, XM_EOT );
  205.         b = debug_readbyte( port );
  207.         switch ( b ) {
  208.             case XM_NAK : cprintf("NAKrn"); break;
  209.             case XM_ACK : cprintf("ACKrn"); break;
  210.             default     : cprintf("%02xrn", b );
  211.         }
  212.     } while ( b == XM_NAK );
  214.     timer = ktime - timer;
  215.     if ( timer > 0 ) {
  216.         cprintf(" %lu bytes in %lu.%lu seconds, %lu bpsn",
  217.             bytes, timer / 1000, timer % 1000,
  218.             bytes*8*1000/timer );
  219.     }
  220.     if ( buffer != NULL ) kfree( buffer );
  221.     if ( f != NULL ) fclose( f );
  223. }
  225. /*********************************************************************/
  226. /* xm_waitbyte - wait a spell = 0
  227.  *             - return early with 1 if a BYTE found for read
  228.  */
  229. xm_waitbyte( WORD port, BYTE *p, DWORD delay_seconds )
  230. {
  231.     DWORD when;
  233.     /* calculate when loop would timeout */
  234.     when = ktime + delay_seconds * 1000;
  236.     if ( when < (delay_seconds * 1000))
  237.         /* timer wrapping - once every 57 days, we'll ignore it in simple example*/
  238.         return( 1 );
  240.     while ( ktime < when ) {
  241.         if ( kbhit() )
  242.             rt_halt("user requested exit while waiting for serial bytes");
  244.         if ( sio_recv_waiting( port ) ) {
  245.             *p = sio_readbyte( port );
  246.             return( 1 );
  247.         }
  248.         rt_sleep( 0 );      /* give up slice */
  249.     }
  250.     /* timed out */
  251.     return( 0 );
  252. }
  255. /*********************************************************************/
  256. void download(WORD port, char *fname)
  257. {
  258.     int  i, count;
  259.     BYTE b;
  260.     int retries;
  261.     char buffer[ XM_BUFSIZE ];
  262.     FILE *f = NULL;
  263.     BYTE seq;       /* XMODEM sequence number */
  264.     BYTE localseq;  /* our expected sequence number */
  265.     BYTE xsum;  /* 8 bit checksum */
  266.     WORD xcrc;  /* 16 bit CRC */
  267.     int use_crc = 0;
  268.     DWORD bytes = 0;
  269.     DWORD timer;
  271.     timer = ktime;          /* note start time */
  273.     /* write out C's waiting for input */
  274.     retries = 10;
  275.     use_crc = 1;
  276.     do {
  277.         do {
  278.             /* write out individual C */
  279.             sio_writebyte( port, XM_CRC );      /* C */
  280.             if ( xm_waitbyte( port, &b, 10 ) ) break;
  281.             if ( retries-- == 0 ) {
  282.                 cprintf("Download gave up after no responsern");
  283.                 return;
  284.             }
  285.         } while ( 1 );
  287.         /* look at sent data */
  288.         if ( b == 3 ) return;   /* control break */
  289.     } while ( b != XM_SOH );
  291.     /* we have a SOH */
  292.     localseq = 1;
  293.     timer = ktime;
  295.     /* try to create output file */
  296.     if ( (f = fopen( fname,"wb")) == NULL ) {
  297.         sio_writebyte( port, XM_CAN );
  298.         rt_halt("unable to open local file for download");
  299.     }
  301.     retries = NUM_RETRIES;
  302.     goto skip_soh;      /* we already have the first byte handy */
  304.     /* we expect packets full of bytes */
  305.     do {
  306.         if ( --retries == 0 ) {
  307.             cprintf("too many retries, giving uprn");
  308.             sio_writebyte( port, XM_CAN );
  309.             break;
  310.         }
  312.         if ( !xm_waitbyte( port, &b, 10 ) ) {
  313.             /* handle timeout */
  314.             cprintf("timeout waiting for start of packetrn");
  315.             sio_writebyte( port, XM_NAK );
  316.             continue;
  317.         }
  318. skip_soh:
  319.         if ( b == XM_CAN )  /* sender requests a cancel */
  320.             break;
  321.         if ( b == XM_EOT ) {/* end of transmission !!! */
  322.             sio_writebyte( port, XM_ACK );  // acknowledge it
  323.             break;
  324.         }
  326.         if ( b != XM_SOH ) {
  327.             cprintf("garbage received at start of packetrn");
  328.             sio_writebyte( port, XM_NAK );
  329.             continue;
  330.         }
  332.         /* looking for sequence number */
  333.         if ( !xm_waitbyte( port, &b, 10 ) ) {
  334.             /* handle timeout */
  335.             cprintf("timeout waiting for sequence numberrn");
  336.             sio_writebyte( port, XM_NAK );
  337.             continue;
  338.         }
  339.         if ( b == (localseq-1 )) {
  340.             /* we already acknowledged it */
  341.             cprintf("received duplicate packetrn");
  342.             sio_writebyte( port, XM_ACK );
  343.             continue;
  344.         }
  345.         if ( b != localseq ) {
  346.             /* either garbage or peer is on a different packet */
  347.             cprintf("sequence number out of order : %u expected : %urn",
  348.                 b, localseq );
  349.             sio_writebyte( port, XM_NAK );
  350.             continue;
  351.         }
  352.         /* look for complement byte */
  353.         if ( !xm_waitbyte( port, &b, 10 ) ) {
  354.             /* handle timeout */
  355.             cprintf("timeout waiting for sequence complementrn");
  356.             sio_writebyte( port, XM_NAK );
  357.             continue;
  358.         }
  359.         if ( b != (~localseq &255 )) {
  360.             /* complement failed */
  361.             cprintf("sequence number corrupt, complement <> seqrn");
  362.             sio_writebyte( port, XM_NAK );
  363.             continue;
  364.         }
  366.         /* get data */
  367.         for ( count = 0 ; count < XM_BUFSIZE ; ++count ) {
  368.              if ( !xm_waitbyte( port, &b, 10 ) ) {
  369.                 /* handle timeout */
  370.                 cprintf("timeout waiting for data item %urn", count+1);
  371.                 sio_writebyte( port, XM_NAK );
  372.                 continue;
  373.             }
  374.             buffer[ count ] = b;
  375.         }
  377.         /* get CRC or checksum */
  378.         if ( !xm_waitbyte( port, &b, 10 ) ) {
  379.             /* handle timeout */
  380.             cprintf("timeout waiting for xsumrn");
  381.             sio_writebyte( port, XM_NAK );
  382.             continue;
  383.         }
  385.         if ( use_crc ) {
  386.             xcrc = b << 8;
  387.             if ( !xm_waitbyte( port, &b, 10 ) ) {
  388.                 /* handle timeout */
  389.                 cprintf("timeout waiting for xsumrn");
  390.                 sio_writebyte( port, XM_NAK );
  391.                 continue;
  392.             }
  393.             xcrc |= (b & 255);
  395.             if ( xcrc != calc_crc( buffer, XM_BUFSIZE)) {
  396.                 cprintf("CRC failedrn");
  397.                 sio_writebyte( port, XM_NAK );
  398.                 continue;
  399.             }
  400.         } else {
  401.             if ( b != calc_xsum( buffer, XM_BUFSIZE)) {
  402.                 cprintf("checksum failedrn");
  403.                 sio_writebyte( port, XM_NAK );
  404.                 continue;
  405.             }
  406.         }
  407.         /* packet was successful */
  408.         if ( fwrite( buffer, sizeof( buffer ), 1, f) != 1 ) {
  409.             cprintf("disk file write failedrn");
  410.             break;
  411.         }
  412.         cprintf("downloaded %u bytesr", bytes );
  414.         sio_writebyte( port, XM_ACK );
  415.         /* now advance to the next packet */
  416.         bytes += XM_BUFSIZE;
  417.         localseq++;
  419.         retries = NUM_RETRIES;
  421.     } while ( 1 );
  423.     timer = ktime - timer;
  424.     if ( timer > 0 ) {
  425.         cprintf(" %lu bytes in %lu.%lu seconds, %lu bpsn",
  426.             bytes, timer / 1000, timer % 1000,
  427.             bytes*8*1000/timer );
  428.     }
  429.     if ( f != NULL ) fclose( f );
  431. }
  432. /***********************************************************************/
  433. /* term_thread - includes all the code to make this work as a terminal */
  434. /*               session while user negotiates upload/download         */
  435. /*             - PgUp initiates upload                                 */
  436. /*             - PgDn initiates download                               */
  437. /***********************************************************************/
  438. void term_thread(DWORD port)
  439. {
  440.     int  i, count;
  441.     BYTE b;
  442.     WORD key;
  443.     static char buffer[ 256 ];
  445.     /*
  446.      * Initialize the COM port
  447.      */
  448.     if ( port == 1 )
  449.         sio_init( 1, COMBASE1, COMIRQ1, combuf, combuf, NULL, 0 );
  450.     else
  451.         sio_init( 2, COMBASE2, COMIRQ2, combuf, combuf, NULL, 0 );
  453.     sio_setup (port, (DWORD)9600, 8, SIO_PARITY_NONE, 2, 0);
  455.     kwindow( 1,2, 80,25 );
  457.     do {    /* structured exception handler-like */
  458.         if ( kbhit() ) {
  459.             key = bioskey( 0 );
  460.             b = key & 255;
  462.             if ( key == 0x4900 ) { /* PgUp */
  463.                 cprintf("uploading ...nr");
  464.                 get_userfilename( "file to upload", buffer );
  465.                 upload( port, buffer );
  466.                 cprintf("...donern");
  467.             } else if ( key == 0x5100 ) {
  468.                 cprintf("downloading ...nr");
  469.                 get_userfilename( "file to write to", buffer );
  470.                 download( port, buffer );
  471.                 cprintf("...donern");
  472.             } else if ( b == 27 ) break;
  473.             else sio_writebyte( port, b );
  474.         }
  475.         if ( sio_recv_waiting( port ) ) {
  476.             b = sio_readbyte( port );
  477.             putch( b );
  478.         }
  479.     } while ( 1 );
  480.     sio_close (port);
  481.     rt_halt("user terminated");
  482. }
  483. /*********************************************************************/
  485. main ()
  486. {
  487.     int comport;
  488.     int msg;
  489.     DWORD data;
  491.     rt_init (200);
  492.     rt_timerfreq( 100 );
  493.     kpreemptive = 1;
  495.     kctrlbreak = 0;     /* ignore ctrl breaks */
  496.     clrscr();
  497.     cprintf("Esc to escape..., PgUp to invoke upload, PgDn for download");
  499.     /* determine the desired com port */
  500.     if ((comport = (int)GetIniDWORD("xmodem.ini","default","comport",-1))==-1){
  501.         comport = 1;
  502.         SetIniDWORD("xmodem.ini","default","comport", comport );
  503.     }
  506.     rt_newthread(term_thread, comport , 8192, 0, "term session" );
  507.     kreadmessage( &msg, &data );
  508. }