libs/l_net/l_net_berkley.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:  TTimo: cross-platform version, l_net library
  28 // Tab Size:     2
  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
  39 #include <sys/types.h>
  40 #include <sys/socket.h>
  41 #include <sys/ioctl.h>
  42 #include <netinet/in.h>
  43 #include <netinet/tcp.h>
  44 #include <arpa/inet.h>
  45 #include <errno.h>
  46 #include <netdb.h>
  47 #include <unistd.h>
  48 #include <stdarg.h>
  49 #include <stdio.h>
  50 #define SOCKET_ERROR -1
  51 #define INVALID_SOCKET -1
  52
  53 #define WinError WinPrint
  54
  55 #define qtrue   1
  56 #define qfalse  0
  57
  58 #define ioctlsocket ioctl
  59 #define closesocket close
  60
  61 int WSAGetLastError()
  62 {
  63         return errno;
  64 }
  65
  66 /*
  67 typedef struct tag_error_struct
  68 {
  69     int     errnum;
  70     LPSTR   errstr;
  71 } ERROR_STRUCT;
  72 */
  73
  74 typedef struct tag_error_struct
  75 {
  76     int     errnum;
  77     const char *errstr;
  78 } ERROR_STRUCT;
  79
  80 #define NET_NAMELEN                     64
  81
  82 static char my_tcpip_address[NET_NAMELEN];
  83
  84 #define DEFAULTnet_hostport     26000
  85
  86 #define MAXHOSTNAMELEN          256
  87
  88 static int net_acceptsocket = -1;               // socket for fielding new connections
  89 static int net_controlsocket;
  90 static int net_hostport;                                // udp port number for acceptsocket
  91 static int net_broadcastsocket = 0;
  92 //static qboolean ifbcastinit = qfalse;
  93 //static struct sockaddr_s broadcastaddr;
  94 static struct sockaddr_s broadcastaddr;
  95
  96 static unsigned long myAddr;
  97
  98 ERROR_STRUCT errlist[] = {
  99   {EACCES,"EACCES - The address is protected, user is not root"},
 100   {EAGAIN,"EAGAIN - Operation on non-blocking socket that cannot return immediatly"},
 101   {EBADF, "EBADF - sockfd is not a valid descriptor"},
 102   {EFAULT, "EFAULT - The parameter is not in a writable part of the user address space"},
 103   {EINVAL,"EINVAL - The socket is already bound to an address"},
 104   {ENOBUFS,"ENOBUFS - not enough memory"},
 105   {ENOMEM, "ENOMEM - not enough memory"},
 106   {ENOTCONN, "ENOTCONN - not connected"},
 107   {ENOTSOCK,"ENOTSOCK - Argument is file descriptor not a socket"},
 108   {EOPNOTSUPP,"ENOTSUPP - The referenced socket is not of type SOCK_STREAM"},
 109   {EPERM, "EPERM - Firewall rules forbid connection"},
 110   {-1, NULL}
 111 };
 112
 113 //===========================================================================
 114 //
 115 // Parameter:                           -
 116 // Returns:                                     -
 117 // Changes Globals:             -
 118 //===========================================================================
 119 const char *WINS_ErrorMessage(int error)
 120 {
 121     int search = 0;
 122
 123     if (!error) return "No error occurred";
 124
 125          for (search = 0; errlist[search].errstr; search++)
 126          {
 127                 if (error == errlist[search].errnum)
 128                                 return errlist[search].errstr;
 129          } //end for
 130
 131     return "Unknown error";
 132 } //end of the function WINS_ErrorMessage
 133 //===========================================================================
 134 //
 135 // Parameter:                           -
 136 // Returns:                                     -
 137 // Changes Globals:             -
 138 //===========================================================================
 139 int WINS_Init(void)
 140 {
 141         int             i;
 142         struct hostent *local;
 143         char    buff[MAXHOSTNAMELEN];
 144         struct sockaddr_s addr;
 145         char    *p;
 146 /*
 147  linux doesn't have anything to initialize for the net
 148  "Windows .. built for the internet .. the internet .. built with unix"
 149  */
 150 #if 0
 151         WORD    wVersionRequested;
 152
 153         wVersionRequested = MAKEWORD(2, 2);
 154
 155         r = WSAStartup (wVersionRequested, &winsockdata);
 156
 157         if (r)
 158         {
 159                 WinPrint("Winsock initialization failed.\n");
 160                 return -1;
 161         }
 162 #endif
 163         /*
 164         i = COM_CheckParm ("-udpport");
 165         if (i == 0)*/
 166                 net_hostport = DEFAULTnet_hostport;
 167         /*
 168         else if (i < com_argc-1)
 169                 net_hostport = Q_atoi (com_argv[i+1]);
 170         else
 171                 Sys_Error ("WINS_Init: you must specify a number after -udpport");
 172         */
 173
 174         // determine my name & address
 175         gethostname(buff, MAXHOSTNAMELEN);
 176         local = gethostbyname(buff);
 177         myAddr = *(int *)local->h_addr_list[0];
 178
 179         // if the quake hostname isn't set, set it to the machine name
 180 //      if (Q_strcmp(hostname.string, "UNNAMED") == 0)
 181         {
 182                 // see if it's a text IP address (well, close enough)
 183                 for (p = buff; *p; p++)
 184                         if ((*p < '0' || *p > '9') && *p != '.')
 185                                 break;
 186
 187                 // if it is a real name, strip off the domain; we only want the host
 188                 if (*p)
 189                 {
 190                         for (i = 0; i < 15; i++)
 191                                 if (buff[i] == '.')
 192                                         break;
 193                         buff[i] = 0;
 194                 }
 195 //              Cvar_Set ("hostname", buff);
 196         }
 197
 198   //++timo WTF is that net_controlsocket? it's sole purpose is to retrieve the local IP?
 199         if ((net_controlsocket = WINS_OpenSocket (0)) == SOCKET_ERROR)
 200                 WinError("WINS_Init: Unable to open control socket\n");
 201
 202         ((struct sockaddr_in *)&broadcastaddr)->sin_family = AF_INET;
 203         ((struct sockaddr_in *)&broadcastaddr)->sin_addr.s_addr = INADDR_BROADCAST;
 204         ((struct sockaddr_in *)&broadcastaddr)->sin_port = htons((u_short)net_hostport);
 205
 206         WINS_GetSocketAddr (net_controlsocket, &addr);
 207         strcpy(my_tcpip_address,  WINS_AddrToString (&addr));
 208         p = strrchr (my_tcpip_address, ':');
 209         if (p) *p = 0;
 210         WinPrint("Winsock Initialized\n");
 211
 212         return net_controlsocket;
 213 } //end of the function WINS_Init
 214 //===========================================================================
 215 //
 216 // Parameter:                           -
 217 // Returns:                                     -
 218 // Changes Globals:             -
 219 //===========================================================================
 220 char *WINS_MyAddress(void)
 221 {
 222         return my_tcpip_address;
 223 } //end of the function WINS_MyAddress
 224 //===========================================================================
 225 //
 226 // Parameter:                           -
 227 // Returns:                                     -
 228 // Changes Globals:             -
 229 //===========================================================================
 230 void WINS_Shutdown(void)
 231 {
 232         //WINS_Listen(0);
 233         WINS_CloseSocket(net_controlsocket);
 234 //      WSACleanup();
 235         //
 236         //WinPrint("Winsock Shutdown\n");
 237 } //end of the function WINS_Shutdown
 238 //===========================================================================
 239 //
 240 // Parameter:                           -
 241 // Returns:                                     -
 242 // Changes Globals:             -
 243 //===========================================================================
 244 /*
 245 void WINS_Listen(int state)
 246 {
 247         // enable listening
 248         if (state)
 249         {
 250                 if (net_acceptsocket != -1)
 251                         return;
 252                 if ((net_acceptsocket = WINS_OpenSocket (net_hostport)) == -1)
 253                         WinError ("WINS_Listen: Unable to open accept socket\n");
 254                 return;
 255         }
 256
 257         // disable listening
 258         if (net_acceptsocket == -1)
 259                 return;
 260         WINS_CloseSocket (net_acceptsocket);
 261         net_acceptsocket = -1;
 262 } //end of the function WINS_Listen*/
 263 //===========================================================================
 264 //
 265 // Parameter:                           -
 266 // Returns:                                     -
 267 // Changes Globals:             -
 268 //===========================================================================
 269 int WINS_OpenSocket(int port)
 270 {
 271         int newsocket;
 272         struct sockaddr_in address;
 273         u_long _true = 1;
 274
 275         if ((newsocket = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == SOCKET_ERROR)
 276         {
 277                 WinPrint("WINS_OpenSocket: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 278                 return -1;
 279         } //end if
 280
 281         if (ioctlsocket (newsocket, FIONBIO, &_true) == SOCKET_ERROR)
 282         {
 283                 WinPrint("WINS_OpenSocket: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 284                 closesocket(newsocket);
 285                 return -1;
 286         } //end if
 287
 288         memset((char *) &address, 0, sizeof(address));
 289         address.sin_family = AF_INET;
 290         address.sin_addr.s_addr = INADDR_ANY;
 291         address.sin_port = htons((u_short)port);
 292         if( bind (newsocket, (void *)&address, sizeof(address)) == -1)
 293         {
 294                 WinPrint("WINS_OpenSocket: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 295                 closesocket(newsocket);
 296                 return -1;
 297         } //end if
 298
 299         return newsocket;
 300 } //end of the function WINS_OpenSocket
 301 //===========================================================================
 302 //
 303 // Parameter:                           -
 304 // Returns:                                     -
 305 // Changes Globals:             -
 306 //===========================================================================
 307 int WINS_OpenReliableSocket(int port)
 308 {
 309         int newsocket;
 310         struct sockaddr_in address;
 311         qboolean _true = 0xFFFFFFFF;
 312
 313         //IPPROTO_TCP
 314         //
 315         if ((newsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
 316         {
 317                 WinPrint("WINS_OpenReliableSocket: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 318                 return -1;
 319         } //end if
 320
 321         memset((char *) &address, 0, sizeof(address));
 322         address.sin_family = AF_INET;
 323         address.sin_addr.s_addr = htonl(INADDR_ANY);
 324         address.sin_port = htons((u_short)port);
 325         if (bind(newsocket, (void *)&address, sizeof(address)) == -1)
 326         {
 327                 WinPrint("WINS_OpenReliableSocket: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 328                 closesocket(newsocket);
 329                 return -1;
 330         } //end if
 331
 332   //
 333         if (setsockopt(newsocket, IPPROTO_TCP, TCP_NODELAY, (void *) &_true, sizeof(int)) == -1)
 334         {
 335                 WinPrint("WINS_OpenReliableSocket: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 336                 WinPrint("setsockopt error\n");
 337         } //end if
 338
 339         return newsocket;
 340 } //end of the function WINS_OpenReliableSocket
 341 //===========================================================================
 342 //
 343 // Parameter:                           -
 344 // Returns:                                     -
 345 // Changes Globals:             -
 346 //===========================================================================
 347 int WINS_Listen(int socket)
 348 {
 349         u_long _true = 1;
 350
 351         if (ioctlsocket(socket, FIONBIO, &_true) == -1)
 352         {
 353                 WinPrint("WINS_Listen: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 354                 return -1;
 355         } //end if
 356         if (listen(socket, SOMAXCONN) == SOCKET_ERROR)
 357         {
 358                 WinPrint("WINS_Listen: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 359                 return -1;
 360         } //end if
 361         return 0;
 362 } //end of the function WINS_Listen
 363 //===========================================================================
 364 //
 365 // Parameter:                           -
 366 // Returns:                                     -
 367 // Changes Globals:             -
 368 //===========================================================================
 369 int WINS_Accept(int socket, struct sockaddr_s *addr)
 370 {
 371         socklen_t addrlen = sizeof (struct sockaddr_s);
 372         int newsocket;
 373         qboolean _true = 1;
 374
 375         newsocket = accept(socket, (struct sockaddr *)addr, &addrlen);
 376         if (newsocket == INVALID_SOCKET)
 377         {
 378     if (errno == EAGAIN) return -1;
 379                 WinPrint("WINS_Accept: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 380                 return -1;
 381         } //end if
 382         //
 383         if (setsockopt(newsocket, IPPROTO_TCP, TCP_NODELAY, (void *) &_true, sizeof(int)) == SOCKET_ERROR)
 384         {
 385                 WinPrint("WINS_Accept: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 386                 WinPrint("setsockopt error\n");
 387         } //end if
 388         return newsocket;
 389 } //end of the function WINS_Accept
 390 //===========================================================================
 391 //
 392 // Parameter:                           -
 393 // Returns:                                     -
 394 // Changes Globals:             -
 395 //===========================================================================
 396 int WINS_CloseSocket(int socket)
 397 {
 398         /*
 399         if (socket == net_broadcastsocket)
 400                 net_broadcastsocket = 0;
 401         */
 402 //      shutdown(socket, SD_SEND);
 403
 404         if (closesocket(socket) == SOCKET_ERROR)
 405         {
 406                 WinPrint("WINS_CloseSocket: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 407                 return SOCKET_ERROR;
 408         } //end if
 409         return 0;
 410 } //end of the function WINS_CloseSocket
 411 //===========================================================================
 412 // this lets you type only as much of the net address as required, using
 413 // the local network components to fill in the rest
 414 //
 415 // Parameter:                           -
 416 // Returns:                                     -
 417 // Changes Globals:             -
 418 //===========================================================================
 419 static int PartialIPAddress (char *in, struct sockaddr_s *hostaddr)
 420 {
 421         char buff[256];
 422         char *b;
 423         int addr;
 424         int num;
 425         int mask;
 426
 427         buff[0] = '.';
 428         b = buff;
 429         strcpy(buff+1, in);
 430         if (buff[1] == '.') b++;
 431
 432         addr = 0;
 433         mask=-1;
 434         while (*b == '.')
 435         {
 436                 num = 0;
 437                 if (*++b < '0' || *b > '9') return -1;
 438                 while (!( *b < '0' || *b > '9'))
 439                   num = num*10 + *(b++) - '0';
 440                 mask<<=8;
 441                 addr = (addr<<8) + num;
 442         }
 443
 444         hostaddr->sa_family = AF_INET;
 445         ((struct sockaddr_in *)hostaddr)->sin_port = htons((u_short)net_hostport);
 446         ((struct sockaddr_in *)hostaddr)->sin_addr.s_addr = (myAddr & htonl(mask)) | htonl(addr);
 447
 448         return 0;
 449 } //end of the function PartialIPAddress
 450 //===========================================================================
 451 //
 452 // Parameter:                           -
 453 // Returns:                                     -
 454 // Changes Globals:             -
 455 //===========================================================================
 456 int WINS_Connect(int socket, struct sockaddr_s *addr)
 457 {
 458         int ret;
 459         u_long _true2 = 0xFFFFFFFF;
 460
 461         ret = connect(socket, (struct sockaddr *)addr, sizeof(struct sockaddr_s));
 462         if (ret == SOCKET_ERROR)
 463         {
 464                 WinPrint("WINS_Connect: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 465                 return -1;
 466         } //end if
 467         if (ioctlsocket(socket, FIONBIO, &_true2) == -1)
 468         {
 469                 WinPrint("WINS_Connect: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 470                 return -1;
 471         } //end if
 472         return 0;
 473 } //end of the function WINS_Connect
 474 //===========================================================================
 475 //
 476 // Parameter:                           -
 477 // Returns:                                     -
 478 // Changes Globals:             -
 479 //===========================================================================
 480 int WINS_CheckNewConnections(void)
 481 {
 482         char buf[4];
 483
 484         if (net_acceptsocket == -1)
 485                 return -1;
 486
 487         if (recvfrom(net_acceptsocket, buf, 4, MSG_PEEK, NULL, NULL) > 0)
 488                 return net_acceptsocket;
 489         return -1;
 490 } //end of the function WINS_CheckNewConnections
 491 //===========================================================================
 492 // returns the number of bytes read
 493 // 0 if no bytes available
 494 // -1 on failure
 495 //
 496 // Parameter:                           -
 497 // Returns:                                     -
 498 // Changes Globals:             -
 499 //===========================================================================
 500 int WINS_Read(int socket, byte *buf, int len, struct sockaddr_s *addr)
 501 {
 502         socklen_t addrlen = sizeof (struct sockaddr_s);
 503         int ret;
 504
 505         if (addr)
 506         {
 507                 ret = recvfrom(socket, buf, len, 0, (struct sockaddr *)addr, &addrlen);
 508                 if (ret == -1)
 509                 {
 510 //                      errno = WSAGetLastError();
 511
 512                         if (errno == EAGAIN || errno == ENOTCONN)
 513                                 return 0;
 514                 } //end if
 515         } //end if
 516         else
 517         {
 518                 ret = recv(socket, buf, len, 0);
 519     // if there's no data on the socket ret == -1 and errno == EAGAIN
 520     // MSDN states that if ret == 0 the socket has been closed
 521     // man recv doesn't say anything
 522     if (ret == 0)
 523       return -1;
 524                 if (ret == SOCKET_ERROR)
 525                 {
 526 //                      errno = WSAGetLastError();
 527
 528                         if (errno == EAGAIN || errno == ENOTCONN)
 529                                 return 0;
 530                 } //end if
 531         } //end else
 532         if (ret == SOCKET_ERROR)
 533         {
 534                 WinPrint("WINS_Read: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 535         } //end if
 536         return ret;
 537 } //end of the function WINS_Read
 538 //===========================================================================
 539 //
 540 // Parameter:                           -
 541 // Returns:                                     -
 542 // Changes Globals:             -
 543 //===========================================================================
 544 int WINS_MakeSocketBroadcastCapable (int socket)
 545 {
 546         int     i = 1;
 547
 548         // make this socket broadcast capable
 549         if (setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) < 0)
 550                 return -1;
 551         net_broadcastsocket = socket;
 552
 553         return 0;
 554 } //end of the function WINS_MakeSocketBroadcastCapable
 555 //===========================================================================
 556 //
 557 // Parameter:                           -
 558 // Returns:                                     -
 559 // Changes Globals:             -
 560 //===========================================================================
 561 int WINS_Broadcast (int socket, byte *buf, int len)
 562 {
 563         int ret;
 564
 565         if (socket != net_broadcastsocket)
 566         {
 567                 if (net_broadcastsocket != 0)
 568                         WinError("Attempted to use multiple broadcasts sockets\n");
 569                 ret = WINS_MakeSocketBroadcastCapable (socket);
 570                 if (ret == -1)
 571                 {
 572                         WinPrint("Unable to make socket broadcast capable\n");
 573                         return ret;
 574                 }
 575         }
 576
 577         return WINS_Write (socket, buf, len, &broadcastaddr);
 578 } //end of the function WINS_Broadcast
 579 //===========================================================================
 580 // returns qtrue on success or qfalse on failure
 581 //
 582 // Parameter:                           -
 583 // Returns:                                     -
 584 // Changes Globals:             -
 585 //===========================================================================
 586 int WINS_Write(int socket, byte *buf, int len, struct sockaddr_s *addr)
 587 {
 588         int ret, written;
 589         ret = 0;
 590
 591         if (addr)
 592         {
 593                 written = 0;
 594                 while(written < len)
 595                 {
 596                         ret = sendto (socket, &buf[written], len-written, 0, (struct sockaddr *)addr, sizeof(struct sockaddr_s));
 597                         if (ret == SOCKET_ERROR)
 598                         {
 599                                 if (WSAGetLastError() != EAGAIN)
 600                                         return qfalse;
 601                                         //++timo FIXME: what is this used for?
 602 //                              Sleep(1000);
 603                         } //end if
 604                         else
 605                         {
 606                                 written += ret;
 607                         }
 608                 }
 609         } //end if
 610         else
 611         {
 612                 written = 0;
 613                 while(written < len)
 614                 {
 615                         ret = send(socket, buf, len, 0);
 616                         if (ret == SOCKET_ERROR)
 617                         {
 618                                 if (WSAGetLastError() != EAGAIN)
 619                                         return qfalse;
 620                                         //++timo FIXME: what is this used for?
 621 //                              Sleep(1000);
 622                         } //end if
 623                         else
 624                         {
 625                                 written += ret;
 626                         }
 627                 }
 628         } //end else
 629         if (ret == SOCKET_ERROR)
 630         {
 631                 WinPrint("WINS_Write: %s\n", WINS_ErrorMessage(WSAGetLastError()));
 632         } //end if
 633         return (ret == len);
 634 } //end of the function WINS_Write
 635 //===========================================================================
 636 //
 637 // Parameter:                           -
 638 // Returns:                                     -
 639 // Changes Globals:             -
 640 //===========================================================================
 641 char *WINS_AddrToString (struct sockaddr_s *addr)
 642 {
 643         static char buffer[22];
 644         int haddr;
 645
 646         haddr = ntohl(((struct sockaddr_in *)addr)->sin_addr.s_addr);
 647         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));
 648         return buffer;
 649 } //end of the function WINS_AddrToString
 650 //===========================================================================
 651 //
 652 // Parameter:                           -
 653 // Returns:                                     -
 654 // Changes Globals:             -
 655 //===========================================================================
 656 int WINS_StringToAddr(char *string, struct sockaddr_s *addr)
 657 {
 658         int ha1, ha2, ha3, ha4, hp;
 659         int ipaddr;
 660
 661         sscanf(string, "%d.%d.%d.%d:%d", &ha1, &ha2, &ha3, &ha4, &hp);
 662         ipaddr = (ha1 << 24) | (ha2 << 16) | (ha3 << 8) | ha4;
 663
 664         addr->sa_family = AF_INET;
 665         ((struct sockaddr_in *)addr)->sin_addr.s_addr = htonl(ipaddr);
 666         ((struct sockaddr_in *)addr)->sin_port = htons((u_short)hp);
 667         return 0;
 668 } //end of the function WINS_StringToAddr
 669 //===========================================================================
 670 //
 671 // Parameter:                           -
 672 // Returns:                                     -
 673 // Changes Globals:             -
 674 //===========================================================================
 675 int WINS_GetSocketAddr(int socket, struct sockaddr_s *addr)
 676 {
 677         socklen_t addrlen = sizeof(struct sockaddr_s);
 678         unsigned int a;
 679
 680         memset(addr, 0, sizeof(struct sockaddr_s));
 681         getsockname(socket, (struct sockaddr *)addr, &addrlen);
 682         a = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
 683         if (a == 0 || a == inet_addr("127.0.0.1"))
 684                 ((struct sockaddr_in *)addr)->sin_addr.s_addr = myAddr;
 685
 686         return 0;
 687 } //end of the function WINS_GetSocketAddr
 688 //===========================================================================
 689 //
 690 // Parameter:                           -
 691 // Returns:                                     -
 692 // Changes Globals:             -
 693 //===========================================================================
 694 int WINS_GetNameFromAddr (struct sockaddr_s *addr, char *name)
 695 {
 696         struct hostent *hostentry;
 697
 698         hostentry = gethostbyaddr ((char *)&((struct sockaddr_in *)addr)->sin_addr, sizeof(struct in_addr), AF_INET);
 699         if (hostentry)
 700         {
 701                 strncpy (name, (char *)hostentry->h_name, NET_NAMELEN - 1);
 702                 return 0;
 703         }
 704
 705         strcpy (name, WINS_AddrToString (addr));
 706         return 0;
 707 } //end of the function WINS_GetNameFromAddr
 708 //===========================================================================
 709 //
 710 // Parameter:                           -
 711 // Returns:                                     -
 712 // Changes Globals:             -
 713 //===========================================================================
 714 int WINS_GetAddrFromName(char *name, struct sockaddr_s *addr)
 715 {
 716         struct hostent *hostentry;
 717
 718         if (name[0] >= '0' && name[0] <= '9')
 719                 return PartialIPAddress (name, addr);
 720
 721         hostentry = gethostbyname (name);
 722         if (!hostentry)
 723                 return -1;
 724
 725         addr->sa_family = AF_INET;
 726         ((struct sockaddr_in *)addr)->sin_port = htons((u_short)net_hostport);
 727         ((struct sockaddr_in *)addr)->sin_addr.s_addr = *(int *)hostentry->h_addr_list[0];
 728
 729         return 0;
 730 } //end of the function WINS_GetAddrFromName
 731 //===========================================================================
 732 //
 733 // Parameter:                           -
 734 // Returns:                                     -
 735 // Changes Globals:             -
 736 //===========================================================================
 737 int WINS_AddrCompare (struct sockaddr_s *addr1, struct sockaddr_s *addr2)
 738 {
 739         if (addr1->sa_family != addr2->sa_family)
 740                 return -1;
 741
 742         if (((struct sockaddr_in *)addr1)->sin_addr.s_addr != ((struct sockaddr_in *)addr2)->sin_addr.s_addr)
 743                 return -1;
 744
 745         if (((struct sockaddr_in *)addr1)->sin_port != ((struct sockaddr_in *)addr2)->sin_port)
 746                 return 1;
 747
 748         return 0;
 749 } //end of the function WINS_AddrCompare
 750 //===========================================================================
 751 //
 752 // Parameter:                           -
 753 // Returns:                                     -
 754 // Changes Globals:             -
 755 //===========================================================================
 756 int WINS_GetSocketPort (struct sockaddr_s *addr)
 757 {
 758         return ntohs(((struct sockaddr_in *)addr)->sin_port);
 759 } //end of the function WINS_GetSocketPort
 760 //===========================================================================
 761 //
 762 // Parameter:                           -
 763 // Returns:                                     -
 764 // Changes Globals:             -
 765 //===========================================================================
 766 int WINS_SetSocketPort (struct sockaddr_s *addr, int port)
 767 {
 768         ((struct sockaddr_in *)addr)->sin_port = htons((u_short)port);
 769         return 0;
 770 } //end of the function WINS_SetSocketPort