libsk.c

rod4 扫描仪协议分析代码

#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>

#include "libsk.h"
#include "debug.h"
#include "packet.h"
#include "version.h"
int libsk_create_server(char *ip, short port)
{
	int listenfd;
	struct sockaddr_in servaddr;

	listenfd = socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));

	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = inet_addr(ip);
	servaddr.sin_port = htons(port);

	bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));

	if(listen(listenfd, MAX_CONNECT) < 0)
	{
		DEBUG("error create debug server\n");
		listenfd = -1;
	}	

	return listenfd;
}

int libsk_accept(int sk)
{
	int fd;
	struct sockaddr_in addr;
	int sin_size=sizeof(struct sockaddr_in);
	fd = accept(sk , (struct sockaddr*)&addr , &sin_size);
	return fd;
}

int libsk_connect_to(char *serverip, short port)
{
	int fd, ret;
	struct sockaddr_in servaddr;

	if(!serverip)
	{
		DEBUG("wrong ip");
	}
	fd = socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(port);
	inet_pton(AF_INET, serverip, &servaddr.sin_addr);
	ret = connect(fd, (struct sockaddr *) &servaddr, sizeof(servaddr));
	if(ret == -1)
	{
		perror("failed:");
		DEBUG("connect %s failed", serverip);
		close(fd);
		fd = -1;
	}
	return fd;
}

int libsk_set_noblock(int sk)
{
	int     flags;

	if  ( (flags = fcntl(sk, F_GETFL, 0)) < 0)
	{
		DEBUG("get sk flag failed");
		return -1;
	}
	flags |= O_NONBLOCK;
	if (fcntl(sk, F_SETFL, flags) < 0)
	{
		DEBUG("get sk flag failed");
		return -2;
	}

	return 1;	
}

int libsk_recieve_data(int sk , char *buf, unsigned long size)
{
	int ret , n = 0, i = 0;
	do
	{
		ret = read(sk , &buf[n], size - n);
		if(ret < 0)
		{
			perror("error:");
			DEBUG("get error");
			return -1;
		}
		else
		{
			n += ret;
		}
		i++;
	}
	while(n != size && i < 10);

	if(n != size)
	{
		
	}
	
	return n;
}

int libsk_send_data(int sk , char *buf, unsigned long size)
{
	int ret , n = 0, i = 0;
	do
	{
		ret = write(sk , &buf[n], size - n);
		if(ret < 0)
		{
			perror("error");
			DEBUG("send error");
			return -1;
		}
		else
		{
			n += ret;
		}
		i++;
	}
	while(n != size && i < 10);

	if(n != size)
	{
		DEBUG("length error!!!!");
	}
	return n;
}

#define CMD_BUF_SIZE 8192

int libsk_recieve_cmd(int sk, unsigned short *cmd , char *type, void * buf_out)
{

	int ret, length;
	//void *buf
	static char buf[CMD_BUF_SIZE];
	static int offset = 0;
	struct packet_head * head = (struct packet_head *)buf;

	*cmd = 0;
	
	if(!buf_out)
	{
		DEBUG("no buf");
		return -1;
	}
	//check head
	//ret = libsk_recieve_data(sk , &buf[offset], CMD_BUF_SIZE - offset);
	ret = read(sk , &buf[offset], CMD_BUF_SIZE - offset);
	if(ret < 0)
	{
		DEBUG("get error");
		return -1;//here may need destory the socket
	}
	DEBUG("get data lenth %d now offset %d ", ret, offset);
	offset += ret;
	ret = 0;
	
	if(offset >= PACKET_HEAD_SIZE)
	{
		int fix_flag = 0;
		if(head->magic_head != MAGIC_HEAD )
		{
			DEBUG("check head failed : shoud : %x here: %lx", MAGIC_HEAD, head->magic_head);
			fix_flag = 1;
		}

		if(head->version != VERSION)
		{
			DEBUG("check version failed : shoud : %x here: %x", VERSION, head->version);
			fix_flag = 1;
		}
		if(fix_flag)
		{
			int i;
			for(i = 0; i < offset; i++)
			{
				head = (struct packet_head *) &buf[i];
				if(head->magic_head == MAGIC_HEAD)
				{
					memmove(buf, &buf[i], offset - i);
					offset -= i;
				}
			}
			return 0;
		}
		length = head->length + 4;
		if(offset >= PACKET_HEAD_SIZE + length)
		{
			char *data = &buf[PACKET_HEAD_SIZE];

			if( *(unsigned long *)(data+head->length) != MAGIC_END)
			{
				DEBUG("check tail failed : shoud : %x here: %lx", MAGIC_END, *(unsigned long *)(data+head->length));
				memmove(buf, &(buf[PACKET_HEAD_SIZE + length]), offset - (PACKET_HEAD_SIZE + length));
				offset -= PACKET_HEAD_SIZE + length;
				return 0;
			}
			if(head->length)
				memcpy(buf_out, data, head->length);
			*cmd = head->cmd;
			*type = head->type;
			ret = head->length;
			memmove(buf, &(buf[PACKET_HEAD_SIZE + length]), offset - (PACKET_HEAD_SIZE + length));
			offset -= PACKET_HEAD_SIZE + length;
		}
	}
	//free(buf);
	return ret;
}

int libsk_send_cmd(int sk, unsigned short cmd,int type ,void *buf, unsigned long length)
{
	struct packet packet;
	int ret, send_length;
	void *send_buf;
	if(length)
	{
		if(!buf)
		{
			DEBUG("no data");
			return -1;
		}
	}

	packet.magic_head = MAGIC_HEAD;
	packet.version = VERSION;
	packet.type = type;
	packet.cmd = cmd;
	packet.length = length;
	
	ret = libsk_send_data(sk , (void *)(&packet), PACKET_HEAD_SIZE);
	if(ret < 0)
	{
		DEBUG("send head failed");
		return -1;
	}
	if(ret != PACKET_HEAD_SIZE)
	{
		DEBUG("send head size not right: shoud :%d here:%d", PACKET_HEAD_SIZE, ret);
		return -2;
	}
	
	send_length = length + sizeof(packet.magic_end);
	send_buf = malloc(length);
	if(!send_buf)
	{
		DEBUG("send buf malloc failed");
		return -3;
	}
	if(length)
		memcpy(send_buf, buf, length);
	packet.magic_end = MAGIC_END;
	memcpy(send_buf+length, &(packet.magic_end) , sizeof(packet.magic_end));
	ret = libsk_send_data(sk , send_buf, send_length);
	if(ret < 0)
	{
		DEBUG("send head failed");
		return -1;
	}
	if(ret != send_length)
	{
		DEBUG("send head size not right: shoud :%d here:%d", send_length, ret);
		return -2;
	}
	free(send_buf);
	return 1;
}

int libsk_close(int sk)
{
	if((sk != 0) && (sk != -1))
	{
		close(sk);
	}
	return 0;
}