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