Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit db91ce97 authored by Mike Yu's avatar Mike Yu Committed by Gerrit Code Review
Browse files

Merge changes I3afe28f5,Id9fc9b78 

* changes:
  Logging private DNS validation state
  Add LockedRingBuffer
parents 0a7cdadd 3d5130d4

DnsQueryLog.cpp

+3 −19
Original line number Diff line number Diff line
@@ -17,7 +17,7 @@ 


#include "DnsQueryLog.h"



#include <android-base/stringprintf.h>

#include "util.h"



namespace android::net {
@@ -45,25 +45,10 @@ std::string maskIps(const std::vector<std::string>& ips) { 
    return ret.empty() ? "" : ret.substr(0, ret.length() - 2);

}



// Return the readable string format "hr:min:sec.ms".

std::string timestampToString(const std::chrono::system_clock::time_point& ts) {

    using std::chrono::duration_cast;

    using std::chrono::milliseconds;

    const auto time_sec = std::chrono::system_clock::to_time_t(ts);

    char buf[32];

    std::strftime(buf, sizeof(buf), "%H:%M:%S", std::localtime(&time_sec));

    int ms = duration_cast<milliseconds>(ts.time_since_epoch()).count() % 1000;

    return android::base::StringPrintf("%s.%03d", buf, ms);

}



}  // namespace



void DnsQueryLog::push(Record&& record) {

    std::lock_guard guard(mLock);

    mQueue.push_back(std::move(record));

    if (mQueue.size() > mCapacity) {

        mQueue.pop_front();

    }

    mQueue.push(std::move(record));

}



void DnsQueryLog::dump(netdutils::DumpWriter& dw) const {
@@ -71,8 +56,7 @@ void DnsQueryLog::dump(netdutils::DumpWriter& dw) const { 
    netdutils::ScopedIndent indentStats(dw);

    const auto now = std::chrono::system_clock::now();



    std::lock_guard guard(mLock);

    for (const auto& record : mQueue) {

    for (const auto& record : mQueue.copy()) {

        if (now - record.timestamp > mValidityTimeMs) continue;



        const std::string maskedHostname = maskHostname(record.hostname);

DnsQueryLog.h

+7 −9
Original line number Diff line number Diff line
@@ -17,16 +17,16 @@ 


#pragma once



#include <deque>

#include <string>

#include <vector>



#include <android-base/thread_annotations.h>

#include <netdutils/DumpWriter.h>



#include "LockedQueue.h"



namespace android::net {



// A circular buffer based class used for query logging. It's thread-safe for concurrent access.

// This class stores query records in a locked ring buffer. It's thread-safe for concurrent access.

class DnsQueryLog {

  public:

    static constexpr std::string_view DUMP_KEYWORD = "querylog";
@@ -52,15 +52,13 @@ class DnsQueryLog { 
    // Allow the tests to set the capacity and the validaty time in milliseconds.

    DnsQueryLog(size_t size = kDefaultLogSize,

                std::chrono::milliseconds time = kDefaultValidityMinutes)

        : mCapacity(size), mValidityTimeMs(time) {}

        : mQueue(size), mValidityTimeMs(time) {}



    void push(Record&& record) EXCLUDES(mLock);

    void dump(netdutils::DumpWriter& dw) const EXCLUDES(mLock);

    void push(Record&& record);

    void dump(netdutils::DumpWriter& dw) const;



  private:

    mutable std::mutex mLock;

    std::deque<Record> mQueue GUARDED_BY(mLock);

    const size_t mCapacity;

    LockedRingBuffer<Record> mQueue;

    const std::chrono::milliseconds mValidityTimeMs;



    // The capacity of the circular buffer.

DnsResolverService.cpp

+3 −0
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ 
#include "DnsResolver.h"

#include "Experiments.h"

#include "NetdPermissions.h"  // PERM_*

#include "PrivateDnsConfiguration.h"

#include "ResolverEventReporter.h"

#include "resolv_cache.h"
@@ -117,6 +118,8 @@ binder_status_t DnsResolverService::dump(int fd, const char** args, uint32_t num 
        gDnsResolv->resolverCtrl.dump(dw, netId);

        dw.blankline();

    }



    PrivateDnsConfiguration::getInstance().dump(dw);

    Experiments::getInstance()->dump(dw);

    return STATUS_OK;

}

LockedQueue.h

+24 −0
Original line number Diff line number Diff line
@@ -46,6 +46,30 @@ class LockedQueue { 
    std::deque<T> mQueue GUARDED_BY(mLock);

};



template <typename T>

class LockedRingBuffer {

  public:

    explicit LockedRingBuffer(size_t size) : mCapacity(size) {}



    void push(T&& record) {

        std::lock_guard guard(mLock);

        mQueue.push_back(std::move(record));

        if (mQueue.size() > mCapacity) {

            mQueue.pop_front();

        }

    }



    std::deque<T> copy() const {

        std::lock_guard guard(mLock);

        return mQueue;

    }



  private:

    mutable std::mutex mLock;

    const size_t mCapacity;

    std::deque<T> mQueue GUARDED_BY(mLock);

};



}  // end of namespace net

}  // end of namespace android

PrivateDnsCommon.h

+30 −0
Original line number Diff line number Diff line
@@ -35,4 +35,34 @@ enum class PrivateDnsMode : uint8_t { 
    STRICT,

};



constexpr const char* validationStatusToString(Validation value) {

    switch (value) {

        case Validation::in_process:

            return "in_process";

        case Validation::success:

            return "success";

        case Validation::success_but_expired:

            return "success_but_expired";

        case Validation::fail:

            return "fail";

        case Validation::unknown_server:

            return "unknown_server";

        case Validation::unknown_netid:

            return "unknown_netid";

        default:

            return "unknown_status";

    }

}



constexpr const char* getPrivateDnsModeString(PrivateDnsMode mode) {

    switch (mode) {

        case PrivateDnsMode::OFF:

            return "OFF";

        case PrivateDnsMode::OPPORTUNISTIC:

            return "OPPORTUNISTIC";

        case PrivateDnsMode::STRICT:

            return "STRICT";

    }

}



}  // namespace android::net