├── Chapter1 소스코드 ├── fd_seri.c ├── hello_client.c ├── hello_client_win.c ├── hello_server.c ├── hello_server_win.c ├── low_open.c └── low_read.c ├── Chapter10 소스코드 ├── echo_client.c ├── echo_mpclient.c ├── echo_mpserv.c ├── fork.c ├── remove_zombie.c ├── sigaction.c ├── signal.c ├── wait.c ├── waitpid.c └── zombie.c ├── Chapter11 소스코드 ├── echo_storeserv.c ├── pipe1.c ├── pipe2.c └── pipe3.c ├── Chapter12 소스코드 ├── echo_client.c ├── echo_selectserv.c ├── echo_selectserv_win.c └── select.c ├── Chapter13 소스코드 ├── oob_recv.c ├── oob_recv_win.c ├── oob_send.c ├── oob_send_win.c ├── peek_recv.c ├── peek_send.c ├── readv.c └── writev.c ├── Chapter14 소스코드 ├── news.txt ├── news_receiver.c ├── news_receiver_brd.c ├── news_receiver_win.c ├── news_sender.c ├── news_sender_brd.c └── news_sender_win.c ├── Chapter15 소스코드 ├── desto.c ├── echo_stdclnt.c ├── echo_stdserv.c ├── stdcpy.c ├── syscpy.c └── todes.c ├── Chapter16 소스코드 ├── dup.c ├── sep_clnt.c ├── sep_serv.c └── sep_serv2.c ├── Chapter17 소스코드 ├── echo_EPETserv.c ├── echo_EPLTserv.c ├── echo_client.c └── echo_epollserv.c ├── Chapter18 소스코드 ├── chat_clnt.c ├── chat_serv.c ├── mutex.c ├── semaphore.c ├── thread1.c ├── thread2.c ├── thread3.c └── thread4.c ├── Chapter19 소스코드 ├── thread1_win.c ├── thread2_win.c └── thread3_win.c ├── Chapter2 소스코드 ├── tcp_client.c ├── tcp_client_win.c ├── tcp_server.c └── tcp_server_win.c ├── Chapter20 소스코드 ├── SyncCS_win.c ├── SyncEvent_win.c ├── SyncMutex_win.c ├── SyncSema_win.c ├── chat_clnt_win.c └── chat_serv_win.c ├── Chapter21 소스코드 ├── AsynNotiEchoServ_win.c └── echo_client_win.c ├── Chapter22 소스코드 ├── CmplRoutinesRecv_win.c ├── OverlappedRecv_win.c └── OverlappedSend_win.c ├── Chapter23 소스코드 ├── CmplRouEchoServ_win.c ├── IOCPEchoServ_win.c └── StableEchoClnt_win.c ├── Chapter24 소스코드 ├── index.html ├── webserv_linux.c └── webserv_win.c ├── Chapter3 소스코드 ├── conv_addr_win.c ├── endian_conv.c ├── endian_conv_win.c ├── inet_addr.c ├── inet_adrconv_win.c ├── inet_aton.c └── inet_ntoa.c ├── Chapter4 소스코드 ├── echo_client.c ├── echo_client_win.c ├── echo_server.c └── echo_server_win.c ├── Chapter5 소스코드 ├── echo_client2.c ├── echo_server.c ├── op_client.c ├── op_client_win.c ├── op_clnt.zip ├── op_server.c └── op_server_win.c ├── Chapter6 소스코드 ├── bound_host1.c ├── bound_host2.c ├── uecho_client.c ├── uecho_client_win.c ├── uecho_con_client.c ├── uecho_server.c └── uecho_server_win.c ├── Chapter7 소스코드 ├── file_client.c ├── file_client_win.c ├── file_server.c └── file_server_win.c ├── Chapter8 소스코드 ├── gethostbyaddr.c ├── gethostbyaddr_win.c ├── gethostbyname.c └── gethostbyname_win.c ├── Chapter9 소스코드 ├── buf_win.c ├── echo_client.c ├── get_buf.c ├── reuseadr_eserver.c ├── set_buf.c └── sock_type.c └── README.md /Chapter1 소스코드/fd_seri.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int main(void) 7 | { 8 | int fd1, fd2, fd3; 9 | fd1=socket(PF_INET, SOCK_STREAM, 0); 10 | fd2=open("test.dat", O_CREAT|O_WRONLY|O_TRUNC); 11 | fd3=socket(PF_INET, SOCK_DGRAM, 0); 12 | 13 | printf("file descriptor 1: %d\n", fd1); 14 | printf("file descriptor 2: %d\n", fd2); 15 | printf("file descriptor 3: %d\n", fd3); 16 | 17 | close(fd1); 18 | close(fd2); 19 | close(fd3); 20 | return 0; 21 | } -------------------------------------------------------------------------------- /Chapter1 소스코드/hello_client.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | void error_handling(char *message); 9 | 10 | int main(int argc, char* argv[]) 11 | { 12 | int sock; 13 | struct sockaddr_in serv_addr; 14 | char message[30]; 15 | int str_len; 16 | 17 | if(argc!=3){ 18 | printf("Usage : %s \n", argv[0]); 19 | exit(1); 20 | } 21 | 22 | sock=socket(PF_INET, SOCK_STREAM, 0); 23 | if(sock == -1) 24 | error_handling("socket() error"); 25 | 26 | memset(&serv_addr, 0, sizeof(serv_addr)); 27 | serv_addr.sin_family=AF_INET; 28 | serv_addr.sin_addr.s_addr=inet_addr(argv[1]); 29 | serv_addr.sin_port=htons(atoi(argv[2])); 30 | 31 | if(connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr))==-1) 32 | error_handling("connect() error!"); 33 | 34 | str_len=read(sock, message, sizeof(message)-1); 35 | if(str_len==-1) 36 | error_handling("read() error!"); 37 | 38 | printf("Message from server: %s \n", message); 39 | close(sock); 40 | return 0; 41 | } 42 | 43 | void error_handling(char *message) 44 | { 45 | fputs(message, stderr); 46 | fputc('\n', stderr); 47 | exit(1); 48 | } 49 | -------------------------------------------------------------------------------- /Chapter1 소스코드/hello_client_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | void ErrorHandling(char* message); 5 | 6 | int main(int argc, char* argv[]) 7 | { 8 | WSADATA wsaData; 9 | SOCKET hSocket; 10 | SOCKADDR_IN servAddr; 11 | 12 | char message[30]; 13 | int strLen; 14 | 15 | if(argc!=3) 16 | { 17 | printf("Usage : %s \n", argv[0]); 18 | exit(1); 19 | } 20 | 21 | if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) 22 | ErrorHandling("WSAStartup() error!"); 23 | 24 | hSocket=socket(PF_INET, SOCK_STREAM, 0); 25 | if(hSocket==INVALID_SOCKET) 26 | ErrorHandling("socket() error"); 27 | 28 | memset(&servAddr, 0, sizeof(servAddr)); 29 | servAddr.sin_family=AF_INET; 30 | servAddr.sin_addr.s_addr=inet_addr(argv[1]); 31 | servAddr.sin_port=htons(atoi(argv[2])); 32 | 33 | if(connect(hSocket, (SOCKADDR*)&servAddr, sizeof(servAddr))==SOCKET_ERROR) 34 | ErrorHandling("connect() error!"); 35 | 36 | strLen=recv(hSocket, message, sizeof(message)-1, 0); 37 | if(strLen==-1) 38 | ErrorHandling("read() error!"); 39 | printf("Message from server: %s \n", message); 40 | 41 | closesocket(hSocket); 42 | WSACleanup(); 43 | return 0; 44 | } 45 | 46 | void ErrorHandling(char* message) 47 | { 48 | fputs(message, stderr); 49 | fputc('\n', stderr); 50 | exit(1); 51 | } -------------------------------------------------------------------------------- /Chapter1 소스코드/hello_server.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | void error_handling(char *message); 9 | 10 | int main(int argc, char *argv[]) 11 | { 12 | int serv_sock; 13 | int clnt_sock; 14 | 15 | struct sockaddr_in serv_addr; 16 | struct sockaddr_in clnt_addr; 17 | socklen_t clnt_addr_size; 18 | 19 | char message[]="Hello World!"; 20 | 21 | if(argc!=2){ 22 | printf("Usage : %s \n", argv[0]); 23 | exit(1); 24 | } 25 | 26 | serv_sock=socket(PF_INET, SOCK_STREAM, 0); 27 | if(serv_sock == -1) 28 | error_handling("socket() error"); 29 | 30 | memset(&serv_addr, 0, sizeof(serv_addr)); 31 | serv_addr.sin_family=AF_INET; 32 | serv_addr.sin_addr.s_addr=htonl(INADDR_ANY); 33 | serv_addr.sin_port=htons(atoi(argv[1])); 34 | 35 | if(bind(serv_sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr))==-1 ) 36 | error_handling("bind() error"); 37 | 38 | if(listen(serv_sock, 5)==-1) 39 | error_handling("listen() error"); 40 | 41 | clnt_addr_size=sizeof(clnt_addr); 42 | clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_addr,&clnt_addr_size); 43 | if(clnt_sock==-1) 44 | error_handling("accept() error"); 45 | 46 | write(clnt_sock, message, sizeof(message)); 47 | close(clnt_sock); 48 | close(serv_sock); 49 | return 0; 50 | } 51 | 52 | void error_handling(char *message) 53 | { 54 | fputs(message, stderr); 55 | fputc('\n', stderr); 56 | exit(1); 57 | } 58 | -------------------------------------------------------------------------------- /Chapter1 소스코드/hello_server_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | void ErrorHandling(char* message); 5 | 6 | int main(int argc, char* argv[]) 7 | { 8 | WSADATA wsaData; 9 | SOCKET hServSock, hClntSock; 10 | SOCKADDR_IN servAddr, clntAddr; 11 | 12 | int szClntAddr; 13 | char message[]="Hello World!"; 14 | 15 | if(argc!=2) 16 | { 17 | printf("Usage : %s \n", argv[0]); 18 | exit(1); 19 | } 20 | 21 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 22 | ErrorHandling("WSAStartup() error!"); 23 | 24 | hServSock=socket(PF_INET, SOCK_STREAM, 0); 25 | if(hServSock==INVALID_SOCKET) 26 | ErrorHandling("socket() error"); 27 | 28 | memset(&servAddr, 0, sizeof(servAddr)); 29 | servAddr.sin_family=AF_INET; 30 | servAddr.sin_addr.s_addr=htonl(INADDR_ANY); 31 | servAddr.sin_port=htons(atoi(argv[1])); 32 | 33 | if(bind(hServSock, (SOCKADDR*) &servAddr, sizeof(servAddr))==SOCKET_ERROR) 34 | ErrorHandling("bind() error"); 35 | 36 | if(listen(hServSock, 5)==SOCKET_ERROR) 37 | ErrorHandling("listen() error"); 38 | 39 | szClntAddr=sizeof(clntAddr); 40 | hClntSock=accept(hServSock, (SOCKADDR*)&clntAddr,&szClntAddr); 41 | if(hClntSock==INVALID_SOCKET) 42 | ErrorHandling("accept() error"); 43 | 44 | send(hClntSock, message, sizeof(message), 0); 45 | closesocket(hClntSock); 46 | closesocket(hServSock); 47 | WSACleanup(); 48 | return 0; 49 | } 50 | 51 | void ErrorHandling(char* message) 52 | { 53 | fputs(message, stderr); 54 | fputc('\n', stderr); 55 | exit(1); 56 | } 57 | -------------------------------------------------------------------------------- /Chapter1 소스코드/low_open.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | void error_handling(char* message); 7 | 8 | int main(void) 9 | { 10 | int fd; 11 | char buf[]="Let's go!\n"; 12 | 13 | fd=open("data.txt", O_CREAT|O_WRONLY|O_TRUNC); 14 | if(fd==-1) 15 | error_handling("open() error!"); 16 | printf("file descriptor: %d \n", fd); 17 | 18 | if(write(fd, buf, sizeof(buf))==-1) 19 | error_handling("write() error!"); 20 | 21 | close(fd); 22 | return 0; 23 | } 24 | 25 | void error_handling(char* message) 26 | { 27 | fputs(message, stderr); 28 | fputc('\n', stderr); 29 | exit(1); 30 | } 31 | 32 | /* 33 | root@com:/home/swyoon/tcpip# gcc low_open.c -o lopen 34 | root@com:/home/swyoon/tcpip# ./lopen 35 | file descriptor: 3 36 | root@com:/home/swyoon/tcpip# cat data.txt 37 | Let's go! 38 | root@com:/home/swyoon/tcpip# 39 | */ 40 | -------------------------------------------------------------------------------- /Chapter1 소스코드/low_read.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #define BUF_SIZE 100 7 | 8 | void error_handling(char* message); 9 | 10 | int main(void) 11 | { 12 | int fd; 13 | char buf[BUF_SIZE]; 14 | 15 | fd=open("data.txt", O_RDONLY); 16 | if( fd==-1) 17 | error_handling("open() error!"); 18 | 19 | printf("file descriptor: %d \n" , fd); 20 | 21 | if(read(fd, buf, sizeof(buf))==-1) 22 | error_handling("read() error!"); 23 | 24 | printf("file data: %s", buf); 25 | 26 | close(fd); 27 | return 0; 28 | } 29 | 30 | void error_handling(char* message) 31 | { 32 | fputs(message, stderr); 33 | fputc('\n', stderr); 34 | exit(1); 35 | } 36 | 37 | /* 38 | root@com:/home/swyoon/tcpip# gcc low_read.c -o lread 39 | root@com:/home/swyoon/tcpip# ./lread 40 | file descriptor: 3 41 | file data: Let's go! 42 | root@com:/home/swyoon/tcpip# 43 | */ 44 | -------------------------------------------------------------------------------- /Chapter10 소스코드/echo_client.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 1024 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int sock; 14 | char message[BUF_SIZE]; 15 | int str_len; 16 | struct sockaddr_in serv_adr; 17 | 18 | if(argc!=3) { 19 | printf("Usage : %s \n", argv[0]); 20 | exit(1); 21 | } 22 | 23 | sock=socket(PF_INET, SOCK_STREAM, 0); 24 | if(sock==-1) 25 | error_handling("socket() error"); 26 | 27 | memset(&serv_adr, 0, sizeof(serv_adr)); 28 | serv_adr.sin_family=AF_INET; 29 | serv_adr.sin_addr.s_addr=inet_addr(argv[1]); 30 | serv_adr.sin_port=htons(atoi(argv[2])); 31 | 32 | if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1) 33 | error_handling("connect() error!"); 34 | else 35 | puts("Connected..........."); 36 | 37 | while(1) 38 | { 39 | fputs("Input message(Q to quit): ", stdout); 40 | fgets(message, BUF_SIZE, stdin); 41 | 42 | if(!strcmp(message,"q\n") || !strcmp(message,"Q\n")) 43 | break; 44 | 45 | write(sock, message, strlen(message)); 46 | str_len=read(sock, message, BUF_SIZE-1); 47 | message[str_len]=0; 48 | printf("Message from server: %s", message); 49 | } 50 | 51 | close(sock); 52 | return 0; 53 | } 54 | 55 | void error_handling(char *message) 56 | { 57 | fputs(message, stderr); 58 | fputc('\n', stderr); 59 | exit(1); 60 | } -------------------------------------------------------------------------------- /Chapter10 소스코드/echo_mpclient.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 30 9 | void error_handling(char *message); 10 | void read_routine(int sock, char *buf); 11 | void write_routine(int sock, char *buf); 12 | 13 | int main(int argc, char *argv[]) 14 | { 15 | int sock; 16 | pid_t pid; 17 | char buf[BUF_SIZE]; 18 | struct sockaddr_in serv_adr; 19 | if(argc!=3) { 20 | printf("Usage : %s \n", argv[0]); 21 | exit(1); 22 | } 23 | 24 | sock=socket(PF_INET, SOCK_STREAM, 0); 25 | memset(&serv_adr, 0, sizeof(serv_adr)); 26 | serv_adr.sin_family=AF_INET; 27 | serv_adr.sin_addr.s_addr=inet_addr(argv[1]); 28 | serv_adr.sin_port=htons(atoi(argv[2])); 29 | 30 | if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1) 31 | error_handling("connect() error!"); 32 | 33 | pid=fork(); 34 | if(pid==0) 35 | write_routine(sock, buf); 36 | else 37 | read_routine(sock, buf); 38 | 39 | close(sock); 40 | return 0; 41 | } 42 | 43 | void read_routine(int sock, char *buf) 44 | { 45 | while(1) 46 | { 47 | int str_len=read(sock, buf, BUF_SIZE); 48 | if(str_len==0) 49 | return; 50 | 51 | buf[str_len]=0; 52 | printf("Message from server: %s", buf); 53 | } 54 | } 55 | void write_routine(int sock, char *buf) 56 | { 57 | while(1) 58 | { 59 | fgets(buf, BUF_SIZE, stdin); 60 | if(!strcmp(buf,"q\n") || !strcmp(buf,"Q\n")) 61 | { 62 | shutdown(sock, SHUT_WR); 63 | return; 64 | } 65 | write(sock, buf, strlen(buf)); 66 | } 67 | } 68 | void error_handling(char *message) 69 | { 70 | fputs(message, stderr); 71 | fputc('\n', stderr); 72 | exit(1); 73 | } -------------------------------------------------------------------------------- /Chapter10 소스코드/echo_mpserv.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | #define BUF_SIZE 30 11 | void error_handling(char *message); 12 | void read_childproc(int sig); 13 | 14 | int main(int argc, char *argv[]) 15 | { 16 | int serv_sock, clnt_sock; 17 | struct sockaddr_in serv_adr, clnt_adr; 18 | 19 | pid_t pid; 20 | struct sigaction act; 21 | socklen_t adr_sz; 22 | int str_len, state; 23 | char buf[BUF_SIZE]; 24 | if(argc!=2) { 25 | printf("Usage : %s \n", argv[0]); 26 | exit(1); 27 | } 28 | 29 | act.sa_handler=read_childproc; 30 | sigemptyset(&act.sa_mask); 31 | act.sa_flags=0; 32 | state=sigaction(SIGCHLD, &act, 0); 33 | serv_sock=socket(PF_INET, SOCK_STREAM, 0); 34 | memset(&serv_adr, 0, sizeof(serv_adr)); 35 | serv_adr.sin_family=AF_INET; 36 | serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 37 | serv_adr.sin_port=htons(atoi(argv[1])); 38 | 39 | if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1) 40 | error_handling("bind() error"); 41 | if(listen(serv_sock, 5)==-1) 42 | error_handling("listen() error"); 43 | 44 | while(1) 45 | { 46 | adr_sz=sizeof(clnt_adr); 47 | clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz); 48 | if(clnt_sock==-1) 49 | continue; 50 | else 51 | puts("new client connected..."); 52 | pid=fork(); 53 | if(pid==-1) 54 | { 55 | close(clnt_sock); 56 | continue; 57 | } 58 | if(pid==0) 59 | { 60 | close(serv_sock); 61 | while((str_len=read(clnt_sock, buf, BUF_SIZE))!=0) 62 | write(clnt_sock, buf, str_len); 63 | 64 | close(clnt_sock); 65 | puts("client disconnected..."); 66 | return 0; 67 | } 68 | else 69 | close(clnt_sock); 70 | } 71 | close(serv_sock); 72 | return 0; 73 | } 74 | 75 | void read_childproc(int sig) 76 | { 77 | pid_t pid; 78 | int status; 79 | pid=waitpid(-1, &status, WNOHANG); 80 | printf("removed proc id: %d \n", pid); 81 | } 82 | void error_handling(char *message) 83 | { 84 | fputs(message, stderr); 85 | fputc('\n', stderr); 86 | exit(1); 87 | } -------------------------------------------------------------------------------- /Chapter10 소스코드/fork.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int gval=10; 4 | 5 | int main(int argc, char *argv[]) 6 | { 7 | pid_t pid; 8 | int lval=20; 9 | gval++, lval+=5; 10 | 11 | pid=fork(); 12 | if(pid==0) // if Child Process 13 | gval+=2, lval+=2; 14 | else // if Parent Process 15 | gval-=2, lval-=2; 16 | 17 | if(pid==0) 18 | printf("Child Proc: [%d, %d] \n", gval, lval); 19 | else 20 | printf("Parent Proc: [%d, %d] \n", gval, lval); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /Chapter10 소스코드/remove_zombie.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | void read_childproc(int sig) 8 | { 9 | int status; 10 | pid_t id=waitpid(-1, &status, WNOHANG); 11 | if(WIFEXITED(status)) 12 | { 13 | printf("Removed proc id: %d \n", id); 14 | printf("Child send: %d \n", WEXITSTATUS(status)); 15 | } 16 | } 17 | 18 | int main(int argc, char *argv[]) 19 | { 20 | pid_t pid; 21 | struct sigaction act; 22 | act.sa_handler=read_childproc; 23 | sigemptyset(&act.sa_mask); 24 | act.sa_flags=0; 25 | sigaction(SIGCHLD, &act, 0); 26 | 27 | pid=fork(); 28 | if(pid==0) 29 | { 30 | puts("Hi! I'm child process"); 31 | sleep(10); 32 | return 12; 33 | } 34 | else 35 | { 36 | printf("Child proc id: %d \n", pid); 37 | pid=fork(); 38 | if(pid==0) 39 | { 40 | puts("Hi! I'm child process"); 41 | sleep(10); 42 | exit(24); 43 | } 44 | else 45 | { 46 | int i; 47 | printf("Child proc id: %d \n", pid); 48 | for(i=0; i<5; i++) 49 | { 50 | puts("wait..."); 51 | sleep(5); 52 | } 53 | } 54 | } 55 | return 0; 56 | } 57 | 58 | /* 59 | root@my_linux:/home/swyoon/tcpip# gcc remove_zombie.c -o zombie 60 | root@my_linux:/home/swyoon/tcpip# ./zombie 61 | Hi! I'm child process 62 | Child proc id: 9529 63 | Hi! I'm child process 64 | Child proc id: 9530 65 | wait... 66 | wait... 67 | Removed proc id: 9530 68 | Child send: 24 69 | wait... 70 | Removed proc id: 9529 71 | Child send: 12 72 | wait... 73 | wait... 74 | 75 | */ 76 | -------------------------------------------------------------------------------- /Chapter10 소스코드/sigaction.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void timeout(int sig) 6 | { 7 | if(sig==SIGALRM) 8 | puts("Time out!"); 9 | alarm(2); 10 | } 11 | 12 | int main(int argc, char *argv[]) 13 | { 14 | int i; 15 | struct sigaction act; 16 | act.sa_handler=timeout; 17 | sigemptyset(&act.sa_mask); 18 | act.sa_flags=0; 19 | sigaction(SIGALRM, &act, 0); 20 | 21 | alarm(2); 22 | 23 | for(i=0; i<3; i++) 24 | { 25 | puts("wait..."); 26 | sleep(100); 27 | } 28 | return 0; 29 | } -------------------------------------------------------------------------------- /Chapter10 소스코드/signal.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void timeout(int sig) 6 | { 7 | if(sig==SIGALRM) 8 | puts("Time out!"); 9 | 10 | alarm(2); 11 | } 12 | void keycontrol(int sig) 13 | { 14 | if(sig==SIGINT) 15 | puts("CTRL+C pressed"); 16 | } 17 | 18 | int main(int argc, char *argv[]) 19 | { 20 | int i; 21 | signal(SIGALRM, timeout); 22 | signal(SIGINT, keycontrol); 23 | alarm(2); 24 | 25 | for(i=0; i<3; i++) 26 | { 27 | puts("wait..."); 28 | sleep(100); 29 | } 30 | return 0; 31 | } -------------------------------------------------------------------------------- /Chapter10 소스코드/wait.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int main(int argc, char *argv[]) 7 | { 8 | int status; 9 | pid_t pid=fork(); 10 | 11 | if(pid==0) 12 | { 13 | return 3; 14 | } 15 | else 16 | { 17 | printf("Child PID: %d \n", pid); 18 | pid=fork(); 19 | if(pid==0) 20 | { 21 | exit(7); 22 | } 23 | else 24 | { 25 | printf("Child PID: %d \n", pid); 26 | wait(&status); 27 | if(WIFEXITED(status)) 28 | printf("Child send one: %d \n", WEXITSTATUS(status)); 29 | 30 | wait(&status); 31 | if(WIFEXITED(status)) 32 | printf("Child send two: %d \n", WEXITSTATUS(status)); 33 | sleep(30); // Sleep 30 sec. 34 | } 35 | } 36 | return 0; 37 | } -------------------------------------------------------------------------------- /Chapter10 소스코드/waitpid.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main(int argc, char *argv[]) 6 | { 7 | int status; 8 | pid_t pid=fork(); 9 | 10 | if(pid==0) 11 | { 12 | sleep(15); 13 | return 24; 14 | } 15 | else 16 | { 17 | while(!waitpid(-1, &status, WNOHANG)) 18 | { 19 | sleep(3); 20 | puts("sleep 3sec."); 21 | } 22 | 23 | if(WIFEXITED(status)) 24 | printf("Child send %d \n", WEXITSTATUS(status)); 25 | } 26 | return 0; 27 | } 28 | 29 | /* 30 | root@my_linux:/home/swyoon/tcpip# gcc waitpid.c -o waitpid 31 | root@my_linux:/home/swyoon/tcpip# ./waitpid 32 | sleep 3sec. 33 | sleep 3sec. 34 | sleep 3sec. 35 | sleep 3sec. 36 | sleep 3sec. 37 | Child send 24 38 | */ 39 | -------------------------------------------------------------------------------- /Chapter10 소스코드/zombie.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(int argc, char *argv[]) 5 | { 6 | pid_t pid=fork(); 7 | 8 | if(pid==0) // if Child Process 9 | { 10 | puts("Hi I'am a child process"); 11 | } 12 | else 13 | { 14 | printf("Child Process ID: %d \n", pid); 15 | sleep(30); // Sleep 30 sec. 16 | } 17 | 18 | if(pid==0) 19 | puts("End child process"); 20 | else 21 | puts("End parent process"); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /Chapter11 소스코드/echo_storeserv.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | #define BUF_SIZE 100 11 | void error_handling(char *message); 12 | void read_childproc(int sig); 13 | 14 | int main(int argc, char *argv[]) 15 | { 16 | int serv_sock, clnt_sock; 17 | struct sockaddr_in serv_adr, clnt_adr; 18 | int fds[2]; 19 | 20 | pid_t pid; 21 | struct sigaction act; 22 | socklen_t adr_sz; 23 | int str_len, state; 24 | char buf[BUF_SIZE]; 25 | if(argc!=2) { 26 | printf("Usage : %s \n", argv[0]); 27 | exit(1); 28 | } 29 | 30 | act.sa_handler=read_childproc; 31 | sigemptyset(&act.sa_mask); 32 | act.sa_flags=0; 33 | state=sigaction(SIGCHLD, &act, 0); 34 | 35 | serv_sock=socket(PF_INET, SOCK_STREAM, 0); 36 | memset(&serv_adr, 0, sizeof(serv_adr)); 37 | serv_adr.sin_family=AF_INET; 38 | serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 39 | serv_adr.sin_port=htons(atoi(argv[1])); 40 | 41 | if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1) 42 | error_handling("bind() error"); 43 | if(listen(serv_sock, 5)==-1) 44 | error_handling("listen() error"); 45 | 46 | pipe(fds); 47 | pid=fork(); 48 | if(pid==0) 49 | { 50 | FILE * fp=fopen("echomsg.txt", "wt"); 51 | char msgbuf[BUF_SIZE]; 52 | int i, len; 53 | 54 | for(i=0; i<10; i++) 55 | { 56 | len=read(fds[0], msgbuf, BUF_SIZE); 57 | fwrite((void*)msgbuf, 1, len, fp); 58 | } 59 | fclose(fp); 60 | return 0; 61 | } 62 | 63 | while(1) 64 | { 65 | adr_sz=sizeof(clnt_adr); 66 | clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz); 67 | if(clnt_sock==-1) 68 | continue; 69 | else 70 | puts("new client connected..."); 71 | 72 | pid=fork(); 73 | if(pid==0) 74 | { 75 | close(serv_sock); 76 | while((str_len=read(clnt_sock, buf, BUF_SIZE))!=0) 77 | { 78 | write(clnt_sock, buf, str_len); 79 | write(fds[1], buf, str_len); 80 | } 81 | 82 | close(clnt_sock); 83 | puts("client disconnected..."); 84 | return 0; 85 | } 86 | else 87 | close(clnt_sock); 88 | } 89 | close(serv_sock); 90 | return 0; 91 | } 92 | 93 | void read_childproc(int sig) 94 | { 95 | pid_t pid; 96 | int status; 97 | pid=waitpid(-1, &status, WNOHANG); 98 | printf("removed proc id: %d \n", pid); 99 | } 100 | void error_handling(char *message) 101 | { 102 | fputs(buf, stderr); 103 | fputc('\n', stderr); 104 | exit(1); 105 | } -------------------------------------------------------------------------------- /Chapter11 소스코드/pipe1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define BUF_SIZE 30 4 | 5 | int main(int argc, char *argv[]) 6 | { 7 | int fds[2]; 8 | char str[]="Who are you?"; 9 | char buf[BUF_SIZE]; 10 | pid_t pid; 11 | 12 | pipe(fds); 13 | pid=fork(); 14 | if(pid==0) 15 | { 16 | write(fds[1], str, sizeof(str)); 17 | } 18 | else 19 | { 20 | read(fds[0], buf, BUF_SIZE); 21 | puts(buf); 22 | } 23 | return 0; 24 | } -------------------------------------------------------------------------------- /Chapter11 소스코드/pipe2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define BUF_SIZE 30 4 | 5 | int main(int argc, char *argv[]) 6 | { 7 | int fds[2]; 8 | char str1[]="Who are you?"; 9 | char str2[]="Thank you for your message"; 10 | char buf[BUF_SIZE]; 11 | pid_t pid; 12 | 13 | pipe(fds); 14 | pid=fork(); 15 | 16 | if(pid==0) 17 | { 18 | write(fds[1], str1, sizeof(str1)); 19 | sleep(2); 20 | read(fds[0], buf, BUF_SIZE); 21 | printf("Child proc output: %s \n", buf); 22 | } 23 | else 24 | { 25 | read(fds[0], buf, BUF_SIZE); 26 | printf("Parent proc output: %s \n", buf); 27 | write(fds[1], str2, sizeof(str2)); 28 | sleep(3); 29 | } 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /Chapter11 소스코드/pipe3.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define BUF_SIZE 30 4 | 5 | int main(int argc, char *argv[]) 6 | { 7 | int fds1[2], fds2[2]; 8 | char str1[]="Who are you?"; 9 | char str2[]="Thank you for your message"; 10 | char buf[BUF_SIZE]; 11 | pid_t pid; 12 | 13 | pipe(fds1), pipe(fds2); 14 | pid=fork(); 15 | 16 | if(pid==0) 17 | { 18 | write(fds1[1], str1, sizeof(str1)); 19 | read(fds2[0], buf, BUF_SIZE); 20 | printf("Child proc output: %s \n", buf); 21 | } 22 | else 23 | { 24 | read(fds1[0], buf, BUF_SIZE); 25 | printf("Parent proc output: %s \n", buf); 26 | write(fds2[1], str2, sizeof(str2)); 27 | sleep(3); 28 | } 29 | return 0; 30 | } -------------------------------------------------------------------------------- /Chapter12 소스코드/echo_client.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 1024 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int sock; 14 | char message[BUF_SIZE]; 15 | int str_len; 16 | struct sockaddr_in serv_adr; 17 | 18 | if(argc!=3) { 19 | printf("Usage : %s \n", argv[0]); 20 | exit(1); 21 | } 22 | 23 | sock=socket(PF_INET, SOCK_STREAM, 0); 24 | if(sock==-1) 25 | error_handling("socket() error"); 26 | 27 | memset(&serv_adr, 0, sizeof(serv_adr)); 28 | serv_adr.sin_family=AF_INET; 29 | serv_adr.sin_addr.s_addr=inet_addr(argv[1]); 30 | serv_adr.sin_port=htons(atoi(argv[2])); 31 | 32 | if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1) 33 | error_handling("connect() error!"); 34 | else 35 | puts("Connected..........."); 36 | 37 | while(1) 38 | { 39 | fputs("Input message(Q to quit): ", stdout); 40 | fgets(message, BUF_SIZE, stdin); 41 | 42 | if(!strcmp(message,"q\n") || !strcmp(message,"Q\n")) 43 | break; 44 | 45 | write(sock, message, strlen(message)); 46 | str_len=read(sock, message, BUF_SIZE-1); 47 | message[str_len]=0; 48 | printf("Message from server: %s", message); 49 | } 50 | 51 | close(sock); 52 | return 0; 53 | } 54 | 55 | void error_handling(char *message) 56 | { 57 | fputs(message, stderr); 58 | fputc('\n', stderr); 59 | exit(1); 60 | } -------------------------------------------------------------------------------- /Chapter12 소스코드/echo_selectserv.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | #define BUF_SIZE 100 11 | void error_handling(char *buf); 12 | 13 | int main(int argc, char *argv[]) 14 | { 15 | int serv_sock, clnt_sock; 16 | struct sockaddr_in serv_adr, clnt_adr; 17 | struct timeval timeout; 18 | fd_set reads, cpy_reads; 19 | 20 | socklen_t adr_sz; 21 | int fd_max, str_len, fd_num, i; 22 | char buf[BUF_SIZE]; 23 | if(argc!=2) { 24 | printf("Usage : %s \n", argv[0]); 25 | exit(1); 26 | } 27 | 28 | serv_sock=socket(PF_INET, SOCK_STREAM, 0); 29 | memset(&serv_adr, 0, sizeof(serv_adr)); 30 | serv_adr.sin_family=AF_INET; 31 | serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 32 | serv_adr.sin_port=htons(atoi(argv[1])); 33 | 34 | if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1) 35 | error_handling("bind() error"); 36 | if(listen(serv_sock, 5)==-1) 37 | error_handling("listen() error"); 38 | 39 | FD_ZERO(&reads); 40 | FD_SET(serv_sock, &reads); 41 | fd_max=serv_sock; 42 | 43 | while(1) 44 | { 45 | cpy_reads=reads; 46 | timeout.tv_sec=5; 47 | timeout.tv_usec=5000; 48 | 49 | if((fd_num=select(fd_max+1, &cpy_reads, 0, 0, &timeout))==-1) 50 | break; 51 | 52 | if(fd_num==0) 53 | continue; 54 | 55 | for(i=0; i 2 | #include 3 | #include 4 | #include 5 | 6 | #define BUF_SIZE 1024 7 | void ErrorHandling(char *message); 8 | 9 | int main(int argc, char *argv[]) 10 | { 11 | WSADATA wsaData; 12 | SOCKET hServSock, hClntSock; 13 | SOCKADDR_IN servAdr, clntAdr; 14 | TIMEVAL timeout; 15 | fd_set reads, cpyReads; 16 | 17 | int adrSz; 18 | int strLen, fdNum, i; 19 | char buf[BUF_SIZE]; 20 | 21 | if(argc!=2) { 22 | printf("Usage : %s \n", argv[0]); 23 | exit(1); 24 | } 25 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 26 | ErrorHandling("WSAStartup() error!"); 27 | 28 | hServSock=socket(PF_INET, SOCK_STREAM, 0); 29 | memset(&servAdr, 0, sizeof(servAdr)); 30 | servAdr.sin_family=AF_INET; 31 | servAdr.sin_addr.s_addr=htonl(INADDR_ANY); 32 | servAdr.sin_port=htons(atoi(argv[1])); 33 | 34 | if(bind(hServSock, (SOCKADDR*) &servAdr, sizeof(servAdr))==SOCKET_ERROR) 35 | ErrorHandling("bind() error"); 36 | if(listen(hServSock, 5)==SOCKET_ERROR) 37 | ErrorHandling("listen() error"); 38 | 39 | FD_ZERO(&reads); 40 | FD_SET(hServSock, &reads); 41 | 42 | while(1) 43 | { 44 | cpyReads=reads; 45 | timeout.tv_sec=5; 46 | timeout.tv_usec=5000; 47 | 48 | if((fdNum=select(0, &cpyReads, 0, 0, &timeout))==SOCKET_ERROR) 49 | break; 50 | 51 | if(fdNum==0) 52 | continue; 53 | 54 | for(i=0; i 2 | #include 3 | #include 4 | #include 5 | 6 | #define BUF_SIZE 30 7 | 8 | int main(int argc, char *argv[]) 9 | { 10 | fd_set reads, temps; 11 | int result, str_len; 12 | char buf[BUF_SIZE]; 13 | struct timeval timeout; 14 | 15 | FD_ZERO(&reads); 16 | FD_SET(0, &reads); // 0 is standard input(console) 17 | 18 | /* 19 | timeout.tv_sec=5; 20 | timeout.tv_usec=5000; 21 | */ 22 | 23 | while(1) 24 | { 25 | temps=reads; 26 | timeout.tv_sec=5; 27 | timeout.tv_usec=0; 28 | result=select(1, &temps, 0, 0, &timeout); 29 | if(result==-1) 30 | { 31 | puts("select() error!"); 32 | break; 33 | } 34 | else if(result==0) 35 | { 36 | puts("Time-out!"); 37 | } 38 | else 39 | { 40 | if(FD_ISSET(0, &temps)) 41 | { 42 | str_len=read(0, buf, BUF_SIZE); 43 | buf[str_len]=0; 44 | printf("message from console: %s", buf); 45 | } 46 | } 47 | } 48 | return 0; 49 | } -------------------------------------------------------------------------------- /Chapter13 소스코드/oob_recv.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | #define BUF_SIZE 30 11 | void error_handling(char *message); 12 | void urg_handler(int signo); 13 | 14 | int acpt_sock; 15 | int recv_sock; 16 | 17 | int main(int argc, char *argv[]) 18 | { 19 | struct sockaddr_in recv_adr, serv_adr; 20 | int str_len, state; 21 | socklen_t serv_adr_sz; 22 | struct sigaction act; 23 | char buf[BUF_SIZE]; 24 | 25 | if(argc!=2) { 26 | printf("Usage : %s \n", argv[0]); 27 | exit(1); 28 | } 29 | 30 | act.sa_handler=urg_handler; 31 | sigemptyset(&act.sa_mask); 32 | act.sa_flags=0; 33 | 34 | acpt_sock=socket(PF_INET, SOCK_STREAM, 0); 35 | memset(&recv_adr, 0, sizeof(recv_adr)); 36 | recv_adr.sin_family=AF_INET; 37 | recv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 38 | recv_adr.sin_port=htons(atoi(argv[1])); 39 | 40 | if(bind(acpt_sock, (struct sockaddr*)&recv_adr, sizeof(recv_adr))==-1) 41 | error_handling("bind() error"); 42 | listen(acpt_sock, 5); 43 | 44 | serv_adr_sz=sizeof(serv_adr); 45 | recv_sock=accept(acpt_sock, (struct sockaddr*)&serv_adr, &serv_adr_sz); 46 | 47 | fcntl(recv_sock, F_SETOWN, getpid()); 48 | state=sigaction(SIGURG, &act, 0); 49 | 50 | while((str_len=recv(recv_sock, buf, sizeof(buf), 0))!= 0) 51 | { 52 | if(str_len==-1) 53 | continue; 54 | buf[str_len]=0; 55 | puts(buf); 56 | } 57 | close(recv_sock); 58 | close(acpt_sock); 59 | return 0; 60 | } 61 | 62 | void urg_handler(int signo) 63 | { 64 | int str_len; 65 | char buf[BUF_SIZE]; 66 | str_len=recv(recv_sock, buf, sizeof(buf)-1, MSG_OOB); 67 | buf[str_len]=0; 68 | printf("Urgent message: %s \n", buf); 69 | } 70 | 71 | void error_handling(char *message) 72 | { 73 | fputs(message, stderr); 74 | fputc('\n', stderr); 75 | exit(1); 76 | } -------------------------------------------------------------------------------- /Chapter13 소스코드/oob_recv_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define BUF_SIZE 30 6 | void ErrorHandling(char *message); 7 | 8 | int main(int argc, char *argv[]) 9 | { 10 | WSADATA wsaData; 11 | SOCKET hAcptSock, hRecvSock; 12 | 13 | SOCKADDR_IN recvAdr; 14 | SOCKADDR_IN sendAdr; 15 | int sendAdrSize, strLen; 16 | char buf[BUF_SIZE]; 17 | int result; 18 | 19 | fd_set read, except, readCopy, exceptCopy; 20 | struct timeval timeout; 21 | 22 | if(argc!=2) { 23 | printf("Usage : %s \n", argv[0]); 24 | exit(1); 25 | } 26 | 27 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 28 | ErrorHandling("WSAStartup() error!"); 29 | 30 | hAcptSock=socket(PF_INET, SOCK_STREAM, 0); 31 | memset(&recvAdr, 0, sizeof(recvAdr)); 32 | recvAdr.sin_family=AF_INET; 33 | recvAdr.sin_addr.s_addr=htonl(INADDR_ANY); 34 | recvAdr.sin_port=htons(atoi(argv[1])); 35 | 36 | if(bind(hAcptSock, (SOCKADDR*)&recvAdr, sizeof(recvAdr))==SOCKET_ERROR) 37 | ErrorHandling("bind() error"); 38 | if(listen(hAcptSock, 5)==SOCKET_ERROR) 39 | ErrorHandling("listen() error"); 40 | 41 | sendAdrSize=sizeof(sendAdr); 42 | hRecvSock=accept(hAcptSock, (SOCKADDR*)&sendAdr, &sendAdrSize); 43 | FD_ZERO(&read); 44 | FD_ZERO(&except); 45 | FD_SET(hRecvSock, &read); 46 | FD_SET(hRecvSock, &except); 47 | 48 | while(1) 49 | { 50 | readCopy=read; 51 | exceptCopy=except; 52 | timeout.tv_sec=5; 53 | timeout.tv_usec=0; 54 | 55 | result=select(0, &readCopy, 0, &exceptCopy, &timeout); 56 | 57 | if(result>0) 58 | { 59 | if(FD_ISSET(hRecvSock, &exceptCopy)) 60 | { 61 | strLen=recv(hRecvSock, buf, BUF_SIZE-1, MSG_OOB); 62 | buf[strLen]=0; 63 | printf("Urgent message: %s \n", buf); 64 | } 65 | 66 | if(FD_ISSET(hRecvSock, &readCopy)) 67 | { 68 | strLen=recv(hRecvSock, buf, BUF_SIZE-1, 0); 69 | if(strLen==0) 70 | { 71 | break; 72 | closesocket(hRecvSock); 73 | } 74 | else 75 | { 76 | buf[strLen]=0; 77 | puts(buf); 78 | } 79 | } 80 | } 81 | } 82 | 83 | closesocket(hAcptSock); 84 | WSACleanup(); 85 | return 0; 86 | } 87 | 88 | void ErrorHandling(char *message) 89 | { 90 | fputs(message, stderr); 91 | fputc('\n', stderr); 92 | exit(1); 93 | } -------------------------------------------------------------------------------- /Chapter13 소스코드/oob_send.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 30 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int sock; 14 | struct sockaddr_in recv_adr; 15 | 16 | if(argc!=3) { 17 | printf("Usage : %s \n", argv[0]); 18 | exit(1); 19 | } 20 | 21 | sock=socket(PF_INET, SOCK_STREAM, 0); 22 | memset(&recv_adr, 0, sizeof(recv_adr)); 23 | recv_adr.sin_family=AF_INET; 24 | recv_adr.sin_addr.s_addr=inet_addr(argv[1]); 25 | recv_adr.sin_port=htons(atoi(argv[2])); 26 | 27 | if(connect(sock, (struct sockaddr*)&recv_adr, sizeof(recv_adr))==-1) 28 | error_handling("connect() error!"); 29 | 30 | write(sock, "123", strlen("123")); 31 | send(sock, "4", strlen("4"), MSG_OOB); 32 | write(sock, "567", strlen("567")); 33 | send(sock, "890", strlen("890"), MSG_OOB); 34 | close(sock); 35 | return 0; 36 | } 37 | 38 | void error_handling(char *message) 39 | { 40 | fputs(message, stderr); 41 | fputc('\n', stderr); 42 | exit(1); 43 | } -------------------------------------------------------------------------------- /Chapter13 소스코드/oob_send_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define BUF_SIZE 30 6 | void ErrorHandling(char *message); 7 | 8 | int main(int argc, char *argv[]) 9 | { 10 | WSADATA wsaData; 11 | SOCKET hSocket; 12 | SOCKADDR_IN sendAdr; 13 | if(argc!=3) { 14 | printf("Usage : %s \n", argv[0]); 15 | exit(1); 16 | } 17 | 18 | if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) 19 | ErrorHandling("WSAStartup() error!"); 20 | 21 | hSocket=socket(PF_INET, SOCK_STREAM, 0); 22 | memset(&sendAdr, 0, sizeof(sendAdr)); 23 | sendAdr.sin_family=AF_INET; 24 | sendAdr.sin_addr.s_addr=inet_addr(argv[1]); 25 | sendAdr.sin_port=htons(atoi(argv[2])); 26 | 27 | 28 | if(connect(hSocket, (SOCKADDR*)&sendAdr, sizeof(sendAdr))==SOCKET_ERROR) 29 | ErrorHandling("connect() error!"); 30 | 31 | send(hSocket, "123", 3, 0); 32 | send(hSocket, "4", 1, MSG_OOB); 33 | send(hSocket, "567", 3, 0); 34 | send(hSocket, "890", 3, MSG_OOB); 35 | 36 | closesocket(hSocket); 37 | WSACleanup(); 38 | return 0; 39 | } 40 | 41 | void ErrorHandling(char *message) 42 | { 43 | fputs(message, stderr); 44 | fputc('\n', stderr); 45 | exit(1); 46 | } 47 | -------------------------------------------------------------------------------- /Chapter13 소스코드/peek_recv.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 30 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int acpt_sock, recv_sock; 14 | struct sockaddr_in acpt_adr, recv_adr; 15 | int str_len, state; 16 | socklen_t recv_adr_sz; 17 | char buf[BUF_SIZE]; 18 | if(argc!=2) { 19 | printf("Usage : %s \n", argv[0]); 20 | exit(1); 21 | } 22 | 23 | acpt_sock=socket(PF_INET, SOCK_STREAM, 0); 24 | memset(&acpt_adr, 0, sizeof(acpt_adr)); 25 | acpt_adr.sin_family=AF_INET; 26 | acpt_adr.sin_addr.s_addr=htonl(INADDR_ANY); 27 | acpt_adr.sin_port=htons(atoi(argv[1])); 28 | 29 | if(bind(acpt_sock, (struct sockaddr*)&acpt_adr, sizeof(acpt_adr))==-1) 30 | error_handling("bind() error"); 31 | listen(acpt_sock, 5); 32 | 33 | recv_adr_sz=sizeof(recv_adr); 34 | recv_sock=accept(acpt_sock, (struct sockaddr*)&recv_adr, &recv_adr_sz); 35 | 36 | while(1) 37 | { 38 | str_len=recv(recv_sock, buf, sizeof(buf)-1, MSG_PEEK|MSG_DONTWAIT); 39 | if(str_len>0) 40 | break; 41 | } 42 | 43 | buf[str_len]=0; 44 | printf("Buffering %d bytes: %s \n", str_len, buf); 45 | 46 | str_len=recv(recv_sock, buf, sizeof(buf)-1, 0); 47 | buf[str_len]=0; 48 | printf("Read again: %s \n", buf); 49 | close(acpt_sock); 50 | close(recv_sock); 51 | return 0; 52 | } 53 | 54 | void error_handling(char *message) 55 | { 56 | fputs(message, stderr); 57 | fputc('\n', stderr); 58 | exit(1); 59 | } 60 | -------------------------------------------------------------------------------- /Chapter13 소스코드/peek_send.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | void error_handling(char *message); 8 | 9 | int main(int argc, char *argv[]) 10 | { 11 | int sock; 12 | struct sockaddr_in send_adr; 13 | if(argc!=3) { 14 | printf("Usage : %s \n", argv[0]); 15 | exit(1); 16 | } 17 | 18 | sock=socket(PF_INET, SOCK_STREAM, 0); 19 | memset(&send_adr, 0, sizeof(send_adr)); 20 | send_adr.sin_family=AF_INET; 21 | send_adr.sin_addr.s_addr=inet_addr(argv[1]); 22 | send_adr.sin_port=htons(atoi(argv[2])); 23 | 24 | if(connect(sock, (struct sockaddr*)&send_adr, sizeof(send_adr))==-1) 25 | error_handling("connect() error!"); 26 | 27 | write(sock, "123", strlen("123")); 28 | close(sock); 29 | return 0; 30 | } 31 | 32 | void error_handling(char *message) 33 | { 34 | fputs(message, stderr); 35 | fputc('\n', stderr); 36 | exit(1); 37 | } 38 | -------------------------------------------------------------------------------- /Chapter13 소스코드/readv.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define BUF_SIZE 100 4 | 5 | int main(int argc, char *argv[]) 6 | { 7 | struct iovec vec[2]; 8 | char buf1[BUF_SIZE]={0,}; 9 | char buf2[BUF_SIZE]={0,}; 10 | int str_len; 11 | 12 | vec[0].iov_base=buf1; 13 | vec[0].iov_len=5; 14 | vec[1].iov_base=buf2; 15 | vec[1].iov_len=BUF_SIZE; 16 | 17 | str_len=readv(0, vec, 2); 18 | printf("Read bytes: %d \n", str_len); 19 | printf("First message: %s \n", buf1); 20 | printf("Second message: %s \n", buf2); 21 | return 0; 22 | } 23 | 24 | /* 25 | swyoon@my_linux:~/tcpip$ gcc readv.c -o rv 26 | swyoon@my_linux:~/tcpip$ ./rv 27 | I like TCP/IP socket programming~ 28 | Read bytes: 34 29 | First message: I lik 30 | Second message: e TCP/IP socket programming~ 31 | */ 32 | 33 | -------------------------------------------------------------------------------- /Chapter13 소스코드/writev.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(int argc, char *argv[]) 5 | { 6 | struct iovec vec[2]; 7 | char buf1[]="ABCDEFG"; 8 | char buf2[]="1234567"; 9 | int str_len; 10 | 11 | vec[0].iov_base=buf1; 12 | vec[0].iov_len=3; 13 | vec[1].iov_base=buf2; 14 | vec[1].iov_len=4; 15 | 16 | str_len=writev(1, vec, 2); 17 | puts(""); 18 | printf("Write bytes: %d \n", str_len); 19 | return 0; 20 | } -------------------------------------------------------------------------------- /Chapter14 소스코드/news.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/exgs/ambition_socket_programming/1d365fe728e39ed0b5e16b6d1e295d2ed79a29a0/Chapter14 소스코드/news.txt -------------------------------------------------------------------------------- /Chapter14 소스코드/news_receiver.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 30 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int recv_sock; 14 | int str_len; 15 | char buf[BUF_SIZE]; 16 | struct sockaddr_in adr; 17 | struct ip_mreq join_adr; 18 | 19 | if(argc!=3) { 20 | printf("Usage : %s \n", argv[0]); 21 | exit(1); 22 | } 23 | 24 | recv_sock=socket(PF_INET, SOCK_DGRAM, 0); 25 | memset(&adr, 0, sizeof(adr)); 26 | adr.sin_family=AF_INET; 27 | adr.sin_addr.s_addr=htonl(INADDR_ANY); 28 | adr.sin_port=htons(atoi(argv[2])); 29 | 30 | if(bind(recv_sock, (struct sockaddr*) &adr, sizeof(adr))==-1) 31 | error_handling("bind() error"); 32 | 33 | join_adr.imr_multiaddr.s_addr=inet_addr(argv[1]); 34 | join_adr.imr_interface.s_addr=htonl(INADDR_ANY); 35 | 36 | setsockopt(recv_sock, IPPROTO_IP, 37 | IP_ADD_MEMBERSHIP, (void*)&join_adr, sizeof(join_adr)); 38 | 39 | while(1) 40 | { 41 | str_len=recvfrom(recv_sock, buf, BUF_SIZE-1, 0, NULL, 0); 42 | if(str_len<0) 43 | break; 44 | buf[str_len]=0; 45 | fputs(buf, stdout); 46 | } 47 | close(recv_sock); 48 | return 0; 49 | } 50 | 51 | void error_handling(char *message) 52 | { 53 | fputs(message, stderr); 54 | fputc('\n', stderr); 55 | exit(1); 56 | } -------------------------------------------------------------------------------- /Chapter14 소스코드/news_receiver_brd.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 30 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int recv_sock; 14 | struct sockaddr_in adr; 15 | int str_len; 16 | char buf[BUF_SIZE]; 17 | 18 | if(argc!=2) { 19 | printf("Usage : %s \n", argv[0]); 20 | exit(1); 21 | } 22 | 23 | recv_sock=socket(PF_INET, SOCK_DGRAM, 0); 24 | 25 | memset(&adr, 0, sizeof(adr)); 26 | adr.sin_family=AF_INET; 27 | adr.sin_addr.s_addr=htonl(INADDR_ANY); 28 | adr.sin_port=htons(atoi(argv[1])); 29 | 30 | if(bind(recv_sock, (struct sockaddr*)&adr, sizeof(adr))==-1) 31 | error_handling("bind() error"); 32 | 33 | while(1) 34 | { 35 | str_len=recvfrom(recv_sock, buf, BUF_SIZE-1, 0, NULL, 0); 36 | if(str_len<0) 37 | break; 38 | buf[str_len]=0; 39 | fputs(buf, stdout); 40 | } 41 | 42 | close(recv_sock); 43 | return 0; 44 | } 45 | 46 | void error_handling(char *message) 47 | { 48 | fputs(message, stderr); 49 | fputc('\n', stderr); 50 | exit(1); 51 | } -------------------------------------------------------------------------------- /Chapter14 소스코드/news_receiver_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include // for struct ip_mreq 6 | 7 | #define BUF_SIZE 30 8 | void ErrorHandling(char *message); 9 | 10 | int main(int argc, char *argv[]) 11 | { 12 | WSADATA wsaData; 13 | SOCKET hRecvSock; 14 | SOCKADDR_IN adr; 15 | struct ip_mreq joinAdr; 16 | char buf[BUF_SIZE]; 17 | int strLen; 18 | 19 | 20 | if(argc!=3) { 21 | printf("Usage : %s \n", argv[0]); 22 | exit(1); 23 | } 24 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 25 | ErrorHandling("WSAStartup() error!"); 26 | 27 | hRecvSock=socket(PF_INET, SOCK_DGRAM, 0); 28 | memset(&adr, 0, sizeof(adr)); 29 | adr.sin_family=AF_INET; 30 | adr.sin_addr.s_addr=htonl(INADDR_ANY); 31 | adr.sin_port=htons(atoi(argv[2])); 32 | 33 | if(bind(hRecvSock, (SOCKADDR*) &adr, sizeof(adr))==SOCKET_ERROR) 34 | ErrorHandling("bind() error"); 35 | 36 | joinAdr.imr_multiaddr.s_addr=inet_addr(argv[1]); 37 | joinAdr.imr_interface.s_addr=htonl(INADDR_ANY); 38 | 39 | if(setsockopt(hRecvSock, IPPROTO_IP, IP_ADD_MEMBERSHIP, 40 | (void*)&joinAdr, sizeof(joinAdr))==SOCKET_ERROR) 41 | ErrorHandling("setsock() error"); 42 | 43 | while(1) 44 | { 45 | strLen=recvfrom(hRecvSock, buf, BUF_SIZE-1, 0, NULL, 0); 46 | if(strLen<0) 47 | break; 48 | buf[strLen]=0; 49 | fputs(buf, stdout); 50 | } 51 | closesocket(hRecvSock); 52 | WSACleanup(); 53 | return 0; 54 | } 55 | 56 | void ErrorHandling(char *message) 57 | { 58 | fputs(message, stderr); 59 | fputc('\n', stderr); 60 | exit(1); 61 | } -------------------------------------------------------------------------------- /Chapter14 소스코드/news_sender.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define TTL 64 9 | #define BUF_SIZE 30 10 | void error_handling(char *message); 11 | 12 | int main(int argc, char *argv[]) 13 | { 14 | int send_sock; 15 | struct sockaddr_in mul_adr; 16 | int time_live=TTL; 17 | FILE *fp; 18 | char buf[BUF_SIZE]; 19 | 20 | if(argc!=3){ 21 | printf("Usage : %s \n", argv[0]); 22 | exit(1); 23 | } 24 | 25 | send_sock=socket(PF_INET, SOCK_DGRAM, 0); 26 | memset(&mul_adr, 0, sizeof(mul_adr)); 27 | mul_adr.sin_family=AF_INET; 28 | mul_adr.sin_addr.s_addr=inet_addr(argv[1]); // Multicast IP 29 | mul_adr.sin_port=htons(atoi(argv[2])); // Multicast Port 30 | 31 | setsockopt(send_sock, IPPROTO_IP, 32 | IP_MULTICAST_TTL, (void*)&time_live, sizeof(time_live)); 33 | 34 | if((fp=fopen("news.txt", "r"))==NULL) 35 | error_handling("fopen() error"); 36 | 37 | while(!feof(fp)) /* Broadcasting */ 38 | { 39 | fgets(buf, BUF_SIZE, fp); 40 | sendto(send_sock, buf, strlen(buf), 41 | 0, (struct sockaddr*)&mul_adr, sizeof(mul_adr)); 42 | sleep(2); 43 | } 44 | fclose(fp); 45 | close(send_sock); 46 | return 0; 47 | } 48 | 49 | void error_handling(char *message) 50 | { 51 | fputs(message, stderr); 52 | fputc('\n', stderr); 53 | exit(1); 54 | } -------------------------------------------------------------------------------- /Chapter14 소스코드/news_sender_brd.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 30 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int send_sock; 14 | struct sockaddr_in broad_adr; 15 | FILE *fp; 16 | char buf[BUF_SIZE]; 17 | int so_brd=1; 18 | 19 | if(argc!=3) { 20 | printf("Usage : %s \n", argv[0]); 21 | exit(1); 22 | } 23 | 24 | send_sock=socket(PF_INET, SOCK_DGRAM, 0); 25 | memset(&broad_adr, 0, sizeof(broad_adr)); 26 | broad_adr.sin_family=AF_INET; 27 | broad_adr.sin_addr.s_addr=inet_addr(argv[1]); 28 | broad_adr.sin_port=htons(atoi(argv[2])); 29 | 30 | setsockopt(send_sock, SOL_SOCKET, 31 | SO_BROADCAST, (void*)&so_brd, sizeof(so_brd)); 32 | if((fp=fopen("news.txt", "r"))==NULL) 33 | error_handling("fopen() error"); 34 | 35 | while(!feof(fp)) 36 | { 37 | fgets(buf, BUF_SIZE, fp); 38 | sendto(send_sock, buf, strlen(buf), 39 | 0, (struct sockaddr*)&broad_adr, sizeof(broad_adr)); 40 | sleep(2); 41 | } 42 | 43 | close(send_sock); 44 | return 0; 45 | } 46 | 47 | void error_handling(char *message) 48 | { 49 | fputs(message, stderr); 50 | fputc('\n', stderr); 51 | exit(1); 52 | } -------------------------------------------------------------------------------- /Chapter14 소스코드/news_sender_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include // for IP_MULTICAST_TTL option 6 | 7 | #define TTL 64 8 | #define BUF_SIZE 30 9 | void ErrorHandling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | WSADATA wsaData; 14 | SOCKET hSendSock; 15 | SOCKADDR_IN mulAdr; 16 | int timeLive=TTL; 17 | FILE *fp; 18 | char buf[BUF_SIZE]; 19 | 20 | if(argc!=3) { 21 | printf("Usage : %s \n", argv[0]); 22 | exit(1); 23 | } 24 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 25 | ErrorHandling("WSAStartup() error!"); 26 | 27 | hSendSock=socket(PF_INET, SOCK_DGRAM, 0); 28 | memset(&mulAdr, 0, sizeof(mulAdr)); 29 | mulAdr.sin_family=AF_INET; 30 | mulAdr.sin_addr.s_addr=inet_addr(argv[1]); 31 | mulAdr.sin_port=htons(atoi(argv[2])); 32 | 33 | setsockopt(hSendSock, IPPROTO_IP, 34 | IP_MULTICAST_TTL, (void*)&timeLive, sizeof(timeLive)); 35 | 36 | if((fp=fopen("news.txt", "r"))==NULL) 37 | ErrorHandling("fopen() error"); 38 | 39 | while(!feof(fp)) 40 | { 41 | fgets(buf, BUF_SIZE, fp); 42 | sendto(hSendSock, buf, strlen(buf), 43 | 0, (SOCKADDR*)&mulAdr, sizeof(mulAdr)); 44 | Sleep(2000); 45 | } 46 | closesocket(hSendSock); 47 | WSACleanup(); 48 | return 0; 49 | } 50 | 51 | void ErrorHandling(char *message) 52 | { 53 | fputs(message, stderr); 54 | fputc('\n', stderr); 55 | exit(1); 56 | } -------------------------------------------------------------------------------- /Chapter15 소스코드/desto.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(void) 5 | { 6 | FILE *fp; 7 | int fd=open("data.dat", O_WRONLY|O_CREAT|O_TRUNC); 8 | if(fd==-1) 9 | { 10 | fputs("file open error", stdout); 11 | return -1; 12 | } 13 | 14 | fp=fdopen(fd, "w"); 15 | fputs("Network C programming \n", fp); 16 | fclose(fp); 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /Chapter15 소스코드/echo_stdclnt.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 1024 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int sock; 14 | char message[BUF_SIZE]; 15 | int str_len; 16 | struct sockaddr_in serv_adr; 17 | FILE * readfp; 18 | FILE * writefp; 19 | 20 | if(argc!=3) { 21 | printf("Usage : %s \n", argv[0]); 22 | exit(1); 23 | } 24 | 25 | sock=socket(PF_INET, SOCK_STREAM, 0); 26 | if(sock==-1) 27 | error_handling("socket() error"); 28 | 29 | memset(&serv_adr, 0, sizeof(serv_adr)); 30 | serv_adr.sin_family=AF_INET; 31 | serv_adr.sin_addr.s_addr=inet_addr(argv[1]); 32 | serv_adr.sin_port=htons(atoi(argv[2])); 33 | 34 | if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1) 35 | error_handling("connect() error!"); 36 | else 37 | puts("Connected..........."); 38 | 39 | readfp=fdopen(sock, "r"); 40 | writefp=fdopen(sock, "w"); 41 | 42 | while(1) 43 | { 44 | fputs("Input message(Q to quit): ", stdout); 45 | fgets(message, BUF_SIZE, stdin); 46 | if(!strcmp(message,"q\n") || !strcmp(message,"Q\n")) 47 | break; 48 | 49 | fputs(message, writefp); 50 | fflush(writefp); 51 | fgets(message, BUF_SIZE, readfp); 52 | printf("Message from server: %s", message); 53 | } 54 | fclose(writefp); 55 | fclose(readfp); 56 | return 0; 57 | } 58 | 59 | void error_handling(char *message) 60 | { 61 | fputs(message, stderr); 62 | fputc('\n', stderr); 63 | exit(1); 64 | } 65 | -------------------------------------------------------------------------------- /Chapter15 소스코드/echo_stdserv.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 1024 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int serv_sock, clnt_sock; 14 | char message[BUF_SIZE]; 15 | int str_len, i; 16 | 17 | struct sockaddr_in serv_adr; 18 | struct sockaddr_in clnt_adr; 19 | socklen_t clnt_adr_sz; 20 | FILE * readfp; 21 | FILE * writefp; 22 | 23 | if(argc!=2) { 24 | printf("Usage : %s \n", argv[0]); 25 | exit(1); 26 | } 27 | 28 | serv_sock=socket(PF_INET, SOCK_STREAM, 0); 29 | if(serv_sock==-1) 30 | error_handling("socket() error"); 31 | 32 | memset(&serv_adr, 0, sizeof(serv_adr)); 33 | serv_adr.sin_family=AF_INET; 34 | serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 35 | serv_adr.sin_port=htons(atoi(argv[1])); 36 | 37 | if(bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1) 38 | error_handling("bind() error"); 39 | 40 | if(listen(serv_sock, 5)==-1) 41 | error_handling("listen() error"); 42 | 43 | clnt_adr_sz=sizeof(clnt_adr); 44 | 45 | for(i=0; i<5; i++) 46 | { 47 | clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz); 48 | if(clnt_sock==-1) 49 | error_handling("accept() error"); 50 | else 51 | printf("Connected client %d \n", i+1); 52 | 53 | readfp=fdopen(clnt_sock, "r"); 54 | writefp=fdopen(clnt_sock, "w"); 55 | 56 | while(!feof(readfp)) 57 | { 58 | fgets(message, BUF_SIZE, readfp); 59 | fputs(message, writefp); 60 | fflush(writefp); 61 | } 62 | fclose(readfp); 63 | fclose(writefp); 64 | } 65 | close(serv_sock); 66 | return 0; 67 | } 68 | 69 | void error_handling(char *message) 70 | { 71 | fputs(message, stderr); 72 | fputc('\n', stderr); 73 | exit(1); 74 | } 75 | -------------------------------------------------------------------------------- /Chapter15 소스코드/stdcpy.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define BUF_SIZE 3 3 | 4 | int main(int argc, char *argv[]) 5 | { 6 | FILE * fp1; 7 | FILE * fp2; 8 | char buf[BUF_SIZE]; 9 | 10 | fp1=fopen("news.txt", "r"); 11 | fp2=fopen("cpy.txt", "w"); 12 | 13 | while(fgets(buf, BUF_SIZE, fp1)!=NULL) 14 | fputs(buf, fp2); 15 | 16 | fclose(fp1); 17 | fclose(fp2); 18 | return 0; 19 | } -------------------------------------------------------------------------------- /Chapter15 소스코드/syscpy.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define BUF_SIZE 3 4 | 5 | int main(int argc, char *argv[]) 6 | { 7 | int fd1, fd2, len; 8 | char buf[BUF_SIZE]; 9 | 10 | fd1=open("news.txt", O_RDONLY); 11 | fd2=open("cpy.txt", O_WRONLY|O_CREAT|O_TRUNC); 12 | 13 | while((len=read(fd1, buf, sizeof(buf)))>0) 14 | write(fd2, buf, len); 15 | 16 | close(fd1); 17 | close(fd2); 18 | return 0; 19 | } -------------------------------------------------------------------------------- /Chapter15 소스코드/todes.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(void) 5 | { 6 | FILE *fp; 7 | int fd=open("data.dat", O_WRONLY|O_CREAT|O_TRUNC); 8 | if(fd==-1) 9 | { 10 | fputs("file open error", stdout); 11 | return -1; 12 | } 13 | 14 | printf("First file descriptor: %d \n", fd); 15 | fp=fdopen(fd, "w"); 16 | fputs("TCP/IP SOCKET PROGRAMMING \n", fp); 17 | printf("Second file descriptor: %d \n", fileno(fp)); 18 | fclose(fp); 19 | return 0; 20 | } -------------------------------------------------------------------------------- /Chapter16 소스코드/dup.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(int argc, char *argv[]) 5 | { 6 | int cfd1, cfd2; 7 | char str1[]="Hi~ \n"; 8 | char str2[]="It's nice day~ \n"; 9 | 10 | cfd1=dup(1); 11 | cfd2=dup2(cfd1, 7); 12 | 13 | printf("fd1=%d, fd2=%d \n", cfd1, cfd2); 14 | write(cfd1, str1, sizeof(str1)); 15 | write(cfd2, str2, sizeof(str2)); 16 | 17 | close(cfd1); 18 | close(cfd2); 19 | write(1, str1, sizeof(str1)); 20 | close(1); 21 | write(1, str2, sizeof(str2)); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /Chapter16 소스코드/sep_clnt.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #define BUF_SIZE 1024 8 | 9 | int main(int argc, char *argv[]) 10 | { 11 | int sock; 12 | char buf[BUF_SIZE]; 13 | struct sockaddr_in serv_addr; 14 | 15 | FILE * readfp; 16 | FILE * writefp; 17 | 18 | sock=socket(PF_INET, SOCK_STREAM, 0); 19 | memset(&serv_addr, 0, sizeof(serv_addr)); 20 | serv_addr.sin_family=AF_INET; 21 | serv_addr.sin_addr.s_addr=inet_addr(argv[1]); 22 | serv_addr.sin_port=htons(atoi(argv[2])); 23 | 24 | connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)); 25 | readfp=fdopen(sock, "r"); 26 | writefp=fdopen(sock, "w"); 27 | 28 | while(1) 29 | { 30 | if(fgets(buf, sizeof(buf), readfp)==NULL) 31 | break; 32 | fputs(buf, stdout); 33 | fflush(stdout); 34 | } 35 | 36 | fputs("FROM CLIENT: Thank you! \n", writefp); 37 | fflush(writefp); 38 | fclose(writefp); fclose(readfp); 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /Chapter16 소스코드/sep_serv.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #define BUF_SIZE 1024 8 | 9 | int main(int argc, char *argv[]) 10 | { 11 | int serv_sock, clnt_sock; 12 | FILE * readfp; 13 | FILE * writefp; 14 | 15 | struct sockaddr_in serv_adr, clnt_adr; 16 | socklen_t clnt_adr_sz; 17 | char buf[BUF_SIZE]={0,}; 18 | 19 | serv_sock=socket(PF_INET, SOCK_STREAM, 0); 20 | memset(&serv_adr, 0, sizeof(serv_adr)); 21 | serv_adr.sin_family=AF_INET; 22 | serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 23 | serv_adr.sin_port=htons(atoi(argv[1])); 24 | 25 | bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr)); 26 | listen(serv_sock, 5); 27 | clnt_adr_sz=sizeof(clnt_adr); 28 | clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr,&clnt_adr_sz); 29 | 30 | readfp=fdopen(clnt_sock, "r"); 31 | writefp=fdopen(clnt_sock, "w"); 32 | 33 | fputs("FROM SERVER: Hi~ client? \n", writefp); 34 | fputs("I love all of the world \n", writefp); 35 | fputs("You are awesome! \n", writefp); 36 | fflush(writefp); 37 | 38 | fclose(writefp); 39 | fgets(buf, sizeof(buf), readfp); fputs(buf, stdout); 40 | fclose(readfp); 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /Chapter16 소스코드/sep_serv2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #define BUF_SIZE 1024 8 | 9 | int main(int argc, char *argv[]) 10 | { 11 | int serv_sock, clnt_sock; 12 | FILE * readfp; 13 | FILE * writefp; 14 | 15 | struct sockaddr_in serv_adr, clnt_adr; 16 | socklen_t clnt_adr_sz; 17 | char buf[BUF_SIZE]={0,}; 18 | 19 | serv_sock=socket(PF_INET, SOCK_STREAM, 0); 20 | memset(&serv_adr, 0, sizeof(serv_adr)); 21 | serv_adr.sin_family=AF_INET; 22 | serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 23 | serv_adr.sin_port=htons(atoi(argv[1])); 24 | 25 | bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr)); 26 | listen(serv_sock, 5); 27 | clnt_adr_sz=sizeof(clnt_adr); 28 | clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr,&clnt_adr_sz); 29 | 30 | readfp=fdopen(clnt_sock, "r"); 31 | writefp=fdopen(dup(clnt_sock), "w"); 32 | 33 | fputs("FROM SERVER: Hi~ client? \n", writefp); 34 | fputs("I love all of the world \n", writefp); 35 | fputs("You are awesome! \n", writefp); 36 | fflush(writefp); 37 | 38 | shutdown(fileno(writefp), SHUT_WR); 39 | fclose(writefp); 40 | 41 | fgets(buf, sizeof(buf), readfp); fputs(buf, stdout); 42 | fclose(readfp); 43 | return 0; 44 | } 45 | 46 | /* 47 | swyoon@my_linux:~/tcpip$ gcc sep_serv2.c -o serv2 48 | swyoon@my_linux:~/tcpip$ ./serv2 9190 49 | FROM CLIENT: Thank you! 50 | */ 51 | 52 | -------------------------------------------------------------------------------- /Chapter17 소스코드/echo_EPETserv.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | #define BUF_SIZE 4 12 | #define EPOLL_SIZE 50 13 | void setnonblockingmode(int fd); 14 | void error_handling(char *buf); 15 | 16 | int main(int argc, char *argv[]) 17 | { 18 | int serv_sock, clnt_sock; 19 | struct sockaddr_in serv_adr, clnt_adr; 20 | socklen_t adr_sz; 21 | int str_len, i; 22 | char buf[BUF_SIZE]; 23 | 24 | struct epoll_event *ep_events; 25 | struct epoll_event event; 26 | int epfd, event_cnt; 27 | 28 | if(argc!=2) { 29 | printf("Usage : %s \n", argv[0]); 30 | exit(1); 31 | } 32 | 33 | serv_sock=socket(PF_INET, SOCK_STREAM, 0); 34 | memset(&serv_adr, 0, sizeof(serv_adr)); 35 | serv_adr.sin_family=AF_INET; 36 | serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 37 | serv_adr.sin_port=htons(atoi(argv[1])); 38 | 39 | if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1) 40 | error_handling("bind() error"); 41 | if(listen(serv_sock, 5)==-1) 42 | error_handling("listen() error"); 43 | 44 | epfd=epoll_create(EPOLL_SIZE); 45 | ep_events=malloc(sizeof(struct epoll_event)*EPOLL_SIZE); 46 | 47 | setnonblockingmode(serv_sock); 48 | event.events=EPOLLIN; 49 | event.data.fd=serv_sock; 50 | epoll_ctl(epfd, EPOLL_CTL_ADD, serv_sock, &event); 51 | 52 | while(1) 53 | { 54 | event_cnt=epoll_wait(epfd, ep_events, EPOLL_SIZE, -1); 55 | if(event_cnt==-1) 56 | { 57 | puts("epoll_wait() error"); 58 | break; 59 | } 60 | 61 | puts("return epoll_wait"); 62 | for(i=0; i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | #define BUF_SIZE 4 11 | #define EPOLL_SIZE 50 12 | void error_handling(char *buf); 13 | 14 | int main(int argc, char *argv[]) 15 | { 16 | int serv_sock, clnt_sock; 17 | struct sockaddr_in serv_adr, clnt_adr; 18 | socklen_t adr_sz; 19 | int str_len, i; 20 | char buf[BUF_SIZE]; 21 | 22 | struct epoll_event *ep_events; 23 | struct epoll_event event; 24 | int epfd, event_cnt; 25 | 26 | if(argc!=2) { 27 | printf("Usage : %s \n", argv[0]); 28 | exit(1); 29 | } 30 | 31 | serv_sock=socket(PF_INET, SOCK_STREAM, 0); 32 | memset(&serv_adr, 0, sizeof(serv_adr)); 33 | serv_adr.sin_family=AF_INET; 34 | serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 35 | serv_adr.sin_port=htons(atoi(argv[1])); 36 | 37 | if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1) 38 | error_handling("bind() error"); 39 | if(listen(serv_sock, 5)==-1) 40 | error_handling("listen() error"); 41 | 42 | epfd=epoll_create(EPOLL_SIZE); 43 | ep_events=malloc(sizeof(struct epoll_event)*EPOLL_SIZE); 44 | 45 | event.events=EPOLLIN; 46 | event.data.fd=serv_sock; 47 | epoll_ctl(epfd, EPOLL_CTL_ADD, serv_sock, &event); 48 | 49 | while(1) 50 | { 51 | event_cnt=epoll_wait(epfd, ep_events, EPOLL_SIZE, -1); 52 | if(event_cnt==-1) 53 | { 54 | puts("epoll_wait() error"); 55 | break; 56 | } 57 | 58 | puts("return epoll_wait"); 59 | for(i=0; i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 1024 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int sock; 14 | char message[BUF_SIZE]; 15 | int str_len; 16 | struct sockaddr_in serv_adr; 17 | 18 | if(argc!=3) { 19 | printf("Usage : %s \n", argv[0]); 20 | exit(1); 21 | } 22 | 23 | sock=socket(PF_INET, SOCK_STREAM, 0); 24 | if(sock==-1) 25 | error_handling("socket() error"); 26 | 27 | memset(&serv_adr, 0, sizeof(serv_adr)); 28 | serv_adr.sin_family=AF_INET; 29 | serv_adr.sin_addr.s_addr=inet_addr(argv[1]); 30 | serv_adr.sin_port=htons(atoi(argv[2])); 31 | 32 | if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1) 33 | error_handling("connect() error!"); 34 | else 35 | puts("Connected..........."); 36 | 37 | while(1) 38 | { 39 | fputs("Input message(Q to quit): ", stdout); 40 | fgets(message, BUF_SIZE, stdin); 41 | 42 | if(!strcmp(message,"q\n") || !strcmp(message,"Q\n")) 43 | break; 44 | 45 | write(sock, message, strlen(message)); 46 | str_len=read(sock, message, BUF_SIZE-1); 47 | message[str_len]=0; 48 | printf("Message from server: %s", message); 49 | } 50 | 51 | close(sock); 52 | return 0; 53 | } 54 | 55 | void error_handling(char *message) 56 | { 57 | fputs(message, stderr); 58 | fputc('\n', stderr); 59 | exit(1); 60 | } -------------------------------------------------------------------------------- /Chapter17 소스코드/echo_epollserv.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | #define BUF_SIZE 100 10 | #define EPOLL_SIZE 50 11 | void error_handling(char *buf); 12 | 13 | int main(int argc, char *argv[]) 14 | { 15 | int serv_sock, clnt_sock; 16 | struct sockaddr_in serv_adr, clnt_adr; 17 | socklen_t adr_sz; 18 | int str_len, i; 19 | char buf[BUF_SIZE]; 20 | 21 | struct epoll_event *ep_events; 22 | struct epoll_event event; 23 | int epfd, event_cnt; 24 | 25 | if(argc!=2) { 26 | printf("Usage : %s \n", argv[0]); 27 | exit(1); 28 | } 29 | 30 | serv_sock=socket(PF_INET, SOCK_STREAM, 0); 31 | memset(&serv_adr, 0, sizeof(serv_adr)); 32 | serv_adr.sin_family=AF_INET; 33 | serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 34 | serv_adr.sin_port=htons(atoi(argv[1])); 35 | 36 | if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1) 37 | error_handling("bind() error"); 38 | if(listen(serv_sock, 5)==-1) 39 | error_handling("listen() error"); 40 | 41 | epfd=epoll_create(EPOLL_SIZE); 42 | ep_events=malloc(sizeof(struct epoll_event)*EPOLL_SIZE); 43 | 44 | event.events=EPOLLIN; 45 | event.data.fd=serv_sock; 46 | epoll_ctl(epfd, EPOLL_CTL_ADD, serv_sock, &event); 47 | 48 | while(1) 49 | { 50 | event_cnt=epoll_wait(epfd, ep_events, EPOLL_SIZE, -1); 51 | if(event_cnt==-1) 52 | { 53 | puts("epoll_wait() error"); 54 | break; 55 | } 56 | 57 | for(i=0; i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | #define BUF_SIZE 100 10 | #define NAME_SIZE 20 11 | 12 | void * send_msg(void * arg); 13 | void * recv_msg(void * arg); 14 | void error_handling(char * msg); 15 | 16 | char name[NAME_SIZE]="[DEFAULT]"; 17 | char msg[BUF_SIZE]; 18 | 19 | int main(int argc, char *argv[]) 20 | { 21 | int sock; 22 | struct sockaddr_in serv_addr; 23 | pthread_t snd_thread, rcv_thread; 24 | void * thread_return; 25 | if(argc!=4) { 26 | printf("Usage : %s \n", argv[0]); 27 | exit(1); 28 | } 29 | 30 | sprintf(name, "[%s]", argv[3]); 31 | sock=socket(PF_INET, SOCK_STREAM, 0); 32 | 33 | memset(&serv_addr, 0, sizeof(serv_addr)); 34 | serv_addr.sin_family=AF_INET; 35 | serv_addr.sin_addr.s_addr=inet_addr(argv[1]); 36 | serv_addr.sin_port=htons(atoi(argv[2])); 37 | 38 | if(connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr))==-1) 39 | error_handling("connect() error"); 40 | 41 | pthread_create(&snd_thread, NULL, send_msg, (void*)&sock); 42 | pthread_create(&rcv_thread, NULL, recv_msg, (void*)&sock); 43 | pthread_join(snd_thread, &thread_return); 44 | pthread_join(rcv_thread, &thread_return); 45 | close(sock); 46 | return 0; 47 | } 48 | 49 | void * send_msg(void * arg) // send thread main 50 | { 51 | int sock=*((int*)arg); 52 | char name_msg[NAME_SIZE+BUF_SIZE]; 53 | while(1) 54 | { 55 | fgets(msg, BUF_SIZE, stdin); 56 | if(!strcmp(msg,"q\n")||!strcmp(msg,"Q\n")) 57 | { 58 | close(sock); 59 | exit(0); 60 | } 61 | sprintf(name_msg,"%s %s", name, msg); 62 | write(sock, name_msg, strlen(name_msg)); 63 | } 64 | return NULL; 65 | } 66 | 67 | void * recv_msg(void * arg) // read thread main 68 | { 69 | int sock=*((int*)arg); 70 | char name_msg[NAME_SIZE+BUF_SIZE]; 71 | int str_len; 72 | while(1) 73 | { 74 | str_len=read(sock, name_msg, NAME_SIZE+BUF_SIZE-1); 75 | if(str_len==-1) 76 | return (void*)-1; 77 | name_msg[str_len]=0; 78 | fputs(name_msg, stdout); 79 | } 80 | return NULL; 81 | } 82 | 83 | void error_handling(char *msg) 84 | { 85 | fputs(msg, stderr); 86 | fputc('\n', stderr); 87 | exit(1); 88 | } 89 | -------------------------------------------------------------------------------- /Chapter18 소스코드/chat_serv.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | #define BUF_SIZE 100 11 | #define MAX_CLNT 256 12 | 13 | void * handle_clnt(void * arg); 14 | void send_msg(char * msg, int len); 15 | void error_handling(char * msg); 16 | 17 | int clnt_cnt=0; 18 | int clnt_socks[MAX_CLNT]; 19 | pthread_mutex_t mutx; 20 | 21 | int main(int argc, char *argv[]) 22 | { 23 | int serv_sock, clnt_sock; 24 | struct sockaddr_in serv_adr, clnt_adr; 25 | int clnt_adr_sz; 26 | pthread_t t_id; 27 | if(argc!=2) { 28 | printf("Usage : %s \n", argv[0]); 29 | exit(1); 30 | } 31 | 32 | pthread_mutex_init(&mutx, NULL); 33 | serv_sock=socket(PF_INET, SOCK_STREAM, 0); 34 | 35 | memset(&serv_adr, 0, sizeof(serv_adr)); 36 | serv_adr.sin_family=AF_INET; 37 | serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 38 | serv_adr.sin_port=htons(atoi(argv[1])); 39 | 40 | if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1) 41 | error_handling("bind() error"); 42 | if(listen(serv_sock, 5)==-1) 43 | error_handling("listen() error"); 44 | 45 | while(1) 46 | { 47 | clnt_adr_sz=sizeof(clnt_adr); 48 | clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr,&clnt_adr_sz); 49 | 50 | pthread_mutex_lock(&mutx); 51 | clnt_socks[clnt_cnt++]=clnt_sock; 52 | pthread_mutex_unlock(&mutx); 53 | 54 | pthread_create(&t_id, NULL, handle_clnt, (void*)&clnt_sock); 55 | pthread_detach(t_id); 56 | printf("Connected client IP: %s \n", inet_ntoa(clnt_adr.sin_addr)); 57 | } 58 | close(serv_sock); 59 | return 0; 60 | } 61 | 62 | void * handle_clnt(void * arg) 63 | { 64 | int clnt_sock=*((int*)arg); 65 | int str_len=0, i; 66 | char msg[BUF_SIZE]; 67 | 68 | while((str_len=read(clnt_sock, msg, sizeof(msg)))!=0) 69 | send_msg(msg, str_len); 70 | 71 | pthread_mutex_lock(&mutx); 72 | for(i=0; i 2 | #include 3 | #include 4 | #include 5 | #define NUM_THREAD 100 6 | 7 | void * thread_inc(void * arg); 8 | void * thread_des(void * arg); 9 | 10 | long long num=0; 11 | pthread_mutex_t mutex; 12 | 13 | int main(int argc, char *argv[]) 14 | { 15 | pthread_t thread_id[NUM_THREAD]; 16 | int i; 17 | 18 | pthread_mutex_init(&mutex, NULL); 19 | 20 | for(i=0; i 2 | #include 3 | #include 4 | 5 | void * read(void * arg); 6 | void * accu(void * arg); 7 | static sem_t sem_one; 8 | static sem_t sem_two; 9 | static int num; 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | pthread_t id_t1, id_t2; 14 | sem_init(&sem_one, 0, 0); 15 | sem_init(&sem_two, 0, 1); 16 | 17 | pthread_create(&id_t1, NULL, read, NULL); 18 | pthread_create(&id_t2, NULL, accu, NULL); 19 | 20 | pthread_join(id_t1, NULL); 21 | pthread_join(id_t2, NULL); 22 | 23 | sem_destroy(&sem_one); 24 | sem_destroy(&sem_two); 25 | return 0; 26 | } 27 | 28 | void * read(void * arg) 29 | { 30 | int i; 31 | for(i=0; i<5; i++) 32 | { 33 | fputs("Input num: ", stdout); 34 | 35 | sem_wait(&sem_two); 36 | scanf("%d", &num); 37 | sem_post(&sem_one); 38 | } 39 | return NULL; 40 | } 41 | void * accu(void * arg) 42 | { 43 | int sum=0, i; 44 | for(i=0; i<5; i++) 45 | { 46 | sem_wait(&sem_one); 47 | sum+=num; 48 | sem_post(&sem_two); 49 | } 50 | printf("Result: %d \n", sum); 51 | return NULL; 52 | } -------------------------------------------------------------------------------- /Chapter18 소스코드/thread1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | void* thread_main(void *arg); 4 | 5 | int main(int argc, char *argv[]) 6 | { 7 | pthread_t t_id; 8 | int thread_param=5; 9 | 10 | if(pthread_create(&t_id, NULL, thread_main, (void*)&thread_param)!=0) 11 | { 12 | puts("pthread_create() error"); 13 | return -1; 14 | }; 15 | sleep(10); puts("end of main"); 16 | return 0; 17 | } 18 | 19 | void* thread_main(void *arg) 20 | { 21 | int i; 22 | int cnt=*((int*)arg); 23 | for(i=0; i 2 | #include 3 | #include 4 | #include 5 | void* thread_main(void *arg); 6 | 7 | int main(int argc, char *argv[]) 8 | { 9 | pthread_t t_id; 10 | int thread_param=5; 11 | void * thr_ret; 12 | 13 | if(pthread_create(&t_id, NULL, thread_main, (void*)&thread_param)!=0) 14 | { 15 | puts("pthread_create() error"); 16 | return -1; 17 | }; 18 | 19 | if(pthread_join(t_id, &thr_ret)!=0) 20 | { 21 | puts("pthread_join() error"); 22 | return -1; 23 | }; 24 | 25 | printf("Thread return message: %s \n", (char*)thr_ret); 26 | free(thr_ret); 27 | return 0; 28 | } 29 | 30 | void* thread_main(void *arg) 31 | { 32 | int i; 33 | int cnt=*((int*)arg); 34 | char * msg=(char *)malloc(sizeof(char)*50); 35 | strcpy(msg, "Hello, I'am thread~ \n"); 36 | 37 | for(i=0; i 2 | #include 3 | void * thread_summation(void * arg); 4 | 5 | int sum=0; 6 | 7 | int main(int argc, char *argv[]) 8 | { 9 | pthread_t id_t1, id_t2; 10 | int range1[]={1, 5}; 11 | int range2[]={6, 10}; 12 | 13 | pthread_create(&id_t1, NULL, thread_summation, (void *)range1); 14 | pthread_create(&id_t2, NULL, thread_summation, (void *)range2); 15 | 16 | pthread_join(id_t1, NULL); 17 | pthread_join(id_t2, NULL); 18 | printf("result: %d \n", sum); 19 | return 0; 20 | } 21 | 22 | void * thread_summation(void * arg) 23 | { 24 | int start=((int*)arg)[0]; 25 | int end=((int*)arg)[1]; 26 | 27 | while(start<=end) 28 | { 29 | sum+=start; 30 | start++; 31 | } 32 | return NULL; 33 | } 34 | -------------------------------------------------------------------------------- /Chapter18 소스코드/thread4.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #define NUM_THREAD 100 5 | 6 | void * thread_inc(void * arg); 7 | void * thread_des(void * arg); 8 | long long num=0; 9 | 10 | int main(int argc, char *argv[]) 11 | { 12 | HANDLE thread_id[NUM_THREAD]; 13 | int i; 14 | 15 | printf("sizeof long long: %d \n", sizeof(long long)); 16 | for(i=0; i 2 | #include 3 | #include /* _beginthreadex, _endthreadex */ 4 | 5 | unsigned WINAPI ThreadFunc(void *arg); 6 | 7 | int main(int argc, char *argv[]) 8 | { 9 | HANDLE hThread; 10 | unsigned threadID; 11 | int param=5; 12 | 13 | hThread=(HANDLE)_beginthreadex(NULL, 0, ThreadFunc, (void*)¶m, 0, &threadID); 14 | if(hThread==0) 15 | { 16 | puts("_beginthreadex() error"); 17 | return -1; 18 | } 19 | Sleep(3000); 20 | puts("end of main"); 21 | return 0; 22 | } 23 | 24 | 25 | unsigned WINAPI ThreadFunc(void *arg) 26 | { 27 | int i; 28 | int cnt=*((int*)arg); 29 | for(i=0; i 2 | #include 3 | #include 4 | 5 | unsigned WINAPI ThreadFunc(void *arg); 6 | 7 | int main(int argc, char *argv[]) 8 | { 9 | HANDLE hThread; 10 | DWORD wr; 11 | unsigned threadID; 12 | int param=5; 13 | 14 | hThread=(HANDLE)_beginthreadex(NULL, 0, ThreadFunc, (void*)¶m, 0, &threadID); 15 | if(hThread==0) 16 | { 17 | puts("_beginthreadex() error"); 18 | return -1; 19 | } 20 | 21 | if((wr=WaitForSingleObject(hThread, INFINITE))==WAIT_FAILED) 22 | { 23 | puts("thread wait error"); 24 | return -1; 25 | } 26 | 27 | printf("wait result: %s \n", (wr==WAIT_OBJECT_0) ? "signaled":"time-out"); 28 | 29 | puts("end of main"); 30 | return 0; 31 | } 32 | 33 | 34 | unsigned WINAPI ThreadFunc(void *arg) 35 | { 36 | int i; 37 | int cnt=*((int*)arg); 38 | for(i=0; i 2 | #include 3 | #include 4 | 5 | #define NUM_THREAD 50 6 | unsigned WINAPI threadInc(void * arg); 7 | unsigned WINAPI threadDes(void * arg); 8 | long long num=0; 9 | 10 | int main(int argc, char *argv[]) 11 | { 12 | HANDLE tHandles[NUM_THREAD]; 13 | int i; 14 | 15 | printf("sizeof long long: %d \n", sizeof(long long)); 16 | for(i=0; i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char* argv[]) 12 | { 13 | int sock; 14 | struct sockaddr_in serv_addr; 15 | char message[30]; 16 | int str_len=0; 17 | int idx=0, read_len=0; 18 | 19 | if(argc!=3){ 20 | printf("Usage : %s \n", argv[0]); 21 | exit(1); 22 | } 23 | 24 | sock=socket(PF_INET, SOCK_STREAM, 0); 25 | if(sock == -1) 26 | error_handling("socket() error"); 27 | 28 | memset(&serv_addr, 0, sizeof(serv_addr)); 29 | serv_addr.sin_family=AF_INET; 30 | serv_addr.sin_addr.s_addr=inet_addr(argv[1]); 31 | serv_addr.sin_port=htons(atoi(argv[2])); 32 | 33 | if(connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr))==-1) 34 | error_handling("connect() error!"); 35 | 36 | while(read_len=read(sock, &message[idx++], 1)) 37 | { 38 | if(read_len==-1) 39 | error_handling("read() error!"); 40 | 41 | str_len+=read_len; 42 | } 43 | 44 | printf("Message from server: %s \n", message); 45 | printf("Function read call count: %d \n", str_len); 46 | close(sock); 47 | return 0; 48 | } 49 | 50 | void error_handling(char *message) 51 | { 52 | fputs(message, stderr); 53 | fputc('\n', stderr); 54 | exit(1); 55 | } 56 | -------------------------------------------------------------------------------- /Chapter2 소스코드/tcp_client_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | void ErrorHandling(char* message); 5 | 6 | int main(int argc, char* argv[]) 7 | { 8 | WSADATA wsaData; 9 | SOCKET hSocket; 10 | SOCKADDR_IN servAddr; 11 | 12 | char message[30]; 13 | int strLen=0; 14 | int idx=0, readLen=0; 15 | 16 | if(argc!=3) 17 | { 18 | printf("Usage : %s \n", argv[0]); 19 | exit(1); 20 | } 21 | 22 | if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) 23 | ErrorHandling("WSAStartup() error!"); 24 | 25 | hSocket=socket(PF_INET, SOCK_STREAM, 0); 26 | if(hSocket==INVALID_SOCKET) 27 | ErrorHandling("hSocket() error"); 28 | 29 | memset(&servAddr, 0, sizeof(servAddr)); 30 | servAddr.sin_family=AF_INET; 31 | servAddr.sin_addr.s_addr=inet_addr(argv[1]); 32 | servAddr.sin_port=htons(atoi(argv[2])); 33 | 34 | if(connect(hSocket, (SOCKADDR*)&servAddr, sizeof(servAddr))==SOCKET_ERROR) 35 | ErrorHandling("connect() error!"); 36 | 37 | while(readLen=recv(hSocket, &message[idx++], 1, 0)) 38 | { 39 | if(readLen==-1) 40 | ErrorHandling("read() error!"); 41 | 42 | strLen+=readLen; 43 | } 44 | 45 | printf("Message from server: %s \n", message); 46 | printf("Function read call count: %d \n", strLen); 47 | 48 | closesocket(hSocket); 49 | WSACleanup(); 50 | return 0; 51 | } 52 | 53 | void ErrorHandling(char* message) 54 | { 55 | fputs(message, stderr); 56 | fputc('\n', stderr); 57 | exit(1); 58 | } -------------------------------------------------------------------------------- /Chapter2 소스코드/tcp_server.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int serv_sock; 14 | int clnt_sock; 15 | 16 | struct sockaddr_in serv_addr; 17 | struct sockaddr_in clnt_addr; 18 | socklen_t clnt_addr_size; 19 | 20 | char message[]="Hello World!"; 21 | 22 | if(argc!=2){ 23 | printf("Usage : %s \n", argv[0]); 24 | exit(1); 25 | } 26 | 27 | serv_sock=socket(PF_INET, SOCK_STREAM, 0); 28 | if(serv_sock == -1) 29 | error_handling("socket() error"); 30 | 31 | memset(&serv_addr, 0, sizeof(serv_addr)); 32 | serv_addr.sin_family=AF_INET; 33 | serv_addr.sin_addr.s_addr=htonl(INADDR_ANY); 34 | serv_addr.sin_port=htons(atoi(argv[1])); 35 | 36 | if(bind(serv_sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr))==-1) 37 | error_handling("bind() error"); 38 | 39 | if(listen(serv_sock, 5)==-1) 40 | error_handling("listen() error"); 41 | 42 | clnt_addr_size=sizeof(clnt_addr); 43 | clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_addr,&clnt_addr_size); 44 | if(clnt_sock==-1) 45 | error_handling("accept() error"); 46 | 47 | write(clnt_sock, message, sizeof(message)); 48 | close(clnt_sock); 49 | close(serv_sock); 50 | return 0; 51 | } 52 | 53 | void error_handling(char *message) 54 | { 55 | fputs(message, stderr); 56 | fputc('\n', stderr); 57 | exit(1); 58 | } 59 | -------------------------------------------------------------------------------- /Chapter2 소스코드/tcp_server_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | void ErrorHandling(char* message); 5 | 6 | int main(int argc, char* argv[]) 7 | { 8 | WSADATA wsaData; 9 | SOCKET hServSock, hClntSock; 10 | SOCKADDR_IN servAddr, clntAddr; 11 | 12 | int szClntAddr; 13 | char message[]="Hello World!"; 14 | 15 | if(argc!=2) 16 | { 17 | printf("Usage : %s \n", argv[0]); 18 | exit(1); 19 | } 20 | 21 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 22 | ErrorHandling("WSAStartup() error!"); 23 | 24 | hServSock=socket(PF_INET, SOCK_STREAM, 0); 25 | if(hServSock==INVALID_SOCKET) 26 | ErrorHandling("socket() error"); 27 | 28 | memset(&servAddr, 0, sizeof(servAddr)); 29 | servAddr.sin_family=AF_INET; 30 | servAddr.sin_addr.s_addr=htonl(INADDR_ANY); 31 | servAddr.sin_port=htons(atoi(argv[1])); 32 | 33 | if(bind(hServSock, (SOCKADDR*) &servAddr, sizeof(servAddr))==SOCKET_ERROR) 34 | ErrorHandling("bind() error"); 35 | 36 | if(listen(hServSock, 5)==SOCKET_ERROR) 37 | ErrorHandling("listen() error"); 38 | 39 | szClntAddr=sizeof(clntAddr); 40 | hClntSock=accept(hServSock, (SOCKADDR*)&clntAddr,&szClntAddr); 41 | if(hClntSock==INVALID_SOCKET) 42 | ErrorHandling("accept() error"); 43 | 44 | send(hClntSock, message, sizeof(message), 0); 45 | closesocket(hClntSock); 46 | closesocket(hServSock); 47 | WSACleanup(); 48 | return 0; 49 | } 50 | 51 | void ErrorHandling(char* message) 52 | { 53 | fputs(message, stderr); 54 | fputc('\n', stderr); 55 | exit(1); 56 | } 57 | -------------------------------------------------------------------------------- /Chapter20 소스코드/SyncCS_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define NUM_THREAD 50 6 | unsigned WINAPI threadInc(void * arg); 7 | unsigned WINAPI threadDes(void * arg); 8 | 9 | long long num=0; 10 | CRITICAL_SECTION cs; 11 | 12 | int main(int argc, char *argv[]) 13 | { 14 | HANDLE tHandles[NUM_THREAD]; 15 | int i; 16 | 17 | InitializeCriticalSection(&cs); 18 | for(i=0; i 2 | #include 3 | #include 4 | #define STR_LEN 100 5 | 6 | unsigned WINAPI NumberOfA(void *arg); 7 | unsigned WINAPI NumberOfOthers(void *arg); 8 | 9 | static char str[STR_LEN]; 10 | static HANDLE hEvent; 11 | 12 | int main(int argc, char *argv[]) 13 | { 14 | HANDLE hThread1, hThread2; 15 | 16 | hEvent=CreateEvent(NULL, TRUE, FALSE, NULL); 17 | hThread1=(HANDLE)_beginthreadex(NULL, 0, NumberOfA, NULL, 0, NULL); 18 | hThread2=(HANDLE)_beginthreadex(NULL, 0, NumberOfOthers, NULL, 0, NULL); 19 | 20 | fputs("Input string: ", stdout); 21 | fgets(str, STR_LEN, stdin); 22 | SetEvent(hEvent); 23 | 24 | WaitForSingleObject(hThread1, INFINITE); 25 | WaitForSingleObject(hThread2, INFINITE); 26 | ResetEvent(hEvent); 27 | CloseHandle(hEvent); 28 | return 0; 29 | } 30 | 31 | unsigned WINAPI NumberOfA(void *arg) 32 | { 33 | int i, cnt=0; 34 | WaitForSingleObject(hEvent, INFINITE); 35 | for(i=0; str[i]!=0; i++) 36 | { 37 | if(str[i]=='A') 38 | cnt++; 39 | } 40 | printf("Num of A: %d \n", cnt); 41 | return 0; 42 | } 43 | unsigned WINAPI NumberOfOthers(void *arg) 44 | { 45 | int i, cnt=0; 46 | WaitForSingleObject(hEvent, INFINITE); 47 | for(i=0; str[i]!=0; i++) 48 | { 49 | if(str[i]!='A') 50 | cnt++; 51 | } 52 | printf("Num of others: %d \n", cnt-1); 53 | return 0; 54 | } -------------------------------------------------------------------------------- /Chapter20 소스코드/SyncMutex_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define NUM_THREAD 50 6 | unsigned WINAPI threadInc(void * arg); 7 | unsigned WINAPI threadDes(void * arg); 8 | 9 | long long num=0; 10 | HANDLE hMutex; 11 | 12 | int main(int argc, char *argv[]) 13 | { 14 | HANDLE tHandles[NUM_THREAD]; 15 | int i; 16 | 17 | hMutex=CreateMutex(NULL, FALSE, NULL); 18 | for(i=0; i 2 | #include 3 | #include 4 | 5 | unsigned WINAPI Read(void * arg); 6 | unsigned WINAPI Accu(void * arg); 7 | 8 | static HANDLE semOne; 9 | static HANDLE semTwo; 10 | static int num; 11 | 12 | int main(int argc, char *argv[]) 13 | { 14 | HANDLE hThread1, hThread2; 15 | semOne=CreateSemaphore(NULL, 0, 1, NULL); 16 | semTwo=CreateSemaphore(NULL, 1, 1, NULL); 17 | 18 | hThread1=(HANDLE)_beginthreadex(NULL, 0, Read, NULL, 0, NULL); 19 | hThread2=(HANDLE)_beginthreadex(NULL, 0, Accu, NULL, 0, NULL); 20 | 21 | WaitForSingleObject(hThread1, INFINITE); 22 | WaitForSingleObject(hThread2, INFINITE); 23 | 24 | CloseHandle(semOne); 25 | CloseHandle(semTwo); 26 | return 0; 27 | } 28 | 29 | unsigned WINAPI Read(void * arg) 30 | { 31 | int i; 32 | for(i=0; i<5; i++) 33 | { 34 | fputs("Input num: ", stdout); 35 | 36 | WaitForSingleObject(semTwo, INFINITE); 37 | scanf("%d", &num); 38 | ReleaseSemaphore(semOne, 1, NULL); 39 | } 40 | return 0; 41 | } 42 | unsigned WINAPI Accu(void * arg) 43 | { 44 | int sum=0, i; 45 | for(i=0; i<5; i++) 46 | { 47 | WaitForSingleObject(semOne, INFINITE); 48 | sum+=num; 49 | ReleaseSemaphore(semTwo, 1, NULL); 50 | } 51 | printf("Result: %d \n", sum); 52 | return 0; 53 | } -------------------------------------------------------------------------------- /Chapter20 소스코드/chat_clnt_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #define BUF_SIZE 100 8 | #define NAME_SIZE 20 9 | 10 | unsigned WINAPI SendMsg(void * arg); 11 | unsigned WINAPI RecvMsg(void * arg); 12 | void ErrorHandling(char * msg); 13 | 14 | char name[NAME_SIZE]="[DEFAULT]"; 15 | char msg[BUF_SIZE]; 16 | 17 | int main(int argc, char *argv[]) 18 | { 19 | WSADATA wsaData; 20 | SOCKET hSock; 21 | SOCKADDR_IN servAdr; 22 | HANDLE hSndThread, hRcvThread; 23 | if(argc!=4) { 24 | printf("Usage : %s \n", argv[0]); 25 | exit(1); 26 | } 27 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 28 | ErrorHandling("WSAStartup() error!"); 29 | 30 | sprintf(name, "[%s]", argv[3]); 31 | hSock=socket(PF_INET, SOCK_STREAM, 0); 32 | 33 | memset(&servAdr, 0, sizeof(servAdr)); 34 | servAdr.sin_family=AF_INET; 35 | servAdr.sin_addr.s_addr=inet_addr(argv[1]); 36 | servAdr.sin_port=htons(atoi(argv[2])); 37 | 38 | if(connect(hSock, (SOCKADDR*)&servAdr, sizeof(servAdr))==SOCKET_ERROR) 39 | ErrorHandling("connect() error"); 40 | 41 | hSndThread= 42 | (HANDLE)_beginthreadex(NULL, 0, SendMsg, (void*)&hSock, 0, NULL); 43 | hRcvThread= 44 | (HANDLE)_beginthreadex(NULL, 0, RecvMsg, (void*)&hSock, 0, NULL); 45 | 46 | WaitForSingleObject(hSndThread, INFINITE); 47 | WaitForSingleObject(hRcvThread, INFINITE); 48 | closesocket(hSock); 49 | WSACleanup(); 50 | return 0; 51 | } 52 | 53 | unsigned WINAPI SendMsg(void * arg) // send thread main 54 | { 55 | SOCKET hSock=*((SOCKET*)arg); 56 | char nameMsg[NAME_SIZE+BUF_SIZE]; 57 | while(1) 58 | { 59 | fgets(msg, BUF_SIZE, stdin); 60 | if(!strcmp(msg,"q\n")||!strcmp(msg,"Q\n")) 61 | { 62 | closesocket(hSock); 63 | exit(0); 64 | } 65 | sprintf(nameMsg,"%s %s", name, msg); 66 | send(hSock, nameMsg, strlen(nameMsg), 0); 67 | } 68 | return 0; 69 | } 70 | 71 | unsigned WINAPI RecvMsg(void * arg) // read thread main 72 | { 73 | int hSock=*((SOCKET*)arg); 74 | char nameMsg[NAME_SIZE+BUF_SIZE]; 75 | int strLen; 76 | while(1) 77 | { 78 | strLen=recv(hSock, nameMsg, NAME_SIZE+BUF_SIZE-1, 0); 79 | if(strLen==-1) 80 | return -1; 81 | nameMsg[strLen]=0; 82 | fputs(nameMsg, stdout); 83 | } 84 | return 0; 85 | } 86 | 87 | void ErrorHandling(char *msg) 88 | { 89 | fputs(msg, stderr); 90 | fputc('\n', stderr); 91 | exit(1); 92 | } 93 | -------------------------------------------------------------------------------- /Chapter20 소스코드/chat_serv_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #define BUF_SIZE 100 8 | #define MAX_CLNT 256 9 | 10 | unsigned WINAPI HandleClnt(void * arg); 11 | void SendMsg(char * msg, int len); 12 | void ErrorHandling(char * msg); 13 | 14 | int clntCnt=0; 15 | SOCKET clntSocks[MAX_CLNT]; 16 | HANDLE hMutex; 17 | 18 | int main(int argc, char *argv[]) 19 | { 20 | WSADATA wsaData; 21 | SOCKET hServSock, hClntSock; 22 | SOCKADDR_IN servAdr, clntAdr; 23 | int clntAdrSz; 24 | HANDLE hThread; 25 | if(argc!=2) { 26 | printf("Usage : %s \n", argv[0]); 27 | exit(1); 28 | } 29 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 30 | ErrorHandling("WSAStartup() error!"); 31 | 32 | hMutex=CreateMutex(NULL, FALSE, NULL); 33 | hServSock=socket(PF_INET, SOCK_STREAM, 0); 34 | 35 | memset(&servAdr, 0, sizeof(servAdr)); 36 | servAdr.sin_family=AF_INET; 37 | servAdr.sin_addr.s_addr=htonl(INADDR_ANY); 38 | servAdr.sin_port=htons(atoi(argv[1])); 39 | 40 | if(bind(hServSock, (SOCKADDR*) &servAdr, sizeof(servAdr))==SOCKET_ERROR) 41 | ErrorHandling("bind() error"); 42 | if(listen(hServSock, 5)==SOCKET_ERROR) 43 | ErrorHandling("listen() error"); 44 | 45 | while(1) 46 | { 47 | clntAdrSz=sizeof(clntAdr); 48 | hClntSock=accept(hServSock, (SOCKADDR*)&clntAdr,&clntAdrSz); 49 | 50 | WaitForSingleObject(hMutex, INFINITE); 51 | clntSocks[clntCnt++]=hClntSock; 52 | ReleaseMutex(hMutex); 53 | 54 | hThread= 55 | (HANDLE)_beginthreadex(NULL, 0, HandleClnt, (void*)&hClntSock, 0, NULL); 56 | printf("Connected client IP: %s \n", inet_ntoa(clntAdr.sin_addr)); 57 | } 58 | closesocket(hServSock); 59 | WSACleanup(); 60 | return 0; 61 | } 62 | 63 | unsigned WINAPI HandleClnt(void * arg) 64 | { 65 | SOCKET hClntSock=*((SOCKET*)arg); 66 | int strLen=0, i; 67 | char msg[BUF_SIZE]; 68 | 69 | while((strLen=recv(hClntSock, msg, sizeof(msg), 0))!=0) 70 | SendMsg(msg, strLen); 71 | 72 | WaitForSingleObject(hMutex, INFINITE); 73 | for(i=0; i 2 | #include 3 | #include 4 | 5 | #define BUF_SIZE 100 6 | 7 | void CompressSockets(SOCKET hSockArr[], int idx, int total); 8 | void CompressEvents(WSAEVENT hEventArr[], int idx, int total); 9 | void ErrorHandling(char *msg); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | WSADATA wsaData; 14 | SOCKET hServSock, hClntSock; 15 | SOCKADDR_IN servAdr, clntAdr; 16 | 17 | SOCKET hSockArr[WSA_MAXIMUM_WAIT_EVENTS]; 18 | WSAEVENT hEventArr[WSA_MAXIMUM_WAIT_EVENTS]; 19 | WSAEVENT newEvent; 20 | WSANETWORKEVENTS netEvents; 21 | 22 | int numOfClntSock=0; 23 | int strLen, i; 24 | int posInfo, startIdx; 25 | int clntAdrLen; 26 | char msg[BUF_SIZE]; 27 | 28 | if(argc!=2) { 29 | printf("Usage: %s \n", argv[0]); 30 | exit(1); 31 | } 32 | if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) 33 | ErrorHandling("WSAStartup() error!"); 34 | 35 | hServSock=socket(PF_INET, SOCK_STREAM, 0); 36 | memset(&servAdr, 0, sizeof(servAdr)); 37 | servAdr.sin_family=AF_INET; 38 | servAdr.sin_addr.s_addr=htonl(INADDR_ANY); 39 | servAdr.sin_port=htons(atoi(argv[1])); 40 | 41 | if(bind(hServSock, (SOCKADDR*) &servAdr, sizeof(servAdr))==SOCKET_ERROR) 42 | ErrorHandling("bind() error"); 43 | 44 | if(listen(hServSock, 5)==SOCKET_ERROR) 45 | ErrorHandling("listen() error"); 46 | 47 | newEvent=WSACreateEvent(); 48 | if(WSAEventSelect(hServSock, newEvent, FD_ACCEPT)==SOCKET_ERROR) 49 | ErrorHandling("WSAEventSelect() error"); 50 | 51 | hSockArr[numOfClntSock]=hServSock; 52 | hEventArr[numOfClntSock]=newEvent; 53 | numOfClntSock++; 54 | 55 | while(1) 56 | { 57 | posInfo=WSAWaitForMultipleEvents( 58 | numOfClntSock, hEventArr, FALSE, WSA_INFINITE, FALSE); 59 | startIdx=posInfo-WSA_WAIT_EVENT_0; 60 | 61 | for(i=startIdx; i 2 | #include 3 | #include 4 | #include 5 | 6 | #define BUF_SIZE 1024 7 | void ErrorHandling(char *message); 8 | 9 | int main(int argc, char *argv[]) 10 | { 11 | WSADATA wsaData; 12 | SOCKET hSocket; 13 | char message[BUF_SIZE]; 14 | int strLen; 15 | SOCKADDR_IN servAdr; 16 | 17 | if(argc!=3) { 18 | printf("Usage : %s \n", argv[0]); 19 | exit(1); 20 | } 21 | 22 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 23 | ErrorHandling("WSAStartup() error!"); 24 | 25 | hSocket=socket(PF_INET, SOCK_STREAM, 0); 26 | if(hSocket==INVALID_SOCKET) 27 | ErrorHandling("socket() error"); 28 | 29 | memset(&servAdr, 0, sizeof(servAdr)); 30 | servAdr.sin_family=AF_INET; 31 | servAdr.sin_addr.s_addr=inet_addr(argv[1]); 32 | servAdr.sin_port=htons(atoi(argv[2])); 33 | 34 | if(connect(hSocket, (SOCKADDR*)&servAdr, sizeof(servAdr))==SOCKET_ERROR) 35 | ErrorHandling("connect() error!"); 36 | else 37 | puts("Connected..........."); 38 | 39 | while(1) 40 | { 41 | fputs("Input message(Q to quit): ", stdout); 42 | fgets(message, BUF_SIZE, stdin); 43 | 44 | if(!strcmp(message,"q\n") || !strcmp(message,"Q\n")) 45 | break; 46 | 47 | send(hSocket, message, strlen(message), 0); 48 | strLen=recv(hSocket, message, BUF_SIZE-1, 0); 49 | message[strLen]=0; 50 | printf("Message from server: %s", message); 51 | } 52 | 53 | closesocket(hSocket); 54 | WSACleanup(); 55 | return 0; 56 | } 57 | 58 | void ErrorHandling(char *message) 59 | { 60 | fputs(message, stderr); 61 | fputc('\n', stderr); 62 | exit(1); 63 | } -------------------------------------------------------------------------------- /Chapter22 소스코드/CmplRoutinesRecv_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define BUF_SIZE 1024 6 | void CALLBACK CompRoutine(DWORD, DWORD, LPWSAOVERLAPPED, DWORD); 7 | void ErrorHandling(char *message); 8 | 9 | WSABUF dataBuf; 10 | char buf[BUF_SIZE]; 11 | int recvBytes=0; 12 | 13 | int main(int argc, char* argv[]) 14 | { 15 | WSADATA wsaData; 16 | SOCKET hLisnSock, hRecvSock; 17 | SOCKADDR_IN lisnAdr, recvAdr; 18 | 19 | WSAOVERLAPPED overlapped; 20 | WSAEVENT evObj; 21 | 22 | int idx, recvAdrSz, flags=0; 23 | if(argc!=2) { 24 | printf("Usage: %s \n", argv[0]); 25 | exit(1); 26 | } 27 | if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) 28 | ErrorHandling("WSAStartup() error!"); 29 | 30 | hLisnSock=WSASocket(PF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED); 31 | memset(&lisnAdr, 0, sizeof(lisnAdr)); 32 | lisnAdr.sin_family=AF_INET; 33 | lisnAdr.sin_addr.s_addr=htonl(INADDR_ANY); 34 | lisnAdr.sin_port=htons(atoi(argv[1])); 35 | 36 | if(bind(hLisnSock, (SOCKADDR*) &lisnAdr, sizeof(lisnAdr))==SOCKET_ERROR) 37 | ErrorHandling("bind() error"); 38 | if(listen(hLisnSock, 5)==SOCKET_ERROR) 39 | ErrorHandling("listen() error"); 40 | 41 | recvAdrSz=sizeof(recvAdr); 42 | hRecvSock=accept(hLisnSock, (SOCKADDR*)&recvAdr,&recvAdrSz); 43 | if(hRecvSock==INVALID_SOCKET) 44 | ErrorHandling("accept() error"); 45 | 46 | memset(&overlapped, 0, sizeof(overlapped)); 47 | dataBuf.len=BUF_SIZE; 48 | dataBuf.buf=buf; 49 | evObj=WSACreateEvent(); //Dummy event object 50 | 51 | if(WSARecv(hRecvSock, &dataBuf, 1, &recvBytes, &flags, &overlapped, CompRoutine) 52 | ==SOCKET_ERROR) 53 | { 54 | if(WSAGetLastError()==WSA_IO_PENDING) 55 | puts("Background data receive"); 56 | } 57 | 58 | idx=WSAWaitForMultipleEvents(1, &evObj, FALSE, WSA_INFINITE, TRUE); 59 | if(idx==WAIT_IO_COMPLETION) 60 | puts("Overlapped I/O Completed"); 61 | else // If error occurred! 62 | ErrorHandling("WSARecv() error"); 63 | 64 | WSACloseEvent(evObj); 65 | closesocket(hRecvSock); 66 | closesocket(hLisnSock); 67 | WSACleanup(); 68 | return 0; 69 | } 70 | 71 | void CALLBACK CompRoutine( 72 | DWORD dwError, DWORD szRecvBytes, LPWSAOVERLAPPED lpOverlapped, DWORD flags) 73 | { 74 | if(dwError!=0) 75 | { 76 | ErrorHandling("CompRoutine error"); 77 | } 78 | else 79 | { 80 | recvBytes=szRecvBytes; 81 | printf("Received message: %s \n", buf); 82 | } 83 | } 84 | 85 | void ErrorHandling(char *message) 86 | { 87 | fputs(message, stderr); 88 | fputc('\n', stderr); 89 | exit(1); 90 | } 91 | -------------------------------------------------------------------------------- /Chapter22 소스코드/OverlappedRecv_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define BUF_SIZE 1024 6 | void ErrorHandling(char *message); 7 | 8 | int main(int argc, char* argv[]) 9 | { 10 | WSADATA wsaData; 11 | SOCKET hLisnSock, hRecvSock; 12 | SOCKADDR_IN lisnAdr, recvAdr; 13 | int recvAdrSz; 14 | 15 | WSABUF dataBuf; 16 | WSAEVENT evObj; 17 | WSAOVERLAPPED overlapped; 18 | 19 | char buf[BUF_SIZE]; 20 | int recvBytes=0, flags=0; 21 | 22 | if(argc!=2) { 23 | printf("Usage : %s \n", argv[0]); 24 | exit(1); 25 | } 26 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 27 | ErrorHandling("WSAStartup() error!"); 28 | 29 | hLisnSock=WSASocket(PF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED); 30 | memset(&lisnAdr, 0, sizeof(lisnAdr)); 31 | lisnAdr.sin_family=AF_INET; 32 | lisnAdr.sin_addr.s_addr=htonl(INADDR_ANY); 33 | lisnAdr.sin_port=htons(atoi(argv[1])); 34 | 35 | if(bind(hLisnSock, (SOCKADDR*) &lisnAdr, sizeof(lisnAdr))==SOCKET_ERROR) 36 | ErrorHandling("bind() error"); 37 | 38 | if(listen(hLisnSock, 5)==SOCKET_ERROR) 39 | ErrorHandling("listen() error"); 40 | 41 | recvAdrSz=sizeof(recvAdr); 42 | hRecvSock=accept(hLisnSock, (SOCKADDR*)&recvAdr,&recvAdrSz); 43 | 44 | evObj=WSACreateEvent(); 45 | memset(&overlapped, 0, sizeof(overlapped)); 46 | overlapped.hEvent=evObj; 47 | dataBuf.len=BUF_SIZE; 48 | dataBuf.buf=buf; 49 | 50 | if(WSARecv(hRecvSock, &dataBuf, 1, &recvBytes, &flags, &overlapped, NULL) 51 | ==SOCKET_ERROR) 52 | { 53 | if(WSAGetLastError()==WSA_IO_PENDING) 54 | { 55 | puts("Background data receive"); 56 | WSAWaitForMultipleEvents(1, &evObj, TRUE, WSA_INFINITE, FALSE); 57 | WSAGetOverlappedResult(hRecvSock, &overlapped, &recvBytes, FALSE, NULL); 58 | } 59 | else 60 | { 61 | ErrorHandling("WSARecv() error"); 62 | } 63 | } 64 | 65 | printf("Received message: %s \n", buf); 66 | WSACloseEvent(evObj); 67 | closesocket(hRecvSock); 68 | closesocket(hLisnSock); 69 | WSACleanup(); 70 | return 0; 71 | } 72 | 73 | void ErrorHandling(char *message) 74 | { 75 | fputs(message, stderr); 76 | fputc('\n', stderr); 77 | exit(1); 78 | } -------------------------------------------------------------------------------- /Chapter22 소스코드/OverlappedSend_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | void ErrorHandling(char *msg); 5 | 6 | int main(int argc, char *argv[]) 7 | { 8 | WSADATA wsaData; 9 | SOCKET hSocket; 10 | SOCKADDR_IN sendAdr; 11 | 12 | WSABUF dataBuf; 13 | char msg[]="Network is Computer!"; 14 | int sendBytes=0; 15 | 16 | WSAEVENT evObj; 17 | WSAOVERLAPPED overlapped; 18 | 19 | if(argc!=3) { 20 | printf("Usage: %s \n", argv[0]); 21 | exit(1); 22 | } 23 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 24 | ErrorHandling("WSAStartup() error!"); 25 | 26 | hSocket=WSASocket(PF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED); 27 | memset(&sendAdr, 0, sizeof(sendAdr)); 28 | sendAdr.sin_family=AF_INET; 29 | sendAdr.sin_addr.s_addr=inet_addr(argv[1]); 30 | sendAdr.sin_port=htons(atoi(argv[2])); 31 | 32 | if(connect(hSocket, (SOCKADDR*)&sendAdr, sizeof(sendAdr))==SOCKET_ERROR) 33 | ErrorHandling("connect() error!"); 34 | 35 | evObj=WSACreateEvent(); 36 | memset(&overlapped, 0, sizeof(overlapped)); 37 | 38 | overlapped.hEvent=evObj; 39 | dataBuf.len=strlen(msg)+1; 40 | dataBuf.buf=msg; 41 | 42 | if(WSASend(hSocket, &dataBuf, 1, &sendBytes, 0, &overlapped, NULL) 43 | ==SOCKET_ERROR) 44 | { 45 | if(WSAGetLastError()==WSA_IO_PENDING) 46 | { 47 | puts("Background data send"); 48 | WSAWaitForMultipleEvents(1, &evObj, TRUE, WSA_INFINITE, FALSE); 49 | WSAGetOverlappedResult(hSocket, &overlapped, &sendBytes, FALSE, NULL); 50 | } 51 | else 52 | { 53 | ErrorHandling("WSASend() error"); 54 | } 55 | } 56 | 57 | printf("Send data size: %d \n", sendBytes); 58 | WSACloseEvent(evObj); 59 | closesocket(hSocket); 60 | WSACleanup(); 61 | return 0; 62 | } 63 | 64 | void ErrorHandling(char *msg) 65 | { 66 | fputs(msg, stderr); 67 | fputc('\n', stderr); 68 | exit(1); 69 | } -------------------------------------------------------------------------------- /Chapter23 소스코드/CmplRouEchoServ_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define BUF_SIZE 1024 6 | void CALLBACK ReadCompRoutine(DWORD, DWORD, LPWSAOVERLAPPED, DWORD); 7 | void CALLBACK WriteCompRoutine(DWORD, DWORD, LPWSAOVERLAPPED, DWORD); 8 | void ErrorHandling(char *message); 9 | 10 | typedef struct 11 | { 12 | SOCKET hClntSock; 13 | char buf[BUF_SIZE]; 14 | WSABUF wsaBuf; 15 | } PER_IO_DATA, *LPPER_IO_DATA; 16 | 17 | int main(int argc, char* argv[]) 18 | { 19 | WSADATA wsaData; 20 | SOCKET hLisnSock, hRecvSock; 21 | SOCKADDR_IN lisnAdr, recvAdr; 22 | LPWSAOVERLAPPED lpOvLp; 23 | DWORD recvBytes; 24 | LPPER_IO_DATA hbInfo; 25 | int mode=1, recvAdrSz, flagInfo=0; 26 | 27 | if(argc!=2) { 28 | printf("Usage: %s \n", argv[0]); 29 | exit(1); 30 | } 31 | 32 | if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) 33 | ErrorHandling("WSAStartup() error!"); 34 | 35 | hLisnSock=WSASocket(PF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED); 36 | ioctlsocket(hLisnSock, FIONBIO, &mode); // for non-blocking socket 37 | 38 | memset(&lisnAdr, 0, sizeof(lisnAdr)); 39 | lisnAdr.sin_family=AF_INET; 40 | lisnAdr.sin_addr.s_addr=htonl(INADDR_ANY); 41 | lisnAdr.sin_port=htons(atoi(argv[1])); 42 | 43 | if(bind(hLisnSock, (SOCKADDR*) &lisnAdr, sizeof(lisnAdr))==SOCKET_ERROR) 44 | ErrorHandling("bind() error"); 45 | if(listen(hLisnSock, 5)==SOCKET_ERROR) 46 | ErrorHandling("listen() error"); 47 | 48 | recvAdrSz=sizeof(recvAdr); 49 | 50 | while(1) 51 | { 52 | SleepEx(100, TRUE); // for alertable wait state 53 | hRecvSock=accept(hLisnSock, (SOCKADDR*)&recvAdr,&recvAdrSz); 54 | if(hRecvSock==INVALID_SOCKET) 55 | { 56 | if(WSAGetLastError()==WSAEWOULDBLOCK) 57 | continue; 58 | else 59 | ErrorHandling("accept() error"); 60 | } 61 | puts("Client connected....."); 62 | 63 | lpOvLp=(LPWSAOVERLAPPED)malloc(sizeof(WSAOVERLAPPED)); 64 | memset(lpOvLp, 0, sizeof(WSAOVERLAPPED)); 65 | 66 | hbInfo=(LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA)); 67 | hbInfo->hClntSock=(DWORD)hRecvSock; 68 | (hbInfo->wsaBuf).buf=hbInfo->buf; 69 | (hbInfo->wsaBuf).len=BUF_SIZE; 70 | 71 | lpOvLp->hEvent=(HANDLE)hbInfo; 72 | WSARecv(hRecvSock, &(hbInfo->wsaBuf), 73 | 1, &recvBytes, &flagInfo, lpOvLp, ReadCompRoutine); 74 | } 75 | closesocket(hRecvSock); 76 | closesocket(hLisnSock); 77 | WSACleanup(); 78 | return 0; 79 | } 80 | 81 | void CALLBACK ReadCompRoutine( 82 | DWORD dwError, DWORD szRecvBytes, LPWSAOVERLAPPED lpOverlapped, DWORD flags) 83 | { 84 | LPPER_IO_DATA hbInfo=(LPPER_IO_DATA)(lpOverlapped->hEvent); 85 | SOCKET hSock=hbInfo->hClntSock; 86 | LPWSABUF bufInfo=&(hbInfo->wsaBuf); 87 | DWORD sentBytes; 88 | 89 | if(szRecvBytes==0) 90 | { 91 | closesocket(hSock); 92 | free(lpOverlapped->hEvent); free(lpOverlapped); 93 | puts("Client disconnected....."); 94 | } 95 | else // echo! 96 | { 97 | bufInfo->len=szRecvBytes; 98 | WSASend(hSock, bufInfo, 1, &sentBytes, 0, lpOverlapped, WriteCompRoutine); 99 | } 100 | } 101 | 102 | void CALLBACK WriteCompRoutine( 103 | DWORD dwError, DWORD szSendBytes, LPWSAOVERLAPPED lpOverlapped, DWORD flags) 104 | { 105 | LPPER_IO_DATA hbInfo=(LPPER_IO_DATA)(lpOverlapped->hEvent); 106 | SOCKET hSock=hbInfo->hClntSock; 107 | LPWSABUF bufInfo=&(hbInfo->wsaBuf); 108 | DWORD recvBytes; 109 | int flagInfo=0; 110 | WSARecv(hSock, bufInfo, 111 | 1, &recvBytes, &flagInfo, lpOverlapped, ReadCompRoutine); 112 | } 113 | 114 | void ErrorHandling(char *message) 115 | { 116 | fputs(message, stderr); 117 | fputc('\n', stderr); 118 | exit(1); 119 | } 120 | -------------------------------------------------------------------------------- /Chapter23 소스코드/IOCPEchoServ_win.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/exgs/ambition_socket_programming/1d365fe728e39ed0b5e16b6d1e295d2ed79a29a0/Chapter23 소스코드/IOCPEchoServ_win.c -------------------------------------------------------------------------------- /Chapter23 소스코드/StableEchoClnt_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define BUF_SIZE 1024 6 | void ErrorHandling(char *message); 7 | 8 | int main(int argc, char *argv[]) 9 | { 10 | WSADATA wsaData; 11 | SOCKET hSocket; 12 | SOCKADDR_IN servAdr; 13 | char message[BUF_SIZE]; 14 | int strLen, readLen; 15 | 16 | if(argc!=3) { 17 | printf("Usage: %s \n", argv[0]); 18 | exit(1); 19 | } 20 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 21 | ErrorHandling("WSAStartup() error!"); 22 | 23 | hSocket=socket(PF_INET, SOCK_STREAM, 0); 24 | if(hSocket==INVALID_SOCKET) 25 | ErrorHandling("socket() error"); 26 | 27 | memset(&servAdr, 0, sizeof(servAdr)); 28 | servAdr.sin_family=AF_INET; 29 | servAdr.sin_addr.s_addr=inet_addr(argv[1]); 30 | servAdr.sin_port=htons(atoi(argv[2])); 31 | 32 | if(connect(hSocket, (SOCKADDR*)&servAdr, sizeof(servAdr))==SOCKET_ERROR) 33 | ErrorHandling("connect() error!"); 34 | else 35 | puts("Connected..........."); 36 | 37 | while(1) 38 | { 39 | fputs("Input message(Q to quit): ", stdout); 40 | fgets(message, BUF_SIZE, stdin); 41 | if(!strcmp(message,"q\n") || !strcmp(message,"Q\n")) 42 | break; 43 | 44 | strLen=strlen(message); 45 | send(hSocket, message, strLen, 0); 46 | 47 | readLen=0; 48 | while(1) 49 | { 50 | readLen+=recv(hSocket, &message[readLen], BUF_SIZE-1, 0); 51 | if(readLen>=strLen) 52 | break; 53 | } 54 | message[strLen]=0; 55 | printf("Message from server: %s", message); 56 | } 57 | 58 | closesocket(hSocket); 59 | WSACleanup(); 60 | return 0; 61 | } 62 | 63 | void ErrorHandling(char *message) 64 | { 65 | fputs(message, stderr); 66 | fputc('\n', stderr); 67 | exit(1); 68 | } -------------------------------------------------------------------------------- /Chapter24 소스코드/index.html: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/exgs/ambition_socket_programming/1d365fe728e39ed0b5e16b6d1e295d2ed79a29a0/Chapter24 소스코드/index.html -------------------------------------------------------------------------------- /Chapter24 소스코드/webserv_linux.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/exgs/ambition_socket_programming/1d365fe728e39ed0b5e16b6d1e295d2ed79a29a0/Chapter24 소스코드/webserv_linux.c -------------------------------------------------------------------------------- /Chapter24 소스코드/webserv_win.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/exgs/ambition_socket_programming/1d365fe728e39ed0b5e16b6d1e295d2ed79a29a0/Chapter24 소스코드/webserv_win.c -------------------------------------------------------------------------------- /Chapter3 소스코드/conv_addr_win.c: -------------------------------------------------------------------------------- 1 | #undef UNICODE 2 | #undef _UNICODE 3 | #include 4 | #include 5 | 6 | int main(int argc, char *argv[]) 7 | { 8 | char *strAddr="203.211.218.102:9190"; 9 | 10 | char strAddrBuf[50]; 11 | SOCKADDR_IN servAddr; 12 | int size; 13 | 14 | WSADATA wsaData; 15 | WSAStartup(MAKEWORD(2, 2), &wsaData); 16 | 17 | size=sizeof(servAddr); 18 | WSAStringToAddress( 19 | strAddr, AF_INET, NULL, (SOCKADDR*)&servAddr, &size); 20 | 21 | size=sizeof(strAddrBuf); 22 | WSAAddressToString( 23 | (SOCKADDR*)&servAddr, sizeof(servAddr), NULL, strAddrBuf, &size); 24 | 25 | printf("Second conv result: %s \n", strAddrBuf); 26 | WSACleanup(); 27 | return 0; 28 | } -------------------------------------------------------------------------------- /Chapter3 소스코드/endian_conv.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(int argc, char *argv[]) 5 | { 6 | unsigned short host_port=0x1234; 7 | unsigned short net_port; 8 | unsigned long host_addr=0x12345678; 9 | unsigned long net_addr; 10 | 11 | net_port=htons(host_port); 12 | net_addr=htonl(host_addr); 13 | 14 | printf("Host ordered port: %#x \n", host_port); 15 | printf("Network ordered port: %#x \n", net_port); 16 | printf("Host ordered address: %#lx \n", host_addr); 17 | printf("Network ordered address: %#lx \n", net_addr); 18 | return 0; 19 | } -------------------------------------------------------------------------------- /Chapter3 소스코드/endian_conv_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | void ErrorHandling(char* message); 4 | 5 | int main(int argc, char *argv[]) 6 | { 7 | WSADATA wsaData; 8 | unsigned short host_port=0x1234; 9 | unsigned short net_port; 10 | unsigned long host_addr=0x12345678; 11 | unsigned long net_addr; 12 | 13 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 14 | ErrorHandling("WSAStartup() error!"); 15 | 16 | net_port=htons(host_port); 17 | net_addr=htonl(host_addr); 18 | 19 | printf("Host ordered port: %#x \n", host_port); 20 | printf("Network ordered port: %#x \n", net_port); 21 | printf("Host ordered address: %#lx \n", host_addr); 22 | printf("Network ordered address: %#lx \n", net_addr); 23 | WSACleanup(); 24 | return 0; 25 | } 26 | 27 | void ErrorHandling(char* message) 28 | { 29 | fputs(message, stderr); 30 | fputc('\n', stderr); 31 | exit(1); 32 | } -------------------------------------------------------------------------------- /Chapter3 소스코드/inet_addr.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(int argc, char *argv[]) 5 | { 6 | char *addr1="127.212.124.78"; 7 | char *addr2="127.212.124.256"; 8 | 9 | unsigned long conv_addr=inet_addr(addr1); 10 | if(conv_addr==INADDR_NONE) 11 | printf("Error occured! \n"); 12 | else 13 | printf("Network ordered integer addr: %#lx \n", conv_addr); 14 | 15 | conv_addr=inet_addr(addr2); 16 | if(conv_addr==INADDR_NONE) 17 | printf("Error occureded \n"); 18 | else 19 | printf("Network ordered integer addr: %#lx \n\n", conv_addr); 20 | return 0; 21 | } -------------------------------------------------------------------------------- /Chapter3 소스코드/inet_adrconv_win.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/exgs/ambition_socket_programming/1d365fe728e39ed0b5e16b6d1e295d2ed79a29a0/Chapter3 소스코드/inet_adrconv_win.c -------------------------------------------------------------------------------- /Chapter3 소스코드/inet_aton.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | void error_handling(char *message); 5 | 6 | int main(int argc, char *argv[]) 7 | { 8 | char *addr="127.232.124.79"; 9 | struct sockaddr_in addr_inet; 10 | 11 | if(!inet_aton(addr, &addr_inet.sin_addr)) 12 | error_handling("Conversion error"); 13 | else 14 | printf("Network ordered integer addr: %#x \n", addr_inet.sin_addr.s_addr); 15 | return 0; 16 | } 17 | 18 | void error_handling(char *message) 19 | { 20 | fputs(message, stderr); 21 | fputc('\n', stderr); 22 | exit(1); 23 | } -------------------------------------------------------------------------------- /Chapter3 소스코드/inet_ntoa.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main(int argc, char *argv[]) 6 | { 7 | struct sockaddr_in addr1, addr2; 8 | char *str_ptr; 9 | char str_arr[20]; 10 | 11 | addr1.sin_addr.s_addr=htonl(0x1020304); 12 | addr2.sin_addr.s_addr=htonl(0x1010101); 13 | 14 | str_ptr=inet_ntoa(addr1.sin_addr); 15 | strcpy(str_arr, str_ptr); 16 | printf("Dotted-Decimal notation1: %s \n", str_ptr); 17 | 18 | inet_ntoa(addr2.sin_addr); 19 | printf("Dotted-Decimal notation2: %s \n", str_ptr); 20 | printf("Dotted-Decimal notation3: %s \n", str_arr); 21 | return 0; 22 | } 23 | 24 | /* 25 | root@com:/home/swyoon/tcpip# gcc inet_ntoa.c -o ntoa 26 | root@com:/home/swyoon/tcpip# ./ntoa 27 | Dotted-Decimal notation1: 1.2.3.4 28 | Dotted-Decimal notation2: 1.1.1.1 29 | Dotted-Decimal notation3: 1.2.3.4 30 | 31 | */ 32 | -------------------------------------------------------------------------------- /Chapter4 소스코드/echo_client.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 1024 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int sock; 14 | char message[BUF_SIZE]; 15 | int str_len; 16 | struct sockaddr_in serv_adr; 17 | 18 | if(argc!=3) { 19 | printf("Usage : %s \n", argv[0]); 20 | exit(1); 21 | } 22 | 23 | sock=socket(PF_INET, SOCK_STREAM, 0); 24 | if(sock==-1) 25 | error_handling("socket() error"); 26 | 27 | memset(&serv_adr, 0, sizeof(serv_adr)); 28 | serv_adr.sin_family=AF_INET; 29 | serv_adr.sin_addr.s_addr=inet_addr(argv[1]); 30 | serv_adr.sin_port=htons(atoi(argv[2])); 31 | 32 | if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1) 33 | error_handling("connect() error!"); 34 | else 35 | puts("Connected..........."); 36 | 37 | while(1) 38 | { 39 | fputs("Input message(Q to quit): ", stdout); 40 | fgets(message, BUF_SIZE, stdin); 41 | 42 | if(!strcmp(message,"q\n") || !strcmp(message,"Q\n")) 43 | break; 44 | 45 | write(sock, message, strlen(message)); 46 | str_len=read(sock, message, BUF_SIZE-1); 47 | message[str_len]=0; 48 | printf("Message from server: %s", message); 49 | } 50 | 51 | close(sock); 52 | return 0; 53 | } 54 | 55 | void error_handling(char *message) 56 | { 57 | fputs(message, stderr); 58 | fputc('\n', stderr); 59 | exit(1); 60 | } -------------------------------------------------------------------------------- /Chapter4 소스코드/echo_client_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #define BUF_SIZE 1024 7 | void ErrorHandling(char *message); 8 | 9 | int main(int argc, char *argv[]) 10 | { 11 | WSADATA wsaData; 12 | SOCKET hSocket; 13 | char message[BUF_SIZE]; 14 | int strLen; 15 | SOCKADDR_IN servAdr; 16 | 17 | if(argc!=3) { 18 | printf("Usage : %s \n", argv[0]); 19 | exit(1); 20 | } 21 | 22 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 23 | ErrorHandling("WSAStartup() error!"); 24 | 25 | hSocket=socket(PF_INET, SOCK_STREAM, 0); 26 | if(hSocket==INVALID_SOCKET) 27 | ErrorHandling("socket() error"); 28 | 29 | memset(&servAdr, 0, sizeof(servAdr)); 30 | servAdr.sin_family=AF_INET; 31 | servAdr.sin_addr.s_addr=inet_addr(argv[1]); 32 | servAdr.sin_port=htons(atoi(argv[2])); 33 | 34 | if(connect(hSocket, (SOCKADDR*)&servAdr, sizeof(servAdr))==SOCKET_ERROR) 35 | ErrorHandling("connect() error!"); 36 | else 37 | puts("Connected..........."); 38 | 39 | while(1) 40 | { 41 | fputs("Input message(Q to quit): ", stdout); 42 | fgets(message, BUF_SIZE, stdin); 43 | 44 | if(!strcmp(message,"q\n") || !strcmp(message,"Q\n")) 45 | break; 46 | 47 | send(hSocket, message, strlen(message), 0); 48 | strLen=recv(hSocket, message, BUF_SIZE-1, 0); 49 | message[strLen]=0; 50 | printf("Message from server: %s", message); 51 | } 52 | 53 | closesocket(hSocket); 54 | WSACleanup(); 55 | return 0; 56 | } 57 | 58 | void ErrorHandling(char *message) 59 | { 60 | fputs(message, stderr); 61 | fputc('\n', stderr); 62 | exit(1); 63 | } -------------------------------------------------------------------------------- /Chapter4 소스코드/echo_server.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 1024 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int serv_sock, clnt_sock; 14 | char message[BUF_SIZE]; 15 | int str_len, i; 16 | 17 | struct sockaddr_in serv_adr; 18 | struct sockaddr_in clnt_adr; 19 | socklen_t clnt_adr_sz; 20 | 21 | if(argc!=2) { 22 | printf("Usage : %s \n", argv[0]); 23 | exit(1); 24 | } 25 | 26 | serv_sock=socket(PF_INET, SOCK_STREAM, 0); 27 | if(serv_sock==-1) 28 | error_handling("socket() error"); 29 | 30 | memset(&serv_adr, 0, sizeof(serv_adr)); 31 | serv_adr.sin_family=AF_INET; 32 | serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 33 | serv_adr.sin_port=htons(atoi(argv[1])); 34 | 35 | if(bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1) 36 | error_handling("bind() error"); 37 | 38 | if(listen(serv_sock, 5)==-1) 39 | error_handling("listen() error"); 40 | 41 | clnt_adr_sz=sizeof(clnt_adr); 42 | 43 | for(i=0; i<5; i++) 44 | { 45 | clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz); 46 | if(clnt_sock==-1) 47 | error_handling("accept() error"); 48 | else 49 | printf("Connected client %d \n", i+1); 50 | 51 | while((str_len=read(clnt_sock, message, BUF_SIZE))!=0) 52 | write(clnt_sock, message, str_len); 53 | 54 | close(clnt_sock); 55 | } 56 | 57 | close(serv_sock); 58 | return 0; 59 | } 60 | 61 | void error_handling(char *message) 62 | { 63 | fputs(message, stderr); 64 | fputc('\n', stderr); 65 | exit(1); 66 | } -------------------------------------------------------------------------------- /Chapter4 소스코드/echo_server_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #define BUF_SIZE 1024 7 | void ErrorHandling(char *message); 8 | 9 | int main(int argc, char *argv[]) 10 | { 11 | WSADATA wsaData; 12 | SOCKET hServSock, hClntSock; 13 | char message[BUF_SIZE]; 14 | int strLen, i; 15 | 16 | SOCKADDR_IN servAdr, clntAdr; 17 | int clntAdrSize; 18 | 19 | if(argc!=2) { 20 | printf("Usage : %s \n", argv[0]); 21 | exit(1); 22 | } 23 | 24 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 25 | ErrorHandling("WSAStartup() error!"); 26 | 27 | hServSock=socket(PF_INET, SOCK_STREAM, 0); 28 | if(hServSock==INVALID_SOCKET) 29 | ErrorHandling("socket() error"); 30 | 31 | memset(&servAdr, 0, sizeof(servAdr)); 32 | servAdr.sin_family=AF_INET; 33 | servAdr.sin_addr.s_addr=htonl(INADDR_ANY); 34 | servAdr.sin_port=htons(atoi(argv[1])); 35 | 36 | if(bind(hServSock, (SOCKADDR*)&servAdr, sizeof(servAdr))==SOCKET_ERROR) 37 | ErrorHandling("bind() error"); 38 | 39 | if(listen(hServSock, 5)==SOCKET_ERROR) 40 | ErrorHandling("listen() error"); 41 | 42 | clntAdrSize=sizeof(clntAdr); 43 | 44 | for(i=0; i<5; i++) 45 | { 46 | hClntSock=accept(hServSock, (SOCKADDR*)&clntAdr, &clntAdrSize); 47 | if(hClntSock==-1) 48 | ErrorHandling("accept() error"); 49 | else 50 | printf("Connected client %d \n", i+1); 51 | 52 | while((strLen=recv(hClntSock, message, BUF_SIZE, 0))!=0) 53 | send(hClntSock, message, strLen, 0); 54 | 55 | closesocket(hClntSock); 56 | } 57 | 58 | closesocket(hServSock); 59 | WSACleanup(); 60 | return 0; 61 | } 62 | 63 | void ErrorHandling(char *message) 64 | { 65 | fputs(message, stderr); 66 | fputc('\n', stderr); 67 | exit(1); 68 | } -------------------------------------------------------------------------------- /Chapter5 소스코드/echo_client2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 1024 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int sock; 14 | char message[BUF_SIZE]; 15 | int str_len, recv_len, recv_cnt; 16 | struct sockaddr_in serv_adr; 17 | 18 | if(argc!=3) { 19 | printf("Usage : %s \n", argv[0]); 20 | exit(1); 21 | } 22 | 23 | sock=socket(PF_INET, SOCK_STREAM, 0); 24 | if(sock==-1) 25 | error_handling("socket() error"); 26 | 27 | memset(&serv_adr, 0, sizeof(serv_adr)); 28 | serv_adr.sin_family=AF_INET; 29 | serv_adr.sin_addr.s_addr=inet_addr(argv[1]); 30 | serv_adr.sin_port=htons(atoi(argv[2])); 31 | 32 | if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1) 33 | error_handling("connect() error!"); 34 | else 35 | puts("Connected..........."); 36 | 37 | while(1) 38 | { 39 | fputs("Input message(Q to quit): ", stdout); 40 | fgets(message, BUF_SIZE, stdin); 41 | 42 | if(!strcmp(message,"q\n") || !strcmp(message,"Q\n")) 43 | break; 44 | 45 | str_len=write(sock, message, strlen(message)); 46 | 47 | recv_len=0; 48 | while(recv_len 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 1024 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int serv_sock, clnt_sock; 14 | char message[BUF_SIZE]; 15 | int str_len, i; 16 | 17 | struct sockaddr_in serv_adr; 18 | struct sockaddr_in clnt_adr; 19 | socklen_t clnt_adr_sz; 20 | 21 | if(argc!=2) { 22 | printf("Usage : %s \n", argv[0]); 23 | exit(1); 24 | } 25 | 26 | serv_sock=socket(PF_INET, SOCK_STREAM, 0); 27 | if(serv_sock==-1) 28 | error_handling("socket() error"); 29 | 30 | memset(&serv_adr, 0, sizeof(serv_adr)); 31 | serv_adr.sin_family=AF_INET; 32 | serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 33 | serv_adr.sin_port=htons(atoi(argv[1])); 34 | 35 | if(bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1) 36 | error_handling("bind() error"); 37 | 38 | if(listen(serv_sock, 5)==-1) 39 | error_handling("listen() error"); 40 | 41 | clnt_adr_sz=sizeof(clnt_adr); 42 | 43 | for(i=0; i<5; i++) 44 | { 45 | clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz); 46 | if(clnt_sock==-1) 47 | error_handling("accept() error"); 48 | else 49 | printf("Connected client %d \n", i+1); 50 | 51 | while((str_len=read(clnt_sock, message, BUF_SIZE))!=0) 52 | write(clnt_sock, message, str_len); 53 | 54 | close(clnt_sock); 55 | } 56 | 57 | close(serv_sock); 58 | return 0; 59 | } 60 | 61 | void error_handling(char *message) 62 | { 63 | fputs(message, stderr); 64 | fputc('\n', stderr); 65 | exit(1); 66 | } -------------------------------------------------------------------------------- /Chapter5 소스코드/op_client.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 1024 9 | #define RLT_SIZE 4 10 | #define OPSZ 4 11 | void error_handling(char *message); 12 | 13 | int main(int argc, char *argv[]) 14 | { 15 | int sock; 16 | char opmsg[BUF_SIZE]; 17 | int result, opnd_cnt, i; 18 | struct sockaddr_in serv_adr; 19 | if(argc!=3) { 20 | printf("Usage : %s \n", argv[0]); 21 | exit(1); 22 | } 23 | 24 | sock=socket(PF_INET, SOCK_STREAM, 0); 25 | if(sock==-1) 26 | error_handling("socket() error"); 27 | 28 | memset(&serv_adr, 0, sizeof(serv_adr)); 29 | serv_adr.sin_family=AF_INET; 30 | serv_adr.sin_addr.s_addr=inet_addr(argv[1]); 31 | serv_adr.sin_port=htons(atoi(argv[2])); 32 | 33 | if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1) 34 | error_handling("connect() error!"); 35 | else 36 | puts("Connected..........."); 37 | 38 | fputs("Operand count: ", stdout); 39 | scanf("%d", &opnd_cnt); 40 | opmsg[0]=(char)opnd_cnt; 41 | 42 | for(i=0; i 2 | #include 3 | #include 4 | #include 5 | 6 | #define BUF_SIZE 1024 7 | #define RLT_SIZE 4 8 | #define OPSZ 4 9 | void ErrorHandling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | WSADATA wsaData; 14 | SOCKET hSocket; 15 | char opmsg[BUF_SIZE]; 16 | int result, opndCnt, i; 17 | SOCKADDR_IN servAdr; 18 | if(argc!=3) { 19 | printf("Usage : %s \n", argv[0]); 20 | exit(1); 21 | } 22 | 23 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 24 | ErrorHandling("WSAStartup() error!"); 25 | 26 | hSocket=socket(PF_INET, SOCK_STREAM, 0); 27 | if(hSocket==INVALID_SOCKET) 28 | ErrorHandling("socket() error"); 29 | 30 | memset(&servAdr, 0, sizeof(servAdr)); 31 | servAdr.sin_family=AF_INET; 32 | servAdr.sin_addr.s_addr=inet_addr(argv[1]); 33 | servAdr.sin_port=htons(atoi(argv[2])); 34 | 35 | if(connect(hSocket, (SOCKADDR*)&servAdr, sizeof(servAdr))==SOCKET_ERROR) 36 | ErrorHandling("connect() error!"); 37 | else 38 | puts("Connected..........."); 39 | 40 | fputs("Operand count: ", stdout); 41 | scanf("%d", &opndCnt); 42 | opmsg[0]=(char)opndCnt; 43 | 44 | for(i=0; i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 1024 9 | #define OPSZ 4 10 | void error_handling(char *message); 11 | int calculate(int opnum, int opnds[], char oprator); 12 | 13 | int main(int argc, char *argv[]) 14 | { 15 | int serv_sock, clnt_sock; 16 | char opinfo[BUF_SIZE]; 17 | int result, opnd_cnt, i; 18 | int recv_cnt, recv_len; 19 | struct sockaddr_in serv_adr, clnt_adr; 20 | socklen_t clnt_adr_sz; 21 | if(argc!=2) { 22 | printf("Usage : %s \n", argv[0]); 23 | exit(1); 24 | } 25 | 26 | serv_sock=socket(PF_INET, SOCK_STREAM, 0); 27 | if(serv_sock==-1) 28 | error_handling("socket() error"); 29 | 30 | memset(&serv_adr, 0, sizeof(serv_adr)); 31 | serv_adr.sin_family=AF_INET; 32 | serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 33 | serv_adr.sin_port=htons(atoi(argv[1])); 34 | 35 | if(bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1) 36 | error_handling("bind() error"); 37 | if(listen(serv_sock, 5)==-1) 38 | error_handling("listen() error"); 39 | clnt_adr_sz=sizeof(clnt_adr); 40 | 41 | for(i=0; i<5; i++) 42 | { 43 | opnd_cnt=0; 44 | clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz); 45 | read(clnt_sock, &opnd_cnt, 1); 46 | 47 | recv_len=0; 48 | while((opnd_cnt*OPSZ+1)>recv_len) 49 | { 50 | recv_cnt=read(clnt_sock, &opinfo[recv_len], BUF_SIZE-1); 51 | recv_len+=recv_cnt; 52 | } 53 | result=calculate(opnd_cnt, (int*)opinfo, opinfo[recv_len-1]); 54 | write(clnt_sock, (char*)&result, sizeof(result)); 55 | close(clnt_sock); 56 | } 57 | close(serv_sock); 58 | return 0; 59 | } 60 | 61 | int calculate(int opnum, int opnds[], char op) 62 | { 63 | int result=opnds[0], i; 64 | 65 | switch(op) 66 | { 67 | case '+': 68 | for(i=1; i 2 | #include 3 | #include 4 | #include 5 | 6 | #define BUF_SIZE 1024 7 | #define OPSZ 4 8 | void ErrorHandling(char *message); 9 | int calculate(int opnum, int opnds[], char oprator); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | WSADATA wsaData; 14 | SOCKET hServSock, hClntSock; 15 | char opinfo[BUF_SIZE]; 16 | int result, opndCnt, i; 17 | int recvCnt, recvLen; 18 | SOCKADDR_IN servAdr, clntAdr; 19 | int clntAdrSize; 20 | if(argc!=2) { 21 | printf("Usage : %s \n", argv[0]); 22 | exit(1); 23 | } 24 | 25 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 26 | ErrorHandling("WSAStartup() error!"); 27 | 28 | hServSock=socket(PF_INET, SOCK_STREAM, 0); 29 | if(hServSock==INVALID_SOCKET) 30 | ErrorHandling("socket() error"); 31 | 32 | memset(&servAdr, 0, sizeof(servAdr)); 33 | servAdr.sin_family=AF_INET; 34 | servAdr.sin_addr.s_addr=htonl(INADDR_ANY); 35 | servAdr.sin_port=htons(atoi(argv[1])); 36 | 37 | if(bind(hServSock, (SOCKADDR*)&servAdr, sizeof(servAdr))==SOCKET_ERROR) 38 | ErrorHandling("bind() error"); 39 | if(listen(hServSock, 5)==SOCKET_ERROR) 40 | ErrorHandling("listen() error"); 41 | clntAdrSize=sizeof(clntAdr); 42 | 43 | for(i=0; i<5; i++) 44 | { 45 | opndCnt=0; 46 | hClntSock=accept(hServSock, (SOCKADDR*)&clntAdr, &clntAdrSize); 47 | recv(hClntSock, &opndCnt, 1, 0); 48 | 49 | recvLen=0; 50 | while((opndCnt*OPSZ+1)>recvLen) 51 | { 52 | recvCnt=recv(hClntSock, &opinfo[recvLen], BUF_SIZE-1, 0); 53 | recvLen+=recvCnt; 54 | } 55 | result=calculate(opndCnt, (int*)opinfo, opinfo[recvLen-1]); 56 | send(hClntSock, (char*)&result, sizeof(result), 0); 57 | closesocket(hClntSock); 58 | } 59 | closesocket(hServSock); 60 | WSACleanup(); 61 | return 0; 62 | } 63 | 64 | int calculate(int opnum, int opnds[], char op) 65 | { 66 | int result=opnds[0], i; 67 | 68 | switch(op) 69 | { 70 | case '+': 71 | for(i=1; i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 30 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int sock; 14 | char message[BUF_SIZE]; 15 | struct sockaddr_in my_adr, your_adr; 16 | socklen_t adr_sz; 17 | int str_len, i; 18 | 19 | if(argc!=2){ 20 | printf("Usage : %s \n", argv[0]); 21 | exit(1); 22 | } 23 | 24 | sock=socket(PF_INET, SOCK_DGRAM, 0); 25 | if(sock==-1) 26 | error_handling("socket() error"); 27 | 28 | memset(&my_adr, 0, sizeof(my_adr)); 29 | my_adr.sin_family=AF_INET; 30 | my_adr.sin_addr.s_addr=htonl(INADDR_ANY); 31 | my_adr.sin_port=htons(atoi(argv[1])); 32 | 33 | if(bind(sock, (struct sockaddr*)&my_adr, sizeof(my_adr))==-1) 34 | error_handling("bind() error"); 35 | 36 | for(i=0; i<3; i++) 37 | { 38 | sleep(5); // delay 5 sec. 39 | adr_sz=sizeof(your_adr); 40 | str_len=recvfrom(sock, message, BUF_SIZE, 0, 41 | (struct sockaddr*)&your_adr, &adr_sz); 42 | 43 | printf("Message %d: %s \n", i+1, message); 44 | } 45 | close(sock); 46 | return 0; 47 | } 48 | 49 | void error_handling(char *message) 50 | { 51 | fputs(message, stderr); 52 | fputc('\n', stderr); 53 | exit(1); 54 | } 55 | 56 | /* 57 | root@my_linux:/home/swyoon/tcpip# gcc bound_host1.c -o host1 58 | root@my_linux:/home/swyoon/tcpip# ./host1 59 | Usage : ./host1 60 | root@my_linux:/home/swyoon/tcpip# ./host1 9190 61 | Message 1: Hi! 62 | Message 2: I'm another UDP host! 63 | Message 3: Nice to meet you 64 | root@my_linux:/home/swyoon/tcpip# 65 | 66 | */ 67 | -------------------------------------------------------------------------------- /Chapter6 소스코드/bound_host2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 30 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int sock; 14 | char msg1[]="Hi!"; 15 | char msg2[]="I'm another UDP host!"; 16 | char msg3[]="Nice to meet you"; 17 | 18 | struct sockaddr_in your_adr; 19 | socklen_t your_adr_sz; 20 | if(argc!=3){ 21 | printf("Usage : %s \n", argv[0]); 22 | exit(1); 23 | } 24 | 25 | sock=socket(PF_INET, SOCK_DGRAM, 0); 26 | if(sock==-1) 27 | error_handling("socket() error"); 28 | 29 | memset(&your_adr, 0, sizeof(your_adr)); 30 | your_adr.sin_family=AF_INET; 31 | your_adr.sin_addr.s_addr=inet_addr(argv[1]); 32 | your_adr.sin_port=htons(atoi(argv[2])); 33 | 34 | sendto(sock, msg1, sizeof(msg1), 0, 35 | (struct sockaddr*)&your_adr, sizeof(your_adr)); 36 | sendto(sock, msg2, sizeof(msg2), 0, 37 | (struct sockaddr*)&your_adr, sizeof(your_adr)); 38 | sendto(sock, msg3, sizeof(msg3), 0, 39 | (struct sockaddr*)&your_adr, sizeof(your_adr)); 40 | close(sock); 41 | return 0; 42 | } 43 | 44 | void error_handling(char *message) 45 | { 46 | fputs(message, stderr); 47 | fputc('\n', stderr); 48 | exit(1); 49 | } 50 | 51 | /* 52 | root@my_linux:/home/swyoon/tcpip# gcc bound_host2.c -o host2 53 | root@my_linux:/home/swyoon/tcpip# ./host2 54 | Usage : ./host2 55 | root@my_linux:/home/swyoon/tcpip# ./host2 127.0.0.1 9190 56 | root@my_linux:/home/swyoon/tcpip# 57 | */ 58 | -------------------------------------------------------------------------------- /Chapter6 소스코드/uecho_client.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 30 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int sock; 14 | char message[BUF_SIZE]; 15 | int str_len; 16 | socklen_t adr_sz; 17 | 18 | struct sockaddr_in serv_adr, from_adr; 19 | if(argc!=3){ 20 | printf("Usage : %s \n", argv[0]); 21 | exit(1); 22 | } 23 | 24 | sock=socket(PF_INET, SOCK_DGRAM, 0); 25 | if(sock==-1) 26 | error_handling("socket() error"); 27 | 28 | memset(&serv_adr, 0, sizeof(serv_adr)); 29 | serv_adr.sin_family=AF_INET; 30 | serv_adr.sin_addr.s_addr=inet_addr(argv[1]); 31 | serv_adr.sin_port=htons(atoi(argv[2])); 32 | 33 | // STUB 34 | struct sockaddr_in temp_adr; 35 | memset(&temp_adr, 0, sizeof(temp_adr)); 36 | temp_adr.sin_family=AF_INET; 37 | temp_adr.sin_addr.s_addr=inet_addr("0.0.0.0"); 38 | temp_adr.sin_port=htons(54192); 39 | 40 | bind(sock, (struct sockaddr *)&temp_adr, sizeof(temp_adr)); 41 | while(1) 42 | { 43 | fputs("Insert message(q to quit): ", stdout); 44 | fgets(message, sizeof(message), stdin); 45 | if(!strcmp(message,"q\n") || !strcmp(message,"Q\n")) 46 | break; 47 | 48 | sendto(sock, message, strlen(message), 0, 49 | (struct sockaddr*)&serv_adr, sizeof(serv_adr)); 50 | printf("serv_adr\n"); 51 | printf("IP: %d PORT: %d\n", ntohl(serv_adr.sin_addr.s_addr), ntohs(serv_adr.sin_port)); 52 | adr_sz=sizeof(from_adr); 53 | str_len=recvfrom(sock, message, BUF_SIZE, 0, 54 | (struct sockaddr*)&from_adr, &adr_sz); 55 | printf("recvfrom\n"); 56 | printf("IP: %d PORT: %d\n", ntohl(from_adr.sin_addr.s_addr), ntohs(from_adr.sin_port)); 57 | message[str_len]=0; 58 | printf("Message from server: %s", message); 59 | } 60 | close(sock); 61 | return 0; 62 | } 63 | 64 | void error_handling(char *message) 65 | { 66 | fputs(message, stderr); 67 | fputc('\n', stderr); 68 | exit(1); 69 | } -------------------------------------------------------------------------------- /Chapter6 소스코드/uecho_client_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #define BUF_SIZE 30 7 | void ErrorHandling(char *message); 8 | 9 | int main(int argc, char *argv[]) 10 | { 11 | WSADATA wsaData; 12 | SOCKET sock; 13 | char message[BUF_SIZE]; 14 | int strLen; 15 | 16 | SOCKADDR_IN servAdr; 17 | if(argc!=3) { 18 | printf("Usage : %s \n", argv[0]); 19 | exit(1); 20 | } 21 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 22 | ErrorHandling("WSAStartup() error!"); 23 | 24 | sock=socket(PF_INET, SOCK_DGRAM, 0); 25 | if(sock==INVALID_SOCKET) 26 | ErrorHandling("socket() error"); 27 | 28 | memset(&servAdr, 0, sizeof(servAdr)); 29 | servAdr.sin_family=AF_INET; 30 | servAdr.sin_addr.s_addr=inet_addr(argv[1]); 31 | servAdr.sin_port=htons(atoi(argv[2])); 32 | 33 | connect(sock, (SOCKADDR*)&servAdr, sizeof(servAdr)); 34 | 35 | while(1) 36 | { 37 | fputs("Insert message(q to quit): ", stdout); 38 | fgets(message, sizeof(message), stdin); 39 | if(!strcmp(message,"q\n") || !strcmp(message,"Q\n")) 40 | break; 41 | 42 | send(sock, message, strlen(message), 0); 43 | strLen=recv(sock, message, sizeof(message)-1, 0); 44 | 45 | message[strLen]=0; 46 | printf("Message from server: %s", message); 47 | } 48 | closesocket(sock); 49 | WSACleanup(); 50 | return 0; 51 | } 52 | 53 | void ErrorHandling(char *message) 54 | { 55 | fputs(message, stderr); 56 | fputc('\n', stderr); 57 | exit(1); 58 | } 59 | -------------------------------------------------------------------------------- /Chapter6 소스코드/uecho_con_client.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 30 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int sock; 14 | char message[BUF_SIZE]; 15 | int str_len; 16 | socklen_t adr_sz; 17 | 18 | struct sockaddr_in serv_adr, from_adr; 19 | if(argc!=3){ 20 | printf("Usage : %s \n", argv[0]); 21 | exit(1); 22 | } 23 | 24 | sock=socket(PF_INET, SOCK_DGRAM, 0); 25 | if(sock==-1) 26 | error_handling("socket() error"); 27 | 28 | memset(&serv_adr, 0, sizeof(serv_adr)); 29 | serv_adr.sin_family=AF_INET; 30 | serv_adr.sin_addr.s_addr=inet_addr(argv[1]); 31 | serv_adr.sin_port=htons(atoi(argv[2])); 32 | 33 | connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)); 34 | 35 | while(1) 36 | { 37 | fputs("Insert message(q to quit): ", stdout); 38 | fgets(message, sizeof(message), stdin); 39 | if(!strcmp(message,"q\n") || !strcmp(message,"Q\n")) 40 | break; 41 | /* 42 | sendto(sock, message, strlen(message), 0, 43 | (struct sockaddr*)&serv_adr, sizeof(serv_adr)); 44 | */ 45 | write(sock, message, strlen(message)); 46 | 47 | /* 48 | adr_sz=sizeof(from_adr); 49 | str_len=recvfrom(sock, message, BUF_SIZE, 0, 50 | (struct sockaddr*)&from_adr, &adr_sz); 51 | */ 52 | str_len=read(sock, message, sizeof(message)-1); 53 | 54 | message[str_len]=0; 55 | printf("Message from server: %s", message); 56 | } 57 | close(sock); 58 | return 0; 59 | } 60 | 61 | void error_handling(char *message) 62 | { 63 | fputs(message, stderr); 64 | fputc('\n', stderr); 65 | exit(1); 66 | } 67 | -------------------------------------------------------------------------------- /Chapter6 소스코드/uecho_server.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 30 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int serv_sock; 14 | char message[BUF_SIZE]; 15 | int str_len; 16 | socklen_t clnt_adr_sz; 17 | 18 | struct sockaddr_in serv_adr, clnt_adr; 19 | if(argc!=2){ 20 | printf("Usage : %s \n", argv[0]); 21 | exit(1); 22 | } 23 | 24 | serv_sock=socket(PF_INET, SOCK_DGRAM, 0); 25 | if(serv_sock==-1) 26 | error_handling("UDP socket creation error"); 27 | 28 | memset(&serv_adr, 0, sizeof(serv_adr)); 29 | serv_adr.sin_family=AF_INET; 30 | serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 31 | serv_adr.sin_port=htons(atoi(argv[1])); 32 | 33 | if(bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1) 34 | error_handling("bind() error"); 35 | 36 | while(1) 37 | { 38 | clnt_adr_sz=sizeof(clnt_adr); 39 | str_len=recvfrom(serv_sock, message, BUF_SIZE, 0, 40 | (struct sockaddr*)&clnt_adr, &clnt_adr_sz); 41 | 42 | printf("IP: %d PORT: %d\n", ntohl(clnt_adr.sin_addr.s_addr), ntohs(clnt_adr.sin_port)); 43 | sendto(serv_sock, message, str_len, 0, 44 | (struct sockaddr*)&clnt_adr, clnt_adr_sz); 45 | printf("IP: %d PORT: %d\n", ntohl(clnt_adr.sin_addr.s_addr), ntohs(clnt_adr.sin_port)); 46 | } 47 | close(serv_sock); 48 | return 0; 49 | } 50 | 51 | void error_handling(char *message) 52 | { 53 | fputs(message, stderr); 54 | fputc('\n', stderr); 55 | exit(1); 56 | } 57 | -------------------------------------------------------------------------------- /Chapter6 소스코드/uecho_server_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #define BUF_SIZE 30 7 | void ErrorHandling(char *message); 8 | 9 | int main(int argc, char *argv[]) 10 | { 11 | WSADATA wsaData; 12 | SOCKET servSock; 13 | char message[BUF_SIZE]; 14 | int strLen; 15 | int clntAdrSz; 16 | 17 | SOCKADDR_IN servAdr, clntAdr; 18 | if(argc!=2) { 19 | printf("Usage : %s \n", argv[0]); 20 | exit(1); 21 | } 22 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 23 | ErrorHandling("WSAStartup() error!"); 24 | 25 | servSock=socket(PF_INET, SOCK_DGRAM, 0); 26 | if(servSock==INVALID_SOCKET) 27 | ErrorHandling("UDP socket creation error"); 28 | 29 | memset(&servAdr, 0, sizeof(servAdr)); 30 | servAdr.sin_family=AF_INET; 31 | servAdr.sin_addr.s_addr=htonl(INADDR_ANY); 32 | servAdr.sin_port=htons(atoi(argv[1])); 33 | 34 | if(bind(servSock, (SOCKADDR*)&servAdr, sizeof(servAdr))==SOCKET_ERROR) 35 | ErrorHandling("bind() error"); 36 | 37 | while(1) 38 | { 39 | clntAdrSz=sizeof(clntAdr); 40 | strLen=recvfrom(servSock, message, BUF_SIZE, 0, 41 | (SOCKADDR*)&clntAdr, &clntAdrSz); 42 | sendto(servSock, message, strLen, 0, 43 | (SOCKADDR*)&clntAdr, sizeof(clntAdr)); 44 | } 45 | closesocket(servSock); 46 | WSACleanup(); 47 | return 0; 48 | } 49 | 50 | void ErrorHandling(char *message) 51 | { 52 | fputs(message, stderr); 53 | fputc('\n', stderr); 54 | exit(1); 55 | } -------------------------------------------------------------------------------- /Chapter7 소스코드/file_client.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 30 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int sd; 14 | FILE *fp; 15 | 16 | char buf[BUF_SIZE]; 17 | int read_cnt; 18 | struct sockaddr_in serv_adr; 19 | if(argc!=3) { 20 | printf("Usage: %s \n", argv[0]); 21 | exit(1); 22 | } 23 | 24 | fp=fopen("receive.dat", "wb"); 25 | sd=socket(PF_INET, SOCK_STREAM, 0); 26 | 27 | memset(&serv_adr, 0, sizeof(serv_adr)); 28 | serv_adr.sin_family=AF_INET; 29 | serv_adr.sin_addr.s_addr=inet_addr(argv[1]); 30 | serv_adr.sin_port=htons(atoi(argv[2])); 31 | 32 | connect(sd, (struct sockaddr*)&serv_adr, sizeof(serv_adr)); 33 | 34 | while((read_cnt=read(sd, buf, BUF_SIZE ))!=0) 35 | fwrite((void*)buf, 1, read_cnt, fp); 36 | 37 | puts("Received file data"); 38 | write(sd, "Thank you", 10); 39 | fclose(fp); 40 | close(sd); 41 | return 0; 42 | } 43 | 44 | void error_handling(char *message) 45 | { 46 | fputs(message, stderr); 47 | fputc('\n', stderr); 48 | exit(1); 49 | } -------------------------------------------------------------------------------- /Chapter7 소스코드/file_client_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #define BUF_SIZE 30 7 | void ErrorHandling(char *message); 8 | 9 | int main(int argc, char *argv[]) 10 | { 11 | WSADATA wsaData; 12 | SOCKET hSocket; 13 | FILE *fp; 14 | 15 | char buf[BUF_SIZE]; 16 | int readCnt; 17 | SOCKADDR_IN servAdr; 18 | 19 | if(argc!=3) { 20 | printf("Usage: %s \n", argv[0]); 21 | exit(1); 22 | } 23 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 24 | ErrorHandling("WSAStartup() error!"); 25 | 26 | fp=fopen("receive.dat", "wb"); 27 | hSocket=socket(PF_INET, SOCK_STREAM, 0); 28 | 29 | memset(&servAdr, 0, sizeof(servAdr)); 30 | servAdr.sin_family=AF_INET; 31 | servAdr.sin_addr.s_addr=inet_addr(argv[1]); 32 | servAdr.sin_port=htons(atoi(argv[2])); 33 | 34 | connect(hSocket, (SOCKADDR*)&servAdr, sizeof(servAdr)); 35 | 36 | while((readCnt=recv(hSocket, buf, BUF_SIZE, 0))!=0) 37 | fwrite((void*)buf, 1, readCnt, fp); 38 | 39 | puts("Received file data"); 40 | send(hSocket, "Thank you", 10, 0); 41 | fclose(fp); 42 | closesocket(hSocket); 43 | WSACleanup(); 44 | return 0; 45 | } 46 | 47 | void ErrorHandling(char *message) 48 | { 49 | fputs(message, stderr); 50 | fputc('\n', stderr); 51 | exit(1); 52 | } -------------------------------------------------------------------------------- /Chapter7 소스코드/file_server.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 30 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int serv_sd, clnt_sd; 14 | FILE * fp; 15 | char buf[BUF_SIZE]; 16 | int read_cnt; 17 | 18 | struct sockaddr_in serv_adr, clnt_adr; 19 | socklen_t clnt_adr_sz; 20 | 21 | if(argc!=2) { 22 | printf("Usage: %s \n", argv[0]); 23 | exit(1); 24 | } 25 | 26 | fp=fopen("file_server.c", "rb"); 27 | serv_sd=socket(PF_INET, SOCK_STREAM, 0); 28 | 29 | memset(&serv_adr, 0, sizeof(serv_adr)); 30 | serv_adr.sin_family=AF_INET; 31 | serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 32 | serv_adr.sin_port=htons(atoi(argv[1])); 33 | 34 | bind(serv_sd, (struct sockaddr*)&serv_adr, sizeof(serv_adr)); 35 | listen(serv_sd, 5); 36 | 37 | clnt_adr_sz=sizeof(clnt_adr); 38 | clnt_sd=accept(serv_sd, (struct sockaddr*)&clnt_adr, &clnt_adr_sz); 39 | 40 | while(1) 41 | { 42 | read_cnt=fread((void*)buf, 1, BUF_SIZE, fp); 43 | if(read_cnt 2 | #include 3 | #include 4 | #include 5 | 6 | #define BUF_SIZE 30 7 | void ErrorHandling(char *message); 8 | 9 | int main(int argc, char *argv[]) 10 | { 11 | WSADATA wsaData; 12 | SOCKET hServSock, hClntSock; 13 | FILE * fp; 14 | char buf[BUF_SIZE]; 15 | int readCnt; 16 | 17 | SOCKADDR_IN servAdr, clntAdr; 18 | int clntAdrSz; 19 | 20 | if(argc!=2) { 21 | printf("Usage: %s \n", argv[0]); 22 | exit(1); 23 | } 24 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 25 | ErrorHandling("WSAStartup() error!"); 26 | 27 | fp=fopen("file_server_win.c", "rb"); 28 | hServSock=socket(PF_INET, SOCK_STREAM, 0); 29 | 30 | memset(&servAdr, 0, sizeof(servAdr)); 31 | servAdr.sin_family=AF_INET; 32 | servAdr.sin_addr.s_addr=htonl(INADDR_ANY); 33 | servAdr.sin_port=htons(atoi(argv[1])); 34 | 35 | bind(hServSock, (SOCKADDR*)&servAdr, sizeof(servAdr)); 36 | listen(hServSock, 5); 37 | 38 | clntAdrSz=sizeof(clntAdr); 39 | hClntSock=accept(hServSock, (SOCKADDR*)&clntAdr, &clntAdrSz); 40 | 41 | while(1) 42 | { 43 | readCnt=fread((void*)buf, 1, BUF_SIZE, fp); 44 | if(readCnt 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | void error_handling(char *message); 8 | 9 | int main(int argc, char *argv[]) 10 | { 11 | int i; 12 | struct hostent *host; 13 | struct sockaddr_in addr; 14 | if(argc!=2) { 15 | printf("Usage : %s \n", argv[0]); 16 | exit(1); 17 | } 18 | 19 | memset(&addr, 0, sizeof(addr)); 20 | addr.sin_addr.s_addr=inet_addr(argv[1]); 21 | host=gethostbyaddr((char*)&addr.sin_addr, 4, AF_INET); 22 | if(!host) 23 | error_handling("gethost... error"); 24 | 25 | printf("Official name: %s \n", host->h_name); 26 | 27 | for(i=0; host->h_aliases[i]; i++) 28 | printf("Aliases %d: %s \n", i+1, host->h_aliases[i]); 29 | 30 | printf("Address type: %s \n", 31 | (host->h_addrtype==AF_INET)?"AF_INET":"AF_INET6"); 32 | 33 | for(i=0; host->h_addr_list[i]; i++) 34 | printf("IP addr %d: %s \n", i+1, 35 | inet_ntoa(*(struct in_addr*)host->h_addr_list[i])); 36 | return 0; 37 | } 38 | 39 | void error_handling(char *message) 40 | { 41 | fputs(message, stderr); 42 | fputc('\n', stderr); 43 | exit(1); 44 | } -------------------------------------------------------------------------------- /Chapter8 소스코드/gethostbyaddr_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | void ErrorHandling(char *message); 6 | 7 | int main(int argc, char *argv[]) 8 | { 9 | WSADATA wsaData; 10 | int i; 11 | struct hostent *host; 12 | SOCKADDR_IN addr; 13 | if(argc!=2) { 14 | printf("Usage : %s \n", argv[0]); 15 | exit(1); 16 | } 17 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 18 | ErrorHandling("WSAStartup() error!"); 19 | 20 | memset(&addr, 0, sizeof(addr)); 21 | addr.sin_addr.s_addr=inet_addr(argv[1]); 22 | host=gethostbyaddr((char*)&addr.sin_addr, 4, AF_INET); 23 | if(!host) 24 | ErrorHandling("gethost... error"); 25 | 26 | printf("Official name: %s \n", host->h_name); 27 | for(i=0; host->h_aliases[i]; i++) 28 | printf("Aliases %d: %s \n", i+1, host->h_aliases[i]); 29 | printf("Address type: %s \n", 30 | (host->h_addrtype==AF_INET)?"AF_INET":"AF_INET6"); 31 | for(i=0; host->h_addr_list[i]; i++) 32 | printf("IP addr %d: %s \n", i+1, 33 | inet_ntoa(*(struct in_addr*)host->h_addr_list[i])); 34 | WSACleanup(); 35 | return 0; 36 | } 37 | 38 | void ErrorHandling(char *message) 39 | { 40 | fputs(message, stderr); 41 | fputc('\n', stderr); 42 | exit(1); 43 | } -------------------------------------------------------------------------------- /Chapter8 소스코드/gethostbyname.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | void error_handling(char *message); 7 | 8 | int main(int argc, char *argv[]) 9 | { 10 | int i; 11 | struct hostent *host; 12 | if(argc!=2) { 13 | printf("Usage : %s \n", argv[0]); 14 | exit(1); 15 | } 16 | 17 | host=gethostbyname(argv[1]); 18 | if(!host) 19 | error_handling("gethost... error"); 20 | 21 | printf("Official name: %s \n", host->h_name); 22 | 23 | for(i=0; host->h_aliases[i]; i++) 24 | printf("Aliases %d: %s \n", i+1, host->h_aliases[i]); 25 | 26 | printf("Address type: %s \n", 27 | (host->h_addrtype==AF_INET)?"AF_INET":"AF_INET6"); 28 | 29 | for(i=0; host->h_addr_list[i]; i++) 30 | printf("IP addr %d: %s \n", i+1, 31 | inet_ntoa(*(struct in_addr*)host->h_addr_list[i])); 32 | return 0; 33 | } 34 | 35 | void error_handling(char *message) 36 | { 37 | fputs(message, stderr); 38 | fputc('\n', stderr); 39 | exit(1); 40 | } 41 | -------------------------------------------------------------------------------- /Chapter8 소스코드/gethostbyname_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | void ErrorHandling(char *message); 5 | 6 | int main(int argc, char *argv[]) 7 | { 8 | WSADATA wsaData; 9 | int i; 10 | struct hostent *host; 11 | if(argc!=2) { 12 | printf("Usage : %s \n", argv[0]); 13 | exit(1); 14 | } 15 | if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0) 16 | ErrorHandling("WSAStartup() error!"); 17 | 18 | host=gethostbyname(argv[1]); 19 | if(!host) 20 | ErrorHandling("gethost... error"); 21 | 22 | printf("Official name: %s \n", host->h_name); 23 | for(i=0; host->h_aliases[i]; i++) 24 | printf("Aliases %d: %s \n", i+1, host->h_aliases[i]); 25 | printf("Address type: %s \n", 26 | (host->h_addrtype==AF_INET)?"AF_INET":"AF_INET6"); 27 | for(i=0; host->h_addr_list[i]; i++) 28 | printf("IP addr %d: %s \n", i+1, 29 | inet_ntoa(*(struct in_addr*)host->h_addr_list[i])); 30 | 31 | WSACleanup(); 32 | return 0; 33 | } 34 | 35 | void ErrorHandling(char *message) 36 | { 37 | fputs(message, stderr); 38 | fputc('\n', stderr); 39 | exit(1); 40 | } 41 | -------------------------------------------------------------------------------- /Chapter9 소스코드/buf_win.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | void ErrorHandling(char *message); 6 | void ShowSocketBufSize(SOCKET sock); 7 | 8 | int main(int argc, char *argv[]) 9 | { 10 | WSADATA wsaData; 11 | SOCKET hSock; 12 | int sndBuf, rcvBuf, state; 13 | if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) 14 | ErrorHandling("WSAStartup() error!"); 15 | 16 | hSock=socket(PF_INET, SOCK_STREAM, 0); 17 | ShowSocketBufSize(hSock); 18 | 19 | sndBuf=1024*3, rcvBuf=1024*3; 20 | state=setsockopt(hSock, SOL_SOCKET, SO_SNDBUF, (char*)&sndBuf, sizeof(sndBuf)); 21 | if(state==SOCKET_ERROR) 22 | ErrorHandling("setsockopt() error!"); 23 | 24 | state=setsockopt(hSock, SOL_SOCKET, SO_RCVBUF, (char*)&rcvBuf, sizeof(rcvBuf)); 25 | if(state==SOCKET_ERROR) 26 | ErrorHandling("setsockopt() error!"); 27 | 28 | ShowSocketBufSize(hSock); 29 | closesocket(hSock); 30 | WSACleanup(); 31 | return 0; 32 | } 33 | 34 | void ShowSocketBufSize(SOCKET sock) 35 | { 36 | int sndBuf, rcvBuf, state, len; 37 | 38 | len=sizeof(sndBuf); 39 | state=getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char*)&sndBuf, &len); 40 | if(state==SOCKET_ERROR) 41 | ErrorHandling("getsockopt() error"); 42 | 43 | len=sizeof(rcvBuf); 44 | state=getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char*)&rcvBuf, &len); 45 | if(state==SOCKET_ERROR) 46 | ErrorHandling("getsockopt() error"); 47 | 48 | printf("Input buffer size: %d \n", rcvBuf); 49 | printf("Output buffer size: %d \n", sndBuf); 50 | } 51 | 52 | void ErrorHandling(char *message) 53 | { 54 | fputs(message, stderr); 55 | fputc('\n', stderr); 56 | exit(1); 57 | } -------------------------------------------------------------------------------- /Chapter9 소스코드/echo_client.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define BUF_SIZE 1024 9 | void error_handling(char *message); 10 | 11 | int main(int argc, char *argv[]) 12 | { 13 | int sock; 14 | char message[BUF_SIZE]; 15 | int str_len; 16 | struct sockaddr_in serv_adr; 17 | 18 | if(argc!=3) { 19 | printf("Usage : %s \n", argv[0]); 20 | exit(1); 21 | } 22 | 23 | sock=socket(PF_INET, SOCK_STREAM, 0); 24 | if(sock==-1) 25 | error_handling("socket() error"); 26 | 27 | memset(&serv_adr, 0, sizeof(serv_adr)); 28 | serv_adr.sin_family=AF_INET; 29 | serv_adr.sin_addr.s_addr=inet_addr(argv[1]); 30 | serv_adr.sin_port=htons(atoi(argv[2])); 31 | 32 | if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1) 33 | error_handling("connect() error!"); 34 | else 35 | puts("Connected..........."); 36 | 37 | while(1) 38 | { 39 | fputs("Input message(Q to quit): ", stdout); 40 | fgets(message, BUF_SIZE, stdin); 41 | 42 | if(!strcmp(message,"q\n") || !strcmp(message,"Q\n")) 43 | break; 44 | 45 | write(sock, message, strlen(message)); 46 | str_len=read(sock, message, BUF_SIZE-1); 47 | message[str_len]=0; 48 | printf("Message from server: %s", message); 49 | } 50 | 51 | close(sock); 52 | return 0; 53 | } 54 | 55 | void error_handling(char *message) 56 | { 57 | fputs(message, stderr); 58 | fputc('\n', stderr); 59 | exit(1); 60 | } -------------------------------------------------------------------------------- /Chapter9 소스코드/get_buf.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | void error_handling(char *message); 6 | 7 | int main(int argc, char *argv[]) 8 | { 9 | int sock; 10 | int snd_buf, rcv_buf, state; 11 | socklen_t len; 12 | 13 | sock=socket(PF_INET, SOCK_STREAM, 0); 14 | len=sizeof(snd_buf); 15 | state=getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (void*)&snd_buf, &len); 16 | if(state) 17 | error_handling("getsockopt() error"); 18 | 19 | len=sizeof(rcv_buf); 20 | state=getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (void*)&rcv_buf, &len); 21 | if(state) 22 | error_handling("getsockopt() error"); 23 | 24 | printf("Input buffer size: %d \n", rcv_buf); 25 | printf("Outupt buffer size: %d \n", snd_buf); 26 | return 0; 27 | } 28 | 29 | void error_handling(char *message) 30 | { 31 | fputs(message, stderr); 32 | fputc('\n', stderr); 33 | exit(1); 34 | } -------------------------------------------------------------------------------- /Chapter9 소스코드/reuseadr_eserver.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define TRUE 1 9 | #define FALSE 0 10 | void error_handling(char *message); 11 | 12 | int main(int argc, char *argv[]) 13 | { 14 | int serv_sock, clnt_sock; 15 | char message[30]; 16 | int option, str_len; 17 | socklen_t optlen, clnt_adr_sz; 18 | struct sockaddr_in serv_adr, clnt_adr; 19 | 20 | if(argc!=2) { 21 | printf("Usage : %s \n", argv[0]); 22 | exit(1); 23 | } 24 | 25 | serv_sock=socket(PF_INET, SOCK_STREAM, 0); 26 | if(serv_sock==-1) 27 | error_handling("socket() error"); 28 | /* 29 | optlen=sizeof(option); 30 | option=TRUE; 31 | setsockopt(serv_sock, SOL_SOCKET, SO_REUSEADDR, &option, optlen); 32 | */ 33 | 34 | memset(&serv_adr, 0, sizeof(serv_adr)); 35 | serv_adr.sin_family=AF_INET; 36 | serv_adr.sin_addr.s_addr=htonl(INADDR_ANY); 37 | serv_adr.sin_port=htons(atoi(argv[1])); 38 | 39 | if(bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))) 40 | error_handling("bind() error "); 41 | 42 | if(listen(serv_sock, 5)==-1) 43 | error_handling("listen error"); 44 | clnt_adr_sz=sizeof(clnt_adr); 45 | clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr,&clnt_adr_sz); 46 | 47 | while((str_len=read(clnt_sock,message, sizeof(message)))!= 0) 48 | { 49 | write(clnt_sock, message, str_len); 50 | write(1, message, str_len); 51 | } 52 | close(clnt_sock); 53 | return 0; 54 | } 55 | 56 | void error_handling(char *message) 57 | { 58 | fputs(message, stderr); 59 | fputc('\n', stderr); 60 | exit(1); 61 | } -------------------------------------------------------------------------------- /Chapter9 소스코드/set_buf.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | void error_handling(char *message); 6 | 7 | int main(int argc, char *argv[]) 8 | { 9 | int sock; 10 | int snd_buf=1024*3, rcv_buf=1024*3; 11 | int state; 12 | socklen_t len; 13 | 14 | sock=socket(PF_INET, SOCK_STREAM, 0); 15 | state=setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (void*)&rcv_buf, sizeof(rcv_buf)); 16 | if(state) 17 | error_handling("setsockopt() error!"); 18 | 19 | state=setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (void*)&snd_buf, sizeof(snd_buf)); 20 | if(state) 21 | error_handling("setsockopt() error!"); 22 | 23 | len=sizeof(snd_buf); 24 | state=getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (void*)&snd_buf, &len); 25 | if(state) 26 | error_handling("getsockopt() error!"); 27 | 28 | len=sizeof(rcv_buf); 29 | state=getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (void*)&rcv_buf, &len); 30 | if(state) 31 | error_handling("getsockopt() error!"); 32 | 33 | printf("Input buffer size: %d \n", rcv_buf); 34 | printf("Output buffer size: %d \n", snd_buf); 35 | return 0; 36 | } 37 | 38 | void error_handling(char *message) 39 | { 40 | fputs(message, stderr); 41 | fputc('\n', stderr); 42 | exit(1); 43 | } 44 | /* 45 | root@com:/home/swyoon/tcpip# gcc get_buf.c -o getbuf 46 | root@com:/home/swyoon/tcpip# gcc set_buf.c -o setbuf 47 | root@com:/home/swyoon/tcpip# ./setbuf 48 | Input buffer size: 2000 49 | Output buffer size: 2048 50 | */ 51 | 52 | 53 | -------------------------------------------------------------------------------- /Chapter9 소스코드/sock_type.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | void error_handling(char *message); 6 | 7 | int main(int argc, char *argv[]) 8 | { 9 | int tcp_sock, udp_sock; 10 | int sock_type; 11 | socklen_t optlen; 12 | int state; 13 | 14 | optlen=sizeof(sock_type); 15 | tcp_sock=socket(PF_INET, SOCK_STREAM, 0); 16 | udp_sock=socket(PF_INET, SOCK_DGRAM, 0); 17 | printf("SOCK_STREAM: %d \n", SOCK_STREAM); 18 | printf("SOCK_DGRAM: %d \n", SOCK_DGRAM); 19 | 20 | state=getsockopt(tcp_sock, SOL_SOCKET, SO_TYPE, (void*)&sock_type, &optlen); 21 | if(state) 22 | error_handling("getsockopt() error!"); 23 | printf("Socket type one: %d \n", sock_type); 24 | 25 | state=getsockopt(udp_sock, SOL_SOCKET, SO_TYPE, (void*)&sock_type, &optlen); 26 | if(state) 27 | error_handling("getsockopt() error!"); 28 | printf("Socket type two: %d \n", sock_type); 29 | return 0; 30 | } 31 | 32 | void error_handling(char *message) 33 | { 34 | fputs(message, stderr); 35 | fputc('\n', stderr); 36 | exit(1); 37 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # 윤성우 열혈 TCP/IP 소켓프로그래밍 소스코드 2 | 자료 출처: https://www.orentec.co.kr/jaryosil/TCP_IP_1/add_form.php 3 | 4 | --------------------------------------------------------------------------------