netclient.cpp

安全文件传输

#include "netClient.h"
/*
1 userLog
2 userReg
3 upLoad
4 downLoad
*/

netClient::netClient(const char* server):serverIP(server)
{
	SSL_library_init();
        OpenSSL_add_all_algorithms();
        SSL_load_error_strings();
        ctx=SSL_CTX_new(SSLv23_client_method());
        if(ctx==NULL)
        {
            ERR_print_errors_fp(stdout);
            exit(1);
         }
        else cout << "ctx create seccefully" <<endl;

         cout<<"socket creating.......        ";

        if((serverSock=socket(AF_INET,SOCK_STREAM,0))<0)
        {
                cout<<"socket creat  error"<<endl;
                exit(1);
        }
        cout<<"socket created"<<endl;

        cout<<"address creating......\t\t";
        bzero(&serverAddr,sizeof(serverAddr));
        serverAddr.sin_family=AF_INET;
        serverAddr.sin_port=htons(SERVERPORT);
        if(inet_aton(serverIP,(struct in_addr*)&serverAddr.sin_addr.s_addr)==0)
        {
                cout<<" change serverIP: "<< serverIP<<" is failed"<<endl;
                exit(1);
        }
        cout<<" ServerSocket inited "<<endl;

}

void netClient::isConnect()
{	
	cout<<"server connecting......\t\t";
        if(connect(serverSock,(struct sockaddr *)&serverAddr,sizeof(serverAddr))!=0)
        {
                cout<<"connect bad"<<endl;
                exit(1);
        }
        cout<<"connect server:  "<< serverIP<< endl;
	
	ssl=SSL_new(ctx);
        SSL_set_fd(ssl,serverSock);
        if(SSL_connect(ssl)==-1)
                ERR_print_errors_fp(stderr);
        else{
                cout<<"connected with "<<SSL_get_cipher(ssl)<<"encryptions"<<endl;
                ShowCerts(ssl);
        }

}


void netClient::ShowCerts(SSL* ssl)
{
	X509 *cert;
        char *line;

        cert=SSL_get_peer_certificate(ssl);

        if(cert!=NULL)
        {
                cout<<"certificate informations:"<<endl;
                line=X509_NAME_oneline(X509_get_subject_name(cert),0,0);
                cout<<"subject<name:"<<line<<endl;
                free(line);
                line=X509_NAME_oneline(X509_get_issuer_name(cert),0,0);
                cout<<"issuer name:"<<line<<endl;
                free(line);

                X509_free(cert);
        }
        else
        {
                cout<<"NO certificate informations"<<endl;
        }

}

metaPack& netClient::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& netClient::unbundle(const metaPack& metadata,char* fileName,char* fileTime,unsigned int& fileSize)
{
        strcpy(fileName,metadata.fileName);
        strcpy(fileTime,metadata.fileTime);
        fileSize = metadata.fileSize;
        return metadata;
}

bool netClient::Read(char* fileName,char* fileTime,unsigned int& fileSize)
{
        memset(fileName,0,FILELENGTH);
        memset(fileTime,0,FILELENGTH);
        fileSize = 0;
        metaPack metadata;
        memset(&metadata,0,sizeof(metaPack));
        if(SSL_read(ssl,(void*)&metadata,sizeof(metaPack)) <= 0)
        {
                cout << "read metadata failed\n";
                return false;
        }
        else
        {
                unbundle(metadata,fileName,fileTime,fileSize);
              //  cout << "recv medata from server :\n";
              //  cout << "fileName: " << fileName << "   fileTime:"<< fileTime <<"  fileSize:" << fileSize << endl;
                return true;
        }
}

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

//command encapsulation write
commandType& netClient::encapsulation(commandType& command,const int& cmd,const char* buf,const char* temp,const unsigned int* fileSize)
{	
	command.com = cmd;
	switch(cmd)
	{
		   case 1:
                        {
                                strcpy(command.pack.userLog.userName,buf);
                                strcpy(command.pack.userLog.userPwd,temp);
                        }
                        break;
                case 2:
                        {
                                strcpy(command.pack.userReg.userName,buf);
                                strcpy(command.pack.userReg.userPwd,temp);
                        }
                        break;
                case 3:
                        {
                                strcpy(command.pack.upLoadPac.fileName,buf);
                                strcpy(command.pack.upLoadPac.fileTime,temp);
                                command.pack.upLoadPac.fileSize = *fileSize;
                        }
                        break;
                case 4:
                        {
                                strcpy(command.pack.downLoadPac.fileName,buf);
                        }
                        break;

                default:
                        cout << "command can't explain \n" ;
                        break;

	}
	return command;
}


 bool netClient::Write(const int& cmd,const char* buf,const char* temp , const unsigned int* fileSizeP)
{
        commandType command;
        memset(&command,0,sizeof(commandType));
        encapsulation(command,cmd,buf,temp,fileSizeP);
        if(SSL_write(ssl,(void*)&command,sizeof(commandType)) <= 0)
        {
                cout << "errno in command" << endl;
                return false;
        }
        else if( cmd == 1)
                cout << "userLogin:  userName:" << buf << "  userPwd:" << temp<< endl;
        else if( cmd == 2)
                cout << "userReg: userName:" << buf<< "  userPwd:" << temp<< endl;
        else if( cmd ==3)
                cout <<"upLoadfile  fileName:" << buf <<"  fileTime:" << temp << " fileSize:" << (*fileSizeP) << endl;
        else if( cmd ==4)
                cout <<"downLoadFile:  fileName:" << buf << endl;
	return true;

}

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

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


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

int netClient::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))== -1)
	{
		return -1;
	}
	else 
	{
		return myProtocol.filedata.dataSize;
	}
}