První commit: vychází se z programu taptoser

2 files changed, 794 insertions, 0 deletions

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..ffe0501
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,8 @@
+PROJECT=sercp
+all:
+	gcc $(PROJECT).c -o $(PROJECT) -Wall -pedantic -MP -MD -std=gnu11 -Werror=format-security -O2
+debug:
+	gcc $(PROJECT).c -o $(PROJECT) -Wall -pedantic -MP -MD -std=gnu11 -Werror=format-security -g -O0
+
+clean:
+	rm -f $(PROJECT) $(PROJECT).d $(PROJECT).o
diff --git a/sercp.c b/sercp.c
new file mode 100644
index 0000000..05d2a14
--- /dev/null
+++ b/sercp.c
@@ -0,0 +1,786 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <stdint.h>
+#include <getopt.h>
+#include <termios.h>
+#include <error.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/signal.h>
+#include <fcntl.h>
+#include <poll.h>
+
+#define false 0
+#define FALSE 0
+#define true 1
+#define TRUE 1
+
+
+// SERIAL
+char MODEMDEVICE[64];
+FILE *tapout_fd = NULL;
+int is_outfile = 0;
+int baud_rate = 0;
+int wait_us = 200;
+int wait_ms	= 800;
+#define FILENAME_LENGTH 400
+char output_dump_file[FILENAME_LENGTH];
+char tap_file[FILENAME_LENGTH];
+unsigned char in_buff[65538];
+unsigned char *p_buff;
+unsigned int is_continue = 1;
+unsigned int is_binary = 0;
+struct pollfd spolfd_serial[1];	  // pole descriptoru pro poll
+
+static int inp_indx = 0;
+int serial_fd;
+size_t out_indx;
+struct sigaction saterm;           /* definition of signal action */
+
+float width;		// width of terminal
+long pos = 0;
+int scp = 0;
+int is_scp_read = 0;
+
+typedef struct {
+	uint16_t block_len;
+	uint8_t  block_xor;
+	uint8_t  block_sum;
+} __attribute__((packed))  fi_sum;
+
+typedef struct {
+	uint16_t length;		// delka dat ve fileinfo
+	uint8_t h_xor;			// xor bajtu fileinfa od fi_numblocks
+	uint8_t h_sum;			// sum bajtu fileinfa od fi_numblocks
+	uint8_t fi_numblocks;	// pocet bloku
+	uint8_t fi_name[64];	// jmeno souboru - prozatim musi byt ve fromatu 8.3 - kvuli esxdosu
+	uint8_t fi_date[8];		// nepouzito
+	uint8_t fi_time[8];		// nepouzito
+	fi_sum fi_blocks[256];	// delky a soucty bloku
+} __attribute__((packed)) FILEINFO;
+
+FILEINFO fileinfo;
+
+
+void usage(void) {
+	printf ("Tap file over serial port uploader/downloader. (c)2012-2015 Pavel Vymetálek <pavel@vym.cz>\n");
+	printf ("Based on utility tapheader: http://zeroteam.sk/tapheader.html (c)2012 Michal Jurica <mike@zeroteam.sk>\n");
+	printf ("Usage:\ntaptoser [-v] [-h] [-o filename.tap] [-b|--baud baud_rate] -d /dev/serial tap_file\n");
+	printf ("\t-v, --version\tShow version info\n");
+	printf ("\t-h, --help\tShow this text\n");
+	printf ("\t-d, --device\tCommunication device\n");
+	printf ("\t-w, --wait\tWaiting in microseconds between transmitted bytes. Default is -w 200us\n");
+	printf ("\t-b, --baud\tSet the communication speed. 4800Bd, 9600Bd, 19200Bd and 57600Bd (default) are supported\n");
+	printf ("\t-B, --binary\tBinary output - received tap from ZX Spectrum will save without all tap's specific mishmash\n");
+	printf ("\t-o, --outfile\tOutput file. Usualy *.tap or *.bin with in --binary mode\n");
+	printf ("SCP mode -----\n");
+	printf ("\t-s, --scp\tSCP mode - sent files with fileinfo 1109bytes\n");
+	printf ("\t-r, --read\tread file\n");
+	printf ("\t-w, --wait\tWaiting in milliseconds between transmitted blocks. Default is -w 800 milliseconds\n");
+}
+
+void Set_DTR(unsigned short level) {
+	int status;
+	ioctl(serial_fd, TIOCMGET, &status);
+	if (level) {
+		status |= TIOCM_DTR;
+	} else {
+		status &= ~TIOCM_DTR;
+	}
+	ioctl(serial_fd, TIOCMSET, &status);
+}
+
+void TestCts(void) {
+	int status;
+	do {
+		ioctl(serial_fd, TIOCMGET, &status);
+		if (status & 0x20) break;
+		usleep (100);
+		if (is_continue == 0) return;
+		//		printf ("status: %X\n",status);
+	} while (1);
+}
+
+
+void TestArgs (int argc, char *argv[])
+{
+	int c;
+	while (1) {
+		int option_index = 0;
+		static struct option long_options[] = {
+ 			{"outfile", required_argument, NULL, 'o'},
+			{"device", required_argument, NULL, 'd'},
+			{"baud", required_argument, NULL, 'b'},
+			{"wait", required_argument, NULL, 'w'},
+			{"scp", no_argument, NULL, 's'},
+			{"read", no_argument, NULL, 'r'},
+			{"binary", no_argument, NULL, 'B'},
+			{"version", no_argument, NULL, 'v'},
+			{"help", no_argument, NULL, 'h'},
+			{0, 0, 0, 0}
+		};
+		c = getopt_long (argc, argv, "o:d:b:w:srBvh", long_options, &option_index);
+		if (c == -1) {
+			// konec parametru
+			break;
+		}
+		switch (c) {
+			case 'h':
+				usage();
+				exit(1);
+				break;
+			case 'b':
+				baud_rate = atoi(optarg);
+				break;
+			case 'w':
+				wait_us = atoi(optarg);
+				wait_ms = atoi(optarg);
+				break;
+			case 's':
+				printf ("Serial CP mode is activated\n");
+				scp = 1;
+				break;
+			case 'r':
+				printf ("scp read...\n");
+				is_scp_read = 1;
+				break;
+			case 'd':
+				strncpy(MODEMDEVICE, optarg, strlen(optarg));
+// 				printf ("Serial port: %s\n", MODEMDEVICE);
+				break;
+			case 'o':
+				strncpy (output_dump_file, optarg, strlen(optarg));
+				is_outfile = 1;
+				break;
+			case 'B':
+				printf ("Running in binary output mode\n");
+				is_binary = 1;
+				break;
+			case 'v':
+				printf ("Version 0.9.1 2015-07-22\n");
+				exit(1);
+				break;
+			default:
+				break;
+		}
+	}
+	if (optind < argc) {
+		while (optind < argc){
+			strncpy (&tap_file[0], argv[optind++], 63);		// input tap file name - without option switch
+		}
+	}
+}
+
+
+// from tapheader utility
+unsigned int h_len;
+
+unsigned int getword(unsigned char* data) {
+	return *data + 256 * (*(data + 1));
+}
+
+void tooshort(FILE *fd) {
+	printf("Input file too short.\n\n");
+	fclose(fd);
+	exit(2);
+}
+
+// decode header1
+void decode(unsigned char *header) {
+	char name[11];
+	unsigned int n;
+	printf("\n");
+	strncpy(name, (char*)(header+2), 10);
+	name[10] = '\0';
+	printf("Filename: %12s \n", name);
+	printf("Flag: %4u ", (unsigned int)*header);
+	n = getword(header+14);
+	h_len = getword(header+12);
+
+	switch(*(header+1)) {
+		case '\0':
+			printf("Type: 0 => program\nProgram length: %6u bytes ", h_len);
+			if (n < 32768)	printf("Runs from line %5u\t", n);
+			printf("Length without variables: %5u bytes ", getword(header+16));
+			break;
+		case '\1':
+			printf("Type: 1 => number array\tLength: %6u bytes", h_len);
+			break;
+		case '\2':
+			printf("Type: 2 => character array\tLength: %6u bytes", h_len);
+			break;
+		case '\3':
+			if (n == 16384 && h_len == 6912)
+				printf("Type: 3 => screen image\n");
+			else
+				printf("Type: 3 => bytes  "
+					"Start address: %5u\t"
+					"Length: %6u bytes\t3rd param: %4u",
+					n, h_len, getword(header+16));
+			break;
+	}
+	printf("\n");
+}
+
+void signal_handler_sigterm (int status) {
+	// CTRL+C pressed
+	is_continue = 0; 	// do not continue
+}
+
+int GetTerminalWidth(void) {
+	struct winsize termsize;
+	ioctl (STDOUT_FILENO, TIOCGWINSZ, &termsize);
+	return (termsize.ws_col);
+}
+
+#define PROGRESS_PERCENT	0
+#define PROGRESS_COMPLETTE	1
+#define PROGRESS_ERROR_CSUM	2
+
+void DoProgress(size_t pos, size_t max, unsigned char csum_ok) {
+	width = GetTerminalWidth();
+	float percent, p, m;
+	int imax = width - 40;
+	int ipercent;
+	int px;
+	char progress_char;
+	p = pos;
+	m = max;
+	percent = 100 / m * p;
+	ipercent = percent / 100 * imax;
+	if (is_binary) progress_char = '#';
+	else  progress_char = '=';
+	printf ("Proceed bytes: %6d/%6d [", (int) pos, (int)max);
+	for (px = 0; px < imax; px++) {
+		if (px < ipercent) printf ("%c", progress_char);
+		else printf (" ");
+	}
+	if (csum_ok == 0) {
+		printf ("] %3d %%\r", (int)percent);
+	} else if (csum_ok == 1) {
+		printf ("]  OK  \r");
+	} else {
+		printf ("]  ERR \r");
+	}
+	fflush (stdout);
+}
+
+#define HEADER_RAW_LEN	21
+
+void RecvTap() {
+	unsigned int err;
+	size_t len;
+	int result;
+	size_t block_pos = 0, last_block_pos = 0;
+	size_t block_len = 10000;
+	size_t tap_pos = 0;
+	unsigned char xor_csum, xor_csum_ok;
+	unsigned char *p_write;
+	unsigned char block_type;				// typ bloku 255 data  0 - hlavicka
+	unsigned char recv_status = 0;			// 0 - zacatek, 1 - hlavicka nactena,  2 - blok se nacita, 3- header less
+	tapout_fd = fopen (output_dump_file, "a");
+	if (tapout_fd == NULL) {
+		err = errno;
+		error (1, err, "can't open output file");
+	}
+	printf("Output file is: %s\n", output_dump_file);
+	p_buff = in_buff;
+	p_write = in_buff;
+	while (is_continue) {
+		result = poll (spolfd_serial, 1, 200);		// 200ms timeout
+		if (result == 0) {
+			// nic neprislo
+			continue;
+		}
+		if (spolfd_serial[0].revents & POLLIN) {
+			len = read (serial_fd, p_buff, 256);
+			block_pos += len;
+			p_buff += len;
+			if (is_binary == 0) {
+				// ulozeni dat ze seriaku jako tap file
+				while (len) {
+					fputc(*p_write, tapout_fd);
+					p_write++;
+					len--;
+				}
+			}
+			if (block_pos != last_block_pos && recv_status >= 2) {
+				last_block_pos = block_pos;
+				DoProgress(block_pos, block_len+2, PROGRESS_PERCENT);
+			}
+			if (block_pos >= HEADER_RAW_LEN && recv_status == 0) {
+				recv_status = 1;		// hlavicka nactena
+				block_len = getword(in_buff);
+				block_type = *(in_buff + 2);
+				if (block_type == 0) {
+					// Hlavicka komplet
+					decode (in_buff + 2);
+					block_len = 0;
+					block_pos = 0;
+					xor_csum = 0;
+					recv_status = 0;
+					p_buff = in_buff;
+					p_write = in_buff;
+				} else if (block_type == 255) {
+					// data block
+					printf ("Data block len: %6zu\n", block_len-2);
+					recv_status = 3;
+				}
+				continue;
+			}
+			if (block_pos > HEADER_RAW_LEN + 3 && recv_status == 1) {
+				// nactena delka dalsiho bloku
+				recv_status = 2;
+				block_len = getword(in_buff + HEADER_RAW_LEN);
+				block_type = *(in_buff + HEADER_RAW_LEN + 2);
+				printf ("Block len: %zu Block type: %d\n", block_len, block_type);
+				continue;
+			}
+			if (block_len + 2 == block_pos && recv_status > 2) {
+				// Blok komplet nacten cekej novy
+				block_len = getword(in_buff);
+				block_type = *(in_buff + 2);
+				for (tap_pos = 0; tap_pos < block_len -1; tap_pos++) {
+					xor_csum ^= *(in_buff + 2 + tap_pos);
+				}
+				xor_csum_ok = *(in_buff + 2 + block_len - 1);
+				if (xor_csum == xor_csum_ok) {
+					DoProgress(block_pos, block_len+2, PROGRESS_COMPLETTE);	// vypis jeste OK
+					if (is_binary == 1) {
+						// binarni vystup do souboru
+						for (tap_pos = 0; tap_pos < block_len - 2; tap_pos++){
+							fputc(*(in_buff + 3 + tap_pos), tapout_fd);	// uloz do souboru
+						}
+						DoProgress(tap_pos, block_len - 2, PROGRESS_COMPLETTE);
+					}
+// 					printf ("Checksum OK\n");
+				} else {
+					DoProgress(block_pos, block_len+2, PROGRESS_ERROR_CSUM);	// vypis error CSUM
+				}
+				block_len = 0;
+				block_pos = 0;
+				xor_csum = 0;
+				recv_status = 0;
+				p_buff = in_buff;
+				p_write = in_buff;
+				continue;
+			}
+		}
+	}
+	fclose (tapout_fd);
+	printf ("\n\nulozeno...\n");
+}
+
+void SendByte(unsigned char *p_dato) {
+	TestCts();
+	write (serial_fd, p_dato, 1);
+// 	tcdrain(serial_fd);		// better solution, but usleep at the next line is
+	usleep (wait_us);			// faster solution, TODO change sleep time according to serial communication speed  200us is for 57600Bd
+}
+
+void SendTap() {
+	FILE *tap_fd;
+	unsigned int err, no, len;
+	struct stat st;
+	unsigned char header[19];
+
+	no = stat(tap_file, &st);
+	if (no != 0) {
+		err = errno;
+		error(1, err, "can't stat input file");
+	}
+
+	tap_fd = fopen(tap_file, "r");
+	if (tap_fd == NULL)	{
+		err = errno;
+		error(1, err, "can't open input file");
+	}
+	while (pos < st.st_size) {
+		if (is_continue == 0) break;
+		pos += no = fread(header, 1, 2, tap_fd);
+		if (no != 2)
+			tooshort(tap_fd);
+		for (out_indx = 0; out_indx < 2; out_indx++) {
+			SendByte(&header[out_indx]);
+		}
+		no = getword(header);
+		if (no == 19) /* HEADER */
+		{
+			pos += no = fread(header, 1, 19, tap_fd);
+			if (no != 19)
+				tooshort(tap_fd);
+// 			printf ("Header len: %d\n", no);
+			decode(header);
+			for (out_indx = 0; out_indx < 19; out_indx++) {
+				SendByte(&header[out_indx]);
+			}
+		} else {
+			if (h_len != no - 2) { /* zobrazuj iba bloky bez hl. */
+				len = no;
+				printf ("NO datablock without header: %d\n", no);
+				printf("Type: datablock\nLength: %u\n", len - 2);
+				pos += no = fread(header, 1, 1, tap_fd);
+				SendByte(header);
+				DoProgress(1, no, PROGRESS_PERCENT);
+				if (no != 1) tooshort(tap_fd);
+				printf("Flag: %u\n\n", (int)*header);
+				len--;
+			} else {
+				len = no;
+			}
+			pos += len;
+			for (out_indx = 0; out_indx < len; out_indx++) {
+				fread(header, 1, 1, tap_fd);
+				SendByte(header);
+				DoProgress(out_indx+1, len, PROGRESS_PERCENT);
+				if (is_continue == 0) break;
+			}
+			printf ("\n");
+			usleep (800000);
+		}
+	}
+	fclose(tap_fd);
+}
+
+
+int CheckFileInfo(FILEINFO* p_fi) {
+	unsigned char *p_fiinfo = (unsigned char*)p_fi;
+	uint16_t fi_len;
+	uint8_t fi_xor = 0;
+	uint8_t fi_sum = 0;
+	fi_len = p_fi->length;
+	p_fiinfo += 4;			// suma se bude pocitat od offsetu 4
+	for (uint16_t indx = 0; indx < (fi_len-4); indx++) {
+		fi_xor ^= *p_fiinfo;
+		fi_sum += *p_fiinfo;
+		p_fiinfo++;
+	}
+	if (fi_xor == p_fi->h_xor && fi_sum == p_fi->h_sum) {
+		return 0;
+	}
+	return -1;
+}
+
+void CountFileInfoChecksum(FILEINFO* p_fi) {
+	unsigned char *p_fiinfo = (unsigned char*)p_fi;
+	uint16_t fi_len;
+	uint8_t fi_xor = 0;
+	uint8_t fi_sum = 0;
+	fi_len = p_fi->length;
+	p_fiinfo += 4;			// suma se bude pocitat od offsetu 4
+	for (uint16_t indx = 0; indx < (fi_len-4); indx++) {
+		fi_xor ^= *p_fiinfo;
+		fi_sum += *p_fiinfo;
+		p_fiinfo++;
+	}
+	p_fi->h_xor = fi_xor;
+	p_fi->h_sum = fi_sum;
+}
+
+int CheckSumBlock(FILEINFO* p_fi, uint8_t block_indx, uint8_t *p_buffer) {
+	uint16_t block_len;
+	uint8_t b_xor = 0;
+	uint8_t b_sum = 0;
+	uint8_t block_xor;
+	uint8_t block_sum;
+	block_len = p_fi->fi_blocks[block_indx].block_len;
+	block_sum = p_fi->fi_blocks[block_indx].block_sum;
+	block_xor = p_fi->fi_blocks[block_indx].block_xor;
+	for (uint16_t indx = 0; indx < block_len; indx++) {
+		b_xor ^= *p_buffer;
+		b_sum += *p_buffer;
+		p_buffer++;
+	}
+	if (b_xor == block_xor && b_sum == block_sum) {
+		return 0;	// vrat se, je to v poradku
+	}
+	return -1;		// vrat se s chybou bloku
+}
+
+void CountSumBlock(FILEINFO* p_fi, uint8_t block_indx, uint8_t *p_buffer, uint16_t block_len) {
+	uint8_t block_xor = 0;
+	uint8_t block_sum = 0;
+	for (uint16_t indx = 0; indx < block_len; indx++) {
+		block_xor ^= *p_buffer;
+		block_sum += *p_buffer;
+		p_buffer++;
+	}
+	p_fi->fi_blocks[block_indx].block_len = block_len;
+	p_fi->fi_blocks[block_indx].block_sum = block_sum;
+	p_fi->fi_blocks[block_indx].block_xor = block_xor;
+}
+
+
+unsigned char buff[32768];
+
+uint32_t GetOverallLen(FILEINFO *p_fi) {
+	uint32_t overall_len = 0;
+	uint8_t block_num = p_fi->fi_numblocks;
+	for (uint8_t indx = 0; indx < block_num; indx++) {
+		overall_len += p_fi->fi_blocks[indx].block_len;
+	}
+	return overall_len;
+}
+
+void RecvSCP(void) {
+	int recv_phase = 0;			// 0 - fileinfo, 1 - blok 16kiB, 2 - posledni blok
+	uint8_t block_index = 0;
+	int result;
+	uint16_t len;
+	uint16_t length = 0;
+	uint16_t expected_len = 0;
+// 	uint8_t expected_xor;
+// 	uint8_t expected_sum;
+	uint32_t overall_length = 0;		// celkova delka souboru
+	uint32_t recv_length = 0;			// zatim prijatych dat ze souboru
+	int err;
+
+	FILEINFO *p_fileinfo = &fileinfo;
+	unsigned char *p_buff = buff;
+	tapout_fd = NULL;
+
+	memset (p_fileinfo, 0, sizeof(fileinfo));
+	while (is_continue) {
+		result = poll (spolfd_serial, 1, 200);		// 200ms timeout
+		if (result == 0) {
+			// nic neprislo
+			continue;
+		}
+		switch (recv_phase) {
+			case 0:
+				// prijem fileinfo
+				if (spolfd_serial[0].revents & POLLIN) {
+					len = read (serial_fd, p_buff, sizeof(fileinfo));
+					p_buff += len;
+					length += len;
+					if (length == sizeof(fileinfo)) {
+						memcpy((unsigned char*) p_fileinfo, buff, sizeof(fileinfo));
+						if (CheckFileInfo(p_fileinfo) == 0) {
+							printf("Prijato fileinfo\n");
+							overall_length = GetOverallLen(p_fileinfo);
+							printf("Nazev souboru: \"%s\" pocet bloku:%d, delka souboru: %u\n", p_fileinfo->fi_name, p_fileinfo->fi_numblocks, overall_length);
+							recv_phase++;			// priste se uz prijimaji bloky
+							block_index = 0;		// zacina se prvnim blokem
+							p_buff = buff;			// buffer na zacatek
+							length = 0;
+							expected_len = p_fileinfo->fi_blocks[block_index].block_len;
+
+
+							tapout_fd = fopen ((char*)p_fileinfo->fi_name, "w");
+							if (tapout_fd == NULL) {
+								err = errno;
+								error (1, err, "can't open output file");
+							}
+// 							expected_xor = p_fileinfo->fi_blocks[block_index].block_xor;
+// 							expected_sum = p_fileinfo->fi_blocks[block_index].block_sum;
+						} else {
+							printf("Fileinfo neni v cajku. Koncim...\n");
+							break;
+						}
+						break;
+					} else if (length > sizeof(fileinfo)){
+						len = read (serial_fd, p_buff, sizeof(fileinfo));
+						printf("Nejaky bordel. Koncim...\n");
+						break;
+					}
+				}
+				break;
+			case 1:
+				// prijem datoveho bloku - max. delka 16kiB
+				if (spolfd_serial[0].revents & POLLIN) {
+					len = read (serial_fd, p_buff, expected_len);
+					p_buff += len;
+					expected_len -= len;
+					length += len;
+					recv_length += len;
+					DoProgress(recv_length, overall_length, PROGRESS_PERCENT);
+					if (length == p_fileinfo->fi_blocks[block_index].block_len) {
+						// prijaty prvni block
+// 						printf("Prijaty blok c.%d delky: %d\n", block_index, length);
+						if (CheckSumBlock(p_fileinfo, block_index, buff) == 0) {
+							// blok je v cajku - zapsat do souboru
+							if (tapout_fd) fwrite(buff, length, 1, tapout_fd);
+						}
+						length = 0;
+						p_buff = buff;
+						block_index++;
+						expected_len = p_fileinfo->fi_blocks[block_index].block_len;
+					}
+					if (expected_len == 0 || block_index == 255) {
+						printf ("\nKonec prenosu\n");
+						recv_phase++;
+						is_continue = 0;
+						break;
+					}
+				} else if (length > 16384) {
+						len = read (serial_fd, p_buff, 16384);
+						printf("Nejaky bordel. Koncim...\n");
+						break;
+				}
+			}
+	}
+	if (tapout_fd) fclose (tapout_fd);
+	printf ("\n\nulozeno...\n");
+}
+
+void SendSCP(void) {
+	FILE *tap_fd;
+	unsigned int err, no, len;
+	struct stat st;
+	FILEINFO *p_fileinfo = &fileinfo;
+	unsigned char *p_buff = buff;
+	uint32_t file_len;
+	uint8_t num_blocks = 0;
+	ssize_t odeslano;
+	uint32_t len_sent;
+	uint16_t sent_size;
+	uint32_t overall_sent;
+
+
+	no = stat(tap_file, &st);
+	if (no != 0) {
+		err = errno;
+		error(1, err, "can't stat input file");
+	}
+
+	tap_fd = fopen(tap_file, "r");
+	if (tap_fd == NULL)	{
+		err = errno;
+		error(1, err, "can't open input file");
+	}
+	printf ("Soubor %s delky: %ld\n", tap_file, st.st_size);
+	memset (p_fileinfo, 0, sizeof(fileinfo));		// smazat fileinfo
+
+	memcpy(p_fileinfo->fi_name, tap_file, strlen(tap_file));
+	file_len = (uint32_t) st.st_size;
+	while (file_len) {
+		len = fread(buff, 1, 16384, tap_fd);			// precti 16kiB dat
+		CountSumBlock(p_fileinfo, num_blocks, buff, len);
+// 		printf ("Blok c. %d, delka: %d\n", num_blocks, len);
+		file_len -= len;
+		num_blocks++;
+	}
+	p_fileinfo->fi_numblocks = num_blocks;
+	p_fileinfo->length = num_blocks*4 + 85;
+	CountFileInfoChecksum(p_fileinfo);
+	odeslano = write (serial_fd, (void*)p_fileinfo, sizeof(fileinfo));
+	tcdrain(serial_fd);
+	printf("Fileinfo sent...\n");
+	// TODO Cekat pauzu mezi bloky
+	usleep (wait_ms * 1000);
+
+	rewind(tap_fd);				// prenaseny soubor na zacatek
+	file_len = (uint32_t) st.st_size;
+	overall_sent = 0;
+	while (file_len && is_continue) {
+		len = fread(buff, 1, 16384, tap_fd);			// precti 16kiB dat
+		p_buff = buff;
+		sent_size = 256;
+		len_sent = len;
+		while (len_sent && is_continue) {
+			odeslano = write (serial_fd, (void*)p_buff, sent_size);
+			tcdrain(serial_fd);
+			p_buff += odeslano;
+			overall_sent += odeslano;
+			len_sent -= odeslano;
+			if (len_sent < 256) {
+				sent_size = len_sent;
+			}
+			DoProgress(overall_sent, st.st_size, PROGRESS_PERCENT);
+		}
+		usleep (wait_ms * 1000);
+		file_len -= len;
+	}
+	printf("\nFile sent...\n");
+	fclose(tap_fd);
+}
+
+int main(int argc, char** argv, char** env)
+{
+	// osetreni breaku ^C
+	saterm.sa_handler = signal_handler_sigterm;
+	saterm.sa_flags = 0;
+	sigaction (SIGINT, &saterm, NULL);
+	width = GetTerminalWidth();
+
+	// nastaveni serioveho portu
+	struct termios oldtio, newtio;
+	inp_indx = 0;
+	if (argc < 3) {
+		printf("You must specify the Serial device and file\n");
+		usage();
+		exit(1);
+	}
+	TestArgs (argc, argv);
+	/* open the device to be non-blocking (read will return immediatly) */
+	serial_fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY | O_NONBLOCK);
+	if (serial_fd < 0) {
+		perror(MODEMDEVICE);
+		return(-1);
+	}
+	tcgetattr(serial_fd, &oldtio); /* save current port settings */
+	switch (baud_rate){
+		default:
+			baud_rate = 57600;			// default speed
+			newtio.c_cflag = B57600 | CS8 | CLOCAL | CREAD | CSTOPB;// | CRTSCTS;
+			break;
+		case 115200:
+			newtio.c_cflag = B115200 | CS8 | CLOCAL | CREAD | CSTOPB | CRTSCTS;
+			break;
+		case 57600:
+			newtio.c_cflag = B57600 | CS8 | CLOCAL | CREAD | CSTOPB | CRTSCTS;
+			break;
+		case 38400:
+			newtio.c_cflag = B38400 | CS8 | CLOCAL | CREAD | CRTSCTS;	// dva stopbity jsou nastaveny vsude, ale tady ne
+			break;
+		case 19200:
+			newtio.c_cflag = B19200 | CS8 | CLOCAL | CREAD | CSTOPB | CRTSCTS;
+			break;
+		case 9600:
+			newtio.c_cflag = B9600 | CS8 | CLOCAL | CREAD | CSTOPB | CRTSCTS;
+			break;
+		case 4800:
+			newtio.c_cflag = B4800 | CS8 | CLOCAL | CREAD | CSTOPB | CRTSCTS;
+			break;
+		case 2400:
+			newtio.c_cflag = B2400 | CS8 | CLOCAL | CREAD | CSTOPB | CRTSCTS;
+			break;
+		case 1200:
+			newtio.c_cflag = B1200 | CS8 | CLOCAL | CREAD | CSTOPB | CRTSCTS;
+			break;
+	}
+	newtio.c_cflag |= CRTSCTS;
+	printf ("Serial device: %s, communication speed is: %d Bd\n", MODEMDEVICE, baud_rate);
+// 	newtio.c_iflag &= ~(IXON | IXOFF | IXANY);	// vypne XON/XOFF
+	newtio.c_iflag = 0;		//IGNPAR | IXOFF;
+	newtio.c_oflag = 0;
+// 	newtio.c_oflag &= ~OPOST;
+	newtio.c_lflag = 0; //NOFLSH;
+	newtio.c_cc[VMIN] = 0;
+	newtio.c_cc[VTIME] = 10;
+	tcsetattr(serial_fd, TCSANOW, &newtio);
+	tcflush(serial_fd, TCIOFLUSH);
+	spolfd_serial[0].fd = serial_fd;		// nastaveni hlidaneho descriptoru
+	spolfd_serial[0].events = POLLIN;		// hlidaji se data na vstupu
+
+	if (scp) {
+		// serial copy activated
+		if (is_scp_read) {
+			RecvSCP();
+		} else {
+			SendSCP();
+		}
+	} else {
+		Set_DTR(true);		// PC can read data from speccy everytime
+		if (is_outfile) {
+			RecvTap();	// cteni tap souboru ze seriaku a zapis na disk pocitace
+		} else {
+			SendTap();	// poslat na seriak tap soubor do spectra
+		}
+	}
+	close (serial_fd);
+	return 0;
+}