sql_connecter::~sql_connecter()
{
close_connect();
if(res != NULL){
free(res);
}
}
/*
* 处理数据
*/
int handle(int client,void *buf) {
int ret = 0;
struct online_user *user;
struct format *data = (struct format *)buf;
if (data->length == 0)
return -1;
if (data->type > (sizeof(action_list) / 4) || data->type < 0)
return -1;
data->data[data->length] = '\0';
user = find_user(client);
if (user == NULL || user->handler == NULL)
ret = action_list[data->type - 1](client,data->data);
if (user != NULL && user->handler != NULL)
ret = user->handler(client,data->data);
if (ret < 0)
close_connect(client);
return ret;
}
sql_connecter::~sql_connecter()
{
if(this->_mysql_conn != NULL){//只有连接成功才进行关闭操作
close_connect();
}
//结果集使用完毕必须free负责会造成内存泄露
close_result();
}
char *client_read(UNUSED t_serv *serv, int fd)
{
int size_read;
char *cmd;
if ((cmd = malloc(sizeof(char) * BUFF_SIZE)) == NULL)
return (my_error_null(ERR_MALLOC));
bzero(cmd, BUFF_SIZE);
size_read = read(fd, cmd, BUFF_SIZE - 1);
if (size_read <= 0)
{
close_connect(serv, fd, 0);
close_connect(serv, fd, 1);
return (NULL);
}
if (size_read < BUFF_SIZE)
return (cmd);
return (cmd);
}
int main(int argc, char* argv[])
{
if (argc <= 2)
{
printf("Usage: %s ip_address port_number\n", argv[0]);
return 0;
}
log_globals_init(&g_log);
log_init(&g_log, "jhttpserver.log", NULL);
log_set_loglevel(&g_log, LOG_DEBUG);
const char* ip = argv[1];
int port = atoi(argv[2]);
INFO(&g_log, "jhttpserver", "%s : %d", ip, port);
add_signal(SIGPIPE, SIG_IGN, TRUE);
thread_pool* pool = create_thread_pool(8 ,10000);
if (pool == NULL)
{
printf("create thread pool is failed.");
ERROR(&g_log, "jhttpserver", "create thread pool is failed.");
return 1;
}
http_conn* users = (http_conn*)malloc(sizeof(http_conn) * MAX_FD);
assert(users);
int listen_fd = socket(PF_INET, SOCK_STREAM, 0);
struct linger tmp = {1, 0};
setsockopt(listen_fd, SOL_SOCKET, SO_LINGER, &tmp, sizeof(tmp));
int ret = 0;
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
address.sin_port = htons(port);
inet_pton(AF_INET, ip, &address.sin_addr);
ret = bind(listen_fd, (struct sockaddr *)&address, sizeof(address));
assert(ret >= 0);
ret = listen(listen_fd, 5);
assert(ret >= 0);
struct epoll_event events[MAX_EVENT_NUMBER];
epollfd = epoll_create(5);
assert(epollfd != -1);
add_fd(epollfd, listen_fd, false);
while (true)
{
int number = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
if ((number < 0) && (errno != EINTR))
{
printf("epoll failure\n");
break;
}
int i=0;
for (; i<number; i++)
{
int sockfd = events[i].data.fd;
if (sockfd == listen_fd)
{
struct sockaddr_in client_address;
socklen_t client_addr_len = sizeof(client_address);
int conn_fd = accept(listen_fd, (struct sockaddr*)&client_address,
&client_addr_len);
if (conn_fd < 0)
{
printf("errno is : %d\n", errno);
continue;
}
if (user_count > MAX_FD)
{
show_error(conn_fd, "Internal server busy");
continue;
}
init_new_connect(&users[conn_fd], conn_fd, &client_address);
}
else if (events[i].events & (EPOLLRDHUP | EPOLLHUP | EPOLLERR))
{
close_connect(&users[sockfd]);
}
else if (events[i].events & EPOLLIN)
{
if (http_conn_read(&users[sockfd]))
{
add_conn(pool, users + sockfd);
}
else
{
close_connect(&users[sockfd]);
}
}
else if (events[i].events & EPOLLOUT)
{
if (!http_conn_write(&users[sockfd]))
{
close_connect(&users[sockfd]);
}
}
}
}
close(epollfd);
close(listen_fd);
free(users);
destroy_thread_pool(pool);
return 0;
}
void CommandeGen::close() {
m_status = close_connect();
}
sql_conner::~sql_conner()
{
close_connect();
}
static void *worker_thread_or_server(void *userdata)
{
int ready, i, n, bufsize = 128 * 1024;
void *buf;
struct epoll_event ev, *e;
unsigned short port = (unsigned short)(int)(long)userdata;
int s_listen, new_fd;
struct sockaddr_in their_addr;
struct sockaddr_in my_addr;
socklen_t sin_size;
ignore_pipe();
if ((s_listen = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
kerror("c:%s, e:%s\n", "socket", strerror(errno));
return NULL;
}
config_socket(s_listen);
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(port);
my_addr.sin_addr.s_addr = INADDR_ANY;
memset(my_addr.sin_zero, '\0', sizeof(my_addr.sin_zero));
if (bind(s_listen, (struct sockaddr *) &my_addr, sizeof(my_addr)) == -1) {
kerror("c:%s, e:%s\n", "bind", strerror(errno));
return NULL;
}
if (listen(s_listen, BACKLOG) == -1) {
kerror("c:%s, e:%s\n", "listen", strerror(errno));
return NULL;
}
__g_epoll_fd = epoll_create(__g_epoll_max);
memset(&ev, 0, sizeof(ev));
ev.data.fd = s_listen;
ev.events = EPOLLIN;
epoll_ctl(__g_epoll_fd, EPOLL_CTL_ADD, s_listen, &ev);
buf = kmem_alloc(bufsize, char);
for (;;) {
do
ready = epoll_wait(__g_epoll_fd, __g_epoll_events, __g_epoll_max, -1);
while ((ready == -1) && (errno == EINTR));
for (i = 0; i < ready; i++) {
e = __g_epoll_events + i;
if (e->data.fd == s_listen) {
sin_size = sizeof(their_addr);
if ((new_fd = accept(s_listen, (struct sockaddr *) &their_addr, &sin_size)) == -1) {
kerror("c:%s, e:%s\n", "accept", strerror(errno));
continue;
}
/* FIXME: non-blocking will cause orbatch bang */
/* setnonblocking(new_fd); */
/* XXX: new_fd can be o or w */
if (process_connect(new_fd))
close_connect(new_fd);
continue;
} else if (!(e->events & EPOLLIN)) {
kerror("!!! Not EPOLLIN: event is %08x, fd:%d\n", e->events, e->data.fd);
continue;
}
if ((n = recv(e->data.fd, buf, bufsize, 0)) > 0) {
if (do_opt_command(e->data.fd, buf, n))
close_connect(e->data.fd);
} else {
klog("Remote close socket: %d\n", e->data.fd);
close_connect(e->data.fd);
}
}
}
kmem_free(buf);
close(__g_epoll_fd);
__g_epoll_fd = -1;
return NULL;
}
int main(void) {
int i;
int ifd;
int len;
int client_sock;
struct online_user *user;
Client client;
struct sockaddr_in client_name;
int client_name_len = sizeof(client_name);
#define MAX_BUFSIZE 0x100000
char buf[MAX_BUFSIZE];
struct format *package = (struct format *)buf;
tcp_server_sock = tcp_startup(SERVER_TCP_PORT);
init_mysql();
register_ctrl_c();
kdpfd = epoll_create(MAXEPOLLSIZE);
/* 设置要监听的事件。EPOLLIN 表示可读，EPOLLET则指定电平触发 */
ev.events = EPOLLIN;
ev.data.fd = tcp_server_sock;
if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, tcp_server_sock, &ev) < 0)
/* 把 tcp sock 加入监听集合，以便接收连接请求 */
error_die("tcp epoll_ctl\n");
/* 记录监听的文件数，同时他也是 epoll_wait 的第三个参数。
因为内核需要知道 events 数组的有效数据有多长 */
curfds = 1;
for (;;) {
memset(buf,0,sizeof(buf));
printf("waiting...\n");
/* 等待有事件发生。该函数的返回值存放在 nfds 和 events 内 */
nfds = epoll_wait(kdpfd, events, curfds, -1);
if (nfds < 0)
error_die("epoll_wait");
for (i = 0; i < nfds; i++) {
ifd = events[i].data.fd;
if (ifd == tcp_server_sock) {
//新的 TCP 连接请求到来
if (!(events[i].events & EPOLLIN))
error_die("failed to event is not EPOLLIN\n");
client_sock = accept(tcp_server_sock,(struct sockaddr *)&client_name,&client_name_len);
setnonblocking(client_sock);
ev.events = EPOLLIN;
ev.data.fd = client_sock;
if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, client_sock, &ev) < 0)
error_die("epoll_ctl");
curfds++;
client = alloc_client(client_sock);
add_client(client);
} else if ((events[i].events & EPOLLIN)) {
/* 客户端有数据发来（POLLIN）或者发生 POLLHUP/POLLERR（这两个事件系统会自动监听） */
client = find_client(ifd);
if (client != NULL && client->handler != NULL) {
//已经有了处理函数，直接调用这个函数来处理
client->handler(ifd,client->private);
} else {
//默认的处理方法
//读入数据包头部。
len = read(ifd,package,(sizeof(struct format)-sizeof(package->data)));
if (len <= 0) {
//对方断线。
close_connect(ifd);
continue;
}
if (package->length >= MAX_BUFSIZE || package->length <= 0) {
while(read(ifd,package->data,4) > 0);
continue;
}
if ((len = read(ifd,package->data,package->length) <= 0)) {
//读入数据包内容
close_connect(ifd);
continue;
}
// 处理数据
if (handle(ifd,package) == NEED_WRITE) {
ev.events = EPOLLOUT;
ev.data.fd = ifd;
epoll_ctl(kdpfd,EPOLL_CTL_MOD,ifd,&ev);
}
}
} else if(events[i].events & EPOLLOUT) {
