saacproto_util.c

石器时代8.0服务端完整源代码。可以直接编译

		out[i] = src[i];
		if( src[i] == '\n' ){
			out[i+1] = '\0' ;
			return;
		}
		if( src[i] == '\0' )return;
	}
	saacproto_strcpysafe( out , "" , outlen );
}
// WON ADD
unsigned long saacproto_GetNewMessageID(void)

//unsigned int saacproto_GetNewMessageID(void)
{
	return saacproto.message_id++;
}
/*****************
  WRITE
   int flg : if 1, actually write. Otherwise no Network access
*****************/
void saacproto_DebugSend( int fd , char *msg )
{
	saacproto_Send( fd, msg );
}
void saacproto_Send( int fd , char *msg )
{
    char *encoded;
	if( saacproto_writelogfilename[0] != '\0' ){
		FILE *wfp = fopen( saacproto_writelogfilename , "a+" );
		if(wfp)fprintf( wfp , "%s\n", msg );
		if(wfp)fclose(wfp);
	}
#ifdef saacproto__ENCRYPT
    encoded = saacproto.cryptwork;
    saacproto_encodeString( msg , encoded , saacproto.workbufsize*3 );
#else
    encoded = msg;
#endif
	{
		/* add a newline character*/
		unsigned int l = strlen( encoded );
		if( l < saacproto.workbufsize *3){
			encoded[l] = '\n';
			encoded[l+1] = 0;
			l++;
		}
		saacproto.write_func( fd , encoded , l);
	}
}
/****************
  create a header which has function name and new Message ID
****************/
void saacproto_CreateHeader( char *out ,char *fname )
{
	sprintf( out ,"%u %s " , saacproto_GetNewMessageID() , fname );
}
void saacproto_CreateHeaderID( char *out,unsigned long msgid , char *fname )
{
	sprintf( out ,"%u %s " , (unsigned int)msgid , fname );
}
char *saacproto_Ltoa( long v )
{
	static char _ltoa_out[64];
	saacproto_cnv10to62( (int)v , _ltoa_out , sizeof( _ltoa_out ));
/*	sprintf( _ltoa_out , "%d" , (int)v );*/
	return _ltoa_out;
}
char *saacproto_Ultoa( unsigned long v )
{
	static char _ultoa_out[64];
	sprintf( _ultoa_out , "%u" , (unsigned int)v );
	return _ultoa_out;
}
/****************
   string address wrapper
****************/
char *saacproto_wrapStringAddr( char *copy , int maxcopylen , char*src )
{
	saacproto_strcpysafe( copy , src , maxcopylen );
	return copy;
}
/***************
 bzero buffer ( some OSs like win32 don't have bzero )
***************/
void saacproto_bzero( char *b , int siz )
{
	unsigned int i;
	int *p;
	p = (int*)b;
	for(i=0;i<siz/sizeof(int);i++) {
		*(p+i)=0;
	}
	for(i=0;i<siz%sizeof(int);i++) {
		*(b+siz-1-i)=0;
	}
}
/***************
    copy buffer
***************/
void saacproto_bcopy(char*s , char *d , int siz )
{
    unsigned int i;
    int *ps,*pd;
    ps = (int*)s;
    pd = (int*)d;
    for(i=0;i<siz/sizeof(int);i++) {
        *(pd+i) = *(ps+i);
    }
    for(i=0;i<siz%sizeof(int);i++) {
        *(d+siz-1-i)=*(s+siz-1-i);
    }
}
#ifdef saacproto__ENCRYPT
/* define function body only if the macro is set( but it's default) */
static void saacproto_encode64( unsigned char *in , int i, unsigned char *out );
static int saacproto_decode64( unsigned char *in , unsigned char *out );
static void saacproto_jDecode(char *src,int srclen,int key,char *decoded,int *decodedlen);
static void saacproto_jEncode(char *src,int srclen,int key,char *encoded,int *encodedlen,int maxencodedlen);
/*#define JENCODE_KEY    1000 */
int JENCODE_KEY = 1000;
/* translate original lsrpc text to code64 text */
static void saacproto_encodeString( char *src , char *out , int maxoutlen )
{
    int jencodedlen=0;
    long compressed_l = 0;
	int srclen = strlen( src ) + 1;
    int flag=srclen;
	if( srclen < 100 ){
		if( (int)srclen > (int)( saacproto.workbufsize*3-2) ){
			fprintf( stderr, "lsgen: badly configured work buflen\n" );
			exit(1);
		}
		if( (flag%2) == 1 ) flag ++;
		saacproto.compresswork[0] = flag;
		memcpy( saacproto.compresswork+1,src,srclen );
		compressed_l = srclen + 1;
	} else {
		if((flag%2)==0)flag++;
		saacproto.compresswork[0] = flag;
        compressed_l = saacproto_ringoCompressor(
            (unsigned char*)saacproto.compresswork + 1 ,
		    (long)saacproto.workbufsize*3 - 1,
            (unsigned char*)src ,
           (long)strlen(src) ) + 1;    /* be careful! */
	}
	/* return empty line if error or buffer excess */
	if( compressed_l <= 0 ){
		saacproto_strcpysafe( out , "\n" , maxoutlen );
		return;
	}
    memcpy( saacproto.jencodecopy ,saacproto.compresswork ,compressed_l );
    saacproto_jEncode( saacproto.jencodecopy , compressed_l , JENCODE_KEY ,
	    saacproto.jencodeout, &jencodedlen , saacproto.workbufsize*3 -1 );
    saacproto_encode64( (unsigned char*)saacproto.jencodeout , jencodedlen,  (unsigned char*)out );
}
/* translate code64 text to original lsrpc text */
static void saacproto_decodeString( char *src , char *out )
{
    int compressed_l =0, outlen64;
    int l;
    long decompressed_l = 0;
    /* copy src to copybuffer because jencoder modifies the input buffer */
    l = strlen( src );
    if( src[l-1]=='\n' || src[l-1]=='\r' )src[l-1]=0;
    if( src[l-2]=='\n' || src[l-2]=='\r' )src[l-2]=0;
    outlen64 = saacproto_decode64( (unsigned char*)src , (unsigned char*)saacproto.jencodecopy );
    saacproto_jDecode( saacproto.jencodecopy , outlen64 , JENCODE_KEY,
			saacproto.compresswork , &compressed_l);
    /*out[outlen]=0;  PENDING*/
    if( (saacproto.compresswork[0] % 2 ) == 0 ){
	    if( compressed_l <= 0 ){
			decompressed_l = 0;
			fprintf( stderr, "LSRPC: too short:[%s]\n", src );
		} else {
			memcpy( out, saacproto.compresswork+1, compressed_l -1 );
			decompressed_l = compressed_l -1;
		}
	} else {
        decompressed_l =
			saacproto_ringoDecompressor( (unsigned char*)out ,
                  	(long)saacproto.workbufsize ,
					(unsigned char*)saacproto.compresswork+1 ,
					(long)compressed_l -1 );
	}
    out[decompressed_l] = 0;
}
/* followings are taken from code64.c */
char saacproto_charset[64]={
    'A','B','C','D',    'E','F','G','H',
    'I','J','K','L',    'M','N','O','P',
    'Q','R','S','T',    'U','V','W','X',
    'Y','Z','a','b',    'c','d','e','f',
    'g','h','i','j',    'k','l','m','n',
    'o','p','q','r',    's','t','u','v',
    'w','x','y','z',    '0','1','2','3',
    '4','5','6','7',    '8','9','+','-'
};
char saacproto_reversecharset[256]={
    0,0,0,0, 0,0,0,0,
    0,0,0,0, 0,0,0,0,
    0,0,0,0, 0,0,0,0,
    0,0,0,0, 0,0,0,0,
    0,0,0,0, 0,0,0,0,
    0,0,0,62, 0,63,0,0,
    52,53,54,55, 56,57,58,59,
    60,61,0,0, 0,0,0,0,
    0,0,1,2, 3,4,5,6,
    7,8,9,10, 11,12,13,14,
    15,16,17,18, 19,20,21,22,
    23,24,25,0, 0,0,0,0,
    0,26,27,28, 29,30,31,32,
    33,34,35,36, 37,38,39,40,
    41,42,43,44, 45,46,47,48,
    49,50,51,0, 0,0,0,0,
    0,0,0,0,  0,0,0,0,
    0,0,0,0,  0,0,0,0,
    0,0,0,0,  0,0,0,0,
    0,0,0,0,  0,0,0,0,
    0,0,0,0,  0,0,0,0,
    0,0,0,0,  0,0,0,0,
    0,0,0,0,  0,0,0,0,
    0,0,0,0,  0,0,0,0,
    0,0,0,0,  0,0,0,0,
    0,0,0,0,  0,0,0,0,
    0,0,0,0,  0,0,0,0,
    0,0,0,0,  0,0,0,0,
    0,0,0,0,  0,0,0,0,
    0,0,0,0,  0,0,0,0,
    0,0,0,0,  0,0,0,0,
    0,0,0,0,  0,0,0,0
};

static void saacproto_encode64( unsigned char *in , int len , unsigned char *out )
{
    int i;
    int use_bytes;
    int address = 0;
    out[0] = 0;
    for(i=0;;i+=3){
        unsigned char in1 , in2 , in3;
        unsigned char out1 ,out2 , out3 , out4;
        if( i >= len ) break;
        if( i >= (len-1)){   /* the last letter ( to be thrown away ) */
            in1 = in[i] & 0xff;
            in2 = in3 = 0;
            use_bytes = 2;
        } else if( i >= (len-2)){ /* the last 2 letters ( process only 1 byte)*/
            in1 = in[i] & 0xff;
            in2 = in[i+1] & 0xff;
            in3 = 0;
            use_bytes = 3;
        } else {                /* there are more or equal than 3 letters */
            in1 = in[i] & 0xff;
            in2 = in[i+1] & 0xff;
            in3 = in[i+2] & 0xff;
            use_bytes = 4;
        }
        out1 = ((in1 & 0xfc)>>2) & 0x3f;
        out2 = ((in1 & 0x03)<<4) | ((( in2 & 0xf0)>>4)&0x0f);
        out3 = ((in2 & 0x0f)<<2) | ((( in3 & 0xc0)>>6)&0x03);
        out4 = (in3 & 0x3f );
        if( use_bytes >= 2 ){
            out[address++] = saacproto_charset[out1];
            out[address++] = saacproto_charset[out2];
            out[address]=0;
        }
        if( use_bytes >= 3 ){
            out[address++] = saacproto_charset[out3];
            out[address]=0;
        }
        if( use_bytes >= 4 ){
            out[address++] = saacproto_charset[out4];
            out[address]=0;
        }
    }
}
/*
 * Decode it
 * char *in : encoded ascii chars
 * char *out : decoded(  output)
 * return value : output byte count
 * 
 * note: no need to have bigger buffer. because output is to 
 * be smaller than input string size 
 */
static int saacproto_decode64( unsigned char *in , unsigned char *out )
{
    unsigned char in1 , in2 , in3 , in4;
    unsigned char out1 , out2 , out3;
    int use_bytes;
    int address= 0;
    int i;
    for(i=0;;i+=4 ){
        if( in[i] == 0 ){
            break;
        } else if( in[i+1] == 0 ){   /* the last letter */
            break;
        } else if( in[i+2] == 0 ){   /* the last 2 letters */
            in1 = saacproto_reversecharset[in[i]];
            in2 = saacproto_reversecharset[in[i+1]];
            in3 = in4 = 0;
            use_bytes = 1;
        } else if( in[i+3] == 0 ){   /* the last  3 letters */
            in1 = saacproto_reversecharset[in[i]];
            in2 = saacproto_reversecharset[in[i+1]];
            in3 = saacproto_reversecharset[in[i+2]];
            in4 = 0;
            use_bytes = 2;
        } else {   /* process 4 letters */
            in1 = saacproto_reversecharset[in[i]];
            in2 = saacproto_reversecharset[in[i+1]];
            in3 = saacproto_reversecharset[in[i+2]];
            in4 = saacproto_reversecharset[in[i+3]];
            use_bytes = 3;
        }
        out1 =  (in1<<2) | (((in2 & 0x30)>>4)&0x0f) ;
        out2 =  ((in2 & 0x0f )<<4) | ((( in3 & 0x3c)>>2)&0x0f);
        out3 =  ( (in3 &0x03)<<6) |  ( in4 & 0x3f );
        if( use_bytes >= 1 ){
            out[address++] = out1;
        }
        if( use_bytes >= 2 ){
            out[address++] = out2;
        }
        if( use_bytes >= 3 ){
            out[address++] = out3;
        }
        if( use_bytes != 3 ){
            break;
        }
    }
    return address;
}

/* followings are taken from Jencode.c by jun */
static void saacproto_jEncode(char *src,int srclen,int key,char *encoded,int *encodedlen,int maxencodedlen)
{
	char sum=0;
	int i;
	if(srclen+1 > maxencodedlen){
		*encodedlen = maxencodedlen;
		for(i=0;i<(*encodedlen);i++)encoded[i] = src[i];
	}
	if(srclen+1 <= maxencodedlen){
		*encodedlen=srclen+1;
		for(i=0;i<srclen;i++){
			sum = sum + src[i];
			if(((key%7) == (i%5))||((key%2) == (i%2))) src[i] = ~src[i];
		}
		for(i=0;i<(*encodedlen);i++){
			if(abs((key%srclen)) > i) encoded[i] = src[i] + sum*((i*i)%3); 
			if(abs((key%srclen)) == i) encoded[i] = sum;
			if(abs((key%srclen)) < i) encoded[i] = src[i-1] + sum*((i*i)%7);	
		}
	}
}
static void saacproto_jDecode(char *src,int srclen,int key,char *decoded,int *decodedlen)
{
	char sum=0;
	int i;
	*decodedlen=srclen-1;
	if( *decodedlen == 0 ){
		return;		/* return error if length is 0 */
	}
	sum = src[abs(key%(*decodedlen))];
	for(i=0;i<srclen;i++){
		if(abs((key%(*decodedlen))) > i) decoded[i] = src[i] - sum*((i*i)%3);
		if(abs((key%(*decodedlen))) < i) decoded[i-1] = src[i] - sum*((i*i)%7);
	}
	for(i=0;i<(*decodedlen);i++){
		if(((key%7) == (i%5))||((key%2) == (i%2)))decoded[i] = ~decoded[i];
	}
}

/*****************************************************************/
/*       Compress / Decompress routine                           */
/*****************************************************************/	
#define B00000000 0
#define B00000001 1
#define B00000010 2
#define B00000011 3
#define B00000100 4
#define B00000101 5
#define B00000110 6
#define B00000111 7
#define B00001000 8
#define B00001001 9
#define B00001010 10
#define B00001011 11
#define B00001100 12
#define B00001101 13
#define B00001110 14
#define B00001111 15
#define B00010000 16
#define B00010001 17
#define B00010010 18
#define B00010011 19
#define B00010100 20
#define B00010101 21
#define B00010110 22
#define B00010111 23
#define B00011000 24
#define B00011001 25
#define B00011010 26
#define B00011011 27
#define B00011100 28
#define B00011101 29
#define B00011110 30
#define B00011111 31
#define B00100000 32
#define B00100001 33
#define B00100010 34
#define B00100011 35
#define B00100100 36
#define B00100101 37
#define B00100110 38
#define B00100111 39
#define B00101000 40
#define B00101001 41
#define B00101010 42
#define B00101011 43
#define B00101100 44
#define B00101101 45
#define B00101110 46
#define B00101111 47
#define B00110000 48
#define B00110001 49
#define B00110010 50
#define B00110011 51
#define B00110100 52
#define B00110101 53
#define B00110110 54
#define B00110111 55
#define B00111000 56
#define B00111001 57
#define B00111010 58
#define B00111011 59
#define B00111100 60
#define B00111101 61
#define B00111110 62
#define B00111111 63
#define B01000000 64
#define B01000001 65
#define B01000010 66
#define B01000011 67
#define B01000100 68
#define B01000101 69
#define B01000110 70
#define B01000111 71
#define B01001000 72
#define B01001001 73
#define B01001010 74
#define B01001011 75
#define B01001100 76
#define B01001101 77
#define B01001110 78
#define B01001111 79
#define B01010000 80
#define B01010001 81
#define B01010010 82
#define B01010011 83
#define B01010100 84
#define B01010101 85
#define B01010110 86
#define B01010111 87
#define B01011000 88
#define B01011001 89
#define B01011010 90
#define B01011011 91
#define B01011100 92
#define B01011101 93
#define B01011110 94
#define B01011111 95
#define B01100000 96
#define B01100001 97
#define B01100010 98
#define B01100011 99
#define B01100100 100
#define B01100101 101
#define B01100110 102
#define B01100111 103
#define B01101000 104
#define B01101001 105
#define B01101010 106
#define B01101011 107
#define B01101100 108
#define B01101101 109
#define B01101110 110
#define B01101111 111
#define B01110000 112
#define B01110001 113
#define B01110010 114
#define B01110011 115
#define B01110100 116
#define B01110101 117