sys/src/cmd/git/fetch.c

   1 #include <u.h>
   2 #include <libc.h>
   3
   4 #include "git.h"
   5
   6 char *fetchbranch;
   7 char *upstream = "origin";
   8 int listonly;
   9
  10 int
  11 resolveremote(Hash *h, char *ref)
  12 {
  13         char buf[128], *s;
  14         int r, f;
  15
  16         ref = strip(ref);
  17         if((r = hparse(h, ref)) != -1)
  18                 return r;
  19         /* Slightly special handling: translate remote refs to local ones. */
  20         if(strcmp(ref, "HEAD") == 0){
  21                 snprint(buf, sizeof(buf), ".git/HEAD");
  22         }else if(strstr(ref, "refs/heads") == ref){
  23                 ref += strlen("refs/heads");
  24                 snprint(buf, sizeof(buf), ".git/refs/remotes/%s/%s", upstream, ref);
  25         }else if(strstr(ref, "refs/tags") == ref){
  26                 ref += strlen("refs/tags");
  27                 snprint(buf, sizeof(buf), ".git/refs/tags/%s/%s", upstream, ref);
  28         }else{
  29                 return -1;
  30         }
  31
  32         r = -1;
  33         s = strip(buf);
  34         if((f = open(s, OREAD)) == -1)
  35                 return -1;
  36         if(readn(f, buf, sizeof(buf)) >= 40)
  37                 r = hparse(h, buf);
  38         close(f);
  39
  40         if(r == -1 && strstr(buf, "ref:") == buf)
  41                 return resolveremote(h, buf + strlen("ref:"));
  42         return r;
  43 }
  44
  45 int
  46 rename(char *pack, char *idx, Hash h)
  47 {
  48         char name[128];
  49         Dir st;
  50
  51         nulldir(&st);
  52         st.name = name;
  53         snprint(name, sizeof(name), "%H.pack", h);
  54         if(access(name, AEXIST) == 0)
  55                 fprint(2, "warning, pack %s already fetched\n", name);
  56         else if(dirwstat(pack, &st) == -1)
  57                 return -1;
  58         snprint(name, sizeof(name), "%H.idx", h);
  59         if(access(name, AEXIST) == 0)
  60                 fprint(2, "warning, pack %s already indexed\n", name);
  61         else if(dirwstat(idx, &st) == -1)
  62                 return -1;
  63         return 0;
  64 }
  65
  66 int
  67 checkhash(int fd, vlong sz, Hash *hcomp)
  68 {
  69         DigestState *st;
  70         Hash hexpect;
  71         char buf[Pktmax];
  72         vlong n, r;
  73         int nr;
  74
  75         if(sz < 28){
  76                 werrstr("undersize packfile");
  77                 return -1;
  78         }
  79
  80         st = nil;
  81         n = 0;
  82         while(n != sz - 20){
  83                 nr = sizeof(buf);
  84                 if(sz - n - 20 < sizeof(buf))
  85                         nr = sz - n - 20;
  86                 r = readn(fd, buf, nr);
  87                 if(r != nr)
  88                         return -1;
  89                 st = sha1((uchar*)buf, nr, nil, st);
  90                 n += r;
  91         }
  92         sha1(nil, 0, hcomp->h, st);
  93         if(readn(fd, hexpect.h, sizeof(hexpect.h)) != sizeof(hexpect.h))
  94                 sysfatal("truncated packfile");
  95         if(!hasheq(hcomp, &hexpect)){
  96                 werrstr("bad hash: %H != %H", *hcomp, hexpect);
  97                 return -1;
  98         }
  99         return 0;
 100 }
 101
 102 int
 103 mkoutpath(char *path)
 104 {
 105         char s[128];
 106         char *p;
 107         int fd;
 108
 109         snprint(s, sizeof(s), "%s", path);
 110         for(p=strchr(s+1, '/'); p; p=strchr(p+1, '/')){
 111                 *p = 0;
 112                 if(access(s, AEXIST) != 0){
 113                         fd = create(s, OREAD, DMDIR | 0775);
 114                         if(fd == -1)
 115                                 return -1;
 116                         close(fd);
 117                 }
 118                 *p = '/';
 119         }
 120         return 0;
 121 }
 122
 123 int
 124 branchmatch(char *br, char *pat)
 125 {
 126         char name[128];
 127
 128         if(strstr(pat, "refs/heads") == pat)
 129                 snprint(name, sizeof(name), "%s", pat);
 130         else if(strstr(pat, "heads"))
 131                 snprint(name, sizeof(name), "refs/%s", pat);
 132         else
 133                 snprint(name, sizeof(name), "refs/heads/%s", pat);
 134         return strcmp(br, name) == 0;
 135 }
 136
 137 char *
 138 matchcap(char *s, char *cap, int full)
 139 {
 140         if(strncmp(s, cap, strlen(cap)) == 0)
 141                 if(!full || strlen(s) == strlen(cap))
 142                         return s + strlen(cap);
 143         return nil;
 144 }
 145
 146 void
 147 handlecaps(char *caps)
 148 {
 149         char *p, *n, *c, *r;
 150
 151         for(p = caps; p != nil; p = n){
 152                 n = strchr(p, ' ');
 153                 if(n != nil)
 154                         *n++ = 0;
 155                 if((c = matchcap(p, "symref=", 0)) != nil){
 156                         if((r = strchr(c, ':')) != nil){
 157                                 *r++ = '\0';
 158                                 print("symref %s %s\n", c, r);
 159                         }
 160                 }
 161         }
 162 }
 163
 164 void
 165 fail(char *pack, char *idx, char *msg, ...)
 166 {
 167         char buf[ERRMAX];
 168         va_list ap;
 169
 170         va_start(ap, msg);
 171         snprint(buf, sizeof(buf), msg, ap);
 172         va_end(ap);
 173
 174         remove(pack);
 175         remove(idx);
 176         fprint(2, "%s", buf);
 177         exits(buf);
 178 }
 179
 180 int
 181 fetchpack(Conn *c)
 182 {
 183         char buf[Pktmax], *sp[3];
 184         char *packtmp, *idxtmp;
 185         Hash h, *have, *want;
 186         int nref, refsz, first;
 187         int i, n, req, pfd;
 188         vlong packsz;
 189         Object *o;
 190
 191         nref = 0;
 192         refsz = 16;
 193         first = 1;
 194         have = eamalloc(refsz, sizeof(have[0]));
 195         want = eamalloc(refsz, sizeof(want[0]));
 196         while(1){
 197                 n = readpkt(c, buf, sizeof(buf));
 198                 if(n == -1)
 199                         return -1;
 200                 if(n == 0)
 201                         break;
 202                 if(strncmp(buf, "ERR ", 4) == 0)
 203                         sysfatal("%s", buf + 4);
 204
 205                 if(first && n > strlen(buf))
 206                         handlecaps(buf + strlen(buf) + 1);
 207                 first = 0;
 208
 209                 getfields(buf, sp, nelem(sp), 1, " \t\n\r");
 210                 if(strstr(sp[1], "^{}"))
 211                         continue;
 212                 if(fetchbranch && !branchmatch(sp[1], fetchbranch))
 213                         continue;
 214                 if(refsz == nref + 1){
 215                         refsz *= 2;
 216                         have = erealloc(have, refsz * sizeof(have[0]));
 217                         want = erealloc(want, refsz * sizeof(want[0]));
 218                 }
 219                 if(hparse(&want[nref], sp[0]) == -1)
 220                         sysfatal("invalid hash %s", sp[0]);
 221                 if (resolveremote(&have[nref], sp[1]) == -1)
 222                         memset(&have[nref], 0, sizeof(have[nref]));
 223                 print("remote %s %H local %H\n", sp[1], want[nref], have[nref]);
 224                 nref++;
 225         }
 226         if(listonly){
 227                 flushpkt(c);
 228                 return 0;
 229         }
 230
 231         if(writephase(c) == -1)
 232                 sysfatal("write: %r");
 233         req = 0;
 234         for(i = 0; i < nref; i++){
 235                 if(hasheq(&have[i], &want[i]))
 236                         continue;
 237                 if((o = readobject(want[i])) != nil){
 238                         unref(o);
 239                         continue;
 240                 }
 241                 n = snprint(buf, sizeof(buf), "want %H\n", want[i]);
 242                 if(writepkt(c, buf, n) == -1)
 243                         sysfatal("could not send want for %H", want[i]);
 244                 req = 1;
 245         }
 246         flushpkt(c);
 247         for(i = 0; i < nref; i++){
 248                 if(hasheq(&have[i], &Zhash))
 249                         continue;
 250                 n = snprint(buf, sizeof(buf), "have %H\n", have[i]);
 251                 if(writepkt(c, buf, n + 1) == -1)
 252                         sysfatal("could not send have for %H", have[i]);
 253         }
 254         if(!req)
 255                 flushpkt(c);
 256
 257         n = snprint(buf, sizeof(buf), "done\n");
 258         if(writepkt(c, buf, n) == -1)
 259                 sysfatal("write: %r");
 260         if(!req)
 261                 return 0;
 262         if(readphase(c) == -1)
 263                 sysfatal("read: %r");
 264         if((n = readpkt(c, buf, sizeof(buf))) == -1)
 265                 sysfatal("read: %r");
 266         buf[n] = 0;
 267
 268         if((packtmp = smprint(".git/objects/pack/fetch.%d.pack", getpid())) == nil)
 269                 sysfatal("smprint: %r");
 270         if((idxtmp = smprint(".git/objects/pack/fetch.%d.idx", getpid())) == nil)
 271                 sysfatal("smprint: %r");
 272         if(mkoutpath(packtmp) == -1)
 273                 sysfatal("could not create %s: %r", packtmp);
 274         if((pfd = create(packtmp, ORDWR, 0664)) == -1)
 275                 sysfatal("could not create %s: %r", packtmp);
 276
 277         fprint(2, "fetching...\n");
 278         packsz = 0;
 279         while(1){
 280                 n = readn(c->rfd, buf, sizeof buf);
 281                 if(n == 0)
 282                         break;
 283                 if(n == -1 || write(pfd, buf, n) != n)
 284                         sysfatal("fetch packfile: %r");
 285                 packsz += n;
 286         }
 287
 288         closeconn(c);
 289         if(seek(pfd, 0, 0) == -1)
 290                 fail(packtmp, idxtmp, "packfile seek: %r");
 291         if(checkhash(pfd, packsz, &h) == -1)
 292                 fail(packtmp, idxtmp, "corrupt packfile: %r");
 293         close(pfd);
 294         if(indexpack(packtmp, idxtmp, h) == -1)
 295                 fail(packtmp, idxtmp, "could not index fetched pack: %r");
 296         if(rename(packtmp, idxtmp, h) == -1)
 297                 fail(packtmp, idxtmp, "could not rename indexed pack: %r");
 298         return 0;
 299 }
 300
 301 void
 302 usage(void)
 303 {
 304         fprint(2, "usage: %s [-dl] [-b br] [-u upstream] remote\n", argv0);
 305         fprint(2, "\t-b br:     only fetch matching branch 'br'\n");
 306         fprint(2, "remote:      fetch from this repository\n");
 307         exits("usage");
 308 }
 309
 310 void
 311 main(int argc, char **argv)
 312 {
 313         Conn c;
 314
 315         ARGBEGIN{
 316         case 'b':       fetchbranch=EARGF(usage());     break;
 317         case 'u':       upstream=EARGF(usage());        break;
 318         case 'd':       chattygit++;                    break;
 319         case 'l':       listonly++;                     break;
 320         default:        usage();                        break;
 321         }ARGEND;
 322
 323         gitinit();
 324         if(argc != 1)
 325                 usage();
 326
 327         if(gitconnect(&c, argv[0], "upload") == -1)
 328                 sysfatal("could not dial %s: %r", argv[0]);
 329         if(fetchpack(&c) == -1)
 330                 sysfatal("fetch failed: %r");
 331         closeconn(&c);
 332         exits(nil);
 333 }