הטמעת פרוטוקול Reliable Udp עבור .Net

האינטרנט השתנה מזמן. אחד הפרוטוקולים העיקריים של האינטרנט - UDP משמש יישומים לא רק כדי לספק נתונים גרמות ושידורים, אלא גם לספק חיבורי "עמית לעמית" בין צמתי רשת. בשל העיצוב הפשוט שלו, לפרוטוקול זה יש הרבה שימושים לא מתוכננים בעבר, אולם החסרונות של הפרוטוקול, כמו היעדר מסירה מובטחת, לא נעלמו לשום מקום. מאמר זה מתאר את היישום של פרוטוקול המסירה המובטחת על UDP.
תוכן:כניסה
דרישות פרוטוקול
כותרת UDP אמינה
עקרונות כלליים של הפרוטוקול
פסקי זמן וטיימרים פרוטוקולים
דיאגרמת מצב שידור UDP אמינה
עמוק יותר לתוך הקוד. יחידת בקרת תמסורת
עמוק יותר לתוך הקוד. מדינות

• שיטת DisposeByTimeout
• שיטת ProcessPackets
• שיטת ReceivePacket
• שיטת שלח מנות

עמוק יותר לתוך הקוד. יצירה ויצירת קשרים
עמוק יותר לתוך הקוד. סגירת החיבור בזמן קצוב
עמוק יותר לתוך הקוד. שחזור העברת נתונים
API UDP אמין
מסקנה
קישורים ומאמרים שימושיים

כניסה

הארכיטקטורה המקורית של האינטרנט הניחה מרחב כתובות הומוגני שבו לכל צומת יש כתובת IP גלובלית וייחודית והוא יכול לתקשר ישירות עם צמתים אחרים. כעת לאינטרנט, למעשה, יש ארכיטקטורה שונה - אזור אחד של כתובות IP גלובליות ואזורים רבים עם כתובות פרטיות המוסתרות מאחורי מכשירי NAT.בארכיטקטורה זו, רק מכשירים במרחב הכתובות הגלובלי יכולים לתקשר בקלות עם כל אחד ברשת מכיוון שיש להם כתובת IP ייחודית הניתנת לניתוב גלובלית. צומת ברשת פרטית יכול להתחבר לצמתים אחרים באותה רשת, ויכול להתחבר גם לצמתים מוכרים אחרים במרחב הכתובות הגלובלי. אינטראקציה זו מושגת בעיקר בזכות מנגנון תרגום כתובות הרשת. התקני NAT, כגון נתבי Wi-Fi, יוצרים ערכי טבלת תרגום מיוחדים עבור חיבורים יוצאים ומשנים כתובות IP ומספרי יציאות במנות. זה מאפשר חיבורים יוצאים מהרשת הפרטית למארחים במרחב הכתובות הגלובלי. אך יחד עם זאת, התקני NAT ​​בדרך כלל חוסמים את כל התעבורה הנכנסת אלא אם נקבעו כללים נפרדים לחיבורים נכנסים.

ארכיטקטורה זו של האינטרנט נכונה מספיק עבור תקשורת לקוח-שרת, שבה לקוחות יכולים להיות ברשתות פרטיות, ולשרתים יש כתובת גלובלית. אבל זה יוצר קשיים לחיבור ישיר של שני צמתים ביניהם אחר רשתות פרטיות. חיבור ישיר בין שני צמתים חשוב ליישומי עמית לעמית כגון שידור קולי (סקייפ), השגת גישה מרחוק למחשב (TeamViewer) או משחקים מקוונים.

אחת השיטות היעילות ביותר ליצירת חיבור עמית לעמית בין מכשירים ברשתות פרטיות שונות נקראת ניקוב חורים. טכניקה זו משמשת לרוב עם יישומים המבוססים על פרוטוקול UDP.

אבל אם האפליקציה שלך דורשת מסירה מובטחת של נתונים, למשל, אתה מעביר קבצים בין מחשבים, אזי השימוש ב-UDP יהווה קשיים רבים בשל העובדה ש-UDP אינו פרוטוקול מסירה מובטח ואינו מספק משלוח מנות לפי הסדר, בניגוד ל-TCP נוהל.

במקרה זה, כדי להבטיח אספקת מנות מובטחת, נדרש ליישם פרוטוקול שכבת יישומים המספק את הפונקציונליות הדרושה ועובד על UDP.

אני רוצה לציין מיד שקיימת טכניקת ניקוב חורים ב-TCP ליצירת חיבורי TCP בין צמתים ברשתות פרטיות שונות, אך בשל חוסר התמיכה בה על ידי התקני NAT ​​רבים, היא בדרך כלל לא נחשבת לדרך העיקרית לחיבור צמתים כאלה.

בהמשך מאמר זה, אתמקד רק ביישום פרוטוקול המסירה המובטחת. היישום של טכניקת ניקוב החורים UDP יתואר במאמרים הבאים.

דרישות פרוטוקול

1. מסירת מנות אמינה המיושמת באמצעות מנגנון משוב חיובי (מה שנקרא אישור חיובי)
2. הצורך בהעברה יעילה של ביג דאטה, כלומר. על הפרוטוקול להימנע מהעברת מנות מיותרת
3. צריך להיות אפשרי לבטל את מנגנון אישור המסירה (היכולת לתפקד כפרוטוקול UDP "טהור")
4. יכולת ליישם מצב פקודה, עם אישור של כל הודעה
5. היחידה הבסיסית של העברת נתונים על גבי הפרוטוקול חייבת להיות הודעה

דרישות אלו תואמות במידה רבה את דרישות פרוטוקול ה-Reliable Data המתוארות ב rfc 908 и rfc 1151, והסתמכתי על הסטנדרטים הללו בעת פיתוח הפרוטוקול הזה.

כדי להבין את הדרישות הללו, בואו נסתכל על התזמון של העברת נתונים בין שני צמתי רשת באמצעות פרוטוקולי TCP ו-UDP. תן בשני המקרים שתאבד חבילה אחת.
העברת נתונים לא אינטראקטיביים באמצעות TCP:

כפי שניתן לראות מהתרשים, במקרה של אובדן מנות, TCP יזהה את החבילה האבודה וידווח עליה לשולח על ידי בקשת מספר הקטע האבוד.
העברת נתונים באמצעות פרוטוקול UDP:

UDP לא נוקטת כל צעדי איתור אובדן. בקרה על שגיאות שידור בפרוטוקול UDP היא לחלוטין באחריות האפליקציה.

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

בנוסף, כדי לשפר את הביצועים (כלומר שליחת יותר מקטע אחד מבלי לקבל אישור), פרוטוקול ה-TCP משתמש במה שנקרא חלון השידור - מספר בתים של נתונים ששולח המקטע מצפה לקבל.

למידע נוסף על פרוטוקול TCP, ראה rfc 793, מ-UDP ל rfc 768איפה, למעשה, הם מוגדרים.

מהאמור לעיל, ברור שעל מנת ליצור פרוטוקול מסירת הודעות אמין על UDP (להלן UDP אמין), נדרש ליישם מנגנוני העברת נתונים דומים ל-TCP. כלומר:

• שמור מצב חיבור
• השתמש במספור פלחים
• השתמש בחבילות אישור מיוחדות
• השתמש במנגנון חלונות פשוט כדי להגדיל את תפוקת הפרוטוקול

בנוסף, אתה צריך:

• מסמן את תחילתה של הודעה, כדי להקצות משאבים לחיבור
• לסמן את סיום ההודעה, להעביר את ההודעה שהתקבלה לאפליקציה במעלה הזרם ולשחרר משאבי פרוטוקול
• אפשר לפרוטוקול הספציפי לחיבור להשבית את מנגנון אישור המסירה לתפקד כ-UDP "טהור".

כותרת UDP אמינה

נזכיר ש-Datagram UDP מובלע ב-IP Datagram. חבילת UDP מהימנה "עטופת" כראוי לתוך Datagram UDP.
עטיפה אמינה של כותרת UDP:

המבנה של כותרת UDP Reliable הוא די פשוט:

• דגלים - דגלי בקרת חבילה
• MessageType - סוג הודעה המשמש יישומים במעלה הזרם כדי להירשם להודעות ספציפיות
• TransmissionId - מספר השידור, יחד עם הכתובת והיציאה של הנמען, מזהים באופן ייחודי את החיבור
• PacketNumber - מספר מנה
• אפשרויות - אפשרויות פרוטוקול נוספות. במקרה של החבילה הראשונה, היא משמשת לציון גודל ההודעה

הדגלים הם כדלקמן:

• FirstPacket - החבילה הראשונה של ההודעה
• NoAsk - ההודעה אינה דורשת הפעלת מנגנון אישור
• LastPacket - החבילה האחרונה של ההודעה
• RequestForPacket - חבילת אישור או בקשה לחבילה שאבדה

עקרונות כלליים של הפרוטוקול

מכיוון ש-Reliable UDP מתמקד בהעברת הודעות מובטחת בין שני צמתים, היא חייבת להיות מסוגלת ליצור קשר עם הצד השני. כדי ליצור חיבור, השולח שולח חבילה עם דגל FirstPacket, שהתגובה אליו משמעה שהחיבור נוצר. כל מנות התגובה, או, במילים אחרות, מנות אישור, תמיד מגדירים את הערך של השדה PacketNumber לערך אחד יותר מהערך PacketNumber הגדול ביותר של מנות שהתקבלו בהצלחה. שדה האפשרויות עבור החבילה הראשונה שנשלחה הוא גודל ההודעה.

מנגנון דומה משמש לסיום חיבור. הדגל LastPacket מוגדר על החבילה האחרונה של ההודעה. בחבילת התגובה מצוין מספר החבילה האחרונה + 1, מה שעבור הצד המקבל פירושו מסירה מוצלחת של ההודעה.
דיאגרמת יצירת חיבור וסיום:

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

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

פסקי זמן וטיימרים פרוטוקולים

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

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

דיאגרמת מצב שידור UDP אמינה

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

סגור - היא לא ממש מדינה, היא נקודת התחלה וסיום של האוטומט. עבור המדינה סגור מתקבל בלוק בקרת שידור, אשר בהטמעת שרת UDP אסינכרוני, מעביר מנות לחיבורים המתאימים ומתחיל עיבוד מצב.

FirstPacketSending – המצב ההתחלתי שבו החיבור היוצא נמצא בעת שליחת ההודעה.

במצב זה, החבילה הראשונה עבור הודעות רגילות נשלחת. עבור הודעות ללא אישור שליחה, זהו המצב היחיד שבו נשלחת ההודעה כולה.

SendingCycle – מצב קרקע לשידור מנות הודעות.

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

FirstPacketReceived – המצב ההתחלתי של מקבל ההודעה.

הוא בודק את נכונות תחילת השידור, יוצר את המבנים הדרושים ושולח אישור על קבלת החבילה הראשונה.

עבור הודעה המורכבת מחבילה בודדת ונשלחה ללא שימוש בהוכחת מסירה, זהו המצב היחיד. לאחר עיבוד הודעה כזו, החיבור נסגר.

הרכבה – מצב בסיסי לקבלת מנות הודעות.

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

השלמת – סגירת החיבור במקרה של קליטה מוצלחת של כל ההודעה.

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

עמוק יותר לתוך הקוד. יחידת בקרת תמסורת

אחד המרכיבים המרכזיים של Reliable UDP הוא בלוק בקרת השידור. המשימה של בלוק זה היא לאחסן חיבורים ורכיבי עזר נוכחיים, להפיץ מנות נכנסות לחיבורים המתאימים, לספק ממשק לשליחת מנות לחיבור, וליישם את הפרוטוקול API. בלוק בקרת השידור מקבל מנות משכבת ​​UDP ומעביר אותן למכונת המצב לעיבוד. כדי לקבל מנות, הוא מיישם שרת UDP אסינכרוני.
כמה חברים במחלקה ReliableUdpConnectionControlBlock:

internal class ReliableUdpConnectionControlBlock : IDisposable
{
  // массив байт для указанного ключа. Используется для сборки входящих сообщений    
  public ConcurrentDictionary<Tuple<EndPoint, Int32>, byte[]> IncomingStreams { get; private set;}
  // массив байт для указанного ключа. Используется для отправки исходящих сообщений.
  public ConcurrentDictionary<Tuple<EndPoint, Int32>, byte[]> OutcomingStreams { get; private set; }
  // connection record для указанного ключа.
  private readonly ConcurrentDictionary<Tuple<EndPoint, Int32>, ReliableUdpConnectionRecord> m_listOfHandlers;
  // список подписчиков на сообщения.
  private readonly List<ReliableUdpSubscribeObject> m_subscribers;    
  // локальный сокет    
  private Socket m_socketIn;
  // порт для входящих сообщений
  private int m_port;
  // локальный IP адрес
  private IPAddress m_ipAddress;    
  // локальная конечная точка    
  public IPEndPoint LocalEndpoint { get; private set; }    
  // коллекция предварительно инициализированных
  // состояний конечного автомата
  public StatesCollection States { get; private set; }
  // генератор случайных чисел. Используется для создания TransmissionId
  private readonly RNGCryptoServiceProvider m_randomCrypto;    	
  //...
}

יישום שרת UDP אסינכרוני:

private void Receive()
{
  EndPoint connectedClient = new IPEndPoint(IPAddress.Any, 0);
  // создаем новый буфер, для каждого socket.BeginReceiveFrom 
  byte[] buffer = new byte[DefaultMaxPacketSize + ReliableUdpHeader.Length];
  // передаем буфер в качестве параметра для асинхронного метода
  this.m_socketIn.BeginReceiveFrom(buffer, 0, buffer.Length, SocketFlags.None, ref connectedClient, EndReceive, buffer);
}   

private void EndReceive(IAsyncResult ar)
{
  EndPoint connectedClient = new IPEndPoint(IPAddress.Any, 0);
  int bytesRead = this.m_socketIn.EndReceiveFrom(ar, ref connectedClient);
  //пакет получен, готовы принимать следующий        
  Receive();
  // т.к. простейший способ решить вопрос с буфером - получить ссылку на него 
  // из IAsyncResult.AsyncState        
  byte[] bytes = ((byte[]) ar.AsyncState).Slice(0, bytesRead);
  // получаем заголовок пакета        
  ReliableUdpHeader header;
  if (!ReliableUdpStateTools.ReadReliableUdpHeader(bytes, out header))
  {          
    // пришел некорректный пакет - отбрасываем его
    return;
  }
  // конструируем ключ для определения connection record’а для пакета
  Tuple<EndPoint, Int32> key = new Tuple<EndPoint, Int32>(connectedClient, header.TransmissionId);
  // получаем существующую connection record или создаем новую
  ReliableUdpConnectionRecord record = m_listOfHandlers.GetOrAdd(key, new ReliableUdpConnectionRecord(key, this, header.ReliableUdpMessageType));
  // запускаем пакет в обработку в конечный автомат
  record.State.ReceivePacket(record, header, bytes);
}

עבור כל העברת הודעה נוצר מבנה המכיל מידע על החיבור. מבנה כזה נקרא שיא חיבור.
כמה חברים במחלקה ReliableUdpConnectionRecord:

internal class ReliableUdpConnectionRecord : IDisposable
{    
  // массив байт с сообщением    
  public byte[] IncomingStream { get; set; }
  // ссылка на состояние конечного автомата    
  public ReliableUdpState State { get; set; }    
  // пара, однозначно определяющая connection record
  // в блоке управления передачей     
  public Tuple<EndPoint, Int32> Key { get; private set;}
  // нижняя граница приемного окна    
  public int WindowLowerBound;
  // размер окна передачи
  public readonly int WindowSize;     
  // номер пакета для отправки
  public int SndNext;
  // количество пакетов для отправки
  public int NumberOfPackets;
  // номер передачи (именно он и есть вторая часть Tuple)
  // для каждого сообщения свой	
  public readonly Int32 TransmissionId;
  // удаленный IP endpoint – собственно получатель сообщения
  public readonly IPEndPoint RemoteClient;
  // размер пакета, во избежание фрагментации на IP уровне
  // не должен превышать MTU – (IP.Header + UDP.Header + RelaibleUDP.Header)
  public readonly int BufferSize;
  // блок управления передачей
  public readonly ReliableUdpConnectionControlBlock Tcb;
  // инкапсулирует результаты асинхронной операции для BeginSendMessage/EndSendMessage
  public readonly AsyncResultSendMessage AsyncResult;
  // не отправлять пакеты подтверждения
  public bool IsNoAnswerNeeded;
  // последний корректно полученный пакет (всегда устанавливается в наибольший номер)
  public int RcvCurrent;
  // массив с номерами потерянных пакетов
  public int[] LostPackets { get; private set; }
  // пришел ли последний пакет. Используется как bool.
  public int IsLastPacketReceived = 0;
  //...
}

עמוק יותר לתוך הקוד. מדינות

מדינות מיישמות את מכונת המצב של פרוטוקול Reliable UDP, שבו מתבצע העיבוד העיקרי של מנות. המחלקה המופשטת ReliableUdpState מספקת ממשק למדינה:

כל ההיגיון של הפרוטוקול מיושם על ידי המחלקות שהוצגו לעיל, יחד עם מחלקה עזר המספקת שיטות סטטיות, כמו למשל, בניית ה-ReliableUdp header מתוך רשומת החיבור.

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

שיטת DisposeByTimeout

שיטת DisposeByTimeout אחראית לשחרור משאבי חיבור לאחר פסק זמן ולאותת מסירת הודעה מוצלחת/לא מוצלחת.
ReliableUdpState.DisposeByTimeout:

protected virtual void DisposeByTimeout(object record)
{
  ReliableUdpConnectionRecord connectionRecord = (ReliableUdpConnectionRecord) record;      
  if (record.AsyncResult != null)
  {
    connectionRecord.AsyncResult.SetAsCompleted(false);
  }
  connectionRecord.Dispose();
}

זה מוחלף רק במדינה השלמת.
Completed.DisposeByTimeout:

protected override void DisposeByTimeout(object record)
{
  ReliableUdpConnectionRecord connectionRecord = (ReliableUdpConnectionRecord) record;
  // сообщаем об успешном получении сообщения
  SetAsCompleted(connectionRecord);        
}

שיטת ProcessPackets

שיטת ProcessPackets אחראית על עיבוד נוסף של חבילה או חבילות. התקשר ישירות או באמצעות טיימר המתנה למנות.

בתנאי הרכבה השיטה עוקפת ואחראית לבדיקת מנות אבודות ומעבר למצב השלמת, במקרה של קבלת החבילה האחרונה והעברת בדיקה מוצלחת
Assembling.ProcessPackets:

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  if (connectionRecord.IsDone != 0)
    return;
  if (!ReliableUdpStateTools.CheckForNoPacketLoss(connectionRecord, connectionRecord.IsLastPacketReceived != 0))
  {
    // есть потерянные пакеты, отсылаем запросы на них
    foreach (int seqNum in connectionRecord.LostPackets)
    {
      if (seqNum != 0)
      {
        ReliableUdpStateTools.SendAskForLostPacket(connectionRecord, seqNum);
      }
    }
    // устанавливаем таймер во второй раз, для повторной попытки передачи
    if (!connectionRecord.TimerSecondTry)
    {
      connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
      connectionRecord.TimerSecondTry = true;
      return;
    }
    // если после двух попыток срабатываний WaitForPacketTimer 
    // не удалось получить пакеты - запускаем таймер завершения соединения
    StartCloseWaitTimer(connectionRecord);
  }
  else if (connectionRecord.IsLastPacketReceived != 0)
  // успешная проверка 
  {
    // высылаем подтверждение о получении блока данных
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
    connectionRecord.State = connectionRecord.Tcb.States.Completed;
    connectionRecord.State.ProcessPackets(connectionRecord);
    // вместо моментальной реализации ресурсов
    // запускаем таймер, на случай, если
    // если последний ack не дойдет до отправителя и он запросит его снова.
    // по срабатыванию таймера - реализуем ресурсы
    // в состоянии Completed метод таймера переопределен
    StartCloseWaitTimer(connectionRecord);
  }
  // это случай, когда ack на блок пакетов был потерян
  else
  {
    if (!connectionRecord.TimerSecondTry)
    {
      ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
      connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
      connectionRecord.TimerSecondTry = true;
      return;
    }
    // запускаем таймер завершения соединения
    StartCloseWaitTimer(connectionRecord);
  }
}

בתנאי SendingCycle שיטה זו נקראת רק על טיימר, והיא אחראית על שליחת ההודעה האחרונה מחדש, כמו גם הפעלת טיימר סגירת החיבור.
SendingCycle.ProcessPackets:

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  if (connectionRecord.IsDone != 0)
    return;        
  // отправляем повторно последний пакет 
  // ( в случае восстановления соединения узел-приемник заново отправит запросы, которые до него не дошли)        
  ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, connectionRecord.SndNext - 1));
  // включаем таймер CloseWait – для ожидания восстановления соединения или его завершения
  StartCloseWaitTimer(connectionRecord);
}

בתנאי השלמת השיטה עוצרת את הטיימר הפועל ושולחת את ההודעה למנויים.
Completed.ProcessPackets:

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  if (connectionRecord.WaitForPacketsTimer != null)
    connectionRecord.WaitForPacketsTimer.Dispose();
  // собираем сообщение и передаем его подписчикам
  ReliableUdpStateTools.CreateMessageFromMemoryStream(connectionRecord);
}

שיטת ReceivePacket

בתנאי FirstPacketReceived המשימה העיקרית של השיטה היא לקבוע אם חבילת ההודעות הראשונה אכן הגיעה לממשק, וגם לאסוף הודעה המורכבת מחבילה אחת.
FirstPacketReceived.ReceivePacket:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket))
    // отбрасываем пакет
    return;
  // комбинация двух флагов - FirstPacket и LastPacket - говорит что у нас единственное сообщение
  if (header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket) &
      header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
  {
    ReliableUdpStateTools.CreateMessageFromSinglePacket(connectionRecord, header, payload.Slice(ReliableUdpHeader.Length, payload.Length));
    if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.NoAsk))
    {
      // отправляем пакет подтверждение          
      ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
    }
    SetAsCompleted(connectionRecord);
    return;
  }
  // by design все packet numbers начинаются с 0;
  if (header.PacketNumber != 0)          
    return;
  ReliableUdpStateTools.InitIncomingBytesStorage(connectionRecord, header);
  ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
  // считаем кол-во пакетов, которые должны прийти
  connectionRecord.NumberOfPackets = (int)Math.Ceiling((double) ((double) connectionRecord.IncomingStream.Length/(double) connectionRecord.BufferSize));
  // записываем номер последнего полученного пакета (0)
  connectionRecord.RcvCurrent = header.PacketNumber;
  // после сдвинули окно приема на 1
  connectionRecord.WindowLowerBound++;
  // переключаем состояние
  connectionRecord.State = connectionRecord.Tcb.States.Assembling;
  // если не требуется механизм подтверждение
  // запускаем таймер который высвободит все структуры         
  if (header.Flags.HasFlag(ReliableUdpHeaderFlags.NoAsk))
  {
    connectionRecord.CloseWaitTimer = new Timer(DisposeByTimeout, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
  }
  else
  {
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
    connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
  }
}

בתנאי SendingCycle שיטה זו מבוטלת כדי לקבל אישורי מסירה ובקשות לשידור חוזר.
SendingCycle.ReceivePacket:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  if (connectionRecord.IsDone != 0)
    return;
  if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.RequestForPacket))
    return;
  // расчет конечной границы окна
  // берется граница окна + 1, для получения подтверждений доставки
  int windowHighestBound = Math.Min((connectionRecord.WindowLowerBound + connectionRecord.WindowSize), (connectionRecord.NumberOfPackets));
  // проверка на попадание в окно        
  if (header.PacketNumber < connectionRecord.WindowLowerBound || header.PacketNumber > windowHighestBound)
    return;
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // проверить на последний пакет:
  if (header.PacketNumber == connectionRecord.NumberOfPackets)
  {
    // передача завершена
    Interlocked.Increment(ref connectionRecord.IsDone);
    SetAsCompleted(connectionRecord);
    return;
  }
  // это ответ на первый пакет c подтверждением         
  if ((header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket) && header.PacketNumber == 1))
  {
    // без сдвига окна
    SendPacket(connectionRecord);
  }
  // пришло подтверждение о получении блока данных
  else if (header.PacketNumber == windowHighestBound)
  {
    // сдвигаем окно прием/передачи
    connectionRecord.WindowLowerBound += connectionRecord.WindowSize;
    // обнуляем массив контроля передачи
    connectionRecord.WindowControlArray.Nullify();
    // отправляем блок пакетов
    SendPacket(connectionRecord);
  }
  // это запрос на повторную передачу – отправляем требуемый пакет          
  else
    ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, header.PacketNumber));
}

בתנאי הרכבה בשיטת ReceivePacket מתבצעת העבודה העיקרית של הרכבת הודעה ממנות נכנסות.
Assembling.ReceivePacket:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  if (connectionRecord.IsDone != 0)
    return;
  // обработка пакетов с отключенным механизмом подтверждения доставки
  if (header.Flags.HasFlag(ReliableUdpHeaderFlags.NoAsk))
  {
    // сбрасываем таймер
    connectionRecord.CloseWaitTimer.Change(connectionRecord.LongTimerPeriod, -1);
    // записываем данные
    ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
    // если получили пакет с последним флагом - делаем завершаем          
    if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
    {
      connectionRecord.State = connectionRecord.Tcb.States.Completed;
      connectionRecord.State.ProcessPackets(connectionRecord);
    }
    return;
  }        
  // расчет конечной границы окна
  int windowHighestBound = Math.Min((connectionRecord.WindowLowerBound + connectionRecord.WindowSize - 1), (connectionRecord.NumberOfPackets - 1));
  // отбрасываем не попадающие в окно пакеты
  if (header.PacketNumber < connectionRecord.WindowLowerBound || header.PacketNumber > (windowHighestBound))
    return;
  // отбрасываем дубликаты
  if (connectionRecord.WindowControlArray.Contains(header.PacketNumber))
    return;
  // записываем данные 
  ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
  // увеличиваем счетчик пакетов        
  connectionRecord.PacketCounter++;
  // записываем в массив управления окном текущий номер пакета        
  connectionRecord.WindowControlArray[header.PacketNumber - connectionRecord.WindowLowerBound] = header.PacketNumber;
  // устанавливаем наибольший пришедший пакет        
  if (header.PacketNumber > connectionRecord.RcvCurrent)
    connectionRecord.RcvCurrent = header.PacketNumber;
  // перезапускам таймеры        
  connectionRecord.TimerSecondTry = false;
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // если пришел последний пакет
  if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
  {
    Interlocked.Increment(ref connectionRecord.IsLastPacketReceived);
  }
  // если нам пришли все пакеты окна, то сбрасываем счетчик
  // и высылаем пакет подтверждение
  else if (connectionRecord.PacketCounter == connectionRecord.WindowSize)
  {
    // сбрасываем счетчик.      
    connectionRecord.PacketCounter = 0;
    // сдвинули окно передачи
    connectionRecord.WindowLowerBound += connectionRecord.WindowSize;
    // обнуление массива управления передачей
    connectionRecord.WindowControlArray.Nullify();
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
  }
  // если последний пакет уже имеется        
  if (Thread.VolatileRead(ref connectionRecord.IsLastPacketReceived) != 0)
  {
    // проверяем пакеты          
    ProcessPackets(connectionRecord);
  }
}

בתנאי השלמת המשימה היחידה של השיטה היא לשלוח אישור מחדש על המסירה המוצלחת של ההודעה.
Completed.ReceivePacket:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  // повторная отправка последнего пакета в связи с тем,
  // что последний ack не дошел до отправителя
  if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
  {
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
  }
}

שיטת שלח מנות

בתנאי FirstPacketSending שיטה זו שולחת את חבילת הנתונים הראשונה, או אם ההודעה אינה דורשת אישור מסירה, את כל ההודעה.
FirstPacketSending.SendPacket:

public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{
  connectionRecord.PacketCounter = 0;
  connectionRecord.SndNext = 0;
  connectionRecord.WindowLowerBound = 0;       
  // если подтверждения не требуется - отправляем все пакеты
  // и высвобождаем ресурсы
  if (connectionRecord.IsNoAnswerNeeded)
  {
    // Здесь происходит отправка As Is
    do
    {
      ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, ReliableUdpStateTools. CreateReliableUdpHeader(connectionRecord)));
      connectionRecord.SndNext++;
    } while (connectionRecord.SndNext < connectionRecord.NumberOfPackets);
    SetAsCompleted(connectionRecord);
    return;
  }
  // создаем заголовок пакета и отправляем его 
  ReliableUdpHeader header = ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord);
  ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, header));
  // увеличиваем счетчик
  connectionRecord.SndNext++;
  // сдвигаем окно
  connectionRecord.WindowLowerBound++;
  connectionRecord.State = connectionRecord.Tcb.States.SendingCycle;
  // Запускаем таймер
  connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
}

בתנאי SendingCycle בשיטה זו נשלח בלוק של מנות.
SendingCycle.SendPacket:

public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{      
  // отправляем блок пакетов      
  for (connectionRecord.PacketCounter = 0;
        connectionRecord.PacketCounter < connectionRecord.WindowSize &&
        connectionRecord.SndNext < connectionRecord.NumberOfPackets;
        connectionRecord.PacketCounter++)
  {
    ReliableUdpHeader header = ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord);
    ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, header));
    connectionRecord.SndNext++;
  }
  // на случай большого окна передачи, перезапускаем таймер после отправки
  connectionRecord.WaitForPacketsTimer.Change( connectionRecord.ShortTimerPeriod, -1 );
  if ( connectionRecord.CloseWaitTimer != null )
  {
    connectionRecord.CloseWaitTimer.Change( -1, -1 );
  }
}

עמוק יותר לתוך הקוד. יצירה ויצירת קשרים

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

שקול בפירוט את היצירה שיא חיבור להתחבר ולשלוח את החבילה הראשונה. ההעברה מתבצעת תמיד על ידי האפליקציה שקוראת ל-API של שלח הודעה. לאחר מכן, מופעלת שיטת StartTransmission של בלוק בקרת השידור, אשר מתחילה את שידור הנתונים עבור ההודעה החדשה.
צור חיבור יוצא:

private void StartTransmission(ReliableUdpMessage reliableUdpMessage, EndPoint endPoint, AsyncResultSendMessage asyncResult)
{
  if (m_isListenerStarted == 0)
  {
    if (this.LocalEndpoint == null)
    {
      throw new ArgumentNullException( "", "You must use constructor with parameters or start listener before sending message" );
    }
    // запускаем обработку входящих пакетов
    StartListener(LocalEndpoint);
  }
  // создаем ключ для словаря, на основе EndPoint и ReliableUdpHeader.TransmissionId        
  byte[] transmissionId = new byte[4];
  // создаем случайный номер transmissionId        
  m_randomCrypto.GetBytes(transmissionId);
  Tuple<EndPoint, Int32> key = new Tuple<EndPoint, Int32>(endPoint, BitConverter.ToInt32(transmissionId, 0));
  // создаем новую запись для соединения и проверяем, 
  // существует ли уже такой номер в наших словарях
  if (!m_listOfHandlers.TryAdd(key, new ReliableUdpConnectionRecord(key, this, reliableUdpMessage, asyncResult)))
  {
    // если существует – то повторно генерируем случайный номер 
    m_randomCrypto.GetBytes(transmissionId);
    key = new Tuple<EndPoint, Int32>(endPoint, BitConverter.ToInt32(transmissionId, 0));
    if (!m_listOfHandlers.TryAdd(key, new ReliableUdpConnectionRecord(key, this, reliableUdpMessage, asyncResult)))
      // если снова не удалось – генерируем исключение
      throw new ArgumentException("Pair TransmissionId & EndPoint is already exists in the dictionary");
  }
  // запустили состояние в обработку         
  m_listOfHandlers[key].State.SendPacket(m_listOfHandlers[key]);
}

שליחת החבילה הראשונה (מצב FirstPacketSending):

public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{
  connectionRecord.PacketCounter = 0;
  connectionRecord.SndNext = 0;
  connectionRecord.WindowLowerBound = 0;       
  // ... 
  // создаем заголовок пакета и отправляем его 
  ReliableUdpHeader header = ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord);
  ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, header));
  // увеличиваем счетчик
  connectionRecord.SndNext++;
  // сдвигаем окно
  connectionRecord.WindowLowerBound++;
  // переходим в состояние SendingCycle
  connectionRecord.State = connectionRecord.Tcb.States.SendingCycle;
  // Запускаем таймер
  connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
}

לאחר שליחת החבילה הראשונה, השולח נכנס למצב SendingCycle - המתן לאישור מסירת החבילה.
הצד המקבל, בשיטת EndReceive, מקבל את החבילה שנשלחה, יוצר חבילה חדשה שיא חיבור ומעביר את החבילה הזו, עם כותרת מנותחת מראש, לשיטת ReceivePacket של המדינה לעיבוד FirstPacketReceived
יצירת חיבור בצד המקבל:

private void EndReceive(IAsyncResult ar)
{
  // ...
  // пакет получен
  // парсим заголовок пакета        
  ReliableUdpHeader header;
  if (!ReliableUdpStateTools.ReadReliableUdpHeader(bytes, out header))
  {          
    // пришел некорректный пакет - отбрасываем его
    return;
  }
  // конструируем ключ для определения connection record’а для пакета
  Tuple<EndPoint, Int32> key = new Tuple<EndPoint, Int32>(connectedClient, header.TransmissionId);
  // получаем существующую connection record или создаем новую
  ReliableUdpConnectionRecord record = m_listOfHandlers.GetOrAdd(key, new ReliableUdpConnectionRecord(key, this, header. ReliableUdpMessageType));
  // запускаем пакет в обработку в конечный автомат
  record.State.ReceivePacket(record, header, bytes);
}

קבלת החבילה הראשונה ושליחת אישור (מצב FirstPacketReceived):

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket))
    // отбрасываем пакет
    return;
  // ...
  // by design все packet numbers начинаются с 0;
  if (header.PacketNumber != 0)          
    return;
  // инициализируем массив для хранения частей сообщения
  ReliableUdpStateTools.InitIncomingBytesStorage(connectionRecord, header);
  // записываем данные пакет в массив
  ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
  // считаем кол-во пакетов, которые должны прийти
  connectionRecord.NumberOfPackets = (int)Math.Ceiling((double) ((double) connectionRecord.IncomingStream.Length/(double) connectionRecord.BufferSize));
  // записываем номер последнего полученного пакета (0)
  connectionRecord.RcvCurrent = header.PacketNumber;
  // после сдвинули окно приема на 1
  connectionRecord.WindowLowerBound++;
  // переключаем состояние
  connectionRecord.State = connectionRecord.Tcb.States.Assembling;  
  if (/*если не требуется механизм подтверждение*/)
  // ...
  else
  {
    // отправляем подтверждение
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
    connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
  }
}

עמוק יותר לתוך הקוד. סגירת החיבור בזמן קצוב

טיפול בזמן קצוב הוא חלק חשוב ב-Reliable UDP. שקול דוגמה שבה צומת ביניים נכשל ואספקת נתונים בשני הכיוונים הפכה לבלתי אפשרית.
תרשים לסגירת חיבור לפי פסק זמן:

כפי שניתן לראות מהתרשים, טיימר העבודה של השולח מתחיל מיד לאחר שליחת גוש מנות. זה קורה בשיטת SendPacket של המדינה SendingCycle.
הפעלת טיימר העבודה (מצב SendingCycle):

public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{      
  // отправляем блок пакетов   
  // ...   
  // перезапускаем таймер после отправки
  connectionRecord.WaitForPacketsTimer.Change( connectionRecord.ShortTimerPeriod, -1 );
  if ( connectionRecord.CloseWaitTimer != null )
    connectionRecord.CloseWaitTimer.Change( -1, -1 );
}

תקופות הטיימר נקבעות בעת יצירת החיבור. ברירת המחדל של ShortTimerPeriod היא 5 שניות. בדוגמה, הוא מוגדר ל-1,5 שניות.

עבור חיבור נכנס, הטיימר מתחיל לאחר קבלת חבילת הנתונים הנכנסת האחרונה, זה קורה בשיטת ReceivePacket של המדינה הרכבה
הפעלת טיימר העבודה (מצב הרכבה):

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  // ... 
  // перезапускаем таймеры        
  connectionRecord.TimerSecondTry = false;
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // ...
}

לא הגיעו עוד מנות בחיבור הנכנס בזמן ההמתנה לטיימר הפועל. הטיימר כבה וקרא לשיטת ProcessPackets, שם נמצאו החבילות האבודות ונשלחו לראשונה בקשות מסירה מחדש.
שליחת בקשות מסירה מחדש (מצב הרכבה):

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  // ...        
  if (/*проверка на потерянные пакеты */)
  {
    // отправляем запросы на повторную доставку
    // устанавливаем таймер во второй раз, для повторной попытки передачи
    if (!connectionRecord.TimerSecondTry)
    {
      connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
    connectionRecord.TimerSecondTry = true;
    return;
    }
  // если после двух попыток срабатываний WaitForPacketTimer 
  // не удалось получить пакеты - запускаем таймер завершения соединения
  StartCloseWaitTimer(connectionRecord);
  }
  else if (/*пришел последний пакет и успешная проверка */)
  {
    // ...
    StartCloseWaitTimer(connectionRecord);
  }
  // если ack на блок пакетов был потерян
  else
  { 
    if (!connectionRecord.TimerSecondTry)
    {
      // повторно отсылаем ack
      connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
      connectionRecord.TimerSecondTry = true;
      return;
    }
    // запускаем таймер завершения соединения
    StartCloseWaitTimer(connectionRecord);
  }
}

המשתנה TimerSecondTry מוגדר ל נָכוֹן. משתנה זה אחראי על הפעלה מחדש של טיימר העבודה.

בצד השולח, גם טיימר העבודה מופעל והחבילה האחרונה שנשלחה נשלחת מחדש.
הפעלת טיימר סגירת חיבור (מצב SendingCycle):

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  // ...        
  // отправляем повторно последний пакет 
  // ...        
  // включаем таймер CloseWait – для ожидания восстановления соединения или его завершения
  StartCloseWaitTimer(connectionRecord);
}

לאחר מכן, טיימר סגירת החיבור מתחיל בחיבור היוצא.
ReliableUdpState.StartCloseWaitTimer:

protected void StartCloseWaitTimer(ReliableUdpConnectionRecord connectionRecord)
{
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(connectionRecord.LongTimerPeriod, -1);
  else
    connectionRecord.CloseWaitTimer = new Timer(DisposeByTimeout, connectionRecord, connectionRecord.LongTimerPeriod, -1);
}

פרק הזמן הקצוב של טיימר סגירת החיבור הוא 30 שניות כברירת מחדל.

לאחר זמן קצר, הטיימר הפועל בצד הנמען נדלק שוב, בקשות נשלחות שוב ולאחר מכן מתחיל טיימר סגירת החיבור לחיבור הנכנס

כאשר טיימרי הסגירה פועלים, כל המשאבים של שני רשומות החיבור משתחררים. השולח מדווח על כישלון המסירה לאפליקציה במעלה הזרם (ראה Reliable UDP API).
שחרור משאבי רשומות חיבור:

public void Dispose()
{
  try
  {
    System.Threading.Monitor.Enter(this.LockerReceive);
  }
  finally
  {
    Interlocked.Increment(ref this.IsDone);
    if (WaitForPacketsTimer != null)
    {
      WaitForPacketsTimer.Dispose();
    }
    if (CloseWaitTimer != null)
    {
      CloseWaitTimer.Dispose();
    }
    byte[] stream;
    Tcb.IncomingStreams.TryRemove(Key, out stream);
    stream = null;
    Tcb.OutcomingStreams.TryRemove(Key, out stream);
    stream = null;
    System.Threading.Monitor.Exit(this.LockerReceive);
  }
}

עמוק יותר לתוך הקוד. שחזור העברת נתונים

דיאגרמת שחזור העברת נתונים במקרה של אובדן מנות:

כפי שכבר נדון בסגירת החיבור בזמן קצוב, כאשר יפוג הטיימר הפועל, המקלט יבדוק אם יש מנות אבודות. במקרה של אובדן מנות, תערך רשימה של מספר החבילות שלא הגיעו לנמען. המספרים הללו מוזנים למערך LostPackets של חיבור ספציפי, ובקשות למשלוח חוזר נשלחות.
שליחת בקשות למשלוח מחדש של חבילות (מצב הרכבה):

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  //...
  if (!ReliableUdpStateTools.CheckForNoPacketLoss(connectionRecord, connectionRecord.IsLastPacketReceived != 0))
  {
    // есть потерянные пакеты, отсылаем запросы на них
    foreach (int seqNum in connectionRecord.LostPackets)
    {
      if (seqNum != 0)
      {
        ReliableUdpStateTools.SendAskForLostPacket(connectionRecord, seqNum);
      }
    }
    // ...
  }
}

השולח יקבל את בקשת המשלוח מחדש וישלח את החבילות החסרות. ראוי לציין שברגע זה השולח כבר התחיל את טיימר סגירת החיבור וכאשר מתקבלת בקשה, הוא מתאפס.
שליחת מנות אבודות מחדש (מצב SendingCycle):

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  // ...
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  // сброс таймера закрытия соединения 
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // ...
  // это запрос на повторную передачу – отправляем требуемый пакет          
  else
    ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, header.PacketNumber));
}

החבילה שנשלחה מחדש (חבילה מס' 3 בתרשים) מתקבלת על ידי החיבור הנכנס. מתבצעת בדיקה כדי לראות אם חלון הקבלה מלא ושידור הנתונים הרגיל משוחזר.
בדיקת התאמות בחלון הקבלה (מצב הרכבה):

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  // ...
  // увеличиваем счетчик пакетов        
  connectionRecord.PacketCounter++;
  // записываем в массив управления окном текущий номер пакета        
  connectionRecord.WindowControlArray[header.PacketNumber - connectionRecord.WindowLowerBound] = header.PacketNumber;
  // устанавливаем наибольший пришедший пакет        
  if (header.PacketNumber > connectionRecord.RcvCurrent)
    connectionRecord.RcvCurrent = header.PacketNumber;
  // перезапускам таймеры        
  connectionRecord.TimerSecondTry = false;
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // ...
  // если нам пришли все пакеты окна, то сбрасываем счетчик
  // и высылаем пакет подтверждение
  else if (connectionRecord.PacketCounter == connectionRecord.WindowSize)
  {
    // сбрасываем счетчик.      
    connectionRecord.PacketCounter = 0;
    // сдвинули окно передачи
    connectionRecord.WindowLowerBound += connectionRecord.WindowSize;
    // обнуление массива управления передачей
    connectionRecord.WindowControlArray.Nullify();
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
  }
  // ...
}

API UDP אמין

כדי ליצור אינטראקציה עם פרוטוקול העברת הנתונים, קיימת מחלקה פתוחה של Reliable Udp, שהיא מעטפת על בלוק בקרת ההעברה. להלן החברים החשובים ביותר בכיתה:

public sealed class ReliableUdp : IDisposable
{
  // получает локальную конечную точку
  public IPEndPoint LocalEndpoint    
  // создает экземпляр ReliableUdp и запускает
  // прослушивание входящих пакетов на указанном IP адресе
  // и порту. Значение 0 для порта означает использование
  // динамически выделенного порта
  public ReliableUdp(IPAddress localAddress, int port = 0) 
  // подписка на получение входящих сообщений
  public ReliableUdpSubscribeObject SubscribeOnMessages(ReliableUdpMessageCallback callback, ReliableUdpMessageTypes messageType = ReliableUdpMessageTypes.Any, IPEndPoint ipEndPoint = null)    
  // отписка от получения сообщений
  public void Unsubscribe(ReliableUdpSubscribeObject subscribeObject)
  // асинхронно отправить сообщение 
  // Примечание: совместимость с XP и Server 2003 не теряется, т.к. используется .NET Framework 4.0
  public Task<bool> SendMessageAsync(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, CancellationToken cToken)
  // начать асинхронную отправку сообщения
  public IAsyncResult BeginSendMessage(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, AsyncCallback asyncCallback, Object state)
  // получить результат асинхронной отправки
  public bool EndSendMessage(IAsyncResult asyncResult)  
  // очистить ресурсы
  public void Dispose()    
}

הודעות מתקבלות במנוי. חתימת האצל עבור שיטת ההתקשרות חזרה:

public delegate void ReliableUdpMessageCallback( ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteClient );

הודעה:

public class ReliableUdpMessage
{
  // тип сообщения, простое перечисление
  public ReliableUdpMessageTypes Type { get; private set; }
  // данные сообщения
  public byte[] Body { get; private set; }
  // если установлено в true – механизм подтверждения доставки будет отключен
  // для передачи конкретного сообщения
  public bool NoAsk { get; private set; }
}

כדי להירשם לסוג הודעה ספציפי ו/או לשולח ספציפי, משתמשים בשני פרמטרים אופציונליים: ReliableUdpMessageTypes messageType ו-IPEndPoint ipEndPoint.

סוגי הודעות:

public enum ReliableUdpMessageTypes : short
{ 
  // Любое
  Any = 0,
  // Запрос к STUN server 
  StunRequest = 1,
  // Ответ от STUN server
  StunResponse = 2,
  // Передача файла
  FileTransfer =3,
  // ...
}

ההודעה נשלחת באופן אסינכרוני; לשם כך, הפרוטוקול מיישם מודל תכנות אסינכרוני:

public IAsyncResult BeginSendMessage(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, AsyncCallback asyncCallback, Object state)

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

public bool EndSendMessage(IAsyncResult asyncResult)

מסקנה

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

הגרסה המודגמת של פרוטוקול המסירה האמין היא חזקה וגמישה מספיק כדי לעמוד בדרישות שהוגדרו קודם לכן. אבל אני רוצה להוסיף שניתן לשפר את היישום המתואר. לדוגמה, כדי להגדיל את התפוקה ולשנות באופן דינמי תקופות טיימר, ניתן להוסיף לפרוטוקול מנגנונים כגון חלון הזזה ו-RTT, זה יהיה שימושי גם ליישם מנגנון לקביעת MTU בין צמתי חיבור (אבל רק אם נשלחות הודעות גדולות) .

תודה על תשומת הלב, אני מצפה לתגובות והערות שלך.

נ.ב למי שמעוניין בפרטים או סתם רוצה לבדוק את הפרוטוקול, הקישור לפרויקט ב-GitHube:
פרויקט UDP אמין

קישורים ומאמרים שימושיים

1. מפרט פרוטוקול TCP: באנגלית и на русском
2. מפרט פרוטוקול UDP: באנגלית и на русском
3. דיון בפרוטוקול RUDP: draft-ietf-sigtran-reliable-udp-00
4. פרוטוקול נתונים אמין: rfc 908 и rfc 1151
5. יישום פשוט של אישור מסירה באמצעות UDP: קח שליטה מוחלטת על הרשת שלך עם .NET ו-UDP
6. מאמר המתאר מנגנוני מעבר NAT: תקשורת עמית לעמית על פני רשת מתרגמי כתובות
7. יישום מודל התכנות האסינכרוני: יישום מודל התכנות האסינכרוני CLR и כיצד ליישם את דפוס העיצוב של IAsyncResult
8. העברת מודל התכנות האסינכרוני לתבנית האסינכרונית מבוססת המשימות (APM ב-TAP):
   TPL ותכנות אסינכרוני .NET מסורתי
   שיתוף פעולה עם תבניות וסוגים אסינכרוניים אחרים

עדכון: תודה mayorovp и sidristij לרעיון של הוספת משימה לממשק. התאימות של הספרייה למערכות הפעלה ישנות אינה מופרת, מכיוון המסגרת הרביעית תומכת הן בשרת XP והן בשרת 4.

מקור: www.habr.com