communication.cpp

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

bool CComdev::SetStopbit(int stopBit)
{
	bool result;
	result = CComdev::SetStopbit(this->com_fd, stopBit);
	return result;
}

bool CComdev::SetParity(int comfd, paritytype_t type)
{
	if (!isatty(comfd))
	{
		error_log("error at SetParity, comfd is not atty\n");
		return false;
	}
	struct termios option;
	if (tcgetattr(comfd, &option) != 0)
	{
		error_log("error at SetParity, tcgetattr error\n");
		return false;
	}

	switch (type)
	{
		case N:    
			option.c_cflag &= ~PARENB;
			option.c_iflag &= ~INPCK;
			break;  
		case O:
			option.c_cflag |= PARENB; 
			option.c_cflag |= PARODD;
			option.c_iflag |= INPCK;
			break;
		case E:
			option.c_cflag |= PARENB;
			option.c_cflag &= ~PARODD;
			option.c_iflag |= INPCK;
			break; 
		default:
			return false;
			break;			
	}

	if (tcsetattr(comfd, TCSANOW, &option) != 0)
	{
		error_log("error SetParity, tcsetattr error\n");
		return false;
	}
	else return true;
	{
		
	}	
}

bool CComdev::SetParity(paritytype_t type)
{
	bool result;
	result = CComdev::SetParity(this->com_fd, type);
	return result;
}

bool CComdev::SetOption(int comfd, struct termios *p_option)
{
	if (!isatty(comfd))
	{
		error_log("error at SetOption, comfd is not atty\n");
		return false;
	}
	if (p_option == NULL)
	{
		error_log("error at SetOption, option is NULL\n");
		return false;
	}

	if (tcsetattr(comfd, TCSANOW, p_option) != 0)
	{
		error_log("error at SetOption, tcsetattr error\n");
		return false;
	}
	else return true;
}

bool CComdev::SetOption(struct termios *p_option)
{
	bool result;
	result = CComdev::SetOption(this->com_fd, p_option);
	return result;
}

bool CComdev::GetOption(int comfd, struct termios *p_option)
{
	if (!isatty(comfd))
	{
		error_log("error at GetOption, comfd is not atty\n");
		return false;
	}
	if (p_option == NULL)
	{
		error_log("error at GetOption, p_option is NULL\n");
		return false;
	}
	
	if (tcgetattr(comfd, p_option) != 0)
	{
		error_log("error at GetOption, tcgetattr error\n");
		return false;
	}
	else return true;
}


bool CComdev::GetOption(struct termios *p_option)
{
	bool result;
	result = CComdev::GetOption(this->com_fd, p_option);
	return result;
}

bool CComdev::CloseCom(int& comfd)
{
	if (isatty(comfd))
	{
		close(comfd);
		comfd = -1;
		return true;
	}
	else
	{
		error_log("comfd is not COM dev\n");
		return false;
	}
}

bool CComdev::CloseCom()
{
	bool result;
	result = CComdev::CloseCom(this->com_fd);
	return result;
}

/*==============================================================================
* Net socket
==============================================================================*/

#define NETERRTOFILE "neterror.log"
int net_error;

void net_error_init()
{
	net_error = 0;
}

int net_error_log(const char *error_msg1, const char *error_msg2, const int error_code)
{
	if (error_msg1 != NULL)
	{
		printf("--@@Com103 error message 1 is %s. @@--\n", error_msg1);
	}
	if (error_msg2 != NULL)
	{
		printf("--@@Com103 error message 2 is %s. @@--\n", error_msg2);
	}
	net_error = error_code;
	printf("--@@Com103 error code is %d @@--\n", net_error);
}

//-------------------------------------------------------------------------

namespace nsErrorReturnValues
{
	const int SOCKET_ERROR      = -1;
    const int BIND_ERROR        = -1;
    const int CONNECT_ERROR     = -1;
    const int SEND_ERROR        = -1;
    const int RECV_ERROR        = -1;
    const int LISTEN_ERROR      = -1;
    const int ACCEPT_ERROR      = -1;
    const int GETSOCKNAME_ERROR = -1;
    const int GETPEERNAME_ERROR = -1;
    const int GETSOCKOPT_ERROR  = -1;
    const int SETSOCKOPT_ERROR  = -1;
    const int SHUTDOWN_ERROR    = -1;
}

namespace nsErrorMessages
{
	const char * NOT_OPENED = "Socket not opened yet";
    const char * OPENED     = "Socket already opened";
}

namespace nsMethodNames
{
	const char * OPEN        = "CSocket::Open()";
    const char * CLOSE       = "CSocket::Close()";
    const char * BIND        = "CSocket::Bind()";
    const char * CONNECT     = "CSocket::Connect()";
    const char * SEND        = "CSocket::Send()";
    const char * SENDTO      = "CSocket::Sendto()";
    const char * RECV        = "CSocket::Recv()";
    const char * RECVFROM    = "CSocket::Recvfrom()";
    const char * LISTEN      = "CSocket::Listen()";
    const char * ACCEPT      = "CSocket::Accept()";
    const char * GETSOCKNAME = "CSocket::Getsockname()";
    const char * GETPEERNAME = "CSocket::Getpeername()";
    const char * GETSOCKOPT  = "CSocket::Getsockopt()";
    const char * SETSOCKOPT  = "CSocket::Setsockopt()";
    const char * SHUTDOWN    = "CSocket::Shutdown()";
    const char * WAIT        = "CSocket::Wait()";
}

using namespace nsErrorReturnValues;
using namespace nsErrorMessages;
using namespace nsMethodNames;

//----------------------------------------
CSocket::CSocket()
{
	this->socketfd = -1;
}

CSocket::CSocket(int_socket sockfd)
{
	this->socketfd = sockfd;
}

CSocket::CSocket(enuProtocol protocol)
{
	this->socketfd = -1;
	this->Open(protocol);
}

CSocket::~CSocket()
{
	if (this->IsOpened())
	{
		::close(this->socketfd);
		this->socketfd = -1;
	}
}

int_socket CSocket::OpenSocket(enuProtocol protocol)
{
	int_socket tempsock;
	
	tempsock = ::socket(AF_INET, protocol, 0);
	if (tempsock == SOCKET_ERROR)
	{
		switch (errno)
		{
			case EPROTONOSUPPORT://
				net_error_log(OPEN, "protocol no support", errno);
				break;
			case ENFILE://
				net_error_log(OPEN, "not core mem to socket", errno);
				break;
			case EMFILE://
				net_error_log(OPEN, "overflow process des_tbl", errno);
				break;
			default:
				net_error_log(OPEN);
				break;
		}
		return -1;
	}
	else
	{//socket
		int val;
		val = fcntl(tempsock, F_GETFL, 0);
		fcntl(tempsock, F_SETFL, val | O_NONBLOCK);
		
		return tempsock;
	}
}

bool CSocket::Open(enuProtocol protocol)
{
	if (this->IsOpened())
	{
		net_error_log(OPEN, OPENED, OPENED_CODE);
		return false;
	}
	
	this->socketfd = CSocket::OpenSocket(protocol);
	if (!this->IsOpened()) return false;
	else return true;
}

void CSocket::Close(int_socket& mysocket)
{
	if (!CSocket::IsOpened(mysocket))
	{
		net_error_log(CLOSE, NOT_OPENED, NOT_OPENED_CODE);
		return;
	}
	::close(mysocket);
	mysocket = -1;
	return;
}

void CSocket::Close()
{
	CSocket::Close(this->socketfd);
	return;
}

bool CSocket::Bind(int_socket mysock, const sockaddr_in& addr)
{
	int localError;
	
	if (!CSocket::IsOpened(mysock))
	{
		net_error_log(BIND, NOT_OPENED, NOT_OPENED_CODE);
		return false;
	}
	
	const sockaddr *socketAddress = reinterpret_cast<const sockaddr *>(&addr);
	localError = ::bind(mysock, socketAddress, sizeof(addr));
	if (localError == BIND_ERROR)
	{
		switch (errno)
		{
			default:
				net_error_log(BIND);
				break;
		}
		return false;
	}
	else return true;
}

bool CSocket::Bind(const sockaddr_in& addr)
{
	bool result;
	result = CSocket::Bind(this->socketfd, addr);
	return result;
}

bool CSocket::Connect(int_socket mysock, const sockaddr_in& addr)
{
	int localError;
	
	if (!CSocket::IsOpened(mysock))
	{
		net_error_log(CONNECT, NOT_OPENED, NOT_OPENED_CODE);
		return false;
	}

	const int val = fcntl(mysock, F_GETFL, 0);
	fcntl(mysock, F_SETFL, val &(~ O_NONBLOCK));
	localError = ::connect(mysock, (struct sockaddr *)&addr, sizeof(addr));
	fcntl(mysock, F_SETFL, val | O_NONBLOCK);

	if (localError == CONNECT_ERROR)
	{//connect
		switch (errno)
		{
			case EBADF://socket
				net_error_log(CONNECT, "EBADF", errno);
				break;
			case ENOTSOCK://socket
				net_error_log(CONNECT, "ENOTSOCK", errno);
				break;
			case EADDRNOTAVAIL://
				net_error_log(CONNECT, "EADDRNOTAVAIL", errno);
				break;
			case EAFNOSUPPORT://socket
				net_error_log(CONNECT, "EAFNOSUPPORT", errno);
				break;
			case EISCONN://
				net_error_log(CONNECT, "EISCONN", errno);
				break;
			case ETIMEDOUT://
				net_error_log(CONNECT, "ETIMEDOUT", errno);
				break;
			case ECONNREFUSED://
				net_error_log(CONNECT, "RST ECONNREFUSED", errno);
				break;
			case ENETUNREACH://
				net_error_log(CONNECT, "ENETUNREACH", errno);
				break;
			case EADDRINUSE://
				net_error_log(CONNECT, "EADDRINUSE", errno);
				break;
			case EINPROGRESS://
				net_error_log(CONNECT, "EINPROGRESS", errno);
				break;
			case EALREADY://
				net_error_log(CONNECT, "EALREADY", errno);
				break;
			default:
				net_error_log(CONNECT);
		}
		return false;
	}
	else return true;
}

bool CSocket::Connect(const sockaddr_in& addr)
{
	bool result;
	result = CSocket::Connect(this->socketfd, addr);
	return result;
}

ssize_t CSocket::Send(int_socket mysock, const void * data, size_t size, unsigned int timeout, int flags)
{
	ssize_t bytes;
	
	if (!CSocket::IsOpened(mysock))
	{
		net_error_log(SEND, NOT_OPENED, NOT_OPENED_CODE);
		return -1;
	}

	fd_set w_set;
	struct timeval tv;
	FD_ZERO(&w_set);
	FD_SET(mysock, &w_set);
	tv.tv_sec = timeout;
	tv.tv_usec = 0;
	if (select(mysock+1, NULL, &w_set, NULL, &tv) == 0) bytes = 0;
	else bytes = ::send(mysock, data, size, flags);

	if (bytes == SEND_ERROR) net_error_log(SEND);
	
	return bytes;
}

ssize_t CSocket::Send(const void* data, size_t size, unsigned int timeout, int flags)// throw (CException)
{
	ssize_t result;
	result = CSocket::Send(this->socketfd, data, size, timeout, flags);
	return result;
}

ssize_t CSocket::Sendto(int_socket mysock, const sockaddr_in& addr, const void * data, size_t size, unsigned int timeout, int flags)
{
	ssize_t bytes;
	
	if (!CSocket::IsOpened(mysock))
	{
		net_error_log(SENDTO, NOT_OPENED, NOT_OPENED_CODE);
		return -1;
	}
	
	const sockaddr *socketAddress = reinterpret_cast<const sockaddr*>(&addr);

	fd_set w_set;
	struct timeval tv;
	FD_ZERO(&w_set);
	FD_SET(mysock, &w_set);
	tv.tv_sec = timeout;
	tv.tv_usec = 0;
	if (select(mysock+1, NULL, &w_set, NULL, &tv) == 0) bytes = 0;
	else bytes = ::sendto(mysock, data, size, flags, socketAddress, sizeof(addr));
	if (bytes == SEND_ERROR) net_error_log(SENDTO);
	
	return bytes;
}

ssize_t CSocket::Sendto(const sockaddr_in& addr, const void * data, size_t size, unsigned int timeout, int flags)// throw (CException)
{
	ssize_t result;
	result = CSocket::Sendto(this->socketfd, addr, data, size, timeout, flags);
	return result;
}

ssize_t CSocket::Recv(int_socket mysock, void *data, size_t size, unsigned int timeout, int flags)
{
	ssize_t bytes;
	
	if (!CSocket::IsOpened(mysock))
	{
		net_error_log(RECV, NOT_OPENED, NOT_OPENED_CODE);
		return -1;
	}

	fd_set r_set;
	struct timeval tv;
	FD_ZERO(&r_set);
	FD_SET(mysock, &r_set);
	tv.tv_sec = timeout;
	tv.tv_usec = 0;
	if (select(mysock+1, &r_set, NULL, NULL, &tv) == 0) bytes = 0;
	else bytes = ::recv(mysock, data, size, flags);

	if (bytes == RECV_ERROR) net_error_log(RECV);
	
	return bytes;
}

ssize_t CSocket::Recv(void * data, size_t size, unsigned int timeout, int flags)// throw (CException)
{
	ssize_t result;
	result = CSocket::Recv(this->socketfd, data, size, timeout, flags);
	return result;
}

ssize_t CSocket::Recvfrom(int_socket mysock, sockaddr_in& addr, void * data, size_t size, unsigned int timeout, int flags)
{
	ssize_t bytes;
	
	if (!CSocket::IsOpened(mysock))
	{
		net_error_log(RECVFROM, NOT_OPENED, NOT_OPENED_CODE);
		return -1;
	}
	socklen_t addrLen = sizeof(addr);
	sockaddr *socketAddress = reinterpret_cast<sockaddr *>(&addr);

	fd_set r_set;
	struct timeval tv;
	FD_ZERO(&r_set);
	FD_SET(mysock, &r_set);
	tv.tv_sec = timeout;
	tv.tv_usec = 0;
	if (select(mysock+1, &r_set, NULL, NULL, &tv) == 0) bytes = 0;

	else bytes = ::recvfrom(mysock, data, size, flags, socketAddress, &addrLen);

	if (bytes == RECV_ERROR) net_error_log(RECVFROM);
	return bytes;
}

ssize_t CSocket::Recvfrom(sockaddr_in& addr, void * data, size_t size, unsigned int timeout, int flags)
{
	ssize_t result;
	result = CSocket::Recvfrom(this->socketfd, addr, data, size, timeout, flags);
	return result;
}

bool CSocket::Listen(int_socket mysock, int queuelen)
{
	ssize_t localError;
	
	if (!CSocket::IsOpened(mysock))
	{
		net_error_log(LISTEN, NOT_OPENED, NOT_OPENED_CODE);
		return false;
	}
	localError = ::listen(mysock, queuelen);
	if (localError == LISTEN_ERROR)
	{
		net_error_log(LISTEN);
		return false;
	}
	else return true;
}

bool CSocket::Listen(int queuelen)
{
	bool result;
	result = CSocket::Listen(this->socketfd, queuelen);
	return result;
}

int_socket CSocket::Accept(int_socket mysock, struct sockaddr_in* addr)
{
	int_socket sfd;
	bool main_pass = true;
	bool returned = false;
	
	struct timeval tv;
	tv.tv_sec = 2;
	tv.tv_usec = 0;
	fd_set read_set;
	FD_ZERO(&read_set);
	FD_SET(mysock, &read_set);
	
	if (!CSocket::IsOpened(mysock))
	{
		net_error_log(ACCEPT, NOT_OPENED, NOT_OPENED_CODE);
		return -1;
	}
	socklen_t addrLen = sizeof(addr);
	sockaddr *socketAddress = (struct sockaddr *)addr;//reinterpret_cast<sockaddr *>(&addr);

	while (main_pass)
	{
		if (select(mysock+1, &read_set, NULL, NULL, &tv) == 0)
		{
			sfd = -1;
			main_pass = false;
			return sfd;
		}
		else
		{
			sfd = ::accept(mysock, socketAddress, &addrLen);
			main_pass = false;
			return sfd;
		}
		if (sfd == ACCEPT_ERROR)
		{//accept
			switch (errno)
			{
				case EINTR:
					if (returned)
					{
						main_pass = false;
						net_error_log(ACCEPT, "meet EINTR", errno);
					}
					else
					{
						returned = true;
						main_pass = true;