diff --git a/DnsProxyListener.cpp b/DnsProxyListener.cpp
index 945819a..9dc620b 100644
--- a/DnsProxyListener.cpp
+++ b/DnsProxyListener.cpp
@@ -36,7 +36,8 @@
 #include <vector>
 
 #include <android-base/stringprintf.h>
-#include <cutils/misc.h>
+#include <android/multinetwork.h>  // ResNsendFlags
+#include <cutils/misc.h>           // FIRST_APPLICATION_UID
 #include <log/log.h>
 #include <netdutils/OperationLimiter.h>
 #include <netdutils/Slice.h>
diff --git a/include/netd_resolv/params.h b/include/netd_resolv/params.h
index c565753..ec61445 100644
--- a/include/netd_resolv/params.h
+++ b/include/netd_resolv/params.h
@@ -19,15 +19,13 @@
 
 #include <stdint.h>
 
-/* Hard-coded defines */
-#define MAXNS 4           /* max # name servers we'll track */
-#define MAXDNSRCH 6       /* max # domains in search path */
-#define MAXDNSRCHPATH 256 /* max length of domain search paths */
-#define MAXNSSAMPLES 64   /* max # samples to store per server */
+#define MAXNS 4            // max # name servers we'll track
+#define MAXDNSRCH 6        // max # domains in search path
+#define MAXDNSRCHPATH 256  // max length of domain search paths
+#define MAXNSSAMPLES 64    // max # samples to store per server
 
 // Per-netid configuration parameters passed from netd to the resolver
-// TODO: rename to res_params
-struct __res_params {
+struct res_params {
     uint16_t sample_validity;  // sample lifetime in s
     // threshold of success / total samples below which a server is considered broken
     uint8_t success_threshold;  // 0: disable, value / 100 otherwise
diff --git a/include/netd_resolv/resolv.h b/include/netd_resolv/resolv.h
index f79ec64..2e65370 100644
--- a/include/netd_resolv/resolv.h
+++ b/include/netd_resolv/resolv.h
@@ -28,15 +28,13 @@
 #ifndef NETD_RESOLV_RESOLV_H
 #define NETD_RESOLV_RESOLV_H
 
-/*
- * This header contains declarations related to per-network DNS server selection.
- * They are used by system/netd/ and should not be exposed by the public NDK headers.
- */
-#include <android/multinetwork.h>  // ResNsendFlags
+#include "params.h"
 
 #include <netinet/in.h>
 
-#include "params.h"
+struct addrinfo;
+struct hostent;
+struct res_params;
 
 typedef union sockaddr_union {
     struct sockaddr sa;
@@ -62,10 +60,6 @@
  */
 #define NETD_RESOLV_TIMEOUT 255  // consistent with RCODE_TIMEOUT
 
-struct __res_params;
-struct addrinfo;
-struct hostent;
-
 /*
  * A struct to capture context relevant to network operations.
  *
@@ -140,7 +134,7 @@
 // Set name servers for a network
 LIBNETD_RESOLV_PUBLIC int resolv_set_nameservers_for_net(unsigned netid, const char** servers,
                                                          int numservers, const char* domains,
-                                                         const __res_params* params);
+                                                         const res_params* params);
 
 LIBNETD_RESOLV_PUBLIC int resolv_set_private_dns_for_net(unsigned netid, uint32_t mark,
                                                          const char** servers, int numServers,
diff --git a/include/netd_resolv/resolv_stub.h b/include/netd_resolv/resolv_stub.h
index 32710db..c5ed19e 100644
--- a/include/netd_resolv/resolv_stub.h
+++ b/include/netd_resolv/resolv_stub.h
@@ -44,10 +44,10 @@
     int (*android_net_res_stats_get_info_for_net)(unsigned netid, int* nscount,
                                                   sockaddr_storage servers[MAXNS], int* dcount,
                                                   char domains[MAXDNSRCH][MAXDNSRCHPATH],
-                                                  __res_params* params, res_stats stats[MAXNS],
+                                                  res_params* params, res_stats stats[MAXNS],
                                                   int* wait_for_pending_req_timeout_count);
 
-    void (*android_net_res_stats_get_usable_servers)(const __res_params* params, res_stats stats[],
+    void (*android_net_res_stats_get_usable_servers)(const res_params* params, res_stats stats[],
                                                      int nscount, bool valid_servers[]);
 
     void (*resolv_delete_cache_for_net)(unsigned netid);
@@ -61,7 +61,7 @@
     bool (*resolv_init)(const dnsproxylistener_callbacks& callbacks);
 
     int (*resolv_set_nameservers_for_net)(unsigned netid, const char** servers, unsigned numservers,
-                                          const char* domains, const __res_params* params);
+                                          const char* domains, const res_params* params);
 
     int (*resolv_set_private_dns_for_net)(unsigned netid, uint32_t mark, const char** servers,
                                           const unsigned numServers, const char* tlsName,
diff --git a/include/netd_resolv/stats.h b/include/netd_resolv/stats.h
index e078e72..94e964b 100644
--- a/include/netd_resolv/stats.h
+++ b/include/netd_resolv/stats.h
@@ -51,11 +51,11 @@
 
 LIBNETD_RESOLV_PUBLIC int android_net_res_stats_get_info_for_net(
         unsigned netid, int* nscount, sockaddr_storage servers[MAXNS], int* dcount,
-        char domains[MAXDNSRCH][MAXDNSRCHPATH], __res_params* params, res_stats stats[MAXNS],
+        char domains[MAXDNSRCH][MAXDNSRCHPATH], res_params* params, res_stats stats[MAXNS],
         int* wait_for_pending_req_timeout_count);
 
 // Returns an array of bools indicating which servers are considered good
-LIBNETD_RESOLV_PUBLIC void android_net_res_stats_get_usable_servers(const __res_params* params,
+LIBNETD_RESOLV_PUBLIC void android_net_res_stats_get_usable_servers(const res_params* params,
                                                                     res_stats stats[], int nscount,
                                                                     bool valid_servers[]);
 
diff --git a/libnetd_resolv_test.cpp b/libnetd_resolv_test.cpp
index 2bd27fd..f4812a6 100644
--- a/libnetd_resolv_test.cpp
+++ b/libnetd_resolv_test.cpp
@@ -79,7 +79,7 @@
     }
 
     const char* mDefaultSearchDomains = "example.com";
-    const __res_params mDefaultParams_Binder = {
+    const res_params mDefaultParams_Binder = {
             .sample_validity = 300,
             .success_threshold = 25,
             .min_samples = 8,
diff --git a/res_cache.cpp b/res_cache.cpp
index 8d498ab..98e6909 100644
--- a/res_cache.cpp
+++ b/res_cache.cpp
@@ -32,6 +32,8 @@
 constexpr bool kDumpData = false;
 #define LOG_TAG "res_cache"
 
+#include "resolv_cache.h"
+
 #include <resolv.h>
 #include <stdarg.h>
 #include <stdio.h>
@@ -49,9 +51,9 @@
 
 #include <android-base/logging.h>
 #include <android-base/thread_annotations.h>
+#include <android/multinetwork.h>  // ResNsendFlags
 
 #include "res_state_ext.h"
-#include "resolv_cache.h"
 #include "resolv_private.h"
 
 #define VLOG if (!kVerboseLogging) {} else LOG(INFO)
@@ -187,7 +189,7 @@
  *     printf( "%s", buff );
  */
 
-/* Defaults used for initializing __res_params */
+/* Defaults used for initializing res_params */
 
 // If successes * 100 / total_samples is less than this value, the server is considered failing
 #define SUCCESS_THRESHOLD 75
@@ -1145,7 +1147,7 @@
     char* nameservers[MAXNS];
     struct addrinfo* nsaddrinfo[MAXNS];
     int revision_id;  // # times the nameservers have been replaced
-    struct __res_params params;
+    res_params params;
     struct res_stats nsstats[MAXNS];
     char defdname[MAXDNSRCHPATH];
     int dnsrch_offset[MAXDNSRCH + 1];  // offsets into defdname
@@ -1709,7 +1711,7 @@
     return cache_info;
 }
 
-static void resolv_set_default_params(struct __res_params* params) {
+static void resolv_set_default_params(res_params* params) {
     params->sample_validity = NSSAMPLE_VALIDITY;
     params->success_threshold = SUCCESS_THRESHOLD;
     params->min_samples = 0;
@@ -1719,7 +1721,7 @@
 }
 
 int resolv_set_nameservers_for_net(unsigned netid, const char** servers, const int numservers,
-                                   const char* domains, const __res_params* params) {
+                                   const char* domains, const res_params* params) {
     char* cp;
     int* offset;
     struct addrinfo* nsaddrinfo[MAXNS];
@@ -1940,8 +1942,7 @@
 int android_net_res_stats_get_info_for_net(unsigned netid, int* nscount,
                                            struct sockaddr_storage servers[MAXNS], int* dcount,
                                            char domains[MAXDNSRCH][MAXDNSRCHPATH],
-                                           struct __res_params* params,
-                                           struct res_stats stats[MAXNS],
+                                           res_params* params, struct res_stats stats[MAXNS],
                                            int* wait_for_pending_req_timeout_count) {
     int revision_id = -1;
     std::lock_guard guard(cache_mutex);
@@ -2002,7 +2003,7 @@
     return revision_id;
 }
 
-int resolv_cache_get_resolver_stats(unsigned netid, __res_params* params, res_stats stats[MAXNS]) {
+int resolv_cache_get_resolver_stats(unsigned netid, res_params* params, res_stats stats[MAXNS]) {
     std::lock_guard guard(cache_mutex);
     resolv_cache_info* info = find_cache_info_locked(netid);
     if (info) {
diff --git a/res_send.cpp b/res_send.cpp
index 0f048b4..5da47fd 100644
--- a/res_send.cpp
+++ b/res_send.cpp
@@ -99,6 +99,7 @@
 #include <unistd.h>
 
 #include <android-base/logging.h>
+#include <android/multinetwork.h>  // ResNsendFlags
 
 #include <netdutils/Slice.h>
 #include "DnsTlsDispatcher.h"
@@ -145,10 +146,10 @@
 
 static int get_salen(const struct sockaddr*);
 static struct sockaddr* get_nsaddr(res_state, size_t);
-static int send_vc(res_state, struct __res_params* params, const u_char*, int, u_char*, int, int*,
-                   int, time_t*, int*, int*);
-static int send_dg(res_state, struct __res_params* params, const u_char*, int, u_char*, int, int*,
-                   int, int*, int*, time_t*, int*, int*);
+static int send_vc(res_state, res_params* params, const u_char*, int, u_char*, int, int*, int,
+                   time_t*, int*, int*);
+static int send_dg(res_state, res_params* params, const u_char*, int, u_char*, int, int*, int, int*,
+                   int*, time_t*, int*, int*);
 static void Aerror(const res_state, FILE*, const char*, int, const struct sockaddr*, int);
 static void Perror(const res_state, FILE*, const char*, int);
 static int sock_eq(struct sockaddr*, struct sockaddr*);
@@ -506,8 +507,8 @@
         statp->_u._ext.nstimes[lastns] = nstime;
     }
 
-    struct res_stats stats[MAXNS];
-    struct __res_params params;
+    res_stats stats[MAXNS];
+    res_params params;
     int revision_id = resolv_cache_get_resolver_stats(statp->netid, &params, stats);
     bool usable_servers[MAXNS];
     android_net_res_stats_get_usable_servers(&params, stats, statp->nscount, usable_servers);
@@ -689,8 +690,7 @@
     }
 }
 
-static struct timespec get_timeout(const res_state statp, const struct __res_params* params,
-                                   const int ns) {
+static struct timespec get_timeout(const res_state statp, const res_params* params, const int ns) {
     int msec;
     if (params->base_timeout_msec != 0) {
         // TODO: scale the timeout by retry attempt and maybe number of servers
@@ -715,9 +715,8 @@
     return result;
 }
 
-static int send_vc(res_state statp, struct __res_params* params, const u_char* buf, int buflen,
-                   u_char* ans, int anssiz, int* terrno, int ns, time_t* at, int* rcode,
-                   int* delay) {
+static int send_vc(res_state statp, res_params* params, const u_char* buf, int buflen, u_char* ans,
+                   int anssiz, int* terrno, int ns, time_t* at, int* rcode, int* delay) {
     *at = time(NULL);
     *delay = 0;
     const HEADER* hp = (const HEADER*) (const void*) buf;
@@ -984,9 +983,9 @@
     return n;
 }
 
-static int send_dg(res_state statp, struct __res_params* params, const u_char* buf, int buflen,
-                   u_char* ans, int anssiz, int* terrno, int ns, int* v_circuit, int* gotsomewhere,
-                   time_t* at, int* rcode, int* delay) {
+static int send_dg(res_state statp, res_params* params, const u_char* buf, int buflen, u_char* ans,
+                   int anssiz, int* terrno, int ns, int* v_circuit, int* gotsomewhere, time_t* at,
+                   int* rcode, int* delay) {
     *at = time(NULL);
     *delay = 0;
     const HEADER* hp = (const HEADER*) (const void*) buf;
diff --git a/res_stats.cpp b/res_stats.cpp
index 4001206..feba34f 100644
--- a/res_stats.cpp
+++ b/res_stats.cpp
@@ -118,7 +118,7 @@
 // Returns true if the server is considered unusable, i.e. if the success rate is not lower than the
 // threshold for the stored stored samples. If not enough samples are stored, the server is
 // considered usable.
-static bool res_stats_usable_server(const struct __res_params* params, res_stats* stats) {
+static bool res_stats_usable_server(const res_params* params, res_stats* stats) {
     int successes = -1;
     int errors = -1;
     int timeouts = -1;
@@ -157,7 +157,7 @@
     return 1;
 }
 
-void android_net_res_stats_get_usable_servers(const struct __res_params* params, res_stats stats[],
+void android_net_res_stats_get_usable_servers(const res_params* params, res_stats stats[],
                                               int nscount, bool usable_servers[]) {
     unsigned usable_servers_found = 0;
     for (int ns = 0; ns < nscount; ns++) {
diff --git a/resolv_private.h b/resolv_private.h
index d4b38be..852bb8d 100644
--- a/resolv_private.h
+++ b/resolv_private.h
@@ -128,7 +128,7 @@
 /* Retrieve a local copy of the stats for the given netid. The buffer must have space for
  * MAXNS __resolver_stats. Returns the revision id of the resolvers used.
  */
-int resolv_cache_get_resolver_stats(unsigned netid, __res_params* params, res_stats stats[MAXNS]);
+int resolv_cache_get_resolver_stats(unsigned netid, res_params* params, res_stats stats[MAXNS]);
 
 /* Add a sample to the shared struct for the given netid and server, provided that the
  * revision_id of the stored servers has not changed.
diff --git a/resolver_test.cpp b/resolver_test.cpp
index 623ec79..c6a68e9 100644
--- a/resolver_test.cpp
+++ b/resolver_test.cpp
@@ -119,7 +119,7 @@
     void TearDown() { mDnsClient.TearDown(); }
 
     bool GetResolverInfo(std::vector<std::string>* servers, std::vector<std::string>* domains,
-                         std::vector<std::string>* tlsServers, __res_params* params,
+                         std::vector<std::string>* tlsServers, res_params* params,
                          std::vector<ResolverStats>* stats,
                          int* wait_for_pending_req_timeout_count) {
         using android::net::INetd;
@@ -133,7 +133,7 @@
         if (!rv.isOk() || params32.size() != static_cast<size_t>(INetd::RESOLVER_PARAMS_COUNT)) {
             return false;
         }
-        *params = __res_params{
+        *params = res_params{
                 .sample_validity =
                         static_cast<uint16_t>(params32[INetd::RESOLVER_PARAMS_SAMPLE_VALIDITY]),
                 .success_threshold =
@@ -280,7 +280,7 @@
         std::vector<std::string> res_servers;
         std::vector<std::string> res_domains;
         std::vector<std::string> res_tls_servers;
-        __res_params res_params;
+        res_params res_params;
         std::vector<ResolverStats> res_stats;
         int wait_for_pending_req_timeout_count;
         ASSERT_TRUE(GetResolverInfo(&res_servers, &res_domains, &res_tls_servers, &res_params,
@@ -474,7 +474,7 @@
     std::vector<std::string> res_servers;
     std::vector<std::string> res_domains;
     std::vector<std::string> res_tls_servers;
-    __res_params res_params;
+    res_params res_params;
     std::vector<ResolverStats> res_stats;
     int wait_for_pending_req_timeout_count;
     ASSERT_TRUE(GetResolverInfo(&res_servers, &res_domains, &res_tls_servers, &res_params,
@@ -646,7 +646,7 @@
         std::vector<std::string> res_servers;
         std::vector<std::string> res_domains;
         std::vector<std::string> res_tls_servers;
-        __res_params res_params;
+        res_params res_params;
         std::vector<ResolverStats> res_stats;
         int wait_for_pending_req_timeout_count;
         ASSERT_TRUE(GetResolverInfo(&res_servers, &res_domains, &res_tls_servers, &res_params,
@@ -839,7 +839,7 @@
     std::vector<std::string> res_servers;
     std::vector<std::string> res_domains;
     std::vector<std::string> res_tls_servers;
-    __res_params res_params;
+    res_params res_params;
     std::vector<ResolverStats> res_stats;
     int wait_for_pending_req_timeout_count;
     ASSERT_TRUE(GetResolverInfo(&res_servers, &res_domains, &res_tls_servers, &res_params,
@@ -869,7 +869,7 @@
     std::vector<std::string> res_servers;
     std::vector<std::string> res_domains;
     std::vector<std::string> res_tls_servers;
-    __res_params res_params;
+    res_params res_params;
     std::vector<ResolverStats> res_stats;
     int wait_for_pending_req_timeout_count;
     ASSERT_TRUE(GetResolverInfo(&res_servers, &res_domains, &res_tls_servers, &res_params,
@@ -977,7 +977,7 @@
     std::vector<std::string> res_servers;
     std::vector<std::string> res_domains;
     std::vector<std::string> res_tls_servers;
-    __res_params res_params;
+    res_params res_params;
     std::vector<ResolverStats> res_stats;
     int wait_for_pending_req_timeout_count;
     ASSERT_TRUE(GetResolverInfo(&res_servers, &res_domains, &res_tls_servers, &res_params,
@@ -1029,7 +1029,7 @@
     std::vector<std::string> res_servers;
     std::vector<std::string> res_domains;
     std::vector<std::string> res_tls_servers;
-    __res_params res_params;
+    res_params res_params;
     std::vector<ResolverStats> res_stats;
     int wait_for_pending_req_timeout_count;
     ASSERT_TRUE(GetResolverInfo(&res_servers, &res_domains, &res_tls_servers, &res_params,