gotwebd/parse.y

   1 /*
   2  * Copyright (c) 2016-2019, 2020-2021 Tracey Emery <tracey@traceyemery.net>
   3  * Copyright (c) 2004, 2005 Esben Norby <norby@openbsd.org>
   4  * Copyright (c) 2004 Ryan McBride <mcbride@openbsd.org>
   5  * Copyright (c) 2002, 2003, 2004 Henning Brauer <henning@openbsd.org>
   6  * Copyright (c) 2001 Markus Friedl.  All rights reserved.
   7  * Copyright (c) 2001 Daniel Hartmeier.  All rights reserved.
   8  * Copyright (c) 2001 Theo de Raadt.  All rights reserved.
   9  *
  10  * Permission to use, copy, modify, and distribute this software for any
  11  * purpose with or without fee is hereby granted, provided that the above
  12  * copyright notice and this permission notice appear in all copies.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  15  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  16  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  17  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  18  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  19  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  20  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  21  */
  22
  23 %{
  24 #include "got_compat.h"
  25
  26 #include <sys/ioctl.h>
  27 #include <sys/types.h>
  28 #include <sys/queue.h>
  29 #include <sys/socket.h>
  30 #include <sys/stat.h>
  31
  32 #include <net/if.h>
  33 #include <netinet/in.h>
  34
  35 #include <arpa/inet.h>
  36
  37 #include <ctype.h>
  38 #include <err.h>
  39 #include <errno.h>
  40 #include <event.h>
  41 #include <ifaddrs.h>
  42 #include <limits.h>
  43 #include <netdb.h>
  44 #include <stdarg.h>
  45 #include <stdlib.h>
  46 #include <stdio.h>
  47 #include <string.h>
  48 #include <syslog.h>
  49 #include <unistd.h>
  50
  51 #include "got_sockaddr.h"
  52 #include "got_reference.h"
  53
  54 #include "proc.h"
  55 #include "gotwebd.h"
  56
  57 TAILQ_HEAD(files, file)          files = TAILQ_HEAD_INITIALIZER(files);
  58 static struct file {
  59         TAILQ_ENTRY(file)        entry;
  60         FILE                    *stream;
  61         char                    *name;
  62         int                      lineno;
  63         int                      errors;
  64 } *file;
  65 struct file     *newfile(const char *, int);
  66 static void      closefile(struct file *);
  67 int              check_file_secrecy(int, const char *);
  68 int              yyparse(void);
  69 int              yylex(void);
  70 int              yyerror(const char *, ...)
  71     __attribute__((__format__ (printf, 1, 2)))
  72     __attribute__((__nonnull__ (1)));
  73 int              kw_cmp(const void *, const void *);
  74 int              lookup(char *);
  75 int              lgetc(int);
  76 int              lungetc(int);
  77 int              findeol(void);
  78
  79 TAILQ_HEAD(symhead, sym)         symhead = TAILQ_HEAD_INITIALIZER(symhead);
  80 struct sym {
  81         TAILQ_ENTRY(sym)         entry;
  82         int                      used;
  83         int                      persist;
  84         char                    *nam;
  85         char                    *val;
  86 };
  87
  88 int      symset(const char *, const char *, int);
  89 char    *symget(const char *);
  90
  91 static int               errors;
  92
  93 static struct gotwebd           *gotwebd;
  94 static struct server            *new_srv;
  95 static struct server            *conf_new_server(const char *);
  96 int                              getservice(const char *);
  97 int                              n;
  98
  99 int              get_addrs(const char *, struct server *, in_port_t);
 100 int              addr_dup_check(struct addresslist *, struct address *,
 101                     const char *, const char *);
 102 int              add_addr(struct server *, struct address *);
 103 struct address  *host_v4(const char *);
 104 struct address  *host_v6(const char *);
 105 int              host_dns(const char *, struct server *,
 106                     int, in_port_t, const char *, int);
 107 int              host_if(const char *, struct server *,
 108                     int, in_port_t, const char *, int);
 109 int              host(const char *, struct server *,
 110                     int, in_port_t, const char *, int);
 111 int              is_if_in_group(const char *, const char *);
 112
 113 typedef struct {
 114         union {
 115                 long long        number;
 116                 char            *string;
 117                 in_port_t        port;
 118         } v;
 119         int lineno;
 120 } YYSTYPE;
 121
 122 %}
 123
 124 %token  LISTEN WWW_PATH MAX_REPOS SITE_NAME SITE_OWNER SITE_LINK LOGO
 125 %token  LOGO_URL SHOW_REPO_OWNER SHOW_REPO_AGE SHOW_REPO_DESCRIPTION
 126 %token  MAX_REPOS_DISPLAY REPOS_PATH MAX_COMMITS_DISPLAY ON ERROR
 127 %token  SHOW_SITE_OWNER SHOW_REPO_CLONEURL PORT PREFORK RESPECT_EXPORTOK
 128 %token  UNIX_SOCKET UNIX_SOCKET_NAME SERVER CHROOT CUSTOM_CSS SOCKET
 129
 130 %token  <v.string>      STRING
 131 %type   <v.port>        fcgiport
 132 %token  <v.number>      NUMBER
 133 %type   <v.number>      boolean
 134
 135 %%
 136
 137 grammar         : /* empty */
 138                 | grammar '\n'
 139                 | grammar varset '\n'
 140                 | grammar main '\n'
 141                 | grammar server '\n'
 142                 | grammar error '\n'            { file->errors++; }
 143                 ;
 144
 145 varset          : STRING '=' STRING     {
 146                         char *s = $1;
 147                         while (*s++) {
 148                                 if (isspace((unsigned char)*s)) {
 149                                         yyerror("macro name cannot contain "
 150                                             "whitespace");
 151                                         free($1);
 152                                         free($3);
 153                                         YYERROR;
 154                                 }
 155                         }
 156                         if (symset($1, $3, 0) == -1)
 157                                 fatal("cannot store variable");
 158                         free($1);
 159                         free($3);
 160                 }
 161                 ;
 162
 163 boolean         : STRING {
 164                         if (strcasecmp($1, "1") == 0 ||
 165                             strcasecmp($1, "yes") == 0 ||
 166                             strcasecmp($1, "on") == 0)
 167                                 $$ = 1;
 168                         else if (strcasecmp($1, "0") == 0 ||
 169                             strcasecmp($1, "off") == 0 ||
 170                             strcasecmp($1, "no") == 0)
 171                                 $$ = 0;
 172                         else {
 173                                 yyerror("invalid boolean value '%s'", $1);
 174                                 free($1);
 175                                 YYERROR;
 176                         }
 177                         free($1);
 178                 }
 179                 | ON { $$ = 1; }
 180                 | NUMBER { $$ = $1; }
 181                 ;
 182
 183 fcgiport        : PORT NUMBER {
 184                         if ($2 <= 0 || $2 > (int)USHRT_MAX) {
 185                                 yyerror("invalid port: %lld", $2);
 186                                 YYERROR;
 187                         }
 188                         $$ = $2;
 189                 }
 190                 | PORT STRING {
 191                         int      val;
 192
 193                         if ((val = getservice($2)) == -1) {
 194                                 yyerror("invalid port: %s", $2);
 195                                 free($2);
 196                                 YYERROR;
 197                         }
 198                         free($2);
 199
 200                         $$ = val;
 201                 }
 202                 ;
 203
 204 main            : PREFORK NUMBER {
 205                         gotwebd->prefork_gotwebd = $2;
 206                 }
 207                 | CHROOT STRING {
 208                         n = strlcpy(gotwebd->httpd_chroot, $2,
 209                             sizeof(gotwebd->httpd_chroot));
 210                         if (n >= sizeof(gotwebd->httpd_chroot)) {
 211                                 yyerror("%s: httpd_chroot truncated", __func__);
 212                                 free($2);
 213                                 YYERROR;
 214                         }
 215                         free($2);
 216                 }
 217                 | UNIX_SOCKET boolean {
 218                         gotwebd->unix_socket = $2;
 219                 }
 220                 | UNIX_SOCKET_NAME STRING {
 221                         n = snprintf(gotwebd->unix_socket_name,
 222                             sizeof(gotwebd->unix_socket_name), "%s%s",
 223                             strlen(gotwebd->httpd_chroot) ?
 224                             gotwebd->httpd_chroot : D_HTTPD_CHROOT, $2);
 225                         if (n < 0 ||
 226                             (size_t)n >= sizeof(gotwebd->unix_socket_name)) {
 227                                 yyerror("%s: unix_socket_name truncated",
 228                                     __func__);
 229                                 free($2);
 230                                 YYERROR;
 231                         }
 232                         free($2);
 233                 }
 234                 ;
 235
 236 server          : SERVER STRING {
 237                         struct server *srv;
 238
 239                         TAILQ_FOREACH(srv, &gotwebd->servers, entry) {
 240                                 if (strcmp(srv->name, $2) == 0) {
 241                                         yyerror("server name exists '%s'", $2);
 242                                         free($2);
 243                                         YYERROR;
 244                                 }
 245                         }
 246
 247                         new_srv = conf_new_server($2);
 248                         log_debug("adding server %s", $2);
 249                         free($2);
 250                 }
 251                 | SERVER STRING {
 252                         struct server *srv;
 253
 254                         TAILQ_FOREACH(srv, &gotwebd->servers, entry) {
 255                                 if (strcmp(srv->name, $2) == 0) {
 256                                         yyerror("server name exists '%s'", $2);
 257                                         free($2);
 258                                         YYERROR;
 259                                 }
 260                         }
 261
 262                         new_srv = conf_new_server($2);
 263                         log_debug("adding server %s", $2);
 264                         free($2);
 265                 } '{' optnl serveropts2 '}' {
 266                 }
 267                 ;
 268
 269 serveropts1     : REPOS_PATH STRING {
 270                         n = strlcpy(new_srv->repos_path, $2,
 271                             sizeof(new_srv->repos_path));
 272                         if (n >= sizeof(new_srv->repos_path)) {
 273                                 yyerror("%s: repos_path truncated", __func__);
 274                                 free($2);
 275                                 YYERROR;
 276                         }
 277                         free($2);
 278                 }
 279                 | SITE_NAME STRING {
 280                         n = strlcpy(new_srv->site_name, $2,
 281                             sizeof(new_srv->site_name));
 282                         if (n >= sizeof(new_srv->site_name)) {
 283                                 yyerror("%s: site_name truncated", __func__);
 284                                 free($2);
 285                                 YYERROR;
 286                         }
 287                         free($2);
 288                 }
 289                 | SITE_OWNER STRING {
 290                         n = strlcpy(new_srv->site_owner, $2,
 291                             sizeof(new_srv->site_owner));
 292                         if (n >= sizeof(new_srv->site_owner)) {
 293                                 yyerror("%s: site_owner truncated", __func__);
 294                                 free($2);
 295                                 YYERROR;
 296                         }
 297                         free($2);
 298                 }
 299                 | SITE_LINK STRING {
 300                         n = strlcpy(new_srv->site_link, $2,
 301                             sizeof(new_srv->site_link));
 302                         if (n >= sizeof(new_srv->site_link)) {
 303                                 yyerror("%s: site_link truncated", __func__);
 304                                 free($2);
 305                                 YYERROR;
 306                         }
 307                         free($2);
 308                 }
 309                 | LOGO STRING {
 310                         n = strlcpy(new_srv->logo, $2, sizeof(new_srv->logo));
 311                         if (n >= sizeof(new_srv->logo)) {
 312                                 yyerror("%s: logo truncated", __func__);
 313                                 free($2);
 314                                 YYERROR;
 315                         }
 316                         free($2);
 317                 }
 318                 | LOGO_URL STRING {
 319                         n = strlcpy(new_srv->logo_url, $2,
 320                             sizeof(new_srv->logo_url));
 321                         if (n >= sizeof(new_srv->logo_url)) {
 322                                 yyerror("%s: logo_url truncated", __func__);
 323                                 free($2);
 324                                 YYERROR;
 325                         }
 326                         free($2);
 327                 }
 328                 | CUSTOM_CSS STRING {
 329                         n = strlcpy(new_srv->custom_css, $2,
 330                             sizeof(new_srv->custom_css));
 331                         if (n >= sizeof(new_srv->custom_css)) {
 332                                 yyerror("%s: custom_css truncated", __func__);
 333                                 free($2);
 334                                 YYERROR;
 335                         }
 336                         free($2);
 337                 }
 338                 | LISTEN ON STRING fcgiport {
 339                         if (get_addrs($3, new_srv, $4) == -1) {
 340                                 yyerror("could not get addrs");
 341                                 YYERROR;
 342                         }
 343                         new_srv->fcgi_socket = 1;
 344                 }
 345                 | LISTEN ON SOCKET STRING {
 346                         if (!strcasecmp($4, "off") ||
 347                             !strcasecmp($4, "no")) {
 348                                 new_srv->unix_socket = 0;
 349                                 free($4);
 350                                 YYACCEPT;
 351                         }
 352
 353                         new_srv->unix_socket = 1;
 354
 355                         n = snprintf(new_srv->unix_socket_name,
 356                             sizeof(new_srv->unix_socket_name), "%s%s",
 357                             strlen(gotwebd->httpd_chroot) ?
 358                             gotwebd->httpd_chroot : D_HTTPD_CHROOT, $4);
 359                         if (n < 0 ||
 360                             (size_t)n >= sizeof(new_srv->unix_socket_name)) {
 361                                 yyerror("%s: unix_socket_name truncated",
 362                                     __func__);
 363                                 free($4);
 364                                 YYERROR;
 365                         }
 366                         free($4);
 367                 }
 368                 | MAX_REPOS NUMBER {
 369                         if ($2 > 0)
 370                                 new_srv->max_repos = $2;
 371                 }
 372                 | SHOW_SITE_OWNER boolean {
 373                         new_srv->show_site_owner = $2;
 374                 }
 375                 | SHOW_REPO_OWNER boolean {
 376                         new_srv->show_repo_owner = $2;
 377                 }
 378                 | SHOW_REPO_AGE boolean {
 379                         new_srv->show_repo_age = $2;
 380                 }
 381                 | SHOW_REPO_DESCRIPTION boolean {
 382                         new_srv->show_repo_description = $2;
 383                 }
 384                 | SHOW_REPO_CLONEURL boolean {
 385                         new_srv->show_repo_cloneurl = $2;
 386                 }
 387                 | RESPECT_EXPORTOK boolean {
 388                         new_srv->respect_exportok = $2;
 389                 }
 390                 | MAX_REPOS_DISPLAY NUMBER {
 391                                 new_srv->max_repos_display = $2;
 392                 }
 393                 | MAX_COMMITS_DISPLAY NUMBER {
 394                         if ($2 > 0)
 395                                 new_srv->max_commits_display = $2;
 396                 }
 397                 ;
 398
 399 serveropts2     : serveropts2 serveropts1 nl
 400                 | serveropts1 optnl
 401                 ;
 402
 403 nl              : '\n' optnl
 404                 ;
 405
 406 optnl           : '\n' optnl            /* zero or more newlines */
 407                 | /* empty */
 408                 ;
 409
 410 %%
 411
 412 struct keywords {
 413         const char      *k_name;
 414         int              k_val;
 415 };
 416
 417 int
 418 yyerror(const char *fmt, ...)
 419 {
 420         va_list ap;
 421         char *msg;
 422
 423         file->errors++;
 424         va_start(ap, fmt);
 425         if (vasprintf(&msg, fmt, ap) == -1)
 426                 fatalx("yyerror vasprintf");
 427         va_end(ap);
 428         logit(LOG_CRIT, "%s:%d: %s", file->name, yylval.lineno, msg);
 429         free(msg);
 430         return (0);
 431 }
 432
 433 int
 434 kw_cmp(const void *k, const void *e)
 435 {
 436         return (strcmp(k, ((const struct keywords *)e)->k_name));
 437 }
 438
 439 int
 440 lookup(char *s)
 441 {
 442         /* This has to be sorted always. */
 443         static const struct keywords keywords[] = {
 444                 { "chroot",                     CHROOT },
 445                 { "custom_css",                 CUSTOM_CSS },
 446                 { "listen",                     LISTEN },
 447                 { "logo",                       LOGO },
 448                 { "logo_url",                   LOGO_URL },
 449                 { "max_commits_display",        MAX_COMMITS_DISPLAY },
 450                 { "max_repos",                  MAX_REPOS },
 451                 { "max_repos_display",          MAX_REPOS_DISPLAY },
 452                 { "on",                         ON },
 453                 { "port",                       PORT },
 454                 { "prefork",                    PREFORK },
 455                 { "repos_path",                 REPOS_PATH },
 456                 { "respect_exportok",           RESPECT_EXPORTOK },
 457                 { "server",                     SERVER },
 458                 { "show_repo_age",              SHOW_REPO_AGE },
 459                 { "show_repo_cloneurl",         SHOW_REPO_CLONEURL },
 460                 { "show_repo_description",      SHOW_REPO_DESCRIPTION },
 461                 { "show_repo_owner",            SHOW_REPO_OWNER },
 462                 { "show_site_owner",            SHOW_SITE_OWNER },
 463                 { "site_link",                  SITE_LINK },
 464                 { "site_name",                  SITE_NAME },
 465                 { "site_owner",                 SITE_OWNER },
 466                 { "socket",                     SOCKET },
 467                 { "unix_socket",                UNIX_SOCKET },
 468                 { "unix_socket_name",           UNIX_SOCKET_NAME },
 469         };
 470         const struct keywords *p;
 471
 472         p = bsearch(s, keywords, sizeof(keywords)/sizeof(keywords[0]),
 473             sizeof(keywords[0]), kw_cmp);
 474
 475         if (p)
 476                 return (p->k_val);
 477         else
 478                 return (STRING);
 479 }
 480
 481 #define MAXPUSHBACK     128
 482
 483 unsigned char *parsebuf;
 484 int parseindex;
 485 unsigned char pushback_buffer[MAXPUSHBACK];
 486 int pushback_index = 0;
 487
 488 int
 489 lgetc(int quotec)
 490 {
 491         int c, next;
 492
 493         if (parsebuf) {
 494                 /* Read character from the parsebuffer instead of input. */
 495                 if (parseindex >= 0) {
 496                         c = parsebuf[parseindex++];
 497                         if (c != '\0')
 498                                 return (c);
 499                         parsebuf = NULL;
 500                 } else
 501                         parseindex++;
 502         }
 503
 504         if (pushback_index)
 505                 return (pushback_buffer[--pushback_index]);
 506
 507         if (quotec) {
 508                 c = getc(file->stream);
 509                 if (c == EOF)
 510                         yyerror("reached end of file while parsing "
 511                             "quoted string");
 512                 return (c);
 513         }
 514
 515         c = getc(file->stream);
 516         while (c == '\\') {
 517                 next = getc(file->stream);
 518                 if (next != '\n') {
 519                         c = next;
 520                         break;
 521                 }
 522                 yylval.lineno = file->lineno;
 523                 file->lineno++;
 524                 c = getc(file->stream);
 525         }
 526
 527         return (c);
 528 }
 529
 530 int
 531 lungetc(int c)
 532 {
 533         if (c == EOF)
 534                 return (EOF);
 535         if (parsebuf) {
 536                 parseindex--;
 537                 if (parseindex >= 0)
 538                         return (c);
 539         }
 540         if (pushback_index < MAXPUSHBACK-1)
 541                 return (pushback_buffer[pushback_index++] = c);
 542         else
 543                 return (EOF);
 544 }
 545
 546 int
 547 findeol(void)
 548 {
 549         int c;
 550
 551         parsebuf = NULL;
 552
 553         /* Skip to either EOF or the first real EOL. */
 554         while (1) {
 555                 if (pushback_index)
 556                         c = pushback_buffer[--pushback_index];
 557                 else
 558                         c = lgetc(0);
 559                 if (c == '\n') {
 560                         file->lineno++;
 561                         break;
 562                 }
 563                 if (c == EOF)
 564                         break;
 565         }
 566         return (ERROR);
 567 }
 568
 569 int
 570 yylex(void)
 571 {
 572         unsigned char buf[8096];
 573         unsigned char *p, *val;
 574         int quotec, next, c;
 575         int token;
 576
 577 top:
 578         p = buf;
 579         c = lgetc(0);
 580         while (c == ' ' || c == '\t')
 581                 c = lgetc(0); /* nothing */
 582
 583         yylval.lineno = file->lineno;
 584         if (c == '#') {
 585                 c = lgetc(0);
 586                 while (c != '\n' && c != EOF)
 587                         c = lgetc(0); /* nothing */
 588         }
 589         if (c == '$' && parsebuf == NULL) {
 590                 while (1) {
 591                         c = lgetc(0);
 592                         if (c == EOF)
 593                                 return (0);
 594
 595                         if (p + 1 >= buf + sizeof(buf) - 1) {
 596                                 yyerror("string too long");
 597                                 return (findeol());
 598                         }
 599                         if (isalnum(c) || c == '_') {
 600                                 *p++ = c;
 601                                 continue;
 602                         }
 603                         *p = '\0';
 604                         lungetc(c);
 605                         break;
 606                 }
 607                 val = symget(buf);
 608                 if (val == NULL) {
 609                         yyerror("macro '%s' not defined", buf);
 610                         return (findeol());
 611                 }
 612                 parsebuf = val;
 613                 parseindex = 0;
 614                 goto top;
 615         }
 616
 617         switch (c) {
 618         case '\'':
 619         case '"':
 620                 quotec = c;
 621                 while (1) {
 622                         c = lgetc(quotec);
 623                         if (c == EOF)
 624                                 return (0);
 625                         if (c == '\n') {
 626                                 file->lineno++;
 627                                 continue;
 628                         } else if (c == '\\') {
 629                                 next = lgetc(quotec);
 630                                 if (next == EOF)
 631                                         return (0);
 632                                 if (next == quotec || c == ' ' || c == '\t')
 633                                         c = next;
 634                                 else if (next == '\n') {
 635                                         file->lineno++;
 636                                         continue;
 637                                 } else
 638                                         lungetc(next);
 639                         } else if (c == quotec) {
 640                                 *p = '\0';
 641                                 break;
 642                         } else if (c == '\0') {
 643                                 yyerror("syntax error");
 644                                 return (findeol());
 645                         }
 646                         if (p + 1 >= buf + sizeof(buf) - 1) {
 647                                 yyerror("string too long");
 648                                 return (findeol());
 649                         }
 650                         *p++ = c;
 651                 }
 652                 yylval.v.string = strdup(buf);
 653                 if (yylval.v.string == NULL)
 654                         err(1, "yylex: strdup");
 655                 return (STRING);
 656         }
 657
 658 #define allowed_to_end_number(x) \
 659         (isspace(x) || x == ')' || x ==',' || x == '/' || x == '}' || x == '=')
 660
 661         if (c == '-' || isdigit(c)) {
 662                 do {
 663                         *p++ = c;
 664                         if ((unsigned)(p-buf) >= sizeof(buf)) {
 665                                 yyerror("string too long");
 666                                 return (findeol());
 667                         }
 668                         c = lgetc(0);
 669                 } while (c != EOF && isdigit(c));
 670                 lungetc(c);
 671                 if (p == buf + 1 && buf[0] == '-')
 672                         goto nodigits;
 673                 if (c == EOF || allowed_to_end_number(c)) {
 674                         const char *errstr = NULL;
 675
 676                         *p = '\0';
 677                         yylval.v.number = strtonum(buf, LLONG_MIN,
 678                             LLONG_MAX, &errstr);
 679                         if (errstr) {
 680                                 yyerror("\"%s\" invalid number: %s",
 681                                     buf, errstr);
 682                                 return (findeol());
 683                         }
 684                         return (NUMBER);
 685                 } else {
 686 nodigits:
 687                         while (p > buf + 1)
 688                                 lungetc(*--p);
 689                         c = *--p;
 690                         if (c == '-')
 691                                 return (c);
 692                 }
 693         }
 694
 695 #define allowed_in_string(x) \
 696         (isalnum(x) || (ispunct(x) && x != '(' && x != ')' && \
 697         x != '{' && x != '}' && \
 698         x != '!' && x != '=' && x != '#' && \
 699         x != ','))
 700
 701         if (isalnum(c) || c == ':' || c == '_') {
 702                 do {
 703                         *p++ = c;
 704                         if ((unsigned)(p-buf) >= sizeof(buf)) {
 705                                 yyerror("string too long");
 706                                 return (findeol());
 707                         }
 708                         c = lgetc(0);
 709                 } while (c != EOF && (allowed_in_string(c)));
 710                 lungetc(c);
 711                 *p = '\0';
 712                 token = lookup(buf);
 713                 if (token == STRING) {
 714                         yylval.v.string = strdup(buf);
 715                         if (yylval.v.string == NULL)
 716                                 err(1, "yylex: strdup");
 717                 }
 718                 return (token);
 719         }
 720         if (c == '\n') {
 721                 yylval.lineno = file->lineno;
 722                 file->lineno++;
 723         }
 724         if (c == EOF)
 725                 return (0);
 726         return (c);
 727 }
 728
 729 int
 730 check_file_secrecy(int fd, const char *fname)
 731 {
 732         struct stat st;
 733
 734         if (fstat(fd, &st)) {
 735                 log_warn("cannot stat %s", fname);
 736                 return (-1);
 737         }
 738         if (st.st_uid != 0 && st.st_uid != getuid()) {
 739                 log_warnx("%s: owner not root or current user", fname);
 740                 return (-1);
 741         }
 742         if (st.st_mode & (S_IWGRP | S_IXGRP | S_IRWXO)) {
 743                 log_warnx("%s: group writable or world read/writable", fname);
 744                 return (-1);
 745         }
 746         return (0);
 747 }
 748
 749 struct file *
 750 newfile(const char *name, int secret)
 751 {
 752         struct file *nfile;
 753
 754         nfile = calloc(1, sizeof(struct file));
 755         if (nfile == NULL) {
 756                 log_warn("calloc");
 757                 return (NULL);
 758         }
 759         nfile->name = strdup(name);
 760         if (nfile->name == NULL) {
 761                 log_warn("strdup");
 762                 free(nfile);
 763                 return (NULL);
 764         }
 765         nfile->stream = fopen(nfile->name, "r");
 766         if (nfile->stream == NULL) {
 767                 /* no warning, we don't require a conf file */
 768                 free(nfile->name);
 769                 free(nfile);
 770                 return (NULL);
 771         } else if (secret &&
 772             check_file_secrecy(fileno(nfile->stream), nfile->name)) {
 773                 fclose(nfile->stream);
 774                 free(nfile->name);
 775                 free(nfile);
 776                 return (NULL);
 777         }
 778         nfile->lineno = 1;
 779         return (nfile);
 780 }
 781
 782 static void
 783 closefile(struct file *xfile)
 784 {
 785         fclose(xfile->stream);
 786         free(xfile->name);
 787         free(xfile);
 788 }
 789
 790 static void
 791 add_default_server(void)
 792 {
 793         new_srv = conf_new_server(D_SITENAME);
 794         log_debug("%s: adding default server %s", __func__, D_SITENAME);
 795 }
 796
 797 int
 798 parse_config(const char *filename, struct gotwebd *env)
 799 {
 800         struct sym *sym, *next;
 801
 802         if (config_init(env) == -1)
 803                 fatalx("failed to initialize configuration");
 804
 805         gotwebd = env;
 806
 807         file = newfile(filename, 0);
 808         if (file == NULL) {
 809                 add_default_server();
 810                 sockets_parse_sockets(env);
 811                 /* just return, as we don't require a conf file */
 812                 return (0);
 813         }
 814
 815         yyparse();
 816         errors = file->errors;
 817         closefile(file);
 818
 819         /* Free macros and check which have not been used. */
 820         TAILQ_FOREACH_SAFE(sym, &symhead, entry, next) {
 821                 if ((gotwebd->gotwebd_verbose > 1) && !sym->used)
 822                         fprintf(stderr, "warning: macro '%s' not used\n",
 823                             sym->nam);
 824                 if (!sym->persist) {
 825                         free(sym->nam);
 826                         free(sym->val);
 827                         TAILQ_REMOVE(&symhead, sym, entry);
 828                         free(sym);
 829                 }
 830         }
 831
 832         if (errors)
 833                 return (-1);
 834
 835         /* just add default server if no config specified */
 836         if (gotwebd->server_cnt == 0)
 837                 add_default_server();
 838
 839         /* setup our listening sockets */
 840         sockets_parse_sockets(env);
 841
 842         return (0);
 843 }
 844
 845 struct server *
 846 conf_new_server(const char *name)
 847 {
 848         struct server *srv = NULL;
 849
 850         srv = calloc(1, sizeof(*srv));
 851         if (srv == NULL)
 852                 fatalx("%s: calloc", __func__);
 853
 854         n = strlcpy(srv->name, name, sizeof(srv->name));
 855         if (n >= sizeof(srv->name))
 856                 fatalx("%s: strlcpy", __func__);
 857         n = snprintf(srv->unix_socket_name,
 858             sizeof(srv->unix_socket_name), "%s%s", D_HTTPD_CHROOT,
 859             D_UNIX_SOCKET);
 860         if (n < 0 || (size_t)n >= sizeof(srv->unix_socket_name))
 861                 fatalx("%s: snprintf", __func__);
 862         n = strlcpy(srv->repos_path, D_GOTPATH,
 863             sizeof(srv->repos_path));
 864         if (n >= sizeof(srv->repos_path))
 865                 fatalx("%s: strlcpy", __func__);
 866         n = strlcpy(srv->site_name, D_SITENAME,
 867             sizeof(srv->site_name));
 868         if (n >= sizeof(srv->site_name))
 869                 fatalx("%s: strlcpy", __func__);
 870         n = strlcpy(srv->site_owner, D_SITEOWNER,
 871             sizeof(srv->site_owner));
 872         if (n >= sizeof(srv->site_owner))
 873                 fatalx("%s: strlcpy", __func__);
 874         n = strlcpy(srv->site_link, D_SITELINK,
 875             sizeof(srv->site_link));
 876         if (n >= sizeof(srv->site_link))
 877                 fatalx("%s: strlcpy", __func__);
 878         n = strlcpy(srv->logo, D_GOTLOGO,
 879             sizeof(srv->logo));
 880         if (n >= sizeof(srv->logo))
 881                 fatalx("%s: strlcpy", __func__);
 882         n = strlcpy(srv->logo_url, D_GOTURL, sizeof(srv->logo_url));
 883         if (n >= sizeof(srv->logo_url))
 884                 fatalx("%s: strlcpy", __func__);
 885         n = strlcpy(srv->custom_css, D_GOTWEBCSS, sizeof(srv->custom_css));
 886         if (n >= sizeof(srv->custom_css))
 887                 fatalx("%s: strlcpy", __func__);
 888
 889         srv->show_site_owner = D_SHOWSOWNER;
 890         srv->show_repo_owner = D_SHOWROWNER;
 891         srv->show_repo_age = D_SHOWAGE;
 892         srv->show_repo_description = D_SHOWDESC;
 893         srv->show_repo_cloneurl = D_SHOWURL;
 894         srv->respect_exportok = D_RESPECTEXPORTOK;
 895
 896         srv->max_repos_display = D_MAXREPODISP;
 897         srv->max_commits_display = D_MAXCOMMITDISP;
 898         srv->max_repos = D_MAXREPO;
 899
 900         srv->unix_socket = 1;
 901         srv->fcgi_socket = 0;
 902
 903         TAILQ_INIT(&srv->al);
 904         TAILQ_INSERT_TAIL(&gotwebd->servers, srv, entry);
 905         gotwebd->server_cnt++;
 906
 907         return srv;
 908 };
 909
 910 int
 911 symset(const char *nam, const char *val, int persist)
 912 {
 913         struct sym *sym;
 914
 915         TAILQ_FOREACH(sym, &symhead, entry) {
 916                 if (strcmp(nam, sym->nam) == 0)
 917                         break;
 918         }
 919
 920         if (sym != NULL) {
 921                 if (sym->persist == 1)
 922                         return (0);
 923                 else {
 924                         free(sym->nam);
 925                         free(sym->val);
 926                         TAILQ_REMOVE(&symhead, sym, entry);
 927                         free(sym);
 928                 }
 929         }
 930         sym = calloc(1, sizeof(*sym));
 931         if (sym == NULL)
 932                 return (-1);
 933
 934         sym->nam = strdup(nam);
 935         if (sym->nam == NULL) {
 936                 free(sym);
 937                 return (-1);
 938         }
 939         sym->val = strdup(val);
 940         if (sym->val == NULL) {
 941                 free(sym->nam);
 942                 free(sym);
 943                 return (-1);
 944         }
 945         sym->used = 0;
 946         sym->persist = persist;
 947         TAILQ_INSERT_TAIL(&symhead, sym, entry);
 948         return (0);
 949 }
 950
 951 int
 952 cmdline_symset(char *s)
 953 {
 954         char *sym, *val;
 955         int ret;
 956
 957         val = strrchr(s, '=');
 958         if (val == NULL)
 959                 return (-1);
 960
 961         sym = strndup(s, val - s);
 962         if (sym == NULL)
 963                 fatal("%s: strndup", __func__);
 964
 965         ret = symset(sym, val + 1, 1);
 966         free(sym);
 967
 968         return (ret);
 969 }
 970
 971 char *
 972 symget(const char *nam)
 973 {
 974         struct sym *sym;
 975
 976         TAILQ_FOREACH(sym, &symhead, entry) {
 977                 if (strcmp(nam, sym->nam) == 0) {
 978                         sym->used = 1;
 979                         return (sym->val);
 980                 }
 981         }
 982         return (NULL);
 983 }
 984
 985 int
 986 getservice(const char *n)
 987 {
 988         struct servent *s;
 989         const char *errstr;
 990         long long llval;
 991
 992         llval = strtonum(n, 0, UINT16_MAX, &errstr);
 993         if (errstr) {
 994                 s = getservbyname(n, "tcp");
 995                 if (s == NULL)
 996                         s = getservbyname(n, "udp");
 997                 if (s == NULL)
 998                         return (-1);
 999                 return ntohs(s->s_port);
1000         }
1001
1002         return (unsigned short)llval;
1003 }
1004
1005 struct address *
1006 host_v4(const char *s)
1007 {
1008         struct in_addr ina;
1009         struct sockaddr_in *sain;
1010         struct address *h;
1011
1012         memset(&ina, 0, sizeof(ina));
1013         if (inet_pton(AF_INET, s, &ina) != 1)
1014                 return (NULL);
1015
1016         if ((h = calloc(1, sizeof(*h))) == NULL)
1017                 fatal(__func__);
1018         sain = (struct sockaddr_in *)&h->ss;
1019         got_sockaddr_inet_init(sain, &ina);
1020         if (sain->sin_addr.s_addr == INADDR_ANY)
1021                 h->prefixlen = 0; /* 0.0.0.0 address */
1022         else
1023                 h->prefixlen = -1; /* host address */
1024         return (h);
1025 }
1026
1027 struct address *
1028 host_v6(const char *s)
1029 {
1030         struct addrinfo hints, *res;
1031         struct sockaddr_in6 *sa_in6, *ra;
1032         struct address *h = NULL;
1033
1034         memset(&hints, 0, sizeof(hints));
1035         hints.ai_family = AF_INET6;
1036         hints.ai_socktype = SOCK_DGRAM; /* dummy */
1037         hints.ai_flags = AI_NUMERICHOST;
1038         if (getaddrinfo(s, "0", &hints, &res) == 0) {
1039                 if ((h = calloc(1, sizeof(*h))) == NULL)
1040                         fatal(__func__);
1041                 sa_in6 = (struct sockaddr_in6 *)&h->ss;
1042                 ra = (struct sockaddr_in6 *)res->ai_addr;
1043                 got_sockaddr_inet6_init(sa_in6, &ra->sin6_addr,
1044                     ra->sin6_scope_id);
1045                 if (memcmp(&sa_in6->sin6_addr, &in6addr_any,
1046                     sizeof(sa_in6->sin6_addr)) == 0)
1047                         h->prefixlen = 0; /* any address */
1048                 else
1049                         h->prefixlen = -1; /* host address */
1050                 freeaddrinfo(res);
1051         }
1052
1053         return (h);
1054 }
1055
1056 int
1057 host_dns(const char *s, struct server *new_srv, int max,
1058     in_port_t port, const char *ifname, int ipproto)
1059 {
1060         struct addrinfo hints, *res0, *res;
1061         int error, cnt = 0;
1062         struct sockaddr_in *sain;
1063         struct sockaddr_in6 *sin6;
1064         struct address *h;
1065
1066         if ((cnt = host_if(s, new_srv, max, port, ifname, ipproto)) != 0)
1067                 return (cnt);
1068
1069         memset(&hints, 0, sizeof(hints));
1070         hints.ai_family = PF_UNSPEC;
1071         hints.ai_socktype = SOCK_DGRAM; /* DUMMY */
1072         hints.ai_flags = AI_ADDRCONFIG;
1073         error = getaddrinfo(s, NULL, &hints, &res0);
1074         if (error == EAI_AGAIN || error == EAI_NODATA || error == EAI_NONAME)
1075                 return (0);
1076         if (error) {
1077                 log_warnx("%s: could not parse \"%s\": %s", __func__, s,
1078                     gai_strerror(error));
1079                 return (-1);
1080         }
1081
1082         for (res = res0; res && cnt < max; res = res->ai_next) {
1083                 if (res->ai_family != AF_INET &&
1084                     res->ai_family != AF_INET6)
1085                         continue;
1086                 if ((h = calloc(1, sizeof(*h))) == NULL)
1087                         fatal(__func__);
1088
1089                 if (port)
1090                         h->port = port;
1091                 if (ifname != NULL) {
1092                         if (strlcpy(h->ifname, ifname, sizeof(h->ifname)) >=
1093                             sizeof(h->ifname)) {
1094                                 log_warnx("%s: interface name truncated",
1095                                     __func__);
1096                                 freeaddrinfo(res0);
1097                                 free(h);
1098                                 return (-1);
1099                         }
1100                 }
1101                 if (ipproto != -1)
1102                         h->ipproto = ipproto;
1103                 h->ss.ss_family = res->ai_family;
1104                 h->prefixlen = -1; /* host address */
1105
1106                 if (res->ai_family == AF_INET) {
1107                         struct sockaddr_in *ra;
1108                         sain = (struct sockaddr_in *)&h->ss;
1109                         ra = (struct sockaddr_in *)res->ai_addr;
1110                         got_sockaddr_inet_init(sain, &ra->sin_addr);
1111                 } else {
1112                         struct sockaddr_in6 *ra;
1113                         sin6 = (struct sockaddr_in6 *)&h->ss;
1114                         ra = (struct sockaddr_in6 *)res->ai_addr;
1115                         got_sockaddr_inet6_init(sin6, &ra->sin6_addr, 0);
1116                 }
1117
1118                 if (add_addr(new_srv, h))
1119                         return -1;
1120                 cnt++;
1121         }
1122         if (cnt == max && res) {
1123                 log_warnx("%s: %s resolves to more than %d hosts", __func__,
1124                     s, max);
1125         }
1126         freeaddrinfo(res0);
1127         return (cnt);
1128 }
1129
1130 int
1131 host_if(const char *s, struct server *new_srv, int max,
1132     in_port_t port, const char *ifname, int ipproto)
1133 {
1134         struct ifaddrs *ifap, *p;
1135         struct sockaddr_in *sain;
1136         struct sockaddr_in6 *sin6;
1137         struct address *h;
1138         int cnt = 0, af;
1139
1140         if (getifaddrs(&ifap) == -1)
1141                 fatal("getifaddrs");
1142
1143         /* First search for IPv4 addresses */
1144         af = AF_INET;
1145
1146  nextaf:
1147         for (p = ifap; p != NULL && cnt < max; p = p->ifa_next) {
1148                 if (p->ifa_addr == NULL ||
1149                     p->ifa_addr->sa_family != af ||
1150                     (strcmp(s, p->ifa_name) != 0 &&
1151                     !is_if_in_group(p->ifa_name, s)))
1152                         continue;
1153                 if ((h = calloc(1, sizeof(*h))) == NULL)
1154                         fatal("calloc");
1155
1156                 if (port)
1157                         h->port = port;
1158                 if (ifname != NULL) {
1159                         if (strlcpy(h->ifname, ifname, sizeof(h->ifname)) >=
1160                             sizeof(h->ifname)) {
1161                                 log_warnx("%s: interface name truncated",
1162                                     __func__);
1163                                 free(h);
1164                                 freeifaddrs(ifap);
1165                                 return (-1);
1166                         }
1167                 }
1168                 if (ipproto != -1)
1169                         h->ipproto = ipproto;
1170                 h->ss.ss_family = af;
1171                 h->prefixlen = -1; /* host address */
1172
1173                 if (af == AF_INET) {
1174                         struct sockaddr_in *ra;
1175                         sain = (struct sockaddr_in *)&h->ss;
1176                         ra = (struct sockaddr_in *)p->ifa_addr;
1177                         got_sockaddr_inet_init(sain, &ra->sin_addr);
1178                 } else {
1179                         struct sockaddr_in6 *ra;
1180                         sin6 = (struct sockaddr_in6 *)&h->ss;
1181                         ra = (struct sockaddr_in6 *)p->ifa_addr;
1182                         got_sockaddr_inet6_init(sin6, &ra->sin6_addr,
1183                             ra->sin6_scope_id);
1184                 }
1185
1186                 if (add_addr(new_srv, h))
1187                         return -1;
1188                 cnt++;
1189         }
1190         if (af == AF_INET) {
1191                 /* Next search for IPv6 addresses */
1192                 af = AF_INET6;
1193                 goto nextaf;
1194         }
1195
1196         if (cnt > max) {
1197                 log_warnx("%s: %s resolves to more than %d hosts", __func__,
1198                     s, max);
1199         }
1200         freeifaddrs(ifap);
1201         return (cnt);
1202 }
1203
1204 int
1205 host(const char *s, struct server *new_srv, int max,
1206     in_port_t port, const char *ifname, int ipproto)
1207 {
1208         struct address *h;
1209
1210         h = host_v4(s);
1211
1212         /* IPv6 address? */
1213         if (h == NULL)
1214                 h = host_v6(s);
1215
1216         if (h != NULL) {
1217                 if (port)
1218                         h->port = port;
1219                 if (ifname != NULL) {
1220                         if (strlcpy(h->ifname, ifname, sizeof(h->ifname)) >=
1221                             sizeof(h->ifname)) {
1222                                 log_warnx("%s: interface name truncated",
1223                                     __func__);
1224                                 free(h);
1225                                 return (-1);
1226                         }
1227                 }
1228                 if (ipproto != -1)
1229                         h->ipproto = ipproto;
1230
1231                 if (add_addr(new_srv, h))
1232                         return -1;
1233                 return (1);
1234         }
1235
1236         return (host_dns(s, new_srv, max, port, ifname, ipproto));
1237 }
1238
1239 int
1240 is_if_in_group(const char *ifname, const char *groupname)
1241 {
1242 /* TA: Check this... */
1243 #ifdef HAVE_STRUCT_IFGROUPREQ
1244         unsigned int len;
1245         struct ifgroupreq ifgr;
1246         struct ifg_req *ifg;
1247         int s;
1248         int ret = 0;
1249
1250         if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
1251                 err(1, "socket");
1252
1253         memset(&ifgr, 0, sizeof(ifgr));
1254         if (strlcpy(ifgr.ifgr_name, ifname, IFNAMSIZ) >= IFNAMSIZ)
1255                 err(1, "IFNAMSIZ");
1256         if (ioctl(s, SIOCGIFGROUP, (caddr_t)&ifgr) == -1) {
1257                 if (errno == EINVAL || errno == ENOTTY)
1258                         goto end;
1259                 err(1, "SIOCGIFGROUP");
1260         }
1261
1262         len = ifgr.ifgr_len;
1263         ifgr.ifgr_groups = calloc(len / sizeof(struct ifg_req),
1264             sizeof(struct ifg_req));
1265         if (ifgr.ifgr_groups == NULL)
1266                 err(1, "getifgroups");
1267         if (ioctl(s, SIOCGIFGROUP, (caddr_t)&ifgr) == -1)
1268                 err(1, "SIOCGIFGROUP");
1269
1270         ifg = ifgr.ifgr_groups;
1271         for (; ifg && len >= sizeof(struct ifg_req); ifg++) {
1272                 len -= sizeof(struct ifg_req);
1273                 if (strcmp(ifg->ifgrq_group, groupname) == 0) {
1274                         ret = 1;
1275                         break;
1276                 }
1277         }
1278         free(ifgr.ifgr_groups);
1279
1280 end:
1281         close(s);
1282         return (ret);
1283 #else
1284         return (0);
1285 #endif
1286 }
1287
1288 int
1289 get_addrs(const char *addr, struct server *new_srv, in_port_t port)
1290 {
1291         if (strcmp("", addr) == 0) {
1292                 if (host("127.0.0.1", new_srv, 1, port, "127.0.0.1",
1293                     -1) <= 0) {
1294                         yyerror("invalid listen ip: %s",
1295                             "127.0.0.1");
1296                         return (-1);
1297                 }
1298                 if (host("::1", new_srv, 1, port, "::1", -1) <= 0) {
1299                         yyerror("invalid listen ip: %s", "::1");
1300                         return (-1);
1301                 }
1302         } else {
1303                 if (host(addr, new_srv, GOTWEBD_MAXIFACE, port, addr,
1304                     -1) <= 0) {
1305                         yyerror("invalid listen ip: %s", addr);
1306                         return (-1);
1307                 }
1308         }
1309         return (0);
1310 }
1311
1312 int
1313 addr_dup_check(struct addresslist *al, struct address *h, const char *new_srv,
1314     const char *other_srv)
1315 {
1316         struct address *a;
1317         void *ia;
1318         char buf[INET6_ADDRSTRLEN];
1319         const char *addrstr;
1320
1321         TAILQ_FOREACH(a, al, entry) {
1322                 if (memcmp(&a->ss, &h->ss, sizeof(h->ss)) != 0 ||
1323                     a->port != h->port)
1324                         continue;
1325
1326                 switch (h->ss.ss_family) {
1327                 case AF_INET:
1328                         ia = &((struct sockaddr_in *)(&h->ss))->sin_addr;
1329                         break;
1330                 case AF_INET6:
1331                         ia = &((struct sockaddr_in6 *)(&h->ss))->sin6_addr;
1332                         break;
1333                 default:
1334                         yyerror("unknown address family: %d", h->ss.ss_family);
1335                         return -1;
1336                 }
1337                 addrstr = inet_ntop(h->ss.ss_family, ia, buf, sizeof(buf));
1338                 if (addrstr) {
1339                         if (other_srv) {
1340                                 yyerror("server %s: duplicate fcgi listen "
1341                                     "address %s:%d, already used by server %s",
1342                                     new_srv, addrstr, h->port, other_srv);
1343                         } else {
1344                                 log_warnx("server: %s: duplicate fcgi listen "
1345                                     "address %s:%d", new_srv, addrstr, h->port);
1346                         }
1347                 } else {
1348                         if (other_srv) {
1349                                 yyerror("server: %s: duplicate fcgi listen "
1350                                     "address, already used by server %s",
1351                                     new_srv, other_srv);
1352                         } else {
1353                                 log_warnx("server %s: duplicate fcgi listen "
1354                                     "address", new_srv);
1355                         }
1356                 }
1357
1358                 return -1;
1359         }
1360
1361         return 0;
1362 }
1363
1364 int
1365 add_addr(struct server *new_srv, struct address *h)
1366 {
1367         struct server *srv;
1368
1369         /* Address cannot be shared between different servers. */
1370         TAILQ_FOREACH(srv, &gotwebd->servers, entry) {
1371                 if (srv == new_srv)
1372                         continue;
1373                 if (addr_dup_check(&srv->al, h, new_srv->name, srv->name))
1374                         return -1;
1375         }
1376
1377         /* Tolerate duplicate address lines within the scope of a server. */
1378         if (addr_dup_check(&new_srv->al, h, NULL, NULL) == 0)
1379                 TAILQ_INSERT_TAIL(&new_srv->al, h, entry);
1380         else
1381                 free(h);
1382
1383         return 0;
1384 }