fvwm/read.c

   1 /* -*-c-*- */
   2 /* This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 2 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18  * This module is all original code
  19  * by Rob Nation
  20  * Copyright 1993, Robert Nation
  21  *     You may use this code for any purpose, as long as the original
  22  *     copyright remains in the source code and all documentation
  23  *
  24  * Changed 09/24/98 by Dan Espen:
  25  * - remove logic that processed and saved module configuration commands.
  26  * Its now in "modconf.c".
  27  */
  28 #include "config.h"
  29
  30 #include <stdio.h>
  31 #ifdef HAVE_FCNTL_H
  32 #include <fcntl.h>
  33 #endif
  34
  35 #include "libs/Parse.h"
  36 #include "libs/Strings.h"
  37 #include "fvwm.h"
  38 #include "externs.h"
  39 #include "cursor.h"
  40 #include "functions.h"
  41 #include "events.h"
  42 #include "misc.h"
  43 #include "screen.h"
  44
  45 #define MAX_READ_DEPTH 40
  46 static char *curr_read_file = NULL;
  47 static char *curr_read_dir = NULL;
  48 static int curr_read_depth = 0;
  49 static char *prev_read_files[MAX_READ_DEPTH];
  50
  51 static int push_read_file(const char *file)
  52 {
  53         if (curr_read_depth >= MAX_READ_DEPTH)
  54         {
  55                 fvwm_msg(
  56                         ERR, "Read", "Nested Read limit %d is reached",
  57                         MAX_READ_DEPTH);
  58                 return 0;
  59         }
  60         prev_read_files[curr_read_depth++] = curr_read_file;
  61         curr_read_file = safestrdup(file);
  62         if (curr_read_dir)
  63         {
  64                 free(curr_read_dir);
  65         }
  66         curr_read_dir = NULL;
  67
  68         return 1;
  69 }
  70
  71 static void pop_read_file(void)
  72 {
  73         if (curr_read_depth == 0)
  74         {
  75                 return;
  76         }
  77         if (curr_read_file)
  78         {
  79                 free(curr_read_file);
  80         }
  81         curr_read_file = prev_read_files[--curr_read_depth];
  82         if (curr_read_dir)
  83         {
  84                 free(curr_read_dir);
  85         }
  86         curr_read_dir = NULL;
  87
  88         return;
  89 }
  90
  91 const char *get_current_read_file(void)
  92 {
  93         return curr_read_file;
  94 }
  95
  96 const char *get_current_read_dir(void)
  97 {
  98         if (!curr_read_dir)
  99         {
 100                 char *dir_end;
 101                 if (!curr_read_file)
 102                 {
 103                         return ".";
 104                 }
 105                 /* it should be a library function parse_file_dir() */
 106                 dir_end = strrchr(curr_read_file, '/');
 107                 if (!dir_end)
 108                 {
 109                         dir_end = curr_read_file;
 110                 }
 111                 curr_read_dir = safemalloc(dir_end - curr_read_file + 1);
 112                 strncpy(curr_read_dir, curr_read_file,
 113                         dir_end - curr_read_file);
 114                 curr_read_dir[dir_end - curr_read_file] = '\0';
 115         }
 116         return curr_read_dir;
 117 }
 118
 119
 120 /*
 121  * Read and execute each line from stream.
 122  */
 123 void run_command_stream(
 124         cond_rc_t *cond_rc, FILE *f, const exec_context_t *exc)
 125 {
 126         char *tline;
 127         char line[1024];
 128
 129         /* Set close-on-exec flag */
 130         fcntl(fileno(f), F_SETFD, 1);
 131
 132         /* Update window decorations in case we were called from a menu that
 133          * has now popped down. */
 134         handle_all_expose();
 135
 136         tline = fgets(line, (sizeof line) - 1, f);
 137         while (tline)
 138         {
 139                 int l;
 140                 while (tline && (l = strlen(line)) < sizeof(line) && l >= 2 &&
 141                       line[l-2]=='\\' && line[l-1]=='\n')
 142                 {
 143                         tline = fgets(line+l-2,sizeof(line)-l+1,f);
 144                 }
 145                 tline=line;
 146                 while (isspace((unsigned char)*tline))
 147                 {
 148                         tline++;
 149                 }
 150                 l = strlen(tline);
 151                 if (l > 0 && tline[l - 1] == '\n')
 152                 {
 153                         tline[l - 1] = '\0';
 154                 }
 155                 execute_function(cond_rc, exc, tline, 0);
 156                 tline = fgets(line, (sizeof line) - 1, f);
 157         }
 158
 159         return;
 160 }
 161
 162
 163 /**
 164  * Parse the action string.  We expect a filename, and optionally,
 165  * the keyword "Quiet".  The parameter `cmdname' is used for diagnostic
 166  * messages only.
 167  *
 168  * Returns true if the parse succeeded.
 169  * The filename and the presence of the quiet flag are returned
 170  * using the pointer arguments.
 171  **/
 172 static int parse_filename(
 173         char *cmdname, char *action, char **filename, int *quiet_flag)
 174 {
 175         char *rest;
 176         char *option;
 177
 178         /*  fvwm_msg(INFO,cmdname,"action == '%s'",action); */
 179
 180         /* read file name arg */
 181         rest = GetNextToken(action,filename);
 182         if (*filename == NULL)
 183         {
 184                 fvwm_msg(ERR, cmdname, "missing filename parameter");
 185                 return 0;
 186         }
 187         /* optional "Quiet" argument -- flag defaults to `off' (noisy) */
 188         *quiet_flag = 0;
 189         rest = GetNextToken(rest,&option);
 190         if (option != NULL)
 191         {
 192                 *quiet_flag = strncasecmp(option, "Quiet", 5) == 0;
 193                 free(option);
 194         }
 195
 196         return 1;
 197 }
 198
 199
 200 /**
 201  * Returns 0 if file not found
 202  **/
 203 int run_command_file(
 204         char *filename, const exec_context_t *exc)
 205 {
 206         char *full_filename;
 207         FILE* f;
 208
 209         if (filename[0] == '/')
 210         {             /* if absolute path */
 211                 f = fopen(filename,"r");
 212                 full_filename = filename;
 213         }
 214         else
 215         {             /* else its a relative path */
 216                 full_filename = CatString3(fvwm_userdir, "/", filename);
 217                 f = fopen(full_filename, "r");
 218                 if (f == NULL)
 219                 {
 220                         full_filename = CatString3(
 221                                 FVWM_DATADIR, "/", filename);
 222                         f = fopen(full_filename, "r");
 223                 }
 224         }
 225         if (f == NULL)
 226         {
 227                 return 0;
 228         }
 229         if (push_read_file(full_filename) == 0)
 230         {
 231                 return 0;
 232         }
 233         run_command_stream(NULL, f, exc);
 234         fclose(f);
 235         pop_read_file();
 236
 237         return 1;
 238 }
 239
 240 /**
 241  * Busy Cursor Stuff for Read
 242  **/
 243 static void cursor_control(Bool grab)
 244 {
 245         static int read_depth = 0;
 246         static Bool need_ungrab = False;
 247
 248         if (!(Scr.BusyCursor & BUSY_READ) && !need_ungrab)
 249         {
 250                 return;
 251         }
 252         if (grab)
 253         {
 254                 if (!read_depth && GrabEm(CRS_WAIT, GRAB_BUSY))
 255                 {
 256                         need_ungrab = True;
 257                 }
 258                 if (need_ungrab)
 259                 {
 260                         read_depth++;
 261                 }
 262         }
 263         else if (need_ungrab)
 264         {
 265                 read_depth--;
 266                 if (!read_depth || !(Scr.BusyCursor & BUSY_READ))
 267                 {
 268                         UngrabEm(GRAB_BUSY);
 269                         need_ungrab = False;
 270                         read_depth = 0;
 271                 }
 272         }
 273
 274         return;
 275 }
 276
 277 void CMD_Read(F_CMD_ARGS)
 278 {
 279         char* filename;
 280         int read_quietly;
 281
 282         DoingCommandLine = False;
 283
 284         if (cond_rc != NULL)
 285         {
 286                 cond_rc->rc = COND_RC_OK;
 287         }
 288         if (!parse_filename("Read", action, &filename, &read_quietly))
 289         {
 290                 if (cond_rc != NULL)
 291                 {
 292                         cond_rc->rc = COND_RC_ERROR;
 293                 }
 294                 return;
 295         }
 296         cursor_control(True);
 297         if (!run_command_file(filename, exc))
 298         {
 299                 if (!read_quietly)
 300                 {
 301                         if (filename[0] == '/')
 302                         {
 303                                 fvwm_msg(
 304                                         ERR, "Read",
 305                                         "file '%s' not found", filename);
 306                         }
 307                         else
 308                         {
 309                                 fvwm_msg(
 310                                         ERR, "Read",
 311                                         "file '%s' not found in %s or "
 312                                         FVWM_DATADIR, filename, fvwm_userdir);
 313                         }
 314                 }
 315                 if (cond_rc != NULL)
 316                 {
 317                         cond_rc->rc = COND_RC_ERROR;
 318                 }
 319         }
 320         free(filename);
 321         cursor_control(False);
 322
 323         return;
 324 }
 325
 326 void CMD_PipeRead(F_CMD_ARGS)
 327 {
 328         char* command;
 329         int read_quietly;
 330         FILE* f;
 331
 332         DoingCommandLine = False;
 333
 334         if (cond_rc != NULL)
 335         {
 336                 cond_rc->rc = COND_RC_OK;
 337         }
 338         if (!parse_filename("PipeRead", action, &command, &read_quietly))
 339         {
 340                 if (cond_rc != NULL)
 341                 {
 342                         cond_rc->rc = COND_RC_ERROR;
 343                 }
 344                 return;
 345         }
 346         cursor_control(True);
 347         f = popen(command, "r");
 348         if (f == NULL)
 349         {
 350                 if (cond_rc != NULL)
 351                 {
 352                         cond_rc->rc = COND_RC_ERROR;
 353                 }
 354                 if (!read_quietly)
 355                 {
 356                         fvwm_msg(
 357                                 ERR, "PipeRead", "command '%s' not run",
 358                                 command);
 359                 }
 360                 free(command);
 361                 cursor_control(False);
 362                 return;
 363         }
 364         free(command);
 365
 366         run_command_stream(cond_rc,f, exc);
 367         pclose(f);
 368         cursor_control(False);
 369
 370         return;
 371 }