src/config_mem.c

   1 /*
   2  * Copyright (C) the libgit2 contributors. All rights reserved.
   3  *
   4  * This file is part of libgit2, distributed under the GNU GPL v2 with
   5  * a Linking Exception. For full terms see the included COPYING file.
   6  */
   7
   8 #include "config.h"
   9
  10 #include "config_backend.h"
  11 #include "config_parse.h"
  12 #include "config_entries.h"
  13
  14 typedef struct {
  15         git_config_backend parent;
  16         git_config_entries *entries;
  17         git_buf cfg;
  18 } config_memory_backend;
  19
  20 typedef struct {
  21         git_config_entries *entries;
  22         git_config_level_t level;
  23 } config_memory_parse_data;
  24
  25 static int config_error_readonly(void)
  26 {
  27         git_error_set(GIT_ERROR_CONFIG, "this backend is read-only");
  28         return -1;
  29 }
  30
  31 static int read_variable_cb(
  32         git_config_parser *reader,
  33         const char *current_section,
  34         const char *var_name,
  35         const char *var_value,
  36         const char *line,
  37         size_t line_len,
  38         void *payload)
  39 {
  40         config_memory_parse_data *parse_data = (config_memory_parse_data *) payload;
  41         git_buf buf = GIT_BUF_INIT;
  42         git_config_entry *entry;
  43         const char *c;
  44         int result;
  45
  46         GIT_UNUSED(reader);
  47         GIT_UNUSED(line);
  48         GIT_UNUSED(line_len);
  49
  50         if (current_section) {
  51                 /* TODO: Once warnings land, we should likely warn
  52                  * here. Git appears to warn in most cases if it sees
  53                  * un-namespaced config options.
  54                  */
  55                 git_buf_puts(&buf, current_section);
  56                 git_buf_putc(&buf, '.');
  57         }
  58
  59         for (c = var_name; *c; c++)
  60                 git_buf_putc(&buf, git__tolower(*c));
  61
  62         if (git_buf_oom(&buf))
  63                 return -1;
  64
  65         entry = git__calloc(1, sizeof(git_config_entry));
  66         GIT_ERROR_CHECK_ALLOC(entry);
  67         entry->name = git_buf_detach(&buf);
  68         entry->value = var_value ? git__strdup(var_value) : NULL;
  69         entry->level = parse_data->level;
  70         entry->include_depth = 0;
  71
  72         if ((result = git_config_entries_append(parse_data->entries, entry)) < 0)
  73                 return result;
  74
  75         return result;
  76 }
  77
  78 static int config_memory_open(git_config_backend *backend, git_config_level_t level, const git_repository *repo)
  79 {
  80         config_memory_backend *memory_backend = (config_memory_backend *) backend;
  81         config_memory_parse_data parse_data;
  82         git_config_parser reader;
  83
  84         GIT_UNUSED(repo);
  85
  86         if (memory_backend->cfg.size == 0)
  87                 return 0;
  88
  89         git_parse_ctx_init(&reader.ctx, memory_backend->cfg.ptr, memory_backend->cfg.size);
  90         reader.file = NULL;
  91         parse_data.entries = memory_backend->entries;
  92         parse_data.level = level;
  93
  94         return git_config_parse(&reader, NULL, read_variable_cb, NULL, NULL, &parse_data);
  95 }
  96
  97 static int config_memory_get(git_config_backend *backend, const char *key, git_config_entry **out)
  98 {
  99         config_memory_backend *memory_backend = (config_memory_backend *) backend;
 100         return git_config_entries_get(out, memory_backend->entries, key);
 101 }
 102
 103 static int config_memory_iterator(
 104         git_config_iterator **iter,
 105         git_config_backend *backend)
 106 {
 107         config_memory_backend *memory_backend = (config_memory_backend *) backend;
 108         git_config_entries *entries;
 109         int error;
 110
 111         if ((error = git_config_entries_dup(&entries, memory_backend->entries)) < 0)
 112                 goto out;
 113
 114         if ((error = git_config_entries_iterator_new(iter, entries)) < 0)
 115                 goto out;
 116
 117 out:
 118         /* Let iterator delete duplicated entries when it's done */
 119         git_config_entries_free(entries);
 120         return error;
 121 }
 122
 123 static int config_memory_set(git_config_backend *backend, const char *name, const char *value)
 124 {
 125         GIT_UNUSED(backend);
 126         GIT_UNUSED(name);
 127         GIT_UNUSED(value);
 128         return config_error_readonly();
 129 }
 130
 131 static int config_memory_set_multivar(
 132         git_config_backend *backend, const char *name, const char *regexp, const char *value)
 133 {
 134         GIT_UNUSED(backend);
 135         GIT_UNUSED(name);
 136         GIT_UNUSED(regexp);
 137         GIT_UNUSED(value);
 138         return config_error_readonly();
 139 }
 140
 141 static int config_memory_delete(git_config_backend *backend, const char *name)
 142 {
 143         GIT_UNUSED(backend);
 144         GIT_UNUSED(name);
 145         return config_error_readonly();
 146 }
 147
 148 static int config_memory_delete_multivar(git_config_backend *backend, const char *name, const char *regexp)
 149 {
 150         GIT_UNUSED(backend);
 151         GIT_UNUSED(name);
 152         GIT_UNUSED(regexp);
 153         return config_error_readonly();
 154 }
 155
 156 static int config_memory_lock(git_config_backend *backend)
 157 {
 158         GIT_UNUSED(backend);
 159         return config_error_readonly();
 160 }
 161
 162 static int config_memory_unlock(git_config_backend *backend, int success)
 163 {
 164         GIT_UNUSED(backend);
 165         GIT_UNUSED(success);
 166         return config_error_readonly();
 167 }
 168
 169 static int config_memory_snapshot(git_config_backend **out, git_config_backend *backend)
 170 {
 171         GIT_UNUSED(out);
 172         GIT_UNUSED(backend);
 173         git_error_set(GIT_ERROR_CONFIG, "this backend does not support snapshots");
 174         return -1;
 175 }
 176
 177 static void config_memory_free(git_config_backend *_backend)
 178 {
 179         config_memory_backend *backend = (config_memory_backend *)_backend;
 180
 181         if (backend == NULL)
 182                 return;
 183
 184         git_config_entries_free(backend->entries);
 185         git_buf_dispose(&backend->cfg);
 186         git__free(backend);
 187 }
 188
 189 int git_config_backend_from_string(git_config_backend **out, const char *cfg, size_t len)
 190 {
 191         config_memory_backend *backend;
 192
 193         backend = git__calloc(1, sizeof(config_memory_backend));
 194         GIT_ERROR_CHECK_ALLOC(backend);
 195
 196         if (git_config_entries_new(&backend->entries) < 0) {
 197                 git__free(backend);
 198                 return -1;
 199         }
 200
 201         if (git_buf_set(&backend->cfg, cfg, len) < 0) {
 202                 git_config_entries_free(backend->entries);
 203                 git__free(backend);
 204                 return -1;
 205         }
 206
 207         backend->parent.version = GIT_CONFIG_BACKEND_VERSION;
 208         backend->parent.readonly = 1;
 209         backend->parent.open = config_memory_open;
 210         backend->parent.get = config_memory_get;
 211         backend->parent.set = config_memory_set;
 212         backend->parent.set_multivar = config_memory_set_multivar;
 213         backend->parent.del = config_memory_delete;
 214         backend->parent.del_multivar = config_memory_delete_multivar;
 215         backend->parent.iterator = config_memory_iterator;
 216         backend->parent.lock = config_memory_lock;
 217         backend->parent.unlock = config_memory_unlock;
 218         backend->parent.snapshot = config_memory_snapshot;
 219         backend->parent.free = config_memory_free;
 220
 221         *out = (git_config_backend *)backend;
 222
 223         return 0;
 224 }