Merge branch 'main' into documentation

lib/src/analysis/analyzer.rs

@@ -1,12 +1,17 @@
 use std::borrow::Cow;
+use chrono::{DateTime, FixedOffset};
+use serde::Serialize;
 
-use super::information_element::InformationElement;
+use crate::{diag::MessagesContainer, gsmtap_parser};
+
+use super::{information_element::InformationElement, lte_downgrade::LteSib6And7DowngradeAnalyzer};
 
 /// Qualitative measure of how severe a Warning event type is.
 /// The levels should break down like this:
 ///   * Low: if combined with a large number of other Warnings, user should investigate
 ///   * Medium: if combined with a few other Warnings, user should investigate
 ///   * High: user should investigate
+#[derive(Serialize, Debug, Clone)]
 pub enum Severity {
     Low,
     Medium,
@@ -15,14 +20,17 @@ pub enum Severity {
 
 /// [QualitativeWarning] events will always be shown to the user in some manner,
 /// while `Informational` ones may be hidden based on user settings.
+#[derive(Serialize, Debug, Clone)]
+#[serde(tag = "type")]
 pub enum EventType {
     Informational,
-    QualitativeWarning(Severity),
+    QualitativeWarning { severity: Severity },
 }
 
 /// Events are user-facing signals that can be emitted by an [Analyzer] upon a
 /// message being received. They can be used to signifiy an IC detection
 /// warning, or just to display some relevant information to the user.
+#[derive(Serialize, Debug, Clone)]
 pub struct Event {
     pub event_type: EventType,
     pub message: String,
@@ -49,3 +57,133 @@ pub trait Analyzer {
     /// thousands of them alongside many other [Analyzers](Analyzer).
     fn analyze_information_element(&mut self, ie: &InformationElement) -> Option<Event>;
 }
+
+#[derive(Serialize, Debug)]
+pub struct AnalyzerMetadata {
+    name: String,
+    description: String,
+}
+
+#[derive(Serialize, Debug)]
+pub struct ReportMetadata {
+    analyzers: Vec<AnalyzerMetadata>,
+}
+
+#[derive(Serialize, Debug, Clone)]
+pub struct PacketAnalysis {
+    timestamp: DateTime<FixedOffset>,
+    events: Vec<Option<Event>>,
+}
+
+#[derive(Serialize, Debug)]
+pub struct AnalysisRow {
+    pub timestamp: DateTime<FixedOffset>,
+    pub skipped_message_reasons: Vec<String>,
+    pub analysis: Vec<PacketAnalysis>,
+}
+
+impl AnalysisRow {
+    pub fn is_empty(&self) -> bool {
+        self.skipped_message_reasons.is_empty() && self.analysis.is_empty()
+    }
+}
+
+pub struct Harness {
+    analyzers: Vec<Box<dyn Analyzer + Send>>,
+}
+
+impl Harness {
+    pub fn new() -> Self {
+        Self { analyzers: Vec::new() }
+    }
+
+    pub fn new_with_all_analyzers() -> Self {
+        let mut harness = Harness::new();
+        harness.add_analyzer(Box::new(LteSib6And7DowngradeAnalyzer{}));
+        harness
+    }
+
+    pub fn add_analyzer(&mut self, analyzer: Box<dyn Analyzer + Send>) {
+        self.analyzers.push(analyzer);
+    }
+
+    pub fn analyze_qmdl_messages(&mut self, container: MessagesContainer) -> AnalysisRow {
+        let mut row = AnalysisRow {
+            timestamp: chrono::Local::now().fixed_offset(),
+            skipped_message_reasons: Vec::new(),
+            analysis: Vec::new(),
+        };
+        for maybe_qmdl_message in container.into_messages() {
+            let qmdl_message = match maybe_qmdl_message {
+                Ok(msg) => msg,
+                Err(err) => {
+                    row.skipped_message_reasons.push(format!("{:?}", err));
+                    continue;
+                }
+            };
+
+            let gsmtap_message = match gsmtap_parser::parse(qmdl_message) {
+                Ok(msg) => msg,
+                Err(err) => {
+                    row.skipped_message_reasons.push(format!("{:?}", err));
+                    continue;
+                }
+            };
+
+            let Some((timestamp, gsmtap_msg)) = gsmtap_message else {
+                continue;
+            };
+
+            let element = match InformationElement::try_from(&gsmtap_msg) {
+                Ok(element) => element,
+                Err(err) => {
+                    row.skipped_message_reasons.push(format!("{:?}", err));
+                    continue;
+                }
+            };
+
+            let analysis_result = self.analyze_information_element(&element);
+            if analysis_result.iter().any(Option::is_some) {
+                row.analysis.push(PacketAnalysis {
+                    timestamp: timestamp.to_datetime(),
+                    events: analysis_result,
+                });
+            }
+        }
+        row
+    }
+
+    fn analyze_information_element(&mut self, ie: &InformationElement) -> Vec<Option<Event>> {
+        self.analyzers.iter_mut()
+            .map(|analyzer| analyzer.analyze_information_element(ie))
+            .collect()
+    }
+
+    pub fn get_names(&self) -> Vec<Cow<'_, str>> {
+        self.analyzers.iter()
+            .map(|analyzer| analyzer.get_name())
+            .collect()
+    }
+
+    pub fn get_descriptions(&self) -> Vec<Cow<'_, str>> {
+        self.analyzers.iter()
+            .map(|analyzer| analyzer.get_description())
+            .collect()
+    }
+
+    pub fn get_metadata(&self) -> ReportMetadata {
+        let names = self.get_names();
+        let descriptions = self.get_names();
+        let mut analyzers = Vec::new();
+        for (name, description) in names.iter().zip(descriptions.iter()) {
+            analyzers.push(AnalyzerMetadata {
+                name: name.to_string(),
+                description: description.to_string(),
+            });
+        }
+
+        ReportMetadata {
+            analyzers,
+        }
+    }
+}

lib/src/analysis/information_element.rs

@@ -52,31 +52,34 @@ pub enum LteInformationElement {
     //ScMcchNb(),
 }
 
-impl TryFrom<&GsmtapMessage> for LteInformationElement {
+impl TryFrom<&GsmtapMessage> for InformationElement {
     type Error = InformationElementError;
 
     fn try_from(gsmtap_msg: &GsmtapMessage) -> Result<Self, Self::Error> {
-        if let GsmtapType::LteRrc(lte_rrc_subtype) = gsmtap_msg.header.gsmtap_type {
-            use LteRrcSubtype as L;
-            use LteInformationElement as R;
-            return match lte_rrc_subtype {
-                L::DlCcch => Ok(R::DlCcch(decode(&gsmtap_msg.payload)?)),
-                L::DlDcch => Ok(R::DlDcch(decode(&gsmtap_msg.payload)?)),
-                L::UlCcch => Ok(R::UlCcch(decode(&gsmtap_msg.payload)?)),
-                L::UlDcch => Ok(R::UlDcch(decode(&gsmtap_msg.payload)?)),
-                L::BcchBch => Ok(R::BcchBch(decode(&gsmtap_msg.payload)?)),
-                L::BcchDlSch => Ok(R::BcchDlSch(decode(&gsmtap_msg.payload)?)),
-                L::PCCH => Ok(R::PCCH(decode(&gsmtap_msg.payload)?)),
-                L::MCCH => Ok(R::MCCH(decode(&gsmtap_msg.payload)?)),
-                L::ScMcch => Ok(R::ScMcch(decode(&gsmtap_msg.payload)?)),
-                L::BcchBchMbms => Ok(R::BcchBchMbms(decode(&gsmtap_msg.payload)?)),
-                L::BcchDlSchBr => Ok(R::BcchDlSchBr(decode(&gsmtap_msg.payload)?)),
-                L::BcchDlSchMbms => Ok(R::BcchDlSchMbms(decode(&gsmtap_msg.payload)?)),
-                L::SbcchSlBch => Ok(R::SbcchSlBch(decode(&gsmtap_msg.payload)?)),
-                L::SbcchSlBchV2x => Ok(R::SbcchSlBchV2x(decode(&gsmtap_msg.payload)?)),
-                _ => Err(InformationElementError::UnsupportedGsmtapType(gsmtap_msg.header.gsmtap_type)),
-            };
+        match gsmtap_msg.header.gsmtap_type {
+            GsmtapType::LteRrc(lte_rrc_subtype) => {
+                use LteRrcSubtype as L;
+                use LteInformationElement as R;
+                let lte = match lte_rrc_subtype {
+                    L::DlCcch => R::DlCcch(decode(&gsmtap_msg.payload)?),
+                    L::DlDcch => R::DlDcch(decode(&gsmtap_msg.payload)?),
+                    L::UlCcch => R::UlCcch(decode(&gsmtap_msg.payload)?),
+                    L::UlDcch => R::UlDcch(decode(&gsmtap_msg.payload)?),
+                    L::BcchBch => R::BcchBch(decode(&gsmtap_msg.payload)?),
+                    L::BcchDlSch => R::BcchDlSch(decode(&gsmtap_msg.payload)?),
+                    L::PCCH => R::PCCH(decode(&gsmtap_msg.payload)?),
+                    L::MCCH => R::MCCH(decode(&gsmtap_msg.payload)?),
+                    L::ScMcch => R::ScMcch(decode(&gsmtap_msg.payload)?),
+                    L::BcchBchMbms => R::BcchBchMbms(decode(&gsmtap_msg.payload)?),
+                    L::BcchDlSchBr => R::BcchDlSchBr(decode(&gsmtap_msg.payload)?),
+                    L::BcchDlSchMbms => R::BcchDlSchMbms(decode(&gsmtap_msg.payload)?),
+                    L::SbcchSlBch => R::SbcchSlBch(decode(&gsmtap_msg.payload)?),
+                    L::SbcchSlBchV2x => R::SbcchSlBchV2x(decode(&gsmtap_msg.payload)?),
+                    _ => return Err(InformationElementError::UnsupportedGsmtapType(gsmtap_msg.header.gsmtap_type)),
+                };
+                Ok(InformationElement::LTE(lte))
+            },
+            _ => Err(InformationElementError::UnsupportedGsmtapType(gsmtap_msg.header.gsmtap_type)),
         }
-        Err(InformationElementError::UnsupportedGsmtapType(gsmtap_msg.header.gsmtap_type))
     }
 }

lib/src/analysis/lte_downgrade.rs

@@ -5,10 +5,10 @@ use super::information_element::{InformationElement, LteInformationElement};
 use telcom_parser::lte_rrc::{BCCH_DL_SCH_MessageType, BCCH_DL_SCH_MessageType_c1, CellReselectionPriority, SystemInformationBlockType7, SystemInformationCriticalExtensions, SystemInformation_r8_IEsSib_TypeAndInfo, SystemInformation_r8_IEsSib_TypeAndInfo_Entry};
 
 /// Based on heuristic T7 from Shinjo Park's "Why We Cannot Win".
-pub struct LteSib7DowngradeAnalyzer {
+pub struct LteSib6And7DowngradeAnalyzer {
 }
 
-impl LteSib7DowngradeAnalyzer {
+impl LteSib6And7DowngradeAnalyzer {
     fn unpack_system_information<'a>(&self, ie: &'a InformationElement) -> Option<&'a SystemInformation_r8_IEsSib_TypeAndInfo> {
         if let InformationElement::LTE(LteInformationElement::BcchDlSch(bcch_dl_sch_message)) = ie {
             if let BCCH_DL_SCH_MessageType::C1(BCCH_DL_SCH_MessageType_c1::SystemInformation(system_information)) = &bcch_dl_sch_message.message {
@@ -22,13 +22,13 @@ impl LteSib7DowngradeAnalyzer {
 }
 
 // TODO: keep track of SIB state to compare LTE reselection blocks w/ 2g/3g ones
-impl Analyzer for LteSib7DowngradeAnalyzer {
+impl Analyzer for LteSib6And7DowngradeAnalyzer {
     fn get_name(&self) -> Cow<str> {
-        Cow::from("LTE SIB 7 Downgrade")
+        Cow::from("LTE SIB 6/7 Downgrade")
     }
 
     fn get_description(&self) -> Cow<str> {
-        Cow::from("Tests for LTE cells broadcasting a SIB type 7 which include 2G/3G frequencies with higher priorities.")
+        Cow::from("Tests for LTE cells broadcasting a SIB type 6 and 7 which include 2G/3G frequencies with higher priorities.")
     }
 
     fn analyze_information_element(&mut self, ie: &InformationElement) -> Option<super::analyzer::Event> {
@@ -41,7 +41,7 @@ impl Analyzer for LteSib7DowngradeAnalyzer {
                             if let Some(CellReselectionPriority(p)) = carrier_info.cell_reselection_priority {
                                 if p == 0 {
                                     return Some(Event {
-                                        event_type: EventType::QualitativeWarning(Severity::High),
+                                        event_type: EventType::QualitativeWarning { severity: Severity::High },
                                         message: "LTE cell advertised a 3G cell for priority 0 reselection".to_string(),
                                     });
                                 }
@@ -53,7 +53,7 @@ impl Analyzer for LteSib7DowngradeAnalyzer {
                             if let Some(CellReselectionPriority(p)) = carrier_info.cell_reselection_priority {
                                 if p == 0 {
                                     return Some(Event {
-                                        event_type: EventType::QualitativeWarning(Severity::High),
+                                        event_type: EventType::QualitativeWarning { severity: Severity::High },
                                         message: "LTE cell advertised a 3G cell for priority 0 reselection".to_string(),
                                     });
                                 }
@@ -66,7 +66,7 @@ impl Analyzer for LteSib7DowngradeAnalyzer {
                         if let Some(CellReselectionPriority(p)) = carrier_info.common_info.cell_reselection_priority {
                             if p == 0 {
                                 return Some(Event {
-                                    event_type: EventType::QualitativeWarning(Severity::High),
+                                    event_type: EventType::QualitativeWarning { severity: Severity::High },
                                     message: "LTE cell advertised a 2G cell for priority 0 reselection".to_string(),
                                 });
                             }

lib/src/gsmtap_parser.rs

@@ -4,15 +4,6 @@ use crate::gsmtap::*;
 use log::error;
 use thiserror::Error;
 
-pub struct GsmtapParser {
-}
-
-impl Default for GsmtapParser {
-    fn default() -> Self {
-        GsmtapParser::new()
-    }
-}
-
 #[derive(Debug, Error)]
 pub enum GsmtapParserError {
     #[error("Invalid LteRrcOtaMessage ext header version {0}")]
@@ -21,119 +12,113 @@ pub enum GsmtapParserError {
     InvalidLteRrcOtaHeaderPduNum(u8, u8),
 }
 
-impl GsmtapParser {
-    pub fn new() -> Self {
-        GsmtapParser {}
-    }
-
-    pub fn recv_message(&mut self, msg: Message) -> Result<Option<(Timestamp, GsmtapMessage)>, GsmtapParserError> {
-        if let Message::Log { timestamp, body, .. } = msg {
-            match self.log_to_gsmtap(body)? {
-                Some(msg) => Ok(Some((timestamp, msg))),
-                None => Ok(None),
-            }
-        } else {
-            Ok(None)
-        }
-    }
-
-    fn log_to_gsmtap(&self, value: LogBody) -> Result<Option<GsmtapMessage>, GsmtapParserError> {
-        match value {
-            LogBody::LteRrcOtaMessage { ext_header_version, packet } => {
-                let gsmtap_type = match ext_header_version {
-                    0x02 | 0x03 | 0x04 | 0x06 | 0x07 | 0x08 | 0x0d | 0x16 => match packet.get_pdu_num() {
-                        1 => GsmtapType::LteRrc(LteRrcSubtype::BcchBch),
-                        2 => GsmtapType::LteRrc(LteRrcSubtype::BcchDlSch),
-                        3 => GsmtapType::LteRrc(LteRrcSubtype::MCCH),
-                        4 => GsmtapType::LteRrc(LteRrcSubtype::PCCH),
-                        5 => GsmtapType::LteRrc(LteRrcSubtype::DlCcch),
-                        6 => GsmtapType::LteRrc(LteRrcSubtype::DlDcch),
-                        7 => GsmtapType::LteRrc(LteRrcSubtype::UlCcch),
-                        8 => GsmtapType::LteRrc(LteRrcSubtype::UlDcch),
-                        pdu => return Err(GsmtapParserError::InvalidLteRrcOtaHeaderPduNum(ext_header_version, pdu)),
-                    },
-                    0x09 | 0x0c => match packet.get_pdu_num() {
-                        8 => GsmtapType::LteRrc(LteRrcSubtype::BcchBch),
-                        9 => GsmtapType::LteRrc(LteRrcSubtype::BcchDlSch),
-                        10 => GsmtapType::LteRrc(LteRrcSubtype::MCCH),
-                        11 => GsmtapType::LteRrc(LteRrcSubtype::PCCH),
-                        12 => GsmtapType::LteRrc(LteRrcSubtype::DlCcch),
-                        13 => GsmtapType::LteRrc(LteRrcSubtype::DlDcch),
-                        14 => GsmtapType::LteRrc(LteRrcSubtype::UlCcch),
-                        15 => GsmtapType::LteRrc(LteRrcSubtype::UlDcch),
-                        pdu => return Err(GsmtapParserError::InvalidLteRrcOtaHeaderPduNum(ext_header_version, pdu)),
-                    },
-                    0x0e..=0x10 => match packet.get_pdu_num() {
-                        1 => GsmtapType::LteRrc(LteRrcSubtype::BcchBch),
-                        2 => GsmtapType::LteRrc(LteRrcSubtype::BcchDlSch),
-                        4 => GsmtapType::LteRrc(LteRrcSubtype::MCCH),
-                        5 => GsmtapType::LteRrc(LteRrcSubtype::PCCH),
-                        6 => GsmtapType::LteRrc(LteRrcSubtype::DlCcch),
-                        7 => GsmtapType::LteRrc(LteRrcSubtype::DlDcch),
-                        8 => GsmtapType::LteRrc(LteRrcSubtype::UlCcch),
-                        9 => GsmtapType::LteRrc(LteRrcSubtype::UlDcch),
-                        pdu => return Err(GsmtapParserError::InvalidLteRrcOtaHeaderPduNum(ext_header_version, pdu)),
-                    },
-                    0x13 | 0x1a | 0x1b => match packet.get_pdu_num() {
-                        1 => GsmtapType::LteRrc(LteRrcSubtype::BcchBch),
-                        3 => GsmtapType::LteRrc(LteRrcSubtype::BcchDlSch),
-                        6 => GsmtapType::LteRrc(LteRrcSubtype::MCCH),
-                        7 => GsmtapType::LteRrc(LteRrcSubtype::PCCH),
-                        8 => GsmtapType::LteRrc(LteRrcSubtype::DlCcch),
-                        9 => GsmtapType::LteRrc(LteRrcSubtype::DlDcch),
-                        10 => GsmtapType::LteRrc(LteRrcSubtype::UlCcch),
-                        11 => GsmtapType::LteRrc(LteRrcSubtype::UlDcch),
-                        45 => GsmtapType::LteRrc(LteRrcSubtype::BcchBchNb),
-                        46 => GsmtapType::LteRrc(LteRrcSubtype::BcchDlSchNb),
-                        47 => GsmtapType::LteRrc(LteRrcSubtype::PcchNb),
-                        48 => GsmtapType::LteRrc(LteRrcSubtype::DlCcchNb),
-                        49 => GsmtapType::LteRrc(LteRrcSubtype::DlDcchNb),
-                        50 => GsmtapType::LteRrc(LteRrcSubtype::UlCcchNb),
-                        52 => GsmtapType::LteRrc(LteRrcSubtype::UlDcchNb),
-                        pdu => return Err(GsmtapParserError::InvalidLteRrcOtaHeaderPduNum(ext_header_version, pdu)),
-                    }
-                    0x14 | 0x18 | 0x19 => match packet.get_pdu_num() {
-                        1 => GsmtapType::LteRrc(LteRrcSubtype::BcchBch),
-                        2 => GsmtapType::LteRrc(LteRrcSubtype::BcchDlSch),
-                        4 => GsmtapType::LteRrc(LteRrcSubtype::MCCH),
-                        5 => GsmtapType::LteRrc(LteRrcSubtype::PCCH),
-                        6 => GsmtapType::LteRrc(LteRrcSubtype::DlCcch),
-                        7 => GsmtapType::LteRrc(LteRrcSubtype::DlDcch),
-                        8 => GsmtapType::LteRrc(LteRrcSubtype::UlCcch),
-                        9 => GsmtapType::LteRrc(LteRrcSubtype::UlDcch),
-                        54 => GsmtapType::LteRrc(LteRrcSubtype::BcchBchNb),
-                        55 => GsmtapType::LteRrc(LteRrcSubtype::BcchDlSchNb),
-                        56 => GsmtapType::LteRrc(LteRrcSubtype::PcchNb),
-                        57 => GsmtapType::LteRrc(LteRrcSubtype::DlCcchNb),
-                        58 => GsmtapType::LteRrc(LteRrcSubtype::DlDcchNb),
-                        59 => GsmtapType::LteRrc(LteRrcSubtype::UlCcchNb),
-                        61 => GsmtapType::LteRrc(LteRrcSubtype::UlDcchNb),
-                        pdu => return Err(GsmtapParserError::InvalidLteRrcOtaHeaderPduNum(ext_header_version, pdu)),
-                    },
-                    _ => return Err(GsmtapParserError::InvalidLteRrcOtaExtHeaderVersion(ext_header_version)),
-                };
-                let mut header = GsmtapHeader::new(gsmtap_type);
-                // Wireshark GSMTAP only accepts 14 bits of ARFCN
-                header.arfcn = packet.get_earfcn().try_into().unwrap_or(0);
-                header.frame_number = packet.get_sfn();
-                header.subslot = packet.get_subfn();
-                Ok(Some(GsmtapMessage {
-                    header,
-                    payload: packet.take_payload(),
-                }))
-            },
-            LogBody::Nas4GMessage { msg, .. } => {
-                // currently we only handle "plain" (i.e. non-secure) NAS messages
-                let header = GsmtapHeader::new(GsmtapType::LteNas(LteNasSubtype::Plain));
-                Ok(Some(GsmtapMessage {
-                    header,
-                    payload: msg,
-                }))
-            },
-            _ => {
-                error!("gsmtap_sink: ignoring unhandled log type: {:?}", value);
-                Ok(None)
-            },
+pub fn parse(msg: Message) -> Result<Option<(Timestamp, GsmtapMessage)>, GsmtapParserError> {
+    if let Message::Log { timestamp, body, .. } = msg {
+        match log_to_gsmtap(body)? {
+            Some(msg) => Ok(Some((timestamp, msg))),
+            None => Ok(None),
         }
+    } else {
+        Ok(None)
+    }
+}
+
+fn log_to_gsmtap(value: LogBody) -> Result<Option<GsmtapMessage>, GsmtapParserError> {
+    match value {
+        LogBody::LteRrcOtaMessage { ext_header_version, packet } => {
+            let gsmtap_type = match ext_header_version {
+                0x02 | 0x03 | 0x04 | 0x06 | 0x07 | 0x08 | 0x0d | 0x16 => match packet.get_pdu_num() {
+                    1 => GsmtapType::LteRrc(LteRrcSubtype::BcchBch),
+                    2 => GsmtapType::LteRrc(LteRrcSubtype::BcchDlSch),
+                    3 => GsmtapType::LteRrc(LteRrcSubtype::MCCH),
+                    4 => GsmtapType::LteRrc(LteRrcSubtype::PCCH),
+                    5 => GsmtapType::LteRrc(LteRrcSubtype::DlCcch),
+                    6 => GsmtapType::LteRrc(LteRrcSubtype::DlDcch),
+                    7 => GsmtapType::LteRrc(LteRrcSubtype::UlCcch),
+                    8 => GsmtapType::LteRrc(LteRrcSubtype::UlDcch),
+                    pdu => return Err(GsmtapParserError::InvalidLteRrcOtaHeaderPduNum(ext_header_version, pdu)),
+                },
+                0x09 | 0x0c => match packet.get_pdu_num() {
+                    8 => GsmtapType::LteRrc(LteRrcSubtype::BcchBch),
+                    9 => GsmtapType::LteRrc(LteRrcSubtype::BcchDlSch),
+                    10 => GsmtapType::LteRrc(LteRrcSubtype::MCCH),
+                    11 => GsmtapType::LteRrc(LteRrcSubtype::PCCH),
+                    12 => GsmtapType::LteRrc(LteRrcSubtype::DlCcch),
+                    13 => GsmtapType::LteRrc(LteRrcSubtype::DlDcch),
+                    14 => GsmtapType::LteRrc(LteRrcSubtype::UlCcch),
+                    15 => GsmtapType::LteRrc(LteRrcSubtype::UlDcch),
+                    pdu => return Err(GsmtapParserError::InvalidLteRrcOtaHeaderPduNum(ext_header_version, pdu)),
+                },
+                0x0e..=0x10 => match packet.get_pdu_num() {
+                    1 => GsmtapType::LteRrc(LteRrcSubtype::BcchBch),
+                    2 => GsmtapType::LteRrc(LteRrcSubtype::BcchDlSch),
+                    4 => GsmtapType::LteRrc(LteRrcSubtype::MCCH),
+                    5 => GsmtapType::LteRrc(LteRrcSubtype::PCCH),
+                    6 => GsmtapType::LteRrc(LteRrcSubtype::DlCcch),
+                    7 => GsmtapType::LteRrc(LteRrcSubtype::DlDcch),
+                    8 => GsmtapType::LteRrc(LteRrcSubtype::UlCcch),
+                    9 => GsmtapType::LteRrc(LteRrcSubtype::UlDcch),
+                    pdu => return Err(GsmtapParserError::InvalidLteRrcOtaHeaderPduNum(ext_header_version, pdu)),
+                },
+                0x13 | 0x1a | 0x1b => match packet.get_pdu_num() {
+                    1 => GsmtapType::LteRrc(LteRrcSubtype::BcchBch),
+                    3 => GsmtapType::LteRrc(LteRrcSubtype::BcchDlSch),
+                    6 => GsmtapType::LteRrc(LteRrcSubtype::MCCH),
+                    7 => GsmtapType::LteRrc(LteRrcSubtype::PCCH),
+                    8 => GsmtapType::LteRrc(LteRrcSubtype::DlCcch),
+                    9 => GsmtapType::LteRrc(LteRrcSubtype::DlDcch),
+                    10 => GsmtapType::LteRrc(LteRrcSubtype::UlCcch),
+                    11 => GsmtapType::LteRrc(LteRrcSubtype::UlDcch),
+                    45 => GsmtapType::LteRrc(LteRrcSubtype::BcchBchNb),
+                    46 => GsmtapType::LteRrc(LteRrcSubtype::BcchDlSchNb),
+                    47 => GsmtapType::LteRrc(LteRrcSubtype::PcchNb),
+                    48 => GsmtapType::LteRrc(LteRrcSubtype::DlCcchNb),
+                    49 => GsmtapType::LteRrc(LteRrcSubtype::DlDcchNb),
+                    50 => GsmtapType::LteRrc(LteRrcSubtype::UlCcchNb),
+                    52 => GsmtapType::LteRrc(LteRrcSubtype::UlDcchNb),
+                    pdu => return Err(GsmtapParserError::InvalidLteRrcOtaHeaderPduNum(ext_header_version, pdu)),
+                }
+                0x14 | 0x18 | 0x19 => match packet.get_pdu_num() {
+                    1 => GsmtapType::LteRrc(LteRrcSubtype::BcchBch),
+                    2 => GsmtapType::LteRrc(LteRrcSubtype::BcchDlSch),
+                    4 => GsmtapType::LteRrc(LteRrcSubtype::MCCH),
+                    5 => GsmtapType::LteRrc(LteRrcSubtype::PCCH),
+                    6 => GsmtapType::LteRrc(LteRrcSubtype::DlCcch),
+                    7 => GsmtapType::LteRrc(LteRrcSubtype::DlDcch),
+                    8 => GsmtapType::LteRrc(LteRrcSubtype::UlCcch),
+                    9 => GsmtapType::LteRrc(LteRrcSubtype::UlDcch),
+                    54 => GsmtapType::LteRrc(LteRrcSubtype::BcchBchNb),
+                    55 => GsmtapType::LteRrc(LteRrcSubtype::BcchDlSchNb),
+                    56 => GsmtapType::LteRrc(LteRrcSubtype::PcchNb),
+                    57 => GsmtapType::LteRrc(LteRrcSubtype::DlCcchNb),
+                    58 => GsmtapType::LteRrc(LteRrcSubtype::DlDcchNb),
+                    59 => GsmtapType::LteRrc(LteRrcSubtype::UlCcchNb),
+                    61 => GsmtapType::LteRrc(LteRrcSubtype::UlDcchNb),
+                    pdu => return Err(GsmtapParserError::InvalidLteRrcOtaHeaderPduNum(ext_header_version, pdu)),
+                },
+                _ => return Err(GsmtapParserError::InvalidLteRrcOtaExtHeaderVersion(ext_header_version)),
+            };
+            let mut header = GsmtapHeader::new(gsmtap_type);
+            // Wireshark GSMTAP only accepts 14 bits of ARFCN
+            header.arfcn = packet.get_earfcn().try_into().unwrap_or(0);
+            header.frame_number = packet.get_sfn();
+            header.subslot = packet.get_subfn();
+            Ok(Some(GsmtapMessage {
+                header,
+                payload: packet.take_payload(),
+            }))
+        },
+        LogBody::Nas4GMessage { msg, .. } => {
+            // currently we only handle "plain" (i.e. non-secure) NAS messages
+            let header = GsmtapHeader::new(GsmtapType::LteNas(LteNasSubtype::Plain));
+            Ok(Some(GsmtapMessage {
+                header,
+                payload: msg,
+            }))
+        },
+        _ => {
+            error!("gsmtap_sink: ignoring unhandled log type: {:?}", value);
+            Ok(None)
+        },
     }
 }