void loop (void)
{
int i, n, maxfd, maxi, listenfd, clifd, nread;
char buf[MAXLINE];
uid_t uid;
fd_set rset, allset;
FD_ZERO (&allset);
/* obtain fd to listen for client requests on */
if ((listenfd = serv_listen (CS_OPEN)) < 0) {
log_sys ("serv_listen error");
}
FD_SET (listenfd, &allset);
maxfd = listenfd;
maxi = -1;
for (;;) {
rset = allset; /* rset gets modified each time around */
if ((n = select (maxfd + 1, &rset, NULL, NULL, NULL)) < 0) {
log_sys ("select error");
}
if (FD_ISSET (listenfd, &rset)) {
/* accept new client request */
if ((clifd = serv_accept (listenfd, &uid)) < 0) {
log_sys ("serv_accept error: %d", clifd);
}
i = client_add (clifd, uid);
FD_SET (clifd, &allset);
if (clifd > maxfd) {
maxfd = clifd; /* max fd for select() */
}
if (i > maxi) {
maxi = i; /* max index in client[] array */
}
log_msg ("new connection: uid %d, fd %d", uid, clifd);
}
for (i = 0; i <= maxi; i++) { /* go through client[] array */
if ((clifd = client[i].fd) < 0) {
continue;
}
if (FD_ISSET (clifd, &rset)) {
/* read argument buffer from client */
if ((nread = read (clifd, buf, MAXLINE)) < 0) {
log_sys ("read error on fd %d", clifd);
} else if (nread == 0) {
log_msg ("closed: uid %d, fd %d",
client[i].uid, clifd);
client_del (clifd); /* client has closed cxn */
FD_CLR (clifd, &allset);
close (clifd);
} else { /* process client's request */
request (buf, nread, clifd, client[i].uid);
}
}
}
}
}
void
loop(void)
{
int listenfd, clifd;
int rval, i, nr;
int maxi, maxfd;
uid_t uid;
fd_set rset, allset;
char buf[MAXLINE];
/* obtain fd to listen for client request on */
if ((listenfd = serv_listen(CS_OPEN)) < 0)
log_sys("serv_listen error");
FD_ZERO(&allset);
FD_SET(listenfd, &allset);
maxfd = listenfd;
maxi = -1;
for (;;) {
rset = allset; /* rset get modified each time around */
rval = select(maxfd + 1, &rset, NULL, NULL, NULL);
if (rval < 0)
log_sys("select error");
if (FD_ISSET(listenfd, &rset)) {
/* accept new client request */
if ((clifd = serv_accept(listenfd, &uid)) < 0)
log_sys("serv_accept error");
i = client_add(clifd, uid);
FD_SET(clifd, &allset);
if (i > maxi)
maxi = i;
if (clifd > maxfd)
maxfd = clifd;
log_msg("new connection: uid %d, fd %d", uid, clifd);
continue;
}
for (i = 0; i <= maxi; i++) {
if (client[i].fd == -1)
continue;
if (FD_ISSET(client[i].fd, &rset)) {
/* read argument buffer from client */
if ((nr = read(client[i].fd, buf, MAXLINE)) < 0) {
log_sys("read error on fd %d", clifd);
} else if (nr == 0) {
log_msg("closed: uid %d, fd %d",
client[i].uid, clifd);
client_del(client[i].fd); /* client has closed cxn */
FD_CLR(clifd, &allset);
close(clifd);
} else { /* process client's request */
handler_request(buf, nr, clifd, client[i].uid);
}
}
}
}
}
void create_control_socket(const char *filename) {
int fd;
if((fd = serv_listen(filename)) < 0) {
wack_alarm(PRINT, "disabling wackatrl support.");
return;
}
E_attach_fd(fd, READ_FD, handle_control_connect, 0, NULL, HIGH_PRIORITY);
}
void
loop(void)
{
int i, maxi, listenfd, clifd, nread;
char buf[MAXLINE];
uid_t uid;
struct pollfd *pollfd;
if ((pollfd = malloc(open_max() * sizeof(struct pollfd))) == NULL)
err_sys("malloc error");
/* obtain fd to listen for client requests on */
if ((listenfd = serv_listen(CS_OPEN)) < 0)
log_sys("serv_listen error");
client_add(listenfd, 0); /* we use [0] for listenfd */
pollfd[0].fd = listenfd;
pollfd[0].events = POLLIN;
maxi = 0;
for ( ; ; ) {
if (poll(pollfd, maxi + 1, -1) < 0)
log_sys("poll error");
if (pollfd[0].revents & POLLIN) {
/* accept new client request */
if ((clifd = serv_accept(listenfd, &uid)) < 0)
log_sys("serv_accept error: %d", clifd);
i = client_add(clifd, uid);
pollfd[i].fd = clifd;
pollfd[i].events = POLLIN;
if (i > maxi)
maxi = i;
log_msg("new connection: uid %d, fd %d", uid, clifd);
}
for (i = 1; i <= maxi; i++) {
if ((clifd = client[i].fd) < 0)
continue;
if (pollfd[i].revents & POLLHUP) {
goto hungup;
} else if (pollfd[i].revents & POLLIN) {
/* read argument buffer from client */
if ((nread = read(clifd, buf, MAXLINE)) < 0) {
log_sys("read error on fd %d", clifd);
} else if (nread == 0) {
hungup:
log_msg("closed: uid %d, fd %d",
client[i].uid, clifd);
client_del(clifd); /* client has closed conn */
pollfd[i].fd = -1;
close(clifd);
} else { /* process client's request */
request(buf, nread, clifd, client[i].uid);
}
}
}
}
}
int main(int argc, char *argv[])
{
serv_listen(33333);
char buffer[256];
memset(buffer, 0, 256);
printf("bef whi\n");
while (strcmp(buffer, "stop") != 0) {
printf("in whi\n");
memset(buffer, 0, 256);
fgets(buffer, 255, stdin);
serv_send(buffer);
}
serv_stop();
return 0;
}
static int app_start(struct sec_db* sdb){
int fd,serve_fd;
pthread_t tid;
pthread_attr_t attr;
if( (serve_fd = serv_listen(SERVICE)) < 0){
return -1;
}
while(1){
if( (fd = serv_accept(serve_fd,NULL)) < 0){
return -1;
}
if( init_pthread_attr_t(&attr))
return -1;
if( pthread_create(&tid,&attr,app_do_request,(void*)&fd))
return -1;
pthread_attr_destroy(&attr);
};
}
void *server_socket(void *a)
{
int n;
uid_t uid;
int listenfd, connfd;
char buf[4096];
if((listenfd = serv_listen("/tmp/my_unix.socket")) < 0)
{
if(listenfd == -1)
{
perror("socket error");
exit(1);
}
if(listenfd == -2)
{
perror("bind error");
exit(1);
}
if(listenfd == -3)
{
perror("listen error");
exit(1);
}
}
while(1)
{
conn_again:
if((connfd = serv_accept(listenfd, &uid)) < 0)
{
if(connfd == -1)
{
int errsv = errno;
/* EINTR为4，表示被信号中断，EAGAIN为11，
表示设置了O_NONBLOCK同时没有连接被请
求。两个宏定义在同一个文件
asm-generic/errno-base.h中 */
if((errsv == EINTR) || (errsv == ECONNABORTED))
{
printf("serv_accept again...\n");
goto conn_again;
}
else
{
printf("errno = %d,", errsv);
errno = errsv;
perror("accept error");
exit(1);
}
}
else if(connfd == -2)
{
perror("stat error");
exit(1);
}
else if(connfd == -3)
{
perror("it's not a real socket file");
exit(1);
}
}
while(1)
{
if((n = read(connfd, buf, 4096)) == -1)
{
perror("read connfd error");
exit(1);
}
else if(n == 0)
{
//对端关闭
close(connfd);
break;
}
else
{
if(((strcmp(buf,"getpic") == 0) && (strlen(buf) == 6)) || ((strcmp(buf,"flush") == 0) && (strlen(buf) == 5 )))
{
((MainForm *)a)->pic->valchanged = 1;
}
if((strcmp(buf,"getpic") != 0))
((MainForm *)a)->message->setMsg(QString::fromUtf8(buf));
memset(buf, 0, sizeof(buf));
}
}
}
}
void loop(void)
{
int i,n, maxfd,maxi, listenfd, clifd, nread;
char buf[MAXLENLINE];
uid_t uid;
fd_set rset, allset;
FD_ZERO(&allset);
if((listenfd = serv_listen(CS_OPEN)))
{
//log_sys("serv_listen error");
}
FD_SET(listenfd, &allset);
maxfd = listenfd;
maxi = -1;
for ( ; ; )
{
rset = allset;
if ((n=select(maxfd+1, &rset, NULL, NULL, NULL)) < 0)
{
//log_sys("select error");
}
if (FD_ISSET(listenfd, &rset))
{
if((clifd = serv_accept(listenfd, &uid)) < 0)
{
//log_sys("serv_accept error: %d", clifd);
}
i = client_add(clifd, uid);
FD_SET(clifd, &allset);
if (clifd > maxfd)
{
maxfd = clifd;
}
if (i > maxi)
{
maxi = i;
}
//log_msg("new connection: uid %d, fd %d", uid, clifd);
}
else
{
for (i = 0; i <= maxi; i++)
{
if ((clifd = client[i].fd) < 0)
{
continue;
}
if (FD_ISSET(clifd, &rset))
{
if ((nread = read(clifd, buf, MAXLENLINE)) < 0)
{
//log_sys("read error on fd: %d",clifd);
}
else if(nread == 0)
{
//log_msg("closed: uid %d, fd %d",client[i].uid, clifd);
client_del(clifd);
FD_CLR(clifd,&allset);
close(clifd);
}
else
{
handle_request(buf, nread, clifd, client[i].uid);
}
}
}
}
}
}
void loop2(void)
{
int i, listenfd, clifd, nread;
char buf[MAXLENLINE];
uid_t uid;
struct pollfd *pollfd = NULL;
int numfd = 1;
pollfd_wrap *pfd_wrap;
struct pollfd *default_pfd;
default_pfd->fd = -1;
default_pfd->events = POLLIN;
default_pfd->events = 0;
pfd_wrap->pfd = default_pfd;
pfd_wrap->maxfd = NALLOC;
pollfd_init(pfd_wrap, default_pfd);
pollfd = pfd_wrap->pfd;
int maxfd = pfd_wrap->maxfd;
if ((listenfd = serv_listen(CS_OPEN)) < 0)
{
//log_sys("serv_listen error");
}
client_add(listenfd, 0);
pollfd[0].fd = listenfd;
for (;;)
{
if (poll(pollfd, numfd, -1) < 0)
{
//log_sys("poll error");
}
if (pollfd[0].revents & POLLIN)
{
if ((clifd = serv_accept(listenfd, &uid)) < 0)
{
//log_sys("serv_accept error: %d", clifd);
}
client_add(clifd,uid);
if (numfd == pfd_wrap->maxfd)
{
default_pfd->fd = -1;
pollfd_alloc(pfd_wrap, default_pfd);
}
else
{
default_pfd->fd = clifd;
pollfd_add(pfd_wrap, default_pfd);
}
pollfd = pfd_wrap->pfd;
pollfd[numfd].fd = clifd;
pollfd[numfd].events = POLLIN;
pollfd[numfd].revents = 0;
numfd++;
//log_msg("new connection: uid %d, fd %d, uid, clifd");
}
for (i = 1; i < numfd; i++)
{
if (pollfd[i].revents & POLLHUP)
{
goto hungup;
}
else if(pollfd[i].revents & POLLIN)
{
if ((nread = read(pollfd[i].fd, buf, MAXLENLINE)) < 0)
{
//log_sys("read error on fd %d",pollfd[i].fd);
}
else if(nread == 0)
{
hungup:
//log_msg("closed: fd %d", pollfd[i].fd);
client_del(pollfd[i].fd);
close(pollfd[i].fd);
//pack the pollfd
//TODO there is a drawback, if you allocate
//many pollfds, it cannot be released if you
//needn't them;
if (i < (numfd-1))
{
pollfd[i].fd = pollfd[numfd-1].fd;
pollfd[i].events = pollfd[numfd-1].events;
pollfd[i].revents = pollfd[numfd-1].revents;
i--;
}
numfd--;
}
else
{
handle_request(buf, nread, pollfd[i].fd,client[i].uid);
}
}
}
}
}
/*
* === FUNCTION ======================================================================
* Name: listenout
* Author: Chenzhi Xu
* Created: 11/19/15 14:29:29
* Description: 侦听外部来报
* 当和外部使用中间件时，此函数接收来自中间件的数据
* 将数据传给儿子，由儿子处理数据，父亲只负责接收数据
* =====================================================================================
*/
int listenout()
{
struct addrinfo *ailist;
struct sockaddr_in addr;
struct sockaddr *addrp;
int socktype;
socklen_t addrlen;
int listensockfd;
int listenunixfd;
int nzero;
char *host;
#if defined(NZERO)
nzero=NZERO;
#elif defined(_SC_NZERO)
nzero=sysconf(_SC_NZERO);
#else
#error NZERO undefined
#endif
/* 获取本机主机名 */
if( (host=getmyname( )) == NULL )
err_sys( "get host name err" );
printf("%s%s\n", AT, host);
/* 根据主机名和端口号初始化sockaddr结构 */
// preconnect( host, "12344", SOCK_STREAM, &ailist );
// addrlen=ailist->ai_addrlen;
// /* 直接取第一条记录 不考虑匹配多条的情况 */
// memcpy( &addr, ailist->ai_addr, addrlen );
// socktype=ailist->ai_socktype;
// free( host );
// host = NULL;
// freeaddrinfo( ailist );
// printf("%hu\n", ntohs((( struct sockaddr_in * )( ailist->ai_addr ))->sin_port));
// struct in_addr saddr;
// saddr=(( struct sockaddr_in * )( ailist->ai_addr ))->sin_addr;
// struct sockaddr a;
// a=*( ailist->ai_addr );
// printf("AF_INET %d %d\n", a.sa_family, AF_INET);
/* sock套接字 侦听内部其他系统的数据
* 外部使用中间件 中间件进程和此进程使用unix域套接字通讯
*/
memset( &addr, 0x00, sizeof(addr) );
addr.sin_family = AF_INET;
addr.sin_port = htons(12344);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addrlen=sizeof(struct sockaddr);
addrp=(struct sockaddr *)&addr;
/* 绑定端口 声明最大连接数 */
if ( ( listensockfd = initserver( SOCK_STREAM, addrp, addrlen, 100 ) ) < 0 )
{
err_sys( "initserver err" );
}
zl_connect_out_func( addrp );
/* 打开及设置keepalive内容 */
SocketKeepalive( listensockfd );
/* unix域套接字 */
if ((listenunixfd=serv_listen(UNIXFILE))<0)
{
printf("%s%d %s\n",AT, listenunixfd, strerror(errno));
err_sys("serv_listen error");
}
/* 设置执行时关闭 */
set_cloexec( listensockfd );
set_cloexec( listenunixfd );
/* 设置进程优先级 */
// ni=getpriority(PRIO_PROCESS,0);
// printf("%s,now nice=%d\n", AT, ni);
//#ifndef Darwin
nice(nzero/2);
//#endif
// setpriority(PRIO_PROCESS,0,nzero);
printf("%snice=%d\n", AT, getpriority(PRIO_PROCESS,0));
// printf("%s,sockfd=%d unixfd=%d\n", AT, listensockfd, listenunixfd);
if( SelectAndHandle( listensockfd, listenunixfd ) != 0 )
err_msg( "handle err" );
close( listensockfd );
close( listenunixfd );
return 0;
}
void
loop(void)
{
int i, listenfd, clifd, nread;
char buf[MAXLINE];
uid_t uid;
struct pollfd *pollfd;
int numfd = 1;
int maxfd = NALLOC;
if ((pollfd = malloc(NALLOC * sizeof(struct pollfd))) == NULL)
err_sys("malloc error");
for (i = 0; i < NALLOC; i++) {
pollfd[i].fd = -1;
pollfd[i].events = POLLIN;
pollfd[i].revents = 0;
}
/* obtain fd to listen for client requests on */
if ((listenfd = serv_listen(CS_OPEN)) < 0)
log_sys("serv_listen error");
client_add(listenfd, 0); /* we use [0] for listenfd */
pollfd[0].fd = listenfd;
for ( ; ; ) {
if (poll(pollfd, numfd, -1) < 0)
log_sys("poll error");
if (pollfd[0].revents & POLLIN) {
/* accept new client request */
if ((clifd = serv_accept(listenfd, &uid)) < 0)
log_sys("serv_accept error: %d", clifd);
client_add(clifd, uid);
/* possibly increase the size of the pollfd array */
if (numfd == maxfd)
pollfd = grow_pollfd(pollfd, &maxfd);
pollfd[numfd].fd = clifd;
pollfd[numfd].events = POLLIN;
pollfd[numfd].revents = 0;
numfd++;
log_msg("new connection: uid %d, fd %d", uid, clifd);
}
for (i = 1; i < numfd; i++) {
if (pollfd[i].revents & POLLHUP) {
goto hungup;
} else if (pollfd[i].revents & POLLIN) {
/* read argument buffer from client */
if ((nread = read(pollfd[i].fd, buf, MAXLINE)) < 0) {
log_sys("read error on fd %d", pollfd[i].fd);
} else if (nread == 0) {
hungup:
/* the client closed the connection */
log_msg("closed: uid %d, fd %d",
client[i].uid, pollfd[i].fd);
client_del(pollfd[i].fd);
close(pollfd[i].fd);
if (i < (numfd-1)) {
/* pack the array */
pollfd[i].fd = pollfd[numfd-1].fd;
pollfd[i].events = pollfd[numfd-1].events;
pollfd[i].revents = pollfd[numfd-1].revents;
i--; /* recheck this entry */
}
numfd--;
} else { /* process client's request */
handle_request(buf, nread, pollfd[i].fd,
client[i].uid);
}
}
}
}
}
