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                 imsg_close(ibuf, wbuf);
 333                 err = got_privsep_flush_imsg(ibuf);
 334                 if (err)
 335                         break;
 336
 337                 free(fetch_url);
 338                 fetch_url = NULL;
 339                 free(send_url);
 340                 send_url = NULL;
 341
 342                 if (repo->fetch_config && repo->fetch_config->branch)
 343                         branch = repo->fetch_config->branch;
 344                 else
 345                         branch = repo->branch;
 346                 while (branch) {
 347                         err = send_gotconfig_str(ibuf, branch->branch_name);
 348                         if (err)
 349                                 break;
 350                         branch = branch->next;
 351                 }
 352
 353                 if (repo->send_config && repo->send_config->branch)
 354                         branch = repo->send_config->branch;
 355                 else
 356                         branch = repo->branch;
 357                 while (branch) {
 358                         err = send_gotconfig_str(ibuf, branch->branch_name);
 359                         if (err)
 360                                 break;
 361                         branch = branch->next;
 362                 }
 363
 364                 ref = repo->fetch_ref;
 365                 while (ref) {
 366                         err = send_gotconfig_str(ibuf, ref->ref_name);
 367                         if (err)
 368                                 break;
 369                         ref = ref->next;
 370                 }
 371         }
 372
 373         free(fetch_url);
 374         free(send_url);
 375         return err;
 376 }
 377
 378 static const struct got_error *
 379 validate_protocol(const char *protocol, const char *repo_name)
 380 {
 381         static char msg[512];
 382
 383         if (strcmp(protocol, "ssh") != 0 &&
 384             strcmp(protocol, "git+ssh") != 0 &&
 385             strcmp(protocol, "git") != 0 &&
 386             strcmp(protocol, "git+http") != 0 &&
 387             strcmp(protocol, "http") != 0 &&
 388             strcmp(protocol, "https") != 0 &&
 389             strcmp(protocol, "git+https") != 0) {
 390                 snprintf(msg, sizeof(msg),"unknown protocol \"%s\" "
 391                     "for remote repository \"%s\"", protocol, repo_name);
 392                 return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
 393         }
 394
 395         return NULL;
 396 }
 397
 398 static const struct got_error *
 399 validate_config(struct gotconfig *gotconfig)
 400 {
 401         const struct got_error *err;
 402         struct gotconfig_remote_repo *repo, *repo2;
 403         static char msg[512];
 404
 405         TAILQ_FOREACH(repo, &gotconfig->remotes, entry) {
 406                 if (repo->name == NULL) {
 407                         return got_error_msg(GOT_ERR_PARSE_CONFIG,
 408                             "name required for remote repository");
 409                 }
 410
 411                 TAILQ_FOREACH(repo2, &gotconfig->remotes, entry) {
 412                         if (repo == repo2 ||
 413                             strcmp(repo->name, repo2->name) != 0)
 414                                 continue;
 415                         snprintf(msg, sizeof(msg),
 416                             "duplicate remote repository name '%s'",
 417                             repo->name);
 418                         return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
 419                 }
 420
 421                 if (repo->server == NULL &&
 422                     (repo->fetch_config == NULL ||
 423                     repo->fetch_config->server == NULL) &&
 424                     (repo->send_config == NULL ||
 425                     repo->send_config->server == NULL)) {
 426                         snprintf(msg, sizeof(msg),
 427                             "server required for remote repository \"%s\"",
 428                             repo->name);
 429                         return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
 430                 }
 431
 432                 if (repo->protocol == NULL &&
 433                     (repo->fetch_config == NULL ||
 434                     repo->fetch_config->protocol == NULL) &&
 435                     (repo->send_config == NULL ||
 436                     repo->send_config->protocol == NULL)) {
 437                         snprintf(msg, sizeof(msg),
 438                             "protocol required for remote repository \"%s\"",
 439                             repo->name);
 440                         return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
 441                 }
 442
 443                 if (repo->protocol) {
 444                         err = validate_protocol(repo->protocol, repo->name);
 445                         if (err)
 446                                 return err;
 447                 }
 448                 if (repo->fetch_config && repo->fetch_config->protocol) {
 449                         err = validate_protocol(repo->fetch_config->protocol,
 450                             repo->name);
 451                         if (err)
 452                                 return err;
 453                 }
 454                 if (repo->send_config && repo->send_config->protocol) {
 455                         err = validate_protocol(repo->send_config->protocol,
 456                             repo->name);
 457                         if (err)
 458                                 return err;
 459                 }
 460
 461                 if (repo->repository == NULL &&
 462                     (repo->fetch_config == NULL ||
 463                     repo->fetch_config->repository == NULL) &&
 464                     (repo->send_config == NULL ||
 465                     repo->send_config->repository == NULL)) {
 466                         snprintf(msg, sizeof(msg),
 467                             "repository path required for remote "
 468                             "repository \"%s\"", repo->name);
 469                         return got_error_msg(GOT_ERR_PARSE_CONFIG, msg);
 470                 }
 471         }
 472
 473         return NULL;
 474 }
 475
 476 int
 477 main(int argc, char *argv[])
 478 {
 479         const struct got_error *err = NULL;
 480         struct imsgbuf ibuf;
 481         struct gotconfig *gotconfig = NULL;
 482         size_t datalen;
 483         const char *filename = "got.conf";
 484 #if 0
 485         static int attached;
 486
 487         while (!attached)
 488                 sleep(1);
 489 #endif
 490         signal(SIGINT, catch_sigint);
 491
 492         imsg_init(&ibuf, GOT_IMSG_FD_CHILD);
 493
 494 #ifndef PROFILE
 495         /* revoke access to most system calls */
 496         if (pledge("stdio recvfd", NULL) == -1) {
 497                 err = got_error_from_errno("pledge");
 498                 got_privsep_send_error(&ibuf, err);
 499                 return 1;
 500         }
 501
 502         /* revoke fs access */
 503         if (landlock_no_fs() == -1) {
 504                 err = got_error_from_errno("landlock_no_fs");
 505                 got_privsep_send_error(&ibuf, err);
 506                 return 1;
 507         }
 508         if (cap_enter() == -1) {
 509                 err = got_error_from_errno("cap_enter");
 510                 got_privsep_send_error(&ibuf, err);
 511                 return 1;
 512         }
 513 #endif
 514
 515         if (argc > 1)
 516                 filename = argv[1];
 517
 518         for (;;) {
 519                 struct imsg imsg;
 520                 int fd = -1;
 521
 522                 memset(&imsg, 0, sizeof(imsg));
 523
 524                 if (sigint_received) {
 525                         err = got_error(GOT_ERR_CANCELLED);
 526                         break;
 527                 }
 528
 529                 err = got_privsep_recv_imsg(&imsg, &ibuf, 0);
 530                 if (err) {
 531                         if (err->code == GOT_ERR_PRIVSEP_PIPE)
 532                                 err = NULL;
 533                         break;
 534                 }
 535
 536                 if (imsg.hdr.type == GOT_IMSG_STOP)
 537                         break;
 538
 539                 switch (imsg.hdr.type) {
 540                 case GOT_IMSG_GOTCONFIG_PARSE_REQUEST:
 541                         datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
 542                         if (datalen != 0) {
 543                                 err = got_error(GOT_ERR_PRIVSEP_LEN);
 544                                 break;
 545                         }
 546                         fd = imsg_get_fd(&imsg);
 547                         if (fd == -1){
 548                                 err = got_error(GOT_ERR_PRIVSEP_NO_FD);
 549                                 break;
 550                         }
 551
 552                         if (gotconfig)
 553                                 gotconfig_free(gotconfig);
 554                         err = gotconfig_parse(&gotconfig, filename, &fd);
 555                         if (err)
 556                                 break;
 557                         err = validate_config(gotconfig);
 558                         break;
 559                 case GOT_IMSG_GOTCONFIG_AUTHOR_REQUEST:
 560                         if (gotconfig == NULL) {
 561                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 562                                 break;
 563                         }
 564                         err = send_gotconfig_str(&ibuf,
 565                             gotconfig->author ?  gotconfig->author : "");
 566                         break;
 567                 case GOT_IMSG_GOTCONFIG_ALLOWEDSIGNERS_REQUEST:
 568                         if (gotconfig == NULL) {
 569                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 570                                 break;
 571                         }
 572                         err = send_gotconfig_str(&ibuf,
 573                             gotconfig->allowed_signers_file ?
 574                                 gotconfig->allowed_signers_file : "");
 575                         break;
 576                 case GOT_IMSG_GOTCONFIG_REVOKEDSIGNERS_REQUEST:
 577                         if (gotconfig == NULL) {
 578                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 579                                 break;
 580                         }
 581                         err = send_gotconfig_str(&ibuf,
 582                             gotconfig->revoked_signers_file ?
 583                                 gotconfig->revoked_signers_file : "");
 584                         break;
 585                 case GOT_IMSG_GOTCONFIG_SIGNERID_REQUEST:
 586                         if (gotconfig == NULL) {
 587                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 588                                 break;
 589                         }
 590                         err = send_gotconfig_str(&ibuf,
 591                             gotconfig->signer_id ? gotconfig->signer_id : "");
 592                         break;
 593                 case GOT_IMSG_GOTCONFIG_REMOTES_REQUEST:
 594                         if (gotconfig == NULL) {
 595                                 err = got_error(GOT_ERR_PRIVSEP_MSG);
 596                                 break;
 597                         }
 598                         err = send_gotconfig_remotes(&ibuf,
 599                             &gotconfig->remotes, gotconfig->nremotes);
 600                         break;
 601                 default:
 602                         err = got_error(GOT_ERR_PRIVSEP_MSG);
 603                         break;
 604                 }
 605
 606                 if (fd != -1) {
 607                         if (close(fd) == -1 && err == NULL)
 608                                 err = got_error_from_errno("close");
 609                 }
 610
 611                 imsg_free(&imsg);
 612                 if (err)
 613                         break;
 614         }
 615
 616         imsg_clear(&ibuf);
 617         if (err) {
 618                 if (!sigint_received && err->code != GOT_ERR_PRIVSEP_PIPE) {
 619                         fprintf(stderr, "%s: %s\n", getprogname(), err->msg);
 620                         got_privsep_send_error(&ibuf, err);
 621                 }
 622         }
 623         if (close(GOT_IMSG_FD_CHILD) == -1 && err == NULL)
 624                 err = got_error_from_errno("close");
 625         return err ? 1 : 0;
 626 }