More code cleanups

src/uri.cc

@@ -105,19 +105,24 @@ bool parse(UriStruct& result, const std::string& uri)
   int rv;
   const char* p = uri.c_str();
   rv = uri_split(&res, p);
-  if(rv == 0) {
+  if(rv != 0) {
+    return false;
+  }
+
   result.protocol.assign(p + res.fields[USR_SCHEME].off,
                          res.fields[USR_SCHEME].len);
   result.host.assign(p + res.fields[USR_HOST].off, res.fields[USR_HOST].len);
-    if(res.port == 0) {
+  if (res.port == 0) {
     uint16_t defPort;
     if((defPort = getDefaultPort(result.protocol)) == 0) {
       return false;
     }
     result.port = defPort;
-    } else {
+  }
+  else {
     result.port = res.port;
   }
+
   if(res.field_set & (1 << USR_PATH)) {
     if(res.field_set & (1 << USR_BASENAME)) {
       result.dir.assign(p + res.fields[USR_PATH].off,
@@ -125,45 +130,51 @@ bool parse(UriStruct& result, const std::string& uri)
                         res.fields[USR_BASENAME].len);
       result.file.assign(p + res.fields[USR_BASENAME].off,
                           res.fields[USR_BASENAME].len);
-      } else {
+    }
+    else {
       result.dir.assign(p + res.fields[USR_PATH].off,
                         res.fields[USR_PATH].len);
       result.file = A2STR::NIL;
     }
-    } else {
+  }
+  else {
     result.dir = "/";
     result.file = A2STR::NIL;
   }
+
   if(res.field_set & (1 << USR_QUERY)) {
     result.query = "?";
     result.query.append(p + res.fields[USR_QUERY].off,
                         res.fields[USR_QUERY].len);
-    } else {
+  }
+  else {
     result.query = A2STR::NIL;
   }
+
   if(res.field_set & (1 << USR_USER)) {
     result.username.assign(p + res.fields[USR_USER].off,
                             res.fields[USR_USER].len);
     result.username = util::percentDecode(result.username.begin(),
                                           result.username.end());
-    } else {
+  }
+  else {
     result.username = A2STR::NIL;
   }
+
   if(res.field_set & (1 << USR_PASSWD)) {
     result.hasPassword = true;
     result.password.assign(p + res.fields[USR_PASSWD].off,
                             res.fields[USR_PASSWD].len);
     result.password = util::percentDecode(result.password.begin(),
                                           result.password.end());
-    } else {
+  }
+  else {
     result.hasPassword = false;
     result.password = A2STR::NIL;
   }
+
   result.ipv6LiteralAddress = res.flags & USF_IPV6ADDR;
   return true;
-  } else {
-    return false;
-  }
 }
 
 std::string getFieldString(const uri_split_result& res, int field,
@@ -171,9 +182,8 @@ std::string getFieldString(const uri_split_result& res, int field,
 {
   if(res.field_set & (1 << field)) {
     return std::string(base + res.fields[field].off, res.fields[field].len);
-  } else {
-    return "";
   }
+  return "";
 }
 
 std::string construct(const UriStruct& us)
@@ -193,39 +203,48 @@ std::string construct(const UriStruct& us)
     res += "[";
     res += us.host;
     res += "]";
-  } else {
+  }
+  else {
     res += us.host;
   }
-  uint16_t defPort= getDefaultPort(us.protocol);
+
+  uint16_t defPort = getDefaultPort(us.protocol);
   if(us.port != 0 && defPort != us.port) {
     res += fmt(":%u", us.port);
   }
+
   res += us.dir;
   if(us.dir.empty() || us.dir[us.dir.size()-1] != '/') {
     res += "/";
   }
+
   res += us.file;
   res += us.query;
   return res;
 }
 
-enum {
+namespace {
+  enum {
     NPATH_START,
     NPATH_SLASH,
     NPATH_SDOT,
     NPATH_DDOT,
     NPATH_PATHCOMP
-};
+  };
+}
 
 std::string normalizePath(std::string path)
 {
-  std::string::iterator begin = path.begin(), out = begin;
+  typedef std::string::iterator itr;
+
+  itr begin = path.begin(), out = begin;
   int state = NPATH_START;
   bool startWithSlash = false;
   std::vector<int> range;
   // 32 is arbitrary
   range.reserve(32);
-  for(std::string::iterator in = begin, eoi = path.end(); in != eoi; ++in) {
+
+  for(itr in = begin, eoi = path.end(); in != eoi; ++in) {
     switch(state) {
     case NPATH_START:
       switch(*in) {
@@ -295,6 +314,7 @@ std::string normalizePath(std::string path)
       break;
     }
   }
+
   switch(state) {
   case NPATH_SDOT:
     range.pop_back();
@@ -310,18 +330,21 @@ std::string normalizePath(std::string path)
   default:
     break;
   }
+
   if(startWithSlash) {
     ++out;
   }
+
   for(int i = 0; i < (int)range.size(); i += 2) {
-    std::string::iterator a = begin+range[i];
+    itr a = begin + range[i];
-    std::string::iterator b = begin+range[i+1];
+    itr b = begin + range[i+1];
     if(a == out) {
       out = b;
     } else {
       out = std::copy(a, b, out);
     }
   }
+
   path.erase(out, path.end());
   return path;
 }
@@ -333,16 +356,20 @@ std::string joinPath(std::string basePath,
 {
   if(newPathFirst == newPathLast) {
     return basePath;
-  } else if(basePath.empty() || *newPathFirst == '/') {
+  }
+
+  if(basePath.empty() || *newPathFirst == '/') {
     return normalizePath(std::string(newPathFirst, newPathLast));
-  } else if(basePath[basePath.size()-1] == '/') {
+  }
-    basePath.append(newPathFirst, newPathLast);
+
-    return normalizePath(basePath);
+  if(basePath[basePath.size()-1] == '/') {
-  } else {
-    basePath += "/";
     basePath.append(newPathFirst, newPathLast);
     return normalizePath(basePath);
   }
+
+  basePath += "/";
+  basePath.append(newPathFirst, newPathLast);
+  return normalizePath(basePath);
 }
 } // namespace
 
@@ -356,11 +383,13 @@ std::string joinUri(const std::string& baseUri, const std::string& uri)
   UriStruct us;
   if(parse(us, uri)) {
     return uri;
-  } else {
+  }
+
   UriStruct bus;
   if(!parse(bus, baseUri)) {
     return uri;
   }
+
   std::string::const_iterator qend;
   for(qend = uri.begin(); qend != uri.end(); ++qend) {
     if(*qend == '#') {
@@ -385,7 +414,6 @@ std::string joinUri(const std::string& baseUri, const std::string& uri)
   }
   res.append(end, qend);
   return res;
-  }
 }
 
 } // namespace uri

src/util.cc

@@ -279,8 +279,8 @@ bool isHexDigit(const char c)
 
 bool isHexDigit(const std::string& s)
 {
-  for(std::string::const_iterator i = s.begin(), eoi = s.end(); i != eoi; ++i) {
+  for (const auto& c : s) {
-    if(!isHexDigit(*i)) {
+    if(!isHexDigit(c)) {
       return false;
     }
   }
@@ -676,15 +676,15 @@ void computeHeadPieces
   if(head == 0) {
     return;
   }
-  for(auto fi = fileEntries.begin(), eoi = fileEntries.end(); fi != eoi; ++fi) {
+  for (const auto& fi: fileEntries) {
-    if((*fi)->getLength() == 0) {
+    if(fi->getLength() == 0) {
       continue;
     }
-    size_t lastIndex =
+    const size_t lastIndex = (fi->getOffset() +
-      ((*fi)->getOffset()+std::min(head, (*fi)->getLength())-1)/pieceLength;
+        std::min(head, fi->getLength()) - 1
-    for(size_t index = (*fi)->getOffset()/pieceLength;
+        ) / pieceLength;
-        index <= lastIndex; ++index) {
+    for(size_t idx = fi->getOffset() / pieceLength; idx <= lastIndex; ++idx) {
-      indexes.push_back(index);
+      indexes.push_back(idx);
     }
   }
 }
@@ -700,16 +700,16 @@ void computeTailPieces
   if(tail == 0) {
     return;
   }
-  for(auto fi = fileEntries.begin(), eoi = fileEntries.end(); fi != eoi; ++fi) {
+  for (const auto& fi: fileEntries) {
-    if((*fi)->getLength() == 0) {
+    if(fi->getLength() == 0) {
       continue;
     }
-    int64_t endOffset = (*fi)->getLastOffset();
+    int64_t endOffset = fi->getLastOffset();
-    size_t fromIndex =
+    size_t fromIndex = (endOffset - 1 - (std::min(tail, fi->getLength()) - 1)) /
-      (endOffset-1-(std::min(tail, (*fi)->getLength())-1))/pieceLength;
+      pieceLength;
-    for(size_t index = fromIndex; index <= (endOffset-1)/pieceLength;
+    const size_t toIndex = (endOffset - 1) / pieceLength;
-        ++index) {
+    while (fromIndex <= toIndex) {
-      indexes.push_back(index);
+      indexes.push_back(fromIndex++);
     }
   }
 }
@@ -724,23 +724,26 @@ void parsePrioritizePieceRange
   std::vector<size_t> indexes;
   std::vector<Scip> parts;
   splitIter(src.begin(), src.end(), std::back_inserter(parts), ',', true);
-  for(std::vector<Scip>::const_iterator i = parts.begin(),
+  for (const auto& i: parts) {
-        eoi = parts.end(); i != eoi; ++i) {
+    if(util::streq(i.first, i.second, "head")) {
-    if(util::streq((*i).first, (*i).second, "head")) {
       computeHeadPieces(indexes, fileEntries, pieceLength, defaultSize);
-    } else if(util::startsWith((*i).first, (*i).second, "head=")) {
+    }
-      std::string sizestr((*i).first+5, (*i).second);
+    else if(util::startsWith(i.first, i.second, "head=")) {
+      std::string sizestr(i.first + 5, i.second);
       computeHeadPieces(indexes, fileEntries, pieceLength,
                         std::max((int64_t)0, getRealSize(sizestr)));
-    } else if(util::streq((*i).first, (*i).second, "tail")) {
+    }
+    else if(util::streq(i.first, i.second, "tail")) {
       computeTailPieces(indexes, fileEntries, pieceLength, defaultSize);
-    } else if(util::startsWith((*i).first, (*i).second, "tail=")) {
+    }
-      std::string sizestr((*i).first+5, (*i).second);
+    else if(util::startsWith(i.first, i.second, "tail=")) {
+      std::string sizestr(i.first + 5, i.second);
       computeTailPieces(indexes, fileEntries, pieceLength,
                         std::max((int64_t)0, getRealSize(sizestr)));
-    } else {
+    }
+    else {
       throw DL_ABORT_EX(fmt("Unrecognized token %s",
-                            std::string((*i).first, (*i).second).c_str()));
+                            std::string(i.first, i.second).c_str()));
     }
   }
   std::sort(indexes.begin(), indexes.end());
@@ -1177,7 +1180,8 @@ std::string getContentDispositionFilename(const std::string& header)
                                          header.c_str(), header.size());
   if(rv == -1) {
     return "";
-  } else {
+  }
+
   std::string res;
   if(!charset || strieq(charset, charset+charsetlen, "iso-8859-1")) {
     res = iso8859p1ToUtf8(cdval, rv);
@@ -1187,10 +1191,8 @@ std::string getContentDispositionFilename(const std::string& header)
   if(!detectDirTraversal(res) &&
       res.find_first_of("/\\") == std::string::npos) {
     return res;
-    } else {
+  }
   return "";
-    }
-  }
 }
 
 std::string toUpper(std::string src)
@@ -1335,24 +1337,23 @@ void setGlobalSignalHandler(int sig, sigset_t* mask, signal_handler_t handler,
 std::string getHomeDir()
 {
   const char* p = getenv("HOME");
-  if(p) {
+  if (p) {
     return p;
-  } else {
+  }
 #ifdef __MINGW32__
   p = getenv("USERPROFILE");
-    if(p) {
+  if (p) {
     return p;
-    } else {
+  }
   p = getenv("HOMEDRIVE");
-      if(p) {
+  if (p) {
     std::string homeDir = p;
     p = getenv("HOMEPATH");
-        if(p) {
+    if (p) {
       homeDir += p;
       return homeDir;
     }
   }
-    }
 #elif HAVE_PWD_H
   passwd* pw = getpwuid(geteuid());
   if(pw && pw->pw_dir) {
@@ -1360,7 +1361,6 @@ std::string getHomeDir()
   }
 #endif // HAVE_PWD_H
   return A2STR::NIL;
-  }
 }
 
 int64_t getRealSize(const std::string& sizeWithUnit)
@@ -1387,7 +1387,8 @@ int64_t getRealSize(const std::string& sizeWithUnit)
   if(!parseLLIntNoThrow(v, size) || v < 0) {
     throw DL_ABORT_EX(fmt("Bad or negative value detected: %s",
                           sizeWithUnit.c_str()));
-  } else if(INT64_MAX/mult < v) {
+  }
+  if(INT64_MAX/mult < v) {
     throw DL_ABORT_EX(fmt(MSG_STRING_INTEGER_CONVERSION_FAILURE,
                           "overflow/underflow"));
   }
@@ -1474,9 +1475,7 @@ void mkdirs(const std::string& dirpath)
   if(!dir.mkdirs()) {
     int errNum = errno;
     if(!dir.isDir()) {
-      throw DL_ABORT_EX3
+      throw DL_ABORT_EX3(errNum, fmt(EX_MAKE_DIR, dir.getPath().c_str(),
-        (errNum,
-         fmt(EX_MAKE_DIR, dir.getPath().c_str(),
                                      safeStrerror(errNum).c_str()),
                          error_code::DIR_CREATE_ERROR);
     }
@@ -1518,8 +1517,7 @@ void* allocateAlignedMemory(size_t alignment, size_t size)
   void* buffer;
   int res;
   if((res = posix_memalign(&buffer, alignment, size)) != 0) {
-    throw FATAL_EXCEPTION
+    throw FATAL_EXCEPTION(fmt("Error in posix_memalign: %s",
-      (fmt("Error in posix_memalign: %s",
                               util::safeStrerror(res).c_str()));
   }
   return buffer;
@@ -1663,11 +1661,13 @@ std::string applyDir(const std::string& dir, const std::string& relPath)
   if(dir.empty()) {
     s = "./";
     s += relPath;
-  } else {
+  }
+  else {
     s = dir;
     if(dir == "/") {
       s += relPath;
-    } else {
+    }
+    else {
       s += "/";
       s += relPath;
     }
@@ -1728,18 +1728,19 @@ bool detectDirTraversal(const std::string& s)
   if(s.empty()) {
     return false;
   }
-  for(std::string::const_iterator i = s.begin(), eoi = s.end(); i != eoi; ++i) {
+  for (const auto& ch: s) {
-    unsigned char c = *i;
+    if (in(ch, 0x00u, 0x1fu) || ch == 0x7fu) {
-    if(in(c, 0x00u, 0x1fu) || c == 0x7fu) {
       return true;
     }
   }
   return s == "." || s == ".." || s[0] == '/' ||
-    util::startsWith(s, "./") || util::startsWith(s, "../") ||
+    util::startsWith(s, "./") ||
+    util::startsWith(s, "../") ||
     s.find("/../") != std::string::npos ||
     s.find("/./") != std::string::npos ||
     s[s.size()-1] == '/' ||
-    util::endsWith(s, "/.") || util::endsWith(s, "/..");
+    util::endsWith(s, "/.") ||
+    util::endsWith(s, "/..");
 }
 
 std::string escapePath(const std::string& s)
@@ -1810,9 +1811,8 @@ void executeHook
                   numFilesStr.c_str(),
                   firstFilename.c_str()));
   pid_t cpid = fork();
-  if(cpid == -1) {
+  if (cpid > 0) {
-    A2_LOG_ERROR("fork() failed. Cannot execute user command.");
+    // child!
-  } else if(cpid == 0) {
     execlp(command.c_str(),
            command.c_str(),
            gidStr.c_str(),
@@ -1821,8 +1821,15 @@ void executeHook
            reinterpret_cast<char*>(0));
     perror(("Could not execute user command: "+command).c_str());
     _exit(EXIT_FAILURE);
+    return;
   }
-#else
+
+  if(cpid == -1) {
+    A2_LOG_ERROR("fork() failed. Cannot execute user command.");
+  }
+  return;
+
+#else // __MINGW32__
   PROCESS_INFORMATION pi;
   STARTUPINFOW si;
 
@@ -1832,6 +1839,8 @@ void executeHook
   bool batch = util::iendsWith(command, ".bat");
   std::string cmdline;
   std::string cmdexe;
+
+  // XXX batch handling, in particular quoting, correct?
   if(batch) {
     const char* p = getenv("windir");
     if(p) {
@@ -1878,6 +1887,8 @@ void executeHook
   if(!rc) {
     A2_LOG_ERROR("CreateProcess() failed. Cannot execute user command.");
   }
+  return;
+
 #endif
 }
 
@@ -1912,11 +1923,10 @@ void executeHookByOptName
 std::string createSafePath
 (const std::string& dir, const std::string& filename)
 {
-  return util::applyDir
+  return util::applyDir(dir, util::isUtf8(filename) ?
-    (dir,
+                             util::fixTaintedBasename(filename) :
-     util::isUtf8(filename)?
+                             util::escapePath(util::percentEncode(filename))
-     util::fixTaintedBasename(filename):
+                        );
-     util::escapePath(util::percentEncode(filename)));
 }
 
 std::string encodeNonUtf8(const std::string& s)
@@ -1926,11 +1936,10 @@ std::string encodeNonUtf8(const std::string& s)
 
 std::string makeString(const char* str)
 {
-  if(str) {
+  if(!str) {
-    return str;
-  } else {
     return A2STR::NIL;
   }
+  return str;
 }
 
 std::string safeStrerror(int errNum)
@@ -1944,9 +1953,8 @@ bool noProxyDomainMatch
 {
   if(!domain.empty() && domain[0] == '.' && !util::isNumericHost(hostname)) {
     return util::endsWith(hostname, domain);
-  } else {
-    return hostname == domain;
   }
+  return hostname == domain;
 }
 
 bool tlsHostnameMatch(const std::string& pattern, const std::string& hostname)
@@ -1987,11 +1995,10 @@ bool tlsHostnameMatch(const std::string& pattern, const std::string& hostname)
   if(hnLeftLabelEnd - hostname.begin() < ptLeftLabelEnd - pattern.begin()) {
     return false;
   }
-  return
+  return istartsWith(hostname.begin(), hnLeftLabelEnd, pattern.begin(),
-    istartsWith(hostname.begin(), hnLeftLabelEnd,
+                     ptWildcard) &&
-                pattern.begin(), ptWildcard) &&
+         iendsWith(hostname.begin(), hnLeftLabelEnd, ptWildcard + 1,
-    iendsWith(hostname.begin(), hnLeftLabelEnd,
+                   ptLeftLabelEnd);
-              ptWildcard+1, ptLeftLabelEnd);
 }
 
 bool strieq(const std::string& a, const char* b)