Skip to content

Commit 8aa4942

Browse files
itheweiithewei
committed
add event html
1 parent 5902b9a commit 8aa4942

39 files changed

+7488
-0
lines changed

‎base/hstring.cpp‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,28 @@
88
#include <iostream>
99
#include <sstream>
1010

11+
char* strupper(char* str) {
12+
char* p = str;
13+
while (*p != '\0') {
14+
if (*p >= 'a' && *p <= 'z') {
15+
*p &= ~0x20;
16+
}
17+
++p;
18+
}
19+
return str;
20+
}
21+
22+
char* strlower(char* str) {
23+
char* p = str;
24+
while (*p != '\0') {
25+
if (*p >= 'A' && *p <= 'Z') {
26+
*p |= 0x20;
27+
}
28+
++p;
29+
}
30+
return str;
31+
}
32+
1133
int vscprintf(const char* fmt, va_list ap) {
1234
return vsnprintf(NULL, 0, fmt, ap);
1335
}

‎base/hstring.h‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,9 @@ using std::string;
1010

1111
typedef std::vector<string> StringList;
1212

13+
char* strupper(char* str);
14+
char* strlower(char* str);
15+
1316
string asprintf(const char* fmt, ...);
1417
StringList split(const string& str, char delim);
1518
string trim(const string& str, const char* chars = SPACE_CHARS);

‎etc/httpd.conf‎

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
# [root]
2+
3+
# logfile = logs/test.log
4+
# loglevel = [VERBOSE,DEBUG,INFO,WARN,ERROR,FATAL,SILENT]
5+
loglevel = INFO
6+
log_remain_days = 3
7+
8+
# worker_processes = 4
9+
# auto = ncpu
10+
worker_processes = auto
11+
12+
# http server
13+
port = 8080
14+
base_url = /v1/api
15+
document_root = html
16+
home_page = index.html
17+
error_page = error.html
18+
19+
file_stat_interval = 10 # s
20+
file_cached_time = 60 # s

‎event/client.cpp.demo‎

Lines changed: 97 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,97 @@
1+
#include "hloop.h"
2+
3+
#include "htime.h"
4+
#include "hsocket.h"
5+
6+
#define RECV_BUFSIZE 8192
7+
8+
void on_timer(htimer_t* timer, void* userdata) {
9+
static int cnt = 0;
10+
printf("on_timer timer_id=%d time=%luus cnt=%d\n", timer->timer_id, timer->loop->cur_time, ++cnt);
11+
}
12+
13+
void on_idle(hidle_t* idle, void* userdata) {
14+
static int cnt = 0;
15+
printf("on_idle idle_id=%d cnt=%d\n", idle->idle_id, ++cnt);
16+
}
17+
18+
void on_read(hevent_t* event, void* userdata) {
19+
printf("on_read fd=%d\n", event->fd);
20+
char recvbuf[RECV_BUFSIZE] = {0};
21+
int nrecv;
22+
recv:
23+
memset(recvbuf, 0, sizeof(recvbuf));
24+
nrecv = recv(event->fd, recvbuf, sizeof(recvbuf), 0);
25+
printf("recv retval=%d\n", nrecv);
26+
if (nrecv < 0) {
27+
if (sockerrno != NIO_EAGAIN) {
28+
//goto recv_done;
29+
return;
30+
}
31+
else {
32+
perror("recv");
33+
goto recv_error;
34+
}
35+
}
36+
if (nrecv == 0) {
37+
goto disconnect;
38+
}
39+
printf("> %s\n", recvbuf);
40+
if (nrecv == sizeof(recvbuf)) {
41+
goto recv;
42+
}
43+
44+
recv_error:
45+
disconnect:
46+
printf("closesocket fd=%d\n", event->fd);
47+
closesocket(event->fd);
48+
hevent_del(event);
49+
}
50+
51+
void on_connect(hevent_t* event, void* userdata) {
52+
printf("on_connect connfd=%d\n", event->fd);
53+
struct sockaddr_in localaddr,peeraddr;
54+
socklen_t addrlen = sizeof(struct sockaddr_in);
55+
int ret = getpeername(event->fd, (struct sockaddr*)&peeraddr, &addrlen);
56+
if (ret < 0) {
57+
printf("connect failed: %s: %d\n", strerror(sockerrno), sockerrno);
58+
closesocket(event->fd);
59+
return;
60+
}
61+
addrlen = sizeof(struct sockaddr_in);
62+
getsockname(event->fd, (struct sockaddr*)&localaddr, &addrlen);
63+
printf("connect connfd=%d [%s:%d] => [%s:%d]\n", event->fd,
64+
inet_ntoa(localaddr.sin_addr), ntohs(localaddr.sin_port),
65+
inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
66+
67+
hevent_read(event->loop, event->fd, on_read, NULL);
68+
69+
static const char* http_request = "GET / HTTP/1.1\r\n\r\n";
70+
int nsend = send(event->fd, http_request, strlen(http_request), 0);
71+
printf("send retval=%d\n", nsend);
72+
printf("< %s\n", http_request);
73+
}
74+
75+
int main(int argc, char** argv) {
76+
if (argc < 3) {
77+
printf("Usage: cmd host port\n");
78+
return -10;
79+
}
80+
const char* host = argv[1];
81+
int port = atoi(argv[2]);
82+
83+
int connfd = Connect(host, port, 1);
84+
printf("connfd=%d\n", connfd);
85+
if (connfd < 0) {
86+
return connfd;
87+
}
88+
89+
hloop_t loop;
90+
hloop_init(&loop);
91+
//hidle_add(&loop, on_idle, NULL);
92+
htimer_add(&loop, on_timer, NULL, 1000, INFINITE);
93+
hevent_connect(&loop, connfd, on_connect, NULL);
94+
hloop_run(&loop);
95+
96+
return 0;
97+
}

‎event/epoll.cpp‎

Lines changed: 129 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,129 @@
1+
#include "hevent.h"
2+
3+
#ifdef EVENT_EPOLL
4+
#include "hplatform.h"
5+
#ifdef OS_LINUX
6+
#include <sys/epoll.h>
7+
#endif
8+
9+
#include "hdef.h"
10+
11+
#define INIT_EVENTS_NUM 64
12+
13+
typedef struct epoll_ctx_s {
14+
int epfd;
15+
int capacity;
16+
int nevents;
17+
struct epoll_event* events;
18+
} epoll_ctx_t;
19+
20+
static void epoll_ctx_resize(epoll_ctx_t* epoll_ctx, int size) {
21+
int bytes = sizeof(struct epoll_event) * size;
22+
epoll_ctx->events = (struct epoll_event*)realloc(epoll_ctx->events, bytes);
23+
epoll_ctx->capacity = size;
24+
}
25+
26+
int _event_init(hloop_t* loop) {
27+
if (loop->event_ctx) return 0;
28+
epoll_ctx_t* epoll_ctx = (epoll_ctx_t*)malloc(sizeof(epoll_ctx_t));
29+
epoll_ctx->epfd = epoll_create(INIT_EVENTS_NUM);
30+
epoll_ctx->capacity = INIT_EVENTS_NUM;
31+
epoll_ctx->nevents = 0;
32+
int bytes = sizeof(struct epoll_event) * epoll_ctx->capacity;
33+
epoll_ctx->events = (struct epoll_event*)malloc(bytes);
34+
memset(epoll_ctx->events, 0, bytes);
35+
loop->event_ctx = epoll_ctx;
36+
return 0;
37+
}
38+
39+
int _event_cleanup(hloop_t* loop) {
40+
if (loop->event_ctx == NULL) return 0;
41+
epoll_ctx_t* epoll_ctx = (epoll_ctx_t*)loop->event_ctx;
42+
close(epoll_ctx->epfd);
43+
SAFE_FREE(epoll_ctx->events);
44+
SAFE_FREE(loop->event_ctx);
45+
return 0;
46+
}
47+
48+
int _add_event(hevent_t* event, int type) {
49+
hloop_t* loop = event->loop;
50+
if (loop->event_ctx == NULL) {
51+
hloop_event_init(loop);
52+
}
53+
epoll_ctx_t* epoll_ctx = (epoll_ctx_t*)loop->event_ctx;
54+
int op = event->events == 0 ? EPOLL_CTL_ADD : EPOLL_CTL_MOD;
55+
if (type & READ_EVENT) {
56+
event->events |= EPOLLIN;
57+
}
58+
if (type & WRITE_EVENT) {
59+
event->events |= EPOLLOUT;
60+
}
61+
struct epoll_event ee;
62+
ee.events = event->events;
63+
ee.data.fd = event->fd;
64+
epoll_ctl(epoll_ctx->epfd, op, event->fd, &ee);
65+
if (op == EPOLL_CTL_ADD) {
66+
if (epoll_ctx->nevents == epoll_ctx->capacity) {
67+
epoll_ctx_resize(epoll_ctx, epoll_ctx->capacity*2);
68+
}
69+
epoll_ctx->nevents++;
70+
}
71+
return 0;
72+
}
73+
74+
int _del_event(hevent_t* event, int type) {
75+
hloop_t* loop = event->loop;
76+
epoll_ctx_t* epoll_ctx = (epoll_ctx_t*)loop->event_ctx;
77+
if (epoll_ctx == NULL) return 0;
78+
79+
if (event->events == 0) return 0;
80+
if (type & READ_EVENT) {
81+
event->events &= ~EPOLLIN;
82+
}
83+
if (type & WRITE_EVENT) {
84+
event->events &= ~EPOLLOUT;
85+
}
86+
int op = event->events == 0 ? EPOLL_CTL_DEL : EPOLL_CTL_MOD;
87+
struct epoll_event ee;
88+
ee.events = event->events;
89+
ee.data.fd = event->fd;
90+
epoll_ctl(epoll_ctx->epfd, op, event->fd, &ee);
91+
if (op == EPOLL_CTL_DEL) {
92+
epoll_ctx->nevents--;
93+
}
94+
return 0;
95+
}
96+
97+
int _handle_events(hloop_t* loop, int timeout) {
98+
epoll_ctx_t* epoll_ctx = (epoll_ctx_t*)loop->event_ctx;
99+
if (epoll_ctx == NULL) return 0;
100+
if (epoll_ctx->nevents == 0) return 0;
101+
int nepoll = epoll_wait(epoll_ctx->epfd, epoll_ctx->events, epoll_ctx->nevents, timeout);
102+
if (nepoll < 0) {
103+
perror("epoll");
104+
return nepoll;
105+
}
106+
if (nepoll == 0) return 0;
107+
int nevent = 0;
108+
for (int i = 0; i < epoll_ctx->nevents; ++i) {
109+
if (nevent == nepoll) break;
110+
int fd = epoll_ctx->events[i].data.fd;
111+
uint32_t revents = epoll_ctx->events[i].events;
112+
if (revents) {
113+
++nevent;
114+
auto iter = loop->events.find(fd);
115+
if (iter == loop->events.end()) {
116+
continue;
117+
}
118+
hevent_t* event = iter->second;
119+
if (revents & EPOLLIN) {
120+
_on_read(event);
121+
}
122+
if (revents & EPOLLOUT) {
123+
_on_write(event);
124+
}
125+
}
126+
}
127+
return nevent;
128+
}
129+
#endif

‎event/hevent.cpp‎

Lines changed: 85 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,85 @@
1+
#include "hevent.h"
2+
3+
#include "hdef.h"
4+
#include "hlog.h"
5+
#include "hsocket.h"
6+
7+
int _on_read(hevent_t* event) {
8+
event->readable = 1;
9+
//if (event->accept) {
10+
//}
11+
if (event->read_cb) {
12+
event->read_cb(event, event->read_userdata);
13+
}
14+
event->readable = 0;
15+
return 0;
16+
}
17+
18+
int _on_write(hevent_t* event) {
19+
_del_event(event, WRITE_EVENT);
20+
event->writeable = 1;
21+
//if (event->connect) {
22+
//}
23+
if (event->write_cb) {
24+
event->write_cb(event, event->read_userdata);
25+
}
26+
event->writeable = 0;
27+
return 0;
28+
}
29+
30+
int hloop_event_init(hloop_t* loop) {
31+
return _event_init(loop);
32+
}
33+
34+
int hloop_event_cleanup(hloop_t* loop) {
35+
return _event_cleanup(loop);
36+
}
37+
38+
int hloop_add_event(hevent_t* event, int type) {
39+
return _add_event(event, type);
40+
}
41+
42+
int hloop_del_event(hevent_t* event, int type) {
43+
return _del_event(event, type);
44+
}
45+
46+
static void remove_bad_fds(hloop_t* loop) {
47+
int error = 0;
48+
socklen_t optlen = sizeof(int);
49+
int ret = 0;
50+
auto iter = loop->events.begin();
51+
while (iter != loop->events.end()) {
52+
int fd = iter->first;
53+
ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, (char*)&error, &optlen);
54+
if (ret < 0 || error != 0) {
55+
hloge("getsockopt fd=%d retval=%d SO_ERROR=%d", fd, ret, error);
56+
hloop_del_event(iter->second);
57+
iter = loop->events.erase(iter);
58+
continue;
59+
}
60+
++iter;
61+
}
62+
}
63+
64+
int hloop_handle_events(hloop_t* loop, int timeout) {
65+
/*
66+
// remove destroy events
67+
hevent_t* event = NULL;
68+
auto iter = loop->events.begin();
69+
while (iter != loop->events.end()) {
70+
event = iter->second;
71+
if (event->destroy) {
72+
SAFE_FREE(event);
73+
iter = loop->events.erase(iter);
74+
continue;
75+
}
76+
++iter;
77+
}
78+
*/
79+
int nevent = _handle_events(loop, timeout);
80+
if (nevent < 0) {
81+
printf("handle_events error=%d\n", -nevent);
82+
remove_bad_fds(loop);
83+
}
84+
return nevent;
85+
}

0 commit comments

Comments
 (0)