开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
saacproto_util.c
资源名称：saac.tar.gz　[点击查看]
上传用户：qys8201
上传日期：2021-12-11
资源大小：978k
文件大小：42k
源码类别：

模拟服务器

开发平台：

C/C++

saacproto_util.c：源码内容
  1. #define _SAACPROTOUTIL_C_
  2. #include "version.h"
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #ifndef WIN32
  7. #include <unistd.h>
  8. #include <strings.h>
  9. #endif
  10. #include "main.h"
  11. #include "saacproto_util.h"
  12. #ifdef saacproto__ENCRYPT
  13. long saacproto_ringoCompressor( unsigned char *code , long codelen , unsigned char *text , long textlen);
  14. long saacproto_ringoDecompressor( unsigned char *text , long textlen , unsigned char *code , long codelen);
  15. #endif
  16. /*
  17.   lsrpc routines
  18. */
  19. int saacproto_AllocateCommonWork(int bufsiz)
  20. {
  21. saacproto.workbufsize = bufsiz;
  22. saacproto.work = NULL;
  23. saacproto.arraywork = NULL;
  24. saacproto.escapework = NULL;
  25. saacproto.val_str = NULL;
  26. saacproto.token_list = NULL;
  27. saacproto.cryptwork = NULL;
  28. saacproto.jencodecopy = NULL;
  29. saacproto.jencodeout = NULL;
  30. saacproto.compresswork = NULL;
  31. saacproto.work = (char*)calloc( 1, saacproto.workbufsize );
  32. saacproto.arraywork = (char*)calloc( 1, saacproto.workbufsize );
  33. saacproto.escapework = (char*)calloc( 1, saacproto.workbufsize );
  34. saacproto.val_str = (char*)calloc( 1, saacproto.workbufsize );
  35. saacproto.token_list = (char**)calloc( 1, saacproto.workbufsize *sizeof( char** ) );
  36. saacproto.cryptwork = (char*)calloc( 1, saacproto.workbufsize * 3 );
  37. saacproto.jencodecopy = (char*)calloc( 1, saacproto.workbufsize * 3 );
  38. saacproto.jencodeout = (char*)calloc( 1, saacproto.workbufsize * 3 );
  39. saacproto.compresswork = (char*)calloc( 1, saacproto.workbufsize * 3 );
  40. memset( saacproto.work , 0, saacproto.workbufsize );
  41. memset( saacproto.arraywork , 0, saacproto.workbufsize );
  42. memset( saacproto.escapework , 0, saacproto.workbufsize );
  43. memset( saacproto.val_str , 0, saacproto.workbufsize );
  44. memset( (char*)saacproto.token_list ,0,  saacproto.workbufsize*sizeof(char**) );
  45. memset( saacproto.cryptwork , 0, saacproto.workbufsize*3 );
  46. memset( saacproto.jencodecopy , 0, saacproto.workbufsize*3 );
  47. memset( saacproto.jencodeout , 0, saacproto.workbufsize*3 );
  48. memset( saacproto.compresswork , 0, saacproto.workbufsize*3 );
  49. if( saacproto.work == NULL ||
  50.    saacproto.arraywork == NULL ||
  51.    saacproto.escapework == NULL ||
  52.    saacproto.val_str == NULL ||
  53.    saacproto.token_list == NULL ||
  54.    saacproto.cryptwork == NULL ||
  55.    saacproto.jencodecopy == NULL ||
  56.    saacproto.jencodeout == NULL ||
  57.    saacproto.compresswork == NULL ){
  58.     free( saacproto.work);free( saacproto.val_str);
  59.     free( saacproto.escapework);free( saacproto.arraywork );
  60.     free( saacproto.token_list);free( saacproto.cryptwork );
  61.     free( saacproto.jencodecopy);free( saacproto.jencodeout );
  62.     free( saacproto.compresswork );
  63.     return -1;
  64. }
  65. return 0;
  66. }
  67. /**********
  68.   Get message information from a network input
  69. **********/
  70. void saacproto_GetMessageInfo( int *id , char *funcname , int len, char **tk )
  71. {
  72. if( tk[0] == NULL || tk[1] == NULL ){
  73. *id = 0;
  74. saacproto_strcpysafe( funcname , "" , len );
  75. return;
  76. }
  77. *id =  strtoul( tk[0] ,NULL,10);
  78. saacproto_strcpysafe( funcname , tk[1] , len );
  79. return;
  80. }
  81. /********************************************
  82.   string utilities
  83. *********************************************/
  84. void saacproto_strcpysafe( char *dest, char *src, int maxlen )
  85. {
  86. int i;
  87. for(i=0;i<maxlen-1;i++){
  88. dest[i] = src[i];
  89. if( src[i]==0)break;
  90. }
  91. dest[i]=0;
  92. }
  93. void saacproto_strcatsafe( char *dest , char *src , int maxlen )
  94. {
  95. int i,j;
  96. for(i=0;i<maxlen-1;i++){
  97. if( dest[i] == 0 ){
  98. for(j=i;j<maxlen-1;j++){
  99. dest[j]= src[j-i];
  100. if( src[j-i] == 0 )break;
  101. }
  102. dest[j]=0;
  103. break;
  104. }
  105. }
  106. }
  107. char*saacproto_mkstr_int( int i )
  108. {
  109. #define MKSTR_INT(v) saacproto_Ltoa( (long)(v)) 
  110. saacproto_strcpysafe( saacproto.val_str ,  (char*)MKSTR_INT(i) , saacproto.workbufsize );
  111. saacproto_strcatsafe( saacproto.val_str ," " , saacproto.workbufsize );
  112. return saacproto.val_str;
  113. }
  114. char*saacproto_mkstr_u_int( unsigned int i )
  115. {
  116. #define MKSTR_U_INT(v) saacproto_Ultoa( (unsigned long ) (v) )
  117. saacproto_strcpysafe( saacproto.val_str , MKSTR_U_INT(i) , saacproto.workbufsize );
  118. saacproto_strcatsafe( saacproto.val_str ," " , saacproto.workbufsize );
  119. return saacproto.val_str;
  120. }
  121. char*saacproto_mkstr_long( long l )
  122. {
  123. #define MKSTR_LONG(v) saacproto_Ltoa( v ) 
  124. saacproto_strcpysafe( saacproto.val_str , MKSTR_LONG(l) , saacproto.workbufsize );
  125. saacproto_strcatsafe( saacproto.val_str ," " , saacproto.workbufsize );
  126. return saacproto.val_str;
  127. }
  128. char*saacproto_mkstr_u_long( unsigned long l )
  129. {
  130. #define MKSTR_U_LONG(v) saacproto_Ultoa(v ) 
  131. saacproto_strcpysafe( saacproto.val_str , MKSTR_U_LONG(l) , saacproto.workbufsize );
  132. saacproto_strcatsafe( saacproto.val_str ," " , saacproto.workbufsize );
  133. return saacproto.val_str;
  134. }
  135. char*saacproto_mkstr_short( short s )
  136. {
  137. #define MKSTR_SHORT16(v)    saacproto_Ltoa( (long)((int)(v) ))
  138. saacproto_strcpysafe( saacproto.val_str , MKSTR_SHORT16(s) , saacproto.workbufsize );
  139. saacproto_strcatsafe( saacproto.val_str ," " , saacproto.workbufsize );
  140. return saacproto.val_str;
  141. }
  142. char*saacproto_mkstr_u_short( short s )
  143. {
  144. #define MKSTR_U_SHORT16(v)   saacproto_Ltoa( (long)(  ((long)(v)) & 0xffff ))
  145. saacproto_strcpysafe( saacproto.val_str , MKSTR_U_SHORT16(s) , saacproto.workbufsize );
  146. saacproto_strcatsafe( saacproto.val_str ," " , saacproto.workbufsize );
  147. return saacproto.val_str;
  148. }
  149. char*saacproto_mkstr_char( char c )
  150. {
  151. #define MKSTR_CHAR8(v)   saacproto_Ltoa( ( long)((int)(v)))
  152. saacproto_strcpysafe( saacproto.val_str , MKSTR_CHAR8(c) , saacproto.workbufsize );
  153. saacproto_strcatsafe( saacproto.val_str ," ", saacproto.workbufsize );
  154. return saacproto.val_str;
  155. }
  156. char*saacproto_mkstr_u_char( char c)
  157. {
  158. #define MKSTR_U_CHAR8(v)   saacproto_Ltoa( (long)( ((long)(v)) & 0xff ))
  159. saacproto_strcpysafe( saacproto.val_str , MKSTR_U_CHAR8(c) , saacproto.workbufsize );
  160. saacproto_strcatsafe( saacproto.val_str ," "  , saacproto.workbufsize );
  161. return saacproto.val_str;
  162. }
  163. char*saacproto_mkstr_string( char*a )
  164. {
  165. char *ret = saacproto_escapeString( a );
  166. saacproto_strcatsafe( ret , " ", saacproto.workbufsize );
  167. return ret;
  168. }
  169. char*saacproto_mkstr_float(float f )
  170. {
  171. sprintf( saacproto.val_str , "%f " , f );
  172. return saacproto.val_str;
  173. }
  174. char*saacproto_mkstr_double( double d )
  175. {
  176. sprintf( saacproto.val_str , "%f " , d );
  177. return saacproto.val_str;
  178. }
  179. char*saacproto_mkstr_int_array( int size , int *array )
  180. {
  181. #define MKSTR_ARRAYMACRO( func) 
  182. {
  183.  int i;
  184.          saacproto.arraywork[0] = '';
  185.  for(i=0;i<size;i++){   
  186.              saacproto_strcatsafe( saacproto.arraywork , func(array[i]) , saacproto.workbufsize );
  187.  }
  188.          return saacproto.arraywork;
  189.     }
  191. MKSTR_ARRAYMACRO( saacproto_mkstr_int );
  192. }
  193. char*saacproto_mkstr_u_int_array( int size , int *array )
  194. {
  195. MKSTR_ARRAYMACRO( saacproto_mkstr_u_int );
  196. }
  197. char*saacproto_mkstr_short_array( int size , short *array )
  198. {
  199. MKSTR_ARRAYMACRO( saacproto_mkstr_short );
  200. }
  201. char*saacproto_mkstr_u_short_array( int size , short *array )
  202. {
  203. MKSTR_ARRAYMACRO( saacproto_mkstr_u_short );
  204. }
  205. char *saacproto_mkstr_char_array( int size , char *array )
  206. {
  207. MKSTR_ARRAYMACRO( saacproto_mkstr_char );
  208. }
  209. char *saacproto_mkstr_u_char_array( int size , unsigned char *array )
  210. {
  211. MKSTR_ARRAYMACRO( saacproto_mkstr_u_char );
  212. }
  213. char *saacproto_mkstr_float_array( int size , float *array )
  214. {
  215. MKSTR_ARRAYMACRO( saacproto_mkstr_float );
  216. }
  217. char *saacproto_mkstr_double_array( int size , double *array )
  218. {
  219. MKSTR_ARRAYMACRO( saacproto_mkstr_double );
  220. }
  221. /*********************
  222.    translate string into base types
  223. *********************/
  224. int saacproto_demkstr_int( char*a )
  225. {
  226. if( a == (char*)NULL)return 0;
  227. /* return (int)strtol( a ,NULL , 10);*/
  228. return saacproto_a62toi( a );
  229. }
  230. unsigned int saacproto_demkstr_u_int( char*a )
  231. {
  232. if( a == (char*)NULL)return 0;
  233. return (unsigned int ) strtoul( a ,NULL,10);
  234. }
  235. long saacproto_demkstr_long( char*a )
  236. {
  237. if( a == (char*)NULL)return 0;
  238. return (long)strtol( a , NULL , 10 );
  239. }
  240. unsigned long saacproto_demkstr_u_long(char*a )
  241. {
  242. if( a == (char*)NULL)return 0;
  243. return (unsigned long ) strtoul( a , NULL , 10 ) ;
  244. }
  245. short saacproto_demkstr_short( char*a )
  246. {
  247. if( a == (char*)NULL)return 0;
  248. return (short) strtol( a , NULL , 10 );
  249. }
  250. unsigned short saacproto_demkstr_u_short( char*a )
  251. {
  252. if( a == (char*)NULL)return 0;
  253. return (unsigned short) strtoul( a , NULL , 10 );
  254. }
  255. char saacproto_demkstr_char( char*a )
  256. {
  257. if( a == (char*)NULL)return 0;
  258. return (char) strtol(  a  , NULL , 10 );
  259. }
  260. unsigned char saacproto_demkstr_u_char( char*a )
  261. {
  262. if( a == (char*)NULL)return 0;
  263. return (unsigned char ) strtoul( a,NULL , 10 );
  264. }
  265. float saacproto_demkstr_float( char*a )
  266. {
  267. if( a == (char*)NULL)return 0.0F;
  268. return (float) atof( a);
  269. }
  270. double saacproto_demkstr_double(char*a )
  271. {
  272. if( a == (char*)NULL)return 0.0F;
  273. return (double) strtod( a , NULL );
  274. }
  275. char* saacproto_demkstr_string( char*a)
  276. {
  277. if( a == (char*)NULL){
  278. saacproto_strcpysafe( saacproto.escapework , "" , saacproto.workbufsize );
  279. return saacproto.escapework;
  280. }
  281. return saacproto_descapeString( a );
  282. }
  283. int *saacproto_demkstr_int_array( char**tk ,int *buf  ,int start , int size )
  284. {
  285. #define DEMKSTR_ARRAYMACRO( func, defaultvalue )          
  286.     {
  287.         int i;
  288.         for(i=start;i<(start+size);i++){
  289.             if( tk[i] == NULL ){   
  290.         buf[i-start]=defaultvalue ;
  291.             } else {
  292.             buf[i-start] = func( tk[i] );
  293.             }
  294.     }
  295.         return buf;
  296.     }
  297.     DEMKSTR_ARRAYMACRO( saacproto_demkstr_int , 0 );
  298. }
  299. int *saacproto_demkstr_u_int_array( char **tk , int *buf , int start , int size )
  300. {
  301. DEMKSTR_ARRAYMACRO( saacproto_demkstr_u_int , 0 );
  302. }
  303. unsigned int *saacproto_demkstr_long_array(
  304.  char **tk , unsigned int *buf , int start , int size )
  305. {
  306. DEMKSTR_ARRAYMACRO( saacproto_demkstr_long  , 0);
  307. }
  308. unsigned long *saacproto_demkstr_u_long_array(
  309.  char **tk , unsigned long *buf , int start , int size )
  310. {
  311. DEMKSTR_ARRAYMACRO( saacproto_demkstr_u_long , 0);
  312. }
  313. short *saacproto_demkstr_short_array( char **tk , short *buf , int start , int size )
  314. {
  315. DEMKSTR_ARRAYMACRO( saacproto_demkstr_short , 0);
  316. }
  317. unsigned short* saacproto_demkstr_u_short_array( 
  318.  char **tk , unsigned short *buf , int start , int size )
  319. {
  320. DEMKSTR_ARRAYMACRO( saacproto_demkstr_u_short , 0);
  321. }
  322. char *saacproto_demkstr_char_array( char **tk , char *buf , int start , int size )
  323. {
  324. DEMKSTR_ARRAYMACRO( saacproto_demkstr_u_char , 0);
  325. }
  326. unsigned char *saacproto_demkstr_u_char_array( 
  327. char **tk , unsigned char*buf , int start , int size )
  328. {
  329. DEMKSTR_ARRAYMACRO( saacproto_demkstr_u_char , 0);
  330. }
  331. float *saacproto_demkstr_float_array( char **tk , float *buf , int start , int size )
  332. {
  333. DEMKSTR_ARRAYMACRO( saacproto_demkstr_float , (float)0.0);
  334. }
  335. double *saacproto_demkstr_u_double_array( char **tk , double *buf , int start , int size )
  336. {
  337. DEMKSTR_ARRAYMACRO( saacproto_demkstr_double , (double)0.0);
  338. }
  339. char*  saacproto_escapeString( char*a )
  340. {
  341. int i,c=0;
  342. saacproto.escapework[0] = '';
  343. for(i=0;;i++){
  344. if( a[i] == '' ){
  345. saacproto.escapework[c++] = '';
  346. break;
  347. } else if( ( char )0x80 <= a[i] && a[i] <= ( char )0xFF ){
  348. // for 2 Byte Word
  349. saacproto.escapework[c++] = a[i++];
  350. saacproto.escapework[c++] = a[i];
  351. } else if( a[i] == '\' ){
  352. saacproto.escapework[c++] = '\';
  353. saacproto.escapework[c++] = '\';
  354. } else if( a[i] == ' ' ){
  355. saacproto.escapework[c++] = '\';
  356. saacproto.escapework[c++] = 'S';
  357. } else if( a[i] == 'n' ){
  358. saacproto.escapework[c++] = '\';
  359. saacproto.escapework[c++] = 'n';
  360. } else if( a[i] == 'r' ){
  361. saacproto.escapework[c++] = '\';
  362. saacproto.escapework[c++] = 'r';
  363. } else {
  364. saacproto.escapework[c++] = a[i];
  365. }
  366. }
  367. return saacproto.escapework;
  368. }
  369. char* saacproto_descapeString( char*a )
  370. {
  371. int i ,c =0;
  372. saacproto.escapework[0] = '';
  373. for(i=0;;i++){
  374. if( a[i] == '' ){
  375. saacproto.escapework[c++]='';
  376. break;
  377. } else if( (char)0x80 <= a[i] && a[i] <= (char)0xFF ){
  378. // for 2 Byte Word
  379. saacproto.escapework[c++] = a[i++];
  380. saacproto.escapework[c++] = a[i];
  381. } else if( a[i] == '\' ){
  382. if( a[i+1] == 'S' ){     /* space */
  383. saacproto.escapework[c++] = ' ';
  384. } else if( a[i+1] == 'n' ){
  385. saacproto.escapework[c++] = 'n';
  386. } else if( a[i+1] == 'r' ){
  387. saacproto.escapework[c++] = 'r';
  388. } else if( a[i+1] == '\' ){
  389. saacproto.escapework[c++] = '\';
  390. } else {
  391. saacproto.escapework[c++] = a[i];
  392. }
  393. i++;           
  394. } else {
  395. saacproto.escapework[c++] = a[i];
  396. }
  397. }
  398. return saacproto.escapework;
  399. }
  400. /*
  401.    This function works only when char*src is escaped
  402.    NOTICE: Effects and Modifies the contents of char*src!
  403.    NOTICE : Ends the output token list with NULL pointer
  404. Ex:
  405.         v out[0]       v out[1]
  406.   "     asdjfhasfdasdf asdf asf asdf "
  407.  */
  408. #ifdef saacproto__ENCRYPT
  409. static void saacproto_decodeString( char *src , char *out );
  410. static void saacproto_encodeString( char *src , char *out , int maxoutlen );
  411. #endif
  412. void saacproto_splitString( char *src  )
  413. {
  414. int i,c=0;
  415. char *decoded;
  417. #ifdef saacproto__ENCRYPT
  418. decoded = saacproto.cryptwork;
  419. saacproto_decodeString( src , decoded );
  420. #else
  421. decoded = src;
  422. #endif
  423. if( saacproto_readlogfilename[0] != ''){
  424. FILE *rfp;
  425. rfp = fopen( saacproto_readlogfilename , "a+" );
  426. if(rfp)fprintf( rfp, "%sn",decoded );
  427. if(rfp)fclose(rfp);
  428. }
  429. for(i = 0 ; ; i++ ){
  430. if( decoded[i] == '' ) break;
  431. if( i==0){
  432.     saacproto.token_list[c++]=&(decoded[i]);
  433. }
  434. if( decoded[i]== ' '){
  435.     saacproto.token_list[c++]=&(decoded[i+1]);
  436. }
  437. }
  438. while( *decoded ){
  439. if( ( *decoded  ) == ' ' || (*decoded ) == 'n' || (*decoded ) == 'r' ) *decoded = '';
  440. decoded++;
  441.   }
  442. saacproto.token_list[c] = (char*)NULL;
  443. }
  444. int saacproto_default_write_wrap( int fd , char *buf , int size )
  445. {
  446. #ifndef WIN32
  447. return write( fd , buf , size );
  448. #else
  449. return 0;
  450. #endif
  451. }
  453. void saacproto_consumeLine(char *buf , int offset )
  454. {
  455. int i;
  456. int shift=0;
  457. buf+= offset;
  458. for(i=0;;i++){
  459. if( buf[i] == 'n' ){
  460. shift = i + 1;
  461. break;
  462. }
  463. }
  464.     if( shift == 0 )return;
  465. for(i=shift;;i++){
  466. buf[i - shift] = buf[i];
  467. if( buf[i] == '')break;
  468. }
  469. }
  470. void saacproto_copyLine( char*src , char *out , int outlen )
  471. {
  472. int i;
  473. for(i=0;;i++){
  474. out[i] = src[i];
  475. if( src[i] == 'n' ){
  476. out[i+1] = '' ;
  477. return;
  478. }
  479. if( src[i] == '' )return;
  480. }
  481. saacproto_strcpysafe( out , "" , outlen );
  482. }
  483. unsigned int saacproto_GetNewMessageID(void)
  484. {
  485. return saacproto.message_id++;
  486. }
  487. /*****************
  488.   WRITE
  489.    int flg : if 1, actually write. Otherwise no Network access
  490. *****************/
  491. void saacproto_DebugSend( int fd , char *msg )
  492. {
  493. saacproto_Send( fd, msg );
  494. }
  495. void saacproto_Send( int fd , char *msg )
  496. {
  497.     char *encoded;
  498. if( saacproto_writelogfilename[0] != '' ){
  499. FILE *wfp = fopen( saacproto_writelogfilename , "a+" );
  500. if(wfp)fprintf( wfp , "%sn", msg );
  501. if(wfp)fclose(wfp);
  502. }
  503. #ifdef saacproto__ENCRYPT
  504.     encoded = saacproto.cryptwork;
  505.     saacproto_encodeString( msg , encoded , saacproto.workbufsize*3 );
  506. #else
  507.     encoded = msg;
  508. #endif
  509. {
  510. /* add a newline character*/
  511. unsigned int l = strlen( encoded );
  512. if( l < saacproto.workbufsize *3){
  513. encoded[l] = 'n';
  514. encoded[l+1] = 0;
  515. l++;
  516. }else{
  517. //andy_log
  518. log( "l:%d < workbufsize:%d err : n (%s)n", l, saacproto.workbufsize, msg );
  519. }
  520. saacproto.write_func( fd , encoded , l);
  521. }
  522. }
  523. /****************
  524.   create a header which has function name and new Message ID
  525. ****************/
  526. void saacproto_CreateHeader( char *out ,char *fname )
  527. {
  528. sprintf( out ,"%u %s " , saacproto_GetNewMessageID() , fname );
  529. }
  530. void saacproto_CreateHeaderID( char *out,unsigned long msgid , char *fname )
  531. {
  532. sprintf( out ,"%u %s " , (unsigned int)msgid , fname );
  533. }
  534. char *saacproto_Ltoa( long v )
  535. {
  536. static char _ltoa_out[64];
  537. saacproto_cnv10to62( (int)v , _ltoa_out , sizeof( _ltoa_out ));
  538. /* sprintf( _ltoa_out , "%d" , (int)v );*/
  539. return _ltoa_out;
  540. }
  541. char *saacproto_Ultoa( unsigned long v )
  542. {
  543. static char _ultoa_out[64];
  544. sprintf( _ultoa_out , "%u" , (unsigned int)v );
  545. return _ultoa_out;
  546. }
  547. /****************
  548.    string address wrapper
  549. ****************/
  550. char *saacproto_wrapStringAddr( char *copy , int maxcopylen , char*src )
  551. {
  552. saacproto_strcpysafe( copy , src , maxcopylen );
  553. return copy;
  554. }
  555. /***************
  556.  bzero buffer ( some OSs like win32 don't have bzero )
  557. ***************/
  558. void saacproto_bzero( char *b , int siz )
  559. {
  560. unsigned int i;
  561. int *p;
  562. p = (int*)b;
  563. for(i=0;i<siz/sizeof(int);i++) {
  564. *(p+i)=0;
  565. }
  566. for(i=0;i<siz%sizeof(int);i++) {
  567. *(b+siz-1-i)=0;
  568. }
  569. }
  570. /***************
  571.     copy buffer
  572. ***************/
  573. void saacproto_bcopy(char*s , char *d , int siz )
  574. {
  575.     unsigned int i;
  576.     int *ps,*pd;
  577.     ps = (int*)s;
  578.     pd = (int*)d;
  579.     for(i=0;i<siz/sizeof(int);i++) {
  580.         *(pd+i) = *(ps+i);
  581.     }
  582.     for(i=0;i<siz%sizeof(int);i++) {
  583.         *(d+siz-1-i)=*(s+siz-1-i);
  584.     }
  585. }
  586. #ifdef saacproto__ENCRYPT
  587. /* define function body only if the macro is set( but it's default) */
  588. static void saacproto_encode64( unsigned char *in , int i, unsigned char *out );
  589. static int saacproto_decode64( unsigned char *in , unsigned char *out );
  590. static void saacproto_jDecode(char *src,int srclen,int key,char *decoded,int *decodedlen);
  591. static void saacproto_jEncode(char *src,int srclen,int key,char *encoded,int *encodedlen,int maxencodedlen);
  592. #define JENCODE_KEY    1000 
  593. /* translate original lsrpc text to code64 text */
  594. static void saacproto_encodeString( char *src , char *out , int maxoutlen )
  595. {
  596.     int jencodedlen=0;
  597.     long compressed_l = 0;
  598. int srclen = strlen( src ) + 1;
  599.     int flag=srclen;
  600. if( srclen < 100 ){
  601. if( (int)srclen > (int)( saacproto.workbufsize*3-2) ){
  602. fprintf( stderr, "lsgen: badly configured work buflenn" );
  603. exit(1);
  604. }
  605. if( (flag%2) == 1 ) flag ++;
  606. saacproto.compresswork[0] = flag;
  607. memcpy( saacproto.compresswork+1,src,srclen );
  608. compressed_l = srclen + 1;
  609. } else {
  610. if((flag%2)==0)flag++;
  611. saacproto.compresswork[0] = flag;
  612.         compressed_l = saacproto_ringoCompressor(
  613.             (unsigned char*)saacproto.compresswork + 1 ,
  614.     (long)saacproto.workbufsize*3 - 1,
  615.             (unsigned char*)src ,
  616.            (long)strlen(src) ) + 1;    /* be careful! */
  617. }
  618. /* return empty line if error or buffer excess */
  619. if( compressed_l <= 0 ){
  620. saacproto_strcpysafe( out , "n" , maxoutlen );
  621. return;
  622. }
  623.     memcpy( saacproto.jencodecopy ,saacproto.compresswork ,compressed_l );
  624.     saacproto_jEncode( saacproto.jencodecopy , compressed_l , JENCODE_KEY ,
  625.     saacproto.jencodeout, &jencodedlen , saacproto.workbufsize*3 -1 );
  626.     saacproto_encode64( (unsigned char*)saacproto.jencodeout , jencodedlen,  (unsigned char*)out );
  627. }
  628. /* translate code64 text to original lsrpc text */
  629. static void saacproto_decodeString( char *src , char *out )
  630. {
  631.     int compressed_l =0, outlen64;
  632.     int l;
  633.     long decompressed_l = 0;
  634.     /* copy src to copybuffer because jencoder modifies the input buffer */
  635.     l = strlen( src );
  636.     if( src[l-1]=='n' || src[l-1]=='r' )src[l-1]=0;
  637.     if( src[l-2]=='n' || src[l-2]=='r' )src[l-2]=0;
  638.     outlen64 = saacproto_decode64( (unsigned char*)src , (unsigned char*)saacproto.jencodecopy );
  639.     saacproto_jDecode( saacproto.jencodecopy , outlen64 , JENCODE_KEY,
  640. saacproto.compresswork , &compressed_l);
  641.     /*out[outlen]=0;  PENDING*/
  642.     if( (saacproto.compresswork[0] % 2 ) == 0 ){
  643.     if( compressed_l <= 0 ){
  644. decompressed_l = 0;
  645. fprintf( stderr, "LSRPC: too short:[%s]n", src );
  646. } else {
  647. memcpy( out, saacproto.compresswork+1, compressed_l -1 );
  648. decompressed_l = compressed_l -1;
  649. }
  650. } else {
  651.         decompressed_l =
  652. saacproto_ringoDecompressor( (unsigned char*)out ,
  653.                    (long)saacproto.workbufsize ,
  654. (unsigned char*)saacproto.compresswork+1 ,
  655. (long)compressed_l -1 );
  656. }
  657.     out[decompressed_l] = 0;
  658. }
  659. /* followings are taken from code64.c */
  660. char saacproto_charset[64]={
  661.     'A','B','C','D',    'E','F','G','H',
  662.     'I','J','K','L',    'M','N','O','P',
  663.     'Q','R','S','T',    'U','V','W','X',
  664.     'Y','Z','a','b',    'c','d','e','f',
  665.     'g','h','i','j',    'k','l','m','n',
  666.     'o','p','q','r',    's','t','u','v',
  667.     'w','x','y','z',    '0','1','2','3',
  668.     '4','5','6','7',    '8','9','+','-'
  669. };
  670. char saacproto_reversecharset[256]={
  671.     0,0,0,0, 0,0,0,0,
  672.     0,0,0,0, 0,0,0,0,
  673.     0,0,0,0, 0,0,0,0,
  674.     0,0,0,0, 0,0,0,0,
  675.     0,0,0,0, 0,0,0,0,
  676.     0,0,0,62, 0,63,0,0,
  677.     52,53,54,55, 56,57,58,59,
  678.     60,61,0,0, 0,0,0,0,
  679.     0,0,1,2, 3,4,5,6,
  680.     7,8,9,10, 11,12,13,14,
  681.     15,16,17,18, 19,20,21,22,
  682.     23,24,25,0, 0,0,0,0,
  683.     0,26,27,28, 29,30,31,32,
  684.     33,34,35,36, 37,38,39,40,
  685.     41,42,43,44, 45,46,47,48,
  686.     49,50,51,0, 0,0,0,0,
  687.     0,0,0,0,  0,0,0,0,
  688.     0,0,0,0,  0,0,0,0,
  689.     0,0,0,0,  0,0,0,0,
  690.     0,0,0,0,  0,0,0,0,
  691.     0,0,0,0,  0,0,0,0,
  692.     0,0,0,0,  0,0,0,0,
  693.     0,0,0,0,  0,0,0,0,
  694.     0,0,0,0,  0,0,0,0,
  695.     0,0,0,0,  0,0,0,0,
  696.     0,0,0,0,  0,0,0,0,
  697.     0,0,0,0,  0,0,0,0,
  698.     0,0,0,0,  0,0,0,0,
  699.     0,0,0,0,  0,0,0,0,
  700.     0,0,0,0,  0,0,0,0,
  701.     0,0,0,0,  0,0,0,0,
  702.     0,0,0,0,  0,0,0,0
  703. };
  705. static void saacproto_encode64( unsigned char *in , int len , unsigned char *out )
  706. {
  707.     int i;
  708.     int use_bytes;
  709.     int address = 0;
  710.     out[0] = 0;
  711.     for(i=0;;i+=3){
  712.         unsigned char in1 , in2 , in3;
  713.         unsigned char out1 ,out2 , out3 , out4;
  714.         if( i >= len ) break;
  715.         if( i >= (len-1)){   /* the last letter ( to be thrown away ) */
  716.             in1 = in[i] & 0xff;
  717.             in2 = in3 = 0;
  718.             use_bytes = 2;
  719.         } else if( i >= (len-2)){ /* the last 2 letters ( process only 1 byte)*/
  720.             in1 = in[i] & 0xff;
  721.             in2 = in[i+1] & 0xff;
  722.             in3 = 0;
  723.             use_bytes = 3;
  724.         } else {                /* there are more or equal than 3 letters */
  725.             in1 = in[i] & 0xff;
  726.             in2 = in[i+1] & 0xff;
  727.             in3 = in[i+2] & 0xff;
  728.             use_bytes = 4;
  729.         }
  730.         out1 = ((in1 & 0xfc)>>2) & 0x3f;
  731.         out2 = ((in1 & 0x03)<<4) | ((( in2 & 0xf0)>>4)&0x0f);
  732.         out3 = ((in2 & 0x0f)<<2) | ((( in3 & 0xc0)>>6)&0x03);
  733.         out4 = (in3 & 0x3f );
  734.         if( use_bytes >= 2 ){
  735.             out[address++] = saacproto_charset[out1];
  736.             out[address++] = saacproto_charset[out2];
  737.             out[address]=0;
  738.         }
  739.         if( use_bytes >= 3 ){
  740.             out[address++] = saacproto_charset[out3];
  741.             out[address]=0;
  742.         }
  743.         if( use_bytes >= 4 ){
  744.             out[address++] = saacproto_charset[out4];
  745.             out[address]=0;
  746.         }
  747.     }
  748. }
  749. /*
  750.  * Decode it
  751.  * char *in : encoded ascii chars
  752.  * char *out : decoded(  output)
  753.  * return value : output byte count
  754.  * 
  755.  * note: no need to have bigger buffer. because output is to 
  756.  * be smaller than input string size 
  757.  */
  758. static int saacproto_decode64( unsigned char *in , unsigned char *out )
  759. {
  760.     unsigned char in1 , in2 , in3 , in4;
  761.     unsigned char out1 , out2 , out3;
  762.     int use_bytes;
  763.     int address= 0;
  764.     int i;
  765.     for(i=0;;i+=4 ){
  766.         if( in[i] == 0 ){
  767.             break;
  768.         } else if( in[i+1] == 0 ){   /* the last letter */
  769.             break;
  770.         } else if( in[i+2] == 0 ){   /* the last 2 letters */
  771.             in1 = saacproto_reversecharset[in[i]];
  772.             in2 = saacproto_reversecharset[in[i+1]];
  773.             in3 = in4 = 0;
  774.             use_bytes = 1;
  775.         } else if( in[i+3] == 0 ){   /* the last  3 letters */
  776.             in1 = saacproto_reversecharset[in[i]];
  777.             in2 = saacproto_reversecharset[in[i+1]];
  778.             in3 = saacproto_reversecharset[in[i+2]];
  779.             in4 = 0;
  780.             use_bytes = 2;
  781.         } else {   /* process 4 letters */
  782.             in1 = saacproto_reversecharset[in[i]];
  783.             in2 = saacproto_reversecharset[in[i+1]];
  784.             in3 = saacproto_reversecharset[in[i+2]];
  785.             in4 = saacproto_reversecharset[in[i+3]];
  786.             use_bytes = 3;
  787.         }
  788.         out1 =  (in1<<2) | (((in2 & 0x30)>>4)&0x0f) ;
  789.         out2 =  ((in2 & 0x0f )<<4) | ((( in3 & 0x3c)>>2)&0x0f);
  790.         out3 =  ( (in3 &0x03)<<6) |  ( in4 & 0x3f );
  791.         if( use_bytes >= 1 ){
  792.             out[address++] = out1;
  793.         }
  794.         if( use_bytes >= 2 ){
  795.             out[address++] = out2;
  796.         }
  797.         if( use_bytes >= 3 ){
  798.             out[address++] = out3;
  799.         }
  800.         if( use_bytes != 3 ){
  801.             break;
  802.         }
  803.     }
  804.     return address;
  805. }
  807. /* followings are taken from Jencode.c by jun */
  808. static void saacproto_jEncode(char *src,int srclen,int key,char *encoded,int *encodedlen,int maxencodedlen)
  809. {
  810. char sum=0;
  811. int i;
  812. if(srclen+1 > maxencodedlen){
  813. *encodedlen = maxencodedlen;
  814. for(i=0;i<(*encodedlen);i++)encoded[i] = src[i];
  815. }
  816. if(srclen+1 <= maxencodedlen){
  817. *encodedlen=srclen+1;
  818. for(i=0;i<srclen;i++){
  819. sum = sum + src[i];
  820. if(((key%7) == (i%5))||((key%2) == (i%2))) src[i] = ~src[i];
  821. }
  822. for(i=0;i<(*encodedlen);i++){
  823. if(abs((key%srclen)) > i) encoded[i] = src[i] + sum*((i*i)%3); 
  824. if(abs((key%srclen)) == i) encoded[i] = sum;
  825. if(abs((key%srclen)) < i) encoded[i] = src[i-1] + sum*((i*i)%7);
  826. }
  827. }
  828. }
  829. static void saacproto_jDecode(char *src,int srclen,int key,char *decoded,int *decodedlen)
  830. {
  831. char sum=0;
  832. int i;
  833. *decodedlen=srclen-1;
  834. if( *decodedlen == 0 ){
  835. return; /* return error if length is 0 */
  836. }
  837. sum = src[abs(key%(*decodedlen))];
  838. for(i=0;i<srclen;i++){
  839. if(abs((key%(*decodedlen))) > i) decoded[i] = src[i] - sum*((i*i)%3);
  840. if(abs((key%(*decodedlen))) < i) decoded[i-1] = src[i] - sum*((i*i)%7);
  841. }
  842. for(i=0;i<(*decodedlen);i++){
  843. if(((key%7) == (i%5))||((key%2) == (i%2)))decoded[i] = ~decoded[i];
  844. }
  845. }
  847. /*****************************************************************/
  848. /*       Compress / Decompress routine                           */
  849. /*****************************************************************/
  850. #define B00000000 0
  851. #define B00000001 1
  852. #define B00000010 2
  853. #define B00000011 3
  854. #define B00000100 4
  855. #define B00000101 5
  856. #define B00000110 6
  857. #define B00000111 7
  858. #define B00001000 8
  859. #define B00001001 9
  860. #define B00001010 10
  861. #define B00001011 11
  862. #define B00001100 12
  863. #define B00001101 13
  864. #define B00001110 14
  865. #define B00001111 15
  866. #define B00010000 16
  867. #define B00010001 17
  868. #define B00010010 18
  869. #define B00010011 19
  870. #define B00010100 20
  871. #define B00010101 21
  872. #define B00010110 22
  873. #define B00010111 23
  874. #define B00011000 24
  875. #define B00011001 25
  876. #define B00011010 26
  877. #define B00011011 27
  878. #define B00011100 28
  879. #define B00011101 29
  880. #define B00011110 30
  881. #define B00011111 31
  882. #define B00100000 32
  883. #define B00100001 33
  884. #define B00100010 34
  885. #define B00100011 35
  886. #define B00100100 36
  887. #define B00100101 37
  888. #define B00100110 38
  889. #define B00100111 39
  890. #define B00101000 40
  891. #define B00101001 41
  892. #define B00101010 42
  893. #define B00101011 43
  894. #define B00101100 44
  895. #define B00101101 45
  896. #define B00101110 46
  897. #define B00101111 47
  898. #define B00110000 48
  899. #define B00110001 49
  900. #define B00110010 50
  901. #define B00110011 51
  902. #define B00110100 52
  903. #define B00110101 53
  904. #define B00110110 54
  905. #define B00110111 55
  906. #define B00111000 56
  907. #define B00111001 57
  908. #define B00111010 58
  909. #define B00111011 59
  910. #define B00111100 60
  911. #define B00111101 61
  912. #define B00111110 62
  913. #define B00111111 63
  914. #define B01000000 64
  915. #define B01000001 65
  916. #define B01000010 66
  917. #define B01000011 67
  918. #define B01000100 68
  919. #define B01000101 69
  920. #define B01000110 70
  921. #define B01000111 71
  922. #define B01001000 72
  923. #define B01001001 73
  924. #define B01001010 74
  925. #define B01001011 75
  926. #define B01001100 76
  927. #define B01001101 77
  928. #define B01001110 78
  929. #define B01001111 79
  930. #define B01010000 80
  931. #define B01010001 81
  932. #define B01010010 82
  933. #define B01010011 83
  934. #define B01010100 84
  935. #define B01010101 85
  936. #define B01010110 86
  937. #define B01010111 87
  938. #define B01011000 88
  939. #define B01011001 89
  940. #define B01011010 90
  941. #define B01011011 91
  942. #define B01011100 92
  943. #define B01011101 93
  944. #define B01011110 94
  945. #define B01011111 95
  946. #define B01100000 96
  947. #define B01100001 97
  948. #define B01100010 98
  949. #define B01100011 99
  950. #define B01100100 100
  951. #define B01100101 101
  952. #define B01100110 102
  953. #define B01100111 103
  954. #define B01101000 104
  955. #define B01101001 105
  956. #define B01101010 106
  957. #define B01101011 107
  958. #define B01101100 108
  959. #define B01101101 109
  960. #define B01101110 110
  961. #define B01101111 111
  962. #define B01110000 112
  963. #define B01110001 113
  964. #define B01110010 114
  965. #define B01110011 115
  966. #define B01110100 116
  967. #define B01110101 117
  968. #define B01110110 118
  969. #define B01110111 119
  970. #define B01111000 120
  971. #define B01111001 121
  972. #define B01111010 122
  973. #define B01111011 123
  974. #define B01111100 124
  975. #define B01111101 125
  976. #define B01111110 126
  977. #define B01111111 127
  978. #define B10000000 128
  979. #define B10000001 129
  980. #define B10000010 130
  981. #define B10000011 131
  982. #define B10000100 132
  983. #define B10000101 133
  984. #define B10000110 134
  985. #define B10000111 135
  986. #define B10001000 136
  987. #define B10001001 137
  988. #define B10001010 138
  989. #define B10001011 139
  990. #define B10001100 140
  991. #define B10001101 141
  992. #define B10001110 142
  993. #define B10001111 143
  994. #define B10010000 144
  995. #define B10010001 145
  996. #define B10010010 146
  997. #define B10010011 147
  998. #define B10010100 148
  999. #define B10010101 149
  1000. #define B10010110 150
  1001. #define B10010111 151
  1002. #define B10011000 152
  1003. #define B10011001 153
  1004. #define B10011010 154
  1005. #define B10011011 155
  1006. #define B10011100 156
  1007. #define B10011101 157
  1008. #define B10011110 158
  1009. #define B10011111 159
  1010. #define B10100000 160
  1011. #define B10100001 161
  1012. #define B10100010 162
  1013. #define B10100011 163
  1014. #define B10100100 164
  1015. #define B10100101 165
  1016. #define B10100110 166
  1017. #define B10100111 167
  1018. #define B10101000 168
  1019. #define B10101001 169
  1020. #define B10101010 170
  1021. #define B10101011 171
  1022. #define B10101100 172
  1023. #define B10101101 173
  1024. #define B10101110 174
  1025. #define B10101111 175
  1026. #define B10110000 176
  1027. #define B10110001 177
  1028. #define B10110010 178
  1029. #define B10110011 179
  1030. #define B10110100 180
  1031. #define B10110101 181
  1032. #define B10110110 182
  1033. #define B10110111 183
  1034. #define B10111000 184
  1035. #define B10111001 185
  1036. #define B10111010 186
  1037. #define B10111011 187
  1038. #define B10111100 188
  1039. #define B10111101 189
  1040. #define B10111110 190
  1041. #define B10111111 191
  1042. #define B11000000 192
  1043. #define B11000001 193
  1044. #define B11000010 194
  1045. #define B11000011 195
  1046. #define B11000100 196
  1047. #define B11000101 197
  1048. #define B11000110 198
  1049. #define B11000111 199
  1050. #define B11001000 200
  1051. #define B11001001 201
  1052. #define B11001010 202
  1053. #define B11001011 203
  1054. #define B11001100 204
  1055. #define B11001101 205
  1056. #define B11001110 206
  1057. #define B11001111 207
  1058. #define B11010000 208
  1059. #define B11010001 209
  1060. #define B11010010 210
  1061. #define B11010011 211
  1062. #define B11010100 212
  1063. #define B11010101 213
  1064. #define B11010110 214
  1065. #define B11010111 215
  1066. #define B11011000 216
  1067. #define B11011001 217
  1068. #define B11011010 218
  1069. #define B11011011 219
  1070. #define B11011100 220
  1071. #define B11011101 221
  1072. #define B11011110 222
  1073. #define B11011111 223
  1074. #define B11100000 224
  1075. #define B11100001 225
  1076. #define B11100010 226
  1077. #define B11100011 227
  1078. #define B11100100 228
  1079. #define B11100101 229
  1080. #define B11100110 230
  1081. #define B11100111 231
  1082. #define B11101000 232
  1083. #define B11101001 233
  1084. #define B11101010 234
  1085. #define B11101011 235
  1086. #define B11101100 236
  1087. #define B11101101 237
  1088. #define B11101110 238
  1089. #define B11101111 239
  1090. #define B11110000 240
  1091. #define B11110001 241
  1092. #define B11110010 242
  1093. #define B11110011 243
  1094. #define B11110100 244
  1095. #define B11110101 245
  1096. #define B11110110 246
  1097. #define B11110111 247
  1098. #define B11111000 248
  1099. #define B11111001 249
  1100. #define B11111010 250
  1101. #define B11111011 251
  1102. #define B11111100 252
  1103. #define B11111101 253
  1104. #define B11111110 254
  1105. #define B11111111 255
  1106. /* masks for first byte ( write )*/
  1107. int  saacproto_modifymask_first[8][9]={
  1108.     {0, B00000001,B00000011,B00000111,B00001111,B00011111,B00111111,B01111111,B11111111},/* mod 0*/
  1109.     {0, B00000011,B00000111,B00001111,B00011111,B00111111,B01111111,B11111111,B11111111},/* mod 1*/
  1110.     {0, B00000111,B00001111,B00011111,B00111111,B01111111,B11111111,B11111111,B11111111},/* mod 2*/
  1111.     {0, B00001111,B00011111,B00111111,B01111111,B11111111,B11111111,B11111111,B11111111},/* mod 3*/
  1112.     {0, B00011111,B00111111,B01111111,B11111111,B11111111,B11111111,B11111111,B11111111},/* mod 4*/
  1113.     {0, B00111111,B01111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111},/* mod 5*/
  1114.     {0, B01111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111},/* mod 6*/
  1115.     {0, B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111},/* mod 7*/
  1116. };
  1117. /* masks for second byte ( write ) */
  1118. int saacproto_modifymask_second[8][9]={
  1119.     {0, B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000},/* mod 0 */
  1120.     {0, B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000001},/* mod 1 */
  1121.     {0, B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000001,B00000011},/* mod 2 */
  1122.     {0, B00000000,B00000000,B00000000,B00000000,B00000000,B00000001,B00000011,B00000111},/* mod 3 */
  1123.     {0, B00000000,B00000000,B00000000,B00000000,B00000001,B00000011,B00000111,B00001111},/* mod 4 */
  1124.     {0, B00000000,B00000000,B00000000,B00000001,B00000011,B00000111,B00001111,B00011111},/* mod 5 */
  1125.     {0, B00000000,B00000000,B00000001,B00000011,B00000111,B00001111,B00011111,B00111111},/* mod 6 */
  1126.     {0, B00000000,B00000001,B00000011,B00000111,B00001111,B00011111,B00111111,B01111111},/* mod 7 */
  1127. };
  1128. /*
  1129.  * used by bitstream routines
  1130.  */
  1131. int bitstream_maxbyte, bitstream_bitaddr ;
  1132. char *bitstream_buf;
  1133. /* initialize bitstream for output */
  1134. static int initOutputBitStream( char *buf ,int buflen)
  1135. {
  1136.     bitstream_bitaddr = 0;
  1137.     bitstream_maxbyte = buflen;
  1138.     bitstream_buf = buf;
  1139.     memset( buf,0, buflen);
  1140.     return 0;
  1141. }
  1142. /* initialize bitstream for input */
  1143. static int initInputBitStream( char *buf , int buflen)
  1144. {
  1145.     bitstream_bitaddr = 0;
  1146.     bitstream_maxbyte = buflen;
  1147.     bitstream_buf = buf;
  1148.     return 0;
  1149. }
  1150. /*
  1151.  * read from bit stream. used only from 1 bit to 8 bits
  1152.  * this is a base routine
  1153.  */
  1154. static unsigned int readInputBitStreamBody( int bwidth )
  1155. {
  1156.     int mod = bitstream_bitaddr % 8;
  1157.     int byteaddr = bitstream_bitaddr / 8;
  1158.     /* return if excess */
  1159.     if( byteaddr >= bitstream_maxbyte)return 0;
  1160.     if( bwidth >= 1 && bwidth <= 8){
  1161.         int b1 = (( bitstream_buf[byteaddr] & saacproto_modifymask_first[mod][bwidth] )>>mod);
  1162.         int b2 = (( bitstream_buf[byteaddr+1] & saacproto_modifymask_second[mod][bwidth])<<(8-mod));
  1163.         bitstream_bitaddr += bwidth;
  1164.         return  b1 | b2;
  1165.     } else {
  1166.         return 0;
  1167.     }
  1168. }
  1169. /*
  1170.  *  read from bit stream. used from 1 bit to 32 bits
  1171.  *
  1172.  */
  1173. static unsigned int readInputBitStream( int bwidth )
  1174. {
  1175.     if( bwidth <= 0 ){
  1176.         return 0;
  1177.     } else if( bwidth >= 1 && bwidth <= 8 ){
  1178.         return readInputBitStreamBody( bwidth );
  1179.     } else if( bwidth >= 9 && bwidth <= 16 ){
  1180.         unsigned int first = readInputBitStreamBody(8);
  1181.         unsigned int second = readInputBitStreamBody( bwidth-8);
  1182.         return first + (second << 8 );
  1183.     } else if( bwidth >= 17 && bwidth <= 24 ){
  1184.         unsigned int first = readInputBitStreamBody(8);
  1185.         unsigned int second = readInputBitStreamBody(8);
  1186.         unsigned int third = readInputBitStreamBody(bwidth-8);
  1187.         return first + ( second << 8 ) + ( third << 16 );
  1188.     } else if( bwidth >= 25 && bwidth <= 32 ){
  1189.         unsigned int first = readInputBitStreamBody(8);
  1190.         unsigned int second = readInputBitStreamBody(8);
  1191.         unsigned int third = readInputBitStreamBody(8);
  1192.         unsigned int forth = readInputBitStreamBody(bwidth-8);
  1193.         return first + ( second << 8 ) + ( third << 16 ) + ( forth << 24 );
  1194.     }
  1195. return 0;
  1196. }
  1197. /*
  1198.  * write to a bitstream. only used from 1 bit to 8 bits
  1199.  * this is a base routine.
  1200.  */
  1201. static int writeOutputBitStreamBody( int bwidth , unsigned char b)
  1202. {
  1203.     int mod = bitstream_bitaddr % 8;
  1204.     int byteaddr = bitstream_bitaddr / 8;
  1205.     /* return error if excess */
  1206.     if( bitstream_maxbyte <= (byteaddr+1)) return -1;
  1207.     bitstream_buf[byteaddr] &= saacproto_modifymask_first[mod][bwidth];
  1208.     bitstream_buf[byteaddr] |= (b << mod) & saacproto_modifymask_first[mod][bwidth];
  1209.     bitstream_buf[byteaddr+1] &= saacproto_modifymask_second[mod][bwidth];
  1210.     bitstream_buf[byteaddr+1] |= (b>>(8-mod))& saacproto_modifymask_second[mod][bwidth];
  1211.     bitstream_bitaddr += bwidth;
  1212.     return byteaddr+1;
  1213. }
  1214. /*
  1215.  * write to a bitstream. used from 1 bits to 32 bits
  1216.  * returns -1 if error or buffer excession
  1217.  */
  1218. static int writeOutputBitStream( int bwidth, unsigned int dat)
  1219. {
  1220.     int ret;
  1221.     if( bwidth <= 0){
  1222.         return -1;
  1223.     } else if( bwidth >= 1 && bwidth <= 8 ){
  1224.         if((ret=writeOutputBitStreamBody( bwidth , (unsigned char)dat))<0)return -1;
  1225.     } else if( bwidth > 8 && bwidth <= 16 ){
  1226.         if(writeOutputBitStreamBody( 8 , (unsigned char)(dat&0xff))<0)return -1;
  1227.         if((ret=writeOutputBitStreamBody( bwidth - 8 , ( unsigned char)((dat>>8)&0xff)))<0)return -1;
  1228.     } else if( bwidth > 16 && bwidth <= 24 ){
  1229.         if(writeOutputBitStreamBody( 8 , (unsigned char)(dat&0xff))<0)return -1;
  1230.         if(writeOutputBitStreamBody( 8 , (unsigned char)((dat>>8)&0xff))<0)return -1;
  1231.         if((ret=writeOutputBitStreamBody( bwidth-16,(unsigned char)((dat>>16)&0xff)))<0)return -1;
  1232.     } else if( bwidth > 24 && bwidth <= 32 ){
  1233.         if(writeOutputBitStreamBody( 8 , (unsigned char)(dat&0xff))<0)return -1;
  1234.         if(writeOutputBitStreamBody( 8 , (unsigned char)((dat>>8)&0xff))<0)return -1;
  1235.         if(writeOutputBitStreamBody( 8 , (unsigned char)((dat>>16)&0xff))<0)return -1;
  1236.         if((ret=writeOutputBitStreamBody( bwidth-24,(unsigned char)((dat>>24)&0xff)))<0)return -1;
  1237.     } else {
  1238.         return -1;
  1239.     }
  1240.     return ret;
  1241. }
  1242. #define CHAR_SIZE 256
  1243. #define NODE_SIZE 512
  1244. #define BITS_LEN 9          /* 9 bit lzw compression */
  1245. typedef struct {
  1246.     unsigned char chr;
  1247.     int parent;
  1248.     int brother;
  1249.     int child;
  1250. }NODE;
  1251. long saacproto_ringoCompressor( unsigned char *code , long codelen ,
  1252.             unsigned char *text , long textlen)
  1253. {
  1254.     NODE node[NODE_SIZE];
  1255.     int freeNode;        
  1256.     int w,k;        /* used in this algo */
  1257.     int textind;    /* index to text buffer */
  1258.     int i;
  1259.     int position = 0;   /* indicates the last byte of code buffer */
  1260.     if( textlen <= 0 ) return -1;
  1261.     initOutputBitStream((char*) code,codelen);
  1262.     /* fill characters ( 0 ~ 255 ) in the beggining part of
  1263.        Node list */
  1264.     for(i=0; i<= CHAR_SIZE; i++){
  1265.         node[i].chr = (unsigned char)i;
  1266.         node[i].brother = i + 1;
  1267.         node[i].parent = 0;
  1268.         node[i].child = 0;
  1269.     }
  1270.     node[CHAR_SIZE].brother = 0;
  1271.     freeNode = CHAR_SIZE + 1;
  1272.     w = text[0];
  1273.     textind = 1;
  1274.     while(1){
  1275.         int rv;
  1276.         if( textind >= textlen ){
  1277.             k = CHAR_SIZE;      /* indicates EOF */
  1278.         } else {
  1279.             k = text[textind];
  1280.         }
  1281.         /* search if pattern 'wk' is registered or not. */
  1282.         rv = node[w].child;
  1283.         while(1){
  1284.             if( rv <= 0 ) break;
  1285.             if( node[rv].chr == k ) break;
  1286.             rv = node[rv].brother;
  1287.         }
  1288.         if( rv > 0 ){
  1289.             /* found it */
  1290.             w = rv;
  1291.         } else {
  1292.             position = writeOutputBitStream( BITS_LEN ,w  );
  1293.             /* return if buffer excession  */
  1294.             if( position > codelen ) return -1;
  1295.             /* register pattern 'wk' in the dictionary */
  1296.             if( freeNode < NODE_SIZE ){
  1297.                 node[freeNode].parent = w;
  1298.                 node[freeNode].chr = k;
  1299.                 node[freeNode].brother = node[w].child;
  1300.                 node[freeNode].child = 0;
  1301.                 node[w].child = freeNode;
  1302.                 freeNode++;
  1303.             }
  1304.             w = k;
  1305.         }
  1306.         if( textind == ( textlen + 1 )  ) break;
  1307.         textind++;
  1308.     }
  1309.     return position;
  1310. }
  1312. /*
  1313.  * Decoder.
  1314.  * return -1 if buffer excession. Notice buffer text
  1315.  * is modified .
  1316.  */
  1317. long saacproto_ringoDecompressor( unsigned char *text , long textlen ,
  1318.             unsigned char *code , long codelen)
  1319. {
  1320.     NODE node[NODE_SIZE];
  1321.     int stack[NODE_SIZE];
  1322.     int sp;
  1323.     int freeNode;
  1324.     int len;
  1325.     int i;
  1326.     int k = 0;
  1327.     int w = 0;
  1328.     if( codelen <= 0 ) return -1;
  1329.     initInputBitStream( (char*)code , codelen );
  1330.     for(i=0;i<CHAR_SIZE;i++){
  1331.         node[i].chr = (unsigned char)i;
  1332.         node[i].brother = i+1;
  1333.         node[i].parent = 0;
  1334.         node[i].child = 0;
  1335.     }
  1336.     node[CHAR_SIZE].brother = 0;
  1337.     freeNode = CHAR_SIZE + 1;
  1338.     len=0;  /* index to text buffer */
  1339.     sp=0;   /* stack pointer */
  1340.     while(1){
  1341.         int rv = 0;
  1342.         rv = readInputBitStream( BITS_LEN );
  1343.         /* return OK if EOF */
  1344.         if( rv == CHAR_SIZE ) break;        
  1345.         if( rv >= freeNode ){
  1346.             stack[sp++] = k;            /* exception */
  1347.             if( sp >=( sizeof( stack ) /sizeof(stack[0] )) )return -1;   
  1348.             k = w;
  1349.         } else {
  1350.             k = rv;
  1351.         }
  1352.         while(k> CHAR_SIZE ){
  1353.             if( k >= (sizeof(node)/sizeof(node[0]))) return -1;
  1354.             stack[sp++] = node[k].chr;
  1355.             k = node[k].parent;
  1356.             if( sp >=( sizeof( stack ) /sizeof(stack[0] )) ) return -1;
  1357.         }
  1358.         stack[sp++] = k;
  1359.         if( sp >= ( sizeof( stack ) /sizeof(stack[0] )) ) return -1;
  1360.         /* output to text buffer from stack.*/
  1361.         while(sp){
  1362.             if( ++len > textlen ) return -1;
  1363.             *text++ = stack[--sp];
  1364.         }
  1365.         /* register the pattern 'wk'*/
  1366.         if( len > 1 && freeNode < NODE_SIZE ){
  1367.             node[freeNode].parent = w;
  1368.             node[freeNode].chr = k;
  1369.             if( w >= (sizeof(node)/sizeof(node[0])))return -1;
  1370.             node[freeNode].brother = node[w].child;
  1371.             node[freeNode].child = 0;
  1372.             node[w].child = freeNode;
  1373.             freeNode++;
  1374.         }
  1375.         w = rv;
  1376.     }
  1377.     return len;
  1378. }
  1379. #endif  /* ifdef saacproto__ENCRYPT */
  1381. /* Convert 62-base digits to 10 digits */
  1382. int saacproto_a62toi( char *a )
  1383. {
  1384. int ret = 0;
  1385. int minus ;
  1386. if( a[0] == '-' ){
  1387. minus = -1;
  1388.         a++;
  1389. } else {
  1390. minus = 1;
  1391. }
  1393. while( *a != '' )
  1394. {
  1395. ret *= 62;
  1396. if( '0' <= (*a) && (*a) <= '9' )
  1397. ret += (*a)-'0';
  1398. else
  1399. if( 'a' <= (*a) && (*a) <= 'z' )
  1400. ret += (*a)-'a'+10;
  1401. else
  1402. if( 'A' <= (*a) && (*a) <= 'Z' )
  1403. ret += (*a)-'A'+36;
  1404. else
  1405. return 0;
  1406. a++;
  1407. }
  1408. return ret * minus;
  1409. }
  1411. /*  Convert 10-base digits into 62-base digits. */
  1412. char *saacproto_cnv10to62( int a, char *out, int outlen )
  1413. {
  1414. int i, j;
  1415.     char    base[] = { "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"};
  1416.     int     tmp[64];
  1417.     int     src;
  1418.     int minus;
  1419. int baselen = sizeof( base)-1;
  1420.     if( a < 0 ){
  1421. minus = 1;
  1422. a *= -1;
  1423. } else {
  1424. minus = 0;
  1425. }
  1426.     /* special case */    
  1427.     if( a < baselen) {
  1428. if( minus ){
  1429. *(out) = '-';
  1430. *(out+1) = base[a];
  1431. *(out+2) = '';
  1432. return (out);
  1433. } else {
  1434. *out = base[a];
  1435. *(out+1) = '';
  1436. return( out);
  1437. }
  1438.     }
  1439.     src = a;
  1440.     for( i = 0; src >= baselen; i ++ ) {
  1441.         tmp[i] = src % baselen;
  1442.         src /= baselen;
  1443.     }
  1444.     i--;
  1445.     if( minus ){
  1446. *out = '-';
  1447.       *(out+1) = base[src];
  1448. for( j = 2; i >= 0; i --, j ++ ) {
  1449. if( j > outlen - 2 ) return NULL;
  1450. *(out+j) = base[tmp[i]];
  1451. }
  1452. } else {
  1453.       *out = base[src];
  1454. for( j = 1; i >= 0; i --, j ++ ) {
  1455. if( j > outlen - 2 ) return NULL;
  1456. *(out+j) = base[tmp[i]];
  1457. }
  1458. }
  1459. *(out+j) = '';
  1460.     return( out);
  1461. }