TCP IP - Leo-Mun/UROP_SDN GitHub Wiki
- ์ปดํจํฐ ๋คํธ์ํฌ๋ฅผ ๊ฒฝ์ ํ๋ ํ๋ก์ธ์ค ๊ฐ ํต์ ์ ์ข ์ฐฉ์ , ํ๋์ ๋๋ถ๋ถ ์ธํฐ๋ท ํ๋กํ ์ฝ์ ์ฌ์ฉํจ์ผ๋ก '์ธํฐ๋ท ์์ผ'์ด๋ผ ํ ์ ์์
- ๊ตฌ์ฑ์์
- ๋ก์ปฌ IP์ฃผ์ (์์ ์ IP์ฃผ์)
- ๋ก์ปฌ ํฌํธ (์์ ์ ํฌํธ๋ฒํธ)
- ์๊ฒฉ IP ์ฃผ์ (์๋๋ฐฉ์ IP์ฃผ์)
- ์๊ฒฉ ํฌํธ (์๋๋ฐฉ์ ํฌํธ๋ฒํธ)
์ธํฐ๋ท ์์ผ์ ํฌ๊ฒ TCP(์ฐ๊ฒฐ์งํฅํ, Stream), UDP(๋น ์ฐ๊ฒฐ์งํฅํ, ๋ฐ์ดํฐ๊ทธ๋จ ์๋น์ค)๋ก ๊ตฌ๋ณ
- ์ฐ๊ฒฐ์งํฅํ
- ์ ์ก ์ค๊ฐ์ ๋ฐ์ดํฐ์ ์๋ฉธ ์์ด ์๋๋ฐฉ์๊ฒ ์ ์ก
- ์ ์ก๋ ์์๋๋ก ์๋๋ฐฉ์๊ฒ ์ ์ก
- ์ ์ก๋ ๋ฐ์ดํฐ์ ๊ฒฝ๊ณ๊ฐ ์์ -> ํธ์ถ๋ read(), write() ์ ํ์๊ฐ ์๊ด์์.
- ์์ผ : ์์ผ ์ ์ฐ๊ฒฐ์ ๋ฐ๋์ 1๋1 ์ด์ด์ผํจ
- ์ ๋ขฐ์ฑ์ด ์๋ ์์ฐจ์ ๋ฐ์ดํธ๊ธฐ๋ฐ์ ์ฐ๊ฒฐ์งํฅ ๋ฐ์ดํฐ ์ ์ก๋ฐฉ์์ ์์ผ
- ๋น ์ฐ๊ฒฐ์งํฅํ
- ์ ์ก๋ ์์๋ณด๋ค๋ ๊ฐ์ฅ ๋น ๋ฅธ ์ ์ก์ ์งํฅ (์๋์ฐ์ )
- ์ ์ก์ค ๋ฐ์ดํฐ์ ์์ค ๊ฐ๋ฅ์ฑ์ด ์กด์ฌ (ํ์ or ์๋ฉธ)
- ๋ฐ์ดํฐ์ ๊ฒฝ๊ณ๊ฐ ์กด์ฌ
- ํ ๋ฒ์ ์ ์กํ ์ ์๋ ๋ฐ์ดํฐ ์ ํ์ด ์์
- ์ ๋ขฐ์ฑ, ์์ฐจ์ ๋ฐ์ดํฐ ์ ์ก์ ๋ณด์ฅํ์ง ์๊ณ ๊ณ ์์ ๋ฐ์ดํฐ ์ ์ก์ ๋ชฉ์ ์ผ๋ก ํ๋ ์์ผ
- ์ฃผ์์ฒด๊ณ(ํ๋กํ ์ฝ)์ ๋ํ ์ ๋ณด์ ๋ฌ
- AF_INET : IPv4 ์ธํฐ๋ท ํ๋กํ ์ฝ ์ฃผ์์ฒด๊ณ
- AF_INET6 : IPv6 ์ธํฐ๋ท ํ๋กํ ์ฝ ์ฃผ์์ฒด๊ณ
- AF_LOCAL : ๋ก์ปฌ ํต์ ๋ชฉ์ ์ ์ ๋์ค ํ๋กํ ์ฝ ์ฒด๊ณ
- ์์ผ ํ์
์ ๋ณด์ ๋ฌ
- SOCK_STREAM (TCP)
- SOCK_DGRAM (UDP)
- ํ๋กํ ์ฝ์ ์ต์ข
์ ํ
- ๋์ผํ ํ๋กํ ์ฝ ์ฒด๊ณ์์ ๋ฐ์ดํฐ ์ ์ก๋ฐฉ์์ ์์ด์ ๋์ผํ ํ๋กํ ์ฝ์ด 2๊ฐ ์ด์์ด ์์ ์ ์์ผ๋ฏ๋ก ๋ช ์ํด์ค์ผ ํจ
-
์ธํฐ๋ท ์ฃผ์
- ์ธํฐ๋ท ์ฌ์ฉ์ ์ํด์ IP๊ฐ ํ์ํ๊ณ , ์ด๋ฌํ IP์ฃผ์์ฒด๊ณ์ 2๊ฐ์ง ์กด์ฌ (IPv4, IPv6)
- ๋์ ์ฐจ์ด๋ ์ฃผ์ ํํ์ ์ฌ์ฉ ๋๋ ๋ฐ์ดํธ์. (๋ฒ์ฉ์ ์ผ๋ก ์ฌ์ฉ ๋๋ ์ฃผ์์ฒด๊ณ๋ IPv4)
- ๋คํธ์ํฌ์ฃผ์, ํธ์คํธ์ฃผ์๋ก ๋ถ๋ฅ. ์ด ๋ ์ฃผ์์ ํํ์ ๋ฐ๋ผ 4๊ฐ์ ํด๋์ค๋ก ๋๋ ์ ์์ (Eํด๋์ค๋ ์์ฝ ํด๋์ค)
- A : 8-bit network ID, 24-bit host ID
- B : 16-bit network ID, 16-bit host ID
- C : 24-bit network ID, 8-bit host ID
- D : Multicast applications
-
Port ๋ฒํธ
- ํ๋์ ์ด์์ฒด์ ๋ด์์ ์์ผ์ ๊ตฌ๋ถํ๋ ๋ชฉ์ ์ผ๋ก ์ฌ์ฉ, ๊ทธ๋ฌ๋ฏ๋ก ํ๋์ ์ด์์ฒด์ ์์ ๋์ผํ port๋ฒํธ๋ฅผ ๋ฅ ์ด์ ํ ๋น ํ ์ ์๋ค.
- ํํ ๋ฒ์๋ 0์ด์ 65535์ดํ (16-bit) ๋จ, 0-1023 ์ Well-known PORT ๋ผ์ ์ธ ์ ์์?( ์ ์๋ ค์ง ํฌํธ(well-known port)๋ ํน์ ํ ์ฐ์์๋ฅผ ์ํด์ IANA์์ ํ ๋นํ TCP ๋ฐ UDP ํฌํธ ๋ฒํธ์ ์ผ๋ถ์ด๋ค. ์ด ๋ฒํธ๋ ๊ฐ์ ์ ์ผ๋ก ์ง์ ๋ ๊ฒ์ ์๋๋ฉฐ, IANA์ ๊ถ๊ณ ์์ผ ๋ฟ์ด๋ค. ๊ฐ๋ ๊ฐ ํฌํธ ๋ฒํธ๋ฅผ ๊ทธ๋๋ก ์ฌ์ฉํ์ง ์๊ณ ๋ค๋ฅธ ์ฉ๋๋ก ์ฌ์ฉํ๊ธฐ๋ ํ๋ค. ์ด ๊ฒฝ์ฐ, ํธ๋ก์ด ๋ชฉ๋ง์ ๊ฐ์ ํ๋ก๊ทธ๋จ๋ค์ด ์ ์์ ์ธ ๋ชฉ์ ์ผ๋ก ํฌํธ๋ฅผ ๋ณ๊ฒฝํ์ฌ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๋ ์๋ค.) .
- ํ๋์ ์ด์์ฒด์ ๋ด์์ ๋์ผํ ํฌํธ๋ฒํธ๋ฅผ ํ ๋นํ ์ ์์ง๋ง TCP, UDP์์ผ์๋ ๋์ผํ ํฌํธ๋ฒํธ๋ฅผ ํ ๋นํ ์ ์๋ค.
- ๋ฐ์ดํฐ ์ ์ก์ ๋ชฉ์ ์ง ์ฃผ์์๋ IP์ฃผ์์ ํฌํธ๋ฒํธ๊ฐ ์์ด์ผ ๋จ
IPv4์ ์ฃผ์์ฒด๊ณ๋ฅผ ํํํ๊ธฐ ์ํด 'sockaddr_in'๊ตฌ์กฐ์ฒด๋ฅผ ์ฌ์ฉ
struct sockaddr_in
{
sa_family_t sin_family;
unit16_t sin_port;
struct in_addr sin_addr;
char siz_zero[8];
}
struct in_addr
{
in_addr_t s_addr; // IPv4 address (32-bit)
}
- sin_family
- ์ฃผ์์ฒด๊ณ๋ฅผ ์๋ฏธ
- ์ข ๋ฅ๋ก๋ AF_INET(IPv4 ํ๋กํ ์ฝ), AF_INET6(IPv6 ํ๋กํ ์ฝ), AF_LOCAL(Localํต์ ์ ๋์ค ํ๋กํ ์ฝ) ์ด ์กด์ฌ
- sin_port
- 16๋นํธ Port๋ฒํธ๋ฅผ ๋คํธ์ํฌ ๋ฐ์ดํธ ์์๋ก ์ ์ฅ
- sin_addr
- 32๋นํธ์ IP์ฃผ์๋ฅผ ๋คํธ์ํฌ ๋ฐ์ดํธ ์์๋ก ์ ์ฅ
- sin_zero
- sockaddr_in๊ณผ sockaddr์ ํฌ๊ธฐ๋ฅผ ์ผ์น์ํค๊ธฐ ์ํด ์ฝ์ ๋ ๋ฉค๋ฒ.
- ํน๋ณํ ์๋ฏธ๋ ์์ง๋ง ๊ณต๊ฐ์ ์ฑ์ธ๋ ๋ฐ๋์ 0์ผ๋ก ์ฑ์์ผ ํจ.
struct sockaddr
{
sa_family_t sin_family; // ์ฃผ์์ฒด๊ณ
char sa_data[14]; // ์ด๊ณณ์ IP์ฃผ์, Port ๋ฒํธ๊ฐ ํฌํจ๋์ด์๋ค.
}
๊ฐ ๋ฉค๋ฒ์ ๋ง๋ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ ํ, ๋จ๋ ๋ถ๋ถ์ 0์ผ๋ก ์ฑ์์ sockaddr_in๊ณผ sockaddr์ ํฌ๊ธฐ๋ฅผ ๋์ผํ๊ฒ ๋ง์ถฐ์ค๋ค.
- ํํ ์๊ณ ์๋ "xxx.xxx.xxx.xxx"๋ ์ญ์ง์ ํํ๋ฐฉ์(Dotted-Decimal Notation). ํ์ง๋ง ์ปดํจํฐ๋ ์ด๊ฒ์ ํ๋์ ์ ์๋ก ๋ํ๋ด์ค์ผํ๋ค.
-
inet_addr()
in_addr_t inet_addr(const char *string);
๋ฐํ๊ฐ์ผ๋ก๋ ๋ณํ์ ์ฑ๊ณต์ ๋คํธ์ํฌ ๋ฐ์ดํธ ์์(๋น ์๋์)์ผ๋ก ๋ณํ๋ 32๋นํธ์ ์ ์๊ฐ, ์คํจ ์ INADDR_NONE ๊ฐ ๋ฐํ ๋จ
-
inet_aton()
int inet_aton(const char *string, struct in_addr *addr);
string : ๋ณํํ IP์ฃผ์ ์ ๋ณด๋ฅผ ๋ด๊ณ ์๋ ๋ฌธ์์ด
aadr : ๋ณํ๋ ์ ๋ณด๋ฅผ ์ ์ฅํ in_addr ๊ตฌ์กฐ์ฒด ๋ณ์
๋ฐํ๊ฐ์ผ๋ก๋ ์ฑ๊ณต์ 1, ์คํจ ์ 0 ์ ๋ฐํํ๋ค.
inet_addr()๊ณผ ์ฐจ์ด๋ in_addr ๊ตฌ์กฐ์ฒด ๋ณ์๋ฅผ ์ฌ์ฉํ๋ค๋ ์ ์ด๋ค.
-
inet_ntoa()
char *inet_ntoa(struct in_addr adr);
์ธ์๋ก ์ ๋ฌ๋ ์ ์ํํ์ IP์ฃผ์๊ฐ์ ๋ฌธ์์ด ํํ์ IP์ฃผ์ ์ ๋ณด๋ก ๋ณํํ์ฌ ๋ฐํํ๋ ํจ์. ๋ฐํ๊ฐ์ผ๋ก๋ ์ฑ๊ณต์ ๋ณํ๋ ๋ฌธ์์ด์ ์ฃผ์๊ฐ, ์คํจ ์ -1 ๊ฐ ๋ฐํ.
- ๋ฐ์ดํฐ ์ก์์ ๊ณผ์ ์ 4๋จ๊ณ๋ก ๊ณ์ธตํ.
- ์ด๋ฅผ ํตํด ์ป์ ์ ์๋ ์ด์ ์ด ์ฌ๋ฌ๊ฐ์ง ์์.
- ํ๋กํ ์ฝ ์ค๊ณ์ ์ฉ์ด์ฑ
- ํ์คํ ์์ ์ ํตํ ๊ฐ๋ฐฉํ ์์คํ ์ค๊ณ (ex. ๋์นด๋๊ฐ ์๋ค๋ฉด ์๋ฌด ๋์นด๋๋ฅผ ์ฌ์ ๊ฝ์ผ๋ฉด ๋จ)
- Link ๊ณ์ธต
- ๋ฌผ๋ฆฌ์ ์ธ ์์ญ์ผ๋ก LAN, WAN, MAN ์ด ์ํ๋ ์์ญ
- IP๊ณ์ธต
- ๋ชฉ์ ์ง๋ก ๋ฐ์ดํฐ๋ฅผ ์ ๋ฌ์ ๊ฒฝ๋ก๋ฅผ ์ ํํ๋ ๊ณ์ธต. ์ด ์์ญ์์ ์ฌ์ฉํ๋ ํ๋กํ ์ฝ์ด IP(Internet Protocol).
- IP ์์ฒด๋ ๋น ์ฐ๊ฒฐ ์งํฅ์ฑ์ด๋ผ ๋ฌด์กฐ๊ฑด ์ ๋ขฐํ ์๋ ์๋ค.
- TCP/IP ๊ณ์ธต
- ๊ฒฝ๋ก๋ ์ด๋ฏธ IP๊ณ์ธต์์ ์ค์ , ์ค์ ๋ฐ์ดํฐ๋ฅผ ์ ์กํ๋ ๊ณ์ธต์ด๋ค. ๋ฐฉ๋ฒ์ ํฌ๊ฒ TCP, UDP๋ก ๊ตฌ๋ณ.
- TCP์ ๊ธฐ๋ฐ์ IP๊ฐ ๋๊ณ , IP์์ฒด๊ฐ 1๊ฐ์ ํจํท์ ์ ์กํ๋ ๊ฒฝ๋ก์๋ง ์ง์ค. -> ์ฌ๋ฌ๊ฐ๋ฅผ ์ ์กํด๋ ๋ชจ๋ ๊ฒฝ๋ก๊ฐ ๊ฐ์ง์๊ณ ์์๋ ๋ณด์ฅํ ์ ์์.
- ์ด๋ฌํ IP์ TCP๊ฐ ์ถ๊ฐ๋๋ฉด ๋ฐ์ดํฐ์ ์ก์์ ์ ์์ค๋๋ data๋ฅผ ๊ฒ์ฌ. ์ด๋ก์จ ์ ์ก๋๋ data๊ฐ ๋ณด์ฅ์ด ๋๋ค.
- Application ๊ณ์ธต
- ํ๋ก๊ทธ๋จ์ ์ฑ๊ฒฉ์ ๋ฐ๋ผ server, client๋ก ๊ตฌ๋ณ, ์ด ๋ ๊ท์ฝ(Protocol)์ด ์์ฑ.
- ๋๋ถ๋ถ์ ๋คํธ์ํฌ ํ๋ก๊ทธ๋๋ฐ์ด ์ํ๋ค.
- ๊ฐ ๊ณ์ธต์ ๋ด๋นํ๋ ๊ฒ์ด SW ์ผ์๋ ์๊ณ (SDN), NIC์ ๊ฐ์ ๋ฌผ๋ฆฌ์ ์ฅ์น์ผ ์ ์๋ค.(์ ํต์ ์ธ ๋คํธ์ํฌ ๊ตฌ์ฑ๋ฐฉ์)
1. socket()
-
์์ผ ์์ฑ์ ์ฌ์ฉ ๋๋ ํจ์
int socket(int domain, int type, int protocol);
domain : ์์ผ์ด ์ฌ์ฉํ ํ๋กํ ์ฝ ์ฒด๊ณ ์ ๋ณด.
type : ์์ผ์ ๋ฐ์ดํฐ ์ ์ก๋ฐฉ์์ ๋ํ ์ ๋ณด.
protocol : ๋๋ฐ์ด์ค๊ฐ ํต์ ์ ์ฌ์ฉ ๋๋ ํ๋กํ ์ฝ ์ ๋ณด.
2. bind()
-
์ด๊ธฐํ๋ ์ฃผ์์ ๋ณด๋ฅผ ์์ผ์๊ฒ ํ ๋นํ๋ ํจ์.
int bind(int sockfd, struct sockaddr *myaddr, socklen_t addrlen);
sockfd : ์ฃผ์์ ๋ณด๋ฅผ ํ ๋นํ ์์ผ์ ํ์ผ ๋์คํฌ๋ฆฝํฐ
myaddr : ํ ๋นํ๊ณ ์ ํ๋ ์ฃผ์์ ๋ณด๋ฅผ ์ง๋ ๊ตฌ์กฐ์ฒด ๋ณ์
addrlen : 2๋ฒ์งธ ์ธ์์ ๊ธธ์ด์ ๋ณด
3. listen()
-
ํด๋ผ์ด์ธํธ๊ฐ ์ฐ๊ฒฐ์์ฒญ์ ํ ์ ์๋ '์ฐ๊ฒฐ์์ฒญ ๋๊ธฐ์ํ'๊ฐ ๋๋ ํจ์.
int listen(int sock, int backlog);
sock : ์ฐ๊ฒฐ ๋๊ธฐ์ํ์ ๋๊ณ ์ ํ๋ ์์ผ์ ํ์ผ ๋์คํฌ๋ฆฝํฐ.
backlog : ์ฐ๊ฒฐ์์ฒญ ๋๊ธฐ ํ์ ํฌ๊ธฐ์ ๋ณด.
4. accept()
-
๋๊ธฐ ํ์์ ๋๊ธฐ์ค์ธ ํด๋ผ์ด์ธํธ์ ์์ฒญ์ ์๋ฝํ๋ ๊ธฐ๋ฅ์ ํจ์.
int accept(int sock, struct sockaddr *addr, socklen_t *addrlen);
sock : ์๋ฒ ์์ผ์ ํ์ผ ๋์คํฌ๋ฆฝํฐ.
addr : ์ฐ๊ฒฐ์์ฒญํ ํด๋ผ์ด์ธํธ์ ์ฃผ์์ ๋ณด๋ฅผ ๋ด์ ๋ณ์, ์๋ฃ ์ ํด๋ผ์ด์ธํธ ์์ผ์ ์ฃผ์์ ๋ณด๊ฐ ์ฑ์์ง๋ค.
addrlen : ๋ ๋ฒ์งธ ๋งค๊ฐ๋ณ์์ ์ฃผ์์ ๋ณ์ ํฌ๊ธฐ๋ฅผ ๋ฐ์ดํธ ๋จ์๋ก ์ ๋ฌ.
5. connect()
-
ํด๋ผ์ด์ธํธ์์๋ง ์ฌ์ฉ ๋๋ ํจ์๋ก์จ, ์๋ฒ์ ์ฐ๊ฒฐ์์ฒญ์ ๋ชฉ์ ์ผ๋ก ํ๋ ํจ์.
int connect(int sock, sockaddr *servaddr, socklen_t addrlen)
sock : ํด๋ผ์ด์ธํธ ์์ผ ํ์ผ ๋์คํฌ๋ฆฝํฐ. servaddr : ์ฐ๊ฒฐ์์ฒญํ ์๋ฒ์ ์ฃผ์์ ๋ณด๋ฅผ ๋ด์ ๋ณ์. addrlen : 2๋ฒ์งธ ์ธ์์ ์ฃผ์์ ๋ฐ์ดํธ๋จ์ ๊ธธ์ด์ ๋ณด.
๊ฐ๋จํ "Hello World" ์๋ฒ ์์ค์ฝ๋
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
void error_handling(char *message);
int main( int argc, char *argv[])
{
int serv_sock;
int clnt_sock;
struct sockaddr_in serv_addr;
struct sockaddr_in clnt_addr;
socklen_t clnt_addr_size;
char message[] = "Hello Stranger!";
if( argc != 2)
{
printf("Usage : %s <port>\n",argv[0]);
exit(1);
}
serv_sock = socket(PF_INET, SOCK_STREAM, 0); // socket create
if( serv_sock == -1 )
error_handling("socket() error");
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(atoi(argv[1]));
if( bind(serv_sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) == 1) // bind func call
error_handling("bind() error");
if( listen(serv_sock, 20) == -1) // listen func call
error_handling("listen() error");
clnt_addr_size = sizeof(clnt_addr);
clnt_sock = accept( serv_sock, (struct sockaddr*)&clnt_addr, &clnt_addr_size); // accept func call
if( clnt_sock == -1 )
error_handling("accept() error");
write(clnt_sock, message, sizeof(message)); // data trade, if white func call => linking sign exist
close(clnt_sock);
close(serv_sock);
return 0;
}
void error_handling(char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
ํด๋ผ์ด์ธํธ ์์ค์ฝ๋
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
void error_handling(char *message);
int main(int argc, char *argv[])
{
int sock;
struct sockaddr_in serv_addr;
char message[30];
int str_len = 0;
int idx = 0, read_len = 0;
if( argc != 3 )
{
printf("Usage : %s <IP> <port>\n", argv[0]);
exit(1);
}
if( (sock = socket(PF_INET, SOCK_STREAM, 0)) == -1 )
error_handling("Socket() error!");
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
serv_addr.sin_port = htons(atoi(argv[2]));
if( connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1 )
error_handling("connect() error");
if( recv(sock, message, sizeof(message), 0) == -1 )
error_handling("recv() error!");
printf("Message from server : %s \n",message );
close(sock);
return 0;
}
void error_handling(char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
์๋ฒ์ ํด๋ผ์ด์ธํธ์ ํต์ ๊ณผ์ ์ ์๋์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ํํํ ์ ์๋ค.
- send(), recv()์ read(), write()์ ์ฐจ์ด
- send(), recv()๋ ํต์ ์ ์ข ๋ ํนํ๋ ํจ์๋ก์จ socket lib์ ์ ์ธ๋์ด ์๋ค.
- read(), write()๋ ๋ค์ํ ๊ณณ์์ ์ฌ์ฉ ๋๋ ๋ฒ์ฉ์ ์ธ ํจ์๋ก์จ ์ฌ์ฉ ์ OS๊ฐ ์ง์ ์ฒ๋ฆฌ๋ฅผ ํด์ค ์ ๋ ์๋ค.
- ํฐ ์ฐจ์ด์ ์ค ํ๋๋ flag๋ฅผ ์ฌ์ฉํ ํ์๊ฐ ์๋ค๋ฉด send(), recv() ์ฌ์ฉ์ ํด์ผ ํ๋ค๋ฉด read(), write()๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค.