![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to net_mp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quake1|
Return to net_mp.c CVS log | Up to [Quake] / quake1 |
1.1 root 1: // net_mpath.c
2:
3: #include <dpmi.h>
4: #include "quakedef.h"
5: #include "mpdosock.h"
6:
7: short flat_selector;
8:
9: int WSAGetLastError(void);
10: void sockets_flush(void);
11:
12: extern cvar_t hostname;
13:
14: #define DEFAULTnet_hostport 26000
15:
16: #define MAXHOSTNAMELEN 256
17:
18: static int net_acceptsocket = -1; // socket for fielding new connections
19: static int net_controlsocket;
20: static int net_hostport; // udp port number for acceptsocket
21: static int net_broadcastsocket = 0;
22: //static qboolean ifbcastinit = false;
23: static struct qsockaddr broadcastaddr;
24:
25: static unsigned long myAddr;
26:
27: #include "net_mp.h"
28:
29:
30: //=============================================================================
31:
32: int MPATH_Init (void)
33: {
34: int i;
35: struct hostent *local;
36: char buff[MAXHOSTNAMELEN];
37: struct qsockaddr addr;
38: char *p;
39:
40: if (COM_CheckParm ("-mpath") == 0)
41: return -1;
42:
43: i = COM_CheckParm ("-udpport");
44: if (i == 0)
45: net_hostport = DEFAULTnet_hostport;
46: else if (i < com_argc-1)
47: net_hostport = Q_atoi (com_argv[i+1]);
48: else
49: Sys_Error ("MPATH_Init: you must specify a number after -udpport");
50:
51: flat_selector = __dpmi_allocate_ldt_descriptors(1);
52: if (flat_selector == -1) {
53: Con_Printf("MPATH_Init: Can't get flat selector\n");
54: return -1;
55: }
56: if (__dpmi_set_segment_base_address(flat_selector, 0) == -1) {
57: Con_Printf("MPATH_Init: Can't seg flat base!\n");
58: return -1;
59: }
60: if (__dpmi_set_segment_limit(flat_selector, 0xffffffff) == -1) {
61: Con_Printf("MPATH_Init: Can't set segment limit\n");
62: return -1;
63: }
64: // determine my name & address
65: gethostname(buff, MAXHOSTNAMELEN);
66: local = gethostbyname(buff);
67: myAddr = *(int *)local->h_addr_list[0];
68:
69: // if the quake hostname isn't set, set it to the machine name
70: if (Q_strcmp(hostname.string, "UNNAMED") == 0)
71: {
72: // see if it's a text IP address (well, close enough)
73: for (p = buff; *p; p++)
74: if ((*p < '0' || *p > '9') && *p != '.')
75: break;
76:
77: // if it is a real name, strip off the domain; we only want the host
78: if (*p)
79: {
80: for (i = 0; i < 15; i++)
81: if (buff[i] == '.')
82: break;
83: buff[i] = 0;
84: }
85: Cvar_Set ("hostname", buff);
86: }
87:
88: if ((net_controlsocket = MPATH_OpenSocket (0)) == -1)
89: Sys_Error("MPATH_Init: Unable to open control socket\n");
90:
91: ((struct sockaddr_in *)&broadcastaddr)->sin_family = AF_INET;
92: ((struct sockaddr_in *)&broadcastaddr)->sin_addr.s_addr = INADDR_BROADCAST;
93: ((struct sockaddr_in *)&broadcastaddr)->sin_port = htons(net_hostport);
94:
95: MPATH_GetSocketAddr (net_controlsocket, &addr);
96: Q_strcpy(my_tcpip_address, MPATH_AddrToString (&addr));
97: p = Q_strrchr (my_tcpip_address, ':');
98: if (p)
99: *p = 0;
100:
101: Con_Printf("MPath Initialized\n");
102: tcpipAvailable = true;
103:
104: return net_controlsocket;
105: }
106:
107: //=============================================================================
108:
109: void MPATH_Shutdown (void)
110: {
111: MPATH_Listen (false);
112: MPATH_CloseSocket (net_controlsocket);
113: }
114:
115: //=============================================================================
116:
117: void MPATH_Listen (qboolean state)
118: {
119: // enable listening
120: if (state)
121: {
122: if (net_acceptsocket != -1)
123: return;
124: if ((net_acceptsocket = MPATH_OpenSocket (net_hostport)) == -1)
125: Sys_Error ("MPATH_Listen: Unable to open accept socket\n");
126: return;
127: }
128:
129: // disable listening
130: if (net_acceptsocket == -1)
131: return;
132: MPATH_CloseSocket (net_acceptsocket);
133: net_acceptsocket = -1;
134: }
135:
136: //=============================================================================
137:
138: int MPATH_OpenSocket (int port)
139: {
140: int newsocket;
141: struct sockaddr_in address;
142: u_long _true = 1;
143:
144: if ((newsocket = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
145: return -1;
146:
147: if (ioctlsocket (newsocket, FIONBIO, &_true) == -1)
148: goto ErrorReturn;
149:
150: address.sin_family = AF_INET;
151: address.sin_addr.s_addr = INADDR_ANY;
152: address.sin_port = htons(port);
153: if( bind (newsocket, (void *)&address, sizeof(address)) == -1)
154: goto ErrorReturn;
155:
156: return newsocket;
157:
158: ErrorReturn:
159: closesocket (newsocket);
160: return -1;
161: }
162:
163: //=============================================================================
164:
165: int MPATH_CloseSocket (int socket)
166: {
167: if (socket == net_broadcastsocket)
168: net_broadcastsocket = 0;
169: return closesocket (socket);
170: }
171:
172:
173: //=============================================================================
174: /*
175: ============
176: PartialIPAddress
177:
178: this lets you type only as much of the net address as required, using
179: the local network components to fill in the rest
180: ============
181: */
182: static int PartialIPAddress (char *in, struct qsockaddr *hostaddr)
183: {
184: char buff[256];
185: char *b;
186: int addr;
187: int num;
188: int mask;
189:
190: buff[0] = '.';
191: b = buff;
192: strcpy(buff+1, in);
193: if (buff[1] == '.') b++;
194:
195: addr = 0;
196: mask=-1;
197: while (*b == '.')
198: {
199: num = 0;
200: if (*++b < '0' || *b > '9') return -1;
201: while (!( *b < '0' || *b > '9'))
202: num = num*10 + *(b++) - '0';
203: mask<<=8;
204: addr = (addr<<8) + num;
205: }
206:
207: hostaddr->sa_family = AF_INET;
208: ((struct sockaddr_in *)hostaddr)->sin_port = htons(net_hostport);
209: ((struct sockaddr_in *)hostaddr)->sin_addr.s_addr = (myAddr & htonl(mask)) | htonl(addr);
210:
211: return 0;
212: }
213: //=============================================================================
214:
215: int MPATH_Connect (int socket, struct qsockaddr *addr)
216: {
217: return 0;
218: }
219:
220: //=============================================================================
221:
222: int MPATH_CheckNewConnections (void)
223: {
224: char buf[4];
225:
226: if (net_acceptsocket == -1)
227: return -1;
228:
229: if (recvfrom (net_acceptsocket, buf, 4, MSG_PEEK, NULL, NULL) > 0)
230: return net_acceptsocket;
231: return -1;
232: }
233:
234: //=============================================================================
235:
236: int MPATH_Read (int socket, byte *buf, int len, struct qsockaddr *addr)
237: {
238: int addrlen = sizeof (struct qsockaddr);
239: int ret;
240:
241: ret = recvfrom (socket, buf, len, 0, (struct sockaddr *)addr, &addrlen);
242: if (ret == -1)
243: {
244: int errno = WSAGetLastError();
245:
246: if (errno == WSAEWOULDBLOCK || errno == WSAECONNREFUSED)
247: return 0;
248:
249: }
250: return ret;
251: }
252:
253: //=============================================================================
254:
255: int MPATH_MakeSocketBroadcastCapable (int socket)
256: {
257: int i = 1;
258:
259: // make this socket broadcast capable
260: if (setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) < 0)
261: return -1;
262: net_broadcastsocket = socket;
263:
264: return 0;
265: }
266:
267: //=============================================================================
268:
269: int MPATH_Broadcast (int socket, byte *buf, int len)
270: {
271: int ret;
272:
273: if (socket != net_broadcastsocket)
274: {
275: if (net_broadcastsocket != 0)
276: Sys_Error("Attempted to use multiple broadcasts sockets\n");
277: ret = MPATH_MakeSocketBroadcastCapable (socket);
278: if (ret == -1)
279: {
280: Con_Printf("Unable to make socket broadcast capable\n");
281: return ret;
282: }
283: }
284:
285: return MPATH_Write (socket, buf, len, &broadcastaddr);
286: }
287:
288: //=============================================================================
289:
290: int MPATH_Write (int socket, byte *buf, int len, struct qsockaddr *addr)
291: {
292: int ret;
293:
294: ret = sendto (socket, buf, len, 0, (struct sockaddr *)addr, sizeof(struct qsockaddr));
295: if (ret == -1)
296: if (WSAGetLastError() == WSAEWOULDBLOCK)
297: return 0;
298:
299: sockets_flush();
300:
301: return ret;
302: }
303:
304: //=============================================================================
305:
306: char *MPATH_AddrToString (struct qsockaddr *addr)
307: {
308: static char buffer[22];
309: int haddr;
310:
311: haddr = ntohl(((struct sockaddr_in *)addr)->sin_addr.s_addr);
312: 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));
313: return buffer;
314: }
315:
316: //=============================================================================
317:
318: int MPATH_StringToAddr (char *string, struct qsockaddr *addr)
319: {
320: int ha1, ha2, ha3, ha4, hp;
321: int ipaddr;
322:
323: sscanf(string, "%d.%d.%d.%d:%d", &ha1, &ha2, &ha3, &ha4, &hp);
324: ipaddr = (ha1 << 24) | (ha2 << 16) | (ha3 << 8) | ha4;
325:
326: addr->sa_family = AF_INET;
327: ((struct sockaddr_in *)addr)->sin_addr.s_addr = htonl(ipaddr);
328: ((struct sockaddr_in *)addr)->sin_port = htons(hp);
329: return 0;
330: }
331:
332: //=============================================================================
333:
334: int MPATH_GetSocketAddr (int socket, struct qsockaddr *addr)
335: {
336: int addrlen = sizeof(struct qsockaddr);
337: unsigned int a;
338:
339: Q_memset(addr, 0, sizeof(struct qsockaddr));
340: getsockname(socket, (struct sockaddr *)addr, &addrlen);
341: a = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
342: if (a == 0 || a == inet_addr("127.0.0.1"))
343: ((struct sockaddr_in *)addr)->sin_addr.s_addr = myAddr;
344:
345: return 0;
346: }
347:
348: //=============================================================================
349:
350: int MPATH_GetNameFromAddr (struct qsockaddr *addr, char *name)
351: {
352: struct hostent *hostentry;
353:
354: hostentry = gethostbyaddr ((char *)&((struct sockaddr_in *)addr)->sin_addr, sizeof(struct in_addr), AF_INET);
355: if (hostentry)
356: {
357: Q_strncpy (name, (char *)hostentry->h_name, NET_NAMELEN - 1);
358: return 0;
359: }
360:
361: Q_strcpy (name, MPATH_AddrToString (addr));
362: return 0;
363: }
364:
365: //=============================================================================
366:
367: int MPATH_GetAddrFromName(char *name, struct qsockaddr *addr)
368: {
369: struct hostent *hostentry;
370:
371: if (name[0] >= '0' && name[0] <= '9')
372: return PartialIPAddress (name, addr);
373:
374: hostentry = gethostbyname (name);
375: if (!hostentry)
376: return -1;
377:
378: addr->sa_family = AF_INET;
379: ((struct sockaddr_in *)addr)->sin_port = htons(net_hostport);
380: ((struct sockaddr_in *)addr)->sin_addr.s_addr = *(int *)hostentry->h_addr_list[0];
381:
382: return 0;
383: }
384:
385: //=============================================================================
386:
387: int MPATH_AddrCompare (struct qsockaddr *addr1, struct qsockaddr *addr2)
388: {
389: if (addr1->sa_family != addr2->sa_family)
390: return -1;
391:
392: if (((struct sockaddr_in *)addr1)->sin_addr.s_addr != ((struct sockaddr_in *)addr2)->sin_addr.s_addr)
393: return -1;
394:
395: if (((struct sockaddr_in *)addr1)->sin_port != ((struct sockaddr_in *)addr2)->sin_port)
396: return 1;
397:
398: return 0;
399: }
400:
401: //=============================================================================
402:
403: int MPATH_GetSocketPort (struct qsockaddr *addr)
404: {
405: return ntohs(((struct sockaddr_in *)addr)->sin_port);
406: }
407:
408:
409: int MPATH_SetSocketPort (struct qsockaddr *addr, int port)
410: {
411: ((struct sockaddr_in *)addr)->sin_port = htons(port);
412: return 0;
413: }
414:
415: //=============================================================================
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.