C:/asm/STM32-ethernet/ENC28J60prj/uip-master/uip/uip_arp.c

См. документацию.

/**
 * \addtogroup uip
 * @{
 */

/**
 * \defgroup uiparp uIP Address Resolution Protocol
 * @{
 *
 * Протокол разрешения адреса (Address Resolution Protocol, ARP)
 * используется для определения соответствия между адресами IP
 * и адресами уровня линка, такими как адреса Ethernet MAC. ARP
 * использует щироковещательные запросы (broadcast), чтобы запросить
 * адрес уровня линка для известного адреса IP, и хост, который
 * с конфигурирован на тот адрес IP, которому предназначен запрос,
 * ответит на него своим адресом уровня линка (т. е. передаст
 * свой MAC-адрес).
 *
 * \note Эта реализация ARP поддерживает только Ethernet.
 */
 
/**
 * \file
 * Реализация ARP Address Resolution Protocol.
 * \author Adam Dunkels <adam@dunkels.com>
 *
 */

/*
 * Copyright (c) 2001-2003, Adam Dunkels.
 * Все права зарезервированы. *
 * Повторное распространение, использование в исходном и двоичном виде,
 * с модификацией или без - разрешается, если выполняются следующие
 * условия:
 * 1. Распространение исходного кода должно сохранить вышеуказанную пометку
 *    копирайта, этот список условий и следующую правовую оговорку.
 * 2. Распространение исходного кода должно сохранить вышеуказанную пометку
 *    копирайта, этот список условий и следующую правовую оговорку в
 *    документации и/или других материалах, которые будут предоставлены
 *    вместе с распространяемыми материалами.
 * 3. Имя автора не может использоваться, чтобы подтвердить или продвинуть
 *    продукты, написанные с использованием этого программного обеспечения
 *    без специального на то разрешения.
 *
 * ЭТО ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ АВТОРОМ ``КАК ЕСТЬ'', БЕЗ
 * КАКОЙ-ЛИБО ЛЮБОЙ РАСШИРЕННОЙ ИЛИ ПОДРАЗУМЕВАЕМОЙ ГАРАНТИИ, ВКЛЮЧАЯ,
 * НО НЕ ОГРАНИЧИВАЯСЬ ЭТИМ, ГАРАНТИИ ВЫСОКОГО СПРОСА И ПРИГОДНОСТИ
 * ДЛЯ КОНКРЕТНОЙ ЦЕЛИ. АВТОР НИ ПРИ КАКИХ УСЛОВИЯХ НЕ ОТВЕТСТВЕНЕН
 * ЗА ЛЮБЫЕ УБЫТКИ - ПРЯМЫЕ, КОСВЕННЫЕ, СЛУЧАЙНЫЕ, СПЕЦИАЛЬНЫЕ, ОБРАЗЦОВЫЕ
 * ИЛИ ПОСЛЕДОВАТЕЛЬНЫЕ (ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ ЭТИМ, ТРЕБОВАНИЯ
 * ЗАМЕНЫ ТОВАРА ИЛИ СЕРВИСА; ПОТЕРИ ИСПОЛЬЗОВАНИЯ, ДАННЫХ ИЛИ ВЫГОДЫ;
 * ИЛИ ПРЕКРАЩЕНИЕ БИЗНЕСА), ОДНАКО ВЫЗВАННЫЕ ПО ЛЮБОЙ ТЕОРИИ ОТВЕТСТВЕННОСТИ,
 * ЛИБО В КОНТРАКТЕ, ПРЯМОЙ ОТВЕТСТВЕННОСТИ, ЛИБО В НАРУШЕНИИ ЗАКОННЫХ ПРАВ
 * (ВКЛЮЧАЯ ТАК ИЛИ ИНАЧЕ НЕБРЕЖНОСТЬ), ВОЗНИКАЮЩИЕ ВСЕГДА ИЗ ИСПОЛЬЗОВАНИЯ
 * ЭТОГО ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ, ДАЖЕ ЕСЛИ БЫЛО ПРЕДУПРЕЖДЕНИЕ О ВОЗМОЖНОСТИ
 * ТАКОГО ПОВРЕЖДЕНИЯ.
 *
 * Этот файл является частью стека uIP TCP/IP.
 *
 * $Id: uip_arp.c,v 1.8 2006/06/02 23:36:21 adam Exp $
 *
 */


#include "uip_arp.h"

#include <string.h>

struct arp_hdr {
  struct uip_eth_hdr ethhdr;
  u16_t hwtype;
  u16_t protocol;
  u8_t hwlen;
  u8_t protolen;
  u16_t opcode;
  struct uip_eth_addr shwaddr;
  u16_t sipaddr[2];
  struct uip_eth_addr dhwaddr;
  u16_t dipaddr[2];
};

struct ethip_hdr {
  struct uip_eth_hdr ethhdr;
  /* IP header. */
  u8_t vhl,
    tos,
    len[2],
    ipid[2],
    ipoffset[2],
    ttl,
    proto;
  u16_t ipchksum;
  u16_t srcipaddr[2],
    destipaddr[2];
};

#define ARP_REQUEST 1
#define ARP_REPLY   2

#define ARP_HWTYPE_ETH 1

struct arp_entry {
  u16_t ipaddr[2];
  struct uip_eth_addr ethaddr;
  u8_t time;
};

static const struct uip_eth_addr broadcast_ethaddr =
  {{0xff,0xff,0xff,0xff,0xff,0xff}};
static const u16_t broadcast_ipaddr[2] = {0xffff,0xffff};

static struct arp_entry arp_table[UIP_ARPTAB_SIZE];
static u16_t ipaddr[2];
static u8_t i, c;

static u8_t arptime;
static u8_t tmpage;

#define BUF   ((struct arp_hdr *)&uip_buf[0])
#define IPBUF ((struct ethip_hdr *)&uip_buf[0])
/*-----------------------------------------------------------------------------------*/
/**
 * Инициализирует модуль ARP.
 *
 */
/*-----------------------------------------------------------------------------------*/
void
uip_arp_init(void)
{
  for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
    memset(arp_table[i].ipaddr, 0, 4);
  }
}
/*-----------------------------------------------------------------------------------*/
/**
 * Функция периодической обработки ARP.
 *
 * Эта функция выполняет периодические обработки по таймеру для модуля ARP, и она
 * должна вызываться с регулярными интервалами. Рекомендованный интервал между
 * вызовами 10 секунд.
 *
 */
/*-----------------------------------------------------------------------------------*/
void
uip_arp_timer(void)
{
  struct arp_entry *tabptr;
  
  ++arptime;
  for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
    tabptr = &arp_table[i];
    if((tabptr->ipaddr[0] | tabptr->ipaddr[1]) != 0 &&
       arptime - tabptr->time >= UIP_ARP_MAXAGE) {
      memset(tabptr->ipaddr, 0, 4);
    }
  }

}
/*-----------------------------------------------------------------------------------*/
static void
uip_arp_update(u16_t *ipaddr, struct uip_eth_addr *ethaddr)
{
  register struct arp_entry *tabptr;
  /* Просмотр таблицы ARP и попытка найти запись для обновления
     Если таковая не найдена, привязка IP -> MAC будет вставлена
     в таблицу ARP. */
  for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {

    tabptr = &arp_table[i];
    /* Проверка только тех записей, которые реально используются. */
    if(tabptr->ipaddr[0] != 0 &&
       tabptr->ipaddr[1] != 0) {

      /* Проверка - соответствует ли адрес источника (source IP) приходящего
         пакета адресу IP в этой записи таблицы ARP. */
      if(ipaddr[0] == tabptr->ipaddr[0] &&
         ipaddr[1] == tabptr->ipaddr[1]) {
         /* Найдена старая запись, обновление её и возврат. */
         memcpy(tabptr->ethaddr.addr, ethaddr->addr, 6);
         tabptr->time = arptime;
         return;
      }
    }
  }

  /* Если мы оказались тут, то в таблице ARP не было найдено существующей
     записи, так что мы создадим её. */

  /* Сначала попробуем найти незадействованную запись в таблице ARP. */
  for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
    tabptr = &arp_table[i];
    if(tabptr->ipaddr[0] == 0 &&
       tabptr->ipaddr[1] == 0) {
       break;
    }
  }

  /* Если незадействованных записей не найдено, мы попробуем найти самую
     старую запись, и отбросим её. */
  if(i == UIP_ARPTAB_SIZE) {
    tmpage = 0;
    c = 0;
    for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
      tabptr = &arp_table[i];
      if(arptime - tabptr->time > tmpage) {
         tmpage = arptime - tabptr->time;
         c = i;
      }
    }
    i = c;
    tabptr = &arp_table[i];
  }

  /* Теперь заполним запись таблицы ARP новой информацией. */
  memcpy(tabptr->ipaddr, ipaddr, 4);
  memcpy(tabptr->ethaddr.addr, ethaddr->addr, 6);
  tabptr->time = arptime;
}
/*-----------------------------------------------------------------------------------*/
/**
 * Обработка ARP для приходящих пакетов IP
 *
 * Эта функция должна вызваться драйвером устройства, когда принят пакет IP.
 * Функция проверит, есть ли адрес в кэше (в таблице) ARP, и если это так,
 * то запись ARP будет обновлена в кэше (в таблице ARP). Если запись ARP 
 * в кэше не найдена, то будет создана новая запись.
 *
 * Эта функция подразумевает наличие в буфере uip_buf[] пакета IP с предварительно
 * ожидаемым заголовком Ethernet, и длина пакета должна быть в глобальной переменной
 * uip_len.
 */
/*-----------------------------------------------------------------------------------*/
#if 0
void
uip_arp_ipin(void)
{
  uip_len -= sizeof(struct uip_eth_hdr);
   
  /* Запись будет вставляться или обновляться только тогда, когда адрес источника
     (source IP) в пришедшем пакете IP поступил от хоста из локальной сети. */
  if((IPBUF->srcipaddr[0] & uip_netmask[0]) !=
     (uip_hostaddr[0] & uip_netmask[0])) {
    return;
  }
  if((IPBUF->srcipaddr[1] & uip_netmask[1]) !=
     (uip_hostaddr[1] & uip_netmask[1])) {
    return;
  }
  uip_arp_update(IPBUF->srcipaddr, &(IPBUF->ethhdr.src));
  
  return;
}
#endif /* 0 */
/*-----------------------------------------------------------------------------------*/
/**
 * Обработка ARP для приходящих пакетов ARP.
 *
 * Эта функция должна быть вызвана драйвером устройства, когда принят пакет ARP.
 * Функция будет работать по-разному, в зависимости от типа пакета ARP: если это
 * ответ на запрос (ARP reply), который был отослан ранее, то кэш ARP будет заполнен
 * значением из ответа. Если входящий ARP пакет является запросом (ARP request) на
 * наш адрес IP, то будет создан пакет ответа (ARP reply) и помещен в буфер uip_buf[].
 *
 * Когда функция делает возврат, значение глобальной переменной uip_len показывает,
 * должен или нет драйвер устройства отправить пакет. Если uip_len равна 0, то 
 * пакет отправлять не нужно. Если uip_len не равна 0, то она содержит длину 
 * исходящего пакета, который находится в буфере uip_buf[].
 *
 * Эта функция подразумевает на входе наличия пакета ARP с предварительно ожидаемым
 * заголовком Ethernet в буфере uip_buf[], и длину пакета в глобальной переменной
 * uip_len.
 */
/*-----------------------------------------------------------------------------------*/
void
uip_arp_arpin(void)
{
  
  if(uip_len < sizeof(struct arp_hdr)) {
    uip_len = 0;
    return;
  }
  uip_len = 0;
  
  switch(BUF->opcode) {
  case HTONS(ARP_REQUEST):
    /* Запрос ARP. Если запрашивается наш адрес, то отправим обратно
       ответ. */
    if(uip_ipaddr_cmp(BUF->dipaddr, uip_hostaddr)) {
      /* Сначала зарегистрируем в нашей таблице ARP того, кто сделал
         запрос, поскольку вероятно в будущем с этим хостом возможен
         обмен данными. */
      uip_arp_update(BUF->sipaddr, &BUF->shwaddr);
      
      /* Код ответа (reply opcode) равен 2. */
      BUF->opcode = HTONS(2);

      memcpy(BUF->dhwaddr.addr, BUF->shwaddr.addr, 6);
      memcpy(BUF->shwaddr.addr, uip_ethaddr.addr, 6);
      memcpy(BUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
      memcpy(BUF->ethhdr.dest.addr, BUF->dhwaddr.addr, 6);
      
      BUF->dipaddr[0] = BUF->sipaddr[0];
      BUF->dipaddr[1] = BUF->sipaddr[1];
      BUF->sipaddr[0] = uip_hostaddr[0];
      BUF->sipaddr[1] = uip_hostaddr[1];

      BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP);
      uip_len = sizeof(struct arp_hdr);
    }
    break;
  case HTONS(ARP_REPLY):
    /* Это был ответ (ARP reply). Добавим или обновим запись в таблице ARP,
       если ответ предназначался нам. */
    if(uip_ipaddr_cmp(BUF->dipaddr, uip_hostaddr)) {
      uip_arp_update(BUF->sipaddr, &BUF->shwaddr);
    }
    break;
  }

  return;
}
/*-----------------------------------------------------------------------------------*/
/**
 * Ожидается наличие присоединенного заголовка Ethernet к исходящему пакету IP,
 * и делается проверка, нужно или нет отправить запрос ARP.
 *
 * Эта функция должна быть вызвана перед отправкой пакета IP. Функция
 * проверяет адрес назначения (destination IP) пакета IP, чтобы посмотреть,
 * какой адрес Ethernet MAC должен быть использован в качестве адреса назначения
 * (destination MAC) в сети Ethernet.
 *
 * Если адрес destination IP находится в локальной сети (это определяется
 * путем операции логического И над сетевой маской и нашим адресом IP), функция
 * проверит кэш ARP, чтобы посмотреть имеется ли в ней запись для адреса 
 * destination IP. Если есть, то функция вернет присоединенный заголовок Ethernet.
 * Если в кэше ARP не найдена запись с адресом destination IP, то данные пакета
 * в буфере uip_buf[] будут заменены на пакет запроса (ARP request) на адрес
 * destination IP. Пакет IP отбрасывается, и подразумевается, что протоколы
 * более высокого уровня (например TCP) по необходимости сделают повторную 
 * передачу отброшенного пакета.
 *
 * Если адрес destination IP находится не в локальной сети, вместо этого будет
 * использоваться адрес IP шлюза по умолчанию (default router).
 *
 * Когда функция делает возврат, в буфере uip_buf[] находится пакет, и длина
 * пакета находится в глобальной переменной uip_len.
 */
/*-----------------------------------------------------------------------------------*/
void
uip_arp_out(void)
{
  struct arp_entry *tabptr;
  
  /* Ищет адрес назначения (destination IP) в таблице ARP, и конструирует
     заголовок Ethernet. Если destination IP находится не в локальной сети,
     будем использовать вместо него адрес IP шлюза по умолчанию (default router).

     Если в таблице ARP не найдена соответствующая запись, то перезапишем
     оригинальный пакет IP запросом ARP на адрес IP. */

  /* Сначала проверим адрес назначения, попадает ли он в локальное
     широковещание (local broadcast). */
  if(uip_ipaddr_cmp(IPBUF->destipaddr, broadcast_ipaddr)) {
    memcpy(IPBUF->ethhdr.dest.addr, broadcast_ethaddr.addr, 6);
  } else {
    /* Проверка - принадлежит ли адрес назначения локальной сети. */
    if(!uip_ipaddr_maskcmp(IPBUF->destipaddr, uip_hostaddr, uip_netmask)) {
      /* Адрес назначения был не в локальной сети, поэтому вместо него нужно
         использовать адрес IP шлюза по умолчанию, когда определяем
         MAC-адрес. */
      uip_ipaddr_copy(ipaddr, uip_draddr);
    } else {
      /* Иначе будет использовать адрес IP назначения. */
      uip_ipaddr_copy(ipaddr, IPBUF->destipaddr);
    }
      
    for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
      tabptr = &arp_table[i];
      if(uip_ipaddr_cmp(ipaddr, tabptr->ipaddr)) {
         break;
      }
    }

    if(i == UIP_ARPTAB_SIZE) {
      /* Адрес назначения отсутствует в нашей таблице ARP, поэтому
         перезапишем пакет IP пакетом запроса ARP. */

      memset(BUF->ethhdr.dest.addr, 0xff, 6);
      memset(BUF->dhwaddr.addr, 0x00, 6);
      memcpy(BUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
      memcpy(BUF->shwaddr.addr, uip_ethaddr.addr, 6);
    
      uip_ipaddr_copy(BUF->dipaddr, ipaddr);
      uip_ipaddr_copy(BUF->sipaddr, uip_hostaddr);
      BUF->opcode = HTONS(ARP_REQUEST); /* ARP request. */
      BUF->hwtype = HTONS(ARP_HWTYPE_ETH);
      BUF->protocol = HTONS(UIP_ETHTYPE_IP);
      BUF->hwlen = 6;
      BUF->protolen = 4;
      BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP);

      uip_appdata = &uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN];
    
      uip_len = sizeof(struct arp_hdr);
      return;
    }

    /* Создание заголовка Ethernet. */
    memcpy(IPBUF->ethhdr.dest.addr, tabptr->ethaddr.addr, 6);
  }
  memcpy(IPBUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
  
  IPBUF->ethhdr.type = HTONS(UIP_ETHTYPE_IP);

  uip_len += sizeof(struct uip_eth_hdr);
}
/*-----------------------------------------------------------------------------------*/

/** @} */
/** @} */