📄 authen.c
字号:
CommonShow("新线程ComServer出错！");
close(ListenFd);
return(-8);
};
bzero(MessageBuf,100);
sprintf(MessageBuf, "创建线程: %d 处理新请求.", tid);
CommonShow(MessageBuf);
}
/*日志文件*/
SysDate(&newYear, &newMonth, &newDay);
if (iYear!=newYear || iMonth!=newMonth || iDay!=newDay) {
pthread_mutex_lock(&LogMutex);
fclose(fplog);
iYear=newYear;iMonth=newMonth;iDay=newDay;
bzero(FileName,21);
sprintf(FileName, "%04d%02d%02d.log", iYear,iMonth,iDay);
if ((fplog=fopen(FileName,"a+"))==NULL) {
CommonShow("fopen出错！");
}
pthread_mutex_unlock(&LogMutex);
}
} /*while主循环结束 */
close(ListenFd);
return(0);
}
/***************************************************************************/
int MessageServer()
{
if (lpCtlInfo->IsStop) return(-1);
else return(0);
}
/***************************************************************************/
void *ComServer(void* ConnFdBuf)
{
int iIndex;
int ConnFd;
pthread_t selfid;
char Buf[MAX_BUFFER_SIZE];
char BufBack[MAX_BUFFER_SIZE];
char MsgType[3];
R_RSA_PUBLIC_KEY ClientPublicKey;
int ClientPublicKeyReady=0;
int iLen=0;
int iMsgLen=0;
ConnFd=atoi((char *)ConnFdBuf);
selfid=pthread_self();
if (SetBlock(ConnFd)<0) {
SubShow(selfid,"SetBlock出错，ComServer");
close(ConnFd);
pthread_exit(NULL);
}
while(1) {
if ((iMsgLen=ReadRemotePakeage(ConnFd,Buf))<0) {
printf("MsgLen:%d\n", iMsgLen);
SubShow(selfid,"ReadRemotePakeage出错，ComServer, 连接关闭，线程结束");
close(ConnFd);
pthread_exit(NULL);
}
strncpy(MsgType,Buf+4,2);MsgType[2]=0;
if ((strcmp(MsgType,"RQ")==0)||(strcmp(MsgType,"EX")==0)) {
if ((iLen=ProcessPackage(Buf, BufBack, iMsgLen, &ClientPublicKey, &ClientPublicKeyReady,selfid))<=0) { /*调用小奔的后台处理函数，小奔向回写缓冲区Bufback写数据*/
SubShow(selfid,"处理数据包出错！连接关闭，线程结束");
close(ConnFd);
pthread_exit(NULL);
}
strncpy(MsgType,BufBack+4,2);MsgType[2]=0;
if (SendRemotePakeage(ConnFd, BufBack, iLen)<0) {
SubShow(selfid,"发送数据包出错！连接关闭，线程结束");
close(ConnFd);
pthread_exit(NULL);
}
if (strcmp(MsgType,"RP")==0) {
SubShow(selfid,"成功返回登录应答包！连接关闭，线程结束");
close(ConnFd);
pthread_exit(NULL);
} else if (strcmp(MsgType,"MG")==0) {
SubShow(selfid,"成功返回消息包！连接关闭，线程结束");
close(ConnFd);
pthread_exit(NULL);
}
}
} /*end of while*/
}
/************************************************************
*ReturnValue: 数据包字节数 *
************************************************************/
int ReadRemotePakeage(int ConnFd, char *Buf)
{
int MsgLen;
int n;
fd_set ConnSet1;
struct timeval tvConnTimeOut;
tvConnTimeOut.tv_sec=TIME_OUT;
FD_ZERO(&ConnSet1);
FD_SET(ConnFd, &ConnSet1);
/*
if ((n=select(ConnFd+1,&ConnSet1,NULL,NULL,&tvConnTimeOut))<0 || (!FD_ISSET(ConnFd, &ConnSet1)) ) {
CommonShow("select出错！ReadRemotePakeage");
return(-1);
} */
/*调用Readn函数从缓冲区中读入数据到buf*/
if ((n=Readn(ConnFd, Buf, MSGLEN_BYTES))<0) {
CommonShow("ReadRemotePackage error when read lenth");
return(-2);
}
else if(n==0) return(-3);
if ((MsgLen=HexToInt(Buf,MSGLEN_BYTES))<0) {
CommonShow("Received a non hex string, ReadRemotePackage");
return(-4);
}
if ((n=Readn(ConnFd,Buf+MSGLEN_BYTES,MsgLen-MSGLEN_BYTES))<0) {
CommonShow("ReadRemotePackage error when read lenth");
return(-5);
}
else if (n==0) return(-6);
return(n+MSGLEN_BYTES);
}
int SendRemotePakeage(int ConnFd, char *BufBack, int iLen)
{
int n;
fd_set ConnSet2;
struct timeval tvConnTimeOut;
if (iLen>MAX_BUFFER_SIZE) {
CommonShow("包长度太长，SendRemotePackage");
return(-3);
}
tvConnTimeOut.tv_sec=TIME_OUT;
FD_ZERO(&ConnSet2);
FD_SET(ConnFd, &ConnSet2);
/*
if ((n=select(ConnFd+1,NULL,&ConnSet2,NULL,&tvConnTimeOut))<0 || (!FD_ISSET(ConnFd, &ConnSet2)) ) {
CommonShow("select出错！SendRemotePakeage");
return(-1);
} */
/**/
if ((n=write(ConnFd, BufBack, iLen))!=iLen) {
CommonShow("SendRemotePackage error");
return(-2);
}
return n;
}
/************************************************************/
/*验证处理函数
*ReturnValue: 返回包的字节数 */
/************************************************************/
int ProcessPackage(char *Buf, char *BufBack, int iMsgLen, R_RSA_PUBLIC_KEY *pClientPublicKey, int *ClientPublicKeyReady, int tid)
{
R_RANDOM_STRUCT randomStruct1;
char MsgType[3];
char MsgBodyText[MAX_BUFFER_SIZE]; /*需要发送的未加密包体*/
int MsgBodyTextLen;
char RecvText[MAX_BUFFER_SIZE];
char SendText[MAX_BUFFER_SIZE];
int RecvTextLen;
char foperator[7];
char fpassword[26];
char fdepart[8];
char fareacode[2];
char fgsmusername[11];
char fgsmpassword[21];
char fcdrusername[11];
char fcdrpassword[21];
char fipaddress[16];
char fappname[21];
char fprocessid[11];
int iLen;
int MsgLen;
int BodyLen;
int iStatus;
char *pCur;
char *Msg1="公钥交换长度不匹配！";
char *Msg2="无法识别包类型!";
char *Msg3="登录前应该交换公钥!";
char *Msg4="登录数据包解密失败!";
char *Msg5="十六进制转化出错！";
char Msg8[255];char ReturnCode[5];
char MsgBuf[255];
u_short *p; int i;
strncpy(MsgType, Buf+4, 2); MsgType[2]=0;
if (strcmp(MsgType, "EX")==0) {
iLen=HexToInt(Buf+12, 4);
p=(unsigned short*)(Buf+12+4);
for(i=0;i<sizeof(ServerPublicKey);i=i+2) *(p+i)=htons(*(p+i));
bzero(pClientPublicKey,sizeof(ServerPublicKey));
memcpy(pClientPublicKey, Buf+12+4, sizeof(ServerPublicKey));
*ClientPublicKeyReady=1;
/*返回共钥交换包*/
sprintf(MsgBodyText, "%4X", sizeof(ServerPublicKey));
memcpy(MsgBodyText+4, &ServerPublicKey, sizeof(ServerPublicKey));
BodyLen=sizeof(ServerPublicKey)+4;
p=(unsigned short*)(MsgBodyText+4); for(i=0;i<sizeof(ServerPublicKey);i=i+2) *(p+i)=ntohs(*(p+i));
MsgLen=BuildPackage(BufBack, MsgBodyText, BodyLen, 1, "EX", "0000");
}
else if (strcmp(MsgType, "RQ")==0) {
if (*ClientPublicKeyReady==1) {
/*解密包体*/
bzero(RecvText, MAX_BUFFER_SIZE);
pthread_mutex_lock(&KeyMutex);
iStatus=RSAPrivateDecrypt(RecvText, &RecvTextLen, Buf+12, iMsgLen-12, &ServerPrivateKey);
pthread_mutex_unlock(&KeyMutex);
if (iStatus==0) {
/*取解密后的字段，RecvText*/
bzero(foperator,7);
bzero(fpassword,26);
bzero(fdepart,8);
bzero(fareacode,2);
bzero(fgsmusername,11);
bzero(fgsmpassword,21);
bzero(fcdrusername,11);
bzero(fcdrpassword,21);
bzero(fipaddress,16);
/*解开工号和口令等*/
pCur=RecvText;
if ((iLen=HexToInt(pCur, 4))<0) goto HexToIntError;
memcpy(foperator,pCur+4,MIN(iLen,6));foperator[6]=0;pCur=pCur+4+iLen;
if ((iLen=HexToInt(pCur, 4))<0) goto HexToIntError;
memcpy(fpassword,pCur+4,MIN(iLen,25));fpassword[25]=0;pCur=pCur+4+iLen;
if ((iLen=HexToInt(pCur, 4))<0) goto HexToIntError;
memcpy(fipaddress,pCur+4,MIN(iLen,15));fipaddress[15]=0;pCur=pCur+4+iLen;
/*访问数据库*/
pthread_mutex_lock(&DatabaseMutex);
iStatus=CheckOperator(foperator, fpassword, fdepart, fareacode, fgsmusername, fgsmpassword, fcdrusername, fcdrpassword);
pthread_mutex_unlock(&DatabaseMutex);
bzero(Msg8,255);
if (iStatus==-1) {strcpy(Msg8, "口令不正确!"); strcpy(ReturnCode, "0001");}
else if (iStatus==-2) {strcpy(Msg8, "用户名不存在!"); strcpy(ReturnCode, "0002");}
else if (iStatus==0) {strcpy(Msg8, "登录成功!"); strcpy(ReturnCode, "0000");}
else {strcpy(Msg8, "数据库错误!"); strcpy(ReturnCode, "0003");}
bzero(MsgBuf,255);
sprintf(MsgBuf, "%s : %s : %s",foperator, fipaddress, Msg8);
SubShow(tid, MsgBuf);
if (lpCtlInfo->IsLog) {
bzero(MsgBuf,255);
GetSysTime(MsgBuf);
sprintf(MsgBuf+14," : %s : %s : %s",foperator, fipaddress, Msg8);
if (fplog) {
pthread_mutex_lock(&LogMutex);
fprintf(fplog,"%s\n", MsgBuf);
fflush(fplog);
pthread_mutex_unlock(&LogMutex);
}
}
if (iStatus!=0) {
sprintf(MsgBodyText, "%4X", strlen(Msg8));
memcpy(MsgBodyText+4, Msg8, strlen(Msg8));
BodyLen=strlen(Msg8)+4;
MsgLen=BuildPackage(BufBack, MsgBodyText, BodyLen, 1, "MG", ReturnCode);
}
else {
/*生成发送包体明文*/
bzero(SendText, MAX_BUFFER_SIZE);
pCur=SendText;
iLen=strlen(fgsmusername);
sprintf(pCur, "%4X", iLen);
memcpy(pCur+4, fgsmusername, iLen); pCur=pCur+4+iLen;
iLen=strlen(fgsmpassword);
sprintf(pCur, "%4X", iLen);
memcpy(pCur+4, fgsmpassword, iLen); pCur=pCur+4+iLen;
iLen=strlen(fcdrusername);
sprintf(pCur, "%4X", iLen);
memcpy(pCur+4, fcdrusername, iLen); pCur=pCur+4+iLen;
iLen=strlen(fcdrpassword);
sprintf(pCur, "%4X", iLen);
memcpy(pCur+4, fcdrpassword, iLen); pCur=pCur+4+iLen;
*pCur=0;
/*加密包体*/
iLen=(pCur-SendText);
pthread_mutex_lock(&KeyMutex);
bzero(MsgBodyText,MAX_BUFFER_SIZE);
bzero(&randomStruct1,sizeof(randomStruct1));
MsgBodyTextLen=0;
R_RandomCreate(&randomStruct1);
iStatus=RSAPublicEncrypt(MsgBodyText, &MsgBodyTextLen, SendText, iLen, pClientPublicKey, &randomStruct1);
pthread_mutex_unlock(&KeyMutex);
MsgLen=BuildPackage(BufBack, MsgBodyText, MsgBodyTextLen, 8, "RP", "0000");
}
}
else { /*登录数据包解密失败*/
sprintf(MsgBodyText, "%4X", strlen(Msg4));
memcpy(MsgBodyText+4, Msg4, strlen(Msg4));
BodyLen=strlen(Msg4)+4;
MsgLen=BuildPackage(BufBack, MsgBodyText, BodyLen, 1, "MG", "0009");
}
}
else { /*0006：登录前应该交换公钥!*/
sprintf(MsgBodyText, "%4X", strlen(Msg3));
memcpy(MsgBodyText+4, Msg3, strlen(Msg3));
BodyLen=strlen(Msg3)+4;
MsgLen=BuildPackage(BufBack, MsgBodyText, BodyLen, 1, "MG", "0006");
}
/*RQ end*/
}
else { /*处理其它类型数据包*/
sprintf(MsgBodyText, "%4X", strlen(Msg2));
memcpy(MsgBodyText+4, Msg2, strlen(Msg2));
BodyLen=strlen(Msg2)+4;
MsgLen=BuildPackage(BufBack, MsgBodyText, BodyLen, 1, "MG", "0008"); /*0008:无法识别包类型*/
}
return(MsgLen);
HexToIntError:
sprintf(MsgBodyText, "%4X", strlen(Msg5));
memcpy(MsgBodyText+4, Msg5, strlen(Msg5));
BodyLen=strlen(Msg5)+4;
MsgLen=BuildPackage(BufBack, MsgBodyText, BodyLen, 1, "MG", "0005"); /*0005:十六进制转化出错*/
return(MsgLen);
}
/************************************************************/
/*验证处理函数
*ReturnValue: 返回包的字节数 */
/************************************************************/
int BuildPackage(char *BufBack, char *MsgBodyText, int MsgBodyLen, int FieldsCount, char *MsgType, char *ReturnCode)
{
char Msg[40];
if (MsgBodyLen >= (MAX_BUFFER_SIZE-12)) {
strcpy (Msg, "数据包溢出！");
sprintf(MsgBodyText, "%4X", strlen(Msg));
strcpy (MsgBodyText+4, Msg);
strcpy (MsgType, "MG");
MsgBodyLen=4+strlen(Msg);
FieldsCount=1;
strcpy(ReturnCode, "0004");
}
sprintf(BufBack, "%4X", MsgBodyLen+12);
memcpy (BufBack+4, MsgType, 2);
sprintf(BufBack+6, "%2X", FieldsCount);
memcpy (BufBack+8, ReturnCode, 4);
memcpy (BufBack+12,MsgBodyText,MsgBodyLen);
return(MsgBodyLen+12);
}
/************************************************************/
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -