C:/asm/STM32-ethernet/ENC28J60prj/uip-master/uip/uip.h

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

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

/**
 * \file
 * Заголовочный файл для стека uIP TCP/IP.
 * \author Adam Dunkels <adam@dunkels.com>
 *
 * Этот заголовочный файл стека uIP TCP/IP содержит определения нескольких
 * макросов C, которые используются программами uIP, а также внутренними
 * структурами uIP, структурами заголовка TCP/IP и декларациями фунций.
 *
 */


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

#ifndef __UIP_H__
#define __UIP_H__

#include "uipopt.h"

/**
 * Представление адреса IP.
 *
 */
typedef u16_t uip_ip4addr_t[2];
typedef u16_t uip_ip6addr_t[8];
#if UIP_CONF_IPV6
typedef uip_ip6addr_t uip_ipaddr_t;
#else /* UIP_CONF_IPV6 */
typedef uip_ip4addr_t uip_ipaddr_t;
#endif /* UIP_CONF_IPV6 */

/*---------------------------------------------------------------------------*/
/* Сначала приведены функции, которые должны вызываться из системы.
 * Инициализация, периодический таймер и приходящие пакеты обрабатываются
 * тремя следующими функциями.
 */

/**
 * \defgroup uipconffunc Функции конфирурации uIP
 * @{
 *
 * Функции конфигурации uIP используются для установки во время выполнения
 * (run-time) параметров, таких как например адресов IP.
 */

/**
 * Устанавливает IP-адрес хоста.
 *
 * Адрес IP представлен как 4-байтный массив, где первый октет адреса IP
 * помещается первым в 4-байтном массиве.
 *
 * Пример:
 \code

 uip_ipaddr_t addr;

 uip_ipaddr(&addr, 192,168,1,2);
 uip_sethostaddr(&addr);
 
 \endcode
 * \param addr Указатель на адрес IP типа uip_ipaddr_t;
 *
 * \sa uip_ipaddr()
 *
 * \hideinitializer
 */
#define uip_sethostaddr(addr) uip_ipaddr_copy(uip_hostaddr, (addr))

/**
 * Получает IP-адрес хоста.
 *
 * Адрес IP представлен как 4-байтный массив, где первый октет адреса IP
 * помещается первым в 4-байтном массиве.
 *
 * Пример:
 \code
 uip_ipaddr_t hostaddr;

 uip_gethostaddr(&hostaddr);
 \endcode
 * \param addr Указатель на переменную uip_ipaddr_t, которая будет заполнена
 * текущим сконфигурированным IP-адресом.
 *
 * \hideinitializer
 */
#define uip_gethostaddr(addr) uip_ipaddr_copy((addr), uip_hostaddr)

/**
 * Адрес IP шлюза (маршрутизатора) по умолчанию.
 *
 * \param addr Указатель на переменную uip_ipaddr_t, содержащую IP-адрес
 * для default router.
 *
 * \sa uip_ipaddr()
 *
 * \hideinitializer
 */
#define uip_setdraddr(addr) uip_ipaddr_copy(uip_draddr, (addr))

/**
 * Устанавливает маску подсети (netmask).
 *
 * \param addr Указатель на переменную uip_ipaddr_t, содержащую
 * значение маски подсети.
 *
 * \sa uip_ipaddr()
 *
 * \hideinitializer
 */
#define uip_setnetmask(addr) uip_ipaddr_copy(uip_netmask, (addr))


/**
 * Получает IP-адрес шлюза по умолчанию.
 *
 * \param addr Указатель на переменную uip_ipaddr_t, которая будет
 * заполнена значением IP-адреса для default router.
 *
 * \hideinitializer
 */
#define uip_getdraddr(addr) uip_ipaddr_copy((addr), uip_draddr)

/**
 * Получает маску подсети (netmask).
 *
 * \param addr Указатель на переменную uip_ipaddr_t, которая будет
 * заполнена значением маски подсети.
 *
 * \hideinitializer
 */
#define uip_getnetmask(addr) uip_ipaddr_copy((addr), uip_netmask)

/** @} */

/**
 * \defgroup uipinit Функции инициализации uIP
 * @{
 *
 * Функции инициализации uIP используются для запуска uIP.
 */

/**
 * Функция инициализации uIP.
 *
 * Эта функция должна быть вызвана в момент загрузки системы, чтобы
 * она проинициализировала стек uIP TCP/IP stack.
 */
void uip_init(void);

/**
 * Функция инициализации uIP.
 *
 * Эта функция должна быть вызвана в момент загрузки системы для 
 * установки изначального ip_id.
 */
void uip_setipid(u16_t id);

/** @} */

/**
 * \defgroup uipdevfunc Функции драйвера устройства uIP
 * @{
 *
 * Эти функции используются сетевым драйвером устройства, который
 * работает совместно с uIP.
 */

/**
 * Обрабатывает приходящий пакет.
 *
 * Эта функция должна быть вызвана, когда драйвер устройства принял
 * пакет через сеть. Пакет от драйвера устройства должен находиться
 * в буфере uip_buf, и длина пакета должна быть помещена в переменную
 * uip_len.
 *
 * Когда функция делает возврат, она может поместить исходящий пакет
 * в тот же буфер uip_buf. Если это так, то переменная uip_len 
 * устанавливается в значение длины этого пакета. Если нет пакета для
 * отправки, то значение переменной uip_len устанавливается равным 0.
 *
 * В коде ниже показан обычный способ вызова функции.
 \code
  uip_len = devicedriver_poll();
  if(uip_len > 0) {
    uip_input();
    if(uip_len > 0) {
      devicedriver_send();
    }
  }
 \endcode
 *
 * \note Если Вы пишете драйвер устройства uIP, которому нужен ARP
 * (Address Resolution Protocol), например когда uIP работает через
 * Ethernet, то Вам нужно перед вызовом этой функции вызвать
 * код uIP ARP:
 \code
  #define BUF ((struct uip_eth_hdr *)&uip_buf[0])
  uip_len = ethernet_devicedrver_poll();
  if(uip_len > 0) {
    if(BUF->type == HTONS(UIP_ETHTYPE_IP)) {
      uip_arp_ipin();
      uip_input();
      if(uip_len > 0) {
        uip_arp_out();
        ethernet_devicedriver_send();
      }
    } else if(BUF->type == HTONS(UIP_ETHTYPE_ARP)) {
      uip_arp_arpin();
      if(uip_len > 0) {
        ethernet_devicedriver_send();
      }
    }
 \endcode
 *
 * \hideinitializer
 */
#define uip_input()        uip_process(UIP_DATA)

/**
 * Периодическая обработка соединения, идентифицируемого по его номеру.
 *
 * Эта функция делает необходимые периодические обработки (таймеры,
 * поллинг) для соединения uIP TCP, и должна вызываться по срабатыванию
 * периодического таймера uIP. Она должна быть вызвана для каждого
 * соединения, назависимо от того - открыто это соединение или закрыто.
 *
 * Когда функция делает возврат, она может поместить в буфер пакета uIP
 * исходящий пакет, ожидающий отправки. Если это так, то переменная 
 * uip_len будет установлена в ненулевое значение. Чтобы отправить пакет,
 * должен быть вызван драйвер устройства.
 *
 * Обычно функция вызывается из цикла for() примерно так:
 \code
  for(i = 0; i < UIP_CONNS; ++i) {
    uip_periodic(i);
    if(uip_len > 0) {
      devicedriver_send();
    }
  }
 \endcode
 *
 * \note Если Вы пишете драйвер устройства uIP, которому нужен ARP
 * (Address Resolution Protocol), например когда uIP работает через
 * Ethernet, то Вам нужно вызвать функцию uip_arp_out() перед вызовом
 * драйвера устройства:
 \code
  for(i = 0; i < UIP_CONNS; ++i) {
    uip_periodic(i);
    if(uip_len > 0) {
      uip_arp_out();
      ethernet_devicedriver_send();
    }
  }
 \endcode
 *
 * \param conn Номер соединения, которое периодически опрашивается.
 *
 * \hideinitializer
 */
#define uip_periodic(conn) do { uip_conn = &uip_conns[conn]; \
                                uip_process(UIP_TIMER); } while (0)

/**
 *
 *
 */
#define uip_conn_active(conn) (uip_conns[conn].tcpstateflags != UIP_CLOSED)

/**
 * Выполняет периодические обработки соединения, идентифицируемого по
 * указателю на его структуру.
 *
 * То же самое, что и uip_periodic(), однако принимает в аргументе указатель
 * на реальную структуру uip_conn вместо целого числа. Эта функция может быть
 * использована для принудиельной периодической обработки отдельного соединения.
 *
 * \param conn Указатель на структуру uip_conn для обрабатываемого соединения.
 *
 * \hideinitializer
 */
#define uip_periodic_conn(conn) do { uip_conn = conn; \
                                     uip_process(UIP_TIMER); } while (0)

/**
 * Запрашивает отдельное соединение, которое должно быть опрошено.
 *
 * То же самое, что и uip_periodic_conn(), но не делает обработку по таймеру.
 * Приложение опрашивает появление новых данных.
 *
 * \param conn Указатель на структуру uip_conn для обрабатываемого
 * соединения.
 *
 * \hideinitializer
 */
#define uip_poll_conn(conn) do { uip_conn = conn; \
                                 uip_process(UIP_POLL_REQUEST); } while (0)


#if UIP_UDP
/**
 * Периодическая обработка соединения UDP, идентифицированного по его номеру.
 *
 * Эта функция точно такая же, как и uip_periodic(), но для соединений
 * UDP. Она вызывается точно так же, как и функция uip_periodic():
 \code
  for(i = 0; i < UIP_UDP_CONNS; i++) {
    uip_udp_periodic(i);
    if(uip_len > 0) {
      devicedriver_send();
    }
  }
 \endcode
 *
 * \note Как и при использовании функции uip_periodic(), нужно позаботиться
 * taken о том, как использовать её при задействовании uIP вместе с ARP и Ethernet:
 \code
  for(i = 0; i < UIP_UDP_CONNS; i++) {
    uip_udp_periodic(i);
    if(uip_len > 0) {
      uip_arp_out();
      ethernet_devicedriver_send();
    }
  }
 \endcode
 *
 * \param conn Номер обрабатываемого соединения UDP.
 *
 * \hideinitializer
 */
#define uip_udp_periodic(conn) do { uip_udp_conn = &uip_udp_conns[conn]; \
                                uip_process(UIP_UDP_TIMER); } while (0)

/**
 * Периодическая обработка соединения UDP, идентифицированного по указателю
 * на его структуру.
 *
 * То же самое, что и uip_udp_periodic(), но в качестве аргумента вместо
 * целого числа принимает указатель на реальную структуру uip_conn.
 * Эта функция может использоваться для принудительной периодической обработки
 * отдельного соединения.
 *
 * \param conn Указатель на структуру uip_udp_conn для обрабатываемого
 * соединения.
 *
 * \hideinitializer
 */
#define uip_udp_periodic_conn(conn) do { uip_udp_conn = conn; \
                                         uip_process(UIP_UDP_TIMER); } while (0)


#endif /* UIP_UDP */

/**
 * Буфер пакета uIP.
 *
 * Массив uip_buf используется для того, чтобы хранить входящие и исходящие
 * пакеты. Драйвер устройства должен поместить в этот буфер приходящие данные.
 * Когда данные отправляются, драйвер устройства должен читать заголовки уровня
 * линка и заголовки TCP/IP из этого буфера. Размер заголовков уровня линка
 * конфигурируется дефайном UIP_LLH_LEN.
 *
 * \note Данные приложения должны быть помещены в этот буфер, так что драйвер
 * устройства должен читать их с места, указанного через указатель uip_appdata,
 * как это показано в следующем примере:
 \code
 void
 devicedriver_send(void)
 {
    hwsend(&uip_buf[0], UIP_LLH_LEN);
    if(uip_len <= UIP_LLH_LEN + UIP_TCPIP_HLEN) {
      hwsend(&uip_buf[UIP_LLH_LEN], uip_len - UIP_LLH_LEN);
    } else {
      hwsend(&uip_buf[UIP_LLH_LEN], UIP_TCPIP_HLEN);
      hwsend(uip_appdata, uip_len - UIP_TCPIP_HLEN - UIP_LLH_LEN);
    }
 }
 \endcode
 */
extern u8_t uip_buf[UIP_BUFSIZE+2];

/** @} */

/*---------------------------------------------------------------------------*/
/* Функции, которые используются программой приложения uIP. Открытие и
 * и закрытие соединений, отправка и прием данных и т. п. действия
 * обрбатываются следующими функциями.
*/
/**
 * \defgroup uipappfunc Функции приложения uIP
 * @{
 *
 * Функции, используемые в приложении, работающем поверх uIP.
 */

/**
 * Запуск прослушивания указанного порта.
 *
 * \note Поскольку эта функция ожидает номер порта с сетевым порядком байт,
 * то при необходимости должно быть применено преобразование HTONS() или htons().
 *
 \code
 uip_listen(HTONS(80));
 \endcode
 *
 * \param port 16-битный номер порта с сетевым порядком байт.
 */
void uip_listen(u16_t port);

/**
 * Остановить прослушивание указанного порта.
 *
 * \note Поскольку эта функция ожидает номер порта с сетевым порядком байт,
 * то при необходимости должно быть применено преобразование HTONS() или htons().
 *
 \code
 uip_unlisten(HTONS(80));
 \endcode
 *
 * \param port 16-битный номер порта с сетевым порядком байт.
 */
void uip_unlisten(u16_t port);

/**
 * Соединение с дальним хостом (remote host), используя TCP.
 *
 * Эта функция используется для запуска нового соединения с указанным портом
 * указанного хоста. Она выделяет новый идентификатор соединения,
 * устанавливает соединение в состояние SYN_SENT и устанавливает таймер
 * ретрансмиссии в 0. Это приведет к тому, что будет передан сегмент TCP SYN
 * в следующий раз, когда это соединение будет периодически обработано,
 * что будет сделано обычно через 0.5 секунд после вызова uip_connect().
 *
 * \note Эта функция доступна, только если активна поддержка активного открытого
 * соединения путем задания UIP_ACTIVE_OPEN на значение 1 в файле uipopt.h.
 *
 * \note Поскольку эта функция ожидает номер порта с сетевым порядком байт,
 * то при необходимости должно быть применено преобразование HTONS() или htons().
 *
 \code
 uip_ipaddr_t ipaddr;

 uip_ipaddr(&ipaddr, 192,168,1,2);
 uip_connect(&ipaddr, HTONS(80));
 \endcode
 *
 * \param ripaddr IP-адрес для remote hot.
 *
 * \param port 16-битный номер порта с сетевым порядком байт.
 *
 * \return Указатель на идентификатор соединения uI для нового соединения,
 * или NULL, если не может быть выделено новое соединение.
 *
 */
struct uip_conn *uip_connect(uip_ipaddr_t *ripaddr, u16_t port);



/**
 * \internal
 *
 * Проверка - есть ли на соединении потерянные (например не подтвержденные)
 * данные.
 *
 * \param conn Указатель на структуру uip_conn для соединения.
 *
 * \hideinitializer
 */
#define uip_outstanding(conn) ((conn)->len)

/**
 * Посылает данные через текущее соединение.
 *
 * Эта функция используется для отправки одного сегмента данных TCP.
 * Могут отправлять данные только приложения, которые были вызваны из
 * uIP для обработки события.
 *
 * Количество данных, которое было на самом деле отправлено после вызова
 * этой функции, определяется максимальным количеством данны, которое
 * позволяет TCP. uIP автоматически будет урезать данные, так чтобы
 * было отправлено допустимое количество. Может быть использована
 * фукнция uip_mss(), чтобы запросить у uIP количество данных, которое
 * будет отправлено в действительности.
 *
 * \note Эта функция не дает гарантии, что посылаемые данные дойдут до
 * получателя. Если данные будут потеряны в сети, приложение будет вызвано
 * с установленным событием uip_rexmit(). Затем приложение заново отправит
 * данные, используя эту фукнцию.
 *
 * \param data Указатель на данные для отправки.
 *
 * \param len Максимальное количество данных для отправки.
 *
 * \hideinitializer
 */
void uip_send(const void *data, int len);

/**
 * Длина любых пришедшик данны, которые в настоящий момент доступны
 * (если доступны) в буфере uip_appdata.
 *
 * Перед этим может быть использована функция uip_data(), чтобы проверить,
 * есть ли вообще доступные данные.
 *
 * \hideinitializer
 */
/*void uip_datalen(void);*/
#define uip_datalen()       uip_len

/**
 * Длина любых данные вне диапазона (out-of-band data, или urgent data,
 * т. е. данные, требующие срочной доставки), которые поступили 
 * на соединении.
 *
 * \note Чтобы эта функция была разрешена, должен быть установлен
 * конфигурационный параметр UIP_URGDATA.
 *
 * \hideinitializer
 */
#define uip_urgdatalen()    uip_urglen

/**
 * Закрывает текущее соединение.
 *
 * Эта функция должным образом закроет текущее соединение.
 *
 * \hideinitializer
 */
#define uip_close()         (uip_flags = UIP_CLOSE)

/**
 * Обрыв (Abort) текущего соединения.
 *
 * Эта функция оборвет (сбросит) текущее соедиение, что обычно используется,
 * когда случилась ошибка, что не дает право использовать функцию uip_close().
 *
 * \hideinitializer
 */
#define uip_abort()         (uip_flags = UIP_ABORT)

/**
 * Говорит посылающему данные хосту, что нужно остановить отправку данных.
 *
 * Эта функция закроет окно приема, чем приведет к остановке приема данных
 * для текущего соединения.
 *
 * \hideinitializer
 */
#define uip_stop()          (uip_conn->tcpstateflags |= UIP_STOPPED)

/**
 * Проверяет, было ли текущее соединение ранее остановлено вызовом uip_stop().
 *
 * \hideinitializer
 */
#define uip_stopped(conn)   ((conn)->tcpstateflags & UIP_STOPPED)

/**
 * Перезапускает текущее соединение, если оно было ранее остановлено
 * вызовом uip_stop().
 *
 * Эта функция снова откроет окно приема, что приведет к возобновлению
 * приема данных на текущем соединении.
 *
 * \hideinitializer
 */
#define uip_restart()         do { uip_flags |= UIP_NEWDATA; \
                                   uip_conn->tcpstateflags &= ~UIP_STOPPED; \
                              } while(0)


/* Проверки uIP, которые она может делать для того, чтобы определить,
   в каком состоянии находится соединение, и что должна делать функция
   приложения. */

/**
 * Текущее соединение является соединением UDP?
 *
 * Эта функция проверяет, является ли текущее соединение соединением UDP.
 *
 * \hideinitializer
 *
 */
#define uip_udpconnection() (uip_conn == NULL)

/**
 * Есть ли новые данные?
 *
 * Вернет не 0, если для приложения имеются новые данные, которые 
 * представлены по указателю. Размер доступных данных можно узнать
 * по значению переменной uip_len.
 *
 * \hideinitializer
 */
#define uip_newdata()   (uip_flags & UIP_NEWDATA)

/**
 * Были ли подтверждены ранее отправленные данные?
 *
 * Вернет не 0, если ранее посланные данные были подтверждены стороной
 * remote host. Это означает, что приложение может послать новые данные.
 *
 * \hideinitializer
 */
#define uip_acked()   (uip_flags & UIP_ACKDATA)

/**
 * Соединение все еще установлено?
 *
 * Вернет не 0, если текущее соедиение еще работает, и подключено к
 * remote host. Это случится в обоих случаях, если соединение активно
 * открыто (вызовом uip_connect()) или пассивно открыто (вызовом
 * uip_listen()).
 *
 * \hideinitializer
 */
#define uip_connected() (uip_flags & UIP_CONNECTED)

/**
 * Было ли соединение закрыто на дальнем конце?
 *
 * Не 0, если соединение было закрыто по инициативе remote host.
 * Если это так, то приложение может сделать необходимые очистки.
 *
 * \hideinitializer
 */
#define uip_closed()    (uip_flags & UIP_CLOSE)

/**
 * Было ли соединение оборвано (aborted) на другом конце?
 *
 * Не 0, если текущее было оборвано (сброшено) по инициативе
 * remote host.
 *
 * \hideinitializer
 */
#define uip_aborted()    (uip_flags & UIP_ABORT)

/**
 * Истек ли таймаут на соединении?
 *
 * Не 0, если текущее соединение было оборвано из за слишком большого
 * количества ретрансмиссий.
 *
 * \hideinitializer
 */
#define uip_timedout()    (uip_flags & UIP_TIMEDOUT)

/**
 * Нужно ли отправить заново ранее посланные данные?
 *
 * Вернет не 0, если ранее отправленные данные были потеряны в сети,
 * в этом случае приложение должно заново их отправить (retransmit).
 * Приложение должно отправить точно те же данные, которые оно отправило
 * последний раз, используя функцию uip_send().
 *
 * \hideinitializer
 */
#define uip_rexmit()     (uip_flags & UIP_REXMIT)

/**
 * Соединение опрашивается от uIP?
 *
 * Не 0, если причина вызова приложения в том, что соединение было неактивно
 * некоторое время, и должно быть опрошено.
 *
 * Событие опроса (polling event) может быть использовано для отправки
 * данных без ожидания, что remote host отправит данные.
 *
 * \hideinitializer
 */
#define uip_poll()       (uip_flags & UIP_POLL)

/**
 * Получает максимальный начальный размер сегмента (MSS) текущего
 * соединения.
 *
 * \hideinitializer
 */
#define uip_initialmss()             (uip_conn->initialmss)

/**
 * Получает текущий максимальный размер сегмента, который может быть
 * отправлен через текущее соединение.
 *
 * Такущий максимальный размер сегмента, который можно отправить
 * на соединении, вычисляется на основе окна прием и MSS соединения
 * (которое также доступно через вызов uip_initialmss()).
 *
 * \hideinitializer
 */
#define uip_mss()             (uip_conn->mss)

/**
 * Устанавливает новое соединение UDP.
 *
 * Эта функция устанавливает новое соединение UDP. Функция автоматически
 * выделит неиспользуемый локальный порт для нового соединения. Однако может
 * быть выбран другой порт с помощью вызова uip_udp_bind() после того,
 * как была вызвана функция uip_udp_new().
 *
 * Пример:
 \code
 uip_ipaddr_t addr;
 struct uip_udp_conn *c;
 
 uip_ipaddr(&addr, 192,168,2,1);
 c = uip_udp_new(&addr, HTONS(12345));
 if(c != NULL) {
   uip_udp_bind(c, HTONS(12344));
 }
 \endcode
 * \param ripaddr IP-адрес для remote host.
 *
 * \param rport Номер порта remote host с сетевым порядком байт.
 *
 * \return Структура uip_udp_conn для нового соединения или NULL,
 * если не может быть выделено соединение.
 */
struct uip_udp_conn *uip_udp_new(uip_ipaddr_t *ripaddr, u16_t rport);

/**
 * Удаляет соединение UDP.
 *
 * \param conn Указатель на структуру uip_udp_conn для соединения.
 *
 * \hideinitializer
 */
#define uip_udp_remove(conn) (conn)->lport = 0

/**
 * Привязка соединения UDP к локальному порту.
 *
 * \param conn Указатель на структуру uip_udp_conn для соединения.
 *
 * \param port Номер локального порта с сетевым порядком байт.
 *
 * \hideinitializer
 */
#define uip_udp_bind(conn, port) (conn)->lport = port

/**
 * Отправляет датаграмму UDP длиной len через текущее соединение.
 *
 * Эта функция может быть вызвана только в ответ на событие UDP (опроса
 * или поступления новых данных). Данные должны быть представлены в буфере
 * uip_buf, в том месте, на которое указывает указатель uip_appdata.
 *
 * \param len Длина данных в буфере uip_buf.
 *
 * \hideinitializer
 */
#define uip_udp_send(len) uip_send((char *)uip_appdata, len)

/** @} */

/* Вспомогательные и конвертирующие функции uIP. */

/**
 * \defgroup uipconvfunc Функции преобразований uIP
 * @{
 *
 * Эти функции могут использоваться для преобразования между разными
 * форматами данных, используемых в uIP.
 */
 
/**
 * Конструирует адрес IP из 4 байт.
 *
 * Эта функция составляет IP-адрес того типа, который обрабатывает 
 * внутри себя uIP. Эта функция удобна, чтобы указать IP-адреса
 * для использования, например, с функцией uip_connect().
 *
 * Пример:
 \code
 uip_ipaddr_t ipaddr;
 struct uip_conn *c;
 
 uip_ipaddr(&ipaddr, 192,168,1,2);
 c = uip_connect(&ipaddr, HTONS(80));
 \endcode
 *
 * \param addr Указатель на переменную uip_ipaddr_t, которая будет
 * заполнена адресом IP.
 *
 * \param addr0 Первый октет адреса IP.
 * \param addr1 Второй октет адреса IP.
 * \param addr2 Третий октет адреса IP.
 * \param addr3 Четвертый октет адреса IP.
 *
 * \hideinitializer
 */
#define uip_ipaddr(addr, addr0,addr1,addr2,addr3) do { \
                     ((u16_t *)(addr))[0] = HTONS(((addr0) << 8) | (addr1)); \
                     ((u16_t *)(addr))[1] = HTONS(((addr2) << 8) | (addr3)); \
                  } while(0)

/**
 * Составляет адрес IPv6 из восьми 16-битных слов.
 *
 * Эта функция конструирует адрес IPv6.
 *
 * \hideinitializer
 */
#define uip_ip6addr(addr, addr0,addr1,addr2,addr3,addr4,addr5,addr6,addr7) do { \
                     ((u16_t *)(addr))[0] = HTONS((addr0)); \
                     ((u16_t *)(addr))[1] = HTONS((addr1)); \
                     ((u16_t *)(addr))[2] = HTONS((addr2)); \
                     ((u16_t *)(addr))[3] = HTONS((addr3)); \
                     ((u16_t *)(addr))[4] = HTONS((addr4)); \
                     ((u16_t *)(addr))[5] = HTONS((addr5)); \
                     ((u16_t *)(addr))[6] = HTONS((addr6)); \
                     ((u16_t *)(addr))[7] = HTONS((addr7)); \
                  } while(0)

/**
 * Копирует IP-адрес в другой IP-адрес.
 *
 * Копирует IP-адрес с одного места в другое.
 *
 * Пример:
 \code
 uip_ipaddr_t ipaddr1, ipaddr2;

 uip_ipaddr(&ipaddr1, 192,16,1,2);
 uip_ipaddr_copy(&ipaddr2, &ipaddr1);
 \endcode
 *
 * \param dest Место назначения копии.
 * \param src Исходные данные, откуда IP будет копироваться.
 *
 * \hideinitializer
 */
#if !UIP_CONF_IPV6
#define uip_ipaddr_copy(dest, src) do { \
                     ((u16_t *)dest)[0] = ((u16_t *)src)[0]; \
                     ((u16_t *)dest)[1] = ((u16_t *)src)[1]; \
                  } while(0)
#else /* !UIP_CONF_IPV6 */
#define uip_ipaddr_copy(dest, src) memcpy(dest, src, sizeof(uip_ip6addr_t))
#endif /* !UIP_CONF_IPV6 */

/**
 * Сравнение двух IP-адресов
 *
 * Сравнивает два IP-адреса.
 *
 * Пример:
 \code
 uip_ipaddr_t ipaddr1, ipaddr2;

 uip_ipaddr(&ipaddr1, 192,16,1,2);
 if(uip_ipaddr_cmp(&ipaddr2, &ipaddr1)) {
    printf("They are the same");
 }
 \endcode
 *
 * \param addr1 Первый IP-адрес.
 * \param addr2 Второй IP-адрес.
 *
 * \hideinitializer
 */
#if !UIP_CONF_IPV6
#define uip_ipaddr_cmp(addr1, addr2) (((u16_t *)addr1)[0] == ((u16_t *)addr2)[0] && \
                                      ((u16_t *)addr1)[1] == ((u16_t *)addr2)[1])
#else /* !UIP_CONF_IPV6 */
#define uip_ipaddr_cmp(addr1, addr2) (memcmp(addr1, addr2, sizeof(uip_ip6addr_t)) == 0)
#endif /* !UIP_CONF_IPV6 */

/**
 * Сравнение двух адресов IP с сетевой маской
 *
 * Сравнивает два адреса IP с сетевой маской. Маски используются, чтобы маскировать
 * биты, которые должны сравниваться.
 *
 * Пример:
 \code
 uip_ipaddr_t ipaddr1, ipaddr2, mask;

 uip_ipaddr(&mask, 255,255,255,0);
 uip_ipaddr(&ipaddr1, 192,16,1,2);
 uip_ipaddr(&ipaddr2, 192,16,1,3);
 if(uip_ipaddr_maskcmp(&ipaddr1, &ipaddr2, &mask)) {
    printf("They are the same");
 }
 \endcode
 *
 * \param addr1 Первый IP-адрес.
 * \param addr2 Второй IP-адрес.
 * \param mask Сетевая маска.
 *
 * \hideinitializer
 */
#define uip_ipaddr_maskcmp(addr1, addr2, mask) \
                          (((((u16_t *)addr1)[0] & ((u16_t *)mask)[0]) == \
                            (((u16_t *)addr2)[0] & ((u16_t *)mask)[0])) && \
                           ((((u16_t *)addr1)[1] & ((u16_t *)mask)[1]) == \
                            (((u16_t *)addr2)[1] & ((u16_t *)mask)[1])))


/**
 * Маскирует сетевую часть адреса IP.
 *
 * Выделяет маской сетевую часть от IP-адреса, которая получается от адреса
 * и сетевой маски.
 *
 * Пример:
 \code
 uip_ipaddr_t ipaddr1, ipaddr2, netmask;

 uip_ipaddr(&ipaddr1, 192,16,1,2);
 uip_ipaddr(&netmask, 255,255,255,0);
 uip_ipaddr_mask(&ipaddr2, &ipaddr1, &netmask);
 \endcode
 *
 * В предыдущем примере переменная "ipaddr2" будет содержать IP-адрес
 * 192.168.1.0.
 *
 * \param dest Место, куда будет помещен результат.
 * \param src Адрес IP.
 * \param mask Сетевая маска.
 *
 * \hideinitializer
 */
#define uip_ipaddr_mask(dest, src, mask) do { \
                     ((u16_t *)dest)[0] = ((u16_t *)src)[0] & ((u16_t *)mask)[0]; \
                     ((u16_t *)dest)[1] = ((u16_t *)src)[1] & ((u16_t *)mask)[1]; \
                  } while(0)

/**
 * Получение первого октета от адреса IP.
 *
 * Выбирает первый октет из IP-адреса.
 *
 * Пример:
 \code
 uip_ipaddr_t ipaddr;
 u8_t octet;

 uip_ipaddr(&ipaddr, 1,2,3,4);
 octet = uip_ipaddr1(&ipaddr);
 \endcode
 *
 * В предыдущем примере переменная "octet" будет содержать значение 1.
 *
 * \hideinitializer
 */
#define uip_ipaddr1(addr) (htons(((u16_t *)(addr))[0]) >> 8)

/**
 * Получение второго октета от адреса IP.
 *
 * Выбирает второй октет из IP-адреса.
 *
 * Пример:
 \code
 uip_ipaddr_t ipaddr;
 u8_t octet;

 uip_ipaddr(&ipaddr, 1,2,3,4);
 octet = uip_ipaddr2(&ipaddr);
 \endcode
 *
 * В предыдущем примере переменная "octet" будет содержать значение 2.
 *
 * \hideinitializer
 */
#define uip_ipaddr2(addr) (htons(((u16_t *)(addr))[0]) & 0xff)

/**
 * Получение третьего октета от адреса IP.
 *
 * Выбирает третий октет из IP-адреса.
 *
 * Пример:
 \code
 uip_ipaddr_t ipaddr;
 u8_t octet;

 uip_ipaddr(&ipaddr, 1,2,3,4);
 octet = uip_ipaddr3(&ipaddr);
 \endcode
 *
 * В предыдущем примере переменная "octet" будет содержать значение 3.
 *
 * \hideinitializer
 */
#define uip_ipaddr3(addr) (htons(((u16_t *)(addr))[1]) >> 8)

/**
 * Получение четвертого октета от адреса IP.
 *
 * Выбирает четвертый октет из IP-адреса.
 *
 * Пример:
 \code
 uip_ipaddr_t ipaddr;
 u8_t octet;

 uip_ipaddr(&ipaddr, 1,2,3,4);
 octet = uip_ipaddr4(&ipaddr);
 \endcode
 *
 * В предыдущем примере переменная "octet" будет содержать значение 4.
 *
 * \hideinitializer
 */
#define uip_ipaddr4(addr) (htons(((u16_t *)(addr))[1]) & 0xff)

/**
 * Преобразует 16-битное число с порядком байт хоста в число с 
 * сетевым порядком байт.
 *
 * Этот макрос главным образом используется для преобразования констант
 * номера порта. Для преобразования переменных в сетевой порядок байт
 * используйте вместо этого функцию htons().
 *
 * \hideinitializer
 */
#ifndef HTONS
#   if UIP_BYTE_ORDER == UIP_BIG_ENDIAN
#      define HTONS(n) (n)
#   else /* UIP_BYTE_ORDER == UIP_BIG_ENDIAN */
#      define HTONS(n) (u16_t)((((u16_t) (n)) << 8) | (((u16_t) (n)) >> 8))
#   endif /* UIP_BYTE_ORDER == UIP_BIG_ENDIAN */
#else
#error "HTONS already defined!"
#endif /* HTONS */

/**
 * Преобразует 16-битное число с порядком байт хоста в число с 
 * сетевым порядком байт.
 *
 * Этот функция главным образом используется для преобразования переменных
 * номера порта. Для преобразования констант в сетевой порядок байт
 * используйте вместо этого макрос HTONS().
 */
#ifndef htons
u16_t htons(u16_t val);
#endif /* htons */
#ifndef ntohs
#define ntohs htons
#endif

/** @} */

/**
 * Указатель на данные приложения, находящиеся в буфере пакета.
 *
 * Этот указатель указывает на данные приложения, когда вызывается функция
 * приложения. Если приложению нужно отправить данные, то оно может
 * использовать это пространство для записи туда данных перед вызовом
 * uip_send().
 */
extern void *uip_appdata;

#if UIP_URGDATA > 0
/* u8_t *uip_urgdata:
 *
 * Этот указатель указывает на любые urgent data, которые были приняты.
 * Он представлен, если была разрешена компиляция поддержки urgent data
 * (UIP_URGDATA).
 */
extern void *uip_urgdata;
#endif /* UIP_URGDATA > 0 */


/**
 * \defgroup uipdrivervars Переменные, используемые драйверами устройства uIP
 * @{
 *
 * uIP имеет несколько глобальных переменных, которе используются в драйверах
 * устройства для uIP.
 */

/**
 * Длина пакета в буфере uip_buf.
 *
 * Глобальная переменная uip_len содержит длину пакета в буфере
 * uip_buf.
 *
 * Когда сетевой драйвер устройства вызывает функцию ввода uIP, переменная 
 * uip_len должна быть установлена на значение длины пакета в буфере
 * uip_buf.
 *
 * Когда отправляются пакеты, драйвер устройства должен использовать содержимое
 * переменной uip_len, чтобы определить длину уходящего пакета.
 *
 */
extern u16_t uip_len;

/** @} */

#if UIP_URGDATA > 0
extern u16_t uip_urglen, uip_surglen;
#endif /* UIP_URGDATA > 0 */


/**
 * Представление соединения TCP в стеке uIP.
 *
 * Структура uip_conn используется для идентификации соединения. Все поля
 * структуры, кроме одного, считаются для приложения полями только для 
 * чтения. Исключение составляет поле appstate, назначение которого - 
 * разрешить приложению сохранить свое состояние (например, файловые
 * указатели) для соединения. Тип этого поля конфигурируется в файле
 * заголовка "uipopt.h".
 */
struct uip_conn {
  uip_ipaddr_t ripaddr;    /**< Адрес IP для remote host. */
  
  u16_t lport;             /**< Локальный порт TCP, с сетевым порядком байт. */
  u16_t rport;             /**< Локальная копия порта TCP дальней стороны
                                соединения, с сетевым порядком байт. */
  
  u8_t rcv_nxt[4];         /**< Номер последоательности, который ожидается
                                следующим для приема. */
  u8_t snd_nxt[4];         /**< Номер последовательности, который был нами
                                отправлен последним. */
  u16_t len;               /**< Длина ранее отправленных данных. */
  u16_t mss;               /**< Текущий максимальный размер сегмента для
                                соединения. */
  u16_t initialmss;        /**< Начальный максимальный размер сегмента для
                                соединения. */
  u8_t sa;                 /**< Переменная состояния вычисления таймаута
                                ретрансмиссии. */
  u8_t sv;                 /**< Переменная состояния вычисления таймаута
                                ретрансмиссии. */
  u8_t rto;                /**< Таймаут ретрансмиссии. */
  u8_t tcpstateflags;      /**< Состояние и флаги TCP. */
  u8_t timer;              /**< Таймер ретрансмиссии. */
  u8_t nrtx;               /**< Количество ретрансмиссий, отправленных для
                                последнего посланного сегмента. */

  /** Переменная состояния приложения. */
  uip_tcp_appstate_t appstate;
};


/**
 * Указатель на текущее соединение TCP.
 *
 * Указатель uip_conn может использоваться для доступа к текущему 
 * соединению TCP.
 */
extern struct uip_conn *uip_conn;
/* Массив, содержащий все соединения uIP. */
extern struct uip_conn uip_conns[UIP_CONNS];
/**
 * \addtogroup uiparch
 * @{
 */

/**
 * 4-байтовый массив для вычисления 32-битного номера последовательности.
 */
extern u8_t uip_acc32[4];

/** @} */


#if UIP_UDP
/**
 * Представление соединения UDP в стеке uIP.
 */
struct uip_udp_conn {
  uip_ipaddr_t ripaddr;    /**< Адрес IP дальнего участника соединения. */
  u16_t lport;             /**< Локальный номер порта с сетевым порядком байт. */
  u16_t rport;             /**< Номер порта дальнего участника соединения,
                                с сетевым порядком байт. */
  u8_t  ttl;               /**< Время жизни по умолчанию (time-to-live). */

  /** Переменная состояния приложения. */
  uip_udp_appstate_t appstate;
};

/**
 * Текущее соединение UDP.
 */
extern struct uip_udp_conn *uip_udp_conn;
extern struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
#endif /* UIP_UDP */

/**
 * Структура содержит статистику TCP/IP, которая собирается, если значение
 * UIP_STATISTICS установлено в 1.
 *
 */
struct uip_stats {
  struct {
    uip_stats_t drop;      /**< Количество отброшенных пакетов на слое IP. */
    uip_stats_t recv;      /**< Количество принятых пакетов на слое IP. */
    uip_stats_t sent;      /**< Количество отправленных пакетов на слое IP. */
    uip_stats_t vhlerr;    /**< Количество отброшенных пакетов по причине
                                ошибочной версии IP или длины заголовка. */
    uip_stats_t hblenerr;  /**< Количество отброшенных пакетов по причине
                                ошибочной длины IP, старший байт. */
    uip_stats_t lblenerr;  /**< Количество отброшенных пакетов по причине
                                ошибочной длины IP, младший байт. */
    uip_stats_t fragerr;   /**< Количество отброшенных пакетов по той причине,
                                что они были IP-фрагментами. */
    uip_stats_t chkerr;    /**< Количество отброшенных пакетов из-за ошибок
                                контрольной суммы IP. */
    uip_stats_t protoerr;  /**< Количество отброшенных пакетов по той причине,
                                что не были пакетами ICMP, UDP или TCP. */
  } ip;                    /**< Статистические данные IP. */
  struct {
    uip_stats_t drop;      /**< Количество отброшенных пакетов ICMP. */
    uip_stats_t recv;      /**< Количество принятых пакетов ICMP. */
    uip_stats_t sent;      /**< Количество отправленных пакетов ICMP. */
    uip_stats_t typeerr;   /**< Количество пакетов ICMP неправильного типа. */
  } icmp;                  /**< Статистические данные ICMP. */
  struct {
    uip_stats_t drop;      /**< Количество отброшенных сегментов TCP. */
    uip_stats_t recv;      /**< Количество принятых сегментов TCP. */
    uip_stats_t sent;      /**< Количество отправленных сегментов TCP. */
    uip_stats_t chkerr;    /**< Количество сегментов TCP с ошибкой
                                в контрольной сумме. */
    uip_stats_t ackerr;    /**< Количество сегментов TCP с ошибочным
                                номером ACK. */
    uip_stats_t rst;       /**< Количество принятых сегментов TCP RST (сброс). */
    uip_stats_t rexmit;    /**< Количество повторно отправленных сегментов TCP. */
    uip_stats_t syndrop;   /**< Количество отброшенных SYN-ов из-за слишком малого
                                количества доступных соединений. */
    uip_stats_t synrst;    /**< Количество SYN-ов для закрытых портов,
                                инициировавших RST. */
  } tcp;                   /**< Статистические данные TCP. */
#if UIP_UDP
  struct {
    uip_stats_t drop;      /**< Количество отброшенных сегментов UDP. */
    uip_stats_t recv;      /**< Количество принятых сегментов UDP. */
    uip_stats_t sent;      /**< Количество отправленных сегментов UDP. */
    uip_stats_t chkerr;    /**< Количество сегментов UDP с ошибкой
                                в контрольной сумме. */
  } udp;                   /**< Статистические данные UDP. */
#endif /* UIP_UDP */
};

/**
 * Статистическая инфрмация uIP TCP/IP.
 *
 * Это переменная, в которой собирается статистика uIP TCP/IP.
 */
extern struct uip_stats uip_stat;


/*---------------------------------------------------------------------------*/
/* Все, что находится ниже этой точки, задействовано внутри uIP и не должно
 * использоваться напрямую в приложении или в драйвере устройства.
 */
/*---------------------------------------------------------------------------*/
/* u8_t uip_flags:
 *
 * Когда вызывается функция приложения, uip_flags будет содержать флаги,
 * которые заданы в этом файле.
 */
extern u8_t uip_flags;

/* Следующие флаги могут быть установлены в глобальной переменной uip_flags
   перед вызовом функции обратного вызова приложения (application callback).
   Флаги UIP_ACKDATA, UIP_NEWDATA и UIP_CLOSE могут быть установлены в одно
   и то же время, в то время как другие являются взаимоисключающими.
   Обратите внимание на то, что эти флаги *НЕ ДОЛЖНЫ* быть исползованы
   напрямую, в обход специальных макросов и функций uIP. */

#define UIP_ACKDATA   1    /* Показывает, что переданные данные были
                              подтверждены, и приложение может отправить
                              новые данные вместо ретрансмиссии ранее 
                              отправленных. */
#define UIP_NEWDATA   2    /* Показывает, что дальний участник обмена
                              отправил нам новые данные. */
#define UIP_REXMIT    4    /* Говорит приложению отправить заново данные,
                              которые были отправлены последний раз. */
#define UIP_POLL      8    /* Используется для опроса приложения, чтобы
                              проверить, есть ли у приложения данные,
                              которые оно хотело бы отправить. */
#define UIP_CLOSE     16   /* Участник обмена (remote host) закрыл соединение,
                              так что соединение завершилось. Или приложение
                              сигнализирует, что оно хотело бы завершить
                              соединение. */
#define UIP_ABORT     32   /* Участник обмена (remote host) оборвал соединение,
                              так что соединение завершилось. Или приложение
                              сигнализирует, что оно хотело бы оборвать
                              соединение. */
#define UIP_CONNECTED 64   /* У нас есть соединение от remote host, и для него
                              установлено новое соединение, или активное соединение
                              было успешно установлено. */

#define UIP_TIMEDOUT  128  /* Соединение было оборвано (aborted) из-за слишком
                              большого количества повторных передач. */

/* uip_process(flag):
 *
 * Действительная функция uIP, которая делает всю работу.
 */
void uip_process(u8_t flag);

/* Следующие флаги передаются в качестве аргумента для функции uip_process().
   Они используются для того, чтобы отличить друг от друга два случая вызова
   uip_process(). Вызов может быть либо по причине наличия принятых данных,
   которые должны быть обработаны, либо потому, что сработал периодический 
   таймер. Эти значения никогда не должны использоваться напрямую, только
   в макросах, которые определены в этом файле. */
 
#define UIP_DATA          1   /* Говорит для uIP, что в буфере uip_buf
                                 есть поступившие данные. Длина данных
                                 сохранена в глобальной переменной uip_len. */
#define UIP_TIMER         2   /* Говорит для uIP, что сработал периодический
                                 таймер. */
#define UIP_POLL_REQUEST  3   /* Говорит для uIP, что должно быть опрошено
                                 соединение. */
#define UIP_UDP_SEND_CONN 4   /* Говорит для uIP, что в буфере uip_buf 
                                 должна быть создана датаграмма UDP. */
#if UIP_UDP
#define UIP_UDP_TIMER     5
#endif /* UIP_UDP */

/* Состояния TCP, используемые в uip_conn->tcpstateflags. */
#define UIP_CLOSED      0
#define UIP_SYN_RCVD    1
#define UIP_SYN_SENT    2
#define UIP_ESTABLISHED 3
#define UIP_FIN_WAIT_1  4
#define UIP_FIN_WAIT_2  5
#define UIP_CLOSING     6
#define UIP_TIME_WAIT   7
#define UIP_LAST_ACK    8
#define UIP_TS_MASK     15
  
#define UIP_STOPPED      16

/* Заголовки TCP и IP. */
struct uip_tcpip_hdr {
#if UIP_CONF_IPV6
  /* Заголовок IPv6. */
  u8_t vtc,
    tcflow;
  u16_t flow;
  u8_t len[2];
  u8_t proto, ttl;
  uip_ip6addr_t srcipaddr, destipaddr;
#else /* UIP_CONF_IPV6 */
  /* Заголовок IPv4. */
  u8_t vhl,
    tos,
    len[2],
    ipid[2],
    ipoffset[2],
    ttl,
    proto;
  u16_t ipchksum;
  u16_t srcipaddr[2],
    destipaddr[2];
#endif /* UIP_CONF_IPV6 */
  
  /* Заголовок TCP. */
  u16_t srcport,
    destport;
  u8_t seqno[4],
    ackno[4],
    tcpoffset,
    flags,
    wnd[2];
  u16_t tcpchksum;
  u8_t urgp[2];
  u8_t optdata[4];
};

/* Заголовки ICMP и IP. */
struct uip_icmpip_hdr {
#if UIP_CONF_IPV6
  /* Заголовок IPv6. */
  u8_t vtc,
    tcf;
  u16_t flow;
  u8_t len[2];
  u8_t proto, ttl;
  uip_ip6addr_t srcipaddr, destipaddr;
#else /* UIP_CONF_IPV6 */
  /* Заголовок IPv4. */
  u8_t vhl,
    tos,
    len[2],
    ipid[2],
    ipoffset[2],
    ttl,
    proto;
  u16_t ipchksum;
  u16_t srcipaddr[2],
    destipaddr[2];
#endif /* UIP_CONF_IPV6 */
  
  /* Заголовок ICMP (echo). */
  u8_t type, icode;
  u16_t icmpchksum;
#if !UIP_CONF_IPV6
  u16_t id, seqno;
#else /* !UIP_CONF_IPV6 */
  u8_t flags, reserved1, reserved2, reserved3;
  u8_t icmp6data[16];
  u8_t options[1];
#endif /* !UIP_CONF_IPV6 */
};


/* Заголовки UDP и IP. */
struct uip_udpip_hdr {
#if UIP_CONF_IPV6
  /* Заголовок IPv6. */
  u8_t vtc,
    tcf;
  u16_t flow;
  u8_t len[2];
  u8_t proto, ttl;
  uip_ip6addr_t srcipaddr, destipaddr;
#else /* UIP_CONF_IPV6 */
  /* Заголовок IP. */
  u8_t vhl,
    tos,
    len[2],
    ipid[2],
    ipoffset[2],
    ttl,
    proto;
  u16_t ipchksum;
  u16_t srcipaddr[2],
    destipaddr[2];
#endif /* UIP_CONF_IPV6 */
  
  /* Заголовок UDP. */
  u16_t srcport,
    destport;
  u16_t udplen;
  u16_t udpchksum;
};



/**
 * Размер пространства, доступного для данных пользователей в буфере \ref uip_buf.
 *
 * Этот макрос содержит доступное место для данных пользователя в буфере \ref
 * uip_buf. Макрос предназначен для проверки границ доступных для пользователя данных.
 *
 * Пример:
 \code
 snprintf(uip_appdata, UIP_APPDATA_SIZE, "%u\n", i);
 \endcode
 *
 * \hideinitializer
 */
#define UIP_APPDATA_SIZE (UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN)


#define UIP_PROTO_ICMP  1
#define UIP_PROTO_TCP   6
#define UIP_PROTO_UDP   17
#define UIP_PROTO_ICMP6 58

/* Размеры для заголовков. */
#if UIP_CONF_IPV6
#define UIP_IPH_LEN    40
#else /* UIP_CONF_IPV6 */
#define UIP_IPH_LEN    20    /* Размер заголовка IP */
#endif /* UIP_CONF_IPV6 */
#define UIP_UDPH_LEN    8    /* Размер заголовка UDP */
#define UIP_TCPH_LEN   20    /* Размер заголовка TCP */
#define UIP_IPUDPH_LEN (UIP_UDPH_LEN + UIP_IPH_LEN)    /* Размер для
                                                          заголовка IP + UDP */
#define UIP_IPTCPH_LEN (UIP_TCPH_LEN + UIP_IPH_LEN)    /* Размер для
                                                          заголовка IP + TCP */
#define UIP_TCPIP_HLEN UIP_IPTCPH_LEN


#if UIP_FIXEDADDR
extern const uip_ipaddr_t uip_hostaddr, uip_netmask, uip_draddr;
#else /* UIP_FIXEDADDR */
extern uip_ipaddr_t uip_hostaddr, uip_netmask, uip_draddr;
#endif /* UIP_FIXEDADDR */



/**
 * Представление 48-битного адреса Ethernet.
 */
struct uip_eth_addr {
  u8_t addr[6];
};

/**
 * Вычисление контрольной суммы Internet для данных буфера.
 *
 * Контрольная сумма Internet - это поразрядное дополнение до 1 
 * суммы поразрядного дополнения всех 16-битных слов в буфере.
 *
 * См. RFC1071.
 *
 * \param buf Указатель на буфер, от которого вычисляется контрольная
 * сумма.
 *
 * \param len Длина буфера, от которого вычисляется контрольная
 * сумма.
 *
 * \return The Контрольная сумма Internet для буфера.
 */
u16_t uip_chksum(u16_t *buf, u16_t len);

/**
 * Вычисление контрольной суммы заголовка IP для заголовка пакета 
 * в буфере uip_buf.
 *
 * Контрольная сумма заголовка IP является контрольной суммой Internet
 * от 20 байт заголовка IP.
 *
 * \return Контрольная сумма заголовка IP для заголовка IP в 
 * в буфере uip_buf.
 */
u16_t uip_ipchksum(void);

/**
 * Вычисление контрольной суммы TCP для пакета в uip_buf и uip_appdata.
 *
 * Контрольная сумма TCP является контрольной суммой Internet от содержимого
 * данных сегмента TCP, и псевдозаголовка, определенного в RFC793.
 *
 * \return Контрольная сумма TCP сегмента TCP в uip_buf, на который
 * указывает uip_appdata.
 */
u16_t uip_tcpchksum(void);

/**
 * Вычисление контрольной суммы UDP для пакета в uip_buf и uip_appdata.
 *
 * Контрольная сумма UDP является контрольной суммой Internet от содержимого
 * данных сегмента UDP, и псевдозаголовка, определенного в RFC768.
 *
 * \return Контрольная сумма UDP сегмента UDP segment в uip_buf, на который
 * указывает uip_appdata.
 */
u16_t uip_udpchksum(void);


#endif /* __UIP_H__ */


/** @} */