gotctl/gotctl.c

   1 /*
   2  * Copyright (c) 2022 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/queue.h>
  20 #include <sys/socket.h>
  21 #include <sys/un.h>
  22
  23 #include <err.h>
  24 #include <event.h>
  25 #include <imsg.h>
  26 #include <limits.h>
  27 #include <locale.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <getopt.h>
  32 #include <unistd.h>
  33
  34 #include "got_error.h"
  35 #include "got_version.h"
  36 #include "got_path.h"
  37
  38 #include "got_lib_gitproto.h"
  39
  40 #include "gotd.h"
  41
  42 #ifndef nitems
  43 #define nitems(_a)      (sizeof((_a)) / sizeof((_a)[0]))
  44 #endif
  45
  46 #define GOTCTL_CMD_INFO "info"
  47 #define GOTCTL_CMD_STOP "stop"
  48
  49 struct gotctl_cmd {
  50         const char      *cmd_name;
  51         const struct got_error *(*cmd_main)(int, char *[], int);
  52         void            (*cmd_usage)(void);
  53 };
  54
  55 __dead static void      usage(int, int);
  56
  57 __dead static void      usage_info(void);
  58 __dead static void      usage_stop(void);
  59
  60 static const struct got_error*          cmd_info(int, char *[], int);
  61 static const struct got_error*          cmd_stop(int, char *[], int);
  62
  63 static const struct gotctl_cmd gotctl_commands[] = {
  64         { "info",       cmd_info,       usage_info },
  65         { "stop",       cmd_stop,       usage_stop },
  66 };
  67
  68 __dead static void
  69 usage_info(void)
  70 {
  71         fprintf(stderr, "usage: %s info\n", getprogname());
  72         exit(1);
  73 }
  74
  75 static const struct got_error *
  76 show_info(struct imsg *imsg)
  77 {
  78         struct gotd_imsg_info info;
  79         size_t datalen;
  80
  81         datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
  82         if (datalen != sizeof(info))
  83                 return got_error(GOT_ERR_PRIVSEP_LEN);
  84         memcpy(&info, imsg->data, sizeof(info));
  85
  86         printf("gotd PID: %d\n", info.pid);
  87         printf("verbosity: %d\n", info.verbosity);
  88         printf("number of repositories: %d\n", info.nrepos);
  89         printf("number of connected clients: %d\n", info.nclients);
  90         return NULL;
  91 }
  92
  93 static const struct got_error *
  94 show_repo_info(struct imsg *imsg)
  95 {
  96         struct gotd_imsg_info_repo info;
  97         size_t datalen;
  98
  99         datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
 100         if (datalen != sizeof(info))
 101                 return got_error(GOT_ERR_PRIVSEP_LEN);
 102         memcpy(&info, imsg->data, sizeof(info));
 103
 104         printf("repository \"%s\", path %s\n", info.repo_name, info.repo_path);
 105         return NULL;
 106 }
 107
 108 static const struct got_error *
 109 show_client_info(struct imsg *imsg)
 110 {
 111         struct gotd_imsg_info_client info;
 112         size_t datalen;
 113
 114         datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
 115         if (datalen != sizeof(info))
 116                 return got_error(GOT_ERR_PRIVSEP_LEN);
 117         memcpy(&info, imsg->data, sizeof(info));
 118
 119         printf("client UID %d, GID %d, ", info.euid, info.egid);
 120         if (info.session_child_pid)
 121                 printf("session PID %ld, ", (long)info.session_child_pid);
 122         if (info.repo_child_pid)
 123                 printf("repo PID %ld, ", (long)info.repo_child_pid);
 124         if (info.is_writing)
 125                 printf("writing to %s\n", info.repo_name);
 126         else
 127                 printf("reading from %s\n", info.repo_name);
 128
 129         return NULL;
 130 }
 131
 132 static const struct got_error *
 133 cmd_info(int argc, char *argv[], int gotd_sock)
 134 {
 135         const struct got_error *err;
 136         struct imsgbuf ibuf;
 137         struct imsg imsg;
 138
 139         imsg_init(&ibuf, gotd_sock);
 140
 141         if (imsg_compose(&ibuf, GOTD_IMSG_INFO, 0, 0, -1, NULL, 0) == -1)
 142                 return got_error_from_errno("imsg_compose INFO");
 143
 144         err = gotd_imsg_flush(&ibuf);
 145         while (err == NULL) {
 146                 err = gotd_imsg_poll_recv(&imsg, &ibuf, 0);
 147                 if (err) {
 148                         if (err->code == GOT_ERR_EOF)
 149                                 err = NULL;
 150                         break;
 151                 }
 152
 153                 switch (imsg.hdr.type) {
 154                 case GOTD_IMSG_ERROR:
 155                         err = gotd_imsg_recv_error(NULL, &imsg);
 156                         break;
 157                 case GOTD_IMSG_INFO:
 158                         err = show_info(&imsg);
 159                         break;
 160                 case GOTD_IMSG_INFO_REPO:
 161                         err = show_repo_info(&imsg);
 162                         break;
 163                 case GOTD_IMSG_INFO_CLIENT:
 164                         err = show_client_info(&imsg);
 165                         break;
 166                 default:
 167                         err = got_error(GOT_ERR_PRIVSEP_MSG);
 168                         break;
 169                 }
 170
 171                 imsg_free(&imsg);
 172         }
 173
 174         imsg_clear(&ibuf);
 175         return err;
 176 }
 177
 178 __dead static void
 179 usage_stop(void)
 180 {
 181         fprintf(stderr, "usage: %s stop\n", getprogname());
 182         exit(1);
 183 }
 184
 185 static const struct got_error *
 186 cmd_stop(int argc, char *argv[], int gotd_sock)
 187 {
 188         const struct got_error *err;
 189         struct imsgbuf ibuf;
 190         struct imsg imsg;
 191
 192         imsg_init(&ibuf, gotd_sock);
 193
 194         if (imsg_compose(&ibuf, GOTD_IMSG_STOP, 0, 0, -1, NULL, 0) == -1)
 195                 return got_error_from_errno("imsg_compose STOP");
 196
 197         err = gotd_imsg_flush(&ibuf);
 198         while (err == NULL) {
 199                 err = gotd_imsg_poll_recv(&imsg, &ibuf, 0);
 200                 if (err) {
 201                         if (err->code == GOT_ERR_EOF)
 202                                 err = NULL;
 203                         break;
 204                 }
 205
 206                 switch (imsg.hdr.type) {
 207                 case GOTD_IMSG_ERROR:
 208                         err = gotd_imsg_recv_error(NULL, &imsg);
 209                         break;
 210                 default:
 211                         err = got_error(GOT_ERR_PRIVSEP_MSG);
 212                         break;
 213                 }
 214
 215                 imsg_free(&imsg);
 216         }
 217
 218         imsg_clear(&ibuf);
 219         return err;
 220 }
 221
 222 static void
 223 list_commands(FILE *fp)
 224 {
 225         size_t i;
 226
 227         fprintf(fp, "commands:");
 228         for (i = 0; i < nitems(gotctl_commands); i++) {
 229                 const struct gotctl_cmd *cmd = &gotctl_commands[i];
 230                 fprintf(fp, " %s", cmd->cmd_name);
 231         }
 232         fputc('\n', fp);
 233 }
 234
 235 __dead static void
 236 usage(int hflag, int status)
 237 {
 238         FILE *fp = (status == 0) ? stdout : stderr;
 239
 240         fprintf(fp, "usage: %s [-hV] [-f path] command [arg ...]\n",
 241             getprogname());
 242         if (hflag)
 243                 list_commands(fp);
 244         exit(status);
 245 }
 246
 247 static const struct got_error *
 248 apply_unveil(const char *unix_socket_path)
 249 {
 250 #ifdef PROFILE
 251         if (unveil("gmon.out", "rwc") != 0)
 252                 return got_error_from_errno2("unveil", "gmon.out");
 253 #endif
 254         if (unveil(unix_socket_path, "w") != 0)
 255                 return got_error_from_errno2("unveil", unix_socket_path);
 256
 257         if (unveil(NULL, NULL) != 0)
 258                 return got_error_from_errno("unveil");
 259
 260         return NULL;
 261 }
 262
 263 static int
 264 connect_gotd(const char *socket_path)
 265 {
 266         const struct got_error *error = NULL;
 267         int gotd_sock = -1;
 268         struct sockaddr_un sun;
 269
 270         error = apply_unveil(socket_path);
 271         if (error)
 272                 errx(1, "%s", error->msg);
 273
 274 #ifndef PROFILE
 275         if (pledge("stdio unix", NULL) == -1)
 276                 err(1, "pledge");
 277 #endif
 278         if ((gotd_sock = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
 279                 err(1, "socket");
 280
 281         memset(&sun, 0, sizeof(sun));
 282         sun.sun_family = AF_UNIX;
 283         if (strlcpy(sun.sun_path, socket_path, sizeof(sun.sun_path)) >=
 284             sizeof(sun.sun_path))
 285                 errx(1, "gotd socket path too long");
 286         if (connect(gotd_sock, (struct sockaddr *)&sun, sizeof(sun)) == -1)
 287                 err(1, "connect: %s", socket_path);
 288
 289 #ifndef PROFILE
 290         if (pledge("stdio", NULL) == -1)
 291                 err(1, "pledge");
 292 #endif
 293
 294         return gotd_sock;
 295 }
 296
 297 int
 298 main(int argc, char *argv[])
 299 {
 300         const struct gotctl_cmd *cmd;
 301         int gotd_sock = -1, i;
 302         int ch;
 303         int hflag = 0, Vflag = 0;
 304         static const struct option longopts[] = {
 305             { "version", no_argument, NULL, 'V' },
 306             { NULL, 0, NULL, 0 }
 307         };
 308         const char *socket_path = GOTD_UNIX_SOCKET;
 309
 310         setlocale(LC_CTYPE, "");
 311
 312 #ifndef PROFILE
 313         if (pledge("stdio unix unveil", NULL) == -1)
 314                 err(1, "pledge");
 315 #endif
 316
 317         while ((ch = getopt_long(argc, argv, "+hf:V", longopts, NULL)) != -1) {
 318                 switch (ch) {
 319                 case 'h':
 320                         hflag = 1;
 321                         break;
 322                 case 'f':
 323                         socket_path = optarg;
 324                         break;
 325                 case 'V':
 326                         Vflag = 1;
 327                         break;
 328                 default:
 329                         usage(hflag, 1);
 330                         /* NOTREACHED */
 331                 }
 332         }
 333
 334         argc -= optind;
 335         argv += optind;
 336         optind = 1;
 337         optreset = 1;
 338
 339         if (Vflag) {
 340                 got_version_print_str();
 341                 return 0;
 342         }
 343
 344         if (argc <= 0)
 345                 usage(hflag, hflag ? 0 : 1);
 346
 347         for (i = 0; i < nitems(gotctl_commands); i++) {
 348                 const struct got_error *error;
 349
 350                 cmd = &gotctl_commands[i];
 351
 352                 if (strncmp(cmd->cmd_name, argv[0], strlen(argv[0])) != 0)
 353                         continue;
 354
 355                 if (hflag)
 356                         cmd->cmd_usage();
 357
 358                 gotd_sock = connect_gotd(socket_path);
 359                 if (gotd_sock == -1)
 360                         return 1;
 361                 error = cmd->cmd_main(argc, argv, gotd_sock);
 362                 close(gotd_sock);
 363                 if (error) {
 364                         fprintf(stderr, "%s: %s\n", getprogname(), error->msg);
 365                         return 1;
 366                 }
 367
 368                 return 0;
 369         }
 370
 371         fprintf(stderr, "%s: unknown command '%s'\n", getprogname(), argv[0]);
 372         list_commands(stderr);
 373         return 1;
 374 }