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

Last change on this file since 314 was 312, checked in by Nishi, on Oct 14, 2024 at 3:17:37 AM

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