urlmatch.c

   1 #define DISABLE_SIGN_COMPARE_WARNINGS
   2
   3 #include "git-compat-util.h"
   4 #include "gettext.h"
   5 #include "hex-ll.h"
   6 #include "strbuf.h"
   7 #include "urlmatch.h"
   8
   9 #define URL_ALPHA "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
  10 #define URL_DIGIT "0123456789"
  11 #define URL_ALPHADIGIT URL_ALPHA URL_DIGIT
  12 #define URL_SCHEME_CHARS URL_ALPHADIGIT "+.-"
  13 #define URL_HOST_CHARS URL_ALPHADIGIT ".-_[:]" /* IPv6 literals need [:] */
  14 #define URL_UNSAFE_CHARS " <>\"%{}|\\^`" /* plus 0x00-0x1F,0x7F-0xFF */
  15 #define URL_GEN_RESERVED ":/?#[]@"
  16 #define URL_SUB_RESERVED "!$&'()*+,;="
  17 #define URL_RESERVED URL_GEN_RESERVED URL_SUB_RESERVED /* only allowed delims */
  18
  19 static int append_normalized_escapes(struct strbuf *buf,
  20                                      const char *from,
  21                                      size_t from_len,
  22                                      const char *esc_extra,
  23                                      const char *esc_ok)
  24 {
  25         /*
  26          * Append to strbuf 'buf' characters from string 'from' with length
  27          * 'from_len' while unescaping characters that do not need to be escaped
  28          * and escaping characters that do.  The set of characters to escape
  29          * (the complement of which is unescaped) starts out as the RFC 3986
  30          * unsafe characters (0x00-0x1F,0x7F-0xFF," <>\"#%{}|\\^`").  If
  31          * 'esc_extra' is not NULL, those additional characters will also always
  32          * be escaped.  If 'esc_ok' is not NULL, those characters will be left
  33          * escaped if found that way, but will not be unescaped otherwise (used
  34          * for delimiters).  If a %-escape sequence is encountered that is not
  35          * followed by 2 hexadecimal digits, the sequence is invalid and
  36          * false (0) will be returned.  Otherwise true (1) will be returned for
  37          * success.
  38          *
  39          * Note that all %-escape sequences will be normalized to UPPERCASE
  40          * as indicated in RFC 3986.  Unless included in esc_extra or esc_ok
  41          * alphanumerics and "-._~" will always be unescaped as per RFC 3986.
  42          */
  43
  44         while (from_len) {
  45                 int ch = *from++;
  46                 int was_esc = 0;
  47
  48                 from_len--;
  49                 if (ch == '%') {
  50                         if (from_len < 2)
  51                                 return 0;
  52                         ch = hex2chr(from);
  53                         if (ch < 0)
  54                                 return 0;
  55                         from += 2;
  56                         from_len -= 2;
  57                         was_esc = 1;
  58                 }
  59                 if ((unsigned char)ch <= 0x1F || (unsigned char)ch >= 0x7F ||
  60                     strchr(URL_UNSAFE_CHARS, ch) ||
  61                     (esc_extra && strchr(esc_extra, ch)) ||
  62                     (was_esc && strchr(esc_ok, ch)))
  63                         strbuf_addf(buf, "%%%02X", (unsigned char)ch);
  64                 else
  65                         strbuf_addch(buf, ch);
  66         }
  67
  68         return 1;
  69 }
  70
  71 static const char *end_of_token(const char *s, int c, size_t n)
  72 {
  73         const char *next = memchr(s, c, n);
  74         if (!next)
  75                 next = s + n;
  76         return next;
  77 }
  78
  79 static int match_host(const struct url_info *url_info,
  80                       const struct url_info *pattern_info)
  81 {
  82         const char *url = url_info->url + url_info->host_off;
  83         const char *pat = pattern_info->url + pattern_info->host_off;
  84         int url_len = url_info->host_len;
  85         int pat_len = pattern_info->host_len;
  86
  87         while (url_len && pat_len) {
  88                 const char *url_next = end_of_token(url, '.', url_len);
  89                 const char *pat_next = end_of_token(pat, '.', pat_len);
  90
  91                 if (pat_next == pat + 1 && pat[0] == '*')
  92                         /* wildcard matches anything */
  93                         ;
  94                 else if ((pat_next - pat) == (url_next - url) &&
  95                          !memcmp(url, pat, url_next - url))
  96                         /* the components are the same */
  97                         ;
  98                 else
  99                         return 0; /* found an unmatch */
 100
 101                 if (url_next < url + url_len)
 102                         url_next++;
 103                 url_len -= url_next - url;
 104                 url = url_next;
 105                 if (pat_next < pat + pat_len)
 106                         pat_next++;
 107                 pat_len -= pat_next - pat;
 108                 pat = pat_next;
 109         }
 110
 111         return (!url_len && !pat_len);
 112 }
 113
 114 static char *url_normalize_1(const char *url, struct url_info *out_info, char allow_globs)
 115 {
 116         /*
 117          * Normalize NUL-terminated url using the following rules:
 118          *
 119          * 1. Case-insensitive parts of url will be converted to lower case
 120          * 2. %-encoded characters that do not need to be will be unencoded
 121          * 3. Characters that are not %-encoded and must be will be encoded
 122          * 4. All %-encodings will be converted to upper case hexadecimal
 123          * 5. Leading 0s are removed from port numbers
 124          * 6. If the default port for the scheme is given it will be removed
 125          * 7. A path part (including empty) not starting with '/' has one added
 126          * 8. Any dot segments (. or ..) in the path are resolved and removed
 127          * 9. IPv6 host literals are allowed (but not normalized or validated)
 128          *
 129          * The rules are based on information in RFC 3986.
 130          *
 131          * Please note this function requires a full URL including a scheme
 132          * and host part (except for file: URLs which may have an empty host).
 133          *
 134          * The return value is a newly allocated string that must be freed
 135          * or NULL if the url is not valid.
 136          *
 137          * If out_info is non-NULL, the url and err fields therein will always
 138          * be set.  If a non-NULL value is returned, it will be stored in
 139          * out_info->url as well, out_info->err will be set to NULL and the
 140          * other fields of *out_info will also be filled in.  If a NULL value
 141          * is returned, NULL will be stored in out_info->url and out_info->err
 142          * will be set to a brief, translated, error message, but no other
 143          * fields will be filled in.
 144          *
 145          * This is NOT a URL validation function.  Full URL validation is NOT
 146          * performed.  Some invalid host names are passed through this function
 147          * undetected.  However, most all other problems that make a URL invalid
 148          * will be detected (including a missing host for non file: URLs).
 149          */
 150
 151         size_t url_len = strlen(url);
 152         struct strbuf norm;
 153         size_t spanned;
 154         size_t scheme_len, user_off=0, user_len=0, passwd_off=0, passwd_len=0;
 155         size_t host_off=0, host_len=0, port_off=0, port_len=0, path_off, path_len, result_len;
 156         const char *slash_ptr, *at_ptr, *colon_ptr, *path_start;
 157         char *result;
 158
 159         /*
 160          * Copy lowercased scheme and :// suffix, %-escapes are not allowed
 161          * First character of scheme must be URL_ALPHA
 162          */
 163         spanned = strspn(url, URL_SCHEME_CHARS);
 164         if (!spanned || !isalpha(url[0]) || spanned + 3 > url_len ||
 165             url[spanned] != ':' || url[spanned+1] != '/' || url[spanned+2] != '/') {
 166                 if (out_info) {
 167                         out_info->url = NULL;
 168                         out_info->err = _("invalid URL scheme name or missing '://' suffix");
 169                 }
 170                 return NULL; /* Bad scheme and/or missing "://" part */
 171         }
 172         strbuf_init(&norm, url_len);
 173         scheme_len = spanned;
 174         spanned += 3;
 175         url_len -= spanned;
 176         while (spanned--)
 177                 strbuf_addch(&norm, tolower(*url++));
 178
 179
 180         /*
 181          * Copy any username:password if present normalizing %-escapes
 182          */
 183         at_ptr = strchr(url, '@');
 184         slash_ptr = url + strcspn(url, "/?#");
 185         if (at_ptr && at_ptr < slash_ptr) {
 186                 user_off = norm.len;
 187                 if (at_ptr > url) {
 188                         if (!append_normalized_escapes(&norm, url, at_ptr - url,
 189                                                        "", URL_RESERVED)) {
 190                                 if (out_info) {
 191                                         out_info->url = NULL;
 192                                         out_info->err = _("invalid %XX escape sequence");
 193                                 }
 194                                 strbuf_release(&norm);
 195                                 return NULL;
 196                         }
 197                         colon_ptr = strchr(norm.buf + scheme_len + 3, ':');
 198                         if (colon_ptr) {
 199                                 passwd_off = (colon_ptr + 1) - norm.buf;
 200                                 passwd_len = norm.len - passwd_off;
 201                                 user_len = (passwd_off - 1) - (scheme_len + 3);
 202                         } else {
 203                                 user_len = norm.len - (scheme_len + 3);
 204                         }
 205                 }
 206                 strbuf_addch(&norm, '@');
 207                 url_len -= (++at_ptr - url);
 208                 url = at_ptr;
 209         }
 210
 211
 212         /*
 213          * Copy the host part excluding any port part, no %-escapes allowed
 214          */
 215         if (!url_len || strchr(":/?#", *url)) {
 216                 /* Missing host invalid for all URL schemes except file */
 217                 if (!starts_with(norm.buf, "file:")) {
 218                         if (out_info) {
 219                                 out_info->url = NULL;
 220                                 out_info->err = _("missing host and scheme is not 'file:'");
 221                         }
 222                         strbuf_release(&norm);
 223                         return NULL;
 224                 }
 225         } else {
 226                 host_off = norm.len;
 227         }
 228         colon_ptr = slash_ptr - 1;
 229         while (colon_ptr > url && *colon_ptr != ':' && *colon_ptr != ']')
 230                 colon_ptr--;
 231         if (*colon_ptr != ':') {
 232                 colon_ptr = slash_ptr;
 233         } else if (!host_off && colon_ptr < slash_ptr && colon_ptr + 1 != slash_ptr) {
 234                 /* file: URLs may not have a port number */
 235                 if (out_info) {
 236                         out_info->url = NULL;
 237                         out_info->err = _("a 'file:' URL may not have a port number");
 238                 }
 239                 strbuf_release(&norm);
 240                 return NULL;
 241         }
 242
 243         if (allow_globs)
 244                 spanned = strspn(url, URL_HOST_CHARS "*");
 245         else
 246                 spanned = strspn(url, URL_HOST_CHARS);
 247
 248         if (spanned < colon_ptr - url) {
 249                 /* Host name has invalid characters */
 250                 if (out_info) {
 251                         out_info->url = NULL;
 252                         out_info->err = _("invalid characters in host name");
 253                 }
 254                 strbuf_release(&norm);
 255                 return NULL;
 256         }
 257         while (url < colon_ptr) {
 258                 strbuf_addch(&norm, tolower(*url++));
 259                 url_len--;
 260         }
 261
 262
 263         /*
 264          * Check the port part and copy if not the default (after removing any
 265          * leading 0s); no %-escapes allowed
 266          */
 267         if (colon_ptr < slash_ptr) {
 268                 /* skip the ':' and leading 0s but not the last one if all 0s */
 269                 url++;
 270                 url += strspn(url, "0");
 271                 if (url == slash_ptr && url[-1] == '0')
 272                         url--;
 273                 if (url == slash_ptr) {
 274                         /* Skip ":" port with no number, it's same as default */
 275                 } else if (slash_ptr - url == 2 &&
 276                            starts_with(norm.buf, "http:") &&
 277                            !strncmp(url, "80", 2)) {
 278                         /* Skip http :80 as it's the default */
 279                 } else if (slash_ptr - url == 3 &&
 280                            starts_with(norm.buf, "https:") &&
 281                            !strncmp(url, "443", 3)) {
 282                         /* Skip https :443 as it's the default */
 283                 } else {
 284                         /*
 285                          * Port number must be all digits with leading 0s removed
 286                          * and since all the protocols we deal with have a 16-bit
 287                          * port number it must also be in the range 1..65535
 288                          * 0 is not allowed because that means "next available"
 289                          * on just about every system and therefore cannot be used
 290                          */
 291                         unsigned long pnum = 0;
 292                         spanned = strspn(url, URL_DIGIT);
 293                         if (spanned < slash_ptr - url) {
 294                                 /* port number has invalid characters */
 295                                 if (out_info) {
 296                                         out_info->url = NULL;
 297                                         out_info->err = _("invalid port number");
 298                                 }
 299                                 strbuf_release(&norm);
 300                                 return NULL;
 301                         }
 302                         if (slash_ptr - url <= 5)
 303                                 pnum = strtoul(url, NULL, 10);
 304                         if (pnum == 0 || pnum > 65535) {
 305                                 /* port number not in range 1..65535 */
 306                                 if (out_info) {
 307                                         out_info->url = NULL;
 308                                         out_info->err = _("invalid port number");
 309                                 }
 310                                 strbuf_release(&norm);
 311                                 return NULL;
 312                         }
 313                         strbuf_addch(&norm, ':');
 314                         port_off = norm.len;
 315                         strbuf_add(&norm, url, slash_ptr - url);
 316                         port_len = slash_ptr - url;
 317                 }
 318                 url_len -= slash_ptr - colon_ptr;
 319                 url = slash_ptr;
 320         }
 321         if (host_off)
 322                 host_len = norm.len - host_off - (port_len ? port_len + 1 : 0);
 323
 324
 325         /*
 326          * Now copy the path resolving any . and .. segments being careful not
 327          * to corrupt the URL by unescaping any delimiters, but do add an
 328          * initial '/' if it's missing and do normalize any %-escape sequences.
 329          */
 330         path_off = norm.len;
 331         path_start = norm.buf + path_off;
 332         strbuf_addch(&norm, '/');
 333         if (*url == '/') {
 334                 url++;
 335                 url_len--;
 336         }
 337         for (;;) {
 338                 const char *seg_start;
 339                 size_t seg_start_off = norm.len;
 340                 const char *next_slash = url + strcspn(url, "/?#");
 341                 int skip_add_slash = 0;
 342
 343                 /*
 344                  * RFC 3689 indicates that any . or .. segments should be
 345                  * unescaped before being checked for.
 346                  */
 347                 if (!append_normalized_escapes(&norm, url, next_slash - url, "",
 348                                                URL_RESERVED)) {
 349                         if (out_info) {
 350                                 out_info->url = NULL;
 351                                 out_info->err = _("invalid %XX escape sequence");
 352                         }
 353                         strbuf_release(&norm);
 354                         return NULL;
 355                 }
 356
 357                 seg_start = norm.buf + seg_start_off;
 358                 if (!strcmp(seg_start, ".")) {
 359                         /* ignore a . segment; be careful not to remove initial '/' */
 360                         if (seg_start == path_start + 1) {
 361                                 strbuf_setlen(&norm, norm.len - 1);
 362                                 skip_add_slash = 1;
 363                         } else {
 364                                 strbuf_setlen(&norm, norm.len - 2);
 365                         }
 366                 } else if (!strcmp(seg_start, "..")) {
 367                         /*
 368                          * ignore a .. segment and remove the previous segment;
 369                          * be careful not to remove initial '/' from path
 370                          */
 371                         const char *prev_slash = norm.buf + norm.len - 3;
 372                         if (prev_slash == path_start) {
 373                                 /* invalid .. because no previous segment to remove */
 374                                 if (out_info) {
 375                                         out_info->url = NULL;
 376                                         out_info->err = _("invalid '..' path segment");
 377                                 }
 378                                 strbuf_release(&norm);
 379                                 return NULL;
 380                         }
 381                         while (*--prev_slash != '/') {}
 382                         if (prev_slash == path_start) {
 383                                 strbuf_setlen(&norm, prev_slash - norm.buf + 1);
 384                                 skip_add_slash = 1;
 385                         } else {
 386                                 strbuf_setlen(&norm, prev_slash - norm.buf);
 387                         }
 388                 }
 389                 url_len -= next_slash - url;
 390                 url = next_slash;
 391                 /* if the next char is not '/' done with the path */
 392                 if (*url != '/')
 393                         break;
 394                 url++;
 395                 url_len--;
 396                 if (!skip_add_slash)
 397                         strbuf_addch(&norm, '/');
 398         }
 399         path_len = norm.len - path_off;
 400
 401
 402         /*
 403          * Now simply copy the rest, if any, only normalizing %-escapes and
 404          * being careful not to corrupt the URL by unescaping any delimiters.
 405          */
 406         if (*url) {
 407                 if (!append_normalized_escapes(&norm, url, url_len, "", URL_RESERVED)) {
 408                         if (out_info) {
 409                                 out_info->url = NULL;
 410                                 out_info->err = _("invalid %XX escape sequence");
 411                         }
 412                         strbuf_release(&norm);
 413                         return NULL;
 414                 }
 415         }
 416
 417
 418         result = strbuf_detach(&norm, &result_len);
 419         if (out_info) {
 420                 out_info->url = result;
 421                 out_info->err = NULL;
 422                 out_info->url_len = result_len;
 423                 out_info->scheme_len = scheme_len;
 424                 out_info->user_off = user_off;
 425                 out_info->user_len = user_len;
 426                 out_info->passwd_off = passwd_off;
 427                 out_info->passwd_len = passwd_len;
 428                 out_info->host_off = host_off;
 429                 out_info->host_len = host_len;
 430                 out_info->port_off = port_off;
 431                 out_info->port_len = port_len;
 432                 out_info->path_off = path_off;
 433                 out_info->path_len = path_len;
 434         }
 435         return result;
 436 }
 437
 438 char *url_normalize(const char *url, struct url_info *out_info)
 439 {
 440         return url_normalize_1(url, out_info, 0);
 441 }
 442
 443 static size_t url_match_prefix(const char *url,
 444                                const char *url_prefix,
 445                                size_t url_prefix_len)
 446 {
 447         /*
 448          * url_prefix matches url if url_prefix is an exact match for url or it
 449          * is a prefix of url and the match ends on a path component boundary.
 450          * Both url and url_prefix are considered to have an implicit '/' on the
 451          * end for matching purposes if they do not already.
 452          *
 453          * url must be NUL terminated.  url_prefix_len is the length of
 454          * url_prefix which need not be NUL terminated.
 455          *
 456          * The return value is the length of the match in characters (including
 457          * the final '/' even if it's implicit) or 0 for no match.
 458          *
 459          * Passing NULL as url and/or url_prefix will always cause 0 to be
 460          * returned without causing any faults.
 461          */
 462         if (!url || !url_prefix)
 463                 return 0;
 464         if (!url_prefix_len || (url_prefix_len == 1 && *url_prefix == '/'))
 465                 return (!*url || *url == '/') ? 1 : 0;
 466         if (url_prefix[url_prefix_len - 1] == '/')
 467                 url_prefix_len--;
 468         if (strncmp(url, url_prefix, url_prefix_len))
 469                 return 0;
 470         if ((strlen(url) == url_prefix_len) || (url[url_prefix_len] == '/'))
 471                 return url_prefix_len + 1;
 472         return 0;
 473 }
 474
 475 static int match_urls(const struct url_info *url,
 476                       const struct url_info *url_prefix,
 477                       struct urlmatch_item *match)
 478 {
 479         /*
 480          * url_prefix matches url if the scheme, host and port of url_prefix
 481          * are the same as those of url and the path portion of url_prefix
 482          * is the same as the path portion of url or it is a prefix that
 483          * matches at a '/' boundary.  If url_prefix contains a user name,
 484          * that must also exactly match the user name in url.
 485          *
 486          * If the user, host, port and path match in this fashion, the returned
 487          * value is the length of the path match including any implicit
 488          * final '/'.  For example, "http://me@example.com/path" is matched by
 489          * "http://example.com" with a path length of 1.
 490          *
 491          * If there is a match and exactusermatch is not NULL, then
 492          * *exactusermatch will be set to true if both url and url_prefix
 493          * contained a user name or false if url_prefix did not have a
 494          * user name.  If there is no match *exactusermatch is left untouched.
 495          */
 496         char usermatched = 0;
 497         size_t pathmatchlen;
 498
 499         if (!url || !url_prefix || !url->url || !url_prefix->url)
 500                 return 0;
 501
 502         /* check the scheme */
 503         if (url_prefix->scheme_len != url->scheme_len ||
 504             strncmp(url->url, url_prefix->url, url->scheme_len))
 505                 return 0; /* schemes do not match */
 506
 507         /* check the user name if url_prefix has one */
 508         if (url_prefix->user_off) {
 509                 if (!url->user_off || url->user_len != url_prefix->user_len ||
 510                     strncmp(url->url + url->user_off,
 511                             url_prefix->url + url_prefix->user_off,
 512                             url->user_len))
 513                         return 0; /* url_prefix has a user but it's not a match */
 514                 usermatched = 1;
 515         }
 516
 517         /* check the host */
 518         if (!match_host(url, url_prefix))
 519                 return 0; /* host names do not match */
 520
 521         /* check the port */
 522         if (url_prefix->port_len != url->port_len ||
 523             strncmp(url->url + url->port_off,
 524                     url_prefix->url + url_prefix->port_off, url->port_len))
 525                 return 0; /* ports do not match */
 526
 527         /* check the path */
 528         pathmatchlen = url_match_prefix(
 529                 url->url + url->path_off,
 530                 url_prefix->url + url_prefix->path_off,
 531                 url_prefix->url_len - url_prefix->path_off);
 532         if (!pathmatchlen)
 533                 return 0; /* paths do not match */
 534
 535         if (match) {
 536                 match->hostmatch_len = url_prefix->host_len;
 537                 match->pathmatch_len = pathmatchlen;
 538                 match->user_matched = usermatched;
 539         }
 540
 541         return 1;
 542 }
 543
 544 static int cmp_matches(const struct urlmatch_item *a,
 545                        const struct urlmatch_item *b)
 546 {
 547         if (a->hostmatch_len != b->hostmatch_len)
 548                 return a->hostmatch_len < b->hostmatch_len ? -1 : 1;
 549         if (a->pathmatch_len != b->pathmatch_len)
 550                 return a->pathmatch_len < b->pathmatch_len ? -1 : 1;
 551         if (a->user_matched != b->user_matched)
 552                 return b->user_matched ? -1 : 1;
 553         return 0;
 554 }
 555
 556 int urlmatch_config_entry(const char *var, const char *value,
 557                           const struct config_context *ctx, void *cb)
 558 {
 559         struct string_list_item *item;
 560         struct urlmatch_config *collect = cb;
 561         struct urlmatch_item matched = {0};
 562         struct url_info *url = &collect->url;
 563         const char *key, *dot;
 564         struct strbuf synthkey = STRBUF_INIT;
 565         int retval;
 566         int (*select_fn)(const struct urlmatch_item *a, const struct urlmatch_item *b) =
 567                 collect->select_fn ? collect->select_fn : cmp_matches;
 568
 569         if (!skip_prefix(var, collect->section, &key) || *(key++) != '.') {
 570                 if (collect->cascade_fn)
 571                         return collect->cascade_fn(var, value, ctx, cb);
 572                 return 0; /* not interested */
 573         }
 574         dot = strrchr(key, '.');
 575         if (dot) {
 576                 char *config_url, *norm_url;
 577                 struct url_info norm_info;
 578
 579                 config_url = xmemdupz(key, dot - key);
 580                 norm_url = url_normalize_1(config_url, &norm_info, 1);
 581                 if (norm_url)
 582                         retval = match_urls(url, &norm_info, &matched);
 583                 else if (collect->fallback_match_fn)
 584                         retval = collect->fallback_match_fn(config_url,
 585                                                             collect->cb);
 586                 else
 587                         retval = 0;
 588                 free(config_url);
 589                 free(norm_url);
 590                 if (!retval)
 591                         return 0;
 592                 key = dot + 1;
 593         }
 594
 595         if (collect->key && strcmp(key, collect->key))
 596                 return 0;
 597
 598         item = string_list_insert(&collect->vars, key);
 599         if (!item->util) {
 600                 item->util = xcalloc(1, sizeof(matched));
 601         } else {
 602                 if (select_fn(&matched, item->util) < 0)
 603                          /*
 604                           * Our match is worse than the old one,
 605                           * we cannot use it.
 606                           */
 607                         return 0;
 608                 /* Otherwise, replace it with this one. */
 609         }
 610
 611         memcpy(item->util, &matched, sizeof(matched));
 612         strbuf_addstr(&synthkey, collect->section);
 613         strbuf_addch(&synthkey, '.');
 614         strbuf_addstr(&synthkey, key);
 615         retval = collect->collect_fn(synthkey.buf, value, ctx, collect->cb);
 616
 617         strbuf_release(&synthkey);
 618         return retval;
 619 }
 620
 621 void urlmatch_config_release(struct urlmatch_config *config)
 622 {
 623         string_list_clear(&config->vars, 1);
 624 }