![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to net_ser.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quake1|
Return to net_ser.c CVS log | Up to [Quake] / quake1 |
1.1 root 1: // net_ser.c
2:
3: #include "quakedef.h"
4: #include "net_ser.h"
5: #include "dosisms.h"
6: #include "crc.h"
7:
8: #include "net_comx.c"
9:
10: // serial protocol
11:
12: #define SERIAL_PROTOCOL_VERSION 3
13:
14: // The serial protocol is message oriented. The high level message format is
15: // a one byte message type (MTYPE_xxx), data, and a 16-bit checksum. All
16: // multi-byte fields are sent in network byte order. There are currently 4
17: // MTYPEs defined. Their formats are as follows:
18: //
19: // MTYPE_RELIABLE sequence data_length data checksum eom
20: // MTYPE_UNRELIABLE sequence data_length data checksum eom
21: // MTYPE_ACK sequence checksum eom
22: // MTYPE_CONTROL data_length data checksum eom
23: //
24: // sequence is an 8-bit unsigned value starting from 0
25: // data_length is a 16-bit unsigned value; it is the length of the data only
26: // the checksum is a 16-bit value. the CRC formula used is defined in crc.h.
27: // the checksum covers the entire messages, excluding itself
28: // eom is a special 2 byte sequence used to mark the End Of Message. This is
29: // needed for error recovery.
30: //
31: // A lot of behavior is based on knowledge of the upper level Quake network
32: // layer. For example, only one reliable message can be outstanding (pending
33: // reception of an MTYPE_ACK) at a time.
34: //
35: // The low level routines used to communicate with the modem are not part of
36: // this protocol.
37: //
38: // The CONTROL messages are only used for session establishment. They are
39: // not reliable or sequenced.
40:
41: #define MTYPE_RELIABLE 0x01
42: #define MTYPE_UNRELIABLE 0x02
43: #define MTYPE_CONTROL 0x03
44: #define MTYPE_ACK 0x04
45: #define MTYPE_CLIENT 0x80
46:
47: #define ESCAPE_COMMAND 0xe0
48: #define ESCAPE_EOM 0x19
49:
50: static qboolean listening = false;
51:
52:
53: typedef struct SerialLine_s
54: {
55: struct SerialLine_s *next;
56: qsocket_t *sock;
57: int lengthStated;
58: int lengthFound;
59: int tty;
60: qboolean connected;
61: qboolean connecting;
62: qboolean client;
63: double connect_time;
64: unsigned short crcStated;
65: unsigned short crcValue;
66: byte currState;
67: byte prevState;
68: byte mtype;
69: byte sequence;
70: } SerialLine;
71:
72: #define STATE_READY 0
73: #define STATE_SEQUENCE 1
74: #define STATE_LENGTH1 2
75: #define STATE_LENGTH2 3
76: #define STATE_DATA 4
77: #define STATE_CRC1 5
78: #define STATE_CRC2 6
79: #define STATE_EOM 7
80: #define STATE_ESCAPE 8
81: #define STATE_ABORT 9
82:
83: SerialLine serialLine[NUM_COM_PORTS];
84:
85: int myDriverLevel;
86:
87: static void Serial_SendACK (SerialLine *p, byte sequence);
88:
89:
90: static void ResetSerialLineProtocol (SerialLine *p)
91: {
92: p->connected = false;
93: p->connecting = false;
94: p->currState = STATE_READY;
95: p->prevState = STATE_READY;
96: p->lengthFound = 0;
97: }
98:
99:
100: static int ProcessInQueue(SerialLine *p)
101: {
102: int b;
103:
104: while (1)
105: {
106: b = TTY_ReadByte(p->tty);
107: if (b == ERR_TTY_NODATA)
108: break;
109:
110: if (b == ERR_TTY_LINE_STATUS)
111: {
112: p->currState = STATE_ABORT;
113: continue;
114: }
115: if (b == ERR_TTY_MODEM_STATUS)
116: {
117: p->currState = STATE_ABORT;
118: return -1;
119: }
120:
121: if (b == ESCAPE_COMMAND)
122: if (p->currState != STATE_ESCAPE)
123: {
124: p->prevState = p->currState;
125: p->currState = STATE_ESCAPE;
126: continue;
127: }
128:
129: if (p->currState == STATE_ESCAPE)
130: {
131: if (b == ESCAPE_EOM)
132: {
133: if (p->prevState == STATE_ABORT)
134: {
135: p->currState = STATE_READY;
136: p->lengthFound = 0;
137: continue;
138: }
139:
140: if (p->prevState != STATE_EOM)
141: {
142: p->currState = STATE_READY;
143: p->lengthFound = 0;
144: Con_DPrintf("Serial: premature EOM\n");
145: continue;
146: }
147:
148: switch (p->mtype)
149: {
150: case MTYPE_RELIABLE:
151: Con_DPrintf("Serial: sending ack %u\n", p->sequence);
152: Serial_SendACK (p, p->sequence);
153: if (p->sequence == p->sock->receiveSequence)
154: {
155: p->sock->receiveSequence = (p->sequence + 1) & 0xff;
156: p->sock->receiveMessageLength += p->lengthFound;
157: }
158: else
159: Con_DPrintf("Serial: reliable out of order; got %u wanted %u\n", p->sequence, p->sock->receiveSequence);
160: break;
161:
162: case MTYPE_UNRELIABLE:
163: p->sock->unreliableReceiveSequence = (p->sequence + 1) & 0xff;
164: p->sock->receiveMessageLength += p->lengthFound;
165: break;
166:
167: case MTYPE_ACK:
168: Con_DPrintf("Serial: got ack %u\n", p->sequence);
169: if (p->sequence == p->sock->sendSequence)
170: {
171: p->sock->sendSequence = (p->sock->sendSequence + 1) & 0xff;
172: p->sock->canSend = true;
173: }
174: else
175: Con_DPrintf("Serial: ack out of order; got %u wanted %u\n",p->sequence, p->sock->sendSequence);
176: break;
177:
178: case MTYPE_CONTROL:
179: p->sock->receiveMessageLength += p->lengthFound;
180: break;
181: }
182:
183: p->currState = STATE_READY;
184: p->lengthFound = 0;
185: continue;
186: }
187:
188:
189: if (b != ESCAPE_COMMAND)
190: {
191: p->currState = STATE_ABORT;
192: Con_DPrintf("Serial: Bad escape sequence\n");
193: continue;
194: }
195:
196: // b == ESCAPE_COMMAND
197: p->currState = p->prevState;
198: }
199:
200: p->prevState = p->currState;
201:
202: //DEBUG
203: if (p->sock->receiveMessageLength + p->lengthFound > NET_MAXMESSAGE)
204: {
205: Con_DPrintf("Serial blew out receive buffer: %u\n", p->sock->receiveMessageLength + p->lengthFound);
206: p->currState = STATE_ABORT;
207: }
208: if (p->sock->receiveMessageLength + p->lengthFound == NET_MAXMESSAGE)
209: {
210: Con_DPrintf("Serial hit receive buffer limit: %u\n", p->sock->receiveMessageLength + p->lengthFound);
211: p->currState = STATE_ABORT;
212: }
213: //end DEBUG
214:
215: switch (p->currState)
216: {
217: case STATE_READY:
218: CRC_Init(&p->crcValue);
219: CRC_ProcessByte(&p->crcValue, b);
220: if (p->client)
221: {
222: if ((b & MTYPE_CLIENT) != 0)
223: {
224: p->currState = STATE_ABORT;
225: Con_DPrintf("Serial: client got own message\n");
226: break;
227: }
228: }
229: else
230: {
231: if ((b & MTYPE_CLIENT) == 0)
232: {
233: p->currState = STATE_ABORT;
234: Con_DPrintf("Serial: server got own message\n");
235: break;
236: }
237: b &= 0x7f;
238: }
239: p->mtype = b;
240: if (b != MTYPE_CONTROL)
241: p->currState = STATE_SEQUENCE;
242: else
243: p->currState = STATE_LENGTH1;
244: if (p->mtype < MTYPE_ACK)
245: {
246: p->sock->receiveMessage[p->sock->receiveMessageLength] = b;
247: p->lengthFound++;
248: }
249: break;
250:
251: case STATE_SEQUENCE:
252: p->sequence = b;
253: CRC_ProcessByte(&p->crcValue, b);
254: if (p->mtype != MTYPE_ACK)
255: p->currState = STATE_LENGTH1;
256: else
257: p->currState = STATE_CRC1;
258: break;
259:
260: case STATE_LENGTH1:
261: p->lengthStated = b * 256;
262: CRC_ProcessByte(&p->crcValue, b);
263: p->currState = STATE_LENGTH2;
264: break;
265:
266: case STATE_LENGTH2:
267: p->lengthStated += b;
268: CRC_ProcessByte(&p->crcValue, b);
269: if (p->mtype == MTYPE_RELIABLE && p->lengthStated > MAX_MSGLEN)
270: {
271: p->currState = STATE_ABORT;
272: Con_DPrintf("Serial: bad reliable message length %u\n", p->lengthStated);
273: }
274: else if (p->mtype == MTYPE_UNRELIABLE && p->lengthStated > MAX_DATAGRAM)
275: {
276: p->currState = STATE_ABORT;
277: Con_DPrintf("Serial: bad unreliable message length %u\n", p->lengthStated);
278: }
279: else
280: {
281: p->currState = STATE_DATA;
282: if (p->mtype < MTYPE_ACK)
283: {
284: *(short *)&p->sock->receiveMessage [p->sock->receiveMessageLength + 1] = p->lengthStated;
285: p->lengthFound += 2;
286: }
287: }
288: break;
289:
290: case STATE_DATA:
291: p->sock->receiveMessage[p->sock->receiveMessageLength + p->lengthFound] = b;
292: p->lengthFound++;
293: CRC_ProcessByte(&p->crcValue, b);
294: if (p->lengthFound == p->lengthStated + 3)
295: p->currState = STATE_CRC1;
296: break;
297:
298: case STATE_CRC1:
299: p->crcStated = b * 256;
300: p->currState = STATE_CRC2;
301: break;
302:
303: case STATE_CRC2:
304: p->crcStated += b;
305: if (p->crcStated == CRC_Value(p->crcValue))
306: {
307: p->currState = STATE_EOM;
308: }
309: else
310: {
311: p->currState = STATE_ABORT;
312: Con_DPrintf("Serial: Bad crc\n");
313: }
314: break;
315:
316: case STATE_EOM:
317: p->currState = STATE_ABORT;
318: Con_DPrintf("Serial: Bad message format\n");
319: break;
320:
321: case STATE_ABORT:
322: break;
323: }
324: }
325: return 0;
326: }
327:
328:
329: int Serial_Init (void)
330: {
331: int n;
332:
333: if (COM_CheckParm("-nolan"))
334: return -1;
335: if (COM_CheckParm ("-noserial"))
336: return -1;
337:
338: myDriverLevel = net_driverlevel;
339:
340: if (TTY_Init())
341: return -1;
342:
343: for (n = 0; n < NUM_COM_PORTS; n++)
344: {
345: serialLine[n].tty = TTY_Open(n);
346: ResetSerialLineProtocol (&serialLine[n]);
347: }
348:
349: Con_Printf("Serial driver initialized\n");
350: serialAvailable = true;
351:
352: return 0;
353: }
354:
355:
356: void Serial_Shutdown (void)
357: {
358: int n;
359:
360: for (n = 0; n < NUM_COM_PORTS; n++)
361: {
362: if (serialLine[n].connected)
363: Serial_Close(serialLine[n].sock);
364: }
365:
366: TTY_Shutdown();
367: }
368:
369:
370: void Serial_Listen (qboolean state)
371: {
372: listening = state;
373: }
374:
375:
376: qboolean Serial_CanSendMessage (qsocket_t *sock)
377: {
378: return sock->canSend;
379: }
380:
381:
382: qboolean Serial_CanSendUnreliableMessage (qsocket_t *sock)
383: {
384: return TTY_OutputQueueIsEmpty(((SerialLine *)sock->driverdata)->tty);
385: }
386:
387:
388: int Serial_SendMessage (qsocket_t *sock, sizebuf_t *message)
389: {
390: SerialLine *p;
391: int n;
392: unsigned short crc;
393: byte b;
394:
395: p = (SerialLine *)sock->driverdata;
396: CRC_Init (&crc);
397:
398: // message type
399: b = MTYPE_RELIABLE;
400: if (p->client)
401: b |= MTYPE_CLIENT;
402: TTY_WriteByte(p->tty, b);
403: CRC_ProcessByte (&crc, b);
404:
405: // sequence
406: b = p->sock->sendSequence;
407: TTY_WriteByte(p->tty, b);
408: if (b == ESCAPE_COMMAND)
409: TTY_WriteByte(p->tty, b);
410: CRC_ProcessByte (&crc, b);
411:
412: // data length
413: b = message->cursize >> 8;
414: TTY_WriteByte(p->tty, b);
415: if (b == ESCAPE_COMMAND)
416: TTY_WriteByte(p->tty, b);
417: CRC_ProcessByte (&crc, b);
418: b = message->cursize & 0xff;
419: TTY_WriteByte(p->tty, b);
420: if (b == ESCAPE_COMMAND)
421: TTY_WriteByte(p->tty, b);
422: CRC_ProcessByte (&crc, b);
423:
424: // data
425: for (n = 0; n < message->cursize; n++)
426: {
427: b = message->data[n];
428: TTY_WriteByte(p->tty, b);
429: if (b == ESCAPE_COMMAND)
430: TTY_WriteByte(p->tty, b);
431: CRC_ProcessByte (&crc, b);
432: }
433:
434: // checksum
435: b = CRC_Value (crc) >> 8;
436: TTY_WriteByte(p->tty, b);
437: if (b == ESCAPE_COMMAND)
438: TTY_WriteByte(p->tty, b);
439: b = CRC_Value (crc) & 0xff;
440: TTY_WriteByte(p->tty, b);
441: if (b == ESCAPE_COMMAND)
442: TTY_WriteByte(p->tty, b);
443:
444: // end of message
445: TTY_WriteByte(p->tty, ESCAPE_COMMAND);
446: TTY_WriteByte(p->tty, ESCAPE_EOM);
447:
448: TTY_Flush(p->tty);
449:
450: // mark sock as busy and save the message for possible retransmit
451: sock->canSend = false;
452: Q_memcpy(sock->sendMessage, message->data, message->cursize);
453: sock->sendMessageLength = message->cursize;
454: sock->lastSendTime = net_time;
455:
456: return 1;
457: }
458:
459:
460: static void ReSendMessage (qsocket_t *sock)
461: {
462: sizebuf_t temp;
463:
464: Con_DPrintf("Serial: re-sending reliable\n");
465: temp.data = sock->sendMessage;
466: temp.maxsize = sock->sendMessageLength;
467: temp.cursize = sock->sendMessageLength;
468: Serial_SendMessage (sock, &temp);
469: }
470:
471:
472: int Serial_SendUnreliableMessage (qsocket_t *sock, sizebuf_t *message)
473: {
474: SerialLine *p;
475: int n;
476: unsigned short crc;
477: byte b;
478:
479: p = (SerialLine *)sock->driverdata;
480:
481: if (!TTY_OutputQueueIsEmpty(p->tty))
482: {
483: TTY_Flush(p->tty);
484: return 1;
485: }
486:
487: CRC_Init (&crc);
488:
489: // message type
490: b = MTYPE_UNRELIABLE;
491: if (p->client)
492: b |= MTYPE_CLIENT;
493: TTY_WriteByte(p->tty, b);
494: CRC_ProcessByte (&crc, b);
495:
496: // sequence
497: b = p->sock->unreliableSendSequence;
498: p->sock->unreliableSendSequence = (b + 1) & 0xff;
499: TTY_WriteByte(p->tty, b);
500: if (b == ESCAPE_COMMAND)
501: TTY_WriteByte(p->tty, b);
502: CRC_ProcessByte (&crc, b);
503:
504: // data length
505: b = message->cursize >> 8;
506: TTY_WriteByte(p->tty, b);
507: if (b == ESCAPE_COMMAND)
508: TTY_WriteByte(p->tty, b);
509: CRC_ProcessByte (&crc, b);
510: b = message->cursize & 0xff;
511: TTY_WriteByte(p->tty, b);
512: if (b == ESCAPE_COMMAND)
513: TTY_WriteByte(p->tty, b);
514: CRC_ProcessByte (&crc, b);
515:
516: // data
517: for (n = 0; n < message->cursize; n++)
518: {
519: b = message->data[n];
520: TTY_WriteByte(p->tty, b);
521: if (b == ESCAPE_COMMAND)
522: TTY_WriteByte(p->tty, b);
523: CRC_ProcessByte (&crc, b);
524: }
525:
526: // checksum
527: b = CRC_Value (crc) >> 8;
528: TTY_WriteByte(p->tty, b);
529: if (b == ESCAPE_COMMAND)
530: TTY_WriteByte(p->tty, b);
531: b = CRC_Value (crc) & 0xff;
532: TTY_WriteByte(p->tty, b);
533: if (b == ESCAPE_COMMAND)
534: TTY_WriteByte(p->tty, b);
535:
536: // end of message
537: TTY_WriteByte(p->tty, ESCAPE_COMMAND);
538: TTY_WriteByte(p->tty, ESCAPE_EOM);
539:
540: TTY_Flush(p->tty);
541:
542: return 1;
543: }
544:
545:
546: static void Serial_SendACK (SerialLine *p, byte sequence)
547: {
548: unsigned short crc;
549: byte b;
550:
551: CRC_Init (&crc);
552:
553: // message type
554: b = MTYPE_ACK;
555: if (p->client)
556: b |= MTYPE_CLIENT;
557: TTY_WriteByte(p->tty, b);
558: CRC_ProcessByte (&crc, b);
559:
560: // sequence
561: b = sequence;
562: TTY_WriteByte(p->tty, b);
563: if (b == ESCAPE_COMMAND)
564: TTY_WriteByte(p->tty, b);
565: CRC_ProcessByte (&crc, b);
566:
567: // checksum
568: b = CRC_Value (crc) >> 8;
569: TTY_WriteByte(p->tty, b);
570: if (b == ESCAPE_COMMAND)
571: TTY_WriteByte(p->tty, b);
572: b = CRC_Value (crc) & 0xff;
573: TTY_WriteByte(p->tty, b);
574: if (b == ESCAPE_COMMAND)
575: TTY_WriteByte(p->tty, b);
576:
577: // end of message
578: TTY_WriteByte(p->tty, ESCAPE_COMMAND);
579: TTY_WriteByte(p->tty, ESCAPE_EOM);
580:
581: TTY_Flush(p->tty);
582: }
583:
584:
585: static void Serial_SendControlMessage (SerialLine *p, sizebuf_t *message)
586: {
587: unsigned short crc;
588: int n;
589: byte b;
590:
591: CRC_Init (&crc);
592:
593: // message type
594: b = MTYPE_CONTROL;
595: if (p->client)
596: b |= MTYPE_CLIENT;
597: TTY_WriteByte(p->tty, b);
598: CRC_ProcessByte (&crc, b);
599:
600: // data length
601: b = message->cursize >> 8;
602: TTY_WriteByte(p->tty, b);
603: if (b == ESCAPE_COMMAND)
604: TTY_WriteByte(p->tty, b);
605: CRC_ProcessByte (&crc, b);
606: b = message->cursize & 0xff;
607: TTY_WriteByte(p->tty, b);
608: if (b == ESCAPE_COMMAND)
609: TTY_WriteByte(p->tty, b);
610: CRC_ProcessByte (&crc, b);
611:
612: // data
613: for (n = 0; n < message->cursize; n++)
614: {
615: b = message->data[n];
616: TTY_WriteByte(p->tty, b);
617: if (b == ESCAPE_COMMAND)
618: TTY_WriteByte(p->tty, b);
619: CRC_ProcessByte (&crc, b);
620: }
621:
622: // checksum
623: b = CRC_Value (crc) >> 8;
624: TTY_WriteByte(p->tty, b);
625: if (b == ESCAPE_COMMAND)
626: TTY_WriteByte(p->tty, b);
627: b = CRC_Value (crc) & 0xff;
628: TTY_WriteByte(p->tty, b);
629: if (b == ESCAPE_COMMAND)
630: TTY_WriteByte(p->tty, b);
631:
632: // end of message
633: TTY_WriteByte(p->tty, ESCAPE_COMMAND);
634: TTY_WriteByte(p->tty, ESCAPE_EOM);
635:
636: TTY_Flush(p->tty);
637: }
638:
639:
640: static int _Serial_GetMessage (SerialLine *p)
641: {
642: byte ret;
643: short length;
644:
645: if (ProcessInQueue(p))
646: return -1;
647:
648: if (p->sock->receiveMessageLength == 0)
649: return 0;
650:
651: ret = p->sock->receiveMessage[0];
652: length = *(short *)&p->sock->receiveMessage[1];
653: if (ret == MTYPE_CONTROL)
654: ret = 1;
655:
656: SZ_Clear (&net_message);
657: SZ_Write (&net_message, &p->sock->receiveMessage[3], length);
658:
659: length += 3;
660: p->sock->receiveMessageLength -= length;
661:
662: if (p->sock->receiveMessageLength + p->lengthFound)
663: Q_memcpy(p->sock->receiveMessage, &p->sock->receiveMessage[length], p->sock->receiveMessageLength + p->lengthFound);
664:
665: return ret;
666: }
667:
668: int Serial_GetMessage (qsocket_t *sock)
669: {
670: SerialLine *p;
671: int ret;
672:
673: p = (SerialLine *)sock->driverdata;
674:
675: ret = _Serial_GetMessage (p);
676:
677: if (ret == 1)
678: messagesReceived++;
679:
680: if (!sock->canSend)
681: if ((net_time - sock->lastSendTime) > 1.0)
682: {
683: ReSendMessage (sock);
684: sock->lastSendTime = net_time;
685: }
686:
687: return ret;
688: }
689:
690:
691: void Serial_Close (qsocket_t *sock)
692: {
693: SerialLine *p = (SerialLine *)sock->driverdata;
694: TTY_Close(p->tty);
695: ResetSerialLineProtocol (p);
696: }
697:
698:
699: char *com_types[] = {"direct", "modem"};
700: unsigned com_bauds[] = {9600, 14400, 19200, 28800, 57600};
701:
702: void Serial_SearchForHosts (qboolean xmit)
703: {
704: int n;
705: SerialLine *p;
706:
707: if (sv.active)
708: return;
709:
710: if (hostCacheCount == HOSTCACHESIZE)
711: return;
712:
713: // see if we've already answered
714: for (n = 0; n < hostCacheCount; n++)
715: if (Q_strcmp (hostcache[n].cname, "#") == 0)
716: return;
717:
718: for (n = 0; n < NUM_COM_PORTS; n++)
719: if (TTY_IsEnabled(n))
720: break;
721: if (n == NUM_COM_PORTS)
722: return;
723: p = &serialLine[n];
724:
725: if (TTY_IsModem(p->tty))
726: return;
727:
728: sprintf(hostcache[hostCacheCount].name, "COM%u", n+1);
729: Q_strcpy(hostcache[hostCacheCount].map, "");
730: hostcache[hostCacheCount].users = 0;
731: hostcache[hostCacheCount].maxusers = 0;
732: hostcache[hostCacheCount].driver = net_driverlevel;
733: Q_strcpy(hostcache[hostCacheCount].cname, "#");
734: hostCacheCount++;
735:
736: return;
737: }
738:
739:
740: static qsocket_t *_Serial_Connect (char *host, SerialLine *p)
741: {
742: int ret;
743: double start_time;
744: double last_time;
745:
746: p->client = true;
747: if (TTY_Connect(p->tty, host))
748: return NULL;
749:
750: p->sock = NET_NewQSocket ();
751: p->sock->driver = myDriverLevel;
752: if (p->sock == NULL)
753: {
754: Con_Printf("No sockets available\n");
755: return NULL;
756: }
757: p->sock->driverdata = p;
758:
759: // send the connection request
760: start_time = SetNetTime();
761: last_time = 0.0;
762:
763: SZ_Clear(&net_message);
764: MSG_WriteByte(&net_message, CCREQ_CONNECT);
765: MSG_WriteString(&net_message, "QUAKE");
766: do
767: {
768: SetNetTime();
769: if ((net_time - last_time) >= 1.0)
770: {
771: Serial_SendControlMessage (p, &net_message);
772: last_time = net_time;
773: Con_Printf("trying...\n"); SCR_UpdateScreen ();
774: }
775: ret = _Serial_GetMessage (p);
776: }
777: while (ret == 0 && (net_time - start_time) < 5.0);
778:
779: if (ret == 0)
780: {
781: Con_Printf("Unable to connect, no response\n");
782: goto ErrorReturn;
783: }
784:
785: if (ret == -1)
786: {
787: Con_Printf("Connection request error\n");
788: goto ErrorReturn;
789: }
790:
791: MSG_BeginReading ();
792: ret = MSG_ReadByte();
793: if (ret == CCREP_REJECT)
794: {
795: Con_Printf(MSG_ReadString());
796: goto ErrorReturn;
797: }
798: if (ret != CCREP_ACCEPT)
799: {
800: Con_Printf("Unknown connection response\n");
801: goto ErrorReturn;
802: }
803:
804: p->connected = true;
805: p->sock->lastMessageTime = net_time;
806:
807: Con_Printf ("Connection accepted\n");
808:
809: return p->sock;
810:
811: ErrorReturn:
812: TTY_Disconnect(p->tty);
813: return NULL;
814: }
815:
816: qsocket_t *Serial_Connect (char *host)
817: {
818: int n;
819: qsocket_t *ret = NULL;
820:
821: // see if this looks like a phone number
822: if (*host == '#')
823: host++;
824: for (n = 0; n < Q_strlen(host); n++)
825: if (host[n] == '.' || host[n] == ':')
826: return NULL;
827:
828: for (n = 0; n < NUM_COM_PORTS; n++)
829: if (TTY_IsEnabled(n) && !serialLine[n].connected)
830: if ((ret = _Serial_Connect (host, &serialLine[n])))
831: break;
832: return ret;
833: }
834:
835:
836: static qsocket_t *_Serial_CheckNewConnections (SerialLine *p)
837: {
838: int command;
839:
840: p->client = false;
841: if (!TTY_CheckForConnection(p->tty))
842: return NULL;
843:
844: if (TTY_IsModem(p->tty))
845: {
846: if (!p->connecting)
847: {
848: p->connecting = true;
849: p->connect_time = net_time;
850: }
851: else if ((net_time - p->connect_time) > 15.0)
852: {
853: p->connecting = false;
854: TTY_Disconnect(p->tty);
855: return NULL;
856: }
857: }
858:
859: p->sock = NET_NewQSocket ();
860: p->sock->driver = myDriverLevel;
861: if (p->sock == NULL)
862: {
863: Con_Printf("No sockets available\n");
864: return NULL;
865: }
866: p->sock->driverdata = p;
867:
868: SZ_Clear(&net_message);
869: if (_Serial_GetMessage(p) != 1)
870: {
871: NET_FreeQSocket(p->sock);
872: return NULL;
873: }
874:
875: MSG_BeginReading ();
876: command = MSG_ReadByte();
877:
878: if (command == CCREQ_SERVER_INFO)
879: {
880: if (Q_strcmp(MSG_ReadString(), "QUAKE") != 0)
881: return NULL;
882:
883: if (MSG_ReadByte() != SERIAL_PROTOCOL_VERSION)
884: return NULL;
885:
886: SZ_Clear(&net_message);
887: MSG_WriteByte(&net_message, CCREP_SERVER_INFO);
888: MSG_WriteString(&net_message, hostname.string);
889: MSG_WriteString(&net_message, sv.name);
890: MSG_WriteByte(&net_message, net_activeconnections);
891: MSG_WriteByte(&net_message, svs.maxclients);
892: Serial_SendControlMessage (p, &net_message);
893: SZ_Clear(&net_message);
894: return NULL;
895: }
896:
897: if (command != CCREQ_CONNECT)
898: return NULL;
899:
900: if (Q_strcmp(MSG_ReadString(), "QUAKE") != 0)
901: return NULL;
902:
903: // send him back the info about the server connection he has been allocated
904: SZ_Clear(&net_message);
905: MSG_WriteByte(&net_message, CCREP_ACCEPT);
906: Serial_SendControlMessage (p, &net_message);
907: SZ_Clear(&net_message);
908:
909: p->connected = true;
910: p->connecting = false;
911: p->sock->lastMessageTime = net_time;
912: sprintf(p->sock->address, "COM%u", (int)((p - serialLine) + 1));
913:
914: return p->sock;
915: }
916:
917: qsocket_t *Serial_CheckNewConnections (void)
918: {
919: int n;
920: qsocket_t *ret = NULL;
921:
922: for (n = 0; n < NUM_COM_PORTS; n++)
923: if (TTY_IsEnabled(n) && !serialLine[n].connected)
924: if ((ret = _Serial_CheckNewConnections (&serialLine[n])))
925: break;
926: return ret;
927: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.