eth_utils.c | searchcode

/drivers/net/wireless/tiwlan1251/CUDK/CLI/eth_utils.c

https://bitbucket.org/cyanogenmod/cm-kernel
C | 552 lines | 256 code | 122 blank | 174 comment | 36 complexity | 0fdd909f0fbc1b262733ebc74ee9e884 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0

/*******************************************************************************
**+--------------------------------------------------------------------------+**
**|                                                                          |**
**| Copyright 1998-2008 Texas Instruments, Inc. - http://www.ti.com/         |**
**|                                                                          |**
**| Licensed under the Apache License, Version 2.0 (the "License");          |**
**| you may not use this file except in compliance with the License.         |**
**| You may obtain a copy of the License at                                  |**
**|                                                                          |**
**|     http://www.apache.org/licenses/LICENSE-2.0                           |**
**|                                                                          |**
**| Unless required by applicable law or agreed to in writing, software      |**
**| distributed under the License is distributed on an "AS IS" BASIS,        |**
**| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |**
**| See the License for the specific language governing permissions and      |**
**| limitations under the License.                                           |**
**|                                                                          |**
**+--------------------------------------------------------------------------+**
*******************************************************************************/

/****************************************************************************************************/
/*                                                                                                  */
/*      MODULE:     eth_utils.c                                                                     */
/*      PURPOSE:    Ethernet communication utilities                                                */
/*                                                                                                  */
/****************************************************************************************************/

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <unistd.h>
#include <arpa/inet.h>

#include "ipc.h"
#include "ticon.h"							  
#include "errno.h"
#include "signal.h"
#include "eth_utils.h"

extern char* inet_ntoa(struct  in_addr);
	/************/
	/* Defines */
	/**********/

#define LOOGER_ETHERNET_PORT	(700)
#define WIPP_ETHERNET_PORT		(701)
#define G_TESTER_ETHERNET_PORT	(702)

#define READ_STATE_GET_HEADER		(0x00)
#define READ_STATE_GET_LENGTH1		(0x01)
#define READ_STATE_GET_LENGTH2		(0x02)
#define READ_STATE_GET_PAYLOAD		(0x03)

#define PACKET_PREFIX			(0xFF)

#define IN_BUFFER_SIZE			(1024)
#define OUT_BUFFER_SIZE			(512)

	/*********************/
	/* Global variables */
	/*******************/

unsigned char ethernet_utils_welcome_message[] = {'W', 2, 0, 2, ETH_UTILS_PROTOCOL_VERSION};

char ethernet_utils_module_names[ETHERNET_UTILS_NUMBER_OF_MODULES][20] =
{
	"terminal",
	"logger",
	"wipp control",
	"g tester"
};

	/********************************/
	/* static functions prototypes */
	/******************************/

int ethernet_utils_init_module(int module_index, u_short port_number, int *module_pipe, unsigned char mux_uart_id);
void ethernet_utils_signal_handler(int signal);
int ethernet_utils_process_in_command(int module_index, unsigned char *read_state, unsigned short *packet_size, unsigned char *in_buffer, unsigned int *in_buffer_offset);
int ethernet_utils_write_socket(int module_index, int length, unsigned char *buffer);
void ethernet_utils_disconnect_socket(int module_index);

	/**************/
	/* Functions */
	/************/

/************************************************************************
 *                        ethernet_utils_init                           *
 ************************************************************************
DESCRIPTION: Initialize the ethernet communication

CONTEXT	   : main process only!
************************************************************************/
void ethernet_utils_init()
{
	ethernet_logger_process_pid = ethernet_utils_init_module(ETHERNET_UTILS_LOGGER_MODULE_ID, LOOGER_ETHERNET_PORT, ethernet_logger_pipe, LOGGER_MUX_UART_ID);
	ethernet_wipp_process_pid = ethernet_utils_init_module(ETHERNET_UTILS_WIPP_MODULE_ID, WIPP_ETHERNET_PORT, ethernet_wipp_control_pipe, WIPP_CONTROL_MUX_UART_ID);
	ethernet_g_tester_process_pid = ethernet_utils_init_module(ETHERNET_UTILS_G_TESTER_MODULE_ID, G_TESTER_ETHERNET_PORT, ethernet_g_tester_pipe, G_TESTER_MUX_UART_ID);
}
		  
/************************************************************************
 *                        ethernet_utils_deinit                         *
 ************************************************************************
DESCRIPTION: Deinitialize the ethernet communication

CONTEXT	   : main process only!
************************************************************************/
void ethernet_utils_deinit()
{
	/* Kill the logger process */
	if (ethernet_logger_process_pid > 0)
	{
		kill(ethernet_logger_process_pid, SIGKILL);
	}

	/* Kill the wipp control process */
	if (ethernet_wipp_process_pid > 0)
	{
		kill(ethernet_wipp_process_pid, SIGKILL);
	}

	/* Kill the wipp control process */
	if (ethernet_g_tester_process_pid > 0)
	{
		kill(ethernet_g_tester_process_pid, SIGKILL);
	}
}

/************************************************************************
 *                        ethernet_utils_signal_handler                 *
 ************************************************************************
DESCRIPTION: Signal handler - receive the USER

CONTEXT	   : Signal owner 
************************************************************************/
void ethernet_utils_signal_handler(int signal) 
{ 
}

/************************************************************************
 *                        ethernet_utils_init_module                    *
 ************************************************************************
DESCRIPTION: Initialize ethernet communication

RETURNS:   : Process ID of the new process or -1 if error.

CONTEXT	   : main process only!
************************************************************************/
int ethernet_utils_init_module(int module_index, u_short port_number, int *module_pipe, unsigned char mux_uart_id)
{
	int child_process_id;

	/***************************************/
	/* Create a pipe to control the child */
	/*************************************/

	if (pipe(module_pipe) < 0)
	{
		console_printf_terminal("eth_utils, error creating pipe\n");

		return -1;
	}

	/* Set the shared memory variables */
	SHARED_MEMORY_IPC_PIPE(module_index) = module_pipe[1];
	SHARED_MEMORY_MUX_UART_ID(module_index) = mux_uart_id;

	/* Create a child process */
	child_process_id = fork();

	if (0 == child_process_id)
	{
		/******************/
		/* Child process */
		/****************/

		int result;
		int socket_id;
		int optval = 1;
		int socket_alive;
		int max_fd_index;
		socklen_t client_addr_len;
		fd_set read_set;
		unsigned char out_buffer[OUT_BUFFER_SIZE];
		unsigned char in_buffer[IN_BUFFER_SIZE];
		unsigned char read_state;
		unsigned short packet_size;
		unsigned int in_buffer_offset;
		struct sockaddr_in server_addr;
		struct sockaddr_in client_addr;

		console_printf_terminal("eth_utils, Hello from %s child module (pid = %d).\n", ethernet_utils_module_names[module_index], getpid());

		/* Close the write direction of the pipe  - because i only read information from this pipe. */ 
		close(module_pipe[1]); 

		SHARED_MEMORY_OUTPUT_PATH(module_index) = OUTPUT_PATH_SIMPLE_UART;

		/* Set the signal handler for the 'SIGUSR1' signal */
		signal(SIGUSR1, ethernet_utils_signal_handler); 

		while (TRUE)
		{
			/******************/
			/* Open a socket */
			/****************/

			socket_id = socket(PF_INET, SOCK_STREAM, 0);

			if (!socket_id)
			{
				/* Error opening socket */
				
				console_printf_terminal("eth_utils, error opening %s socket. (errno = %d)\n", ethernet_utils_module_names[module_index], errno);

				_exit(1);
			}

			/*************************/
			/* Configure the socket */
			/***********************/

			if (setsockopt(socket_id, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) == -1)
			{
				/* Error setting socket option */
				
				console_printf_terminal("eth_utils, error setting %s socket option.  (errno = %d)\n", ethernet_utils_module_names[module_index], errno);

				_exit(1);
			}

			/********************/
			/* Bind the socket */
			/******************/

			server_addr.sin_family = AF_INET;
			server_addr.sin_addr.s_addr = htonl (INADDR_ANY);
			server_addr.sin_port = htons(port_number);

			result = bind(socket_id, (struct sockaddr *)&server_addr, sizeof(server_addr));

			if (result != 0)
			{
				/* Error binding socket */
				
				console_printf_terminal("eth_utils, error binding %s socket. (errno = %d)\n", ethernet_utils_module_names[module_index], errno);

				_exit(1);
			}

			/****************************/
			/* Listening to the socket */
			/**************************/

			result = listen(socket_id, 5);

			if (-1 == result)
			{
				/* Error listening to socket */
				
				console_printf_terminal("eth_utils, error listening to %s socket. (errno = %d)\n", ethernet_utils_module_names[module_index], errno);

				_exit(1);
			}

			/**********************/
			/* Accept connection */
			/********************/

			client_addr_len = sizeof(client_addr);

			/* We suppose to get new socket id after accept (blocking action) */
			result = accept(socket_id, (struct sockaddr *)&client_addr, &client_addr_len);

			if (-1 == result)
			{			
				/* Error accepting connection */
				
				console_printf_terminal("eth_utils, error accepting %s connection. (errno = %d)\n", ethernet_utils_module_names[module_index], errno);

				_exit(1);
			}

			close(socket_id);

			socket_id = result;

			read_state = READ_STATE_GET_HEADER;

			SHARED_MEMORY_ETHERNET_SOCKET_ID(module_index) = socket_id;

			console_printf_terminal("\n***********************************************\n");
			console_printf_terminal("* eth_utils, %s connection accepted. \n", ethernet_utils_module_names[module_index]);
			console_printf_terminal("*\n* Remote IP: %s\n***********************************************\n", inet_ntoa(client_addr.sin_addr));

			/* Switch to ethernet output */
			SHARED_MEMORY_OUTPUT_PATH(module_index) = OUTPUT_PATH_ETHERNET;

			/*********************************/
			/* Send Hello message to client */
			/*******************************/

			ethernet_utils_write_socket(module_index, sizeof(ethernet_utils_welcome_message), ethernet_utils_welcome_message);

			/**********************/
			/* Manage connection */
			/********************/

			socket_alive = TRUE;

			while (socket_alive)
			{
				/***********************************************************************************/   
				/* Wait for one of two external events: 									      */
				/* -----------------------------------											 */
				/*																			    */
				/* 1. Data received from TCP client and should be transfered to parent process */
				/* 2. Data received from parent process and should be transfered to client 	  */
				/*****************************************************************************/   

				/* Prepare the read set fields */
				FD_ZERO(&read_set);
				FD_SET(socket_id, &read_set);
				FD_SET(module_pipe[0], &read_set);

				/* Determine the maximum index of the file descriptor */
				max_fd_index = (max(socket_id, module_pipe[0]) + 1);

				/* Wait for event - blocking */
				result = select(max_fd_index, &read_set, NULL, NULL, NULL);

				/************************/
				/* Check event results */
				/**********************/

				if (result > 0)
				{
					if (FD_ISSET(socket_id, &read_set))
					{
						/******************************/
						/* Data received from client */
						/****************************/
						
						/* Process the input command */
						if (ethernet_utils_process_in_command(module_index, &read_state, &packet_size, in_buffer, &in_buffer_offset) <= 0) 
						{
							socket_alive = FALSE;
						}
					}

					if (FD_ISSET(module_pipe[0], &read_set))
                    {
						/**************************************/
						/* Data received from parent process */
						/************************************/

						result = read(module_pipe[0], out_buffer, sizeof(out_buffer));
                        if( result < 0 )
                        {
                            console_printf_terminal("eth_utils, read error (err=%d)\n", result);
                            socket_alive = FALSE;
                        }
				
						if (ethernet_utils_write_socket(module_index, result, out_buffer) == -1)
						{
							socket_alive = FALSE;
						}
					}
				}
				else
				{
					console_printf_terminal("eth_utils, 'select' command error\n");

					socket_alive = FALSE;
				}
			}

			/* Disconnect the socket */
			ethernet_utils_disconnect_socket(module_index);
		}
	}

	/* Close the read direction of the pipe  - because i only write information from this pipe. (to child process) */ 
	close(module_pipe[0]); 

	/* return the process id, I will use it later when i want to kill this process */
	return child_process_id;
}

/************************************************************************
 *                        ethernet_utils_process_in_command             *
 ************************************************************************
DESCRIPTION: Handle In commands

CONTEXT	   : Only the same process that is reading from the socket
************************************************************************/
int ethernet_utils_process_in_command(int module_index, unsigned char *read_state, unsigned short *packet_size, unsigned char *in_buffer, unsigned int *in_buffer_offset)
{	
	unsigned char prefix;
	int socket_id = SHARED_MEMORY_ETHERNET_SOCKET_ID(module_index);
    int result = 1; 

	/*console_printf_terminal("ethernet_utils_process_in_command (socket = %d)\n", socket_id); */

	/* Continue while there is data in the RX buffer */
	switch (*read_state)
	{
	case READ_STATE_GET_HEADER:

		/* Read the packet prefix - one byte */
		result = read(socket_id, &prefix, sizeof(prefix));
		/*console_printf_terminal("ethernet_utils_process_in_command (State = READ_STATE_GET_HEADER, length = %d)\n", result); */

		if (result > 0)
		{
			if (prefix == PACKET_PREFIX)
			{
				*read_state = READ_STATE_GET_LENGTH1;
			}
			else
			{
				console_printf_terminal("ethernet_utils_process_in_command, Error: protocol sync error! \n"); 

				result = -1;
			}
		}

		break;

	case READ_STATE_GET_LENGTH1:

		/* Read the packet size first byte */
		result = read(socket_id, (void *)((unsigned char *)(packet_size) + 0), sizeof(unsigned char));
		/*console_printf_terminal("ethernet_utils_process_in_command (State = READ_STATE_GET_LENGTH1, length = %d)\n", result); */
		
		if (result > 0)
		{
			*read_state = READ_STATE_GET_LENGTH2;
		}

		break;

	case READ_STATE_GET_LENGTH2:

		/* Read the packet size second byte */
		result = read(socket_id, (void *)((unsigned char *)(packet_size) + 1), sizeof(unsigned char));
		/*console_printf_terminal("ethernet_utils_process_in_command (State = READ_STATE_GET_LENGTH2, length = %d, packet_size = %d)\n", result, *packet_size); */
		
		if (result > 0)
		{
			/* Sanity check on the length */

			*in_buffer_offset = 0;

			*read_state = READ_STATE_GET_PAYLOAD;
		}

		break;


	case READ_STATE_GET_PAYLOAD:

		/* Read the packet size second byte */
		result = read(socket_id, (in_buffer + 3 + *in_buffer_offset), (*packet_size - *in_buffer_offset));
		/*console_printf_terminal("ethernet_utils_process_in_command (State = READ_STATE_GET_PAYLOAD, offset = %d, length = %d)\n", *in_buffer_offset, result); */
		
		if (result > 0)
		{
			*in_buffer_offset += result;

			if (*packet_size == *in_buffer_offset)
			{
				/* All the packet has arrived */

				*read_state = READ_STATE_GET_HEADER;

				/* Send it to the main process */

				ipc_send_command_to_main_process(module_index, in_buffer, (*packet_size + 3));
			}
		}

		break;
	}

	return result;
}

/************************************************************************
 *                        ethernet_utils_write_socket     			    *
 ************************************************************************
DESCRIPTION: write data to socket

CONTEXT    : Only the same process that is writing to the socket
************************************************************************/
int ethernet_utils_write_socket(int module_index, int length, unsigned char *buffer)
{
	int result;

/*	console_printf_terminal("eth_utils, ethernet_utils_wipp_write() (length = %d).\n", length); */

	/* Write to the socket */
	result = write(SHARED_MEMORY_ETHERNET_SOCKET_ID(module_index), buffer, length);

/*	console_printf_terminal("eth_utils, ethernet_utils_wipp_write() (result = %d).\n", result); */

	if (result != length)
	{
		/**************************/
		/* Error writing to port */
		/************************/
		
		console_printf_terminal("eth_utils, Error writing to %s socket (result = %d, errno = %d, error = %s)\n", ethernet_utils_module_names[module_index], result, errno, strerror(errno));

		result = -1;
	}

	return result;
}

/************************************************************************
 *                        ethernet_utils_disconnect_socket 			    *
 ************************************************************************
DESCRIPTION: Disconnect a socket

CONTEXT    : Only the process that is disconnecting
************************************************************************/
void ethernet_utils_disconnect_socket(int module_index)
{
	char temp_buf[6] = {'x','x','x', '5', '0', 0};

	/* Switch to UART output */
	SHARED_MEMORY_SWITCH_TO_UART_OUTPUT(module_index);

	console_printf_terminal("eth_utils, disconnecting from %s socket.\n", ethernet_utils_module_names[module_index]);

	switch (module_index)
	{  
	case ETHERNET_UTILS_LOGGER_MODULE_ID:
		/* Set debug path back to UART */
		ipc_send_command_to_main_process(ETHERNET_UTILS_LOGGER_MODULE_ID, (unsigned char*)temp_buf, 5);
		break;

	case ETHERNET_UTILS_WIPP_MODULE_ID:
		temp_buf[3] = WIPP_CONTROL_FROM_GENERAL_PROCESS_DEACTIVATE_IPERF;
		ipc_send_command_to_main_process(GENERAL_PROCESS_MODULE_ID,(unsigned char*) temp_buf, 5);
		break;
	}

	/* Close the socket */
	close(SHARED_MEMORY_ETHERNET_SOCKET_ID(module_index));
}