#include <sys/socket.h> 	// -> #include <netdb.h> 에 포함된다.
int socket(
    int domain,		// 프로토콜 체계
    int type,		// 서비스 타입
    int protocal);	// 소켓에서 사용할 프로토콜

//--------------------------------------------------------------
// 파일명 : open_socket.c
// 기  능 : socket() 시스템 콜을 호출하고, 생성된 소켓번호를 출력
// 컴파일 : cc -o open_socket open_socket.c
// 사용법 : open_socket
//--------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>	// 소켓 시스템 콜에 필요한 상수 선언
#include <sys/stat.h>	// 파일의 상태에 대한 데이터 선언
#include <sys/socket.h>	// 소켓 시스템 콜 선언  -> #include <netdb.h> 에 포함된다.
#include <fcntl.h>	// open에 필요한 flag 선언 (O_RDONLY)
#include <unistd.h>

int main() {
    //파일 및 소켓번호
    int fd1, fd2, sd1, sd2;
    
    // 파일 열기
    fd1 = open("/etc/passwd", O_RDONLY, 0);
    printf("/etc/passwd's file descriptor = %d\n", fd1);
    
    // TCP 소켓 열기
    sd1 = socket(PF_INET, SOCK_STREAM, 0);
    printf("stream socket descriptor = %d\n", sd1);

    // UDP 소켓 열기
    sd2 = socket(PF_INET, SOCK_DGRAM, 0);
    printf("datagram socket descriptor = %d\n", sd2);
 
    // 또다른 파일 열기
    fd2 = open("/etc/hosts", O_RDONLY, 0);
    printf("/etc/hosts's file descriptor = %d\n", fd2);
    
    // 파일 및 소켓 닫기
    close(fd2);
    close(sd2);
    close(sd1);
    close(fd1);
    
    return 0;
}

#include <stdio.h>
#include <unistd.h>
printf("getdtablesize() = %d\n", getdtablesize());

struct sockaddr {
    u_short sa_family;	// address family
    char sa_data[14];	// 주소
};

#include <netinet/in.h>
struct in_addr {
    u_long s_addr;		// 32비트의 binary IP 주소를 저장할 구조체
};

struct sockaddr_in {
    short	sin_family;			// 주소 체계
    u_short	sin_port;			// 16비트 포트번호
    struct	in_addr sin_addr;	// 32비트 IP 주소
    char	sin_zero[8];		// 전체 크기를 16바이트로 맞추기 위한 dummy
};

#include <netdb.h>
pmyservent = getservbyname("echo", "udp");

#include <netdb.h>
struct servent {
	char *s_name;		// 서비스 이름
    char **s_aliases;	// 별명 목록
    int  s_port;		// 포트번호
    char *s_proto;		// 사용하는 프로토콜
}

//--------------------------------------------------------------------
// 파일명: byte_order.c
// 기  능: 호스트 바이트 순서 테스트 프로그램
// 컴파일: cc -o byte_order byte_order.c -lsocket
// 사용법: byte_order
//--------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>	// 위 두 헤더파일은 이것만 선언해도 포함 됨

int main(void) {
	struct servent *servent;
	servent = getservbyname("echo", "udp");
	if(servent==NULL) {
		printf("서비스 정보를 얻을 수 없음. \n\n");
		exit(0);	
	}
	
	printf("UDP 에코 포트번호 (네트워크 순서) : %d\n", servent->s_port);
	printf("UDP 에코 포트번호 (호스트 순서) : %d\n", ntohs(servent->s_port));
    // cpu가 인텔인 경우에는 반드시 ntohs()를 이용해 바이트 순서를 바꿔주어야 한다.
	
	return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
const char *inet_ntop(int af, const void *src, char *dst, size_t cnt);
int *inet_pton(int af, const char *src, void *dst);

//--------------------------------------------------------------------
// 파일명: ascii_ip.c
// 기  능: ASCII (dotted decimal)로 포현된 주소를 4 바이트 IP 주소로 변환
// 컴파일: cc -o ascii_ip ascii_ip.c
// 사용법: ascii_ip 192.203.144.11
//--------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h> // in_addr 정의
#include <arpa/inet.h> // inet_pton(), inet_ntop() 정의
#include <netdb.h>

int main(int argc, char *argv[]) {
	struct in_addr inaddr;	// 32비트 IP주소 구조체
	char buf[20];

	if(argc < 2) {
		printf("사용법 : %s IP 주소(dotted decimal) \n", argv[0]);
		exit(0);
	}
	printf("*입력한 dotted decimal IP 주소: %s\n", argv[1]);

	inet_pton(AF_INET, argv[1], &inaddr.s_addr);
	printf(" inet_pton(%s) = 0x%X\n", argv[1], inaddr.s_addr);
	inet_ntop(AF_INET, &inaddr.s_addr, buf, sizeof(buf));
	printf(" inet_ntop(0x%X) = %s\n", inaddr.s_addr, buf);

	return 0;
}

#include <netdb.h>
struct hostent *gethostbyname(const char *hname);
struct hostent *gethostbyaddr(const char *in_addr, int len, int family);

struct hostent {
    char*	h_name;			// 호스트 이름
    char**	h_aliases;		// 호스트 별명들
    int 	h_addrtype;		// 호스트 주소의 종류 (AF_INET = 2 등 주소체계)
    int 	h_length;		// 주소의 크기 (바이트 단위, IPv4에서는 4byte)
    char**	h_addr_list;	// IP 주소 리스트
};
#define	h_addr h_addr_list[0] // 첫 번째 (대표) 주소

//-----------------------------------------------------------------------
// 파일명: get_hostent.c
// 동  작: 도메인 이름을 IP 주소로 변환
// 컴파일: cc -o get_hostent get_hostent.c
// 실  행: get_hostent www.skuniv.ac.kr
//-----------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>		// memcpy 함수 선언
#include <sys/socket.h>
#include <netinet/in.h> // in_addr 정의
#include <arpa/inet.h>
#include <unistd.h>
#include <netdb.h> // gethostbyname() 정의
#include <errno.h>

int main(int argc, char *argv[]) {
	struct hostent *hp;
	struct in_addr in;
	int i;
	char buf[20];

	if(argc<2) { // 인자가 작으면
		printf("Usage: %s hostname\n", argv[0]);
		exit(1);
	}
	hp = gethostbyname(argv[1]);
	if(hp==NULL) {
		printf("gethostbyname fail\n");
		exit(0);
	}
	printf("호스트 이름		: %s\n", hp->h_name);
	printf("호스트 주소타입 번호	: %d\n", hp->h_addrtype);
	printf("호스트 주소의 길이	: %d\n", hp->h_length);
	for(i=0; hp->h_addr_list[i]; i++) {
		memcpy(&in.s_addr, hp->h_addr_list[i], sizeof(in.s_addr));
		inet_ntop(AF_INET, &in, buf, sizeof(buf)); // &in이나 &in.s_addr이나 상관없다.
		printf("IP 주소(%d 번째) : %s ", i+1, buf); // 구조체 멤버가 하나 밖에 없기 때문
	}
	for( i=0; hp->h_aliases[i]; i++) {
		printf("호스트 별명(%d 번째) : %s ", i+1, hp->h_aliases[i]);
	}
	puts("");
	return 0;
}

//-----------------------------------------------------------------------
// 파일명: get_host_byaddr.c
// 동  작: hostent 구조체 내용 출력 프로그램
// 컴파일: cc -o get_host_byaddr get_host_byaddr.c
// 실  행: get_host_byaddr 192.203.144.27
//-----------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h> // in_addr 정의
#include <arpa/inet.h> // inet_ntop, inet_pton
#include <netdb.h> // gethostbyaddr() 정의

int main(int argc, char *argv[]) {
	struct hostent *myhost;
	struct in_addr in;

	if(argc<2) { // 인자가 작으면
		printf("사용법: %s ip_address \n", argv[0]);
		exit(0);
	}
	
	inet_pton(AF_INET, argv[1], &in.s_addr); // dotted decimal -> 32bit 주소
	myhost = gethostbyaddr((char*)&(in.s_addr), sizeof(in.s_addr), AF_INET);
						  // typecasting. 안해도 상관은 없는듯 하다.
    
	if (myhost == NULL) {
		printf("Error at gethostbyaddr()\n");
		exit(0);
	}
	printf("호스트 이름: %s\n", myhost->h_name);
	return 0;
}

int socket(
    int domain,		// 프로토콜 체계
    int type,		// 서비스 타입 -> SOCK_STREAM(TCP) 또는 SOCK_DGRAM(UDP)
    int protocal);	// 소켓에서 사용할 프로토콜 -> 위에서 이미 결정 되었으므로 0!

int connect (
	int s,							// 서버와 연결시킬 소켓번호
	const struct sockaddr *addr,	// 상대방 서버의 소켓주소 구조체 typecasting을 꼭 해줘야함 ★
	int addrlen);					// 구조체 *addr의 크기

struct sockaddr {
    u_short sa_family;	// address family
    char sa_data[14];	// 주소
};

// 위에꺼 복습
struct in_addr {
    u_long s_addr;		// 32비트의 IP 주소를 저장할 구조체
};

struct sockaddr_in {
    short	sin_family;			// 주소 체계
    u_short	sin_port;			// 16비트 포트번호
    struct	in_addr sin_addr;	// 32비트 IP 주소
    char	sin_zero[8];		// 전체 크기를 16바이트로 맞추기 위한 dummy
};

int send(int s, char* buf, int length, int flags);
int write(int s, void* buf, int length);

int recv(int s, char* buf, int length, int flags);
int read(int s, void* buf, int length);

//---------------------------------------------
// 파일명 : mydaytime.c
// 기  능 : daytime 서비스를 요청하는 TCP(연결형) 클라이언트
// 컴파일 : cc -o mydaytime mydaytime.c
// 사용법 : mydaytime 203.252.65.3
//---------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define MAXLINE 127

int main(int argc, char *argv[]) {
	int s, nbyte;
	struct sockaddr_in servaddr; // 서버 소켓 주소 구조체
	char buf[ MAXLINE + 1 ];

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

	// 소켓 생성  // 프로토콜체계 인터넷, 서비스 TCP
	if((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
		perror("socket fail");
		exit(1);
	}
	// 서버의 소켓주소 구조체 servaddr을 '\0'으로 초기화
	bzero((char*)&servaddr, sizeof(servaddr));
	// servaddr의 주소 지정
	servaddr.sin_family = AF_INET; // 주소체계 인터넷
	inet_pton(AF_INET, argv[1], &servaddr.sin_addr); // dotted decimal to binary
	servaddr.sin_port = htons(13); // well-known port 13

	// 연결 요청  // 소켓 디스크립터, 서버 소켓주소 구조체(Type casting)
	if (connect(s, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
		perror("connect fail"); // 연결 실패시 -1 반환
		exit(1);
	}
	// 서버가 보내오는 daytime 데이터의 수신 및 화면 출력
	 if((nbyte = read(s, buf, MAXLINE)) < 0) {
		perror("read fail");
		exit(1);
	 }
	 buf[nbyte] = 0; // 문자열의 끝
	 printf("%s", buf);
	 close(s);
	 return 0;
}

./mydaytime 129.6.15.28

59133 20-10-11 15:17:56 22 0 0 642.5 UTC(NIST) *

//-------------------------------------------------------
// 파일명 : tcp_echocli.c
// 기  능 : echo 서비스를 요청하는 TCP(연결형) 클라이언트
// 컴파일 : cc -o tcp_echocli tcp_echocli.c
// 사용법 : tcpi_echocli 203.252.65.3
//-------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define MAXLINE 127

int main(int argc, char *argv[]) {
	int s, nbyte;
	struct sockaddr_in servaddr; // 서버 소켓 주소 구조체
	char buf[ MAXLINE + 1 ];

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

	// 소켓 생성  // 프로토콜체계 인터넷, 서비스 TCP
	if((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
		perror("socket fail");
		exit(1);
	}
	// 에코 서버의 소켓주소 구조체 작성
	bzero((char*)&servaddr, sizeof(servaddr));
	// servaddr의 주소 지정
	servaddr.sin_family = AF_INET; // 주소체계 인터넷
	inet_pton(AF_INET, argv[1], &servaddr.sin_addr); // dotted decimal to binary
	servaddr.sin_port = htons(7); // well-known port 7

	// 연결 요청  // 소켓 디스크립터, 서버 소켓주소 구조체(Type casting)
	if (connect(s, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
		perror("connect fail"); // 연결 실패시 -1 반환
		exit(1);
	}

	printf("입력 : ");
	if (fgets(buf, sizeof(buf), stdin) == NULL) // 키보드로부터 입력 받기
		exit(0);

	nbyte = strlen(buf); // 입력받은 문자열 길이
	// 에코 서버로 메시지 송신
	if (write(s, buf, nbyte) < 0) { // 소켓
		printf("write error\n");
		exit(0);
	}

	// 수신된 에코 데이터 화면출력
	printf("수신 : ");
	if((nbyte = read(s, buf, MAXLINE)) < 0) {
		perror("read fail");
		exit(0);
	}
	buf[nbyte] = 0;
	printf("%s", buf);
	close(s);
	return 0;
}

int bind(
    int s,					// 소켓 번호
    struct sockaddr *addr,	// 서버 자신의 소켓 주소 구조체 포인터
    int len);				// *addr 구조체의 크기

#define SERV_IP_ADDR "203.252.65.3"
#define SERV_PORT 3008

// 소켓 생성
s = socket(PF_INET, SOCK_STREAM, 0);
struct sockaddr_in servaddr;

// 소켓주소 구조체 내용
servaddr.sin_family = AF_INET;
inet_pton(AF_INET, SERV_IP_ADDR, &servaddr.sin_addr);
//servaddr.sin_addr.s_addr = inet_addr(SERV_IP_ADDR); 도 가능
servaddr.sin_port = htons(SERV_PORT);

// 소켓번호와 소켓 주소를 bind
bind(s, (struct sockaddr *)&servaddr, sizeof(servaddr));

servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

int listen(
	int s,			// 소켓번호
	int backlog);	// 연결을 기다리는 클라이언트의 최대 수

listen(s, 2);

int accept(
    int s,					// 소켓 번호
    struct sockaddr *addr,	// 연결요청을 한 클라이언트의 소켓주소 구조체
    int *addrlen);			// *addr 구조체 크기의 포인터

accp_sock = accept(listen_sock, (struct sockaddr *)&cliaddr, &addrlen)

//-----------------------------------------------
// 파일명 : tcp_echoserv.c
// 기  능 : 에코 서비스를 수행하는 서버
// 컴파일 : cc -o tcp_echoserv tcp_echoserv.c
// 사용법 : ./tcp_echoserv.c 3008
//-----------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

#define MAXLINE 127

int main(int argc, char *argv[]) {
	struct sockaddr_in servaddr, cliaddr;	// 소켓 두개
	int listen_sock, accp_sock,		// 소켓 번호
		addrlen=sizeof(cliaddr),	// 소켓주소 구조체 길이
		nbyte,
		count=0;
	char buf[ MAXLINE + 1 ];

	if(argc != 2) {
		printf("usage: %s port\n", argv[0]);
		exit(0);
	}
	// 소켓 생성
	if((listen_sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
		perror("socket fail");
		exit(0);
	}

	// servaddr을 '\0'으로 초기화
	bzero((char *)&servaddr, sizeof(servaddr));
	// servaddr 세팅
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(atoi(argv[1]));	// 문자열 포트번호

	// bind() 호출
	if(bind(listen_sock, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
		perror("bind fail");
		exit(0);
	}
	// 소켓을 수동 대기모드로 세팅
	listen(listen_sock, 5);
	// 여기까지 하면 준비 완료!
	
	// iterative 에코 서비스 수행
	while(1) {
		puts("서버가 요청을 기다림");
		// 연결 요청을 기다림. 여기서 block 된다!
		accp_sock = accept(listen_sock, (struct sockaddr *)&cliaddr, &addrlen);
		if(accp_sock < 0) {
			perror("accept fail");
			exit(0);
		}
		printf("%d 번째 클라이언트가 연결됨..\n", ++count);
		nbyte = read(accp_sock, buf, MAXLINE);
		buf[nbyte] = 0;
		printf("%s", buf);
		write(accp_sock, buf, nbyte);
		close(accp_sock);
	}
	close(listen_sock);
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netdb.h>

#define MAXLINE 127

int main(int argc, char *argv[]) {
        int s, nbyte;
        struct sockaddr_in servaddr;
        char buf[MAXLINE + 1];

        if (argc != 3) { // 이 부분 달라짐 !!!
                printf("Usage: %s ip_address port_num\n", argv[0]);
                exit(0);
        }

        // 소켓 생성
        if ((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
                perror("socket fail");
                exit(1);
        }

        // 에코 서버 소켓주소 구조체 초기화
        bzero(&servaddr, sizeof(servaddr));

        // servaddr 주소 지정
        servaddr.sin_family = AF_INET;
        //inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
        servaddr.sin_addr.s_addr = inet_addr(argv[1]);
        servaddr.sin_port = htons(atoi(argv[2])); // 이 부분 달라짐 !!!

        // connect 요청
        if (connect(s, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
                perror("connect fail");
                exit(1);
        }

        // 보낼 데이터 입력
        printf("입력 : ");
        if (fgets(buf, sizeof(buf), stdin) == NULL)
                exit(0);
        nbyte = strlen(buf);

        // 에코 서버로 메시지 송신
        if (write(s, buf, nbyte) < 0) {
                perror("write fail");
                exit(0);
        }

        // 수신한 에코 데이터 출력
        if ((nbyte = read(s, buf, MAXLINE)) < 0) {
                perror("read fail");
                exit(0);
        }
        buf[nbyte] = 0;
        printf("수신 : %s", buf);
        close(s);

        return 0;
}

./tcp_echocli1 127.0.0.1 3008

입력 : input test
수신 : input test

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netdb.h>

#define MAXLINE 127

int main(int argc, char *argv[]) {
        int s, nbyte;
        struct sockaddr_in servaddr;
        struct in_addr in;
        struct hostent *hp;
        char buf[MAXLINE + 1];

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

        // 소켓 생성
        if ((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
                perror("socket fail");
                exit(0);
        }

        // 도메인을 바이너리로 변환
        hp = gethostbyname(argv[1]);
        memcpy(&in, hp->h_addr_list[0], sizeof(in));

        // 서버 소켓주소 초기화
        bzero(&servaddr, sizeof(servaddr));

        // servaddr 셋팅
        servaddr.sin_family = AF_INET;
        servaddr.sin_addr.s_addr = in.s_addr;
        servaddr.sin_port = htons(atoi(argv[2]));

        // connect() 연결
        if (connect(s, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
                perror("connect fail");
                exit(1);
        }

        // 보낼 데이터 입력
        printf("입력 : ");
        if (fgets(buf, sizeof(buf), stdin) == NULL) {
                exit(0);
        }
        nbyte = strlen(buf);

        // 데이터 송신 write()
        if (write(s, buf, nbyte) < 0) {
                perror("write fail");
                exit(0);
        }

        // 데이터 수신 read() 및 출력
        if ((nbyte = read(s, buf, MAXLINE)) < 0) {
                perror("read fail");
                exit(0);
        }
        buf[nbyte] = 0;
        printf("수신 : %s", buf);

        // 소켓 close
        close(s);

        return 0;
}

int sendto(int s, char* buf, int length, int flags,
          sockaddr* to, int tolen)

int recvfrom(int s, char* buf, int length, int flags,
            sockaddr* from, int* tolen)

socket(PF_INET, SOCK_DGRAM, 0);
...
sendto(s, buf, strlen(buf), 0, (struct sockaddr *)&servaddr, addrlen);
recvfrom(s, buf, MAXLINE, 0, (struct sockaddr *)&servaddr, &addrlen);

unsigned long inet_addr(const char *string);

//---------------------------------------------
// 파일명 : udp_echocli.c
// 기  능 : echo 서비스를 요청하는 UDP(비연결형) 클라이언트
// 컴파일 : cc -o udp_echocli udp_echocli.c
// 사용법 : udp_echocli 117.17.142.162 4008
//---------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define MAXLINE 511

int main(int argc, char *argv[]) {
	struct sockaddr_in servaddr;
	int s, nbyte, addrlen = sizeof(servaddr);
	char buf[ MAXLINE + 1 ];

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

	// 소켓 생성
	if((s = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
		perror("socket fail");
		exit(1);
	}

	// 에코 서버의 소켓주소 구조체 작성
	bzero((char*)&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = inet_addr(argv[1]);
	servaddr.sin_port = htons(atoi(argv[2]));

	// 키보드 입력 받음
	printf("입력 : ");
	if (fgets(buf, sizeof(buf), stdin) == NULL) {
		printf("fgets fail");
		exit(0);
	}

	// 에코 서버로 메시지 송신
	if (sendto(s, buf, strlen(buf), 0,
		(struct sockaddr *)&servaddr, addrlen) < 0) {
		perror("sendto fail");
		exit(0);
	}

	// 수신된 에코 메시지
	if((nbyte = recvfrom(s, buf, MAXLINE, 0,
		(struct sockaddr *)&servaddr, &addrlen)) < 0) {
		perror("recvfrom fail");
		exit(0);
	}
	buf[nbyte] = 0;
	printf("%s", buf);
	close(s);
	return 0;
}

//-----------------------------------------------
// 파일명 : udp_echoserv.c
// 기  능 : 에코 서비스를 수행하는 서버
// 컴파일 : cc -o udp_echoserv udp_echoserv.c
// 사용법 : ./udp_echoserv.c 4008
//-----------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

#define MAXLINE 511

int main(int argc, char *argv[]) {
	struct sockaddr_in servaddr, cliaddr;	// 소켓 두개
	int s, nbyte, addrlen=sizeof(struct sockaddr);
	char buf[ MAXLINE + 1 ];

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

	// 소켓 생성
	if((s = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
		perror("socket fail");
		exit(0);
	}

	// servaddr을 '\0'으로 초기화
	bzero((char *)&servaddr, addrlen);
	bzero((char*)&cliaddr, addrlen);

	// servaddr 세팅
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(atoi(argv[1]));	// 문자열 포트번호

	// bind() 호출
	if(bind(s, (struct sockaddr *)&servaddr, addrlen) < 0) {
		perror("bind fail");
		exit(0);
	}
	// 여기까지 하면 준비 완료!
	
	// iterative 에코 서비스 수행
	while(1) {
		puts("Server : waiting request.");
		nbyte = recvfrom(s, buf, MAXLINE, 0,
			(struct sockaddr*)&cliaddr, &addrlen);
		if(nbyte<0) {
			perror("recvfrom fail");
			exit(1);	
		}
		buf[nbyte] = 0;
		printf("%d byte recv: %s\n", nbyte, buf);
		if (sendto(s, buf, nbyte, 0,
			(struct sockaddr*)&cliaddr, addrlen) < 0) {
			perror("sendto fail");
			exit(1);
		}
		puts("sendto complete");
	}
	return 0;
}