lib/gitproto.c

   1 /*
   2  * Copyright (c) 2019 Ori Bernstein <ori@openbsd.org>
   3  * Copyright (c) 2021 Stefan Sperling <stsp@openbsd.org>
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 #include "got_compat.h"
  19
  20 #include <sys/queue.h>
  21 #include <sys/types.h>
  22
  23 #include <ctype.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "got_error.h"
  29 #include "got_path.h"
  30
  31 #include "got_lib_gitproto.h"
  32
  33 #ifndef nitems
  34 #define nitems(_a)      (sizeof((_a)) / sizeof((_a)[0]))
  35 #endif
  36
  37 static void
  38 free_tokens(char **tokens, size_t ntokens)
  39 {
  40         int i;
  41
  42         for (i = 0; i < ntokens; i++) {
  43                 free(tokens[i]);
  44                 tokens[i] = NULL;
  45         }
  46 }
  47
  48 static const struct got_error *
  49 tokenize_line(char **tokens, char *line, int len, int mintokens, int maxtokens)
  50 {
  51         const struct got_error *err = NULL;
  52         char *p;
  53         size_t i, n = 0;
  54
  55         for (i = 0; i < maxtokens; i++)
  56                 tokens[i] = NULL;
  57
  58         for (i = 0; n < len && i < maxtokens; i++) {
  59                 while (n < len && isspace((unsigned char)*line)) {
  60                         line++;
  61                         n++;
  62                 }
  63                 p = line;
  64                 while (*line != '\0' && n < len &&
  65                     (!isspace((unsigned char)*line) || i == maxtokens - 1)) {
  66                         line++;
  67                         n++;
  68                 }
  69                 tokens[i] = strndup(p, line - p);
  70                 if (tokens[i] == NULL) {
  71                         err = got_error_from_errno("strndup");
  72                         goto done;
  73                 }
  74                 /* Skip \0 field-delimiter at end of token. */
  75                 while (line[0] == '\0' && n < len) {
  76                         line++;
  77                         n++;
  78                 }
  79         }
  80         if (i < mintokens)
  81                 err = got_error_msg(GOT_ERR_BAD_PACKET,
  82                     "pkt-line contains too few tokens");
  83 done:
  84         if (err)
  85                 free_tokens(tokens, i);
  86         return err;
  87 }
  88
  89 const struct got_error *
  90 got_gitproto_parse_refline(char **id_str, char **refname,
  91     char **server_capabilities, char *line, int len)
  92 {
  93         const struct got_error *err = NULL;
  94         char *tokens[3];
  95
  96         *id_str = NULL;
  97         *refname = NULL;
  98         /* don't reset *server_capabilities */
  99
 100         err = tokenize_line(tokens, line, len, 2, nitems(tokens));
 101         if (err)
 102                 return err;
 103
 104         if (tokens[0])
 105                 *id_str = tokens[0];
 106         if (tokens[1])
 107                 *refname = tokens[1];
 108         if (tokens[2]) {
 109                 if (*server_capabilities == NULL) {
 110                         char *p;
 111                         *server_capabilities = tokens[2];
 112                         p = strrchr(*server_capabilities, '\n');
 113                         if (p)
 114                                 *p = '\0';
 115                 } else
 116                         free(tokens[2]);
 117         }
 118
 119         return NULL;
 120 }
 121
 122 const struct got_error *
 123 got_gitproto_parse_want_line(char **id_str,
 124     char **capabilities, char *line, int len)
 125 {
 126         const struct got_error *err = NULL;
 127         char *tokens[3];
 128
 129         *id_str = NULL;
 130         /* don't reset *capabilities */
 131
 132         err = tokenize_line(tokens, line, len, 2, nitems(tokens));
 133         if (err)
 134                 return err;
 135
 136         if (tokens[0] == NULL) {
 137                 free_tokens(tokens, nitems(tokens));
 138                 return got_error_msg(GOT_ERR_BAD_PACKET, "empty want-line");
 139         }
 140
 141         if (strcmp(tokens[0], "want") != 0) {
 142                 free_tokens(tokens, nitems(tokens));
 143                 return got_error_msg(GOT_ERR_BAD_PACKET, "bad want-line");
 144         }
 145
 146         free(tokens[0]);
 147         if (tokens[1])
 148                 *id_str = tokens[1];
 149         if (tokens[2]) {
 150                 if (*capabilities == NULL) {
 151                         char *p;
 152                         *capabilities = tokens[2];
 153                         p = strrchr(*capabilities, '\n');
 154                         if (p)
 155                                 *p = '\0';
 156                 } else
 157                         free(tokens[2]);
 158         }
 159
 160         return NULL;
 161 }
 162
 163 const struct got_error *
 164 got_gitproto_parse_have_line(char **id_str, char *line, int len)
 165 {
 166         const struct got_error *err = NULL;
 167         char *tokens[2];
 168
 169         *id_str = NULL;
 170
 171         err = tokenize_line(tokens, line, len, 2, nitems(tokens));
 172         if (err)
 173                 return err;
 174
 175         if (tokens[0] == NULL) {
 176                 free_tokens(tokens, nitems(tokens));
 177                 return got_error_msg(GOT_ERR_BAD_PACKET, "empty have-line");
 178         }
 179
 180         if (strcmp(tokens[0], "have") != 0) {
 181                 free_tokens(tokens, nitems(tokens));
 182                 return got_error_msg(GOT_ERR_BAD_PACKET, "bad have-line");
 183         }
 184
 185         free(tokens[0]);
 186         if (tokens[1])
 187                 *id_str = tokens[1];
 188
 189         return NULL;
 190 }
 191
 192 const struct got_error *
 193 got_gitproto_parse_ref_update_line(char **old_id_str, char **new_id_str,
 194     char **refname, char **capabilities, char *line, size_t len)
 195 {
 196         const struct got_error *err = NULL;
 197         char *tokens[4];
 198
 199         *old_id_str = NULL;
 200         *new_id_str = NULL;
 201         *refname = NULL;
 202
 203         /* don't reset *capabilities */
 204
 205         err = tokenize_line(tokens, line, len, 3, nitems(tokens));
 206         if (err)
 207                 return err;
 208
 209         if (tokens[0] == NULL || tokens[1] == NULL || tokens[2] == NULL) {
 210                 free_tokens(tokens, nitems(tokens));
 211                 return got_error_msg(GOT_ERR_BAD_PACKET, "empty ref-update");
 212         }
 213
 214         *old_id_str = tokens[0];
 215         *new_id_str = tokens[1];
 216         *refname = tokens[2];
 217         if (tokens[3]) {
 218                 if (*capabilities == NULL) {
 219                         char *p;
 220                         *capabilities = tokens[3];
 221                         p = strrchr(*capabilities, '\n');
 222                         if (p)
 223                                 *p = '\0';
 224                 } else
 225                         free(tokens[3]);
 226         }
 227
 228         return NULL;
 229 }
 230
 231 static const struct got_error *
 232 match_capability(char **my_capabilities, const char *capa,
 233     const struct got_capability *mycapa)
 234 {
 235         char *equalsign;
 236         char *s;
 237
 238         equalsign = strchr(capa, '=');
 239         if (equalsign) {
 240                 if (strncmp(capa, mycapa->key, equalsign - capa) != 0)
 241                         return NULL;
 242         } else {
 243                 if (strcmp(capa, mycapa->key) != 0)
 244                         return NULL;
 245         }
 246
 247         if (asprintf(&s, "%s %s%s%s",
 248             *my_capabilities != NULL ? *my_capabilities : "",
 249             mycapa->key,
 250             mycapa->value != NULL ? "=" : "",
 251             mycapa->value != NULL ? mycapa->value : "") == -1)
 252                 return got_error_from_errno("asprintf");
 253
 254         free(*my_capabilities);
 255         *my_capabilities = s;
 256         return NULL;
 257 }
 258
 259 static const struct got_error *
 260 add_symref(struct got_pathlist_head *symrefs, char *capa)
 261 {
 262         const struct got_error *err = NULL;
 263         char *colon, *name = NULL, *target = NULL;
 264
 265         /* Need at least "A:B" */
 266         if (strlen(capa) < 3)
 267                 return NULL;
 268
 269         colon = strchr(capa, ':');
 270         if (colon == NULL)
 271                 return NULL;
 272
 273         *colon = '\0';
 274         name = strdup(capa);
 275         if (name == NULL)
 276                 return got_error_from_errno("strdup");
 277
 278         target = strdup(colon + 1);
 279         if (target == NULL) {
 280                 err = got_error_from_errno("strdup");
 281                 goto done;
 282         }
 283
 284         /* We can't validate the ref itself here. The main process will. */
 285         err = got_pathlist_append(symrefs, name, target);
 286 done:
 287         if (err) {
 288                 free(name);
 289                 free(target);
 290         }
 291         return err;
 292 }
 293
 294 const struct got_error *
 295 got_gitproto_match_capabilities(char **common_capabilities,
 296     struct got_pathlist_head *symrefs, char *capabilities,
 297     const struct got_capability my_capabilities[], size_t ncapa)
 298 {
 299         const struct got_error *err = NULL;
 300         char *capa, *equalsign;
 301         size_t i;
 302
 303         *common_capabilities = NULL;
 304         do {
 305                 capa = strsep(&capabilities, " ");
 306                 if (capa == NULL)
 307                         return NULL;
 308
 309                 equalsign = strchr(capa, '=');
 310                 if (equalsign != NULL && symrefs != NULL &&
 311                     strncmp(capa, "symref", equalsign - capa) == 0) {
 312                         err = add_symref(symrefs, equalsign + 1);
 313                         if (err)
 314                                 break;
 315                         continue;
 316                 }
 317
 318                 for (i = 0; i < ncapa; i++) {
 319                         err = match_capability(common_capabilities,
 320                             capa, &my_capabilities[i]);
 321                         if (err)
 322                                 break;
 323                 }
 324         } while (capa);
 325
 326         if (*common_capabilities == NULL) {
 327                 *common_capabilities = strdup("");
 328                 if (*common_capabilities == NULL)
 329                         err = got_error_from_errno("strdup");
 330         }
 331         return err;
 332 }
 333
 334 const struct got_error *
 335 got_gitproto_append_capabilities(size_t *capalen, char *buf, size_t offset,
 336     size_t bufsize, const struct got_capability my_capabilities[], size_t ncapa)
 337 {
 338         char *p = buf + offset;
 339         size_t i, len, remain = bufsize - offset;
 340
 341         *capalen = 0;
 342
 343         if (offset >= bufsize || remain < 1)
 344                 return got_error(GOT_ERR_NO_SPACE);
 345
 346         /* Capabilities are hidden behind a NUL byte. */
 347         *p = '\0';
 348         p++;
 349         remain--;
 350         *capalen += 1;
 351
 352         for (i = 0; i < ncapa; i++) {
 353                 len = strlcat(p, " ", remain);
 354                 if (len >= remain)
 355                         return got_error(GOT_ERR_NO_SPACE);
 356                 remain -= len;
 357                 *capalen += 1;
 358
 359                 len = strlcat(p, my_capabilities[i].key, remain);
 360                 if (len >= remain)
 361                         return got_error(GOT_ERR_NO_SPACE);
 362                 remain -= len;
 363                 *capalen += strlen(my_capabilities[i].key);
 364
 365                 if (my_capabilities[i].value == NULL)
 366                         continue;
 367
 368                 len = strlcat(p, "=", remain);
 369                 if (len >= remain)
 370                         return got_error(GOT_ERR_NO_SPACE);
 371                 remain -= len;
 372                 *capalen += 1;
 373
 374                 len = strlcat(p, my_capabilities[i].value, remain);
 375                 if (len >= remain)
 376                         return got_error(GOT_ERR_NO_SPACE);
 377                 remain -= len;
 378                 *capalen += strlen(my_capabilities[i].value);
 379         }
 380
 381         return NULL;
 382 }
 383
 384 const struct got_error *
 385 got_gitproto_split_capabilities_str(struct got_capability **capabilities,
 386     size_t *ncapabilities, char *capabilities_str)
 387 {
 388         char *capastr, *capa;
 389         size_t i;
 390
 391         *capabilities = NULL;
 392         *ncapabilities = 0;
 393
 394         /* Compute number of capabilities on a copy of the input string. */
 395         capastr = strdup(capabilities_str);
 396         if (capastr == NULL)
 397                 return got_error_from_errno("strdup");
 398         do {
 399                 capa = strsep(&capastr, " ");
 400                 if (capa && *capa != '\0')
 401                         (*ncapabilities)++;
 402         } while (capa);
 403         free(capastr);
 404
 405         *capabilities = calloc(*ncapabilities, sizeof(**capabilities));
 406         if (*capabilities == NULL)
 407                 return got_error_from_errno("calloc");
 408
 409         /* Modify input string in place, splitting it into key/value tuples. */
 410         i = 0;
 411         for (;;) {
 412                 char *key = NULL, *value = NULL, *equalsign;
 413
 414                 capa = strsep(&capabilities_str, " ");
 415                 if (capa == NULL)
 416                         break;
 417                 if (*capa == '\0')
 418                         continue;
 419
 420                 if (i >= *ncapabilities) { /* should not happen */
 421                         free(*capabilities);
 422                         *capabilities = NULL;
 423                         *ncapabilities = 0;
 424                         return got_error(GOT_ERR_NO_SPACE);
 425                 }
 426
 427                 key = capa;
 428
 429                 equalsign = strchr(capa, '=');
 430                 if (equalsign != NULL) {
 431                         *equalsign = '\0';
 432                         value = equalsign + 1;
 433                 }
 434
 435                 (*capabilities)[i].key = key;
 436                 (*capabilities)[i].value = value;
 437                 i++;
 438         }
 439
 440         return NULL;
 441 }