refspec.c

   1 #define USE_THE_REPOSITORY_VARIABLE
   2
   3 #include "git-compat-util.h"
   4 #include "gettext.h"
   5 #include "hash.h"
   6 #include "hex.h"
   7 #include "strvec.h"
   8 #include "refs.h"
   9 #include "refspec.h"
  10 #include "strbuf.h"
  11
  12 /*
  13  * Parses the provided refspec 'refspec' and populates the refspec_item 'item'.
  14  * Returns 1 if successful and 0 if the refspec is invalid.
  15  */
  16 static int parse_refspec(struct refspec_item *item, const char *refspec, int fetch)
  17 {
  18         size_t llen;
  19         int is_glob;
  20         const char *lhs, *rhs;
  21         int flags;
  22
  23         is_glob = 0;
  24
  25         lhs = refspec;
  26         if (*lhs == '+') {
  27                 item->force = 1;
  28                 lhs++;
  29         } else if (*lhs == '^') {
  30                 item->negative = 1;
  31                 lhs++;
  32         }
  33
  34         rhs = strrchr(lhs, ':');
  35
  36         /* negative refspecs only have one side */
  37         if (item->negative && rhs)
  38                 return 0;
  39
  40         /*
  41          * Before going on, special case ":" (or "+:") as a refspec
  42          * for pushing matching refs.
  43          */
  44         if (!fetch && rhs == lhs && rhs[1] == '\0') {
  45                 item->matching = 1;
  46                 return 1;
  47         }
  48
  49         if (rhs) {
  50                 size_t rlen = strlen(++rhs);
  51                 is_glob = (1 <= rlen && strchr(rhs, '*'));
  52                 item->dst = xstrndup(rhs, rlen);
  53         } else {
  54                 item->dst = NULL;
  55         }
  56
  57         llen = (rhs ? (rhs - lhs - 1) : strlen(lhs));
  58         if (1 <= llen && memchr(lhs, '*', llen)) {
  59                 if ((rhs && !is_glob) || (!rhs && !item->negative && fetch))
  60                         return 0;
  61                 is_glob = 1;
  62         } else if (rhs && is_glob) {
  63                 return 0;
  64         }
  65
  66         item->pattern = is_glob;
  67         if (llen == 1 && *lhs == '@')
  68                 item->src = xstrdup("HEAD");
  69         else
  70                 item->src = xstrndup(lhs, llen);
  71         flags = REFNAME_ALLOW_ONELEVEL | (is_glob ? REFNAME_REFSPEC_PATTERN : 0);
  72
  73         if (item->negative) {
  74                 struct object_id unused;
  75
  76                 /*
  77                  * Negative refspecs only have a LHS, which indicates a ref
  78                  * (or pattern of refs) to exclude from other matches. This
  79                  * can either be a simple ref, or a glob pattern. Exact sha1
  80                  * match is not currently supported.
  81                  */
  82                 if (!*item->src)
  83                         return 0; /* negative refspecs must not be empty */
  84                 else if (llen == the_hash_algo->hexsz && !get_oid_hex(item->src, &unused))
  85                         return 0; /* negative refpsecs cannot be exact sha1 */
  86                 else if (!check_refname_format(item->src, flags))
  87                         ; /* valid looking ref is ok */
  88                 else
  89                         return 0;
  90
  91                 /* the other rules below do not apply to negative refspecs */
  92                 return 1;
  93         }
  94
  95         if (fetch) {
  96                 struct object_id unused;
  97
  98                 /* LHS */
  99                 if (!*item->src)
 100                         ; /* empty is ok; it means "HEAD" */
 101                 else if (llen == the_hash_algo->hexsz && !get_oid_hex(item->src, &unused))
 102                         item->exact_sha1 = 1; /* ok */
 103                 else if (!check_refname_format(item->src, flags))
 104                         ; /* valid looking ref is ok */
 105                 else
 106                         return 0;
 107                 /* RHS */
 108                 if (!item->dst)
 109                         ; /* missing is ok; it is the same as empty */
 110                 else if (!*item->dst)
 111                         ; /* empty is ok; it means "do not store" */
 112                 else if (!check_refname_format(item->dst, flags))
 113                         ; /* valid looking ref is ok */
 114                 else
 115                         return 0;
 116         } else {
 117                 /*
 118                  * LHS
 119                  * - empty is allowed; it means delete.
 120                  * - when wildcarded, it must be a valid looking ref.
 121                  * - otherwise, it must be an extended SHA-1, but
 122                  *   there is no existing way to validate this.
 123                  */
 124                 if (!*item->src)
 125                         ; /* empty is ok */
 126                 else if (is_glob) {
 127                         if (check_refname_format(item->src, flags))
 128                                 return 0;
 129                 }
 130                 else
 131                         ; /* anything goes, for now */
 132                 /*
 133                  * RHS
 134                  * - missing is allowed, but LHS then must be a
 135                  *   valid looking ref.
 136                  * - empty is not allowed.
 137                  * - otherwise it must be a valid looking ref.
 138                  */
 139                 if (!item->dst) {
 140                         if (check_refname_format(item->src, flags))
 141                                 return 0;
 142                 } else if (!*item->dst) {
 143                         return 0;
 144                 } else {
 145                         if (check_refname_format(item->dst, flags))
 146                                 return 0;
 147                 }
 148         }
 149
 150         return 1;
 151 }
 152
 153 int refspec_item_init(struct refspec_item *item, const char *refspec, int fetch)
 154 {
 155         memset(item, 0, sizeof(*item));
 156         return parse_refspec(item, refspec, fetch);
 157 }
 158
 159 void refspec_item_init_or_die(struct refspec_item *item, const char *refspec,
 160                               int fetch)
 161 {
 162         if (!refspec_item_init(item, refspec, fetch))
 163                 die(_("invalid refspec '%s'"), refspec);
 164 }
 165
 166 void refspec_item_clear(struct refspec_item *item)
 167 {
 168         FREE_AND_NULL(item->src);
 169         FREE_AND_NULL(item->dst);
 170         item->force = 0;
 171         item->pattern = 0;
 172         item->matching = 0;
 173         item->exact_sha1 = 0;
 174 }
 175
 176 void refspec_init(struct refspec *rs, int fetch)
 177 {
 178         memset(rs, 0, sizeof(*rs));
 179         rs->fetch = fetch;
 180 }
 181
 182 static void refspec_append_nodup(struct refspec *rs, char *refspec)
 183 {
 184         struct refspec_item item;
 185
 186         refspec_item_init_or_die(&item, refspec, rs->fetch);
 187
 188         ALLOC_GROW(rs->items, rs->nr + 1, rs->alloc);
 189         rs->items[rs->nr++] = item;
 190
 191         ALLOC_GROW(rs->raw, rs->raw_nr + 1, rs->raw_alloc);
 192         rs->raw[rs->raw_nr++] = refspec;
 193 }
 194
 195 void refspec_append(struct refspec *rs, const char *refspec)
 196 {
 197         refspec_append_nodup(rs, xstrdup(refspec));
 198 }
 199
 200 void refspec_appendf(struct refspec *rs, const char *fmt, ...)
 201 {
 202         va_list ap;
 203
 204         va_start(ap, fmt);
 205         refspec_append_nodup(rs, xstrvfmt(fmt, ap));
 206         va_end(ap);
 207 }
 208
 209 void refspec_appendn(struct refspec *rs, const char **refspecs, int nr)
 210 {
 211         int i;
 212         for (i = 0; i < nr; i++)
 213                 refspec_append(rs, refspecs[i]);
 214 }
 215
 216 void refspec_clear(struct refspec *rs)
 217 {
 218         int i;
 219
 220         for (i = 0; i < rs->nr; i++)
 221                 refspec_item_clear(&rs->items[i]);
 222
 223         FREE_AND_NULL(rs->items);
 224         rs->alloc = 0;
 225         rs->nr = 0;
 226
 227         for (i = 0; i < rs->raw_nr; i++)
 228                 free((char *)rs->raw[i]);
 229         FREE_AND_NULL(rs->raw);
 230         rs->raw_alloc = 0;
 231         rs->raw_nr = 0;
 232
 233         rs->fetch = 0;
 234 }
 235
 236 int valid_fetch_refspec(const char *fetch_refspec_str)
 237 {
 238         struct refspec_item refspec;
 239         int ret = refspec_item_init(&refspec, fetch_refspec_str, REFSPEC_FETCH);
 240         refspec_item_clear(&refspec);
 241         return ret;
 242 }
 243
 244 int valid_remote_name(const char *name)
 245 {
 246         int result;
 247         struct strbuf refspec = STRBUF_INIT;
 248         strbuf_addf(&refspec, "refs/heads/test:refs/remotes/%s/test", name);
 249         result = valid_fetch_refspec(refspec.buf);
 250         strbuf_release(&refspec);
 251         return result;
 252 }
 253
 254 void refspec_ref_prefixes(const struct refspec *rs,
 255                           struct strvec *ref_prefixes)
 256 {
 257         int i;
 258         for (i = 0; i < rs->nr; i++) {
 259                 const struct refspec_item *item = &rs->items[i];
 260                 const char *prefix = NULL;
 261
 262                 if (item->exact_sha1 || item->negative)
 263                         continue;
 264                 if (rs->fetch == REFSPEC_FETCH)
 265                         prefix = item->src;
 266                 else if (item->dst)
 267                         prefix = item->dst;
 268                 else if (item->src && !item->exact_sha1)
 269                         prefix = item->src;
 270
 271                 if (!prefix)
 272                         continue;
 273
 274                 if (item->pattern) {
 275                         const char *glob = strchr(prefix, '*');
 276                         strvec_pushf(ref_prefixes, "%.*s",
 277                                      (int)(glob - prefix),
 278                                      prefix);
 279                 } else {
 280                         expand_ref_prefix(ref_prefixes, prefix);
 281                 }
 282         }
 283 }