Sorgenti delle applicazioni

4150001 #include <unistd.h>
4150002 #include <stdlib.h>
4150003 #include <sys/stat.h>
4150004 #include <fcntl.h>
4150005 #include <kernel/devices.h>
4150006 #include <stdio.h>
4150007 //----------------------------------------------------------------------
4150008 int
4150009 main (void)
4150010 {
4150011  int status;
4150012  status = mknod ("mem", (mode_t) (S_IFCHR | 0444),
4150013  (dev_t) DEV_MEM);
4150014  if (status) perror (NULL);
4150015  status = mknod ("null", (mode_t) (S_IFCHR | 0666),
4150016  (dev_t) DEV_NULL);
4150017  if (status) perror (NULL);
4150018  status = mknod ("port", (mode_t) (S_IFCHR | 0644),
4150019  (dev_t) DEV_PORT);
4150020  if (status) perror (NULL);
4150021  status = mknod ("zero", (mode_t) (S_IFCHR | 0666),
4150022  (dev_t) DEV_ZERO);
4150023  if (status) perror (NULL);
4150024  status = mknod ("tty", (mode_t) (S_IFCHR | 0666),
4150025  (dev_t) DEV_TTY);
4150026  if (status) perror (NULL);
4150027  status = mknod ("dsk0", (mode_t) (S_IFBLK | 0644),
4150028  (dev_t) DEV_DSK0);
4150029  if (status) perror (NULL);
4150030  status = mknod ("dsk1", (mode_t) (S_IFBLK | 0644),
4150031  (dev_t) DEV_DSK1);
4150032  if (status) perror (NULL);
4150033  status = mknod ("dsk2", (mode_t) (S_IFBLK | 0644),
4150034  (dev_t) DEV_DSK2);
4150035  if (status) perror (NULL);
4150036  status = mknod ("dsk3", (mode_t) (S_IFBLK | 0644),
4150037  (dev_t) DEV_DSK3);
4150038  if (status) perror (NULL);
4150039  status = mknod ("kmem_ps", (mode_t) (S_IFCHR | 0444),
4150040  (dev_t) DEV_KMEM_PS);
4150041  if (status) perror (NULL);
4150042  status = mknod ("kmem_mmp", (mode_t) (S_IFCHR | 0444),
4150043  (dev_t) DEV_KMEM_MMP);
4150044  if (status) perror (NULL);
4150045  status = mknod ("kmem_sb", (mode_t) (S_IFCHR | 0444),
4150046  (dev_t) DEV_KMEM_SB);
4150047  if (status) perror (NULL);
4150048  status = mknod ("kmem_inode", (mode_t) (S_IFCHR | 0444),
4150049  (dev_t) DEV_KMEM_INODE);
4150050  if (status) perror (NULL);
4150051  status = mknod ("kmem_file", (mode_t) (S_IFCHR | 0444),
4150052  (dev_t) DEV_KMEM_FILE);
4150053  if (status) perror (NULL);
4150054  status = mknod ("console", (mode_t) (S_IFCHR | 0644),
4150055  (dev_t) DEV_CONSOLE);
4150056  if (status) perror (NULL);
4150057  status = mknod ("console0", (mode_t) (S_IFCHR | 0644),
4150058  (dev_t) DEV_CONSOLE0);
4150059  if (status) perror (NULL);
4150060  status = mknod ("console1", (mode_t) (S_IFCHR | 0644),
4150061  (dev_t) DEV_CONSOLE1);
4150062  if (status) perror (NULL);
4150063  status = mknod ("console2", (mode_t) (S_IFCHR | 0644),
4150064  (dev_t) DEV_CONSOLE2);
4150065  if (status) perror (NULL);
4150066  status = mknod ("console3", (mode_t) (S_IFCHR | 0644),
4150067  (dev_t) DEV_CONSOLE3);
4150068  if (status) perror (NULL);
4150069 
4150070  return (0);
4150071 }

4160001 #include <unistd.h>
4160002 #include <stdio.h>
4160003 //----------------------------------------------------------------------
4160004 int
4160005 main (void)
4160006 {
4160007  unsigned int count;
4160008  for (count = 0; count < 60; count++)
4160009  {
4160010  printf ("a");
4160011  sleep (1);
4160012  }
4160013  return (8);
4160014 }

4170001 #include <unistd.h>
4170002 #include <stdio.h>
4170003 #include <stdlib.h>
4170004 //----------------------------------------------------------------------
4170005 int
4170006 main (void)
4170007 {
4170008  unsigned int count;
4170009  for (count = 0; count < 30; count++)
4170010  {
4170011  printf ("b");
4170012  sleep (2);
4170013  }
4170014  exit (0);
4170015  return (0);
4170016 }

4180001 #include <fcntl.h>
4180002 #include <sys/stat.h>
4180003 #include <stddef.h>
4180004 #include <unistd.h>
4180005 #include <stdio.h>
4180006 #include <stdlib.h>
4180007 #include <errno.h>
4180008 //----------------------------------------------------------------------
4180009 static void cat_file_descriptor (int fd);
4180010 //----------------------------------------------------------------------
4180011 int
4180012 main (int argc, char *argv[], char *envp[])
4180013 {
4180014  int i;
4180015  int fd;
4180016  struct stat file_status;
4180017  //
4180018  // Check if the input comes from standard input.
4180019  //
4180020  if (argc < 2)
4180021  {
4180022  cat_file_descriptor (STDIN_FILENO);
4180023  exit (0);
4180024  }
4180025  //
4180026  // There is at least an argument: scan them.
4180027  //
4180028  for(i = 1; i < argc; i++)
4180029  {
4180030  //
4180031  // Verify if the file exists.
4180032  //
4180033  if (stat(argv[i], &file_status) != 0)
4180034  {
4180035  fprintf (stderr, "File \"%s\" does not exist!\n",
4180036  argv[i]);
4180037  continue;
4180038  }
4180039  //
4180040  // File exists: check the file type.
4180041  //
4180042  if (S_ISDIR (file_status.st_mode))
4180043  {
4180044  fprintf (stderr, "Cannot \"cat\" "
4180045  "\"%s\": it is a directory!\n",
4180046  argv[i]);
4180047  continue;
4180048  }
4180049  //
4180050  // File exists and can be "cat"ed.
4180051  //
4180052  fd = open (argv[i], O_RDONLY);
4180053  if (fd >= 0)
4180054  {
4180055  cat_file_descriptor (fd);
4180056  close (fd);
4180057  }
4180058  else
4180059  {
4180060  perror (NULL);
4180061  exit (1);
4180062  }
4180063  }
4180064  return (0);
4180065 }
4180066 //----------------------------------------------------------------------
4180067 static void
4180068 cat_file_descriptor (int fd)
4180069 {
4180070  ssize_t count;
4180071  char buffer[BUFSIZ];
4180072 
4180073  for (;;)
4180074  {
4180075  count = read (fd, buffer, (size_t) BUFSIZ);
4180076  if (count > 0)
4180077  {
4180078  write (STDOUT_FILENO, buffer, (size_t) count);
4180079  }
4180080  else
4180081  {
4180082  break;
4180083  }
4180084  }
4180085 }
4180086 

4190001 #include <unistd.h>
4190002 #include <stdlib.h>
4190003 #include <signal.h>
4190004 //----------------------------------------------------------------------
4190005 int
4190006 main (void)
4190007 {
4190008  pid_t pid;
4190009  //------------------------------------------------------------------
4190010  pid = fork ();
4190011  if (pid == 0)
4190012  {
4190013  setuid ((uid_t) 10);
4190014  execve ("/bin/aaa", NULL, NULL);
4190015  exit (0);
4190016  }
4190017  //------------------------------------------------------------------
4190018  pid = fork ();
4190019  if (pid == 0)
4190020  {
4190021  setuid ((uid_t) 11);
4190022  execve ("/bin/bbb", NULL, NULL);
4190023  exit (0);
4190024  }
4190025  //------------------------------------------------------------------
4190026  while (1)
4190027  {
4190028  ; // Just loop, to consume CPU time: it must be killed manually.
4190029  }
4190030  return (0);
4190031 }

4200001 #include <unistd.h>
4200002 #include <stdlib.h>
4200003 #include <sys/stat.h>
4200004 #include <sys/types.h>
4200005 #include <fcntl.h>
4200006 #include <errno.h>
4200007 #include <signal.h>
4200008 #include <stdio.h>
4200009 #include <sys/wait.h>
4200010 #include <stdio.h>
4200011 #include <string.h>
4200012 #include <limits.h>
4200013 #include <sys/os16.h>
4200014 //----------------------------------------------------------------------
4200015 static void usage (void);
4200016 //----------------------------------------------------------------------
4200017 int
4200018 main (int argc, char *argv[], char *envp[])
4200019 {
4200020  int status;
4200021  mode_t mode;
4200022  char *m; // Pointer inside the octal mode string.
4200023  int digit;
4200024  int a; // Argument index.
4200025  //
4200026  //
4200027  //
4200028  if (argc < 3)
4200029  {
4200030  usage ();
4200031  return (1);
4200032  }
4200033  //
4200034  // Get mode: must be the first argument.
4200035  //
4200036  for (m = argv[1]; *m != 0; m++)
4200037  {
4200038  digit = (*m - '0');
4200039  if (digit < 0 || digit > 7)
4200040  {
4200041  usage ();
4200042  return (2);
4200043  }
4200044  mode = mode * 8 + digit;
4200045  }
4200046  //
4200047  // System call for all the remaining arguments.
4200048  //
4200049  for (a = 2; a < argc; a++)
4200050  {
4200051  status = chmod (argv[a], mode);
4200052  if (status != 0)
4200053  {
4200054  perror (argv[a]);
4200055  return (3);
4200056  }
4200057  }
4200058  //
4200059  // All done.
4200060  //
4200061  return (0);
4200062 }
4200063 //----------------------------------------------------------------------
4200064 static void
4200065 usage (void)
4200066 {
4200067  fprintf (stderr, "Usage: chmod OCTAL_MODE FILE...\n");
4200068  fprintf (stderr, "Example: chmod 0640 my_file\n");
4200069 }

4210001 #include <unistd.h>
4210002 #include <stdlib.h>
4210003 #include <sys/stat.h>
4210004 #include <sys/types.h>
4210005 #include <fcntl.h>
4210006 #include <errno.h>
4210007 #include <stdio.h>
4210008 #include <ctype.h>
4210009 #include <pwd.h>
4210010 //----------------------------------------------------------------------
4210011 static void usage (void);
4210012 //----------------------------------------------------------------------
4210013 int
4210014 main (int argc, char *argv[], char *envp[])
4210015 {
4210016  char *user;
4210017  int uid;
4210018  struct passwd *pws;
4210019  struct stat file_status;
4210020  int a; // Argument index.
4210021  int status;
4210022  //
4210023  //
4210024  //
4210025  if (argc < 3)
4210026  {
4210027  usage ();
4210028  return (1);
4210029  }
4210030  //
4210031  // Get user id number.
4210032  //
4210033  user = argv[1];
4210034  if (isdigit (*user))
4210035  {
4210036  uid = atoi (user);
4210037  }
4210038  else
4210039  {
4210040  pws = getpwnam (user);
4210041  if (pws == NULL)
4210042  {
4210043  fprintf(stderr, "Unknown user \"%s\"!\n", user);
4210044  return(2);
4210045  }
4210046  uid = pws->pw_uid;
4210047  }
4210048  //
4210049  // Now we have the user id. Start scanning file names.
4210050  //
4210051  for (a = 2; a < argc; a++)
4210052  {
4210053  //
4210054  // Verify if the file exists, through the return value of
4210055  // `stat()'. No other checks are made.
4210056  //
4210057  if (stat(argv[a], &file_status) == 0)
4210058  {
4210059  //
4210060  // Try to change ownership.
4210061  //
4210062  status = chown (argv[a], uid, file_status.st_gid);
4210063  if (status != 0)
4210064  {
4210065  perror (NULL);
4210066  return (3);
4210067  }
4210068  }
4210069  else
4210070  {
4210071  fprintf (stderr, "File \"%s\" does not exist!\n",
4210072  argv[a]);
4210073  continue;
4210074  }
4210075  }
4210076  //
4210077  // All done.
4210078  //
4210079  return (0);
4210080 }
4210081 //----------------------------------------------------------------------
4210082 static void
4210083 usage (void)
4210084 {
4210085  fprintf (stderr, "Usage: chown USER|UID FILE...\n");
4210086  fprintf (stderr, "Example: chown user my_file\n");
4210087 }

4220001 #include <sys/os16.h>
4220002 #include <sys/stat.h>
4220003 #include <sys/types.h>
4220004 #include <unistd.h>
4220005 #include <stdlib.h>
4220006 #include <fcntl.h>
4220007 #include <errno.h>
4220008 #include <signal.h>
4220009 #include <stdio.h>
4220010 #include <string.h>
4220011 #include <limits.h>
4220012 #include <libgen.h>
4220013 //----------------------------------------------------------------------
4220014 static void usage (void);
4220015 //----------------------------------------------------------------------
4220016 int
4220017 main (int argc, char *argv[], char *envp[])
4220018 {
4220019  char *source;
4220020  char *destination;
4220021  char *destination_full;
4220022  struct stat file_status;
4220023  int dest_is_a_dir = 0;
4220024  int a; // Argument index.
4220025  char path[PATH_MAX];
4220026  int fd_source = -1;
4220027  int fd_destination = -1;
4220028  char buffer_in[BUFSIZ];
4220029  char *buffer_out;
4220030  ssize_t count_in; // Read counter.
4220031  ssize_t count_out; // Write counter.
4220032  //
4220033  // There must be at least two arguments, plus the program name.
4220034  //
4220035  if (argc < 3)
4220036  {
4220037  usage ();
4220038  return (1);
4220039  }
4220040  //
4220041  // Select the last argument as the destination.
4220042  //
4220043  destination = argv[argc-1];
4220044  //
4220045  // Check if it is a directory and save it in a flag.
4220046  //
4220047  if (stat (destination, &file_status) == 0)
4220048  {
4220049  if (S_ISDIR (file_status.st_mode))
4220050  {
4220051  dest_is_a_dir = 1;
4220052  }
4220053  }
4220054  //
4220055  // If there are more than two arguments, verify that the last
4220056  // one is a directory.
4220057  //
4220058  if (argc > 3)
4220059  {
4220060  if (!dest_is_a_dir)
4220061  {
4220062  usage ();
4220063  fprintf (stderr, "The destination \"%s\" ",
4220064  destination);
4220065  fprintf (stderr, "is not a directory!\n");
4220066  return (1);
4220067  }
4220068  }
4220069  //
4220070  // Scan the arguments, excluded the last, that is the destination.
4220071  //
4220072  for (a = 1; a < (argc - 1); a++)
4220073  {
4220074  //
4220075  // Source.
4220076  //
4220077  source = argv[a];
4220078  //
4220079  // Verify access permissions.
4220080  //
4220081  if (access (source, R_OK) < 0)
4220082  {
4220083  perror (source);
4220084  continue;
4220085  }
4220086  //
4220087  // Destination.
4220088  //
4220089  // If it is a directory, the destination path
4220090  // must be corrected.
4220091  //
4220092  if (dest_is_a_dir)
4220093  {
4220094  path[0] = 0;
4220095  strcat (path, destination);
4220096  strcat (path, "/");
4220097  strcat (path, basename (source));
4220098  //
4220099  // Update the destination path.
4220100  //
4220101  destination_full = path;
4220102  }
4220103  else
4220104  {
4220105  destination_full = destination;
4220106  }
4220107  //
4220108  // Check if destination file exists.
4220109  //
4220110  if (stat (destination_full, &file_status) == 0)
4220111  {
4220112  fprintf (stderr, "The destination file, \"%s\", ",
4220113  destination_full);
4220114  fprintf (stderr, "already exists!\n");
4220115  continue;
4220116  }
4220117  //
4220118  // Everything is ready for the copy.
4220119  //
4220120  fd_source = open (source, O_RDONLY);
4220121  if (fd_source < 0)
4220122  {
4220123  perror (source);
4220124  //
4220125  // Continue with the next file.
4220126  //
4220127  continue;
4220128  }
4220129  //
4220130  fd_destination = creat (destination_full, 0777);
4220131  if (fd_destination < 0)
4220132  {
4220133  perror (destination);
4220134  close (fd_source);
4220135  //
4220136  // Continue with the next file.
4220137  //
4220138  continue;
4220139  }
4220140  //
4220141  // Copy the data.
4220142  //
4220143  while (1)
4220144  {
4220145  count_in = read (fd_source, buffer_in, (size_t) BUFSIZ);
4220146  if (count_in > 0)
4220147  {
4220148  for (buffer_out = buffer_in; count_in > 0;)
4220149  {
4220150  count_out = write (fd_destination, buffer_out,
4220151  (size_t) count_in);
4220152  if (count_out < 0)
4220153  {
4220154  perror (destination);
4220155  close (fd_source);
4220156  close (fd_destination);
4220157  return (3);
4220158  }
4220159  //
4220160  // If not all data is written, continue writing,
4220161  // but change the buffer start position and the
4220162  // amount to be written.
4220163  //
4220164  buffer_out += count_out;
4220165  count_in -= count_out;
4220166  }
4220167  }
4220168  else if (count_in < 0)
4220169  {
4220170  perror (source);
4220171  close (fd_source);
4220172  close (fd_destination);
4220173  }
4220174  else
4220175  {
4220176  break;
4220177  }
4220178  }
4220179  //
4220180  if (close (fd_source))
4220181  {
4220182  perror (source);
4220183  }
4220184  if (close (fd_destination))
4220185  {
4220186  perror (destination);
4220187  return (4);
4220188  }
4220189  }
4220190  //
4220191  // All done.
4220192  //
4220193  return (0);
4220194 }
4220195 //----------------------------------------------------------------------
4220196 static void
4220197 usage (void)
4220198 {
4220199  fprintf (stderr, "Usage: cp OLD_NAME NEW_NAME\n");
4220200  fprintf (stderr, " cp FILE... DIRECTORY\n");
4220201 }

4230001 .extern _main
4230002 .extern __stdio_stream_setup
4230003 .extern __dirent_directory_stream_setup
4230004 .extern __atexit_setup
4230005 .extern __environment_setup
4230006 .global ___mkargv
4230007 ;-----------------------------------------------------------------------
4230008 ; Please note that, all segments are already set from the scheduler,
4230009 ; and there is also data inside the stack, so that the call to `main()'
4230010 ; function will result as expected.
4230011 ;
4230012 ; This is a modified version of `crt0.s' with a smaller stack size.
4230013 ;-----------------------------------------------------------------------
4230014 ; The following statement says that the code will start at "startup"
4230015 ; label.
4230016 ;-----------------------------------------------------------------------
4230017 entry startup
4230018 ;-----------------------------------------------------------------------
4230019 .text
4230020 ;-----------------------------------------------------------------------
4230021 startup: 
4230022  ;
4230023  ; Jump after initial data.
4230024  ;
4230025  jmp startup_code
4230026  ;
4230027 filler:
4230028  ;
4230029  ; After four bytes, from the start, there is the
4230030  ; magic number and other data.
4230031  ;
4230032  .space (0x0004 - (filler - startup))
4230033  ;
4230034 magic:
4230035  .data4 0x6F733136 ; os16
4230036  .data4 0x6170706C ; appl
4230037  ;
4230038 segoff: ;
4230039  .data2 __segoff ; Data segment offset.
4230040 etext: ;
4230041  .data2 __etext ; End of code
4230042 edata: ; 
4230043  .data2 __edata ; End of initialized data.
4230044 ebss: ;
4230045  .data2 __end ; End of not initialized data.
4230046 stack_size: ;
4230047  .data2 0x2000 ; Requested stack size. Every single application
4230048  ; might change this value.
4230049  ;
4230050  ; At the next label, the work begins.
4230051  ;
4230052 .align 2
4230053 startup_code:
4230054  ;
4230055  ; Before the call to the main function, it is necessary to extract
4230056  ; the value to assign to the global variable `environ'. It is
4230057  ; described as `char **environ' and should contain the same address
4230058  ; pointed by `envp'. To get this value, the stack is popped and then
4230059  ; pushed again. Please recall that the stack was prepared from
4230060  ; the process management, at the `exec()' system call.
4230061  ;
4230062  pop ax ; argc
4230063  pop bx ; argv
4230064  pop cx ; envp
4230065  mov _environ, cx ; Variable `environ' comes from <unistd.h>.
4230066  push cx
4230067  push bx
4230068  push ax
4230069  ;
4230070  ; Could it be enough? Of course not! To be able to handle the
4230071  ; environment, it must be copied inside the table
4230072  ; `_environment_table[][]', that is defined inside <stdlib.h>.
4230073  ; To copy the environment it is used the function
4230074  ; `_environment_setup()', passing the `envp' pointer.
4230075  ;
4230076  push cx
4230077  call __environment_setup
4230078  add sp, #2
4230079  ;
4230080  ; After the environment copy is done, the value for the traditional
4230081  ; variable `environ' is updated, to point to the new array of
4230082  ; pointer. The updated value comes from variable `_environment',
4230083  ; defined inside <stdlib.h>. Then, also the `argv' contained inside
4230084  ; the stack is replaced with the new value.
4230085  ;
4230086  mov ax, #__environment
4230087  mov _environ, ax
4230088  ;
4230089  pop ax ; argc
4230090  pop bx ; argv[][]
4230091  pop cx ; envp[][]
4230092  mov cx, #__environment
4230093  push cx
4230094  push bx
4230095  push ax
4230096  ;
4230097  ; Setup standard I/O streams and at-exit table.
4230098  ;
4230099  call __stdio_stream_setup
4230100  call __dirent_directory_stream_setup
4230101  call __atexit_setup
4230102  ;
4230103  ; Call the main function. The arguments are already pushed inside
4230104  ; the stack.
4230105  ;
4230106  call _main
4230107  ;
4230108  ; Save the return value at the symbol `exit_value'.
4230109  ;
4230110  mov exit_value, ax
4230111  ;
4230112 .align 2
4230113 halt:
4230114  ;
4230115  push #2 ; Size of message.
4230116  push #exit_value ; Pointer to the message.
4230117  push #6 ; SYS_EXIT
4230118  call _sys
4230119  add sp, #2
4230120  add sp, #2
4230121  add sp, #2
4230122  ;
4230123  jmp halt
4230124  ;
4230125 ;-----------------------------------------------------------------------
4230126 .align 2
4230127 ___mkargv: ; Symbol `___mkargv' is used by Bcc inside the function
4230128  ret ; `main()' and must be present for a successful
4230129  ; compilation.
4230130 ;-----------------------------------------------------------------------
4230131 .align 2
4230132 .data
4230133 ;
4230134 exit_value:
4230135  .data2 0x0000
4230136 ;-----------------------------------------------------------------------
4230137 .align 2
4230138 .bss

4240001 #include <unistd.h>
4240002 #include <stdlib.h>
4240003 #include <errno.h>
4240004 #include <time.h>
4240005 #include <ctype.h>
4240006 //----------------------------------------------------------------------
4240007 static void usage (void);
4240008 //----------------------------------------------------------------------
4240009 int
4240010 main (int argc, char *argv[], char *envp[])
4240011 {
4240012  struct tm *timeptr;
4240013  char string[5];
4240014  time_t timer;
4240015  int length;
4240016  char *input;
4240017  int i;
4240018  //
4240019  // There can be at most an argument.
4240020  //
4240021  if (argc > 2)
4240022  {
4240023  usage ();
4240024  return (1);
4240025  }
4240026  //
4240027  // Check if there is no argument: must show the date.
4240028  //
4240029  if (argc == 1)
4240030  {
4240031  timer = time (NULL);
4240032  printf ("%s\n", ctime (&timer));
4240033  return (0);
4240034  }
4240035  //
4240036  // There is one argument and must be the date do set.
4240037  //
4240038  input = argv[1];
4240039  //
4240040  // First get current date, for default values.
4240041  //
4240042  timer = time (NULL);
4240043  timeptr = gmtime (&timer);
4240044  //
4240045  // Verify to have a correct input.
4240046  //
4240047  length = (int) strlen (input);
4240048  if (length == 8 || length == 10 || length == 12)
4240049  {
4240050  for (i = 0; i < length; i++)
4240051  {
4240052  if (!isdigit (input[i]))
4240053  {
4240054  usage ();
4240055  return (2);
4240056  }
4240057  }
4240058  }
4240059  else
4240060  {
4240061  printf ("input: \"%s\"; length: %i\n", input, length);
4240062  usage ();
4240063  return (3);
4240064  }
4240065  //
4240066  // Select the month.
4240067  //
4240068  string[0] = input[0];
4240069  string[1] = input[1];
4240070  string[2] = '0円';
4240071  timeptr->tm_mon = atoi (string);
4240072  //
4240073  // Select the day.
4240074  //
4240075  string[0] = input[2];
4240076  string[1] = input[3];
4240077  string[2] = '0円';
4240078  timeptr->tm_mday = atoi (string);
4240079  //
4240080  // Select the hour.
4240081  //
4240082  string[0] = input[4];
4240083  string[1] = input[5];
4240084  string[2] = '0円';
4240085  timeptr->tm_hour = atoi (string);
4240086  //
4240087  // Select the minute.
4240088  //
4240089  string[0] = input[6];
4240090  string[1] = input[7];
4240091  string[2] = '0円';
4240092  timeptr->tm_min = atoi (string);
4240093  //
4240094  // Select the year: must verify if there is a century.
4240095  //
4240096  if (length == 12)
4240097  {
4240098  string[0] = input[8];
4240099  string[1] = input[9];
4240100  string[2] = input[10];
4240101  string[3] = input[11];
4240102  string[4] = '0円';
4240103  timeptr->tm_year = atoi (string);
4240104  }
4240105  else if (length == 10)
4240106  {
4240107  sprintf (string, "%04i", timeptr->tm_year);
4240108  string[2] = input[8];
4240109  string[3] = input[9];
4240110  string[4] = '0円';
4240111  timeptr->tm_year = atoi (string);
4240112  }
4240113  //
4240114  // Now convert to `time_t'.
4240115  //
4240116  timer = mktime (timeptr);
4240117  //
4240118  // Save to the system.
4240119  //
4240120  stime (&timer);
4240121  //
4240122  return (0);
4240123 }
4240124 //----------------------------------------------------------------------
4240125 static void
4240126 usage (void)
4240127 {
4240128  fprintf (stderr, "Usage: date [MMDDHHMM[[CC]YY]]\n");
4240129 }

4250001 //----------------------------------------------------------------------
4250002 // 2009年08月18日
4250003 // Modified by Daniele Giacomini for `os16', to harmonize with it,
4250004 // even, when possible, on coding style.
4250005 //
4250006 // The original was taken form ELKS sources: `elkscmd/misc_utils/ed.c'.
4250007 //----------------------------------------------------------------------
4250008 //
4250009 // Copyright (c) 1993 by David I. Bell
4250010 // Permission is granted to use, distribute, or modify this source,
4250011 // provided that this copyright notice remains intact.
4250012 //
4250013 // The "ed" built-in command (much simplified)
4250014 //
4250015 //----------------------------------------------------------------------
4250016 
4250017 #include <stdio.h>
4250018 #include <ctype.h>
4250019 #include <unistd.h>
4250020 #include <stdbool.h>
4250021 #include <string.h>
4250022 #include <stdlib.h>
4250023 #include <fcntl.h>
4250024 //----------------------------------------------------------------------
4250025 #define isoctal(ch) (((ch) >= '0') && ((ch) <= '7'))
4250026 #define USERSIZE 1024 /* max line length typed in by user */
4250027 #define INITBUFSIZE 1024 /* initial buffer size */
4250028 //----------------------------------------------------------------------
4250029 typedef int num_t;
4250030 typedef int len_t;
4250031 //
4250032 // The following is the type definition of structure `line_t', but the
4250033 // structure contains pointers to the same kind of type. With the
4250034 // compiler Bcc, it is the only way to declare it.
4250035 //
4250036 typedef struct line line_t;
4250037 //
4250038 struct line {
4250039  line_t *next;
4250040  line_t *prev;
4250041  len_t len;
4250042  char data[1];
4250043 };
4250044 //
4250045 static line_t lines;
4250046 static line_t *curline;
4250047 static num_t curnum;
4250048 static num_t lastnum;
4250049 static num_t marks[26];
4250050 static bool dirty;
4250051 static char *filename;
4250052 static char searchstring[USERSIZE];
4250053 //
4250054 static char *bufbase;
4250055 static char *bufptr;
4250056 static len_t bufused;
4250057 static len_t bufsize;
4250058 //----------------------------------------------------------------------
4250059 static void docommands (void);
4250060 static void subcommand (char *cp, num_t num1, num_t num2);
4250061 static bool getnum (char **retcp, bool *rethavenum,
4250062  num_t *retnum);
4250063 static bool setcurnum (num_t num);
4250064 static bool initedit (void);
4250065 static void termedit (void);
4250066 static void addlines (num_t num);
4250067 static bool insertline (num_t num, char *data, len_t len);
4250068 static bool deletelines (num_t num1, num_t num2);
4250069 static bool printlines (num_t num1, num_t num2, bool expandflag);
4250070 static bool writelines (char *file, num_t num1, num_t num2);
4250071 static bool readlines (char *file, num_t num);
4250072 static num_t searchlines (char *str, num_t num1, num_t num2);
4250073 static len_t findstring (line_t *lp, char *str, len_t len,
4250074  len_t offset);
4250075 static line_t *findline (num_t num);
4250076 //----------------------------------------------------------------------
4250077 // Main.
4250078 //----------------------------------------------------------------------
4250079 int
4250080 main (int argc, char *argv[], char *envp[])
4250081 {
4250082  if (!initedit ()) return (2);
4250083  //
4250084  if (argc > 1)
4250085  {
4250086  filename = strdup (argv[1]);
4250087  if (filename == NULL)
4250088  {
4250089  fprintf (stderr, "No memory\n");
4250090  termedit ();
4250091  return (1);
4250092  }
4250093  //
4250094  if (!readlines (filename, 1))
4250095  {
4250096  termedit ();
4250097  return (0);
4250098  }
4250099  //
4250100  if (lastnum) setcurnum(1);
4250101  //
4250102  dirty = false;
4250103  }
4250104  //
4250105  docommands ();
4250106  //
4250107  termedit ();
4250108  return (0);
4250109 }
4250110 //----------------------------------------------------------------------
4250111 // Read commands until we are told to stop.
4250112 //----------------------------------------------------------------------
4250113 void
4250114 docommands (void)
4250115 {
4250116  char *cp;
4250117  int len;
4250118  num_t num1;
4250119  num_t num2;
4250120  bool have1;
4250121  bool have2;
4250122  char buf[USERSIZE];
4250123  //
4250124  while (true)
4250125  {
4250126  printf(": ");
4250127  fflush (stdout);
4250128  //
4250129  if (fgets (buf, sizeof(buf), stdin) == NULL)
4250130  {
4250131  return;
4250132  }
4250133  //
4250134  len = strlen (buf);
4250135  if (len == 0)
4250136  {
4250137  return;
4250138  }
4250139  //
4250140  cp = &buf[len - 1];
4250141  if (*cp != '\n')
4250142  {
4250143  fprintf(stderr, "Command line too long\n");
4250144  do
4250145  {
4250146  len = fgetc(stdin);
4250147  }
4250148  while ((len != EOF) && (len != '\n'));
4250149  //
4250150  continue;
4250151  }
4250152  //
4250153  while ((cp > buf) && isblank (cp[-1]))
4250154  {
4250155  cp--;
4250156  }
4250157  //
4250158  *cp = '0円';
4250159  //
4250160  cp = buf;
4250161  //
4250162  while (isblank (*cp))
4250163  {
4250164  //*cp++;
4250165  cp++;
4250166  }
4250167  //
4250168  have1 = false;
4250169  have2 = false;
4250170  //
4250171  if ((curnum == 0) && (lastnum > 0))
4250172  {
4250173  curnum = 1;
4250174  curline = lines.next;
4250175  }
4250176  //
4250177  if (!getnum (&cp, &have1, &num1))
4250178  {
4250179  continue;
4250180  }
4250181  //
4250182  while (isblank (*cp))
4250183  {
4250184  cp++;
4250185  }
4250186  //
4250187  if (*cp == ',')
4250188  {
4250189  cp++;
4250190  if (!getnum (&cp, &have2, &num2))
4250191  {
4250192  continue;
4250193  }
4250194  //
4250195  if (!have1)
4250196  {
4250197  num1 = 1;
4250198  }
4250199  if (!have2)
4250200  {
4250201  num2 = lastnum;
4250202  }
4250203  have1 = true;
4250204  have2 = true;
4250205  }
4250206  //
4250207  if (!have1)
4250208  {
4250209  num1 = curnum;
4250210  }
4250211  if (!have2)
4250212  {
4250213  num2 = num1;
4250214  }
4250215  //
4250216  // Command interpretation switch.
4250217  //
4250218  switch (*cp++)
4250219  {
4250220  case 'a':
4250221  addlines (num1 + 1);
4250222  break;
4250223  //
4250224  case 'c':
4250225  deletelines (num1, num2);
4250226  addlines (num1);
4250227  break;
4250228  //
4250229  case 'd':
4250230  deletelines (num1, num2);
4250231  break;
4250232  //
4250233  case 'f':
4250234  if (*cp && !isblank (*cp))
4250235  {
4250236  fprintf (stderr, "Bad file command\n");
4250237  break;
4250238  }
4250239  //
4250240  while (isblank (*cp))
4250241  {
4250242  cp++;
4250243  }
4250244  if (*cp == '0円')
4250245  {
4250246  if (filename)
4250247  {
4250248  printf ("\"%s\"\n", filename);
4250249  }
4250250  else
4250251  {
4250252  printf ("No filename\n");
4250253  }
4250254  break;
4250255  }
4250256  //
4250257  cp = strdup (cp);
4250258  //
4250259  if (cp == NULL)
4250260  {
4250261  fprintf (stderr, "No memory for filename\n");
4250262  break;
4250263  }
4250264  //
4250265  if (filename)
4250266  {
4250267  free(filename);
4250268  }
4250269  //
4250270  filename = cp;
4250271  break;
4250272  //
4250273  case 'i':
4250274  addlines (num1);
4250275  break;
4250276  //
4250277  case 'k':
4250278  while (isblank(*cp))
4250279  {
4250280  cp++;
4250281  }
4250282  //
4250283  if ((*cp < 'a') || (*cp > 'a') || cp[1])
4250284  {
4250285  fprintf (stderr, "Bad mark name\n");
4250286  break;
4250287  }
4250288  //
4250289  marks[*cp - 'a'] = num2;
4250290  break;
4250291  //
4250292  case 'l':
4250293  printlines (num1, num2, true);
4250294  break;
4250295  //
4250296  case 'p':
4250297  printlines (num1, num2, false);
4250298  break;
4250299  //
4250300  case 'q':
4250301  while (isblank(*cp))
4250302  {
4250303  cp++;
4250304  }
4250305  //
4250306  if (have1 || *cp)
4250307  {
4250308  fprintf (stderr, "Bad quit command\n");
4250309  break;
4250310  }
4250311  //
4250312  if (!dirty)
4250313  {
4250314  return;
4250315  }
4250316  //
4250317  printf ("Really quit? ");
4250318  fflush (stdout);
4250319  //
4250320  buf[0] = '0円';
4250321  fgets (buf, sizeof(buf), stdin);
4250322  cp = buf;
4250323  //
4250324  while (isblank (*cp))
4250325  {
4250326  cp++;
4250327  }
4250328  //
4250329  if ((*cp == 'y') || (*cp == 'Y'))
4250330  {
4250331  return;
4250332  }
4250333  //
4250334  break;
4250335  //
4250336  case 'r':
4250337  if (*cp && !isblank(*cp))
4250338  {
4250339  fprintf (stderr, "Bad read command\n");
4250340  break;
4250341  }
4250342  //
4250343  while (isblank(*cp))
4250344  {
4250345  cp++;
4250346  }
4250347  //
4250348  if (*cp == '0円')
4250349  {
4250350  fprintf (stderr, "No filename\n");
4250351  break;
4250352  }
4250353  //
4250354  if (!have1)
4250355  {
4250356  num1 = lastnum;
4250357  }
4250358  //
4250359  // Open the file and add to the buffer
4250360  // at the next line.
4250361  //
4250362  if (readlines (cp, num1 + 1))
4250363  {
4250364  //
4250365  // If the file open fails, just
4250366  // break the command.
4250367  //
4250368  break;
4250369  }
4250370  //
4250371  // Set the default file name, if no
4250372  // previous name is available.
4250373  //
4250374  if (filename == NULL)
4250375  {
4250376  filename = strdup (cp);
4250377  }
4250378  //
4250379  break;
4250380 
4250381  case 's':
4250382  subcommand (cp, num1, num2);
4250383  break;
4250384  //
4250385  case 'w':
4250386  if (*cp && !isblank(*cp))
4250387  {
4250388  fprintf(stderr, "Bad write command\n");
4250389  break;
4250390  }
4250391  //
4250392  while (isblank(*cp))
4250393  {
4250394  cp++;
4250395  }
4250396  //
4250397  if (!have1)
4250398  {
4250399  num1 = 1;
4250400  num2 = lastnum;
4250401  }
4250402  //
4250403  // If the file name is not specified, use the
4250404  // default one.
4250405  //
4250406  if (*cp == '0円')
4250407  {
4250408  cp = filename;
4250409  }
4250410  //
4250411  // If even the default file name is not specified,
4250412  // tell it.
4250413  //
4250414  if (cp == NULL)
4250415  {
4250416  fprintf (stderr, "No file name specified\n");
4250417  break;
4250418  }
4250419  //
4250420  // Write the file.
4250421  //
4250422  writelines (cp, num1, num2);
4250423  //
4250424  break;
4250425  //
4250426  case 'z':
4250427  switch (*cp)
4250428  {
4250429  case '-':
4250430  printlines (curnum-21, curnum, false);
4250431  break;
4250432  case '.':
4250433  printlines (curnum-11, curnum+10, false);
4250434  break;
4250435  default:
4250436  printlines (curnum, curnum+21, false);
4250437  break;
4250438  }
4250439  break;
4250440  //
4250441  case '.':
4250442  if (have1)
4250443  {
4250444  fprintf (stderr, "No arguments allowed\n");
4250445  break;
4250446  }
4250447  printlines (curnum, curnum, false);
4250448  break;
4250449  //
4250450  case '-':
4250451  if (setcurnum (curnum - 1))
4250452  {
4250453  printlines (curnum, curnum, false);
4250454  }
4250455  break;
4250456  //
4250457  case '=':
4250458  printf ("%d\n", num1);
4250459  break;
4250460  //
4250461  case '0円':
4250462  if (have1)
4250463  {
4250464  printlines (num2, num2, false);
4250465  break;
4250466  }
4250467  //
4250468  if (setcurnum (curnum + 1))
4250469  {
4250470  printlines (curnum, curnum, false);
4250471  }
4250472  break;
4250473  //
4250474  default:
4250475  fprintf (stderr, "Unimplemented command\n");
4250476  break;
4250477  }
4250478  }
4250479 }
4250480 //----------------------------------------------------------------------
4250481 // Do the substitute command.
4250482 // The current line is set to the last substitution done.
4250483 //----------------------------------------------------------------------
4250484 void
4250485 subcommand (char *cp, num_t num1, num_t num2)
4250486 {
4250487  int delim;
4250488  char *oldstr;
4250489  char *newstr;
4250490  len_t oldlen;
4250491  len_t newlen;
4250492  len_t deltalen;
4250493  len_t offset;
4250494  line_t *lp;
4250495  line_t *nlp;
4250496  bool globalflag;
4250497  bool printflag;
4250498  bool didsub;
4250499  bool needprint;
4250500 
4250501  if ((num1 < 1) || (num2 > lastnum) || (num1 > num2))
4250502  {
4250503  fprintf (stderr, "Bad line range for substitute\n");
4250504  return;
4250505  }
4250506  //
4250507  globalflag = false;
4250508  printflag = false;
4250509  didsub = false;
4250510  needprint = false;
4250511  //
4250512  if (isblank (*cp) || (*cp == '0円'))
4250513  {
4250514  fprintf (stderr, "Bad delimiter for substitute\n");
4250515  return;
4250516  }
4250517  //
4250518  delim = *cp++;
4250519  oldstr = cp;
4250520  //
4250521  cp = strchr (cp, delim);
4250522  //
4250523  if (cp == NULL)
4250524  {
4250525  fprintf (stderr, "Missing 2nd delimiter for substitute\n");
4250526  return;
4250527  }
4250528  //
4250529  *cp++ = '0円';
4250530  //
4250531  newstr = cp;
4250532  cp = strchr (cp, delim);
4250533  //
4250534  if (cp)
4250535  {
4250536  *cp++ = '0円';
4250537  }
4250538  else
4250539  {
4250540  cp = "";
4250541  }
4250542  while (*cp)
4250543  {
4250544  switch (*cp++)
4250545  {
4250546  case 'g':
4250547  globalflag = true;
4250548  break;
4250549  //
4250550  case 'p':
4250551  printflag = true;
4250552  break;
4250553  //
4250554  default:
4250555  fprintf (stderr, "Unknown option for substitute\n");
4250556  return;
4250557  }
4250558  }
4250559  //
4250560  if (*oldstr == '0円')
4250561  {
4250562  if (searchstring[0] == '0円')
4250563  {
4250564  fprintf (stderr, "No previous search string\n");
4250565  return;
4250566  }
4250567  oldstr = searchstring;
4250568  }
4250569  //
4250570  if (oldstr != searchstring)
4250571  {
4250572  strcpy (searchstring, oldstr);
4250573  }
4250574  //
4250575  lp = findline (num1);
4250576  if (lp == NULL)
4250577  {
4250578  return;
4250579  }
4250580  //
4250581  oldlen = strlen(oldstr);
4250582  newlen = strlen(newstr);
4250583  deltalen = newlen - oldlen;
4250584  offset = 0;
4250585  //
4250586  while (num1 <= num2)
4250587  {
4250588  offset = findstring (lp, oldstr, oldlen, offset);
4250589  if (offset < 0)
4250590  {
4250591  if (needprint)
4250592  {
4250593  printlines (num1, num1, false);
4250594  needprint = false;
4250595  }
4250596  //
4250597  offset = 0;
4250598  lp = lp->next;
4250599  num1++;
4250600  continue;
4250601  }
4250602  //
4250603  needprint = printflag;
4250604  didsub = true;
4250605  dirty = true;
4250606 
4250607  //--------------------------------------------------------------
4250608  // If the replacement string is the same size or shorter
4250609  // than the old string, then the substitution is easy.
4250610  //--------------------------------------------------------------
4250611 
4250612  if (deltalen <= 0)
4250613  {
4250614  memcpy (&lp->data[offset], newstr, newlen);
4250615  //
4250616  if (deltalen)
4250617  {
4250618  memcpy (&lp->data[offset + newlen],
4250619  &lp->data[offset + oldlen],
4250620  lp->len - offset - oldlen);
4250621  //
4250622  lp->len += deltalen;
4250623  }
4250624  //
4250625  offset += newlen;
4250626  //
4250627  if (globalflag)
4250628  {
4250629  continue;
4250630  }
4250631  //
4250632  if (needprint)
4250633  {
4250634  printlines(num1, num1, false);
4250635  needprint = false;
4250636  }
4250637  //
4250638  lp = nlp->next;
4250639  num1++;
4250640  continue;
4250641  }
4250642 
4250643  //--------------------------------------------------------------
4250644  // The new string is larger, so allocate a new line
4250645  // structure and use that. Link it in in place of
4250646  // the old line structure.
4250647  //--------------------------------------------------------------
4250648 
4250649  nlp = (line_t *) malloc (sizeof (line_t) + lp->len + deltalen);
4250650  //
4250651  if (nlp == NULL)
4250652  {
4250653  fprintf (stderr, "Cannot get memory for line\n");
4250654  return;
4250655  }
4250656  //
4250657  nlp->len = lp->len + deltalen;
4250658  //
4250659  memcpy (nlp->data, lp->data, offset);
4250660  //
4250661  memcpy (&nlp->data[offset], newstr, newlen);
4250662  //
4250663  memcpy (&nlp->data[offset + newlen],
4250664  &lp->data[offset + oldlen],
4250665  lp->len - offset - oldlen);
4250666  //
4250667  nlp->next = lp->next;
4250668  nlp->prev = lp->prev;
4250669  nlp->prev->next = nlp;
4250670  nlp->next->prev = nlp;
4250671  //
4250672  if (curline == lp)
4250673  {
4250674  curline = nlp;
4250675  }
4250676  //
4250677  free(lp);
4250678  lp = nlp;
4250679  //
4250680  offset += newlen;
4250681  //
4250682  if (globalflag)
4250683  {
4250684  continue;
4250685  }
4250686  //
4250687  if (needprint)
4250688  {
4250689  printlines (num1, num1, false);
4250690  needprint = false;
4250691  }
4250692  //
4250693  lp = lp->next;
4250694  num1++;
4250695  }
4250696  //
4250697  if (!didsub)
4250698  {
4250699  fprintf (stderr, "No substitutions found for \"%s\"\n", oldstr);
4250700  }
4250701 }
4250702 //----------------------------------------------------------------------
4250703 // Search a line for the specified string starting at the specified
4250704 // offset in the line. Returns the offset of the found string, or -1.
4250705 //----------------------------------------------------------------------
4250706 len_t
4250707 findstring (line_t *lp, char *str, len_t len, len_t offset)
4250708 {
4250709  len_t left;
4250710  char *cp;
4250711  char *ncp;
4250712  //
4250713  cp = &lp->data[offset];
4250714  left = lp->len - offset;
4250715  //
4250716  while (left >= len)
4250717  {
4250718  ncp = memchr(cp, *str, left);
4250719  if (ncp == NULL)
4250720  {
4250721  return (len_t) -1;
4250722  }
4250723  //
4250724  left -= (ncp - cp);
4250725  if (left < len)
4250726  {
4250727  return (len_t) -1;
4250728  }
4250729  //
4250730  cp = ncp;
4250731  if (memcmp(cp, str, len) == 0)
4250732  {
4250733  return (len_t) (cp - lp->data);
4250734  }
4250735  //
4250736  cp++;
4250737  left--;
4250738  }
4250739  //
4250740  return (len_t) -1;
4250741 }
4250742 //----------------------------------------------------------------------
4250743 // Add lines which are typed in by the user.
4250744 // The lines are inserted just before the specified line number.
4250745 // The lines are terminated by a line containing a single dot (ugly!),
4250746 // or by an end of file.
4250747 //----------------------------------------------------------------------
4250748 void
4250749 addlines (num_t num)
4250750 {
4250751  int len;
4250752  char buf[USERSIZE + 1];
4250753  //
4250754  while (fgets (buf, sizeof (buf), stdin))
4250755  {
4250756  if ((buf[0] == '.') && (buf[1] == '\n') && (buf[2] == '0円'))
4250757  {
4250758  return;
4250759  }
4250760  //
4250761  len = strlen (buf);
4250762  //
4250763  if (len == 0)
4250764  {
4250765  return;
4250766  }
4250767  //
4250768  if (buf[len - 1] != '\n')
4250769  {
4250770  fprintf (stderr, "Line too long\n");
4250771  //
4250772  do
4250773  {
4250774  len = fgetc(stdin);
4250775  }
4250776  while ((len != EOF) && (len != '\n'));
4250777  //
4250778  return;
4250779  }
4250780  //
4250781  if (!insertline (num++, buf, len))
4250782  {
4250783  return;
4250784  }
4250785  }
4250786 }
4250787 //----------------------------------------------------------------------
4250788 // Parse a line number argument if it is present. This is a sum
4250789 // or difference of numbers, '.', '$', 'x, or a search string.
4250790 // Returns true if successful (whether or not there was a number). 
4250791 // Returns false if there was a parsing error, with a message output.
4250792 // Whether there was a number is returned indirectly, as is the number.
4250793 // The character pointer which stopped the scan is also returned.
4250794 //----------------------------------------------------------------------
4250795 static bool
4250796 getnum (char **retcp, bool *rethavenum, num_t *retnum)
4250797 {
4250798  char *cp;
4250799  char *str;
4250800  bool havenum;
4250801  num_t value;
4250802  num_t num;
4250803  num_t sign;
4250804  //
4250805  cp = *retcp;
4250806  havenum = false;
4250807  value = 0;
4250808  sign = 1;
4250809  //
4250810  while (true)
4250811  {
4250812  while (isblank(*cp))
4250813  {
4250814  cp++;
4250815  }
4250816  //
4250817  switch (*cp)
4250818  {
4250819  case '.':
4250820  havenum = true;
4250821  num = curnum;
4250822  cp++;
4250823  break;
4250824  //
4250825  case '$':
4250826  havenum = true;
4250827  num = lastnum;
4250828  cp++;
4250829  break;
4250830  //
4250831  case '\'':
4250832  cp++;
4250833  if ((*cp < 'a') || (*cp > 'z'))
4250834  {
4250835  fprintf (stderr, "Bad mark name\n");
4250836  return false;
4250837  }
4250838  //
4250839  havenum = true;
4250840  num = marks[*cp++ - 'a'];
4250841  break;
4250842  //
4250843  case '/':
4250844  str = ++cp;
4250845  cp = strchr (str, '/');
4250846  if (cp)
4250847  {
4250848  *cp++ = '0円';
4250849  }
4250850  else
4250851  {
4250852  cp = "";
4250853  }
4250854  num = searchlines (str, curnum, lastnum);
4250855  if (num == 0)
4250856  {
4250857  return false;
4250858  }
4250859  //
4250860  havenum = true;
4250861  break;
4250862  //
4250863  default:
4250864  if (!isdigit (*cp))
4250865  {
4250866  *retcp = cp;
4250867  *rethavenum = havenum;
4250868  *retnum = value;
4250869  return true;
4250870  }
4250871  //
4250872  num = 0;
4250873  while (isdigit(*cp))
4250874  {
4250875  num = num * 10 + *cp++ - '0';
4250876  }
4250877  havenum = true;
4250878  break;
4250879  }
4250880  //
4250881  value += num * sign;
4250882  //
4250883  while (isblank (*cp))
4250884  {
4250885  cp++;
4250886  }
4250887  //
4250888  switch (*cp)
4250889  {
4250890  case '-':
4250891  sign = -1;
4250892  cp++;
4250893  break;
4250894  //
4250895  case '+':
4250896  sign = 1;
4250897  cp++;
4250898  break;
4250899  //
4250900  default:
4250901  *retcp = cp;
4250902  *rethavenum = havenum;
4250903  *retnum = value;
4250904  return true;
4250905  }
4250906  }
4250907 }
4250908 //----------------------------------------------------------------------
4250909 // Initialize everything for editing.
4250910 //----------------------------------------------------------------------
4250911 bool
4250912 initedit (void)
4250913 {
4250914  int i;
4250915  //
4250916  bufsize = INITBUFSIZE;
4250917  bufbase = malloc (bufsize);
4250918  //
4250919  if (bufbase == NULL)
4250920  {
4250921  fprintf (stderr, "No memory for buffer\n");
4250922  return false;
4250923  }
4250924  //
4250925  bufptr = bufbase;
4250926  bufused = 0;
4250927  //
4250928  lines.next = &lines;
4250929  lines.prev = &lines;
4250930  //
4250931  curline = NULL;
4250932  curnum = 0;
4250933  lastnum = 0;
4250934  dirty = false;
4250935  filename = NULL;
4250936  searchstring[0] = '0円';
4250937  //
4250938  for (i = 0; i < 26; i++)
4250939  {
4250940  marks[i] = 0;
4250941  }
4250942  //
4250943  return true;
4250944 }
4250945 //----------------------------------------------------------------------
4250946 // Finish editing.
4250947 //----------------------------------------------------------------------
4250948 void
4250949 termedit (void)
4250950 {
4250951  if (bufbase) free(bufbase);
4250952  bufbase = NULL;
4250953  //
4250954  bufptr = NULL;
4250955  bufsize = 0;
4250956  bufused = 0;
4250957  //
4250958  if (filename) free(filename);
4250959  filename = NULL;
4250960  //
4250961  searchstring[0] = '0円';
4250962  //
4250963  if (lastnum) deletelines (1, lastnum);
4250964  //
4250965  lastnum = 0;
4250966  curnum = 0;
4250967  curline = NULL;
4250968 }
4250969 //----------------------------------------------------------------------
4250970 // Read lines from a file at the specified line number.
4250971 // Returns true if the file was successfully read.
4250972 //----------------------------------------------------------------------
4250973 bool
4250974 readlines (char *file, num_t num)
4250975 {
4250976  int fd;
4250977  int cc;
4250978  len_t len;
4250979  len_t linecount;
4250980  len_t charcount;
4250981  char *cp;
4250982  //
4250983  if ((num < 1) || (num > lastnum + 1))
4250984  {
4250985  fprintf (stderr, "Bad line for read\n");
4250986  return false;
4250987  }
4250988  //
4250989  fd = open (file, O_RDONLY);
4250990  if (fd < 0)
4250991  {
4250992  perror (file);
4250993  return false;
4250994  }
4250995  //
4250996  bufptr = bufbase;
4250997  bufused = 0;
4250998  linecount = 0;
4250999  charcount = 0;
4251000  //
4251001  printf ("\"%s\", ", file);
4251002  fflush(stdout);
4251003  //
4251004  do
4251005  {
4251006  cp = memchr(bufptr, '\n', bufused);
4251007  if (cp)
4251008  {
4251009  len = (cp - bufptr) + 1;
4251010  //
4251011  if (!insertline (num, bufptr, len))
4251012  {
4251013  close (fd);
4251014  return false;
4251015  }
4251016  //
4251017  bufptr += len;
4251018  bufused -= len;
4251019  charcount += len;
4251020  linecount++;
4251021  num++;
4251022  continue;
4251023  }
4251024  //
4251025  if (bufptr != bufbase)
4251026  {
4251027  memcpy (bufbase, bufptr, bufused);
4251028  bufptr = bufbase + bufused;
4251029  }
4251030  //
4251031  if (bufused >= bufsize)
4251032  {
4251033  len = (bufsize * 3) / 2;
4251034  cp = realloc (bufbase, len);
4251035  if (cp == NULL)
4251036  {
4251037  fprintf (stderr, "No memory for buffer\n");
4251038  close (fd);
4251039  return false;
4251040  }
4251041  //
4251042  bufbase = cp;
4251043  bufptr = bufbase + bufused;
4251044  bufsize = len;
4251045  }
4251046  //
4251047  cc = read (fd, bufptr, bufsize - bufused);
4251048  bufused += cc;
4251049  bufptr = bufbase;
4251050  }
4251051  while (cc > 0);
4251052  //
4251053  if (cc < 0)
4251054  {
4251055  perror (file);
4251056  close (fd);
4251057  return false;
4251058  }
4251059  //
4251060  if (bufused)
4251061  {
4251062  if (!insertline (num, bufptr, bufused))
4251063  {
4251064  close (fd);
4251065  return -1;
4251066  }
4251067  linecount++;
4251068  charcount += bufused;
4251069  }
4251070  //
4251071  close (fd);
4251072  //
4251073  printf ("%d lines%s, %d chars\n",
4251074  linecount,
4251075  (bufused ? " (incomplete)" : ""),
4251076  charcount);
4251077  //
4251078  return true;
4251079 }
4251080 //----------------------------------------------------------------------
4251081 // Write the specified lines out to the specified file.
4251082 // Returns true if successful, or false on an error with a message
4251083 // output.
4251084 //----------------------------------------------------------------------
4251085 bool
4251086 writelines (char *file, num_t num1, num_t num2)
4251087 {
4251088  int fd;
4251089  line_t *lp;
4251090  len_t linecount;
4251091  len_t charcount;
4251092  //
4251093  if ((num1 < 1) || (num2 > lastnum) || (num1 > num2))
4251094  {
4251095  fprintf (stderr, "Bad line range for write\n");
4251096  return false;
4251097  }
4251098  //
4251099  linecount = 0;
4251100  charcount = 0;
4251101  //
4251102  fd = creat (file, 0666);
4251103  if (fd < 0)
4251104  {
4251105  perror (file);
4251106  return false;
4251107  }
4251108  //
4251109  printf("\"%s\", ", file);
4251110  fflush (stdout);
4251111  //
4251112  lp = findline (num1);
4251113  if (lp == NULL)
4251114  {
4251115  close (fd);
4251116  return false;
4251117  }
4251118  //
4251119  while (num1++ <= num2)
4251120  {
4251121  if (write(fd, lp->data, lp->len) != lp->len)
4251122  {
4251123  perror(file);
4251124  close(fd);
4251125  return false;
4251126  }
4251127  //
4251128  charcount += lp->len;
4251129  linecount++;
4251130  lp = lp->next;
4251131  }
4251132  //
4251133  if (close(fd) < 0)
4251134  {
4251135  perror(file);
4251136  return false;
4251137  }
4251138  //
4251139  printf ("%d lines, %d chars\n", linecount, charcount);
4251140  //
4251141  return true;
4251142 }
4251143 //----------------------------------------------------------------------
4251144 // Print lines in a specified range.
4251145 // The last line printed becomes the current line.
4251146 // If expandflag is true, then the line is printed specially to
4251147 // show magic characters.
4251148 //----------------------------------------------------------------------
4251149 bool
4251150 printlines (num_t num1, num_t num2, bool expandflag)
4251151 {
4251152  line_t *lp;
4251153  unsigned char *cp;
4251154  int ch;
4251155  len_t count;
4251156  //
4251157  if ((num1 < 1) || (num2 > lastnum) || (num1 > num2))
4251158  {
4251159  fprintf (stderr, "Bad line range for print\n");
4251160  return false;
4251161  }
4251162  //
4251163  lp = findline (num1);
4251164  if (lp == NULL)
4251165  {
4251166  return false;
4251167  }
4251168  //
4251169  while (num1 <= num2)
4251170  {
4251171  if (!expandflag)
4251172  {
4251173  write (STDOUT_FILENO, lp->data, lp->len);
4251174  setcurnum (num1++);
4251175  lp = lp->next;
4251176  continue;
4251177  }
4251178 
4251179  //--------------------------------------------------------------
4251180  // Show control characters and characters with the
4251181  // high bit set specially.
4251182  //--------------------------------------------------------------
4251183 
4251184  cp = (unsigned char *) lp->data;
4251185  count = lp->len;
4251186  //
4251187  if ((count > 0) && (cp[count - 1] == '\n'))
4251188  {
4251189  count--;
4251190  }
4251191  //
4251192  while (count-- > 0)
4251193  {
4251194  ch = *cp++;
4251195  if (ch & 0x80)
4251196  {
4251197  fputs ("M-", stdout);
4251198  ch &= 0x7f;
4251199  }
4251200  if (ch < ' ')
4251201  {
4251202  fputc ('^', stdout);
4251203  ch += '@';
4251204  }
4251205  if (ch == 0x7f)
4251206  {
4251207  fputc ('^', stdout);
4251208  ch = '?';
4251209  }
4251210  fputc (ch, stdout);
4251211  }
4251212  //
4251213  fputs ("$\n", stdout);
4251214  //
4251215  setcurnum (num1++);
4251216  lp = lp->next;
4251217  }
4251218  //
4251219  return true;
4251220 }
4251221 //----------------------------------------------------------------------
4251222 // Insert a new line with the specified text.
4251223 // The line is inserted so as to become the specified line,
4251224 // thus pushing any existing and further lines down one.
4251225 // The inserted line is also set to become the current line.
4251226 // Returns true if successful.
4251227 //----------------------------------------------------------------------
4251228 bool
4251229 insertline (num_t num, char *data, len_t len)
4251230 {
4251231  line_t *newlp;
4251232  line_t *lp;
4251233  //
4251234  if ((num < 1) || (num > lastnum + 1))
4251235  {
4251236  fprintf (stderr, "Inserting at bad line number\n");
4251237  return false;
4251238  }
4251239  //
4251240  newlp = (line_t *) malloc (sizeof (line_t) + len - 1);
4251241  if (newlp == NULL)
4251242  {
4251243  fprintf (stderr, "Failed to allocate memory for line\n");
4251244  return false;
4251245  }
4251246  //
4251247  memcpy (newlp->data, data, len);
4251248  newlp->len = len;
4251249  //
4251250  if (num > lastnum)
4251251  {
4251252  lp = &lines;
4251253  }
4251254  else
4251255  {
4251256  lp = findline (num);
4251257  if (lp == NULL)
4251258  {
4251259  free ((char *) newlp);
4251260  return false;
4251261  }
4251262  }
4251263  //
4251264  newlp->next = lp;
4251265  newlp->prev = lp->prev;
4251266  lp->prev->next = newlp;
4251267  lp->prev = newlp;
4251268  //
4251269  lastnum++;
4251270  dirty = true;
4251271  //
4251272  return setcurnum (num);
4251273 }
4251274 //----------------------------------------------------------------------
4251275 // Delete lines from the given range.
4251276 //----------------------------------------------------------------------
4251277 bool
4251278 deletelines (num_t num1, num_t num2)
4251279 {
4251280  line_t *lp;
4251281  line_t *nlp;
4251282  line_t *plp;
4251283  num_t count;
4251284  //
4251285  if ((num1 < 1) || (num2 > lastnum) || (num1 > num2))
4251286  {
4251287  fprintf (stderr, "Bad line numbers for delete\n");
4251288  return false;
4251289  }
4251290  //
4251291  lp = findline (num1);
4251292  if (lp == NULL)
4251293  {
4251294  return false;
4251295  }
4251296  //
4251297  if ((curnum >= num1) && (curnum <= num2))
4251298  {
4251299  if (num2 < lastnum)
4251300  {
4251301  setcurnum (num2 + 1);
4251302  }
4251303  else if (num1 > 1)
4251304  {
4251305  setcurnum (num1 - 1);
4251306  }
4251307  else
4251308  {
4251309  curnum = 0;
4251310  }
4251311  }
4251312  //
4251313  count = num2 - num1 + 1;
4251314  //
4251315  if (curnum > num2)
4251316  {
4251317  curnum -= count;
4251318  }
4251319  //
4251320  lastnum -= count;
4251321  //
4251322  while (count-- > 0)
4251323  {
4251324  nlp = lp->next;
4251325  plp = lp->prev;
4251326  plp->next = nlp;
4251327  nlp->prev = plp;
4251328  lp->next = NULL;
4251329  lp->prev = NULL;
4251330  lp->len = 0;
4251331  free(lp);
4251332  lp = nlp;
4251333  }
4251334  //
4251335  dirty = true;
4251336  //
4251337  return true;
4251338 }
4251339 //----------------------------------------------------------------------
4251340 // Search for a line which contains the specified string.
4251341 // If the string is NULL, then the previously searched for string
4251342 // is used. The currently searched for string is saved for future use.
4251343 // Returns the line number which matches, or 0 if there was no match
4251344 // with an error printed.
4251345 //----------------------------------------------------------------------
4251346 num_t
4251347 searchlines (char *str, num_t num1, num_t num2)
4251348 {
4251349  line_t *lp;
4251350  int len;
4251351  //
4251352  if ((num1 < 1) || (num2 > lastnum) || (num1 > num2))
4251353  {
4251354  fprintf (stderr, "Bad line numbers for search\n");
4251355  return 0;
4251356  }
4251357  //
4251358  if (*str == '0円')
4251359  {
4251360  if (searchstring[0] == '0円')
4251361  {
4251362  fprintf(stderr, "No previous search string\n");
4251363  return 0;
4251364  }
4251365  str = searchstring;
4251366  }
4251367  //
4251368  if (str != searchstring)
4251369  {
4251370  strcpy(searchstring, str);
4251371  }
4251372  //
4251373  len = strlen(str);
4251374  //
4251375  lp = findline (num1);
4251376  if (lp == NULL)
4251377  {
4251378  return 0;
4251379  }
4251380  //
4251381  while (num1 <= num2)
4251382  {
4251383  if (findstring(lp, str, len, 0) >= 0)
4251384  {
4251385  return num1;
4251386  }
4251387  //
4251388  num1++;
4251389  lp = lp->next;
4251390  }
4251391  //
4251392  fprintf (stderr, "Cannot find string \"%s\"\n", str);
4251393  //
4251394  return 0;
4251395 }
4251396 //----------------------------------------------------------------------
4251397 // Return a pointer to the specified line number.
4251398 //----------------------------------------------------------------------
4251399 line_t *
4251400 findline (num_t num)
4251401 {
4251402  line_t *lp;
4251403  num_t lnum;
4251404  //
4251405  if ((num < 1) || (num > lastnum))
4251406  {
4251407  fprintf (stderr, "Line number %d does not exist\n", num);
4251408  return NULL;
4251409  }
4251410  //
4251411  if (curnum <= 0)
4251412  {
4251413  curnum = 1;
4251414  curline = lines.next;
4251415  }
4251416  //
4251417  if (num == curnum)
4251418  {
4251419  return curline;
4251420  }
4251421  //
4251422  lp = curline;
4251423  lnum = curnum;
4251424  //
4251425  if (num < (curnum / 2))
4251426  {
4251427  lp = lines.next;
4251428  lnum = 1;
4251429  }
4251430  else if (num > ((curnum + lastnum) / 2))
4251431  {
4251432  lp = lines.prev;
4251433  lnum = lastnum;
4251434  }
4251435  //
4251436  while (lnum < num)
4251437  {
4251438  lp = lp->next;
4251439  lnum++;
4251440  }
4251441  //
4251442  while (lnum > num)
4251443  {
4251444  lp = lp->prev;
4251445  lnum--;
4251446  }
4251447  //
4251448  return lp;
4251449 }
4251450 //----------------------------------------------------------------------
4251451 // Set the current line number.
4251452 // Returns true if successful.
4251453 //----------------------------------------------------------------------
4251454 bool
4251455 setcurnum (num_t num)
4251456 {
4251457  line_t *lp;
4251458  //
4251459  lp = findline (num);
4251460  if (lp == NULL)
4251461  {
4251462  return false;
4251463  }
4251464  //
4251465  curnum = num;
4251466  curline = lp;
4251467  //
4251468  return true;
4251469 }
4251470 
4251471 /* END CODE */

4260001 #include <unistd.h>
4260002 #include <stdio.h>
4260003 #include <stdlib.h>
4260004 #include <signal.h>
4260005 #include <sys/wait.h>
4260006 #include <limits.h>
4260007 #include <sys/os16.h>
4260008 #include <fcntl.h>
4260009 #include <stdio.h>
4260010 //----------------------------------------------------------------------
4260011 int
4260012 main (int argc, char *argv[], char *envp[])
4260013 {
4260014  char *device_name;
4260015  int fdn;
4260016  char *exec_argv[2];
4260017  char **exec_envp;
4260018  char buffer[BUFSIZ];
4260019  ssize_t size_read;
4260020  int status;
4260021  //
4260022  // The first argument is mandatory and must be a console terminal.
4260023  //
4260024  device_name = argv[1];
4260025  //
4260026  // A console terminal is correctly selected (but it is not checked
4260027  // if it is a really available one).
4260028  // Set as a process group leader.
4260029  //
4260030  setpgrp ();
4260031  //
4260032  // Open the terminal, that should become the controlling terminal:
4260033  // close the standard input and open the new terminal (r/w).
4260034  //
4260035  close (0);
4260036  fdn = open (device_name, O_RDWR);
4260037  if (fdn < 0)
4260038  {
4260039  //
4260040  // Cannot open terminal. A message should appear, at least
4260041  // to the current console.
4260042  //
4260043  perror (NULL);
4260044  return (-1);
4260045  }
4260046  //
4260047  // Reset terminal device permissions and ownership.
4260048  //
4260049  status = fchown (fdn, (uid_t) 0, (gid_t) 0);
4260050  if (status != 0)
4260051  {
4260052  perror (NULL);
4260053  }
4260054  status = fchmod (fdn, 0644);
4260055  if (status != 0)
4260056  {
4260057  perror (NULL);
4260058  }
4260059  //
4260060  // The terminal is open and it should be already the controlling
4260061  // one: show `/etc/issue'. The same variable `fdn' is used, because
4260062  // the controlling terminal will never be closed (the exit syscall
4260063  // will do it).
4260064  //
4260065  fdn = open ("/etc/issue", O_RDONLY);
4260066  if (fdn > 0)
4260067  {
4260068  //
4260069  // The file is present and is shown.
4260070  //
4260071  for (size_read = 1; size_read > 0;)
4260072  {
4260073  size_read = read (fdn, buffer, (size_t) (BUFSIZ - 1));
4260074  if (size_read < 0)
4260075  {
4260076  break;
4260077  }
4260078  buffer[size_read] = '0円';
4260079  printf ("%s", buffer);
4260080  }
4260081  close (fdn);
4260082  }
4260083  //
4260084  // Show the terminal.
4260085  //
4260086  printf ("This is terminal %s\n", device_name);
4260087  //
4260088  // It is time to exec login: the environment is inherited directly
4260089  // from `init'.
4260090  //
4260091  exec_argv[0] = "login";
4260092  exec_argv[1] = NULL;
4260093  exec_envp = envp;
4260094  execve ("/bin/login", exec_argv, exec_envp);
4260095  //
4260096  // If `execve()' returns, it is an error.
4260097  //
4260098  exit (-1);
4260099 }

4270001 #include <unistd.h>
4270002 #include <stdio.h>
4270003 #include <stdlib.h>
4270004 #include <signal.h>
4270005 #include <sys/wait.h>
4270006 #include <limits.h>
4270007 #include <sys/os16.h>
4270008 #include <fcntl.h>
4270009 #include <string.h>
4270010 //----------------------------------------------------------------------
4270011 #define RESPAWN_MAX 7
4270012 #define COMMAND_MAX 100
4270013 #define LINE_MAX 1024
4270014 //----------------------------------------------------------------------
4270015 int
4270016 main (int argc, char *argv[], char *envp[])
4270017 {
4270018  //
4270019  // `init.c' has its own `init.crt0.s' with a very small stack
4270020  // size. Remember to verify to have enough room for the stack.
4270021  //
4270022  pid_t pid;
4270023  int status;
4270024  char *exec_argv[3];
4270025  char *exec_envp[3];
4270026  char buffer[LINE_MAX];
4270027  int r; // Respawn table index.
4270028  int b; // Buffer index.
4270029  size_t size_read;
4270030  char *inittab_id;
4270031  char *inittab_runlevels;
4270032  char *inittab_action;
4270033  char *inittab_process;
4270034  int eof;
4270035  int fd;
4270036  //
4270037  // It follows a table for commands to be respawn.
4270038  //
4270039  struct {
4270040  pid_t pid;
4270041  char command[COMMAND_MAX];
4270042  } respawn[RESPAWN_MAX];
4270043 
4270044  //------------------------------------------------------------------
4270045  signal (SIGHUP, SIG_IGN);
4270046  signal (SIGINT, SIG_IGN);
4270047  signal (SIGQUIT, SIG_IGN);
4270048  signal (SIGILL, SIG_IGN);
4270049  signal (SIGABRT, SIG_IGN);
4270050  signal (SIGFPE, SIG_IGN);
4270051 // signal (SIGKILL, SIG_IGN); Cannot ignore SIGKILL.
4270052  signal (SIGSEGV, SIG_IGN);
4270053  signal (SIGPIPE, SIG_IGN);
4270054  signal (SIGALRM, SIG_IGN);
4270055  signal (SIGTERM, SIG_IGN);
4270056 // signal (SIGSTOP, SIG_IGN); Cannot ignore SIGSTOP.
4270057  signal (SIGTSTP, SIG_IGN);
4270058  signal (SIGCONT, SIG_IGN);
4270059  signal (SIGTTIN, SIG_IGN);
4270060  signal (SIGTTOU, SIG_IGN);
4270061  signal (SIGUSR1, SIG_IGN);
4270062  signal (SIGUSR2, SIG_IGN);
4270063  //------------------------------------------------------------------
4270064  printf ("init\n");
4270065  // heap_clear ();
4270066  // process_info ();
4270067  //------------------------------------------------------------------
4270068  //
4270069  // Reset the `respawn' table.
4270070  //
4270071  for (r = 0; r < RESPAWN_MAX; r++)
4270072  {
4270073  respawn[r].pid = 0;
4270074  respawn[r].command[0] = 0;
4270075  respawn[r].command[COMMAND_MAX-1] = 0;
4270076  }
4270077  //
4270078  // Read the `/etc/inittab' file.
4270079  //
4270080  fd = open ("/etc/inittab", O_RDONLY);
4270081  //
4270082  if (fd < 0)
4270083  {
4270084  perror ("Cannot open file `/etc/inittab'");
4270085  exit (-1);
4270086  }
4270087  //
4270088  //
4270089  //
4270090  for (eof = 0, r = 0; !eof && r < RESPAWN_MAX; r++)
4270091  {
4270092  for (b = 0; b < LINE_MAX; b++)
4270093  {
4270094  size_read = read (fd, &buffer[b], (size_t) 1);
4270095  if (size_read <= 0)
4270096  {
4270097  buffer[b] = 0;
4270098  eof = 1; // Close the read loop.
4270099  break;
4270100  }
4270101  if (buffer[b] == '\n')
4270102  {
4270103  buffer[b] = 0;
4270104  break;
4270105  }
4270106  }
4270107  //
4270108  // Remove comments: just replace `#' with `0円'.
4270109  //
4270110  for (b = 0; b < LINE_MAX; b++)
4270111  {
4270112  if (buffer[b] == '#')
4270113  {
4270114  buffer[b] = 0;
4270115  break;
4270116  }
4270117  }
4270118  //
4270119  // If the buffer is an empty string, just loop to next
4270120  // record.
4270121  //
4270122  if (strlen (buffer) == 0)
4270123  {
4270124  r--;
4270125  continue;
4270126  }
4270127  //
4270128  //
4270129  //
4270130  inittab_id = strtok (buffer, ":");
4270131  inittab_runlevels = strtok (NULL, ":");
4270132  inittab_action = strtok (NULL, ":");
4270133  inittab_process = strtok (NULL, ":");
4270134  //
4270135  // Only action `respawn' is used.
4270136  //
4270137  if (strcmp (inittab_action, "respawn") == 0)
4270138  {
4270139  strncpy (respawn[r].command, inittab_process, COMMAND_MAX);
4270140  }
4270141  else
4270142  {
4270143  r--;
4270144  }
4270145  }
4270146  //
4270147  //
4270148  //
4270149  close (fd);
4270150  //
4270151  // Define common environment.
4270152  //
4270153  exec_envp[0] = "PATH=/bin:/usr/bin:/sbin:/usr/sbin";
4270154  exec_envp[1] = "CONSOLE=/dev/console";
4270155  exec_envp[2] = NULL;
4270156  //
4270157  // Start processes.
4270158  //
4270159  for (r = 0; r < RESPAWN_MAX; r++)
4270160  {
4270161  if (strlen (respawn[r].command) > 0)
4270162  {
4270163  respawn[r].pid = fork ();
4270164  if (respawn[r].pid == 0)
4270165  {
4270166  exec_argv[0] = strtok (respawn[r].command, " \t");
4270167  exec_argv[1] = strtok (NULL, " \t");
4270168  exec_argv[2] = NULL;
4270169  execve (exec_argv[0], exec_argv, exec_envp);
4270170  perror (NULL);
4270171  exit (0);
4270172  }
4270173  }
4270174  }
4270175  //
4270176  // Wait for the death of child.
4270177  //
4270178  while (1)
4270179  {
4270180  pid = wait (&status);
4270181  for (r = 0; r < RESPAWN_MAX; r++)
4270182  {
4270183  if (pid == respawn[r].pid)
4270184  {
4270185  //
4270186  // Run it again.
4270187  //
4270188  respawn[r].pid = fork ();
4270189  if (respawn[r].pid == 0)
4270190  {
4270191  exec_argv[0] = strtok (respawn[r].command, " \t");
4270192  exec_argv[1] = strtok (NULL, " \t");
4270193  exec_argv[2] = NULL;
4270194  execve (exec_argv[0], exec_argv, exec_envp);
4270195  exit (0);
4270196  }
4270197  break;
4270198  }
4270199  }
4270200  }
4270201 }

4280001 #include <sys/os16.h>
4280002 #include <sys/stat.h>
4280003 #include <sys/types.h>
4280004 #include <unistd.h>
4280005 #include <stdlib.h>
4280006 #include <fcntl.h>
4280007 #include <errno.h>
4280008 #include <signal.h>
4280009 #include <stdio.h>
4280010 #include <string.h>
4280011 #include <limits.h>
4280012 #include <libgen.h>
4280013 //----------------------------------------------------------------------
4280014 static void usage (void);
4280015 //----------------------------------------------------------------------
4280016 int
4280017 main (int argc, char *argv[], char *envp[])
4280018 {
4280019  int signal;
4280020  int pid;
4280021  int a; // Index inside arguments.
4280022  int option_s = 0;
4280023  int option_l = 0;
4280024  int opt;
4280025  extern char *optarg;
4280026  extern int optopt;
4280027  //
4280028  // There must be at least an option, plus the program name.
4280029  //
4280030  if (argc < 2)
4280031  {
4280032  usage ();
4280033  return (1);
4280034  }
4280035  //
4280036  // Check for options.
4280037  //
4280038  while ((opt = getopt (argc, argv, ":ls:")) != -1)
4280039  {
4280040  switch (opt)
4280041  {
4280042  case 'l':
4280043  option_l = 1;
4280044  break;
4280045  case 's':
4280046  option_s = 1;
4280047  //
4280048  // In that case, there must be at least three arguments:
4280049  // the option, the signal and the process id.
4280050  //
4280051  if (argc < 4)
4280052  {
4280053  usage ();
4280054  return (1);
4280055  }
4280056  //
4280057  // Argument numbers are ok. Check the signal.
4280058  //
4280059  if (strcmp (optarg, "HUP") == 0)
4280060  {
4280061  signal = SIGHUP;
4280062  }
4280063  else if (strcmp (optarg, "INT") == 0)
4280064  {
4280065  signal = SIGINT;
4280066  }
4280067  else if (strcmp (optarg, "QUIT") == 0)
4280068  {
4280069  signal = SIGQUIT;
4280070  }
4280071  else if (strcmp (optarg, "ILL") == 0)
4280072  {
4280073  signal = SIGILL;
4280074  }
4280075  else if (strcmp (optarg, "ABRT") == 0)
4280076  {
4280077  signal = SIGABRT;
4280078  }
4280079  else if (strcmp (optarg, "FPE") == 0)
4280080  {
4280081  signal = SIGFPE;
4280082  }
4280083  else if (strcmp (optarg, "KILL") == 0)
4280084  {
4280085  signal = SIGKILL;
4280086  }
4280087  else if (strcmp (optarg, "SEGV") == 0)
4280088  {
4280089  signal = SIGSEGV;
4280090  }
4280091  else if (strcmp (optarg, "PIPE") == 0)
4280092  {
4280093  signal = SIGPIPE;
4280094  }
4280095  else if (strcmp (optarg, "ALRM") == 0)
4280096  {
4280097  signal = SIGALRM;
4280098  }
4280099  else if (strcmp (optarg, "TERM") == 0)
4280100  {
4280101  signal = SIGTERM;
4280102  }
4280103  else if (strcmp (optarg, "STOP") == 0)
4280104  {
4280105  signal = SIGSTOP;
4280106  }
4280107  else if (strcmp (optarg, "TSTP") == 0)
4280108  {
4280109  signal = SIGTSTP;
4280110  }
4280111  else if (strcmp (optarg, "CONT") == 0)
4280112  {
4280113  signal = SIGCONT;
4280114  }
4280115  else if (strcmp (optarg, "CHLD") == 0)
4280116  {
4280117  signal = SIGCHLD;
4280118  }
4280119  else if (strcmp (optarg, "TTIN") == 0)
4280120  {
4280121  signal = SIGTTIN;
4280122  }
4280123  else if (strcmp (optarg, "TTOU") == 0)
4280124  {
4280125  signal = SIGTTOU;
4280126  }
4280127  else if (strcmp (optarg, "USR1") == 0)
4280128  {
4280129  signal = SIGUSR1;
4280130  }
4280131  else if (strcmp (optarg, "USR2") == 0)
4280132  {
4280133  signal = SIGUSR2;
4280134  }
4280135  else
4280136  {
4280137  fprintf (stderr, "Unknown signal %s.\n", optarg);
4280138  return (1);
4280139  }
4280140  break;
4280141  case '?':
4280142  fprintf (stderr, "Unknown option -%c.\n", optopt);
4280143  usage ();
4280144  return (1);
4280145  break;
4280146  case ':':
4280147  fprintf (stderr, "Missing argument for option -%c\n",
4280148  optopt);
4280149  usage ();
4280150  return (1);
4280151  break;
4280152  default:
4280153  fprintf (stderr, "Getopt problem: unknown option %c\n",
4280154  opt);
4280155  return (1);
4280156  }
4280157  }
4280158  //
4280159  //
4280160  //
4280161  if (option_l && option_s)
4280162  {
4280163  fprintf (stderr, "Options \"-l\" and \"-s\" together ");
4280164  fprintf (stderr, "are incompatible.\n");
4280165  usage ();
4280166  return (1);
4280167  }
4280168  //
4280169  // Option "-l".
4280170  //
4280171  if (option_l)
4280172  {
4280173  printf ("HUP ");
4280174  printf ("INT ");
4280175  printf ("QUIT ");
4280176  printf ("ILL ");
4280177  printf ("ABRT ");
4280178  printf ("FPE ");
4280179  printf ("KILL ");
4280180  printf ("SEGV ");
4280181  printf ("PIPE ");
4280182  printf ("ALRM ");
4280183  printf ("TERM ");
4280184  printf ("STOP ");
4280185  printf ("TSTP ");
4280186  printf ("CONT ");
4280187  printf ("CHLD ");
4280188  printf ("TTIN ");
4280189  printf ("TTOU ");
4280190  printf ("USR1 ");
4280191  printf ("USR2 ");
4280192  printf ("\n");
4280193  }
4280194  //
4280195  // Option "-s".
4280196  //
4280197  if (option_s)
4280198  {
4280199  //
4280200  // Scan arguments.
4280201  //
4280202  for (a = 3; a < argc; a++)
4280203  {
4280204  //
4280205  // Get PID.
4280206  //
4280207  pid = atoi (argv[a]);
4280208  if (pid > 0)
4280209  {
4280210  //
4280211  // Kill.
4280212  //
4280213  if (kill (pid, signal) < 0)
4280214  {
4280215  perror (argv[a]);
4280216  }
4280217  }
4280218  else
4280219  {
4280220  fprintf (stderr, "Invalid PID %s.", argv[a]);
4280221  }
4280222  }
4280223  }
4280224  //
4280225  // All done.
4280226  //
4280227  return (0);
4280228 }
4280229 //----------------------------------------------------------------------
4280230 static void
4280231 usage (void)
4280232 {
4280233  fprintf (stderr, "Usage: kill -s SIGNAL_NAME PID...\n");
4280234  fprintf (stderr, " kill -l\n");
4280235 }

4290001 #include <sys/os16.h>
4290002 #include <sys/stat.h>
4290003 #include <sys/types.h>
4290004 #include <unistd.h>
4290005 #include <stdlib.h>
4290006 #include <fcntl.h>
4290007 #include <errno.h>
4290008 #include <signal.h>
4290009 #include <stdio.h>
4290010 #include <string.h>
4290011 #include <limits.h>
4290012 #include <libgen.h>
4290013 //----------------------------------------------------------------------
4290014 static void usage (void);
4290015 //----------------------------------------------------------------------
4290016 int
4290017 main (int argc, char *argv[], char *envp[])
4290018 {
4290019  char *source;
4290020  char *destination;
4290021  char *new_destination;
4290022  struct stat file_status;
4290023  int dest_is_a_dir = 0;
4290024  int a; // Argument index.
4290025  char path[PATH_MAX];
4290026  //
4290027  // There must be at least two arguments, plus the program name.
4290028  //
4290029  if (argc < 3)
4290030  {
4290031  usage ();
4290032  return (1);
4290033  }
4290034  //
4290035  // Select the last argument as the destination.
4290036  //
4290037  destination = argv[argc-1];
4290038  //
4290039  // Check if it is a directory and save it in a flag.
4290040  //
4290041  if (stat (destination, &file_status) == 0)
4290042  {
4290043  if (S_ISDIR (file_status.st_mode))
4290044  {
4290045  dest_is_a_dir = 1;
4290046  }
4290047  }
4290048  //
4290049  // If there are more than two arguments, verify that the last
4290050  // one is a directory.
4290051  //
4290052  if (argc > 3)
4290053  {
4290054  if (!dest_is_a_dir)
4290055  {
4290056  usage ();
4290057  fprintf (stderr, "The destination \"%s\" ",
4290058  destination);
4290059  fprintf (stderr, "is not a directory!\n");
4290060  return (1);
4290061  }
4290062  }
4290063  //
4290064  // Scan the arguments, excluded the last, that is the destination.
4290065  //
4290066  for (a = 1; a < (argc - 1); a++)
4290067  {
4290068  //
4290069  // Source.
4290070  //
4290071  source = argv[a];
4290072  //
4290073  // Verify access permissions.
4290074  //
4290075  if (access (source, R_OK) < 0)
4290076  {
4290077  perror (source);
4290078  continue;
4290079  }
4290080  //
4290081  // Destination.
4290082  //
4290083  // If it is a directory, the destination path
4290084  // must be corrected.
4290085  //
4290086  if (dest_is_a_dir)
4290087  {
4290088  path[0] = 0;
4290089  strcat (path, destination);
4290090  strcat (path, "/");
4290091  strcat (path, basename (source));
4290092  //
4290093  // Update the destination path.
4290094  //
4290095  new_destination = path;
4290096  }
4290097  else
4290098  {
4290099  new_destination = destination;
4290100  }
4290101  //
4290102  // Check if destination file exists.
4290103  //
4290104  if (stat (new_destination, &file_status) == 0)
4290105  {
4290106  fprintf (stderr, "The destination file, \"%s\", ",
4290107  new_destination);
4290108  fprintf (stderr, "already exists!\n");
4290109  continue;
4290110  }
4290111  //
4290112  // Everything is ready for the link.
4290113  //
4290114  if (link (source, new_destination) < 0)
4290115  {
4290116  perror (new_destination);
4290117  continue;
4290118  }
4290119  }
4290120  //
4290121  // All done.
4290122  //
4290123  return (0);
4290124 }
4290125 //----------------------------------------------------------------------
4290126 static void
4290127 usage (void)
4290128 {
4290129  fprintf (stderr, "Usage: ln OLD_NAME NEW_NAME\n");
4290130  fprintf (stderr, " ln FILE... DIRECTORY\n");
4290131 }

4300001 #include <unistd.h>
4300002 #include <stdlib.h>
4300003 #include <sys/stat.h>
4300004 #include <sys/types.h>
4300005 #include <fcntl.h>
4300006 #include <errno.h>
4300007 #include <unistd.h>
4300008 #include <signal.h>
4300009 #include <stdio.h>
4300010 #include <sys/wait.h>
4300011 #include <stdio.h>
4300012 #include <string.h>
4300013 #include <limits.h>
4300014 #include <stdint.h>
4300015 #include <sys/os16.h>
4300016 //----------------------------------------------------------------------
4300017 #define LOGIN_MAX 64
4300018 #define PASSWORD_MAX 64
4300019 #define HOME_MAX 64
4300020 #define LINE_MAX 1024
4300021 //----------------------------------------------------------------------
4300022 int
4300023 main (int argc, char *argv[], char *envp[])
4300024 {
4300025  char login[LOGIN_MAX];
4300026  char password[PASSWORD_MAX];
4300027  char buffer[LINE_MAX];
4300028  char *user_name;
4300029  char *user_password;
4300030  char *user_uid;
4300031  char *user_gid;
4300032  char *user_description;
4300033  char *user_home;
4300034  char *user_shell;
4300035  uid_t uid;
4300036  uid_t euid;
4300037  int fd;
4300038  ssize_t size_read;
4300039  int b; // Index inside buffer.
4300040  int loop;
4300041  char *exec_argv[2];
4300042  int status;
4300043  char *tty_path;
4300044  //
4300045  // Check if login is running correctly.
4300046  //
4300047  euid = geteuid ();
4300048  uid = geteuid ();
4300049  // //
4300050  // // Show process info.
4300051  // //
4300052  // heap_clear ();
4300053  // process_info ();
4300054  //
4300055  // Check privileges.
4300056  //
4300057  if (!(uid == 0 && euid == 0))
4300058  {
4300059  printf ("%s: can only run with root privileges!\n", argv[0]);
4300060  exit (-1);
4300061  }
4300062  //
4300063  // Prepare arguments for the shell call.
4300064  //
4300065  exec_argv[0] = "-";
4300066  exec_argv[1] = NULL;
4300067  //
4300068  // Login.
4300069  //
4300070  while (1)
4300071  {
4300072  fd = open ("/etc/passwd", O_RDONLY);
4300073  //
4300074  if (fd < 0)
4300075  {
4300076  perror ("Cannot open file `/etc/passwd'");
4300077  exit (-1);
4300078  }
4300079  //
4300080  printf ("Log in as \"root\" or \"user\" "
4300081  "with password \"ciao\" :-)\n");
4300082  input_line (login, "login:", LOGIN_MAX, INPUT_LINE_ECHO);
4300083  //
4300084  //
4300085  //
4300086  loop = 1;
4300087  while (loop)
4300088  {
4300089  for (b = 0; b < LINE_MAX; b++)
4300090  {
4300091  size_read = read (fd, &buffer[b], (size_t) 1);
4300092  if (size_read <= 0)
4300093  {
4300094  buffer[b] = 0;
4300095  loop = 0; // Close the middle loop.
4300096  break;
4300097  }
4300098  if (buffer[b] == '\n')
4300099  {
4300100  buffer[b] = 0;
4300101  break;
4300102  }
4300103  }
4300104  //
4300105  user_name = strtok (buffer, ":");
4300106  user_password = strtok (NULL, ":");
4300107  user_uid = strtok (NULL, ":");
4300108  user_gid = strtok (NULL, ":");
4300109  user_description = strtok (NULL, ":");
4300110  user_home = strtok (NULL, ":");
4300111  user_shell = strtok (NULL, ":");
4300112  //
4300113  if (strcmp (user_name, login) == 0)
4300114  {
4300115  input_line (password, "password:", PASSWORD_MAX,
4300116  INPUT_LINE_STARS);
4300117  //
4300118  // Compare passwords: empty passwords are not allowed.
4300119  //
4300120  if (strcmp (user_password, password) == 0)
4300121  {
4300122  uid = atoi (user_uid);
4300123  euid = uid;
4300124  //
4300125  // Find the controlling terminal and change
4300126  // property and access permissions.
4300127  //
4300128  tty_path = ttyname (STDIN_FILENO);
4300129  if (tty_path != NULL)
4300130  {
4300131  status = chown (tty_path, uid, 0);
4300132  if (status != 0)
4300133  {
4300134  perror (NULL);
4300135  }
4300136  status = chmod (tty_path, 0600);
4300137  if (status != 0)
4300138  {
4300139  perror (NULL);
4300140  }
4300141  }
4300142  //
4300143  // Cd to the home directory, if present.
4300144  //
4300145  status = chdir (user_home);
4300146  if (status != 0)
4300147  {
4300148  perror (NULL);
4300149  }
4300150  //
4300151  // Now change personality.
4300152  //
4300153  setuid (uid);
4300154  seteuid (euid);
4300155  //
4300156  // Run the shell, replacing the login process; the
4300157  // environment is taken from `init'.
4300158  //
4300159  execve (user_shell, exec_argv, envp);
4300160  exit (0);
4300161  }
4300162  //
4300163  // Login failed: will try again.
4300164  //
4300165  loop = 0; // Close the middle loop.
4300166  break;
4300167  }
4300168  }
4300169  close (fd);
4300170  }
4300171 }

4310001 #include <sys/os16.h>
4310002 #include <sys/stat.h>
4310003 #include <sys/types.h>
4310004 #include <unistd.h>
4310005 #include <stdlib.h>
4310006 #include <fcntl.h>
4310007 #include <errno.h>
4310008 #include <signal.h>
4310009 #include <stdio.h>
4310010 #include <string.h>
4310011 #include <limits.h>
4310012 #include <libgen.h>
4310013 #include <dirent.h>
4310014 #include <pwd.h>
4310015 #include <time.h>
4310016 
4310017 #define BUFFER_SIZE 16384
4310018 #define LIST_SIZE 256
4310019 
4310020 //----------------------------------------------------------------------
4310021 static void usage (void);
4310022 //----------------------------------------------------------------------
4310023 //----------------------------------------------------------------------
4310024 int compare (void *p1, void *p2);
4310025 //----------------------------------------------------------------------
4310026 int
4310027 main (int argc, char *argv[], char *envp[])
4310028 {
4310029  int option_a = 0;
4310030  int option_l = 0;
4310031  int opt;
4310032 // extern char *optarg; // not used.
4310033  extern int optind;
4310034  extern int optopt;
4310035  struct stat file_status;
4310036  DIR *dp;
4310037  struct dirent *dir;
4310038  char buffer[BUFFER_SIZE];
4310039  int b; // Buffer index.
4310040  char *list[LIST_SIZE];
4310041  int l; // List index.
4310042  int len; // Name length.
4310043  char *path = NULL;
4310044  char pathname[PATH_MAX];
4310045  struct passwd *pws;
4310046  struct tm *tms;
4310047  //
4310048  // Check for options.
4310049  //
4310050  while ((opt = getopt (argc, argv, ":al")) != -1)
4310051  {
4310052  switch (opt)
4310053  {
4310054  case 'l':
4310055  option_l = 1;
4310056  break;
4310057  case 'a':
4310058  option_a = 1;
4310059  break;
4310060  case '?':
4310061  fprintf (stderr, "Unknown option -%c.\n", optopt);
4310062  usage ();
4310063  return (1);
4310064  break;
4310065  case ':':
4310066  fprintf (stderr, "Missing argument for option -%c\n",
4310067  optopt);
4310068  usage ();
4310069  return (1);
4310070  break;
4310071  default:
4310072  fprintf (stderr, "Getopt problem: unknown option %c\n",
4310073  opt);
4310074  return (1);
4310075  }
4310076  }
4310077  //
4310078  // If no arguments are present, at least the current directory is
4310079  // read.
4310080  //
4310081  if (optind == argc)
4310082  {
4310083  //
4310084  // There are no more arguments. Replace the program name,
4310085  // corresponding to `argv[0]', with the current directory
4310086  // path string.
4310087  //
4310088  argv[0] = ".";
4310089  argc = 1;
4310090  optind = 0;
4310091  }
4310092  //
4310093  // This is a very simplified `ls': if there is only a name
4310094  // and it is a directory, the directory content is taken as
4310095  // the new `argv[]' array.
4310096  //
4310097  if (optind == (argc -1))
4310098  {
4310099  //
4310100  // There is a request for a single name. Test if it exists
4310101  // and if it is a directory.
4310102  //
4310103  if (stat(argv[optind], &file_status) != 0)
4310104  {
4310105  fprintf (stderr, "File \"%s\" does not exist!\n",
4310106  argv[optind]);
4310107  return (2);
4310108  }
4310109  //
4310110  if (S_ISDIR (file_status.st_mode))
4310111  {
4310112  //
4310113  // Save the directory inside the `path' pointer.
4310114  //
4310115  path = argv[optind];
4310116  //
4310117  // Open the directory.
4310118  //
4310119  dp = opendir (argv[optind]);
4310120  if (dp == NULL)
4310121  {
4310122  perror (argv[optind]);
4310123  return (3);
4310124  }
4310125  //
4310126  // Read the directory and fill the buffer with names.
4310127  //
4310128  b = 0;
4310129  l = 0;
4310130  while ((dir = readdir (dp)) != NULL)
4310131  {
4310132  len = strlen (dir->d_name);
4310133  //
4310134  // Check if the buffer can hold it.
4310135  //
4310136  if ((b + len + 1 ) > BUFFER_SIZE)
4310137  {
4310138  fprintf (stderr, "not enough memory\n");
4310139  break;
4310140  }
4310141  //
4310142  // Consider the directory item only if there is
4310143  // a valid name. If it is empty, just ignore it.
4310144  //
4310145  if (len > 0)
4310146  {
4310147  strcpy (&buffer[b], dir->d_name);
4310148  list[l] = &buffer[b];
4310149  b += len + 1;
4310150  l++;
4310151  }
4310152  }
4310153  //
4310154  // Close the directory.
4310155  //
4310156  closedir (dp);
4310157  //
4310158  // Sort the list.
4310159  //
4310160  qsort (list, (size_t) l, sizeof (char *), compare);
4310161 
4310162  //
4310163  // Convert the directory list into a new `argv[]' array,
4310164  // with a valid `argc'. The variable `optind' must be
4310165  // reset to the first element index, because there is
4310166  // no program name inside the new `argv[]' at index zero.
4310167  //
4310168  argv = list;
4310169  argc = l;
4310170  optind = 0;
4310171  }
4310172  }
4310173  //
4310174  // Scan arguments, or list converted into `argv[]'.
4310175  //
4310176  for (; optind < argc; optind++)
4310177  {
4310178  if (argv[optind][0] == '.')
4310179  {
4310180  //
4310181  // Current name starts with `.'.
4310182  //
4310183  if (!option_a)
4310184  {
4310185  //
4310186  // Do not show name starting with `.'.
4310187  //
4310188  continue;
4310189  }
4310190  }
4310191  //
4310192  // Build the pathname.
4310193  //
4310194  if (path == NULL)
4310195  {
4310196  strcpy (&pathname[0], argv[optind]);
4310197  }
4310198  else
4310199  {
4310200  strcpy (pathname, path);
4310201  strcat (pathname, "/");
4310202  strcat (pathname, argv[optind]);
4310203  }
4310204  //
4310205  // Check if file exists, reading status.
4310206  //
4310207  if (stat(pathname, &file_status) != 0)
4310208  {
4310209  fprintf (stderr, "File \"%s\" does not exist!\n",
4310210  pathname);
4310211  return (2);
4310212  }
4310213  //
4310214  // Show file name.
4310215  //
4310216  if (option_l)
4310217  {
4310218  //
4310219  // Print the file type.
4310220  //
4310221  if (S_ISBLK (file_status.st_mode)) printf ("b");
4310222  else if (S_ISCHR (file_status.st_mode)) printf ("c");
4310223  else if (S_ISFIFO (file_status.st_mode)) printf ("p");
4310224  else if (S_ISREG (file_status.st_mode)) printf ("-");
4310225  else if (S_ISDIR (file_status.st_mode)) printf ("d");
4310226  else if (S_ISLNK (file_status.st_mode)) printf ("l");
4310227  else if (S_ISSOCK (file_status.st_mode)) printf ("s");
4310228  else printf ("?");
4310229  //
4310230  // Print permissions.
4310231  //
4310232  if (S_IRUSR & file_status.st_mode) printf ("r");
4310233  else printf ("-");
4310234  if (S_IWUSR & file_status.st_mode) printf ("w");
4310235  else printf ("-");
4310236  if (S_IXUSR & file_status.st_mode) printf ("x");
4310237  else printf ("-");
4310238  if (S_IRGRP & file_status.st_mode) printf ("r");
4310239  else printf ("-");
4310240  if (S_IWGRP & file_status.st_mode) printf ("w");
4310241  else printf ("-");
4310242  if (S_IXGRP & file_status.st_mode) printf ("x");
4310243  else printf ("-");
4310244  if (S_IROTH & file_status.st_mode) printf ("r");
4310245  else printf ("-");
4310246  if (S_IWOTH & file_status.st_mode) printf ("w");
4310247  else printf ("-");
4310248  if (S_IXOTH & file_status.st_mode) printf ("x");
4310249  else printf ("-");
4310250  //
4310251  // Print links.
4310252  //
4310253  printf (" %3i", (int) file_status.st_nlink);
4310254  //
4310255  // Print owner.
4310256  //
4310257  pws = getpwuid (file_status.st_uid);
4310258  //
4310259  printf (" %s", pws->pw_name);
4310260  //
4310261  // Print group (no group available);
4310262  //
4310263  printf (" (no group)");
4310264  //
4310265  // Print file size or device major-minor.
4310266  //
4310267  if (S_ISBLK (file_status.st_mode)
4310268  || S_ISCHR (file_status.st_mode))
4310269  {
4310270  printf (" %3i,", (int) major (file_status.st_rdev));
4310271  printf (" %3i", (int) minor (file_status.st_rdev));
4310272  }
4310273  else
4310274  {
4310275  printf (" %8i", (int) file_status.st_size);
4310276  }
4310277  //
4310278  // Print modification date and time.
4310279  //
4310280  tms = localtime (&(file_status.st_mtime));
4310281  printf (" %4u-%02u-%02u %02u:%02u",
4310282  tms->tm_year, tms->tm_mon, tms->tm_mday,
4310283  tms->tm_hour, tms->tm_min);
4310284  //
4310285  // Print file name, but with no additional path.
4310286  //
4310287  printf (" %s\n", argv[optind]);
4310288  }
4310289  else
4310290  {
4310291  //
4310292  // Just show the file name and go to the next line.
4310293  //
4310294  printf ("%s\n", argv[optind]);
4310295  }
4310296  }
4310297  //
4310298  // All done.
4310299  //
4310300  return (0);
4310301 }
4310302 //----------------------------------------------------------------------
4310303 static void
4310304 usage (void)
4310305 {
4310306  fprintf (stderr, "Usage: ls [OPTION] [FILE]...\n");
4310307 }
4310308 //----------------------------------------------------------------------
4310309 int
4310310 compare (void *p1, void *p2)
4310311 {
4310312  char **pp1 = p1;
4310313  char **pp2 = p2;
4310314  //
4310315  return (strcmp (*pp1, *pp2));
4310316 }
4310317 

4320001 #include <unistd.h>
4320002 #include <stdlib.h>
4320003 #include <errno.h>
4320004 //----------------------------------------------------------------------
4320005 #define MAX_LINES 20
4320006 #define MAX_COLUMNS 80
4320007 //----------------------------------------------------------------------
4320008 static char *man_page_directory = "/usr/share/man";
4320009 //----------------------------------------------------------------------
4320010 static void usage (void);
4320011 static FILE *open_man_page (int section, char *name);
4320012 static void build_path_name (int section, char *name, char *path);
4320013 //----------------------------------------------------------------------
4320014 int
4320015 main (int argc, char *argv[], char *envp[])
4320016 {
4320017  FILE *fp;
4320018  char *name;
4320019  int section;
4320020  int c;
4320021  int line = 1; // Line internal counter.
4320022  int column = 1; // Column internal counter.
4320023  int loop;
4320024  //
4320025  // There must be minimum an argument, and maximum two.
4320026  //
4320027  if (argc < 2 || argc > 3)
4320028  {
4320029  usage ();
4320030  return (1);
4320031  }
4320032  //
4320033  // If there are two arguments, there must be the
4320034  // section number.
4320035  //
4320036  if (argc == 3)
4320037  {
4320038  section = atoi (argv[1]);
4320039  name = argv[2];
4320040  }
4320041  else
4320042  {
4320043  section = 0;
4320044  name = argv[1];
4320045  }
4320046  //
4320047  // Try to open the manual page.
4320048  //
4320049  fp = open_man_page (section, name);
4320050  //
4320051  if (fp == NULL)
4320052  {
4320053  //
4320054  // Error opening file.
4320055  //
4320056  return (1);
4320057  }
4320058 
4320059  //
4320060  // The following loop continues while the file
4320061  // gives characters, or when a command to change
4320062  // file or to quit is given.
4320063  //
4320064  for (loop = 1; loop; )
4320065  {
4320066  //
4320067  // Read a single character.
4320068  //
4320069  c = getc (fp);
4320070  //
4320071  if (c == EOF)
4320072  {
4320073  loop = 0;
4320074  break;
4320075  }
4320076  //
4320077  // If the character read is a special one,
4320078  // the line/column calculation is modified,
4320079  // so that it is known when to stop scrolling.
4320080  //
4320081  switch (c)
4320082  {
4320083  case '\r':
4320084  //
4320085  // Displaying this character, the cursor should go
4320086  // back to the first column. So the column counter
4320087  // is reset.
4320088  //
4320089  column = 1;
4320090  break;
4320091  case '\n':
4320092  //
4320093  // Displaying this character, the cursor should go
4320094  // back to the next line, at the first column.
4320095  // So the column counter is reset and the line
4320096  // counter is incremented.
4320097  //
4320098  line++;
4320099  column = 1;
4320100  break;
4320101  case '\b':
4320102  //
4320103  // Displaying this character, the cursor should go
4320104  // back one position, unless it is already at the
4320105  // beginning.
4320106  //
4320107  if (column > 1)
4320108  {
4320109  column--;
4320110  }
4320111  break;
4320112  default:
4320113  //
4320114  // Any other character must increase the column
4320115  // counter.
4320116  //
4320117  column++;
4320118  }
4320119  //
4320120  // Display the character, even if it is a special one:
4320121  // it is responsibility of the screen device management
4320122  // to do something good with special characters.
4320123  //
4320124  putchar (c);
4320125  //
4320126  // If the column counter is gone beyond the screen columns,
4320127  // then adjust the column counter and increment the line
4320128  // counter.
4320129  //
4320130  if (column > MAX_COLUMNS)
4320131  {
4320132  column -= MAX_COLUMNS;
4320133  line++;
4320134  }
4320135  //
4320136  // Check if there is space for scrolling.
4320137  //
4320138  if (line < MAX_LINES)
4320139  {
4320140  continue;
4320141  }
4320142  //
4320143  // Here, displayed lines are MAX_LINES.
4320144  //
4320145  if (column > 1)
4320146  {
4320147  //
4320148  // Something was printed at the current line: must
4320149  // do a new line.
4320150  //
4320151  putchar ('\n');
4320152  }
4320153  //
4320154  // Show the more prompt.
4320155  //
4320156  printf ("--More--");
4320157  fflush (stdout);
4320158  //
4320159  // Read a character from standard input.
4320160  //
4320161  c = getchar ();
4320162  //
4320163  // Consider command `q', but any other character
4320164  // can be introduced, to let show the next page.
4320165  //
4320166  switch (c)
4320167  {
4320168  case 'Q':
4320169  case 'q':
4320170  //
4320171  // Quit. But must erase the `--More--' prompt.
4320172  //
4320173  printf ("\b \b\b \b\b \b\b \b\b \b");
4320174  printf ("\b \b\b \b\b \b\b \b");
4320175  fclose (fp);
4320176  return (0);
4320177  }
4320178  //
4320179  // Backspace to overwrite `--More--' and the character
4320180  // pressed.
4320181  //
4320182  printf ("\b \b\b \b\b \b\b \b\b \b\b \b\b \b\b \b\b \b");
4320183  //
4320184  // Reset line/column counters.
4320185  //
4320186  column = 1;
4320187  line = 1;
4320188  }
4320189  //
4320190  // Close the file pointer if it is still open.
4320191  //
4320192  if (fp != NULL)
4320193  {
4320194  fclose (fp);
4320195  }
4320196  //
4320197  return (0);
4320198 }
4320199 //----------------------------------------------------------------------
4320200 static void
4320201 usage (void)
4320202 {
4320203  fprintf (stderr, "Usage: man [SECTION] NAME\n");
4320204 }
4320205 //----------------------------------------------------------------------
4320206 FILE *
4320207 open_man_page (int section, char *name)
4320208 {
4320209  FILE *fp;
4320210  char path[PATH_MAX];
4320211  struct stat file_status;
4320212  //
4320213  //
4320214  //
4320215  if (section > 0)
4320216  {
4320217  build_path_name (section, name, path);
4320218  //
4320219  // Check if file exists.
4320220  //
4320221  if (stat (path, &file_status) != 0)
4320222  {
4320223  fprintf (stderr, "Man page %s(%i) does not exist!\n",
4320224  name, section);
4320225  return (NULL);
4320226  }
4320227  }
4320228  else
4320229  {
4320230  //
4320231  // Must try a section.
4320232  //
4320233  for (section = 1; section < 9; section++)
4320234  {
4320235  build_path_name (section, name, path);
4320236  //
4320237  // Check if file exists.
4320238  //
4320239  if (stat (path, &file_status) == 0)
4320240  {
4320241  //
4320242  // Found.
4320243  //
4320244  break;
4320245  }
4320246  }
4320247  }
4320248  //
4320249  // Check if a file was found.
4320250  //
4320251  if (section < 9)
4320252  {
4320253  fp = fopen (path, "r");
4320254  //
4320255  if (fp == NULL)
4320256  {
4320257  //
4320258  // Error opening file.
4320259  //
4320260  perror (path);
4320261  return (NULL);
4320262  }
4320263  else
4320264  {
4320265  //
4320266  // Opened right.
4320267  //
4320268  return (fp);
4320269  }
4320270  }
4320271  else
4320272  {
4320273  fprintf (stderr, "Man page %s does not exist!\n",
4320274  name);
4320275  return (NULL);
4320276  }
4320277 }
4320278 //----------------------------------------------------------------------
4320279 void
4320280 build_path_name (int section, char *name, char *path)
4320281 {
4320282  char string_section[10];
4320283  //
4320284  // Convert the section number into a string.
4320285  //
4320286  sprintf (string_section, "%i", section);
4320287  //
4320288  // Prepare the path to the man file.
4320289  //
4320290  path[0] = 0;
4320291  strcat (path, man_page_directory);
4320292  strcat (path, "/");
4320293  strcat (path, name);
4320294  strcat (path, ".");
4320295  strcat (path, string_section);
4320296 }

4330001 #include <sys/os16.h>
4330002 #include <sys/stat.h>
4330003 #include <sys/types.h>
4330004 #include <unistd.h>
4330005 #include <stdlib.h>
4330006 #include <fcntl.h>
4330007 #include <errno.h>
4330008 #include <signal.h>
4330009 #include <stdio.h>
4330010 #include <string.h>
4330011 #include <limits.h>
4330012 #include <libgen.h>
4330013 //----------------------------------------------------------------------
4330014 static int mkdir_parents (const char *path, mode_t mode);
4330015 static void usage (void);
4330016 //----------------------------------------------------------------------
4330017 int
4330018 main (int argc, char *argv[], char *envp[])
4330019 {
4330020  sysmsg_uarea_t msg;
4330021  int status;
4330022  mode_t mode = 0;
4330023  int m; // Index inside mode argument.
4330024  int digit;
4330025  char **dir;
4330026  int d; // Directory index.
4330027  int option_p = 0;
4330028  int option_m = 0;
4330029  int opt;
4330030  extern char *optarg;
4330031  extern int optind;
4330032  extern int optopt;
4330033  //
4330034  // There must be at least an argument, plus the program name.
4330035  //
4330036  if (argc < 2)
4330037  {
4330038  usage ();
4330039  return (1);
4330040  }
4330041  //
4330042  // Check for options, starting from `p'. The `dir' pointer is used
4330043  // to calculate the argument pointer to the first directory [1].
4330044  // The macro-instruction `max()' is declared inside <sys/os16.h>
4330045  // and does the expected thing.
4330046  //
4330047  while ((opt = getopt (argc, argv, ":pm:")) != -1)
4330048  {
4330049  switch (opt)
4330050  {
4330051  case 'm':
4330052  option_m = 1;
4330053  for (m = 0; m < strlen (optarg); m++)
4330054  {
4330055  digit = (optarg[m] - '0');
4330056  if (digit < 0 || digit > 7)
4330057  {
4330058  usage ();
4330059  return (2);
4330060  }
4330061  mode = mode * 8 + digit;
4330062  }
4330063  break;
4330064  case 'p':
4330065  option_p = 1;
4330066  break;
4330067  case '?':
4330068  printf ("Unknown option -%c.\n", optopt);
4330069  usage ();
4330070  return (1);
4330071  break;
4330072  case ':':
4330073  printf ("Missing argument for option -%c\n", optopt);
4330074  usage ();
4330075  return (2);
4330076  break;
4330077  default:
4330078  printf ("Getopt problem: unknown option %c\n", opt);
4330079  return (3);
4330080  }
4330081  }
4330082  //
4330083  dir = argv + optind;
4330084  //
4330085  // Check if the mode is to be set to a default value.
4330086  //
4330087  if (!option_m)
4330088  {
4330089  //
4330090  // Default mode.
4330091  //
4330092  sys (SYS_UAREA, &msg, (sizeof msg));
4330093  mode = 0777 & ~msg.umask;
4330094  }
4330095  //
4330096  // Directory creation.
4330097  //
4330098  for (d = 0; dir[d] != NULL; d++)
4330099  {
4330100  if (option_p)
4330101  {
4330102  status = mkdir_parents (dir[d], mode);
4330103  if (status != 0)
4330104  {
4330105  perror (dir[d]);
4330106  return (3);
4330107  }
4330108  }
4330109  else
4330110  {
4330111  status = mkdir (dir[d], mode);
4330112  if (status != 0)
4330113  {
4330114  perror (dir[d]);
4330115  return (4);
4330116  }
4330117  }
4330118  }
4330119  //
4330120  // All done.
4330121  //
4330122  return (0);
4330123 }
4330124 //----------------------------------------------------------------------
4330125 static int
4330126 mkdir_parents (const char *path, mode_t mode)
4330127 {
4330128  char path_copy[PATH_MAX];
4330129  char *path_parent;
4330130  struct stat fst;
4330131  int status;
4330132  //
4330133  // Check if the path is empty.
4330134  //
4330135  if (path == NULL || strlen (path) == 0)
4330136  {
4330137  //
4330138  // Recursion ends here.
4330139  //
4330140  return (0);
4330141  }
4330142  //
4330143  // Check if it does already exists.
4330144  //
4330145  status = stat (path, &fst);
4330146  if (status == 0 && fst.st_mode & S_IFDIR)
4330147  {
4330148  //
4330149  // The path exists and is a directory.
4330150  //
4330151  return (0);
4330152  }
4330153  else if (status == 0 && !(fst.st_mode & S_IFDIR))
4330154  {
4330155  //
4330156  // The path exists but is not a directory.
4330157  //
4330158  errno = ENOTDIR; // Not a directory.
4330159  return (-1);
4330160  }
4330161  //
4330162  // Get the directory path.
4330163  //
4330164  strncpy (path_copy, path, PATH_MAX);
4330165  path_parent = dirname (path_copy);
4330166  //
4330167  // If it is `.', or `/', the recursion is terminated.
4330168  //
4330169  if (strncmp (path_parent, ".", PATH_MAX) == 0 ||
4330170  strncmp (path_parent, "/", PATH_MAX) == 0)
4330171  {
4330172  return (0);
4330173  }
4330174  //
4330175  // Otherwise, continue the recursion.
4330176  //
4330177  status = mkdir_parents (path_parent, mode);
4330178  if (status != 0)
4330179  {
4330180  return (-1);
4330181  }
4330182  //
4330183  // Previous directories are there: create the current one.
4330184  //
4330185  status = mkdir (path, mode);
4330186  if (status)
4330187  {
4330188  perror (path);
4330189  return (-1);
4330190  }
4330191 
4330192  return (0);
4330193 }
4330194 //----------------------------------------------------------------------
4330195 static void
4330196 usage (void)
4330197 {
4330198  fprintf (stderr, "Usage: mkdir [-p] [-m OCTAL_MODE] DIR...\n");
4330199 }

4340001 #include <unistd.h>
4340002 #include <errno.h>
4340003 //----------------------------------------------------------------------
4340004 #define MAX_LINES 20
4340005 #define MAX_COLUMNS 80
4340006 //----------------------------------------------------------------------
4340007 static void usage (void);
4340008 //----------------------------------------------------------------------
4340009 int
4340010 main (int argc, char *argv[], char *envp[])
4340011 {
4340012  FILE *fp;
4340013  char *name;
4340014  int c;
4340015  int line = 1; // Line internal counter.
4340016  int column = 1; // Column internal counter.
4340017  int a; // Index inside arguments.
4340018  int loop;
4340019  //
4340020  // There must be at least an argument, plus the program name.
4340021  //
4340022  if (argc < 2)
4340023  {
4340024  usage ();
4340025  return (1);
4340026  }
4340027  //
4340028  // No options are allowed.
4340029  //
4340030  for (a = 1; a < argc ; a++)
4340031  {
4340032  //
4340033  // Get next name from arguments.
4340034  //
4340035  name = argv[a];
4340036  //
4340037  // Try to open the file, read only.
4340038  //
4340039  fp = fopen (name, "r");
4340040  //
4340041  if (fp == NULL)
4340042  {
4340043  //
4340044  // Error opening file.
4340045  //
4340046  perror (name);
4340047  return (1);
4340048  }
4340049  //
4340050  // Print the file name to be displayed.
4340051  //
4340052  printf ("== %s ==\n", name);
4340053  line++;
4340054  //
4340055  // The following loop continues while the file
4340056  // gives characters, or when a command to change
4340057  // file or to quit is given.
4340058  //
4340059  for (loop = 1; loop; )
4340060  {
4340061  //
4340062  // Read a single character.
4340063  //
4340064  c = getc (fp);
4340065  //
4340066  if (c == EOF)
4340067  {
4340068  loop = 0;
4340069  break;
4340070  }
4340071  //
4340072  // If the character read is a special one,
4340073  // the line/column calculation is modified,
4340074  // so that it is known when to stop scrolling.
4340075  //
4340076  switch (c)
4340077  {
4340078  case '\r':
4340079  //
4340080  // Displaying this character, the cursor should go
4340081  // back to the first column. So the column counter
4340082  // is reset.
4340083  //
4340084  column = 1;
4340085  break;
4340086  case '\n':
4340087  //
4340088  // Displaying this character, the cursor should go
4340089  // back to the next line, at the first column.
4340090  // So the column counter is reset and the line
4340091  // counter is incremented.
4340092  //
4340093  line++;
4340094  column = 1;
4340095  break;
4340096  case '\b':
4340097  //
4340098  // Displaying this character, the cursor should go
4340099  // back one position, unless it is already at the
4340100  // beginning.
4340101  //
4340102  if (column > 1)
4340103  {
4340104  column--;
4340105  }
4340106  break;
4340107  default:
4340108  //
4340109  // Any other character must increase the column
4340110  // counter.
4340111  //
4340112  column++;
4340113  }
4340114  //
4340115  // Display the character, even if it is a special one:
4340116  // it is responsibility of the screen device management
4340117  // to do something good with special characters.
4340118  //
4340119  putchar (c);
4340120  //
4340121  // If the column counter is gone beyond the screen columns,
4340122  // then adjust the column counter and increment the line
4340123  // counter.
4340124  //
4340125  if (column > MAX_COLUMNS)
4340126  {
4340127  column -= MAX_COLUMNS;
4340128  line++;
4340129  }
4340130  //
4340131  // Check if there is space for scrolling.
4340132  //
4340133  if (line < MAX_LINES)
4340134  {
4340135  continue;
4340136  }
4340137  //
4340138  // Here, displayed lines are MAX_LINES.
4340139  //
4340140  if (column > 1)
4340141  {
4340142  //
4340143  // Something was printed at the current line: must
4340144  // do a new line.
4340145  //
4340146  putchar ('\n');
4340147  }
4340148  //
4340149  // Show the more prompt.
4340150  //
4340151  printf ("--More--");
4340152  fflush (stdout);
4340153  //
4340154  // Read a character from standard input.
4340155  //
4340156  c = getchar ();
4340157  //
4340158  // Consider commands `n' and `q', but any other character
4340159  // can be introduced, to let show the next page.
4340160  //
4340161  switch (c)
4340162  {
4340163  case 'N':
4340164  case 'n':
4340165  //
4340166  // Go to the next file, if any.
4340167  //
4340168  fclose (fp);
4340169  fp = NULL;
4340170  loop = 0;
4340171  break;
4340172  case 'Q':
4340173  case 'q':
4340174  //
4340175  // Quit. But must erase the `--More--' prompt.
4340176  //
4340177  printf ("\b \b\b \b\b \b\b \b\b \b");
4340178  printf ("\b \b\b \b\b \b\b \b");
4340179  fclose (fp);
4340180  return (0);
4340181  }
4340182  //
4340183  // Backspace to overwrite `--More--' and the character
4340184  // pressed.
4340185  //
4340186  printf ("\b \b\b \b\b \b\b \b\b \b\b \b\b \b\b \b\b \b");
4340187  //
4340188  // Reset line/column counters.
4340189  //
4340190  column = 1;
4340191  line = 1;
4340192  }
4340193  //
4340194  // Close the file pointer if it is still open.
4340195  //
4340196  if (fp != NULL)
4340197  {
4340198  fclose (fp);
4340199  }
4340200  }
4340201  //
4340202  return (0);
4340203 }
4340204 //----------------------------------------------------------------------
4340205 static void
4340206 usage (void)
4340207 {
4340208  fprintf (stderr, "Usage: more FILE...\n");
4340209 }

4350001 #include <unistd.h>
4350002 #include <stdlib.h>
4350003 #include <sys/stat.h>
4350004 #include <sys/types.h>
4350005 #include <fcntl.h>
4350006 #include <errno.h>
4350007 #include <signal.h>
4350008 #include <stdio.h>
4350009 #include <sys/wait.h>
4350010 #include <stdio.h>
4350011 #include <string.h>
4350012 #include <limits.h>
4350013 #include <sys/os16.h>
4350014 //----------------------------------------------------------------------
4350015 static void usage (void);
4350016 //----------------------------------------------------------------------
4350017 int
4350018 main (int argc, char *argv[], char *envp[])
4350019 {
4350020  int options;
4350021  int status;
4350022  //
4350023  //
4350024  //
4350025  if (argc < 3 || argc > 4)
4350026  {
4350027  usage ();
4350028  return (1);
4350029  }
4350030  //
4350031  // Set options.
4350032  //
4350033  if (argc == 4)
4350034  {
4350035  if (strcmp (argv[3], "rw") == 0)
4350036  {
4350037  options = MOUNT_DEFAULT;
4350038  }
4350039  else if (strcmp (argv[3], "ro") == 0)
4350040  {
4350041  options = MOUNT_RO;
4350042  }
4350043  else
4350044  {
4350045  printf ("Invalid mount option: only \"ro\" or \"rw\" "
4350046  "are allowed\n");
4350047  return (2);
4350048  }
4350049  }
4350050  else
4350051  {
4350052  options = MOUNT_DEFAULT;
4350053  }
4350054  //
4350055  // System call.
4350056  //
4350057  status = mount (argv[1], argv[2], options);
4350058  if (status != 0)
4350059  {
4350060  perror (NULL);
4350061  return (2);
4350062  }
4350063  //
4350064  return (0);
4350065 }
4350066 //----------------------------------------------------------------------
4350067 static void
4350068 usage (void)
4350069 {
4350070  fprintf (stderr, "Usage: mount DEVICE MOUNT_POINT "
4350071  "[MOUNT_OPTIONS]\n");
4350072 }

4360001 #include <kernel/proc.h>
4360002 #include <unistd.h>
4360003 #include <stdio.h>
4360004 #include <fcntl.h>
4360005 #include <unistd.h>
4360006 #include <stdlib.h>
4360007 //----------------------------------------------------------------------
4360008 void
4360009 print_proc_head (void)
4360010 {
4360011  printf (
4360012 "pp p pg \n"
4360013 "id id rp tty uid euid suid usage s iaddr isiz daddr dsiz sp name\n"
4360014  );
4360015 }
4360016 //----------------------------------------------------------------------
4360017 void
4360018 print_proc_pid (proc_t *ps, pid_t pid)
4360019 {
4360020  char stat;
4360021  switch (ps->status)
4360022  {
4360023  case PROC_EMPTY : stat = '-'; break;
4360024  case PROC_CREATED : stat = 'c'; break;
4360025  case PROC_READY : stat = 'r'; break;
4360026  case PROC_RUNNING : stat = 'R'; break;
4360027  case PROC_SLEEPING: stat = 's'; break;
4360028  case PROC_ZOMBIE : stat = 'z'; break;
4360029  default : stat = '?'; break;
4360030  }
4360031 
4360032  printf ("%2i %2i %2i %04x %4i %4i %4i %02i.%02i %c %05lx %04x ",
4360033  (unsigned int) ps->ppid,
4360034  (unsigned int) pid,
4360035  (unsigned int) ps->pgrp,
4360036  (unsigned int) ps->device_tty,
4360037  (unsigned int) ps->uid,
4360038  (unsigned int) ps->euid,
4360039  (unsigned int) ps->suid,
4360040  (unsigned int) ((ps->usage / CLOCKS_PER_SEC) / 60),
4360041  (unsigned int) ((ps->usage / CLOCKS_PER_SEC) % 60),
4360042  stat,
4360043  (unsigned long int) ps->address_i,
4360044  (unsigned int) ps->size_i);
4360045 
4360046  printf ("%05lx %04x %04x %s",
4360047  (unsigned long int) ps->address_d,
4360048  (unsigned int) ps->size_d,
4360049  (unsigned int) ps->sp,
4360050  ps->name);
4360051 
4360052  printf ("\n");
4360053 }
4360054 //----------------------------------------------------------------------
4360055 int
4360056 main (void)
4360057 {
4360058  pid_t pid;
4360059  proc_t *ps;
4360060  int fd;
4360061  ssize_t size_read;
4360062  char buffer[sizeof (proc_t)];
4360063 
4360064  fd = open ("/dev/kmem_ps", O_RDONLY);
4360065  if (fd < 0)
4360066  {
4360067  perror ("ps: cannot open \"/dev/kmem_ps\"");
4360068  exit (0);
4360069  }
4360070 
4360071  print_proc_head ();
4360072  for (pid = 0; pid < PROCESS_MAX; pid++)
4360073  {
4360074  lseek (fd, (off_t) pid, SEEK_SET);
4360075  size_read = read (fd, buffer, sizeof (proc_t));
4360076  if (size_read < sizeof (proc_t))
4360077  {
4360078  printf ("ps: cannot read \"/dev/kmem_ps\" pid %i", pid);
4360079  perror (NULL);
4360080  continue;
4360081  }
4360082  ps = (proc_t *) buffer;
4360083  if (ps->status > 0)
4360084  {
4360085  ps->name[PATH_MAX-1] = 0; // Terminated string.
4360086  print_proc_pid (ps, pid);
4360087  }
4360088  }
4360089 
4360090  close (fd);
4360091  return (0);
4360092 }

4370001 #include <fcntl.h>
4370002 #include <sys/stat.h>
4370003 #include <stddef.h>
4370004 #include <unistd.h>
4370005 #include <errno.h>
4370006 //----------------------------------------------------------------------
4370007 static void usage (void);
4370008 //----------------------------------------------------------------------
4370009 int
4370010 main (int argc, char *argv[], char *envp[])
4370011 {
4370012  int a; // Argument index.
4370013  int status;
4370014  struct stat file_status;
4370015  //
4370016  // No options are known, but at least an argument must be given.
4370017  //
4370018  if (argc < 2)
4370019  {
4370020  usage ();
4370021  return (1);
4370022  }
4370023  //
4370024  // Scan arguments.
4370025  //
4370026  for(a = 1; a < argc; a++)
4370027  {
4370028  //
4370029  // Verify if the file exists.
4370030  //
4370031  if (stat(argv[a], &file_status) != 0)
4370032  {
4370033  fprintf (stderr, "File \"%s\" does not exist!\n",
4370034  argv[a]);
4370035  continue;
4370036  }
4370037  //
4370038  // File exists: check the file type.
4370039  //
4370040  if (S_ISDIR (file_status.st_mode))
4370041  {
4370042  fprintf (stderr, "Cannot remove directory \"%s\"!\n",
4370043  argv[a]);
4370044  continue;
4370045  }
4370046  //
4370047  // Can remove it.
4370048  //
4370049  status = unlink (argv[a]);
4370050  if (status != 0)
4370051  {
4370052  perror (NULL);
4370053  return (2);
4370054  }
4370055  }
4370056  return (0);
4370057 }
4370058 //----------------------------------------------------------------------
4370059 static void
4370060 usage (void)
4370061 {
4370062  fprintf (stderr, "Usage: rm FILE...\n");
4370063 }

4380001 #include <unistd.h>
4380002 #include <stdlib.h>
4380003 #include <sys/stat.h>
4380004 #include <sys/types.h>
4380005 #include <fcntl.h>
4380006 #include <errno.h>
4380007 #include <unistd.h>
4380008 #include <signal.h>
4380009 #include <stdio.h>
4380010 #include <sys/wait.h>
4380011 #include <stdio.h>
4380012 #include <string.h>
4380013 #include <limits.h>
4380014 #include <sys/os16.h>
4380015 //----------------------------------------------------------------------
4380016 #define PROMPT_SIZE 16
4380017 //----------------------------------------------------------------------
4380018 static void sh_cd (int argc, char *argv[]);
4380019 static void sh_pwd (int argc, char *argv[]);
4380020 static void sh_umask (int argc, char *argv[]);
4380021 //----------------------------------------------------------------------
4380022 int
4380023 main (int argc, char *argv[], char *envp[])
4380024 {
4380025  char buffer_cmd[ARG_MAX/2];
4380026  char *argv_cmd[ARG_MAX/16];
4380027  char prompt[PROMPT_SIZE];
4380028  uid_t uid;
4380029  int argc_cmd;
4380030  pid_t pid_cmd;
4380031  pid_t pid_dead;
4380032  int status;
4380033  //
4380034  //
4380035  //
4380036  uid = geteuid ();
4380037  //
4380038  // Load processes, reading the keyboard.
4380039  //
4380040  while (1)
4380041  {
4380042  if (uid == 0)
4380043  {
4380044  strncpy (prompt, "# ", PROMPT_SIZE);
4380045  }
4380046  else
4380047  {
4380048  strncpy (prompt, "$ ", PROMPT_SIZE);
4380049  }
4380050  //
4380051  input_line (buffer_cmd, prompt, (ARG_MAX/2), INPUT_LINE_ECHO);
4380052  //
4380053  // Clear `argv_cmd[]';
4380054  //
4380055  for (argc_cmd = 0; argc_cmd < (ARG_MAX/16); argc_cmd++)
4380056  {
4380057  argv_cmd[argc_cmd] = NULL;
4380058  }
4380059  //
4380060  // Initialize the command scan.
4380061  //
4380062  argv_cmd[0] = strtok (buffer_cmd, " \t");
4380063  //
4380064  // Verify: if the input is not valid, loop again.
4380065  //
4380066  if (argv_cmd[0] == NULL)
4380067  {
4380068  continue;
4380069  }
4380070  //
4380071  // Find the arguments.
4380072  //
4380073  for (argc_cmd = 1;
4380074  argc_cmd < ((ARG_MAX/16)-1) && argv_cmd[argc_cmd-1] != NULL;
4380075  argc_cmd++)
4380076  {
4380077  argv_cmd[argc_cmd] = strtok (NULL, " \t");
4380078  }
4380079  //
4380080  // If there are too many arguments, show a message and continue.
4380081  //
4380082  if (argv_cmd[argc_cmd-1] != NULL)
4380083  {
4380084  errset (E2BIG); // Argument list too long.
4380085  perror (NULL);
4380086  continue;
4380087  }
4380088  //
4380089  // Correct the value for `argc_cmd', because actually
4380090  // it counts also the NULL element.
4380091  //
4380092  argc_cmd--;
4380093  //
4380094  // Verify if it is an internal command.
4380095  //
4380096  if (strcmp (argv_cmd[0], "exit") == 0)
4380097  {
4380098  return (0);
4380099  }
4380100  else if (strcmp (argv_cmd[0], "cd") == 0)
4380101  {
4380102  sh_cd (argc_cmd, argv_cmd);
4380103  continue;
4380104  }
4380105  else if (strcmp (argv_cmd[0], "pwd") == 0)
4380106  {
4380107  sh_pwd (argc_cmd, argv_cmd);
4380108  continue;
4380109  }
4380110  else if (strcmp (argv_cmd[0], "umask") == 0)
4380111  {
4380112  sh_umask (argc_cmd, argv_cmd);
4380113  continue;
4380114  }
4380115  //
4380116  // It should be a program to run.
4380117  //
4380118  pid_cmd = fork ();
4380119  if (pid_cmd == -1)
4380120  {
4380121  printf ("%s: cannot run command", argv[0]);
4380122  perror (NULL);
4380123  }
4380124  else if (pid_cmd == 0)
4380125  {
4380126  execvp (argv_cmd[0], argv_cmd);
4380127  perror (NULL);
4380128  exit (0);
4380129  }
4380130  while (1)
4380131  {
4380132  pid_dead = wait (&status);
4380133  if (pid_dead == pid_cmd)
4380134  {
4380135  break;
4380136  }
4380137  }
4380138  printf ("pid %i terminated with status %i.\n",
4380139  (int) pid_dead, status);
4380140  }
4380141 }
4380142 //----------------------------------------------------------------------
4380143 static void
4380144 sh_cd (int argc, char *argv[])
4380145 {
4380146  int status;
4380147  //
4380148  if (argc != 2)
4380149  {
4380150  errset (EINVAL); // Invalid argument.
4380151  perror (NULL);
4380152  return;
4380153  }
4380154  //
4380155  status = chdir (argv[1]);
4380156  if (status != 0)
4380157  {
4380158  perror (NULL);
4380159  }
4380160  return;
4380161 }
4380162 //----------------------------------------------------------------------
4380163 static void
4380164 sh_pwd (int argc, char *argv[])
4380165 {
4380166  char path[PATH_MAX];
4380167  void *pstatus;
4380168  //
4380169  if (argc != 1)
4380170  {
4380171  errset (EINVAL); // Invalid argument.
4380172  perror (NULL);
4380173  return;
4380174  }
4380175  //
4380176  // Get the current directory.
4380177  //
4380178  pstatus = getcwd (path, (size_t) PATH_MAX);
4380179  if (pstatus == NULL)
4380180  {
4380181  perror (NULL);
4380182  }
4380183  else
4380184  {
4380185  printf ("%s\n", path);
4380186  }
4380187  return;
4380188 }
4380189 //----------------------------------------------------------------------
4380190 static void
4380191 sh_umask (int argc, char *argv[])
4380192 {
4380193  sysmsg_uarea_t msg;
4380194  char *m; // Index inside the umask octal string.
4380195  int mask;
4380196  int digit;
4380197  //
4380198  if (argc > 2)
4380199  {
4380200  errset (EINVAL); // Invalid argument.
4380201  perror (NULL);
4380202  return;
4380203  }
4380204  //
4380205  // If no argument is available, the umask is shown, with a direct
4380206  // system call.
4380207  //
4380208  if (argc == 1)
4380209  {
4380210  sys (SYS_UAREA, &msg, (sizeof msg));
4380211  printf ("%04o\n", msg.umask);
4380212  return;
4380213  }
4380214  //
4380215  // Get the mask: must be the first argument.
4380216  //
4380217  for (mask = 0, m = argv[1]; *m != 0; m++)
4380218  {
4380219  digit = (*m - '0');
4380220  if (digit < 0 || digit > 7)
4380221  {
4380222  errset (EINVAL); // Invalid argument.
4380223  perror (NULL);
4380224  return;
4380225  }
4380226  mask = mask * 8 + digit;
4380227  }
4380228  //
4380229  // Set the umask and return.
4380230  //
4380231  umask (mask);
4380232  return;
4380233 }

4390001 #include <fcntl.h>
4390002 #include <sys/stat.h>
4390003 #include <utime.h>
4390004 #include <stddef.h>
4390005 #include <unistd.h>
4390006 #include <errno.h>
4390007 //----------------------------------------------------------------------
4390008 static void usage (void);
4390009 //----------------------------------------------------------------------
4390010 int
4390011 main (int argc, char *argv[], char *envp[])
4390012 {
4390013  int a; // Argument index.
4390014  int status;
4390015  struct stat file_status;
4390016  //
4390017  // No options are known, but at least an argument must be given.
4390018  //
4390019  if (argc < 2)
4390020  {
4390021  usage ();
4390022  return (1);
4390023  }
4390024  //
4390025  // Scan arguments.
4390026  //
4390027  for(a = 1; a < argc; a++)
4390028  {
4390029  //
4390030  // Verify if the file exists, through the return value of
4390031  // `stat()'. No other checks are made.
4390032  //
4390033  if (stat(argv[a], &file_status) == 0)
4390034  {
4390035  //
4390036  // File exists: should be updated the times.
4390037  //
4390038  status = utime (argv[a], NULL);
4390039  if (status != 0)
4390040  {
4390041  perror (NULL);
4390042  return (2);
4390043  }
4390044  }
4390045  else
4390046  {
4390047  //
4390048  // File does not exist: should be created.
4390049  //
4390050  status = open (argv[a], O_WRONLY|O_CREAT|O_TRUNC, 0666);
4390051  //
4390052  if (status >= 0)
4390053  {
4390054  //
4390055  // Here, the variable `status' is the file
4390056  // descriptor to be closed.
4390057  //
4390058  status = close (status);
4390059  if (status != 0)
4390060  {
4390061  perror (NULL);
4390062  return (3);
4390063  }
4390064  }
4390065  else
4390066  {
4390067  perror (NULL);
4390068  return (4);
4390069  }
4390070  }
4390071  }
4390072  return (0);
4390073 }
4390074 //----------------------------------------------------------------------
4390075 static void
4390076 usage (void)
4390077 {
4390078  fprintf (stderr, "Usage: touch FILE...\n");
4390079 }

4400001 #include <fcntl.h>
4400002 #include <sys/stat.h>
4400003 #include <utime.h>
4400004 #include <stddef.h>
4400005 #include <unistd.h>
4400006 #include <errno.h>
4400007 #include <sys/os16.h>
4400008 #include <sys/types.h>
4400009 //----------------------------------------------------------------------
4400010 static void usage (void);
4400011 //----------------------------------------------------------------------
4400012 int
4400013 main (int argc, char *argv[], char *envp[])
4400014 {
4400015  int dev_minor;
4400016  struct stat file_status;
4400017  //
4400018  // No options and no arguments.
4400019  //
4400020  if (argc > 1)
4400021  {
4400022  usage ();
4400023  return (1);
4400024  }
4400025  //
4400026  // Verify the standard input.
4400027  //
4400028  if (fstat (STDIN_FILENO, &file_status) == 0)
4400029  {
4400030  if (major (file_status.st_rdev) == DEV_CONSOLE_MAJOR)
4400031  {
4400032  dev_minor = minor (file_status.st_rdev);
4400033  //
4400034  // If minor is equal to 0xFF, it is `/dev/console'
4400035  // that is not a controlling terminal, but just
4400036  // a reference for the current virtual console.
4400037  //
4400038  if (dev_minor < 0xFF)
4400039  {
4400040  printf ("/dev/console%i\n", dev_minor);
4400041  }
4400042  }
4400043  }
4400044  else
4400045  {
4400046  perror ("Cannot get standard input file status");
4400047  return (2);
4400048  }
4400049  //
4400050  return (0);
4400051 }
4400052 
4400053 //----------------------------------------------------------------------
4400054 static void
4400055 usage (void)
4400056 {
4400057  fprintf (stderr, "Usage: tty\n");
4400058 }

4410001 #include <unistd.h>
4410002 #include <stdlib.h>
4410003 #include <sys/stat.h>
4410004 #include <sys/types.h>
4410005 #include <fcntl.h>
4410006 #include <errno.h>
4410007 #include <signal.h>
4410008 #include <stdio.h>
4410009 #include <sys/wait.h>
4410010 #include <stdio.h>
4410011 #include <string.h>
4410012 #include <limits.h>
4410013 #include <sys/os16.h>
4410014 //----------------------------------------------------------------------
4410015 static void usage (void);
4410016 //----------------------------------------------------------------------
4410017 int
4410018 main (int argc, char *argv[], char *envp[])
4410019 {
4410020  int status;
4410021  //
4410022  // One argument is mandatory.
4410023  //
4410024  if (argc != 2)
4410025  {
4410026  usage ();
4410027  return (1);
4410028  }
4410029  //
4410030  // System call.
4410031  //
4410032  status = umount (argv[1]);
4410033  if (status != 0)
4410034  {
4410035  perror (argv[1]);
4410036  return (2);
4410037  }
4410038  //
4410039  return (0);
4410040 }
4410041 //----------------------------------------------------------------------
4410042 static void
4410043 usage (void)
4410044 {
4410045  fprintf (stderr, "Usage: umount MOUNT_POINT\n");
4410046 }