revamp resolve tree file and adapt to new funtion format

src/include/66/tree.h

@@ -32,9 +32,6 @@
 #define TREE_GROUPS_USER "user"
 #define TREE_GROUPS_USER_LEN (sizeof TREE_GROUPS_USER - 1)
 
-#define DATA_TREE 1
-#define DATA_TREE_MASTER 2
-
 typedef struct resolve_tree_s resolve_tree_t, *resolve_tree_t_ref ;
 struct resolve_tree_s
 {
@@ -62,20 +59,20 @@ struct resolve_tree_s
 typedef enum resolve_tree_enum_e resolve_tree_enum_t, *resolve_tree_enum_t_ref;
 enum resolve_tree_enum_e
 {
-    TREE_ENUM_NAME = 0,
-    TREE_ENUM_DEPENDS,
-    TREE_ENUM_REQUIREDBY,
-    TREE_ENUM_ALLOW,
-    TREE_ENUM_GROUPS,
-    TREE_ENUM_CONTENTS,
-    TREE_ENUM_NDEPENDS,
-    TREE_ENUM_NREQUIREDBY,
-    TREE_ENUM_NALLOW,
-    TREE_ENUM_NGROUPS,
-    TREE_ENUM_NCONTENTS,
-    TREE_ENUM_INIT,
-    TREE_ENUM_DISEN,
-    TREE_ENUM_ENDOFKEY
+    E_RESOLVE_TREE_NAME = 0,
+    E_RESOLVE_TREE_DEPENDS,
+    E_RESOLVE_TREE_REQUIREDBY,
+    E_RESOLVE_TREE_ALLOW,
+    E_RESOLVE_TREE_GROUPS,
+    E_RESOLVE_TREE_CONTENTS,
+    E_RESOLVE_TREE_NDEPENDS,
+    E_RESOLVE_TREE_NREQUIREDBY,
+    E_RESOLVE_TREE_NALLOW,
+    E_RESOLVE_TREE_NGROUPS,
+    E_RESOLVE_TREE_NCONTENTS,
+    E_RESOLVE_TREE_INIT,
+    E_RESOLVE_TREE_DISEN,
+    E_RESOLVE_TREE_ENDOFKEY
 } ;
 
 typedef struct resolve_tree_master_s resolve_tree_master_t, *resolve_tree_master_t_ref ;
@@ -99,14 +96,14 @@ struct resolve_tree_master_s
 typedef enum resolve_tree_master_enum_e resolve_tree_master_enum_t, *resolve_tree_master_enum_t_ref;
 enum resolve_tree_master_enum_e
 {
-    TREE_ENUM_MASTER_NAME = 0,
-    TREE_ENUM_MASTER_ALLOW,
-    TREE_ENUM_MASTER_ENABLED,
-    TREE_ENUM_MASTER_CURRENT,
-    TREE_ENUM_MASTER_CONTENTS,
-    TREE_ENUM_MASTER_NENABLED,
-    TREE_ENUM_MASTER_NCONTENTS,
-    TREE_ENUM_MASTER_ENDOFKEY
+    E_RESOLVE_TREE_MASTER_NAME = 0,
+    E_RESOLVE_TREE_MASTER_ALLOW,
+    E_RESOLVE_TREE_MASTER_ENABLED,
+    E_RESOLVE_TREE_MASTER_CURRENT,
+    E_RESOLVE_TREE_MASTER_CONTENTS,
+    E_RESOLVE_TREE_MASTER_NENABLED,
+    E_RESOLVE_TREE_MASTER_NCONTENTS,
+    E_RESOLVE_TREE_MASTER_ENDOFKEY
 } ;
 
 extern resolve_field_table_t resolve_tree_field_table[] ;
@@ -162,13 +159,8 @@ extern int tree_isenabled(char const *base, char const *treename) ;
  * @Return -1 on system error */
 extern int tree_ongroups(char const *base, char const *treename, char const *group) ;
 
-extern int tree_cmd_state(unsigned int verbosity,char const *cmd,char const *tree) ;
-extern int tree_state(int argc, char const *const *argv) ;
-
 extern int tree_copy(stralloc *dir, char const *tree,char const *treename) ;
 
-extern int tree_copy_tmp(char const *workdir, ssexec_t *info) ;
-
 extern int tree_get_permissions(char const *tree, uid_t owner) ;
 
 extern int tree_sethome(ssexec_t *info) ;

src/lib66/tree/deps-lib/deps

-tree_cmd_state.o
-tree_copy.o
-tree_copy_tmp.o
 tree_find_current.o
 tree_get_permissions.o
 tree_iscurrent.o

src/lib66/tree/tree_find_current.c

@@ -28,18 +28,17 @@ int tree_find_current(stralloc *tree, char const *base)
     log_flow() ;
 
     int e = 0 ;
-    size_t baselen = strlen(base) ;
     resolve_tree_master_t mres = RESOLVE_TREE_MASTER_ZERO ;
     resolve_wrapper_t_ref wres = resolve_set_struct(DATA_TREE_MASTER, &mres) ;
-    char t[baselen + SS_SYSTEM_LEN + 1] ;
 
-    auto_strings(t, base, SS_SYSTEM) ;
-
-    if (!resolve_read(wres, t, SS_MASTER + 1))
+    if (!resolve_read_g(wres, base, SS_MASTER + 1))
         goto err ;
 
-    if (!auto_stra(tree, base, SS_SYSTEM, "/", mres.sa.s + mres.current))
-        goto err ;
+    if (mres.current) {
+        if (!auto_stra(tree, base, SS_SYSTEM, "/", mres.sa.s + mres.current))
+            goto err ;
+
+    } else goto err ;
 
     e = 1 ;
     err:

src/lib66/tree/tree_iscurrent.c

@@ -26,14 +26,10 @@ int tree_iscurrent(char const *base, char const *treename)
     log_flow() ;
 
     int e = -1 ;
-    size_t baselen = strlen(base) ;
     resolve_tree_master_t mres = RESOLVE_TREE_MASTER_ZERO ;
     resolve_wrapper_t_ref wres = resolve_set_struct(DATA_TREE_MASTER, &mres) ;
-    char t[baselen + SS_SYSTEM_LEN + 1] ;
 
-    auto_strings(t, base, SS_SYSTEM) ;
-
-    if (!resolve_read(wres, t, SS_MASTER + 1))
+    if (!resolve_read_g(wres, base, SS_MASTER + 1))
         goto err ;
 
     if (!strcmp(mres.sa.s + mres.current, treename))

src/lib66/tree/tree_isenabled.c

@@ -27,15 +27,12 @@ int tree_isenabled(char const *base, char const *treename)
     log_flow() ;
 
     int e = -1 ;
-    size_t baselen = strlen(base), pos = 0 ;
+    size_t pos = 0 ;
     stralloc sa = STRALLOC_ZERO ;
     resolve_tree_master_t mres = RESOLVE_TREE_MASTER_ZERO ;
     resolve_wrapper_t_ref wres = resolve_set_struct(DATA_TREE_MASTER, &mres) ;
-    char solve[baselen + SS_SYSTEM_LEN + 1] ;
 
-    auto_strings(solve, base, SS_SYSTEM) ;
-
-    if (!resolve_read(wres, solve, SS_MASTER + 1))
+    if (!resolve_read_g(wres, base, SS_MASTER + 1))
         goto err ;
 
     if (mres.nenabled) {

src/lib66/tree/tree_isinitialized.c

@@ -26,14 +26,10 @@ int tree_isinitialized(char const *base, char const *treename)
     log_flow() ;
 
     int e = -1 ;
-    size_t baselen = strlen(base) ;
     resolve_tree_t tres = RESOLVE_TREE_ZERO ;
     resolve_wrapper_t_ref wres = resolve_set_struct(DATA_TREE, &tres) ;
-    char solve[baselen + SS_SYSTEM_LEN + 1] ;
 
-    auto_strings(solve, base, SS_SYSTEM) ;
-
-    if (!resolve_read(wres, solve, treename))
+    if (!resolve_read_g(wres, base, treename))
         goto err ;
 
     if (tres.init)

src/lib66/tree/tree_ongroups.c

@@ -29,15 +29,12 @@ int tree_ongroups(char const *base, char const *treename, char const *group)
     log_flow() ;
 
     int e = -1 ;
-    size_t baselen = strlen(base), pos = 0 ;
+    size_t pos = 0 ;
     stralloc sa = STRALLOC_ZERO ;
     resolve_tree_t tres = RESOLVE_TREE_ZERO ;
     resolve_wrapper_t_ref wres = resolve_set_struct(DATA_TREE, &tres) ;
-    char solve[baselen + SS_SYSTEM_LEN + 1] ;
 
-    auto_strings(solve, base, SS_SYSTEM) ;
-
-    if (!resolve_read(wres, solve, treename))
+    if (!resolve_read_g(wres, base, treename))
         goto err ;
 
     if (tres.ngroups) {

src/lib66/tree/tree_resolve_get_field_tosa.c

@@ -29,61 +29,61 @@ int tree_resolve_get_field_tosa(stralloc *sa, resolve_tree_t *tres, resolve_tree
 
     switch(field) {
 
-        case TREE_ENUM_NAME:
+        case E_RESOLVE_TREE_NAME:
             str = tres->sa.s + tres->name ;
             break ;
 
-        case TREE_ENUM_DEPENDS:
+        case E_RESOLVE_TREE_DEPENDS:
             str = tres->sa.s + tres->depends ;
             break ;
 
-        case TREE_ENUM_REQUIREDBY:
+        case E_RESOLVE_TREE_REQUIREDBY:
             str = tres->sa.s + tres->requiredby ;
             break ;
 
-        case TREE_ENUM_ALLOW:
+        case E_RESOLVE_TREE_ALLOW:
             str = tres->sa.s + tres->allow ;
             break ;
 
-        case TREE_ENUM_GROUPS:
+        case E_RESOLVE_TREE_GROUPS:
             str = tres->sa.s + tres->groups ;
             break ;
 
-        case TREE_ENUM_CONTENTS:
+        case E_RESOLVE_TREE_CONTENTS:
             str = tres->sa.s + tres->contents ;
             break ;
 
-        case TREE_ENUM_NDEPENDS:
+        case E_RESOLVE_TREE_NDEPENDS:
             fmt[uint32_fmt(fmt,tres->ndepends)] = 0 ;
             str = fmt ;
             break ;
 
-        case TREE_ENUM_NREQUIREDBY:
+        case E_RESOLVE_TREE_NREQUIREDBY:
             fmt[uint32_fmt(fmt,tres->nrequiredby)] = 0 ;
             str = fmt ;
             break ;
 
-        case TREE_ENUM_NALLOW:
+        case E_RESOLVE_TREE_NALLOW:
             fmt[uint32_fmt(fmt,tres->nallow)] = 0 ;
             str = fmt ;
             break ;
 
-        case TREE_ENUM_NGROUPS:
+        case E_RESOLVE_TREE_NGROUPS:
             fmt[uint32_fmt(fmt,tres->ngroups)] = 0 ;
             str = fmt ;
             break ;
 
-        case TREE_ENUM_NCONTENTS:
+        case E_RESOLVE_TREE_NCONTENTS:
             fmt[uint32_fmt(fmt,tres->ncontents)] = 0 ;
             str = fmt ;
             break ;
 
-        case TREE_ENUM_INIT:
+        case E_RESOLVE_TREE_INIT:
             fmt[uint32_fmt(fmt,tres->init)] = 0 ;
             str = fmt ;
             break ;
 
-        case TREE_ENUM_DISEN:
+        case E_RESOLVE_TREE_DISEN:
             fmt[uint32_fmt(fmt,tres->disen)] = 0 ;
             str = fmt ;
             break ;

src/lib66/tree/tree_resolve_master_create.c

@@ -30,11 +30,9 @@ int tree_resolve_master_create(char const *base, uid_t owner)
     log_flow() ;
 
     int e = 0 ;
-    size_t baselen = strlen(base) ;
     struct passwd *pw = getpwuid(owner) ;
     resolve_tree_master_t mres = RESOLVE_TREE_MASTER_ZERO ;
     resolve_wrapper_t_ref wres = resolve_set_struct(DATA_TREE_MASTER, &mres) ;
-    char dst[baselen + SS_SYSTEM_LEN + 1] ;
 
     if (!pw) {
 
@@ -45,13 +43,11 @@ int tree_resolve_master_create(char const *base, uid_t owner)
 
     resolve_init(wres) ;
 
-    auto_strings(dst, base, SS_SYSTEM) ;
-
     mres.name = resolve_add_string(wres, SS_MASTER + 1) ;
     mres.allow = resolve_add_string(wres, pw->pw_name) ;
 
     log_trace("write Master resolve file of trees") ;
-    if (!resolve_write(wres, dst, SS_MASTER + 1))
+    if (!resolve_write_g(wres, base, SS_MASTER + 1))
         goto err ;
 
     e  = 1 ;

src/lib66/tree/tree_resolve_master_get_field_tosa.c

@@ -19,7 +19,7 @@
 #include <skalibs/types.h>//UINT_FMT
 
 #include <66/tree.h>
-#include <stdio.h>
+
 int tree_resolve_master_get_field_tosa(stralloc *sa, resolve_tree_master_t *mres, resolve_tree_master_enum_t field)
 {
     log_flow() ;
@@ -29,32 +29,32 @@ int tree_resolve_master_get_field_tosa(stralloc *sa, resolve_tree_master_t *mres
 
     switch(field) {
 
-        case TREE_ENUM_MASTER_NAME:
+        case E_RESOLVE_TREE_MASTER_NAME:
             str = mres->sa.s + mres->name ;
             break ;
 
-        case TREE_ENUM_MASTER_ALLOW:
+        case E_RESOLVE_TREE_MASTER_ALLOW:
             str = mres->sa.s + mres->allow ;
             break ;
 
-        case TREE_ENUM_MASTER_ENABLED:
+        case E_RESOLVE_TREE_MASTER_ENABLED:
             str = mres->sa.s + mres->enabled ;
             break ;
 
-        case TREE_ENUM_MASTER_CURRENT:
+        case E_RESOLVE_TREE_MASTER_CURRENT:
             str = mres->sa.s + mres->current ;
             break ;
 
-        case TREE_ENUM_MASTER_CONTENTS:
+        case E_RESOLVE_TREE_MASTER_CONTENTS:
             str = mres->sa.s + mres->contents ;
             break ;
 
-        case TREE_ENUM_MASTER_NENABLED:
+        case E_RESOLVE_TREE_MASTER_NENABLED:
             fmt[uint32_fmt(fmt,mres->nenabled)] = 0 ;
             str = fmt ;
             break ;
 
-        case TREE_ENUM_MASTER_NCONTENTS:
+        case E_RESOLVE_TREE_MASTER_NCONTENTS:
             fmt[uint32_fmt(fmt,mres->ncontents)] = 0 ;
             str = fmt ;
             break ;

src/lib66/tree/tree_resolve_master_modify_field.c

@@ -24,14 +24,14 @@
 
 resolve_field_table_t resolve_tree_master_field_table[] = {
 
-    [TREE_ENUM_MASTER_NAME] = { .field = "name" },
-    [TREE_ENUM_MASTER_ALLOW] = { .field = "allow" },
-    [TREE_ENUM_MASTER_ENABLED] = { .field = "enabled" },
-    [TREE_ENUM_MASTER_CURRENT] = { .field = "current" },
-    [TREE_ENUM_MASTER_CONTENTS] = { .field = "contents" },
-    [TREE_ENUM_MASTER_NENABLED] = { .field = "nenabled" },
-    [TREE_ENUM_MASTER_NCONTENTS] = { .field = "ncontents" },
-    [TREE_ENUM_MASTER_ENDOFKEY] = { .field = 0 }
+    [E_RESOLVE_TREE_MASTER_NAME] = { .field = "name" },
+    [E_RESOLVE_TREE_MASTER_ALLOW] = { .field = "allow" },
+    [E_RESOLVE_TREE_MASTER_ENABLED] = { .field = "enabled" },
+    [E_RESOLVE_TREE_MASTER_CURRENT] = { .field = "current" },
+    [E_RESOLVE_TREE_MASTER_CONTENTS] = { .field = "contents" },
+    [E_RESOLVE_TREE_MASTER_NENABLED] = { .field = "nenabled" },
+    [E_RESOLVE_TREE_MASTER_NCONTENTS] = { .field = "ncontents" },
+    [E_RESOLVE_TREE_MASTER_ENDOFKEY] = { .field = 0 }
 } ;
 
 int tree_resolve_master_modify_field(resolve_tree_master_t *mres, uint8_t field, char const *data)
@@ -45,32 +45,36 @@ int tree_resolve_master_modify_field(resolve_tree_master_t *mres, uint8_t field,
 
     switch(field) {
 
-        case TREE_ENUM_MASTER_NAME:
+        case E_RESOLVE_TREE_MASTER_NAME:
             mres->name = resolve_add_string(wres,data) ;
             break ;
 
-        case TREE_ENUM_MASTER_ALLOW:
+        case E_RESOLVE_TREE_MASTER_ALLOW:
             mres->allow = resolve_add_string(wres,data) ;
             break ;
 
-        case TREE_ENUM_MASTER_ENABLED:
+        case E_RESOLVE_TREE_MASTER_ENABLED:
             mres->enabled = resolve_add_string(wres,data) ;
             break ;
 
-        case TREE_ENUM_MASTER_CURRENT:
+        case E_RESOLVE_TREE_MASTER_CURRENT:
             mres->current = resolve_add_string(wres,data) ;
             break ;
 
-        case TREE_ENUM_MASTER_CONTENTS:
+        case E_RESOLVE_TREE_MASTER_CONTENTS:
             mres->contents = resolve_add_string(wres,data) ;
             break ;
 
-        case TREE_ENUM_MASTER_NENABLED:
+        case E_RESOLVE_TREE_MASTER_NENABLED:
+            if (!data)
+                data = "0" ;
             if (!uint0_scan(data, &ifield)) goto err ;
             mres->nenabled = ifield ;
             break ;
 
-        case TREE_ENUM_MASTER_NCONTENTS:
+        case E_RESOLVE_TREE_MASTER_NCONTENTS:
+            if (!data)
+                data = "0" ;
             if (!uint0_scan(data, &ifield)) goto err ;
             mres->ncontents = ifield ;
             break ;

src/lib66/tree/tree_resolve_modify_field.c

@@ -24,88 +24,102 @@
 
 resolve_field_table_t resolve_tree_field_table[] = {
 
-    [TREE_ENUM_NAME] = { .field = "name" },
-    [TREE_ENUM_DEPENDS] = { .field = "depends" },
-    [TREE_ENUM_REQUIREDBY] = { .field = "requiredby" },
-    [TREE_ENUM_ALLOW] = { .field = "allow" },
-    [TREE_ENUM_GROUPS] = { .field = "groups" },
-    [TREE_ENUM_CONTENTS] = { .field = "contents" },
-    [TREE_ENUM_NDEPENDS] = { .field = "ndepends" },
-    [TREE_ENUM_NREQUIREDBY] = { .field = "nrequiredby" },
-    [TREE_ENUM_NALLOW] = { .field = "nallow" },
-    [TREE_ENUM_NGROUPS] = { .field = "ngroups" },
-    [TREE_ENUM_NCONTENTS] = { .field = "ncontents" },
-    [TREE_ENUM_INIT] = { .field = "init" },
-    [TREE_ENUM_DISEN] = { .field = "disen" },
-    [TREE_ENUM_ENDOFKEY] = { .field = 0 }
+    [E_RESOLVE_TREE_NAME] = { .field = "name" },
+    [E_RESOLVE_TREE_DEPENDS] = { .field = "depends" },
+    [E_RESOLVE_TREE_REQUIREDBY] = { .field = "requiredby" },
+    [E_RESOLVE_TREE_ALLOW] = { .field = "allow" },
+    [E_RESOLVE_TREE_GROUPS] = { .field = "groups" },
+    [E_RESOLVE_TREE_CONTENTS] = { .field = "contents" },
+    [E_RESOLVE_TREE_NDEPENDS] = { .field = "ndepends" },
+    [E_RESOLVE_TREE_NREQUIREDBY] = { .field = "nrequiredby" },
+    [E_RESOLVE_TREE_NALLOW] = { .field = "nallow" },
+    [E_RESOLVE_TREE_NGROUPS] = { .field = "ngroups" },
+    [E_RESOLVE_TREE_NCONTENTS] = { .field = "ncontents" },
+    [E_RESOLVE_TREE_INIT] = { .field = "init" },
+    [E_RESOLVE_TREE_DISEN] = { .field = "disen" },
+    [E_RESOLVE_TREE_ENDOFKEY] = { .field = 0 }
 } ;
 
 int tree_resolve_modify_field(resolve_tree_t *tres, uint8_t field, char const *data)
 {
     log_flow() ;
 
-    uint32_t ifield ;
+    uint32_t ifield = 0 ;
     int e = 0 ;
 
     resolve_wrapper_t_ref wres = resolve_set_struct(DATA_TREE, tres) ;
 
     switch(field) {
 
-        case TREE_ENUM_NAME:
+        case E_RESOLVE_TREE_NAME:
             tres->name = resolve_add_string(wres,data) ;
             break ;
 
-        case TREE_ENUM_DEPENDS:
+        case E_RESOLVE_TREE_DEPENDS:
             tres->depends = resolve_add_string(wres,data) ;
             break ;
 
-        case TREE_ENUM_REQUIREDBY:
+        case E_RESOLVE_TREE_REQUIREDBY:
             tres->requiredby = resolve_add_string(wres,data) ;
             break ;
 
-        case TREE_ENUM_ALLOW:
+        case E_RESOLVE_TREE_ALLOW:
             tres->allow = resolve_add_string(wres,data) ;
             break ;
 
-        case TREE_ENUM_GROUPS:
+        case E_RESOLVE_TREE_GROUPS:
             tres->groups = resolve_add_string(wres,data) ;
             break ;
 
-        case TREE_ENUM_CONTENTS:
+        case E_RESOLVE_TREE_CONTENTS:
             tres->contents = resolve_add_string(wres,data) ;
             break ;
 
-        case TREE_ENUM_NDEPENDS:
+        case E_RESOLVE_TREE_NDEPENDS:
+            if (!data)
+                data = "0" ;
             if (!uint0_scan(data, &ifield)) goto err ;
             tres->ndepends = ifield ;
             break ;
 
-        case TREE_ENUM_NREQUIREDBY:
+        case E_RESOLVE_TREE_NREQUIREDBY:
+            if (!data)
+                data = "0" ;
             if (!uint0_scan(data, &ifield)) goto err ;
             tres->nrequiredby = ifield ;
             break ;
 
-        case TREE_ENUM_NALLOW:
+        case E_RESOLVE_TREE_NALLOW:
+            if (!data)
+                data = "0" ;
             if (!uint0_scan(data, &ifield)) goto err ;
             tres->nallow = ifield ;
             break ;
 
-        case TREE_ENUM_NGROUPS:
+        case E_RESOLVE_TREE_NGROUPS:
+            if (!data)
+                data = "0" ;
             if (!uint0_scan(data, &ifield)) goto err ;
             tres->ngroups = ifield ;
             break ;
 
-        case TREE_ENUM_NCONTENTS:
+        case E_RESOLVE_TREE_NCONTENTS:
+            if (!data)
+                data = "0" ;
             if (!uint0_scan(data, &ifield)) goto err ;
             tres->ncontents = ifield ;
             break ;
 
-        case TREE_ENUM_INIT:
+        case E_RESOLVE_TREE_INIT:
+            if (!data)
+                data = "0" ;
             if (!uint0_scan(data, &ifield)) goto err ;
             tres->init = ifield ;
             break ;
 
-        case TREE_ENUM_DISEN:
+        case E_RESOLVE_TREE_DISEN:
+            if (!data)
+                data = "0" ;
             if (!uint0_scan(data, &ifield)) goto err ;
             tres->disen = ifield ;
             break ;

src/lib66/tree/tree_sethome.c

@@ -17,7 +17,6 @@
 
 #include <oblibs/log.h>
 #include <oblibs/string.h>
-#include <oblibs/environ.h> //char const **environ ;
 
 #include <66/constants.h>
 #include <66/ssexec.h>
@@ -59,8 +58,8 @@ int tree_sethome(ssexec_t *info)
             /** Tree doesn't exist yet.
              * Let see if we have a seed/<name> to create it,
              * but only if we come from the 66-enable tool. */
-            if (strcmp(info->prog, "66-enable"))
-                return 0 ;
+            //if (strcmp(info->prog, "66-enable"))
+              //  return 0 ;
 
             if (!tree_seed_isvalid(info->treename.s))
                 log_warnu_return(LOG_EXIT_ZERO,"find a seed file to create the tree: ", info->treename.s) ;
@@ -69,14 +68,14 @@ int tree_sethome(ssexec_t *info)
             char const *newargv[nargc] ;
             unsigned int m = 0 ;
 
-            newargv[m++] = "fake_name" ;
+            newargv[m++] = "66-tree" ;
             newargv[m++] = info->treename.s ;
             newargv[m++] = 0 ;
 
-            if (ssexec_tree(nargc, newargv,(char const *const *)environ, info))
+            if (ssexec_tree(nargc, newargv, info))
                 log_warnu_return(LOG_EXIT_ZERO,"create tree: ",info->treename.s) ;
         }
-        /** The tree_sethome() function can be recursively called. The info->tree may not empty.
+        /** The tree_sethome() function can be recursively called. The info->tree may not be empty.
          * Be sure to clean up before using it. */
         info->tree.len = 0 ;
         if (!auto_stra(&info->tree, base, SS_SYSTEM, "/", info->treename.s))

src/lib66/tree/tree_switch_current.c

@@ -12,23 +12,62 @@
  * except according to the terms contained in the LICENSE file./
  */
 
+#include <string.h>
+
+#include <oblibs/string.h>
 #include <oblibs/log.h>
+#include <oblibs/types.h>
+#include <oblibs/directory.h>
+
+#include <skalibs/unix-transactional.h>
+#include <skalibs/types.h>
 
 #include <66/constants.h>
 #include <66/resolve.h>
 #include <66/tree.h>
+#include <66/utils.h>
 
 int tree_switch_current(char const *base, char const *treename)
 {
     log_flow() ;
 
+    int r = 0, e = 0 ;
+    size_t baselen = strlen(base) ;
+    size_t treelen = strlen(treename) ;
+
     resolve_tree_master_t mres = RESOLVE_TREE_MASTER_ZERO ;
     resolve_wrapper_t_ref wres = resolve_set_struct(DATA_TREE_MASTER, &mres) ;
 
-    if (!resolve_modify_field_g(wres, base, SS_MASTER + 1, TREE_ENUM_MASTER_CURRENT,  treename))
-        log_warnu_return(LOG_EXIT_ZERO, "modify field: ", resolve_tree_master_field_table[TREE_ENUM_MASTER_CURRENT].field," of inner resolve file with value: ", treename) ;
+    char pack[UID_FMT] ;
+    size_t packlen = uint_fmt(pack, MYUID) ;
+    pack[packlen] = 0 ;
+    char dst[baselen + SS_TREE_CURRENT_LEN + 1 + packlen + treelen + 2 + 1] ;
+    char sym[baselen + SS_TREE_CURRENT_LEN + 1 + packlen + 1 + SS_TREE_CURRENT_LEN + 1] ;
+
+    auto_strings(dst, base, SS_TREE_CURRENT, "/" , pack) ;
+
+    r = scan_mode(dst,S_IFDIR) ;
+    if (!r){
+        if (!dir_create_parent(dst,0755))
+            goto freed ;
+    } else if(r == -1)
+        goto freed ;
+
+    auto_strings(dst, base, SS_SYSTEM, "/", treename) ;
+
+    auto_strings(sym, base, SS_TREE_CURRENT, "/", pack, "/", SS_TREE_CURRENT) ;
+
+    if (!atomic_symlink(dst, sym,"tree_switch_current"))
+        goto freed ;
+
+    if (!resolve_modify_field_g(wres, base, SS_MASTER + 1, E_RESOLVE_TREE_MASTER_CURRENT,  treename)) {
+        log_warnu("modify field: ", resolve_tree_master_field_table[E_RESOLVE_TREE_MASTER_CURRENT].field," of inner resolve file with value: ", treename) ;
+        goto freed ;
+    }
 
-    resolve_free(wres) ;
+    e = 1 ;
 
-    return 1 ;
+    freed:
+        resolve_free(wres) ;
+        return e ;
 }