src/vserver-info.c

   1 // $Id: vserver-info.c,v 1.23 2005/07/04 22:36:46 ensc Exp $    --*- 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 "lib/utils-legacy.h"
  24 #include "pathconfig.h"
  25 #include "util.h"
  26
  27 #include "internal.h"
  28 #include "vserver.h"
  29
  30 #include <stdlib.h>
  31 #include <getopt.h>
  32 #include <assert.h>
  33 #include <stdbool.h>
  34 #include <fcntl.h>
  35 #include <errno.h>
  36 #include <sys/utsname.h>
  37 #include <dirent.h>
  38 #include <strings.h>
  39
  40 #define ENSC_WRAPPERS_FCNTL     1
  41 #define ENSC_WRAPPERS_IO        1
  42 #define ENSC_WRAPPERS_UNISTD    1
  43 #define ENSC_WRAPPERS_VSERVER   1
  44 #include <wrappers.h>
  45
  46 #undef _POSIX_SOURCE
  47 #include "capability-compat.h"
  48
  49 typedef enum { tgNONE,tgCONTEXT, tgID, tgRUNNING,
  50                tgVDIR, tgNAME, tgCFGDIR, tgAPPDIR,
  51                tgAPIVER, tgPXID,
  52                tgINITPID, tgINITPID_PID,
  53                tgXID, tgUTS, tgSYSINFO,
  54                tgFEATURE, tgCANONIFY,
  55                tgVERIFYCAP, tgXIDTYPE, tgVERIFYPROC,
  56 }       VserverTag;
  57
  58 static struct {
  59     char const * const  tag;
  60     VserverTag const    val;
  61     char const * const  descr;
  62 }  const TAGS[] = {
  63   { "CONTEXT", tgCONTEXT, ("the current and/or assigned context; when an optinal argument "
  64                            "evaluates to false,only the current context will be printed") },
  65   { "ID",      tgID,      "gives out the vserver-id for the context-xid" },
  66   { "RUNNING", tgRUNNING, "gives out '1' when vserver is running; else, it fails without output" },
  67   { "VDIR",    tgVDIR,    "gives out the root-directory of the vserver" },
  68   { "NAME",    tgNAME,    "gives out the name of the vserver" },
  69   { "CFGDIR",  tgCFGDIR,  "gives out the configuration directory of the vserver" },
  70   { "APPDIR",  tgAPPDIR,  "gives out the name of the toplevel application cfgdir" },
  71   { "INITPID",     tgINITPID,     "gives out the initpid of the given context" },
  72   { "INITPID_PID", tgINITPID_PID, "gives out the initpid of the given pid" },
  73   { "XID",         tgXID,         "gives out the context-id of the given pid" },
  74   { "APIVER",      tgAPIVER,      "gives out the version of the kernel API" },
  75   { "UTS",         tgUTS,         ("gives out an uts-entry; possible entries are "
  76                                    "context, sysname, nodename, release, version, "
  77                                    "machine and domainname") },
  78   { "SYSINFO",     tgSYSINFO,     "gives out information about the systen" },
  79   { "FEATURE",     tgFEATURE,     "returns 0 iff the queried feature is supported" },
  80   { "PXID",        tgPXID,        "returns the xid of the parent context" },
  81   { "CANONIFY",    tgCANONIFY,    "canonifies the vserver-name and removes dangerous characters" },
  82   { "VERIFYCAP",   tgVERIFYCAP,   "test if the kernel supports linux capabilities" },
  83   { "VERIFYPROC",  tgVERIFYPROC,  "test if /proc can be read by contexts!=0" },
  84   { "XIDTYPE",     tgXIDTYPE,     "returns the type of the given XID" },
  85 };
  86
  87 int wrapper_exit_code = 1;
  88
  89 static struct option const
  90 CMDLINE_OPTIONS[] = {
  91   { "help",     no_argument,  0, 'h' },
  92   { "version",  no_argument,  0, 'v' },
  93   { 0,0,0,0 }
  94 };
  95
  96
  97 static void
  98 showHelp(int fd, char const *cmd, int res)
  99 {
 100   WRITE_MSG(fd, "Usage:  ");
 101   WRITE_STR(fd, cmd);
 102   WRITE_MSG(fd,
 103             " [-ql] <vserver>|<pid>|<context> <tag>\n"
 104             "Please report bugs to " PACKAGE_BUGREPORT "\n");
 105   exit(res);
 106 }
 107
 108 static void
 109 showVersion()
 110 {
 111   WRITE_MSG(1,
 112             "vserver-info " VERSION " -- returns information about vservers\n"
 113             "This program is part of " PACKAGE_STRING "\n\n"
 114             "Copyright (C) 2003 Enrico Scholz\n"
 115             VERSION_COPYRIGHT_DISCLAIMER);
 116   exit(0);
 117 }
 118
 119 static void
 120 showTags()
 121 {
 122   char const *          delim = "";
 123   size_t        i;
 124
 125   WRITE_MSG(1, "Valid tags are: ");
 126   for (i=0; i<DIM_OF(TAGS); ++i) {
 127     WRITE_STR(1, delim);
 128     WRITE_STR(1, TAGS[i].tag);
 129
 130     delim = ", ";
 131   }
 132   WRITE_MSG(1, "\n");
 133   exit(0);
 134 }
 135
 136 static VserverTag
 137 stringToTag(char const *str)
 138 {
 139   size_t        i;
 140   for (i=0; i<DIM_OF(TAGS); ++i)
 141     if (strcmp(TAGS[i].tag, str)==0) return TAGS[i].val;
 142
 143   return tgNONE;
 144 }
 145
 146 static vc_uts_type
 147 utsText2Tag(char const *str)
 148 {
 149   if      (strcmp(str, "context")   ==0) return vcVHI_CONTEXT;
 150   else if (strcmp(str, "sysname")   ==0) return vcVHI_SYSNAME;
 151   else if (strcmp(str, "nodename")  ==0) return vcVHI_NODENAME;
 152   else if (strcmp(str, "release")   ==0) return vcVHI_RELEASE;
 153   else if (strcmp(str, "version")   ==0) return vcVHI_VERSION;
 154   else if (strcmp(str, "machine")   ==0) return vcVHI_MACHINE;
 155   else if (strcmp(str, "domainname")==0) return vcVHI_DOMAINNAME;
 156   else {
 157     WRITE_MSG(2, "Unknown UTS tag\n");
 158     exit(1);
 159   }
 160 }
 161
 162 static bool
 163 verifyProc()
 164 {
 165   char const            *errptr;
 166
 167   if (!switchToWatchXid(&errptr)) {
 168     perror(errptr);
 169     return false;
 170   }
 171
 172   if (access("/proc/uptime", R_OK)==-1) {
 173     if (errno!=ENOENT)
 174       perror("access(\"/proc/uptime\")");
 175
 176     return false;
 177   }
 178
 179   return true;
 180 }
 181
 182 static bool
 183 verifyCap()
 184 {
 185   struct __user_cap_header_struct header;
 186   struct __user_cap_data_struct user;
 187   header.version = _LINUX_CAPABILITY_VERSION;
 188   header.pid     = 0;
 189
 190   if (getuid()!=0) {
 191     WRITE_MSG(2, "'VERIFYCAP' can be executed as root only\n");
 192     return false;
 193   }
 194
 195 //  if( prctl( PR_SET_KEEPCAPS, 1,0,0,0 ) < 0 ) {
 196 //    perror( "prctl:" );
 197 //    return false;
 198 //  }
 199
 200   if (capget(&header, &user)==-1) {
 201     perror("capget()");
 202     return false;
 203   }
 204
 205   user.effective   = 0;
 206   user.permitted   = 0;
 207   user.inheritable = 0;
 208
 209   if (capset(&header, &user)==-1) {
 210     perror("capset()");
 211     return false;
 212   }
 213
 214   return chroot("/")==-1;
 215 }
 216
 217 static char *
 218 getAPIVer(char *buf)
 219 {
 220   int           v = vc_get_version();
 221   size_t        l;
 222
 223   if (v==-1) return 0;
 224
 225
 226   l = utilvserver_fmt_xulong(0, (unsigned int)v);
 227   memcpy(buf, "0x00000000", 10);
 228   utilvserver_fmt_xulong(buf+2+8-l, (unsigned int)v);
 229
 230   return buf;
 231 }
 232
 233 static char *
 234 getXid(char *buf, char const *pid_str)
 235 {
 236   pid_t         pid = atoi(pid_str);
 237   xid_t         xid = vc_get_task_xid(pid);
 238
 239   if (xid==VC_NOCTX) perror("vc_get_task_xid()");
 240   else {
 241     utilvserver_fmt_long(buf, xid);
 242     return buf;
 243   }
 244
 245   return 0;
 246 }
 247
 248 static char *
 249 getPXid(char UNUSED *buf, char const UNUSED *vserver)
 250 {
 251   // TODO: implement me when available
 252   return 0;
 253 }
 254
 255 static char *
 256 getInitPid_native(char *buf, xid_t xid)
 257 {
 258   struct vc_vx_info             info;
 259
 260   if (vc_get_vx_info(xid, &info)==-1) perror("vc_get_vx_info()");
 261   else {
 262     utilvserver_fmt_long(buf, info.initpid);
 263     return buf;
 264   }
 265
 266   return 0;
 267 }
 268
 269 #if defined(VC_ENABLE_API_COMPAT) || defined(VC_ENABLE_API_V11)
 270 static int
 271 selectPid(struct dirent const *ent)
 272 {
 273   return atoi(ent->d_name)!=0;
 274 }
 275
 276 static bool
 277 getInitPid_internal(pid_t pid, xid_t xid, pid_t *res)
 278 {
 279   *res = -1;
 280
 281   for (;*res==-1;) {
 282     size_t                      bufsize = utilvserver_getProcEntryBufsize();
 283     char                        buf[bufsize+1];
 284     char                        *pos = 0;
 285
 286     pos = utilvserver_getProcEntry(pid, "\ns_context: ", buf, bufsize);
 287     if (pos==0 && errno==EAGAIN) continue;
 288
 289     if (pos==0 || (xid_t)atoi(pos)!=xid) return false;
 290
 291     buf[bufsize] = '\0';
 292     pos          = strstr(buf, "\ninitpid: ");
 293
 294     if (pos!=0) {
 295       pos       += sizeof("\ninitpid: ")-1;
 296       if (strncmp(pos, "none", 4)==0) *res = -1;
 297       else                            *res = atoi(pos);
 298     }
 299   }
 300
 301   return true;
 302 }
 303
 304 static char *
 305 getInitPid_emulated(char *buf, xid_t xid)
 306 {
 307   struct dirent **namelist;
 308   int           n;
 309
 310   switchToWatchXid(0);  // ignore errors silently...
 311   n = scandir("/proc", &namelist, selectPid, alphasort);
 312   if (n<0) perror("scandir()");
 313   else while (n--) {
 314     pid_t       pid;
 315     if (!getInitPid_internal(atoi(namelist[n]->d_name), xid, &pid)) continue;
 316
 317     utilvserver_fmt_long(buf, pid);
 318     return buf;
 319   }
 320
 321   return 0;
 322 }
 323 #endif // VC_ENABLE_API_COMPAT
 324
 325 static char *
 326 getInitPid(char *buf, xid_t xid)
 327 {
 328   if (vc_isSupported(vcFEATURE_VINFO))
 329     return getInitPid_native(buf, xid);
 330   else
 331     return getInitPid_emulated(buf, xid);
 332 }
 333
 334 static char *
 335 getInitPidPid(char *buf, char const *vserver)
 336 {
 337   struct vc_vx_info     info;
 338   pid_t                 pid = atoi(vserver);
 339   xid_t                 xid = vc_get_task_xid(pid);
 340
 341   if (xid==VC_NOCTX) perror("vc_get_task_xid()");
 342   else if (vc_get_vx_info(xid, &info)==-1) perror("vc_get_vx_info()");
 343   else {
 344     utilvserver_fmt_long(buf, info.initpid);
 345     return buf;
 346   }
 347
 348   return 0;
 349 }
 350
 351 static char *
 352 getUTS(char *buf, xid_t xid, size_t argc, char * argv[])
 353 {
 354   if (argc>0) {
 355     vc_uts_type type = utsText2Tag(argv[0]);
 356     if (vc_get_vhi_name(xid, type, buf, sizeof(buf)-1)==-1)
 357       perror("vc_get_vhi_name()");
 358     else
 359       return buf;
 360   }
 361   else {
 362     bool                is_passed = false;
 363     char                tmp[128];
 364 #define APPEND_UTS(TYPE)                                                \
 365     (((vc_get_vhi_name(xid, TYPE, tmp, sizeof(tmp)-1)!=-1) && (strcat(buf, tmp), strcat(buf, " "), is_passed=true)) || \
 366      (strcat(buf, "??? ")))
 367
 368     if (APPEND_UTS(vcVHI_CONTEXT) &&
 369         APPEND_UTS(vcVHI_SYSNAME) &&
 370         APPEND_UTS(vcVHI_NODENAME) &&
 371         APPEND_UTS(vcVHI_RELEASE) &&
 372         APPEND_UTS(vcVHI_VERSION) &&
 373         APPEND_UTS(vcVHI_MACHINE) &&
 374         APPEND_UTS(vcVHI_DOMAINNAME) &&
 375         is_passed)
 376       return buf;
 377
 378     perror("vc_get_vhi_name()");
 379 #undef APPEND_UTS
 380   }
 381
 382   return 0;
 383 }
 384
 385 static int
 386 printSysInfo(char *buf)
 387 {
 388   int                   fd = open(PKGLIBDIR "/FEATURES.txt", O_RDONLY);
 389   struct utsname        uts;
 390
 391   if (uname(&uts)==-1)
 392     perror("uname()");
 393   else {
 394     WRITE_MSG(1,
 395               "Versions:\n"
 396               "                   Kernel: ");
 397     WRITE_STR(1, uts.release);
 398     WRITE_MSG(1, "\n"
 399               "                   VS-API: ");
 400
 401     memset(buf, 0, 128);
 402     if (getAPIVer(buf)) WRITE_STR(1, buf);
 403     else                WRITE_MSG(1, "???");
 404
 405     WRITE_MSG(1, "\n"
 406               "             util-vserver: " PACKAGE_VERSION "; " __DATE__ ", " __TIME__"\n"
 407               "\n");
 408   }
 409
 410   if (fd==-1)
 411     WRITE_MSG(1, "FEATURES.txt not found\n");
 412   else {
 413     off_t               l  = Elseek(fd, 0, SEEK_END);
 414     Elseek(fd, 0, SEEK_SET);
 415     {
 416       char              buf[l];
 417       EreadAll(fd, buf, l);
 418       EwriteAll(1, buf, l);
 419     }
 420     Eclose(fd);
 421   }
 422
 423   return EXIT_SUCCESS;
 424 }
 425
 426 static char *
 427 getContext(char *buf, char const *vserver, bool allow_only_static)
 428 {
 429   xid_t         xid = vc_getVserverCtx(vserver, vcCFG_AUTO,
 430                                        allow_only_static, 0);
 431   if (xid==VC_NOCTX) return 0;
 432
 433   utilvserver_fmt_long(buf, xid);
 434   return buf;
 435 }
 436
 437 static char const *
 438 getXIDType(xid_t xid, int argc, char *argv[])
 439 {
 440   char const *          tp;
 441
 442   switch (vc_getXIDType(xid)) {
 443     case vcTYPE_INVALID         :  tp = "invalid"; break;
 444     case vcTYPE_MAIN            :  tp = "main";    break;
 445     case vcTYPE_WATCH           :  tp = "watch";   break;
 446     case vcTYPE_STATIC          :  tp = "static";  break;
 447     case vcTYPE_DYNAMIC         :  tp = "dynamic"; break;
 448     default                     :  tp = 0;         break;
 449   }
 450
 451   if (argc==0 || tp==0)
 452     return tp;
 453
 454   while (argc>0) {
 455     --argc;
 456     if (strcasecmp(argv[argc], tp)==0) return tp;
 457   }
 458
 459   return 0;
 460 }
 461
 462 static int
 463 testFeature(int argc, char *argv[])
 464 {
 465   return (argc>0 && vc_isSupportedString(argv[0])) ? EXIT_SUCCESS : EXIT_FAILURE;
 466 }
 467
 468 static bool
 469 str2bool(char const *str)
 470 {
 471   return atoi(str)!=0 || strchr("yYtT", str[0])!=0 || strcasecmp("true", str)==0;
 472 }
 473
 474 static int
 475 execQuery(char const *vserver, VserverTag tag, int argc, char *argv[])
 476 {
 477   char const *          res = 0;
 478   char                  buf[sizeof(xid_t)*4 + 1024 + strlen(vserver)];
 479
 480   memset(buf, 0, sizeof buf);
 481   switch (tag) {
 482     case tgNAME         :  res = vc_getVserverName(vserver, vcCFG_AUTO); break;
 483     case tgVDIR         :
 484       res = vc_getVserverVdir(vserver, vcCFG_AUTO, argc>0 && atoi(argv[0]));
 485       break;
 486     case tgCFGDIR       :  res = vc_getVserverCfgDir(vserver, vcCFG_AUTO);     break;
 487     case tgAPPDIR       :
 488       res = vc_getVserverAppDir(vserver, vcCFG_AUTO, argc==0 ? "" : argv[0]);
 489       break;
 490
 491     case tgRUNNING      : {
 492       signed long               xid;    // type is a small hack, but should be ok...
 493       struct vc_vx_info         info;
 494
 495       if (isNumber(vserver, &xid) && xid>=0)
 496         res = (vc_get_vx_info(xid, &info)==-1) ? 0 : "1";
 497       else
 498         res = (vc_getVserverCtx(vserver, vcCFG_AUTO, false, 0)==VC_NOCTX) ? 0 : "1";
 499
 500       break;
 501     }
 502
 503     case tgCANONIFY     :
 504       strcpy(buf, vserver);
 505       if (canonifyVserverName(buf)>0) res = buf;
 506       break;
 507
 508     case tgCONTEXT      :  res = getContext(buf, vserver,
 509                                             argc==0 || str2bool(argv[0])); break;
 510     case tgINITPID_PID  :  res = getInitPidPid(buf, vserver);  break;
 511     case tgAPIVER       :  res = getAPIVer(buf);               break;
 512     case tgXID          :  res = getXid(buf, vserver);         break;
 513     case tgPXID         :  res = getPXid(buf, vserver);        break;
 514     case tgSYSINFO      :  return printSysInfo(buf);           break;
 515     case tgFEATURE      :  return testFeature(argc,argv);      break;
 516     case tgVERIFYCAP    :  return verifyCap() ? 0 : 1;         break;
 517     case tgVERIFYPROC   :  return verifyProc() ? 0 : 1;        break;
 518
 519
 520     default             : {
 521       xid_t             xid = *vserver!='\0' ? vc_xidopt2xid(vserver,true,0) : VC_SAMECTX;
 522
 523       switch (tag) {
 524         case tgID       :  res = vc_getVserverByCtx(xid,0,0);  break;
 525         case tgINITPID  :  res = getInitPid(buf, xid);         break;
 526         case tgUTS      :  res = getUTS(buf, xid, argc, argv); break;
 527         case tgXIDTYPE  :  res = getXIDType(xid, argc, argv);  break;
 528
 529         default         :  assert(false); abort();  // TODO
 530       }
 531     }
 532   }
 533
 534   if (res==0) return EXIT_FAILURE;
 535   WRITE_STR(1, res);
 536   WRITE_MSG(1, "\n");
 537   return EXIT_SUCCESS;
 538 }
 539
 540 int main(int argc, char *argv[])
 541 {
 542   bool          quiet = false;
 543   char const *  vserver;
 544   VserverTag    tag;
 545
 546   while (1) {
 547     int         c = getopt_long(argc, argv, "ql", CMDLINE_OPTIONS, 0);
 548     if (c==-1) break;
 549
 550     switch (c) {
 551       case 'h'          :  showHelp(1, argv[0], 0);
 552       case 'v'          :  showVersion();
 553       case 'l'          :  showTags();
 554       case 'q'          :  quiet = true; break;
 555       default           :
 556         WRITE_MSG(2, "Try '");
 557         WRITE_STR(2, argv[0]);
 558         WRITE_MSG(2, " --help\" for more information.\n");
 559         exit(1);
 560         break;
 561     }
 562   }
 563
 564   if (optind+2>argc) {
 565     execQuery("-", tgSYSINFO, 0, 0);
 566     WRITE_MSG(2, "\nAssumed 'SYSINFO' as no other option given; try '--help' for more information.\n");
 567     exit(0);
 568   }
 569
 570   vserver = argv[optind];
 571   tag     = stringToTag(argv[optind+1]);
 572
 573   if (tag==tgNONE) {
 574     WRITE_MSG(2, "Unknown tag; use '-l' to get list of valid tags\n");
 575     exit(1);
 576   }
 577
 578   if (quiet) {
 579     int         fd = Eopen("/dev/null", O_WRONLY, 0644);
 580     Edup2(fd, 1);
 581     Eclose(fd);
 582   }
 583
 584   return execQuery(vserver, tag, argc-(optind+2), argv+optind+2);
 585 }