libdocument/ev-file-helpers.c

   1 /*
   2  *  Copyright (C) 2002 Jorn Baayen
   3  *  Copyright © 2009 Christian Persch
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <config.h>
  21
  22 #include <stdlib.h>
  23 #include <sys/types.h>
  24 #include <unistd.h>
  25 #include <string.h>
  26 #include <errno.h>
  27
  28 #include <glib.h>
  29 #include <glib/gstdio.h>
  30 #include <glib/gi18n-lib.h>
  31
  32 #include "ev-file-helpers.h"
  33
  34 static gchar *tmp_dir = NULL;
  35
  36 /*
  37  * ev_dir_ensure_exists:
  38  * @dir: the directory name
  39  * @mode: permissions to use when creating the directory
  40  * @error: a location to store a #GError
  41  *
  42  * Create @dir recursively with permissions @mode.
  43  *
  44  * Returns: %TRUE on success, or %FALSE on error with @error filled in
  45  */
  46 static gboolean
  47 _ev_dir_ensure_exists (const gchar *dir,
  48                        int          mode,
  49                        GError     **error)
  50 {
  51         int errsv;
  52         char *display_name;
  53
  54         g_return_val_if_fail (dir != NULL, FALSE);
  55
  56         errno = 0;
  57         if (g_mkdir_with_parents (dir, mode) == 0)
  58                 return TRUE;
  59
  60         errsv = errno;
  61         if (errsv == EEXIST && g_file_test (dir, G_FILE_TEST_IS_DIR))
  62                 return TRUE;
  63
  64         display_name = g_filename_display_name (dir);
  65         g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv),
  66                      "Failed to create directory '%s': %s",
  67                      display_name, g_strerror (errsv));
  68         g_free (display_name);
  69
  70         return FALSE;
  71 }
  72
  73 /*
  74  * _ev_tmp_dir:
  75  * @error: a location to store a #GError
  76  *
  77  * Returns the tmp directory.
  78  *
  79  * Returns: the tmp directory, or %NULL with @error filled in if the
  80  *   directory could not be created
  81  */
  82 static const char *
  83 _ev_tmp_dir (GError **error)
  84 {
  85
  86         if (tmp_dir == NULL) {
  87                 gchar *dirname, *prgname;
  88
  89                 prgname = g_get_prgname ();
  90                 dirname = g_strdup_printf ("%s-%u", prgname ? prgname : "unknown", getpid ());
  91                 tmp_dir = g_build_filename (g_get_tmp_dir (), dirname, NULL);
  92                 g_free (dirname);
  93         }
  94
  95         if (!_ev_dir_ensure_exists (tmp_dir, 0700, error))
  96                 return NULL;
  97
  98         return tmp_dir;
  99 }
 100
 101 void
 102 _ev_file_helpers_init (void)
 103 {
 104 }
 105
 106 void
 107 _ev_file_helpers_shutdown (void)
 108 {
 109         if (tmp_dir != NULL)
 110                 g_rmdir (tmp_dir);
 111
 112         g_free (tmp_dir);
 113         tmp_dir = NULL;
 114 }
 115
 116 /**
 117  * ev_mkstemp:
 118  * @template: a template string; must contain 'XXXXXX', but not necessarily as a suffix
 119  * @file_name: a location to store the filename of the temp file
 120  * @error: a location to store a #GError
 121  *
 122  * Creates a temp file in the evince temp directory.
 123  *
 124  * Returns: a file descriptor to the newly created temp file name, or %-1
 125  *   on error with @error filled in
 126  */
 127 int
 128 ev_mkstemp (const char  *template,
 129             char       **file_name,
 130             GError     **error)
 131 {
 132         const char *tmp;
 133         char *name;
 134         int fd;
 135
 136         if ((tmp = _ev_tmp_dir (error)) == NULL)
 137               return -1;
 138
 139         name = g_build_filename (tmp, template, NULL);
 140         fd = g_mkstemp (name);
 141
 142         if (fd == -1) {
 143                 int errsv = errno;
 144
 145                 g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv),
 146                              _("Failed to create a temporary file: %s"),
 147                              g_strerror (errsv));
 148
 149                 g_free (name);
 150                 return -1;
 151         }
 152
 153         if (file_name)
 154                 *file_name = name;
 155
 156         return fd;
 157 }
 158
 159 static void
 160 close_fd_cb (gpointer fdptr)
 161 {
 162         int fd = GPOINTER_TO_INT (fdptr);
 163
 164         close (fd);
 165 }
 166
 167 /**
 168  * ev_mkstemp_file:
 169  * @template: a template string; must contain 'XXXXXX', but not necessarily as a suffix
 170  * @error: a location to store a #GError
 171  *
 172  * Creates a temp #GFile in the evince temp directory. See ev_mkstemp() for more information.
 173  *
 174  * Returns: a newly allocated #GFile for the newly created temp file name, or %NULL
 175  *   on error with @error filled in
 176  */
 177 GFile *
 178 ev_mkstemp_file (const char        *template,
 179                  GError           **error)
 180 {
 181         char *file_name;
 182         int fd;
 183         GFile *file;
 184
 185         fd = ev_mkstemp (template, &file_name, error);
 186         if (fd == -1)
 187                 return NULL;
 188
 189         file = g_file_new_for_path (file_name);
 190         g_free (file_name);
 191
 192         g_object_set_data_full (G_OBJECT (file), "ev-mkstemp-fd",
 193                                 GINT_TO_POINTER (fd), (GDestroyNotify) close_fd_cb);
 194
 195         return file;
 196 }
 197
 198 /**
 199  * This function is copied from
 200  * http://bugzilla.gnome.org/show_bug.cgi?id=524831
 201  * and renamed from g_mkdtemp to _ev_g_mkdtemp.
 202  *
 203  * If/when this function gets added to glib, it can be removed from
 204  * evince' sources.
 205  *
 206  *
 207  * g_mkdtemp:
 208  * @tmpl: template directory name
 209  *
 210  * Creates a temporary directory. See the mkdtemp() documentation
 211  * on most UNIX-like systems.
 212  *
 213  * The parameter is a string that should follow the rules for
 214  * mkdtemp() templates, i.e. contain the string "XXXXXX".  g_mkdtemp()
 215  * is slightly more flexible than mkdtemp() in that the sequence does
 216  * not have to occur at the very end of the template. The X string
 217  * will be modified to form the name of a directory that didn't
 218  * already exist.  The string should be in the GLib file name
 219  * encoding. Most importantly, on Windows it should be in UTF-8.
 220  *
 221  * Return value: If a temporary directory was successfully created,
 222  * @tmpl will be returned with the XXXXXX string modified in such a
 223  * way as to make the path unique.  In case of errors, %NULL is
 224  * returned.
 225  */
 226 static gchar *
 227 _ev_g_mkdtemp (gchar *tmpl)
 228 {
 229   static const char letters[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 230   static const int NLETTERS = sizeof (letters) - 1;
 231   static int counter = 0;
 232   char *XXXXXX;
 233   GTimeVal tv;
 234   glong value;
 235   int count;
 236
 237   /* find the last occurrence of "XXXXXX" */
 238   XXXXXX = g_strrstr (tmpl, "XXXXXX");
 239
 240   if (!XXXXXX || strncmp (XXXXXX, "XXXXXX", 6))
 241     {
 242       errno = EINVAL;
 243       return NULL;
 244     }
 245
 246   /* Get some more or less random data.  */
 247   g_get_current_time (&tv);
 248   value = (tv.tv_usec ^ tv.tv_sec) + counter++;
 249
 250   for (count = 0; count < 100; value += 7777, ++count)
 251     {
 252       glong v = value;
 253
 254       /* Fill in the random bits.  */
 255       XXXXXX[0] = letters[v % NLETTERS];
 256       v /= NLETTERS;
 257       XXXXXX[1] = letters[v % NLETTERS];
 258       v /= NLETTERS;
 259       XXXXXX[2] = letters[v % NLETTERS];
 260       v /= NLETTERS;
 261       XXXXXX[3] = letters[v % NLETTERS];
 262       v /= NLETTERS;
 263       XXXXXX[4] = letters[v % NLETTERS];
 264       v /= NLETTERS;
 265       XXXXXX[5] = letters[v % NLETTERS];
 266
 267       /* tmpl is in UTF-8 on Windows, thus use g_mkdir() */
 268       if (g_mkdir (tmpl, 0700) == 0)
 269         return tmpl;
 270
 271       if (errno != EEXIST)
 272          /* Any other error will apply also to other names we might
 273          *  try, and there are 2^32 or so of them, so give up now.
 274          */
 275          return NULL;
 276     }
 277
 278   /* We got out of the loop because we ran out of combinations to try.  */
 279   errno = EEXIST;
 280   return NULL;
 281 }
 282
 283 /**
 284  * ev_mkdtemp:
 285  * @template: a template string; must end in 'XXXXXX'
 286  * @error: a location to store a #GError
 287  *
 288  * Creates a temp directory in the evince temp directory.
 289  *
 290  * Returns: a newly allocated string with the temp directory name, or %NULL
 291  *   on error with @error filled in
 292  */
 293 gchar *
 294 ev_mkdtemp (const char        *template,
 295             GError           **error)
 296 {
 297         const char *tmp;
 298         char *name;
 299
 300         if ((tmp = _ev_tmp_dir (error)) == NULL)
 301               return NULL;
 302
 303         name = g_build_filename (tmp, template, NULL);
 304         if (_ev_g_mkdtemp (name) == NULL) {
 305                 int errsv = errno;
 306
 307                 g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv),
 308                              _("Failed to create a temporary directory: %s"),
 309                              g_strerror (errsv));
 310
 311                 g_free (name);
 312                 return NULL;
 313         }
 314
 315         return name;
 316 }
 317
 318 /* Remove a local temp file created by evince */
 319 void
 320 ev_tmp_filename_unlink (const gchar *filename)
 321 {
 322         const gchar *tempdir;
 323
 324         if (!filename)
 325                 return;
 326
 327         tempdir = g_get_tmp_dir ();
 328         if (g_str_has_prefix (filename, tempdir) == 0) {
 329                 g_unlink (filename);
 330         }
 331 }
 332
 333 void
 334 ev_tmp_file_unlink (GFile *file)
 335 {
 336         gboolean res;
 337         GError  *error = NULL;
 338
 339         if (!file)
 340                 return;
 341
 342         res = g_file_delete (file, NULL, &error);
 343         if (!res) {
 344                 char *uri;
 345
 346                 uri = g_file_get_uri (file);
 347                 g_warning ("Unable to delete temp file %s: %s\n", uri, error->message);
 348                 g_free (uri);
 349                 g_error_free (error);
 350         }
 351 }
 352
 353 void
 354 ev_tmp_uri_unlink (const gchar *uri)
 355 {
 356         GFile *file;
 357
 358         if (!uri)
 359                 return;
 360
 361         file = g_file_new_for_uri (uri);
 362         if (!g_file_is_native (file)) {
 363                 g_warning ("Attempting to delete non native uri: %s\n", uri);
 364                 g_object_unref (file);
 365                 return;
 366         }
 367
 368         ev_tmp_file_unlink (file);
 369         g_object_unref (file);
 370 }
 371
 372 /**
 373  * ev_xfer_uri_simple:
 374  * @from: the source URI
 375  * @to: the target URI
 376  * @error: a #GError location to store an error, or %NULL
 377  *
 378  * Performs a g_file_copy() from @from to @to.
 379  *
 380  * Returns: %TRUE on success, or %FALSE on error with @error filled in
 381  */
 382 gboolean
 383 ev_xfer_uri_simple (const char *from,
 384                     const char *to,
 385                     GError     **error)
 386 {
 387         GFile *source_file;
 388         GFile *target_file;
 389         gboolean result;
 390
 391         if (!from)
 392                 return TRUE;
 393
 394         g_return_val_if_fail (to != NULL, TRUE);
 395
 396         source_file = g_file_new_for_uri (from);
 397         target_file = g_file_new_for_uri (to);
 398
 399         result = g_file_copy (source_file, target_file,
 400 #if GLIB_CHECK_VERSION(2,19,0)
 401                               G_FILE_COPY_TARGET_DEFAULT_PERMS |
 402 #endif
 403                               G_FILE_COPY_OVERWRITE,
 404                               NULL, NULL, NULL, error);
 405
 406         g_object_unref (target_file);
 407         g_object_unref (source_file);
 408
 409         return result;
 410 }
 411
 412 static gchar *
 413 get_mime_type_from_uri (const gchar *uri, GError **error)
 414 {
 415         GFile       *file;
 416         GFileInfo   *file_info;
 417         const gchar *content_type;
 418         gchar       *mime_type = NULL;
 419
 420         file = g_file_new_for_uri (uri);
 421         file_info = g_file_query_info (file,
 422                                        G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
 423                                        0, NULL, error);
 424         g_object_unref (file);
 425
 426         if (file_info == NULL)
 427                 return NULL;
 428
 429         content_type = g_file_info_get_content_type (file_info);
 430         if (content_type) {
 431                 mime_type = g_content_type_get_mime_type (content_type);
 432         }
 433
 434         g_object_unref (file_info);
 435         return mime_type;
 436 }
 437
 438 static gchar *
 439 get_mime_type_from_data (const gchar *uri, GError **error)
 440 {
 441 #ifndef G_OS_WIN32
 442         GFile            *file;
 443         GFileInputStream *input_stream;
 444         gssize            size_read;
 445         guchar            buffer[1024];
 446         gboolean          retval;
 447         gchar            *content_type, *mime_type;
 448
 449         file = g_file_new_for_uri (uri);
 450
 451         input_stream = g_file_read (file, NULL, error);
 452         if (!input_stream) {
 453                 g_object_unref (file);
 454                 return NULL;
 455         }
 456
 457         size_read = g_input_stream_read (G_INPUT_STREAM (input_stream),
 458                                          buffer, sizeof (buffer), NULL, error);
 459         if (size_read == -1) {
 460                 g_object_unref (input_stream);
 461                 g_object_unref (file);
 462                 return NULL;
 463         }
 464
 465         retval = g_input_stream_close (G_INPUT_STREAM (input_stream), NULL, error);
 466
 467         g_object_unref (input_stream);
 468         g_object_unref (file);
 469         if (!retval)
 470                 return NULL;
 471
 472         content_type = g_content_type_guess (NULL, /* no filename */
 473                                              buffer, size_read,
 474                                              NULL);
 475         if (!content_type)
 476                 return NULL;
 477
 478         mime_type = g_content_type_get_mime_type (content_type);
 479         g_free (content_type);
 480         return mime_type;
 481 #else
 482         /*
 483          * On Windows, the implementation of g_content_type_guess() is too limited at the moment, so we do not
 484          * use it and fall back to get_mime_type_from_uri()
 485          */
 486         return get_mime_type_from_uri (uri, error);
 487 #endif /* G_OS_WIN32 */
 488 }
 489
 490 /**
 491  * ev_file_get_mime_type:
 492  * @uri: the URI
 493  * @fast: whether to use fast MIME type detection
 494  * @error: a #GError location to store an error, or %NULL
 495  *
 496  * Note: on unknown MIME types, this may return NULL without @error
 497  * being filled in.
 498  *
 499  * Returns: a newly allocated string with the MIME type of the file at
 500  *   @uri, or %NULL on error or if the MIME type could not be determined
 501  */
 502 gchar *
 503 ev_file_get_mime_type (const gchar *uri,
 504                        gboolean     fast,
 505                        GError     **error)
 506 {
 507         return fast ? get_mime_type_from_uri (uri, error) : get_mime_type_from_data (uri, error);
 508 }
 509
 510 /* Compressed files support */
 511 #define BZIPCOMMAND "bzip2"
 512 #define GZIPCOMMAND "gzip"
 513 #define N_ARGS      4
 514 #define BUFFER_SIZE 1024
 515
 516 static gchar *
 517 compression_run (const gchar       *uri,
 518                  EvCompressionType  type,
 519                  gboolean           compress,
 520                  GError           **error)
 521 {
 522         gchar *argv[N_ARGS];
 523         gchar *uri_dst = NULL;
 524         gchar *filename, *filename_dst = NULL;
 525         gchar *cmd;
 526         gint   fd, pout;
 527         GError *err = NULL;
 528
 529         if (type == EV_COMPRESSION_NONE)
 530                 return NULL;
 531
 532         cmd = g_find_program_in_path ((type == EV_COMPRESSION_BZIP2) ? BZIPCOMMAND : GZIPCOMMAND);
 533         if (!cmd) {
 534                 /* FIXME: better error codes! */
 535                 /* FIXME: i18n later */
 536                 g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
 537                              "Failed to find the \"%s\" command in the search path.",
 538                              type == EV_COMPRESSION_BZIP2 ? BZIPCOMMAND : GZIPCOMMAND);
 539                 return NULL;
 540         }
 541
 542         filename = g_filename_from_uri (uri, NULL, error);
 543         if (!filename) {
 544                 g_free (cmd);
 545                 return NULL;
 546         }
 547
 548         fd = ev_mkstemp ("comp.XXXXXX", &filename_dst, error);
 549         if (fd == -1) {
 550                 g_free (cmd);
 551                 g_free (filename);
 552
 553                 return NULL;
 554         }
 555
 556         argv[0] = cmd;
 557         argv[1] = compress ? "-c" : "-cd";
 558         argv[2] = filename;
 559         argv[3] = NULL;
 560
 561         if (g_spawn_async_with_pipes (NULL, argv, NULL,
 562                                       G_SPAWN_STDERR_TO_DEV_NULL,
 563                                       NULL, NULL, NULL,
 564                                       NULL, &pout, NULL, &err)) {
 565                 GIOChannel *in, *out;
 566                 gchar buf[BUFFER_SIZE];
 567                 GIOStatus read_st, write_st;
 568                 gsize bytes_read, bytes_written;
 569
 570                 in = g_io_channel_unix_new (pout);
 571                 g_io_channel_set_encoding (in, NULL, NULL);
 572                 out = g_io_channel_unix_new (fd);
 573                 g_io_channel_set_encoding (out, NULL, NULL);
 574
 575                 do {
 576                         read_st = g_io_channel_read_chars (in, buf,
 577                                                            BUFFER_SIZE,
 578                                                            &bytes_read,
 579                                                            error);
 580                         if (read_st == G_IO_STATUS_NORMAL) {
 581                                 write_st = g_io_channel_write_chars (out, buf,
 582                                                                      bytes_read,
 583                                                                      &bytes_written,
 584                                                                      error);
 585                                 if (write_st == G_IO_STATUS_ERROR)
 586                                         break;
 587                         } else if (read_st == G_IO_STATUS_ERROR) {
 588                                 break;
 589                         }
 590                 } while (bytes_read > 0);
 591
 592                 g_io_channel_unref (in);
 593                 g_io_channel_unref (out);
 594         }
 595
 596         close (fd);
 597
 598         if (err) {
 599                 g_propagate_error (error, err);
 600         } else {
 601                 uri_dst = g_filename_to_uri (filename_dst, NULL, error);
 602         }
 603
 604         g_free (cmd);
 605         g_free (filename);
 606         g_free (filename_dst);
 607
 608         return uri_dst;
 609 }
 610
 611 /**
 612  * ev_file_uncompress:
 613  * @uri: a file URI
 614  * @type: the compression type
 615  * @error: a #GError location to store an error, or %NULL
 616  *
 617  * Uncompresses the file at @uri.
 618  *
 619  * If @type is %EV_COMPRESSION_NONE, it does nothing and returns %NULL.
 620  *
 621  * Otherwise, it returns the filename of a
 622  * temporary file containing the decompressed data from the file at @uri.
 623  * On error it returns %NULL and fills in @error.
 624  *
 625  * It is the caller's responsibility to unlink the temp file after use.
 626  *
 627  * Returns: a newly allocated string URI, or %NULL on error
 628  */
 629 gchar *
 630 ev_file_uncompress (const gchar       *uri,
 631                     EvCompressionType  type,
 632                     GError           **error)
 633 {
 634         g_return_val_if_fail (uri != NULL, NULL);
 635
 636         return compression_run (uri, type, FALSE, error);
 637 }
 638
 639 /**
 640  * ev_file_compress:
 641  * @uri: a file URI
 642  * @type: the compression type
 643  * @error: a #GError location to store an error, or %NULL
 644  *
 645  * Compresses the file at @uri.
 646
 647  * If @type is %EV_COMPRESSION_NONE, it does nothing and returns %NULL.
 648  *
 649  * Otherwise, it returns the filename of a
 650  * temporary file containing the compressed data from the file at @uri.
 651  *
 652  * On error it returns %NULL and fills in @error.
 653  *
 654  * It is the caller's responsibility to unlink the temp file after use.
 655  *
 656  * Returns: a newly allocated string URI, or %NULL on error
 657  */
 658 gchar *
 659 ev_file_compress (const gchar       *uri,
 660                   EvCompressionType  type,
 661                   GError           **error)
 662 {
 663         g_return_val_if_fail (uri != NULL, NULL);
 664
 665         return compression_run (uri, type, TRUE, error);
 666 }