Linux QQ之客户端（续）

首先给各位看官和自己道歉，私事耽误了代码的提交。那么接着往下贴出来。

上一篇写到全局头文件（const_global.h）和客户端前台（gui.h/c），那么本次接着贴出socket和DB部分

// socket.h

#ifndef SOCKET_H
#define SOCKET_H

#include "wrap.h"

extern int errno;

int passivesock(const char *, const char *, int);
int passiveUDP(const char *);
int passiveTCP(const char *);
int connectTCP(char *, int);
int connectUDP(char *, int);

int open_udp_server_running(char *);
void send_udp_msg(char *, int, char *);
void receice_udp_msg(int, char *);
void save_tcp_msg(char *);


void request_peer_user_address(char *, char *);
void login_user(char *, char *, char *);
#endif

// socket.c

#include "const_global.h"
#include "socket.h"

/* port base, for non-root servers	*/

/*------------------------------------------------------------------------
 * passivesock - allocate & bind a server socket using TCP or UDP
 *------------------------------------------------------------------------
 */
int passivesock(const char *service_port, const char *transport, int qlen) {
	/*
	 * Arguments:
	 *      service   - service associated with the desired port
	 *      transport - transport protocol to use ("tcp" or "udp")
	 *      qlen      - maximum server request queue length
	 */
	unsigned short portbase = 100;
	struct servent *pse; 	/* pointer to service information entry	*/
	struct protoent *ppe; 	/* pointer to protocol information entry*/
	struct sockaddr_in sin; /* an Internet endpoint address	*/
	int s, type; 			/* socket descriptor and socket type */
	char reuse_addr[8]; 	/* define socket reuse address */

	memset(&sin, 0, sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_addr.s_addr = INADDR_ANY;

	/* Map service name to port number */
	if ((pse = getservbyname(service_port, transport))) sin.sin_port = htons(ntohs((unsigned short) pse->s_port) + portbase);
	else if ((sin.sin_port = htons((unsigned short) atoi(service_port))) == 0) format_record("Can't get  service port entry.");

	/* Map protocol name to protocol number */
	if ((ppe = getprotobyname(transport)) == 0) format_record("Can't get protocol type entry.");

	/* Use protocol to choose a socket type */
	if (strcmp(transport, "UDP") == 0) type = SOCK_DGRAM;
	else type = SOCK_STREAM;

	/* Allocate a socket */
	s = socket(PF_INET, type, ppe->p_proto);
	if (s < 0) {
		format_error_log("Can not create socket.");
		format_debug_log("Execute socket function failed, you may check socket basic env such as <port|proto> and so on.");
		return 0;
	}

	/* set socket option */
	setsockopt(s, SOL_SOCKET, SO_REUSEADDR, reuse_addr, sizeof(reuse_addr));

	/* Bind the socket */
	if (bind(s, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
		format_error_log("Can not bind to port.");
		format_debug_log("Execute bind function failed, you may check socket basic env.");
		return 0;
	}
	if (type == SOCK_STREAM && listen(s, qlen) < 0) {
		format_error_log("Can not listen on port.");
		format_debug_log("Execute listen function failed, you may check the port is listening.");
		return 0;
	}
	return s;
}

int passiveUDP(const char *service_port){
/*
 * Arguments:
 *      service - service associated with the desired port
 */
	return passivesock(service_port, "UDP", 0);
}

int passiveTCP(const char *service_port){
/*
 * Arguments:
 *      service - service associated with the desired port
 */
	return passivesock(service_port, "TCP", FD_SETSIZE);
}

int connectTCP(char *server_ip, int server_port){
	int sockfd;
	struct sockaddr_in servaddr;
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	memset(&servaddr,0,sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	inet_pton(AF_INET, server_ip, &servaddr.sin_addr);
	servaddr.sin_port = htons(server_port);

	if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
		sockfd = -1;
		format_error_log("Can not connect tcp server.");
		format_debug_log("Execute connect function failed, you may check the process has been running.");
	}
//	fcntl(sockfd, F_SETFL, O_NDELAY);
	return sockfd;
}

int open_tcp_connection(){
	int server_port;
	char server_ip[20];

	xini_initial(&ini);
	ini.load(&ini, CLIENT_CFG_FILE);
	strcpy(server_ip, ini.get_value_data(&ini, "SOCKET", "socket_server_ip"));
	server_port = atoi(ini.get_value_data(&ini, "SOCKET", "socket_listen_port"));
	ini.dispose(&ini);
	xini_destroy(&ini);

	return connectTCP(server_ip, server_port);
}

void save_tcp_msg(char *msg) {
	char buf_return[25], *action_type, *result;

	int clientfd = open_tcp_connection();
	if(-1 == clientfd){
		format_error_log("Get connection from server failed.");
		format_debug_log("Execute open_tcp_connection function failed, you may check the server is running or not.");
		goto End;
	}
	if (Write(clientfd, msg, 130) < 0) {
		format_error_log("Write message to server failed.");
		format_debug_log("Execute Write function failed, you may check the server is running or not.");
		goto End;
	}

	memset(buf_return, '\0', sizeof(buf_return));
	if (Read(clientfd, buf_return, sizeof(buf_return)) <= 0) {
		format_error_log("Read message to server failed.");
		format_debug_log("Execute Read function failed, you may check the server is running or not.");
		goto End;
	}

	action_type = strtok(buf_return,split);
	result = strtok(NULL,split);
	if(strcmp("SUCCESS",result)) {
		format_error_log("Save message to DB failed.");
		format_debug_log("Get the save message result failed, you may check the server is running or not.");
	}

	End :
		Close(clientfd);
}

void send_udp_msg(char *server_ip, int server_port, char *msg){
	int sockmsgfd;
	struct sockaddr_in servaddr;
	sockmsgfd = Socket(AF_INET, SOCK_DGRAM, 0);
	memset(&servaddr,0,sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	inet_pton(AF_INET, server_ip, &servaddr.sin_addr);
	servaddr.sin_port = htons(server_port);

	sendto(sockmsgfd, msg, strlen(msg), 0, (struct sockaddr *)&servaddr, sizeof(servaddr));

	Close(sockmsgfd);
}

void receive_udp_msg(int sockmsgfd, char *udp_buf) {
	struct sockaddr_in cliaddr;
	int cliaddr_len;

	cliaddr_len = sizeof(cliaddr);
	if (recvfrom(sockmsgfd, udp_buf, MAXLINE, 0, (struct sockaddr *) &cliaddr,
			&cliaddr_len) <= 0) {
		Close(sockmsgfd);
		*udp_buf='\0';
	}
}

int open_udp_server_running(char *ip_port) {
	struct sockaddr_in servaddr, cliaddr;
	char *address, *ip, *port;
	int serv_port, sockmsgfd, cliaddr_len, n;

	address = (char *) malloc(30);
	strcpy(address, ip_port);
	ip = strtok(address, ":");
	port = strtok(NULL, ":");

	serv_port = atoi(port);

	sockmsgfd = Socket(AF_INET, SOCK_DGRAM, 0);

	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY );
	servaddr.sin_port = htons(serv_port);

	if (Bind(sockmsgfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0) {
		return -1;
	}

	return sockmsgfd;
}

void request_peer_user_address(char *peer_uid, char *peer_user_address) {
	int clientfd, buf_len=50;
	char buf[50];

	clientfd = open_tcp_connection();
	sprintf(buf, "REQUEST%sADDRESS%s%s%sNULL", split, split, peer_uid, split);
	if (Write(clientfd, buf, buf_len) < 0) {
		format_error_log("Write request to server to get peer user address failed.");
		format_debug_log("Execute Write function failed, you may check the server is running or not.");
		goto End;
	}
	memset(buf, '\0', sizeof(buf));
	if (Read(clientfd, buf, buf_len) < 0) {
		format_error_log("Read return result from server of peer user address failed.");
		format_debug_log("Execute Read function failed, you may check the server is running or not.");
		goto End;
	}
	strtok(buf, split); 				// action type [LOGIN|REFRESH|REQUEST]
	strtok(NULL, split); 				// login status [SUCCESS|FAILED] and USER_NAME
	strcpy(peer_user_address, strtok(NULL, split)); //ip:port

	End:
		Close(clientfd);
}

void login_user(char *user_name, char *user_pwd, char *buf) {
	int clientfd;

	clientfd = open_tcp_connection();
	if (-1 == clientfd) {
		format_error_log("Can not connect to server, login failed.");
		format_debug_log("Execute open_tcp_connection function failed, you may check the server is running or not.");
		return;
	}
	sprintf(buf, "LOGIN%s%s%s%s%sNULL", split, user_name, split, user_pwd, split);

	if (Write(clientfd, buf, MAXLINE) < 0) {
		format_error_log("Write request to server to login failed.");
		format_debug_log("Execute Write function failed, you may check the server is running or not.");
		goto End;
	}
	memset(buf, '\0', MAXLINE);
	if (Read(clientfd, buf, MAXLINE) < 0) {
		format_error_log("Read return result from server of login failed.");
		format_debug_log("Execute Read function failed, you may check the server is running or not.");
		goto End;
	}
	End:
		Close(clientfd);
}

void set_uri_info(char *uri, char *display) {
	xini_initial(&ini);
	ini.load(&ini, CLIENT_CFG_FILE);
	strcpy(uri, ini.get_value_data(&ini, "HTTP", "http_connect_uri"));
	strcpy(display, ini.get_value_data(&ini, "HTTP", "http_connect_display"));
	ini.dispose(&ini);
	xini_destroy(&ini);
}

// db.h

/*
 * gtk1.c
 *
 *  Created on: Dec 21, 2013
 *      Author: zsf
 *     Version: 2.5
 */
#ifndef DB_H
#define DB_H

#include <mysql/mysql.h>

void display_row(MYSQL_ROW);
void show_db_records();
int login_validation(const char *, const char *);
char *get_user_name();
MYSQL_RES *exe_sql(char *);

MYSQL sql_conn;
#endif

// db.c

/*
 * gtk1.c
 *
 *  Created on: Dec 21, 2013
 *      Author: zsf
 *     Version: 2.5
 */
#include "const_global.h"
#include "db.h"

// test output function
void display_row(MYSQL_ROW sqlrow) {
	short int field_count = 0;
	while (field_count < mysql_field_count(&sql_conn)) {
		printf("%s ", sqlrow[field_count]);
		field_count++;
	}
	printf("\n");
}

void show_db_records() {
	int res;
	MYSQL_RES *res_ptr;
	MYSQL_ROW sqlrow;

	res = mysql_query(&sql_conn, "SELECT * FROM demo");
	if (res) {
		format_record(mysql_error(&sql_conn));
	} else {
		format_record("Get records list as follows:");
		res_ptr = mysql_store_result(&sql_conn);
		if (res_ptr) {
			while ((sqlrow = mysql_fetch_row(res_ptr))) {
				display_row(sqlrow);
			}
			mysql_free_result(res_ptr);
		}
	}
}

int login_validation(const char *user_id, const char *user_passwd) {
	MYSQL_RES *res_ptr;
	MYSQL_ROW sqlrow;
	char sql[MAX_SQL_LEN];
	int records_num = 0;

	sprintf(sql,
			"select user.pet_name from user join status on (user.id=status.id) where user.id='%s' and user.passwd='%s';",
			user_id, user_passwd);

	res_ptr = exe_sql(sql);
	records_num = mysql_num_rows(res_ptr);

	// id is the primary key in table user ,so the value is not more than 1 if exists
	if (records_num) {
		LOGIN_STATUS = LOGIN_SUCCESS;
		sqlrow = mysql_fetch_row(res_ptr);
		memset(USER_NAME, 0, sizeof(USER_NAME));
		strcpy(USER_NAME, sqlrow[0]);
	} else {
		LOGIN_STATUS = LOGIN_FAILED;
	}
	mysql_free_result(res_ptr);

	return LOGIN_STATUS;
}

MYSQL_RES *exe_sql(char *sql) {
	char *host, *user, *pass, *db;
	MYSQL_RES *result;
	MYSQL mysql;

	mysql_init(&mysql);
	xini_initial(&ini);
	ini.load(&ini, SERVER_CFG_FILE);

	host = (char *) malloc(20);
	user = (char *) malloc(10);
	pass = (char *) malloc(10);
	db = (char *) malloc(10);

	strcpy(host, ini.get_value_data(&ini, "DB", "db_server_ip"));
	strcpy(user, ini.get_value_data(&ini, "DB", "db_user_name"));
	strcpy(pass, ini.get_value_data(&ini, "DB", "db_user_passwd"));
	strcpy(db, ini.get_value_data(&ini, "DB", "db_name"));

	ini.dispose(&ini);
	xini_destroy(&ini);

	if (!mysql_real_connect(&mysql, host, user, pass, db, 0, NULL, 0)) {
		format_record(mysql_error(&mysql));
	}
	if (mysql_query(&mysql, "set names 'utf8'") != 0) { /* set characters */
		format_error_log("Set character failed.");
		format_debug_log("Set db server character failed. Exec cmd [set names 'utf8'].");
	}
	if (mysql_query(&mysql, sql) != 0) {
		format_error_log("Execute sql sentence failed.");
		format_debug_log("Execute sql sentence failed, sql sentence as follows:");
		format_debug_log(sql);
	}
	result = mysql_store_result(&mysql);

	free(host);
	free(user);
	free(pass);
	free(db);
	mysql_close(&mysql);

	return result;
}