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