libs/System.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  * System.c: code for dealing with various OS system call variants
  19  */
  20
  21 #include "config.h"
  22 #include "fvwmlib.h"
  23 #include "envvar.h"
  24 #include "System.h"
  25 #include "Strings.h"
  26
  27 #if HAVE_UNAME
  28 #include <sys/utsname.h>
  29 #endif
  30 #include "libs/fvwm_sys_stat.h"
  31
  32 #if HAVE_SYS_SELECT_H
  33 #include <sys/select.h>
  34 #endif
  35
  36
  37 /*
  38  * just in case...
  39  */
  40 #ifndef FD_SETSIZE
  41 #define FD_SETSIZE 2048
  42 #endif
  43
  44
  45 fd_set_size_t fvwmlib_max_fd = (fd_set_size_t)-9999999;
  46
  47 fd_set_size_t GetFdWidth(void)
  48 {
  49 #if HAVE_SYSCONF
  50         return min(sysconf(_SC_OPEN_MAX),FD_SETSIZE);
  51 #else
  52         return min(getdtablesize(),FD_SETSIZE);
  53 #endif
  54 }
  55
  56 void fvwmlib_init_max_fd(void)
  57 {
  58         fvwmlib_max_fd = GetFdWidth();
  59
  60         return;
  61 }
  62
  63
  64 /* return a string indicating the OS type (i.e. "Linux", "SINIX-D", ... ) */
  65 int getostype(char *buf, int max)
  66 {
  67 #if HAVE_UNAME
  68         struct utsname sysname;
  69
  70         if (uname( &sysname ) >= 0)
  71         {
  72                 buf[0] = '\0';
  73                 strncat(buf, sysname.sysname, max);
  74                 return 0;
  75         }
  76 #endif
  77         strcpy (buf, "");
  78         return -1;
  79 }
  80
  81
  82 /*
  83  * Set a colon-separated path, with environment variable expansions,
  84  * and expand '+' to be the value of the previous path.
  85  */
  86 void setPath(char **p_path, const char *newpath, int free_old_path)
  87 {
  88         char *oldpath = *p_path;
  89         int oldlen = strlen(oldpath);
  90         char *stripped_path = stripcpy(newpath);
  91         int found_plus = strchr(newpath, '+') != NULL;
  92
  93         /* Leave room for the old path, if we find a '+' in newpath */
  94         *p_path = envDupExpand(stripped_path, found_plus ? oldlen - 1 : 0);
  95         free(stripped_path);
  96
  97         if (found_plus)
  98         {
  99                 char *p = strchr(*p_path, '+');
 100                 memmove(p + oldlen, p + 1, strlen(p + 1) + 1);
 101                 memmove(p, oldpath, oldlen);
 102         }
 103
 104         if (free_old_path)
 105         {
 106                 free(oldpath);
 107         }
 108 }
 109
 110
 111 /*
 112  *
 113  * Find the specified file somewhere along the given path.
 114  *
 115  * There is a possible race condition here:  We check the file and later
 116  * do something with it.  By then, the file might not be accessible.
 117  * Oh well.
 118  *
 119  */
 120 #include <stdio.h>
 121 char *searchPath(
 122         const char *pathlist, const char *filename, const char *suffix,
 123         int type)
 124 {
 125         char *path;
 126         int filename_len;
 127         int maxpath_len;
 128
 129         if (filename == NULL || *filename == 0)
 130         {
 131                 return NULL;
 132         }
 133
 134         if (pathlist == NULL || *pathlist == 0)
 135         {
 136                 /* use pwd if no path list is given */
 137                 pathlist = ".";
 138         }
 139
 140         filename_len = strlen(filename);
 141         maxpath_len = (pathlist) ? strlen(pathlist) : 0;
 142         maxpath_len += (suffix) ? strlen(suffix) : 0;
 143
 144         /* +1 for extra / and +1 for null termination */
 145         path = safemalloc(maxpath_len + filename_len + 2);
 146         *path = '\0';
 147
 148         if (*filename == '/')
 149         {
 150                 /* No search if filename begins with a slash */
 151                 strcpy(path, filename);
 152
 153                 /* test if the path is accessable -- the module code assumes
 154                  * this is done */
 155                 if (access(filename, type) == 0)
 156                 {
 157                         return path;
 158                 }
 159
 160                 /* the file is not accessable (don't test suffixes with full
 161                  * path), return NULL */
 162                 free(path);
 163
 164                 return NULL;
 165         }
 166
 167         /* Search each element of the pathlist for the file */
 168         while (pathlist && *pathlist)
 169         {
 170                 char *path_end = strchr(pathlist, ':');
 171                 char *curr_end;
 172
 173                 if (path_end != NULL)
 174                 {
 175                         strncpy(path, pathlist, path_end - pathlist);
 176                         path[path_end - pathlist] = '\0';
 177                 }
 178                 else
 179                 {
 180                         strcpy(path, pathlist);
 181                 }
 182
 183                 /* handle specially the path extention using semicolon */
 184                 curr_end = strchr(path, ';');
 185                 if (curr_end != NULL)
 186                 {
 187                         char *dot = strrchr(filename, '.');
 188                         int filebase_len;
 189                         /* count a leading nil in newext_len too */
 190                         int newext_len = path + strlen(path) - curr_end;
 191                         if (dot != NULL)
 192                         {
 193                                 filebase_len = dot - filename;
 194                         }
 195                         else
 196                         {
 197                                 filebase_len = filename_len;
 198                         }
 199                         *(curr_end++) = '/';
 200                         memmove(curr_end + filebase_len, curr_end, newext_len);
 201                         strncpy(curr_end, filename, filebase_len);
 202                 }
 203                 else
 204                 {
 205                         strcat(path, "/");
 206                         strcat(path, filename);
 207                 }
 208
 209                 if (access(path, type) == 0)
 210                 {
 211                         return path;
 212                 }
 213
 214                 if (suffix && *suffix != '\0') {
 215                         strcat(path, suffix);
 216                         if (access(path, type) == 0)
 217                         {
 218                                 return path;
 219                         }
 220                 }
 221
 222                 /* Point to next element of the path */
 223                 if (path_end == NULL)
 224                 {
 225                         break;
 226                 }
 227                 else
 228                 {
 229                         pathlist = path_end + 1;
 230                 }
 231         }
 232
 233         /* Hmm, couldn't find the file.  Return NULL */
 234         free(path);
 235         return NULL;
 236 }
 237
 238 /*
 239  * void setFileStamp(FileStamp *stamp, const char *name);
 240  * Bool isFileStampChanged(const FileStamp *stamp, const char *name);
 241  *
 242  * An interface for verifying cached files.
 243  * The first function associates a file stamp with file (named by name).
 244  * The second function returns True or False in case the file was changed
 245  * from the time the stamp was associated.
 246  *
 247  * FileStamp can be a structure; try to save memory by evaluating a checksum.
 248  */
 249
 250 FileStamp getFileStamp(const char *name)
 251 {
 252         static struct stat buf;
 253
 254         if (!name || stat(name, &buf))
 255         {
 256                 return 0;
 257         }
 258         return ((FileStamp)buf.st_mtime << 13) + (FileStamp)buf.st_size;
 259 }
 260
 261 void setFileStamp(FileStamp *stamp, const char *name)
 262 {
 263         *stamp = getFileStamp(name);
 264 }
 265
 266 Bool isFileStampChanged(const FileStamp *stamp, const char *name)
 267 {
 268         return *stamp != getFileStamp(name);
 269 }
 270
 271 #ifdef HAVE_SAFETY_MKSTEMP
 272 int fvwm_mkstemp (char *TEMPLATE)
 273 {
 274         return mkstemp(TEMPLATE);
 275 }
 276 #else
 277
 278 /* This function is an adaptation of the mkstemp() function included
 279  * in the Gnu C Library, version 2.2.2. The Gnu C library, in turn,
 280  * adapted the function from OpenBSD.
 281  * Michael Han <mikehan@mikehan.com> */
 282
 283 #include <stdio.h>
 284 #include <errno.h>
 285 #include <sys/types.h>
 286 #include <sys/stat.h>
 287 #include <fcntl.h>
 288 #include <unistd.h>
 289 #include "ftime.h"
 290
 291 #define __set_errno(val) errno = (val)
 292
 293 /* These are the characters used in temporary filenames.  */
 294 static const char letters[] =
 295 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 296
 297 /* Generate a unique temporary file name from TEMPLATE.
 298    The last six characters of TEMPLATE must be "XXXXXX";
 299    they are replaced with a string that makes the filename unique.
 300    Then open the file and return a fd. */
 301
 302 int fvwm_mkstemp (char *template)
 303 {
 304         int len;
 305         char *XXXXXX;
 306         static unsigned long value;
 307         struct timeval tv;
 308         int count, fd = -1;
 309         int save_errno = errno;
 310
 311         len = strlen (template);
 312         if (len < 6 || strcmp (&template[len - 6], "XXXXXX"))
 313         {
 314                 __set_errno (EINVAL);
 315                 return -1;
 316         }
 317
 318         /* This is where the Xs start.  */
 319         XXXXXX = &template[len - 6];
 320
 321         /* Get some more or less random data.  */
 322         gettimeofday (&tv, NULL);
 323         value = ((unsigned long) tv.tv_usec << 16) ^ tv.tv_sec ^ getpid ();
 324
 325         for (count = 0; count < TMP_MAX; value = 7777, count)
 326         {
 327                 unsigned long v = value;
 328
 329                 /* Fill in the random bits.  */
 330                 XXXXXX[0] = letters[v % 62];
 331                 v /= 62;
 332                 XXXXXX[1] = letters[v % 62];
 333                 v /= 62;
 334                 XXXXXX[2] = letters[v % 62];
 335                 v /= 62;
 336                 XXXXXX[3] = letters[v % 62];
 337                 v /= 62;
 338                 XXXXXX[4] = letters[v % 62];
 339                 v /= 62;
 340                 XXXXXX[5] = letters[v % 62];
 341
 342                 fd = open(
 343                         template, O_RDWR | O_CREAT | O_EXCL,
 344                         FVWM_S_IRUSR | FVWM_S_IWUSR);
 345                 if (fd >= 0)
 346                 {
 347                         __set_errno (save_errno);
 348                         return fd;
 349                 }
 350                 else if (errno != EEXIST)
 351                 {
 352                         return -1;
 353                 }
 354         }
 355
 356         /* We got out of the loop because we ran out of combinations to try.  */
 357         __set_errno (EEXIST);
 358         return -1;
 359 }
 360
 361 #endif /* HAVE_SAFETY_MKSTEMP */