Kernel/VFS - Added warning (instead of LOG) when GetNodeFromInode is unsupported
[tpg/acess2.git] / Usermode / Applications / init_src / main.c
1 /*
2  * Acess2 System Init Task
3  */
4 #include <acess/sys.h>
5 #include <stdlib.h>
6 #include <stdio.h>
7 #include <string.h>
8 #include "common.h"
9 #include <ctype.h>
10
11 // === CONSTANTS ===
12 #define DEFAULT_SHELL   "/Acess/SBin/login"
13 #define INITTAB_FILE    "/Acess/Conf/inittab"
14
15 #define ARRAY_SIZE(x)   ((sizeof(x))/(sizeof((x)[0])))
16
17 // === PROTOTYPES ===
18  int    ProcessInittab(const char *Path);
19 char    *ReadQuotedString(FILE *FP);
20 char    **ReadCommand(FILE *FP);
21 void    FreeCommand(char **Command);
22
23 tInitProgram    *AllocateProgram(char **Command, enum eProgType Type, size_t ExtraSpace);
24 void    RespawnProgam(tInitProgram *Program);
25
26  int    AddKTerminal(int TerminalSpec, char **Command);
27  int    AddSerialTerminal(const char *DevPathSegment, const char *ModeStr, char **Command);
28  int    AddDaemon(char *StdoutPath, char *StderrPath, char **Command);
29
30  int    SpawnCommand(int c_stdin, int c_stdout, int c_stderr, char **ArgV);
31  int    SpawnKTerm(tInitProgram *Program);
32  int    SpawnSTerm(tInitProgram *Program);
33  int    SpawnDaemon(tInitProgram *Program);
34
35 // === GLOBALS ===
36 const char      *gsInittabPath = INITTAB_FILE;
37 tInitProgram    *gpInitPrograms;
38
39 // === CODE ===
40 /**
41  * \fn int main(int argc, char *argv[])
42  * \brief Entrypoint
43  */
44 int main(int argc, char *argv[])
45 {
46         // Parse commandline args
47         // TODO: cmdline
48
49         // TODO: Behave differently if not invoked as first process?
50
51         // Begin init process
52         if( ProcessInittab(gsInittabPath) != 0 )
53         {
54                 // No inittab file found, default to:
55                 _SysDebug("inittab '%s' is invalid, falling back to one VT", gsInittabPath);
56                 
57                 #if 1
58                 for( ;; )
59                 {
60                         int pid = SpawnCommand(0, 1, 1, (char *[]){DEFAULT_SHELL, NULL});
61                         // TODO: Detect errors
62                         _SysWaitTID(pid, NULL);
63                 }
64                 #else
65                 return 41;
66                 #endif
67         }
68
69         // TODO: Implement message watching
70         for(;;)
71         {
72                  int    pid, status;
73                 pid = _SysWaitTID(-1, &status);
74                 _SysDebug("PID %i died, looking for respawn entry", pid);
75         }
76         
77         return 42;
78 }
79
80 char *ReadQuotedString(FILE *FP)
81 {
82         char    ch;
83         
84         while( isblank(ch = fgetc(FP)) )
85                 ;
86
87         if( ch == '\n' ) {
88                 return NULL;
89         }
90
91         char    *retstr = NULL;
92          int    mode = 0;
93          int    pos = 0, space = 0;
94         for( ; !feof(FP); ch = fgetc(FP) )
95         {
96                  int    skip;
97                 skip = 1;
98                 if( mode & 4 ) {
99                         // Add escaped/special character
100                         skip = 0;
101                         mode &= 3;
102                 }
103                 else if( mode == 0 )
104                 {
105                         if( isspace(ch) ) {
106                                 fseek(FP, -1, SEEK_CUR);
107                                 break;
108                         }
109                         else if( ch == '\\' )
110                                 mode |= 4;
111                         else if( ch == '"' )
112                                 mode = 1;
113                         else if( ch == '\'')
114                                 mode = 2;
115                         else {
116                                 // Add character
117                                 skip = 0;
118                         }
119                 }
120                 // Double-quoted string
121                 else if( mode == 1 )
122                 {
123                         if( ch == '"' )
124                                 mode = 0;
125                         else if( ch == '\\' )
126                                 mode |= 4;
127                         else {
128                                 // Add character
129                                 skip = 0;
130                         }
131                 }
132                 // Single-quoted string
133                 else if( mode == 2 )
134                 {
135                         if( ch == '\'' )
136                                 mode = 0;
137                         else if( ch == '\\' )
138                                 mode |= 4;
139                         else {
140                                 // Add character
141                                 skip = 0;
142                         }
143                 }
144         
145                 if( !skip )
146                 {
147                         if( pos == space ) {
148                                 space += 32;
149                                 void *tmp = realloc(retstr, space+1);
150                                 if( !tmp ) {
151                                         _SysDebug("ReadQuotedString - realloc(%i) failure", space+1);
152                                         free(retstr);
153                                         return NULL;
154                                 }
155                                 retstr = tmp;
156                         }
157                         retstr[pos++] = ch;
158                 }
159         }
160         if( retstr )
161                 retstr[pos] = '\0';
162         return retstr;
163 }
164
165 char **ReadCommand(FILE *FP)
166 {
167         const int       space = 8;
168          int    pos = 0;
169         char    **ret = malloc(space*sizeof(char*));
170         char    *arg;
171         do {
172                 arg = ReadQuotedString(FP);
173                 if(arg == NULL)
174                         break;
175                 if( pos == space - 1 ) {
176                         _SysDebug("Too many arguments %i", pos);
177                         ret[pos] = NULL;
178                         FreeCommand(ret);
179                         return NULL;
180                 }
181                 ret[pos++] = arg;
182         } while(arg != NULL);
183         
184         if( pos == 0 )
185         {
186                 free(ret);
187                 return NULL;
188         }
189         ret[pos] = NULL;
190         return ret;
191 }
192
193 void FreeCommand(char **Command)
194 {
195         int pos = 0;
196         while( Command[pos] )
197         {
198                 free(Command[pos]);
199                 pos ++;
200         }
201         free(Command);
202 }
203
204 int ProcessInittab(const char *Path)
205 {
206          int    line_num = 0;
207         FILE    *fp = fopen(Path, "r");
208
209         if( !fp )
210                 return 1;       
211
212         while(!feof(fp))
213         {
214                 char cmdbuf[64+1];
215                 
216                 line_num ++;
217
218                  int    rv;
219                 if( (rv = fscanf(fp, "%64s%*[ \t]", cmdbuf)) != 1 ) {
220                         _SysDebug("fscanf rv %i != exp 1", rv);
221                         break;
222                 }
223                 
224                 // Clear comments
225                 if( cmdbuf[0] == '#' ) {
226                         while( !feof(fp) && fgetc(fp) != '\n' )
227                                 ;
228                         continue ;
229                 }
230                 if( cmdbuf[0] == '\0' ) {
231                         char    ch = fgetc(fp);
232                         if( ch != '\n' && ch != -1 ) {
233                                 fclose(fp);
234                                 _SysDebug("Unexpected char 0x%x, expecting EOL", ch);
235                                 return 2;       // Unexpected character?
236                         }
237                         continue ;
238                 }
239
240                 // Check commands
241                 if( strcmp(cmdbuf, "ktty") == 0 ) {
242                         // ktty <ID> <command...>
243                         // - Spins off a console on the specified kernel TTY
244                          int    id = 0;
245                         if( fscanf(fp, "%d ", &id) != 1 ) {
246                                 _SysDebug("init[ktty] - TTY ID read failed");
247                                 goto lineError;
248                         }
249                         char    **command = ReadCommand(fp);
250                         if( !command ) {
251                                 _SysDebug("init[ktty] - Command read failure");
252                                 goto lineError;
253                         }
254                         AddKTerminal(id, command);
255                 }
256                 else if(strcmp(cmdbuf, "stty") == 0 ) {
257                         // stty <devpath> [78][NOE][012][bB]<baud> <command...>
258                         char    path_seg[32+1];
259                         char    modespec[4+6+1];
260                         if( fscanf(fp, "%32s %10s ", path_seg, modespec) != 2 ) {
261                                 goto lineError;
262                         }
263                         char **command = ReadCommand(fp);
264                         if( !command )
265                                 goto lineError;
266                         AddSerialTerminal(path_seg, modespec, command);
267                 }
268                 else if(strcmp(cmdbuf, "daemon") == 0 ) {
269                         // daemon <stdout> <stderr> <command...>
270                         // - Runs a daemon (respawning) that logs to the specified files
271                         // - Will append a header whenever the daemon starts
272                         char    *stdout_path = ReadQuotedString(fp);
273                         if( !stdout_path )
274                                 goto lineError;
275                         char    *stderr_path = ReadQuotedString(fp);
276                         if( !stderr_path )
277                                 goto lineError;
278                         char    **command = ReadCommand(fp);
279                         if( !command )
280                                 goto lineError;
281                         
282                         AddDaemon(stdout_path, stderr_path, command);
283                 }
284                 else if(strcmp(cmdbuf, "exec") == 0 ) {
285                         // exec <command...>
286                         // - Runs a command and waits for it to complete before continuing
287                         // - NOTE: No other commands will respawn while this is running
288                         char **command = ReadCommand(fp);
289                         if(!command)
290                                 goto lineError;
291
292                         int handles[] = {0, 1, 1};
293                         int pid = _SysSpawn(command[0], (const char **)command, NULL, 3, handles, NULL);
294                         int retstatus;
295                         _SysWaitTID(pid, &retstatus);
296                         _SysDebug("Command '%s' returned %i", command[0], retstatus);
297
298                         FreeCommand(command);
299                 }
300                 else {
301                         // Unknown command.
302                         _SysDebug("Unknown command '%s'", cmdbuf);
303                         goto lineError;
304                 }
305                 fscanf(fp, " ");
306                 continue;
307         lineError:
308                 _SysDebug("label lineError: goto'd - line %i, cmdbuf='%s'", line_num, cmdbuf);
309                 while( !feof(fp) && fgetc(fp) != '\n' )
310                         ;
311                 continue ;
312         }
313
314         fclose(fp);
315
316         if( gpInitPrograms == NULL )
317                 return 2;
318
319         return 0;
320 }
321
322 tInitProgram *AllocateProgram(char **Command, enum eProgType Type, size_t ExtraSpace)
323 {
324         tInitProgram    *ret;
325         
326         ret = malloc( sizeof(tInitProgram) - sizeof(union uProgTypes) + ExtraSpace );
327         ret->Next = NULL;
328         ret->CurrentPID = 0;
329         ret->Type = Type;
330         ret->Command = Command;
331         
332         // Append
333         ret->Next = gpInitPrograms;
334         gpInitPrograms = ret;
335         
336         return ret;
337 }
338
339 void RespawnProgam(tInitProgram *Program)
340 {
341          int    rv = 0;
342         switch(Program->Type)
343         {
344         case PT_KTERM:  rv = SpawnKTerm(Program);       break;
345         case PT_STERM:  rv = SpawnSTerm(Program);       break;
346         case PT_DAEMON: rv = SpawnDaemon(Program);      break;
347         default:
348                 _SysDebug("BUGCHECK - Program Type %i unknown", Program->Type);
349                 break;
350         }
351         if( !rv ) {
352                 _SysDebug("Respawn failure!");
353                 // TODO: Remove from list?
354         }
355 }
356
357 int AddKTerminal(int TerminalID, char **Command)
358 {
359         // TODO: Smarter validation
360         if( TerminalID < 0 || TerminalID > 7 )
361                 return -1;
362         
363         tInitProgram    *ent = AllocateProgram(Command, PT_KTERM, sizeof(struct sKTerm));
364         ent->TypeInfo.KTerm.ID = TerminalID;
365
366         RespawnProgam(ent);
367         return 0;
368 }
369
370 int AddSerialTerminal(const char *DevPathSegment, const char *ModeStr, char **Command)
371 {
372         char    dbit, parity, sbit;
373          int    baud;
374
375         // Parse mode string
376         if( sscanf(ModeStr, "%1[78]%1[NOE]%1[012]%*1[bB]%d", &dbit, &parity, &sbit, &baud) != 4 ) {
377                 // Oops?
378                 _SysDebug("Serial mode string is invalid ('%s')", ModeStr);
379                 return -1;
380         }
381         
382         // Validate baud rate / build mode word
383         // TODO: Does baud rate need validation?
384         uint32_t        modeword = 0;
385         modeword |= (dbit == '7' ? 1 : 0) << 0;
386         modeword |= (parity == 'O' ? 1 : (parity == 'E' ? 2 : 0)) << 1;
387         modeword |= (sbit - '0') << 3;
388         
389         // Create info
390         const char DEVPREFIX[] = "/Devices/";
391         int pathlen = sizeof(DEVPREFIX) + strlen(DevPathSegment);
392         tInitProgram    *ent = AllocateProgram(Command, PT_STERM, sizeof(struct sSTerm)+pathlen);
393         ent->TypeInfo.STerm.FormatBits = modeword;
394         ent->TypeInfo.STerm.BaudRate = baud;
395         strcpy(ent->TypeInfo.STerm.Path, DEVPREFIX);
396         strcat(ent->TypeInfo.STerm.Path, DevPathSegment);
397
398         RespawnProgam(ent);
399         return 0;
400 }
401
402 int AddDaemon(char *StdoutPath, char *StderrPath, char **Command)
403 {
404         tInitProgram    *ent = AllocateProgram(Command, PT_DAEMON, sizeof(struct sDaemon));
405         ent->TypeInfo.Daemon.StdoutPath = StdoutPath;
406         ent->TypeInfo.Daemon.StderrPath = StderrPath;
407         
408         RespawnProgam(ent);
409         return 0;
410 }
411
412 int SpawnCommand(int c_stdin, int c_stdout, int c_stderr, char **ArgV)
413 {
414          int    handles[] = {c_stdin, c_stdout, c_stderr};
415
416         int rv = _SysSpawn(ArgV[0], (const char **)ArgV, NULL, 3, handles, NULL);
417
418         _SysClose(c_stdin);
419         if( c_stdout != c_stdin )
420                 _SysClose(c_stdout);
421         if( c_stderr != c_stdin && c_stderr != c_stdout )
422                 _SysClose(c_stderr);
423
424         return rv;
425 }
426
427 int SpawnKTerm(tInitProgram *Program)
428 {
429         const char fmt[] = "/Devices/pts/vt%ic";
430         char    path[sizeof(fmt)];
431         
432         snprintf(path, sizeof(path), fmt, Program->TypeInfo.KTerm.ID);
433         
434          int    in = _SysOpen(path, OPENFLAG_READ);
435          int    out = _SysOpen(path, OPENFLAG_WRITE);
436         
437         return SpawnCommand(in, out, out, Program->Command);
438 }
439
440 int SpawnSTerm(tInitProgram *Program)
441 {
442          int    in = _SysOpen(Program->TypeInfo.STerm.Path, OPENFLAG_READ);
443          int    out = _SysOpen(Program->TypeInfo.STerm.Path, OPENFLAG_WRITE);
444
445         if(in == -1 || out == -1 ) {
446                 _SysDebug("Unable to open serial port '%s'", Program->TypeInfo.STerm.Path);
447                 return -1;
448         }
449
450         #if 0
451         if( _SysIOCtl(in, 0, NULL) != DRV_TYPE_SERIAL )
452         {
453                 // Oops?
454                 return -2;
455         }
456         _SysIOCtl(in, SERIAL_IOCTL_GETSETBAUD, &Program->TypeInfo.STerm.BaudRate);
457         _SysIOCtl(in, SERIAL_IOCTL_GETSETFORMAT, &Program->TypeInfo.STerm.FormatBits);
458         #endif
459
460         return SpawnCommand(in, out, out, Program->Command);
461 }
462
463 int SpawnDaemon(tInitProgram *Program)
464 {
465          int    in = _SysOpen("/Devices/null", OPENFLAG_READ);
466          int    out = _SysOpen(Program->TypeInfo.Daemon.StdoutPath, OPENFLAG_WRITE);
467          int    err = _SysOpen(Program->TypeInfo.Daemon.StderrPath, OPENFLAG_WRITE);
468         
469         if( in == -1 || out == -1 || err == -1 ) {
470                 _SysClose(in);
471                 _SysClose(out);
472                 _SysClose(err);
473                 return -2;
474         }
475         
476         // Log spawn header
477         {
478                 char    buffer[101];
479                 size_t len = snprintf(buffer, 100, "[%i] init spawning '%s'\n", _SysTimestamp(), Program->Command);
480                 _SysWrite(out, buffer, len);
481         }
482         
483         return SpawnCommand(in, out, err, Program->Command);
484 }
485

UCC git Repository :: git.ucc.asn.au