snifferTCP

#include "sdk30.h"
#include "ip_.h"
#include "timer.h"

#define UDP 0

int logSockData(char* data, int Size, struct sockaddr_in *from);
int isMoreLogSize(int size);
int openLogFile(void);
void setMyEthParams(char eth_str[32]);
char *getMyEthParams(void);
static void sockTransmitMsgDisplay(void);
static int OpenTCP(void);

static struct sockaddr_in server, socaddr_tmp;
static struct sockaddr_in client_cash;
static struct sockaddr_in client_pos;
static int my_listen_socket = -1;
static S_FS_FILE *file = NULL;
static char eth_str[32] = { 0 };

/**
 * Read c string to \n charachter or to num-1
 * @param char* dst : Distination string
 * @param unsigned int num : number of chars to be read
 * @param S_FS_FILE *pxFile : File stream
 * @return int : 0 if end of the file, 1 else
 * @note none
 */
int my_fgets(char* dst, int num, S_FS_FILE *pxFile) {
	int i = 0;
	int iRet = 0;
	char ch = 0;

	if (dst == NULL || num <= 0 || pxFile == NULL)
		return 0;
	else if (num == 1) {
		dst[0] = '\0';
		return 1;
	}

	iRet = FS_read(&ch, 1, 1, pxFile);
	if (iRet == 0)
		return 0;

	do {
		if (ch == '\0' || ch == '\n') {
			break;
		} else if (ch == '\r') {
			continue;
		}
		dst[i] = ch;
		i++;
	} while (i < (num - 1) && FS_read(&ch, 1, 1, pxFile) != 0);

	dst[i] = '\0';
	return 1;
}

/**
 * \brief close udp socket
 * \param ctx  channel context
 * \return true if udp socket closed
 */
static int CloseUdp(void) {
	if (my_listen_socket == -1)
		return 1;

	if (closesocket(my_listen_socket) == 0) {
		my_listen_socket = -1;
		return 1;
	}
	return 0;
}

/**
 * \brief open udp socket
 * \param ctx udp channel context
 * \return
 *  - 0 if create socket success
 *  - -1 if error occur
 */
static int OpenUdp(void) {
	int ret = 0;

	if (my_listen_socket != -1)
		CloseUdp();

	my_listen_socket = socket(AF_INET, SOCK_DGRAM, 0);

	if (my_listen_socket < 0) {
		return 0;
	}

	return 1;
}

static int OpenTCP(void) {
	int ret = 0;

	ret = socket(AF_INET, SOCK_STREAM, 0);
	if (ret < 0) {
		return 0;
	}

	return ret;
}

int initUdpParams(void) {
	int nMode;
	S_FS_FILE *f = NULL;
	int res = FS_mount("/HOST", &nMode);
	if (FS_OK == res) {
		f = FS_open("/HOST/SOCK_CONFIG.INI", "r");
		if (NULL != f) {
			char buf[64] = { 0 };
			char *pos = NULL;

			res = my_fgets(buf, sizeof(buf), f);
			if (!res)
				goto lblFSerror;
			pos = strchr(buf, ':');
			if (pos != NULL) {
				server.sin_family = AF_INET;
				server.sin_port = htons(atoi(pos+1));
				server.sin_addr.s_addr = INADDR_ANY;
			}

			memset(&buf, 0, sizeof(buf));

			res = my_fgets(buf, sizeof(buf), f);
			if (!res)
				goto lblFSerror;
			pos = strchr(buf, ':');
			if (pos != NULL) {
				client_cash.sin_len = 8;
				client_cash.sin_family = AF_INET;
				client_cash.sin_port = htons(atoi(pos+1));
				*pos = '\0';
				client_cash.sin_addr.s_addr = __inet_addr(buf);
			}

			memset(&buf, 0, sizeof(buf));

			res = my_fgets(buf, sizeof(buf), f);
			if (!res)
				goto lblFSerror;
			pos = strchr(buf, ':');
			if (pos != NULL) {
				client_pos.sin_len = 8;
				client_pos.sin_family = AF_INET;
				client_pos.sin_port = htons(atoi(pos+1));
				*pos = '\0';
				client_pos.sin_addr.s_addr = __inet_addr(buf);
			}

			FS_close(f);
		}
	}
	if (UDP) {
		res = OpenUdp();
		if (res != 1)
			goto lblFSerror;
	} else {
		my_listen_socket = OpenTCP();
	}

	res = openLogFile();

	setMyEthParams(eth_str);

	return 1;
	lblFSerror: FS_unmount("/HOST");
	if (f)
		FS_close(f);
	return 0;
}

void setMyEthParams(char eth_str[32]) {
	S_ETHERNET_CONFIG val;
	char *ip_addr_pnt = NULL;
	struct in_addr addr;
	unsigned short port = 0;
	char buf[10] = { 0 };

	USQ_EthernetConfig(S_ETHERNET_GET_CURRENT, &val);
	addr.s_addr = val.addr;

	ip_addr_pnt = __inet_ntoa(addr);
	if (ip_addr_pnt != NULL)
		strcpy(eth_str, ip_addr_pnt);
	port = ntohs(server.sin_port);
	snprintf(buf, sizeof(buf), ":%u", port);
	strncat(eth_str, buf, sizeof(buf));
}

char *getMyEthParams() {
	return eth_str;
}

static int sendUdpTo(int _socket, const void* buffer, size_t size,
		struct sockaddr_in *_to) {

	size = sendto(_socket, buffer, size, 0, (struct sockaddr *) _to, 8);

	return size;
}

static int recvUdpFrom(int _socket, void* buffer, size_t size,
		struct sockaddr_in *_from, int *_fromlen) {

	size = recvfrom(_socket, buffer, size, 0, (struct sockaddr *) _from,
			_fromlen);

	return size;
}

unsigned short routeTCPSockData(void) {
	char message[512] = { 0 };
	int c = 0;
	int read_size = 0;
	fd_set rfds;
	struct timeval tv;
	int ret = 0;
	int tcp_sock_srv = -1;
	int tcp_sock_cli = -1;

	if (bind(my_listen_socket, (struct sockaddr *) &server, sizeof(server))
			< 0) {
		return 0;
	}

	listen(my_listen_socket, 5);

	tv.tv_sec = 5;
	tv.tv_usec = 0;

	FD_ZERO(&rfds);


	c = sizeof(socaddr_tmp);

	while (1) {
		FD_SET(my_listen_socket, &rfds);
		if ((ret = selectsocket(1, &rfds, NULL, NULL, &tv)) <= 0) {
			continue;
		}

		tcp_sock_srv = accept(my_listen_socket,
				(struct sockaddr *) &client_cash, &c);

		FD_ZERO(&rfds);
		FD_SET(tcp_sock_srv, &rfds);
		FD_SET(my_listen_socket, &rfds);
		//FD_SET(tcp_sock_cli, &rfds);
		while ((ret = selectsocket(2, &rfds, NULL, NULL, &tv)) >= 0) {
			if(ret == 0){
				//FD_SET(tcp_sock_cli, &rfds);
				FD_SET(tcp_sock_srv, &rfds);
				FD_SET(my_listen_socket, &rfds);
				continue;
			}

			read_size = recvUdpFrom(tcp_sock_srv, message, sizeof(message),
					NULL, NULL);
			if (read_size > sizeof(message) || read_size <= 0) {
				closesocket(tcp_sock_srv);
			    closesocket(tcp_sock_cli);
			    tcp_sock_cli = -1;
				tcp_sock_srv = -1;
				break;
			}
			if(tcp_sock_cli == -1){
				tcp_sock_cli = OpenTCP();
				ret = connect(tcp_sock_cli, (struct sockaddr *) &client_pos,
									sizeof(struct sockaddr));
				if (ret == -1) {
					closesocket(tcp_sock_srv);
					closesocket(tcp_sock_cli);
					tcp_sock_cli = -1;
					tcp_sock_srv = -1;
					break;
				}
			}


				sendUdpTo(tcp_sock_srv, message, read_size, &client_cash);

				sendUdpTo(tcp_sock_cli, message, read_size, &client_pos);


			memset(&message, 0, sizeof(message));
			//memset(&socaddr_tmp, 0, sizeof(socaddr_tmp));
		}
	}

	return 1;
}

unsigned short routeUDPSockData(void) {
	char message[512] = { 0 };
	int c = 0;
	int read_size = 0;

	if (bind(my_listen_socket, (struct sockaddr *) &server, sizeof(server))
			< 0) {
		return 0;
	}

	c = sizeof(socaddr_tmp);

	while (1) {

		read_size = recvUdpFrom(my_listen_socket, message, sizeof(message),
				&socaddr_tmp, &c);

		if (read_size > sizeof(message) || read_size <= 0) {
			continue;
		}
		if (isMoreLogSize(read_size * 2)) {
			logSockData(message, read_size, &socaddr_tmp);
		}
		TimerStart(0, 200);
		if (!memcmp(&socaddr_tmp.sin_port, &client_cash.sin_port,
				sizeof(unsigned short))
				&& memcmp(&socaddr_tmp.sin_addr, &client_cash.sin_addr,
						sizeof(unsigned int))) {
			sendUdpTo(my_listen_socket, message, read_size, &client_cash);
		} else if (!memcmp(&socaddr_tmp.sin_port, &client_pos.sin_port,
				sizeof(unsigned short))
				&& memcmp(&socaddr_tmp.sin_addr, &client_pos.sin_addr,
						sizeof(unsigned int))) {
			sendUdpTo(my_listen_socket, message, read_size, &client_pos);
		} else {
			// Unknown message received
		}

		memset(&message, 0, sizeof(message));
		memset(&socaddr_tmp, 0, sizeof(socaddr_tmp));
	}

	return 1;
}

int openLogFile(void) {
	file = FS_open("/HOST/SOCK_LOG.TXT", "a");
	if (!file) {
		return 0;
	}
	return 1;
}

int isMoreLogSize(int size) {

	static int more_size = 1;
	long ret = 0;

	if (!more_size) {
		return 0;
	}

	ret = FS_dskfree("/HOST");

	if (ret == FS_ERROR) {
		return 0;
	} else if (ret <= size) {
		more_size = 0;
		FS_close(file);
		file = NULL;
	}

	return more_size;
}

int logSockData(char* data, int Size, struct sockaddr_in *from) {
	char a, c;
	char line[17] = { 0 };
	char raw[12] = { 0 };
	char buf[128] = { 0 };
	int j, i;
	unsigned short port = 0;
	char ip_addr[16] = { 0 };
	char *ip_addr_pnt = NULL;

	if (data == NULL || from == NULL || file == NULL) {
		return 0;
	}

	ip_addr_pnt = __inet_ntoa(from->sin_addr);
	if (ip_addr_pnt != NULL)
		strcpy(ip_addr, ip_addr_pnt);
	port = ntohs(from->sin_port);

	snprintf(buf, sizeof(buf), "--------Received from ip %s:%u--------\n\r",
			ip_addr, port);
	FS_write(buf, sizeof(char), strlen(buf), file);

	for (i = 0; i < Size; i++) {
		c = data[i];
		snprintf(raw, sizeof(raw), "%.2x \0", (unsigned char) c);
		FS_write(raw, sizeof(char), strlen(raw), file);
		//memset(raw, 0, sizeof(raw));
		a = (c >= 32 && c <= 128) ? (unsigned char) c : '.';
		line[i % 16] = a;

		if ((i != 0 && (i + 1) % 16 == 0) || i == Size - 1) {
			line[i % 16 + 1] = '\0';
			snprintf(raw, sizeof(raw), "          \0");
			FS_write(raw, sizeof(char), strlen(raw), file);
			//memset(raw, 0, sizeof(raw));
			for (j = strlen(line); j < 16; j++) {
				snprintf(raw, sizeof(raw), "   \0");
				FS_write(raw, sizeof(char), strlen(raw), file);
				//memset(raw, 0, sizeof(raw));
			}

			FS_write(line, sizeof(char), strlen(line), file);
			snprintf(raw, sizeof(raw), " \n\r\0");
			FS_write(raw, sizeof(char), strlen(raw), file);
			//memset(raw, 0, sizeof(raw));
		}
	}
	snprintf(raw, sizeof(raw), "\n\r\0");
	FS_write(raw, sizeof(char), strlen(raw), file);
	//memset(raw, 0, sizeof(raw));

	return 1;
}

unsigned short handleRouteMsg(void) {

	while (1) {
		if (TimerGet(0) <= 0)
			continue;

		while (TimerGet(0) > 0) {
			sockTransmitMsgDisplay();
			TimerStart(1, 200);
			while (TimerGet(1) > 0) {
				/*NOP*/;
			}

		}

		idle_message(0, NULL, NULL);
	}

}

static void sockTransmitMsgDisplay() {
	FILE *hDisplay;
	int nFont;
	char *font;
	int x, y;
	int scrwidth, scrheight;
	unsigned char pname[] = "ingenico.ru";
	char fontfilename[] = "/SYSTEM/ARCOMF.SGN";
	char msg[] = "<<DATA TRANSMIT<<";

	hDisplay = fopen("DISPLAY", "w");

	nFont = GetDefaultFont();
	font = LoadFont(fontfilename);
	if (font != NULL)
		DefCurrentFont(font);

	_clrscr();

	GetScreenSize(&scrheight, &scrwidth);

	x =
			(scrwidth
					- SizeOfISO8859String(pname, (char *) _dLARGE_,
							_FIXED_WIDTH_)) / 2;
	y = 20;
	_DrawExtendedString8859(x, y, pname, _OFF_, (char *) _dLARGE_,
			_FIXED_WIDTH_);
	x = (scrwidth
			- SizeOfISO8859String((unsigned char *) msg, (char *) _dMEDIUM_,
					_FIXED_WIDTH_)) / 2;
	y += GetExtendedPoliceSize((char *) _dLARGE_);
	_DrawExtendedString8859(x, y, (unsigned char *) msg, _OFF_,
			(char *) _dMEDIUM_, _FIXED_WIDTH_);

	PaintGraphics();
	// restore default font
	SetDefaultFont(nFont);
	//if( font != NULL ) UnloadFont(font);
	fclose(hDisplay); ///< Close display driver

}