remove ss_ prefix at file name. Rename ss_state_XXX function to state_XXX

src/lib66/ss_get_enum.c → src/lib66/enum.c

 /*
- * ss_get_enum.c
+ * get_enum.c
  *
  * Copyright (c) 2018-2021 Eric Vidal <eric@obarun.org>
  *

src/lib66/ss_environ.c → src/lib66/environ.c

 /*
- * ss_environ.c
+ * environ.c
  *
  * Copyright (c) 2018-2021 Eric Vidal <eric@obarun.org>
  *

src/lib66/ss_info_utils.c → src/lib66/info_utils.c

 /*
- * ss_info_utils.c
+ * info_utils.c
  *
  * Copyright (c) 2018-2021 Eric Vidal <eric@obarun.org>
  *
@@ -203,7 +203,7 @@ void info_display_nline(char const *field,char const *str)
     stralloc_free(&cp) ;
 }
 
-void info_graph_display(ss_resolve_t *res, depth_t *depth, int last, int padding, ss_resolve_graph_style *style)
+void info_graph_display(resolve_service_t *res, depth_t *depth, int last, int padding, ss_resolve_graph_style *style)
 {
     log_flow() ;
 
@@ -227,13 +227,13 @@ void info_graph_display(ss_resolve_t *res, depth_t *depth, int last, int padding
     {
         char *ste = res->sa.s + res->state ;
         char *name = res->sa.s + res->name ;
-        if (!ss_state_check(ste,name))
+        if (!state_check(ste,name))
         {
             ppid = "unitialized" ;
             goto dis ;
         }
 
-        if (!ss_state_read(&sta,ste,name))
+        if (!state_read(&sta,ste,name))
             log_dieusys(LOG_EXIT_SYS,"read state of: ",name) ;
 
         if (sta.init) {
@@ -280,14 +280,14 @@ void info_graph_display(ss_resolve_t *res, depth_t *depth, int last, int padding
     if (buffer_putsflush(buffer_1,"\n") < 0) return ;
 }
 
-int info_walk(ss_resolve_t *res,char const *src,int reverse, depth_t *depth, int padding, ss_resolve_graph_style *style)
+int info_walk(resolve_service_t *res,char const *src,int reverse, depth_t *depth, int padding, ss_resolve_graph_style *style)
 {
     log_flow() ;
 
     size_t pos = 0, idx = 0 ;
     stralloc sadeps = STRALLOC_ZERO ;
-    ss_resolve_t dres = RESOLVE_ZERO ;
-
+    resolve_service_t dres = RESOLVE_SERVICE_ZERO ;
+    resolve_wrapper_t_ref wres = resolve_set_struct(SERVICE_STRUCT, &dres) ;
     if((!res->ndeps) || (depth->level > MAXDEPTH))
         goto freed ;
 
@@ -299,8 +299,8 @@ int info_walk(ss_resolve_t *res,char const *src,int reverse, depth_t *depth, int
         int last =  idx + 1 < res->ndeps  ? 0 : 1 ;
         char *name = sadeps.s + pos ;
 
-        if (!ss_resolve_check(src,name)) goto err ;
-        if (!ss_resolve_read(&dres,src,name)) goto err ;
+        if (!resolve_check(src,name)) goto err ;
+        if (!resolve_read(wres,src,name)) goto err ;
 
         info_graph_display(&dres, depth, last,padding,style) ;
 
@@ -331,16 +331,16 @@ int info_walk(ss_resolve_t *res,char const *src,int reverse, depth_t *depth, int
         }
     }
     freed:
-    ss_resolve_free(&dres) ;
+    resolve_free(wres) ;
     stralloc_free(&sadeps) ;
     return 1 ;
     err:
-        ss_resolve_free(&dres) ;
+        resolve_free(wres) ;
         stralloc_free(&sadeps) ;
         return 0 ;
 }
 
-int info_graph_init (ss_resolve_t *res,char const *src,unsigned int reverse, int padding, ss_resolve_graph_style *style)
+int info_graph_init (resolve_service_t *res,char const *src,unsigned int reverse, int padding, ss_resolve_graph_style *style)
 {
     log_flow() ;
 

src/lib66/ss_instance.c → src/lib66/instance.c

 /*
- * ss_instance.c
+ * instance.c
  *
  * Copyright (c) 2018-2021 Eric Vidal <eric@obarun.org>
  *
@@ -28,8 +28,6 @@
 
 #include <66/enum.h>
 
-/** New functions */
-
 int instance_check(char const *svname)
 {
     log_flow() ;

src/lib66/ss_state.c → src/lib66/state.c

 /*
- * ss_state.c
+ * state.c
  *
  * Copyright (c) 2018-2021 Eric Vidal <eric@obarun.org>
  *
@@ -27,7 +27,7 @@
 
 #include <66/state.h>
 
-void ss_state_rmfile(char const *src,char const *name)
+void state_rmfile(char const *src,char const *name)
 {
     log_flow() ;
 
@@ -43,7 +43,7 @@ void ss_state_rmfile(char const *src,char const *name)
     unlink_void(tmp) ;
 }
 
-void ss_state_pack(char *pack, ss_state_t *sta)
+void state_pack(char *pack, ss_state_t *sta)
 {
     log_flow() ;
 
@@ -54,7 +54,7 @@ void ss_state_pack(char *pack, ss_state_t *sta)
     uint64_pack_big(pack+16,sta->pid) ;
 }
 
-void ss_state_unpack(char *pack,ss_state_t *sta)
+void state_unpack(char *pack,ss_state_t *sta)
 {
     log_flow() ;
 
@@ -76,7 +76,7 @@ void ss_state_unpack(char *pack,ss_state_t *sta)
     sta->pid = pid ;
 }
 
-int ss_state_write(ss_state_t *sta, char const *dst, char const *name)
+int state_write(ss_state_t *sta, char const *dst, char const *name)
 {
     log_flow() ;
 
@@ -90,13 +90,13 @@ int ss_state_write(ss_state_t *sta, char const *dst, char const *name)
     memcpy(tmp + dstlen + 1, name, namelen) ;
     tmp[dstlen + 1 + namelen] = 0 ;
 
-    ss_state_pack(pack,sta) ;
+    state_pack(pack,sta) ;
     if (!openwritenclose_unsafe(tmp,pack,SS_STATE_SIZE)) return 0 ;
 
     return 1 ;
 }
 
-int ss_state_read(ss_state_t *sta, char const *src, char const *name)
+int state_read(ss_state_t *sta, char const *src, char const *name)
 {
     log_flow() ;
 
@@ -111,12 +111,12 @@ int ss_state_read(ss_state_t *sta, char const *src, char const *name)
     tmp[srclen + 1 + namelen] = 0 ;
 
     if (openreadnclose(tmp, pack, SS_STATE_SIZE) < SS_STATE_SIZE) return 0 ;
-    ss_state_unpack(pack, sta) ;
+    state_unpack(pack, sta) ;
 
     return 1 ;
 }
 
-int ss_state_check(char const *src, char const *name)
+int state_check(char const *src, char const *name)
 {
     log_flow() ;
 
@@ -133,7 +133,7 @@ int ss_state_check(char const *src, char const *name)
     return 1 ;
 }
 
-void ss_state_setflag(ss_state_t *sta,int flags,int flags_val)
+void state_setflag(ss_state_t *sta,int flags,int flags_val)
 {
     log_flow() ;
 
@@ -148,19 +148,19 @@ void ss_state_setflag(ss_state_t *sta,int flags,int flags_val)
     }
 }
 
-int ss_state_check_flags(char const *src, char const *name,int flags)
+int state_check_flags(char const *src, char const *name,int flags)
 {
     log_flow() ;
 
     /** unitialized at all, all flags == 0.
      * Return -1 to make a distinction between
      * file absent and flag == 0. */
-    if (!ss_state_check(src,name))
+    if (!state_check(src,name))
         return -1 ;
 
     ss_state_t sta = STATE_ZERO ;
 
-    if (!ss_state_read(&sta,src,name))
+    if (!state_read(&sta,src,name))
         // should not happen
         return -1 ;
 

src/lib66/ss_utils.c → src/lib66/utils.c

 /*
- * ss_utils.c
+ * utils.c
  *
  * Copyright (c) 2018-2021 Eric Vidal <eric@obarun.org>
  *
@@ -19,11 +19,14 @@
 #include <sys/stat.h>
 #include <pwd.h>
 #include <errno.h>
+#include <stdlib.h>
 
 #include <oblibs/log.h>
 #include <oblibs/files.h>
 #include <oblibs/sastr.h>
 #include <oblibs/string.h>
+#include <oblibs/types.h>
+#include <oblibs/directory.h>
 
 #include <skalibs/genalloc.h>
 #include <skalibs/stralloc.h>
@@ -32,6 +35,7 @@
 
 #include <66/config.h>
 #include <66/constants.h>
+#include <66/service.h>
 #include <66/resolve.h>
 #include <66/parser.h>
 
@@ -40,7 +44,7 @@
 sv_alltype const sv_alltype_zero = SV_ALLTYPE_ZERO ;
 sv_name_t const sv_name_zero = SV_NAME_ZERO ;
 keynocheck const keynocheck_zero = KEYNOCHECK_ZERO ;
-ss_resolve_t const ss_resolve_zero = RESOLVE_ZERO ;
+
 
 /** this following function come from Laurent Bercot
  * author of s6 library all rights reserved on this author
@@ -321,14 +325,16 @@ int read_svfile(stralloc *sasv,char const *name,char const *src)
     return 1 ;
 }
 
-int module_in_cmdline(genalloc *gares, ss_resolve_t *res, char const *dir)
+int module_in_cmdline(genalloc *gares, resolve_service_t *res, char const *dir)
 {
     log_flow() ;
 
+    int e = 0 ;
     stralloc tmp = STRALLOC_ZERO ;
     size_t pos = 0 ;
+    resolve_wrapper_t_ref wres = resolve_set_struct(SERVICE_STRUCT, res) ;
 
-    if (!ss_resolve_append(gares,res)) goto err ;
+    if (!resolve_append(gares,wres)) goto err ;
 
     if (res->contents)
     {
@@ -338,27 +344,31 @@ int module_in_cmdline(genalloc *gares, ss_resolve_t *res, char const *dir)
     for (; pos < tmp.len ; pos += strlen(tmp.s + pos) + 1)
     {
         char *name = tmp.s + pos ;
-        if (!ss_resolve_check(dir,name)) goto err ;
-        if (!ss_resolve_read(res,dir,name)) goto err ;
+        if (!resolve_check(dir,name)) goto err ;
+        if (!resolve_read(wres,dir,name)) goto err ;
         if (res->type == TYPE_CLASSIC)
-            if (ss_resolve_search(gares,name) < 0)
-                if (!ss_resolve_append(gares,res)) goto err ;
+            if (resolve_search(gares,name, SERVICE_STRUCT) < 0)
+                if (!resolve_append(gares,wres)) goto err ;
     }
-    stralloc_free(&tmp) ;
-    return 1 ;
+
+    e = 1 ;
+
     err:
+        free(wres) ;
         stralloc_free(&tmp) ;
-        return 0 ;
+        return e ;
 }
 
 int module_search_service(char const *src, genalloc *gares, char const *name,uint8_t *found, char module_name[256])
 {
     log_flow() ;
 
+    int e = 0 ;
     size_t srclen = strlen(src), pos = 0, deps = 0 ;
     stralloc list = STRALLOC_ZERO ;
     stralloc tmp = STRALLOC_ZERO ;
-    ss_resolve_t res = RESOLVE_ZERO ;
+    resolve_service_t res = RESOLVE_SERVICE_ZERO ;
+    resolve_wrapper_t_ref wres = resolve_set_struct(SERVICE_STRUCT, &res) ;
     char const *exclude[2] = { SS_MASTER + 1, 0 } ;
 
     char t[srclen + SS_RESOLVE_LEN + 1] ;
@@ -369,7 +379,7 @@ int module_search_service(char const *src, genalloc *gares, char const *name,uin
     for (;pos < list.len ; pos += strlen(list.s + pos) + 1)
     {
         char *dname = list.s + pos ;
-        if (!ss_resolve_read(&res,src,dname)) goto err ;
+        if (!resolve_read(wres,src,dname)) goto err ;
         if (res.type == TYPE_MODULE && res.contents)
         {
             if (!sastr_clean_string(&tmp,res.sa.s + res.contents)) goto err ;
@@ -388,9 +398,9 @@ int module_search_service(char const *src, genalloc *gares, char const *name,uin
     end:
     /** search if the service is on the commandline
      * if not we crash */
-    for(pos = 0 ; pos < genalloc_len(ss_resolve_t,gares) ; pos++)
+    for(pos = 0 ; pos < genalloc_len(resolve_service_t,gares) ; pos++)
     {
-        ss_resolve_t_ref pres = &genalloc_s(ss_resolve_t,gares)[pos] ;
+        resolve_service_t_ref pres = &genalloc_s(resolve_service_t, gares)[pos] ;
         char *str = pres->sa.s ;
         char *name = str + pres->name ;
         if (!strcmp(name,module_name)) {
@@ -399,14 +409,236 @@ int module_search_service(char const *src, genalloc *gares, char const *name,uin
         }
     }
 
-    stralloc_free(&list) ;
-    stralloc_free(&tmp) ;
-    ss_resolve_free(&res) ;
-    return 1 ;
+    e = 1 ;
+
     err:
         stralloc_free(&list) ;
         stralloc_free(&tmp) ;
-        ss_resolve_free(&res) ;
+        resolve_free(wres) ;
+        return e ;
+}
+
+/* @sdir -> service dir
+ * @mdir -> module dir */
+int module_path(stralloc *sdir, stralloc *mdir, char const *sv,char const *frontend_src, uid_t owner)
+{
+    log_flow() ;
+
+    int r, insta ;
+    stralloc sainsta = STRALLOC_ZERO ;
+    stralloc mhome = STRALLOC_ZERO ; // module user dir
+    stralloc shome = STRALLOC_ZERO ; // service user dir
+    char const *src = 0 ;
+    char const *dest = 0 ;
+
+    insta = instance_check(sv) ;
+    instance_splitname(&sainsta,sv,insta,SS_INSTANCE_TEMPLATE) ;
+
+    if (!owner)
+    {
+        src = SS_MODULE_ADMDIR ;
+        dest = frontend_src ;
+    }
+    else
+    {
+        if (!set_ownerhome(&mhome,owner)) log_warnusys_return(LOG_EXIT_ZERO,"set home directory") ;
+        if (!stralloc_cats(&mhome,SS_MODULE_USERDIR)) log_warnsys_return(LOG_EXIT_ZERO,"stralloc") ;
+        if (!stralloc_0(&mhome)) log_warnsys_return(LOG_EXIT_ZERO,"stralloc") ;
+        mhome.len-- ;
+        src = mhome.s ;
+
+        if (!set_ownerhome(&shome,owner)) log_warnusys_return(LOG_EXIT_ZERO,"set home directory") ;
+        if (!stralloc_cats(&shome,SS_SERVICE_USERDIR)) log_warnsys_return(LOG_EXIT_ZERO,"stralloc") ;
+        if (!stralloc_0(&shome)) log_warnsys_return(LOG_EXIT_ZERO,"stralloc") ;
+        shome.len-- ;
+        dest = shome.s ;
+
+    }
+    if (!auto_stra(mdir,src,sainsta.s)) log_warnsys_return(LOG_EXIT_ZERO,"stralloc") ;
+    r = scan_mode(mdir->s,S_IFDIR) ;
+    if (!r || r == -1)
+    {
+        mdir->len = 0 ;
+        src = SS_MODULE_ADMDIR ;
+        if (!auto_stra(mdir,src,sainsta.s)) log_warnsys_return(LOG_EXIT_ZERO,"stralloc") ;
+        r = scan_mode(mdir->s,S_IFDIR) ;
+        if (!r || r == -1)
+        {
+            mdir->len = 0 ;
+            src = SS_MODULE_SYSDIR ;
+            if (!auto_stra(mdir,src,sainsta.s)) log_warnsys_return(LOG_EXIT_ZERO,"stralloc") ;
+            r = scan_mode(mdir->s,S_IFDIR) ;
+            if (!r || r == -1) log_warnu_return(LOG_EXIT_ZERO,"find module: ",sv) ;
+        }
+
+    }
+    if (!auto_stra(sdir,dest,sv)) log_warnsys_return(LOG_EXIT_ZERO,"stralloc") ;
+
+    stralloc_free(&sainsta) ;
+    stralloc_free(&mhome) ;
+    stralloc_free(&shome) ;
+    return 1 ;
+}
+
+int sa_pointo(stralloc *sa, ssexec_t *info, int type, unsigned int where)
+{
+    log_flow() ;
+
+    sa->len = 0 ;
+
+    char ownerstr[UID_FMT] ;
+    size_t ownerlen = uid_fmt(ownerstr,info->owner) ;
+    ownerstr[ownerlen] = 0 ;
+
+    if (where == SS_RESOLVE_STATE) {
+
+        if (!auto_stra(sa, info->live.s, SS_STATE + 1, "/", ownerstr, "/", info->treename.s))
+            goto err ;
+
+    } else if (where == SS_RESOLVE_SRC) {
+
+        if (!auto_stra(sa, info->tree.s, SS_SVDIRS))
+            goto err ;
+
+    } else if (where == SS_RESOLVE_BACK) {
+
+        if (!auto_stra(sa, info->base.s, SS_SYSTEM, SS_BACKUP, "/", info->treename.s))
+            goto err ;
+
+    } else if (where == SS_RESOLVE_LIVE) {
+
+        if (!auto_stra(sa, info->live.s, SS_STATE + 1, "/", ownerstr, "/", info->treename.s, SS_SVDIRS))
+            goto err ;
+    }
+
+    if (type >= 0 && where) {
+
+        if (type == TYPE_CLASSIC) {
+
+            if (!auto_stra(sa, SS_SVC))
+                goto err ;
+
+        } else if (!auto_stra(sa, SS_DB))
+            goto err ;
+    }
+
+    return 1 ;
+
+    err:
         return 0 ;
 }
 
+int create_live(ssexec_t *info)
+{
+    log_flow() ;
+
+    int r ;
+    gid_t gidowner ;
+    if (!yourgid(&gidowner,info->owner)) return 0 ;
+    stralloc sares = STRALLOC_ZERO ;
+    stralloc ressrc = STRALLOC_ZERO ;
+
+    if (!sa_pointo(&ressrc,info,SS_NOTYPE,SS_RESOLVE_SRC)) goto err ;
+
+    if (!sa_pointo(&sares,info,SS_NOTYPE,SS_RESOLVE_STATE)) goto err ;
+    r = scan_mode(sares.s,S_IFDIR) ;
+    if (r < 0) goto err ;
+    if (!r)
+    {
+        ssize_t len = get_rlen_until(sares.s,'/',sares.len) ;
+        sares.len-- ;
+        char sym[sares.len + SS_SVDIRS_LEN + 1] ;
+        memcpy(sym,sares.s,sares.len) ;
+        sym[sares.len] = 0 ;
+
+        r = dir_create_parent(sym,0700) ;
+        if (!r) goto err ;
+        sym[len] = 0 ;
+        if (chown(sym,info->owner,gidowner) < 0) goto err ;
+        memcpy(sym,sares.s,sares.len) ;
+        memcpy(sym + sares.len, SS_SVDIRS, SS_SVDIRS_LEN) ;
+        sym[sares.len + SS_SVDIRS_LEN] = 0 ;
+
+        log_trace("point symlink: ",sym," to ",ressrc.s) ;
+        if (symlink(ressrc.s,sym) < 0)
+        {
+            log_warnusys("symlink: ", sym) ;
+            goto err ;
+        }
+    }
+    /** live/state/uid/treename/init file */
+    if (!file_write_unsafe(sares.s,"init","",0)) goto err ;
+
+    stralloc_free(&ressrc) ;
+    stralloc_free(&sares) ;
+
+    return 1 ;
+    err:
+        stralloc_free(&ressrc) ;
+        stralloc_free(&sares) ;
+        return 0 ;
+}
+/*
+ *
+ *
+ * Not used
+ *
+ *
+ *
+
+int sort_byfile_first(stralloc *sort, char const *src)
+{
+    log_flow() ;
+
+    int fdsrc ;
+    stralloc tmp = STRALLOC_ZERO ;
+
+    DIR *dir = opendir(src) ;
+    if (!dir)
+    {
+        log_warnusys("open : ", src) ;
+        goto errstra ;
+    }
+    fdsrc = dir_fd(dir) ;
+
+    for (;;)
+    {
+        tmp.len = 0 ;
+        struct stat st ;
+        direntry *d ;
+        d = readdir(dir) ;
+        if (!d) break ;
+        if (d->d_name[0] == '.')
+        if (((d->d_name[1] == '.') && !d->d_name[2]) || !d->d_name[1])
+            continue ;
+
+        if (stat_at(fdsrc, d->d_name, &st) < 0)
+        {
+            log_warnusys("stat ", src, d->d_name) ;
+            goto errdir ;
+        }
+
+        if (S_ISREG(st.st_mode))
+        {
+            if (!auto_stra(&tmp,src,d->d_name)) goto errdir ;
+            if (!stralloc_insertb(sort,0,tmp.s,strlen(tmp.s) + 1)) goto errdir ;
+        }
+        else if(S_ISDIR(st.st_mode))
+        {
+            if (!auto_stra(&tmp,src,d->d_name,"/")) goto errdir ;
+            if (!stralloc_insertb(sort,sort->len,tmp.s,strlen(tmp.s) + 1)) goto errdir ;
+        }
+    }
+
+    dir_close(dir) ;
+    stralloc_free(&tmp) ;
+
+    return 1 ;
+
+    errdir:
+        dir_close(dir) ;
+    errstra:
+        stralloc_free(&tmp) ;
+        return 0 ;
+}
+*/