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_reference.h"
  52
  53 #include "gotwebd.h"
  54
  55 TAILQ_HEAD(files, file)          files = TAILQ_HEAD_INITIALIZER(files);
  56 static struct file {
  57         TAILQ_ENTRY(file)        entry;
  58         FILE                    *stream;
  59         char                    *name;
  60         int                      lineno;
  61         int                      errors;
  62 } *file;
  63 struct file     *newfile(const char *, int);
  64 static void      closefile(struct file *);
  65 int              check_file_secrecy(int, const char *);
  66 int              yyparse(void);
  67 int              yylex(void);
  68 int              yyerror(const char *, ...)
  69     __attribute__((__format__ (printf, 1, 2)))
  70     __attribute__((__nonnull__ (1)));
  71 int              kw_cmp(const void *, const void *);
  72 int              lookup(char *);
  73 int              lgetc(int);
  74 int              lungetc(int);
  75 int              findeol(void);
  76
  77 TAILQ_HEAD(symhead, sym)         symhead = TAILQ_HEAD_INITIALIZER(symhead);
  78 struct sym {
  79         TAILQ_ENTRY(sym)         entry;
  80         int                      used;
  81         int                      persist;
  82         char                    *nam;
  83         char                    *val;
  84 };
  85
  86 int      symset(const char *, const char *, int);
  87 char    *symget(const char *);
  88
  89 static int               errors;
  90
  91 static struct gotwebd           *gotwebd;
  92 static struct server            *new_srv;
  93 static struct server            *conf_new_server(const char *);
  94 int                              getservice(const char *);
  95 int                              n;
  96
  97 int              get_addrs(const char *, const char *, struct server *);
  98 int              addr_dup_check(struct addresslist *, struct address *,
  99                     const char *, const char *);
 100 int              add_addr(struct server *, struct address *);
 101
 102 typedef struct {
 103         union {
 104                 long long        number;
 105                 char            *string;
 106         } v;
 107         int lineno;
 108 } YYSTYPE;
 109
 110 %}
 111
 112 %token  LISTEN WWW_PATH MAX_REPOS SITE_NAME SITE_OWNER SITE_LINK LOGO
 113 %token  LOGO_URL SHOW_REPO_OWNER SHOW_REPO_AGE SHOW_REPO_DESCRIPTION
 114 %token  MAX_REPOS_DISPLAY REPOS_PATH MAX_COMMITS_DISPLAY ON ERROR
 115 %token  SHOW_SITE_OWNER SHOW_REPO_CLONEURL PORT PREFORK RESPECT_EXPORTOK
 116 %token  UNIX_SOCKET UNIX_SOCKET_NAME SERVER CHROOT CUSTOM_CSS SOCKET
 117
 118 %token  <v.string>      STRING
 119 %token  <v.number>      NUMBER
 120 %type   <v.number>      boolean
 121 %type   <v.string>      listen_addr
 122
 123 %%
 124
 125 grammar         : /* empty */
 126                 | grammar '\n'
 127                 | grammar varset '\n'
 128                 | grammar main '\n'
 129                 | grammar server '\n'
 130                 | grammar error '\n'            { file->errors++; }
 131                 ;
 132
 133 varset          : STRING '=' STRING     {
 134                         char *s = $1;
 135                         while (*s++) {
 136                                 if (isspace((unsigned char)*s)) {
 137                                         yyerror("macro name cannot contain "
 138                                             "whitespace");
 139                                         free($1);
 140                                         free($3);
 141                                         YYERROR;
 142                                 }
 143                         }
 144                         if (symset($1, $3, 0) == -1)
 145                                 fatal("cannot store variable");
 146                         free($1);
 147                         free($3);
 148                 }
 149                 ;
 150
 151 boolean         : STRING {
 152                         if (strcasecmp($1, "1") == 0 ||
 153                             strcasecmp($1, "on") == 0)
 154                                 $$ = 1;
 155                         else if (strcasecmp($1, "0") == 0 ||
 156                             strcasecmp($1, "off") == 0)
 157                                 $$ = 0;
 158                         else {
 159                                 yyerror("invalid boolean value '%s'", $1);
 160                                 free($1);
 161                                 YYERROR;
 162                         }
 163                         free($1);
 164                 }
 165                 | ON { $$ = 1; }
 166                 | NUMBER {
 167                         if ($1 != 0 && $1 != 1) {
 168                                 yyerror("invalid boolean value '%lld'", $1);
 169                                 YYERROR;
 170                         }
 171                         $$ = $1;
 172                 }
 173                 ;
 174
 175 listen_addr     : '*' { $$ = NULL; }
 176                 | STRING
 177                 ;
 178
 179 main            : PREFORK NUMBER {
 180                         if ($2 <= 0 || $2 > PROC_MAX_INSTANCES) {
 181                                 yyerror("prefork is %s: %lld",
 182                                     $2 <= 0 ? "too small" : "too large", $2);
 183                                 YYERROR;
 184                         }
 185                         gotwebd->prefork_gotwebd = $2;
 186                 }
 187                 | CHROOT STRING {
 188                         if (*$2 == '\0') {
 189                                 yyerror("chroot path can't be an empty"
 190                                     " string");
 191                                 free($2);
 192                                 YYERROR;
 193                         }
 194
 195                         n = strlcpy(gotwebd->httpd_chroot, $2,
 196                             sizeof(gotwebd->httpd_chroot));
 197                         if (n >= sizeof(gotwebd->httpd_chroot)) {
 198                                 yyerror("%s: httpd_chroot truncated", __func__);
 199                                 free($2);
 200                                 YYERROR;
 201                         }
 202                         free($2);
 203                 }
 204                 | UNIX_SOCKET boolean {
 205                         gotwebd->unix_socket = $2;
 206                 }
 207                 | UNIX_SOCKET_NAME STRING {
 208                         n = snprintf(gotwebd->unix_socket_name,
 209                             sizeof(gotwebd->unix_socket_name), "%s%s",
 210                             gotwebd->httpd_chroot, $2);
 211                         if (n < 0 ||
 212                             (size_t)n >= sizeof(gotwebd->unix_socket_name)) {
 213                                 yyerror("%s: unix_socket_name truncated",
 214                                     __func__);
 215                                 free($2);
 216                                 YYERROR;
 217                         }
 218                         free($2);
 219                 }
 220                 ;
 221
 222 server          : SERVER STRING {
 223                         struct server *srv;
 224
 225                         TAILQ_FOREACH(srv, &gotwebd->servers, entry) {
 226                                 if (strcmp(srv->name, $2) == 0) {
 227                                         yyerror("server name exists '%s'", $2);
 228                                         free($2);
 229                                         YYERROR;
 230                                 }
 231                         }
 232
 233                         new_srv = conf_new_server($2);
 234                         log_debug("adding server %s", $2);
 235                         free($2);
 236                 }
 237                 | SERVER STRING {
 238                         struct server *srv;
 239
 240                         TAILQ_FOREACH(srv, &gotwebd->servers, entry) {
 241                                 if (strcmp(srv->name, $2) == 0) {
 242                                         yyerror("server name exists '%s'", $2);
 243                                         free($2);
 244                                         YYERROR;
 245                                 }
 246                         }
 247
 248                         new_srv = conf_new_server($2);
 249                         log_debug("adding server %s", $2);
 250                         free($2);
 251                 } '{' optnl serveropts2 '}' {
 252                 }
 253                 ;
 254
 255 serveropts1     : REPOS_PATH STRING {
 256                         n = strlcpy(new_srv->repos_path, $2,
 257                             sizeof(new_srv->repos_path));
 258                         if (n >= sizeof(new_srv->repos_path)) {
 259                                 yyerror("%s: repos_path truncated", __func__);
 260                                 free($2);
 261                                 YYERROR;
 262                         }
 263                         free($2);
 264                 }
 265                 | SITE_NAME STRING {
 266                         n = strlcpy(new_srv->site_name, $2,
 267                             sizeof(new_srv->site_name));
 268                         if (n >= sizeof(new_srv->site_name)) {
 269                                 yyerror("%s: site_name truncated", __func__);
 270                                 free($2);
 271                                 YYERROR;
 272                         }
 273                         free($2);
 274                 }
 275                 | SITE_OWNER STRING {
 276                         n = strlcpy(new_srv->site_owner, $2,
 277                             sizeof(new_srv->site_owner));
 278                         if (n >= sizeof(new_srv->site_owner)) {
 279                                 yyerror("%s: site_owner truncated", __func__);
 280                                 free($2);
 281                                 YYERROR;
 282                         }
 283                         free($2);
 284                 }
 285                 | SITE_LINK STRING {
 286                         n = strlcpy(new_srv->site_link, $2,
 287                             sizeof(new_srv->site_link));
 288                         if (n >= sizeof(new_srv->site_link)) {
 289                                 yyerror("%s: site_link truncated", __func__);
 290                                 free($2);
 291                                 YYERROR;
 292                         }
 293                         free($2);
 294                 }
 295                 | LOGO STRING {
 296                         n = strlcpy(new_srv->logo, $2, sizeof(new_srv->logo));
 297                         if (n >= sizeof(new_srv->logo)) {
 298                                 yyerror("%s: logo truncated", __func__);
 299                                 free($2);
 300                                 YYERROR;
 301                         }
 302                         free($2);
 303                 }
 304                 | LOGO_URL STRING {
 305                         n = strlcpy(new_srv->logo_url, $2,
 306                             sizeof(new_srv->logo_url));
 307                         if (n >= sizeof(new_srv->logo_url)) {
 308                                 yyerror("%s: logo_url truncated", __func__);
 309                                 free($2);
 310                                 YYERROR;
 311                         }
 312                         free($2);
 313                 }
 314                 | CUSTOM_CSS STRING {
 315                         n = strlcpy(new_srv->custom_css, $2,
 316                             sizeof(new_srv->custom_css));
 317                         if (n >= sizeof(new_srv->custom_css)) {
 318                                 yyerror("%s: custom_css truncated", __func__);
 319                                 free($2);
 320                                 YYERROR;
 321                         }
 322                         free($2);
 323                 }
 324                 | LISTEN ON listen_addr PORT STRING {
 325                         if (get_addrs($3, $5, new_srv) == -1) {
 326                                 yyerror("could not get addrs");
 327                                 YYERROR;
 328                         }
 329                         free($3);
 330                         free($5);
 331                         new_srv->fcgi_socket = 1;
 332                 }
 333                 | LISTEN ON listen_addr PORT NUMBER {
 334                         char portno[32];
 335                         int n;
 336
 337                         n = snprintf(portno, sizeof(portno), "%lld",
 338                             (long long)$5);
 339                         if (n < 0 || (size_t)n >= sizeof(portno))
 340                                 fatalx("port number too long: %lld",
 341                                     (long long)$5);
 342
 343                         if (get_addrs($3, portno, new_srv) == -1) {
 344                                 yyerror("could not get addrs");
 345                                 YYERROR;
 346                         }
 347                         free($3);
 348                         new_srv->fcgi_socket = 1;
 349                 }
 350                 | LISTEN ON SOCKET STRING {
 351                         if (strcasecmp($4, "off") == 0) {
 352                                 new_srv->unix_socket = 0;
 353                                 free($4);
 354                                 YYACCEPT;
 355                         }
 356
 357                         new_srv->unix_socket = 1;
 358
 359                         n = snprintf(new_srv->unix_socket_name,
 360                             sizeof(new_srv->unix_socket_name), "%s%s",
 361                             gotwebd->httpd_chroot, $4);
 362                         if (n < 0 ||
 363                             (size_t)n >= sizeof(new_srv->unix_socket_name)) {
 364                                 yyerror("%s: unix_socket_name truncated",
 365                                     __func__);
 366                                 free($4);
 367                                 YYERROR;
 368                         }
 369                         free($4);
 370                 }
 371                 | MAX_REPOS NUMBER {
 372                         if ($2 <= 0) {
 373                                 yyerror("max_repos is too small: %lld", $2);
 374                                 YYERROR;
 375                         }
 376                         new_srv->max_repos = $2;
 377                 }
 378                 | SHOW_SITE_OWNER boolean {
 379                         new_srv->show_site_owner = $2;
 380                 }
 381                 | SHOW_REPO_OWNER boolean {
 382                         new_srv->show_repo_owner = $2;
 383                 }
 384                 | SHOW_REPO_AGE boolean {
 385                         new_srv->show_repo_age = $2;
 386                 }
 387                 | SHOW_REPO_DESCRIPTION boolean {
 388                         new_srv->show_repo_description = $2;
 389                 }
 390                 | SHOW_REPO_CLONEURL boolean {
 391                         new_srv->show_repo_cloneurl = $2;
 392                 }
 393                 | RESPECT_EXPORTOK boolean {
 394                         new_srv->respect_exportok = $2;
 395                 }
 396                 | MAX_REPOS_DISPLAY NUMBER {
 397                         if ($2 < 0) {
 398                                 yyerror("max_repos_display is too small: %lld",
 399                                     $2);
 400                                 YYERROR;
 401                         }
 402                         new_srv->max_repos_display = $2;
 403                 }
 404                 | MAX_COMMITS_DISPLAY NUMBER {
 405                         if ($2 <= 1) {
 406                                 yyerror("max_commits_display is too small:"
 407                                     " %lld", $2);
 408                                 YYERROR;
 409                         }
 410                         new_srv->max_commits_display = $2;
 411                 }
 412                 ;
 413
 414 serveropts2     : serveropts2 serveropts1 nl
 415                 | serveropts1 optnl
 416                 ;
 417
 418 nl              : '\n' optnl
 419                 ;
 420
 421 optnl           : '\n' optnl            /* zero or more newlines */
 422                 | /* empty */
 423                 ;
 424
 425 %%
 426
 427 struct keywords {
 428         const char      *k_name;
 429         int              k_val;
 430 };
 431
 432 int
 433 yyerror(const char *fmt, ...)
 434 {
 435         va_list ap;
 436         char *msg;
 437
 438         file->errors++;
 439         va_start(ap, fmt);
 440         if (vasprintf(&msg, fmt, ap) == -1)
 441                 fatalx("yyerror vasprintf");
 442         va_end(ap);
 443         logit(LOG_CRIT, "%s:%d: %s", file->name, yylval.lineno, msg);
 444         free(msg);
 445         return (0);
 446 }
 447
 448 int
 449 kw_cmp(const void *k, const void *e)
 450 {
 451         return (strcmp(k, ((const struct keywords *)e)->k_name));
 452 }
 453
 454 int
 455 lookup(char *s)
 456 {
 457         /* This has to be sorted always. */
 458         static const struct keywords keywords[] = {
 459                 { "chroot",                     CHROOT },
 460                 { "custom_css",                 CUSTOM_CSS },
 461                 { "listen",                     LISTEN },
 462                 { "logo",                       LOGO },
 463                 { "logo_url",                   LOGO_URL },
 464                 { "max_commits_display",        MAX_COMMITS_DISPLAY },
 465                 { "max_repos",                  MAX_REPOS },
 466                 { "max_repos_display",          MAX_REPOS_DISPLAY },
 467                 { "on",                         ON },
 468                 { "port",                       PORT },
 469                 { "prefork",                    PREFORK },
 470                 { "repos_path",                 REPOS_PATH },
 471                 { "respect_exportok",           RESPECT_EXPORTOK },
 472                 { "server",                     SERVER },
 473                 { "show_repo_age",              SHOW_REPO_AGE },
 474                 { "show_repo_cloneurl",         SHOW_REPO_CLONEURL },
 475                 { "show_repo_description",      SHOW_REPO_DESCRIPTION },
 476                 { "show_repo_owner",            SHOW_REPO_OWNER },
 477                 { "show_site_owner",            SHOW_SITE_OWNER },
 478                 { "site_link",                  SITE_LINK },
 479                 { "site_name",                  SITE_NAME },
 480                 { "site_owner",                 SITE_OWNER },
 481                 { "socket",                     SOCKET },
 482                 { "unix_socket",                UNIX_SOCKET },
 483                 { "unix_socket_name",           UNIX_SOCKET_NAME },
 484         };
 485         const struct keywords *p;
 486
 487         p = bsearch(s, keywords, sizeof(keywords)/sizeof(keywords[0]),
 488             sizeof(keywords[0]), kw_cmp);
 489
 490         if (p)
 491                 return (p->k_val);
 492         else
 493                 return (STRING);
 494 }
 495
 496 #define MAXPUSHBACK     128
 497
 498 unsigned char *parsebuf;
 499 int parseindex;
 500 unsigned char pushback_buffer[MAXPUSHBACK];
 501 int pushback_index = 0;
 502
 503 int
 504 lgetc(int quotec)
 505 {
 506         int c, next;
 507
 508         if (parsebuf) {
 509                 /* Read character from the parsebuffer instead of input. */
 510                 if (parseindex >= 0) {
 511                         c = parsebuf[parseindex++];
 512                         if (c != '\0')
 513                                 return (c);
 514                         parsebuf = NULL;
 515                 } else
 516                         parseindex++;
 517         }
 518
 519         if (pushback_index)
 520                 return (pushback_buffer[--pushback_index]);
 521
 522         if (quotec) {
 523                 c = getc(file->stream);
 524                 if (c == EOF)
 525                         yyerror("reached end of file while parsing "
 526                             "quoted string");
 527                 return (c);
 528         }
 529
 530         c = getc(file->stream);
 531         while (c == '\\') {
 532                 next = getc(file->stream);
 533                 if (next != '\n') {
 534                         c = next;
 535                         break;
 536                 }
 537                 yylval.lineno = file->lineno;
 538                 file->lineno++;
 539                 c = getc(file->stream);
 540         }
 541
 542         return (c);
 543 }
 544
 545 int
 546 lungetc(int c)
 547 {
 548         if (c == EOF)
 549                 return (EOF);
 550         if (parsebuf) {
 551                 parseindex--;
 552                 if (parseindex >= 0)
 553                         return (c);
 554         }
 555         if (pushback_index < MAXPUSHBACK-1)
 556                 return (pushback_buffer[pushback_index++] = c);
 557         else
 558                 return (EOF);
 559 }
 560
 561 int
 562 findeol(void)
 563 {
 564         int c;
 565
 566         parsebuf = NULL;
 567
 568         /* Skip to either EOF or the first real EOL. */
 569         while (1) {
 570                 if (pushback_index)
 571                         c = pushback_buffer[--pushback_index];
 572                 else
 573                         c = lgetc(0);
 574                 if (c == '\n') {
 575                         file->lineno++;
 576                         break;
 577                 }
 578                 if (c == EOF)
 579                         break;
 580         }
 581         return (ERROR);
 582 }
 583
 584 int
 585 yylex(void)
 586 {
 587         unsigned char buf[8096];
 588         unsigned char *p, *val;
 589         int quotec, next, c;
 590         int token;
 591
 592 top:
 593         p = buf;
 594         c = lgetc(0);
 595         while (c == ' ' || c == '\t')
 596                 c = lgetc(0); /* nothing */
 597
 598         yylval.lineno = file->lineno;
 599         if (c == '#') {
 600                 c = lgetc(0);
 601                 while (c != '\n' && c != EOF)
 602                         c = lgetc(0); /* nothing */
 603         }
 604         if (c == '$' && parsebuf == NULL) {
 605                 while (1) {
 606                         c = lgetc(0);
 607                         if (c == EOF)
 608                                 return (0);
 609
 610                         if (p + 1 >= buf + sizeof(buf) - 1) {
 611                                 yyerror("string too long");
 612                                 return (findeol());
 613                         }
 614                         if (isalnum(c) || c == '_') {
 615                                 *p++ = c;
 616                                 continue;
 617                         }
 618                         *p = '\0';
 619                         lungetc(c);
 620                         break;
 621                 }
 622                 val = symget(buf);
 623                 if (val == NULL) {
 624                         yyerror("macro '%s' not defined", buf);
 625                         return (findeol());
 626                 }
 627                 parsebuf = val;
 628                 parseindex = 0;
 629                 goto top;
 630         }
 631
 632         switch (c) {
 633         case '\'':
 634         case '"':
 635                 quotec = c;
 636                 while (1) {
 637                         c = lgetc(quotec);
 638                         if (c == EOF)
 639                                 return (0);
 640                         if (c == '\n') {
 641                                 file->lineno++;
 642                                 continue;
 643                         } else if (c == '\\') {
 644                                 next = lgetc(quotec);
 645                                 if (next == EOF)
 646                                         return (0);
 647                                 if (next == quotec || c == ' ' || c == '\t')
 648                                         c = next;
 649                                 else if (next == '\n') {
 650                                         file->lineno++;
 651                                         continue;
 652                                 } else
 653                                         lungetc(next);
 654                         } else if (c == quotec) {
 655                                 *p = '\0';
 656                                 break;
 657                         } else if (c == '\0') {
 658                                 yyerror("syntax error");
 659                                 return (findeol());
 660                         }
 661                         if (p + 1 >= buf + sizeof(buf) - 1) {
 662                                 yyerror("string too long");
 663                                 return (findeol());
 664                         }
 665                         *p++ = c;
 666                 }
 667                 yylval.v.string = strdup(buf);
 668                 if (yylval.v.string == NULL)
 669                         err(1, "yylex: strdup");
 670                 return (STRING);
 671         }
 672
 673 #define allowed_to_end_number(x) \
 674         (isspace(x) || x == ')' || x ==',' || x == '/' || x == '}' || x == '=')
 675
 676         if (c == '-' || isdigit(c)) {
 677                 do {
 678                         *p++ = c;
 679                         if ((unsigned)(p-buf) >= sizeof(buf)) {
 680                                 yyerror("string too long");
 681                                 return (findeol());
 682                         }
 683                         c = lgetc(0);
 684                 } while (c != EOF && isdigit(c));
 685                 lungetc(c);
 686                 if (p == buf + 1 && buf[0] == '-')
 687                         goto nodigits;
 688                 if (c == EOF || allowed_to_end_number(c)) {
 689                         const char *errstr = NULL;
 690
 691                         *p = '\0';
 692                         yylval.v.number = strtonum(buf, LLONG_MIN,
 693                             LLONG_MAX, &errstr);
 694                         if (errstr) {
 695                                 yyerror("\"%s\" invalid number: %s",
 696                                     buf, errstr);
 697                                 return (findeol());
 698                         }
 699                         return (NUMBER);
 700                 } else {
 701 nodigits:
 702                         while (p > buf + 1)
 703                                 lungetc(*--p);
 704                         c = *--p;
 705                         if (c == '-')
 706                                 return (c);
 707                 }
 708         }
 709
 710 #define allowed_in_string(x) \
 711         (isalnum(x) || (ispunct(x) && x != '(' && x != ')' && \
 712         x != '{' && x != '}' && \
 713         x != '!' && x != '=' && x != '#' && \
 714         x != ','))
 715
 716         if (isalnum(c) || c == ':' || c == '_') {
 717                 do {
 718                         *p++ = c;
 719                         if ((unsigned)(p-buf) >= sizeof(buf)) {
 720                                 yyerror("string too long");
 721                                 return (findeol());
 722                         }
 723                         c = lgetc(0);
 724                 } while (c != EOF && (allowed_in_string(c)));
 725                 lungetc(c);
 726                 *p = '\0';
 727                 token = lookup(buf);
 728                 if (token == STRING) {
 729                         yylval.v.string = strdup(buf);
 730                         if (yylval.v.string == NULL)
 731                                 err(1, "yylex: strdup");
 732                 }
 733                 return (token);
 734         }
 735         if (c == '\n') {
 736                 yylval.lineno = file->lineno;
 737                 file->lineno++;
 738         }
 739         if (c == EOF)
 740                 return (0);
 741         return (c);
 742 }
 743
 744 int
 745 check_file_secrecy(int fd, const char *fname)
 746 {
 747         struct stat st;
 748
 749         if (fstat(fd, &st)) {
 750                 log_warn("cannot stat %s", fname);
 751                 return (-1);
 752         }
 753         if (st.st_uid != 0 && st.st_uid != getuid()) {
 754                 log_warnx("%s: owner not root or current user", fname);
 755                 return (-1);
 756         }
 757         if (st.st_mode & (S_IWGRP | S_IXGRP | S_IRWXO)) {
 758                 log_warnx("%s: group writable or world read/writable", fname);
 759                 return (-1);
 760         }
 761         return (0);
 762 }
 763
 764 struct file *
 765 newfile(const char *name, int secret)
 766 {
 767         struct file *nfile;
 768
 769         nfile = calloc(1, sizeof(struct file));
 770         if (nfile == NULL) {
 771                 log_warn("calloc");
 772                 return (NULL);
 773         }
 774         nfile->name = strdup(name);
 775         if (nfile->name == NULL) {
 776                 log_warn("strdup");
 777                 free(nfile);
 778                 return (NULL);
 779         }
 780         nfile->stream = fopen(nfile->name, "r");
 781         if (nfile->stream == NULL) {
 782                 /* no warning, we don't require a conf file */
 783                 free(nfile->name);
 784                 free(nfile);
 785                 return (NULL);
 786         } else if (secret &&
 787             check_file_secrecy(fileno(nfile->stream), nfile->name)) {
 788                 fclose(nfile->stream);
 789                 free(nfile->name);
 790                 free(nfile);
 791                 return (NULL);
 792         }
 793         nfile->lineno = 1;
 794         return (nfile);
 795 }
 796
 797 static void
 798 closefile(struct file *xfile)
 799 {
 800         fclose(xfile->stream);
 801         free(xfile->name);
 802         free(xfile);
 803 }
 804
 805 static void
 806 add_default_server(void)
 807 {
 808         new_srv = conf_new_server(D_SITENAME);
 809         log_debug("%s: adding default server %s", __func__, D_SITENAME);
 810 }
 811
 812 int
 813 parse_config(const char *filename, struct gotwebd *env)
 814 {
 815         struct sym *sym, *next;
 816
 817         if (config_init(env) == -1)
 818                 fatalx("failed to initialize configuration");
 819
 820         gotwebd = env;
 821
 822         file = newfile(filename, 0);
 823         if (file == NULL) {
 824                 add_default_server();
 825                 sockets_parse_sockets(env);
 826                 /* just return, as we don't require a conf file */
 827                 return (0);
 828         }
 829
 830         yyparse();
 831         errors = file->errors;
 832         closefile(file);
 833
 834         /* Free macros and check which have not been used. */
 835         TAILQ_FOREACH_SAFE(sym, &symhead, entry, next) {
 836                 if ((gotwebd->gotwebd_verbose > 1) && !sym->used)
 837                         fprintf(stderr, "warning: macro '%s' not used\n",
 838                             sym->nam);
 839                 if (!sym->persist) {
 840                         free(sym->nam);
 841                         free(sym->val);
 842                         TAILQ_REMOVE(&symhead, sym, entry);
 843                         free(sym);
 844                 }
 845         }
 846
 847         if (errors)
 848                 return (-1);
 849
 850         /* just add default server if no config specified */
 851         if (gotwebd->server_cnt == 0)
 852                 add_default_server();
 853
 854         /* setup our listening sockets */
 855         sockets_parse_sockets(env);
 856
 857         return (0);
 858 }
 859
 860 struct server *
 861 conf_new_server(const char *name)
 862 {
 863         struct server *srv = NULL;
 864
 865         srv = calloc(1, sizeof(*srv));
 866         if (srv == NULL)
 867                 fatalx("%s: calloc", __func__);
 868
 869         n = strlcpy(srv->name, name, sizeof(srv->name));
 870         if (n >= sizeof(srv->name))
 871                 fatalx("%s: strlcpy", __func__);
 872         n = snprintf(srv->unix_socket_name,
 873             sizeof(srv->unix_socket_name), "%s%s", D_HTTPD_CHROOT,
 874             D_UNIX_SOCKET);
 875         if (n < 0 || (size_t)n >= sizeof(srv->unix_socket_name))
 876                 fatalx("%s: snprintf", __func__);
 877         n = strlcpy(srv->repos_path, D_GOTPATH,
 878             sizeof(srv->repos_path));
 879         if (n >= sizeof(srv->repos_path))
 880                 fatalx("%s: strlcpy", __func__);
 881         n = strlcpy(srv->site_name, D_SITENAME,
 882             sizeof(srv->site_name));
 883         if (n >= sizeof(srv->site_name))
 884                 fatalx("%s: strlcpy", __func__);
 885         n = strlcpy(srv->site_owner, D_SITEOWNER,
 886             sizeof(srv->site_owner));
 887         if (n >= sizeof(srv->site_owner))
 888                 fatalx("%s: strlcpy", __func__);
 889         n = strlcpy(srv->site_link, D_SITELINK,
 890             sizeof(srv->site_link));
 891         if (n >= sizeof(srv->site_link))
 892                 fatalx("%s: strlcpy", __func__);
 893         n = strlcpy(srv->logo, D_GOTLOGO,
 894             sizeof(srv->logo));
 895         if (n >= sizeof(srv->logo))
 896                 fatalx("%s: strlcpy", __func__);
 897         n = strlcpy(srv->logo_url, D_GOTURL, sizeof(srv->logo_url));
 898         if (n >= sizeof(srv->logo_url))
 899                 fatalx("%s: strlcpy", __func__);
 900         n = strlcpy(srv->custom_css, D_GOTWEBCSS, sizeof(srv->custom_css));
 901         if (n >= sizeof(srv->custom_css))
 902                 fatalx("%s: strlcpy", __func__);
 903
 904         srv->show_site_owner = D_SHOWSOWNER;
 905         srv->show_repo_owner = D_SHOWROWNER;
 906         srv->show_repo_age = D_SHOWAGE;
 907         srv->show_repo_description = D_SHOWDESC;
 908         srv->show_repo_cloneurl = D_SHOWURL;
 909         srv->respect_exportok = D_RESPECTEXPORTOK;
 910
 911         srv->max_repos_display = D_MAXREPODISP;
 912         srv->max_commits_display = D_MAXCOMMITDISP;
 913         srv->max_repos = D_MAXREPO;
 914
 915         srv->unix_socket = 1;
 916         srv->fcgi_socket = 0;
 917
 918         TAILQ_INIT(&srv->al);
 919         TAILQ_INSERT_TAIL(&gotwebd->servers, srv, entry);
 920         gotwebd->server_cnt++;
 921
 922         return srv;
 923 };
 924
 925 int
 926 symset(const char *nam, const char *val, int persist)
 927 {
 928         struct sym *sym;
 929
 930         TAILQ_FOREACH(sym, &symhead, entry) {
 931                 if (strcmp(nam, sym->nam) == 0)
 932                         break;
 933         }
 934
 935         if (sym != NULL) {
 936                 if (sym->persist == 1)
 937                         return (0);
 938                 else {
 939                         free(sym->nam);
 940                         free(sym->val);
 941                         TAILQ_REMOVE(&symhead, sym, entry);
 942                         free(sym);
 943                 }
 944         }
 945         sym = calloc(1, sizeof(*sym));
 946         if (sym == NULL)
 947                 return (-1);
 948
 949         sym->nam = strdup(nam);
 950         if (sym->nam == NULL) {
 951                 free(sym);
 952                 return (-1);
 953         }
 954         sym->val = strdup(val);
 955         if (sym->val == NULL) {
 956                 free(sym->nam);
 957                 free(sym);
 958                 return (-1);
 959         }
 960         sym->used = 0;
 961         sym->persist = persist;
 962         TAILQ_INSERT_TAIL(&symhead, sym, entry);
 963         return (0);
 964 }
 965
 966 int
 967 cmdline_symset(char *s)
 968 {
 969         char *sym, *val;
 970         int ret;
 971
 972         val = strrchr(s, '=');
 973         if (val == NULL)
 974                 return (-1);
 975
 976         sym = strndup(s, val - s);
 977         if (sym == NULL)
 978                 fatal("%s: strndup", __func__);
 979
 980         ret = symset(sym, val + 1, 1);
 981         free(sym);
 982
 983         return (ret);
 984 }
 985
 986 char *
 987 symget(const char *nam)
 988 {
 989         struct sym *sym;
 990
 991         TAILQ_FOREACH(sym, &symhead, entry) {
 992                 if (strcmp(nam, sym->nam) == 0) {
 993                         sym->used = 1;
 994                         return (sym->val);
 995                 }
 996         }
 997         return (NULL);
 998 }
 999
1000 int
1001 get_addrs(const char *hostname, const char *servname, struct server *new_srv)
1002 {
1003         struct addrinfo hints, *res0, *res;
1004         int error;
1005         struct sockaddr_in *sin;
1006         struct sockaddr_in6 *sin6;
1007         struct address *h;
1008
1009         memset(&hints, 0, sizeof(hints));
1010         hints.ai_family = AF_UNSPEC;
1011         hints.ai_socktype = SOCK_STREAM;
1012         hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
1013         error = getaddrinfo(hostname, servname, &hints, &res0);
1014         if (error) {
1015                 log_warnx("%s: could not parse \"%s:%s\": %s", __func__,
1016                     hostname, servname, gai_strerror(error));
1017                 return (-1);
1018         }
1019
1020         for (res = res0; res; res = res->ai_next) {
1021                 if ((h = calloc(1, sizeof(*h))) == NULL)
1022                         fatal(__func__);
1023
1024                 if (hostname == NULL) {
1025                         strlcpy(h->ifname, "*", sizeof(h->ifname));
1026                 } else {
1027                         if (strlcpy(h->ifname, hostname, sizeof(h->ifname)) >=
1028                             sizeof(h->ifname)) {
1029                                 log_warnx("%s: address truncated: %s",
1030                                     __func__, hostname);
1031                                 freeaddrinfo(res0);
1032                                 free(h);
1033                                 return (-1);
1034                         }
1035                 }
1036
1037                 h->ai_family = res->ai_family;
1038                 h->ai_socktype = res->ai_socktype;
1039                 h->ai_protocol = res->ai_protocol;
1040                 memcpy(&h->ss, res->ai_addr, res->ai_addrlen);
1041                 h->slen = res->ai_addrlen;
1042
1043                 switch (res->ai_family) {
1044                 case AF_INET:
1045                         sin = (struct sockaddr_in *)res->ai_addr;
1046                         h->port = ntohs(sin->sin_port);
1047                         break;
1048                 case AF_INET6:
1049                         sin6 = (struct sockaddr_in6 *)res->ai_addr;
1050                         h->port = ntohs(sin6->sin6_port);
1051                         break;
1052                 default:
1053                         fatalx("unknown address family %d", res->ai_family);
1054                 }
1055
1056                 if (add_addr(new_srv, h))
1057                         return -1;
1058         }
1059         freeaddrinfo(res0);
1060         return (0);
1061 }
1062
1063 int
1064 addr_dup_check(struct addresslist *al, struct address *h, const char *new_srv,
1065     const char *other_srv)
1066 {
1067         struct address *a;
1068         void *ia;
1069         char buf[INET6_ADDRSTRLEN];
1070         const char *addrstr;
1071
1072         TAILQ_FOREACH(a, al, entry) {
1073                 if (a->ai_family != h->ai_family ||
1074                     a->ai_socktype != h->ai_socktype ||
1075                     a->ai_protocol != h->ai_protocol ||
1076                     a->slen != h->slen ||
1077                     memcmp(&a->ss, &h->ss, a->slen) != 0)
1078                         continue;
1079
1080                 switch (h->ss.ss_family) {
1081                 case AF_INET:
1082                         ia = &((struct sockaddr_in *)(&h->ss))->sin_addr;
1083                         break;
1084                 case AF_INET6:
1085                         ia = &((struct sockaddr_in6 *)(&h->ss))->sin6_addr;
1086                         break;
1087                 default:
1088                         yyerror("unknown address family: %d", h->ss.ss_family);
1089                         return -1;
1090                 }
1091                 addrstr = inet_ntop(h->ss.ss_family, ia, buf, sizeof(buf));
1092                 if (addrstr) {
1093                         if (other_srv) {
1094                                 yyerror("server %s: duplicate fcgi listen "
1095                                     "address %s:%d, already used by server %s",
1096                                     new_srv, addrstr, h->port, other_srv);
1097                         } else {
1098                                 log_warnx("server: %s: duplicate fcgi listen "
1099                                     "address %s:%d", new_srv, addrstr, h->port);
1100                         }
1101                 } else {
1102                         if (other_srv) {
1103                                 yyerror("server: %s: duplicate fcgi listen "
1104                                     "address, already used by server %s",
1105                                     new_srv, other_srv);
1106                         } else {
1107                                 log_warnx("server %s: duplicate fcgi listen "
1108                                     "address", new_srv);
1109                         }
1110                 }
1111
1112                 return -1;
1113         }
1114
1115         return 0;
1116 }
1117
1118 int
1119 add_addr(struct server *new_srv, struct address *h)
1120 {
1121         struct server *srv;
1122
1123         /* Address cannot be shared between different servers. */
1124         TAILQ_FOREACH(srv, &gotwebd->servers, entry) {
1125                 if (srv == new_srv)
1126                         continue;
1127                 if (addr_dup_check(&srv->al, h, new_srv->name, srv->name))
1128                         return -1;
1129         }
1130
1131         /* Tolerate duplicate address lines within the scope of a server. */
1132         if (addr_dup_check(&new_srv->al, h, NULL, NULL) == 0)
1133                 TAILQ_INSERT_TAIL(&new_srv->al, h, entry);
1134         else
1135                 free(h);
1136
1137         return 0;
1138 }