libsocketclient.c

这是封装的socket库

#include "tcpsocketclient.h"
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/un.h>
#include <unistd.h>
#include <pthread.h>
#include <poll.h>
#include <fcntl.h>
#include <errno.h>
void * client_thread(void *arg)
{
	int ret,delay = 1000;
	client_ctx_t *tmp,*tmp_next;
	struct pollfd poll_fd,*poll_entry;
	client_ctx_t *client_ctx = (client_ctx_t*)arg;
//	fprintf(stderr,"client_fd:%d.\n",ser_ctx->client_fd);
	fprintf(stderr,"client thread start......................\n");
	while(1)
	{
		poll_entry = &poll_fd;
		client_ctx->poll_entry = poll_entry;
		poll_entry->fd = client_ctx->client_fd;
		poll_entry->events = POLLIN;
		poll_entry++;

		do{
			ret = poll(poll_entry, 1, delay);
			if((ret < 0)&& (errno == EINTR) && (errno == EAGAIN))
			{
				return ;
			}
		}while(ret < 0);
		ret = handle_connection(client_ctx);
		if(ret < 0)
		{
			close_connection(client_ctx);
		}

	}
}

static int handle_connection(client_ctx_t *client_ctx)
{
	int len,ret;
	unsigned int timeout;

	if(client_ctx == NULL)
	{
	fprintf(stderr,"line:%d\n",__LINE__);
		return -1;
	}
	timeout = get_cur_time();
//	fprintf(stderr,"client_timeout:%d\n",CLIENT_TIME_OUT);
//	fprintf(stderr,"timeout:%d tmp->timeout:%d tmp->client_fd:%d\n",timeout,tmp->timeout,tmp->client_fd);
//	fprintf(stderr,"timeout-tmp->timeout:%d client_timeout:%d\n",timeout-(tmp->timeout),CLIENT_TIME_OUT);
	if((timeout - (client_ctx->timeout)) > CLIENT_TIME_OUT)
	{
		fprintf(stderr,"fd timeout.\n");
		if(client_ctx->interface.disconnect_callback!=NULL)	
		{
			client_ctx->interface.disconnect_callback(client_ctx->disconnect_param,client_ctx->client_fd);
		}
		return -1;
	}
	if((client_ctx->poll_entry->revents)& (POLLERR | POLLHUP))
	{
		perror("poll");
		return -1;
	}
	if((client_ctx->poll_entry->revents) & POLLIN)
	{
		client_ctx->timeout = timeout;
		len = recv(client_ctx->client_fd,client_ctx->buf,8192,0);
		if(len < 0 )
		{
			if((errno != EAGAIN) && (errno != EINTR))
//			perror("");
//	fprintf(stderr,"line:%d errnor:%d\n",__LINE__,errno);
			return -1;
		}
		else if(len == 0)
		{
	fprintf(stderr,"line:%d\n",__LINE__);
			return -1;
		}
		else
		{
			if(client_ctx->interface.recv_callback!=NULL)
			{
				client_ctx->interface.recv_callback(client_ctx->param,client_ctx->client_fd, client_ctx->buf,len, 0);
			}
		}
	}
	return 0;	

}

static int close_connection(client_ctx_t *client_ctx)
{
	fprintf(stderr,"close connection fd:%d\n",client_ctx->client_fd);
	close(client_ctx->client_fd);
	return 0;
}
client_ctx_t* client_new()
{
	client_ctx_t * client_ctx = (client_ctx_t*)malloc(sizeof(client_ctx_t));
	if(client_ctx == NULL)
	{
		fprintf(stderr,"server_new malloc faile\n");
		return NULL;
	}
	return client_ctx;
}

static int client_start(interface_t * this, char *ip, int port)
{
	int ret;
	int client_fd;
	int addr_len;
	pthread_t thread_id;
	struct in_addr addr;
	struct sockaddr_in client_addr;
	client_ctx_t *client_ctx;

	

	client_fd = socket(PF_INET, SOCK_STREAM, 0);
	if( client_fd == -1)
	{
		fprintf(stderr,"Failed to create socket.\n");
		return -1;
	}

	addr_len = sizeof(struct sockaddr);

	client_addr.sin_family = AF_INET;
	client_addr.sin_port = htons(port);
	client_addr.sin_addr.s_addr = inet_addr(ip);
//	memcpy(&server_addr.sin_addr, &addr, sizeof(struct in_addr));
	bzero(&(client_addr.sin_zero),8);

	ret = connect(client_fd, (struct sockaddr*)&client_addr, addr_len);
	if(ret == -1)
	{
		perror("connection");
		fprintf(stderr,"Failed to connection address.\n");
		return -1;

	}



	set_nonblock(client_fd);
	client_ctx->client_fd = client_fd;
	client_ctx->timeout = get_cur_time();	
	ret = pthread_create(&thread_id, NULL, client_thread, this);
	if(ret != 0)
	{
		fprintf(stderr,"Failed to create thread.\n");
		return -1;
	}
	
	return 0;
}

static int set_recv_callback(interface_t * this,void (*callback)(void *param, int socket, char *buf, int len, int flags), void *param)
{

	client_ctx_t *client_ctx = (client_ctx_t*)this->parent;
	this->recv_callback = callback;
	client_ctx->param = param;
}

static int set_disconnect_callback(interface_t * this,void (*callback)(void *param, int socket), void *param)
{
	
	client_ctx_t *client_ctx = (client_ctx_t*)this->parent;
	this->disconnect_callback = callback;
	client_ctx->disconnect_param = param;
}


static int client_send(interface_t *this, char *buf, int len, int flags)
{
	int ret;
	int delay = 1000;
	struct pollfd poll_fd;
	client_ctx_t *client_ctx = (client_ctx_t*)this->parent;

	poll_fd.fd = client_ctx->client_fd;
	poll_fd.events = POLLOUT;
	while(len > 0)
	{
		do{
			ret = poll(&poll_fd, 1, delay);
			if((ret < 0)&& (errno == EINTR) && (errno == EAGAIN))
			{
				return ;
			}
		}while(ret < 0);

		if((poll_fd.revents)& (POLLERR | POLLHUP))
		{
			perror("poll");
			return -1;
		}

		if(poll_fd.revents & POLLOUT)
		{
			ret = send(client_ctx->client_fd,buf,len,flags);
			buf += len;
			len = len - ret;
		}
	}
	return 0;
}
int client_init(client_ctx_t *client_ctx)
{
	if(client_ctx == NULL)
		return -1;

	client_ctx->interface.parent = (void *)client_ctx;
	client_ctx->interface.interface_start = client_start;
	client_ctx->interface.set_recv_callback = set_recv_callback;
	client_ctx->interface.set_disconnect_callback = set_disconnect_callback;
	client_ctx->interface.interface_send = client_send;

	return 0;
//	server_ctx->server_send = server_send;
}

void inline set_nonblock(int fd)
{
	int ret;
	
	ret = fcntl(fd, F_GETFL);
	fcntl(fd, F_SETFL, ret|O_NONBLOCK);
	
	return ;
}

void inline set_block(int fd)
{
	int ret;

	ret = fcntl(fd, F_GETFL);
	ret &= ~O_NONBLOCK;
	fcntl(fd, F_SETFL, ret);

	return ;
}
unsigned int get_cur_time()
{
	struct timeval tv;
	gettimeofday(&tv,NULL);
	return tv.tv_sec;
}