Rust生命周期问题排查：BGP路由表构建中的引用生命周期错误

我在理解Rust生命周期概念时遇到了问题。尝试用bgpkit_parser crate通过URL读取bz2文件并创建基数树（radix trie），在build_routetable函数中，从文件提取AS Path字段得到path，处理后得到clean_path向量，执行let origin = clean_path.last()获取最后一个元素时，Rust抛出E0597错误，提示clean_path在仍被借用时就被销毁，搞不懂错误原因。

相关代码如下：

fn as_parser(element: &BgpElem) -> Vec<u32> {
    let x = &element.as_path.as_ref().unwrap().segments[0];
    let mut as_vec = &Vec::new();
    let mut as_path: Vec<u32> = Vec::new();
    if let AsPathSegment::AsSequence(value) = x {
        as_vec = value;
    }
    for i in as_vec {
        as_path.push(i.asn); 
    }
    return as_path;
}

fn prefix_parser(element: &BgpElem) -> String {
    let subnet_id = element.prefix.prefix.ip().to_string().to_owned();
    let prefix_id = element.prefix.prefix.prefix().to_string().to_owned();
    let prefix = format!("{}/{}", subnet_id, prefix_id);//.as_str();
    return prefix;
}

fn get_aspath(raw_aspath: Vec<u32>) -> Vec<u32> {
    let mut as_path = Vec::new();
    for i in raw_aspath {
        if i < 64511 {
            if as_path.contains(&i) {
                continue;
            }
            else {
                as_path.push(i);
            }
        }
        else if 65535 < i && i < 4000000000 {
            if as_path.contains(&i) {
                continue;
            }
            else {
                as_path.push(i);
            }
        }
    }
    return as_path;
}

fn build_routetable(mut trie4: Trie<String, Option<&u32>>, mut trie6: Trie<String, Option<&u32>>) {
    let url: &str = "http://archive.routeviews.org/route-views.chile/
        bgpdata/2022.06/RIBS/rib.20220601.0000.bz2";
    let parser = BgpkitParser::new(url).unwrap();
    let mut count = 0;
    for elem in parser {
        if elem.elem_type == bgpkit_parser::ElemType::ANNOUNCE {
            let record_timestamp = &elem.timestamp;
            let record_type = "A";
            let peer = &elem.peer_ip;
            let prefix = prefix_parser(&elem);
            let path = as_parser(&elem);
            let clean_path = get_aspath(path);
            
            // Issue is on the below line
            // `clean_path` does not live long enough
            // borrowed value does not live long
            // enough rustc E0597
            // main.rs(103, 9): `clean_path` dropped 
            // here while still borrowed 
            // main.rs(77, 91): let's call the
            // lifetime of this reference `'1` 
            // main.rs(92, 17): argument requires 
            // that `clean_path` is borrowed for `'1`
            
            let origin = clean_path.last(); //issue line
            if prefix.contains(":") {
                trie6.insert(prefix, origin);
            }
            else {
                trie4.insert(prefix, origin);
            }
            count+=1;
            if count >= 10000 {
                println!("{:?} | {:?} | {:?} | {:?} | {:?}", 
                record_type, record_timestamp, peer, prefix, path);
                count=0
            }
        };
    }
    println!("Trie4 size: {:?} prefixes", trie4.len());
    println!("Trie6 size: {:?} prefixes", trie6.len());
    
}

错误核心原因 #

你试图将指向clean_path内部元素的引用（Option<&u32>）存入基数树trie4/trie6，但clean_path是循环内的局部变量，每次循环迭代结束后就会被销毁释放内存。而基数树的生命周期远长于循环，这就导致引用指向了已经失效的内存区域，违反了Rust的内存安全规则，因此编译器抛出E0597错误。

解决方案 #

要解决这个问题，核心是让基数树存储拥有所有权的值而非引用，具体有以下可行方式：

1. 存储Option<u32>而非引用 #

修改基数树的类型为Trie<String, Option<u32>>，并将origin从引用转换为拥有所有权的值：

// 修改build_routetable的参数类型
fn build_routetable(mut trie4: Trie<String, Option<u32>>, mut trie6: Trie<String, Option<u32>>) {
    // ... 其他代码保持不变 ...
    let origin = clean_path.last().copied(); // 使用copied()将&u32转为u32
    if prefix.contains(":") {
        trie6.insert(prefix, origin);
    } else {
        trie4.insert(prefix, origin);
    }
    // ... 其他代码保持不变 ...
}

这样基数树直接持有u32的所有权，不再依赖clean_path的生命周期，彻底解决引用失效问题。

2. 额外优化建议 #

• 简化as_parser函数，避免冗余代码：

  fn as_parser(element: &BgpElem) -> Vec<u32> {
      let segments = element.as_path.as_ref().unwrap();
      if let Some(AsPathSegment::AsSequence(value)) = segments.segments.first() {
          value.iter().map(|item| item.asn).collect()
      } else {
          Vec::new()
      }
  }
  

• 用HashSet优化get_aspath的去重逻辑，降低时间复杂度：

  use std::collections::HashSet;
  
  fn get_aspath(raw_aspath: Vec<u32>) -> Vec<u32> {
      let mut seen = HashSet::new();
      raw_aspath.into_iter()
          .filter(|&i| (i < 64511) || (65535 < i && i < 4000000000))
          .filter(|i| seen.insert(*i))
          .collect()
  }
  

内容的提问来源于stack exchange，提问作者e110