석수코딩교육

마지막이 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;
}

/*

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