奇怪了 此tcp服务器不输出任何东西奇怪了 跪求高手帮忙！

cu-superstar

网上别人写的一段代码 复制即可编译 但我测试的时候编译可以通过 执行后却不输出任何东西 至少那些提示信息要输出吧！
printf("server running:port[%d]/n", port);  //连这句都没输出 我就奇了怪了

1. //   
   
2. 
   
3. #include <sys/socket.h>   
   
4. #include <sys/epoll.h>   
   
5. #include <netinet/in.h>   
   
6. #include <arpa/inet.h>   
   
7. #include <fcntl.h>   
   
8. #include <unistd.h>   
   
9. #include <stdio.h>   
   
10. #include <errno.h>   
    
11. #include <iostream>   
    
12. using namespace std;  
    
13. #define MAX_EVENTS 500   
    
14. struct myevent_s  
    
15. {  
    
16.     int fd;  
    
17.     void (*call_back)(int fd, int events, void *arg);  
    
18.     int events;  
    
19.     void *arg;  
    
20.     int status; // 1: in epoll wait list, 0 not in   
    
21.     char buff[128]; // recv data buffer   
    
22.     int len;  
    
23.     long last_active; // last active time   
    
24. };  
    
25. // set event   
    
26. void EventSet(myevent_s *ev, int fd, void (*call_back)(int, int, void*), void *arg)  
    
27. {  
    
28.     ev->fd = fd;  
    
29.     ev->call_back = call_back;  
    
30.     ev->events = 0;  
    
31.     ev->arg = arg;  
    
32.     ev->status = 0;  
    
33.     ev->last_active = time(NULL);  
    
34. }  
    
35. // add/mod an event to epoll   
    
36. void EventAdd(int epollFd, int events, myevent_s *ev)  
    
37. {  
    
38.     struct epoll_event epv = {0, {0}};  
    
39.     int op;  
    
40.     epv.data.ptr = ev;  
    
41.     epv.events = ev->events = events;  
    
42.     if(ev->status == 1){  
    
43.         op = EPOLL_CTL_MOD;  
    
44.     }  
    
45.     else{  
    
46.         op = EPOLL_CTL_ADD;  
    
47.         ev->status = 1;  
    
48.     }  
    
49.     if(epoll_ctl(epollFd, op, ev->fd, &epv) < 0)  
    
50.         printf("Event Add failed[fd=%d]/n", ev->fd);  
    
51.     else  
    
52.         printf("Event Add OK[fd=%d]/n", ev->fd);  
    
53. }  
    
54. // delete an event from epoll   
    
55. void EventDel(int epollFd, myevent_s *ev)  
    
56. {  
    
57.     struct epoll_event epv = {0, {0}};  
    
58.     if(ev->status != 1) return;  
    
59.     epv.data.ptr = ev;  
    
60.     ev->status = 0;  
    
61.     epoll_ctl(epollFd, EPOLL_CTL_DEL, ev->fd, &epv);  
    
62. }  
    
63. int g_epollFd;  
    
64. myevent_s g_Events[MAX_EVENTS+1]; // g_Events[MAX_EVENTS] is used by listen fd   
    
65. void RecvData(int fd, int events, void *arg);  
    
66. void SendData(int fd, int events, void *arg);  
    
67. // accept new connections from clients   
    
68. void AcceptConn(int fd, int events, void *arg)  
    
69. {  
    
70.     struct sockaddr_in sin;  
    
71.     socklen_t len = sizeof(struct sockaddr_in);  
    
72.     int nfd, i;  
    
73.     // accept   
    
74.     if((nfd = accept(fd, (struct sockaddr*)&sin, &len)) == -1)  
    
75.     {  
    
76.         if(errno != EAGAIN && errno != EINTR)  
    
77.         {  
    
78.             printf("%s: bad accept", __func__);  
    
79.         }  
    
80.         return;  
    
81.     }  
    
82.     do  
    
83.     {  
    
84.         for(i = 0; i < MAX_EVENTS; i++)  
    
85.         {  
    
86.             if(g_Events[i].status == 0)  
    
87.             {  
    
88.                 break;  
    
89.             }  
    
90.         }  
    
91.         if(i == MAX_EVENTS)  
    
92.         {  
    
93.             printf("%s:max connection limit[%d].", __func__, MAX_EVENTS);  
    
94.             break;  
    
95.         }  
    
96.         // set nonblocking   
    
97.         if(fcntl(nfd, F_SETFL, O_NONBLOCK) < 0) break;  
    
98.         // add a read event for receive data   
    
99.         EventSet(&g_Events[i], nfd, RecvData, &g_Events[i]);  
    
100.         EventAdd(g_epollFd, EPOLLIN|EPOLLET, &g_Events[i]);  
     
101.         printf("new conn[%s:%d][time:%d]/n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), g_Events[i].last_active);  
     
102.     }while(0);  
     
103. }  
     
104. // receive data   
     
105. void RecvData(int fd, int events, void *arg)  
     
106. {  
     
107.     struct myevent_s *ev = (struct myevent_s*)arg;  
     
108.     int len;  
     
109.     // receive data   
     
110.     len = recv(fd, ev->buff, sizeof(ev->buff)-1, 0);   
     
111.     EventDel(g_epollFd, ev);  
     
112.     if(len > 0)  
     
113.     {  
     
114.         ev->len = len;  
     
115.         ev->buff[len] = '\0';  
     
116.         printf("C[%d]:%s/n", fd, ev->buff);  
     
117.         // change to send event   
     
118.         EventSet(ev, fd, SendData, ev);  
     
119.         EventAdd(g_epollFd, EPOLLOUT|EPOLLET, ev);  
     
120.     }  
     
121.     else if(len == 0)  
     
122.     {  
     
123.         close(ev->fd);  
     
124.         printf("[fd=%d] closed gracefully./n", fd);  
     
125.     }  
     
126.     else  
     
127.     {  
     
128.         close(ev->fd);  
     
129.         printf("recv[fd=%d] error[%d]:%s/n", fd, errno, strerror(errno));  
     
130.     }  
     
131. }  
     
132. // send data   
     
133. void SendData(int fd, int events, void *arg)  
     
134. {  
     
135.     struct myevent_s *ev = (struct myevent_s*)arg;  
     
136.     int len;  
     
137.     // send data   
     
138.     len = send(fd, ev->buff, ev->len, 0);  
     
139.     ev->len = 0;  
     
140.     EventDel(g_epollFd, ev);  
     
141.     if(len > 0)  
     
142.     {  
     
143.         // change to receive event   
     
144.         EventSet(ev, fd, RecvData, ev);  
     
145.         EventAdd(g_epollFd, EPOLLIN|EPOLLET, ev);  
     
146.     }  
     
147.     else  
     
148.     {  
     
149.         close(ev->fd);  
     
150.         printf("recv[fd=%d] error[%d]/n", fd, errno);  
     
151.     }  
     
152. }  
     
153. void InitListenSocket(int epollFd, short port)  
     
154. {  
     
155.     int listenFd = socket(AF_INET, SOCK_STREAM, 0);  
     
156.     fcntl(listenFd, F_SETFL, O_NONBLOCK); // set non-blocking   
     
157.     printf("server listen fd=%d/n", listenFd);  
     
158.     EventSet(&g_Events[MAX_EVENTS], listenFd, AcceptConn, &g_Events[MAX_EVENTS]);  
     
159.     // add listen socket   
     
160.     EventAdd(epollFd, EPOLLIN|EPOLLET, &g_Events[MAX_EVENTS]);  
     
161.     // bind & listen   
     
162.     sockaddr_in sin;  
     
163.     bzero(&sin, sizeof(sin));  
     
164.     sin.sin_family = AF_INET;  
     
165.     sin.sin_addr.s_addr = INADDR_ANY;  
     
166.     sin.sin_port = htons(port);  
     
167.     bind(listenFd, (const sockaddr*)&sin, sizeof(sin));  
     
168.     listen(listenFd, 5);  
     
169. }  
     
170. int main(int argc, char **argv)  
     
171. {  
     
172.     short port = 12345; // default port   
     
173.     if(argc == 2){  
     
174.         port = atoi(argv[1]);  
     
175.     }  
     
176.     // create epoll   
     
177.     g_epollFd = epoll_create(MAX_EVENTS);  
     
178.     if(g_epollFd <= 0) printf("create epoll failed.%d/n", g_epollFd);  
     
179.     // create & bind listen socket, and add to epoll, set non-blocking   
     
180.     InitListenSocket(g_epollFd, port);  
     
181.     // event loop   
     
182.     struct epoll_event events[MAX_EVENTS];  
     
183.     printf("server running:port[%d]/n", port);  //连这句都没输出 我就奇了怪了
     
184.     int checkPos = 0;  
     
185.     while(1){  
     
186.         // a simple timeout check here, every time 100, better to use a mini-heap, and add timer event   
     
187.         long now = time(NULL);  
     
188.         for(int i = 0; i < 100; i++, checkPos++) // doesn't check listen fd   
     
189.         {  
     
190.             if(checkPos == MAX_EVENTS) checkPos = 0; // recycle   
     
191.             if(g_Events[checkPos].status != 1) continue;  
     
192.             long duration = now - g_Events[checkPos].last_active;  
     
193.             if(duration >= 60) // 60s timeout   
     
194.             {  
     
195.                 close(g_Events[checkPos].fd);  
     
196.                 printf("[fd=%d] timeout[%d--%d]./n", g_Events[checkPos].fd, g_Events[checkPos].last_active, now);  
     
197.                 EventDel(g_epollFd, &g_Events[checkPos]);  
     
198.             }  
     
199.         }  
     
200.         // wait for events to happen   
     
201.         int fds = epoll_wait(g_epollFd, events, MAX_EVENTS, 1000);  
     
202.         if(fds < 0){  
     
203.             printf("epoll_wait error, exit/n");  
     
204.             break;  
     
205.         }  
     
206.         for(int i = 0; i < fds; i++){  
     
207.             myevent_s *ev = (struct myevent_s*)events[i].data.ptr;  
     
208.             if((events[i].events&EPOLLIN)&&(ev->events&EPOLLIN)) // read event   
     
209.             {  
     
210.                 ev->call_back(ev->fd, events[i].events, ev->arg);  
     
211.             }  
     
212.             if((events[i].events&EPOLLOUT)&&(ev->events&EPOLLOUT)) // write event   
     
213.             {  
     
214.                 ev->call_back(ev->fd, events[i].events, ev->arg);  
     
215.             }  
     
216.         }  
     
217.     }  
     
218.     // free resource   
     
219.     return 0;  
     
220. }   
     

复制代码

hanzhenlll

看看你的这上面初始化 还是 其他函数调用的部分..

打印下信息看看，就知道到哪个函数卡主了，另外 注意加一些出错处理。。。。写得很不规范啊


    g_epollFd = epoll_create(MAX_EVENTS);  
    if(g_epollFd <= 0) printf("create epoll failed.%d/n", g_epollFd);  
    // create & bind listen socket, and add to epoll, set non-blocking   
    InitListenSocket(g_epollFd, port);  
    // event loop   
    struct epoll_event events[MAX_EVENTS];