/**************************************************************************** * apps/netutils/libcurl4nx/curl4nx_easy_perform.c * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. The * ASF licenses this file to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance with the * License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations * under the License. * ****************************************************************************/ /**************************************************************************** * Included Files ****************************************************************************/ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "netutils/netlib.h" #include "netutils/curl4nx.h" #include "curl4nx_private.h" #if defined(CONFIG_NETUTILS_CODECS) # if defined(CONFIG_CODECS_URLCODE) # define WGET_USE_URLENCODE 1 # include "netutils/urldecode.h" # endif # if defined(CONFIG_CODECS_BASE64) # include "netutils/base64.h" # endif #else # undef CONFIG_CODECS_URLCODE # undef CONFIG_CODECS_BASE64 #endif /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ #define CURL4NX_STATE_STATUSLINE 0 #define CURL4NX_STATE_STATUSCODE 1 #define CURL4NX_STATE_STATUSREASON 2 #define CURL4NX_STATE_HEADERS 3 #define CURL4NX_STATE_DATA_NORMAL 4 #define CURL4NX_STATE_DATA_CHUNKED 5 /**************************************************************************** * Private Functions ****************************************************************************/ /**************************************************************************** * Name: curl4nx_easy_perform() * * Description: * Resolve the hostname to an IP address. There are 3 cases: * - direct IP: inet_aton is used * - using internal curl4nx resolution * - DNS resolution, if available ****************************************************************************/ /**************************************************************************** * Name: curl4nx_resolve * Description: * Translate a host name to an IP address (V4 only for the moment) * - either the host is a string with an IP * - either the known hosts were defined by CURL4NXOPT_ ****************************************************************************/ static int curl4nx_resolve(FAR struct curl4nx_s *handle, FAR char *hostname, FAR struct in_addr *ip) { int ret = inet_aton(hostname, ip); if (ret != 0) { return CURL4NXE_OK; /* IP address is valid */ } curl4nx_warn("Not a valid IP address, trying hostname resolution\n"); return CURL4NXE_COULDNT_RESOLVE_HOST; } /**************************************************************************** * Name: curl4nx_is_header * Description: * Return TRUE if buf contains header, then update off to point at the * beginning of header value ****************************************************************************/ static int curl4nx_is_header(FAR char *buf, int len, FAR const char *header, FAR int *off) { if (strncasecmp(buf, header, strlen(header))) { return false; } *off = strlen(header); while ((*off) < len && buf[*off] == ' ') { (*off)++; } return true; } /**************************************************************************** * Public Functions ****************************************************************************/ /**************************************************************************** * Name: curl4nx_easy_perform() ****************************************************************************/ int curl4nx_easy_perform(FAR struct curl4nx_s *handle) { struct sockaddr_in server; FILE * stream; /* IOSTREAM used to printf in the socket TODO avoid */ int rxoff; /* Current offset within RX buffer */ char tmpbuf[16]; /* Buffer to hold small strings */ int tmplen; /* Number of bytes used in tmpbuffer */ int state; /* Current state of the parser */ int ret; /* Return value from internal calls */ char * headerbuf; int headerlen; char * end; int cret = CURL4NXE_OK; /* Public return value */ bool redirected = false; /* Boolean to manage HTTP redirections */ bool chunked = false; unsigned long long done = 0; int redircount = 0; curl4nx_info("started\n"); stream = NULL; headerbuf = malloc(CONFIG_LIBCURL4NX_MAXHEADERLINE); if (!headerbuf) { cret = CURL4NXE_OUT_OF_MEMORY; goto abort; } if (handle->host[0] == 0 || handle->port == 0) { /* URL has not been set */ cret = CURL4NXE_URL_MALFORMAT; goto freebuf; } /* TODO: check that host and port have changed or are the same, so we can * recycle the socket for the next request. */ do { handle->sockfd = socket(AF_INET, SOCK_STREAM, 0); if (handle->sockfd < 0) { /* socket failed. It will set the errno appropriately */ curl4nx_err("ERROR: socket failed: %d\n", errno); cret = CURL4NXE_COULDNT_CONNECT; goto freebuf; } /* TODO: timeouts */ server.sin_family = AF_INET; server.sin_port = htons(handle->port); cret = curl4nx_resolve(handle, handle->host, &server.sin_addr); if (cret != CURL4NXE_OK) { /* Could not resolve host (or malformed IP address) */ curl4nx_err("ERROR: Failed to resolve hostname\n"); cret = CURL4NXE_COULDNT_RESOLVE_HOST; goto freebuf; } /* Connect to server. First we have to set some fields in the * 'server' address structure. The system will assign me an arbitrary * local port that is not in use. */ ret = connect(handle->sockfd, (struct sockaddr *)&server, sizeof(struct sockaddr_in)); if (ret < 0) { curl4nx_err("ERROR: connect failed: %d\n", errno); cret = CURL4NXE_COULDNT_CONNECT; goto close; } curl4nx_info("Connected...\n"); stream = fdopen(handle->sockfd, "wb"); /* Send request */ fprintf(stream, "%s %s HTTP/%d.%d\r\n", handle->method, handle->path, handle->version >> 4, handle->version & 0x0f); /* Send headers */ fprintf(stream, "Host: %s\r\n", handle->host); /* For the moment we do not support compression */ fprintf(stream, "Content-encoding: identity\r\n"); /* Send more headers */ /* End of headers */ fprintf(stream, "\r\n"); /* TODO send data */ fflush(stream); curl4nx_info("Request sent\n"); /* Now wait for the result */ redirected = false; /* for now */ state = CURL4NX_STATE_STATUSLINE; tmplen = 0; while (1) { ret = recv(handle->sockfd, handle->rxbuf, handle->rxbufsize, 0); if (ret < 0) { curl4nx_err("RECV failed, errno=%d\n", errno); cret = CURL4NXE_RECV_ERROR; goto close; } else if (ret == 0) { curl4nx_err("Connection lost\n"); cret = CURL4NXE_GOT_NOTHING; goto close; } curl4nx_info("Received %d bytes\n", ret); rxoff = 0; if (state == CURL4NX_STATE_STATUSLINE) { /* Accumulate HTTP/x.y until space */ while ((tmplen < sizeof(tmpbuf)) && (rxoff < ret)) { if (handle->rxbuf[rxoff] == ' ') { /* found space after http version */ tmpbuf[tmplen] = 0; /* Finish pending string */ rxoff++; curl4nx_info("received version: [%s]\n", tmpbuf); tmplen = 0; /* reset buffer to look at code */ state = CURL4NX_STATE_STATUSCODE; break; } /* Not a space: accumulate chars */ tmpbuf[tmplen] = handle->rxbuf[rxoff]; tmplen++; rxoff++; } /* Check for overflow, * version code should not fill the tmpbuf */ if (tmplen == sizeof(tmpbuf)) { /* extremely long http version -> invalid response */ curl4nx_err("Buffer overflow while reading version\n"); cret = CURL4NXE_RECV_ERROR; goto close; } /* No overflow and no space found: wait for next buffer */ } /* NO ELSE HERE, state may have changed and require new management * for the same rx buffer. */ if (state == CURL4NX_STATE_STATUSCODE) { /* Accumulate response code until space */ while ((tmplen < sizeof(tmpbuf)) && (rxoff < ret)) { if (handle->rxbuf[rxoff] == ' ') { /* Found space after http version */ tmpbuf[tmplen] = 0; /* Finish pending string */ rxoff++; curl4nx_info("received code: [%s]\n", tmpbuf); handle->status = strtol(tmpbuf, &end, 10); if (*end != 0) { curl4nx_err("Bad status code [%s]\n", tmpbuf); cret = CURL4NXE_RECV_ERROR; goto close; } tmplen = 0; /* reset buffer to look at code */ state = CURL4NX_STATE_STATUSREASON; break; } /* Not a space: accumulate chars */ tmpbuf[tmplen] = handle->rxbuf[rxoff]; tmplen++; rxoff++; } /* Check for overflow, * version code should not fill the tmpbuf */ if (tmplen == sizeof(tmpbuf)) { /* Extremely long http code -> invalid response */ curl4nx_err("Buffer overflow while reading code\n"); cret = CURL4NXE_RECV_ERROR; goto close; } /* No overflow and no space found: wait for next buffer */ } if (state == CURL4NX_STATE_STATUSREASON) { /* Accumulate response code until CRLF */ while (rxoff < ret) { if (handle->rxbuf[rxoff] == 0x0d || handle->rxbuf[rxoff] == 0x0a) { /* Accumulate all contiguous CR and LF in any order */ tmpbuf[tmplen] = handle->rxbuf[rxoff]; tmplen++; if (tmplen == 2) { if (tmpbuf[0] == 0x0d && tmpbuf[1] == 0x0a) { headerlen = 0; handle->content_length = 0; state = CURL4NX_STATE_HEADERS; break; } else { tmplen = 0; /* Reset search for CRLF */ } } } else { /* This char is not interesting: reset storage */ tmplen = 0; /* curl4nx_info("-> %c\n", handle->rxbuf[rxoff]); */ } rxoff++; } } if (state == CURL4NX_STATE_HEADERS) { while (rxoff < ret) { if (handle->rxbuf[rxoff] == 0x0d || handle->rxbuf[rxoff] == 0x0a) { /* Accumulate all contiguous CR and LF in any order */ tmpbuf[tmplen] = handle->rxbuf[rxoff]; tmplen++; if (tmplen == 2) { if (tmpbuf[0] == 0x0d && tmpbuf[1] == 0x0a) { if (headerlen == 0) /* Found an empty header */ { curl4nx_info("\n"); rxoff++; /* Skip this char */ state = chunked ? CURL4NX_STATE_DATA_CHUNKED : CURL4NX_STATE_DATA_NORMAL; break; } else { int off; curl4nx_iofunc_f func; headerbuf[headerlen] = 0; func = handle->headerfunc; if (func == NULL) { func = handle->writefunc; } func(headerbuf, headerlen, 1, handle->headerdata); /* Find the content-length */ if (curl4nx_is_header(headerbuf, headerlen, "content-length:", &off)) { handle->content_length = strtoull(headerbuf + off, &end, 10); if (*end != 0) { curl4nx_err("Stray chars after " "content length!\n"); cret = CURL4NXE_RECV_ERROR; goto close; } curl4nx_info("Found content length: " "%llu\n", handle->content_length); } /* Find the transfer encoding */ if (curl4nx_is_header(headerbuf, headerlen, "transfer-encoding:", &off)) { chunked = !strncasecmp(headerbuf + off, "chunked", 7); if (chunked) { curl4nx_info("Transfer using " "chunked format\n"); } } /* Find the location */ if (curl4nx_is_header(headerbuf, headerlen, "location:", &off)) { /* Parse the new URL if we get a * redirection code. */ if (handle->status >= 300 && handle->status < 400) { if (handle->flags & CURL4NX_FLAGS_FOLLOWLOCATION) { if ((handle->max_redirs > 0) && (redircount >= handle->max_redirs)) { curl4nx_info( "Too many redirections\n"); cret = CURL4NXE_TOO_MANY_REDIRECTS; goto close; } cret = curl4nx_easy_setopt( handle, CURL4NXOPT_URL, headerbuf + off); if (cret != CURL4NXE_OK) { goto close; } redirected = true; redircount += 1; curl4nx_info(" REDIRECTION (%d) -> %s\n", redircount, headerbuf + off); } } } /* Prepare for next header */ headerlen = 0; tmplen = 0; /* Reset search for CRLF */ } } else { tmplen = 0; /* Reset search for CRLF */ } } } else { tmplen = 0; /* Reset CRLF detection */ /* Plus one for final zero */ if (headerlen < (CONFIG_LIBCURL4NX_MAXHEADERLINE - 1)) { headerbuf[headerlen] = handle->rxbuf[rxoff]; headerlen++; } else { curl4nx_warn("prevented header overload\n"); } } rxoff++; } } if (state == CURL4NX_STATE_DATA_NORMAL) { if ((handle->flags & CURL4NX_FLAGS_FAILONERROR) && handle->status >= 400) { cret = CURL4NXE_HTTP_RETURNED_ERROR; goto close; } curl4nx_info("now in normal data state, rxoff=%d rxlen=%d\n", rxoff, ret); done += (ret - rxoff); handle->writefunc(handle->rxbuf + rxoff, ret - rxoff, 1, handle->writedata); if (handle->content_length != 0) { curl4nx_info("Done %llu of %llu\n", done, handle->content_length); if (handle->progressfunc) { handle->progressfunc(handle->progressdata, handle->content_length, done, 0, 0); } if (handle->content_length == done) { /* Transfer is complete */ goto close; } } } if (state == CURL4NX_STATE_DATA_CHUNKED) { if ((handle->flags & CURL4NX_FLAGS_FAILONERROR) && handle->status >= 400) { cret = CURL4NXE_HTTP_RETURNED_ERROR; goto close; } curl4nx_info("now in chunked data state, rxoff=%d rxlen=%d\n", rxoff, ret); curl4nx_err("Not supported yet.\n"); goto close; } } /* Done with this connection - this will also close the socket */ close: curl4nx_info("Closing\n"); if (stream) { fclose(stream); } } while (redirected); freebuf: free(headerbuf); abort: curl4nx_info("done\n"); return cret; }