src/viewer/datasource.c

   1 /*
   2    Internal file viewer for the Midnight Commander
   3    Functions for datasources
   4
   5    Copyright (C) 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003,
   6    2004, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
   7
   8    Written by: 1994, 1995, 1998 Miguel de Icaza
   9    1994, 1995 Janne Kukonlehto
  10    1995 Jakub Jelinek
  11    1996 Joseph M. Hinkle
  12    1997 Norbert Warmuth
  13    1998 Pavel Machek
  14    2004 Roland Illig <roland.illig@gmx.de>
  15    2005 Roland Illig <roland.illig@gmx.de>
  16    2009 Slava Zanko <slavazanko@google.com>
  17    2009 Andrew Borodin <aborodin@vmail.ru>
  18    2009 Ilia Maslakov <il.smind@gmail.com>
  19
  20    This file is part of the Midnight Commander.
  21
  22    The Midnight Commander is free software; you can redistribute it
  23    and/or modify it under the terms of the GNU General Public License as
  24    published by the Free Software Foundation; either version 2 of the
  25    License, or (at your option) any later version.
  26
  27    The Midnight Commander is distributed in the hope that it will be
  28    useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  29    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  30    General Public License for more details.
  31
  32    You should have received a copy of the GNU General Public License
  33    along with this program; if not, write to the Free Software
  34    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  35    MA 02110-1301, USA.
  36  */
  37
  38 /*
  39    The data source provides the viewer with data from either a file, a
  40    string or the output of a command. The mcview_get_byte() function can be
  41    used to get the value of a byte at a specific offset. If the offset
  42    is out of range, -1 is returned. The function mcview_get_byte_indexed(a,b)
  43    returns the byte at the offset a+b, or -1 if a+b is out of range.
  44
  45    The mcview_set_byte() function has the effect that later calls to
  46    mcview_get_byte() will return the specified byte for this offset. This
  47    function is designed only for use by the hexedit component after
  48    saving its changes. Inspect the source before you want to use it for
  49    other purposes.
  50
  51    The mcview_get_filesize() function returns the current size of the
  52    data source. If the growing buffer is used, this size may increase
  53    later on. Use the mcview_may_still_grow() function when you want to
  54    know if the size can change later.
  55  */
  56
  57 #include <config.h>
  58
  59 #include "lib/global.h"
  60 #include "lib/vfs/vfs.h"
  61 #include "lib/util.h"
  62 #include "lib/widget.h"         /* D_NORMAL, D_ERROR */
  63
  64 #include "internal.h"
  65
  66 /*** global variables ****************************************************************************/
  67
  68 /*** file scope macro definitions ****************************************************************/
  69
  70 /*** file scope type declarations ****************************************************************/
  71
  72 /*** file scope variables ************************************************************************/
  73
  74 /*** file scope functions ************************************************************************/
  75 /* --------------------------------------------------------------------------------------------- */
  76
  77 /* --------------------------------------------------------------------------------------------- */
  78 /*** public functions ****************************************************************************/
  79 /* --------------------------------------------------------------------------------------------- */
  80
  81 static void
  82 mcview_set_datasource_stdio_pipe (mcview_t * view, FILE * fp)
  83 {
  84     assert (fp != NULL);
  85     view->datasource = DS_STDIO_PIPE;
  86     view->ds_stdio_pipe = fp;
  87
  88     mcview_growbuf_init (view);
  89 }
  90
  91 /* --------------------------------------------------------------------------------------------- */
  92
  93 void
  94 mcview_set_datasource_none (mcview_t * view)
  95 {
  96     view->datasource = DS_NONE;
  97 }
  98
  99 /* --------------------------------------------------------------------------------------------- */
 100
 101 off_t
 102 mcview_get_filesize (mcview_t * view)
 103 {
 104     switch (view->datasource)
 105     {
 106     case DS_NONE:
 107         return 0;
 108     case DS_STDIO_PIPE:
 109     case DS_VFS_PIPE:
 110         return mcview_growbuf_filesize (view);
 111     case DS_FILE:
 112         return view->ds_file_filesize;
 113     case DS_STRING:
 114         return view->ds_string_len;
 115     default:
 116         assert (!"Unknown datasource type");
 117         return 0;
 118     }
 119 }
 120
 121 /* --------------------------------------------------------------------------------------------- */
 122
 123 void
 124 mcview_update_filesize (mcview_t * view)
 125 {
 126     if (view->datasource == DS_FILE)
 127     {
 128         struct stat st;
 129         if (mc_fstat (view->ds_file_fd, &st) != -1)
 130             view->ds_file_filesize = st.st_size;
 131     }
 132 }
 133
 134 /* --------------------------------------------------------------------------------------------- */
 135
 136 char *
 137 mcview_get_ptr_file (mcview_t * view, off_t byte_index)
 138 {
 139     assert (view->datasource == DS_FILE);
 140
 141     mcview_file_load_data (view, byte_index);
 142     if (mcview_already_loaded (view->ds_file_offset, byte_index, view->ds_file_datalen))
 143         return (char *) (view->ds_file_data + (byte_index - view->ds_file_offset));
 144     return NULL;
 145 }
 146
 147 /* --------------------------------------------------------------------------------------------- */
 148
 149 char *
 150 mcview_get_ptr_string (mcview_t * view, off_t byte_index)
 151 {
 152     assert (view->datasource == DS_STRING);
 153     if (byte_index < (off_t) view->ds_string_len)
 154         return (char *) (view->ds_string_data + byte_index);
 155     return NULL;
 156 }
 157
 158 /* --------------------------------------------------------------------------------------------- */
 159
 160 int
 161 mcview_get_utf (mcview_t * view, off_t byte_index, int *char_width, gboolean * result)
 162 {
 163     gchar *str = NULL;
 164     int res = -1;
 165     gunichar ch;
 166     gchar *next_ch = NULL;
 167
 168     *char_width = 0;
 169     *result = FALSE;
 170
 171     switch (view->datasource)
 172     {
 173     case DS_STDIO_PIPE:
 174     case DS_VFS_PIPE:
 175         str = mcview_get_ptr_growing_buffer (view, byte_index);
 176         break;
 177     case DS_FILE:
 178         str = mcview_get_ptr_file (view, byte_index);
 179         break;
 180     case DS_STRING:
 181         str = mcview_get_ptr_string (view, byte_index);
 182         break;
 183     case DS_NONE:
 184         break;
 185     }
 186
 187     if (str == NULL)
 188         return 0;
 189
 190     res = g_utf8_get_char_validated (str, -1);
 191
 192     if (res < 0)
 193     {
 194         ch = *str;
 195         *char_width = 1;
 196     }
 197     else
 198     {
 199         ch = res;
 200         /* Calculate UTF-8 char width */
 201         next_ch = g_utf8_next_char (str);
 202         if (next_ch)
 203             *char_width = next_ch - str;
 204         else
 205             return 0;
 206     }
 207     *result = TRUE;
 208     return ch;
 209 }
 210
 211 /* --------------------------------------------------------------------------------------------- */
 212
 213 gboolean
 214 mcview_get_byte_string (mcview_t * view, off_t byte_index, int *retval)
 215 {
 216     assert (view->datasource == DS_STRING);
 217     if (byte_index < (off_t) view->ds_string_len)
 218     {
 219         if (retval)
 220             *retval = view->ds_string_data[byte_index];
 221         return TRUE;
 222     }
 223     if (retval)
 224         *retval = -1;
 225     return FALSE;
 226 }
 227
 228 /* --------------------------------------------------------------------------------------------- */
 229
 230 gboolean
 231 mcview_get_byte_none (mcview_t * view, off_t byte_index, int *retval)
 232 {
 233     assert (view->datasource == DS_NONE);
 234     (void) &view;
 235     (void) byte_index;
 236     if (retval)
 237         *retval = -1;
 238     return FALSE;
 239 }
 240
 241 /* --------------------------------------------------------------------------------------------- */
 242
 243 void
 244 mcview_set_byte (mcview_t * view, off_t offset, byte b)
 245 {
 246     (void) &b;
 247     assert (offset < mcview_get_filesize (view));
 248     assert (view->datasource == DS_FILE);
 249     view->ds_file_datalen = 0;  /* just force reloading */
 250 }
 251
 252 /* --------------------------------------------------------------------------------------------- */
 253
 254 /*static */
 255 void
 256 mcview_file_load_data (mcview_t * view, off_t byte_index)
 257 {
 258     off_t blockoffset;
 259     ssize_t res;
 260     size_t bytes_read;
 261
 262     assert (view->datasource == DS_FILE);
 263
 264     if (mcview_already_loaded (view->ds_file_offset, byte_index, view->ds_file_datalen))
 265         return;
 266
 267     if (byte_index >= view->ds_file_filesize)
 268         return;
 269
 270     blockoffset = mcview_offset_rounddown (byte_index, view->ds_file_datasize);
 271     if (mc_lseek (view->ds_file_fd, blockoffset, SEEK_SET) == -1)
 272         goto error;
 273
 274     bytes_read = 0;
 275     while (bytes_read < view->ds_file_datasize)
 276     {
 277         res =
 278             mc_read (view->ds_file_fd, view->ds_file_data + bytes_read,
 279                      view->ds_file_datasize - bytes_read);
 280         if (res == -1)
 281             goto error;
 282         if (res == 0)
 283             break;
 284         bytes_read += (size_t) res;
 285     }
 286     view->ds_file_offset = blockoffset;
 287     if ((off_t) bytes_read > view->ds_file_filesize - view->ds_file_offset)
 288     {
 289         /* the file has grown in the meantime -- stick to the old size */
 290         view->ds_file_datalen = view->ds_file_filesize - view->ds_file_offset;
 291     }
 292     else
 293     {
 294         view->ds_file_datalen = bytes_read;
 295     }
 296     return;
 297
 298   error:
 299     view->ds_file_datalen = 0;
 300 }
 301
 302 /* --------------------------------------------------------------------------------------------- */
 303
 304 void
 305 mcview_close_datasource (mcview_t * view)
 306 {
 307     switch (view->datasource)
 308     {
 309     case DS_NONE:
 310         break;
 311     case DS_STDIO_PIPE:
 312         if (view->ds_stdio_pipe != NULL)
 313         {
 314             (void) pclose (view->ds_stdio_pipe);
 315             mcview_display (view);
 316             close_error_pipe (D_NORMAL, NULL);
 317             view->ds_stdio_pipe = NULL;
 318         }
 319         mcview_growbuf_free (view);
 320         break;
 321     case DS_VFS_PIPE:
 322         if (view->ds_vfs_pipe != -1)
 323         {
 324             (void) mc_close (view->ds_vfs_pipe);
 325             view->ds_vfs_pipe = -1;
 326         }
 327         mcview_growbuf_free (view);
 328         break;
 329     case DS_FILE:
 330         (void) mc_close (view->ds_file_fd);
 331         view->ds_file_fd = -1;
 332         g_free (view->ds_file_data);
 333         view->ds_file_data = NULL;
 334         break;
 335     case DS_STRING:
 336         g_free (view->ds_string_data);
 337         view->ds_string_data = NULL;
 338         break;
 339     default:
 340         assert (!"Unknown datasource type");
 341     }
 342     view->datasource = DS_NONE;
 343 }
 344
 345 /* --------------------------------------------------------------------------------------------- */
 346
 347 void
 348 mcview_set_datasource_file (mcview_t * view, int fd, const struct stat *st)
 349 {
 350     view->datasource = DS_FILE;
 351     view->ds_file_fd = fd;
 352     view->ds_file_filesize = st->st_size;
 353     view->ds_file_offset = 0;
 354     view->ds_file_data = g_malloc (4096);
 355     view->ds_file_datalen = 0;
 356     view->ds_file_datasize = 4096;
 357 }
 358
 359 /* --------------------------------------------------------------------------------------------- */
 360
 361 gboolean
 362 mcview_load_command_output (mcview_t * view, const char *command)
 363 {
 364     FILE *fp;
 365
 366     mcview_close_datasource (view);
 367
 368     open_error_pipe ();
 369     fp = popen (command, "r");
 370     if (fp == NULL)
 371     {
 372         /* Avoid two messages.  Message from stderr has priority.  */
 373         mcview_display (view);
 374         if (!close_error_pipe (mcview_is_in_panel (view) ? -1 : D_ERROR, NULL))
 375             mcview_show_error (view, _("Cannot spawn child process"));
 376         return FALSE;
 377     }
 378
 379     /* First, check if filter produced any output */
 380     mcview_set_datasource_stdio_pipe (view, fp);
 381     if (!mcview_get_byte (view, 0, NULL))
 382     {
 383         mcview_close_datasource (view);
 384
 385         /* Avoid two messages.  Message from stderr has priority.  */
 386         mcview_display (view);
 387         if (!close_error_pipe (mcview_is_in_panel (view) ? -1 : D_ERROR, NULL))
 388             mcview_show_error (view, _("Empty output from child filter"));
 389         return FALSE;
 390     }
 391     else
 392     {
 393         /*
 394          * At least something was read correctly. Close stderr and let
 395          * program die if it will try to write something there.
 396          *
 397          * Ideally stderr should be read asynchronously to prevent programs
 398          * from blocking (poll/select multiplexor).
 399          */
 400         close_error_pipe (D_NORMAL, NULL);
 401     }
 402     return TRUE;
 403 }
 404
 405 /* --------------------------------------------------------------------------------------------- */
 406
 407 void
 408 mcview_set_datasource_vfs_pipe (mcview_t * view, int fd)
 409 {
 410     assert (fd != -1);
 411     view->datasource = DS_VFS_PIPE;
 412     view->ds_vfs_pipe = fd;
 413
 414     mcview_growbuf_init (view);
 415 }
 416
 417 /* --------------------------------------------------------------------------------------------- */
 418
 419 void
 420 mcview_set_datasource_string (mcview_t * view, const char *s)
 421 {
 422     view->datasource = DS_STRING;
 423     view->ds_string_data = (byte *) g_strdup (s);
 424     view->ds_string_len = strlen (s);
 425 }
 426
 427 /* --------------------------------------------------------------------------------------------- */