sys/src/cmd/ip/torrent.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <mp.h>
   4 #include <libsec.h>
   5
   6 typedef struct Dict Dict;
   7 typedef struct Piece Piece;
   8 typedef struct File File;
   9 typedef struct Stats Stats;
  10
  11 struct Dict
  12 {
  13         Dict    *val;
  14         Dict    *next;
  15         char    *start, *end;
  16         int     len;
  17         char    typ;    // i, d, s, l
  18         char    str[];
  19 };
  20
  21 struct Piece
  22 {
  23         uchar   *hash;
  24         int     len;
  25         int     brk;
  26 };
  27
  28 struct File
  29 {
  30         File    *next;
  31         char    *name;
  32         int     fd;
  33         vlong   off;
  34         vlong   len;
  35 };
  36
  37 struct Stats
  38 {
  39         Lock;
  40         vlong   up;
  41         vlong   down;
  42         vlong   left;
  43 };
  44
  45 enum {
  46         MAXIO = 16*1024,
  47         SRVPROCS = 16,
  48         CLIPROCS = 16,
  49 };
  50
  51 int debug;
  52 int nproc = 1;
  53 int killgroup = -1;
  54 int port = 6881;
  55 char *deftrack = "http://exodus.desync.com/announce";
  56 char *mntweb = "/mnt/web";
  57 char *useragent = "torrent";
  58 uchar infohash[SHA1dlen];
  59 uchar peerid[20];
  60 int blocksize;
  61
  62 int npieces;
  63 Piece *pieces;
  64
  65 int nhavemap;
  66 uchar *havemap;
  67 int nhavepieces;
  68
  69 File *files;
  70 Stats stats;
  71
  72 int
  73 finished(void)
  74 {
  75         return nhavepieces >= npieces;
  76 }
  77
  78 void
  79 freedict(Dict *d)
  80 {
  81         if(d){
  82                 if(d->val != d)
  83                         freedict(d->val);
  84                 freedict(d->next);
  85                 free(d);
  86         }
  87 }
  88
  89 char*
  90 bparse(char *s, char *e, Dict **dp)
  91 {
  92         char *x, t;
  93         Dict *d;
  94         int n;
  95
  96         *dp = nil;
  97         if(s >= e)
  98                 return e;
  99
 100         t = *s;
 101         switch(t){
 102         case 'd':
 103         case 'l':
 104                 x = s++;
 105                 d = nil;
 106                 while(s < e){
 107                         if(*s == 'e'){
 108                                 s++;
 109                                 break;
 110                         }
 111                         if(t == 'd'){
 112                                 s = bparse(s, e, dp);
 113                                 if((d = *dp) == nil)
 114                                         break;
 115                         } else
 116                                 d = *dp = mallocz(sizeof(*d), 1);
 117                         d->typ = t;
 118                         d->start = x;
 119                         if(s < e){
 120                                 s = bparse(s, e, &d->val);
 121                                 dp = &d->next;
 122                                 d->end = s;
 123                         }
 124                         x = s;
 125                 }
 126                 if(d)
 127                         d->end = s;
 128                 return s;
 129         case 'i':
 130                 x = ++s;
 131                 if((s = memchr(x, 'e', e - x)) == nil)
 132                         return e;
 133                 n = s - x;
 134                 s++;
 135                 break;
 136         default:
 137                 if((x = memchr(s, ':', e - s)) == nil)
 138                         return e;
 139                 x++;
 140                 if((n = atoi(s)) < 0)
 141                         return e;
 142                 s = x + n;
 143                 if((s > e) || (s < x)){
 144                         n = e - x;
 145                         s = e;
 146                 }
 147                 t = 's';
 148         }
 149         d = mallocz(sizeof(*d) + n+1, 1);
 150         d->typ = t;
 151         memmove(d->str, x, d->len = n);
 152         d->str[n] = 0;
 153         *dp = d;
 154         return s;
 155 }
 156
 157 char*
 158 dstr(Dict *d)
 159 {
 160         if(d && (d->typ == 's' || d->typ == 'i'))
 161                 return d->str;
 162         return nil;
 163 }
 164
 165 Dict*
 166 dlook(Dict *d, char *s)
 167 {
 168         for(; d && d->typ == 'd'; d = d->next)
 169                 if(d->len && strcmp(d->str, s) == 0)
 170                         return d->val;
 171         return nil;
 172 }
 173
 174 int
 175 readall(int fd, char **p)
 176 {
 177         int n, r;
 178
 179         n = 0;
 180         *p = nil;
 181         while(*p = realloc(*p, n+1024)){
 182                 if((r = read(fd, *p+n, 1024)) <= 0)
 183                         break;
 184                 n += r;
 185         }
 186         return n;
 187 }
 188
 189 int
 190 rwpiece(int wr, int index, uchar *data, int len, int poff)
 191 {
 192         vlong off;
 193         int n, m;
 194         File *f;
 195
 196         if(len <= 0 || poff < 0 || poff >= pieces[index].len)
 197                 return 0;
 198         if(len+poff > pieces[index].len)
 199                 len = pieces[index].len - poff;
 200         off = (vlong)index * (vlong)blocksize;
 201         off += poff;
 202         for(f = files; f; f = f->next)
 203                 if((f->off+f->len) > off)
 204                         break;
 205         off -= f->off;
 206         n = ((off + len) > f->len) ? f->len - off : len;
 207         if((n = (wr ? pwrite(f->fd, data, n, off) : pread(f->fd, data, n, off))) <= 0)
 208                 return -1;
 209         if((m = rwpiece(wr, index, data + n, len - n, poff + n)) < 0)
 210                 return -1;
 211         return n+m;
 212 }
 213
 214 int
 215 havepiece(int x, char *from)
 216 {
 217         uchar *p, m, hash[SHA1dlen];
 218         int n;
 219
 220         m = 0x80>>(x&7);
 221         if(havemap[x>>3] & m)
 222                 return 1;
 223         p = malloc(blocksize);
 224         n = pieces[x].len;
 225         if(rwpiece(0, x, p, n, 0) != n){
 226                 free(p);
 227                 return 0;
 228         }
 229         sha1(p, n, hash, nil);
 230         free(p);
 231         if(memcmp(hash, pieces[x].hash, sizeof(hash))){
 232                 if(debug && from != nil)
 233                         fprint(2, "peer %s: damaged piece %d\n", from, x);
 234                 return 0;
 235         }
 236         lock(&stats);
 237         if((havemap[x>>3] & m) == 0){
 238                 havemap[x>>3] |= m;
 239                 nhavepieces++;
 240                 stats.left -= pieces[x].len;
 241         }
 242         unlock(&stats);
 243         if(debug && from != nil)
 244                 fprint(2, "peer %s: completed piece %d\n", from, x);
 245         return 1;
 246 }
 247
 248 int
 249 pickpiece(uchar *map)
 250 {
 251         int i, x, r, k;
 252         uchar m;
 253
 254         r = -1;
 255         k = 0;
 256         for(i = 0; i<nhavemap; i++){
 257                 if(map[i] == 0)
 258                         continue;
 259                 for(x = i<<3, m = 0x80; m; m >>= 1, x++){
 260                         if((~map[i] | havemap[i]) & m)
 261                                 continue;
 262                         if(nrand(++k) == 0)
 263                                 r = x;
 264                 }
 265         }
 266         return r;
 267 }
 268
 269 int
 270 unpack(uchar *s, int n, char *fmt, ...)
 271 {
 272         va_list arg;
 273         uchar *b, *e;
 274
 275         b = s;
 276         e = b + n;
 277         va_start(arg, fmt);
 278         for(; *fmt; fmt++) {
 279                 switch(*fmt){
 280                 case '_':
 281                         s++;
 282                         break;
 283                 case 'b':
 284                         if(s+1 > e) goto Err;
 285                         *va_arg(arg, int*) = *s++;
 286                         break;
 287                 case 'w':
 288                         if(s+2 > e) goto Err;
 289                         *va_arg(arg, int*) = s[0]<<8 | s[1];
 290                         s += 2;
 291                         break;
 292                 case 'l':
 293                         if(s+4 > e) goto Err;
 294                         *va_arg(arg, int*) = s[0]<<24 | s[1]<<16 | s[2]<<8 | s[3];
 295                         s += 4;
 296                         break;
 297                 case 'v':
 298                         if(s+4 > e) goto Err;
 299                         *va_arg(arg, vlong*) =
 300                                 (vlong)s[0]<<56 |
 301                                 (vlong)s[1]<<48 |
 302                                 (vlong)s[2]<<40 |
 303                                 (vlong)s[3]<<32 |
 304                                 (vlong)s[4]<<24 |
 305                                 (vlong)s[5]<<16 |
 306                                 (vlong)s[6]<<8 |
 307                                 (vlong)s[7];
 308                         s += 8;
 309                         break;
 310                 }
 311         }
 312         va_end(arg);
 313         return s - b;
 314 Err:
 315         va_end(arg);
 316         return -1;
 317 }
 318
 319 int
 320 pack(uchar *s, int n, char *fmt, ...)
 321 {
 322         va_list arg;
 323         uchar *b, *e;
 324         vlong v;
 325         int i;
 326
 327         b = s;
 328         e = b + n;
 329         va_start(arg, fmt);
 330         for(; *fmt; fmt++) {
 331                 switch(*fmt){
 332                 case '_':
 333                         i = 0;
 334                         if(0){
 335                 case 'b':
 336                         i = va_arg(arg, int);
 337                         }
 338                         if(s+1 > e) goto Err;
 339                         *s++ = i & 0xFF;
 340                         break;
 341                 case 'w':
 342                         i = va_arg(arg, int);
 343                         if(s+2 > e) goto Err;
 344                         *s++ = (i>>8) & 0xFF;
 345                         *s++ = i & 0xFF;
 346                         break;
 347                 case 'l':
 348                         i = va_arg(arg, int);
 349                         if(s+4 > e) goto Err;
 350                         *s++ = (i>>24) & 0xFF;
 351                         *s++ = (i>>16) & 0xFF;
 352                         *s++ = (i>>8) & 0xFF;
 353                         *s++ = i & 0xFF;
 354                         break;
 355                 case 'v':
 356                         v = va_arg(arg, vlong);
 357                         if(s+8 > e) goto Err;
 358                         *s++ = (v>>56) & 0xFF;
 359                         *s++ = (v>>48) & 0xFF;
 360                         *s++ = (v>>40) & 0xFF;
 361                         *s++ = (v>>32) & 0xFF;
 362                         *s++ = (v>>24) & 0xFF;
 363                         *s++ = (v>>16) & 0xFF;
 364                         *s++ = (v>>8) & 0xFF;
 365                         *s++ = v & 0xFF;
 366                         break;
 367                 case '*':
 368                         i = va_arg(arg, int);
 369                         if(s+i > e) goto Err;
 370                         memmove(s, va_arg(arg, void*), i);
 371                         s += i;
 372                         break;
 373                 }
 374         }
 375         va_end(arg);
 376         return s - b;
 377 Err:
 378         va_end(arg);
 379         return -1;
 380 }
 381
 382
 383
 384 int
 385 peer(int fd, int incoming, char *addr)
 386 {
 387         uchar buf[64+MAXIO], *map, *told, *p, m;
 388         int mechoking, hechoking;
 389         int mewant, hewant;
 390         int workpiece, workoffset;
 391         int i, o, l, x, n;
 392
 393         if(debug) fprint(2, "peer %s: %s connected\n", addr, incoming ? "incoming" : "outgoing");
 394
 395         for(i=0; i<2; i++){
 396                 if((incoming && i) || (!incoming && !i)){
 397                         if(debug) fprint(2, "peer %s: -> handshake\n", addr);
 398                         n = pack(buf, sizeof(buf), "*________**",
 399                                 20, "\x13BitTorrent protocol",
 400                                 sizeof(infohash), infohash,
 401                                 sizeof(peerid), peerid);
 402                         if(write(fd, buf, n) != n)
 403                                 return 1;
 404                 }
 405                 if((incoming && !i) || (!incoming && i)){
 406                         n = 20 + 8 + sizeof(infohash);
 407                         if((n = readn(fd, buf, n)) != n)
 408                                 return 1;
 409                         if(memcmp(buf, "\x13BitTorrent protocol", 20))
 410                                 return 0;
 411                         if(memcmp(infohash, buf + 20 + 8, sizeof(infohash)))
 412                                 return 0;
 413                         if(debug) fprint(2, "peer %s: <- handshake\n", addr);
 414                 }
 415         }
 416         if(readn(fd, buf, sizeof(peerid)) != sizeof(peerid))
 417                 return 1;
 418         if(memcmp(peerid, buf, sizeof(peerid)) == 0)
 419                 return 0;
 420         if(debug) fprint(2, "peer %s: peerid %.*s\n", addr, sizeof(peerid), (char*)buf);
 421
 422         mechoking = 1;
 423         hechoking = 1;
 424         mewant = 0;
 425         hewant = 0;
 426         workpiece = -1;
 427         workoffset = 0;
 428
 429         map = mallocz(nhavemap, 1);
 430         told = malloc(nhavemap);
 431
 432         if(debug) fprint(2, "peer %s: -> bitfield %d\n", addr, nhavemap);
 433         memmove(told, havemap, nhavemap);
 434         n = pack(buf, sizeof(buf), "lb*", nhavemap+1, 0x05, nhavemap, told);
 435         if(write(fd, buf, n) != n)
 436                 goto Out;
 437
 438         for(;;){
 439                 for(i=0; i<nhavemap; i++){
 440                         if(told[i] != havemap[i]){
 441                                 for(x = i<<3, m = 0x80; m; m >>= 1, x++){
 442                                         if((~havemap[i] | told[i] | map[i]) & m)
 443                                                 continue;
 444                                         told[i] |= m;
 445                                         if(debug) fprint(2, "peer %s: -> have %d\n", addr, x);
 446                                         n = pack(buf, sizeof(buf), "lbl", 1+4, 0x04, x);
 447                                         if(write(fd, buf, n) != n)
 448                                                 goto Out;
 449                                 }
 450                         }
 451                         if(!mewant && (map[i] & ~havemap[i])){
 452                                 mewant = 1;
 453                                 if(debug) fprint(2, "peer %s: -> interested\n", addr);
 454                                 n = pack(buf, sizeof(buf), "lb", 1, 0x02);
 455                                 if(write(fd, buf, n) != n)
 456                                         goto Out;
 457                         }
 458                 }
 459                 if(!hechoking && mewant){
 460                         x = workpiece;
 461                         if(x < 0 || (havemap[x>>3]&(0x80>>(x&7))) != 0 || workoffset >= pieces[x].len)
 462                                 x = pickpiece(map);
 463                         if(x >= 0){
 464                                 o = workpiece != x ? pieces[x].brk : workoffset;
 465                                 l = pieces[x].len - o;
 466                                 if(l > MAXIO)
 467                                         l = MAXIO;
 468                                 workpiece = x;
 469                                 workoffset = o + l;
 470                                 if(debug) fprint(2, "peer %s: -> request %d %d %d\n", addr, x, o, l);
 471                                 n = pack(buf, sizeof(buf), "lblll", 1+4+4+4, 0x06, x, o, l);
 472                                 if(write(fd, buf, n) != n)
 473                                         goto Out;
 474                         }
 475                 }
 476                 if(mechoking && hewant){
 477                         mechoking = 0;
 478                         if(debug) fprint(2, "peer %s: -> unchoke\n", addr);
 479                         n = pack(buf, sizeof(buf), "lb", 1, 0x01);
 480                         if(write(fd, buf, n) != n)
 481                                 goto Out;
 482                 }
 483
 484                 if(readn(fd, buf, 4) != 4)
 485                         break;
 486                 unpack(buf, 4, "l", &n);
 487                 if(n < 0 || n > sizeof(buf))
 488                         break;
 489                 if(n == 0)
 490                         continue;
 491                 if(readn(fd, buf, n) != n)
 492                         break;
 493
 494                 n--;
 495                 p = buf+1;
 496                 switch(*buf){
 497                 case 0x00:      // Choke
 498                         hechoking = 1;
 499                         workpiece = -1;
 500                         if(debug) fprint(2, "peer %s: <- choke\n", addr);
 501                         break;
 502                 case 0x01:      // Unchoke
 503                         hechoking = 0;
 504                         if(debug) fprint(2, "peer %s: <- unchoke\n", addr);
 505                         break;
 506                 case 0x02:      // Interested
 507                         hewant = 1;
 508                         if(debug) fprint(2, "peer %s: <- interested\n", addr);
 509                         break;
 510                 case 0x03:      // Notinterested
 511                         hewant = 0;
 512                         if(debug) fprint(2, "peer %s: <- notinterested\n", addr);
 513                         break;
 514                 case 0x04:      // Have <piceindex>
 515                         if(unpack(p, n, "l", &x) < 0)
 516                                 goto Out;
 517                         if(debug) fprint(2, "peer %s: <- have %d\n", addr, x);
 518                         if(x < 0 || x >= npieces)
 519                                 continue;
 520                         map[x>>3] |= 0x80>>(x&7);
 521                         break;
 522                 case 0x05:      // Bitfield
 523                         if(debug) fprint(2, "peer %s: <- bitfield %d\n", addr, n);
 524                         if(n != nhavemap)
 525                                 continue;
 526                         memmove(map, p, n);
 527                         break;
 528                 case 0x06:      // Request <index> <begin> <length>
 529                         if(unpack(p, n, "lll", &x, &o, &l) < 0)
 530                                 goto Out;
 531                         if(debug) fprint(2, "peer %s: <- request %d %d %d\n", addr, x, o, l);
 532                         if(x < 0 || x >= npieces)
 533                                 continue;
 534                         if(!hewant || mechoking || (~havemap[x>>3]&(0x80>>(x&7))))
 535                                 continue;
 536                         if(debug) fprint(2, "peer %s: -> piece %d %d\n", addr, x, o);
 537                         n = 4+1+4+4;
 538                         if(l > MAXIO)
 539                                 l = MAXIO;
 540                         if((l = rwpiece(0, x, buf + n, l, o)) <= 0)
 541                                 continue;
 542                         n = pack(buf, sizeof(buf), "lbll", 1+4+4+l, 0x07, x, o);
 543                         n += l;
 544                         if(write(fd, buf, n) != n)
 545                                 goto Out;
 546                         lock(&stats);
 547                         stats.up += n;
 548                         unlock(&stats);
 549                         break;
 550                 case 0x07:      // Piece <index> <begin> <block>
 551                         if(unpack(p, n, "ll", &x, &o) != 8)
 552                                 goto Out;
 553                         p += 8;
 554                         n -= 8;
 555                         lock(&stats);
 556                         stats.down += n;
 557                         unlock(&stats);
 558                         if(debug) fprint(2, "peer %s: <- piece %d %d %d\n", addr, x, o, n);
 559                         if(x < 0 || x >= npieces)
 560                                 continue;
 561                         if((havemap[x>>3]&(0x80>>(x&7))) != 0)
 562                                 continue;
 563                         if(o < 0 || o >= pieces[x].len)
 564                                 continue;
 565                         if(o+n > pieces[x].len)
 566                                 n = o - pieces[x].len;
 567                         if((o > pieces[x].brk) || (o+n <= pieces[x].brk))
 568                                 continue;
 569                         n = rwpiece(1, x, p, n, o);
 570                         if(n <= 0)
 571                                 continue;
 572                         pieces[x].brk = o+n;
 573                         if(o+n >= pieces[x].len && !havepiece(x, addr)){
 574                                 pieces[x].brk = 0;
 575                                 /* backoff from this piece for a while */
 576                                 if(x == workpiece)
 577                                         workpiece = -1;
 578                         }
 579                         break;
 580                 case 0x08:      // Cancel <index> <begin> <length>
 581                         if(unpack(p, n, "lll", &x, &o, &l) < 0)
 582                                 goto Out;
 583                         if(debug) fprint(2, "peer %s: <- cancel %d %d %d\n", addr, x, o, l);
 584                         break;
 585                 case 0x09:      // Port <port>
 586                         if(unpack(p, n, "l", &x) < 0)
 587                                 goto Out;
 588                         if(debug) fprint(2, "peer %s: <- port %d\n", addr, x);
 589                         break;
 590                 }
 591         }
 592
 593 Out:
 594         free(told);
 595         free(map);
 596         return 1;
 597 }
 598
 599 void
 600 server(void)
 601 {
 602         char addr[64], adir[40], ldir[40];
 603         int afd, lfd, dfd, pid, nprocs;
 604         NetConnInfo *ni;
 605
 606         afd = -1;
 607         nprocs = 0;
 608         for(port=6881; port<6890; port++){
 609                 snprint(addr, sizeof(addr), "tcp!*!%d", port);
 610                 if((afd = announce(addr, adir)) >= 0)
 611                         break;
 612         }
 613         if(afd < 0){
 614                 fprint(2, "announce: %r");
 615                 return;
 616         }
 617         if(rfork(RFFDG|RFPROC|RFMEM))
 618                 return;
 619         for(;;){
 620                 if((lfd = listen(adir, ldir)) < 0){
 621                         fprint(2, "listen: %r");
 622                         break;
 623                 }
 624                 while(nprocs >= SRVPROCS)
 625                         if(waitpid() > 0)
 626                                 nprocs--;
 627                 nprocs++;
 628                 if(pid = rfork(RFFDG|RFPROC|RFMEM)){
 629                         if(pid < 0)
 630                                 nprocs--;
 631                         close(lfd);
 632                         continue;
 633                 }
 634                 if((dfd = accept(lfd, ldir)) < 0){
 635                         fprint(2, "accept: %r");
 636                         break;
 637                 }
 638                 ni = getnetconninfo(ldir, dfd);
 639                 peer(dfd, 1, ni ? ni->raddr : "???");
 640                 if(ni) freenetconninfo(ni);
 641                 break;
 642         }
 643         exits(0);
 644 }
 645
 646 void
 647 client(char *ip, char *port)
 648 {
 649         static Dict *peerqh, *peerqt;
 650         static QLock peerslk;
 651         static int nprocs;
 652         char *addr;
 653         Dict *d;
 654         int fd;
 655
 656         if(ip == nil || port == nil)
 657                 return;
 658
 659         d = mallocz(sizeof(*d) + 64, 1);
 660         snprint(addr = d->str, 64, "tcp!%s!%s", ip, port);
 661         qlock(&peerslk);
 662         if(dlook(peerqh, addr)){
 663                 qunlock(&peerslk);
 664                 free(d);
 665                 return;
 666         }
 667         d->len = strlen(addr);
 668         d->typ = 'd';
 669         d->val = d;
 670         /* enqueue to front */
 671         if((d->next = peerqh) == nil)
 672                 peerqt = d;
 673         peerqh = d;
 674         if(nprocs >= CLIPROCS){
 675                 qunlock(&peerslk);
 676                 return;
 677         }
 678         nprocs++;
 679         qunlock(&peerslk);
 680         if(rfork(RFFDG|RFPROC|RFMEM|RFNOWAIT))
 681                 return;
 682
 683         for(;;){
 684                 qlock(&peerslk);
 685                 /* dequeue and put to tail */
 686                 if(d = peerqh){
 687                         if((peerqh = d->next) == nil)
 688                                 peerqt = nil;
 689                         d->next = nil;
 690                         if(peerqt)
 691                                 peerqt->next = d;
 692                         else
 693                                 peerqh = d;
 694                         peerqt = d;
 695                 } else
 696                         nprocs--;
 697                 qunlock(&peerslk);
 698                 if(d == nil)
 699                         exits(0);
 700                 addr = d->str;
 701                 if(debug) fprint(2, "client %s\n", addr);
 702                 if((fd = dial(addr, nil, nil, nil)) >= 0){
 703                         peer(fd, 0, addr);
 704                         close(fd);
 705                 }
 706                 sleep(1000+nrand(5000));
 707         }
 708 }
 709
 710 int
 711 hopen(char *url, ...)
 712 {
 713         int conn, ctlfd, fd, n;
 714         char buf[1024+1];
 715         va_list arg;
 716
 717         snprint(buf, sizeof buf, "%s/clone", mntweb);
 718         if((ctlfd = open(buf, ORDWR)) < 0)
 719                 return -1;
 720         if((n = read(ctlfd, buf, sizeof buf-1)) <= 0){
 721                 close(ctlfd);
 722                 return -1;
 723         }
 724         buf[n] = 0;
 725         conn = atoi(buf);
 726         va_start(arg, url);
 727         strcpy(buf, "url ");
 728         n = 4+vsnprint(buf+4, sizeof(buf)-4, url, arg);
 729         va_end(arg);
 730         if(write(ctlfd, buf, n) != n){
 731         ErrOut:
 732                 close(ctlfd);
 733                 return -1;
 734         }
 735         if(useragent != nil && useragent[0] != '\0'){
 736                 n = snprint(buf, sizeof buf, "useragent %s", useragent);
 737                 write(ctlfd, buf, n);
 738         }
 739         snprint(buf, sizeof buf, "%s/%d/body", mntweb, conn);
 740         if((fd = open(buf, OREAD)) < 0)
 741                 goto ErrOut;
 742         close(ctlfd);
 743         return fd;
 744 }
 745
 746 void
 747 webseed(Dict *w, File *f)
 748 {
 749         int fd, err, n, m, o, p, x, y;
 750         uchar buf[MAXIO];
 751         vlong off, len;
 752         Dict *w0;
 753         char *s;
 754
 755         if(w == nil || f == nil || finished())
 756                 return;
 757         if(rfork(RFPROC|RFMEM))
 758                 return;
 759         w0 = w;
 760 Retry:
 761         if(debug) fprint(2, "webseed %s %s\n", w->str, f->name);
 762         s = strrchr(w->str, '/');
 763         if(s && s[1] == 0)
 764                 fd = hopen("%s%s", w->str, f->name);
 765         else
 766                 fd = hopen("%s", w->str);
 767         if(fd < 0){
 768 Error:
 769                 if(debug) fprint(2, "webseed %s %s: %r\n", w->str, f->name);
 770                 if(finished())
 771                         exits(0);
 772                 if((w = w->next) == w0)
 773                         exits(0);
 774                 goto Retry;
 775         }
 776
 777         err = 0;
 778         off = f->off;
 779         len = f->len;
 780         while(len > 0 && !finished()){
 781                 m = sizeof(buf);
 782                 if(len < m)
 783                         m = len;
 784                 if((n = read(fd, buf, m)) <= 0)
 785                         break;
 786
 787                 x = off / blocksize;
 788                 p = off - (vlong)x*blocksize;
 789                 off += n;
 790                 len -= n;
 791                 y = off / blocksize;
 792
 793                 o = 0;
 794                 while(n > 0){
 795                         m = pieces[x].len - p;
 796                         if(m > n)
 797                                 m = n;
 798                         if((havemap[x>>3] & (0x80>>(x&7))) == 0)
 799                                 rwpiece(1, x, buf+o, m, p);
 800                         if(x == y)
 801                                 break;
 802                         o += m;
 803                         n -= m;
 804                         p = 0;
 805                         if(havepiece(x++, w->str))
 806                                 continue;
 807                         if(++err > 10){
 808                                 close(fd);
 809                                 werrstr("file corrupted");
 810                                 goto Error;
 811                         }
 812                 }
 813         }
 814         havepiece(off / blocksize, w->str);
 815         havepiece(f->off / blocksize, w->str);
 816         close(fd);
 817         exits(0);
 818 }
 819
 820 void
 821 clients4(uchar *p, int len)
 822 {
 823         char ip[16], port[6];
 824
 825         while(len >= 6){
 826                 len -= 6;
 827                 snprint(ip, sizeof(ip), "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
 828                 snprint(port, sizeof(port), "%d", p[4]<<8 | p[5]);
 829                 p += 6;
 830                 client(ip, port);
 831         }
 832 }
 833
 834 void
 835 webtracker(char *url)
 836 {
 837         char *event, *p;
 838         Dict *d, *l;
 839         int n, fd;
 840
 841         if(rfork(RFPROC|RFMEM))
 842                 return;
 843         if(debug) fprint(2, "webtracker %s\n", url);
 844
 845         event = "&event=started";
 846         for(;;){
 847                 vlong up, down, left;
 848
 849                 lock(&stats);
 850                 up = stats.up;
 851                 down = stats.down;
 852                 left = stats.left;
 853                 unlock(&stats);
 854
 855                 d = nil;
 856                 if((fd = hopen("%s?info_hash=%.*H&peer_id=%.*H&port=%d&"
 857                         "uploaded=%lld&downloaded=%lld&left=%lld&compact=1&no_peer_id=1%s",
 858                         url, sizeof(infohash), infohash, sizeof(peerid), peerid, port,
 859                         up, down, left, event)) >= 0){
 860                         event = "";
 861                         n = readall(fd, &p);
 862                         close(fd);
 863                         bparse(p, p+n, &d);
 864                         free(p);
 865                 } else if(debug) fprint(2, "tracker %s: %r\n", url);
 866                 /* check errors and warnings */
 867                 if(p = dstr(dlook(d, "failure reason"))) {
 868                         if(debug)
 869                                 fprint(2, "tracker failure: %s\n", p);
 870                         exits(0);
 871                 }
 872                 if(p = dstr(dlook(d, "warning message")))
 873                         if(debug)
 874                                 fprint(2, "tracker warning: %s\n", p);
 875                 if(l = dlook(d, "peers")){
 876                         if(l->typ == 's')
 877                                 clients4((uchar*)l->str, l->len);
 878                         else for(; l && l->typ == 'l'; l = l->next)
 879                                 client(dstr(dlook(l->val, "ip")), dstr(dlook(l->val, "port")));
 880                 }
 881                 n = 0;
 882                 if(p = dstr(dlook(d, "interval")))
 883                         n = atoi(p);
 884                 if(n < 10 | n > 60*60)
 885                         n = 2*60;
 886                 freedict(d);
 887                 sleep(n * 1000 + nrand(5000));
 888         }
 889 }
 890
 891 int
 892 udpaddr(char addr[64], int naddr, char *url)
 893 {
 894         int port;
 895         char *x;
 896
 897         if((url = strchr(url, ':')) == nil)
 898                 return -1;
 899         url++;
 900         while(*url == '/')
 901                 url++;
 902         if(x = strchr(url, ':')){
 903                 port = atoi(x+1);
 904         } else {
 905                 port = 80;
 906                 if((x = strchr(url, '/')) == nil)
 907                         x = strchr(url, 0);
 908         }
 909         snprint(addr, naddr, "udp!%.*s!%d", (int)(x-url), url, port);
 910         return 0;
 911 }
 912
 913 void
 914 udptracker(char *url)
 915 {
 916         int fd, event, n, m, a, i;
 917         int transid, interval;
 918         vlong connid;
 919         uchar buf[MAXIO];
 920         char addr[64];
 921
 922         if(udpaddr(addr, sizeof(addr), url) < 0)
 923                 return;
 924         if(rfork(RFPROC|RFMEM))
 925                 return;
 926         if(debug) fprint(2, "udptracker %s\n", addr);
 927
 928         event = 1;
 929         for(;;){
 930                 alarm(30000);
 931                 if((fd = dial(addr, 0, 0, 0)) < 0)
 932                         goto Sleep;
 933
 934                 /* connect */
 935                 transid = rand();
 936                 n = pack(buf, sizeof(buf), "vll", 0x41727101980LL, 0, transid);
 937                 if(write(fd, buf, n) != n)
 938                         goto Sleep;
 939                 for(;;){
 940                         if((n = read(fd, buf, sizeof(buf))) <= 0)
 941                                 goto Sleep;
 942                         if(unpack(buf, n, "llv", &a, &i, &connid) < 0)
 943                                 continue;
 944                         if(a == 0 && i == transid)
 945                                 break;
 946                 }
 947                 alarm(0);
 948
 949                 /* announce */
 950                 transid = rand();
 951                 lock(&stats);
 952                 n = pack(buf, sizeof(buf), "vll**vvvl____llw",
 953                         connid, 1, transid,
 954                         sizeof(infohash), infohash,
 955                         sizeof(peerid), peerid,
 956                         stats.down,
 957                         stats.left,
 958                         stats.up,
 959                         event,
 960                         0, -1,
 961                         port);
 962                 unlock(&stats);
 963
 964                 interval = 0;
 965                 alarm(30000);
 966                 if(write(fd, buf, n) != n)
 967                         goto Sleep;
 968                 for(;;){
 969                         if((n = read(fd, buf, sizeof(buf))) <= 0)
 970                                 goto Sleep;
 971                         if((m = unpack(buf, n, "lll________", &a, &i, &interval)) < 0)
 972                                 continue;
 973                         if(a == 1 && i == transid){
 974                                 clients4(buf+m, n - m);
 975                                 break;
 976                         }
 977                 }
 978                 event = 0;
 979 Sleep:
 980                 alarm(0);
 981                 if(fd >= 0)
 982                         close(fd);
 983                 if(interval < 10 | interval > 60*60)
 984                         interval = 2*60;
 985                 sleep(interval * 1000 + nrand(5000));
 986         }
 987 }
 988
 989 void
 990 tracker(char *url)
 991 {
 992         static Dict *trackers;
 993         static QLock trackerslk;
 994         Dict *d;
 995         int n;
 996
 997         if(url == nil)
 998                 return;
 999         qlock(&trackerslk);
1000         if(dlook(trackers, url)){
1001                 qunlock(&trackerslk);
1002                 return;
1003         }
1004         n = strlen(url);
1005         d = mallocz(sizeof(*d) + n+1, 1);
1006         strcpy(d->str, url);
1007         d->len = n;
1008         d->typ = 'd';
1009         d->val = d;
1010         d->next = trackers;
1011         trackers = d;
1012         url = d->str;
1013         qunlock(&trackerslk);
1014         if(!cistrncmp(url, "udp:", 4))
1015                 udptracker(url);
1016         else
1017                 webtracker(url);
1018 }
1019
1020 int
1021 Hfmt(Fmt *f)
1022 {
1023         uchar *s, *e;
1024         s = va_arg(f->args, uchar*);
1025         if(f->flags & FmtPrec)
1026                 e = s + f->prec;
1027         else
1028                 e = s + strlen((char*)s);
1029         for(; s < e; s++)
1030                 if(fmtprint(f, *s && ((*s >= '0' && *s <= '9') ||
1031                         (*s >= 'a' && *s <= 'z') ||
1032                         (*s >= 'A' && *s <= 'Z') ||
1033                         strchr(".-_~", *s)) ? "%c" : "%%%.2x", *s) < 0)
1034                         return -1;
1035         return 0;
1036 }
1037
1038 int
1039 mktorrent(int fd, Dict *alist, Dict *wlist)
1040 {
1041         uchar *b, h[SHA1dlen];
1042         Dir *d;
1043         int n;
1044
1045         if((d = dirfstat(fd)) == nil)
1046                 return -1;
1047         if(d->qid.type & QTDIR){
1048                 free(d);
1049                 werrstr("file is a directory");
1050                 return -1;
1051         }
1052         if(d->length == 0){
1053                 free(d);
1054                 werrstr("empty file");
1055                 return -1;
1056         }
1057         for(blocksize = 256*1024;;blocksize<<=1){
1058                 npieces = (d->length + blocksize-1) / blocksize;
1059                 if(npieces <= 8*1024 || blocksize >= 2*1024*1024)
1060                         break;
1061         }
1062
1063         /*
1064          * keys in dictionaries have to be ordered alphabetically
1065          */
1066         print("d8:announce%ld:%s", strlen(alist->str), alist->str);
1067         if(alist->next){
1068                 print("13:announce-listl");
1069                 print("l%ld:%se", strlen(alist->str), alist->str);
1070                 for(alist = alist->next; alist; alist = alist->next)
1071                         print("l%ld:%se", strlen(alist->str), alist->str);
1072                 print("e");
1073         }
1074
1075         print("4:infod");
1076         print("6:lengthi%llde", d->length);
1077         print("4:name%ld:%s", strlen(d->name), d->name);
1078         print("12:piece lengthi%de", blocksize);
1079         print("6:pieces%d:", npieces*sizeof(h));
1080         free(d);
1081         b = malloc(blocksize);
1082         while((n = readn(fd, b, blocksize)) > 0){
1083                 sha1(b, n, h, nil);
1084                 if(write(1, h, sizeof(h)) != sizeof(h)){
1085                         free(b);
1086                         return -1;
1087                 }
1088                 npieces--;
1089         }
1090         if(npieces){
1091                 werrstr("read failed: %r");
1092                 return -1;
1093         }
1094         free(b);
1095         print("e");
1096
1097         if(wlist){
1098                 if(wlist->next){
1099                         print("8:url-listl");
1100                         for(; wlist; wlist = wlist->next)
1101                                 print("%ld:%s", strlen(wlist->str), wlist->str);
1102                         print("e");
1103                 } else
1104                         print("8:url-list%ld:%s", strlen(wlist->str), wlist->str);
1105         }
1106         print("e");
1107
1108         return 0;
1109 }
1110
1111 int
1112 mkdirs(char *s)
1113 {
1114         char *p;
1115         int f;
1116
1117         if(access(s, AEXIST) == 0)
1118                 return 0;
1119         for(p=strchr(s+1, '/'); p; p=strchr(p+1, '/')){
1120                 *p = 0;
1121                 if(access(s, AEXIST)){
1122                         if((f = create(s, OREAD, DMDIR | 0777)) < 0){
1123                                 *p = '/';
1124                                 return -1;
1125                         }
1126                         close(f);
1127                 }
1128                 *p = '/';
1129         }
1130         return 0;
1131 }
1132
1133 char*
1134 fixnamedup(char *s)
1135 {
1136         int n, l;
1137         char *d;
1138         Rune r;
1139
1140         n = 0;
1141         d = strdup(s);
1142         l = strlen(d);
1143         while(*s){
1144                 s += chartorune(&r, s);
1145                 if(r == ' ')
1146                         r = 0xa0;
1147                 if((n + runelen(r)) >= l){
1148                         l += 64;
1149                         d = realloc(d, l);
1150                 }
1151                 n += runetochar(d + n, &r);
1152         }
1153         d[n] = 0;
1154         return cleanname(d);
1155 }
1156
1157 int
1158 catch(void *, char *msg)
1159 {
1160         if(strstr(msg, "alarm"))
1161                 return 1;
1162         postnote(PNGROUP, killgroup, "kill");
1163         return 0;
1164 }
1165
1166 void
1167 usage(void)
1168 {
1169         fprint(2, "usage: %s [ -vsdpc ] [ -m mtpt ] [ -t tracker-url ] "
1170                   "[ -w webseed-url ] [ -i peerid ] [ -A useragent ] [ file ]\n", argv0);
1171         exits("usage");
1172 }
1173
1174 Dict*
1175 scons(char *s, Dict *t)
1176 {
1177         Dict *l;
1178
1179         if(s == nil)
1180                 return t;
1181         for(l = t; l; l = l->next)
1182                 if(strcmp(l->str, s) == 0)
1183                         return t;
1184         l = mallocz(sizeof(*l) + strlen(s)+1, 1);
1185         l->next = t;
1186         strcpy(l->str, s);
1187         return l;
1188 }
1189
1190 void
1191 main(int argc, char *argv[])
1192 {
1193         int sflag, pflag, vflag, cflag, fd, i, n;
1194         Dict *alist, *wlist, *info, *torrent, *d, *l;
1195         char *p, *s, *e;
1196         File **fp, *f;
1197         vlong len;
1198
1199         fmtinstall('H', Hfmt);
1200         alist = wlist = nil;
1201         sflag = pflag = vflag = cflag = 0;
1202         ARGBEGIN {
1203         case 'm':
1204                 mntweb = EARGF(usage());
1205                 break;
1206         case 't':
1207                 alist = scons(EARGF(usage()), alist);
1208                 break;
1209         case 'w':
1210                 wlist = scons(EARGF(usage()), wlist);
1211                 break;
1212         case 's':
1213                 sflag = 1;
1214                 break;
1215         case 'p':
1216                 pflag = 1;
1217                 break;
1218         case 'v':
1219                 vflag = 1;
1220                 break;
1221         case 'c':
1222                 cflag = 1;
1223                 break;
1224         case 'd':
1225                 debug++;
1226                 break;
1227         case 'i':
1228                 strncpy((char*)peerid, EARGF(usage()), sizeof(peerid));
1229                 break;
1230         case 'A':
1231                 useragent = EARGF(usage());
1232                 break;
1233         default:
1234                 usage();
1235         } ARGEND;
1236
1237         if((s = getenv("NPROC")) != 0){
1238                 if((nproc = atoi(s)) <= 0)
1239                         nproc = 1;
1240                 free(s);
1241         }
1242
1243         fd = 0;
1244         if(*argv)
1245                 if((fd = open(*argv, OREAD)) < 0)
1246                         sysfatal("open: %r");
1247         if(cflag){
1248                 if(alist == nil)
1249                         alist = scons(deftrack, alist);
1250                 if(mktorrent(fd, alist, wlist) < 0)
1251                         sysfatal("%r");
1252                 exits(0);
1253         }
1254         if((n = readall(fd, &p)) <= 0)
1255                 sysfatal("read torrent: %r");
1256         bparse(p, p+n, &torrent);
1257
1258         alist = scons(dstr(dlook(torrent, "announce")), alist);
1259         for(d = dlook(torrent, "announce-list"); d && d->typ == 'l'; d = d->next)
1260                 for(l = d->val; l && l->typ == 'l'; l = l->next)
1261                         alist = scons(dstr(l->val), alist);
1262
1263         if(d = dlook(torrent, "url-list")){
1264                 if(d->typ == 's')
1265                         wlist = scons(dstr(d->val), wlist);
1266                 else for(l = d; l && l->typ == 'l'; l = l->next)
1267                         wlist = scons(dstr(l->val), wlist);
1268                 /* make wlist into a ring */
1269                 for(l = wlist; l && l->next; l = l->next)
1270                         ;
1271                 if(l) l->next = wlist;
1272         }
1273
1274         if(alist == nil && wlist == nil)
1275                 sysfatal("no trackers or webseeds in torrent");
1276
1277         if((d = info = dlook(torrent, "info")) == nil)
1278                 sysfatal("no meta info in torrent");
1279         for(s = e = d->start; d && d->typ == 'd'; d = d->next)
1280                 e = d->end;
1281         sha1((uchar*)s, e - s, (uchar*)infohash, nil);
1282         free(p);
1283
1284         fp = &files;
1285         if(d = dlook(info, "files")){
1286                 for(; d && d->typ == 'l'; d = d->next){
1287                         Dict *di;
1288
1289                         if((s = dstr(dlook(d->val, "length"))) == nil)
1290                                 continue;
1291                         f = mallocz(sizeof(*f), 1);
1292                         f->len = atoll(s);
1293                         f->name = dstr(dlook(info, "name"));
1294                         for(di = dlook(d->val, "path"); di && di->typ == 'l'; di = di->next)
1295                                 if(s = dstr(di->val))
1296                                         f->name = f->name ? smprint("%s/%s", f->name, s) : s;
1297                         *fp = f;
1298                         fp = &f->next;
1299                 }
1300         } else if(s = dstr(dlook(info, "length"))){
1301                 f = mallocz(sizeof(*f), 1);
1302                 f->len = atoll(s);
1303                 f->name = dstr(dlook(info, "name"));
1304                 *fp = f;
1305         }
1306         len = 0;
1307         for(f = files; f; f = f->next){
1308                 if(f->name == nil || f->len <= 0)
1309                         sysfatal("bogus file entry in meta info");
1310                 s = fixnamedup(f->name);
1311                 if(vflag) fprint(pflag ? 2 : 1, "%s\n", s);
1312                 if((f->fd = open(s, ORDWR)) < 0){
1313                         if(mkdirs(s) < 0)
1314                                 sysfatal("mkdirs: %r");
1315                         if((f->fd = create(s, ORDWR, 0666)) < 0)
1316                                 sysfatal("create: %r");
1317                 }
1318                 f->off = len;
1319                 len += f->len;
1320         }
1321         if(len <= 0)
1322                 sysfatal("no files in torrent");
1323
1324         if((s = dstr(dlook(info, "piece length"))) == nil)
1325                 sysfatal("missing piece length in meta info");
1326         if((blocksize = atoi(s)) <= 0)
1327                 sysfatal("bogus piece length in meta info");
1328         d = dlook(info, "pieces");
1329         if(d == nil || d->typ != 's' || d->len <= 0 || d->len % SHA1dlen)
1330                 sysfatal("bad or no pices in meta info");
1331         npieces = d->len / SHA1dlen;
1332         pieces = mallocz(sizeof(Piece) * npieces, 1);
1333         nhavemap = (npieces+7) / 8;
1334         havemap = mallocz(nhavemap, 1);
1335         for(i = 0; i<npieces; i++){
1336                 pieces[i].hash = (uchar*)d->str + i*SHA1dlen;
1337                 if(len < blocksize)
1338                         pieces[i].len = len;
1339                 else
1340                         pieces[i].len = blocksize;
1341                 len -= pieces[i].len;
1342                 stats.left += pieces[i].len;
1343         }
1344         if(len)
1345                 sysfatal("pieces do not match file length");
1346
1347         for(i=0; i<nproc; i++){
1348                 switch(rfork(RFPROC|RFMEM)){
1349                 case -1:
1350                         sysfatal("fork: %r");
1351                 case 0:
1352                         for(; i<npieces; i+=nproc)
1353                                 havepiece(i, nil);
1354                         exits(0);
1355                 }
1356         }
1357         while(waitpid() >= 0)
1358                 ;
1359
1360         if(finished() && !sflag)
1361                 exits(0);
1362
1363         srand(truerand());
1364         atnotify(catch, 1);
1365         switch(i = rfork(RFPROC|RFMEM|RFNOTEG)){
1366         case -1:
1367                 sysfatal("fork: %r");
1368         case 0:
1369                 if(peerid[0] == 0)
1370                         strncpy((char*)peerid, "-NF9001-", 9);
1371                 for(i=sizeof(peerid)-1; i >= 0 && peerid[i] == 0; i--)
1372                         peerid[i] = nrand(10)+'0';
1373                 server();
1374                 for(; alist; alist = alist->next)
1375                         tracker(alist->str);
1376                 for(f = files, l = wlist; f && l; f = f->next, l = l->next)
1377                         webseed(l, f);
1378                 while(waitpid() != -1)
1379                         ;
1380                 break;
1381         default:
1382                 killgroup = i;
1383                 do {
1384                         sleep(1000);
1385                         if(pflag)
1386                                 print("%d %d\n", nhavepieces, npieces);
1387                 } while(!finished() || sflag);
1388         }
1389         postnote(PNGROUP, killgroup, "kill");
1390         exits(0);
1391 }