refspec.c

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