src/viewer/datasource.c

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