int parse_data_pair(const char *data, int isStr)
{
char buff[1024] = {0};
struct data_pair *pdata = &g_data_pair[g_data_num];
char *temp = NULL;
if(data == NULL || data[0] == 0) {
g_data_num = 0;
memset(&g_data_pair, 0, sizeof(g_data_pair));
return 0;
}
while(*data == ' ') data++;
strcpy(buff, data);
temp = buff;
if((temp = strtok(temp, "|")) == NULL) {
return -1;
}
memset(pdata, 0, sizeof(struct data_pair));
if(isStr) {
pdata->data1[0] = strlen(temp)+1;
strcpy(&pdata->data1[1], temp);
} else {
pdata->data1[0] = (unsigned char)convert_to_bin((char*)(pdata->data1+1), sizeof(pdata->data1)-1, temp, 3, "%02X ");
}
if(pdata->data1[0] == 0) {
return -1;
}
g_data_num++;
if((temp = strtok(NULL, "|")) == NULL) {
return 0;
}
while(*temp == ' ') temp++;
if(isStr) {
pdata->data2[0] = strlen(temp)+1;
strcpy(&pdata->data2[1], temp);
} else {
pdata->data2[0] = (unsigned char)convert_to_bin((char*)(pdata->data2+1), sizeof(pdata->data2)-1, temp, 3, "%02X ");
}
return 0;
}
sc_lv_base::sc_lv_base( const char* a )
: m_len( 0 ), m_size( 0 ), m_data( 0 ), m_ctrl( 0 )
{
std::string s = convert_to_bin( a );
init( s.length() - 1 );
assign_from_string( s );
}
char* create_data ( char **blocks, int **cor_blocks, int version ) //up
{
int i;
int j;
int var = 0;
char *data;
char *buf;
int size;
int col = 0;
int extra_size;
int number = number_of_blocks[version];
col+=size_of_information[version];
col+=number_of_correction_byte[version] * 8 * number;
data = ( char* )calloc(col + 1, sizeof(char) );
buf = ( char* )calloc(8 + 1, sizeof(char) );
if ( ( data == NULL ) || ( buf == NULL ) )
{
fprintf( stderr, "Can't allocate memory\n" );
exit(1);
}
data[col] = '\0';
data[8] = '\0';
size = (size_of_information[version] / 8) / number; //number byte in block
extra_size = (size_of_information[version] / 8) % number; //extra byte
for ( i = 0; i < size; i++) //blocks
{
for ( j = 0 ; j < number; j++)
{
memcpy ( &data[var], &blocks[j][i*8], 8 );
var+=8;
}
}
for ( i = 0; i < extra_size; i++ ) //extra blocks
{
data[var] = blocks[number - 1][i];
memcpy ( &data[var], &blocks[number - 1][i*8], 8 );
var+=8;
}
for ( i = 0; i < number_of_correction_byte[version]; i++) //correction
{
for ( j = 0 ; j < number; j++)
{
buf = convert_to_bin ( cor_blocks[j][i+1], 8 );
memcpy( &data[var], buf, 8 );
var+=8;
}
}
return data;
}
int main(int argc, char **argv)
{
parse_options( argc, argv);
if (b_to_binary == 0)
{
convert_to_res();
}
else
{
convert_to_bin();
}
printf("\n");
return 0;
}
char* convert_to_utf8( char *str ) //convert int to utf8 binary
{
int i;
char *str_bin;
int length;
str_bin = ( char* )calloc( strlen( str ) * 8 + 1, sizeof( char ) ); //for bin str
if ( str_bin == NULL )
{
fprintf( stderr, "Can't allocate memory\n" );
exit(1);
}
length = strlen( str );
for ( i = 0; i < length; i++ )
memcpy( str_bin + i * 8, convert_to_bin( str[i], 8 ), 8 * sizeof( char ) ); //copy binary code
str_bin[strlen( str ) * 8] = '\0'; //end of string
return str_bin;
}
sc_lv_base&
sc_lv_base::operator = ( const char* a )
{
assign_from_string( convert_to_bin( a ) );
return *this;
}
sc_lv_base::sc_lv_base( const char* a, int length_ )
: m_len( 0 ), m_size( 0 ), m_data( 0 ), m_ctrl( 0 )
{
init( length_ );
assign_from_string( convert_to_bin( a ) );
}
char* add_service_inf(char *str, int* ver) //service information and addition string to full size
{
int data = 4; //service data (bit) = coding method(4 bit) + size of data(8 or 16 bit)
int zero;
int extra = 0; //extra byte
int buffer;
int length;
int i;
char *str_full;
char *zero_str;
if ( *ver <= 9 ) //length of data field
data+=8;
else
data+=16;
length = strlen( str );
if ( ( length + data ) > ( size_of_information[*ver] ) ) //if big size
{
( *ver )++;
data = 4;
if ( *ver <= 9 ) //length of data field again, because version changed
data+=8;
else
data+=16;
}
zero = (strlen( str ) + data )%8; //number of zero until str%8 != 0
zero_str = ( char* )calloc( zero + 1, sizeof( char ) );
if ( zero_str == NULL )
{
fprintf( stderr, "Can't allocate memory\n" );
exit(1);
}
zero_str[zero] = '\0';
memset( zero_str, ( char )((int)'0'), zero ); //initializing array
buffer = ( strlen( str ) + data + zero - size_of_information[*ver] );
if ( buffer < 0 )
extra = -buffer/8; //number of extra byte
str_full = ( char* )calloc( strlen( str ) + data + zero + extra*8 + 1, sizeof(char) ); //new str full
if ( str_full == NULL )
{
fprintf( stderr, "Can't allocate memory\n" );
exit(1);
}
str_full[strlen( str ) + data + zero + extra*8] = '\0';
strcpy(str_full, "0100"); //add coding method
strcpy(&str_full[4], convert_to_bin(strlen( str ) / 8, data - 4 )); //add size of data
strcpy(&str_full[data], str); //add data(bit)
strcpy(&str_full[data + strlen(str)], zero_str); //add zero
for (i = 0; i < extra; i++) //add extra byte
{
if (i%2 == 0)
strcpy(&str_full[data + strlen(str) + zero + i*8], "11101100");
else
strcpy(&str_full[data + strlen(str) + zero + i*8], "00010001");
}
return str_full;
}
