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