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