main.c@ 301

Visit:

Last change on this file since 301 was 301, checked in by Nishi, on Oct 10, 2024 at 11:06:20 AM
fix compat headers
Property svn:keywords set to `Id`
File size: 19.0 KB

Line
1	/* $Id: main.c 301 2024-10-10 02:06:20Z nishi $ */
2
3	#define SOURCE
4
5	#include "../config.h"
6
7	#ifdef __BORLANDC__
8
9	#pragma resource "gui_bcc.res"
10
11	#endif
12
13	#if !defined(_MSC_VER) && !defined(__BORLANDC__)
14	#include <unistd.h>
15	#endif
16	#include <stdio.h>
17	#include <stdbool.h>
18	#include <string.h>
19	#include <signal.h>
20	#include <stdlib.h>
21
22	#ifndef NO_SSL
23	#include <openssl/opensslv.h>
24	#endif
25
26	#include <cm_log.h>
27	#include <cm_string.h>
28
29	#include "tw_config.h"
30	#include "tw_server.h"
31	#include "tw_version.h"
32
33	#if defined(__MINGW32__) \|\| defined(_MSC_VER) \|\| defined(__BORLANDC__) \|\| defined(__WATCOMC__)
34	#include <windows.h>
35	#endif
36
37	#ifdef _PSP
38	#include <pspkernel.h>
39	#include <pspdebug.h>
40	#include <pspsdk.h>
41	#include <psputility.h>
42	#include <pspctrl.h>
43	#include <pspnet_apctl.h>
44	#include <pspwlan.h>
45
46	PSP_MODULE_INFO("Tewi HTTPd", PSP_MODULE_USER, 1, 1);
47	PSP_MAIN_THREAD_ATTR(PSP_THREAD_ATTR_USER);
48
49	#define printf(...) pspDebugScreenPrintf(__VA_ARGS__)
50	#define STDERR_LOG(...) pspDebugScreenPrintf(__VA_ARGS__)
51	#elif defined(__ps2sdk__)
52	#include <debug.h>
53	#include <iopcontrol.h>
54	#include <sifrpc.h>
55	#include <kernel.h>
56
57	#define printf(...) scr_printf(__VA_ARGS__)
58	#define STDERR_LOG(...) scr_printf(__VA_ARGS__)
59	#elif defined(__PPU__)
60	#include <rsx/gcm_sys.h>
61	#include <rsx/rsx.h>
62	#include <sysutil/video.h>
63	#include <malloc.h>
64	#include <sys/thread.h>
65	#include <stdarg.h>
66	#include <png.h>
67
68	#define printf(...) tt_printf(__VA_ARGS__)
69	#define STDERR_LOG(...) tt_printf(__VA_ARGS__)
70	#elif defined(_MSC_VER) \|\| defined(__BORLANDC__) \|\| defined(__USLC__)
71	#include <stdarg.h>
72
73	void STDERR_LOG(const char* format, ...) {
74	va_list args;
75	va_start(args, format);
76	vfprintf(stderr, format, args);
77	va_end(args);
78	}
79	#else
80	#define STDERR_LOG(...) fprintf(stderr, __VA_ARGS__)
81	#endif
82
83	extern bool cm_do_log;
84	extern struct tw_config config;
85	extern FILE* logfile;
86
87	char tw_server[2048];
88
89	int startup(int argc, char** argv);
90
91	#if defined(__MINGW32__) \|\| defined(_MSC_VER) \|\| defined(__WATCOMC__) \|\| defined(__BORLANDC__)
92	char* get_registry(const char* main, const char* sub) {
93	DWORD bufsize = 512;
94	HKEY handle;
95	char* value = malloc(513);
96	int err = RegOpenKeyEx(HKEY_LOCAL_MACHINE, main, 0, KEY_QUERY_VALUE, &handle);
97	if(err == ERROR_SUCCESS) {
98	err = RegQueryValueEx(handle, sub, NULL, NULL, value, &bufsize);
99	if(err != ERROR_SUCCESS) {
100	free(value);
101	RegCloseKey(handle);
102	return NULL;
103	}
104	RegCloseKey(handle);
105	return value;
106	} else {
107	free(value);
108	return NULL;
109	}
110	}
111	#endif
112
113	#ifdef SERVICE
114	SERVICE_STATUS status;
115	SERVICE_STATUS_HANDLE status_handle;
116
117	void WINAPI servhandler(DWORD control) {
118	switch(control) {
119	case SERVICE_CONTROL_STOP:
120	case SERVICE_CONTROL_SHUTDOWN:
121	status.dwCurrentState = SERVICE_STOP_PENDING;
122	break;
123	}
124	SetServiceStatus(status_handle, &status);
125	}
126
127	void WINAPI servmain(DWORD argc, LPSTR* argv) {
128	char* path = get_registry("Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Tewi HTTPd", "InstallDir");
129	int st;
130	if(path != NULL) {
131	char* lpath = cm_strcat(path, "/logs/tewi.log");
132	logfile = fopen(lpath, "a");
133	free(lpath);
134	free(path);
135	} else {
136	logfile = fopen(PREFIX "/logs/tewi.log", "a");
137	}
138	if(logfile == NULL) logfile = stderr;
139	status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
140	status.dwCurrentState = SERVICE_START_PENDING;
141	status.dwControlsAccepted = SERVICE_ACCEPT_STOP \| SERVICE_ACCEPT_SHUTDOWN;
142	status.dwWin32ExitCode = NO_ERROR;
143	status.dwServiceSpecificExitCode = 0;
144	status.dwCheckPoint = 0;
145	status.dwWaitHint = 0;
146	status_handle = RegisterServiceCtrlHandler("Tewi HTTPd", servhandler);
147	if(status_handle == NULL) return;
148	if(SetServiceStatus(status_handle, &status) == 0) return;
149	st = startup(argc, argv);
150	if(st != -1) {
151	status.dwWin32ExitCode = NO_ERROR;
152	status.dwServiceSpecificExitCode = st;
153	status.dwCurrentState = SERVICE_STOPPED;
154	SetServiceStatus(status_handle, &status);
155	return;
156	}
157	status.dwCurrentState = SERVICE_RUNNING;
158	SetServiceStatus(status_handle, &status);
159	tw_server_loop();
160	status.dwCurrentState = SERVICE_STOPPED;
161	SetServiceStatus(status_handle, &status);
162	}
163	#endif
164
165	int running = 1;
166	#ifdef _PSP
167
168	int psp_exit_callback(int arg1, int arg2, void* arg3) { running = 0; }
169
170	int psp_callback_thread(SceSize args, void* argp) {
171	int cid;
172	cid = sceKernelCreateCallback("Exit Call Back", psp_exit_callback, NULL);
173	sceKernelRegisterExitCallback(cid);
174	sceKernelSleepThreadCB();
175	return 0;
176	}
177	#endif
178
179	#ifdef __PPU__
180	uint32_t depth_pitch;
181	uint32_t depth_offset;
182	uint32_t* depth_buffer;
183
184	#define CB_SIZE 0x100000
185	#define HOST_SIZE (32 * 1024 * 1024)
186
187	struct rsx_buffer {
188	int width, height, id;
189	uint32_t* ptr;
190	uint32_t offset;
191	};
192
193	void wait_rsx(gcmContextData* ctx, uint32_t label) {
194	rsxSetWriteBackendLabel(ctx, GCM_INDEX_TYPE_32B, label);
195
196	rsxFlushBuffer(ctx);
197
198	while((uint32_t)gcmGetLabelAddress(GCM_INDEX_TYPE_32B) != label) usleep(50);
199
200	label++;
201	}
202
203	void wait_rsx_until_idle(gcmContextData* ctx) {
204	uint32_t label = 1;
205	rsxSetWriteBackendLabel(ctx, GCM_INDEX_TYPE_32B, label);
206	rsxSetWaitLabel(ctx, GCM_INDEX_TYPE_32B, label);
207	label++;
208	wait_rsx(ctx, label);
209	}
210
211	void get_resolution(int* width, int* height) {
212	videoState state;
213	videoResolution res;
214	if(videoGetState(0, 0, &state) != 0) {
215	return;
216	}
217
218	if(state.state != 0) {
219	return;
220	}
221
222	if(videoGetResolution(state.displayMode.resolution, &res) != 0) {
223	return;
224	}
225	*width = res.width;
226	*height = res.height;
227	}
228
229	void make_buffer(struct rsx_buffer* buffer, int id) {
230	int w, h;
231	get_resolution(&w, &h);
232
233	buffer->ptr = (uint32_t)rsxMemalign(64, 4 w * h);
234	if(buffer->ptr == NULL) return;
235
236	if(rsxAddressToOffset(buffer->ptr, &buffer->offset) != 0) return;
237
238	if(gcmSetDisplayBuffer(id, buffer->offset, 4 * w, w, h) != 0) return;
239	buffer->width = w;
240	buffer->height = h;
241	buffer->id = id;
242	}
243
244	gcmContextData* init_screen(void) {
245	void* host = memalign(1024 * 1024, HOST_SIZE);
246	gcmContextData* ctx = NULL;
247	videoState state;
248	videoConfiguration vconfig;
249	videoResolution res;
250	rsxInit(&ctx, CB_SIZE, HOST_SIZE, host);
251	if(ctx == NULL) {
252	free(host);
253	return NULL;
254	}
255
256	if(videoGetState(0, 0, &state) != 0) {
257	rsxFinish(ctx, 0);
258	free(host);
259	return NULL;
260	}
261
262	if(state.state != 0) {
263	rsxFinish(ctx, 0);
264	free(host);
265	return NULL;
266	}
267
268	if(videoGetResolution(state.displayMode.resolution, &res) != 0) {
269	rsxFinish(ctx, 0);
270	free(host);
271	return NULL;
272	}
273
274	memset(&vconfig, 0, sizeof(vconfig));
275	vconfig.resolution = state.displayMode.resolution;
276	vconfig.format = VIDEO_BUFFER_FORMAT_XRGB;
277	vconfig.pitch = res.width * 4;
278	vconfig.aspect = state.displayMode.aspect;
279
280	wait_rsx_until_idle(ctx);
281
282	if(videoConfigure(0, &vconfig, NULL, 0) != 0) {
283	rsxFinish(ctx, 0);
284	free(host);
285	return NULL;
286	}
287
288	if(videoGetState(0, 0, &state) != 0) {
289	rsxFinish(ctx, 0);
290	free(host);
291	return NULL;
292	}
293	gcmSetFlipMode(GCM_FLIP_VSYNC);
294
295	depth_pitch = res.width * 4;
296	depth_buffer = (uint32_t)rsxMemalign(64, (res.height depth_pitch) * 2);
297	rsxAddressToOffset(depth_buffer, &depth_offset);
298
299	gcmResetFlipStatus();
300
301	return ctx;
302	}
303
304	void set_render_target(gcmContextData* context, struct rsx_buffer* buffer) {
305	gcmSurface sf;
306
307	sf.colorFormat = GCM_SURFACE_X8R8G8B8;
308	sf.colorTarget = GCM_SURFACE_TARGET_0;
309	sf.colorLocation[0] = GCM_LOCATION_RSX;
310	sf.colorOffset[0] = buffer->offset;
311	sf.colorPitch[0] = depth_pitch;
312
313	sf.colorLocation[1] = GCM_LOCATION_RSX;
314	sf.colorLocation[2] = GCM_LOCATION_RSX;
315	sf.colorLocation[3] = GCM_LOCATION_RSX;
316	sf.colorOffset[1] = 0;
317	sf.colorOffset[2] = 0;
318	sf.colorOffset[3] = 0;
319	sf.colorPitch[1] = 64;
320	sf.colorPitch[2] = 64;
321	sf.colorPitch[3] = 64;
322
323	sf.depthFormat = GCM_SURFACE_ZETA_Z16;
324	sf.depthLocation = GCM_LOCATION_RSX;
325	sf.depthOffset = depth_offset;
326	sf.depthPitch = depth_pitch;
327
328	sf.type = GCM_TEXTURE_LINEAR;
329	sf.antiAlias = GCM_SURFACE_CENTER_1;
330
331	sf.width = buffer->width;
332	sf.height = buffer->height;
333	sf.x = 0;
334	sf.y = 0;
335
336	rsxSetSurface(context, &sf);
337	}
338
339	void wait_flip(void) {
340	while(gcmGetFlipStatus() != 0) usleep(200);
341	gcmResetFlipStatus();
342	}
343
344	void flip(gcmContextData* ctx, uint32_t buffer) {
345	if(gcmSetFlip(ctx, buffer) == 0) {
346	rsxFlushBuffer(ctx);
347	gcmSetWaitFlip(ctx);
348	}
349	}
350
351	uint8_t* tvram;
352
353	extern uint8_t font[];
354
355	int tt_x = 0;
356	int tt_y = 0;
357	int tt_width;
358	int tt_height;
359
360	void tt_putstr(const char* str) {
361	int i;
362	for(i = 0; str[i] != 0; i++) {
363	tvram[tt_y * tt_width + tt_x] = str[i];
364	if(str[i] == '\n') {
365	tt_x = 0;
366	tt_y++;
367	} else {
368	tt_x++;
369	if(tt_x == tt_width) {
370	tt_x = 0;
371	tt_y++;
372	}
373	}
374	if(tt_y == tt_height) {
375	tt_y--;
376	int x, y;
377	for(y = 0; y < tt_height - 1; y++) {
378	for(x = 0; x < tt_width; x++) {
379	tvram[y * tt_width + x] = tvram[(y + 1) * tt_width + x];
380	}
381	}
382	for(x = 0; x < tt_width; x++) {
383	tvram[(tt_height - 1) * tt_width + x] = 0x20;
384	}
385	}
386	}
387	}
388
389	void tt_putchar(struct rsx_buffer* buffer, int x, int y, uint8_t c) {
390	int i, j;
391	if(c == 0) return;
392	if(c < 0x20) c = 0x20;
393	if(c >= 0x7f) c = 0x20;
394	for(i = 0; i < 8; i++) {
395	uint8_t l = i == 7 ? 0 : font[(c - 0x20) * 8 + i];
396	for(j = 0; j < 6; j++) {
397	uint32_t col = 0;
398	if(l & (1 << 7)) {
399	col = 0xffffff;
400	}
401	l = l << 1;
402	buffer->ptr[(y * 8 + i) * buffer->width + x * 6 + j] = col;
403	}
404	}
405	}
406
407	void draw(struct rsx_buffer* buffer, int current) {
408	int i, j, c;
409	for(i = 0; i < buffer->height / 8; i++) {
410	for(j = 0; j < buffer->width / 6; j++) {
411	uint8_t c = tvram[i * (buffer->width / 6) + j];
412	tt_putchar(buffer, j, i, c);
413	}
414	}
415	}
416
417	#define BUFFERS 1
418	gcmContextData* ctx;
419	struct rsx_buffer buffers[BUFFERS];
420
421	void text_thread(void* arg) {
422	int current = 0;
423	while(1) {
424	wait_flip();
425	draw(&buffers[current], current);
426	flip(ctx, buffers[current].id);
427	current++;
428	if(current >= BUFFERS) current = 0;
429	}
430	}
431
432	void tt_printf(const char* tmpl, ...) {
433	va_list va;
434	va_start(va, tmpl);
435	int i;
436	char cbuf[2];
437	cbuf[1] = 0;
438	char* log = cm_strdup("");
439	for(i = 0; tmpl[i] != 0; i++) {
440	if(tmpl[i] == '%') {
441	i++;
442	if(tmpl[i] == 's') {
443	char* tmp = log;
444	log = cm_strcat(tmp, va_arg(va, char*));
445	free(tmp);
446	} else if(tmpl[i] == 'd') {
447	char buf[513];
448	sprintf(buf, "%d", va_arg(va, int));
449	char* tmp = log;
450	log = cm_strcat(tmp, buf);
451	free(tmp);
452	} else if(tmpl[i] == '%') {
453	char* tmp = log;
454	log = cm_strcat(tmp, "%");
455	free(tmp);
456	}
457	} else {
458	cbuf[0] = tmpl[i];
459	char* tmp = log;
460	log = cm_strcat(tmp, cbuf);
461	free(tmp);
462	}
463	}
464	va_end(va);
465	tt_putstr(log);
466	}
467
468	void show_png(void) {
469	FILE* f = fopen(PREFIX "/pbtewi.png", "rb");
470	if(f == NULL) {
471	f = fopen(PREFIX "/../ICON0.PNG", "rb");
472	}
473	if(f == NULL) return;
474	png_structp png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
475	png_infop info = png_create_info_struct(png);
476	if(setjmp(png_jmpbuf(png))) {
477	png_destroy_read_struct(&png, &info, NULL);
478	fclose(f);
479	return;
480	}
481
482	png_init_io(png, f);
483	png_read_info(png, info);
484
485	int width = png_get_image_width(png, info);
486	int height = png_get_image_height(png, info);
487	int depth = png_get_bit_depth(png, info);
488	int type = png_get_color_type(png, info);
489
490	if(depth == 16) png_set_strip_16(png);
491	if(type == PNG_COLOR_TYPE_PALETTE) png_set_palette_to_rgb(png);
492	if(type == PNG_COLOR_TYPE_GRAY && depth < 8) png_set_expand_gray_1_2_4_to_8(png);
493	if(png_get_valid(png, info, PNG_INFO_tRNS)) png_set_tRNS_to_alpha(png);
494	if(type == PNG_COLOR_TYPE_RGB \|\| type == PNG_COLOR_TYPE_GRAY \|\| type == PNG_COLOR_TYPE_PALETTE) png_set_filler(png, 0xFF, PNG_FILLER_AFTER);
495	if(type == PNG_COLOR_TYPE_GRAY \|\| type == PNG_COLOR_TYPE_GRAY_ALPHA) png_set_gray_to_rgb(png);
496	png_read_update_info(png, info);
497	png_bytep* rows = (png_bytep)malloc(sizeof(rows) * (height));
498
499	int i;
500
501	for(i = 0; i < height; i++) {
502	rows[i] = (png_byte*)malloc(png_get_rowbytes(png, info));
503	}
504
505	png_read_image(png, rows);
506
507	for(i = 0; i < height; i++) {
508	int j;
509	for(j = 0; j < width; j++) {
510	png_bytep byte = &(rows[i][j * 4]);
511	uint32_t col = (byte[0] << 16) \| (byte[1] << 8) \| (byte[2]);
512	int k;
513	for(k = 0; k < BUFFERS; k++) {
514	buffers[k].ptr[buffers[k].width * i - width + j] = col;
515	}
516	}
517	}
518
519	png_destroy_read_struct(&png, &info, NULL);
520	fclose(f);
521
522	for(i = 0; i < height; i++) {
523	free(rows[i]);
524	}
525	free(rows);
526	}
527
528	#endif
529
530	#if !defined(BUILD_GUI_VALID)
531	int main(int argc, char** argv) {
532	int st;
533	#ifdef SERVICE
534	SERVICE_TABLE_ENTRY table[] = {{"Tewi HTTPd", servmain}, {NULL, NULL}};
535	logfile = stderr;
536	if(!StartServiceCtrlDispatcher(table)){
537	printf("Failed to start the service dispatcher\n");
538	return 1;
539	}
540	#else
541	logfile = stderr;
542	#ifdef _PSP
543	pspDebugScreenInit();
544	pspDebugScreenSetXY(0, 0);
545	printf("PSP Bootstrap, Tewi/%s\n", tw_get_version());
546	int thid = sceKernelCreateThread("update_thread", psp_callback_thread, 0x11, 0xfa0, 0, NULL);
547	if(thid >= 0) {
548	sceKernelStartThread(thid, 0, NULL);
549	} else {
550	printf("Failed to start thread\n");
551	while(running) sceKernelDelayThread(50 * 1000);
552	sceKernelExitGame();
553	}
554	sceCtrlSetSamplingCycle(0);
555	sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
556	sceUtilityLoadNetModule(PSP_NET_MODULE_COMMON);
557	sceUtilityLoadNetModule(PSP_NET_MODULE_INET);
558	if(pspSdkInetInit()) {
559	printf("Could not init the network\n");
560	while(running) sceKernelDelayThread(50 * 1000);
561	sceKernelExitGame();
562	} else {
563	printf("Network initialization successful\n");
564	}
565	if(sceWlanGetSwitchState() != 1) {
566	printf("Turn the Wi-Fi switch on\n");
567	while(sceWlanGetSwitchState() != 1) {
568	sceKernelDelayThread(1000 * 1000);
569	}
570	} else {
571	printf("Wi-Fi is turned on\n");
572	}
573	int i;
574	int choice[100];
575	int incr = 0;
576	int last = 0;
577	int cur = 0;
578	for(i = 1; i < 100; i++) {
579	choice[i - 1] = 0;
580	netData name;
581	netData data;
582	if(sceUtilityCheckNetParam(i) != 0) continue;
583	choice[incr++] = i;
584	pspDebugScreenSetXY(0, 1 + 3 + incr - 1);
585	if(incr == 1) printf("> ");
586	pspDebugScreenSetXY(2, 1 + 3 + incr - 1);
587	sceUtilityGetNetParam(i, 0, &name);
588	sceUtilityGetNetParam(i, 1, &data);
589	printf("SSID=%s", data.asString);
590	sceUtilityGetNetParam(i, 4, &data);
591	if(data.asString[0]) {
592	sceUtilityGetNetParam(i, 5, &data);
593	printf(" IPADDR=%s\n", data.asString);
594	} else {
595	printf(" DHCP\n");
596	}
597	}
598	int press = 0;
599	while(1) {
600	if(!running) {
601	sceKernelExitGame();
602	}
603	SceCtrlData c;
604	sceCtrlReadBufferPositive(&c, 1);
605	press = 0;
606	if(c.Buttons & PSP_CTRL_DOWN) {
607	if(cur < incr - 1) {
608	cur++;
609	}
610	press = 1;
611	} else if(c.Buttons & PSP_CTRL_UP) {
612	if(cur > 0) {
613	cur--;
614	}
615	press = -1;
616	} else if(c.Buttons & PSP_CTRL_START) {
617	break;
618	}
619	if(last != cur) {
620	pspDebugScreenSetXY(0, 1 + 3 + last);
621	printf(" ");
622	pspDebugScreenSetXY(0, 1 + 3 + cur);
623	printf("> ");
624	last = cur;
625	}
626	if(press != 0) {
627	while(1) {
628	SceCtrlData c;
629	sceCtrlReadBufferPositive(&c, 1);
630	if(press == 1) {
631	if(!(c.Buttons & PSP_CTRL_DOWN)) break;
632	} else if(press == -1) {
633	if(!(c.Buttons & PSP_CTRL_UP)) break;
634	}
635	}
636	}
637	}
638	pspDebugScreenSetXY(0, 1 + 3 + incr + 1);
639	int err = sceNetApctlConnect(choice[cur]);
640	if(err != 0) {
641	printf("Apctl initialization failure\n");
642	while(running) sceKernelDelayThread(50 * 1000);
643	sceKernelExitGame();
644	} else {
645	printf("Apctl initialization successful\n");
646	}
647	printf("Apctl connecting\n");
648	while(1) {
649	int state;
650	err = sceNetApctlGetState(&state);
651	if(err != 0) {
652	printf("Apctl getting status failure\n");
653	while(running) sceKernelDelayThread(50 * 1000);
654	sceKernelExitGame();
655	}
656	if(state == 4) {
657	break;
658	}
659	sceKernelDelayThread(50 * 1000);
660	}
661	union SceNetApctlInfo info;
662	if(sceNetApctlGetInfo(8, &info) != 0) {
663	printf("Got an unknown IP\n");
664	while(running) sceKernelDelayThread(50 * 1000);
665	sceKernelExitGame();
666	}
667	printf("Connected, My IP is %s\n", info.ip);
668	#elif defined(__PPU__)
669	int i;
670	ctx = init_screen();
671	int w, h;
672	get_resolution(&w, &h);
673	tt_width = w / 6;
674	tt_height = h / 8;
675	tvram = malloc((w / 6) * (h / 8));
676	for(i = 0; i < BUFFERS; i++) make_buffer(&buffers[i], i);
677	flip(ctx, BUFFERS - 1);
678	sys_ppu_thread_t id;
679	sysThreadCreate(&id, text_thread, NULL, 1500, 0x1000, THREAD_JOINABLE, "TextThread");
680	printf("PS3 Bootstrap, Tewi/%s\n", tw_get_version());
681	show_png();
682	netInitialize();
683	#elif defined(__ps2sdk__)
684	SifInitRpc(0);
685	while(!SifIopReset("", 0))
686	;
687	while(!SifIopSync())
688	;
689	init_scr();
690	scr_printf("PS2 Bootstrap, Tewi/%s\n", tw_get_version());
691	SleepThread();
692	#endif
693	st = startup(argc, argv);
694	if(st != -1) {
695	#ifdef _PSP
696	printf("Error code %d\n", st);
697	while(running) sceKernelDelayThread(50 * 1000);
698	sceKernelExitGame();
699	#else
700	#ifdef __PPU__
701	printf("Error code %d\n", st);
702	while(1)
703	;
704	#endif
705	return st;
706	#endif
707	}
708	tw_server_loop();
709	#endif
710	#ifdef _PSP
711	sceKernelExitGame();
712	#endif
713	return 0;
714	}
715	#endif
716
717	int startup(int argc, char** argv) {
718	int i;
719	char* r;
720	#if defined(__MINGW32__) \|\| defined(_MSC_VER) \|\| defined(__WATCOMC__) \|\| defined(__BORLANDC__)
721	char* confpath = cm_strdup(PREFIX "/etc/tewi.conf");
722	char* regpath = get_registry("Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Tewi HTTPd", "InstallDir");
723	if(regpath != NULL) {
724	free(confpath);
725	confpath = cm_strcat(regpath, "/etc/tewi.conf");
726	free(regpath);
727	}
728	#else
729	const char* confpath = PREFIX "/etc/tewi.conf";
730	#endif
731	if(argv != NULL) {
732	for(i = 1; i < argc; i++) {
733	if(argv[i][0] == '-') {
734	if(strcmp(argv[i], "--verbose") == 0 \|\| strcmp(argv[i], "-v") == 0) {
735	if(!cm_do_log) {
736	cm_do_log = true;
737	#ifndef NO_SSL
738	cm_log("", "This is Tewi HTTPd, version %s, using %s", tw_get_version(), OPENSSL_VERSION_TEXT);
739	#else
740	cm_log("", "This is Tewi HTTPd, version %s", tw_get_version());
741	#endif
742	} else {
743	cm_do_log = true;
744	}
745	} else if(strcmp(argv[i], "--config") == 0 \|\| strcmp(argv[i], "-C") == 0) {
746	i++;
747	if(argv[i] == NULL) {
748	STDERR_LOG("Missing argument\n");
749	return 1;
750	}
751	confpath = argv[i];
752	#ifndef _PSP
753	} else if(strcmp(argv[i], "--logfile") == 0 \|\| strcmp(argv[i], "-l") == 0) {
754	i++;
755	if(argv[i] == NULL) {
756	STDERR_LOG("Missing argument\n");
757	return 1;
758	}
759	if(logfile != NULL && logfile != stderr) {
760	fclose(logfile);
761	}
762	logfile = fopen(argv[i], "a");
763	if(logfile == NULL) {
764	STDERR_LOG("Failed to open logfile\n");
765	return 1;
766	}
767	#endif
768	} else if(strcmp(argv[i], "--version") == 0 \|\| strcmp(argv[i], "-V") == 0) {
769	printf("Tewi HTTPd Tewi/%s\n", tw_get_version());
770	printf("Under public domain.\n");
771	printf("Original by 2024 Nishi\n");
772	printf("\n");
773	printf("Usage: %s [--config\|-C config] [--verbose\|-v] [--version\|-V]\n", argv[0]);
774	printf("--config \| -C config : Specify config\n");
775	#ifndef _PSP
776	printf("--logfile \| -l logfile : Specify logfile\n");
777	#endif
778	printf("--verbose \| -v : Verbose mode\n");
779	printf("--version \| -V : Version information\n");
780	return 0;
781	} else {
782	STDERR_LOG("Unknown option: %s\n", argv[i]);
783	return 1;
784	}
785	}
786	}
787	}
788	tw_config_init();
789	if(tw_config_read(confpath) != 0) {
790	STDERR_LOG("Could not read the config\n");
791	return 1;
792	}
793	if(tw_server_init() != 0) {
794	STDERR_LOG("Could not initialize the server\n");
795	return 1;
796	}
797	sprintf(tw_server, "Tewi/%s (%s)%s", tw_get_version(), tw_get_platform(), config.extension == NULL ? "" : config.extension);
798	r = cm_strcat(tw_server, " running...");
799	cm_force_log(r);
800	free(r);
801	#if !defined(__MINGW32__) && !defined(_MSC_VER) && !defined(__BORLANDC__) && !defined(__WATCOMC__)
802	signal(SIGCHLD, SIG_IGN);
803	signal(SIGPIPE, SIG_IGN);
804	#elif !defined(BUILD_GUI)
805	SetConsoleTitle(tw_server);
806	#endif
807	return -1;
808	}

Note: See TracBrowser for help on using the repository browser.

source: Main/trunk/Server/main.c@ 301

Download in other formats: