src/rpm-fake.c

   1 // $Id: rpm-fake.c 2693 2008-03-01 00:26:31Z dhozac $    --*- c++ -*--
   2
   3 // Copyright (C) 2003 Enrico Scholz <enrico.scholz@informatik.tu-chemnitz.de>
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; version 2 of the License.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with this program; if not, write to the Free Software
  16 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17 //
  18
  19 #ifdef HAVE_CONFIG_H
  20 #  include <config.h>
  21 #endif
  22
  23 #include "pathconfig.h"
  24 #include "util.h"
  25
  26 #include <lib/vserver.h>
  27 #include <lib/internal.h>
  28 #include <lib_internal/sys_clone.h>
  29
  30 #include <sys/socket.h>
  31 #include <dlfcn.h>
  32 #include <stdlib.h>
  33 #include <stdint.h>
  34 #include <stdio.h>
  35 #include <unistd.h>
  36 #include <asm/unistd.h>
  37 #include <string.h>
  38 #include <stdbool.h>
  39 #include <errno.h>
  40 #include <fcntl.h>
  41 #include <stdarg.h>
  42 #include <sys/mount.h>
  43 #include <linux/fs.h>
  44 #include <sched.h>
  45 #include <signal.h>
  46 #include <sys/types.h>
  47 #include <sys/wait.h>
  48 #include <sys/un.h>
  49 #include <fcntl.h>
  50 #include <pwd.h>
  51 #include <grp.h>
  52
  53
  54   // from selinux.h
  55   // FIXME: add configure autodetection and include <selinux.h> directly
  56 int rpm_execcon(unsigned int verified,
  57                 const char *filename,
  58                 char *const argv[], char *const envp[]);
  59
  60
  61 #define ENSC_WRAPPERS_PREFIX    "rpm-fake.so: "
  62 #define ENSC_WRAPPERS_VSERVER   1
  63 #define ENSC_WRAPPERS_UNISTD    1
  64 #include <wrappers.h>
  65
  66 #undef _POSIX_SOURCE
  67 #include "capability-compat.h"
  68
  69 #define LIBNAME         "rpm-fake.so"
  70 #define PLATFORM_FILE   "/etc/rpm/platform"
  71
  72 #define INIT(FILE,FUNC) FUNC##_func = ((__typeof__(FUNC) *) (xdlsym(FILE, #FUNC)))
  73 #define DECLARE(FUNC)   static __typeof__(FUNC) *       FUNC##_func = 0
  74
  75 #define DEBUG 1
  76
  77 #define DBG_INIT        0x0001
  78 #define DBG_VARIABLES   0x0002
  79 #define DBG_RESOLVER    0x0004
  80 #define DBG_EXECV       0x0008
  81 #define DBG_ENV         0x0010
  82 #define DBG_VERBOSE0    0x8000
  83 #define DBG_VERBOSE1    (0x4000 | DBG_VERBOSE0)
  84 #define DBG_VERBOSE2    (0x2000 | DBG_VERBOSE1)
  85
  86 int                     wrapper_exit_code = 255;
  87
  88 static xid_t            ctx   = VC_NOCTX;
  89 static uint32_t         caps  = ~0;
  90 static int              flags = 0;
  91 static char const *     mnts  = 0;
  92 static char const *     root  = 0;
  93 static int              pw_sock   = -1;
  94 static int              sync_sock = -1;
  95 static unsigned int     debug_level = 0;
  96
  97 static bool             is_initialized = false;
  98
  99 static bool             ctx_created = false;
 100
 101   //DECLARE(rpm_execcon);
 102   //DECLARE(execv);
 103 DECLARE(getpwnam);
 104 DECLARE(getgrnam);
 105 DECLARE(endpwent);
 106 DECLARE(endgrent);
 107
 108 static void             initRPMFake() __attribute__((__constructor__));
 109 static void             exitRPMFake() __attribute__((__destructor__));
 110
 111 static inline bool
 112 isDbgLevel(unsigned int level)
 113 {
 114   return ((debug_level&level)==level);
 115 }
 116
 117 static void *
 118 xdlsym(void *handle, const char *symbol)
 119 {
 120   void  *res = dlsym(handle, symbol);
 121   if (res==0) {
 122     char const  *error = dlerror();
 123     Vwrite(2, symbol, strlen(symbol));
 124     Vwrite(2, ": ", 2);
 125     Vwrite(2, error, strlen(error));
 126     Vwrite(2, "\n", 2);
 127
 128     _exit(255);
 129   }
 130
 131   return res;
 132 }
 133
 134 static void
 135 showHelp()
 136 {
 137   WRITE_MSG(1,
 138             "Usage: LD_PRELOAD=" LIBNAME " <executable> <args>*\n\n"
 139             LIBNAME " unterstands the following environment variables:\n"
 140             "  $RPM_FAKE_RESOLVER     ...  program which does the NSS resolving (defaults\n"
 141             "                              to " RESOLVER_PROG ")\n"
 142             "  $RPM_FAKE_RESOLVER_UID ...  uid of the resolver program\n"
 143             "  $RPM_FAKE_RESOLVER_GID ...  gid of the resolver program\n"
 144             "  $RPM_FAKE_CTX          ...  vserver context which shall be used for resolver\n"
 145             "                              and scriptlets\n"
 146             "  $RPM_FAKE_CAP          ...  linux capability remove-mask for the context\n"
 147             "  $RPM_FAKE_FLAGS        ...  vserver flags of the context\n"
 148             "  $RPM_FAKE_CHROOT       ...  directory of the chroot environment\n"
 149             "  $RPM_FAKE_NAMESPACE_MOUNTS\n"
 150             "                          ... colon separated list of directories which will\n"
 151             "                              umounted before scriptlet execution\n\n"
 152             "  $RPM_FAKE_HELP          ... shows this message\n"
 153             "  $RPM_FAKE_VERSION       ... shows the version of this program\n\n"
 154             "  $RPM_FAKE_DEBUG         ... sets the debuglevel bitmask\n\n"
 155             "Please report bugs to " PACKAGE_BUGREPORT "\n");
 156   exit(0);
 157 }
 158
 159 static void
 160 showVersion()
 161 {
 162   WRITE_MSG(1,
 163             LIBNAME " " VERSION " -- wrapper around rpm\n"
 164             "This program is part of " PACKAGE_STRING "\n\n"
 165             "Copyright (C) 2003 Enrico Scholz\n"
 166             VERSION_COPYRIGHT_DISCLAIMER);
 167   exit(0);
 168 }
 169
 170 static void
 171 unsetPreloadEnv()
 172 {
 173   char                  *env = getenv("LD_PRELOAD");
 174   char                  *pos;
 175
 176     // the const <-> non-const assignment is not an issue since the following
 177     // modifying operations will not be executed in the const-case
 178   env = env ? env : "";
 179   pos = strstr(env, LIBNAME);
 180
 181   if (pos!=0) {
 182     char        *end_pos = pos + sizeof(LIBNAME);
 183     bool        is_end = (end_pos[-1]=='\0');
 184     char        *start_pos;
 185
 186     end_pos[-1] = '\0';
 187     start_pos   = strrchr(env, ':');
 188     if (start_pos==0) start_pos = env;
 189     else if (!is_end) ++start_pos;
 190
 191     if (is_end) *start_pos = '\0';
 192     else        memmove(start_pos, end_pos, strlen(end_pos)+1);
 193   }
 194
 195 #ifdef DEBUG
 196   if (isDbgLevel(DBG_VERBOSE1|DBG_VARIABLES)) {
 197     WRITE_MSG(2, "env='");
 198     WRITE_STR(2, env);
 199     WRITE_MSG(2, "'\n");
 200   }
 201 #endif
 202
 203   if (*env=='\0') unsetenv("LD_PRELOAD");
 204 }
 205
 206 static void
 207 clearEnv()
 208 {
 209   if (isDbgLevel(DBG_ENV)) WRITE_MSG(2, "clearEnv()\n");
 210
 211   unsetenv("RPM_FAKE_S_CONTEXT_REV");
 212   unsetenv("RPM_FAKE_S_CONTEXT_NR");
 213   unsetenv("RPM_FAKE_CTX");
 214   unsetenv("RPM_FAKE_FLAGS");
 215   unsetenv("RPM_FAKE_CHROOT");
 216   unsetenv("RPM_FAKE_NAMESPACE_MOUNTS");
 217
 218   unsetenv("RPM_FAKE_RESOLVER_GID");
 219   unsetenv("RPM_FAKE_RESOLVER_UID");
 220   unsetenv("RPM_FAKE_RESOLVER");
 221   unsetenv("RPM_FAKE_PWSOCKET");
 222
 223   unsetenv("RPM_FAKE_DEBUG");
 224
 225   unsetPreloadEnv();
 226 }
 227
 228 static int
 229 getDefaultEnv(char const *key, int dflt)
 230 {
 231   char          *env = getenv(key);
 232   int           res;
 233
 234   if (env==0 || env[0]=='\0') res = dflt;
 235   else                        res = atoi(env);
 236
 237   return res;
 238 }
 239
 240   /// \returns true iff we are in ctx after leaving this function
 241 static bool
 242 setupContext(xid_t xid, char const **xid_str)
 243 {
 244   bool          res = false;
 245
 246   if (vc_isSupported(vcFEATURE_MIGRATE)) {
 247     xid_t       rc=VC_NOCTX;
 248
 249     if ((xid==VC_DYNAMIC_XID || !vc_is_dynamic_xid(xid)) &&
 250         (rc=vc_ctx_create(xid, NULL))==VC_NOCTX &&
 251         errno!=EEXIST) {
 252       perror(ENSC_WRAPPERS_PREFIX "vc_ctx_create()");
 253       exit(255);
 254     }
 255
 256     if (rc!=VC_NOCTX) {
 257       char                      buf[sizeof(xid_t)*3 + 128];
 258       size_t                    l;
 259       struct vc_ctx_caps        caps;
 260       struct vc_ctx_flags       flags;
 261
 262       strcpy(buf, "rpm-fake.so #");
 263       l = utilvserver_fmt_uint(buf+sizeof("rpm-fake.so #")-1, getppid());
 264       Evc_set_vhi_name(rc, vcVHI_CONTEXT, buf, sizeof("rpm-fake.so #")+l-1);
 265
 266       caps.ccaps =  0ull;
 267       caps.cmask = ~0ull;
 268       caps.bcaps = ~vc_get_insecurebcaps();
 269       caps.bmask = ~0ull;
 270       Evc_set_ccaps(rc, &caps);
 271
 272       flags.flagword = 0;
 273       flags.mask = VC_VXF_SC_HELPER;
 274       Evc_set_cflags(rc, &flags);
 275
 276         // context will be activated later...
 277
 278       xid = rc;
 279       res = true;
 280       ctx_created = true;
 281     }
 282   }
 283
 284   if (xid==VC_DYNAMIC_XID)
 285     *xid_str = 0;
 286   else {
 287     char                buf[sizeof(xid_t)*3 + 2];
 288     size_t              l;
 289
 290     l        = utilvserver_fmt_uint(buf, xid); buf[l] = '\0';
 291     *xid_str = strdup(buf);
 292   }
 293
 294   Ewrite(3, &xid, sizeof xid);
 295   return res;
 296 }
 297
 298 #if 0
 299 static void
 300 initPwSocket()
 301 {
 302   char const *  sock_name = getenv("RPM_FAKE_PWSOCKET");
 303   if (sock_name!=0) {
 304     int flag;
 305     struct sockaddr_un  addr = {
 306       .sun_family = AF_UNIX,
 307     };
 308
 309     strncpy(addr.sun_path, sock_name, sizeof(addr.sun_path)-1);
 310     addr.sun_path[sizeof(addr.sun_path)-1]='\0';
 311
 312     if ((pw_sock=socket(AF_UNIX, SOCK_STREAM, 0))==-1 ||
 313         connect(pw_sock, (struct sockaddr *)(&addr), sizeof addr)==-1 ||
 314         (flag=fcntl(pw_sock, F_GETFD))==-1 ||
 315         fcntl(pw_sock, F_SETFD, flag | FD_CLOEXEC)==-1) {
 316       perror(ENSC_WRAPPERS_PREFIX "error while initializing pw-socket");
 317       exit(255);
 318     }
 319   }
 320 }
 321 #else
 322 static void
 323 initPwSocket()
 324 {
 325   char const *  resolver = getenv("RPM_FAKE_RESOLVER");
 326   if (resolver==0) resolver=RESOLVER_PROG;
 327
 328   if (resolver!=0 && *resolver!='\0') {
 329     int                 res_sock[2];
 330     int                 sync_pipe[2];
 331     pid_t               pid;
 332     char const *        uid=0;
 333     char const *        gid=0;
 334
 335     uid=getenv("RPM_FAKE_RESOLVER_UID");
 336     gid=getenv("RPM_FAKE_RESOLVER_GID");
 337
 338     if (socketpair(AF_UNIX, SOCK_STREAM, 0, res_sock)==-1 ||
 339         pipe(sync_pipe)==-1 ||
 340         fcntl(res_sock[0],  F_SETFD, FD_CLOEXEC)==-1 ||
 341         fcntl(sync_pipe[0], F_SETFD, FD_CLOEXEC)==-1) {
 342       perror(ENSC_WRAPPERS_PREFIX "failed to create/initialize resolver-socket or pipe");
 343       exit(255);
 344     }
 345
 346     pid = fork();
 347     if (pid==-1) {
 348       perror(ENSC_WRAPPERS_PREFIX "fork()");
 349       exit(255);
 350     }
 351
 352     if (pid==0) {
 353       char const        *args[20];
 354       char const        **ptr  = args;
 355       char const        *env[] = { "HOME=/", "PATH=/bin:/usr/bin", 0 };
 356       char const        *xid_str;
 357       char              flag_str[ sizeof(flags)*3 + 2];
 358       char              caps_str[ sizeof(caps)*3  + 2];
 359
 360       clearEnv();
 361
 362       setsid();
 363       dup2(res_sock[1],  0);
 364       dup2(res_sock[1],  1);
 365       if (sync_pipe[1]!=3) {
 366         close(3);
 367         dup2(sync_pipe[1], 3);
 368         close(sync_pipe[1]);
 369       }
 370       close(res_sock[1]);
 371         /* ... *socket[0] are marked as close-on-exec ...*/
 372
 373       flag_str[utilvserver_fmt_uint(flag_str, flags)] = '\0';
 374       caps_str[utilvserver_fmt_uint(caps_str, caps)]  = '\0';
 375
 376       *ptr++ = resolver;
 377       *ptr++ = "-F"; *ptr++ = flag_str;
 378       *ptr++ = "-C"; *ptr++ = caps_str;
 379       if (root)  { *ptr++ = "-r"; *ptr++ = ".";   }
 380       if (uid)   { *ptr++ = "-u"; *ptr++ = uid;   }
 381       if (gid)   { *ptr++ = "-g"; *ptr++ = gid;   }
 382
 383       if (root) Echdir(root);
 384
 385       if (setupContext(ctx, &xid_str)) { *ptr++ = "-s"; }
 386       else if (xid_str)                { *ptr++ = "-c"; *ptr++ = xid_str; }
 387
 388       *ptr++ = 0;
 389       execve(resolver, (char **)args, (char **)env);
 390       perror(ENSC_WRAPPERS_PREFIX "failed to exec resolver");
 391       exit(255);
 392     }
 393     else {
 394       uint8_t           c;
 395
 396       close(res_sock[1]);
 397       close(sync_pipe[1]);
 398       pw_sock   = res_sock[0];
 399       sync_sock = sync_pipe[0];
 400
 401       if (read(sync_sock, &ctx, sizeof ctx)!=sizeof(ctx) ||
 402           read(sync_sock, &c, 1)!=1 ||
 403           write(pw_sock, ".", 1)!=1 ||
 404           read(pw_sock, &c,   1)!=1 ||
 405           c!='.') {
 406         WRITE_MSG(2, ENSC_WRAPPERS_PREFIX "failed to initialize communication with resolver\n");
 407         exit(255);
 408       }
 409
 410       if (wait4(pid, 0, WNOHANG,0)==-1) {
 411         WRITE_MSG(2, ENSC_WRAPPERS_PREFIX" unexpected initialization-error of resolver\n");
 412         exit(255);
 413       }
 414     }
 415   }
 416 }
 417 #endif
 418
 419 static void
 420 reduceCapabilities()
 421 {
 422   struct __user_cap_header_struct header;
 423   struct __user_cap_data_struct user;
 424
 425   header.version = _LINUX_CAPABILITY_VERSION;
 426   header.pid     = 0;
 427
 428   if (capget(&header, &user)==-1) {
 429     perror("capget()");
 430     exit(wrapper_exit_code);
 431   }
 432
 433   user.effective   &= ~(1<<CAP_MKNOD);
 434   user.permitted   &= ~(1<<CAP_MKNOD);
 435   user.inheritable &= ~(1<<CAP_MKNOD);
 436
 437   if (capset(&header, &user)==-1) {
 438     perror("capset()");
 439     exit(wrapper_exit_code);
 440   }
 441 }
 442
 443 static void
 444 initEnvironment()
 445 {
 446   int           syscall_rev;
 447   int           syscall_nr;
 448
 449   if (is_initialized) return;
 450
 451   syscall_rev = getDefaultEnv("RPM_FAKE_S_CONTEXT_REV", 0);
 452   syscall_nr  = getDefaultEnv("RPM_FAKE_S_CONTEXT_NR",  273);
 453
 454 #ifdef VC_ENABLE_API_LEGACY
 455   {
 456     extern void vc_init_internal_legacy(int ctx_rev, int ctx_number,
 457                                         int ipv4_rev, int ipv4_number);
 458
 459     vc_init_internal_legacy(syscall_rev, syscall_nr, 3, 274);
 460   }
 461 #endif
 462
 463   ctx       = getDefaultEnv("RPM_FAKE_CTX",  VC_DYNAMIC_XID);
 464   caps      = getDefaultEnv("RPM_FAKE_CAP",  ~0x3404040f);
 465   flags     = getDefaultEnv("RPM_FAKE_FLAGS", 0);
 466   root      = getenv("RPM_FAKE_CHROOT");
 467   mnts      = getenv("RPM_FAKE_NAMESPACE_MOUNTS");
 468   if (mnts && *mnts) mnts = strdup(mnts);
 469   else               mnts = 0;
 470
 471 #if DEBUG
 472   if (isDbgLevel(DBG_VERBOSE1))
 473     dprintf(2, "ctx=%u, caps=%016x, flags=%016x,\nroot='%s',\nmnts='%s'\n",
 474             ctx, caps, flags, root, mnts);
 475 #endif
 476
 477   is_initialized = true;
 478 }
 479
 480 static void
 481 initSymbols()
 482 {
 483     //INIT(RTLD_NEXT, rpm_execcon);
 484     //INIT(RTLD_NEXT, execv);
 485   INIT(RTLD_NEXT, getgrnam);
 486   INIT(RTLD_NEXT, getpwnam);
 487   INIT(RTLD_NEXT, endpwent);
 488   INIT(RTLD_NEXT, endgrent);
 489 }
 490
 491 void
 492 initRPMFake()
 493 {
 494   if (getenv("RPM_FAKE_VERSION")) showVersion();
 495   if (getenv("RPM_FAKE_HELP"))    showHelp();
 496
 497   debug_level = getDefaultEnv("RPM_FAKE_DEBUG", 0);
 498
 499   if (isDbgLevel(DBG_INIT)) WRITE_MSG(2, ">>>>> initRPMFake <<<<<\n");
 500
 501   reduceCapabilities();
 502   initSymbols();
 503   initEnvironment();
 504   initPwSocket();
 505
 506 #if 0
 507   if (isDbgLevel(DBG_VARIABLES|DBG_VERBOSE2)) {
 508
 509   }
 510 #endif
 511 }
 512
 513 void
 514 exitRPMFake()
 515 {
 516   if (isDbgLevel(DBG_INIT)) WRITE_MSG(2, ">>>>> exitRPMFake <<<<<\n");
 517   if (pw_sock!=-1) {
 518     uint8_t     c;
 519     if (read(sync_sock, &c, 1)!=1) { /*...*/ }
 520     if (write(pw_sock, "Q", 1)!=1) { /*...*/ }
 521     if (ctx_created) {
 522       if (vc_isSupported(vcFEATURE_VWAIT)) {
 523         if (vc_wait_exit(ctx)==-1) { /*...*/ }
 524       }
 525       else {
 526         /* this can race */
 527         if (read(sync_sock, &c, 1)!=0) { /*...*/}
 528       }
 529     }
 530   }
 531 }
 532
 533
 534   //============   the worker part   ===========
 535
 536
 537 static bool
 538 doPwStringRequest(uint32_t *result, char style, char const *name)
 539 {
 540   uint32_t      len = strlen(name);
 541   uint8_t       code;
 542   uint8_t       c;
 543
 544   return (TEMP_FAILURE_RETRY(read (sync_sock, &c, 1))==1 &&
 545           TEMP_FAILURE_RETRY(write(pw_sock, &style, 1))==1 &&
 546           TEMP_FAILURE_RETRY(write(pw_sock, &len,   sizeof len))==sizeof(len) &&
 547           TEMP_FAILURE_RETRY(write(pw_sock, name,   len))==(ssize_t)(len) &&
 548           TEMP_FAILURE_RETRY(read (pw_sock, &code,  sizeof code))==sizeof(code) &&
 549           TEMP_FAILURE_RETRY(read (pw_sock, result, sizeof *result))==sizeof(*result) &&
 550           code!=0);
 551 }
 552
 553 struct passwd *
 554 getpwnam(const char * name)
 555 {
 556   if (pw_sock==-1) return getpwnam_func(name);
 557   else {
 558     uint32_t                    id;
 559     static struct passwd        res = {
 560       .pw_passwd = "*",
 561       .pw_gid    = -1,
 562       .pw_gecos  = "",
 563       .pw_dir    = "/",
 564       .pw_shell  = "/bin/false"
 565     };
 566
 567     res.pw_name = (char *)(name);
 568     if (!doPwStringRequest(&id, 'P', name)) return 0;
 569     res.pw_uid = id;
 570
 571     return &res;
 572   }
 573 }
 574
 575 struct group *
 576 getgrnam(const char * name)
 577 {
 578   if (pw_sock==-1) return getgrnam_func(name);
 579   else {
 580     uint32_t                    id;
 581     static struct group         res = {
 582       .gr_passwd = "*",
 583       .gr_mem    = 0
 584     };
 585
 586     res.gr_name = (char *)(name);
 587     if (!doPwStringRequest(&id, 'G', name)) return 0;
 588     res.gr_gid = id;
 589
 590     return &res;
 591   }
 592 }
 593
 594 void
 595 endgrent()
 596 {
 597   if (pw_sock==-1) endgrent_func();
 598   TEMP_FAILURE_RETRY(write(pw_sock, "Cg", 2));
 599 }
 600
 601 void
 602 endpwent()
 603 {
 604   if (pw_sock==-1) endpwent_func();
 605   TEMP_FAILURE_RETRY(write(pw_sock, "Cp", 2));
 606 }
 607
 608
 609 static int
 610 execvWorker(char const *path, char * const argv[], char * const envp[])
 611 {
 612   int           res = -1;
 613
 614   if (vc_isSupported(vcFEATURE_MIGRATE))
 615     res = vc_ctx_migrate(ctx, 0);
 616   else {
 617 #ifdef VC_ENABLE_API_COMPAT
 618     res = vc_new_s_context(ctx,caps,flags);
 619 #else
 620     WRITE_MSG(2, ENSC_WRAPPERS_PREFIX "can not change context: migrate kernel feature missing and 'compat' API disabled\n");
 621 #endif
 622   }
 623
 624   clearEnv();
 625
 626   if (res!=-1)
 627     res=execve(path, argv, envp);
 628
 629   return res;
 630 }
 631
 632 struct ExecvParams
 633 {
 634     char const *        path;
 635     char * const *      argv;
 636     char * const *      envp;
 637     char const *        mnts;
 638 };
 639
 640 static int
 641 removeNamespaceMountsChild(struct ExecvParams const *params)
 642 {
 643   char                  buf[strlen(params->mnts)+1], *ptr;
 644
 645   strcpy(buf, params->mnts);
 646   ptr = strtok(buf, ":");
 647   while (ptr) {
 648     if (umount2(ptr, 0)==-1) {
 649         // FIXME: What is the semantic for CLONE_NEWNS? Is it ok that mounts in
 650         // chroots are visible only, when chroot is on /dev/root?
 651         //
 652         // For now, ignore any errors, but future versions should handle them.
 653
 654         //return -1;
 655     }
 656     ptr = strtok(0, ":");
 657   }
 658
 659   return execvWorker(params->path, params->argv, params->envp);
 660 }
 661
 662 static int
 663 removeNamespaceMounts(char const *path,
 664                       char * const argv[], char * const envp[])
 665 {
 666   if (mnts==0) return execvWorker(path, argv, envp);
 667
 668   {
 669     int                         status;
 670     pid_t                       p, pid;
 671     struct ExecvParams          params;
 672
 673     params.path = path;
 674     params.argv = argv;
 675     params.envp = envp;
 676     params.mnts = mnts;
 677
 678       // the rpmlib signal-handler is still active; use the default one to
 679       // make wait4() working...
 680     signal(SIGCHLD, SIG_DFL);
 681
 682 #ifdef NDEBUG
 683     pid = sys_clone(CLONE_NEWNS|SIGCHLD|CLONE_VFORK, 0);
 684 #else
 685     pid = sys_clone(CLONE_NEWNS|SIGCHLD, 0);
 686 #endif
 687
 688     switch (pid) {
 689       case -1   :  return -1;
 690       case 0    :  _exit(removeNamespaceMountsChild(&params));
 691       default   :  break;
 692     }
 693
 694     while ((p=wait4(pid, &status, 0,0))==-1 &&
 695            (errno==EINTR || errno==EAGAIN)) ;
 696
 697     if (p==-1)   return -1;
 698
 699     if (WIFEXITED(status))   _exit(WEXITSTATUS(status));
 700     if (WIFSIGNALED(status)) kill(getpid(), WTERMSIG(status));
 701
 702     return -1;
 703   }
 704 }
 705
 706
 707 int
 708 execv(char const *path, char * const argv[])
 709 {
 710   extern char **environ;
 711
 712   if (isDbgLevel(DBG_EXECV)) {
 713     WRITE_MSG(2, "execv('");
 714     WRITE_STR(2, path);
 715     WRITE_MSG(2, "', ...)\n");
 716   }
 717
 718   return removeNamespaceMounts(path, argv, environ);
 719 }
 720
 721 int
 722 rpm_execcon(unsigned int UNUSED verified,
 723             const char *filename,
 724             char *const argv[], char *const envp[])
 725 {
 726   if (isDbgLevel(DBG_EXECV)) {
 727     WRITE_MSG(2, "rpm_execcon(..., '");
 728     WRITE_STR(2, filename);
 729     WRITE_MSG(2, "', ...)\n");
 730   }
 731
 732   return removeNamespaceMounts(filename, argv, envp);
 733 }
 734
 735 int
 736 is_selinux_enabled()
 737 {
 738   return 0;
 739 }