communication.cpp

为电力系统开发保护设备装置通讯的源代码 采用串口通讯, ret hat 9下 QT开发

					}
					break;
				default:
					main_pass = false;
					net_error_log(ACCEPT);
					break;
			}
		}
		else main_pass = false;
	}
	return sfd;	
}

int_socket CSocket::Accept(struct sockaddr_in * addr)
{
	int_socket result;
	
	result = CSocket::Accept(this->socketfd, addr);
	return result;
}

bool CSocket::GetSockname(int_socket mysock, struct sockaddr_in *localaddr, socklen_t *addrlen)
{
	int localError;
	
	if (!CSocket::IsOpened(mysock))
	{
		net_error_log(GETSOCKNAME, NOT_OPENED, NOT_OPENED_CODE);
		return false;
	}
	localError = ::getsockname(mysock, (struct sockaddr *)localaddr, addrlen);
	if (localError == GETSOCKNAME_ERROR)
	{
		switch (errno)
		{
			default:
				net_error_log(GETSOCKNAME);
				break;
		}
		return false;
	}
	else return true;
}

bool CSocket::GetSockname(struct sockaddr_in *localaddr, socklen_t *addrlen)
{
	bool result;
	result = CSocket::GetSockname(this->socketfd, localaddr, addrlen);
	return result;
}

bool CSocket::GetPeername(int_socket mysock, struct sockaddr_in *peeraddr, socklen_t *addrlen)
{
	int localError;
	
	if (!CSocket::IsOpened(mysock))
	{
		net_error_log(GETPEERNAME, NOT_OPENED, NOT_OPENED_CODE);
	}
	localError = ::getpeername(mysock, (struct sockaddr *)peeraddr, addrlen);
	if (localError == GETPEERNAME_ERROR)
	{
		switch (errno)
		{
			default:
				net_error_log(GETPEERNAME);
				break;
		}
		return false;
	}
	else return true;
}

bool CSocket::GetPeername(struct sockaddr_in *peeraddr, socklen_t *addrlen)
{
	bool result;
	result = CSocket::GetPeername(this->socketfd, peeraddr, addrlen);
	return result;
}

void CSocket::Shutdown(int_socket mysock, enuShutdown how)
{
	int localError;
	if (!CSocket::IsOpened(mysock))
	{
		net_error_log(SHUTDOWN, NOT_OPENED, NOT_OPENED_CODE);
		return;
	}
	
	localError = ::shutdown(mysock, how);
	
	if (localError == SHUTDOWN_ERROR)
	{
		switch (errno)
		{
			default:
				net_error_log(SHUTDOWN);
				break;
		}
		return;
	}
	return;
}

void CSocket::Shutdown(enuShutdown how)
{
	CSocket::Shutdown(this->socketfd, how);
}

bool CSocket::Wait(int_socket mysock, bool & read, bool &write, bool &exception, int seconds, int useconds)
{
	if (!CSocket::IsOpened(mysock))
	{
		net_error_log(WAIT, NOT_OPENED, NOT_OPENED_CODE);
		return false;
	}
	
	struct timeval time;
	time.tv_sec = seconds;
	time.tv_usec = useconds;
	
	fd_set * readfds = 0;
	fd_set * writefds = 0;
	fd_set * exceptfds = 0;
	
	if (read)
	{
		readfds = new fd_set;
		FD_ZERO(readfds);
		FD_SET(mysock, readfds);
	}
	if (write)
	{
		writefds = new fd_set;
		FD_ZERO(writefds);
		FD_SET(mysock, writefds);
	}
	if (exception)
	{
		exceptfds = new fd_set;
		FD_ZERO(exceptfds);
		FD_SET(mysock, exceptfds);
	}
	
	int ret = select(mysock, readfds, writefds, exceptfds, &time);
	if (read)
	{
		read = FD_ISSET(mysock, readfds);
	}
	if (write)
	{
		write = FD_ISSET(mysock, writefds);
	}
	if (exception)
	{
		exception = FD_ISSET(mysock, exceptfds);
	}
	
	delete readfds;
	delete writefds;
	delete exceptfds;
	
	if (ret < 0)
	{
		switch (errno)
		{
			default:
				net_error_log(WAIT);
				break;
		}
		return false;
	}
	return (ret != 0);
}

bool CSocket::Wait(bool& read, bool& write, bool& exception, int seconds, int useconds)// throw (CException)
{
	bool result;
	result = CSocket::Wait(this->socketfd, read, write, exception, seconds, useconds);
	return result;
}

bool CSocket::IsOpened(int_socket mysock)
{
	if (isfdtype(mysock, S_IFSOCK) == 1) return true;
	else return false;
}

bool CSocket::IsOpened()
{
	bool result;
	result = CSocket::IsOpened(this->socketfd);
	return result;
}
/*===============================================================================
	client:
	  socket()-->connect()-->| send or recv |-->close()
===============================================================================*/
CClient::CClient(CSocket::enuProtocol_t initProtocol, HAFormat initFormat, const char *initServername, int initServerport)
			: my_sock(initProtocol)
{
	if (initProtocol == CSocket::TCP) is_tcp = true;
	else is_tcp = false;

	bzero(&server_addr, sizeof(server_addr));
	if (initFormat == NUMDOTADDR)
	{
		char str[256];
		memset(str, 0x00, sizeof(str));
		inet_pton(AF_INET, initServername, &server_addr.sin_addr);
		inet_ntop(AF_INET, &server_addr.sin_addr, str, sizeof(str));
	}

	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(initServerport);

	if (this->IsTCP())my_sock.Connect(server_addr);

	socklen_t myaddr_len = sizeof(my_addr);;
	getsockname(my_sock.GetDescriptor(), (struct sockaddr *)&my_addr, &myaddr_len);
}

CClient::CClient(int_socket initSocketfd):my_sock(initSocketfd)
{
	this->is_tcp = true;
}

void CClient::Close()
{
	my_sock.Close();
	bzero(&server_addr, sizeof(server_addr));
	bzero(&my_addr, sizeof(my_addr));
}

void CClient::Shutdown()
{
	my_sock.Shutdown(CSocket::READ_WRITE);
}

CClient::~CClient()
{
	if (my_sock.IsOpened())
	{
		my_sock.Close();
	}
}

bool CClient::SetServer(HAFormat initFormat, const char *initServername, int initServerport)
{
	if (this->IsTCP())
		return false;
	bzero(&server_addr, sizeof(server_addr));
	if (initFormat == NUMDOTADDR)
	{
		char str[256];
		inet_pton(AF_INET, initServername, &server_addr.sin_addr);
		inet_ntop(AF_INET, &server_addr.sin_addr, str, sizeof(str));
	}
	
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(initServerport);
	return true;
}

ssize_t CClient::Send(const void *data, size_t size, unsigned int timeout, int flag)
{
	ssize_t result;
	
	if (this->IsTCP()) result = my_sock.Send(data, size, timeout, flag);
	else result = my_sock.Sendto(server_addr, data, size, timeout, flag);

	return result;
}

ssize_t CClient::Recv(void *data, size_t size, unsigned int timeout, int flag)
{
	ssize_t result;
	if (this->IsTCP()) result = my_sock.Recv(data, size, timeout, flag);
	else result = my_sock.Recvfrom(server_addr, data, size, timeout, flag);

	return result;
}

int_socket CClient::GetSocketfd()
{
	return my_sock.GetDescriptor();
}
/*==============================================================================
*CServer
*
===============================================================================*/
/*
______    _____    _____    ______    ______________   ______
|socket()|--> |bind()|--> |listen()|--> |accept()|--> |read() or write()|--> |close()|
-------    -----    ------    -------    ---------------   -------
*/
CServer::CServer(CSocket::enuProtocol_t initProtocol, int initServerPort, int initQueueLen)
			:server_sock(initProtocol)
{
	if (initProtocol == CSocket::TCP) this->is_tcp = true;
	else this->is_tcp = false;
	
	bzero(&server_addr, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	server_addr.sin_port = htons(initServerPort);
	
	server_sock.Bind(this->server_addr);
	if (initProtocol == CSocket::TCP) server_sock.Listen(initQueueLen);
}

CServer::~CServer()
{
	server_sock.Close();
}

bool CServer::Close()
{
	server_sock.Close();
	return true;
}

ssize_t CServer::Send(const void * data, size_t size, unsigned int timeout, int flag)
{
	ssize_t result;
	
	if (this->IsTCP())
	{
		result = -1;//result = server_sock.Send(data, size, timeout, flag);
	}
	else
	{
		result = server_sock.Sendto(client_addr, data, size, timeout, flag);
	}
	return result;
}

ssize_t CServer::Recv(void *data, size_t size, unsigned int timeout, int flag)
{
	ssize_t result;
	if (this->IsTCP()) result = -1;
	else result = server_sock.Recvfrom(client_addr, data, size, timeout, flag);
	return result;
}

int_socket CServer::Accept()
{
	if (!this->IsTCP()) return -1;
	int_socket result;
	struct sockaddr_in temp_sockaddr;
	result = server_sock.Accept(&temp_sockaddr);//result = server_sock.Accept(temp_sockaddr);
	if (isfdtype(result, S_IFSOCK) == 1) return result;
	else return -1;
}

/*==============================================================================
*CCommunication
*
==============================================================================*/
void communi_error(char *msg)
{
	printf("--@@Com103 %s @@--\n", msg);
}

CCommunication::CCommunication()
{
	this->type = NIL;
}

CCommunication::CCommunication(communication_t iType, int realdev_fd)
{
	this->type = iType;
	switch (iType)
	{
		case NET:
			break;
		case NETCLIENT:
			this->realdev.p_netclient = new CClient((int_socket)realdev_fd);
			if (this->realdev.p_netclient == NULL)
			{
				this->type = NIL;
			}
			break;
		case NETSERVER:
			break;
		case COM:
			break;
		default:
			break;
	}
}

CCommunication::~CCommunication()
{
	this->Close();
}

CCommunication::CCommunication(communication_t iType, int iPortno, speed_t iSpeed, unsigned iDataBits, unsigned int iStopBit, paritytype_t iParity,//COM
						char *iMyAddress, CSocket::enuProtocol_t iProtocol, char *iServerAddress, int iServerPort)//NET
{
	bool result;
	
	this->type = NIL;
	result = this->Open(iType, iPortno, iSpeed, iDataBits, iStopBit, iParity, iMyAddress, iProtocol, iServerAddress, iServerPort);
	if (!result) communi_error("error at CCommunication::CCommunication, Open error");
}

bool CCommunication::Open(communication_t iType, int iPortno, speed_t iSpeed, unsigned iDataBits, unsigned int iStopBit, paritytype_t iParity,//COM
					char *iMyAddress, CSocket::enuProtocol_t iProtocol, char *iServerAddress, int iServerPort)//NET
{
	if (this->type != NIL) this->Close();
	iMyAddress[0] = 0x00;
	this->type = iType;
	switch (iType)
	{
		case NET:
			this->realdev.p_net = new CSocket(iProtocol);
			if (this->realdev.p_net == NULL)
			{
				this->type = NIL;
				return false;
			}
			break;
		case NETCLIENT:
			this->realdev.p_netclient = new CClient(iProtocol, NUMDOTADDR, iServerAddress, iServerPort);
			break;
		case NETSERVER:
			break;
		case COM:
			this->realdev.p_com = new CComdev(iPortno, iSpeed, iDataBits, iStopBit, iParity, 1);
			if (this->realdev.p_com == NULL)
			{
				this->type = NIL;
				return false;
			}
			else this->realdev.p_com->SetMin(0);
			break;
		default:
			this->type = NIL;
			return false;
	}
	return true;
}

ssize_t CCommunication::RecvData(void *buffer, size_t size, unsigned int timeout)
{
	ssize_t result = 0;
	if (buffer == NULL)	return -1;
	switch (this->type)
	{
		case NET:
			result = this->realdev.p_net->Recv(buffer, size, timeout);
			if (result < 0)
			{
				this->type = NIL;
				this->realdev.p_net->Close();
			}
			break;
		case NETCLIENT:
			result = this->realdev.p_netclient->Recv(buffer, size, timeout);
			if (result < 0)
			{
				this->type = NIL;
				this->realdev.p_netclient->Close();
			}
			break;
		case NETSERVER:
			result = this->realdev.p_netserver->Recv(buffer, size, timeout);
			if (result < 0)
			{
				this->type = NIL;
				this->realdev.p_netserver->Close();
			}
			break;
		case COM:
			result = this->realdev.p_com->ReadData(buffer, size);
			if (result < 0)
			{
				this->type = NIL;
				this->realdev.p_com->CloseCom();
			}
			break;
		case NIL:
			result = -1;
			break;
		default : break;
	}
	return result;
}

bool CCommunication::RecvData(void *buffer, int& p_size, unsigned int timeout)
{
	if (p_size < 0 || buffer == NULL) return false;
	size_t size = (size_t)(p_size);
	ssize_t result = this->RecvData(buffer, size, timeout);
	p_size = (int)result;
	if (this->type == NIL) return false;
	else return true;
}

ssize_t CCommunication::SendData(void *buffer, size_t size, unsigned int timeout)
{
	ssize_t result = 0;
	
	if (buffer == NULL)	return -1;

	switch (this->type)
	{
		case NET:
			result = this->realdev.p_net->Send(buffer, size, timeout);
			if (result < 0)
			{
				this->type = NIL;
				this->realdev.p_net->Close();
			}
			break;
		case NETCLIENT:
			result = this->realdev.p_netclient->Send(buffer, size, timeout);
			if (result < 0)
			{
				this->type = NIL;
				this->realdev.p_netclient->Close();
			}
			break;
		case NETSERVER:
			result = this->realdev.p_netserver->Send(buffer, size, timeout);
			if (result < 0)
			{
				this->type = NIL;
				this->realdev.p_netserver->Close();
			}
			break;
		case COM:
			result = this->realdev.p_com->WriteData(buffer, size);
			if (result < 0)
			{
				this->type = NIL;
				this->realdev.p_com->CloseCom();
			}
			break;
		case NIL:
			result = -1;
			break;
		default : break;
	}
	return result;
}

bool CCommunication::SendData(void *buffer, int& p_size, unsigned int timeout)
{
	if (buffer == NULL || p_size < 0) return false;
	size_t size = (size_t)(p_size);
	ssize_t result = this->SendData(buffer, size, timeout);
	p_size = (int)result;
	if (this->type == NIL) return false;
	else return true;
}

communication_t CCommunication::GetType()
{
	return this->type;
}

CCommunication * CCommunication::Accept()
{
	if (this->type != NETSERVER) return NULL;
	
	int_socket accept_sockfd;
	CCommunication *p_tempcommu = NULL;
	accept_sockfd = this->realdev.p_netserver->Accept();
	if (isfdtype(accept_sockfd, S_IFSOCK) != 1)	return NULL;
	p_tempcommu = new CCommunication(NETCLIENT, accept_sockfd);
	if (p_tempcommu == NULL) return NULL;
	else return p_tempcommu;
}

bool CCommunication::Close()
{
	switch (this->type)
	{
		case NET:
			delete(this->realdev.p_net);
			this->realdev.p_net = NULL;
			this->type = NIL;
			break;
		case COM:
			delete(this->realdev.p_com);
			this->realdev.p_com = NULL;
			this->type = NIL;
			break;
		case NETCLIENT:
			delete(this->realdev.p_netclient);
			this->realdev.p_netclient = NULL;
			this->type = NIL;
			break;
		case NETSERVER:
			delete(this->realdev.p_netserver);
			this->realdev.p_netserver = NULL;
			this->type = NIL;
			break;
		default : break;
	}
	return true;
}