IPC - Sockets: Client-Server Example

ישנן מספר שיטות לתקשורת בין Processes. כאן נדגים תקשורת בעזרת Socket. נראה תקשורת בין Processes על אותו מעבד. בפוסט אחר נדגים Socket על לתקשורת על הרשת - השימוש זם יעשה ממש באותו API.

Socket הוא אמצעי לתקשורת בין Processes.

נתאר כאן תהליך התקשרות בין server  לבין client.

ה-server שבדוגמא מחכה בהאזנה לבקשת connect מ-client. הדיאגרמה הבאה מתארת את התהליכים המתבצעים ב-Server. 

התבליכים הנ"ל יודגמו בדוגמא שתוצג מיד. 4 המלבנים העליונים הם התהליכים הסטנדרטיים שמתבצעים ב-server. במימוש הזה ה-server "נתקע" על accept ומחכה ל-client שיתחבר. שתי הצורות התחתונות הם מימוש אופייני ל-server שמגיב לקריאות של הרבה clients: עבור כל client יוצרים process חדש עם fork, וחוזרים להאזנה ב-parent process.

התהליכים ב-client פשוטים יותר, והם מוצגים בדיאגרמה הבאה:

ה-client שולח בקשת connect. אם לא יצליח להתחבר ל-server - למשל אם ה-server עדיין לא רץ, הפעולה תכשל.

הדוגמא נלקחה מתוך:

 Beej's Guide to Network Programming Using Internet Sockets

ה-server  מאזין על פורט מספר 3490. כשהוא מזהה client, הוא מיצר עבורו process חדש בעזרת fork ושולח ל-client משם הודעת "Hello World"

הנה הקוד של ה-server ואחריו הקוד של ה-client:

1. /*
2.  * stream_server.c
3.  *
4.  *  Created on: May 3, 2012
5.  */
6. /*
7. ** server.c -- a stream socket server demo
8. */
9. #include <stdio.h>
10. #include <stdlib.h>
11. #include <unistd.h>
12. #include <errno.h>
13. #include <string.h>
14. #include <sys/types.h>
15. #include <sys/socket.h>
16. #include <netinet/in.h>
17. #include <netdb.h>
18. #include <arpa/inet.h>
19. #include <sys/wait.h>
20. #include <signal.h>
21. #define PORT "3490" // the port users will be connecting to
22. #define BACKLOG 10 // how many pending connections queue will hold
23. 
    
24. void sigchld_handler(int s)
25. {
26. while(waitpid(-1, NULL, WNOHANG) > 0);
27. }
28. // get sockaddr, IPv4 or IPv6:
29. void *get_in_addr(struct sockaddr *sa)
30. {
31. if (sa->sa_family == AF_INET) {
32. return &(((struct sockaddr_in*)sa)->sin_addr);
33. }
34. return &(((struct sockaddr_in6*)sa)->sin6_addr);
35. }
36. int main(void)
37. {
38. int sockfd, new_fd; // listen on sock_fd, new connection on new_fd
39. struct addrinfo hints, *servinfo, *p;
40. struct sockaddr_storage their_addr; // connector's address information
41. socklen_t sin_size;
42. struct sigaction sa;
43. int yes=1;
44. char s[INET6_ADDRSTRLEN];
45. int rv;
46. memset(&hints, 0, sizeof hints);
47. hints.ai_family = AF_UNSPEC;
48. hints.ai_socktype = SOCK_STREAM;
49. hints.ai_flags = AI_PASSIVE; // use my IP
50. if ((rv = getaddrinfo(NULL, PORT, &hints, &servinfo)) != 0) {
51. fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
52. return 1;
53. }
54. // loop through all the results and bind to the first we can
55. for(p = servinfo; p != NULL; p = p->ai_next) {
56. if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
57. printf("\n in loop! p->ai_addr=0x%x, p->ai_addrle=0x%x  p->ai_protocol=0x%x", p->ai_addr, p->ai_addrlen,  p->ai_protocol);
58. perror("server: socket");
59. continue;
60. }
61. if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes,
62. sizeof(int)) == -1) {
63. perror("setsockopt");
64. exit(1);
65. }
66. if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
67. close(sockfd);
68. perror("server: bind");
69. continue;
70. }
71. printf("\n p->ai_addr=0x%x, p->ai_addrle=0x%x  p->ai_protocol=0x%x", p->ai_addr, p->ai_addrlen,  p->ai_protocol);
72. break;
73. }
74. if (p == NULL) {
75. fprintf(stderr, "server: failed to bind\n");
76. return 2;
77. 
    
78. }
79. freeaddrinfo(servinfo); // all done with this structure
81. perror("listen");
82. exit(1);
83. }
84. sa.sa_handler = sigchld_handler; // reap all dead processes
85. sigemptyset(&sa.sa_mask);
86. sa.sa_flags = SA_RESTART;
87. if (sigaction(SIGCHLD, &sa, NULL) == -1) {
88. perror("sigaction");
89. exit(1);
90. }
91. printf("server: waiting for connections...\n");
92. while(1) { // main accept() loop
93. sin_size = sizeof their_addr;
94. new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);
95. if (new_fd == -1) {
96. perror("accept");
97. continue;
98. }
99. inet_ntop(their_addr.ss_family, get_in_addr((struct sockaddr *)&their_addr),s, sizeof s);
100. printf("server: got connection from %s\n", s);
101. if (!fork()) { // this is the child process
102. close(sockfd); // child doesn't need the listener
103. if (send(new_fd, "Hello, world!", 13, 0) == -1)
104. perror("send");
105. close(new_fd);
106. exit(0);
107. }
108. close(new_fd); // parent doesn't need this
109. }
110. return 0;
111. }

בהדגש צהוב - 4 הפונקציות העיקריות בתהליך יצירת התקשורת ע"י ה-sever- ראו סכימת בלוקים למעלה:
- socket
- bind
- listen
- accept/

נסקור את ארבעתן, תוך כדי הסברים על שאר הפונקציות המודגשות בצבע.

 socket

שורה 56  - יצירת socket. הנה ה=prototype של socket:

int socket(int domain, int type, int protocol);

נסקור את הערכים האפשריים עבור כל אחד מ-3 הפרמטרים של socket:

domain (או בשם אחר - address family) יכול לקבל את הערכים הבאים - ציינתי כאן רק את הערכים הרלונטים לנו:

AF_INET - מערכת עם IPv4

AF_INET6 - מערכת עם IPv6

AF_UNSPEC - יכול להתאים לכל מערכת.

 type

SOCK_DGRAM -  שימוש ב-datagram. זה בד"כ אומר -UDP.

SOCK_STREAM - שימוש במערכת full duplex בד"כ - TCP.

SOC_SEQPACKET - מערכת full duplex sequntial, למשל SCTP.

protocol

0 או IPPROTO_IP - המערכת תבחר את הפרוטוקול הדיפולטיבי בהתאם ל-type, כך שעבור SOCK_STREAM הפרוטוקול שיבחר הוא IP_PROTO_TCP.

IPPROTO_TCP

IPPROTO_UDP

IPPROTO_RAW

IPPROTO_ICMP

IPPROTO_IPV6

זה היה ההסבר על שלושת הפרמטרים של הפונקציה socket, אבל במימוש הנ"ל בוצע קודם תהליך להכנת הפרמטרים הנ"ל בעזרת הפונקציה getaddrinfo

הסבר על getaddrinfo:
מכניסים לתוך הפונקציה פרמטרים, והיא כבר תכין את הפרמטרים הדרושים עבור socket.

getaddrinfo - שימו לב לשימוש ב-structure בשם servinfo לצורך הכנסת הפרמטרים ל-לפונקציה socket.

הנה שורה 50 בה הפונקציה מופעלת:

(rv = getaddrinfo(NULL, PORT, &hints, &servinfo)

הנה ה-prototype  שלה:

int getaddrinfo(const char *node, const char *service,
                const struct addrinfo *hints,
                struct addrinfo **res);

נסביר את הפרמטרים שלה:
node - לשים NULL כשמכינים פרמטרים ל-socket.
service - מספר הפורט או service name. אנחנו נשים תמיד את מספר הפורט.
struct addrinfp *hints - נתייחס כאן רק לחברים ב-addrinfo המעניינים אותנו. זה נמצא בשורות 47-49 הנה הן כאן:

1. hints.ai_family = AF_UNSPEC;
2. hints.ai_socktype = SOCK_STREAM;
3. hints.ai_flags = AI_PASSIVE; // use my IP

.ai_family - כמו שדה ה-domain בפונקציה socket. ראה פרוט למעלה. יכול לקבל AF_INET, AF_INET6 ו-AF_UNSPEC, כמו ב- domain למעלה.

ai_socktype - כמו שדה ה-type של הפונקציה socket - ראו למעלה. עבור tcp נכניס את הערך SOCK_STREAM.

ai_flags - הערך AI_PASSIVE יגרום למערכת לשלוף את ה-IP המקומי.

 struct addrinfo **res  - כאן מתקבלת התוצאה. נראה שהתוצאה מסודרת כרשימה מקושרת של structures מסוג  addrinfo. כל strucutre כזה מייצג כתובת network שמתאימה לפרמטרים node ו-service. הלופ בשורה 56 רץ על פני ה-res  ומנסה להפעיל את socket.

bind

שורה 66: 

if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {

זו הפעולה של חיבור בין ה-socket לבין ה-port במחשב הלוקאלי.

הנה ה-prototype של bind:

int bind(int sockfd, struct sockaddr *my_addr, int addrlen);

הפרמטר הראשון הוא ה-descriptor שמתקבל מהפונקציה socket.

שני הפרמטרים האחרים, מתקבלים מתוך ה-addrinfo struct שיצרנו עם הפונקציה getaddrinfo.

listen

שורה 80:

if (listen(sockfd, BACKLOG) == -1) {

ה-prototype של listen:

int listen(int sockfd, int backlog);

כאשר sockfd הוא ה-descriptor שמתקבל מתוך הפונקציה socket,

ו-backlog הוא  מספר ה-connections המקסימלי שיאופשר. הגדרנו כאן 10 - שורה 22.

הפונקציה listen מתחילה תהליך האזנה ל-clients שמבקשים להתחבר. אחריה מופעלת accept.

accept

שורה 95: 

new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);

הנה ה-prototype שלה:

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

sockfd - כרגיל, ה-descriptor שמחזירה socket.

addr - זהו ה-struct אליו יכנסו הנתונים של ה-host שהתחבר. נראה מיד את השימוש בהם.

addrlen - הגודל של struct addr.

accept "נתקעת" עד שנוצר connection עם client כלשהו.

לגבי ה-struct sockaddrr *addr:

לכאן כאמור יכנסו נתוני ההתחברות של ה-client ושולפים אותם עם inet_ntop.

שורה 99:

inet_ntop(their_addr.ss_family, get_in_addr((struct sockaddr *)&their_addr),s, sizeof s);

זוהי  פונקציה שממירה את ה-structure ל-string.

ה-prototype שלה:

const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);

הסבר הפרמטרים: 

af - זהו ה-address family , מקבל את הערכים:

AF_INET - מערכת עם IPv4

AF_INET6 - מערכת עם IPv6

נמצא ב- their_addr.ss_family (ראה שורה 99...)

*src - הכתובת מתוך ה-structure במקרה שלנו, שליפת הכתובת מתוך- their_address.

*dst - הכתובת של ה-destination string. נכניס את ה-string ל-buffer בשם s.

size - הגודל של ה-destination string.

-> סיימנו עם 4 הפונקציות של ה-sever, בעזרתן יצרנו את התקשורת. 

כעת, ברגע שנוצר חיבור עם client נצור עבורו process עצמאי ע"י fork. ומתוך ה-child process נשלח הודעה ל-client ע"י send:

if (send(new_fd, "Hello, world!", 13, 0) == -1)

עד כאן מימוש ה-server. נעבור ל-client.

הנה הקוד של ה-client, אבל שוב אתן קרדיט ל 

 Beej's Guide to Network Programming Using Internet Sockets

משם לקחתי את הדוגמא.

1. 
   
2. /*
3.  * client.c
4.  *
5.  *  Created on: May 3, 2012
6. 
   
7.  */
8. 
   
9. #include <stdio.h>
10. #include <stdlib.h>
11. #include <unistd.h>
12. #include <errno.h>
13. #include <string.h>
14. #include <netdb.h>
15. #include <sys/types.h>
16. #include <netinet/in.h>
17. #include <sys/socket.h>
18. #include <arpa/inet.h>
19. #define PORT "3490" // the port client will be connecting to
20. #define MAXDATASIZE 100 // max number of bytes we can get at once
21. // get sockaddr, IPv4 or IPv6:
22. void *get_in_addr(struct sockaddr *sa)
23. {
24. if (sa->sa_family == AF_INET) {
25. return &(((struct sockaddr_in*)sa)->sin_addr);
26. }
27. return &(((struct sockaddr_in6*)sa)->sin6_addr);
28. }
29. int main(int argc, char *argv[])
30. {
31. int sockfd, numbytes;
32. char buf[MAXDATASIZE];
33. struct addrinfo hints, *servinfo, *p;
34. int rv;
35. char s[INET6_ADDRSTRLEN];
36. if (argc != 2) {
37. fprintf(stderr,"usage: client hostname\n");
38. exit(1);
39. }
40. memset(&hints, 0, sizeof hints);
41.         ints.ai_family = AF_UNSPEC;
42. hints.ai_socktype = SOCK_STREAM;
43. if ((rv = getaddrinfo(argv[1], PORT, &hints, &servinfo)) != 0) {
44. fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
45. return 1;
46. }
47. // loop through all the results and connect to the first we can
48. for(p = servinfo; p != NULL; p = p->ai_next) {
49. if ((sockfd = socket(p->ai_family, p->ai_socktype,p->ai_protocol)) == -1) {
50. perror("client: socket");
51. continue;
52. }
53. if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
54. close(sockfd);
55. perror("client: connect");
56. continue;
57. }
58. break;
59. }
60. if (p == NULL) {
61. fprintf(stderr, "client: failed to connect\n");
62. return 2;
63. }
64. inet_ntop(p->ai_family, get_in_addr((struct sockaddr *)p->ai_addr),
65. s, sizeof s);
66. printf("client: connecting to %s\n", s);
67. freeaddrinfo(servinfo); // all done with this structure
68. if ((numbytes = recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1) {
69. perror("recv");
70. exit(1);
71. }
72. buf[numbytes] = '\0';
73. printf("client: received '%s'\n",buf);
74. close(sockfd);
75. return 0;
76. }
77. 
    

כאן נוכל לקצר בהסברים, היות שהפונקציות דומות לאלה שבהם השתמשנו עבור ה-server.

ההבדל - כפי שהשתקף בסכמת הבלוקים למעלה - כאן תהליך ההתחברות מופעל ע"י שתי פונקציות:

socket ו-connect. שתיהן מודגשות בצהוב.

את socket כבר ראינו ב-server.

הנה ה-prototype של connect:

int connect(int sockfd, struct sockaddr *serv_addr, int addrlen);

את ה-sockaddr וה-addrlen אנו מקבלים, כמו ב-server מפונקצית העזר getaddrinfo:

1. if ((rv = getaddrinfo(argv[1], PORT, &hints, &servinfo)) != 0) {

נזכר שוב ב-prototype של getaddrinfo:

int getaddrinfo(const char *node, const char *service,
                const struct addrinfo *hints,
                struct addrinfo **res);

הפעם ה- *node הוא הכתובת של ה-server. הפונקציה שלנו מקבלת אותו כארגומנט (argv).

בניית ה-hints דומה לזו שראינו כבר.

עם ההתחברות, ה-clinet מוכן לפעולה!

שורה 67 - קליטת נתונים מה-socket. נקלו את ההודעה "Hello World" ששולח ה-server, ונדפיס אותה - שורות 72-73.

זאת היתה הדוגמא לתקשורת client/server עם TCP protocol.