pidgin3: comparison src/util.c

-:3769f413f073
+:8c224ef70efa
 	char *url;
 	gboolean full;
 	char *user_agent;
 	gboolean http11;
 	char *request;
+	gsize request_written;
 	gboolean include_headers;
 	int inpa;
-	gboolean sentreq;
+	gboolean got_headers;
-	gboolean startsaving;
 	gboolean has_explicit_data_len;
 	char *webdata;
 	unsigned long len;
 	unsigned long data_len;
 	}
 	return content_len;
 }
 static void
 url_fetched_cb(gpointer url_data, gint sock, GaimInputCondition cond)
 {
 	GaimFetchUrlData *gfud = url_data;
 	int len;
 	char buf[4096];
 	char *data_cursor;
 	gboolean got_eof = FALSE;
-	if (sock == -1)
+	while((len = read(sock, buf, sizeof(buf))) > 0) {
-	{
-		gfud->callback(gfud->user_data, NULL, 0);
-		destroy_fetch_url_data(gfud);
-		return;
-	}
-	if (!gfud->sentreq)
-	{
-		char *send;
-		char buf[1024];
-		if (gfud->request) {
-			send = gfud->request;
-		} else {
-			if (gfud->user_agent) {
-				/* Host header is not forbidden in HTTP/1.0 requests, and HTTP/1.1
-				 * clients must know how to handle the "chunked" transfer encoding.
-				 * Gaim doesn't know how to handle "chunked", so should always send
-				 * the Host header regardless, to get around some observed problems
-				 */
-				g_snprintf(buf, sizeof(buf),
-					"GET %s%s HTTP/%s\r\n"
-					"Connection: close\r\n"
-					"User-Agent: %s\r\n"
-					"Host: %s\r\n\r\n",
-					(gfud->full ? "" : "/"),
-					(gfud->full ? gfud->url : gfud->website.page),
-					(gfud->http11 ? "1.1" : "1.0"),
-					gfud->user_agent, gfud->website.address);
-			} else {
-				g_snprintf(buf, sizeof(buf),
-					"GET %s%s HTTP/%s\r\n"
-					"Connection: close\r\n"
-					"Host: %s\r\n\r\n",
-					(gfud->full ? "" : "/"),
-					(gfud->full ? gfud->url : gfud->website.page),
-					(gfud->http11 ? "1.1" : "1.0"),
-					gfud->website.address);
-			}
-			send = buf;
-		}
-		gaim_debug_misc("gaim_url_fetch", "Request: %s\n", send);
-		write(sock, send, strlen(send));
-		fcntl(sock, F_SETFL, O_NONBLOCK);
-		gfud->sentreq = TRUE;
-		gfud->inpa = gaim_input_add(sock, GAIM_INPUT_READ,
-			url_fetched_cb, url_data);
-		gfud->data_len = 4096;
-		gfud->webdata = g_malloc(gfud->data_len);
-		return;
-	}
-	while ((len = read(sock, buf, sizeof(buf))) > 0)
-	{
 		/* If we've filled up our butfer, make it bigger */
-		if ((gfud->len + len) >= gfud->data_len)
+		if((gfud->len + len) >= gfud->data_len) {
-		{
+			while((gfud->len + len) >= gfud->data_len)
-			gfud->data_len += MAX(((gfud->data_len) / 2), sizeof(buf));
+				gfud->data_len += sizeof(buf);
 			gfud->webdata = g_realloc(gfud->webdata, gfud->data_len);
 		}
 		data_cursor = gfud->webdata + gfud->len;
 		memcpy(data_cursor, buf, len);
 		gfud->webdata[gfud->len] = '\0';
-		if (!gfud->startsaving)
+		if(!gfud->got_headers) {
-		{
 			char *tmp;
 			/** See if we've reached the end of the headers yet */
-			if ((tmp = strstr(gfud->webdata, "\r\n\r\n"))) {
+			if((tmp = strstr(gfud->webdata, "\r\n\r\n"))) {
 				char * new_data;
 				guint header_len = (tmp + 4 - gfud->webdata);
 				size_t content_len, body_len = 0;
 				gaim_debug_misc("gaim_url_fetch", "Response headers: '%.*s'\n",
 				/* See if we can find a redirect. */
 				if (parse_redirect(gfud->webdata, header_len, sock, gfud))
 					return;
-				gfud->startsaving = TRUE;
+				gfud->got_headers = TRUE;
 				/* No redirect. See if we can find a content length. */
 				content_len = parse_content_len(gfud->webdata, header_len);
 				if (content_len == 0)
 			got_eof = TRUE;
 			break;
 		}
 	}
-	if (len <= 0) {
+	if(len <= 0) {
-		if (errno == EWOULDBLOCK) {
+		if(errno == EAGAIN) {
-			errno = 0;
 			return;
 		} else if (errno != ETIMEDOUT) {
 			got_eof = TRUE;
 		} else {
 			gaim_input_remove(gfud->inpa);
 		close(sock);
 		gfud->callback(gfud->user_data, gfud->webdata, gfud->len);
 		destroy_fetch_url_data(gfud);
 	}
+}
+static void
+url_fetch_connect_cb(gpointer url_data, gint sock, GaimInputCondition cond) {
+	GaimFetchUrlData *gfud = url_data;
+	int len, total_len;
+	if(sock == -1) {
+		gfud->callback(gfud->user_data, NULL, 0);
+		destroy_fetch_url_data(gfud);
+		return;
+	}
+	if (!gfud->request) {
+		if (gfud->user_agent) {
+			/* Host header is not forbidden in HTTP/1.0 requests, and HTTP/1.1
+			 * clients must know how to handle the "chunked" transfer encoding.
+			 * Gaim doesn't know how to handle "chunked", so should always send
+			 * the Host header regardless, to get around some observed problems
+			 */
+			gfud->request = g_strdup_printf(
+				"GET %s%s HTTP/%s\r\n"
+				"Connection: close\r\n"
+				"User-Agent: %s\r\n"
+				"Host: %s\r\n\r\n",
+				(gfud->full ? "" : "/"),
+				(gfud->full ? gfud->url : gfud->website.page),
+				(gfud->http11 ? "1.1" : "1.0"),
+				gfud->user_agent, gfud->website.address);
+		} else {
+			gfud->request = g_strdup_printf(
+				"GET %s%s HTTP/%s\r\n"
+				"Connection: close\r\n"
+				"Host: %s\r\n\r\n",
+				(gfud->full ? "" : "/"),
+				(gfud->full ? gfud->url : gfud->website.page),
+				(gfud->http11 ? "1.1" : "1.0"),
+				gfud->website.address);
+		}
+	}
+	gaim_debug_misc("gaim_url_fetch", "Request: '%s'\n", gfud->request);
+	if(!gfud->inpa)
+		gfud->inpa = gaim_input_add(sock, GAIM_INPUT_WRITE,
+			url_fetch_connect_cb, gfud);
+	total_len = strlen(gfud->request);
+	len = write(sock, gfud->request + gfud->request_written,
+			total_len - gfud->request_written);
+	if(len < 0 && errno == EAGAIN)
+		return;
+	else if(len < 0) {
+		gaim_input_remove(gfud->inpa);
+		close(sock);
+		gfud->callback(gfud->user_data, NULL, 0);
+		destroy_fetch_url_data(gfud);
+		return;
+	}
+	gfud->request_written += len;
+	if(gfud->request_written != total_len)
+		return;
+	gaim_input_remove(gfud->inpa);
+	gfud->inpa = gaim_input_add(sock, GAIM_INPUT_READ, url_fetched_cb,
+		gfud);
 }
 void
 gaim_url_fetch_request(const char *url, gboolean full,
 		const char *user_agent, gboolean http11,
 	gaim_url_parse(url, &gfud->website.address, &gfud->website.port,
 				   &gfud->website.page, &gfud->website.user, &gfud->website.passwd);
 	if (gaim_proxy_connect(NULL, gfud->website.address,
-								   gfud->website.port, url_fetched_cb,
+		gfud->website.port, url_fetch_connect_cb, gfud) != 0) {
-								   gfud) != 0)
-	{
 		destroy_fetch_url_data(gfud);
 		cb(user_data, g_strdup(_("g003: Error opening connection.\n")), 0);
 	}
 }
 	for(; *str; str = g_utf8_next_char(str)) {
 		gunichar wc = g_utf8_get_char(str);
 		/* super simple check. hopefully not too wrong. */
 		if(wc >= 0x80) {
 			g_string_append_printf(out, "&#%u;", (guint32) wc);
 		} else {
 			g_string_append_unichar(out, wc);
 		}
 	}
 	out = g_string_new("");
 	while( (b = strstr(buf, "&#")) ) {
 		gunichar wc;
 		int base = 0;
 		/* append everything leading up to the &# */
 		g_string_append_len(out, buf, b-buf);
 		b += 2; /* skip past the &# */
 		/* strtoul will handle 0x prefix as hex, but not x */
 		if(*b == 'x' || *b == 'X')
 			base = 16;
 		/* advances buf to the end of the ncr segment */
 	return ret;
 }
 /* previously conversation::find_nick() */
 gboolean
 gaim_utf8_has_word(const char *haystack, const char *needle)
 {
 	char *hay, *pin, *p;
 	int n;
 	gboolean ret = FALSE;

Mercurial > pidgin3 / file comparison

comparison: src/util.c

src/util.c