lssproto_util.c

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

#define _LSSPROTOUTIL_C_
#include "version.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef WIN32
#include <unistd.h>
#include <strings.h>
#endif
#include "lssproto_util.h"
//ttom +2 for degug
#define IS_2BYTEWORD( _a_ ) ( (char)(0x80) <= (_a_) && (_a_) <= (char)(0xFF) )

#include "common.h"
#ifdef lssproto__ENCRYPT
long lssproto_ringoCompressor( unsigned char *code , long codelen , unsigned char *text , long textlen);
long lssproto_ringoDecompressor( unsigned char *text , long textlen , unsigned char *code , long codelen);
#endif
/*
  lsrpc routines
*/
int lssproto_AllocateCommonWork(int bufsiz)
{
	lssproto.workbufsize = bufsiz;
	lssproto.work = NULL;
	lssproto.arraywork = NULL;
	lssproto.escapework = NULL;
	lssproto.val_str = NULL;
	lssproto.token_list = NULL;
	lssproto.cryptwork = NULL;
	lssproto.jencodecopy = NULL;
	lssproto.jencodeout = NULL;
	lssproto.compresswork = NULL;
	lssproto.work = (char*)calloc( 1, lssproto.workbufsize );
	lssproto.arraywork = (char*)calloc( 1, lssproto.workbufsize );
	lssproto.escapework = (char*)calloc( 1, lssproto.workbufsize );
	lssproto.val_str = (char*)calloc( 1, lssproto.workbufsize );
	lssproto.token_list = (char**)calloc( 1, lssproto.workbufsize *sizeof( char** ) );
	lssproto.cryptwork = (char*)calloc( 1, lssproto.workbufsize * 3 );
	lssproto.jencodecopy = (char*)calloc( 1, lssproto.workbufsize * 3 );
	lssproto.jencodeout = (char*)calloc( 1, lssproto.workbufsize * 3 );
	lssproto.compresswork = (char*)calloc( 1, lssproto.workbufsize * 3 );
	memset( lssproto.work , 0, lssproto.workbufsize );
	memset( lssproto.arraywork , 0, lssproto.workbufsize );
	memset( lssproto.escapework , 0, lssproto.workbufsize );
	memset( lssproto.val_str , 0, lssproto.workbufsize );
	memset( (char*)lssproto.token_list ,0,  lssproto.workbufsize*sizeof(char**) );
	memset( lssproto.cryptwork , 0, lssproto.workbufsize*3 );
	memset( lssproto.jencodecopy , 0, lssproto.workbufsize*3 );
	memset( lssproto.jencodeout , 0, lssproto.workbufsize*3 );
	memset( lssproto.compresswork , 0, lssproto.workbufsize*3 );
	if( lssproto.work == NULL ||
	   lssproto.arraywork == NULL ||
	   lssproto.escapework == NULL ||
	   lssproto.val_str == NULL ||
	   lssproto.token_list == NULL ||
	   lssproto.cryptwork == NULL ||
	   lssproto.jencodecopy == NULL ||
	   lssproto.jencodeout == NULL ||
	   lssproto.compresswork == NULL ){
	    free( lssproto.work);free( lssproto.val_str);
	    free( lssproto.escapework);free( lssproto.arraywork );
	    free( lssproto.token_list);free( lssproto.cryptwork );
	    free( lssproto.jencodecopy);free( lssproto.jencodeout );
	    free( lssproto.compresswork );
	    return -1;
	}
	return 0;
}
/**********
  Get message information from a network input
**********/
void lssproto_GetMessageInfo( int *id , char *funcname , int len, char **tk )
{
	if( tk[0] == NULL || tk[1] == NULL ){
		*id = 0;
		lssproto_strcpysafe( funcname , "" , len );
		return;
	}
	*id =  strtoul( tk[0] ,NULL,10);
	lssproto_strcpysafe( funcname , tk[1] , len );
	return;
}
/********************************************
  string utilities
*********************************************/
void lssproto_strcpysafe( char *dest, char *src, int maxlen )
{
	int i;
	for(i=0;i<maxlen-1;i++){
		dest[i] = src[i];
		if( src[i]==0)break;
	}
	dest[i]=0;
}
void lssproto_strcatsafe( char *dest , char *src , int maxlen )
{
	int i,j;
	for(i=0;i<maxlen-1;i++){
		if( dest[i] == 0 ){
			for(j=i;j<maxlen-1;j++){
				dest[j]= src[j-i];
				if( src[j-i] == 0 )break;
			}
			dest[j]=0;
			break;
		}
	}
}
char*lssproto_mkstr_int( int i )
{
#define MKSTR_INT(v) lssproto_Ltoa( (long)(v)) 
	lssproto_strcpysafe( lssproto.val_str ,  (char*)MKSTR_INT(i) , lssproto.workbufsize );
	lssproto_strcatsafe( lssproto.val_str ," " , lssproto.workbufsize );
	return lssproto.val_str;
}
char*lssproto_mkstr_u_int( unsigned int i )
{
#define MKSTR_U_INT(v) lssproto_Ultoa( (unsigned long ) (v) )
	lssproto_strcpysafe( lssproto.val_str , MKSTR_U_INT(i) , lssproto.workbufsize );
	lssproto_strcatsafe( lssproto.val_str ," " , lssproto.workbufsize );
	return lssproto.val_str;
}
char*lssproto_mkstr_long( long l )
{
#define MKSTR_LONG(v) lssproto_Ltoa( v ) 
	lssproto_strcpysafe( lssproto.val_str , MKSTR_LONG(l) , lssproto.workbufsize );
	lssproto_strcatsafe( lssproto.val_str ," " , lssproto.workbufsize );
	return lssproto.val_str;
}
char*lssproto_mkstr_u_long( unsigned long l )
{
#define MKSTR_U_LONG(v) lssproto_Ultoa(v ) 
	lssproto_strcpysafe( lssproto.val_str , MKSTR_U_LONG(l) , lssproto.workbufsize );
	lssproto_strcatsafe( lssproto.val_str ," " , lssproto.workbufsize );
	return lssproto.val_str;	
}
char*lssproto_mkstr_short( short s )
{
#define MKSTR_SHORT16(v)    lssproto_Ltoa( (long)((int)(v) ))
	lssproto_strcpysafe( lssproto.val_str , MKSTR_SHORT16(s) , lssproto.workbufsize );
	lssproto_strcatsafe( lssproto.val_str ," " , lssproto.workbufsize );
	return lssproto.val_str;	
}
char*lssproto_mkstr_u_short( short s )
{
#define MKSTR_U_SHORT16(v)   lssproto_Ltoa( (long)(  ((long)(v)) & 0xffff ))
	lssproto_strcpysafe( lssproto.val_str , MKSTR_U_SHORT16(s) , lssproto.workbufsize );
	lssproto_strcatsafe( lssproto.val_str ," " , lssproto.workbufsize );
	return lssproto.val_str;	
}
char*lssproto_mkstr_char( char c )
{
#define MKSTR_CHAR8(v)   lssproto_Ltoa( ( long)((int)(v)))
	lssproto_strcpysafe( lssproto.val_str , MKSTR_CHAR8(c) , lssproto.workbufsize );
	lssproto_strcatsafe( lssproto.val_str ," ", lssproto.workbufsize );
	return lssproto.val_str;	
}
char*lssproto_mkstr_u_char( char c)
{
#define MKSTR_U_CHAR8(v)   lssproto_Ltoa( (long)( ((long)(v)) & 0xff ))
	lssproto_strcpysafe( lssproto.val_str , MKSTR_U_CHAR8(c) , lssproto.workbufsize );
	lssproto_strcatsafe( lssproto.val_str ," "  , lssproto.workbufsize );
	return lssproto.val_str;
}
char*lssproto_mkstr_string( char*a )
{
	char *ret = lssproto_escapeString( a );
	lssproto_strcatsafe( ret , " ", lssproto.workbufsize );
	return ret;
}
char*lssproto_mkstr_float(float f )
{
	sprintf( lssproto.val_str , "%f " , f );
	return lssproto.val_str;
}
char*lssproto_mkstr_double( double d )
{
	sprintf( lssproto.val_str , "%f " , d );
	return lssproto.val_str;
}
char*lssproto_mkstr_int_array( int size , int *array )
{
#define MKSTR_ARRAYMACRO( func) \
	{\
		 int i;\
         lssproto.arraywork[0] = '\0';\
		 for(i=0;i<size;i++){   \
             lssproto_strcatsafe( lssproto.arraywork , func(array[i]) , lssproto.workbufsize );\
		 }\
         return lssproto.arraywork;\
    }\

	MKSTR_ARRAYMACRO( lssproto_mkstr_int );
}
char*lssproto_mkstr_u_int_array( int size , int *array )
{
	MKSTR_ARRAYMACRO( lssproto_mkstr_u_int );
}
char*lssproto_mkstr_short_array( int size , short *array )
{
	MKSTR_ARRAYMACRO( lssproto_mkstr_short );
}
char*lssproto_mkstr_u_short_array( int size , short *array )
{
	MKSTR_ARRAYMACRO( lssproto_mkstr_u_short );
}
char *lssproto_mkstr_char_array( int size , char *array )
{
	MKSTR_ARRAYMACRO( lssproto_mkstr_char );
}
char *lssproto_mkstr_u_char_array( int size , unsigned char *array )
{
	MKSTR_ARRAYMACRO( lssproto_mkstr_u_char );
}
char *lssproto_mkstr_float_array( int size , float *array )
{
	MKSTR_ARRAYMACRO( lssproto_mkstr_float );
}
char *lssproto_mkstr_double_array( int size , double *array )
{
	MKSTR_ARRAYMACRO( lssproto_mkstr_double );
}
/*********************
   translate string into base types
*********************/
int lssproto_demkstr_int( char*a )
{
	if( a == (char*)NULL)return 0;
/*	return (int)strtol( a ,NULL , 10);*/
	return lssproto_a62toi( a );
}
unsigned int lssproto_demkstr_u_int( char*a )
{
	if( a == (char*)NULL)return 0;
	return (unsigned int ) strtoul( a ,NULL,10);
}
long lssproto_demkstr_long( char*a )
{
	if( a == (char*)NULL)return 0;
	return (long)strtol( a , NULL , 10 );
}
unsigned long lssproto_demkstr_u_long(char*a )
{
	if( a == (char*)NULL)return 0;
	return (unsigned long ) strtoul( a , NULL , 10 ) ;
}
short lssproto_demkstr_short( char*a )
{
	if( a == (char*)NULL)return 0;
	return (short) strtol( a , NULL , 10 );
}
unsigned short lssproto_demkstr_u_short( char*a )
{
	if( a == (char*)NULL)return 0;
	return (unsigned short) strtoul( a , NULL , 10 );
}
char lssproto_demkstr_char( char*a )
{
	if( a == (char*)NULL)return 0;
	return (char) strtol(  a  , NULL , 10 );
}
unsigned char lssproto_demkstr_u_char( char*a )
{
	if( a == (char*)NULL)return 0;
	return (unsigned char ) strtoul( a,NULL , 10 );
}
float lssproto_demkstr_float( char*a )
{
	if( a == (char*)NULL)return 0.0F;
	return (float) atof( a);
}
double lssproto_demkstr_double(char*a )
{
	if( a == (char*)NULL)return 0.0F;
	return (double) strtod( a , NULL );
}
char* lssproto_demkstr_string( char*a)
{
	if( a == (char*)NULL){
		lssproto_strcpysafe( lssproto.escapework , "" , lssproto.workbufsize );
		return lssproto.escapework;
	}
	return lssproto_descapeString( a );
}
int *lssproto_demkstr_int_array( char**tk ,int *buf  ,int start , int size )
{
#define DEMKSTR_ARRAYMACRO( func, defaultvalue )          \
    {\
        int i;\
        for(i=start;i<(start+size);i++){\
            if( tk[i] == NULL ){   \
		        buf[i-start]=defaultvalue ;\
            } else {\
     	 	    buf[i-start] = func( tk[i] );\
            }\
	    }\
        return buf;\
    }
    DEMKSTR_ARRAYMACRO( lssproto_demkstr_int , 0 );
}
int *lssproto_demkstr_u_int_array( char **tk , int *buf , int start , int size )
{
	DEMKSTR_ARRAYMACRO( lssproto_demkstr_u_int , 0 );
}
unsigned int *lssproto_demkstr_long_array(
 char **tk , unsigned int *buf , int start , int size )
{
	DEMKSTR_ARRAYMACRO( lssproto_demkstr_long  , 0);
}
unsigned long *lssproto_demkstr_u_long_array(
 char **tk , unsigned long *buf , int start , int size )
{
	DEMKSTR_ARRAYMACRO( lssproto_demkstr_u_long , 0);
}
short *lssproto_demkstr_short_array( char **tk , short *buf , int start , int size )
{
	DEMKSTR_ARRAYMACRO( lssproto_demkstr_short , 0);
}
unsigned short* lssproto_demkstr_u_short_array( 
 char **tk , unsigned short *buf , int start , int size )
{
	DEMKSTR_ARRAYMACRO( lssproto_demkstr_u_short , 0);
}
char *lssproto_demkstr_char_array( char **tk , char *buf , int start , int size )
{
	DEMKSTR_ARRAYMACRO( lssproto_demkstr_u_char , 0);
}
unsigned char *lssproto_demkstr_u_char_array( 
char **tk , unsigned char*buf , int start , int size )
{
	DEMKSTR_ARRAYMACRO( lssproto_demkstr_u_char , 0);
}
float *lssproto_demkstr_float_array( char **tk , float *buf , int start , int size )
{
	DEMKSTR_ARRAYMACRO( lssproto_demkstr_float , (float)0.0);
}
double *lssproto_demkstr_u_double_array( char **tk , double *buf , int start , int size )
{
	DEMKSTR_ARRAYMACRO( lssproto_demkstr_double , (double)0.0);
}
char*  lssproto_escapeString( char*a )
{
	int i,c=0;
	lssproto.escapework[0] = '\0';
	for(i=0;;i++){
		if( a[i] == '\0' ){
			lssproto.escapework[c++] = '\0';
			break;
		} else if( ( char )0x80 <= a[i] && a[i] <= ( char )0xFF ){
		        // for 2 Byte Word
		        lssproto.escapework[c++] = a[i++];
		        lssproto.escapework[c++] = a[i];
		} else if( a[i] == '\\' ){
			lssproto.escapework[c++] = '\\';
			lssproto.escapework[c++] = '\\';
		} else if( a[i] == ' ' ){
			lssproto.escapework[c++] = '\\';
			lssproto.escapework[c++] = 'S';
		} else if( a[i] == '\n' ){
			lssproto.escapework[c++] = '\\';
			lssproto.escapework[c++] = 'n';
		} else if( a[i] == '\r' ){
			lssproto.escapework[c++] = '\\';
			lssproto.escapework[c++] = 'r';
		} else {
			lssproto.escapework[c++] = a[i];
		}
	}
	return lssproto.escapework;
}
char* lssproto_descapeString( char*a )
{
	int i ,c =0;
	lssproto.escapework[0] = '\0';
	for(i=0;;i++){
		if( a[i] == '\0' ){
			lssproto.escapework[c++]='\0';
			break;
		} else if( (char)0x80 <= a[i] && a[i] <= (char)0xFF ){
		        // for 2 Byte Word
		        lssproto.escapework[c++] = a[i++];
		        lssproto.escapework[c++] = a[i];
		} else if( a[i] == '\\' ){
		        if( a[i+1] == 0 ){     /* null */
		                lssproto.escapework[c++] = a[i];
		                continue;
		        }
		        if( a[i+1] == 'S' ){     /* space */
				lssproto.escapework[c++] = ' ';
			} else if( a[i+1] == 'n' ){
				lssproto.escapework[c++] = '\n';
			} else if( a[i+1] == 'r' ){
				lssproto.escapework[c++] = '\r';
			} else if( a[i+1] == '\\' ){
				lssproto.escapework[c++] = '\\';
			} else {
				lssproto.escapework[c++] = a[i];
			}
			i++;           
		} else {
			lssproto.escapework[c++] = a[i];
		}
	}
	return lssproto.escapework;
}
/*
   This function works only when char*src is escaped
   NOTICE: Effects and Modifies the contents of char*src!
   NOTICE : Ends the output token list with NULL pointer
Ex:
        v out[0]       v out[1]
  "     asdjfhasfdasdf asdf asf asdf "
 */
#ifdef lssproto__ENCRYPT
static void lssproto_decodeString( char *src , char *out );
static void lssproto_encodeString( char *src , char *out , int maxoutlen );
#endif
void lssproto_splitString( char *src  )
{
	int i,c=0;
	char *decoded;
	
#ifdef lssproto__ENCRYPT
	decoded = lssproto.cryptwork;
	lssproto_decodeString( src , decoded );
#else
	decoded = src;
#endif


	if( lssproto_readlogfilename[0] != '\0'){
		FILE *rfp;
		rfp = fopen( lssproto_readlogfilename , "a+" );
		if(rfp)fprintf( rfp, "%s\n",decoded );
		if(rfp)fclose(rfp);
	}
	for(i = 0 ; ; i++ ){
		if( decoded[i] == '\0' ) break;
		if( i==0){
		    lssproto.token_list[c++]=&(decoded[i]);
		}
		if( decoded[i]== ' '){
		    lssproto.token_list[c++]=&(decoded[i+1]);
		}
	}
	while( *decoded ){
		if( ( *decoded  ) == ' ' || (*decoded ) == '\n' || (*decoded ) == '\r' ) *decoded = '\0';
		decoded++;
 	}
	lssproto.token_list[c] = (char*)NULL;
}
int lssproto_default_write_wrap( int fd , char *buf , int size )
{
#ifndef WIN32
	return write( fd , buf , size );
#else
	return 0;
#endif
}

void lssproto_consumeLine(char *buf , int offset )
{
	int i;
	int shift=0;
	buf+= offset;
	for(i=0;;i++){
		if( buf[i] == '\n' ){
			shift = i + 1;
			break;
		}
	}
    if( shift == 0 )return;
	for(i=shift;;i++){
		buf[i - shift] = buf[i];
		if( buf[i] == '\0')break;
	}
}
void lssproto_copyLine( char*src , char *out , int outlen )
{
	int i;
	for(i=0;;i++){
		out[i] = src[i];
		if( src[i] == '\n' ){
			out[i+1] = '\0' ;
			return;
		}
		if( src[i] == '\0' )return;
	}
	lssproto_strcpysafe( out , "" , outlen );
}
unsigned int lssproto_GetNewMessageID(void)