c/c++编写window服务的授权服务(四)

// stdafx.h : 标准系统包含文件的包含文件，
// 或是经常使用但不常更改的
// 特定于项目的包含文件
//

#pragma once
#include <winsock2.h>
#include <stdio.h>
#include <stdlib.h>

#include "targetver.h"
#include <tchar.h>

#include <fstream>
#include <iostream>

#include <ole2.h>
#include <conio.h>

using namespace std;

// TODO: 在此处引用程序需要的其他头文件

// LicenseServiceTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "string.h"

#pragma comment(lib,"WS2_32.lib")
long ConnTimeOut=10000;   //连接超时10秒

bool SendMessage_t(char* ipaddr,int port,char* msg);
int HandleRequestLicense(SOCKET socketRequest,char* msg);
//---
char* CurExeDir;
char* GetCurDir(void);
int ReplaceStr(char *sSrc, char *sMatchStr, char *sReplaceStr);
bool EqStr(const char* A,const char* B);
//获取系统时间到豪秒级
SYSTEMTIME GetCurrentSystemDateTime();
long GetSubValueDateTime(SYSTEMTIME one,SYSTEMTIME two);
//--

//获取ServerConfig.ini参数函数
bool GetServerConfig_ini(void);
//------------------------------------------
//定义文件操作的函数
//属性
FILE* fp;
char* filepath;
//方法
bool OpenFile(void);
int EndFile(void);
char* NextLine(void);
int CloseFile(void);
//------------------------------------------
//ServerConfig.ini
//服务器配置文件的全局参数变量
char* host;
char* port;
char* todate;
char* code;
//------------------------------------------

//入口函数
int _tmain(int argc, _TCHAR* argv[])
{
GetServerConfig_ini();
bool rbc=false;
char* strch={ "RequestLicenseCommand"}; //请求License服务
long timeval=0;
long stimes=0;
SYSTEMTIME dt1=GetCurrentSystemDateTime();
do
{
bool rbc=SendMessage_t(host,atoi(port),strch); //"192.168.1.232",9998
if(rbc==true) stimes+=1;
//连接超时处理
SYSTEMTIME dt2=GetCurrentSystemDateTime();
timeval=GetSubValueDateTime(dt2,dt1); //dt2-dt1
}//连接超时，退出处理本Socket程序
while(timeval<=ConnTimeOut && stimes<=3);

if(stimes>=3)
{
printf("请求License服务成功!且有使用权!");
}
else
{
printf("请求License服务失败,或无使用权!");
}
char q;
cin>>q;
return 0;
}
//实现 发送信息函数
bool SendMessage_t(char* ipaddr,int port,char* msg)
{
bool rbc=false;
//port=9998;
WORD wVersionRequested;
WSADATA wsaData;
int err;

//版本请求
wVersionRequested = MAKEWORD(2, 2);
//初始化WinSock(WSAStartup函数)
err = WSAStartup( wVersionRequested, &wsaData);
if ( err != 0 )
{  //初始化出错了退出函数
rbc=false;
return rbc;
}
//初始化成功！但版本不一致! 退出函数
if ( LOBYTE( wsaData.wVersion ) != 2 ||
HIBYTE( wsaData.wVersion ) != 2 ) {
WSACleanup( ); //清除Socket
rbc=false;
return rbc;        //退出函数
}
//生成一个socket(sockSrv变量)
//SOCK_STREAM  用于TCP协议
//SOCK_DGRAM   用于UDP协议
SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);  //使用TCP协议
//设置一个地址Socket(addrSrv变量)
SOCKADDR_IN addrSrv;
memset(&addrSrv,0,sizeof(addrSrv));
addrSrv.sin_addr.S_un.S_addr=inet_addr(ipaddr);//要访问的IP地址
addrSrv.sin_family=AF_INET;
addrSrv.sin_port=htons(port);                 //端口9998
//绑定函数(指定本地IP地址所使用的端口号时候使用)
//(把sockSrv变量与addrSrv变量绑定在一起)
bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
//请求一个连接
printf("正在连接License服务器...");

//bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
if(connect(sockSrv, (sockaddr*)&addrSrv,sizeof(addrSrv)) != SOCKET_ERROR )
{
int ret=HandleRequestLicense(sockSrv,msg);
if(ret==2)
{
rbc=true;
printf("测试连接成功，且允许使用!");
}
else if(ret==1)
{
rbc=false;
printf("测试连接成功，且不允许使用!");
}
else if(ret==0)
{
rbc=false;
printf("测试连接未成功!");
}
if(ret==2||ret==1)
{  //连接成功，退出本次连接
char* stop="stop";
if(send(sockSrv,stop,strlen(stop),0)==SOCKET_ERROR)
{
printf("发送报错了:%d\n ",WSAGetLastError());
}
printf("结束本次连接!");
}
//printf(ret);
} //Connect end
else
{
rbc=false;
//printf("没连上!\n");
}

//关闭Socket变量sockSrv
closesocket(sockSrv);
//清除Socket
WSACleanup();
printf("已退出SendMessage函数!\n");
return rbc;
}

//实现 处理请求License Socket回应函数
//0表示未连接成功,1表未连接成功且无使用权限,2表示连接成功且有使用权限
int HandleRequestLicense(SOCKET sockSrv,char* msg)
{
int ret=0;
bool Exits=false;
if(send(sockSrv,msg,strlen(msg),0)==SOCKET_ERROR)
{
printf("发送报错了:%d\n ",WSAGetLastError());
}
else
{
printf(msg);printf("\n");
//接收返回值
char recvBuf[100];
int recv_len=-1;
while(Exits==false)
{
memset(&recvBuf,0,sizeof(recvBuf));
recv_len=recv(sockSrv,recvBuf,100,0);
if(recv_len>0)
{
char* rec;
rec=new char[recv_len]; //动态生成一个数组
strcpy(rec,recvBuf);
//输出接收到的字符串
printf(rec);printf("\n");
//分析接收到的字符串语义
bool start=false,stop=false,isMsg=false;
start=EqStr(rec,"start");
stop=EqStr(rec,"stop");
isMsg=EqStr(rec,msg);
if(start==true)
{
ret=2;
Exits=true;
}
if(stop==true)
{
ret=1;
Exits=true;
}
if(isMsg==true)
{
ret=0;
Exits=true;
}
}
Sleep(200);
}
printf("请求处理结束!");
}
return ret;

}

//实现 获取当前可执行文件所在目录
char* GetCurDir(void)
{
//推荐用如下方法来得到当前程序所在目录比较安全：
//void _splitpath( const char *path, char *drive, char *dir, char *fname, char *ext );
//函数来分解开始提到的_pgmptr，然后再用
//void _makepath( char *path, const char *drive, const char *dir, const char *fname, const

char *ext );
//函数来对分解后的路径进行组合。这两个函数结合起来功能强大，使用灵活，
//基本上所有的有关目录和路径方面的操作都可以搞定.
//(1)
char* szFilePath=new char[MAX_PATH];
memset(szFilePath,0,MAX_PATH);

GetModuleFileNameA(NULL,szFilePath,MAX_PATH);
//GetModuleFileNameW(NULL,szFilePath,MAX_PATH);

char* szfp=new char[strlen(szFilePath)+1];
strcpy(szfp,szFilePath);

int srcLen=strlen(szfp)+1;
char* Driver=new char[srcLen];
char* dir=new char[srcLen];
char* fn=new char[srcLen];
char* ext=new char[srcLen];
//
memset(Driver,0,srcLen);
memset(dir,0,srcLen);
memset(fn,0,srcLen);
memset(ext,0,srcLen);
//分解路径
_splitpath(szfp,Driver,dir,fn,ext);

char* dri=new char[strlen(Driver)+1];
strcpy(dri,Driver);

char* dir_t=new char[strlen(dir)+1];
strcpy(dir_t,dir);
//组合目录
int len=strlen(dri)+strlen(dir_t);
char* result=new char[len];
memset(result,0,len);
sprintf(result, "%s\\%s",dri,dir_t);

char* r=new char[strlen(result)+1];
strcpy(r,result);
return r;
}

//实现 替换字符串中特征字符串为指定字符串
int ReplaceStr(char *sSrc, char *sMatchStr, char *sReplaceStr)
{
int  StringLen;
int MAX_MSG_LENGTH=strlen(sSrc)+1;
char* caNewString=new char[MAX_MSG_LENGTH];

char *FindPos = strstr(sSrc, sMatchStr);
if( (!FindPos) || (!sMatchStr) )
return -1;

while( FindPos )
{
memset(caNewString, 0, sizeof(caNewString));
StringLen = FindPos - sSrc;
strncpy(caNewString, sSrc, StringLen);
strcat(caNewString, sReplaceStr);
strcat(caNewString, FindPos + strlen(sMatchStr));
strcpy(sSrc, caNewString);

FindPos = strstr(sSrc, sMatchStr);
}
return 0;
}
//实现 字符串是否相等函数
bool EqStr(const char* A,const char* B)
{
bool r=true;
char* t_A=new char[strlen(A)+1];
strcpy(t_A,A);
char* t_B=new char[strlen(B)+1];
strcpy(t_B,B);
int ALen=strlen(t_A);
int BLen=strlen(t_B);
if(ALen>=BLen) ALen=BLen;
{
for(int i=0;i<ALen;i++)
{
if(t_A[i]!=t_B[i])
{
r=false;
break;
}
}
}
return r;
}

SYSTEMTIME GetCurrentSystemDateTime()
{
SYSTEMTIME sys;
GetLocalTime(&sys);
//printf("\n%4d-%02d-%02d %02d:%02d:%02d.%03d 星期%1d

\n",sys.wYear,sys.wMonth,sys.wDay,sys.wHour,sys.wMinute,

sys.wSecond,sys.wMilliseconds,sys.wDayOfWeek);
return sys;
}
long GetSubValueDateTime(SYSTEMTIME one,SYSTEMTIME two)
{
//one-two
int year=one.wYear-two.wYear;
int month=one.wMonth-two.wMonth;
int date=one.wDay-two.wDay;
int hh=one.wHour-two.wHour;
int mm=one.wMinute-two.wMinute;
int ss=one.wSecond -two.wSecond;
int ms=one.wMilliseconds -two.wMilliseconds;
long r=0;
r=ms+ss*1000+mm*60*1000+hh*60*60*1000;
return r;
}
//实现 获取ServerConfig.ini参数函数
bool GetServerConfig_ini(void)
{
char* curdir;
if(CurExeDir==NULL)
{
CurExeDir=GetCurDir();
}
curdir=CurExeDir;
//获取ini文件中的数据
char* inifn="ServerConfig.ini";
int len=strlen(curdir)+strlen(inifn)+1;
char* inipath=new char[len];
sprintf(inipath, "%s\\%s", curdir, inifn);
//printf(inipath);
//---------
char* line;
filepath =inipath;
if(OpenFile()==true)
{
char* line;
while(!EndFile())
{
line=NextLine();
if(line!=NULL)
{
//printf("%s\n",line);
int lineLen=strlen(line);
if(lineLen>0)
{
if(line[0]!=';')
{
if(strstr(line,"LicenseServerHost=")!=NULL)
{
host=line;
}
if(strstr(line,"Port=")!=NULL)
{
port=line;
}
if(strstr(line,"ToDate=")!=NULL)
{
todate=line;
}
if(strstr(line,"LicenseCode=")!=NULL)
{
code=line;
}
}
}
}
}
CloseFile();
}
ReplaceStr(host,"LicenseServerHost=","");
ReplaceStr(port,"Port=","");
ReplaceStr(todate,"ToDate=","");
ReplaceStr(code,"LicenseCode=","");
printf("host->%s\n",host);
printf("port->%s\n",port);
printf("todate->%s\n",todate);
printf("code->%s\n",code);
return true;
}

//实现 打开文件操作
bool OpenFile(void)
{
char* path=filepath;
if((fp=fopen(path,"r"))==NULL)
{
printf("file cannot be opened\n");
return false;
}
return true;
}
//实现 检查文件是否结束函数
int EndFile(void)
{
return feof(fp);
}
//实现 读取下一行函数
char* NextLine()
{
char line[4000];
if(fgets(line,4000,fp)!=NULL)
{
char* ret=new char[strlen(line)+1];
strcpy(ret,line);
return ret;
}
return NULL;
}
//实现 关闭文件函数
int CloseFile(void)
{
if(fp!=NULL)
{
return fclose(fp);
}
return -1;
}
//---the---end---