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 "src/wtools.h"
  61 #include "lib/vfs/mc-vfs/vfs.h"
  62
  63 #include "internal.h"
  64
  65 /*** global variables ****************************************************************************/
  66
  67 /*** file scope macro definitions ****************************************************************/
  68
  69 /*** file scope type declarations ****************************************************************/
  70
  71 /*** file scope variables ************************************************************************/
  72
  73 /*** file scope functions ************************************************************************/
  74
  75 /*** public functions ****************************************************************************/
  76
  77 /* --------------------------------------------------------------------------------------------- */
  78
  79 static void
  80 mcview_set_datasource_stdio_pipe (mcview_t * view, FILE * fp)
  81 {
  82     assert (fp != NULL);
  83     view->datasource = DS_STDIO_PIPE;
  84     view->ds_stdio_pipe = fp;
  85
  86     mcview_growbuf_init (view);
  87 }
  88
  89 /* --------------------------------------------------------------------------------------------- */
  90
  91 void
  92 mcview_set_datasource_none (mcview_t * view)
  93 {
  94     view->datasource = DS_NONE;
  95 }
  96
  97 /* --------------------------------------------------------------------------------------------- */
  98
  99 off_t
 100 mcview_get_filesize (mcview_t * view)
 101 {
 102     switch (view->datasource)
 103     {
 104     case DS_NONE:
 105         return 0;
 106     case DS_STDIO_PIPE:
 107     case DS_VFS_PIPE:
 108         return mcview_growbuf_filesize (view);
 109     case DS_FILE:
 110         return view->ds_file_filesize;
 111     case DS_STRING:
 112         return view->ds_string_len;
 113     default:
 114         assert (!"Unknown datasource type");
 115         return 0;
 116     }
 117 }
 118
 119 /* --------------------------------------------------------------------------------------------- */
 120
 121 void
 122 mcview_update_filesize (mcview_t * view)
 123 {
 124     if (view->datasource == DS_FILE)
 125     {
 126         struct stat st;
 127         if (mc_fstat (view->ds_file_fd, &st) != -1)
 128             view->ds_file_filesize = st.st_size;
 129     }
 130 }
 131
 132 /* --------------------------------------------------------------------------------------------- */
 133
 134 char *
 135 mcview_get_ptr_file (mcview_t * view, off_t byte_index)
 136 {
 137     assert (view->datasource == DS_FILE);
 138
 139     mcview_file_load_data (view, byte_index);
 140     if (mcview_already_loaded (view->ds_file_offset, byte_index, view->ds_file_datalen))
 141         return (char *) (view->ds_file_data + (byte_index - view->ds_file_offset));
 142     return NULL;
 143 }
 144
 145 /* --------------------------------------------------------------------------------------------- */
 146
 147 char *
 148 mcview_get_ptr_string (mcview_t * view, off_t byte_index)
 149 {
 150     assert (view->datasource == DS_STRING);
 151     if (byte_index < (off_t) view->ds_string_len)
 152         return (char *) (view->ds_string_data + byte_index);
 153     return NULL;
 154 }
 155
 156 /* --------------------------------------------------------------------------------------------- */
 157
 158 int
 159 mcview_get_utf (mcview_t * view, off_t byte_index, int *char_width, gboolean * result)
 160 {
 161     gchar *str = NULL;
 162     int res = -1;
 163     gunichar ch;
 164     gchar *next_ch = NULL;
 165     int width = 0;
 166
 167     *result = TRUE;
 168
 169     switch (view->datasource)
 170     {
 171     case DS_STDIO_PIPE:
 172     case DS_VFS_PIPE:
 173         str = mcview_get_ptr_growing_buffer (view, byte_index);
 174         break;
 175     case DS_FILE:
 176         str = mcview_get_ptr_file (view, byte_index);
 177         break;
 178     case DS_STRING:
 179         str = mcview_get_ptr_string (view, byte_index);
 180         break;
 181     case DS_NONE:
 182         break;
 183     }
 184
 185     if (str == NULL)
 186     {
 187         *result = FALSE;
 188         width = 0;
 189         return 0;
 190     }
 191
 192     res = g_utf8_get_char_validated (str, -1);
 193
 194     if (res < 0)
 195     {
 196         ch = *str;
 197         width = 0;
 198     }
 199     else
 200     {
 201         ch = res;
 202         /* Calculate UTF-8 char width */
 203         next_ch = g_utf8_next_char (str);
 204         if (next_ch)
 205         {
 206             width = next_ch - str;
 207         }
 208         else
 209         {
 210             ch = 0;
 211             width = 0;
 212         }
 213     }
 214     *char_width = width;
 215     return ch;
 216 }
 217
 218 /* --------------------------------------------------------------------------------------------- */
 219
 220 gboolean
 221 mcview_get_byte_string (mcview_t * view, off_t byte_index, int *retval)
 222 {
 223     assert (view->datasource == DS_STRING);
 224     if (byte_index < (off_t) view->ds_string_len)
 225     {
 226         if (retval)
 227             *retval = view->ds_string_data[byte_index];
 228         return TRUE;
 229     }
 230     if (retval)
 231         *retval = -1;
 232     return FALSE;
 233 }
 234
 235 /* --------------------------------------------------------------------------------------------- */
 236
 237 gboolean
 238 mcview_get_byte_none (mcview_t * view, off_t byte_index, int *retval)
 239 {
 240     assert (view->datasource == DS_NONE);
 241     (void) &view;
 242     (void) byte_index;
 243     if (retval)
 244         *retval = -1;
 245     return FALSE;
 246 }
 247
 248 /* --------------------------------------------------------------------------------------------- */
 249
 250 void
 251 mcview_set_byte (mcview_t * view, off_t offset, byte b)
 252 {
 253     (void) &b;
 254     assert (offset < mcview_get_filesize (view));
 255     assert (view->datasource == DS_FILE);
 256     view->ds_file_datalen = 0;  /* just force reloading */
 257 }
 258
 259 /* --------------------------------------------------------------------------------------------- */
 260
 261 /*static */
 262 void
 263 mcview_file_load_data (mcview_t * view, off_t byte_index)
 264 {
 265     off_t blockoffset;
 266     ssize_t res;
 267     size_t bytes_read;
 268
 269     assert (view->datasource == DS_FILE);
 270
 271     if (mcview_already_loaded (view->ds_file_offset, byte_index, view->ds_file_datalen))
 272         return;
 273
 274     if (byte_index >= view->ds_file_filesize)
 275         return;
 276
 277     blockoffset = mcview_offset_rounddown (byte_index, view->ds_file_datasize);
 278     if (mc_lseek (view->ds_file_fd, blockoffset, SEEK_SET) == -1)
 279         goto error;
 280
 281     bytes_read = 0;
 282     while (bytes_read < view->ds_file_datasize)
 283     {
 284         res =
 285             mc_read (view->ds_file_fd, view->ds_file_data + bytes_read,
 286                      view->ds_file_datasize - bytes_read);
 287         if (res == -1)
 288             goto error;
 289         if (res == 0)
 290             break;
 291         bytes_read += (size_t) res;
 292     }
 293     view->ds_file_offset = blockoffset;
 294     if ((off_t) bytes_read > view->ds_file_filesize - view->ds_file_offset)
 295     {
 296         /* the file has grown in the meantime -- stick to the old size */
 297         view->ds_file_datalen = view->ds_file_filesize - view->ds_file_offset;
 298     }
 299     else
 300     {
 301         view->ds_file_datalen = bytes_read;
 302     }
 303     return;
 304
 305   error:
 306     view->ds_file_datalen = 0;
 307 }
 308
 309 /* --------------------------------------------------------------------------------------------- */
 310
 311 void
 312 mcview_close_datasource (mcview_t * view)
 313 {
 314     switch (view->datasource)
 315     {
 316     case DS_NONE:
 317         break;
 318     case DS_STDIO_PIPE:
 319         if (view->ds_stdio_pipe != NULL)
 320         {
 321             (void) pclose (view->ds_stdio_pipe);
 322             mcview_display (view);
 323             close_error_pipe (D_NORMAL, NULL);
 324             view->ds_stdio_pipe = NULL;
 325         }
 326         mcview_growbuf_free (view);
 327         break;
 328     case DS_VFS_PIPE:
 329         if (view->ds_vfs_pipe != -1)
 330         {
 331             (void) mc_close (view->ds_vfs_pipe);
 332             view->ds_vfs_pipe = -1;
 333         }
 334         mcview_growbuf_free (view);
 335         break;
 336     case DS_FILE:
 337         (void) mc_close (view->ds_file_fd);
 338         view->ds_file_fd = -1;
 339         g_free (view->ds_file_data);
 340         view->ds_file_data = NULL;
 341         break;
 342     case DS_STRING:
 343         g_free (view->ds_string_data);
 344         view->ds_string_data = NULL;
 345         break;
 346     default:
 347         assert (!"Unknown datasource type");
 348     }
 349     view->datasource = DS_NONE;
 350 }
 351
 352 /* --------------------------------------------------------------------------------------------- */
 353
 354 void
 355 mcview_set_datasource_file (mcview_t * view, int fd, const struct stat *st)
 356 {
 357     view->datasource = DS_FILE;
 358     view->ds_file_fd = fd;
 359     view->ds_file_filesize = st->st_size;
 360     view->ds_file_offset = 0;
 361     view->ds_file_data = g_malloc (4096);
 362     view->ds_file_datalen = 0;
 363     view->ds_file_datasize = 4096;
 364 }
 365
 366 /* --------------------------------------------------------------------------------------------- */
 367
 368 gboolean
 369 mcview_load_command_output (mcview_t * view, const char *command)
 370 {
 371     FILE *fp;
 372
 373     mcview_close_datasource (view);
 374
 375     open_error_pipe ();
 376     if ((fp = popen (command, "r")) == NULL)
 377     {
 378         /* Avoid two messages.  Message from stderr has priority.  */
 379         mcview_display (view);
 380         if (!close_error_pipe (mcview_is_in_panel (view) ? -1 : D_ERROR, NULL))
 381             mcview_show_error (view, _(" Cannot spawn child process "));
 382         return FALSE;
 383     }
 384
 385     /* First, check if filter produced any output */
 386     mcview_set_datasource_stdio_pipe (view, fp);
 387     if (!mcview_get_byte (view, 0, NULL))
 388     {
 389         mcview_close_datasource (view);
 390
 391         /* Avoid two messages.  Message from stderr has priority.  */
 392         mcview_display (view);
 393         if (!close_error_pipe (mcview_is_in_panel (view) ? -1 : D_ERROR, NULL))
 394             mcview_show_error (view, _("Empty output from child filter"));
 395         return FALSE;
 396     }
 397     else
 398     {
 399         /*
 400          * At least something was read correctly. Close stderr and let
 401          * program die if it will try to write something there.
 402          *
 403          * Ideally stderr should be read asynchronously to prevent programs
 404          * from blocking (poll/select multiplexor).
 405          */
 406         close_error_pipe (D_NORMAL, NULL);
 407     }
 408     return TRUE;
 409 }
 410
 411 /* --------------------------------------------------------------------------------------------- */
 412
 413 void
 414 mcview_set_datasource_vfs_pipe (mcview_t * view, int fd)
 415 {
 416     assert (fd != -1);
 417     view->datasource = DS_VFS_PIPE;
 418     view->ds_vfs_pipe = fd;
 419
 420     mcview_growbuf_init (view);
 421 }
 422
 423 /* --------------------------------------------------------------------------------------------- */
 424
 425 void
 426 mcview_set_datasource_string (mcview_t * view, const char *s)
 427 {
 428     view->datasource = DS_STRING;
 429     view->ds_string_data = (byte *) g_strdup (s);
 430     view->ds_string_len = strlen (s);
 431 }
 432
 433 /* --------------------------------------------------------------------------------------------- */