builtins/jobs.def

   1 This file is jobs.def, from which is created jobs.c.
   2 It implements the builtins "jobs" and "disown" in Bash.
   3
   4 Copyright (C) 1987-2005 Free Software Foundation, Inc.
   5
   6 This file is part of GNU Bash, the Bourne Again SHell.
   7
   8 Bash is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2, or (at your option) any later
  11 version.
  12
  13 Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License along
  19 with Bash; see the file COPYING.  If not, write to the Free Software
  20 Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA.
  21
  22 $PRODUCES jobs.c
  23
  24 $BUILTIN jobs
  25 $FUNCTION jobs_builtin
  26 $DEPENDS_ON JOB_CONTROL
  27 $SHORT_DOC jobs [-lnprs] [jobspec ...] or jobs -x command [args]
  28 Lists the active jobs.  The -l option lists process id's in addition
  29 to the normal information; the -p option lists process id's only.
  30 If -n is given, only processes that have changed status since the last
  31 notification are printed.  JOBSPEC restricts output to that job.  The
  32 -r and -s options restrict output to running and stopped jobs only,
  33 respectively.  Without options, the status of all active jobs is
  34 printed.  If -x is given, COMMAND is run after all job specifications
  35 that appear in ARGS have been replaced with the process ID of that job's
  36 process group leader.
  37 $END
  38
  39 #include <config.h>
  40
  41 #if defined (JOB_CONTROL)
  42 #include "../bashtypes.h"
  43 #include <signal.h>
  44 #if defined (HAVE_UNISTD_H)
  45 #  include <unistd.h>
  46 #endif
  47
  48 #include "../bashansi.h"
  49 #include "../bashintl.h"
  50
  51 #include "../shell.h"
  52 #include "../jobs.h"
  53 #include "../execute_cmd.h"
  54 #include "bashgetopt.h"
  55 #include "common.h"
  56
  57 #define JSTATE_ANY      0x0
  58 #define JSTATE_RUNNING  0x1
  59 #define JSTATE_STOPPED  0x2
  60
  61 static int execute_list_with_replacements __P((WORD_LIST *));
  62
  63 /* The `jobs' command.  Prints outs a list of active jobs.  If the
  64    argument `-l' is given, then the process id's are printed also.
  65    If the argument `-p' is given, print the process group leader's
  66    pid only.  If `-n' is given, only processes that have changed
  67    status since the last notification are printed.  If -x is given,
  68    replace all job specs with the pid of the appropriate process
  69    group leader and execute the command.  The -r and -s options mean
  70    to print info about running and stopped jobs only, respectively. */
  71 int
  72 jobs_builtin (list)
  73      WORD_LIST *list;
  74 {
  75   int form, execute, state, opt, any_failed, job;
  76   sigset_t set, oset;
  77
  78   execute = any_failed = 0;
  79   form = JLIST_STANDARD;
  80   state = JSTATE_ANY;
  81
  82   reset_internal_getopt ();
  83   while ((opt = internal_getopt (list, "lpnxrs")) != -1)
  84     {
  85       switch (opt)
  86         {
  87         case 'l':
  88           form = JLIST_LONG;
  89           break;
  90         case 'p':
  91           form = JLIST_PID_ONLY;
  92           break;
  93         case 'n':
  94           form = JLIST_CHANGED_ONLY;
  95           break;
  96         case 'x':
  97           if (form != JLIST_STANDARD)
  98             {
  99               builtin_error (_("no other options allowed with `-x'"));
 100               return (EXECUTION_FAILURE);
 101             }
 102           execute++;
 103           break;
 104         case 'r':
 105           state = JSTATE_RUNNING;
 106           break;
 107         case 's':
 108           state = JSTATE_STOPPED;
 109           break;
 110
 111         default:
 112           builtin_usage ();
 113           return (EX_USAGE);
 114         }
 115     }
 116
 117   list = loptend;
 118
 119   if (execute)
 120     return (execute_list_with_replacements (list));
 121
 122   if (!list)
 123     {
 124       switch (state)
 125         {
 126         case JSTATE_ANY:
 127           list_all_jobs (form);
 128           break;
 129         case JSTATE_RUNNING:
 130           list_running_jobs (form);
 131           break;
 132         case JSTATE_STOPPED:
 133           list_stopped_jobs (form);
 134           break;
 135         }
 136       return (EXECUTION_SUCCESS);
 137     }
 138
 139   while (list)
 140     {
 141       BLOCK_CHILD (set, oset);
 142       job = get_job_spec (list);
 143
 144       if ((job == NO_JOB) || jobs == 0 || get_job_by_jid (job) == 0)
 145         {
 146           sh_badjob (list->word->word);
 147           any_failed++;
 148         }
 149       else if (job != DUP_JOB)
 150         list_one_job ((JOB *)NULL, form, 0, job);
 151
 152       UNBLOCK_CHILD (oset);
 153       list = list->next;
 154     }
 155   return (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
 156 }
 157
 158 static int
 159 execute_list_with_replacements (list)
 160      WORD_LIST *list;
 161 {
 162   register WORD_LIST *l;
 163   int job, result;
 164   COMMAND *command;
 165   JOB *j;
 166
 167   /* First do the replacement of job specifications with pids. */
 168   for (l = list; l; l = l->next)
 169     {
 170       if (l->word->word[0] == '%')      /* we have a winner */
 171         {
 172           job = get_job_spec (l);
 173
 174           /* A bad job spec is not really a job spec! Pass it through. */
 175           if (INVALID_JOB (job))
 176             continue;
 177
 178           j = get_job_by_jid (job);
 179           free (l->word->word);
 180           l->word->word = itos (j->pgrp);
 181         }
 182     }
 183
 184   /* Next make a new simple command and execute it. */
 185   begin_unwind_frame ("jobs_builtin");
 186
 187   command = make_bare_simple_command ();
 188   command->value.Simple->words = copy_word_list (list);
 189   command->value.Simple->redirects = (REDIRECT *)NULL;
 190   command->flags |= CMD_INHIBIT_EXPANSION;
 191   command->value.Simple->flags |= CMD_INHIBIT_EXPANSION;
 192
 193   add_unwind_protect (dispose_command, command);
 194   result = execute_command (command);
 195   dispose_command (command);
 196
 197   discard_unwind_frame ("jobs_builtin");
 198   return (result);
 199 }
 200 #endif /* JOB_CONTROL */
 201
 202 $BUILTIN disown
 203 $FUNCTION disown_builtin
 204 $DEPENDS_ON JOB_CONTROL
 205 $SHORT_DOC disown [-h] [-ar] [jobspec ...]
 206 By default, removes each JOBSPEC argument from the table of active jobs.
 207 If the -h option is given, the job is not removed from the table, but is
 208 marked so that SIGHUP is not sent to the job if the shell receives a
 209 SIGHUP.  The -a option, when JOBSPEC is not supplied, means to remove all
 210 jobs from the job table; the -r option means to remove only running jobs.
 211 $END
 212
 213 #if defined (JOB_CONTROL)
 214 int
 215 disown_builtin (list)
 216      WORD_LIST *list;
 217 {
 218   int opt, job, retval, nohup_only, running_jobs, all_jobs;
 219   sigset_t set, oset;
 220   intmax_t pid_value;
 221
 222   nohup_only = running_jobs = all_jobs = 0;
 223   reset_internal_getopt ();
 224   while ((opt = internal_getopt (list, "ahr")) != -1)
 225     {
 226       switch (opt)
 227         {
 228         case 'a':
 229           all_jobs = 1;
 230           break;
 231         case 'h':
 232           nohup_only = 1;
 233           break;
 234         case 'r':
 235           running_jobs = 1;
 236           break;
 237         default:
 238           builtin_usage ();
 239           return (EX_USAGE);
 240         }
 241     }
 242   list = loptend;
 243   retval = EXECUTION_SUCCESS;
 244
 245   /* `disown -a' or `disown -r' */
 246   if (list == 0 && (all_jobs || running_jobs))
 247     {
 248       if (nohup_only)
 249         nohup_all_jobs (running_jobs);
 250       else
 251         delete_all_jobs (running_jobs);
 252       return (EXECUTION_SUCCESS);
 253     }
 254
 255   do
 256     {
 257       BLOCK_CHILD (set, oset);
 258       job = (list && legal_number (list->word->word, &pid_value) && pid_value == (pid_t) pid_value)
 259                 ? get_job_by_pid ((pid_t) pid_value, 0)
 260                 : get_job_spec (list);
 261
 262       if (job == NO_JOB || jobs == 0 || INVALID_JOB (job))
 263         {
 264           sh_badjob (list ? list->word->word : "current");
 265           retval = EXECUTION_FAILURE;
 266         }
 267       else if (nohup_only)
 268         nohup_job (job);
 269       else
 270         delete_job (job, 1);
 271       UNBLOCK_CHILD (oset);
 272
 273       if (list)
 274         list = list->next;
 275     }
 276   while (list);
 277
 278   return (retval);
 279 }
 280 #endif /* JOB_CONTROL */