libexec/got-read-gotconfig/got-read-gotconfig.c

   1 /*
   2  * Copyright (c) 2020 Stefan Sperling <stsp@openbsd.org>
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include "got_compat.h"
  18
  19 #include <sys/types.h>
  20 #include <sys/queue.h>
  21 #include <sys/uio.h>
  22 #include <sys/time.h>
  23
  24 #include <stdint.h>
  25 #include <limits.h>
  26 #include <signal.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31 #include <zlib.h>
  32
  33 #include "got_error.h"
  34 #include "got_object.h"
  35 #include "got_path.h"
  36 #include "got_repository.h"
  37
  38 #include "got_lib_delta.h"
  39 #include "got_lib_object.h"
  40 #include "got_lib_privsep.h"
  41
  42 #include "gotconfig.h"
  43
  44 /* parse.y */
  45 static volatile sig_atomic_t sigint_received;
  46
  47 static void
  48 catch_sigint(int signo)
  49 {
  50         sigint_received = 1;
  51 }
  52
  53 static const struct got_error *
  54 make_fetch_url(char **url, struct gotconfig_remote_repo *repo)
  55 {
  56         const struct got_error *err = NULL;
  57         char *s = NULL, *p = NULL;
  58         const char *protocol, *server, *repo_path;
  59         int port;
  60
  61         *url = NULL;
  62
  63         if (repo->fetch_config && repo->fetch_config->protocol)
  64                 protocol = repo->fetch_config->protocol;
  65         else
  66                 protocol = repo->protocol;
  67         if (protocol == NULL)
  68                 return got_error_fmt(GOT_ERR_PARSE_CONFIG,
  69                     "fetch protocol required for remote repository \"%s\"",
  70                     repo->name);
  71         if (asprintf(&s, "%s://", protocol) == -1)
  72                 return got_error_from_errno("asprintf");
  73
  74         if (repo->fetch_config && repo->fetch_config->server)
  75                 server = repo->fetch_config->server;
  76         else
  77                 server = repo->server;
  78         if (server == NULL)
  79                 return got_error_fmt(GOT_ERR_PARSE_CONFIG,
  80                     "fetch server required for remote repository \"%s\"",
  81                     repo->name);
  82         p = s;
  83         s = NULL;
  84         if (asprintf(&s, "%s%s", p, server) == -1) {
  85                 err = got_error_from_errno("asprintf");
  86                 goto done;
  87         }
  88         free(p);
  89         p = NULL;
  90
  91         if (repo->fetch_config && repo->fetch_config->server)
  92                 port = repo->fetch_config->port;
  93         else
  94                 port = repo->port;
  95         if (port) {
  96                 p = s;
  97                 s = NULL;
  98                 if (asprintf(&s, "%s:%d", p, repo->port) == -1) {
  99                         err = got_error_from_errno("asprintf");
 100                         goto done;
 101                 }
 102                 free(p);
 103                 p = NULL;
 104         }
 105
 106         if (repo->fetch_config && repo->fetch_config->repository)
 107                 repo_path = repo->fetch_config->repository;
 108         else
 109                 repo_path = repo->repository;
 110         if (repo_path == NULL)
 111                 return got_error_fmt(GOT_ERR_PARSE_CONFIG,
 112                     "fetch repository path required for remote "
 113                     "repository \"%s\"", repo->name);
 114
 115         while (repo_path[0] == '/')
 116                 repo_path++;
 117         p = s;
 118         s = NULL;
 119         if (asprintf(&s, "%s/%s", p, repo_path) == -1) {
 120                 err = got_error_from_errno("asprintf");
 121                 goto done;
 122         }
 123         free(p);
 124         p = NULL;
 125
 126         got_path_strip_trailing_slashes(s);
 127 done:
 128         if (err) {
 129                 free(s);
 130                 free(p);
 131         } else
 132                 *url = s;
 133         return err;
 134 }
 135
 136 static const struct got_error *
 137 make_send_url(char **url, struct gotconfig_remote_repo *repo)
 138 {
 139         const struct got_error *err = NULL;
 140         char *s = NULL, *p = NULL;
 141         const char *protocol, *server, *repo_path;
 142         int port;
 143
 144         *url = NULL;
 145
 146         if (repo->send_config && repo->send_config->protocol)
 147                 protocol = repo->send_config->protocol;
 148         else
 149                 protocol = repo->protocol;
 150         if (protocol == NULL)
 151                 return got_error_fmt(GOT_ERR_PARSE_CONFIG,
 152                     "send protocol required for remote repository \"%s\"",
 153                     repo->name);
 154         if (asprintf(&s, "%s://", protocol) == -1)
 155                 return got_error_from_errno("asprintf");
 156
 157         if (repo->send_config && repo->send_config->server)
 158                 server = repo->send_config->server;
 159         else
 160                 server = repo->server;
 161         if (server == NULL)
 162                 return got_error_fmt(GOT_ERR_PARSE_CONFIG,
 163                     "send server required for remote repository \"%s\"",
 164                     repo->name);
 165         p = s;
 166         s = NULL;
 167         if (asprintf(&s, "%s%s", p, server) == -1) {
 168                 err = got_error_from_errno("asprintf");
 169                 goto done;
 170         }
 171         free(p);
 172         p = NULL;
 173
 174         if (repo->send_config && repo->send_config->server)
 175                 port = repo->send_config->port;
 176         else
 177                 port = repo->port;
 178         if (port) {
 179                 p = s;
 180                 s = NULL;
 181                 if (asprintf(&s, "%s:%d", p, repo->port) == -1) {
 182                         err = got_error_from_errno("asprintf");
 183                         goto done;
 184                 }
 185                 free(p);
 186                 p = NULL;
 187         }
 188
 189         if (repo->send_config && repo->send_config->repository)
 190                 repo_path = repo->send_config->repository;
 191         else
 192                 repo_path = repo->repository;
 193         if (repo_path == NULL)
 194                 return got_error_fmt(GOT_ERR_PARSE_CONFIG,
 195                     "send repository path required for remote "
 196                     "repository \"%s\"", repo->name);
 197
 198         while (repo_path[0] == '/')
 199                 repo_path++;
 200         p = s;
 201         s = NULL;
 202         if (asprintf(&s, "%s/%s", p, repo_path) == -1) {
 203                 err = got_error_from_errno("asprintf");
 204                 goto done;
 205         }
 206         free(p);
 207         p = NULL;
 208
 209         got_path_strip_trailing_slashes(s);
 210 done:
 211         if (err) {
 212                 free(s);
 213                 free(p);
 214         } else
 215                 *url = s;
 216         return err;
 217 }
 218
 219 static const struct got_error *
 220 send_gotconfig_str(struct imsgbuf *ibuf, const char *value)
 221 {
 222         size_t len = value ? strlen(value) : 0;
 223
 224         if (imsg_compose(ibuf, GOT_IMSG_GOTCONFIG_STR_VAL, 0, 0, -1,
 225             value, len) == -1)
 226                 return got_error_from_errno("imsg_compose GOTCONFIG_STR_VAL");
 227
 228         return got_privsep_flush_imsg(ibuf);
 229 }
 230
 231 static const struct got_error *
 232 send_gotconfig_remotes(struct imsgbuf *ibuf,
 233     struct gotconfig_remote_repo_list *remotes, int nremotes)
 234 {
 235         const struct got_error *err = NULL;
 236         struct got_imsg_remotes iremotes;
 237         struct gotconfig_remote_repo *repo;
 238         char *fetch_url = NULL, *send_url = NULL;
 239
 240         iremotes.nremotes = nremotes;
 241         if (imsg_compose(ibuf, GOT_IMSG_GOTCONFIG_REMOTES, 0, 0, -1,
 242             &iremotes, sizeof(iremotes)) == -1)
 243                 return got_error_from_errno("imsg_compose GOTCONFIG_REMOTES");
 244
 245         err = got_privsep_flush_imsg(ibuf);
 246         imsg_clear(ibuf);
 247         if (err)
 248                 return err;
 249
 250         TAILQ_FOREACH(repo, remotes, entry) {
 251                 struct got_imsg_remote iremote;
 252                 size_t len = sizeof(iremote);
 253                 struct ibuf *wbuf;
 254                 struct node_branch *branch;
 255                 struct node_ref *ref;
 256                 int nfetch_branches = 0, nsend_branches = 0, nfetch_refs = 0;
 257
 258                 if (repo->fetch_config && repo->fetch_config->branch)
 259                         branch = repo->fetch_config->branch;
 260                 else
 261                         branch = repo->branch;
 262                 while (branch) {
 263                         branch = branch->next;
 264                         nfetch_branches++;
 265                 }
 266
 267                 if (repo->send_config && repo->send_config->branch)
 268                         branch = repo->send_config->branch;
 269                 else
 270                         branch = repo->branch;
 271                 while (branch) {
 272                         branch = branch->next;
 273                         nsend_branches++;
 274                 }
 275
 276                 ref = repo->fetch_ref;
 277                 while (ref) {
 278                         ref = ref->next;
 279                         nfetch_refs++;
 280                 }
 281
 282                 iremote.nfetch_branches = nfetch_branches;
 283                 iremote.nsend_branches = nsend_branches;
 284                 iremote.nfetch_refs = nfetch_refs;
 285                 iremote.mirror_references = repo->mirror_references;
 286                 iremote.fetch_all_branches = repo->fetch_all_branches;
 287
 288                 iremote.name_len = strlen(repo->name);
 289                 len += iremote.name_len;
 290
 291                 err = make_fetch_url(&fetch_url, repo);
 292                 if (err)
 293                         break;
 294                 iremote.fetch_url_len = strlen(fetch_url);
 295                 len += iremote.fetch_url_len;
 296
 297                 err = make_send_url(&send_url, repo);
 298                 if (err)
 299                         break;
 300                 iremote.send_url_len = strlen(send_url);
 301                 len += iremote.send_url_len;
 302
 303                 wbuf = imsg_create(ibuf, GOT_IMSG_GOTCONFIG_REMOTE, 0, 0, len);
 304                 if (wbuf == NULL) {
 305                         err = got_error_from_errno(
 306                             "imsg_create GOTCONFIG_REMOTE");
 307                         break;
 308                 }
 309
 310                 if (imsg_add(wbuf, &iremote, sizeof(iremote)) == -1) {
 311                         err = got_error_from_errno(
 312                             "imsg_add GOTCONFIG_REMOTE");
 313                         break;
 314                 }
 315
 316                 if (imsg_add(wbuf, repo->name, iremote.name_len) == -1) {
 317                         err = got_error_from_errno(
 318                             "imsg_add GOTCONFIG_REMOTE");
 319                         break;
 320                 }
 321                 if (imsg_add(wbuf, fetch_url, iremote.fetch_url_len) == -1) {
 322                         err = got_error_from_errno(
 323                             "imsg_add GOTCONFIG_REMOTE");
 324                         break;
 325                 }
 326                 if (imsg_add(wbuf, send_url, iremote.send_url_len) == -1) {
 327                         err = got_error_from_errno(
 328                             "imsg_add GOTCONFIG_REMOTE");
 329                         break;
 330                 }
 331
 332                 wbuf->fd = -1;
 333                 imsg_close(ibuf, wbuf);
 334                 err = got_privsep_flush_imsg(ibuf);
 335                 if (err)
 336                         break;
 337
 338                 free(fetch_url);
 339                 fetch_url = NULL;
 340                 free(send_url);
 341                 send_url = NULL;
 342
 343                 if (repo->fetch_config && repo->fetch_config->branch)
 344                         branch = repo->fetch_config->branch;
 345                 else
 346                         branch = repo->branch;
 347                 while (branch) {
 348                         err = send_gotconfig_str(ibuf, branch->branch_name);
 349                         if (err)
 350                                 break;
 351                         branch = branch->next;
 352                 }
 353
 354                 if (repo->send_config && repo->send_config->branch)
 355                         branch = repo->send_config->branch;
 356                 else
 357                         branch = repo->branch;
 358                 while (branch) {
 359                         err = send_gotconfig_str(ibuf, branch->branch_name);
 360                         if (err)
 361                                 break;
 362                         branch = branch->next;
 363                 }
 364
 365                 ref = repo->fetch_ref;
 366                 while (ref) {
 367                         err = send_gotconfig_str(ibuf, ref->ref_name);
 368                         if (err)
 369                                 break;
 370                         ref = ref->next;
 371                 }
 372         }
 373
 374         free(fetch_url);
 375         free(send_url);
 376         return err;
 377 }
 378
 379 static const struct got_error *
 380 validate_protocol(const char *protocol, const char *repo_name)
 381 {
 382         static char msg[512];
 383
 384         if (strcmp(protocol, "ssh") != 0 &&
 385             strcmp(protocol, "git+ssh") != 0 &&
 386             strcmp(protocol, "git") != 0) {
 387                 snprintf(msg, sizeof(msg),"unknown protocol \"%s\" "
 388                     "for remote repository \"%s\"", protocol, repo_name);
 389                 return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
 390         }
 391
 392         return NULL;
 393 }
 394
 395 static const struct got_error *
 396 validate_config(struct gotconfig *gotconfig)
 397 {
 398         const struct got_error *err;
 399         struct gotconfig_remote_repo *repo, *repo2;
 400         static char msg[512];
 401
 402         TAILQ_FOREACH(repo, &gotconfig->remotes, entry) {
 403                 if (repo->name == NULL) {
 404                         return got_error_msg(GOT_ERR_PARSE_CONFIG,
 405                             "name required for remote repository");
 406                 }
 407
 408                 TAILQ_FOREACH(repo2, &gotconfig->remotes, entry) {
 409                         if (repo == repo2 ||
 410                             strcmp(repo->name, repo2->name) != 0)
 411                                 continue;
 412                         snprintf(msg, sizeof(msg),
 413                             "duplicate remote repository name '%s'",
 414                             repo->name);
 415                         return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
 416                 }
 417
 418                 if (repo->server == NULL &&
 419                     (repo->fetch_config == NULL ||
 420                     repo->fetch_config->server == NULL) &&
 421                     (repo->send_config == NULL ||
 422                     repo->send_config->server == NULL)) {
 423                         snprintf(msg, sizeof(msg),
 424                             "server required for remote repository \"%s\"",
 425                             repo->name);
 426                         return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
 427                 }
 428
 429                 if (repo->protocol == NULL &&
 430                     (repo->fetch_config == NULL ||
 431                     repo->fetch_config->protocol == NULL) &&
 432                     (repo->send_config == NULL ||
 433                     repo->send_config->protocol == NULL)) {
 434                         snprintf(msg, sizeof(msg),
 435                             "protocol required for remote repository \"%s\"",
 436                             repo->name);
 437                         return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
 438                 }
 439
 440                 if (repo->protocol) {
 441                         err = validate_protocol(repo->protocol, repo->name);
 442                         if (err)
 443                                 return err;
 444                 }
 445                 if (repo->fetch_config && repo->fetch_config->protocol) {
 446                         err = validate_protocol(repo->fetch_config->protocol,
 447                             repo->name);
 448                         if (err)
 449                                 return err;
 450                 }
 451                 if (repo->send_config && repo->send_config->protocol) {
 452                         err = validate_protocol(repo->send_config->protocol,
 453                             repo->name);
 454                         if (err)
 455                                 return err;
 456                 }
 457
 458                 if (repo->repository == NULL &&
 459                     (repo->fetch_config == NULL ||
 460                     repo->fetch_config->repository == NULL) &&
 461                     (repo->send_config == NULL ||
 462                     repo->send_config->repository == NULL)) {
 463                         snprintf(msg, sizeof(msg),
 464                             "repository path required for remote "
 465                             "repository \"%s\"", repo->name);
 466                         return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
 467                 }
 468         }
 469
 470         return NULL;
 471 }
 472
 473 int
 474 main(int argc, char *argv[])
 475 {
 476         const struct got_error *err = NULL;
 477         struct imsgbuf ibuf;
 478         struct gotconfig *gotconfig = NULL;
 479         size_t datalen;
 480         const char *filename = "got.conf";
 481 #if 0
 482         static int attached;
 483
 484         while (!attached)
 485                 sleep(1);
 486 #endif
 487         signal(SIGINT, catch_sigint);
 488
 489         imsg_init(&ibuf, GOT_IMSG_FD_CHILD);
 490
 491 #ifndef PROFILE
 492         /* revoke access to most system calls */
 493         if (pledge("stdio recvfd", NULL) == -1) {
 494                 err = got_error_from_errno("pledge");
 495                 got_privsep_send_error(&ibuf, err);
 496                 return 1;
 497         }
 498
 499         /* revoke fs access */
 500         if (landlock_no_fs() == -1) {
 501                 err = got_error_from_errno("landlock_no_fs");
 502                 got_privsep_send_error(&ibuf, err);
 503                 return 1;
 504         }
 505         if (cap_enter() == -1) {
 506                 err = got_error_from_errno("cap_enter");
 507                 got_privsep_send_error(&ibuf, err);
 508                 return 1;
 509         }
 510 #endif
 511
 512         if (argc > 1)
 513                 filename = argv[1];
 514
 515         for (;;) {
 516                 struct imsg imsg;
 517
 518                 memset(&imsg, 0, sizeof(imsg));
 519                 imsg.fd = -1;
 520
 521                 if (sigint_received) {
 522                         err = got_error(GOT_ERR_CANCELLED);
 523                         break;
 524                 }
 525
 526                 err = got_privsep_recv_imsg(&imsg, &ibuf, 0);
 527                 if (err) {
 528                         if (err->code == GOT_ERR_PRIVSEP_PIPE)
 529                                 err = NULL;
 530                         break;
 531                 }
 532
 533                 if (imsg.hdr.type == GOT_IMSG_STOP)
 534                         break;
 535
 536                 switch (imsg.hdr.type) {
 537                 case GOT_IMSG_GOTCONFIG_PARSE_REQUEST:
 538                         datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
 539                         if (datalen != 0) {
 540                                 err = got_error(GOT_ERR_PRIVSEP_LEN);
 541                                 break;
 542                         }
 543                         if (imsg.fd == -1){
 544                                 err = got_error(GOT_ERR_PRIVSEP_NO_FD);
 545                                 break;
 546                         }
 547
 548                         if (gotconfig)
 549                                 gotconfig_free(gotconfig);
 550                         err = gotconfig_parse(&gotconfig, filename, &imsg.fd);
 551                         if (err)
 552                                 break;
 553                         err = validate_config(gotconfig);
 554                         break;
 555                 case GOT_IMSG_GOTCONFIG_AUTHOR_REQUEST:
 556                         if (gotconfig == NULL) {
 557                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 558                                 break;
 559                         }
 560                         err = send_gotconfig_str(&ibuf,
 561                             gotconfig->author ?  gotconfig->author : "");
 562                         break;
 563                 case GOT_IMSG_GOTCONFIG_ALLOWEDSIGNERS_REQUEST:
 564                         if (gotconfig == NULL) {
 565                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 566                                 break;
 567                         }
 568                         err = send_gotconfig_str(&ibuf,
 569                             gotconfig->allowed_signers_file ?
 570                                 gotconfig->allowed_signers_file : "");
 571                         break;
 572                 case GOT_IMSG_GOTCONFIG_REVOKEDSIGNERS_REQUEST:
 573                         if (gotconfig == NULL) {
 574                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 575                                 break;
 576                         }
 577                         err = send_gotconfig_str(&ibuf,
 578                             gotconfig->revoked_signers_file ?
 579                                 gotconfig->revoked_signers_file : "");
 580                         break;
 581                 case GOT_IMSG_GOTCONFIG_SIGNERID_REQUEST:
 582                         if (gotconfig == NULL) {
 583                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 584                                 break;
 585                         }
 586                         err = send_gotconfig_str(&ibuf,
 587                             gotconfig->signer_id ? gotconfig->signer_id : "");
 588                         break;
 589                 case GOT_IMSG_GOTCONFIG_REMOTES_REQUEST:
 590                         if (gotconfig == NULL) {
 591                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 592                                 break;
 593                         }
 594                         err = send_gotconfig_remotes(&ibuf,
 595                             &gotconfig->remotes, gotconfig->nremotes);
 596                         break;
 597                 default:
 598                         err = got_error(GOT_ERR_PRIVSEP_MSG);
 599                         break;
 600                 }
 601
 602                 if (imsg.fd != -1) {
 603                         if (close(imsg.fd) == -1 && err == NULL)
 604                                 err = got_error_from_errno("close");
 605                 }
 606
 607                 imsg_free(&imsg);
 608                 if (err)
 609                         break;
 610         }
 611
 612         imsg_clear(&ibuf);
 613         if (err) {
 614                 if (!sigint_received && err->code != GOT_ERR_PRIVSEP_PIPE) {
 615                         fprintf(stderr, "%s: %s\n", getprogname(), err->msg);
 616                         got_privsep_send_error(&ibuf, err);
 617                 }
 618         }
 619         if (close(GOT_IMSG_FD_CHILD) == -1 && err == NULL)
 620                 err = got_error_from_errno("close");
 621         return err ? 1 : 0;
 622 }