ANMIAN

server.c

#include <sys/time.h>

#include <sys/types.h>

#include <unistd.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <sys/stat.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#define TIMEOUT 10       /* timeout : seconds */

#define FD_MAX_CLIENT 3

#define BUF_SIZE 1024

#define EXIT_STR "exit"

/*

 * error - wrapper for perror

 */

void error(char *msg) {

  perror(msg);

  exit(1);

}

int main(int argc, char **argv)

{

    int server_sockfd;

    int client_sockfd; 

    int max_fd;                     /* for using select */

    struct sockaddr_in serveraddr;

    struct sockaddr_in clientaddr;

    int clientlen;

    int client[FD_MAX_CLIENT];

    char buf[BUF_SIZE];          /* message buffer */

    int n; /* message byte size */

    struct timeval tv;

    fd_set readfds, temp_fds;

    int notdone;

    int i, ret;

    /* socket: create the parent socket  */

    server_sockfd = socket(AF_INET, SOCK_STREAM, 0);

    if (server_sockfd < 0) 

        error("ERROR opening socket");

    max_fd = server_sockfd;

    bzero((char*)&serveraddr, sizeof(serveraddr));

    serveraddr.sin_family = AF_INET;

    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);

    serveraddr.sin_port = htons(9000);

    if(bind(server_sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0)

        error("ERROR on binding");

    if(listen(server_sockfd, 5) < 0) /* allow 5 requests(backlog) to queue up */ 

        error("ERROR on listen");

    for (i = 0; i < FD_MAX_CLIENT; i++) {

        client[i] = -1;

    }

    /* initialize some things for the main loop */

    clientlen = sizeof(clientaddr);

    notdone = 1;

    printf("TCP Server Waiting ...\n");

    fflush(stdout);

    FD_ZERO(&readfds);          /* initialize the fd set */

    FD_SET(server_sockfd, &readfds); /* add socket fd */

    while(notdone)

    {

        temp_fds = readfds;

        tv.tv_sec = TIMEOUT;

        tv.tv_usec = 0;        

        ret = select(max_fd+1, &temp_fds, 0, 0, &tv);

        if (ret < 0)

          error("ERROR in select");

        else if(ret == 0)

        {

            printf("waiting...\n");

            continue;

        }

        if (FD_ISSET(server_sockfd, &temp_fds)) {

            /* accept: wait for a connection request */

            client_sockfd = accept(server_sockfd, (struct sockaddr *)&clientaddr, &clientlen);

            if(client_sockfd < 0)

                error("ERROR on accept");

            printf("connection from (%s , %d)\n", inet_ntoa(clientaddr.sin_addr),ntohs(clientaddr.sin_port));

            for (i = 0; i < FD_MAX_CLIENT; i++)

            {

                if (client[i] < 0) {

                    client[i] = client_sockfd;

                    printf("\nclient_idx=%d, client_sockfd=%d\n", i, client_sockfd);

                    break;

                }

            }

            if(i >= FD_MAX_CLIENT)

            {

                printf("too many clients. so, closing client fd[%d]\n", client_sockfd);

                close(client_sockfd);

                continue;

            }

            FD_SET(client_sockfd, &readfds); /* add socket fd */

            max_fd = (client_sockfd > max_fd)?(client_sockfd):(max_fd);

        }

        for (i = 0; i <= FD_MAX_CLIENT; i++)

        {

            if (client[i] < 0)

                continue;

            client_sockfd = client[i];

            if (FD_ISSET(client_sockfd, &temp_fds))

            {

                bzero(buf, BUF_SIZE);

                /* n = recv(client_sockfd, buf, BUF_SIZE, 0); */

                n = read(client_sockfd, buf, BUF_SIZE);

                if (n <= 0) {

                    printf("Close client_sockfd : %d", client_sockfd);

                    close(client_sockfd);

                    FD_CLR(client_sockfd, &readfds);

                    client[i] = -1;

                }

                printf("[%d]RECV %s\n", client_sockfd, buf);

                if(strncmp(buf,EXIT_STR,strlen(EXIT_STR)) == 0)

                {

                    notdone = 0;

                    break;

                }

                /* send(client_sockfd,buf,strlen(buf), 0); */

                write(client_sockfd, buf, strlen(buf));

                break;

            }

        }

    }

    /* clean up */

    printf("\nTerminating server.\n");

    close(server_sockfd);

    exit(0);

}

client.c

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <netinet/in.h>

#include <errno.h>

#include <netdb.h>

#define BUF_SIZE 1024

#define EXIT_STR "exit"

/* 

 * error - wrapper for perror

 */

void error(char *msg) {

    perror(msg);

    exit(0);

}

int main()

{

    int sockfd, n;

    char send_data[BUF_SIZE],recv_data[BUF_SIZE];

    struct hostent *host;

    struct sockaddr_in server_addr;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    if (sockfd < 0)

        error("ERROR opening socket");

    host = gethostbyname("127.0.0.1");

    if (host == NULL) 

        error("ERROR, no such host");

    bzero((char*) &server_addr, sizeof(server_addr));

    server_addr.sin_addr = *((struct in_addr *)host->h_addr);

    server_addr.sin_family = AF_INET;

    server_addr.sin_port = htons(9000);

    /* connect: create a connection with the server */

    if (connect(sockfd, (struct sockaddr *) &server_addr, sizeof(struct sockaddr)) < 0)

        error("ERROR connecting");

    while(1) {

        printf("Please enter msg: ");

        bzero(send_data, BUF_SIZE);

        fgets(send_data, sizeof(send_data), stdin);

        /*n = send(sockfd,send_data,strlen(send_data), 0);*/

        n = write(sockfd,send_data,strlen(send_data));

        if (n < 0) 

            error("ERROR writing to socket");

        if(strncmp(send_data , EXIT_STR, strlen(EXIT_STR)) == 0)

        {

            close(sockfd);

            break;

        }

        bzero(recv_data, BUF_SIZE);

        n = read(sockfd, recv_data, BUF_SIZE);

        /*n = recv(sockfd, recv_data, BUF_SIZE,0);*/

        if (n < 0) 

            error("ERROR reading from socket");

        printf("RECV = %s\n" , recv_data);

    }

    return 0;

}

poll.c

#include <stdio.h>

#include <unistd.h>

#include <sys/poll.h>

#define TIMEOUT 5000  /* msec */

int main(void)

{

    struct pollfd fds[2];

    int ret;

    /* waiting at stdin */

    fds[0].fd = STDIN_FILENO;

    fds[0].events = POLLIN;

    /* check to can write to stdout */

    fds[1].fd = STDOUT_FILENO;

    fds[1].events = POLLOUT;

    ret = poll(fds, 2, TIMEOUT);

    if(ret == -1)

    {

        perror("poll");

        return 1;

    }

    if(!ret)

    {

        printf("timeout : %d(ms)\n", TIMEOUT);

        return 0;

    }

    if(fds[0].revents & POLLIN)

        printf("stdin is readable\n");

    if(fds[1].revents & POLLOUT)

        printf("stdout is writable\n");

    return 0;

}

==========================================

$ ./poll

Stdout is wriable

$ ./poll < test.txt

Stdin is readable

Stdout is writable