1. 네트워크 관련 명령어

1. telnet

• 원격 컴퓨터에 로그인하고 명령을 실행 할 수 있는 텍스트 기반의 네트워크 프로토콜
• 기본적인 tcp 연결 생성용으로 사용

2. nc

• 다양한 네트워크 작업을 수행할 수 있는 커맨드라인 도구
• TCP 및 UDP 프로토콜을 사용하여 소켓을 열고 데이터를 송수힌 할 수 있으며, 클라이언트와 서버 간의 연결을 설정

1. TCP/UDP 연결

1. TCP 연결

nc [opt] [host] [port]

2. UDP 연결

nc -u [opt] [host] [port]

2. 파일 전송

1. 수신 측

nc -l [port] > [filename]

2. 송신 측

nc [host][port] < [filename]

3. 포트 스캔

nc -zv [host] [port-range]

• -zv 옵션: 포트 스캔 모드를 설정
• -z 옵션: 아무 데이터를 전송하지 않고, listening daemon 들만 스캔
• -v 옵션: 상세 정보를 출력

3. ifconfig

• 네트워크 인터페이스의 설정을 확인하고 변경하는 명령어

1. ifconfig

• 현재 시스템에 설정된 네트워크 인터페이스의 정보를 출력

2. ifconfig [인터페이스명]

• 특정 네트워크 인터페이스의 정보만 출력

3. ifconfig [인터패이스명][ip주소][넷마스크]

• 특정 네트워크 인터페이스의 ip주소와 넷마스크를 설정

4. ifconfig [인터페이스명][up/down]

• 특정 네트워크 인터페이스를 활성화 또는 비활성화

4. ping

• 네트워크 연결 상태를 확인

5. traceroute

• 목적지까지 패킷이 어떤 경로를 통해 전송되는지 추적

1. traceroute [호스트명/ip주소]

• 해당 호스트나 IP주소로 ICMP 패킷을 보내서 경로를 추적

6. netstat

• 네트워크 연결 상태 및 활성화된 포트를 확인

7. dig

• DNS(Domain Name System) 조회를 수행

8. ssh

• 원격 서버에 안전하게 로그인하고, 컴퓨터간에 파일을 전송

9. scp

• ssh 프로토콜을 사용하여 로컬과 원격 시스템 간에 파일을 복사

1. scp [옵션][원본파일][대상경로]

• -r: 디렉토리를 복사
• -P: ssh 포트를 지정
• -v: 디버그 모드로 실행

10.curl, wget

• 웹 페이지나 파일을 다운로드
• 주로 HTTP, HTTPS, FTP 등의 프로토콜을 사용하여 데이터를 전송

1. curl [옵션][URL]

• -i: 헤더 정보를 출력
• -X: HTTP 메소드를 지정
• -H: HTTP 요청 헤더를 지정
• -d: POST 요청 시 전송할 데이터를 지정
• -o: 출력 파일을 지정

2. REST API 호출

• API 엔드포인트 URL 과 HTTP 메소드, 요청 헤더, 전송할 데이터 등을 지정

API

• POST https://example.com/api/users

curl 명령

• curl -X POST -H "Content-Type: application/json" -d '{"username": "sanghwan", "password": "11111111"}' https://example.com/api/users

11. tcpdump

• 네트워크 패킷을 캡쳐하고 분석하기 위한 명령어
• 패킷 분석 및 디버깅, 보안 감사 등에 사용

1. tcpdump [옵션][식별자]

• -i:캡처할 인터페이스를 지정
• -n: IP 주소 및 포트 번호를 숫자 형태로 출력
• -s: 캡처할 패킷의 최대 크기를 지정
• -v: 패킷을 자세하게 출력
• -c: 캡처할 패킷의 수를 지정
• -w: 캡처한 패킷을 파일에 저장

2. tcpdump host [ip주소]

• 특정 IP 주소에서 전송되는 모든 패킷을 캡쳐

3. tcpdump port [port]

• 특정 포트에서 발생하는 패킷을 캡쳐

4. tcpdump [protocol]

• 특정 프로토콜을 사용하는 패킷을 캡쳐

2. 네트워크 응용 개요

1. 네트워크의 종류

1. 클라이언트 - 서버 방식

• 서버가 계속 작동하고 있어야 함

2. P2P(peer to peer) 방식

2. 소켓

• 컴퓨터들간의 통신을 가능하게 하는 엔드포인트
• 소켓을 사용하여 서버와 클라이언트 간에 데이터를 전송

1. 스트림 소켓

• 전송 제어 프로토콜(TCP)을 기반으로 하는 소켓
• 연결 지향적이며 신뢰성 있는 데이터 전송
• 웹 브라우징, 이메일 전송 등의 애플리케이션에서 주로 사용

2. 데이터그램 소켓

• 사용자 데이터그램 프로토콜(UDP)을 기반으로 하는 소켓
• 비연결 지향적이며 신뢰성이 떨어지지만 속도가 빠름
• 데이터 전송 순서를 보장하지 않음
• 음성 및 동영상 스트리밍, 온라인 게임 등의 애플리케이션에서 주로 사용

3. TCP

1. TCP 서버

1. server.c 코드

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <ctype.h>

int main(int argc, char *argv[]) {
	struct sockaddr_in server, remote;
	int request_sock, new_sock;
	int bytesread, addrlen;
	int i;
	char buf[BUFSIZ];
	if (argc != 2) {
		(void) fprintf(stderr,"usage: %s port\n", argv[0]);
		exit(1);
	}
	if ((request_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
		perror("socket");
		exit(1);
	}

	memset((void *) &server, 0, sizeof (server));
	server.sin_family = AF_INET;
	server.sin_addr.s_addr = INADDR_ANY;
	printf("%d\n", INADDR_ANY);
    //host to network short: 아키텍쳐에 따라 비트를 저장하는 방식이 다르기 때문에, 이것을 네트워크 응용프로그램이 이해할 수 있도록 통일된 방식으로 변환
	server.sin_port = htons((u_short)atoi(argv[1]));

	if (bind(request_sock, (struct sockaddr *)&server, sizeof (server)) < 0) {
		perror("bind");
		exit(1);
	}
	if (listen(request_sock, SOMAXCONN) < 0) {
		perror("listen");
		exit(1);
	}
	for (;;) {
		addrlen = sizeof(remote);
		new_sock = accept(request_sock,
			(struct sockaddr *)&remote, (socklen_t *)&addrlen);
		if (new_sock < 0) {
			perror("accept");
			exit(1);
		}
		printf("connection from host %s, port %d, socket %d\n",
			inet_ntoa(remote.sin_addr), ntohs(remote.sin_port), new_sock);

		for (;;) {
			bytesread = read(new_sock, buf, sizeof (buf) - 1);
			if (bytesread<=0) {
				printf("server: end of file on %d\n", new_sock);
				if (close(new_sock))
					perror("close");
				break;
			}
			buf[bytesread] = '\0';
			printf("%s: %d bytes from %d: %s\n",
				argv[0], bytesread, new_sock, buf);
			for(i = 0; i < bytesread; i++)
				buf[i] = toupper(buf[i]);
			/* echo it back */
			if (write(new_sock, buf, bytesread) != bytesread)
				perror("echo");
		}
	}
}

2. 동작 모습

2. TCP 클라이언트

1. client.c 코드

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <string.h>

int main(int argc, char *argv[])
{
	struct hostent *hostp;
	struct sockaddr_in server;
	int sock;

	char buf[BUFSIZ];
	int bytesread;

	if(argc != 3)
	{
		(void) fprintf(stderr,"usage: %s host port\n", argv[0]);
		exit(1);
	}

	if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
		perror("socket");
		exit(1);
	}

	if ((hostp = gethostbyname(argv[1])) == 0) {
		fprintf(stderr,"%s: unknown host\n",argv[2]);
		exit(1);
	}

	memset((void *) &server, 0, sizeof (server));
	server.sin_family = AF_INET;
	memcpy((void *) &server.sin_addr, hostp->h_addr, hostp->h_length);
	server.sin_port = htons((u_short)atoi(argv[2]));

	if (connect(sock, (struct sockaddr *)&server, sizeof (server)) < 0) {
		(void) close(sock);
		fprintf(stderr, "connect");
		exit(1);
	}
	for (;;) {
		/* data from keyboard */
		if (!fgets(buf, sizeof buf, stdin)) {
			close(sock);
			exit(0);
		}
		if (write(sock, buf, strlen(buf)) < 0) {
			perror("write");
			exit(1);
		}
		bytesread = read(sock, buf, sizeof buf - 1);
		buf[bytesread] = '\0';
		printf("%s: got %d bytes: %s\n", argv[0], bytesread, buf);
	}
}

2. 동작 모습

4. UDP

1. UDP 서버

1. udpserver.c 코드

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <unistd.h>
#include <ctype.h>


int main(int argc, char *argv[])
{
   int sockid, nread, addrlen;
   int i;
   struct sockaddr_in my_addr, client_addr;
   char msg[50];
   if(argc != 2)
   {
	printf("%s port\n", argv[0]);
	return 0;
   }

   printf("Server: creating socket\n");
   if ( (sockid = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
      { printf("Server: socket error: %d\n",errno); exit(0); }

   printf("Server: binding my local socket\n");
   memset((char *) &my_addr, 0, sizeof(my_addr));
   my_addr.sin_family = AF_INET;
   my_addr.sin_addr.s_addr = INADDR_ANY;
   my_addr.sin_port = htons(atoi(argv[1]));
   if ( (bind(sockid, (struct sockaddr *) &my_addr,
      sizeof(my_addr)) < 0) )
      { printf("Server: bind fail: %d\n",errno); exit(0); }

   while(1) {
     memset((char *) &client_addr, 0, sizeof(client_addr));
     addrlen = sizeof(client_addr);
     printf("Server: starting blocking message read\n");
     nread = recvfrom(sockid,msg,sizeof (msg) - 1 ,0,
                 (struct sockaddr *) &client_addr, (socklen_t *)&addrlen);
     printf("message from host %s, port %d, addrlen %d socket %d\n",
        inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), addrlen, sockid);

     printf("Server: retrun code from read is %d\n",nread);
  	msg[nread] = '\0';
     if (nread >0) printf("Server: message is: %s\n",msg);

     for(i = 0; i < nread; i++)
        msg[i] = toupper(msg[i]);

     sendto(sockid, msg,strlen(msg),0,(struct sockaddr *) &client_addr,
                    addrlen);

  }
  close(sockid);
}

2. 동작 모습

2. UDP 클라이언트

1. udpcli.c 코드

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <errno.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
   int sockid, retcode;
   int addrlen, nread;
   struct hostent *hostp;

   struct sockaddr_in my_addr, server_addr;
   char msg[128];
   if(argc != 4)
   {
	printf("%s myport serveraddr serverport\n", argv[0]);
        return 0;
   }

   printf("Client: creating socket\n");
      if ( (sockid = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
      { printf("Client: socket failed: %d\n",errno); exit(0); }

   printf("Client: binding my local socket\n");
   memset((char *) &my_addr, 0, sizeof(my_addr));
   my_addr.sin_family = AF_INET;
   my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
   my_addr.sin_addr.s_addr = inet_addr(argv[2]);
   my_addr.sin_port = htons(atoi(argv[1]));

   if ( (bind(sockid, (struct sockaddr *) &my_addr,
              sizeof(my_addr)) < 0) )
      { printf("Client: bind fail: %d\n",errno); exit(0); }

    if ((hostp = gethostbyname(argv[2])) == 0) {
        fprintf(stderr,"%s: unknown host\n",argv[2]);
        exit(1);
    }


   printf("Client: creating addr structure for server\n");
   bzero((char *) &server_addr, sizeof(server_addr));
   server_addr.sin_family = AF_INET;
   server_addr.sin_addr.s_addr = inet_addr(argv[2]);
	memcpy((void *) &server_addr.sin_addr, hostp->h_addr, hostp->h_length);
   server_addr.sin_port = htons((u_short)atoi(argv[3]));

   printf("Client: initializing message and sending\n");
   sprintf(msg,  "Hello world");
   retcode = sendto(sockid,msg,strlen(msg),0,(struct sockaddr *) &server_addr,
 		    sizeof(server_addr));
   if (retcode <= -1)
     {printf("client: sendto failed: %d\n",errno); exit(0); }
   printf("Client: Successful\n");
 nread = recvfrom(sockid, msg, sizeof (msg) - 1 ,0,
                 (struct sockaddr *) &server_addr, (socklen_t *)&addrlen);

   msg[nread] = '\0';
   printf("From Server: %s\n", msg);

   /* close socket */
   close(sockid);
 }

2. 동작 모습

5. Multiplexing File Descriptors

1. select()

• I/O 멀티플렉싱 시스템 콜, 여러 개의 파일 디스크립터를 감사
• 어떤 디스크립터가 읽거나 쓰기 상태가 가능한 상태인지 확인하여 해당 디스크립터를 선택
• 이를 통해 단일 프로세스가 여러 개의 I/O 요청을 동시에 처리
• select() 함수가 호출되면, 블로킹 되어있다가 어떤 파일 디스크립터가 선택되면 반환
• select() 함수가 반환한 뒤, 선택된 파일 디스크립터에 대해 처리를 수행

2. Multiplexing Server, Client

1. serverorg.c 코드

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>

int main(int argc, char *argv[]) {
	struct sockaddr_in server, remote;
	int request_sock, new_sock;
	int i, nfound, fd, maxfd, bytesread, addrlen;
	fd_set rmask, mask;
	static struct timeval timeout = { 5, 0 }; /* 5 seconds */

	char buf[BUFSIZ];
	if (argc != 2) {
		(void) fprintf(stderr,"usage: %s port\n",argv[0]);
		exit(1);
	}
	if ((request_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
		perror("socket");
		exit(1);
	}

	memset((void *) &server, 0, sizeof server);
	server.sin_family = AF_INET;
	server.sin_addr.s_addr = INADDR_ANY;
	server.sin_port = htons((u_short)atoi(argv[1]));
	if (bind(request_sock, (struct sockaddr *)&server, sizeof server) < 0) {
		perror("bind");
		exit(1);
	}
	if (listen(request_sock, SOMAXCONN) < 0) {
		perror("listen");
		exit(1);
	}

	FD_ZERO(&mask);
	FD_SET(request_sock, &mask);
	maxfd = request_sock;
	for (;;) {
		rmask = mask;
		nfound = select(maxfd + 1, &rmask, (fd_set *)0, (fd_set *)0, &timeout);
		if (nfound < 0) {
			if (errno == EINTR) {
				printf("interrupted system call\n");
				continue;
			}
			/* something is very wrong! */
			perror("select");
			exit(1);
		}
		if (FD_ISSET(request_sock, &rmask)) {
			/* a new connection is available on the connetion socket */
			addrlen = sizeof(remote);
			new_sock = accept(request_sock,
				(struct sockaddr *)&remote, (socklen_t *)&addrlen);
			if (new_sock < 0) {
				perror("accept");
				exit(1);
			}
			printf("connection from host %s, port %d, socket %d\n",
				inet_ntoa(remote.sin_addr), ntohs(remote.sin_port),
				new_sock);
			FD_SET(new_sock, &mask);
			if (new_sock > maxfd)
				maxfd = new_sock;
			FD_CLR(request_sock, &rmask);
		}
		for (fd = 4; fd <= maxfd ; fd++) {
			/* look for other sockets that have data available */
			if (FD_ISSET(fd, &rmask)) {
				/* process the data */
				bytesread = read(fd, buf, sizeof (buf) - 1);
				if (bytesread < 0) {
					perror("read");
					/* fall through */
				}
				if (bytesread<=0) {
					printf("server: end of file on %d\n",fd);
					FD_CLR(fd, &mask);
					if (close(fd)) perror("close");
					continue;
				}
				buf[bytesread] = '\0';
				printf("%s: %d bytes from %d: %s\n",
					argv[0], bytesread, fd, buf);
				for(i = 0; i < bytesread; i++)
					buf[i] = toupper(buf[i]);

				/* echo it back */
				if (write(fd, buf, bytesread) != bytesread)
					perror("echo");
			}
		}
	}
}

2. clientorg.c 코드

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <errno.h>
#include <netdb.h>
#include <string.h>
#include <ctype.h>

int main(int argc, char *argv[]) {
	struct hostent *hostp;
	struct sockaddr_in server;
	int sock;
	static struct timeval timeout = { 5, 0 }; /* five seconds */
	fd_set rmask, xmask, mask;
	char buf[BUFSIZ];
	int nfound, bytesread;
	if (argc != 3) {
		(void) fprintf(stderr,"usage: %s host port\n",argv[0]);
		exit(1);
	}
	if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
		perror("socket");
		exit(1);
	}

	if ((hostp = gethostbyname(argv[1])) == 0) {
		fprintf(stderr,"%s: unknown host\n",argv[1]);
		exit(1);
	}
	memset((void *) &server, 0, sizeof server);
	server.sin_family = AF_INET;
	memcpy((void *) &server.sin_addr, hostp->h_addr, hostp->h_length);
	server.sin_port = htons((u_short)atoi(argv[2]));
	if (connect(sock, (struct sockaddr *)&server, sizeof (server)) < 0) {
		(void) close(sock);
		perror("connect");
		exit(1);
	}

	FD_ZERO(&mask);
	FD_SET(sock, &mask);
	FD_SET(fileno(stdin), &mask);
	for (;;) {
		rmask = mask;
		nfound = select(FD_SETSIZE, &rmask, (fd_set *)0, (fd_set *)0, &timeout);
		if (nfound < 0) {
			/* something is very wrong! */
			perror("select");
			exit(1);
		}
		if (FD_ISSET(fileno(stdin), &rmask)) {
			/* data from keyboard */
			if (!fgets(buf, sizeof (buf) - 1, stdin)) {
				if (ferror(stdin)) {
					perror("stdin");
					exit(1);
				}
				exit(0);
			}
			if (write(sock, buf, strlen(buf)) < 0) {
				perror("write");
				exit(1);
			}
		}
		if (FD_ISSET(sock, &rmask)) {
			/* data from network */
			bytesread = read(sock, buf, sizeof (buf) - 1);
			if ( bytesread == 0) {
				perror("close connection");
				exit(1);
			}
			buf[bytesread] = '\0';
			printf("%s: got %d bytes: %s\n", argv[0], bytesread, buf);
		}
	}
}

3. 동작 모습

6. 소켓 관련 함수

1. 테스트 코드

1. functest.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <ctype.h>

#include <netinet/tcp.h>
#include <errno.h> 


// getsockopt test
int getsockopttest(int sockfd) {
    int optnames[128] = {
	    SO_ACCEPTCONN, SO_BROADCAST, SO_DEBUG, SO_ERROR, SO_KEEPALIVE,
	    SO_LINGER, SO_OOBINLINE, SO_RCVBUF, SO_REUSEADDR, SO_REUSEPORT, 
	    SO_SNDBUF, SO_TYPE, SO_PROTOCOL, TCP_NODELAY, SO_DOMAIN,
            SO_DONTROUTE, -1
    };

    int optval = 0;
    int i = 0;
    socklen_t len = sizeof(optval);

    printf("Socket : %d\n", sockfd);
    for (i = 0; i < 100; i++) {
        if(optnames[i] == -1) 
            break;
        optval = 0;
        len = sizeof(optval);
	//if (getsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &keepalive, &len) == -1) {
        if (getsockopt(sockfd, SOL_SOCKET, optnames[i], &optval, &len) == -1) {
            printf("%d: error %d\n", i, errno);
        } else {
            printf("%d: %d\n", i, optval);
	}
    }

    return 0;
}

// setsockopt test
int setsockopttest(int sockfd) {

	int keepalive = 1;
	socklen_t len = sizeof(keepalive);
	if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &keepalive, len) == -1) {
		perror("setsockopt failed");
		exit(EXIT_FAILURE);
	}

	int reuse = 1;
	len = sizeof(reuse);
	if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, len) == -1) {
		perror("setsockopt failed");
		exit(EXIT_FAILURE);
	}
	if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, &reuse, len) == -1) {
		perror("setsockopt failed");
		exit(EXIT_FAILURE);
	}

	return 0;
}

// address related functions
int addresstest(struct sockaddr_in *addr) {
    int val = 0;
    in_addr_t t;
    char *ipaddr = "10.4.2.1";
    char ipaddr2[100];
    struct in_addr inp;

    printf("host %s, port %d\n", inet_ntoa(addr->sin_addr), ntohs(addr->sin_port));

    val = inet_aton(ipaddr, &inp);
    printf("%08x %d\n", ntohl(inp.s_addr), val);

    t = inet_addr(ipaddr);
    printf("%08X %s\n", t, ipaddr);
    t = inet_network(ipaddr);
    printf("%08X %s\n", t, ipaddr);

    printf("inet_ntoa %s\n", inet_ntoa(inp));

    printf("inet_lnaof %08X\n", inet_lnaof(inp));
    printf("inet_netof %08X\n", inet_netof(inp));

    inp = inet_makeaddr(10, 4 << 16 | 2 << 8 | 2);
    printf("inet_makeaddr %s\n", inet_ntoa(inp));

    printf("inet_lnaof %08X\n", inet_lnaof(inp));
    printf("inet_netof %08X\n", inet_netof(inp));

    memset(&inp, 0, sizeof(inp));
    inet_pton(AF_INET, ipaddr, &inp);
    printf("inet_pton %s %08X \n", ipaddr, inp.s_addr);

}

int main(int argc, char *argv[]) {
	struct sockaddr_in server, remote;
	int request_sock, new_sock;
	int bytesread, addrlen;
	int i, ret;
	char buf[BUFSIZ];
	if (argc != 3) {
		(void) fprintf(stderr,"usage: %s IP port\n", argv[0]);
		exit(1);
	}
	if ((request_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
		perror("socket");
		exit(1);
	}

	memset((void *) &server, 0, sizeof (server));
	server.sin_family = AF_INET;
	//server.sin_addr.s_addr = INADDR_ANY;
        inet_aton(argv[1], &server.sin_addr);
	server.sin_port = htons((u_short)atoi(argv[2]));

        setsockopttest(request_sock);
	if (bind(request_sock, (struct sockaddr *)&server, sizeof (server)) < 0) {
		perror("bind");
		exit(1);
	}
	if (listen(request_sock, SOMAXCONN) < 0) {
		perror("listen");
		exit(1);
	}
	addresstest(&server);
        getsockopttest(request_sock);
	for (;;) {
		addrlen = sizeof(remote);
		new_sock = accept(request_sock, (struct sockaddr *)&remote, (socklen_t *)&addrlen);
		if (new_sock < 0) {
			exit(1);
		}
		printf("connection from host %s, port %d, socket %d\n",
			inet_ntoa(remote.sin_addr), ntohs(remote.sin_port), new_sock);
                getsockopttest(request_sock);
                getsockopttest(new_sock);

	}
}

2. 출력

7. 파이썬을 이용한 소켓 프로그래밍

1. TCP

1. TCP Server

tcpsrv.py

from socket import *

serverPort = 12000
serverSocket = socket(AF_INET,SOCK_STREAM)
serverSocket.bind(('',serverPort))

serverSocket.listen(1)
print ('The server is ready to receive')

while True:
	connectionSocket, addr = serverSocket.accept()
	print (addr)
	sentence = connectionSocket.recv(1024).decode()
	print(sentence)
	capitalizedSentence = sentence.upper()
	connectionSocket.send(capitalizedSentence.encode())
	connectionSocket.close()

2. TCP Client

tcpcli.py

from socket import *

serverName = 'localhost'
serverPort = 12000
clientSocket = socket(AF_INET, SOCK_STREAM)

clientSocket.connect((serverName,serverPort))

sentence = input('Input lowercase sentence:')
clientSocket.send(sentence.encode())

modifiedSentence = clientSocket.recv(1024)
print ('From Server:', modifiedSentence.decode())

clientSocket.close()

2. UDP

1. UDP Server

udpsrv.py

from socket import *
serverPort = 12000
serverSocket = socket(AF_INET, SOCK_DGRAM)
serverSocket.bind(('', serverPort))
print ("The server is ready to receive")
while True:
    message, clientAddress = serverSocket.recvfrom(2048)
    print(message.decode())
    print(clientAddress)
    modifiedMessage = message.decode().upper()
    serverSocket.sendto(modifiedMessage.encode(), clientAddress)

2. UDP Client

udpcli.py

from socket import *
serverName = 'localhost'
serverPort = 12000
clientSocket = socket(AF_INET, SOCK_DGRAM)
message = input('Input lowercase sentence:')
clientSocket.sendto(message.encode(),(serverName, serverPort))
modifiedMessage, serverAddress = clientSocket.recvfrom(2048)
print (modifiedMessage.decode())
clientSocket.close()