hexcompare-1.0.4/ 000755 001752 000144 00000000000 12524677222 014551 5 ustar 00mateusz users 000000 000000 hexcompare-1.0.4/gui.c 000644 001752 000144 00000071355 12524675125 015514 0 ustar 00mateusz users 000000 000000 /*
* This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
* Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see .
*/
#include "gui.h"
/* #####################################################################
## ANCILLARY MATHEMATICAL FUNCTIONS ##
##################################################################### */
static void calculate_dimensions(int *width, int *height, int *total_blocks,
unsigned long *bytes_per_block,
unsigned long largest_file_size,
int *blocks_with_excess_byte)
{
/* Acquire the dimensions of window */
getmaxyx(stdscr, *height, *width);
/* If the window dimensions are too small, exit. */
if ((*height < 16) || (*width < 10)) {
endwin();
printf("Terminal dimensions are too small to proceed. "
"Increase the size to a minimum of 16w x 10h.\n\n");
exit(1);
}
/* Calculate how many bytes are held in a block.
Each block holds a minimum of one byte. The number is
biggest file size / # blocks ((width-SIDE_MARGIN) * (height-11))
rounded to the next number up. */
*total_blocks = (*width - SIDE_MARGIN*2) *
(*height - VERTICAL_BLACK_SPACE);
*bytes_per_block = (unsigned long) largest_file_size /
(*total_blocks);
*blocks_with_excess_byte = (unsigned long) largest_file_size %
(*total_blocks);
return;
}
static int calculate_current_block(int total_blocks, unsigned long file_offset,
unsigned long *offset_index)
{
/* With a given offset, calculate which element it corresponds to
in the offset_index. */
int i, current_block = 0;
for (i = 0; i < total_blocks; i++) {
/* Go block by block, and see if our offset is greater than
that of the block's. */
if (file_offset >= offset_index[i]) {
current_block = i;
} else {
break;
}
/* Break if we reach EOF. */
if ((i+1 < total_blocks) && (offset_index[i+1] == offset_index[i]))
break;
}
return current_block;
}
/* computes the width of the hex offset margin on the left */
static int calculate_max_offset_characters(unsigned long fsz)
{
char s[32];
sprintf(s, "%lX", fsz);
return(strlen(s));
}
/* #####################################################################
## SCREEN HANDLING FUNCTIONS ##
##################################################################### */
static char raw_to_ascii(char input)
{
if ((input > 31) && (input < 127)) return input;
return '.';
}
/* #####################################################################
## HANDLE MOUSE ACTIONS ##
##################################################################### */
static void mouse_clicked(unsigned long *file_offset, unsigned long
*offset_index, int width, int height,
int total_blocks, char *mode,
int mouse_x, int mouse_y, int action)
{
int index;
/* In overview mode, you can single-click boxes in the top view
to move to the offset that they represent. Double click brings
you to the hex representation. */
if (*mode == OVERVIEW_MODE && (action == BUTTON1_CLICKED ||
action == BUTTON1_DOUBLE_CLICKED)) {
/* If the mouse is out of bounds, return. */
if (mouse_x < SIDE_MARGIN || mouse_x > width - SIDE_MARGIN - 1
|| mouse_y < 2 || mouse_y > height - 8)
return;
/* Calculate the box it falls in. */
index = (width-SIDE_MARGIN*2) * (mouse_y-2) +
mouse_x-SIDE_MARGIN;
/* Set the offset to the value in the box. */
if (index < total_blocks && index >= 0)
*file_offset = offset_index[index];
/* If double-clicked, set to HEX MODE. */
if (action == BUTTON1_DOUBLE_CLICKED)
*mode = HEX_MODE;
}
return;
}
/* #####################################################################
## GENERATE TITLE BAR ##
##################################################################### */
static void generate_titlebar(struct file *file_one, struct file *file_two,
unsigned long file_offset, int width, int height,
char mode, int display)
{
int i;
char title_offset[32];
char bottom_message[128];
/* Define and set colour for the title bar. */
init_pair(TITLE_BAR, COLOR_BLACK, COLOR_WHITE);
attron(COLOR_PAIR(TITLE_BAR) | A_BOLD);
/* Create the title bar background. */
for (i = 0; i < width; i++) {
mvprintw(0, i, " ");
mvprintw(height-1, i, " ");
}
/* Create the title. */
mvprintw(0, SIDE_MARGIN, "hexcompare: %s vs. %s",
file_one->name, file_two->name);
/* Indicate file offset. */
sprintf(title_offset, " 0x%04x", (unsigned int) file_offset);
mvprintw(0, width-strlen(title_offset)-SIDE_MARGIN, "%s",
title_offset);
/* Write bottom menu options. */
strcpy(bottom_message, "Quit: q | ");
if (display == HEX_VIEW) {
strcat(bottom_message, "Hex Mode: m | ");
} else {
strcat(bottom_message, "ASCII Mode: m | ");
}
if (mode == OVERVIEW_MODE) {
strcat(bottom_message, "Full View: v | Page & Arrow Keys to Move");
} else {
strcat(bottom_message, "Mixed View: v | Arrow Keys to Move");
}
mvprintw(height-1, SIDE_MARGIN, "%s", bottom_message);
/* Set the colour scheme back to default. */
attroff(COLOR_PAIR(TITLE_BAR) | A_BOLD);
return;
}
/* #####################################################################
## GENERATE BLOCK DATA FOR OVERVIEW MODE ##
##################################################################### */
static char *generate_blocks(struct file *file_one, struct file *file_two,
char *block_cache, int total_blocks,
unsigned long bytes_per_block,
int blocks_with_excess_byte)
{
int i;
unsigned char *block_one, *block_two;
block_one = malloc(bytes_per_block + 1);
block_two = malloc(bytes_per_block + 1);
/* De-allocate existing memory that holds the block data. */
if (block_cache != NULL) free(block_cache);
/* Allocate the correct amount of memory and initialize it. */
block_cache = malloc(total_blocks);
memset(block_cache, BLOCK_EMPTY, total_blocks);
/* Seek to start of file. */
fseek(file_one->pointer, 0, SEEK_SET);
fseek(file_two->pointer, 0, SEEK_SET);
/* Compare bytes of file_one with file_two. Store results in */
/* a dynamically-sized block_cache. */
for (i = 0; i < total_blocks; i++) {
int bytes_read_one, bytes_read_two;
size_t bytes_in_block, j;
/* Calculate how many bytes to read for this block. */
if (i < blocks_with_excess_byte) {
bytes_in_block = bytes_per_block + 1;
} else {
bytes_in_block = bytes_per_block;
}
/* Set the default. */
block_cache[i] = BLOCK_SAME;
/* Clear the block of data. */
memset(block_one, '\0', bytes_in_block);
memset(block_two, '\0', bytes_in_block);
/* Read in the next block of data. */
bytes_read_one = fread(block_one, bytes_in_block,
1, file_one->pointer);
bytes_read_two = fread(block_two, bytes_in_block,
1, file_two->pointer);
/* Stop here if we read 0 bytes. Both files are fully read. */
if (bytes_read_one == 0 && bytes_read_two == 0) {
block_cache[i] = BLOCK_EMPTY;
break;
}
/* If the file lengths don't match up, we know the blocks are
different. Go to the next block. */
if (bytes_read_one != bytes_read_two) {
block_cache[i] = BLOCK_DIFFERENT;
continue;
}
/* Both blocks have the same length. Compare them character by
character. */
for (j = 0; j < bytes_in_block; j++) {
if (block_one[j] != block_two[j]) {
block_cache[i] = BLOCK_DIFFERENT;
break;
}
}
}
/* free memory */
free(block_one);
free(block_two);
return block_cache;
}
/* #####################################################################
## BLOCK OFFSET FUNCTIONS FOR OVERVIEW MODE ##
##################################################################### */
static unsigned long *generate_offsets(unsigned long *offset_index,
int total_blocks,
unsigned long bytes_per_block,
int blocks_with_excess_byte)
{
int i;
unsigned long offset = 0;
/* De-allocate existing memory that holds the offset data. */
if (offset_index != NULL) free(offset_index);
/* Allocate the correct amount of memory and initialize it. */
offset_index = malloc(total_blocks * sizeof(unsigned long));
memset(offset_index, 0, total_blocks);
/* Generate offset data. */
for (i = 0; i < total_blocks; i++) {
offset_index[i] = offset;
if (i < blocks_with_excess_byte) {
offset += bytes_per_block + 1;
} else {
offset += bytes_per_block;
}
}
return offset_index;
}
static unsigned long calculate_offset(unsigned long file_offset,
unsigned long *offset_index, int width,
int total_blocks, int shift_type,
unsigned long largest_file_size)
{
/* Initialize variables. */
unsigned long new_offset = file_offset;
int blocks_in_row = width - SIDE_MARGIN*2;
int current_block = 0;
/* Calculate parameters for the offset. */
int offset_char_size = calculate_max_offset_characters(largest_file_size);
int hex_width = width - offset_char_size - 3 - SIDE_MARGIN * 2;
int offset_jump = (hex_width - (hex_width % 4)) / 4;
/* Locate the current block we're in. */
current_block = calculate_current_block(total_blocks, file_offset,
offset_index);
/* Return the offset of the block we want. */
switch (shift_type) {
case LEFT_BLOCK:
if (current_block > 0) current_block--;
break;
case RIGHT_BLOCK:
if (current_block < total_blocks - 1) current_block++;
break;
case UP_ROW:
if (current_block - blocks_in_row < 0) {
current_block = 0;
} else {
current_block -= blocks_in_row;
}
break;
case DOWN_ROW:
if (current_block + blocks_in_row >= total_blocks) {
current_block = total_blocks - 1;
} else {
current_block += blocks_in_row;
}
break;
case UP_LINE:
if (file_offset - offset_jump > file_offset) {
current_block = 0;
break;
} else {
return file_offset - offset_jump + 1;
}
case DOWN_LINE:
if (file_offset + offset_jump >= largest_file_size) {
return file_offset;
} else {
return file_offset + offset_jump - 1;
}
}
new_offset = offset_index[current_block];
return new_offset;
}
/* returns a pointer to the 'filename' part of a path. One could argue
* that basename() would be appropriate here, but the problem is that
* some platforms have a basename() that modifies the passed string,
* which we want to avoid. */
static char *getfilename(char *f) {
char *res = f;
for (; *f != 0; f += 1) {
if ((*f == '/') || (*f == '\\')) {
res = f + 1;
}
}
return(res);
}
/* #####################################################################
## DRAW ROWS OF RAW DATA IN HEX/ASCII FORM ##
##################################################################### */
static void display_file_names(int row, struct file *file_one,
struct file *file_two, int offset_char_size,
int offset_jump)
{
char *filename_one, *filename_two;
/* ltrim the filenames if any / character is found */
filename_one = getfilename(file_one->name);
filename_two = getfilename(file_two->name);
/* Display the file names. */
attron(COLOR_PAIR(TITLE_BAR));
mvprintw(row, SIDE_MARGIN+offset_char_size+3, " %s ",
filename_one);
mvprintw(row, SIDE_MARGIN+offset_char_size+4+
offset_jump*2, " %s ", filename_two);
attroff(COLOR_PAIR(TITLE_BAR));
}
static void display_offsets(int start_row, int finish_row, int offset_jump,
int offset_char_size, unsigned long file_offset)
{
int i;
char offset_line[32];
unsigned long temp_offset = file_offset;
attron(COLOR_PAIR(TITLE_BAR));
for (i = start_row; i < finish_row; i++) {
sprintf(offset_line, "0x%%0%ix ", offset_char_size);
mvprintw(i, SIDE_MARGIN, offset_line, temp_offset);
temp_offset += offset_jump - 1;
}
attroff(COLOR_PAIR(TITLE_BAR));
}
static void draw_hex_data(int start_row, int finish_row, struct file *file_one,
struct file *file_two, unsigned long file_offset,
int offset_char_size, int offset_jump, int display)
{
unsigned long temp_offset = file_offset;
int i, j;
for (i = start_row; i < finish_row; i++) {
int bold = 0;
for (j = SIDE_MARGIN+offset_char_size+3; j <
SIDE_MARGIN+offset_char_size+offset_jump*2+1; j += 2) {
int colour_pair;
unsigned char byte_one, byte_two;
char byte_one_hex[16], byte_two_hex[16];
char byte_one_ascii, byte_two_ascii;
int bytes_read_one, bytes_read_two;
/* Seek to the proper locations in the file. */
fseek(file_one->pointer, temp_offset, SEEK_SET);
fseek(file_two->pointer, temp_offset, SEEK_SET);
/* Read a byte from the files. */
bytes_read_one = fread(&byte_one, 1, 1, file_one->pointer);
bytes_read_two = fread(&byte_two, 1, 1, file_two->pointer);
/* Convert binary to ASCII hex. */
sprintf(byte_one_hex, "%02x", byte_one);
sprintf(byte_two_hex, "%02x", byte_two);
byte_one_hex[2] = '\0';
byte_two_hex[2] = '\0';
/* Interpret ASCII version of bytes. */
byte_one_ascii = raw_to_ascii(byte_one);
byte_two_ascii = raw_to_ascii(byte_two);
/* Make every other byte bold. */
if (bold != 0) attron(A_BOLD);
/* Post results. */
/* Byte 1:
Determine if its EMPTY/DIFFERENT/SAME. */
if (bytes_read_one == 0) {
colour_pair = BLOCK_EMPTY;
} else if (bytes_read_two == 0) {
colour_pair = BLOCK_DIFFERENT;
} else if (byte_one == byte_two) {
colour_pair = BLOCK_SAME;
} else {
colour_pair = BLOCK_DIFFERENT;
}
/* Display the block. */
attron(COLOR_PAIR(colour_pair));
if (colour_pair == BLOCK_EMPTY) {
mvprintw(i,j, " ");
} else if (display == HEX_VIEW) {
mvprintw(i,j, " %c", byte_one_ascii);
} else {
mvprintw(i,j, "%s", byte_one_hex);
}
attroff(COLOR_PAIR(colour_pair));
/* Byte 2:
Determine if its EMPTY/DIFFERENT/SAME. */
if (bytes_read_two == 0) {
colour_pair = BLOCK_EMPTY;
} else if (bytes_read_one == 0) {
colour_pair = BLOCK_DIFFERENT;
} else if (byte_one == byte_two) {
colour_pair = BLOCK_SAME;
} else {
colour_pair = BLOCK_DIFFERENT;
}
/* Display the block. */
attron(COLOR_PAIR(colour_pair));
if (colour_pair == BLOCK_EMPTY) {
mvprintw(i,j+offset_jump*2+1, " ");
} else if (display == HEX_VIEW) {
mvprintw(i,j+offset_jump*2+1, " %c", byte_two_ascii);
} else {
mvprintw(i,j+offset_jump*2+1, "%s", byte_two_hex);
}
attroff(COLOR_PAIR(colour_pair));
/* Switch bold characters with non-bold characters. */
if (bold != 0) attroff(A_BOLD);
bold ^= 1;
temp_offset++;
}
}
return;
}
/* #####################################################################
## GENERATE SCREEN IN OVERVIEW MODE ##
##################################################################### */
static void generate_overview(struct file *file_one, struct file *file_two,
unsigned long *file_offset, int width,
int height, char *block_cache, int total_blocks,
unsigned long *offset_index, int display,
unsigned long largest_file_size)
{
/* In overview mode:
BLOCKDIAGRAM-BLOCKDIAGRAM-BLOCKDIAGRAM-BLOCKDIAGRAM
BLOCKDIAGRAM-BLOCKDIAGRAM-BLOCKDIAGRAM-BLOCKDIAGRAM
BLOCKDIAGRAM-BLOCKDIAGRAM-BLOCKDIAGRAM-BLOCKDIAGRAM
BLOCKDIAGRAM-BLOCKDIAGRAM-BLOCKDIAGRAM-BLOCKDIAGRAM
FILENAME 1 FILENAME 2
OFFSET HEX1-HEX1-HEX1-HEX1-HEX1 HEX2-HEX2-HEX2-HEX2
OFFSET HEX1-HEX1-HEX1-HEX1-HEX1 HEX2-HEX2-HEX2-HEX2
OFFSET HEX1-HEX1-HEX1-HEX1-HEX1 HEX2-HEX2-HEX2-HEX2
Where BLOCKDIAGRAM is the blue/red squares comparing
hex blocks from file 1 and file 2. Size is variable.
SCROLLBAR is the scrollbar representing how far in
the file we are, HEX1 is the hex for file 1 from the
offset, and HEX2 is the hex for file 2 from the
offset. */
/* Create variables. */
int i, j;
int offset_char_size;
int hex_width;
int offset_jump;
int current_block;
/* Define colors block diagram. */
init_pair(BLOCK_SAME, COLOR_WHITE, COLOR_BLUE);
init_pair(BLOCK_DIFFERENT, COLOR_WHITE, COLOR_RED);
init_pair(BLOCK_EMPTY, COLOR_BLACK, COLOR_CYAN);
init_pair(BLOCK_ACTIVE, COLOR_BLACK, COLOR_YELLOW);
init_pair(TITLE_BAR, COLOR_BLACK, COLOR_WHITE);
/* Find which block in the diagram is active based off of
the current offset. */
/* Generate the block diagram. */
for (i = 0; i < height - VERTICAL_BLACK_SPACE; i++) {
for (j = 0; j < width - SIDE_MARGIN*2; j++) {
/* Draw the blocks that are matching/different/empty. */
int index = i*(width-SIDE_MARGIN*2)+j;
attron(COLOR_PAIR(block_cache[index]));
mvprintw(i+2,j+SIDE_MARGIN," ");
attroff(COLOR_PAIR(block_cache[index]));
}
}
/* Show the active block. */
current_block = calculate_current_block(total_blocks, *file_offset, offset_index);
attron(COLOR_PAIR(BLOCK_ACTIVE));
mvprintw(current_block / (width - SIDE_MARGIN*2) + 2,
current_block % (width - SIDE_MARGIN*2) + SIDE_MARGIN," ");
attroff(COLOR_PAIR(BLOCK_ACTIVE));
/* Generate the offset markers.
Calculate parameters for the offset. */
offset_char_size = calculate_max_offset_characters(largest_file_size);
hex_width = width - offset_char_size - 3 - SIDE_MARGIN * 2;
offset_jump = (hex_width - (hex_width % 4)) / 4;
/* Display the offsets.
Display the hex offsets on the left. */
display_offsets(height-7, height-2, offset_jump, offset_char_size,
*file_offset);
/* Generate HEX characters
Seek to initial offset. */
draw_hex_data(height - 7, height - 2, file_one, file_two,
*file_offset, offset_char_size, offset_jump, display);
/* Write the file titles. */
display_file_names(height-8, file_one, file_two, offset_char_size,
offset_jump);
return;
}
/* #####################################################################
## GENERATE SCREEN IN HEX MODE ##
##################################################################### */
static void generate_hex(struct file *file_one, struct file *file_two,
unsigned long *file_offset, int width, int height,
int display, unsigned long largest_file_size)
{
/* In hex mode:
FILENAME 1 FILENAME 2
OFFSET HEX1-HEX1-HEX1-HEX1-HEX1 HEX2-HEX2-HEX2-HEX2
OFFSET HEX1-HEX1-HEX1-HEX1-HEX1 HEX2-HEX2-HEX2-HEX2
OFFSET HEX1-HEX1-HEX1-HEX1-HEX1 HEX2-HEX2-HEX2-HEX2
OFFSET HEX1-HEX1-HEX1-HEX1-HEX1 HEX2-HEX2-HEX2-HEX2
OFFSET HEX1-HEX1-HEX1-HEX1-HEX1 HEX2-HEX2-HEX2-HEX2
OFFSET HEX1-HEX1-HEX1-HEX1-HEX1 HEX2-HEX2-HEX2-HEX2
OFFSET HEX1-HEX1-HEX1-HEX1-HEX1 HEX2-HEX2-HEX2-HEX2
OFFSET HEX1-HEX1-HEX1-HEX1-HEX1 HEX2-HEX2-HEX2-HEX2
OFFSET HEX1-HEX1-HEX1-HEX1-HEX1 HEX2-HEX2-HEX2-HEX2
*/
/* Generate the offset markers.
Calculate parameters for the offset. */
int offset_char_size = calculate_max_offset_characters(largest_file_size);
int hex_width = width - offset_char_size - 3 - SIDE_MARGIN * 2;
int offset_jump = (hex_width - (hex_width % 4)) / 4;
/* Define colors block diagram. */
init_pair(BLOCK_SAME, COLOR_WHITE, COLOR_BLUE);
init_pair(BLOCK_DIFFERENT, COLOR_WHITE, COLOR_RED);
init_pair(BLOCK_EMPTY, COLOR_BLACK, COLOR_CYAN);
init_pair(BLOCK_ACTIVE, COLOR_BLACK, COLOR_YELLOW);
init_pair(TITLE_BAR, COLOR_BLACK, COLOR_WHITE);
/* Display the hex offsets on the left. */
display_offsets(3, height-2, offset_jump, offset_char_size,
*file_offset);
/* Generate HEX characters
Seek to initial offset. */
draw_hex_data(3, height - 2, file_one, file_two,
*file_offset, offset_char_size, offset_jump, display);
/* Write the file titles. */
display_file_names(2, file_one, file_two, offset_char_size,
offset_jump);
return;
}
/* #####################################################################
## GENERATE SCREEN VIEW ##
##################################################################### */
static void generate_screen(struct file *file_one, struct file *file_two,
char mode, unsigned long *file_offset, int width,
int height, char *block_cache, int total_blocks,
unsigned long *offset_index, int display,
unsigned long largest_file_size)
{
/* Clear the window. */
erase();
/* Generate the title bar. */
generate_titlebar(file_one, file_two, *file_offset, width, height,
mode, display);
/* Generate the window contents according to the mode we're in. */
if (mode == OVERVIEW_MODE) {
generate_overview(file_one, file_two, file_offset,
width, height, block_cache, total_blocks,
offset_index, display, largest_file_size);
} else if (mode == HEX_MODE) {
generate_hex(file_one, file_two, file_offset, width, height,
display, largest_file_size);
}
}
/* #####################################################################
## MAIN FUNCTION ##
##################################################################### */
void start_gui(struct file *file_one, struct file *file_two,
unsigned long largest_file_size)
{
/* Initiate variables */
unsigned long file_offset = 0; /* File offset. */
char mode = OVERVIEW_MODE; /* Display mode. */
int key_pressed; /* What key is pressed. */
char *block_cache = NULL; /* A quick comparison overview. */
unsigned long *offset_index = NULL; /* Keep track of offsets per block. */
int display = HEX_VIEW; /* ASCII vs. HEX mode. */
MEVENT mouse; /* Mouse event struct. */
WINDOW *main_window; /* Pointer for main window. */
int width, height, total_blocks, blocks_with_excess_byte;
unsigned long bytes_per_block;
/* Initiate the display. */
main_window = initscr(); /* Start curses mode. */
if (has_colors() != TRUE) {
puts("Error: Your terminal do not seem to handle colors.");
endwin();
return;
}
start_color(); /* Enable the use of colours. */
raw(); /* Disable line buffering. */
noecho(); /* Don't echo while we get characters. */
keypad(stdscr, TRUE); /* Enable capture of arrow keys. */
curs_set(0); /* Make the cursor invisible. */
mousemask(ALL_MOUSE_EVENTS, NULL); /* Get all mouse events. */
clear(); /* Clear out the screen */
/* Calculate values based on window dimensions. */
calculate_dimensions(&width, &height, &total_blocks, &bytes_per_block,
largest_file_size, &blocks_with_excess_byte);
/* Compile the block/offset cache. The block cache contains an index
of what the general differences are between the two compared
files. It exists to avoid re-comparing the two files every time
the screen is regenerated. The offset cache keeps track of what
the offsets are for each block in the block diagram, as they
may be uneven. */
block_cache = generate_blocks(file_one, file_two, block_cache,
total_blocks, bytes_per_block,
blocks_with_excess_byte);
offset_index = generate_offsets(offset_index, total_blocks,
bytes_per_block, blocks_with_excess_byte);
/* Generate initial screen contents. */
generate_screen(file_one, file_two, mode, &file_offset, width, height,
block_cache, total_blocks, offset_index, display,
largest_file_size);
/* Wait for user-keypresses and react accordingly. */
for(;;) {
/* poll the next keypress event from curses */
key_pressed = wgetch(main_window);
/* if we got 'q' or ESC, then quit */
if ((key_pressed == 'q') || (key_pressed == 27)) break;
switch (key_pressed) {
/* Move left/right/down/up on the blog diagram in overview
mode. */
case KEY_LEFT:
if (mode == OVERVIEW_MODE)
file_offset = calculate_offset(file_offset,
offset_index, width, total_blocks,
LEFT_BLOCK, largest_file_size);
break;
case KEY_RIGHT:
if (mode == OVERVIEW_MODE)
file_offset = calculate_offset(file_offset,
offset_index, width, total_blocks,
RIGHT_BLOCK, largest_file_size);
break;
case KEY_UP:
if (mode == OVERVIEW_MODE)
file_offset = calculate_offset(file_offset,
offset_index, width, total_blocks,
UP_ROW, largest_file_size);
else if (mode == HEX_MODE)
file_offset = calculate_offset(file_offset,
offset_index, width, total_blocks,
UP_LINE, largest_file_size);
break;
case KEY_DOWN:
if (mode == OVERVIEW_MODE)
file_offset = calculate_offset(file_offset,
offset_index, width, total_blocks,
DOWN_ROW, largest_file_size);
else if (mode == HEX_MODE)
file_offset = calculate_offset(file_offset,
offset_index, width, total_blocks,
DOWN_LINE, largest_file_size);
break;
case KEY_NPAGE:
file_offset = calculate_offset(file_offset,
offset_index, width, total_blocks,
DOWN_LINE, largest_file_size);
break;
case KEY_PPAGE:
file_offset = calculate_offset(file_offset,
offset_index, width, total_blocks,
UP_LINE, largest_file_size);
break;
case 'm':
if (display == ASCII_VIEW) display = HEX_VIEW;
else display = ASCII_VIEW;
break;
case 'v':
if (mode == OVERVIEW_MODE) mode = HEX_MODE;
else mode = OVERVIEW_MODE;
break;
case KEY_MOUSE:
if (nc_getmouse(&mouse) == OK) {
/* Left single-click. */
if (mouse.bstate & BUTTON1_CLICKED)
mouse_clicked(&file_offset, offset_index,
width, height, total_blocks, &mode,
mouse.x, mouse.y, BUTTON1_CLICKED);
/* Left double-click. */
if (mouse.bstate & BUTTON1_DOUBLE_CLICKED)
mouse_clicked(&file_offset, offset_index,
width, height, total_blocks, &mode,
mouse.x, mouse.y,
BUTTON1_DOUBLE_CLICKED);
}
break;
/* Redraw the window on resize. Recaltulate dimensions,
and redo the block/offset cache. */
case KEY_RESIZE:
calculate_dimensions(&width, &height, &total_blocks,
&bytes_per_block, largest_file_size,
&blocks_with_excess_byte);
block_cache = generate_blocks(file_one, file_two,
block_cache, total_blocks, bytes_per_block,
blocks_with_excess_byte);
offset_index = generate_offsets(offset_index,
total_blocks, bytes_per_block,
blocks_with_excess_byte);
break;
}
generate_screen(file_one, file_two, mode, &file_offset, width,
height, block_cache, total_blocks,
offset_index, display, largest_file_size);
}
/* End curses mode and exit. */
clear();
refresh();
endwin();
free(block_cache);
return;
}
hexcompare-1.0.4/README 000644 001752 000144 00000005363 12524664406 015440 0 ustar 00mateusz users 000000 000000
HEXCOMPARE - Visual File Comparison Utility
http://sourceforge.net/projects/hexcompare/
DESCRIPTION:
------------
hexcompare is a tool used to compare two binary or ASCII files. In overview
mode, it presents a block diagram which quickly displays what's the
same/different between two sets of files.
LICENSE:
--------
hexcompare is released under the GNU GPLv3.
HOW TO COMPILE:
---------------
Enter the "make" command in your terminal, minus the quote. It will produce
an executable called "hexcompare". This is our program.
HOW TO INTERPRET:
-----------------
Start the program by using the files you want to compare as the arguments.
For instance:
./hexcompare file_one file_two
Once in the program has started, you will see that the screen is divided
into two. In the top portion, you have the "overview." This is a block diagram
representing the differences between both files at a given offset.
A blue block means that the bytes that it represents are the same between
both files. Red means that they're different. Grey means that neither file has
any data at an offset.
Each block represents a number of bytes. How many bytes are represented
depends on your terminal window size: the bigger it is, the more blocks that
can be fit on screen. The more blocks on screen, the more the files are
divided up into smaller chunks of bytes.
The bottom half of the screen contains the raw data at a specified offset.
Using the "m" key will alternate the display between presenting the data as
hex and as ASCII. Pressing "v" will make the data view of the lower part of
the screen take up the whole terminal.
HOW TO NAVIGATE:
----------------
The mouse can be used to navigate the block diagram "overview." Single
clicking on a block will load in the offset represented by that block, and
show the data that's found there.
Double-clicking on a block will bring up a more detailed hex view of the
specified location.
The arrow keys can be used to go from block to block in the overview. Page
Up/Down can be used to go up/down lines of hex/ASCII data.
CHANGELOG:
----------
1.0.4 Mateusz Viste contributed several patches that improve portability,
remove unnecessary dependencies and fix a few cosmetical issues, also
fixed a flicker issue reported by Rene Liebscher.
1.0.3 Tomasz Wasilczyk contributed numerous fixes to correct eroneous
comparisons, compiler warnings and build issues.
1.0.2 More efficient byte comparison scheme.
1.0.1 Thanks to Grawity: fixed how the files were tarred together. Thanks to
pickledspiders: changed from -curses to -lcurses in the Makefile.
1.0.0 Initial Release by Julien McArdle (julien.im)
=========================================================
hexcompare-1.0.4/Makefile 000644 001752 000144 00000000322 12524440032 016171 0 ustar 00mateusz users 000000 000000 CFLAGS = -O3 -Wall -Wextra -pedantic -Wformat-security -std=gnu89
all: hexcompare
hexcompare: main.c gui.c
$(CC) $(CFLAGS) -o hexcompare main.c gui.c -lncurses
clean:
rm -f *.o
rm -f hexcompare
hexcompare-1.0.4/general.h 000644 001752 000144 00000001635 12524664723 016346 0 ustar 00mateusz users 000000 000000 /*
* This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
* Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see .
*/
#ifndef HEX_GENERAL
#define HEX_GENERAL
#include
#define PVER "1.0.4"
struct file {
char *name; /* File name */
FILE *pointer; /* File descriptor */
unsigned long size; /* File size */
};
#endif
hexcompare-1.0.4/Makefile.dos 000644 001752 000144 00000000565 12524676471 017010 0 ustar 00mateusz users 000000 000000 #
# This is a Makefile for building hexcompare on DOS using DJGPP.
#
# Requirements:
# * DJGPP v2.04 or newer
# * the pdcurses library
#
CFLAGS = -O3 -Wall -Wextra -pedantic -Wformat-security -std=gnu89
all: hexcomp.exe
hexcomp.exe: main.c gui.c
$(CC) $(CFLAGS) -o hexcomp.exe main.c gui.c -l:pdcurses.a
upx -9 hexcomp.exe
clean:
del hexcomp.exe
hexcompare-1.0.4/main.c 000644 001752 000144 00000004241 12524664712 015642 0 ustar 00mateusz users 000000 000000 /*
* This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
* Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see .
*/
#include
#include "general.h"
#include "gui.h"
int main(int argc, char **argv)
{
struct file file_one, file_two;
unsigned long largest_file_size;
char *message[] = {
"Arguments missing.\n",
"Usage:\n hexcompare file1 [file2]\n",
"Failed to open file \"%s\".\n"
};
/* Verify that we have enough input arguments. */
if (argc < 2) {
puts("hexcompare v" PVER "\n");
printf("%s%s", message[0], message[1]);
return 1;
}
/* Load in the file names. */
file_one.name = argv[1];
if (argc == 2) {
file_two.name = argv[1];
} else {
file_two.name = argv[2];
}
/* Open the files.
Present the user with an error message if they cannot be opened. */
if ((file_one.pointer = fopen(file_one.name, "rb")) == NULL) {
printf(message[2], file_one.name);
return 1;
}
if ((file_two.pointer = fopen(file_two.name, "rb")) == NULL) {
printf(message[2], file_two.name);
fclose(file_one.pointer);
return 1;
}
/* Get the file size */
fseek(file_one.pointer, 0, SEEK_END);
file_one.size = ftell(file_one.pointer);
fseek(file_two.pointer, 0, SEEK_END);
file_two.size = ftell(file_two.pointer);
/* Determine the largest file size */
largest_file_size = (file_one.size > file_two.size) ? file_one.size
: file_two.size;
/* Initiate the GUI display. */
start_gui(&file_one, &file_two, largest_file_size);
/* Close the files. */
fclose(file_one.pointer);
fclose(file_two.pointer);
/* Clean exit. */
return 0;
}
hexcompare-1.0.4/gui.h 000644 001752 000144 00000003215 12524674361 015510 0 ustar 00mateusz users 000000 000000 /*
* This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
* Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see .
*/
#ifndef HEX_GUI
#define HEX_GUI
#include
#include
#include
#include "general.h"
#define OVERVIEW_MODE 0
#define HEX_MODE 1
#define HEX_VIEW 0
#define ASCII_VIEW 1
#define BLOCK_SAME 1 /* Blue Box */
#define BLOCK_DIFFERENT 2 /* Red Box */
#define BLOCK_EMPTY 3 /* Grey Box */
#define BLOCK_ACTIVE 4 /* Green Box */
#define TITLE_BAR 5 /* Black text on White Background */
#define SIDE_MARGIN 2 /* Width of the side margins in chars */
#define VERTICAL_BLACK_SPACE 11 /* Sum of padding from top to bottom */
#define UP_ROW 2
#define DOWN_ROW -2
#define LEFT_BLOCK -1
#define RIGHT_BLOCK 1
#define UP_LINE 3
#define DOWN_LINE -3
/* If I'm not running PDCURSES, I assume it's going to be ncurses */
#ifndef __PDCURSES__
#define nc_getmouse getmouse
#endif
void start_gui(struct file *file_one, struct file *file_two,
unsigned long largest_file_size);
#endif