/[svn]/ircd-hybrid-7.2/src/s_bsd_win32.c
ViewVC logotype

Annotation of /ircd-hybrid-7.2/src/s_bsd_win32.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 33 - (hide annotations)
Sun Oct 2 20:50:00 2005 UTC (15 years, 6 months ago) by knight
Original Path: ircd-hybrid/src/s_bsd_win32.c
File MIME type: text/x-chdr
File size: 12777 byte(s)
- svn:keywords

1 adx 30 /*
2     * ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3     * s_bsd_win32.c: Winsock WSAAsyncSelect() compatible network routines.
4     *
5     * Copyright (C) 2002 by the past and present ircd coders, and others.
6     *
7     * This program 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     * This program 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 this program; if not, write to the Free Software
19     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20     * USA
21     *
22 knight 31 * $Id$
23 adx 30 */
24    
25     #include "stdinc.h"
26     #include <iphlpapi.h>
27     #include "fdlist.h"
28     #include "ircd.h"
29     #include "s_bsd.h"
30     #include "common.h"
31     #include "client.h"
32     #include "numeric.h"
33     #include "restart.h"
34    
35     #define WM_SOCKET (WM_USER + 0)
36     #define WM_DNS (WM_USER + 1)
37     #define WM_REHASH (WM_USER + 0x100)
38     #define WM_REMOTD (WM_USER + 0x101)
39    
40     static HWND wndhandle;
41     static dlink_list dns_queries = {NULL, NULL, 0};
42     static dlink_node *setupfd_hook;
43     static DWORD (WINAPI * _GetNetworkParams) (PFIXED_INFO, PULONG) = NULL;
44    
45     extern int main(int, char *[]);
46    
47     /*
48     * Initial entry point for Win32 GUI applications, called by the C runtime.
49     *
50     * It should be only a wrapper for main(), since when compiled as a console
51     * application, main() is called instead.
52     */
53     int WINAPI
54     WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
55     LPSTR lpCmdLine, int nCmdShow)
56     {
57     /* Do we really need these pidfile, logfile etc arguments?
58     * And we are not on a console, so -help or -foreground is meaningless. */
59    
60     char *argv[2] = {"ircd", NULL};
61    
62     return main(1, argv);
63     }
64    
65     /*
66     * Handler for Win32 messages.
67     */
68     static LRESULT CALLBACK
69     hybrid_wndproc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
70     {
71     switch (uMsg)
72     {
73     case WM_SOCKET:
74     {
75     fde_t *F = lookup_fd((int) wParam);
76     PF *hdl;
77    
78     if (F != NULL && F->flags.open)
79     switch (WSAGETSELECTEVENT(lParam))
80     {
81     case FD_ACCEPT:
82     case FD_CLOSE:
83     case FD_READ:
84     if ((hdl = F->read_handler) != NULL)
85     {
86     F->read_handler = NULL;
87     hdl(F, F->read_data);
88     if (F->flags.open)
89     comm_setselect(F, 0, NULL, NULL, 0);
90     }
91     break;
92    
93     case FD_CONNECT:
94     case FD_WRITE:
95     if ((hdl = F->write_handler) != NULL)
96     {
97     F->write_handler = NULL;
98     hdl(F, F->write_data);
99     if (F->flags.open)
100     comm_setselect(F, 0, NULL, NULL, 0);
101     }
102     }
103    
104     return 0;
105     }
106    
107     case WM_DNS:
108     {
109     dlink_node *ptr;
110    
111     DLINK_FOREACH(ptr, dns_queries.head)
112     if (((struct DNSQuery *) ptr->data)->handle == wParam)
113     {
114     struct DNSQuery *query = ptr->data;
115     struct DNSReply *reply = NULL;
116    
117     dlinkDelete(&query->node, &dns_queries);
118    
119     if (WSAGETASYNCERROR(lParam) == 0)
120     {
121     struct hostent *h = (struct hostent *) &query->reply;
122     static struct DNSReply _reply;
123     reply = &_reply;
124    
125     reply->h_name = h->h_name;
126     reply->addr.ss.ss_family = h->h_addrtype;
127    
128     switch (h->h_addrtype)
129     {
130     case AF_INET:
131     memcpy(&((struct sockaddr_in *) &reply->addr)->sin_addr,
132     h->h_addr_list[0], h->h_length);
133     break;
134    
135     #ifdef IPV6
136     case AF_INET6:
137     memcpy(&((struct sockaddr_in6 *) &reply->addr)->sin6_addr,
138     h->h_addr_list[0], h->h_length);
139     break;
140     #endif
141    
142     default: /* shouldn't happen */
143     reply = NULL;
144     }
145     }
146    
147     query->callback(query->ptr, reply);
148     return 0;
149     }
150    
151     return 0;
152     }
153    
154     case WM_REHASH:
155     dorehash = 1;
156     return 0;
157    
158     case WM_REMOTD:
159     doremotd = 1;
160     return 0;
161    
162     case WM_DESTROY:
163     PostQuitMessage(0);
164     return 0;
165    
166     default:
167     return DefWindowProc(hwnd, uMsg, wParam, lParam);
168     }
169     }
170    
171     /*
172     * Associates a window message with the given socket.
173     * This will automagically switch it to nonblocking.
174     */
175     static void *
176     setup_winsock_fd(va_list args)
177     {
178     int fd = va_arg(args, int);
179    
180     WSAAsyncSelect(fd, wndhandle, WM_SOCKET, 0);
181    
182     return pass_callback(setupfd_hook, fd);
183     }
184    
185     /*
186     * Initialize Winsock, create a window handle.
187     */
188     void
189     init_netio(void)
190     {
191     WNDCLASS wndclass;
192     WSADATA wsa;
193     HMODULE lib;
194    
195     /* Initialize Winsock networking */
196     if (WSAStartup(0x101, &wsa) != 0)
197     {
198     MessageBox(NULL, "Cannot initialize Winsock -- terminating ircd",
199     NULL, MB_OK | MB_ICONERROR);
200     exit(1);
201     }
202    
203     /* First, we need a class for our window that has message handler
204     * set to hybrid_wndproc() */
205     memset(&wndclass, 0, sizeof(wndclass));
206    
207     wndclass.lpfnWndProc = hybrid_wndproc;
208     wndclass.hInstance = GetModuleHandle(NULL);
209     wndclass.lpszClassName = PACKAGE_NAME;
210    
211     RegisterClass(&wndclass);
212    
213     /* Now, initialize the window */
214     wndhandle = CreateWindow(PACKAGE_NAME, NULL, 0,
215     CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
216     NULL, NULL, wndclass.hInstance, NULL);
217    
218     if (!wndhandle)
219     {
220     MessageBox(NULL, "Cannot allocate window handle -- terminating ircd",
221     NULL, MB_OK | MB_ICONERROR);
222     exit(1);
223     }
224    
225     /* Set up a timer which will periodically post a message to our queue.
226     * This way, ircd won't wait infinitely for a network event */
227     SetTimer(wndhandle, 0, SELECT_DELAY, NULL);
228    
229     if ((lib = LoadLibrary("IPHLPAPI.DLL")) != NULL)
230     _GetNetworkParams = GetProcAddress(lib, "GetNetworkParams");
231    
232     setupfd_hook = install_hook(setup_socket_cb, setup_winsock_fd);
233     }
234    
235     /*
236     * comm_setselect
237     *
238     * This is a needed exported function which will be called to register
239     * and deregister interest in a pending IO state for a given FD.
240     */
241     void
242     comm_setselect(fde_t *F, unsigned int type, PF *handler,
243     void *client_data, time_t timeout)
244     {
245     int new_events = 0;
246    
247     if ((type & COMM_SELECT_READ))
248     {
249     F->read_handler = handler;
250     F->read_data = client_data;
251     }
252    
253     if ((type & COMM_SELECT_WRITE))
254     {
255     F->write_handler = handler;
256     F->write_data = client_data;
257     }
258    
259     new_events = (F->read_handler ? (FD_ACCEPT | FD_CLOSE | FD_READ) : 0) |
260     (F->write_handler ? (FD_CONNECT | FD_WRITE) : 0);
261    
262     if (timeout != 0)
263     F->timeout = CurrentTime + (timeout / 1000);
264    
265     if (new_events != F->evcache)
266     {
267     WSAAsyncSelect(F->fd, wndhandle, WM_SOCKET, new_events);
268     F->evcache = new_events;
269     }
270     }
271    
272     /*
273     * Waits until a message is posted in our window queue and deals with it.
274     */
275     void
276     comm_select(void)
277     {
278     MSG msg;
279    
280     if (!GetMessage(&msg, NULL, 0, 0))
281     server_die("WM_QUIT received", NO);
282    
283     set_time();
284    
285     DispatchMessage(&msg);
286     }
287    
288     /* This is our win32 super-light resolver ;) */
289    
290     void
291     delete_resolver_queries(const struct DNSQuery *query)
292     {
293     WSACancelAsyncRequest(query->handle);
294     dlinkDelete(&query->node, &dns_queries);
295     }
296    
297     void
298     gethost_byname_type(const char *name, struct DNSQuery *query, int type)
299     {
300     gethost_byname(name, query);
301     }
302    
303     void
304     gethost_byname(const char *name, struct DNSQuery *query)
305     {
306     query->handle = WSAAsyncGetHostByName(wndhandle, WM_DNS, name, query->reply,
307     sizeof(query->reply));
308    
309     if (!query->handle)
310     query->callback(query->ptr, NULL);
311     else
312     dlinkAdd(query, &query->node, &dns_queries);
313     }
314    
315     void
316     gethost_byaddr(const struct irc_ssaddr *addr, struct DNSQuery *query)
317     {
318     query->handle = WSAAsyncGetHostByAddr(
319     wndhandle, WM_DNS,
320     #ifdef IPV6
321     addr.ss.ss_family == AF_INET6 ? &((struct sockaddr_in6*)addr)->sin6_addr) :
322     #endif
323     &((struct sockaddr_in *) addr)->sin_addr,
324     #ifdef IPV6
325     addr.ss.ss_family == AF_INET6 ? sizeof(struct in6_addr) :
326     #endif
327     sizeof(struct in_addr),
328     addr->ss.ss_family, query->reply, sizeof(query->reply)
329     );
330    
331     if (!query->handle)
332     query->callback(query->ptr, NULL);
333     else
334     dlinkAdd(query, &query->node, &dns_queries);
335     }
336    
337     void
338     report_dns_servers(struct Client *source_p)
339     {
340     FIXED_INFO *FixedInfo;
341     ULONG ulOutBufLen;
342     IP_ADDR_STRING *ip;
343    
344     if (_GetNetworkParams == NULL)
345     return;
346    
347     FixedInfo = MyMalloc(sizeof(FIXED_INFO));
348     ulOutBufLen = sizeof(FIXED_INFO);
349    
350     if (_GetNetworkParams(FixedInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW)
351     {
352     MyFree(FixedInfo);
353     FixedInfo = MyMalloc(ulOutBufLen);
354    
355     if (_GetNetworkParams(FixedInfo, &ulOutBufLen) != ERROR_SUCCESS)
356     return;
357     }
358    
359     for (ip = &FixedInfo->DnsServerList; ip != NULL; ip = ip->Next)
360     sendto_one(source_p, form_str(RPL_STATSALINE), me.name, source_p->name,
361     ip->IpAddress.String);
362    
363     MyFree(FixedInfo);
364     }
365    
366     /* Copyright (C) 2001 Free Software Foundation, Inc.
367     *
368     * Get name and information about current kernel.
369     */
370     int
371     uname(struct utsname *uts)
372     {
373     enum { WinNT, Win95, Win98, WinUnknown };
374     OSVERSIONINFO osver;
375     SYSTEM_INFO sysinfo;
376     DWORD sLength;
377     DWORD os = WinUnknown;
378    
379     memset(uts, 0, sizeof(*uts));
380    
381     osver.dwOSVersionInfoSize = sizeof (osver);
382     GetVersionEx (&osver);
383     GetSystemInfo (&sysinfo);
384    
385     switch (osver.dwPlatformId)
386     {
387     case VER_PLATFORM_WIN32_NT: /* NT, Windows 2000 or Windows XP */
388     if (osver.dwMajorVersion == 4)
389     strcpy (uts->sysname, "Windows NT4x"); /* NT4x */
390     else if (osver.dwMajorVersion <= 3)
391     strcpy (uts->sysname, "Windows NT3x"); /* NT3x */
392     else if (osver.dwMajorVersion == 5 && osver.dwMinorVersion < 1)
393     strcpy (uts->sysname, "Windows 2000"); /* 2k */
394     else if (osver.dwMajorVersion == 5 && osver.dwMinorVersion == 2)
395     strcpy (uts->sysname, "Windows 2003"); /* 2003 */
396     else if (osver.dwMajorVersion == 5 && osver.dwMinorVersion == 1)
397     strcpy (uts->sysname, "Windows XP"); /* XP */
398     os = WinNT;
399     break;
400    
401     case VER_PLATFORM_WIN32_WINDOWS: /* Win95, Win98 or WinME */
402     if ((osver.dwMajorVersion > 4) ||
403     ((osver.dwMajorVersion == 4) && (osver.dwMinorVersion > 0)))
404     {
405     if (osver.dwMinorVersion >= 90)
406     strcpy (uts->sysname, "Windows ME"); /* ME */
407     else
408     strcpy (uts->sysname, "Windows 98"); /* 98 */
409     os = Win98;
410     }
411     else
412     {
413     strcpy (uts->sysname, "Windows 95"); /* 95 */
414     os = Win95;
415     }
416     break;
417    
418     case VER_PLATFORM_WIN32s: /* Windows 3.x */
419     strcpy (uts->sysname, "Windows");
420     break;
421     }
422    
423     sprintf (uts->version, "%ld.%02ld",
424     osver.dwMajorVersion, osver.dwMinorVersion);
425    
426     if (osver.szCSDVersion[0] != '\0' &&
427     (strlen (osver.szCSDVersion) + strlen (uts->version) + 1) <
428     sizeof (uts->version))
429     {
430     strcat (uts->version, " ");
431     strcat (uts->version, osver.szCSDVersion);
432     }
433    
434     sprintf (uts->release, "build %ld", osver.dwBuildNumber & 0xFFFF);
435    
436     switch (sysinfo.wProcessorArchitecture)
437     {
438     case PROCESSOR_ARCHITECTURE_PPC:
439     strcpy (uts->machine, "ppc");
440     break;
441     case PROCESSOR_ARCHITECTURE_ALPHA:
442     strcpy (uts->machine, "alpha");
443     break;
444     case PROCESSOR_ARCHITECTURE_MIPS:
445     strcpy (uts->machine, "mips");
446     break;
447     case PROCESSOR_ARCHITECTURE_INTEL:
448     /*
449     * dwProcessorType is only valid in Win95 and Win98 and WinME
450     * wProcessorLevel is only valid in WinNT
451     */
452     switch (os)
453     {
454     case Win95:
455     case Win98:
456     switch (sysinfo.dwProcessorType)
457     {
458     case PROCESSOR_INTEL_386:
459     case PROCESSOR_INTEL_486:
460     case PROCESSOR_INTEL_PENTIUM:
461     sprintf (uts->machine, "i%ld", sysinfo.dwProcessorType);
462     break;
463     default:
464     strcpy (uts->machine, "i386");
465     break;
466     }
467     break;
468     case WinNT:
469     switch(sysinfo.wProcessorArchitecture)
470     {
471     case PROCESSOR_ARCHITECTURE_INTEL:
472     sprintf (uts->machine, "x86(%d)", sysinfo.wProcessorLevel);
473     break;
474     case PROCESSOR_ARCHITECTURE_IA64:
475     sprintf (uts->machine, "ia64(%d)", sysinfo.wProcessorLevel);
476     break;
477     #ifdef PROCESSOR_ARCHITECTURE_AMD64
478     case PROCESSOR_ARCHITECTURE_AMD64:
479     sprintf (uts->machine, "x86_64(%d)", sysinfo.wProcessorLevel);
480     break;
481     #endif
482     default:
483     sprintf (uts->machine, "unknown(%d)", sysinfo.wProcessorLevel);
484     break;
485     }
486     break;
487     default:
488     strcpy (uts->machine, "unknown");
489     break;
490     }
491     break;
492     default:
493     strcpy (uts->machine, "unknown");
494     break;
495     }
496    
497     sLength = sizeof (uts->nodename) - 1;
498     GetComputerName (uts->nodename, &sLength);
499     return 0;
500     }

Properties

Name Value
svn:eol-style native
svn:keywords Id Revision

svnadmin@ircd-hybrid.org
ViewVC Help
Powered by ViewVC 1.1.28