rc_ctl_table.c

epoll机制的收发程序 只能在2.6内核上使用

/*
 * 文 件 名：rc_ctl_table.c
 * 功    能：链表相关的函数
 * 作    者：马云龙
 * E_mail : [e-mail]
 * 开始时间：2007-4-24 9:37
 * 结束时间：2007-4-27 13:12
 * 修改时间：
 */
#include	<stdio.h>
#include	<stdlib.h>
#include	<unistd.h>
#include	<string.h>
#include	<fcntl.h>
#include	<dirent.h>
#include	<errno.h>
#include	<sys/socket.h>
#include	<netinet/in.h>
#include	<arpa/inet.h>     
#include	<sys/time.h>
#include	<time.h>
#include	<signal.h>
#include	<pthread.h>

#include	"rc_pub_define.h"
#include	"rc_pub_type.h"
#include	"rc_pub_packet.h"
#include	"rc_pub_net.h"
#include	"rc_pub_path.h"
#include	"rc_pub_file.h"
#include	"rc_pub_fifo.h"
#include	"rc_pub_log.h"
#include	"rc_pub_time.h"

#include	"rc_ctl_define.h"
#include	"rc_ctl_data.h"
#include	"rc_ctl_mysql.h"
#include	"rc_ctl_net.h"


/*
 * 功  能：创建一个新的发送任务数据
 * 参  数：ctlinfo：链接相关信息
 *         type：链接类型，摄像机或者控件
 *         fifo：从管道中读出的内容
 *         buf：要发送的内容
 *         len：要发送的内容的长度
 * 返回值：成功返回发送任务的指针，否则返回一个空指针
 * 说  明：buf必需是一个用malloc已经分配好的内存区
 */
struct_task_net_w *rc_create_task_new_w(struct_msg_con *ctlinfo, unsigned char type, struct_buf_fifo *fifo, char *buf, int len)
{
	int						len_struct;
	struct_task_net_w		*newsnd;
	
	newsnd = NULL;
	
	len_struct = sizeof(struct_task_net_w);
	newsnd = malloc(len_struct);
	if(newsnd == NULL)
		return NULL;
	bzero(newsnd, len_struct);
	
	len_struct = sizeof(struct_data_net_s);
	newsnd->buf = malloc(len_struct);
	if(newsnd->buf == NULL)
	{
		free(newsnd);
		newsnd = NULL;
		return NULL;
	}
	bzero(newsnd->buf, len_struct);
	
	newsnd->sockfd = ctlinfo->sockfd;
#ifdef		DETAILED_INFO_SEND_TASK
	newsnd->type = type;
	strcpy(newsnd->serial, ctlinfo->serial);
#endif
	pthread_mutex_init(&(newsnd->mutex_opt), NULL);
	newsnd->packets = 0;
	newsnd->next = NULL;
	
	newsnd->buf->msg_fifo = fifo;
	newsnd->buf->next = NULL;
	
	newsnd->buf->data.buf = buf;
	newsnd->buf->data.size = len;
	newsnd->buf->data.len = 0;
	
	return newsnd;
}

/*
 * 功  能：向发送队列中添加要发送的数据
 * 参  数：head：要发送的数据队列的头指针
 *         newtask：新的数据的指针
 * 返回值：成功返回0，否则返回-1
 * 说  明：是将newdata的地址添加到任务队列尾，不对task做任何操作，
 *         newdata必须是一个临时分配好的内存区
 */
int rc_add_data_snd(struct_data_net_s **head, struct_data_net_s *newdata)
{
	struct_data_net_s	*tmp;
	
	if(newdata != NULL)
		newdata->next = NULL;
	else
		return 0;
	
	if((*head) == NULL)
	{
		*head = newdata;
	}
	else
	{
		tmp = *head;
		while(1)
		{
			if(tmp->next == NULL)
			{
				tmp->next = newdata;
				break;
			}
			tmp = tmp->next;
		}
	}
	
	return 0;
}

/*
 * 功  能：删除要发送的数据的队列
 * 参  数：head：数据队列的头指针
 * 返回值：直接返回0
 */
int rc_del_data_snd_all(struct_data_net_s **head)
{
	struct_data_net_s	*tmp_1;
	struct_data_net_s	*tmp_2;
	
	tmp_1 = *head;
	if(tmp_1 == NULL)
	{
		return 0;
	}
	
	while(1)
	{
		tmp_2 = tmp_1->next;
		if(tmp_1->msg_fifo != NULL)
		{
			free(tmp_1->msg_fifo);
			tmp_1->msg_fifo = NULL;
		}
		if(tmp_1->data.buf != NULL)
		{
			free(tmp_1->data.buf);
			tmp_1->data.buf = NULL;
		}
		free(tmp_1);
		tmp_1 = tmp_2;
		if(tmp_1 == NULL)
		{
			break;
		}
	}
	
	return 0;
}

/*
 * 功  能：向读任务的队列中添加新的任务
 * 参  数：head：任务队列的头指针
 *         newtask：新的任务的指针
 * 返回值：成功返回0，否则返回-1
 * 说  明：是将newtask的地址添加到任务队列尾，不对task做任何操作，
 *         newtask必须是一个临时分配的内存区
 */
int rc_add_task_r(struct_task_net_r **head, struct_task_net_r *newtask)
{
	struct_task_net_r	*tmp;
	
	if(newtask != NULL)
		newtask->next = NULL;
	else
		return 0;
	
	if((*head) == NULL)
	{
		*head = newtask;
	}
	else
	{
		tmp = *head;
		while(1)
		{
			if(tmp->next == NULL)
			{
				tmp->next = newtask;
				break;
			}
			tmp = tmp->next;
		}
	}
	
	return 0;
}

/*
 * 功  能：删除读任务的队列
 * 参  数：head：任务队列的头指针
 * 返回值：直接返回0
 */
int rc_del_task_r_all(struct_task_net_r **head)
{
	struct_task_net_r	*tmp_1;
	struct_task_net_r	*tmp_2;
	
	tmp_1 = *head;
	if(tmp_1 == NULL)
	{
		return 0;
	}
	
	while(1)
	{
		tmp_2 = tmp_1->next;
		free(tmp_1);
		tmp_1 = tmp_2;
		if(tmp_1 == NULL)
		{
			break;
		}
	}
	
	return 0;
}

/*
 * 功  能：向写任务的队列中添加新的任务
 * 参  数：head：任务队列的头指针
 *         newtask：新的任务的指针
 * 返回值：成功返回0，否则返回-1
 * 说  明：是将newtask的地址添加到任务队列尾，不对task做任何操作，
 *         newtask必须是一个临时分配的内存区
 *         如果这个sock上要发送的数据包超过了最大限制，也返回-1
 *         只要是返回值为-1的都会释放掉newtask所占用的空间
 */
int rc_add_task_w(struct_task_net_w **head, struct_task_net_w *newtask)
{
	int					ret;
	struct_task_net_w	*tmp;
	
	if(newtask != NULL)
	{
		if(newtask->buf != NULL)
		{
			if(newtask->buf->data.buf != NULL)
			{
				if(newtask->buf->data.size > 0)
					goto CHECK_OK;
				if(newtask->buf->data.buf != NULL)
				{
					free(newtask->buf->data.buf);
					newtask->buf->data.buf = NULL;
				}
				if(newtask->buf->msg_fifo != NULL)
				{
					free(newtask->buf->msg_fifo);
					newtask->buf->msg_fifo = NULL;
				}
			}
			free(newtask->buf);
			newtask->buf = NULL;
		}
		free(newtask);
		newtask = NULL;
		return -1;
	}
	else
	{
		return 0;
	}
	
CHECK_OK:
	pthread_mutex_init(&(newtask->mutex_opt), NULL);
	newtask->next = NULL;
	ret = -1;
	if((*head) == NULL)
	{
		*head = newtask;
		(*head)->packets++;
		ret = 0;
	}
	else
	{
		tmp = *head;
		while(1)
		{
			if(tmp->next == NULL)
			{
				newtask->packets++;
				newtask->next = NULL;
				tmp->next = newtask;
				ret = 0;
				break;
			}
			if(tmp->sockfd == newtask->sockfd)
			{
				pthread_mutex_lock(&(tmp->mutex_opt));
				if(tmp->packets < MAX_PACKETS_SND)
				{
					tmp->packets++;
					rc_add_data_snd(&(tmp->buf), newtask->buf);
					free(newtask);
					newtask = NULL;
					ret = 0;
				}
				else
				{
					if(newtask->buf->data.buf != NULL)
					{
						free(newtask->buf->data.buf);
						newtask->buf->data.buf = NULL;
					}
					if(newtask->buf->msg_fifo != NULL)
					{
						free(newtask->buf->msg_fifo);
						newtask->buf->msg_fifo = NULL;
					}
					free(newtask->buf);
					newtask->buf = NULL;
					free(newtask);
					newtask = NULL;
					ret = -1;
				}
				pthread_mutex_unlock(&(tmp->mutex_opt));
				break;
			}
			tmp = tmp->next;
		}
	}
	
	return ret;
}

/*
 * 功  能：删除写任务的队列
 * 参  数：head：任务队列的头指针
 * 返回值：直接返回0
 */
int rc_del_task_w_all(struct_task_net_w **head)
{
	struct_task_net_w	*tmp_1;
	struct_task_net_w	*tmp_2;
	
	tmp_1 = *head;
	if(tmp_1 == NULL)
	{
		return 0;
	}
	
	while(1)
	{
		tmp_2 = tmp_1->next;
		pthread_mutex_lock(&(tmp_1->mutex_opt));//先加锁，防止其它线程正在使用
		rc_del_data_snd_all(&(tmp_1->buf));//先删除要发送的数据
		free(tmp_1);
		tmp_1 = tmp_2;
		if(tmp_1 == NULL)
		{
			break;
		}
	}
	
	return 0;
}

/*
 * 功  能：根据sockfd从写任务的队列中删除一个写任务
 * 参  数：head：任务队列的头指针
 *         sockfd：要删除的文件描述符
 * 返回值：直接返回0
 */
int rc_del_task_w_one(struct_task_net_w **head, int sockfd)
{
	struct_task_net_w	*tmp;
	struct_task_net_w	*tmp_1;
	
	tmp = *head;
	if(tmp == NULL)
	{
		return 0;
	}
	
	if(tmp->sockfd == sockfd)
	{
		*head = tmp->next;
		pthread_mutex_lock(&(tmp->mutex_opt));//先加锁，防止其它线程正在使用
		rc_del_data_snd_all(&(tmp->buf));//先删除要发送的数据
		free(tmp);
		tmp = NULL;
		return 0;
	}
	tmp_1 = *head;
	tmp = tmp_1->next;
	while(1)
	{
		if(tmp == NULL)
			break;
		if(tmp->sockfd == sockfd)
		{
			tmp_1->next = tmp->next;
			pthread_mutex_lock(&(tmp->mutex_opt));//先加锁，防止其它线程正在使用
			rc_del_data_snd_all(&(tmp->buf));//先删除要发送的数据
			free(tmp);
			tmp = NULL;
			return 0;
		}
		tmp_1 = tmp;
		tmp = tmp->next;
	}
	
	return 0;
}

/*
 * 功  能：向链接链表中添加一个新的链接
 * 参  数：head：链表队列的头指针
 *         newcon：新的链接的指针
 * 返回值：成功返回0，否则返回-1
 * 说  明：是将newcon的地址添加到任务队列尾，不对task做任何操作，
 *         newcon必须是一个临时分配好的内存区
 */
int rc_add_connection(struct_msg_con **head, struct_msg_con *newcon)
{
	struct_msg_con	*tmp;
	
	if(newcon != NULL)
		newcon->next = NULL;
	else
		return 0;
	
	if((*head) == NULL)
	{
		*head = newcon;
	}
	else
	{
		tmp = *head;
		while(1)
		{
			if(tmp->next == NULL)
			{
				newcon->next = NULL;
				tmp->next = newcon;
				break;
			}
			tmp = tmp->next;
		}
	}
	
	return 0;
}


/*
 * 功  能：从链接链表中删除一个链接
 * 参  数：head：链表队列的头指针
 *         sockfd：要删除的链接的sockfd值
 * 返回值：成功返回1，找不到相匹配的链接返回0，失败返回-1
 * 说  明：删除的时候已经将sockfd关闭
 */
int rc_del_connection_one(struct_msg_con **head, int sockfd)
{
	int					ret;
	struct_msg_con		*tmp;
	struct_msg_con		*tmp_l;
	
	ret = 0;
	if(*head == NULL)
	{
		goto LAB_RETURN;
	}
	
	tmp = *head;
	if(tmp->sockfd == sockfd)
	{
		pthread_mutex_lock(&(tmp->mutex_opt));
		if(tmp->rcv.buf != NULL)
		{
			free(tmp->rcv.buf);
			tmp->rcv.buf = NULL;
		}
		*head = tmp->next;
		free(tmp);
		ret = 1;
		close(sockfd);
		goto LAB_RETURN;
	}
	else
	{
		while(1)
		{
			tmp_l = tmp;
			tmp = tmp->next;
			if(tmp == NULL)
			{
				break;
			}
			if(tmp->sockfd == sockfd)
			{
				pthread_mutex_lock(&(tmp->mutex_opt));
				tmp_l->next = tmp->next;
				if(tmp->rcv.buf != NULL)
				{
					free(tmp->rcv.buf);
					tmp->rcv.buf = NULL;
				}
				free(tmp);
				ret = 1;
				close(sockfd);
				goto LAB_RETURN;
			}
		}
	}