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 18 by douglas, 2002-12-09T21:40:12-08:00 vs.
Revision 24 by douglas, 2002-12-22T00:58:21-08:00

# Line 62 | Line 62 | HttpHandler::HttpHandler()
62          }
63   #endif // _WIN32
64  
65 –        begin = 0;
65          length = 0;
66          chunked = false;
67   }
# Line 133 | Line 132 | bool HttpHandler::handle(URL &url, bool
132                  delete [] port;
133          }
134  
135 + //      putline("Referer: " + ¿referer?);
136          putline("Connection: close");
137          putline();
138  
# Line 151 | Line 151 | bool HttpHandler::handle(URL &url, bool
151                  unsigned dot = line.find('.');
152                  unsigned space = line.find(' ');
153  
154 <                unsigned major = strtoul(line.substr(5, dot - 5).c_str(), 0, 0);
155 <                unsigned minor = strtoul(line.substr(dot + 1, space - dot - 1).c_str(), 0,
156 <                        0);
154 >                unsigned major = strtoul(line.substr(5, dot - 5).c_str(), 0, 10);
155 >                unsigned minor = strtoul(line.substr(dot + 1, space - dot - 1).c_str(),
156 >                        0, 10);
157  
158 <                if (major > 1 || minor < 1)
158 >                if (major > 1)
159                  {
160 <                        cerr << program << ": Potentially Incompatible Server: HTTP/" << major
161 <                                << "." << minor << "\n";
160 >                        cerr << program << ": Potentially Incompatible Server: HTTP/" <<
161 >                                major << "." << minor << "\n";
162  
163                          return answer;
164                  }
165  
166 <                response = code(strtoul(line.substr(space + 1).c_str(), 0, 0));
166 >                response = code(strtoul(line.substr(space + 1).c_str(), 0, 10));
167  
168                  if (response < ok) do line = getline(); while (line != "");
169          }
# Line 182 | Line 182 | bool HttpHandler::handle(URL &url, bool
182  
183                          while (isspace(value[0])) value.erase(0, 1);
184  
185 < //                      if (field =
185 >                        if (field == "Content-Type")
186 >                        {
187 >                                type = value;
188 >                        }
189 >                        else if (field == "Content-Length")
190 >                        {
191 >                                length = strtoul(value.c_str(), 0, 10);
192 >                        }
193 >                        else if (field == "Location")
194 >                        {
195 >                                location = value;
196 >                        }
197 >                        else if (field == "Transfer-Encoding")
198 >                        {
199 >                                chunked = value == "chunked";
200 >                        }
201                  }
202          }
203          while (line != "");
# Line 217 | Line 232 | bool HttpHandler::handle(URL &url, bool
232                  break;
233          }
234  
235 +        if (!head && answer) populate();
236 +
237          return answer;
238   }
239  
240   HttpHandler& HttpHandler::getline(string& line, char endline)
241   {
242 <        int end = page.find(endline, begin);
243 <        int newline = page.find('\n', begin);
242 >        unsigned end = page.find(endline);
243 >        unsigned newline = page.find('\n');
244  
245          if (newline < end || end == string::npos)
246          {
247                  end = newline;
248          }
249  
250 <        line = page.substr(begin, end - begin);
251 <
235 <        if (end == string::npos)
236 <        {
237 <                begin = end;
238 <        }
239 <        else
240 <        {
241 <                begin = end + 1;
242 <        }
250 >        line = page.substr(0, end);
251 >        page.erase(0, (end == string::npos ? end : end + 1));
252  
253          return *this;
254   }
255  
247 – bool HttpHandler::good()
248 – {
249 –        bool answer = true;
250 –
251 –        if (begin >= page.length())
252 –        {
253 –                answer = false;
254 –        }
255 –        else if (begin == string::npos)
256 –        {
257 –                answer = false;
258 –        }
259 –
260 –        return answer;
261 – }
262 –
256   void HttpHandler::clear()
257   {
258          closesocket(http);
# Line 267 | Line 260 | void HttpHandler::clear()
260          type = "";
261          length = 0;
262          location = "";
270 –        begin = 0;
263          page = "";
264          chunked = false;
265   }
266  
267 + void HttpHandler::populate()
268 + {
269 +        if (!chunked)
270 +        {
271 +                unsigned left = length;
272 +
273 +                while (left > 0)
274 +                {
275 +                        memset(buffer, 0, BUFSIZ + 1);
276 +
277 +                        unsigned bytes = left > BUFSIZ ? BUFSIZ : left;
278 +                        unsigned received;
279 +
280 +                        if ((received = recv(http, buffer, bytes, 0)) == SOCKET_ERROR)
281 +                        {
282 +                                error(program + ": Recv");
283 +                                exit(1);
284 +                        }
285 +                        else if (received != bytes)
286 +                        {
287 +                                left -= received;
288 +                                page += buffer;
289 +
290 +                                memset(buffer, 0, BUFSIZ + 1);
291 +
292 +                                bytes -= received;
293 +                                if (recv(http, buffer, bytes, 0) == SOCKET_ERROR)
294 +                                {
295 +                                        error(program + ": Recv");
296 +                                        exit(1);
297 +                                }
298 +                        }
299 +
300 +                        page += buffer;
301 +                        left -= bytes;
302 +                }
303 +        }
304 +        else
305 +        {
306 +                unsigned chunk;
307 +
308 +                do
309 +                {
310 +                        chunk = strtoul(getline().c_str(), 0, 16);
311 +
312 +                        unsigned left = chunk;
313 +
314 +                        while (left > 0)
315 +                        {
316 +                                memset(buffer, 0, BUFSIZ + 1);
317 +
318 +                                unsigned bytes = left > BUFSIZ ? BUFSIZ : left;
319 +                                unsigned received;
320 +
321 +                                if ((received = recv(http, buffer, bytes, 0)) == SOCKET_ERROR)
322 +                                {
323 +                                        error(program + ": Recv");
324 +                                        exit(1);
325 +                                }
326 +                                else if (received != bytes)
327 +                                {
328 +                                        left -= received;
329 +                                        page += buffer;
330 +
331 +                                        memset(buffer, 0, BUFSIZ + 1);
332 +
333 +                                        bytes -= received;
334 +                                        if (recv(http, buffer, bytes, 0) == SOCKET_ERROR)
335 +                                        {
336 +                                                error(program + ": Recv");
337 +                                                exit(1);
338 +                                        }
339 +                                }
340 +
341 +                                page += buffer;
342 +                                left -= bytes;
343 +                        }
344 +
345 +                        getline();
346 +                        length += chunk;
347 +                }
348 +                while (chunk > 0);
349 +        }
350 +
351 +        for (unsigned index = 0; index < page.length(); index++)
352 +        {
353 +                if (page[index] == '\r' && (index + 1 < page.length()) ? page[index +
354 +                        1] == '\n' : false)
355 +                {
356 +                        page.erase(index, 1);
357 +                }
358 +                else if (page[index] == '\r')
359 +                {
360 +                        page[index] = '\n';
361 +                }
362 +        }
363 + }
364 +
365   void HttpHandler::putline(const string line)
366   {
367          sprintf(buffer, "%s\r\n", line.c_str());

Diff Legend

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