libs/l_net/l_net_wins.c

   1 /*
   2 Copyright (C) 1999-2006 Id Software, Inc. and contributors.
   3 For a list of contributors, see the accompanying CONTRIBUTORS file.
   4
   5 This file is part of GtkRadiant.
   6
   7 GtkRadiant is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 GtkRadiant is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GtkRadiant; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20 */
  21
  22 //===========================================================================
  23 //
  24 // Name:         l_net_wins.c
  25 // Function:     WinSock
  26 // Programmer:   MrElusive
  27 // Last update:  -
  28 // Tab Size:     3
  29 // Notes:
  30 //===========================================================================
  31
  32 #include <windows.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include "l_net.h"
  37 #include "l_net_wins.h"
  38 //#include <winsock.h>
  39 //#include "mpdosock.h"
  40
  41 #define WinError WinPrint
  42
  43 #define qtrue   1
  44 #define qfalse  0
  45
  46 typedef struct tag_error_struct
  47 {
  48     int     errnum;
  49     LPSTR   errstr;
  50 } ERROR_STRUCT;
  51
  52 #define NET_NAMELEN                     64
  53
  54 char my_tcpip_address[NET_NAMELEN];
  55
  56 #define DEFAULTnet_hostport     26000
  57
  58 #define MAXHOSTNAMELEN          256
  59
  60 static int net_acceptsocket = -1;               // socket for fielding new connections
  61 static int net_controlsocket;
  62 static int net_hostport;                                // udp port number for acceptsocket
  63 static int net_broadcastsocket = 0;
  64 //static qboolean ifbcastinit = qfalse;
  65 static struct sockaddr_s broadcastaddr;
  66
  67 static unsigned long myAddr;
  68
  69 WSADATA winsockdata;
  70
  71 ERROR_STRUCT errlist[] = {
  72     {WSAEINTR,           "WSAEINTR - Interrupted"},
  73     {WSAEBADF,           "WSAEBADF - Bad file number"},
  74     {WSAEFAULT,          "WSAEFAULT - Bad address"},
  75     {WSAEINVAL,          "WSAEINVAL - Invalid argument"},
  76     {WSAEMFILE,          "WSAEMFILE - Too many open files"},
  77
  78 /*
  79 *    Windows Sockets definitions of regular Berkeley error constants
  80 */
  81
  82     {WSAEWOULDBLOCK,     "WSAEWOULDBLOCK - Socket marked as non-blocking"},
  83     {WSAEINPROGRESS,     "WSAEINPROGRESS - Blocking call in progress"},
  84     {WSAEALREADY,        "WSAEALREADY - Command already completed"},
  85     {WSAENOTSOCK,        "WSAENOTSOCK - Descriptor is not a socket"},
  86     {WSAEDESTADDRREQ,    "WSAEDESTADDRREQ - Destination address required"},
  87     {WSAEMSGSIZE,        "WSAEMSGSIZE - Data size too large"},
  88     {WSAEPROTOTYPE,      "WSAEPROTOTYPE - Protocol is of wrong type for this socket"},
  89     {WSAENOPROTOOPT,     "WSAENOPROTOOPT - Protocol option not supported for this socket type"},
  90     {WSAEPROTONOSUPPORT, "WSAEPROTONOSUPPORT - Protocol is not supported"},
  91     {WSAESOCKTNOSUPPORT, "WSAESOCKTNOSUPPORT - Socket type not supported by this address family"},
  92     {WSAEOPNOTSUPP,      "WSAEOPNOTSUPP - Option not supported"},
  93     {WSAEPFNOSUPPORT,    "WSAEPFNOSUPPORT - "},
  94     {WSAEAFNOSUPPORT,    "WSAEAFNOSUPPORT - Address family not supported by this protocol"},
  95     {WSAEADDRINUSE,      "WSAEADDRINUSE - Address is in use"},
  96     {WSAEADDRNOTAVAIL,   "WSAEADDRNOTAVAIL - Address not available from local machine"},
  97     {WSAENETDOWN,        "WSAENETDOWN - Network subsystem is down"},
  98     {WSAENETUNREACH,     "WSAENETUNREACH - Network cannot be reached"},
  99     {WSAENETRESET,       "WSAENETRESET - Connection has been dropped"},
 100     {WSAECONNABORTED,    "WSAECONNABORTED - Connection aborted"},
 101     {WSAECONNRESET,      "WSAECONNRESET - Connection reset"},
 102     {WSAENOBUFS,         "WSAENOBUFS - No buffer space available"},
 103     {WSAEISCONN,         "WSAEISCONN - Socket is already connected"},
 104     {WSAENOTCONN,        "WSAENOTCONN - Socket is not connected"},
 105     {WSAESHUTDOWN,       "WSAESHUTDOWN - Socket has been shut down"},
 106     {WSAETOOMANYREFS,    "WSAETOOMANYREFS - Too many references"},
 107     {WSAETIMEDOUT,       "WSAETIMEDOUT - Command timed out"},
 108     {WSAECONNREFUSED,    "WSAECONNREFUSED - Connection refused"},
 109     {WSAELOOP,           "WSAELOOP - "},
 110     {WSAENAMETOOLONG,    "WSAENAMETOOLONG - "},
 111     {WSAEHOSTDOWN,       "WSAEHOSTDOWN - Host is down"},
 112     {WSAEHOSTUNREACH,    "WSAEHOSTUNREACH - "},
 113     {WSAENOTEMPTY,       "WSAENOTEMPTY - "},
 114     {WSAEPROCLIM,        "WSAEPROCLIM - "},
 115     {WSAEUSERS,          "WSAEUSERS - "},
 116     {WSAEDQUOT,          "WSAEDQUOT - "},
 117     {WSAESTALE,          "WSAESTALE - "},
 118     {WSAEREMOTE,         "WSAEREMOTE - "},
 119
 120 /*
 121 *    Extended Windows Sockets error constant definitions
 122 */
 123
 124     {WSASYSNOTREADY,     "WSASYSNOTREADY - Network subsystem not ready"},
 125     {WSAVERNOTSUPPORTED, "WSAVERNOTSUPPORTED - Version not supported"},
 126     {WSANOTINITIALISED,  "WSANOTINITIALISED - WSAStartup() has not been successfully called"},
 127
 128 /*
 129 *    Other error constants.
 130 */
 131
 132     {WSAHOST_NOT_FOUND,  "WSAHOST_NOT_FOUND - Host not found"},
 133     {WSATRY_AGAIN,       "WSATRY_AGAIN - Host not found or SERVERFAIL"},
 134     {WSANO_RECOVERY,     "WSANO_RECOVERY - Non-recoverable error"},
 135     {WSANO_DATA,         "WSANO_DATA - (or WSANO_ADDRESS) - No data record of requested type"},
 136     {-1,                 NULL}
 137 };
 138
 139 #ifdef _DEBUG
 140 void WinPrint(char *str, ...);
 141 #else
 142 void WinPrint(char *str, ...);
 143 #endif
 144
 145 //===========================================================================
 146 //
 147 // Parameter:                           -
 148 // Returns:                                     -
 149 // Changes Globals:             -
 150 //===========================================================================
 151 char *WINS_ErrorMessage(int error)
 152 {
 153     int search = 0;
 154
 155     if (!error) return "No error occurred";
 156
 157          for (search = 0; errlist[search].errstr; search++)
 158          {
 159                 if (error == errlist[search].errnum)
 160                                 return errlist[search].errstr;
 161          } //end for
 162
 163     return "Unknown error";
 164 } //end of the function WINS_ErrorMessage
 165 //===========================================================================
 166 //
 167 // Parameter:                           -
 168 // Returns:                                     -
 169 // Changes Globals:             -
 170 //===========================================================================
 171 int WINS_Init(void)
 172 {
 173         int             i;
 174         struct hostent *local;
 175         char    buff[MAXHOSTNAMELEN];
 176         struct sockaddr_s addr;
 177         char    *p;
 178         int             r;
 179         WORD    wVersionRequested;
 180
 181         wVersionRequested = MAKEWORD(1, 1);
 182
 183         r = WSAStartup (wVersionRequested, &winsockdata);
 184
 185         if (r)
 186         {
 187                 WinPrint("Winsock initialization failed.\n");
 188                 return -1;
 189         }
 190
 191         /*
 192         i = COM_CheckParm ("-udpport");
 193         if (i == 0)*/
 194                 net_hostport = DEFAULTnet_hostport;
 195         /*
 196         else if (i < com_argc-1)
 197                 net_hostport = Q_atoi (com_argv[i+1]);
 198         else
 199                 Sys_Error ("WINS_Init: you must specify a number after -udpport");
 200         */
 201
 202         // determine my name & address
 203         gethostname(buff, MAXHOSTNAMELEN);
 204         local = gethostbyname(buff);
 205         myAddr = *(int *)local->h_addr_list[0];
 206
 207         // if the quake hostname isn't set, set it to the machine name
 208 //      if (Q_strcmp(hostname.string, "UNNAMED") == 0)
 209         {
 210                 // see if it's a text IP address (well, close enough)
 211                 for (p = buff; *p; p++)
 212                         if ((*p < '0' || *p > '9') && *p != '.')
 213                                 break;
 214
 215                 // if it is a real name, strip off the domain; we only want the host
 216                 if (*p)
 217                 {
 218                         for (i = 0; i < 15; i++)
 219                                 if (buff[i] == '.')
 220                                         break;
 221                         buff[i] = 0;
 222                 }
 223 //              Cvar_Set ("hostname", buff);
 224         }
 225
 226         if ((net_controlsocket = WINS_OpenSocket (0)) == -1)
 227                 WinError("WINS_Init: Unable to open control socket\n");
 228
 229         ((struct sockaddr_in *)&broadcastaddr)->sin_family = AF_INET;
 230         ((struct sockaddr_in *)&broadcastaddr)->sin_addr.s_addr = INADDR_BROADCAST;
 231         ((struct sockaddr_in *)&broadcastaddr)->sin_port = htons((u_short)net_hostport);
 232
 233         WINS_GetSocketAddr (net_controlsocket, &addr);
 234         strcpy(my_tcpip_address,  WINS_AddrToString (&addr));
 235         p = strrchr (my_tcpip_address, ':');
 236         if (p) *p = 0;
 237         WinPrint("Winsock Initialized\n");
 238
 239         return net_controlsocket;
 240 } //end of the function WINS_Init
 241 //===========================================================================
 242 //
 243 // Parameter:                           -
 244 // Returns:                                     -
 245 // Changes Globals:             -
 246 //===========================================================================
 247 char *WINS_MyAddress(void)
 248 {
 249         return my_tcpip_address;
 250 } //end of the function WINS_MyAddress
 251 //===========================================================================
 252 //
 253 // Parameter:                           -
 254 // Returns:                                     -
 255 // Changes Globals:             -
 256 //===========================================================================
 257 void WINS_Shutdown(void)
 258 {
 259         //WINS_Listen(0);
 260         WINS_CloseSocket(net_controlsocket);
 261         WSACleanup();
 262         //
 263         //WinPrint("Winsock Shutdown\n");
 264 } //end of the function WINS_Shutdown
 265 //===========================================================================
 266 //
 267 // Parameter:                           -
 268 // Returns:                                     -
 269 // Changes Globals:             -
 270 //===========================================================================
 271 /*
 272 void WINS_Listen(int state)
 273 {
 274         // enable listening
 275         if (state)
 276         {
 277                 if (net_acceptsocket != -1)
 278                         return;
 279                 if ((net_acceptsocket = WINS_OpenSocket (net_hostport)) == -1)
 280                         WinError ("WINS_Listen: Unable to open accept socket\n");
 281                 return;
 282         }
 283
 284         // disable listening
 285         if (net_acceptsocket == -1)
 286                 return;
 287         WINS_CloseSocket (net_acceptsocket);
 288         net_acceptsocket = -1;
 289 } //end of the function WINS_Listen*/
 290 //===========================================================================
 291 //
 292 // Parameter:                           -
 293 // Returns:                                     -
 294 // Changes Globals:             -
 295 //===========================================================================
 296 int WINS_OpenSocket(int port)
 297 {
 298         int newsocket;
 299         struct sockaddr_in address;
 300         u_long _true = 1;
 301
 302         if ((newsocket = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
 303         {
 304                 WinPrint("WINS_OpenSocket: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 305                 return -1;
 306         } //end if
 307
 308         if (ioctlsocket (newsocket, FIONBIO, &_true) == -1)
 309         {
 310                 WinPrint("WINS_OpenSocket: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 311                 closesocket(newsocket);
 312                 return -1;
 313         } //end if
 314
 315         memset((char *) &address, 0, sizeof(address));
 316         address.sin_family = AF_INET;
 317         address.sin_addr.s_addr = INADDR_ANY;
 318         address.sin_port = htons((u_short)port);
 319         if( bind (newsocket, (void *)&address, sizeof(address)) == -1)
 320         {
 321                 WinPrint("WINS_OpenSocket: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 322                 closesocket(newsocket);
 323                 return -1;
 324         } //end if
 325
 326         return newsocket;
 327 } //end of the function WINS_OpenSocket
 328 //===========================================================================
 329 //
 330 // Parameter:                           -
 331 // Returns:                                     -
 332 // Changes Globals:             -
 333 //===========================================================================
 334 int WINS_OpenReliableSocket(int port)
 335 {
 336         int newsocket;
 337         struct sockaddr_in address;
 338         BOOL _true = 0xFFFFFFFF;
 339
 340         //IPPROTO_TCP
 341         //
 342         if ((newsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
 343         {
 344                 WinPrint("WINS_OpenReliableSocket: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 345                 return -1;
 346         } //end if
 347
 348         memset((char *) &address, 0, sizeof(address));
 349         address.sin_family = AF_INET;
 350         address.sin_addr.s_addr = htonl(INADDR_ANY);
 351         address.sin_port = htons((u_short)port);
 352         if (bind(newsocket, (void *)&address, sizeof(address)) == -1)
 353         {
 354                 WinPrint("WINS_OpenReliableSocket: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 355                 closesocket(newsocket);
 356                 return -1;
 357         } //end if
 358
 359   //
 360         if (setsockopt(newsocket, IPPROTO_TCP, TCP_NODELAY, (void *) &_true, sizeof(int)) == SOCKET_ERROR)
 361         {
 362                 WinPrint("WINS_OpenReliableSocket: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 363                 WinPrint("setsockopt error\n");
 364         } //end if
 365
 366         return newsocket;
 367 } //end of the function WINS_OpenReliableSocket
 368 //===========================================================================
 369 //
 370 // Parameter:                           -
 371 // Returns:                                     -
 372 // Changes Globals:             -
 373 //===========================================================================
 374 int WINS_Listen(int socket)
 375 {
 376         u_long _true = 1;
 377
 378         if (ioctlsocket(socket, FIONBIO, &_true) == -1)
 379         {
 380                 WinPrint("WINS_Listen: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 381                 return -1;
 382         } //end if
 383         if (listen(socket, SOMAXCONN) == SOCKET_ERROR)
 384         {
 385                 WinPrint("WINS_Listen: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 386                 return -1;
 387         } //end if
 388         return 0;
 389 } //end of the function WINS_Listen
 390 //===========================================================================
 391 //
 392 // Parameter:                           -
 393 // Returns:                                     -
 394 // Changes Globals:             -
 395 //===========================================================================
 396 int WINS_Accept(int socket, struct sockaddr_s *addr)
 397 {
 398         int addrlen = sizeof (struct sockaddr_s);
 399         int newsocket;
 400         BOOL _true = 1;
 401
 402         newsocket = accept(socket, (struct sockaddr *)addr, &addrlen);
 403         if (newsocket == INVALID_SOCKET)
 404         {
 405                 if (WSAGetLastError() == WSAEWOULDBLOCK) return -1;
 406                 WinPrint("WINS_Accept: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 407                 return -1;
 408         } //end if
 409         //
 410         if (setsockopt(newsocket, IPPROTO_TCP, TCP_NODELAY, (void *) &_true, sizeof(int)) == SOCKET_ERROR)
 411         {
 412                 WinPrint("WINS_Accept: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 413                 WinPrint("setsockopt error\n");
 414         } //end if
 415         return newsocket;
 416 } //end of the function WINS_Accept
 417 //===========================================================================
 418 //
 419 // Parameter:                           -
 420 // Returns:                                     -
 421 // Changes Globals:             -
 422 //===========================================================================
 423 int WINS_CloseSocket(int socket)
 424 {
 425         /*
 426         if (socket == net_broadcastsocket)
 427                 net_broadcastsocket = 0;
 428         */
 429 //      shutdown(socket, SD_SEND);
 430
 431         if (closesocket(socket) == SOCKET_ERROR)
 432         {
 433                 WinPrint("WINS_CloseSocket: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 434                 return SOCKET_ERROR;
 435         } //end if
 436         return 0;
 437 } //end of the function WINS_CloseSocket
 438 //===========================================================================
 439 // this lets you type only as much of the net address as required, using
 440 // the local network components to fill in the rest
 441 //
 442 // Parameter:                           -
 443 // Returns:                                     -
 444 // Changes Globals:             -
 445 //===========================================================================
 446 static int PartialIPAddress (char *in, struct sockaddr_s *hostaddr)
 447 {
 448         char buff[256];
 449         char *b;
 450         int addr;
 451         int num;
 452         int mask;
 453
 454         buff[0] = '.';
 455         b = buff;
 456         strcpy(buff+1, in);
 457         if (buff[1] == '.') b++;
 458
 459         addr = 0;
 460         mask=-1;
 461         while (*b == '.')
 462         {
 463                 num = 0;
 464                 if (*++b < '0' || *b > '9') return -1;
 465                 while (!( *b < '0' || *b > '9'))
 466                   num = num*10 + *(b++) - '0';
 467                 mask<<=8;
 468                 addr = (addr<<8) + num;
 469         }
 470
 471         hostaddr->sa_family = AF_INET;
 472         ((struct sockaddr_in *)hostaddr)->sin_port = htons((u_short)net_hostport);
 473         ((struct sockaddr_in *)hostaddr)->sin_addr.s_addr = (myAddr & htonl(mask)) | htonl(addr);
 474
 475         return 0;
 476 } //end of the function PartialIPAddress
 477 //===========================================================================
 478 //
 479 // Parameter:                           -
 480 // Returns:                                     -
 481 // Changes Globals:             -
 482 //===========================================================================
 483 int WINS_Connect(int socket, struct sockaddr_s *addr)
 484 {
 485         int ret;
 486         u_long _true2 = 0xFFFFFFFF;
 487
 488         ret = connect(socket, (struct sockaddr *)addr, sizeof(struct sockaddr_s));
 489         if (ret == SOCKET_ERROR)
 490         {
 491                 WinPrint("WINS_Connect: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 492                 return -1;
 493         } //end if
 494         if (ioctlsocket(socket, FIONBIO, &_true2) == -1)
 495         {
 496                 WinPrint("WINS_Connect: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 497                 return -1;
 498         } //end if
 499         return 0;
 500 } //end of the function WINS_Connect
 501 //===========================================================================
 502 //
 503 // Parameter:                           -
 504 // Returns:                                     -
 505 // Changes Globals:             -
 506 //===========================================================================
 507 int WINS_CheckNewConnections(void)
 508 {
 509         char buf[4];
 510
 511         if (net_acceptsocket == -1)
 512                 return -1;
 513
 514         if (recvfrom(net_acceptsocket, buf, 4, MSG_PEEK, NULL, NULL) > 0)
 515                 return net_acceptsocket;
 516         return -1;
 517 } //end of the function WINS_CheckNewConnections
 518 //===========================================================================
 519 // returns the number of bytes read
 520 // 0 if no bytes available
 521 // -1 on failure
 522 //
 523 // Parameter:                           -
 524 // Returns:                                     -
 525 // Changes Globals:             -
 526 //===========================================================================
 527 int WINS_Read(int socket, byte *buf, int len, struct sockaddr_s *addr)
 528 {
 529         int addrlen = sizeof (struct sockaddr_s);
 530         int ret, errno;
 531
 532         if (addr)
 533         {
 534                 ret = recvfrom(socket, buf, len, 0, (struct sockaddr *)addr, &addrlen);
 535                 if (ret == -1)
 536                 {
 537                         errno = WSAGetLastError();
 538
 539                         if (errno == WSAEWOULDBLOCK || errno == WSAECONNREFUSED)
 540                                 return 0;
 541                 } //end if
 542         } //end if
 543         else
 544         {
 545                 ret = recv(socket, buf, len, 0);
 546                 if (ret == SOCKET_ERROR)
 547                 {
 548                         errno = WSAGetLastError();
 549
 550                         if (errno == WSAEWOULDBLOCK || errno == WSAECONNREFUSED)
 551                                 return 0;
 552                 } //end if
 553         } //end else
 554         if (ret == SOCKET_ERROR)
 555         {
 556                 WinPrint("WINS_Read: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 557         } //end if
 558         return ret;
 559 } //end of the function WINS_Read
 560 //===========================================================================
 561 //
 562 // Parameter:                           -
 563 // Returns:                                     -
 564 // Changes Globals:             -
 565 //===========================================================================
 566 int WINS_MakeSocketBroadcastCapable (int socket)
 567 {
 568         int     i = 1;
 569
 570         // make this socket broadcast capable
 571         if (setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) < 0)
 572                 return -1;
 573         net_broadcastsocket = socket;
 574
 575         return 0;
 576 } //end of the function WINS_MakeSocketBroadcastCapable
 577 //===========================================================================
 578 //
 579 // Parameter:                           -
 580 // Returns:                                     -
 581 // Changes Globals:             -
 582 //===========================================================================
 583 int WINS_Broadcast (int socket, byte *buf, int len)
 584 {
 585         int ret;
 586
 587         if (socket != net_broadcastsocket)
 588         {
 589                 if (net_broadcastsocket != 0)
 590                         WinError("Attempted to use multiple broadcasts sockets\n");
 591                 ret = WINS_MakeSocketBroadcastCapable (socket);
 592                 if (ret == -1)
 593                 {
 594                         WinPrint("Unable to make socket broadcast capable\n");
 595                         return ret;
 596                 }
 597         }
 598
 599         return WINS_Write (socket, buf, len, &broadcastaddr);
 600 } //end of the function WINS_Broadcast
 601 //===========================================================================
 602 // returns qtrue on success or qfalse on failure
 603 //
 604 // Parameter:                           -
 605 // Returns:                                     -
 606 // Changes Globals:             -
 607 //===========================================================================
 608 int WINS_Write(int socket, byte *buf, int len, struct sockaddr_s *addr)
 609 {
 610         int ret, written;
 611
 612         if (addr)
 613         {
 614                 written = 0;
 615                 while(written < len)
 616                 {
 617                         ret = sendto (socket, &buf[written], len-written, 0, (struct sockaddr *)addr, sizeof(struct sockaddr_s));
 618                         if (ret == SOCKET_ERROR)
 619                         {
 620                                 if (WSAGetLastError() != WSAEWOULDBLOCK)
 621                                         return qfalse;
 622                                 Sleep(1000);
 623                         } //end if
 624                         else
 625                         {
 626                                 written += ret;
 627                         }
 628                 }
 629         } //end if
 630         else
 631         {
 632                 written = 0;
 633                 while(written < len)
 634                 {
 635                         ret = send(socket, buf, len, 0);
 636                         if (ret == SOCKET_ERROR)
 637                         {
 638                                 if (WSAGetLastError() != WSAEWOULDBLOCK)
 639                                         return qfalse;
 640                                 Sleep(1000);
 641                         } //end if
 642                         else
 643                         {
 644                                 written += ret;
 645                         }
 646                 }
 647         } //end else
 648         if (ret == SOCKET_ERROR)
 649         {
 650                 WinPrint("WINS_Write: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 651         } //end if
 652         return (ret == len);
 653 } //end of the function WINS_Write
 654 //===========================================================================
 655 //
 656 // Parameter:                           -
 657 // Returns:                                     -
 658 // Changes Globals:             -
 659 //===========================================================================
 660 char *WINS_AddrToString (struct sockaddr_s *addr)
 661 {
 662         static char buffer[22];
 663         int haddr;
 664
 665         haddr = ntohl(((struct sockaddr_in *)addr)->sin_addr.s_addr);
 666         sprintf(buffer, "%d.%d.%d.%d:%d", (haddr >> 24) & 0xff, (haddr >> 16) & 0xff, (haddr >> 8) & 0xff, haddr & 0xff, ntohs(((struct sockaddr_in *)addr)->sin_port));
 667         return buffer;
 668 } //end of the function WINS_AddrToString
 669 //===========================================================================
 670 //
 671 // Parameter:                           -
 672 // Returns:                                     -
 673 // Changes Globals:             -
 674 //===========================================================================
 675 int WINS_StringToAddr(char *string, struct sockaddr_s *addr)
 676 {
 677         int ha1, ha2, ha3, ha4, hp;
 678         int ipaddr;
 679
 680         sscanf(string, "%d.%d.%d.%d:%d", &ha1, &ha2, &ha3, &ha4, &hp);
 681         ipaddr = (ha1 << 24) | (ha2 << 16) | (ha3 << 8) | ha4;
 682
 683         addr->sa_family = AF_INET;
 684         ((struct sockaddr_in *)addr)->sin_addr.s_addr = htonl(ipaddr);
 685         ((struct sockaddr_in *)addr)->sin_port = htons((u_short)hp);
 686         return 0;
 687 } //end of the function WINS_StringToAddr
 688 //===========================================================================
 689 //
 690 // Parameter:                           -
 691 // Returns:                                     -
 692 // Changes Globals:             -
 693 //===========================================================================
 694 int WINS_GetSocketAddr(int socket, struct sockaddr_s *addr)
 695 {
 696         int addrlen = sizeof(struct sockaddr_s);
 697         unsigned int a;
 698
 699         memset(addr, 0, sizeof(struct sockaddr_s));
 700         getsockname(socket, (struct sockaddr *)addr, &addrlen);
 701         a = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
 702         if (a == 0 || a == inet_addr("127.0.0.1"))
 703                 ((struct sockaddr_in *)addr)->sin_addr.s_addr = myAddr;
 704
 705         return 0;
 706 } //end of the function WINS_GetSocketAddr
 707 //===========================================================================
 708 //
 709 // Parameter:                           -
 710 // Returns:                                     -
 711 // Changes Globals:             -
 712 //===========================================================================
 713 int WINS_GetNameFromAddr (struct sockaddr_s *addr, char *name)
 714 {
 715         struct hostent *hostentry;
 716
 717         hostentry = gethostbyaddr ((char *)&((struct sockaddr_in *)addr)->sin_addr, sizeof(struct in_addr), AF_INET);
 718         if (hostentry)
 719         {
 720                 strncpy (name, (char *)hostentry->h_name, NET_NAMELEN - 1);
 721                 return 0;
 722         }
 723
 724         strcpy (name, WINS_AddrToString (addr));
 725         return 0;
 726 } //end of the function WINS_GetNameFromAddr
 727 //===========================================================================
 728 //
 729 // Parameter:                           -
 730 // Returns:                                     -
 731 // Changes Globals:             -
 732 //===========================================================================
 733 int WINS_GetAddrFromName(char *name, struct sockaddr_s *addr)
 734 {
 735         struct hostent *hostentry;
 736
 737         if (name[0] >= '0' && name[0] <= '9')
 738                 return PartialIPAddress (name, addr);
 739
 740         hostentry = gethostbyname (name);
 741         if (!hostentry)
 742                 return -1;
 743
 744         addr->sa_family = AF_INET;
 745         ((struct sockaddr_in *)addr)->sin_port = htons((u_short)net_hostport);
 746         ((struct sockaddr_in *)addr)->sin_addr.s_addr = *(int *)hostentry->h_addr_list[0];
 747
 748         return 0;
 749 } //end of the function WINS_GetAddrFromName
 750 //===========================================================================
 751 //
 752 // Parameter:                           -
 753 // Returns:                                     -
 754 // Changes Globals:             -
 755 //===========================================================================
 756 int WINS_AddrCompare (struct sockaddr_s *addr1, struct sockaddr_s *addr2)
 757 {
 758         if (addr1->sa_family != addr2->sa_family)
 759                 return -1;
 760
 761         if (((struct sockaddr_in *)addr1)->sin_addr.s_addr != ((struct sockaddr_in *)addr2)->sin_addr.s_addr)
 762                 return -1;
 763
 764         if (((struct sockaddr_in *)addr1)->sin_port != ((struct sockaddr_in *)addr2)->sin_port)
 765                 return 1;
 766
 767         return 0;
 768 } //end of the function WINS_AddrCompare
 769 //===========================================================================
 770 //
 771 // Parameter:                           -
 772 // Returns:                                     -
 773 // Changes Globals:             -
 774 //===========================================================================
 775 int WINS_GetSocketPort (struct sockaddr_s *addr)
 776 {
 777         return ntohs(((struct sockaddr_in *)addr)->sin_port);
 778 } //end of the function WINS_GetSocketPort
 779 //===========================================================================
 780 //
 781 // Parameter:                           -
 782 // Returns:                                     -
 783 // Changes Globals:             -
 784 //===========================================================================
 785 int WINS_SetSocketPort (struct sockaddr_s *addr, int port)
 786 {
 787         ((struct sockaddr_in *)addr)->sin_port = htons((u_short)port);
 788         return 0;
 789 } //end of the function WINS_SetSocketPort