// Copyright 2015 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "webservd/log_manager.h"
#include <arpa/inet.h>
#include <cinttypes>
#include <netinet/in.h>
#include <set>
#include <base/bind.h>
#include <base/files/file_enumerator.h>
#include <base/files/file_util.h>
#include <base/lazy_instance.h>
#include <base/strings/stringprintf.h>
#include <brillo/strings/string_utils.h>
namespace webservd {
namespace {
// Singleton instance of LogManager class.
base::LazyInstance<LogManager> g_log_manager = LAZY_INSTANCE_INITIALIZER;
// The number of files to keep in the log directory. Since there is one log
// file per day of logging, this is essentially how many days' worth of logs
// to keep. This also controls the total maximum size of the log data, which
// is (kLogFilesToKeep * kMaxLogFileSize).
const size_t kLogFilesToKeep = 7;
// Maximum log file size.
const int64_t kMaxLogFileSize = 1024 * 1024; // 1 MB
// Obtain an IP address as a human-readable string for logging.
std::string GetIPAddress(const sockaddr* addr) {
static_assert(INET6_ADDRSTRLEN > INET_ADDRSTRLEN, "Unexpected IP addr len.");
char buf[INET6_ADDRSTRLEN] = "-";
if (!addr)
return buf;
switch (addr->sa_family) {
case AF_INET: {
auto addr_in = reinterpret_cast<const sockaddr_in*>(addr);
if (!inet_ntop(AF_INET, &addr_in->sin_addr, buf, sizeof(buf)))
PLOG(ERROR) << "Unable to get IP address string (IPv4)";
}
break;
case AF_INET6: {
auto addr_in6 = reinterpret_cast<const sockaddr_in6*>(addr);
// Note that inet_ntop(3) doesn't handle IPv4-mapped IPv6
// addresses [1] the way you'd expect .. for example, it returns
// "::ffff:172.22.72.163" instead of the more traditional IPv4
// notation "172.22.72.163". Fortunately, this is pretty easy to
// fix ourselves.
//
// [1] : see RFC 4291, section 2.5.5.2 for what that means
// http://tools.ietf.org/html/rfc4291#section-2.5.5
//
auto dwords = reinterpret_cast<const uint32_t*>(&addr_in6->sin6_addr);
if (dwords[0] == 0x00000000 && dwords[1] == 0x00000000 &&
dwords[2] == htonl(0x0000ffff)) {
auto bytes = reinterpret_cast<const uint8_t*>(&addr_in6->sin6_addr);
return base::StringPrintf("%d.%d.%d.%d",
bytes[12], bytes[13], bytes[14], bytes[15]);
} else if (!inet_ntop(AF_INET6, &addr_in6->sin6_addr, buf, sizeof(buf))) {
PLOG(ERROR) << "Unable to get IP address string (IPv6)";
}
}
break;
default:
LOG(ERROR) << "Unsupported address family " << addr->sa_family;
break;
}
return buf;
}
} // Anonymous namespace
// Logger class to write the log data to a log file.
class FileLogger final : public LogManager::LoggerInterface {
public:
FileLogger(const base::FilePath& log_directory, LogManager* log_manager)
: log_directory_(log_directory), log_manager_{log_manager} {}
// Write the log entry to today's log file.
void Log(const base::Time& timestamp, const std::string& entry) override {
tm time_buf = {};
char file_name[32] = {};
// Create the file name in year-month-day format so that string sort would
// correspond to date sort.
time_t time = timestamp.ToTimeT();
strftime(file_name, sizeof(file_name), "%Y-%m-%d.log",
localtime_r(&time, &time_buf));
base::FilePath file_path = log_directory_.Append(file_name);
bool success = false;
bool exists = base::PathExists(file_path);
// If the file already exists, check its size. If it is going to be larger
// then the maximum allowed log size, archive the current log file and
// create a new, empty one.
if (exists) {
int64_t file_size = 0;
bool got_size = base::GetFileSize(file_path, &file_size);
if (got_size && (file_size + entry.size() > kMaxLogFileSize))
exists = !ArchiveLogFile(file_name);
}
if (exists) {
success = base::AppendToFile(file_path, entry.data(), entry.size());
} else {
int size = static_cast<int>(entry.size());
success = (base::WriteFile(file_path, entry.data(), size) == size);
if (success) {
// We just created a new file, see if we need to purge old ones.
log_manager_->PerformLogMaintenance();
}
}
PLOG_IF(ERROR, !success) << "Failed to append a log entry to log file at "
<< file_path.value();
}
private:
// Renames the log file to a next available suffix-appended archive when
// the log file size starts to exceed the pre-defined maximum size.
// The existing log file is renamed by changing the original |file_name| to
// YYYY-MM-DD-<suffix>.log where suffix is characters 'a', 'b', ...
// Since '-' comes before '.', "2015-02-25-a.log" will come before
// "2015-02-25.log" in sort order and the previously-renamed files will be
// considered "older" than the current one, which is what we need.
// Returns true if the file has been successfully renamed.
bool ArchiveLogFile(const std::string& file_name) {
char suffix = 'a';
auto pair = brillo::string_utils::SplitAtFirst(file_name, ".");
// If we try all the suffixes from 'a' to 'z' and still can't find a name,
// abandon this strategy and keep appending to the current file.
while (suffix <= 'z') {
base::FilePath archive_file_path = log_directory_.Append(
base::StringPrintf("%s-%c.%s", pair.first.c_str(),
suffix, pair.second.c_str()));
if (!base::PathExists(archive_file_path)) {
base::FilePath file_path = log_directory_.Append(file_name);
if (base::Move(file_path, archive_file_path)) {
// Successfully renamed, start a new log file.
return true;
} else {
PLOG(ERROR) << "Failed to rename log file from "
<< file_path.value() << " to "
<< archive_file_path.value();
}
break;
}
suffix++;
}
return false;
}
base::FilePath log_directory_;
LogManager* log_manager_{nullptr};
};
void LogManager::Init(const base::FilePath& log_directory) {
LogManager* inst = GetInstance();
inst->log_directory_ = log_directory;
inst->SetLogger(
std::unique_ptr<LoggerInterface>{new FileLogger{log_directory, inst}});
inst->PerformLogMaintenance();
}
void LogManager::OnRequestCompleted(const base::Time& timestamp,
const sockaddr* client_addr,
const std::string& method,
const std::string& url,
const std::string& version,
int status_code,
int64_t response_size) {
std::string ip_address = GetIPAddress(client_addr);
tm time_buf = {};
char str_buf[32] = {};
// Format the date/time as "25/Feb/2015:03:29:12 -0800".
time_t time = timestamp.ToTimeT();
strftime(str_buf, sizeof(str_buf), "%d/%b/%Y:%H:%M:%S %z",
localtime_r(&time, &time_buf));
// Log file entry for one HTTP request looking like this:
// 127.0.0.1 - - [25/Feb/2015:03:29:12 -0800] "GET /test HTTP/1.1" 200 2326
std::string size_string{"-"};
if (response_size >= 0)
size_string = std::to_string(response_size);
std::string log_entry = base::StringPrintf(
"%s - - [%s] \"%s %s %s\" %d %s\n", ip_address.c_str(), str_buf,
method.c_str(), url.c_str(), version.c_str(), status_code,
size_string.c_str());
GetInstance()->logger_->Log(timestamp, log_entry);
}
void LogManager::SetLogger(std::unique_ptr<LoggerInterface> logger) {
GetInstance()->logger_ = std::move(logger);
}
LogManager* LogManager::GetInstance() {
return g_log_manager.Pointer();
}
void LogManager::PerformLogMaintenance() {
// Get the list of all the log files in the log directory and put them into
// a set which will sort the files by name (and effectively by the date since
// we chose the file naming scheme deliberately to guarantee proper sorting
// order).
std::set<base::FilePath> log_files;
base::FileEnumerator enumerator{log_directory_,
false,
base::FileEnumerator::FILES,
"*.log"};
base::FilePath file = enumerator.Next();
while (!file.empty()) {
log_files.insert(file);
file = enumerator.Next();
}
// Now, if we have more files than we want to keep, purge the old files.
while (log_files.size() > kLogFilesToKeep) {
auto front_it = log_files.begin();
PLOG_IF(WARNING, !base::DeleteFile(*front_it, false))
<< "Failed to delete an old log file: " << front_it->value();
log_files.erase(front_it);
}
}
} // namespace webservd