389-ds-base/lib/ldaputil/dbconf.c

/** BEGIN COPYRIGHT BLOCK
 * Copyright (C) 2001 Sun Microsystems, Inc. Used by permission.
 * Copyright (C) 2005 Red Hat, Inc.
 * All rights reserved.
 *
 * License: GPL (version 3 or any later version).
 * See LICENSE for details.
 * END COPYRIGHT BLOCK **/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif


#include <string.h>
/* This was malloc.h - but it's moved to stdlib.h on most platforms, and FBSD is strict */
/* Make it stdlib.h, and revert to malloc.h with ifdefs if we have issues here. WB 2016 */
#include <stdlib.h>
#include <ctype.h>

#include <ldaputil/errors.h>
#include <ldaputil/certmap.h>
#include <ldaputil/encode.h>
#include <ldaputil/dbconf.h>

#define BIG_LINE 1024

static const char *DB_DIRECTIVE = "directory";
static const int DB_DIRECTIVE_LEN = 9; /* strlen("DB_DIRECTIVE") */

static const char *ENCODED = "encoded";

static void
insert_dbinfo_propval(DBConfDBInfo_t *db_info,
                      DBPropVal_t *propval)
{
    if (db_info->lastprop) {
        db_info->lastprop->next = propval;
    } else {
        db_info->firstprop = propval;
    }

    db_info->lastprop = propval;
}

static void
insert_dbconf_dbinfo(DBConfInfo_t *conf_info,
                     DBConfDBInfo_t *db_info)
{
    if (conf_info->lastdb) {
        conf_info->lastdb->next = db_info;
    } else {
        conf_info->firstdb = db_info;
    }

    conf_info->lastdb = db_info;
}

void
dbconf_free_propval(DBPropVal_t *propval)
{
    if (propval) {
        if (propval->prop)
            free(propval->prop);
        if (propval->val)
            free(propval->val);
        memset((void *)propval, 0, sizeof(DBPropVal_t));
        free(propval);
    }
}

NSAPI_PUBLIC void
dbconf_free_dbinfo(DBConfDBInfo_t *db_info)
{
    if (db_info) {
        DBPropVal_t *next;
        DBPropVal_t *cur;

        if (db_info->dbname)
            free(db_info->dbname);
        if (db_info->url)
            free(db_info->url);

        cur = db_info->firstprop;

        while (cur) {
            next = cur->next;
            dbconf_free_propval(cur);
            cur = next;
        }

        memset((void *)db_info, 0, sizeof(DBConfDBInfo_t));
        free(db_info);
    }
}

NSAPI_PUBLIC void
dbconf_free_confinfo(DBConfInfo_t *conf_info)
{
    DBConfDBInfo_t *next;
    DBConfDBInfo_t *cur;

    if (conf_info) {
        cur = conf_info->firstdb;

        while (cur) {
            next = cur->next;
            dbconf_free_dbinfo(cur);
            cur = next;
        }

        memset((void *)conf_info, 0, sizeof(DBConfInfo_t));
        free(conf_info);
    }
}

static int
skip_blank_lines_and_spaces(FILE *fp, char *buf, char **ptr_out, int *eof)
{
    char *ptr = buf;
    char *end;

    while (buf && (*buf || fgets(buf, BIG_LINE, fp))) {
        ptr = buf;

        /* skip leading whitespace */
        while (*ptr && isspace(*ptr))
            ++ptr;

        /* skip blank line or comment */
        if (!*ptr || *ptr == '#') {
            *buf = 0; /* to force reading of next line */
            continue;
        }

        /* Non-blank line found */
        break;
    }

    *ptr_out = ptr;
    if (!*ptr) {
        *eof = 1;
    } else {
        /* skip trailing whitespace */
        end = ptr + strlen(ptr) - 1;
        while (isspace(*end))
            *end-- = 0;
    }

    return LDAPU_SUCCESS;
}

static int
dbconf_parse_propval(char *buf, char *ptr, DBConfDBInfo_t *db_info)
{
    char *dbname = db_info->dbname;
    int dbname_len = strlen(dbname);
    char *prop;
    char *val;
    DBPropVal_t *propval;
    char *delimeter_chars = " \t";
    char *lastchar;
    int end_of_prop;
    char *encval = 0; /* encoded value */
    char *origprop = 0;

    if ((ptr - buf + dbname_len > BIG_LINE) ||
        strncmp(ptr, dbname, dbname_len) ||
        !(ptr[dbname_len] == ':' || isspace(ptr[dbname_len]))) {
        /* Not a prop-val for the current db but not an error */
        return LDAPU_ERR_NOT_PROPVAL;
    }

    /* remove the last char if it is newline */
    lastchar = strrchr(buf, '\n');
    if (lastchar)
        *lastchar = '\0';

    prop = ptr + dbname_len + 1;

    while (*prop && (isspace(*prop) || *prop == ':'))
        ++prop;

    if (!*prop) {
        return LDAPU_ERR_PROP_IS_MISSING;
    }

    end_of_prop = strcspn(prop, delimeter_chars);

    if (prop[end_of_prop] != '\0') {
        /* buf doesn't end here -- val is present */
        prop[end_of_prop] = '\0';
        val = &prop[end_of_prop + 1];

        while (*val && isspace(*val))
            ++val;
        if (*val == '\0')
            val = 0;
    } else {
        val = 0;
    }

    /*
     * The prop-val line could be one of the following:
     * "<dbname>:prop val" OR "<dbname>:encoded prop encval"
     * If (prop == "encoded") then the val has "prop encval".
     * Get the actual prop from val and get encval (i.e. encoded value)
     * and decode it.  If it is encoded then the val part must be non-NULL.
     */
    if (val && *val && !strcmp(prop, ENCODED)) {
        /* val has the actual prop followed by the encoded value */
        origprop = prop;
        prop = val;
        while (*prop && (isspace(*prop) || *prop == ':'))
            ++prop;

        if (!*prop) {
            return LDAPU_ERR_PROP_IS_MISSING;
        }

        end_of_prop = strcspn(prop, delimeter_chars);

        if (prop[end_of_prop] != '\0') {
            /* buf doesn't end here -- encval is present */
            prop[end_of_prop] = '\0';
            encval = &prop[end_of_prop + 1];

            while (*encval && isspace(*encval))
                ++encval;
            if (*encval == '\0')
                encval = 0;
        } else {
            encval = 0;
        }

        if (!encval) {
            /* special case - if encval is null, "encoded" itself is a
         * property and what we have in prop now is the value. */
            val = prop;
            prop = origprop;
        } else {
            /* decode the value */
            val = dbconf_decodeval(encval);
        }
    }

    /* Success - we have prop & val */
    propval = (DBPropVal_t *)malloc(sizeof(DBPropVal_t));

    if (!propval) {
        if (encval && val)
            free(val);
        return LDAPU_ERR_OUT_OF_MEMORY;
    }
    memset((void *)propval, 0, sizeof(DBPropVal_t));
    propval->prop = strdup(prop);
    propval->val = val ? strdup(val) : 0;

    if (encval && val)
        free(val); /* val was allocated by dbconf_decodeval */

    if (!propval->prop || (val && !propval->val)) {
        dbconf_free_propval(propval);
        return LDAPU_ERR_OUT_OF_MEMORY;
    }

    insert_dbinfo_propval(db_info, propval);
    return LDAPU_SUCCESS;
}

static int
dbconf_read_propval(FILE *fp, char *buf, DBConfDBInfo_t *db_info, int *eof)
{
    int rv;
    char *ptr = buf;

    while (buf && (*buf || fgets(buf, BIG_LINE, fp))) {
        ptr = buf;

        rv = skip_blank_lines_and_spaces(fp, buf, &ptr, eof);

        if (rv != LDAPU_SUCCESS || *eof)
            return rv;

        /* We have a non-blank line which could be prop-val pair for the
     * dbname in the db_info. parse the prop-val pair and continue.
     */
        rv = dbconf_parse_propval(buf, ptr, db_info);

        if (rv == LDAPU_ERR_NOT_PROPVAL)
            return LDAPU_SUCCESS;
        if (rv != LDAPU_SUCCESS)
            return rv;

        *buf = 0; /* to force reading of next line */
    }

    if (!*buf)
        *eof = 1;

    return LDAPU_SUCCESS;
}

static int
parse_directive(char *buf, const char *directive, const int directive_len, DBConfDBInfo_t **db_info_out)
{
    DBConfDBInfo_t *db_info;
    char *dbname;
    char *url;
    int end_of_dbname;
    char *delimeter_chars = " \t";
    char *lastchar;

    /* remove the last char if it is newline */
    lastchar = strrchr(buf, '\n');
    if (lastchar)
        *lastchar = '\0';

    if (strncmp(buf, directive, directive_len) ||
        !isspace(buf[directive_len])) {
        return LDAPU_ERR_DIRECTIVE_IS_MISSING;
    }

    dbname = buf + directive_len + 1;

    while (*dbname && isspace(*dbname))
        ++dbname;

    if (!*dbname) {
        return LDAPU_ERR_DBNAME_IS_MISSING;
    }

    end_of_dbname = strcspn(dbname, delimeter_chars);

    if (dbname[end_of_dbname] != '\0') {
        /* buf doesn't end here -- url is present */
        dbname[end_of_dbname] = '\0';
        url = &dbname[end_of_dbname + 1];

        while (*url && isspace(*url))
            ++url;

        if (*url == '\0')
            url = 0;
    } else {
        url = 0;
    }

    /* Success - we have dbname & url */
    db_info = (DBConfDBInfo_t *)malloc(sizeof(DBConfDBInfo_t));

    if (!db_info)
        return LDAPU_ERR_OUT_OF_MEMORY;
    memset((void *)db_info, 0, sizeof(DBConfDBInfo_t));
    db_info->dbname = strdup(dbname);
    db_info->url = url ? strdup(url) : 0;

    if (!db_info->dbname || (url && !db_info->url)) {
        dbconf_free_dbinfo(db_info);
        return LDAPU_ERR_OUT_OF_MEMORY;
    }

    *db_info_out = db_info;
    return LDAPU_SUCCESS;
}

/* Read the next database info from the file and put it in db_info_out.  The
 * buf may contain first line of the database info.  When this function
 * finishes, the buf may contain unprocessed information (which should be
 * passed to the next call to read_db_info).
 */
static int
read_db_info(FILE *fp, char *buf, DBConfDBInfo_t **db_info_out, const char *directive, const int directive_len, int *eof)
{
    char *ptr;
    DBConfDBInfo_t *db_info;
    int rv;

    *db_info_out = 0;

    rv = skip_blank_lines_and_spaces(fp, buf, &ptr, eof);

    if (rv != LDAPU_SUCCESS || *eof)
        return rv;

    /* We possibly have a directive of the form "directory <name> <url>" */
    rv = parse_directive(ptr, directive, directive_len, &db_info);
    if (rv != LDAPU_SUCCESS)
        return rv;

    /* We have parsed the directive successfully -- lets look for additional
     * property-value pairs for the database.
     */
    if (!fgets(buf, BIG_LINE, fp)) {
        *eof = 1;
        rv = LDAPU_SUCCESS;
    } else {
        rv = dbconf_read_propval(fp, buf, db_info, eof);
    }

    if (rv != LDAPU_SUCCESS) {
        dbconf_free_dbinfo(db_info);
        *db_info_out = 0;
    } else {
        *db_info_out = db_info;
    }

    return rv;
}

int
dbconf_read_config_file_sub(const char *file,
                            const char *directive,
                            const int directive_len,
                            DBConfInfo_t **conf_info_out)
{
    FILE *fp;
    DBConfInfo_t *conf_info;
    DBConfDBInfo_t *db_info;
    char buf[BIG_LINE];
    int rv;
    int eof;

    buf[0] = 0;

    if ((fp = fopen(file, "r")) == NULL) {
        return LDAPU_ERR_CANNOT_OPEN_FILE;
    }

    /* Allocate DBConfInfo_t */
    conf_info = (DBConfInfo_t *)malloc(sizeof(DBConfInfo_t));

    if (!conf_info) {
        fclose(fp);
        return LDAPU_ERR_OUT_OF_MEMORY;
    }

    memset((void *)conf_info, 0, sizeof(DBConfInfo_t));

    /* Read each db info */
    eof = 0;
    while (!eof &&
           ((rv = read_db_info(fp, buf, &db_info, directive, directive_len, &eof)) == LDAPU_SUCCESS)) {
        insert_dbconf_dbinfo(conf_info, db_info);
    }

    if (rv != LDAPU_SUCCESS) {
        dbconf_free_confinfo(conf_info);
        *conf_info_out = 0;
    } else {
        *conf_info_out = conf_info;
    }

    fclose(fp);
    return rv;
}

NSAPI_PUBLIC int
dbconf_read_config_file(const char *file, DBConfInfo_t **conf_info_out)
{
    return dbconf_read_config_file_sub(file, DB_DIRECTIVE, DB_DIRECTIVE_LEN,
                                       conf_info_out);
}

int
dbconf_read_default_dbinfo_sub(const char *file,
                               const char *directive,
                               const int directive_len,
                               DBConfDBInfo_t **db_info_out)
{
    FILE *fp;
    DBConfDBInfo_t *db_info;
    char buf[BIG_LINE];
    int rv;
    int eof;

    buf[0] = 0;

    if ((fp = fopen(file, "r")) == NULL) {
        return LDAPU_ERR_CANNOT_OPEN_FILE;
    }

    /* Read each db info until eof or dbname == default*/
    eof = 0;

    while (!eof &&
           ((rv = read_db_info(fp, buf, &db_info, directive, directive_len, &eof)) == LDAPU_SUCCESS)) {
        if (!strcmp(db_info->dbname, DBCONF_DEFAULT_DBNAME))
            break;
        dbconf_free_dbinfo(db_info);
        db_info = NULL;
    }

    if (rv != LDAPU_SUCCESS) {
        *db_info_out = 0;
    } else {
        *db_info_out = db_info;
    }

    fclose(fp);
    return rv;
}


NSAPI_PUBLIC int
dbconf_read_default_dbinfo(const char *file,
                           DBConfDBInfo_t **db_info_out)
{
    return dbconf_read_default_dbinfo_sub(file, DB_DIRECTIVE, DB_DIRECTIVE_LEN,
                                          db_info_out);
}

/*
 * ldapu_strcasecmp - is like strcasecmp on UNIX but also accepts null strings.
 */
int
ldapu_strcasecmp(const char *s1, const char *s2)
{

    if (!s1)
        return !s2 ? 0 : 0 - tolower(*s2);
    else if (!s2)
        return tolower(*s1);

    return strcasecmp(s1, s2);
}

NSAPI_PUBLIC int
ldapu_dbinfo_attrval(DBConfDBInfo_t *db_info,
                     const char *attr,
                     char **val)
{
    /* Look for given attr in the db_info and return its value */
    int rv = LDAPU_ATTR_NOT_FOUND;
    DBPropVal_t *next;

    *val = 0;

    if (db_info) {
        next = db_info->firstprop;
        while (next) {
            rv = ldapu_strcasecmp(attr, next->prop);
            if (!rv) {
                /* Found the property */
                *val = next->val ? strdup(next->val) : 0;

                if (next->val && !*val) {
                    rv = LDAPU_ERR_OUT_OF_MEMORY;
                } else {
                    rv = LDAPU_SUCCESS;
                }
                break;
            }
            next = next->next;
        }
    }

    return rv;
}

void
dbconf_print_propval(DBPropVal_t *propval)
{
    if (propval) {
        fprintf(stderr, "\tprop: \"%s\"\tval: \"%s\"\n", propval->prop,
                propval->val ? propval->val : "");
    } else {
        fprintf(stderr, "Null propval\n");
    }
}

void
dbconf_print_dbinfo(DBConfDBInfo_t *db_info)
{
    DBPropVal_t *next;

    if (db_info) {
        fprintf(stderr, "dbname: \"%s\"\n", db_info->dbname);
        fprintf(stderr, "url: \t\"%s\"\n", db_info->url ? db_info->url : "");
        next = db_info->firstprop;
        while (next) {
            dbconf_print_propval(next);
            next = next->next;
        }
    } else {
        fprintf(stderr, "Null db_info\n");
    }
}

void
dbconf_print_confinfo(DBConfInfo_t *conf_info)
{
    DBConfDBInfo_t *next;

    if (conf_info) {
        next = conf_info->firstdb;
        while (next) {
            dbconf_print_dbinfo(next);
            next = next->next;
        }
    } else {
        fprintf(stderr, "Null conf_info\n");
    }
}


NSAPI_PUBLIC int
dbconf_output_db_directive(FILE *fp, const char *dbname, const char *url)
{
    fprintf(fp, "%s %s %s\n", DB_DIRECTIVE, dbname, url);
    return LDAPU_SUCCESS;
}

NSAPI_PUBLIC int
dbconf_output_propval(FILE *fp, const char *dbname, const char *prop, const char *val, const int encoded)
{
    if (encoded && val && *val) {
        char *new_val = dbconf_encodeval(val);

        if (!new_val)
            return LDAPU_ERR_OUT_OF_MEMORY;
        fprintf(fp, "%s:%s %s %s\n", dbname, ENCODED,
                prop, new_val);
        free(new_val);
    } else {
        fprintf(fp, "%s:%s %s\n", dbname, prop, val ? val : "");
    }

    return LDAPU_SUCCESS;
}


NSAPI_PUBLIC int
dbconf_get_dbnames(const char *dbmap, char ***dbnames_out, int *cnt_out)
{
    DBConfInfo_t *conf_info = 0;
    DBConfDBInfo_t *db = 0;
    int cnt = 0;
    char **dbnames = 0;
    char *heap = 0;
    int rv;

    *dbnames_out = 0;
    *cnt_out = 0;

    rv = dbconf_read_config_file(dbmap, &conf_info);

    if (rv != LDAPU_SUCCESS)
        return rv;

    db = conf_info->firstdb;


    dbnames = (char **)malloc(32 * 1024);
    heap = (char *)dbnames + 2 * 1024;

    if (!dbnames) {
        dbconf_free_confinfo(conf_info);
        return LDAPU_ERR_OUT_OF_MEMORY;
    }

    *dbnames_out = dbnames;

    while (db) {
        *dbnames++ = heap;
        strcpy(heap, db->dbname);
        heap += strlen(db->dbname) + 1;
        db = db->next;
        cnt++;
    }

    *dbnames = NULL;
    *cnt_out = cnt;
    dbconf_free_confinfo(conf_info);

    return LDAPU_SUCCESS;
}

NSAPI_PUBLIC int
dbconf_free_dbnames(char **dbnames)
{
    if (dbnames)
        free(dbnames);

    return LDAPU_SUCCESS;
}