src/context.c

/**
 * @file context.c
 * @author Radek Krejci <rkrejci@cesnet.cz>
 * @brief context implementation for libyang
 *
 * Copyright (c) 2015 CESNET, z.s.p.o.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of the Company nor the names of its contributors
 *    may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 */

#define _GNU_SOURCE
#include <dirent.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>

#include "common.h"
#include "context.h"
#include "dict.h"

API struct ly_ctx *
ly_ctx_new(const char *search_dir)
{
    struct ly_ctx *ctx;
    char *cwd;

    ctx = calloc(1, sizeof *ctx);
    if (!ctx) {
        LOGMEM;
        return NULL;
    }

    /* dictionary */
    lydict_init(&ctx->dict);

    /* models list */
    ctx->models.list = calloc(16, sizeof *ctx->models.list);
    ctx->models.used = 0;
    ctx->models.size = 16;
    if (search_dir) {
        cwd = get_current_dir_name();
        if (chdir(search_dir)) {
            LOGERR(LY_ESYS, "Unable to use search directory \"%s\" (%s)",
                   search_dir, strerror(errno));
            free(cwd);
            ly_ctx_destroy(ctx);
            return NULL;
        }
        ctx->models.search_path = get_current_dir_name();
        chdir(cwd);
        free(cwd);
    }

    return ctx;
}

API void
ly_ctx_set_searchdir(struct ly_ctx *ctx, const char *search_dir)
{
    char *cwd;

    if (!ctx) {
        return;
    }

    if (search_dir) {
        cwd = get_current_dir_name();
        if (chdir(search_dir)) {
            LOGERR(LY_ESYS, "Unable to use search directory \"%s\" (%s)",
                   search_dir, strerror(errno));
            free(cwd);
            return;
        }
        ctx->models.search_path = get_current_dir_name();
        chdir(cwd);
        free(cwd);
    } else {
        free(ctx->models.search_path);
        ctx->models.search_path = NULL;
    }
}

API void
ly_ctx_destroy(struct ly_ctx *ctx)
{
    if (!ctx) {
        return;
    }

    /* models list */
    while (ctx->models.used) {
        ly_module_free(ctx->models.list[0]);
    }
    free(ctx->models.search_path);
    free(ctx->models.list);

    /* dictionary */
    lydict_clean(&ctx->dict);

    free(ctx);
}

static struct ly_module *
search_file(struct ly_ctx *ctx, struct ly_module *module, const char *name, const char *revision)
{
    size_t len, flen;
    int fd;
    char *cwd;
    DIR *dir;
    struct dirent *file;
    LY_MINFORMAT format;
    struct ly_module *result = NULL;
    int localsearch = 1;

    len = strlen(name);
    cwd = get_current_dir_name();
    dir = opendir(cwd);
    LOGVRB("Searching for \"%s\" in %s.", name, cwd);
    if (!dir) {
        LOGWRN("Unable to open local directory for searching referenced modules (%s)",
               strerror(errno));
        /* try search directory */
        goto searchpath;
    }

search:
    while ((file = readdir(dir))) {
        if (strncmp(name, file->d_name, len)) {
            continue;
        }

        flen = strlen(file->d_name);
        if (revision && flen > len + 5) {
            /* check revision from the filename */
            /* TODO */
        }

        /* get type according to filename suffix */
        if (!strcmp(&file->d_name[flen - 4], ".yin")) {
            format = LY_IN_YIN;
        } else if (!strcmp(&file->d_name[flen - 5], ".yang")) {
            format = LY_IN_YANG;
        } else {
            continue;
        }

        /* open the file */
        fd = open(file->d_name, O_RDONLY);
        if (fd < 0) {
            LOGERR(LY_ESYS, "Unable to open data model file \"%s\" (%s).",
                   file->d_name, strerror(errno));
            goto cleanup;
        }

        if (module) {
            result = (struct ly_module *)ly_submodule_read_fd(module, fd, format);
        } else {
            result = ly_module_read_fd(ctx, fd, format);
        }
        close(fd);

        if (result) {
            break;
        }
    }

searchpath:
    if (!ctx->models.search_path) {
        LOGWRN("No search path defined for the current context.");
    } else if (!result && localsearch) {
        /* search in local directory done, try context's search_path */
        closedir(dir);
        dir = opendir(ctx->models.search_path);
        if (!dir) {
            LOGERR(LY_ESYS, "Unable to open data model search directory \"%s\" (%s).",
                   ctx->models.search_path, strerror(errno));
            goto cleanup;
        }

        chdir(ctx->models.search_path);
        LOGVRB("Searching for \"%s\" in %s.", name, ctx->models.search_path);

        localsearch = 0;
        goto search;
    }

cleanup:
    chdir(cwd);
    free(cwd);
    closedir(dir);

    return result;
}

struct ly_submodule *
ly_ctx_get_submodule(struct ly_module *module, const char *name, const char *revision)
{
    struct ly_submodule *result;
    int i;

    if (!module || !name) {
        ly_errno = LY_EINVAL;
        return NULL;
    }

    /* search in modules included by the main module */
    if (module->type) {
        module = ((struct ly_submodule *)module)->belongsto;
    }
    for (i = 0; i < module->inc_size; i++) {
        result = module->inc[i].submodule;
        if (strcmp(name, result->name)) {
            continue;
        }

        if (!revision || (result->rev_size && !strcmp(revision, result->rev[0].date))) {
            return result;
        }
    }

    /* not found in context, try to get it from the search directory */
    result = (struct ly_submodule *)search_file(module->ctx, module, name, revision);
    if (!result) {
        LOGERR(LY_EVALID, "Submodule \"%s\" of the \"%s\" data model not found (search path is \"%s\")",
               name, module->name, module->ctx->models.search_path);
    }

    return result;
}

API struct ly_module *
ly_ctx_get_module(struct ly_ctx *ctx, const char *name, const char *revision, int read)
{
    int i;
    struct ly_module *result = NULL;

    if (!ctx || !name) {
        ly_errno = LY_EINVAL;
        return NULL;
    }

    for (i = 0; i < ctx->models.used; i++) {
        result = ctx->models.list[i];
        if (!result || strcmp(name, result->name)) {
            continue;
        }

        if (!revision || (result->rev_size && !strcmp(revision, result->rev[0].date))) {
            return result;
        }
    }

    if (!read) {
        return NULL;
    }

    /* not found in context, try to get it from the search directory */
    result = search_file(ctx, NULL, name, revision);
    if (!result) {
        LOGERR(LY_EVALID, "Data model \"%s\" not found (search path is \"%s\")", name, ctx->models.search_path);
    }

    return result;
}

API char **
ly_ctx_get_module_names(struct ly_ctx *ctx)
{
    int i;
    char **result = NULL;
    unsigned int count = 0;

    if (!ctx) {
        ly_errno = LY_EINVAL;
        return NULL;
    }

    for (i = 0; i < ctx->models.used; i++) {
        ++count;
        result = realloc(result, count * sizeof *result);
        result[count-1] = strdup(ctx->models.list[i]->name);
    }
    ++count;
    result = realloc(result, count * sizeof *result);
    result[count-1] = NULL;

    return result;
}