rust/hedgewars-server/src/protocol.rs
changeset 14796 f5d43f007970
parent 14795 add191d825f4
child 15074 c5a6e8566425
equal deleted inserted replaced
14795:add191d825f4 14796:f5d43f007970
     9 #[cfg(test)]
     9 #[cfg(test)]
    10 pub mod test;
    10 pub mod test;
    11 
    11 
    12 pub struct ProtocolDecoder {
    12 pub struct ProtocolDecoder {
    13     buf: netbuf::Buf,
    13     buf: netbuf::Buf,
    14     consumed: usize,
       
    15     is_recovering: bool,
    14     is_recovering: bool,
    16 }
    15 }
    17 
    16 
    18 impl ProtocolDecoder {
    17 impl ProtocolDecoder {
    19     pub fn new() -> ProtocolDecoder {
    18     pub fn new() -> ProtocolDecoder {
    20         ProtocolDecoder {
    19         ProtocolDecoder {
    21             buf: netbuf::Buf::new(),
    20             buf: netbuf::Buf::new(),
    22             consumed: 0,
       
    23             is_recovering: false,
    21             is_recovering: false,
    24         }
    22         }
    25     }
    23     }
    26 
    24 
    27     fn recover(&mut self) -> bool {
    25     fn recover(&mut self) -> bool {
    46         Ok(count)
    44         Ok(count)
    47     }
    45     }
    48 
    46 
    49     pub fn extract_messages(&mut self) -> Vec<messages::HWProtocolMessage> {
    47     pub fn extract_messages(&mut self) -> Vec<messages::HWProtocolMessage> {
    50         let mut messages = vec![];
    48         let mut messages = vec![];
    51         let mut consumed = 0;
       
    52         if !self.is_recovering {
    49         if !self.is_recovering {
    53             loop {
    50             loop {
    54                 match parser::message(&self.buf[consumed..]) {
    51                 match parser::message(&self.buf[..]) {
    55                     Ok((tail, message)) => {
    52                     Ok((tail, message)) => {
    56                         messages.push(message);
    53                         messages.push(message);
    57                         consumed += self.buf.len() - tail.len();
    54                         self.buf.consume(self.buf.len() - tail.len());
    58                     }
    55                     }
    59                     Err(nom::Err::Incomplete(_)) => break,
    56                     Err(nom::Err::Incomplete(_)) => break,
    60                     Err(nom::Err::Failure(e)) | Err(nom::Err::Error(e)) => {
    57                     Err(nom::Err::Failure(e)) | Err(nom::Err::Error(e)) => {
    61                         debug!("Invalid message: {:?}", e);
    58                         debug!("Invalid message: {:?}", e);
    62                         self.buf.consume(consumed);
       
    63                         consumed = 0;
       
    64                         if !self.recover() || self.buf.is_empty() {
    59                         if !self.recover() || self.buf.is_empty() {
    65                             break;
    60                             break;
    66                         }
    61                         }
    67                     }
    62                     }
    68                 }
    63                 }
    69             }
    64             }
    70         }
    65         }
    71         self.buf.consume(consumed);
       
    72         messages
    66         messages
    73     }
    67     }
    74 }
    68 }