6 장과제샘플코드 - 다자간채팅 (udp 버전 1) 목포해양대해양컴퓨터공학과

Size: px

Start display at page:

Download "6 장과제샘플코드 - 다자간채팅 (udp 버전 1) 목포해양대해양컴퓨터공학과"

Ronald Thornton
5 years ago
Views:

1 6 장과제샘플코드 - 다자간채팅 (udp 버전 1)

2 과제 서버에서먼저 bind 하고그포트를다른사람에게알려줄것 클라이언트들은알려준포트로접속 서버는클라이언트로부터받은메시지를다른클라이언트들에게전달 2

3 Makefile 1 SRC_DIR =../../common 2 COM_OBJS = $(SRC_DIR)/addressUtility.o $(SRC_DIR)/dieWithMessage.o umcprotocol.o 3 SRV_OBJS = umcserver.o umcserverprocess.o 4 CLI_OBJS = umcclient.o umcclientprocess.o 5 6 CFLAGS = -g -std=gnu99 7 CC = gcc 8 9 all: 10 make umcserver 11 make umcclient umcserver : $(COM_OBJS) $(SRV_OBJS) 14 gcc -o umcserver $(CFLAGS) $(COM_OBJS) $(SRV_OBJS) umcclient : $(COM_OBJS) $(CLI_OBJS) 17 gcc -o umcclient $(CFLAGS) $(COM_OBJS) $(CLI_OBJS) install : 20 mv umcserver umcclient ~/bin clean : 23 rm *.o umcserver umcclient 3

4 umcprotocol.h (1) 1 #ifndef UMC_PROTOCOL_H_ 2 #define UMC_PROTOCOL_H_ 3 4 #include <stdint.h> 5 #include <unistd.h> 6 7 enum { 8 MAX_WIRE_SIZE = 512, 9 MAX_MSG_SIZE = 500, 10 MAX_SILENT_TIME = }; typedef enum { 14 JOIN_REQ = 1, 15 JOIN_ACK = 2, 16 DATA_REQ = 3, 17 DATA_ACK = 4, 18 MESSAGE = 5, 19 CHK_REQ = 6, 20 CHK_ACK = 7, 21 LEAVE_REQ = 8, 22 LEAVE_ACK = 9, 23 ERROR = } f_code_t; 25 4

5 umcprotocol.h (2) 26 typedef struct { 27 uint32_t msg_size; 28 uint8_t msg_data[max_msg_size]; 29 } msg_t; typedef struct { 32 f_code_t fcode; 33 msg_t message; 34 } mcht_t; #define MAGIC_NUMBER 0x typedef struct { 40 uint32_t magic_no; 41 uint32_t fcode; 42 msg_t message; 43 } mcht_pdu_t; int mk_pdu(const mcht_t *mcht_ptr, mcht_pdu_t *pdu_ptr); 47 int parse_pdu(const mcht_pdu_t *pdu_ptr, mcht_t *mcht_ptr); 48 #endif 5

6 umcprotocol.c (1) 1 #include "umcprotocol.h" 2 3 #include <stdio.h> 4 #include <string.h> 5 #include <arpa/inet.h> 6 7 /******************************************************************************/ 8 int mk_pdu(const mcht_t *mcht_ptr, mcht_pdu_t *pdu_ptr) 9 { 10 pdu_ptr->magic_no = htonl(magic_number); pdu_ptr->fcode = htonl(mcht_ptr->fcode); 13 if ((mcht_ptr->fcode == JOIN_REQ) 14 (mcht_ptr->fcode == DATA_REQ) 15 (mcht_ptr->fcode == MESSAGE)) { if (mcht_ptr->message.msg_size >= MAX_MSG_SIZE) { 18 fprintf(stderr, "Out of message length limit!\n"); 19 return 0; 20 } 21 pdu_ptr->message.msg_size = htonl(mcht_ptr->message.msg_size); 22 strncpy(pdu_ptr->message.msg_data, 23 mcht_ptr->message.msg_data, 24 mcht_ptr->message.msg_size); 25 } 26 return 1; 27 } 6

7 umcprotocol.c (2) 28 /******************************************************************************/ 29 int parse_pdu(const mcht_pdu_t *pdu_ptr, mcht_t *mcht_ptr) 30 { 31 if (ntohl(pdu_ptr->magic_no)!= MAGIC_NUMBER) { 32 fprintf(stderr, "invalid MAGIC_NUMBER!\n"); 33 return 0; 34 } mcht_ptr->fcode = (f_code_t)ntohl(pdu_ptr->fcode); 37 if ((mcht_ptr->fcode == JOIN_REQ) 38 (mcht_ptr->fcode == DATA_REQ) 39 (mcht_ptr->fcode == MESSAGE)) { 40 mcht_ptr->message.msg_size = ntohl(pdu_ptr->message.msg_size); if (mcht_ptr->message.msg_size >= MAX_MSG_SIZE) { 43 fprintf(stderr, "Out of message length limit!\n"); 44 return 0; 45 } 46 strncpy(mcht_ptr->message.msg_data, 47 pdu_ptr->message.msg_data, 48 mcht_ptr->message.msg_size); 49 } 50 return 1; 51 } 7

8 umcclientprocess.h 1 #ifndef _UMC_CLIENT_PROCESS_H 2 #define _UMC_CLIENT_PROCESS_H 3 4 #define QUIT_STR "QUIT" 5 6 int read_and_sendto(int ifd, int sock, struct sockaddr *toaddr); 7 int recvfrom_and_process(int sock, struct sockaddr *fromaddr, int ofd); 8 int join_request(int sock, struct sockaddr *toaddr, char *nickname); 9 10 #endif 8

9 umcclientprocess.c (1) 1 #include <stdlib.h> 2 #include <string.h> 3 #include <sys/types.h> 4 #include <sys/socket.h> 5 #include <netdb.h> 6 #include "../../common/practical.h" 7 8 #include "umcprotocol.h" 9 #include "umcclientprocess.h" 10 9

10 umcclientprocess.c (2) 11 /******************************************************************************/ 12 int join_request(int sock, struct sockaddr *toaddr, char *nickname) 13 { 14 mcht_t mcht_str = {0}; mcht_str.fcode = JOIN_REQ; 17 strncpy(mcht_str.message.msg_data, nickname, MAX_MSG_SIZE); 18 mcht_str.message.msg_size = strlen(mcht_str.message.msg_data); mcht_pdu_t send_pdu; if (!mk_pdu(&mcht_str, &send_pdu)) { 23 fprintf(stderr, "mk_pdu ERROR!\n"); 24 return 0; 25 } int pdu_size = sizeof(send_pdu); 28 ssize_t numbytessent = sendto(sock, &send_pdu, pdu_size, 0, 29 toaddr, sizeof(*toaddr)); if (numbytessent!= pdu_size) { 32 fprintf(stderr, "sendto ERROR!\n"); 33 return 0; 34 } return 1; 37 } 38 10

11 umcclientprocess.c (3) 39 /******************************************************************************/ 40 int read_and_sendto(int ifd, int sock, struct sockaddr *toaddr) 41 { 42 mcht_t mcht_str = {0}; if (read(ifd, mcht_str.message.msg_data, MAX_MSG_SIZE) <= 0) { 45 fprintf(stderr, "Read ERROR!\n"); 46 return 0; 47 } if (strncmp(mcht_str.message.msg_data, QUIT_STR, strlen(quit_str)) == 0) { 50 mcht_str.fcode = LEAVE_REQ; 51 } 52 else { 53 mcht_str.fcode = DATA_REQ; 54 mcht_str.message.msg_size = strlen(mcht_str.message.msg_data); 55 } 56 11

12 umcclientprocess.c (4) 57 mcht_pdu_t send_pdu; if (!mk_pdu(&mcht_str, &send_pdu)) { 60 fprintf(stderr, "mk_pdu ERROR!\n"); 61 return 0; 62 } int pdu_size = sizeof(send_pdu); 65 ssize_t numbytessent = sendto(sock, &send_pdu, pdu_size, 0, 66 toaddr, sizeof(*toaddr)); if (numbytessent!= pdu_size) { 69 fprintf(stderr, "sendto ERROR!\n"); 70 return 0; 71 } return 1; 74 } 75 12

13 umcclientprocess.c (5) 76 /******************************************************************************/ 77 int recvfrom_and_process(int sock, struct sockaddr *fromaddr, int ofd) 78 { 79 mcht_pdu_t mcht_pdu = {0}; // for receiving int addrlen; 82 ssize_t numbytesrcvd = recvfrom(sock, &mcht_pdu, MAX_WIRE_SIZE, 0, 83 fromaddr, &addrlen); 84 if (numbytesrcvd < 0) 85 return 0; mcht_t mcht_str = {0}; 88 mcht_t new_mcht_str = {0}; if (!parse_pdu(&mcht_pdu, &mcht_str)) { 91 fprintf(stderr, "parse_pdu ERROR!\n"); 92 return 0; 93 } char msgbuf[max_msg_size] = {0}; 13

14 umcclientprocess.c (6) 97 switch(mcht_str.fcode) { 98 case JOIN_ACK: 99 sprintf(msgbuf, " 연결되었습니다.\n"); if (write(ofd, msgbuf, MAX_MSG_SIZE) <= 0) { 102 fprintf(stderr, "Write ERROR!\n"); 103 return 0; 104 } 105 break; case LEAVE_ACK: 108 sprintf(msgbuf, " 탈퇴하였습니다.\n"); if (write(ofd, msgbuf, MAX_MSG_SIZE) <= 0) { 111 fprintf(stderr, "Write ERROR!\n"); 112 return 0; 113 } 114 DieWithSystemMessage(" 정상종료합니다.\n"); 115 break; 116 case DATA_ACK: // do nothing 117 break; 14

15 umcclientprocess.c (7) 124 case CHK_REQ: 125 new_mcht_str.fcode = CHK_ACK; mcht_pdu_t send_pdu; 128 if (!mk_pdu(&new_mcht_str, &send_pdu)) { 129 fprintf(stderr, "mk_pdu ERROR!\n"); 130 return 0; 131 } 132 int pdu_size = sizeof(send_pdu); 133 ssize_t numbytessent = sendto(sock, &send_pdu, pdu_size, 0, 134 fromaddr, sizeof(*fromaddr)); if (numbytessent!= pdu_size) { 137 fprintf(stderr, "sendto ERROR!\n"); 138 return 0; 139 } 140 break; 141 default: // others : JOIN_REQ, DATA_REQ, CHK_ACK, LEAVE_REQ 142 fprintf(stderr, "invalid fcode!\n"); 143 return 0; 144 } return 1; 147 } 15

16 umcclient.c (1) 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 #include <unistd.h> 5 #include <sys/socket.h> 6 #include <netdb.h> 7 #include "../../common/practical.h" 8 #include "umcprotocol.h" 9 #include "umcclientprocess.h" /******************************************************************************/ 12 int main(int argc, char *argv[]) { if (argc!= 4 ) // 명령어행인자의개수가알맞은지확인 15 DieWithUserMessage("Parameter(s)", 16 "<Server Address/Name> <Server Port/Service> <nickname>"); char *server = argv[1]; // 첫번쨰인자 : 서버의주소 / 이름 19 char *servport = argv[2]; // 두번째인자 : 서버포트 / 서비스이름 20 char *nickname = argv[3]; // 세번째인자 : 별명 21 16

17 umcclient.c (2) 22 // 어떤형태의주소를원하는지시스템에알림 23 struct addrinfo addrcriteria; // 원하는주소기준설정 24 memset(&addrcriteria, 0, sizeof(addrcriteria)); // 구조체를 0으로초기화 25 addrcriteria.ai_family = AF_UNSPEC; // IPV4,IPV6 모두반환 26 addrcriteria.ai_socktype = SOCK_DGRAM; // 데이터그램소켓만반환 27 addrcriteria.ai_protocol = IPPROTO_UDP; // UDP만반환 // 주소들획득 struct addrinfo *addr; 32 struct addrinfo *servaddr; // 서버주소의리스트 int rtnval = getaddrinfo(server, servport, &addrcriteria, &servaddr); 35 if (rtnval!= 0) 36 DieWithUserMessage("getaddrinfo() failed", gai_strerror(rtnval)); int sock = -1; 39 for (addr = servaddr; addr!= NULL; addr = addr->ai_next) { 40 // 데이터그램 UDP소켓생성 41 sock = socket(addr->ai_family, addr->ai_socktype, 42 addr->ai_protocol); // 클라이언트소켓식별자 43 if (sock > 0) 44 break; 45 } join_request(sock, addr->ai_addr, nickname); 17

18 umcclient.c (3) 49 fd_set master_set, read_set; FD_ZERO(&master_set); 52 FD_SET(0, &master_set); 53 FD_SET(sock, &master_set); while(read_set = master_set, select(sock+1, &read_set, NULL, NULL, NULL) > 0) { 56 if (FD_ISSET(0, &read_set)) { 57 if (!read_and_sendto(0, sock, addr->ai_addr)) 58 DieWithSystemMessage("sendto() failed"); 59 } if (FD_ISSET(sock, &read_set)) { 62 struct sockaddr_storage fromaddr; if (!recvfrom_and_process(sock, (struct sockaddr *) &fromaddr, 1)) { 65 DieWithSystemMessage("recvfrom() failed"); 66 } 67 } 68 } freeaddrinfo(servaddr); 71 close(sock); exit(0); 74 } 18

19 umcserverprocess.h 1 #ifndef _UMC_SERVER_PROCESS_H 2 #define _UMC_SERVER_PROCESS_H 3 4 #include <time.h> 5 6 #define MAX_IDLE_TIME 60 7 #define MAX_NAME_SIZE typedef struct _clnt_record { 10 uint8_t nickname[max_name_size]; 11 struct sockaddr clnt_addr; 12 time_t last_atime; 13 struct _clnt_record *next; 14 } clnt_record_t; int recvfrom_and_serve(int sockfd, struct sockaddr *fromaddr, socklen_t addrlen, 17 clnt_record_t **hd_ptr); 18 int join_process(mcht_t *mcht_str, struct sockaddr *fromaddr, clnt_record_t **hd_ptr) ; 19 int leave_process(struct sockaddr *fromaddr, clnt_record_t **hd_ptr); 20 int data_process(int sockfd, mcht_t *mcht_str, struct sockaddr *fromaddr, i 21 clnt_record_t *hd_ptr); 22 int chk_alive(int sock, clnt_record_t *hd_ptr); 23 int update_client_status(struct sockaddr *fromaddr, clnt_record_t *hd_ptr); 24 int prnt_clnt_list(clnt_record_t *hd_ptr); #endif 19

20 umcserverprocess.c (1) 1 #include <stdlib.h> 2 #include <string.h> 3 #include <sys/types.h> 4 #include <sys/socket.h> 5 #include <netdb.h> 6 #include <time.h> 7 8 #include "../../common/practical.h" 9 #include "umcprotocol.h" 10 #include "umcserverprocess.h" /******************************************************************************/ 13 int recvfrom_and_serve(int sockfd, struct sockaddr *fromaddr, socklen_t addrlen, 14 clnt_record_t **hd_ptr) 15 { 16 socklen_t fromaddrlen = addrlen; 17 mcht_pdu_t recv_pdu; ssize_t numbytesrcvd = recvfrom(sockfd, &recv_pdu, sizeof(recv_pdu), 0, 20 fromaddr, &fromaddrlen); 21 if (numbytesrcvd < 0) { 22 fprintf(stderr, "recv_from ERROR!\n"); 23 return 0; 24 } 25 20

21 umcserverprocess.c (2) 26 mcht_t mcht_str = {0}; 27 mcht_t resp_mcht_str = {0}; 28 mcht_pdu_t send_pdu = {0}; if (!parse_pdu(&recv_pdu, &mcht_str)) { 31 fprintf(stderr, "parse_pdu ERROR!\n"); 32 return 0; 33 } // fprintf(stderr, "arrived: %d\n", mcht_str.fcode); 36 prnt_clnt_list(*hd_ptr); if (mcht_str.fcode == CHK_ACK) { 39 update_client_status(fromaddr, *hd_ptr); 40 return 1; 41 } 42 else { if (mcht_str.fcode == JOIN_REQ) { 45 if (join_process(&mcht_str, fromaddr, hd_ptr)) { 46 resp_mcht_str.fcode = JOIN_ACK; 47 } 48 else { 49 resp_mcht_str.fcode = ERROR; 50 } 51 } 21

22 umcserverprocess.c (3) 52 else if (mcht_str.fcode == DATA_REQ) { 53 if (data_process(sockfd, &mcht_str, fromaddr, *hd_ptr)) { 54 resp_mcht_str.fcode = DATA_ACK; 55 } 56 else { 57 resp_mcht_str.fcode = ERROR; 58 } 59 } 60 else if (mcht_str.fcode == LEAVE_REQ) { 61 if (leave_process(fromaddr, hd_ptr)) { 62 resp_mcht_str.fcode = LEAVE_ACK; 63 } 64 else { 65 resp_mcht_str.fcode = ERROR; 66 } 67 } 22

23 umcserverprocess.c (4) 69 if (!mk_pdu(&resp_mcht_str, &send_pdu)){ 70 fprintf(stderr, "mk_pdu ERROR!\n"); 71 return 0; } int pdu_size = sizeof(send_pdu); 76 ssize_t numbytessent = sendto(sockfd, &send_pdu, pdu_size, 0, 77 fromaddr, fromaddrlen); if (numbytessent!= pdu_size) { 80 fprintf(stderr, "sendto ERROR!\n"); 81 return 0; 82 } 83 return 1; 84 } 85 } 23

24 umcserverprocess.c (5) 86 /******************************************************************************/ 87 int join_process(mcht_t *mcht_str, struct sockaddr *fromaddr, clnt_record_t **hd_ptr) 88 { 89 clnt_record_t *new_record = (clnt_record_t *)malloc(sizeof(clnt_record_t)); if (new_record) { 92 strncpy(new_record->nickname, mcht_str->message.msg_data, 93 MAX_NAME_SIZE); 94 memcpy(&new_record->clnt_addr, fromaddr, sizeof(*fromaddr)); 95 new_record->last_atime = time(null); 96 new_record->next = *hd_ptr; 97 *hd_ptr = new_record; 98 } 99 else { 100 fprintf(stderr, "malloc ERROR!\n"); 101 return 0; 102 } return 1; 105 } 24

25 umcserverprocess.c (6) 107 /******************************************************************************/ 108 int leave_process(struct sockaddr *fromaddr, clnt_record_t **hd_ptr) 109 { 110 clnt_record_t *tmp; 111 clnt_record_t *prev = NULL; 112 int found = 0; for (tmp = *hd_ptr;!found && tmp; prev = tmp, tmp = tmp->next) { 115 if (SockAddrsEqual(&tmp->clnt_addr, fromaddr)) { 116 if (prev) 117 prev->next = tmp->next; 118 else // first one 119 *hd_ptr = tmp->next; found = 1; 122 } 123 } if (!found) { 126 fprintf(stderr, "no such client!\n"); 127 return 0; 128 } free(tmp); 131 return 1; 132 } 25

26 umcserverprocess.c (7) 133 /******************************************************************************/ 134 int data_process(int sockfd, mcht_t *mcht_str, struct sockaddr *fromaddr, 135 clnt_record_t *hd_ptr) 136 { 137 mcht_t data; clnt_record_t *tmp; 140 int found = 0; for (tmp = hd_ptr;!found && tmp; tmp = tmp->next) { 143 if (SockAddrsEqual(&tmp->clnt_addr, fromaddr)) { 144 tmp->last_atime = time(null); 145 data.fcode = MESSAGE; 146 sprintf(data.message.msg_data, "%s: ", tmp->nickname); 147 strncat(data.message.msg_data, mcht_str->message.msg_data, 148 MAX_MSG_SIZE); 149 data.message.msg_size = strlen(data.message.msg_data); 150 found = 1; 151 } 152 } if (!found) { 155 fprintf(stderr, "no such client!\n"); 156 return 0; 157 }

27 umcserverprocess.c (8) 159 mcht_pdu_t send_pdu; if (!mk_pdu(&data, &send_pdu)){ 162 fprintf(stderr, "mk_pdu ERROR!\n"); 163 return 0; 164 } 165 for (tmp = hd_ptr; tmp; tmp = tmp->next) { 166 if (SockAddrsEqual(&tmp->clnt_addr, fromaddr)) { 167 continue; 168 } 169 else { 170 int pdu_size = sizeof(send_pdu); 171 ssize_t numbytessent = sendto(sockfd, 172 &send_pdu, pdu_size, 0, 173 &tmp->clnt_addr, sizeof(tmp->clnt_addr)); if (numbytessent!= pdu_size) { 176 fprintf(stderr, "sendto ERROR!\n"); 177 return 0; 178 } 179 } 180 } 181 return 1; 182 } 27

28 umcserverprocess.c (9) 184 /******************************************************************************/ 185 int chk_alive(int sockfd, clnt_record_t *hd_ptr) 186 { 187 mcht_t alive_chk; 188 mcht_pdu_t send_pdu; alive_chk.fcode = CHK_REQ; 191 if(!mk_pdu(&alive_chk, &send_pdu)) { 192 fprintf(stderr, "mk_pdu ERROR!\n"); 193 return 0; 194 } time_t current_time = time(null); clnt_record_t *tmp; for (tmp = hd_ptr; tmp; tmp = tmp->next) { 201 if (tmp->last_atime + MAX_SILENT_TIME < current_time) { 202 int pdu_size = sizeof(send_pdu); 203 ssize_t numbytessent = sendto(sockfd, 204 &send_pdu, pdu_size, 0, 205 &tmp->clnt_addr, sizeof(tmp->clnt_addr)); if (numbytessent!= pdu_size) { 208 fprintf(stderr, "sendto ERROR!\n"); 209 return 0; 210 } 211 } 212 } 213 return 1; 214 } 28

29 umcserverprocess.c (10) 216 /******************************************************************************/ 217 int update_client_status(struct sockaddr *fromaddr, clnt_record_t *hd_ptr) 218 { 219 clnt_record_t *tmp; 220 int found = 0; for (tmp = hd_ptr;!found && tmp; tmp = tmp->next) { 223 if (SockAddrsEqual(&tmp->clnt_addr, fromaddr)) { 224 tmp->last_atime = time(null); 225 found = 1; 226 } 227 } if (!found) { 230 fprintf(stderr, "no such client!\n"); 231 return 0; 232 } return 1; 235 } 29

30 umcserverprocess.c (11) 237 /******************************************************************************/ 238 int prnt_clnt_list(clnt_record_t *hd_ptr) 239 { 240 int clnt_cnt = 0; 241 clnt_record_t *tmp; printf("client List: "); 244 for (tmp = hd_ptr; tmp; tmp = tmp->next, clnt_cnt++) { 245 PrintSocketAddress(&tmp->clnt_addr, stdout); 246 if (tmp->next) 247 printf(" - "); 248 } 249 printf("\n"); return clnt_cnt; } 30

31 umcserver.c (1) 1 #include <stdlib.h> 2 #include <string.h> 3 #include <sys/types.h> 4 #include <sys/socket.h> 5 #include <netdb.h> 6 7 #include "../../common/practical.h" 8 #include "umcprotocol.h" 9 #include "umcserverprocess.h" int prepare_udp_server_socket(char *service); 12 31

32 umcserver.c (2) 13 /******************************************************************************/ 14 int main(int argc, char *argv[]) { if (argc!= 2) // 명령어행의인자개수가알맞은지확인 17 DieWithUserMessage("Parameter(s)", "<Server Port/Service>"); char *service = argv[1]; // 첫번째인자 : 지역포트 / 서비스이름 int sock = prepare_udp_server_socket(service); clnt_record_t *head = NULL; struct sockaddr_storage clntaddr; 26 socklen_t clntaddrlen = sizeof(clntaddr); while(1) { 29 if (!recvfrom_and_serve(sock, (struct sockaddr *) &clntaddr, clntaddr Len, &head)) { 30 DieWithSystemMessage("recvfrom() failed"); 31 } 32 if (!chk_alive(sock, head)) { 33 DieWithSystemMessage("chk_alive() failed"); 34 } } 37 close(sock); 38 } 32

33 umcserver.c (3) 39 /******************************************************************************/ 40 int prepare_udp_server_socket(char *service) 41 { 42 struct addrinfo addrcriteria; // 원하는주소기준설정 43 memset(&addrcriteria, 0, sizeof(addrcriteria)); // 구조체를 0으로초기화 44 addrcriteria.ai_family = AF_UNSPEC; // IPv4,IPv6 모두반환 45 addrcriteria.ai_flags = AI_PASSIVE; // 주소 / 포트에무관하게반환 46 addrcriteria.ai_socktype = SOCK_DGRAM; // 데이터그램소켓만반환 47 addrcriteria.ai_protocol = IPPROTO_UDP; // UDP만반환 struct addrinfo *servaddr; 50 int rtnval = getaddrinfo(null, service, &addrcriteria, &servaddr); 51 if (rtnval!= 0) 52 DieWithUserMessage("getaddrinfo() failed", gai_strerror(rtnval)); int sock = socket(servaddr->ai_family, servaddr->ai_socktype, 55 servaddr->ai_protocol); 56 if (sock < 0) 57 DieWithSystemMessage("socket() failed"); if (bind(sock, servaddr->ai_addr, servaddr->ai_addrlen) < 0) 60 DieWithSystemMessage("bind() failed"); freeaddrinfo(servaddr); return sock; 65 } 33

CSE 333 Section 8 - Client-Side Networking

CSE 333 Section 8 - Client-Side Networking Welcome back to section! We re glad that you re here :) Networking Quick Review What are the following protocols used for? (bonus: what layer of the networking