src/background.c

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