src/background.c

   1 /* {{{ Copyright */
   2
   3 /* Background support.
   4    Copyright (C) 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
   5    Free Software Foundation, Inc.
   6
   7    Written by: 1996 Miguel de Icaza
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23 /* }}} */
  24
  25 /** \file background.c
  26  *  \brief Source: Background support
  27  */
  28
  29 #include <config.h>
  30
  31 #ifdef WITH_BACKGROUND
  32
  33 #include <stdlib.h>
  34 #include <errno.h>
  35 #include <signal.h>
  36 #include <stdarg.h>
  37 #include <stdio.h>
  38 #include <string.h>
  39
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #include <sys/wait.h>           /* waitpid() */
  43 #include <unistd.h>
  44 #include <fcntl.h>
  45
  46 #include "lib/global.h"
  47 #include "background.h"
  48 #include "wtools.h"
  49 #include "layout.h"             /* repaint_screen() */
  50 #include "fileopctx.h"          /* FileOpContext */
  51 #include "lib/tty/key.h"        /* add_select_channel(), delete_select_channel() */
  52
  53 enum ReturnType
  54 {
  55     Return_String,
  56     Return_Integer
  57 };
  58
  59 /* If true, this is a background process */
  60 int we_are_background = 0;
  61
  62 /* File descriptor for talking to our parent */
  63 static int parent_fd;
  64
  65 /* File descriptor for messages from our parent */
  66 static int from_parent_fd;
  67
  68 #define MAXCALLARGS 4           /* Number of arguments supported */
  69
  70 struct TaskList *task_list = NULL;
  71
  72 static int background_attention (int fd, void *closure);
  73
  74 static void
  75 register_task_running (FileOpContext * ctx, pid_t pid, int fd, int to_child, char *info)
  76 {
  77     TaskList *new;
  78
  79     new = g_new (TaskList, 1);
  80     new->pid = pid;
  81     new->info = info;
  82     new->state = Task_Running;
  83     new->next = task_list;
  84     new->fd = fd;
  85     new->to_child_fd = to_child;
  86     task_list = new;
  87
  88     add_select_channel (fd, background_attention, ctx);
  89 }
  90
  91 static int
  92 destroy_task_and_return_fd (pid_t pid)
  93 {
  94     TaskList *p = task_list;
  95     TaskList *prev = 0;
  96
  97     while (p)
  98     {
  99         if (p->pid == pid)
 100         {
 101             if (prev)
 102                 prev->next = p->next;
 103             else
 104                 task_list = p->next;
 105             g_free (p->info);
 106             g_free (p);
 107             return p->fd;
 108         }
 109         prev = p;
 110         p = p->next;
 111     }
 112
 113     /* pid not found */
 114     return -1;
 115 }
 116
 117 void
 118 unregister_task_running (pid_t pid, int fd)
 119 {
 120     destroy_task_and_return_fd (pid);
 121     delete_select_channel (fd);
 122 }
 123
 124 void
 125 unregister_task_with_pid (pid_t pid)
 126 {
 127     int fd = destroy_task_and_return_fd (pid);
 128     if (fd != -1)
 129         delete_select_channel (fd);
 130 }
 131
 132 /*
 133  * Try to make the Midnight Commander a background job
 134  *
 135  * Returns:
 136  *  1 for parent
 137  *  0 for child
 138  * -1 on failure
 139  */
 140 int
 141 do_background (struct FileOpContext *ctx, char *info)
 142 {
 143     int comm[2];                /* control connection stream */
 144     int back_comm[2];           /* back connection */
 145     pid_t pid;
 146
 147     if (pipe (comm) == -1)
 148         return -1;
 149
 150     if (pipe (back_comm) == -1)
 151         return -1;
 152
 153     if ((pid = fork ()) == -1)
 154     {
 155         int saved_errno = errno;
 156         (void) close (comm[0]);
 157         (void) close (comm[1]);
 158         (void) close (back_comm[0]);
 159         (void) close (back_comm[1]);
 160         errno = saved_errno;
 161         return -1;
 162     }
 163
 164     if (pid == 0)
 165     {
 166         int nullfd;
 167
 168         parent_fd = comm[1];
 169         from_parent_fd = back_comm[0];
 170
 171         we_are_background = 1;
 172         current_dlg = NULL;
 173
 174         /* Make stdin/stdout/stderr point somewhere */
 175         close (0);
 176         close (1);
 177         close (2);
 178
 179         if ((nullfd = open ("/dev/null", O_RDWR)) != -1)
 180         {
 181             while (dup2 (nullfd, 0) == -1 && errno == EINTR);
 182             while (dup2 (nullfd, 1) == -1 && errno == EINTR);
 183             while (dup2 (nullfd, 2) == -1 && errno == EINTR);
 184         }
 185
 186         return 0;
 187     }
 188     else
 189     {
 190         ctx->pid = pid;
 191         register_task_running (ctx, pid, comm[0], back_comm[1], info);
 192         return 1;
 193     }
 194 }
 195
 196 /* {{{ Parent handlers */
 197
 198 /* Parent/child protocol
 199  *
 200  * the child (the background) process send the following:
 201  * void *routine -- routine to be invoked in the parent
 202  * int  nargc    -- number of arguments
 203  * int  type     -- Return argument type.
 204  *
 205  * If the routine is zero, then it is a way to tell the parent
 206  * that the process is dying.
 207  *
 208  * nargc arguments in the following format:
 209  * int size of the coming block
 210  * size bytes with the block
 211  *
 212  * Now, the parent loads all those and then invokes
 213  * the routine with pointers to the information passed
 214  * (we just support pointers).
 215  *
 216  * If the return type is integer:
 217  *
 218  *     the parent then writes an int to the child with
 219  *     the return value from the routine and the values
 220  *     of any global variable that is modified in the parent
 221  *     currently: do_append and recursive_result.
 222  *
 223  * If the return type is a string:
 224  *
 225  *     the parent writes the resulting string length
 226  *     if the result string was NULL or the empty string,
 227  *     then the length is zero.
 228  *     The parent then writes the string length and frees
 229  *     the result string.
 230  */
 231 /*
 232  * Receive requests from background process and invoke the
 233  * specified routine
 234  */
 235
 236 static int
 237 background_attention (int fd, void *closure)
 238 {
 239     FileOpContext *ctx;
 240     int have_ctx;
 241     union
 242     {
 243         int (*have_ctx0) (int);
 244         int (*have_ctx1) (int, char *);
 245         int (*have_ctx2) (int, char *, char *);
 246         int (*have_ctx3) (int, char *, char *, char *);
 247         int (*have_ctx4) (int, char *, char *, char *, char *);
 248
 249         int (*non_have_ctx0) (FileOpContext *, int);
 250         int (*non_have_ctx1) (FileOpContext *, int, char *);
 251         int (*non_have_ctx2) (FileOpContext *, int, char *, char *);
 252         int (*non_have_ctx3) (FileOpContext *, int, char *, char *, char *);
 253         int (*non_have_ctx4) (FileOpContext *, int, char *, char *, char *, char *);
 254
 255         char *(*ret_str0) ();
 256         char *(*ret_str1) (char *);
 257         char *(*ret_str2) (char *, char *);
 258         char *(*ret_str3) (char *, char *, char *);
 259         char *(*ret_str4) (char *, char *, char *, char *);
 260
 261         void *pointer;
 262     } routine;
 263     /*    void *routine; */
 264     int argc, i, result, status;
 265     char *data[MAXCALLARGS];
 266     ssize_t bytes, ret;
 267     struct TaskList *p;
 268     int to_child_fd = -1;
 269     enum ReturnType type;
 270
 271     ctx = closure;
 272
 273     bytes = read (fd, &routine.pointer, sizeof (routine));
 274     if (bytes == -1 || (size_t) bytes < (sizeof (routine)))
 275     {
 276         const char *background_process_error = _(" Background process error ");
 277
 278         unregister_task_running (ctx->pid, fd);
 279         if (!waitpid (ctx->pid, &status, WNOHANG))
 280         {
 281             /* the process is still running, but it misbehaves - kill it */
 282             kill (ctx->pid, SIGTERM);
 283             message (D_ERROR, background_process_error, _(" Unknown error in child "));
 284             return 0;
 285         }
 286
 287         /* 0 means happy end */
 288         if (WIFEXITED (status) && (WEXITSTATUS (status) == 0))
 289             return 0;
 290
 291         message (D_ERROR, background_process_error, _(" Child died unexpectedly "));
 292
 293         return 0;
 294     }
 295
 296     if ((read (fd, &argc, sizeof (argc)) != sizeof (argc)) ||
 297         (read (fd, &type, sizeof (type)) != sizeof (type)) ||
 298         (read (fd, &have_ctx, sizeof (have_ctx)) != sizeof (have_ctx)))
 299     {
 300         message (D_ERROR, _(" Background protocol error "), _("Reading failed"));
 301         return 0;
 302     }
 303
 304     if (argc > MAXCALLARGS)
 305     {
 306         message (D_ERROR, _(" Background protocol error "),
 307                  _(" Background process sent us a request for more arguments \n"
 308                    " than we can handle. \n"));
 309     }
 310
 311     if (have_ctx)
 312     {
 313         if (read (fd, ctx, sizeof (FileOpContext)) != sizeof (FileOpContext))
 314         {
 315             message (D_ERROR, _(" Background protocol error "), _("Reading failed"));
 316             return 0;
 317         }
 318     }
 319
 320     for (i = 0; i < argc; i++)
 321     {
 322         int size;
 323
 324         if (read (fd, &size, sizeof (size)) != sizeof (size))
 325         {
 326             message (D_ERROR, _(" Background protocol error "), _("Reading failed"));
 327             return 0;
 328         }
 329         data[i] = g_malloc (size + 1);
 330         if (read (fd, data[i], size) != size)
 331         {
 332             message (D_ERROR, _(" Background protocol error "), _("Reading failed"));
 333             return 0;
 334         }
 335         data[i][size] = 0;      /* NULL terminate the blocks (they could be strings) */
 336     }
 337
 338     /* Find child task info by descriptor */
 339     /* Find before call, because process can destroy self after */
 340     for (p = task_list; p; p = p->next)
 341     {
 342         if (p->fd == fd)
 343             break;
 344     }
 345
 346     if (p)
 347         to_child_fd = p->to_child_fd;
 348
 349     if (to_child_fd == -1)
 350         message (D_ERROR, _(" Background process error "), _(" Unknown error in child "));
 351
 352     /* Handle the call */
 353     if (type == Return_Integer)
 354     {
 355         if (!have_ctx)
 356             switch (argc)
 357             {
 358             case 0:
 359                 result = routine.have_ctx0 (Background);
 360                 break;
 361             case 1:
 362                 result = routine.have_ctx1 (Background, data[0]);
 363                 break;
 364             case 2:
 365                 result = routine.have_ctx2 (Background, data[0], data[1]);
 366                 break;
 367             case 3:
 368                 result = routine.have_ctx3 (Background, data[0], data[1], data[2]);
 369                 break;
 370             case 4:
 371                 result = routine.have_ctx4 (Background, data[0], data[1], data[2], data[3]);
 372                 break;
 373             }
 374         else
 375             switch (argc)
 376             {
 377             case 0:
 378                 result = routine.non_have_ctx0 (ctx, Background);
 379                 break;
 380             case 1:
 381                 result = routine.non_have_ctx1 (ctx, Background, data[0]);
 382                 break;
 383             case 2:
 384                 result = routine.non_have_ctx2 (ctx, Background, data[0], data[1]);
 385                 break;
 386             case 3:
 387                 result = routine.non_have_ctx3 (ctx, Background, data[0], data[1], data[2]);
 388                 break;
 389             case 4:
 390                 result =
 391                     routine.non_have_ctx4 (ctx, Background, data[0], data[1], data[2], data[3]);
 392                 break;
 393             }
 394
 395         /* Send the result code and the value for shared variables */
 396         ret = write (to_child_fd, &result, sizeof (int));
 397         if (have_ctx && to_child_fd != -1)
 398             ret = write (to_child_fd, ctx, sizeof (FileOpContext));
 399     }
 400     else if (type == Return_String)
 401     {
 402         int len;
 403         char *resstr = NULL;
 404
 405         /* FIXME: string routines should also use the Foreground/Background
 406          * parameter.  Currently, this is not used here
 407          */
 408         switch (argc)
 409         {
 410         case 0:
 411             resstr = routine.ret_str0 ();
 412             break;
 413         case 1:
 414             resstr = routine.ret_str1 (data[0]);
 415             break;
 416         case 2:
 417             resstr = routine.ret_str2 (data[0], data[1]);
 418             break;
 419         case 3:
 420             resstr = routine.ret_str3 (data[0], data[1], data[2]);
 421             break;
 422         case 4:
 423             resstr = routine.ret_str4 (data[0], data[1], data[2], data[3]);
 424             break;
 425         default:
 426             g_assert_not_reached ();
 427         }
 428         if (resstr)
 429         {
 430             len = strlen (resstr);
 431             ret = write (to_child_fd, &len, sizeof (len));
 432             if (len)
 433             {
 434                 write (to_child_fd, resstr, len);
 435             }
 436             g_free (resstr);
 437         }
 438         else
 439         {
 440             len = 0;
 441             ret = write (to_child_fd, &len, sizeof (len));
 442         }
 443     }
 444     for (i = 0; i < argc; i++)
 445         g_free (data[i]);
 446
 447     repaint_screen ();
 448     return 0;
 449 }
 450
 451
 452 /* }}} */
 453
 454 /* {{{ client RPC routines */
 455
 456 /* Sends the header for a call to a routine in the parent process.  If the file
 457  * operation context is not NULL, then it requests that the first parameter of
 458  * the call be a file operation context.
 459  */
 460 static void
 461 parent_call_header (void *routine, int argc, enum ReturnType type, FileOpContext * ctx)
 462 {
 463     int have_ctx;
 464     ssize_t ret;
 465
 466     have_ctx = (ctx != NULL);
 467
 468     ret = write (parent_fd, &routine, sizeof (routine));
 469     ret = write (parent_fd, &argc, sizeof (int));
 470     ret = write (parent_fd, &type, sizeof (type));
 471     ret = write (parent_fd, &have_ctx, sizeof (have_ctx));
 472
 473     if (have_ctx)
 474         ret = write (parent_fd, ctx, sizeof (FileOpContext));
 475 }
 476
 477 int
 478 parent_call (void *routine, struct FileOpContext *ctx, int argc, ...)
 479 {
 480     va_list ap;
 481     int i;
 482     ssize_t ret;
 483
 484     va_start (ap, argc);
 485     parent_call_header (routine, argc, Return_Integer, ctx);
 486     for (i = 0; i < argc; i++)
 487     {
 488         int len;
 489         void *value;
 490
 491         len = va_arg (ap, int);
 492         value = va_arg (ap, void *);
 493         ret = write (parent_fd, &len, sizeof (int));
 494         ret = write (parent_fd, value, len);
 495     }
 496
 497     ret = read (from_parent_fd, &i, sizeof (int));
 498     if (ctx)
 499         ret = read (from_parent_fd, ctx, sizeof (FileOpContext));
 500
 501     return i;
 502 }
 503
 504 char *
 505 parent_call_string (void *routine, int argc, ...)
 506 {
 507     va_list ap;
 508     char *str;
 509     int i;
 510
 511     va_start (ap, argc);
 512     parent_call_header (routine, argc, Return_String, NULL);
 513     for (i = 0; i < argc; i++)
 514     {
 515         int len;
 516         void *value;
 517
 518         len = va_arg (ap, int);
 519         value = va_arg (ap, void *);
 520         if ((write (parent_fd, &len, sizeof (int)) != sizeof (int)) ||
 521             (write (parent_fd, value, len) != len))
 522             return NULL;
 523     }
 524     if (read (from_parent_fd, &i, sizeof (int)) != sizeof (int))
 525         return NULL;
 526     if (!i)
 527         return NULL;
 528     str = g_malloc (i + 1);
 529     if (read (from_parent_fd, str, i) != i)
 530     {
 531         g_free (str);
 532         return NULL;
 533     }
 534     str[i] = 0;
 535     return str;
 536 }
 537
 538 #endif /* WITH_BACKGROUND */