X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fuclient.git;a=blobdiff_plain;f=uclient-http.c;h=ebe77582368ebee4f7a50482f49b154b12371b16;hp=574dc0177a9d99054095a4d4aaf1d47428c5d6b6;hb=HEAD;hpb=cabb2e2641cea551d60b5b15f6cb1d092e6fbb03

diff --git a/uclient-http.c b/uclient-http.c
index 574dc01..ebe7758 100644
--- a/uclient-http.c
+++ b/uclient-http.c
@@ -15,10 +15,13 @@
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
+#include <sys/socket.h>
 #include <stdio.h>
 #include <ctype.h>
 #include <unistd.h>
 #include <stdint.h>
+#include <string.h>
+#include <fcntl.h>
 
 #include <libubox/ustream.h>
 #include <libubox/ustream-ssl.h>
@@ -89,6 +92,8 @@ struct uclient_http {
 	long read_chunked;
 	long content_length;
 
+	int usock_flags;
+
 	uint32_t nc;
 
 	struct blob_buf headers;
@@ -107,6 +112,8 @@ static const char * const uclient_http_prefix[] = {
 	[__PREFIX_MAX] = NULL
 };
 
+static int uclient_http_connect(struct uclient *cl);
+
 static int uclient_do_connect(struct uclient_http *uh, const char *port)
 {
 	socklen_t sl;
@@ -117,10 +124,13 @@ static int uclient_do_connect(struct uclient_http *uh, const char *port)
 
 	memset(&uh->uc.remote_addr, 0, sizeof(uh->uc.remote_addr));
 
-	fd = usock_inet(USOCK_TCP | USOCK_NONBLOCK, uh->uc.url->host, port, &uh->uc.remote_addr);
+	fd = usock_inet_timeout(USOCK_TCP | USOCK_NONBLOCK | uh->usock_flags,
+				uh->uc.url->host, port, &uh->uc.remote_addr,
+				uh->uc.timeout_msecs);
 	if (fd < 0)
 		return -1;
 
+	fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
 	ustream_fd_init(&uh->ufd, fd);
 
 	sl = sizeof(uh->uc.local_addr);
@@ -188,6 +198,9 @@ static void uclient_notify_eof(struct uclient_http *uh)
 			return;
 	}
 
+	if (uh->content_length < 0 && uh->read_chunked >= 0)
+		uh->uc.data_eof = true;
+
 	uclient_backend_set_eof(&uh->uc);
 
 	if (uh->connection_close)
@@ -274,7 +287,19 @@ static void uclient_http_process_headers(struct uclient_http *uh)
 	uh->auth_type = uclient_http_update_auth_type(uh);
 }
 
-static void
+static bool uclient_request_supports_body(enum request_type req_type)
+{
+	switch (req_type) {
+	case REQ_POST:
+	case REQ_PUT:
+	case REQ_DELETE:
+		return true;
+	default:
+		return false;
+	}
+}
+
+static int
 uclient_http_add_auth_basic(struct uclient_http *uh)
 {
 	struct uclient_url *url = uh->uc.url;
@@ -282,11 +307,16 @@ uclient_http_add_auth_basic(struct uclient_http *uh)
 	char *auth_buf;
 
 	if (auth_len > 512)
-		return;
+		return -EINVAL;
 
 	auth_buf = alloca(base64_len(auth_len) + 1);
+	if (!auth_buf)
+		return -ENOMEM;
+
 	base64_encode(url->auth, auth_len, auth_buf);
 	ustream_printf(uh->us, "Authorization: Basic %s\r\n", auth_buf);
+
+	return 0;
 }
 
 static char *digest_unquote_sep(char **str)
@@ -355,11 +385,14 @@ get_cnonce(char *dest)
 {
 	uint32_t val = 0;
 	FILE *f;
+	size_t n;
 
 	f = fopen("/dev/urandom", "r");
 	if (f) {
-		fread(&val, sizeof(val), 1, f);
+		n = fread(&val, sizeof(val), 1, f);
 		fclose(f);
+		if (n != 1)
+			return;
 	}
 
 	bin_to_hex(dest, &val, sizeof(val));
@@ -400,14 +433,15 @@ static void add_field(char **buf, int *ofs, int *len, const char *name, const ch
 	*ofs = cur - *buf;
 }
 
-static void
+static int
 uclient_http_add_auth_digest(struct uclient_http *uh)
 {
 	struct uclient_url *url = uh->uc.url;
 	const char *realm = NULL, *opaque = NULL;
 	const char *user, *password;
-	char *buf, *next;
+	char *buf, *next, *buf_orig;
 	int len, ofs;
+	int err = 0;
 
 	char cnonce_str[9];
 	char nc_str[9];
@@ -421,14 +455,21 @@ uclient_http_add_auth_digest(struct uclient_http *uh)
 	};
 
 	len = strlen(uh->auth_str) + 1;
-	if (len > 512)
-		return;
+	if (len > 512) {
+		err = -EINVAL;
+		goto fail;
+	}
 
 	buf = alloca(len);
+	if (!buf) {
+		err = -ENOMEM;
+		goto fail;
+	}
+
 	strcpy(buf, uh->auth_str);
 
 	/* skip auth type */
-	strsep(&buf, " ");
+	buf_orig = strsep(&buf, " ");
 
 	next = buf;
 	while (*next) {
@@ -462,8 +503,10 @@ uclient_http_add_auth_digest(struct uclient_http *uh)
 		*dest = digest_unquote_sep(&next);
 	}
 
-	if (!realm || !data.qop || !data.nonce)
-		return;
+	if (!realm || !data.qop || !data.nonce) {
+		err = -EINVAL;
+		goto fail_buf;
+	}
 
 	sprintf(nc_str, "%08x", uh->nc++);
 	get_cnonce(cnonce_str);
@@ -477,10 +520,17 @@ uclient_http_add_auth_digest(struct uclient_http *uh)
 		char *user_buf;
 
 		len = password - url->auth;
-		if (len > 256)
-			return;
+		if (len > 256) {
+			err = -EINVAL;
+			goto fail_buf;
+		}
 
 		user_buf = alloca(len + 1);
+		if (!user_buf) {
+			err = -ENOMEM;
+			goto fail_buf;
+		}
+
 		strncpy(user_buf, url->auth, len);
 		user_buf[len] = 0;
 		user = user_buf;
@@ -507,59 +557,78 @@ uclient_http_add_auth_digest(struct uclient_http *uh)
 		add_field(&buf, &ofs, &len, "opaque", opaque);
 
 	ustream_printf(uh->us, "Authorization: Digest nc=%s, qop=%s%s\r\n", data.nc, data.qop, buf);
+
 	free(buf);
+
+	return 0;
+
+fail_buf:
+	free(buf_orig);
+fail:
+	return err;
 }
 
-static void
+static int
 uclient_http_add_auth_header(struct uclient_http *uh)
 {
 	if (!uh->uc.url->auth)
-		return;
+		return 0;
 
 	switch (uh->auth_type) {
 	case AUTH_TYPE_UNKNOWN:
 	case AUTH_TYPE_NONE:
 		break;
 	case AUTH_TYPE_BASIC:
-		uclient_http_add_auth_basic(uh);
-		break;
+		return uclient_http_add_auth_basic(uh);
 	case AUTH_TYPE_DIGEST:
-		uclient_http_add_auth_digest(uh);
-		break;
+		return uclient_http_add_auth_digest(uh);
 	}
+
+	return 0;
 }
 
-static void
+static int
 uclient_http_send_headers(struct uclient_http *uh)
 {
 	struct uclient_url *url = uh->uc.url;
 	struct blob_attr *cur;
 	enum request_type req_type = uh->req_type;
-	int rem;
+	bool literal_ipv6;
+	int err, rem;
 
 	if (uh->state >= HTTP_STATE_HEADERS_SENT)
-		return;
+		return 0;
 
 	if (uh->uc.proxy_url)
 		url = uh->uc.proxy_url;
 
+	literal_ipv6 = strchr(url->host, ':');
+
 	ustream_printf(uh->us,
 		"%s %s HTTP/1.1\r\n"
-		"Host: %s\r\n",
-		request_types[req_type],
-		url->location, url->host);
+		"Host: %s%s%s%s%s\r\n",
+		request_types[req_type], url->location,
+		literal_ipv6 ? "[" : "",
+		url->host,
+		literal_ipv6 ? "]" : "",
+		url->port ? ":" : "",
+		url->port ? url->port : "");
 
 	blobmsg_for_each_attr(cur, uh->headers.head, rem)
 		ustream_printf(uh->us, "%s: %s\r\n", blobmsg_name(cur), (char *) blobmsg_data(cur));
 
-	if (uh->req_type == REQ_POST || uh->req_type == REQ_PUT)
+	if (uclient_request_supports_body(uh->req_type))
 		ustream_printf(uh->us, "Transfer-Encoding: chunked\r\n");
 
-	uclient_http_add_auth_header(uh);
+	err = uclient_http_add_auth_header(uh);
+	if (err)
+		return err;
 
 	ustream_printf(uh->us, "\r\n");
 
 	uh->state = HTTP_STATE_HEADERS_SENT;
+
+	return 0;
 }
 
 static void uclient_http_headers_complete(struct uclient_http *uh)
@@ -573,7 +642,7 @@ static void uclient_http_headers_complete(struct uclient_http *uh)
 
 	if (auth_type == AUTH_TYPE_UNKNOWN && uh->uc.status_code == 401 &&
 	    (uh->req_type == REQ_HEAD || uh->req_type == REQ_GET)) {
-		uclient_http_init_request(uh);
+		uclient_http_connect(&uh->uc);
 		uclient_http_send_headers(uh);
 		uh->state = HTTP_STATE_REQUEST_DONE;
 		return;
@@ -659,28 +728,33 @@ static void __uclient_notify_read(struct uclient_http *uh)
 		return;
 
 	if (uh->state < HTTP_STATE_RECV_DATA) {
-		char *sep;
+		char *sep, *next;
 		int cur_len;
 
 		do {
-			sep = strstr(data, "\r\n");
+			sep = strchr(data, '\n');
 			if (!sep)
 				break;
 
+			next = sep + 1;
+			if (sep > data && sep[-1] == '\r')
+				sep--;
+
 			/* Check for multi-line HTTP headers */
 			if (sep > data) {
-				if (!sep[2])
+				if (!*next)
 					return;
 
-				if (isspace(sep[2]) && sep[2] != '\r') {
+				if (isspace(*next) && *next != '\r' && *next != '\n') {
 					sep[0] = ' ';
-					sep[1] = ' ';
+					if (sep + 1 < next)
+						sep[1] = ' ';
 					continue;
 				}
 			}
 
 			*sep = 0;
-			cur_len = sep + 2 - data;
+			cur_len = next - data;
 			uclient_parse_http_line(uh, data);
 			if (seq != uh->seq)
 				return;
@@ -846,7 +920,7 @@ static int uclient_http_connect(struct uclient *cl)
 	struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
 	int ret;
 
-	if (!cl->eof || uh->disconnect)
+	if (!cl->eof || uh->disconnect || uh->connection_close)
 		uclient_http_disconnect(uh);
 
 	uclient_http_init_request(uh);
@@ -876,6 +950,9 @@ static struct uclient *uclient_http_alloc(void)
 	struct uclient_http *uh;
 
 	uh = calloc_a(sizeof(*uh));
+	if (!uh)
+		return NULL;
+
 	uh->disconnect_t.cb = uclient_http_disconnect_cb;
 	blob_buf_init(&uh->headers, 0);
 
@@ -951,11 +1028,14 @@ static int
 uclient_http_send_data(struct uclient *cl, const char *buf, unsigned int len)
 {
 	struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
+	int err;
 
 	if (uh->state >= HTTP_STATE_REQUEST_DONE)
 		return -1;
 
-	uclient_http_send_headers(uh);
+	err = uclient_http_send_headers(uh);
+	if (err)
+		return err;
 
 	if (len > 0) {
 		ustream_printf(uh->us, "%X\r\n", len);
@@ -970,12 +1050,16 @@ static int
 uclient_http_request_done(struct uclient *cl)
 {
 	struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
+	int err;
 
 	if (uh->state >= HTTP_STATE_REQUEST_DONE)
 		return -1;
 
-	uclient_http_send_headers(uh);
-	if (uh->req_type == REQ_POST || uh->req_type == REQ_PUT)
+	err = uclient_http_send_headers(uh);
+	if (err)
+		return err;
+
+	if (uclient_request_supports_body(uh->req_type))
 		ustream_printf(uh->us, "0\r\n\r\n");
 	uh->state = HTTP_STATE_REQUEST_DONE;
 
@@ -1059,7 +1143,7 @@ uclient_http_read(struct uclient *cl, char *buf, unsigned int len)
 	return len;
 }
 
-bool uclient_http_redirect(struct uclient *cl)
+int uclient_http_redirect(struct uclient *cl)
 {
 	struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
 	struct blobmsg_policy location = {
@@ -1085,13 +1169,15 @@ bool uclient_http_redirect(struct uclient *cl)
 	if (!tb)
 		return false;
 
-	url = uclient_get_url(blobmsg_data(tb), url->auth);
+	url = uclient_get_url_location(url, blobmsg_data(tb));
 	if (!url)
 		return false;
 
 	free(cl->url);
 	cl->url = url;
-	uclient_http_connect(cl);
+	if (uclient_http_connect(cl))
+		return -1;
+
 	uclient_http_request_done(cl);
 
 	return true;
@@ -1115,6 +1201,28 @@ int uclient_http_set_ssl_ctx(struct uclient *cl, const struct ustream_ssl_ops *o
 	return 0;
 }
 
+int uclient_http_set_address_family(struct uclient *cl, int af)
+{
+	struct uclient_http *uh = container_of(cl, struct uclient_http, uc);
+
+	if (cl->backend != &uclient_backend_http)
+		return -1;
+
+	switch (af) {
+	case AF_INET:
+		uh->usock_flags = USOCK_IPV4ONLY;
+		break;
+	case AF_INET6:
+		uh->usock_flags = USOCK_IPV6ONLY;
+		break;
+	default:
+		uh->usock_flags = 0;
+		break;
+	}
+
+	return 0;
+}
+
 const struct uclient_backend uclient_backend_http = {
 	.prefix = uclient_http_prefix,