file transimission through zmodem protocol.

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@1354 bbd45198-f89e-11dd-88c7-29a3b14d5316

components/rzsz/rz.c

+/*
+ * File      : rz.c
+ * the implemention of receiving files from the remote computers  
+ * through the zmodem proctocol.
+ * Change Logs:
+ * Date           Author       Notes
+ * 2011-03-29     itspy       
+ */
+
+#include <rtthread.h>
+#include <finsh.h>
+#include <shell.h>
+#include <rtdef.h>
+#include <dfs.h>
+#include <dfs_file.h>
+#include <dfs_posix.h>
+#include <stdio.h>
+#include "zdef.h"
+
+
+void zr_start(char *path);
+static rt_err_t zrec_init(rt_uint8_t *rxbuf,struct zfile *zf);
+static rt_err_t zrec_files(struct zfile *zf);
+static rt_err_t zwrite_file(rt_uint8_t *buf,rt_uint16_t size,struct zfile *zf);
+static rt_err_t zrec_file_data(rt_uint8_t *buf,struct zfile *zf);;
+static rt_err_t zrec_file(rt_uint8_t *rxbuf,struct zfile *zf);
+static rt_err_t zget_file_info(char *name,struct zfile *zf);
+static rt_err_t zwrite_file(rt_uint8_t *buf,rt_uint16_t size,struct zfile *zf);
+static void zrec_ack_bibi(void);
+
+
+/* start zmodem receive proccess */
+void zr_start(char *path)
+{
+    struct zfile *zf;
+    rt_uint8_t n;
+	char ch;
+	rt_err_t res = -RT_ERROR;
+	zf = rt_malloc(sizeof(struct zfile));
+	if (zf == RT_NULL)
+	{
+	    rt_kprintf("zf: out of memory\r\n");
+		return;
+	}
+	memset(zf, 0, sizeof(struct zfile));
+    zf->fname = path;
+	zf->fd = -1;
+    rt_kprintf("\r\n");
+	res = zrec_files(zf);      
+    if (res == RT_EOK)
+    {		  
+        rt_kprintf("\b\b\bfile: %s                           \r\n",zf->fname+1);
+		rt_kprintf("size: %ld bytes\r\n",zf->bytes_received);
+		rt_kprintf("receive completed.\r\n");
+		close(zf->fd);
+		rt_free(zf);
+    }
+    else
+    {
+        rt_kprintf("\b\b\bfile: %s                           \r\n",zf->fname+1);
+		rt_kprintf("size: 0 bytes\r\n");
+		rt_kprintf("receive failed.\r\n");
+	    close(zf->fd);
+	    unlink(zf->fname);    /* remove this file */ 
+	    rt_free(zf);
+    }
+	/* waiting,clear console buffer */
+	rt_thread_delay(RT_TICK_PER_SECOND/2);
+	while(1)                     
+	{
+	   n=rt_device_read(shell->device, 0, &ch, 1);
+	   if (n == 0) break;
+	}
+	return ;
+}
+
+
+
+
+/* receiver init, wait for ack */
+static rt_err_t zrec_init(rt_uint8_t *rxbuf,struct zfile *zf)
+{
+    rt_uint8_t err_cnt = 0;
+	rt_err_t res = -RT_ERROR;
+	for (;;) 
+	{
+		zput_pos(0L);
+		tx_header[ZF0] = ZF0_CMD;
+		tx_header[ZF1] = ZF1_CMD;
+		tx_header[ZF2] = ZF2_CMD;
+		zsend_hex_header(ZRINIT, tx_header);
+again:
+        res = zget_header(rx_header);
+		switch(res)
+		{
+		case ZFILE:						 
+			 ZF0_CMD  = rx_header[ZF0];
+			 ZF1_CMD  = rx_header[ZF1];
+			 ZF2_CMD  = rx_header[ZF2];
+			 ZF3_CMD  = rx_header[ZF3];
+			 res = zget_data(rxbuf, RX_BUFFER_SIZE);
+			 if (res == GOTCRCW)
+			 {
+	             if (zget_file_info((char*)rxbuf,zf) != RT_EOK) 
+	             {
+	                 zsend_hex_header(ZSKIP, tx_header);
+		             return (res);
+	             }
+			     return RT_EOK;; 
+			 }     
+			 zsend_hex_header(ZNAK, tx_header);
+			 goto again;
+		case ZSINIT:
+			 if (zget_data((rt_uint8_t*)Attn, ZATTNLEN) == GOTCRCW) 	  /* send zack */
+			 {
+				zsend_hex_header(ZACK, tx_header);
+				goto again;
+			 }
+			 zsend_hex_header(ZNAK, tx_header);		     /* send znak */
+			 goto again;
+		case ZRQINIT:
+			 continue;
+		case ZEOF:
+			 continue;
+		case ZCOMPL:
+			 goto again;
+		case ZFIN:			     /* end file session */
+			 zrec_ack_bibi(); 
+			 return res;
+		 default:
+		      if (++err_cnt >1000) return -RT_ERROR;
+		      continue;
+		}
+	}
+}
+
+/* receive files */
+static rt_err_t zrec_files(struct zfile *zf)
+{
+	rt_uint8_t *rxbuf;
+	rt_err_t res = -RT_ERROR;
+	zinit_parameter();
+	rxbuf = rt_malloc(RX_BUFFER_SIZE*sizeof(rt_uint8_t));
+	if (rxbuf == RT_NULL)
+	{
+		 rt_kprintf("not enough memory\r\n");
+		 return -RT_ERROR;
+	}
+	rt_kprintf("rz: ready...\r\n");	   /* here ready to receive things */
+	if ((res = zrec_init(rxbuf,zf))!= RT_EOK)
+	{
+	     rt_kprintf("receive init failed !\r\n");
+		 rt_free(rxbuf);
+		 return -RT_ERROR;
+	}
+	res = zrec_file(rxbuf,zf);
+	if (res == ZFIN)
+	{	
+	    rt_free(rxbuf); 
+	    return RT_EOK;	     /* if finish session */
+	}
+	else if (res == ZCAN)
+	{
+        rt_free(rxbuf);
+		return ZCAN;        /* cancel by sender */
+	}
+	else
+	{
+	   zsend_can();
+	   rt_free(rxbuf);
+	   return res;
+	}
+}
+/* receive file */
+static rt_err_t zrec_file(rt_uint8_t *rxbuf,struct zfile *zf)
+{
+	rt_err_t res = - RT_ERROR;
+	rt_uint16_t err_cnt = 0;
+	do 
+	{
+		zput_pos(zf->bytes_received);
+		zsend_hex_header(ZRPOS, tx_header);
+again:
+        res = zget_header(rx_header);
+		switch (res) 
+		{
+		case ZDATA:
+			 zget_pos(Rxpos);
+			 if (Rxpos != zf->bytes_received)
+			 {
+                 zsend_break(Attn);      
+				 continue;
+			 }
+			 err_cnt = 0;
+			 res = zrec_file_data(rxbuf,zf);
+			 if (res == -RT_ERROR)
+			 {	  
+			     zsend_break(Attn);
+			     continue;
+			 }
+			 else if (res == GOTCAN) return res;	
+			 else goto again;	 
+		case ZRPOS:
+		     zget_pos(Rxpos);
+			 continue;
+		case ZEOF:
+		     err_cnt = 0;
+		     zget_pos(Rxpos);
+			 if (Rxpos != zf->bytes_received  || Rxpos != zf->bytes_total) 
+			 {
+			     continue;
+			 }							 
+		     return (zrec_init(rxbuf,zf));    /* resend ZRINIT packet,ready to receive next file */
+        case ZFIN:
+			 zrec_ack_bibi(); 
+			 return ZCOMPL; 
+		case ZCAN:
+#ifdef ZDEBUG
+             rt_kprintf("error code: sender cancelled \r\n");
+#endif
+			 unlink(zf->fname);
+			 zf->bytes_received = 0L;		 /* throw the received data */  
+		     return res;
+		case ZSKIP:
+			 return res;
+		case -RT_ERROR:             
+			 zsend_break(Attn);
+			 continue;
+		case ZNAK:
+		case TIMEOUT:
+		default: 
+			continue;
+		}
+	} while(++err_cnt < 100);
+	return res;
+}
+
+/* proccess file infomation */
+static rt_err_t zget_file_info(char *name,struct zfile *zf)
+{
+	char *p;
+	char *ftemp,*ptr;
+	rt_uint16_t i,len;
+	rt_err_t res  = -RT_ERROR;
+	struct statfs buf;
+	struct stat finfo;
+
+	if (zf->fname == RT_NULL) 		       /* extract file path  */
+    {
+	    len = strlen(name)+2; 
+	}
+	else
+	    len = strlen(zf->fname)+strlen(name)+2; 
+    ftemp = rt_malloc(len);
+    if (ftemp == RT_NULL)		 
+	{
+	    rt_kprintf("ftemp: out of memory\n");
+		return -RT_ERROR;
+	}
+	memset(ftemp,0,len);
+
+    for (i=0,ptr=zf->fname;i<len-strlen(name)-2;i++)
+		 ftemp[i] = *ptr++;
+    ftemp[len-strlen(name)-2] = '/';
+	/* check if is a directory */
+	if ((zf->fd=open(ftemp, DFS_O_DIRECTORY,0)) < 0)	 
+	{
+	    rt_kprintf("can not open file:%s\r\n",zf->fname+1);
+		close(zf->fd);
+		zf->fd = -1;
+	    return res;
+	}
+	fstat(zf->fd, &finfo);
+	if ((finfo.st_mode&S_IFDIR) != S_IFDIR)           
+	{
+		close(zf->fd);
+		zf->fd = -1;
+		return res;
+	}
+	close(zf->fd);	   
+	/* get fullpath && file attributes */
+    strcat(ftemp,name);
+    zf->fname = ftemp;
+	p = strlen(name)+name+1;	   
+	sscanf((const char *)p, "%ld%lo%o", &zf->bytes_total,&zf->ctime,&zf->mode);
+	dfs_statfs(working_directory,&buf);
+	if (zf->bytes_total > (buf.f_blocks * buf.f_bfree))
+	{
+	    rt_kprintf(" not enough disk space !\r\n");
+		return -RT_ERROR;  
+	}
+	zf->bytes_received   = 0L;
+	if ((zf->fd = open(zf->fname,DFS_O_CREAT|DFS_O_WRONLY,0)) < 0)	 /* create or replace exist file */
+	{
+	    rt_kprintf("can not create file:%s \r\n",zf->fname);	
+		rt_free(ftemp);
+		return -RT_ERROR;
+	}
+	return RT_EOK;
+}
+
+/* receive file data,continously, no ack */
+static rt_err_t zrec_file_data(rt_uint8_t *buf,struct zfile *zf)
+{
+    rt_err_t res = -RT_ERROR;
+more_data:
+	res = zget_data(buf,RX_BUFFER_SIZE);
+	switch(res)
+	{
+	case GOTCRCW:						   /* zack received */
+		 zwrite_file(buf,Rxcount,zf);
+		 zf->bytes_received += Rxcount;
+		 zput_pos(zf->bytes_received);
+		 zsend_line(XON);
+		 zsend_hex_header(ZACK, tx_header);
+		 return RT_EOK;
+	case GOTCRCQ:
+		 zwrite_file(buf,Rxcount,zf);
+		 zf->bytes_received += Rxcount;
+		 zput_pos(zf->bytes_received);
+		 zsend_hex_header(ZACK, tx_header);
+		 goto more_data;
+	case GOTCRCG:
+		 zwrite_file(buf,Rxcount,zf);
+		 zf->bytes_received += Rxcount;
+		 goto more_data;
+	case GOTCRCE:
+		 zwrite_file(buf,Rxcount,zf);
+		 zf->bytes_received += Rxcount;
+		 return RT_EOK;
+	case GOTCAN:
+#ifdef ZDEBUG
+	     rt_kprintf("error code : ZCAN \r\n");
+#endif
+		 return res;
+	case TIMEOUT:
+	     return res;
+    case -RT_ERROR:
+	     zsend_break(Attn);
+	     return res;
+	default:
+	     return res;
+	}
+}
+
+/* write file */
+static rt_err_t zwrite_file(rt_uint8_t *buf,rt_uint16_t size,struct zfile *zf)
+{
+	return (write(zf->fd,buf,size));
+}
+
+/* ack bibi */
+static void zrec_ack_bibi(void)
+{
+	rt_uint8_t i;
+	zput_pos(0L);
+	for (i=0;i<3;i++) 
+	{
+		zsend_hex_header(ZFIN, tx_header);
+		switch (zread_line(100)) 
+		{
+		case 'O':
+			 zread_line(1);	
+			 return;
+		case RCDO:
+			 return;
+		case TIMEOUT:
+		default:
+			 break;
+		}
+	}
+}
+
+/* end of rz.c */

components/rzsz/sz.c

+/*
+ * File      : sz.c
+ * the implemention of sending files to the remote computers  
+ * through the zmodem proctocol.
+ * Change Logs:
+ * Date           Author       Notes
+ * 2011-03-29     itspy       
+ */
+
+#include <rtthread.h>
+#include <finsh.h>
+#include <shell.h>
+#include <rtdef.h>
+#include <dfs.h>
+#include <dfs_file.h>
+#include <dfs_posix.h>
+#include "zdef.h"
+
+
+static rt_uint8_t TX_BUFFER[TX_BUFFER_SIZE];	     /* sender buffer */
+static rt_uint8_t file_cnt = 0;		                 /* count of number of files opened */
+static rt_uint8_t Rxflags  = 0;	                  	 /* rx parameter flags */
+static rt_uint8_t ZF2_OP;		                  	 /* file transfer option */ 
+
+void zs_start(char *path);
+static void zsend_init(void);
+static rt_err_t zsend_files(struct zfile *zf);
+static rt_err_t zsend_file(struct zfile *zf,rt_uint8_t *buf, rt_uint16_t len);
+static rt_err_t zsend_file_data(struct zfile *zf);
+static rt_uint16_t zfill_buffer(struct zfile *zf,rt_uint8_t *buf,rt_uint16_t size);
+static rt_err_t zget_sync(void);
+static void zsay_bibi(void);
+
+
+
+
+/* start zmodem send process */
+void zs_start(char *path)
+{
+    struct zfile *zf;
+	rt_err_t res = RT_ERROR;
+	zf = rt_malloc(sizeof(struct zfile));
+	if (zf == RT_NULL)
+	{
+	    rt_kprintf("zf: out of memory\r\n");
+		return;
+	}
+	memset(zf, 0, sizeof(struct zfile));
+    zf->fname = path;
+	zf->fd = -1;
+	res = zsend_files(zf);
+    if (!res)
+    {
+        rt_kprintf("\r\nfile: %s \r\nsize: %ld bytes\r\nsend completed.\r\n",
+		          zf->fname+1,zf->bytes_received);
+    }
+    else
+    {
+        rt_kprintf("\r\nfile: %s \r\nsize: 0 bytes\r\nsend failed.\r\n",zf->fname+1);
+    }
+	rt_free(zf);
+	return;
+}
+/* init the parameters */
+static void zsend_init(void)
+{
+	rt_err_t res = -RT_ERROR;
+	zinit_parameter();
+	for(;;)          /* wait ZPAD */
+	{
+		res = zread_line(800);
+		if (res == ZPAD) break;
+	}
+	for (;;) 
+	{
+	    res = zget_header(rx_header);
+		if (res == ZRINIT) break;
+	}
+	if ((rx_header[ZF1] & ZRQNVH))
+	{
+		zput_pos(0x80L);	/* Show we can var header */
+		zsend_hex_header(ZRQINIT, tx_header);
+	}
+	Rxflags = rx_header[ZF0] & 0377;
+	if (Rxflags & CANFC32) Txfcs32 = 1;    /* used 32bits CRC check */
+
+	if (ZF2_OP == ZTRLE && (Rxflags & CANRLE))	  /* for RLE packet */
+		 Txfcs32 = 2;
+	else
+		ZF2_OP = 0;
+    /* send SINIT cmd */
+	return;
+}
+/* send files */
+static rt_err_t zsend_files(struct zfile *zf)
+{
+	char *p,*q;
+	char *str = "/";
+	struct stat finfo;
+	rt_err_t res = -RT_ERROR;
+
+	if (zf->fname == RT_NULL)
+	{
+	    rt_kprintf("\r\nerror: no file to be send.\r\n");
+		return res;
+	}
+	if ((zf->fd=open(zf->fname, DFS_O_RDONLY,0)) <0)
+	{
+	    rt_kprintf("\r\ncan not open file:%s\r\n",zf->fname+1);
+	    return res;
+	}
+
+	zf->file_end = 0;
+	++file_cnt;	 
+	/* extract file name */
+	p = zf->fname;
+	for (;;)
+	{
+		q = strstr(p,str);
+		if (q == RT_NULL)  break;
+		p = q+1;
+	}	
+	q = (char*)TX_BUFFER;	  
+	for (;;)
+	{
+	    *q++ = *p++;
+		if (*p == 0) break;
+	}
+	*q++ = 0;
+	p=q;
+	while (q < (char*)(TX_BUFFER + 1024))
+		*q++ = 0;
+	/* get file attributes */
+	fstat(zf->fd,&finfo);
+	Left_sizes += finfo.st_size;			                
+	rt_sprintf(p, "%lu %lo %o 3 %d %ld", (long)finfo.st_size, finfo.st_mtime,
+			  finfo.st_mode, file_cnt, Left_sizes);
+	Left_sizes -= finfo.st_size;
+	TX_BUFFER[127] = (finfo.st_size + 127) >>7;
+	TX_BUFFER[126] = (finfo.st_size + 127) >>15;
+
+	zsend_init();
+	/* start sending files */							
+	res = zsend_file(zf,TX_BUFFER, (p-(char*)TX_BUFFER)+strlen(p)+1);
+	zsay_bibi();
+	close(zf->fd);
+/*	unlink(path);   */
+	return res;
+}
+
+/* send file name and related info */
+static rt_err_t zsend_file(struct zfile *zf,rt_uint8_t *buf, rt_uint16_t len)
+{
+	rt_uint8_t cnt;
+	rt_err_t res = -RT_ERROR;
+	for (cnt=0;cnt<5;cnt++) 
+	{  
+		tx_header[ZF0] = ZF0_CMD;	            /* file conversion option */
+		tx_header[ZF1] = ZF1_CMD;               /* file management option */
+		tx_header[ZF2] = (ZF3_CMD|ZF2_OP);	    /* file transfer option   */
+		tx_header[ZF3] = ZF3_CMD;
+		zsend_bin_header(ZFILE, tx_header);
+		zsend_bin_data(buf, len, ZCRCW);
+loop:
+		res = zget_header(rx_header);
+		switch (res) 
+		{
+		case ZRINIT:
+			 while ((res = zread_line(50)) > 0)
+			 {
+				 if (res == ZPAD) 
+				 {
+					goto loop;
+				 }
+			 }
+			 break;
+		case ZCAN:
+		case TIMEOUT:
+		case ZABORT:
+		case ZFIN:
+             break;
+		case -RT_ERROR:
+		case ZNAK:
+			 break;
+		case ZCRC:	                         /* no CRC request */
+			 goto loop;
+		case ZFERR:
+		case ZSKIP:
+			 break;
+		case ZRPOS:		           	         /* here we want */
+		     zget_pos(Rxpos);
+			 Txpos = Rxpos;
+			 return(zsend_file_data(zf));
+		default:
+			 break;
+		} 
+	}
+	return res;
+}
+
+/* send the file data */
+static rt_err_t zsend_file_data(struct zfile *zf)
+{
+	rt_int16_t cnt;
+	rt_uint8_t cmd;
+	rt_err_t res = -RT_ERROR;	
+	/* send ZDATA packet, start to send data */
+start_send:
+	zput_pos(Txpos);
+	zsend_bin_header(ZDATA, tx_header);
+	do
+	{
+		cnt = zfill_buffer(zf,TX_BUFFER,RX_BUFFER_SIZE);
+		if (cnt < RX_BUFFER_SIZE )
+			cmd = ZCRCE;				
+		else
+			cmd = ZCRCG;
+		zsend_bin_data(TX_BUFFER, cnt, cmd);
+		zf->bytes_received= Txpos += cnt;
+		if (cmd == ZCRCW)
+			goto get_syn1;
+	} while (cnt == RX_BUFFER_SIZE);
+	for (;;) 	                     /*  get ack and check if send finish */
+	{
+		zput_pos(Txpos);
+		zsend_bin_header(ZEOF, tx_header);
+get_syn1:
+        res = zget_sync();
+		switch (res) 
+		{
+		case ZACK:
+			 goto get_syn1;
+		case ZNAK:
+			 continue;
+		case ZRPOS:				        /* resend here */
+		     lseek(zf->fd,Txpos,0);
+			 goto start_send;
+		case ZRINIT:		           /*  send finish,then begin to send next file */
+			 return RT_EOK;
+		case ZSKIP:
+		case -RT_ERROR:
+		     return res;
+		default:
+             return res;
+		}
+	}
+}
+
+/* fill file data to buffer*/
+static rt_uint16_t zfill_buffer(struct zfile *zf,rt_uint8_t *buf,rt_uint16_t size)
+{
+	return (read(zf->fd,buf,size));
+}
+
+/* wait sync(ack) from the receiver */
+static rt_err_t zget_sync(void)
+{
+    rt_err_t res = -RT_ERROR;
+	for (;;) 
+	{
+		res = zget_header(rx_header);
+		switch (res) 
+		{
+		case ZCAN:
+		case ZABORT:
+		case ZFIN:
+		case TIMEOUT:
+			 return -RT_ERROR;
+		case ZRPOS:		             /* get pos, need to resend */
+		     zget_pos(Rxpos);
+			 Txpos = Rxpos;
+			 return res;
+		case ZACK:
+			 return res;
+		case ZRINIT:		         /* get ZRINIT indicate that the prev file send completed */
+			 return res;
+		case ZSKIP:
+			 return res;
+		case -RT_ERROR:
+		default:
+			 zsend_bin_header(ZNAK, tx_header);
+			 continue;
+		}
+	}
+}
+
+/* say "bibi" to the receiver */
+static void zsay_bibi(void)
+{
+	for (;;) 
+	{
+		zput_pos(0L);	            	      /* reninit position of next file*/
+		zsend_hex_header(ZFIN, tx_header);	  /* send finished session cmd */
+		switch (zget_header(rx_header)) 
+		{
+		case ZFIN:
+			zsend_line('O'); 
+			zsend_line('O'); 
+		case ZCAN:
+		case TIMEOUT:
+			return;
+		}
+	}
+}
+/* end of sz.c */

components/rzsz/zcore.c

+/*
+ * File      : rz.c
+ * the core functions of implementing zmodem proctocol
+ * Change Logs:
+ * Date           Author       Notes
+ * 2011-03-29     itspy       
+ */
+
+#include <rtthread.h>
+#include <finsh.h>
+#include <shell.h>
+#include <rtdef.h>
+#include <dfs.h>
+#include <dfs_file.h>
+#include <dfs_posix.h>
+#include <stdio.h>
+#include "zdef.h"
+
+char ZF0_CMD;		             /* file conversion request */
+char ZF1_CMD;	 	             /* file management request */
+char ZF2_CMD;		             /* file transport request */
+char ZF3_CMD; 
+rt_uint8_t   Rxframeind;		 /* ZBIN ZBIN32, or ZHEX type of frame */
+rt_uint16_t  Rxcount;		     /* received count*/
+char header_type;	             /* header type */
+rt_uint8_t   rx_header[4];	     /* received header */
+rt_uint8_t   tx_header[4];	     /* transmitted header */
+rt_uint32_t  Rxpos;		         /* received file position */
+rt_uint32_t  Txpos;		         /* transmitted file position */
+rt_uint8_t   Txfcs32;		     /* TURE means send binary frames with 32 bit FCS */
+rt_uint8_t   TxCRC;		         /* controls 32 bit CRC being sent */
+rt_uint8_t   RxCRC;		         /* indicates/controls 32 bit CRC being received */			                     /* 0 == CRC16,  1 == CRC32,  2 == CRC32 + RLE */
+char Attn[ZATTNLEN+1];	         /* attention string rx sends to tx on err */
+
+void zinit_parameter(void);
+void zsend_bin_header(rt_uint8_t type, rt_uint8_t *hdr);
+void zsend_hex_header(rt_uint8_t type, rt_uint8_t *hdr);
+void zsend_bin_data(rt_uint8_t *buf, rt_int16_t len, rt_uint8_t frameend);
+static rt_int16_t zrec_data16(rt_uint8_t *buf,rt_uint16_t len);
+static rt_int16_t zrec_data32(rt_uint8_t *buf,rt_int16_t len);
+static rt_int16_t zrec_data32r(rt_uint8_t *buf, rt_int16_t len);
+rt_int16_t zget_data(rt_uint8_t *buf, rt_uint16_t len);
+rt_int16_t zget_header(rt_uint8_t *hdr);
+static rt_int16_t zget_bin_header(rt_uint8_t *hdr);
+static rt_int16_t zget_bin_fcs(rt_uint8_t *hdr);
+rt_int16_t zget_hex_header(rt_uint8_t *hdr);
+static void zsend_ascii(rt_uint8_t c);
+void zsend_zdle_char(rt_uint16_t ch);
+static rt_int16_t zget_hex(void);
+rt_int16_t zread_byte(void);
+rt_int16_t zxor_read(void);
+void zput_pos(rt_uint32_t pos);
+void zget_pos(rt_uint32_t pos);
+ 
+
+ 
+
+void zinit_parameter(void)
+{
+    rt_uint8_t i;
+
+    ZF0_CMD  = /*CANFC32|*/CANFDX|CANOVIO;		/*  not chose CANFC32,CANRLE,although it have been supported */
+	ZF1_CMD  = 0;							    /* fix header length,not support CANVHDR */
+	ZF2_CMD  = 0;
+	ZF3_CMD  = 0;	
+	Rxframeind =0;
+	header_type   = 0;
+	Rxcount  = 0;
+	for (i=0;i<4;i++) rx_header[i] = tx_header[i] = 0;
+	Rxpos    = Txpos = 0;
+	RxCRC    = 0;	
+	Txfcs32  = 0;
+	return ;
+}
+
+/* send binary header */
+void zsend_bin_header(rt_uint8_t type, rt_uint8_t *hdr)
+{
+	rt_uint8_t i;
+	rt_uint32_t crc;
+
+	zsend_byte(ZPAD); 
+	zsend_byte(ZDLE);
+	TxCRC = Txfcs32;
+	if (TxCRC == 0)
+	{
+		zsend_byte(ZBIN);
+		zsend_zdle_char(type);
+		/* add 16bits crc */
+	    crc = 0L;
+	    crc = updcrc16(type, 0);
+		for (i=0;i<4;i++)
+		{
+		    zsend_zdle_char(*hdr);
+		    crc = updcrc16((0377 & *hdr++),crc);
+		}
+    	crc = updcrc16(0,updcrc16(0,crc));
+		zsend_zdle_char(((int)(crc>>8)));
+		zsend_zdle_char(crc);
+	}
+	else if(TxCRC == 1)   
+	{
+        zsend_byte(ZBIN32);
+		zsend_zdle_char(type);
+		/* add 32bits crc */
+	    crc = 0xffffffffL; 
+	    crc = updcrc32(type, crc);
+        for (i=0;i<4;i++)
+	    {
+		    zsend_zdle_char(*hdr);
+		    crc = updcrc32((0377 & *hdr++), crc);
+     	}
+	    crc = ~crc;
+	    for (i=0; i<4;i++) 
+	    {
+		    zsend_zdle_char(crc);
+		    crc >>= 8;
+	    }
+	}
+	else if (TxCRC == 2)
+	{
+		zsend_byte(ZBINR32);
+		zsend_zdle_char(type);
+		/* add 32bits crc */
+	    crc = 0xffffffffL; 
+	    crc = updcrc32(type, crc);
+        for (i=0;i<4;i++)
+	    {
+		    zsend_zdle_char(*hdr);
+		    crc = updcrc32((0377 & *hdr++), crc);
+     	}
+	    crc = ~crc;
+	    for (i=0; i<4;i++) 
+	    {
+		    zsend_zdle_char(crc);
+		    crc >>= 8;
+	    }
+	}
+	return;
+}
+
+/* send hex header */
+void zsend_hex_header(rt_uint8_t type, rt_uint8_t *hdr)
+{
+	rt_uint8_t i;
+	rt_uint16_t crc;
+
+	zsend_line(ZPAD); zsend_line(ZPAD); zsend_line(ZDLE);
+	zsend_line(ZHEX);
+	zsend_ascii(type);
+	crc = updcrc16(type, 0);
+	for (i=0; i<4; i++) 
+	{
+		zsend_ascii(*hdr); 
+		crc = updcrc16((0377 & *hdr++), crc);
+	}
+	crc = updcrc16(0,updcrc16(0,crc));
+	zsend_ascii(crc>>8);
+	zsend_ascii(crc);
+	/* send display control cmd */
+	zsend_line(015); zsend_line(0212); 
+	if (type != ZFIN && type != ZACK)
+		zsend_line(021);
+	TxCRC = 0;               /* clear tx crc type */
+	return;
+}
+
+/* send binary data,with frameend */
+void zsend_bin_data(rt_uint8_t *buf, rt_int16_t len, rt_uint8_t frameend)
+{
+    rt_int16_t i,c,tmp;
+	rt_uint32_t crc;
+
+    if (TxCRC == 0)         /* send binary data with 16bits crc check */
+	{
+		crc = 0x0L;
+		for (i=0;i<len;i++) 
+		{
+			zsend_zdle_char(*buf); 
+			crc = updcrc16((0377 & *buf++), crc);
+		}
+		zsend_byte(ZDLE); zsend_byte(frameend);
+		crc = updcrc16(frameend, crc);
+		crc = updcrc16(0,updcrc16(0,crc));
+		zsend_zdle_char(crc>>8);
+	    zsend_zdle_char(crc);
+	}
+	else if (TxCRC == 1)   /* send binary data with 32 bits crc check */
+	{
+		crc = 0xffffffffL;
+	    for (i=0;i<len;i++) 
+	    {
+		    c = *buf++ & 0377;
+		    zsend_zdle_char(c);
+		    crc = updcrc32(c, crc);
+	    }
+	    zsend_byte(ZDLE); zsend_byte(frameend);
+	    crc = updcrc32(frameend, crc);
+	    crc = ~crc;
+	    for (i=0;i<4;i++) 
+	    {
+		    zsend_zdle_char((int)crc);  crc >>= 8;
+	    }
+	}
+	else if (TxCRC == 2)   /* send binary data with 32bits crc check,RLE encode */
+	{
+	    crc = 0xffffffffL;
+        tmp = *buf++ & 0377;
+	    for (i = 0; --len >= 0; ++buf)
+		{
+		   if ((c = *buf & 0377) == tmp && i < 126 && len>0) 
+		   {
+			  ++i;  continue;
+		   }
+		   if (i==0)
+		   {
+			   zsend_zdle_char(tmp);
+			   crc = updcrc32(tmp, crc);
+		       if (tmp == ZRESC) 
+			   {
+				   zsend_zdle_char(0100); crc = updcrc32(0100, crc);
+			   }
+			   tmp = c; 
+		   }
+		   else if (i == 1)
+		   {
+		    	if (tmp != ZRESC)
+			    {
+				    zsend_zdle_char(tmp); zsend_zdle_char(tmp);
+				    crc = updcrc32(tmp, crc);
+				    crc = updcrc32(tmp, crc);
+				    i = 0; tmp = c;
+			    }
+
+		   }
+		   else 
+		   {
+			    zsend_zdle_char(ZRESC); crc = updcrc32(ZRESC, crc);
+			    if (tmp == 040 && i < 34)
+			    {
+				    i += 036;
+				    zsend_zdle_char(i); 
+				    crc = updcrc32(i, crc);
+			    }
+			    else 
+				{
+				    i += 0101;
+				    zsend_zdle_char(i); crc = updcrc32(i, crc);
+			     	zsend_zdle_char(tmp); crc = updcrc32(tmp, crc);
+			    }
+			    i = 0; tmp = c; 
+		   }
+	   }
+	   zsend_byte(ZDLE); zsend_byte(frameend);
+	   crc = updcrc32(frameend, crc);
+	   crc = ~crc;
+	   for (i=0;i<4;i++) 
+	   {
+		   zsend_zdle_char(crc);  
+		   crc >>= 8;
+	   }
+	}
+	if (frameend == ZCRCW)
+		zsend_byte(XON);
+	return;
+}
+
+/* receive data,with 16bits CRC check */
+static rt_int16_t zrec_data16(rt_uint8_t *buf,rt_uint16_t len)
+{
+	rt_int16_t c,crc_cnt;
+	rt_uint16_t crc;
+	rt_err_t res = -RT_ERROR;
+ 	rt_uint8_t *p,flag = 0;
+	p = buf;
+	crc = 0L;  
+    Rxcount = 0;  
+	while(buf <= p+len) 
+	{
+		if ((res = zread_byte()) & ~0377)
+		{
+		    if (res == GOTCRCE || res == GOTCRCG ||
+			    res == GOTCRCQ || res == GOTCRCW)
+			{
+				  c = res;
+				  crc = updcrc16(res&0377, crc);
+				  flag = 1;	
+				  continue;	
+			}
+			else if (res == GOTCAN)  return ZCAN;
+			else if (res == TIMEOUT) return TIMEOUT;
+			else return res;
+
+		}
+		else
+		{
+		   if (flag)
+		   {
+		       crc = updcrc16(res, crc); 
+			   crc_cnt++;
+			   if (crc_cnt < 2) continue;
+			   if ((crc & 0xffff))
+			   {
+#ifdef ZDEBUG
+				 	 rt_kprintf("error code: CRC16 error \r\n");
+#endif
+					 return -RT_ERROR;
+			   } 
+               return c;
+		   }
+		   else
+		   {
+		      *buf++ = res;
+		      Rxcount++;
+		      crc = updcrc16(res, crc);
+		   }
+		}
+	}
+	return -RT_ERROR;
+}
+
+/* receive data,with 32bits CRC check */
+static rt_int16_t zrec_data32(rt_uint8_t *buf,rt_int16_t len)
+{
+	rt_int16_t c,crc_cnt = 0;
+	rt_uint32_t crc;
+	rt_err_t res = -RT_ERROR;
+	rt_uint8_t *p,flag = 0;
+
+	crc = 0xffffffffL;  
+	Rxcount = 0;  
+	while (buf <= p+len) 
+	{
+		if ((res = zread_byte()) & ~0377)
+		{
+		    if (res == GOTCRCE || res == GOTCRCG ||
+			    res == GOTCRCQ || res == GOTCRCW)
+			{
+				  c = res;
+				  crc = updcrc32(res&0377, crc);
+				  flag = 1;	
+				  continue;	
+			}
+			else if (res == GOTCAN)  return ZCAN;
+			else if (res == TIMEOUT) return TIMEOUT;
+			else return res;
+
+		}
+		else
+		{
+		   if (flag)
+		   {
+		       crc = updcrc32(res, crc); 
+			   crc_cnt++;
+			   if (crc_cnt < 4) continue;
+			   if ((crc & 0xDEBB20E3))
+			   {
+#ifdef ZDEBUG
+				 	 rt_kprintf("error code: CRC32 error \r\n");
+#endif
+					 return -RT_ERROR;
+			   } 
+               return c;
+		   }
+		   else
+		   {
+		      *buf++ = res;
+		      Rxcount++;
+		      crc = updcrc32(res, crc);
+		   }
+		}
+	}
+	return -RT_ERROR;
+}
+/* receive data,with RLE encoded,32bits CRC check */
+static rt_int16_t zrec_data32r(rt_uint8_t *buf, rt_int16_t len)
+{
+	rt_int16_t c,crc_cnt = 0;
+	rt_uint32_t crc;
+	rt_err_t res = -RT_ERROR;
+	rt_uint8_t *p,flag = 0;
+
+	crc = 0xffffffffL;  
+	Rxcount = 0;  
+	p = buf;
+	while (buf <= p+len) 
+	{
+		if ((res = zread_byte()) & ~0377)
+		{
+		    if (res == GOTCRCE || res == GOTCRCG ||
+			    res == GOTCRCQ || res == GOTCRCW)
+			{
+				  c = res;
+				  crc = updcrc32(res&0377, crc);
+				  flag = 1;	
+				  continue;	
+			}
+			else if (res == GOTCAN)  return ZCAN;
+			else if (res == TIMEOUT) return TIMEOUT;
+			else return res;
+
+		}
+		else
+		{
+		   if (flag)
+		   {
+		       crc = updcrc32(res, crc); 
+			   crc_cnt++;
+			   if (crc_cnt < 4) continue;
+			   if ((crc & 0xDEBB20E3))
+			   {
+#ifdef ZDEBUG
+				 	 rt_kprintf("error code: CRC32 error \r\n");
+#endif
+					 return -RT_ERROR;
+			   } 
+               return c;
+		   }
+		   else
+		   {
+		       crc = updcrc32(res, crc);
+		       switch (c) 
+		       {
+		       case 0:
+			        if (res == ZRESC) 
+			        {
+			 	        c = -1;  continue;
+			        }
+			        *buf++ = res;  
+			        Rxcount++;
+			        continue;
+		       case -1:
+			        if (res >= 040 && res < 0100) 
+			        {
+				        c = res - 035; res = 040;  
+						goto spaces;
+			        }
+			        if (res == 0100) 
+			        {
+				        c = 0;
+				        *buf++ = ZRESC; 
+				        Rxcount++;
+				        continue;
+			        }
+			        c = res;  continue;
+		       default:
+			        c -= 0100;
+			        if (c < 1)
+			 	        goto end;
+spaces:
+			        if ((buf + c) > p+len)
+				        goto end;
+			        while ( --res >= 0)
+			        {
+				        *buf++ = res;
+				        Rxcount++;
+			        }
+			        c = 0;  continue;
+		        }
+		   }
+		}	// if -else
+
+	}
+end:
+	return -RT_ERROR;
+}
+rt_int16_t zget_data(rt_uint8_t *buf, rt_uint16_t len)
+{
+	rt_int16_t res = -RT_ERROR;
+
+	if (RxCRC == 0)
+	{
+		 res = zrec_data16(buf,len);
+	}
+	else if (RxCRC == 1)
+	{
+		res = zrec_data32(buf, len);
+	}
+	else if (RxCRC == 2)
+	{
+	    res = zrec_data32r(buf, len);
+	}
+	return res;
+}
+/* get type and cmd of header, fix lenght */
+rt_int16_t zget_header(rt_uint8_t *hdr)
+{
+	rt_int16_t c,prev_char;
+	rt_uint32_t bit;
+	rt_uint16_t get_can,step_out;
+
+	bit = get_device_speed();	  /* getbaudrate */
+	Rxframeind = header_type = 0;
+    step_out = 0;
+	prev_char = 0xff;
+	for (;;)
+	{
+	    c = zread_line(100);
+		switch(c)
+		{
+		case 021:
+		case 0221:
+		     if (prev_char == CAN)   break;
+		     if (prev_char == ZCRCW)  goto start_again;
+		     break;
+	    case RCDO:
+		     goto end;
+		case TIMEOUT:
+			 if (prev_char == CAN) break;
+			 if (prev_char == ZCRCW)
+			 {
+				 c = -RT_ERROR; goto end;
+			 }
+			 goto end;
+		case ZCRCW:
+		     if (prev_char == CAN) goto start_again;
+			 break;
+		case CAN:
+get_can:
+		     if (++get_can > 5)
+			 {
+			     c = ZCAN; goto end;
+             }
+			 break;
+		case ZPAD:
+		     if (prev_char == CAN)   break;
+		     if (prev_char == ZCRCW) goto start_again;
+		     step_out = 1;
+			 break;
+		default:
+		     if (prev_char == CAN)   break;
+			 if (prev_char == ZCRCW) goto start_again;
+start_again:
+		     if (--bit == 0)
+			 {
+			     c = GCOUNT; goto end;
+			 }
+			 get_can = 0;
+			 break;
+		}
+		prev_char = c;
+		if (step_out) break;    /* exit loop */
+	}
+	step_out = get_can = 0;
+	for (;;)
+	{
+	    c = zxor_read();
+		switch(c)
+		{
+		case ZPAD:
+		     break;
+	    case RCDO:
+		case TIMEOUT:
+		     goto end;
+		case ZDLE:
+		     step_out = 1;
+			 break;
+		default:
+		     goto start_again;
+		}
+		if (step_out) break;
+	}
+ 
+	Rxframeind = c = zxor_read();
+	switch (c) 
+	{
+	case ZBIN32:
+		 RxCRC = 1;  c = zget_bin_fcs(hdr); break;
+	case ZBINR32:
+		 RxCRC = 2;  c = zget_bin_fcs(hdr); break;
+	case ZBIN:
+		 RxCRC = 0;  c = zget_bin_header(hdr); break;
+	case ZHEX:
+		 RxCRC = 0;  c = zget_hex_header(hdr); break;
+	case CAN:
+		goto get_can;
+	case RCDO:
+	case TIMEOUT:
+		goto end;
+	default:
+		goto start_again;
+	}
+end:
+	return c;
+}
+
+/* receive a binary header */
+static rt_int16_t zget_bin_header(rt_uint8_t *hdr)
+{
+	rt_int16_t res, i;
+	rt_uint16_t crc;
+
+	if ((res = zread_byte()) & ~0377)
+		return res;
+	header_type = res;
+	crc = updcrc16(res, 0);
+
+	for (i=0;i<4;i++) 
+	{
+		if ((res = zread_byte()) & ~0377)
+			return res;
+		crc = updcrc16(res, crc);
+		*hdr++ = res;
+	}
+	if ((res = zread_byte()) & ~0377)
+		return res;
+	crc = updcrc16(res, crc);
+	if ((res = zread_byte()) & ~0377)
+		return res;
+	crc = updcrc16(res, crc);
+	if (crc & 0xFFFF) 
+	{
+		rt_kprintf("CRC error\n");
+		return -RT_ERROR;
+	}
+	return header_type;
+}
+
+/* receive a binary header,with 32bits FCS */
+static rt_int16_t zget_bin_fcs(rt_uint8_t *hdr)
+{
+	rt_int16_t res, i;
+	rt_uint32_t crc;
+
+	if ((res = zread_byte()) & ~0377)
+		return res;
+	header_type = res;
+	crc = 0xFFFFFFFFL; crc = updcrc32(res, crc);
+
+	for (i=0;i<4;i++)    /* 4headers */
+	{
+		if ((res = zread_byte()) & ~0377)
+			return res;
+		crc = updcrc32(res, crc);
+		*hdr++ = res;
+
+	}
+	for (i=0;i<4;i++) 	/* 4bytes crc */
+	{
+		if ((res = zread_byte()) & ~0377)
+			return res;
+		crc = updcrc32(res, crc);
+
+	}
+	if (crc != 0xDEBB20E3)       
+	{
+#ifdef ZDEBUG
+		rt_kprintf("CRC error\n");
+#endif
+		return -RT_ERROR;
+	}
+	return header_type;
+}
+
+
+/* receive a hex style header (type and position) */
+rt_int16_t zget_hex_header(rt_uint8_t *hdr)
+{
+	rt_int16_t res,i;
+	rt_uint16_t crc;
+
+	if ((res = zget_hex()) < 0)
+		return res;
+	header_type = res;
+	crc = updcrc16(res, 0);
+
+	for (i=0;i<4;i++) 
+	{
+		if ((res = zget_hex()) < 0)
+			return res;
+		crc = updcrc16(res, crc);
+		*hdr++ = res;
+	}
+	if ((res = zget_hex()) < 0)
+		return res;
+	crc = updcrc16(res, crc);
+	if ((res = zget_hex()) < 0)
+		return res;
+	crc = updcrc16(res, crc);
+	if (crc & 0xFFFF) 
+	{
+#ifdef ZDEBUG
+		rt_kprintf("error code : CRC error\r\n"); 
+#endif
+		return -RT_ERROR;
+	}
+	res = zread_line(100);
+	if (res < 0)
+		return res;
+	res = zread_line(100);
+	if (res < 0)
+		return res;
+	return header_type;
+}
+
+/* convert to ascii */
+static void zsend_ascii(rt_uint8_t c)
+{
+	const char hex[] = "0123456789abcdef";
+
+	zsend_line(hex[(c&0xF0)>>4]);
+	zsend_line(hex[(c)&0xF]);
+	return;
+}
+
+/*
+ * aend character c with ZMODEM escape sequence encoding.
+ */
+void zsend_zdle_char(rt_uint16_t ch)
+{
+    rt_uint16_t	res;
+
+	res = ch & 0377;
+	switch (res) 
+	{
+	case 0377:
+		zsend_byte(res);
+		break;
+	case ZDLE:
+		zsend_byte(ZDLE);  
+		res ^= 0100;
+		zsend_byte(res);
+		break;
+	case 021: 
+	case 023:
+	case 0221: 
+	case 0223:
+		zsend_byte(ZDLE);  
+		res ^= 0100;  
+		zsend_byte(res);
+		break;
+	default:
+		zsend_byte(res);
+	}
+}
+
+/* decode two lower case hex digits into an 8 bit byte value */
+static rt_int16_t zget_hex(void)
+{
+	rt_int16_t res,n;
+
+	if ((res = zxor_read()) < 0)
+		return res;
+	n = res - '0';
+	if (n > 9)
+		n -= ('a' - ':');
+	if (n & ~0x0f)
+		return -RT_ERROR;
+	if ((res = zxor_read()) < 0)
+		return res;
+	res -= '0';
+	if (res > 9)
+		res -= ('a' - ':');
+	if (res & ~0x0f)
+		return -RT_ERROR;
+	res += (n<<4);
+	return res;
+}
+
+
+/*
+ * read a byte, checking for ZMODEM escape encoding
+ *  including CAN*5 which represents a quick abort
+ */
+rt_int16_t zread_byte(void)
+{
+	register int res;
+
+again:
+	/* Quick check for non control characters */
+	if ((res = zread_line(100)) & 0140)
+		return res;
+	switch (res) 
+	{
+	case ZDLE:
+		break;
+	case 023:
+	case 0223:
+	case 021:
+	case 0221:
+		goto again;
+	default:
+		return res;
+	}
+again2:
+	if ((res = zread_line(100)) < 0)
+		return res;
+	if (res == CAN && (res = zread_line(100)) < 0)
+		return res;
+	if (res == CAN && (res = zread_line(100)) < 0)
+		return res;
+	if (res == CAN && (res = zread_line(100)) < 0)
+		return res;
+	switch (res) 
+	{
+	case CAN:
+		 return GOTCAN;
+	case ZCRCE:
+	case ZCRCG:
+	case ZCRCQ:
+	case ZCRCW:
+		 return (res | GOTOR);
+	case ZRUB0:
+	 	 return 0177;
+	case ZRUB1:
+		 return 0377;
+	case 023:
+	case 0223:
+	case 021:
+	case 0221:
+		 goto again2;
+	default:
+		 if ((res & 0140) ==  0100)
+			return (res ^ 0100);
+		 break;
+	}
+	return -RT_ERROR;
+}
+
+/*
+ * @read a character from the modem line with timeout.
+ * @eat parity, XON and XOFF characters.
+ */
+rt_int16_t zxor_read(void)
+{
+	rt_int16_t res;
+
+	for (;;) 
+	{
+		if ((res = zread_line(100)) < 0)
+			return res;
+		switch (res &= 0177) {
+		case XON:
+		case XOFF:
+			continue;		
+		case '\r':
+		case '\n':
+		case ZDLE:
+		default:
+			return res;
+		}
+	}
+	/* NOTREACHED */
+}
+
+/* put file posistion into the header*/
+void zput_pos(rt_uint32_t pos)
+{
+	tx_header[ZP0] = pos;
+	tx_header[ZP1] = pos>>8;
+	tx_header[ZP2] = pos>>16;
+	tx_header[ZP3] = pos>>24;
+	return;
+}
+
+/* Recover a long integer from a header */
+void zget_pos(rt_uint32_t pos)
+{
+	Rxpos = (rx_header[ZP3] & 0377);
+	Rxpos = (Rxpos << 8) | (rx_header[ZP2] & 0377);
+	Rxpos = (Rxpos << 8) | (rx_header[ZP1] & 0377);
+	Rxpos = (Rxpos << 8) | (rx_header[ZP0] & 0377);
+}
+
+/* End of zm.c */

components/rzsz/zdef.h

+#ifndef __ZDEF_H__
+#define __ZDEF_H__
+
+#include <rtthread.h>
+#include "crc.h"
+#define ZPAD      '*'	/* 052 padding character begins frames */
+#define ZDLE      030	/* ctrl-X ZMODEM escape - `ala BISYNC DLE */
+#define ZDLEE     (ZDLE^0100)	/* escaped ZDLE as transmitted */
+#define ZBIN      'A'	/* binary frame indicator (CRC-16) */
+#define ZHEX      'B'	/* hex frame indicator */
+#define ZBIN32    'C'	/* binary frame with 32 bit FCS */
+#define ZBINR32   'D'	/* RLE packed Binary frame with 32 bit FCS */
+#define ZVBIN     'a'	/* binary frame indicator (CRC-16) */
+#define ZVHEX     'b'	/* hex frame indicator */
+#define ZVBIN32   'c'	/* binary frame with 32 bit FCS */
+#define ZVBINR32  'd'	/* RLE packed Binary frame with 32 bit FCS */
+#define ZRESC	  0176	/* RLE flag/escape character */
+
+
+/* Frame types */
+#define ZRQINIT	  0	    /* request receive init */
+#define ZRINIT    1     /* receive init */
+#define ZSINIT    2	    /* send init sequence (optional) */
+#define ZACK      3	    /* ACK to above */
+#define ZFILE     4	    /* file name from sender */
+#define ZSKIP     5	    /* ro sender: skip this file */
+#define ZNAK      6	    /* last packet was garbled */
+#define ZABORT    7	    /* abort batch transfers */
+#define ZFIN      8	    /* finish session */
+#define ZRPOS     9	    /* resume data trans at this position */
+#define ZDATA     10    /* data packet(s) follow */
+#define ZEOF      11    /* end of file */
+#define ZFERR     12    /* fatal Read or Write error Detected */
+#define ZCRC      13    /* request for file CRC and response */
+#define ZCHALLENGE 14   /* receiver's Challenge */
+#define ZCOMPL    15	/* request is complete */
+#define ZCAN      16	/* other end canned session with CAN*5 */
+#define ZFREECNT  17	/* request for free bytes on filesystem */
+#define ZCOMMAND  18	/* command from sending program */
+
+/* ZDLE sequfences */
+#define ZCRCE     'h'	/* CRC next, frame ends, header packet follows */
+#define ZCRCG     'i'	/* CRC next, frame continues nonstop */
+#define ZCRCQ     'j'	/* CRC next, frame continues, ZACK expected */
+#define ZCRCW     'k'	/* CRC next, ZACK expected, end of frame */
+#define ZRUB0     'l'	/* translate to rubout 0177 */
+#define ZRUB1     'm'	/* translate to rubout 0377 */
+
+/* zdlread return values (internal) */
+/* -1 is general error, -2 is timeout */
+#define GOTOR     0400
+#define GOTCRCE   (ZCRCE|GOTOR)	/* ZDLE-ZCRCE received */
+#define GOTCRCG   (ZCRCG|GOTOR)	/* ZDLE-ZCRCG received */
+#define GOTCRCQ   (ZCRCQ|GOTOR)	/* ZDLE-ZCRCQ received */
+#define GOTCRCW   (ZCRCW|GOTOR)	/* ZDLE-ZCRCW received */
+#define GOTCAN	  (GOTOR|030)	/* CAN*5 seen */
+
+/* Byte positions within header array */
+#define ZF0	      3	    /* first flags byte */
+#define ZF1	      2
+#define ZF2	      1
+#define ZF3	      0
+#define ZP0	      0	    /* low order 8 bits of position */
+#define ZP1	      1
+#define ZP2	      2
+#define ZP3	      3	    /* high order 8 bits of file position */
+
+/* Parameters for ZRINIT header */
+#define ZRPXWN	  8	    /* 9th byte in header contains window size/256 */
+#define ZRPXQQ	  9	    /* 10th to 14th bytes contain quote mask */
+/* Bit Masks for ZRINIT flags byte ZF0 */
+#define CANFDX	  01	/* rx can send and receive true FDX */
+#define CANOVIO	  02	/* rx can receive data during disk I/O */
+#define CANBRK	  04	/* rx can send a break signal */
+#define CANRLE	  010	/* receiver can decode RLE */
+#define CANLZW	  020	/* receiver can uncompress */
+#define CANFC32	  040	/* receiver can use 32 bit Frame Check */
+#define ESCCTL    0100	/* receiver expects ctl chars to be escaped */
+#define ESC8      0200	/* receiver expects 8th bit to be escaped */
+
+/* Bit Masks for ZRINIT flags byte ZF1 */
+#define CANVHDR	  01	/* variable headers OK */
+#define ZRRQWN	  8	    /* receiver specified window size in ZRPXWN */
+#define ZRRQQQ	  16	/* additional control chars to quote in ZRPXQQ	*/
+#define ZRQNVH	  (ZRRQWN|ZRRQQQ)	/* variable len hdr reqd to access info */
+
+/* Parameters for ZSINIT frame */
+#define ZATTNLEN  32	/* max length of attention string */
+#define ALTCOFF   ZF1	/* offset to alternate canit string, 0 if not used */
+
+/* Parameters for ZFILE frame */
+/* Conversion options one of these in ZF0 */
+#define ZCBIN	  1	   /* binary transfer - inhibit conversion */
+#define ZCNL	  2	   /* convert NL to local end of line convention */
+#define ZCRESUM	  3	   /* resume interrupted file transfer */
+/* Management include options, one of these ored in ZF1 */
+#define ZMSKNOLOC 0200 /* skip file if not present at rx */
+/* Management options, one of these ored in ZF1 */
+#define ZMMASK	  037  /* mask for the choices below */
+#define ZMNEWL	  1	   /* transfer if source newer or longer */
+#define ZMCRC	  2	   /* transfer if different file CRC or length */
+#define ZMAPND	  3	   /* append contents to existing file (if any) */
+#define ZMCLOB	  4	   /* replace existing file */
+#define ZMNEW	  5	   /* transfer if source newer */
+	/* Number 5 is alive ... */
+#define ZMDIFF	  6	   /* transfer if dates or lengths different */
+#define ZMPROT	  7	   /* protect destination file */
+#define ZMCHNG	  8	   /* change filename if destination exists */
+/* Transport options, one of these in ZF2 */
+#define ZTLZW	  1	   /* lempel-Ziv compression */
+#define ZTRLE	  3	   /* run Length encoding */
+/* Extended options for ZF3, bit encoded */
+#define ZXSPARS	  64   /* encoding for sparse file operations */
+#define ZCANVHDR  01   /* variable headers OK */
+/* Receiver window size override */
+#define ZRWOVR    4	   /* byte position for receive window override/256 */
+
+/* Parameters for ZCOMMAND frame ZF0 (otherwise 0) */
+#define ZCACK1	  1	   /* acknowledge, then do command */
+extern char Attn[ZATTNLEN+1];	/* Attention string rx sends to tx on err */
+
+/* Globals used by ZMODEM functions */
+extern rt_uint8_t  Rxframeind; /* ZBIN ZBIN32, or ZHEX type of frame */
+extern char header_type;	   /* type of header received */
+extern rt_uint8_t  rx_header[4];		/* received header */
+extern rt_uint8_t  tx_header[4];		/* transmitted header */
+extern rt_uint8_t  Txfcs32;		/* TRUE means send binary frames with 32 bit FCS */
+extern rt_uint16_t Rxcount;	   /* count of data bytes received */
+extern rt_uint16_t Rxtimeout;  /* tenths of seconds to wait for something */
+extern rt_uint32_t Rxpos;	   /* received file position */
+extern rt_uint32_t Txpos;	   /* transmitted file position */
+extern rt_uint8_t  Txfcs32;	   /* TURE means send binary frames with 32 bit FCS */
+
+/* ward Christensen / CP/M parameters - Don't change these! */
+#define ENQ     005
+#define CAN     ('X'&037)
+#define XOFF    ('s'&037)
+#define XON     ('q'&037)
+#define SOH     1
+#define STX     2
+#define ETX     3
+#define SYN     026
+#define ESC     033
+#define WANTG   0107	/* send G not NAK to get nonstop batch xmsn */
+#define EOT     4
+#define ACK     6
+#define NAK     025
+#define CPMEOF  032
+#define WANTCRC 0103	/* send C not NAK to get crc not checksum */
+#define TIMEOUT (-2)
+#define RCDO    (-3)
+#define GCOUNT  (-4)
+#define ERRORMAX 5
+#define RETRYMAX 5
+#define WCEOT   (-10)
+#define PATHLEN  257	/* ready for 4.2 bsd ? */
+#define UNIXFILE 0xF000	/* the S_IFMT file mask bit for stat */
+
+
+
+#define BITRATE 115200
+#define TX_BUFFER_SIZE 1024
+#define RX_BUFFER_SIZE  1024	  /*sender or receiver's max buffer size */
+extern char ZF0_CMD;	/* local ZMODEM file conversion request */
+extern char ZF1_CMD;	/* local ZMODEM file management request */
+extern char ZF2_CMD;	/* local ZMODEM file management request */
+extern char ZF3_CMD;	/* local ZMODEM file management request */
+extern rt_uint32_t Baudrate ;
+extern rt_uint32_t Left_bytes;
+extern rt_uint32_t Left_sizes;
+ 
+
+struct zmodemf
+{
+    struct rt_semaphore zsem;
+    rt_device_t device;
+};
+extern struct zmodemf zmodem;
+
+struct zfile
+{
+	char *fname;
+	rt_int32_t   fd;
+	rt_uint32_t  ctime;
+    rt_uint32_t  mode;
+	rt_uint32_t  bytes_total;
+	rt_uint32_t  bytes_sent;
+	rt_uint32_t  bytes_received;
+	rt_uint32_t  file_end;
+	
+};
+extern struct finsh_shell* shell;
+ 
+#define ZDEBUG 1
+/* sz.c */
+extern void zs_start(char *path);
+/* rz.c */
+extern void zr_start(char *path);
+
+/* zcore.c */
+extern void zinit_parameter(void);
+extern rt_int16_t zget_header(rt_uint8_t *hdr);
+extern void zsend_bin_header(rt_uint8_t type, rt_uint8_t *hdr);
+extern void zsend_hex_header(rt_uint8_t type, rt_uint8_t *hdr);
+extern rt_int16_t zget_data(rt_uint8_t *buf, rt_uint16_t len);
+extern void zsend_bin_data(rt_uint8_t *buf, rt_int16_t len, rt_uint8_t frameend);
+extern void zput_pos(rt_uint32_t pos);
+extern void zget_pos(rt_uint32_t pos);
+/* zdevice.c */
+extern rt_uint32_t get_device_speed(void);
+extern void zsend_byte(rt_uint16_t c);
+extern void zsend_line(rt_uint16_t c);
+extern rt_int16_t zread_line(rt_uint16_t timeout);
+extern void zsend_break(char *cmd);
+extern void zsend_can(void);
+ 
+#endif  /* __ZDEF_H__ */

components/rzsz/zdevice.c

+/*
+ * File      : zdevice.c
+ * the implemention of zmodem proctocol.
+ * Change Logs:
+ * Date           Author       Notes
+ * 2011-03-29     itspy       
+ */
+
+#include <rtthread.h>
+#include <finsh.h>
+#include <shell.h>
+#include <rtdef.h>
+#include <dfs.h>
+#include <dfs_file.h>
+#include <dfs_posix.h>
+#include "zdef.h"
+
+										  
+rt_uint32_t Line_left  = 0;		     /* left number of data in the read line buffer*/ 
+rt_uint32_t Left_sizes = 0;			 /* left file sizes */
+rt_uint32_t Baudrate   = BITRATE; 	 /* console baudrate */
+ 
+
+
+rt_uint32_t get_device_speed(void)
+{
+    return(Baudrate);
+}
+
+rt_uint32_t get_sys_time(void)
+{
+    return(0L);
+}
+
+void zsend_byte(rt_uint16_t ch)
+{
+    rt_device_write(zmodem.device,0,&ch,1);  
+    return;
+}
+
+void zsend_line(rt_uint16_t c)
+{
+    rt_uint16_t ch;
+	ch = (c & 0377);
+    rt_device_write(zmodem.device,0,&ch,1);   
+    return;
+}
+
+static char buf[RX_BUFFER_SIZE + 1];
+
+rt_int16_t zread_line(rt_uint16_t timeout)
+{
+	char *str;	 
+	
+	if (Line_left > 0)
+	{
+	    Line_left -= 1;
+		return (*str++ & 0377);
+	}
+	Line_left = 0;
+	timeout/=5;
+	while (1)
+	{
+     	if (rt_sem_take(&zmodem.zsem, RT_TICK_PER_SECOND*timeout) != RT_EOK) continue;
+     	Line_left = rt_device_read(shell->device, 0, buf, 1);
+		if (Line_left)
+		{
+		     Line_left = Line_left;
+		     str = buf;
+			 break;
+		}
+	}
+	if (Line_left < 1) return TIMEOUT;
+	Line_left -=1;
+	return (*str++ & 0377);
+}
+
+/*
+ * send a string to the modem, processing for \336 (sleep 1 sec)
+ *   and \335 (break signal)
+ */
+void zsend_break(char *cmd)
+{
+   
+	while (*cmd++) 
+	{
+		switch (*cmd) 
+		{
+		case '\336':
+			 continue;
+		case '\335':
+		     rt_thread_delay(RT_TICK_PER_SECOND);
+			 continue;
+		default:
+			 zsend_line(*cmd);
+			 break;
+		}
+	}
+}
+/* send cancel string to get the other end to shut up */
+void zsend_can(void)
+{
+	static char cmd[] = {24,24,24,24,24,24,24,24,24,24,0};
+	zsend_break(cmd);
+	rt_kprintf("\x0d");
+	Line_left=0;	       /* clear Line_left */
+}
+
+/* end of rbsb.c */

components/rzsz/zstart.c

+/*
+ * File      : zstart.c
+ * the implemention of zmodem proctocol.
+ * Change Logs:
+ * Date           Author       Notes
+ * 2011-03-29     itspy       
+ */
+
+#include <rtthread.h>
+#include <finsh.h>
+#include <shell.h>
+#include <dfs.h>
+#include <dfs_file.h>
+#include "zdef.h"
+
+
+
+struct zmodemf zmodem;
+
+rt_err_t zmodem_rx_ind(rt_device_t dev, rt_size_t size)
+{
+    /* release semaphore */
+    rt_sem_release(&zmodem.zsem);
+
+    return RT_EOK;
+}
+
+void finsh_rz(void *parameter)
+{
+	char *path;
+    rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);
+    rt_uint8_t flag;	
+
+	flag = RT_DEVICE_FLAG_STREAM;
+    zmodem.device->flag &=(~flag);
+    rt_sem_init(&(zmodem.zsem), "zsem", 0, 0);
+	path = rt_thread_self()->parameter;
+    /* save old rx_indicate	*/
+    rx_indicate = zmodem.device->rx_indicate;
+    /* set new rx_indicate */
+    rt_device_set_rx_indicate(zmodem.device, zmodem_rx_ind);
+	/* start receive remote files */
+    zr_start(path);
+	zmodem.device->flag |=flag;
+    /* recovery old rx_indicate	*/
+    rt_device_set_rx_indicate(zmodem.device, rx_indicate);
+    /* finsh>> */
+    rt_kprintf(FINSH_PROMPT);
+}
+void finsh_sz(void *parameter)
+{
+	char *path;
+    rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);
+    rt_uint8_t flag;	
+
+	flag = RT_DEVICE_FLAG_STREAM;
+    zmodem.device->flag &=(~flag);
+    rt_sem_init(&(zmodem.zsem), "zsem", 0, 0);
+	path = rt_thread_self()->parameter;
+	/* save old rx_indicate	*/
+    rx_indicate = zmodem.device->rx_indicate;
+	/* set new rx_indicate */
+    rt_device_set_rx_indicate(zmodem.device, zmodem_rx_ind);
+	zs_start(path);
+	zmodem.device->flag |=flag;
+    /* recovery old rx_indicate	*/
+    rt_device_set_rx_indicate(zmodem.device, rx_indicate);
+    /* finsh>> */
+    rt_kprintf(FINSH_PROMPT);
+}
+
+#ifdef RT_USING_FINSH
+#include <finsh.h>
+#include <shell.h>
+
+static void rz(char *para)
+{
+    rt_thread_t init_thread;
+    rt_device_t device;
+    const char* device_name = finsh_get_device();
+
+    device = rt_device_find(device_name);
+    if( device == RT_NULL )
+    {
+        rt_kprintf("%s not find\r\n",device_name);
+    }
+    zmodem.device = device;
+    init_thread = rt_thread_create("rz",
+                                   finsh_rz,
+                                   (void*)para,
+                                   2048,
+                                   rt_thread_self()->current_priority+1,
+                                   20);
+
+    if (init_thread != RT_NULL) rt_thread_startup(init_thread);
+}
+FINSH_FUNCTION_EXPORT(rz, receive files by zmodem protocol)
+static void sz(char *para)
+{
+    rt_thread_t init_thread;
+    rt_device_t device;
+    const char* device_name = finsh_get_device();
+
+    device = rt_device_find(device_name);
+    if( device == RT_NULL )
+    {
+        rt_kprintf("%s not find\r\n",device_name);
+    }
+    zmodem.device = device;
+    init_thread = rt_thread_create("sz",
+                                   finsh_sz,
+                                   (void*)para,
+                                   2048,
+                                   rt_thread_self()->current_priority+1,
+                                   20);
+
+    if (init_thread != RT_NULL) rt_thread_startup(init_thread);
+}
+FINSH_FUNCTION_EXPORT(sz, send files by zmodem protocol)
+#endif