use $(LIBENSCVECTOR) instead of libensc_vector.a
[util-vserver.git] / util-vserver / lib / vserver.h
index 42b0e5f..b997d29 100644 (file)
@@ -34,6 +34,7 @@
 #  define VC_ATTR_UNUSED                __attribute__((__unused__))
 #  define VC_ATTR_NORETURN              __attribute__((__noreturn__))
 #  define VC_ATTR_CONST                        __attribute__((__const__))
+#  define VC_ATTR_DEPRECATED           __attribute__((__deprecated__))
 #  if __GNUC__*0x10000 + __GNUC_MINOR__*0x100 + __GNUC_PATCHLEVEL__ >= 0x30300
 #    define VC_ATTR_NONNULL(ARGS)      __attribute__((__nonnull__ ARGS))
 #    define VC_ATTR_ALWAYSINLINE        __attribute__((__always_inline__))
@@ -51,6 +52,7 @@
 #  define VC_ATTR_UNUSED
 #  define VC_ATTR_NORETURN
 #  define VC_ATTR_ALWAYSINLINE
+#  define VC_ATTR_DEPRECATED
 #  define VC_ATTR_PURE
 #  define VC_ATTR_CONST
 #endif
 
 /** the value which is returned in error-case (no ctx found) */
 #define VC_NOCTX               ((xid_t)(-1))
+#define VC_NOXID               ((xid_t)(-1))
 /** the value which means a random (the next free) ctx */
 #define VC_DYNAMIC_XID         ((xid_t)(-1))
 /** the value which means the current ctx */
 #define VC_SAMECTX             ((xid_t)(-2))
 
+#define VC_NONID               ((nid_t)(-1))
+#define VC_DYNAMIC_NID         ((nid_t)(-1))
+
 #define VC_LIM_INFINITY                (~0ULL)
 #define VC_LIM_KEEP            (~1ULL)
 
+#define VC_CDLIM_UNSET         (0U)
+#define VC_CDLIM_INFINITY      (~0U)
+#define VC_CDLIM_KEEP          (~1U)
   
 #ifndef S_CTX_INFO_LOCK
 #  define S_CTX_INFO_LOCK      1
 #define VC_CAP_LEASE                   28
 #define VC_CAP_QUOTACTL                29
 
-#define VC_IMMUTABLE_FILE_FL           0x00000010l
-#define VC_IMMUTABLE_LINK_FL           0x00008000l
+#define VC_IMMUTABLE_FILE_FL           0x0000010lu
+#define VC_IMMUTABLE_LINK_FL           0x0008000lu
 #define VC_IMMUTABLE_ALL               (VC_IMMUTABLE_LINK_FL|VC_IMMUTABLE_FILE_FL)
 
-#define VC_IATTR_XID                   0x01000000
+#define VC_IATTR_XID                   0x01000000u
 
-#define VC_IATTR_ADMIN                 0x00000001
-#define VC_IATTR_WATCH                 0x00000002
-#define VC_IATTR_HIDE                  0x00000004
-#define VC_IATTR_FLAGS                 0x00000007
+#define VC_IATTR_ADMIN                 0x00000001u
+#define VC_IATTR_WATCH                 0x00000002u
+#define VC_IATTR_HIDE                  0x00000004u
+#define VC_IATTR_FLAGS                 0x00000007u
 
-#define VC_IATTR_BARRIER               0x00010000
-#define        VC_IATTR_IUNLINK                0x00020000
-#define VC_IATTR_IMMUTABLE             0x00040000
+#define VC_IATTR_BARRIER               0x00010000u
+#define        VC_IATTR_IUNLINK                0x00020000u
+#define VC_IATTR_IMMUTABLE             0x00040000u
 
 
 // the flags
-#define VC_VXF_INFO_LOCK               0x00000001
-#define VC_VXF_INFO_NPROC              0x00000002
-#define VC_VXF_INFO_PRIVATE            0x00000004
-#define VC_VXF_INFO_INIT               0x00000008
+#define VC_VXF_INFO_LOCK               0x00000001ull
+#define VC_VXF_INFO_NPROC              0x00000004ull
+#define VC_VXF_INFO_PRIVATE            0x00000008ull
+#define VC_VXF_INFO_INIT               0x00000010ull
+
+#define VC_VXF_INFO_HIDEINFO           0x00000020ull
+#define VC_VXF_INFO_ULIMIT             0x00000040ull
+#define VC_VXF_INFO_NAMESPACE          0x00000080ull
 
-#define VC_VXF_INFO_HIDE               0x00000010
-#define VC_VXF_INFO_ULIMIT             0x00000020
-#define VC_VXF_INFO_NSPACE             0x00000040
+#define        VC_VXF_SCHED_HARD               0x00000100ull
+#define        VC_VXF_SCHED_PRIO               0x00000200ull
+#define        VC_VXF_SCHED_PAUSE              0x00000400ull
 
-#define        VC_VXF_SCHED_HARD               0x00000100
-#define        VC_VXF_SCHED_PRIO               0x00000200
-#define        VC_VXF_SCHED_PAUSE              0x00000400
+#define VC_VXF_VIRT_MEM                        0x00010000ull
+#define VC_VXF_VIRT_UPTIME             0x00020000ull
+#define VC_VXF_VIRT_CPU                        0x00040000ull
+#define VC_VXF_VIRT_LOAD               0x00080000ull
 
-#define VC_VXF_VIRT_MEM                        0x00010000
-#define VC_VXF_VIRT_UPTIME             0x00020000
+#define VC_VXF_HIDE_MOUNT              0x01000000ull
+#define VC_VXF_HIDE_NETIF              0x02000000ull
 
 #define        VC_VXF_STATE_SETUP              (1ULL<<32)
 #define        VC_VXF_STATE_INIT               (1ULL<<33)
 
+#define VC_VXF_FORK_RSS                        (1ULL<<48)
+#define VC_VXF_PROLIFIC                        (1ULL<<49)
+
+#define VC_VXF_IGNEG_NICE              (1ULL<<52)
+
+
+// the ccapabilities
+#define VC_VXC_SET_UTSNAME             0x00000001ull
+#define VC_VXC_SET_RLIMIT              0x00000002ull
+
+#define VC_VXC_RAW_ICMP                        0x00000100ull
+
+#define VC_VXC_SECURE_MOUNT            0x00010000ull
+#define VC_VXC_SECURE_REMOUNT          0x00020000ull
+
+
+#define VC_VXSM_FILL_RATE              0x0001
+#define VC_VXSM_INTERVAL               0x0002
+#define VC_VXSM_TOKENS                 0x0010
+#define VC_VXSM_TOKENS_MIN             0x0020
+#define VC_VXSM_TOKENS_MAX             0x0040
+#define VC_VXSM_PRIO_BIAS              0x0100
+
+
 
 /** \defgroup  syscalls Syscall wrappers
  *  Functions which are calling the vserver syscall directly. */
 
 #ifdef IS_DOXYGEN
 typedef an_unsigned_integer_type       xid_t;
+typedef an_unsigned_integer_type       nid_t;
 #endif
 
 #ifdef __cplusplus
@@ -185,10 +224,24 @@ extern "C" {
 #endif
 
   struct vc_ip_mask_pair {
-    uint32_t   ip;
+      uint32_t ip;
       uint32_t mask;
   };
 
+    /** \brief   The generic vserver syscall
+     *  \ingroup syscalls
+     *
+     *  This function executes the generic vserver syscall. It uses the
+     *  correct syscallnumber (which may differ between the different
+     *  architectures).
+     *
+     *  \param   cmd  the command to be executed
+     *  \param   xid  the xid on which the cmd shall be applied
+     *  \param   data additional arguments; depends on \c cmd
+     *  \returns depends on \c cmd; usually, -1 stands for an error
+     */
+  int  vc_syscall(uint32_t cmd, xid_t xid, void *data);
+
     /** \brief   Returns the version of the current kernel API.
      *  \ingroup syscalls
      * \returns The versionnumber of the kernel API
@@ -208,7 +261,7 @@ extern "C" {
      *  \param remove_cap  The linux capabilities which will be \b removed.
      *  \param flags       Special flags which will be set.
      *
-     *  \returns  The new context-id, or VC_NOCTX on errors; errno
+     *  \returns  The new context-id, or VC_NOCTX on errors; \c errno
      *           will be set appropriately
      *
      *  See http://vserver.13thfloor.at/Stuff/Logic.txt for details */
@@ -237,16 +290,16 @@ extern "C" {
      *  \param xid  The new context; special values are:
      * - VC_DYNAMIC_XID which means to create a dynamic context
      *
-     * \returns the xid of the created context, or VC_NOCTX on errors. errno
+     * \returns the xid of the created context, or VC_NOCTX on errors. \c errno
      *          will be set appropriately. */
-  xid_t        vc_create_context(xid_t xid);
+  xid_t        vc_ctx_create(xid_t xid);
 
     /** \brief   Moves the current process into the specified context.
      *  \ingroup syscalls
      *
      *  \param   xid  The new context
      *  \returns 0 on success, -1 on errors */
-  int  vc_migrate_context(xid_t xid);
+  int  vc_ctx_migrate(xid_t xid);
   
     /* rlimit related functions */
   
@@ -330,9 +383,77 @@ extern "C" {
   int  vc_ctx_kill(xid_t ctx, pid_t pid, int sig);
 
 
+  struct vc_nx_info {
+      nid_t    nid;
+  };
+
+  nid_t                vc_get_task_nid(pid_t pid);
+  int          vc_get_nx_info(nid_t nid, struct vc_nx_info *) VC_ATTR_NONNULL((2));
+
+  typedef enum { vcNET_IPV4, vcNET_IPV6, vcNET_IPV4R, vcNET_IPV6R }    vc_net_nx_type;
+  
+  struct vc_net_nx {
+      vc_net_nx_type   type;
+      size_t           count;
+      uint32_t         ip;
+      uint32_t         mask;
+  };
+
+  nid_t                vc_net_create(nid_t nid);
+  int          vc_net_migrate(nid_t nid);
+
+  int          vc_net_add(nid_t nid, struct vc_net_nx const *info);
+  int          vc_net_remove(nid_t nid, struct vc_net_nx const *info);
+
+  struct vc_net_flags {
+      uint_least64_t   flagword;
+      uint_least64_t   mask;
+  };
+  
+  int          vc_get_nflags(nid_t, struct vc_net_flags *);
+  int          vc_set_nflags(nid_t, struct vc_net_flags const *);
+
+  
+  struct vc_net_caps {
+      uint_least64_t   ncaps;
+      uint_least64_t   cmask;
+  };
+
+  int          vc_get_ncaps(nid_t, struct vc_net_caps *);
+  int          vc_set_ncaps(nid_t, struct vc_net_caps const *);
+
+
+  
 
   int          vc_set_iattr(char const *filename, xid_t xid,
                             uint_least32_t flags, uint_least32_t mask) VC_ATTR_NONNULL((1));
+
+    /** \brief   Returns information about attributes and assigned context of a file.
+     *  \ingroup syscalls
+     *
+     *  This function returns the VC_IATTR_XXX flags and about the assigned
+     *  context of a file. To request an information, the appropriate bit in
+     *  \c mask must be set and the corresponding parameter (\a xid or \a
+     *  flags) must not be NULL.
+     *
+     *  E.g. to receive the assigned context, the \c VC_IATTR_XID bit must be
+     *  set in \a mask, and \a xid must point to valid memory.
+     *
+     *  Possible flags are \c VC_IATTR_ADMIN, \c VC_IATTR_WATCH , \c VC_IATTR_HIDE,
+     *  \c VC_IATTR_BARRIER, \c VC_IATTR_IUNLINK and \c VC_IATTR_IMMUTABLE.
+     *
+     *  \param filename  The name of the file whose attributes shall be determined.
+
+     *  \param xid       When non-zero and the VC_IATTR_XID bit is set in \a mask,
+     *                   the assigned context of \a filename will be stored there.
+     *  \param flags     When non-zero, a bitmask of current attributes will be
+     *                   stored there. These attributes must be requested explicitly
+     *                   by setting the appropriate bit in \a mask
+     *  \param mask      Points to a bitmask which tells which attributes shall be
+     *                   determined. On return, it will masquerade the attributes
+     *                   which were determined.
+     *
+     *  \pre  mask!=0 && !((*mask&VC_IATTR_XID) && xid==0) && !((*mask&~VC_IATTR_XID) && flags==0) */
   int          vc_get_iattr(char const *filename, xid_t * /*@null@*/ xid,
                             uint_least32_t * /*@null@*/ flags,
                             uint_least32_t * /*@null@*/ mask) VC_ATTR_NONNULL((1));
@@ -342,7 +463,13 @@ extern "C" {
       pid_t    initpid;
   };
   
-    /** Returns the context of the given process. pid==0 means the current process. */
+    /** \brief   Returns the context of the given process.
+     *  \ingroup syscalls
+     *
+     *  \param  pid  the process-id whose xid shall be determined;
+     *               pid==0 means the current process.
+     *  \returns     the xid of process \c pid or -1 on errors
+     */
   xid_t                vc_get_task_xid(pid_t pid);
   int          vc_get_vx_info(xid_t xid, struct vc_vx_info *info) VC_ATTR_NONNULL((2));
 
@@ -363,34 +490,106 @@ extern "C" {
   int          vc_set_namespace();
   int          vc_cleanup_namespace();
 
+  
+  /** \brief    Flags of process-contexts
+   */
   struct  vc_ctx_flags {
+      /** \brief Mask of set context flags */
       uint_least64_t   flagword;
+      /** \brief Mask of set and unset context flags when used by set
+       *         operations, or modifiable flags when used by get
+       *         operations */
       uint_least64_t   mask;
   };
-  
+
+  /** \brief    Capabilities of process-contexts */
   struct  vc_ctx_caps {
+      /** \brief  Mask of set common system capabilities */
       uint_least64_t   bcaps;
+      /** \brief Mask of set and unset common system capabilities when used by
+       *         set operations, or the modifiable capabilities when used by
+       *         get operations */
       uint_least64_t   bmask;
+      /** \brief Mask of set process context capabilities */
       uint_least64_t   ccaps;
+      /** \brief Mask of set and unset process context capabilities when used
+       *         by set operations, or the modifiable capabilities when used
+       *         by get operations */
       uint_least64_t   cmask;
   };
 
+  /** \brief    Information about parsing errors
+   *  \ingroup  helper
+   */
   struct vc_err_listparser {
-      char const       *ptr;
-      size_t           len;
+      char const       *ptr;           ///< Pointer to the first character of an erroneous string
+      size_t           len;            ///< Length of the erroneous string
   };
  
-  int                  vc_get_flags(xid_t xid, struct vc_ctx_flags *)       VC_ATTR_NONNULL((2));
-  int                  vc_set_flags(xid_t xid, struct vc_ctx_flags const *) VC_ATTR_NONNULL((2));
+  int                  vc_get_cflags(xid_t xid, struct vc_ctx_flags *)       VC_ATTR_NONNULL((2));
+  int                  vc_set_cflags(xid_t xid, struct vc_ctx_flags const *) VC_ATTR_NONNULL((2));
 
   int                  vc_get_ccaps(xid_t xid, struct vc_ctx_caps *);
   int                  vc_set_ccaps(xid_t xid, struct vc_ctx_caps const *);
 
-  uint_least64_t       vc_text2bcap(char const *, size_t len);
-  char const *         vc_lobcap2text(uint_least64_t *);
-  int                  vc_list2bcap(char const *, size_t len,
+  /** \brief   Converts a single string into bcapability
+   *  \ingroup helper
+   *
+   *  \param   str   The string to be parsed;
+   *                 both "CAP_xxx" and "xxx" will be accepted
+   *  \param   len   The length of the string, or \c 0 for automatic detection
+   *
+   *  \returns 0 on error; a bitmask on success
+   *  \pre     \a str != 0
+   */
+  uint_least64_t       vc_text2bcap(char const *str, size_t len);
+
+  /** \brief   Converts the lowest bit of a bcapability or the entire value
+   *           (when possible) to a textual representation
+   *  \ingroup helper
+   *
+   *  \param   val  The string to be converted; on success, the detected bit(s)
+   *                will be unset, in errorcase only the lowest set bit
+   *
+   *  \returns A textual representation of \a val resp. of its lowest set bit;
+   *           or \c NULL in errorcase.
+   *  \pre     \a val!=0
+   *  \post    \a *val<sub>old</sub> \c != 0  \c <-->
+   *               \a *val<sub>old</sub> > \a *val<sub>new</sub>
+   *  \post    \a *val<sub>old</sub> \c == 0  \c --->  \a result == 0
+   */
+  char const * vc_lobcap2text(uint_least64_t *val) VC_ATTR_NONNULL((1));
+
+  /** \brief   Converts a string into a bcapability-bitmask
+   *  \ingroup helper
+   *
+   *  Syntax of \a str: \verbinclude list2xxx.syntax
+   *
+   *  When the \c `~' prefix is used, the bits will be unset and a `~' after
+   *  another `~' will cancel both ones. The \c `^' prefix specifies a
+   *  bitnumber instead of a bitmask.
+   *
+   *  "literal name" is everything which will be accepted by the
+   *  vc_text2bcap() function. The special values for \c NAME will be
+   *  recognized case insensitively
+   *
+   *  \param  str   The string to be parsed
+   *  \param  len   The length of the string, or \c 0 for automatic detection
+   *  \param  err   Pointer to a structure for error-information, or \c NULL.
+   *  \param  cap   Pointer to a vc_ctx_caps structure holding the results;
+   *                only the \a bcaps and \a bmask fields will be changed and
+   *                already set values will not be honored. When an error
+   *                occured, \a cap will have the value of all processed valid
+   *                \c BCAP parts.
+   *
+   *  \returns 0 on success, -1 on error. In error case, \a err will hold
+   *           position and length of the first not understood BCAP part
+   *  \pre     \a str != 0 && \a cap != 0;
+   *           \a cap->bcaps and \a cap->bmask must be initialized
+   */
+  int                  vc_list2bcap(char const *str, size_t len,
                                     struct vc_err_listparser *err,
-                                    struct vc_ctx_caps *);
+                                    struct vc_ctx_caps *cap) VC_ATTR_NONNULL((1,4));
 
   uint_least64_t       vc_text2ccap(char const *, size_t len);
   char const *         vc_loccap2text(uint_least64_t *);
@@ -398,62 +597,113 @@ extern "C" {
                                     struct vc_err_listparser *err,
                                     struct vc_ctx_caps *);
 
-  int                  vc_list2flag(char const *, size_t len,
+  int                  vc_list2cflag(char const *, size_t len,
                                     struct vc_err_listparser *err,
                                     struct vc_ctx_flags *flags);
-  uint_least64_t       vc_text2flag(char const *, size_t len);
-  char const *         vc_loflag2text(uint_least64_t *);
+  uint_least64_t       vc_text2cflag(char const *, size_t len);
+  char const *         vc_locflag2text(uint_least64_t *);
   
-  uint_least32_t       vc_list2flag_compat(char const *, size_t len,
+  uint_least32_t       vc_list2cflag_compat(char const *, size_t len,
                                            struct vc_err_listparser *err);
-  uint_least32_t       vc_text2flag_compat(char const *, size_t len);
-  char const *         vc_hiflag2text_compat(uint_least32_t);
+  uint_least32_t       vc_text2cflag_compat(char const *, size_t len);
+  char const *         vc_hicflag2text_compat(uint_least32_t);
+
+  int                  vc_text2cap(char const *);
+  char const *         vc_cap2text(unsigned int);
+
   
-  int          vc_text2cap(char const *);
-  char const * vc_cap2text(unsigned int);
-
-  inline static uint_least32_t vc_get_insecurecaps() {
-    return ( (1<<VC_CAP_LINUX_IMMUTABLE) | (1<<VC_CAP_NET_BROADCAST) |
-            (1<<VC_CAP_NET_ADMIN) | (1<<VC_CAP_NET_RAW) |
-            (1<<VC_CAP_IPC_LOCK) | (1<<VC_CAP_IPC_OWNER) |
-            (1<<VC_CAP_SYS_MODULE) | (1<<VC_CAP_SYS_RAWIO) |
-            (1<<VC_CAP_SYS_PACCT) | (1<<VC_CAP_SYS_ADMIN) |
-            (1<<VC_CAP_SYS_BOOT) | (1<<VC_CAP_SYS_NICE) |
-            (1<<VC_CAP_SYS_RESOURCE) | (1<<VC_CAP_SYS_TIME) |
-            (1<<VC_CAP_MKNOD) | (1<<VC_CAP_QUOTACTL) );
-  }
+  int                  vc_list2nflag(char const *, size_t len,
+                                    struct vc_err_listparser *err,
+                                    struct vc_net_flags *flags);
+  uint_least64_t       vc_text2nflag(char const *, size_t len);
+  char const *         vc_lonflag2text(uint_least64_t *);
 
-  inline static int            vc_setfilecontext(char const *filename, xid_t xid) {
-    return vc_set_iattr(filename, xid, 0, VC_IATTR_XID);
+  uint_least64_t       vc_text2ncap(char const *, size_t len);
+  char const *         vc_loncap2text(uint_least64_t *);
+  int                  vc_list2ncap(char const *, size_t len,
+                                    struct vc_err_listparser *err,
+                                    struct vc_net_caps *);
+
+  uint_least64_t               vc_get_insecurebcaps() VC_ATTR_CONST;
+  inline static uint_least64_t vc_get_insecureccaps() {
+    return ~(VC_VXC_SET_UTSNAME|VC_VXC_RAW_ICMP);
   }
   
-  inline static xid_t          vc_getfilecontext(char const *filename) {
-    xid_t      res;
-    if (vc_get_iattr(filename, &res, 0,0)==-1) return VC_NOCTX;
-    return res;
+  inline static int    vc_setfilecontext(char const *filename, xid_t xid) {
+    return vc_set_iattr(filename, xid, 0, VC_IATTR_XID);
   }
+  
+  /** \brief   Returns the context of \c filename
+   *  \ingroup syscalls
+   *
+   *  This function calls vc_get_iattr() with appropriate arguments to
+   *  determine the context of \c filename. In error-case or when no context
+   *  is assigned, \c VC_NOCTX will be returned. To differ between both cases,
+   *  \c errno must be examined.
+   *
+   *  \b WARNING: this function can modify \c errno although no error happened.
+   *
+   *  \param   filename  The file to check
+   *  \returns The assigned context, or VC_NOCTX when an error occured or no
+   *           such assignment exists. \c errno will be 0 in the latter case */
+  xid_t                vc_getfilecontext(char const *filename) VC_ATTR_NONNULL((1));
 
 
   struct vc_set_sched {
-      int32_t  fill_rate;
-      int32_t  interval;
-      int32_t  tokens;
-      int32_t  tokens_min;
-      int32_t  tokens_max;
-      uint64_t cpu_mask;
+      uint_least32_t   set_mask;
+      int_least32_t    fill_rate;
+      int_least32_t    interval;
+      int_least32_t    tokens;
+      int_least32_t    tokens_min;
+      int_least32_t    tokens_max;
+      int_least32_t    priority_bias;
   };
 
   int          vc_set_sched(xid_t xid, struct vc_set_sched const *);
+
+
+  struct vc_ctx_dlimit {
+      uint_least32_t   space_used;
+      uint_least32_t   space_total;
+      uint_least32_t   inodes_used;
+      uint_least32_t   inodes_total;
+      uint_least32_t   reserved;
+  };
   
+
+  /** Add a disk limit to a file system. */
+  int          vc_add_dlimit(char const *filename, xid_t xid,
+                             uint_least32_t flags) VC_ATTR_NONNULL((1));
+  /** Remove a disk limit from a file system. */
+  int          vc_rem_dlimit(char const *filename, xid_t xid,
+                             uint_least32_t flags) VC_ATTR_NONNULL((1));
+
+  /** Set a disk limit. */
+  int          vc_set_dlimit(char const *filename, xid_t xid,
+                             uint_least32_t flags,
+                             struct vc_ctx_dlimit const *limits) VC_ATTR_NONNULL((1,4));
+  /** Get a disk limit. */
+  int          vc_get_dlimit(char const *filename, xid_t xid,
+                             uint_least32_t flags,
+                             struct vc_ctx_dlimit *limits) VC_ATTR_NONNULL((1));
   
+    
   typedef enum { vcFEATURE_VKILL,  vcFEATURE_IATTR,   vcFEATURE_RLIMIT,
                 vcFEATURE_COMPAT, vcFEATURE_MIGRATE, vcFEATURE_NAMESPACE,
-                vcFEATURE_SCHED,  vcFEATURE_VINFO,   vcFEATURE_VHI }
+                vcFEATURE_SCHED,  vcFEATURE_VINFO,   vcFEATURE_VHI,
+                 vcFEATURE_VSHELPER0, vcFEATURE_VSHELPER }
     vcFeatureSet;
 
-  bool         vc_isSupported(vcFeatureSet);
+  bool         vc_isSupported(vcFeatureSet) VC_ATTR_CONST;
   bool         vc_isSupportedString(char const *);
+
+  
+  typedef enum { vcTYPE_INVALID, vcTYPE_MAIN, vcTYPE_WATCH,
+                vcTYPE_STATIC, vcTYPE_DYNAMIC }
+    vcXidType;
   
+  vcXidType    vc_getXIDType(xid_t xid) VC_ATTR_CONST;
+
   /* The management part */
 
 #define VC_LIMIT_VSERVER_NAME_LEN      1024
@@ -504,15 +754,16 @@ extern "C" {
       freed by the caller. */
   char *       vc_getVserverByCtx(xid_t ctx, /*@null@*/vcCfgStyle *style,
                                   /*@null@*/char const *revdir);
-
 #define vcSKEL_INTERFACES      1u
 #define vcSKEL_PKGMGMT         2u
 #define vcSKEL_FILESYSTEM      4u
-  
+
   /** Create a basic configuration skeleton for a vserver plus toplevel
    *  directories for pkgmanagemt and filesystem (when requested). */
   int          vc_createSkeleton(char const *id, vcCfgStyle style, int flags);
-  
+
+
 #ifdef __cplusplus
 }
 #endif