You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficserver.apache.org by am...@apache.org on 2018/10/14 16:59:27 UTC
[trafficserver] branch master updated: TCL: Remove TCL dependency
from iocore
This is an automated email from the ASF dual-hosted git repository.
amc pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/trafficserver.git
The following commit(s) were added to refs/heads/master by this push:
new d5519d0 TCL: Remove TCL dependency from iocore
d5519d0 is described below
commit d5519d0ce9799bd6afdc8a56346899479553ed99
Author: Xavier Chi <ch...@gmail.com>
AuthorDate: Thu Oct 11 14:01:43 2018 -0500
TCL: Remove TCL dependency from iocore
---
iocore/net/SSLCertLookup.cc | 60 ++++++++++++++++-----------------------------
iocore/utils/I_Machine.h | 10 +++++---
iocore/utils/Machine.cc | 52 +++++++++------------------------------
3 files changed, 38 insertions(+), 84 deletions(-)
diff --git a/iocore/net/SSLCertLookup.cc b/iocore/net/SSLCertLookup.cc
index 5cf5ca1..7ea608b 100644
--- a/iocore/net/SSLCertLookup.cc
+++ b/iocore/net/SSLCertLookup.cc
@@ -33,6 +33,8 @@
#include "tscore/Trie.h"
#include "tscore/TestBox.h"
+#include <unordered_map>
+
// Check if the ticket_key callback #define is available, and if so, enable session tickets.
#ifdef SSL_CTX_set_tlsext_ticket_key_cb
@@ -101,7 +103,6 @@ public:
int insert(const char *name, int idx);
SSLCertContext *lookup(const char *name) const;
void printWildDomains() const;
- void freeWildDomains() const;
unsigned
count() const
{
@@ -132,9 +133,9 @@ private:
/// We can only match one layer with the wildcards
/// This table stores the wildcarded subdomain
- mutable HashMap<cchar *, StringHashFns, int> wilddomains;
+ std::unordered_map<std::string, int> wilddomains;
/// Contexts stored by IP address or FQDN
- InkHashTable *hostnames;
+ std::unordered_map<std::string, int> hostnames;
/// List for cleanup.
/// Exactly one pointer to each SSL context is stored here.
Vec<SSLCertContext> ctx_store;
@@ -349,7 +350,7 @@ reverse_dns_name(const char *hostname, char (&reversed)[TS_MAX_HOST_NAME_LEN + 1
return ptr;
}
-SSLContextStorage::SSLContextStorage() : wilddomains(-1), hostnames(ink_hash_table_create(InkHashTableKeyType_String)) {}
+SSLContextStorage::SSLContextStorage() {}
bool
SSLCtxCompare(SSLCertContext const &cc1, SSLCertContext const &cc2)
@@ -371,9 +372,6 @@ SSLContextStorage::~SSLContextStorage()
this->ctx_store[i].release();
}
}
-
- ink_hash_table_destroy(this->hostnames);
- freeWildDomains();
}
int
@@ -399,7 +397,6 @@ int
SSLContextStorage::insert(const char *name, int idx)
{
ats_wildcard_matcher wildcard;
- InkHashTableValue value;
char lower_case_name[TS_MAX_HOST_NAME_LEN + 1];
make_to_lower_case(name, lower_case_name, sizeof(lower_case_name));
if (wildcard.match(lower_case_name)) {
@@ -411,21 +408,22 @@ SSLContextStorage::insert(const char *name, int idx)
subdomain = nullptr;
}
if (subdomain) {
- auto index = this->wilddomains.get(subdomain);
- if (index != -1) {
- Debug("ssl", "previously indexed '%s' with SSL_CTX #%d, cannot index it with SSL_CTX #%d now", lower_case_name, index, idx);
+ if (auto it = this->wilddomains.find(subdomain); it != this->wilddomains.end()) {
+ Debug("ssl", "previously indexed '%s' with SSL_CTX #%d, cannot index it with SSL_CTX #%d now", lower_case_name, it->second,
+ idx);
idx = -1;
} else {
- this->wilddomains.put(ats_strdup(subdomain), idx);
+ this->wilddomains.emplace(subdomain, idx);
Debug("ssl", "indexed '%s' with SSL_CTX %p [%d]", lower_case_name, this->ctx_store[idx].ctx, idx);
}
}
} else {
- if (ink_hash_table_lookup(this->hostnames, lower_case_name, &value) && reinterpret_cast<InkHashTableValue>(idx) != value) {
- Debug("ssl", "previously indexed '%s' with SSL_CTX %p, cannot index it with SSL_CTX #%d now", lower_case_name, value, idx);
+ if (auto it = this->hostnames.find(lower_case_name); it != this->hostnames.end() && idx != it->second) {
+ Debug("ssl", "previously indexed '%s' with SSL_CTX %d, cannot index it with SSL_CTX #%d now", lower_case_name, it->second,
+ idx);
idx = -1;
} else {
- ink_hash_table_insert(this->hostnames, lower_case_name, reinterpret_cast<void *>(static_cast<intptr_t>(idx)));
+ this->hostnames.emplace(lower_case_name, idx);
Debug("ssl", "indexed '%s' with SSL_CTX %p [%d]", lower_case_name, this->ctx_store[idx].ctx, idx);
}
}
@@ -435,47 +433,31 @@ SSLContextStorage::insert(const char *name, int idx)
void
SSLContextStorage::printWildDomains() const
{
- Vec<cchar *> keys;
- this->wilddomains.get_keys(keys);
- for (size_t i = 0; i < keys.length(); i++) {
- Debug("ssl", "Stored wilddomain %s", keys.get(i));
- }
-}
-
-void
-SSLContextStorage::freeWildDomains() const
-{
- Vec<cchar *> keys;
- this->wilddomains.get_keys(keys);
- size_t n = keys.length();
- for (size_t i = 0; i < n; i++) {
- ats_free((char *)keys.get(i));
+ for (auto &&it : this->wilddomains) {
+ Debug("ssl", "Stored wilddomain %s", it.first.c_str());
}
- this->wilddomains.clear();
}
SSLCertContext *
SSLContextStorage::lookup(const char *name) const
{
- InkHashTableValue value;
// First look for an exact name match
- if (ink_hash_table_lookup(const_cast<InkHashTable *>(this->hostnames), name, &value)) {
- return &(this->ctx_store[reinterpret_cast<intptr_t>(value)]);
+ if (auto it = this->hostnames.find(name); it != this->hostnames.end()) {
+ return &(this->ctx_store[it->second]);
}
// Try lower casing it
char lower_case_name[TS_MAX_HOST_NAME_LEN + 1];
make_to_lower_case(name, lower_case_name, sizeof(lower_case_name));
- if (ink_hash_table_lookup(const_cast<InkHashTable *>(this->hostnames), lower_case_name, &value)) {
- return &(this->ctx_store[reinterpret_cast<intptr_t>(value)]);
+ if (auto it_lower = this->hostnames.find(lower_case_name); it_lower != this->hostnames.end()) {
+ return &(this->ctx_store[it_lower->second]);
}
// Then strip off the top domain name and look for a wildcard domain match
const char *subdomain = index(lower_case_name, '.');
if (subdomain) {
++subdomain; // Move beyond the '.'
- auto index = this->wilddomains.get(subdomain);
- if (index >= 0) {
- return &(this->ctx_store[index]);
+ if (auto it = this->wilddomains.find(subdomain); it != this->wilddomains.end()) {
+ return &(this->ctx_store[it->second]);
}
}
return nullptr;
diff --git a/iocore/utils/I_Machine.h b/iocore/utils/I_Machine.h
index fe4da83..4c28cc5 100644
--- a/iocore/utils/I_Machine.h
+++ b/iocore/utils/I_Machine.h
@@ -32,7 +32,10 @@
#include "tscore/ink_inet.h"
#include "tscore/ink_uuid.h"
-#include "tscore/ink_hash_table.h"
+
+#include <unordered_map>
+#include <unordered_set>
+#include <memory>
/**
The Machine is a simple place holder for the hostname and the ip
@@ -89,7 +92,6 @@ protected:
Machine(char const *hostname, sockaddr const *addr);
static self *_instance; ///< Singleton for the class.
-
- InkHashTable *machine_id_strings;
- InkHashTable *machine_id_ipaddrs;
+ std::unordered_set<std::string> machine_id_strings;
+ std::unordered_map<std::string, IpAddr *> machine_id_ipaddrs;
};
diff --git a/iocore/utils/Machine.cc b/iocore/utils/Machine.cc
index dac3225..b8bc015 100644
--- a/iocore/utils/Machine.cc
+++ b/iocore/utils/Machine.cc
@@ -66,12 +66,7 @@ Machine::init(char const *name, sockaddr const *ip)
}
Machine::Machine(char const *the_hostname, sockaddr const *addr)
- : hostname(nullptr),
- hostname_len(0),
- ip_string_len(0),
- ip_hex_string_len(0),
- machine_id_strings(ink_hash_table_create(InkHashTableKeyType_String)),
- machine_id_ipaddrs(ink_hash_table_create(InkHashTableKeyType_String))
+ : hostname(nullptr), hostname_len(0), ip_string_len(0), ip_hex_string_len(0)
{
char localhost[1024];
char ip_strbuf[INET6_ADDRSTRLEN];
@@ -236,35 +231,15 @@ Machine::Machine(char const *the_hostname, sockaddr const *addr)
Machine::~Machine()
{
ats_free(hostname);
-
- // release machine_id_strings hash table.
- InkHashTableIteratorState ht_iter;
- InkHashTableEntry *ht_entry = nullptr;
- ht_entry = ink_hash_table_iterator_first(machine_id_strings, &ht_iter);
-
- while (ht_entry != nullptr) {
- char *value = static_cast<char *>(ink_hash_table_entry_value(machine_id_strings, ht_entry));
- ats_free(value);
- ht_entry = ink_hash_table_iterator_next(machine_id_strings, &ht_iter);
+ for (auto spot = machine_id_ipaddrs.begin(); spot != machine_id_ipaddrs.end(); spot++) {
+ delete spot->second;
}
- ink_hash_table_destroy(machine_id_strings);
-
- // release machine_id_ipaddrs hash table.
- ht_entry = nullptr;
- ht_entry = ink_hash_table_iterator_first(machine_id_ipaddrs, &ht_iter);
- while (ht_entry != nullptr) {
- IpAddr *ipaddr = static_cast<IpAddr *>(ink_hash_table_entry_value(machine_id_ipaddrs, ht_entry));
- delete ipaddr;
- ht_entry = ink_hash_table_iterator_next(machine_id_ipaddrs, &ht_iter);
- }
- ink_hash_table_destroy(machine_id_ipaddrs);
}
bool
Machine::is_self(const char *name)
{
char lower_case_name[TS_MAX_HOST_NAME_LEN + 1] = {0};
- void *value = nullptr;
if (name == nullptr) {
return false;
@@ -272,55 +247,50 @@ Machine::is_self(const char *name)
make_to_lower_case(name, lower_case_name, sizeof(lower_case_name));
- return ink_hash_table_lookup(machine_id_strings, lower_case_name, &value) == 1 ? true : false;
+ return machine_id_strings.find(lower_case_name) != machine_id_strings.end();
}
bool
Machine::is_self(const IpAddr *ipaddr)
{
- void *value = nullptr;
char string_value[INET6_ADDRSTRLEN + 1] = {0};
if (ipaddr == nullptr) {
return false;
}
ipaddr->toString(string_value, sizeof(string_value));
- return ink_hash_table_lookup(machine_id_ipaddrs, string_value, &value) == 1 ? true : false;
+ return machine_id_ipaddrs.find(string_value) != machine_id_ipaddrs.end();
}
bool
Machine::is_self(struct sockaddr const *addr)
{
- void *value = nullptr;
char string_value[INET6_ADDRSTRLEN + 1] = {0};
if (addr == nullptr) {
return false;
}
ats_ip_ntop(addr, string_value, sizeof(string_value));
- return ink_hash_table_lookup(machine_id_ipaddrs, string_value, &value) == 1 ? true : false;
+ return machine_id_ipaddrs.find(string_value) != machine_id_ipaddrs.end();
}
void
Machine::insert_id(char *id)
{
char lower_case_name[TS_MAX_HOST_NAME_LEN + 1] = {0};
- char *value = nullptr;
make_to_lower_case(id, lower_case_name, sizeof(lower_case_name));
- value = ats_strndup(lower_case_name, strlen(lower_case_name));
- ink_hash_table_insert(machine_id_strings, lower_case_name, value);
+ machine_id_strings.emplace(lower_case_name);
}
void
Machine::insert_id(IpAddr *ipaddr)
{
- int length = INET6_ADDRSTRLEN + 1;
+ char string_value[INET6_ADDRSTRLEN + 1] = {0};
if (ipaddr != nullptr) {
- char *string_value = static_cast<char *>(ats_calloc(length, 1));
- ipaddr->toString(string_value, length);
- ink_hash_table_insert(machine_id_strings, string_value, string_value);
- ink_hash_table_insert(machine_id_ipaddrs, string_value, ipaddr);
+ ipaddr->toString(string_value, sizeof(string_value));
+ machine_id_strings.emplace(string_value);
+ machine_id_ipaddrs.emplace(string_value, ipaddr);
}
}