tftp.c@ 108333

最後變更在這個檔案從108333是 108048,由 vboxsync 提交於 7 週前
curl-8.11.1: Applied and adjusted our curl changes to 8.7.1. jiraref:VBP-1535
屬性 svn:eol-style 設為 `native`
檔案大小: 40.7 KB

行
1	/***************************************************************************
2	* _ _ ____ _
3	* Project ___\| \| \| \| _ \\| \|
4	* / __\| \| \| \| \|_) \| \|
5	* \| (__\| \|_\| \| _ <\| \|___
6	* \___\|\___/\|_\| \_\_____\|
7	*
8	* Copyright (C) Daniel Stenberg, <[email protected]>, et al.
9	*
10	* This software is licensed as described in the file COPYING, which
11	* you should have received as part of this distribution. The terms
12	* are also available at https://curl.se/docs/copyright.html.
13	*
14	* You may opt to use, copy, modify, merge, publish, distribute and/or sell
15	* copies of the Software, and permit persons to whom the Software is
16	* furnished to do so, under the terms of the COPYING file.
17	*
18	* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19	* KIND, either express or implied.
20	*
21	* SPDX-License-Identifier: curl
22	*
23	***************************************************************************/
24
25	#include "curl_setup.h"
26
27	#ifndef CURL_DISABLE_TFTP
28
29	#ifdef HAVE_NETINET_IN_H
30	#include <netinet/in.h>
31	#endif
32	#ifdef HAVE_NETDB_H
33	#include <netdb.h>
34	#endif
35	#ifdef HAVE_ARPA_INET_H
36	#include <arpa/inet.h>
37	#endif
38	#ifdef HAVE_NET_IF_H
39	#include <net/if.h>
40	#endif
41	#ifdef HAVE_SYS_IOCTL_H
42	#include <sys/ioctl.h>
43	#endif
44
45	#ifdef HAVE_SYS_PARAM_H
46	#include <sys/param.h>
47	#endif
48
49	#include "urldata.h"
50	#include <curl/curl.h>
51	#include "cf-socket.h"
52	#include "transfer.h"
53	#include "sendf.h"
54	#include "tftp.h"
55	#include "progress.h"
56	#include "connect.h"
57	#include "strerror.h"
58	#include "sockaddr.h" /* required for Curl_sockaddr_storage */
59	#include "multiif.h"
60	#include "url.h"
61	#include "strcase.h"
62	#include "speedcheck.h"
63	#include "select.h"
64	#include "escape.h"
65
66	/* The last 3 #include files should be in this order */
67	#include "curl_printf.h"
68	#include "curl_memory.h"
69	#include "memdebug.h"
70
71	/* RFC2348 allows the block size to be negotiated */
72	#define TFTP_BLKSIZE_DEFAULT 512
73	#define TFTP_OPTION_BLKSIZE "blksize"
74
75	/* from RFC2349: */
76	#define TFTP_OPTION_TSIZE "tsize"
77	#define TFTP_OPTION_INTERVAL "timeout"
78
79	typedef enum {
80	TFTP_MODE_NETASCII = 0,
81	TFTP_MODE_OCTET
82	} tftp_mode_t;
83
84	typedef enum {
85	TFTP_STATE_START = 0,
86	TFTP_STATE_RX,
87	TFTP_STATE_TX,
88	TFTP_STATE_FIN
89	} tftp_state_t;
90
91	typedef enum {
92	TFTP_EVENT_NONE = -1,
93	TFTP_EVENT_INIT = 0,
94	TFTP_EVENT_RRQ = 1,
95	TFTP_EVENT_WRQ = 2,
96	TFTP_EVENT_DATA = 3,
97	TFTP_EVENT_ACK = 4,
98	TFTP_EVENT_ERROR = 5,
99	TFTP_EVENT_OACK = 6,
100	TFTP_EVENT_TIMEOUT
101	} tftp_event_t;
102
103	typedef enum {
104	TFTP_ERR_UNDEF = 0,
105	TFTP_ERR_NOTFOUND,
106	TFTP_ERR_PERM,
107	TFTP_ERR_DISKFULL,
108	TFTP_ERR_ILLEGAL,
109	TFTP_ERR_UNKNOWNID,
110	TFTP_ERR_EXISTS,
111	TFTP_ERR_NOSUCHUSER, /* This will never be triggered by this code */
112
113	/* The remaining error codes are internal to curl */
114	TFTP_ERR_NONE = -100,
115	TFTP_ERR_TIMEOUT,
116	TFTP_ERR_NORESPONSE
117	} tftp_error_t;
118
119	struct tftp_packet {
120	unsigned char *data;
121	};
122
123	struct tftp_state_data {
124	tftp_state_t state;
125	tftp_mode_t mode;
126	tftp_error_t error;
127	tftp_event_t event;
128	struct Curl_easy *data;
129	curl_socket_t sockfd;
130	int retries;
131	int retry_time;
132	int retry_max;
133	time_t rx_time;
134	struct Curl_sockaddr_storage local_addr;
135	struct Curl_sockaddr_storage remote_addr;
136	curl_socklen_t remote_addrlen;
137	int rbytes;
138	int sbytes;
139	int blksize;
140	int requested_blksize;
141	unsigned short block;
142	struct tftp_packet rpacket;
143	struct tftp_packet spacket;
144	};
145
146
147	/* Forward declarations */
148	static CURLcode tftp_rx(struct tftp_state_data *state, tftp_event_t event);
149	static CURLcode tftp_tx(struct tftp_state_data *state, tftp_event_t event);
150	static CURLcode tftp_connect(struct Curl_easy data, bool done);
151	static CURLcode tftp_disconnect(struct Curl_easy *data,
152	struct connectdata *conn,
153	bool dead_connection);
154	static CURLcode tftp_do(struct Curl_easy data, bool done);
155	static CURLcode tftp_done(struct Curl_easy *data,
156	CURLcode, bool premature);
157	static CURLcode tftp_setup_connection(struct Curl_easy *data,
158	struct connectdata *conn);
159	static CURLcode tftp_multi_statemach(struct Curl_easy data, bool done);
160	static CURLcode tftp_doing(struct Curl_easy data, bool dophase_done);
161	static int tftp_getsock(struct Curl_easy data, struct connectdata conn,
162	curl_socket_t *socks);
163	static CURLcode tftp_translate_code(tftp_error_t error);
164
165
166	/*
167	* TFTP protocol handler.
168	*/
169
170	const struct Curl_handler Curl_handler_tftp = {
171	"tftp", /* scheme */
172	tftp_setup_connection, /* setup_connection */
173	tftp_do, /* do_it */
174	tftp_done, /* done */
175	ZERO_NULL, /* do_more */
176	tftp_connect, /* connect_it */
177	tftp_multi_statemach, /* connecting */
178	tftp_doing, /* doing */
179	tftp_getsock, /* proto_getsock */
180	tftp_getsock, /* doing_getsock */
181	ZERO_NULL, /* domore_getsock */
182	ZERO_NULL, /* perform_getsock */
183	tftp_disconnect, /* disconnect */
184	ZERO_NULL, /* write_resp */
185	ZERO_NULL, /* write_resp_hd */
186	ZERO_NULL, /* connection_check */
187	ZERO_NULL, /* attach connection */
188	PORT_TFTP, /* defport */
189	CURLPROTO_TFTP, /* protocol */
190	CURLPROTO_TFTP, /* family */
191	PROTOPT_NOTCPPROXY \| PROTOPT_NOURLQUERY /* flags */
192	};
193
194	/**********************************************************
195	*
196	* tftp_set_timeouts -
197	*
198	* Set timeouts based on state machine state.
199	* Use user provided connect timeouts until DATA or ACK
200	* packet is received, then use user-provided transfer timeouts
201	*
202	*
203	**********************************************************/
204	static CURLcode tftp_set_timeouts(struct tftp_state_data *state)
205	{
206	time_t maxtime, timeout;
207	timediff_t timeout_ms;
208	bool start = (state->state == TFTP_STATE_START);
209
210	/* Compute drop-dead time */
211	timeout_ms = Curl_timeleft(state->data, NULL, start);
212
213	if(timeout_ms < 0) {
214	/* time-out, bail out, go home */
215	failf(state->data, "Connection time-out");
216	return CURLE_OPERATION_TIMEDOUT;
217	}
218
219	if(timeout_ms > 0)
220	maxtime = (time_t)(timeout_ms + 500) / 1000;
221	else
222	maxtime = 3600; /* use for calculating block timeouts */
223
224	/* Set per-block timeout to total */
225	timeout = maxtime;
226
227	/* Average reposting an ACK after 5 seconds */
228	state->retry_max = (int)timeout/5;
229
230	/* But bound the total number */
231	if(state->retry_max < 3)
232	state->retry_max = 3;
233
234	if(state->retry_max > 50)
235	state->retry_max = 50;
236
237	/* Compute the re-ACK interval to suit the timeout */
238	state->retry_time = (int)(timeout/state->retry_max);
239	if(state->retry_time < 1)
240	state->retry_time = 1;
241
242	infof(state->data,
243	"set timeouts for state %d; Total % " FMT_OFF_T ", retry %d maxtry %d",
244	(int)state->state, timeout_ms, state->retry_time, state->retry_max);
245
246	/* init RX time */
247	state->rx_time = time(NULL);
248
249	return CURLE_OK;
250	}
251
252	/**********************************************************
253	*
254	* tftp_set_send_first
255	*
256	* Event handler for the START state
257	*
258	**********************************************************/
259
260	static void setpacketevent(struct tftp_packet *packet, unsigned short num)
261	{
262	packet->data[0] = (unsigned char)(num >> 8);
263	packet->data[1] = (unsigned char)(num & 0xff);
264	}
265
266
267	static void setpacketblock(struct tftp_packet *packet, unsigned short num)
268	{
269	packet->data[2] = (unsigned char)(num >> 8);
270	packet->data[3] = (unsigned char)(num & 0xff);
271	}
272
273	static unsigned short getrpacketevent(const struct tftp_packet *packet)
274	{
275	return (unsigned short)((packet->data[0] << 8) \| packet->data[1]);
276	}
277
278	static unsigned short getrpacketblock(const struct tftp_packet *packet)
279	{
280	return (unsigned short)((packet->data[2] << 8) \| packet->data[3]);
281	}
282
283	static size_t tftp_strnlen(const char *string, size_t maxlen)
284	{
285	const char *end = memchr(string, '\0', maxlen);
286	return end ? (size_t) (end - string) : maxlen;
287	}
288
289	static const char tftp_option_get(const char buf, size_t len,
290	const char option, const char value)
291	{
292	size_t loc;
293
294	loc = tftp_strnlen(buf, len);
295	loc++; /* NULL term */
296
297	if(loc >= len)
298	return NULL;
299	*option = buf;
300
301	loc += tftp_strnlen(buf + loc, len-loc);
302	loc++; /* NULL term */
303
304	if(loc > len)
305	return NULL;
306	value = &buf[strlen(option) + 1];
307
308	return &buf[loc];
309	}
310
311	static CURLcode tftp_parse_option_ack(struct tftp_state_data *state,
312	const char *ptr, int len)
313	{
314	const char *tmp = ptr;
315	struct Curl_easy *data = state->data;
316
317	/* if OACK does not contain blksize option, the default (512) must be used */
318	state->blksize = TFTP_BLKSIZE_DEFAULT;
319
320	while(tmp < ptr + len) {
321	const char option, value;
322
323	tmp = tftp_option_get(tmp, ptr + len - tmp, &option, &value);
324	if(!tmp) {
325	failf(data, "Malformed ACK packet, rejecting");
326	return CURLE_TFTP_ILLEGAL;
327	}
328
329	infof(data, "got option=(%s) value=(%s)", option, value);
330
331	if(checkprefix(TFTP_OPTION_BLKSIZE, option)) {
332	long blksize;
333
334	blksize = strtol(value, NULL, 10);
335
336	if(!blksize) {
337	failf(data, "invalid blocksize value in OACK packet");
338	return CURLE_TFTP_ILLEGAL;
339	}
340	if(blksize > TFTP_BLKSIZE_MAX) {
341	failf(data, "%s (%d)", "blksize is larger than max supported",
342	TFTP_BLKSIZE_MAX);
343	return CURLE_TFTP_ILLEGAL;
344	}
345	else if(blksize < TFTP_BLKSIZE_MIN) {
346	failf(data, "%s (%d)", "blksize is smaller than min supported",
347	TFTP_BLKSIZE_MIN);
348	return CURLE_TFTP_ILLEGAL;
349	}
350	else if(blksize > state->requested_blksize) {
351	/* could realloc pkt buffers here, but the spec does not call out
352	* support for the server requesting a bigger blksize than the client
353	* requests */
354	failf(data, "%s (%ld)",
355	"server requested blksize larger than allocated", blksize);
356	return CURLE_TFTP_ILLEGAL;
357	}
358
359	state->blksize = (int)blksize;
360	infof(data, "%s (%d) %s (%d)", "blksize parsed from OACK",
361	state->blksize, "requested", state->requested_blksize);
362	}
363	else if(checkprefix(TFTP_OPTION_TSIZE, option)) {
364	long tsize = 0;
365
366	tsize = strtol(value, NULL, 10);
367	infof(data, "%s (%ld)", "tsize parsed from OACK", tsize);
368
369	/* tsize should be ignored on upload: Who cares about the size of the
370	remote file? */
371	if(!data->state.upload) {
372	if(!tsize) {
373	failf(data, "invalid tsize -:%s:- value in OACK packet", value);
374	return CURLE_TFTP_ILLEGAL;
375	}
376	Curl_pgrsSetDownloadSize(data, tsize);
377	}
378	}
379	}
380
381	return CURLE_OK;
382	}
383
384	static CURLcode tftp_option_add(struct tftp_state_data state, size_t csize,
385	char buf, const char option)
386	{
387	if(( strlen(option) + *csize + 1) > (size_t)state->blksize)
388	return CURLE_TFTP_ILLEGAL;
389	strcpy(buf, option);
390	*csize += strlen(option) + 1;
391	return CURLE_OK;
392	}
393
394	static CURLcode tftp_connect_for_tx(struct tftp_state_data *state,
395	tftp_event_t event)
396	{
397	CURLcode result;
398	#ifndef CURL_DISABLE_VERBOSE_STRINGS
399	struct Curl_easy *data = state->data;
400
401	infof(data, "%s", "Connected for transmit");
402	#endif
403	state->state = TFTP_STATE_TX;
404	result = tftp_set_timeouts(state);
405	if(result)
406	return result;
407	return tftp_tx(state, event);
408	}
409
410	static CURLcode tftp_connect_for_rx(struct tftp_state_data *state,
411	tftp_event_t event)
412	{
413	CURLcode result;
414	#ifndef CURL_DISABLE_VERBOSE_STRINGS
415	struct Curl_easy *data = state->data;
416
417	infof(data, "%s", "Connected for receive");
418	#endif
419	state->state = TFTP_STATE_RX;
420	result = tftp_set_timeouts(state);
421	if(result)
422	return result;
423	return tftp_rx(state, event);
424	}
425
426	static CURLcode tftp_send_first(struct tftp_state_data *state,
427	tftp_event_t event)
428	{
429	size_t sbytes;
430	ssize_t senddata;
431	const char *mode = "octet";
432	char *filename;
433	struct Curl_easy *data = state->data;
434	CURLcode result = CURLE_OK;
435
436	/* Set ASCII mode if -B flag was used */
437	if(data->state.prefer_ascii)
438	mode = "netascii";
439
440	switch(event) {
441
442	case TFTP_EVENT_INIT: /* Send the first packet out */
443	case TFTP_EVENT_TIMEOUT: /* Resend the first packet out */
444	/* Increment the retry counter, quit if over the limit */
445	state->retries++;
446	if(state->retries > state->retry_max) {
447	state->error = TFTP_ERR_NORESPONSE;
448	state->state = TFTP_STATE_FIN;
449	return result;
450	}
451
452	if(data->state.upload) {
453	/* If we are uploading, send an WRQ */
454	setpacketevent(&state->spacket, TFTP_EVENT_WRQ);
455	if(data->state.infilesize != -1)
456	Curl_pgrsSetUploadSize(data, data->state.infilesize);
457	}
458	else {
459	/* If we are downloading, send an RRQ */
460	setpacketevent(&state->spacket, TFTP_EVENT_RRQ);
461	}
462	/* As RFC3617 describes the separator slash is not actually part of the
463	filename so we skip the always-present first letter of the path
464	string. */
465	result = Curl_urldecode(&state->data->state.up.path[1], 0,
466	&filename, NULL, REJECT_ZERO);
467	if(result)
468	return result;
469
470	if(strlen(filename) > (state->blksize - strlen(mode) - 4)) {
471	failf(data, "TFTP filename too long");
472	free(filename);
473	return CURLE_TFTP_ILLEGAL; /* too long filename field */
474	}
475
476	msnprintf((char *)state->spacket.data + 2,
477	state->blksize,
478	"%s%c%s%c", filename, '\0', mode, '\0');
479	sbytes = 4 + strlen(filename) + strlen(mode);
480
481	/* optional addition of TFTP options */
482	if(!data->set.tftp_no_options) {
483	char buf[64];
484	/* add tsize option */
485	msnprintf(buf, sizeof(buf), "%" FMT_OFF_T,
486	data->state.upload && (data->state.infilesize != -1) ?
487	data->state.infilesize : 0);
488
489	result = tftp_option_add(state, &sbytes,
490	(char *)state->spacket.data + sbytes,
491	TFTP_OPTION_TSIZE);
492	if(result == CURLE_OK)
493	result = tftp_option_add(state, &sbytes,
494	(char *)state->spacket.data + sbytes, buf);
495
496	/* add blksize option */
497	msnprintf(buf, sizeof(buf), "%d", state->requested_blksize);
498	if(result == CURLE_OK)
499	result = tftp_option_add(state, &sbytes,
500	(char *)state->spacket.data + sbytes,
501	TFTP_OPTION_BLKSIZE);
502	if(result == CURLE_OK)
503	result = tftp_option_add(state, &sbytes,
504	(char *)state->spacket.data + sbytes, buf);
505
506	/* add timeout option */
507	msnprintf(buf, sizeof(buf), "%d", state->retry_time);
508	if(result == CURLE_OK)
509	result = tftp_option_add(state, &sbytes,
510	(char *)state->spacket.data + sbytes,
511	TFTP_OPTION_INTERVAL);
512	if(result == CURLE_OK)
513	result = tftp_option_add(state, &sbytes,
514	(char *)state->spacket.data + sbytes, buf);
515
516	if(result != CURLE_OK) {
517	failf(data, "TFTP buffer too small for options");
518	free(filename);
519	return CURLE_TFTP_ILLEGAL;
520	}
521	}
522
523	/* the typecase for the 3rd argument is mostly for systems that do
524	not have a size_t argument, like older unixes that want an 'int' */
525	senddata = sendto(state->sockfd, (void *)state->spacket.data,
526	(SEND_TYPE_ARG3)sbytes, 0,
527	&data->conn->remote_addr->curl_sa_addr,
528	(curl_socklen_t)data->conn->remote_addr->addrlen);
529	if(senddata != (ssize_t)sbytes) {
530	char buffer[STRERROR_LEN];
531	failf(data, "%s", Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
532	}
533	free(filename);
534	break;
535
536	case TFTP_EVENT_OACK:
537	if(data->state.upload) {
538	result = tftp_connect_for_tx(state, event);
539	}
540	else {
541	result = tftp_connect_for_rx(state, event);
542	}
543	break;
544
545	case TFTP_EVENT_ACK: /* Connected for transmit */
546	result = tftp_connect_for_tx(state, event);
547	break;
548
549	case TFTP_EVENT_DATA: /* Connected for receive */
550	result = tftp_connect_for_rx(state, event);
551	break;
552
553	case TFTP_EVENT_ERROR:
554	state->state = TFTP_STATE_FIN;
555	break;
556
557	default:
558	failf(state->data, "tftp_send_first: internal error");
559	break;
560	}
561
562	return result;
563	}
564
565	/* the next blocknum is x + 1 but it needs to wrap at an unsigned 16bit
566	boundary */
567	#define NEXT_BLOCKNUM(x) (((x) + 1)&0xffff)
568
569	/**********************************************************
570	*
571	* tftp_rx
572	*
573	* Event handler for the RX state
574	*
575	**********************************************************/
576	static CURLcode tftp_rx(struct tftp_state_data *state,
577	tftp_event_t event)
578	{
579	ssize_t sbytes;
580	int rblock;
581	struct Curl_easy *data = state->data;
582	char buffer[STRERROR_LEN];
583
584	switch(event) {
585
586	case TFTP_EVENT_DATA:
587	/* Is this the block we expect? */
588	rblock = getrpacketblock(&state->rpacket);
589	if(NEXT_BLOCKNUM(state->block) == rblock) {
590	/* This is the expected block. Reset counters and ACK it. */
591	state->retries = 0;
592	}
593	else if(state->block == rblock) {
594	/* This is the last recently received block again. Log it and ACK it
595	again. */
596	infof(data, "Received last DATA packet block %d again.", rblock);
597	}
598	else {
599	/* totally unexpected, just log it */
600	infof(data,
601	"Received unexpected DATA packet block %d, expecting block %d",
602	rblock, NEXT_BLOCKNUM(state->block));
603	break;
604	}
605
606	/* ACK this block. */
607	state->block = (unsigned short)rblock;
608	setpacketevent(&state->spacket, TFTP_EVENT_ACK);
609	setpacketblock(&state->spacket, state->block);
610	sbytes = sendto(state->sockfd, (void *)state->spacket.data,
611	4, SEND_4TH_ARG,
612	(struct sockaddr *)&state->remote_addr,
613	state->remote_addrlen);
614	if(sbytes < 0) {
615	failf(data, "%s", Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
616	return CURLE_SEND_ERROR;
617	}
618
619	/* Check if completed (That is, a less than full packet is received) */
620	if(state->rbytes < (ssize_t)state->blksize + 4) {
621	state->state = TFTP_STATE_FIN;
622	}
623	else {
624	state->state = TFTP_STATE_RX;
625	}
626	state->rx_time = time(NULL);
627	break;
628
629	case TFTP_EVENT_OACK:
630	/* ACK option acknowledgement so we can move on to data */
631	state->block = 0;
632	state->retries = 0;
633	setpacketevent(&state->spacket, TFTP_EVENT_ACK);
634	setpacketblock(&state->spacket, state->block);
635	sbytes = sendto(state->sockfd, (void *)state->spacket.data,
636	4, SEND_4TH_ARG,
637	(struct sockaddr *)&state->remote_addr,
638	state->remote_addrlen);
639	if(sbytes < 0) {
640	failf(data, "%s", Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
641	return CURLE_SEND_ERROR;
642	}
643
644	/* we are ready to RX data */
645	state->state = TFTP_STATE_RX;
646	state->rx_time = time(NULL);
647	break;
648
649	case TFTP_EVENT_TIMEOUT:
650	/* Increment the retry count and fail if over the limit */
651	state->retries++;
652	infof(data,
653	"Timeout waiting for block %d ACK. Retries = %d",
654	NEXT_BLOCKNUM(state->block), state->retries);
655	if(state->retries > state->retry_max) {
656	state->error = TFTP_ERR_TIMEOUT;
657	state->state = TFTP_STATE_FIN;
658	}
659	else {
660	/* Resend the previous ACK */
661	sbytes = sendto(state->sockfd, (void *)state->spacket.data,
662	4, SEND_4TH_ARG,
663	(struct sockaddr *)&state->remote_addr,
664	state->remote_addrlen);
665	if(sbytes < 0) {
666	failf(data, "%s", Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
667	return CURLE_SEND_ERROR;
668	}
669	}
670	break;
671
672	case TFTP_EVENT_ERROR:
673	setpacketevent(&state->spacket, TFTP_EVENT_ERROR);
674	setpacketblock(&state->spacket, state->block);
675	(void)sendto(state->sockfd, (void *)state->spacket.data,
676	4, SEND_4TH_ARG,
677	(struct sockaddr *)&state->remote_addr,
678	state->remote_addrlen);
679	/* do not bother with the return code, but if the socket is still up we
680	* should be a good TFTP client and let the server know we are done */
681	state->state = TFTP_STATE_FIN;
682	break;
683
684	default:
685	failf(data, "%s", "tftp_rx: internal error");
686	return CURLE_TFTP_ILLEGAL; /* not really the perfect return code for
687	this */
688	}
689	return CURLE_OK;
690	}
691
692	/**********************************************************
693	*
694	* tftp_tx
695	*
696	* Event handler for the TX state
697	*
698	**********************************************************/
699	static CURLcode tftp_tx(struct tftp_state_data *state, tftp_event_t event)
700	{
701	struct Curl_easy *data = state->data;
702	ssize_t sbytes;
703	CURLcode result = CURLE_OK;
704	struct SingleRequest *k = &data->req;
705	size_t cb; /* Bytes currently read */
706	char buffer[STRERROR_LEN];
707	char *bufptr;
708	bool eos;
709
710	switch(event) {
711
712	case TFTP_EVENT_ACK:
713	case TFTP_EVENT_OACK:
714	if(event == TFTP_EVENT_ACK) {
715	/* Ack the packet */
716	int rblock = getrpacketblock(&state->rpacket);
717
718	if(rblock != state->block &&
719	/* There is a bug in tftpd-hpa that causes it to send us an ack for
720	* 65535 when the block number wraps to 0. So when we are expecting
721	* 0, also accept 65535. See
722	* https://www.syslinux.org/archives/2010-September/015612.html
723	* */
724	!(state->block == 0 && rblock == 65535)) {
725	/* This is not the expected block. Log it and up the retry counter */
726	infof(data, "Received ACK for block %d, expecting %d",
727	rblock, state->block);
728	state->retries++;
729	/* Bail out if over the maximum */
730	if(state->retries > state->retry_max) {
731	failf(data, "tftp_tx: giving up waiting for block %d ack",
732	state->block);
733	result = CURLE_SEND_ERROR;
734	}
735	else {
736	/* Re-send the data packet */
737	sbytes = sendto(state->sockfd, (void *)state->spacket.data,
738	4 + (SEND_TYPE_ARG3)state->sbytes, SEND_4TH_ARG,
739	(struct sockaddr *)&state->remote_addr,
740	state->remote_addrlen);
741	/* Check all sbytes were sent */
742	if(sbytes < 0) {
743	failf(data, "%s", Curl_strerror(SOCKERRNO,
744	buffer, sizeof(buffer)));
745	result = CURLE_SEND_ERROR;
746	}
747	}
748
749	return result;
750	}
751	/* This is the expected packet. Reset the counters and send the next
752	block */
753	state->rx_time = time(NULL);
754	state->block++;
755	}
756	else
757	state->block = 1; /* first data block is 1 when using OACK */
758
759	state->retries = 0;
760	setpacketevent(&state->spacket, TFTP_EVENT_DATA);
761	setpacketblock(&state->spacket, state->block);
762	if(state->block > 1 && state->sbytes < state->blksize) {
763	state->state = TFTP_STATE_FIN;
764	return CURLE_OK;
765	}
766
767	/* TFTP considers data block size < 512 bytes as an end of session. So
768	* in some cases we must wait for additional data to build full (512 bytes)
769	* data block.
770	* */
771	state->sbytes = 0;
772	bufptr = (char *)state->spacket.data + 4;
773	do {
774	result = Curl_client_read(data, bufptr, state->blksize - state->sbytes,
775	&cb, &eos);
776	if(result)
777	return result;
778	state->sbytes += (int)cb;
779	bufptr += cb;
780	} while(state->sbytes < state->blksize && cb);
781
782	sbytes = sendto(state->sockfd, (void *) state->spacket.data,
783	4 + (SEND_TYPE_ARG3)state->sbytes, SEND_4TH_ARG,
784	(struct sockaddr *)&state->remote_addr,
785	state->remote_addrlen);
786	/* Check all sbytes were sent */
787	if(sbytes < 0) {
788	failf(data, "%s", Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
789	return CURLE_SEND_ERROR;
790	}
791	/* Update the progress meter */
792	k->writebytecount += state->sbytes;
793	Curl_pgrsSetUploadCounter(data, k->writebytecount);
794	break;
795
796	case TFTP_EVENT_TIMEOUT:
797	/* Increment the retry counter and log the timeout */
798	state->retries++;
799	infof(data, "Timeout waiting for block %d ACK. "
800	" Retries = %d", NEXT_BLOCKNUM(state->block), state->retries);
801	/* Decide if we have had enough */
802	if(state->retries > state->retry_max) {
803	state->error = TFTP_ERR_TIMEOUT;
804	state->state = TFTP_STATE_FIN;
805	}
806	else {
807	/* Re-send the data packet */
808	sbytes = sendto(state->sockfd, (void *)state->spacket.data,
809	4 + (SEND_TYPE_ARG3)state->sbytes, SEND_4TH_ARG,
810	(struct sockaddr *)&state->remote_addr,
811	state->remote_addrlen);
812	/* Check all sbytes were sent */
813	if(sbytes < 0) {
814	failf(data, "%s", Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
815	return CURLE_SEND_ERROR;
816	}
817	/* since this was a re-send, we remain at the still byte position */
818	Curl_pgrsSetUploadCounter(data, k->writebytecount);
819	}
820	break;
821
822	case TFTP_EVENT_ERROR:
823	state->state = TFTP_STATE_FIN;
824	setpacketevent(&state->spacket, TFTP_EVENT_ERROR);
825	setpacketblock(&state->spacket, state->block);
826	(void)sendto(state->sockfd, (void *)state->spacket.data, 4, SEND_4TH_ARG,
827	(struct sockaddr *)&state->remote_addr,
828	state->remote_addrlen);
829	/* do not bother with the return code, but if the socket is still up we
830	* should be a good TFTP client and let the server know we are done */
831	state->state = TFTP_STATE_FIN;
832	break;
833
834	default:
835	failf(data, "tftp_tx: internal error, event: %i", (int)(event));
836	break;
837	}
838
839	return result;
840	}
841
842	/**********************************************************
843	*
844	* tftp_translate_code
845	*
846	* Translate internal error codes to CURL error codes
847	*
848	**********************************************************/
849	static CURLcode tftp_translate_code(tftp_error_t error)
850	{
851	CURLcode result = CURLE_OK;
852
853	if(error != TFTP_ERR_NONE) {
854	switch(error) {
855	case TFTP_ERR_NOTFOUND:
856	result = CURLE_TFTP_NOTFOUND;
857	break;
858	case TFTP_ERR_PERM:
859	result = CURLE_TFTP_PERM;
860	break;
861	case TFTP_ERR_DISKFULL:
862	result = CURLE_REMOTE_DISK_FULL;
863	break;
864	case TFTP_ERR_UNDEF:
865	case TFTP_ERR_ILLEGAL:
866	result = CURLE_TFTP_ILLEGAL;
867	break;
868	case TFTP_ERR_UNKNOWNID:
869	result = CURLE_TFTP_UNKNOWNID;
870	break;
871	case TFTP_ERR_EXISTS:
872	result = CURLE_REMOTE_FILE_EXISTS;
873	break;
874	case TFTP_ERR_NOSUCHUSER:
875	result = CURLE_TFTP_NOSUCHUSER;
876	break;
877	case TFTP_ERR_TIMEOUT:
878	result = CURLE_OPERATION_TIMEDOUT;
879	break;
880	case TFTP_ERR_NORESPONSE:
881	result = CURLE_COULDNT_CONNECT;
882	break;
883	default:
884	result = CURLE_ABORTED_BY_CALLBACK;
885	break;
886	}
887	}
888	else
889	result = CURLE_OK;
890
891	return result;
892	}
893
894	/**********************************************************
895	*
896	* tftp_state_machine
897	*
898	* The tftp state machine event dispatcher
899	*
900	**********************************************************/
901	static CURLcode tftp_state_machine(struct tftp_state_data *state,
902	tftp_event_t event)
903	{
904	CURLcode result = CURLE_OK;
905	struct Curl_easy *data = state->data;
906
907	switch(state->state) {
908	case TFTP_STATE_START:
909	DEBUGF(infof(data, "TFTP_STATE_START"));
910	result = tftp_send_first(state, event);
911	break;
912	case TFTP_STATE_RX:
913	DEBUGF(infof(data, "TFTP_STATE_RX"));
914	result = tftp_rx(state, event);
915	break;
916	case TFTP_STATE_TX:
917	DEBUGF(infof(data, "TFTP_STATE_TX"));
918	result = tftp_tx(state, event);
919	break;
920	case TFTP_STATE_FIN:
921	infof(data, "%s", "TFTP finished");
922	break;
923	default:
924	DEBUGF(infof(data, "STATE: %d", state->state));
925	failf(data, "%s", "Internal state machine error");
926	result = CURLE_TFTP_ILLEGAL;
927	break;
928	}
929
930	return result;
931	}
932
933	/**********************************************************
934	*
935	* tftp_disconnect
936	*
937	* The disconnect callback
938	*
939	**********************************************************/
940	static CURLcode tftp_disconnect(struct Curl_easy *data,
941	struct connectdata *conn, bool dead_connection)
942	{
943	struct tftp_state_data *state = conn->proto.tftpc;
944	(void) data;
945	(void) dead_connection;
946
947	/* done, free dynamically allocated pkt buffers */
948	if(state) {
949	Curl_safefree(state->rpacket.data);
950	Curl_safefree(state->spacket.data);
951	free(state);
952	}
953
954	return CURLE_OK;
955	}
956
957	/**********************************************************
958	*
959	* tftp_connect
960	*
961	* The connect callback
962	*
963	**********************************************************/
964	static CURLcode tftp_connect(struct Curl_easy data, bool done)
965	{
966	struct tftp_state_data *state;
967	int blksize;
968	int need_blksize;
969	struct connectdata *conn = data->conn;
970
971	blksize = TFTP_BLKSIZE_DEFAULT;
972
973	state = conn->proto.tftpc = calloc(1, sizeof(struct tftp_state_data));
974	if(!state)
975	return CURLE_OUT_OF_MEMORY;
976
977	/* alloc pkt buffers based on specified blksize */
978	if(data->set.tftp_blksize)
979	/* range checked when set */
980	blksize = (int)data->set.tftp_blksize;
981
982	need_blksize = blksize;
983	/* default size is the fallback when no OACK is received */
984	if(need_blksize < TFTP_BLKSIZE_DEFAULT)
985	need_blksize = TFTP_BLKSIZE_DEFAULT;
986
987	if(!state->rpacket.data) {
988	state->rpacket.data = calloc(1, need_blksize + 2 + 2);
989
990	if(!state->rpacket.data)
991	return CURLE_OUT_OF_MEMORY;
992	}
993
994	if(!state->spacket.data) {
995	state->spacket.data = calloc(1, need_blksize + 2 + 2);
996
997	if(!state->spacket.data)
998	return CURLE_OUT_OF_MEMORY;
999	}
1000
1001	/* we do not keep TFTP connections up basically because there is none or
1002	* little gain for UDP */
1003	connclose(conn, "TFTP");
1004
1005	state->data = data;
1006	state->sockfd = conn->sock[FIRSTSOCKET];
1007	state->state = TFTP_STATE_START;
1008	state->error = TFTP_ERR_NONE;
1009	state->blksize = TFTP_BLKSIZE_DEFAULT; /* Unless updated by OACK response */
1010	state->requested_blksize = blksize;
1011
1012	((struct sockaddr *)&state->local_addr)->sa_family =
1013	(CURL_SA_FAMILY_T)(conn->remote_addr->family);
1014
1015	tftp_set_timeouts(state);
1016
1017	if(!conn->bits.bound) {
1018	/* If not already bound, bind to any interface, random UDP port. If it is
1019	* reused or a custom local port was desired, this has already been done!
1020	*
1021	* We once used the size of the local_addr struct as the third argument
1022	* for bind() to better work with IPv6 or whatever size the struct could
1023	* have, but we learned that at least Tru64, AIX and IRIX requires the
1024	* size of that argument to match the exact size of a 'sockaddr_in' struct
1025	* when running IPv4-only.
1026	*
1027	* Therefore we use the size from the address we connected to, which we
1028	* assume uses the same IP version and thus hopefully this works for both
1029	* IPv4 and IPv6...
1030	*/
1031	int rc = bind(state->sockfd, (struct sockaddr *)&state->local_addr,
1032	(curl_socklen_t)conn->remote_addr->addrlen);
1033	if(rc) {
1034	char buffer[STRERROR_LEN];
1035	failf(data, "bind() failed; %s",
1036	Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
1037	return CURLE_COULDNT_CONNECT;
1038	}
1039	conn->bits.bound = TRUE;
1040	}
1041
1042	Curl_pgrsStartNow(data);
1043
1044	*done = TRUE;
1045
1046	return CURLE_OK;
1047	}
1048
1049	/**********************************************************
1050	*
1051	* tftp_done
1052	*
1053	* The done callback
1054	*
1055	**********************************************************/
1056	static CURLcode tftp_done(struct Curl_easy *data, CURLcode status,
1057	bool premature)
1058	{
1059	CURLcode result = CURLE_OK;
1060	struct connectdata *conn = data->conn;
1061	struct tftp_state_data *state = conn->proto.tftpc;
1062
1063	(void)status; /* unused */
1064	(void)premature; /* not used */
1065
1066	if(Curl_pgrsDone(data))
1067	return CURLE_ABORTED_BY_CALLBACK;
1068
1069	/* If we have encountered an error */
1070	if(state)
1071	result = tftp_translate_code(state->error);
1072
1073	return result;
1074	}
1075
1076	/**********************************************************
1077	*
1078	* tftp_getsock
1079	*
1080	* The getsock callback
1081	*
1082	**********************************************************/
1083	static int tftp_getsock(struct Curl_easy *data,
1084	struct connectdata conn, curl_socket_t socks)
1085	{
1086	(void)data;
1087	socks[0] = conn->sock[FIRSTSOCKET];
1088	return GETSOCK_READSOCK(0);
1089	}
1090
1091	/**********************************************************
1092	*
1093	* tftp_receive_packet
1094	*
1095	* Called once select fires and data is ready on the socket
1096	*
1097	**********************************************************/
1098	static CURLcode tftp_receive_packet(struct Curl_easy *data)
1099	{
1100	curl_socklen_t fromlen;
1101	CURLcode result = CURLE_OK;
1102	struct connectdata *conn = data->conn;
1103	struct tftp_state_data *state = conn->proto.tftpc;
1104
1105	/* Receive the packet */
1106	fromlen = sizeof(state->remote_addr);
1107	state->rbytes = (int)recvfrom(state->sockfd,
1108	(void *)state->rpacket.data,
1109	(RECV_TYPE_ARG3)state->blksize + 4,
1110	0,
1111	(struct sockaddr *)&state->remote_addr,
1112	&fromlen);
1113	state->remote_addrlen = fromlen;
1114
1115	/* Sanity check packet length */
1116	if(state->rbytes < 4) {
1117	failf(data, "Received too short packet");
1118	/* Not a timeout, but how best to handle it? */
1119	state->event = TFTP_EVENT_TIMEOUT;
1120	}
1121	else {
1122	/* The event is given by the TFTP packet time */
1123	unsigned short event = getrpacketevent(&state->rpacket);
1124	state->event = (tftp_event_t)event;
1125
1126	switch(state->event) {
1127	case TFTP_EVENT_DATA:
1128	/* Do not pass to the client empty or retransmitted packets */
1129	if(state->rbytes > 4 &&
1130	(NEXT_BLOCKNUM(state->block) == getrpacketblock(&state->rpacket))) {
1131	result = Curl_client_write(data, CLIENTWRITE_BODY,
1132	(char *)state->rpacket.data + 4,
1133	state->rbytes-4);
1134	if(result) {
1135	tftp_state_machine(state, TFTP_EVENT_ERROR);
1136	return result;
1137	}
1138	}
1139	break;
1140	case TFTP_EVENT_ERROR:
1141	{
1142	unsigned short error = getrpacketblock(&state->rpacket);
1143	char str = (char )state->rpacket.data + 4;
1144	size_t strn = state->rbytes - 4;
1145	state->error = (tftp_error_t)error;
1146	if(tftp_strnlen(str, strn) < strn)
1147	infof(data, "TFTP error: %s", str);
1148	break;
1149	}
1150	case TFTP_EVENT_ACK:
1151	break;
1152	case TFTP_EVENT_OACK:
1153	result = tftp_parse_option_ack(state,
1154	(const char *)state->rpacket.data + 2,
1155	state->rbytes-2);
1156	if(result)
1157	return result;
1158	break;
1159	case TFTP_EVENT_RRQ:
1160	case TFTP_EVENT_WRQ:
1161	default:
1162	failf(data, "%s", "Internal error: Unexpected packet");
1163	break;
1164	}
1165
1166	/* Update the progress meter */
1167	if(Curl_pgrsUpdate(data)) {
1168	tftp_state_machine(state, TFTP_EVENT_ERROR);
1169	return CURLE_ABORTED_BY_CALLBACK;
1170	}
1171	}
1172	return result;
1173	}
1174
1175	/**********************************************************
1176	*
1177	* tftp_state_timeout
1178	*
1179	* Check if timeouts have been reached
1180	*
1181	**********************************************************/
1182	static timediff_t tftp_state_timeout(struct Curl_easy *data,
1183	tftp_event_t *event)
1184	{
1185	time_t current;
1186	struct connectdata *conn = data->conn;
1187	struct tftp_state_data *state = conn->proto.tftpc;
1188	timediff_t timeout_ms;
1189
1190	if(event)
1191	*event = TFTP_EVENT_NONE;
1192
1193	timeout_ms = Curl_timeleft(state->data, NULL,
1194	(state->state == TFTP_STATE_START));
1195	if(timeout_ms < 0) {
1196	state->error = TFTP_ERR_TIMEOUT;
1197	state->state = TFTP_STATE_FIN;
1198	return 0;
1199	}
1200	current = time(NULL);
1201	if(current > state->rx_time + state->retry_time) {
1202	if(event)
1203	*event = TFTP_EVENT_TIMEOUT;
1204	state->rx_time = time(NULL); /* update even though we received nothing */
1205	}
1206
1207	return timeout_ms;
1208	}
1209
1210	/**********************************************************
1211	*
1212	* tftp_multi_statemach
1213	*
1214	* Handle single RX socket event and return
1215	*
1216	**********************************************************/
1217	static CURLcode tftp_multi_statemach(struct Curl_easy data, bool done)
1218	{
1219	tftp_event_t event;
1220	CURLcode result = CURLE_OK;
1221	struct connectdata *conn = data->conn;
1222	struct tftp_state_data *state = conn->proto.tftpc;
1223	timediff_t timeout_ms = tftp_state_timeout(data, &event);
1224
1225	*done = FALSE;
1226
1227	if(timeout_ms < 0) {
1228	failf(data, "TFTP response timeout");
1229	return CURLE_OPERATION_TIMEDOUT;
1230	}
1231	if(event != TFTP_EVENT_NONE) {
1232	result = tftp_state_machine(state, event);
1233	if(result)
1234	return result;
1235	*done = (state->state == TFTP_STATE_FIN);
1236	if(*done)
1237	/* Tell curl we are done */
1238	Curl_xfer_setup_nop(data);
1239	}
1240	else {
1241	/* no timeouts to handle, check our socket */
1242	int rc = SOCKET_READABLE(state->sockfd, 0);
1243
1244	if(rc == -1) {
1245	/* bail out */
1246	int error = SOCKERRNO;
1247	char buffer[STRERROR_LEN];
1248	failf(data, "%s", Curl_strerror(error, buffer, sizeof(buffer)));
1249	state->event = TFTP_EVENT_ERROR;
1250	}
1251	else if(rc) {
1252	result = tftp_receive_packet(data);
1253	if(result)
1254	return result;
1255	result = tftp_state_machine(state, state->event);
1256	if(result)
1257	return result;
1258	*done = (state->state == TFTP_STATE_FIN);
1259	if(*done)
1260	/* Tell curl we are done */
1261	Curl_xfer_setup_nop(data);
1262	}
1263	/* if rc == 0, then select() timed out */
1264	}
1265
1266	return result;
1267	}
1268
1269	/**********************************************************
1270	*
1271	* tftp_doing
1272	*
1273	* Called from multi.c while DOing
1274	*
1275	**********************************************************/
1276	static CURLcode tftp_doing(struct Curl_easy data, bool dophase_done)
1277	{
1278	CURLcode result;
1279	result = tftp_multi_statemach(data, dophase_done);
1280
1281	if(*dophase_done) {
1282	DEBUGF(infof(data, "DO phase is complete"));
1283	}
1284	else if(!result) {
1285	/* The multi code does not have this logic for the DOING state so we
1286	provide it for TFTP since it may do the entire transfer in this
1287	state. */
1288	if(Curl_pgrsUpdate(data))
1289	result = CURLE_ABORTED_BY_CALLBACK;
1290	else
1291	result = Curl_speedcheck(data, Curl_now());
1292	}
1293	return result;
1294	}
1295
1296	/**********************************************************
1297	*
1298	* tftp_perform
1299	*
1300	* Entry point for transfer from tftp_do, starts state mach
1301	*
1302	**********************************************************/
1303	static CURLcode tftp_perform(struct Curl_easy data, bool dophase_done)
1304	{
1305	CURLcode result = CURLE_OK;
1306	struct connectdata *conn = data->conn;
1307	struct tftp_state_data *state = conn->proto.tftpc;
1308
1309	*dophase_done = FALSE;
1310
1311	result = tftp_state_machine(state, TFTP_EVENT_INIT);
1312
1313	if((state->state == TFTP_STATE_FIN) \|\| result)
1314	return result;
1315
1316	tftp_multi_statemach(data, dophase_done);
1317
1318	if(*dophase_done)
1319	DEBUGF(infof(data, "DO phase is complete"));
1320
1321	return result;
1322	}
1323
1324
1325	/**********************************************************
1326	*
1327	* tftp_do
1328	*
1329	* The do callback
1330	*
1331	* This callback initiates the TFTP transfer
1332	*
1333	**********************************************************/
1334
1335	static CURLcode tftp_do(struct Curl_easy data, bool done)
1336	{
1337	struct tftp_state_data *state;
1338	CURLcode result;
1339	struct connectdata *conn = data->conn;
1340
1341	*done = FALSE;
1342
1343	if(!conn->proto.tftpc) {
1344	result = tftp_connect(data, done);
1345	if(result)
1346	return result;
1347	}
1348
1349	state = conn->proto.tftpc;
1350	if(!state)
1351	return CURLE_TFTP_ILLEGAL;
1352
1353	result = tftp_perform(data, done);
1354
1355	/* If tftp_perform() returned an error, use that for return code. If it
1356	was OK, see if tftp_translate_code() has an error. */
1357	if(!result)
1358	/* If we have encountered an internal tftp error, translate it. */
1359	result = tftp_translate_code(state->error);
1360
1361	return result;
1362	}
1363
1364	static CURLcode tftp_setup_connection(struct Curl_easy *data,
1365	struct connectdata *conn)
1366	{
1367	char *type;
1368
1369	conn->transport = TRNSPRT_UDP;
1370
1371	/* TFTP URLs support an extension like ";mode=<typecode>" that
1372	* we will try to get now! */
1373	type = strstr(data->state.up.path, ";mode=");
1374
1375	if(!type)
1376	type = strstr(conn->host.rawalloc, ";mode=");
1377
1378	if(type) {
1379	char command;
1380	type = 0; / it was in the middle of the hostname */
1381	command = Curl_raw_toupper(type[6]);
1382
1383	switch(command) {
1384	case 'A': /* ASCII mode */
1385	case 'N': /* NETASCII mode */
1386	data->state.prefer_ascii = TRUE;
1387	break;
1388
1389	case 'O': /* octet mode */
1390	case 'I': /* binary mode */
1391	default:
1392	/* switch off ASCII */
1393	data->state.prefer_ascii = FALSE;
1394	break;
1395	}
1396	}
1397
1398	return CURLE_OK;
1399	}
1400	#endif

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/libs/curl-8.11.1/lib/tftp.c@ 108333

以其他格式下載: