osmith
/
wireshark
forked from osmocom/wireshark
1
0
Fork 0
Code Pull Requests Releases Wiki Activity
wireshark/epan/int-64bit.c

552 lines
14 KiB
C
Raw Blame History

/* int-64bit.c
* Routines for handling of 64-bit integers
* 2001 Ronnie Sahlberg
*
* $Id: int-64bit.c,v 1.3 2002/08/28 20:40:44 jmayer Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* 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 2
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <string.h>
#include "int-64bit.h"
/* all functions take the 64bit integer parameter as a
pointer to a 64bit integer in network order.
that is ptr[0] is the most significant byte and
ptr[7] is the least significant byte.
*/
#define U64STRLEN 21
/* this must be signed. if it is not clear why, please dont
modify the functions in this file. it will break.
*/
static const signed char u64val[64][U64STRLEN] =
{
/* 1 */ { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 2 */ { 2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 3 */ { 4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 4 */ { 8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 5 */ { 6,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 6 */ { 2,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 7 */ { 4,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 8 */ { 8,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 9 */ { 6,5,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 10 */ { 2,1,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 11 */ { 4,2,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 12 */ { 8,4,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 13 */ { 6,9,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 14 */ { 2,9,1,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 15 */ { 4,8,3,6,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 16 */ { 8,6,7,2,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 17 */ { 6,3,5,5,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 18 */ { 2,7,0,1,3,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 19 */ { 4,4,1,2,6,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 20 */ { 8,8,2,4,2,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 21 */ { 6,7,5,8,4,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 22 */ { 2,5,1,7,9,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 23 */ { 4,0,3,4,9,1,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 24 */ { 8,0,6,8,8,3,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 25 */ { 6,1,2,7,7,7,6,1,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 26 */ { 2,3,4,4,5,5,3,3,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 27 */ { 4,6,8,8,0,1,7,6,0,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 28 */ { 8,2,7,7,1,2,4,3,1,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 29 */ { 6,5,4,5,3,4,8,6,2,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 30 */ { 2,1,9,0,7,8,6,3,5,0,0,0,0,0,0,0,0,0,0,0,0 },
/* 31 */ { 4,2,8,1,4,7,3,7,0,1,0,0,0,0,0,0,0,0,0,0,0 },
/* 32 */ { 8,4,6,3,8,4,7,4,1,2,0,0,0,0,0,0,0,0,0,0,0 },
/* 33 */ { 6,9,2,7,6,9,4,9,2,4,0,0,0,0,0,0,0,0,0,0,0 },
/* 34 */ { 2,9,5,4,3,9,9,8,5,8,0,0,0,0,0,0,0,0,0,0,0 },
/* 35 */ { 4,8,1,9,6,8,9,7,1,7,1,0,0,0,0,0,0,0,0,0,0 },
/* 36 */ { 8,6,3,8,3,7,9,5,3,4,3,0,0,0,0,0,0,0,0,0,0 },
/* 37 */ { 6,3,7,6,7,4,9,1,7,8,6,0,0,0,0,0,0,0,0,0,0 },
/* 38 */ { 2,7,4,3,5,9,8,3,4,7,3,1,0,0,0,0,0,0,0,0,0 },
/* 39 */ { 4,4,9,6,0,9,7,7,8,4,7,2,0,0,0,0,0,0,0,0,0 },
/* 40 */ { 8,8,8,3,1,8,5,5,7,9,4,5,0,0,0,0,0,0,0,0,0 },
/* 41 */ { 6,7,7,7,2,6,1,1,5,9,9,0,1,0,0,0,0,0,0,0,0 },
/* 42 */ { 2,5,5,5,5,2,3,2,0,9,9,1,2,0,0,0,0,0,0,0,0 },
/* 43 */ { 4,0,1,1,1,5,6,4,0,8,9,3,4,0,0,0,0,0,0,0,0 },
/* 44 */ { 8,0,2,2,2,0,3,9,0,6,9,7,8,0,0,0,0,0,0,0,0 },
/* 45 */ { 6,1,4,4,4,0,6,8,1,2,9,5,7,1,0,0,0,0,0,0,0 },
/* 46 */ { 2,3,8,8,8,0,2,7,3,4,8,1,5,3,0,0,0,0,0,0,0 },
/* 47 */ { 4,6,6,7,7,1,4,4,7,8,6,3,0,7,0,0,0,0,0,0,0 },
/* 48 */ { 8,2,3,5,5,3,8,8,4,7,3,7,0,4,1,0,0,0,0,0,0 },
/* 49 */ { 6,5,6,0,1,7,6,7,9,4,7,4,1,8,2,0,0,0,0,0,0 },
/* 50 */ { 2,1,3,1,2,4,3,5,9,9,4,9,2,6,5,0,0,0,0,0,0 },
/* 51 */ { 4,2,6,2,4,8,6,0,9,9,9,8,5,2,1,1,0,0,0,0,0 },
/* 52 */ { 8,4,2,5,8,6,3,1,8,9,9,7,1,5,2,2,0,0,0,0,0 },
/* 53 */ { 6,9,4,0,7,3,7,2,6,9,9,5,3,0,5,4,0,0,0,0,0 },
/* 54 */ { 2,9,9,0,4,7,4,5,2,9,9,1,7,0,0,9,0,0,0,0,0 },
/* 55 */ { 4,8,9,1,8,4,9,0,5,8,9,3,4,1,0,8,1,0,0,0,0 },
/* 56 */ { 8,6,9,3,6,9,8,1,0,7,9,7,8,2,0,6,3,0,0,0,0 },
/* 57 */ { 6,3,9,7,2,9,7,3,0,4,9,5,7,5,0,2,7,0,0,0,0 },
/* 58 */ { 2,7,8,5,5,8,5,7,0,8,8,1,5,1,1,4,4,1,0,0,0 },
/* 59 */ { 4,4,7,1,1,7,1,5,1,6,7,3,0,3,2,8,8,2,0,0,0 },
/* 60 */ { 8,8,4,3,2,4,3,0,3,2,5,7,0,6,4,6,7,5,0,0,0 },
/* 61 */ { 6,7,9,6,4,8,6,0,6,4,0,5,1,2,9,2,5,1,1,0,0 },
/* 62 */ { 2,5,9,3,9,6,3,1,2,9,0,0,3,4,8,5,0,3,2,0,0 },
/* 63 */ { 4,0,9,7,8,3,7,2,4,8,1,0,6,8,6,1,1,6,4,0,0 },
/* 64 */ { 8,0,8,5,7,7,4,5,8,6,3,0,2,7,3,3,2,2,9,0,0 }
};
/* convert an unsigned 64 bit integer into a string
it is important that this function is efficient
since it will be used for every 64bit integer in
any capture.
It is much less important that the inverse: atou64
be efficient since it is only called when
diplayfilters are entered.
"neg" should be 1 if the number should have a "-" put in
front of it.
*/
static char *
n64toa(const unsigned char *u64ptr, int neg)
{
unsigned char acc[U64STRLEN]; /* accumulator */
int i,j,k,pos;
static char str[U64STRLEN+1]; /* 1 extra for the sign */
/* clear out the accumulator */
for(i=0;i<U64STRLEN-1;i++){
acc[i]=0;
}
pos=0;
/* loop over the 8 bytes of the 64bit integer,
lsb to msb */
for(i=7;i>=0;i--){
/* optimize, most of these bytes will be 0 ?*/
if(u64ptr[i]==0){
pos+=8;
} else {
for(j=0;j<8;j++,pos++){
if(u64ptr[i]&(1<<j)){
for(k=0;k<U64STRLEN-1;k++){
acc[k]+=u64val[pos][k];
}
}
}
}
/* we must handle carries inside this loop
since othevise the signed char in acc will
owerflow/wrap, but we dont need to do it
for every iteration. its enough if we
do it halfway through and at the end
and we will prevent any overflow.
*/
if((i%4)==0){
/* handle carries */
for(j=0;j<U64STRLEN-1;j++){
if(acc[j]>9){
int x;
x=acc[j]/10;
acc[j+1]+=x;
acc[j]-=x*10;
}
}
}
}
/* convert to a string */
str[U64STRLEN-1+neg]=0;
for(i=0;i<U64STRLEN-1;i++){
str[U64STRLEN-2-i+neg]='0'+acc[i];
}
/* skip the initial zeros */
for(i=0;i<U64STRLEN-2;i++){
if(str[i+neg]>'0'){
break;
}
}
/* insert the sign */
if (neg)
str[i] = '-';
return str+i;
}
/*
* Convert an unsigned 64-bit integer into a string, in decimal.
*/
char *
u64toa(const unsigned char *u64ptr)
{
/*
* Just use "n64toa()".
*/
return n64toa(u64ptr, 0);
}
/*
* Convert a signed 64-bit integer into a string, in decimal.
*/
char *
i64toa(const unsigned char *i64ptr)
{
unsigned char neg[8];
int i;
int carry;
int byte;
/*
* The bytes of the integer go from msb to lsb, so the
* msb is "i64ptr[0]".
*
* The sign bit, therefore, is "i64ptr[0] & 0x80".
*/
if (i64ptr[0] & 0x80) {
/*
* It's negative - compute the absolute value,
* by taking the two's complement; take the
* one's complement of the low-order byte, add
* 1, take the one's complement of the next byte
* up, add the carry from the previous addition,
* etc.
*
* If it's the maximum negative value, which is
* 0x8000000000000000, this will turn it back
* into 0x8000000000000000, which "n64toa()"
* will handle correctly, reporting the absolute
* value of the maximum negative value;
* thus, we don't have to worry about it.
*/
carry = 1;
for (i = 7; i >= 0; i--) {
byte = ((unsigned char)~i64ptr[i]) + carry;
neg[i] = byte;
if (byte & 0x100)
carry = 1;
else
carry = 0;
}
/*
* Use "n64toa()" on the negative, and tell it to insert
* a "-".
*/
return n64toa(neg, 1);
} else {
/*
* It's positive, so just use "n64toa()".
*/
return n64toa(i64ptr, 0);
}
}
/* like memcmp but compares in reverse */
static int
revcmp(const signed char *s1, const signed char *s2, int len)
{
int i;
for(i=len-1;i>=0;i--){
if(s1[i]==s2[i]){
continue;
}
if(s1[i]>s2[i]){
return 1;
} else {
return -1;
}
}
return 0;
}
/*
* Convert a string to an unsigned 64-bit integer.
*/
unsigned char *
atou64(const char *u64str, unsigned char *u64int)
{
signed char res[U64STRLEN]; /* residual */
int i,j,len;
const char *strp;
if(!u64str){
return NULL;
}
/* if it is a hex string */
if( (u64str[0]=='0')
&& (u64str[1]=='x') ){
return htou64(u64str, u64int);
}
/* verify that the string is ok */
for(strp=u64str;*strp;strp++){
if((*strp>='0')&&(*strp<='9')){
continue;
}
return NULL;
}
/* clear the result vector */
for(i=0;i<8;i++){
u64int[i]=0;
}
/* clear the residual string and copy the
original to it (subtracting '0')
*/
for(i=0;i<U64STRLEN;i++){
res[i]=0;
}
while(*u64str=='0'){ /* skip initial blanks */
u64str++;
}
len=strlen(u64str)-1;
for(i=0;len>=0;i++,len--){
res[i]=u64str[len]-'0';
}
/* go through all bits and subtract their
value */
for(i=63;i>=0;i--){
if(revcmp(u64val[i], res, U64STRLEN)<=0){
u64int[7-(i>>3)]|=(1<<(i&0x07));
for(j=0;j<U64STRLEN;j++){
res[j]-=u64val[i][j];
/*underflow*/
if(res[j]<0){
res[j]+=10;
res[j+1]-=1;
}
}
}
}
return u64int;
}
/*
* Convert a string to a signed 64-bit integer.
*/
unsigned char *
atoi64(const char *i64str, unsigned char *i64int)
{
int i;
int carry;
int byte;
if(!i64str){
return NULL;
}
/*
* Does it begin with a minus sign?
*/
if (i64str[0] == '-') {
/*
* Yes - convert the rest of the string to a number...
*/
if (atou64(&i64str[1], i64int) == NULL) {
/*
* We failed.
*/
return NULL;
}
/*
* ...and then take its negative.
*/
carry = 1;
for (i = 7; i >= 0; i--) {
byte = ((unsigned char)~i64int[i]) + carry;
i64int[i] = byte;
if (byte & 0x100)
carry = 1;
else
carry = 0;
}
return i64int;
} else {
/*
* No - just let "atou64()" handle it.
*/
return atou64(i64str, i64int);
}
}
/*
* Convert an unsigned 64-bit integer to a string, in hex.
*/
char *
u64toh(const unsigned char *u64ptr)
{
static char str[19], *strp;
static char ntoh[] = {'0','1','2','3','4','5','6','7',
'8','9','a','b','c','d','e','f'};
int i;
str[0]='0';
str[1]='x';
strp=str+2;
for(i=0;i<8;i++){
*strp++ = ntoh[u64ptr[i]>>4];
*strp++ = ntoh[u64ptr[i]&0x0f];
}
*strp=0;
return str;
}
static unsigned int
ntoh(unsigned char h)
{
if((h>='0')&&(h<='9')){
return h-'0';
}
if((h>='A')&&(h<='F')){
return h+10-'A';
}
if((h>='a')&&(h<='f')){
return h+10-'a';
}
return 0;
}
/*
* Convert a hex string to an unsigned 64-bit integer.
*/
unsigned char *
htou64(const char *u64str, unsigned char *u64int)
{
int i,len;
char str[16];
const char *strp;
if(!u64str){
return NULL;
}
/* verify that the string is ok */
if( (u64str[0]!='0')
|| (u64str[1]!='x') ){
return NULL;
}
for(strp=u64str+2;*strp;strp++){
if((*strp>='0')&&(*strp<='9')){
continue;
}
if((*strp>='A')&&(*strp<='F')){
continue;
}
if((*strp>='a')&&(*strp<='f')){
continue;
}
return NULL;
}
/* clear the result vector */
for(i=0;i<8;i++){
u64int[i]=0;
}
/* get len of input string */
for(len=0,strp=u64str+2;len<16;len++,strp++){
if((*strp>='0')&&(*strp<='9')){
continue;
}
if((*strp>='A')&&(*strp<='F')){
continue;
}
if((*strp>='a')&&(*strp<='f')){
continue;
}
break;
}
for(i=0;i<16;i++){
str[i]='0';
}
for(i=0;i<len;i++){
str[15-i]=u64str[len+1-i];
}
for(i=0;i<8;i++){
u64int[i]=(ntoh(str[i*2])<<4)
| ntoh(str[1+i*2]);
}
return u64int;
}
#ifdef TEST_DEBUG
#include <stdio.h>
int main(void)
{
char i998877665544331[8] =
{0x0, 0x23, 0x7c, 0xbd, 0x4c, 0x49, 0xd5, 0x6f};
char iminus9988776655443311[8] =
{0xff, 0xdc, 0x83, 0x42, 0xb3, 0xb6, 0x2a, 0x91};
char i9223372036854775807[8] =
{0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
char iminus1[8] =
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
char iminus9223372036854775808[8] =
{0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
char u9223372036854775808[8] =
{0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
char u18446744073709551615[8] =
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
char u0xaabbccdd00112233[8] =
{0xaa, 0xbb, 0xcc, 0xdd, 0x0, 0x11, 0x22, 0x33};
char t[8];
printf("%s (9988776655443311)\n",i64toa(i998877665544331));
printf("%s (-9988776655443311)\n",i64toa(iminus9988776655443311));
printf("%s (9223372036854775807)\n",i64toa(i9223372036854775807));
printf("%s (-1)\n",i64toa(iminus1));
printf("%s (-9223372036854775808)\n",i64toa(iminus9223372036854775808));
printf("%s (9988776655443311)\n",u64toa(i998877665544331));
printf("%s (9223372036854775807)\n",u64toa(i9223372036854775807));
printf("%s (9223372036854775808)\n",u64toa(u9223372036854775808));
printf("%s (18446744073709551615)\n",u64toa(u18446744073709551615));
printf("%s (0xaabbccdd00112233)\n",u64toh(u0xaabbccdd00112233));
printf("%s (55443311)\n",i64toa(atoi64("55443311",t)));
printf("%s (-55443311)\n",i64toa(atoi64("-55443311",t)));
printf("%s (9988776655443311)\n",i64toa(atoi64("9988776655443311",t)));
printf("%s (-9988776655443311)\n",i64toa(atoi64("-9988776655443311",t)));
printf("%s (9223372036854775807)\n",i64toa(atoi64("9223372036854775807",t)));
printf("%s (-1)\n",i64toa(atoi64("-1",t)));
printf("%s (-9223372036854775808)\n",i64toa(atoi64("-9223372036854775808",t)));
printf("%s (55443311)\n",u64toa(atou64("55443311",t)));
printf("%s (0x55443311)\n",u64toh(htou64("0x55443311",t)));
return 0;
}
#endif
View Git Blame Copy Permalink