서버 프로그램 종료시에

몇가지 방법이 있습니다.

1. 논블럭킹 소켓

/*
* do a non-blocking-accept
*
* tested with FreeBSD
*
* Steve Shah (sshah@planetoid.org)
*
*/

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#define NIPQUAD(addr) \
((unsigned char *)&addr)[0], \
((unsigned char *)&addr)[1], \
((unsigned char *)&addr)[2], \
((unsigned char *)&addr)[3]

int main (int argc, char *argv[])
{
struct sockaddr_in incoming_connection;
struct sockaddr_in bound_connection;
int incoming_fd;
int incoming_socket;
unsigned int incoming_connection_len;
struct protoent *tcp;
int port;
int errcode;
int i;
char buf[80];
int buflen;

/*
* Parse command line parameters
*
*/

if (argc < 2) {
printf ("Usage non-blocking-accept \n");
exit(0);
}

port = atoi(argv[1]);
if (port < 1024 || port > 65534) {
printf ("Port number is out of range.\n");
exit(0);
}

/*
* Get TCP's protocol number (needed for the socket() system call)
*
*/

tcp = getprotobyname("tcp");
if (tcp == NULL) {
printf ("Can't get protocol numbers for TCP\n");
exit(0);
}

/*
* Create a new socket
*
*/

incoming_socket = socket(AF_INET, SOCK_STREAM, tcp->p_proto);
if (incoming_socket < 0) {
printf ("Can't create a socket\n");
exit(0);
}

/*
* Bind to a specific port using the new socket
*
*/

bound_connection.sin_family = AF_INET;
bound_connection.sin_addr.s_addr = htonl(INADDR_ANY);
bound_connection.sin_port = htons(port);

/* Note that sockaddr_in is a internet interpretation of sockaddr */

errcode = bind(incoming_socket,
(struct sockaddr *)&bound_connection,
sizeof (struct sockaddr));
if (errcode < 0) {
printf ("Can't bind to port %d", port);
perror("");
exit(0);
}

/*
* Tell us how many incoming connections we can at most queue
*
*/

errcode = listen(incoming_socket, 128);
if (errcode == -1) {
perror ("Can't listen to bound socket");
exit(0);
}

/*
* Make socket non-blocking
*
*/

if (fcntl(incoming_socket, F_SETFL, O_NDELAY) < 0) {
perror("Can't set socket to non-blocking");
exit(0);
}

/*
* Enter the accept loop
*
*/

incoming_connection_len = sizeof(struct sockaddr_in);

do {
incoming_fd = accept(incoming_socket,
(struct sockaddr *)&incoming_connection,
&incoming_connection_len);
if (incoming_fd != -1) {
printf ("Accepted connection from %d.%d.%d.%d%d\n",
NIPQUAD(incoming_connection.sin_addr.s_addr),
ntohs(incoming_connection.sin_port));
for (i=10;i>=1;i--) {
buflen = snprintf (buf, 80, "%d\n", i);
write (incoming_fd, buf, buflen);
sleep(1);
}
close (incoming_fd);
} else {
printf ("Waiting for a connection...\n");
sleep(1);
}
} while (1);

return 0;
}

=========================================================================
2. multiplexing i/o를 사용해서 하는 방법
accept도 결국은 read이벤트에 걸리니까 select리턴 후
ISSET(listen_fd)를 걸었을때 이벤트가 있으면 accept 처리하면 됩니다.
select에서 일정 시간만큼 timeout을 걸어서 종료조건이 되면
서버를 종료 시킬 수 있습니다.

#include
#include
#include
#include
#include
#include
#define TRUE 1

/*
* This program uses select to check that someone is trying to connect
* before calling accept.
*/

main()
{
int sock, length;
struct sockaddr_in server;
int msgsock;
char buf[1024];
int rval;
fd_set ready;
struct timeval to;

/* Create socket. */
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
perror("opening stream socket");
exit(1);
}
/* Name socket using wildcards. */
server.sin_len = sizeof(server);
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = 0;
if (bind(sock, (struct sockaddr *)&server,
sizeof(server)) < 0) {
perror("binding stream socket");
exit(1);
}
/* Find out assigned port number and print it out. */
length = sizeof(server);
if (getsockname(sock, (struct sockaddr *)&server,
&length) < 0) {
perror("getting socket name");
exit(1);
}
printf("Socket port #%d\n", ntohs(server.sin_port));

/* Start accepting connections. */
listen(sock, 5);
do {
FD_ZERO(&ready);
FD_SET(sock, &ready);
to.tv_sec = 5;
if (select(sock + 1, &ready, (fd_set *)0,
(fd_set *)0, &to) < 0) {
perror("select");
continue;
}
if (FD_ISSET(sock, &ready)) {
msgsock = accept(sock, (struct sockaddr *)0,
(int *)0);
if (msgsock == -1)
perror("accept");
else do {
memset(buf, 0, sizeof(buf));
if ((rval = read(msgsock, buf, 1024)) < 0)
perror("reading stream message");
else if (rval == 0)
printf("Ending connection\n");
else
printf("-->%s\n", buf);
} while (rval > 0);
close(msgsock);
} else
printf("Do something else\n");
} while (TRUE);
exit(0);
}

=========================================================================
3. alarm을 사용해서 지정 시간동안 접속이 없으면 accept를
빠져나와서 다른 작업을 하고, 종료 조건이 아니면
다시 알람을 설정하고 잠들면 되겠죠.

/******************************************************************/
/* Include files */
/******************************************************************/
#include
#include
#include
#include
#include
#include
#include

/******************************************************************/
/* Signal catcher routine. This routine will be called when the */
/* signal occurs. */
/******************************************************************/
void catcher(int sig)
{
printf(" Signal catcher called for signal %d\n", sig);
}

/******************************************************************/
/* Main program */
/******************************************************************/
int main(int argc, char *argv[])
{
struct sigaction sact;
struct sockaddr_in addr;
time_t t;
int sd, rc;

/******************************************************************/
/* Create an AF_INET, SOCK_STREAM socket */
/******************************************************************/
printf("Create a TCP socket\n");
sd = socket(AF_INET, SOCK_STREAM, 0);
if (sd == -1)
{
perror(" socket failed");
return(-1);
}

/******************************************************************/
/* Bind the socket. A port number was not specified because */
/* we are not going to ever connect to this socket. */
/******************************************************************/
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
printf("Bind the socket\n");
rc = bind(sd, (struct sockaddr *)&addr, sizeof(addr));
if (rc != 0)
{
perror(" bind failed");
close(sd);
return(-2);
}

/******************************************************************/
/* Perform a listen on the socket. */
/******************************************************************/
printf("Set the listen backlog\n");
rc = listen(sd, 5);
if (rc != 0)
{
perror(" listen failed");
close(sd);
return(-3);
}

/******************************************************************/
/* Set up an alarm that will go off in 5 seconds. */
/******************************************************************/
printf("\nSet an alarm to go off in 5 seconds. This alarm will cause the\n");
printf("blocked accept() to return a -1 and an errno value of EINTR.\n\n");
sigemptyset(&sact.sa_mask);
sact.sa_flags = 0;
sact.sa_handler = catcher;
sigaction(SIGALRM, &sact, NULL);
alarm(5);

/******************************************************************/
/* Display the current time when the alarm was set */
/******************************************************************/
time(&t);
printf("Before accept(), time is %s", ctime(&t));

/******************************************************************/
/* Call accept. This call will normally block indefinitely, */
/* but because we have an alarm set, it will only block for */
/* 5 seconds. When the alarm goes off, the accept call will */
/* complete with -1 and an errno value of EINTR. */
/******************************************************************/
errno = 0;
printf(" Wait for an incoming connection to arrive\n");
rc = accept(sd, NULL, NULL);
printf(" accept() completed. rc = %d, errno = %d\n", rc, errno);
if (rc >= 0)
{
printf(" Incoming connection was recevied\n");
close(rc);
}
else
{
perror(" errno string");
}

/******************************************************************/
/* Show what time it was when the alarm went off */
/******************************************************************/
time(&t);
printf("After accept(), time is %s\n", ctime(&t));
close(sd);
return(0);
}