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

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

#define DEBUG_PRINTF(...) /*printf(__VA_ARGS__)*/

/**
 * \defgroup uip The uIP TCP/IP stack
 * @{
 *
 * uIP является реализацией стека протоколов TCP/IP, предназначенной
 * для маленьких 8-битных и 16-битных микроконтроллеров.
 *
 * uIP предоставляет протоколы, необходимые для обмена данными через
 * сеть Internet, с очень малым размером кода и низкими требованиями
 * к объему RAM - размер кода uIP составляет порядка нескольких килобайт,
 * и количество задействованной памяти RAM составляет несколько сотен
 * байт.
 */

/**
 * \file
 * Код стека uIP TCP/IP.
 * \author Adam Dunkels <adam@dunkels.com>
 */

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

/*
 * uIP является малой реализацеий протоколов IP, UDP и TCP (а также
 * базовой части ICMP). Реализаци слоев IP, UDP, TCP и слоя приложения
 * очень тесно взаимосвязаны. Чтобы снизить размер компилируемого кода,
 * часто используется оператор goto. Хотя можно было бы разбить uip_process()
 * на несколько функций поменьше, это увеличит размер кода на передачу 
 * параметров и снижения эффективности работы оптимизации.
 *
 * Принцип работы состоит в том, что у нас есть маленький буфер uip_buf,
 * в который драйвер устройства помещает пришедший пакет. Стек TCP/IP
 * делает парсинг заголовков в пакете, и вызывает приложение. Если
 * remote host отправил данные приложению, то эти данные представлены
 * в буфере uip_buf, и приложение проитает данные оттуда. Также приложение
 * при необходимости может поместить туда для передаваемого потока байт. 
 * Приложению не будут поставляться данные, которые выпадают из
 * последовательности обмена.
 *
 * Если приложение хочет отправить данные другому участнику обмена 
 * (на сторону remote host), то оно должно поместить данные в буфер
 * uip_buf. Указатель uip_appdata указывает на первый доступный байт. 
 * Стек TCP/IP вычислит контрольные суммы, и заполнит необходимые поля
 * заголовка, и затем отправит обратно пакет участнику обмена.
*/

#include "uip.h"
#include "uipopt.h"
#include "uip_arch.h"

#if UIP_CONF_IPV6
#include "uip-neighbor.h"
#endif /* UIP_CONF_IPV6 */

#include <string.h>

/*---------------------------------------------------------------------------*/
/* Определения переменных. */


/* Адрес IP для этого хоста. Если он задан как фиксированный (путем
   установки UIP_FIXEDADDR на 1 в файле uipopt.h), то адрес будет
   установлен здесь в виде констант. Иначе адрес будет задан переменными. */
#if UIP_FIXEDADDR > 0
const uip_ipaddr_t uip_hostaddr =
  {HTONS((UIP_IPADDR0 << 8) | UIP_IPADDR1),
   HTONS((UIP_IPADDR2 << 8) | UIP_IPADDR3)};
const uip_ipaddr_t uip_draddr =
  {HTONS((UIP_DRIPADDR0 << 8) | UIP_DRIPADDR1),
   HTONS((UIP_DRIPADDR2 << 8) | UIP_DRIPADDR3)};
const uip_ipaddr_t uip_netmask =
  {HTONS((UIP_NETMASK0 << 8) | UIP_NETMASK1),
   HTONS((UIP_NETMASK2 << 8) | UIP_NETMASK3)};
#else
uip_ipaddr_t uip_hostaddr, uip_draddr, uip_netmask;
#endif /* UIP_FIXEDADDR */

static const uip_ipaddr_t all_ones_addr =
#if UIP_CONF_IPV6
  {0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff};
#else /* UIP_CONF_IPV6 */
  {0xffff,0xffff};
#endif /* UIP_CONF_IPV6 */
static const uip_ipaddr_t all_zeroes_addr =
#if UIP_CONF_IPV6
  {0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000};
#else /* UIP_CONF_IPV6 */
  {0x0000,0x0000};
#endif /* UIP_CONF_IPV6 */


#if UIP_FIXEDETHADDR
const struct uip_eth_addr uip_ethaddr = {{UIP_ETHADDR0,
                                          UIP_ETHADDR1,
                                          UIP_ETHADDR2,
                                          UIP_ETHADDR3,
                                          UIP_ETHADDR4,
                                          UIP_ETHADDR5}};
#else
struct uip_eth_addr uip_ethaddr = {{0,0,0,0,0,0}};
#endif

#ifndef UIP_CONF_EXTERNAL_BUFFER
u8_t uip_buf[UIP_BUFSIZE + 2];   /* Буфер пакета, который будет содержать
                                    поступающие пакеты. */
#endif /* UIP_CONF_EXTERNAL_BUFFER */

void *uip_appdata;               /* Указатель uip_appdata, указывающий на
                                    данные приложения. */
void *uip_sappdata;              /* Указатель uip_sappdata указывает на
                                    данные приложения, которые должны быть
                                    отправлены. */
#if UIP_URGDATA > 0
void *uip_urgdata;               /* Указатель uip_urgdata указывает на
                                    urgent data (out-of-band data), если
                                    таковые имеются. */
u16_t uip_urglen, uip_surglen;
#endif /* UIP_URGDATA > 0 */

u16_t uip_len, uip_slen;
                                 /* Переменная uip_len будет 8-или 16-битная,
                                    в зависимости от максимального размера
                                    пакета. */

u8_t uip_flags;                  /* Переменная uip_flags, используемая в обмене
                                    между стеком TCP/IP и программой приложения. */
struct uip_conn *uip_conn;      /* Переменная uip_conn всегда указывает на
                                    текущее соединение. */

struct uip_conn uip_conns[UIP_CONNS];
                                 /* Массив uip_conns содержит все соединения TCP. */
u16_t uip_listenports[UIP_LISTENPORTS];
                                 /* Массив uip_listenports содержит список всех
                                    прослушиваемых сейчас портов. */
#if UIP_UDP
struct uip_udp_conn *uip_udp_conn;
struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
#endif /* UIP_UDP */

static u16_t ipid;               /* Эта переменная содержит увеличиваемое число,
                                     используемое в поле IP ID. */

void uip_setipid(u16_t id) { ipid = id; }

static u8_t iss[4];              /* Эта переменная используется для начального номера
                                     последовательности TCP. */

#if UIP_ACTIVE_OPEN
static u16_t lastport;           /* Отслеживает последний порт, используемый для
                                     нового соединения. */
#endif /* UIP_ACTIVE_OPEN */

/* Временные переменные. */
u8_t uip_acc32[4];
static u8_t c, opt;
static u16_t tmp16;

/* Структуры и определения. */
#define TCP_FIN 0x01
#define TCP_SYN 0x02
#define TCP_RST 0x04
#define TCP_PSH 0x08
#define TCP_ACK 0x10
#define TCP_URG 0x20
#define TCP_CTL 0x3f

#define TCP_OPT_END     0   /* Конец списка опций TCP */
#define TCP_OPT_NOOP    1   /* Опция TCP "No-operation" (нет операции) */
#define TCP_OPT_MSS     2   /* Опция TCP максимального размера сегмента */

#define TCP_OPT_MSS_LEN 4   /* Длина опции TCP MSS. */

#define ICMP_ECHO_REPLY 0
#define ICMP_ECHO       8

#define ICMP6_ECHO_REPLY             129
#define ICMP6_ECHO                   128
#define ICMP6_NEIGHBOR_SOLICITATION  135
#define ICMP6_NEIGHBOR_ADVERTISEMENT 136

#define ICMP6_FLAG_S (1 << 6)

#define ICMP6_OPTION_SOURCE_LINK_ADDRESS 1
#define ICMP6_OPTION_TARGET_LINK_ADDRESS 2


/* Macros. */
#define BUF ((struct uip_tcpip_hdr *)&uip_buf[UIP_LLH_LEN])
#define FBUF ((struct uip_tcpip_hdr *)&uip_reassbuf[0])
#define ICMPBUF ((struct uip_icmpip_hdr *)&uip_buf[UIP_LLH_LEN])
#define UDPBUF ((struct uip_udpip_hdr *)&uip_buf[UIP_LLH_LEN])


#if UIP_STATISTICS == 1
struct uip_stats uip_stat;
#define UIP_STAT(s) s
#else
#define UIP_STAT(s)
#endif /* UIP_STATISTICS == 1 */

#if UIP_LOGGING == 1
#include <stdio.h>
void uip_log(char *msg);
#define UIP_LOG(m) uip_log(m)
#else
#define UIP_LOG(m)
#endif /* UIP_LOGGING == 1 */

#if ! UIP_ARCH_ADD32
void
uip_add32(u8_t *op32, u16_t op16)
{
  uip_acc32[3] = op32[3] + (op16 & 0xff);
  uip_acc32[2] = op32[2] + (op16 >> 8);
  uip_acc32[1] = op32[1];
  uip_acc32[0] = op32[0];
  
  if(uip_acc32[2] < (op16 >> 8)) {
    ++uip_acc32[1];
    if(uip_acc32[1] == 0) {
      ++uip_acc32[0];
    }
  }
  
  
  if(uip_acc32[3] < (op16 & 0xff)) {
    ++uip_acc32[2];
    if(uip_acc32[2] == 0) {
      ++uip_acc32[1];
      if(uip_acc32[1] == 0) {
        ++uip_acc32[0];
      }
    }
  }
}

#endif /* UIP_ARCH_ADD32 */

#if ! UIP_ARCH_CHKSUM
/*---------------------------------------------------------------------------*/
static u16_t
chksum(u16_t sum, const u8_t *data, u16_t len)
{
  u16_t t;
  const u8_t *dataptr;
  const u8_t *last_byte;

  dataptr = data;
  last_byte = data + len - 1;
  
  while(dataptr < last_byte) {   /* Еще по крайней мере два байта */
    t = (dataptr[0] << 8) + dataptr[1];
    sum += t;
    if(sum < t) {
      sum++;                     /* перенос */
    }
    dataptr += 2;
  }
  
  if(dataptr == last_byte) {
    t = (dataptr[0] << 8) + 0;
    sum += t;
    if(sum < t) {
      sum++;                     /* перенос */
    }
  }

  /* Возврат суммы, где порядок байт как у хоста. */
  return sum;
}
/*---------------------------------------------------------------------------*/
u16_t
uip_chksum(u16_t *data, u16_t len)
{
  return htons(chksum(0, (u8_t *)data, len));
}
/*---------------------------------------------------------------------------*/
#ifndef UIP_ARCH_IPCHKSUM
u16_t
uip_ipchksum(void)
{
  u16_t sum;

  sum = chksum(0, &uip_buf[UIP_LLH_LEN], UIP_IPH_LEN);
  DEBUG_PRINTF("uip_ipchksum: sum 0x%04x\n", sum);
  return (sum == 0) ? 0xffff : htons(sum);
}
#endif
/*---------------------------------------------------------------------------*/
static u16_t
upper_layer_chksum(u8_t proto)
{
  u16_t upper_layer_len;
  u16_t sum;
  
#if UIP_CONF_IPV6
  upper_layer_len = (((u16_t)(BUF->len[0]) << 8) + BUF->len[1]);
#else /* UIP_CONF_IPV6 */
  upper_layer_len = (((u16_t)(BUF->len[0]) << 8) + BUF->len[1]) - UIP_IPH_LEN;
#endif /* UIP_CONF_IPV6 */
  
  /* Первый псевдозаголовок суммы. */
  
  /* Поля протокола IP и длины. В этом месте добавление без переноса. */
  sum = upper_layer_len + proto;
  /* Сумма адресов IP source и IP destination. */
  sum = chksum(sum, (u8_t *)&BUF->srcipaddr[0], 2 * sizeof(uip_ipaddr_t));

  /* Sum TCP header and data. */
  sum = chksum(sum, &uip_buf[UIP_IPH_LEN + UIP_LLH_LEN],
               upper_layer_len);
    
  return (sum == 0) ? 0xffff : htons(sum);
}
/*---------------------------------------------------------------------------*/
#if UIP_CONF_IPV6
u16_t
uip_icmp6chksum(void)
{
  return upper_layer_chksum(UIP_PROTO_ICMP6);
  
}
#endif /* UIP_CONF_IPV6 */
/*---------------------------------------------------------------------------*/
u16_t
uip_tcpchksum(void)
{
  return upper_layer_chksum(UIP_PROTO_TCP);
}
/*---------------------------------------------------------------------------*/
#if UIP_UDP_CHECKSUMS
u16_t
uip_udpchksum(void)
{
  return upper_layer_chksum(UIP_PROTO_UDP);
}
#endif /* UIP_UDP_CHECKSUMS */
#endif /* UIP_ARCH_CHKSUM */
/*---------------------------------------------------------------------------*/
void
uip_init(void)
{
  for(c = 0; c < UIP_LISTENPORTS; ++c) {
    uip_listenports[c] = 0;
  }
  for(c = 0; c < UIP_CONNS; ++c) {
    uip_conns[c].tcpstateflags = UIP_CLOSED;
  }
#if UIP_ACTIVE_OPEN
  lastport = 1024;
#endif /* UIP_ACTIVE_OPEN */

#if UIP_UDP
  for(c = 0; c < UIP_UDP_CONNS; ++c) {
    uip_udp_conns[c].lport = 0;
  }
#endif /* UIP_UDP */
  

  /* Инициализация IPv4. */
#if UIP_FIXEDADDR == 0
  /*  uip_hostaddr[0] = uip_hostaddr[1] = 0;*/
#endif /* UIP_FIXEDADDR */

}
/*---------------------------------------------------------------------------*/
#if UIP_ACTIVE_OPEN
struct uip_conn *
uip_connect(uip_ipaddr_t *ripaddr, u16_t rport)
{
  register struct uip_conn *conn, *cconn;
  
  /* Поиск неиспользуемого локального порта. */
 again:
  ++lastport;

  if(lastport >= 32000) {
    lastport = 4096;
  }

  /* Проверка: этот порт уже используется? Если так, то попытка
     найти другой. */
  for(c = 0; c < UIP_CONNS; ++c) {
    conn = &uip_conns[c];
    if(conn->tcpstateflags != UIP_CLOSED &&
       conn->lport == htons(lastport)) {
      goto again;
    }
  }

  conn = 0;
  for(c = 0; c < UIP_CONNS; ++c) {
    cconn = &uip_conns[c];
    if(cconn->tcpstateflags == UIP_CLOSED) {
      conn = cconn;
      break;
    }
    if(cconn->tcpstateflags == UIP_TIME_WAIT) {
      if(conn == 0 ||
         cconn->timer > conn->timer) {
         conn = cconn;
      }
    }
  }

  if(conn == 0) {
    return 0;
  }
  
  conn->tcpstateflags = UIP_SYN_SENT;

  conn->snd_nxt[0] = iss[0];
  conn->snd_nxt[1] = iss[1];
  conn->snd_nxt[2] = iss[2];
  conn->snd_nxt[3] = iss[3];

  conn->initialmss = conn->mss = UIP_TCP_MSS;
  
  conn->len = 1;   /* Длина TCP для SYN равна 1. */
  conn->nrtx = 0;
  conn->timer = 1; /* SYN будет отправлен в следующий раз. */
  conn->rto = UIP_RTO;
  conn->sa = 0;
  conn->sv = 16;   /* Начальное значение для вариации RTT. */
  conn->lport = htons(lastport);
  conn->rport = rport;
  uip_ipaddr_copy(&conn->ripaddr, ripaddr);
  
  return conn;
}
#endif /* UIP_ACTIVE_OPEN */
/*---------------------------------------------------------------------------*/
#if UIP_UDP
struct uip_udp_conn *
uip_udp_new(uip_ipaddr_t *ripaddr, u16_t rport)
{
  register struct uip_udp_conn *conn;
  
  /* Поиск неиспользуемого локального порта. */
 again:
  ++lastport;

  if(lastport >= 32000) {
    lastport = 4096;
  }
  
  for(c = 0; c < UIP_UDP_CONNS; ++c) {
    if(uip_udp_conns[c].lport == htons(lastport)) {
      goto again;
    }
  }


  conn = 0;
  for(c = 0; c < UIP_UDP_CONNS; ++c) {
    if(uip_udp_conns[c].lport == 0) {
      conn = &uip_udp_conns[c];
      break;
    }
  }

  if(conn == 0) {
    return 0;
  }
  
  conn->lport = HTONS(lastport);
  conn->rport = rport;
  if(ripaddr == NULL) {
    memset(conn->ripaddr, 0, sizeof(uip_ipaddr_t));
  } else {
    uip_ipaddr_copy(&conn->ripaddr, ripaddr);
  }
  conn->ttl = UIP_TTL;
  
  return conn;
}
#endif /* UIP_UDP */
/*---------------------------------------------------------------------------*/
void
uip_unlisten(u16_t port)
{
  for(c = 0; c < UIP_LISTENPORTS; ++c) {
    if(uip_listenports[c] == port) {
      uip_listenports[c] = 0;
      return;
    }
  }
}
/*---------------------------------------------------------------------------*/
void
uip_listen(u16_t port)
{
  for(c = 0; c < UIP_LISTENPORTS; ++c) {
    if(uip_listenports[c] == 0) {
      uip_listenports[c] = port;
      return;
    }
  }
}
/*---------------------------------------------------------------------------*/
/* XXX: пересборка фрагментации IP: протестировано не очень хорошо. */

#if UIP_REASSEMBLY && !UIP_CONF_IPV6
#define UIP_REASS_BUFSIZE (UIP_BUFSIZE - UIP_LLH_LEN)
static u8_t uip_reassbuf[UIP_REASS_BUFSIZE];
static u8_t uip_reassbitmap[UIP_REASS_BUFSIZE / (8 * 8)];
static const u8_t bitmap_bits[8] = {0xff, 0x7f, 0x3f, 0x1f,
                                     0x0f, 0x07, 0x03, 0x01};
static u16_t uip_reasslen;
static u8_t uip_reassflags;
#define UIP_REASS_FLAG_LASTFRAG 0x01
static u8_t uip_reasstmr;

#define IP_MF   0x20

static u8_t
uip_reass(void)
{
  u16_t offset, len;
  u16_t i;

  /* Если ip_reasstmr равен 0, то в буфере нет пакета, поэтому
     запишем заголовок IP фрагмента в буфер пересборки.
     Таймер обновляестя на максимальное время. */
  if(uip_reasstmr == 0) {
    memcpy(uip_reassbuf, &BUF->vhl, UIP_IPH_LEN);
    uip_reasstmr = UIP_REASS_MAXAGE;
    uip_reassflags = 0;
    /* Очистка битовой карты. */
    memset(uip_reassbitmap, 0, sizeof(uip_reassbitmap));
  }

  /* Проверка - соответствует ли входящий фрагмент текущему фрагменту,
     находящемуся в буфере пересборки. Если это так, то фрагмент
     будет скопирован в буфер. */
  if(BUF->srcipaddr[0] == FBUF->srcipaddr[0] &&
     BUF->srcipaddr[1] == FBUF->srcipaddr[1] &&
     BUF->destipaddr[0] == FBUF->destipaddr[0] &&
     BUF->destipaddr[1] == FBUF->destipaddr[1] &&
     BUF->ipid[0] == FBUF->ipid[0] &&
     BUF->ipid[1] == FBUF->ipid[1]) {

    len = (BUF->len[0] << 8) + BUF->len[1] - (BUF->vhl & 0x0f) * 4;
    offset = (((BUF->ipoffset[0] & 0x3f) << 8) + BUF->ipoffset[1]) * 8;

    /* Если смещение или смешщение + длина фрагмента переполняют
       буфер пересборки, то отбросим весь пакет. */
    if(offset > UIP_REASS_BUFSIZE ||
       offset + len > UIP_REASS_BUFSIZE) {
      uip_reasstmr = 0;
      goto nullreturn;
    }

    /* Копирование фрагмента в буфер пересборки, со смещением
       вправо. */
    memcpy(&uip_reassbuf[UIP_IPH_LEN + offset],
           (char *)BUF + (int)((BUF->vhl & 0x0f) * 4),
           len);
      
    /* Обновление битовой карты. */
    if(offset / (8 * 8) == (offset + len) / (8 * 8)) {
      /* Если две конечные точки находятся в одном и том же байте,
         то будет обновлен только этот байт. */
      uip_reassbitmap[offset / (8 * 8)] |=
          bitmap_bits[(offset / 8 ) & 7] &
         ~bitmap_bits[((offset + len) / 8 ) & 7];
    } else {
      /* Если две конечные точки находятся в разных байтах, обновим байты
         в конечных точках и заполним данные между ними байтами 0xff. */
      uip_reassbitmap[offset / (8 * 8)] |=
            bitmap_bits[(offset / 8 ) & 7];
      for(i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i) {
         uip_reassbitmap[i] = 0xff;
      }
      uip_reassbitmap[(offset + len) / (8 * 8)] |=
            ~bitmap_bits[((offset + len) / 8 ) & 7];
    }
    
    /* Если в этом фрагменте флаг More Fragments равен 0, то мы знаем,
       это последний фрагмент, так что можно теперь вычислить размер
       всего пакета. Мы также установим флаг IP_REASS_FLAG_LASTFRAG,
       чтобы показать, что мы приняли завершающий фрагмент. */

    if((BUF->ipoffset[0] & IP_MF) == 0) {
      uip_reassflags |= UIP_REASS_FLAG_LASTFRAG;
      uip_reasslen = offset + len;
    }
    
    /* И в завершение проверим, находится ли буфере полный пакет. Мы делаем
       это путем проверки - был ли последний фрагмент, все ли биты
       в карте бит установлены. */
    if(uip_reassflags & UIP_REASS_FLAG_LASTFRAG) {
      /* Проверка всех байт, кроме последнего байта в карте бит. */
      for(i = 0; i < uip_reasslen / (8 * 8) - 1; ++i) {
         if(uip_reassbitmap[i] != 0xff) {
            goto nullreturn;
         }
      }
      /* Проверка последнего байта в карте бит. Он должне содержать просто
         правильную сумму бит. */
      if(uip_reassbitmap[uip_reasslen / (8 * 8)] !=
         (u8_t)~bitmap_bits[uip_reasslen / 8 & 7]) {
         goto nullreturn;
      }

      /* Если мы попали сюда, то у нас есть в буфере полный пакет, так что
         выделим pbuf и скопируем пакет туда. Также сбросим таймер. */
      uip_reasstmr = 0;
      memcpy(BUF, FBUF, uip_reasslen);

      /* Покажем, что теперь IP пакет "нормальный" (т. е. не фрагментированный). */
      BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
      BUF->len[0] = uip_reasslen >> 8;
      BUF->len[1] = uip_reasslen & 0xff;
      BUF->ipchksum = 0;
      BUF->ipchksum = ~(uip_ipchksum());

      return uip_reasslen;
    }
  }

 nullreturn:
  return 0;
}
#endif /* UIP_REASSEMBLY */
/*---------------------------------------------------------------------------*/
static void uip_add_rcv_nxt(u16_t n)
{
  uip_add32(uip_conn->rcv_nxt, n);
  uip_conn->rcv_nxt[0] = uip_acc32[0];
  uip_conn->rcv_nxt[1] = uip_acc32[1];
  uip_conn->rcv_nxt[2] = uip_acc32[2];
  uip_conn->rcv_nxt[3] = uip_acc32[3];
}
/*---------------------------------------------------------------------------*/
void uip_process(u8_t flag)
{
   register struct uip_conn *uip_connr = uip_conn;

#if UIP_UDP
   if(flag == UIP_UDP_SEND_CONN) {
      goto udp_send;
   }
#endif /* UIP_UDP */
  
   uip_sappdata = uip_appdata = &uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];

   /* Проверка - был ли вызов по причине опроса отдельного соединения. */
   if(flag == UIP_POLL_REQUEST) {
      if((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED &&
         !uip_outstanding(uip_connr)) {
         uip_flags = UIP_POLL;
         UIP_APPCALL();
         goto appsend;
      }
      goto drop;
    
      /* Проверка - был ли вызов по причине срабатывания периодического
         таймера. */
   } else if(flag == UIP_TIMER) {
#if UIP_REASSEMBLY
      if(uip_reasstmr != 0) {
         --uip_reasstmr;
      }
#endif /* UIP_REASSEMBLY */
      /* Увеличение начального последовательного номера. */
      if(++iss[3] == 0) {
         if(++iss[2] == 0) {
            if(++iss[1] == 0) {
               ++iss[0];
            }
         }
      }

      /* Сброс переменных длины. */
      uip_len = 0;
      uip_slen = 0;

      /* Проверка - находится ли соединение в состоянии, когда
         просто идет отслеживание таймаута. Если это так, то
         увеличим таймер соединения, и удалим соединение
         если таймаут истек. */
      if(uip_connr->tcpstateflags == UIP_TIME_WAIT ||
         uip_connr->tcpstateflags == UIP_FIN_WAIT_2) {
         ++(uip_connr->timer);
         if(uip_connr->timer == UIP_TIME_WAIT_TIMEOUT) {
            uip_connr->tcpstateflags = UIP_CLOSED;
         }
      } else if(uip_connr->tcpstateflags != UIP_CLOSED) {
         /* Если соединение имеет неподтвержденные данные,
            то увеличим таймер соединения и посмотрим,
            достигнуто ли значение RTO, в этом случае
            делаем ретрансмиссию. */
         if(uip_outstanding(uip_connr)) {
            if(uip_connr->timer-- == 0) {
               if(uip_connr->nrtx == UIP_MAXRTX ||
                  ((uip_connr->tcpstateflags == UIP_SYN_SENT ||
                  uip_connr->tcpstateflags == UIP_SYN_RCVD) &&
                  uip_connr->nrtx == UIP_MAXSYNRTX)) {
                  uip_connr->tcpstateflags = UIP_CLOSED;

                  /* Мы вызвали UIP_APPCALL() с переменной uip_flags,
                     где установлен UIP_TIMEDOUT, чтобы оповестить
                     приложение о том, что таймаут соединения истек. */
                  uip_flags = UIP_TIMEDOUT;
                  UIP_APPCALL();

                  /* Также мы пошлем пакет сброса на remote host. */
                  BUF->flags = TCP_RST | TCP_ACK;
                  goto tcp_send_nodata;
               }

               /* Экспоненциальный возврат. */
               uip_connr->timer = UIP_RTO << (uip_connr->nrtx > 4?
                                              4:
                                              uip_connr->nrtx);
               ++(uip_connr->nrtx);
   
               /* ОК, теперь нам нужна повторная передача. Это мы будем
                  делать по-разному, в зависимости от состояния, 
                  в котором находимся. Если в ESTABLISHED, то вызовем
                  приложение, которое может подготовить данные к
                  повторной передаче. Если в SYN_RCVD, мы заново отправим
                  SYNACK, который мы отправмли ранее и если LAST_ACK,
                  то заново передадим наш FINACK. */
               UIP_STAT(++uip_stat.tcp.rexmit);
               switch(uip_connr->tcpstateflags & UIP_TS_MASK) {
               case UIP_SYN_RCVD:
                  /* В состояии SYN_RCVD state, мы должны заново передать
                     наш SYNACK. */
                  goto tcp_send_synack;
   
#if UIP_ACTIVE_OPEN
               case UIP_SYN_SENT:
                  /* В состоянии SYN_SENT заново передадим SYN. */
                  BUF->flags = 0;
                  goto tcp_send_syn;
#endif /* UIP_ACTIVE_OPEN */
   
               case UIP_ESTABLISHED:
                  /* В состоянии ESTABLISHED мы вызовем приложение,
                     чтобы сделать действительный ретрансмит, после
                     этого перепрыгнем на код для отправки пакета
                     (по метке apprexmit). */
                  uip_flags = UIP_REXMIT;
                  UIP_APPCALL();
                  goto apprexmit;
   
               case UIP_FIN_WAIT_1:
               case UIP_CLOSING:
               case UIP_LAST_ACK:
                  /* Во всех этих состояниях мы должны заново передать
                     FINACK. */
                  goto tcp_send_finack;
               }
            }
         } else if((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED) {
            /* Если в этом месте не нужно делать ретрансмиссию, то
               опросим приложение на предмет новых данных. */
            uip_flags = UIP_POLL;
            UIP_APPCALL();
            goto appsend;
         }
      }
      goto drop;
   }
#if UIP_UDP
   if(flag == UIP_UDP_TIMER) {
      if(uip_udp_conn->lport != 0) {
         uip_conn = NULL;
         uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
         uip_len = uip_slen = 0;
         uip_flags = UIP_POLL;
         UIP_UDP_APPCALL();
         goto udp_send;
      } else {
         goto drop;
      }
   }
#endif

   /* В этом месте начитается обработка входных данных. */
   UIP_STAT(++uip_stat.ip.recv);

   /* Начало кода обработки входного заголовка IP. */
  
#if UIP_CONF_IPV6
   /* Проверка правильности заголовка IP. */
   if((BUF->vtc & 0xf0) != 0x60) { /* Версия IP и длина заголовка. */
      UIP_STAT(++uip_stat.ip.drop);
      UIP_STAT(++uip_stat.ip.vhlerr);
      UIP_LOG("ipv6: invalid version.");
      goto drop;
   }
#else /* UIP_CONF_IPV6 */
   /* Проверка правильности заголовка IP. */
   if(BUF->vhl != 0x45) { /* Версия IP и длина заголовка. */
      UIP_STAT(++uip_stat.ip.drop);
      UIP_STAT(++uip_stat.ip.vhlerr);
      UIP_LOG("ip: invalid version or header length.");
      goto drop;
   }
#endif /* UIP_CONF_IPV6 */
  
   /* Проверка размера пакета. Если размер, который сообщает переменная
      uip_len, меньше размера, сообщенного в заголовке IP, предполагаем
      что пакет был поврежден при передаче. Если размер в uip_len
      больше, чем размер в заголовке пакета IP, то пакет был дополнен,
      и мы установим uip_len в правильное значение. */

   if((BUF->len[0] << 8) + BUF->len[1] <= uip_len) {
      uip_len = (BUF->len[0] << 8) + BUF->len[1];
#if UIP_CONF_IPV6
      uip_len += 40; /* Длина, сообщенная в заголовке IPv6,
                        является длиной полезной нагрузки,
                        которая идет за заголовком. Однако
                        uIP использует переменную uip_len
                        для удержания размера всего пакета,
                        включая заголовок IP. Для IPv4 это
                        не проблема, так как поле длины в
                        заголовке IPv4 содержит длину целого
                        пакета. Но для IPv6 нам нужно добавить
                        размер заголовка IPv6 (40 байт). */
#endif /* UIP_CONF_IPV6 */
   } else {
      UIP_LOG("ip: packet shorter than reported in IP header.");
      goto drop;
   }

#if !UIP_CONF_IPV6
   /* Проверка флага фрагмента. */
   if((BUF->ipoffset[0] & 0x3f) != 0 ||
      BUF->ipoffset[1] != 0) {
#if UIP_REASSEMBLY
      uip_len = uip_reass();
      if(uip_len == 0) {
         goto drop;
      }
#else /* UIP_REASSEMBLY */
      UIP_STAT(++uip_stat.ip.drop);
      UIP_STAT(++uip_stat.ip.fragerr);
      UIP_LOG("ip: fragment dropped.");
      goto drop;
#endif /* UIP_REASSEMBLY */
   }
#endif /* UIP_CONF_IPV6 */

   if(uip_ipaddr_cmp(uip_hostaddr, all_zeroes_addr)) {
      /* Если мы сконфигурированы использовать ping адреса IP, и
         адрес IP еще не назначен, то мы примем все пакеты ICMP. */
#if UIP_PINGADDRCONF && !UIP_CONF_IPV6
      if(BUF->proto == UIP_PROTO_ICMP) {
         UIP_LOG("ip: possible ping config packet received.");
         goto icmp_input;
      } else {
         UIP_LOG("ip: packet dropped since no address assigned.");
         goto drop;
      }
#endif /* UIP_PINGADDRCONF */

   } else {
      /* Если сконфигурирована поддержка IP broadcast, то проверим
         пакет UDP на broadcast, который мог предназначаться нам. */
#if UIP_BROADCAST
      DEBUG_PRINTF("UDP IP checksum 0x%04x\n", uip_ipchksum());
      if(BUF->proto == UIP_PROTO_UDP &&
         uip_ipaddr_cmp(BUF->destipaddr, all_ones_addr)
         /*&&
         uip_ipchksum() == 0xffff*/) {
         goto udp_input;
      }
#endif /* UIP_BROADCAST */
    
      /* Проверка, предназначен ли пакет нашему адресу IP. */
#if !UIP_CONF_IPV6
      if(!uip_ipaddr_cmp(BUF->destipaddr, uip_hostaddr)) {
         UIP_STAT(++uip_stat.ip.drop);
         goto drop;
      }
#else /* UIP_CONF_IPV6 */
      /* Для IPv6 прием пакета немного сложнее, так как нам нужно
         убедиться, что мы также прослушиваем определенные адреса multicast
         (все multicast адреса хостов, требуемые адреса узлов multicast).
         Однако тут мы будем читить, и принимать все пакеты multicast,
         которые были отправлены на адреса ff02::/16 адресов. */
      if(!uip_ipaddr_cmp(BUF->destipaddr, uip_hostaddr) &&
         BUF->destipaddr[0] != HTONS(0xff02)) {
         UIP_STAT(++uip_stat.ip.drop);
         goto drop;
      }
#endif /* UIP_CONF_IPV6 */
   }

#if !UIP_CONF_IPV6
   if(uip_ipchksum() != 0xffff) { /* Вычисление и проверка контрольной
                                     суммы заголовка IP. */
      UIP_STAT(++uip_stat.ip.drop);
      UIP_STAT(++uip_stat.ip.chkerr);
      UIP_LOG("ip: bad checksum.");
      goto drop;
   }
#endif /* UIP_CONF_IPV6 */

   if(BUF->proto == UIP_PROTO_TCP) { /* Проверка пакета TCP. Если это так,
                                        начинаем обработку ввода TCP. */
      goto tcp_input;
   }

#if UIP_UDP
   if(BUF->proto == UIP_PROTO_UDP) {
      goto udp_input;
   }
#endif /* UIP_UDP */

#if !UIP_CONF_IPV6
   /* Далее идет код обработки ICMPv4. */
   if(BUF->proto != UIP_PROTO_ICMP) { /* Отсюда будем разрешать только
                                         пакеты ICMP. */
      UIP_STAT(++uip_stat.ip.drop);
      UIP_STAT(++uip_stat.ip.protoerr);
      UIP_LOG("ip: neither tcp nor icmp.");
      goto drop;
   }

#if UIP_PINGADDRCONF
 icmp_input:
#endif /* UIP_PINGADDRCONF */
   UIP_STAT(++uip_stat.icmp.recv);

   /* Обработка ICMP echo (например ping). Она проста, мы только поменяем
      тип ICMP с ECHO на ECHO_REPLY, и подстроим контрольную сумму ICMP
      перед возвратом пакета. */
   if(ICMPBUF->type != ICMP_ECHO) {
      UIP_STAT(++uip_stat.icmp.drop);
      UIP_STAT(++uip_stat.icmp.typeerr);
      UIP_LOG("icmp: not icmp echo.");
      goto drop;
   }

   /* Если мы были сконфигурированы для использования назначенного IP адреса
      ping. мы используем адрес IP назначения этого пакета ping и назначим
      его самим себе. */
#if UIP_PINGADDRCONF
   if((uip_hostaddr[0] | uip_hostaddr[1]) == 0) {
      uip_hostaddr[0] = BUF->destipaddr[0];
      uip_hostaddr[1] = BUF->destipaddr[1];
   }
#endif /* UIP_PINGADDRCONF */

  ICMPBUF->type = ICMP_ECHO_REPLY;

   if(ICMPBUF->icmpchksum >= HTONS(0xffff - (ICMP_ECHO << 8))) {
      ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8) + 1;
   } else {
      ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8);
   }

   /* Перестановка адресов IP. */
   uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr);
   uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);

   UIP_STAT(++uip_stat.icmp.sent);
   goto send;

  /* Конец кода обработки входного заголовка IPv4. */
#else /* !UIP_CONF_IPV6 */

  /* Это код обработки IPv6 ICMPv6. */
  DEBUG_PRINTF("icmp6_input: length %d\n", uip_len);

   if(BUF->proto != UIP_PROTO_ICMP6) { /* Отсюда будем разрешать только
                                          пакеты ICMPv6. */
      UIP_STAT(++uip_stat.ip.drop);
      UIP_STAT(++uip_stat.ip.protoerr);
      UIP_LOG("ip: neither tcp nor icmp6.");
      goto drop;
   }

   UIP_STAT(++uip_stat.icmp.recv);

   /* Если мы получаем ходатайство соседа для нашего адреса, то мы
      должны передать сообщение соседа обратно. */
   if(ICMPBUF->type == ICMP6_NEIGHBOR_SOLICITATION) {
      if(uip_ipaddr_cmp(ICMPBUF->icmp6data, uip_hostaddr)) {
         if(ICMPBUF->options[0] == ICMP6_OPTION_SOURCE_LINK_ADDRESS) {
            /* Сохранение адреса отправителя в списке наших соседей. */
            uip_neighbor_add(ICMPBUF->srcipaddr, &(ICMPBUF->options[2]));
         }
      
         /* Теперь нужно отправить сообщение соседа обратно туда,
             откуда оно пришло. */
         ICMPBUF->type = ICMP6_NEIGHBOR_ADVERTISEMENT;
         ICMPBUF->flags = ICMP6_FLAG_S; /* Solicited flag. */
      
         ICMPBUF->reserved1 = ICMPBUF->reserved2 = ICMPBUF->reserved3 = 0;
      
         uip_ipaddr_copy(ICMPBUF->destipaddr, ICMPBUF->srcipaddr);
         uip_ipaddr_copy(ICMPBUF->srcipaddr, uip_hostaddr);
         ICMPBUF->options[0] = ICMP6_OPTION_TARGET_LINK_ADDRESS;
         ICMPBUF->options[1] = 1;  /* Options length, 1 = 8 bytes. */
         memcpy(&(ICMPBUF->options[2]), &uip_ethaddr, sizeof(uip_ethaddr));
         ICMPBUF->icmpchksum = 0;
         ICMPBUF->icmpchksum = ~uip_icmp6chksum();
         goto send;
      }
      goto drop;
   } else if(ICMPBUF->type == ICMP6_ECHO) {
      /* Обработка ICMP echo (например ping). Она проста, мы только
         меняем тип ICMP с ECHO на ECHO_REPLY, и обновляем контролную
         сумму ICMP перед возвратом пакета. */
      ICMPBUF->type = ICMP6_ECHO_REPLY;
    
      uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr);
      uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
      ICMPBUF->icmpchksum = 0;
      ICMPBUF->icmpchksum = ~uip_icmp6chksum();
    
      UIP_STAT(++uip_stat.icmp.sent);
      goto send;
   } else {
      DEBUG_PRINTF("Unknown icmp6 message type %d\n", ICMPBUF->type);
      UIP_STAT(++uip_stat.icmp.drop);
      UIP_STAT(++uip_stat.icmp.typeerr);
      UIP_LOG("icmp: unknown ICMP message.");
      goto drop;
   }
   /* Конец обработки IPv6 ICMP. */
#endif /* !UIP_CONF_IPV6 */

#if UIP_UDP
   /* Обработка входа UDP. */
 udp_input:
   /* Обработка UDP реально похожа на хак. Мы ничего не делаем 
      с заголовками UDP/IP, просто позволим приложению UDP
      сделать всю сложную работу. Если приложение установило
      uip_slen, то у нас есть пакет для отправки. */
#if UIP_UDP_CHECKSUMS
   uip_len = uip_len - UIP_IPUDPH_LEN;
   uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
   if(UDPBUF->udpchksum != 0 && uip_udpchksum() != 0xffff) {
      UIP_STAT(++uip_stat.udp.drop);
      UIP_STAT(++uip_stat.udp.chkerr);
      UIP_LOG("udp: bad checksum.");
      goto drop;
   }
#else /* UIP_UDP_CHECKSUMS */
   uip_len = uip_len - UIP_IPUDPH_LEN;
#endif /* UIP_UDP_CHECKSUMS */

   /* Демультиплексирование этого пакета UDP между "подключениями" UDP. */
   for(uip_udp_conn = &uip_udp_conns[0];
      uip_udp_conn < &uip_udp_conns[UIP_UDP_CONNS];
      ++uip_udp_conn) {
      /* Если локальный порт UDP не 0, то считается что соединение
         используется. Если это так, то локальный номер порта проверяется
         на номер порта назначения в принятом пакете. Если эти два
         номера порта совпадают, номер порта дальнего конца проверяется
         на предмет привязки к соединения к порту дальнего конца. 
         В завершение, если соединение привязано к адресу IP дальнего
         конца, в пакете проверяется адрес IP источника. */
      if(uip_udp_conn->lport != 0 &&
         UDPBUF->destport == uip_udp_conn->lport &&
         (uip_udp_conn->rport == 0 ||
         UDPBUF->srcport == uip_udp_conn->rport) &&
         (uip_ipaddr_cmp(uip_udp_conn->ripaddr, all_zeroes_addr) ||
         uip_ipaddr_cmp(uip_udp_conn->ripaddr, all_ones_addr) ||
         uip_ipaddr_cmp(BUF->srcipaddr, uip_udp_conn->ripaddr))) {
         goto udp_found;
      }
   }
   UIP_LOG("udp: no matching connection found");
   goto drop;
  
 udp_found:
   uip_conn = NULL;
   uip_flags = UIP_NEWDATA;
   uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
   uip_slen = 0;
   UIP_UDP_APPCALL();
 udp_send:
   if(uip_slen == 0) {
      goto drop;
   }
   uip_len = uip_slen + UIP_IPUDPH_LEN;

#if UIP_CONF_IPV6
   /* Для IPv6 длина поля IP не включено в длину IP заголовка IPv6. */
   BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);
   BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);
#else /* UIP_CONF_IPV6 */
   BUF->len[0] = (uip_len >> 8);
   BUF->len[1] = (uip_len & 0xff);
#endif /* UIP_CONF_IPV6 */

   BUF->ttl = uip_udp_conn->ttl;
   BUF->proto = UIP_PROTO_UDP;

   UDPBUF->udplen = HTONS(uip_slen + UIP_UDPH_LEN);
   UDPBUF->udpchksum = 0;

   BUF->srcport  = uip_udp_conn->lport;
   BUF->destport = uip_udp_conn->rport;

   uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
   uip_ipaddr_copy(BUF->destipaddr, uip_udp_conn->ripaddr);
   
   uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPTCPH_LEN];

#if UIP_UDP_CHECKSUMS
   /* Вычисление контрольной суммы UDP. */
   UDPBUF->udpchksum = ~(uip_udpchksum());
   if(UDPBUF->udpchksum == 0) {
      UDPBUF->udpchksum = 0xffff;
   }
#endif /* UIP_UDP_CHECKSUMS */
  
   goto ip_send_nolen;
#endif /* UIP_UDP */
  
   /* Обработка ввода TCP. */
 tcp_input:
   UIP_STAT(++uip_stat.tcp.recv);

   /* Начало кода обработки входного заголовка TCP. */
  
   if(uip_tcpchksum() != 0xffff) { /* Вычисление и проверка 
                                      контрольной суммы TCP. */
      UIP_STAT(++uip_stat.tcp.drop);
      UIP_STAT(++uip_stat.tcp.chkerr);
      UIP_LOG("tcp: bad checksum.");
      goto drop;
   }
  
   /* Демультиплексирование этого сегмента. */
   /* Сначала проверяем активные соединения. */
   for(uip_connr = &uip_conns[0]; uip_connr <= &uip_conns[UIP_CONNS - 1];
       ++uip_connr) {
      if(uip_connr->tcpstateflags != UIP_CLOSED &&
         BUF->destport == uip_connr->lport &&
         BUF->srcport == uip_connr->rport &&
         uip_ipaddr_cmp(BUF->srcipaddr, uip_connr->ripaddr)) {
         goto found;
      }
   }

   /* Если мы не нашли и активное соедиение, которое ожидает пакет,
      либо этот пакет старая копия, или он является пакетом SYN,
      предназначенный для соединения в состоянии LISTEN. Если флаг
      SYN не установлен, это старый пакет, и мы пошлем RST. */
   if((BUF->flags & TCP_CTL) != TCP_SYN) {
      goto reset;
   }
  
   tmp16 = BUF->destport;
   /* Далее проверим прослушиваемые соединения. */
   for(c = 0; c < UIP_LISTENPORTS; ++c) {
      if(tmp16 == uip_listenports[c]) {
         goto found_listen;
      }
   }
  
   /* Не найдено подходящих соединений, так что пошлем пакет RST. */
   UIP_STAT(++uip_stat.tcp.synrst);
 reset:

   /* Мы не посылаем сбросы в ответ на сбросы. */
   if(BUF->flags & TCP_RST) {
      goto drop;
   }

   UIP_STAT(++uip_stat.tcp.rst);
  
   BUF->flags = TCP_RST | TCP_ACK;
   uip_len = UIP_IPTCPH_LEN;
   BUF->tcpoffset = 5 << 4;

   /* Переставим поля seqno и ackno в заголовке TCP. */
   c = BUF->seqno[3];
   BUF->seqno[3] = BUF->ackno[3];
   BUF->ackno[3] = c;
  
   c = BUF->seqno[2];
   BUF->seqno[2] = BUF->ackno[2];
   BUF->ackno[2] = c;
  
   c = BUF->seqno[1];
   BUF->seqno[1] = BUF->ackno[1];
   BUF->ackno[1] = c;
  
   c = BUF->seqno[0];
   BUF->seqno[0] = BUF->ackno[0];
   BUF->ackno[0] = c;

   /* Также увеличим номер последовательности, который подтверждаем.
      Если наименее значемый байт переполнился, то нужно распространить
      перенос на более старшие байты. */
   if(++BUF->ackno[3] == 0) {
      if(++BUF->ackno[2] == 0) {
         if(++BUF->ackno[1] == 0) {
            ++BUF->ackno[0];
         }
      }
   }
 
   /* Переставим номера портов. */
   tmp16 = BUF->srcport;
   BUF->srcport = BUF->destport;
   BUF->destport = tmp16;
  
   /* Переставим адреса IP. */
   uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr);
   uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
  
   /* И отправим пакет RST! */
   goto tcp_send_noconn;

   /* По этой метке будут переходы, если обнаружено, что входящий пакет
      для соединения в состоянии LISTEN. Тогда мы должны создать новое
      соединение и отправить в ответ SYNACK. */
 found_listen:
   /* Сначала проверим, есть ли доступные соединения. Не используемые
      соединения хранятся в той же таблице, что и используемые, однако
      у неиспользуемых поле tcpstate установлено в состояние CLOSED.
      Также отслеживаются соединения в состоянии TIME_WAIT, и будем
      использовать самые старые из них, если не найдено соединений
      в состоянии CLOSED. Благодарю Eddie C. Dost за отличный алгоритм
      для поиска TIME_WAIT. */
   uip_connr = 0;
   for(c = 0; c < UIP_CONNS; ++c) {
      if(uip_conns[c].tcpstateflags == UIP_CLOSED) {
         uip_connr = &uip_conns[c];
         break;
      }
      if(uip_conns[c].tcpstateflags == UIP_TIME_WAIT) {
         if(uip_connr == 0 ||
            uip_conns[c].timer > uip_connr->timer) {
            uip_connr = &uip_conns[c];
         }
      }
   }

   if(uip_connr == 0) {
      /* Все соединения уже задействованы, так что отбросим пакет
         и будем надеяться, что дальний конец переотправит пакет
         тогда, когда у нас будет больше свободных соединений. */
      UIP_STAT(++uip_stat.tcp.syndrop);
      UIP_LOG("tcp: found no unused connections.");
      goto drop;
   }
   uip_conn = uip_connr;
  
   /* Заполним нужные поля для нового соединения. */
   uip_connr->rto = uip_connr->timer = UIP_RTO;
   uip_connr->sa = 0;
   uip_connr->sv = 4;
   uip_connr->nrtx = 0;
   uip_connr->lport = BUF->destport;
   uip_connr->rport = BUF->srcport;
   uip_ipaddr_copy(uip_connr->ripaddr, BUF->srcipaddr);
   uip_connr->tcpstateflags = UIP_SYN_RCVD;
   
   uip_connr->snd_nxt[0] = iss[0];
   uip_connr->snd_nxt[1] = iss[1];
   uip_connr->snd_nxt[2] = iss[2];
   uip_connr->snd_nxt[3] = iss[3];
   uip_connr->len = 1;
   
   /* rcv_nxt должно быть seqno из входящего пакета + 1. */
   uip_connr->rcv_nxt[3] = BUF->seqno[3];
   uip_connr->rcv_nxt[2] = BUF->seqno[2];
   uip_connr->rcv_nxt[1] = BUF->seqno[1];
   uip_connr->rcv_nxt[0] = BUF->seqno[0];
   uip_add_rcv_nxt(1);

   /* Парсинг опции TCP MSS, если она есть. */
   if((BUF->tcpoffset & 0xf0) > 0x50) {
      for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2 ;) {
         opt = uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + c];
         if(opt == TCP_OPT_END) {
            /* Конец опций. */
            break;
         } else if(opt == TCP_OPT_NOOP) {
            ++c;
            /* Опция NOP. */
         } else if(opt == TCP_OPT_MSS &&
             uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == TCP_OPT_MSS_LEN) {
            /* Опция MSS с правильной длиной опции. */
            tmp16 = ((u16_t)uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) |
                    (u16_t)uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + 3 + c];
            uip_connr->initialmss = uip_connr->mss =
            tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
      
            /* И мы завершили обработку опций. */
            break;
         } else {
            /* Все другие опции имеют поле длины, так что нам проще
               их пропустить. */
            if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {
               /* Если поле длины 0, то опции ошибочно сформированы,
                  и мы их не будем дальше обрабатывать. */
               break;
            }
            c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
         }
      }
   }
  
   /* Наш ответ будет SYNACK. */
#if UIP_ACTIVE_OPEN
   tcp_send_synack:
   BUF->flags = TCP_ACK;
  
 tcp_send_syn:
   BUF->flags |= TCP_SYN;
#else /* UIP_ACTIVE_OPEN */
 tcp_send_synack:
   BUF->flags = TCP_SYN | TCP_ACK;
#endif /* UIP_ACTIVE_OPEN */
  
   /* Отправим опцию TCP Maximum Segment Size с нашим SYNACK. */
   BUF->optdata[0] = TCP_OPT_MSS;
   BUF->optdata[1] = TCP_OPT_MSS_LEN;
   BUF->optdata[2] = (UIP_TCP_MSS) / 256;
   BUF->optdata[3] = (UIP_TCP_MSS) & 255;
   uip_len = UIP_IPTCPH_LEN + TCP_OPT_MSS_LEN;
   BUF->tcpoffset = ((UIP_TCPH_LEN + TCP_OPT_MSS_LEN) / 4) << 4;
   goto tcp_send;

   /* По этой метке будут переходы, если будет найдено
      активное соединение. */
 found:
   uip_conn = uip_connr;
   uip_flags = 0;
   /* Будет сделана самая стандартная обработка сброса TCP; мы просто
      примем любой RST и убъем наше соединение. Мы фактически должны
      проверить, является ли номер последовательности этого сброса
      в нашем предоставленном окне, перед тем как мы примем сброс. */
   if(BUF->flags & TCP_RST) {
      uip_connr->tcpstateflags = UIP_CLOSED;
      UIP_LOG("tcp: got reset, aborting connection.");
      uip_flags = UIP_ABORT;
      UIP_APPCALL();
      goto drop;
   }
   /* Вычисленная длина данных, если приложение послало нам
      любые данные. */
   c = (BUF->tcpoffset >> 4) << 2;
   /* uip_len будет содержать длину действительных данных TCP. Она будет
      вычислена путем вычитания длины заголовка TCP (в переменной c)
      и длины заголовка IP (20 байт). */
   uip_len = uip_len - c - UIP_IPH_LEN;

   /* Сначала проверим номер последовательности входящего пакета, тот ли
      он, что ожидается как следующий. Если нет, то пошлем ACK с правильным
      номером. */
   if(!(((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_SYN_SENT) &&
       ((BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)))) {
      if((uip_len > 0 || ((BUF->flags & (TCP_SYN | TCP_FIN)) != 0)) &&
         (BUF->seqno[0] != uip_connr->rcv_nxt[0] ||
         BUF->seqno[1] != uip_connr->rcv_nxt[1] ||
         BUF->seqno[2] != uip_connr->rcv_nxt[2] ||
         BUF->seqno[3] != uip_connr->rcv_nxt[3])) {
         goto tcp_send_ack;
      }
   }

   /* Далее проверим, подтверждает ли входящий сегмент какие-нибудь еще
      не подтвержденные данные. Если это так, то обновим номер
      последовательности, сбросим длину неподтвержденных данных,
      вычислим оценки RTT, и сбросим таймер ретрансмиссии. */
   if((BUF->flags & TCP_ACK) && uip_outstanding(uip_connr)) {
      uip_add32(uip_connr->snd_nxt, uip_connr->len);

      if(BUF->ackno[0] == uip_acc32[0] &&
         BUF->ackno[1] == uip_acc32[1] &&
         BUF->ackno[2] == uip_acc32[2] &&
         BUF->ackno[3] == uip_acc32[3]) {
         /* Обновление номера последовательности. */
         uip_connr->snd_nxt[0] = uip_acc32[0];
         uip_connr->snd_nxt[1] = uip_acc32[1];
         uip_connr->snd_nxt[2] = uip_acc32[2];
         uip_connr->snd_nxt[3] = uip_acc32[3];

         /* Сделаем оценку RTT, если мы не сделали ретрансмиссии. */
         if(uip_connr->nrtx == 0) {
            signed char m;
            m = uip_connr->rto - uip_connr->timer;
            /* Это взято непосредственно из оригинального коа VJ в его статье */
            m = m - (uip_connr->sa >> 3);
            uip_connr->sa += m;
            if(m < 0) {
               m = -m;
            }
            m = m - (uip_connr->sv >> 2);
            uip_connr->sv += m;
            uip_connr->rto = (uip_connr->sa >> 3) + uip_connr->sv;
         }
         /* Установка флага, что было подтверждение. */
         uip_flags = UIP_ACKDATA;
         /* Сброс таймера ретрансмиссии. */
         uip_connr->timer = uip_connr->rto;

         /* Сброс длины неподтвержденных данных. */
         uip_connr->len = 0;
      }
  }

   /* Предпримем разные действия в зависимости от того, в каком состоянии
      находится соединение. */
   switch(uip_connr->tcpstateflags & UIP_TS_MASK) {
      /* Здесь не обрабатываются состояния CLOSED и LISTEN. CLOSE_WAIT
         не реализовано, поскольку мы вынуждаем приложение сделать закрытие,
         когда участник обмена посылает FIN (следовательно приложение
         перейдет непосредственно от ESTABLISHED к LAST_ACK). */
   case UIP_SYN_RCVD:
      /* В состоянии SYN_RCVD отправим SYNACK в ответ на SYN, и
         ждем ACK, который подтвердит данные, которые мы послали последний
         раз. Таким образом, мы хотим иметь установленным флаг UIP_ACKDATA.
         Если так, то входим в состояние ESTABLISHED. */
      if(uip_flags & UIP_ACKDATA) {
         uip_connr->tcpstateflags = UIP_ESTABLISHED;
         uip_flags = UIP_CONNECTED;
         uip_connr->len = 0;
         if(uip_len > 0) {
            uip_flags |= UIP_NEWDATA;
            uip_add_rcv_nxt(uip_len);
         }
         uip_slen = 0;
         UIP_APPCALL();
         goto appsend;
      }
      goto drop;
#if UIP_ACTIVE_OPEN
   case UIP_SYN_SENT:
      /* В состоянии SYN_SENT, мы ждем SYNACK, который отправляется в ответ
         на наш SYN. Переменная rcv_nxt установлена в номер последовательности
         SYNACK плюс один, и мы посылаем ACK. Перейдем в состояние ESTABLISHED. */
      if((uip_flags & UIP_ACKDATA) &&
         (BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)) {
         /* Парсинг опции TCP MSS, если она представлена. */
         if((BUF->tcpoffset & 0xf0) > 0x50) {
            for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2 ;) {
               opt = uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + c];
               if(opt == TCP_OPT_END) {
                  /* Конец опций. */
                  break;
               } else if(opt == TCP_OPT_NOOP) {
                  ++c;
                  /* Опция NOP. */
               } else if(opt == TCP_OPT_MSS &&
                  uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == TCP_OPT_MSS_LEN) {
                  /* Опция MSS с правильной длиной опции. */
                  tmp16 = (uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) |
                  uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 3 + c];
                  uip_connr->initialmss =
                     uip_connr->mss = tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
   
                  /* Имы закончили обработку опций. */
                  break;
               } else {
                  /* Все другие опции имеют поле длины, так что их можно
                     проще пропустить. */
                  if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {
                     /* Если поле длины 0, то опция сформирована ошибочно
                        и мы дальше не обрабатываем их далее. */
                     break;
                  }
                  c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
               }
            }
         }
         uip_connr->tcpstateflags = UIP_ESTABLISHED;
         uip_connr->rcv_nxt[0] = BUF->seqno[0];
         uip_connr->rcv_nxt[1] = BUF->seqno[1];
         uip_connr->rcv_nxt[2] = BUF->seqno[2];
         uip_connr->rcv_nxt[3] = BUF->seqno[3];
         uip_add_rcv_nxt(1);
         uip_flags = UIP_CONNECTED | UIP_NEWDATA;
         uip_connr->len = 0;
         uip_len = 0;
         uip_slen = 0;
         UIP_APPCALL();
         goto appsend;
      }
      /* Сообщаем приложению, что соединение потерпело ошибку */
      uip_flags = UIP_ABORT;
      UIP_APPCALL();
      /* Соединение было завершено после того как мы послали RST */
      uip_conn->tcpstateflags = UIP_CLOSED;
      goto reset;
#endif /* UIP_ACTIVE_OPEN */
   case UIP_ESTABLISHED:
      /* В состоянии ESTABLISHED вызовем приложение, чтобы подать данные
         в uip_buf. Если флаг UIP_ACKDATA установлен, приложение должно
         поместить новые данные в буфер, иначе мы заново передадим старый
         сегмент, и приложение должно поместить данные в буфер.
   
         Если взодящий пакет FIN, мы должны также закрыть соединение 
         на этой стороне, и мы посылаем FIN и входим в состояние LAST_ACK.
         Здесь мы требуем, чтобы не было никаких неподтвержденных данных;
         иначе будут задействованы номера последовательности. */

      if(BUF->flags & TCP_FIN && !(uip_connr->tcpstateflags & UIP_STOPPED)) {
         if(uip_outstanding(uip_connr)) {
            goto drop;
         }
         uip_add_rcv_nxt(1 + uip_len);
         uip_flags |= UIP_CLOSE;
         if(uip_len > 0) {
            uip_flags |= UIP_NEWDATA;
         }
         UIP_APPCALL();
         uip_connr->len = 1;
         uip_connr->tcpstateflags = UIP_LAST_ACK;
         uip_connr->nrtx = 0;
 tcp_send_finack:
         BUF->flags = TCP_FIN | TCP_ACK;
         goto tcp_send_nodata;
      }
   
      /* Проверим флаг URG. Если он установлен, то сегмент несет в себе
         urgent data, которые мы должны передать приложению. */
      if((BUF->flags & TCP_URG) != 0) {
#if UIP_URGDATA > 0
         uip_urglen = (BUF->urgp[0] << 8) | BUF->urgp[1];
         if(uip_urglen > uip_len) {
            /* Есть больше urgent data в следующем сегменте, который
               поступит. */
            uip_urglen = uip_len;
         }
         uip_add_rcv_nxt(uip_urglen);
         uip_len -= uip_urglen;
         uip_urgdata = uip_appdata;
         uip_appdata += uip_urglen;
      } else {
         uip_urglen = 0;
#else /* UIP_URGDATA > 0 */
         uip_appdata = ((char *)uip_appdata) + ((BUF->urgp[0] << 8) | BUF->urgp[1]);
         uip_len -= (BUF->urgp[0] << 8) | BUF->urgp[1];
#endif /* UIP_URGDATA > 0 */
      }
   
      /* Если uip_len > 0, то в пакете есть данные TCP, запомним это
         установкой флага UIP_NEWDATA и обновим номер последовательности,
         который мы подтверждаем. Если приложение остановило поток данных,
         используя uip_stop(), мы не должны принять любые пакеты данных
         от remote host. */
      if(uip_len > 0 && !(uip_connr->tcpstateflags & UIP_STOPPED)) {
         uip_flags |= UIP_NEWDATA;
         uip_add_rcv_nxt(uip_len);
      }

      /* Проверка - меньше ли доступное место в буфере, представленное
         дальнему участнику обмена, чем начальное MSS для этого соединения.
         Если это так, то мы установим текущее MSS на рамер окна, чтобы
         гарантировать, что приложение не отправит данных больше, чем
         другая сторона может обработать.

         Если дальний участник обмена представил нулевое окно, то установим
         MSS в начальное MSS, так что приложение будет отправлять целое
         MSS данных. Эти данные не будут подтверждены приемником,
         и приложение будет передавать их повторно. Это назвается
         "постоянный таймер" и использует механизм ретрансмиссии.
      */
      tmp16 = ((u16_t)BUF->wnd[0] << 8) + (u16_t)BUF->wnd[1];
      if(tmp16 > uip_connr->initialmss ||
         tmp16 == 0) {
         tmp16 = uip_connr->initialmss;
      }
      uip_connr->mss = tmp16;

      /* Если этот пакет составляет ACK для неподтвержденных данных
         (помеченных флагом UIP_ACKDATA, мы должны вызвать приложение,
         поскольку оно может хотеть отправить больше данных. Если
         в пришедшем пакете были данные от дальнего участника обмена
         (помеченные флагом UIP_NEWDATA), то приложение также должно
         быть оповещено об этом.

         Когда вызывается приложение, глобальная переменная uip_len
         содержит длину пришедших данных. Приложение может получить
         доступ к пришедшим данным через глобальный указатель
         uip_appdata, который обычно указывает на 
         UIP_IPTCPH_LEN + UIP_LLH_LEN байт в буфере uip_buf.

         Если приложение хочет отправить данные, то они должны быть
         помещены в буфер uip_appdata и длина данных должна быть
         помещена в uip_len. Если у приложения нет данных для
         отправки, то uip_len должна быть сброшена в 0. */
      if(uip_flags & (UIP_NEWDATA | UIP_ACKDATA)) {
         uip_slen = 0;
         UIP_APPCALL();

    appsend:
         if(uip_flags & UIP_ABORT) {
            uip_slen = 0;
            uip_connr->tcpstateflags = UIP_CLOSED;
            BUF->flags = TCP_RST | TCP_ACK;
            goto tcp_send_nodata;
         }

         if(uip_flags & UIP_CLOSE) {
            uip_slen = 0;
            uip_connr->len = 1;
            uip_connr->tcpstateflags = UIP_FIN_WAIT_1;
            uip_connr->nrtx = 0;
            BUF->flags = TCP_FIN | TCP_ACK;
            goto tcp_send_nodata;
         }

         /* Если uip_slen > 0, то у приложения есть данные для отправки. */
         if(uip_slen > 0) {
            /* Если соединение имеет подтвержденные данные, то содержимое
               переменной ->len должно быть отброшено. */
            if((uip_flags & UIP_ACKDATA) != 0) {
               uip_connr->len = 0;
            }

            /* Если переменная ->len не 0, то соединение уже имеет данные
               в пути и не сейчас имеет права отправить больше. */
            if(uip_connr->len == 0) {
               /* Приложение не может отправить больше, чем это разрешено
                  mss (минимум MSS и доспупное окно). */
               if(uip_slen > uip_connr->mss) {
               uip_slen = uip_connr->mss;
               }

               /* Запомним, сколько данных мы теперь отсылаем, чтобы мы знали,
                  когда все будет подтверждено. */
               uip_connr->len = uip_slen;
            } else {
               /* Если у приложения уже есть неподтвержденные данные, убедимся,
                  что приложение не передает (например ретрансмиссию) больше,
                  чем отправило ранее. */
               uip_slen = uip_connr->len;
            }
         }
         uip_connr->nrtx = 0;
    apprexmit:
         uip_appdata = uip_sappdata;
   
         /* Если у приложения есть данные для отправки, или если в пришедшем
            пакете есть новые данные, мы должны отправить пакет. */
         if(uip_slen > 0 && uip_connr->len > 0) {
            /* Добавление длины заголовков IP и TCP. */
            uip_len = uip_connr->len + UIP_TCPIP_HLEN;
            /* Мы всегда установим флаг ACK в пакетах ответа. */
            BUF->flags = TCP_ACK | TCP_PSH;
            /* Отправим пакет. */
            goto tcp_send_noopts;
         }
         /* Если здесь нет данных для отправки, просто отправим чистый ACK,
            если здесь новые данные. */
         if(uip_flags & UIP_NEWDATA) {
            uip_len = UIP_TCPIP_HLEN;
            BUF->flags = TCP_ACK;
            goto tcp_send_noopts;
         }
      }
      goto drop;
   case UIP_LAST_ACK:
      /* Мы можем закрыть это соединение, если участник обмена подтвердил
         наш FIN. Это показывается флагом UIP_ACKDATA. */
      if(uip_flags & UIP_ACKDATA) {
         uip_connr->tcpstateflags = UIP_CLOSED;
         uip_flags = UIP_CLOSE;
         UIP_APPCALL();
      }
      break;
    
   case UIP_FIN_WAIT_1:
      /* Приложение имеет закрытое соединение, но remote host его еще
         не закрыл. Тут мы ничего не делаем, но ждем FIN с дальней стороны. */
      if(uip_len > 0) {
         uip_add_rcv_nxt(uip_len);
      }
      if(BUF->flags & TCP_FIN) {
         if(uip_flags & UIP_ACKDATA) {
            uip_connr->tcpstateflags = UIP_TIME_WAIT;
            uip_connr->timer = 0;
            uip_connr->len = 0;
         } else {
            uip_connr->tcpstateflags = UIP_CLOSING;
         }
         uip_add_rcv_nxt(1);
         uip_flags = UIP_CLOSE;
         UIP_APPCALL();
         goto tcp_send_ack;
      } else if(uip_flags & UIP_ACKDATA) {
         uip_connr->tcpstateflags = UIP_FIN_WAIT_2;
         uip_connr->len = 0;
         goto drop;
      }
      if(uip_len > 0) {
         goto tcp_send_ack;
      }
      goto drop;
   
  case UIP_FIN_WAIT_2:
      if(uip_len > 0) {
         uip_add_rcv_nxt(uip_len);
      }
      if(BUF->flags & TCP_FIN) {
         uip_connr->tcpstateflags = UIP_TIME_WAIT;
         uip_connr->timer = 0;
         uip_add_rcv_nxt(1);
         uip_flags = UIP_CLOSE;
         UIP_APPCALL();
         goto tcp_send_ack;
      }
      if(uip_len > 0) {
         goto tcp_send_ack;
      }
      goto drop;

   case UIP_TIME_WAIT:
      goto tcp_send_ack;
    
   case UIP_CLOSING:
      if(uip_flags & UIP_ACKDATA) {
         uip_connr->tcpstateflags = UIP_TIME_WAIT;
         uip_connr->timer = 0;
      }
   }
   goto drop;
  
   /* Мы перепрыгнули сюда, когда готоыв к отправке пакета, и просто
      хотим установить подходящие номера последовательности
      в заголовке TCP. */
 tcp_send_ack:
   BUF->flags = TCP_ACK;
   tcp_send_nodata:
   uip_len = UIP_IPTCPH_LEN;
 tcp_send_noopts:
   BUF->tcpoffset = (UIP_TCPH_LEN / 4) << 4;
 tcp_send:
   /* Мы завершили входную обработку. Теперь все готово к отправке
      ответа. Наша работа заключается в заполнении всех полей заголовков
      TCP и IP перед вычислением контрольной суммы и завершающей отправкой
      пакета. */
   BUF->ackno[0] = uip_connr->rcv_nxt[0];
   BUF->ackno[1] = uip_connr->rcv_nxt[1];
   BUF->ackno[2] = uip_connr->rcv_nxt[2];
   BUF->ackno[3] = uip_connr->rcv_nxt[3];
  
   BUF->seqno[0] = uip_connr->snd_nxt[0];
   BUF->seqno[1] = uip_connr->snd_nxt[1];
   BUF->seqno[2] = uip_connr->snd_nxt[2];
   BUF->seqno[3] = uip_connr->snd_nxt[3];
   
   BUF->proto = UIP_PROTO_TCP;
  
   BUF->srcport  = uip_connr->lport;
   BUF->destport = uip_connr->rport;
   
   uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
   uip_ipaddr_copy(BUF->destipaddr, uip_connr->ripaddr);

   if(uip_connr->tcpstateflags & UIP_STOPPED) {
      /* Если соединение выдало uip_stop(), мы представляем нулевое
         окно, чтобы remote host прекратил посылать данные. */
      BUF->wnd[0] = BUF->wnd[1] = 0;
   } else {
      BUF->wnd[0] = ((UIP_RECEIVE_WINDOW) >> 8);
      BUF->wnd[1] = ((UIP_RECEIVE_WINDOW) & 0xff);
   }

 tcp_send_noconn:
   BUF->ttl = UIP_TTL;
#if UIP_CONF_IPV6
   /* Для IPv6, поле длины IP не включает длину IP заголовка IPv6. */
   BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);
   BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);
#else /* UIP_CONF_IPV6 */
   BUF->len[0] = (uip_len >> 8);
   BUF->len[1] = (uip_len & 0xff);
#endif /* UIP_CONF_IPV6 */

   BUF->urgp[0] = BUF->urgp[1] = 0;
  
   /* Вычисление контрольной суммы TCP. */
   BUF->tcpchksum = 0;
   BUF->tcpchksum = ~(uip_tcpchksum());
  
ip_send_nolen:

#if UIP_CONF_IPV6
   BUF->vtc = 0x60;
   BUF->tcflow = 0x00;
   BUF->flow = 0x00;
#else /* UIP_CONF_IPV6 */
   BUF->vhl = 0x45;
   BUF->tos = 0;
   BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
   ++ipid;
   BUF->ipid[0] = ipid >> 8;
   BUF->ipid[1] = ipid & 0xff;
   /* Вычисление контрольной суммы IP. */
   BUF->ipchksum = 0;
   BUF->ipchksum = ~(uip_ipchksum());
   DEBUG_PRINTF("uip ip_send_nolen: chkecum 0x%04x\n", uip_ipchksum());
#endif /* UIP_CONF_IPV6 */
   
   UIP_STAT(++uip_stat.tcp.sent);
 send:
   DEBUG_PRINTF("Sending packet with length %d (%d)\n", uip_len,
                (BUF->len[0] << 8) | BUF->len[1]);
  
   UIP_STAT(++uip_stat.ip.sent);
   /* Возврат, чтобы дать возможность вызвавшему сделать реальную
      отправку данных. */
   uip_flags = 0;
   return;
 drop:
   uip_len = 0;
   uip_flags = 0;
   return;
}
/*---------------------------------------------------------------------------*/
u16_t
htons(u16_t val)
{
  return HTONS(val);
}
/*---------------------------------------------------------------------------*/
void
uip_send(const void *data, int len)
{
   if(len > 0) {
      uip_slen = len;
      if(data != uip_sappdata) {
         memcpy(uip_sappdata, (data), uip_slen);
      }
   }
}
/** @} */