//--------------------------------------  
// USSD EAE write for ussd test
// Author: lw 2006/7/10
//--------------------------------------

#include "./include/smpp.h"

#define ISDN_LEN 8

typedef struct PPPChatSession
{
        BYTE   LinkNo;
        BYTE   flag;
        BYTE   sid;
        BYTE   link_sid;
        BYTE   link_flag;
        BYTE   seed[4];
        BYTE   ssm_state;
        BYTE   shmsg[256];
        BYTE   us_prm;
        BYTE   input[4];
        BYTE   history[512];
        BYTE   count;
        char   msisdn[ISDN_LEN*2+1];
        char   mt_msisdn[ISDN_LEN*2+1];
        char   buf[256];
}
PPPChatSession;

typedef enum _USSD_OP
{
	PSSDR = 0 ,  // MAP_Process_USS_Data request operation
	PSSRR = 1 ,  // MAP_Process_USS_Request request operation
	USSRR = 2 ,  // MAP_USS_Request Request operation
	USSNR = 3 ,  // MAP_USS_Notify Request operation
	OPENR = 5 ,  // open request operation
	RELR  = 6 ,  // Release request operation
	
	PSSDE = 7 ,  // MAP_Process_USS_Data error   operation
	PSSRE = 8 ,  // MAP_Process_USS_Request error   operation
	USSRA = 9 ,  // MAP_USS_Request Answer  operation
	USSRE = 10,  // MAP_USS_Request Error   operation
	USSNE = 11,  // MAP_USS_Notify Error   operation
	USSNA = 12,  // MAP_USS_Notify Answer  operation
	OPENE = 13,  // open error   operation
	RELE  = 14,  // Release error   operation
	UTEST = 15,  // USSD TEST Message
	
	PSSDS = 16,  // MAP_Process_USS_Data confirm operation
	PSSRS = 17,  // MAP_Process_USS_Request confirm operation
	USSRC = 18,  // MAP_USS_Request Confirm operation
	USSNC = 19,  // MAP_USS_Notify Confirm operation
	PSSRC = 20,  // MAP_Process_USS_Request confirm operation
	OPENC = 21,  // open confirm operation
	RELC  = 22,  // Release confirm operation
} 
USSD_OP;

typedef enum US_STATE
{
	 US_IDLE=0,
	 US_OPENR,
	 US_OPENC,
	 US_OPENE,
	 US_PSSRR,
	 US_PSSRA,
	 US_PSSRE,
	 US_PSSRC,
	 US_PSSRS,
	 US_USSRR,
	 US_USSRC,
	 US_USSRS,
	 US_USSNR,
	 US_USSNC,
	 US_USSNS,
	 US_RELER,
	 US_RELEC,
	 US_RELEE,
}
US_STATE;

#define MAX_GAME_SESSION 255

typedef struct GuessGame
{
	     BYTE   wxc2_hlr_number[8];
	     BYTE   link_enable;
       BYTE   link;	     
}GuessGame;

GuessGame gg;


struct PPPChatSession ssm_data[MAX_GAME_SESSION];

#define SD_PKT_NUM	10
#define STORE_MSG_ITEM	60

typedef struct	SMPP_MSG_STORE_STRUCT
{
	BYTE	short_message[SMPP_MSG_LEN];
	BYTE	message_id[65];
} SMPP_MSG_STORE_STRUCT;


#define MAX_GAME_LINK 1

static struct itimerval itimer,old_itimer;
static int		timer_counter[MAX_GAME_LINK];
static int		stateFlag[MAX_GAME_LINK];
static int		msg_count[MAX_GAME_LINK];
static int		msg_pointer[MAX_GAME_LINK];
static SMPP_MSG_STORE_STRUCT	store_msg_buf[MAX_GAME_LINK][STORE_MSG_ITEM];

static void On_Timer();
static void SetTimer();
static void smpp_test_init();
static int  smpp_onDataRecv(BYTE linkNo, SMPP_MSG *pData, WORD dataLen);
static int  smpp_onLinkStateChange(BYTE linkNo, BYTE linkstate);

BYTE hae_isdn_ston(BYTE *normal_isdn,BYTE *str_isdn)
{
	BYTE		ii;
	BYTE		len;

	len = strlen(str_isdn);
	if (len > ISDN_LEN*2-2)
		return 0;
	if ((len % 2) == 1)		// odd number
	{
		AsciiToBcd(normal_isdn+1,str_isdn,len-1);
		ii = len/2 + 1;
		normal_isdn[ii] = (str_isdn[len-1] - '0') << 4;
		normal_isdn[ii] |= 0x0E;
	}
	else
	{
		AsciiToBcd(normal_isdn+1,str_isdn,len);
		ii = len/2;
	}
	memset(normal_isdn+ii+1,0xEE,ISDN_LEN-ii-1);
	normal_isdn[0] = 0x91;	// default value
	return 1;
}


void hae_isdn_ntos(BYTE *str_isdn,BYTE *normal_isdn)
{
	BYTE		len = 0;
	BYTE		ii,jj;

	for (ii = 1;ii < ISDN_LEN;ii ++)
	{
		jj = (normal_isdn[ii] >> 4) & 0x0f;
		if (jj > 0x0c)
			break;
		str_isdn[len++] = jj + '0';
		jj = normal_isdn[ii] & 0x0f;
		if (jj > 0x0c)
			break;
		str_isdn[len++] = jj + '0';
	}
	str_isdn[len] = '\0';
}

int register_link()
{
	BYTE	        ret;
	
	if( gg.link == MAX_SMPP_LINK+1 )
	{
		ret = smpp_registerLink(SMPP_CLIENT, BIND_TRX, gg.wxc2_hlr_number, TRANSACTION);
		if ((ret&0x80) == 0x80) 
		{
			 gg.link = ret&0x7f;
			 printf("Get link for GuessGame EAE .link:%d",  gg.link);
			 smpp_attach_link(gg.link, smpp_onDataRecv, smpp_onLinkStateChange);
			 return 1;
		}
  }
  else
  {
  	  smpp_attach_link(gg.link, smpp_onDataRecv, smpp_onLinkStateChange);
	    return 1;
  }
	return 0;
}

void smpp_test_init(int flag)
{
	int  i;
	
	FILE *fp;
	char line[32];
	BYTE  temp_isdn[ISDN_LEN+1];
	BYTE  temp_msisdn[65];
	char test_file[] = "./conf/guess_number_test.conf";
	
  gg.link_enable = 0;
  gg.link = MAX_SMPP_LINK+1;
	for (i=0; i<MAX_GAME_LINK; i++)
	{
		memset(store_msg_buf[i], 0, sizeof(SMPP_MSG_STORE_STRUCT)*STORE_MSG_ITEM);
		msg_pointer[i]	= 0;
	}
	strcpy(gg.wxc2_hlr_number, "86755001");
	register_link();
	
	if( flag )
	{
			fp = fopen( test_file , "r");
			if( fp == NULL )
			{
				  printf("Open %s file fail!\n", test_file );
			}
			
			
			 while ( !feof ( fp ) )
		   {
		        if( fgets ( line, 256, fp ) == NULL )
		        {
		            break;
		        }
		        
		        for( i = 16 ; i > 6 ; i -- )
		        {
		        	 if( line[i] == ' ' || line[i] == '\t' || line[i] == '\r' || line[i] == '\n')
		        	 {
		        	 	  continue;
		        	 }
		        	 else if( isdigit( line[i] ) )
		        	 {
		        	 	  break;
		        	 }
		        }
		        if( i < 16 && i > 6 )
		        {
		        	 line[i+1] = '\0';
		        } 
		        line[16] = '\0';
		        for( i = 0 ; i <  MAX_GAME_SESSION ; i ++ )
		    	  {
		
		    	  	 	 if( !ssm_data[i].flag )
		    	  	 	 {
		    	  	 	    ssm_data[i].flag = 1;
		    	  	 	    ssm_data[i].ssm_state =6;
		    	  	 	    printf("read msisdn :%s\n",line);
		    	  	 	    strcpy ( temp_msisdn, line );
		                hae_isdn_ston ( temp_isdn, temp_msisdn ); 
		                memcpy( ssm_data[i].msisdn ,  temp_isdn , ISDN_LEN);   
		                break;
		             }
		    	 }
		   }
	}
}



int main(int argc,char *argv[])
{
	int i;
	char ret;

	heartbeat_init(0xFFFF);
	debug_init();
	iptrMainInit();
	snmp_init(SMPP_PORT);
	mtp_shm_init();
	sccp_init();

	smpp_init_new();
	while ((ret = getopt(argc,argv,"n")) != -1)
	{
		switch (ret)
		{
			case 'n':
				printf("\n\n\nNetwork initial ussd to ms\n\n\n");
				smpp_test_init(1);
				break;
			default:
				smpp_test_init(0);
				break;
		}
	}
	
  
	for (i=0; i<MAX_GAME_LINK; i++)
	{
		stateFlag[i]	= FALSE;
		timer_counter[i]= 0;
		msg_count[i]	= 0;
	}

	opterr = 0;
	


	SetTimer();
	while(1)
	{
		usleep(50);
	}
	return 1;
}

void ChatFsm();

static int call_flag = 0;

void On_Timer()
{
	int i;
	

	for (i=0; i<MAX_GAME_LINK; i++)
	{	// 2 msgs per second
		if (timer_counter[i]==25)
			timer_counter[i]=0;
		if ((timer_counter[i]%25)==0)
		{
			if( (call_flag++)%2 == 0 )
			{ 
			   ChatFsm();
			}
		}
		timer_counter[i]++;

		if (msg_count[i] == SD_PKT_NUM)
		{
			smpp_close(i);
		}
	}

	iptrans_timer();
	debug_rt();
	snmp_timer();
	mtp3_proc();
	heartbeat_timer();
	sccp_timer();
	smpp_fsm_new();
}

void SetTimer()
{
	struct sigaction	act;
	act.sa_handler=On_Timer;
	sigemptyset(&act.sa_mask);
	act.sa_flags=0;
	if(sigaction(SIGALRM,&act,NULL)<0)
	{
		perror("Produce Sigaction");
		exit(1);
	}
	
	itimer.it_interval.tv_sec=0;
	itimer.it_interval.tv_usec=20*1000;
	itimer.it_value.tv_sec=0;
	itimer.it_value.tv_usec=20*1000;

	if (setitimer(ITIMER_REAL,&itimer,&old_itimer) !=0 )
	{
		printf("Setting Timer  error! \n");
		exit(1);
	}
}




int smpp_onDataRecv(BYTE linkNo, SMPP_MSG *pMsg, WORD dataLen)
{
	int sequence_number=100;
	SMPP_MSG	smpp_msg;
	int i;
	BYTE  temp_isdn[ISDN_LEN+1];
	BYTE  temp_msisdn[65];
	struct PPPChatSession *ssm_ptr;

	switch (pMsg->message_type)
	{

	case 0x0C:	/* SUBMIT SM RESP */
		printf("[TEST PROGRAM]Link %d received SUBMIT SM RESP.\n", linkNo);
		break;
	case 0x0F:	/* DELIVER SM */
		printf("[TEST PROGRAM]Link %d received DELIVER SM. op:%d \n", linkNo , pMsg->pdu.deliver_sm.ussd_service_op);
    switch( pMsg->pdu.deliver_sm.ussd_service_op )
    {
    	 case PSSRR:
    	 	    smpp_send_ascout("\33[32mPPP Chat Recv PSSRR\33[0m\n");
    	 	    if( pMsg->pdu.deliver_sm.user_message_reference >=  MAX_GAME_SESSION )
    	      {
    	      	   smpp_send_ascout("\33[32mThe session id is too large!\33[0m\n");
    	      	   return -1;
    	      }
    	 	    for( i = 0 ; i <  MAX_GAME_SESSION ; i ++ )
    	      {
    	  	     if( pMsg->pdu.deliver_sm.user_message_reference == ssm_data[i].sid ||  pMsg->pdu.deliver_sm.user_message_reference == ssm_data[i].link_sid )
    	  	     {
    	  	 	       if( ssm_data[i].flag == 1)
    	  	 	       {
	                    smpp_send_ascout("\33[32mThe session id is in used!\33[0m\n");
    	  	 	   	      return -1;
    	  	 	       }
    	  	 	       ssm_data[i].flag = 1;
    	  	 	       ssm_data[i].ssm_state =1;
    	  	 	       strcpy ( temp_msisdn, pMsg->pdu.submit_sm.source_addr );
                   hae_isdn_ston ( temp_isdn, temp_msisdn ); 
                   memcpy( ssm_data[i].msisdn ,  temp_isdn , ISDN_LEN);
                   if( pMsg->pdu.deliver_sm.short_message_len <= ISDN*2 )
                   {
                       memcpy( ssm_data[i].mt_msisdn , pMsg->pdu.deliver_sm.short_message , pMsg->pdu.deliver_sm.short_message_len );
                   }
                   break;
    	  	      }
    	      }
    	      
    	 	    break;
    	 case USSRC:
    	 	    ssm_ptr = &ssm_data[pMsg->pdu.deliver_sm.user_message_reference];
    	 	    ssm_ptr->us_prm = US_USSRC;
    	 	    smpp_send_ascout("\33[32mGuess Game Recv USSRC\33[0m\n");
    	 	    if( pMsg->pdu.deliver_sm.sm_length == 4 )
    	 	    {
    	 	        memcpy( &ssm_ptr->input , &pMsg->pdu.deliver_sm.short_message  ,4);
    	 	        ssm_ptr->input[0] -= '0'; 
    	 	        ssm_ptr->input[1] -= '0';
    	 	        ssm_ptr->input[2] -= '0';
    	 	        ssm_ptr->input[3] -= '0';
    	 	    }
    	 	    strcpy( ssm_ptr->shmsg , pMsg->pdu.deliver_sm.short_message  );
    	 	    ssm_ptr->shmsg[pMsg->pdu.deliver_sm.sm_length]  = '\0';
    	 	    break;
    	 case USSNC:
    	 	    ssm_ptr->us_prm = US_USSNC;
    	 	    smpp_send_ascout("\33[32mGuess Game Recv USSNC\33[0m\n");
    	 	    break;
    	 default:
    	 	    break;
    }
		
		/* fill with DELIVER SM RESP structure. */
		smpp_msg.message_type	= 0x10;
		smpp_msg.pdu.deliver_sm_resp.head.command_status	= htonl(ESME_ROK);
		smpp_msg.pdu.deliver_sm_resp.head.sequence_number	= pMsg->pdu.deliver_sm.head.sequence_number;
		smpp_msg.pdu.deliver_sm_resp.message_id				    = 0x0;
		smpp_send(linkNo, &smpp_msg, dataLen);
		smpp_send_ascout("Send deliver_sm_resp\n");
		call_flag = 0;
		break;
  }
	return sequence_number;
}

int smpp_onLinkStateChange(BYTE linkNo, BYTE linkstate)
{
	printf("[TEST PROGRAM]link %d state change to %d\n",linkNo, linkstate);
	if (linkstate == 1)
		gg.link_enable	= 1;
	else
		gg.link_enable	= 0;

	return linkNo;
}

void SendMsgToSMPP(int sid , BYTE* msg , BYTE ussd_op)
{
	   SMPP_MSG         pMsg;
	   int              data_len;
	   PDU_SUBMIT_SM   *submit_sm;
	   struct PPPChatSession *ssm_ptr;
	   
	   if( sid >= MAX_GAME_SESSION )
	   {
	      ssm_ptr = &ssm_data[sid - MAX_GAME_SESSION]; 
	   }
	   else
	   {
	   	  ssm_ptr = &ssm_data[sid]; 
	   } 
	   memset( &pMsg , 0 , sizeof(SMPP_MSG));
	   
	   submit_sm = &pMsg.pdu.submit_sm; 
	   pMsg.message_type	= 0x0B;
	   pMsg.optional_param_flag1 =  0x08000001;
	   if( sid < MAX_GAME_SESSION )
	     submit_sm->user_message_reference = sid;
	   else
	   	 submit_sm->user_message_reference = 0xFFFF;
	   submit_sm->ussd_service_op        = ussd_op;
	   strcpy( submit_sm->service_type , "USSD" );
	   hae_isdn_ntos( submit_sm->destination_addr , ssm_ptr->msisdn ); 
     submit_sm->sm_length =  strlen( msg );
     strcpy( submit_sm->short_message , msg );
     smpp_send( gg.link , &pMsg , data_len );
}


void ChatFsm()
{
     int rt;
     int i;
     char temp_str[1024];
     struct PPPChatSession *ssm_ptr;
     
     if( !gg.link_enable && !register_link() )
     {
     	    smpp_send_ascout("Try to connect to WXC2 HLR fail\n");
     	    printf("Try to connect to WXC2 HLR fail\n");
  	      return;
     }
     //sprintf(debugBuf,);
	   //smpp_send_ascout("The session id is in used!\n");
     
     for( i = 0 ;i < MAX_GAME_SESSION ; i++)
     {
     	   ssm_ptr = &ssm_data[i];
     	   if( ssm_ptr->flag == 0 )
     	   {
     	   	 continue;
     	   }
		     switch( ssm_ptr->ssm_state )
		     {
		     	    case 0:
		     	    	   continue;
		          case 1:		  
		          	   sprintf(temp_str, "\33[32mPPP Chat recv PSSR  MO:%s MT:%s \nFsm state :% d sid : %d\33[0m\n" 
		          	                   , ssm_ptr->ssm_state , i , ssm_data[i].msisdn , ssm_data[i].mt_msisdn );
		          	   smpp_send_ascout(temp_str);        	   		               
		               sprintf( ssm_ptr->shmsg ," Mobile Phone request to chat with you: 1 : Accept ;\n2 : Reject:\n ");
		               SendMsgToSMPP( i ,ssm_ptr->shmsg , USSRR );
		               sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
		               smpp_send_ascout(temp_str);
		               ssm_ptr->ssm_state = 2;
		               break;
		          case 2:
		               switch( ssm_ptr->us_prm )
		               {
		               	   case US_IDLE:
		               	        break;
		                   case US_RELER:
		                        break;
		                   case US_USSRC:
		                   	    sprintf(temp_str, "\33[32mGame Fsm state :% d sid : %d\33[0m\n" , ssm_ptr->ssm_state , i);
		          	            smpp_send_ascout(temp_str);     
		                   	    if( strlen(ssm_ptr->shmsg) != 4 )
							          	   {
							          	   	   sprintf(temp_str, "\33[32mThe input string length is not 4.\33[0m\n");
		          	                 smpp_send_ascout(temp_str); 
							                   return;
							          	   }  
		                        if( !CheckInput( ssm_ptr->input ) )
		                        {
		                           sprintf( ssm_ptr->shmsg ,"Input is Error! Please input four difference numbers.\n");
		                           SendMsgToSMPP(  i ,ssm_ptr->shmsg , USSRR );
		                        }
		                        rt = GuessNumber( ssm_ptr->input , ssm_ptr->seed ) & 0xFF ;
		                        ssm_ptr->count ++;
		                        if( ssm_ptr->count >= 8 )
		                        {
		                            sprintf ( ssm_ptr->shmsg ,"Game Over!\n");
		                            sprintf ( temp_str , "NO%d:%d%d%d%d ",ssm_ptr->count , ssm_ptr->input[0],ssm_ptr->input[1],ssm_ptr->input[2],ssm_ptr->input[3]);
		                            strcat ( ssm_ptr->history , temp_str );
		                            sprintf ( temp_str         , "->%dA%dB\n" , rt>>4 , rt&0x0F);
		                            strcat  ( ssm_ptr->history , temp_str );
		                            //strcat  ( ssm_ptr->shmsg , ssm_ptr->history );
		                            SendMsgToSMPP( i ,ssm_ptr->shmsg , USSNR );
		                            sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
		                            smpp_send_ascout(temp_str);
		                            ssm_ptr->ssm_state = 3;
		                            ssm_ptr->us_prm  = US_IDLE;
		                            return ;
		                        }
		                        sprintf( temp_str , "NO%d:%d%d%d%d ",ssm_ptr->count , ssm_ptr->input[0],ssm_ptr->input[1],ssm_ptr->input[2],ssm_ptr->input[3]);
		                        if( rt != 0x40 )
		                        {
		                            strcat ( ssm_ptr->history , temp_str );
		                            sprintf( temp_str         , "->%dA%dB\n" , rt>>4 , rt&0x0F);
		                            strcat ( ssm_ptr->history , temp_str );
		                            strcpy ( ssm_ptr->shmsg   , ssm_ptr->history ); 
		                            SendMsgToSMPP( i ,ssm_ptr->shmsg , USSRR );
		                            sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
		                            smpp_send_ascout(temp_str);
		                            ssm_ptr->us_prm  = US_IDLE;
		                        }
		                        else
		                        {
		                            strcat ( ssm_ptr->history , temp_str );
		                            sprintf( temp_str         , "->%dA%dB\n" , rt>>4 , rt&0x0F);
		                            strcat ( ssm_ptr->history , temp_str );
		                            strcpy ( ssm_ptr->shmsg   , ssm_ptr->history ); 
		                            SendMsgToSMPP( i ,ssm_ptr->shmsg , USSNR );
		                            sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
		                            smpp_send_ascout(temp_str);
		                            ssm_ptr->ssm_state = 3;
		                            ssm_ptr->us_prm  = US_IDLE;
		                        }
		                        break;     
		               }
		               break;
              case 3:
              	   if( ssm_ptr->us_prm == US_USSNC )
              	   {
              	       switch( ssm_ptr->count )
		                   {
		                     case 1:
		                        sprintf ( ssm_ptr->shmsg ," So Luck!\n");
		                        break;
		                     case 2:
		                        sprintf ( ssm_ptr->shmsg ," Luck\n");
		                        break;
		                     case 3:
		                        sprintf ( ssm_ptr->shmsg ," Perfect\n");
		                        break;
		                     case 4:
		                        sprintf ( ssm_ptr->shmsg ," Very Good\n");
		                        break;
		                     case 5:
		                        sprintf ( ssm_ptr->shmsg ," Good\n");
		                        break;
		                     case 6:
		                     case 7:
		                     case 8:
		                        sprintf ( ssm_ptr->shmsg ," Correct\n");
		                        break;
		                     default:
		                     	  strcpy ( ssm_ptr->shmsg   , ssm_ptr->history ); 
		                     	  SendMsgToSMPP( i ,ssm_ptr->shmsg , USSNR );
		                        sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
		                        smpp_send_ascout(temp_str);
		                        ssm_ptr->ssm_state = 4;
		                     	  return;
		                     	  break;
		                  }
		                  SendMsgToSMPP( i ,ssm_ptr->shmsg , USSNR );
		                  sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
		                  smpp_send_ascout(temp_str);
		                  ssm_ptr->ssm_state = 4;
		               }
		          case 4:
		          	   if( ssm_ptr->us_prm == US_USSNC )
              	   {
			          	   sprintf(temp_str, "\33[32mGame Fsm state :% d sid : %d\33[0m\n" , ssm_ptr->ssm_state , i);
			          	   smpp_send_ascout(temp_str); 
			               sprintf( ssm_ptr->shmsg ," Guess Number\n1 . Restart game \n 2 . exit\n");
			               SendMsgToSMPP( i ,ssm_ptr->shmsg , USSRR );
			               ssm_ptr->ssm_state = 5;  
			               sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
			               smpp_send_ascout(temp_str);
			             }
		               break;
		          case 5:
		          	   if( ssm_ptr->us_prm == US_USSNC )
              	   {
			                if( ssm_ptr->shmsg[0] == '1' )
			                {
			                	 if( !RandomNum( ssm_ptr->seed ) )
		                     {
		                          //"Create random number fail"
		                          return;
		                     }   
		                     sprintf( ssm_ptr->shmsg ," Game Restart.input four difference numbers: \n");
			                   SendMsgToSMPP( i ,ssm_ptr->shmsg , USSRR );
			                   ssm_ptr->ssm_state = 2;
			                }  
			                else if( ssm_ptr->shmsg[0] == '2' )
			                {
			                	 sprintf( ssm_ptr->shmsg ," Game Exit.GoodBye! Wellcome to use WXC2 system!\n");
			                   SendMsgToSMPP( i ,ssm_ptr->shmsg , USSNR );
			                   ssm_ptr->ssm_state = 0;
			                   ssm_ptr->flag = 0;
			                } 
			                else
			                {
			                	 sprintf( ssm_ptr->shmsg ," Unexpeced menu selection!\n");
			                   SendMsgToSMPP( i ,ssm_ptr->shmsg , USSNR );
			                }
			                sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
			                smpp_send_ascout(temp_str);
			             }
		          	   break;
		         case 6:
		         	     if( gg.link_enable )
		         	     {
			         	     sprintf(temp_str, "\33[32mGame Fsm state :% d sid : %d\33[0m\n" , ssm_ptr->ssm_state , i);
			          	   smpp_send_ascout(temp_str);        	   
			               if( !RandomNum( ssm_ptr->seed ) )
			               {
			                   //"Create random number fail"
			                   return;
			               }     
			               sprintf( ssm_ptr->shmsg ," WellCome to WXC2 Online Guess Number Game System!\n Please input you guess nubmer:\n");
			               SendMsgToSMPP( i+MAX_GAME_SESSION ,ssm_ptr->shmsg , USSRR );
			               sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
			               smpp_send_ascout(temp_str);
		                 ssm_ptr->ssm_state = 2;
		         	     }
		         	     break;
		     }
     }
}