libs/wine/config.c

   1 /*
   2  * Configuration parameters shared between Wine server and clients
   3  *
   4  * Copyright 2002 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdio.h>
  25 #include <stdarg.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <errno.h>
  29 #include <sys/stat.h>
  30 #ifdef HAVE_UNISTD_H
  31 # include <unistd.h>
  32 #endif
  33 #ifdef HAVE_PWD_H
  34 #include <pwd.h>
  35 #endif
  36 #include "wine/library.h"
  37
  38 static const char server_config_dir[] = "/.wine";        /* config dir relative to $HOME */
  39 static const char server_root_prefix[] = "/tmp/.wine-";  /* prefix for server root dir */
  40 static const char server_dir_prefix[] = "/server-";      /* prefix for server dir */
  41
  42 static char *bindir;
  43 static char *dlldir;
  44 static char *datadir;
  45 static char *config_dir;
  46 static char *server_dir;
  47 static char *build_dir;
  48 static char *user_name;
  49 static char *argv0_name;
  50
  51 #ifdef __GNUC__
  52 static void fatal_error( const char *err, ... )  __attribute__((noreturn,format(printf,1,2)));
  53 static void fatal_perror( const char *err, ... )  __attribute__((noreturn,format(printf,1,2)));
  54 #endif
  55
  56 /* die on a fatal error */
  57 static void fatal_error( const char *err, ... )
  58 {
  59     va_list args;
  60
  61     va_start( args, err );
  62     fprintf( stderr, "wine: " );
  63     vfprintf( stderr, err, args );
  64     va_end( args );
  65     exit(1);
  66 }
  67
  68 /* die on a fatal error */
  69 static void fatal_perror( const char *err, ... )
  70 {
  71     va_list args;
  72
  73     va_start( args, err );
  74     fprintf( stderr, "wine: " );
  75     vfprintf( stderr, err, args );
  76     perror( " " );
  77     va_end( args );
  78     exit(1);
  79 }
  80
  81 /* malloc wrapper */
  82 static void *xmalloc( size_t size )
  83 {
  84     void *res;
  85
  86     if (!size) size = 1;
  87     if (!(res = malloc( size ))) fatal_error( "virtual memory exhausted\n");
  88     return res;
  89 }
  90
  91 /* strdup wrapper */
  92 static char *xstrdup( const char *str )
  93 {
  94     size_t len = strlen(str) + 1;
  95     char *res = xmalloc( len );
  96     memcpy( res, str, len );
  97     return res;
  98 }
  99
 100 /* remove all trailing slashes from a path name */
 101 static inline void remove_trailing_slashes( char *path )
 102 {
 103     int len = strlen( path );
 104     while (len > 1 && path[len-1] == '/') path[--len] = 0;
 105 }
 106
 107 /* build a path from the specified dir and name */
 108 static char *build_path( const char *dir, const char *name )
 109 {
 110     size_t len = strlen(dir);
 111     char *ret = xmalloc( len + strlen(name) + 2 );
 112
 113     memcpy( ret, dir, len );
 114     if (len && ret[len-1] != '/') ret[len++] = '/';
 115     strcpy( ret + len, name );
 116     return ret;
 117 }
 118
 119 /* return the directory that contains the library at run-time */
 120 static char *get_runtime_libdir(void)
 121 {
 122 #ifdef HAVE_DLADDR
 123     Dl_info info;
 124     char *libdir;
 125
 126     if (dladdr( get_runtime_libdir, &info ) && info.dli_fname[0] == '/')
 127     {
 128         const char *p = strrchr( info.dli_fname, '/' );
 129         unsigned int len = p - info.dli_fname;
 130         if (!len) len++;  /* include initial slash */
 131         libdir = xmalloc( len + 1 );
 132         memcpy( libdir, info.dli_fname, len );
 133         libdir[len] = 0;
 134         return libdir;
 135     }
 136 #endif /* HAVE_DLADDR */
 137     return NULL;
 138 }
 139
 140 /* initialize the server directory value */
 141 static void init_server_dir( dev_t dev, ino_t ino )
 142 {
 143     char *p;
 144 #ifdef HAVE_GETUID
 145     const unsigned int uid = getuid();
 146 #else
 147     const unsigned int uid = 0;
 148 #endif
 149
 150     server_dir = xmalloc( sizeof(server_root_prefix) + 32 + sizeof(server_dir_prefix) +
 151                           2*sizeof(dev) + 2*sizeof(ino) );
 152     sprintf( server_dir, "%s%u%s", server_root_prefix, uid, server_dir_prefix );
 153     p = server_dir + strlen(server_dir);
 154
 155     if (sizeof(dev) > sizeof(unsigned long) && dev > ~0UL)
 156         p += sprintf( p, "%lx%08lx-", (unsigned long)((unsigned long long)dev >> 32), (unsigned long)dev );
 157     else
 158         p += sprintf( p, "%lx-", (unsigned long)dev );
 159
 160     if (sizeof(ino) > sizeof(unsigned long) && ino > ~0UL)
 161         sprintf( p, "%lx%08lx", (unsigned long)((unsigned long long)ino >> 32), (unsigned long)ino );
 162     else
 163         sprintf( p, "%lx", (unsigned long)ino );
 164 }
 165
 166 /* retrieve the default dll dir */
 167 const char *get_dlldir( const char **default_dlldir )
 168 {
 169     *default_dlldir = DLLDIR;
 170     return dlldir;
 171 }
 172
 173 /* initialize all the paths values */
 174 static void init_paths(void)
 175 {
 176     struct stat st;
 177
 178     const char *home = getenv( "HOME" );
 179     const char *user = NULL;
 180     const char *prefix = getenv( "WINEPREFIX" );
 181
 182 #ifdef HAVE_GETPWUID
 183     char uid_str[32];
 184     struct passwd *pwd = getpwuid( getuid() );
 185
 186     if (pwd)
 187     {
 188         user = pwd->pw_name;
 189         if (!home) home = pwd->pw_dir;
 190     }
 191     if (!user)
 192     {
 193         sprintf( uid_str, "%lu", (unsigned long)getuid() );
 194         user = uid_str;
 195     }
 196 #else  /* HAVE_GETPWUID */
 197     if (!(user = getenv( "USER" )))
 198         fatal_error( "cannot determine your user name, set the USER environment variable\n" );
 199 #endif  /* HAVE_GETPWUID */
 200     user_name = xstrdup( user );
 201
 202     /* build config_dir */
 203
 204     if (prefix)
 205     {
 206         config_dir = xstrdup( prefix );
 207         remove_trailing_slashes( config_dir );
 208         if (config_dir[0] != '/')
 209             fatal_error( "invalid directory %s in WINEPREFIX: not an absolute path\n", prefix );
 210         if (stat( config_dir, &st ) == -1)
 211         {
 212             if (errno != ENOENT)
 213                 fatal_perror( "cannot open %s as specified in WINEPREFIX", config_dir );
 214             fatal_error( "the '%s' directory specified in WINEPREFIX doesn't exist.\n"
 215                          "You may want to create it by running 'wineprefixcreate'.\n", config_dir );
 216         }
 217     }
 218     else
 219     {
 220         if (!home) fatal_error( "could not determine your home directory\n" );
 221         if (home[0] != '/') fatal_error( "your home directory %s is not an absolute path\n", home );
 222         config_dir = xmalloc( strlen(home) + sizeof(server_config_dir) );
 223         strcpy( config_dir, home );
 224         remove_trailing_slashes( config_dir );
 225         strcat( config_dir, server_config_dir );
 226         if (stat( config_dir, &st ) == -1)
 227         {
 228             if (errno == ENOENT) return;  /* will be created later on */
 229             fatal_perror( "cannot open %s", config_dir );
 230         }
 231     }
 232     if (!S_ISDIR(st.st_mode)) fatal_error( "%s is not a directory\n", config_dir );
 233 #ifdef HAVE_GETUID
 234     if (st.st_uid != getuid()) fatal_error( "%s is not owned by you\n", config_dir );
 235 #endif
 236
 237     init_server_dir( st.st_dev, st.st_ino );
 238 }
 239
 240 /* check if basedir is a valid build dir by checking for wineserver and ntdll */
 241 /* helper for running_from_build_dir */
 242 static inline int is_valid_build_dir( char *basedir, int baselen )
 243 {
 244     struct stat st;
 245
 246     strcpy( basedir + baselen, "/server/wineserver" );
 247     if (stat( basedir, &st ) == -1) return 0;  /* no wineserver found */
 248     /* check for ntdll too to make sure */
 249     strcpy( basedir + baselen, "/dlls/ntdll/ntdll.dll.so" );
 250     if (stat( basedir, &st ) == -1) return 0;  /* no ntdll found */
 251
 252     basedir[baselen] = 0;
 253     return 1;
 254 }
 255
 256 /* check if we are running from the build directory */
 257 static char *running_from_build_dir( const char *basedir, const char *bindir )
 258 {
 259     struct stat st;
 260     const char *p;
 261     char *path;
 262     int res;
 263
 264     if (!(path = build_path( bindir, "wineserver" ))) return NULL;
 265     res = stat( path, &st );
 266     free( path );
 267     if (res != -1) return NULL;  /* the real bindir is valid */
 268
 269     /* remove last component from basedir */
 270     p = basedir + strlen(basedir) - 1;
 271     while (p > basedir && *p == '/') p--;
 272     while (p > basedir && *p != '/') p--;
 273     if (p == basedir) return NULL;
 274     path = xmalloc( p - basedir + sizeof("/dlls/ntdll/ntdll.dll.so") );
 275     memcpy( path, basedir, p - basedir );
 276
 277     if (!is_valid_build_dir( path, p - basedir ))
 278     {
 279         /* remove another component */
 280         while (p > basedir && *p == '/') p--;
 281         while (p > basedir && *p != '/') p--;
 282         if (p == basedir || !is_valid_build_dir( path, p - basedir ))
 283         {
 284             free( path );
 285             return NULL;
 286         }
 287     }
 288     return path;
 289 }
 290
 291 /* initialize the argv0 path */
 292 void wine_init_argv0_path( const char *argv0 )
 293 {
 294     size_t size, len;
 295     const char *p, *basename;
 296     char *cwd, *libdir;
 297
 298     if (!(p = strrchr( argv0, '/' )))
 299         basename = argv0;
 300     else
 301         basename = p + 1;
 302
 303     argv0_name = xstrdup( basename );
 304
 305     if ((libdir = get_runtime_libdir()))
 306     {
 307         bindir = build_path( libdir, LIB_TO_BINDIR );
 308         if ((build_dir = running_from_build_dir( libdir, bindir )))
 309         {
 310             free( libdir );
 311             goto in_build_dir;
 312         }
 313         dlldir = build_path( libdir, LIB_TO_DLLDIR );
 314         datadir = build_path( libdir, LIB_TO_DATADIR );
 315         free( libdir );
 316         return;
 317     }
 318
 319     if (!p) return;  /* if argv0 doesn't contain a path, don't store anything */
 320
 321     len = p - argv0;
 322     if (!len) len++;  /* include leading slash */
 323
 324     if (argv0[0] == '/')  /* absolute path */
 325     {
 326         bindir = xmalloc( len + 1 );
 327         memcpy( bindir, argv0, len );
 328         bindir[len] = 0;
 329     }
 330     else
 331     {
 332         /* relative path, make it absolute */
 333         for (size = 256 + len; ; size *= 2)
 334         {
 335             if (!(cwd = malloc( size ))) return;
 336             if (getcwd( cwd, size - len ))
 337             {
 338                 bindir = cwd;
 339                 cwd += strlen(cwd);
 340                 *cwd++ = '/';
 341                 memcpy( cwd, argv0, len );
 342                 cwd[len] = 0;
 343                 break;
 344             }
 345             free( cwd );
 346             if (errno != ERANGE) return;
 347         }
 348     }
 349
 350     if ((build_dir = running_from_build_dir( bindir, bindir ))) goto in_build_dir;
 351
 352     dlldir = build_path( bindir, BIN_TO_DLLDIR );
 353     datadir = build_path( bindir, BIN_TO_DATADIR );
 354     return;
 355
 356 in_build_dir:
 357     free( bindir );
 358     free( argv0_name );
 359     bindir = NULL;
 360     argv0_name = build_path( "loader/", basename );
 361 }
 362
 363 /* return the configuration directory ($WINEPREFIX or $HOME/.wine) */
 364 const char *wine_get_config_dir(void)
 365 {
 366     if (!config_dir) init_paths();
 367     return config_dir;
 368 }
 369
 370 /* retrieve the wine data dir */
 371 const char *wine_get_data_dir(void)
 372 {
 373     return datadir;
 374 }
 375
 376 /* retrieve the wine build dir (if we are running from there) */
 377 const char *wine_get_build_dir(void)
 378 {
 379     return build_dir;
 380 }
 381
 382 /* return the full name of the server directory (the one containing the socket) */
 383 const char *wine_get_server_dir(void)
 384 {
 385     if (!server_dir)
 386     {
 387         if (!config_dir) init_paths();
 388         else
 389         {
 390             struct stat st;
 391
 392             if (stat( config_dir, &st ) == -1)
 393             {
 394                 if (errno != ENOENT) fatal_error( "cannot stat %s\n", config_dir );
 395                 return NULL;  /* will have to try again once config_dir has been created */
 396             }
 397             init_server_dir( st.st_dev, st.st_ino );
 398         }
 399     }
 400     return server_dir;
 401 }
 402
 403 /* return the current user name */
 404 const char *wine_get_user_name(void)
 405 {
 406     if (!user_name) init_paths();
 407     return user_name;
 408 }
 409
 410 /* return the standard version string */
 411 const char *wine_get_version(void)
 412 {
 413     return PACKAGE_VERSION;
 414 }
 415
 416 /* return the build id string */
 417 const char *wine_get_build_id(void)
 418 {
 419     extern const char wine_build[];
 420     return wine_build;
 421 }
 422
 423 /* exec a binary using the preloader if requested; helper for wine_exec_wine_binary */
 424 static void preloader_exec( char **argv, int use_preloader )
 425 {
 426 #ifdef linux
 427     if (use_preloader)
 428     {
 429         static const char preloader[] = "wine-preloader";
 430         char *p, *full_name;
 431         char **last_arg = argv, **new_argv;
 432
 433         if (!(p = strrchr( argv[0], '/' ))) p = argv[0];
 434         else p++;
 435
 436         full_name = xmalloc( p - argv[0] + sizeof(preloader) );
 437         memcpy( full_name, argv[0], p - argv[0] );
 438         memcpy( full_name + (p - argv[0]), preloader, sizeof(preloader) );
 439
 440         /* make a copy of argv */
 441         while (*last_arg) last_arg++;
 442         new_argv = xmalloc( (last_arg - argv + 2) * sizeof(*argv) );
 443         memcpy( new_argv + 1, argv, (last_arg - argv + 1) * sizeof(*argv) );
 444         new_argv[0] = full_name;
 445         execv( full_name, new_argv );
 446         free( new_argv );
 447         free( full_name );
 448         return;
 449     }
 450 #endif
 451     execv( argv[0], argv );
 452 }
 453
 454 /* exec a wine internal binary (either the wine loader or the wine server) */
 455 void wine_exec_wine_binary( const char *name, char **argv, const char *env_var )
 456 {
 457     const char *path, *pos, *ptr;
 458     int use_preloader = 0;
 459
 460     if (!name)  /* no name means default loader */
 461     {
 462         name = argv0_name;
 463         use_preloader = 1;
 464     }
 465
 466     if ((ptr = strrchr( name, '/' )))
 467     {
 468         /* if we are in build dir and name contains a path, try that */
 469         if (build_dir)
 470         {
 471             argv[0] = build_path( build_dir, name );
 472             preloader_exec( argv, use_preloader );
 473             free( argv[0] );
 474         }
 475         name = ptr + 1;  /* get rid of path */
 476     }
 477
 478     /* first, bin directory from the current libdir or argv0 */
 479     if (bindir)
 480     {
 481         argv[0] = build_path( bindir, name );
 482         preloader_exec( argv, use_preloader );
 483         free( argv[0] );
 484     }
 485
 486     /* then specified environment variable */
 487     if (env_var)
 488     {
 489         argv[0] = (char *)env_var;
 490         preloader_exec( argv, use_preloader );
 491     }
 492
 493     /* now search in the Unix path */
 494     if ((path = getenv( "PATH" )))
 495     {
 496         argv[0] = xmalloc( strlen(path) + strlen(name) + 2 );
 497         pos = path;
 498         for (;;)
 499         {
 500             while (*pos == ':') pos++;
 501             if (!*pos) break;
 502             if (!(ptr = strchr( pos, ':' ))) ptr = pos + strlen(pos);
 503             memcpy( argv[0], pos, ptr - pos );
 504             strcpy( argv[0] + (ptr - pos), "/" );
 505             strcat( argv[0] + (ptr - pos), name );
 506             preloader_exec( argv, use_preloader );
 507             pos = ptr;
 508         }
 509         free( argv[0] );
 510     }
 511
 512     /* and finally try BINDIR */
 513     argv[0] = build_path( BINDIR, name );
 514     preloader_exec( argv, use_preloader );
 515     free( argv[0] );
 516 }