ViewVC Help

View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing

root/proj/trunk/Search/HttpHandler.cpp

Comparing trunk/Search/HttpHandler.cpp (file contents):
Revision 208 by douglas, 2003-07-18T00:17:10-07:00 vs.
Revision 365 by douglas, 2008-08-11T15:16:35-07:00

#	Line 1 | Line 1
1		/* ============================================================================
2		* Douglas Thrift's Search Engine License
3		*
4	<	* Copyright (C) 2002-2003, Douglas Thrift. All Rights Reserved.
4	>	* Copyright (C) 2002-2004, Douglas Thrift. All Rights Reserved.
5		* Redistribution and use in source and binary forms, with or without
6		* modification, are permitted provided that the following conditions are met:
7		*
#	Line 46 | Line 46
46		//
47		// Douglas Thrift
48		//
49	<	// $Id: HttpHandler.cpp,v 1.20 2003/07/18 07:17:10 douglas Exp $
49	>	// $Id$
50
51	<	#include "HttpHandler.h"
51	>	#include "HttpHandler.hpp"
52
53		// Lovely C Sockets!
54		#ifndef _WIN32
#	Line 59 | Line 59
59		#include <netinet/in.h>
60		#include <netdb.h>
61
62	–	#define INVALID_SOCKET -1
63	–	#define SOCKET_ERROR -1
64	–
62		inline int closesocket(SOCKET s) { return close(s); }
63		#endif
64
65	<	HttpHandler::HttpHandler()
65	>	#ifndef _OpenSSL_
66	>	HttpHandler::HttpHandler() : binary(false), length(0), chunked(false)
67	>	#else
68	>	HttpHandler::HttpHandler() : binary(false), length(0), chunked(false),
69	>	tls(false)
70	>	#endif
71		{
70	–	buffer = new char[BUFSIZ + 1];
71	–
72		#ifdef _WIN32
73		if (WSAStartup(MAKEWORD(2, 0), &data) != 0)
74		{
#	Line 76 | Line 76 | HttpHandler::HttpHandler()
76		exit(1);
77		}
78		#endif // _WIN32
79	–
80	–	binary = false;
81	–	length = 0;
82	–	chunked = false;
83	–	#ifdef _OpenSSL_
84	–	tls = false;
85	–	#endif
79		}
80
81		HttpHandler::~HttpHandler()
82		{
90	–	delete [] buffer;
91	–
83		#ifdef _WIN32
84		WSACleanup();
85		#endif // _WIN32
86		}
87
88	<	bool HttpHandler::handle(URL &url, const string referer, bool head)
88	>	bool HttpHandler::handle(URL &url, const string& referer, bool head)
89		{
90	<	bool answer = false;
90	>	bool answer(false);
91
92		if ((http = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
93		{
#	Line 112 | Line 103 | bool HttpHandler::handle(URL &url, const
103		if ((host = gethostbyname(url.getAddress().c_str())) == NULL)
104		{
105		error(program + ": Host: " + url.getAddress(), true);
106	+
107		return answer;
108		}
109
#	Line 122 | Line 114 | bool HttpHandler::handle(URL &url, const
114		SOCKET_ERROR)
115		{
116		error(program + ": Connect");
117	+
118		return answer;
119		}
120
#	Line 166 | Line 159 | bool HttpHandler::handle(URL &url, const
159		putline("Host: " + url.getAddress() + ':' + port.str());
160		}
161
162	<	if (referer != "")
162	>	if (!referer.empty())
163		{
164		putline("Referer: " + referer);
165		}
#	Line 174 | Line 167 | bool HttpHandler::handle(URL &url, const
167		putline("Connection: close");
168		putline();
169
170	<	code response;
170	>	Code response;
171		string line;
172
173		do
174		{
175		line = getline();
176
177	<	if (line.find("HTTP/") != 0)
185	<	{
186	<	return answer;
187	<	}
177	>	if (line.find("HTTP/") != 0) return answer;
178
179	<	unsigned dot = line.find('.');
180	<	unsigned space = line.find(' ');
179	>	size_t dot(line.find('.')), space(line.find(' ')), major, minor;
180	>	istringstream number(line.substr(5, dot - 5) + " " + line.substr(dot
181	>	+ 1, space - dot - 1));
182
183	<	unsigned major = strtoul(line.substr(5, dot - 5).c_str(), 0, 10);
184	<	unsigned minor = strtoul(line.substr(dot + 1, space - dot - 1).c_str(),
194	<	0, 10);
183	>	number >> major;
184	>	number >> minor;
185
186		if (major > 1)
187		{
#	Line 201 | Line 191 | bool HttpHandler::handle(URL &url, const
191		return answer;
192		}
193
194	<	response = code(strtoul(line.substr(space + 1).c_str(), 0, 10));
194	>	number.clear();
195	>	number.str(line.substr(space + 1, 3));
196	>
197	>	number >> response;
198
199	<	if (response < ok) do line = getline(); while (line != "");
199	>	if (response < ok) do line = getline(); while (!line.empty());
200		}
201		while (response < ok);
202
#	Line 211 | Line 204 | bool HttpHandler::handle(URL &url, const
204		{
205		line = getline();
206
207	<	if (line != "")
207	>	if (!line.empty())
208		{
209	<	unsigned colon = line.find(':');
210	<
218	<	string field = line.substr(0, colon);
219	<	string value = line.substr(colon + 1);
209	>	size_t colon(line.find(':'));
210	>	string field(line.substr(0, colon)), value(line.substr(colon + 1));
211
212		while (isspace(value[0])) value.erase(0, 1);
213
#	Line 226 | Line 217 | bool HttpHandler::handle(URL &url, const
217		}
218		else if (field == "Content-Length")
219		{
220	<	length = strtoul(value.c_str(), 0, 10);
220	>	istringstream number(value);
221	>
222	>	number >> length;
223		}
224		else if (field == "Location")
225		{
#	Line 238 | Line 231 | bool HttpHandler::handle(URL &url, const
231		}
232		}
233		}
234	<	while (line != "");
234	>	while (!line.empty());
235
236		switch (response)
237		{
238		case ok:
239		if (debug) cerr << "response = " << response << "\n";
240	+
241		answer = true;
242		break;
243		case choices:
#	Line 251 | Line 245 | bool HttpHandler::handle(URL &url, const
245		case found:
246		if (debug) cerr << "response = " << response << "\n"
247		<< "location = " << location << "\n";
248	+
249		location = getLink(location, url);
250		break;
251		case notfound:
#	Line 259 | Line 254 | bool HttpHandler::handle(URL &url, const
254		break;
255		default:
256		if (debug) cerr << "response = " << response << "\n";
257	<	if (response <= 299)
258	<	{
264	<	answer = true;
265	<	}
266	<	else if (response <= 399)
257	>
258	>	if (response <= 299) answer = true; else if (response <= 399)
259		{
260		location = getLink(location, url);
261		}
#	Line 277 | Line 269 | bool HttpHandler::handle(URL &url, const
269
270		void HttpHandler::clear()
271		{
272	+	#ifdef _OpenSSL_
273		if (tls)
274		{
275		SSL_shutdown(ssl);
276		SSL_free(ssl);
277		SSL_CTX_free(ctx);
278		}
279	+	#endif
280
281		closesocket(http);
282
289	–	type = "";
283		length = 0;
284	<	location = "";
284	>
285	>	type.erase();
286	>	location.erase();
287		page.clear();
288		page.str("");
289	+
290		chunked = false;
291		#ifdef _OpenSSL_
292		tls = false;
#	Line 301 | Line 297 | void HttpHandler::populate()
297		{
298		if (!chunked)
299		{
300	<	unsigned left = length;
300	>	size_t left(length);
301
302		while (left > 0)
303		{
304		memset(buffer, 0, BUFSIZ + 1);
305
306	<	unsigned bytes = left > BUFSIZ ? BUFSIZ : left;
306	>	size_t bytes(left > BUFSIZ ? BUFSIZ : left);
307		long received;
308
309		while (true)
#	Line 323 | Line 319 | void HttpHandler::populate()
319		SSL_read(ssl, buffer, bytes)) <= 0)
320		{
321		!tls ? error(program + ": Recv") : error(program +
322	<	": SSL Read", received);
322	>	": SSL Read", int(received));
323		}
324		#endif
325		else if (received != bytes)
326		{
327		left -= received;
328	+
329		page << buffer;
330
331		memset(buffer, 0, BUFSIZ + 1);
332
333		bytes -= received;
334		}
335	<	else
339	<	{
340	<	break;
341	<	}
335	>	else break;
336		}
337
338		page << buffer;
339	+
340		left -= bytes;
341		}
342		}
343		else
344		{
345	<	unsigned chunk;
345	>	size_t chunk;
346
347		do
348		{
349	<	chunk = strtoul(getline().c_str(), 0, 16);
349	>	istringstream number(getline());
350	>
351	>	number.setf(ios_base::hex, ios_base::basefield);
352
353	<	unsigned left = chunk;
353	>	number >> chunk;
354	>
355	>	size_t left(chunk);
356
357		while (left > 0)
358		{
359		memset(buffer, 0, BUFSIZ + 1);
360
361	<	unsigned bytes = left > BUFSIZ ? BUFSIZ : left;
361	>	size_t bytes(left > BUFSIZ ? BUFSIZ : left);
362		long received;
363
364		while (true)
#	Line 376 | Line 375 | void HttpHandler::populate()
375		SSL_read(ssl, buffer, bytes)) <= 0)
376		{
377		!tls ? error(program + ": Recv") : error(program +
378	<	": SSL Read", received);
378	>	": SSL Read", int(received));
379	>
380		exit(1);
381		}
382		#endif
#	Line 389 | Line 389 | void HttpHandler::populate()
389
390		bytes -= received;
391		}
392	<	else
393	<	{
394	<	break;
395	<	}
392	>	else break;
393		}
394
395		page << buffer;
396	+
397		left -= bytes;
398		}
399
400		getline();
401	+
402		length += chunk;
403		}
404		while (chunk > 0);
#	Line 407 | Line 406 | void HttpHandler::populate()
406
407		if (!binary)
408		{
409	<	string page = this->page.str();
409	>	string page(this->page.str());
410
411	<	for (unsigned index = 0; index < page.length(); index++)
411	>	for (size_t index(0); index < page.length(); index++)
412		{
413	<	if (page[index] == '\r' && (index + 1 < page.length()) ? page[index +
414	<	1] == '\n' : false)
413	>	if (page[index] == '\r' && (index + 1 < page.length()) ?
414	>	page[index + 1] == '\n' : false)
415		{
416		page.erase(index, 1);
417		}
#	Line 426 | Line 425 | void HttpHandler::populate()
425		}
426		}
427
428	<	void HttpHandler::putline(const string line)
428	>	void HttpHandler::putline(const string& line)
429		{
430		sprintf(buffer, "%s\r\n", line.c_str());
431
#	Line 761 | Line 760 | bool HttpHandler::starttls()
760		SSL_load_error_strings();
761		SSL_library_init();
762
763	<	//
763	>	#ifndef _urandomdev_
764	>	int pid(getpid()), now(time(NULL));
765	>	size_t seed(now > pid ? now - pid : pid - now);
766	>	char* junk = new char[seed % 30 + 2];
767	>
768	>	junk[0] = pid;
769	>	junk[seed % 30 + 1] = now;
770	>
771	>	srand(seed);
772	>
773	>	for (size_t index = 1; index < seed % 30 + 1; index++)
774	>	{
775	>	junk[index] = rand();
776	>	}
777	>
778	>	if (debug)
779	>	{
780	>	cerr << "junk = {\n";
781	>
782	>	for (size_t index = 1; index < seed % 30 + 2; index++)
783	>	{
784	>	cerr << "   [" << index << "] = " << size_t(junk[index]) << "\n";
785	>	}
786	>
787	>	cerr << "}\n";
788	>	}
789	>
790	>	RAND_seed(junk, seed % 30 + 2);
791	>
792	>	delete junk;
793	>	#else
794	>	if (debug) cerr << "junk = /dev/urandom\n";
795	>	#endif
796	>
797	>	ctx = SSL_CTX_new(TLSv1_client_method());
798	>
799	>	if (ctx == NULL)
800	>	{
801	>	cerr << program << ": SSL CTX New: "
802	>	<< ERR_reason_error_string(ERR_get_error()) << "\n";
803	>
804	>	return false;
805	>	}
806	>
807	>	ssl = SSL_new(ctx);
808	>
809	>	if (SSL_set_fd(ssl, http) == 0)
810	>	{
811	>	cerr << program << ": SSL Set FD: "
812	>	<< ERR_reason_error_string(ERR_get_error()) << "\n";
813	>
814	>	return false;
815	>	}
816	>
817	>	int number;
818	>
819	>	if ((number = SSL_connect(ssl)) <= 0)
820	>	{
821	>	error(program + ": SSL Connect", number);
822	>
823	>	return false;
824	>	}
825
826		return true;
827		}

Comparing trunk/Search/HttpHandler.cpp (property svn:eol-style):
Revision 208 by douglas, 2003-07-18T00:17:10-07:00 vs.
Revision 365 by douglas, 2008-08-11T15:16:35-07:00

#	Line 0 | Line 1
1	+	native

Comparing trunk/Search/HttpHandler.cpp (property svn:keywords):
Revision 208 by douglas, 2003-07-18T00:17:10-07:00 vs.
Revision 365 by douglas, 2008-08-11T15:16:35-07:00

#	Line 0 | Line 1
1	+	Id

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines