main.c@ 244

Visit:

Last change on this file since 244 was 244, checked in by Nishi, on Oct 4, 2024 at 5:04:15 AM
adding gui manager
Property svn:keywords set to `Id`
File size: 18.9 KB

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

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

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

Download in other formats: