hq_linx_chat/include/tcp.h

#ifndef _TCP_H
#define _TCP_H

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

#include "debug.h"
#include "mychat.h"

#define BACKLOG 5

/* 信息检测 */
extern char tcp_info_check(struct sockaddr_in *sin)
{
	char ip[16];
	u_short port;							
	inet_ntop(AF_INET, (void *)&(sin->sin_addr.s_addr), ip, sizeof(ip));
	port = ntohs(sin->sin_port);				
	pr_debug("信息检测地址：%s:%d\n", ip, port);
	
	return 1;
}


/* 接收到(IP, 端口, 客户信息, 内容) */
extern char tcp_recv_from(char *ip, int port, struct sockaddr_in *cin, char *str)
{
	int ret = -1;
	struct sockaddr_in sin;
	
	int tcp_recv_fd;
	int tcp_newfd;
	tcp_recv_fd = socket(AF_INET, SOCK_STREAM, 0);
	
//	int enable = 1;
//	setsockopt(tcp_recv_fd, SOL_tcp_recv_fd, SO_REUSEADDR,  &enable, sizeof(int));
//	int nNetTimeout=1000;//1秒
    //发送时限
//	setsockopt(tcp_recv_fd, SOL_SOCKET, SO_SNDTIMEO, &nNetTimeout, sizeof(int));
    //接收时限
//	setsockopt(tcp_recv_fd, SOL_SOCKET, SO_RCVTIMEO, &nNetTimeout, sizeof(int));

	sin.sin_family = AF_INET;
	sin.sin_port = htons(port);
	sin.sin_addr.s_addr = inet_addr(ip);
	bzero(sin.sin_zero, 8);

	ret = bind(tcp_recv_fd, (struct sockaddr*)&sin, sizeof(sin));
	if (ret < 0) {
		perror("tcp_recv_from->bind\nError:");
		tcp_info_check(&sin);
		return ret;	
	}

	listen(tcp_recv_fd, BACKLOG);

	char buf[BUFSIZ];
	struct sockaddr cin_in;
	socklen_t addrlen = sizeof(cin_in);

	tcp_newfd = accept(tcp_recv_fd, &cin_in, &addrlen);
	if (tcp_newfd < 0) {
		perror("tcp_recv_from->accept\nError:");
		return ret;						
	}
	else
	{
		bzero(buf, BUFSIZ);
		recv(tcp_newfd, buf, BUFSIZ, 0);
		buf[BUFSIZ-1] = '\0';
		memcpy(str, &buf, BUFSIZ);
		memcpy(cin, &cin_in, sizeof(struct sockaddr_in));
	}

	close(tcp_recv_fd);
	
	return 1;						
}

/* 发送(IP,端口,信息) */
extern char tcp_send_to(char *ip, unsigned int port, char *str, int size_str)
{
	int ret = -1;
	struct sockaddr_in cin;
	
	int tcp_send_fd;
	tcp_send_fd = socket(AF_INET, SOCK_STREAM, 0);
//	int enable = 1;
//	setsockopt(tcp_recv_fd, SOL_tcp_recv_fd, SO_REUSEADDR,  &enable, sizeof(int));
//	int nNetTimeout=1000;//1秒
    //发送时限
//	setsockopt(tcp_send_fd, SOL_SOCKET, SO_SNDTIMEO, &nNetTimeout, sizeof(int));
    //接收时限
//	setsockopt(tcp_send_fd, SOL_SOCKET, SO_RCVTIMEO, &nNetTimeout, sizeof(int));

	cin.sin_family = AF_INET;
	cin.sin_port = htons(port);
	cin.sin_addr.s_addr = inet_addr(ip);
	bzero(cin.sin_zero, 8);


	ret = connect(tcp_send_fd, (struct sockaddr*)&cin, sizeof(cin));
	if (ret < 0) {
		perror("tcp_send_to->connect\nError:");
		tcp_info_check(&cin);
		return ret;	
	}

	ret = send(tcp_send_fd, str, size_str, 0);
	if (ret < 0) {
		perror("tcp_send_to->send\nError:");
		return ret;						
	}

	close(tcp_send_fd);
	
	return 1;						
}



/* 接收到(地址, 客户信息, 内容) */
extern int tcp_addr_ini(struct sockaddr_in *sin)
{
	int ret = -1;
	int tcp_recv_addr_fd;	
	
	tcp_recv_addr_fd = socket(AF_INET, SOCK_STREAM, 0);
//	int enable = 1;
//	setsockopt(tcp_recv_addr_fd, SOL_tcp_recv_fd, SO_REUSEADDR,  &enable, sizeof(int));
//	int nNetTimeout=1000;//1秒
    //发送时限
//	setsockopt(tcp_recv_addr_fd, SOL_SOCKET, SO_SNDTIMEO, &nNetTimeout, sizeof(int));
    //接收时限
//	setsockopt(tcp_recv_addr_fd, SOL_SOCKET, SO_RCVTIMEO, &nNetTimeout, sizeof(int));
	
	ret = bind(tcp_recv_addr_fd, (struct sockaddr*)sin, sizeof(struct sockaddr_in));
	if (ret < 0) {
		perror("tcp_addr_ini->bind\nError:");
		tcp_info_check(sin);
		return ret;	
	}

	listen(tcp_recv_addr_fd, BACKLOG);
	
	return tcp_recv_addr_fd;
}

/************************(addr, 客户信息, 内容)***************************************/
/* 接收到(地址, 客户信息, 内容) */
extern char tcp_addr_recv_from(int tcp_recv_addr_fd, struct sockaddr_in *cin, struct msg_tcp *msg)
{
	int ret = -1;
	int tcp_addr_newfd;
	struct sockaddr cin_in;
	struct msg_tcp msg_buf;
	
	socklen_t addrlen = sizeof(cin_in);
	tcp_addr_newfd = accept(tcp_recv_addr_fd, &cin_in, &addrlen);
	if (tcp_addr_newfd < 0) {
		perror("tcp_addr_ini->accept\nError:");
		return tcp_addr_newfd;						
	}	
	memcpy(cin, &cin_in, sizeof(struct sockaddr_in));
	
	ret = recv(tcp_addr_newfd, &msg_buf, sizeof(msg_buf), 0);
	if (ret < 0) //真正出错了
	{
		perror("tcp_addr_recv_from");
		return ret;	
	}	
	memcpy(msg, &msg_buf, sizeof(msg_buf));
	
	close(tcp_addr_newfd);
	return 1;						
}

/* 发送(地址,信息, 大小) */
extern char tcp_addr_send_to(struct sockaddr_in *cin, struct msg_tcp *msg, int msgsize)
{
	int ret = -1;	
	int tcp_send_addr_fd;
	tcp_send_addr_fd = socket(AF_INET, SOCK_STREAM, 0);
	
//	int nNetTimeout=1000;//1秒
    //发送时限
//	setsockopt(tcp_send_addr_fd, SOL_SOCKET, SO_SNDTIMEO, &nNetTimeout, sizeof(int));
    //接收时限
//	setsockopt(tcp_send_addr_fd, SOL_SOCKET, SO_RCVTIMEO, &nNetTimeout, sizeof(int));
		
	ret = connect(tcp_send_addr_fd, (struct sockaddr*)cin, sizeof(struct sockaddr_in));
	if (ret < 0) {
		perror("tcp_addr_send_to->connect\nError:");
		tcp_info_check(cin);
		return ret;	
	}

	ret = send(tcp_send_addr_fd, msg, msgsize, 0);

	if (ret < 0) {
		perror("tcp_addr_send_to->send\nError:");
		return ret;						
	}
	
	close(tcp_send_addr_fd);
	
	return 1;						
}

#endif