update engine: 32- and 64-bit compile

src/platform/update_engine/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 <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <algorithm>
 #include <string>
 #include <vector>
 #include "chromeos/obsolete_logging.h"
 
 using std::min;
@@ skipping 64 matching lines @@
       perror("write");
       return;
     }
     bytes_written += r;
   }
   LOG(INFO) << "WriteString wrote " << bytes_written << " bytes";
 }
 
 string Itoa(off_t num) {
   char buf[100] = {0};
-  snprintf(buf, sizeof(buf), "%lld", num);
+  snprintf(buf, sizeof(buf), "%" PRIi64, num);
   return buf;
 }
 
 void WriteHeaders(int fd, bool support_range, off_t full_size,
                   off_t start_offset) {
   LOG(INFO) << "writing headers";
   WriteString(fd, "HTTP/1.1 200 OK\r\n");
   WriteString(fd, "Content-Type: application/octet-stream\r\n");
   if (support_range) {
     WriteString(fd, "Accept-Ranges: bytes\r\n");
     WriteString(fd, string("Content-Range: bytes ") + Itoa(start_offset) +
                 "-" + Itoa(full_size - 1) + "/" + Itoa(full_size) + "\r\n");
   }
   off_t content_length = full_size;
   if (support_range)
     content_length -= start_offset;
   WriteString(fd, string("Content-Length: ") + Itoa(content_length) + "\r\n");
   WriteString(fd, "\r\n");
 }
 
 void HandleQuitQuitQuit(int fd) {
+  WriteHeaders(fd, true, 0, 0);
   exit(0);
 }
 
 void HandleBig(int fd, const HttpRequest& request) {
   const off_t full_length = kBigLength;
   WriteHeaders(fd, true, full_length, request.offset);
   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);
 }
 
 // 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);
-  const off_t content_length = min(9000LL, full_length - request.offset);
+  const off_t content_length =
+      min(static_cast<off_t>(9000), full_length - request.offset);
   const bool should_sleep = (request.offset % (9000 * 7)) == 0;
 
   string buf;
 
   for (int i = request.offset; i % 10; i++)
     buf.append(1, 'a' + (i % 10));
-  while (buf.size() < content_length)
+  while (static_cast<off_t>(buf.size()) < content_length)
     buf.append("abcdefghij");
   buf.resize(content_length);
 
   if (!should_sleep) {
     LOG(INFO) << "writing data blob of size " << buf.size();
     WriteString(fd, buf);
   } else {
     string::size_type half_way_point = buf.size() / 2;
     LOG(INFO) << "writing small data blob of size " << half_way_point;
     WriteString(fd, buf.substr(0, half_way_point));
@@ skipping 68 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;
 }