net_main.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20 // net_main.c
  21
  22 #include "quakedef.h"
  23 #include "net_vcr.h"
  24
  25 qsocket_t       *net_activeSockets = NULL;
  26 qsocket_t       *net_freeSockets = NULL;
  27 int                     net_numsockets = 0;
  28
  29 qboolean        serialAvailable = false;
  30 qboolean        ipxAvailable = false;
  31 qboolean        tcpipAvailable = false;
  32 qboolean        tcpipAdhoc = false;
  33
  34 int                     net_hostport;
  35 int                     DEFAULTnet_hostport = 26000;
  36
  37 char            my_ipx_address[NET_NAMELEN];
  38 char            my_tcpip_address[NET_NAMELEN];
  39
  40 void (*GetComPortConfig) (int portNumber, int *port, int *irq, int *baud, qboolean *useModem);
  41 void (*SetComPortConfig) (int portNumber, int port, int irq, int baud, qboolean useModem);
  42 void (*GetModemConfig) (int portNumber, char *dialType, char *clear, char *init, char *hangup);
  43 void (*SetModemConfig) (int portNumber, char *dialType, char *clear, char *init, char *hangup);
  44
  45 static qboolean listening = false;
  46
  47 qboolean        slistInProgress = false;
  48 qboolean        slistSilent = false;
  49 qboolean        slistLocal = true;
  50 static double   slistStartTime;
  51 static int              slistLastShown;
  52
  53 static void Slist_Send(void);
  54 static void Slist_Poll(void);
  55 PollProcedure   slistSendProcedure = {NULL, 0.0, Slist_Send};
  56 PollProcedure   slistPollProcedure = {NULL, 0.0, Slist_Poll};
  57
  58
  59 sizebuf_t               net_message;
  60 int                             net_activeconnections = 0;
  61
  62 int messagesSent = 0;
  63 int messagesReceived = 0;
  64 int unreliableMessagesSent = 0;
  65 int unreliableMessagesReceived = 0;
  66
  67 cvar_t  net_messagetimeout = {"net_messagetimeout","300"};
  68 cvar_t  hostname = {"hostname", "Unnamed Server"};
  69
  70 qboolean        configRestored = false;
  71 cvar_t  config_com_port = {"_config_com_port", "0x3f8", true};
  72 cvar_t  config_com_irq = {"_config_com_irq", "4", true};
  73 cvar_t  config_com_baud = {"_config_com_baud", "57600", true};
  74 cvar_t  config_com_modem = {"_config_com_modem", "1", true};
  75 cvar_t  config_modem_dialtype = {"_config_modem_dialtype", "T", true};
  76 cvar_t  config_modem_clear = {"_config_modem_clear", "ATZ", true};
  77 cvar_t  config_modem_init = {"_config_modem_init", "", true};
  78 cvar_t  config_modem_hangup = {"_config_modem_hangup", "AT H", true};
  79
  80 #ifdef IDGODS
  81 cvar_t  idgods = {"idgods", "0"};
  82 #endif
  83
  84 int     vcrFile = -1;
  85 qboolean recording = false;
  86
  87 // these two macros are to make the code more readable
  88 #define sfunc   net_drivers[sock->driver]
  89 #define dfunc   net_drivers[net_driverlevel]
  90
  91 int     net_driverlevel;
  92
  93
  94 double                  net_time;
  95
  96 double SetNetTime(void)
  97 {
  98         net_time = Sys_FloatTime();
  99         return net_time;
 100 }
 101
 102
 103 /*
 104 ===================
 105 NET_NewQSocket
 106
 107 Called by drivers when a new communications endpoint is required
 108 The sequence and buffer fields will be filled in properly
 109 ===================
 110 */
 111 qsocket_t *NET_NewQSocket (void)
 112 {
 113         qsocket_t       *sock;
 114
 115         if (net_freeSockets == NULL)
 116                 return NULL;
 117
 118         if (net_activeconnections >= svs.maxclients)
 119                 return NULL;
 120
 121         // get one from free list
 122         sock = net_freeSockets;
 123         net_freeSockets = sock->next;
 124
 125         // add it to active list
 126         sock->next = net_activeSockets;
 127         net_activeSockets = sock;
 128
 129         sock->disconnected = false;
 130         sock->connecttime = net_time;
 131         Q_strcpy (sock->address,"UNSET ADDRESS");
 132         sock->driver = net_driverlevel;
 133         sock->socket = 0;
 134         sock->driverdata = NULL;
 135         sock->canSend = true;
 136         sock->sendNext = false;
 137         sock->lastMessageTime = net_time;
 138         sock->ackSequence = 0;
 139         sock->sendSequence = 0;
 140         sock->unreliableSendSequence = 0;
 141         sock->sendMessageLength = 0;
 142         sock->receiveSequence = 0;
 143         sock->unreliableReceiveSequence = 0;
 144         sock->receiveMessageLength = 0;
 145
 146         return sock;
 147 }
 148
 149
 150 void NET_FreeQSocket(qsocket_t *sock)
 151 {
 152         qsocket_t       *s;
 153
 154         // remove it from active list
 155         if (sock == net_activeSockets)
 156                 net_activeSockets = net_activeSockets->next;
 157         else
 158         {
 159                 for (s = net_activeSockets; s; s = s->next)
 160                         if (s->next == sock)
 161                         {
 162                                 s->next = sock->next;
 163                                 break;
 164                         }
 165                 if (!s)
 166                         Sys_Error ("NET_FreeQSocket: not active\n");
 167         }
 168
 169         // add it to free list
 170         sock->next = net_freeSockets;
 171         net_freeSockets = sock;
 172         sock->disconnected = true;
 173 }
 174
 175
 176 static void NET_Listen_f (void)
 177 {
 178         if (Cmd_Argc () != 2)
 179         {
 180                 Con_Printf ("\"listen\" is \"%u\"\n", listening ? 1 : 0);
 181                 return;
 182         }
 183
 184         listening = Q_atoi(Cmd_Argv(1)) ? true : false;
 185
 186         for (net_driverlevel=0 ; net_driverlevel<net_numdrivers; net_driverlevel++)
 187         {
 188                 if (net_drivers[net_driverlevel].initialized == false)
 189                         continue;
 190                 dfunc.Listen (listening);
 191         }
 192 }
 193
 194
 195 static void MaxPlayers_f (void)
 196 {
 197         int     n;
 198
 199         if (Cmd_Argc () != 2)
 200         {
 201                 Con_Printf ("\"maxplayers\" is \"%u\"\n", svs.maxclients);
 202                 return;
 203         }
 204
 205         if (sv.active)
 206         {
 207                 Con_Printf ("maxplayers can not be changed while a server is running.\n");
 208                 return;
 209         }
 210
 211         n = Q_atoi(Cmd_Argv(1));
 212         if (n < 1)
 213                 n = 1;
 214         if (n > svs.maxclientslimit)
 215         {
 216                 n = svs.maxclientslimit;
 217                 Con_Printf ("\"maxplayers\" set to \"%u\"\n", n);
 218         }
 219
 220         if ((n == 1) && listening)
 221                 Cbuf_AddText ("listen 0\n");
 222
 223         if ((n > 1) && (!listening))
 224                 Cbuf_AddText ("listen 1\n");
 225
 226         svs.maxclients = n;
 227         if (n == 1)
 228         {
 229                 Cvar_Set ("deathmatch", "0");
 230                 Cvar_Set ("coop", "0");
 231         }
 232         else
 233         {
 234                 if (coop.value)
 235                         Cvar_Set ("deathmatch", "0");
 236                 else
 237         {
 238             if (deathmatch.value > 1)
 239                 Cvar_SetValue ("deathmatch", deathmatch.value);
 240             else
 241                 Cvar_Set ("deathmatch", "1");
 242         }
 243         }
 244 }
 245
 246
 247 static void NET_Port_f (void)
 248 {
 249         int     n;
 250
 251         if (Cmd_Argc () != 2)
 252         {
 253                 Con_Printf ("\"port\" is \"%u\"\n", net_hostport);
 254                 return;
 255         }
 256
 257         n = Q_atoi(Cmd_Argv(1));
 258         if (n < 1 || n > 65534)
 259         {
 260                 Con_Printf ("Bad value, must be between 1 and 65534\n");
 261                 return;
 262         }
 263
 264         DEFAULTnet_hostport = n;
 265         net_hostport = n;
 266
 267         if (listening)
 268         {
 269                 // force a change to the new port
 270                 Cbuf_AddText ("listen 0\n");
 271                 Cbuf_AddText ("listen 1\n");
 272         }
 273 }
 274
 275
 276 static void PrintSlistHeader(void)
 277 {
 278         Con_Printf("Server          Map             Users\n");
 279         Con_Printf("--------------- --------------- -----\n");
 280         slistLastShown = 0;
 281 }
 282
 283
 284 static void PrintSlist(void)
 285 {
 286         int n;
 287
 288         for (n = slistLastShown; n < hostCacheCount; n++)
 289         {
 290                 if (hostcache[n].maxusers)
 291                         Con_Printf("%-15.15s %-15.15s %2u/%2u\n", hostcache[n].name, hostcache[n].map, hostcache[n].users, hostcache[n].maxusers);
 292                 else
 293                         Con_Printf("%-15.15s %-15.15s\n", hostcache[n].name, hostcache[n].map);
 294         }
 295         slistLastShown = n;
 296 }
 297
 298
 299 static void PrintSlistTrailer(void)
 300 {
 301         if (hostCacheCount)
 302                 Con_Printf("== end list ==\n\n");
 303         else
 304                 Con_Printf("No Quake servers found.\n\n");
 305 }
 306
 307
 308 void NET_Slist_f (void)
 309 {
 310         if (slistInProgress)
 311                 return;
 312
 313         if (! slistSilent)
 314         {
 315         if (kurok)
 316                     Con_Printf("Looking for Kurok servers...\n");
 317                 else
 318                     Con_Printf("Looking for Quake servers...\n");
 319                 PrintSlistHeader();
 320         }
 321
 322         slistInProgress = true;
 323         slistStartTime = Sys_FloatTime();
 324
 325         SchedulePollProcedure(&slistSendProcedure, 0.0);
 326         SchedulePollProcedure(&slistPollProcedure, 0.1);
 327
 328         hostCacheCount = 0;
 329 }
 330
 331
 332 static void Slist_Send(void)
 333 {
 334         for (net_driverlevel=0; net_driverlevel < net_numdrivers; net_driverlevel++)
 335         {
 336                 if (!slistLocal && net_driverlevel == 0)
 337                         continue;
 338                 if (net_drivers[net_driverlevel].initialized == false)
 339                         continue;
 340                 dfunc.SearchForHosts (true);
 341         }
 342
 343         if ((Sys_FloatTime() - slistStartTime) < 0.5)
 344                 SchedulePollProcedure(&slistSendProcedure, 0.75);
 345 }
 346
 347
 348 static void Slist_Poll(void)
 349 {
 350         for (net_driverlevel=0; net_driverlevel < net_numdrivers; net_driverlevel++)
 351         {
 352                 if (!slistLocal && net_driverlevel == 0)
 353                         continue;
 354                 if (net_drivers[net_driverlevel].initialized == false)
 355                         continue;
 356                 dfunc.SearchForHosts (false);
 357         }
 358
 359         if (! slistSilent)
 360                 PrintSlist();
 361
 362         if ((Sys_FloatTime() - slistStartTime) < 1.5)
 363         {
 364                 SchedulePollProcedure(&slistPollProcedure, 0.1);
 365                 return;
 366         }
 367
 368         if (! slistSilent)
 369                 PrintSlistTrailer();
 370         slistInProgress = false;
 371         slistSilent = false;
 372         slistLocal = true;
 373 }
 374
 375
 376 /*
 377 ===================
 378 NET_Connect
 379 ===================
 380 */
 381
 382 int hostCacheCount = 0;
 383 hostcache_t hostcache[HOSTCACHESIZE];
 384
 385 qsocket_t *NET_Connect (char *host)
 386 {
 387         qsocket_t               *ret;
 388         int                             n;
 389         int                             numdrivers = net_numdrivers;
 390
 391         SetNetTime();
 392
 393         if (host && *host == 0)
 394                 host = NULL;
 395
 396         if (host)
 397         {
 398                 if (Q_strcasecmp (host, "local") == 0)
 399                 {
 400                         numdrivers = 1;
 401                         goto JustDoIt;
 402                 }
 403
 404                 if (hostCacheCount)
 405                 {
 406                         for (n = 0; n < hostCacheCount; n++)
 407                                 if (Q_strcasecmp (host, hostcache[n].name) == 0)
 408                                 {
 409                                         host = hostcache[n].cname;
 410                                         break;
 411                                 }
 412                         if (n < hostCacheCount)
 413                                 goto JustDoIt;
 414                 }
 415         }
 416
 417         slistSilent = host ? true : false;
 418         NET_Slist_f ();
 419
 420         while(slistInProgress)
 421                 NET_Poll();
 422
 423         if (host == NULL)
 424         {
 425                 if (hostCacheCount != 1)
 426                         return NULL;
 427                 host = hostcache[0].cname;
 428                 Con_Printf("Connecting to...\n%s @ %s\n\n", hostcache[0].name, host);
 429         }
 430
 431         if (hostCacheCount)
 432                 for (n = 0; n < hostCacheCount; n++)
 433                         if (Q_strcasecmp (host, hostcache[n].name) == 0)
 434                         {
 435                                 host = hostcache[n].cname;
 436                                 break;
 437                         }
 438
 439 JustDoIt:
 440         for (net_driverlevel=0 ; net_driverlevel<numdrivers; net_driverlevel++)
 441         {
 442                 if (net_drivers[net_driverlevel].initialized == false)
 443                         continue;
 444                 ret = dfunc.Connect (host);
 445                 if (ret)
 446                         return ret;
 447         }
 448
 449         if (host)
 450         {
 451                 Con_Printf("\n");
 452                 PrintSlistHeader();
 453                 PrintSlist();
 454                 PrintSlistTrailer();
 455         }
 456
 457         return NULL;
 458 }
 459
 460
 461 /*
 462 ===================
 463 NET_CheckNewConnections
 464 ===================
 465 */
 466
 467 struct
 468 {
 469         double  time;
 470         int             op;
 471         long    session;
 472 } vcrConnect;
 473
 474 qsocket_t *NET_CheckNewConnections (void)
 475 {
 476         qsocket_t       *ret;
 477
 478         SetNetTime();
 479
 480         for (net_driverlevel=0 ; net_driverlevel<net_numdrivers; net_driverlevel++)
 481         {
 482                 if (net_drivers[net_driverlevel].initialized == false)
 483                         continue;
 484                 if (net_driverlevel && listening == false)
 485                         continue;
 486                 ret = dfunc.CheckNewConnections ();
 487                 if (ret)
 488                 {
 489                         if (recording)
 490                         {
 491                                 vcrConnect.time = host_time;
 492                                 vcrConnect.op = VCR_OP_CONNECT;
 493                                 vcrConnect.session = (long)ret;
 494                                 Sys_FileWrite (vcrFile, &vcrConnect, sizeof(vcrConnect));
 495                                 Sys_FileWrite (vcrFile, ret->address, NET_NAMELEN);
 496                         }
 497                         return ret;
 498                 }
 499         }
 500
 501         if (recording)
 502         {
 503                 vcrConnect.time = host_time;
 504                 vcrConnect.op = VCR_OP_CONNECT;
 505                 vcrConnect.session = 0;
 506                 Sys_FileWrite (vcrFile, &vcrConnect, sizeof(vcrConnect));
 507         }
 508
 509         return NULL;
 510 }
 511
 512 /*
 513 ===================
 514 NET_Close
 515 ===================
 516 */
 517 void NET_Close (qsocket_t *sock)
 518 {
 519         if (!sock)
 520                 return;
 521
 522         if (sock->disconnected)
 523                 return;
 524
 525         SetNetTime();
 526
 527         // call the driver_Close function
 528         sfunc.Close (sock);
 529
 530         NET_FreeQSocket(sock);
 531 }
 532
 533
 534 /*
 535 =================
 536 NET_GetMessage
 537
 538 If there is a complete message, return it in net_message
 539
 540 returns 0 if no data is waiting
 541 returns 1 if a message was received
 542 returns -1 if connection is invalid
 543 =================
 544 */
 545
 546 struct
 547 {
 548         double  time;
 549         int             op;
 550         long    session;
 551         int             ret;
 552         int             len;
 553 } vcrGetMessage;
 554
 555 extern void PrintStats(qsocket_t *s);
 556
 557 int     NET_GetMessage (qsocket_t *sock)
 558 {
 559         int ret;
 560
 561         if (!sock)
 562                 return -1;
 563
 564         if (sock->disconnected)
 565         {
 566                 Con_Printf("NET_GetMessage: disconnected socket\n");
 567                 return -1;
 568         }
 569
 570         SetNetTime();
 571
 572         ret = sfunc.QGetMessage(sock);
 573
 574         // see if this connection has timed out
 575         if (ret == 0 && sock->driver)
 576         {
 577                 if (net_time - sock->lastMessageTime > net_messagetimeout.value)
 578                 {
 579                         NET_Close(sock);
 580                         return -1;
 581                 }
 582         }
 583
 584
 585         if (ret > 0)
 586         {
 587                 if (sock->driver)
 588                 {
 589                         sock->lastMessageTime = net_time;
 590                         if (ret == 1)
 591                                 messagesReceived++;
 592                         else if (ret == 2)
 593                                 unreliableMessagesReceived++;
 594                 }
 595
 596                 if (recording)
 597                 {
 598                         vcrGetMessage.time = host_time;
 599                         vcrGetMessage.op = VCR_OP_GETMESSAGE;
 600                         vcrGetMessage.session = (long)sock;
 601                         vcrGetMessage.ret = ret;
 602                         vcrGetMessage.len = net_message.cursize;
 603                         Sys_FileWrite (vcrFile, &vcrGetMessage, 24);
 604                         Sys_FileWrite (vcrFile, net_message.data, net_message.cursize);
 605                 }
 606         }
 607         else
 608         {
 609                 if (recording)
 610                 {
 611                         vcrGetMessage.time = host_time;
 612                         vcrGetMessage.op = VCR_OP_GETMESSAGE;
 613                         vcrGetMessage.session = (long)sock;
 614                         vcrGetMessage.ret = ret;
 615                         Sys_FileWrite (vcrFile, &vcrGetMessage, 20);
 616                 }
 617         }
 618
 619         return ret;
 620 }
 621
 622
 623 /*
 624 ==================
 625 NET_SendMessage
 626
 627 Try to send a complete length+message unit over the reliable stream.
 628 returns 0 if the message cannot be delivered reliably, but the connection
 629                 is still considered valid
 630 returns 1 if the message was sent properly
 631 returns -1 if the connection died
 632 ==================
 633 */
 634 struct
 635 {
 636         double  time;
 637         int             op;
 638         long    session;
 639         int             r;
 640 } vcrSendMessage;
 641
 642 int NET_SendMessage (qsocket_t *sock, sizebuf_t *data)
 643 {
 644         int             r;
 645
 646         if (!sock)
 647                 return -1;
 648
 649         if (sock->disconnected)
 650         {
 651                 Con_Printf("NET_SendMessage: disconnected socket\n");
 652                 return -1;
 653         }
 654
 655         SetNetTime();
 656         r = sfunc.QSendMessage(sock, data);
 657         if (r == 1 && sock->driver)
 658                 messagesSent++;
 659
 660         if (recording)
 661         {
 662                 vcrSendMessage.time = host_time;
 663                 vcrSendMessage.op = VCR_OP_SENDMESSAGE;
 664                 vcrSendMessage.session = (long)sock;
 665                 vcrSendMessage.r = r;
 666                 Sys_FileWrite (vcrFile, &vcrSendMessage, 20);
 667         }
 668
 669         return r;
 670 }
 671
 672
 673 int NET_SendUnreliableMessage (qsocket_t *sock, sizebuf_t *data)
 674 {
 675         int             r;
 676
 677         if (!sock)
 678                 return -1;
 679
 680         if (sock->disconnected)
 681         {
 682                 Con_Printf("NET_SendMessage: disconnected socket\n");
 683                 return -1;
 684         }
 685
 686         SetNetTime();
 687         r = sfunc.SendUnreliableMessage(sock, data);
 688         if (r == 1 && sock->driver)
 689                 unreliableMessagesSent++;
 690
 691         if (recording)
 692         {
 693                 vcrSendMessage.time = host_time;
 694                 vcrSendMessage.op = VCR_OP_SENDMESSAGE;
 695                 vcrSendMessage.session = (long)sock;
 696                 vcrSendMessage.r = r;
 697                 Sys_FileWrite (vcrFile, &vcrSendMessage, 20);
 698         }
 699
 700         return r;
 701 }
 702
 703
 704 /*
 705 ==================
 706 NET_CanSendMessage
 707
 708 Returns true or false if the given qsocket can currently accept a
 709 message to be transmitted.
 710 ==================
 711 */
 712 qboolean NET_CanSendMessage (qsocket_t *sock)
 713 {
 714         int             r;
 715
 716         if (!sock)
 717                 return false;
 718
 719         if (sock->disconnected)
 720                 return false;
 721
 722         SetNetTime();
 723
 724         r = sfunc.CanSendMessage(sock);
 725
 726         if (recording)
 727         {
 728                 vcrSendMessage.time = host_time;
 729                 vcrSendMessage.op = VCR_OP_CANSENDMESSAGE;
 730                 vcrSendMessage.session = (long)sock;
 731                 vcrSendMessage.r = r;
 732                 Sys_FileWrite (vcrFile, &vcrSendMessage, 20);
 733         }
 734
 735         return r;
 736 }
 737
 738
 739 int NET_SendToAll(sizebuf_t *data, int blocktime)
 740 {
 741         double          start;
 742         int                     i;
 743         int                     count = 0;
 744         qboolean        state1 [MAX_SCOREBOARD];
 745         qboolean        state2 [MAX_SCOREBOARD];
 746
 747         for (i=0, host_client = svs.clients ; i<svs.maxclients ; i++, host_client++)
 748         {
 749                 if (!host_client->netconnection)
 750                         continue;
 751                 if (host_client->active)
 752                 {
 753                         if (host_client->netconnection->driver == 0)
 754                         {
 755                                 NET_SendMessage(host_client->netconnection, data);
 756                                 state1[i] = true;
 757                                 state2[i] = true;
 758                                 continue;
 759                         }
 760                         count++;
 761                         state1[i] = false;
 762                         state2[i] = false;
 763                 }
 764                 else
 765                 {
 766                         state1[i] = true;
 767                         state2[i] = true;
 768                 }
 769         }
 770
 771         start = Sys_FloatTime();
 772         while (count)
 773         {
 774                 count = 0;
 775                 for (i=0, host_client = svs.clients ; i<svs.maxclients ; i++, host_client++)
 776                 {
 777                         if (! state1[i])
 778                         {
 779                                 if (NET_CanSendMessage (host_client->netconnection))
 780                                 {
 781                                         state1[i] = true;
 782                                         NET_SendMessage(host_client->netconnection, data);
 783                                 }
 784                                 else
 785                                 {
 786                                         NET_GetMessage (host_client->netconnection);
 787                                 }
 788                                 count++;
 789                                 continue;
 790                         }
 791
 792                         if (! state2[i])
 793                         {
 794                                 if (NET_CanSendMessage (host_client->netconnection))
 795                                 {
 796                                         state2[i] = true;
 797                                 }
 798                                 else
 799                                 {
 800                                         NET_GetMessage (host_client->netconnection);
 801                                 }
 802                                 count++;
 803                                 continue;
 804                         }
 805                 }
 806                 if ((Sys_FloatTime() - start) > blocktime)
 807                         break;
 808         }
 809         return count;
 810 }
 811
 812
 813 //=============================================================================
 814
 815 /*
 816 ====================
 817 NET_Init
 818 ====================
 819 */
 820
 821 void NET_Init (void)
 822 {
 823         int                     i;
 824         int                     controlSocket;
 825         qsocket_t       *s;
 826
 827         if (COM_CheckParm("-playback"))
 828         {
 829                 net_numdrivers = 1;
 830                 net_drivers[0].Init = VCR_Init;
 831         }
 832
 833         if (COM_CheckParm("-record"))
 834                 recording = true;
 835
 836         i = COM_CheckParm ("-port");
 837         if (!i)
 838                 i = COM_CheckParm ("-udpport");
 839         if (!i)
 840                 i = COM_CheckParm ("-ipxport");
 841
 842         if (i)
 843         {
 844                 if (i < com_argc-1)
 845                         DEFAULTnet_hostport = Q_atoi (com_argv[i+1]);
 846                 else
 847                         Sys_Error ("NET_Init: you must specify a number after -port");
 848         }
 849         net_hostport = DEFAULTnet_hostport;
 850
 851         if (COM_CheckParm("-listen") || cls.state == ca_dedicated)
 852                 listening = true;
 853         net_numsockets = svs.maxclientslimit;
 854         if (cls.state != ca_dedicated)
 855                 net_numsockets++;
 856
 857         SetNetTime();
 858
 859         for (i = 0; i < net_numsockets; i++)
 860         {
 861                 s = (qsocket_t *)Hunk_AllocName(sizeof(qsocket_t), "qsocket");
 862                 s->next = net_freeSockets;
 863                 net_freeSockets = s;
 864                 s->disconnected = true;
 865         }
 866
 867         // allocate space for network message buffer
 868         SZ_Alloc (&net_message, NET_MAXMESSAGE);
 869
 870         Cvar_RegisterVariable (&net_messagetimeout);
 871         Cvar_RegisterVariable (&hostname);
 872         Cvar_RegisterVariable (&config_com_port);
 873         Cvar_RegisterVariable (&config_com_irq);
 874         Cvar_RegisterVariable (&config_com_baud);
 875         Cvar_RegisterVariable (&config_com_modem);
 876         Cvar_RegisterVariable (&config_modem_dialtype);
 877         Cvar_RegisterVariable (&config_modem_clear);
 878         Cvar_RegisterVariable (&config_modem_init);
 879         Cvar_RegisterVariable (&config_modem_hangup);
 880 #ifdef IDGODS
 881         Cvar_RegisterVariable (&idgods);
 882 #endif
 883
 884         if(!host_initialized)
 885         {
 886                 Cmd_AddCommand ("slist", NET_Slist_f);
 887                 Cmd_AddCommand ("listen", NET_Listen_f);
 888                 Cmd_AddCommand ("maxplayers", MaxPlayers_f);
 889                 Cmd_AddCommand ("port", NET_Port_f);
 890         }
 891
 892         // initialize all the drivers
 893         for (net_driverlevel=0 ; net_driverlevel<net_numdrivers ; net_driverlevel++)
 894                 {
 895                 controlSocket = net_drivers[net_driverlevel].Init();
 896                 if (controlSocket == -1)
 897                         continue;
 898                 net_drivers[net_driverlevel].initialized = true;
 899                 net_drivers[net_driverlevel].controlSock = controlSocket;
 900                 if (listening)
 901                         net_drivers[net_driverlevel].Listen (true);
 902                 }
 903
 904         if (*my_ipx_address)
 905                 Con_DPrintf("IPX address %s\n", my_ipx_address);
 906         if (*my_tcpip_address)
 907                 Con_DPrintf("TCP/IP address %s\n", my_tcpip_address);
 908 }
 909
 910 /*
 911 ====================
 912 NET_Shutdown
 913 ====================
 914 */
 915
 916 void            NET_Shutdown (void)
 917 {
 918         qsocket_t       *sock;
 919
 920         SetNetTime();
 921
 922         for (sock = net_activeSockets; sock; sock = sock->next)
 923                 NET_Close(sock);
 924
 925 //
 926 // shutdown the drivers
 927 //
 928         for (net_driverlevel = 0; net_driverlevel < net_numdrivers; net_driverlevel++)
 929         {
 930                 if (net_drivers[net_driverlevel].initialized == true)
 931                 {
 932                         net_drivers[net_driverlevel].Shutdown ();
 933                         net_drivers[net_driverlevel].initialized = false;
 934                 }
 935         }
 936
 937         if (vcrFile != -1)
 938         {
 939                 Con_Printf ("Closing vcrfile.\n");
 940                 Sys_FileClose(vcrFile);
 941         }
 942 }
 943
 944
 945 static PollProcedure *pollProcedureList = NULL;
 946
 947 void NET_Poll(void)
 948 {
 949         PollProcedure *pp;
 950         qboolean        useModem;
 951
 952         if (!configRestored)
 953         {
 954                 if (serialAvailable)
 955                 {
 956                         if (config_com_modem.value == 1.0)
 957                                 useModem = true;
 958                         else
 959                                 useModem = false;
 960                         SetComPortConfig (0, (int)config_com_port.value, (int)config_com_irq.value, (int)config_com_baud.value, useModem);
 961                         SetModemConfig (0, config_modem_dialtype.string, config_modem_clear.string, config_modem_init.string, config_modem_hangup.string);
 962                 }
 963                 configRestored = true;
 964         }
 965
 966         SetNetTime();
 967
 968         for (pp = pollProcedureList; pp; pp = pp->next)
 969         {
 970                 if (pp->nextTime > net_time)
 971                         break;
 972                 pollProcedureList = pp->next;
 973                 pp->procedure(pp->arg);
 974         }
 975 }
 976
 977
 978 void SchedulePollProcedure(PollProcedure *proc, double timeOffset)
 979 {
 980         PollProcedure *pp, *prev;
 981
 982         proc->nextTime = Sys_FloatTime() + timeOffset;
 983         for (pp = pollProcedureList, prev = NULL; pp; pp = pp->next)
 984         {
 985                 if (pp->nextTime >= proc->nextTime)
 986                         break;
 987                 prev = pp;
 988         }
 989
 990         if (prev == NULL)
 991         {
 992                 proc->next = pollProcedureList;
 993                 pollProcedureList = proc;
 994                 return;
 995         }
 996
 997         proc->next = pp;
 998         prev->next = proc;
 999 }
1000
1001
1002 #ifdef IDGODS
1003 #define IDNET   0xc0f62800
1004
1005 qboolean IsID(struct qsockaddr *addr)
1006 {
1007         if (idgods.value == 0.0)
1008                 return false;
1009
1010         if (addr->sa_family != 2)
1011                 return false;
1012
1013         if ((BigLong(*(int *)&addr->sa_data[2]) & 0xffffff00) == IDNET)
1014                 return true;
1015         return false;
1016 }
1017 #endif