refspec.c

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