summaryrefslogtreecommitdiff
path: root/h64e
diff options
context:
space:
mode:
Diffstat (limited to 'h64e')
-rw-r--r--h64e/Makefile4
-rw-r--r--h64e/core.c562
-rw-r--r--h64e/core.h79
3 files changed, 645 insertions, 0 deletions
diff --git a/h64e/Makefile b/h64e/Makefile
new file mode 100644
index 0000000..074800b
--- /dev/null
+++ b/h64e/Makefile
@@ -0,0 +1,4 @@
+CC=gcc
+CFLAGS=
+make:
+ $(CC) -c core.c \ No newline at end of file
diff --git a/h64e/core.c b/h64e/core.c
new file mode 100644
index 0000000..8a8e2b0
--- /dev/null
+++ b/h64e/core.c
@@ -0,0 +1,562 @@
+#include "core.h"
+
+
+int h64e_set_default( h64e_t *fmt )
+{
+ if (NULL == fmt)
+ {
+ return -1;
+ }
+
+ fmt->flag_offset = 0;
+ fmt->offset_addr = 0;
+ fmt->column_size = 16;
+ fmt->flag_no_group = 0;
+ fmt->group = H64E_G_BYTE;
+ fmt->flag_output = 0;
+ fmt->output_type = H64E_O_NONE;
+
+ return 0;
+}
+
+int h64e_check_param( h64e_t *fmt )
+{
+ /* check NULL thats wrong */
+ if (fmt == NULL)
+ {
+ printf("Checked param is null\n");
+ return 0;
+ }
+
+ if (fmt->flag_output)
+ {
+ /* groupint and param shoudl match by size */
+ if (h64e_transform_sz(fmt)!=h64e_outpt_sz(fmt))
+ {
+ printf("Hex grouping and output type should match\n");
+ return 0;
+ }
+
+ /* if output type sec correctly */
+ if ((fmt->output_type<H64E_O_START) || (fmt->output_type>H64E_O_END))
+ {
+ printf("Unknown output type\n");
+ return 0;
+ }
+ }
+
+ return 1;
+}
+
+
+int h64e_output_line( h64e_t *fmt, uint8_t *buf, size_t size )
+{
+ int sz;
+ int err;
+
+ if (fmt == NULL || buf == NULL)
+ {
+ printf("NULL arguments\n");
+ return -1;
+ }
+
+ if (fmt->column_size != size)
+ {
+ printf("Column size value wrong\n");
+ return -1;
+ }
+
+ if (fmt->flag_offset)
+ {
+ printf("%08x: ", fmt->offset_addr );
+ }
+
+ sz = h64e_transform_sz( fmt );
+ err = h64e_outputf( fmt, buf, size/sz );
+ if (err != 0)
+ {
+ printf("Cannot output buffer\n");
+ return -1;
+ }
+
+ if (fmt->flag_offset)
+ {
+ fmt->offset_addr += size;
+ }
+
+ return 0;
+}
+
+int h64e_output_buffer( h64e_t *fmt, uint8_t *buf, size_t size)
+{
+ int i;
+ uint8_t clmn;
+
+ if (fmt == NULL || buf == NULL)
+ {
+ printf("fmt or buf is NULL\n");
+ return -1;
+ }
+
+ clmn = fmt->column_size;
+ i = 0;
+ do
+ {
+
+ if (i+clmn < size)
+ {
+ h64e_output_line( fmt, buf+i, clmn );
+ } else
+ {
+ if (fmt->flag_offset)
+ printf("%08x: ", fmt->offset_addr);
+
+ h64e_outputf_padding( fmt, buf+i, (size-i), fmt->column_size );
+ }
+ i += clmn;
+ } while (i<size);
+
+ return 0;
+}
+
+
+int h64e_transform_sz( h64e_t *fmt )
+{
+ if ( fmt == NULL )
+ return -1;
+
+ switch(fmt->group)
+ {
+ case H64E_G_BYTE:
+ return 1;
+ case H64E_G_WORD:
+ return 2;
+ case H64E_G_DWORD:
+ return 4;
+ case H64E_G_QWORD:
+ return 8;
+ default:
+ printf("Unknown transform type\n");
+ return -1;
+ }
+ return 1;
+}
+
+int h64e_outpt_sz( h64e_t *fmt )
+{
+ if (fmt == NULL)
+ {
+ return -1;
+ }
+
+ switch(fmt->output_type)
+ {
+ case H64E_O_NONE:
+ printf("Output type unset\n");
+ return -1;
+ case H64E_O_STRING:
+ case H64E_O_INT8:
+ case H64E_O_UINT8:
+ return 1;
+ case H64E_O_INT16:
+ case H64E_O_UINT16:
+ return 2;
+ case H64E_O_INT32:
+ case H64E_O_UINT32:
+ return 4;
+ case H64E_O_INT64:
+ case H64E_O_UINT64:
+ return 8;
+ default:
+ printf("Unknown output type\n");
+ return -1;
+ }
+
+ return 1;
+}
+
+int h64e_space_sz( h64e_t *fmt )
+{
+ if (fmt == NULL)
+ {
+ return -1;
+ }
+
+ switch(fmt->group)
+ {
+ case H64E_G_BYTE:
+ return 2;
+ case H64E_G_WORD:
+ return 4;
+ case H64E_G_DWORD:
+ return 8;
+ case H64E_G_QWORD:
+ return 16;
+ default:
+ printf("Unknown group type\n");
+ return 1;
+ }
+
+ return -1;
+}
+
+/* number of transform limbs there */
+int h64e_outputf( h64e_t *fmt, uint8_t *buf, size_t nsize )
+{
+ int i;
+ int tsz,osz;
+ trnf_clb tclb = NULL;
+ output_clb oclb = NULL;
+
+ if (fmt == NULL)
+ {
+ return -1;
+ }
+
+ /* output grouped hex values */
+ tsz = h64e_transform_sz( fmt );
+ tclb = h64e_trnf_fun( fmt );
+
+ if (!fmt->flag_no_group)
+ {
+ if (!tclb)
+ {
+ printf("Couldnt register callback\n");
+ return -1;
+ }
+ for (i=0; i<nsize; i++)
+ {
+ tclb(buf+i*tsz);
+ printf(" ");
+ }
+ }
+
+ /* output formated numbers */
+ if ( fmt->flag_output )
+ {
+ osz = h64e_outpt_sz( fmt );
+ oclb = h64e_outpt_fun( fmt );
+ if (fmt->flag_output)
+ {
+ if (!oclb)
+ {
+ printf("Couldnt register callback\n");
+ return -1;
+ }
+ for (i=0;i<nsize;i++)
+ {
+ oclb(buf+i*osz);
+ }
+ }
+ }
+
+ printf("\n");
+
+ return 0;
+}
+
+
+int h64e_read_req( h64e_t *fmt, uint8_t *buf, size_t size )
+{
+ return 0;
+}
+
+trnf_clb h64e_trnf_fun( h64e_t *fmt )
+{
+ uint8_t g;
+ if (fmt == NULL)
+ {
+ return NULL;
+ }
+
+ g = fmt->group;
+ switch (g)
+ {
+ case H64E_G_BYTE:
+ return trnf_byte;
+ case H64E_G_WORD:
+ return trnf_word;
+ case H64E_G_DWORD:
+ return trnf_dword;
+ case H64E_G_QWORD:
+ return trnf_qword;
+ default:
+ printf("Unsuported transformation func type\n");
+ return NULL;
+ }
+
+ return NULL;
+}
+
+output_clb h64e_outpt_fun( h64e_t *fmt )
+{
+ if (fmt == NULL)
+ {
+ return NULL;
+ }
+
+ switch (fmt->output_type)
+ {
+ case H64E_O_STRING:
+ return outpt_str;
+ case H64E_O_INT8:
+ return outpt_int8;
+ case H64E_O_UINT8:
+ return outpt_uint8;
+ case H64E_O_INT16:
+ return outpt_int16;
+ case H64E_O_UINT16:
+ return outpt_uint16;
+ case H64E_O_INT32:
+ return outpt_int32;
+ case H64E_O_UINT32:
+ return outpt_uint32;
+ case H64E_O_INT64:
+ return outpt_int64;
+ case H64E_O_UINT64:
+ return outpt_uint64;
+ case H64E_O_NONE:
+ return NULL;
+ default:
+ printf("Unknown output format\n");
+ return NULL;
+ }
+
+ return NULL;
+}
+
+/*
+when group have reminder deal with reminder in normal way
+nsize should be allways smaller then reminder
+*/
+int h64e_outputf_padding( h64e_t *fmt, uint8_t *buf, size_t nsize, int column )
+{
+ #define STATE_GROUP 1
+ #define STATE_SPACE 2
+ #define STATE_END 3
+ int i,j,acc_i,acc_j,run,state;
+ int tsz,osz,spacesz;
+ int group=0,space=0,sgroup=0;
+ trnf_clb tclb = NULL;
+ output_clb oclb = NULL;
+ unsigned char str[128]; //could blow in future
+
+ if (fmt == NULL)
+ {
+ return -1;
+ }
+
+ /* output grouped hex values */
+ tsz = h64e_transform_sz( fmt );
+ spacesz = h64e_space_sz( fmt );
+ tclb = h64e_trnf_fun( fmt );
+
+ if (!fmt->flag_no_group)
+ {
+ if (!tclb)
+ {
+ printf("Couldnt register callback\n");
+ return -1;
+ }
+
+ /* double counter */
+ i = 0; //count total
+ j = 0; acc_j=0;//count columns
+ run = 1;
+ state = STATE_GROUP;
+ while (run)
+ {
+ switch (state)
+ {
+ case STATE_GROUP:
+ if (acc_j<nsize)
+ {
+ printf("%02x", (unsigned char)(buf[acc_j]));
+ } else
+ {
+ printf(" ");
+ }
+ j += 1;
+ acc_j += 1;
+ if (j==tsz)
+ {
+ j = 0;
+ state = STATE_SPACE;
+ }
+ break;
+ case STATE_SPACE:
+ printf(" ");
+ if (acc_j == column)
+ {
+ state = STATE_END;
+ } else
+ {
+ state = STATE_GROUP;
+ }
+ break;
+ case STATE_END:
+ run = 0;
+ break;
+ default:
+ printf("Wrong state\n");
+ return -1;
+ }
+ }
+ }
+
+ /* output formated numbers */
+ if (fmt->flag_output)
+ {
+ osz = h64e_outpt_sz( fmt );
+ oclb = h64e_outpt_fun( fmt );
+ if (fmt->flag_output)
+ {
+ if (!oclb)
+ {
+ printf("Couldnt register callback\n");
+ return -1;
+ }
+ for (i=0;i<(nsize/tsz);i++)
+ {
+ oclb(buf+i*osz);
+ }
+ if ((nsize%tsz) != 0)
+ {
+ memset(str,0x00,sizeof(str));
+ memcpy(str+tsz-(nsize%tsz), buf+i*osz, nsize%tsz); //dirty calc
+ oclb(str);
+ }
+ }
+ }
+
+ printf("\n");
+
+ return 0;
+}
+
+int trnf_byte( char *buf )
+{
+ uint8_t *u = buf;
+
+ printf("%02x", u[0]);
+
+ return 0;
+}
+
+int trnf_word( char *buf )
+{
+ uint8_t *u = buf;
+
+ printf("%02x%02x", u[0], u[1]);
+
+ return 0;
+}
+
+int trnf_dword( char *buf )
+{
+ uint8_t *u = buf;
+
+ printf("%02x%02x%02x%02x", u[0], u[1], u[2], u[3]);
+
+ return 0;
+}
+
+int trnf_qword( char *buf )
+{
+ uint8_t *u = buf;
+
+ printf("%02x%02x%02x%02x%02x%02x%02x%02x", u[0], u[1], u[2], u[3], u[4], u[5], u[6], u[7]);
+
+ return 0;
+}
+
+int outpt_str( char *buf )
+{
+ uint8_t *s=buf;
+
+ if ( isprint(*s) )
+ {
+ printf("%c",*s);
+ } else
+ {
+ printf(".");
+ }
+
+ return 0;
+}
+
+
+int outpt_int8( char *buf )
+{
+ int8_t *i8=buf;
+
+ printf("%4i",*i8);
+
+ return 0;
+}
+
+
+int outpt_uint8( char *buf )
+{
+ uint8_t *u8=buf;
+
+ printf("%3d",*u8);
+
+ return 0;
+}
+
+
+int outpt_int16( char *buf )
+{
+ int16_t *i16 = (int16_t *)buf;
+
+ printf("%6hd ",*i16);
+
+ return 0;
+}
+
+
+int outpt_uint16( char *buf )
+{
+ uint16_t *u16 = (uint16_t *)buf;
+
+ printf("%5hu ",*u16);
+
+ return 0;
+}
+
+int outpt_int32( char *buf )
+{
+ int32_t *i32 = (int32_t *)buf;
+
+ printf("%9d ",*i32);
+
+ return 0;
+}
+
+int outpt_uint32( char *buf )
+{
+ uint32_t *u32 = (uint32_t *)buf;
+
+ printf("%8u ",*u32);
+
+ return 0;
+}
+
+int outpt_int64( char *buf )
+{
+ int64_t *i64 = (int64_t *)buf;
+
+ printf("%lld ",*i64);
+
+ return 0;
+}
+
+int outpt_uint64( char *buf )
+{
+ uint64_t *u64 = (uint64_t *)buf;
+
+ printf("%llu ",*u64);
+
+ return 0;
+}
diff --git a/h64e/core.h b/h64e/core.h
new file mode 100644
index 0000000..703c3aa
--- /dev/null
+++ b/h64e/core.h
@@ -0,0 +1,79 @@
+#ifndef __H64E_CORE_H
+#define __H64E_CORE_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <ctype.h>
+
+#define H64E_G_NONE 0
+#define H64E_G_BYTE 1
+#define H64E_G_WORD 2
+#define H64E_G_DWORD 3
+#define H64E_G_QWORD 4
+
+
+#define H64E_O_START 0
+#define H64E_O_NONE 0
+#define H64E_O_STRING 1
+#define H64E_O_INT8 2
+#define H64E_O_UINT8 3
+#define H64E_O_INT16 4
+#define H64E_O_UINT16 5
+#define H64E_O_INT32 6
+#define H64E_O_UINT32 7
+#define H64E_O_INT64 8
+#define H64E_O_UINT64 9
+#define H64E_O_END H64E_O_UINT64
+
+#define H64E_OK 0
+#define H64E_OESIZE 1 /*size mistmatch*/
+
+typedef int (*trnf_clb)(char*);
+typedef int (*output_clb)(char*);
+
+typedef struct h64e_t
+{
+ int flag_offset; /* output offset */
+ uint64_t offset_addr; /* offset postion */
+ uint8_t column_size; /* size of column to operate with */
+ int flag_no_group; /* dont output hex values */
+ uint8_t group; /* if there is need transdorm to specific type */
+ int flag_output; /* output convereted types */
+ uint8_t output_type; /* output in many different ways */
+} h64e_t;
+
+/* set default values */
+int h64e_set_default( h64e_t *fmt );
+/* check if all parametrs work well with each other */
+int h64e_check_param( h64e_t *fmt );
+int h64e_output( uint8_t *buf, size_t size );
+/* feed output to be printed out line by line */
+int h64e_output_line( h64e_t *fmt, uint8_t *buf, size_t size );
+/* feed output to be printed out as buffer */
+int h64e_output_buffer( h64e_t *fmt, uint8_t *buf, size_t size);
+int h64e_transform_sz( h64e_t *fmt );
+int h64e_outpt_sz( h64e_t *fmt );
+int h64e_space_sz( h64e_t *fmt );
+int h64e_outputf( h64e_t *fmt, uint8_t *buf, size_t nsize );
+int h64e_read_req( h64e_t *fmt, uint8_t *buf, size_t size );
+trnf_clb h64e_trnf_fun( h64e_t *fmt );
+output_clb h64e_outpt_fun( h64e_t *fmt );
+int h64e_outputf_padding( h64e_t *fmt, uint8_t *buf, size_t nsize, int column );
+
+int trnf_byte( char *buf );
+int trnf_word( char *buf );
+int trnf_dword( char *buf );
+int trnf_qword( char *buf );
+
+int outpt_str( char *buf );
+int outpt_int8( char *buf );
+int outpt_uint8( char *buf );
+int outpt_int16( char *buf );
+int outpt_uint16( char *buf );
+int outpt_int32( char *buf );
+int outpt_uint32( char *buf );
+int outpt_int64( char *buf );
+int outpt_uint64( char *buf );
+#endif \ No newline at end of file
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 09:00:51 +0000