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 = NULL;
 208
 209         /* We attempt to open the filename by doing the following:
 210          *
 211          * - If the file does start with a "/" then it's treated as an
 212          *   absolute path.
 213          *
 214          *  - Otherwise, it's assumed to be in FVWM_USERDIR OR FVWM_DATADIR,
 215          *    whichever comes first.
 216          *
 217          * - If the file starts with "./" or "../" then try and
 218          *   open the file exactly as specified which means
 219          *   things like:
 220          *
 221          *   ../.././foo is catered for.  At this point, we just try and open
 222          *   the specified file regardless.
 223          *
 224          *  - *Hidden* files in the CWD would have to be specified as:
 225          *
 226          *    ./.foo
 227          */
 228         full_filename = filename;
 229
 230         if (full_filename[0] == '/')
 231         {
 232                 /* It's an absolute path */
 233                 f = fopen(full_filename,"r");
 234         } else {
 235                 /* It's a relative path.  Check in either FVWM_USERDIR or
 236                  * FVWM_DATADIR.
 237                  * */
 238                 full_filename = CatString3(fvwm_userdir, "/", filename);
 239
 240                 if((f = fopen(full_filename, "r")) == NULL)
 241                 {
 242                         full_filename = CatString3(
 243                                         FVWM_DATADIR, "/", filename);
 244                         f = fopen(full_filename, "r");
 245                 }
 246         }
 247
 248         if ((f == NULL) &&
 249                 (f = fopen(filename, "r")) == NULL) {
 250                 /* We really couldn't open the file. */
 251                 return 0;
 252         }
 253
 254         if (push_read_file(full_filename) == 0)
 255         {
 256                 return 0;
 257         }
 258         run_command_stream(NULL, f, exc);
 259         fclose(f);
 260         pop_read_file();
 261
 262         return 1;
 263 }
 264
 265 /**
 266  * Busy Cursor Stuff for Read
 267  **/
 268 static void cursor_control(Bool grab)
 269 {
 270         static int read_depth = 0;
 271         static Bool need_ungrab = False;
 272
 273         if (!(Scr.BusyCursor & BUSY_READ) && !need_ungrab)
 274         {
 275                 return;
 276         }
 277         if (grab)
 278         {
 279                 if (!read_depth && GrabEm(CRS_WAIT, GRAB_BUSY))
 280                 {
 281                         need_ungrab = True;
 282                 }
 283                 if (need_ungrab)
 284                 {
 285                         read_depth++;
 286                 }
 287         }
 288         else if (need_ungrab)
 289         {
 290                 read_depth--;
 291                 if (!read_depth || !(Scr.BusyCursor & BUSY_READ))
 292                 {
 293                         UngrabEm(GRAB_BUSY);
 294                         need_ungrab = False;
 295                         read_depth = 0;
 296                 }
 297         }
 298
 299         return;
 300 }
 301
 302 void CMD_Read(F_CMD_ARGS)
 303 {
 304         char* filename;
 305         int read_quietly;
 306
 307         DoingCommandLine = False;
 308
 309         if (cond_rc != NULL)
 310         {
 311                 cond_rc->rc = COND_RC_OK;
 312         }
 313         if (!parse_filename("Read", action, &filename, &read_quietly))
 314         {
 315                 if (cond_rc != NULL)
 316                 {
 317                         cond_rc->rc = COND_RC_ERROR;
 318                 }
 319                 return;
 320         }
 321         cursor_control(True);
 322         if (!run_command_file(filename, exc))
 323         {
 324                 if (!read_quietly)
 325                 {
 326                         if (filename[0] == '/')
 327                         {
 328                                 fvwm_msg(
 329                                         ERR, "Read",
 330                                         "file '%s' not found", filename);
 331                         }
 332                         else
 333                         {
 334                                 fvwm_msg(
 335                                         ERR, "Read",
 336                                         "file '%s' not found in %s or "
 337                                         FVWM_DATADIR, filename, fvwm_userdir);
 338                         }
 339                 }
 340                 if (cond_rc != NULL)
 341                 {
 342                         cond_rc->rc = COND_RC_ERROR;
 343                 }
 344         }
 345         free(filename);
 346         cursor_control(False);
 347
 348         return;
 349 }
 350
 351 void CMD_PipeRead(F_CMD_ARGS)
 352 {
 353         char* command;
 354         int read_quietly;
 355         FILE* f;
 356
 357         DoingCommandLine = False;
 358
 359         if (cond_rc != NULL)
 360         {
 361                 cond_rc->rc = COND_RC_OK;
 362         }
 363         if (!parse_filename("PipeRead", action, &command, &read_quietly))
 364         {
 365                 if (cond_rc != NULL)
 366                 {
 367                         cond_rc->rc = COND_RC_ERROR;
 368                 }
 369                 return;
 370         }
 371         cursor_control(True);
 372         f = popen(command, "r");
 373         if (f == NULL)
 374         {
 375                 if (cond_rc != NULL)
 376                 {
 377                         cond_rc->rc = COND_RC_ERROR;
 378                 }
 379                 if (!read_quietly)
 380                 {
 381                         fvwm_msg(
 382                                 ERR, "PipeRead", "command '%s' not run",
 383                                 command);
 384                 }
 385                 free(command);
 386                 cursor_control(False);
 387                 return;
 388         }
 389         free(command);
 390
 391         run_command_stream(cond_rc,f, exc);
 392         pclose(f);
 393         cursor_control(False);
 394
 395         return;
 396 }