modules/FvwmCpp/FvwmCpp.c

   1 /* -*-c-*- */
   2 /* This module, and the entire FvwmCpp program, and the concept for
   3  * interfacing this module to the Window Manager, are all original work
   4  * by Robert Nation
   5  *
   6  * Copyright 1994, Robert Nation
   7  *  No guarantees or warantees or anything
   8  * are provided or implied in any way whatsoever. Use this program at your
   9  * own risk. Permission to use this program for any purpose is given,
  10  * as long as the copyright is kept intact. */
  11
  12 /* This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25  */
  26
  27 #include "config.h"
  28
  29 #include <stdio.h>
  30 #include <signal.h>
  31 #include <fcntl.h>
  32 #include <sys/wait.h>
  33 #include "libs/ftime.h"
  34 #include <unistd.h>
  35 #include <ctype.h>
  36 #include <pwd.h>
  37 #include <sys/param.h>
  38 #include <sys/types.h>
  39 #include <netdb.h>
  40
  41 #include <X11/Xlib.h>
  42 #include <X11/Xutil.h>
  43 #include <X11/Xproto.h>
  44 #include <X11/Xatom.h>
  45 #include <X11/Intrinsic.h>
  46
  47 #include "libs/Module.h"
  48 #include "libs/fvwm_sys_stat.h"
  49
  50 #include "FvwmCpp.h"
  51 #include "libs/fvwmlib.h"
  52 #include "libs/FShape.h"
  53 #include "libs/PictureBase.h"
  54 #include "libs/FSMlib.h"
  55 #include "libs/Strings.h"
  56 #include "libs/System.h"
  57 #include <X11/StringDefs.h>
  58 #include <X11/Shell.h>
  59 #define Resolution(pixels, mm) ((((pixels) * 2000 / (mm)) + 1) / 2)
  60
  61 char *MyName;
  62 int fd[2];
  63
  64 long Vx, Vy;
  65 static char *MkDef(char *name, char *def);
  66 static char *MkNum(char *name,int def);
  67 static char *cpp_defs(Display *display, const char *host, char *m4_options, char *config_file);
  68 #define MAXHOSTNAME 255
  69 #define EXTRA 20
  70
  71 char *cpp_prog = FVWM_CPP;          /* Name of the cpp program */
  72
  73 char cpp_options[BUFSIZ];
  74 char cpp_outfile[BUFSIZ]="";
  75
  76
  77 /*
  78  *
  79  *  Procedure:
  80  *      main - start of module
  81  *
  82  */
  83 int main(int argc, char **argv)
  84 {
  85   Display *dpy;                 /* which display are we talking to */
  86   char *temp, *s;
  87   char *display_name = NULL;
  88   char *filename = NULL;
  89   char *tmp_file;
  90   int i;
  91   int debug = 0;
  92   int lock = 0;
  93   int noread = 0;
  94   char *user_dir;
  95
  96   /* Figure out the working directory and go to it */
  97   user_dir = getenv("FVWM_USERDIR");
  98   if (user_dir != NULL)
  99   {
 100     if (chdir(user_dir) < 0)
 101       fprintf(stderr, "%s: <<Warning>> chdir to %s failed in cpp_defs",
 102               MyName, user_dir);
 103   }
 104
 105   sprintf(cpp_options, "-I'%s' ", FVWM_DATADIR);
 106
 107   /* Record the program name for error messages */
 108   temp = argv[0];
 109
 110   s=strrchr(argv[0], '/');
 111   if (s != NULL)
 112     temp = s + 1;
 113
 114   MyName = safemalloc(strlen(temp)+2);
 115   strcpy(MyName,"*");
 116   strcat(MyName, temp);
 117
 118   if(argc < 6)
 119     {
 120       fprintf(stderr,"%s Version %s should only be executed by fvwm!\n",MyName,
 121               VERSION);
 122       exit(1);
 123     }
 124
 125   /* We should exit if our fvwm pipes die */
 126   signal (SIGPIPE, DeadPipe);
 127
 128   fd[0] = atoi(argv[1]);
 129   fd[1] = atoi(argv[2]);
 130
 131   for(i=6;i<argc;i++)
 132     {
 133       /* leaving this in just in case-- any option starting with '-'
 134          will get passed on to cpp anyway */
 135       if(strcasecmp(argv[i],"-cppopt") == 0)
 136         {
 137           strcat(cpp_options, argv[++i]);
 138           strcat(cpp_options, " ");
 139         }
 140       else if (strcasecmp(argv[i], "-cppprog") == 0)
 141         {
 142           cpp_prog = argv[++i];
 143         }
 144       else if(strcasecmp(argv[i], "-outfile") == 0)
 145       {
 146         strcpy(cpp_outfile,argv[++i]);
 147       }
 148       else if(strcasecmp(argv[i], "-debug") == 0)
 149         {
 150           debug = 1;
 151         }
 152       else if(strcasecmp(argv[i], "-lock") == 0)
 153         {
 154           lock = 1;
 155         }
 156       else if(strcasecmp(argv[i], "-noread") == 0)
 157         {
 158           noread = 1;
 159         }
 160       else if (strncasecmp(argv[i],"-",1) == 0)
 161       {
 162         /* pass on any other arguments starting with '-' to cpp */
 163         strcat(cpp_options, argv[i]);
 164         strcat(cpp_options, " ");
 165       }
 166       else
 167         filename = argv[i];
 168     }
 169
 170   /* If we don't have a cpp, stop right now.  */
 171   if (!cpp_prog || cpp_prog[0] == '\0') {
 172     fprintf(stderr, "%s: no C preprocessor program specified\n", MyName);
 173     exit(1);
 174   }
 175
 176   if (!filename)
 177   {
 178     fprintf(stderr, "%s: no file specified.\n", MyName);
 179     exit(1);
 180   }
 181   for(i=0;i<strlen(filename);i++)
 182     if((filename[i] == '\n')||(filename[i] == '\r'))
 183       {
 184         filename[i] = 0;
 185       }
 186
 187   if (!(dpy = XOpenDisplay(display_name)))
 188     {
 189       fprintf(stderr,"%s: can't open display %s",
 190               MyName, XDisplayName(display_name));
 191       exit (1);
 192     }
 193
 194   /* set up G */
 195   PictureInitCMap(dpy);
 196
 197   /* tell fvwm we're running if -lock is not used */
 198   if (!lock)
 199     SendFinishedStartupNotification(fd);
 200
 201   tmp_file = cpp_defs(dpy, display_name,cpp_options, filename);
 202
 203   if (!noread)
 204   {
 205     char *read_string = CatString3("Read '", tmp_file, "'");
 206     SendText(fd, read_string, 0);
 207   }
 208
 209   /* tell fvwm to continue if -lock is used */
 210   if (lock)
 211     SendFinishedStartupNotification(fd);
 212
 213   /* For a debugging version, we may wish to omit this part. */
 214   /* I'll let some cpp advocates clean this up */
 215   if (!debug)
 216   {
 217     char *delete_string;
 218     char *delete_file = tmp_file;
 219     if (tmp_file[0] != '/' && user_dir != NULL)
 220     {
 221       delete_file = safestrdup(CatString3(user_dir, "/", tmp_file));
 222     }
 223     delete_string = CatString3("Exec exec /bin/rm '", delete_file, "'");
 224     SendText(fd, delete_string, 0);
 225   }
 226
 227   return 0;
 228 }
 229
 230
 231
 232 static char *cpp_defs(Display *display, const char *host, char *cpp_options, char *config_file)
 233 {
 234         Screen *screen;
 235         Visual *visual;
 236         char client[MAXHOSTNAME], server[MAXHOSTNAME], *colon;
 237         char ostype[BUFSIZ];
 238         char options[BUFSIZ];
 239         static char tmp_name[BUFSIZ];
 240         struct hostent *hostname;
 241         char *vc;                     /* Visual Class */
 242         FILE *tmpf;
 243         struct passwd *pwent;
 244         int fd;
 245         int ScreenWidth, ScreenHeight;
 246         int Mscreen;
 247
 248         /* Generate a temporary filename.  Honor the TMPDIR environment variable,
 249            if set. Hope nobody deletes this file! */
 250
 251         if (strlen(cpp_outfile) == 0)
 252         {
 253                 if ((vc=getenv("TMPDIR")))
 254                 {
 255                         strcpy(tmp_name, vc);
 256                 }
 257                 else
 258                 {
 259                         strcpy(tmp_name, "/tmp");
 260                 }
 261                 strcat(tmp_name, "/fvwmrcXXXXXX");
 262                 fd = fvwm_mkstemp(tmp_name);
 263                 if (fd == -1)
 264                 {
 265                         fprintf(
 266                                 stderr,
 267                                 "[FvwmCpp][cpp_def] fvwm_mkstemp failed %s\n",
 268                                 tmp_name);
 269                         exit(0377);
 270                 }
 271         }
 272         else
 273         {
 274                 strcpy(tmp_name,cpp_outfile);
 275                 /*
 276                  * check to make sure it doesn't exist already, to prevent
 277                  * security hole
 278                  */
 279                 /* first try to unlink it */
 280                 unlink(tmp_name);
 281                 fd = open(
 282                         tmp_name, O_WRONLY|O_EXCL|O_CREAT,
 283                         FVWM_S_IRUSR | FVWM_S_IWUSR);
 284                 if (fd < 0)
 285                 {
 286                         fprintf(
 287                                 stderr,
 288                                 "[FvwmCpp][cpp_defs] error opening file %s\n",
 289                                 tmp_name);
 290                         exit(0377);
 291                 }
 292         }
 293         close(fd);
 294
 295         /*
 296          * Create the appropriate command line to run cpp, and
 297          * open a pipe to the command.
 298          */
 299
 300         sprintf(options, "%s %s >%s\n", cpp_prog, cpp_options, tmp_name);
 301         tmpf = popen(options, "w");
 302         if (tmpf == NULL)
 303         {
 304                 fprintf(
 305                         stderr,
 306                         "[FvwmCpp][cpp_defs] Cannot open pipe to cpp\n");
 307                 exit(0377);
 308         }
 309
 310         gethostname(client,MAXHOSTNAME);
 311
 312         getostype  (ostype, sizeof ostype);
 313
 314         hostname = gethostbyname(client);
 315         strcpy(server, XDisplayName(host));
 316         colon = strchr(server, ':');
 317         if (colon != NULL) *colon = '\0';
 318         if ((server[0] == '\0') || (!strcmp(server, "unix")))
 319                 strcpy(server, client); /* must be connected to :0 or unix:0 */
 320
 321         /* TWM_TYPE is fvwm, for completeness */
 322
 323         fputs(MkDef("TWM_TYPE", "fvwm"), tmpf);
 324
 325         /* The machine running the X server */
 326         fputs(MkDef("SERVERHOST", server), tmpf);
 327         /* The machine running the window manager process */
 328         fputs(MkDef("CLIENTHOST", client), tmpf);
 329         if (hostname)
 330                 fputs(MkDef("HOSTNAME", (char *)hostname->h_name), tmpf);
 331         else
 332                 fputs(MkDef("HOSTNAME", (char *)client), tmpf);
 333
 334         fputs(MkDef("OSTYPE", ostype), tmpf);
 335
 336         pwent=getpwuid(geteuid());
 337         fputs(MkDef("USER", pwent->pw_name), tmpf);
 338
 339         fputs(MkDef("HOME", getenv("HOME")), tmpf);
 340         fputs(MkNum("VERSION", ProtocolVersion(display)), tmpf);
 341         fputs(MkNum("REVISION", ProtocolRevision(display)), tmpf);
 342         fputs(MkDef("VENDOR", ServerVendor(display)), tmpf);
 343         fputs(MkNum("RELEASE", VendorRelease(display)), tmpf);
 344
 345         Mscreen= DefaultScreen(display);
 346         fputs(MkNum("SCREEN", Mscreen), tmpf);
 347
 348         ScreenWidth = DisplayWidth(display,Mscreen);
 349         ScreenHeight = DisplayHeight(display,Mscreen);
 350         fputs(MkNum("WIDTH", DisplayWidth(display,Mscreen)), tmpf);
 351         fputs(MkNum("HEIGHT", DisplayHeight(display,Mscreen)), tmpf);
 352
 353         screen = ScreenOfDisplay(display, Mscreen);
 354         fputs(MkNum("X_RESOLUTION",Resolution(screen->width,screen->mwidth)),
 355               tmpf);
 356         fputs(MkNum("Y_RESOLUTION",Resolution(screen->height,screen->mheight)),
 357               tmpf);
 358         fputs(MkNum("PLANES",DisplayPlanes(display, Mscreen)), tmpf);
 359
 360         visual = DefaultVisualOfScreen(screen);
 361         fputs(MkNum("BITS_PER_RGB", visual->bits_per_rgb), tmpf);
 362
 363         switch(visual->class)
 364         {
 365         case(StaticGray):
 366                 vc = "StaticGray";
 367                 break;
 368         case(GrayScale):
 369                 vc = "GrayScale";
 370                 break;
 371         case(StaticColor):
 372                 vc = "StaticColor";
 373                 break;
 374         case(PseudoColor):
 375                 vc = "PseudoColor";
 376                 break;
 377         case(TrueColor):
 378                 vc = "TrueColor";
 379                 break;
 380         case(DirectColor):
 381                 vc = "DirectColor";
 382                 break;
 383         default:
 384                 vc = "NonStandard";
 385                 break;
 386         }
 387         fputs(MkDef("CLASS", vc), tmpf);
 388
 389         switch(Pvisual->class)
 390         {
 391         case(StaticGray):
 392                 vc = "StaticGray";
 393                 break;
 394         case(GrayScale):
 395                 vc = "GrayScale";
 396                 break;
 397         case(StaticColor):
 398                 vc = "StaticColor";
 399                 break;
 400         case(PseudoColor):
 401                 vc = "PseudoColor";
 402                 break;
 403         case(TrueColor):
 404                 vc = "TrueColor";
 405                 break;
 406         case(DirectColor):
 407                 vc = "DirectColor";
 408                 break;
 409         default:
 410                 vc = "NonStandard";
 411                 break;
 412         }
 413         fputs(MkDef("FVWM_CLASS", vc), tmpf);
 414
 415         if (visual->class != StaticGray && visual->class != GrayScale)
 416                 fputs(MkDef("COLOR", "Yes"), tmpf);
 417         else
 418                 fputs(MkDef("COLOR", "No"), tmpf);
 419
 420         if (Pvisual->class != StaticGray && Pvisual->class != GrayScale)
 421                 fputs(MkDef("FVWM_COLOR", "Yes"), tmpf);
 422         else
 423                 fputs(MkDef("FVWM_COLOR", "No"), tmpf);
 424
 425         fputs(MkDef("FVWM_VERSION", VERSION), tmpf);
 426
 427         /* Add options together */
 428         *options = '\0';
 429         if (FHaveShapeExtension)
 430                 strcat(options, "SHAPE ");
 431
 432         if (XpmSupport)
 433                 strcat(options, "XPM ");
 434
 435         strcat(options, "Cpp ");
 436
 437         fputs(MkDef("OPTIONS", options), tmpf);
 438
 439         fputs(MkDef("FVWM_MODULEDIR", FVWM_MODULEDIR), tmpf);
 440         fputs(MkDef("FVWM_DATADIR", FVWM_DATADIR), tmpf);
 441
 442         if ((vc = getenv("FVWM_USERDIR")))
 443                 fputs(MkDef("FVWM_USERDIR", vc), tmpf);
 444
 445         if (SessionSupport && (vc = getenv("SESSION_MANAGER")))
 446                 fputs(MkDef("SESSION_MANAGER", vc), tmpf);
 447
 448
 449         /*
 450          * At this point, we've sent the definitions to cpp.  Just include
 451          * the fvwmrc file now.
 452          */
 453
 454         fprintf(tmpf, "#include \"%s\"\n", config_file);
 455
 456         pclose(tmpf);
 457         return(tmp_name);
 458 }
 459
 460
 461
 462
 463
 464 /*
 465  *
 466  *  Procedure:
 467  *      SIGPIPE handler - SIGPIPE means fvwm is dying
 468  *
 469  */
 470 RETSIGTYPE DeadPipe(int nonsense)
 471 {
 472   exit(0);
 473   SIGNAL_RETURN;
 474 }
 475
 476 static char *MkDef(char *name, char *def)
 477 {
 478   char *cp = NULL;
 479   int n;
 480
 481   /* Get space to hold everything, if needed */
 482
 483   n = EXTRA + strlen(name) + strlen(def);
 484   cp = safemalloc(n);
 485
 486   sprintf(cp, "#define %s %s\n",name,def);
 487
 488   return(cp);
 489 }
 490
 491 static char *MkNum(char *name,int def)
 492 {
 493   char num[20];
 494
 495   sprintf(num, "%d", def);
 496
 497   return(MkDef(name, num));
 498 }