Method get_device_for_phy_payload_relayed

chirpstack/src/uplink/data.rs:281–342

(&mut self)

    }

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

        let relay_ctx = self.relay_context.as_ref().unwrap();

        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")));
        };

        let dr = relay_ctx.req.metadata.dr;
        let ch = helpers::get_uplink_ch(
            &self.uplink_frame_set.region_config_id,
            relay_ctx.req.frequency,
            dr,
        )? as u8;

        match device::get_for_phypayload_and_incr_f_cnt_up(
            &self.uplink_frame_set.region_config_id,
            true,
            &mut self.phy_payload,
            dr,
            ch,
        )
        .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");
                    return Err(Error::Abort);
                }
                _ => {
                    return Err(Error::Anyhow(
                        anyhow::Error::new(e).context("Get device-session"),
                    ));
                }
            },