ld_uri.c

Go to the documentation of this file.

/*
 * $Id$
 *
 * LDAP Database Driver for SER
 *
 * Copyright (C) 2008 iptelorg GmbH
 *
 * This file is part of SER, a free SIP server.
 *
 * SER is free software; you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option) any later
 * version.
 *
 * SER is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 */

#include "ld_uri.h"
#include "ld_cfg.h"

#include "../../mem/mem.h"
#include "../../ut.h"

#include <string.h>

#define cmpstr(s1, s2, f) \
        ((s1)!=(s2)) && ((s1)==0 || (s2)==0 || (f)((s1), (s2))!=0)


static unsigned char ld_uri_cmp(db_uri_t* uri1, db_uri_t* uri2)
{
        struct ld_uri* luri1, *luri2;

        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))
                return 0;
        return 1;
}

static int dupl_string(char** dst, const char* begin, const char* end)
{
        if (*dst) pkg_free(*dst);

        *dst = pkg_malloc(end - begin + 1);
        if ((*dst) == NULL) {
                return -1;
        }

        memcpy(*dst, begin, end - begin);
        (*dst)[end - begin] = '\0';
        return 0;
}

static char* pkgstrdup(str* s)
{
        char* dst;

        if (!s)
                return NULL;

        dst = pkg_malloc(s->len + 1);
        if (dst == NULL)
                return NULL;

        memcpy(dst, s->s, s->len);
        dst[s->len] = '\0';

        return dst;
}


/*
 * Parse ldap URI of form
 * //[username[:password]@]hostname[:port]
 *
 * Returns 0 if parsing was successful and -1 otherwise
 */
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 */
                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 portlen = 0;

        prev_token = 0;

        if (!res || !scheme || !uri) {
                goto err;
        }

        if (uri->len < SHORTEST_DB_URL_LEN) {
                goto err;
        }

        st = ST_BEGIN;
        ldapbegin = begin = uri->s;

        for(i = 0; i < uri->len && st != ST_SECTION_ID; i++) {
                switch(st) {
                case ST_BEGIN:
                        switch(uri->s[i]) {
                        case '/':
                                st = ST_SLASH2;
                                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;
                                break;

                        default:
                                goto err;
                        }
                        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;
                                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;

                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;

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

                if (ldap_url_parse(res->uri, &res->ldap_url) != 0) {
                        ERR("ldap: Error while parsing URL '%s'\n", res->uri);
                        goto err;
                }

                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->password.s) {
                        if (!(res->password = pkgstrdup(&cfg_conn_info->password))) {
                                ERR("ldap: No memory left\n");
                                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) {
                pkg_free(res->username);
                res->username = NULL;
        }
        if (res->password) {
                pkg_free(res->password);
                res->password = NULL;
        }
        if (res->ca_list) {
                pkg_free(res->ca_list);
                res->ca_list = NULL;
        }
        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)
{
        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)
{
        struct ld_uri* luri;

        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;

        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);
                db_drv_free(&luri->drv);
                pkg_free(luri);
        }
        return -1;
}