int pr_memcache_conn_set_namespace(pr_memcache_t *mcache, module *m,
const char *prefix) {
if (mcache == NULL ||
m == NULL) {
errno = EINVAL;
return -1;
}
if (mcache->namespace_tab == NULL) {
pr_table_t *tab;
tab = pr_table_alloc(mcache->pool, 0);
if (pr_table_ctl(tab, PR_TABLE_CTL_SET_KEY_CMP, modptr_cmp_cb) < 0) {
pr_trace_msg(trace_channel, 4,
"error setting key comparison callback for namespace table: %s",
strerror(errno));
}
if (pr_table_ctl(tab, PR_TABLE_CTL_SET_KEY_HASH, modptr_hash_cb) < 0) {
pr_trace_msg(trace_channel, 4,
"error setting key hash callback for namespace table: %s",
strerror(errno));
}
mcache->namespace_tab = tab;
}
if (prefix != NULL) {
int count;
size_t prefix_len;
prefix_len = strlen(prefix);
count = pr_table_kexists(mcache->namespace_tab, m, sizeof(module *));
if (count <= 0) {
if (pr_table_kadd(mcache->namespace_tab, m, sizeof(module *),
pstrndup(mcache->pool, prefix, prefix_len), prefix_len) < 0) {
pr_trace_msg(trace_channel, 7,
"error adding namespace prefix '%s' for module 'mod_%s.c': %s",
prefix, m->name, strerror(errno));
}
} else {
if (pr_table_kset(mcache->namespace_tab, m, sizeof(module *),
pstrndup(mcache->pool, prefix, prefix_len), prefix_len) < 0) {
pr_trace_msg(trace_channel, 7,
"error setting namespace prefix '%s' for module 'mod_%s.c': %s",
prefix, m->name, strerror(errno));
}
}
} else {
/* A NULL prefix means the caller is removing their namespace maping. */
(void) pr_table_kremove(mcache->namespace_tab, m, sizeof(module *), NULL);
}
return 0;
}
static void uidcache_create(void) {
if ((auth_caching & PR_AUTH_CACHE_FL_UID2NAME) &&
!uid_tab &&
auth_pool) {
int ok = TRUE;
uid_tab = pr_table_alloc(auth_pool, 0);
if (pr_table_ctl(uid_tab, PR_TABLE_CTL_SET_KEY_CMP, uid_keycmp_cb) < 0) {
pr_trace_msg(trace_channel, 2,
"error setting key comparison callback for uidcache: %s",
strerror(errno));
ok = FALSE;
}
if (pr_table_ctl(uid_tab, PR_TABLE_CTL_SET_KEY_HASH, uid_hash_cb) < 0) {
pr_trace_msg(trace_channel, 2,
"error setting key hash callback for uidcache: %s",
strerror(errno));
ok = FALSE;
}
if (!ok) {
pr_trace_msg(trace_channel, 2, "%s",
"destroying unusable uidcache table");
pr_table_free(uid_tab);
uid_tab = NULL;
}
}
}
END_TEST
START_TEST (uri_parse_params_test) {
int res;
const char *uri;
char *host = NULL, *path = NULL, *username, *password;
unsigned int port = 0;
pr_table_t *params = NULL;
params = pr_table_alloc(p, 1);
mark_point();
uri = "sql://castaglia.org?foo";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res < 0, "Failed to handle invalid URI '%s'", uri);
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
mark_point();
pr_table_empty(params);
uri = "sql://castaglia.org?foo=";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
res = pr_table_count(params);
fail_unless(res == 1, "Expected 1 parameter, got %d", res);
mark_point();
uri = "sql://castaglia.org?foo=&";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res < 0, "Failed to handle invalid URI '%s'", uri);
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
mark_point();
uri = "sql://castaglia.org?foo=bar&foo=baz";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
res = pr_table_count(params);
fail_unless(res == 1, "Expected 1 parameter, got %d", res);
mark_point();
uri = "sql://castaglia.org?foo=bar&baz=quxx&foo=baz";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
res = pr_table_count(params);
fail_unless(res == 2, "Expected 2 parameters, got %d", res);
pr_table_empty(params);
pr_table_free(params);
}
int var_init(void) {
if (!var_pool) {
var_pool = make_sub_pool(permanent_pool);
pr_pool_tag(var_pool, "Variables Pool");
}
if (!var_tab)
var_tab = pr_table_alloc(var_pool, 0);
return 0;
}
END_TEST
START_TEST (uri_parse_port_test) {
int res;
const char *uri;
char *host = NULL, *path = NULL, *username = NULL, *password = NULL;
unsigned int expected, port = 0;
pr_table_t *params = NULL;
params = pr_table_alloc(p, 1);
mark_point();
uri = "sql://castaglia.org";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
fail_unless(port == 0, "Failed to parse port out of URI '%s'", uri);
mark_point();
uri = "sql://castaglia.org:3567";
expected = 3567;
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
fail_unless(port == expected, "Expected %u, got %u", expected, port);
mark_point();
uri = "sql://castaglia.org:foo";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res < 0, "Failed to handle invalid URI '%s': %s", uri);
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
mark_point();
uri = "sql://castaglia.org:0";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res < 0, "Failed to handle invalid URI '%s': %s", uri);
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
mark_point();
uri = "sql://castaglia.org:70000";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res < 0, "Failed to handle invalid URI '%s': %s", uri);
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
pr_table_free(params);
}
END_TEST
START_TEST (uri_parse_path_test) {
int res;
const char *uri;
char *expected, *host = NULL, *path = NULL, *username, *password;
unsigned int port = 0;
pr_table_t *params = NULL;
params = pr_table_alloc(p, 1);
mark_point();
uri = "sql://castaglia.org";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
fail_unless(path == NULL, "Expected null path, got %s", path);
mark_point();
uri = "sql://castaglia.org/path";
expected = "/path";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
fail_unless(path != NULL, "Expected path, got null");
fail_unless(strcmp(path, expected) == 0, "Expected '%s', got '%s'", expected,
path);
mark_point();
uri = "sql://castaglia.org:1234/path/to/resource";
expected = "/path/to/resource";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
fail_unless(path != NULL, "Expected path, got null");
fail_unless(strcmp(path, expected) == 0, "Expected '%s', got '%s'", expected,
path);
mark_point();
uri = "sql://castaglia.org:1234/path/to/resource?key=val";
expected = "/path/to/resource";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
fail_unless(path != NULL, "Expected path, got null");
fail_unless(strcmp(path, expected) == 0, "Expected '%s', got '%s'", expected,
path);
pr_table_empty(params);
pr_table_free(params);
}
MODRET add_lmd_allow_user(cmd_rec *cmd) {
config_rec *c;
int i;
pr_table_t *explicit_users;
if(cmd->argc < 2)
CONF_ERROR(cmd, "missing argument");
CHECK_CONF(cmd, CONF_ROOT|CONF_GLOBAL);
/* argv => LMDBAllowedUser nobody nobody1 nobody2 */
c = find_config(main_server->conf, CONF_PARAM, "LMDBAllowedUser", FALSE);
if(c && c->argv[0]) {
explicit_users = c->argv[0];
} else {
c = add_config_param(cmd->argv[0], 0, NULL);
c->argv[0] = explicit_users = pr_table_alloc(main_server->pool, 0);
}
for(i=1; i < cmd->argc; i++) {
const char *account = pstrdup(main_server->pool, cmd->argv[i]);
if(pr_table_exists(explicit_users, account) > 0) {
pr_log_debug(DEBUG2,
"%s: %s is already registerd", MODULE_NAME, account);
continue;
}
if(pr_table_add_dup(explicit_users, account, "y", 0) < 0){
pr_log_pri(PR_LOG_ERR,
"%s: failed pr_table_add_dup(): %s",
MODULE_NAME, strerror(errno));
exit(1);
}
pr_log_debug(DEBUG2,
"%s: add LMDBAllowedUser[%d] %s", MODULE_NAME, i, account);
}
return PR_HANDLED(cmd);
}
END_TEST
START_TEST (uri_parse_scheme_test) {
int res;
const char *uri;
char *host = NULL, *path = NULL, *username = NULL, *password = NULL;
unsigned int port = 0;
pr_table_t *params = NULL;
params = pr_table_alloc(p, 1);
mark_point();
uri = "foo";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res < 0, "Failed to handle invalid URI '%s'", uri);
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
mark_point();
uri = "foobarbaz";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res < 0, "Failed to handle invalid URI '%s'", uri);
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
mark_point();
uri = "sql://";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res < 0, "Failed to handle invalid URI '%s'", uri);
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
pr_table_free(params);
}
int pr_trace_set_levels(const char *channel, int min_level, int max_level) {
if (channel == NULL) {
void *v;
if (trace_tab == NULL) {
errno = EINVAL;
return -1;
}
v = pr_table_remove(trace_tab, channel, NULL);
if (v == NULL) {
errno = EINVAL;
return -1;
}
return 0;
}
if (min_level > max_level) {
errno = EINVAL;
return -1;
}
if (trace_tab == NULL &&
min_level < 0) {
return 0;
}
if (trace_pool == NULL) {
trace_pool = make_sub_pool(permanent_pool);
pr_pool_tag(trace_pool, "Trace API");
trace_tab = pr_table_alloc(trace_pool, 0);
/* Register a handler for churning the log pool during HUP. */
pr_event_register(NULL, "core.restart", trace_restart_ev, NULL);
}
if (min_level >= 0) {
struct trace_levels *levels;
levels = pcalloc(trace_pool, sizeof(struct trace_levels));
levels->min_level = min_level;
levels->max_level = max_level;
if (strcmp(channel, PR_TRACE_DEFAULT_CHANNEL) != 0) {
int count = pr_table_exists(trace_tab, channel);
if (count <= 0) {
if (pr_table_add(trace_tab, pstrdup(trace_pool, channel), levels,
sizeof(struct trace_levels)) < 0) {
return -1;
}
} else {
if (pr_table_set(trace_tab, pstrdup(trace_pool, channel), levels,
sizeof(struct trace_levels)) < 0)
return -1;
}
} else {
register unsigned int i;
for (i = 0; trace_channels[i]; i++) {
(void) pr_trace_set_levels(trace_channels[i], min_level, max_level);
}
}
} else {
if (strcmp(channel, PR_TRACE_DEFAULT_CHANNEL) != 0) {
(void) pr_table_remove(trace_tab, channel, NULL);
} else {
register unsigned int i;
for (i = 0; trace_channels[i]; i++) {
(void) pr_table_remove(trace_tab, trace_channels[i], NULL);
}
}
}
return 0;
}
struct passwd *pr_auth_getpwnam(pool *p, const char *name) {
cmd_rec *cmd = NULL;
modret_t *mr = NULL;
struct passwd *res = NULL;
module *m = NULL;
cmd = make_cmd(p, 1, name);
mr = dispatch_auth(cmd, "getpwnam", &m);
if (MODRET_ISHANDLED(mr) &&
MODRET_HASDATA(mr))
res = mr->data;
if (cmd->tmp_pool) {
destroy_pool(cmd->tmp_pool);
cmd->tmp_pool = NULL;
}
/* Sanity check */
if (res == NULL) {
errno = ENOENT;
return NULL;
}
/* Make sure the UID and GID are not -1 */
if (res->pw_uid == (uid_t) -1) {
pr_log_pri(PR_LOG_ERR, "error: UID of -1 not allowed");
return NULL;
}
if (res->pw_gid == (gid_t) -1) {
pr_log_pri(PR_LOG_ERR, "error: GID of -1 not allowed");
return NULL;
}
if ((auth_caching & PR_AUTH_CACHE_FL_AUTH_MODULE) &&
!auth_tab &&
auth_pool) {
auth_tab = pr_table_alloc(auth_pool, 0);
}
if (m &&
auth_tab) {
int count = 0;
void *value = NULL;
value = palloc(auth_pool, sizeof(module *));
*((module **) value) = m;
count = pr_table_exists(auth_tab, name);
if (count <= 0) {
if (pr_table_add(auth_tab, pstrdup(auth_pool, name), value,
sizeof(module *)) < 0) {
pr_trace_msg(trace_channel, 3,
"error adding module 'mod_%s.c' for user '%s' to the authcache: %s",
m->name, name, strerror(errno));
} else {
pr_trace_msg(trace_channel, 5,
"stashed module 'mod_%s.c' for user '%s' in the authcache",
m->name, name);
}
} else {
if (pr_table_set(auth_tab, pstrdup(auth_pool, name), value,
sizeof(module *)) < 0) {
pr_trace_msg(trace_channel, 3,
"error setting module 'mod_%s.c' for user '%s' in the authcache: %s",
m->name, name, strerror(errno));
} else {
pr_trace_msg(trace_channel, 5,
"stashed module 'mod_%s.c' for user '%s' in the authcache",
m->name, name);
}
}
}
uidcache_add(res->pw_uid, name);
/* Get the (possibly rewritten) home directory. */
res->pw_dir = pr_auth_get_home(p, res->pw_dir);
pr_log_debug(DEBUG10, "retrieved UID %lu for user '%s'",
(unsigned long) res->pw_uid, name);
return res;
}
END_TEST
START_TEST (uri_parse_real_uris_test) {
int res;
const char *uri;
char *host = NULL, *path = NULL, *username = NULL, *password = NULL;
char *expected;
unsigned int port = 0;
pr_table_t *params = NULL;
params = pr_table_alloc(p, 1);
mark_point();
host = path = username = password = NULL;
port = 0;
pr_table_empty(params);
uri = "sql://*****:*****@server:12345/dbname";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
expected = "server";
fail_unless(host != NULL, "Expected host, got null");
fail_unless(strcmp(host, expected) == 0, "Expected '%s', got '%s'",
expected, host);
expected = "/dbname";
fail_unless(path != NULL, "Expected path, got null");
fail_unless(strcmp(path, expected) == 0, "Expected '%s', got '%s'",
expected, path);
expected = "user";
fail_unless(username != NULL, "Expected username, got null");
fail_unless(strcmp(username, expected) == 0, "Expected '%s', got '%s'",
expected, username);
expected = "pass";
fail_unless(password != NULL, "Expected password, got null");
fail_unless(strcmp(password, expected) == 0, "Expected '%s', got '%s'",
expected, password);
fail_unless(port == 12345, "Expected 12345, got %u", port);
res = pr_table_count(params);
fail_unless(res == 0, "Expected 0 parameters, got %d", res);
mark_point();
host = path = username = password = NULL;
port = 0;
pr_table_empty(params);
uri = "sql:///path/to/sqlite.db?database=dbname";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
expected = "/path/to/sqlite.db";
fail_unless(host != NULL, "Expected host, got null");
fail_unless(strcmp(host, expected) == 0, "Expected '%s', got '%s'",
expected, host);
fail_unless(path == NULL, "Expected null, got path '%s'", path);
fail_unless(username == NULL, "Expected null, got username '%s'", username);
fail_unless(password == NULL, "Expected null, got password '%s'", password);
fail_unless(port == 0, "Expected 0, got %u", port);
res = pr_table_count(params);
fail_unless(res == 1, "Expected 1 parameter, got %d", res);
/* Note that this will not parse as expected. Using an absolute path as
* the hostname makes it hard to determine the URL path, as the same
* path separators are used.
*/
mark_point();
host = path = username = password = NULL;
port = 0;
pr_table_empty(params);
uri = "sql:///path/to/sqlite.db/dbname";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
expected = "/path/to/sqlite.db/dbname";
fail_unless(host != NULL, "Expected host, got null");
fail_unless(strcmp(host, expected) == 0, "Expected '%s', got '%s'",
expected, host);
fail_unless(path == NULL, "Expected null, got path '%s'", path);
fail_unless(username == NULL, "Expected null, got username '%s'", username);
fail_unless(password == NULL, "Expected null, got password '%s'", password);
fail_unless(port == 0, "Expected 0, got %u", port);
res = pr_table_count(params);
fail_unless(res == 0, "Expected 0 parameters, got %d", res);
mark_point();
host = path = username = password = NULL;
port = 0;
pr_table_empty(params);
uri = "sql://*****:*****@localhost?database=proftpd&ctx=vhostctx&conf=vhostconf&map=vhostmap&base_id=7";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
expected = "localhost";
fail_unless(host != NULL, "Expected host, got null");
fail_unless(strcmp(host, expected) == 0, "Expected '%s', got '%s'",
expected, host);
fail_unless(path == NULL, "Expected null, got path '%s'", path);
expected = "foo";
fail_unless(username != NULL, "Expected username, got null");
fail_unless(strcmp(username, expected) == 0, "Expected '%s', got '%s'",
expected, username);
expected = "bar";
fail_unless(password != NULL, "Expected password, got null");
fail_unless(strcmp(password, expected) == 0, "Expected '%s', got '%s'",
expected, password);
fail_unless(port == 0, "Expected 0, got %u", port);
res = pr_table_count(params);
fail_unless(res == 5, "Expected 5 parameters, got %d", res);
mark_point();
host = path = username = password = NULL;
port = 0;
pr_table_empty(params);
uri = "sql:///Users/tj/git/proftpd-mod_conf_sql/proftpd.db?ctx=ftpctx:id,parent_id,name,type,value&conf=ftpconf:id,type,value";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
expected = "/Users/tj/git/proftpd-mod_conf_sql/proftpd.db";
fail_unless(host != NULL, "Expected host, got null");
fail_unless(strcmp(host, expected) == 0, "Expected '%s', got '%s'",
expected, host);
fail_unless(path == NULL, "Expected null, got path '%s'", path);
fail_unless(username == NULL, "Expected null, got username");
fail_unless(password == NULL, "Expected null, got password");
fail_unless(port == 0, "Expected 0, got %u", port);
res = pr_table_count(params);
fail_unless(res == 2, "Expected 2 parameters, got %d", res);
pr_table_empty(params);
pr_table_free(params);
}
END_TEST
START_TEST (uri_parse_userinfo_test) {
int res;
const char *uri;
char *expected, *host = NULL, *path, *username = NULL, *password = NULL;
unsigned int port = 0;
pr_table_t *params = NULL;
params = pr_table_alloc(p, 1);
mark_point();
uri = "sql://castaglia.org";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
fail_unless(username == NULL, "Expected null username, got %s", username);
fail_unless(password == NULL, "Expected null password, got %s", password);
mark_point();
uri = "sql://[email protected]";
expected = "user";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
fail_unless(username == NULL, "Expected null username, got %s", username);
fail_unless(password == NULL, "Expected null password, got %s", password);
mark_point();
uri = "sql://*****:*****@castaglia.org";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
expected = "user";
fail_unless(username != NULL, "Expected username, got null");
fail_unless(strcmp(username, expected) == 0, "Expected '%s', got '%s'",
expected, username);
expected = "pass";
fail_unless(password != NULL, "Expected password, got null");
fail_unless(strcmp(password, expected) == 0, "Expected '%s', got '%s'",
expected, password);
mark_point();
uri = "sql://user:@castaglia.org";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
expected = "user";
fail_unless(username != NULL, "Expected username, got null");
fail_unless(strcmp(username, expected) == 0, "Expected '%s', got '%s'",
expected, username);
expected = "";
fail_unless(password != NULL, "Expected password, got null");
fail_unless(strcmp(password, expected) == 0, "Expected '%s', got '%s'",
expected, password);
mark_point();
uri = "sql://@castaglia.org";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to handle parse URI '%s': %s", uri,
strerror(errno));
fail_unless(username == NULL, "Expected null username, got %s", username);
fail_unless(password == NULL, "Expected null password, got %s", password);
pr_table_free(params);
}
END_TEST
START_TEST (uri_parse_host_test) {
int res;
const char *uri;
char *expected, *host = NULL, *path, *username = NULL, *password = NULL;
unsigned int port = 0;
pr_table_t *params = NULL;
params = pr_table_alloc(p, 1);
mark_point();
uri = "sql://castaglia.org";
expected = "castaglia.org";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
fail_unless(host != NULL, "Failed to parse host out of URI '%s'", uri);
fail_unless(strcmp(host, expected) == 0, "Expected '%s', got '%s'",
expected, host);
mark_point();
uri = "sql://127.0.0.1";
expected = "127.0.0.1";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
fail_unless(host != NULL, "Failed to parse host out of URI '%s'", uri);
fail_unless(strcmp(host, expected) == 0, "Expected '%s', got '%s'",
expected, host);
mark_point();
uri = "sql://[::1]";
expected = "::1";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
fail_unless(host != NULL, "Failed to parse host out of URI '%s'", uri);
fail_unless(strcmp(host, expected) == 0, "Expected '%s', got '%s'",
expected, host);
mark_point();
uri = "sql://[::1";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res < 0, "Parsed URI '%s' unexpectedly", uri);
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
mark_point();
uri = "sql:///path/to/some/file";
expected = "/path/to/some/file";
res = sqlconf_uri_parse(p, uri, &host, &port, &path, &username, &password,
params);
fail_unless(res == 0, "Failed to parse URI '%s': %s", uri, strerror(errno));
fail_unless(host != NULL, "Failed to parse host out of URI '%s'", uri);
fail_unless(strcmp(host, expected) == 0, "Expected '%s', got '%s'",
expected, host);
pr_table_free(params);
}
void *vroot_fsio_opendir(pr_fs_t *fs, const char *orig_path) {
int res, xerrno;
char vpath[PR_TUNABLE_PATH_MAX + 1], *path = NULL;
void *dirh = NULL;
struct stat st;
size_t pathlen = 0;
pool *tmp_pool = NULL;
unsigned int alias_count;
if (session.curr_phase == LOG_CMD ||
session.curr_phase == LOG_CMD_ERR ||
(session.sf_flags & SF_ABORT) ||
vroot_path_have_base() == FALSE) {
/* NOTE: once stackable FS modules are supported, have this fall through
* to the next module in the stack.
*/
return opendir(orig_path);
}
tmp_pool = make_sub_pool(session.pool);
pr_pool_tag(tmp_pool, "VRoot FSIO opendir pool");
/* If the given path ends in a slash, remove it. The handling of
* VRootAliases is sensitive to trailing slashes.
*/
path = pstrdup(tmp_pool, orig_path);
vroot_path_clean(path);
/* If the given path ends in a slash, remove it. The handling of
* VRootAliases is sensitive to such things.
*/
pathlen = strlen(path);
if (pathlen > 1 &&
path[pathlen-1] == '/') {
path[pathlen-1] = '\0';
pathlen--;
}
if (vroot_path_lookup(NULL, vpath, sizeof(vpath)-1, path, 0, NULL) < 0) {
xerrno = errno;
destroy_pool(tmp_pool);
errno = xerrno;
return NULL;
}
/* Check if the looked-up vpath is a symlink; we may need to resolve any
* links ourselves, rather than assuming that the system opendir(3) can
* handle it.
*/
res = vroot_fsio_lstat(fs, vpath, &st);
while (res == 0 &&
S_ISLNK(st.st_mode)) {
char data[PR_TUNABLE_PATH_MAX + 1];
pr_signals_handle();
memset(data, '\0', sizeof(data));
res = vroot_fsio_readlink(fs, vpath, data, sizeof(data)-1);
if (res < 0) {
break;
}
data[res] = '\0';
sstrncpy(vpath, data, sizeof(vpath));
res = vroot_fsio_lstat(fs, vpath, &st);
}
dirh = opendir(vpath);
if (dirh == NULL) {
xerrno = errno;
(void) pr_log_writefile(vroot_logfd, MOD_VROOT_VERSION,
"error opening virtualized directory '%s' (from '%s'): %s", vpath, path,
strerror(xerrno));
destroy_pool(tmp_pool);
errno = xerrno;
return NULL;
}
alias_count = vroot_alias_count();
if (alias_count > 0) {
unsigned long *cache_dirh = NULL;
if (vroot_dirtab == NULL) {
vroot_dir_pool = make_sub_pool(session.pool);
pr_pool_tag(vroot_dir_pool, "VRoot Directory Pool");
vroot_dirtab = pr_table_alloc(vroot_dir_pool, 0);
/* Since this table will use DIR pointers as keys, we want to override
* the default hashing and key comparison functions used.
*/
pr_table_ctl(vroot_dirtab, PR_TABLE_CTL_SET_KEY_HASH,
vroot_dirtab_hash_cb);
pr_table_ctl(vroot_dirtab, PR_TABLE_CTL_SET_KEY_CMP,
vroot_dirtab_keycmp_cb);
}
cache_dirh = palloc(vroot_dir_pool, sizeof(unsigned long));
*cache_dirh = (unsigned long) dirh;
if (pr_table_kadd(vroot_dirtab, cache_dirh, sizeof(unsigned long),
pstrdup(vroot_dir_pool, vpath), strlen(vpath) + 1) < 0) {
(void) pr_log_writefile(vroot_logfd, MOD_VROOT_VERSION,
"error stashing path '%s' (key %p) in directory table: %s", vpath,
dirh, strerror(errno));
} else {
vroot_dir_aliases = make_array(vroot_dir_pool, 0, sizeof(char *));
res = vroot_alias_do(vroot_alias_dirscan, vpath);
if (res < 0) {
(void) pr_log_writefile(vroot_logfd, MOD_VROOT_VERSION,
"error doing dirscan on aliases table: %s", strerror(errno));
} else {
register unsigned int i;
(void) pr_log_writefile(vroot_logfd, MOD_VROOT_VERSION,
"found %d %s in directory '%s'", vroot_dir_aliases->nelts,
vroot_dir_aliases->nelts != 1 ? "VRootAliases" : "VRootAlias",
vpath);
vroot_dir_idx = 0;
for (i = 0; i < vroot_dir_aliases->nelts; i++) {
char **elts = vroot_dir_aliases->elts;
(void) pr_log_writefile(vroot_logfd, MOD_VROOT_VERSION,
"'%s' aliases: [%u] %s", vpath, i, elts[i]);
}
}
}
}
destroy_pool(tmp_pool);
return dirh;
}
static int log_failure_mkfields(pool *p) {
pr_table_t *fields;
fields = pr_table_alloc(p, 0);
if (pr_table_ctl(fields, PR_TABLE_CTL_SET_KEY_CMP,
(void *) field_id_cmp) < 0) {
int xerrno = errno;
pr_log_pri(PR_LOG_INFO, "error setting key comparison callback for "
"field ID/names: %s", strerror(errno));
pr_table_free(fields);
errno = xerrno;
return -1;
}
if (pr_table_ctl(fields, PR_TABLE_CTL_SET_KEY_HASH,
(void *) field_id_hash) < 0) {
int xerrno = errno;
pr_log_pri(PR_LOG_INFO, "error setting key hash callback for "
"field ID/names: %s", strerror(errno));
pr_table_free(fields);
errno = xerrno;
return -1;
}
/* Now populate the table with the ID/name values. The key is the
* LogFormat "meta" ID, and the value is the corresponding name string,
* for use e.g. as JSON object member names.
*/
field_add(p, fields, LOGFMT_META_BYTES_SENT, "bytes_sent",
LOG_FAILURE_FIELD_TYPE_NUMBER);
field_add(p, fields, LOGFMT_META_FILENAME, "file",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_ENV_VAR, "ENV:",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_REMOTE_HOST, "remote_dns",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_REMOTE_IP, "remote_ip",
LOG_FAILURE_FIELD_TYPE_STRING);
#if defined(LOGFMT_META_REMOTE_PORT)
field_add(p, fields, LOGFMT_META_REMOTE_PORT, "remote_port",
LOG_FAILURE_FIELD_TYPE_NUMBER);
#endif /* LOGFMT_META_REMOTE_PORT */
field_add(p, fields, LOGFMT_META_IDENT_USER, "identd_user",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_PID, "pid",
LOG_FAILURE_FIELD_TYPE_NUMBER);
field_add(p, fields, LOGFMT_META_TIME, "local_time",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_SECONDS, "transfer_secs",
LOG_FAILURE_FIELD_TYPE_NUMBER);
field_add(p, fields, LOGFMT_META_COMMAND, "raw_command",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_LOCAL_NAME, "server_name",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_LOCAL_PORT, "local_port",
LOG_FAILURE_FIELD_TYPE_NUMBER);
field_add(p, fields, LOGFMT_META_LOCAL_IP, "local_ip",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_LOCAL_FQDN, "server_dns",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_USER, "user",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_ORIGINAL_USER, "original_user",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_RESPONSE_CODE, "response_code",
LOG_FAILURE_FIELD_TYPE_NUMBER);
#if defined(LOGFMT_META_RESPONSE_MS)
field_add(p, fields, LOGFMT_META_RESPONSE_MS, "response_ms",
LOG_FAILURE_FIELD_TYPE_NUMBER);
#endif /* LOGFMT_META_RESPONSE_MS */
field_add(p, fields, LOGFMT_META_CLASS, "connection_class",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_ANON_PASS, "anon_password",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_METHOD, "command",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_XFER_PATH, "transfer_path",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_DIR_NAME, "dir_name",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_DIR_PATH, "dir_path",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_CMD_PARAMS, "command_params",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_RESPONSE_STR, "response_msg",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_PROTOCOL, "protocol",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_VERSION, "server_version",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_RENAME_FROM, "rename_from",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_FILE_MODIFIED, "file_modified",
LOG_FAILURE_FIELD_TYPE_BOOLEAN);
field_add(p, fields, LOGFMT_META_UID, "uid",
LOG_FAILURE_FIELD_TYPE_NUMBER);
field_add(p, fields, LOGFMT_META_GID, "gid",
LOG_FAILURE_FIELD_TYPE_NUMBER);
field_add(p, fields, LOGFMT_META_RAW_BYTES_IN, "session_bytes_rcvd",
LOG_FAILURE_FIELD_TYPE_NUMBER);
field_add(p, fields, LOGFMT_META_RAW_BYTES_OUT, "session_bytes_sent",
LOG_FAILURE_FIELD_TYPE_NUMBER);
field_add(p, fields, LOGFMT_META_EOS_REASON, "session_end_reason",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_VHOST_IP, "server_ip",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_NOTE_VAR, "NOTE:",
LOG_FAILURE_FIELD_TYPE_STRING);
#if defined(LOGFMT_META_XFER_MS)
field_add(p, fields, LOGFMT_META_XFER_MS, "transfer_ms",
LOG_FAILURE_FIELD_TYPE_NUMBER);
#endif /* LOGFMT_META_XFER_MS */
field_add(p, fields, LOGFMT_META_XFER_STATUS, "transfer_status",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_XFER_FAILURE, "transfer_failure",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_MICROSECS, "microsecs",
LOG_FAILURE_FIELD_TYPE_NUMBER);
field_add(p, fields, LOGFMT_META_MILLISECS, "millisecs",
LOG_FAILURE_FIELD_TYPE_NUMBER);
field_add(p, fields, LOGFMT_META_ISO8601, "timestamp",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOGFMT_META_GROUP, "group",
LOG_FAILURE_FIELD_TYPE_STRING);
field_add(p, fields, LOG_FAILURE_META_CONNECT, "connecting",
LOG_FAILURE_FIELD_TYPE_BOOLEAN);
field_add(p, fields, LOG_FAILURE_META_DISCONNECT, "disconnecting",
LOG_FAILURE_FIELD_TYPE_BOOLEAN);
log_failure_fields = fields;
return 0;
}
