lib/bup/_helpers.c

   1 #define _LARGEFILE64_SOURCE 1
   2 #define PY_SSIZE_T_CLEAN 1
   3 #undef NDEBUG
   4 #include "../../config/config.h"
   5
   6 // According to Python, its header has to go first:
   7 //   http://docs.python.org/2/c-api/intro.html#include-files
   8 #include <Python.h>
   9
  10 #include <assert.h>
  11 #include <errno.h>
  12 #include <fcntl.h>
  13 #include <arpa/inet.h>
  14 #include <stdint.h>
  15 #include <stdlib.h>
  16 #include <stdio.h>
  17 #include <sys/mman.h>
  18
  19 #ifdef HAVE_SYS_TYPES_H
  20 #include <sys/types.h>
  21 #endif
  22 #ifdef HAVE_SYS_STAT_H
  23 #include <sys/stat.h>
  24 #endif
  25 #ifdef HAVE_UNISTD_H
  26 #include <unistd.h>
  27 #endif
  28
  29 #ifdef HAVE_LINUX_FS_H
  30 #include <linux/fs.h>
  31 #endif
  32 #ifdef HAVE_SYS_IOCTL_H
  33 #include <sys/ioctl.h>
  34 #endif
  35
  36 #include "bupsplit.h"
  37
  38 #if defined(FS_IOC_GETFLAGS) && defined(FS_IOC_SETFLAGS)
  39 #define BUP_HAVE_FILE_ATTRS 1
  40 #endif
  41
  42 #ifndef FS_NOCOW_FL
  43 // Of course, this assumes it's a bitfield value.
  44 #define FS_NOCOW_FL 0
  45 #endif
  46
  47 static int istty2 = 0;
  48
  49 // Probably we should use autoconf or something and set HAVE_PY_GETARGCARGV...
  50 #if __WIN32__ || __CYGWIN__
  51
  52 // There's no 'ps' on win32 anyway, and Py_GetArgcArgv() isn't available.
  53 static void unpythonize_argv(void) { }
  54
  55 #else // not __WIN32__
  56
  57 // For some reason this isn't declared in Python.h
  58 extern void Py_GetArgcArgv(int *argc, char ***argv);
  59
  60 static void unpythonize_argv(void)
  61 {
  62     int argc, i;
  63     char **argv, *arge;
  64
  65     Py_GetArgcArgv(&argc, &argv);
  66
  67     for (i = 0; i < argc-1; i++)
  68     {
  69         if (argv[i] + strlen(argv[i]) + 1 != argv[i+1])
  70         {
  71             // The argv block doesn't work the way we expected; it's unsafe
  72             // to mess with it.
  73             return;
  74         }
  75     }
  76
  77     arge = argv[argc-1] + strlen(argv[argc-1]) + 1;
  78
  79     if (strstr(argv[0], "python") && argv[1] == argv[0] + strlen(argv[0]) + 1)
  80     {
  81         char *p;
  82         size_t len, diff;
  83         p = strrchr(argv[1], '/');
  84         if (p)
  85         {
  86             p++;
  87             diff = p - argv[0];
  88             len = arge - p;
  89             memmove(argv[0], p, len);
  90             memset(arge - diff, 0, diff);
  91             for (i = 0; i < argc; i++)
  92                 argv[i] = argv[i+1] ? argv[i+1]-diff : NULL;
  93         }
  94     }
  95 }
  96
  97 #endif // not __WIN32__ or __CYGWIN__
  98
  99
 100 static PyObject *selftest(PyObject *self, PyObject *args)
 101 {
 102     if (!PyArg_ParseTuple(args, ""))
 103         return NULL;
 104
 105     return Py_BuildValue("i", !bupsplit_selftest());
 106 }
 107
 108
 109 static PyObject *blobbits(PyObject *self, PyObject *args)
 110 {
 111     if (!PyArg_ParseTuple(args, ""))
 112         return NULL;
 113     return Py_BuildValue("i", BUP_BLOBBITS);
 114 }
 115
 116
 117 static PyObject *splitbuf(PyObject *self, PyObject *args)
 118 {
 119     unsigned char *buf = NULL;
 120     Py_ssize_t len = 0;
 121     int out = 0, bits = -1;
 122
 123     if (!PyArg_ParseTuple(args, "t#", &buf, &len))
 124         return NULL;
 125     assert(len <= INT_MAX);
 126     out = bupsplit_find_ofs(buf, len, &bits);
 127     if (out) assert(bits >= BUP_BLOBBITS);
 128     return Py_BuildValue("ii", out, bits);
 129 }
 130
 131
 132 static PyObject *bitmatch(PyObject *self, PyObject *args)
 133 {
 134     unsigned char *buf1 = NULL, *buf2 = NULL;
 135     Py_ssize_t len1 = 0, len2 = 0;
 136     Py_ssize_t byte;
 137     int bit;
 138
 139     if (!PyArg_ParseTuple(args, "t#t#", &buf1, &len1, &buf2, &len2))
 140         return NULL;
 141
 142     bit = 0;
 143     for (byte = 0; byte < len1 && byte < len2; byte++)
 144     {
 145         int b1 = buf1[byte], b2 = buf2[byte];
 146         if (b1 != b2)
 147         {
 148             for (bit = 0; bit < 8; bit++)
 149                 if ( (b1 & (0x80 >> bit)) != (b2 & (0x80 >> bit)) )
 150                     break;
 151             break;
 152         }
 153     }
 154
 155     assert(byte <= (INT_MAX >> 3));
 156     return Py_BuildValue("i", byte*8 + bit);
 157 }
 158
 159
 160 static PyObject *firstword(PyObject *self, PyObject *args)
 161 {
 162     unsigned char *buf = NULL;
 163     Py_ssize_t len = 0;
 164     uint32_t v;
 165
 166     if (!PyArg_ParseTuple(args, "t#", &buf, &len))
 167         return NULL;
 168
 169     if (len < 4)
 170         return NULL;
 171
 172     v = ntohl(*(uint32_t *)buf);
 173     return PyLong_FromUnsignedLong(v);
 174 }
 175
 176
 177 #define BLOOM2_HEADERLEN 16
 178
 179 static void to_bloom_address_bitmask4(const unsigned char *buf,
 180         const int nbits, uint64_t *v, unsigned char *bitmask)
 181 {
 182     int bit;
 183     uint32_t high;
 184     uint64_t raw, mask;
 185
 186     memcpy(&high, buf, 4);
 187     mask = (1<<nbits) - 1;
 188     raw = (((uint64_t)ntohl(high) << 8) | buf[4]);
 189     bit = (raw >> (37-nbits)) & 0x7;
 190     *v = (raw >> (40-nbits)) & mask;
 191     *bitmask = 1 << bit;
 192 }
 193
 194 static void to_bloom_address_bitmask5(const unsigned char *buf,
 195         const int nbits, uint32_t *v, unsigned char *bitmask)
 196 {
 197     int bit;
 198     uint32_t high;
 199     uint32_t raw, mask;
 200
 201     memcpy(&high, buf, 4);
 202     mask = (1<<nbits) - 1;
 203     raw = ntohl(high);
 204     bit = (raw >> (29-nbits)) & 0x7;
 205     *v = (raw >> (32-nbits)) & mask;
 206     *bitmask = 1 << bit;
 207 }
 208
 209 #define BLOOM_SET_BIT(name, address, otype) \
 210 static void name(unsigned char *bloom, const unsigned char *buf, const int nbits)\
 211 {\
 212     unsigned char bitmask;\
 213     otype v;\
 214     address(buf, nbits, &v, &bitmask);\
 215     bloom[BLOOM2_HEADERLEN+v] |= bitmask;\
 216 }
 217 BLOOM_SET_BIT(bloom_set_bit4, to_bloom_address_bitmask4, uint64_t)
 218 BLOOM_SET_BIT(bloom_set_bit5, to_bloom_address_bitmask5, uint32_t)
 219
 220
 221 #define BLOOM_GET_BIT(name, address, otype) \
 222 static int name(const unsigned char *bloom, const unsigned char *buf, const int nbits)\
 223 {\
 224     unsigned char bitmask;\
 225     otype v;\
 226     address(buf, nbits, &v, &bitmask);\
 227     return bloom[BLOOM2_HEADERLEN+v] & bitmask;\
 228 }
 229 BLOOM_GET_BIT(bloom_get_bit4, to_bloom_address_bitmask4, uint64_t)
 230 BLOOM_GET_BIT(bloom_get_bit5, to_bloom_address_bitmask5, uint32_t)
 231
 232
 233 static PyObject *bloom_add(PyObject *self, PyObject *args)
 234 {
 235     unsigned char *sha = NULL, *bloom = NULL;
 236     unsigned char *end;
 237     Py_ssize_t len = 0, blen = 0;
 238     int nbits = 0, k = 0;
 239
 240     if (!PyArg_ParseTuple(args, "w#s#ii", &bloom, &blen, &sha, &len, &nbits, &k))
 241         return NULL;
 242
 243     if (blen < 16+(1<<nbits) || len % 20 != 0)
 244         return NULL;
 245
 246     if (k == 5)
 247     {
 248         if (nbits > 29)
 249             return NULL;
 250         for (end = sha + len; sha < end; sha += 20/k)
 251             bloom_set_bit5(bloom, sha, nbits);
 252     }
 253     else if (k == 4)
 254     {
 255         if (nbits > 37)
 256             return NULL;
 257         for (end = sha + len; sha < end; sha += 20/k)
 258             bloom_set_bit4(bloom, sha, nbits);
 259     }
 260     else
 261         return NULL;
 262
 263
 264     return Py_BuildValue("n", len/20);
 265 }
 266
 267 static PyObject *bloom_contains(PyObject *self, PyObject *args)
 268 {
 269     unsigned char *sha = NULL, *bloom = NULL;
 270     Py_ssize_t len = 0, blen = 0;
 271     int nbits = 0, k = 0;
 272     unsigned char *end;
 273     int steps;
 274
 275     if (!PyArg_ParseTuple(args, "t#s#ii", &bloom, &blen, &sha, &len, &nbits, &k))
 276         return NULL;
 277
 278     if (len != 20)
 279         return NULL;
 280
 281     if (k == 5)
 282     {
 283         if (nbits > 29)
 284             return NULL;
 285         for (steps = 1, end = sha + 20; sha < end; sha += 20/k, steps++)
 286             if (!bloom_get_bit5(bloom, sha, nbits))
 287                 return Py_BuildValue("Oi", Py_None, steps);
 288     }
 289     else if (k == 4)
 290     {
 291         if (nbits > 37)
 292             return NULL;
 293         for (steps = 1, end = sha + 20; sha < end; sha += 20/k, steps++)
 294             if (!bloom_get_bit4(bloom, sha, nbits))
 295                 return Py_BuildValue("Oi", Py_None, steps);
 296     }
 297     else
 298         return NULL;
 299
 300     return Py_BuildValue("ii", 1, k);
 301 }
 302
 303
 304 static uint32_t _extract_bits(unsigned char *buf, int nbits)
 305 {
 306     uint32_t v, mask;
 307
 308     mask = (1<<nbits) - 1;
 309     v = ntohl(*(uint32_t *)buf);
 310     v = (v >> (32-nbits)) & mask;
 311     return v;
 312 }
 313
 314
 315 static PyObject *extract_bits(PyObject *self, PyObject *args)
 316 {
 317     unsigned char *buf = NULL;
 318     Py_ssize_t len = 0;
 319     int nbits = 0;
 320
 321     if (!PyArg_ParseTuple(args, "t#i", &buf, &len, &nbits))
 322         return NULL;
 323
 324     if (len < 4)
 325         return NULL;
 326
 327     return PyLong_FromUnsignedLong(_extract_bits(buf, nbits));
 328 }
 329
 330
 331 struct sha {
 332     unsigned char bytes[20];
 333 };
 334
 335
 336 struct idx {
 337     unsigned char *map;
 338     struct sha *cur;
 339     struct sha *end;
 340     uint32_t *cur_name;
 341     Py_ssize_t bytes;
 342     int name_base;
 343 };
 344
 345
 346 static int _cmp_sha(const struct sha *sha1, const struct sha *sha2)
 347 {
 348     int i;
 349     for (i = 0; i < sizeof(struct sha); i++)
 350         if (sha1->bytes[i] != sha2->bytes[i])
 351             return sha1->bytes[i] - sha2->bytes[i];
 352     return 0;
 353 }
 354
 355
 356 static void _fix_idx_order(struct idx **idxs, int *last_i)
 357 {
 358     struct idx *idx;
 359     int low, mid, high, c = 0;
 360
 361     idx = idxs[*last_i];
 362     if (idxs[*last_i]->cur >= idxs[*last_i]->end)
 363     {
 364         idxs[*last_i] = NULL;
 365         PyMem_Free(idx);
 366         --*last_i;
 367         return;
 368     }
 369     if (*last_i == 0)
 370         return;
 371
 372     low = *last_i-1;
 373     mid = *last_i;
 374     high = 0;
 375     while (low >= high)
 376     {
 377         mid = (low + high) / 2;
 378         c = _cmp_sha(idx->cur, idxs[mid]->cur);
 379         if (c < 0)
 380             high = mid + 1;
 381         else if (c > 0)
 382             low = mid - 1;
 383         else
 384             break;
 385     }
 386     if (c < 0)
 387         ++mid;
 388     if (mid == *last_i)
 389         return;
 390     memmove(&idxs[mid+1], &idxs[mid], (*last_i-mid)*sizeof(struct idx *));
 391     idxs[mid] = idx;
 392 }
 393
 394
 395 static uint32_t _get_idx_i(struct idx *idx)
 396 {
 397     if (idx->cur_name == NULL)
 398         return idx->name_base;
 399     return ntohl(*idx->cur_name) + idx->name_base;
 400 }
 401
 402 #define MIDX4_HEADERLEN 12
 403
 404 static PyObject *merge_into(PyObject *self, PyObject *args)
 405 {
 406     PyObject *ilist = NULL;
 407     unsigned char *fmap = NULL;
 408     struct sha *sha_ptr, *sha_start = NULL;
 409     uint32_t *table_ptr, *name_ptr, *name_start;
 410     struct idx **idxs = NULL;
 411     Py_ssize_t flen = 0;
 412     int bits = 0, i;
 413     unsigned int total;
 414     uint32_t count, prefix;
 415     int num_i;
 416     int last_i;
 417
 418     if (!PyArg_ParseTuple(args, "w#iIO", &fmap, &flen, &bits, &total, &ilist))
 419         return NULL;
 420
 421     num_i = PyList_Size(ilist);
 422     idxs = (struct idx **)PyMem_Malloc(num_i * sizeof(struct idx *));
 423
 424     for (i = 0; i < num_i; i++)
 425     {
 426         long len, sha_ofs, name_map_ofs;
 427         idxs[i] = (struct idx *)PyMem_Malloc(sizeof(struct idx));
 428         PyObject *itup = PyList_GetItem(ilist, i);
 429         if (!PyArg_ParseTuple(itup, "t#llli", &idxs[i]->map, &idxs[i]->bytes,
 430                     &len, &sha_ofs, &name_map_ofs, &idxs[i]->name_base))
 431             return NULL;
 432         idxs[i]->cur = (struct sha *)&idxs[i]->map[sha_ofs];
 433         idxs[i]->end = &idxs[i]->cur[len];
 434         if (name_map_ofs)
 435             idxs[i]->cur_name = (uint32_t *)&idxs[i]->map[name_map_ofs];
 436         else
 437             idxs[i]->cur_name = NULL;
 438     }
 439     table_ptr = (uint32_t *)&fmap[MIDX4_HEADERLEN];
 440     sha_start = sha_ptr = (struct sha *)&table_ptr[1<<bits];
 441     name_start = name_ptr = (uint32_t *)&sha_ptr[total];
 442
 443     last_i = num_i-1;
 444     count = 0;
 445     prefix = 0;
 446     while (last_i >= 0)
 447     {
 448         struct idx *idx;
 449         uint32_t new_prefix;
 450         if (count % 102424 == 0 && istty2)
 451             fprintf(stderr, "midx: writing %.2f%% (%d/%d)\r",
 452                     count*100.0/total, count, total);
 453         idx = idxs[last_i];
 454         new_prefix = _extract_bits((unsigned char *)idx->cur, bits);
 455         while (prefix < new_prefix)
 456             table_ptr[prefix++] = htonl(count);
 457         memcpy(sha_ptr++, idx->cur, sizeof(struct sha));
 458         *name_ptr++ = htonl(_get_idx_i(idx));
 459         ++idx->cur;
 460         if (idx->cur_name != NULL)
 461             ++idx->cur_name;
 462         _fix_idx_order(idxs, &last_i);
 463         ++count;
 464     }
 465     while (prefix < (1<<bits))
 466         table_ptr[prefix++] = htonl(count);
 467     assert(count == total);
 468     assert(prefix == (1<<bits));
 469     assert(sha_ptr == sha_start+count);
 470     assert(name_ptr == name_start+count);
 471
 472     PyMem_Free(idxs);
 473     return PyLong_FromUnsignedLong(count);
 474 }
 475
 476 // This function should technically be macro'd out if it's going to be used
 477 // more than ocasionally.  As of this writing, it'll actually never be called
 478 // in real world bup scenarios (because our packs are < MAX_INT bytes).
 479 static uint64_t htonll(uint64_t value)
 480 {
 481     static const int endian_test = 42;
 482
 483     if (*(char *)&endian_test == endian_test) // LSB-MSB
 484         return ((uint64_t)htonl(value & 0xFFFFFFFF) << 32) | htonl(value >> 32);
 485     return value; // already in network byte order MSB-LSB
 486 }
 487
 488 #define FAN_ENTRIES 256
 489
 490 static PyObject *write_idx(PyObject *self, PyObject *args)
 491 {
 492     char *filename = NULL;
 493     PyObject *idx = NULL;
 494     PyObject *part;
 495     unsigned char *fmap = NULL;
 496     Py_ssize_t flen = 0;
 497     unsigned int total = 0;
 498     uint32_t count;
 499     int i, j, ofs64_count;
 500     uint32_t *fan_ptr, *crc_ptr, *ofs_ptr;
 501     uint64_t *ofs64_ptr;
 502     struct sha *sha_ptr;
 503
 504     if (!PyArg_ParseTuple(args, "sw#OI", &filename, &fmap, &flen, &idx, &total))
 505         return NULL;
 506
 507     if (PyList_Size (idx) != FAN_ENTRIES) // Check for list of the right length.
 508         return PyErr_Format (PyExc_TypeError, "idx must contain %d entries",
 509                              FAN_ENTRIES);
 510
 511     const char idx_header[] = "\377tOc\0\0\0\002";
 512     memcpy (fmap, idx_header, sizeof(idx_header) - 1);
 513
 514     fan_ptr = (uint32_t *)&fmap[sizeof(idx_header) - 1];
 515     sha_ptr = (struct sha *)&fan_ptr[FAN_ENTRIES];
 516     crc_ptr = (uint32_t *)&sha_ptr[total];
 517     ofs_ptr = (uint32_t *)&crc_ptr[total];
 518     ofs64_ptr = (uint64_t *)&ofs_ptr[total];
 519
 520     count = 0;
 521     ofs64_count = 0;
 522     for (i = 0; i < FAN_ENTRIES; ++i)
 523     {
 524         int plen;
 525         part = PyList_GET_ITEM(idx, i);
 526         PyList_Sort(part);
 527         plen = PyList_GET_SIZE(part);
 528         count += plen;
 529         *fan_ptr++ = htonl(count);
 530         for (j = 0; j < plen; ++j)
 531         {
 532             unsigned char *sha = NULL;
 533             Py_ssize_t sha_len = 0;
 534             unsigned int crc = 0;
 535             unsigned PY_LONG_LONG ofs_py = 0;
 536             uint64_t ofs;
 537             if (!PyArg_ParseTuple(PyList_GET_ITEM(part, j), "t#IK",
 538                                   &sha, &sha_len, &crc, &ofs_py))
 539                 return NULL;
 540             assert(crc <= UINT32_MAX);
 541             assert(ofs_py <= UINT64_MAX);
 542             ofs = ofs_py;
 543             if (sha_len != sizeof(struct sha))
 544                 return NULL;
 545             memcpy(sha_ptr++, sha, sizeof(struct sha));
 546             *crc_ptr++ = htonl(crc);
 547             if (ofs > 0x7fffffff)
 548             {
 549                 *ofs64_ptr++ = htonll(ofs);
 550                 ofs = 0x80000000 | ofs64_count++;
 551             }
 552             *ofs_ptr++ = htonl((uint32_t)ofs);
 553         }
 554     }
 555
 556     int rc = msync(fmap, flen, MS_ASYNC);
 557     if (rc != 0)
 558         return PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
 559
 560     return PyLong_FromUnsignedLong(count);
 561 }
 562
 563
 564 // I would have made this a lower-level function that just fills in a buffer
 565 // with random values, and then written those values from python.  But that's
 566 // about 20% slower in my tests, and since we typically generate random
 567 // numbers for benchmarking other parts of bup, any slowness in generating
 568 // random bytes will make our benchmarks inaccurate.  Plus nobody wants
 569 // pseudorandom bytes much except for this anyway.
 570 static PyObject *write_random(PyObject *self, PyObject *args)
 571 {
 572     uint32_t buf[1024/4];
 573     int fd = -1, seed = 0, verbose = 0;
 574     ssize_t ret;
 575     long long len = 0, kbytes = 0, written = 0;
 576
 577     if (!PyArg_ParseTuple(args, "iLii", &fd, &len, &seed, &verbose))
 578         return NULL;
 579
 580     srandom(seed);
 581
 582     for (kbytes = 0; kbytes < len/1024; kbytes++)
 583     {
 584         unsigned i;
 585         for (i = 0; i < sizeof(buf)/sizeof(buf[0]); i++)
 586             buf[i] = random();
 587         ret = write(fd, buf, sizeof(buf));
 588         if (ret < 0)
 589             ret = 0;
 590         written += ret;
 591         if (ret < (int)sizeof(buf))
 592             break;
 593         if (verbose && kbytes/1024 > 0 && !(kbytes%1024))
 594             fprintf(stderr, "Random: %lld Mbytes\r", kbytes/1024);
 595     }
 596
 597     // handle non-multiples of 1024
 598     if (len % 1024)
 599     {
 600         unsigned i;
 601         for (i = 0; i < sizeof(buf)/sizeof(buf[0]); i++)
 602             buf[i] = random();
 603         ret = write(fd, buf, len % 1024);
 604         if (ret < 0)
 605             ret = 0;
 606         written += ret;
 607     }
 608
 609     if (kbytes/1024 > 0)
 610         fprintf(stderr, "Random: %lld Mbytes, done.\n", kbytes/1024);
 611     return Py_BuildValue("L", written);
 612 }
 613
 614
 615 static PyObject *random_sha(PyObject *self, PyObject *args)
 616 {
 617     static int seeded = 0;
 618     uint32_t shabuf[20/4];
 619     int i;
 620
 621     if (!seeded)
 622     {
 623         assert(sizeof(shabuf) == 20);
 624         srandom(time(NULL));
 625         seeded = 1;
 626     }
 627
 628     if (!PyArg_ParseTuple(args, ""))
 629         return NULL;
 630
 631     memset(shabuf, 0, sizeof(shabuf));
 632     for (i=0; i < 20/4; i++)
 633         shabuf[i] = random();
 634     return Py_BuildValue("s#", shabuf, 20);
 635 }
 636
 637
 638 static int _open_noatime(const char *filename, int attrs)
 639 {
 640     int attrs_noatime, fd;
 641     attrs |= O_RDONLY;
 642 #ifdef O_NOFOLLOW
 643     attrs |= O_NOFOLLOW;
 644 #endif
 645 #ifdef O_LARGEFILE
 646     attrs |= O_LARGEFILE;
 647 #endif
 648     attrs_noatime = attrs;
 649 #ifdef O_NOATIME
 650     attrs_noatime |= O_NOATIME;
 651 #endif
 652     fd = open(filename, attrs_noatime);
 653     if (fd < 0 && errno == EPERM)
 654     {
 655         // older Linux kernels would return EPERM if you used O_NOATIME
 656         // and weren't the file's owner.  This pointless restriction was
 657         // relaxed eventually, but we have to handle it anyway.
 658         // (VERY old kernels didn't recognized O_NOATIME, but they would
 659         // just harmlessly ignore it, so this branch won't trigger)
 660         fd = open(filename, attrs);
 661     }
 662     return fd;
 663 }
 664
 665
 666 static PyObject *open_noatime(PyObject *self, PyObject *args)
 667 {
 668     char *filename = NULL;
 669     int fd;
 670     if (!PyArg_ParseTuple(args, "s", &filename))
 671         return NULL;
 672     fd = _open_noatime(filename, 0);
 673     if (fd < 0)
 674         return PyErr_SetFromErrnoWithFilename(PyExc_OSError, filename);
 675     return Py_BuildValue("i", fd);
 676 }
 677
 678
 679 static PyObject *fadvise_done(PyObject *self, PyObject *args)
 680 {
 681     int fd = -1;
 682     long long ofs = 0;
 683     if (!PyArg_ParseTuple(args, "iL", &fd, &ofs))
 684         return NULL;
 685 #ifdef POSIX_FADV_DONTNEED
 686     posix_fadvise(fd, 0, ofs, POSIX_FADV_DONTNEED);
 687 #endif
 688     return Py_BuildValue("");
 689 }
 690
 691
 692 #ifdef BUP_HAVE_FILE_ATTRS
 693 static PyObject *bup_get_linux_file_attr(PyObject *self, PyObject *args)
 694 {
 695     int rc;
 696     unsigned long attr;
 697     char *path;
 698     int fd;
 699
 700     if (!PyArg_ParseTuple(args, "s", &path))
 701         return NULL;
 702
 703     fd = _open_noatime(path, O_NONBLOCK);
 704     if (fd == -1)
 705         return PyErr_SetFromErrnoWithFilename(PyExc_OSError, path);
 706
 707     attr = 0;
 708     rc = ioctl(fd, FS_IOC_GETFLAGS, &attr);
 709     if (rc == -1)
 710     {
 711         close(fd);
 712         return PyErr_SetFromErrnoWithFilename(PyExc_OSError, path);
 713     }
 714
 715     close(fd);
 716     return Py_BuildValue("k", attr);
 717 }
 718 #endif /* def BUP_HAVE_FILE_ATTRS */
 719
 720
 721 #ifdef BUP_HAVE_FILE_ATTRS
 722 static PyObject *bup_set_linux_file_attr(PyObject *self, PyObject *args)
 723 {
 724     int rc;
 725     unsigned long orig_attr, attr;
 726     char *path;
 727     int fd;
 728
 729     if (!PyArg_ParseTuple(args, "sk", &path, &attr))
 730         return NULL;
 731
 732     fd = open(path, O_RDONLY | O_NONBLOCK | O_LARGEFILE | O_NOFOLLOW);
 733     if (fd == -1)
 734         return PyErr_SetFromErrnoWithFilename(PyExc_OSError, path);
 735
 736     // Restrict attr to modifiable flags acdeijstuADST -- see
 737     // chattr(1) and the e2fsprogs source.  Letter to flag mapping is
 738     // in pf.c flags_array[].
 739     attr &= FS_APPEND_FL | FS_COMPR_FL | FS_NODUMP_FL | FS_EXTENT_FL
 740     | FS_IMMUTABLE_FL | FS_JOURNAL_DATA_FL | FS_SECRM_FL | FS_NOTAIL_FL
 741     | FS_UNRM_FL | FS_NOATIME_FL | FS_DIRSYNC_FL | FS_SYNC_FL
 742     | FS_TOPDIR_FL | FS_NOCOW_FL;
 743
 744     // The extents flag can't be removed, so don't (see chattr(1) and chattr.c).
 745     rc = ioctl(fd, FS_IOC_GETFLAGS, &orig_attr);
 746     if (rc == -1)
 747     {
 748         close(fd);
 749         return PyErr_SetFromErrnoWithFilename(PyExc_OSError, path);
 750     }
 751     attr |= (orig_attr & FS_EXTENT_FL);
 752
 753     rc = ioctl(fd, FS_IOC_SETFLAGS, &attr);
 754     if (rc == -1)
 755     {
 756         close(fd);
 757         return PyErr_SetFromErrnoWithFilename(PyExc_OSError, path);
 758     }
 759
 760     close(fd);
 761     return Py_BuildValue("O", Py_None);
 762 }
 763 #endif /* def BUP_HAVE_FILE_ATTRS */
 764
 765
 766 #if defined(HAVE_UTIMENSAT) || defined(HAVE_FUTIMES) || defined(HAVE_LUTIMES)
 767
 768 static int bup_parse_xutime_args(char **path,
 769                                  long *access,
 770                                  long *access_ns,
 771                                  long *modification,
 772                                  long *modification_ns,
 773                                  PyObject *self, PyObject *args)
 774 {
 775     if (!PyArg_ParseTuple(args, "s((ll)(ll))",
 776                           path,
 777                           access, access_ns,
 778                           modification, modification_ns))
 779         return 0;
 780
 781     if (isnan(*access))
 782     {
 783         PyErr_SetString(PyExc_ValueError, "access time is NaN");
 784         return 0;
 785     }
 786     else if (isinf(*access))
 787     {
 788         PyErr_SetString(PyExc_ValueError, "access time is infinite");
 789         return 0;
 790     }
 791     else if (isnan(*modification))
 792     {
 793         PyErr_SetString(PyExc_ValueError, "modification time is NaN");
 794         return 0;
 795     }
 796     else if (isinf(*modification))
 797     {
 798         PyErr_SetString(PyExc_ValueError, "modification time is infinite");
 799         return 0;
 800     }
 801
 802     if (isnan(*access_ns))
 803     {
 804         PyErr_SetString(PyExc_ValueError, "access time ns is NaN");
 805         return 0;
 806     }
 807     else if (isinf(*access_ns))
 808     {
 809         PyErr_SetString(PyExc_ValueError, "access time ns is infinite");
 810         return 0;
 811     }
 812     else if (isnan(*modification_ns))
 813     {
 814         PyErr_SetString(PyExc_ValueError, "modification time ns is NaN");
 815         return 0;
 816     }
 817     else if (isinf(*modification_ns))
 818     {
 819         PyErr_SetString(PyExc_ValueError, "modification time ns is infinite");
 820         return 0;
 821     }
 822
 823     return 1;
 824 }
 825
 826 #endif /* defined(HAVE_UTIMENSAT) || defined(HAVE_FUTIMES)
 827           || defined(HAVE_LUTIMES) */
 828
 829
 830 #ifdef HAVE_UTIMENSAT
 831
 832 static PyObject *bup_xutime_ns(PyObject *self, PyObject *args,
 833                                int follow_symlinks)
 834 {
 835     int rc;
 836     char *path;
 837     long access, access_ns, modification, modification_ns;
 838     struct timespec ts[2];
 839
 840     if (!bup_parse_xutime_args(&path, &access, &access_ns,
 841                                &modification, &modification_ns,
 842                                self, args))
 843        return NULL;
 844
 845     ts[0].tv_sec = access;
 846     ts[0].tv_nsec = access_ns;
 847     ts[1].tv_sec = modification;
 848     ts[1].tv_nsec = modification_ns;
 849     rc = utimensat(AT_FDCWD, path, ts,
 850                    follow_symlinks ? 0 : AT_SYMLINK_NOFOLLOW);
 851     if (rc != 0)
 852         return PyErr_SetFromErrnoWithFilename(PyExc_OSError, path);
 853
 854     return Py_BuildValue("O", Py_None);
 855 }
 856
 857
 858 #define BUP_HAVE_BUP_UTIME_NS 1
 859 static PyObject *bup_utime_ns(PyObject *self, PyObject *args)
 860 {
 861     return bup_xutime_ns(self, args, 1);
 862 }
 863
 864
 865 #define BUP_HAVE_BUP_LUTIME_NS 1
 866 static PyObject *bup_lutime_ns(PyObject *self, PyObject *args)
 867 {
 868     return bup_xutime_ns(self, args, 0);
 869 }
 870
 871
 872 #else /* not defined(HAVE_UTIMENSAT) */
 873
 874
 875 #ifdef HAVE_UTIMES
 876 #define BUP_HAVE_BUP_UTIME_NS 1
 877 static PyObject *bup_utime_ns(PyObject *self, PyObject *args)
 878 {
 879     int rc;
 880     char *path;
 881     long access, access_ns, modification, modification_ns;
 882     struct timeval tv[2];
 883
 884     if (!bup_parse_xutime_args(&path, &access, &access_ns,
 885                                &modification, &modification_ns,
 886                                self, args))
 887        return NULL;
 888
 889     tv[0].tv_sec = access;
 890     tv[0].tv_usec = access_ns / 1000;
 891     tv[1].tv_sec = modification;
 892     tv[1].tv_usec = modification_ns / 1000;
 893     rc = utimes(path, tv);
 894     if (rc != 0)
 895         return PyErr_SetFromErrnoWithFilename(PyExc_OSError, path);
 896
 897     return Py_BuildValue("O", Py_None);
 898 }
 899 #endif /* def HAVE_UTIMES */
 900
 901
 902 #ifdef HAVE_LUTIMES
 903 #define BUP_HAVE_BUP_LUTIME_NS 1
 904 static PyObject *bup_lutime_ns(PyObject *self, PyObject *args)
 905 {
 906     int rc;
 907     char *path;
 908     long access, access_ns, modification, modification_ns;
 909     struct timeval tv[2];
 910
 911     if (!bup_parse_xutime_args(&path, &access, &access_ns,
 912                                &modification, &modification_ns,
 913                                self, args))
 914        return NULL;
 915
 916     tv[0].tv_sec = access;
 917     tv[0].tv_usec = access_ns / 1000;
 918     tv[1].tv_sec = modification;
 919     tv[1].tv_usec = modification_ns / 1000;
 920     rc = lutimes(path, tv);
 921     if (rc != 0)
 922         return PyErr_SetFromErrnoWithFilename(PyExc_OSError, path);
 923
 924     return Py_BuildValue("O", Py_None);
 925 }
 926 #endif /* def HAVE_LUTIMES */
 927
 928
 929 #endif /* not defined(HAVE_UTIMENSAT) */
 930
 931
 932 #ifdef HAVE_STAT_ST_ATIM
 933 # define BUP_STAT_ATIME_NS(st) (st)->st_atim.tv_nsec
 934 # define BUP_STAT_MTIME_NS(st) (st)->st_mtim.tv_nsec
 935 # define BUP_STAT_CTIME_NS(st) (st)->st_ctim.tv_nsec
 936 #elif defined HAVE_STAT_ST_ATIMENSEC
 937 # define BUP_STAT_ATIME_NS(st) (st)->st_atimespec.tv_nsec
 938 # define BUP_STAT_MTIME_NS(st) (st)->st_mtimespec.tv_nsec
 939 # define BUP_STAT_CTIME_NS(st) (st)->st_ctimespec.tv_nsec
 940 #else
 941 # define BUP_STAT_ATIME_NS(st) 0
 942 # define BUP_STAT_MTIME_NS(st) 0
 943 # define BUP_STAT_CTIME_NS(st) 0
 944 #endif
 945
 946
 947 static void set_invalid_timespec_msg(const char *field,
 948                                      const long long sec,
 949                                      const long nsec,
 950                                      const char *filename,
 951                                      int fd)
 952 {
 953     if (filename != NULL)
 954         PyErr_Format(PyExc_ValueError,
 955                      "invalid %s timespec (%lld %ld) for file \"%s\"",
 956                      field, sec, nsec, filename);
 957     else
 958         PyErr_Format(PyExc_ValueError,
 959                      "invalid %s timespec (%lld %ld) for file descriptor %d",
 960                      field, sec, nsec, fd);
 961 }
 962
 963
 964 static int normalize_timespec_values(const char *name,
 965                                      long long *sec,
 966                                      long *nsec,
 967                                      const char *filename,
 968                                      int fd)
 969 {
 970     if (*nsec < -999999999 || *nsec > 999999999)
 971     {
 972         set_invalid_timespec_msg(name, *sec, *nsec, filename, fd);
 973         return 0;
 974     }
 975     if (*nsec < 0)
 976     {
 977         if (*sec == LONG_MIN)
 978         {
 979             set_invalid_timespec_msg(name, *sec, *nsec, filename, fd);
 980             return 0;
 981         }
 982         *nsec += 1000000000;
 983         *sec -= 1;
 984     }
 985     return 1;
 986 }
 987
 988
 989 #define CHECK_VALUE_FITS(name, value, src_type, dest_type, max_value) \
 990 if (sizeof(src_type) >= sizeof(dest_type) && (value) > (max_value)) \
 991 { \
 992     PyErr_SetString(PyExc_OverflowError, \
 993                     name " cannot be converted to integer"); \
 994     return NULL; \
 995 }
 996
 997
 998 static PyObject *stat_struct_to_py(const struct stat *st,
 999                                    const char *filename,
1000                                    int fd)
1001 {
1002     long long atime = st->st_atime;
1003     long long mtime = st->st_mtime;
1004     long long ctime = st->st_ctime;
1005     long atime_ns = BUP_STAT_ATIME_NS(st);
1006     long mtime_ns = BUP_STAT_MTIME_NS(st);
1007     long ctime_ns = BUP_STAT_CTIME_NS(st);
1008
1009     if (!normalize_timespec_values("atime", &atime, &atime_ns, filename, fd))
1010         return NULL;
1011     if (!normalize_timespec_values("mtime", &mtime, &mtime_ns, filename, fd))
1012         return NULL;
1013     if (!normalize_timespec_values("ctime", &ctime, &ctime_ns, filename, fd))
1014         return NULL;
1015
1016     // We can check the known (via POSIX) signed and unsigned types at
1017     // compile time, but not (easily) the unspecified types.  Ideally,
1018     // some of these will be optimized out at compile time.
1019     CHECK_VALUE_FITS("stat st_mode", st->st_mode, mode_t, PY_LONG_LONG, PY_LLONG_MAX);
1020     CHECK_VALUE_FITS("stat st_dev", st->st_dev, dev_t, PY_LONG_LONG, PY_LLONG_MAX);
1021     CHECK_VALUE_FITS("stat st_uid", st->st_uid, uid_t, PY_LONG_LONG, PY_LLONG_MAX);
1022     CHECK_VALUE_FITS("stat st_gid", st->st_uid, uid_t, PY_LONG_LONG, PY_LLONG_MAX);
1023     CHECK_VALUE_FITS("stat st_nlink", st->st_nlink, nlink_t, PY_LONG_LONG, PY_LLONG_MAX);
1024     CHECK_VALUE_FITS("stat st_rdev", st->st_rdev, dev_t, PY_LONG_LONG, PY_LLONG_MAX);
1025
1026     return Py_BuildValue("LKLLLLLL(Ll)(Ll)(Ll)",
1027                          (PY_LONG_LONG) st->st_mode,
1028                          (unsigned PY_LONG_LONG) st->st_ino,
1029                          (PY_LONG_LONG) st->st_dev,
1030                          (PY_LONG_LONG) st->st_nlink,
1031                          (PY_LONG_LONG) st->st_uid,
1032                          (PY_LONG_LONG) st->st_gid,
1033                          (PY_LONG_LONG) st->st_rdev,
1034                          (PY_LONG_LONG) st->st_size,
1035                          (PY_LONG_LONG) atime,
1036                          (long) atime_ns,
1037                          (PY_LONG_LONG) mtime,
1038                          (long) mtime_ns,
1039                          (PY_LONG_LONG) ctime,
1040                          (long) ctime_ns);
1041 }
1042
1043
1044 static PyObject *bup_stat(PyObject *self, PyObject *args)
1045 {
1046     int rc;
1047     char *filename;
1048
1049     if (!PyArg_ParseTuple(args, "s", &filename))
1050         return NULL;
1051
1052     struct stat st;
1053     rc = stat(filename, &st);
1054     if (rc != 0)
1055         return PyErr_SetFromErrnoWithFilename(PyExc_OSError, filename);
1056     return stat_struct_to_py(&st, filename, 0);
1057 }
1058
1059
1060 static PyObject *bup_lstat(PyObject *self, PyObject *args)
1061 {
1062     int rc;
1063     char *filename;
1064
1065     if (!PyArg_ParseTuple(args, "s", &filename))
1066         return NULL;
1067
1068     struct stat st;
1069     rc = lstat(filename, &st);
1070     if (rc != 0)
1071         return PyErr_SetFromErrnoWithFilename(PyExc_OSError, filename);
1072     return stat_struct_to_py(&st, filename, 0);
1073 }
1074
1075
1076 static PyObject *bup_fstat(PyObject *self, PyObject *args)
1077 {
1078     int rc, fd;
1079
1080     if (!PyArg_ParseTuple(args, "i", &fd))
1081         return NULL;
1082
1083     struct stat st;
1084     rc = fstat(fd, &st);
1085     if (rc != 0)
1086         return PyErr_SetFromErrno(PyExc_OSError);
1087     return stat_struct_to_py(&st, NULL, fd);
1088 }
1089
1090
1091 static PyMethodDef helper_methods[] = {
1092     { "selftest", selftest, METH_VARARGS,
1093         "Check that the rolling checksum rolls correctly (for unit tests)." },
1094     { "blobbits", blobbits, METH_VARARGS,
1095         "Return the number of bits in the rolling checksum." },
1096     { "splitbuf", splitbuf, METH_VARARGS,
1097         "Split a list of strings based on a rolling checksum." },
1098     { "bitmatch", bitmatch, METH_VARARGS,
1099         "Count the number of matching prefix bits between two strings." },
1100     { "firstword", firstword, METH_VARARGS,
1101         "Return an int corresponding to the first 32 bits of buf." },
1102     { "bloom_contains", bloom_contains, METH_VARARGS,
1103         "Check if a bloom filter of 2^nbits bytes contains an object" },
1104     { "bloom_add", bloom_add, METH_VARARGS,
1105         "Add an object to a bloom filter of 2^nbits bytes" },
1106     { "extract_bits", extract_bits, METH_VARARGS,
1107         "Take the first 'nbits' bits from 'buf' and return them as an int." },
1108     { "merge_into", merge_into, METH_VARARGS,
1109         "Merges a bunch of idx and midx files into a single midx." },
1110     { "write_idx", write_idx, METH_VARARGS,
1111         "Write a PackIdxV2 file from an idx list of lists of tuples" },
1112     { "write_random", write_random, METH_VARARGS,
1113         "Write random bytes to the given file descriptor" },
1114     { "random_sha", random_sha, METH_VARARGS,
1115         "Return a random 20-byte string" },
1116     { "open_noatime", open_noatime, METH_VARARGS,
1117         "open() the given filename for read with O_NOATIME if possible" },
1118     { "fadvise_done", fadvise_done, METH_VARARGS,
1119         "Inform the kernel that we're finished with earlier parts of a file" },
1120 #ifdef BUP_HAVE_FILE_ATTRS
1121     { "get_linux_file_attr", bup_get_linux_file_attr, METH_VARARGS,
1122       "Return the Linux attributes for the given file." },
1123 #endif
1124 #ifdef BUP_HAVE_FILE_ATTRS
1125     { "set_linux_file_attr", bup_set_linux_file_attr, METH_VARARGS,
1126       "Set the Linux attributes for the given file." },
1127 #endif
1128 #ifdef BUP_HAVE_BUP_UTIME_NS
1129     { "bup_utime_ns", bup_utime_ns, METH_VARARGS,
1130       "Change path timestamps with up to nanosecond precision." },
1131 #endif
1132 #ifdef BUP_HAVE_BUP_LUTIME_NS
1133     { "bup_lutime_ns", bup_lutime_ns, METH_VARARGS,
1134       "Change path timestamps with up to nanosecond precision;"
1135       " don't follow symlinks." },
1136 #endif
1137     { "stat", bup_stat, METH_VARARGS,
1138       "Extended version of stat." },
1139     { "lstat", bup_lstat, METH_VARARGS,
1140       "Extended version of lstat." },
1141     { "fstat", bup_fstat, METH_VARARGS,
1142       "Extended version of fstat." },
1143     { NULL, NULL, 0, NULL },  // sentinel
1144 };
1145
1146
1147 PyMODINIT_FUNC init_helpers(void)
1148 {
1149     // FIXME: migrate these tests to configure.  Check against the
1150     // type we're going to use when passing to python.  Other stat
1151     // types are tested at runtime.
1152     assert(sizeof(ino_t) <= sizeof(unsigned PY_LONG_LONG));
1153     assert(sizeof(off_t) <= sizeof(PY_LONG_LONG));
1154     assert(sizeof(blksize_t) <= sizeof(PY_LONG_LONG));
1155     assert(sizeof(blkcnt_t) <= sizeof(PY_LONG_LONG));
1156     // Just be sure (relevant when passing timestamps back to Python above).
1157     assert(sizeof(PY_LONG_LONG) <= sizeof(long long));
1158
1159     char *e;
1160     PyObject *m = Py_InitModule("_helpers", helper_methods);
1161     if (m == NULL)
1162         return;
1163     e = getenv("BUP_FORCE_TTY");
1164     istty2 = isatty(2) || (atoi(e ? e : "0") & 2);
1165     unpythonize_argv();
1166 }