[saturn.git] / datalink.c

/*
 * Tool for Saturn USB DataLink device
 * Copyright (c) 2014 notaz
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be 
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>

// ugh.. avoid conflicting winsize/termio from sys/ioctl.h
#define winsize winsize_
#define termio termio_
#include <linux/termios.h>

#define BAUD_RATE 375000
#define MAX_DATA_SIZE 191

static int setup(int fd)
{
	struct termios2 tty;
	//struct termios tty;
	int ret;

	memset(&tty, 0, sizeof(tty));

	//ret = tcgetattr(fd, &tty);
	ret = ioctl(fd, TCGETS2, &tty);
	if (ret != 0) {
		perror("TCGETS2");
		return ret;
	}

	tty.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP
			| INLCR | IGNCR | ICRNL | IXON);
	tty.c_oflag &= ~OPOST;
	tty.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
	tty.c_cflag &= ~(CSIZE | PARENB);
	tty.c_cflag |= CS8 | CSTOPB | CREAD;
	tty.c_cflag &= ~CBAUD;
	tty.c_cflag |= BOTHER;
	tty.c_ispeed =
	tty.c_ospeed = BAUD_RATE;

	tty.c_cc[VMIN] = 1;
	tty.c_cc[VTIME] = 0;	// read timeout deciseconds

	//ret = tcsetattr(fd, TCSANOW, &tty);
	ret = ioctl(fd, TCSETS2, &tty);
	if (ret != 0) {
		perror("TCSETS2");
		return ret;
	}

	memset(&tty, 0, sizeof(tty));
	ret = ioctl(fd, TCGETS2, &tty);
	if (ret != 0) {
		perror("TCGETS2");
		return ret;
	}

	if (tty.c_ispeed != BAUD_RATE || tty.c_ospeed != BAUD_RATE) {
		fprintf(stderr, "warning: could not set %d baud, got:\n",
			BAUD_RATE);
		fprintf(stderr, "c_ispeed: %d\n", tty.c_ispeed);
		fprintf(stderr, "c_ospeed: %d\n", tty.c_ospeed);
		fprintf(stderr, "c_cflag: 0%o\n", tty.c_cflag);
	}

	return 0;
}

static void dump_pkt(const uint8_t *buf, size_t size, const char *msg)
{
	size_t i;

	printf("%s\n", msg);

	for (i = 0; i < size; ) {
		printf("%02zx:", i);
		while (i < size) {
			printf(" %02x", buf[i]);
			i++;
			if ((i & 15) == 0)
				break;
		}
		printf("\n");
	}
}

static uint8_t sum(const uint8_t *buf, size_t size)
{
	uint8_t ret = 0;
	size_t i;

	for (i = 0; i < size; i++)
		ret += buf[i];

	return ret;
}

static int send_pkt(int fd, uint8_t cmd, uint32_t addr, uint8_t len,
	const void *data, size_t data_size)
{
	uint8_t pkt[200];
	int ret;

	pkt[0] = 0x5a;
	pkt[1] = 9 - 2 + data_size;
	pkt[2] = cmd;
	pkt[3] = addr >> 24;
	pkt[4] = addr >> 16;
	pkt[5] = addr >> 8;
	pkt[6] = addr;
	pkt[7] = len;
	if (data_size > 0)
		memcpy(&pkt[8], data, data_size);
	pkt[8 + data_size] = sum(&pkt[1], 8 + data_size - 1);

	// dump_pkt(pkt, 9 + data_size, "send:");

	ret = write(fd, pkt, 9 + data_size);
	if (ret != 9 + data_size) {
		fprintf(stderr, "write: %d/%zd, cmd %02x, addr %08x: ",
			ret, 9 + data_size, cmd, addr);
		perror("");
		dump_pkt(pkt, 9 + data_size, "");
		return -1;
	}

	return 0;
}

static int recv_pkt(int fd, uint8_t cmd, uint32_t addr,
	void *data, size_t data_size)
{
	size_t size = 9 + data_size;
	size_t got;
	uint8_t pkt[200];
	uint8_t csum;
	int ret;

	for (got = 0; got < size; ) {
		ret = read(fd, pkt + got, size);
		if (ret <= 0) {
			fprintf(stderr, "read: %d, %zd/%zd, "
					"cmd %02x, addr %08x: ",
				ret, got, size, cmd, addr);
			perror("");
			if (got > 0)
				dump_pkt(pkt, got, "received data:");
			return -1;
		}
		got += ret;
	}

	csum = sum(&pkt[1], size - 2);
	if (csum != pkt[size - 1]) {
		fprintf(stderr, "read: %zd, cmd %02x, addr %08x: "
				"checksum incorrect, expected %02x\n",
			got, cmd, addr, csum);
		dump_pkt(pkt, got, "");
		return -2;
	}

	if (pkt[0] != 0xa5 || pkt[1] != size - 2 || pkt[2] != 0xff) {
		fprintf(stderr, "read: %zd, cmd %02x, addr %08x: "
				"unexpected response header\n",
			got, cmd, addr);
		dump_pkt(pkt, got, "");
		return -2;
	}

	if (data_size != 0)
		memcpy(data, &pkt[8], data_size);

	// dump_pkt(pkt, got, "recv:");

	return 0;
}

static int do_rx(int fd, uint32_t addr, void *buf, size_t size)
{
	char *cbuf = buf;
	int ret;
	int len;

	/* must use at least 2 packets */
	if (size <= MAX_DATA_SIZE)
		len = size / 2;
	else
		len = MAX_DATA_SIZE;

	ret = send_pkt(fd, 0x01, addr, len, NULL, 0);
	if (ret != 0)
		return ret;

	ret = recv_pkt(fd, 0x01, addr, cbuf, len);
	if (ret != 0)
		return ret;

	addr += len;
	cbuf += len;
	size -= len;

	while (size > 0) {
		uint8_t cmd = size > MAX_DATA_SIZE ? 0x11 : 0x21;

		len = size;
		if (len > MAX_DATA_SIZE)
			len = MAX_DATA_SIZE;

		ret = send_pkt(fd, cmd, addr, len, NULL, 0);
		if (ret != 0)
			return ret;

		ret = recv_pkt(fd, 0x01, addr, cbuf, len);
		if (ret != 0)
			return ret;

		addr += len;
		cbuf += len;
		size -= len;
	}

	return 0;
}

static int do_tx(int fd, uint32_t addr, void *buf, size_t size, int exe)
{
	size_t size_last = size;
	uint32_t addr_last = addr;
	char *cbuf = buf;
	uint8_t cmd = 0x09;
	int ret;
	int len;

	if (size > MAX_DATA_SIZE) {
		/* skip first packet, we'll send it last */
		size_last = MAX_DATA_SIZE;
		addr += size_last;
		cbuf += size_last;
		size -= size_last;

		while (size > 0) {
			len = size;
			if (len > MAX_DATA_SIZE)
				len = MAX_DATA_SIZE;

			ret = send_pkt(fd, cmd, addr, len, cbuf, len);
			if (ret != 0)
				return ret;

			ret = recv_pkt(fd, cmd, addr, NULL, 0);
			if (ret != 0)
				return ret;

			addr += len;
			cbuf += len;
			size -= len;
		}
	}

	if (exe)
		cmd = 0x19;

	ret = send_pkt(fd, cmd, addr_last, size_last, buf, size_last);
	if (ret != 0)
		return ret;

	ret = recv_pkt(fd, cmd, addr_last, NULL, 0);
	if (ret != 0)
		return ret;

	return 0;
}

static void usage(const char *argv0)
{
	printf("usage:\n"
		"%s [dev <device>] command(s)\n"
		"commands:\n"
		"  rx <addr> <size> <outfile>\n"
		"  tx <addr> <size> <infile> [x]\n"
		"    <outfile> can be \"/hd/\" for a hexdump\n"
		"    x instructs to execute uploaded data\n"
		"    for tx, size 0 asks to use filesize\n", argv0);
	exit(1);
}

static void invarg(int argc, char *argv[], int arg)
{
	if (arg < argc)
		fprintf(stderr, "invalid arg %d: \"%s\"\n", arg, argv[arg]);
	else
		fprintf(stderr, "missing required argument %d\n", arg);
	exit(1);
}

int main(int argc, char *argv[])
{
	const char *portname = "/dev/ttyUSB0";
	const char *fname;
	struct stat st;
	void *buf = NULL;
	FILE *f = NULL;
	uint32_t addr;
	size_t size;
	char *endp;
	int arg = 1;
	int ret;
	int fd;

	if (argc < 2 || !strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))
		usage(argv[0]);

	if (!strcmp(argv[arg], "dev")) {
		arg++;
		if (argv[arg] != NULL)
			portname = argv[arg];
		else
			invarg(argc, argv, arg);
		arg++;
	}

	fd = open(portname, O_RDWR | O_NOCTTY | O_SYNC);
	if (fd < 0) {
		fprintf(stderr, "open %s: ", portname);
		perror("");
		return 1;
	}

	ret = setup(fd);
	if (ret)
		return ret;

	while (arg < argc)
	{
		if (!strcmp(argv[arg], "rx") ||
		    !strcmp(argv[arg], "tx"))
		{
			int tx = !strcmp(argv[arg], "tx");
			int exe = 0;

			if (argc - arg < 4)
				invarg(argc, argv, argc);

			endp = NULL;
			addr = strtoul(argv[++arg], &endp, 0);
			if (endp == NULL || *endp != 0)
				invarg(argc, argv, arg);

			endp = NULL;
			size = strtoul(argv[++arg], &endp, 0);
			if (endp == NULL || *endp != 0)
				invarg(argc, argv, arg);

			fname = argv[++arg];
			if (tx || strcmp(fname, "/hd/") != 0) {
				f = fopen(fname, tx ? "rb" : "wb");
				if (f == NULL) {
					fprintf(stderr, "open %s: \n",
						fname);
					perror("");
					return 1;
				}
			}

			if (tx && size == 0) {
				ret = fstat(fileno(f), &st);
				if (ret != 0) {
					fprintf(stderr, "fstat %s: \n",
						fname);
					perror("stat");
					return 1;
				}
				size = st.st_size;
			}

			if (size == 0) {
				fprintf(stderr, "size is 0\n");
				return 1;
			}

			buf = realloc(buf, size);
			if (buf == NULL) {
				fprintf(stderr, "OOM\n");
				return 1;
			}

			if (tx) {
				ret = fread(buf, 1, size, f);
				if (ret != size) {
					fprintf(stderr, "read %s: \n",
						fname);
					perror("");
					return 1;
				}

				if (arg + 1 < argc
				    && !strcmp(argv[arg + 1], "x"))
				{
					exe = 1;
					arg++;
				}

				ret = do_tx(fd, addr, buf, size, exe);
				if (ret != 0)
					return ret;
			}
			else {
				ret = do_rx(fd, addr, buf, size);
				if (ret != 0)
					return ret;

				if (f != NULL) {
					ret = fwrite(buf, 1, size, f);
					if (ret != size) {
						fprintf(stderr,
							"write %s: \n",
							fname);
						perror("");
						return 1;
					}
				}
				else {
					dump_pkt(buf, size, "");
				}
			}

			if (f != NULL) {
				fclose(f);
				f = NULL;
			}
			arg++;
		}
		else {
			invarg(argc, argv, arg);
		}
	}

	return 0;
}
Commit	Line	Data
01698af3	1	/*
	2	* Tool for Saturn USB DataLink device
	3	* Copyright (c) 2014 notaz
	4	*
	5	* Permission is hereby granted, free of charge, to any person obtaining
	6	* a copy of this software and associated documentation files (the
	7	* "Software"), to deal in the Software without restriction, including
	8	* without limitation the rights to use, copy, modify, merge, publish,
	9	* distribute, sublicense, and/or sell copies of the Software, and to
	10	* permit persons to whom the Software is furnished to do so, subject to
	11	* the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be
	14	* included in all copies or substantial portions of the Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	17	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	18	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	19	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	20	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	21	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	22	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	23	* SOFTWARE.
	24	*/
	25
	26	#include <stdio.h>
	27	#include <string.h>
	28	#include <stdlib.h>
	29	#include <string.h>
	30	#include <stdint.h>
	31	#include <sys/types.h>
	32	#include <sys/stat.h>
	33	#include <fcntl.h>
	34	#include <sys/ioctl.h>
	35	#include <unistd.h>
	36
	37	// ugh.. avoid conflicting winsize/termio from sys/ioctl.h
	38	#define winsize winsize_
	39	#define termio termio_
	40	#include <linux/termios.h>
	41
	42	#define BAUD_RATE 375000
	43	#define MAX_DATA_SIZE 191
	44
	45	static int setup(int fd)
	46	{
	47	struct termios2 tty;
	48	//struct termios tty;
	49	int ret;
	50
	51	memset(&tty, 0, sizeof(tty));
	52
	53	//ret = tcgetattr(fd, &tty);
	54	ret = ioctl(fd, TCGETS2, &tty);
	55	if (ret != 0) {
	56	perror("TCGETS2");
	57	return ret;
	58	}
	59
	60	tty.c_iflag &= ~(IGNBRK \| BRKINT \| PARMRK \| ISTRIP
	61	\| INLCR \| IGNCR \| ICRNL \| IXON);
	62	tty.c_oflag &= ~OPOST;
	63	tty.c_lflag &= ~(ECHO \| ECHONL \| ICANON \| ISIG \| IEXTEN);
	64	tty.c_cflag &= ~(CSIZE \| PARENB);
65	tty.c_cflag \|= CS8 \| CSTOPB \| CREAD;
66	tty.c_cflag &= ~CBAUD;
67	tty.c_cflag \|= BOTHER;
68	tty.c_ispeed =
69	tty.c_ospeed = BAUD_RATE;
70
71	tty.c_cc[VMIN] = 1;
72	tty.c_cc[VTIME] = 0; // read timeout deciseconds
73
74	//ret = tcsetattr(fd, TCSANOW, &tty);
75	ret = ioctl(fd, TCSETS2, &tty);
76	if (ret != 0) {
77	perror("TCSETS2");
78	return ret;
79	}
80
81	memset(&tty, 0, sizeof(tty));
82	ret = ioctl(fd, TCGETS2, &tty);
83	if (ret != 0) {
84	perror("TCGETS2");
85	return ret;
86	}
87
88	if (tty.c_ispeed != BAUD_RATE \|\| tty.c_ospeed != BAUD_RATE) {
89	fprintf(stderr, "warning: could not set %d baud, got:\n",
90	BAUD_RATE);
91	fprintf(stderr, "c_ispeed: %d\n", tty.c_ispeed);
92	fprintf(stderr, "c_ospeed: %d\n", tty.c_ospeed);
93	fprintf(stderr, "c_cflag: 0%o\n", tty.c_cflag);
94	}
95
96	return 0;
97	}
98
99	static void dump_pkt(const uint8_t buf, size_t size, const char msg)
100	{
101	size_t i;
102
103	printf("%s\n", msg);
104
105	for (i = 0; i < size; ) {
106	printf("%02zx:", i);
107	while (i < size) {
108	printf(" %02x", buf[i]);
109	i++;
110	if ((i & 15) == 0)
111	break;
112	}
113	printf("\n");
114	}
115	}
116
117	static uint8_t sum(const uint8_t *buf, size_t size)
118	{
119	uint8_t ret = 0;
120	size_t i;
121
122	for (i = 0; i < size; i++)
123	ret += buf[i];
124
125	return ret;
126	}
127
128	static int send_pkt(int fd, uint8_t cmd, uint32_t addr, uint8_t len,
129	const void *data, size_t data_size)
130	{
131	uint8_t pkt[200];
132	int ret;
133
134	pkt[0] = 0x5a;
135	pkt[1] = 9 - 2 + data_size;
136	pkt[2] = cmd;
137	pkt[3] = addr >> 24;
138	pkt[4] = addr >> 16;
139	pkt[5] = addr >> 8;
140	pkt[6] = addr;
141	pkt[7] = len;
142	if (data_size > 0)
143	memcpy(&pkt[8], data, data_size);
144	pkt[8 + data_size] = sum(&pkt[1], 8 + data_size - 1);
145
146	// dump_pkt(pkt, 9 + data_size, "send:");
147
148	ret = write(fd, pkt, 9 + data_size);
149	if (ret != 9 + data_size) {
150	fprintf(stderr, "write: %d/%zd, cmd %02x, addr %08x: ",
151	ret, 9 + data_size, cmd, addr);
152	perror("");
153	dump_pkt(pkt, 9 + data_size, "");
154	return -1;
155	}
156
157	return 0;
158	}
159
160	static int recv_pkt(int fd, uint8_t cmd, uint32_t addr,
161	void *data, size_t data_size)
162	{
163	size_t size = 9 + data_size;
164	size_t got;
165	uint8_t pkt[200];
166	uint8_t csum;
167	int ret;
168
169	for (got = 0; got < size; ) {
170	ret = read(fd, pkt + got, size);
171	if (ret <= 0) {
172	fprintf(stderr, "read: %d, %zd/%zd, "
173	"cmd %02x, addr %08x: ",
174	ret, got, size, cmd, addr);
175	perror("");
176	if (got > 0)
177	dump_pkt(pkt, got, "received data:");
178	return -1;
179	}
180	got += ret;
181	}
182
183	csum = sum(&pkt[1], size - 2);
184	if (csum != pkt[size - 1]) {
185	fprintf(stderr, "read: %zd, cmd %02x, addr %08x: "
186	"checksum incorrect, expected %02x\n",
187	got, cmd, addr, csum);
188	dump_pkt(pkt, got, "");
189	return -2;
190	}
191
192	if (pkt[0] != 0xa5 \|\| pkt[1] != size - 2 \|\| pkt[2] != 0xff) {
193	fprintf(stderr, "read: %zd, cmd %02x, addr %08x: "
194	"unexpected response header\n",
195	got, cmd, addr);
196	dump_pkt(pkt, got, "");
197	return -2;
198	}
199
200	if (data_size != 0)
201	memcpy(data, &pkt[8], data_size);
202
203	// dump_pkt(pkt, got, "recv:");
204
205	return 0;
206	}
207
208	static int do_rx(int fd, uint32_t addr, void *buf, size_t size)
209	{
210	char *cbuf = buf;
211	int ret;
212	int len;
213
214	/* must use at least 2 packets */
215	if (size <= MAX_DATA_SIZE)
216	len = size / 2;
217	else
218	len = MAX_DATA_SIZE;
219
220	ret = send_pkt(fd, 0x01, addr, len, NULL, 0);
221	if (ret != 0)
222	return ret;
223
224	ret = recv_pkt(fd, 0x01, addr, cbuf, len);
225	if (ret != 0)
226	return ret;
227
228	addr += len;
229	cbuf += len;
230	size -= len;
231
232	while (size > 0) {
233	uint8_t cmd = size > MAX_DATA_SIZE ? 0x11 : 0x21;
234
235	len = size;
236	if (len > MAX_DATA_SIZE)
237	len = MAX_DATA_SIZE;
238
239	ret = send_pkt(fd, cmd, addr, len, NULL, 0);
240	if (ret != 0)
241	return ret;
242
243	ret = recv_pkt(fd, 0x01, addr, cbuf, len);
244	if (ret != 0)
245	return ret;
246
247	addr += len;
248	cbuf += len;
249	size -= len;
250	}
251
252	return 0;
253	}
254
255	static int do_tx(int fd, uint32_t addr, void *buf, size_t size, int exe)
256	{
257	size_t size_last = size;
258	uint32_t addr_last = addr;
259	char *cbuf = buf;
260	uint8_t cmd = 0x09;
261	int ret;
262	int len;
263
264	if (size > MAX_DATA_SIZE) {
265	/* skip first packet, we'll send it last */
266	size_last = MAX_DATA_SIZE;
267	addr += size_last;
268	cbuf += size_last;
269	size -= size_last;
270
271	while (size > 0) {
272	len = size;
273	if (len > MAX_DATA_SIZE)
274	len = MAX_DATA_SIZE;
275
276	ret = send_pkt(fd, cmd, addr, len, cbuf, len);
277	if (ret != 0)
278	return ret;
279
280	ret = recv_pkt(fd, cmd, addr, NULL, 0);
281	if (ret != 0)
282	return ret;
283
284	addr += len;
285	cbuf += len;
286	size -= len;
287	}
288	}
289
290	if (exe)
291	cmd = 0x19;
292
293	ret = send_pkt(fd, cmd, addr_last, size_last, buf, size_last);
294	if (ret != 0)
295	return ret;
296
297	ret = recv_pkt(fd, cmd, addr_last, NULL, 0);
298	if (ret != 0)
299	return ret;
300
301	return 0;
302	}
303
304	static void usage(const char *argv0)
305	{
306	printf("usage:\n"
307	"%s [dev <device>] command(s)\n"
308	"commands:\n"
309	" rx <addr> <size> <outfile>\n"
310	" tx <addr> <size> <infile> [x]\n"
311	" <outfile> can be \"/hd/\" for a hexdump\n"
312	" x instructs to execute uploaded data\n"
313	" for tx, size 0 asks to use filesize\n", argv0);
314	exit(1);
315	}
316
317	static void invarg(int argc, char *argv[], int arg)
318	{
319	if (arg < argc)
320	fprintf(stderr, "invalid arg %d: \"%s\"\n", arg, argv[arg]);
321	else
322	fprintf(stderr, "missing required argument %d\n", arg);
323	exit(1);
324	}
325
326	int main(int argc, char *argv[])
327	{
328	const char *portname = "/dev/ttyUSB0";
329	const char *fname;
330	struct stat st;
331	void *buf = NULL;
332	FILE *f = NULL;
333	uint32_t addr;
334	size_t size;
335	char *endp;
336	int arg = 1;
337	int ret;
338	int fd;
339
340	if (argc < 2 \|\| !strcmp(argv[1], "-h") \|\| !strcmp(argv[1], "--help"))
341	usage(argv[0]);
342
343	if (!strcmp(argv[arg], "dev")) {
344	arg++;
345	if (argv[arg] != NULL)
346	portname = argv[arg];
347	else
348	invarg(argc, argv, arg);
349	arg++;
350	}
351
352	fd = open(portname, O_RDWR \| O_NOCTTY \| O_SYNC);
353	if (fd < 0) {
354	fprintf(stderr, "open %s: ", portname);
355	perror("");
356	return 1;
357	}
358
359	ret = setup(fd);
360	if (ret)
361	return ret;
362
363	while (arg < argc)
364	{
365	if (!strcmp(argv[arg], "rx") \|\|
366	!strcmp(argv[arg], "tx"))
367	{
368	int tx = !strcmp(argv[arg], "tx");
369	int exe = 0;
370
371	if (argc - arg < 4)
372	invarg(argc, argv, argc);
373
374	endp = NULL;
375	addr = strtoul(argv[++arg], &endp, 0);
376	if (endp == NULL \|\| *endp != 0)
377	invarg(argc, argv, arg);
378
379	endp = NULL;
380	size = strtoul(argv[++arg], &endp, 0);
381	if (endp == NULL \|\| *endp != 0)
382	invarg(argc, argv, arg);
383
384	fname = argv[++arg];
385	if (tx \|\| strcmp(fname, "/hd/") != 0) {
386	f = fopen(fname, tx ? "rb" : "wb");
387	if (f == NULL) {
388	fprintf(stderr, "open %s: \n",
389	fname);
390	perror("");
391	return 1;
392	}
393	}
394
395	if (tx && size == 0) {
396	ret = fstat(fileno(f), &st);
397	if (ret != 0) {
398	fprintf(stderr, "fstat %s: \n",
399	fname);
400	perror("stat");
401	return 1;
402	}
403	size = st.st_size;
404	}
405
406	if (size == 0) {
407	fprintf(stderr, "size is 0\n");
408	return 1;
409	}
410
411	buf = realloc(buf, size);
412	if (buf == NULL) {
413	fprintf(stderr, "OOM\n");
414	return 1;
415	}
416
417	if (tx) {
418	ret = fread(buf, 1, size, f);
419	if (ret != size) {
420	fprintf(stderr, "read %s: \n",
421	fname);
422	perror("");
423	return 1;
424	}
425
426	if (arg + 1 < argc
427	&& !strcmp(argv[arg + 1], "x"))
428	{
429	exe = 1;
430	arg++;
431	}
432
433	ret = do_tx(fd, addr, buf, size, exe);
434	if (ret != 0)
435	return ret;
436	}
437	else {
438	ret = do_rx(fd, addr, buf, size);
439	if (ret != 0)
440	return ret;
441
442	if (f != NULL) {
443	ret = fwrite(buf, 1, size, f);
444	if (ret != size) {
445	fprintf(stderr,
446	"write %s: \n",
447	fname);
448	perror("");
449	return 1;
450	}
451	}
452	else {
453	dump_pkt(buf, size, "");
454	}
455	}
456
457	if (f != NULL) {
458	fclose(f);
459	f = NULL;
460	}
461	arg++;
462	}
463	else {
464	invarg(argc, argv, arg);
465	}
466	}
467
468	return 0;
469	}