lib/gitconfig.c

   1 /* $OpenBSD: conf.c,v 1.107 2017/10/27 08:29:32 mpi Exp $        */
   2 /* $EOM: conf.c,v 1.48 2000/12/04 02:04:29 angelos Exp $         */
   3
   4 /*
   5  * Copyright (c) 1998, 1999, 2000, 2001 Niklas Hallqvist.  All rights reserved.
   6  * Copyright (c) 2000, 2001, 2002 Håkan Olsson.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <sys/types.h>
  30 #include <sys/queue.h>
  31 #include <sys/stat.h>
  32
  33 #include <ctype.h>
  34 #include <fcntl.h>
  35 #include <stdarg.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <unistd.h>
  40 #include <errno.h>
  41
  42 #include "got_compat.h"
  43
  44 #include "got_error.h"
  45
  46 #include "got_lib_gitconfig.h"
  47
  48 #ifndef nitems
  49 #define nitems(_a) (sizeof(_a) / sizeof((_a)[0]))
  50 #endif
  51
  52 #define LOG_MISC        0
  53 #define LOG_REPORT      1
  54 #ifdef GITCONFIG_DEBUG
  55 #define LOG_DBG(x) log_debug x
  56 #else
  57 #define LOG_DBG(x)
  58 #endif
  59
  60 #define log_print(...) fprintf(stderr, __VA_ARGS__)
  61 #define log_error(...) fprintf(stderr, __VA_ARGS__)
  62
  63 #ifdef GITCONFIG_DEBUG
  64 static void
  65 log_debug(int cls, int level, const char *fmt, ...)
  66 {
  67         va_list         ap;
  68
  69         va_start(ap, fmt);
  70         vfprintf(stderr, fmt, ap);
  71         va_end(ap);
  72         putc('\n', stderr);
  73 }
  74 #endif
  75
  76 struct got_gitconfig_trans {
  77         TAILQ_ENTRY(got_gitconfig_trans) link;
  78         int      trans;
  79         enum got_gitconfig_op {
  80                 CONF_SET, CONF_REMOVE, CONF_REMOVE_SECTION
  81         }        op;
  82         char    *section;
  83         char    *tag;
  84         char    *value;
  85         int      override;
  86         int      is_default;
  87 };
  88
  89 TAILQ_HEAD(got_gitconfig_trans_head, got_gitconfig_trans);
  90
  91 struct got_gitconfig_binding {
  92         LIST_ENTRY(got_gitconfig_binding) link;
  93         char    *section;
  94         char    *tag;
  95         char    *value;
  96         int      is_default;
  97 };
  98
  99 LIST_HEAD(got_gitconfig_bindings, got_gitconfig_binding);
 100
 101 struct got_gitconfig {
 102         struct got_gitconfig_bindings bindings[256];
 103         struct got_gitconfig_trans_head trans_queue;
 104         char    *addr;
 105         int     seq;
 106 };
 107
 108 static __inline__ u_int8_t
 109 conf_hash(const char *s)
 110 {
 111         u_int8_t hash = 0;
 112
 113         while (*s) {
 114                 hash = ((hash << 1) | (hash >> 7)) ^ tolower((unsigned char)*s);
 115                 s++;
 116         }
 117         return hash;
 118 }
 119
 120 /*
 121  * Insert a tag-value combination from LINE (the equal sign is at POS)
 122  */
 123 static int
 124 conf_remove_now(struct got_gitconfig *conf, char *section, char *tag)
 125 {
 126         struct got_gitconfig_binding *cb, *next;
 127
 128         for (cb = LIST_FIRST(&conf->bindings[conf_hash(section)]); cb;
 129             cb = next) {
 130                 next = LIST_NEXT(cb, link);
 131                 if (strcasecmp(cb->section, section) == 0 &&
 132                     strcasecmp(cb->tag, tag) == 0) {
 133                         LIST_REMOVE(cb, link);
 134                         LOG_DBG((LOG_MISC, 95, "[%s]:%s->%s removed", section,
 135                             tag, cb->value));
 136                         free(cb->section);
 137                         free(cb->tag);
 138                         free(cb->value);
 139                         free(cb);
 140                         return 0;
 141                 }
 142         }
 143         return 1;
 144 }
 145
 146 static int
 147 conf_remove_section_now(struct got_gitconfig *conf, char *section)
 148 {
 149         struct got_gitconfig_binding *cb, *next;
 150         int     unseen = 1;
 151
 152         for (cb = LIST_FIRST(&conf->bindings[conf_hash(section)]); cb;
 153             cb = next) {
 154                 next = LIST_NEXT(cb, link);
 155                 if (strcasecmp(cb->section, section) == 0) {
 156                         unseen = 0;
 157                         LIST_REMOVE(cb, link);
 158                         LOG_DBG((LOG_MISC, 95, "[%s]:%s->%s removed", section,
 159                             cb->tag, cb->value));
 160                         free(cb->section);
 161                         free(cb->tag);
 162                         free(cb->value);
 163                         free(cb);
 164                 }
 165         }
 166         return unseen;
 167 }
 168
 169 /*
 170  * Insert a tag-value combination from LINE (the equal sign is at POS)
 171  * into SECTION of our configuration database.
 172  */
 173 static int
 174 conf_set_now(struct got_gitconfig *conf, char *section, char *tag,
 175     char *value, int override, int is_default)
 176 {
 177         struct got_gitconfig_binding *node = 0;
 178
 179         if (override)
 180                 conf_remove_now(conf, section, tag);
 181         else if (got_gitconfig_get_str(conf, section, tag)) {
 182                 if (!is_default)
 183                         LOG_DBG((LOG_MISC, 95,
 184                             "conf_set_now: duplicate tag [%s]:%s, "
 185                             "ignoring...", section, tag));
 186                 return 1;
 187         }
 188         node = calloc(1, sizeof *node);
 189         if (!node) {
 190                 log_error("conf_set_now: calloc (1, %lu) failed",
 191                     (unsigned long)sizeof *node);
 192                 return 1;
 193         }
 194         node->section = node->tag = node->value = NULL;
 195         if ((node->section = strdup(section)) == NULL)
 196                 goto fail;
 197         if ((node->tag = strdup(tag)) == NULL)
 198                 goto fail;
 199         if ((node->value = strdup(value)) == NULL)
 200                 goto fail;
 201         node->is_default = is_default;
 202
 203         LIST_INSERT_HEAD(&conf->bindings[conf_hash(section)], node, link);
 204         LOG_DBG((LOG_MISC, 95, "conf_set_now: [%s]:%s->%s", node->section,
 205             node->tag, node->value));
 206         return 0;
 207 fail:
 208         free(node->value);
 209         free(node->tag);
 210         free(node->section);
 211         free(node);
 212         return 1;
 213 }
 214
 215 /*
 216  * Parse the line LINE of SZ bytes.  Skip Comments, recognize section
 217  * headers and feed tag-value pairs into our configuration database.
 218  */
 219 static const struct got_error *
 220 conf_parse_line(char **section, struct got_gitconfig *conf, int trans,
 221     char *line, int ln, size_t sz)
 222 {
 223         char    *val;
 224         size_t   i;
 225         int      j;
 226
 227         /* '[section]' parsing...  */
 228         if (*line == '[') {
 229                 for (i = 1; i < sz; i++)
 230                         if (line[i] == ']')
 231                                 break;
 232                 free(*section);
 233                 if (i == sz) {
 234                         log_print("conf_parse_line: %d:"
 235                             "unmatched ']', ignoring until next section", ln);
 236                         *section = NULL;
 237                         return NULL;
 238                 }
 239                 *section = strndup(line + 1, i - 1);
 240                 if (*section == NULL)
 241                         return got_error_from_errno("strndup");
 242                 return NULL;
 243         }
 244         while (sz > 0 && isspace((unsigned char)*line)) {
 245                 line++;
 246                 sz--;
 247         }
 248
 249         /* Lines starting with '#' or ';' are comments.  */
 250         if (*line == '#' || *line == ';')
 251                 return NULL;
 252
 253         /* Deal with assignments.  */
 254         for (i = 0; i < sz; i++)
 255                 if (line[i] == '=') {
 256                         /* If no section, we are ignoring the lines.  */
 257                         if (!*section) {
 258                                 log_print("conf_parse_line: %d: ignoring line "
 259                                     "due to no section", ln);
 260                                 return NULL;
 261                         }
 262                         line[strcspn(line, " \t=")] = '\0';
 263                         val = line + i + 1 + strspn(line + i + 1, " \t");
 264                         /* Skip trailing whitespace, if any */
 265                         for (j = sz - (val - line) - 1; j > 0 &&
 266                             isspace((unsigned char)val[j]); j--)
 267                                 val[j] = '\0';
 268                         /* XXX Perhaps should we not ignore errors?  */
 269                         got_gitconfig_set(conf, trans, *section, line, val,
 270                             0, 0);
 271                         return NULL;
 272                 }
 273         /* Other non-empty lines are weird.  */
 274         i = strspn(line, " \t");
 275         if (line[i])
 276                 log_print("conf_parse_line: %d: syntax error", ln);
 277
 278         return NULL;
 279 }
 280
 281 /* Parse the mapped configuration file.  */
 282 static const struct got_error *
 283 conf_parse(struct got_gitconfig *conf, int trans, char *buf, size_t sz)
 284 {
 285         const struct got_error *err = NULL;
 286         char    *cp = buf;
 287         char    *bufend = buf + sz;
 288         char    *line, *section = NULL;
 289         int     ln = 1;
 290
 291         line = cp;
 292         while (cp < bufend) {
 293                 if (*cp == '\n') {
 294                         /* Check for escaped newlines.  */
 295                         if (cp > buf && *(cp - 1) == '\\')
 296                                 *(cp - 1) = *cp = ' ';
 297                         else {
 298                                 *cp = '\0';
 299                                 err = conf_parse_line(&section, conf, trans,
 300                                     line, ln, cp - line);
 301                                 if (err)
 302                                         return err;
 303                                 line = cp + 1;
 304                         }
 305                         ln++;
 306                 }
 307                 cp++;
 308         }
 309         if (cp != line)
 310                 log_print("conf_parse: last line unterminated, ignored.");
 311         return NULL;
 312 }
 313
 314 const struct got_error *
 315 got_gitconfig_open(struct got_gitconfig **conf, int fd)
 316 {
 317         size_t i;
 318
 319         *conf = calloc(1, sizeof(**conf));
 320         if (*conf == NULL)
 321                 return got_error_from_errno("malloc");
 322
 323         for (i = 0; i < nitems((*conf)->bindings); i++)
 324                 LIST_INIT(&(*conf)->bindings[i]);
 325         TAILQ_INIT(&(*conf)->trans_queue);
 326         return got_gitconfig_reinit(*conf, fd);
 327 }
 328
 329 static void
 330 conf_clear(struct got_gitconfig *conf)
 331 {
 332         struct got_gitconfig_binding *cb;
 333         size_t i;
 334
 335         if (conf->addr) {
 336                 for (i = 0; i < nitems(conf->bindings); i++)
 337                         for (cb = LIST_FIRST(&conf->bindings[i]); cb;
 338                             cb = LIST_FIRST(&conf->bindings[i]))
 339                                 conf_remove_now(conf, cb->section, cb->tag);
 340                 free(conf->addr);
 341                 conf->addr = NULL;
 342         }
 343 }
 344
 345 /* Execute all queued operations for this transaction.  Cleanup.  */
 346 static int
 347 conf_end(struct got_gitconfig *conf, int transaction, int commit)
 348 {
 349         struct got_gitconfig_trans *node, *next;
 350
 351         for (node = TAILQ_FIRST(&conf->trans_queue); node; node = next) {
 352                 next = TAILQ_NEXT(node, link);
 353                 if (node->trans == transaction) {
 354                         if (commit)
 355                                 switch (node->op) {
 356                                 case CONF_SET:
 357                                         conf_set_now(conf, node->section,
 358                                             node->tag, node->value,
 359                                             node->override, node->is_default);
 360                                         break;
 361                                 case CONF_REMOVE:
 362                                         conf_remove_now(conf, node->section,
 363                                             node->tag);
 364                                         break;
 365                                 case CONF_REMOVE_SECTION:
 366                                         conf_remove_section_now(conf, node->section);
 367                                         break;
 368                                 default:
 369                                         log_print("got_gitconfig_end: unknown "
 370                                             "operation: %d", node->op);
 371                                 }
 372                         TAILQ_REMOVE(&conf->trans_queue, node, link);
 373                         free(node->section);
 374                         free(node->tag);
 375                         free(node->value);
 376                         free(node);
 377                 }
 378         }
 379         return 0;
 380 }
 381
 382
 383 void
 384 got_gitconfig_close(struct got_gitconfig *conf)
 385 {
 386         conf_clear(conf);
 387         free(conf);
 388 }
 389
 390 static int
 391 conf_begin(struct got_gitconfig *conf)
 392 {
 393         return ++conf->seq;
 394 }
 395
 396 /* Open the config file and map it into our address space, then parse it.  */
 397 const struct got_error *
 398 got_gitconfig_reinit(struct got_gitconfig *conf, int fd)
 399 {
 400         const struct got_error *err = NULL;
 401         int      trans;
 402         size_t   sz;
 403         char    *new_conf_addr = 0;
 404         struct stat st;
 405
 406         if (fstat(fd, &st)) {
 407                 err = got_error_from_errno("fstat");
 408                 goto fail;
 409         }
 410
 411         sz = st.st_size;
 412         new_conf_addr = malloc(sz);
 413         if (new_conf_addr == NULL) {
 414                 err = got_error_from_errno("malloc");
 415                 goto fail;
 416         }
 417         /* XXX I assume short reads won't happen here.  */
 418         if (read(fd, new_conf_addr, sz) != (int)sz) {
 419                 err = got_error_from_errno("read");
 420                 goto fail;
 421         }
 422
 423         trans = conf_begin(conf);
 424
 425         err = conf_parse(conf, trans, new_conf_addr, sz);
 426         if (err)
 427                 goto fail;
 428
 429         /* Free potential existing configuration.  */
 430         conf_clear(conf);
 431         conf_end(conf, trans, 1);
 432         conf->addr = new_conf_addr;
 433         return NULL;
 434
 435 fail:
 436         free(new_conf_addr);
 437         return err;
 438 }
 439
 440 /*
 441  * Return the numeric value denoted by TAG in section SECTION or DEF
 442  * if that tag does not exist.
 443  */
 444 int
 445 got_gitconfig_get_num(struct got_gitconfig *conf, const char *section,
 446     const char *tag, int def)
 447 {
 448         char    *value = got_gitconfig_get_str(conf, section, tag);
 449
 450         if (value)
 451                 return atoi(value);
 452         return def;
 453 }
 454
 455 /* Validate X according to the range denoted by TAG in section SECTION.  */
 456 int
 457 got_gitconfig_match_num(struct got_gitconfig *conf, char *section, char *tag,
 458     int x)
 459 {
 460         char    *value = got_gitconfig_get_str(conf, section, tag);
 461         int      val, min, max, n;
 462
 463         if (!value)
 464                 return 0;
 465         n = sscanf(value, "%d,%d:%d", &val, &min, &max);
 466         switch (n) {
 467         case 1:
 468                 LOG_DBG((LOG_MISC, 95, "got_gitconfig_match_num: %s:%s %d==%d?",
 469                     section, tag, val, x));
 470                 return x == val;
 471         case 3:
 472                 LOG_DBG((LOG_MISC, 95, "got_gitconfig_match_num: %s:%s %d<=%d<=%d?",
 473                     section, tag, min, x, max));
 474                 return min <= x && max >= x;
 475         default:
 476                 log_error("got_gitconfig_match_num: section %s tag %s: invalid number "
 477                     "spec %s", section, tag, value);
 478         }
 479         return 0;
 480 }
 481
 482 /* Return the string value denoted by TAG in section SECTION.  */
 483 char *
 484 got_gitconfig_get_str(struct got_gitconfig *conf, const char *section,
 485     const char *tag)
 486 {
 487         struct got_gitconfig_binding *cb;
 488
 489         for (cb = LIST_FIRST(&conf->bindings[conf_hash(section)]); cb;
 490             cb = LIST_NEXT(cb, link))
 491                 if (strcasecmp(section, cb->section) == 0 &&
 492                     strcasecmp(tag, cb->tag) == 0) {
 493                         LOG_DBG((LOG_MISC, 95, "got_gitconfig_get_str: [%s]:%s->%s",
 494                             section, tag, cb->value));
 495                         return cb->value;
 496                 }
 497         LOG_DBG((LOG_MISC, 95,
 498             "got_gitconfig_get_str: configuration value not found [%s]:%s", section,
 499             tag));
 500         return 0;
 501 }
 502
 503 const struct got_error *
 504 got_gitconfig_get_section_list(struct got_gitconfig_list **sections,
 505     struct got_gitconfig *conf)
 506 {
 507         const struct got_error *err = NULL;
 508         struct got_gitconfig_list *list = NULL;
 509         struct got_gitconfig_list_node *node = 0;
 510         struct got_gitconfig_binding *cb;
 511         size_t i;
 512
 513         *sections = NULL;
 514
 515         list = malloc(sizeof *list);
 516         if (!list)
 517                 return got_error_from_errno("malloc");
 518         TAILQ_INIT(&list->fields);
 519         list->cnt = 0;
 520         for (i = 0; i < nitems(conf->bindings); i++) {
 521                 for (cb = LIST_FIRST(&conf->bindings[i]); cb;
 522                     cb = LIST_NEXT(cb, link)) {
 523                         int section_present = 0;
 524                         TAILQ_FOREACH(node, &list->fields, link) {
 525                                 if (strcmp(node->field, cb->section) == 0) {
 526                                         section_present = 1;
 527                                         break;
 528                                 }
 529                         }
 530                         if (section_present)
 531                                 continue;
 532                         list->cnt++;
 533                         node = calloc(1, sizeof *node);
 534                         if (!node) {
 535                                 err = got_error_from_errno("calloc");
 536                                 goto cleanup;
 537                         }
 538                         node->field = strdup(cb->section);
 539                         if (!node->field) {
 540                                 err = got_error_from_errno("strdup");
 541                                 goto cleanup;
 542                         }
 543                         TAILQ_INSERT_TAIL(&list->fields, node, link);
 544                 }
 545         }
 546
 547         *sections = list;
 548         return NULL;
 549
 550 cleanup:
 551         free(node);
 552         if (list)
 553                 got_gitconfig_free_list(list);
 554         return err;
 555 }
 556
 557 /*
 558  * Build a list of string values out of the comma separated value denoted by
 559  * TAG in SECTION.
 560  */
 561 struct got_gitconfig_list *
 562 got_gitconfig_get_list(struct got_gitconfig *conf, char *section, char *tag)
 563 {
 564         char    *liststr = 0, *p, *field, *t;
 565         struct got_gitconfig_list *list = 0;
 566         struct got_gitconfig_list_node *node = 0;
 567
 568         list = malloc(sizeof *list);
 569         if (!list)
 570                 goto cleanup;
 571         TAILQ_INIT(&list->fields);
 572         list->cnt = 0;
 573         liststr = got_gitconfig_get_str(conf, section, tag);
 574         if (!liststr)
 575                 goto cleanup;
 576         liststr = strdup(liststr);
 577         if (!liststr)
 578                 goto cleanup;
 579         p = liststr;
 580         while ((field = strsep(&p, ",")) != NULL) {
 581                 /* Skip leading whitespace */
 582                 while (isspace((unsigned char)*field))
 583                         field++;
 584                 /* Skip trailing whitespace */
 585                 if (p)
 586                         for (t = p - 1; t > field && isspace((unsigned char)*t); t--)
 587                                 *t = '\0';
 588                 if (*field == '\0') {
 589                         log_print("got_gitconfig_get_list: empty field, ignoring...");
 590                         continue;
 591                 }
 592                 list->cnt++;
 593                 node = calloc(1, sizeof *node);
 594                 if (!node)
 595                         goto cleanup;
 596                 node->field = strdup(field);
 597                 if (!node->field)
 598                         goto cleanup;
 599                 TAILQ_INSERT_TAIL(&list->fields, node, link);
 600         }
 601         free(liststr);
 602         return list;
 603
 604 cleanup:
 605         free(node);
 606         if (list)
 607                 got_gitconfig_free_list(list);
 608         free(liststr);
 609         return 0;
 610 }
 611
 612 struct got_gitconfig_list *
 613 got_gitconfig_get_tag_list(struct got_gitconfig *conf, const char *section)
 614 {
 615         struct got_gitconfig_list *list = 0;
 616         struct got_gitconfig_list_node *node = 0;
 617         struct got_gitconfig_binding *cb;
 618
 619         list = malloc(sizeof *list);
 620         if (!list)
 621                 goto cleanup;
 622         TAILQ_INIT(&list->fields);
 623         list->cnt = 0;
 624         for (cb = LIST_FIRST(&conf->bindings[conf_hash(section)]); cb;
 625             cb = LIST_NEXT(cb, link))
 626                 if (strcasecmp(section, cb->section) == 0) {
 627                         list->cnt++;
 628                         node = calloc(1, sizeof *node);
 629                         if (!node)
 630                                 goto cleanup;
 631                         node->field = strdup(cb->tag);
 632                         if (!node->field)
 633                                 goto cleanup;
 634                         TAILQ_INSERT_TAIL(&list->fields, node, link);
 635                 }
 636         return list;
 637
 638 cleanup:
 639         free(node);
 640         if (list)
 641                 got_gitconfig_free_list(list);
 642         return 0;
 643 }
 644
 645 void
 646 got_gitconfig_free_list(struct got_gitconfig_list *list)
 647 {
 648         struct got_gitconfig_list_node *node = TAILQ_FIRST(&list->fields);
 649
 650         while (node) {
 651                 TAILQ_REMOVE(&list->fields, node, link);
 652                 free(node->field);
 653                 free(node);
 654                 node = TAILQ_FIRST(&list->fields);
 655         }
 656         free(list);
 657 }
 658
 659 static int
 660 got_gitconfig_trans_node(struct got_gitconfig *conf, int transaction,
 661     enum got_gitconfig_op op, char *section, char *tag, char *value,
 662     int override, int is_default)
 663 {
 664         struct got_gitconfig_trans *node;
 665
 666         node = calloc(1, sizeof *node);
 667         if (!node) {
 668                 log_error("got_gitconfig_trans_node: calloc (1, %lu) failed",
 669                     (unsigned long)sizeof *node);
 670                 return 1;
 671         }
 672         node->trans = transaction;
 673         node->op = op;
 674         node->override = override;
 675         node->is_default = is_default;
 676         if (section && (node->section = strdup(section)) == NULL)
 677                 goto fail;
 678         if (tag && (node->tag = strdup(tag)) == NULL)
 679                 goto fail;
 680         if (value && (node->value = strdup(value)) == NULL)
 681                 goto fail;
 682         TAILQ_INSERT_TAIL(&conf->trans_queue, node, link);
 683         return 0;
 684
 685 fail:
 686         free(node->section);
 687         free(node->tag);
 688         free(node->value);
 689         free(node);
 690         return 1;
 691 }
 692
 693 /* Queue a set operation.  */
 694 int
 695 got_gitconfig_set(struct got_gitconfig *conf, int transaction, char *section,
 696     char *tag, char *value, int override, int is_default)
 697 {
 698         return got_gitconfig_trans_node(conf, transaction, CONF_SET, section,
 699             tag, value, override, is_default);
 700 }
 701
 702 /* Queue a remove operation.  */
 703 int
 704 got_gitconfig_remove(struct got_gitconfig *conf, int transaction,
 705     char *section, char *tag)
 706 {
 707         return got_gitconfig_trans_node(conf, transaction, CONF_REMOVE,
 708             section, tag, NULL, 0, 0);
 709 }
 710
 711 /* Queue a remove section operation.  */
 712 int
 713 got_gitconfig_remove_section(struct got_gitconfig *conf, int transaction,
 714     char *section)
 715 {
 716         return got_gitconfig_trans_node(conf, transaction, CONF_REMOVE_SECTION,
 717             section, NULL, NULL, 0, 0);
 718 }