hcq/MaxScale
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

MXS-2197: Make SERV_LISTENER a C++ class

Browse Source 
The class is still mostly the same as the old C version but it now uses
std::string instead of char pointers. Changed configuration default values
so that the parameters passed to the listener allocation are always valid.
This commit is contained in:
Markus Mäkelä
2018-11-28 14:22:12 +02:00
parent 77585bdb8c
commit 01e9f71af1
15 changed files with 353 additions and 367 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
server/core/authenticator.cc
View File

@ -47,11 +47,11 @@ bool authenticator_init(void** dest, const char* authenticator, const char* opti
else if (func->initialize)
{
char* optarray[AUTHENTICATOR_MAX_OPTIONS + 1];
size_t optlen = options ? strlen(options) : 0;
size_t optlen = options && *options ? strlen(options) : 0;
char optcopy[optlen + 1];
int optcount = 0;
if (options)
if (options && *options)
{
strcpy(optcopy, options);
char* opt = optcopy;

6
server/core/config.cc
View File

@ -327,9 +327,9 @@ const MXS_MODULE_PARAM config_listener_params[] =
{CN_PORT, MXS_MODULE_PARAM_COUNT}, // Either port or socket,
// checked when created
{CN_SOCKET, MXS_MODULE_PARAM_STRING},
{CN_AUTHENTICATOR_OPTIONS, MXS_MODULE_PARAM_STRING},
{CN_AUTHENTICATOR_OPTIONS, MXS_MODULE_PARAM_STRING, ""},
{CN_ADDRESS, MXS_MODULE_PARAM_STRING, "::"},
{CN_AUTHENTICATOR, MXS_MODULE_PARAM_STRING},
{CN_AUTHENTICATOR, MXS_MODULE_PARAM_STRING, "MySQLAuth"},
{CN_SSL, MXS_MODULE_PARAM_ENUM, "false",
MXS_MODULE_OPT_ENUM_UNIQUE,
ssl_values},
@ -3860,7 +3860,7 @@ int create_new_listener(CONFIG_CONTEXT* obj)
"listener '%s' already listens on the %s %s.",
obj->object,
service->name,
l->name,
l->name.c_str(),
socket ? "socket" : "port",
socket ? socket : port);
return 1;

6
server/core/dcb.cc
View File

@ -43,7 +43,7 @@
#include <maxbase/atomic.hh>
#include <maxscale/clock.h>
#include <maxscale/limits.h>
#include <maxscale/listener.h>
#include <maxscale/listener.hh>
#include <maxscale/log.h>
#include <maxscale/poll.h>
#include <maxscale/router.h>
@ -2451,9 +2451,9 @@ DCB* dcb_accept(DCB* dcb)
}
}
memcpy(&client_dcb->func, protocol_funcs, sizeof(MXS_PROTOCOL));
if (dcb->listener->authenticator)
if (!dcb->listener->authenticator.empty())
{
authenticator_name = dcb->listener->authenticator;
authenticator_name = dcb->listener->authenticator.c_str();
}
else if (client_dcb->func.auth_default != NULL)
{

162
server/core/listener.cc
View File

@ -33,7 +33,7 @@
#include <fcntl.h>
#include <string>
#include <maxscale/listener.h>
#include <maxscale/listener.hh>
#include <maxscale/paths.h>
#include <maxscale/ssl.h>
#include <maxscale/protocol.h>
@ -47,6 +47,40 @@ static RSA* rsa_1024 = NULL;
static RSA* tmp_rsa_callback(SSL* s, int is_export, int keylength);
SERV_LISTENER::SERV_LISTENER(SERVICE* service, const std::string& name, const std::string& address,
uint16_t port, const std::string& protocol, const std::string& authenticator,
const std::string& auth_opts, void* auth_instance, SSL_LISTENER* ssl)
: name(name)
, protocol(protocol)
, port(port)
, address(address)
, authenticator(authenticator)
, auth_options(auth_opts)
, auth_instance(auth_instance)
, ssl(ssl)
, listener(nullptr)
, users(nullptr)
, service(service)
, active(1)
, next(nullptr)
{
}
SERV_LISTENER::~SERV_LISTENER()
{
if (users)
{
users_free(users);
}
if (listener)
{
dcb_close(listener);
}
SSL_LISTENER_free(ssl);
}
/**
* Create a new listener structure
*
@ -67,84 +101,27 @@ SERV_LISTENER* listener_alloc(SERVICE* service,
const char* auth_options,
SSL_LISTENER* ssl)
{
char* my_address = NULL;
if (address)
if (!authenticator)
{
my_address = MXS_STRDUP(address);
if (!my_address)
if ((authenticator = get_default_authenticator(protocol)) == NULL)
{
return NULL;
MXS_ERROR("No authenticator defined for listener '%s' and could not get "
"default authenticator for protocol '%s'.", name, protocol);
return nullptr;
}
}
char* my_auth_options = NULL;
if (auth_options && (my_auth_options = MXS_STRDUP(auth_options)) == NULL)
{
MXS_FREE(my_address);
return NULL;
}
char* my_authenticator = NULL;
if (authenticator)
{
my_authenticator = MXS_STRDUP(authenticator);
}
else if ((authenticator = get_default_authenticator(protocol)) == NULL
|| (my_authenticator = MXS_STRDUP(authenticator)) == NULL)
{
MXS_ERROR("No authenticator defined for listener '%s' and could not get "
"default authenticator for protocol '%s'.",
name,
protocol);
MXS_FREE(my_address);
return NULL;
}
void* auth_instance = NULL;
if (!authenticator_init(&auth_instance, my_authenticator, my_auth_options))
if (!authenticator_init(&auth_instance, authenticator, auth_options))
{
MXS_ERROR("Failed to initialize authenticator module '%s' for "
"listener '%s'.",
my_authenticator,
name);
MXS_FREE(my_address);
MXS_FREE(my_authenticator);
return NULL;
MXS_ERROR("Failed to initialize authenticator module '%s' for listener '%s'.",
authenticator, name);
return nullptr;
}
char* my_protocol = MXS_STRDUP(protocol);
char* my_name = MXS_STRDUP(name);
SERV_LISTENER* proto = (SERV_LISTENER*)MXS_MALLOC(sizeof(SERV_LISTENER));
if (!my_protocol || !proto || !my_name || !my_authenticator)
{
MXS_FREE(my_authenticator);
MXS_FREE(my_protocol);
MXS_FREE(my_address);
MXS_FREE(my_name);
MXS_FREE(proto);
return NULL;
}
proto->active = 1;
proto->name = my_name;
proto->listener = NULL;
proto->service = service;
proto->protocol = my_protocol;
proto->address = my_address;
proto->port = port;
proto->authenticator = my_authenticator;
proto->auth_options = my_auth_options;
proto->ssl = ssl;
proto->users = NULL;
proto->next = NULL;
proto->auth_instance = auth_instance;
pthread_mutex_init(&proto->lock, NULL);
return proto;
return new(std::nothrow) SERV_LISTENER(service, name, address, port, protocol, authenticator,
auth_options, auth_instance, ssl);
}
/**
@ -154,26 +131,7 @@ SERV_LISTENER* listener_alloc(SERVICE* service,
*/
void listener_free(SERV_LISTENER* listener)
{
if (listener)
{
if (listener->users)
{
users_free(listener->users);
}
if (listener->listener)
{
dcb_close(listener->listener);
}
SSL_LISTENER_free(listener->ssl);
MXS_FREE(listener->address);
MXS_FREE(listener->authenticator);
MXS_FREE(listener->auth_options);
MXS_FREE(listener->name);
MXS_FREE(listener->protocol);
MXS_FREE(listener);
}
delete listener;
}
/**
@ -480,24 +438,24 @@ static bool create_listener_config(const SERV_LISTENER* listener, const char* fi
{
MXS_ERROR("Failed to open file '%s' when serializing listener '%s': %d, %s",
filename,
listener->name,
listener->name.c_str(),
errno,
mxs_strerror(errno));
return false;
}
// TODO: Check for return values on all of the dprintf calls
dprintf(file, "[%s]\n", listener->name);
dprintf(file, "[%s]\n", listener->name.c_str());
dprintf(file, "type=listener\n");
dprintf(file, "protocol=%s\n", listener->protocol);
dprintf(file, "protocol=%s\n", listener->protocol.c_str());
dprintf(file, "service=%s\n", listener->service->name);
dprintf(file, "address=%s\n", listener->address);
dprintf(file, "address=%s\n", listener->address.c_str());
dprintf(file, "port=%u\n", listener->port);
dprintf(file, "authenticator=%s\n", listener->authenticator);
dprintf(file, "authenticator=%s\n", listener->authenticator.c_str());
if (listener->auth_options)
if (!listener->auth_options.empty())
{
dprintf(file, "authenticator_options=%s\n", listener->auth_options);
dprintf(file, "authenticator_options=%s\n", listener->auth_options.c_str());
}
if (listener->ssl)
@ -518,7 +476,7 @@ bool listener_serialize(const SERV_LISTENER* listener)
sizeof(filename),
"%s/%s.cnf.tmp",
get_config_persistdir(),
listener->name);
listener->name.c_str());
if (unlink(filename) == -1 && errno != ENOENT)
{
@ -555,11 +513,11 @@ bool listener_serialize(const SERV_LISTENER* listener)
json_t* listener_to_json(const SERV_LISTENER* listener)
{
json_t* param = json_object();
json_object_set_new(param, "address", json_string(listener->address));
json_object_set_new(param, "address", json_string(listener->address.c_str()));
json_object_set_new(param, "port", json_integer(listener->port));
json_object_set_new(param, "protocol", json_string(listener->protocol));
json_object_set_new(param, "authenticator", json_string(listener->authenticator));
json_object_set_new(param, "auth_options", json_string(listener->auth_options));
json_object_set_new(param, "protocol", json_string(listener->protocol.c_str()));
json_object_set_new(param, "authenticator", json_string(listener->authenticator.c_str()));
json_object_set_new(param, "auth_options", json_string(listener->auth_options.c_str()));
if (listener->ssl)
{
@ -589,7 +547,7 @@ json_t* listener_to_json(const SERV_LISTENER* listener)
}
json_t* rval = json_object();
json_object_set_new(rval, CN_ID, json_string(listener->name));
json_object_set_new(rval, CN_ID, json_string(listener->name.c_str()));
json_object_set_new(rval, CN_TYPE, json_string(CN_LISTENERS));
json_object_set_new(rval, CN_ATTRIBUTES, attr);

83
server/core/service.cc
View File

@ -41,7 +41,7 @@
#include <maxscale/dcb.h>
#include <maxscale/paths.h>
#include <maxscale/housekeeper.h>
#include <maxscale/listener.h>
#include <maxscale/listener.hh>
#include <maxscale/log.h>
#include <maxscale/poll.h>
#include <maxscale/protocol.h>
@ -351,7 +351,7 @@ static int serviceStartPort(Service* service, SERV_LISTENER* port)
int listeners = 0;
size_t config_bind_len =
(port->address ? strlen(port->address) : ANY_IPV4_ADDRESS_LEN) + 1 + UINTLEN(port->port);
(!port->address.empty() ? port->address.length() : ANY_IPV4_ADDRESS_LEN) + 1 + UINTLEN(port->port);
char config_bind[config_bind_len + 1]; // +1 for NULL
MXS_PROTOCOL* funcs;
@ -375,10 +375,10 @@ static int serviceStartPort(Service* service, SERV_LISTENER* port)
port->listener->service = service;
if ((funcs = (MXS_PROTOCOL*)load_module(port->protocol, MODULE_PROTOCOL)) == NULL)
if ((funcs = (MXS_PROTOCOL*)load_module(port->protocol.c_str(), MODULE_PROTOCOL)) == NULL)
{
MXS_ERROR("Unable to load protocol module %s. Listener for service %s not started.",
port->protocol,
port->protocol.c_str(),
service->name);
close_port(port);
return 0;
@ -388,9 +388,9 @@ static int serviceStartPort(Service* service, SERV_LISTENER* port)
const char* authenticator_name = "NullAuthDeny";
if (port->authenticator)
if (!port->authenticator.empty())
{
authenticator_name = port->authenticator;
authenticator_name = port->authenticator.c_str();
}
else if (port->listener->func.auth_default)
{
@ -403,13 +403,13 @@ static int serviceStartPort(Service* service, SERV_LISTENER* port)
{
MXS_ERROR("Failed to load authenticator module '%s' for listener '%s'",
authenticator_name,
port->name);
port->name.c_str());
close_port(port);
return 0;
}
// Add protocol and authenticator capabilities from the listener
const MXS_MODULE* proto_mod = get_module(port->protocol, MODULE_PROTOCOL);
const MXS_MODULE* proto_mod = get_module(port->protocol.c_str(), MODULE_PROTOCOL);
const MXS_MODULE* auth_mod = get_module(authenticator_name, MODULE_AUTHENTICATOR);
mxb_assert(proto_mod && auth_mod);
service->capabilities |= proto_mod->module_capabilities | auth_mod->module_capabilities;
@ -421,9 +421,9 @@ static int serviceStartPort(Service* service, SERV_LISTENER* port)
* listeners aren't normal DCBs, we can skip that.
*/
if (port->address)
if (!port->address.empty())
{
sprintf(config_bind, "%s|%d", port->address, port->port);
sprintf(config_bind, "%s|%d", port->address.c_str(), port->port);
}
else
{
@ -439,7 +439,7 @@ static int serviceStartPort(Service* service, SERV_LISTENER* port)
MXS_ERROR("[%s] Fatal error when loading users for listener '%s', "
"service is not started.",
service->name,
port->name);
port->name.c_str());
close_port(port);
return 0;
@ -447,7 +447,7 @@ static int serviceStartPort(Service* service, SERV_LISTENER* port)
MXS_WARNING("[%s] Failed to load users for listener '%s', authentication"
" might not work.",
service->name,
port->name);
port->name.c_str());
break;
default:
@ -594,7 +594,7 @@ bool serviceStopListener(SERVICE* svc, const char* name)
for (SERV_LISTENER* listener = listener_iterator_init(service, &iter);
listener; listener = listener_iterator_next(&iter))
{
if (listener_is_active(listener) && strcmp(listener->name, name) == 0)
if (listener_is_active(listener) && listener->name == name)
{
if (poll_remove_dcb(listener->listener) == 0)
{
@ -617,7 +617,7 @@ bool serviceStartListener(SERVICE* svc, const char* name)
for (SERV_LISTENER* listener = listener_iterator_init(service, &iter);
listener; listener = listener_iterator_next(&iter))
{
if (listener_is_active(listener) && strcmp(listener->name, name) == 0)
if (listener_is_active(listener) && listener->name == name)
{
if (listener->listener && listener->listener->session->state == SESSION_STATE_LISTENER_STOPPED
&& poll_add_dcb(listener->listener) == 0)
@ -752,7 +752,7 @@ bool service_remove_listener(Service* service, const char* target)
for (SERV_LISTENER* listener = listener_iterator_init(service, &iter);
listener; listener = listener_iterator_next(&iter))
{
if (listener_is_active(listener) && strcmp(listener->name, target) == 0)
if (listener_is_active(listener) && listener->name == target)
{
listener_set_active(listener, false);
@ -821,28 +821,10 @@ SERV_LISTENER* service_find_listener(Service* service,
for (SERV_LISTENER* listener = listener_iterator_init(service, &iter);
listener; listener = listener_iterator_next(&iter))
{
if (listener_is_active(listener))
if (listener_is_active(listener) && port == listener->port)
{
bool is_same_port = false;
if (port && (port == listener->port)
&& ((address && listener->address && strcmp(listener->address, address) == 0)
|| (address == NULL && listener->address == NULL)))
{
is_same_port = true;
}
bool is_same_socket = false;
if (!is_same_port)
{
if (socket && listener->address && strcmp(listener->address, socket) == 0)
{
is_same_socket = true;
}
}
if (is_same_port || is_same_socket)
if ((!address && listener->address.empty()) || listener->address == address
|| (!socket && listener->address.empty()) || listener->address == socket)
{
return listener;
}
@ -872,15 +854,12 @@ bool serviceHasListener(Service* service,
for (SERV_LISTENER* listener = listener_iterator_init(service, &iter);
listener; listener = listener_iterator_next(&iter))
{
if (listener_is_active(listener)
&& // Listener with same name exists
(strcmp(listener->name, name) == 0
|| // Listener listening on the same interface and port exists
((strcmp(listener->protocol, protocol) == 0 && listener->port == port
&& ((address && listener->address && strcmp(listener->address, address) == 0)
|| (address == NULL && listener->address == NULL))))))
if (listener_is_active(listener) && listener->port == port)
{
return true;
if ((!address && listener->address.empty()) || listener->address == address)
{
return true;
}
}
}
@ -894,7 +873,7 @@ bool service_has_named_listener(Service* service, const char* name)
for (SERV_LISTENER* listener = listener_iterator_init(service, &iter);
listener; listener = listener_iterator_next(&iter))
{
if (listener_is_active(listener) && strcmp(listener->name, name) == 0)
if (listener_is_active(listener) && listener->name == name)
{
return true;
}
@ -1403,10 +1382,10 @@ void dListListeners(DCB* dcb)
{
dcb_printf(dcb,
"%-20s | %-19s | %-18s | %-15s | %5d | %s\n",
listener->name,
listener->name.c_str(),
service->name,
listener->protocol,
(listener && listener->address) ? listener->address : "*",
listener->protocol.c_str(),
(listener && !listener->address.empty()) ? listener->address.c_str() : "*",
listener->port,
listener_state_to_string(listener));
}
@ -1473,7 +1452,7 @@ bool Service::refresh_users()
MXS_ERROR("[%s] Fatal error when loading users for listener '%s',"
" authentication will not work.",
m_name.c_str(),
listener->name);
listener->name.c_str());
ret = false;
break;
@ -1481,7 +1460,7 @@ bool Service::refresh_users()
MXS_WARNING("[%s] Failed to load users for listener '%s', authentication"
" might not work.",
m_name.c_str(),
listener->name);
listener->name.c_str());
ret = false;
break;
@ -1938,7 +1917,7 @@ void service_print_users(DCB* dcb, const SERVICE* service)
if (listener_is_active(listener) && listener->listener
&& listener->listener->authfunc.diagnostic)
{
dcb_printf(dcb, "User names (%s): ", listener->name);
dcb_printf(dcb, "User names (%s): ", listener->name.c_str());
listener->listener->authfunc.diagnostic(dcb, listener);
@ -2048,7 +2027,7 @@ static json_t* service_listener_json_data(const SERVICE* service, const char* na
for (SERV_LISTENER* listener = listener_iterator_init(service, &iter);
listener; listener = listener_iterator_next(&iter))
{
if (listener_is_active(listener) && strcmp(listener->name, name) == 0)
if (listener_is_active(listener) && listener->name == name)
{
return listener_to_json(listener);
}

6
server/core/test/test_dcb.cc
View File

@ -35,7 +35,7 @@
#include <string.h>
#include <maxscale/config.hh>
#include <maxscale/listener.h>
#include <maxscale/listener.hh>
#include <maxscale/routingworker.hh>
#include "../dcb.cc"
@ -48,10 +48,10 @@
static int test1()
{
DCB* dcb;
SERV_LISTENER dummy;
SERV_LISTENER* dummy = nullptr;
/* Single buffer tests */
fprintf(stderr, "testdcb : creating buffer with type DCB_ROLE_INTERNAL");
dcb = dcb_alloc(DCB_ROLE_INTERNAL, &dummy);
dcb = dcb_alloc(DCB_ROLE_INTERNAL, dummy);
printDCB(dcb);
fprintf(stderr, "\t..done\nAllocated dcb.");
// TODO: Without running workers, the following will hang. As it does not

6
server/core/test/test_poll.cc
View File

@ -34,7 +34,7 @@
#include <string.h>
#include <errno.h>
#include <maxscale/dcb.h>
#include <maxscale/listener.h>
#include <maxscale/listener.hh>
#include <maxscale/service.hh>
#include "test_utils.h"
@ -49,7 +49,7 @@ static int test1()
DCB* dcb;
int result;
int eno = 0;
SERV_LISTENER dummy;
SERV_LISTENER* dummy = nullptr;
SERVICE service;
service.routerModule = (char*)"required by a check in dcb.cc";
@ -59,7 +59,7 @@ static int test1()
"testpoll : Initialise the polling system.");
init_test_env(NULL);
fprintf(stderr, "\t..done\nAdd a DCB");
dcb = dcb_alloc(DCB_ROLE_CLIENT_HANDLER, &dummy);
dcb = dcb_alloc(DCB_ROLE_CLIENT_HANDLER, dummy);
if (dcb == NULL)
{

4
server/modules/authenticator/CDCPlainAuth/cdc_plain_auth.cc
View File

@ -556,8 +556,6 @@ int cdc_replace_users(SERV_LISTENER* listener)
int i = cdc_read_users(newusers, path);
USERS* oldusers = NULL;
pthread_mutex_lock(&listener->lock);
if (i > 0)
{
/** Successfully loaded at least one user */
@ -578,8 +576,6 @@ int cdc_replace_users(SERV_LISTENER* listener)
cdc_set_service_user(listener);
pthread_mutex_unlock(&listener->lock);
if (oldusers)
{
users_free(oldusers);

6
server/modules/authenticator/MySQLAuth/mysql_auth.cc
View File

@ -635,8 +635,8 @@ static int mysql_auth_load_users(SERV_LISTENER* port)
{
MXS_ERROR("[%s] Unable to load users for listener %s listening at [%s]:%d.",
service->name,
port->name,
port->address ? port->address : "::",
port->name.c_str(),
!port->address.empty() ? port->address.c_str() : "::",
port->port);
}
@ -673,7 +673,7 @@ static int mysql_auth_load_users(SERV_LISTENER* port)
}
else if (loaded > 0 && first_load)
{
MXS_NOTICE("[%s] Loaded %d MySQL users for listener %s.", service->name, loaded, port->name);
MXS_NOTICE("[%s] Loaded %d MySQL users for listener %s.", service->name, loaded, port->name.c_str());
}
return rc;

2
server/modules/protocol/HTTPD/httpd.cc
View File

@ -206,7 +206,7 @@ static int httpd_read_event(DCB* dcb)
/** If listener->authenticator is the default authenticator, it means that
* we don't need to check the user credentials. All other authenticators
* cause a 401 Unauthorized to be returned on the first try. */
bool auth_ok = strcmp(httpd_default_auth(), dcb->listener->authenticator) == 0;
bool auth_ok = httpd_default_auth() == dcb->listener->authenticator;
/**
* Get the request headers