AU: MultiHttpFetcher, an HttpFetcher for specific byte ranges

test_http_server.cc

 // Copyright (c) 2009 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file implements a simple HTTP server. It can exhibit odd behavior
 // that's useful for testing. For example, it's useful to test that
 // the updater can continue a connection if it's dropped, or that it
 // handles very slow data transfers.
 
 // To use this, simply make an HTTP connection to localhost:port and
 // GET a url.
 
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <sys/types.h>
 #include <errno.h>
 #include <inttypes.h>
+#include <netinet/in.h>
+#include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
 #include <unistd.h>
+
 #include <algorithm>
 #include <string>
 #include <vector>
-#include "base/logging.h"
+
+#include <base/logging.h>
 
 using std::min;
 using std::string;
 using std::vector;
 
 namespace chromeos_update_engine {
 
 struct HttpRequest {
   HttpRequest() : offset(0), return_code(200) {}
   string host;
@@ skipping 58 matching lines @@
     CHECK_NE(string::npos, host_end);
     string host = headers.substr(host_start, host_end - host_start);
 
     LOG(INFO) << "Host: " << host;
     request->host = host;
   }
 
   return true;
 }
 
-void WriteString(int fd, const string& str) {
+bool WriteString(int fd, const string& str) {
   unsigned int bytes_written = 0;
   while (bytes_written < str.size()) {
-    ssize_t r = write(fd, str.c_str() + bytes_written,
+    ssize_t r = write(fd, str.data() + bytes_written,
                       str.size() - bytes_written);
-    LOG(INFO) << "write() wrote " << r << " bytes";
     if (r < 0) {
       perror("write");
-      return;
+      LOG(INFO) << "write failed";
+      return false;
     }
     bytes_written += r;
   }
-  LOG(INFO) << "WriteString wrote " << bytes_written << " bytes";
+  return true;
 }
 
 string Itoa(off_t num) {
   char buf[100] = {0};
   snprintf(buf, sizeof(buf), "%" PRIi64, num);
   return buf;
 }
 
 void WriteHeaders(int fd, bool support_range, off_t full_size,
                   off_t start_offset, int return_code) {
@@ skipping 11 matching lines @@
   WriteString(fd, string("Content-Length: ") + Itoa(content_length) + "\r\n");
   WriteString(fd, "\r\n");
 }
 
 void HandleQuitQuitQuit(int fd) {
   WriteHeaders(fd, true, 0, 0, 200);
   exit(0);
 }
 
 void HandleBig(int fd, const HttpRequest& request, int big_length) {
+  LOG(INFO) << "starting big";
   const off_t full_length = big_length;
   WriteHeaders(fd, true, full_length, request.offset, request.return_code);
-  const off_t content_length = full_length - request.offset;
   int i = request.offset;
-  for (; i % 10; i++)
-    WriteString(fd, string(1, 'a' + (i % 10)));
-  CHECK_EQ(i % 10, 0);
-  for (; i < content_length; i += 10)
-    WriteString(fd, "abcdefghij");
-  CHECK_EQ(i, full_length);
+  bool success = true;
+  for (; (i % 10) && success; i++)
+    success = WriteString(fd, string(1, 'a' + (i % 10)));
+  if (success)
+    CHECK_EQ(i % 10, 0);
+  for (; (i < full_length) && success; i += 10) {
+    success = WriteString(fd, "abcdefghij");
+  }
+  if (success)
+    CHECK_EQ(i, full_length);
+  LOG(INFO) << "Done w/ big";
 }
 
 // This is like /big, but it writes at most 9000 bytes. Also,
 // half way through it sleeps for 70 seconds
 // (technically, when (offset % (9000 * 7)) == 0).
 void HandleFlaky(int fd, const HttpRequest& request) {
   const off_t full_length = kBigLength;
   WriteHeaders(fd, true, full_length, request.offset, request.return_code);
   const off_t content_length =
       min(static_cast<off_t>(9000), full_length - request.offset);
@@ skipping 77 matching lines @@
     HandleDefault(fd, request);
 
   close(fd);
 }
 
 }  // namespace chromeos_update_engine
 
 using namespace chromeos_update_engine;
 
 int main(int argc, char** argv) {
+  // Ignore SIGPIPE on write() to sockets.
+  signal(SIGPIPE, SIG_IGN);
+  
   socklen_t clilen;
   struct sockaddr_in server_addr;
   struct sockaddr_in client_addr;
   memset(&server_addr, 0, sizeof(server_addr));
   memset(&client_addr, 0, sizeof(client_addr));
 
   int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
   if (listen_fd < 0)
     LOG(FATAL) << "socket() failed";
 
@@ skipping 22 matching lines @@
     int client_fd = accept(listen_fd,
                            (struct sockaddr *) &client_addr,
                            &clilen);
     LOG(INFO) << "got past accept";
     if (client_fd < 0)
       LOG(FATAL) << "ERROR on accept";
     HandleConnection(client_fd);
   }
   return 0;
 }