saacproto_lserver.c

最新主流石器時代源代碼,包含諸多目前流行功能代碼.

#include "saacproto_lserver.h"
#include "saacproto_serv.h"
#include "main.h"
#include "char.h"
#include "util.h"
#include "version.h"


#ifdef _LOCK_SERVER

LServer Ls;
LSMem *LSbufHead;
SAMessC *SAMess;

struct timeval select_timeout;
void REreadConfig( char *path );
BOOL LSbuffInit()
{
	//LSbufHead->next = NULL;
	//LSbufHead = NULL;
	return TRUE;
}

BOOL LServerInit()
{
	int i;
	if( Ls.data[LS_FD] >= 0 )
		close( Ls.data[LS_FD]);
	for( i=0;i<LS_MAXDATA;i++)	{
		Ls.data[i] = 0;
	}
	Ls.data[LS_TYPE] = LSTYPE_NORMAL;
	Ls.data[LS_FD] = -1;
	memset( Ls.address, 0, sizeof( Ls.address));
	Ls.errs = 0;
	return TRUE;
}

BOOL connectToLServer( char *laddress, int lport)
{
    int ti;
	if( Ls.data[LS_USE] )	{
		return FALSE;
	}
	if( (ti = tcpip_connect( laddress, lport)) == LS_OK)	{
		Ls.data[LS_TI] = ti;
		Ls.data[LS_USE] = 1;
		Ls.data[LS_LASTTIME] = 0;
		Ls.data[LS_TYPE] = LSTYPE_STANDBY;
		Ls.data[LS_PORT] = lport;
		Ls.errs = 0;
		snprintf( Ls.address, sizeof( Ls.address),"%s", laddress);
		Ls.data[LS_LASTERROR] = -1;
		log("LS[use:%d, FD:%d, TI:%d, address:%s, port:%d]...\n", Ls.data[LS_USE], Ls.data[LS_FD],
			Ls.data[LS_TI], Ls.address, Ls.data[LS_PORT]);
	} else {
		Ls.data[LS_LASTERROR] = ti;
		return FALSE;
	}
	return TRUE;
}

BOOL DisConnectLServer()
{
	if( Ls.data[LS_USE])	{
		Ls.data[LS_LASTERROR] = LSMESS_NOCONNECT;
		Ls.data[LS_USE] = 0;
		Ls.errs = 0;
		return FALSE;
	}

    close( Ls.data[LS_FD]);
	Ls.data[LS_FD] = -1;
	LServerInit();

	while( LSbufHead != NULL )	{
		DEL_LS_MemBufferHead();
	}
    return TRUE;
}

int tcpip_connect( char *addr , int port)
{
    int s, r;
    struct sockaddr_in svaddr;
    struct hostent *he;
    
    s = socket( AF_INET, SOCK_STREAM , 0 );
    if(s<0) return LSMESS_SOCKERROR;
    bzero( &svaddr , sizeof( svaddr ));
    svaddr.sin_family = AF_INET;
    svaddr.sin_port = htons( port );

    if( inet_aton( addr, &svaddr.sin_addr ) == 0 ){
        he = gethostbyname( addr );
        if( he == NULL ){
            return LSMESS_HOSTERROR;
        }
        memcpy( & svaddr.sin_addr.s_addr , he->h_addr, sizeof( struct in_addr));
    }
    r = connect( s , ( struct sockaddr*)&svaddr,sizeof(svaddr));
    if( r < 0 ) return LSMESS_NOCONNECT;
    set_nodelay( s );
	Ls.data[LS_FD] = s;
    return LS_OK;
}
int LS_getData( int stype)
{
	return Ls.data[stype];
}

BOOL TcpIp_LS_accept()
{
    int sret;
    struct timeval t;
	char tmpbuf[4096];
	char send_buf[4096];
	int lsfd = Ls.data[LS_FD];
	LSMem *FlgMem;
    fd_set rfds, wfds , efds;

	FD_ZERO( &rfds );
	FD_ZERO( &wfds );
	FD_ZERO( &efds );
	
    select_timeout.tv_sec = 0;
    select_timeout.tv_usec = 0;

	if( Ls.data[LS_USE] && (lsfd >= 0 ) && !Ls.errs )	{
		FD_SET( lsfd, &rfds );
		FD_SET( lsfd, &wfds );
		FD_SET( lsfd, &efds );
	}else	{
		log(" LS error t1!!\n");
		return FALSE;
	}

    t = select_timeout;
    sret = select( lsfd+1, &rfds , (fd_set*)NULL, &efds , &t);
	if( sret > 0 ) {
		memset( tmpbuf, 0, sizeof( tmpbuf));
		if( ( lsfd >= 0 ) && FD_ISSET( lsfd , &rfds ) ){
			int rr;
			rr = read( lsfd, tmpbuf , sizeof( tmpbuf));
			if( rr <= 0 ){
				Ls.errs = 1;
				Ls.data[LS_LASTERROR] = LSMESS_READERROR;
			} else {
				Add_LS_WRMemBuffer( tmpbuf , rr, MEMREAD); //增加讯息
			}
		}
	}

    t = select_timeout;    
    sret = select( lsfd+1, (fd_set*)NULL, &wfds, &efds , &t);
	if( sret > 0 ) {
		if( ( lsfd >= 0 ) && FD_ISSET( lsfd , &wfds )){
			int l , rr, writesize;
			FlgMem = NULL;
			memset( send_buf, 0, sizeof( send_buf));
			l = MMGet_LS_WRMemBufList( send_buf, sizeof( send_buf), MEMWRITE);
			if( l > 0 ){
				writesize = strlen( send_buf)+1;
				rr = write( lsfd , send_buf , writesize);
				if( rr < 0 ){
					Ls.errs = 1;
				}
			}
		}
	}

    return TRUE;
}

BOOL Add_LS_WRMemBuffer( char *buf, int strlens, int flg)
{
	int i=0;
	LSMem *workLS, *FindLs;
	FindLs = LSbufHead;

	if( Ls.data[LS_LASTTIME] >= 50 )	{
		log( "LS Mess busy:%d\n", Ls.data[LS_LASTTIME]);
		return FALSE;
	}
	while ( 1 )	{
		if( FindLs == NULL || FindLs->next == NULL )
			break;
		FindLs = FindLs->next;
		i++;
	}

	Ls.data[LS_LASTTIME] = i;
	workLS = MEMBUF_getNew();
	if( workLS == NULL )
		return FALSE;
	memcpy( workLS->buf, buf, sizeof( workLS->buf));
	workLS->type = flg;
	workLS->next = NULL;

	if( LSbufHead == NULL )
		LSbufHead = workLS;
	else	{
		FindLs->next = workLS;
	}

	return TRUE;
}

LSMem *MEMBUF_getNew()
{
	LSMem *MBUF=NULL;
	MBUF = (LSMem *) calloc( 1, sizeof( struct MemMessage) );
	if( MBUF == NULL )
		return NULL;
	MBUF->type = 0;
	return MBUF;
}

int MMGet_LsReadBuflist( char *buf, int len)
{
	int l;
	char buf1[256];
	LSMem *FlgMem;
	FlgMem = NULL;
	l = MMGet_LS_WRMemBufList( buf1, len, MEMREAD);
	if( l > 0 )	{
		memcpy( buf, &buf1, 256);
		return strlen( buf1);
	}
	return 0;
}

int MMGet_LS_WRMemBufList(  char *buf, int len, int flg)
{
	LSMem *workLS;
	LSMem *POINT1=NULL;
	workLS = LSbufHead;
	POINT1 = NULL;
	while( workLS != NULL ){
		if( workLS->type == flg )	{
			sprintf( buf, "%s", workLS->buf);
			if( POINT1 == NULL )	{
				LSbufHead = workLS->next;
			}else	{
				POINT1->next = workLS->next;
			}
			free ( workLS);
			return 1;
		}
		POINT1 = workLS;
		workLS = workLS->next;
	}
	return 0;
}

void DEL_LS_MemBufferHead()
{
	LSMem *workLS;
	if( LSbufHead == NULL )
		return;
	if( LSbufHead->next == NULL )
		return;
	workLS = LSbufHead;
	LSbufHead = LSbufHead->next;
	free( workLS);
}

void DEL_LS_MemBufferList( LSMem *FlgMem )
{
	LSMem *workLS=NULL;
	LSMem *POINT1=NULL;

	workLS = LSbufHead;
	POINT1 = NULL;
	while( workLS != NULL)	{
		if( workLS == FlgMem )	{
			if( POINT1 == NULL )	{
				LSbufHead = FlgMem->next;
			}else	{
				POINT1->next = FlgMem->next;
			}
			free( FlgMem);
			return;
		}else	{
			POINT1 = workLS;
			workLS = workLS->next;
		}
	}
}

BOOL CHECK_LS_BEUSE()
{
	if( Ls.data[LS_USE] == 1)
		return TRUE;
	else
		return FALSE;
}

void CHECK_LSTYPE()
{
	static time_t standbyTime;

	if( Ls.data[LS_USE] ){
		if( Ls.errs )	{
			if( DisConnectLServer() == FALSE )	{
				log( "LS Close..\n");
			}else	{
				log( "LS Close error ..!!\n");
			}
		}
		standbyTime = time(NULL);
	}else	{
		if( (standbyTime + 60 ) > time(NULL) )
			return;

		REreadConfig( "saac.cf");
		LServerInit();
		usleep( 200*10000);
		standbyTime = time(NULL);
		if( connectToLServer( LSADDRESS, LSPORT) == FALSE )	{
			log("%s", "LOGIN LServer FAIL!!\n");
			return;
		}else	{
			usleep( 100*10000);
			LServer_SALogin_send();
		}
	}
	//if( Ls.data[LS_LASTTIME] >= 10 )

}

int get_LSFD()
{
	if( Ls.data[LS_USE] )	{
		return Ls.data[LS_FD];
	}
	return -1;
}

void Show_LS_MEMBufferList()
{
	LSMem *workLS=NULL;

	workLS = LSbufHead;
	while( workLS != NULL )	{
		log( "[ %s] ", workLS->buf);
		workLS = workLS->next;
	}

}

int lockproto_SaacDispatchMessage( char *encoded )
{
	int lens;
	char funcname[1024];
	if( SAMESS_setChar( encoded) == FALSE )
		return -1;
	
	memset( funcname, 0, sizeof( funcname));
	if( SAMESS_getChar( funcname, &lens) == FALSE )	{
		log("funcname:NULL\n");
		return 0;
	}

	if( !strcmp( funcname , "TEST" )){
		char buf1[256],buf2[256],buf3[256];
		if( SAMESS_getChar( buf1, &lens) == FALSE ) return 0;
		if( SAMESS_getChar( buf2, &lens) == FALSE ) return 0;
		if( SAMESS_getChar( buf3, &lens) == FALSE ) return 0;
		return 0;
	}

	if( !strcmp( funcname , "SACheckLock1" )){
		char si[256], Pcdkey[256], Pid[256], flg[256], PASS[256];
		if( SAMESS_getChar( si, &lens) == FALSE ) return 0;
		if( SAMESS_getChar( Pcdkey, &lens) == FALSE ) return 0;
		if( SAMESS_getChar( Pid, &lens) == FALSE ) return 0;
		if( SAMESS_getChar( flg, &lens) == FALSE ) return 0;
		if( SAMESS_getChar( PASS, &lens) == FALSE ) return 0;
		LServer_SACheckLock1_recv( si, Pcdkey, Pid, flg, PASS);
		return 0;
	}

	if( !strcmp( funcname , "SACheckLock2" )){
		char si[256], Pcdkey[256], Pid[256], name[256], flg[256], PASS[256];