modules/FvwmIconMan/FvwmIconMan.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 #include "config.h"
  18
  19 #include <unistd.h>
  20 #include <signal.h>
  21 #include <errno.h>
  22 #include "FvwmIconMan.h"
  23 #include "readconfig.h"
  24 #include "x.h"
  25 #include "xmanager.h"
  26
  27 #include "libs/fvwmsignal.h"
  28 #include "libs/Module.h"
  29 #include "libs/FTips.h"
  30 #include "libs/Parse.h"
  31
  32
  33 char *MyName;
  34 FlocaleWinString *FwinString;
  35 int mods_unused = DEFAULT_MODS_UNUSED;
  36
  37 static RETSIGTYPE TerminateHandler(int);
  38
  39 char *copy_string(char **target, const char *src)
  40 {
  41         int len;
  42         if (src == NULL)
  43         {
  44                 len = 0;
  45                 if (*target)
  46                 {
  47                         Free(*target);
  48                 }
  49                 return *target = NULL;
  50         }
  51
  52         len = strlen(src);
  53         ConsoleDebug(CORE, "copy_string: 1: 0x%lx\n", (unsigned long)*target);
  54
  55         if (*target)
  56         {
  57                 Free(*target);
  58         }
  59
  60         ConsoleDebug(CORE, "copy_string: 2\n");
  61         *target = (char *)safemalloc((len + 1) * sizeof(char));
  62         strcpy(*target, src);
  63         ConsoleDebug(CORE, "copy_string: 3\n");
  64         return *target;
  65 }
  66
  67 #ifdef TRACE_MEMUSE
  68
  69 long MemUsed = 0;
  70
  71 void Free(void *p)
  72 {
  73         struct malloc_header *head = (struct malloc_header *)p;
  74
  75         if (p != NULL)
  76         {
  77                 head--;
  78                 if (head->magic != MALLOC_MAGIC)
  79                 {
  80                         fprintf(stderr, "Corrupted memory found in Free\n");
  81                         abort();
  82                         return;
  83                 }
  84                 if (head->len > MemUsed)
  85                 {
  86                         fprintf(stderr, "Free block too big\n");
  87                         return;
  88                 }
  89                 MemUsed -= head->len;
  90                 Free(head);
  91         }
  92 }
  93
  94 void PrintMemuse(void)
  95 {
  96         ConsoleDebug(CORE, "Memory used: %ld\n", MemUsed);
  97 }
  98
  99 #else
 100
 101 void Free(void *p)
 102 {
 103         if (p != NULL)
 104         {
 105                 free(p);
 106         }
 107 }
 108
 109 void PrintMemuse(void)
 110 {
 111 }
 112
 113 #endif
 114
 115
 116 static RETSIGTYPE
 117 TerminateHandler(int sig)
 118 {
 119         fvwmSetTerminate(sig);
 120         SIGNAL_RETURN;
 121 }
 122
 123
 124 void
 125 ShutMeDown(int flag)
 126 {
 127         ConsoleDebug(CORE, "Bye Bye\n");
 128         exit(flag);
 129 }
 130
 131 void
 132 DeadPipe(int nothing)
 133 {
 134         (void)nothing;
 135         ShutMeDown(0);
 136         SIGNAL_RETURN;
 137 }
 138
 139 static void
 140 main_loop(void)
 141 {
 142         fd_set readset, saveset;
 143         fd_set_size_t fd_width = x_fd;
 144         unsigned long ms;
 145         struct timeval tv;
 146
 147         /*
 148          * Calculate which is descriptor is numerically higher:
 149          * this determines how wide the descriptor set needs to be ...
 150          */
 151         if (fd_width < fvwm_fd[1])
 152         {
 153                 fd_width = fvwm_fd[1];
 154         }
 155         ++fd_width;
 156
 157         FD_ZERO(&saveset);
 158         FD_SET(fvwm_fd[1], &saveset);
 159         FD_SET(x_fd, &saveset);
 160
 161         tv.tv_sec  = 60;
 162         tv.tv_usec = 0;
 163
 164         while (!isTerminated)
 165         {
 166                 /* Check the pipes for anything to read, and block if
 167                  * there is nothing there yet ...
 168                  */
 169                 readset = saveset;
 170
 171                 if (fvwmSelect(fd_width, &readset, NULL, NULL, &tv) < 0)
 172                 {
 173                         ConsoleMessage(
 174                                 "Internal error with select: errno=%s\n",
 175                                 strerror(errno));
 176                 }
 177                 else
 178                 {
 179
 180                         if (FD_ISSET(x_fd, &readset) || FPending(theDisplay))
 181                         {
 182                                 xevent_loop();
 183                         }
 184                         if (FD_ISSET(fvwm_fd[1], &readset))
 185                         {
 186                                 ReadFvwmPipe();
 187                         }
 188
 189                 }
 190                 if ((ms = FTipsCheck(theDisplay)))
 191                 {
 192                         tv.tv_sec  = ms / 1000;
 193                         tv.tv_usec = (ms % 1000) * 1000;
 194                 }
 195                 else
 196                 {
 197                         tv.tv_sec  = 60;
 198                         tv.tv_usec = 0;
 199                 }
 200         } /* while */
 201 }
 202
 203 int
 204 main(int argc, char **argv)
 205 {
 206         int i;
 207
 208 #ifdef HAVE_LIBEFENCE
 209         extern int EF_PROTECT_BELOW, EF_PROTECT_FREE;
 210
 211         EF_PROTECT_BELOW = 1;
 212         EF_PROTECT_FREE = 1;
 213 #endif
 214
 215         FlocaleInit(LC_CTYPE, "", "", "FvwmIconMan");
 216
 217         OpenConsole(OUTPUT_FILE);
 218
 219         init_globals();
 220         init_winlists();
 221
 222         MyName = GetFileNameFromPath(argv[0]);
 223
 224         if (argc == 7)
 225         {
 226                 if (strcasecmp(argv[6], "Transient")==0 ||
 227                         strcasecmp(argv[6], "-Transient") == 0)
 228                 {
 229                         globals.transient = 1;
 230                 }
 231                 else
 232                 {
 233                         MyName = argv[6];
 234                 }
 235         }
 236         ModuleLen = strlen(MyName) + 1;
 237         Module = safemalloc(ModuleLen+1);
 238         *Module = '*';
 239         strcpy(Module+1, MyName);
 240
 241         if (argc < 6)
 242         {
 243                 fprintf(stderr,
 244                         "%s version %s should only be executed by fvwm!\n",
 245                         MyName, VERSION);
 246                 ShutMeDown(1);
 247         }
 248         fvwm_fd[0] = atoi(argv[1]);
 249         fvwm_fd[1] = atoi(argv[2]);
 250         init_display();
 251
 252 #ifdef HAVE_SIGACTION
 253         {
 254                 struct sigaction  sigact;
 255
 256                 sigemptyset(&sigact.sa_mask);
 257                 sigaddset(&sigact.sa_mask, SIGPIPE);
 258                 sigaddset(&sigact.sa_mask, SIGINT);
 259                 sigaddset(&sigact.sa_mask, SIGHUP);
 260                 sigaddset(&sigact.sa_mask, SIGTERM);
 261                 sigaddset(&sigact.sa_mask, SIGQUIT);
 262 # ifdef SA_RESTART
 263                 sigact.sa_flags = SA_RESTART;
 264 # else
 265                 sigact.sa_flags = 0;
 266 # endif
 267                 sigact.sa_handler = TerminateHandler;
 268
 269                 sigaction(SIGPIPE, &sigact, NULL);
 270                 sigaction(SIGINT,  &sigact, NULL);
 271                 sigaction(SIGHUP,  &sigact, NULL);
 272                 sigaction(SIGTERM, &sigact, NULL);
 273                 sigaction(SIGQUIT, &sigact, NULL);
 274         }
 275 #else
 276         /* We don't have sigaction(), so fall back to less robust methods. */
 277 #ifdef USE_BSD_SIGNALS
 278         fvwmSetSignalMask(
 279                 sigmask(SIGPIPE) |
 280                 sigmask(SIGINT) |
 281                 sigmask(SIGHUP) |
 282                 sigmask(SIGTERM) |
 283                 sigmask(SIGQUIT));
 284 #endif
 285         signal(SIGPIPE, TerminateHandler);
 286         signal(SIGINT,  TerminateHandler);
 287         signal(SIGHUP,  TerminateHandler);
 288         signal(SIGTERM, TerminateHandler);
 289         signal(SIGQUIT, TerminateHandler);
 290 #ifdef HAVE_SIGINTERRUPT
 291         siginterrupt(SIGPIPE, 0);
 292         siginterrupt(SIGINT, 0);
 293         siginterrupt(SIGHUP, 0);
 294         siginterrupt(SIGTERM, 0);
 295         siginterrupt(SIGQUIT, 0);
 296 #endif
 297 #endif
 298
 299         read_in_resources();
 300         FlocaleAllocateWinString(&FwinString);
 301
 302         for (i = 0; i < globals.num_managers; i++)
 303         {
 304                 X_init_manager(i);
 305         }
 306
 307         assert(globals.managers);
 308
 309         SetMessageMask(
 310                 fvwm_fd, M_CONFIGURE_WINDOW | M_RES_CLASS | M_RES_NAME |
 311                 M_ADD_WINDOW | M_DESTROY_WINDOW | M_ICON_NAME |
 312                 M_DEICONIFY | M_ICONIFY | M_ICON_LOCATION | M_END_WINDOWLIST |
 313                 M_NEW_DESK | M_NEW_PAGE | M_FOCUS_CHANGE | M_WINDOW_NAME |
 314                 M_CONFIG_INFO | M_SENDCONFIG | M_VISIBLE_NAME |
 315                 M_MINI_ICON | M_STRING | M_WINDOWSHADE | M_DEWINDOWSHADE);
 316   /* extended messages */
 317   SetMessageMask(fvwm_fd, MX_VISIBLE_ICON_NAME | MX_PROPERTY_CHANGE);
 318
 319   SendText(fvwm_fd, "Send_WindowList", 0);
 320
 321   /* tell fvwm we're running */
 322   SendFinishedStartupNotification(fvwm_fd);
 323
 324   /* Lock on send only for iconify and deiconify (for NoIconAction) */
 325   SetSyncMask(fvwm_fd, M_DEICONIFY | M_ICONIFY);
 326   SetNoGrabMask(fvwm_fd, M_DEICONIFY | M_ICONIFY);
 327
 328   main_loop();
 329
 330   return 0;
 331 }