int
main(int argc, char **argv)
{
int listenfd, i;
socklen_t addrlen;
void sig_int(int);
pid_t child_make(int, int, int);
if (argc == 3)
listenfd = Tcp_listen(NULL, argv[1], &addrlen);
else if (argc == 4)
listenfd = Tcp_listen(argv[1], argv[2], &addrlen);
else
err_quit("usage: serv03 [ <host> ] <port#> <#children>");
nchildren = atoi(argv[argc-1]);
pids = Calloc(nchildren, sizeof(pid_t));
cptr = meter(nchildren);
my_lock_init("/tmp/lock.XXXXXX"); /* one lock file for all children */
for (i = 0; i < nchildren; i++)
pids[i] = child_make(i, listenfd, addrlen); /* parent returns */
Signal(SIGINT, sig_int);
for ( ; ; )
pause(); /* everything done by children */
}
void child_main_loop(void)
{
unsigned int i;
int connfd;
unsigned int busy = 1;
while(1){
if(QUIT) return;
socklen_t size = sizeof(struct sockaddr_in);
struct sockaddr_in their_addr;
connfd = Accept(listenfd, (struct sockaddr*)&their_addr, &size);
while(1){
for(i = 0; i != CHILD_MAXCLIENTS; i++){
struct child_s child = child_ptr[i];
if(child.status == T_WAITING){
child.status = T_CONNECTED;
child.connfd = connfd;
child_ptr[i] = child;
child_make(&child_ptr[i]);
busy = 0;
break;
}
}
if(!busy) break;
}
}
}
int main(int argc, char *argv[])
{
int listenfd , i;
socklen_t addrlen;
void sig_int(int);
pid_t child_make(int,int,int);
if(argc == 3)
listenfd = Tcp_listen(NULL, argv[1], &addrlen);
else if(argc == 4)
listenfd = Tcp_listen(argv[1], argv[2], &addrlen);
else
err_quit("usage: serv02 [<host>] <port#> <#children>");
nchildren = atoi(argv[argc-1]);
pids = (pid_t*)Calloc(nchildren, sizeof(pid_t));
cptr = meter(nchildren);
for (i = 0; i < nchildren; ++i)
{
/* code */
pids[i] = child_make(i, listenfd, addrlen);
}
Signal(SIGINT, sig_int);
for(;;)
pause();
}
int main()
{
int sock, i;
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons(PORT);
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) <0 )
{
err_exit("socket _failed");
}
if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
{
err_exit("bind failed");
}
if (listen(sock, 5) < 0)
{
err_exit("listen failed");
}
for (i = 0; i < COUNT; i++)
{
child_make(sock, sizeof(addr));
}
}
int main(int argc, char **argv)
{
int listenfd, i;
socklen_t addrlen;
void sig_int(int);
pid_t child_make(int, int, int);
if (argc == 3) {
listenfd = tcp_listen(NULL, argv[1], &addrlen);
} else if (argc == 4) {
listenfd = tcp_listen(argv[1], argv[2], &addrlen);
} else {
err_quit("usage: serv02m [ <host> ] <port#> <#children>");
}
nchildren = atoi(argv[argc-1]);
pids = (pid_t *) calloc(nchildren, sizeof(pid_t));
cptr = meter(nchildren);
for (i = 0; i < nchildren; i++) {
pids[i] = child_make(i, listenfd, addrlen); // parent returns
}
signal(SIGINT, sig_int);
for ( ; ; ) {
pause(); // everything done by children
}
}
int main(int argc, char * argv[]) {
int listenfd;
int num;
int i;
if (argc < 2) {
print_usage();
}
num = atoi(argv[1]);
idle_num = num;
fprintf(stdout, "%d Channels are running ... \n", num);
//to lock the log file
lock_init(LOG_LOCK);
listenfd = init_server();
pids = (pid_t *)(malloc(sizeof(pid_t) * num));
for (i = 0; i < num; i++) {
pids[i] = child_make(i, listenfd);
}
signal_wrapper(SIGINT, sig_int);
close_wrapper(listenfd);
while(true)
pause();
return 0;
}
int
main(int argc, char **argv)
{
int listenfd, i;
socklen_t addrlen;
void sig_int(int);
pid_t child_make(int, int, int);
if (argc == 3)
listenfd = Tcp_listen(NULL, argv[1], &addrlen);
else if (argc == 4)
listenfd = Tcp_listen(argv[1], argv[2], &addrlen);
else
err_quit("usage: ./server_prefork_meter [ <host> ] <port#> <#children>");
nchildren = atoi(argv[argc-1]);
pids = calloc(nchildren, sizeof(pid_t));
cptr = meter(nchildren);
if(pids == NULL)
{
err_sys("calloc");
}
for (i = 0; i < nchildren; i++)
pids[i] = child_make(i, listenfd, addrlen); /* parent returns */
if (signal(SIGINT, sig_int) == SIG_ERR)
perror("signal SIGINT");
for ( ; ; )
pause(); /* everything done by children */
}
int
main(int argc, char **argv)
{
int listenfd, i;
socklen_t addrlen;
void sig_int(int);
pid_t child_make(int, int, int);
if (argc == 3) {
listenfd = tcp_listen(NULL, argv[1], &addrlen);
} else if (argc == 4) {
listenfd = tcp_listen(argv[1], argv[2], &addrlen);
} else {
fprintf(stderr, "usage: serv02 [ <host> ] <port#> <#children>\n");
exit(1);
}
nchildren = atoi(argv[argc-1]);
if ((pids = calloc(nchildren, sizeof(pid_t))) == NULL) {
perror("calloc error");
exit(1);
}
for (i = 0; i < nchildren; i++)
pids[i] = child_make(i, listenfd, addrlen); /* parent returns */
if (signal(SIGINT, sig_int) == SIG_ERR) {
perror("signal error");
exit(1);
}
for ( ; ; )
pause(); /* everything done by children */
}
int main(int argc, char const *argv[])
{
int i;
pids = (pid_t *)calloc(NCHILD,sizeof(pid_t));
for (i = 0; i < NCHILD; ++i)
{
pids[i] = child_make();
}
printf("pid = %d, ppid = %d\n", getpid(),getppid());
return 0;
}
int main(int argc, char* argv[])
{
int iListenFd;
sockaddr_in oBindAddr;
sockaddr_in oCliAddr;
socklen_t clilen;
if (argc < 2)
{
printf("usage:Serv00 <port> <children>\n");
return -1;
}
printf("argc =%d\n", argc);
oBindAddr.sin_family = AF_INET;
oBindAddr.sin_port = htons(atoi(argv[1]));
oBindAddr.sin_addr.s_addr = 0;
iListenFd = socket(AF_INET, SOCK_STREAM, 0);
int iRet = bind(iListenFd,(struct sockaddr*) &oBindAddr, sizeof(oBindAddr));
if (iRet != 0)
{
printf("bind error!\n");
return -1;
}
listen(iListenFd, 1024);
clilen = sizeof(oCliAddr);
iChildren= atoi(argv[2]);
tChildPid = (pid_t*)malloc( iChildren * sizeof(pid_t));
cptr = meter(iChildren);
printf("port=%d, children num=%d\n", oBindAddr.sin_port, iChildren);
for (int i = 0; i < iChildren; i++)
{
tChildPid[i] = child_make(i, iListenFd, clilen);
}
signal(SIGINT, sig_int);
signal(SIGUSR1, sig_usr1);
//signal(SIGCHLD, sig_chld);
for(; ;)
{
pause();
}
}
int
main(int argc, char *argv[])
{
int listenfd, i;
socklen_t addrlen;
void sig_int(int);
pid_t child_make(int, int,int);
void my_lock_init(char *);
void my_lock_wait();
void my_lock_release();
if (argc == 3) {
listenfd = Tcp_listen(NULL, argv[1], &addrlen);
}
if (argc == 4) {
listenfd = Tcp_listen(argv[1], argv[2], &addrlen);
}
if (argc != 3 && argc != 4) {
err_quit("usage: prefork_server01 [<host>] <port#> <#children>");
}
nchildren = atoi(argv[argc-1]);
pids = Calloc(nchildren, sizeof(pid_t));
my_lock_init("/tmp/lock.XXXXXX");
for (i=0 ;i < nchildren ;i++ ) {
pids[i] = child_make(i, listenfd, addrlen);
}
Signal(SIGINT, sig_int);
for ( ; ; ) {
pause(); /* 実際の処理は子プロセスが行う */
}
return 0;
}
void mpm_prefork()
{
int listenfd, i;
char listen[6];
sprintf(listen, "%d", config->Listen);
socklen_t addrlen;
void sig_int(int);
pid_t child_make(int, int, int);
listenfd = Tcp_listen(NULL, listen, &addrlen);
nchildren = config->StartServers;
pids = calloc(nchildren, sizeof(pid_t));
my_lock_init("/tmp/lock.server");
for (i = 0; i < nchildren; i++)
pids[i] = child_make(i, listenfd, addrlen);
Signal(SIGTERM, sig_int);
for ( ; ; )
pause();
}
int
main(int argc, char **argv)
{
int listenfd, i, navail, maxfd, nsel, connfd, rc;
void sig_int(int);
pid_t child_make(int, int, int);
ssize_t n;
fd_set rset, masterset;
socklen_t addrlen, clilen;
struct sockaddr *cliaddr;
if (argc == 3)
listenfd = Tcp_listen(NULL, argv[1], &addrlen);
else if (argc == 4)
listenfd = Tcp_listen(argv[1], argv[2], &addrlen);
else
err_quit("usage: serv05 [ <host> ] <port#> <#children>");
FD_ZERO(&masterset);
FD_SET(listenfd, &masterset);
maxfd = listenfd;
cliaddr = Malloc(addrlen);
nchildren = atoi(argv[argc-1]);
navail = nchildren;
cptr = Calloc(nchildren, sizeof(Child));
/* 4prefork all the children */
for (i = 0; i < nchildren; i++) {
child_make(i, listenfd, addrlen); /* parent returns */
FD_SET(cptr[i].child_pipefd, &masterset);
maxfd = max(maxfd, cptr[i].child_pipefd);
}
Signal(SIGINT, sig_int);
for ( ; ; ) {
rset = masterset;
if (navail <= 0)
FD_CLR(listenfd, &rset); /* turn off if no available children */
nsel = Select(maxfd, &rset, NULL, NULL, NULL);
/* 4check for new connections */
if (FD_ISSET(listenfd, &rset)) {
clilen = addrlen;
connfd = Accept(listenfd, cliaddr, &clilen);
for (i = 0; i < nchildren; i++)
if (cptr[i].child_status == 0)
break; /* available */
if (i == nchildren)
err_quit("no available children");
cptr[i].child_status = 1; /* mark child as busy */
cptr[i].child_count++;
navail--;
n = Write_fd(cptr[i].child_pipefd, "", 1, connfd);
Close(connfd);
if (--nsel == 0)
continue; /* all done with select() results */
}
/* 4find any newly-available children */
for (i = 0; i < nchildren; i++) {
if (FD_ISSET(cptr[i].child_pipefd, &rset)) {
if ( (n = Read(cptr[i].child_pipefd, &rc, 1)) == 0)
err_quit("child %d terminated unexpectedly", i);
cptr[i].child_status = 0;
navail++;
if (--nsel == 0)
break; /* all done with select() results */
}
}
}
}
int main(int argc, char *argv[]) {
int sockfd, newsockfd, portno, clilen;
char buff[256], *ptr;
struct sockaddr_in serv_addr, cli_addr;
int n;
const int on = 1;
if (argc < 2) {
fprintf(stderr, "ERROR, no port provided\n");
}
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
perror("ERROR opening socket");
//setsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));
bzero((char *) &serv_addr, sizeof(serv_addr));
portno = atoi(argv[1]);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(portno); /// =htons(atoi(argv[1]));
//setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
perror("ERROR on binding");
exit(0);
}
listen(sockfd, 5);
int i;
pids = calloc(START_SERVERS, sizeof(pid_t));
for (i = 0; i < START_SERVERS; i++) {
pids[i] = child_make(i, sockfd, sizeof(serv_addr));
}
signal(SIGINT, sig_int);
for (;;) {
for(i=0;i<START_SERVERS;i++){
sleep(10);
int p;
int sockfd;
struct sockaddr_un servaddr;
sockfd = socket(AF_LOCAL, SOCK_STREAM,0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sun_family = AF_LOCAL;
char *unixpath[32];
sprintf(unixpath,"%d", pids[i]);
strcpy(servaddr.sun_path, unixpath);
connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr));
n = write(sockfd,"req",3);
//if (n < 0) printf("ERROR writing to socket\n");
bzero(buff,256);
n = read(sockfd,buff,255);
//if (n < 0) printf("ERROR reading from socket\n");
printf("Number of requests handled :%s\n",buff);
close(sockfd);
int req = atoi(buff);
if(req>=MAX_REQUEST_PER_CHILD){
kill(pids[i],SIGTERM);
printf("Killed process pid : %ld\n",pids[i]);
pids[i] = child_make(i, sockfd, sizeof(serv_addr));
sleep(10);
printf ("Started process pid: %ld\n",pids[i]);
}
}
pause();
}
}
int
main(int argc, char **argv)
{
int listenfd, n;
struct sockaddr_in servaddr;
void sig_chld(int);
void sig_int(int);
struct socket_fdinfo si;
if (argc != 4)
err_quit("Usage: %s <port> <#children> <#max>", basename(argv[0]));
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(atoi(argv[1]));
Bind(listenfd, (SA *) & servaddr, sizeof(servaddr));
Listen(listenfd, LISTENQ);
maxconn = atoi(argv[3]);
Pch = Calloc(maxconn, sizeof(struct child));
if ((nchildren = mmap(0, sizeof(int),
PROT_READ | PROT_WRITE,
MAP_ANON | MAP_SHARED, -1, 0)) == MAP_FAILED)
err_sys("mmap error");
if ((Pstat = mmap(0, sizeof(long) * maxconn,
PROT_READ | PROT_WRITE,
MAP_ANON | MAP_SHARED, -1, 0)) == MAP_FAILED)
err_sys("mmap error");
minconn = *nchildren = atoi(argv[2]);
if ((lock_fd = open("/tmp/lock.fd", O_WRONLY|O_CREAT|O_TRUNC, 0644)) < 0)
err_sys("open lock_fd error");
if (unlink("/tmp/lock.fd") < 0)
err_sys("unlink error");
#if 0
Signal(SIGCHLD, sig_chld); /* must call waitpid() */
#endif
_signal(SIGTERM, sig_term);
int i, nsel;
fd_set masterset, rset;
FD_ZERO(&masterset);
FD_SET(listenfd, &masterset);
for (i = 0; i < *nchildren; i++) {
/* parent prefork children */
child_make(i, listenfd);
#if (_DEBUG)
printf("%d status: %d\n", i, Pch[i].child_status);
#endif
}
_signal(SIGINT, _sig_int);
_signal(SIGCHLD, sig_chld);
for (;;) {
rset = masterset;
if ((nsel = select(listenfd+1, &rset, NULL, NULL, NULL)) < 0) {
if (errno == EINTR)
continue;
else
err_sys("select error");
} else if (nsel == 0) { /* _no_ need */
err_msg("select timeout");
continue;
}
if ((n = proc_pidfdinfo(getpid(), listenfd, PROC_PIDFDSOCKETINFO, &si, sizeof(si))) <= 0)
err_sys("proc_pidfdinfo error");
if (n < sizeof(si))
err_quit("proc_pidfdinfo failed");
/*
* struct socket_info {}
* soi_qlen: half-connction
* soi_incqlen: incoming-connection
* soi_rcv.sbi_cc: establish but not delivered connection
* soi_snd.sbi_cc: send but not delivered connection
*/
mode_lock_wait(lock_fd);
if (si.psi.soi_qlen + si.psi.soi_incqlen > 1 &&
*nchildren < maxconn && quitflag != 1)
#if 0
if (si.psi.soi_rcv.sbi_cc + si.psi.soi_snd.sbi_cc > 0 &&
*nchildren < maxconn && !quitflag)
#endif /* On BSD always 0 */
{
for (i = 0; i < maxconn; i++) {
if (Pch[i].child_status == 0)
break;
}
child_make(i, listenfd);
(*nchildren)++;
}
mode_lock_release(lock_fd);
}
exit(0);
}
/*
* Create a pool of children to handle incoming connections
*/
short int child_pool_create (void)
{
unsigned int i;
/*
* Make sure the number of MaxClients is not zero, since this
* variable determines the size of the array created for children
* later on.
*/
if (child_config.maxclients == 0) {
log_message (LOG_ERR,
"child_pool_create: \"MaxClients\" must be "
"greater than zero.");
return -1;
}
if (child_config.startservers == 0) {
log_message (LOG_ERR,
"child_pool_create: \"StartServers\" must be "
"greater than zero.");
return -1;
}
child_ptr =
(struct child_s *) calloc_shared_memory (child_config.maxclients,
sizeof (struct child_s));
if (!child_ptr) {
log_message (LOG_ERR,
"Could not allocate memory for children.");
return -1;
}
servers_waiting =
(unsigned int *) malloc_shared_memory (sizeof (unsigned int));
if (servers_waiting == MAP_FAILED) {
log_message (LOG_ERR,
"Could not allocate memory for child counting.");
return -1;
}
*servers_waiting = 0;
/*
* Create a "locking" file for use around the servers_waiting
* variable.
*/
_child_lock_init ();
if (child_config.startservers > child_config.maxclients) {
log_message (LOG_WARNING,
"Can not start more than \"MaxClients\" servers. "
"Starting %u servers instead.",
child_config.maxclients);
child_config.startservers = child_config.maxclients;
}
for (i = 0; i != child_config.maxclients; i++) {
child_ptr[i].status = T_EMPTY;
child_ptr[i].connects = 0;
}
for (i = 0; i != child_config.startservers; i++) {
DEBUG2 ("Trying to create child %d of %d", i + 1,
child_config.startservers);
child_ptr[i].status = T_WAITING;
child_ptr[i].tid = child_make (&child_ptr[i]);
if (child_ptr[i].tid < 0) {
log_message (LOG_WARNING,
"Could not create child number %d of %d",
i, child_config.startservers);
return -1;
} else {
log_message (LOG_INFO,
"Creating child number %d of %d ...",
i + 1, child_config.startservers);
SERVER_INC ();
}
}
log_message (LOG_INFO, "Finished creating all children.");
return 0;
}
/*
* Keep the proper number of servers running. This is the birth of the
* servers. It monitors this at least once a second.
*/
void child_main_loop (void)
{
unsigned int i;
while (1) {
if (config.quit)
return;
/* If there are not enough spare servers, create more */
SERVER_COUNT_LOCK ();
if (*servers_waiting < child_config.minspareservers) {
log_message (LOG_NOTICE,
"Waiting servers (%d) is less than MinSpareServers (%d). "
"Creating new child.",
*servers_waiting,
child_config.minspareservers);
SERVER_COUNT_UNLOCK ();
for (i = 0; i != child_config.maxclients; i++) {
if (child_ptr[i].status == T_EMPTY) {
child_ptr[i].status = T_WAITING;
child_ptr[i].tid =
child_make (&child_ptr[i]);
if (child_ptr[i].tid < 0) {
log_message (LOG_NOTICE,
"Could not create child");
child_ptr[i].status = T_EMPTY;
break;
}
SERVER_INC ();
break;
}
}
} else {
SERVER_COUNT_UNLOCK ();
}
sleep (5);
/* Handle log rotation if it was requested */
if (received_sighup) {
/*
* Ignore the return value of reload_config for now.
* This should actually be handled somehow...
*/
reload_config ();
#ifdef FILTER_ENABLE
filter_reload ();
#endif /* FILTER_ENABLE */
/* propagate filter reload to all children */
child_kill_children (SIGHUP);
received_sighup = FALSE;
}
}
}
int main(int argc, char* argv[])
{
int listenfd, i, navail, maxfd, nsel, connfd, rc;
void sig_int(int);
pid_t child_make(int,int,int);
ssize_t n;
fd_set rset, masterset;
socklen_t addrlen,clilen;
struct sockaddr* cliaddr;
listenfd = Tcp_listen(argv[1], argv[2], &addrlen);
FD_ZERO(&masterset);
FD_SET(listenfd, &masterset);
maxfd = listenfd;
cliaddr = Malloc(addrlen);
nchildren = atoi(argv[argc - 1]);
navail = nchildren;
cptr = Calloc(nchildren, sizeof(Child));
for (i = 0; i < nchildren; ++i)
{
child_make(i, listenfd, addrlen);
FD_SET(cptr[i].child_pipefd, &masterset);
maxfd = max(maxfd, cptr[i].child_pipefd);
}
Signal(SIGINT, sig_int);
for(;;){
rset = masterset ;
if(navail <= 0)
FD_CLR(listenfd, &rset);
nsel = Select(maxfd+1, &rset, NULL, NULL, NULL);
if(FD_ISSET(listenfd, &rset)){
clilen = addrlen;
connfd = Accept(listenfd, cliaddr, &clilen);
for (i = 0; i < nchildren; ++i)
{
if(cptr[i].child_status == 0)
break;
}
if(i == nchildren)
err_quit("no available children");
cptr[i].child_status = 1;
cptr[i].child_count++;
navail--;
n = Write_fd(cptr[i].child_pipefd, "", 1, connfd);
Close(connfd);
if(--nsel==0) continue;
}
for(i = 0; i <nchildren ;++i){
if(FD_ISSET(cptr[i].child_pipefd, &rset)){
if((n = Read(cptr[i].child_pipefd, &rc, 1)) == 0){
err_quit("child %d terminated unexpectd",i);
}
cptr[i].child_status = 0;
navail++;
if(--nsel ==0)break;
}
}
}
}
