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         GFile            *file;
 442         GFileInputStream *input_stream;
 443         gssize            size_read;
 444         guchar            buffer[1024];
 445         gboolean          retval;
 446         gchar            *content_type, *mime_type;
 447
 448         file = g_file_new_for_uri (uri);
 449
 450         input_stream = g_file_read (file, NULL, error);
 451         if (!input_stream) {
 452                 g_object_unref (file);
 453                 return NULL;
 454         }
 455
 456         size_read = g_input_stream_read (G_INPUT_STREAM (input_stream),
 457                                          buffer, sizeof (buffer), NULL, error);
 458         if (size_read == -1) {
 459                 g_object_unref (input_stream);
 460                 g_object_unref (file);
 461                 return NULL;
 462         }
 463
 464         retval = g_input_stream_close (G_INPUT_STREAM (input_stream), NULL, error);
 465
 466         g_object_unref (input_stream);
 467         g_object_unref (file);
 468         if (!retval)
 469                 return NULL;
 470
 471         content_type = g_content_type_guess (NULL, /* no filename */
 472                                              buffer, size_read,
 473                                              NULL);
 474         if (!content_type)
 475                 return NULL;
 476
 477         mime_type = g_content_type_get_mime_type (content_type);
 478         g_free (content_type);
 479         return mime_type;
 480 }
 481
 482 /**
 483  * ev_file_get_mime_type:
 484  * @uri: the URI
 485  * @fast: whether to use fast MIME type detection
 486  * @error: a #GError location to store an error, or %NULL
 487  *
 488  * Note: on unknown MIME types, this may return NULL without @error
 489  * being filled in.
 490  *
 491  * Returns: a newly allocated string with the MIME type of the file at
 492  *   @uri, or %NULL on error or if the MIME type could not be determined
 493  */
 494 gchar *
 495 ev_file_get_mime_type (const gchar *uri,
 496                        gboolean     fast,
 497                        GError     **error)
 498 {
 499         return fast ? get_mime_type_from_uri (uri, error) : get_mime_type_from_data (uri, error);
 500 }
 501
 502 /* Compressed files support */
 503 #define BZIPCOMMAND "bzip2"
 504 #define GZIPCOMMAND "gzip"
 505 #define N_ARGS      4
 506 #define BUFFER_SIZE 1024
 507
 508 static gchar *
 509 compression_run (const gchar       *uri,
 510                  EvCompressionType  type,
 511                  gboolean           compress,
 512                  GError           **error)
 513 {
 514         gchar *argv[N_ARGS];
 515         gchar *uri_dst = NULL;
 516         gchar *filename, *filename_dst = NULL;
 517         gchar *cmd;
 518         gint   fd, pout;
 519         GError *err = NULL;
 520
 521         if (type == EV_COMPRESSION_NONE)
 522                 return NULL;
 523
 524         cmd = g_find_program_in_path ((type == EV_COMPRESSION_BZIP2) ? BZIPCOMMAND : GZIPCOMMAND);
 525         if (!cmd) {
 526                 /* FIXME: better error codes! */
 527                 /* FIXME: i18n later */
 528                 g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
 529                              "Failed to find the \"%s\" command in the search path.",
 530                              type == EV_COMPRESSION_BZIP2 ? BZIPCOMMAND : GZIPCOMMAND);
 531                 return NULL;
 532         }
 533
 534         filename = g_filename_from_uri (uri, NULL, error);
 535         if (!filename) {
 536                 g_free (cmd);
 537                 return NULL;
 538         }
 539
 540         fd = ev_mkstemp ("comp.XXXXXX", &filename_dst, error);
 541         if (fd == -1) {
 542                 g_free (cmd);
 543                 g_free (filename);
 544
 545                 return NULL;
 546         }
 547
 548         argv[0] = cmd;
 549         argv[1] = compress ? "-c" : "-cd";
 550         argv[2] = filename;
 551         argv[3] = NULL;
 552
 553         if (g_spawn_async_with_pipes (NULL, argv, NULL,
 554                                       G_SPAWN_STDERR_TO_DEV_NULL,
 555                                       NULL, NULL, NULL,
 556                                       NULL, &pout, NULL, &err)) {
 557                 GIOChannel *in, *out;
 558                 gchar buf[BUFFER_SIZE];
 559                 GIOStatus read_st, write_st;
 560                 gsize bytes_read, bytes_written;
 561
 562                 in = g_io_channel_unix_new (pout);
 563                 g_io_channel_set_encoding (in, NULL, NULL);
 564                 out = g_io_channel_unix_new (fd);
 565                 g_io_channel_set_encoding (out, NULL, NULL);
 566
 567                 do {
 568                         read_st = g_io_channel_read_chars (in, buf,
 569                                                            BUFFER_SIZE,
 570                                                            &bytes_read,
 571                                                            error);
 572                         if (read_st == G_IO_STATUS_NORMAL) {
 573                                 write_st = g_io_channel_write_chars (out, buf,
 574                                                                      bytes_read,
 575                                                                      &bytes_written,
 576                                                                      error);
 577                                 if (write_st == G_IO_STATUS_ERROR)
 578                                         break;
 579                         } else if (read_st == G_IO_STATUS_ERROR) {
 580                                 break;
 581                         }
 582                 } while (bytes_read > 0);
 583
 584                 g_io_channel_unref (in);
 585                 g_io_channel_unref (out);
 586         }
 587
 588         close (fd);
 589
 590         if (err) {
 591                 g_propagate_error (error, err);
 592         } else {
 593                 uri_dst = g_filename_to_uri (filename_dst, NULL, error);
 594         }
 595
 596         g_free (cmd);
 597         g_free (filename);
 598         g_free (filename_dst);
 599
 600         return uri_dst;
 601 }
 602
 603 /**
 604  * ev_file_uncompress:
 605  * @uri: a file URI
 606  * @type: the compression type
 607  * @error: a #GError location to store an error, or %NULL
 608  *
 609  * Uncompresses the file at @uri.
 610  *
 611  * If @type is %EV_COMPRESSION_NONE, it does nothing and returns %NULL.
 612  *
 613  * Otherwise, it returns the filename of a
 614  * temporary file containing the decompressed data from the file at @uri.
 615  * On error it returns %NULL and fills in @error.
 616  *
 617  * It is the caller's responsibility to unlink the temp file after use.
 618  *
 619  * Returns: a newly allocated string URI, or %NULL on error
 620  */
 621 gchar *
 622 ev_file_uncompress (const gchar       *uri,
 623                     EvCompressionType  type,
 624                     GError           **error)
 625 {
 626         g_return_val_if_fail (uri != NULL, NULL);
 627
 628         return compression_run (uri, type, FALSE, error);
 629 }
 630
 631 /**
 632  * ev_file_compress:
 633  * @uri: a file URI
 634  * @type: the compression type
 635  * @error: a #GError location to store an error, or %NULL
 636  *
 637  * Compresses the file at @uri.
 638
 639  * If @type is %EV_COMPRESSION_NONE, it does nothing and returns %NULL.
 640  *
 641  * Otherwise, it returns the filename of a
 642  * temporary file containing the compressed data from the file at @uri.
 643  *
 644  * On error it returns %NULL and fills in @error.
 645  *
 646  * It is the caller's responsibility to unlink the temp file after use.
 647  *
 648  * Returns: a newly allocated string URI, or %NULL on error
 649  */
 650 gchar *
 651 ev_file_compress (const gchar       *uri,
 652                   EvCompressionType  type,
 653                   GError           **error)
 654 {
 655         g_return_val_if_fail (uri != NULL, NULL);
 656
 657         return compression_run (uri, type, TRUE, error);
 658 }