Index: docs/libcurl/curl_easy_setopt.3 =================================================================== RCS file: /cvsroot/curl/curl/docs/libcurl/curl_easy_setopt.3,v retrieving revision 1.245 diff -u -r1.245 curl_easy_setopt.3 --- docs/libcurl/curl_easy_setopt.3 29 Dec 2008 21:26:11 -0000 1.245 +++ docs/libcurl/curl_easy_setopt.3 14 Jan 2009 22:21:05 -0000 @@ -1000,6 +1000,14 @@ transfer decoding will be disabled, if set to 1 it is enabled (default). libcurl does chunked transfer decoding by default unless this option is set to zero. (added in 7.16.2) +.SH TFTP OPTIONS +.IP CURLOPT_TFTPBLKSIZE +Specify block size to use for TFTP data transmission. Valid range as per +RFC 2348 is 8-65464 bytes. The default of 512 bytes will be used if this +option is not specified. The specified block size will only be used pending +support by the remote server. If the server does not return an option +acknowledgement or returns an option acknowledgement with no blksize, the +default of 512 bytes will be used. .SH FTP OPTIONS .IP CURLOPT_FTPPORT Pass a pointer to a zero terminated string as parameter. It will be used to Index: include/curl/curl.h =================================================================== RCS file: /cvsroot/curl/curl/include/curl/curl.h,v retrieving revision 1.371 diff -u -r1.371 curl.h --- include/curl/curl.h 10 Dec 2008 23:13:31 -0000 1.371 +++ include/curl/curl.h 14 Jan 2009 22:21:05 -0000 @@ -1150,6 +1150,9 @@ CINIT(PROXYUSERNAME, OBJECTPOINT, 175), CINIT(PROXYPASSWORD, OBJECTPOINT, 176), + /* block size for TFTP transfers */ + CINIT(TFTP_BLKSIZE, LONG, 177), + CURLOPT_LASTENTRY /* the last unused */ } CURLoption; Index: lib/tftp.c =================================================================== RCS file: /cvsroot/curl/curl/lib/tftp.c,v retrieving revision 1.76 diff -u -r1.76 tftp.c --- lib/tftp.c 13 Jan 2009 23:24:06 -0000 1.76 +++ lib/tftp.c 14 Jan 2009 22:21:06 -0000 @@ -5,7 +5,7 @@ * | (__| |_| | _ <| |___ * \___|\___/|_| \_\_____| * - * Copyright (C) 1998 - 2008, Daniel Stenberg, , et al. + * Copyright (C) 1998 - 2009, Daniel Stenberg, , et al. * * This software is licensed as described in the file COPYING, which * you should have received as part of this distribution. The terms @@ -26,7 +26,6 @@ #ifndef CURL_DISABLE_TFTP /* -- WIN32 approved -- */ #include -#include #include #include #include @@ -72,6 +71,7 @@ #include "strerror.h" #include "sockaddr.h" /* required for Curl_sockaddr_storage */ #include "url.h" +#include "rawstr.h" #define _MPRINTF_REPLACE /* use our functions only */ #include @@ -82,8 +82,13 @@ /* The last #include file should be: */ #include "memdebug.h" -/* RFC2348 allows the block size to be negotiated, but we don't support that */ -#define TFTP_BLOCKSIZE 512 +/* RFC2348 allows the block size to be negotiated */ +#define TFTP_BLKSIZE_DEFAULT 512 +#define TFTP_BLKSIZE_MIN 8 +#define TFTP_BLKSIZE_MAX 65464 +#define TFTP_OPTION_BLKSIZE "blksize" +#define TFTP_OPTION_TSIZE "tsize" +#define TFTP_OPTION_INTERVAL "interval" typedef enum { TFTP_MODE_NETASCII=0, @@ -104,6 +109,7 @@ TFTP_EVENT_DATA = 3, TFTP_EVENT_ACK = 4, TFTP_EVENT_ERROR = 5, + TFTP_EVENT_OACK = 6, TFTP_EVENT_TIMEOUT } tftp_event_t; @@ -124,7 +130,7 @@ } tftp_error_t; typedef struct tftp_packet { - unsigned char data[2 + 2 + TFTP_BLOCKSIZE]; + unsigned char *data; } tftp_packet_t; typedef struct tftp_state_data { @@ -143,7 +149,9 @@ struct Curl_sockaddr_storage remote_addr; socklen_t remote_addrlen; ssize_t rbytes; - int sbytes; + size_t sbytes; + size_t blksize; + int requested_blksize; tftp_packet_t rpacket; tftp_packet_t spacket; } tftp_state_data_t; @@ -153,6 +161,7 @@ static CURLcode tftp_rx(tftp_state_data_t *state, tftp_event_t event) ; static CURLcode tftp_tx(tftp_state_data_t *state, tftp_event_t event) ; static CURLcode tftp_connect(struct connectdata *conn, bool *done); +static CURLcode tftp_disconnect(struct connectdata *conn); static CURLcode tftp_do(struct connectdata *conn, bool *done); static CURLcode tftp_done(struct connectdata *conn, CURLcode, bool premature); @@ -175,7 +184,7 @@ ZERO_NULL, /* proto_getsock */ ZERO_NULL, /* doing_getsock */ ZERO_NULL, /* perform_getsock */ - ZERO_NULL, /* disconnect */ + tftp_disconnect, /* disconnect */ PORT_TFTP, /* defport */ PROT_TFTP /* protocol */ }; @@ -256,7 +265,7 @@ state->retry_time=1; infof(state->conn->data, - "set timeouts for state %d; Total %d, retry %d maxtry %d\n", + "set timeouts for state %d; Total %d, retry %d maxtry %d\n", state->state, (state->max_time-state->start_time), state->retry_time, state->retry_max); @@ -294,11 +303,143 @@ return (unsigned short)((packet->data[2] << 8) | packet->data[3]); } +static size_t Curl_strnlen(const char *string, size_t maxlen) +{ + const char *end = memchr (string, '\0', maxlen); + return end ? (size_t) (end - string) : maxlen; +} + +static const char *tftp_option_get(const char *buf, size_t len, + const char **option, const char **value) +{ + size_t loc; + + loc = Curl_strnlen( buf, len ); + loc++; /* NULL term */ + + if (loc >= len) + return NULL; + *option = buf; + + loc += Curl_strnlen( buf+loc, len-loc ); + loc++; /* NULL term */ + + if (loc > len) + return NULL; + *value = &buf[strlen(*option) + 1]; + + return &buf[loc]; +} + +static CURLcode tftp_parse_option_ack(tftp_state_data_t *state, + const char *ptr, int len) +{ + const char *tmp = ptr; + struct SessionHandle *data = state->conn->data; + + /* if OACK doesn't contain blksize option, the default (512) must be used */ + state->blksize = TFTP_BLKSIZE_DEFAULT; + + while (tmp < ptr + len) { + const char *option, *value; + + tmp = tftp_option_get(tmp, ptr + len - tmp, &option, &value); + if(tmp == NULL) { + failf(data, "Malformed ACK packet, rejecting"); + return CURLE_TFTP_ILLEGAL; + } + + infof(data, "got option=(%s) value=(%s)\n", option, value); + + if(checkprefix(option, TFTP_OPTION_BLKSIZE)) { + int blksize; + + blksize = strtol( value, NULL, 10 ); + + if(!blksize) { + failf(data, "invalid blocksize value in OACK packet"); + return CURLE_TFTP_ILLEGAL; + } + else if(blksize > TFTP_BLKSIZE_MAX) { + failf(data, "%s (%d)", "blksize is larger than max supported", + TFTP_BLKSIZE_MAX); + return CURLE_TFTP_ILLEGAL; + } + else if(blksize < TFTP_BLKSIZE_MIN) { + failf(data, "%s (%d)", "blksize is smaller than min supported", + TFTP_BLKSIZE_MIN); + return CURLE_TFTP_ILLEGAL; + } + else if (blksize > state->requested_blksize) { + /* could realloc pkt buffers here, but the spec doesn't call out + * support for the server requesting a bigger blksize than the client + * requests */ + failf(data, "%s (%d)", + "server requested blksize larger than allocated", blksize); + return CURLE_TFTP_ILLEGAL; + } + + state->blksize = blksize; + infof(data, "%s (%d) %s (%d)\n", "blksize parsed from OACK", + state->blksize, "requested", state->requested_blksize); + } + else if(checkprefix(option, TFTP_OPTION_TSIZE)) { + long tsize = 0; + + tsize = strtol( value, NULL, 10 ); + if(!tsize) { + failf(data, "invalid tsize value in OACK packet"); + return CURLE_TFTP_ILLEGAL; + } + Curl_pgrsSetDownloadSize(data, tsize); + infof(data, "%s (%d)\n", "tsize parsed from OACK", tsize); + } + } + + return CURLE_OK; +} + +static size_t tftp_option_add(tftp_state_data_t *state, size_t csize, + char *buf, const char *option) +{ + if( ( strlen(option) + csize + 1U ) > state->blksize ) + return 0; + strcpy(buf, option); + return( strlen(option) + 1 ); +} + +static int tftp_connect_for_tx(tftp_state_data_t *state, tftp_event_t event) +{ + int res = 0; + struct SessionHandle *data = state->conn->data; + + infof(data, "%s\n", "Connected for transmit"); + state->state = TFTP_STATE_TX; + res = tftp_set_timeouts(state); + if(res) + return(res); + return tftp_tx(state, event); +} + +static int tftp_connect_for_rx(tftp_state_data_t *state, tftp_event_t event) +{ + int res = 0; + struct SessionHandle *data = state->conn->data; + + infof(data, "%s\n", "Connected for receive"); + state->state = TFTP_STATE_RX; + res = tftp_set_timeouts(state); + if(res) + return(res); + return tftp_rx(state, event); +} + static CURLcode tftp_send_first(tftp_state_data_t *state, tftp_event_t event) { int sbytes; const char *mode = "octet"; char *filename; + char buf[8]; struct SessionHandle *data = state->conn->data; CURLcode res = CURLE_OK; @@ -322,7 +463,7 @@ /* If we are uploading, send an WRQ */ setpacketevent(&state->spacket, TFTP_EVENT_WRQ); state->conn->data->req.upload_fromhere = - (char *)&state->spacket.data[4]; + (char *)state->spacket.data+4; if(data->set.infilesize != -1) Curl_pgrsSetUploadSize(data, data->set.infilesize); } @@ -331,17 +472,40 @@ setpacketevent(&state->spacket, TFTP_EVENT_RRQ); } /* As RFC3617 describes the separator slash is not actually part of the - file name so we skip the always-present first letter of the path string. */ + file name so we skip the always-present first letter of the path + string. */ filename = curl_easy_unescape(data, &state->conn->data->state.path[1], 0, NULL); if(!filename) return CURLE_OUT_OF_MEMORY; - snprintf((char *)&state->spacket.data[2], - TFTP_BLOCKSIZE, + snprintf((char *)state->spacket.data+2, + state->blksize, "%s%c%s%c", filename, '\0', mode, '\0'); - sbytes = 4 + (int)strlen(filename) + (int)strlen(mode); - sbytes = sendto(state->sockfd, (void *)&state->spacket, + sbytes = 4 + strlen(filename) + strlen(mode); + + /* add tsize option */ + sbytes += tftp_option_add(state, sbytes, + (char *)state->spacket.data+sbytes, + TFTP_OPTION_TSIZE); + sbytes += tftp_option_add(state, sbytes, + (char *)state->spacket.data+sbytes, "0"); + /* add blksize option */ + snprintf( buf, sizeof(buf), "%d", state->requested_blksize ); + sbytes += tftp_option_add(state, sbytes, + (char *)state->spacket.data+sbytes, + TFTP_OPTION_BLKSIZE); + sbytes += tftp_option_add(state, sbytes, + (char *)state->spacket.data+sbytes, buf ); + /* add timeout option */ + snprintf( buf, sizeof(buf), "%d", state->retry_time ); + sbytes += tftp_option_add(state, sbytes, + (char *)state->spacket.data+sbytes, + TFTP_OPTION_INTERVAL); + sbytes += tftp_option_add(state, sbytes, + (char *)state->spacket.data+sbytes, buf ); + + sbytes = sendto(state->sockfd, (void *)state->spacket.data, sbytes, 0, state->conn->ip_addr->ai_addr, state->conn->ip_addr->ai_addrlen); @@ -351,21 +515,22 @@ Curl_safefree(filename); break; + case TFTP_EVENT_OACK: + if(data->set.upload) { + res = tftp_connect_for_tx(state, event); + } + else { + res = tftp_connect_for_rx(state, event); + } + break; + case TFTP_EVENT_ACK: /* Connected for transmit */ - infof(data, "%s\n", "Connected for transmit"); - state->state = TFTP_STATE_TX; - res = tftp_set_timeouts(state); - if(res) - break; - return tftp_tx(state, event); + res = tftp_connect_for_tx(state, event); + break; - case TFTP_EVENT_DATA: /* connected for receive */ - infof(data, "%s\n", "Connected for receive"); - state->state = TFTP_STATE_RX; - res = tftp_set_timeouts(state); - if(res) - break; - return tftp_rx(state, event); + case TFTP_EVENT_DATA: /* Connected for receive */ + res = tftp_connect_for_rx(state, event); + break; case TFTP_EVENT_ERROR: state->state = TFTP_STATE_FIN; @@ -394,7 +559,6 @@ switch(event) { case TFTP_EVENT_DATA: - /* Is this the block we expect? */ rblock = getrpacketblock(&state->rpacket); if((state->block+1) != rblock) { @@ -423,7 +587,7 @@ } /* Check if completed (That is, a less than full packet is received) */ - if(state->rbytes < (ssize_t)sizeof(state->spacket)){ + if(state->rbytes < (ssize_t)state->blksize+4){ state->state = TFTP_STATE_FIN; } else { @@ -431,6 +595,25 @@ } break; + case TFTP_EVENT_OACK: + /* ACK option acknowledgement so we can move on to data */ + state->block = 0; + state->retries = 0; + setpacketevent(&state->spacket, TFTP_EVENT_ACK); + setpacketblock(&state->spacket, state->block); + sbytes = sendto(state->sockfd, (void *)state->spacket.data, + 4, SEND_4TH_ARG, + (struct sockaddr *)&state->remote_addr, + state->remote_addrlen); + if(sbytes < 0) { + failf(data, "%s", Curl_strerror(state->conn, SOCKERRNO)); + return CURLE_SEND_ERROR; + } + + /* we're ready to RX data */ + state->state = TFTP_STATE_RX; + break; + case TFTP_EVENT_TIMEOUT: /* Increment the retry count and fail if over the limit */ state->retries++; @@ -442,7 +625,7 @@ } else { /* Resend the previous ACK */ - sbytes = sendto(state->sockfd, (void *)&state->spacket, + sbytes = sendto(state->sockfd, (void *)state->spacket.data, 4, SEND_4TH_ARG, (struct sockaddr *)&state->remote_addr, state->remote_addrlen); @@ -518,11 +701,12 @@ state->retries = 0; setpacketevent(&state->spacket, TFTP_EVENT_DATA); setpacketblock(&state->spacket, state->block); - if(state->block > 1 && state->sbytes < TFTP_BLOCKSIZE) { + if(state->block > 1 && state->sbytes < state->blksize) { state->state = TFTP_STATE_FIN; return CURLE_OK; } - res = Curl_fillreadbuffer(state->conn, TFTP_BLOCKSIZE, &state->sbytes); + res = Curl_fillreadbuffer(state->conn, state->blksize, + (int *)&state->sbytes); if(res) return res; sbytes = sendto(state->sockfd, (void *)state->spacket.data, @@ -551,7 +735,7 @@ } else { /* Re-send the data packet */ - sbytes = sendto(state->sockfd, (void *)&state->spacket, + sbytes = sendto(state->sockfd, (void *)state->spacket.data, 4+state->sbytes, SEND_4TH_ARG, (struct sockaddr *)&state->remote_addr, state->remote_addrlen); @@ -614,6 +798,25 @@ return res; } +/********************************************************** + * + * tftp_disconnect + * + * The disconnect callback + * + **********************************************************/ +static CURLcode tftp_disconnect(struct connectdata *conn) +{ + tftp_state_data_t *state = conn->data->state.proto.tftp; + + /* done, free dynamically allocated pkt buffers */ + if(state) { + Curl_safefree(state->rpacket.data); + Curl_safefree(state->spacket.data); + } + + return CURLE_OK; +} /********************************************************** * @@ -626,7 +829,9 @@ { CURLcode code; tftp_state_data_t *state; - int rc; + int blksize, rc; + + blksize = TFTP_BLKSIZE_DEFAULT; /* If there already is a protocol-specific struct allocated for this sessionhandle, deal with it */ @@ -640,12 +845,36 @@ return CURLE_OUT_OF_MEMORY; } + /* alloc pkt buffers based on specified blksize */ + if(conn->data->set.tftp_blksize) + { + blksize = conn->data->set.tftp_blksize; + if(blksize > TFTP_BLKSIZE_MAX || blksize < TFTP_BLKSIZE_MIN ) + return CURLE_TFTP_ILLEGAL; + } + + if(!state->rpacket.data) { + state->rpacket.data = calloc(1, blksize + 2 + 2); + + if(!state->rpacket.data) + return CURLE_OUT_OF_MEMORY; + } + + if(!state->spacket.data) { + state->spacket.data = calloc(1, blksize + 2 + 2); + + if(!state->spacket.data) + return CURLE_OUT_OF_MEMORY; + } + conn->bits.close = FALSE; /* keep it open if possible */ state->conn = conn; state->sockfd = state->conn->sock[FIRSTSOCKET]; state->state = TFTP_STATE_START; state->error = TFTP_ERR_NONE; + state->blksize = TFTP_BLKSIZE_DEFAULT; + state->requested_blksize = blksize; ((struct sockaddr *)&state->local_addr)->sa_family = (unsigned short)(conn->ip_addr->ai_family); @@ -769,8 +998,8 @@ /* Receive the packet */ fromlen = sizeof(fromaddr); state->rbytes = (ssize_t)recvfrom(state->sockfd, - (void *)&state->rpacket, - sizeof(state->rpacket), + (void *)state->rpacket.data, + state->blksize+4, 0, (struct sockaddr *)&fromaddr, &fromlen); @@ -796,7 +1025,7 @@ if(state->rbytes > 4 && ((state->block+1) == getrpacketblock(&state->rpacket))) { code = Curl_client_write(conn, CLIENTWRITE_BODY, - (char *)&state->rpacket.data[4], + (char *)state->rpacket.data+4, state->rbytes-4); if(code) return code; @@ -806,10 +1035,17 @@ break; case TFTP_EVENT_ERROR: state->error = (tftp_error_t)getrpacketblock(&state->rpacket); - infof(data, "%s\n", (const char *)&state->rpacket.data[4]); + infof(data, "%s\n", (const char *)state->rpacket.data+4); break; case TFTP_EVENT_ACK: break; + case TFTP_EVENT_OACK: + code = tftp_parse_option_ack(state, + (const char *)state->rpacket.data+2, + state->rbytes-2); + if(code) + return code; + break; case TFTP_EVENT_RRQ: case TFTP_EVENT_WRQ: default: Index: lib/url.c =================================================================== RCS file: /cvsroot/curl/curl/lib/url.c,v retrieving revision 1.780 diff -u -r1.780 url.c --- lib/url.c 8 Jan 2009 00:31:49 -0000 1.780 +++ lib/url.c 14 Jan 2009 22:21:08 -0000 @@ -917,6 +917,12 @@ */ data->set.ftp_response_timeout = va_arg( param , long ) * 1000; break; + case CURLOPT_TFTP_BLKSIZE: + /* + * TFTP option that specifies the block size to use for data transmission + */ + data->set.tftp_blksize = va_arg(param, long); + break; case CURLOPT_DIRLISTONLY: /* * An option that changes the command to one that asks for a list Index: lib/urldata.h =================================================================== RCS file: /cvsroot/curl/curl/lib/urldata.h,v retrieving revision 1.401 diff -u -r1.401 urldata.h --- lib/urldata.h 13 Jan 2009 06:44:03 -0000 1.401 +++ lib/urldata.h 14 Jan 2009 22:21:08 -0000 @@ -1423,6 +1423,7 @@ long timeout; /* in milliseconds, 0 means no timeout */ long connecttimeout; /* in milliseconds, 0 means no timeout */ long ftp_response_timeout; /* in milliseconds, 0 means no timeout */ + long tftp_blksize ; /* in bytes, 0 means use default */ curl_off_t infilesize; /* size of file to upload, -1 means unknown */ long low_speed_limit; /* bytes/second */ long low_speed_time; /* number of seconds */