OCS/ocs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
cook
ocs/mss/main/src/wxc2main.c
zhangsz 025a455e17 feat: create cook branch
2025-03-08 16:40:56 +08:00

2123 lines
47 KiB
C
Raw Permalink Blame History

#include <stdio.h>
#include <time.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <termio.h>
#include <sys/stat.h>
#include <sys/io.h>
#include <sys/utsname.h>
#include "include/wxc2ver.h"
#include "../../plat/snmp/src/include/snmp.h"
#include "../../plat/public/src/include/license_id.h"
#include "../../plat/tcap/src/include/tcap_public.h"
#include "../../plat/radius/src/include/radius.h"
#include "../../plat/tcp/src/include/tcp_if.h"
#define MAX_FUNCTION_ID 16
#define MAX_APP_FUNC_ID 16
#define MAX_License_ID (MAX_FUNCTION_ID+MAX_APP_FUNC_ID)
extern unsigned int wxc2_get_shm_offset();
typedef enum _WXC2_LICENSE_DIR
{
BOTH_IN_DE_CREASABLE,
ONLY_INCREASABLE,
ONLY_DECREASABLE,
}WXC2_LICENSE_DIR;
typedef struct _wxc2_license_vadility
{
char name[16]; /* name of the module or function */
int maxValue; /* max value of the license, the minimum is 0 */
int step; /* step of license, each modification should be X*step */
int dir; /* how to modify the license, 0=can increase or decrease,
1=only increase, 2=only decrease */
}wxc2_license_vadility;
wxc2_license_vadility wxc2_license_rule[MAX_License_ID]=
{
{"MSC TRUNKS",1024,1,ONLY_INCREASABLE},
{"HLR USERS",100000,100,ONLY_INCREASABLE},
{"VLR USERS",100000,100,ONLY_INCREASABLE},
{"AUC USERS",100000,100,ONLY_INCREASABLE},
{"EIR USERS",100000,100,ONLY_INCREASABLE},
{"PPS USERS",100000,100,ONLY_INCREASABLE},
{"SMSC USERS",100000,100,ONLY_INCREASABLE},
{"MNP USERS",100000,100,ONLY_INCREASABLE},
{"SMEG USERS",100000,100,ONLY_INCREASABLE},
{"OPPS USERS",100000,100,ONLY_INCREASABLE},
{"PALIM USERS",100000,100,ONLY_INCREASABLE},
{"Mesh HLR",100000,100,ONLY_INCREASABLE},
{"RMC",100000,100,ONLY_INCREASABLE},
{"",100000,100,ONLY_INCREASABLE},
{"",100000,100,ONLY_INCREASABLE},
{"",100000,100,ONLY_INCREASABLE},
{"GPRS",1,1,BOTH_IN_DE_CREASABLE},
{"USSD",1,1,BOTH_IN_DE_CREASABLE},
{"ISUP",1,1,BOTH_IN_DE_CREASABLE},
{"BICC",1,1,BOTH_IN_DE_CREASABLE},
{"AIF",1,1,BOTH_IN_DE_CREASABLE},
{"MGC",1,1,BOTH_IN_DE_CREASABLE},
{"CAP",1,1,BOTH_IN_DE_CREASABLE},
{"OPPS_OPR",1,1,BOTH_IN_DE_CREASABLE},
{"OPPS_IMDM",1,1,BOTH_IN_DE_CREASABLE},
{"ISDN",1,1,BOTH_IN_DE_CREASABLE},
{"SIP",1,1,BOTH_IN_DE_CREASABLE},
{"RLS",1,1,BOTH_IN_DE_CREASABLE},
{"",1,1,BOTH_IN_DE_CREASABLE},
{"",1,1,BOTH_IN_DE_CREASABLE},
{"",1,1,BOTH_IN_DE_CREASABLE},
{"",1,1,BOTH_IN_DE_CREASABLE}
};
//extern int mnpf_exit(int flag);
//extern int mnpf_timer();
//extern int mnpf_init(int capability, int sysID, u_long local_ip,u_long peer_ip,char *sn);
extern void debug_change_title1();
u32 WXC2_OID_PREFIX[]={1,3,6,1,4,1,1373,2,3,3,99};
static BYTE app_state = 0, sub_state=0;
#define SYS_IT_INTERVAL_SEC 0
#define ES4_IT_INTERVAL_USEC (9*1000)
#define CENTOS_IT_INTERVAL_USEC (10*1000) // actually it's 10 ms interval, but should set timer to 9 ms on ES4
#define APP_CYCLE 10
#define DEFAULT_USERS (100000+1)
#define MAX_APP_NUM 16
#define MAX_LICENSE_TYPE 255
#define WXC2_SHM_KEY 0x90010000
#define WXC2_SHM_PERM 0777
#define MAX_DELAY_TIME 2000
char app_name[MAX_APP_NUM][8]={
"MSC",
"HLR",
"VLR",
"AUC",
"EIR",
"PPS",
"SMSC",
"MNP",
"SMEG"
"OPPS",
"PALIM",
"MC",
"RMC",
"",
"",
"",
};
enum _SYS_LIST{
MSC_,
HLR_,
VLR_,
AUC_,
EIR_,
PPS_,
SMSC_,
MNPF_,
SMEG_,
OPPS_,
PALIM_,
MC_,
RMC_
};
enum _WXC2_STATE{
WXC2_STARTUP,
WXC2_INITRAM,
WXC2_PRIV,
WXC2_NORMAL,
};
enum _WXC2_SYSTTYPE{
WXC2_SYSTYPE_UNIB,
WXC2_SYSTYPE_X40,
WXC2_SYSTYPE_X100,
};
char systemTypeName[3][8]={
"NIB",
"X40",
"X100"};
/* index=MSC,HLR,PPS,AUC,EIR , from 0 */
/* old one
struct _wxc2_param
{
int systemType;
char segmentFaultCommand[128];
int register_flag[MAX_APP_NUM];
int max_users[MAX_APP_NUM];
char serialNumber[16];
unsigned char HDSerialNumber[256];
char license_flag[MAX_APP_NUM];
u_char license_date[3]; // year(0-99),month,day
unsigned char userBcdLicense[MAX_LICENSE_TYPE][8];
unsigned int userIntLicense[MAX_LICENSE_TYPE];
unsigned char HDSerialNumber1[256];
}wxc2_param,tmpParam;
*/
/* new one */
struct _wxc2_param
{
char serialNumber[16];
int systemType;
u_char license_date[3]; /* year(0-99),month,day */
int register_flag[MAX_APP_NUM];
int max_users[MAX_APP_NUM];
unsigned char HDSerialNumber[2][256];
unsigned char userBcdLicense[MAX_LICENSE_TYPE][8];
unsigned int userIntLicense[MAX_LICENSE_TYPE];
}wxc2_param,tmpParam;
static int sys_timer10ms=0;
static int systemID=0,systemInited=0;
static int shutDownCommand = 0,endflag=0;
static int wxc2_main_state = WXC2_STARTUP;
static int wxc2_startup_state = VLR_;
//static int HzFlag=0;
static u_long wxc_localip,wxc_peerip;
static char wxc_localip_str[32],wxc_peerip_str[32];
static int nowModule=MSC_;
static u_char heartbeat_no = 0x09,hb_sub_no=0x00;
static u_short hb_no=0x0901;
static u_short plat_work_port = 4096;
static char wxc2HDInfo[256]; /* array[0] is length */
struct timeval tmstart,tmend;
static char serialNumber[18]="";
//static int updateFromLowVersion=0;
u_char noTimeSyncFlag = 0;
struct timeval main_now;
typedef enum _OS_VERSION
{
OS_ES4,
OS_CENTOS,
}OS_VERSION;
static int Linux_OS_Release=OS_CENTOS; /* 0=ES4, 1=CentOS */
typedef struct segLog{
u_long tmnow;
u_char app_state;
u_char sub_state;
}segLog;
segLog *segmentLog;
/*----------------------------------------------------*/
static void wxc2SetTermSignal(struct termio *ptermio, void (*handler)(int));
static void wxc2Terminate(int sig);
static void moduleProc();
static int GetHDInfo();
static void SaveWxc2SystemConf();
static int CheckHDLicense(unsigned char *HDSerialNumber);
static void CheckLicenseExpire();
static void UpdateWXC2License();
/*----------------------------------------------------*/
extern int iptrMainInit();
extern void iptrans_timer();
extern void debug_init();
extern void debug_rt();
extern void heartbeat_init( unsigned short sysID);
extern void heartbeat_timer();
extern void snmp_init(unsigned short port );
extern void snmp_timer();
extern int smpp_timer();
extern int smpp_init_new(u8 sysid);
extern int smpp_fsm_new();
extern void mtp_shm_init(WORD moduleid_systemid, DWORD local_ip, DWORD peer_ip);
extern void mtp3_proc();
extern void sccp_init(int sysid, u_long localip, u_long peerip);
extern void sccp_timer();
extern int ReadHDInfoList();
extern int CheckIfHDInfoBackup(unsigned char *license_info);
extern int SaveHDInfoList(unsigned char *new_hd_info);
extern void tcap_init(u_short maxPorts,u_long localip,u_long peerip);
extern void tcap_msgprc();
extern void tcap_fsm();
extern void xap_init(u_short maxPorts);
extern void xap_fsm();
extern void scsm_init();
extern void scsm();
extern int pps_init();
extern int pps_proc();
extern int pps_exit();
extern void DesCrypt(
unsigned char *Output /*8 bytes*/,
unsigned char *Input /*8 bytes*/,
unsigned char *DesKey/*default=NULL.While using for user licenses control,can keep the default value*/,
unsigned char DesMode/*encrpt or decrypt,refer to enum _DesMode*/);
extern void ppsRecordLog();
extern void debug_init_wxc2_ver(char *info);
//extern void gx_handle_msg_cb();
extern void m2ua_init(BYTE);
extern void mtp3_init_serial(char *Serial);
extern void sccp_init_serial_number(BYTE *Serial);
extern int cdr_init(char plane_id, char memset_flag);
extern void m2ua_timer(void);
extern void ReadMCMSParam(void);
extern int fd_main(int argc, char * argv[]);
extern int gx_fsm(long sec, int msec);
/*----------------------------------------------------*/
static u8 wxc2_version[4] = {1, 0, 1, 50};
//static char wxc2_mini_version[4]={""};
static int wxc2_update_version(char *state_str)
{
char ver_string[64];
/*if(wxc2_version[3] == 0)
{
sprintf(ver_string, "WXC2 MSS R%d.%d.%d%s - %s", \
wxc2_version[0], wxc2_version[1], wxc2_version[2], wxc2_mini_version,state_str);
}
else*/
{
//sprintf(ver_string, "WXC2 MSS R%d.%d.%d.%03d%s - %s",
sprintf(ver_string, "AGT OCS %d.%d.%d.%03d - %s", \
wxc2_version[0], wxc2_version[1], wxc2_version[2], wxc2_version[3],state_str);
}
debug_init_wxc2_ver(ver_string);
return 1;
}
static int
snmpSetWXC2(u_char oidLen, DWORD *oid,u_char *pdata, u_short dataLen)
{
u_char ocode=0;
DWORD oidtype=0;
// int ssn;
// u_char bufdecrypt[128]="";
// char buf[128];
//16.2.1.1:configuration
if(oidLen<14) return 0;
oidtype = oid[11];
if(oidtype !=2) return 0; //only configuration supported
oidtype = oid[12];
if(oidtype !=1) return 0; //parameter
oidtype = oid[13];
if(oidtype !=1 && oidtype !=2) return 0; //status, license
switch(oidtype)
{
case 1: /* status */
ocode = pdata[0];
switch(ocode)
{
case 1: //init
break;
case 2: //suspend
break;
case 3: //normal
break;
case 4: //shutdown
shutDownCommand = 1;
break;
case 5: //Save subs. data
endflag=1;
return dataLen;
if(wxc2_param.register_flag[PPS_]) pps_exit(1);
endflag =0;
break;
case 6: //backup configuration file, it should work with the script,MSS generates a log file, a script do the acutal backuping...
{
FILE *fpLog;
fpLog = fopen("/usr/local/wxc2/log/mss_backup_conf.txt","w");
fprintf(fpLog,"This is a log file to backup mss conf\n");
fclose(fpLog);
}
//system("tar cf /usr/local/subsManage/conf.bk.tar conf");
//system("chmod 666 /usr/local/subsManage/conf.bk.tar");
break;
case 7:
//system("tar xf /usr/local/subsManage/conf.bk.tar");
wxc2Terminate(128);
break;
default:
return 0;
break;
}
break;
case 2: /* license */
UpdateWXC2License();
break;
break;
}
return dataLen;
}
static int snmpGetWXC2(u_char oidLen, DWORD *oid,u_char *pdata, u_char *vartype)
{
DWORD oidtype=0;
int len=0;
int i;
unsigned int intLicense;
//16.2.1.3: license status
if(oidLen<14) return 0;
oidtype = oid[11];
if(oidtype !=2) return 0; //only configuration supported
oidtype = oid[12];
if(oidtype !=1) return 0; //parameter
oidtype = oid[13];
if (oidtype != 3) return 0; //license status
switch (oidtype)
{
case 3: /* license status */
len = MAX_License_ID * sizeof(int);
for (i = 0; i < MAX_License_ID; i++)
{
intLicense = htonl(wxc2_param.userIntLicense[i]);
memcpy(pdata + i * sizeof(unsigned int), (u_char *) &intLicense, sizeof(unsigned int));
}
break;
default:
break;
}
*vartype = 4;
return len;
}
static
void wxc2SetTermSignal(struct termio *ptermio, void (*handler)(int))
{
ioctl(0,TCGETA, ptermio);
ptermio->c_cc[VINTR] = '\x03';
ioctl(0,TCSETA, ptermio);
signal(SIGINT, handler);
// signal(SIGPIPE,handler);
signal(SIGKILL,handler);
signal(SIGSTOP,handler);
signal(SIGTERM,handler);
}
static
void wxc2Terminate(int sig)
{
char exitlog[128]="../log/wxc2exit.txt";
FILE *fpExit;
struct tm *tp, tb;
long ltime;
//char *argv[2];
int loop=0;
static int wxc2TermFlag=0;
if(wxc2TermFlag) return;
wxc2TermFlag = 1;
endflag=1;
printf("backup file for normal stop...\n");
fpExit=fopen(exitlog,"w");
if(fpExit!=NULL)
{
tp = &tb;
ltime = time((long *)0);
tp = localtime(&ltime);
fprintf(fpExit,"WXC2 procedure exit log\n");
fprintf(fpExit," Time: %s\n",asctime(tp));
fprintf(fpExit,"Now module: %s\n",app_name[nowModule]);
fclose(fpExit);
}else{
printf("fopen file failed\n");
}
if(wxc2_param.register_flag[PPS_]) pps_exit(1);
loop = 0;
while(loop++<MAX_DELAY_TIME)
{
moduleProc(); /* to send pps daily report or other CDR need*/
if(wxc2_param.register_flag[PPS_])
pps_proc();
usleep(10);
loop++;
}
if(sig == 128) //for restore configuration
{
FILE *fpLog;
fpLog = fopen("/usr/local/wxc2/log/mss_restore_conf.txt","w");
fprintf(fpLog,"This is a log file to restore mss conf\n");
fclose(fpLog);
}
exit(sig);
}
static
void sysDaemonInit()
{
int i;
pid_t pid;
if ( (pid = fork()) < 0) /* parent terminates */
printf("%s: %s: fork (%d)",
__FILE__, __FUNCTION__, __LINE__);
else if (pid != 0)
exit(0); /* parent goes bye-bye */
setsid(); // become session leader
for (i = 0; i<3; i++)
close(i);
}
static void
SetFSMTimer()
{
struct itimerval *ptv, tv;
struct utsname u_name;
uname(&u_name);
if(strstr(u_name.release,"2.6.9") == NULL)
Linux_OS_Release = OS_CENTOS;
ptv = (struct itimerval *) &tv;
ptv->it_interval.tv_sec = SYS_IT_INTERVAL_SEC;
ptv->it_value. tv_sec = SYS_IT_INTERVAL_SEC;
if(Linux_OS_Release == OS_ES4)
{
ptv->it_interval.tv_usec = ES4_IT_INTERVAL_USEC;
ptv->it_value.tv_usec = ES4_IT_INTERVAL_USEC;
}
else
{
ptv->it_interval.tv_usec = CENTOS_IT_INTERVAL_USEC;
ptv->it_value.tv_usec = CENTOS_IT_INTERVAL_USEC;
}
setitimer(ITIMER_REAL, ptv, NULL);
}
void wxc2StartLog(int flag)
{
FILE *fpLog=NULL;
char logFile[]="../log/wxc2_startup.log";
time_t *p,tnow;
p=&tnow;
*p = time(NULL);
fpLog = fopen(logFile,"a+");
if(fpLog !=NULL)
{
if(!flag)
fprintf(fpLog,"wxc2main startup --->%s ",ctime(p));
else
fprintf(fpLog,"wxc2main shutdown --->%s ",ctime(p));
fclose(fpLog);
}
}
int wxc2_system(char *command)
{
int pid, status;
char *argv[3];
pid = fork();
if(pid == -1)
return -1;
if(pid == 0)
{
argv[0] = "wxc2d";
argv[1] = "restart";
argv[2] = 0;
execvp("/usr/local/wxc2/bin/wxc2d",argv);
exit(127);
}
do{
if(waitpid(pid,&status,0) == -1){
if(errno != EINTR)
return -1;
}else{
return status;
}
}while(1);
}
#if 0
static void SysGuard(int sig)
{
struct timeval tm;
char fname[64]={"../log/logout.txt"};
FILE *fp;
struct tm *tp, tb;
long ltime;
tp = &tb;
ltime = time((long *)0);
tp = localtime(&ltime);
sprintf(fname,"../log/wxc2_logout.log");
fp = fopen(fname,"w");
if(fp != NULL)
{
gettimeofday(&tm,NULL);
fprintf(fp,"====================================\n");
fprintf(fp,"system restart for segementation fault!\n");
fprintf(fp,"log time : %s\n",ctime(&tm.tv_sec));
fprintf(fp,"Now module: %d\n",segmentLog->sub_state);
fclose(fp);
}
printf("wxc2 exit for SEGMENT FAULT!\n");
pps_exit(0);
ppsRecordLog();
exit(1);
}
#endif
static void sysTimer_IRQ()
{
gettimeofday(&main_now,NULL);
sys_timer10ms = 1;
}
static void
SigactionSystem()
{
struct sigaction action;//,actsegv;
action.sa_handler = sysTimer_IRQ;
sigemptyset(&action.sa_mask);
action.sa_flags = SA_RESTART;
if(sigaction(SIGALRM, &action, NULL)<0)
{
printf("sigactin sigalarm failed\n");
}
/* if(!wxc2_param.segmentFaultAction)
{
actsegv.sa_handler = SysGuard;
sigemptyset(&actsegv.sa_mask);
actsegv.sa_flags = SA_RESTART;
sigaction(SIGSEGV,&actsegv,NULL);
}
*/
}
static void CheckLicenseExpire()
{
struct tm *tp, tb;
long ltime;
int error_flag = 0;
/* max license is 2099-12-31 */
tp = &tb;
ltime = time((long *)0);
tp = localtime(&ltime);
//printf("Check license date..."); may cause system crash
if((tp->tm_year+1900)>wxc2_param.license_date[0]+2000)
{
error_flag = 1;
}
else if((tp->tm_year+1900)==wxc2_param.license_date[0]+2000)
{
if((tp->tm_mon+1)>wxc2_param.license_date[1])
{
error_flag = 1;
}
else if((tp->tm_mon+1)==wxc2_param.license_date[1])
{
if(tp->tm_mday>wxc2_param.license_date[2])
{
error_flag = 1;
}
}
}
if(error_flag)
{
printf("Failed!\n");
/*printf("License is expired (20%02d-%02d-%02d),today:(%04d-%02d-%02d)\n",
wxc2_param.license_date[0],
wxc2_param.license_date[1],
wxc2_param.license_date[2],
tp->tm_year+1900,
tp->tm_mon+1,
tp->tm_mday);*/
exit(4);
}
//printf("pass!\n"); may cause system crash
}
static int CheckHDLicense(unsigned char *HDSerailNumber)
{
#if 0// old CheckHDLicense
int length;
length = wxc2HDInfo[0];
printf("Check HD License...\n");
if (memcmp(&wxc2HDInfo[1],HDSerailNumber,length) !=0)
{
char ascii_buf[256];
BcdToAscii(ascii_buf,&wxc2HDInfo[1],length*2);
printf("Check HD license...FAILED!\n");
//printf("Activation request code: %s\n", ascii_buf);
printf("Please send ./log/Activation_request_code.txt to get the license\n");
return 0;
}
printf("Check HD License...PASS!\n");
return 1;
#endif
int length;
length = wxc2HDInfo[0];
printf("Check HD License...\n");
ReadHDInfoList();
if (memcmp(&wxc2HDInfo[1],HDSerailNumber,length) !=0)
{
if(CheckIfHDInfoBackup(HDSerailNumber) == 0)
{
char ascii_buf[256];
BcdToAscii(ascii_buf, (BYTE *)&wxc2HDInfo[1],length*2);
printf("Check HD license...FAILED!\n");
//printf("Activation request code: %s\n", ascii_buf);
printf("Please send ../log/Activation_request_code.txt to get the license\n");
return 0;
}
}
SaveHDInfoList((unsigned char *)wxc2HDInfo);
printf("Check HD License...PASS!\n");
return 1;
}
static int GetHDInfo()
{
FILE *fpConf=NULL;
int i,j=0,k;
char ethmac[64]="",meminfo[64]="",cpuinfo[64]="",hwinfo[128]="",*offset,*offset_0, buf[8192];
char ascii_buf[128] = {0};
unsigned char TmpStr[64] = {0}, act_req_code[128] = {0}, act_req_code_des[128] = {0};
int lic_mem_cpu = 0;// 0, new lic; 1, old lic;
//struct stat fileinfo;
// Ethernet Hardware Address
printf("Get HD info ...\n\n");
memset(ethmac, 0, 64);
sprintf(buf,"ip a >../log/ethlog.txt");
system(buf);
fpConf = fopen("../log/ethlog.txt","r");
if(fpConf != NULL)
{
fread(buf,2048,1,fpConf);
offset = strstr(buf,"ether ");
if (offset == NULL)
{
offset = strstr(buf,"HWaddr ");
if (offset != NULL)
{
offset += 7;
}
} else {
offset += 6;
}
if (offset != NULL)
{
//offset += 7;
for(i=0,j=0;i<64;i++)
{
if ((*(offset+i)=='\n') ||
(*(offset+i)==' '))
{
ethmac[j] = 0;
break;
}
else if (*(offset+i)==':')
continue;
else
{
ethmac[j] = *(offset+i);
//printf("ethmac[%d] = %c\n", j, ethmac[j]);
j++;
}
}
ethmac[j] = 0;
}
fclose(fpConf);
remove("../log/ethlog.txt");
}
else
{
printf("Log directory may be missing!\n");
return 0;
}
if(lic_mem_cpu)
{
// Memory
memset(meminfo, 0, 64);
sprintf(buf,"cat /proc/meminfo >../log/memlog.txt");
system(buf);
fpConf = fopen("../log/memlog.txt","r");
if(fpConf != NULL)
{
fread(buf,2048,1,fpConf);
offset = strstr(buf,"MemTotal:");
if (offset != NULL)
{
for(i=0,j=0;i<64;i++)
{
if ((*(offset+i)=='\n') ||(*(offset+i)=='k'))
{
meminfo[j] = 0;
break;
}
else if (isdigit(*(offset+i)))
{
meminfo[j] = *(offset+i);
//printf("meminfo[%d] = %c\n", j, meminfo[j]);
j++;
}
}
meminfo[j] = 0;
}
fclose(fpConf);
remove("../log/memlog.txt");
}
else
{
printf("Log directory may be missing!\n");
return 0;
}
}
else
{
int uuid_or_cpuid=0; //0=CPUID, 1=UUID
memset(meminfo, 0, 64);
sprintf(buf,"sudo dmidecode | grep UUID >../log/cpuIDlog.txt");
system(buf);
fpConf = fopen("../log/cpuIDlog.txt","r");
if(fpConf != NULL)
{
fread(buf,2048,1,fpConf);
offset_0=offset = strstr(buf,"UUID: ");
if (offset != NULL)
{
uuid_or_cpuid = 1;
for(i=6,j=0;i<64;i++)
{
if (*(offset+i)=='\n')
{
meminfo[j] = 0;
break;
}
else if (isdigit(*(offset+i)))
{
meminfo[j] = *(offset+i);
printf("cpuinfo[%d] = %c\n", j, meminfo[j]);
j++;
}
}
}
fclose(fpConf);
remove("../log/cpuIDlog.txt");
}
if(uuid_or_cpuid == 0)//UUID not found
{
sprintf(buf,"sudo dmidecode -t 4 | grep ID >../log/cpuIDlog.txt");
system(buf);
fpConf = fopen("../log/cpuIDlog.txt","r");
if(fpConf != NULL)
{
fread(buf,2048,1,fpConf);
offset_0=offset = strstr(buf,"ID: ");
if (offset != NULL)
{
for(i=4,j=0;i<64;i++)
{
if (*(offset+i)=='\n')
{
meminfo[j] = 0;
break;
}
else if (isdigit(*(offset+i)))
{
meminfo[j] = *(offset+i);
printf("cpuinfo[%d] = %c\n", j, meminfo[j]);
j++;
}
}
}
offset = strstr(offset_0+4,"ID: ");
if (offset != NULL)
{
for(i=4;i<64;i++)
{
if (*(offset+i)=='\n')
{
meminfo[j] = 0;
break;
}
else if (isdigit(*(offset+i)))
{
meminfo[j] = *(offset+i);
printf("cpuinfo[%d] = %c\n", j, meminfo[j]);
j++;
}
}
}
fclose(fpConf);
remove("../log/cpuIDlog.txt");
}
}
}
if(lic_mem_cpu)
{
// CPUInfo
memset(cpuinfo, 0, 64);
sprintf(buf,"cat /proc/cpuinfo >../log/cpuModlog.txt");
system(buf);
fpConf = fopen("../log/cpuModlog.txt","r");
if(fpConf != NULL)
{
fread(buf,2048,1,fpConf);
offset = strstr(buf,"cpu family");
if (offset != NULL)
{
for(i=0,j=0;i<64;i++)
{
if (*(offset+i)=='\n')
{
cpuinfo[j] = 0;
break;
}
else if (isdigit(*(offset+i)))
{
cpuinfo[j] = *(offset+i);
//printf("cpuinfo[%d] = %c\n", j, cpuinfo[j]);
j++;
}
}
}
offset = strstr(buf,"model");
if (offset != NULL)
{
for(i=0;i<64;i++)
{
if (*(offset+i)=='\n')
{
cpuinfo[j] = 0;
break;
}
else if (isdigit(*(offset+i)))
{
cpuinfo[j] = *(offset+i);
//printf("cpuinfo[%d] = %c\n", j, cpuinfo[j]);
j++;
}
}
}
offset = strstr(buf,"cache size");
//offset = strstr(buf,"cpu MHz");
//offset = strstr(buf,"bogomips");
if (offset != NULL)
{
for(i=0;i<64;i++)
{
if (*(offset+i)=='\n')
{
cpuinfo[j] = 0;
break;
}
else if (*(offset+i) == 'K')
{
//continue;
break;
}
else if (isdigit(*(offset+i)))
{
cpuinfo[j] = *(offset+i);
//printf("cpuinfo[%d] = %c\n", j, cpuinfo[j]);
j++;
}
}
cpuinfo[j] = 0;
}
fclose(fpConf);
remove("../log/cpuModlog.txt");
}
else
{
printf("Log directory may be missing!\n");
return 0;
}
}
strcpy(hwinfo, "");
strcat(hwinfo, ethmac);
i = j = strlen(ethmac);
hwinfo[i++] = ethmac[0];
hwinfo[i++] = ethmac[1];
hwinfo[i++] = ethmac[2];
hwinfo[i++] = ethmac[3];
hwinfo[i] = 0;
strcat(hwinfo, meminfo);
j = strlen(meminfo);
i += j;
hwinfo[i++] = ethmac[4];
hwinfo[i++] = ethmac[5];
hwinfo[i++] = ethmac[6];
hwinfo[i++] = ethmac[7];
hwinfo[i] = 0;
if (lic_mem_cpu)
{
strcat(hwinfo, cpuinfo);
j = strlen(cpuinfo);
i += j;
}
hwinfo[i++] = ethmac[8];
hwinfo[i++] = ethmac[9];
hwinfo[i++] = ethmac[10];
hwinfo[i++] = ethmac[11];
hwinfo[i] = 0;
j = strlen(hwinfo);
if (j == 0)
{
printf("Missing Activation Request Info!\n");
return 0;
}
k = (j + 7) / 8;
//printf("hwinfo: %s, len: %d, segment: %d\n", hwinfo, j, k);
memset(hwinfo + j, '0', 128 - j);
memset(act_req_code, 0, 128);
for (i = 0; i < k; i++)
{
memset(TmpStr, 0, 64);
DesCrypt(TmpStr, (unsigned char *)hwinfo + 8 * i, NULL, 0);
memcpy(act_req_code + 8 * i, TmpStr, 8);
}
memset(ascii_buf, 0, 128);
BcdToAscii(ascii_buf, act_req_code, k * 16);
fpConf = fopen("../log/Activation_request_code.txt","w");
if (fpConf != NULL)
{
fprintf(fpConf, "%s\n", ascii_buf);
fclose(fpConf);
}
else
{
printf("Missing Activation_request_code file!\n");
return 0;
}
memset(act_req_code_des, 0, 128);
for (i = 0; i < k; i++)
{
memset(TmpStr, 0, 64);
DesCrypt(TmpStr, act_req_code + 8 * i, NULL, 0);
memcpy(act_req_code_des + 8 * i, TmpStr, 8);
}
//memset(ascii_buf, 0, 128);
//BcdToAscii(ascii_buf, act_req_code_des, k * 16);
//printf("Activation request code DES: %s\n", ascii_buf);
wxc2HDInfo[0] = k*8;
memcpy(&wxc2HDInfo[1],act_req_code_des,k*8);
printf("Get HD info... OK!\n");
return 1;
}
static void SaveWxc2SystemConf()
{
FILE *fpConf=NULL;
char filename[]="./conf/system.ini";
fpConf = fopen(filename,"w");
if(fpConf==NULL){
return;
}
fwrite(&wxc2_param,sizeof(wxc2_param),1,fpConf);
fclose(fpConf);
}
static void UpdateWXC2License()
{
FILE *fpConf=NULL;
FILE *fpFIB=NULL;
char buf[512],output[256];
u_char data[8];
int i,len,newLicense,dif;
char filename[]="/usr/local/subsManage/system.ini";
struct stat fileinfo;
memset(&tmpParam,0,sizeof(tmpParam));
fpFIB = fopen("/usr/local/subsManage/fib.txt","w");
fpConf = fopen(filename,"r");
if(fpConf==NULL){
fprintf(fpFIB,"Cann't open config file:system.ini\n");
fclose(fpFIB);
return;
}
stat(filename,&fileinfo);
if(fileinfo.st_size < sizeof(wxc2_param))
{
fprintf(fpFIB,"Error file length: %d, should be: %lu\n",
(int)fileinfo.st_size, sizeof(wxc2_param));
fclose(fpFIB);
fclose(fpConf);
remove(filename);
return;
}
fread(&tmpParam,sizeof(wxc2_param),1,fpConf);
fclose(fpConf);
rename(filename,"/usr/local/subsManage/system.ini.OLD");
if(tmpParam.systemType != wxc2_param.systemType)
{
fprintf(fpFIB,"Wrong FIB file: system type (%s) is not the same as the current one (%s)\n",
systemTypeName[tmpParam.systemType],
systemTypeName[wxc2_param.systemType]);
fclose(fpFIB);
return;
}
if(memcmp(tmpParam.serialNumber,wxc2_param.serialNumber,8))
{
fprintf(fpFIB,"Wrong FIB file: serial number is not correct.\n");
fclose(fpFIB);
return;
}
/*
if(!systemID)
{
if(!CheckHDLicense(tmpParam.HDSerialNumber[0]))
{
fprintf(fpFIB,"Wrong FIB file: Hardware codeis not correct.\n");
fclose(fpFIB);
return;
}
}
else
{
if(!CheckHDLicense(tmpParam.HDSerialNumber[1]))
{
fprintf(fpFIB,"Wrong FIB file: Hardware codeis not correct.\n");
fclose(fpFIB);
return;
}
}
*/
for(i=0;i<MAX_APP_NUM;i++)
{
if(tmpParam.register_flag[i] && (!wxc2_param.register_flag[i]))
{
fprintf(fpFIB,"Wrong FIB file: system %s can't be opened when update license\n",
app_name[i]);
fclose(fpFIB);
return;
}
}
for (i = 0; i < LIC_MAX_ID; i++)
{
if ((i < MAX_APP_FUNC_ID) && (wxc2_param.register_flag[i] == 0))
{ // application, not registered
tmpParam.userIntLicense[i] = 0;
//printf("tmp LICENSE[%d]:%d\n",i, tmpParam.userIntLicense[i]);
continue;
}
DesCrypt(data,tmpParam.userBcdLicense[i],NULL,1);
tmpParam.userIntLicense[i] = (data[6] * 256 + data[7]) * wxc2_license_rule[i].step;
if (tmpParam.userIntLicense[i] < 0)
{
fprintf(fpFIB,"Wrong license value: %s license should be greater than 0\n",
wxc2_license_rule[i].name);
fclose(fpFIB);
return;
}
//printf("tmp LICENSE[%d]:%d\n",i, tmpParam.userIntLicense[i]);
}
for(i=0;i<MAX_License_ID;i++)
{
newLicense = tmpParam.userIntLicense[i];
if (newLicense > wxc2_license_rule[i].maxValue)
{
fprintf(fpFIB,"Wrong license value: %s license can't be greater than maxValue %d\n",
wxc2_license_rule[i].name, wxc2_license_rule[i].maxValue);
fclose(fpFIB);
return;
}
if (wxc2_license_rule[i].dir == ONLY_INCREASABLE)
{
if (newLicense < wxc2_param.userIntLicense[i])
{
fprintf(fpFIB,"Wrong license value: %s license can't be less than before,old=%d,now=%d\n",
wxc2_license_rule[i].name,wxc2_param.userIntLicense[i],newLicense);
fclose(fpFIB);
return;
}
}
else if (wxc2_license_rule[i].dir == ONLY_DECREASABLE)
{
if (newLicense > wxc2_param.userIntLicense[i])
{
fprintf(fpFIB,"Wrong license value: %s license can't be greater than before\n",
wxc2_license_rule[i].name);
fclose(fpFIB);
return;
}
}
if (newLicense >= wxc2_param.userIntLicense[i])
dif = newLicense - wxc2_param.userIntLicense[i];
else
dif = wxc2_param.userIntLicense[i] - newLicense;
if (dif > 0)
{ // if dif equals 0, means no change at all
if (dif % wxc2_license_rule[i].step)
{
fprintf(fpFIB,"Wrong license value: %s license should change by step %d\n",
wxc2_license_rule[i].name, wxc2_license_rule[i].step);
fclose(fpFIB);
return;
}
}
}
if(tmpParam.license_date[0] == 0 &&
tmpParam.license_date[1] == 0 &&
tmpParam.license_date[2] == 0)
{
tmpParam.license_date[0] = 99;
tmpParam.license_date[1] = 12;
tmpParam.license_date[2] = 31;
}
memcpy(&wxc2_param,&tmpParam,sizeof(wxc2_param));
rename("./conf/system.ini","./conf/system.ini.OLD");
SaveWxc2SystemConf();
/* set FIB file */
fprintf(fpFIB,"[ system info ]\n");
fprintf(fpFIB,"software version=R9.0\n");
switch(wxc2_param.systemType)
{
case 0:
fprintf(fpFIB,"system type=NIB\n");
break;
case 1:
fprintf(fpFIB,"system type=X40\n");
break;
case 2:
fprintf(fpFIB,"system type=X100\n");
break;
}
fprintf(fpFIB,"\n");
fprintf(fpFIB,"[ deployment info ]\n");
fprintf(fpFIB,"serial number=%s\n",serialNumber);
len = wxc2_param.HDSerialNumber[0][255];
for(i=0;i<len/16;i++)
{
DesCrypt((unsigned char *)&output[i*8],
(unsigned char *)&wxc2_param.HDSerialNumber[0][i*8],
NULL,1);
}
output[len] = 0;
BcdToAscii(buf, (BYTE *)output,len);
buf[len] = 0;
fprintf(fpFIB,"HDID0=%s\n",buf);
if(wxc2_param.systemType==WXC2_SYSTYPE_UNIB)
{
fprintf(fpFIB,"HDID1=NULL\n");
}
else
{
len = wxc2_param.HDSerialNumber[1][255];
for(i=0;i<len/16;i++)
{
DesCrypt((unsigned char *)&output[i*8],
(unsigned char *)&wxc2_param.HDSerialNumber[1][i*8],
NULL,1);
}
output[len] = 0;
BcdToAscii(buf, (BYTE *)output,len);
buf[len] = 0;
fprintf(fpFIB,"HDID1=%s\n",buf);
}
if(wxc2_param.license_date[0] == 99)
{
fprintf(fpFIB,"expire on=000000\n");
}
else
{
fprintf(fpFIB,"expire on=%02d%02d%02d\n",
wxc2_param.license_date[0],
wxc2_param.license_date[1],
wxc2_param.license_date[2]);
}
fprintf(fpFIB,"\n");
fprintf(fpFIB,"[ application flag ]\n");
for(i=0;i<8;i++)
{
if(wxc2_param.register_flag[i])
fprintf(fpFIB,"%s=ON\n",app_name[i]);
else
fprintf(fpFIB,"%s=OFF\n",app_name[i]);
}
fprintf(fpFIB,"\n");
fprintf(fpFIB,"[ license ]\n");
for(i=0;i<MAX_License_ID;i++)
{
fprintf(fpFIB,"%s=%d\n",wxc2_license_rule[i].name,wxc2_param.userIntLicense[i]);
}
fprintf(fpFIB,"\n");
fprintf(fpFIB,"\n");
fclose(fpFIB);
}
unsigned int crc32(unsigned char *data, int length)
{
unsigned char i;
unsigned int crc = 0xffffffff; // Initial value
while(length--)
{
crc ^= *data++; // crc ^= *data; data++;
for (i = 0; i < 8; ++i)
{
if (crc & 1)
crc = (crc >> 1) ^ 0xEDB88320;// 0xEDB88320= reverse 0x04C11DB7
else
crc = (crc >> 1);
}
}
return ~crc;
}
static int check_license_file_validity(struct _wxc2_param *param_ptr)
{
unsigned int check_sum = 0;
unsigned int licensed_check_sum = 0;
char license_date[128], e_license_date[128];
if(param_ptr == NULL)
{
goto invalid_license;
}
check_sum = crc32((unsigned char *)param_ptr, sizeof(struct _wxc2_param)-4);
memcpy(&licensed_check_sum, &param_ptr->userIntLicense[MAX_LICENSE_TYPE-1], 4);
if(check_sum != licensed_check_sum)
goto invalid_license;
if(1)
{
char year[5], month[3], day[3];
memcpy(e_license_date, &param_ptr->userIntLicense[250], 8);
DesCrypt(license_date,e_license_date, NULL,1);
memcpy(year, license_date, 4);
year[4] = 0;
memcpy(month, &license_date[4], 2);
month[2] = 0;
memcpy(day, &license_date[6], 2);
day[2] = 0;
param_ptr->license_date[0] = atoi(year) - 2000;
param_ptr->license_date[1] = atoi(month);
param_ptr->license_date[2] = atoi(day);
}
return 1;
invalid_license:
printf("invalid license\r\n");
exit(110);
return 0;
}
static
void ReadSystemConf()
{
FILE *fpConf=NULL;
int i,flag=0;
// char hostname[128];
char filename[]="./conf/system.ini";
struct stat fileinfo;
u_char data[8];
fpConf = fopen(filename,"r");
if(fpConf==NULL){
printf("Cann't open config file\n");
printf("Please check directory and conf file\n");
printf("Failed to continue!\n");
exit(1);
}
stat(filename,&fileinfo);
/*
if(fileinfo.st_size != sizeof(wxc2_param))
{
// don't set license when initialized
//updateFromLowVersion = 1;
}
*/
fread(&wxc2_param,sizeof(wxc2_param),1,fpConf);
fclose(fpConf);
// add descrypt and crc check=========================
char buf[128];
AsciiToBcd(buf,wxc2_param.serialNumber,16);
DesCrypt((unsigned char *)serialNumber,buf,NULL,1);
check_license_file_validity(&wxc2_param);
// ===================================================
/*
if(updateFromLowVersion)
{
memcpy(wxc2_param.HDSerialNumber[1],wxc2_param.HDSerialNumber,256);
}
*/
for(i=0;i<MAX_APP_NUM;i++){
if(wxc2_param.register_flag[i])
flag = 1;
}
if(flag==0)
{
printf("Error config file for no application enabled!\n");
exit(1);
}
if(wxc2_param.systemType == WXC2_SYSTYPE_UNIB)
{
plat_work_port = (MAX_DIALOGUEID/4);
printf("system info: UNIB\n");
}
else if(wxc2_param.systemType == WXC2_SYSTYPE_X40)
{
plat_work_port = (MAX_DIALOGUEID/2);
printf("system info: X40\n");
}
else
{
plat_work_port = MAX_DIALOGUEID;
printf("system info: X100\n");
}
/*
if(!gethostname(hostname,128)){
if(strstr(hostname,"-0")!=NULL){
systemID = 0;
}else if(strstr(hostname,"-1")!=NULL){
systemID = 1;
}
}
*/
/*
for(i=0;i<MAX_APP_NUM;i++){
printf("APP[%d]:\n",i);
printf(" register: %d\n",wxc2_param.register_flag[i]);
printf(" max user: %d\n",wxc2_param.max_users[i]);
}
*/
for (i = 0; i < MAX_License_ID; i++)
{
if ((i < MAX_APP_FUNC_ID) && (wxc2_param.register_flag[i] == 0))
{ // application, not registered
wxc2_param.userIntLicense[i] = 0;
// printf("LICENSE[%d]:%d\n",i, wxc2_param.userIntLicense[i]);
continue;
}
DesCrypt(data,wxc2_param.userBcdLicense[i],NULL,1);
wxc2_param.userIntLicense[i] = (data[6] * 256 + data[7]) * wxc2_license_rule[i].step;
//printf("LICENSE[%d]:%d\n",i, wxc2_param.userIntLicense[i]);
}
wxc2_param.register_flag[PPS_] = 1;
}
int wxc2_read_sysparam(void)
{
FILE *fp;
int ii;
char *ch_ptr,*buf_ptr;
char *temp_ptr;
char hostname[64];
char temp_info[64],info_str[1024];
struct hostent *pcn;
struct in_addr temp_addr;
char sysconf[]="./conf/wxc2_sys.conf";
if ((gethostname(hostname,63)) == -1)
{
printf("Can not get hostname\n");
return 0;
}
pcn = gethostbyname(hostname);
if (pcn == NULL)
{
printf("Get host ip address fail. Please check your ethernet configure\n");
return 0;
}
fp = fopen(sysconf,"r"); // read system configure
if (fp == NULL)
{
printf("can not open file %s!!\n",sysconf);
return 0;
}
ch_ptr = strchr(hostname,'.');
if (ch_ptr != NULL)
ch_ptr[0] = '\0'; // delete the suffix of host name
while (!feof(fp))
{
info_str[0] = '\n';
fgets(info_str,250,fp);
if (info_str[0] == '#' || info_str[0] == '\n')
continue;
buf_ptr = info_str;
if(!strncasecmp(info_str,"heartbeat no=",13))
{
heartbeat_no = atoi(&info_str[13]);
continue;
}
if(!strncasecmp(info_str,"heartbeat sub no=",17))
{
hb_sub_no = atoi(&info_str[17]);
continue;
}
if(!strncasecmp(info_str,"noTimeSync=",11))
{
noTimeSyncFlag = atoi(&info_str[11]);
continue;
}
if(!strncasecmp(info_str,"mca enable",10))
{
wxc2_param.register_flag[RMC_] = 1;
continue;
}
/*
if(!strncasecmp(info_str,"local ip=",9))
{
wxc_localip = inet_addr(&info_str[9]);
continue;
}
if(!strncasecmp(info_str,"peer ip=",8))
{
wxc_peerip = inet_addr(&info_str[8]);
continue;
}
if(!strncasecmp(info_str,"system id=",10))
{
systemID = atoi(&info_str[10]);
continue;
}
*/
for (ii = 0;ii < 2;ii ++)
{
ch_ptr = strsep(&(buf_ptr),"=;");
if (ch_ptr == NULL)
{
printf("This field lacks infomation:%s\n",buf_ptr);
return 0;
}
if (ii == 0)
{
if (strlen(ch_ptr) != strlen(hostname))
{
printf("Please check host name in file:%s\t%s\n",ch_ptr,hostname);
return 0;
}
temp_ptr = strchr(hostname,'-');
if (temp_ptr != NULL) {
if (strncmp(ch_ptr, hostname, strlen(hostname) - strlen(temp_ptr)) != 0) {
printf("The host name is unexpected!\n");
return 0;
}
} else {
if (strncmp(ch_ptr, hostname, strlen(hostname)) != 0) {
printf("The host name is unexpected!\n");
return 0;
}
}
strcpy(temp_info,ch_ptr);
}
else
{
if (memcmp(hostname,temp_info,strlen(temp_info)) == 0) // owner ip address
{
//if (strcmp(inet_ntoa(*(struct in_addr *)(*pcn->h_addr_list)),ch_ptr) != 0)
//{
// printf("Error ip address\n");
// return 0;
//}
systemID = temp_info[strlen(temp_info)-1] - '0';
if (systemID > 5)
{
printf("Error system id\n");
return 0;
}
wxc_localip = inet_addr(ch_ptr); //((struct in_addr *)(*pcn->h_addr_list))->s_addr;
strcpy(wxc_localip_str, ch_ptr);
}
else
{
if (!inet_aton(ch_ptr,&temp_addr))
{
printf("Can not get peer ip address\n");
return 0;
}
wxc_peerip = temp_addr.s_addr;
strcpy(wxc_peerip_str, ch_ptr);
}
} //for
}//while
}
hb_no = heartbeat_no;
hb_no <<=8;
if(hb_sub_no)
hb_no |= hb_sub_no;
else
hb_no |= systemID;
fclose(fp);
return 1;
}
static void
wxc2HBinit()
{
// hb_no = heartbeat_no;
// hb_no <<=8;
// hb_no |= systemID;
heartbeat_init(hb_no);
}
void LogModuleStartState( int nType , char *Module , int nResult )
{
char sType[32];
char sResult[32];
char sModule[32];
if( strlen(Module) > 10 )
{
printf("LogModuleStartState:too long module name!\n");
return;
}
strcpy(sModule, Module );
TxtColor(BRIGHT,WHITE,BLACK,sModule);
if( nType )
{
strcpy(sType , "Application");
}
else
{
strcpy(sType , "Platform");
}
if( nResult )
{
strcpy(sResult , " OK ");
TxtColor(BRIGHT,GREEN,BLACK,sResult);
}
else
{
strcpy(sResult , "Fail");
TxtColor(BRIGHT,RED,BLACK,sResult);
}
printf("Initialing %s %s Module: \t\t\t\t[ %s ]\n",sType,sModule,sResult);
}
static
void moduleInit()
{
int ret = 0;
printf("\n\n[R9 Platform Init]\n\n");
debug_init();
LogModuleStartState( 0, "DEBUG" , 1);
ret = iptrMainInit();
LogModuleStartState( 0, "IPTR" , ret);
snmp_init(4957);
LogModuleStartState( 0, "SNMP" , ret);
snmp_init_serial_number(serialNumber);
if(noTimeSyncFlag == 1)
snmp_set_timenosync();
if( !wxc2_param.register_flag[RMC_])
{
m2ua_init(systemID);
LogModuleStartState( 0, "M2UA" , ret);
// mtp_shm_init(0x900|systemID);
mtp_shm_init(hb_no, wxc_localip, wxc_peerip);
LogModuleStartState( 0, "MTP3" , 1);
mtp3_init_serial(serialNumber);
sccp_init(systemID, wxc_localip, wxc_peerip);
LogModuleStartState( 0, "SCCP" , 1);
sccp_init_serial_number((BYTE *)serialNumber);
ret = smpp_init_new(systemID);
LogModuleStartState( 0, "SMPP" , ret);
tcap_init(plat_work_port,wxc_localip,wxc_peerip);
LogModuleStartState( 0, "TCAP" , 1);
xap_init(plat_work_port);
LogModuleStartState( 0, "XAPP" , 1);
radius_init();
LogModuleStartState( 0, "RADIUS" , 1);
tcp_init();
LogModuleStartState( 0, "TCP" , 1);
}
if (wxc2_param.register_flag[PPS_])
{
scsm_init();
LogModuleStartState( 0, "SCF" , 1);
}
wxc2HBinit();
LogModuleStartState( 0, "HB" , 1);
cdr_init(systemID, 0);
printf("\n\n[R9 Platform Init completed]\n\n");
inquire_setmsg(11,WXC2_OID_PREFIX, (setcall)snmpSetWXC2);
inquire_getmsg(11,WXC2_OID_PREFIX, (getcall)snmpGetWXC2);
}
static void moduleProc()
{
//static int wait_sccp_normal_count = 0;
//static BYTE t20ms = 0;
segmentLog->tmnow = time(NULL);
segmentLog->sub_state = 0;
sub_state = 0;
iptrans_timer();
segmentLog->sub_state ++;
sub_state ++;
snmp_timer();
segmentLog->sub_state ++;
sub_state ++;
heartbeat_timer();
segmentLog->sub_state ++;
sub_state ++;
debug_rt();
if (wxc2_main_state == WXC2_NORMAL)
//if(wait_sccp_normal_count++>30)/*wait for 30secs */
{
//wait_sccp_normal_count=6001;
segmentLog->sub_state ++;
sub_state ++;
m2ua_timer();
segmentLog->sub_state ++;
sub_state ++;
mtp3_proc();
segmentLog->sub_state ++;
sub_state ++;
sccp_timer();
segmentLog->sub_state ++;
sub_state ++;
tcap_fsm();
segmentLog->sub_state ++;
sub_state ++;
smpp_fsm_new();
segmentLog->sub_state ++;
sub_state ++;
xap_fsm();
segmentLog->sub_state ++;
sub_state ++;
radius_timer();
segmentLog->sub_state ++;
sub_state ++;
tcp_timer();
}
if (wxc2_param.register_flag[PPS_])
{
segmentLog->sub_state ++;
sub_state ++;
scsm();
}
}
void RecordLogInfo()
{
int shm_id;
FILE *fpTmp=NULL;
shm_id = shmget(WXC2_SHM_KEY+wxc2_get_shm_offset(),1024,WXC2_SHM_PERM | IPC_CREAT);
if(shm_id == -1)
return;
segmentLog = (segLog *)shmat(shm_id,(char *)0,0);
if(segmentLog == (void *) -1)
{
printf("get shm failed\n");
exit(127);
}
fpTmp = fopen("../log/wxc2_log.txt","w");
if(fpTmp == NULL) return ;
fprintf(fpTmp,"time: %ld\n",segmentLog->tmnow);
fprintf(fpTmp,"app_state: %d\n",segmentLog->app_state);
fprintf(fpTmp,"sub_state: %d\n",segmentLog->sub_state);
fclose(fpTmp);
}
int wxc2_get_license(int functionID)
{
if (functionID >= MAX_License_ID)
return -1;
return wxc2_param.userIntLicense[functionID];
}
u_long wxc2_get_localip(char *ip_str)
{
if(ip_str != NULL)
strcpy(ip_str,wxc_localip_str);
return wxc_localip;
}
u_long wxc2_get_peerip(char *ip_str)
{
if(ip_str != NULL)
strcpy(ip_str,wxc_peerip_str);
return wxc_peerip;
}
#define WXC2_STARTUP_COMPLETED 1
int wxc2_startup(u8 no_sync)
{
struct termio prev_termio;
switch(wxc2_startup_state)
{
case 0:
if(wxc2_param.register_flag[PPS_])
{
if(pps_init((wxc2_param.max_users[PPS_])%DEFAULT_USERS,
systemID,wxc_localip,wxc_peerip,serialNumber,no_sync))
{
LogModuleStartState( 1 , "PPS" , 1);
wxc2SetTermSignal(&prev_termio,wxc2Terminate);
printf("wxc2 initram ...\n");
systemInited = 1;
wxc2HBinit();
wxc2_update_version("Normal");
debug_change_title1();
return WXC2_STARTUP_COMPLETED;
}
}
else
{
wxc2_startup_state = 0;
wxc2SetTermSignal(&prev_termio,wxc2Terminate);
systemInited = 1;
outb(0x05,0x37a);
wxc2HBinit();
wxc2_update_version("Normal");
debug_change_title1();
return WXC2_STARTUP_COMPLETED;
}
break;
default:
wxc2_startup_state = 0;
break;
}
return 0;
}
void wxc2_normal_running()
{
static int license_check_timer=0;
if(license_check_timer++ == 360000) /* every hour */
{
license_check_timer = 0;
//CheckLicenseExpire();
}
switch (app_state)
{
case 0:
app_state = 0;
segmentLog->app_state = app_state;
segmentLog->sub_state =50;
sub_state =50;
if (wxc2_param.register_flag[PPS_])
{
pps_proc();
}
break;
default:
app_state = 0;
break;
}
}
int isWxc2mainNormal()
{
if(wxc2_main_state == WXC2_NORMAL)
return TRUE;
return FALSE;
}
int main(int argc, char **argv)
{
int retval, err_flag=0, daemon_flag=0, no_sync=0;
char buf[32]="";
struct itimerval tv;
char checkPidFile[32]="./pidofwxc2.txt";
char checkPidCommand[128]="pidof agtocs 2>./pidofwxc2.txt 1>&2";
FILE *fpPid=NULL;
//BYTE in;
system(checkPidCommand);
fpPid = fopen(checkPidFile,"r");
if(fpPid !=NULL)
{
int len,i;
char record[32];
memset(record,0,32);
fread(record,32,1,fpPid);
len = strlen(record);
if(len>2)
for(i=0;i<len;i++)
{
if(record[i] == ' ' && i!=len-1)
{
printf("agtocs (pid=%s) is running, stop it first!\n",record);
fclose(fpPid);
//remove(checkPidFile);
exit(0);
}
}
fclose(fpPid);
}
remove(checkPidFile);
/* Find out what is the system clock granularity. */
tv.it_interval.tv_sec = 0;
tv.it_interval.tv_usec = 1;
tv.it_value.tv_sec = 0;
tv.it_value.tv_usec = 0;
setitimer (ITIMER_REAL, &tv, 0);
setitimer (ITIMER_REAL, 0, &tv);
printf ("System clock granularity: %ld microseconds.\n", tv.it_interval.tv_usec);
wxc2StartLog(0);
while ((retval = getopt(argc, argv, "dtc")) != -1)
{
switch (retval) {
case 'd':
daemon_flag = 1;
break;
case 't':
no_sync = 1;
break;
case 'c':
no_sync = 1;
break;
case '?':
err_flag = 1;
break;
}
}
if (err_flag) {
printf("Usage: %s [-d] \n", argv[0]);
printf(" -d with daemon mode\n");
exit(1);
}
if(!wxc2_read_sysparam()){
printf("Error config file ./conf/wxc2_sys.conf!\n");
exit(1);
}
if(!GetHDInfo())
{
printf("Get HD Info...FAILED!\n");
exit(1);
}
ReadSystemConf();
ReadMCMSParam(); /* MCMS parameters, bind ip, shm key shift */
RecordLogInfo();
if(!systemID)
{
if(!CheckHDLicense(wxc2_param.HDSerialNumber[0]))
exit(1);
}
else
{
if(!CheckHDLicense(wxc2_param.HDSerialNumber[1]))
exit(1);
}
CheckLicenseExpire();
AsciiToBcd((BYTE *)buf,wxc2_param.serialNumber,16);
DesCrypt((unsigned char *)serialNumber, (unsigned char *)buf,NULL,1);
if(daemon_flag)
sysDaemonInit();
moduleInit();
wxc2_update_version("Init...");
SigactionSystem();
SetFSMTimer();
fd_main(argc, argv);
wxc2_main_state = WXC2_STARTUP;
wxc2_startup_state = 0;
sys_timer10ms = 1;
while(1)
{
if(sys_timer10ms)
{
sys_timer10ms = 0;
moduleProc();
switch(wxc2_main_state)
{
case WXC2_STARTUP:
if(wxc2_startup(no_sync) == WXC2_STARTUP_COMPLETED)
wxc2_main_state = WXC2_NORMAL;
break;
case WXC2_NORMAL:
wxc2_normal_running();
break;
default:
wxc2_main_state = WXC2_STARTUP;
break;
}
segmentLog->sub_state =20;
segmentLog->app_state = 20;
//gx_handle_msg_cb();
gx_fsm(main_now.tv_sec, main_now.tv_usec%1000);
}
if (sys_timer10ms == 0)
{
if(Linux_OS_Release == OS_ES4)
usleep(1);
else
usleep(1000);
}
}
return 1;
}
Reference in New Issue View Git Blame Copy Permalink