src/utils.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * utils.cpp:
   4  *
   5  * Contact:
   6  *   Moonlight List (moonlight-list@lists.ximian.com)
   7  *
   8  * Copyright 2007 Novell, Inc. (http://www.novell.com)
   9  *
  10  * See the LICENSE file included with the distribution for details.
  11  */
  12
  13 #include <config.h>
  14
  15 #include <glib/gstdio.h>
  16 #include <fcntl.h>
  17 #include <errno.h>
  18 #include <stdlib.h>
  19
  20 #include "utils.h"
  21 #include "application.h"
  22 #include "deployment.h"
  23
  24 static gpointer
  25 managed_stream_open (gpointer context, const char *filename, int mode)
  26 {
  27         // minizip expects to get a FILE* here, we'll just shuffle our context around.
  28
  29         return context;
  30 }
  31
  32 static unsigned long
  33 managed_stream_read (gpointer context, gpointer stream, void *buf, unsigned long size)
  34 {
  35         ManagedStreamCallbacks *s = (ManagedStreamCallbacks *) context;
  36         unsigned long left = size;
  37         unsigned long nread = 0;
  38         int n;
  39
  40         do {
  41                 if ((n = s->Read (s->handle, (char *) buf + nread, 0, MIN (left, G_MAXINT32))) <= 0)
  42                         break;
  43
  44                 nread += n;
  45                 left -= n;
  46         } while (nread < size);
  47
  48         return nread;
  49 }
  50
  51 static unsigned long
  52 managed_stream_write (gpointer context, gpointer stream, const void *buf, unsigned long size)
  53 {
  54         ManagedStreamCallbacks *s = (ManagedStreamCallbacks *) context;
  55         unsigned long nwritten = 0;
  56         unsigned long left = size;
  57         int n;
  58
  59         do {
  60                 n = MIN (left, G_MAXINT32);
  61                 s->Write (s->handle, (char *) buf + nwritten, 0, n);
  62                 nwritten += n;
  63                 left -= n;
  64         } while (nwritten < size);
  65
  66         return nwritten;
  67 }
  68
  69 static long
  70 managed_stream_tell (gpointer context, gpointer stream)
  71 {
  72         ManagedStreamCallbacks *s = (ManagedStreamCallbacks *) context;
  73
  74         return s->Position (s->handle);
  75 }
  76
  77 static long
  78 managed_stream_seek (gpointer context, gpointer stream, unsigned long offset, int origin)
  79 {
  80         ManagedStreamCallbacks *s = (ManagedStreamCallbacks *) context;
  81
  82         s->Seek (s->handle, offset, origin);
  83
  84         return 0;
  85 }
  86
  87 static int
  88 managed_stream_close (gpointer context, gpointer stream)
  89 {
  90         return 0;
  91 }
  92
  93 static int
  94 managed_stream_error (gpointer context, gpointer stream)
  95 {
  96         return 0;
  97 }
  98
  99
 100 gboolean
 101 managed_unzip_stream_to_stream_first_file (ManagedStreamCallbacks *source, ManagedStreamCallbacks *dest)
 102 {
 103         zlib_filefunc_def funcs;
 104         unzFile zipFile;
 105         gboolean ret;
 106
 107         ret = FALSE;
 108
 109         funcs.zopen_file = managed_stream_open;
 110         funcs.zread_file = managed_stream_read;
 111         funcs.zwrite_file = managed_stream_write;
 112         funcs.ztell_file = managed_stream_tell;
 113         funcs.zseek_file = managed_stream_seek;
 114         funcs.zclose_file = managed_stream_close;
 115         funcs.zerror_file = managed_stream_error;
 116         funcs.opaque = source;
 117
 118         zipFile = unzOpen2 (NULL, &funcs);
 119
 120         if (!zipFile)
 121                 return FALSE;
 122
 123         if (unzGoToFirstFile (zipFile) != UNZ_OK)
 124                 goto cleanup;
 125
 126         if (unzOpenCurrentFile (zipFile) != UNZ_OK)
 127                 goto cleanup;
 128
 129         ret = managed_unzip_extract_to_stream (zipFile, dest);
 130
 131 cleanup:
 132         unzCloseCurrentFile (zipFile);
 133         unzClose (zipFile);
 134
 135         return ret;
 136 }
 137
 138 gboolean
 139 managed_unzip_stream_to_stream (ManagedStreamCallbacks *source, ManagedStreamCallbacks *dest, const char *partname)
 140 {
 141         zlib_filefunc_def funcs;
 142         unzFile zipFile;
 143         gboolean ret;
 144
 145         ret = FALSE;
 146
 147         funcs.zopen_file = managed_stream_open;
 148         funcs.zread_file = managed_stream_read;
 149         funcs.zwrite_file = managed_stream_write;
 150         funcs.ztell_file = managed_stream_tell;
 151         funcs.zseek_file = managed_stream_seek;
 152         funcs.zclose_file = managed_stream_close;
 153         funcs.zerror_file = managed_stream_error;
 154         funcs.opaque = source;
 155
 156         zipFile = unzOpen2 (NULL, &funcs);
 157
 158         if (!zipFile)
 159                 return FALSE;
 160
 161         if (unzLocateFile (zipFile, partname, 2) != UNZ_OK)
 162                 goto cleanup;
 163
 164         if (unzOpenCurrentFile (zipFile) != UNZ_OK)
 165                 goto cleanup;
 166
 167         ret = managed_unzip_extract_to_stream (zipFile, dest);
 168
 169 cleanup:
 170         unzCloseCurrentFile (zipFile);
 171         unzClose (zipFile);
 172
 173         return ret;
 174 }
 175
 176 gboolean
 177 managed_unzip_extract_to_stream (unzFile zipFile, ManagedStreamCallbacks *dest)
 178 {
 179         char buf[4096];
 180         int nread;
 181
 182         do {
 183                 if ((nread = unzReadCurrentFile (zipFile, buf, sizeof (buf))) > 0) {
 184                         dest->Write (dest->handle, buf, 0, nread);
 185                 }
 186         } while (nread > 0);
 187
 188         return TRUE;
 189 }
 190
 191 /**
 192  * MID:
 193  * @lo: the low bound
 194  * @hi: the high bound
 195  *
 196  * Finds the midpoint between positive integer values, @lo and @hi.
 197  *
 198  * Notes: Typically expressed as '(@lo + @hi) / 2', this is incorrect
 199  * when @lo and @hi are sufficiently large enough that combining them
 200  * would overflow their integer type. To work around this, we use the
 201  * formula, '@lo + ((@hi - @lo) / 2)', thus preventing this problem
 202  * from occuring.
 203  *
 204  * Returns the midpoint between @lo and @hi (rounded down).
 205  **/
 206 #define MID(lo, hi) (lo + ((hi - lo) >> 1))
 207
 208
 209 static guint
 210 bsearch (GPtrArray *array, bool stable, GCompareFunc cmp, void *item)
 211 {
 212         register guint lo, hi;
 213         guint m;
 214         int c;
 215
 216         if (array->len == 0)
 217                 return 0;
 218
 219         lo = 0, hi = array->len;
 220
 221         do {
 222                 m = MID (lo, hi);
 223                 if ((c = cmp (&item, &array->pdata[m])) > 0) {
 224                         lo = m + 1;
 225                         m = lo;
 226                 } else if (c < 0) {
 227                         hi = m;
 228                 } else if (stable) {
 229                         lo = m + 1;
 230                         m = lo;
 231                 } else {
 232                         break;
 233                 }
 234         } while (lo < hi);
 235
 236         return m;
 237 }
 238
 239 void
 240 g_ptr_array_insert_sorted (GPtrArray *array, GCompareFunc cmp, void *item)
 241 {
 242         guint index = bsearch (array, true, cmp, item);
 243
 244         g_ptr_array_insert (array, index, item);
 245 }
 246
 247 void
 248 g_ptr_array_insert (GPtrArray *array, guint index, void *item)
 249 {
 250         guint8 *dest, *src;
 251         guint n;
 252
 253         if (index >= array->len) {
 254                 g_ptr_array_add (array, item);
 255                 return;
 256         }
 257
 258         g_ptr_array_set_size (array, array->len + 1);
 259
 260         dest = ((guint8 *) array->pdata) + (sizeof (void *) * (index + 1));
 261         src = ((guint8 *) array->pdata) + (sizeof (void *) * index);
 262         n = array->len - index - 1;
 263
 264         memmove (dest, src, (sizeof (void *) * n));
 265         array->pdata[index] = item;
 266 }
 267
 268 int
 269 write_all (int fd, char *buf, size_t len)
 270 {
 271         size_t nwritten = 0;
 272         ssize_t n;
 273
 274         do {
 275                 do {
 276                         n = write (fd, buf + nwritten, len - nwritten);
 277                 } while (n == -1 && errno == EINTR);
 278
 279                 if (n == -1)
 280                         return -1;
 281
 282                 nwritten += n;
 283         } while (nwritten < len);
 284
 285         return 0;
 286 }
 287
 288 static bool
 289 is_dll_or_mdb (const char *filename, int n)
 290 {
 291         return n > 4 && (!g_ascii_strcasecmp (filename + (n - 4), ".dll") || !g_ascii_strcasecmp (filename + (n - 4), ".mdb"));
 292 }
 293
 294 const char *
 295 CanonicalizeFilename (char *filename, int n, CanonMode mode)
 296 {
 297         char *inptr = filename;
 298         char *inend;
 299
 300         if (n < 0)
 301                 n = strlen (filename);
 302
 303         inend = inptr + n;
 304
 305         if (mode == CanonModeXap && is_dll_or_mdb (filename, n)) {
 306                 // Note: We don't want to change the casing of the dll's
 307                 // basename since Mono requires the basename to match the
 308                 // expected case.
 309
 310                 inend -= 5;
 311                 while (inend > inptr && *inend != '\\' && *inend != '/')
 312                         inend--;
 313
 314                 if (*inend == '\\') {
 315                         // include the trailing '\\'
 316                         inend++;
 317                 }
 318         }
 319
 320         while (inptr < inend) {
 321                 if (*inptr != '\\') {
 322                         if (mode != CanonModeNone)
 323                                 *inptr = g_ascii_tolower (*inptr);
 324                 } else
 325                         *inptr = G_DIR_SEPARATOR;
 326
 327                 inptr++;
 328         }
 329
 330         return filename;
 331 }
 332
 333 bool
 334 ExtractFile (unzFile zip, int fd)
 335 {
 336         char buf[4096];
 337         int nread;
 338         ssize_t n;
 339
 340         do {
 341                 n = 0;
 342                 if ((nread = unzReadCurrentFile (zip, buf, sizeof (buf))) > 0) {
 343                         if ((n = write_all (fd, buf, nread)) == -1)
 344                                 break;
 345                 }
 346         } while (nread > 0);
 347
 348         if (nread != 0 || n == -1 /*|| fsync (fd) == -1*/) {
 349                 close (fd);
 350
 351                 return false;
 352         }
 353
 354         close (fd);
 355
 356         return true;
 357 }
 358
 359 bool
 360 ExtractAll (unzFile zip, const char *dir, CanonMode mode)
 361 {
 362         char *filename, *dirname, *path, *altpath;
 363         unz_file_info info;
 364         int fd;
 365
 366         if (unzGoToFirstFile (zip) != UNZ_OK)
 367                 return false;
 368
 369         do {
 370                 unzGetCurrentFileInfo (zip, &info, NULL, 0, NULL, 0, NULL, 0);
 371                 if (info.external_fa & (1 << 4))
 372                         continue;
 373
 374                 if (!(filename = (char *) g_malloc (info.size_filename + 1)))
 375                         return false;
 376
 377                 unzGetCurrentFileInfo (zip, NULL, filename, info.size_filename + 1, NULL, 0, NULL, 0);
 378
 379                 CanonicalizeFilename (filename, info.size_filename, mode);
 380
 381                 path = g_build_filename (dir, filename, NULL);
 382
 383                 dirname = g_path_get_dirname (path);
 384                 if (g_mkdir_with_parents (dirname, 0700) == -1 && errno != EEXIST) {
 385                         g_free (filename);
 386                         g_free (dirname);
 387                         g_free (path);
 388                         return false;
 389                 }
 390
 391                 g_free (dirname);
 392
 393                 if ((fd = g_open (path, O_CREAT | O_WRONLY | O_TRUNC, 0600)) == -1) {
 394                         g_free (filename);
 395                         g_free (path);
 396                         return false;
 397                 }
 398
 399                 if (unzOpenCurrentFile (zip) != UNZ_OK) {
 400                         g_free (filename);
 401                         g_free (path);
 402                         close (fd);
 403                         return false;
 404                 }
 405
 406                 if (!ExtractFile (zip, fd)) {
 407                         unzCloseCurrentFile (zip);
 408                         g_free (filename);
 409                         g_free (path);
 410                         return false;
 411                 }
 412
 413                 unzCloseCurrentFile (zip);
 414
 415                 if (mode == CanonModeXap && is_dll_or_mdb (filename, info.size_filename)) {
 416                         CanonicalizeFilename (filename, info.size_filename, CanonModeResource);
 417                         altpath = g_build_filename (dir, filename, NULL);
 418                         if (strcmp (path, altpath) != 0)
 419                                 symlink (path, altpath);
 420                         g_free (altpath);
 421                 }
 422
 423                 g_free (filename);
 424                 g_free (path);
 425         } while (unzGoToNextFile (zip) == UNZ_OK);
 426
 427         return true;
 428 }
 429
 430 char *
 431 MakeTempDir (char *tmpdir)
 432 {
 433         char *xxx;
 434         int attempts = 0;
 435         size_t n;
 436
 437         if ((n = strlen (tmpdir)) < 6) {
 438                 errno = EINVAL;
 439                 return NULL;
 440         }
 441
 442         xxx = tmpdir + (n - 6);
 443         if (strcmp (xxx, "XXXXXX") != 0) {
 444                 errno = EINVAL;
 445                 return NULL;
 446         }
 447
 448         do {
 449
 450                 if (!mktemp (tmpdir))
 451                         return NULL;
 452
 453                 if (g_mkdir (tmpdir, 0700) != -1)
 454                         return tmpdir;
 455
 456                 if (errno != EEXIST) {
 457                         // don't bother trying again...
 458                         return NULL;
 459                 }
 460
 461                 // that path already exists, try a new one...
 462                 strcpy (xxx, "XXXXXX");
 463                 attempts++;
 464         } while (attempts < 100);
 465
 466         return NULL;
 467 }
 468
 469
 470 static int
 471 rmdir_real (GString *path)
 472 {
 473         const gchar *dirname;
 474         struct stat st;
 475         size_t len;
 476         GDir *dir;
 477
 478         if (!(dir = g_dir_open (path->str, 0, NULL)))
 479                 return -1;
 480
 481         g_string_append_c (path, G_DIR_SEPARATOR);
 482         len = path->len;
 483
 484         while ((dirname = g_dir_read_name (dir))) {
 485                 if (!strcmp (dirname, ".") || !strcmp (dirname, ".."))
 486                         continue;
 487
 488                 g_string_truncate (path, len);
 489                 g_string_append (path, dirname);
 490
 491                 if (g_lstat (path->str, &st) == -1)
 492                         continue;
 493
 494                 if (S_ISDIR (st.st_mode))
 495                         rmdir_real (path);
 496                 else
 497                         g_unlink (path->str);
 498         }
 499
 500         g_dir_close (dir);
 501
 502         g_string_truncate (path, len - 1);
 503
 504         return g_rmdir (path->str);
 505 }
 506
 507 //
 508 // Creates a temporary directory, based on the @filename template
 509 //
 510 // Returns: a g-allocated string name that points to the created
 511 // directory, or NULL on failure
 512 //
 513 char *
 514 CreateTempDir (const char *filename)
 515 {
 516         const char *name;
 517         char *path, *buf;
 518
 519         if (!(name = strrchr (filename, '/')))
 520                 name = filename;
 521         else
 522                 name++;
 523
 524         buf = g_strdup_printf ("%s.XXXXXX", name);
 525
 526         if (Application::GetCurrent())
 527                 path = g_build_filename (Application::GetCurrent()->GetResourceRoot(), buf, NULL);
 528         else {
 529                 path = g_build_filename (g_get_tmp_dir (), buf, NULL);
 530                 Deployment::GetCurrent()->TrackPath (path);
 531         }
 532         g_free (buf);
 533
 534         if (!MakeTempDir (path)) {
 535                 g_free (path);
 536                 return NULL;
 537         }
 538
 539         return path;
 540 }
 541
 542 int
 543 RemoveDir (const char *dir)
 544 {
 545         GString *path;
 546         int rv;
 547
 548         path = g_string_new (dir);
 549         rv = rmdir_real (path);
 550         g_string_free (path, true);
 551
 552         return rv;
 553 }
 554
 555 int
 556 CopyFileTo (const char *filename, int fd)
 557 {
 558         char buf[4096];
 559         ssize_t nread;
 560         int in;
 561
 562         if ((in = g_open (filename, O_RDONLY)) == -1) {
 563                 close (fd);
 564                 return -1;
 565         }
 566
 567         do {
 568                 do {
 569                         nread = read (in, buf, sizeof (buf));
 570                 } while (nread == -1 && errno == EINTR);
 571
 572                 if (nread == -1)
 573                         goto exception;
 574
 575                 if (nread == 0)
 576                         break;
 577
 578                 if (write_all (fd, buf, nread) == -1)
 579                         goto exception;
 580         } while (true);
 581
 582         if (fsync (fd) == -1)
 583                 goto exception;
 584
 585         close (in);
 586         close (fd);
 587
 588         return 0;
 589
 590 exception:
 591
 592         close (in);
 593         close (fd);
 594
 595         return -1;
 596 }
 597
 598 cairo_t*
 599 measuring_context_create (void)
 600 {
 601         cairo_surface_t* surf = cairo_image_surface_create (CAIRO_FORMAT_A1, 1, 1);
 602         return cairo_create (surf);
 603 }
 604
 605 void
 606 measuring_context_destroy (cairo_t *cr)
 607 {
 608         cairo_surface_destroy (cairo_get_target (cr));
 609         cairo_destroy (cr);
 610 }
 611
 612
 613 static ssize_t
 614 read_internal (int fd, char *buf, size_t n)
 615 {
 616         ssize_t nread;
 617
 618         do {
 619                 nread = read (fd, buf, n);
 620         } while (nread == -1 && errno == EINTR);
 621
 622         return nread;
 623 }
 624
 625
 626 TextStream::TextStream ()
 627 {
 628         cd = (GIConv) -1;
 629         bufptr = buffer;
 630         buflen = 0;
 631         fd = -1;
 632
 633         eof = true;
 634 }
 635
 636 TextStream::~TextStream ()
 637 {
 638         if (fd != -1)
 639                 close (fd);
 640
 641         if (cd != (GIConv) -1) {
 642                 g_iconv_close (cd);
 643                 cd = (GIConv) -1;
 644         }
 645 }
 646
 647 #define BOM ((gunichar2) 0xFEFF)
 648 #define ANTIBOM ((gunichar2) 0xFFFE)
 649
 650 enum Encoding {
 651         UTF16_BE,
 652         UTF16_LE,
 653         UTF32_BE,
 654         UTF32_LE,
 655         UTF8,
 656         UNKNOWN,
 657 };
 658
 659 static const char *encoding_names[] = { "UTF-16BE", "UTF-16LE", "UTF-32BE", "UTF-32LE", "UTF-8" };
 660
 661
 662 bool
 663 TextStream::OpenBuffer (const char *buf, int size)
 664 {
 665         fmode = false;
 666
 667         textbufptr = textbuf = (char *) buf;
 668         textbufsize = size;
 669
 670         if (size > 0)
 671                 eof = false;
 672
 673         return ReadBOM (false);
 674 }
 675
 676 bool
 677 TextStream::OpenFile (const char *filename, bool force)
 678 {
 679         fmode = true;
 680
 681         if (fd != -1)
 682                 Close ();
 683
 684         if ((fd = g_open (filename, O_RDONLY)) == -1)
 685                 return false;
 686
 687         return ReadBOM (force);
 688 }
 689
 690 bool
 691 TextStream::ReadBOM (bool force)
 692 {
 693         Encoding encoding = UNKNOWN;
 694         gunichar2 bom;
 695         ssize_t nread;
 696
 697         // prefetch the first chunk of data in order to determine encoding
 698         if ((nread = ReadInternal (buffer, sizeof (buffer))) == -1) {
 699                 Close ();
 700
 701                 return false;
 702         }
 703
 704         bufptr = buffer;
 705         buflen = nread;
 706
 707         if (nread >= 2) {
 708                 memcpy (&bom, buffer, 2);
 709                 switch (bom) {
 710                 case ANTIBOM:
 711                         encoding = UTF16_BE;
 712                         buflen -= 2;
 713                         bufptr += 2;
 714                         break;
 715                 case BOM:
 716                         encoding = UTF16_LE;
 717                         buflen -= 2;
 718                         bufptr += 2;
 719                         break;
 720                 case 0:
 721                         if (nread >= 4) {
 722                                 memcpy (&bom, buffer + 2, 2);
 723                                 if (bom == ANTIBOM) {
 724                                         encoding = UTF32_BE;
 725                                         buflen -= 4;
 726                                         bufptr += 4;
 727                                 } else if (bom == BOM) {
 728                                         encoding = UTF32_LE;
 729                                         buflen -= 4;
 730                                         bufptr += 4;
 731                                 }
 732                         }
 733                         break;
 734                 default:
 735                         encoding = UTF8;
 736                         break;
 737                 }
 738         } else {
 739                 // assume utf-8
 740                 encoding = UTF8;
 741         }
 742
 743         if (encoding == UNKNOWN) {
 744                 if (!force) {
 745                         Close ();
 746
 747                         return false;
 748                 }
 749
 750                 encoding = UTF8;
 751         }
 752
 753         if (encoding != UTF8 && (cd = g_iconv_open ("UTF-8", encoding_names[encoding])) == (GIConv) -1) {
 754                 Close ();
 755
 756                 return false;
 757         }
 758
 759         eof = false;
 760
 761         return true;
 762 }
 763
 764 void
 765 TextStream::Close ()
 766 {
 767         if (fd != -1) {
 768                 close (fd);
 769                 fd = -1;
 770         }
 771
 772         if (cd != (GIConv) -1) {
 773                 g_iconv_close (cd);
 774                 cd = (GIConv) -1;
 775         }
 776
 777         bufptr = buffer;
 778         buflen = 0;
 779         eof = true;
 780 }
 781
 782 bool
 783 TextStream::Eof ()
 784 {
 785         return eof && buflen == 0;
 786 }
 787
 788 ssize_t
 789 TextStream::Read (char *buf, size_t n)
 790 {
 791         size_t inleft = buflen;
 792         char *inbuf = bufptr;
 793         char *outbuf = buf;
 794         size_t outleft = n;
 795         ssize_t nread;
 796         size_t r;
 797
 798         do {
 799                 if (cd != (GIConv) -1) {
 800                         if (g_iconv (cd, &inbuf, &inleft, &outbuf, &outleft) == (size_t) -1) {
 801                                 switch (errno) {
 802                                 case E2BIG:
 803                                         // not enough space available in the output buffer
 804                                         goto out;
 805                                 case EINVAL:
 806                                         // incomplete multibyte character sequence
 807                                         goto out;
 808                                 case EILSEQ:
 809                                         // illegal multibyte sequence
 810                                         return -1;
 811                                 default:
 812                                         // unknown error, fail
 813                                         return -1;
 814                                 }
 815                         }
 816                 } else {
 817                         r = MIN (inleft, outleft);
 818                         memcpy (outbuf, inbuf, r);
 819                         outleft -= r;
 820                         outbuf += r;
 821                         inleft -= r;
 822                         inbuf += r;
 823                 }
 824
 825                 if (outleft == 0 || eof)
 826                         break;
 827
 828                 // buffer more data
 829                 if (inleft > 0)
 830                         memmove (buffer, inbuf, inleft);
 831
 832                 inbuf = buffer + inleft;
 833                 if ((nread = ReadInternal (inbuf, sizeof (buffer) - inleft)) <= 0) {
 834                         eof = true;
 835                         break;
 836                 }
 837
 838                 inleft += nread;
 839                 inbuf = buffer;
 840         } while (true);
 841
 842         if (eof && cd != (GIConv) -1)
 843                 g_iconv (cd, NULL, NULL, &outbuf, &outleft);
 844
 845 out:
 846
 847         buflen = inleft;
 848         bufptr = inbuf;
 849
 850         return (outbuf - buf);
 851 }
 852
 853 ssize_t
 854 TextStream::ReadInternal (char *buffer, ssize_t size)
 855 {
 856         if (fmode) {
 857                 return read_internal (fd, buffer, size);
 858         } else {
 859                 ssize_t nread = size;
 860
 861                 if (eof)
 862                         return -1;
 863
 864                 if (textbufptr + size > textbuf + textbufsize) {
 865                         eof = true;
 866                         nread = textbuf + textbufsize - textbufptr;
 867                 }
 868                 memcpy (buffer, textbufptr, nread);
 869
 870                 textbufptr += nread;
 871
 872                 return nread;
 873         }
 874 }
 875
 876
 877 GArray *double_garray_from_str (const char *s, gint max)
 878 {
 879         char *next = (char *)s;
 880         GArray *values = g_array_sized_new (false, true, sizeof (double), max > 0 ? max : 16);
 881         double coord = 0.0;
 882         guint end = max > 0 ? max : G_MAXINT;
 883
 884         while (next && values->len < end) {
 885                 while (g_ascii_isspace (*next) || *next == ',')
 886                         next = g_utf8_next_char (next);
 887
 888                 if (next) {
 889                         errno = 0;
 890                         char *prev = next;
 891                         coord = g_ascii_strtod (prev, &next);
 892                         if (errno != 0 || next == prev)
 893                                 goto error;
 894
 895                         g_array_append_val (values, coord);
 896                 }
 897         }
 898
 899 error:
 900         while (values->len < (guint) max) {
 901                 coord = 0.0;
 902                 g_array_append_val (values, coord);
 903         }
 904
 905         return values;
 906 }
 907
 908 char * parse_rfc_1945_quoted_string (char *input, char *c, char **end)
 909 {
 910         char *start;
 911
 912         if (input == NULL || input [0] != '"')
 913                 return NULL;
 914
 915         *end = NULL;
 916
 917         input++;
 918         start = input;
 919
 920         do {
 921 /*
 922  *      We're parsing a quoted-string according to RFC 1945:
 923  *
 924  *       quoted-string  = ( <"> *(qdtext) <"> )
 925  *
 926  *       qdtext         = <any CHAR except <"> and CTLs,
 927  *                        but including LWS>
 928  *
 929  *       LWS            = [CRLF] 1*( SP | HT )
 930  *       CTL            = <any US-ASCII control character
 931  *                        (octets 0 - 31) and DEL (127)>
 932  *
 933  */
 934                 char h = *input;
 935                 *c = h;
 936
 937                 // LWS
 938                 if (h == 10 || h == 13 || h == ' ' || h == 9)
 939                         continue;
 940
 941                 // CTL
 942                 if (h == 0)
 943                         return start;
 944
 945                 if ((h > 0 && h <= 31) || h == 127) {
 946                         *end = input + 1;
 947                         *input = 0;
 948                         return start;
 949                 }
 950
 951                 // quote
 952                 if (h == '"') {
 953                         *end = input + 1;
 954                         *input = 0;
 955                         return start;
 956                 }
 957
 958         } while (*(input++));
 959
 960         return start;
 961 }
 962
 963 char *parse_rfc_1945_token (char *input, char *c, char **end)
 964 {
 965         char *start = input;
 966         bool first = false;
 967
 968         if (input == NULL || c == NULL || end == NULL)
 969                 return NULL;
 970
 971         *c = 0;
 972         *end = NULL;
 973
 974
 975         do {
 976 /*
 977  *      We're parsing a token according to RFC 1945:
 978  *
 979  *       token          = 1*<any CHAR except CTLs or tspecials>
 980  *
 981  *       tspecials      = "(" | ")" | "<" | ">" | "@"
 982  *                      | "," | ";" | ":" | "\" | <">
 983  *                      | "/" | "[" | "]" | "?" | "="
 984  *                      | "{" | "}" | SP | HT
 985  *
 986  *       CTL            = <any US-ASCII control character
 987  *                        (octets 0 - 31) and DEL (127)>
 988  *       SP             = <US-ASCII SP, space (32)>
 989  *       HT             = <US-ASCII HT, horizontal-tab (9)>
 990  *
 991  */
 992                 char h = *input;
 993                 *c = h;
 994
 995                 // CTL
 996                 if (h == 0)
 997                         return start;
 998
 999                 if ((h > 0 && h <= 31) || h == 127) {
1000                         if (!first) {
1001                                 start = input + 1;
1002                                 continue;
1003                         }
1004                         *end = input + 1;
1005                         *input = 0;
1006                         continue;
1007                 }
1008
1009                 // tspecials
1010                 switch (h) {
1011                 case '(':
1012                 case ')':
1013                 case '<':
1014                 case '>':
1015                 case '@':
1016                 case ',':
1017                 case ';':
1018                 case ':':
1019                 case '\\':
1020                 case '"':
1021                 case '/':
1022                 case '[':
1023                 case ']':
1024                 case '?':
1025                 case '=':
1026                 case '{':
1027                 case '}':
1028                 case 32:
1029                 case 9:
1030                         if (!first) {
1031                                 start = input + 1;
1032                                 continue;
1033                         }
1034                         *end = input + 1;
1035                         *input = 0;
1036                         return start;
1037                 }
1038                 first = true;
1039         } while (*(input++));
1040
1041
1042         // reached the end of the input, only one token
1043         return start;
1044 }
1045
1046 Cancellable::Cancellable ()
1047 {
1048         cancel_cb = NULL;
1049         downloader = NULL;
1050 }
1051
1052 Cancellable::~Cancellable ()
1053 {
1054         if (downloader)
1055                 downloader->unref ();
1056 }
1057
1058 void
1059 Cancellable::Cancel ()
1060 {
1061         if (cancel_cb)
1062                 cancel_cb (downloader, context);
1063 }
1064
1065 void
1066 Cancellable::SetCancelFuncAndData (CancelCallback cb, Downloader *downloader, void *_context)
1067 {
1068         cancel_cb = cb;
1069         context = _context;
1070         if (this->downloader)
1071                 this->downloader->unref ();
1072         this->downloader = downloader;
1073         if (this->downloader)
1074                 this->downloader->ref ();
1075 }