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; }