Changeset 352 in MondoRescue

Timestamp:

Jan 28, 2006, 6:41:40 PM (19 years ago)

Author:

bcornec

Message:

monitas v0.1a

Location:

branches/stable/monitas

Files:

• README (added)
• client.c (modified) (13 diffs)
• common.c (added)
• from-mondo.c (added)
• make-client (added)
• make-server (added)
• server.c (modified) (27 diffs)
• structs.h (added)

branches/stable/monitas/client.c

@@ -4 +4 @@
 
 
+
 FIXME
-- fork child process ('daemon', almost) to interact with server
-- parent process will interact with keyboard ('logout'=quit)
-- if trigger_backup msg arrives then act accordingly
-- remember, the client is a 'server' from the minute it logs in
-  until the minute it logs out of the server: the client listens
-  on a port between 8800 and 8899, waiting for incoming msgs
-  from server; all the forked process has to do is take over the
-  task of watching that port and act on the incoming data
-- when trigger_backup is received then send file along connection
-
-05/19
+- perror() --- replace with log_it()
+
+
+
+06/19
+- fixed bugs in mondoarchive compare code
+- added track_restore_task_progress()
+
+06/16
+- when calling mondoarchive in bkgd, see if it starts OK; if it
+  doesn't then say so & return error
+
+06/14
+- added a FIFO to let user request backup/compare/restore
+- send progress info to server - % done, etc. - when backing up
+- pipe logs to logfile, not stdout
+
+06/11
+- added call to register_pid()
+- commented code a bit
+- implemented compare_archives and restore_archives()
+
+06/10
+- create function to call external executable in background
+- create function to wait for it to terminate & to grab its result
+- put them in common.c
+
+05/27
+- fixed watch_port_for_triggers()
+- turned st_'s into a global and some locals
+- fork in login thingy becomes a thread
+- added bind_client_port()
+- added accept_and_recv_thru_client_port()
+- changed flag (recv) from DONTWAIT to 0 [no flag]
+
+05/21
+- added back_my_smitch_up(), compare_archives(), restore_archives()
+- added log_it(); fixed fprintf(stderr,"") and printf() reporting
+- parallelize/fork the 'watch for triggers from server' process
 - added tmsg_to_string()
 - forked port-watcher to receive triggers from server in bkgd
@@ -32 +61 @@
 
 #include "structs.h"
+//#define LOG_THESE_AND_HIGHER debug
+#define LOGFILE "/var/log/monitas-client.log"
 
 
@@ -37 +68 @@
 /* global vars */
 
-
+bool g_logged_in_currently=false, g_logging_out=false;
+int g_sClient=-1, g_client_port=0; /* client port; set by login */
+struct sockaddr_in g_sinClient; /* client port */
+char g_server_name[MAX_STR_LEN+1];
+pthread_t g_mondo_thread=0;
+char g_command_fifo[MAX_STR_LEN+1];
+char g_logfile[MAX_STR_LEN+1] = "/var/log/monitas-client.log";
+
+/* externs */
+
+extern char *call_program_and_get_last_line_of_output(char*);
+extern int call_program_and_log_output(char*);
+extern void call_program_in_background(pthread_t*, char*);
+extern int create_and_watch_fifo_for_commands(char*);
+extern bool does_file_exist(char*);
+extern int get_bkgd_prog_result(pthread_t*);
+extern void log_it_SUB(char*, t_loglevel level, char *sz_message);
+extern bool program_still_running(char*);
+extern int receive_file_from_socket(FILE*, int);
+extern void register_pid(pid_t, char*);
+extern char *tmsg_to_string(t_msg msg_type);
+extern int transmit_file_to_socket(FILE*, int);
+extern void register_pid(pid_t, char*);
+extern void set_signals(bool);
 
 /* prototypes */
 
+int accept_and_recv_thru_client_port(int, int*, struct sockaddr_in*, char*, int);
+int back_my_smitch_up(char*, int);
+int bind_client_port(struct sockaddr_in*, int);
+int compare_archives(char*, int);
 int find_and_bind_free_server_port(struct sockaddr_in*, int*);
 long increment_magic_number(void);
 int login_to_server(char*,char*);
+void logout_and_exit(char*);
 int logout_of_server(char*);
+int process_incoming_command(char*);
+int restore_archives(char*, char*, int);
+void restore_archives_SIGPIPE(int);
+int send_final_progress_report(char*);
 int send_msg_to_server(struct s_client2server_msg_record*, char*);
 int send_ping_to_server(char*,char*);
-char *tmsg_to_string(t_msg);
-void watch_port_for_triggers_from_server(struct sockaddr_in *, int, int);
-
-/* subroutines */
+int send_progress_rpt_to_server(char*, char*);
+void terminate_daemon(int);
+void *track_backup_task_progress(void*);
+void *track_compare_task_progress(void*);
+void *track_restore_task_progress(void*);
+void *watch_port_for_triggers_from_server(void*);
+
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+int accept_and_recv_thru_client_port(int sClient, int *new_sClient, struct sockaddr_in*sinClient, char*incoming, int expected_length)
+/*
+Purpose:Run accept() and recv() to open port and receive
+    message from server.
+Params: sClient - file descriptor of port
+    new_sClient - [returned] file descriptor of the
+    new connection to port which we open in this func
+    sinClient - record about port
+    expected_length - expected length of incoming block
+Return: length of block received, or <0 if error
+*/
+{
+      int len;
+
+      len = sizeof(struct sockaddr_in);
+      if ((*new_sClient = accept(sClient, (struct sockaddr*)sinClient, (unsigned int*)&len)) < 0) { log_it(error, "[child] Cannot accept"); return(-6); }
+      if ((len = recv(*new_sClient, incoming, expected_length, /*MSG_DONTWAIT*/0)) <= 0) { log_it(error, "[child] Cannot recv"); return(-7); }
+      return(len);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+char *get_param_from_rcfile(char*fname, char*field)
+{
+  char command[MAX_STR_LEN+1], tmp[MAX_STR_LEN+1];
+  static char sz_res[MAX_STR_LEN+1];
+
+  sz_res[0]='\0';
+  if (does_file_exist(fname))
+    {
+      sprintf(command, "cat %s | grep %s= | cut -d'=' -f2,3,4,5,6,7,8,9", fname, field);
+      strcpy(tmp, call_program_and_get_last_line_of_output(command));
+      strcpy(sz_res, tmp);
+    }
+  return(sz_res);
+}
+
+
+
+int back_my_smitch_up(char*msgbody, int socket_fd)
+/*
+Purpose:Backup archives to server.
+Params: msgbody - char[MSG_BODY_SIZE] containing info
+    about the archives to be created
+    socket_fd - file descriptor to which to
+    write the archives to server.
+Return: result (0=success; nonzero=failure)
+*/
+{
+  char tmp[MAX_STR_LEN+1], command[MAX_STR_LEN+1], tempdev[MAX_STR_LEN+1];
+  char temporary_logfile[MAX_STR_LEN+1]; // where mondoarchive writes its stdout,stderr
+  char mondoparams_str[MAX_STR_LEN+1];
+  struct s_server2client_msg_record incoming_rec;
+  int retval=0, len, new_sClient, res=0;
+  FILE*fin;
+  pthread_t progress_thread;
+
+  sprintf(tmp, "Backup of %s commenced", msgbody);
+  log_it(info, tmp);
+  if (send_progress_rpt_to_server(g_server_name, tmp)) { log_it(error, "Unable to send 'yep, got this msg' progress_rpt to server"); }
+  sprintf(temporary_logfile, "/tmp/monitas-client.templog.%d", (int)random()%32767);
+  sprintf(tempdev, "/tmp/monitas-client.device.%d", (int)random()%32767);
+  unlink(tempdev);
+  if (mkfifo(tempdev, 700))
+    {
+      log_it(error, "Unable to create temporary data output fifo in preparation for the call to mondoarchive");
+      return(1);
+    }
+  unlink(temporary_logfile);
+  if (mkfifo(temporary_logfile, 700))
+    {
+      log_it(error, "Unable to create temporary logfile fifo in preparation for the call to mondoarchive");
+      return(1);
+    }
+  strcpy(mondoparams_str, get_param_from_rcfile(CLIENT_RCFILE, "mondoarchive_params"));
+  sprintf(tmp, "mondoarchive_params --> '%s'", mondoparams_str);
+  log_it(debug, tmp);
+  sprintf(command, "mondoarchive -Ou %s -d %s -I %s -F &> %s; rm -f %s %s", mondoparams_str, tempdev, msgbody, temporary_logfile, tempdev, temporary_logfile);
+  call_program_in_background(&g_mondo_thread, command);
+  sleep(10);
+  if (!program_still_running(command))
+    { res=1; log_it(error, "Unable to start mondoarchive. Please check /var/log/mondo-archive.log"); }
+  else
+    {
+      if (pthread_create(&progress_thread, NULL, track_backup_task_progress, (void*)temporary_logfile))
+        { log_it(error, "Cannot create pthread to track mondo task progress"); return(1); }
+      log_it(debug, "Opening fopen() to tempdev");
+      if (!(fin = fopen(tempdev, "r"))) { log_it(error, "Cannot open FIFO"); return(1); }
+      log_it(debug, "fopen() OK");
+      retval = transmit_file_to_socket(fin, socket_fd);
+      fclose(fin);
+      res = get_bkgd_prog_result(&g_mondo_thread);
+      pthread_join(progress_thread, NULL);
+    }
+  if (res)
+    { retval++; log_it(error, "Mondoarchive returned an error. Notifying server..."); }
+  if (res)
+    { retval++; log_it(error, "Mondoarchive returned an error."); }
+  if (retval) { log_it(debug, "Errors have occurred. Notifing server..."); }
+  else        { log_it(debug, "Everything is OK so far. Notifying server..."); }
+  if (write(socket_fd, (char*)&retval, sizeof(retval))!=sizeof(retval)) {retval++;}
+/* receive msg from server; did backup go OK at its end or not? */
+  unlink(tempdev);
+  unlink(temporary_logfile);
+  log_it(debug, "Waiting for progress thread to join us");
+  log_it(debug, "Groovy. Continuing..");
+  len = accept_and_recv_thru_client_port(g_sClient, &new_sClient, &g_sinClient, (char*)&incoming_rec, sizeof(incoming_rec));
+  if (len<0) { log_it(error, "After backup, unable to accept/recv thru client port"); return(-10); }
+  sprintf(tmp, "After backup, I received %s - %s", tmsg_to_string(incoming_rec.msg_type), incoming_rec.body);
+  log_it(debug, tmp);
+  if (incoming_rec.msg_type == backup_fail)
+    { retval++; log_it(error, "Server reported error(s) during backup, although client didn't."); }
+  if (retval)
+    {
+      sprintf(tmp, "Backup of %s failed", msgbody);
+      log_it(error, tmp);
+      call_program_and_log_output("tail -n6 /var/log/mondo-archive.log");
+    }
+  else
+    {
+      sprintf(tmp, "Server agrees, backup of %s succeeded :-)", msgbody);
+      log_it(info, tmp);
+    }
+  if (send_final_progress_report(tmp) < 0) { retval++; log_it(error, "Unable to send final progress_rpt to server"); }
+  return(retval);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+int bind_client_port(struct sockaddr_in *sinClient, int client_port)
+/*
+Purpose:Bind one of my ports so that I may open it later and
+        write/read data to/from server with it.
+Params: sinClient - record/structure relating to the socket
+        client_port - port# to be bound
+Return: socket handle, to be used by other subroutines, if success
+        or <0 if failure
+*/
+{
+      int sClient=-1;
+      char tmp[MAX_STR_LEN+1];
+
+      memset((void*)sinClient, 0, sizeof(struct sockaddr_in));
+      sinClient->sin_family = AF_INET;
+      sinClient->sin_addr.s_addr = INADDR_ANY;
+      sinClient->sin_port = htons(client_port);
+      if ((sClient = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
+    {
+      sprintf(tmp, "Unable to open socket on port #%d", g_client_port);
+      log_it(error, tmp);
+          return(-1);
+    }
+      if (bind(sClient, (struct sockaddr*)sinClient, sizeof(struct sockaddr_in)) < 0)
+    {
+      sprintf(tmp, "Cannot bind %d - %s", g_client_port, strerror(errno));
+      log_it(error, tmp);
+      return(-2);
+    }
+      if (listen(sClient, MAX_PENDING) < 0)
+    {
+      sprintf(tmp, "Cannot setup listen (%d) - %sn", g_client_port, strerror(errno));
+      log_it(error, tmp);
+      return(-3);
+    }
+      log_it(debug, "Successfully bound client port.");
+      return(sClient);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+int compare_archives(char*msgbody, int socket_fd)
+/*
+Purpose:Compare archives, sent by server.
+Params: msgbody - char[MSG_BODY_SIZE] containing info
+about the archives to be compared
+socket_fd - file descriptor from which to
+read the archives sent by server to be compared.
+Return: result (0=success; nonzero=failure)
+*/
+{
+  char tmp[MAX_STR_LEN+1], command[MAX_STR_LEN+1], tempdev[MAX_STR_LEN+1], *p;
+  char temporary_logfile[MAX_STR_LEN+1]; // where mondoarchive writes its stdout,stderr
+  char mondoparams_str[MAX_STR_LEN+1];
+  struct s_server2client_msg_record incoming_rec;
+  int retval=0, len, new_sClient, res=0;
+  FILE*fout, *fin;
+  long diffs=0;
+  pthread_t progress_thread;
+
+  sprintf(tmp, "Comparison of %s commenced", msgbody);
+  log_it(info, tmp);
+  if (send_progress_rpt_to_server(g_server_name, tmp)) { log_it(error, "Unable to send 'yep, got this msg' progress_rpt to server"); }
+  sprintf(temporary_logfile, "/tmp/monitas-client.templog.%d", (int)random()%32767);
+  sprintf(tempdev, "/tmp/monitas-client.device.%d", (int)random()%32767);
+  unlink(tempdev);
+  if (mkfifo(tempdev, 700))
+    {
+      log_it(error, "Unable to create temporary fifo in preparation for the call to mondoarchive");
+      return(1);
+    }
+  unlink(temporary_logfile);
+  if (mkfifo(temporary_logfile, 700))
+    {
+      log_it(error, "Unable to create temporary logfile fifo in preparation for the call to mondoarchive");
+      return(1);
+    }
+  strcpy(mondoparams_str, get_param_from_rcfile(CLIENT_RCFILE, "mondoarchive_params"));
+  sprintf(tmp, "mondoarchive_params --> '%s'", mondoparams_str);
+  log_it(debug, tmp);
+  sprintf(command, "mondoarchive -Vu -F %s -d %s -I %s > %s"/*; rm -f %s %s"*/, mondoparams_str, tempdev, msgbody, temporary_logfile/*, tempdev, temporary_logfile*/);
+  call_program_in_background(&g_mondo_thread, command);
+  sleep(5);
+  if (!program_still_running(command))
+    { res=1; log_it(error, "Unable to start mondoarchive. Please check /var/log/mondo-archive.log"); }
+  else
+    {
+      if (pthread_create(&progress_thread, NULL, track_compare_task_progress, (void*)temporary_logfile))
+        { log_it(error, "Cannot create pthread to track mondo task progress"); return(1); }
+      fout = fopen(tempdev, "w");
+      log_it(debug, "Opened fopen() to tempdev");
+      retval = receive_file_from_socket(fout, socket_fd);
+      log_it(debug, "Calling get_bkgd_prog_result");
+      fclose(fout);
+      res = get_bkgd_prog_result(&g_mondo_thread);
+      res = 0; // *shrug* Seems to help :)
+      pthread_join(progress_thread, NULL);
+    }
+  if (res)
+    { retval++; log_it(error, "Mondoarchive returned an error."); }
+  if (retval) { log_it(debug, "Errors have occurred. Notifing server..."); }
+  else        { log_it(debug, "Everything is OK so far. Notifying server..."); }
+  if (write(socket_fd, (char*)&retval, sizeof(retval))!=sizeof(retval)) {retval++;}
+/* receive msg from server; did comparison go OK at its end or not? */
+  unlink(tempdev);
+  unlink(temporary_logfile);
+  len = accept_and_recv_thru_client_port(g_sClient, &new_sClient, &g_sinClient, (char*)&incoming_rec, sizeof(incoming_rec));
+  if (len<0) { log_it(error, "After comparison, unable to accept/recv thru client port"); return(-10); }
+  sprintf(tmp, "After comparison, I received %s - %s", tmsg_to_string(incoming_rec.msg_type), incoming_rec.body);
+  log_it(debug, tmp);
+  if (incoming_rec.msg_type == compare_fail)
+    { retval++; log_it(error, "Server reported error(s) during comparison, although client didn't."); }
+  if (retval)
+    {
+      sprintf(tmp, "Errors occurred during comparison of %s", msgbody);
+      strcpy(command, call_program_and_get_last_line_of_output("tail -n20 /var/log/mondo-archive.log | grep /tmp/changed | head -n1"));
+      p = strstr(command, "/tmp/changed");
+      if (p)
+        {
+          strcat(command, " ");
+          sprintf(tmp, "command = '%s'", command);
+          log_it(debug, tmp);
+          *(strchr(p, ' '))='\0';
+          sprintf(tmp, "Opening list of changed files ('%s')", p);
+          log_it(debug, tmp);
+          log_it(info, "---Changed files---");
+          if ((fin=fopen(p, "r")))
+            { for(diffs=0; !feof(fin); diffs++) { fgets(tmp, MAX_STR_LEN, fin); if (strlen(tmp)>0) {tmp[strlen(tmp)-1]='\0';} log_it(info, tmp); } fclose(fin); }
+          log_it(info, "----End of list----");
+          sprintf(tmp, "%ld differences were found during comparison of %s", diffs, msgbody);
+          log_it(warn, tmp);
+          unlink(p);
+        }
+      else
+        {
+          sprintf(tmp, "Errors occurred during comparison of %s", msgbody);
+          log_it(error, tmp);
+          call_program_and_log_output("tail -n6 /var/log/mondo-archive.log");
+          log_it(info, "Please check /var/log/mondo-archive.log for more information");
+        }
+    }
+  else
+    {
+      sprintf(tmp, "Server agrees, comparison of %s succeeded :-)", msgbody);
+      log_it(info, tmp);
+    }
+  if (send_final_progress_report(tmp)) { retval++; log_it(error, "Unable to send final progress_rpt to server"); }
+  return(retval);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
 
 int find_and_bind_free_server_port(struct sockaddr_in *sin, int *p_s)
@@ -59 +428 @@
 Params: sin - server's IP address in a structure
     p_s - [return] file descriptor of port binding
-Return: result (0=success, nonzero=failure)
+Return: result (>0=success, -1=failure)
 */
 {
   int server_port;
+  char tmp[MAX_STR_LEN+1];
 
   for(server_port = 8700; server_port < 8710; server_port++)
@@ -70 +440 @@
     {
       perror("socket");
-      return(1);
+      return(-1);
     }
       if (connect(*p_s, (struct sockaddr*)sin, sizeof(struct sockaddr_in)) < 0)
     {
-      printf("Not connecting at %d\r", server_port);
+      sprintf(tmp, "Not connecting at %d", server_port);
+      log_it(debug, tmp);
       continue;
     }
       return(server_port);
     }
-  fprintf(stderr, "Cannot find free server port\nIs server actually running?\n");
-  return(1);
-}
+  return(-1);
+}
+
+
+
+/*-----------------------------------------------------------*/
 
 
@@ -98 +472 @@
   return(magic);
 }
+
+
+
+/*-----------------------------------------------------------*/
 
 
@@ -113 +491 @@
 {
   struct s_client2server_msg_record orig_rec;
-  int i;
 
   orig_rec.msg_type = login;
   strncpy(orig_rec.body, hostname, sizeof(orig_rec.body));
-  for(i=0; i<3; i++)
-    {
-      if (send_msg_to_server(&orig_rec, servername) > 0)
-        { return(orig_rec.port); }
-      printf("Attempt #%d to login failed. Retrying...\n", i+1);
-    }
-  printf("Failed to login\n");
-  return(-1);
-}
+  if (send_msg_to_server(&orig_rec, servername) < 0)
+    { return(-1); }
+  else
+    { return(orig_rec.port); }
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+
+void logout_and_exit(char*servername)
+/*
+Purpose:Logout of server. Terminate.
+Params: servername - ip address of server
+Return: none
+*/
+{
+  if (g_logged_in_currently)
+    {
+      if (logout_of_server(servername))
+        { log_it(warn, "Failed to logout of server."); }
+    }
+  call_program_and_log_output("rm -Rf /tmp/monitas-client.*");
+  register_pid(0, "client");
+//  chmod(g_command_fifo, 0);
+  unlink(g_command_fifo);
+  log_it(info, "---------- Monitas (client) has terminated ----------");
+  exit(0);
+}
+
+
+
+/*-----------------------------------------------------------*/
 
 
@@ -138 +542 @@
   struct s_client2server_msg_record orig_rec;
 
+  g_logging_out = true;
+  log_it(debug, "Logging out of server");
   orig_rec.msg_type = logout;
   strncpy(orig_rec.body, "Bye bye!", sizeof(orig_rec.body));
-  if (send_msg_to_server(&orig_rec, servername) <= 0)
+  if (send_msg_to_server(&orig_rec, servername) < 0)
     { return(1); }
   else
@@ -148 +554 @@
 
 
-// FIXME -
-// Are the threads trampling on one another's st_sClient, st_new_sClient's?
-// I don't see how. After all, there's only one thread... :-)
+/*-----------------------------------------------------------*/
+
+
+
+int process_incoming_command(char*incoming)
+/*
+Purpose:Process incoming command, presumably
+        read from FIFO and sent there by sysadm/user.
+Params: incoming - raw command string itself
+Return: result (0=success; nonzero=failure)
+*/
+{
+  int res=0;
+  char tmp[MAX_STR_LEN+1];
+  int pos, i;
+  char command[MAX_STR_LEN+1], path[MAX_STR_LEN+1], aux[MAX_STR_LEN+1];
+  struct s_client2server_msg_record orig_rec;
+
+  pos=0;
+  sscanf(incoming, "%s %s", command, path);
+  for(i=0; i<strlen(command); i++) { command[i]=command[i]|0x60; }
+  if (!strcmp(command, "restore"))
+    { sscanf(incoming, "%s %s %s", command, path, aux); }
+  else
+    { aux[0] = '\0'; }
+  sprintf(tmp, "cmd=%s path=%s aux=%s", command, path, aux);
+  log_it(debug, tmp);
+  sprintf(tmp, "%s of %s [aux='%s'] <-- command received", command, path, aux);
+  log_it(info, tmp);
+  if (strcmp(command, "restore") && aux[0]!='\0')
+    { log_it(warn, "Ignoring auxiliary parameter: it is superfluous."); }
+  if (strcmp(command, "backup") && strcmp(command, "compare") && strcmp(command, "restore"))
+    {
+      sprintf(tmp, "%s - command unknown.", command);
+      log_it(error, tmp);
+      res=1;
+    }
+  else
+    {
+      sprintf(tmp, "'%s' sent to server as a formal request", incoming);
+      orig_rec.msg_type = user_req;
+      strncpy(orig_rec.body, incoming, sizeof(orig_rec.body));
+      if (send_msg_to_server(&orig_rec, g_server_name) < 0)
+        { res++; log_it(error, "Unable to send user req to server"); }
+      else
+        { log_it(debug, tmp); }
+    }
+  return(res);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+int restore_archives(char*msgbody, char*msgbodyAux, int socket_fd)
+/*
+Purpose:Restore archives, sent by server.
+Params: msgbody - char[MSG_BODY_SIZE] containing info
+about the archives to be restored
+socket_fd - file descriptor from which to
+read the archives sent by server.
+Return: result (0=success; nonzero=failure)
+*/
+{
+  char tmp[MAX_STR_LEN+1], command[MAX_STR_LEN+1], tempdev[MAX_STR_LEN+1], *p;
+  char temporary_logfile[MAX_STR_LEN+1]; // where mondorestore writes its stdout,stderr
+  struct s_server2client_msg_record incoming_rec;
+  int retval=0, len, new_sClient, res=0;
+  FILE*fout, *fin;
+  long diffs=0;
+  pthread_t progress_thread;
+  
+  sprintf(tmp, "Restoration of %s commenced", msgbody);
+  log_it(info, tmp);
+  if (send_progress_rpt_to_server(g_server_name, tmp)) { log_it(error, "Unable to send 'yep, got this msg' progress_rpt to server"); }
+  sprintf(temporary_logfile, "/tmp/monitas-client.templog.%d", (int)random()%32767);
+  sprintf(tempdev, "/tmp/monitas-client.device.%d", (int)random()%32767);
+  unlink(tempdev);
+  if (mkfifo(tempdev, 700))
+    {
+      log_it(error, "Unable to create temporary fifo in preparation for the call to mondorestore");
+      return(1);
+    }
+  unlink(temporary_logfile);
+  if (mkfifo(temporary_logfile, 700))
+    {
+      log_it(error, "Unable to create temporary logfile in preparation for the call to mondorestore");
+      return(1);
+    }
+  sprintf(command, "mondorestore --monitas-live %s %s %s &> %s", tempdev, msgbody, msgbodyAux, temporary_logfile);
+//  sprintf(command, "cat %s > %s", tempdev, "/tmp/out.dat");
+  call_program_in_background(&g_mondo_thread, command);
+  sleep(5);
+  if (!program_still_running(command))
+    {
+      res=1; log_it(error, "mondorestore could not be started. Please check /tmp/mondo-restore.log");
+    }
+  else
+    {
+      if (pthread_create(&progress_thread, NULL, track_restore_task_progress, (void*)temporary_logfile))
+        { log_it(error, "Cannot create pthread to track mondo task progress"); return(1); }
+      fout = fopen(tempdev, "w");
+      log_it(debug, "Opened fopen() to tempdev");
+      retval = receive_file_from_socket(fout, socket_fd);
+      if (retval && !system("cat /tmp/mondo-restore.log | grep -i \"End of restore_live_from_monitas_server\" &> /dev/null"))
+        {
+          retval=0;
+          log_it(debug, "SIGPIPE caught but that's OK, it was anticipated.");
+          res=0;
+        }
+      log_it(debug, "Calling get_bkgd_prog_result");
+      fclose(fout);
+      res = get_bkgd_prog_result(&g_mondo_thread);
+      pthread_join(progress_thread, NULL);
+    }
+  unlink(tempdev);
+  unlink(temporary_logfile);
+  if (res)
+    { retval++; log_it(error, "mondorestore returned an error."); }
+  if (retval) { log_it(debug, "Errors have occurred. Notifing server..."); }
+  else        { log_it(debug, "Everything is OK so far. Notifying server..."); }
+  sleep(1); // probably unnecessary
+/* I do this thrice because mondorestore often causes a SIGPIPE, which means... I have to do this thrice :-) */
+  if (write(socket_fd, (char*)&retval, sizeof(retval))!=sizeof(retval)) {log_it(debug, "Failed to write wtf-info"); retval++;}
+  if (write(socket_fd, (char*)&retval, sizeof(retval))!=sizeof(retval)) {log_it(debug, "Failed to write wtf-info"); retval++;}
+  if (write(socket_fd, (char*)&retval, sizeof(retval))!=sizeof(retval)) {log_it(debug, "Failed to write wtf-info"); retval++;}
+/* receive msg from server; did restoration go OK at its end or not? */
+  unlink(tempdev);
+  unlink(temporary_logfile);
+  len = accept_and_recv_thru_client_port(g_sClient, &new_sClient, &g_sinClient, (char*)&incoming_rec, sizeof(incoming_rec));
+  if (len<0) { log_it(error, "After restoration, unable to accept/recv thru client port"); return(-10); }
+  sprintf(tmp, "After restoration, I received %s - %s", tmsg_to_string(incoming_rec.msg_type), incoming_rec.body);
+  log_it(debug, tmp);
+  if (incoming_rec.msg_type == restore_fail)
+    { retval++; log_it(error, "Server reported error(s) during restoration, although client didn't."); }
+  if (retval)
+    {
+      sprintf(tmp, "Errors occurred during restoration of %s", msgbody);
+      strcpy(command, call_program_and_get_last_line_of_output("tail -n20 /var/log/mondo-archive.log | grep /tmp/changed | head -n1"));
+      p = strstr(command, "/tmp/changed");
+      if (p)
+        {
+          strcat(command, " ");
+          sprintf(tmp, "command = '%s'", command);
+          log_it(debug, tmp);
+          *(strchr(p, ' '))='\0';
+          sprintf(tmp, "Opening list of changed files ('%s')", p);
+          log_it(debug, tmp);
+          log_it(info, "---Changed files---");
+          if ((fin=fopen(p, "r")))
+            { for(diffs=0; !feof(fin); diffs++) { fgets(tmp, MAX_STR_LEN, fin); if (strlen(tmp)>0) {tmp[strlen(tmp)-1]='\0';} log_it(info, tmp); } fclose(fin); }
+          log_it(info, "----End of list----");
+          sprintf(tmp, "%ld differences were found during restoration of %s", diffs, msgbody);
+          log_it(warn, tmp);
+        }
+      else
+        {
+          sprintf(tmp, "Errors occurred during restoration of %s", msgbody);
+          log_it(error, tmp);
+          call_program_and_log_output("tail -n6 /var/log/mondo-archive.log");
+          log_it(info, "Please check /var/log/mondo-archive.log for more information");
+        }
+    }
+  else
+    {
+      sprintf(tmp, "Server agrees, restoration of %s succeeded :-)", msgbody);
+      log_it(info, tmp);
+    }
+  if (send_final_progress_report(tmp)) { retval++; log_it(error, "Unable to send final progress_rpt to server"); }
+  return(retval);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+void *send_final_progress_report_SUB(void*inp)
+{
+  char message[MAX_STR_LEN+1];
+
+  strncpy(message, (char*)inp, MAX_STR_LEN);
+  sleep(10);
+  send_progress_rpt_to_server(g_server_name, message);
+  pthread_exit(NULL);
+}
+
+
+
+int send_final_progress_report(char*final_string)
+{
+  pthread_t thread;
+
+  if (send_progress_rpt_to_server(g_server_name, final_string)) { return(1); }
+  if (pthread_create(&thread, NULL, send_final_progress_report_SUB, (void*)"Idle")) { log_it(error, "Unable to create pthread"); return(1); }
+  return(0);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
 int send_msg_to_server(struct s_client2server_msg_record *rec, char *servername)
 /*
 Purpose:Send message to server - a login/logout/ping request
-    or perhaps a request for data to be restored.
+        or perhaps a request for data to be restored.
 Params: rec - the message to be sent to server
-    servername - the hostname of server
-Return: result (-1=failure, >0=success)
+        servername - the hostname of server
+Return: result (<0=failure, 0+=success)
 */
 {
   struct hostent *hp;
   struct sockaddr_in sin;
-  static struct sockaddr_in st_sinClient; /* client port; connected by login; closed by logout */
-  static int st_sClient; /* client connection */
-  static int st_new_sClient;
-  int server_port, s, len;
-  static int  st_client_port=0; /* client port; set by login */
+  int server_port, new_sClient, s, len, res;
   struct s_server2client_msg_record incoming_rec;
   struct pollfd ufds;
-  static t_pid st_pid=-1;
+  char tmp[MAX_STR_LEN+1];
+  void *thread_result;
+  pthread_t a_thread;
 
 /* If logging out then kill the trigger-watcher before trying;
-   otherwise, the trigger-watcher will probably catch the
-   'logout_ok' packet and go nutty on us :-)
-*/
-  if (rec->msg_type == logout)
-    {
-      sprintf(tmp, "kill %d &> /dev/null", st_pid);
-    system(tmp);
-//      kill(st_pid);
-    st_pid = -1;
-    }
-
-/* st_sinClient, st_new_sClient and st_sClient contain info
-   relating to the permanent socket which this subroutine
-   opens at login-time so that it can listen for messages
-   from the server. This subroutine doesn't watch the
-   socket all the time (yet) but it leaves it open until
-   logout-time, for neatness' sake.
-*/
-  if ((hp = gethostbyname(servername)) == NULL) { fprintf(stderr, "%s: unknown host\n", servername); return(1); }
-  if (st_client_port > 0 && rec->msg_type == login) { fprintf(stderr, "Already logged in. Why try again?\n"); return(1); }
-  if (st_client_port <= 0 && rec->msg_type != login) { fprintf(stderr, "Don't try to send msgs before logging in.\n"); return(1); }
+otherwise, the trigger-watcher will probably catch the
+'logout_ok' packet and go nutty on us :-)
+*/
+  if ((hp = gethostbyname(servername)) == NULL)
+    {
+      sprintf(tmp, "%s: unknown host", servername);
+      log_it(error, tmp);
+      return(-1);
+    }
+  if (g_logged_in_currently && rec->msg_type == login) { log_it(error, "Already logged in. Why try again?"); return(-1); }
+  if (!g_logged_in_currently && rec->msg_type != login)
+    {
+      log_it(fatal, "Server has forcibly logged you out.");
+    } /* or you never logged in to begin which, which suggests the programmer screwed up */
   /* open client port if login */
-
   if (rec->msg_type == login)
     {
-      printf("Logging in\n");
-      st_client_port = 8800 + rand()%100; // FIXME: retry if I can't use this port
-      memset((void*)&st_sinClient, 0, sizeof(st_sinClient));
-      st_sinClient.sin_family = AF_INET;
-      st_sinClient.sin_addr.s_addr = INADDR_ANY;
-      st_sinClient.sin_port = htons(st_client_port);
-      if ((st_sClient = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { fprintf(stderr, "Unable to open socket on port #%d\n", st_client_port); return(1); }
-      if (bind(st_sClient, (struct sockaddr*)&st_sinClient, sizeof(st_sinClient)) < 0) { fprintf(stderr, "Cannot bind %d - %s\n", st_client_port, strerror(errno)); return(2); }
-      if (listen(st_sClient, MAX_PENDING) < 0) { fprintf(stderr, "Cannot setup listen (%d) - %s\n", st_client_port, strerror(errno)); return(3); }
-    }
-
+      log_it(info, "Trying to login");
+      g_client_port = 8800 + rand()%100; // FIXME: retry if I can't use this port
+      g_sClient = bind_client_port(&g_sinClient, g_client_port);
+      if (g_sClient<0) { log_it(error, "Cannot bind client port"); return(-1); }
+    }
   /* send msg to server */
-  rec->port = st_client_port;
+  rec->port = g_client_port;
   memset((void*)&sin, 0, sizeof(sin));
   sin.sin_family = AF_INET;
   memcpy((void*)&sin.sin_addr, hp->h_addr, hp->h_length);
   server_port = find_and_bind_free_server_port(&sin, &s);
-  if (server_port<=0) { fprintf(stderr, "Cannot find free server port\nIs server running?\n"); return(1); }
+  if (server_port<=0)
+    {
+      sprintf(tmp, "Cannot find+bind free server port. Is server running?");
+      log_it(error, tmp);
+      return(-3);
+    }
   rec->magic = increment_magic_number();
   send (s, (char*)rec, sizeof(struct s_client2server_msg_record), 0);
   close(s);
-
-  /* wait for ack/pong/feedback */
-  ufds.fd = st_sClient;
-  ufds.events = POLLIN|POLLPRI;
-  poll(&ufds, 1, 1000);
-  if (!ufds.revents) { fprintf(stderr,"Failed to poll\n"); return(-1); }
-  len = sizeof(st_sinClient);
-  if ((st_new_sClient = accept(st_sClient, (struct sockaddr*)&st_sinClient, &len)) < 0) { fprintf(stderr,"[child] Cannot accept\n"); return(1); }
-  if ((len = recv(st_new_sClient, (char*)&incoming_rec, sizeof(incoming_rec), MSG_DONTWAIT)) <= 0) { fprintf(stderr, "[child] Cannot recv\n"); return(2); }
-
-  printf("Received %s - %s\n", tmsg_to_string(incoming_rec.msg_Type, incoming_rec.body);
-  if (rec->msg_type != login && incoming_rec.msg_type == login_ok) { fprintf(stderr, "WTF? login_ok but I wasn't logging in\n"); }
-  if (rec->msg_type != logout&& incoming_rec.msg_type == logout_ok){ fprintf(stderr, "WTF? logout_ok but I wasn't logging out\n"); }
-// FIXME - should I close() after accepting and recving? Or should I wait until logging out?
-
-  /* close client port if logout */
+  /* wait for ack/pong/feedback (if logging in/out) */
+  if (rec->msg_type == login /* || rec->msg_type == logout */)
+    {
+      ufds.fd = g_sClient;
+      ufds.events = POLLIN|POLLPRI;
+      poll(&ufds, 1, 1000);
+      if (!ufds.revents) { log_it(error, "Failed to poll"); return(-5); }
+      len = accept_and_recv_thru_client_port(g_sClient, &new_sClient, &g_sinClient, (char*)&incoming_rec, sizeof(incoming_rec));
+      if (len<0) { log_it(error, "Unable to accept/recv thru client port"); return(-10); }
+      sprintf(tmp, "Received %s - %s", tmsg_to_string(incoming_rec.msg_type), incoming_rec.body);
+      log_it(info, tmp);
+      if (rec->msg_type != login && incoming_rec.msg_type == login_ok) { log_it(error, "WTF? login_ok but I wasn't logging in"); }
+      if (rec->msg_type != logout&& incoming_rec.msg_type == logout_ok){ log_it(error, "WTF? logout_ok but I wasn't logging out"); }
+      close(new_sClient);
+      new_sClient=-1;
+    }
+  if (incoming_rec.msg_type == backup_fail) { log_it(error, "Failed, says server"); return(-8); }
+  /* fork the process which watches in the background for pings/requests/etc. */
+  if (rec->msg_type == login)
+    {
+      g_logged_in_currently = true;
+      strcpy(tmp, "Hello world!");
+      res = pthread_create(&a_thread, NULL, watch_port_for_triggers_from_server, (void*)tmp);
+      log_it(debug, "Returning from login + call to pthread_create");
+      return(server_port);
+    }
   if (rec->msg_type == logout)
     {
-      close(st_new_sClient);
-      st_new_sClient = st_sClient = st_client_port = 0;
-    }
-
-  if (incoming_rec.msg_type == fail) { return(-1); }
-
-/* fork the process which watches in the background for pings/requests/etc. */
-  if (rec->msg_type == login)
-    {
-      st_pid = fork();
-      switch(st_pid)
-        {
-          case -1:
-            fprintf(stderr, "Failed to fork\n"); exit(1);
-          case 0: /* child */
-            watch_port_for_triggers_from_server(&st_sinClient, st_new_sClient, st_sClient);
-            exit(0);
-          default:/* parent */
-            return(server_port);
-        }
-    }
-}
-
-
-
-int send_ping_to_server(char*msg, char*servername)
-/*
-Purpose:Send a 'ping' to server. Wait for 'pong!'.
+      log_it(debug, "Calling pthread_join to reunite trigger-watcher and main loop");
+      res = pthread_join(a_thread, &thread_result);
+      if (res) { /*perror("Thread join failed");*/ log_it(debug, "Thread join failed in send_msg_to_server()"); }
+      else { sprintf(tmp, "Thread join succeeded. Result: %s", (char*)thread_result); log_it(debug, tmp); }
+    }
+  return(0);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+int send_ping_to_server(char*servername, char*msg)
+/*
+Purpose:Send a 'ping' to server.
 Params: msg - string to send ("Hello world"?)
     servername - server's hostname
@@ -272 +870 @@
   orig_rec.msg_type = ping;
   strncpy(orig_rec.body, msg, sizeof(orig_rec.body));
-  if (send_msg_to_server(&orig_rec, servername) <= 0)
+  if (send_msg_to_server(&orig_rec, servername) < 0)
     { return(1); }
   else
@@ -280 +878 @@
 
 
-char *tmsg_to_string(t_msg msg_type)
-/*
-Purpose:Return a string/name of the msg of type msg_type
-Params: msg_type - type of message (enum typedef)
-Return: pointer to static string {name of msg)
-*/
-{
-  static char sz_msg[MAX_STR_LEN];
-  switch(msg_type)
-    {
-      case unused : strcpy(sz_msg, "unused"); break;
-      case login  : strcpy(sz_msg, "login"); break;
-      case logout : strcpy(sz_msg, "logout"); break;
-      case login_ok:strcpy(sz_msg, "login_ok"); break;
-      case logout_ok:strcpy(sz_msg, "logout_ok"); break;
-      case ping   : strcpy(sz_msg, "ping"); break;
-      case pong   : strcpy(sz_msg, "pong"); break;
-      case fail   : strcpy(sz_msg, "fail"); break;
-      case trigger_backup: strcpy(sz_msg, "trigger_backup"); break;
-      case trigger_restore: strcpy(sz_msg, "trigger_restore"); break;
-      case begin_stream: strcpy(sz_msg, "begin_stream"); break;
-      case end_stream: strcpy(sz_msg, "end_stream"); break;
-      default: strcpy(sz_msg, "(Fix tmsg_to_string please)"); break;
-    }
-  return(sz_msg);
-}
-
-
-void watch_port_for_triggers_from_server(struct sockaddr_in *sin, int new_s, int s)
+/*-----------------------------------------------------------*/
+
+
+
+int send_progress_rpt_to_server(char*servername, char*msg)
+/*
+Purpose:Send a 'progress_rpt' string to server.
+Params: msg - string to send ("Hello world"?)
+    servername - server's hostname
+Return: result (0=success, nonzero=failure)
+*/
+{
+  struct s_client2server_msg_record orig_rec;
+  orig_rec.msg_type = progress_rpt;
+  strncpy(orig_rec.body, msg, sizeof(orig_rec.body));
+  if (send_msg_to_server(&orig_rec, servername) < 0)
+    { return(1); }
+  else
+    { return(0); }
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+void terminate_daemon(int sig)
+/*
+Purpose: Shut down the server in response to interrupt.
+Params:  Signal received.
+Returns: None
+*/
+{
+  int res;
+
+// FIXME - takes server 1-2 mins to realize I've aborted. I want that to be 5-10 seconds :)
+  set_signals(false); // termination in progress
+  log_it(info, "Abort signal caught by interrupt handler");
+  call_program_and_log_output("kill `ps ax | grep mondo | grep -v \"ps ax\" | grep -v \"grep mondo\" | grep monitas | cut -d' ' -f1`");
+  if (send_ping_to_server(g_server_name, "I'm pinging you before I logout"))
+    { log_it(error, "Server has shut down without warning."); }
+  if (g_mondo_thread)
+    {
+      res = get_bkgd_prog_result(&g_mondo_thread);
+    }
+  logout_and_exit(g_server_name);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+void *track_backup_task_progress(void*inp)
+{
+  char fname[MAX_STR_LEN+1],
+    tmp[MAX_STR_LEN+1],
+    progress_str[MAX_STR_LEN+1],
+    old_progstr[MAX_STR_LEN+1],
+    *p;
+  struct s_client2server_msg_record rec;
+  FILE*fin;
+  bool biggies=false, regulars=false;
+  int prev_percentage=0, i;
+
+  rec.msg_type = progress_rpt;
+  strcpy(fname, (char*)inp);
+  log_it(debug, "track_backup_task_progres() --- entering");
+  fin = fopen(fname, "r");
+  old_progstr[0]='\0';
+  sprintf(tmp, "fname = %s", fname);
+  log_it(debug, tmp);
+  sleep(2);
+  if (!does_file_exist(fname)) { log_it(fatal, "track_backup_task_progress() -- fname not found"); }
+  strcpy(rec.body, "Working");
+  if (send_msg_to_server(&rec, g_server_name) < 0) { log_it(error, "Failed to send progress_rpt msg to server."); pthread_exit(NULL); }
+  log_it(debug, rec.body);
+/* skip initial stuff */
+  while(!feof(fin))
+    {
+      fgets(progress_str, MAX_STR_LEN, fin);
+      progress_str[MAX_STR_LEN]='\0';
+      if (strlen(progress_str)<2) { continue; }
+      if (strstr(progress_str, "TASK")) { break; }
+    }
+/* skip more stuff */
+  while(!feof(fin))
+    {
+      fgets(progress_str, MAX_STR_LEN, fin);
+      progress_str[MAX_STR_LEN]='\0';
+      if (strlen(progress_str)<2) { continue; }
+      if (!strstr(progress_str, "TASK")) { break; }
+    }
+/* report on regular+biggie files */
+  while(!feof(fin))
+    {
+      fgets(progress_str, MAX_STR_LEN, fin);
+      progress_str[MAX_STR_LEN]='\0';
+      if (strstr(progress_str, "rchiving set 0"))
+        { prev_percentage = 0; regulars = true; }
+      if (strstr(progress_str, "acking up all large files"))
+        { prev_percentage = 0; regulars = false; biggies = true; }
+      if (strlen(progress_str)<2) { continue; }
+      if (!strstr(progress_str, "TASK")) { continue; }
+      progress_str[strlen(progress_str)-1] = '\0';
+      log_it(debug, progress_str);
+      if (!biggies && !regulars)
+        { strcpy(progress_str, "Still working..."); }
+      if (strcmp(progress_str, old_progstr))
+        {
+          strcpy(old_progstr, progress_str);
+          if (biggies)
+            { sprintf(rec.body, "Large files: %s", progress_str+6); }
+          else if (regulars)
+            { sprintf(rec.body, "Regular files: %s", progress_str+6); }
+      if (!(p=strstr(progress_str, "% done"))) { continue; }
+
+          log_it(info, rec.body);
+          if (send_progress_rpt_to_server(g_server_name, rec.body)) { log_it(error, "Failed to send progress_rpt msg to server."); pthread_exit(NULL); }
+          continue;
+
+          while(!isdigit(*(p-1))) { p--; }
+          strcpy(tmp, p);
+          *(strchr(tmp, '%')) = '\0';
+          i = atoi(tmp);
+          if (i > prev_percentage)
+            {
+              prev_percentage = i;
+              log_it(info, rec.body);
+// FIXME - could simply call send_progress_rpt_to_server()
+              if (send_msg_to_server(&rec, g_server_name) < 0) { log_it(error, "Failed to send progress_rpt msg to server."); pthread_exit(NULL); }
+            }
+        }
+    }
+  log_it(debug, "track_backup_task_progress() --- leaving");
+  pthread_exit(NULL);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+void *track_compare_task_progress(void*inp)
+{
+  char fname[MAX_STR_LEN+1],
+    tmp[MAX_STR_LEN+1],
+    progress_str[MAX_STR_LEN+1],
+    old_progstr[MAX_STR_LEN+1],
+    *p;
+//  struct s_client2server_msg_record rec;
+  FILE*fin;
+  bool biggies=false, regulars=false;
+  int prev_percentage=0, i;
+
+  strcpy(fname, (char*)inp);
+  log_it(debug, "track_compare_task_progress() --- entering");
+  if (!(fin = fopen(fname, "r"))) { log_it(fatal, "Unable to openin tempdev while comparing"); }
+  old_progstr[0]='\0';
+  sprintf(tmp, "fname = %s", fname);
+  log_it(debug, tmp);
+  sleep(2);
+  if (!does_file_exist(fname)) { log_it(fatal, "track_compare_task_progress() -- fname not found"); }
+  log_it(debug, "Working");
+  if (send_progress_rpt_to_server(g_server_name, "Working")) { log_it(error, "Failed to send progress_rpt msg to server."); pthread_exit(NULL); }
+
+/* report on regular+biggie files */
+  while(!feof(fin))
+    {
+      fgets(progress_str, MAX_STR_LEN, fin);
+      progress_str[MAX_STR_LEN]='\0';
+      log_it(debug, progress_str);
+      if (strstr(progress_str, "erifying fileset #0"))
+        { prev_percentage = 0; regulars = true; }
+      if (strstr(progress_str, "erifying all bigfiles"))
+        { prev_percentage = 0; regulars = false; biggies = true; }
+      if (strlen(progress_str)<2) { continue; }
+      if (!strstr(progress_str, "TASK")) { continue; }
+      progress_str[strlen(progress_str)-1] = '\0';
+      if (!biggies && !regulars)
+        { strcpy(progress_str, "Still working..."); }
+      if (strcmp(progress_str, old_progstr))
+        {
+          strcpy(old_progstr, progress_str);
+          if (biggies)
+            { sprintf(tmp, "Large files: %s", progress_str+6); }
+          else if (regulars)
+            { sprintf(tmp, "Regular files: %s", progress_str+6); }
+      if (!(p=strstr(progress_str, "% done"))) { continue; }
+
+          log_it(info, tmp);
+          if (send_progress_rpt_to_server(g_server_name, tmp)) { log_it(error, "Failed to send progress_rpt msg to server."); pthread_exit(NULL); }
+          continue;
+
+          while(!isdigit(*(p-1))) { p--; }
+          strcpy(tmp, p);
+          *(strchr(tmp, '%')) = '\0';
+          i = atoi(tmp);
+          if (i > prev_percentage)
+            {
+              prev_percentage = i;
+              log_it(info, tmp);
+// FIXME - could simply call send_progress_rpt_to_server()
+              if (send_progress_rpt_to_server(g_server_name, tmp)) { log_it(error, "Failed to send progress_rpt msg to server."); pthread_exit(NULL); }
+            }
+        }
+    }
+  log_it(debug, "track_compare_task_progress() --- leaving");
+  pthread_exit(NULL);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+void *track_restore_task_progress(void*inp)
+{
+  char fname[MAX_STR_LEN+1],
+    tmp[MAX_STR_LEN+1],
+    progress_str[MAX_STR_LEN+1],
+    old_progstr[MAX_STR_LEN+1],
+    *p;
+//  struct s_client2server_msg_record rec;
+  FILE*fin;
+  bool biggies=false, regulars=false;
+  int prev_percentage=0, i;
+
+  strcpy(fname, (char*)inp);
+  log_it(debug, "track_restore_task_progress() --- entering");
+  if (!(fin = fopen(fname, "r"))) { log_it(fatal, "Unable to openin tempdev while restoring"); }
+  old_progstr[0]='\0';
+  sprintf(tmp, "fname = %s", fname);
+  log_it(debug, tmp);
+  sleep(2);
+  if (!does_file_exist(fname)) { log_it(fatal, "track_restore_task_progress() -- fname not found"); }
+  log_it(debug, "Working");
+  if (send_progress_rpt_to_server(g_server_name, "Working")) { log_it(error, "Failed to send progress_rpt msg to server."); pthread_exit(NULL); }
+
+// FIXME --- mondorestore does not yet spit out its progress in
+// a user-friendly format; so, most of the following code won't
+// work. The server will know we're working but it won't know
+// how far along we've gotten.
+
+/* report on regular+biggie files */
+  while(!feof(fin))
+    {
+      fgets(progress_str, MAX_STR_LEN, fin);
+      progress_str[MAX_STR_LEN]='\0';
+      continue;
+
+      log_it(debug, progress_str);
+      if (strstr(progress_str, "estoring fileset #0"))
+        { prev_percentage = 0; regulars = true; }
+      if (strstr(progress_str, "erifying all bigfiles"))
+        { prev_percentage = 0; regulars = false; biggies = true; }
+      if (strlen(progress_str)<2) { continue; }
+      if (!strstr(progress_str, "TASK")) { continue; }
+      progress_str[strlen(progress_str)-1] = '\0';
+      if (!biggies && !regulars)
+        { strcpy(progress_str, "Still working..."); }
+      if (strcmp(progress_str, old_progstr))
+        {
+          strcpy(old_progstr, progress_str);
+          if (biggies)
+            { sprintf(tmp, "Large files: %s", progress_str+6); }
+          else if (regulars)
+            { sprintf(tmp, "Regular files: %s", progress_str+6); }
+      if (!(p=strstr(progress_str, "% done"))) { continue; }
+
+          log_it(info, tmp);
+          if (send_progress_rpt_to_server(g_server_name, tmp)) { log_it(error, "Failed to send progress_rpt msg to server."); pthread_exit(NULL); }
+          continue;
+
+          while(!isdigit(*(p-1))) { p--; }
+          strcpy(tmp, p);
+          *(strchr(tmp, '%')) = '\0';
+          i = atoi(tmp);
+          if (i > prev_percentage)
+            {
+              prev_percentage = i;
+              log_it(info, tmp);
+// FIXME - could simply call send_progress_rpt_to_server()
+              if (send_progress_rpt_to_server(g_server_name, tmp)) { log_it(error, "Failed to send progress_rpt msg to server."); pthread_exit(NULL); }
+            }
+        }
+    }
+  log_it(debug, "track_restore_task_progress() --- leaving");
+  pthread_exit(NULL);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+void *watch_port_for_triggers_from_server(void*arg)
 /*
 Purpose:Watch client port for incoming trigger
-Params: sin - record containing info on the port/socket
-        new_s - file descriptor of _open_ client socket
-        s - file descriptor of client socket (not the 'open' side of it)
-NB:     I don't really know why new_s and s are what they are or how or why.
+Params: none; uses global vars instead
 Return: none
+*/
 {
   struct pollfd ufds;
-  int len;
-
+  struct s_server2client_msg_record incoming_rec;
+  int len, res, new_s;
+  char tmp[MAX_STR_LEN+1];
+
+  strcpy(tmp,(char*)arg);
+  log_it(info, "Awaiting triggers from server");
   for(;;)
     {
-  /* wait for ack/pong/feedback */
-      ufds.fd = s;
+      /* wait for ack/pong/feedback/trigger */
+      ufds.fd = g_sClient;
       ufds.events = POLLIN|POLLPRI;
       poll(&ufds, 1, 1000);
       if (!ufds.revents) { continue; } /* wait again */
-      len = sizeof(struct sockaddr_in);
-      if ((new_s = accept(s, (struct sockaddr*)sin, &len)) < 0) { fprintf(stderr,"[child] Cannot accept\n"); return(1); }
-      if ((len = recv(new_s, (char*)&incoming_rec, sizeof(incoming_rec), MSG_DONTWAIT)) <= 0) { fprintf(stderr, "[child] Cannot recv\n"); return(2); }
-      printf("Received %s - %s\n", tmsg_to_string(incoming_rec.msg_Type, incoming_rec.body);
-// FIXME - should I close() after accepting and recving?
-    }
-}
-
-
-
-/* main */
+      len = accept_and_recv_thru_client_port(g_sClient, &new_s, &g_sinClient, (char*)&incoming_rec, sizeof(incoming_rec));
+      if (len<0) { log_it(error, "Unable to receive incoming trigger from server"); continue; }
+      switch(incoming_rec.msg_type)
+    {
+    case trigger_backup:
+      res = back_my_smitch_up(incoming_rec.body, new_s); /* no need to multitask: it's the client! :) */
+      break;
+    case trigger_compare:
+      res = compare_archives(incoming_rec.body, new_s);
+      break;
+    case trigger_restore:
+      res = restore_archives(incoming_rec.body, incoming_rec.bodyAux, new_s);
+      break;
+        case logout_ok:
+          if (!g_logging_out)
+            { log_it(fatal, "Server has forcibly logged you out. Has server shut down?"); }
+          g_logged_in_currently = false;
+          g_logging_out = false;
+//    exit(0);
+          pthread_exit("Thou hast been logged out.");
+        case login_fail:
+          log_it(fatal, "Failed to login. Server thinks we're logged in already.");
+    default:
+      sprintf(tmp, "Received %s - '%s'", tmsg_to_string(incoming_rec.msg_type), incoming_rec.body);
+      log_it(info, tmp);
+    }
+      close(new_s);
+    }
+}
+
+    
+
+/*-----------------------------------------------------------*/
+
+
 
 int main(int argc, char*argv[])
@@ -347 +1244 @@
 {
   int client_port;
-  char hostname[MAX_STR_LEN+1], msg[MAX_STR_LEN+1], servername[MAX_STR_LEN+1];
-  bool done;
-
+  char hostname[MAX_STR_LEN+1], tmp[MAX_STR_LEN+1];
+//  char msg[MAX_STR_LEN+1];
+//  bool done;
+//  pthread_t thread;
+
+  log_it(info, "---------- Monitas (client) by Hugo Rabson ----------");
+  register_pid(getpid(), "client");
+  set_signals(true);
   srandom(time(NULL));
   /* FIXME - add Ctrl-C / sigterm trapping */
-  /* FIXME - run login/logout code as a fork and share the logged in/logged out status flag */
-
+
+/*
+  call_program_in_background(&thread, "ls aaa");
+  if (program_still_running("ls aaa"))
+    { printf("Program is still running\n"); }
+  else
+    { printf("Program is no longer running\n"); }
+  exit(0);
+*/
   if (argc == 2)
     {
-      strncpy(servername, argv[1], MAX_STR_LEN);
-      servername[MAX_STR_LEN]='\0';
+      strncpy(g_server_name, argv[1], MAX_STR_LEN);
+      g_server_name[MAX_STR_LEN]='\0';
     }
   else
@@ -365 +1274 @@
     }
   gethostname(hostname, sizeof(hostname));
-  printf("Logging onto server as client '%s'\n", hostname);
-  client_port = login_to_server(hostname, servername);
-  if (client_port <= 0) { fprintf(stderr, "Unable to login to server. Aborting\n"); exit(1); }
-  for(done=false; !done; )
-    {
-      printf("MsgToSend: ");
-      fgets(msg, sizeof(msg), stdin);
-      if (!strncmp(msg, "logout", 6)) { done=true; }
-      else
-    {
-      if (send_ping_to_server(msg, servername))
-        { fprintf(stderr, "Error while waiting for response to ping\n"); exit(1); }
-    }
-    }
-  printf("Logging out of server\n");
-  if (logout_of_server(servername))
-    { fprintf(stderr, "Warning - failed to logout of server.\n"); }
+  sprintf(tmp, "Logging onto server as client '%s'", hostname);
+  log_it(info, tmp);
+  client_port = login_to_server(hostname, g_server_name);
+  if (client_port <= 0)
+    {
+      fprintf(stderr, "Unable to login to server.\n");
+      log_it(error, "Unable to login to server.");
+      exit(1);
+    }
+
+//  set_param_in_rcfile(CLIENT_RCFILE, "mondoarchive_params", "-1 -L");
+  log_it(debug, "Awaiting commands from FIFO");
+  create_and_watch_fifo_for_commands(CLIENT_COMDEV);
+  logout_and_exit(g_server_name);
   exit(0);
 }

branches/stable/monitas/server.c

@@ -3 +3 @@
 
 
-SERVER
-
-
-FIXME
-- when sysadm requests it:-
-  - connect to relevant port of client
-  - send trigger_backup msg
-  - receive file(s)
-  - close client's port
-
-05/20
-- changed 'clientname' to 'clientIP'
+06/19
+- fixed bugs in mondoarchive compare code
+
+06/16
+- every 15 seconds, update /var/spool/monitas/server-status.txt file
+- added handle_progress_rpt()
+- modify restore_path() to allow user to restore to another path
+
+06/14
+- added "2> /dev/null" to call to find /var/spool/monitas
+- improved backup_client(), compare_client(), restore_client()
+- pipe logs to logfile, not stdout
+
+06/11
+- moved register_pid(), set_signals(), termination_in_progress() to common.c
+- commented code a bit
+- improved backup_client(), compare_client(), restore_client()
+
+06/10
+- improved backup_client()
+- discover whether mondoarchive returned error (ask client)
+  and act accordingly (i.e. drop archive)
+
+06/09
+- added /var/spool/monitas/input.dev FIFO to
+  let external programs instruct me to backup
+  or restore a given computer
+- added signal trapping
+
+06/07
+- rename transmit_file... and move
+  to common.c, as transmit_file_to_socket()
+- rename receive_file... and move to
+  common.c, as receive_file_from_socket()
+
+05/27
+- save bkps to /var/spool/monitas/123.456.789.012/[time]
+
+05/23
+- added elementary saving/storing of incoming data
+  from client backing itself up
+
+05/21
+- added backup_client, compare_client, restore_client
+  templates for triggers
  
 05/11
@@ -37 +70 @@
 
 
+/*-----------------------------------------------------------*/
+
+
+
 #include "structs.h"
-
-#define LOG_THESE_AND_HIGHER debug   /* debug, info, warn, error, fatal */
+//#define LOG_THESE_AND_HIGHER debug
+
+
+
 #define NOOF_THREADS 10
-
+#define LOGFILE "/var/log/monitas-server.log"
+#define log_it(x,y) { log_it_SUB(g_logfile,x,y); }
+
+
+/* externs */
+
+extern bool does_file_exist(char*);
+extern char *call_program_and_get_last_line_of_output(char*);
+extern int call_program_and_log_output(char*);
+extern int create_and_watch_fifo_for_commands(char*);
+extern bool does_file_exist(char*);
+extern void log_it_SUB(char*, t_loglevel, char *);
+extern int make_hole_for_file (char *);
+extern int read_block_from_fd(int socket_fd, char*buf, int len_to_read);
+extern int receive_file_from_socket(FILE*, int);
+extern void register_pid(pid_t, char*);
+extern void set_signals(bool);
+extern void termination_in_progress(int);
+extern char *tmsg_to_string(t_msg);
+extern int transmit_file_to_socket(FILE*,int);
 
 
@@ -48 +106 @@
 
 struct s_clientlist g_clientlist; /* FIXME - lock during login/logout, using mutexes */
-
+char g_command_fifo[MAX_STR_LEN+1]; // Device which server will monitor for incoming commands
+pthread_t g_threadinfo[NOOF_THREADS]; // One thread per port, to watch for requests from clients
+char g_logfile[MAX_STR_LEN+1] = "/var/log/monitas-server.log";
+char g_server_status_file[MAX_STR_LEN+1];
 
 
@@ -54 +115 @@
 /* prototypes */
 
-int backup_client(int,char*);
+int backup_client(char*, int, char*);
+int compare_client(char*, int, char*);
 int find_client_in_clientlist(char *);
+int forcibly_logout_all_clients(void);
+int forcibly_logout_client(int);
+void* generate_server_status_file_regularly(void*);
 int handle_incoming_message(int, struct sockaddr_in *, struct s_client2server_msg_record *);
 int handle_login_request(int, struct s_client2server_msg_record *, char *);
 int handle_logout_request(int, struct s_client2server_msg_record *, char *);
 int handle_ping_request(int, struct s_client2server_msg_record *, char *);
-void log_it(t_loglevel, char *);
-int restore_client(int,char*);
-int send_msg_to_client(struct s_server2client_msg_record *, char *, int);
+int handle_progress_rpt(int, struct s_client2server_msg_record *, char *);
+int handle_user_request(int, struct s_client2server_msg_record *, char *);
+int process_incoming_command(char*);
+int read_block_from_fd(int, char*, int);
+int restore_client(char*, int, char*, char*);
+int send_msg_to_client(struct s_server2client_msg_record *, char *, int, int*);
 void start_threads_to_watch_ports_for_requests(void);
-void interact_with_sysadm(void);
+void terminate_daemon(int);
 char *tmsg_to_string(t_msg);
 void* watch_port_for_requests_from_clients(void*);
@@ -70 +138 @@
 
 
-/* subroutines */
-
-int backup_client(int clientno, char*path)
+/*-----------------------------------------------------------*/
+
+
+
+int backup_client(char*ipaddr, int port, char*clientpath)
 /*
 Purpose:Backup the path of a specific client. Receive
-    the archives. Store them locally (on me, the server).
+the archives. Store them locally (on me, the server).
 Params: clientno - client# in g_clientlist[]
-    path - client's path to be backed up
+        clientpath - client's path to be backed up
 Return: result (0=success, nonzero=failure)
 */
 {
   struct s_server2client_msg_record rec_to_client;
-  int i, res=0;
-  char tmp[MAX_STR_LEN];
-
-  sprintf(tmp, "Client# = %d", clientno);
+  int res=0, socket_fd, noof_archives, i, len;
+  char tmp[MAX_STR_LEN+1], outfile[MAX_STR_LEN+1];
+  FILE*fout;
+
+  sprintf(tmp, "%s - backup of %s commencing", ipaddr, clientpath);
+  log_it(info, tmp);
+  sprintf(outfile, "/var/spool/monitas/%s/%s.dat", ipaddr, call_program_and_get_last_line_of_output("date +%s"));
+  if (does_file_exist(outfile)) { log_it(error, "Backup storage location exists already. That should be impossible."); return(1); }
+  if (make_hole_for_file(outfile))
+    { res++; log_it(error, "Cannot write archive to spool dir"); }
+  else if (!(fout=fopen(outfile, "w")))
+    { res++; log_it(fatal, "Failed to openout temp data file"); }
+  else
+    {
+      sprintf(tmp, "Backing up %s - archive=%s", ipaddr, outfile);
+      log_it(debug, tmp);
+      rec_to_client.msg_type = trigger_backup;
+      strncpy(rec_to_client.body, clientpath, sizeof(rec_to_client.body));
+      if (send_msg_to_client(&rec_to_client, ipaddr, port, &socket_fd))
+        { log_it(error, "backup_client - failed to send msg to client"); return(1); }
+      res += receive_file_from_socket(fout, socket_fd);
+      len=read(socket_fd, (char*)&i, sizeof(i));
+      if (!len) { res++; log_it(error, "Client hasn't told me the result of its call to mondoarchive"); }
+      else if (len!=sizeof(i)) { res++; log_it(error, "Client didn't sent _entire_ result of its call to mondoarchive"); }
+      else if (i) { res++; log_it(error, "Client said, mondoarchive returned an error."); }
+      else { log_it(debug, "Client said, mondoarchive returned OK"); }
+      fclose(fout);
+      close(socket_fd);
+    }
+/* Shuffle older backups off the mortal coil. Leave maximum of 4 backup files in /var/spool/monitas/[ipaddr] */
+  sprintf(tmp, "find /var/spool/monitas/%s -type f 2> /dev/null | grep -n \"\" | tail -n1 | cut -d':' -f1", ipaddr);
+  noof_archives = atoi(call_program_and_get_last_line_of_output(tmp));
+  i = noof_archives - 3;
+  if (i>0)
+    {
+      sprintf(tmp, "rm -f `find /var/spool/monitas/%s -type f | sort | head -n%d`", ipaddr, i);
+      call_program_and_log_output(tmp);
+    }
+/* Return success/failure value */
+  if (res>0)
+    {
+      sprintf(tmp, "%s - error(s) occurred while backing up %s", ipaddr, clientpath);
+      log_it(error, tmp);
+      rec_to_client.msg_type = backup_fail;
+      sprintf(rec_to_client.body, "Failed to backup %s", clientpath);
+      log_it(debug, rec_to_client.body);
+      unlink(outfile);
+    }
+  else
+    {
+      sprintf(tmp, "%s - backed up %s ok", ipaddr, clientpath);
+      log_it(info, tmp);
+      rec_to_client.msg_type = backup_ok;
+      sprintf(rec_to_client.body, "%s - backed up ok", clientpath);
+      log_it(debug, rec_to_client.body);
+    }
+  if (send_msg_to_client(&rec_to_client, ipaddr, port, &socket_fd))
+    {
+      res++;
+      sprintf(tmp, "Unable to notify %s of backup success/failure", ipaddr);
+      log_it(error, tmp);
+      i = find_client_in_clientlist(ipaddr);
+      if (i>=0) { forcibly_logout_client(i); }
+      log_it(info, "I'm assuming the backup was bad because the client cannot be reached.");
+      unlink(outfile);
+    }
+  return(res);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+int compare_client(char*ipaddr, int port, char*clientpath)
+/*
+Purpose:Compare the path of a specific client. Transmit
+the archives from my (the server's) local storage loc.
+Params: clientno - client# in g_clientlist[]
+        clientpath - client's path to be compared
+Return: result (0=success, nonzero=failure)
+*/
+{
+  struct s_server2client_msg_record rec_to_client;
+  int res=0, socket_fd, len, i;
+  char tmp[MAX_STR_LEN+1], infile[MAX_STR_LEN+1];
+  FILE*fin;
+
+  sprintf(tmp, "%s - comparison of %s commencing", ipaddr, clientpath);
+  log_it(info, tmp);
+// FIXME - don't assume the latest backup contains the files we want ;)
+  sprintf(tmp, "find /var/spool/monitas/%s -type f | sort | tail -n1", ipaddr);
+  strcpy(infile, call_program_and_get_last_line_of_output(tmp));
+  sprintf(tmp, "Comparing to data file '%s'", infile);
   log_it(debug, tmp);
-  if (clientno >= g_clientlist.items)
-    { log_it(fatal, "backup_client: clientno>=g_clientlist.items"); }
-  sprintf(tmp, "Backing up %s - path=%s", g_clientlist.el[clientno].ipaddr, path);
-  log_it(info, tmp);
-  rec_to_client.msg_type = trigger_backup;
-  strncpy(rec_to_client.body, path, sizeof(rec_to_client.body));
-  if (send_msg_to_client(&rec_to_client, g_clientlist.el[clientno].ipaddr, g_clientlist.el[clientno].port))
-    { log_it(error, "backup_client - failed to send msg to client"); return(1); }
-
-  if (res)
-    {
-      sprintf(tmp, "Error(s) occurred while backing up %s", g_clientlist.el[clientno].ipaddr);
-      log_it(error, tmp);
-      return(1);
+  if (!does_file_exist(infile)) { log_it(error, "Backup not found. That should be impossible."); return(1); }
+  sprintf(tmp, "Comparing %s - archive=%s", ipaddr, infile);
+  log_it(debug, tmp);
+  rec_to_client.msg_type = trigger_compare;
+  strncpy(rec_to_client.body, clientpath, sizeof(rec_to_client.body));
+  if (send_msg_to_client(&rec_to_client, ipaddr, port, &socket_fd))
+    { log_it(error, "compare_client - failed to send msg to client"); return(1); }
+  if (!(fin=fopen(infile, "r")))
+    { log_it(fatal, "Failed to openin temp data file"); }
+  res += transmit_file_to_socket(fin, socket_fd);
+  len=read(socket_fd, (char*)&i, sizeof(i));
+  if (!len) { res++; log_it(error, "Client hasn't told me the result of its call to mondoarchive"); }
+  else if (len!=sizeof(i)) { res++; log_it(error, "Client didn't sent _entire_ result of its call to mondoarchive"); }
+  else if (i) { res++; log_it(error, "Client said, mondoarchive returned an error."); }
+  else { log_it(debug, "Client said, mondoarchive returned OK"); }
+  fclose(fin);
+  close(socket_fd);
+  if (res>0)
+    {
+      sprintf(tmp, "%s - error(s) occurred while comparing %s", ipaddr, clientpath);
+      log_it(error, tmp);
+      rec_to_client.msg_type = compare_fail;
+      sprintf(rec_to_client.body, "Failed to compare %s", clientpath);
+      log_it(debug, rec_to_client.body);
     }
   else
     {
-      sprintf(tmp, "Backed up %s OK", g_clientlist.el[clientno].ipaddr);
-      log_it(error, tmp);
-      return(0);
-    }
-}
+      sprintf(tmp, "%s - compared %s ok", ipaddr, clientpath);
+      log_it(info, tmp);
+      rec_to_client.msg_type = compare_ok;
+      sprintf(rec_to_client.body, "%s - compared ok", clientpath);
+      log_it(debug, rec_to_client.body);
+    }
+  if (send_msg_to_client(&rec_to_client, ipaddr, port, &socket_fd))
+    {
+      sprintf(tmp, "Unable to notify %s of compare success/failure", ipaddr);
+      log_it(error, tmp);
+      i = find_client_in_clientlist(ipaddr);
+      if (i>=0) { forcibly_logout_client(i); }
+    }
+  return(res);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
 
 
@@ -121 +307 @@
 {
   int i;
-  char tmp[MAX_STR_LEN];
+  char tmp[MAX_STR_LEN+1];
 
   for(i = 0; i < g_clientlist.items; i++)
@@ -132 +318 @@
   return(-1);
 }
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+int forcibly_logout_all_clients()
+/*
+Purpose: Tell all clients to disconnect, right now.
+Params:  None
+Returns: 0=success
+*/
+{
+// FIXME - lock g_clientlist for duration of this function
+  while(g_clientlist.items>0)
+    {
+      forcibly_logout_client(0);
+    }
+  return(0);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+int forcibly_logout_client(int clientno)
+/*
+Purpose: Logout specific client(#) by force.
+Params:  Client# in g_clientlist[] array.
+Returns: 0=success, nonzero=failure to get other end to hear me;)
+NB:      The client was definitely removed from our login table.
+         If the client got the message, return 0; else, nonzero.
+*/
+{
+  struct s_server2client_msg_record rec_to_client;
+  char tmp[MAX_STR_LEN+1];
+  int res=0;
+
+  sprintf(tmp, "Forcibly logging %s out", g_clientlist.el[clientno].ipaddr);
+  log_it(info, tmp);
+  rec_to_client.msg_type = logout_ok; /* to confirm logout */
+  strcpy(rec_to_client.body, "Server is shutting down. You are forced to logout");
+  res=send_msg_to_client(&rec_to_client, g_clientlist.el[clientno].ipaddr, g_clientlist.el[clientno].port, NULL);
+  if (--g_clientlist.items > 0)
+    {
+      sprintf(tmp, "Moving clientlist[%d] to clientlist[%d]", clientno, g_clientlist.items);
+      log_it(debug, tmp);
+      sprintf(tmp, "Was ipaddr=%s; now is ipaddr=", g_clientlist.el[clientno].ipaddr);
+      memcpy((void*)&g_clientlist.el[clientno], (void*)&g_clientlist.el[g_clientlist.items], sizeof(struct s_registered_client_record));
+      strcat(tmp, g_clientlist.el[clientno].ipaddr);
+      log_it(debug, tmp);
+    }
+  return(res);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+void* generate_server_status_file_regularly(void*inp)
+{
+  int i;
+  FILE*fout;
+
+  strncpy(g_server_status_file, (char*)inp, MAX_STR_LEN);
+  for(;;)
+    {
+      if ((fout = fopen(g_server_status_file, "w")))
+        {
+// FIXME - lock g_clientlist
+          for(i=0; i<g_clientlist.items; i++)
+            {
+              fprintf(fout, "%s [%s] : %s\n", g_clientlist.el[i].ipaddr, g_clientlist.el[i].hostname_pretty, g_clientlist.el[i].last_progress_rpt);
+            }
+          fclose(fout);
+        }
+      sleep(1);
+    }
+  exit(0);
+}
+
+
+
+/*-----------------------------------------------------------*/
 
 
@@ -145 +419 @@
 */
 {
-  char clientIP[MAX_STR_LEN], *ptr, tmp[MAX_STR_LEN];
+  char clientIP[MAX_STR_LEN+1], tmp[MAX_STR_LEN+1];
+  unsigned char *ptr;
   int res=0;
 
@@ -152 +427 @@
   sprintf(clientIP, "%d.%d.%d.%d", ptr[0], ptr[1], ptr[2], ptr[3]);
   sprintf(tmp, "clientIP = %s", clientIP);
+  log_it(debug, tmp);
+  sprintf(tmp, "%s message from %s [%s] (port %d)", tmsg_to_string(rec->msg_type), clientIP, rec->body, rec->port);
   log_it(debug, tmp);
   switch(rec->msg_type)
@@ -161 +438 @@
       res=handle_ping_request(skt, rec, clientIP);
       break;
+    case progress_rpt:
+      res=handle_progress_rpt(skt, rec, clientIP);
+      break;
     case logout:
       res=handle_logout_request(skt, rec, clientIP);
       break;
+    case user_req:
+      res=handle_user_request(skt, rec, clientIP);
+      break;
     default:
-      sprintf(tmp, "%s request from %s [%s] (port %d) - how do I handle it?", tmsg_to_string(rec->msg_type), clientIP, rec->body, rec->port);
-      log_it(error, tmp);
+      log_it(error, "...How do I handle it?");
     }
   return(res);
 }
+
+
+
+/*-----------------------------------------------------------*/
 
 
@@ -185 +471 @@
   struct s_server2client_msg_record rec_to_client;
   int clientno;
-  char tmp[MAX_STR_LEN];
-
-  sprintf(tmp, "Login request from %s [%s] (port %d)", clientIP, rec_from_client->body, rec_from_client->port);
-  log_it(info, tmp);
+  char tmp[MAX_STR_LEN+1];
+
+//FIXME - lock g_clientlist[]
   clientno = find_client_in_clientlist(clientIP);
   if (clientno>=0)
     {
-      rec_to_client.msg_type = fail;
+      rec_to_client.msg_type = login_fail;
       sprintf(rec_to_client.body, "Sorry, you're already logged in!");
       sprintf(tmp, "Ignoring login rq from %s: he's already logged in.", clientIP);
@@ -210 +495 @@
       strncpy(g_clientlist.el[clientno].ipaddr, clientIP, sizeof(g_clientlist.el[clientno].ipaddr));
       g_clientlist.el[clientno].port = rec_from_client->port;
+      g_clientlist.el[clientno].busy = false;
       g_clientlist.items ++;
       sprintf(tmp, "Login request from %s ACCEPTED", clientIP);
       log_it(info, tmp);
-    }
-  send_msg_to_client(&rec_to_client, clientIP, rec_from_client->port);
+      strcpy(g_clientlist.el[clientno].last_progress_rpt, "Logged in");
+    }
+  send_msg_to_client(&rec_to_client, clientIP, rec_from_client->port, NULL);
   return(0);
 }
+
+
+
+/*-----------------------------------------------------------*/
 
 
@@ -225 +516 @@
     from client.
 Params: skt - client's port to talk to
-    rec_from_client - login rq record received from client
+    rec_from_client - logout rq record received from client
     clientIP - client's IP address, in string
 Return: result (0=success, nonzero=failure)
@@ -232 +523 @@
   struct s_server2client_msg_record rec_to_client;
   int i, res=0;
-  char tmp[MAX_STR_LEN];
-
-  sprintf(tmp, "Logout request from %s [%s] (port %d)", clientIP, rec_from_client->body, rec_from_client->port);
-  log_it(info, tmp);
+  char tmp[MAX_STR_LEN+1];
+
   i = find_client_in_clientlist(clientIP);
   if (i<0)
@@ -241 +530 @@
       sprintf(rec_to_client.body, "Client is not logged in yet. How can I log him out?");
       log_it(error, rec_to_client.body);
-      rec_to_client.msg_type = fail;
+      rec_to_client.msg_type = logout_fail;
+      res=1;
+    }
+  else if (g_clientlist.el[i].busy)
+    {
+      sprintf(rec_to_client.body, "Client is working. I shouldn't log him out.");
+      log_it(error, rec_to_client.body);
+      rec_to_client.msg_type = logout_fail;
       res=1;
     }
@@ -257 +553 @@
       log_it(info, tmp);
     }
-  send_msg_to_client(&rec_to_client, clientIP, rec_from_client->port);
+  send_msg_to_client(&rec_to_client, clientIP, rec_from_client->port, NULL);
   return(res);
 }
+
+
+
+/*-----------------------------------------------------------*/
 
 
@@ -268 +568 @@
     from client.
 Params: skt - client's port to talk to
-    rec_from_client - login rq record received from client
+    rec_from_client - ping record received from client
     clientIP - client's IP address, in string
 Return: result (0=success, nonzero=failure)
@@ -275 +575 @@
   struct s_server2client_msg_record rec_to_client;
   int i;
-  char tmp[MAX_STR_LEN];
-
-  sprintf(tmp, "ping request from port %d --- %s", rec_from_client->port, rec_from_client->body);
-  log_it(info, tmp);
+  char tmp[MAX_STR_LEN+1];
+
   i = find_client_in_clientlist(clientIP);
   if (i < 0)
@@ -289 +587 @@
       rec_to_client.msg_type = pong; /* reply to ping */
       sprintf(rec_to_client.body, "Hey, I'm replying to client#%d's ping. Pong! (re: %s", i, rec_from_client->body);
-      send_msg_to_client(&rec_to_client, clientIP, rec_from_client->port);
+      send_msg_to_client(&rec_to_client, clientIP, rec_from_client->port, NULL);
       log_it(debug, rec_to_client.body);
     }
@@ -297 +595 @@
 
 
-void interact_with_sysadm()
-/*
-Purpose:Tell sysadm about users logged in, etc. in
-    response to keypresses (1=users, ENTER=exit)
-Params: none
-Return: none
-NB: Called by main()
-*/
-{
-  char tmp[MAX_STR_LEN];
-  int i;
-  bool done;
-
-  for(done=false; !done; )
-    {
-      printf("Type 1 to list clients\n");
-      printf("Type 2 to backup a client\n");
-      printf("Type 3 to restore a client\n");
-      printf("Type ENTER to quit.\n");
-      fgets(tmp, sizeof(tmp), stdin);
-      if (!strcmp(tmp, "1\n"))
-    {
-      printf("g_clientlist.items is %d\n", g_clientlist.items);
-      printf("List of %d clients:-\n", g_clientlist.items);
-      printf("\tClient# Port#  IP address       Client name\n");
-      for(i=0; i<g_clientlist.items; i++)
-        {
-          printf("\t%d\t%4d   %-16s %-20s \n", i, g_clientlist.el[i].port, g_clientlist.el[i].ipaddr, g_clientlist.el[i].hostname_pretty);
-        }
-          printf("<End of list>\n\n");
-        }
-      else if (!strcmp(tmp, "2\n"))
-        {
-      if (g_clientlist.items!=1) { printf("Forget it\n"); }
-      else
-        {
-          backup_client(0, "/usr/local");
-        }
-    }
-      else if (!strcmp(tmp, "3\n"))
-        {
-      if (g_clientlist.items!=1) { printf("Forget it\n"); }
-      else
-        {
-          restore_client(0, "/usr/local");
-        }
-    }
-      else if (!strcmp(tmp, "\n"))
-        {
-          if (g_clientlist.items > 0)
+/*-----------------------------------------------------------*/
+
+
+
+int handle_progress_rpt(int skt, struct s_client2server_msg_record *rec_from_client, char *clientIP)
+/*
+Purpose:Handle a progress_rpt which has just been received
+    from client.
+Params: skt - client's port to talk to
+    rec_from_client - user record received from client
+    clientIP - client's IP address, in string
+Return: result (0=success, nonzero=failure)
+*/
+{
+//  struct s_server2client_msg_record rec_to_client;
+  int i, res=0;
+  char tmp[MAX_STR_LEN+1];
+
+  i = find_client_in_clientlist(clientIP);
+  if (i < 0)
+    {
+      sprintf(tmp, "Hey, %s isn't logged in. I'm not going to deal with his progress_rpt.", clientIP);
+      log_it(error, tmp);
+      res++;
+    }
+  else
+    {
+      strcpy(g_clientlist.el[i].last_progress_rpt, rec_from_client->body);
+    }
+  return(res);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+int handle_user_request(int skt, struct s_client2server_msg_record *rec_from_client, char *clientIP)
+/*
+Purpose:Handle a user request which has just been received
+    from client.
+Params: skt - client's port to talk to
+    rec_from_client - user record received from client
+    clientIP - client's IP address, in string
+Return: result (0=success, nonzero=failure)
+*/
+{
+//  struct s_server2client_msg_record rec_to_client;
+  int i, res=0;
+  char tmp[MAX_STR_LEN+1], command[MAX_STR_LEN+1], first_half[MAX_STR_LEN+1], second_half[MAX_STR_LEN+1], *p;
+
+  i = find_client_in_clientlist(clientIP);
+  if (i < 0)
+    {
+      sprintf(tmp, "Hey, %s isn't logged in. I'm not going to deal with his request.", clientIP);
+      log_it(error, tmp);
+      res++;
+    }
+  else
+    {
+      strcpy(first_half, rec_from_client->body);
+      p = strchr(first_half, ' ');
+      if (!p) { second_half[0]='\0'; } else { strcpy(second_half, p); *p='\0'; }
+      sprintf(command, "echo \"%s %s%s\" > %s", first_half, clientIP, second_half, SERVER_COMDEV);
+      log_it(debug, command);
+      i = system(command);
+      if (i) { res++; log_it(error, "Failed to echo command to FIFO"); }
+    }
+  return(res);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+int process_incoming_command(char*incoming)
+/*
+Purpose:Process incoming command, presumably
+        read from FIFO and sent there by sysadm/user.
+Params: incoming - raw command string itself
+Return: result (0=success; nonzero=failure)
+*/
+{
+int res=0, port;
+int clientno;
+char tmp[MAX_STR_LEN+1];
+int pos;
+char command[MAX_STR_LEN+1], ipaddr[MAX_STR_LEN+1],
+    path[MAX_STR_LEN+1], aux[MAX_STR_LEN+1];
+
+//  sprintf(tmp, "incoming = '%s'", incoming);
+//  log_it(debug, tmp);
+          pos=0;
+          sscanf(incoming, "%s %s %s", command, ipaddr, path);
+          if (!strcmp(command, "restore"))
+            { sscanf(incoming, "%s %s %s %s", command, ipaddr, path, aux); }
+          else
+            { aux[0] = '\0'; }
+
+//          for(i=0; i<strlen(command); i++) { command[i]=command[i]|0x60; }
+          sprintf(tmp, "cmd=%s ipaddr=%s path=%s", command, ipaddr, path);
+          log_it(debug, tmp);
+          sprintf(tmp, "%s of %s on %s <-- command received", command, path, ipaddr);
+          log_it(info, tmp);
+          if ((clientno = find_client_in_clientlist(ipaddr)) < 0)
             {
-              printf("There are %d users logged in. Are you sure you want to quit? ", g_clientlist.items);
-              fgets(tmp, sizeof(tmp), stdin);
-              if (tmp[0]=='Y' || tmp[0]=='y')
-                { done=true; }
+              sprintf(tmp, "%s not found in clientlist; so, %s failed.", ipaddr, command);
+              log_it(error, tmp);
+            }
+          else if (g_clientlist.el[clientno].busy == true)
+            {
+              sprintf(tmp, "%s is busy; so, %s failed.", ipaddr, command);
+              log_it(error, tmp);
             }
           else
-            { done=true; }
-          if (done)
-            { log_it(info, "OK, you've chosen to shutdown server."); }
-          else
-            { log_it(info, "Shutdown canceled."); }
-        }
-    }
-}
-
-
-
-void log_it(t_loglevel level, char *sz_message)
-{
-  char sz_outstr[MAX_STR_LEN], sz_level[MAX_STR_LEN], sz_time[MAX_STR_LEN];
-  time_t time_rec;
-
-  time(&time_rec);
-  switch(level)
-    {
-      case debug: strcpy(sz_level, "DEBUG"); break;
-      case info:  strcpy(sz_level, "INFO "); break;
-      case warn:  strcpy(sz_level, "WARN "); break;
-      case error: strcpy(sz_level, "ERROR"); break;
-      case fatal: strcpy(sz_level, "FATAL"); break;
-      default:    strcpy(sz_level, "UNKWN"); break;
-    }
-  sprintf(sz_time, ctime(&time_rec));
-  sz_time[strlen(sz_time)-6] = '\0';
-  sprintf(sz_outstr, "%s %s: %s", sz_time+11, sz_level, sz_message);
-  if ((int)level >= LOG_THESE_AND_HIGHER)
-    {
-      fprintf(stderr, "%s\n",sz_outstr);
-    }
-  if (level==fatal) { fprintf(stderr,"Aborting now."); exit(1); }
-}
-
-
-
-
-int restore_client(int clientno, char*path)
-{
-}
-
-
-int send_msg_to_client(struct s_server2client_msg_record *rec, char *clientIP, int port)
+            {
+              g_clientlist.el[clientno].busy = true;
+              port = g_clientlist.el[clientno].port;
+              if (!strcmp(command, "backup"))
+                { res = backup_client(ipaddr, port, path); }
+              else if (!strcmp(command, "compare"))
+                { res = compare_client(ipaddr, port, path); }
+              else if (!strcmp(command, "restore"))
+                { res = restore_client(ipaddr, port, path, aux); }
+              else
+                {
+                  sprintf(tmp, "%s - cannot '%s'. Command unknown.", ipaddr, command);
+                  log_it(error, tmp);
+                  res=1;
+                }
+              g_clientlist.el[clientno].busy = false;
+            }
+  return(res);
+}
+
+
+
+/*-----------------------------------------------------------*/
+
+
+
+int restore_client(char*ipaddr, int port, char*clientpath, char*auxpath)
+/*
+Purpose:Restore the path of a specific client. Transmit
+the archives from my (the server's) local storage loc.
+Params: clientno - client# in g_clientlist[]
+        clientpath - client's path to be restored
+Return: result (0=success, nonzero=failure)
+*/
+{
+  struct s_server2client_msg_record rec_to_client;
+  int res=0, socket_fd, len, i;
+  char tmp[MAX_STR_LEN+1], infile[MAX_STR_LEN+1];
+  FILE*fin;
+
+  sprintf(tmp, "%s - restoration of %s commencing", ipaddr, clientpath);
+  log_it(info, tmp);
+// FIXME - don't assume the latest backup contains the files we want ;)
+  sprintf(tmp, "find /var/spool/monitas/%s -type f | sort | tail -n1", ipaddr);
+  strcpy(infile, call_program_and_get_last_line_of_output(tmp));
+  sprintf(tmp, "Restoring from data file '%s'", infile);
+  log_it(debug, tmp);
+  if (!does_file_exist(infile)) { log_it(error, "Backup not found. That should be impossible."); return(1); }
+  sprintf(tmp, "Restoring %s - archive=%s", ipaddr, infile);
+  log_it(debug, tmp);
+  rec_to_client.msg_type = trigger_restore;
+  strncpy(rec_to_client.body, clientpath, sizeof(rec_to_client.body));
+  strncpy(rec_to_client.bodyAux, auxpath, sizeof(rec_to_client.bodyAux));
+  if (send_msg_to_client(&rec_to_client, ipaddr, port, &socket_fd))
+    { log_it(error, "restore_client - failed to send msg to client"); return(1); }
+  if (!(fin=fopen(infile, "r")))
+    { log_it(fatal, "Failed to openin temp data file"); }
+  res += transmit_file_to_socket(fin, socket_fd);
+
+  len=read(socket_fd, (char*)&i, sizeof(i));
+  if (!len) { res++; log_it(error, "Client hasn't told me the result of its call to mondorestore"); }
+  else if (len!=sizeof(i)) { res++; log_it(error, "Client didn't sent _entire_ result of its call to mondorestore"); }
+  else if (i) { res++; log_it(error, "Client said, mondorestore returned an error."); }
+  else { log_it(debug, "Client said, mondorestore returned OK"); }
+
+  fclose(fin);
+  close(socket_fd);
+  if (res>0)
+    {
+      sprintf(tmp, "%s - error(s) occurred while restoring %s", ipaddr, clientpath);
+      log_it(error, tmp);
+      rec_to_client.msg_type = restore_fail;
+      sprintf(rec_to_client.body, "Failed to restore %s", clientpath);
+      log_it(debug, rec_to_client.body);
+    }
+  else
+    {
+      sprintf(tmp, "%s - restored %s ok", ipaddr, clientpath);
+      log_it(info, tmp);
+      rec_to_client.msg_type = restore_ok;
+      sprintf(rec_to_client.body, "%s - restored ok", clientpath);
+      log_it(debug, rec_to_client.body);
+    }
+  if (send_msg_to_client(&rec_to_client, ipaddr, port, &socket_fd))
+    {
+      sprintf(tmp, "Unable to notify %s of restore success/failure", ipaddr);
+      log_it(error, tmp);
+      i = find_client_in_clientlist(ipaddr);
+      if (i>=0) { forcibly_logout_client(i); }
+    }
+  return(res);
+}
+
+
+/*-----------------------------------------------------------*/
+
+
+
+int send_msg_to_client(struct s_server2client_msg_record *rec, char *clientIP, int port, int *psocket)
 /*
 Purpose:Send a message from server to client.
-    A 'message' could be a response to a login/logout/ping
-    request or perhaps a 'trigger'. (A trigger is a message
-    from server to client intended to initiate a backup
-    or similar activity.)
+A 'message' could be a response to a login/logout/ping
+request or perhaps a 'trigger'. (A trigger is a message
+from server to client intended to initiate a backup
+or similar activity.)
 Params: rec - record containing the data to be sent to client
-    clientIP - the xxx.yyy.zzz.aaa IP address of client
-    port - the client's port to send data to
-Return: result (0=success, nonzero=failure)
-*/
-{
-  struct hostent *hp;
-  struct sockaddr_in sin;
-  int  s;
-  char tmp[MAX_STR_LEN];
-
-  if ((hp = gethostbyname(clientIP)) == NULL)
-    {
-      sprintf(tmp, "send_msg_to_client: %s: unknown host\n", clientIP);
-      log_it(error, tmp);
-      return(1);
-    }
-  memset((void*)&sin, 0, sizeof(sin));
-  memcpy((void*)&sin.sin_addr, hp->h_addr, hp->h_length);
-  sin.sin_family = AF_INET;
-  sin.sin_addr.s_addr = INADDR_ANY;
-  sin.sin_port = htons(port);
-  if ((s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
-    { perror("socket"); log_it(error, "send_msg_to_client: SOCKET error"); return(1); }
-  if (connect(s, (struct sockaddr*)&sin, sizeof(struct sockaddr_in)) < 0)
-    { sprintf(tmp, "Failed to connect to client %s on port %d", clientIP, port); log_it(error, tmp); return(1); }
-  send(s, (char*)rec, sizeof(struct s_server2client_msg_record), 0);
-  close(s);
-  sprintf(tmp, "Sent %s msg to %s (port %d)", tmsg_to_string(rec->msg_type), clientIP, port);
-  log_it(debug, tmp);
-  return(0);
-}
+clientIP - the xxx.yyy.zzz.aaa IP address of client
+port - the client's port to send data to
+psocket - returns the socket's file descriptor, left
+open by me; or, if psocket==NULL, then socket is closed
+by me before I return.
+Return: result (0=success, nonzero=failure)
+*/
+{
+struct hostent *hp;
+struct sockaddr_in sin;
+int  s;
+char tmp[MAX_STR_LEN+1];
+if ((hp = gethostbyname(clientIP)) == NULL)
+{
+sprintf(tmp, "send_msg_to_client: %s: unknown host", clientIP);
+log_it(error, tmp);
+return(1);
+}
+memset((void*)&sin, 0, sizeof(sin));
+memcpy((void*)&sin.sin_addr, hp->h_addr, hp->h_length);
+sin.sin_family = AF_INET;
+sin.sin_addr.s_addr = INADDR_ANY;
+sin.sin_port = htons(port);
+if ((s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
+{ perror("socket"); log_it(error, "send_msg_to_client: SOCKET error"); return(1); }
+if (connect(s, (struct sockaddr*)&sin, sizeof(struct sockaddr_in)) < 0)
+{ sprintf(tmp, "Failed to connect to client %s on port %d", clientIP, port); log_it(error, tmp); return(1); }
+send(s, (char*)rec, sizeof(struct s_server2client_msg_record), 0);
+if (psocket) { *psocket=s; } else { close(s); }
+sprintf(tmp, "Sent %s msg [%s] to %s (port %d)", tmsg_to_string(rec->msg_type), rec->body, clientIP, port);
+log_it(debug, tmp);
+return(0);
+}
+
+
+
+/*-----------------------------------------------------------*/
 
 
@@ -450 +869 @@
 {
   int i, port, res;
-  pthread_t threadinfo[NOOF_THREADS];
-  char tmp[MAX_STR_LEN];
+  char tmp[MAX_STR_LEN+1];
 
   g_clientlist.items = 0;
@@ -458 +876 @@
       port = 8700+i;
       sprintf(tmp,"%d", port);
-      res = pthread_create(&(threadinfo[i]), NULL, watch_port_for_requests_from_clients, (void*)tmp);
+      res = pthread_create(&(g_threadinfo[i]), NULL, watch_port_for_requests_from_clients, (void*)tmp);
       if (res != 0)
         {
-        perror("Thread creation failed");
+      perror("Thread creation failed");
         }
-      usleep(80000);
-    }
-  sprintf(tmp, "Threads are now running.");
+      usleep(50000);
+    }
+  sprintf(tmp, "Now monitoring ports %d thru %d for requests from clients.", 8700, 8700+NOOF_THREADS-1);
   log_it(info, tmp);
 }
@@ -471 +889 @@
 
 
-char *tmsg_to_string(t_msg msg_type)
-/*
-Purpose:Return a string/name of the msg of type msg_type
-Params: msg_type - type of message (enum typedef)
-Return: pointer to static string {name of msg)
-*/
-{
-  static char sz_msg[MAX_STR_LEN];
-  switch(msg_type)
-    {
-      case unused : strcpy(sz_msg, "unused"); break;
-      case login  : strcpy(sz_msg, "login"); break;
-      case logout : strcpy(sz_msg, "logout"); break;
-      case login_ok:strcpy(sz_msg, "login_ok"); break;
-      case logout_ok:strcpy(sz_msg, "logout_ok"); break;
-      case ping   : strcpy(sz_msg, "ping"); break;
-      case pong   : strcpy(sz_msg, "pong"); break;
-      case fail   : strcpy(sz_msg, "fail"); break;
-      case trigger_backup: strcpy(sz_msg, "trigger_backup"); break;
-      case trigger_restore: strcpy(sz_msg, "trigger_restore"); break;
-      case begin_stream: strcpy(sz_msg, "begin_stream"); break;
-      case end_stream: strcpy(sz_msg, "end_stream"); break;
-      default: strcpy(sz_msg, "(Fix tmsg_to_string please)"); break;
-    }
-  return(sz_msg);
-}
+/*-----------------------------------------------------------*/
+
+
+
+void terminate_daemon(int sig)
+/*
+Purpose: Shut down the server in response to interrupt.
+Params:  Signal received.
+Returns: None
+*/
+{
+  char command[MAX_STR_LEN+1];
+  static bool logged_out_everyone=false;
+
+  set_signals(false); // termination in progress
+  log_it(info, "Abort signal caught by interrupt handler");
+  if (!logged_out_everyone)
+    {
+// FIXME - lock the var w/mutex
+      logged_out_everyone=true;
+      forcibly_logout_all_clients();
+    }
+/*
+  for(i=0; i<NOOF_THREADS; i--)
+    {
+      sprintf(tmp, "Terminating thread #%d", i);
+      log_it(debug, tmp);
+      pthread_join(g_threadinfo[i], NULL);
+    }
+*/
+  forcibly_logout_all_clients();
+  sprintf(command, "rm -f %s", g_command_fifo);
+  call_program_and_log_output(command);
+//  chmod(g_command_fifo, 0);
+  unlink(g_command_fifo);
+  unlink(g_server_status_file);
+  register_pid(0, "server");
+  log_it(info, "---------- Monitas (server) has terminated ----------");
+  exit(0);
+}
+
+
+
+/*-----------------------------------------------------------*/
 
 
@@ -514 +950 @@
   int watch_port;
   struct sockaddr_in sin;
-  char buf[MAX_STR_LEN+1], tmp[MAX_STR_LEN];
+  char buf[MAX_STR_LEN+1], tmp[MAX_STR_LEN+1];
   int len, s, new_s;
   struct s_client2server_msg_record rec;
 
   watch_port = atoi((char*)sz_watchport);
-  sprintf(tmp, "watch_port_for_requests_from_clients(%d) - starting", watch_port);
-  log_it(debug, tmp);
+//  sprintf(tmp, "watch_port_for_requests_from_clients(%d) - starting", watch_port); log_it(debug, tmp);
   memset((void*)&sin, 0, sizeof(sin));
   sin.sin_family = AF_INET;
@@ -544 +979 @@
     }
   /* service incoming connections */
-  sprintf(tmp, "Opened socket on port #%d OK", watch_port);
-  log_it(info, tmp);
+  sprintf(tmp, "Bound port #%d OK", watch_port);
+  log_it(debug, tmp);
   while(true)
     {
@@ -568 +1003 @@
 
 
+/*-----------------------------------------------------------*/
+
+
+
 int main(int argc, char*argv[])
 /*
@@ -575 +1014 @@
 */
 {
-  char tmp[MAX_STR_LEN];
-
-/* FIXME - add Ctrl-C / sigterm trapping */
-
+  pthread_t server_status_thread;
+
+  log_it(info, "---------- Monitas (server) by Hugo Rabson ----------");
+  register_pid(getpid(), "server");
+  set_signals(true);
   start_threads_to_watch_ports_for_requests();
-  interact_with_sysadm(); /* report on users logged in, etc.; return after a while... */
-  if (g_clientlist.items != 0)
-    { fprintf(stderr, "Ruh-roh! Some users are still logged in. Oh well...\n"); }
-/* FIXME - force clients to log off */
-/* FIXME - send signal to threads, telling them to terminate */
-  sprintf(tmp, "Done. Server is exiting now.");
-  log_it(info, tmp);
-  return(0);
+  pthread_create(&server_status_thread, NULL, generate_server_status_file_regularly, (void*)SERVER_STATUS_FILE);
+  create_and_watch_fifo_for_commands(SERVER_COMDEV);
+  log_it(warn, "Execution should never reach this point");
+  exit(0);
 }
 /* end main() */