From 4f10a615df63bda84aa4a95893e453a79a0eb1b4 Mon Sep 17 00:00:00 2001 From: Victor Seva Date: Wed, 17 May 2023 16:36:01 +0200 Subject: [PATCH] db2_ldap: clang-format for coherent indentation and coding style --- src/modules/db2_ldap/db2_ldap_mod.c | 295 +++++----- src/modules/db2_ldap/ld_cfg.c | 400 ++++++------- src/modules/db2_ldap/ld_cfg.h | 43 +- src/modules/db2_ldap/ld_cmd.c | 298 +++++----- src/modules/db2_ldap/ld_cmd.h | 30 +- src/modules/db2_ldap/ld_con.c | 145 +++-- src/modules/db2_ldap/ld_con.h | 21 +- src/modules/db2_ldap/ld_fld.c | 836 +++++++++++++++------------- src/modules/db2_ldap/ld_fld.h | 31 +- src/modules/db2_ldap/ld_res.c | 22 +- src/modules/db2_ldap/ld_res.h | 9 +- src/modules/db2_ldap/ld_uri.c | 366 ++++++------ src/modules/db2_ldap/ld_uri.h | 23 +- 13 files changed, 1306 insertions(+), 1213 deletions(-) diff --git a/src/modules/db2_ldap/db2_ldap_mod.c b/src/modules/db2_ldap/db2_ldap_mod.c index fa1796f3d21..a355c848fe5 100644 --- a/src/modules/db2_ldap/db2_ldap_mod.c +++ b/src/modules/db2_ldap/db2_ldap_mod.c @@ -59,47 +59,41 @@ MODULE_VERSION /* * LDAP module interface */ -static cmd_export_t cmds[] = { - {"db_ctx", (cmd_function)NULL, 0, 0, 0, 0}, - {"db_con", (cmd_function)ld_con, 0, 0, 0, 0}, - {"db_uri", (cmd_function)ld_uri, 0, 0, 0, 0}, - {"db_cmd", (cmd_function)ld_cmd, 0, 0, 0, 0}, - {"db_put", (cmd_function)ld_cmd_exec, 0, 0, 0, 0}, - {"db_del", (cmd_function)ld_cmd_exec, 0, 0, 0, 0}, - {"db_get", (cmd_function)ld_cmd_exec, 0, 0, 0, 0}, - {"db_upd", (cmd_function)ld_cmd_exec, 0, 0, 0, 0}, - {"db_sql", (cmd_function)ld_cmd_exec, 0, 0, 0, 0}, - {"db_res", (cmd_function)ld_res, 0, 0, 0, 0}, - {"db_fld", (cmd_function)ld_fld, 0, 0, 0, 0}, - {"db_first", (cmd_function)ld_cmd_first, 0, 0, 0, 0}, - {"db_next", (cmd_function)ld_cmd_next, 0, 0, 0, 0}, - {"db_setopt", (cmd_function)ld_cmd_setopt, 0, 0, 0, 0}, - {"db_getopt", (cmd_function)NULL, 0, 0, 0, 0}, - {0, 0, 0, 0, 0, 0} -}; +static cmd_export_t cmds[] = {{"db_ctx", (cmd_function)NULL, 0, 0, 0, 0}, + {"db_con", (cmd_function)ld_con, 0, 0, 0, 0}, + {"db_uri", (cmd_function)ld_uri, 0, 0, 0, 0}, + {"db_cmd", (cmd_function)ld_cmd, 0, 0, 0, 0}, + {"db_put", (cmd_function)ld_cmd_exec, 0, 0, 0, 0}, + {"db_del", (cmd_function)ld_cmd_exec, 0, 0, 0, 0}, + {"db_get", (cmd_function)ld_cmd_exec, 0, 0, 0, 0}, + {"db_upd", (cmd_function)ld_cmd_exec, 0, 0, 0, 0}, + {"db_sql", (cmd_function)ld_cmd_exec, 0, 0, 0, 0}, + {"db_res", (cmd_function)ld_res, 0, 0, 0, 0}, + {"db_fld", (cmd_function)ld_fld, 0, 0, 0, 0}, + {"db_first", (cmd_function)ld_cmd_first, 0, 0, 0, 0}, + {"db_next", (cmd_function)ld_cmd_next, 0, 0, 0, 0}, + {"db_setopt", (cmd_function)ld_cmd_setopt, 0, 0, 0, 0}, + {"db_getopt", (cmd_function)NULL, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}}; /* * Exported parameters */ -static param_export_t params[] = { - {"config", PARAM_STR, &ld_cfg_file}, - {"reconnect_attempt", PARAM_INT, &ld_reconnect_attempt}, - {0, 0, 0} -}; +static param_export_t params[] = {{"config", PARAM_STR, &ld_cfg_file}, + {"reconnect_attempt", PARAM_INT, &ld_reconnect_attempt}, {0, 0, 0}}; struct module_exports exports = { - "db2_ldap", /* module name */ - DEFAULT_DLFLAGS, /* dlopen flags */ - cmds, /* cmd (cfg function) exports */ - params, /* param exports */ - 0, /* RPC method exports */ - 0, /* pseudo-variables exports */ - 0, /* response handling function */ - ld_mod_init, /* module init function */ - 0, /* per-child init function */ - ld_mod_destroy /* module destroy function */ + "db2_ldap", /* module name */ + DEFAULT_DLFLAGS, /* dlopen flags */ + cmds, /* cmd (cfg function) exports */ + params, /* param exports */ + 0, /* RPC method exports */ + 0, /* pseudo-variables exports */ + 0, /* response handling function */ + ld_mod_init, /* module init function */ + 0, /* per-child init function */ + ld_mod_destroy /* module destroy function */ }; @@ -107,108 +101,82 @@ struct module_exports exports = { int ldap_test(void) { int i, row; - db_ctx_t* db; - db_cmd_t* put, *del, *get; - db_res_t* result; - db_rec_t* rec; - char* times; - - db_fld_t int_vals[] = { - {.name = "col_bool", .type = DB_INT}, - {.name = "col_int8", .type = DB_INT}, - {.name = "col_int4", .type = DB_INT}, - {.name = "col_inet", .type = DB_INT}, - {.name = "col_timestamp", .type = DB_INT}, - {.name = "col_bit", .type = DB_INT}, - {.name = "col_varbit", .type = DB_INT}, - {.name = NULL} - }; - - db_fld_t datetime_vals[] = { - {.name = "col_int8", .type = DB_INT}, - {.name = "col_int4", .type = DB_INT}, - {.name = "col_timestamp", .type = DB_INT}, - {.name = NULL} - }; - - - db_fld_t bitmap_vals[] = { - {.name = "col_int8", .type = DB_INT}, - {.name = "col_int4", .type = DB_INT}, - {.name = "col_bit", .type = DB_INT}, - {.name = "col_varbit", .type = DB_INT}, - {.name = NULL} - }; - - db_fld_t float_vals[] = { - {.name = "col_float4", .type = DB_FLOAT}, - {.name = "col_float8", .type = DB_FLOAT}, - {.name = NULL} - }; + db_ctx_t *db; + db_cmd_t *put, *del, *get; + db_res_t *result; + db_rec_t *rec; + char *times; + + db_fld_t int_vals[] = {{.name = "col_bool", .type = DB_INT}, + {.name = "col_int8", .type = DB_INT}, + {.name = "col_int4", .type = DB_INT}, + {.name = "col_inet", .type = DB_INT}, + {.name = "col_timestamp", .type = DB_INT}, + {.name = "col_bit", .type = DB_INT}, + {.name = "col_varbit", .type = DB_INT}, {.name = NULL}}; + + db_fld_t datetime_vals[] = {{.name = "col_int8", .type = DB_INT}, + {.name = "col_int4", .type = DB_INT}, + {.name = "col_timestamp", .type = DB_INT}, {.name = NULL}}; + + + db_fld_t bitmap_vals[] = {{.name = "col_int8", .type = DB_INT}, + {.name = "col_int4", .type = DB_INT}, + {.name = "col_bit", .type = DB_INT}, + {.name = "col_varbit", .type = DB_INT}, {.name = NULL}}; + + db_fld_t float_vals[] = {{.name = "col_float4", .type = DB_FLOAT}, + {.name = "col_float8", .type = DB_FLOAT}, {.name = NULL}}; db_fld_t double_vals[] = { - {.name = "col_float8", .type = DB_DOUBLE}, - {.name = NULL} - }; - - db_fld_t str_vals[] = { - {.name = "col_varchar", .type = DB_STR}, - {.name = "col_bytea", .type = DB_STR}, - {.name = "col_text", .type = DB_STR}, - {.name = "col_bpchar", .type = DB_STR}, - {.name = "col_char", .type = DB_STR}, - {.name = NULL} - }; - - db_fld_t cstr_vals[] = { - {.name = "col_varchar", .type = DB_CSTR}, - {.name = "col_bytea", .type = DB_CSTR}, - {.name = "col_text", .type = DB_CSTR}, - {.name = "col_bpchar", .type = DB_CSTR}, - {.name = "col_char", .type = DB_CSTR}, - {.name = NULL} - }; + {.name = "col_float8", .type = DB_DOUBLE}, {.name = NULL}}; + + db_fld_t str_vals[] = {{.name = "col_varchar", .type = DB_STR}, + {.name = "col_bytea", .type = DB_STR}, + {.name = "col_text", .type = DB_STR}, + {.name = "col_bpchar", .type = DB_STR}, + {.name = "col_char", .type = DB_STR}, {.name = NULL}}; + + db_fld_t cstr_vals[] = {{.name = "col_varchar", .type = DB_CSTR}, + {.name = "col_bytea", .type = DB_CSTR}, + {.name = "col_text", .type = DB_CSTR}, + {.name = "col_bpchar", .type = DB_CSTR}, + {.name = "col_char", .type = DB_CSTR}, {.name = NULL}}; db_fld_t blob_vals[] = { - {.name = "col_bytea", .type = DB_BLOB}, - {.name = NULL} - }; - - - db_fld_t res[] = { - {.name = "col_bool", .type = DB_INT}, - {.name = "col_bytea", .type = DB_BLOB}, - {.name = "col_char", .type = DB_STR}, - {.name = "col_int8", .type = DB_INT}, - {.name = "col_int4", .type = DB_INT}, - {.name = "col_int2", .type = DB_INT}, - {.name = "col_text", .type = DB_STR}, - {.name = "col_float4", .type = DB_FLOAT}, - {.name = "col_float8", .type = DB_DOUBLE}, - {.name = "col_inet", .type = DB_INT}, - {.name = "col_bpchar", .type = DB_STR}, - {.name = "col_varchar", .type = DB_STR}, - {.name = "col_timestamp", .type = DB_DATETIME}, - {.name = "col_bit", .type = DB_BITMAP}, - {.name = "col_varbit", .type = DB_BITMAP}, - {.name = NULL} - }; - - db_fld_t cred[] = { - {.name = "auth_username", .type = DB_CSTR}, - {.name = "realm", .type = DB_CSTR}, - {.name = NULL} - }; + {.name = "col_bytea", .type = DB_BLOB}, {.name = NULL}}; + + + db_fld_t res[] = {{.name = "col_bool", .type = DB_INT}, + {.name = "col_bytea", .type = DB_BLOB}, + {.name = "col_char", .type = DB_STR}, + {.name = "col_int8", .type = DB_INT}, + {.name = "col_int4", .type = DB_INT}, + {.name = "col_int2", .type = DB_INT}, + {.name = "col_text", .type = DB_STR}, + {.name = "col_float4", .type = DB_FLOAT}, + {.name = "col_float8", .type = DB_DOUBLE}, + {.name = "col_inet", .type = DB_INT}, + {.name = "col_bpchar", .type = DB_STR}, + {.name = "col_varchar", .type = DB_STR}, + {.name = "col_timestamp", .type = DB_DATETIME}, + {.name = "col_bit", .type = DB_BITMAP}, + {.name = "col_varbit", .type = DB_BITMAP}, {.name = NULL}}; + + db_fld_t cred[] = {{.name = "auth_username", .type = DB_CSTR}, + {.name = "realm", .type = DB_CSTR}, {.name = NULL}}; db = db_ctx("ldap"); - if (db == NULL) { + if(db == NULL) { ERR("Error while initializing database layer\n"); goto error; } - if (db_add_db(db, "ldap://127.0.0.1") < 0) goto error; + if(db_add_db(db, "ldap://127.0.0.1") < 0) + goto error; - if (db_connect(db) < 0) goto error; + if(db_connect(db) < 0) + goto error; /* del = db_cmd(DB_DEL, db, "test", NULL, NULL, NULL); @@ -437,7 +405,7 @@ int ldap_test(void) */ get = db_cmd(DB_GET, db, "credentials", res, cred, NULL); - if (get == NULL) { + if(get == NULL) { ERR("Error while building select query\n"); goto error; } @@ -445,7 +413,7 @@ int ldap_test(void) get->match[0].v.cstr = "jan"; get->match[1].v.cstr = "iptel.org"; - if (db_exec(&result, get)) { + if(db_exec(&result, get)) { ERR("Error while executing select query\n"); goto error; } @@ -462,36 +430,38 @@ int ldap_test(void) while(rec) { ERR("row: %d\n", row); for(i = 0; !DB_FLD_LAST(rec->fld[i]); i++) { - if (rec->fld[i].flags & DB_NULL) { + if(rec->fld[i].flags & DB_NULL) { ERR("%s: NULL\n", rec->fld[i].name); } else { switch(rec->fld[i].type) { - case DB_INT: - case DB_BITMAP: - ERR("%s: %d\n", rec->fld[i].name, rec->fld[i].v.int4); - break; - - case DB_DATETIME: - times = ctime(&rec->fld[i].v.time); - ERR("%s: %d:%.*s\n", rec->fld[i].name, rec->fld[i].v.time, strlen(times) - 1, times); - break; - - case DB_DOUBLE: - ERR("%s: %f\n", rec->fld[i].name, rec->fld[i].v.dbl); - break; - - case DB_FLOAT: - ERR("%s: %f\n", rec->fld[i].name, rec->fld[i].v.flt); - break; - - case DB_STR: - case DB_BLOB: - ERR("%s: %.*s\n", rec->fld[i].name, rec->fld[i].v.lstr.len, rec->fld[i].v.lstr.s); - break; - - case DB_CSTR: - ERR("%s: %s\n", rec->fld[i].name, rec->fld[i].v.cstr); - break; + case DB_INT: + case DB_BITMAP: + ERR("%s: %d\n", rec->fld[i].name, rec->fld[i].v.int4); + break; + + case DB_DATETIME: + times = ctime(&rec->fld[i].v.time); + ERR("%s: %d:%.*s\n", rec->fld[i].name, + rec->fld[i].v.time, strlen(times) - 1, times); + break; + + case DB_DOUBLE: + ERR("%s: %f\n", rec->fld[i].name, rec->fld[i].v.dbl); + break; + + case DB_FLOAT: + ERR("%s: %f\n", rec->fld[i].name, rec->fld[i].v.flt); + break; + + case DB_STR: + case DB_BLOB: + ERR("%s: %.*s\n", rec->fld[i].name, + rec->fld[i].v.lstr.len, rec->fld[i].v.lstr.s); + break; + + case DB_CSTR: + ERR("%s: %s\n", rec->fld[i].name, rec->fld[i].v.cstr); + break; } } } @@ -507,10 +477,13 @@ int ldap_test(void) db_ctx_free(db); return 0; - error: - if (get) db_cmd_free(get); - if (put) db_cmd_free(put); - if (del) db_cmd_free(del); +error: + if(get) + db_cmd_free(get); + if(put) + db_cmd_free(put); + if(del) + db_cmd_free(del); db_disconnect(db); db_ctx_free(db); return -1; @@ -526,13 +499,13 @@ static void ld_mod_destroy(void) static int ld_mod_init(void) { - if (ld_load_cfg(&ld_cfg_file)) { - ERR("ldap: Error while loading configuration file\n"); - return -1; + if(ld_load_cfg(&ld_cfg_file)) { + ERR("ldap: Error while loading configuration file\n"); + return -1; } #ifdef LD_TEST - if (ldap_test() == 0) { + if(ldap_test() == 0) { ERR("ldap: Testing successful\n"); } else { ERR("ldap: Testing failed\n"); diff --git a/src/modules/db2_ldap/ld_cfg.c b/src/modules/db2_ldap/ld_cfg.c index 070701413ef..d3b20a20e57 100644 --- a/src/modules/db2_ldap/ld_cfg.c +++ b/src/modules/db2_ldap/ld_cfg.c @@ -39,294 +39,301 @@ #include -enum section_type { +enum section_type +{ LDAP_CON_SECTION = 0, LDAP_TABLE_SECTION }; -static struct ld_cfg* cfg = NULL; +static struct ld_cfg *cfg = NULL; -static struct ld_con_info* con = NULL; +static struct ld_con_info *con = NULL; void ld_cfg_free(void) { - struct ld_con_info* c; - struct ld_cfg* ptr; + struct ld_con_info *c; + struct ld_cfg *ptr; int i; - while (cfg) { + while(cfg) { ptr = cfg; cfg = cfg->next; - if (ptr->table.s) pkg_free(ptr->table.s); - if (ptr->base.s) pkg_free(ptr->base.s); - if (ptr->filter.s) pkg_free(ptr->filter.s); + if(ptr->table.s) + pkg_free(ptr->table.s); + if(ptr->base.s) + pkg_free(ptr->base.s); + if(ptr->filter.s) + pkg_free(ptr->filter.s); for(i = 0; i < ptr->n; i++) { - if (ptr->field[i].s) pkg_free(ptr->field[i].s); - if (ptr->attr[i].s) pkg_free(ptr->attr[i].s); + if(ptr->field[i].s) + pkg_free(ptr->field[i].s); + if(ptr->attr[i].s) + pkg_free(ptr->attr[i].s); } - if (ptr->field) pkg_free(ptr->field); - if (ptr->attr) pkg_free(ptr->attr); - if (ptr->syntax) pkg_free(ptr->syntax); + if(ptr->field) + pkg_free(ptr->field); + if(ptr->attr) + pkg_free(ptr->attr); + if(ptr->syntax) + pkg_free(ptr->syntax); } - while (con) { + while(con) { c = con; con = con->next; - if (c->id.s) pkg_free(c->id.s); - if (c->host.s) pkg_free(c->host.s); - if (c->username.s) pkg_free(c->username.s); - if (c->password.s) pkg_free(c->password.s); + if(c->id.s) + pkg_free(c->id.s); + if(c->host.s) + pkg_free(c->host.s); + if(c->username.s) + pkg_free(c->username.s); + if(c->password.s) + pkg_free(c->password.s); pkg_free(c); } - } -static int parse_field_map(void* param, cfg_parser_t* st, unsigned int flags) +static int parse_field_map(void *param, cfg_parser_t *st, unsigned int flags) { int ret; cfg_token_t t; - void* ptr; + void *ptr; static cfg_option_t syntaxes[] = { - {"GeneralizedTime", .val = LD_SYNTAX_GENTIME}, - {"Integer", .val = LD_SYNTAX_INT }, - {"BitString", .val = LD_SYNTAX_BIT }, - {"Boolean", .val = LD_SYNTAX_BOOL }, - {"String", .val = LD_SYNTAX_STRING }, - {"Binary", .val = LD_SYNTAX_BIN }, - {"Float", .val = LD_SYNTAX_FLOAT }, - {0} - }; + {"GeneralizedTime", .val = LD_SYNTAX_GENTIME}, + {"Integer", .val = LD_SYNTAX_INT}, + {"BitString", .val = LD_SYNTAX_BIT}, + {"Boolean", .val = LD_SYNTAX_BOOL}, + {"String", .val = LD_SYNTAX_STRING}, + {"Binary", .val = LD_SYNTAX_BIN}, {"Float", .val = LD_SYNTAX_FLOAT}, + {0}}; - cfg_option_t* syntax; + cfg_option_t *syntax; - if (cfg_eat_equal(st, flags)) return -1; + if(cfg_eat_equal(st, flags)) + return -1; - if (!(ptr = pkg_realloc(cfg->field, sizeof(str) * (cfg->n + 1)))) { + if(!(ptr = pkg_realloc(cfg->field, sizeof(str) * (cfg->n + 1)))) { ERR("ldap:%s:%d:%d Out of memory\n", st->file, st->line, st->col); return -1; } - cfg->field = (str*)ptr; + cfg->field = (str *)ptr; cfg->field[cfg->n].s = NULL; - if (!(ptr = pkg_realloc(cfg->attr, sizeof(str) * (cfg->n + 1)))) { + if(!(ptr = pkg_realloc(cfg->attr, sizeof(str) * (cfg->n + 1)))) { ERR("ldap:%s:%d:%d: Out of memory\n", st->file, st->line, st->col); return -1; } - cfg->attr = (str*)ptr; + cfg->attr = (str *)ptr; cfg->attr[cfg->n].s = NULL; - if (!(ptr = pkg_realloc(cfg->syntax, sizeof(enum ld_syntax)*(cfg->n+1)))) { + if(!(ptr = pkg_realloc( + cfg->syntax, sizeof(enum ld_syntax) * (cfg->n + 1)))) { ERR("ldap:%s:%d:%d: Out of memory\n", st->file, st->line, st->col); return -1; } - cfg->syntax = (enum ld_syntax*)ptr; + cfg->syntax = (enum ld_syntax *)ptr; cfg->syntax[cfg->n] = LD_SYNTAX_STRING; cfg->n++; ret = cfg_get_token(&t, st, 0); - if (ret < 0) return -1; - if (ret > 0) { - ERR("ldap:%s:%d:%d: Database field name expected\n", - st->file, st->line, st->col); + if(ret < 0) + return -1; + if(ret > 0) { + ERR("ldap:%s:%d:%d: Database field name expected\n", st->file, st->line, + st->col); return -1; } - if (t.type != CFG_TOKEN_ALPHA) { - ERR("ldap:%s:%d:%d: Invalid field name format %d:'%.*s'\n", - st->file, t.start.line, t.start.col, - t.type, STR_FMT(&t.val)); + if(t.type != CFG_TOKEN_ALPHA) { + ERR("ldap:%s:%d:%d: Invalid field name format %d:'%.*s'\n", st->file, + t.start.line, t.start.col, t.type, STR_FMT(&t.val)); return -1; } - if ((cfg->field[cfg->n - 1].s = as_asciiz(&t.val)) == NULL) { - ERR("ldap:%s:%d:%d: Out of memory\n", st->file, - t.start.line, t.start.col); + if((cfg->field[cfg->n - 1].s = as_asciiz(&t.val)) == NULL) { + ERR("ldap:%s:%d:%d: Out of memory\n", st->file, t.start.line, + t.start.col); return -1; } cfg->field[cfg->n - 1].len = t.val.len; ret = cfg_get_token(&t, st, 0); - if (ret < 0) return -1; - if (ret > 0) { - ERR("ldap:%s:%d:%d: Delimiter ':' missing\n", - st->file, st->line, st->col); + if(ret < 0) + return -1; + if(ret > 0) { + ERR("ldap:%s:%d:%d: Delimiter ':' missing\n", st->file, st->line, + st->col); return -1; } - if (t.type != ':') { - ERR("ldap:%s:%d:%d: Syntax error, ':' expected\n", - st->file, t.start.line, t.start.col); + if(t.type != ':') { + ERR("ldap:%s:%d:%d: Syntax error, ':' expected\n", st->file, + t.start.line, t.start.col); return -1; } ret = cfg_get_token(&t, st, 0); - if (ret < 0) return -1; - if (ret > 0) { - ERR("ldap:%s:%d:%d: LDAP Attribute syntax or name expected\n", - st->file, st->line, st->col); + if(ret < 0) + return -1; + if(ret > 0) { + ERR("ldap:%s:%d:%d: LDAP Attribute syntax or name expected\n", st->file, + st->line, st->col); return -1; } - if (t.type == '(') { + if(t.type == '(') { ret = cfg_get_token(&t, st, 0); - if (ret < 0) return -1; - if (ret > 0) { - ERR("ldap:%s:%d:%d: LDAP Attribute Syntax expected\n", - st->file, st->line, st->col); + if(ret < 0) + return -1; + if(ret > 0) { + ERR("ldap:%s:%d:%d: LDAP Attribute Syntax expected\n", st->file, + st->line, st->col); return -1; } - if (t.type != CFG_TOKEN_ALPHA) { - ERR("ldap:%s:%d:%d: Invalid LDAP attribute syntax format %d:'%.*s'\n", - st->file, t.start.line, t.start.col, - t.type, STR_FMT(&t.val)); + if(t.type != CFG_TOKEN_ALPHA) { + ERR("ldap:%s:%d:%d: Invalid LDAP attribute syntax format " + "%d:'%.*s'\n", + st->file, t.start.line, t.start.col, t.type, + STR_FMT(&t.val)); return -1; } - if ((syntax = cfg_lookup_token(syntaxes, &t.val)) == NULL) { - ERR("ldap:%s:%d:%d: Invalid syntaxt value '%.*s'\n", - st->file, t.start.line, t.start.col, STR_FMT(&t.val)); + if((syntax = cfg_lookup_token(syntaxes, &t.val)) == NULL) { + ERR("ldap:%s:%d:%d: Invalid syntaxt value '%.*s'\n", st->file, + t.start.line, t.start.col, STR_FMT(&t.val)); return -1; } cfg->syntax[cfg->n - 1] = syntax->val; ret = cfg_get_token(&t, st, 0); - if (ret < 0) return -1; - if (ret > 0) { + if(ret < 0) + return -1; + if(ret > 0) { ERR("ldap:%s:%d:%d: Closing ')' missing in attribute syntax\n", - st->file, st->line, st->col); + st->file, st->line, st->col); return -1; } - if (t.type != ')') { - ERR("ldap:%s:%d:%d: Syntax error, ')' expected\n", - st->file, st->line, st->col); + if(t.type != ')') { + ERR("ldap:%s:%d:%d: Syntax error, ')' expected\n", st->file, + st->line, st->col); return -1; } ret = cfg_get_token(&t, st, 0); - if (ret < 0) return -1; - if (ret > 0) { - ERR("ldap:%s:%d:%d: LDAP Attribute name expected\n", - st->file, st->line, st->col); + if(ret < 0) + return -1; + if(ret > 0) { + ERR("ldap:%s:%d:%d: LDAP Attribute name expected\n", st->file, + st->line, st->col); return -1; } } - if (t.type != CFG_TOKEN_ALPHA) { + if(t.type != CFG_TOKEN_ALPHA) { ERR("ldap:%s:%d:%d: Invalid LDAP attribute name format %d:'%.*s'\n", - st->file, t.start.line, t.start.col, t.type, STR_FMT(&t.val)); + st->file, t.start.line, t.start.col, t.type, STR_FMT(&t.val)); return -1; } - if ((cfg->attr[cfg->n - 1].s = as_asciiz(&t.val)) == NULL) { - ERR("ldap:%s:%d:%d: Out of memory\n", - st->file, t.start.line, t.start.col); + if((cfg->attr[cfg->n - 1].s = as_asciiz(&t.val)) == NULL) { + ERR("ldap:%s:%d:%d: Out of memory\n", st->file, t.start.line, + t.start.col); return -1; } cfg->attr[cfg->n - 1].len = t.val.len; - if (cfg_eat_eol(st, flags)) return -1; + if(cfg_eat_eol(st, flags)) + return -1; return 0; } -static cfg_option_t scope_values[] = { - {"base", .val = LDAP_SCOPE_BASE }, - {"onelevel", .val = LDAP_SCOPE_ONELEVEL}, - {"one", .val = LDAP_SCOPE_ONELEVEL}, - {"subtree", .val = LDAP_SCOPE_SUBTREE }, - {"sub", .val = LDAP_SCOPE_SUBTREE }, +static cfg_option_t scope_values[] = {{"base", .val = LDAP_SCOPE_BASE}, + {"onelevel", .val = LDAP_SCOPE_ONELEVEL}, + {"one", .val = LDAP_SCOPE_ONELEVEL}, + {"subtree", .val = LDAP_SCOPE_SUBTREE}, + {"sub", .val = LDAP_SCOPE_SUBTREE}, #if defined HAVE_SCOPE_CHILDREN - {"children", .val = LDAP_SCOPE_CHILDREN}, + {"children", .val = LDAP_SCOPE_CHILDREN}, #endif - {0} -}; + {0}}; static cfg_option_t deref_values[] = { - {"never", .val = LDAP_DEREF_NEVER }, /* default, 0x00 */ - {"searching", .val = LDAP_DEREF_SEARCHING}, - {"finding", .val = LDAP_DEREF_FINDING }, - {"always", .val = LDAP_DEREF_ALWAYS }, - {0} -}; + {"never", .val = LDAP_DEREF_NEVER}, /* default, 0x00 */ + {"searching", .val = LDAP_DEREF_SEARCHING}, + {"finding", .val = LDAP_DEREF_FINDING}, + {"always", .val = LDAP_DEREF_ALWAYS}, {0}}; static cfg_option_t ldap_tab_options[] = { - {"scope", .param = scope_values, .f = cfg_parse_enum_opt}, - {"field_map", .f = parse_field_map}, - {"filter", .f = cfg_parse_str_opt, .flags = CFG_STR_PKGMEM}, - {"base", .f = cfg_parse_str_opt, .flags = CFG_STR_PKGMEM}, - {"timelimit", .f = cfg_parse_int_opt}, - {"sizelimit", .f = cfg_parse_int_opt}, - {"chase_references", .param = deref_values, .f = cfg_parse_enum_opt}, - {"chase_referrals", .f = cfg_parse_bool_opt}, - {0} -}; + {"scope", .param = scope_values, .f = cfg_parse_enum_opt}, + {"field_map", .f = parse_field_map}, + {"filter", .f = cfg_parse_str_opt, .flags = CFG_STR_PKGMEM}, + {"base", .f = cfg_parse_str_opt, .flags = CFG_STR_PKGMEM}, + {"timelimit", .f = cfg_parse_int_opt}, + {"sizelimit", .f = cfg_parse_int_opt}, + {"chase_references", .param = deref_values, .f = cfg_parse_enum_opt}, + {"chase_referrals", .f = cfg_parse_bool_opt}, {0}}; -static cfg_option_t auth_values[] = { - {"none", .val = LDAP_AUTHMECH_NONE}, - {"simple", .val = LDAP_AUTHMECH_SIMPLE}, - {"digest-md5", .val = LDAP_AUTHMECH_DIGESTMD5}, - {"external", .val = LDAP_AUTHMECH_EXTERNAL}, - {0} -}; +static cfg_option_t auth_values[] = {{"none", .val = LDAP_AUTHMECH_NONE}, + {"simple", .val = LDAP_AUTHMECH_SIMPLE}, + {"digest-md5", .val = LDAP_AUTHMECH_DIGESTMD5}, + {"external", .val = LDAP_AUTHMECH_EXTERNAL}, {0}}; static cfg_option_t ldap_con_options[] = { - {"host", .f = cfg_parse_str_opt, .flags = CFG_STR_PKGMEM}, - {"port", .f = cfg_parse_int_opt}, - {"username", .f = cfg_parse_str_opt, .flags = CFG_STR_PKGMEM}, - {"password", .f = cfg_parse_str_opt, .flags = CFG_STR_PKGMEM}, - {"authtype", .param = auth_values, .f = cfg_parse_enum_opt}, - {"tls", .f = cfg_parse_bool_opt}, - {"ca_list", .f = cfg_parse_str_opt, .flags = CFG_STR_PKGMEM}, - {"require_certificate", .f = cfg_parse_str_opt, .flags = CFG_STR_PKGMEM}, - {0} -}; + {"host", .f = cfg_parse_str_opt, .flags = CFG_STR_PKGMEM}, + {"port", .f = cfg_parse_int_opt}, + {"username", .f = cfg_parse_str_opt, .flags = CFG_STR_PKGMEM}, + {"password", .f = cfg_parse_str_opt, .flags = CFG_STR_PKGMEM}, + {"authtype", .param = auth_values, .f = cfg_parse_enum_opt}, + {"tls", .f = cfg_parse_bool_opt}, + {"ca_list", .f = cfg_parse_str_opt, .flags = CFG_STR_PKGMEM}, + {"require_certificate", .f = cfg_parse_str_opt, + .flags = CFG_STR_PKGMEM}, + {0}}; -static cfg_option_t section_types[] = { - {"connection", .val = LDAP_CON_SECTION}, - {"con", .val = LDAP_CON_SECTION}, - {"table", .val = LDAP_TABLE_SECTION}, - {0} -}; +static cfg_option_t section_types[] = {{"connection", .val = LDAP_CON_SECTION}, + {"con", .val = LDAP_CON_SECTION}, {"table", .val = LDAP_TABLE_SECTION}, + {0}}; -static int parse_section(void* param, cfg_parser_t* st, unsigned int flags) +static int parse_section(void *param, cfg_parser_t *st, unsigned int flags) { cfg_token_t t; int ret, type, i; - cfg_option_t* opt; - str* id = NULL; - struct ld_cfg* tab; - struct ld_con_info* cinfo; + cfg_option_t *opt; + str *id = NULL; + struct ld_cfg *tab; + struct ld_con_info *cinfo; ret = cfg_get_token(&t, st, 0); - if (ret < 0) return -1; - if (ret > 0) { - ERR("%s:%d:%d: Section type missing\n", - st->file, st->line, st->col); + if(ret < 0) + return -1; + if(ret > 0) { + ERR("%s:%d:%d: Section type missing\n", st->file, st->line, st->col); return -1; } - if (t.type != CFG_TOKEN_ALPHA || - ((opt = cfg_lookup_token(section_types, &t.val)) == NULL)) { - ERR("%s:%d:%d: Invalid section type %d:'%.*s'\n", - st->file, t.start.line, t.start.col, t.type, STR_FMT(&t.val)); + if(t.type != CFG_TOKEN_ALPHA + || ((opt = cfg_lookup_token(section_types, &t.val)) == NULL)) { + ERR("%s:%d:%d: Invalid section type %d:'%.*s'\n", st->file, + t.start.line, t.start.col, t.type, STR_FMT(&t.val)); return -1; } type = opt->val; - if (type == LDAP_TABLE_SECTION) { - if ((tab = pkg_malloc(sizeof(*tab))) == NULL) { + if(type == LDAP_TABLE_SECTION) { + if((tab = pkg_malloc(sizeof(*tab))) == NULL) { ERR("ldap:%s:%d: Out of memory\n", st->file, st->line); return -1; } @@ -346,8 +353,8 @@ static int parse_section(void* param, cfg_parser_t* st, unsigned int flags) deref_values[i].param = &cfg->chase_references; } ldap_tab_options[7].param = &cfg->chase_referrals; - } else if (type == LDAP_CON_SECTION) { - if ((cinfo = pkg_malloc(sizeof(*cinfo))) == NULL) { + } else if(type == LDAP_CON_SECTION) { + if((cinfo = pkg_malloc(sizeof(*cinfo))) == NULL) { ERR("ldap:%s:%d: Out of memory\n", st->file, st->line); return -1; } @@ -367,62 +374,64 @@ static int parse_section(void* param, cfg_parser_t* st, unsigned int flags) ldap_con_options[6].param = &con->ca_list; ldap_con_options[7].param = &con->req_cert; } else { - BUG("%s:%d:%d: Unsupported section type %c\n", - st->file, t.start.line, t.start.col, t.type); + BUG("%s:%d:%d: Unsupported section type %c\n", st->file, t.start.line, + t.start.col, t.type); return -1; } ret = cfg_get_token(&t, st, 0); - if (ret < 0) return -1; - if (ret > 0) { - ERR("%s:%d:%d: Delimiter ':' expected.\n", - st->file, st->line, st->col); + if(ret < 0) + return -1; + if(ret > 0) { + ERR("%s:%d:%d: Delimiter ':' expected.\n", st->file, st->line, st->col); return -1; } - if (type == LDAP_TABLE_SECTION) { + if(type == LDAP_TABLE_SECTION) { id = &cfg->table; - } else if (type == LDAP_CON_SECTION) { + } else if(type == LDAP_CON_SECTION) { id = &con->id; } else { - BUG("%s:%d:%d: Invalid section type %d\n", st->file, - st->line, st->col, type); + BUG("%s:%d:%d: Invalid section type %d\n", st->file, st->line, st->col, + type); } ret = cfg_parse_str(id, st, CFG_STR_PKGMEM); - if (ret < 0) return -1; - if (ret > 0) { - ERR("%s:%d:%d: Section identifier expected\n", - st->file, st->line, st->col); + if(ret < 0) + return -1; + if(ret > 0) { + ERR("%s:%d:%d: Section identifier expected\n", st->file, st->line, + st->col); return -1; } ret = cfg_get_token(&t, st, 0); - if (ret < 0) return ret; - if (ret > 0) { - ERR("%s:%d:%d: Missing closing ']'.\n", - st->file, st->line, st->col); + if(ret < 0) + return ret; + if(ret > 0) { + ERR("%s:%d:%d: Missing closing ']'.\n", st->file, st->line, st->col); return -1; } - if (t. type != ']') { - ERR("%s:%d:%d: Syntax error, ']' expected.\n", - st->file, t.start.line, t.start.col); + if(t.type != ']') { + ERR("%s:%d:%d: Syntax error, ']' expected.\n", st->file, t.start.line, + t.start.col); return -1; } - if (cfg_eat_eol(st, flags)) return -1; + if(cfg_eat_eol(st, flags)) + return -1; return 0; } -struct ld_cfg* ld_find_cfg(str* table) +struct ld_cfg *ld_find_cfg(str *table) { - struct ld_cfg* ptr; + struct ld_cfg *ptr; ptr = cfg; while(ptr) { - if (ptr->table.len == table->len && - !strncmp(ptr->table.s, table->s, table->len)) + if(ptr->table.len == table->len + && !strncmp(ptr->table.s, table->s, table->len)) return ptr; ptr = ptr->next; } @@ -430,12 +439,13 @@ struct ld_cfg* ld_find_cfg(str* table) } -char* ld_find_attr_name(enum ld_syntax* syntax, struct ld_cfg* cfg, char* fld_name) +char *ld_find_attr_name( + enum ld_syntax *syntax, struct ld_cfg *cfg, char *fld_name) { int i; for(i = 0; i < cfg->n; i++) { - if (!strcmp(fld_name, cfg->field[i].s)) { + if(!strcmp(fld_name, cfg->field[i].s)) { *syntax = cfg->syntax[i]; return cfg->attr[i].s; } @@ -444,14 +454,14 @@ char* ld_find_attr_name(enum ld_syntax* syntax, struct ld_cfg* cfg, char* fld_na } -struct ld_con_info* ld_find_conn_info(str* conn_id) +struct ld_con_info *ld_find_conn_info(str *conn_id) { - struct ld_con_info* ptr; + struct ld_con_info *ptr; ptr = con; while(ptr) { - if (ptr->id.len == conn_id->len && - !memcmp(ptr->id.s, conn_id->s, conn_id->len)) { + if(ptr->id.len == conn_id->len + && !memcmp(ptr->id.s, conn_id->s, conn_id->len)) { return ptr; } ptr = ptr->next; @@ -464,12 +474,12 @@ static int ld_cfg_validity_check(struct ld_cfg *cfg) { struct ld_cfg *pcfg; - for (pcfg = cfg; pcfg; pcfg = pcfg->next) { - if (pcfg->sizelimit < 0 || pcfg->sizelimit > LD_MAXINT) { + for(pcfg = cfg; pcfg; pcfg = pcfg->next) { + if(pcfg->sizelimit < 0 || pcfg->sizelimit > LD_MAXINT) { ERR("ldap: invalid sizelimit (%d) specified\n", pcfg->sizelimit); return -1; } - if (pcfg->timelimit < 0 || pcfg->timelimit > LD_MAXINT) { + if(pcfg->timelimit < 0 || pcfg->timelimit > LD_MAXINT) { ERR("ldap: invalid timelimit (%d) specified\n", pcfg->timelimit); return -1; } @@ -479,20 +489,20 @@ static int ld_cfg_validity_check(struct ld_cfg *cfg) } -int ld_load_cfg(str* filename) +int ld_load_cfg(str *filename) { - cfg_parser_t* parser; + cfg_parser_t *parser; cfg = NULL; - if ((parser = cfg_parser_init(0, filename)) == NULL) { + if((parser = cfg_parser_init(0, filename)) == NULL) { ERR("ldap: Error while initializing configuration file parser.\n"); return -1; } cfg_section_parser(parser, parse_section, NULL); - if (sr_cfg_parse(parser)) { - if (cfg == NULL) { + if(sr_cfg_parse(parser)) { + if(cfg == NULL) { ERR("ldap: A table name (i.e. [table_name]) is missing in the " "configuration file.\n"); } @@ -502,7 +512,7 @@ int ld_load_cfg(str* filename) } cfg_parser_close(parser); - if (ld_cfg_validity_check(cfg)) { + if(ld_cfg_validity_check(cfg)) { ld_cfg_free(); return -1; } diff --git a/src/modules/db2_ldap/ld_cfg.h b/src/modules/db2_ldap/ld_cfg.h index 609ac76ab85..e7bf884c4bd 100644 --- a/src/modules/db2_ldap/ld_cfg.h +++ b/src/modules/db2_ldap/ld_cfg.h @@ -34,42 +34,45 @@ #define LD_MAXINT (2147483647) -struct ld_cfg { - str table; /**< Name of the db api table */ - str base; /**< The search base to be used with the table, zero terminated */ - int scope; /**< LDAP scope */ - str filter; /**< The search filter, zero terminated */ - str* field; /**< An array of DB API fields, zero terminated */ - str* attr; /**< An array of LDAP attribute names, zero terminated */ - enum ld_syntax* syntax; /**< An array of configured LDAP syntaxes */ - int n; /**< Number of fields in the arrays */ +struct ld_cfg +{ + str table; /**< Name of the db api table */ + str base; /**< The search base to be used with the table, zero terminated */ + int scope; /**< LDAP scope */ + str filter; /**< The search filter, zero terminated */ + str *field; /**< An array of DB API fields, zero terminated */ + str *attr; /**< An array of LDAP attribute names, zero terminated */ + enum ld_syntax *syntax; /**< An array of configured LDAP syntaxes */ + int n; /**< Number of fields in the arrays */ int sizelimit; /**< retrieve at most sizelimit entries for a search */ int timelimit; /**< wait at most timelimit seconds for a search to complete */ - int chase_references; /**< dereference option for LDAP library */ - int chase_referrals; /**< follow referrals option for LDAP library */ - struct ld_cfg* next; /**< The next table in the list */ + int chase_references; /**< dereference option for LDAP library */ + int chase_referrals; /**< follow referrals option for LDAP library */ + struct ld_cfg *next; /**< The next table in the list */ }; -struct ld_con_info { +struct ld_con_info +{ str id; str host; unsigned int port; str username; str password; int authmech; - int tls; /**< TLS encryption enabled */ + int tls; /**< TLS encryption enabled */ str ca_list; /**< Path of the file that contains certificates of the CAs */ - str req_cert; /**< LDAP level of certificate request behaviour */ - struct ld_con_info* next; + str req_cert; /**< LDAP level of certificate request behaviour */ + struct ld_con_info *next; }; -struct ld_cfg* ld_find_cfg(str* table); +struct ld_cfg *ld_find_cfg(str *table); -char* ld_find_attr_name(enum ld_syntax* syntax, struct ld_cfg* cfg, char* fld_name); +char *ld_find_attr_name( + enum ld_syntax *syntax, struct ld_cfg *cfg, char *fld_name); -struct ld_con_info* ld_find_conn_info(str* conn_id); +struct ld_con_info *ld_find_conn_info(str *conn_id); -int ld_load_cfg(str* filename); +int ld_load_cfg(str *filename); void ld_cfg_free(void); diff --git a/src/modules/db2_ldap/ld_cmd.c b/src/modules/db2_ldap/ld_cmd.c index c9bd29387fc..f8ede7a813b 100644 --- a/src/modules/db2_ldap/ld_cmd.c +++ b/src/modules/db2_ldap/ld_cmd.c @@ -50,26 +50,27 @@ * @param cmd A pointer to generic db_cmd command being freed. * @param payload A pointer to ld_cmd structure to be freed. */ -static void ld_cmd_free(db_cmd_t* cmd, struct ld_cmd* payload) +static void ld_cmd_free(db_cmd_t *cmd, struct ld_cmd *payload) { db_drv_free(&payload->gen); - if (payload->result) pkg_free(payload->result); + if(payload->result) + pkg_free(payload->result); pkg_free(payload); } -static int build_result_array(char*** res, db_cmd_t* cmd) +static int build_result_array(char ***res, db_cmd_t *cmd) { - struct ld_fld* lfld; - char** t; + struct ld_fld *lfld; + char **t; int i; - if (cmd->result_count == 0) { + if(cmd->result_count == 0) { *res = NULL; return 0; } - t = (char**)pkg_malloc(sizeof(char*) * (cmd->result_count + 1)); - if (t == NULL) { + t = (char **)pkg_malloc(sizeof(char *) * (cmd->result_count + 1)); + if(t == NULL) { ERR("ldap: No memory left\n"); return -1; } @@ -86,41 +87,43 @@ static int build_result_array(char*** res, db_cmd_t* cmd) } -int ld_cmd(db_cmd_t* cmd) +int ld_cmd(db_cmd_t *cmd) { - struct ld_cmd* lcmd; - struct ld_cfg* cfg; - struct ld_fld* lfld; + struct ld_cmd *lcmd; + struct ld_cfg *cfg; + struct ld_fld *lfld; int i, j; - lcmd = (struct ld_cmd*)pkg_malloc(sizeof(struct ld_cmd)); - if (lcmd == NULL) { + lcmd = (struct ld_cmd *)pkg_malloc(sizeof(struct ld_cmd)); + if(lcmd == NULL) { ERR("ldap: No memory left\n"); goto error; } memset(lcmd, '\0', sizeof(struct ld_cmd)); - if (db_drv_init(&lcmd->gen, ld_cmd_free) < 0) goto error; - - switch(cmd->type) { - case DB_PUT: - case DB_DEL: - case DB_UPD: - ERR("ldap: The driver does not support directory modifications yet.\n"); + if(db_drv_init(&lcmd->gen, ld_cmd_free) < 0) goto error; - break; - - case DB_GET: - break; - case DB_SQL: - ERR("ldap: The driver does not support raw queries yet.\n"); - goto error; + switch(cmd->type) { + case DB_PUT: + case DB_DEL: + case DB_UPD: + ERR("ldap: The driver does not support directory modifications " + "yet.\n"); + goto error; + break; + + case DB_GET: + break; + + case DB_SQL: + ERR("ldap: The driver does not support raw queries yet.\n"); + goto error; } cfg = ld_find_cfg(&cmd->table); - if (cfg == NULL) { + if(cfg == NULL) { ERR("ldap: Cannot find configuration for '%.*s', giving up\n", - STR_FMT(&cmd->table)); + STR_FMT(&cmd->table)); goto error; } @@ -128,66 +131,75 @@ int ld_cmd(db_cmd_t* cmd) lcmd->scope = cfg->scope; lcmd->sizelimit = cfg->sizelimit; - if (cfg->timelimit) { + if(cfg->timelimit) { lcmd->timelimit.tv_sec = cfg->timelimit; lcmd->timelimit.tv_usec = 0; } - if (cfg->filter.s) { + if(cfg->filter.s) { lcmd->filter = cfg->filter; } lcmd->chase_references = cfg->chase_references; lcmd->chase_referrals = cfg->chase_referrals; - if (ld_resolve_fld(cmd->match, cfg) < 0) goto error; - if (ld_resolve_fld(cmd->result, cfg) < 0) goto error; + if(ld_resolve_fld(cmd->match, cfg) < 0) + goto error; + if(ld_resolve_fld(cmd->result, cfg) < 0) + goto error; /* prepare filter for each result field */ - for(i = 0; !DB_FLD_EMPTY(cmd->result) && !DB_FLD_LAST(cmd->result[i]); i++) { + for(i = 0; !DB_FLD_EMPTY(cmd->result) && !DB_FLD_LAST(cmd->result[i]); + i++) { int n; lfld = DB_GET_PAYLOAD(cmd->result + i); lfld->filter = NULL; - - for(j = 0, n = 0; !DB_FLD_EMPTY(cmd->match) && !DB_FLD_LAST(cmd->match[j]); j++) { - if (strcmp(cmd->result[i].name, cmd->match[j].name) == 0) - n++; + + for(j = 0, n = 0; + !DB_FLD_EMPTY(cmd->match) && !DB_FLD_LAST(cmd->match[j]); j++) { + if(strcmp(cmd->result[i].name, cmd->match[j].name) == 0) + n++; } - - if (n > 0) { - lfld->filter = pkg_malloc((n+1)*sizeof(*(lfld->filter))); - if (!lfld->filter) return -1 /* E_OUT_OF_MEM*/; - for(j = 0, n = 0; !DB_FLD_EMPTY(cmd->match) && !DB_FLD_LAST(cmd->match[j]); j++) { - if (strcmp(cmd->result[i].name, cmd->match[j].name) == 0) { - lfld->filter[n] = cmd->match+j; + + if(n > 0) { + lfld->filter = pkg_malloc((n + 1) * sizeof(*(lfld->filter))); + if(!lfld->filter) + return -1 /* E_OUT_OF_MEM*/; + for(j = 0, n = 0; + !DB_FLD_EMPTY(cmd->match) && !DB_FLD_LAST(cmd->match[j]); + j++) { + if(strcmp(cmd->result[i].name, cmd->match[j].name) == 0) { + lfld->filter[n] = cmd->match + j; n++; } } lfld->filter[n] = NULL; } } - if (build_result_array(&lcmd->result, cmd) < 0) goto error; + if(build_result_array(&lcmd->result, cmd) < 0) + goto error; DB_SET_PAYLOAD(cmd, lcmd); return 0; - error: - if (lcmd) { +error: + if(lcmd) { DB_SET_PAYLOAD(cmd, NULL); db_drv_free(&lcmd->gen); - if (lcmd->result) pkg_free(lcmd->result); + if(lcmd->result) + pkg_free(lcmd->result); pkg_free(lcmd); } return -1; } -int ld_cmd_exec(db_res_t* res, db_cmd_t* cmd) +int ld_cmd_exec(db_res_t *res, db_cmd_t *cmd) { - db_con_t* con; - struct ld_res* lres; - struct ld_cmd* lcmd; - struct ld_con* lcon; - char* filter, *err_desc; + db_con_t *con; + struct ld_res *lres; + struct ld_cmd *lcmd; + struct ld_con *lcon; + char *filter, *err_desc; int ret, err; LDAPMessage *msg, *resmsg; int reconn_cnt; @@ -206,27 +218,28 @@ int ld_cmd_exec(db_res_t* res, db_cmd_t* cmd) con = cmd->ctx->con[db_payload_idx]; lcmd = DB_GET_PAYLOAD(cmd); lcon = DB_GET_PAYLOAD(con); - + reconn_cnt = ld_reconnect_attempt; - if (ld_prepare_ldap_filter(&filter, cmd, &lcmd->filter) < 0) { + if(ld_prepare_ldap_filter(&filter, cmd, &lcmd->filter) < 0) { ERR("ldap: Error while building LDAP search filter\n"); goto error; } DBG("ldap: ldap_search(base:'%s', filter:'%s')\n", lcmd->base, filter); do { - if (lcon->flags & LD_CONNECTED) { - ldap_set_option(lcon->con, LDAP_OPT_DEREF, ((void *)&lcmd->chase_references)); + if(lcon->flags & LD_CONNECTED) { + ldap_set_option(lcon->con, LDAP_OPT_DEREF, + ((void *)&lcmd->chase_references)); /* there is alternative method using LDAP_CONTROL_REFERRALS per request but is not well documented */ - ldap_set_option(lcon->con, LDAP_OPT_REFERRALS, lcmd->chase_referrals?LDAP_OPT_ON:LDAP_OPT_OFF); - + ldap_set_option(lcon->con, LDAP_OPT_REFERRALS, + lcmd->chase_referrals ? LDAP_OPT_ON : LDAP_OPT_OFF); + ret = ldap_search_ext(lcon->con, lcmd->base, lcmd->scope, filter, - lcmd->result, 0, NULL, NULL, - lcmd->timelimit.tv_sec ? &lcmd->timelimit : NULL, - lcmd->sizelimit, - &msgid); - if (ret != LDAP_SUCCESS) { + lcmd->result, 0, NULL, NULL, + lcmd->timelimit.tv_sec ? &lcmd->timelimit : NULL, + lcmd->sizelimit, &msgid); + if(ret != LDAP_SUCCESS) { ERR("ldap: Error while searching: %s\n", ldap_err2string(ret)); goto error; } @@ -238,90 +251,91 @@ int ld_cmd_exec(db_res_t* res, db_cmd_t* cmd) */ memset(&restimeout, 0, sizeof(restimeout)); restimeout.tv_sec = 5; - ret = ldap_result(lcon->con, - LDAP_RES_ANY, - LDAP_MSG_ALL, - &restimeout, - &resmsg); + ret = ldap_result(lcon->con, LDAP_RES_ANY, LDAP_MSG_ALL, + &restimeout, &resmsg); } else { /* force it to reconnect */ ret = -1; } - if (ret <= 0) { - ERR("ldap: Error in ldap_search: %s\n", ret < 0 ? ldap_err2string(ret) : "timeout"); - if (ret == LDAP_SERVER_DOWN) { + if(ret <= 0) { + ERR("ldap: Error in ldap_search: %s\n", + ret < 0 ? ldap_err2string(ret) : "timeout"); + if(ret == LDAP_SERVER_DOWN) { lcon->flags &= ~LD_CONNECTED; do { - if (!reconn_cnt) { - ERR("ldap: maximum reconnection attempt reached! giving up\n"); + if(!reconn_cnt) { + ERR("ldap: maximum reconnection attempt reached! " + "giving up\n"); goto error; } reconn_cnt--; err = ld_con_connect(con); - } while (err != 0); + } while(err != 0); } else { goto error; } } - } while (ret <= 0); + } while(ret <= 0); /* looking for unsolicited messages */ - for (msg = ldap_first_message(lcon->con, resmsg); - msg != NULL; - msg = ldap_next_message(lcon->con, msg)) { - if (ldap_msgtype(msg) == LDAP_RES_EXTENDED) { - if (ldap_parse_extended_result(lcon->con, - msg, - &oid, - &data, - 0) != LDAP_SUCCESS) { + for(msg = ldap_first_message(lcon->con, resmsg); msg != NULL; + msg = ldap_next_message(lcon->con, msg)) { + if(ldap_msgtype(msg) == LDAP_RES_EXTENDED) { + if(ldap_parse_extended_result(lcon->con, msg, &oid, &data, 0) + != LDAP_SUCCESS) { ERR("ldap: Error while parsing extended result\n"); - goto error; + goto error; } - if (oid != NULL) { - if (strcmp(oid, LDAP_NOTICE_OF_DISCONNECTION) == 0) { + if(oid != NULL) { + if(strcmp(oid, LDAP_NOTICE_OF_DISCONNECTION) == 0) { WARN("ldap: Notice of Disconnection (OID: %s)\n", oid); } else { WARN("ldap: Unsolicited message received. OID: %s\n", oid); } ldap_memfree(oid); } - if (data != NULL) { + if(data != NULL) { WARN("ldap: Unsolicited message data: %.*s\n", - (int)data->bv_len, data->bv_val); + (int)data->bv_len, data->bv_val); ber_bvfree(data); } } } - ret = ldap_parse_result(lcon->con, resmsg, &err, NULL, &err_desc, NULL, NULL, 0); - if (ret != LDAP_SUCCESS) { + ret = ldap_parse_result( + lcon->con, resmsg, &err, NULL, &err_desc, NULL, NULL, 0); + if(ret != LDAP_SUCCESS) { ERR("ldap: Error while reading result status: %s\n", - ldap_err2string(ret)); + ldap_err2string(ret)); goto error; } - if (err != LDAP_SUCCESS) { + if(err != LDAP_SUCCESS) { ERR("ldap: LDAP server reports error: %s\n", ldap_err2string(err)); goto error; } - if (res) { + if(res) { lres = DB_GET_PAYLOAD(res); lres->msg = resmsg; - } else if (resmsg) { + } else if(resmsg) { ldap_msgfree(resmsg); } - if (filter) pkg_free(filter); - if (err_desc) ldap_memfree(err_desc); + if(filter) + pkg_free(filter); + if(err_desc) + ldap_memfree(err_desc); return 0; - error: - if (filter) pkg_free(filter); - if (resmsg) ldap_msgfree(resmsg); - if (err_desc) ldap_memfree(err_desc); +error: + if(filter) + pkg_free(filter); + if(resmsg) + ldap_msgfree(resmsg); + if(err_desc) + ldap_memfree(err_desc); return -1; } @@ -330,43 +344,44 @@ int ld_cmd_exec(db_res_t* res, db_cmd_t* cmd) * of messages returned by the LDAP server and convert * the field values. */ -static int search_entry(db_res_t* res, int init) +static int search_entry(db_res_t *res, int init) { - db_con_t* con; - struct ld_res* lres; - struct ld_con* lcon; + db_con_t *con; + struct ld_res *lres; + struct ld_con *lcon; int r; lres = DB_GET_PAYLOAD(res); /* FIXME */ con = res->cmd->ctx->con[db_payload_idx]; lcon = DB_GET_PAYLOAD(con); - if (init - || !lres->current - || ldap_msgtype(lres->current) != LDAP_RES_SEARCH_ENTRY - /* there is no more value combination result left */ - || ld_incindex(res->cmd->result)) { + if(init || !lres->current + || ldap_msgtype(lres->current) != LDAP_RES_SEARCH_ENTRY + /* there is no more value combination result left */ + || ld_incindex(res->cmd->result)) { do { - if (init) { + if(init) { lres->current = ldap_first_message(lcon->con, lres->msg); init = 0; - } - else + } else lres->current = ldap_next_message(lcon->con, lres->current); - + while(lres->current) { - if (ldap_msgtype(lres->current) == LDAP_RES_SEARCH_ENTRY) { + if(ldap_msgtype(lres->current) == LDAP_RES_SEARCH_ENTRY) { break; } lres->current = ldap_next_message(lcon->con, lres->current); } - if (lres->current == NULL) return 1; + if(lres->current == NULL) + return 1; r = ld_ldap2fldinit(res->cmd->result, lcon->con, lres->current); - } while (r > 0); - if (r < 0) return -1; + } while(r > 0); + if(r < 0) + return -1; } else { - if (ld_ldap2fld(res->cmd->result, lcon->con, lres->current) < 0) return -1; + if(ld_ldap2fld(res->cmd->result, lcon->con, lres->current) < 0) + return -1; } res->cur_rec->fld = res->cmd->result; @@ -374,46 +389,49 @@ static int search_entry(db_res_t* res, int init) } -int ld_cmd_first(db_res_t* res) +int ld_cmd_first(db_res_t *res) { return search_entry(res, 1); } -int ld_cmd_next(db_res_t* res) +int ld_cmd_next(db_res_t *res) { return search_entry(res, 0); } -#define is_space(c) ((c)==' '||(c)==','||(c)==';'||(c)=='\t'||(c)=='\n'||(c)=='\r'||(c)=='\0') +#define is_space(c) \ + ((c) == ' ' || (c) == ',' || (c) == ';' || (c) == '\t' || (c) == '\n' \ + || (c) == '\r' || (c) == '\0') -int ld_cmd_setopt(db_cmd_t* cmd, char* optname, va_list ap) +int ld_cmd_setopt(db_cmd_t *cmd, char *optname, va_list ap) { - struct ld_fld* lfld; - char* val, *c; + struct ld_fld *lfld; + char *val, *c; int i; - - if (!strcasecmp("client_side_filtering", optname)) { - val = va_arg(ap, char*); - for(i = 0; !DB_FLD_EMPTY(cmd->result) && !DB_FLD_LAST(cmd->result[i]); i++) { + if(!strcasecmp("client_side_filtering", optname)) { + val = va_arg(ap, char *); + + for(i = 0; !DB_FLD_EMPTY(cmd->result) && !DB_FLD_LAST(cmd->result[i]); + i++) { c = val; do { c = strstr(c, cmd->result[i].name); - if (c) { - if ((c == val || is_space(*(c-1))) && is_space(*(c+strlen(cmd->result[i].name)))) { - lfld = (struct ld_fld*)DB_GET_PAYLOAD(cmd->result + i); + if(c) { + if((c == val || is_space(*(c - 1))) + && is_space(*(c + strlen(cmd->result[i].name)))) { + lfld = (struct ld_fld *)DB_GET_PAYLOAD(cmd->result + i); lfld->client_side_filtering = 1; break; } c += strlen(cmd->result[i].name); } - } while (c != NULL); + } while(c != NULL); } - } - else + } else return 1; - return 0; + return 0; } /** @} */ diff --git a/src/modules/db2_ldap/ld_cmd.h b/src/modules/db2_ldap/ld_cmd.h index ff6b8aa3be3..0ea431c20aa 100644 --- a/src/modules/db2_ldap/ld_cmd.h +++ b/src/modules/db2_ldap/ld_cmd.h @@ -47,16 +47,18 @@ * This data structure extends the generic data structure db_cmd in the * database API with data specific to the ldap driver. */ -struct ld_cmd { - db_drv_t gen; /**< Generic part of the data structure (must be first */ - char* base; /**< Search base of the command */ - int scope; /**< Scope of the search */ - str filter; /**< To be added to the search filter */ - char** result; /**< An array with result attribute names for ldap_search */ +struct ld_cmd +{ + db_drv_t gen; /**< Generic part of the data structure (must be first */ + char *base; /**< Search base of the command */ + int scope; /**< Scope of the search */ + str filter; /**< To be added to the search filter */ + char **result; /**< An array with result attribute names for ldap_search */ int sizelimit; /**< retrieve at most sizelimit entries for a search */ - struct timeval timelimit; /**< wait at most timelimit seconds for a search to complete */ - int chase_references; /**< dereference option for LDAP library */ - int chase_referrals; /**< follow referrals option for LDAP library */ + struct timeval + timelimit; /**< wait at most timelimit seconds for a search to complete */ + int chase_references; /**< dereference option for LDAP library */ + int chase_referrals; /**< follow referrals option for LDAP library */ }; @@ -67,7 +69,7 @@ struct ld_cmd { * @param cmd A generic db_cmd structure to which the newly created ld_cmd * structure will be attached. */ -int ld_cmd(db_cmd_t* cmd); +int ld_cmd(db_cmd_t *cmd); /** The main execution function in ldap SER driver. @@ -80,15 +82,15 @@ int ld_cmd(db_cmd_t* cmd); * @retval A negative number if the database server failed to execute command * @retval A positive number if there was an error on client side (SER) */ -int ld_cmd_exec(db_res_t* res, db_cmd_t* cmd); +int ld_cmd_exec(db_res_t *res, db_cmd_t *cmd); -int ld_cmd_first(db_res_t* res); +int ld_cmd_first(db_res_t *res); -int ld_cmd_next(db_res_t* res); +int ld_cmd_next(db_res_t *res); -int ld_cmd_setopt(db_cmd_t* cmd, char* optname, va_list ap); +int ld_cmd_setopt(db_cmd_t *cmd, char *optname, va_list ap); /** @} */ diff --git a/src/modules/db2_ldap/ld_con.c b/src/modules/db2_ldap/ld_con.c index 6f9837ff3b3..28b0fe20af7 100644 --- a/src/modules/db2_ldap/ld_con.c +++ b/src/modules/db2_ldap/ld_con.c @@ -48,63 +48,65 @@ * @param con A generic db_con connection structure. * @param payload LDAP specific payload to be freed. */ -static void ld_con_free(db_con_t* con, struct ld_con* payload) +static void ld_con_free(db_con_t *con, struct ld_con *payload) { - struct ld_uri* luri; + struct ld_uri *luri; int ret; - if (!payload) return; + if(!payload) + return; luri = DB_GET_PAYLOAD(con->uri); /* Delete the structure only if there are no more references * to it in the connection pool */ - if (db_pool_remove((db_pool_entry_t*)payload) == 0) return; + if(db_pool_remove((db_pool_entry_t *)payload) == 0) + return; db_pool_entry_free(&payload->gen); - if (payload->con) { + if(payload->con) { ret = ldap_unbind_ext_s(payload->con, NULL, NULL); - if (ret != LDAP_SUCCESS) { - ERR("ldap: Error while unbinding from %s: %s\n", - luri->uri, ldap_err2string(ret)); + if(ret != LDAP_SUCCESS) { + ERR("ldap: Error while unbinding from %s: %s\n", luri->uri, + ldap_err2string(ret)); } } pkg_free(payload); } -int ld_con(db_con_t* con) +int ld_con(db_con_t *con) { - struct ld_con* lcon; - struct ld_uri* luri; + struct ld_con *lcon; + struct ld_uri *luri; luri = DB_GET_PAYLOAD(con->uri); /* First try to lookup the connection in the connection pool and * re-use it if a match is found */ - lcon = (struct ld_con*)db_pool_get(con->uri); - if (lcon) { - DBG("ldap: Connection to %s found in connection pool\n", - luri->uri); + lcon = (struct ld_con *)db_pool_get(con->uri); + if(lcon) { + DBG("ldap: Connection to %s found in connection pool\n", luri->uri); goto found; } - lcon = (struct ld_con*)pkg_malloc(sizeof(struct ld_con)); - if (!lcon) { + lcon = (struct ld_con *)pkg_malloc(sizeof(struct ld_con)); + if(!lcon) { ERR("ldap: No memory left\n"); goto error; } memset(lcon, '\0', sizeof(struct ld_con)); - if (db_pool_entry_init(&lcon->gen, ld_con_free, con->uri) < 0) goto error; + if(db_pool_entry_init(&lcon->gen, ld_con_free, con->uri) < 0) + goto error; DBG("ldap: Preparing new connection to %s\n", luri->uri); /* Put the newly created LDAP connection into the pool */ - db_pool_put((struct db_pool_entry*)lcon); + db_pool_put((struct db_pool_entry *)lcon); DBG("ldap: Connection stored in connection pool\n"); - found: +found: /* Attach driver payload to the db_con structure and set connect and * disconnect functions */ @@ -113,8 +115,8 @@ int ld_con(db_con_t* con) con->disconnect = ld_con_disconnect; return 0; - error: - if (lcon) { +error: + if(lcon) { db_pool_entry_free(&lcon->gen); pkg_free(lcon); } @@ -122,30 +124,26 @@ int ld_con(db_con_t* con) } -int lutil_sasl_interact( - LDAP *ld, - unsigned flags, - void *defaults, - void *in ) +int lutil_sasl_interact(LDAP *ld, unsigned flags, void *defaults, void *in) { sasl_interact_t *interact = in; const char *dflt = interact->defresult; - if (ld == NULL) + if(ld == NULL) return LDAP_PARAM_ERROR; - while (interact->id != SASL_CB_LIST_END) { - switch( interact->id ) { + while(interact->id != SASL_CB_LIST_END) { + switch(interact->id) { // the username to authenticate case SASL_CB_AUTHNAME: - if (defaults) - dflt = ((struct ld_uri*)defaults)->username; + if(defaults) + dflt = ((struct ld_uri *)defaults)->username; break; // the password for the provided username case SASL_CB_PASS: - if (defaults) - dflt = ((struct ld_uri*)defaults)->password; + if(defaults) + dflt = ((struct ld_uri *)defaults)->password; break; // the realm for the authentication attempt case SASL_CB_GETREALM: @@ -168,59 +166,60 @@ int lutil_sasl_interact( } -int ld_con_connect(db_con_t* con) +int ld_con_connect(db_con_t *con) { - struct ld_con* lcon; - struct ld_uri* luri; + struct ld_con *lcon; + struct ld_uri *luri; int ret, version = 3; - char* err_str = NULL; + char *err_str = NULL; lcon = DB_GET_PAYLOAD(con); luri = DB_GET_PAYLOAD(con->uri); /* Do not reconnect already connected connections */ - if (lcon->flags & LD_CONNECTED) return 0; + if(lcon->flags & LD_CONNECTED) + return 0; DBG("ldap: Connecting to %s\n", luri->uri); - if (lcon->con) { + if(lcon->con) { ret = ldap_unbind_ext_s(lcon->con, NULL, NULL); - if (ret != LDAP_SUCCESS) { - ERR("ldap: Error while unbinding from %s: %s\n", - luri->uri, ldap_err2string(ret)); + if(ret != LDAP_SUCCESS) { + ERR("ldap: Error while unbinding from %s: %s\n", luri->uri, + ldap_err2string(ret)); } } /* we pass the TLS_REQCERT and TLS_REQCERT attributes over environment variables to ldap library */ - if (luri->tls) { - if (setenv("LDAPTLS_CACERT", luri->ca_list, 1)) { + if(luri->tls) { + if(setenv("LDAPTLS_CACERT", luri->ca_list, 1)) { ERR("ldap: Can't set environment variable 'LDAPTLS_CACERT'\n"); goto error; } - if (setenv("LDAPTLS_REQCERT", luri->req_cert, 1)) { + if(setenv("LDAPTLS_REQCERT", luri->req_cert, 1)) { ERR("ldap: Can't set environment variable 'LDAPTLS_REQCERT'\n"); goto error; } } ret = ldap_initialize(&lcon->con, luri->uri); - if (lcon->con == NULL) { + if(lcon->con == NULL) { ERR("ldap: Error while initializing new LDAP connection to %s\n", - luri->uri); + luri->uri); goto error; } ret = ldap_set_option(lcon->con, LDAP_OPT_PROTOCOL_VERSION, &version); - if (ret != LDAP_OPT_SUCCESS) { + if(ret != LDAP_OPT_SUCCESS) { ERR("ldap: Error while setting protocol version 3: %s\n", - ldap_err2string(ret)); + ldap_err2string(ret)); goto error; } - if (luri->tls) { + if(luri->tls) { ret = ldap_start_tls_s(lcon->con, NULL, NULL); - if (ret != LDAP_SUCCESS) { + if(ret != LDAP_SUCCESS) { /* get addition info of this error */ #ifdef OPENLDAP23 ldap_get_option(lcon->con, LDAP_OPT_ERROR_STRING, &err_str); @@ -228,7 +227,7 @@ int ld_con_connect(db_con_t* con) ldap_get_option(lcon->con, LDAP_OPT_DIAGNOSTIC_MESSAGE, &err_str); #endif ERR("ldap: Error while starting TLS: %s\n", ldap_err2string(ret)); - if (err_str) { + if(err_str) { ERR("ldap: %s\n", err_str); ldap_memfree(err_str); } @@ -236,7 +235,7 @@ int ld_con_connect(db_con_t* con) } } - switch (luri->authmech) { + switch(luri->authmech) { case LDAP_AUTHMECH_NONE: ret = ldap_simple_bind_s(lcon->con, NULL, NULL); break; @@ -244,9 +243,9 @@ int ld_con_connect(db_con_t* con) ret = ldap_simple_bind_s(lcon->con, luri->username, luri->password); break; case LDAP_AUTHMECH_DIGESTMD5: - ret = ldap_sasl_interactive_bind_s( lcon->con, NULL, - LDAP_MECHANISM_STR_DIGESTMD5, NULL, NULL, - 0, lutil_sasl_interact, luri ); + ret = ldap_sasl_interactive_bind_s(lcon->con, NULL, + LDAP_MECHANISM_STR_DIGESTMD5, NULL, NULL, 0, + lutil_sasl_interact, luri); break; case LDAP_AUTHMECH_EXTERNAL: default: @@ -254,9 +253,8 @@ int ld_con_connect(db_con_t* con) break; } - if (ret != LDAP_SUCCESS) { - ERR("ldap: Bind to %s failed: %s\n", - luri->uri, ldap_err2string(ret)); + if(ret != LDAP_SUCCESS) { + ERR("ldap: Bind to %s failed: %s\n", luri->uri, ldap_err2string(ret)); goto error; } @@ -264,12 +262,12 @@ int ld_con_connect(db_con_t* con) lcon->flags |= LD_CONNECTED; return 0; - error: - if (lcon->con) { +error: + if(lcon->con) { ret = ldap_unbind_ext_s(lcon->con, NULL, NULL); - if (ret) { - ERR("ldap: Error while unbinding from %s: %s\n", - luri->uri, ldap_err2string(ret)); + if(ret) { + ERR("ldap: Error while unbinding from %s: %s\n", luri->uri, + ldap_err2string(ret)); } } lcon->con = NULL; @@ -277,24 +275,25 @@ int ld_con_connect(db_con_t* con) } -void ld_con_disconnect(db_con_t* con) +void ld_con_disconnect(db_con_t *con) { - struct ld_con* lcon; - struct ld_uri* luri; + struct ld_con *lcon; + struct ld_uri *luri; int ret; lcon = DB_GET_PAYLOAD(con); luri = DB_GET_PAYLOAD(con->uri); - if ((lcon->flags & LD_CONNECTED) == 0) return; + if((lcon->flags & LD_CONNECTED) == 0) + return; DBG("ldap: Unbinding from %s\n", luri->uri); - if (lcon->con) { + if(lcon->con) { ret = ldap_unbind_ext_s(lcon->con, NULL, NULL); - if (ret) { - ERR("ldap: Error while unbinding from %s: %s\n", - luri->uri, ldap_err2string(ret)); + if(ret) { + ERR("ldap: Error while unbinding from %s: %s\n", luri->uri, + ldap_err2string(ret)); } } diff --git a/src/modules/db2_ldap/ld_con.h b/src/modules/db2_ldap/ld_con.h index c02b4a6ca06..08927535c56 100644 --- a/src/modules/db2_ldap/ld_con.h +++ b/src/modules/db2_ldap/ld_con.h @@ -43,8 +43,10 @@ /** * Per-connection flags for LDAP connections. */ -enum ld_con_flags { - LD_CONNECTED = (1 << 0), /**< The connection has been connected successfully */ +enum ld_con_flags +{ + LD_CONNECTED = + (1 << 0), /**< The connection has been connected successfully */ }; @@ -52,10 +54,11 @@ enum ld_con_flags { * This structure represents connections to LDAP servers. It contains * LDAP specific per-connection data, */ -struct ld_con { - db_pool_entry_t gen; /**< Generic part of the structure */ - LDAP* con; /**< LDAP connection handle */ - unsigned int flags; /**< Flags */ +struct ld_con +{ + db_pool_entry_t gen; /**< Generic part of the structure */ + LDAP *con; /**< LDAP connection handle */ + unsigned int flags; /**< Flags */ }; @@ -66,7 +69,7 @@ struct ld_con { * @retval 0 on success * @retval A negative number on error */ -int ld_con(db_con_t* con); +int ld_con(db_con_t *con); /** Establish a new connection to server. @@ -76,14 +79,14 @@ int ld_con(db_con_t* con); * @retval 0 on success. * @retval A negative number on error. */ -int ld_con_connect(db_con_t* con); +int ld_con_connect(db_con_t *con); /** Disconnected from LDAP server. * Disconnects a previously connected connection to LDAP server. * @param con A structure representing the connection to be disconnected. */ -void ld_con_disconnect(db_con_t* con); +void ld_con_disconnect(db_con_t *con); /** @} */ diff --git a/src/modules/db2_ldap/ld_fld.c b/src/modules/db2_ldap/ld_fld.c index 5286b4f5538..8180476db57 100644 --- a/src/modules/db2_ldap/ld_fld.c +++ b/src/modules/db2_ldap/ld_fld.c @@ -30,11 +30,11 @@ * Data field conversion and type checking functions. */ -#define _XOPEN_SOURCE 4 /* bsd */ -#define _XOPEN_SOURCE_EXTENDED 1 /* solaris */ -#define _SVID_SOURCE 1 /* timegm */ +#define _XOPEN_SOURCE 4 /* bsd */ +#define _XOPEN_SOURCE_EXTENDED 1 /* solaris */ +#define _SVID_SOURCE 1 /* timegm */ -#define _BSD_SOURCE /* snprintf */ +#define _BSD_SOURCE /* snprintf */ #define _DEFAULT_SOURCE 1 /* _BSD_SOURCE is deprecated */ #include "ld_fld.h" @@ -49,40 +49,42 @@ #include #include #include -#include /* strptime, XOPEN issue must be >= 4 */ +#include /* strptime, XOPEN issue must be >= 4 */ /** * Reallocatable string buffer. */ -struct sbuf { - char *s; /**< allocated memory itself */ - int len; /**< used memory */ - int size; /**< total size of allocated memory */ - int increment; /**< increment when realloc is necessary */ +struct sbuf +{ + char *s; /**< allocated memory itself */ + int len; /**< used memory */ + int size; /**< total size of allocated memory */ + int increment; /**< increment when realloc is necessary */ }; -#define TEST_RESIZE \ - if (rsize > sb->size) { \ - asize = rsize - sb->size; \ - new_size = sb->size + (asize / sb->increment + \ - (asize % sb->increment > 0)) * sb->increment; \ - newp = pkg_malloc(new_size); \ - if (!newp) { \ - ERR("ldap: No memory left\n"); \ - return -1; \ - } \ - if (sb->s) { \ - memcpy(newp, sb->s, sb->len); \ - pkg_free(sb->s); \ - } \ - sb->s = newp; \ - sb->size = new_size; \ +#define TEST_RESIZE \ + if(rsize > sb->size) { \ + asize = rsize - sb->size; \ + new_size = sb->size \ + + (asize / sb->increment + (asize % sb->increment > 0)) \ + * sb->increment; \ + newp = pkg_malloc(new_size); \ + if(!newp) { \ + ERR("ldap: No memory left\n"); \ + return -1; \ + } \ + if(sb->s) { \ + memcpy(newp, sb->s, sb->len); \ + pkg_free(sb->s); \ + } \ + sb->s = newp; \ + sb->size = new_size; \ } -static inline int sb_add(struct sbuf *sb, char* str, int len) +static inline int sb_add(struct sbuf *sb, char *str, int len) { int new_size = 0, asize; int rsize = sb->len + len; @@ -96,7 +98,7 @@ static inline int sb_add(struct sbuf *sb, char* str, int len) } -static inline int sb_add_esc(struct sbuf *sb, char* str, int len) +static inline int sb_add_esc(struct sbuf *sb, char *str, int len) { int new_size = 0, asize, i; int rsize = sb->len + len * 3; @@ -107,35 +109,45 @@ static inline int sb_add_esc(struct sbuf *sb, char* str, int len) w = sb->s + sb->len; for(i = 0; i < len; i++) { switch(str[i]) { - case '*': - *w++ = '\\'; *w++ = '2'; *w++ = 'A'; - sb->len += 3; - break; + case '*': + *w++ = '\\'; + *w++ = '2'; + *w++ = 'A'; + sb->len += 3; + break; - case '(': - *w++ = '\\'; *w++ = '2'; *w++ = '8'; - sb->len += 3; - break; + case '(': + *w++ = '\\'; + *w++ = '2'; + *w++ = '8'; + sb->len += 3; + break; - case ')': - *w++ = '\\'; *w++ = '2'; *w++ = '9'; - sb->len += 3; - break; + case ')': + *w++ = '\\'; + *w++ = '2'; + *w++ = '9'; + sb->len += 3; + break; - case '\\': - *w++ = '\\'; *w++ = '5'; *w++ = 'C'; - sb->len += 3; - break; + case '\\': + *w++ = '\\'; + *w++ = '5'; + *w++ = 'C'; + sb->len += 3; + break; - case '\0': - *w++ = '\\'; *w++ = '0'; *w++ = '0'; - sb->len += 3; - break; + case '\0': + *w++ = '\\'; + *w++ = '0'; + *w++ = '0'; + sb->len += 3; + break; - default: - *w++ = str[i]; - sb->len++; - break; + default: + *w++ = str[i]; + sb->len++; + break; } } @@ -148,73 +160,80 @@ static inline int sb_add_esc(struct sbuf *sb, char* str, int len) * @param fld Generic db_fld_t* structure being freed. * @param payload The ldap extension structure to be freed */ -static void ld_fld_free(db_fld_t* fld, struct ld_fld* payload) +static void ld_fld_free(db_fld_t *fld, struct ld_fld *payload) { db_drv_free(&payload->gen); - if (payload->values) ldap_value_free_len(payload->values); + if(payload->values) + ldap_value_free_len(payload->values); payload->values = NULL; - if (payload->filter) pkg_free(payload->filter); + if(payload->filter) + pkg_free(payload->filter); payload->filter = NULL; pkg_free(payload); } -int ld_fld(db_fld_t* fld, char* table) +int ld_fld(db_fld_t *fld, char *table) { - struct ld_fld* res; + struct ld_fld *res; - res = (struct ld_fld*)pkg_malloc(sizeof(struct ld_fld)); - if (res == NULL) { + res = (struct ld_fld *)pkg_malloc(sizeof(struct ld_fld)); + if(res == NULL) { ERR("ldap: No memory left\n"); return -1; } memset(res, '\0', sizeof(struct ld_fld)); - if (db_drv_init(&res->gen, ld_fld_free) < 0) goto error; + if(db_drv_init(&res->gen, ld_fld_free) < 0) + goto error; DB_SET_PAYLOAD(fld, res); return 0; - error: - if (res) pkg_free(res); +error: + if(res) + pkg_free(res); return -1; } -int ld_resolve_fld(db_fld_t* fld, struct ld_cfg* cfg) +int ld_resolve_fld(db_fld_t *fld, struct ld_cfg *cfg) { int i; - struct ld_fld* lfld; + struct ld_fld *lfld; - if (fld == NULL || cfg == NULL) return 0; + if(fld == NULL || cfg == NULL) + return 0; for(i = 0; !DB_FLD_EMPTY(fld) && !DB_FLD_LAST(fld[i]); i++) { lfld = DB_GET_PAYLOAD(fld + i); lfld->attr.s = ld_find_attr_name(&lfld->syntax, cfg, fld[i].name); - if (lfld->attr.s == NULL) lfld->attr.s = fld[i].name; - if (lfld->attr.s) lfld->attr.len = strlen(lfld->attr.s); + if(lfld->attr.s == NULL) + lfld->attr.s = fld[i].name; + if(lfld->attr.s) + lfld->attr.len = strlen(lfld->attr.s); } return 0; } -static inline int ldap_int2db_int(int* dst, str* src) +static inline int ldap_int2db_int(int *dst, str *src) { - if (str2sint(src, dst) != 0) { - ERR("ldap: Error while converting value '%.*s' to integer\n", - src->len, ZSW(src->s)); + if(str2sint(src, dst) != 0) { + ERR("ldap: Error while converting value '%.*s' to integer\n", src->len, + ZSW(src->s)); return -1; } return 0; } -static inline int ldap_bit2db_int(int* dst, str* src) +static inline int ldap_bit2db_int(int *dst, str *src) { int i, v; - if (src->len > 32) { + if(src->len > 32) { WARN("ldap: bitString '%.*s'B is longer than 32 bits, truncating\n", - src->len, ZSW(src->s)); + src->len, ZSW(src->s)); } v = 0; for(i = 0; i < src->len; i++) { @@ -226,42 +245,43 @@ static inline int ldap_bit2db_int(int* dst, str* src) } -static inline int ldap_gentime2db_datetime(time_t* dst, str* src) +static inline int ldap_gentime2db_datetime(time_t *dst, str *src) { struct tm time; - if (src->len < 12) return -1; + if(src->len < 12) + return -1; /* It is necessary to zero tm structure first */ memset(&time, '\0', sizeof(struct tm)); /* YYYYMMDDHHMMSS[.sss][ 'Z' | ( {'+'|'-'} ZZZZ) ] */ - strptime(src->s, "%Y%m%d%H%M%S", &time); /* Note: frac of seconds are lost in time_t representation */ - - if (src->s[src->len-1] == 'Z' || src->s[src->len-5] == '-' || src->s[src->len-5] == '+') { - /* GMT or specified TZ, no daylight saving time */ - #ifdef HAVE_TIMEGM + strptime(src->s, "%Y%m%d%H%M%S", + &time); /* Note: frac of seconds are lost in time_t representation */ + + if(src->s[src->len - 1] == 'Z' || src->s[src->len - 5] == '-' + || src->s[src->len - 5] == '+') { +/* GMT or specified TZ, no daylight saving time */ +#ifdef HAVE_TIMEGM *dst = timegm(&time); - #else +#else *dst = _timegm(&time); - #endif /* HAVE_TIMEGM */ +#endif /* HAVE_TIMEGM */ - if (src->s[src->len-1] != 'Z') { + if(src->s[src->len - 1] != 'Z') { /* timezone is specified */ memset(&time, '\0', sizeof(struct tm)); strptime(src->s + src->len - 4, "%H%M", &time); - switch (src->s[src->len-5]) { + switch(src->s[src->len - 5]) { case '-': - *dst -= time.tm_hour*3600+time.tm_min*60; + *dst -= time.tm_hour * 3600 + time.tm_min * 60; break; case '+': - *dst += time.tm_hour*3600+time.tm_min*60; + *dst += time.tm_hour * 3600 + time.tm_min * 60; break; - default: - ; + default:; } } - } - else { + } else { /* it's local time */ /* Daylight saving information got lost in the database @@ -272,25 +292,26 @@ static inline int ldap_gentime2db_datetime(time_t* dst, str* src) time.tm_isdst = -1; *dst = mktime(&time); } - + return 0; } -static inline int ldap_str2db_double(double* dst, char* src) +static inline int ldap_str2db_double(double *dst, char *src) { *dst = atof(src); return 0; } -static inline int ldap_str2db_float(float* dst, char* src) +static inline int ldap_str2db_float(float *dst, char *src) { *dst = (float)atof(src); return 0; } -static inline int ldap_fld2db_fld(db_fld_t* fld, str v) { +static inline int ldap_fld2db_fld(db_fld_t *fld, str v) +{ switch(fld->type) { case DB_CSTR: @@ -305,57 +326,57 @@ static inline int ldap_fld2db_fld(db_fld_t* fld, str v) { case DB_INT: case DB_BITMAP: - if (v.s[0] == '\'' && v.s[v.len - 1] == 'B' && - v.s[v.len - 2] == '\'') { + if(v.s[0] == '\'' && v.s[v.len - 1] == 'B' + && v.s[v.len - 2] == '\'') { v.s++; v.len -= 3; - if (ldap_bit2db_int(&fld->v.int4, &v) != 0) { + if(ldap_bit2db_int(&fld->v.int4, &v) != 0) { ERR("ldap: Error while converting bit string '%.*s'\n", - v.len, ZSW(v.s)); + v.len, ZSW(v.s)); return -1; } break; } - if (v.len == 4 && !strncasecmp("TRUE", v.s, v.len)) { + if(v.len == 4 && !strncasecmp("TRUE", v.s, v.len)) { fld->v.int4 = 1; break; } - if (v.len == 5 && !strncasecmp("FALSE", v.s, v.len)) { + if(v.len == 5 && !strncasecmp("FALSE", v.s, v.len)) { fld->v.int4 = 0; break; } - if (ldap_int2db_int(&fld->v.int4, &v) != 0) { - ERR("ldap: Error while converting %.*s to integer\n", - v.len, ZSW(v.s)); + if(ldap_int2db_int(&fld->v.int4, &v) != 0) { + ERR("ldap: Error while converting %.*s to integer\n", v.len, + ZSW(v.s)); return -1; } break; case DB_DATETIME: - if (ldap_gentime2db_datetime(&fld->v.time, &v) != 0) { + if(ldap_gentime2db_datetime(&fld->v.time, &v) != 0) { ERR("ldap: Error while converting LDAP time value '%.*s'\n", - v.len, ZSW(v.s)); + v.len, ZSW(v.s)); return -1; } break; case DB_FLOAT: /* We know that the ldap library zero-terminated v.s */ - if (ldap_str2db_float(&fld->v.flt, v.s) != 0) { - ERR("ldap: Error while converting '%.*s' to float\n", - v.len, ZSW(v.s)); + if(ldap_str2db_float(&fld->v.flt, v.s) != 0) { + ERR("ldap: Error while converting '%.*s' to float\n", v.len, + ZSW(v.s)); return -1; } break; case DB_DOUBLE: /* We know that the ldap library zero-terminated v.s */ - if (ldap_str2db_double(&fld->v.dbl, v.s) != 0) { - ERR("ldap: Error while converting '%.*s' to double\n", - v.len, ZSW(v.s)); + if(ldap_str2db_double(&fld->v.dbl, v.s) != 0) { + ERR("ldap: Error while converting '%.*s' to double\n", v.len, + ZSW(v.s)); return -1; } break; @@ -367,29 +388,31 @@ static inline int ldap_fld2db_fld(db_fld_t* fld, str v) { return 0; } -int ld_ldap2fldinit(db_fld_t* fld, LDAP* ldap, LDAPMessage* msg) +int ld_ldap2fldinit(db_fld_t *fld, LDAP *ldap, LDAPMessage *msg) { return ld_ldap2fldex(fld, ldap, msg, 1); } -int ld_ldap2fld(db_fld_t* fld, LDAP* ldap, LDAPMessage* msg) +int ld_ldap2fld(db_fld_t *fld, LDAP *ldap, LDAPMessage *msg) { return ld_ldap2fldex(fld, ldap, msg, 0); } -int ld_incindex(db_fld_t* fld) { +int ld_incindex(db_fld_t *fld) +{ int i; - struct ld_fld* lfld; + struct ld_fld *lfld; - if (fld == NULL) return 0; + if(fld == NULL) + return 0; i = 0; - while (!DB_FLD_EMPTY(fld) && !DB_FLD_LAST(fld[i])) { + while(!DB_FLD_EMPTY(fld) && !DB_FLD_LAST(fld[i])) { lfld = DB_GET_PAYLOAD(fld + i); lfld->index++; /* the index limit has been reached */ - if (lfld->index >= lfld->valuesnum) { + if(lfld->index >= lfld->valuesnum) { lfld->index = 0; } else { return 0; @@ -401,26 +424,27 @@ int ld_incindex(db_fld_t* fld) { return 1; } -#define CMP_NUM(fld_v,match_v,fld) \ - if (fld_v.fld == match_v.fld) \ - op = 0x02; \ - else if (fld_v.fld < match_v.fld) \ - op = 0x01; \ - else if (fld_v.fld > match_v.fld) \ +#define CMP_NUM(fld_v, match_v, fld) \ + if(fld_v.fld == match_v.fld) \ + op = 0x02; \ + else if(fld_v.fld < match_v.fld) \ + op = 0x01; \ + else if(fld_v.fld > match_v.fld) \ op = 0x04; - -int ld_ldap2fldex(db_fld_t* fld, LDAP* ldap, LDAPMessage* msg, int init) + +int ld_ldap2fldex(db_fld_t *fld, LDAP *ldap, LDAPMessage *msg, int init) { int i; - struct ld_fld* lfld; + struct ld_fld *lfld; str v; - if (fld == NULL || msg == NULL) return 0; + if(fld == NULL || msg == NULL) + return 0; for(i = 0; !DB_FLD_EMPTY(fld) && !DB_FLD_LAST(fld[i]); i++) { lfld = DB_GET_PAYLOAD(fld + i); - if (init) { - if (fld[i].type == DB_NONE) { - switch (lfld->syntax) { + if(init) { + if(fld[i].type == DB_NONE) { + switch(lfld->syntax) { case LD_SYNTAX_STRING: fld[i].type = DB_STR; break; @@ -432,7 +456,7 @@ int ld_ldap2fldex(db_fld_t* fld, LDAP* ldap, LDAPMessage* msg, int init) case LD_SYNTAX_FLOAT: fld[i].type = DB_FLOAT; break; - + case LD_SYNTAX_GENTIME: fld[i].type = DB_DATETIME; break; @@ -440,23 +464,24 @@ int ld_ldap2fldex(db_fld_t* fld, LDAP* ldap, LDAPMessage* msg, int init) fld[i].type = DB_BITMAP; break; } - } - + /* free the values of the previous object */ - if (lfld->values) ldap_value_free_len(lfld->values); + if(lfld->values) + ldap_value_free_len(lfld->values); lfld->values = ldap_get_values_len(ldap, msg, lfld->attr.s); lfld->index = 0; - - if (lfld->values == NULL || lfld->values[0] == NULL) { + + if(lfld->values == NULL || lfld->values[0] == NULL) { fld[i].flags |= DB_NULL; /* index == 0 means no value available */ lfld->valuesnum = 0; - if (lfld->client_side_filtering && lfld->filter) { + if(lfld->client_side_filtering && lfld->filter) { int j; /* if all the filter conditions require NULL value then we can accept the record */ - for (j=0; lfld->filter[j]; j++) { - if (lfld->filter[j]->flags & DB_NULL && lfld->filter[j]->op == DB_EQ) { + for(j = 0; lfld->filter[j]; j++) { + if(lfld->filter[j]->flags & DB_NULL + && lfld->filter[j]->op == DB_EQ) { continue; } return 1; /* get next record */ @@ -466,9 +491,10 @@ int ld_ldap2fldex(db_fld_t* fld, LDAP* ldap, LDAPMessage* msg, int init) /* init the number of values */ fld[i].flags &= ~DB_NULL; lfld->valuesnum = ldap_count_values_len(lfld->values); - - if ((lfld->valuesnum > 1 || lfld->client_side_filtering) && lfld->filter) { - + + if((lfld->valuesnum > 1 || lfld->client_side_filtering) + && lfld->filter) { + /* in case of multivalue we must check if value fits in filter criteria. LDAP returns record (having each multivalue) if one particular multivalue fits in filter provided to LDAP search. We need @@ -481,25 +507,23 @@ int ld_ldap2fldex(db_fld_t* fld, LDAP* ldap, LDAPMessage* msg, int init) The same algorithm is applied for client side filtering */ - + do { int passed, j; - for (j=0, passed = 1; lfld->filter[j] && passed; j++) { - int op; /* b0..less, b1..equal, b2..greater, zero..non equal */ + for(j = 0, passed = 1; lfld->filter[j] && passed; j++) { + int op; /* b0..less, b1..equal, b2..greater, zero..non equal */ op = 0x00; - if (lfld->filter[j]->flags & DB_NULL) { + if(lfld->filter[j]->flags & DB_NULL) { /* always non equal because field is not NULL */ - } - else { - + } else { + v.s = lfld->values[lfld->index]->bv_val; v.len = lfld->values[lfld->index]->bv_len; - - if (ldap_fld2db_fld(fld + i, v) < 0) { + + if(ldap_fld2db_fld(fld + i, v) < 0) { passed = 0; break; /* for loop */ - } - else { + } else { db_fld_val_t v; int t; static char buf[30]; @@ -509,22 +533,25 @@ int ld_ldap2fldex(db_fld_t* fld, LDAP* ldap, LDAPMessage* msg, int init) db_cmd(). We implement some basic conversions. */ v = lfld->filter[j]->v; - if (t == DB_CSTR) { + if(t == DB_CSTR) { v.lstr.s = v.cstr; v.lstr.len = strlen(v.lstr.s); t = DB_STR; - } - switch (fld[i].type) { + } + switch(fld[i].type) { case DB_CSTR: fld[i].v.lstr.s = fld[i].v.cstr; - fld[i].v.lstr.len = strlen(fld[i].v.lstr.s); - fld[i].type = DB_STR; + fld[i].v.lstr.len = + strlen(fld[i].v.lstr.s); + fld[i].type = DB_STR; /* no break */ case DB_STR: - - switch (t) { + + switch(t) { case DB_INT: - v.lstr.len = snprintf(buf, sizeof(buf)-1, "%d", v.int4); + v.lstr.len = snprintf(buf, + sizeof(buf) - 1, + "%d", v.int4); v.lstr.s = buf; break; /* numeric conversion for double/float not supported because of non unique string representation */ @@ -533,26 +560,31 @@ int ld_ldap2fldex(db_fld_t* fld, LDAP* ldap, LDAPMessage* msg, int init) } break; case DB_INT: - switch (t) { + switch(t) { case DB_DOUBLE: - if ((double)(int)v.dbl != (double)v.dbl) + if((double)(int)v.dbl + != (double)v.dbl) goto skip_conv; v.int4 = v.dbl; break; case DB_FLOAT: - if ((float)(int)v.flt != (float)v.flt) + if((float)(int)v.flt + != (float)v.flt) goto skip_conv; v.int4 = v.flt; break; - case DB_STR: - if (v.lstr.len > 0) { + case DB_STR: + if(v.lstr.len > 0) { char c, *p; int n; c = v.lstr.s[v.lstr.len]; - v.lstr.s[v.lstr.len] = '\0'; - n = strtol(v.lstr.s, &p, 10); - v.lstr.s[v.lstr.len] = c; - if ((*p) != '\0') { + v.lstr.s[v.lstr.len] = + '\0'; + n = strtol(v.lstr.s, &p, + 10); + v.lstr.s[v.lstr.len] = + c; + if((*p) != '\0') { goto skip_conv; } v.int4 = n; @@ -563,50 +595,56 @@ int ld_ldap2fldex(db_fld_t* fld, LDAP* ldap, LDAPMessage* msg, int init) } break; case DB_FLOAT: - switch (t) { + switch(t) { case DB_DOUBLE: v.flt = v.dbl; break; case DB_INT: v.flt = v.int4; break; - #ifdef __USE_ISOC99 - case DB_STR: - if (v.lstr.len > 0) { +#ifdef __USE_ISOC99 + case DB_STR: + if(v.lstr.len > 0) { char c, *p; float n; c = v.lstr.s[v.lstr.len]; - v.lstr.s[v.lstr.len] = '\0'; - n = strtof(v.lstr.s, &p); - v.lstr.s[v.lstr.len] = c; - if ((*p) != '\0') { + v.lstr.s[v.lstr.len] = + '\0'; + n = strtof( + v.lstr.s, &p); + v.lstr.s[v.lstr.len] = + c; + if((*p) != '\0') { goto skip_conv; } v.flt = n; } break; - #endif +#endif default: goto skip_conv; } break; case DB_DOUBLE: - switch (t) { + switch(t) { case DB_FLOAT: v.dbl = v.flt; break; case DB_INT: v.dbl = v.int4; break; - case DB_STR: - if (v.lstr.len > 0) { + case DB_STR: + if(v.lstr.len > 0) { char c, *p; double n; c = v.lstr.s[v.lstr.len]; - v.lstr.s[v.lstr.len] = '\0'; - n = strtod(v.lstr.s, &p); - v.lstr.s[v.lstr.len] = c; - if ((*p) != '\0') { + v.lstr.s[v.lstr.len] = + '\0'; + n = strtod( + v.lstr.s, &p); + v.lstr.s[v.lstr.len] = + c; + if((*p) != '\0') { goto skip_conv; } v.dbl = n; @@ -621,65 +659,79 @@ int ld_ldap2fldex(db_fld_t* fld, LDAP* ldap, LDAPMessage* msg, int init) case DB_DATETIME: default: goto skip_conv; - } + } t = fld[i].type; skip_conv: - if (t == fld[i].type) { - - switch (fld[i].type) { + if(t == fld[i].type) { + + switch(fld[i].type) { case DB_CSTR: /* impossible, already converted to DB_STR */ case DB_STR: - if (fld[i].v.lstr.len == v.lstr.len) { - op = strncmp(fld[i].v.lstr.s, v.lstr.s, v.lstr.len); - if (op < 0) + if(fld[i].v.lstr.len + == v.lstr.len) { + op = strncmp( + fld[i].v.lstr.s, + v.lstr.s, + v.lstr.len); + if(op < 0) op = 0x01; - else if (op > 0) + else if(op > 0) op = 0x04; else op = 0x02; - } - else if (fld[i].v.lstr.len < v.lstr.len) { - op = strncmp(fld[i].v.lstr.s, v.lstr.s, fld[i].v.lstr.len); - if (op < 0) + } else if(fld[i].v.lstr.len + < v.lstr.len) { + op = strncmp( + fld[i].v.lstr.s, + v.lstr.s, + fld[i].v.lstr.len); + if(op < 0) op = 0x01; - else + else op = 0x04; - } - else /* if (fld[i].v.lstr.len > v.lstr.len) */ { - op = strncmp(fld[i].v.lstr.s, v.lstr.s, v.lstr.len); - if (op > 0) + } else /* if (fld[i].v.lstr.len > v.lstr.len) */ + { + op = strncmp( + fld[i].v.lstr.s, + v.lstr.s, + v.lstr.len); + if(op > 0) op = 0x04; - else + else op = 0x01; } break; case DB_BLOB: - if (fld[i].v.blob.len == v.blob.len && memcmp(fld[i].v.blob.s, v.blob.s, v.blob.len) == 0) + if(fld[i].v.blob.len + == v.blob.len + && memcmp(fld[i].v.blob + .s, + v.blob.s, + v.blob.len) + == 0) op = 0x02; - break; + break; case DB_INT: CMP_NUM(fld[i].v, v, int4); - break; + break; case DB_BITMAP: CMP_NUM(fld[i].v, v, bitmap); - break; + break; case DB_DATETIME: CMP_NUM(fld[i].v, v, time); - break; + break; case DB_FLOAT: CMP_NUM(fld[i].v, v, flt); - break; + break; case DB_DOUBLE: CMP_NUM(fld[i].v, v, dbl); - break; - default: - ; + break; + default:; } } - } } - switch (lfld->filter[j]->op) { + switch(lfld->filter[j]->op) { case DB_EQ: passed = op == 0x02; break; @@ -698,64 +750,65 @@ int ld_ldap2fldex(db_fld_t* fld, LDAP* ldap, LDAPMessage* msg, int init) case DB_GEQ: passed = op == 0x04 || op == 0x02; break; - default: - ; + default:; } } - - if (passed) { - lfld->index++; - } - else { + + if(passed) { + lfld->index++; + } else { char *save_bvval; int save_bvlen; int i; /* shift following values, push useless value at the end and decrease num of values */ - + save_bvval = lfld->values[lfld->index]->bv_val; save_bvlen = lfld->values[lfld->index]->bv_len; - for (i=lfld->index+1; i < lfld->valuesnum; i++) { - lfld->values[i-1]->bv_val = lfld->values[i]->bv_val; - lfld->values[i-1]->bv_len = lfld->values[i]->bv_len; + for(i = lfld->index + 1; i < lfld->valuesnum; i++) { + lfld->values[i - 1]->bv_val = + lfld->values[i]->bv_val; + lfld->values[i - 1]->bv_len = + lfld->values[i]->bv_len; } - lfld->values[lfld->valuesnum-1]->bv_val = save_bvval; - lfld->values[lfld->valuesnum-1]->bv_len = save_bvlen; + lfld->values[lfld->valuesnum - 1]->bv_val = + save_bvval; + lfld->values[lfld->valuesnum - 1]->bv_len = + save_bvlen; lfld->valuesnum--; } - - } while (lfld->index < lfld->valuesnum); - - if (lfld->valuesnum == 0) { - return 1; /* get next record */ + + } while(lfld->index < lfld->valuesnum); + + if(lfld->valuesnum == 0) { + return 1; /* get next record */ } } - } + } /* pointer to the current value */ lfld->index = 0; } /* this is an empty value */ - if (!lfld->valuesnum) + if(!lfld->valuesnum) continue; v.s = lfld->values[lfld->index]->bv_val; v.len = lfld->values[lfld->index]->bv_len; - if (ldap_fld2db_fld(fld + i, v) < 0) + if(ldap_fld2db_fld(fld + i, v) < 0) return -1; - } return 0; } -static inline int db_int2ldap_str(struct sbuf* buf, db_fld_t* fld) +static inline int db_int2ldap_str(struct sbuf *buf, db_fld_t *fld) { int len; char tmp[INT2STR_MAX_LEN + 1]; len = snprintf(tmp, INT2STR_MAX_LEN + 1, "%-d", fld->v.int4); - if (len < 0 || len >= INT2STR_MAX_LEN + 1) { + if(len < 0 || len >= INT2STR_MAX_LEN + 1) { BUG("ldap: Error while converting integer to string\n"); return -1; } @@ -763,41 +816,41 @@ static inline int db_int2ldap_str(struct sbuf* buf, db_fld_t* fld) } -static inline int db_datetime2ldap_gentime(struct sbuf* buf, db_fld_t* fld) +static inline int db_datetime2ldap_gentime(struct sbuf *buf, db_fld_t *fld) { char tmp[16]; - struct tm* t; + struct tm *t; t = gmtime(&fld->v.time); - if (strftime(tmp, sizeof(tmp), "%Y%m%d%H%M%SZ", t) != sizeof(tmp)-1) { + if(strftime(tmp, sizeof(tmp), "%Y%m%d%H%M%SZ", t) != sizeof(tmp) - 1) { ERR("ldap: Error while converting time_t value to LDAP format\n"); return -1; } - return sb_add(buf, tmp, sizeof(tmp)-1); + return sb_add(buf, tmp, sizeof(tmp) - 1); } -static inline int db_int2ldap_bool(struct sbuf* buf, db_fld_t* fld) +static inline int db_int2ldap_bool(struct sbuf *buf, db_fld_t *fld) { - if (fld->v.int4) - return sb_add(buf, "TRUE", 4); - else - return sb_add(buf, "FALSE", 5); + if(fld->v.int4) + return sb_add(buf, "TRUE", 4); + else + return sb_add(buf, "FALSE", 5); } -static inline int db_uint2ldap_int(struct sbuf* buf, db_fld_t* fld) +static inline int db_uint2ldap_int(struct sbuf *buf, db_fld_t *fld) { - char* num; + char *num; int len, v; - + v = fld->v.int4; num = int2str(v, &len); return sb_add(buf, num, len); } -static inline int db_bit2ldap_bitstr(struct sbuf* buf, db_fld_t* fld) +static inline int db_bit2ldap_bitstr(struct sbuf *buf, db_fld_t *fld) { int rv, i; @@ -806,7 +859,7 @@ static inline int db_bit2ldap_bitstr(struct sbuf* buf, db_fld_t* fld) i = 1 << (sizeof(fld->v.int4) * 8 - 1); while(i) { - rv |= sb_add(buf, (fld->v.int4 & i)?"1":"0", 1); + rv |= sb_add(buf, (fld->v.int4 & i) ? "1" : "0", 1); i = i >> 1; } rv |= sb_add(buf, "'B", 2); @@ -814,13 +867,13 @@ static inline int db_bit2ldap_bitstr(struct sbuf* buf, db_fld_t* fld) } -static inline int db_float2ldap_str(struct sbuf* buf, db_fld_t* fld) +static inline int db_float2ldap_str(struct sbuf *buf, db_fld_t *fld) { char tmp[16]; int len; len = snprintf(tmp, 16, "%-10.2f", fld->v.flt); - if (len < 0 || len >= 16) { + if(len < 0 || len >= 16) { BUG("ldap: Error while converting float to string\n"); return -1; } @@ -841,164 +894,171 @@ static inline int db_float2ldap_str(struct sbuf* buf, db_fld_t* fld) return sb_add(buf, tmp, len); }*/ -static inline int ld_db2ldap(struct sbuf* buf, db_fld_t* fld) { - struct ld_fld* lfld; - +static inline int ld_db2ldap(struct sbuf *buf, db_fld_t *fld) +{ + struct ld_fld *lfld; + lfld = DB_GET_PAYLOAD(fld); switch(fld->type) { case DB_CSTR: - if (sb_add_esc(buf, fld->v.cstr, - fld->v.cstr ? strlen(fld->v.cstr) : 0) != 0) goto error; + if(sb_add_esc( + buf, fld->v.cstr, fld->v.cstr ? strlen(fld->v.cstr) : 0) + != 0) + goto error; break; case DB_STR: - if (sb_add_esc(buf, fld->v.lstr.s, fld->v.lstr.len) != 0) goto error; + if(sb_add_esc(buf, fld->v.lstr.s, fld->v.lstr.len) != 0) + goto error; break; case DB_INT: switch(lfld->syntax) { - case LD_SYNTAX_STRING: - case LD_SYNTAX_INT: - case LD_SYNTAX_FLOAT: - if (db_int2ldap_str(buf, fld)) - goto error; - break; + case LD_SYNTAX_STRING: + case LD_SYNTAX_INT: + case LD_SYNTAX_FLOAT: + if(db_int2ldap_str(buf, fld)) + goto error; + break; - case LD_SYNTAX_GENTIME: - if (db_datetime2ldap_gentime(buf, fld)) - goto error; - break; + case LD_SYNTAX_GENTIME: + if(db_datetime2ldap_gentime(buf, fld)) + goto error; + break; - case LD_SYNTAX_BIT: - if (db_bit2ldap_bitstr(buf, fld)) - goto error; - break; + case LD_SYNTAX_BIT: + if(db_bit2ldap_bitstr(buf, fld)) + goto error; + break; - case LD_SYNTAX_BOOL: - if (db_int2ldap_bool(buf, fld)) - goto error; - break; + case LD_SYNTAX_BOOL: + if(db_int2ldap_bool(buf, fld)) + goto error; + break; - default: - ERR("ldap: Cannot convert integer field %s " - "to LDAP attribute %.*s\n", - fld->name, lfld->attr.len, ZSW(lfld->attr.s)); - goto error; + default: + ERR("ldap: Cannot convert integer field %s " + "to LDAP attribute %.*s\n", + fld->name, lfld->attr.len, ZSW(lfld->attr.s)); + goto error; } break; case DB_BITMAP: switch(lfld->syntax) { - case LD_SYNTAX_INT: - if (db_uint2ldap_int(buf, fld)) - goto error; - break; + case LD_SYNTAX_INT: + if(db_uint2ldap_int(buf, fld)) + goto error; + break; - case LD_SYNTAX_BIT: - case LD_SYNTAX_STRING: - if (db_bit2ldap_bitstr(buf, fld)) - goto error; - break; + case LD_SYNTAX_BIT: + case LD_SYNTAX_STRING: + if(db_bit2ldap_bitstr(buf, fld)) + goto error; + break; - default: - ERR("ldap: Cannot convert bitmap field %s " - "to LDAP attribute %.*s\n", - fld->name, lfld->attr.len, ZSW(lfld->attr.s)); - goto error; + default: + ERR("ldap: Cannot convert bitmap field %s " + "to LDAP attribute %.*s\n", + fld->name, lfld->attr.len, ZSW(lfld->attr.s)); + goto error; } break; case DB_DATETIME: switch(lfld->syntax) { - case LD_SYNTAX_STRING: - case LD_SYNTAX_GENTIME: - if (db_datetime2ldap_gentime(buf, fld)) - goto error; - break; + case LD_SYNTAX_STRING: + case LD_SYNTAX_GENTIME: + if(db_datetime2ldap_gentime(buf, fld)) + goto error; + break; - case LD_SYNTAX_INT: - if (db_uint2ldap_int(buf, fld)) - goto error; - break; + case LD_SYNTAX_INT: + if(db_uint2ldap_int(buf, fld)) + goto error; + break; - default: - ERR("ldap: Cannot convert datetime field %s " - "to LDAP attribute %.*s\n", - fld->name, lfld->attr.len, ZSW(lfld->attr.s)); - goto error; + default: + ERR("ldap: Cannot convert datetime field %s " + "to LDAP attribute %.*s\n", + fld->name, lfld->attr.len, ZSW(lfld->attr.s)); + goto error; } break; case DB_FLOAT: switch(lfld->syntax) { - case LD_SYNTAX_STRING: - case LD_SYNTAX_FLOAT: - if (db_float2ldap_str(buf, fld)) - goto error; - break; + case LD_SYNTAX_STRING: + case LD_SYNTAX_FLOAT: + if(db_float2ldap_str(buf, fld)) + goto error; + break; - default: - ERR("ldap: Cannot convert float field %s " - "to LDAP attribute %.*s\n", - fld->name, lfld->attr.len, ZSW(lfld->attr.s)); - goto error; + default: + ERR("ldap: Cannot convert float field %s " + "to LDAP attribute %.*s\n", + fld->name, lfld->attr.len, ZSW(lfld->attr.s)); + goto error; } case DB_DOUBLE: switch(lfld->syntax) { - case LD_SYNTAX_STRING: - case LD_SYNTAX_FLOAT: - if (db_float2ldap_str(buf, fld)) - goto error; - break; + case LD_SYNTAX_STRING: + case LD_SYNTAX_FLOAT: + if(db_float2ldap_str(buf, fld)) + goto error; + break; - default: - ERR("ldap: Cannot convert double field %s " - "to LDAP attribute %.*s\n", - fld->name, lfld->attr.len, ZSW(lfld->attr.s)); - goto error; - break; + default: + ERR("ldap: Cannot convert double field %s " + "to LDAP attribute %.*s\n", + fld->name, lfld->attr.len, ZSW(lfld->attr.s)); + goto error; + break; } break; case DB_BLOB: switch(lfld->syntax) { - case LD_SYNTAX_STRING: - case LD_SYNTAX_BIN: - if (sb_add_esc(buf, fld->v.lstr.s, fld->v.lstr.len) < 0) - goto error; - break; + case LD_SYNTAX_STRING: + case LD_SYNTAX_BIN: + if(sb_add_esc(buf, fld->v.lstr.s, fld->v.lstr.len) < 0) + goto error; + break; - default: - ERR("ldap: Cannot convert binary field %s " - "to LDAP attribute %.*s\n", - fld->name, lfld->attr.len, ZSW(lfld->attr.s)); - goto error; + default: + ERR("ldap: Cannot convert binary field %s " + "to LDAP attribute %.*s\n", + fld->name, lfld->attr.len, ZSW(lfld->attr.s)); + goto error; } break; default: BUG("ldap: Unsupported field type encountered: %d\n", fld->type); goto error; - } + } return 0; error: return -1; } /* skip fields belonging to a field which is requested for filtering at client side */ -inline static void skip_client_side_filtering_fields(db_cmd_t* cmd, db_fld_t **fld) { - struct ld_fld* lfld; +inline static void skip_client_side_filtering_fields( + db_cmd_t *cmd, db_fld_t **fld) +{ + struct ld_fld *lfld; db_fld_t *f; try_next: - if (DB_FLD_EMPTY(*fld) || DB_FLD_LAST(**fld)) return; - for (f=cmd->result; !DB_FLD_EMPTY(f) && !DB_FLD_LAST(*f); f++) { + if(DB_FLD_EMPTY(*fld) || DB_FLD_LAST(**fld)) + return; + for(f = cmd->result; !DB_FLD_EMPTY(f) && !DB_FLD_LAST(*f); f++) { lfld = DB_GET_PAYLOAD(f); - if (lfld->client_side_filtering && lfld->filter) { + if(lfld->client_side_filtering && lfld->filter) { int j; - for (j = 0; lfld->filter[j]; j++) { - if (lfld->filter[j] == *fld) { + for(j = 0; lfld->filter[j]; j++) { + if(lfld->filter[j] == *fld) { (*fld)++; goto try_next; } @@ -1006,42 +1066,41 @@ inline static void skip_client_side_filtering_fields(db_cmd_t* cmd, db_fld_t **f } } } - -int ld_prepare_ldap_filter(char** filter, db_cmd_t* cmd, str* add) + +int ld_prepare_ldap_filter(char **filter, db_cmd_t *cmd, str *add) { - db_fld_t* fld; - struct ld_fld* lfld; + db_fld_t *fld; + struct ld_fld *lfld; int rv = 0; - struct sbuf buf = { - .s = NULL, .len = 0, - .size = 0, .increment = 128 - }; + struct sbuf buf = {.s = NULL, .len = 0, .size = 0, .increment = 128}; fld = cmd->match; skip_client_side_filtering_fields(cmd, &fld); - + /* Return NULL if there are no fields and no preconfigured search * string supplied in the configuration file */ - if ((DB_FLD_EMPTY(fld) || DB_FLD_LAST(*fld)) && ((add->s == NULL) || !add->len)) { + if((DB_FLD_EMPTY(fld) || DB_FLD_LAST(*fld)) + && ((add->s == NULL) || !add->len)) { *filter = NULL; return 0; } rv = sb_add(&buf, "(&", 2); - if (add->s && add->len) { + if(add->s && add->len) { /* Add the filter component specified in the config file */ rv |= sb_add(&buf, add->s, add->len); } - for(; !DB_FLD_EMPTY(fld) && !DB_FLD_LAST(*fld); fld++, skip_client_side_filtering_fields(cmd, &fld)) { + for(; !DB_FLD_EMPTY(fld) && !DB_FLD_LAST(*fld); + fld++, skip_client_side_filtering_fields(cmd, &fld)) { int op; lfld = DB_GET_PAYLOAD(fld); op = fld->op; - - if (fld->flags & DB_NULL) { - switch (op) { + + if(fld->flags & DB_NULL) { + switch(op) { case DB_EQ: /* fld==NULL -> (!(x=*)) */ op = DB_NE; @@ -1051,39 +1110,38 @@ int ld_prepare_ldap_filter(char** filter, db_cmd_t* cmd, str* add) op = DB_EQ; break; default: - ERR("ldap: Cannot compare null value field %s\n", fld->name); + ERR("ldap: Cannot compare null value field %s\n", + fld->name); goto error; - } + } } - + /* we need construct operators as: not: (!(fld=val)) : (!(fld=val))(fldval) */ - switch (op) { + switch(op) { case DB_LT: case DB_GT: case DB_NE: rv |= sb_add(&buf, "(!(", 3); rv |= sb_add(&buf, lfld->attr.s, lfld->attr.len); rv |= sb_add(&buf, "=", 1); - if (fld->flags & DB_NULL) { + if(fld->flags & DB_NULL) { rv |= sb_add(&buf, "*", 1); - } - else { - if (ld_db2ldap(&buf, fld) < 0) { + } else { + if(ld_db2ldap(&buf, fld) < 0) { goto error; } } rv |= sb_add(&buf, "))", 2); break; - default: - ; + default:; } - if (op != DB_NE) { + if(op != DB_NE) { rv |= sb_add(&buf, "(", 1); rv |= sb_add(&buf, lfld->attr.s, lfld->attr.len); - switch (op) { + switch(op) { case DB_LEQ: case DB_LT: rv |= sb_add(&buf, "<=", 2); @@ -1095,30 +1153,30 @@ int ld_prepare_ldap_filter(char** filter, db_cmd_t* cmd, str* add) case DB_EQ: rv |= sb_add(&buf, "=", 1); break; - default: - ; + default:; } - if (fld->flags & DB_NULL) { + if(fld->flags & DB_NULL) { rv |= sb_add(&buf, "*", 1); - } - else { - if (ld_db2ldap(&buf, fld) < 0) { + } else { + if(ld_db2ldap(&buf, fld) < 0) { goto error; } } rv |= sb_add(&buf, ")", 1); - } + } } rv |= sb_add(&buf, ")", 1); rv |= sb_add(&buf, "", 1); - if (rv) goto error; + if(rv) + goto error; *filter = buf.s; return 0; error: - if (buf.s) pkg_free(buf.s); + if(buf.s) + pkg_free(buf.s); return -1; } diff --git a/src/modules/db2_ldap/ld_fld.h b/src/modules/db2_ldap/ld_fld.h index 24721cb51c5..066114ea921 100644 --- a/src/modules/db2_ldap/ld_fld.h +++ b/src/modules/db2_ldap/ld_fld.h @@ -44,7 +44,8 @@ struct ld_cfg; #include -enum ld_syntax { +enum ld_syntax +{ LD_SYNTAX_STRING = 0, LD_SYNTAX_GENTIME, LD_SYNTAX_INT, @@ -54,15 +55,17 @@ enum ld_syntax { LD_SYNTAX_FLOAT }; -struct ld_fld { +struct ld_fld +{ db_drv_t gen; - str attr; /**< Name of corresponding LDAP attribute */ - enum ld_syntax syntax; /**< LDAP attribute syntax */ - struct berval** values; /**< Values retrieved from the LDAP result */ + str attr; /**< Name of corresponding LDAP attribute */ + enum ld_syntax syntax; /**< LDAP attribute syntax */ + struct berval **values; /**< Values retrieved from the LDAP result */ unsigned int valuesnum; unsigned int index; - db_fld_t** filter; /**< filter applied on the field pointing to db_cmd_t.match[] */ - int client_side_filtering; /**< do not pass filter to LDAP server but filter result set */ + db_fld_t ** + filter; /**< filter applied on the field pointing to db_cmd_t.match[] */ + int client_side_filtering; /**< do not pass filter to LDAP server but filter result set */ }; @@ -74,20 +77,20 @@ struct ld_fld { * @retval 0 on success. * @retval A negative number on error. */ -int ld_fld(db_fld_t* fld, char* table); +int ld_fld(db_fld_t *fld, char *table); -int ld_resolve_fld(db_fld_t* fld, struct ld_cfg* cfg); +int ld_resolve_fld(db_fld_t *fld, struct ld_cfg *cfg); -int ld_prepare_ldap_filter(char** filter, db_cmd_t* cmd, str* add); +int ld_prepare_ldap_filter(char **filter, db_cmd_t *cmd, str *add); -int ld_incindex(db_fld_t* fld); +int ld_incindex(db_fld_t *fld); -int ld_ldap2fldinit(db_fld_t* fld, LDAP* ldap, LDAPMessage* msg); +int ld_ldap2fldinit(db_fld_t *fld, LDAP *ldap, LDAPMessage *msg); -int ld_ldap2fld(db_fld_t* fld, LDAP* ldap, LDAPMessage* msg); +int ld_ldap2fld(db_fld_t *fld, LDAP *ldap, LDAPMessage *msg); -int ld_ldap2fldex(db_fld_t* fld, LDAP* ldap, LDAPMessage* msg, int init); +int ld_ldap2fldex(db_fld_t *fld, LDAP *ldap, LDAPMessage *msg, int init); /** @} */ diff --git a/src/modules/db2_ldap/ld_res.c b/src/modules/db2_ldap/ld_res.c index deb04b5d1fc..a8cef3b6a32 100644 --- a/src/modules/db2_ldap/ld_res.c +++ b/src/modules/db2_ldap/ld_res.c @@ -40,31 +40,33 @@ #include "../../lib/srdb2/db_gen.h" -static void ld_res_free(db_res_t* res, struct ld_res* payload) +static void ld_res_free(db_res_t *res, struct ld_res *payload) { db_drv_free(&payload->gen); - if (payload->msg) ldap_msgfree(payload->msg); + if(payload->msg) + ldap_msgfree(payload->msg); payload->msg = NULL; pkg_free(payload); } -int ld_res(db_res_t* res) +int ld_res(db_res_t *res) { - struct ld_res* lres; + struct ld_res *lres; - lres = (struct ld_res*)pkg_malloc(sizeof(struct ld_res)); - if (lres == NULL) { + lres = (struct ld_res *)pkg_malloc(sizeof(struct ld_res)); + if(lres == NULL) { ERR("ldap: No memory left\n"); return -1; } memset(lres, '\0', sizeof(struct ld_res)); - if (db_drv_init(&lres->gen, ld_res_free) < 0) goto error; + if(db_drv_init(&lres->gen, ld_res_free) < 0) + goto error; DB_SET_PAYLOAD(res, lres); return 0; - - error: - if (lres) { + +error: + if(lres) { db_drv_free(&lres->gen); pkg_free(lres); } diff --git a/src/modules/db2_ldap/ld_res.h b/src/modules/db2_ldap/ld_res.h index 1c322e131f1..318fd91120f 100644 --- a/src/modules/db2_ldap/ld_res.h +++ b/src/modules/db2_ldap/ld_res.h @@ -39,13 +39,14 @@ #include -struct ld_res { +struct ld_res +{ db_drv_t gen; - LDAPMessage* msg; - LDAPMessage* current; + LDAPMessage *msg; + LDAPMessage *current; }; -int ld_res(db_res_t* res); +int ld_res(db_res_t *res); /** @} */ diff --git a/src/modules/db2_ldap/ld_uri.c b/src/modules/db2_ldap/ld_uri.c index e155d587674..1196491cf8a 100644 --- a/src/modules/db2_ldap/ld_uri.c +++ b/src/modules/db2_ldap/ld_uri.c @@ -43,7 +43,7 @@ * return 0 if match, 1 if not */ #define cmpstr(s1, s2, f) \ - ((s1)!=(s2)) && ((s1)==0 || (s2)==0 || (f)((s1), (s2))!=0) + ((s1) != (s2)) && ((s1) == 0 || (s2) == 0 || (f)((s1), (s2)) != 0) /** Compares two LDAP connection URIs. @@ -54,30 +54,32 @@ * by the connection pool to determine if a connection to a given * server already exists. **/ -static unsigned char ld_uri_cmp(db_uri_t* uri1, db_uri_t* uri2) +static unsigned char ld_uri_cmp(db_uri_t *uri1, db_uri_t *uri2) { - struct ld_uri* luri1, *luri2; + struct ld_uri *luri1, *luri2; - if (!uri1 || !uri2) return 0; + if(!uri1 || !uri2) + return 0; luri1 = DB_GET_PAYLOAD(uri1); luri2 = DB_GET_PAYLOAD(uri2); - if (luri1->ldap_url->lud_port != luri2->ldap_url->lud_port) return 0; - if (cmpstr(luri1->ldap_url->lud_host, - luri2->ldap_url->lud_host, strcasecmp)) + if(luri1->ldap_url->lud_port != luri2->ldap_url->lud_port) + return 0; + if(cmpstr(luri1->ldap_url->lud_host, luri2->ldap_url->lud_host, strcasecmp)) return 0; return 1; } /** Duplicate a string */ -static int dupl_string(char** dst, const char* begin, const char* end) +static int dupl_string(char **dst, const char *begin, const char *end) { - if (*dst) pkg_free(*dst); + if(*dst) + pkg_free(*dst); *dst = pkg_malloc(end - begin + 1); - if ((*dst) == NULL) { + if((*dst) == NULL) { return -1; } @@ -88,15 +90,15 @@ static int dupl_string(char** dst, const char* begin, const char* end) /** Duplicate a string */ -static char* pkgstrdup(str* s) +static char *pkgstrdup(str *s) { - char* dst; + char *dst; - if (!s) + if(!s) return NULL; dst = pkg_malloc(s->len + 1); - if (dst == NULL) + if(dst == NULL) return NULL; memcpy(dst, s->s, s->len); @@ -112,35 +114,36 @@ static char* pkgstrdup(str* s) * * Returns 0 if parsing was successful and -1 otherwise */ -int parse_ldap_uri(struct ld_uri* res, str* scheme, str* uri) +int parse_ldap_uri(struct ld_uri *res, str *scheme, str *uri) { #define SHORTEST_DB_URL "a" #define SHORTEST_DB_URL_LEN (sizeof(SHORTEST_DB_URL) - 1) - enum state { - ST_BEGIN, /* First state */ - ST_SECTION_ID, /* Config section id */ - ST_SLASH2, /* Second slash */ + enum state + { + ST_BEGIN, /* First state */ + ST_SECTION_ID, /* Config section id */ + ST_SLASH2, /* Second slash */ ST_USER_HOST, /* Username or hostname */ ST_PASS_PORT, /* Password or port part */ ST_HOST_PORT /* Hostname and port part */ }; enum state st; - int i, ldapurllen; - const char* begin; - const char* ldapbegin; - char* prev_token; - struct ld_con_info* cfg_conn_info; - char* sport, *puri; + int i, ldapurllen; + const char *begin; + const char *ldapbegin; + char *prev_token; + struct ld_con_info *cfg_conn_info; + char *sport, *puri; int portlen = 0; prev_token = 0; - if (!res || !scheme || !uri) { + if(!res || !scheme || !uri) { goto err; } - if (uri->len < SHORTEST_DB_URL_LEN) { + if(uri->len < SHORTEST_DB_URL_LEN) { goto err; } @@ -149,220 +152,237 @@ int parse_ldap_uri(struct ld_uri* res, str* scheme, str* uri) for(i = 0; i < uri->len && st != ST_SECTION_ID; i++) { switch(st) { - case ST_BEGIN: - switch(uri->s[i]) { - case '/': - st = ST_SLASH2; + case ST_BEGIN: + switch(uri->s[i]) { + case '/': + st = ST_SLASH2; + break; + + default: + st = ST_SECTION_ID; + } break; - default: - st = ST_SECTION_ID; - } - break; - - case ST_SECTION_ID: - break; - - case ST_SLASH2: - switch(uri->s[i]) { - case '/': - st = ST_USER_HOST; - ldapbegin = begin = uri->s + i + 1; + case ST_SECTION_ID: break; - default: - goto err; - } - break; + case ST_SLASH2: + switch(uri->s[i]) { + case '/': + st = ST_USER_HOST; + ldapbegin = begin = uri->s + i + 1; + break; - case ST_USER_HOST: - switch(uri->s[i]) { - case '@': - st = ST_HOST_PORT; - if (dupl_string(&res->username, begin, uri->s + i) < 0) goto err; - ldapbegin = begin = uri->s + i + 1; + default: + goto err; + } break; - case ':': - st = ST_PASS_PORT; - if (dupl_string(&prev_token, begin, uri->s + i) < 0) goto err; - begin = uri->s + i + 1; + case ST_USER_HOST: + switch(uri->s[i]) { + case '@': + st = ST_HOST_PORT; + if(dupl_string(&res->username, begin, uri->s + i) < 0) + goto err; + ldapbegin = begin = uri->s + i + 1; + break; + + case ':': + st = ST_PASS_PORT; + if(dupl_string(&prev_token, begin, uri->s + i) < 0) + goto err; + begin = uri->s + i + 1; + break; + } break; - } - break; - case ST_PASS_PORT: - switch(uri->s[i]) { - case '@': - st = ST_HOST_PORT; - res->username = prev_token; - if (dupl_string(&res->password, begin, uri->s + i) < 0) goto err; - ldapbegin = begin = uri->s + i + 1; + case ST_PASS_PORT: + switch(uri->s[i]) { + case '@': + st = ST_HOST_PORT; + res->username = prev_token; + if(dupl_string(&res->password, begin, uri->s + i) < 0) + goto err; + ldapbegin = begin = uri->s + i + 1; + break; + } break; - } - break; - case ST_HOST_PORT: - break; + case ST_HOST_PORT: + break; } } switch(st) { - case ST_PASS_PORT: - case ST_USER_HOST: - case ST_HOST_PORT: - ldapurllen = uri->len - (int)(ldapbegin - uri->s); - // +3 for the '://' ldap url snippet - res->uri = pkg_malloc(scheme->len + 3 + ldapurllen + 1); - if (res->uri== NULL) { - ERR("ldap: No memory left\n"); - goto err; - } - memcpy(res->uri, scheme->s, scheme->len); - res->uri[scheme->len] = ':'; - res->uri[scheme->len + 1] = '/'; - res->uri[scheme->len + 2] = '/'; - memcpy(res->uri + scheme->len + 3, ldapbegin, ldapurllen); - res->uri[scheme->len + 3 + ldapurllen] = '\0'; - - if (ldap_url_parse(res->uri, &res->ldap_url) != 0) { - ERR("ldap: Error while parsing URL '%s'\n", res->uri); - goto err; - } - break; - case ST_SECTION_ID: - /* the value of uri is the id of the config + case ST_PASS_PORT: + case ST_USER_HOST: + case ST_HOST_PORT: + ldapurllen = uri->len - (int)(ldapbegin - uri->s); + // +3 for the '://' ldap url snippet + res->uri = pkg_malloc(scheme->len + 3 + ldapurllen + 1); + if(res->uri == NULL) { + ERR("ldap: No memory left\n"); + goto err; + } + memcpy(res->uri, scheme->s, scheme->len); + res->uri[scheme->len] = ':'; + res->uri[scheme->len + 1] = '/'; + res->uri[scheme->len + 2] = '/'; + memcpy(res->uri + scheme->len + 3, ldapbegin, ldapurllen); + res->uri[scheme->len + 3 + ldapurllen] = '\0'; + + if(ldap_url_parse(res->uri, &res->ldap_url) != 0) { + ERR("ldap: Error while parsing URL '%s'\n", res->uri); + goto err; + } + break; + case ST_SECTION_ID: + /* the value of uri is the id of the config connection section in this case */ - cfg_conn_info = ld_find_conn_info(uri); - if (!cfg_conn_info) { - ERR("ldap: connection id '%.*s' not found in ldap config\n", uri->len, uri->s); - goto err; - } - - ldapurllen = cfg_conn_info->host.len; - sport = NULL; - if (cfg_conn_info->port) { - sport = int2str(cfg_conn_info->port, &portlen); - // +1: we need space for ':' host and port delimiter - ldapurllen += portlen + 1; - } - - // +3 for the '://' ldap url snippet - puri = res->uri = pkg_malloc(scheme->len + 3 + ldapurllen + 1); - if (res->uri== NULL) { - ERR("ldap: No memory left\n"); - goto err; - } - memcpy(puri, scheme->s, scheme->len); - puri += scheme->len; - memcpy(puri, "://", strlen("://")); - puri+= strlen("://"); - memcpy(puri, cfg_conn_info->host.s, cfg_conn_info->host.len); - puri+=cfg_conn_info->host.len; - if (sport) { - *puri++ = ':'; - memcpy(puri, sport, portlen); - } - res->uri[scheme->len + 3 + ldapurllen] = '\0'; + cfg_conn_info = ld_find_conn_info(uri); + if(!cfg_conn_info) { + ERR("ldap: connection id '%.*s' not found in ldap config\n", + uri->len, uri->s); + goto err; + } - if (ldap_url_parse(res->uri, &res->ldap_url) != 0) { - ERR("ldap: Error while parsing URL '%s'\n", res->uri); - goto err; - } + ldapurllen = cfg_conn_info->host.len; + sport = NULL; + if(cfg_conn_info->port) { + sport = int2str(cfg_conn_info->port, &portlen); + // +1: we need space for ':' host and port delimiter + ldapurllen += portlen + 1; + } - if (cfg_conn_info->username.s) { - if (!(res->username = pkgstrdup(&cfg_conn_info->username))) { + // +3 for the '://' ldap url snippet + puri = res->uri = pkg_malloc(scheme->len + 3 + ldapurllen + 1); + if(res->uri == NULL) { ERR("ldap: No memory left\n"); goto err; } - } + memcpy(puri, scheme->s, scheme->len); + puri += scheme->len; + memcpy(puri, "://", strlen("://")); + puri += strlen("://"); + memcpy(puri, cfg_conn_info->host.s, cfg_conn_info->host.len); + puri += cfg_conn_info->host.len; + if(sport) { + *puri++ = ':'; + memcpy(puri, sport, portlen); + } + res->uri[scheme->len + 3 + ldapurllen] = '\0'; - if (cfg_conn_info->password.s) { - if (!(res->password = pkgstrdup(&cfg_conn_info->password))) { - ERR("ldap: No memory left\n"); + if(ldap_url_parse(res->uri, &res->ldap_url) != 0) { + ERR("ldap: Error while parsing URL '%s'\n", res->uri); goto err; } - } - res->authmech = cfg_conn_info->authmech; - res->tls = cfg_conn_info->tls; - if (cfg_conn_info->ca_list.s) { - if (!(res->ca_list = pkgstrdup(&cfg_conn_info->ca_list))) { + if(cfg_conn_info->username.s) { + if(!(res->username = pkgstrdup(&cfg_conn_info->username))) { ERR("ldap: No memory left\n"); goto err; + } } - } - if (cfg_conn_info->req_cert.s) { - if (!(res->req_cert = pkgstrdup(&cfg_conn_info->req_cert))) { + + if(cfg_conn_info->password.s) { + if(!(res->password = pkgstrdup(&cfg_conn_info->password))) { ERR("ldap: No memory left\n"); goto err; + } } - } - break; - default: - goto err; + res->authmech = cfg_conn_info->authmech; + res->tls = cfg_conn_info->tls; + if(cfg_conn_info->ca_list.s) { + if(!(res->ca_list = pkgstrdup(&cfg_conn_info->ca_list))) { + ERR("ldap: No memory left\n"); + goto err; + } + } + if(cfg_conn_info->req_cert.s) { + if(!(res->req_cert = pkgstrdup(&cfg_conn_info->req_cert))) { + ERR("ldap: No memory left\n"); + goto err; + } + } + + break; + default: + goto err; } return 0; - err: - if (prev_token) pkg_free(prev_token); - if (res == NULL) return -1; - if (res->username) { +err: + if(prev_token) + pkg_free(prev_token); + if(res == NULL) + return -1; + if(res->username) { pkg_free(res->username); res->username = NULL; } - if (res->password) { + if(res->password) { pkg_free(res->password); res->password = NULL; } - if (res->ca_list) { + if(res->ca_list) { pkg_free(res->ca_list); res->ca_list = NULL; } - if (res->req_cert) { + if(res->req_cert) { pkg_free(res->req_cert); res->req_cert = NULL; } return -1; } -static void ld_uri_free(db_uri_t* uri, struct ld_uri* payload) +static void ld_uri_free(db_uri_t *uri, struct ld_uri *payload) { - if (payload == NULL) return; - if (payload->ldap_url) ldap_free_urldesc(payload->ldap_url); - if (payload->uri) pkg_free(payload->uri); - if (payload->username) pkg_free(payload->username); - if (payload->password) pkg_free(payload->password); - if (payload->ca_list) pkg_free(payload->ca_list); - if (payload->req_cert) pkg_free(payload->req_cert); + if(payload == NULL) + return; + if(payload->ldap_url) + ldap_free_urldesc(payload->ldap_url); + if(payload->uri) + pkg_free(payload->uri); + if(payload->username) + pkg_free(payload->username); + if(payload->password) + pkg_free(payload->password); + if(payload->ca_list) + pkg_free(payload->ca_list); + if(payload->req_cert) + pkg_free(payload->req_cert); db_drv_free(&payload->drv); pkg_free(payload); } -int ld_uri(db_uri_t* uri) +int ld_uri(db_uri_t *uri) { - struct ld_uri* luri; + struct ld_uri *luri; - luri = (struct ld_uri*)pkg_malloc(sizeof(struct ld_uri)); - if (luri == NULL) { + luri = (struct ld_uri *)pkg_malloc(sizeof(struct ld_uri)); + if(luri == NULL) { ERR("ldap: No memory left\n"); goto error; } memset(luri, '\0', sizeof(struct ld_uri)); - if (db_drv_init(&luri->drv, ld_uri_free) < 0) goto error; - if (parse_ldap_uri(luri, &uri->scheme, &uri->body) < 0) goto error; + if(db_drv_init(&luri->drv, ld_uri_free) < 0) + goto error; + if(parse_ldap_uri(luri, &uri->scheme, &uri->body) < 0) + goto error; DB_SET_PAYLOAD(uri, luri); uri->cmp = ld_uri_cmp; return 0; - error: - if (luri) { - if (luri->uri) pkg_free(luri->uri); - if (luri->ldap_url) ldap_free_urldesc(luri->ldap_url); +error: + if(luri) { + if(luri->uri) + pkg_free(luri->uri); + if(luri->ldap_url) + ldap_free_urldesc(luri->ldap_url); db_drv_free(&luri->drv); pkg_free(luri); } diff --git a/src/modules/db2_ldap/ld_uri.h b/src/modules/db2_ldap/ld_uri.h index 8b99c74246b..fcbaaa159fb 100644 --- a/src/modules/db2_ldap/ld_uri.h +++ b/src/modules/db2_ldap/ld_uri.h @@ -38,7 +38,8 @@ #include -enum auth_type { +enum auth_type +{ LDAP_AUTHMECH_NONE = 0, LDAP_AUTHMECH_SIMPLE, LDAP_AUTHMECH_DIGESTMD5, @@ -49,22 +50,22 @@ enum auth_type { #define LDAP_MECHANISM_STR_EXTERNAL "external" - /** LDAP driver specific payload to attach to db_uri structures. * This is the LDAP specific structure that will be attached * to generic db_uri structures in the database API in SER. The * structure contains parsed elements of the ldap: URI. */ -struct ld_uri { +struct ld_uri +{ db_drv_t drv; - char* username; - char* password; - char* uri; /**< The whole URI, including scheme */ + char *username; + char *password; + char *uri; /**< The whole URI, including scheme */ int authmech; - int tls; /**< TLS encryption enabled */ - char* ca_list; /**< Path of the file that contains certificates of the CAs */ - char* req_cert; /**< LDAP level of certificate request behaviour */ - LDAPURLDesc* ldap_url; /**< URI parsed by the ldap client library */ + int tls; /**< TLS encryption enabled */ + char *ca_list; /**< Path of the file that contains certificates of the CAs */ + char *req_cert; /**< LDAP level of certificate request behaviour */ + LDAPURLDesc *ldap_url; /**< URI parsed by the ldap client library */ }; @@ -75,7 +76,7 @@ struct ld_uri { * @retval 0 on success * @retval A negative number on error. */ -int ld_uri(db_uri_t* uri); +int ld_uri(db_uri_t *uri); /** @} */