uicb.c

   1 /*
   2  * uicb.c - user interface callbacks management
   3  *
   4  * Copyright © 2007-2008 Julien Danjou <julien@danjou.info>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  */
  21
  22 /**
  23  * @defgroup ui_callback User Interface Callbacks
  24  */
  25
  26 /* strndup() */
  27 #define _GNU_SOURCE
  28
  29 #include <sys/wait.h>
  30 #include <string.h>
  31 #include <unistd.h>
  32 #include <errno.h>
  33
  34 #include "awesome.h"
  35 #include "tag.h"
  36 #include "mouse.h"
  37 #include "statusbar.h"
  38 #include "widget.h"
  39 #include "focus.h"
  40 #include "client.h"
  41 #include "screen.h"
  42 #include "titlebar.h"
  43 #include "layouts/tile.h"
  44
  45 extern AwesomeConf globalconf;
  46
  47 #include "uicbgen.h"
  48
  49 /** Restart awesome with the current command line
  50  * \param screen ID
  51  * \param arg arg (unused)
  52  * \ingroup ui_callback
  53  */
  54 void
  55 uicb_restart(int screen, char *arg __attribute__ ((unused)))
  56 {
  57     uicb_exec(screen, globalconf.argv);
  58 }
  59
  60 /** Execute another process, replacing the current instance of Awesome
  61  * \param screen Screen ID
  62  * \param cmd Command
  63  * \ingroup ui_callback
  64  */
  65 void
  66 uicb_exec(int screen __attribute__ ((unused)), char *cmd)
  67 {
  68     Client *c;
  69     char *args, *path;
  70
  71     /* remap all clients since some WM won't handle them otherwise */
  72     for(c = globalconf.clients; c; c = c->next)
  73         client_unban(c);
  74
  75     XSync(globalconf.display, False);
  76     XCloseDisplay(globalconf.display);
  77
  78     /* Ignore the leading spaces if any */
  79     while(cmd[0] && cmd[0] == ' ')
  80         cmd++;
  81
  82     /* Get the beginning of the arguments */
  83     args = strchr(cmd, ' ');
  84
  85     if(args)
  86         path = strndup(cmd, args - cmd);
  87     else
  88         path = strndup(cmd, a_strlen(cmd));
  89
  90     execlp(path, cmd, NULL);
  91
  92     p_delete(&path);
  93 }
  94
  95 /** Spawn another process
  96  * \param screen Screen ID
  97  * \param arg Command
  98  * \ingroup ui_callback
  99  */
 100 void
 101 uicb_spawn(int screen, char *arg)
 102 {
 103     static char *shell = NULL;
 104     char *display = NULL;
 105     char *tmp, newdisplay[128];
 106
 107     if(!arg)
 108         return;
 109
 110     if(!shell && !(shell = getenv("SHELL")))
 111         shell = a_strdup("/bin/sh");
 112
 113     if(!globalconf.screens_info->xinerama_is_active && (tmp = getenv("DISPLAY")))
 114     {
 115         display = a_strdup(tmp);
 116         if((tmp = strrchr(display, '.')))
 117             *tmp = '\0';
 118         snprintf(newdisplay, sizeof(newdisplay), "%s.%d", display, screen);
 119         setenv("DISPLAY", newdisplay, 1);
 120     }
 121
 122
 123     /* The double-fork construct avoids zombie processes and keeps the code
 124      * clean from stupid signal handlers. */
 125     if(fork() == 0)
 126     {
 127         if(fork() == 0)
 128         {
 129             if(globalconf.display)
 130                 close(ConnectionNumber(globalconf.display));
 131             setsid();
 132             execl(shell, shell, "-c", arg, NULL);
 133             warn("execl '%s -c %s' failed: %s\n", shell, arg, strerror(errno));
 134         }
 135         exit(EXIT_SUCCESS);
 136     }
 137     wait(0);
 138 }
 139
 140 static int
 141 run_uicb(char *cmd)
 142 {
 143     char *p, *argcpy;
 144     const char *arg;
 145     int screen;
 146     ssize_t len;
 147     Uicb *uicb;
 148
 149     len = a_strlen(cmd);
 150     p = strtok(cmd, " ");
 151     if (!p)
 152     {
 153         warn("ignoring malformed command\n");
 154         return -1;
 155     }
 156     screen = atoi(cmd);
 157     if(screen >= globalconf.screens_info->nscreen || screen < 0)
 158     {
 159         warn("invalid screen specified: %i\n", screen);
 160         return -1;
 161     }
 162
 163     p = strtok(NULL, " ");
 164     if (!p)
 165     {
 166         warn("ignoring malformed command.\n");
 167         return -1;
 168     }
 169
 170     uicb = name_func_lookup(p, UicbList);
 171     if (!uicb)
 172     {
 173         warn("unknown uicb function: %s.\n", p);
 174         return -1;
 175     }
 176
 177     if (p + a_strlen(p) < cmd + len)
 178     {
 179         arg = p + a_strlen(p) + 1;
 180         len = a_strlen(arg);
 181         /* Allow our callees to modify this string. */
 182         argcpy = p_new(char, len + 1);
 183         a_strncpy(argcpy, len + 1,  arg, len);
 184         uicb(screen, argcpy);
 185         p_delete(&argcpy);
 186     }
 187     else
 188         uicb(screen, NULL);
 189
 190     return 0;
 191 }
 192
 193 int
 194 parse_control(char *cmd)
 195 {
 196     char *p, *curcmd = cmd;
 197
 198     if(!a_strlen(cmd))
 199         return -1;
 200
 201     while((p = strchr(curcmd, '\n')))
 202     {
 203         *p = '\0';
 204         run_uicb(curcmd);
 205         curcmd = p + 1;
 206     }
 207
 208     return 0;
 209 }
 210
 211 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80