석수코딩교육

#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <string.h>

#define MAXLINE 9999
#define MAX_SOCK 128

int main(int argc, char *argv[]) 
{
FILE *fp=NULL;

char line[MAXLINE], message[MAXLINE+1], filename[MAXLINE+1];
struct sockaddr_in server_addr;
int maxfdp1;
int ____socket; /* 서버와 연결된 소켓번호 */
fd_set read_fds;

int kk=0;

if (argc != 4) {

printf("Usage : %s server_ip port filename\n", argv[0]);

printf("%s 127.0.0.1 12572 /usr2/suksu/ftp/BATCH_A0011.dat\n", argv[0]);

exit(0);
}

sprintf(filename, "%s", argv[3]);
if((fp=fopen(filename, "rt"))==NULL) exit(0);

/* 소켓 생성 */
if ((____socket = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
printf("Client: Can't open stream socket.\n");
exit(0);
}

/* 채팅 서버의 소켓주소 구조체 server_addr 초기화 */
bzero((char *)&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr(argv[1]);
server_addr.sin_port = htons(atoi(argv[2]));

/* 연결요청 */
if (connect(____socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
printf("Client: Can't connect to server.\n");
exit(0);
} 
else 
{
    printf("Connected with server succ!!\n");
}

while (1) 
{
memset(line,0x00,sizeof(line));
if(fgets(line,sizeof(line),fp)==NULL) break;

line[strlen(line)-1]=0x00;

if (send(____socket, line, strlen(line), 0) < 0) 
{
printf("Client: Write error on socket.\n");
break;
}
//printf("%s\n", line);

usleep(4444);
kk++;
}

close(____socket);
if(fp != NULL) fclose(fp);

printf("FileName[%s] :[%05d]\n", filename, kk);
}

#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/socket.h>
#include <sys/file.h>
#include <netinet/in.h>
#include <string.h>

#define MAXLINE 99999
#define MAX_SOCK 64

int getmax(int);
void disconnect_client(int); /* 채팅 탈퇴 처리 함수 */
void my_signal(int signo); /* 새로운 시그널 처리 함수 선언 */

int maxfdp1;            /* 최대 소켓번호+1 */
int num_chat = 0;       /* 채팅 참가자 수 */
int ____main_socket;                  /* 초기 소켓 */
int ____client_socket[MAX_SOCK]; /* 채팅에 참가자 소켓번호 목록 */

int main(int argc, char *argv[]) 
{
char rline[MAXLINE+1];
int i, j, kk;
int recv_len;
int client_fd, clilen;

int recv_len_sum=0;
int recv_seq_sum=0;
int recv_divide;


fd_set read_fds; /* 일기 감지할 소켓번호 구조체 */
struct sockaddr_in client_addr, server_addr;

if (argc != 2) {
printf("Usage: %s port\n", argv[0]);
exit(0);
}

/* 초기소켓 생성 */
if ((____main_socket = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
printf("Server: Can't open stream socket.");
exit(0);
}

/* server_addr 구조체의 내용 세팅 */
bzero((char *)&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(atoi(argv[1]));

if (bind(____main_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
printf("Server: Can't bind local address.\n");
exit(0);
}

if (signal(SIGINT, my_signal) == SIG_ERR) { /* Ctrl+C */
printf("Server: signal(SIGINT) error\n");
exit(0);
}
if (signal(SIGTERM, my_signal) == SIG_ERR) { /* software termination */
printf("Server: signal(SIGTERM) error\n");
exit(0);
}
if (signal(SIGQUIT, my_signal) == SIG_ERR) { /* Ctrl+\ */
printf("Server: signal(SIGQUIT) error\n");
exit(0);
}


/* 클라이언트로부터 연결요청을 기다림 */
listen(____main_socket, 5); /* backlog = 5 */

maxfdp1 = ____main_socket + 1; /* 최대 소켓번호+1 */

while (1) 
{
FD_ZERO(&read_fds);
FD_SET(____main_socket, &read_fds);
for (kk=0; kk < num_chat; kk++)
{
    FD_SET(____client_socket[kk], &read_fds);
}

maxfdp1 = getmax(____main_socket) + 1; /* maxfdp1 재 계산 */

if (select(maxfdp1, &read_fds, (fd_set *)0, (fd_set *)0, (struct timeval *)0) < 0) {
printf("Server: select error <= 0\n");
break;
}

if (FD_ISSET(____main_socket, &read_fds)) 
{
clilen = sizeof(client_addr);
client_fd = accept(____main_socket, (struct sockaddr *)&client_addr, &clilen);
if (client_fd == -1) 
{
    printf("Server: accept error\n");
    break;
    }

    ____client_socket[num_chat] = client_fd;
    num_chat++;
}

for (kk=0; kk < num_chat; kk++) 
{
if (FD_ISSET(____client_socket[kk], &read_fds)) 
{
if ((recv_len = recv(____client_socket[kk], rline, MAXLINE, 0)) <= 0) 
{
disconnect_client(kk); /* abrupt exit */
continue;
}
rline[recv_len] = '\0';

            recv_divide = recv_len / getfromframeid(rline, recv_len);
recv_seq_sum++;
recv_len_sum = recv_len_sum + recv_divide;

printf("SESSION SEQ[%07d]/RECV LENGTH[%07d]/DIVIDE[%07d]/REAL SUM[%07d]/SEQ SUM[%07d]\n", 
                                        kk+1, recv_len,
recv_divide, recv_len_sum, recv_seq_sum);
}
}
} /* while */
my_signal(SIGIO);
}

/* 채팅 탈퇴 처리 */
void disconnect_client(int i) {
struct sockaddr_in client_addr;

close(____client_socket[i]);
if (i != num_chat-1)
____client_socket[i] = ____client_socket[num_chat-1];
num_chat--;

printf("[function]disconnect_client>>[%d]\n", num_chat);
}

/* ____client_socket[] 내의 최대 소켓번호 얻기(초기치는 k) */
int getmax(int k) {
int max = k;
int r;
for (r=0; r < num_chat; r++)
if (____client_socket[r] > max)
max = ____client_socket[r];
return max;
}

/* 시그널 처리 함수 정의 */
void my_signal(int signo) {
int i;

signal(SIGINT, SIG_IGN);
signal(SIGTERM, SIG_IGN);
signal(SIGQUIT, SIG_IGN);

/* 모든 열려있는 소켓을 닫는다 */
close(____main_socket);
for (i=0; i < num_chat; i++)
close(____client_socket[i]);

exit(0);
}

int getfromframeid(char *tmp, int len)
{
int kk=0;

if(memcmp(tmp, "A0011", 5) == 0) kk=800;

return kk;
}

/*

gcc -o w_send w_send.c -lwsock32 -Wall -DTEST_PRINTF

gcc -o w_send w_send.c -lwsock32 -Wall -DTEST_PRINTF

gcc -o w_send w_send.c -lwsock32 -Wall -DTEST_PRINTF

gcc -o w_send w_send.c -lwsock32 -Wall -DTEST_PRINTF

gcc -o w_send w_send.c -lwsock32 -Wall -DTEST_PRINTF

gcc -o w_send w_send.c -lwsock32 -Wall -DTEST_PRINTF

*/

#include  <WinSock2.h>
#include  <windows.h>
#include  <stdio.h>
#include  <stdlib.h>
#include  <string.h>
#include  <time.h>

#define  MAXLINE 4096

DWORD WINAPI stdin_input_send_thread(LPVOID arg);

FILE *fp=NULL;
FILE *stream=NULL;
char line[MAXLINE], chatdata[MAXLINE+1];

struct sockaddr_in server_addr;
SOCKET clientsocket; //server connect socket
char *escape = "quit"; //exit command message
BOOL bisquit;           //exit falg variable

int main(int argc, char *argv[])
{
    WSADATA wsa;    //socket
    HANDLE hthread; //thread
    DWORD threadid;
    int size;

    if (argc != 4) 
    {
        printf("usage : %s server_address port filename\n", argv[0]);
        return(-1);
    }
    bisquit = FALSE;

    //socket initialization
    if (WSAStartup(MAKEWORD(2,2), &wsa) != 0) 
    {
        return(-2);
    }
    //socket creation
    if ((clientsocket = socket(AF_INET, SOCK_STREAM, 0)) < 0) 
    {
        printf("fail make socket\n");
        return(-3);
    }

    //memory initialization
    memset(&server_addr, 0x00, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr(argv[1]);
    server_addr.sin_port = htons(atoi(argv[2]));

    //connection with server
    if (connect(clientsocket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) 
    {
        printf("fail connect to server\n");
        return(-4);
    }

    if((fp = fopen(argv[3], "rt"))==NULL)
    {
        printf("fopen error(%s)\n", argv[3]);
        return(-5);
    }

if((stream = fopen("KRX_SEND.dat", "wt"))==NULL)
    {
        printf("fopen error(%s)\n", argv[3]);
        return(-5);
    }

    hthread = CreateThread(NULL, 0, stdin_input_send_thread, 0, 0, &threadid);
    if (hthread == NULL) 
    {
        printf("fail make thread\n");
    }
    else 
    {
        CloseHandle(hthread);
    }

    while (!bisquit) 
    {
        memset(chatdata, 0x00, sizeof(chatdata));

        if ((size = recv(clientsocket, chatdata, MAXLINE, 0)) == INVALID_SOCKET) 
        {
            break;
        }
        else 
        {
            chatdata[size] = '\0';
            printf("(RECV)%s", chatdata);
fprintf(stream, "%s", chatdata);
        }
    }
    closesocket(clientsocket);
    WSACleanup();

    if(fp != NULL) fclose(fp);
if(stream != NULL) fclose(stream);

    return(0);
}

//user data input mechanism
DWORD WINAPI stdin_input_send_thread(LPVOID arg)
{
    char rbuf[MAXLINE];

    while(TRUE) 
    {
        memset(rbuf, 0x00, sizeof(rbuf));
        if(fgets(rbuf, sizeof(rbuf), fp) == NULL)
{
bisquit = TRUE;
break;
}

        printf("(SEND)%s", rbuf);

        if (send(clientsocket, rbuf, strlen(rbuf), 0) < 0) 
        {
            return(-2);
        }

        Sleep(50); //#include
    }

closesocket(clientsocket);
    return 0;
}

/*

gcc -o w_server w_server.c -lwsock32 -Wall -DTEST_PRINTF

gcc -o w_server w_server.c -lwsock32 -Wall -DTEST_PRINTF

gcc -o w_server w_server.c -lwsock32 -Wall -DTEST_PRINTF

gcc -o w_server w_server.c -lwsock32 -Wall -DTEST_PRINTF

*/

#include  <winsock2.h>
#include  <fcntl.h>
#include  <stdio.h>
#include  <stdlib.h>
#include  <string.h>

#define MAXLINE 4096
#define MAX_SOCK 64

#define bzero(b,len) (memset(b,0,len))
#define bcopy(b1,b2,len) (memcpy(b1,b2,len))

char *escapechar = "exit";
char send_calc_msg[MAXLINE+1];

//EXTERN LINK VARIABLE
char input[MAXLINE+1];

int maxfd;
int g_num_chat = 0;
int client_s[MAX_SOCK];

FILE *fp=NULL;


//STATIC LINK
static int getmax(int);
static void removeclient(int);
static int getdottedipaddr(int sd, struct sockaddr_in *addr);

int main(int argc, char *argv[]) 
{
    char rline[MAXLINE+1];
    int ii, kk, recv_len;
    int client_fd, clilen, rc;

    fd_set read_fds;
    WSADATA wsadata;
    SOCKET hservsock;
    SOCKADDR_IN client_addr, server_addr;

    if (argc != 2) {
        printf("usage : %s port\n", argv[0]);
        return(-1);
    }

if((fp=fopen("KRX_RECV.dat", "wt"))==NULL)
{
return(-7);
}

if(WSAStartup(MAKEWORD(2,2), &wsadata) != 0)
    {
        return(-9);
    }

    hservsock=socket(PF_INET, SOCK_STREAM, 0);
    if(hservsock==INVALID_SOCKET)
    {
        return(-8);
    }

    bzero((char *)&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(atoi(argv[1]));

    if (bind(hservsock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        return(-3);
    }
    listen(hservsock, 5); /* backlog = 5 */
    maxfd = hservsock + 1;

for(;;)
    {
        FD_ZERO(&read_fds);
        FD_SET(hservsock, &read_fds);
        for (ii=0; ii < g_num_chat; ii++)
        {
            FD_SET(client_s[ii], &read_fds);
        }
        maxfd = getmax(hservsock) + 1;

        if (select(maxfd, &read_fds, (fd_set *)0, (fd_set *)0, (struct timeval *)0) < 0) 
        {
            printf("server: select error.\n");
            break;
        }

        if (FD_ISSET(hservsock, &read_fds)) 
        {
            clilen = sizeof(client_addr);
            client_fd = accept(hservsock, (struct sockaddr *)&client_addr, &clilen);
            if (client_fd == -1) 
            {
                printf("server: accept error\n");
                break;
            }
            client_s[g_num_chat] = client_fd;
            g_num_chat++;
        }

        for (ii=0; ii<g_num_chat; ii++) 
        {
            if (FD_ISSET(client_s[ii], &read_fds)) 
            {
                if ((recv_len = recv(client_s[ii], rline, MAXLINE, 0)) <= 0) 
                {
                    removeclient(ii); /* abrupt exit *//* abrupt exit *//* abrupt exit *//* abrupt exit */
                    continue;
                }
                rline[recv_len] = '\0';

                for (kk=0; kk<g_num_chat; kk++)
                {
                    send(client_s[kk], rline, recv_len, 0);
                    printf("[%.5d][%d]%s", kk, client_s[ii], rline);

                    if(client_s[ii] == client_s[kk])
                    {
                        fprintf(fp,"%s", rline);
                        fflush(fp);  /*in server, very important*/
                     }
                }
            }
        }
    } /* while */

    rc = WSACleanup();
    if(rc == WSANOTINITIALISED)
    {
        printf(">>error::A successful WSAStartup call must occur before using this function.\n");
    }
    else if(rc == WSAENETDOWN)
    {
        printf(">>error::The network subsystem has failed.\n");
    }
    else if(rc == WSAEINPROGRESS)
    {
        printf(">>error::A blocking Windows Sockets 1.1 call is in progress, or the service provider is still processing a callback function.\n");
    }
    closesocket(hservsock);

if(fp != NULL) fclose(fp);
}

void removeclient(int indx) 
{
    struct sockaddr_in client_addr;

    if (getdottedipaddr(client_s[indx], &client_addr) > -1)
    {
        printf("\nserver>>removeclient>>1 number expired!!(IP: %s).", inet_ntoa(client_addr.sin_addr));
    }
    else
    {
        printf("\nserver>>removeclient>>1 number expired!!.");
    }

    closesocket(client_s[indx]);

    if (indx != g_num_chat-1)
    {
        client_s[indx] = client_s[g_num_chat-1];
    }

    g_num_chat--;
    printf("\nserver>>removeclient>>now number = %d\n", g_num_chat);
}

int getmax(int k) 
{
    int max = k;
    int r;

    for (r=0; r < g_num_chat; r++)
    {
        if (client_s[r] > max) max = client_s[r];
    }
    return max;
}

int getdottedipaddr(int sd, struct sockaddr_in *addr) 
{
    struct sockaddr_in client_addr;
    int len, r;

    len = sizeof(client_addr);
    if ((r = getpeername(sd, (struct sockaddr *)&client_addr, &len)) == 0)
    {
        *addr = client_addr;
    }
    return r;
}

/*

WINDOWS,SERVER,SELECT(RECV),BASIC(SEND)

*/

#include  <winsock2.h>
#include  <stdio.h>
#include  <fcntl.h>
#include  <stdlib.h>
#include  <string.h>

#define MAXLINE 4096
#define MAX_SOCK 64

#define bzero(b,len) (memset(b,0,len))
#define bcopy(b1,b2,len) (memcpy(b1,b2,len))

char *escapechar = "exit";
char send_calc_msg[MAXLINE+1];

//EXTERN LINK VARIABLE
char input[MAXLINE+1];

int maxfd;
int g_num_chat = 0;
int client_s[MAX_SOCK];


//STATIC LINK
static int getmax(int);
static void removeclient(int);
static int getdottedipaddr(int sd, struct sockaddr_in *addr);

int main(int argc, char *argv[]) 
{
    char rline[MAXLINE+1];
    int ii, kk, nn;
    int client_fd, clilen, rc;

    fd_set read_fds;
    WSADATA wsadata;
    SOCKET hservsock;
    SOCKADDR_IN client_addr, server_addr;

    if (argc != 2) {
        printf("usage : %s port\n", argv[0]);
        return(-1);
    }

if(WSAStartup(MAKEWORD(2,2), &wsadata) != 0)
    {
        return(-9);
    }

    hservsock=socket(PF_INET, SOCK_STREAM, 0);
    if(hservsock==INVALID_SOCKET)
    {
        return(-8);
    }

    bzero((char *)&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(atoi(argv[1]));

    if (bind(hservsock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        return(-3);
    }
    listen(hservsock, 5); /* backlog = 5 */
    maxfd = hservsock + 1;

for(;;)
    {
        FD_ZERO(&read_fds);
        FD_SET(hservsock, &read_fds);
        for (ii=0; ii < g_num_chat; ii++)
        {
            FD_SET(client_s[ii], &read_fds);
        }
        maxfd = getmax(hservsock) + 1;

        if (select(maxfd, &read_fds, (fd_set *)0, (fd_set *)0, (struct timeval *)0) < 0) 
        {
            printf("server: select error.\n");
            break;
        }

        if (FD_ISSET(hservsock, &read_fds)) 
        {
            clilen = sizeof(client_addr);
            client_fd = accept(hservsock, (struct sockaddr *)&client_addr, &clilen);
            if (client_fd == -1) 
            {
                printf("server: accept error\n");
                break;
            }
            client_s[g_num_chat] = client_fd;
            g_num_chat++;
        }

        for (ii=0; ii<g_num_chat; ii++) 
        {
            if (FD_ISSET(client_s[ii], &read_fds)) 
            {
                if ((nn = recv(client_s[ii], rline, MAXLINE, 0)) <= 0) 
                {
                    removeclient(ii); /* abrupt exit *//* abrupt exit *//* abrupt exit *//* abrupt exit */
                    continue;
                }
                rline[nn] = 0x00;

                for (kk=0; kk<g_num_chat; kk++)
                {
                    send(client_s[kk], rline, nn, 0);
                    printf("[%.5d][%d]%s", kk, client_s[ii], rline);
                }
            }
        }
    } /* while */

    rc = WSACleanup();
    if(rc == WSANOTINITIALISED)
    {
        printf(">>error::A successful WSAStartup call must occur before using this function.\n");
    }
    else if(rc == WSAENETDOWN)
    {
        printf(">>error::The network subsystem has failed.\n");
    }
    else if(rc == WSAEINPROGRESS)
    {
        printf(">>error::A blocking Windows Sockets 1.1 call is in progress, or the service provider is still processing a callback function.\n");
    }
    closesocket(hservsock);
}

void removeclient(int indx) 
{
    struct sockaddr_in client_addr;

    if (getdottedipaddr(client_s[indx], &client_addr) > -1)
    {
        printf("\nserver>>removeclient>>1 number expired!!(IP: %s).", inet_ntoa(client_addr.sin_addr));
    }
    else
    {
        printf("\nserver>>removeclient>>1 number expired!!.");
    }

    closesocket(client_s[indx]);

    if (indx != g_num_chat-1)
    {
        client_s[indx] = client_s[g_num_chat-1];
    }

    g_num_chat--;
    printf("\nserver>>removeclient>>now number = %d\n", g_num_chat);
}

int getmax(int k) 
{
    int max = k;
    int r;

    for (r=0; r < g_num_chat; r++)
    {
        if (client_s[r] > max) max = client_s[r];
    }
    return max;
}

int getdottedipaddr(int sd, struct sockaddr_in *addr) 
{
    struct sockaddr_in client_addr;
    int len, r;

    len = sizeof(client_addr);
    if ((r = getpeername(sd, (struct sockaddr *)&client_addr, &len)) == 0)
    {
        *addr = client_addr;
    }
    return r;
}

/*

WINDOWS,CLIENT,THREAD(FILE READ SEND),BASIC(RECV)

*/

#include  <WinSock2.h>
#include  <windows.h>
#include  <stdio.h>
#include  <stdlib.h>
#include  <string.h>

#define  MAXLINE 1024

DWORD WINAPI stdin_input_send_thread(LPVOID arg);

FILE *fp=NULL;
char line[MAXLINE], chatdata[MAXLINE+1];

struct sockaddr_in server_addr;
SOCKET clientsocket; //server connect socket
char *escape = "quit"; //exit command message
BOOL bisquit;           //exit falg variable

int main(int argc, char *argv[])
{
    WSADATA wsa;    //socket
    HANDLE hthread; //thread
    DWORD threadid;
    int size;

    if (argc != 4) 
    {
        printf("usage : %s server_address port filename\n", argv[0]);
        return(-1);
    }
    bisquit = FALSE;

    //socket initialization
    if (WSAStartup(MAKEWORD(2,2), &wsa) != 0) 
    {
        return(-2);
    }
    //socket creation
    if ((clientsocket = socket(AF_INET, SOCK_STREAM, 0)) < 0) 
    {
        printf("fail make socket\n");
        return(-3);
    }

    //memory initialization
    memset(&server_addr, 0x00, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr(argv[1]);
    server_addr.sin_port = htons(atoi(argv[2]));

    //connection with server
    if (connect(clientsocket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) 
    {
        printf("fail connect to server\n");
        return(-4);
    }

    if((fp = fopen(argv[3], "rt"))==NULL)
    {
        printf("fopen error(%s)\n", argv[3]);
        return(-5);
    }

    hthread = CreateThread(NULL, 0, stdin_input_send_thread, 0, 0, &threadid);
    if (hthread == NULL) 
    {
        printf("fail make thread\n");
    }
    else 
    {
        CloseHandle(hthread);
    }

    while (!bisquit) 
    {
        memset(chatdata, 0x00, sizeof(chatdata));

        if ((size = recv(clientsocket, chatdata, MAXLINE, 0)) == INVALID_SOCKET) 
        {
            break;
        }
        else 
        {
            chatdata[size] = '\0';
            printf("(RECV)%s", chatdata);
        }
    }
    closesocket(clientsocket);
    WSACleanup();

    if(fp != NULL) fclose(fp);

    return(0);
}

//user data input mechanism
DWORD WINAPI stdin_input_send_thread(LPVOID arg)
{
    char rbuf[4096];

    while(TRUE) 
    {
        memset(rbuf, 0x00, sizeof(rbuf));
        if(fgets(rbuf, sizeof(rbuf), fp) == NULL) break;

        printf("(SEND)%s", rbuf);

        if (send(clientsocket, rbuf, strlen(rbuf), 0) < 0) 
        {
            return(-2);
        }

        Sleep(500); //#include
    }
    return 0;
}

/*

LINUX,SERVER,SELECT(RECV),SELECT(SEND)

LINUX,SERVER,SELECT(RECV),SELECT(SEND)

LINUX,SERVER,SELECT(RECV),SELECT(SEND)

LINUX,SERVER,SELECT(RECV),SELECT(SEND)

LINUX,SERVER,SELECT(RECV),SELECT(SEND)

LINUX,SERVER,SELECT(RECV),SELECT(SEND)

LINUX,SERVER,SELECT(RECV),SELECT(SEND)

LINUX,SERVER,SELECT(RECV),SELECT(SEND)

*/

#include <stdio.h>

#include <fcntl.h>

#include <stdlib.h>

#include <signal.h>

#include <sys/socket.h>

#include <sys/file.h>

#include <netinet/in.h>

#include <string.h>

#define MAXLINE 512

#define MAX_SOCK 64

char *escapechar = "exit";

int maxfdp1;

int g_num_chat = 0;

int s;

int client_s[MAX_SOCK];

static int getmax(int);

static void removeclient(int);

static int getdottedipaddr(int sd, struct sockaddr_in *addr);

static void my_signal(int signo);

int main(int argc, char *argv[]) 

{

    char rline[MAXLINE+1];

    char *start = "Connected to chat-server\n";

    int i, j, n;

    int client_fd, clilen;

    fd_set read_fds;

    struct sockaddr_in client_addr, server_addr;

    if (argc != 2) {

        printf("usage : %s port\n", argv[0]);

        return(-1);

    }

    if ((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {

        printf("can't open stream socket.");

        return(-2);

    }

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

    server_addr.sin_family = AF_INET;

    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    server_addr.sin_port = htons(atoi(argv[1]));

    if (bind(s, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {

        printf("Server: Can't bind local address.\n");

        return(-3);

    }

    if (signal(SIGINT, my_signal) == SIG_ERR) { /* Ctrl+C */

        printf("Server: signal(SIGINT) error\n");

        return(-4);

    }

    if (signal(SIGTERM, my_signal) == SIG_ERR) { /* software termination */

        printf("Server: signal(SIGTERM) error\n");

        return(-5);

    }

    if (signal(SIGQUIT, my_signal) == SIG_ERR) { /* Ctrl+\ */

        printf("Server: signal(SIGQUIT) error\n");

        return(-6);

    }

    listen(s, 5); /* backlog = 5 */

    maxfdp1 = s + 1;

    while (1) 

    {

        FD_ZERO(&read_fds);

        FD_SET(s, &read_fds);

        for (ii=0; ii < g_num_chat; ii++)

        {

            FD_SET(client_s[ii], &read_fds);

}

        maxfdp1 = getmax(s) + 1; /* maxfdp1 재 계산 */

        /*wait & response*/

/*wait & response*/

/*wait & response*/

/*wait & response*/

/*wait & response*/

/*wait & response*/

/*wait & response*/

/*wait & response*/

        if (select(maxfdp1, &read_fds, (fd_set *)0, (fd_set *)0, (struct timeval *)0) < 0) 

        {

            printf("select error.\n");

            break;

        }

        if (FD_ISSET(s, &read_fds)) 

        {

            clilen = sizeof(client_addr);

            client_fd = accept(s, (struct sockaddr *)&client_addr, &clilen);

            if (client_fd == -1) 

            {

                printf("server: accept error\n");

                break;

            }

            client_s[g_num_chat] = client_fd;

            g_num_chat++;

            /*welcome message*/

/*welcome message*/

/*welcome message*/

/*welcome message*/

/*welcome message*/

/*welcome message*/

/*welcome message*/

/*welcome message*/

            send(client_fd, start, strlen(start), 0);

            if (getdottedipaddr(client_fd, &client_addr) > -1)

                printf("%d number additional(IP: %s)\n", g_num_chat, inet_ntoa(client_addr.sin_addr));

            else

                printf("%d number additional\n", g_num_chat);

        }

        for (ii=0; ii<g_num_chat; ii++) 

        {

            if (FD_ISSET(client_s[ii], &read_fds)) 

            {

                if ((n = recv(client_s[ii], rline, MAXLINE, 0)) <= 0) 

                {

                    removeclient(ii); /* abrupt exit *//* abrupt exit *//* abrupt exit *//* abrupt exit */

                    continue;

                }

                rline[n] = '\0';

                if (strstr(rline, escapechar) != NULL) 

                {

                    removeclient(ii); /* abrupt exit *//* abrupt exit *//* abrupt exit *//* abrupt exit *//* abrupt exit */

                    continue;

                }

                for (kk=0; kk<g_num_chat; kk++)

                {

                    send(client_s[kk], rline, n, 0);

                }

                if (getdottedipaddr(client_fd, &client_addr) > -1)

                printf("IP: %s -> %s", inet_ntoa(client_addr.sin_addr), rline);

                else

                printf("%s", rline);

            }

        }

    } /* while */

    my_signal(SIGIO);

}

void removeclient(int indx) 

{

    struct sockaddr_in client_addr;

    if (getdottedipaddr(client_s[indx], &client_addr) > -1)

    printf("1 number expired!!(IP: %s).", inet_ntoa(client_addr.sin_addr));

    else

    printf("1 number expired!!.");

    close(client_s[indx]);

    if (indx != g_num_chat-1) client_s[indx] = client_s[g_num_chat-1];

    g_num_chat--;

    printf("now number = %d\n", g_num_chat);

}

int getmax(int k) {

    int max = k;

    int r;

    for (r=0; r < g_num_chat; r++)

    {

        if (client_s[r] > max) max = client_s[r];

    }

    return max;

}

/* 소켓에 연결된 상대방 주소를 알아낸다 */

int getdottedipaddr(int sd, struct sockaddr_in *addr) {

    struct sockaddr_in client_addr;

    int len, r;

    len = sizeof(client_addr);

    if ((r = getpeername(sd, (struct sockaddr *)&client_addr, &len)) == 0)

    {

        *addr = client_addr;

    }

    return r;

}

/* 시그널 처리 함수 정의 */

void my_signal(int signo) 

{

    int ii;

/* 대부분의 시그널(SIGILL과 SIGTRAP 은 제외)에 대한 처리 함수는 시그널이 포작된 후

즉시 재지정된다. 이것은 프로세스가 시그널의 처리 함수를 잊어버리고, 다음에 시그널이

도착하면 묵시적 처리함수인 SIG_DFL 을 수행하는 것을 의미한다.

이것은 특히 사용자가 인터럽트키를 여러번 누를 수도 있는 대화명 프로그램에서 문제가 된다

그러므로 시그널 함수가 호출되자 마자 SIGINT 시그널을 무시한다 */

    signal(SIGINT, SIG_IGN);

    signal(SIGTERM, SIG_IGN);

    signal(SIGQUIT, SIG_IGN);

    close(s);

    for (ii=0; ii < g_num_chat; ii++)

    {

        close(client_s[ii]);

    }

    exit(0);

}

/*----------------------------------------------------------------------------------------------------

socket function : accept

1. 소켓에 연결을 받아들인다.

#include <sys/types.h>

#include <sys/socket.h>

int accept(int s, struct sockaddr *addr, socklen_t *addrlen);

2. 설명

accept() 함수는 연결지향 소켓 타입 (SOCK_STREAM, SOCK_SEQPACKET, SOCK_RDM)에 사용된다. 

이것은 아직 처리되지 않은 연결들이 대기하고 있는 큐에서 제일 처음 연결된 연결을 가져와서 새로운 연결된 소켓을 만든다. 

그리고 소켓을 가르키는 파일 지정자를 할당하고 이것을 리턴한다.

인자 s 는 socket() 로 만들어진 end-point(듣기 소켓)을 위한 파일지정자이다.

인자 addr 는 sockaddr 구조체에 대한 포인터이다. 

연결이 성공되면 이 구조체를 채워서 되돌려 주게 되고, 

우리는 이구조체의 정보를 이용해서 연결된 클라이언트의 인터넷 정보를 알아낼수 있다. addrlen 인자는 addr의 크기 이다.

만약 미결인 연결이 큐에 존재하지 않고, 소켓이 비봉쇄가 아니라면 accept 는 연결이 존재할때까지 해당영역에서 봉쇄된다. 

비봉쇄 소켓일경우에는 errno 로 EAGAIN 을 설정하고 바로 리턴한다.

3. 반환값

에러시 -1이 반환된다. 성공한다면 받아들인 소켓을 위한 파일지정번호 (0보다 큰)을 반환한다.

---------------------------------*/

Microsoft Windows [Version 6.1.7601]
Copyright (c) 2009 Microsoft Corporation. All rights reserved.

bash-3.1$
bash-3.1$ cat Makefile

CC = gcc

CFLAGS += -I./include/ -g -Wall -Wno-unused-variable
LIBS += -L. -lcurl -ljson-c -lwsock32

.c.o:
        $(CC) -c $< $(CFLAGS)

all: build

common.o : common.c
calc_server.o : calc_server.c
pushcall.o : pushcall.c
win_calc_server.o : win_calc_server.c

win_calc_server: win_calc_server.o pushcall.o common.o calc_server.o
        $(CC) -o $@ $^ $(LIBS)
BUILD_FILES += win_calc_server

build: $(BUILD_FILES)

clean:
        rm -f *.o
        rm -f $(BUILD_FILES)
bash-3.1$ make clean
rm -f *.o
rm -f win_calc_server
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$ make all
gcc -c win_calc_server.c -I./include/ -g -Wall -Wno-unused-variable
gcc -c pushcall.c -I./include/ -g -Wall -Wno-unused-variable
gcc -c common.c -I./include/ -g -Wall -Wno-unused-variable
gcc -c calc_server.c -I./include/ -g -Wall -Wno-unused-variable
gcc -o win_calc_server win_calc_server.o pushcall.o common.o calc_server.o -L. -lcurl -ljson-c -lwsock32
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$
bash-3.1$