字数统计: 1.5k字   |   阅读时长: 6分

nfd-c添加ACK包

发送兴趣包返回数据包的代码在forwarder.c中，forwarder.c实际上包含六个函数，on_incoming_interest，onContentStoreMiss，onContentStoreHit，onOutgoingInterest，onIncomingData，onOutgoingData.

如果想要加入ACK包，应该添加两个函数,需要新添加一个包类型，ack类型的包，tlv如何编码和解码ack包，face部分应该添加一个send_ack方法。

ACK的逻辑和data包的逻辑应该是一样的，分为两部分，首先on_incoming_interest对兴趣包进行解析，如果在CS找到了与兴趣包匹配的数据包，调用on_contentstore_hit，直接通过接口返回数据包，这时候应该同时加上ACK包。

1
2
3
4
5
6
7
8
static void on_contentstore_hit(pit_entry_t *pit_entry, struct data_t *data, struct face_t *face)
{
 //send_ack(face, ack)
  send_data(face, data);
  pit_entry->is_satisfied = true;
  pit_entry->data_freshness_period_time = data->meta.freshness_period;  //设置好到期定时器
  pit_erase(pit_entry); //擦除PIT表项
}

否则应该调用on_contentstore_miss，首先将interest和face添加或者更新到PIT中，然后通过on_outgoing_interest转发兴趣包。on_outgoing_interest主要根据FIB找到下一跳的faceid，对所有可行的下一跳的face都在PIT中添加新的条目，并向这些face转发兴趣包。接着这些face又会通过on_incoming_interest继续判断，直到可以在CS中找到data包。

数据包部分主要包括on_incoming_data和on_outgoing_data。on_incoming_data首先会查PIT中有没有data对应的名字，若果没有输出"NO pit record"，实际上相当于数据包是unsolicited不请自来的。如果PIT有，就应该将数据包插入到CS中以便后续使用。然后删除这个PIT条目，然后执行on_outgoing_data转发数据包。如果到期时间大于当前时间，就将data发送到对应端口，这里同样有send_data,这里也应该加上send_ack

1
2
3
4
5
6
7
8
9
10
11
12
13
14
static void on_outgoing_data(pit_entry_t *pit_entry, struct data_t *data)
{
  // printf ("on_outgoing_data forwarder data is %s\n", data->value);

  face_record_t *face_record = pit_entry->incoming_faces;
  while (face_record != NULL)
  {
    if (face_record->expiry > time_now_us())  //如果到期时间大于当前时间，就将data发送到对应端口
     //send_ack(face_record->face, ack)
      send_data(face_record->face, data);

    face_record = face_record->next;
  }
}

添加NACK包

首先在face中添加send_nack()函数，当接口需要发送nack时调用此函数

1
2
3
4
5
6
7
8
9
10
11
12
13
void send_nack(struct face_t *face, struct Nack *nack) {
  uint8_t buf[2048];
  struct encoder enc;
  encoder_init(&enc, buf, 2048);
  int rtn = nack_tlv_encode(&enc, nack);
    if (rtn != 0) {
    ZF_LOGE("interest encode error");
    return;
  }

  if(face->status)
    face->send(face, enc.buf, enc.offset);
}

然后对on_outgoing_interest函数进行修改，原来是找不到路由直接输出no route，现在是进入on_outgoing_nack()函数，如果fib中没有，或者fib有但是没有下一跳都会进入on_outgoing_nack()函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
static void on_outgoing_interest(struct interest_t *interest, pit_entry_t *pit_entry)
{
  fib_entry_t *fib_entry = fib_find_longest_prefix_matchs(&interest->name); //根据FIB最长前缀匹配寻找下一条列表
  if (NULL == fib_entry)
  {
    //修改的部分
    struct Nack *nack;
    nack_set_reason(nack, NO_ROUTE);
    nack->interest = interest;
    on_outgoing_nack(nack, pit_entry);
    free(nack);
    //原来的部分
    //ZF_LOGW("no route");
    //return;
  }

  nexthop_t *nexthop_list = fib_entry->nexthop_list; //nexthop_list是一个链表
  if (nexthop_list == NULL)
  {
    //修改的部分
    struct Nack *nack;
    nack_set_reason(nack, NO_ROUTE);
    nack->interest = interest;
    on_outgoing_nack(nack, pit_entry);
    //原来的部分
    //ZF_LOGW("no route");
    //return;
  }

  ZF_LOGI("fib_entry = %p, face id = %d", fib_entry, nexthop_list->face->id); //找到下一跳的faceid

  //muticast
  while (nexthop_list != NULL)  //对所有下一条列表广播
  {
    //insert or update out record
    int rtn = pit_entry_add_or_update_face(pit_entry, interest, nexthop_list->face, OUTRECORDING_FLAG);
    if (rtn != 0)
    {
      ZF_LOGE("add outgoing face error");
      continue;
    }

    if (nexthop_list->face->status == FACE_STATE_UP)
    {
      // printf("out face id is %d\n", nexthop_list->face->id);
      send_interest(nexthop_list->face, interest);  //根据FIB向下一条的face发送兴趣包
      break;
    }
    nexthop_list = nexthop_list->next;
  }
}

on_outgoing_nack()函数：查找PIT的请求端口，然后发送nack包。

1
2
3
4
5
6
7
8
9
10
11
12
//新加的
static void on_outgoing_nack(struct Nack *nack, pit_entry_t *pit_entry)
{
  face_record_t *face_record = pit_entry->incoming_faces;
  while (face_record != NULL)
  {
    if (face_record->expiry > time_now_us())  //如果到期时间大于当前时间，就将data发送到对应端口
      send_nack(face_record->face,nack);
    
    face_record = face_record->next;
  }
}

on_incoming_nack()函数，也是模仿了on_incoming_data()。首先找到nack中对应的interest的名字，和PIT中的名字进行对比，如果没有则直接return，如果有就删除PIT表中的条目。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
void on_incoming_nack(struct Nack *nack, struct face_t *face)
{
  struct name_t *name = &nack->interest->name;

  pit_entry_t *pit_entry = pit_find_all_matches(name);
  if (NULL == pit_entry)
  {
    ZF_LOGI("NO pit record");
    return;
  }

  pit_entry_t *pit_entry_next = NULL;
  while (pit_entry) //删除所有匹配到的PIT的信息
  {
    pit_entry_next = pit_entry->next;

    // cancel timer
    cancel_timer(tq, pit_entry->expire_timer);  //取消定时器

    on_outgoing_nack(nack, pit_entry);  //转发nack包

    // mark PIT satisfied
    pit_entry->is_satisfied = true;
    pit_erase(pit_entry); //删除匹配到的PIT

    pit_entry = pit_entry_next;
  }
}

在main()函数中的handle_msg函数中应该加入一个nack的分支

1
2
3
4
5
6
7
8
9
10
11
12
13
14
else if(type == TLV_Nack)
{//接收到Nack包
  nack_count++;
  struct Nack *nack = (struct Nack *)malloc(sizeof(struct Nack));
  nack_init(nack);
  if(nack_tlv_decode(nack, packet, packet_len) != 0)
  {
    ZF_LOGE("verify nack failed, drop this nack");
    nack_errors ++;
    break;
  }
  on_incoming_nack(nack, recv_msg->face);
  free(nack);
}

此外，还需要对app_face进行修改，增加收到nack包的处理，实际上是PIT去调用on_nack回调，回调写在tools/app的各个应用模块中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//app-face的修改 
else if(type == TLV_Nack) {
      struct Nack *nack = (struct Nack *)malloc(sizeof(struct Nack));
      if(nack_tlv_decode(nack, packet, packet_len) != 0)
        break;

      char nack_name[name_string_length(&nack->interest->name)];
      name_to_string(&nack->interest->name, nack_name);

      pthread_mutex_lock(&app_face->app_face_mutex);
      struct pending_interest_t *pi = (struct pending_interest_t *)(htget(app_face->pending_interest_table, nack_name, strlen(nack_name)));
      pthread_mutex_unlock(&(app_face->app_face_mutex));
      // printf("data before send to terminal: %s\n", data->value);

      if (pi != NULL) //如果PIT中有数据包条目，才会进行处理
      {
        cancel_timer(app_face->tq ,pi->expire_timer);
        if (pi->on_nack)
          pi->on_nack(nack, pi->userdata);  //进入处理数据的管道
        pthread_mutex_lock(&(app_face->app_face_mutex));
        htrm(app_face->pending_interest_table, nack_name, strlen(nack_name)); //删除PIT表项
        pthread_mutex_unlock(&(app_face->app_face_mutex));

        //free(pi->nack);
        free(pi);
      }
      if (pi->on_nack)
        pi->on_nack(nack, pi->userdata);  //进入处理数据的管道
      
    }

应用层每个程序当用到express_interest时都需要新添一个on_nack回调用来处理返回的nack包。

1
2
3
4
5
6
7
void on_nack(const struct Nack *nack, void *userdata)
{
  char nack_name_str[name_string_length(&nack->interest->name)];
  name_to_string(&nack->interest->name, nack_name_str);
  std::string nack_name(nack_name_str, strlen(nack_name_str));
  printf("recv nack: %s, reason %d\n", nack_name.c_str(), nack->reason);
}

发送端直接没有路就会进入app_face的process_events的disconnect管道

扫一扫，分享到微信

微信分享二维码
本站总访问量次 |

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

这一定是一个<br><br>很长很长的一生啊