석수코딩교육

#FTP server/client standard tcp program

NOT fork

NOT thread

NOT select

STANDARD tcp OK

비고) 클라이언트소스에 <sys/sendfile.h>에 선언되어진 sendfile 이라는 함수가 유용하게 사용된다.

마지막이 0xff로 끝나는,ㅡㅡ 데이타를 수신할경우에,ㅡㅡㅡㅡㅡㅡㅡㅡ
while(1)
{
    csock = accept();
    while(1)
    {
        recv_len = recv( csock, tmp, sizeof(tmp), 0);
        if(recv_len > 0)
        {
            for(ii=0; ii<recv_len; ii++)
            {
                data[data_len++ ] = tmp[ii];
                if(data_len > 2 && (unsifned char)data[data_len - 1] == (unsigned char)0xff)
                {
                    fprintf(stderr, "%.*s\n", data_len, data);
                    data_len = 0;
                    memset(data, 0x00, sizeof(data));
                }
           }
       }
        else break;
    }
    close(csock);
}

#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;
}