Method get_device_for_phy_payload

chirpstack/src/uplink/data.rs:221–279

(&mut self)

    }

    async fn get_device_for_phy_payload(&mut self) -> Result<(), Error> {
        trace!("Getting device for PhyPayload");

        let dev_addr = if let lrwn::Payload::MACPayload(pl) = &self.phy_payload.payload {
            pl.fhdr.devaddr
        } else {
            return Err(Error::Anyhow(anyhow!("No MacPayload in PhyPayload")));
        };

        match device::get_for_phypayload_and_incr_f_cnt_up(
            &self.uplink_frame_set.region_config_id,
            false,
            &mut self.phy_payload,
            self.uplink_frame_set.dr,
            self.uplink_frame_set.ch as u8,
        )
        .await
        {
            Ok(v) => match v {
                device::ValidationStatus::Ok(f_cnt, d) => {
                    self.device = Some(d);
                    self.f_cnt_up_full = f_cnt;
                }
                device::ValidationStatus::Retransmission(f_cnt, d) => {
                    self.retransmission = true;
                    self.device = Some(d);
                    self.f_cnt_up_full = f_cnt;
                }
                device::ValidationStatus::Reset(f_cnt, d) => {
                    self.reset = true;
                    self.device = Some(d);
                    self.f_cnt_up_full = f_cnt;
                }
            },
            Err(e) => match e {
                StorageError::NotFound(s) => {
                    info!(dev_addr = %s, "No device-session exists for dev_addr");
                    return Err(Error::Abort);
                }
                StorageError::InvalidMIC => {
                    info!(dev_addr = %dev_addr, "None of the device-sessions for dev_addr resulted in valid MIC");

                    // Log uplink for null DevEUI.
                    let mut ufl: stream_pb::UplinkFrameLog = (&self.uplink_frame_set).try_into()?;
                    ufl.dev_eui = "0000000000000000".to_string();
                    stream::frame::log_uplink_for_device(&ufl).await?;

                    return Err(Error::Abort);
                }
                _ => {
                    return Err(Error::Anyhow(
                        anyhow::Error::new(e).context("Get device-session"),
                    ));
                }
            },
        };

        Ok(())