ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/proj/trunk/Search/HttpHandler.cpp
(Generate patch)

Comparing trunk/Search/HttpHandler.cpp (file contents):
Revision 209 by douglas, 2003-07-18T00:26:41-07:00 vs.
Revision 350 by Douglas Thrift, 2004-05-27T20:29:11-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.21 2003/07/18 07:26:41 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
# Line 96 | Line 87 | HttpHandler::~HttpHandler()
87  
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 181 | Line 174 | bool HttpHandler::handle(URL &url, const
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 >                unsigned 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 != "");
200          }
# Line 213 | Line 206 | bool HttpHandler::handle(URL &url, const
206  
207                  if (line != "")
208                  {
209 <                        unsigned colon = line.find(':');
210 <
218 <                        string field = line.substr(0, colon);
219 <                        string value = line.substr(colon + 1);
209 >                        unsigned 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 244 | Line 237 | bool HttpHandler::handle(URL &url, const
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  
283          type = "";
284          length = 0;
285          location = "";
286 +
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 >                unsigned left(length);
301  
302                  while (left > 0)
303                  {
304                          memset(buffer, 0, BUFSIZ + 1);
305  
306 <                        unsigned bytes = left > BUFSIZ ? BUFSIZ : left;
306 >                        unsigned bytes(left > BUFSIZ ? BUFSIZ : left);
307                          long received;
308  
309                          while (true)
# Line 329 | Line 325 | void HttpHandler::populate()
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          }
# Line 351 | Line 346 | void HttpHandler::populate()
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 >                        unsigned left(chunk);
356  
357                          while (left > 0)
358                          {
359                                  memset(buffer, 0, BUFSIZ + 1);
360  
361 <                                unsigned bytes = left > BUFSIZ ? BUFSIZ : left;
361 >                                unsigned bytes(left > BUFSIZ ? BUFSIZ : left);
362                                  long received;
363  
364                                  while (true)
# Line 377 | Line 376 | void HttpHandler::populate()
376                                          {
377                                                  !tls ? error(program + ": Recv") : error(program +
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 (unsigned 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 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 >        unsigned 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 << "] = " << unsigned(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 209 by douglas, 2003-07-18T00:26:41-07:00 vs.
Revision 350 by Douglas Thrift, 2004-05-27T20:29:11-07:00

# Line 0 | Line 1
1 + native

Comparing trunk/Search/HttpHandler.cpp (property svn:keywords):
Revision 209 by douglas, 2003-07-18T00:26:41-07:00 vs.
Revision 350 by Douglas Thrift, 2004-05-27T20:29:11-07:00

# Line 0 | Line 1
1 + Id

Diff Legend

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