showbinary.cpp

以16进制形式显示二进制文件

#include "stdafx.h"

#include "memory.h"
#include <string.h>


#if 1
/*
	I found that vi cannot show binary file in a graceful way. So I decide to
	code a segment of program to show binary files like UltraEdit. Very simple.
	It will output the file's every bytes to standard output and let other tools
	such as "more", "grep" (linux), and so on to deal with it.
*/
 
#define BUFFERSIZE	1024
#define COL		16
static int iteration = BUFFERSIZE/COL;
#define VISUAL_BEGIN	0x20	/* the ascii '!' */
#define VISUAL_END	0x7E	/* the ascii '~' */ 


int main(int argc, char* argv[])
{
	FILE *fd;
	char buffer[BUFFERSIZE+2];
	int i, j;
	unsigned char visual;
	int ret; 
	unsigned long count = 0;
	int bufferpointer;
	int line; 
	if (argc != 2) {
		printf("Usage: %s <binary file name>\n", argv[0]);
		return 1;
	} 
	fd = fopen(argv[1], "r+b");
	if (fd == NULL ) {
		printf("error in opening %s\n", argv[1]);
		return 1;
	} 
	do { 
		ret = fread((void*)buffer, 1, BUFFERSIZE, fd); 
		if (ret < 0) {
			printf( "error in reading %s\n", argv[1]);
			break;
		}
		if (ret == 0) { /* eof */
			break;
		}
		bufferpointer = 0; 
		line = ret/COL;
		for (i = 0; i < line; i++) {
			printf("%8XH: ", count);
			for (j = 0; j < COL; j++) {
				visual = buffer[bufferpointer];
				printf("%2X ", (unsigned short)visual & 0x00FF);
				++count;
				++bufferpointer;
			}
			printf("; "); /* now show the visual ascii in the same line */
			bufferpointer -= COL;
			for (j = 0; j < COL; j++) {
				visual = buffer[bufferpointer];
				if (visual < VISUAL_BEGIN  || visual > VISUAL_END ) {
					printf(".");
				} else {
					printf("%c", visual);
				}
				++bufferpointer;
			}
			printf("\n"); /* finish a line */
		}
		if ( ret < BUFFERSIZE ) {
			int frag = ret % COL;
			printf("%8XH: ", count);
			for (j = 0; j < COL; j++) {
				if (bufferpointer >= ret) {
					printf("   ");
				} else {
					visual = buffer[bufferpointer];
					printf("%2X ", (unsigned short)visual & 0x00FF);
				}
				++count;
				++bufferpointer;
			}
			printf("; ");
			bufferpointer -= COL;
			for (j = 0; j < COL; j++) { 
				if (bufferpointer >= ret) {
					break;
				}
				if (visual < VISUAL_BEGIN || visual > VISUAL_END) {
					printf(".");
				} else {
					visual = buffer[bufferpointer];
					printf("%c", visual);
				}
				++bufferpointer;
			}
			printf("\n");
		}
	} while (1);
	fclose(fd);
	return 0;
}

#endif /* #if 0 */

#if 0
/* 
   i need a mp4 file parser, so i build this project. it will detect the file structure
   and display the result as following format:
     
     name ---------------------------------start : end  [ len  ]

     ftyp ---------------------------------000000:000020[000020]
	 moov ---------------------------------000020:000062[000042]
	     mvhd -----------------------------000028:000040[000012]
	 ......
*/

#define BUF_SIZE	    1024*4
#define VISUAL_BEGIN	0x20	/* the ascii '!' */
#define VISUAL_END	    0xFE	/* the ascii '~' */ 
#define ATOMSIZE	    200
#define	DEPTH		    9 

FILE* fd;
int filelen;
unsigned char buf[BUF_SIZE]; 
int buf_pos; 

typedef struct atom_t
{
	char name[5];
	int start;
	int len;
	int level; /* 0: top level */ 
} atom;

atom atom_array[ATOMSIZE];
int cur_atom_p;
 
void printStruct(int start, int len) /* print struct in ASCii style */
{
	;
}
 


int getNBytes( unsigned char* b, int start, int N)
{ 
	/* try to copy 8 bytes from buf[] into b[].
	   if buf[] can't satisfy our need, update it right now.*/
	if(start >= buf_pos && start + N <= BUF_SIZE + buf_pos ){
		memcpy(b, buf + start - buf_pos, N);
		return 1;
	}
	 
	if( fseek(fd, start, SEEK_SET) != 0) {
		printf("\nget8Bytes: error in seeking to %d\n", start); 
		return 0;
	} 

	/* read BUF_SIZE bytes from mp4 file */
	if( fread(buf, BUF_SIZE, 1, fd) <= 0 ) {
		printf("\nget8Bytes: error in reading\n"); 
		return 0;
	}
	memcpy(b, buf, N);
	buf_pos = start;
	return 1;
}

int get8Bytes( unsigned char* b, int start)
{ 
	return getNBytes( b,  start, 8);
}
void print_atom(int i)
{
		int lev;
		lev = atom_array[i].level; 
//		printf("%2d) ", lev); 
		while(lev>0){
			lev--;
			printf("  ");
		};
		printf("%s ", atom_array[i].name); 
		lev = 33 - atom_array[i].level;
		while(lev>0) {
			lev--;
			printf("--");
		};
		printf(" %.6d:%.6d [%5d]\n", atom_array[i].start, atom_array[i].start + atom_array[i].len, atom_array[i].len);  
}

void print_atom_array()
{
	int lev;
	printf("\tMP4file parsing result: [a: [e-mail]]\n");
	for(int i=0;i<cur_atom_p;i++)
	{
		lev = atom_array[i].level;
		while(lev>0){
			lev--;
			printf(" ");
		};
		printf("[%.6d]%s ", atom_array[i].len, atom_array[i].name); 
		lev = 63 - atom_array[i].level;
		while(lev>0) {
			lev--;
			printf("-");
		};
		printf(" %.6d:%.6d\n", atom_array[i].start, atom_array[i].start + atom_array[i].len); 
	}
	printf("\tMP4file parsing finished.\n");
}

int isNormalSize( unsigned char *buff, int max_len)
{
	int len_ = buff[ 3 ]; 
	unsigned int len = buff[ 2 ];
	len_ += len<<8;
	len = buff[ 1 ];
	len_ += len<<16;
	len = buff[0];
	len_ += len<<24;
	atom_array[cur_atom_p].len = len_;
	if( len_ >= 8 && len_ <= max_len ) return len_;
	return 0;
}
int isVisual4Letters( unsigned char *buff )
{
	unsigned char letter;
	for(int i = 0; i< 4; i++){
		letter = buff[ i ];
		if( letter < VISUAL_BEGIN || letter > VISUAL_END)  return 0; 
		atom_array[cur_atom_p].name[i] = letter;
	}
	atom_array[ cur_atom_p ].name[4] = 0;
	return 1;
}

int isNormalAtom(int start_, int max_len)
{
	unsigned char buffer[8];
	if( get8Bytes( buffer, start_ ) ==0 ) {
		printf("\nbuffer error\n\n");
		return 0;
	}

	if( isNormalSize(buffer, max_len) == 0 ) return 0;
	if( isVisual4Letters(buffer+4) == 0 ) return 0;
	return 1;
}

void seekAtom(int start_, int len_, int level_ )
{
	int brother_start, brother_len; 

	if( isNormalAtom(start_, len_ ) == 0 ) {
		return;       /*it's not a atom*/
	}
	atom_array[cur_atom_p].level = level_; 
	atom_array[cur_atom_p].start = start_; 
	brother_start = start_ + atom_array[cur_atom_p].len;
	brother_len   = len_   - atom_array[cur_atom_p].len; 
	
	print_atom(cur_atom_p);
	cur_atom_p++;
	if(cur_atom_p >= ATOMSIZE) {
		printf("so many atoms found in the file!\n");
		return;
	}

	/* seek child atom(s) */
	if( atom_array[cur_atom_p-1].len >= 16 )
	{
		if( level_ < DEPTH)
		{ 
			seekAtom(start_ + 8, atom_array[cur_atom_p-1].len - 8, level_+1 ); 
		}
	}

	/* seek brother(s) */
	if(  brother_len == 0 ) { /* End Of Fragment */
		return;
	}
	if( brother_len < 8 ) 
	{
		printf("wrong file format! maybe.\n");
		return;
	}	
	seekAtom( brother_start, brother_len, level_  );
}

void parse_mp4(char* filename)
{
	fd = fopen(filename, "r+b");
	if( fd==NULL ) {
		printf("error in opening %s\n", filename);
		return;
	}

	/*get file length */
	if( fseek(fd, 0, SEEK_END) != 0) {
		printf("error in seeking %s\n", filename);
		fclose(fd);
		return;
	}
	filelen = ftell(fd);
	if(filelen<0) {
		fclose(fd);
		printf("error in getting %s's length\n", filename);
		return;
	} 
	if( fseek(fd,0, SEEK_SET) != 0) {
		printf("error in seeking %s\n", filename);
		fclose(fd);
		return;
	} 

	/* read BUF_SIZE/3 bytes from mp4 file */
	if( fread(buf, BUF_SIZE, 1, fd) <= 0 ) {
		printf("error in reading %s\n", filename);
		fclose(fd);
		return;
	}

	/* seek atoms in the buffer */
	cur_atom_p = 0; 
	buf_pos = 0;
	seekAtom(0, filelen, 0 );
	/* print_atom_array(); */
}

int main(int argc, char* argv[])
{
	if (argc != 2) {
		printf("Usage: %s <file name>\n", argv[0]);
		return 1;
	}
	parse_mp4(argv[1]);	
	return 1;
}

#endif