Cleanup HttpHeaderProcessor take 2

Decided to keep the 'if(' -> 'if (' stuff, as I formatted the whole file
and so it is internally consistent within the file. Also, too much
hassle.

src/HttpHeaderProcessor.cc

@@ -85,12 +85,13 @@ HttpHeaderProcessor::HttpHeaderProcessor(ParserMode mode)
 HttpHeaderProcessor::~HttpHeaderProcessor() {}
 
 namespace {
-size_t getToken(std::string& buf,
+size_t
-                const unsigned char* data, size_t length, size_t off)
+getToken(std::string& buf, const unsigned char* data, size_t length, size_t off)
 {
-  size_t j;
+  size_t j = off;
-  for(j = off; j < length && !util::isLws(data[j]) && !util::isCRLF(data[j]);
+  while (j < length && !util::isLws(data[j]) && !util::isCRLF(data[j])) {
-      ++j);
+    ++j;
+  }
   buf.append(&data[off], &data[j]);
   return j - 1;
 }
@@ -98,22 +99,28 @@ size_t getToken(std::string& buf,
 
 namespace {
 size_t getFieldNameToken(std::string& buf,
-                         const unsigned char* data, size_t length, size_t off)
+                         const unsigned char* data,
+                         size_t length,
+                         size_t off)
 {
-  size_t j;
+  size_t j = off;
-  for(j = off; j < length && data[j] != ':' &&
+  while (j < length && data[j] != ':' && !util::isLws(data[j]) &&
-        !util::isLws(data[j]) && !util::isCRLF(data[j]); ++j);
+         !util::isCRLF(data[j])) {
+    ++j;
+  }
   buf.append(&data[off], &data[j]);
   return j - 1;
 }
 } // namespace
 
 namespace {
-size_t getText(std::string& buf,
+size_t
-               const unsigned char* data, size_t length, size_t off)
+getText(std::string& buf, const unsigned char* data, size_t length, size_t off)
 {
-  size_t j;
+  size_t j = off;
-  for(j = off; j < length && !util::isCRLF(data[j]); ++j);
+  while (j < length && !util::isCRLF(data[j])) {
+    ++j;
+  }
   buf.append(&data[off], &data[j]);
   return j - 1;
 }
@@ -121,10 +128,14 @@ size_t getText(std::string& buf,
 
 namespace {
 size_t ignoreText(std::string& buf,
-                  const unsigned char* data, size_t length, size_t off)
+                  const unsigned char* data,
+                  size_t length,
+                  size_t off)
 {
-  size_t j;
+  size_t j = off;
-  for(j = off; j < length && !util::isCRLF(data[j]); ++j);
+  while (j < length && !util::isCRLF(data[j])) {
+    ++j;
+  }
   return j - 1;
 }
 } // namespace
@@ -139,145 +150,183 @@ bool HttpHeaderProcessor::parse(const unsigned char* data, size_t length)
     case PREV_METHOD:
       if (util::isLws(c) || util::isCRLF(c)) {
         throw DL_ABORT_EX("Bad Request-Line: missing method");
-      } else {
+      }
+
       i = getToken(buf_, data, length, i);
       state_ = METHOD;
-      }
       break;
+
     case METHOD:
       if (util::isLws(c)) {
         result_->setMethod(buf_);
         buf_.clear();
         state_ = PREV_PATH;
-      } else if(util::isCRLF(c)) {
-        throw DL_ABORT_EX("Bad Request-Line: missing request-target");
-      } else {
-        i = getToken(buf_, data, length, i);
-      }
         break;
+      }
+
+      if (util::isCRLF(c)) {
+        throw DL_ABORT_EX("Bad Request-Line: missing request-target");
+      }
+
+      i = getToken(buf_, data, length, i);
+      break;
+
     case PREV_PATH:
       if (util::isCRLF(c)) {
         throw DL_ABORT_EX("Bad Request-Line: missing request-target");
-      } else if(!util::isLws(c)) {
+      }
+
+      if (util::isLws(c)) {
+        break;
+      }
+
       i = getToken(buf_, data, length, i);
       state_ = PATH;
-      }
       break;
+
     case PATH:
       if (util::isLws(c)) {
         result_->setRequestPath(buf_);
         buf_.clear();
         state_ = PREV_REQ_VERSION;
-      } else if(util::isCRLF(c)) {
-        throw DL_ABORT_EX("Bad Request-Line: missing HTTP-version");
-      } else {
-        i = getToken(buf_, data, length, i);
-      }
         break;
+      }
+
+      if (util::isCRLF(c)) {
+        throw DL_ABORT_EX("Bad Request-Line: missing HTTP-version");
+      }
+
+      i = getToken(buf_, data, length, i);
+      break;
+
     case PREV_REQ_VERSION:
       if (util::isCRLF(c)) {
         throw DL_ABORT_EX("Bad Request-Line: missing HTTP-version");
-      } else if(!util::isLws(c)) {
+      }
+
+      if (util::isLws(c)) {
+        break;
+      }
+
       i = getToken(buf_, data, length, i);
       state_ = REQ_VERSION;
-      }
       break;
+
     case REQ_VERSION:
       if (util::isCRLF(c)) {
         result_->setVersion(buf_);
         buf_.clear();
-        if(c == '\n') {
+        state_ = c == '\n' ? PREV_FIELD_NAME : PREV_EOL;
-          state_ = PREV_FIELD_NAME;
-        } else {
-          state_ = PREV_EOL;
-        }
-      } else if(util::isLws(c)) {
-        throw DL_ABORT_EX("Bad Request-Line: LWS after HTTP-version");
-      } else {
-        i = getToken(buf_, data, length, i);
-      }
         break;
+      }
+
+      if (util::isLws(c)) {
+        throw DL_ABORT_EX("Bad Request-Line: LWS after HTTP-version");
+      }
+
+      i = getToken(buf_, data, length, i);
+      break;
+
     case PREV_RES_VERSION:
       if (util::isLws(c) || util::isCRLF(c)) {
         throw DL_ABORT_EX("Bad Status-Line: missing HTTP-version");
-      } else {
+      }
+
       i = getToken(buf_, data, length, i);
       state_ = RES_VERSION;
-      }
       break;
+
     case RES_VERSION:
       if (util::isLws(c)) {
         result_->setVersion(buf_);
         buf_.clear();
         state_ = PREV_STATUS_CODE;
-      } else if(util::isCRLF(c)) {
+        break;
+      }
+
+      if (util::isCRLF(c)) {
         throw DL_ABORT_EX("Bad Status-Line: missing status-code");
       }
+
       break;
+
     case PREV_STATUS_CODE:
       if (util::isCRLF(c)) {
         throw DL_ABORT_EX("Bad Status-Line: missing status-code");
-      } else if(!util::isLws(c)) {
+      }
+
+      if (!util::isLws(c)) {
         state_ = STATUS_CODE;
         i = getToken(buf_, data, length, i);
       }
+
       break;
+
     case STATUS_CODE:
-      if(util::isLws(c) || util::isCRLF(c)) {
+      if (!util::isLws(c) && !util::isCRLF(c)) {
+        i = getToken(buf_, data, length, i);
+        break;
+      }
+
+      {
         int statusCode = -1;
         if (buf_.size() == 3 && util::isNumber(buf_.begin(), buf_.end())) {
-          statusCode = (buf_[0]-'0')*100 + (buf_[1]-'0')*10 + (buf_[2]-'0');
+          statusCode =
+              (buf_[0] - '0') * 100 + (buf_[1] - '0') * 10 + (buf_[2] - '0');
+        }
+        if (statusCode < 100) {
+          throw DL_ABORT_EX("Bad status code: bad status-code");
         }
-        if(statusCode >= 100) {
         result_->setStatusCode(statusCode);
         buf_.clear();
-        } else {
-          throw DL_ABORT_EX("Bad status code: bad status-code");
       }
       if (c == '\r') {
         state_ = PREV_EOL;
-        } else if(c == '\n') {
-          state_ = PREV_FIELD_NAME;
-        } else {
-          state_ = PREV_REASON_PHRASE;
-        }
-      } else {
-        i = getToken(buf_, data, length, i);
-      }
         break;
+      }
+
+      if (c == '\n') {
+        state_ = PREV_FIELD_NAME;
+        break;
+      }
+
+      state_ = PREV_REASON_PHRASE;
+      break;
+
     case PREV_REASON_PHRASE:
       if (util::isCRLF(c)) {
         // The reason-phrase is completely optional.
-        if(c == '\n') {
+        state_ = c == '\n' ? PREV_FIELD_NAME : PREV_EOL;
-          state_ = PREV_FIELD_NAME;
+        break;
-        } else {
-          state_ = PREV_EOL;
       }
-      } else if(!util::isLws(c)) {
+
+      if (util::isLws(c)) {
+        break;
+      }
+
       state_ = REASON_PHRASE;
       i = getText(buf_, data, length, i);
-      }
       break;
+
     case REASON_PHRASE:
       if (util::isCRLF(c)) {
         result_->setReasonPhrase(buf_);
         buf_.clear();
-        if(c == '\n') {
+        state_ = c == '\n' ? PREV_FIELD_NAME : PREV_EOL;
-          state_ = PREV_FIELD_NAME;
-        } else {
-          state_ = PREV_EOL;
-        }
-      } else {
-        i = getText(buf_, data, length, i);
-      }
         break;
+      }
+
+      i = getText(buf_, data, length, i);
+      break;
+
     case PREV_EOL:
-      if(c == '\n') {
+      if (c != '\n') {
-        state_ = PREV_FIELD_NAME;
-      } else {
         throw DL_ABORT_EX("Bad HTTP header: missing LF");
       }
+
+      state_ = PREV_FIELD_NAME;
       break;
+
     case PREV_FIELD_NAME:
       if (util::isLws(c)) {
         if (lastFieldName_.empty()) {
@@ -285,7 +334,9 @@ bool HttpHeaderProcessor::parse(const unsigned char* data, size_t length)
         }
         // Evil Multi-line header field
         state_ = FIELD_VALUE;
-      } else {
+        break;
+      }
+
       if (!lastFieldName_.empty()) {
         if (lastFieldHdKey_ != HttpHeader::MAX_INTERESTING_HEADER) {
           result_->put(lastFieldHdKey_, util::strip(buf_));
@@ -296,66 +347,94 @@ bool HttpHeaderProcessor::parse(const unsigned char* data, size_t length)
       }
       if (c == '\n') {
         state_ = HEADERS_COMPLETE;
-        } else if(c == '\r') {
+        break;
+      }
+
+      if (c == '\r') {
         state_ = PREV_EOH;
-        } else if(c == ':') {
+        break;
+      }
+
+      if (c == ':') {
         throw DL_ABORT_EX("Bad HTTP header: field name starts with ':'");
-        } else {
+      }
+
       state_ = FIELD_NAME;
       i = getFieldNameToken(lastFieldName_, data, length, i);
-        }
-      }
       break;
+
     case FIELD_NAME:
       if (util::isLws(c) || util::isCRLF(c)) {
         throw DL_ABORT_EX("Bad HTTP header: missing ':'");
-      } else if(c == ':') {
+      }
+
+      if (c == ':') {
         util::lowercase(lastFieldName_);
         lastFieldHdKey_ = idInterestingHeader(lastFieldName_.c_str());
         state_ = PREV_FIELD_VALUE;
-      } else {
-        i = getFieldNameToken(lastFieldName_, data, length, i);
-      }
         break;
+      }
+
+      i = getFieldNameToken(lastFieldName_, data, length, i);
+      break;
+
     case PREV_FIELD_VALUE:
       if (c == '\r') {
         state_ = PREV_EOL;
-      } else if(c == '\n') {
+        break;
+      }
+
+      if (c == '\n') {
         state_ = PREV_FIELD_NAME;
-      } else if(!util::isLws(c)) {
+        break;
+      }
+
+      if (util::isLws(c)) {
+        break;
+      }
+
       state_ = FIELD_VALUE;
       if (lastFieldHdKey_ == HttpHeader::MAX_INTERESTING_HEADER) {
         i = ignoreText(buf_, data, length, i);
-        } else {
-          i = getText(buf_, data, length, i);
-        }
-      }
         break;
+      }
+
+      i = getText(buf_, data, length, i);
+      break;
+
     case FIELD_VALUE:
       if (c == '\r') {
         state_ = PREV_EOL;
-      } else if(c == '\n') {
+        break;
+      }
+
+      if (c == '\n') {
         state_ = PREV_FIELD_NAME;
-      } else {
+        break;
+      }
+
       if (lastFieldHdKey_ == HttpHeader::MAX_INTERESTING_HEADER) {
         i = ignoreText(buf_, data, length, i);
-        } else {
-          i = getText(buf_, data, length, i);
-        }
-      }
         break;
+      }
+
+      i = getText(buf_, data, length, i);
+      break;
+
     case PREV_EOH:
-      if(c == '\n') {
+      if (c != '\n') {
-        state_ = HEADERS_COMPLETE;
-      } else {
         throw DL_ABORT_EX("Bad HTTP header: "
                           "missing LF at the end of the header");
       }
+
+      state_ = HEADERS_COMPLETE;
       break;
+
     case HEADERS_COMPLETE:
       goto fin;
     }
   }
+
 fin:
   // See Apache's documentation
   // http://httpd.apache.org/docs/2.2/en/mod/core.html about size
@@ -364,6 +443,7 @@ bool HttpHeaderProcessor::parse(const unsigned char* data, size_t length)
   if (lastFieldName_.size() > 1024 || buf_.size() > 8192) {
     throw DL_ABORT_EX("Too large HTTP header");
   }
+
   lastBytesProcessed_ = i;
   headers_.append(&data[0], &data[i]);
   return state_ == HEADERS_COMPLETE;

src/HttpHeaderProcessor.h

@@ -45,7 +45,8 @@ namespace aria2 {
 
 class HttpHeader;
 
-class HttpHeaderProcessor {
+class HttpHeaderProcessor
+{
 public:
   enum ParserMode {
     CLIENT_PARSER,
@@ -82,6 +83,7 @@ public:
    * Resets internal status and ready for next header processing.
    */
   void clear();
+
 private:
   ParserMode mode_;
   int state_;