netserver.cpp

安全文件传输

#include "netServer.h"
// FIlENAMESIZE 20 in the userProtocol.h
// DATAMAXBUF 1024 in the userProtocol.h


netServer::netServer()
{	
	int setSockOn = 1;
	SSL_library_init();
        OpenSSL_add_all_algorithms();
        SSL_load_error_strings();
        setCertPrivate();
        cout<<"socket creating.......        ";
        if((serverSock=socket(AF_INET,SOCK_STREAM,0))<0)
        {
                cout<<"socket creat  error"<<endl;
                exit(1);
        }
        cout<<"socket created"<<endl;
	setsockopt(serverSock,SOL_SOCKET,SO_REUSEADDR,&setSockOn,sizeof(setSockOn));
        bzero(&serverAddr,sizeof(serverAddr));
        serverAddr.sin_family=AF_INET;
        serverAddr.sin_port=htons(SERVERPORT);
        serverAddr.sin_addr.s_addr=INADDR_ANY;

         cout<<"binding......\t\t";
        if(bind(serverSock,(struct sockaddr *)&serverAddr,sizeof(struct sockaddr))==-1)
        {
               cout<<"bind bad"<<endl;
                exit(1);
        }else
                cout<<"binded"<<endl;

        cout<<"listening....\t\t";
        if(listen(serverSock,10)==-1)
        {
                cout<<"listen bad"<<endl;
        }else
                cout<<"begin listen........"<<endl;
}
void netServer::setCertPrivate()
{
 	ctx=SSL_CTX_new(SSLv23_server_method());
        if(ctx==NULL)
        {
                ERR_print_errors_fp(stdout);
                exit(1);
        }

        if(SSL_CTX_use_certificate_file(ctx,"cacert.pem",SSL_FILETYPE_PEM)<=0)
        {
                ERR_print_errors_fp(stdout);
                exit(1);
        }

        if(SSL_CTX_use_PrivateKey_file(ctx,"privkey.pem",SSL_FILETYPE_PEM)<=0)        {
                ERR_print_errors_fp(stdout);
                exit(1);
        }

        if(!SSL_CTX_check_private_key(ctx))
        {
                ERR_print_errors_fp(stdout);
                exit(1);
        }
	cout << "ssl server init over" << endl;
}

int netServer::isAccept()
{
	unsigned int len=sizeof(clientAddr);
        clientSock=accept(serverSock,(struct sockaddr*)&clientAddr,&len);
        if(clientSock == -1)
        {

                cout<<"accept_socket bad"<<endl;
                exit(1);
        }
        else
        {	cout << "server:get connection from client "<<endl;
		return clientSock;
	}
}
SSL* netServer::sslAccept()
{	
	ssl=SSL_new(ctx);
        SSL_set_fd(ssl,clientSock);
        if(SSL_accept(ssl)==-1)
        {
                cout<<"ssl accept bad"<<endl;
                close(clientSock);
                exit(1);
        }
        else 
	{
		cout << "ssl accept with sock" << endl;
		return ssl;
	}
}
// metaPack read  write  encapsulation unbundle
metaPack& netServer::encapsulation(metaPack& metadata,const char * fileName,const char* fileTime,const unsigned int fileSize)
{
	memset(&metadata,0,sizeof(metaPack));
	strcpy(metadata.fileName,fileName);
	strcpy(metadata.fileTime,fileTime);
	metadata.fileSize = fileSize;		
	return metadata;
}

const metaPack& netServer::unbundle(const metaPack& metadata,char* fileName,char* fileTime,unsigned int& fileSize)
{	
	
	strcpy(fileName,metadata.fileName);
	strcpy(fileTime,metadata.fileTime);
	fileSize = metadata.fileSize;
	return metadata;
}

int netServer::Read(char* fileName,char* fileTime,unsigned int& fileSize)
{	
	
	int length;
	if(fileName != NULL)
	memset(fileName,0,FILELENGTH);
	if(fileName !=NULL)
	memset(fileTime,0,FILELENGTH);
	fileSize = 0;
	metaPack metadata;

	memset(&metadata,0,sizeof(metaPack));
	if((length=SSL_read(ssl,(void*)&metadata,sizeof(metaPack))) <= 0)
	{	
		cout << "read metadata failed\n";
		return -1;	
	}
	else
	{
		unbundle(metadata,fileName,fileTime,fileSize);
	//	cout << "recv medata from server :\n";
		
		cout << "fileName: " << fileName << "   fileTime:"<< fileTime <<"  fileSize:" << fileSize << endl;
		return length;
	}	
}

int netServer::Write(const char* fileName,const char* fileTime,const unsigned int fileSize)
{
	int length;
	metaPack metadata;
	memset(&metadata,0,sizeof(metadata));
	encapsulation(metadata,fileName,fileTime,fileSize);
	if((length=SSL_write(ssl,(void*)&metadata,sizeof(metaPack))) <= 0)
	{
		cout << "Write metadata failed \n";
		return -1;
	}
	else
	{
	//	cout << "send metadata to client: \n";
		cout << "fileName: "<< fileName << "   fileTime:"<<fileTime<<"  fileSize:" << fileSize << endl;
		return length;
	}
}


// about command explain
/*
1 userLogin
2 userReg
3 upload
4 downLoad
*/
void netServer::unbundle(const commandType& command,int& cmd,char* buf,char* temp,unsigned int* fileSizeP)
{	
	
	if(buf != NULL)
		memset(buf,0,COMMANDBUF);
	if(temp!= NULL)
		memset(temp,0,COMMANDBUF);
	cmd =command.com;

	switch(cmd)
	{
		case 1:
			{
				strcpy(buf,command.pack.userLog.userName);
				strcpy(temp,command.pack.userLog.userPwd);
			}
			break;	
		case 2:
			{
				strcpy(buf,command.pack.userReg.userName);
				strcpy(temp,command.pack.userReg.userPwd);
			}
			break;
		case 3:
			{
				strcpy(buf,command.pack.upLoadPac.fileName);
				strcpy(temp,command.pack.upLoadPac.fileTime);
				*fileSizeP = command.pack.upLoadPac.fileSize;
			}		
			break;
		case 4:
			{
				strcpy(buf,command.pack.downLoadPac.fileName);
			}
			break;
			
		default:
			cout << "command can't explain \n" ;
			break;
	}
}

int netServer::Read(int& cmd,char* buf, char* temp,unsigned int* fileSizePoint)
{
			
		if(buf != NULL)
			memset(buf,0,COMMANDBUF);
		if(temp != NULL)
			memset(temp,0,COMMANDBUF);
		commandType command;
		memset(&command,0,sizeof(commandType));
		int length;
		
		if((length=SSL_read(ssl,(void*)&command,sizeof(commandType)))== -1)
		{
			cout << "received command failed \n";
			return -1;
		}
		else
		{	
			cout << length << endl;
			cout << "received command from client:"<< endl;
			unbundle(command,cmd,buf,temp,fileSizePoint);
			if( cmd == 1)
				cout << "userLogin : \n userName: "<< buf << "   userPwd:"  << temp << endl;
			else if( cmd == 2)
				cout << "userRegiter:\n userName: "<< buf <<"    userPwd:" << temp << endl;
			else if( cmd == 3)
				cout << "upLoadfile:\n  fileName: "<< buf << "fileTime: "<< temp << "fileSize:  " << (*fileSizePoint) << endl;
			else if( cmd == 4)
				cout << "downLoadfile:\n fileName: "<< buf << endl;
			else 
				cout << "Unkown command" << endl;
			return cmd;
		}

}
int  netServer::Read(char* buf)
{	
	int len = 0;
	memset(buf,0,ERRNOBUF);
	if(buf != NULL)
	{
		memset(buf,0,ERRNOBUF);
		if((len = SSL_read(ssl,buf,ERRNOBUF))==-1)
		{
			return -1;
		}
		return len;
	}
	else return -1;
}

int netServer::Write(const char* buf)
{	
	int len = 0;
	if( buf !=NULL )
	{
		if((len=SSL_write(ssl,buf,ERRNOBUF))==-1)
		{
			return -1;
		}
		else return len;
	}
	else return -1;
}


//dataProtocol encapsulation unbundle read write
// 1 start 2 translation 3 end

dataProtocol& netServer::encapsulation(dataProtocol& myProtocol,const int& status,const char* buf,const unsigned int fileSize)
{
	memset(&myProtocol,0,sizeof(myProtocol));
	strcpy(myProtocol.filedata.fileData,buf);
	myProtocol.status = status;
	if(status == 1) myProtocol.filedata.dataSize =fileSize;
	else myProtocol.filedata.dataSize =strlen(buf)+1;
	return myProtocol;
}

const dataProtocol& netServer::unbundle(const dataProtocol& myProtocol,int& status,char* buf,unsigned int& fileSize )
{
	memset(buf,0,DATAMAXBUF);
	strcpy(buf,myProtocol.filedata.fileData);
	status = myProtocol.status;
	fileSize = myProtocol.filedata.dataSize;
	return myProtocol;
}

int netServer::dataRead(int& status,char* buf,unsigned int& fileSize)
{	
	dataProtocol myProtocol;
	memset(&myProtocol,0,sizeof(dataProtocol));
	if((SSL_read(ssl,&myProtocol,sizeof(dataProtocol))) <= 0)
	{	
		cout << "read false" << endl;
		return -1;
	}
	else
	{
		unbundle(myProtocol,status,buf,fileSize);
		return fileSize;
	}
	
}

int netServer::dataWrite(const int& status,const char* buf,const unsigned int fileSize)
{	
	
	dataProtocol myProtocol;
        memset(&myProtocol,0,sizeof(dataProtocol));
        encapsulation(myProtocol,status,buf,fileSize);
        if(SSL_write(ssl,&myProtocol,sizeof(dataProtocol)) <= 0)
        {
                return -1;
        }
        else
        {
                return myProtocol.filedata.dataSize;
        }

}