/*
* Mausezahn - A fast versatile traffic generator
* Copyright (C) 2008 Herbert Haas
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License version 2 as published by the
* Free Software Foundation.
*
* 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 http://www.gnu.org/licenses/gpl-2.0.html
*
*/
///////////////////////////////////////////////////////////////////////////////////////////
//
// Contains various tools for hex-based conversions and manipulation of bytestrings
//
// str2hex_mac ..... converts "00:01:02:0a:ff:ff" into u_int8_t dst[6]
// str2hex ..... converts "1a 00:00-2f" into u_int8_t dst[n] (any length)
// num2hex ..... converts "192.16.1.1" into u_int8_t dst[4]
// bs2str ..... converts {0,1,10} into "00-01-0A"
// getbytes ..... a stupid implementation of memcpy - prefer memcpy instead !!!
// str2ip32 ..... converts "192.168.0.1" into 3232235521 (u_int32_t)
// str2ip32_rev ..... same but assumes network byte order
// type2str ..... converts a u_int16_t into a string, e. g. 0x800 into "08:00"
//
////////////////////////////////////////////////////////////////////////////////////////////
#include "mz.h"
// converts MAC address specified in str into u_int8_t array
// Usage: str2hex_mac ( "00:01:02:aa:ff:ee", src_addr )
// Returns 1 if specified MAC address string is invalid, 0 upon success.
int str2hex_mac(char* str, u_int8_t *addr)
{
char *hs;
int i;
unsigned int test;
char tmp[32];
strcpy(tmp,str); // necessary because strtok cannot operate on fixed strings
hs=(char*)strtok(tmp,"-:., ");
for (i=0; i<6; i++)
{
test = (unsigned int) strtol (hs, NULL, 16);
if (test>0xff) return 1;
addr[i]=(u_int8_t) strtol (hs, NULL, 16);
hs = strtok(NULL,"-:., ");
if ( (hs == NULL ) && (i!=5) )
{
// Not a valid MAC address
return 1;
}
}
if (hs!=NULL) return 1; // more than 6 bytes
return 0;
}
// Converts ascii hex values (string) into integer array
// For example "1a 00:00-2f" will be converted to {26, 0, 0, 47}
//
// NOTE: n ist the max number of bytes to be converted
//
// RETURN VALUE: number of bytes converted
// or -1 upon failure
//
int str2hex(char* str, u_int8_t *hp, int n)
{
char *hs;
int curval,i;
if (strlen(str)==0) return 0;
char tmp[8192]=""; //for very long payloads
strncpy(tmp,str,8191); // necessary because strtok cannot operate on fixed strings
hs=(char*)strtok(tmp,"-:., ");
i=0;
do
{ n--;
curval=strtol(hs,NULL,16);
if (curval>0xff) return -1;
hp[i]=(u_int8_t) curval;
i++;
}
while ((n) && ((hs=(char*)strtok(NULL,"-:., "))!= NULL));
return i; // return the length of the array
}
// Converts ascii numbers (terminated string) into integer array
// Every byte can be specified as integers {0..255}
// For example "192.16.1.1" will be converted to {C0, 10, 01, 01}
//
// NOTE: Returns the number of converted bytes!
int num2hex(char* str, u_int8_t *hp)
{
char *hs;
int i;
unsigned int curval;
if (strlen(str)==0) return 0;
char tmp[8192]=""; //for very long payloads
strncpy(tmp,str,8192); // necessary because strtok cannot operate on fixed strings
hs = (char*) strtok (tmp,"-:., ");
i=0;
do
{
curval = (unsigned int) str2int(hs);
if (curval<256)
{
hp[i] = (u_int8_t) curval;
i++;
}
}
while ((hs=(char*)strtok(NULL,"-:., "))!= NULL);
//hp[i]='\0'; // termination not necessary
return i;
}
// Convert array of integers into string of hex
// E.g. {0,1,10} => "00-01-0A"
// Useful for verification messages.
int bs2str(u_int8_t *bs, char* str, int len)
{
int i;
char t[4];
str[0]='\0';
for (i=0; i<len; i++)
{
// if (bs[i]<16) strcat(str,"0"); // enforce two hex digits (e.g. "0a")
sprintf(t,"%02x:",bs[i]);
strcat(str,t);
}
str[strlen(str)-1]='\0'; //remove the last ":"
return 1;
}
// Extract contiguous sequence of bytes from an array
// NOTE: first element has number 1 !!!
// THIS IS DEPRECATED: PREFER memcpy INSTEAD !!!
int getbytes(u_int8_t *source,
u_int8_t *target,
int from,
int to)
{
int i;
// Check wrong arguments
if (from<1)
{
return -1;
}
// copy bytes
for (i=0; i<(to-from+1); i++)
{
target[i]=source[from-1+i];
}
return 1;
}
// Converts an IP address given in 'dotted decimal' into an unsigned 32-bit integer
// Example: "192.168.0.1" => 3232235521
u_int32_t str2ip32 (char* str)
{
u_int32_t ip = 0;
unsigned int a,b,c,d;
int r;
// check whether str really contains an IP address
if (strlen(str)<3) return 0;
if (str==NULL) return 0;
if ((r=sscanf(str,"%i.%i.%i.%i",&a,&b,&c,&d))==0) return 0;
if (r==EOF) return 0;
/* or an alternative method...
// these are the four bytes of a dotted decimal notation IP address:
a = (unsigned int) strtol(strtok(str,"."), (char **)NULL, 10);
b = (unsigned int) strtol(strtok(NULL,"."), (char **)NULL, 10);
c = (unsigned int) strtol(strtok(NULL,"."), (char **)NULL, 10);
d = (unsigned int) strtol(strtok(NULL,"."), (char **)NULL, 10);
*/
if ((a>255)||(b>255)||(c>255)||(d>255)) return 0;
ip = d + 256*c + 256*256*b + 256*256*256*a;
//check with:
//printf("str2ip32 got 4 bytes: %i %i %i %i\n",a,b,c,d);
//printf("str2ip32 returned %u\n",ip);
return ip;
}
// Converts an IP address given in 'dotted decimal' into an unsigned 32-bit integer
// This version does the same as str2ip32() but in 'network byte order'
u_int32_t str2ip32_rev (char* str)
{
u_int32_t ip = 0;
unsigned int a,b,c,d;
int r;
// check whether str really contains an IP address
if (strlen(str)<3) return 0;
if (str==NULL) return 0;
if ((r=sscanf(str,"%i.%i.%i.%i",&a,&b,&c,&d))==0) return 0;
if (r==EOF) return 0;
/* or an alternative method...
// these are the four bytes of a dotted decimal notation IP address:
a = (unsigned int) strtol(strtok(str,"."), (char **)NULL, 10);
b = (unsigned int) strtol(strtok(NULL,"."), (char **)NULL, 10);
c = (unsigned int) strtol(strtok(NULL,"."), (char **)NULL, 10);
d = (unsigned int) strtol(strtok(NULL,"."), (char **)NULL, 10);
*/
if ((a>255)||(b>255)||(c>255)||(d>255)) return 0;
ip = a + b*256 + c*256*256 + d*256*256*256;
//check with:
//printf("str2ip32 got 4 bytes: %i %i %i %i\n",a,b,c,d);
//printf("str2ip32 returned %u\n",ip);
return ip;
}
// Converts a 2-byte value (e. g. a EtherType field)
// into a nice string using hex notation.
// Useful for verification messages.
// Example: type2str (tx.eth_type, msg) may result in msg="08:00"
// Return value: how many hex digits have been found.
int type2str(u_int16_t type, char *str)
{
char hex[8];
int i=0;
(void) sprintf (hex, "%x",type);
i=strlen(hex);
switch (i)
{
case 1:
str[0]='0';
str[1]='0';
str[2]=':';
str[3]='0';
str[4]=hex[0];
str[5]='\0';
break;
case 2:
str[0]='0';
str[1]='0';
str[2]=':';
str[3]=hex[0];
str[4]=hex[1];
str[5]='\0';
break;
case 3:
str[0]='0';
str[1]=hex[0];
str[2]=':';
str[3]=hex[1];
str[4]=hex[2];
str[5]='\0';
break;
case 4:
str[0]=hex[0];
str[1]=hex[1];
str[2]=':';
str[3]=hex[2];
str[4]=hex[3];
str[5]='\0';
break;
}
return i;
}