Сетевой код.

void Net_Init()
{
  // запрашиваем версию Winsock 1.1
  WORD wVersionRequested = MAKEWORD(1,1);

  if (WSAStartup(wVersionRequested, &winsockdata))
  {
    printf("Winsock initialization failedn");
    return;
  }

  printf("Winsock initialized\n");
}

enum net_source_t
{
  NS_CLIENT = 0,
  NS_SERVER = 1
};

void Net_PrepareNetwork(bool multiplayer)
{
  static bool old_multiplayer = false;

  if (old_multiplayer == multiplayer)
    return;
  old_multiplayer = multiplayer;

  if (!multiplayer)
  {
    // удаляем сокеты в случае single game, нам в этом случае сокеты
    // вообще не нужны, общение ведется через память
    if (ip_sockets[NS_SERVER])
    {
      closesocket(ip_sockets[NS_SERVER]);
      ip_sockets[NS_SERVER] = 0;
    }
    if (ip_sockets[NS_CLIENT])
    {
      closesocket(ip_sockets[NS_CLIENT]);
      ip_sockets[NS_CLIENT] = 0;
    }
  }
  else
  {
    // open sockets
    Net_PrepareIP();
  }
}

// здесь,
// sv_serverport - внешняя переменная, содержит порт сервера
// sv_dedicated - переменная, показывающая, что мы создаем выделенный сервер
// cl_clientport - переменная, содержит порт клиента
// (в принципе, это значение не так уж и важно)
void Net_PrepareIP()
{
  int port;

  // open server socket
  if (!ip_sockets[NS_SERVER])
  {
    port = sv_serverport.GetValueInt();

    ip_sockets[NS_SERVER] = Net_CreateIPSocket("localhost", port);
    if (!ip_sockets[NS_SERVER] && sv_dedicated.GetValueInt())
      Error("Couldn't create dedicated server socket");
  }

  if (sv_dedicated.GetValueInt()) // no client socket for dedicated servers
    return;

  // open client socket
  if (!ip_sockets[NS_CLIENT])
  {
    port = cl_clientport.GetValueInt();

    ip_sockets[NS_CLIENT] = Net_CreateIPSocket("localhost", port);
    if (!ip_sockets[NS_CLIENT]) // port is busy
      ip_sockets[NS_CLIENT] = Net_CreateIPSocket("localhost", PORT_ANY);
  }
}

//  тип сетевого адреса
enum net_addr_type_t
{
  NA_LOOPBACK = 0,  // локальный клиент
  NA_BROADCAST = 1, // broadcast сообщение, посылка всем компьютерам в сети
  NA_IP = 2         // IP протокол
};

// сетевой адрес
struct netadr_t
{
  net_addr_type_t type;

  byte ip[4];  // IP адрес состоит из 4 байтов
  unsigned short port;
};

void Net_SendPacket(net_source_t src, int size, void *data, netadr_t *dest)
{
  sockaddr_in addr;

  // если локальный клиент, то вызываем специальный метод
  if ( dest->type == NA_LOOPBACK )
  {
    NET_SendLoopPacket (src, size, data, dest);
    return;
  }

  // проверка на корректность адреса и сокета
  if (dest->type == NA_BROADCAST || dest->type == NA_IP)
  {
    if (!ip_sockets[src])
    return;
  }
  else
    Error("Net_SendPacket: bad socket type");

  // переводим "наш" адрес в socket-compatible ;)
  NetadrToSockadr(dest, (sockaddr*)&addr);

  // пытаем послать данные
  int res = sendto( ip_sockets[src], (char*)data, size, 0, 
                    (sockaddr*)&addr, sizeof(addr));
  if (res == -1)
  {
    int error = WSAGetLastError();

    // вообще то при посылке через non-blocking socket такой ошибки не бывает...
    if (error == WSAEWOULDBLOCK)
    return;

    // некоторые PPP соединения не позволяют broadcast сообщения
    if (error == WSAEADDRNOTAVAIL && dest->type == NA_BROADCAST)
    return;

    // выделенный сервер может "проглотить" ошибку...
    if (sv_dedicated.GetValueInt())
    {
      printf("Net_SendPacket error\n");
    }
    else
    {
      // ошибка "адрес не существует" - это не очень страшно
      if (error == WSAEADDRNOTAVAIL)
        C_Printf("Net_SendPacket error: address not available\n");
      else
        Error("Net_SendPacket ERROR\n");
    }
  }
}

// класс buffer будет описан позже
bool Net_GetPacket(net_source_t sock, netadr_t *src, buffer *net_message)
{
  sockaddr from;

  // пытаем прочитать данные локального клиента
  if (NET_GetLoopPacket (sock, src, net_message))
    return true;

  // проверка корректности сокета
  if (!ip_sockets[sock])
    return false;

  // читаем пакет
  int fromlen = sizeof(from);
  int res = recvfrom( ip_sockets[sock], (char*)net_message->data,
                      net_message->maxsize, 0, &from, &fromlen );

  // переводим адрес отправителя в "наш" формат
  SockadrToNetadr(&from, src);

  if (res == -1)
  {
    int error = WSAGetLastError();

    // сокет пока занят,
    if (error == WSAEWOULDBLOCK)
    return false;

    // слишком большой пакет
    if (error == WSAEMSGSIZE || res == net_message->maxsize)
    {
      printf("Warning: Too big packet \n");
      return false;
    }

    // выделенный сервер "глотает" ошибку
    if (sv_dedicated.GetValueInt())
      printf("Net_GetPacket: Error reading packet\n");
    else
      Error("Net_GetPacket: Error reading packet");
  }

  net_message->cursize = res;
  return true;
}

#define  MAX_UDP_PACKET  2048

class buffer
{
  public:
    byte    *data;
    int     cursize; // buffer size
    int     maxsize; // buffer max size
    
    buffer()
    {
      maxsize = MAX_UDP_PACKET;
      cursize = 0;
      data = new byte[MAX_UDP_PACKET];
    }
    
    buffer(int size)
    {
      cursize = 0;
      maxsize = size;
      data = new byte[size];
    }

    ~buffer()
    {
      if (data)
      delete data;
    }
    // остальные методы будут описаны позже
};

// размер очереди, подбирается экспериментально - так, чтобы локальные
// пакеты не "терялись"
#define  MAX_LOOPBACK  4

typedef struct
{
  byte  data[MAX_UDP_PACKET];
  int datalen;
} loopmsg_t;

typedef struct
{
  loopmsg_t msgs[MAX_LOOPBACK];

  // указатель на начало очереди для send и на конец для get
  int get, send;
} loopback_t;

static loopback_t loopbacks[2]; // для сервера и клиента

 
void NetadrToSockadr (netadr_t *a, struct sockaddr *s)
{
  memset (s, 0, sizeof(*s));

  if (a->type == NA_BROADCAST)
  {
    ((struct sockaddr_in *)s)->sin_family = AF_INET;
    ((struct sockaddr_in *)s)->sin_port = a->port;
    ((struct sockaddr_in *)s)->sin_addr.s_addr = INADDR_BROADCAST;
  }
  else if (a->type == NA_IP)
  {
    ((struct sockaddr_in *)s)->sin_family = AF_INET;
    ((struct sockaddr_in *)s)->sin_addr.s_addr = *(int *)&a->ip;
    ((struct sockaddr_in *)s)->sin_port = a->port;
  }
}

void SockadrToNetadr (struct sockaddr *s, netadr_t *a)
{
  if (s->sa_family == AF_INET)
  {
    a->type = NA_IP;
    *(int *)&a->ip = ((struct sockaddr_in *)s)->sin_addr.s_addr;
    a->port = ((struct sockaddr_in *)s)->sin_port;
  }
}