server/server/win32.C

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 1992 Frank Tore Johansen

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    The author can be reached via e-mail to frankj@ifi.uio.no.
*/

#include <global.h>

#include <stdarg.h>
#include <malloc.h>
#include <string.h>
#include <errno.h>
#include <mmsystem.h>

struct timezone {
        int tz_minuteswest;
        int tz_dsttime;
};


struct itimerval {
        struct timeval it_interval;     /* next value */
        struct timeval it_value;        /* current value */
};

#define ITIMER_REAL    0                /*generates sigalrm */
#define ITIMER_VIRTUAL 1                /*generates sigvtalrm */
#define ITIMER_VIRT    1                /*generates sigvtalrm */
#define ITIMER_PROF    2                /*generates sigprof */


/* Functions to capsule or serve linux style function
 * for Windows Visual C++ 
*/
int gettimeofday(struct timeval *time_Info, struct timezone *timezone_Info)
{
        /* Get the time, if they want it */
        if (time_Info != NULL) {
                time_Info->tv_sec = time(NULL);
                time_Info->tv_usec = timeGetTime()*1000;
        }
        /* Get the timezone, if they want it */
        if (timezone_Info != NULL) {
                _tzset();
                timezone_Info->tz_minuteswest = _timezone;
                timezone_Info->tz_dsttime = _daylight;
        }
        /* And return */
        return 0;
}

DIR *opendir(const char *dir)
{
        DIR *dp;
        char *filespec;
        long handle;
        int index;

        filespec = malloc(strlen(dir) + 2 + 1);
        strcpy(filespec, dir);
        index = strlen(filespec) - 1;
        if (index >= 0 && (filespec[index] == '/' || filespec[index] == '\\'))
                filespec[index] = '\0';
        strcat(filespec, "/*");

        dp = (DIR *) malloc(sizeof(DIR));
        dp->offset = 0;
        dp->finished = 0;
        dp->dir = strdup(dir);

        if ((handle = _findfirst(filespec, &(dp->fileinfo))) < 0) {
                free(filespec); free(dp);
                return NULL;
        }
        dp->handle = handle;
        free(filespec);

        return dp;
}

struct dirent *readdir(DIR * dp)
{
        if (!dp || dp->finished)
                return NULL;

        if (dp->offset != 0) {
                if (_findnext(dp->handle, &(dp->fileinfo)) < 0) {
                        dp->finished = 1;
      if (ENOENT == errno)
        /* Clear error set to mean no more files else that breaks things */
        errno = 0;
                        return NULL;
                }
        }
        dp->offset++;

        strncpy(dp->dent.d_name, dp->fileinfo.name, _MAX_FNAME);
        dp->dent.d_name[_MAX_FNAME] = '\0';
        dp->dent.d_ino = 1;
  /* reclen is used as meaning the length of the whole record */
        dp->dent.d_reclen = strlen(dp->dent.d_name) + sizeof(char) + sizeof(dp->dent.d_ino) + sizeof(dp->dent.d_reclen) + sizeof(dp->dent.d_off);
        dp->dent.d_off = dp->offset;

        return &(dp->dent);
}

int closedir(DIR * dp)
{
        if (!dp)
                return 0;
        _findclose(dp->handle);
        if (dp->dir)
                free(dp->dir);
        if (dp)
                free(dp);

        return 0;
}

void rewinddir(DIR *dir_Info)
{
        /* Re-set to the beginning */
        char *filespec;
        long handle;
        int index;

        dir_Info->handle = 0;
        dir_Info->offset = 0;
        dir_Info->finished = 0;

        filespec = malloc(strlen(dir_Info->dir) + 2 + 1);
        strcpy(filespec, dir_Info->dir);
        index = strlen(filespec) - 1;
        if (index >= 0 && (filespec[index] == '/' || filespec[index] == '\\'))
                filespec[index] = '\0';
        strcat(filespec, "/*");

        if ((handle = _findfirst(filespec, &(dir_Info->fileinfo))) < 0) {
                if (errno == ENOENT) {
                        dir_Info->finished = 1;
                }
        }
        dir_Info->handle = handle;
        free(filespec);
}

/* Service-related stuff

  Those functions are called while init is still being done, so no logging available.

  Not useful for plugins, though.

 */

int bRunning;

#ifndef PYTHON_PLUGIN_EXPORTS

SERVICE_STATUS m_ServiceStatus;
SERVICE_STATUS_HANDLE m_ServiceStatusHandle;
#define SERVICE_NAME        "Crossfire"
#define SERVICE_DISPLAY     "Crossfire server"
#define SERVICE_DESCRIPTION "Crossfire is a multiplayer online RPG game."

#include <winsvc.h>

void service_register( )
    {
        char strDir[ 1024 ];
        HANDLE schSCManager,schService;
    char* strDescription = SERVICE_DESCRIPTION;

        GetModuleFileName( NULL, strDir, 1024 );
    strcat( strDir, " -srv" );

        schSCManager = OpenSCManager( NULL,NULL,SC_MANAGER_ALL_ACCESS );
 
        if (schSCManager == NULL)
        {
        printf( "openscmanager failed" );
                exit( 1 );
        }

    schService = CreateService(schSCManager, SERVICE_NAME, SERVICE_DISPLAY,           // service name to display 
        SERVICE_ALL_ACCESS,        // desired access 
        SERVICE_WIN32_OWN_PROCESS, // service type 
        SERVICE_DEMAND_START,      // start type 
        SERVICE_ERROR_NORMAL,      // error control type 
        strDir,        // service's binary 
        NULL,                      // no load ordering group 
        NULL,                      // no tag identifier 
        NULL,                      // no dependencies 
        NULL,                      // LocalSystem account 
        NULL);                     // no password 
 
    if (schService == NULL) 
        {
        printf( "createservice failed" );
        exit( 1 );
        }

    ChangeServiceConfig2( schService, SERVICE_CONFIG_DESCRIPTION, &strDescription );

    CloseServiceHandle(schService);
    CloseServiceHandle( schSCManager );
    exit( 0 );
    }

void service_unregister( )
    {
        HANDLE schSCManager;
        SC_HANDLE hService;

        schSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
 
        if (schSCManager == NULL)
        {
        printf( "open failed" );
                exit( 1 );
        }

        hService=OpenService(schSCManager, SERVICE_NAME, SERVICE_ALL_ACCESS);

        if (hService == NULL) 
        {
        printf( "openservice failed" );
                exit( 1 );
        }

        if(DeleteService(hService)==0)
        {
        printf( "Delete failed" );
                exit( 1 );
        }

        if(CloseServiceHandle(hService)==0)
        {
        printf( "close failed" );
                exit( 1 );
        }

    if ( !CloseServiceHandle( schSCManager ) )
        {
        printf( "close schSCManager failed" );
        exit( 1 );
        }

    exit( 0 );
    }

void WINAPI ServiceCtrlHandler(DWORD Opcode)
    {
    switch(Opcode) 
        {
        case SERVICE_CONTROL_PAUSE: 
            m_ServiceStatus.dwCurrentState = SERVICE_PAUSED; 
            break; 
 
        case SERVICE_CONTROL_CONTINUE: 
            m_ServiceStatus.dwCurrentState = SERVICE_RUNNING; 
            break; 

        case SERVICE_CONTROL_STOP: 
            m_ServiceStatus.dwWin32ExitCode = 0; 
            m_ServiceStatus.dwCurrentState  = SERVICE_STOPPED; 
            m_ServiceStatus.dwCheckPoint    = 0; 
            m_ServiceStatus.dwWaitHint      = 0; 
 
            SetServiceStatus (m_ServiceStatusHandle,&m_ServiceStatus);

                        bRunning = 0;

            LOG( llevInfo, "Service stopped.\n" );

                        break;
 
        case SERVICE_CONTROL_INTERROGATE: 
            break; 
        }      
    return; 
    }

extern int main( int argc, char** argv );

void WINAPI ServiceMain(DWORD argc, LPTSTR *argv)
    {
        char strDir[ 1024 ];
    char* strSlash;

        GetModuleFileName( NULL, strDir, 1024 );
    strSlash = strrchr( strDir, '\\' );
    if ( strSlash )
        *strSlash = '\0';
    chdir( strDir );

    m_ServiceStatus.dwServiceType        = SERVICE_WIN32; 
    m_ServiceStatus.dwCurrentState       = SERVICE_START_PENDING; 
    m_ServiceStatus.dwControlsAccepted   = SERVICE_ACCEPT_STOP; 
    m_ServiceStatus.dwWin32ExitCode      = 0; 
    m_ServiceStatus.dwServiceSpecificExitCode = 0; 
    m_ServiceStatus.dwCheckPoint         = 0; 
    m_ServiceStatus.dwWaitHint           = 0; 
 
    m_ServiceStatusHandle = RegisterServiceCtrlHandler( SERVICE_NAME, ServiceCtrlHandler );
    if (m_ServiceStatusHandle == (SERVICE_STATUS_HANDLE)0) 
        { 
        return; 
        }     

    m_ServiceStatus.dwCurrentState       = SERVICE_RUNNING; 
    m_ServiceStatus.dwCheckPoint         = 0; 
    m_ServiceStatus.dwWaitHint           = 0;  
    SetServiceStatus (m_ServiceStatusHandle, &m_ServiceStatus);

    bRunning = 1;
    main( 0, NULL );

    return;
    }

void service_handle( )
    {
    SERVICE_TABLE_ENTRY DispatchTable[ ] = { { SERVICE_NAME, ServiceMain },{ NULL, NULL } };  
        StartServiceCtrlDispatcher( DispatchTable );
    exit( 0 );
    }
#endif /* PYTHON_PLUGIN_EXPORTS */
Revision:	1.3
Committed:	Fri Sep 8 04:05:11 2006 UTC (17 years, 8 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.2:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	removed more win32-only stuff
#	Content
1	/*
2	CrossFire, A Multiplayer game for X-windows
3
4	Copyright (C) 1992 Frank Tore Johansen
5
6	This program is free software; you can redistribute it and/or modify
7	it under the terms of the GNU General Public License as published by
8	the Free Software Foundation; either version 2 of the License, or
9	(at your option) any later version.
10
11	This program is distributed in the hope that it will be useful,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	GNU General Public License for more details.
15
16	You should have received a copy of the GNU General Public License
17	along with this program; if not, write to the Free Software
18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19
20	The author can be reached via e-mail to frankj@ifi.uio.no.
21	*/
22
23	#include <global.h>
24
25	#include <stdarg.h>
26	#include <malloc.h>
27	#include <string.h>
28	#include <errno.h>
29	#include <mmsystem.h>
30
31	struct timezone {
32	int tz_minuteswest;
33	int tz_dsttime;
34	};
35
36
37	struct itimerval {
38	struct timeval it_interval; /* next value */
39	struct timeval it_value; /* current value */
40	};
41
42	#define ITIMER_REAL 0 /generates sigalrm /
43	#define ITIMER_VIRTUAL 1 /generates sigvtalrm /
44	#define ITIMER_VIRT 1 /generates sigvtalrm /
45	#define ITIMER_PROF 2 /generates sigprof /
46
47
48	/* Functions to capsule or serve linux style function
49	* for Windows Visual C++
50	*/
51	int gettimeofday(struct timeval time_Info, struct timezone timezone_Info)
52	{
53	/* Get the time, if they want it */
54	if (time_Info != NULL) {
55	time_Info->tv_sec = time(NULL);
56	time_Info->tv_usec = timeGetTime()*1000;
57	}
58	/* Get the timezone, if they want it */
59	if (timezone_Info != NULL) {
60	_tzset();
61	timezone_Info->tz_minuteswest = _timezone;
62	timezone_Info->tz_dsttime = _daylight;
63	}
64	/* And return */
65	return 0;
66	}
67
68	DIR opendir(const char dir)
69	{
70	DIR *dp;
71	char *filespec;
72	long handle;
73	int index;
74
75	filespec = malloc(strlen(dir) + 2 + 1);
76	strcpy(filespec, dir);
77	index = strlen(filespec) - 1;
78	if (index >= 0 && (filespec[index] == '/' \|\| filespec[index] == '\\'))
79	filespec[index] = '\0';
80	strcat(filespec, "/*");
81
82	dp = (DIR *) malloc(sizeof(DIR));
83	dp->offset = 0;
84	dp->finished = 0;
85	dp->dir = strdup(dir);
86
87	if ((handle = _findfirst(filespec, &(dp->fileinfo))) < 0) {
88	free(filespec); free(dp);
89	return NULL;
90	}
91	dp->handle = handle;
92	free(filespec);
93
94	return dp;
95	}
96
97	struct dirent readdir(DIR dp)
98	{
99	if (!dp \|\| dp->finished)
100	return NULL;
101
102	if (dp->offset != 0) {
103	if (_findnext(dp->handle, &(dp->fileinfo)) < 0) {
104	dp->finished = 1;
105	if (ENOENT == errno)
106	/* Clear error set to mean no more files else that breaks things */
107	errno = 0;
108	return NULL;
109	}
110	}
111	dp->offset++;
112
113	strncpy(dp->dent.d_name, dp->fileinfo.name, _MAX_FNAME);
114	dp->dent.d_name[_MAX_FNAME] = '\0';
115	dp->dent.d_ino = 1;
116	/* reclen is used as meaning the length of the whole record */
117	dp->dent.d_reclen = strlen(dp->dent.d_name) + sizeof(char) + sizeof(dp->dent.d_ino) + sizeof(dp->dent.d_reclen) + sizeof(dp->dent.d_off);
118	dp->dent.d_off = dp->offset;
119
120	return &(dp->dent);
121	}
122
123	int closedir(DIR * dp)
124	{
125	if (!dp)
126	return 0;
127	_findclose(dp->handle);
128	if (dp->dir)
129	free(dp->dir);
130	if (dp)
131	free(dp);
132
133	return 0;
134	}
135
136	void rewinddir(DIR *dir_Info)
137	{
138	/* Re-set to the beginning */
139	char *filespec;
140	long handle;
141	int index;
142
143	dir_Info->handle = 0;
144	dir_Info->offset = 0;
145	dir_Info->finished = 0;
146
147	filespec = malloc(strlen(dir_Info->dir) + 2 + 1);
148	strcpy(filespec, dir_Info->dir);
149	index = strlen(filespec) - 1;
150	if (index >= 0 && (filespec[index] == '/' \|\| filespec[index] == '\\'))
151	filespec[index] = '\0';
152	strcat(filespec, "/*");
153
154	if ((handle = _findfirst(filespec, &(dir_Info->fileinfo))) < 0) {
155	if (errno == ENOENT) {
156	dir_Info->finished = 1;
157	}
158	}
159	dir_Info->handle = handle;
160	free(filespec);
161	}
162
163	/* Service-related stuff
164
165	Those functions are called while init is still being done, so no logging available.
166
167	Not useful for plugins, though.
168
169	*/
170
171	int bRunning;
172
173	#ifndef PYTHON_PLUGIN_EXPORTS
174
175	SERVICE_STATUS m_ServiceStatus;
176	SERVICE_STATUS_HANDLE m_ServiceStatusHandle;
177	#define SERVICE_NAME "Crossfire"
178	#define SERVICE_DISPLAY "Crossfire server"
179	#define SERVICE_DESCRIPTION "Crossfire is a multiplayer online RPG game."
180
181	#include <winsvc.h>
182
183	void service_register( )
184	{
185	char strDir[ 1024 ];
186	HANDLE schSCManager,schService;
187	char* strDescription = SERVICE_DESCRIPTION;
188
189	GetModuleFileName( NULL, strDir, 1024 );
190	strcat( strDir, " -srv" );
191
192	schSCManager = OpenSCManager( NULL,NULL,SC_MANAGER_ALL_ACCESS );
193
194	if (schSCManager == NULL)
195	{
196	printf( "openscmanager failed" );
197	exit( 1 );
198	}
199
200	schService = CreateService(schSCManager, SERVICE_NAME, SERVICE_DISPLAY, // service name to display
201	SERVICE_ALL_ACCESS, // desired access
202	SERVICE_WIN32_OWN_PROCESS, // service type
203	SERVICE_DEMAND_START, // start type
204	SERVICE_ERROR_NORMAL, // error control type
205	strDir, // service's binary
206	NULL, // no load ordering group
207	NULL, // no tag identifier
208	NULL, // no dependencies
209	NULL, // LocalSystem account
210	NULL); // no password
211
212	if (schService == NULL)
213	{
214	printf( "createservice failed" );
215	exit( 1 );
216	}
217
218	ChangeServiceConfig2( schService, SERVICE_CONFIG_DESCRIPTION, &strDescription );
219
220	CloseServiceHandle(schService);
221	CloseServiceHandle( schSCManager );
222	exit( 0 );
223	}
224
225	void service_unregister( )
226	{
227	HANDLE schSCManager;
228	SC_HANDLE hService;
229
230	schSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
231
232	if (schSCManager == NULL)
233	{
234	printf( "open failed" );
235	exit( 1 );
236	}
237
238	hService=OpenService(schSCManager, SERVICE_NAME, SERVICE_ALL_ACCESS);
239
240	if (hService == NULL)
241	{
242	printf( "openservice failed" );
243	exit( 1 );
244	}
245
246	if(DeleteService(hService)==0)
247	{
248	printf( "Delete failed" );
249	exit( 1 );
250	}
251
252	if(CloseServiceHandle(hService)==0)
253	{
254	printf( "close failed" );
255	exit( 1 );
256	}
257
258	if ( !CloseServiceHandle( schSCManager ) )
259	{
260	printf( "close schSCManager failed" );
261	exit( 1 );
262	}
263
264	exit( 0 );
265	}
266
267	void WINAPI ServiceCtrlHandler(DWORD Opcode)
268	{
269	switch(Opcode)
270	{
271	case SERVICE_CONTROL_PAUSE:
272	m_ServiceStatus.dwCurrentState = SERVICE_PAUSED;
273	break;
274
275	case SERVICE_CONTROL_CONTINUE:
276	m_ServiceStatus.dwCurrentState = SERVICE_RUNNING;
277	break;
278
279	case SERVICE_CONTROL_STOP:
280	m_ServiceStatus.dwWin32ExitCode = 0;
281	m_ServiceStatus.dwCurrentState = SERVICE_STOPPED;
282	m_ServiceStatus.dwCheckPoint = 0;
283	m_ServiceStatus.dwWaitHint = 0;
284
285	SetServiceStatus (m_ServiceStatusHandle,&m_ServiceStatus);
286
287	bRunning = 0;
288
289	LOG( llevInfo, "Service stopped.\n" );
290
291	break;
292
293	case SERVICE_CONTROL_INTERROGATE:
294	break;
295	}
296	return;
297	}
298
299	extern int main( int argc, char** argv );
300
301	void WINAPI ServiceMain(DWORD argc, LPTSTR *argv)
302	{
303	char strDir[ 1024 ];
304	char* strSlash;
305
306	GetModuleFileName( NULL, strDir, 1024 );
307	strSlash = strrchr( strDir, '\\' );
308	if ( strSlash )
309	*strSlash = '\0';
310	chdir( strDir );
311
312	m_ServiceStatus.dwServiceType = SERVICE_WIN32;
313	m_ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
314	m_ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
315	m_ServiceStatus.dwWin32ExitCode = 0;
316	m_ServiceStatus.dwServiceSpecificExitCode = 0;
317	m_ServiceStatus.dwCheckPoint = 0;
318	m_ServiceStatus.dwWaitHint = 0;
319
320	m_ServiceStatusHandle = RegisterServiceCtrlHandler( SERVICE_NAME, ServiceCtrlHandler );
321	if (m_ServiceStatusHandle == (SERVICE_STATUS_HANDLE)0)
322	{
323	return;
324	}
325
326	m_ServiceStatus.dwCurrentState = SERVICE_RUNNING;
327	m_ServiceStatus.dwCheckPoint = 0;
328	m_ServiceStatus.dwWaitHint = 0;
329	SetServiceStatus (m_ServiceStatusHandle, &m_ServiceStatus);
330
331	bRunning = 1;
332	main( 0, NULL );
333
334	return;
335	}
336
337	void service_handle( )
338	{
339	SERVICE_TABLE_ENTRY DispatchTable[ ] = { { SERVICE_NAME, ServiceMain },{ NULL, NULL } };
340	StartServiceCtrlDispatcher( DispatchTable );
341	exit( 0 );
342	}
343	#endif /* PYTHON_PLUGIN_EXPORTS */