Network
Socket, Bind listen accept, SYN ACK
תכנות סוקטים, הפונקציות bind, listen ו-accept, וה-TCP Handshake עם SYN, ACK ו-RST.
בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל
חומר לימוד
Socket, Bind listen accept, SYN ACK: מהקריאה הראשונה ועד חיבור פתוח
הפרק עוקב אחרי מה שקורה כששתי תוכניות במחשבים שונים מחליפות נתונים ב-TCP או ב-UDP, משתי זוויות: הקוד שהתוכנית כותבת, והחבילות שעוברות ברשת בזמן שהקוד רץ.
- Socket: מה בדיוק מזהה נקודת קצה, איך מערכת ההפעלה מפרידה בין אלפי חיבורים לאותו פורט, ומה ההבדל בין
SOCK_STREAMל-SOCK_DGRAM. - סדר הקריאות: מה שרת TCP קורא ובאיזה סדר (
socket,bind,listen,accept), מה לקוח צריך (connectבלבד), ולמה שרת UDP מסתדר בלי חצי מהן. - bind, listen ו-accept לעומק: לאיזו כתובת נקשרים, למה הקשירה נכשלת, מה גודל התור קובע, ומה בדיוק מחזירה
accept. - לחיצת היד SYN, SYN-ACK, ACK: מספרי הרצף כפי שהם נראים בלכידת Wireshark, הדגלים RST ו-FIN, ומה קורה כשאחד השלבים לא מגיע.
- מצב הפורט והתקפת SYN Flood: מה עונה שרת לפורט פתוח, סגור או מסונן, ואיך SYN Cookies מגינים על תור החיבורים החצי-פתוחים.
רוב השאלות בנושא הזה בודקות אם אתם יודעים איזו קריאה אחראית על מה, ומה יקרה בתרחיש מסוים: שרת שקשור לכתובת הלא נכונה, לקוח שמתחבר לפני accept, או SYN שנשאר בלי תשובה.
socket שלו קורא לאותן קריאות מערכת בדיוק, והורצו בפועל על Linux: הפלט והודעות השגיאה הם מה שהתקבל.Socket: נקודת הקצה של התקשורת
Socket ו-Socket Address: מה מזהה נקודת קצה
קחו לקוח דואר שמושך הודעות מהשרת. הוא לא מדבר עם כרטיס הרשת ישירות: הוא מקבל ממערכת ההפעלה Socket, וכל בקשה שהוא כותב וכל תשובה שהוא קורא עוברות דרך הידית הזו.
Socket הוא נקודת קצה (Endpoint) של ערוץ תקשורת דו-כיווני בין שני תהליכים. אפשר לדמות אותו לשקע בקיר: הוא לא החשמל ולא הכבל, אלא המקום המוגדר שבו מתחברים.
כדי שנתונים יגיעו לשקע הנכון צריך שני פרטים. כתובת ה-IP מביאה אותם למחשב הנכון, ומספר הפורט מביא אותם לתהליך הנכון בתוך המחשב, ולצדם עומד הפרוטוקול, TCP או UDP.
לזוג הזה, כתובת IP ומספר פורט, קוראים Socket Address. בדומה לכתובת דירה, הרחוב והמספר מביאים לבניין, ומספר הדירה מביא לדלת אחת מסוימת.
172.16.4.31:51822 Socket Address of a laptop running a mail client
198.51.100.7:993 Socket Address of the mail server (IMAPS)כדאי לזכור גם מה אינו Socket:
- מספר פורט לבד: זה רק חצי מהכתובת, ואותו מספר קיים בכל מחשב.
- כתובת IP לבד: היא מצביעה על מחשב שלם, לא על תהליך מסוים בתוכו.
- קובץ שנשאר בדיסק ושומר את הנתונים אחרי שהשיחה הסתיימה.
- חיבור TCP שלם: לחיבור יש שני קצוות, אחד אצל הלקוח ואחד אצל השרת, וכל קצה הוא Socket נפרד.
- כתובת MAC, שם דומיין או מספר רצף: אף אחד מהם אינו מגדיר נקודת קצה של תהליך.
טעויות נפוצות
- Socket הוא בעצם מספר הפורט של היישום. הפורט הוא רק אחד משני הרכיבים. בלי כתובת ה-IP אי אפשר לדעת באיזה מחשב נמצא התהליך.
- Socket הוא הכתובת הפיזית (MAC) שצרובה בכרטיס. כתובת MAC מזהה כרטיס רשת בתוך הרשת המקומית, ואין בה שום מידע על תהליך או על פורט.
- Socket הוא שם השרת, למשל שם הדומיין שלו. שם דומיין מתורגם ב-DNS לכתובת IP בלבד. הוא אינו כולל פורט ואינו מצביע על תהליך.
- Socket הוא החיבור כולו, כולל לחיצת היד שפתחה אותו. חיבור נמתח בין שתי נקודות קצה. כל צד מחזיק Socket משלו, ולכן חיבור מזוהה לפי שני Sockets.
- Socket Address מורכב מכתובת IP וממסיכת הרשת שלה. מסיכת הרשת רק מסמנת אילו כתובות שייכות לרשת המקומית. היא אינה מזהה תהליך, ומה שמשלים את הכתובת הוא הפורט.
בדקו את עצמכם
האם 192.0.2.44:8443 הוא Socket Address? ומה לגבי המספר 8443 לבדו?
הצירוף של כתובת ופורט הוא Socket Address. המספר 8443 לבדו אינו, כי חסר בו המחשב שאליו הוא שייך.
תלמיד כותב: 'פתחתי Socket אחד בין הלקוח לשרת'. מה לא מדויק כאן?
Socket הוא קצה אחד. בחיבור בין לקוח לשרת יש שני Sockets, אחד בכל צד, והחיבור מזוהה לפי שניהם.
זיהוי חיבור: ה-4-tuple
שרת web אחד שמאזין בפורט 443 מחזיק בבת אחת אלפי חיבורים. כל חבילה שמגיעה אליו נושאת את אותו פורט יעד, ובכל זאת מערכת ההפעלה יודעת בדיוק לאיזה חיבור לשייך אותה.
הסוד הוא שחיבור TCP אינו מזוהה לפי שדה אחד, אלא לפי ארבעה ערכים שנבדקים יחד, ושמם המקובל 4-tuple:
- כתובת ה-IP של המקור (Source IP).
- הפורט של המקור (Source port).
- כתובת ה-IP של היעד (Destination IP).
- הפורט של היעד (Destination port).
שני חיבורים יכולים להיות זהים בשלושה מהערכים ועדיין להיות נפרדים לגמרי. מספיק שערך אחד שונה כדי שמערכת ההפעלה תראה בהם שני חיבורים.
| חיבור | Source IP | Source port | Destination IP | Destination port | מה מבדיל אותו |
|---|---|---|---|---|---|
| 1 | 172.16.4.31 | 51822 | 198.51.100.7 | 443 | נקודת ההשוואה |
| 2 | 172.16.4.32 | 51822 | 198.51.100.7 | 443 | מחשב מקור אחר |
| 3 | 172.16.4.31 | 51823 | 198.51.100.7 | 443 | פורט מקור אחר |
ההדגמה הבאה פותחת שני חיבורים מאותו מחשב לאותו שרת ולאותו פורט, בדיוק כמו שתי לשוניות בדפדפן. לכל חיבור שהשרת קיבל מודפס ה-4-tuple שלו, כפי שהשרת רואה אותו:
import socket
srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
srv.bind(("127.0.0.1", 47110))
srv.listen(5)
c1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
c2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
c1.connect(("127.0.0.1", 47110)) # no bind(): the kernel picks the source port
c2.connect(("127.0.0.1", 47110))
for name, c in (("tab-1", c1), ("tab-2", c2)):
conn, _ = srv.accept()
src_ip, src_port = conn.getpeername()
dst_ip, dst_port = conn.getsockname()
print(f"{name}: {src_ip}:{src_port} -> {dst_ip}:{dst_port}")tab-1: 127.0.0.1:44002 -> 127.0.0.1:47110
tab-2: 127.0.0.1:44004 -> 127.0.0.1:47110שלושה מהערכים זהים בשתי השורות: כתובת המקור, כתובת היעד והפורט 47110. מה שמבדיל ביניהן הוא פורט המקור, שמערכת ההפעלה בחרה לכל לקוח בעצמה ברגע ה-connect. המספרים 44002 ו-44004 הם מה שיצא בהרצה הזו, ובכל הרצה ייבחרו אחרים: מה שקובע הוא רק שהם שונים זה מזה.
תרחיש 1: שתי לשוניות, מחשב אחד
במחשב 172.16.4.31 פתוחות שתי לשוניות, ושתיהן מושכות דפים מאותו שרת, 198.51.100.7, בפורט 80. כתובת המקור, כתובת היעד ופורט היעד זהים בשני החיבורים.
בכל connect מערכת ההפעלה של המחשב מקצה פורט מקור זמני אחר, למשל 51822 לראשונה ו-51823 לשנייה. זה הערך היחיד ששונה, והוא מספיק.
הדפדפן אינו צריך לסמן בבקשת ה-HTTP מאיזו לשונית היא באה. ההפרדה כבר נעשתה שכבה אחת מתחת, ב-TCP.
תרחיש 2: שני מחשבים שקיבלו אותו פורט מקור
שני מחשבים, 172.16.4.31 ו-172.16.4.32, מתחברים לשרת 198.51.100.7 בפורט 443, ובצירוף מקרים שניהם קיבלו את פורט המקור 51822.
אין שום התנגשות: המחשבים שונים, אז גם ארבעת הערכים של החיבורים שונים. השרת אינו מזהה חיבורים לפי פורט המקור בלבד.
בשרת, כל אחד מהחיבורים מקבל מ-accept סוקט משלו, ושני הסוקטים משתמשים באותו פורט מקומי, 443. השרת אינו נותן לכל לקוח פורט יעד אחר: פורט היעד הוא תמיד הפורט שהשרת מאזין עליו.
טעויות נפוצות
- השרת מפריד בין החיבורים בעזרת הכתובת הפיזית (MAC) שמגיעה מכל מחשב. כותרת TCP אינה מכילה כתובת MAC בכלל, וכתובת ה-MAC של לקוח מרוחק אפילו לא מגיעה לשרת מעבר לנתב.
- כל חיבור מקבל מספר סידורי לפי הסדר שבו הגיעו חבילות ה-SYN. סדר ההגעה אינו נשמר בשום שדה ואינו משמש לזיהוי. כל חבילה משויכת לחיבור לפי ארבעת הערכים שבכותרות שלה.
- מספר הרצף ההתחלתי שהלקוח בחר הוא המזהה של החיבור. המספר נבחר אקראית ואין ערובה שהוא ייחודי. שני לקוחות יכולים לבחור במקרה את אותו מספר, והחיבורים עדיין לא יתבלבלו.
- בזמן
acceptהשרת מצמיד לכל לקוח פורט יעד משלו. כל הלקוחות פונים לאותו פורט יעד, הפורט של השרת. מה ששונה בין החיבורים הוא צד המקור. - שני חיבורים לא יכולים לחלוק פורט מקור. מותר, כל עוד ערך אחר ב-4-tuple שונה: כתובת המקור, כתובת היעד או פורט היעד.
בדקו את עצמכם
תוכנית אחת פותחת שלושה חיבורים מאותה כתובת, לאותו שרת ולאותו פורט יעד. איזה ערך חייב להיות שונה בין שלושתם?
פורט המקור. שלושת הערכים האחרים זהים, ולכן רק הוא יכול להבדיל בין החיבורים.
שני לקוחות בכתובות שונות קיבלו אותו פורט מקור ומתחברים לאותו שרת ולאותו פורט. האם השרת יתבלבל?
לא. שני החיבורים יוצאים מכתובות שונות, וזה מספיק כדי שארבעת הערכים לא יהיו זהים.
socket() וסוג הסוקט: SOCK_STREAM, SOCK_DGRAM ו-SOCK_RAW
ב-C נוצר סוקט בקריאה socket(), שמקבלת שלושה ארגומנטים: משפחת הכתובות, סוג הסוקט, והפרוטוקול. כשהפרוטוקול הוא 0, מערכת ההפעלה בוחרת את ברירת המחדל שמתאימה לסוג.
/* family type protocol (0 = default for the type) */
int stream_fd = socket(AF_INET, SOCK_STREAM, 0); /* IPv4, TCP */
int dgram_fd = socket(AF_INET, SOCK_DGRAM, 0); /* IPv4, UDP */
if (stream_fd < 0 || dgram_fd < 0)
perror("socket");AF_INET הוא משפחת הכתובות (address family), והוא אומר שהכתובות יהיו IPv4. הוא אינו סוג סוקט, ותמיד מופיע כארגומנט נפרד מהסוג.
הארגומנט השני הוא שקובע איך הסוקט יתנהג:
| סוג | איך הנתונים זורמים | הפרוטוקול כשמשפחת הכתובות היא AF_INET |
|---|---|---|
SOCK_STREAM | רצף בתים אחד, אמין ומסודר, בתוך חיבור | TCP |
SOCK_DGRAM | דאטהגרמים: הודעות נפרדות, כל אחת עומדת בפני עצמה, בלי חיבור | UDP |
SOCK_RAW | התוכנית מרכיבה בעצמה את כותרת ה-IP | אין ברירת מחדל, ואין זה הסוג של סוקט TCP רגיל |
הסוג נקבע פעם אחת, ביצירה, ונשאר כזה עד שהסוקט נסגר. אין קריאה שהופכת סוקט SOCK_DGRAM לסוקט TCP, וגם listen לא עושה זאת, כפי שנראה בהמשך.
ההבדל מורגש בצד המקבל. בסוקט TCP אין גבולות בין הודעות: שתי שליחות של 10 בתים יכולות להגיע כקריאה אחת של 20. בסוקט UDP כל דאטהגרם מגיע כיחידה שלמה ונפרדת.
טעויות נפוצות
- כדי לקבל סוקט TCP מעבירים ל-
socket()אתAF_INETכסוג.AF_INETהוא רק משפחת הכתובות. הסוג שנותן TCP הואSOCK_STREAM, והוא ארגומנט אחר. SOCK_DGRAMמעביר את הנתונים כזרם בתים רציף. זרם בתים הואSOCK_STREAM.SOCK_DGRAMמעביר הודעות בודדות, כל אחת עצמאית.SOCK_RAWהוא הסוג הרגיל לסוקט TCP.SOCK_RAWנועד למי שמרכיב את כותרת ה-IP במו ידיו. סוקט TCP רגיל הואSOCK_STREAM.
בדקו את עצמכם
אתם כותבים שרת שמקבל דיווחי מדידה קצרים ב-UDP מעל IPv4. מה תעבירו כארגומנט הראשון וכארגומנט השני של socket()?
AF_INET כמשפחת הכתובות, ו-SOCK_DGRAM כסוג הסוקט.
פורטים ידועים, פורטים זמניים, ומרחב פורטים לכל פרוטוקול
מספר פורט הוא מספר שלם בין 0 ל-65535. שני הצדדים של חיבור משתמשים בפורטים, אבל מסיבות שונות לגמרי.
שרת חייב לשבת בפורט שהלקוחות יודעים עליו מראש, אחרת אף אחד לא ימצא אותו. לכן שירותים מוכרים יושבים על פורטים ידועים (well-known), כולם מתחת ל-1024: 80 ל-HTTP, 443 ל-HTTPS, 53 ל-DNS ו-22 ל-SSH.
ללקוח אין צורך כזה. הפורט שלו כתוב ממילא בחבילת ה-SYN שהוא שולח, והשרת פשוט משיב אליו.
לכן כשלקוח קורא ל-connect(), מערכת ההפעלה בוחרת בשבילו לבד פורט מקור פנוי. פורט כזה נקרא פורט זמני (ephemeral), והוא משמש בעיקר לצד הלקוח של חיבורים; שרת אינו חייב לבחור את הפורט שלו מהטווח הזה.
עוד פרט שנשאל עליו הרבה: TCP ו-UDP מנהלים כל אחד רשימת פורטים עצמאית, שאינה תלויה בשנייה. הפורט 47010 ב-TCP והפורט 47010 ב-UDP הם שני דברים שונים, כפי שמראה ההרצה:
import socket
tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
print(tcp.family.name, tcp.type.name)
print(udp.family.name, udp.type.name)
tcp.bind(("127.0.0.1", 47010)) # TCP port 47010
udp.bind(("127.0.0.1", 47010)) # the same number, but in UDP's port space
print("TCP bound to", tcp.getsockname())
print("UDP bound to", udp.getsockname())AF_INET SOCK_STREAM
AF_INET SOCK_DGRAM
TCP bound to ('127.0.0.1', 47010)
UDP bound to ('127.0.0.1', 47010)שתי הקריאות ל-bind הצליחו על אותה כתובת ואותו מספר. שרתי DNS מנצלים בדיוק את זה ומאזינים לפורט 53 גם ב-UDP וגם ב-TCP, ולכן נקודת קצה מזוהה בפועל לפי כתובת, פורט ופרוטוקול.
טעויות נפוצות
- אם סוקט TCP כבר תפס את פורט 47010, סוקט UDP לא יוכל לקשור את אותו מספר. המספר לבדו אינו מזהה סוקט. TCP ו-UDP מחזיקים מרחבי פורטים נפרדים, והפרוטוקול הוא חלק מהזיהוי.
- סוקט UDP תמיד מקבל פורט אקראי ואינו יכול לקשור פורט קבוע. שרתי UDP קושרים פורט קבוע בדיוק כמו שרתי TCP, אחרת הלקוחות לא היו יודעים לאן לשלוח. שרת DNS בפורט 53 הוא הדוגמה הקלאסית.
- TCP ו-UDP יכולים לחלוק פורט רק כשהתהליכים רצים תחת אותו משתמש. זהות המשתמש אינה קשורה לעניין. ההפרדה נובעת מכך שאלה שני פרוטוקולים עם מרחבי פורטים שונים.
בדקו את עצמכם
בשרת אחד רוצים להריץ שירות TCP ושירות UDP, שניהם על פורט 6100 ועל אותה כתובת. האם זה אפשרי?
כן. לכל פרוטוקול יש מרחב פורטים משלו, ולכן שני הסוקטים אינם מתנגשים.
למה ללקוח אין צורך בפורט ידוע מראש?
כי הוא זה שפונה ראשון. הפורט שלו מופיע ב-SYN, והשרת לומד אותו משם ומשיב אליו.
באיזה סדר קוראים: שרת ולקוח
שרת TCP: socket, bind, listen, accept
ממשק הסוקטים של C נקרא Berkeley sockets, על שם האוניברסיטה שבה פותח. שרת TCP עובר בו ארבע קריאות, ותמיד באותו סדר:
socket(): מבקשים ממערכת ההפעלה סוקט חדש.bind(): קושרים אותו לכתובת ולפורט מקומיים.listen(): מעבירים אותו להאזנה וקובעים כמה חיבורים מוכנים יכולים לחכות.accept(): שולפים חיבור מוכן מהתור ומקבלים עבורו סוקט חדש.
רק אחרי accept מתחילה השיחה עם הלקוח, ב-recv() וב-send() על הסוקט החדש. בסוף סוגרים אותו ב-close().
int lsock = socket(AF_INET, SOCK_STREAM, 0); /* step 1: create */
struct sockaddr_in local;
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
local.sin_port = htons(9090);
local.sin_addr.s_addr = htonl(INADDR_ANY); /* every local address */
if (bind(lsock, (struct sockaddr *)&local, sizeof(local)) < 0) /* step 2 */
perror("bind");
if (listen(lsock, 16) < 0) /* step 3: backlog of 16 */
perror("listen");
while (1) {
int conn = accept(lsock, NULL, NULL); /* step 4: one socket per client */
char req[512];
ssize_t got = recv(conn, req, sizeof(req), 0);
send(conn, req, got, 0); /* echo it back */
close(conn); /* lsock stays open */
}בקוד יש שני סוקטים עם תפקידים שונים: lsock הוא סוקט ההאזנה, שחי לאורך כל ריצת השרת, ו-conn הוא הסוקט של לקוח אחד, שנוצר ונסגר בכל סיבוב.
אי אפשר להחליף את הסדר: בזרימה הרגילה של שרת קושרים קודם, כדי ש-listen תאזין על הכתובת והפורט שהלקוחות מכירים, ו-accept צריכה סוקט שכבר מאזין. connect לא מופיעה כאן בכלל, כי היא קריאה של לקוח.
listen על סוקט TCP שלא עבר bind דווקא מצליחה, אבל הליבה קושרת אותו לפורט אקראי שאף לקוח לא מכיר, ו-bind שתבוא אחריה תיכשל ב-Invalid argument. לכן הכלל נשאר: קודם bind, ורק אחריה listen.לדרך הפעולה הזו של השרת קוראים Passive Open: השרת מתכונן ומחכה, ואינו יוזם שום חיבור בעצמו.
טעויות נפוצות
- שרת TCP קורא ל-
connect, אחר כך ל-listenואז ל-accept.connectהיא הקריאה של הצד היוזם, הלקוח. השרת לעולם לא קורא לה כדי לקבל לקוחות. - הסדר הוא
listen, אחר כךbind, ואזaccept. צריך קודם לקבוע לאיזו כתובת ולאיזה פורט הסוקט שייך, ורק אז להאזין עליהם. בסדר ההפוך השרת יאזין על פורט שלא בחר, ו-bindהמאוחרת כבר לא תצליח. - אפשר להתחיל ב-
acceptולעשותbindו-listenאחריה.acceptשולפת חיבורים מהתור של סוקט מאזין. בליbindו-listenלפניה אין תור כזה, והקריאה נכשלת.
בדקו את עצמכם
סדרו את ארבע הקריאות של שרת TCP: accept, socket, listen, bind.
socket, bind, listen, accept.
למה קוראים לצורת הפעולה של השרת Passive Open?
כי השרת רק מכין סוקט מאזין ומחכה שמישהו יפנה אליו. מי שיוזם את החיבור הוא הלקוח.
לקוח TCP: socket ואחריה connect
הלקוח הוא הצד היוזם, ולכן צורת הפעולה שלו נקראת Active Open. הוא צריך שתי קריאות בלבד: socket(), ואחריה connect(), שמקבלת את הכתובת והפורט שאליהם הוא פונה.
int fd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in peer;
memset(&peer, 0, sizeof(peer));
peer.sin_family = AF_INET;
peer.sin_port = htons(9090);
inet_pton(AF_INET, "198.51.100.7", &peer.sin_addr);
/* no bind(): the kernel picks a free source port and a source address here */
if (connect(fd, (struct sockaddr *)&peer, sizeof(peer)) < 0) /* SYN goes out */
perror("connect");ברגע ש-connect() נקראת, מערכת ההפעלה שולחת לשרת חבילת SYN, וזה הצעד הראשון של לחיצת היד התלת-שלבית.
לקוח TCP רגיל אינו קורא ל-bind(). מה שחסר לסוקט, פורט מקור זמני וכתובת IP מקומית שמתאימה לדרך אל השרת, מערכת ההפעלה משלימה בעצמה בזמן connect.
ראיתם את זה בהדגמת ה-4-tuple: שני הלקוחות לא עשו bind, ובאותה הרצה קיבלו פורטי מקור 44002 ו-44004. אלה מספרים מהטווח הזמני, שונים לגמרי מפורט השרת 47110, ואין שום סיבה שיהיו שווים לו.
טעויות נפוצות
- לקוח שלא קרא ל-
bindאין לו כתובת IP, ולכן הוא לא יכול לשלוח SYN.connectבוחרת לסוקט כתובת מקור מתאימה ופורט מקור פנוי, ואז שולחת את ה-SYN. - השרת צריך להכיר מראש את מספר הפורט של הלקוח, אחרת לא יוכל להשיב. פורט המקור כתוב בכותרת של חבילת ה-SYN. השרת קורא אותו משם ומשיב אליו.
- פורט המקור של הלקוח זהה לפורט היעד, כלומר לקוח שפונה לפורט 80 יוצא מפורט 80. אין קשר בין השניים. פורט המקור נבחר מהטווח הזמני, ובדרך כלל הוא שונה לגמרי מפורט השרת.
- בלי
bind, הסוקט של הלקוח מושתק ולא ישדר דבר.connectמשלימה בעצמה את מה ש-bindהייתה קובעת, והסוקט שולח כרגיל. - גם הלקוח צריך
listenאוaccept, כדי שהחיבור מהשרת ייכנס אליו.listenו-acceptשייכות לצד הממתין, השרת. הלקוח מסיים את עבודתו ב-connect.
בדקו את עצמכם
לקוח קרא ל-socket() ומיד אחר כך ל-connect() לשרת בפורט 25. איזו קריאה שלחה את ה-SYN, ומאיזה פורט הוא יצא?
connect() שלחה את ה-SYN. פורט המקור הוא פורט זמני פנוי שמערכת ההפעלה בחרה בזמן ה-connect, לא 25.
שרת UDP: socket, bind ו-recvfrom
ב-UDP לא מקימים חיבור, ולכן גם לא לוחצים ידיים. כל דאטהגרם עומד בפני עצמו, ולכן אין סוקט מאזין, אין תור של חיבורים שהושלמו, ואין שום דבר ש-accept יכולה לשלוף.
שרת UDP פשוט מסתפק בשלושה צעדים:
socket()עםSOCK_DGRAM.bind()לפורט הקבוע שהלקוחות מכירים.recvfrom()בלולאה: כל קריאה מחזירה דאטהגרם אחד.
recvfrom() מחזירה, יחד עם הנתונים, גם את כתובת השולח. בעזרתה השרת עונה עם sendto(), כך שאין צורך ב-connect כדי לקבל ממישהו נתונים, וממילא השרת לא יודע מי הלקוח לפני שהגיעה ממנו הודעה.
int ufd = socket(AF_INET, SOCK_DGRAM, 0);
struct sockaddr_in me;
memset(&me, 0, sizeof(me));
me.sin_family = AF_INET;
me.sin_port = htons(6100);
me.sin_addr.s_addr = htonl(INADDR_ANY);
bind(ufd, (struct sockaddr *)&me, sizeof(me));
/* no listen(), no accept(): go straight to receiving */
for (;;) {
char msg[256];
struct sockaddr_in who;
socklen_t wlen = sizeof(who);
ssize_t len = recvfrom(ufd, msg, sizeof(msg), 0, (struct sockaddr *)&who, &wlen);
sendto(ufd, "ACKED", 5, 0, (struct sockaddr *)&who, wlen); /* answer the sender */
}ואותו רעיון בהרצה אמיתית, כולל מה שקורה כשמנסים בכל זאת listen על סוקט דאטהגרם:
import socket
srv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
srv.bind(("0.0.0.0", 47210)) # socket + bind, and that is all
cli = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
cli.sendto(b"temp=21.5", ("127.0.0.1", 47210))
data, sender = srv.recvfrom(1024) # the datagram arrives together with its sender
print("server got", data)
print("sender is the client:", sender == ("127.0.0.1", cli.getsockname()[1]))
srv.sendto(b"ok", sender) # reply to whoever sent it
print("client got", cli.recvfrom(1024)[0])
try:
srv.listen(5) # a datagram socket has no connection queue
except OSError as e:
print("listen on SOCK_DGRAM:", e)server got b'temp=21.5'
sender is the client: True
client got b'ok'
listen on SOCK_DGRAM: [Errno 95] Operation not supportedב-Linux הקריאה listen על סוקט SOCK_DGRAM נדחית בשגיאה Operation not supported. הסוקט נשאר סוקט UDP, כי הסוג שלו נקבע כשנוצר.
| קריאה | בשרת TCP | בשרת UDP פשוט |
|---|---|---|
socket | חובה | חובה |
bind | חובה | חובה |
listen | חובה | מיותרת, ואם קוראים לה היא נכשלת |
accept | חובה | מיותרת |
| קבלת נתונים | recv על הסוקט ש-accept החזירה | recvfrom על הסוקט היחיד |
close | חובה בסיום | חובה בסיום |
תרחיש 3: שרת דיווחים ב-UDP על פורט 6100
מתכנתת יוצרת סוקט SOCK_DGRAM לשרת שאוסף דיווחי טמפרטורה, וקושרת אותו לפורט 6100.
הצעד הבא הוא recvfrom(), ישירות. היא לא צריכה listen, לא accept ולא connect.
כל דיווח שמגיע מביא איתו את כתובת החיישן ששלח אותו, והשרת מאשר אליו ב-sendto. אם תוסיף בטעות listen לפני הלולאה, הקריאה תחזיר שגיאה.
טעויות נפוצות
- גם שרת UDP צריך
listenואחריהaccept, אחרת הוא לא יקבל לקוחות. ב-UDP אין חיבורים, ולכן אין מה להאזין להם ואין מה לשלוף מתור.recvfromמקבלת דאטהגרמים ישירות. - ב-UDP אפשר לוותר על
bind. שרת UDP חייב לקשור את הסוקט לפורט הקבוע שלו, אחרת הלקוחות לא יודעים לאן לשלוח. - ב-UDP הנתונים יוצאים ישירות לרשת, בלי סוקט. כל תקשורת דרך מערכת ההפעלה מתחילה ב-
socket(), גם ב-UDP. - ב-UDP אין צורך לסגור את הסוקט. הסוקט הוא משאב של מערכת ההפעלה ויש לשחרר אותו ב-
close()בסיום, כמו ב-TCP. - לפני הדאטהגרם הראשון מכל לקוח מתבצעת מולו לחיצת יד עם SYN ו-ACK. לחיצת יד קיימת רק ב-TCP. ב-UDP הדאטהגרם הראשון הוא כבר הנתונים עצמם.
listenעל סוקט דאטהגרם הופכת אותו מעצמה ל-SOCK_STREAM. סוג הסוקט קבוע מרגע היצירה. הקריאה פשוט נכשלת, והסוקט נשאר UDP.
בדקו את עצמכם
חוץ מ-accept, איזו קריאה שרת TCP חייב לבצע ושרת UDP פשוט אינו צריך?
listen.
למה אין לשרת UDP שום שימוש ב-accept?
accept שולפת חיבור שהושלם מתור. ב-UDP אין חיבורים ואין תור כזה: כל דאטהגרם מגיע לבד ונקרא ב-recvfrom.
bind: קשירת הסוקט לכתובת ולפורט
מה bind עושה ולמה השרת לא יכול בלעדיה
bind() קושרת סוקט לכתובת IP מקומית ולפורט מקומי. מאותו רגע הצירוף הזה שמור לסוקט, וחבילות שמגיעות אליו שייכות לו.
לשרת זה הכרחי. שרת web שהלקוחות מחפשים בפורט 80 חייב לשבת בדיוק שם, ולכן הוא קורא ל-bind עם הפורט הזה.
בלי bind מפורשת, מערכת ההפעלה עלולה להצמיד לסוקט פורט אקראי, שאף לקוח לא יוכל לנחש. בשביל לקוח זה בסדר גמור, ובשביל שרת זה אומר שאיש לא ימצא אותו.
bind באה לפני listen: קודם קובעים איפה, ורק אז מתחילים להאזין. היא פעולה מקומית בלבד ואינה שולחת שום חבילה לרשת.
היא גם לא מאפסת הגדרות רשת, לא סוגרת חיבורים קיימים, לא מוחקת סוקט כדי לפתוח אחר במקומו, ולא יוצרת סוקטים נוספים. כל מה שהיא עושה הוא להצמיד סוקט אחד לכתובת ולפורט.
טעויות נפוצות
bindהיא שמשגרת את ה-SYN הראשון של החיבור.bindלא שולחת דבר. ה-SYN יוצא מצד הלקוח, בקריאה ל-connect.bindמאפסת את הגדרות הרשת של השרת ומנתקת חיבורים ישנים. היא נוגעת רק בסוקט שהועבר אליה, ורק כדי להצמיד אותו לכתובת ולפורט.- ב-
bindקובעים כמה חיבורים יוכלו לחכות בתור. גודל התור, ה-backlog, הוא הארגומנט שלlisten. bindיוצרת סוקט נפרד לכל לקוח שמתחבר. סוקט לכל לקוח נוצר רק ב-accept.
בדקו את עצמכם
שרת IMAP צריך לשבת בפורט 143. איזו קריאה מבטיחה את זה, ולמה היא חייבת לבוא לפני listen?
bind עם פורט 143. בלי קשירה מפורשת הלקוחות לא יודעים לאן לפנות, ו-listen מאזינה על הכתובת והפורט שהסוקט כבר קשור אליהם.
0.0.0.0, כתובת LAN או 127.0.0.1
למחשב אחד יש לא פעם כמה כתובות IP, אחת לכל ממשק רשת: למשל כתובת ברשת המשרד וכתובת ברשת של מכונות וירטואליות. בנוסף יש לכל מחשב את כתובת ה-loopback, 127.0.0.1, שאפשר להגיע אליה רק מתוך המחשב עצמו.
הכתובת שמעבירים ל-bind קובעת מאילו כתובות אפשר להגיע אל השרת:
| הכתובת ב-bind | חיבורים שיתקבלו |
|---|---|
0.0.0.0 (ב-C: INADDR_ANY) | חיבורים לכל אחת מכתובות ה-IP של המחשב, בכל הממשקים |
| כתובת LAN מסוימת | רק חיבורים שמכוונים לכתובת הזו |
127.0.0.1 | רק תוכניות שרצות על אותו מחשב, דרך ממשק ה-loopback |
ההרצה הבאה מעמידה את אותו שרת פעמיים, פעם קשור ל-127.0.0.1 ופעם ל-0.0.0.0, ובכל פעם מנסה להתחבר אליו גם דרך loopback וגם דרך כתובת ה-LAN של המחשב:
import socket, subprocess
lan_ip = subprocess.run(["hostname", "-I"], capture_output=True, text=True).stdout.split()[0]
def serve_and_probe(bind_ip, port):
srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
srv.bind((bind_ip, port))
srv.listen(5)
for target, label in (("127.0.0.1", "via 127.0.0.1"), (lan_ip, "via LAN address")):
c = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
c.connect((target, port))
print(f"bound to {bind_ip:9} | {label:15} | connected")
except OSError as e:
print(f"bound to {bind_ip:9} | {label:15} | {e}")
c.close()
srv.close()
serve_and_probe("127.0.0.1", 47310)
serve_and_probe("0.0.0.0", 47311)bound to 127.0.0.1 | via 127.0.0.1 | connected
bound to 127.0.0.1 | via LAN address | [Errno 111] Connection refused
bound to 0.0.0.0 | via 127.0.0.1 | connected
bound to 0.0.0.0 | via LAN address | connectedהשורה השנייה היא העיקר: הפורט מאזין, ובכל זאת חיבור לכתובת ה-LAN נדחה, כי הסוקט קשור רק ל-loopback. ברגע שהשרת נקשר ל-0.0.0.0, שתי הדרכים עובדות.
bind, הכתובת 0.0.0.0 פירושה 'כל הכתובות שלי'. אין לה קשר לטבלת הניתוב או ל-default route של תעבורה יוצאת, היא לא גורמת ליצירת סוקט נפרד לכל חיבור (את זה עושה accept), והיא לא מפנה שום דבר ל-127.0.0.1.תרחיש 4: שרת פיתוח שקשור ל-loopback
מפתח קושר שרת TCP ל-127.0.0.1, פורט 7070, קורא ל-listen ומחכה. עמית שלו, ממחשב אחר במשרד, פונה אל כתובת ה-LAN של המחשב הזה, באותו פורט.
ה-SYN מגיע לכתובת ה-LAN, ושם אין שום סוקט מאזין, כי הסוקט קשור רק ל-loopback. החיבור נדחה ולחיצת היד לא מושלמת.
הפתרון בצד השרת: bind לכתובת ה-LAN של המחשב או ל-0.0.0.0. הלקוח לא צריך לקשור את 7070 אצלו, ומערכת ההפעלה לא מנתבת בשקט פניות שהגיעו לכתובת ה-LAN אל ה-loopback.
הלקח: לא מספיק לדעת שהפורט פתוח להאזנה. צריך לדעת גם לאיזו כתובת הוא קשור.
טעויות נפוצות
- אם הפורט מאזין, כל מחשב ברשת יכול להתחבר אליו. כשהקשירה היא ל-127.0.0.1, רק תוכניות על אותה מכונה מגיעות לסוקט. פנייה לכתובת ה-LAN נדחית, כמו שראיתם בפלט.
bindל-0.0.0.0 מפנה את כל החיבורים לכתובת ה-loopback. 0.0.0.0 פירושה כל כתובות המחשב. ה-loopback היא רק אחת מהן.bindל-0.0.0.0 משנה את ה-default route של המחשב. בקריאתbindאין לכתובת הזו שום קשר לניתוב. היא רק אומרת על אילו כתובות מקומיות השרת מקבל חיבורים.- קשירה ל-0.0.0.0 מייצרת סוקט לכל חיבור, וקשירה לכתובת מסוימת משאירה את כולם על סוקט אחד. בשני המקרים יש סוקט האזנה אחד, ובשני המקרים
acceptמחזירה סוקט חדש לכל לקוח.
בדקו את עצמכם
שרת מדפסות צריך לקבל עבודות מכל המחשבים ברשת. לאיזו כתובת כדאי לו לעשות bind?
ל-0.0.0.0, שמכסה את כל כתובות המחשב, או לכתובת ה-LAN שלו.
כלי ניהול פנימי האזין רק על 127.0.0.1. מאיפה אפשר להגיע אליו?
רק תוכניות שרצות על אותו מחשב.
כש-bind נכשלת: ארבע שגיאות ומה כל אחת אומרת
רוב הכישלונות של bind() נופלים לאחת משלוש סיבות, ויש סיבה רביעית נדירה יותר. כולן מופיעות בהרצה הבאה, תחת משתמש רגיל (uid 1000) ב-Linux:
import socket
def try_bind(label, addr):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.bind(addr)
print(label, "-> OK")
return s
except OSError as e:
print(label, "->", e)
first = try_bind("1st bind 0.0.0.0:47510", ("0.0.0.0", 47510))
first.listen(5)
try_bind("2nd bind 0.0.0.0:47510", ("0.0.0.0", 47510))
try_bind("bind 0.0.0.0:80 as uid 1000", ("0.0.0.0", 80))
try_bind("bind 10.99.99.99:47610", ("10.99.99.99", 47610))
try_bind("bind 0.0.0.0:8080 as uid 1000", ("0.0.0.0", 8080))1st bind 0.0.0.0:47510 -> OK
2nd bind 0.0.0.0:47510 -> [Errno 98] Address already in use
bind 0.0.0.0:80 as uid 1000 -> [Errno 13] Permission denied
bind 10.99.99.99:47610 -> [Errno 99] Cannot assign requested address
bind 0.0.0.0:8080 as uid 1000 -> OKהסיבה הראשונה: הצירוף כבר תפוס. לכל צירוף של כתובת ופורט יש בעלים אחד בלבד, ולכן ה-bind השנייה נכשלה ב-Address already in use, שקיצורה EADDRINUSE.
הסתכלו שוב על השורה השנייה בפלט. הסוקט הראשון קרא ל-listen ועוד לא קיבל אף לקוח, וזה כבר הספיק: אין כאן המתנה עד שהפורט יתפנה, אין חלוקת תנועה בין שני הסוקטים, ואין מעבר שקט למספר אחר, אלא כישלון מיידי של הקריאה השנייה.
שיתוף אמיתי של פורט בין סוקטים אפשרי רק עם אפשרויות סוקט מיוחדות, שלא הוגדרו כאן. בפועל, מי שתופס את הפורט הוא בדרך כלל תהליך אחר על אותו מחשב, או עותק קודם של אותו שרת שעדיין רץ.
פורט הוא משאב של המחשב שהתוכנית רצה עליו. אם מחשב אחר ברשת משתמש באותו מספר פורט לשירות שלו, זה לא משפיע כלל על ה-bind אצלכם.
הסיבה השנייה: TIME_WAIT. כשחיבור TCP נסגר, הצד שסגר ראשון לא שוכח אותו מייד: ליבת מערכת ההפעלה משאירה אותו זמן מה במצב TIME_WAIT.
אם שרת קרס או נסגר והופעל שוב מייד, החיבורים הישנים שלו עדיין נמצאים ב-TIME_WAIT ומחזיקים את הפורט. התוצאה מבלבלת: Address already in use, למרות שאף תהליך לא מאזין לפורט.
הפתרון המקובל הוא להדליק את האפשרות SO_REUSEADDR על הסוקט, ובהכרח לפני ה-bind:
int on = 1;
/* must come before bind(), or it has no effect on this bind */
if (setsockopt(lsock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
perror("setsockopt");
if (bind(lsock, (struct sockaddr *)&local, sizeof(local)) < 0)
perror("bind");בהרצה הבאה אותו שרת מקבל לקוח, סוגר ראשון את החיבור ונופל, ואז עולה שוב על אותו פורט. פעם אחת הקוד שלו לא מגדיר את האפשרות, ופעם אחת מגדיר אותה בכל הפעלה:
import socket, subprocess
def start_server(port, reuse):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if reuse:
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # before bind()
s.bind(("0.0.0.0", port))
s.listen(5)
return s
def serve_one_client_then_crash(port, reuse):
srv = start_server(port, reuse)
cli = socket.create_connection(("127.0.0.1", port))
conn, _ = srv.accept()
conn.close() # the server closes first, so its end of the connection enters TIME_WAIT
cli.close()
srv.close() # the process "dies": no socket listens on the port now
for port, reuse in ((47420, False), (47421, True)):
serve_one_client_then_crash(port, reuse)
out = subprocess.run(["ss", "-tanH", f"sport = :{port}"], capture_output=True, text=True).stdout
print(f"port {port}, SO_REUSEADDR={reuse}: left behind {[w for w in out.split() if w.isupper()]}")
try:
start_server(port, reuse) # immediate restart of the same program
print(" restart -> listening again")
except OSError as e:
print(" restart ->", e)port 47420, SO_REUSEADDR=False: left behind ['TIME-WAIT']
restart -> [Errno 98] Address already in use
port 47421, SO_REUSEADDR=True: left behind ['TIME-WAIT']
restart -> listening againבשני המקרים נשאר חיבור ב-TIME-WAIT (כך ss כותב את שם המצב) ואף סוקט לא האזין. רק השרת שמגדיר SO_REUSEADDR הצליח לחזור לעבוד.
הסיבה השלישית: הרשאות. במערכות Unix הפורטים מתחת ל-1024 שמורים לתהליכים בעלי הרשאות מיוחדות, כמו root, ולכן משתמש רגיל קיבל Permission denied על פורט 80.
יש שני פתרונות: להריץ את השרת עם ההרשאות המתאימות, או לבחור פורט גבוה. ההרצה מראה שאותו משתמש קשר את 8080 בלי שום בעיה.
הסיבה הרביעית, הנדירה: כתובת IP שלא שייכת לאף ממשק במחשב, כמו 10.99.99.99 בהרצה, נותנת Cannot assign requested address. אי אפשר להאזין על כתובת שאין למחשב.
| הודעת השגיאה | מה גרם לה |
|---|---|
| Address already in use | הצירוף של כתובת ופורט כבר בבעלות סוקט אחר, או שחיבור ישן ב-TIME_WAIT עדיין מחזיק את הפורט |
| Permission denied | ניסיון לקשור פורט מתחת ל-1024 בלי הרשאות מיוחדות |
| Cannot assign requested address | הכתובת שבקריאה לא שייכת למחשב |
| Connection refused | זו בכלל לא שגיאה של bind: היא מתקבלת אצל לקוח שמתחבר לפורט שאין בו מאזין |
תרחיש 5: שני שירותים מתחרים על פורט 9200
שירות א' קשר את 0.0.0.0 ופורט 9200 וכבר קרא ל-listen. שירות ב', על אותו מחשב ובלי אפשרויות סוקט מיוחדות, קורא עכשיו ל-bind לאותו צירוף.
הקריאה של ב' נכשלת מייד ב-Address already in use. היא לא נשארת תקועה עד ש-א' יקרא ל-accept, והשניים לא מתחלקים בפורט.
Permission denied לא רלוונטי כאן: הוא נובע מהרשאות על פורט נמוך, לא מפורט שמישהו אחר כבר תפס.
תרחיש 6: שרת שקם מקריסה
שרת TCP קרס, ומנגנון ההפעלה האוטומטי הרים אותו שוב תוך שנייה. ה-bind נכשלת ב-Address already in use, ו-ss לא מראה שום סוקט מאזין על הפורט.
ההסבר הסביר: חיבורים מהריצה הקודמת עדיין ב-TIME_WAIT. התיקון הוא להוסיף לקוד השרת SO_REUSEADDR לפני ה-bind.
מה לא יעזור: הגדלת ה-backlog, כי הוא נקבע ב-listen שבאה אחרי bind ואין לו קשר לפורט התפוס. וקריאה ל-accept לפני bind פשוט לא אפשרית.
טעויות נפוצות
- חומת האש חוסמת את הפורט, ולכן
bindנכשלת. חומת אש מסננת חבילות שעוברות ברשת. היא לא משפיעה על עצם הקריאה המקומית ל-bind. - פורט המקור של לקוח ישן, שהתחבר פעם לשרת, עדיין תפוס, ובגללו ה-
bindבשרת מחזירהEADDRINUSE. פורט המקור של לקוח שייך לצד הלקוח ואין לו קשר לפורט שהשרת מנסה לקשור. - אחרי קריסה הסוקט הישן נשאר במצב LISTEN וחוסם את הפורט. תהליך שקרס כבר לא מחזיק סוקט מאזין. מה שנשאר הם חיבורים ב-TIME_WAIT.
- ניסיון לקשור פורט מתחת ל-1024 נכשל ב-Address already in use. פורט נמוך בלי הרשאות נותן Permission denied. Address already in use פירושה שהצירוף תפוס.
- פורט 80 אסור לשרת כי הוא לא בטווח הפורטים הזמניים. שרתים לא חייבים להשתמש בטווח הזמני, ורובם בכלל יושבים על פורט ידוע. הבעיה עם 80 היא רק ההרשאות.
bindלפורט תפוס מחזירה Connection refused. Connection refused היא שגיאה של לקוח ב-connect.bindלפורט תפוס מחזירה Address already in use.
בדקו את עצמכם
בחשבון לא מורשה ב-Linux, bind לפורט 25 מחזירה Permission denied. מה הסיבה, ומה אפשר לעשות?
פורטים מתחת ל-1024 דורשים הרשאות מיוחדות. אפשר להריץ עם הרשאות מתאימות, או לעבור לפורט גבוה כמו 2525.
שרת שהופעל מחדש מקבל Address already in use, אבל אף תהליך לא מאזין לפורט. מה כנראה קורה, ומה התיקון המקובל?
חיבורים מהריצה הקודמת נמצאים ב-TIME_WAIT ומחזיקים את הפורט. מגדירים SO_REUSEADDR על הסוקט לפני ה-bind.
במחשב A שרת קשור לפורט 8000. האם זה מונע ממחשב B ברשת לקשור גם הוא את פורט 8000?
לא. פורט הוא משאב של המחשב עצמו, ולכל מחשב מרחב פורטים משלו.
listen וה-backlog
מה listen משנה בסוקט
listen() הופכת סוקט רגיל לסוקט פסיבי, כלומר לסוקט של שרת שממתין לפניות. היא עושה שני דברים: מעבירה אותו למצב האזנה, וקובעת את ה-backlog, גודל תור ההמתנה.
מהרגע הזה הליבה (kernel) של מערכת ההפעלה מטפלת בעצמה בלחיצות היד מול לקוחות שפונים לסוקט. התוכנית לא שולחת אף SYN-ACK ולא מעורבת בכלל בשלב הזה.
סוקט שעדיין לא עבר listen לא מקבל חיבורים, גם אם הוא כבר קשור לפורט. וגם accept דורשת סוקט מאזין: על סוקט שרק עבר bind היא נכשלת. שני המקרים בהרצה:
import socket
srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
srv.bind(("127.0.0.1", 47710))
early = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
early.connect(("127.0.0.1", 47710)) # bound, but listen() not called yet
except OSError as e:
print("before listen:", e)
srv.listen(5) # no accept() yet
cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cli.connect(("127.0.0.1", 47710))
print("connect returned before any accept()")
cli.sendall(b"ORDER 1138") # sent while the connection waits in the queue
conn, peer = srv.accept() # take the ready connection out of the queue
print("accept gave a new socket:", conn.fileno() != srv.fileno())
print("its local port:", conn.getsockname()[1], "| listening port:", srv.getsockname()[1])
print("first recv:", conn.recv(100))before listen: [Errno 111] Connection refused
connect returned before any accept()
accept gave a new socket: True
its local port: 47710 | listening port: 47710
first recv: b'ORDER 1138'השורה הראשונה מראה שלקוח שפנה לפורט קשור אך לא מאזין נדחה. השורה האחרונה של ההרצה בחלק על accept בהמשך מראה את הצד השני: accept על סוקט שלא עבר listen נכשלת ב-Invalid argument.
listen לא באה במקום bind, אלא אחריה: קודם קושרים, אחר כך מאזינים. והיא גם לא עושה את עבודתן של הקריאות האחרות: היא לא שולפת חיבורים מהתור (accept), לא פונה לשרת מרוחק (connect) ולא קובעת כתובת (bind).
טעויות נפוצות
listenהיא הקריאה שמצמידה את הסוקט לכתובת ולפורט. את זה עושהbind, לפניlisten.listenמחזירה סוקט חדש עבור חיבור שממתין בתור. זו העבודה שלaccept.listenלא מחזירה סוקט.listenפותחת חיבור לשרת מרוחק. חיבור יוצא נפתח ב-connect, בצד הלקוח.listenסוגרת את הסוקט לתקשורת נוספת. ההפך: היא פותחת אותו לקבלת חיבורים נכנסים.listenמסננת מחשבים לא מוכרים לפי כתובת MAC. אין לה שום תפקיד של סינון או זיהוי. היא רק מעבירה למצב האזנה וקובעת את גודל התור.
בדקו את עצמכם
מה שני הדברים ש-listen(fd, 32) עושה?
מסמנת את הסוקט כסוקט פסיבי שמאזין לחיבורים נכנסים, וקובעת שעד 32 חיבורים שהושלמו יכולים להמתין בתור ל-accept.
ה-backlog: תור החיבורים שהושלמו
מכיוון שהליבה משלימה את לחיצת היד בעצמה, חיבור יכול להיות מוכן הרבה לפני שהתוכנית מגיעה ל-accept. החיבור הזה צריך לחכות איפשהו.
המקום הזה הוא תור החיבורים שהושלמו, והארגומנט השני של listen קובע את גודלו:
/* at most 32 fully established connections may wait here until accept() takes them */
if (listen(lsock, 32) < 0)
perror("listen");ה-backlog הוא אם כך מגבלת כמות: כמה חיבורים שכבר סיימו את לחיצת היד יכולים לחכות בבת אחת שהתוכנית תוציא אותם ב-accept. הם יוצאים לפי סדר ההמתנה, וה-backlog לא נותן לאף אחד מהם עדיפות.
accept.חשוב לדעת גם מה ה-backlog לא קובע:
- לא כמה לקוחות השרת משרת בו זמנית: חיבור שיצא מהתור ב-
acceptכבר לא נספר, והשרת יכול להחזיק אלפים כאלה. - לא את גודל ה-buffer של כל חיבור, ולא זמן המתנה בשניות.
- לא כמה פעמים מותר לקרוא ל-
accept: אפשר לקרוא לה שוב ושוב לאורך כל חיי השרת. - לא אילו כתובות IP מורשות להתחבר, ולא כמה פעמים יישלח SYN-ACK שוב ללקוח שלא ענה.
התור מתמלא משתי סיבות: גל של בקשות חיבור שמגיעות בבת אחת, או שרת שעסוק מדי ולכן קורא ל-accept לאט מדי. חיבורים ב-TIME_WAIT לא נמצאים בתור הזה בכלל, כי הם כבר נסגרו.
כשהתור מלא, חיבור חדש פשוט לא נכנס, וזה נמשך עד שקריאה ל-accept מוציאה ממנו אחד. מה שקורה לבקשה החדשה תלוי במערכת ההפעלה: או שהיא נזרקת והלקוח ישלח שוב, או שהיא נדחית, למשל ב-RST.
שלושה דברים לא קורים בתור מלא: הסוקט המאזין לא נסגר, התור לא גדל מעצמו מעבר לגודל שנקבע, והשרת לא זורק חיבורים ותיקים שהושלמו כדי לפנות מקום לחדשים.
listen, ולעומתו התור של מי שעוד תקועים באמצע לחיצת היד ומחכים ל-ACK האחרון.ההרצה מתחילת החלק הקודם מראה את התור בפעולה: הלקוח קרא ל-connect אחרי listen ולפני כל accept, והקריאה חזרה בהצלחה. הוא גם שלח מייד ORDER 1138, והטקסט חיכה בליבה עד שה-recv הראשון אחרי accept קרא אותו.
תרחיש 7: לקוח שמגיע לפני accept
השרת כבר עבר bind ו-listen עם backlog של 32, אבל עדיין טוען קובצי הגדרות ולא הגיע ל-accept. לקוח קורא ל-connect.
הלקוח שולח SYN, הליבה של השרת עונה ב-SYN-ACK, והלקוח מחזיר ACK שסוגר את הלחיצה. החיבור מושלם ונכנס לתור, ו-connect אצל הלקוח חוזרת בהצלחה.
אין פסק זמן ואין Connection refused. מה שהלקוח שולח בינתיים נשמר בליבה של השרת ויגיע לתוכנית אחרי accept, והלקוח לא צריך להתחבר שוב.
כשהשרת יגיע סוף סוף ל-accept, היא רק תוציא את החיבור המוכן מהתור ותחזיר עבורו סוקט.
תרחיש 8: תור מלא בשרת עמוס
שרת עם backlog של 4 עסוק בחישוב כבד ומתעכב בין קריאות ה-accept. ארבעה חיבורים מושלמים כבר מחכים, ואז מגיע חמישי.
התור מלא, והחיבור החמישי לא נכנס. לפי מערכת ההפעלה, בקשתו נזרקת והלקוח ינסה שוב, או שהיא נדחית.
רק כשהשרת יקרא ל-accept ויפנה מקום, חיבורים חדשים יוכלו להיכנס לתור שוב.
טעויות נפוצות
connectשל הלקוח תיתקע או תיכשל כל עוד השרת לא קרא ל-accept. הליבה של השרת משלימה את לחיצת היד מייד אחריlisten, ו-connectמצליחה עוד לפניaccept.- מרגע ש-
listenנקראה, לחיצת היד מתבטלת והחיבור נרשם ישר בתור. לחיצת היד מתבצעת במלואה. ההבדל הוא רק שהליבה מבצעת אותה, ולא התוכנית. - מה שהלקוח משדר בזמן שהחיבור עוד ממתין בתור נזרק. הליבה שומרת אותם בחוצץ של החיבור הממתין, והתוכנית קוראת אותם אחרי
accept. - השרת שולח SYN-ACK רק ברגע שהתוכנית קוראת ל-
accept. את ה-SYN-ACK שולחת הליבה ברגע שמגיע SYN לסוקט מאזין, בלי לחכות ל-accept. - הלקוח מקבל RST כי אף אחד עוד לא קרא ל-
accept. RST נשלח כשאין סוקט מאזין על הפורט. כאן יש סוקט מאזין, ולכן החיבור מתקבל לתור. - כשהתור מתמלא, הסוקט המאזין נסגר. הסוקט המאזין נשאר פתוח ומקבל חיבורים חדשים ברגע שמתפנה מקום.
בדקו את עצמכם
השרת קרא ל-listen(fd, 8). מה בדיוק המספר 8 מגביל?
את מספר החיבורים שכבר השלימו את לחיצת היד בליבה ומחכים בתור עד שהתוכנית תוציא אותם ב-accept.
שרת קרא ל-listen אבל עוד לא ל-accept, והתור ריק. לקוח קורא ל-connect ושולח 200 בתים. מה קורה ל-connect ולנתונים?
connect מצליחה: הליבה מסיימת את שלושת השלבים, והחיבור מחכה בתור. 200 הבתים נשמרים בליבה, והשרת יקרא אותם ב-recv אחרי accept.
שרת מחזיק 5,000 לקוחות פעילים עם backlog של 128. האם יש כאן סתירה?
לא. ה-backlog מגביל רק חיבורים שממתינים ל-accept, וחיבורים שכבר יצאו מהתור לא נספרים בו.
accept: סוקט נפרד לכל לקוח
מה accept מחזירה ומה קורה לסוקט המאזין
כדי להבין את accept(), כדאי קודם לשחזר מה כבר התרחש עד שהתוכנית מגיעה לשורה שלה:
- הלקוח קרא ל-
connect, ומערכת ההפעלה שלו שלחה SYN. - הליבה של השרת השיבה ב-SYN-ACK בשם הסוקט המאזין.
- ה-ACK של הלקוח הגיע, והחיבור עבר למצב ESTABLISHED.
- החיבור המוכן נרשם בתור של הסוקט המאזין, ולפעמים כבר מחכים בו גם הבתים הראשונים שהלקוח שלח.
כלומר עבודת הרשת כולה נגמרה, ול-accept נשאר תפקיד אחד: להוציא מהתור את החיבור הבא בתור ולתת לתוכנית סוקט חדש, ששייך לחיבור הזה בלבד. כל השאר נעשה במקום אחר:
| מה שנראה כאילו קורה ב-accept | מי עושה את זה באמת |
|---|---|
| SYN, SYN-ACK וה-ACK האחרון | הליבה, עוד לפני ש-accept נקראה. accept לא משדרת שום חבילה, גם לא ACK נוסף |
| האזנה לפורט | listen, על הסוקט המקורי בלבד. הסוקט החדש לא מאזין לשום פורט |
| קריאת הנתונים הראשונים מהלקוח | recv() על הסוקט החדש, אחרי ש-accept חזרה |
| בדיקת כתובת הלקוח או חסימת מקורות | לא תפקיד של accept: היא מקבלת כל חיבור שהשלים את לחיצת היד |
אחרי accept יש בשרת שני סוגים של סוקטים, ולכל אחד תפקיד אחר:
| הסוקט | בשביל מה הוא קיים | מצבו אחרי accept |
|---|---|---|
| סוקט ההאזנה | לקבל לקוחות חדשים | ממשיך להאזין, פתוח, על אותו פורט |
| הסוקט ש-accept החזירה | לשלוח ולקבל נתונים מול לקוח אחד | משרת רק את הלקוח הזה |
סוקט ההאזנה לא מתגייס לשיחה עם הלקוח הראשון, וגם סיום השיחה הזו לא סוגר אותו. בזכות זה השרת מקבל עוד ועוד לקוחות בלי listen נוספת, וחיבורים חדשים פשוט מחכים בתור ל-accept הבאה.
ההרצה מהחלק על listen כבר הראתה פרט חשוב: לסוקט ש-accept החזירה יש אותו פורט מקומי, 47710, כמו לסוקט ההאזנה. מה שמבדיל בין הסוקטים החדשים הוא הצד של הלקוח.
כל סוקט כזה מזוהה לפי שני הקצוות של החיבור: הכתובת והפורט בצד הלקוח, ולצדם הכתובת והפורט בצד השרת. זה בדיוק ה-4-tuple. לכן לקוחות רבים יכולים להיות מחוברים לאותו פורט שרת בבת אחת.
דוגמה במספרים: המחשב 172.16.4.31 פנה מהפורט 51822 אל השרת 198.51.100.7 בפורט 8443. בסוקט ש-accept החזירה, הקצה המקומי הוא 198.51.100.7:8443 והקצה המרוחק הוא 172.16.4.31:51822, כך שהמספר 51822 מופיע שם רק כפרט שמתאר את הלקוח, ואף פעם לא כפורט של השרת.
והערך שחוזר מ-accept הוא סוקט, לא רק כתובת. אפשר לבקש ממנה גם את כתובת הלקוח, דרך שני הארגומנטים הנוספים שבדוגמת השרת קיבלו NULL, אבל זה מידע נוסף ולא הערך המוחזר.
struct sockaddr_in client;
socklen_t clen = sizeof(client);
int conn = accept(lsock, (struct sockaddr *)&client, &clen); /* return value: a new socket */
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &client.sin_addr, ip, sizeof(ip)); /* optional: who connected */
printf("client %s:%d on fd %d\n", ip, ntohs(client.sin_port), conn);טעויות נפוצות
acceptמחזירה את סוקט ההאזנה עצמו, שעובר לשרת את הלקוח. היא מחזירה סוקט חדש. סוקט ההאזנה נשאר כפי שהיה.- אחרי
acceptסוקט ההאזנה נסגר, וצריךlistenחדשה לפני הלקוח הבא. סוקט ההאזנה ממשיך להאזין, ולקוחות נוספים מחכים בתור שלו ל-acceptהבאה. - את התשובות ללקוח שולחים דרך סוקט ההאזנה. שליחה וקבלה מול לקוח נעשות בסוקט ש-
acceptהחזירה עבורו. - הפורט המקומי של הסוקט החדש הוא הפורט הזמני שממנו הלקוח יצא. הפורט המקומי שלו הוא אותו פורט של סוקט ההאזנה. הפורט הזמני שייך לצד הלקוח.
- מכיוון שהסוקט החדש מזוהה רק בפורט המקומי, אין מקום ללקוח נוסף על אותו פורט. הזיהוי הוא לפי ארבעת הערכים, וצד הלקוח שונה בין החיבורים.
acceptשולחת ACK נוסף כדי לסגור את לחיצת היד. לחיצת היד כבר הושלמה בליבה לפני ש-acceptנקראה.acceptהיא שמנהלת מול הלקוח את ה-SYN, ה-SYN-ACK וה-ACK. הליבה ביצעה אותם כבר.acceptרק מוציאה מהתור חיבור מוכן.- הסוקט ש-
acceptמחזירה נוצר כדי להאזין על פורט אחר. הוא לא מאזין לשום דבר. הוא משמש לתקשורת עם לקוח אחד בלבד. acceptקושרת את הסוקט לכתובת ולפורט. קשירה היא תפקידה שלbind, שנקראת הרבה לפניaccept.
בדקו את עצמכם
שרת צ'אט קיבל עכשיו את המשתמש הראשון ב-accept. דרך איזה סוקט ישלח לו הודעות, ובאיזה סוקט יחכה למשתמש השני?
את ההודעות ישלח דרך הסוקט החדש ש-accept החזירה. למשתמש השני יחכה בסוקט ההאזנה המקורי.
שרת על פורט 8443 קיבל שלושה לקוחות. כמה סוקטים פתוחים בשרת, ומה הפורט המקומי של כל אחד?
ארבעה: סוקט ההאזנה ושלושה סוקטים מ-accept. לכולם אותו פורט מקומי, 8443, והם נבדלים בכתובת ובפורט של הלקוח.
למה accept לא צריכה לשלוח שום חבילה ללקוח?
כי כשהיא נקראת, לחיצת היד כבר הסתיימה בליבה, והחיבור רק מחכה בתור.
תור ריק: accept חוסמת, או חוזרת מייד במצב non-blocking
מה יקרה אם השרת יקרא ל-accept כשאף לקוח עוד לא התחבר והתור ריק?
במצב ברירת המחדל של סוקט, המצב החוסם (blocking), הקריאה נחסמת: התוכנית נעצרת באותה שורה ולא ממשיכה. ברגע שחיבור מושלם נכנס לתור, מערכת ההפעלה מעירה אותה ו-accept חוזרת עם סוקט חדש.
מבחינת סוקט חוסם, תור ריק הוא מצב רגיל ולא תקלה. בהרצה שבהמשך ה-accept הראשונה פשוט ישבה חצי שנייה עד שהתחבר לקוח, ואילו היה מגיע אחרי שעה, היא הייתה יושבת שעה: אין שעון שמכריח אותה לוותר, ואין חזרה בידיים ריקות או עם שגיאה.
אפשר להגדיר את הסוקט כ-non-blocking (לא חוסם). אז accept על תור ריק חוזרת לתוכנית מייד, עם שגיאה שאומרת שכרגע אין חיבור.
import socket, threading, time
srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
srv.bind(("127.0.0.1", 47810))
srv.listen(5)
# Blocking (the default): accept() waits until a client completes the handshake
threading.Timer(0.5, lambda: socket.create_connection(("127.0.0.1", 47810))).start()
t0 = time.monotonic()
a, _ = srv.accept()
print("blocking accept waited at least 0.5 s:", time.monotonic() - t0 >= 0.5)
# Non-blocking: accept() returns at once when the queue is empty
srv.setblocking(False)
try:
srv.accept()
except BlockingIOError as e:
print("non-blocking accept on an empty queue:", e)
# The listening socket keeps working for the next client
srv.setblocking(True)
b_cli = socket.create_connection(("127.0.0.1", 47810))
b, _ = srv.accept()
print("second client accepted, listening socket still open:", srv.fileno() != -1)
print("three different descriptors:", len({srv.fileno(), a.fileno(), b.fileno()}) == 3)
plain = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
plain.bind(("127.0.0.1", 47811))
try:
plain.accept() # bound, but never listen()
except OSError as e:
print("accept without listen:", e)blocking accept waited at least 0.5 s: True
non-blocking accept on an empty queue: [Errno 11] Resource temporarily unavailable
second client accepted, listening socket still open: True
three different descriptors: True
accept without listen: [Errno 22] Invalid argumentב-Linux השגיאה של מצב non-blocking היא EAGAIN (ההודעה Resource temporarily unavailable). השורה האחרונה היא תזכורת מהחלק על listen: על סוקט שלא האזין, accept נכשלת תמיד.
היתרון של non-blocking: השרת לא נתקע. הוא מטפל בעבודה אחרת, ומדי פעם בודק אם הגיע חיבור חדש.
אל תייחסו למצב הזה יותר ממה שהוא: זה דגל על הסוקט שקובע רק אם הקריאה ממתינה או חוזרת, ואין בו שום מנגנון של threads. לחיצת היד נשארת עניין של הליבה ובת שלושה שלבים, וכל חיבור עדיין יוצא מ-accept עם סוקט משלו, כפי ששלושת המזהים השונים בהרצה מראים.
תרחיש 9: accept על תור ריק
שרת קבצים כבר עבר bind ו-listen, ועכשיו קורא ל-accept על סוקט רגיל. עדיין לא הגיע אף לקוח.
הקריאה נחסמת והתוכנית ממתינה. רק כשיופיע לקוח, והליבה תסיים איתו את שלושת השלבים, יהיה בתור חיבור, ואז accept תשתחרר ותחזיר סוקט.
אילו הסוקט היה non-blocking, accept הייתה חוזרת מייד עם שגיאה, והשרת היה ממשיך למשימה אחרת ומנסה שוב מאוחר יותר.
טעויות נפוצות
acceptעל תור ריק נכשלת מייד בשגיאה. בסוקט רגיל היא נחסמת עד שמגיע חיבור. שגיאה מיידית מתקבלת רק במצב non-blocking.acceptחוזרת מייד עם ערך ריק, ולכן צריך לקרוא לה בלולאה בלי הפסקה. זו התנהגות של מצב non-blocking בלבד. בסוקט רגיל הקריאה פשוט ממתינה.- במצב non-blocking נפתח thread חדש בכל קריאה ל-
accept. המצב רק קובע אם הקריאה ממתינה או חוזרת מייד. הוא לא יוצר threads. - non-blocking מקצר את לחיצת היד לשני שלבים. לחיצת היד מתבצעת בליבה ונשארת בת שלושה שלבים. מצב הסוקט לא משפיע עליה.
בדקו את עצמכם
שרת משחק צריך לעדכן את מצב המשחק כמה עשרות פעמים בשנייה, וגם לקבל שחקנים חדשים. למה accept חוסמת תפריע לו, ומה הפתרון?
accept חוסמת תעצור את התוכנית עד שיתחבר שחקן, והעדכונים ייעצרו. עם סוקט non-blocking היא חוזרת מייד כשאין חיבור, והשרת ממשיך בעבודתו ובודק שוב בסבב הבא.
לחיצת היד התלת-שלבית: SYN ו-ACK
שלוש החבילות שפותחות חיבור
TCP לא מוסר אף בית של נתוני יישום עד ששני הצדדים הסכימו שקיים ביניהם חיבור. ההסכמה נבנית משלוש חבילות, ולכן התהליך נקרא לחיצת יד תלת-שלבית (Three-Way Handshake, ובכתיב מקוצר 3-Way Handshake).
היוזם הוא תמיד הלקוח: ברגע שהתוכנית שלו קוראת ל-connect(), הליבה מוציאה את החבילה הראשונה. דמיינו שני קשרים ברדיו: 'אלפא לבראבו, אני סופר מ-x, איך שומע?', 'בראבו לאלפא, קלטתי עד x. אני סופר מ-y, איך שומע?', 'אלפא לבראבו, קלטתי עד y'.
- SYN, מהלקוח לשרת: בקשה לפתוח חיבור, ובתוכה נקודת ההתחלה של הספירה של הלקוח, x.
- SYN-ACK, מהשרת ללקוח: חבילה בודדת שבה דולקים שני דגלים. החלק של ACK מאשר את מה שהלקוח הכריז, והחלק של SYN מכריז על נקודת ההתחלה של השרת, y.
- ACK, מהלקוח לשרת: האישור האחרון, הפעם על ה-SYN של השרת.
הלקוח עובר ל-ESTABLISHED ברגע שהוא שולח את החבילה השלישית, והשרת עובר לשם כשהיא מגיעה אליו. מהרגע הזה אפשר להעביר נתונים, ו-TCP דואג שיגיעו בשלמותם ובסדר.
Client 192.168.50.10 Server 192.168.50.20
(SYN_SENT) ---- [SYN] seq=x --------------> (LISTEN)
<--- [SYN, ACK] seq=y ack=x+1 ------- (SYN_RECEIVED)
(ESTABLISHED) ---- [ACK] seq=x+1 ack=y+1 ----> (ESTABLISHED)הנקודה שמבלבלת הכי הרבה היא השלב האמצעי. SYN-ACK אינו זוג חבילות שיוצאות זו אחר זו, אלא מקטע אחד שנושא שני דגלים. הוא עונה 'כן' לבקשה של הלקוח, ובאותה נשימה מבקש חיבור בכיוון ההפוך.
בכלים כמו netstat, ss או Wireshark השלבים מופיעים כמצבים של החיבור:
| מצב | מתי הוא מופיע |
|---|---|
| LISTEN | בצד השרת: סוקט שקרא ל-listen() ומחכה שיגיע SYN |
| SYN_SENT | בצד הלקוח: ה-SYN יצא, וה-SYN-ACK עוד לא הגיע |
| SYN_RECEIVED | בצד השרת: הגיע SYN ונשלח עליו SYN-ACK, אבל ה-ACK האחרון עוד לא חזר. זה החיבור החצי-פתוח |
| ESTABLISHED | אצל שני הצדדים: שלוש החבילות עברו, והחיבור פעיל |
- SYN_RECEIVED מופיע בחלק מהכלים בכתיב המקוצר SYN_RCVD. זה אותו מצב.
- חיבור שהשלים את שלוש החבילות כבר נמצא ב-ESTABLISHED, גם אם תוכנית השרת עוד לא הגיעה לקריאה ל-
accept(). - חיבור שכבר נסגר עובר למצבים אחרים, למשל TIME_WAIT, ולא חוזר לאף אחד מהמצבים שבטבלה.
- כל עוד לא הגיע לשרת שום SYN, אין אצלו שום רשומה של החיבור הזה.
את הנקודה השנייה אפשר לראות בעיניים. בתוכנית הבאה השרת קורא ל-listen() ולא קורא ל-accept() אף פעם, ובכל זאת הלקוח מתחבר. הורץ ב-Linux, ו-ss מקצר את ESTABLISHED ל-ESTAB:
import socket, subprocess
srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
srv.bind(("127.0.0.1", 7400))
srv.listen(4) # passive socket, accept() is never called
cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cli.connect(("127.0.0.1", 7400)) # the kernel completes SYN, SYN-ACK, ACK
print("connect() returned")
out = subprocess.run(["ss", "-tan", "sport = :7400 or dport = :7400"],
capture_output=True, text=True).stdout
for line in out.splitlines()[1:]: # skip the header line
f = line.split()
print(f"{f[0]:7} {f[3]:17} {f[4]}")connect() returned
LISTEN 127.0.0.1:7400 0.0.0.0:*
ESTAB 127.0.0.1:7400 127.0.0.1:60904
ESTAB 127.0.0.1:60904 127.0.0.1:7400connect() חזר בהצלחה ושני קצוות החיבור במצב ESTAB, למרות שאף שורה בשרת לא קיבלה את הלקוח. את לחיצת היד מבצעת הליבה בעצמה; accept() רק שולף מהתור חיבור שכבר מוכן. פורט המקור של הלקוח, 60904, נבחר אוטומטית ומשתנה בין הרצות.
טעויות נפוצות
- אחרי ה-SYN-ACK השרת שולח RST או FIN, או שהלקוח שולח PSH. החבילה שבאה אחרי SYN-ACK היא ACK של הלקוח. RST ו-FIN הם דגלים של סיום חיבור, ו-PSH עוסק במסירת נתונים לאפליקציה ולא בהקמה.
- כשמגיע SYN, השרת מתעלם ממנו ושולח SYN חדש משלו. השרת מגיב ל-SYN שקיבל. התגובה שלו מאשרת אותו ובאותה חבילה מכריזה גם על ה-SYN של השרת.
- השרת עונה ב-ACK רגיל ואז מחכה שהלקוח ישלח SYN נוסף. האישור וה-SYN של השרת יוצאים יחד, בחבילה השנייה. לא נדרש SYN שני מהלקוח.
- הלקוח פותח חיבור בשלוש חבילות SYN רצופות. רק החבילה הראשונה היא SYN של הלקוח. אחריה באים SYN-ACK מהשרת ו-ACK מהלקוח.
- בלחיצת היד שני הצדדים מתאמים אילו פורטים ישמשו את החיבור. פורט היעד ידוע ללקוח כבר כשהוא קורא ל-
connect(), ופורט המקור שלו כבר נבחר. החבילות נושאות את הפורטים, אבל לא מתמקחות עליהם. - לחיצת היד בודקת שם משתמש וסיסמה, או קובעת מראש כמה חבילות יעברו בחיבור. כל מה שהיא עושה הוא להכריז על מספרי רצף ולאשר אותם. זיהוי משתמשים, אם יש, קורה מאוחר יותר ברמת היישום.
- שלוש החבילות מצפינות את הערוץ. TCP אינו מצפין דבר. ההצפנה מגיעה משכבה מעליו, למשל TLS, שמנהל לחיצת יד נפרדת משלו אחרי שחיבור ה-TCP כבר קיים.
בדקו את עצמכם
כתבו לפי הסדר את שלוש החבילות שפותחות חיבור TCP, וליד כל אחת את השולח.
SYN מהלקוח, SYN-ACK מהשרת, ACK מהלקוח.
בכלי ניטור מופיע בצד השרת חיבור שנשלח בו SYN-ACK, אבל עוד לא חזר עליו ACK. מה המצב שלו?
SYN_RECEIVED (או SYN_RCVD): חיבור חצי-פתוח.
תוכנית שרת קראה ל-listen() ועוד לא קראה ל-accept(), ולקוח העביר את שלוש החבילות. באיזה מצב החיבור?
ESTABLISHED. הליבה השלימה את לחיצת היד, והחיבור מחכה בתור ש-accept() תשלוף אותו.
מספרי רצף, אישורים והתצוגה ב-Wireshark
כדי לוודא שכל הנתונים הגיעו ובסדר הנכון, TCP נותן מספר לכל בית שהוא שולח. הספירה נפרדת לכל כיוון: מה שיוצא מהלקוח נספר בסדרה אחת, ומה שיוצא מהשרת בסדרה אחרת.
לכן לכל צד יש נקודת התחלה משלו, ISN (Initial Sequence Number). בלחיצת היד כל צד מכריז על ה-ISN שלו, והצד שמולו מאשר שקלט אותו.
| חבילה | שולח | דגלים | Seq | Ack |
|---|---|---|---|---|
| 1 | לקוח | SYN | x | אין |
| 2 | שרת | SYN, ACK | y | x+1 |
| 3 | לקוח | ACK | x+1 | y+1 |
את החשבון הזה אפשר לכתוב כפונקציה קצרה. היא מקבלת את שני ה-ISN ומדפיסה את שלוש החבילות, פעם עם מספרים שרירותיים ופעם כששניהם 0. C>S הוא כיוון מהלקוח לשרת, ו-S>C ההפך:
def handshake(client_isn, server_isn):
# each SYN consumes one sequence number, so every ack is the peer's seq + 1
rows = [
("C>S", "SYN", client_isn, None),
("S>C", "SYN+ACK", server_isn, client_isn + 1),
("C>S", "ACK", client_isn + 1, server_isn + 1),
]
for n, (way, flags, seq, ack) in enumerate(rows, 1):
ack_text = "-" if ack is None else ack
print(f"pkt{n} {way} seq={seq:<6} ack={ack_text:<6} flags={flags}")
handshake(4200, 91000)
print()
handshake(0, 0) # the relative view that Wireshark shows by defaultpkt1 C>S seq=4200 ack=- flags=SYN
pkt2 S>C seq=91000 ack=4201 flags=SYN+ACK
pkt3 C>S seq=4201 ack=91001 flags=ACK
pkt1 C>S seq=0 ack=- flags=SYN
pkt2 S>C seq=0 ack=1 flags=SYN+ACK
pkt3 C>S seq=1 ack=1 flags=ACKה-ISN האמיתי נבחר באקראי, ואין שום דרישה שיהיה ייחודי: שני לקוחות שונים יכולים לבחור בדיוק את אותו מספר. מה שמזהה חיבור הם ארבעת הערכים, כתובת ופורט של כל אחד מהצדדים, ולא ה-ISN.
מספרים אקראיים בני עשר ספרות קשים לקריאה, ולכן Wireshark, בהגדרות ברירת המחדל, מראה ספירה יחסית: כל צד מתחיל אצלו מ-Seq=0 ב-SYN שלו, יהיה ה-ISN האמיתי אשר יהיה. זה בדיוק החלק השני של הפלט למעלה. בעמודת Info של לכידה זה נראה כך:
No. Source Destination Info
1 172.16.4.30 172.16.4.80 51822 -> 443 [SYN] Seq=0
2 172.16.4.80 172.16.4.30 443 -> 51822 [SYN, ACK] Seq=0 Ack=1
3 172.16.4.30 172.16.4.80 51822 -> 443 [ACK] Seq=1 Ack=1- שורה 1: הלקוח פותח. Seq=0 הוא ה-ISN שלו בתצוגה היחסית, ואין בחבילה נתוני יישום.
- שורה 2: ה-Seq=0 כאן שייך לשרת. זה ה-ISN של השרת עצמו (גם הוא יחסי), ולא אישור על משהו.
- שורה 2, השדה Ack=1: זה האישור. השרת קלט את ה-SYN של הלקוח, שתפס את המספר 0, ולכן הוא מחכה עכשיו למספר 1.
- שורה 3: יוצאת מהלקוח אל השרת, לא להפך. Seq=1 כי ה-SYN של הלקוח כבר ניצל את 0, ו-Ack=1 כי ה-SYN של השרת (Seq=0) תפס מספר אחד.
Ack=1 בשורה 2 אינו דיווח על תקלה ואינו בקשה לשלוח את החבילה שוב: זה אישור רגיל לגמרי. שורה שלישית עם Seq=0 ו-Ack=0 הייתה שגויה, כי Ack=0 אינו מאשר את ה-SYN של השרת.
תרחיש 10: ISN שאינו אפס
בלכידה עם מספרים מוחלטים מופיעה החבילה 192.168.7.15 אל 192.168.7.1, [SYN] Seq=2500. בשרת יש תהליך שמאזין לפורט, והוא משיב SYN-ACK. איזה Ack יופיע בתשובה?
- Ack=2501: ה-SYN ניצל את 2500, והמספר הבא שהשרת מחכה לו הוא 2501. זו התשובה.
- Ack=2500 היה מתאים רק אילו ה-SYN לא נספר, והאישור היה נעצר במספר שלפניו.
- Ack=0 היה מרמז שהשרת לא קלט כלום, אבל הוא כן קלט SYN.
- Ack=2502 נובע מהטעות שגם ה-ACK האחרון נספר. ה-ACK הזה עוד לא נשלח בכלל כשהשרת עונה, ו-ACK בלי נתונים ממילא אינו תופס מספר.
נמשיך: אם ה-ISN של השרת הוא 64000, החבילה השלישית של הלקוח תצא עם Seq=2501 ו-Ack=64001.
תרחיש 11: השלמת לכידה חסרה
בלכידה יחסית נראות רק שתי חבילות: לקוח אל שרת [SYN] Seq=0, ושרת אל לקוח [SYN, ACK] Seq=0 Ack=1. איזו חבילה תבוא אחריהן?
- כיוון: מהלקוח אל השרת, כי השלב השלישי שייך ללקוח.
- דגלים: ACK בלבד. דגל SYN מופיע רק בשתי החבילות הראשונות.
- Seq=1: המספר הבא של הלקוח, אחרי שה-SYN שלו ניצל את 0.
- Ack=1: ה-SYN של השרת היה Seq=0, ועוד 1.
- אחרי החבילה הזו שני הצדדים ב-ESTABLISHED.
מכאן שתשובה כמו 'הלקוח שולח SYN, ACK' נפסלת בגלל הדגלים, ותשובה כמו 'השרת שולח ACK' נפסלת בגלל הכיוון.
טעויות נפוצות
- Ack=1 ב-SYN-ACK אומר שהשרת קיבל בית נתונים אחד. ב-SYN הראשון אין נתוני יישום. ה-1 נובע מכך שה-SYN עצמו תופס מספר רצף.
- Ack=1 הוא בקשה של השרת שהלקוח ישלח שוב. Ack מאשר את מה שנקלט, ואינו דורש שידור חוזר.
- המספר 1 בחבילה השנייה הוא ה-ISN של השרת. ה-ISN של השרת נמצא בשדה Seq של אותה חבילה. השדה Ack מתייחס לספירה של הלקוח.
- ה-ACK שבתוך ה-SYN-ACK מסמן שהשרת דוחה או מסנן את הבקשה. הוא מאשר את מספר הרצף של הלקוח. דחייה נראית אחרת לגמרי, כפי שנראה בחלק על מצבי הפורט.
- ה-ISN הוא מה שמזהה את החיבור. ה-ISN אקראי ועלול לחזור אצל לקוחות שונים. החיבור מזוהה לפי ארבעה ערכים: כתובת ופורט של המקור, כתובת ופורט של היעד.
- גם ה-ACK האחרון נספר, ולכן על SYN עם Seq=n השרת עונה Ack=n+2. רק ה-SYN נספר בשלב הזה, והשרת מאשר n+1.
בדקו את עצמכם
לקוח שולח SYN עם Seq=8800. מה יהיה ה-Ack בתשובה של השרת?
Ack=8801.
התשובה של השרת היא SYN-ACK עם Seq=120 ו-Ack=8801. אילו ערכי Seq ו-Ack יופיעו ב-ACK של הלקוח?
Seq=8801 ו-Ack=121.
בלכידה בתצוגה יחסית, מה יופיע בשדות Seq ו-Ack של החבילה השלישית?
Seq=1 ו-Ack=1.
למה דווקא שלוש חבילות
חיבור TCP הוא בעצם שני ערוצים שזורמים בכיוונים מנוגדים, ולכל ערוץ ספירה משלו. כדי שערוץ יהיה אמין, מי ששולח בו צריך להכריז על ה-ISN שלו ולשמוע שהצד השני קלט אותו.
ספרו מה צריך לקרות: שתי הכרזות (ISN של הלקוח, ISN של השרת) ושני אישורים. ההכרזה של השרת והאישור שלו על הלקוח נדחסים לחבילה אחת, וכך יוצאות שלוש חבילות ולא ארבע:
| חבילה | על מה היא מכריזה | מה היא מאשרת |
|---|---|---|
| SYN | ה-ISN של הלקוח, x | שום דבר |
| SYN-ACK | ה-ISN של השרת, y | את ה-ISN של הלקוח (ack = x+1) |
| ACK | שום דבר חדש | את ה-ISN של השרת (ack = y+1) |
עם שתי חבילות בלבד זה לא נסגר: ה-SYN של השרת היה נשאר בלי אישור, והשרת לא היה יודע שהלקוח קלט את נקודת ההתחלה שלו. רק אחרי החבילה השלישית שני הכיוונים מסונכרנים ומאושרים, ואז אפשר להתחיל להעביר מידע אמיתי.
ומה לחיצת היד לא עושה? היא לא מסכמת מפתח הצפנה, ולא מחליטה מי ידבר ראשון, כי TCP דו-כיווני ושני הצדדים רשאים לשלוח. היא גם לא מקצה ללקוח פורט זמני, שאותו הלקוח בוחר לעצמו, ולא נועדה לשדר שוב ושוב את אותה בקשה.
בדקו את עצמכם
למה הקמת חיבור TCP דורשת שלוש חבילות, ולא מספיקות שתיים?
כל אחד מהצדדים מכריז על ISN וצריך לקבל עליו אישור. בשתי חבילות ה-ISN של השרת נשאר בלי אישור, והחבילה השלישית סוגרת את הפער.
האם ה-SYN-ACK הוא זה שמקצה ללקוח את פורט המקור שלו?
לא. הלקוח בוחר לעצמו פורט מקור זמני עוד לפני שה-SYN יוצא.
הדגלים SYN, ACK, RST, FIN ו-PSH
בכותרת של כל מקטע TCP יש קבוצת ביטים שנקראים דגלים. הדגלים הדולקים מודיעים לצד השני מה תפקיד החבילה.
| דגל | מה הוא אומר |
|---|---|
| SYN | פתיחת חיבור והכרזה על ISN. תופס מספר רצף אחד |
| ACK | אישור שנקלטו נתונים או SYN |
| RST | ניתוק מיידי מצד אחד, או סירוב לבקשת חיבור |
| FIN | סיום מסודר של החיבור כשהתקשורת הסתיימה |
| PSH | בקשה להעביר את הנתונים לאפליקציה בלי לחכות. אינו חלק מהקמת החיבור |
ACK הוא הדרך של כל צד לומר 'מה ששלחת הגיע אליי'. בזכותו השולח יודע אילו חבילות נקלטו ולא אבדו בדרך, וזה לב האמינות של TCP. אבל ACK לבדו לא פותח חיבור, לא סוגר אותו ולא מאפס אותו.
RST הוא טריקת דלת: החיבור נגמר ברגע זה, בלי חילופי FIN ו-ACK של סגירה מסודרת. הוא לא מפרק את החיבור בהדרגה, לא מחדש אותו ולא מבקש לשלוח שוב מקטעים שאבדו.
מי שרוצה להמשיך לתקשר אחרי RST חייב לפתוח חיבור חדש, כולל לחיצת יד חדשה.
תרחיש 12: לקוח שמתחרט אחרי ה-SYN-ACK
דפדפן שלח SYN לשרת תמונות, וה-SYN-ACK הגיע באיחור גדול. בינתיים המשתמש סגר את הלשונית, או שזמן ההמתנה של הבקשה כבר פג.
אין טעם להשלים את לחיצת היד רק כדי לסגור מיד אחר כך. הלקוח עונה ב-RST, וכך מודיע לשרת שהחיבור מבוטל כבר עכשיו.
גם סורק פורטים שולח RST בדיוק בנקודה הזו, אבל מסיבה אחרת: הוא רוצה ללמוד שהפורט פתוח בלי להשלים חיבור. נגיע לזה בחלק על מצבי הפורט.
טעויות נפוצות
- החיבור נפתח בדגל ACK. פתיחה היא SYN. ACK רק מאשר.
- ACK מסיים את החיבור. סיום מסודר הוא FIN.
- ACK מאפס חיבור. איפוס הוא RST.
- RST הוא ניתוק הדרגתי. ההפך: RST חותך מיד, וההדרגה שייכת ל-FIN.
- RST פותח את החיבור מחדש. RST מבטל את החיבור, וחזרה לתקשורת דורשת לחיצת יד חדשה.
- RST מבקש מהצד השני לשדר שוב. שידור חוזר נגרם מ-timeout או מ-ACK כפול, ולא מ-RST.
- לקוח שקיבל את כל מה שרצה מסיים ב-RST, כחלופה תקינה ל-FIN. הדרך התקינה לסיים היא FIN. RST נועד לביטול פתאומי.
בדקו את עצמכם
איזה דגל מנתק חיבור מיד, ואיזה מסיים אותו בצורה מסודרת?
RST מנתק מיד, FIN מסיים בצורה מסודרת.
לקוח קיבל SYN-ACK, אבל כבר אין לו צורך בחיבור. מה סביר שישלח?
RST, שמבטל את החיבור מיד במקום להשלים אותו ולסגור אחר כך.
כשאחת החבילות לא מגיעה
ברשת אמיתית חבילות הולכות לאיבוד, ולחיצת היד צריכה לשרוד את זה. שני המקרים המרכזיים: ה-SYN-ACK לא מגיע ללקוח, או שה-ACK לא מגיע לשרת.
SYN שלא נענה. הלקוח לא יכול לדעת מה קרה: אולי ה-SYN נבלע בדרך, ואולי השרת לא זמין. מערכת ההפעלה שלו מחכה, שולחת את אותו SYN שוב, ושוב, ואם גם אחרי כמה ניסיונות לא מגיע SYN-ACK היא מוותרת ו-connect() מחזיר שגיאת Timeout.
לאורך כל זה הלקוח לא עובר לפורט יעד אחר, ושרת שלא קיבל דבר גם לא שולח RST. החיבור אינו ESTABLISHED כבר מה-SYN הראשון: הוא יגיע לשם רק אחרי שנקלט SYN-ACK והלקוח שלח ACK.
כמה ניסיונות בדיוק? זה תלוי במערכת. ב-Linux שעליו הורצו הדוגמאות כאן, אלה ערכי ברירת המחדל:
sysctl net.ipv4.tcp_syn_retries net.ipv4.tcp_synack_retriesnet.ipv4.tcp_syn_retries = 6
net.ipv4.tcp_synack_retries = 5הלקוח ישלח SYN חוזר עד 6 פעמים, והשרת ישלח SYN-ACK חוזר עד 5 פעמים, ורק אז יוותרו. במערכות אחרות המספרים שונים, אבל העיקרון קבוע: כמה ניסיונות, ואז ויתור.
connect timeout. זה אינו שדה בכותרת TCP, אלא הגדרה בצד הלקוח, של מערכת ההפעלה או של התוכנית עצמה. היא קובעת כמה זמן לכל היותר לחכות ל-SYN-ACK לפני שמוותרים על החיבור, וכך מונעת המתנה בלי סוף ומשחררת משאבים.
ב-Python זה הערך שמעבירים ל-settimeout() לפני connect(). בדוגמה הבאה ה-SYN נשלח לכתובת שאינה עונה בכלל:
import socket, time
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(4) # connect timeout chosen by the client
start = time.monotonic()
try:
s.connect(("10.255.255.1", 443)) # SYNs to this address get no reply
except socket.timeout:
print(f"gave up after {time.monotonic() - start:.1f}s, no SYN-ACK arrived")gave up after 4.0s, no SYN-ACK arrivedהמגבלה חלה רק על שלב ההקמה. היא לא קובעת כמה זמן חיבור שקט יחזיק ב-ESTABLISHED, לא מגדירה המתנה אחרי ה-ACK האחרון, וגם אינה השהיה שהשרת מכניס לפני שהוא עונה ב-SYN-ACK.
SYN-ACK בלי ACK. השרת ענה, אבל ה-ACK של הלקוח לא מגיע. החיבור לא הוקם, והשרת מחזיק אותו ב-SYN_RECEIVED, כלומר חצי-פתוח.
השרת יחזור על ה-SYN-ACK עוד מספר פעמים, וכשגם זה לא עוזר, ינטוש את הניסיון וישחרר את מה שהקצה. הוא לא משדר SYN-ACK לנצח, לא שולח Time Exceeded ולא מגיב ב-RST ל-SYN הראשון.
תרחיש 13: SYN שנבלע
שירות ניטור קורא ל-connect() לשרת מרוחק, אבל אף SYN-ACK לא חוזר.
- ה-SYN יוצא, והלקוח במצב SYN_SENT.
- אין תשובה. אחרי המתנה אותו SYN יוצא שוב, לאותו פורט יעד.
- הניסיון חוזר עוד כמה פעמים.
- בסוף
connect()נכשל בשגיאת Timeout.
בשום שלב השרת לא שולח RST, והלקוח לא מנסה פורט אחר.
טעויות נפוצות
- כשאין תשובה, הלקוח ינסה פורט יעד אחר באותו שרת. פורט היעד נקבע בקריאה ל-
connect(), וכל הניסיונות החוזרים הולכים אליו. - כבר ה-SYN הראשון הופך את החיבור ל-ESTABLISHED. אחרי SYN הלקוח רק ב-SYN_SENT. ESTABLISHED מגיע אחרי SYN-ACK ו-ACK.
- כשהלקוח שותק אחרי SYN-ACK, השרת מגיב ב-RST ל-SYN הראשון. השרת שולח שוב SYN-ACK כמה פעמים, ואחר כך מוותר ומשחרר את המשאבים.
- השרת ימשיך לשלוח SYN-ACK עד שהלקוח יענה. מספר הניסיונות מוגבל, ואחריו החיבור החצי-פתוח נמחק.
- כשהלחיצה נתקעת, הלקוח מקבל מהנתב הקרוב ICMP Time Exceeded. ההודעה הזו נשלחת כשה-TTL של חבילה מגיע לאפס בנתב, ואינה חלק מכישלון של לחיצת יד.
- connect timeout הוא זמן שהשרת מחכה לפני שהוא שולח SYN-ACK. זו הגדרה של הלקוח: כמה זמן לחכות ל-SYN-ACK לפני שמוותרים.
בדקו את עצמכם
לקוח שלח SYN ושום דבר לא חזר. מה יקרה?
מערכת ההפעלה תשלח את ה-SYN שוב כמה פעמים, עם המתנה ביניהן, ובסוף connect() ייכשל ב-Timeout.
מה בדיוק מגביל connect timeout?
את הזמן המרבי שהלקוח מחכה ל-SYN-ACK לפני שהוא מוותר על החיבור.
באיזה מצב נשאר שרת ששלח SYN-ACK ולא קיבל ACK, ומה יעשה בסוף?
ב-SYN_RECEIVED. הוא ישלח SYN-ACK שוב כמה פעמים, ואז ינטוש את החיבור וישחרר את המשאבים.
מצב הפורט: פתוח, סגור ומסונן
שלוש תשובות אפשריות ל-SYN
SYN הגיע לשרת. מה שיחזור תלוי במה שקורה בפורט היעד: האם יש תהליך שמאזין לו, והאם עומדת בדרך חומת אש.
| הפורט | מה קורה בצד השרת | מה חוזר על ה-SYN | מה הלקוח חווה |
|---|---|---|---|
| פתוח | תהליך מאזין לפורט | SYN-ACK | לחיצת היד ממשיכה |
| סגור | אין מאזין, ואין חומת אש בדרך | RST (ב-Wireshark נראה כ-RST, ACK) | connect() נכשל מיד: Connection refused |
| מסונן | חומת אש עומדת בדרך | שום דבר, או ICMP unreachable | בשתיקה: המתנה עד timeout |
בפורט סגור התשובה מגיעה מהליבה של השרת עצמה, בלי שום תוכנה מעורבת: RST. ה-RST מגיע כמעט מיד, ו-connect() נכשל בשגיאה Connection refused.
שתיקה ארוכה אינה סימן לפורט סגור. היא קורית כשחומת אש זורקת את ה-SYN ולא מחזירה דבר, ואז הלקוח מחכה עד שזמן ההמתנה נגמר. אם חומת האש בוחרת דווקא להחזיר RST, סורק יסווג את הפורט כסגור.
ההבדל ניכר גם בזמן. התוכנית הבאה מנסה פורט שאין עליו מאזין במחשב עצמו, ואחר כך כתובת שאינה עונה לשום SYN, כמו מאחורי חומת אש שמשליכה חבילות:
import socket, time
def probe(host, port, limit):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(limit)
start = time.monotonic()
try:
s.connect((host, port))
result = "connected"
except ConnectionRefusedError as e:
result = "refused: " + str(e)
except socket.timeout as e:
result = "timeout: " + str(e)
finally:
s.close()
print(f"{host}:{port} -> {result} after {time.monotonic() - start:.1f}s")
probe("127.0.0.1", 6553, 3) # nothing listens on this port
probe("10.255.255.1", 6553, 3) # nothing answers at all on this address127.0.0.1:6553 -> refused: [Errno 111] Connection refused after 0.0s
10.255.255.1:6553 -> timeout: timed out after 3.0sהניסיון הראשון נכשל אחרי 0.0 שניות, כי הליבה החזירה RST מיד. השני נמשך את מלוא שלוש השניות שהלקוח הקציב, כי ל-SYN לא חזרה שום תשובה.
סריקת SYN: לשאול בלי להשלים
סורק פורטים (port scanner) מנצל את ההבדלים האלה. בסריקת SYN, שנקראת גם סריקה חצי-פתוחה (half-open), הוא שולח SYN לכל פורט ובודק מה חוזר:
- SYN-ACK: הפורט פתוח, כי יש תהליך שמאזין לו.
- RST: הפורט סגור.
- שום דבר, או ICMP unreachable: הפורט מסונן.
כשמגיע SYN-ACK, הסורק בדרך כלל לא ממשיך ל-ACK אלא שולח RST. כך החיבור אינו מושלם, וגם השרת לא נשאר תקוע עם רשומה חצי-פתוחה.
תרחיש 14: SYN-ACK מפורט 5432
סורק שולח SYN לפורט 5432 בשרת בסיס נתונים, מקבל תשובה שדולקים בה SYN ו-ACK, ושולח מיד RST.
- מסקנה: הפורט פתוח. SYN-ACK אומר שתהליך בשרת מאזין לפורט.
- הוא לא סגור: את ה-RST שלח הסורק עצמו, כחלק מהשיטה.
- הוא לא מסונן: פורט מסונן היה שותק או מחזיר ICMP unreachable, ולא SYN-ACK.
- ה-ACK שבתוך התשובה פשוט מאשר את מספר הרצף של הסורק.
תרחיש 15: RST, ACK מפורט 6379
אין חומת אש בין הסורק לשרת. ה-SYN לפורט 6379 נענה בחבילה שדולקים בה RST ו-ACK.
- אף תהליך לא מאזין לפורט, והשרת סירב לבקשת החיבור. הסורק ירשום: סגור.
- אילו הפורט היה פתוח, הייתה חוזרת SYN-ACK.
- אילו חומת אש הייתה זורקת את ה-SYN, לא היה חוזר דבר, והסורק היה מחכה לפסק זמן.
תרחיש 16: connect לפורט בלי מאזין
תוכנית קוראת ל-connect() לשרת פעיל, בפורט 7070. אין חומת אש בדרך, ואף תהליך בשרת לא מאזין לפורט הזה.
- ה-SYN מגיע לשרת.
- הליבה של השרת עונה RST.
connect()נכשל מיד בשגיאה Connection refused.
לא תגיע SYN-ACK, לא תגיע ICMP Port Unreachable, ולא תהיה המתנה ארוכה.
טעויות נפוצות
- הסורק שלח RST, ולכן הפורט סגור. ה-RST יצא מהסורק כדי לא להשלים את החיבור. מה שקובע הוא התשובה של השרת.
- השרת ענה SYN-ACK כדי לסרב, ולכן הפורט סגור. SYN-ACK הוא הסכמה להמשיך, והוא מגיע רק מפורט פתוח.
- הלחיצה נקטעה לפני ה-ACK, ולכן הפורט מסונן. מסונן פירושו שתיקה או ICMP unreachable. SYN-ACK שהגיע מוכיח שהפורט פתוח.
- בלי לשלוח נתוני יישום אי אפשר לדעת מה מצב הפורט. התשובה ל-SYN לבדה מספיקה.
- פורט סגור שותק עד שזמן ההמתנה נגמר. פורט סגור מחזיר RST מיד. שתיקה מעידה על חומת אש שמשליכה את החבילות.
- פורט TCP סגור מחזיר ICMP Port Unreachable. זו התגובה האופיינית ב-UDP. ב-TCP חוזר RST.
- פורט סגור עונה SYN-ACK, ומיד אחר כך השרת סוגר את החיבור. פורט סגור עונה RST בלבד.
- כדי להסתתר מסורקים, שרת מתעלם מ-SYN שמגיע לפורט בלי האזנה. כשאין חומת אש, הליבה עונה RST. שתיקה דורשת חומת אש.
- גם בפורט בלי מאזין השרת נכנס ל-SYN_RCVD ושולח SYN-ACK. SYN_RCVD ו-SYN-ACK קיימים רק כשיש האזנה פעילה על הפורט.
- על SYN לפורט בלי מאזין השרת שולח ICMP Destination Unreachable במקום RST. ב-TCP התגובה האופיינית היא RST.
בדקו את עצמכם
סורק קיבל RST, ACK מפורט 21, ושום חומת אש לא מפרידה בינו לבין השרת. איך יסווג הפורט?
סגור.
סורק קיבל SYN-ACK מפורט 1433 ושלח אחריו RST. מה מצב הפורט, ומה תפקיד ה-RST?
פתוח. ה-RST רק מונע את השלמת החיבור, ואינו משנה את המסקנה.
סורק שלח SYN פעמיים לפורט 27017 ולא חזר דבר. מה המסקנה?
הפורט מסונן, למשל בגלל חומת אש שזורקת את החבילות.
מגיע דאטהגרם UDP לפורט שאף תהליך לא מאזין לו. מה התגובה האופיינית?
ICMP Port Unreachable. ב-TCP, במצב מקביל, הייתה חוזרת RST.
SYN Flood ו-SYN Cookies
איך ההתקפה ממלאת את התור
על כל SYN שמגיע, השרת עונה SYN-ACK ופותח רשומה של חיבור חצי-פתוח במצב SYN_RECEIVED. הרשומה נשארת עד שה-ACK האחרון מגיע, או עד שהשרת מוותר עליה.
הרשומות האלה יושבות בתור שגודלו מוגבל: התור של החיבורים החצי-פתוחים. חשבו על מסעדה ששומרת שולחן לכל מי שמזמין בטלפון, ומישהו מזמין אלף פעמים בשמות בדויים ולא מגיע: כל השולחנות תפוסים, ואורחים אמיתיים נשארים בחוץ.
זו בדיוק התקפת SYN Flood. התוקף שולח כמות עצומה של SYN, ואת ה-ACK האחרון הוא לא שולח לעולם. השרת עונה SYN-ACK לכל אחד, התור מתמלא, לקוחות לגיטימיים לא מצליחים להתחבר, והשירות מאט או מפסיק לענות לגמרי.
ב-Linux, ההגדרה הבאה מגבילה כמה בקשות חיבור שעוד לא אושרו הליבה זוכרת. כך זה נראה במחשב שעליו הורצו הדוגמאות:
sysctl net.ipv4.tcp_max_syn_backlognet.ipv4.tcp_max_syn_backlog = 512זהו ה-SYN backlog, התור של הבקשות החצי-פתוחות שמחכות ל-ACK. הוא שונה מה-backlog של listen(), שמונה חיבורים שכבר הושלמו ומחכים ל-accept(); כשאומרים ש-SYN Flood 'ממלא את ה-backlog', הכוונה לתור החצי-פתוחים.
הסימן המובהק בכלי ניטור: אלפי חיבורים ב-SYN_RECEIVED, מכתובות מקור רבות ושונות, ואף אחד מהם לא מתקדם ל-ESTABLISHED.
| מה ההתקפה מנצלת? | התשובה |
|---|---|
| תור החיבורים החצי-פתוחים שמחכים ל-ACK | כן, זה המשאב שמתמלא |
| טבלת ARP או מטמון DNS | לא, אין להם קשר |
| הפורטים הזמניים | לא, הם משאב של הלקוח ולא של השרת |
| רוחב הפס, או הצפה בהודעות ICMP Echo | לא, אלה התקפות אחרות. כאן הנזק נובע מחיבורים שלא הושלמו, ולא מנפח התעבורה |
| חיבורים שהושלמו ונשארו פתוחים | לא, ב-SYN Flood לחיצת היד אף פעם לא נגמרת |
תרחיש 17: אלפי SYN_RECEIVED
צוות התפעול רואה בשרת אלפי חיבורים ב-SYN_RECEIVED מכתובות רבות, ואף אחד לא עובר ל-ESTABLISHED.
- הפירוש: השרת שלח SYN-ACK לכולם, ו-ACK לא חוזר. זה הדפוס האופייני ל-SYN Flood.
- החיבורים לא ב-ESTABLISHED כי לחיצת היד לא הושלמה.
- ההסבר 'הלקוחות סגרו את החיבורים' לא מתאים: חיבור שנסגר נמצא במצב אחר, כמו TIME_WAIT.
- ההסבר 'השרת מחכה שהלקוחות ישלחו נתונים' לא מתאים: המתנה לנתונים באה רק אחרי לחיצת יד שלמה.
- ההסבר 'השרת עוד לא קיבל SYN' לא מתאים: SYN_RECEIVED פירושו בדיוק שה-SYN הגיע ונענה.
סיכום
הנקודות שכדאי לזכור מכל הפרק, לפי סדר הנושאים:
- Socket הוא נקודת קצה של תקשורת. מזהים אותו לפי כתובת IP ופורט, וגם לפי הפרוטוקול: סוקט TCP וסוקט UDP באותו פורט לא מתנגשים.
- חיבור TCP מזוהה לפי ארבעה ערכים: כתובת ופורט של המקור, כתובת ופורט של היעד.
SOCK_STREAMהוא זרם בתים, ובברירת מחדל TCP.SOCK_DGRAMהוא דאטהגרמים, ובברירת מחדל UDP.AF_INETהוא משפחת כתובות, לא סוג סוקט.- שרת TCP:
socket,bind,listen,accept. לקוח TCP:connect, בליbind, ומערכת ההפעלה בוחרת לו פורט מקור זמני. שרת UDP:socket,bind,recvfrom, בליlistenובליaccept. bindקושרת סוקט לכתובת ולפורט מקומיים. היא נכשלת ב-Address already in use כשהפורט תפוס (או כשחיבורים ישנים ב-TIME_WAIT ולא הוגדרSO_REUSEADDR), וב-Permission denied על פורט מתחת ל-1024 בלי הרשאות.0.0.0.0פירושו כל הממשקים של המחשב.127.0.0.1פירושו המחשב עצמו בלבד.listenהופכת את הסוקט לפסיבי וקובעת backlog, כמה חיבורים שהושלמו יחכו לפניaccept. את לחיצת היד משלימה הליבה.acceptשולפת חיבור מוכן מהתור ומחזירה סוקט חדש, וסוקט ההאזנה ממשיך להאזין. כשהתור ריק היא חוסמת, אלא אם הסוקט non-blocking.- לחיצת יד: SYN, SYN-ACK, ACK. SYN תופס מספר רצף אחד, ולכן Ack הוא ה-Seq שהתקבל ועוד 1. בתצוגה היחסית של Wireshark: Seq=0; Seq=0 Ack=1; Seq=1 Ack=1. אחרי זה שני הצדדים ESTABLISHED.
- RST מנתק מיד, FIN מסיים בצורה מסודרת. SYN שלא נענה נשלח שוב כמה פעמים עד Timeout, ושרת בלי ACK נשאר ב-SYN_RECEIVED עד שהוא מוותר.
- מצב פורט: פתוח עונה SYN-ACK, סגור (בלי חומת אש) עונה RST, מסונן שותק או מחזיר ICMP unreachable. סריקת SYN היא half-open: הסורק שולח RST במקום ACK.
- SYN Flood: הרבה SYN בלי ACK אחרון ממלאים את תור החיבורים החצי-פתוחים (SYN_RECEIVED). ההגנה: SYN Cookies, שמקודדות את המידע ב-ISN שהשרת שולח ב-SYN-ACK ופותחות רשומה רק אחרי ACK תקין.