/*

 * Run programs residing in the filesystem.

 *

 * Copyright (C) 2022, 2023, 2024 Paul Boddie <paul@boddie.org.uk>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License as

 * published by the Free Software Foundation; either version 2 of

 * the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA  02110-1301, USA

 */

#include <l4/sys/err.h>

#include <fsclient/client.h>

#include <fsclient/process.h>

#include <systypes/fcntl.h>

#include <systypes/format.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "ops.h"

/* Transfer size for communication. */

static const offset_t TO_TRANSFER = 1024;

/* Initiated programs (jobs).

   NOTE: Arbitrary limit. */

#define NUMBER_OF_JOBS 32

static file_t *readers[NUMBER_OF_JOBS] = {NULL};

static process_t *processes[NUMBER_OF_JOBS] = {NULL};

static char *programs[NUMBER_OF_JOBS] = {NULL};

static int next_job = 0;

/* Find the given program in the job list. */

static int _find_program(process_t *process)

{

  int job_number;

  for (job_number = 0; job_number < NUMBER_OF_JOBS; job_number++)

  {

    if (processes[job_number] == process)

      return job_number;

  }

  return -1;

}

/* Remove the details of a program from the job list. */

static void _remove_program(int job_number)

{

  readers[job_number] = NULL;

  processes[job_number] = NULL;

  free(programs[job_number]);

  programs[job_number] = NULL;

}

/* Show the details of a running program. */

static void _show_program(int job_number)

{

  /* Employ the Unix convention of a "+" for the default job to be restored upon

     the appropriate command. */

  printf("[%d]%s %s%s\n", job_number, job_number == next_job ? "+" : " ",

         programs[job_number], readers[job_number] != NULL ? " [!]" : "");

}

/* Show output from a program. */

static void _show_output(file_t *reader)

{

  char buffer[TO_TRANSFER];

  offset_t nread;

  while ((nread = client_read(reader, buffer, TO_TRANSFER)))

    fwrite(buffer, sizeof(char), nread, stdout);

}

/* Show the exit status of a program. */

static void _show_status(notifiable_t *notifiable)

{

  int job_number = _find_program((process_t *) notifiable->base);

  if (job_number == -1)

    return;

  printf("[%d] Completed with", job_number);

  if (notifiable->notifications & NOTIFY_TASK_ERROR)

    printf(" error");

  if (notifiable->notifications & NOTIFY_TASK_SIGNAL)

    printf(" signal %ld", notifiable->values.sig);

  printf(" value %ld\n", notifiable->values.val);

}

/* Wait for a program to finish, showing its output. */

static int _wait_program(file_t *reader, process_t *process)

{

  notifier_t *notifier = client_notifier_task();

  notifiable_t *notifiable;

  int exitcode;

  long err;

  /* Subscribe to reader and process notifications. */

  if (reader != NULL)

  {

    err = client_subscribe(reader, NOTIFY_CONTENT_AVAILABLE | NOTIFY_PEER_CLOSED, notifier);

    if (err)

    {

      printf("Could not subscribe to pipe notifications: %s\n", l4sys_errtostr(err));

      return -1;

    }

  }

  err = notify_subscribe(process_notifiable(process), NOTIFY_TASK_ALL, notifier);

  if (err)

  {

    printf("Could not subscribe to process notifications: %s\n", l4sys_errtostr(err));

    client_unsubscribe(reader, notifier);

    return -1;

  }

  /* Read from and write to pipes until the program terminates. */

  while (1)

  {

    err = notify_wait_many(&notifiable, notifier);

    if (err)

    {

      printf("Notification error: %s\n", l4sys_errtostr(err));

      if (reader != NULL)

        client_unsubscribe(reader, notifier);

      notify_unsubscribe(process_notifiable(process), notifier);

      return -1;

    }

    /* Handle input from the reader. */

    if ((reader != NULL) && (file_notifications(reader) & (NOTIFY_CONTENT_AVAILABLE | NOTIFY_PEER_CLOSED)))

      _show_output(reader);

    /* Handle process termination, obtaining the process state. */

    if (process_terminated(notifiable))

    {

      if ((reader != NULL) && ((process_t *) notifiable->base == process))

        _show_output(reader);

      _show_status(notifiable);

      /* If explicitly waiting for this process, remove it from the job list and

         return. Otherwise, just remove it from the job list and keep waiting

         for the indicated process. */

      _remove_program(_find_program((process_t *) notifiable->base));

      if ((process_t *) notifiable->base == process)

        break;

    }

  }

  exitcode = notifiable->values.val;

  if (reader != NULL)

    client_unsubscribe(reader, notifier);

  notify_unsubscribe(process_notifiable(process), notifier);

  /* Close the process and pipe. */

  process_free(process);

  if (reader != NULL)

    client_close(reader);

  return exitcode;

}

/* Run the given program. */

static int _run_program(int argc, char *argv[], file_t *input_reader)

{

  process_t *process;

  file_t *output_reader, *output_writer;

  int last_job;

  long err;

  /* Create a pipe for process output. */

  err = client_pipe(&output_reader, &output_writer, O_NONBLOCK);

  if (err)

  {

    printf("Could not obtain pipe for output: %s\n", l4sys_errtostr(err));

    return -1;

  }

  /* Start the process. */

  err = process_spawn(argc, (const char **) argv, input_reader, output_writer, &process);

  if (err)

  {

    printf("Could not start process: %s\n", l4sys_errtostr(err));

    return -1;

  }

  /* Release the relinquished end of the pipe. */

  client_close(output_writer);

  /* Record the output stream. */

  last_job = next_job;

  while (processes[next_job] != NULL)

  {

    next_job++;

    if (next_job >= NUMBER_OF_JOBS)

      next_job = 0;

    /* Return an error if no more job slots are available. */

    if (next_job == last_job)

    {

      printf("No job slots available.\n");

      return -1;

    }

  }

  readers[next_job] = output_reader;

  processes[next_job] = process;

  programs[next_job] = strdup(argv[0]);

  return 0;

}

/* Run the given program, providing input from a file. */

int file_to_program(int argc, char *argv[])

{

  file_t *reader;

  /* Obtain a file reader and run the program with this as its input reader. */

  if (argc < 1)

    return -1;

  reader = client_open(argv[0], O_RDONLY);

  if (!client_opened(reader))

  {

    printf("Could not open file: %s\n", argv[0]);

    return -1;

  }

  return _run_program(argc - 1, &argv[1], reader);

}

/* Run the given program, connecting input from another program. */

int pipe_to_program(int argc, char *argv[])

{

  int job_number;

  int exitcode;

  /* Obtain the job number for the output writer and run the program with this

     as its input reader. */

  if (argc < 1)

    return -1;

  if (!strcmp(argv[0], "+"))

    job_number = next_job;

  else

    job_number = atoi(argv[0]);

  if (readers[job_number] == NULL)

  {

    printf("No output available for this job: %s\n", argv[0]);

    return -1;

  }

  exitcode = _run_program(argc - 1, &argv[1], readers[job_number]);

  /* Remove the job's reader to prevent direct access to it and to allow it to

     be closed by the receiving program. */

  client_close(readers[job_number]);

  readers[job_number] = NULL;

  /* Subscribe to signals from the process. */

  notify_subscribe(process_notifiable(processes[job_number]), NOTIFY_TASK_ALL, client_notifier_task());

  return exitcode;

}

/* Run the given program and wait for it to finish. */

int run_program(int argc, char *argv[])

{

  int exitcode = _run_program(argc, argv, NULL);

  if (exitcode)

    return exitcode;

  return _wait_program(readers[next_job], processes[next_job]);

}

/* Show initiated programs. */

int show_programs(int argc, char *argv[])

{

  (void) argc; (void) argv;

  int job_number;

  for (job_number = 0; job_number < NUMBER_OF_JOBS; job_number++)

  {

    if (processes[job_number] != NULL)

      _show_program(job_number);

  }

  return 0;

}

/* Run the given program but do not wait for it to finish, instead allowing the

   program to produce output and potentially block until an operation to wait

   for its completion is performed. */

int spawn_program(int argc, char *argv[])

{

  int exitcode = _run_program(argc, argv, NULL);

  if (!exitcode)

    _show_program(next_job);

  return exitcode;

}

/* Wait for the indicated program (or the last program to be spawned) to finish,

   showing its output. */

int wait_program(int argc, char *argv[])

{

  int job_number;

  if ((argc < 1) || !strcmp(argv[0], "+"))

    job_number = next_job;

  else

    job_number = atoi(argv[0]);

  if (processes[job_number] == NULL)

  {

    printf("No such job: %s\n", argv[0]);

    return -1;

  }

  return _wait_program(readers[job_number], processes[job_number]);

}

/* vim: tabstop=2 expandtab shiftwidth=2

*/