hexview.c

/*****************************************************//**
 * @brief   Prmitive hexadecimal file viewer (pipe it to 'less' or 'more'
 *      to make it much less primitive... see Usage below).
 * @file    hexview.c
 * @version 0.261A
 * @date    29 Feb, 2012
 * @author  migf1 <mig_f1@hotmail.com>
 * @par Language:
 *      C (ANSI C99)
 * @par Usage:
 *      hexview [-raw] [filename]
 *      \n
 *      Use -raw as the 1st command-line argument to force raw output
 *      (useful for piping, e.g: hexview -raw file | less)
 *
 * @remark  Feel free to experiment with the values of the pre-processor
 *      constants: FMT_NCOLS, FMT_PGLINES and FMT_POS. They affect the
 *      appearance of the output.
 *********************************************************
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdbool.h>

#include "con_color.h"
#include "hexview.h"

typedef unsigned char Byte;

typedef struct Buffer {
    char    fname[ MAXINPUT ];  /* name of the file to be viewed      */
    size_t  len, nrows, npages; /* total Bytes, rows and pages        */
//  size_t  bt, row, pg;        /* current byte, row & page indicies  */
    Byte    *data;          /* the actual data buffer             */
} Buffer;

typedef struct Settings {
    _Bool colorize;
    unsigned short int charset;
    _Bool israw;
    _Bool unlimfsize;
} Settings;

enum KeyCommand {
    KEY_HLP     = 'h',
    KEY_QUIT    = 'q',
    KEY_COLOR   = 'c',
    KEY_CHARSET = 't',
    KEY_LOADFILE    = 'f',
    KEY_TOP     = '{',
    KEY_BOT     = '}',
    KEY_PGUP    = '[',
    KEY_PGDN    = ']',
    KEY_ROWUP   = ',',
    KEY_ROWDN   = '.',
    KEY_ROWSTA  = '(',
    KEY_ROWEND  = ')',
    KEY_BYTEB   = '<',
    KEY_BYTEF   = '>',
    KEY_GPAGE   = 'p',
    KEY_GROW    = 'r',
    KEY_GBYTE   = 'b',
    KEY_FNDSTR  = '/',
    KEY_RFNDSTR = '\\',
    KEY_FNDSEQ  = ';',
    KEY_RFNDSEQ = ':',
};

void    buffer_cleanup( Buffer *buffer );
_Bool   buffer_read_file_longmax( Buffer *buffer, const char *fname );
_Bool   buffer_read_file( Buffer *buf, const char *fname, size_t chunklen );


/*********************************************************//**
 * Return the size of a byte in bits
 *************************************************************
 */
size_t bin_bitcount( Byte byte )
{
    return 8U * sizeof(byte);
}

/*********************************************************//**
 * Return a bitstring from a given (decimal) byte.
 *************************************************************
 */
char *bin_byte2bitstring( Byte byte )
{
    int len     = bin_bitcount( byte );
    char *bitstring = calloc( len + 1, sizeof(char) );
    if ( !bitstring )
        return NULL;

    memset(bitstring, '0', len--);
    while ( byte && len > -1) {
        bitstring[len--] = (byte & 1) ? '1' : '0';
        byte >>= 1;
    }

    return bitstring;
}

/*********************************************************//**
 * Read a c-string from stdin.
 *************************************************************
 */
char *s_read( char *s, size_t maxlen )
{
    size_t len = 0U;

    if ( !s || !fgets( s, maxlen, stdin) )
        return NULL;

    if ( maxlen > MAXINPUT)
        maxlen = MAXINPUT;

    if ( s[ (len=strlen(s))-1 ] == '\n')
        s[ len-1 ] = '\0';

    return s;
}

/*********************************************************//**
 * 
 *************************************************************
 */
_Bool fileexists(const char *fname)
{
    FILE *fp = fopen(fname, "rb");
    if ( !fp )
        return false;

    fclose(fp);
    return true;
}

/*********************************************************//**
 * Return the size of a file in bytes, or -1 on error (cannot be more than LONG_MAX).
 *************************************************************
 */
long int filesize(const char *fname)
{
    long int size;
    FILE     *fp;

    if ( NULL == (fp = fopen(fname, "rb")) )    /* binary mode */
        return -1;

    if( fseek(fp, 0, SEEK_END) ) {
        fclose(fp);
        return -1;
    }

    size = ftell(fp);
    fclose(fp);

    return size;
}

/*********************************************************//**
 * Display help screen.
 *************************************************************
 */
void show_help( const _Bool colorize )
{
    CLS();

    colorPRINTF( colorize, FGCLR_EM1, BG_NOCHANGE, "%52s\n\n", NAME_VERSION ); 

#if DISABLED    // ==============================================
    /* list of command line arguments */

    colorPRINTF( colorize, FGCLR_EM1, BG_NOCHANGE, "Command Line Arguments\n\n" );

    puts( "-raw \t\t Force raw output (useful for piping)" );

    puts( "\0" );
#endif      // ==============================================

    /* list of available commands */

    colorPRINTF( colorize, FGCLR_EM1, BG_NOCHANGE, "Available Commands\n" ); 

    puts( "Commands are NOT case-sensitive but require you to press ENTER at the end.\n" );
    printf( "%c \t\t This help screen\n",           KEY_HLP );
    printf( "%c \t\t Quit the program\n",           KEY_QUIT );
    puts( "ENTER \t\t Repeat last command" );
    printf( "%cfilename\t Load a new file (leave NO blanks between %c and filename)\n",
        KEY_LOADFILE, KEY_LOADFILE
    );
    printf( "%c \t\t Toggle colorization (on/off)\n",   KEY_COLOR );
    printf( "%c\t\t Toggle ASCII character set (plain/extended)\n", KEY_CHARSET);

    putchar('\n');

    printf( "%c or %c \t\t Start or end of file\n",     KEY_TOP, KEY_BOT );
    printf( "%c or %c \t\t Start or end of row (line)\n",   KEY_ROWSTA, KEY_ROWEND);
    printf( "%c or %c n\t Move n bytes back or forward (1 is assumed if no n is present)\n",
        KEY_BYTEB, KEY_BYTEF
    );
    printf( "%c or %c n\t Move n rows  up or down (1 is assumed if no n is present)\n",
        KEY_ROWUP, KEY_ROWDN
    );
    printf( "%c or %c n\t Move n pages up or down (1 is assumed if no n is present)\n",
        KEY_PGUP, KEY_PGDN );
    printf( "%c n \t\t Goto n'th byte (0xn for hex, 0n for oct)\n", KEY_GBYTE);
    printf( "%c n \t\t Goto n'th row  (0xn for hex, 0n for oct)\n", KEY_GROW );
    printf( "%c n \t\t Goto n'th page\n", KEY_GPAGE);

    putchar('\n');

    printf( "%c or %c string\t Search ahead or backwards for a text-string (case sensitive)\n",
        KEY_FNDSTR, KEY_RFNDSTR
    );
    printf( "%c or %c sequence\t Search ahead or backwards for a byte-sequence\n",
        KEY_FNDSEQ, KEY_RFNDSEQ
    );

    putchar('\n');
    pressENTER();

    return;
}

/*********************************************************//**
 * Display text labels and other info on the currently displayed page.
 *************************************************************
 */
void show_header( const size_t btcurr, const Buffer *buffer, const Settings *settings )
{
    unsigned short int i;

    if ( !buffer || !buffer->data )
        return;

    CLS();

    /* text label for file-offset */
    colorPRINTF(
        settings->colorize, FGCLR_ROWOFST, BG_NOCHANGE,
        " %-*s ", FMT_OFST,"OFFSET"
    );

    /* hex indicies for Bytes */
    for (i=0; i < FMT_NCOLS; i++)
    {
        char *fmt = (btcurr % FMT_NCOLS == i) ? "%-1hX* " : "%-2hX ";

        if ( i != 0 && i % FMT_GRPCOLS == 0 )       /* group columns      */
            putchar(' ');

        if ( btcurr % FMT_NCOLS == i )
            colorPRINTF(settings->colorize,FGCLR_BYTCURR,BG_NOCHANGE, fmt,i);
        else
            colorPRINTF(settings->colorize,FGCLR_ROWOFST,BG_NOCHANGE, fmt,i);
    }

    /* hex indicies for Characters */
    putchar(' ');
    for (i=0; i < FMT_NCOLS; i++)
    {
        if ( btcurr % FMT_NCOLS == i )
            colorPRINTF(
                settings->colorize, FGCLR_BYTCURR, BG_NOCHANGE, "%hX", i
            );
        else
            colorPRINTF(
                settings->colorize, FGCLR_ROWOFST,BG_NOCHANGE,
                "%hX", i
            );
    }
    putchar('\n');

    /* separating lines */

    putchar(' ');
    for (i=0; i < FMT_OFST + 1; i++)
        colorPRINTF( settings->colorize, FGCLR_ROWOFST, BG_NOCHANGE, "-" );

    for (i=0; i < FMT_NCOLS; i++)
    {
        if (i != 0 && i % FMT_GRPCOLS == 0 )        /* group separation   */
            colorPRINTF(settings->colorize, FGCLR_ROWOFST,BG_NOCHANGE, "-");

        colorPRINTF(
            settings->colorize, FGCLR_ROWOFST, BG_NOCHANGE,
            (btcurr % FMT_NCOLS == i) ? "..-" : "---"
        );
    }
    putchar('\b');
    printf("  ");
    for (i=0; i < FMT_NCOLS; i++)
    {
        colorPRINTF(
            settings->colorize, FGCLR_ROWOFST, BG_NOCHANGE,
            (btcurr % FMT_NCOLS == i) ? "." : "-"
        );
    }

    putchar('\n');

    return;
}

/*********************************************************//**
 * Display the prompt (it conists of 2 lines).
 *************************************************************
 */
_Bool show_prompt(
    const size_t    bt,
    char        *cmd,
    const char  *prevcmd,
    const Buffer    *buffer,
    const Settings  *settings
)
{
    size_t row = 0U, slen = 0U;
    char *cp = NULL, *bitstr = NULL;

    if ( !cmd || !prevcmd || !buffer || !settings || !buffer->data)
        return false;

    /* -----------------------
     * display 1st prompt line
     */

    /* filename (display FNAME_SHOWLEN last chars, if longer) */
    slen = strlen( buffer->fname );
    if ( slen > FNAME_SHOWLEN )
        cp = (char *) &buffer->fname[ slen-FNAME_SHOWLEN ];
    else
        cp = (char *) &buffer->fname;
    colorPRINTF(
        settings->colorize,
        FGCLR_PMTFNAME,
        BGCLR_PMTFNAME,
        " %s%s ",
        cp != buffer->fname ? "..." : "\0",
        cp
    );

    putchar(':');

    /* filesize (in Mbytes) */
    colorPRINTF(
        settings->colorize, FGCLR_PMTFNAME, BGCLR_PMTFNAME,
        " %.3f Mb :", ( (buffer->len * sizeof(Byte)) / (1024.0 * 1024) )
    );

    /* filesize in viewer-rows */
    colorPRINTF(
        settings->colorize, FGCLR_PMTFNAME, BGCLR_PMTFNAME,
        " %llu rows ", (unsigned long long) (buffer->nrows)
    );

    row = BT2ROW(bt, buffer->len, buffer->nrows);   /* calc the row index for bt */

    putchar('|');

    /* filesize in viewer-pages */
    colorPRINTF(
        settings->colorize, FGCLR_PMTPG, BGCLR_PMTPG,
        " Pg:%llu/%llu ",
        (unsigned long long) (1 + ROW2PG(row, buffer->nrows)),
        (unsigned long long) (buffer->npages)
    );

    putchar('|');

    /* selected character set */
    colorPRINTF(
        settings->colorize, FGCLR_PMTCHRSET, BGCLR_PMTCHRSET,
        " %s ", NAME_CHARSET(settings->charset)
    );
    puts("\0");

    /* -----------------------
     * display 2nd prompt line
     */

    /* current byte position */
    colorPRINTF(
        settings->colorize, FGCLR_PMTBYTPOS, BGCLR_PMTBYTPOS,
        " %llu=%llx/%llX ",
        (unsigned long long) bt,
        (unsigned long long) bt,
        (unsigned long long) buffer->len - 1
    );
    /* current row position */
    colorPRINTF(
        settings->colorize, FGCLR_PMTROWPOS, BGCLR_PMTROWPOS,
        "[%llx] ",
        (unsigned long long) row
    );

    putchar('|');
    /* decimal values of current byte (unsigned & signed) */
    colorPRINTF(
        settings->colorize, FGCLR_PMTDEC, BGCLR_PMTDEC,
        " d:%hhu %hhd ",
        buffer->data[bt],
        buffer->data[bt] > 127 ? buffer->data[bt] - 256 : buffer->data[bt]
    );

    putchar('|');
    /* octal value of current byte */
    colorPRINTF(
        settings->colorize, FGCLR_PMTOCT, BGCLR_PMTOCT,
        " o:%hho ",
        buffer->data[bt]
    );

    putchar('|');
    /* binary value of current byte */
    colorPRINTF(
        settings->colorize, FGCLR_PMTBIN, BGCLR_PMTBIN,
        " %s ",
        (bitstr = bin_byte2bitstring( buffer->data[bt] )) ? bitstr : "error"
    );
    if ( bitstr )
        free(bitstr);

    putchar('|');

    /* previous command */
    colorPRINTF(settings->colorize, FGCLR_PMTPRVCMD, BGCLR_PMTPRVCMD, " %s ", prevcmd );

    /* user prompt */
    colorPRINTF(settings->colorize, FGCLR_EM1, BG_NOCHANGE, ": ");

    fflush( stdout );

    /* read the user command */
    if ( !fgets( cmd, MAXINPUT, stdin ) )
        return false;

    /* if not just an ENTER, remove '\n' from the end */
    slen = strlen(cmd);
    if ( '\n' != *cmd && '\n' == cmd[ slen-1 ] )
        cmd[ slen-1 ] = '\0';

    return true;
}

/*********************************************************//**
 * List the contents of a row in hex/char format.
 *************************************************************
 */
_Bool view_row(
    const size_t    row,
    const size_t    btcurr,
    const Buffer    *buffer,
    const Settings  *settings
)
{
    char clead;                 /* leading displayed char     */
    size_t i;
    const size_t row2idx = row * FMT_NCOLS;

    if ( !buffer || !buffer->data || row2idx > buffer->len )
        return false;

    /* display row offset */
    clead   = row == btcurr / FMT_NCOLS ? '*' : ' ';
    if ( row == btcurr / FMT_NCOLS )
        colorPRINTF(
            settings->colorize, FGCLR_BYTCURR, BG_NOCHANGE,
            "%c%0*lX ", clead, FMT_OFST,(long unsigned)row2idx
        );
    else
        colorPRINTF(
            settings->colorize, FGCLR_ROWOFST, BG_NOCHANGE,
            "%c%0*lX ", clead, FMT_OFST,(long unsigned)row2idx
        );

    /* display row's contents as bytes */
    for (i=0; i < FMT_NCOLS && row2idx + i < buffer->len; i++)
    {
        Byte byte = buffer->data[row2idx + i];
        const _Bool isPrintable = (settings->charset == FMT_ASCII)
                    ? isprint((int)byte)
                    : byte > 31;

        if ( i != 0 && i % FMT_GRPCOLS == 0 )       /* group columns      */
            putchar(' ');

        if ( isPrintable )              /* printable byte */
        {
            if ( btcurr != row2idx + i )
                colorPRINTF(
                    settings->colorize, FGCLR_BYTPRT1, BG_NOCHANGE,
                    "%02hX ", byte );
            else
                colorPRINTF(
                    settings->colorize, FGCLR_BYTCURR, BG_NOCHANGE,
                    "%02hX ", byte );
        }
        else if ( byte == 0 )               /* zeroed byte        */
        {
            if ( btcurr != row2idx + i )
                colorPRINTF(
                    settings->colorize, FGCLR_BYTZERO, BG_NOCHANGE,
                    "%02hX ", byte );
            else
                colorPRINTF(
                    settings->colorize, FGCLR_BYTCURR, BG_NOCHANGE,
                    "%02hX ", byte );
        }
        else                        /* non-printable byte */
        {
            if ( btcurr != row2idx + i )
                colorPRINTF(
                    settings->colorize, FGCLR_BYTPRT0, BG_NOCHANGE,
                    "%02hX ", byte );
            else
                colorPRINTF(
                    settings->colorize, FGCLR_BYTCURR, BG_NOCHANGE,
                    "%02hX ", byte );
        }
    }
    for (; i < FMT_NCOLS; i++)
        printf("   ");
    putchar(' ');

    /* display row's contents as ASCII chars */
    for (i=0; i < FMT_NCOLS && row2idx + i < buffer->len; i++)
    {
        int c = (int)buffer->data[row2idx + i];
        const _Bool isPrintable = (settings->charset == FMT_ASCII)
                    ? isprint(c)
                    : (c>31);

        if ( isPrintable )              /* printable byte     */
        {
            if ( btcurr != row2idx + i )
                colorPRINTF(
                    settings->colorize, FGCLR_BYTPRT1, BG_NOCHANGE,
                    "%c", c );
            else
                colorPRINTF(
                    settings->colorize, FGCLR_BYTCURR, BG_NOCHANGE,
                    "%c", c );
        }
        else if ( c == '\0' )               /* zero-byte char     */
        {
            if ( btcurr != row2idx + i )
                colorPRINTF(
                    settings->colorize, FGCLR_BYTZERO, BG_NOCHANGE, "." );
            else
                colorPRINTF(
                    settings->colorize, FGCLR_BYTCURR, BG_NOCHANGE,
                    "." );
        }
        else                        /* non-printable char */
        {
            if ( btcurr != row2idx + i )
                colorPRINTF(
                    settings->colorize, FGCLR_BYTPRT0, BG_NOCHANGE, "." );
            else
                colorPRINTF(
                    settings->colorize, FGCLR_BYTCURR, BG_NOCHANGE, "." );
        }
    }
    for (; i < FMT_NCOLS; i++)
        putchar(' ');
    putchar('\n');


    return true;
}

/*********************************************************//**
 *
 *************************************************************
 */
_Bool view_screen( const size_t btcurr, const Buffer *buffer, const Settings *settings )
{
    size_t i, rowstart;             /* for parsing rows */

    if ( !buffer || !buffer->data )
        return false;

    rowstart = BT2ROW(btcurr, buffer->len, buffer->nrows);

    for (i=0; i < FMT_PGLINES && (i+rowstart) < buffer->nrows; i++)
        view_row( (i+rowstart), btcurr, buffer, settings );

    /* if necessary, fill rest of the page with blank rows */
    for (; i < FMT_PGLINES; i++)
        putchar('\n');

    return true;
}

/*********************************************************//**
 *
 *************************************************************
 */
_Bool do_command(
    size_t      *bt,        /* by reference */
    const char  *cmd,
    const char  *prevcmd,
    Buffer      *buffer,
    Settings    *settings   /* by reference */
)
{
    enum KeyCommand key;
    size_t row;

    if ( !buffer || !buffer->data )
        return false;

    /* execute the command */

    row = BT2ROW( *bt, buffer->len, buffer->nrows );
    key = tolower( (int) *cmd );

    /* display the help screen */
    if ( KEY_HLP == key ) {
        show_help( settings->colorize );
        return true;
    }

    /* load a new file */
    if ( KEY_LOADFILE == key )
    {
        _Bool success = false;
        char answer[256+1] = {'n'};
        char tmpfname[ MAXINPUT ] = {'\0'};

        if ( '\0' == cmd[1] ) {
            printf( "f must be followed by a filename! " );
            pressENTER();
            return true;
        }

        strncpy( tmpfname, &cmd[1], MAXINPUT );
        if ( !fileexists(tmpfname) ) {
            printf( "No such file, keeping current one! " );
            pressENTER();
            return true;
        }

        colorPRINTF(
            settings->colorize, FG_RED, BG_NOCHANGE,
            "Current file will be closed, are you sure (y/) ? "
        );
        if ( 'y' != tolower( (int) *s_read(answer, 256+1) ) )
            return true;

        buffer_cleanup( buffer );
        success = (settings->unlimfsize) 
            ? buffer_read_file( buffer, tmpfname, 100*1024*1024 )
            : buffer_read_file_longmax( buffer, tmpfname );
        if ( !success ) {
            perror(NULL);
            return true;
        }

        return true;
    }

    /* toggle colorization */
    if ( KEY_COLOR == key ) {
        settings->colorize = (settings->colorize == true ) ? false : true;
        return true;
    }

    /* toggle character set */
    if ( KEY_CHARSET == key ) {
        settings->charset =     (settings->charset == FMT_ASCII)
                    ? FMT_XASCII : FMT_ASCII;
        return true;
    }

    /* byte back/forward */
    if ( KEY_BYTEB == key || KEY_BYTEF == key )
    {
        /* get relative step (if any) */
        long long step = strtoll( &cmd[1], NULL, 10 );
        if (errno == ERANGE)            /* over/underflowed step     */
            return true;
        if ( step == 0 )            /* no step ? assume 1        */
            step = 1;
        else if ( step < 0 )            /* negative step? negate it  */
            step = -step;

        /* apply relative row-step */
        if ( KEY_BYTEB == key )
            *bt =   (*bt > step - 1) ? *bt - step : 0;
        else /* KEY_BYTEF == key */
            *bt =   (*bt < buffer->len - 1 - step)
                ? *bt + step
                : buffer->len - 1;

        return true;
    }

    /* row start/end */
    if ( KEY_ROWSTA == key ) {
        *bt = ROW2BT(row, buffer->nrows);
        return true;
    }
    if ( KEY_ROWEND == key ) {
        *bt = ROW2BT(row, buffer->nrows) + FMT_NCOLS - 1;
        return true;
    }

    /* row up/down */
    if ( KEY_ROWUP == key || KEY_ROWDN == key )
    {
        /* get relative row-step (if any) */
        long long step = strtoll( &cmd[1], NULL, 10 );
        if (errno == ERANGE)            /* over/underflowed step     */
            return true;
        if ( step == 0 )            /* no step ? assume 1        */
            step = 1;
        else if ( step < 0 )            /* negative step? negate it  */
            step = -step;

        /* apply relative row-step */
        if ( KEY_ROWUP == key )
            row =   (row > step - 1) ? row - step : 0;
        else /* KEY_ROWDN == key */
            row =   (row < buffer->nrows - 1 - step)
                ? row + step
                : buffer->nrows - 1;
    }

    /* page up/down */
    else if ( KEY_PGUP == key || KEY_PGDN == key )
    {
        /* get relative page-step (if any) */
        long long step = strtoll( &cmd[1], NULL, 10 );
        if (errno == ERANGE)            /* over/underflowed step     */
            return true;
        if ( step == 0 )            /* no step ? assume 1        */
            step = 1;
        else if ( step < 0 )            /* negative step? negate it  */
            step = -step;

        /* apply relative page-step */
        if ( KEY_PGUP == key )
            row =   row > step * (FMT_PGLINES - 1)
                ? row - step * FMT_PGLINES
                : 0;
        else /* KEY_PGDN == key */
            row =   myMIN( (row + step * FMT_PGLINES), buffer->nrows - 1 );
    }

    /* top/bottom of file */
    else if ( KEY_TOP == key ) {
        *bt = 0;
        return true;
    }
    else if ( KEY_BOT == key ) {
        *bt = buffer->len - 1;
        return true;
    }

    /* goto to specified byte */
    else if ( KEY_GBYTE == key ) {
        size_t newbt;
        sscanf( &cmd[1], "%li", (long int *)&newbt );
        row =   BT2ROW(newbt, buffer->len, buffer->nrows);
        *bt = newbt > buffer->len - 1 ? buffer->len - 1 : newbt;
        return true;
    }
    /* goto to specified row */
    else if ( KEY_GROW == key ) {
        size_t newrow;
        sscanf( &cmd[1], "%li", (long int *)&newrow );
        row =   newrow > buffer->nrows - 1
            ? buffer->nrows - 1
            : newrow > 0 ? newrow : 0;
    }
    /* goto to specified page */
    else if ( KEY_GPAGE == key ) {
        size_t newpg = strtoul( &cmd[1], NULL, 10 );
        --newpg;
        row = PG2ROW(newpg, buffer->npages);
    }

    /* search forward for text-string */
    else if ( KEY_FNDSTR == key )
    {
        size_t ibt = *bt;           /* remember cursor position   */
        size_t slen = strlen( &cmd[1] );
        int tmp = 1;

        if ( !strcmp(cmd, prevcmd) )        /* fix ibt if cmd == prevcmd  */
            ibt = ibt > 0 ? ibt+1 : 1;

        /* do the search */
        colorPRINTF(settings->colorize, FG_RED, BG_NOCHANGE, "searching..." );
        while ( slen && ibt < buffer->len - slen + 1
            && (tmp = memcmp(&buffer->data[ibt], (Byte *)&cmd[1], slen * sizeof(Byte)))
        )
            ibt++;
            
        if ( 0 == tmp )             /* string found               */
            *bt = ibt;          /* ... update cursor position */
        else
            BELL(1);

        return true;
    }
    /* search backwards for text-string */
    else if ( KEY_RFNDSTR == key )
    {
        size_t ibt = *bt;           /* remember cursor position   */
        size_t slen = strlen( &cmd[1] );
        int tmp = 1;

        if ( !strcmp(cmd, prevcmd) )        /* fix ibt if cmd == prevcmd  */
            ibt = ibt > 0 ? ibt-1 : 0;

        /* do the search */
        colorPRINTF(settings->colorize, FG_RED, BG_NOCHANGE, "searching..." );
        while ( slen && ibt > 0
            && (tmp=memcmp(&buffer->data[ibt], (Byte *)&cmd[1], slen * sizeof(Byte)))
        )
            ibt--;
        /* 0 is treaded separately because ibt is unsigned */
        if ( ibt == 0 && tmp != 0 )
            tmp = memcmp(&buffer->data[ibt], (Byte *)&cmd[1], slen * sizeof(Byte));

        if ( 0 == tmp )             /* string found               */
            *bt = ibt;          /* ... update cursor position */
        else
            BELL(1);

        return true;
    }

    /* search forward for byte-sequence */
    else if ( KEY_FNDSEQ == key )
    {
        size_t  ibt = *bt;          /* remember cursor position   */
        size_t  iseq;               /* eventually the len of seq[]*/
        Byte    seq[MAXINPUT] = {0};        /* to hold the byte-sequence  */
        int     tmp = 1;            /* general purpose temp int   */

        if ( !strcmp(cmd, prevcmd) )        /* fix ibt if cmd == prevcmd  */
            ibt = ibt > 0 ? ibt+1 : 1;

        /* convert text-string &cmd[1] to byte-sequence seq[] */
        tmp = iseq = 0;
        while ( 1 == sscanf(&cmd[tmp+1], "%2hhx", (Byte *)&seq[iseq]) )
        {
            tmp += 2;
            iseq++;
        }
        seq[iseq] = '\0';           /* this is just for debugging */

        /* do the search */
        colorPRINTF(settings->colorize, FG_RED, BG_NOCHANGE, "searching..." );
        while ( iseq && ibt < buffer->len - iseq + 1
            && (tmp=(memcmp( &buffer->data[ibt], seq, iseq*sizeof(Byte) )))
        )
            ibt++;
            
        if ( 0 == tmp )             /* sequence found             */
            *bt = ibt;          /* ... update cursor position */
        else
            BELL(1);

        return true;
    }
    /* search backwards for byte-sequence */
    else if ( KEY_RFNDSEQ == key )
    {
        size_t  ibt = *bt;          /* remember cursor position   */
        size_t  iseq;               /* eventually the len of seq[]*/
        Byte    seq[MAXINPUT] = {0};        /* to hold the byte-sequence  */
        int     tmp = 1;            /* general purpose temp int   */

        if ( !strcmp(cmd, prevcmd) )        /* fix ibt if cmd == prevcmd  */
            ibt = ibt > 0 ? ibt-1 : 0;

        /* convert text-string &cmd[1] to byte-sequence seq[] */
        tmp = iseq = 0;
        while ( 1 == sscanf(&cmd[tmp+1], "%2hhx", (Byte *)&seq[iseq]) )
        {
            tmp += 2;
            iseq++;
        }
        seq[iseq] = '\0';           /* this is just for debugging */

        /* do the search */
        colorPRINTF(settings->colorize, FG_RED, BG_NOCHANGE, "searching..." );
        while ( iseq && ibt > 0
            && (tmp=memcmp(&buffer->data[ibt], seq, iseq * sizeof(Byte))) )
            ibt--;
        /* 0 is treaded separately because ibt is unsigned */
        if ( ibt == 0 && tmp != 0 )
            tmp = memcmp(&buffer->data[ibt], seq, iseq * sizeof(Byte));

        if ( 0 == tmp )             /* string found               */
            *bt = ibt;          /* ... update cursor position */
        else
            BELL(1);

        return true;
    }

/*
    else
        (*row) += FMT_PGLINES;
*/
    *bt = ROW2BT( row, buffer->nrows ) + ( *bt % FMT_NCOLS );

        return true;
}

/*********************************************************//**
 *
 *************************************************************
 */
_Bool view_buffer( Buffer *buffer, Settings *settings )
{
    size_t bt;                  /* current byte-index        */
    char cmd[ MAXINPUT ] = {']'}, prevcmd[ MAXINPUT ] = {'\0'};

    if ( !buffer || !buffer->data || !settings )
        return false;

    bt = 0;
    for (;;)
    {
        if ( !settings->israw )         /* no headers in raw-mode     */
            show_header( bt, buffer, settings );

        view_screen( bt, buffer, settings );

        if ( settings->israw )          /* no interaction in raw-mode */
            continue;

        strcpy( prevcmd, cmd );         /* backup current command     */

        /* get new command */
        if ( !show_prompt(bt, cmd, prevcmd, buffer, settings) )
            continue;

        if ( KEY_QUIT == *cmd )
            break;

        if ( '\n' == *cmd )         /* restore previous command  */
            strcpy( cmd, prevcmd );

        do_command( &bt, cmd, prevcmd, buffer, settings );

    }

    putchar('\n');

    return true;
}

/*********************************************************//**
 *
 *************************************************************
 */
void buffer_dump( const Buffer *buffer )
{
    size_t  i = 0U;

    if ( !buffer || !buffer->data)
        return;

    for (i=0U; i < buffer->len; i++)
        putchar( (int)buffer->data );
    fflush( stdout );

    return;
}


/*********************************************************//**
 *
 *************************************************************
 */
void buffer_cleanup( Buffer *buffer )
{
    if ( !buffer )
        return;

    if ( buffer->data ) {
        free(buffer->data);
        buffer->data = NULL;
    }

    memset( buffer, 0, sizeof(Buffer) );
    return;
}

/*********************************************************//**
 * Read into a Buffer structure the contents of a file with size up tp LONG_MAX bytes.
 *************************************************************
 */
_Bool buffer_read_file_longmax( Buffer *buffer, const char *fname )
{
    long int buflen, bufsize;
    FILE     *fp = NULL;

    if ( !buffer || !fname || '\0' == *fname )
        return false;

    if ( -1 == (bufsize = filesize(fname)) || NULL == (fp = fopen(fname, "rb")) )
        return false;

    /* make sure our Buffer struct starts with zeroed fields */
    memset( buffer, 0, sizeof(Buffer) );

    /* allocate room in memory for our buffer->data (+1 for zero-terminator) */
    buflen = bufsize / sizeof(Byte);
    if ( NULL == (buffer->data = calloc( buflen+1, sizeof(Byte) )) )
        goto ret_failure;

    printf("Loading \"%s\"... ", fname);
    buflen = fread( buffer->data, sizeof(Byte), buflen, fp);
    if ( ferror(fp) )
        goto ret_failure;

    fclose(fp);
    puts("\nDone!");

    /* update fields in our Buffer structure */
    strcpy( buffer->fname, fname );
    buffer->len     = buflen;
    buffer->nrows   = buffer->len/FMT_NCOLS + (buffer->len % FMT_NCOLS != 0 ?1 :0);
    buffer->npages  = buffer->nrows / FMT_PGLINES
            + (buffer->nrows % FMT_PGLINES != 0 ? 1 : 0 );

    return true;

ret_failure:
    if ( buffer->data )
        free( buffer->data );
    memset( buffer, 0, sizeof(buffer) );

    if ( fp )
        fclose(fp);
    return false;
}

/*********************************************************//**
 * Read contents of file of any size into the Buffer structure.
 *************************************************************
 */
_Bool buffer_read_file( Buffer *buf, const char *fname, size_t chunklen )
{
    size_t  n;              /* # of Bytes read from file to chunk*/
    size_t  buflen = chunklen;      /* current length of our data buffer */
    Byte    *try = NULL;            /* to test reallocs before apply 'em */
    FILE    *fp = NULL;

    if ( !buf || !fname || '\0' == *fname || NULL == (fp=fopen(fname, "rb")) )
        return false;

    /* make sure our Buffer struct starts with zeroed fields */
    memset( buf, 0, sizeof(Buffer) );

    /* allocate ahead room for chunklen Bytes */
    if ( NULL == (buf->data = calloc( buflen, sizeof(Byte) )) )
        return false;

    /* inform the user */
    printf( "Loading \"%s\\n", fname );
    printf( "(in chunks of %llu bytes)\n",
        (unsigned long long)(chunklen * sizeof(Byte))
    );
    printf( "Bytes loaded so far: ");

    /* read the file into our Buffer structure */
    while ( !feof(fp) )
    {
        /* read data from file into the newely allocated part of the Buffer */
        n = fread( &buf->data[buflen-chunklen], sizeof(Byte), chunklen, fp);
        if (ferror(fp) || n < chunklen) {
            goto ret_failure;
        }

        /* allocate ahead chunklen more Bytes */
        buflen += chunklen;
        if ( NULL == (try = realloc( buf->data, buflen * sizeof(Byte) )) )
            goto ret_failure;
        buf->data = try;

        /* display bytes read so far */
        NBS( printf("%llu", (unsigned long long)(buflen-chunklen) * sizeof(Byte)) );
    }
    putchar('\n');

    if ( ferror(fp) )
        goto ret_failure;
    fclose(fp);

    /* truncate buffer=>data to actual file length */
    buflen -= (chunklen - n);
    if (NULL == (try = realloc( buf->data, buflen * sizeof(Byte) )) )
        goto ret_failure;
    buf->data = try;

    /* update fields in our Buffer structure */
    strcpy( buf->fname, fname );
    buf->len    = buflen;
    buf->nrows  = buf->len / FMT_NCOLS + (buf->len % FMT_NCOLS != 0 ? 1 : 0);
    buf->npages     = buf->nrows / FMT_PGLINES
            + (buf->nrows % FMT_PGLINES != 0 ? 1 : 0 );

    return true;

ret_failure:
    if ( buf->data )
        free( buf->data );
    memset( buf, 0, sizeof(buf) );

    if ( fp )
        fclose(fp);
    return false;
}

/*********************************************************//**
 *
 *************************************************************
 */
int main( int argc, char *argv[] )
{
    _Bool   success = false;
    char    tmpfname[ MAXINPUT ] = {'\0'};

    /* our Buffer structure */
    Buffer buffer = {               
        .fname = {'\0'},
        .len=0U, .nrows=0U, .npages=0U,
//      .bt=0U, .row=0U, .pg=0U,
        .data = NULL                /* ... the actual buffer     */
    };
    /* our Settings structure */
    Settings settings = {               
        .colorize   = true,
        .charset    = FMT_ASCII,        /* ... plain ASCII           */
        .israw      = false,
        .unlimfsize = false
    };

    CONOUT_INIT();
    CONOUT_SET_COLOR( FGCLR_NORMAL );       /* set console fg color      */

    /* parse the command line */
    if ( 1 == argc )                /* no command line arguments */
        strncpy(tmpfname, argv[0], MAXINPUT-1 );
    else
        strncpy(tmpfname, argv[1], MAXINPUT-1 );

    /* read the file into the buffer */
    success = (settings.unlimfsize) 
        ? buffer_read_file( &buffer, tmpfname, 100*1024*1024 )
        : buffer_read_file_longmax( &buffer, tmpfname );
    if ( !success ) {
        perror(NULL);
        goto exit_failure;
    }

    /* list the file contents */
    if ( !view_buffer( &buffer, &settings ) ) {
        perror(NULL);
        goto exit_failure;
    }

    buffer_cleanup( &buffer );

    CONOUT_RESTORE();
    exit( EXIT_SUCCESS );

exit_failure:
    buffer_cleanup( &buffer );

    CONOUT_RESTORE();
    pressENTER();
    exit( EXIT_FAILURE );
}