summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/.gitignore9
-rw-r--r--src/cli_def.l424
-rw-r--r--src/cli_new.c1938
-rw-r--r--src/cli_objects.c343
-rw-r--r--src/cli_objects.h65
-rw-r--r--src/cli_parse.y206
-rw-r--r--src/cli_path_utils.c535
-rw-r--r--src/cli_path_utils.h72
-rw-r--r--src/cli_val.h206
-rw-r--r--src/cli_val.l293
-rw-r--r--src/cli_val_engine.c881
-rw-r--r--src/cli_val_engine.h86
-rw-r--r--src/commit.c1364
-rw-r--r--src/delete.c258
-rw-r--r--src/set.c310
15 files changed, 6990 insertions, 0 deletions
diff --git a/src/.gitignore b/src/.gitignore
new file mode 100644
index 0000000..a2b4c94
--- /dev/null
+++ b/src/.gitignore
@@ -0,0 +1,9 @@
+cli_parse.tab.c
+cli_parse.tab.h
+cli_def.lex.c
+cli_def.tab.c
+cli_def.tab.h
+cli_val.lex.c
+delete
+my_*
+show
diff --git a/src/cli_def.l b/src/cli_def.l
new file mode 100644
index 0000000..41994d6
--- /dev/null
+++ b/src/cli_def.l
@@ -0,0 +1,424 @@
+%{
+#include "cli_val.h"
+#include "cli_parse.h"
+FILE *yy_cli_def_in;
+static void make_def_value(vtw_type_e type);
+static int cli_last_nl_returned=0;
+#define STR_DELTA 2
+%}
+%x str
+%option noyywrap
+%option nounput
+%option never-interactive
+
+/*
+ * Regular expressions of IP and MAC addresses, URLs, etc.
+ */
+
+/*
+ * IPv4 address representation.
+ */
+RE_IPV4_BYTE 25[0-5]|2[0-4][0-9]|[01][0-9][0-9]|([0-9]{1,2})
+RE_IPV4 {RE_IPV4_BYTE}(\.{RE_IPV4_BYTE}){3}
+RE_IPV4_PREFIXLEN (3[012]|[12][0-9]|[0-9])
+RE_IPV4NET {RE_IPV4}"/"{RE_IPV4_PREFIXLEN}
+
+/*
+ * IPv6 address representation in Augmented Backus-Naur Form (ABNF)
+ * as defined in RFC-2234.
+ * IPv6 address representation taken from RFC-3986:
+ *
+ * IPv6address = 6( h16 ":" ) ls32
+ * / "::" 5( h16 ":" ) ls32
+ * / [ h16 ] "::" 4( h16 ":" ) ls32
+ * / [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
+ * / [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
+ * / [ *3( h16 ":" ) h16 ] "::" h16 ":" ls32
+ * / [ *4( h16 ":" ) h16 ] "::" ls32
+ * / [ *5( h16 ":" ) h16 ] "::" h16
+ * / [ *6( h16 ":" ) h16 ] "::"
+ *
+ * h16 = 1*4HEXDIG
+ * ls32 = ( h16 ":" h16 ) / IPv4address
+ * IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet
+ * dec-octet = DIGIT ; 0-9
+ * / %x31-39 DIGIT ; 10-99
+ * / "1" 2DIGIT ; 100-199
+ * / "2" %x30-34 DIGIT ; 200-249
+ * / "25" %x30-35 ; 250-255
+ */
+
+RE_H16 [a-fA-F0-9]{1,4}
+RE_H16_COLON {RE_H16}":"
+RE_LS32 (({RE_H16}":"{RE_H16})|{RE_IPV4})
+RE_IPV6_P1 {RE_H16_COLON}{6}{RE_LS32}
+RE_IPV6_P2 "::"{RE_H16_COLON}{5}{RE_LS32}
+RE_IPV6_P3 ({RE_H16})?"::"{RE_H16_COLON}{4}{RE_LS32}
+RE_IPV6_P4 ({RE_H16_COLON}{0,1}{RE_H16})?"::"{RE_H16_COLON}{3}{RE_LS32}
+RE_IPV6_P5 ({RE_H16_COLON}{0,2}{RE_H16})?"::"{RE_H16_COLON}{2}{RE_LS32}
+RE_IPV6_P6 ({RE_H16_COLON}{0,3}{RE_H16})?"::"{RE_H16_COLON}{1}{RE_LS32}
+RE_IPV6_P7 ({RE_H16_COLON}{0,4}{RE_H16})?"::"{RE_LS32}
+RE_IPV6_P8 ({RE_H16_COLON}{0,5}{RE_H16})?"::"{RE_H16}
+RE_IPV6_P9 ({RE_H16_COLON}{0,6}{RE_H16})?"::"
+RE_IPV6 {RE_IPV6_P1}|{RE_IPV6_P2}|{RE_IPV6_P3}|{RE_IPV6_P4}|{RE_IPV6_P5}|{RE_IPV6_P6}|{RE_IPV6_P7}|{RE_IPV6_P8}|{RE_IPV6_P9}
+RE_IPV6_PREFIXLEN 12[0-8]|1[01][0-9]|[0-9][0-9]?
+RE_IPV6NET {RE_IPV6}"/"{RE_IPV6_PREFIXLEN}
+
+/*
+ * Ethernet MAC address representation.
+ */
+RE_MACADDR [a-fA-F0-9]{1,2}(:[a-fA-F0-9]{1,2}){5}
+
+/*
+ * URL-related regular expressions.
+ *
+ * Implementation is based on the BNF-like specification from:
+ * - RFC-1738: HTTP, FTP, FILE
+ * - RFC-3617: TFTP
+ * - RFC-3986: update of RFC-1738
+ */
+RE_URL {RE_URL_FILE}|{RE_URL_FTP}|{RE_URL_HTTP}|{RE_URL_TFTP}
+
+/*
+ * URL schemeparts for IP based protocols.
+ * Representation taken from RFC-1738, and some of it is updated by RFC-3986.
+ *
+ * login = [ user [ ":" password ] "@" ] hostport
+ * hostport = host [ ":" port ]
+ * host = hostname | hostnumber
+ * hostname = *[ domainlabel "." ] toplabel
+ * domainlabel = alphadigit | alphadigit *[ alphadigit | "-" ] alphadigit
+ * toplabel = alpha | alpha *[ alphadigit | "-" ] alphadigit
+ * alphadigit = alpha | digit
+ * hostnumber = digits "." digits "." digits "." digits
+ * port = digits
+ * user = *[ uchar | ";" | "?" | "&" | "=" ]
+ * password = *[ uchar | ";" | "?" | "&" | "=" ]
+ */
+RE_URL_LOGIN ({RE_URL_USER}(":"{RE_URL_PASSWORD})?"@")?{RE_URL_HOSTPORT}
+RE_URL_HOSTPORT {RE_URL_HOST}(":"{RE_URL_PORT})?
+RE_URL_HOST {RE_URL_HOSTNAME}|{RE_IPV4}|{RE_URL_IP_LITERAL}
+RE_URL_IP_LITERAL "["({RE_IPV6}|{RE_URL_IPV_FUTURE})"]"
+RE_URL_IPV_FUTURE "v"({RE_URL_HEXDIG})+"."({RE_URL_UNRESERVED}|{RE_URL_SUBDELIMS}|":")+
+RE_URL_HOSTNAME ({RE_URL_DOMAINLABEL}".")*{RE_URL_TOPLABEL}
+RE_URL_DOMAINLABEL {RE_URL_ALPHADIGIT}|{RE_URL_ALPHADIGIT}({RE_URL_ALPHADIGIT}|"-")*{RE_URL_ALPHADIGIT}
+RE_URL_TOPLABEL {RE_URL_ALPHA}|{RE_URL_ALPHA}({RE_URL_ALPHADIGIT}|"-")*{RE_URL_ALPHADIGIT}
+RE_URL_ALPHADIGIT {RE_URL_ALPHA}|{RE_URL_DIGIT}
+RE_URL_HOSTNUMBER {RE_URL_DIGITS}"."{RE_URL_DIGITS}"."{RE_URL_DIGITS}"."{RE_URL_DIGITS}
+RE_URL_PORT {RE_URL_DIGITS}
+RE_URL_USER ({RE_URL_UCHAR}|";"|"?"|"&"|"=")*
+RE_URL_PASSWORD ({RE_URL_UCHAR}|";"|"?"|"&"|"=")*
+
+/*
+ * FILE URL regular expression.
+ * Representation taken from RFC-1738.
+ *
+ * fileurl = "file://" [ host | "localhost" ] "/" fpath
+ */
+RE_URL_FILE "file://"({RE_URL_HOST}|"localhost")?"/"{RE_URL_FPATH}
+
+/*
+ * FTP URL regular expression.
+ * Representation taken from RFC-1738.
+ *
+ * ftpurl = "ftp://" login [ "/" fpath [ ";type=" ftptype ] ]
+ * fpath = fsegment *[ "/" fsegment ]
+ * fsegment = *[ uchar | "?" | ":" | "@" | "&" | "=" ]
+ * ftptype = "A" | "I" | "D" | "a" | "i" | "d"
+ */
+RE_URL_FTP "ftp://"{RE_URL_LOGIN}("/"{RE_URL_FPATH}(";type="{RE_URL_FTPTYPE})?)?
+RE_URL_FPATH {RE_URL_FSEGMENT}("/"{RE_URL_FSEGMENT})*
+RE_URL_FSEGMENT ({RE_URL_UCHAR}|"?"|":"|"@"|"&"|"=")*
+RE_URL_FTPTYPE "A"|"I"|"D"|"a"|"i"|"d"
+
+/*
+ * HTTP URL regular expression.
+ * Representation taken from RFC-1738.
+ *
+ * httpurl = "http://" hostport [ "/" hpath [ "?" search ] ]
+ * hpath = hsegment *[ "/" hsegment ]
+ * hsegment = *[ uchar | ";" | ":" | "@" | "&" | "=" ]
+ * search = *[ uchar | ";" | ":" | "@" | "&" | "=" ]
+ */
+RE_URL_HTTP "http://"{RE_URL_HOSTPORT}("/"{RE_URL_HPATH}("?"{RE_URL_SEARCH})?)?
+RE_URL_HPATH {RE_URL_HSEGMENT}("/"{RE_URL_HSEGMENT})*
+RE_URL_HSEGMENT ({RE_URL_UCHAR}|";"|":"|"@"|"&"|"=")*
+RE_URL_SEARCH ({RE_URL_UCHAR}|";"|":"|"@"|"&"|"=")*
+
+/*
+ * TFTP URL regular expression.
+ * Representation taken from RFC-3617.
+ *
+ * tftpURI = "tftp://" host "/" file [ mode ]
+ * mode = ";" "mode=" ( "netascii" / "octet" )
+ * file = *( unreserved / escaped )
+ * host = <as specified by RFC 2732 [3]>
+ * unreserved = <as specified in RFC 2396 [4]>
+ * escaped = <as specified in RFC 2396>
+ */
+RE_URL_TFTP "tftp://"{RE_URL_HOST}"/"{RE_URL_TFTP_FILE}({RE_URL_TFTP_MODE})?
+RE_URL_TFTP_MODE ";""mode="("netascii"|"octet")
+RE_URL_TFTP_FILE ({RE_URL_UNRESERVED}|{RE_URL_ESCAPE})*
+
+/*
+ * URL-related miscellaneous definitions.
+ * Representation taken from RFC-1738 and from RFC-3986.
+ *
+ * lowalpha = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" |
+ * "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" |
+ * "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" |
+ * "y" | "z"
+ * hialpha = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" |
+ * "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" |
+ * "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z"
+ * alpha = lowalpha | hialpha
+ * digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" |
+ * "8" | "9"
+ * safe = "$" | "-" | "_" | "." | "+"
+ * extra = "!" | "*" | "'" | "(" | ")" | ","
+ * national = "{" | "}" | "|" | "\" | "^" | "~" | "[" | "]" | "`"
+ * punctuation = "<" | ">" | "#" | "%" | <">
+ *
+ *
+ * reserved = ";" | "/" | "?" | ":" | "@" | "&" | "="
+ * hex = digit | "A" | "B" | "C" | "D" | "E" | "F" |
+ * "a" | "b" | "c" | "d" | "e" | "f"
+ * escape = "%" hex hex
+ *
+ * unreserved = alpha | digit | safe | extra
+ * uchar = unreserved | escape
+ * xchar = unreserved | reserved | escape
+ * digits = 1*digit
+ *
+ * sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
+ * / "*" / "+" / "," / ";" / "="
+ */
+RE_URL_LOWALPHA [a-z]
+RE_URL_HIALPHA [A-Z]
+RE_URL_ALPHA {RE_URL_LOWALPHA}|{RE_URL_HIALPHA}
+RE_URL_DIGIT [0-9]
+RE_URL_SAFE "$"|"-"|"_"|"."|"+"
+RE_URL_EXTRA "!"|"*"|"'"|"("|")"|","
+RE_URL_NATIONAL "{"|"}"|"|"|"\"|"^"|"~"|"["|"]"|"`"
+RE_URL_PUNCTUATION "<"|">"|"#"|"%"|<">
+RE_URL_RESERVED ";"|"/"|"?"|":"|"@"|"&"|"="
+RE_URL_HEXDIG {RE_URL_DIGIT}|[A-F]|[a-f]
+RE_URL_ESCAPE "%"{RE_URL_HEXDIG}{RE_URL_HEXDIG}
+RE_URL_UNRESERVED {RE_URL_ALPHA}|{RE_URL_DIGIT}|{RE_URL_SAFE}|{RE_URL_EXTRA}
+RE_URL_UCHAR {RE_URL_UNRESERVED}|{RE_URL_ESCAPE}
+RE_URL_XCHAR {RE_URL_UNRESERVED}|{RE_URL_RESERVED}|{RE_URL_ESCAPE}
+RE_URL_DIGITS {RE_URL_DIGIT}{1,}
+RE_URL_SUBDELIMS "!"|"$"|"&"|"'"|"("|")"|"*"|"+"|","|";"|"="
+
+
+%%
+ char *string_buf=NULL;
+ char *string_buf_ptr=NULL;
+ int string_len=0, string_buf_len=0;
+ char str_delim=0;
+
+#[^\n]*(\\[ \t]*\n[^\n]*)*\n { /* comment */ }
+\n {yy_cli_def_lineno++;return EOL;}
+<<EOF>> { if(!cli_last_nl_returned) {cli_last_nl_returned=1;return EOL;} yyterminate(); }
+[\`\"] {
+ BEGIN(str);
+ str_delim = yy_cli_def_text[0];
+ string_buf_ptr = string_buf = my_malloc(STR_DELTA + 1, "");
+ string_len = STR_DELTA;
+ string_buf_len = STR_DELTA;
+ }
+<str>[\"\`] {
+ /* maybe a closing quote - all done */
+ if(str_delim == yy_cli_def_text[0]) {
+ BEGIN(INITIAL);
+ *string_buf_ptr = 0;
+ /* return string constant token type and
+ * value to parser
+ */
+ yy_cli_parse_lval.strp = string_buf;
+ return str_delim == '"'?STRING:EX_STRING;
+ }else{
+ *string_buf_ptr++ = yy_cli_def_text[0];
+ goto string_too_long;
+ }
+ }
+
+<str>\n {
+ /* error - unterminated string constant */
+ yy_cli_def_lineno++;
+ }
+
+<str>\\n {*string_buf_ptr++ = '\n';goto string_too_long;}
+<str>\\t {*string_buf_ptr++ = '\t';goto string_too_long;}
+<str>\\r {*string_buf_ptr++ = '\r';goto string_too_long;}
+<str>\\b {*string_buf_ptr++ = '\b';goto string_too_long;}
+<str>\\f {*string_buf_ptr++ = '\f';goto string_too_long;}
+<str>\\\n { yy_cli_def_lineno++; /* continuation => ignore */ }
+
+<str>\\. {
+ *string_buf_ptr++ = yy_cli_def_text[1];
+string_too_long:
+ *string_buf_ptr = 0;
+ /* printf("Cur string |%s|\n", string_buf); */
+ if (!--string_len) {
+ string_buf = my_realloc(string_buf,
+ string_buf_len + STR_DELTA + 1,
+ "cli_def STRING");
+ string_buf_ptr = string_buf + string_buf_len;
+ string_buf_len += STR_DELTA;
+ string_len = STR_DELTA;
+ }
+ }
+<str>[^\\\n\"\`]+ {
+ char *yptr = yy_cli_def_text;
+
+ while ( *yptr ){
+ *string_buf_ptr++ = *yptr++;
+ if (!--string_len) {
+ string_buf = my_realloc(string_buf,
+ string_buf_len + STR_DELTA + 1,
+ "cli_def STRING");
+ string_buf_ptr = string_buf + string_buf_len;
+ string_buf_len += STR_DELTA;
+ string_len = STR_DELTA;
+ }
+ }
+ *string_buf_ptr = 0;
+ }
+
+default: return DEFAULT;
+tag: return TAG;
+type: return TYPE;
+help: return HELP;
+syntax: return SYNTAX;
+commit: return COMMIT;
+check: yy_cli_parse_lval.action = syntax_act; return ACTION;
+delete: yy_cli_parse_lval.action = delete_act; return ACTION;
+update: yy_cli_parse_lval.action = update_act; return ACTION;
+activate: yy_cli_parse_lval.action = activate_act; return ACTION;
+create: yy_cli_parse_lval.action = create_act; return ACTION;
+begin: yy_cli_parse_lval.action = begin_act; return ACTION;
+end: yy_cli_parse_lval.action = end_act; return ACTION;
+multi: return MULTI;
+
+:: {
+ make_def_value(IPV6_TYPE);
+ return VALUE;
+ }
+txt {
+ yy_cli_parse_lval.type = TEXT_TYPE;
+ return TYPE_DEF;
+ }
+
+pattern return PATTERN;
+
+exec return EXEC;
+
+, return COMMA;
+\|\| return OR;
+\&\& return AND;
+\= return ASSIGN;
+\=\= {yy_cli_parse_lval.cond = EQ_COND; return COND;}
+\!\= {yy_cli_parse_lval.cond = NE_COND; return COND;}
+\< {yy_cli_parse_lval.cond = LT_COND; return COND;}
+\> {yy_cli_parse_lval.cond = GT_COND; return COND;}
+\<\= {yy_cli_parse_lval.cond = LE_COND; return COND;}
+\>\= {yy_cli_parse_lval.cond = GE_COND; return COND;}
+in {yy_cli_parse_lval.cond = IN_COND; return COND;}
+\! { return NOT; }
+\$\([^)]+\) {
+ yy_cli_parse_lval.strp = my_strdup(yy_cli_def_text, "TEXT");
+ return VAR;
+ }
+true {
+ make_def_value(BOOL_TYPE);
+ return VALUE;
+ }
+
+false {
+ make_def_value(BOOL_TYPE);
+ return VALUE;
+ }
+
+[0-9]+ {
+ make_def_value(INT_TYPE);
+ return VALUE;
+ }
+
+{RE_IPV4} {
+ make_def_value(IPV4_TYPE);
+ return VALUE;
+ }
+
+{RE_IPV4NET} {
+ make_def_value(IPV4NET_TYPE);
+ return VALUE;
+ }
+
+{RE_IPV6} {
+ make_def_value(IPV6_TYPE);
+ return VALUE;
+ }
+
+{RE_IPV6NET} {
+ make_def_value(IPV6NET_TYPE);
+ return VALUE;
+ }
+
+{RE_MACADDR} {
+ make_def_value(MACADDR_TYPE);
+ return VALUE;
+ }
+u32 {
+ yy_cli_parse_lval.type = INT_TYPE;
+ return TYPE_DEF;
+ }
+
+ipv4 {
+ yy_cli_parse_lval.type = IPV4_TYPE;
+ return TYPE_DEF;
+ }
+
+ipv4net {
+ yy_cli_parse_lval.type = IPV4NET_TYPE;
+ return TYPE_DEF;
+ }
+ipv6 {
+ yy_cli_parse_lval.type = IPV6_TYPE;
+ return TYPE_DEF;
+ }
+
+ipv6net {
+ yy_cli_parse_lval.type = IPV6NET_TYPE;
+ return TYPE_DEF;
+ }
+bool {
+ yy_cli_parse_lval.type = BOOL_TYPE;
+ return TYPE_DEF;
+ }
+macaddr {
+ yy_cli_parse_lval.type = MACADDR_TYPE;
+ return TYPE_DEF;
+ }
+\( return LP;
+\) return RP;
+; return SEMI;
+
+\\\n { yy_cli_def_lineno++; /*whitespace -- continuation => ignore */ }
+
+[ \t]+ /* whitespace */
+
+. {
+ /* everything else is a syntax error */
+ return SYNTAX_ERROR;
+ }
+
+%%
+
+static void make_def_value(vtw_type_e type)
+{
+ memset(&yy_cli_parse_lval.val.val, 0, sizeof(yy_cli_parse_lval.val.val));
+ yy_cli_parse_lval.val.free_me = TRUE;
+ yy_cli_parse_lval.val.val = my_strdup(yy_cli_def_text, "cli_parse.l");
+ yy_cli_parse_lval.val.val_type = type;
+}
diff --git a/src/cli_new.c b/src/cli_new.c
new file mode 100644
index 0000000..2f2801d
--- /dev/null
+++ b/src/cli_new.c
@@ -0,0 +1,1938 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <limits.h>
+#include <stdarg.h>
+#include "cli_val.h"
+#include "cli_parse.h"
+#include <regex.h>
+
+#include "cli_objects.h"
+#include "cli_val_engine.h"
+
+/* Defines: */
+
+#define EXE_STRING_DELTA 512
+#define PATH_DELTA 1000
+#define ENDS_ALLOC 20
+#define PATH_CM_LOCATION 25 /* mcd vs. ccd location
+ change when m_root changed */
+
+/* Global vars: */
+vtw_path m_path, t_path;
+
+/* Loval vars: */
+static vtw_node *vtw_free_nodes; /* linked via left */
+static char val_name[] = VAL_NAME;
+static int cond1[TOP_COND] ={5, 0,-1,-1, 0, 1, 0, 0};
+static int cond2[TOP_COND] ={5, 0, 1,-1,-1, 1, 1, 0};
+static char const *cond_formats[DOMAIN_TYPE] =
+ {
+ 0,
+ "%u", /* INT_TYPE */
+ "%u.%u.%u.%u", /*IPV4_TYPE*/
+ "%u.%u.%u.%u/%u", /*IPV4NET_TYPE*/
+ 0,
+ 0,
+ "%x:%x:%x:%x:%x:%x" /* MACADDR_TYPE */
+ };
+
+static int cond_format_lens[DOMAIN_TYPE] =
+ {
+ 0,
+ 1, /* INT_TYPE */
+ 4, /*IPV4_TYPE*/
+ 5, /*IPV4NET_TYPE*/
+ 0,
+ 0,
+ 6 /* MACADDR_TYPE */
+ };
+
+static int cli_val_len;
+static char *cli_val_alloc;
+static char *cli_val_ptr;
+
+static char *exe_string;
+static int exe_string_len;
+static int node_cnt;
+static int free_node_cnt;
+static boolean in_validate_val;
+static valstruct validate_value_val; /* value being validated
+ to be used as $(@) */
+
+/* Local function declarations: */
+
+static int check_comp(vtw_node *cur);
+static boolean check_syn_func(vtw_node *cur,const char* func,int line);
+#define check_syn(cur) check_syn_func((cur),__FUNCTION__,__LINE__)
+static void copy_path(vtw_path *to, vtw_path *from);
+static int eval_va(valstruct *res, vtw_node *node);
+static int expand_string(char *p);
+static void free_node(vtw_node *node);
+static void free_node_tree(vtw_node *node);
+static void free_reuse_list(void);
+static void free_path(vtw_path *path);
+static void free_string(char *str);
+static vtw_node * get_node(void);
+
+static void scan_ipv6(char *val, unsigned int *parts);
+
+static int set_reference_environment(const char* var_reference,
+ clind_path_ref *n_cfg_path,
+ clind_path_ref *n_tmpl_path,
+ clind_path_ref *n_cmd_path,
+ int active);
+
+/*************************************************
+ GLOBAL FUNCTIONS
+***************************************************/
+/* it is executed as "eval `my_set` in order to be able to
+ modify BASH env
+ therefore, all error will be reported as
+ printf("echo \"bla-bla-bla%s\";", sptr)
+ note very important ';' as the end of the format
+*/
+void bye(char *msg, ...)
+{
+ va_list ap;
+
+ if (is_silent_msg())
+ exit(0);
+ va_start(ap, msg);
+ if (is_echo())
+ printf("echo \"");
+ vprintf(msg, ap);
+ printf(is_echo()? "\";":"\n");
+ va_end(ap);
+
+ exit(0);
+}
+
+/* msg:
+ print message, preceeded by "echo " if global
+ flag echo set. This flag is used by program
+ which are executed as eval `command` in order to
+ modify BASH env
+*/
+void print_msg(char *msg, ...)
+{
+ va_list ap;
+
+ if (is_silent_msg())
+ return;
+ va_start(ap, msg);
+ if (is_echo())
+ printf("echo \"");
+ vprintf(msg, ap);
+ printf(is_echo()? "\";":"\n");
+ va_end(ap);
+}
+
+void touch_dir(const char *dp)
+{
+ struct stat statbuf;
+ if (lstat(dp, &statbuf) < 0) {
+ char *command;
+ command = my_malloc(strlen(dp) + 10, "set");
+ sprintf(command, "mkdir -p %s", dp);
+ system(command);
+ free(command);
+ return;
+ }
+ if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
+ bye("directory %s expected, found regular file", dp);
+ }
+ return;
+}
+
+/*****************************************************
+ add_val:
+ verify that the types are the same;
+ if first valstruct is single value, convert it
+ into multivalue;
+ add the value of second to the list of first;
+*****************************************************/
+void add_val(valstruct *first, valstruct *second)
+{
+ assert (first->free_me && second->free_me);
+ assert(second->cnt == 0);
+ if (first->val_type != second->val_type) {
+ printf("Different types\n\n");
+ } else {
+ if (first->cnt%MULTI_ALLOC == 0) {
+ /* convert into multivalue */
+ first->vals = my_realloc(first->vals, (first->cnt + MULTI_ALLOC) *
+ sizeof(char *), "add_value");
+ if (first->cnt == 0) { /* single value - convert */
+ first->vals[0] = first->val;
+ first->cnt = 1;
+ first->val = NULL;
+ }
+ }
+ second->free_me = FALSE; /* we took its string */
+ first->vals[first->cnt] = second->val;
+ ++first->cnt;
+ }
+}
+/*****************************************************
+ append - append node to the tail of list
+*****************************************************/
+void append(vtw_list *l, vtw_node *n, int aux)
+{
+ vtw_node *lnode;
+ lnode = make_node(LIST_OP, n, NULL);
+ lnode->vtw_node_aux = aux;
+ if(l->vtw_list_tail) {
+ assert(l->vtw_list_tail->vtw_node_right == NULL);
+ l->vtw_list_tail->vtw_node_right = lnode;
+ } else {
+ assert(l->vtw_list_head == NULL);
+ l->vtw_list_head = lnode;
+ }
+ l->vtw_list_tail = lnode;
+}
+
+void dt(vtw_sorted *srtp)
+{
+ int i;
+ for (i=0; i<srtp->num; ++i)
+ printf("%d %s\n", i, (char *)(srtp->ptrs[i]));
+}
+
+
+void di(vtw_sorted *srtp)
+{
+ int i;
+ for (i=0; i<srtp->num; ++i)
+ printf("%u %u\n", i, *(unsigned int *)(srtp->ptrs[i]));
+}
+
+static char _lock_file_[1025] = {0};
+static int _lock_fd_=-1;
+
+static void clean_lock_file(void) {
+ if(_lock_file_[0]) {
+ unlink(_lock_file_);
+ _lock_file_[0]=0;
+ }
+ if(_lock_fd_!=-1) {
+ close(_lock_fd_);
+ _lock_fd_=-1;
+ }
+}
+
+boolean get_config_lock(const char* adirp, const char* lock_name) {
+
+ boolean ret = TRUE;
+
+ sprintf(_lock_file_, "%s/%s", adirp, lock_name);
+
+ _lock_fd_ = open(_lock_file_, O_WRONLY | O_CREAT | O_EXCL, 0644);
+
+ ret = (_lock_fd_!=-1);
+
+ if(ret) {
+ atexit(clean_lock_file);
+ }
+
+ return ret;
+}
+
+void internal_error(int line, char *file)
+{
+ printf("\n\nInternal Error at line %d in %s\n", line, file);
+ exit (-1);
+}
+
+/*************************************************
+ vtw_sort:
+ create sorted structure for the value,
+ allocates ptrs and parts in this structure
+*/
+void vtw_sort(valstruct *valp, vtw_sorted *sortp)
+{
+ int i, unsorted, left, child, right;
+ void *leftp, *rightp, *childp;
+ const char * format;
+ unsigned int *parts;
+ vtw_type_e type = valp->val_type;
+ char *cp;
+ int cur=0, par=0, partnum=0, res=0;
+ void *curp, *parp;
+
+ sortp->num = valp->cnt?valp->cnt : 1;
+ sortp->ptrs = my_malloc(sortp->num * sizeof(void *), "sort_ptrs");
+ sortp->partnum = cond_format_lens[type];
+ if (sortp->partnum) {
+ sortp->parts = my_malloc(sortp->partnum * sortp->num * sizeof(void *),
+ "sort_parts");
+ }else{
+ sortp->parts = NULL;
+ }
+ switch (type){
+ case IPV6_TYPE:
+ case IPV6NET_TYPE:
+ for (i = 0; i < sortp->num; ++i) {
+ parts = sortp->parts + i * sortp->partnum;
+ scan_ipv6(valp->cnt?valp->vals[i]:valp->val, parts);
+ sortp->ptrs[i] = parts;
+ }
+ break;
+ case IPV4_TYPE:
+ case IPV4NET_TYPE:
+ case MACADDR_TYPE:
+ case INT_TYPE:
+ format = cond_formats[valp->val_type];
+ for (i = 0; i < sortp->num; ++i) {
+ cp = valp->cnt?valp->vals[i]:valp->val;
+ parts = sortp->parts + i * sortp->partnum;
+ switch (sortp->partnum) {
+ case 1:
+ (void) sscanf(cp, format, parts);
+ break;
+ case 2:
+ (void) sscanf(cp, format, parts, parts+1);
+ break;
+ case 3:
+ (void) sscanf(cp, format, parts, parts+1, parts+2);
+ break;
+ case 4:
+ (void) sscanf(cp, format, parts, parts+1, parts+2,
+ parts+3);
+ break;
+ case 5:
+ (void) sscanf(cp, format, parts, parts+1, parts+2,
+ parts+3, parts+4);
+ break;
+ case 6:
+ (void) sscanf(cp, format, parts, parts+1, parts+2,
+ parts+3, parts+4, parts+5);
+ break;
+ }
+ sortp->ptrs[i] = parts;
+ }
+ break;
+ case TEXT_TYPE:
+ case BOOL_TYPE:
+ for (i = 0; i < sortp->num; ++i) {
+ sortp->ptrs[i] = valp->cnt?valp->vals[i]:valp->val;
+ }
+ break;
+ default:
+ printf("Unknown value in switch on line %d\n", __LINE__);
+ exit(-5);
+ }
+ if (sortp->num < 2)
+ return;
+ /* now do a heap sort */
+ /* build heap */
+ /* from left to right, we start with the heap of only one (first) element*/
+ for (i = 2; i <= sortp->num; ++i)
+ {
+ cur = i;
+ do {
+ curp = sortp->ptrs[cur - 1];
+ par = cur >> 1;
+ parp = sortp->ptrs[par - 1];
+ if (sortp->partnum){
+ for(partnum = 0; partnum < sortp->partnum; ++partnum) {
+ if (*((unsigned int *)curp + partnum)>
+ *((unsigned int *)parp + partnum)){
+ res = 1;
+ break;
+ }
+ if (*((unsigned int *)curp + partnum)<
+ *((unsigned int *)parp + partnum)){
+ res = -1;
+ break;
+ }
+ res = 0;
+ }
+ }else{
+ res = strcmp((char *)curp, (char *) parp);
+ }
+ if (res <= 0)
+ break;
+ /* swap them */
+ sortp->ptrs[cur - 1] = parp;
+ sortp->ptrs[par - 1] = curp;
+
+ } while ((cur = par) != 1);
+ }
+ /* convert heap into sorted array */
+ unsorted = sortp->num; /* sortp->num must be >= 2 */
+ while (TRUE) {
+ void *tp;
+ /* root to the sorted part */
+ tp = sortp->ptrs[0];
+ sortp->ptrs[0] = sortp->ptrs[--unsorted];
+ sortp->ptrs[unsorted] = tp;
+ if (unsorted == 1)
+ break;
+ /* push down the new root */
+ par = 1;
+ while(TRUE) {
+ left = par << 1; /* left child */
+ if (left > unsorted)
+ break; /* no children */
+ else {
+ if (left == unsorted) {
+ /* only left child */
+ child = left;
+ } else {
+ /* both children */
+ right = left+1;
+ leftp = sortp->ptrs[left - 1];
+ rightp = sortp->ptrs[right - 1];
+ /* find larger child */
+ if (sortp->partnum){
+ for(partnum = 0; partnum < sortp->partnum; ++partnum) {
+ if (*((unsigned int *)leftp + partnum) >
+ *((unsigned int *)rightp + partnum)) {
+ res = 1;
+ break;
+ }
+ if (*((unsigned int *)leftp + partnum) <
+ *((unsigned int *)rightp + partnum)) {
+ res = -1;
+ break;
+ }
+ res = 0;
+ }
+ }else{
+ res = strcmp((char *)leftp, (char *) rightp);
+ }
+ if (res >= 0) {
+ child = left; /* left is larger or same*/
+ } else {
+ child = right;
+ }
+ }
+ /* compare parent and larger child */
+ parp = sortp->ptrs[par - 1];
+ childp = sortp->ptrs[child - 1];
+ if (sortp->partnum){
+ for(partnum = 0; partnum < sortp->partnum; ++partnum) {
+ if (*((unsigned int *)parp + partnum) >
+ *((unsigned int *)childp + partnum)){
+ res = 1;
+ break;
+ }
+ if (*((unsigned int *)parp + partnum) <
+ *((unsigned int *)childp + partnum)){
+ res = -1;
+ break;
+ }
+ res = 0;
+ }
+ }else{
+ res = strcmp((char *)parp, (char *) childp);
+ }
+ if (res >= 0) {
+ /* done with percolating down, parent larger than child */
+ break;
+ }
+ /* child greater, exchage and continue */
+ sortp->ptrs[par - 1] = childp;
+ sortp->ptrs[child - 1] = parp;
+ par = child;
+ }
+ }
+ }
+}
+
+/* returns FALSE if execution returns non-null,
+ returns TRUE if every excution returns NULL
+*/
+boolean execute_list(vtw_node *cur, vtw_def *def)
+{
+ boolean ret;
+ int status;
+ set_in_exec(TRUE);
+ status = char2val(def, get_at_string(), &validate_value_val);
+ if (status) return FALSE;
+ ret = check_syn(cur);
+ free_val(&validate_value_val);
+ set_in_exec(FALSE);
+ return ret;
+}
+
+
+/*****************************************************
+ make_node - create a node with oper, left, and right
+*****************************************************/
+vtw_node * make_node(vtw_oper_e oper, vtw_node *left,
+ vtw_node *right)
+{
+ vtw_node *ret ;
+ ret = get_node();
+ ret->vtw_node_oper = oper;
+ ret->vtw_node_left = left;
+ ret->vtw_node_right = right;
+ ret->vtw_node_string = NULL;
+ ret->vtw_node_aux = 0;
+ return ret;
+}
+vtw_node *make_str_node0(char *str, vtw_oper_e op)
+{
+ vtw_node *ret;
+ ret = make_node(op, NULL, NULL);
+ ret->vtw_node_string = str;
+ ret->vtw_node_type = TEXT_TYPE;
+ return ret;
+}
+/*****************************************************
+ make_str_node - create a VAL_OP node with str
+*****************************************************/
+vtw_node *make_str_node(char *str)
+{
+ return make_str_node0(str, VAL_OP);
+}
+/*****************************************************
+ make_var_node - create a VAR_OP node with str
+*****************************************************/
+vtw_node *make_var_node(char *str)
+{
+ return make_str_node0(str, VAR_OP);
+}
+/*****************************************************
+ make_val_node - create a VAl_OP node with str
+*****************************************************/
+vtw_node *make_val_node(valstruct *val)
+{
+ vtw_node *ret;
+ assert(val->free_me);
+ ret = make_node(VAL_OP, NULL, NULL);
+ ret->vtw_node_val = *val;
+ val->free_me = FALSE;
+ return ret;
+}
+valstruct str2val(char *cp)
+{
+ valstruct ret;
+ memset(&ret, 0, sizeof(ret));
+ ret.val_type = TEXT_TYPE;
+ ret.val = cp;
+ ret.free_me = TRUE;
+ return ret;
+}
+/****************************************************
+ STATIC FUNCTIONS
+****************************************************/
+
+/**************************************************
+ char2val:
+ convert string into valstruct verifying the type
+ according to def
+****************************************************/
+int char2val(vtw_def *def, char *value, valstruct *valp)
+{
+ int token;
+ char *endp, *cp;
+ int linecnt, cnt;
+ int my_type = def->def_type;
+ boolean first = TRUE;
+
+ memset(valp, 0, sizeof (*valp));
+
+ if (my_type == ERROR_TYPE) {
+ my_type = TEXT_TYPE;
+ }
+
+ if (my_type != TEXT_TYPE && my_type != ERROR_TYPE) {
+ cli_val_len = strlen(value);
+ cli_val_ptr = value;
+ while(1) {
+ token = yy_cli_val_lex();
+ if (token != VALUE) {
+ if (first || token){
+ if (def->def_type_help){
+ set_at_string(value);
+ (void)expand_string(def->def_type_help);
+ printf("%s\n", exe_string);
+ fprintf(stderr, "%s\n", exe_string);
+ } else {
+ print_msg("Wrong type of value in %s, "
+ "need %s\n",
+ m_path.path_buf + m_path.print_offset,
+ type_to_name(my_type));
+ }
+ return -1;
+ }
+ return 0;
+ }
+ if (my_type != get_cli_value_ptr()->val_type) {
+ if (def->def_type_help){
+ set_at_string(value);
+ (void)expand_string(def->def_type_help);
+ printf("%s\n", exe_string);
+ fprintf(stderr, "%s\n", exe_string);
+ } else {
+ print_msg("Wrong type of value in %s, "
+ "need %s\n",
+ m_path.path_buf + m_path.print_offset,
+ type_to_name(my_type));
+ }
+ my_free(get_cli_value_ptr()->val);
+ if (first)
+ return -1;
+ return 0;
+ }
+ if (first) {
+ *valp = *get_cli_value_ptr();
+ get_cli_value_ptr()->free_me = FALSE;
+ first = FALSE;
+ } else {
+ if (def->multi)
+ add_val(valp, get_cli_value_ptr());
+ else {
+ print_msg("Unexpected multivalue in %s\n", m_path.path);
+ free_val(get_cli_value_ptr());
+ }
+ }
+ token = yy_cli_val_lex();
+ if (!token)
+ return 0;
+ if (token != EOL) {
+ print_msg("Badly formed value in %s\n",
+ m_path.path + m_path.print_offset);
+ if (token == VALUE)
+ my_free(get_cli_value_ptr()->val);
+ return 0;
+ }
+ }
+ return 0;
+ }
+ valp->val_type = TEXT_TYPE;
+ valp->free_me = TRUE;
+ /* count lines */
+ linecnt = 0;
+ for (cp = value; *cp; ++cp)
+ if (*cp == '\n')
+ ++linecnt;
+ if (cp != value && cp[-1] != '\n')
+ ++linecnt; /* last non empty non \n terminated string */
+ if (linecnt == 0) /* one empty non terminated string */
+ linecnt = 1;
+ if (linecnt == 1) {
+ valp->val=my_strdup(value, "char2val 1");
+ /*truncate '\n' etc */
+ endp = strchr(valp->val, '\n');
+ if (endp)
+ *endp = 0;
+ } else {
+ valp->cnt = linecnt;
+ cnt = (linecnt + MULTI_ALLOC - 1) / MULTI_ALLOC;
+ cnt *= MULTI_ALLOC;
+ valp->vals = my_malloc(cnt * sizeof(char *), "char2val 2");
+ for(cp = value, cnt = 0; cnt < linecnt; ++cnt) {
+ endp = strchr(cp, '\n');
+ if (endp)
+ *endp = 0;
+ valp->vals[cnt]=my_strdup(cp, "char2val 3");
+ if (endp) {
+ *endp = '\n';
+ cp = endp + 1;
+ } else {
+ /* non '\n' terinated string, must be last line, we are done */
+ ++cnt;
+ assert(cnt == linecnt);
+ break;
+ }
+ }
+ }
+ return 0;
+}
+
+
+/****************************************************
+ val_comp:
+ compare two values per cond
+ returns result of comparison
+****************************************************/
+boolean val_cmp(valstruct *left, valstruct *right, vtw_cond_e cond)
+{
+ unsigned int left_parts[9], right_parts[9];
+ vtw_type_e val_type;
+ int parts_num, lstop, rstop, lcur, rcur;
+ char const *format;
+ char *lval, *rval;
+ int ret=0, step=0, res=0;
+
+ val_type = left->val_type;
+ if (left->cnt)
+ lstop = left->cnt;
+ else
+ lstop = 1;
+ if (right->cnt)
+ rstop = right->cnt;
+ else
+ rstop = 1;
+
+ for(lcur = 0; lcur < lstop; ++lcur) {
+ if (!lcur && !left->cnt)
+ lval = left->val;
+ else
+ lval = left->vals[lcur];
+ for(rcur = 0; rcur < rstop; ++rcur) {
+ if (!rcur && !right->cnt)
+ rval = right->val;
+ else
+ rval = right->vals[rcur];
+ switch (val_type) {
+ case IPV6_TYPE:
+ parts_num = 8;
+ goto ipv6_common;
+ case IPV6NET_TYPE:
+ parts_num = 9;
+ ipv6_common:
+ scan_ipv6(lval,left_parts);
+ scan_ipv6(rval,right_parts);
+ break;
+ case IPV4_TYPE:
+ case IPV4NET_TYPE:
+ case MACADDR_TYPE:
+ case INT_TYPE:
+ format = cond_formats[val_type];
+ parts_num = cond_format_lens[val_type];
+ (void) sscanf(lval, format, left_parts, left_parts+1,
+ left_parts+2, left_parts+3, left_parts+4,
+ left_parts+5);
+ (void) sscanf(rval, format, right_parts, right_parts+1,
+ right_parts+2, right_parts+3, right_parts+4,
+ right_parts+5);
+ break;
+ case TEXT_TYPE:
+ case BOOL_TYPE:
+ res = strcmp(lval, rval);
+ goto done_comp;
+ default:
+ printf("Unknown value in switch on line %d\n", __LINE__);
+ exit(-5);
+ }
+ /* here to do a multistep int compare */
+ for (step = 0; step < parts_num; ++ step) {
+ if (left_parts[step] > right_parts[step]) {
+ res = 1;
+ break; /* no reason to continue checking other steps */
+ }
+ if (left_parts[step] < right_parts[step]) {
+ res = -1;
+ break; /* no reason to continue checking other steps */
+ }
+ res = 0;
+ }
+ done_comp:
+ if(res > 0) res = 1;
+ else if(res < 0) res = -1;
+ ret = ((res == cond1[cond]) ||
+ (res == cond2[cond]));
+ if (ret && cond == IN_COND) {
+ set_in_cond_tik(rcur); /* for delete */
+ /* one success is enough for right cycle
+ in case of IN_COND, continue left cycle */
+ break;
+ }
+ if (!ret && cond != IN_COND)
+ /* one failure is enough in cases
+ other than IN_COND - go out */
+ return ret;
+ /* in all other cases:
+ (fail & IN_COND) or (success & !IN_COND)
+ contniue checking; */
+ }
+ }
+ return ret;
+}
+
+
+
+/****************************************************
+ check_comp:
+ evaluate comparison node.
+ returns boolean value of result
+****************************************************/
+static boolean check_comp(vtw_node *cur)
+{
+ int ret;
+ int status;
+ valstruct left, right;
+
+ memset(&left, 0 , sizeof(left));
+ memset(&right, 0 , sizeof(right));
+ ret = FALSE; /* in case of status */
+ status = eval_va(&left, cur->vtw_node_left);
+ if (status)
+ goto free_and_return;
+ status = eval_va(&right, cur->vtw_node_right);
+ if (status)
+ goto free_and_return;
+ if(left.val_type != right.val_type) {
+ printf("Different types in comparison\n");
+ goto free_and_return;
+ }
+ ret = val_cmp(&left, &right,cur->vtw_node_aux);
+ free_and_return:
+ if (left.free_me)
+ free_val(&left);
+ if (right.free_me)
+ free_val(&right);
+ return ret;
+}
+
+/******************
+ Change value of var in the file
+
+*****************/
+
+static int write_value_to_file(const char* var_path,const char* value) {
+
+ if(var_path && value) {
+
+ {
+ /*Build directory, if necessary:*/
+ clind_path_ref var_dir_path=clind_path_construct(var_path);
+
+ if(!var_dir_path) bye("Can not construct path %s", var_path);
+ else {
+
+ char* end = clind_path_pop_string(var_dir_path);
+
+ if(!end || strcmp(end,VAL_NAME)) {
+ bye("Wrong end of path: %s (%s)", end,var_path);
+ }
+
+ free(end);end=NULL;
+
+ touch();
+ touch_dir(clind_path_get_path_string(var_dir_path));
+
+ clind_path_destruct(&var_dir_path);
+ }
+ }
+
+ {
+ /*Write to file*/
+ FILE* fp = fopen(var_path, "w");
+ if(!fp) bye("Can not open value file %s", var_path);
+
+ if (fputs(value, fp) < 0 || fputc('\n',fp) < 0)
+ bye("Error writing file %s", var_path);
+
+ fclose(fp);
+
+ }
+ }
+
+ return 0;
+}
+
+static int change_var_value(const char* var_reference,const char* value, int active_dir) {
+
+ int ret=-1;
+
+ if(var_reference && value) {
+
+ char* var_path=NULL;
+
+ clind_path_ref n_cfg_path=NULL;
+ clind_path_ref n_tmpl_path=NULL;
+ clind_path_ref n_cmd_path=NULL;
+
+ if(set_reference_environment(var_reference,
+ &n_cfg_path,
+ &n_tmpl_path,
+ &n_cmd_path,
+ active_dir)==0) {
+
+ clind_val cv;
+
+ memset(&cv,0,sizeof(cv));
+
+ if(clind_config_engine_apply_command_path(n_cfg_path,
+ n_tmpl_path,
+ n_cmd_path,
+ FALSE,
+ &cv,
+ get_cdirp(),
+ get_tdirp(),
+ TRUE)==0) {
+ var_path=cv.value;
+
+ }
+
+ }
+
+ if(n_cfg_path) clind_path_destruct(&n_cfg_path);
+ if(n_tmpl_path) clind_path_destruct(&n_tmpl_path);
+ if(n_cmd_path) clind_path_destruct(&n_cmd_path);
+
+ if(var_path) {
+ ret=write_value_to_file(var_path,value);
+ free(var_path);
+ }
+ }
+
+ return ret;
+}
+
+/****************************************************
+ check_syn:
+ evaluate syntax tree;
+ returns TRUE if all checks are OK,
+ returns FALSE if check fails.
+****************************************************/
+static boolean check_syn_func(vtw_node *cur,const char* func,int line)
+{
+ int status;
+ int ret;
+ int ii;
+
+ switch(cur->vtw_node_oper) {
+ case LIST_OP:
+ ret = check_syn(cur->vtw_node_left);
+ if (!is_in_commit() && cur->vtw_node_aux)
+ ret = TRUE;
+ if (!ret || !cur->vtw_node_right) /* or no right operand */
+ return ret;
+ return check_syn(cur->vtw_node_right);
+ case HELP_OP:
+ ret = check_syn(cur->vtw_node_left);
+ if (ret <= 0){
+ if (expand_string(cur->vtw_node_right->vtw_node_string) == VTWERR_OK) {
+ fprintf(stderr, exe_string);
+ fprintf(stderr, "\n");
+ printf(exe_string);
+ printf("\n");
+ }
+ }
+ return ret;
+
+ case ASSIGN_OP:
+
+ if (is_in_exec()) {
+
+ valstruct right;
+
+ char* var_reference = NULL;
+
+ memset(&right, 0, sizeof(right));
+ status = eval_va(&right, cur->vtw_node_right);
+
+ if (status || right.cnt) { /* bad or multi */
+ if (right.free_me) free_val(&right);
+ return FALSE;
+ }
+
+ var_reference = strdup(cur->vtw_node_left->vtw_node_string+2);
+
+ {
+ int i=0;
+ while(var_reference[i]) {
+ if(var_reference[i]==')') {
+ var_reference[i]=0;
+ break;
+ }
+ i++;
+ }
+ }
+
+ change_var_value(var_reference,right.val,FALSE);
+ change_var_value(var_reference,right.val,TRUE);
+
+ if (right.free_me) free_val(&right);
+
+ if(var_reference) free(var_reference);
+ }
+
+ return TRUE;
+
+ case EXEC_OP:
+ /* for every value */
+ if (in_validate_val) {
+ char *save_at = get_at_string();
+ for(ii = 0; ii < validate_value_val.cnt || ii == 0; ++ii) {
+ set_at_string(validate_value_val.cnt?
+ validate_value_val.vals[ii]:validate_value_val.val);
+ status = expand_string(cur->vtw_node_left->vtw_node_string);
+ if (status != VTWERR_OK) {
+ set_at_string(save_at);
+ return FALSE;
+ }
+ ret = system(exe_string);
+ if (ret) {
+ set_at_string(save_at);
+ return FALSE;
+ }
+ }
+ set_at_string(save_at);
+ return TRUE;
+ }
+ /* else */
+ status = expand_string(cur->vtw_node_left->vtw_node_string);
+ if (status != VTWERR_OK) {
+ return FALSE;
+ }
+ ret = system(exe_string);
+ return !ret;
+
+ case PATTERN_OP: /* left to var, right to pattern */
+ {
+ valstruct left;
+ regex_t myreg;
+ boolean ret;
+ int ii;
+
+ ret = TRUE;
+ status = eval_va(&left, cur->vtw_node_left);
+ if (status) {
+ ret = FALSE;
+ goto free_and_return;
+ }
+ status = regcomp(&myreg, cur->vtw_node_right->vtw_node_string,
+ REG_EXTENDED);
+ if (status)
+ bye("Can not compile regex |%s|, result %d\n",
+ cur->vtw_node_right->vtw_node_string, status);
+ /* for every value */
+ for(ii = 0; ii < left.cnt || ii == 0; ++ii) {
+ status = regexec(&myreg, left.cnt?
+ left.vals[ii]:left.val,
+ 0, 0, 0);
+ if(status) {
+ ret = FALSE;
+ break;
+ }
+ }
+ free_and_return:
+ if (left.free_me)
+ free_val(&left);
+ return ret;
+ }
+
+ case OR_OP:
+ ret = check_syn(cur->vtw_node_left) ||
+ check_syn(cur->vtw_node_right);
+ return ret;
+ case AND_OP:
+ ret = check_syn(cur->vtw_node_left) &&
+ check_syn(cur->vtw_node_right);
+ return ret;
+ case NOT_OP:
+ ret = check_syn(cur->vtw_node_left);
+ return !ret;
+
+ case COND_OP: /* aux field specifies cond type (GT, GE, etc.)*/
+ ret = check_comp(cur);
+ return ret;
+
+ case VAL_OP:
+ printf("VAL op in check_syn\n");
+ exit(-4);
+ case VAR_OP:
+ printf("VAR op in check_syn\n");
+ exit(-4);
+ default:
+ printf("unknown op %d in check_syn\n", cur->vtw_node_oper);
+ exit(-4);
+ }
+}
+
+/*************************************************
+ copy_path:
+ copy path
+ if destination path owns memory, free it
+**************************************************/
+static void copy_path(vtw_path *to, vtw_path *from)
+{
+ if (to->path_buf)
+ my_free(to->path_buf);
+ if (to->path_ends)
+ my_free(to->path_ends);
+ *to = *from;
+ to->path_buf = (char *) my_malloc(from->path_alloc+2, "copy_path1");
+ memcpy(to->path_buf, from->path_buf, to->path_alloc + 1);
+ to->path = to->path_buf + (from->path-from->path_buf);
+ to->path_ends = (int *) my_malloc(to->path_ends_alloc * sizeof(int),
+ "copy_path2");
+ memcpy(to->path_ends, from->path_ends,
+ to->path_ends_alloc * sizeof(int));
+}
+
+/*****************************************************
+ eval_va:
+ converts VAR_OP or VAL_OP node into valstruct
+ in case of VAR_OP we need to find corresponding
+ template node to obtain type.
+
+*****************************************************/
+static int eval_va(valstruct *res, vtw_node *node)
+{
+ char *cp=NULL;
+ char *pathp=NULL;
+ int status=0;
+
+ switch (node->vtw_node_oper) {
+ case VAR_OP:
+
+ {
+ char *endp = 0;
+ clind_path_ref n_cfg_path=NULL;
+ clind_path_ref n_tmpl_path=NULL;
+ clind_path_ref n_cmd_path=NULL;
+
+ pathp = node->vtw_node_string;
+
+ assert(pathp[0]=='$' && pathp[1]=='(');
+ pathp += 2;
+
+ if(pathp[0] == '@' && pathp[1]!='@'){
+ /* this is why we passed at_val all around */
+ *res = validate_value_val;
+ res->free_me = FALSE;
+ return 0;
+ }
+
+ memset(res,0,sizeof(*res));
+
+ if ((endp = strchr(pathp, ')')) == NULL) {
+ printf("invalid VAR_OP [%s]\n", node->vtw_node_string);
+ return VTWERR_BADPATH;
+ }
+
+ *endp = 0;
+
+ if(set_reference_environment(pathp,
+ &n_cfg_path,
+ &n_tmpl_path,
+ &n_cmd_path,
+ is_in_delete_action())==0) {
+
+ clind_val cv;
+
+ memset(&cv,0,sizeof(cv));
+
+ status=clind_config_engine_apply_command_path(n_cfg_path,
+ n_tmpl_path,
+ n_cmd_path,
+ FALSE,
+ &cv,
+ get_cdirp(),
+ get_tdirp(),
+ FALSE);
+
+ if(status==0) {
+ if(cv.value) {
+ res->val_type = cv.val_type;
+ res->free_me = TRUE;
+ res->val = cv.value;
+ }
+ }
+ }
+
+ if(n_cfg_path) clind_path_destruct(&n_cfg_path);
+ if(n_tmpl_path) clind_path_destruct(&n_tmpl_path);
+ if(n_cmd_path) clind_path_destruct(&n_cmd_path);
+
+ *endp = ')';
+
+ return status;
+ }
+
+ case VAL_OP:
+ *res = node->vtw_node_val;
+ res->free_me = FALSE;
+ return 0;
+ case B_QUOTE_OP:
+ {
+ FILE *f;
+ int a_len, len, rd;
+
+ status = expand_string(node->vtw_node_string);
+ if (status != VTWERR_OK) {
+ return FALSE;
+ }
+ f = popen(exe_string, "r");
+ if (!f)
+ return -1;
+#define LEN 24
+ len = 0;
+ cp = my_malloc(LEN,"");
+ a_len = LEN;
+ for(;;){
+ rd = fread(cp + len, 1, a_len - len , f);
+ len += rd;
+ if (len < a_len)
+ break;
+ cp = my_realloc(cp, a_len+LEN, "");
+ a_len += LEN;
+ }
+ cp[len] = 0;
+ pclose(f);
+ memset(res, 0, sizeof (*res));
+ res->val_type = TEXT_TYPE;
+ res->free_me = TRUE;
+ res->val = cp;
+ }
+ return 0;
+ default:
+ return 0;
+ }
+}
+
+/**********************************************************
+ expand_string:
+ expand string replacing var references with the appropriate
+ values, the formed string is collected in the buffer pointed
+ at by the global exe_string. The buffer dynamically allocated
+ and reallocated.
+***********************************************************/
+static int expand_string(char *stringp)
+{
+ char *scanp;
+ char *resp = exe_string;
+ int left = exe_string_len;
+ int my_len;
+ int len;
+
+ scanp = stringp; /* save stringp for printf */
+
+ do{
+
+ if (left <= 1){
+ my_len = resp - exe_string;
+ exe_string_len += EXE_STRING_DELTA;
+ exe_string = my_realloc(exe_string, exe_string_len, "expand_string 1");
+ left += EXE_STRING_DELTA;
+ resp = exe_string + my_len;
+ /* back in business */
+ }
+ if (*scanp != '$') {
+ if(*scanp == '\\' && scanp[1] == '$') {
+ /* escaped $, treat as regular char */
+ ++scanp;
+ }
+ *resp++ = *scanp++;
+ --left;
+ } else {
+
+ char *cp=NULL;
+ boolean my_cp=FALSE;
+
+ if (scanp[1] != '('){
+
+ printf("Badly formed var reference in %s\n", stringp);
+ exit (VTWERR_BADPATH);
+
+ } else if(scanp[2] == '@' && scanp[3] == ')') {
+
+ cp = get_at_string();
+ my_cp = FALSE;
+ scanp += 4;
+
+ } else {
+
+ clind_path_ref n_cfg_path=NULL;
+ clind_path_ref n_tmpl_path=NULL;
+ clind_path_ref n_cmd_path=NULL;
+
+ char *endp;
+
+ endp = strchr(scanp, ')');
+ if (!endp ){
+ return -1;
+ }
+
+ scanp += 2;
+ /* path reference */
+ *endp = 0;
+ if (endp == scanp)
+ bye("Empty path");
+
+ if(set_reference_environment(scanp,
+ &n_cfg_path,
+ &n_tmpl_path,
+ &n_cmd_path,
+ is_in_delete_action())==0) {
+
+ clind_val cv;
+
+ memset(&cv,0,sizeof(cv));
+
+ if(clind_config_engine_apply_command_path(n_cfg_path,
+ n_tmpl_path,
+ n_cmd_path,
+ FALSE,
+ &cv,
+ get_cdirp(),
+ get_tdirp(),
+ FALSE)==0) {
+ cp=cv.value;
+
+ }
+
+ }
+
+ if(n_cfg_path) clind_path_destruct(&n_cfg_path);
+ if(n_tmpl_path) clind_path_destruct(&n_tmpl_path);
+ if(n_cmd_path) clind_path_destruct(&n_cmd_path);
+
+ if(!cp) {
+ cp="";
+ } else {
+ my_cp=TRUE;
+ }
+
+ *endp = ')';
+
+ scanp = strchr(scanp, ')') + 1;
+ }
+ len = strlen(cp);
+ while(len + 1 > left) { /* 1 for termination */
+ my_len = resp - exe_string;
+ exe_string_len += EXE_STRING_DELTA;
+ exe_string = my_realloc(exe_string, exe_string_len, "expand_string 2");
+ left += EXE_STRING_DELTA;
+ resp = exe_string + my_len;
+ /* back in business */
+ }
+
+ strcpy(resp, cp);
+ if(my_cp && cp) free(cp);
+ resp += len;
+ left -= len;
+ }
+
+ } while(*scanp);
+
+ *resp = 0;
+
+ return VTWERR_OK;
+}
+
+/*****************************************************
+ free_sorted:
+ free all memory allocated to sorted
+*****************************************************/
+void free_sorted(vtw_sorted *sortp)
+{
+ if(sortp->ptrs)
+ my_free(sortp->ptrs);
+ if (sortp->parts)
+ my_free(sortp->parts);
+}
+
+
+/*****************************************************
+ free_def:
+ free all memory allocated to def
+*****************************************************/
+void free_def(vtw_def *defp)
+{
+ vtw_act_type act;
+ for(act=0; act<top_act; ++ act)
+ if (defp->actions[act].vtw_list_head)
+ free_node_tree(defp->actions[act].vtw_list_head);
+ if (defp->def_type_help)
+ my_free(defp->def_type_help);
+ if (defp->def_default)
+ my_free(defp->def_default);
+}
+
+/*****************************************************
+ free_node - add node to free list
+*****************************************************/
+static void free_node(vtw_node *node)
+{
+ --node_cnt;
+ ++free_node_cnt;
+ node->vtw_node_left = vtw_free_nodes;
+ vtw_free_nodes = node;
+}
+
+/*****************************************************
+ free_node_tree - add all nodes of the tree to free list
+*****************************************************/
+static void free_node_tree(vtw_node *node)
+{
+ if (node->vtw_node_left)
+ free_node_tree(node->vtw_node_left);
+ if (node->vtw_node_right)
+ free_node_tree(node->vtw_node_right);
+ if (node->vtw_node_string)
+ free_string(node->vtw_node_string);
+ if (node->vtw_node_val.free_me)
+ free_val(&(node->vtw_node_val));
+ free_node(node);
+}
+
+static void free_path(vtw_path *path)
+{
+ if (path->path_ends)
+ my_free(path->path_ends);
+ if (path->path_buf) {
+ my_free(path->path_buf);
+ }
+}
+
+static void free_reuse_list()
+{
+ vtw_node *next;
+ int cnt = 0;
+
+ while (vtw_free_nodes) {
+ next = vtw_free_nodes->vtw_node_left;
+ my_free(vtw_free_nodes);
+ ++cnt;
+ vtw_free_nodes = next;
+ --free_node_cnt;
+ }
+#if DEBUG
+ printf("%d nodes used\n", cnt);
+#endif
+}
+
+/*****************************************************
+ free_val - dealloc allocated memory of valstruct
+*****************************************************/
+void free_val(valstruct *val)
+{
+ int cnt;
+
+ assert(val->free_me);
+ if (val->val)
+ my_free(val->val);
+ for (cnt = 0; cnt < val->cnt; ++ cnt)
+ my_free(val->vals[cnt]);
+ if(val->vals)
+ my_free(val->vals);
+}
+/*****************************************************
+ free_string - dealloc string
+ just free for now, we might do something else later
+*****************************************************/
+static void free_string(char *str)
+{
+ my_free(str);
+}
+
+
+/*****************************************************
+ get_node - take node from free list or allocate
+*****************************************************/
+static vtw_node * get_node(void)
+{
+ vtw_node *ret;
+ if (vtw_free_nodes){
+ ret = vtw_free_nodes;
+ vtw_free_nodes = vtw_free_nodes->vtw_node_left;
+ --free_node_cnt;
+ } else {
+ ret = my_malloc(sizeof(vtw_node), "New node");
+ }
+ ++node_cnt;
+ memset(ret, 0, sizeof(vtw_node));
+ return ret;
+}
+
+/****************************************************
+ get_value:
+ for a given path (*path) verify that value exists,
+ open it and read it. The pointer to allocated
+ memory is returned in valpp. It is responsibility
+ of a caller to release memory.
+ Returns:
+******************************************************/
+int get_value(char **valpp, vtw_path *pathp)
+{
+ struct stat statbuf;
+ int status = VTWERR_OK;
+ char const *err = NULL;
+ FILE *in = NULL;
+ char *valp;
+ int readcnt;
+
+
+ /* find value */
+ *valpp = 0;
+ push_path(pathp, val_name);
+
+ if (lstat(pathp->path, &statbuf) < 0) {
+ err = "no value file in [%s]\n";
+ goto bad_path;
+ }
+ if ((statbuf.st_mode & S_IFMT) != S_IFREG) {
+ err = "no value file in [%s]\n";
+ goto bad_path;
+ }
+ in = fopen(pathp->path, "r");
+ if (!in) {
+ err = "Can not open value file in [%s]\n";
+ goto bad_path;
+ }
+ valp = my_malloc(statbuf.st_size + 1, "get_value");
+ readcnt = fread(valp, 1, statbuf.st_size, in);
+ if (readcnt != statbuf.st_size) {
+ my_free(valp);
+ cli_val_alloc = 0;
+ err = "Error reading value file in [%s]\n";
+ goto bad_path;
+ }
+ valp[statbuf.st_size] = 0;
+ /* remove \n at the line end */
+ if (valp[statbuf.st_size - 1] == '\n')
+ valp[statbuf.st_size - 1] = 0;
+ *valpp = valp;
+ status = 0;
+pop:
+ if (in)
+ fclose(in);
+ pop_path(pathp);
+ if (err) {
+ fprintf(stderr, err, pathp->path_buf + m_path.print_offset);
+ printf(err, pathp->path_buf + m_path.print_offset);
+ }
+ return status;
+ bad_path:
+ status = VTWERR_BADPATH;
+ goto pop;
+}
+
+int get_value_to_at_string(vtw_path *pathp) {
+
+ char* at=NULL;
+ int status = get_value(&at,pathp);
+
+ if(status==0) {
+ set_at_string(at);
+ } else {
+ set_at_string(NULL);
+ }
+
+ return status;
+}
+
+/*****************************************************
+ out_of_memeory
+ print out of memory message and exit
+*****************************************************/
+void out_of_memory()
+{
+ printf("\n\t!!! OUT OF MEMORY !!!\n");
+ exit(-1);
+}
+
+/*************************************************
+ init_path:
+ init path, exit if not able (out_of_memory)
+**************************************************/
+void init_path(vtw_path *path, const char *root)
+{
+ long path_len;
+ memset(path, 0, sizeof(vtw_path));
+ path_len = pathconf(root, _PC_PATH_MAX);
+ if (path_len < 0)
+ path_len = PATH_DELTA;
+ path->path_alloc = path_len - 2;
+ /* 1 byte for null termination, and 1 byte for '/' */
+ path->path_buf = path->path =
+ (char *)my_malloc(path_len, "init_path 1");
+ strcpy(path->path, root);
+ path->path_len = strlen(root);
+ path->path_ends = (int *)my_malloc(ENDS_ALLOC * sizeof(int *),
+ "init_path 2");
+ path->path_lev = 1;
+ path->path_ends[0] = path->path_len;
+ path->path_ends_alloc = ENDS_ALLOC;
+}
+
+/*****************************************************
+ pop_path - shorten path by one segment
+*****************************************************/
+
+void pop_path(vtw_path *path)
+{
+ if (--path->path_lev < 1) {
+ INTERNAL;
+ }
+ path->path_len = path->path_ends[path->path_lev - 1];
+ path->path_buf[path->path_len] = 0;
+}
+void warrant_path(vtw_path *path, int len)
+{
+ int delta = path->path - path->path_buf;
+
+ while(path->path_alloc - path->path_len < len + 1){
+ path->path_buf = (char *)my_realloc(path->path_buf,
+ path->path_alloc +
+ PATH_DELTA, "push_path 1");
+ path->path_alloc += PATH_DELTA;
+ }
+ path->path = path->path_buf + delta;
+}
+/*****************************************************
+ push_path - extend path by '/' and one new segment
+*****************************************************/
+void push_path(vtw_path *path, char *segm)
+{
+ int len;
+ char *cp;
+ char *pp;
+
+ for(cp=segm, len=0;*cp;++cp, ++len)
+ if(*cp=='%' || *cp=='/')
+ len +=2;
+ warrant_path(path, len + 1);
+ path->path_buf[path->path_len] = '/';
+ path->path_buf[++path->path_len] = 0;
+ for(pp=path->path_buf + path->path_len,cp=segm;
+ *cp;++cp, ++pp)
+ if(*cp=='%') {
+ pp[0] = '%';
+ pp[1] = '2';
+ pp[2] = '5';
+ pp += 2;
+ }else if (*cp == '/') {
+ pp[0] = '%';
+ pp[1] = '2';
+ pp[2] = 'F';
+ pp += 2;
+ }else
+ *pp = *cp;
+ *pp = 0;
+
+ path->path_len += len;
+ if (path->path_lev == path->path_ends_alloc){
+ path->path_ends_alloc += ENDS_ALLOC;
+ path->path_ends = (int *)my_realloc(path->path_ends,
+ sizeof(int *)*path->path_ends_alloc, "puhs_path 2");
+ }
+ path->path_ends[path->path_lev++] = path->path_len;
+}
+
+/****************************************************
+ scan_ipv6:
+ scans ipv6 or ipv6net pointed by val
+ and returns as array of integers pointed
+ by parts
+***************************************************/
+static void scan_ipv6(char *val, unsigned int *parts)
+{
+ int num = 0;
+ int num_cnt = 0;
+ int dot_dot_pos = -1;
+ int dot_cnt = 0;
+ char c;
+ char *p;
+ int base = 16;
+ int total = 8;
+ int gap;
+
+ for (p = val;TRUE; ++p) {
+ switch ((c = *p)) {
+ case '.':
+ if (dot_cnt == 0) {
+ /* turn out it was decimal, convert our wrong
+ hex interpretation;
+ decimal may not have more than 3 digits */
+ num = (num/256)*100 + (num%256)/16*10 + num%16;
+ base = 10;
+ }
+ ++dot_cnt;
+ break;
+ case ':':
+ if (p[1] == ':'){
+ ++p;
+ dot_dot_pos = num_cnt + 1;
+ }
+ break;
+ case '/':
+ base = 10;
+ total = 9;
+ break;
+ case 0:
+ break;
+ default:
+ /* must be a digit */
+ c = tolower(*p);
+ if (isdigit(c))
+ num = num * base + c - '0';
+ else
+ num = num * base + c - 'a' + 10;
+ continue;
+ }
+ /* close the number */
+ /* the case of "::234: etc "
+ handled automatically as 0::234
+ with allowing :: to represent 0 or more
+ groups instead of 1 or more */
+
+ parts[num_cnt] = num;
+ num = 0;
+ ++num_cnt;
+ /* combine two decimal if needed */
+ if (dot_cnt == 2 || (dot_cnt == 3 && (c == 0 || c == '/'))) {
+ --num_cnt;
+ parts[num_cnt - 1] = parts[num_cnt - 1] * 256 + parts[num_cnt];
+ }
+ if (*p == 0)
+ break;
+ }
+ /* replace '::' with 0s */
+ if (dot_dot_pos != -1 && total != num_cnt) {
+ int i;
+ gap = total - num_cnt;
+ if (dot_dot_pos != num_cnt)
+ memmove(parts+dot_dot_pos+gap, parts+dot_dot_pos,
+ (num_cnt-dot_dot_pos)*sizeof(int));
+ for (i = 0; i<gap; ++i)
+ parts[dot_dot_pos+i] = 0;
+ }
+}
+
+/***************************************************
+ switch_path:
+ switch m_path between mcd and ccd directories -
+ modified (UNIONFS) configuration and changed
+ (real) configuration
+****************************************************/
+void switch_path(first_seg *segp)
+{
+ memcpy(m_path.path_buf + segp->f_segoff, segp->f_segp,
+ segp->f_seglen);
+ m_path.path = m_path.path_buf + segp->f_segoff;
+}
+
+/*************************************************
+ validate_value:
+ validates value against type and syntax
+ return TRUE if OK, FALSE otherwise
+**************************************************/
+boolean validate_value(vtw_def *def, char *cp)
+{
+ int status;
+ boolean ret=TRUE;
+
+ /* prepare cur_value */
+ set_at_string(cp);
+ status = char2val(def, cp, &validate_value_val);
+ if (status != VTWERR_OK)
+ return FALSE;
+ if ((def->def_type!=ERROR_TYPE) &&
+ (validate_value_val.val_type != def->def_type)) {
+ if (def->def_type_help){
+ (void)expand_string(def->def_type_help);
+ printf("%s\n", exe_string);
+ fprintf(stderr, "%s\n", exe_string);
+ } else {
+ printf("Incorrect type of %s, need %s\n",
+ cp, type_to_name(def->def_type));
+ }
+ ret = FALSE;
+ goto validate_value_free_and_return;
+ }
+ ret = TRUE;
+ if (def->actions && def->actions[syntax_act].vtw_list_head){
+ in_validate_val = TRUE;
+ ret = check_syn(def->actions[syntax_act].vtw_list_head);
+ in_validate_val = FALSE;
+ }
+ validate_value_free_and_return:
+ free_val(&validate_value_val);
+ return ret;
+}
+
+
+int cli_val_read(char *buf, int max_size)
+{
+ int len;
+
+ if (cli_val_len > max_size)
+ len = max_size;
+ else
+ len = cli_val_len;
+ if (len) {
+ (void)memcpy(buf, cli_val_ptr, len);
+ cli_val_len -= len;
+ cli_val_ptr += len;
+ }
+ return len;
+}
+/*==========================================================*/
+/* MEMORY */
+/*==========================================================*/
+
+void *my_malloc(size_t size, const char *name)
+{
+ return malloc(size);
+}
+void *my_realloc(void *ptr, size_t size, const char *name)
+{
+ return realloc(ptr, size);
+}
+
+void my_free(void *ptr)
+{
+ free(ptr);
+}
+
+/*************************************************
+ my_strdup:
+ do a strdup,
+ exit on no memory
+**************************************************/
+char *my_strdup(const char *s, const char *name)
+{
+ return strdup(s);
+}
+
+void done()
+{
+ free_reuse_list();
+ free_path(&t_path);
+ free_path(&m_path);
+ if (exe_string)
+ my_free(exe_string);
+}
+void mark_paths(vtw_mark *markp)
+{
+ markp->m_lev = m_path.path_lev;
+ markp->t_lev = t_path.path_lev;
+}
+void restore_paths(vtw_mark *markp)
+{
+ while(markp->m_lev < m_path.path_lev)
+ pop_path(&m_path);
+ while(markp->t_lev < t_path.path_lev)
+ pop_path(&t_path);
+}
+
+void touch()
+{
+ char *command;
+ command = my_malloc(strlen(get_mdirp()) + 20, "delete");
+ sprintf(command, "touch %s/%s", get_mdirp(), MOD_NAME);
+ system(command);
+ free(command);
+}
+
+char *type_to_name(vtw_type_e type) {
+ switch(type) {
+ case INT_TYPE: return("u32");
+ case IPV4_TYPE: return("ipv4");
+ case IPV4NET_TYPE: return("ipv4net");
+ case IPV6_TYPE: return("ipv6");
+ case IPV6NET_TYPE: return("ipv6net");
+ case MACADDR_TYPE: return("macaddr");
+ case DOMAIN_TYPE: return("domain");
+ case TEXT_TYPE: return("text");
+ case BOOL_TYPE: return("bool");
+ default: return("unknown");
+ }
+}
+
+#if 1
+void
+dump_log(int argc, char **argv)
+{
+}
+#else
+void dump_log(int argc, char **argv)
+{
+ int i;
+ int len;
+ char *cp;
+
+ len = 0;
+ for (i=0; i<argc;++i)
+ len += strlen(argv[i]);
+ len += argc;
+ cp = my_malloc(len, "dump_log");
+ len = 0;
+ for (i=0; i<argc;++i){
+ strcpy(cp+len, argv[i]);
+ len += strlen(argv[i]);
+ cp[len]= ' ';
+ ++len;
+ }
+ cp[len-1]=0;
+ printf("Command: %s\n",cp);
+ my_free(cp);
+}
+#endif
+
+/********************* New Dir ****************************/
+
+static int set_reference_environment(const char* var_reference,
+ clind_path_ref *n_cfg_path,
+ clind_path_ref *n_tmpl_path,
+ clind_path_ref *n_cmd_path,
+ int active) {
+
+ if(var_reference && n_cfg_path && n_tmpl_path && n_cmd_path) {
+
+ if(*var_reference=='/') {
+
+ if(is_in_delete_action()) {
+ *n_cfg_path=clind_path_construct(get_adirp());
+ } else {
+ *n_cfg_path=clind_path_construct(get_mdirp());
+ }
+ *n_tmpl_path=clind_path_construct(get_tdirp());
+ *n_cmd_path=clind_path_construct(var_reference);
+
+ } else {
+
+ vtw_path n_vt_path;
+
+ memset(&n_vt_path,0,sizeof(n_vt_path));
+
+ copy_path(&n_vt_path, &m_path);
+ /* switch to MPATH */
+ memcpy(n_vt_path.path_buf + get_f_seg_m_ptr()->f_segoff, get_f_seg_m_ptr()->f_segp,
+ get_f_seg_m_ptr()->f_seglen);
+ n_vt_path.path = n_vt_path.path_buf + get_f_seg_m_ptr()->f_segoff;
+
+ if(active) {
+
+ vtw_path active_path;
+
+ memset(&active_path,0,sizeof(active_path));
+
+ copy_path(&active_path, &n_vt_path);
+
+ memcpy(active_path.path_buf + get_f_seg_a_ptr()->f_segoff, get_f_seg_a_ptr()->f_segp,
+ get_f_seg_a_ptr()->f_seglen);
+ active_path.path = active_path.path_buf + get_f_seg_a_ptr()->f_segoff;
+
+ *n_cfg_path=clind_path_construct(active_path.path);
+
+ } else {
+
+ *n_cfg_path=clind_path_construct(n_vt_path.path);
+
+ }
+
+ *n_tmpl_path=clind_path_construct(t_path.path);
+ *n_cmd_path=clind_path_construct(var_reference);
+
+ }
+
+ return 0;
+
+ } else {
+
+ return -1;
+
+ }
+}
+
+/**********************************************************/
diff --git a/src/cli_objects.c b/src/cli_objects.c
new file mode 100644
index 0000000..9bb36f0
--- /dev/null
+++ b/src/cli_objects.c
@@ -0,0 +1,343 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <limits.h>
+#include <stdarg.h>
+#include "cli_val.h"
+#include "cli_parse.h"
+#include <regex.h>
+
+#include "cli_val_engine.h"
+
+#include "cli_objects.h"
+
+/************************ Storage area: *****************/
+
+static char *at_string=NULL;
+static boolean in_delete_action=FALSE;
+static valstruct cli_value;
+static boolean in_commit=FALSE; /* TRUE if in commit program*/
+static boolean in_exec=FALSE; /* TRUE if in exec */
+static boolean _is_echo=FALSE;
+static boolean _is_silent_msg=FALSE;
+static first_seg f_seg_a;
+static first_seg f_seg_c;
+static first_seg f_seg_m;
+static int in_cond_tik=0;
+
+/******************** Accessors: ************************/
+
+static char at_buffer[1024]={0};
+
+/* the string to use as $(@), must be set
+ before call to expand_string */
+char* get_at_string(void) {
+ if(at_string) {
+ return at_string;
+ } else {
+ return at_buffer;
+ }
+}
+
+void set_at_string(char* s) {
+ if(s!=at_buffer) {
+ at_string=s;
+ } else {
+ at_string=NULL;
+ }
+}
+
+void free_at_string(void) {
+ if(at_string) {
+ if(at_string!=at_buffer) free(at_string);
+ at_string=NULL;
+ }
+}
+
+boolean is_in_delete_action(void) {
+ return in_delete_action;
+}
+
+void set_in_delete_action(boolean b) {
+ in_delete_action=b;
+}
+
+boolean is_in_commit(void) {
+ return in_commit;
+}
+
+void set_in_commit(boolean b) {
+ in_commit=b;
+}
+
+boolean is_in_exec(void) {
+ return in_exec;
+}
+
+void set_in_exec(boolean b) {
+ in_exec=b;
+}
+
+boolean is_echo(void) {
+ return _is_echo;
+}
+
+void set_echo(boolean b) {
+ _is_echo=b;
+}
+
+boolean is_silent_msg(void) {
+ return _is_silent_msg;
+}
+
+void set_silent_msg(boolean b) {
+ _is_silent_msg=b;
+}
+
+valstruct* get_cli_value_ptr(void) {
+ return &cli_value;
+}
+
+first_seg* get_f_seg_a_ptr(void) {
+ return &f_seg_a;
+}
+
+first_seg* get_f_seg_c_ptr(void) {
+ return &f_seg_c;
+}
+
+first_seg* get_f_seg_m_ptr(void) {
+ return &f_seg_m;
+}
+
+int is_in_cond_tik(void) {
+ return in_cond_tik;
+}
+
+void set_in_cond_tik(int ict) {
+ in_cond_tik=ict;
+}
+
+void dec_in_cond_tik(void) {
+ --in_cond_tik;
+}
+
+const char* get_tdirp(void) {
+
+ const char* tdirp=getenv(ENV_T_DIR);
+
+ if (!tdirp)
+ tdirp = DEF_T_DIR;
+ if(!tdirp)
+ tdirp="";
+
+ return tdirp;
+}
+
+const char* get_cdirp(void) {
+ return getenv(ENV_C_DIR);
+}
+
+const char* get_adirp(void) {
+
+ const char* adirp=getenv(ENV_A_DIR);
+
+ if (!adirp)
+ adirp = DEF_A_DIR;
+ if(!adirp)
+ adirp="";
+
+ return adirp;
+}
+
+const char* get_mdirp(void) {
+
+ const char* mdirp=getenv(ENV_M_DIR);
+
+ if(!mdirp)
+ mdirp="";
+
+ return mdirp;
+}
+
+const char* get_tmpp(void) {
+
+ const char* tmpp=getenv(ENV_TMP_DIR);
+
+ if(!tmpp)
+ tmpp="";
+
+ return tmpp;
+}
+
+char* get_elevp(void) {
+
+ static char elevp_buffer[2049];
+ static char* elevp=NULL;
+
+ if(elevp==NULL) {
+
+ const char* tmp=getenv(ENV_EDIT_LEVEL);
+
+ if(tmp) {
+ strncpy(elevp_buffer,tmp,sizeof(elevp_buffer)-1);
+ elevp=elevp_buffer;
+ }
+ }
+
+ return elevp;
+}
+
+char* get_tlevp(void) {
+
+ static char tlevp_buffer[2049];
+ static char* tlevp=NULL;
+
+ if(tlevp==NULL) {
+
+ const char* tmp=getenv(ENV_TEMPLATE_LEVEL);
+
+ if(tmp) {
+ strncpy(tlevp_buffer,tmp,sizeof(tlevp_buffer)-1);
+ tlevp=tlevp_buffer;
+ }
+ }
+
+ return tlevp;
+}
+
+/************************* Init ***************************/
+
+void init_edit()
+{
+ int elevlen = 0;
+ int tlevlen = 0;
+
+ init_paths(TRUE);
+ if (!get_elevp())
+ bye("Not in configuration mode");
+ if (!get_tlevp())
+ bye("INTERNAL: environment var |%s| is not set",ENV_TEMPLATE_LEVEL);
+ elevlen = strlen(get_elevp());
+ tlevlen = strlen(get_tlevp());
+ if (elevlen > 0 && get_elevp()[elevlen - 1]=='/') {
+ /* cut off terminateing slash */
+ --elevlen;
+ get_elevp()[elevlen] = 0;
+ }
+ if (elevlen) {
+ char *slashp;
+ char * scanp;
+ if (*get_elevp()!='/')
+ INTERNAL;
+ scanp = get_elevp() + 1;
+ while (TRUE) {
+ slashp = strchr(scanp, '/');
+ if (slashp)
+ *slashp = 0;
+ push_path(&m_path, scanp);
+ if (slashp) {
+ *slashp = '/';
+ scanp = slashp+1;
+ }else
+ break;
+ }
+ }
+ switch_path(MPATH);
+ if (tlevlen > 0 && get_tlevp()[tlevlen - 1]=='/') {
+ /* cut off terminateing slash */
+ --tlevlen;
+ get_tlevp()[tlevlen] = 0;
+ }
+ if (tlevlen) {
+ char *slashp;
+ char * scanp;
+ if (*get_tlevp()!='/')
+ INTERNAL;
+ scanp = get_tlevp() + 1;
+ while (TRUE) {
+ slashp = strchr(scanp, '/');
+ if (slashp)
+ *slashp = 0;
+ push_path(&t_path, scanp);
+ if (slashp) {
+ *slashp = '/';
+ scanp = slashp+1;
+ }else
+ break;
+ }
+ }
+}
+
+void init_paths(boolean for_commit)
+{
+ struct stat statbuf;
+ const char* tdirp = get_tdirp();
+ const char* cdirp = get_cdirp();
+ const char* adirp = get_adirp();
+ const char* mdirp = get_mdirp();
+ const char* tmpp = get_tmpp();
+
+ if (!mdirp || !mdirp[0])
+ bye("Environment variable %s for temp configuration is not set",ENV_M_DIR);
+ if (!cdirp)
+ bye("INTERNAL: environment var |%s| is not set",
+ ENV_C_DIR);
+ if (!tmpp || !tmpp[0])
+ bye("INTERNAL: environment var |%s| is not set",
+ ENV_TMP_DIR);
+ /* make sure that template root is present */
+
+ if (lstat(tdirp, &statbuf) < 0)
+ bye("Template directory |%s| isn't present\n", tdirp);
+ if ((statbuf.st_mode & S_IFMT) != S_IFDIR)
+ bye("Template directory |%s| isn't a directory\n", tdirp);
+ /* set paths to current roots */
+ if (for_commit) {
+ int max_len;
+ const char *startp;
+
+ /* make sure that master configuration root is present */
+ if (lstat(adirp, &statbuf) < 0)
+ bye("Master configuration directory |%s| isn't present\n", adirp);
+ if ((statbuf.st_mode & S_IFMT) != S_IFDIR)
+ bye("Master configuration directory |%s| isn't a directory\n", adirp);
+
+ get_f_seg_a_ptr()->f_segp = adirp;
+ get_f_seg_c_ptr()->f_segp = cdirp;
+ get_f_seg_m_ptr()->f_segp = mdirp;
+ get_f_seg_a_ptr()->f_seglen = strlen(adirp);
+ get_f_seg_c_ptr()->f_seglen = strlen(cdirp);
+ get_f_seg_m_ptr()->f_seglen = strlen(mdirp);
+ if(get_f_seg_a_ptr()->f_seglen > get_f_seg_m_ptr()->f_seglen) {
+ max_len = get_f_seg_a_ptr()->f_seglen;
+ startp = adirp;
+ }else{
+ max_len = get_f_seg_m_ptr()->f_seglen;
+ startp = mdirp;
+ }
+ if(get_f_seg_c_ptr()->f_seglen > max_len) {
+ max_len = get_f_seg_c_ptr()->f_seglen;
+ startp = cdirp;
+ }
+ get_f_seg_a_ptr()->f_segoff = max_len - get_f_seg_a_ptr()->f_seglen;
+ get_f_seg_c_ptr()->f_segoff = max_len - get_f_seg_c_ptr()->f_seglen;
+ get_f_seg_m_ptr()->f_segoff = max_len - get_f_seg_m_ptr()->f_seglen;
+ init_path(&m_path, startp);
+ switch_path(get_f_seg_c_ptr());
+ m_path.print_offset = max_len;
+ }else
+ init_path(&m_path, mdirp);
+
+ init_path(&t_path, tdirp);
+}
+
+/**********************************************************/
diff --git a/src/cli_objects.h b/src/cli_objects.h
new file mode 100644
index 0000000..12b6b38
--- /dev/null
+++ b/src/cli_objects.h
@@ -0,0 +1,65 @@
+#ifndef CLI_OBJ_H
+#define CLI_OBJ_H
+
+#include "cli_val.h"
+
+#define APATH (get_f_seg_a_ptr())
+#define CPATH (get_f_seg_c_ptr())
+#define MPATH (get_f_seg_m_ptr())
+
+/* names of VYATTA env vars */
+#define ENV_EDIT_LEVEL "VYATTA_EDIT_LEVEL"
+#define ENV_TEMPLATE_LEVEL "VYATTA_TEMPLATE_LEVEL"
+#define ENV_A_DIR "VYATTA_ACTIVE_CONFIGURATION_DIR"
+#define ENV_C_DIR "VYATTA_CHANGES_ONLY_DIR"
+#define ENV_M_DIR "VYATTA_TEMP_CONFIG_DIR"
+#define ENV_T_DIR "VYATTA_CONFIG_TEMPLATE"
+#define ENV_TMP_DIR "VYATTA_CONFIG_TMP"
+#define DEF_A_DIR "/opt/vyatta/config/active"
+#define DEF_T_DIR "/opt/vyatta/share/ofr/template"
+#define ENV_OLD_PS1 "VYATTA_OLD_PS1"
+
+/* the string to use as $(@), must be set
+ before call to expand_string */
+char* get_at_string(void);
+void set_at_string(char* s);
+void free_at_string(void);
+
+boolean is_in_delete_action(void);
+void set_in_delete_action(boolean b);
+
+boolean is_in_commit(void);
+void set_in_commit(boolean b);
+
+boolean is_in_exec(void);
+void set_in_exec(boolean b);
+
+boolean is_echo(void);
+void set_echo(boolean b);
+
+boolean is_silent_msg(void);
+void set_silent_msg(boolean b);
+
+valstruct* get_cli_value_ptr(void);
+
+first_seg* get_f_seg_a_ptr(void);
+first_seg* get_f_seg_c_ptr(void);
+first_seg* get_f_seg_m_ptr(void);
+
+int is_in_cond_tik(void);
+void set_in_cond_tik(int ict);
+void dec_in_cond_tik(void);
+
+const char* get_tdirp(void);
+const char* get_cdirp(void);
+const char* get_adirp(void);
+const char* get_mdirp(void);
+const char* get_tmpp(void);
+
+char* get_elevp(void);
+char* get_tlevp(void);
+
+void init_edit(void);
+void init_paths(boolean for_commit);
+
+#endif /* CLI_OBJ_H */
diff --git a/src/cli_parse.y b/src/cli_parse.y
new file mode 100644
index 0000000..f0e43a8
--- /dev/null
+++ b/src/cli_parse.y
@@ -0,0 +1,206 @@
+%{
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "cli_val.h"
+
+extern int yy_cli_def_lineno;
+static vtw_def *parse_defp;
+static int parse_status;
+static boolean cli_def_type_only=0; /*{ if (cli_def_type_only) YYACCEPT;}*/
+/* XXX: sigh, the -p flag to yacc should do this for us kkkk*/
+#define yystacksize tpltstacksize
+#define yysslim tpltsslim
+
+/* forward prototypes */
+extern int yy_cli_parse_parse();
+extern int yy_cli_def_lex();
+extern void yy_cli_parse_error(const char *);
+static void cli_deferror(const char *);
+ extern FILE *yy_cli_def_in;
+#define YYDEBUG 1
+#define yy_cli_parse_lex yy_cli_def_lex
+%}
+%token EOL
+%token MULTI
+%token TAG
+%token TYPE
+%token HELP
+%token DEFAULT
+%token PATTERN
+%token EXEC
+%token SYNTAX
+%token COMMIT
+%token CHECK
+%left SEMI
+%token <val>VALUE
+%token <type>TYPE_DEF
+%token <strp>VAR
+%token <strp> STRING
+%token <strp> EX_STRING
+%token SYNTAX_ERROR
+%token <action>ACTION
+%left ASSIGN
+%left OR
+%left AND
+%right NOT
+%left COMMA
+%nonassoc <cond>COND
+%token RP
+%token LP
+%type <nodep> val
+%type <nodep> exp
+%type <val> val0
+%type <nodep> action
+%type <nodep> action0
+
+%union {
+ char *strp;
+ valstruct val;
+ vtw_type_e type;
+ vtw_cond_e cond;
+ vtw_node *nodep;
+ vtw_act_type action;
+}
+
+%%
+
+input: tag
+ | EOL input
+ | tag otherinput
+ ;
+
+otherinput: type EOL
+ | cause EOL
+ | otherinput type EOL
+ | otherinput cause EOL
+ | otherinput EOL
+ | syntax_error
+ ;
+
+tag: /* empty */
+ | TAG EOL {parse_defp->tag = TRUE;}
+ | MULTI EOL {parse_defp->multi = TRUE;}
+ ;
+
+type: TYPE TYPE_DEF SEMI STRING
+ { parse_defp->def_type = $2;
+ parse_defp->def_type_help = $4; }
+ ;
+
+
+type: TYPE TYPE_DEF
+ { parse_defp->def_type = $2;
+ }
+ ;
+
+cause: help_cause
+ | default_cause
+ | syntax_cause
+ | ACTION action { append(parse_defp->actions + $1, $2, 0);}
+ ;
+
+help_cause: HELP STRING
+ { parse_defp->def_type_help = $2; /* no semantics for now */
+ }
+
+default_cause: DEFAULT VALUE
+ {
+ if ($2.val_type != parse_defp->def_type)
+ yy_cli_parse_error((const char *)"Bad default\n");
+ parse_defp->def_default = $2.val;
+ }
+default_cause: DEFAULT STRING
+ {
+ if (TEXT_TYPE != parse_defp->def_type)
+ yy_cli_parse_error((const char *)"Bad default\n");
+ parse_defp->def_default = $2;
+ }
+
+syntax_cause: SYNTAX exp {append(parse_defp->actions + syntax_act, $2, 0);}
+ ;
+
+syntax_cause: COMMIT exp {append(parse_defp->actions + syntax_act, $2, 1);}
+ ;
+
+action0: STRING { $$ = make_node(EXEC_OP, make_str_node($1),NULL);}
+ ;
+action: action0
+ | action0 SEMI STRING
+ {$$ = make_node(HELP_OP, $1, make_str_node($3));}
+ | exp
+ ;
+exp: LP exp RP
+ {$$=$2;}
+ | exp AND exp {$$ = make_node(AND_OP,$1,$3);}
+ | exp OR exp {$$ = make_node(OR_OP,$1,$3);}
+ | val COND val
+ {$$ = make_node(COND_OP,$1,$3);$$->vtw_node_aux = $2;}
+ | PATTERN VAR STRING
+ { $$ = make_node(PATTERN_OP,make_var_node($2),
+ make_str_node($3));}
+ | EXEC STRING
+ { $$ = make_node(EXEC_OP,make_str_node($2),NULL);}
+ | NOT exp {$$ = make_node(NOT_OP,$2,NULL);}
+ | exp SEMI STRING
+ {$$ = make_node(HELP_OP, $1, make_str_node($3));}
+ | VAR ASSIGN val
+ {$$ = make_node(ASSIGN_OP, make_var_node($1), $3);}
+ ;
+
+val: VAR {$$ = make_var_node($1);}
+ | val0 {$$ = make_val_node(&($1));}
+ | EX_STRING {$$=make_str_node0($1, B_QUOTE_OP);}
+ ;
+
+val0: VALUE
+
+ | val0 COMMA val0 { add_val(&($1), &($3)); $$=$1; }
+
+ | STRING {$$ = str2val($1);}
+ ;
+
+syntax_error: SYNTAX_ERROR {
+ cli_deferror("syntax error");
+ }
+ ;
+
+
+%%
+char *parse_path;
+int parse_def(vtw_def *defp, char *path, boolean type_only)
+{
+ int status;
+ yy_cli_def_lineno = 1;
+ parse_status = 0;
+ parse_defp = defp;
+ cli_def_type_only = type_only;
+ yy_cli_def_in = fopen(path, "r");
+#if 0
+ yy_cli_parse_debug = 1;
+#endif
+ if (!yy_cli_def_in)
+ return -5;
+ parse_path = path;
+ status = yy_cli_parse_parse(); /* 0 is OK */
+ fclose(yy_cli_def_in);
+ return status;
+}
+static void
+cli_deferror(const char *s)
+{
+ printf("Error: %s in file %s, line %d\n",s, parse_path,
+ yy_cli_def_lineno);
+}
+
+void yy_cli_parse_error(const char *s)
+{
+ cli_deferror(s);
+}
+
+
+
+
+
diff --git a/src/cli_path_utils.c b/src/cli_path_utils.c
new file mode 100644
index 0000000..4045516
--- /dev/null
+++ b/src/cli_path_utils.c
@@ -0,0 +1,535 @@
+
+/************************************************************************
+
+ Module: cli
+
+ **** License ****
+ Version: VPL 1.0
+
+ The contents of this file are subject to the Vyatta Public License
+ Version 1.0 ("License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.vyatta.com/vpl
+
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and limitations
+ under the License.
+
+ This code was originally developed by Vyatta, Inc.
+ Portions created by Vyatta are Copyright (C) 2007 Vyatta, Inc.
+ All Rights Reserved.
+
+ Author: Oleg Moskalenko
+ Date: 2007
+ Description: "new" cli path-handling utilities
+
+ **** End License ****
+
+*************************************************************************/
+
+#if !defined(_GNU_SOURCE)
+#define _GNU_SOURCE
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <regex.h>
+#include <dirent.h>
+
+#include <string.h>
+
+#include "cli_path_utils.h"
+
+/*********************
+ * Data definitions
+ *
+ *********************/
+
+typedef char* clind_dir_name;
+
+/**
+ * Definition of the path structure to hold all path-like information:
+ */
+
+struct _clind_path_impl {
+
+ int absolute;
+ int path_len;
+ char* path_string;
+ clind_dir_name* path;
+
+};
+
+/******************************
+ * Path utils. We use them
+ * to manipulate the path-like
+ * structures.
+ *
+ ******************************/
+
+static void clind_reset_path_string(clind_path_impl* obj) {
+
+ char* newpath=NULL;
+
+ if(obj->path_len<1) {
+
+ newpath=strdup("");
+
+ } else {
+
+ int i=0;
+
+ if(!obj->absolute || (strlen(obj->path[0])>0 && ((char*)(obj->path[0]))[0]=='/')) {
+ newpath=strdup(obj->path[0]);
+ } else {
+ newpath=(char*)malloc(strlen(obj->path[0])+1+1);
+ newpath[0]='/';
+ strcpy(newpath+1,(char*)(obj->path[0]));
+ }
+
+ for(i=1;i<obj->path_len;i++) {
+ newpath=(char*)realloc(newpath,strlen(newpath)+1+strlen(obj->path[i])+1);
+ strcpy(newpath+strlen(newpath),"/");
+ strcpy(newpath+strlen(newpath),obj->path[i]);
+ }
+ }
+
+ if(obj->path_string==NULL) {
+ obj->path_string=newpath;
+ } else {
+ obj->path_string=(char*)realloc(obj->path_string,strlen(newpath)+1);
+ strcpy(obj->path_string,newpath);
+ free(newpath);
+ }
+}
+
+clind_path_ref clind_path_construct(const char* path) {
+
+ if(!path) return NULL;
+ else {
+
+ const char* delim="/ \t";
+
+ clind_path_impl *obj = (clind_path_impl*)malloc(sizeof(clind_path_impl));
+ char* tokpath=strdup(path);
+ char* token=strtok(tokpath,delim);
+
+ obj->path_len=0;
+ obj->path_string=strdup("");
+ obj->path=NULL;
+
+ while(token) {
+ clind_path_push((clind_path_ref)obj,token);
+ token=strtok(NULL,delim);
+ }
+
+ free(tokpath);
+
+ obj->absolute=(*path=='/');
+
+ clind_reset_path_string(obj);
+
+ return (clind_path_ref)obj;
+ }
+}
+
+void clind_path_destruct(clind_path_ref* path) {
+
+ if(path && *path) {
+
+ clind_path_impl* obj = (clind_path_impl*)(*path);
+
+ if(obj->path_string) {
+ free(obj->path_string);
+ obj->path_string=NULL;
+ }
+
+ if(obj->path) {
+ while(obj->path_len>0) {
+ char* dir_name = (char*)(obj->path[obj->path_len-1]);
+ if(dir_name) {
+ free(dir_name);
+ }
+ obj->path_len--;
+ }
+ free(obj->path);
+ obj->path=0;
+ }
+
+ *path=0;
+ }
+}
+
+clind_path_ref clind_path_clone(const clind_path_ref path) {
+
+ clind_path_ref ret=NULL;
+ if(path) {
+
+ clind_path_impl* obj = (clind_path_impl*)path;
+
+ ret = clind_path_construct(obj->path_string);
+
+ if(ret) {
+
+ ((clind_path_impl*)ret)->absolute=obj->absolute;
+
+ clind_reset_path_string((clind_path_impl*)ret);
+ }
+ }
+
+ return ret;
+}
+
+int clind_path_get_size(clind_path_ref path) {
+ if(path) {
+ clind_path_impl* obj = (clind_path_impl*)path;
+ return obj->path_len;
+ }
+ return 0;
+}
+
+const char* clind_path_get_path_string(clind_path_ref path) {
+ if(path) {
+ clind_path_impl* obj = (clind_path_impl*)path;
+ if(obj->path_string) {
+ return obj->path_string;
+ }
+ }
+ return "";
+}
+
+int clind_path_is_absolute(clind_path_ref path) {
+ if(path) {
+ clind_path_impl* obj = (clind_path_impl*)path;
+ return obj->absolute;
+ }
+ return 0;
+}
+
+void clind_path_push(clind_path_ref path,const char* dir) {
+
+ if(path && dir && *dir) {
+
+ clind_path_impl* obj = (clind_path_impl*)path;
+ int absolute=(*dir=='/');
+
+ while(*dir && *dir=='/') dir++;
+
+ if(obj->path_len<=0) {
+
+ obj->path_len=1;
+ obj->absolute=absolute;
+
+ if(obj->path) {
+ free(obj->path);
+ }
+
+ obj->path=(clind_dir_name*)malloc(sizeof(clind_dir_name));
+ obj->path[0]=(clind_dir_name)strdup(dir);
+
+ } else {
+
+ obj->path_len++;
+
+ obj->path=(clind_dir_name*)realloc(obj->path,
+ sizeof(clind_dir_name)*(obj->path_len));
+ obj->path[obj->path_len-1]=strdup(dir);
+ }
+
+ clind_reset_path_string(obj);
+ }
+}
+
+char* clind_path_pop_string(clind_path_ref path) {
+
+ char* ret=NULL;
+
+ if(path) {
+
+ clind_path_impl* obj = (clind_path_impl*)path;
+
+ if(obj->path_len<=0) {
+ return ret;
+ }
+
+ obj->path_len--;
+
+ if(obj->path) {
+ if(obj->path[obj->path_len]) {
+ ret = obj->path[obj->path_len];
+ obj->path[obj->path_len]=NULL;
+ }
+ }
+
+ if(obj->path_len<1) {
+ obj->absolute=0;
+ }
+
+ clind_reset_path_string(obj);
+ }
+
+ return ret;
+}
+
+int clind_path_pop(clind_path_ref path) {
+
+ int ret=-1;
+
+ char* ps = clind_path_pop_string(path);
+
+ if(ps) {
+ free(ps);
+ ret=0;
+ }
+
+ return ret;
+}
+
+const char* clind_path_last_string(clind_path_ref path) {
+
+ char* ret=NULL;
+
+ if(path) {
+ clind_path_impl* obj = (clind_path_impl*)path;
+ if(obj->path && obj->path_len>0) {
+ ret=obj->path[obj->path_len-1];
+ }
+ }
+
+ return ret;
+}
+
+void clind_path_unshift(clind_path_ref path,const char* dir) {
+
+ if(path && dir && *dir) {
+
+ clind_path_impl* obj = (clind_path_impl*)path;
+
+ int absolute=(*dir=='/');
+
+ while(*dir && *dir=='/') dir++;
+
+ if(obj->path_len<=0) {
+
+ clind_path_push(path,dir);
+
+ } else {
+
+ obj->path_len++;
+
+ obj->path=(clind_dir_name*)realloc(obj->path,
+ sizeof(clind_dir_name)*(obj->path_len));
+ memmove((char*)(obj->path)+sizeof(clind_dir_name),(char*)(obj->path),
+ sizeof(clind_dir_name)*(obj->path_len-1));
+ obj->path[0]=strdup(dir);
+
+ }
+
+ obj->absolute=absolute;
+
+ clind_reset_path_string(obj);
+ }
+}
+
+const char* clind_path_get_string(clind_path_ref path,int index) {
+
+ const char* ret=NULL;
+
+ if(path) {
+ clind_path_impl* obj = (clind_path_impl*)path;
+ if(obj->path && obj->path_len>index) {
+ ret=obj->path[index];
+ }
+ }
+
+ return ret;
+}
+
+const char* clind_path_first_string(clind_path_ref path) {
+ return clind_path_get_string(path,0);
+}
+
+char* clind_path_shift_string(clind_path_ref path) {
+
+ char* ret=NULL;
+
+ if(path) {
+
+ clind_path_impl* obj = (clind_path_impl*)path;
+
+ if(obj->path_len<=0) {
+ return ret;
+ }
+
+ obj->path_len--;
+
+ if(obj->path) {
+ if(obj->path[0]) {
+ ret = obj->path[0];
+ obj->path[0]=NULL;
+ }
+
+ memmove((char*)(obj->path),(char*)(obj->path)+sizeof(clind_dir_name),
+ sizeof(clind_dir_name)*obj->path_len);
+ }
+
+ obj->absolute=0;
+
+ clind_reset_path_string(obj);
+ }
+
+ return ret;
+}
+
+int clind_path_shift(clind_path_ref path) {
+
+ int ret=-1;
+
+ char* ps = clind_path_shift_string(path);
+
+ if(ps) {
+ free(ps);
+ ret=0;
+ }
+
+ return ret;
+}
+
+void clind_path_debug_print(clind_path_ref path) {
+
+ if(path) {
+
+ int i=0;
+ clind_path_impl* obj = (clind_path_impl*)path;
+
+ if(obj->path_string) {
+ printf("obj->path_string=%s, obj->path_len=%d,obj->absolute=%d\n",
+ obj->path_string,obj->path_len,obj->absolute);
+ } else {
+ printf("obj->path_string=NULL, obj->path_len=%d,obj->absolute=%d\n",
+ obj->path_len,obj->absolute);
+ }
+
+ if(obj->path) {
+ for(i=0;i<obj->path_len;i++) {
+ if(obj->path[i]) {
+ printf(" obj->path[%d]=%s\n",i,obj->path[i]);
+ } else {
+ printf(" obj->path[%d]=NULL\n",i);
+ }
+ }
+ } else {
+ printf(" obj->path=NULL\n");
+ }
+ }
+}
+
+int clind_file_exists(const char* dir,const char* file) {
+
+ int ret=0;
+
+ if(file) {
+
+ char* fname=strdup(file);
+ struct stat statbuf;
+
+ if(dir) {
+ free(fname);
+ fname=(char*)malloc(strlen(dir)+1+strlen(file)+1);
+ strcpy(fname,dir);
+ strcpy(fname+strlen(fname),"/");
+ strcpy(fname+strlen(fname),file);
+ }
+
+ if (lstat(fname, &statbuf) == 0) {
+ ret=1;
+ }
+
+ free(fname);
+ }
+
+ return ret;
+}
+
+char *clind_unescape(const char *name)
+{
+ const char *cp;
+ char *rcp, *ret;
+ char len;
+
+ for(cp=name, len=0;*cp;++cp, ++len)
+ if(*cp=='%')
+ cp +=2;
+ rcp = ret = malloc(len+1);
+ for(cp=name, len=0;*cp;++cp, ++rcp)
+ if(*cp=='%') {
+ ++cp;
+ if (*cp >='a' && *cp<='f')
+ *rcp = (*cp-'a'+10)*16;
+ else if (*cp >='A' && *cp<='F')
+ *rcp = (*cp-'A'+10)*16;
+ else if (*cp >='0' && *cp<='9')
+ *rcp = (*cp-'0')*16;
+ else {
+ printf("Bad escape in |%s|\n", name);
+ exit(-1);
+ }
+ ++cp;
+ if (*cp >='a' && *cp<='f')
+ *rcp += (*cp-'a'+10);
+ else if (*cp >='A' && *cp<='F')
+ *rcp += (*cp-'A'+10);
+ else if (*cp >='0' && *cp<='9')
+ *rcp += (*cp-'0');
+ else {
+ printf("Bad escape in |%s|\n", name);
+ exit(-1);
+ }
+ }else
+ *rcp = *cp;
+ *rcp = 0;
+ return ret;
+}
+
+char* clind_quote(const char* s) {
+
+ char* ret=NULL;
+ if(s) {
+ int i=0;
+ int len=strlen(s);
+ int sz=0;
+ char SQ='\'';
+
+ ret=(char*)malloc(1+5*len+1+1+10);
+ ret[sz++]=SQ;
+
+ for(i=0;i<len;i++) {
+ if(s[i]==SQ) {
+ ret[sz++]=SQ;/*'\''*/
+ ret[sz++]='\\';
+ ret[sz++]=SQ;
+ ret[sz++]=SQ;
+ } else {
+ ret[sz++]=s[i];
+ }
+ }
+
+ ret[sz++]=SQ;
+ ret[sz]=0;
+ }
+ return ret;
+}
+
+
diff --git a/src/cli_path_utils.h b/src/cli_path_utils.h
new file mode 100644
index 0000000..6cc3be8
--- /dev/null
+++ b/src/cli_path_utils.h
@@ -0,0 +1,72 @@
+
+/************************************************************************
+
+ Module: cli
+
+ **** License ****
+ Version: VPL 1.0
+
+ The contents of this file are subject to the Vyatta Public License
+ Version 1.0 ("License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.vyatta.com/vpl
+
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and limitations
+ under the License.
+
+ This code was originally developed by Vyatta, Inc.
+ Portions created by Vyatta are Copyright (C) 2007 Vyatta, Inc.
+ All Rights Reserved.
+
+ Author: Oleg Moskalenko
+ Date: 2007
+ Description: "new" cli path-handling utilities
+
+ **** End License ****
+
+*************************************************************************/
+
+#if !defined(__CLI_PATH_UTILS__)
+#define __CLI_PATH_UTILS__
+
+/*******************
+ * Type definitions
+ *
+ *******************/
+
+typedef struct _clind_path_impl clind_path_impl;
+typedef clind_path_impl* clind_path_ref;
+
+/************************
+ * Path utils
+ *
+ ************************/
+
+clind_path_ref clind_path_construct(const char* path);
+void clind_path_destruct(clind_path_ref* path);
+clind_path_ref clind_path_clone(const clind_path_ref path);
+
+int clind_path_get_size(clind_path_ref path);
+const char* clind_path_get_path_string(clind_path_ref path);
+void clind_path_debug_print(clind_path_ref path);
+int clind_path_is_absolute(clind_path_ref path);
+
+int clind_path_pop(clind_path_ref path);
+char* clind_path_pop_string(clind_path_ref path);
+const char* clind_path_last_string(clind_path_ref path);
+void clind_path_push(clind_path_ref path,const char* dir);
+
+int clind_path_shift(clind_path_ref path);
+char* clind_path_shift_string(clind_path_ref path);
+const char* clind_path_get_string(clind_path_ref path,int index);
+const char* clind_path_first_string(clind_path_ref path);
+void clind_path_unshift(clind_path_ref path,const char* dir);
+
+int clind_file_exists(const char* dir,const char* file);
+
+char *clind_unescape(const char *name);
+char* clind_quote(const char* s);
+
+#endif /* __CLI_PATH_UTILS__ */
diff --git a/src/cli_val.h b/src/cli_val.h
new file mode 100644
index 0000000..8a98a88
--- /dev/null
+++ b/src/cli_val.h
@@ -0,0 +1,206 @@
+#ifndef CLI_DEF_H
+#define CLI_DEF_H
+
+#define BITWISE 0 /* no partial commit */
+
+#define boolean int
+#define TRUE 1
+#define FALSE 0
+
+/* allocation unit for vals in valstruct */
+#define MULTI_ALLOC 5 /* we have room if cnt%MULTI_ALLOC != 0 */
+
+typedef enum {
+ do_del_mode,
+ del_mode,
+ create_mode,
+ update_mode
+}vtw_cmode;
+typedef enum {
+ ERROR_TYPE,
+ INT_TYPE,
+ IPV4_TYPE,
+ IPV4NET_TYPE,
+ IPV6_TYPE,
+ IPV6NET_TYPE,
+ MACADDR_TYPE,
+ DOMAIN_TYPE, /*end of addr types */
+ TEXT_TYPE,
+ BOOL_TYPE
+}vtw_type_e;
+
+typedef enum {
+ EQ_COND = 1,
+ NE_COND,
+ LT_COND,
+ LE_COND,
+ GT_COND,
+ GE_COND,
+ IN_COND,
+ TOP_COND
+}vtw_cond_e;
+/* IN_COND is like EQ for singular compare, but OR for multivalue right operand */
+
+typedef enum {
+ LIST_OP, /* right is next, left is list elem */
+ HELP_OP, /* right is help string, left is elem */
+ EXEC_OP, /* left command string, right help string */
+ PATTERN_OP, /* left to var, right to pattern */
+ OR_OP,
+ AND_OP,
+ NOT_OP,
+ COND_OP, /* aux field specifies cond type (GT, GE, etc.)*/
+ VAL_OP, /* for strings used in other nodes */
+ VAR_OP, /* string points to var */
+ B_QUOTE_OP, /* string points to operand to be executed */
+ ASSIGN_OP /* left to var, right to exp */
+}vtw_oper_e;
+
+typedef struct {
+ vtw_type_e val_type;
+ char *val;
+ int cnt; /* >0 means multivalue */
+ char **vals; /* We might union with val */
+ boolean free_me;
+}valstruct;
+
+typedef struct vtw_node{
+ vtw_oper_e vtw_node_oper;
+ struct vtw_node *vtw_node_left;
+ struct vtw_node *vtw_node_right;
+ char *vtw_node_string;
+ int vtw_node_aux;
+ vtw_type_e vtw_node_type;
+ valstruct vtw_node_val; /* we'll union it later */
+}vtw_node;
+
+typedef struct {
+ vtw_node *vtw_list_head;
+ vtw_node *vtw_list_tail;
+}vtw_list;
+
+typedef struct {
+ int t_lev;
+ int m_lev;
+}vtw_mark;
+
+typedef enum {
+ delete_act,
+ create_act,
+ activate_act,
+ update_act,
+ syntax_act,
+ commit_act,
+ begin_act,
+ end_act,
+ top_act
+}vtw_act_type;
+
+typedef struct {
+ vtw_type_e def_type;
+ char *def_type_help;
+ char *def_default;
+ boolean tag;
+ boolean multi;
+ vtw_list actions[top_act];
+}vtw_def;
+
+typedef struct {
+ const char *f_segp;
+ int f_seglen;
+ int f_segoff;
+} first_seg;
+/* the first segment might be ADIR, or CDIR, or MDIR
+ we reserve space large enough for any one.
+ If the shorter one is used, it right aligned.
+ path points to the start of the current first
+ segment
+*/
+typedef struct {
+ char *path_buf; /* path buffer */
+ char *path; /* path */
+ int path_len; /* path length used */
+ int path_alloc; /* allocated - 1*/
+ int *path_ends; /* path ends for dif levels*/
+ int path_lev; /* how many used */
+ int path_ends_alloc; /* how many allocated */
+ int print_offset; /* for additional optional output information */
+} vtw_path; /* vyatta tree walk */
+
+typedef struct {
+ int num;
+ int partnum;
+ void **ptrs;
+ unsigned int *parts;
+}vtw_sorted;
+
+extern int char2val(vtw_def *def, char *value, valstruct *valp);
+extern int get_value(char **valpp, vtw_path *pathp);
+extern int get_value_to_at_string(vtw_path *pathp);
+extern vtw_node * make_node(vtw_oper_e oper, vtw_node *left,
+ vtw_node *right);
+extern vtw_node *make_str_node(char *str);
+extern vtw_node *make_var_node(char *str);
+extern vtw_node *make_str_node0(char *str, vtw_oper_e op);
+extern void append(vtw_list *l, vtw_node *n, int aux);
+extern int parse_def(vtw_def *defp, char *path, boolean type_only);
+
+extern int yy_cli_val_lex(void);
+extern void cli_val_start(char *s);
+extern void cli_val_done(void);
+extern void init_path(vtw_path *path, const char *root);
+extern void pop_path(vtw_path *path);
+extern void push_path(vtw_path *path, char *segm);
+extern void free_def(vtw_def *defp);
+extern void free_sorted(vtw_sorted *sortp);
+extern void *my_malloc(size_t size, const char *name);
+extern void *my_realloc(void *ptr, size_t size, const char *name);
+
+extern vtw_path m_path, t_path;
+
+/*************************************************
+ GLOBAL FUNCTIONS
+***************************************************/
+extern void add_val(valstruct *first, valstruct *second);
+extern int cli_val_read(char *buf, int max_size);
+extern vtw_node *make_val_node(valstruct *val);
+extern char *my_strdup(const char *s, const char *name);
+extern valstruct str2val(char *cp);
+extern void dump_tree(vtw_node *node, int lev);
+extern void dump_def(vtw_def *defp);
+extern boolean val_cmp(valstruct *left, valstruct *right, vtw_cond_e cond);
+extern void out_of_memory(void);
+extern boolean validate_value(vtw_def *def,
+ char *value);
+extern void internal_error(int line, char *file);
+extern void done(void);
+extern void del_value(vtw_def *defp, char *cp);
+extern void bye(char *msg, ...);
+extern void print_msg(char *msg, ...);
+extern void switch_path(first_seg *seg);
+extern void vtw_sort(valstruct *valp, vtw_sorted *sortp);
+extern void free_val(valstruct *val);
+extern void my_free(void *ptr);
+extern void touch(void);
+extern void dump_log(int argc, char **argv);
+extern char *type_to_name(vtw_type_e type);
+extern boolean execute_list(vtw_node *cur, vtw_def *def);
+extern void touch_dir(const char *dp);
+
+void mark_paths(vtw_mark *markp);
+void restore_paths(vtw_mark *markp);
+
+extern boolean get_config_lock(const char* adirp, const char* lock_name);
+
+#define VTWERR_BADPATH -2
+#define VTWERR_OK 0
+#define TAG_NAME "node.tag"
+#define DEF_NAME "node.def"
+#define VAL_NAME "node.val"
+#define MOD_NAME ".modified"
+#define OPQ_NAME ".wh.__dir_opaque"
+#define LOCK_NAME ".commit.lck"
+
+#define INTERNAL internal_error(__LINE__, __FILE__)
+
+#endif
diff --git a/src/cli_val.l b/src/cli_val.l
new file mode 100644
index 0000000..5856cea
--- /dev/null
+++ b/src/cli_val.l
@@ -0,0 +1,293 @@
+%{
+#include "cli_val.h"
+#include "cli_parse.h"
+#include "cli_objects.h"
+static void make_val_value(vtw_type_e type);
+#define YY_INPUT(buf,result,max_size) (result)=cli_val_read((buf), (max_size))
+%}
+%option noyywrap
+%option nounput
+%option never-interactive
+
+/*
+ * Regular expressions of IP and MAC addresses, URLs, etc.
+ */
+
+/*
+ * IPv4 address representation.
+ */
+RE_IPV4_BYTE 25[0-5]|2[0-4][0-9]|[01][0-9][0-9]|([0-9]{1,2})
+RE_IPV4 {RE_IPV4_BYTE}(\.{RE_IPV4_BYTE}){3}
+RE_IPV4_PREFIXLEN (3[012]|[12][0-9]|[0-9])
+RE_IPV4NET {RE_IPV4}"/"{RE_IPV4_PREFIXLEN}
+
+/*
+ * IPv6 address representation in Augmented Backus-Naur Form (ABNF)
+ * as defined in RFC-2234.
+ * IPv6 address representation taken from RFC-3986:
+ *
+ * IPv6address = 6( h16 ":" ) ls32
+ * / "::" 5( h16 ":" ) ls32
+ * / [ h16 ] "::" 4( h16 ":" ) ls32
+ * / [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
+ * / [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
+ * / [ *3( h16 ":" ) h16 ] "::" h16 ":" ls32
+ * / [ *4( h16 ":" ) h16 ] "::" ls32
+ * / [ *5( h16 ":" ) h16 ] "::" h16
+ * / [ *6( h16 ":" ) h16 ] "::"
+ *
+ * h16 = 1*4HEXDIG
+ * ls32 = ( h16 ":" h16 ) / IPv4address
+ * IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet
+ * dec-octet = DIGIT ; 0-9
+ * / %x31-39 DIGIT ; 10-99
+ * / "1" 2DIGIT ; 100-199
+ * / "2" %x30-34 DIGIT ; 200-249
+ * / "25" %x30-35 ; 250-255
+ */
+
+RE_H16 [a-fA-F0-9]{1,4}
+RE_H16_COLON {RE_H16}":"
+RE_LS32 (({RE_H16}":"{RE_H16})|{RE_IPV4})
+RE_IPV6_P1 {RE_H16_COLON}{6}{RE_LS32}
+RE_IPV6_P2 "::"{RE_H16_COLON}{5}{RE_LS32}
+RE_IPV6_P3 ({RE_H16})?"::"{RE_H16_COLON}{4}{RE_LS32}
+RE_IPV6_P4 ({RE_H16_COLON}{0,1}{RE_H16})?"::"{RE_H16_COLON}{3}{RE_LS32}
+RE_IPV6_P5 ({RE_H16_COLON}{0,2}{RE_H16})?"::"{RE_H16_COLON}{2}{RE_LS32}
+RE_IPV6_P6 ({RE_H16_COLON}{0,3}{RE_H16})?"::"{RE_H16_COLON}{1}{RE_LS32}
+RE_IPV6_P7 ({RE_H16_COLON}{0,4}{RE_H16})?"::"{RE_LS32}
+RE_IPV6_P8 ({RE_H16_COLON}{0,5}{RE_H16})?"::"{RE_H16}
+RE_IPV6_P9 ({RE_H16_COLON}{0,6}{RE_H16})?"::"
+RE_IPV6 {RE_IPV6_P1}|{RE_IPV6_P2}|{RE_IPV6_P3}|{RE_IPV6_P4}|{RE_IPV6_P5}|{RE_IPV6_P6}|{RE_IPV6_P7}|{RE_IPV6_P8}|{RE_IPV6_P9}
+RE_IPV6_PREFIXLEN 12[0-8]|1[01][0-9]|[0-9][0-9]?
+RE_IPV6NET {RE_IPV6}"/"{RE_IPV6_PREFIXLEN}
+
+/*
+ * Ethernet MAC address representation.
+ */
+RE_MACADDR [a-fA-F0-9]{1,2}(:[a-fA-F0-9]{1,2}){5}
+
+/*
+ * URL-related regular expressions.
+ *
+ * Implementation is based on the BNF-like specification from:
+ * - RFC-1738: HTTP, FTP, FILE
+ * - RFC-3617: TFTP
+ * - RFC-3986: update of RFC-1738
+ */
+RE_URL {RE_URL_FILE}|{RE_URL_FTP}|{RE_URL_HTTP}|{RE_URL_TFTP}
+
+/*
+ * URL schemeparts for IP based protocols.
+ * Representation taken from RFC-1738, and some of it is updated by RFC-3986.
+ *
+ * login = [ user [ ":" password ] "@" ] hostport
+ * hostport = host [ ":" port ]
+ * host = hostname | hostnumber
+ * hostname = *[ domainlabel "." ] toplabel
+ * domainlabel = alphadigit | alphadigit *[ alphadigit | "-" ] alphadigit
+ * toplabel = alpha | alpha *[ alphadigit | "-" ] alphadigit
+ * alphadigit = alpha | digit
+ * hostnumber = digits "." digits "." digits "." digits
+ * port = digits
+ * user = *[ uchar | ";" | "?" | "&" | "=" ]
+ * password = *[ uchar | ";" | "?" | "&" | "=" ]
+ */
+RE_URL_LOGIN ({RE_URL_USER}(":"{RE_URL_PASSWORD})?"@")?{RE_URL_HOSTPORT}
+RE_URL_HOSTPORT {RE_URL_HOST}(":"{RE_URL_PORT})?
+RE_URL_HOST {RE_URL_HOSTNAME}|{RE_IPV4}|{RE_URL_IP_LITERAL}
+RE_URL_IP_LITERAL "["({RE_IPV6}|{RE_URL_IPV_FUTURE})"]"
+RE_URL_IPV_FUTURE "v"({RE_URL_HEXDIG})+"."({RE_URL_UNRESERVED}|{RE_URL_SUBDELIMS}|":")+
+RE_URL_HOSTNAME ({RE_URL_DOMAINLABEL}".")*{RE_URL_TOPLABEL}
+RE_URL_DOMAINLABEL {RE_URL_ALPHADIGIT}|{RE_URL_ALPHADIGIT}({RE_URL_ALPHADIGIT}|"-")*{RE_URL_ALPHADIGIT}
+RE_URL_TOPLABEL {RE_URL_ALPHA}|{RE_URL_ALPHA}({RE_URL_ALPHADIGIT}|"-")*{RE_URL_ALPHADIGIT}
+RE_URL_ALPHADIGIT {RE_URL_ALPHA}|{RE_URL_DIGIT}
+RE_URL_HOSTNUMBER {RE_URL_DIGITS}"."{RE_URL_DIGITS}"."{RE_URL_DIGITS}"."{RE_URL_DIGITS}
+RE_URL_PORT {RE_URL_DIGITS}
+RE_URL_USER ({RE_URL_UCHAR}|";"|"?"|"&"|"=")*
+RE_URL_PASSWORD ({RE_URL_UCHAR}|";"|"?"|"&"|"=")*
+
+/*
+ * FILE URL regular expression.
+ * Representation taken from RFC-1738.
+ *
+ * fileurl = "file://" [ host | "localhost" ] "/" fpath
+ */
+RE_URL_FILE "file://"({RE_URL_HOST}|"localhost")?"/"{RE_URL_FPATH}
+
+/*
+ * FTP URL regular expression.
+ * Representation taken from RFC-1738.
+ *
+ * ftpurl = "ftp://" login [ "/" fpath [ ";type=" ftptype ] ]
+ * fpath = fsegment *[ "/" fsegment ]
+ * fsegment = *[ uchar | "?" | ":" | "@" | "&" | "=" ]
+ * ftptype = "A" | "I" | "D" | "a" | "i" | "d"
+ */
+RE_URL_FTP "ftp://"{RE_URL_LOGIN}("/"{RE_URL_FPATH}(";type="{RE_URL_FTPTYPE})?)?
+RE_URL_FPATH {RE_URL_FSEGMENT}("/"{RE_URL_FSEGMENT})*
+RE_URL_FSEGMENT ({RE_URL_UCHAR}|"?"|":"|"@"|"&"|"=")*
+RE_URL_FTPTYPE "A"|"I"|"D"|"a"|"i"|"d"
+
+/*
+ * HTTP URL regular expression.
+ * Representation taken from RFC-1738.
+ *
+ * httpurl = "http://" hostport [ "/" hpath [ "?" search ] ]
+ * hpath = hsegment *[ "/" hsegment ]
+ * hsegment = *[ uchar | ";" | ":" | "@" | "&" | "=" ]
+ * search = *[ uchar | ";" | ":" | "@" | "&" | "=" ]
+ */
+RE_URL_HTTP "http://"{RE_URL_HOSTPORT}("/"{RE_URL_HPATH}("?"{RE_URL_SEARCH})?)?
+RE_URL_HPATH {RE_URL_HSEGMENT}("/"{RE_URL_HSEGMENT})*
+RE_URL_HSEGMENT ({RE_URL_UCHAR}|";"|":"|"@"|"&"|"=")*
+RE_URL_SEARCH ({RE_URL_UCHAR}|";"|":"|"@"|"&"|"=")*
+
+/*
+ * TFTP URL regular expression.
+ * Representation taken from RFC-3617.
+ *
+ * tftpURI = "tftp://" host "/" file [ mode ]
+ * mode = ";" "mode=" ( "netascii" / "octet" )
+ * file = *( unreserved / escaped )
+ * host = <as specified by RFC 2732 [3]>
+ * unreserved = <as specified in RFC 2396 [4]>
+ * escaped = <as specified in RFC 2396>
+ */
+RE_URL_TFTP "tftp://"{RE_URL_HOST}"/"{RE_URL_TFTP_FILE}({RE_URL_TFTP_MODE})?
+RE_URL_TFTP_MODE ";""mode="("netascii"|"octet")
+RE_URL_TFTP_FILE ({RE_URL_UNRESERVED}|{RE_URL_ESCAPE})*
+
+/*
+ * URL-related miscellaneous definitions.
+ * Representation taken from RFC-1738 and from RFC-3986.
+ *
+ * lowalpha = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" |
+ * "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" |
+ * "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" |
+ * "y" | "z"
+ * hialpha = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" |
+ * "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" |
+ * "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z"
+ * alpha = lowalpha | hialpha
+ * digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" |
+ * "8" | "9"
+ * safe = "$" | "-" | "_" | "." | "+"
+ * extra = "!" | "*" | "'" | "(" | ")" | ","
+ * national = "{" | "}" | "|" | "\" | "^" | "~" | "[" | "]" | "`"
+ * punctuation = "<" | ">" | "#" | "%" | <">
+ *
+ *
+ * reserved = ";" | "/" | "?" | ":" | "@" | "&" | "="
+ * hex = digit | "A" | "B" | "C" | "D" | "E" | "F" |
+ * "a" | "b" | "c" | "d" | "e" | "f"
+ * escape = "%" hex hex
+ *
+ * unreserved = alpha | digit | safe | extra
+ * uchar = unreserved | escape
+ * xchar = unreserved | reserved | escape
+ * digits = 1*digit
+ *
+ * sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
+ * / "*" / "+" / "," / ";" / "="
+ */
+RE_URL_LOWALPHA [a-z]
+RE_URL_HIALPHA [A-Z]
+RE_URL_ALPHA {RE_URL_LOWALPHA}|{RE_URL_HIALPHA}
+RE_URL_DIGIT [0-9]
+RE_URL_SAFE "$"|"-"|"_"|"."|"+"
+RE_URL_EXTRA "!"|"*"|"'"|"("|")"|","
+RE_URL_NATIONAL "{"|"}"|"|"|"\"|"^"|"~"|"["|"]"|"`"
+RE_URL_PUNCTUATION "<"|">"|"#"|"%"|<">
+RE_URL_RESERVED ";"|"/"|"?"|":"|"@"|"&"|"="
+RE_URL_HEXDIG {RE_URL_DIGIT}|[A-F]|[a-f]
+RE_URL_ESCAPE "%"{RE_URL_HEXDIG}{RE_URL_HEXDIG}
+RE_URL_UNRESERVED {RE_URL_ALPHA}|{RE_URL_DIGIT}|{RE_URL_SAFE}|{RE_URL_EXTRA}
+RE_URL_UCHAR {RE_URL_UNRESERVED}|{RE_URL_ESCAPE}
+RE_URL_XCHAR {RE_URL_UNRESERVED}|{RE_URL_RESERVED}|{RE_URL_ESCAPE}
+RE_URL_DIGITS {RE_URL_DIGIT}{1,}
+RE_URL_SUBDELIMS "!"|"$"|"&"|"'"|"("|")"|"*"|"+"|","|";"|"="
+
+
+%%
+:: {
+ make_val_value(IPV6_TYPE);
+ return VALUE;
+ }
+
+true {
+ make_val_value(BOOL_TYPE);
+ return VALUE;
+ }
+
+false {
+ make_val_value(BOOL_TYPE);
+ return VALUE;
+ }
+
+[0-9]+ {
+ make_val_value(INT_TYPE);
+ return VALUE;
+ }
+
+{RE_IPV4} {
+ make_val_value(IPV4_TYPE);
+ return VALUE;
+ }
+
+{RE_IPV4NET} {
+ make_val_value(IPV4NET_TYPE);
+ return VALUE;
+ }
+
+{RE_IPV6} {
+ make_val_value(IPV6_TYPE);
+ return VALUE;
+ }
+
+{RE_IPV6NET} {
+ make_val_value(IPV6NET_TYPE);
+ return VALUE;
+ }
+
+{RE_MACADDR} {
+ make_val_value(MACADDR_TYPE);
+ return VALUE;
+ }
+
+\\\n /* whitespace */
+
+[ \t]+ /*whitespace */
+\n return EOL;
+. {
+ /* everything else is a syntax error */
+ return SYNTAX_ERROR;
+ }
+
+
+%%
+static void make_val_value(vtw_type_e type)
+{
+ memset(get_cli_value_ptr(), 0, sizeof(valstruct));
+ get_cli_value_ptr()->free_me = TRUE;
+ get_cli_value_ptr()->val = my_strdup(yytext, "cli_val.l");
+ get_cli_value_ptr()->val_type = type;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/cli_val_engine.c b/src/cli_val_engine.c
new file mode 100644
index 0000000..d597c68
--- /dev/null
+++ b/src/cli_val_engine.c
@@ -0,0 +1,881 @@
+
+/************************************************************************
+
+ Module: cli
+
+ **** License ****
+ Version: VPL 1.0
+
+ The contents of this file are subject to the Vyatta Public License
+ Version 1.0 ("License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.vyatta.com/vpl
+
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and limitations
+ under the License.
+
+ This code was originally developed by Vyatta, Inc.
+ Portions created by Vyatta are Copyright (C) 2007 Vyatta, Inc.
+ All Rights Reserved.
+
+ Author: Oleg Moskalenko
+ Date: 2007
+ Description: "new" cli handler for the reference variables
+
+ **** End License ****
+
+*************************************************************************/
+
+#if !defined(_GNU_SOURCE)
+#define _GNU_SOURCE
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <regex.h>
+#include <dirent.h>
+
+#include <string.h>
+
+#include "cli_val_engine.h"
+
+/*********************
+ * Data definitions
+ *
+ *********************/
+
+/**
+ * Special file names:
+ */
+#define VALUE_FILE ("node.val")
+#define NODE_TAG ("node.tag")
+#define NODE_DEF ("node.def")
+
+/**
+ * "Command" definition (element of a variable path):
+ */
+
+typedef struct {
+ clind_cmd_type cmd_type;
+ const char* text[10];
+} cmd_parse_definition;
+
+/**
+ * Structure to hold information about possible command entries:
+ */
+
+static cmd_parse_definition cmd_parse_definitions[] = {
+ { CLIND_CMD_PARENT_VALUE, {"..","@",NULL } },
+ { CLIND_CMD_NEIGHBOR, {"..","*",NULL } },
+ { CLIND_CMD_PARENT, {"..",NULL } },
+ { CLIND_CMD_PARENT, {".","..",NULL } },
+ { CLIND_CMD_CHILD, {".","*",NULL } },
+ { CLIND_CMD_VALUE, {".","@",NULL } },
+ { CLIND_CMD_SELF_NAME, {".",NULL } },
+ { CLIND_CMD_VALUE, {"@",NULL } },
+ { CLIND_CMD_MULTI_VALUE, {"@@",NULL } },
+ { CLIND_CMD_CHILD, {"*",NULL } },
+ { CLIND_CMD_UNKNOWN, {NULL} }
+};
+
+/************************
+ * Cmd utils forward declarations
+ *
+ ************************/
+
+static int clind_path_shift_cmd(clind_path_ref path,clind_cmd *cmd);
+
+/******************************
+ * Variable evaluation engine *
+ * *
+ ******************************/
+
+/**
+ * For a given config path, return the 'value' of the path.
+ * If the path ends with "node.val", then return the file content.
+ * If not, then return the last path element.
+ * If path is empty, or the file is empty, or the file does not exist,
+ * then return NULL.
+ * The user of this function is responsible for the memory deallocation.
+ */
+
+static char** clind_get_current_value(clind_path_ref cfg_path,
+ clind_path_ref tmpl_path,
+ int check_existence,
+ vtw_type_e *val_type,
+ const char* root_tmpl_path,
+ int return_value_file_name,
+ int multi_value,
+ int *ret_size) {
+
+ char** ret=NULL;
+ *ret_size=0;
+
+ if(val_type) *val_type=TEXT_TYPE;
+
+ if(cfg_path && (clind_path_get_size(cfg_path)>0)) {
+
+ clind_path_ref tmpl_path_clone = clind_path_clone(tmpl_path);
+
+ const char* cfg_path_string = clind_path_get_path_string(cfg_path);
+ const char* cfg_end = clind_path_last_string(cfg_path);
+ const char* tmpl_path_string = clind_path_get_path_string(tmpl_path_clone);
+ const char* tmpl_end = clind_path_last_string(tmpl_path_clone);
+
+ /*
+ printf("%s:111.111:%s:%s:%s:%s:%d\n",__FUNCTION__,
+ cfg_path_string,
+ cfg_end,
+ tmpl_path_string,
+ tmpl_end,
+ multi_value);
+ */
+
+ if(cfg_path_string && cfg_end) {
+
+ if(strcmp(cfg_end,VALUE_FILE)==0) {
+
+ /* Value reference: */
+
+ if(return_value_file_name) {
+
+ ret=(char**)realloc(ret,sizeof(char*)*1);
+ ret[0]=strdup(cfg_path_string);
+ *ret_size=1;
+
+ } else {
+
+ FILE* f = fopen(cfg_path_string,"r");
+ if(f) {
+ char buffer[8193];
+ if(multi_value) {
+ while(fgets(buffer, sizeof(buffer)-1,f)) {
+ int len=strlen(buffer);
+ while(len>0 && (buffer[len-1]==10 || buffer[len-1]==13)) {
+ buffer[len-1]=0;
+ len--;
+ }
+ if(len>0) {
+ ret=(char**)realloc(ret,sizeof(char*)*(*ret_size+1));
+ ret[*ret_size]=strdup(buffer);
+ *ret_size+=1;
+ }
+ }
+ } else {
+ int sz = fread(buffer, 1, sizeof(buffer)-1, f);
+ if(sz>0) {
+ int len=0;
+ buffer[sz]=0;
+ len=strlen(buffer);
+ while(len>0 && (buffer[len-1]==10 || buffer[len-1]==13)) {
+ buffer[len-1]=0;
+ len--;
+ }
+ ret=(char**)malloc(sizeof(char*)*1);
+ ret[0]=strdup(buffer);
+ *ret_size=1;
+ }
+ }
+ fclose(f);
+ }
+ }
+
+ } else if(return_value_file_name) {
+
+ ret=(char**)realloc(ret,sizeof(char*)*1);
+ ret[0]=(char*)malloc(strlen(cfg_path_string)+1+strlen(VALUE_FILE)+1);
+ strcpy(ret[0],cfg_path_string);
+ strcpy(ret[0]+strlen(ret[0]),"/");
+ strcpy(ret[0]+strlen(ret[0]),VALUE_FILE);
+ *ret_size=1;
+
+ } else {
+
+ struct stat statbuf;
+
+ /* Directory reference: */
+
+ if(!check_existence || (lstat(cfg_path_string, &statbuf) == 0)) {
+ ret=(char**)realloc(ret,sizeof(char*)*1);
+ ret[0]=clind_unescape(cfg_end);
+ *ret_size=1;
+ }
+ }
+
+ if(ret) {
+ if(tmpl_end && (strcmp(tmpl_end,NODE_TAG)==0)) {
+ clind_path_pop(tmpl_path_clone);
+ tmpl_path_string = clind_path_get_path_string(tmpl_path_clone);
+ tmpl_end = clind_path_last_string(tmpl_path_clone);
+ }
+ }
+
+ if(ret && tmpl_path_string && !return_value_file_name) {
+
+ vtw_def def;
+ struct stat statbuf;
+ int fn_node_def_size=strlen(tmpl_path_string)+1+strlen(NODE_DEF)+1;
+ char* fn_node_def=(char*)malloc(fn_node_def_size);
+
+ memset(&def, 0, sizeof(def));
+
+ fn_node_def[0]=0;
+
+ if(*tmpl_path_string!='/' && root_tmpl_path) {
+ fn_node_def_size+=strlen(root_tmpl_path+1);
+ fn_node_def=(char*)realloc(fn_node_def,fn_node_def_size);
+ strcpy(fn_node_def+strlen(fn_node_def),root_tmpl_path);
+ strcpy(fn_node_def+strlen(fn_node_def),"/");
+ }
+
+ strcpy(fn_node_def+strlen(fn_node_def),tmpl_path_string);
+ strcpy(fn_node_def+strlen(fn_node_def),"/");
+ strcpy(fn_node_def+strlen(fn_node_def),NODE_DEF);
+
+ if ((lstat(fn_node_def, &statbuf) == 0)&&
+ (parse_def(&def, fn_node_def, TRUE)==0)) {
+
+ if(def.def_type != ERROR_TYPE) {
+
+ int status=0;
+ valstruct res;
+ int i=0;
+
+ memset(&res,0,sizeof(res));
+
+ for(i=0;i<*ret_size;i++) {
+
+ if(ret[i]) {
+
+ /* return the value in the correct type */
+ status = char2val(&def, ret[i], &res);
+
+ if(status==0) {
+
+ if(val_type) *val_type=res.val_type;
+
+ if(res.free_me && res.val) {
+ free(ret[i]);
+ ret[i]=res.val;
+ }
+ } else {
+ /* Bad value ? */
+ }
+ }
+ }
+ }
+
+ } else {
+
+ while(*ret_size>0) {
+ if(ret[*ret_size-1]) {
+ free(ret[*ret_size-1]);
+ }
+ *ret_size-=1;
+ }
+ free(ret);
+ ret=NULL;
+
+ }
+
+ free(fn_node_def);
+ }
+ }
+
+ clind_path_destruct(&tmpl_path_clone);
+ }
+
+ return ret;
+}
+
+/**
+ * Return TRUE if current node is a multi-node value
+ */
+static int is_multi_node(clind_path_ref tmpl_path) {
+
+ int ret=0;
+
+ if(tmpl_path) {
+
+ const char* t_end = clind_path_last_string(tmpl_path);
+
+ if(t_end && (strcmp(t_end,NODE_TAG)==0)) {
+ ret=1;
+ }
+ }
+
+ return ret;
+}
+
+/**
+ * Return TRUE if current node is node.def
+ */
+static int is_node_def(clind_path_ref tmpl_path) {
+
+ int ret=0;
+
+ if(tmpl_path) {
+
+ const char* t_end = clind_path_last_string(tmpl_path);
+
+ if(t_end && (strcmp(t_end,NODE_DEF)==0)) {
+ ret=1;
+ }
+ }
+
+ return ret;
+}
+
+/**
+ * Apply a single command to the configuration path.
+ * cfg_path - absolute configuration path,
+ * tmpl_path - logical template path,
+ * cmd - single reference command from the variable path.
+ * The result is the array of "derived" paths.
+ * result_len output parameter contains the array size.
+ */
+
+static clind_path_ref* clind_config_engine_apply_command(clind_path_ref cfg_path,
+ clind_path_ref tmpl_path,
+ clind_cmd *cmd,
+ int *result_len) {
+ clind_path_ref* ret=NULL;
+
+ if(cfg_path && tmpl_path && result_len && cmd) {
+
+ /*
+ printf("%s:111.111:%s:%s:%d\n",__FUNCTION__,
+ clind_path_get_path_string(cfg_path),
+ clind_path_get_path_string(tmpl_path),
+ cmd->type);
+ */
+
+ switch (cmd->type) {
+
+ case CLIND_CMD_PARENT:
+
+ {
+ *result_len=1;
+ ret=(clind_path_ref*)(malloc(*result_len * sizeof(clind_path_ref)));
+ cfg_path = clind_path_clone(cfg_path);
+ ret[0]=cfg_path;
+
+ if(is_multi_node(tmpl_path)) {
+ clind_path_pop(cfg_path);
+ clind_path_pop(tmpl_path);
+ } else if(is_node_def(tmpl_path)) {
+ clind_path_pop(tmpl_path);
+ }
+
+ clind_path_pop(cfg_path);
+ clind_path_pop(tmpl_path);
+
+ if(is_multi_node(tmpl_path)) {
+ clind_path_pop(cfg_path);
+ clind_path_pop(tmpl_path);
+ }
+ }
+
+ break;
+
+ case CLIND_CMD_SELF_NAME:
+
+ {
+ *result_len=1;
+ ret=(clind_path_ref*)(malloc(*result_len * sizeof(clind_path_ref)));
+ cfg_path = clind_path_clone(cfg_path);
+ ret[0]=cfg_path;
+
+ if(is_multi_node(tmpl_path)) {
+ clind_path_pop(cfg_path);
+ clind_path_pop(tmpl_path);
+ } else if(is_node_def(tmpl_path)) {
+ clind_path_pop(tmpl_path);
+ }
+ }
+
+ break;
+
+ case CLIND_CMD_CHILD:
+
+ {
+ *result_len=1;
+ ret=(clind_path_ref*)(malloc(*result_len * sizeof(clind_path_ref)));
+ cfg_path = clind_path_clone(cfg_path);
+ ret[0]=cfg_path;
+
+ clind_path_push(cfg_path,cmd->value);
+ clind_path_push(tmpl_path,cmd->value);
+ }
+ break;
+
+ case CLIND_CMD_NEIGHBOR:
+
+ {
+ *result_len=1;
+ ret=(clind_path_ref*)(malloc(*result_len * sizeof(clind_path_ref)));
+ cfg_path = clind_path_clone(cfg_path);
+ ret[0]=cfg_path;
+
+ if(is_multi_node(tmpl_path)) {
+ clind_path_pop(cfg_path);
+ clind_path_pop(tmpl_path);
+ } else if(is_node_def(tmpl_path)) {
+ clind_path_pop(tmpl_path);
+ }
+
+ clind_path_pop(cfg_path);
+ clind_path_pop(tmpl_path);
+
+ clind_path_push(cfg_path,cmd->value);
+ clind_path_push(tmpl_path,cmd->value);
+ }
+
+ break;
+
+ case CLIND_CMD_VALUE:
+
+ {
+ const char* t_path_string = clind_path_get_path_string(tmpl_path);
+ const char* t_end = clind_path_last_string(tmpl_path);
+ const char* c_end = clind_path_last_string(cfg_path);
+
+ *result_len=1;
+ ret=(clind_path_ref*)(malloc(*result_len * sizeof(clind_path_ref)));
+ cfg_path = clind_path_clone(cfg_path);
+ ret[0]=cfg_path;
+
+ if(t_end && (strcmp(t_end,NODE_TAG)==0)) {
+ /* do nothing, we are there already */
+ } else if(t_path_string && clind_file_exists(t_path_string,NODE_TAG)) {
+ clind_path_push(tmpl_path,NODE_TAG);
+ } else if(c_end && (strcmp(c_end,VALUE_FILE)==0)) {
+ /* do nothing, we are there already */
+ } else {
+ clind_path_push(cfg_path,VALUE_FILE);
+ }
+ }
+
+ break;
+
+ case CLIND_CMD_PARENT_VALUE:
+
+ {
+ *result_len=1;
+ ret=(clind_path_ref*)(malloc(*result_len * sizeof(clind_path_ref)));
+ cfg_path = clind_path_clone(cfg_path);
+ ret[0]=cfg_path;
+
+ if(is_multi_node(tmpl_path)) {
+ clind_path_pop(cfg_path);
+ clind_path_pop(tmpl_path);
+ } else if(is_node_def(tmpl_path)) {
+ clind_path_pop(tmpl_path);
+ }
+
+ clind_path_pop(cfg_path);
+ clind_path_pop(tmpl_path);
+ }
+
+ break;
+
+ case CLIND_CMD_MULTI_VALUE:
+
+ {
+ const char* cfg_path_string = NULL;
+
+ if(is_multi_node(tmpl_path)) {
+ clind_path_pop(cfg_path);
+ clind_path_pop(tmpl_path);
+ } else if(is_node_def(tmpl_path)) {
+ clind_path_pop(tmpl_path);
+ }
+
+ cfg_path_string = clind_path_get_path_string(cfg_path);
+
+ if(cfg_path_string) {
+
+ const char* c_end = clind_path_last_string(cfg_path);
+
+ if(c_end && (strcmp(c_end,VALUE_FILE)==0)) {
+
+ *result_len=1;
+ ret=(clind_path_ref*)(malloc(*result_len * sizeof(clind_path_ref)));
+ cfg_path = clind_path_clone(cfg_path);
+ ret[0]=cfg_path;
+
+ } else if(clind_file_exists(cfg_path_string,VALUE_FILE)) {
+
+ *result_len=1;
+ ret=(clind_path_ref*)(malloc(*result_len * sizeof(clind_path_ref)));
+ cfg_path = clind_path_clone(cfg_path);
+ ret[0]=cfg_path;
+
+ clind_path_push(cfg_path,VALUE_FILE);
+
+ } else {
+
+ DIR* dir=NULL;
+
+ dir = opendir(cfg_path_string);
+
+ if(dir) {
+
+ *result_len=0;
+
+ ret=(clind_path_ref*)(malloc(*result_len * sizeof(clind_path_ref)));
+
+ do {
+ struct dirent *de = readdir(dir);
+
+ if(!de) break;
+ else if(de->d_name[0] && de->d_name[0]!='.') {
+ clind_path_ref cfg_path_1 = clind_path_clone(cfg_path);
+ clind_path_push(cfg_path_1,de->d_name);
+ (*result_len)++;
+ ret=(clind_path_ref*)(realloc(ret,*result_len * sizeof(clind_path_ref)));
+ ret[*result_len-1]=cfg_path_1;
+ }
+ } while(1);
+
+ clind_path_push(tmpl_path,NODE_TAG);
+
+ closedir(dir);
+ }
+ }
+ }
+ }
+ break;
+
+ default:
+ ;
+ }
+ }
+
+ return ret;
+}
+
+/**
+ * cfg_path - absolute configuration path,
+ * tmpl_path - logical template path,
+ * cmd_path - variable command path.
+ */
+
+int clind_config_engine_apply_command_path(clind_path_ref cfg_path_orig,
+ clind_path_ref tmpl_path_orig,
+ clind_path_ref cmd_path,
+ int check_existence,
+ clind_val* res,
+ const char* root_cfg_path,
+ const char* root_tmpl_path,
+ int return_value_file_name) {
+
+ int ret=-1;
+
+ /*
+ printf("%s:111.111:cfg_path=%s,tmpl_path=%s,cmd_path=%s,rtp=%s\n",__FUNCTION__,
+ clind_path_get_path_string(cfg_path_orig),
+ clind_path_get_path_string(tmpl_path_orig),
+ clind_path_get_path_string(cmd_path),
+ root_tmpl_path);
+ */
+
+ if(cfg_path_orig && tmpl_path_orig && cmd_path && res) {
+
+ /* Command to be processed: */
+ clind_cmd cmd;
+
+ /* Array of configuration pointers. Initially, contains only one
+ element - cfg_path. */
+ clind_path_ref* config_paths=
+ (clind_path_ref*)malloc(sizeof(clind_path_ref)*1);
+
+ /* Size of the array (initially - just one): */
+ int config_paths_size=1;
+
+ /* Clone the input paths to preserve the input objects intact: */
+ clind_path_ref tmpl_path=NULL;
+ clind_path_ref cfg_path=NULL;
+
+ if(clind_path_is_absolute(cmd_path)) {
+ tmpl_path=clind_path_construct(root_tmpl_path);
+ if(!tmpl_path) {
+ return -1;
+ }
+ cfg_path=clind_path_construct(root_cfg_path);
+ if(!cfg_path) {
+ return -1;
+ }
+ } else {
+ cfg_path=clind_path_clone(cfg_path_orig);
+ tmpl_path=clind_path_clone(tmpl_path_orig);
+ }
+
+ res->value=NULL;
+ res->val_type=TEXT_TYPE;
+
+ /* Set the initial array content: */
+ config_paths[0]=cfg_path;
+
+ /* Apply the commands one-by-one: */
+ while(clind_path_get_size(cmd_path)>0 &&
+ (clind_path_shift_cmd(cmd_path,&cmd)==0)) {
+
+ int i=0;
+
+ /* Temporary array to keep the config paths for the next
+ command application: */
+ clind_path_ref* new_config_paths=NULL;
+ int new_config_paths_size=0;
+
+ /* This path contains the template path at the beginning
+ of the cycle: */
+ clind_path_ref tmpl_path_curr=clind_path_clone(tmpl_path);
+
+ for (i=0;i<config_paths_size;i++) {
+
+ int size=0;
+
+ clind_path_ref* new_config_paths_1=NULL;
+
+ if(i==0) {
+ new_config_paths_1=
+ clind_config_engine_apply_command(config_paths[i],
+ tmpl_path,
+ &cmd,
+ &size);
+ } else {
+ clind_path_ref tmpl_path_curr_clone=clind_path_clone(tmpl_path_curr);
+ new_config_paths_1=
+ clind_config_engine_apply_command(config_paths[i],
+ tmpl_path_curr_clone,
+ &cmd,
+ &size);
+ clind_path_destruct(&tmpl_path_curr_clone);
+ }
+
+ if(new_config_paths_1) {
+
+ int j=0;
+
+ for(j=0;j<size;j++) {
+ if(new_config_paths_1[j]) {
+ new_config_paths_size++;
+ new_config_paths=
+ (clind_path_ref*)realloc(new_config_paths,
+ sizeof(clind_path_ref)*
+ new_config_paths_size);
+ new_config_paths[new_config_paths_size-1]=new_config_paths_1[j];
+ }
+ }
+
+ free(new_config_paths_1);
+ }
+
+ clind_path_destruct(&(config_paths[i]));
+ }
+
+ free(config_paths);
+ config_paths=new_config_paths;
+ config_paths_size=new_config_paths_size;
+ clind_path_destruct(&tmpl_path_curr);
+ }
+
+ if(config_paths) {
+
+ char** sarr=NULL;
+ int sarrlen=0;
+
+ vtw_type_e val_type=TEXT_TYPE;
+
+ int i=0;
+
+ for(i=0;i<config_paths_size;i++) {
+
+ if(config_paths[i]) {
+
+ int vallen=0;
+
+ char** valarr=clind_get_current_value(config_paths[i],
+ tmpl_path,
+ check_existence,
+ &val_type,
+ root_tmpl_path,
+ return_value_file_name,
+ /*Last command: */
+ (cmd.type==CLIND_CMD_MULTI_VALUE),
+ &vallen);
+
+ clind_path_destruct(&config_paths[i]);
+
+ if(valarr) {
+
+ int k=0;
+
+ for(k=0;k<vallen;k++) {
+
+ char* s=valarr[k];
+
+ if(s) {
+
+ /* search if we already have it: */
+ int j=0;
+ for(j=0;j<sarrlen;j++) {
+ if(!strcmp(sarr[j],s)) {
+ break;
+ }
+ }
+
+ if(j<sarrlen) {
+ free(s);
+ } else {
+ sarrlen++;
+ sarr=(char**)realloc(sarr,sizeof(char*)*sarrlen);
+ sarr[sarrlen-1]=s;
+ }
+ }
+ }
+ free(valarr);
+ }
+ }
+ }
+
+ free(config_paths);
+
+ if(sarr) {
+
+ ret=0;
+
+ if(sarrlen==1) {
+
+ res->value=sarr[0];
+
+ } else {
+
+ for(i=0;i<sarrlen;i++) {
+
+ if(sarr[i]) {
+
+ char* s = clind_quote(sarr[i]);
+
+ free(sarr[i]);
+ sarr[i]=NULL;
+
+ if(s) {
+
+ if(!res->value) {
+
+ res->value=s;
+
+ } else if(res->value[0]==0) {
+
+ free(res->value);
+ res->value=s;
+
+ } else {
+
+ res->value=(char*)realloc(res->value,
+ strlen(res->value)+1+strlen(s)+1);
+
+ strcpy(res->value+strlen(res->value)," ");
+ strcpy(res->value+strlen(res->value),s);
+
+ free(s);
+ }
+ }
+ }
+ }
+ }
+ free(sarr);
+ }
+ }
+
+ clind_path_destruct(&cmd_path);
+ clind_path_destruct(&cfg_path);
+ clind_path_destruct(&tmpl_path);
+ }
+
+ return ret;
+}
+
+/******************************
+ * Cmd utils.
+ *
+ ******************************/
+
+static int clind_path_shift_cmd(clind_path_ref path,clind_cmd *cmd) {
+
+ int ret=-1;
+
+ if(cmd) {
+
+ cmd->type = CLIND_CMD_UNKNOWN;
+ cmd->value[0]=0;
+
+ if(path && clind_path_get_size(path)>0) {
+
+ int i=0;
+ int done=0;
+
+ while(cmd_parse_definitions[i].text!=NULL && cmd_parse_definitions[i].text[0]!=NULL) {
+
+ int j=0;
+
+ while(cmd_parse_definitions[i].text[j]) {
+ const char* str = clind_path_get_string(path,j);
+ if(str) {
+ if(!strcmp(cmd_parse_definitions[i].text[j],"*")) {
+ if(*str!='.' && *str!='@') {
+ j++;
+ strncpy(cmd->value,str,sizeof(cmd->value)-1);
+ continue;
+ }
+ } else if(!strcmp(cmd_parse_definitions[i].text[j],str)) {
+ j++;
+ strncpy(cmd->value,str,sizeof(cmd->value)-1);
+ continue;
+ }
+ }
+ j=0;
+ break;
+ }
+
+ if(j<1) {
+ i++;
+ continue;
+ } else {
+ done=1;
+ }
+
+ cmd->type = cmd_parse_definitions[i].cmd_type;
+
+ while(j) {
+ clind_path_shift(path);
+ j--;
+ }
+
+ break;
+ }
+
+ if(done) {
+ ret=0;
+ }
+ }
+ }
+
+ return ret;
+}
+
diff --git a/src/cli_val_engine.h b/src/cli_val_engine.h
new file mode 100644
index 0000000..0f32276
--- /dev/null
+++ b/src/cli_val_engine.h
@@ -0,0 +1,86 @@
+
+/************************************************************************
+
+ Module: cli
+
+ **** License ****
+ Version: VPL 1.0
+
+ The contents of this file are subject to the Vyatta Public License
+ Version 1.0 ("License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.vyatta.com/vpl
+
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and limitations
+ under the License.
+
+ This code was originally developed by Vyatta, Inc.
+ Portions created by Vyatta are Copyright (C) 2007 Vyatta, Inc.
+ All Rights Reserved.
+
+ Author: Oleg Moskalenko
+ Date: 2007
+ Description: "new" cli handler for the reference variables
+
+ **** End License ****
+
+*************************************************************************/
+
+#if !defined(__CLI_VAL_ENGINE__)
+#define __CLI_VAL_ENGINE__
+
+#include "cli_path_utils.h"
+#include "cli_val.h"
+
+/*******************
+ * Type definitions
+ *
+ *******************/
+
+typedef enum {
+
+ CLIND_CMD_UNKNOWN=0, /* ??? */
+ CLIND_CMD_PARENT, /* .. */
+ CLIND_CMD_SELF_NAME, /* . */
+ CLIND_CMD_CHILD, /* <name> */
+ CLIND_CMD_NEIGHBOR, /* ../<name> */
+ CLIND_CMD_VALUE, /* @ */
+ CLIND_CMD_PARENT_VALUE, /* ../@ */
+ CLIND_CMD_MULTI_VALUE /* @@ */
+
+} clind_cmd_type;
+
+typedef struct {
+
+ clind_cmd_type type;
+ char value[1025];
+
+} clind_cmd;
+
+typedef struct {
+
+ vtw_type_e val_type;
+ char* value;
+
+} clind_val;
+
+/********************************
+ * Main command-handling method:
+ *
+ ********************************/
+
+int clind_config_engine_apply_command_path(clind_path_ref cfg_path,
+ clind_path_ref tmpl_path,
+ clind_path_ref cmd_path,
+ int check_existence,
+ clind_val *res,
+ const char* root_cfg_path,
+ const char* root_tmpl_path,
+ int return_value_file_name);
+
+
+
+
+#endif /* __CLI_VAL_ENGINE__*/
diff --git a/src/commit.c b/src/commit.c
new file mode 100644
index 0000000..a136b58
--- /dev/null
+++ b/src/commit.c
@@ -0,0 +1,1364 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <limits.h>
+
+#include "cli_val.h"
+#include "cli_objects.h"
+#include "cli_parse.h"
+#include "cli_path_utils.h"
+
+static char def_name[] = DEF_NAME;
+static char tag_name[] = TAG_NAME;
+static char opaque_name[] = OPQ_NAME;
+
+static int fin_commit(boolean ok);
+static boolean commit_value(vtw_def *defp, char *cp,
+ vtw_cmode mode, boolean in_txn);
+static void perform_create_node();
+static void perform_delete_node();
+static void perform_move();
+static boolean commit_delete_child(vtw_def *pdefp, char *child,
+ boolean deleting, boolean in_txn);
+static boolean commit_delete_children(vtw_def *defp, boolean deleting,
+ boolean in_txn);
+static boolean commit_update_children(vtw_def *defp, boolean creating,
+ boolean in_txn, boolean *parent_update);
+
+#if BITWISE
+static void make_dir()
+{
+ struct stat statbuf;
+ if (lstat(m_path.path, &statbuf) < 0) {
+ char *command;
+ command = my_malloc(strlen(m_path.path) + 10, "set");
+ sprintf(command, "mkdir -p %s", m_path.path);
+ system(command);
+ free(command);
+ return;
+ }
+ if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
+ bye("directory %s expected, found regular file", m_path.path);
+ }
+ return;
+}
+#endif
+
+/*************************************************
+ validate_dir_for_commit:
+ validate value.value if there is one, validate
+ subdirectries names (for tag directory, and for
+ regular directory);
+ validate subdirectories
+ returns TRUE if OK, FASLE if errors
+ exits with status != 0 in case of parse error
+*/
+static boolean validate_dir_for_commit()
+{
+ struct stat statbuf;
+ int status=0;
+ vtw_def def;
+ boolean def_present=FALSE;
+ boolean value_present=FALSE;
+ int subdirs_number=0;
+ DIR *dp=NULL;
+ struct dirent *dirp=NULL;
+ char *cp=NULL;
+ boolean ret=TRUE;
+ char *uename = NULL;
+
+#ifdef DEBUG
+ printf("validating directory (node_cnt %d, free_node_cnt %d)\n"
+ "t_path |%s|\n",
+ node_cnt, free_node_cnt, t_path.path);
+#endif
+
+ /* find definition */
+
+ push_path(&t_path, def_name); /* PUSH 1 */
+ if ((lstat(t_path.path, &statbuf) >= 0) &&
+ ((statbuf.st_mode & S_IFMT) == S_IFREG)) {
+ /* definition present */
+ def_present = TRUE;
+ memset(&def, 0, sizeof(def));
+#ifdef DEBUG1
+ printf("Parsing definition\n");
+#endif
+
+ if ((status = parse_def(&def, t_path.path,
+ FALSE))) {
+ exit(status);
+ }
+
+ }
+#ifdef DEBUG1
+ else
+ printf("No definition\n");
+#endif
+ pop_path(&t_path); /* for PUSH 1 */
+
+ /* look at modified stuff */
+ if ((dp = opendir(m_path.path)) == NULL){
+ INTERNAL;
+ }
+ if (def_present && def.tag) {
+ push_path(&t_path, tag_name); /* PUSH 2a */
+ }
+
+ while ((dirp = readdir(dp)) != NULL) {
+
+ if (strcmp(dirp->d_name, ".") == 0 ||
+ strcmp(dirp->d_name, "..") == 0 ||
+ strcmp(dirp->d_name, MOD_NAME) == 0 ||
+ strcmp(dirp->d_name, LOCK_NAME) == 0 ||
+ strcmp(dirp->d_name, opaque_name) == 0 ||
+ strncmp(dirp->d_name, ".wh.", 4) == 0) {
+ continue; /*ignore dot and dot-dot*/
+ }
+
+ subdirs_number++;
+
+ if(uename)
+ my_free(uename);
+
+ uename = clind_unescape(dirp->d_name);
+
+ if (strcmp(uename, VAL_NAME) == 0) {
+
+ value_present=TRUE;
+
+ /* deal with the value */
+ if (!def_present) {
+ printf("There is no definition specified in template\n"
+ "\t%s\n\t - therefore no value permitted\n",
+ t_path.path);
+ ret = FALSE;
+ continue;
+ }
+
+ if (def.tag) {
+ printf("Tag specified in template\n"
+ "\t%s\n\t - therefore no value permitted\n",
+ t_path.path);
+ ret = FALSE;
+ continue;
+ }
+
+ /* value is OK */
+ /* read it */
+ cp = NULL;
+ status = get_value(&cp, &m_path);
+ if (status == VTWERR_OK){
+#ifdef DEBUG1
+ printf("Validating value |%s|\n"
+ "for path %s\n", cp, m_path.path);
+#endif
+ status = validate_value(&def, cp);
+ ret = ret && status;
+ }
+ if (cp)
+ my_free(cp);
+ continue;
+ }
+
+ push_path(&m_path, uename); /* PUSH 3 */
+ if (lstat(m_path.path, &statbuf) < 0) {
+ printf("Can't read directory %s\n",
+ m_path.path);
+ ret = FALSE;
+ pop_path(&m_path); /* for PUSH 3 */
+ continue;
+ }
+
+ if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
+ printf("Non directory file %s\n", m_path.path);
+ ret = FALSE;
+ pop_path(&m_path); /* for PUSH 3 */
+ continue;
+ }
+
+ if (def_present && def.tag) {
+ /* do not push t_path, it is already pushed above */
+ /* validate dir name against definition */
+ boolean res = validate_value(&def, uename);
+ value_present=TRUE;
+ if (!res) {
+ ret = FALSE;
+ /* do not go inside bad directory */
+ pop_path(&m_path); /* for PUSH 3 */
+ continue;
+ }
+ } else {
+ push_path(&t_path, uename); /* PUSH 2b the same as PUSH 2a */
+ if (lstat(t_path.path, &statbuf) < 0) {
+ printf("No such template directory (%s)\n"
+ "for directory %s",
+ t_path.path, m_path.path);
+ ret = FALSE;
+ pop_path(&t_path); /* for PUSH 2b */
+ pop_path(&m_path); /* for PUSH 3 */
+ continue;
+ }
+ if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
+ printf("Non directory file %s\n", m_path.path);
+ ret = FALSE;
+ pop_path(&t_path); /* for PUSH 2b */
+ pop_path(&m_path); /* for PUSH 3 */
+ continue;
+ }
+ }
+
+ status = validate_dir_for_commit();
+ ret = ret && status;
+ pop_path(&m_path); /* for PUSH 3 */
+ if (!def_present || !def.tag)
+ pop_path(&t_path); /* for PUSH 2b */
+
+ }
+ status = closedir(dp);
+ if (status)
+ bye("Cannot close dir %s\n", m_path.path);
+
+ if(!value_present && def_present && !def.tag) {
+ ret = ret && validate_value(&def, "");
+ }
+
+ if (def_present && def.tag)
+ pop_path(&t_path); /* for PUSH 3a */
+ if (def_present)
+ free_def(&def);
+#ifdef DEBUG
+ printf("directory done(node_cnt %d, free_node_cnt %d)\n"
+ "mpath |%s|\n",
+ node_cnt, free_node_cnt, t_path.path);
+#endif
+ if (uename)
+ my_free(uename);
+ return ret;
+}
+
+/***************************************************
+ main:
+ main function (for now)
+***************************************************/
+
+int main(int argc, char **argv)
+{
+
+ boolean status;
+ char *mod;
+ struct stat statbuf;
+ int st;
+ boolean update_pending = FALSE;
+
+ set_in_commit(TRUE);
+ dump_log( argc, argv);
+ init_paths(TRUE);
+ mod = my_malloc(strlen(get_mdirp()) + strlen(MOD_NAME)+2, "COMMIT");
+ sprintf(mod, "%s/%s", get_mdirp(), MOD_NAME);
+ st = lstat(mod, &statbuf);
+ my_free(mod);
+ if (st < 0 ) {
+ bye("No configuration changes to commit\n");
+ exit(-1);
+ }
+
+ if(!get_config_lock(get_adirp(), LOCK_NAME)) {
+ bye("Configuration is locked\n");
+ }
+
+ status = validate_dir_for_commit();
+ if (status == TRUE) {
+ switch_path(CPATH);
+ status = commit_delete_children(NULL, FALSE, FALSE);
+ }
+ if (status == TRUE)
+ status = commit_update_children(NULL, FALSE, FALSE, &update_pending);
+ fin_commit(status);
+
+ done();
+
+ return (status == TRUE) ? 0 : 1;
+}
+
+/*************************************************************
+ perform_create_node -
+ remove node and descendent from woring path
+ and create a new node
+*************************************************************/
+static void perform_create_node()
+{
+#if BITWISE
+ static char format[]="rm -f -r %s;mkdir %s";
+ char *command;
+ switch_path(APATH);
+ command = my_malloc(2 * strlen(m_path.path) + sizeof(format),
+ "commit_create");
+ sprintf(command, format, m_path.path, m_path.path);
+ system(command);
+ my_free(command);
+ switch_path(CPATH);
+#endif
+ return;
+}
+
+
+/*************************************************************
+ perform_delete_node -
+ delete node in current path
+*************************************************************/
+static void perform_delete_node()
+{
+#if BITWISE
+ static char format[]="rm -f -r %s";
+ char *command;
+ command = my_malloc(strlen(m_path.path) + sizeof(format),
+ "commit_delete");
+ sprintf(command, format, m_path.path);
+ system(command);
+ my_free(command);
+#endif
+ return;
+}
+static void perform_move()
+{
+#if BITWISE
+ static char format[] = "rm -r -f %s;mkdir %s;mv %s/" VAL_NAME " %s";
+ char *a_path;
+ char *command;
+ switch_path(APATH);
+ a_path = my_strdup(m_path.path, "");
+ switch_path(CPATH);
+ command = my_malloc(sizeof(format)+3*strlen(a_path)+strlen(m_path.path),"");
+ sprintf(command, format, a_path, a_path, m_path.path, a_path);
+ system(command);
+ my_free(command);
+ my_free(a_path);
+#endif
+ return;
+}
+
+/*************************************************
+ commit_update_child:
+ preconditions: t_path and c_path set up for parent
+ pdefp (IN) - parent definition (may be NULL)
+ child (IN) - name of the child
+ creating (IN) - mode of commiting (update or create)
+ update_parent (OUT) - unfulfilled update request
+ commit child and its descendants
+ returns TRUE if no errors
+ exit if error during execution
+*/
+boolean commit_update_child(vtw_def *pdefp, char *child,
+ boolean creating, boolean in_txn, boolean *update_parent)
+{
+ boolean update_pending = FALSE;
+ boolean multi_tag = FALSE;
+ struct stat statbuf;
+ int status;
+ vtw_def def;
+ vtw_def *my_defp; /*def to be given to my children */
+ vtw_def *act_defp;/*def to be used for actions */
+ char *cp;
+ vtw_mark mark;
+ vtw_act_type act;
+ boolean do_end, ok, do_begin = FALSE, do_txn = FALSE;
+
+ set_at_string(NULL);
+
+ ok = TRUE;
+#ifdef DEBUG
+ printf("commiting directory (node_cnt %d, free_node_cnt %d)\n"
+ "mpath |%s|\n",
+ node_cnt, free_node_cnt, t_path.path);
+#endif
+ if (strcmp(child, ".") == 0 ||
+ strcmp(child, "..") == 0 ||
+ strcmp(child, MOD_NAME) == 0 ||
+ strcmp(child, LOCK_NAME) == 0 ||
+ strcmp(child, opaque_name) == 0)
+ return TRUE;
+
+ /* deleted subdirectory */
+ if (strncmp(child, ".wh.", 4) == 0) { /* whiteout */
+ /* ignore */
+ return TRUE;
+ }
+ mark_paths(&mark);
+ if (!creating) {
+ /* are we marked with opaque */
+ push_path(&m_path, child);
+ push_path(&m_path, opaque_name);
+ if (lstat(m_path.path, &statbuf) >= 0 && !creating) {
+ creating = TRUE;
+ }
+ pop_path(&m_path);
+ pop_path(&m_path);
+ }
+ /* find our definition */
+ if (pdefp && pdefp->tag) {
+ my_defp = NULL;
+ act_defp = pdefp;
+ push_path(&t_path,tag_name);
+ } else {
+ push_path(&t_path, child);
+ push_path(&t_path, def_name);
+ if ((lstat(t_path.path, &statbuf) >= 0) &&
+ ((statbuf.st_mode & S_IFMT) == S_IFREG)) {
+ /* defniition present */
+ act_defp = my_defp = &def;
+ memset(&def, 0, sizeof(def));
+#ifdef DEBUG1
+ printf("Parsing definition\n");
+#endif
+ if ((status = parse_def(&def, t_path.path,
+ FALSE)))
+ exit(status);
+ my_defp = act_defp = &def;
+ if (def.tag)
+ multi_tag = TRUE;
+ } else {
+ my_defp = act_defp = NULL;
+ }
+ pop_path(&t_path); /*def_name */
+ }
+ do_end = FALSE;
+ if (!multi_tag && !in_txn && act_defp &&
+ (act_defp->actions[begin_act].vtw_list_head ||
+ act_defp->actions[end_act].vtw_list_head)){
+ /* we are traversing change directory
+ if we are here, there is a change somewhere */
+ do_txn = in_txn = TRUE;
+ if (act_defp->actions[end_act].vtw_list_head)
+ do_end = TRUE;
+ /* if creating, delete skipped this directory,
+ we have to do begin act */
+ if (creating &&
+ act_defp->actions[begin_act].vtw_list_head)
+ do_begin = TRUE;
+ }
+ push_path(&m_path, child);
+ /* are we a "value" parent node */
+ if (act_defp && !act_defp->tag && act_defp->def_type != ERROR_TYPE ) {
+ /* we are value node */
+ if (!act_defp->multi) {
+ /* single node */
+ /* create_mode do create,
+ update_mode do create or update */
+
+ if (creating)
+ act = create_act;
+ else
+ act = update_act;
+
+ if ((act==update_act) && !act_defp->actions[update_act].vtw_list_head){
+ /* updating but no action
+ ask parent to do - propagate up */
+ *update_parent = TRUE;
+ }
+ /* look for actions */
+ /* if act != create_act => run actions[act] if not empty */
+ /* if act == create_act
+ * if actions[create_act] not empty
+ * run it
+ * else
+ * run actions[update_act] if not empty
+ * run actions[activate_act] if not empty
+ */
+ if (act_defp->actions[act].vtw_list_head
+ || (act == create_act
+ && (act_defp->actions[activate_act].vtw_list_head
+ || act_defp->actions[update_act].vtw_list_head))) {
+ status = get_value_to_at_string(&m_path);
+ if (status != VTWERR_OK)
+ bye("Can not read value at %s", m_path.path);
+ /* remove \n at the line end */
+ cp = strchr(get_at_string(), '\n');
+ if (cp)
+ *cp = 0;
+ if (act_defp->actions[act].vtw_list_head) {
+ status = execute_list(act_defp->actions[act].vtw_list_head,
+ act_defp);
+ if (!status) {
+#ifdef DEBUG
+ bye("begin action not NULL for %s\n", get_at_string());
+#else
+ return(FALSE);
+#endif
+ }
+ } else {
+ /* creating but no create action */
+ /* try update action */
+ if ((act == create_act)
+ && act_defp->actions[update_act].vtw_list_head) {
+ status
+ = execute_list(act_defp->actions[update_act].vtw_list_head,
+ act_defp);
+ if (!status) {
+ return (FALSE);
+ }
+ }
+ }
+ /* try activate action if creating */
+ if ((act == create_act)
+ && act_defp->actions[activate_act].vtw_list_head) {
+ status
+ = execute_list(act_defp->actions[activate_act].vtw_list_head,
+ act_defp);
+ if (!status) {
+ return (FALSE);
+ }
+ }
+ free_at_string();
+ }
+ /* now handle commit value */
+ if (!in_txn) { /* ELSE WAIT TILL THE END OF TXN */
+ perform_move();
+ perform_delete_node();
+ }
+ goto restore;
+ }
+ /* else multi_node */
+ cp = NULL;
+ status = get_value(&cp, &m_path);
+ if (status != VTWERR_OK)
+ bye("Can not read value at %s", m_path.path);
+ ok = commit_value(act_defp, cp, creating?create_mode:update_mode, in_txn);
+ if (cp)
+ my_free(cp);
+ goto restore;
+ }
+ /* else not a value */
+ /* regular */
+ /* do not do anything for tag type multinode */
+ if (!multi_tag && creating) {
+ set_at_string(child); /* for expand inside actions */
+ if (do_begin) {
+ status = execute_list(act_defp->
+ actions[begin_act].
+ vtw_list_head, act_defp);
+ if (!status) {
+#ifdef DEBUG
+ bye("begin action not NULL for %s\n", get_at_string());
+#else
+ return(FALSE);
+#endif
+ }
+ }
+
+ if (act_defp) {
+ if (act_defp->actions[create_act].vtw_list_head) {
+ status
+ = execute_list(act_defp->actions[create_act].vtw_list_head,
+ act_defp);
+ if (!status) {
+ return (FALSE);
+ }
+ } else if (act_defp->actions[update_act].vtw_list_head) {
+ /* no create action => use update action */
+ status
+ = execute_list(act_defp->actions[update_act].vtw_list_head,
+ act_defp);
+ if (!status) {
+ return (FALSE);
+ }
+ }
+ /* not trying activate action here (activate after children are
+ * configured)
+ */
+ }
+ }
+ if (creating && !in_txn) /* ELSE WAIT TILL THE END OF TXN */
+ perform_create_node();
+ /* children */
+ ok = commit_update_children(my_defp, creating, in_txn, &update_pending);
+ if (!ok)
+ return(FALSE);
+
+ if (update_pending){
+ if (!multi_tag && act_defp &&
+ act_defp->actions[update_act].vtw_list_head){
+ set_at_string(child); /* for expand inside actions */
+ ok = execute_list(act_defp->actions[update_act].
+ vtw_list_head, act_defp);
+ if (!ok)
+ return(FALSE);
+ /* update_pending = FALSE; */
+ } else
+ *update_parent = TRUE;
+ }
+ if (creating && !multi_tag && act_defp &&
+ act_defp->actions[activate_act].vtw_list_head){
+ set_at_string(child); /* for expand inside actions */
+ ok = execute_list(act_defp->actions[activate_act].
+ vtw_list_head, act_defp);
+ /* ignore result */
+ }
+ if (!in_txn) /* ELSE WAIT TILL THE END OF TXN */
+ perform_delete_node();
+ restore:
+ if (do_end){
+ set_at_string(child);
+ ok = execute_list(act_defp->actions[end_act].
+ vtw_list_head, act_defp);
+ }
+#if BITWISE
+ if (do_txn && ok) {
+ int len;
+ char *command;
+ char format1[]="rm -r -f %s/*;cp -r -f %s/%s %s";
+ char format2[]="rm -r -f %s/%s;mv %s/%s %s";
+ char format3[]="rm -r -f %s/%s";
+ restore_paths(&mark);
+ switch_path(MPATH);
+ len = sizeof(format1) + 2 * strlen(get_tmpp()) +
+ strlen(m_path.path) + strlen(child);
+ command = my_malloc(len, "");
+ sprintf(command, format1, get_tmpp(), m_path.path, child,
+ get_tmpp());
+ system(command);
+ my_free(command);
+ switch_path(APATH);
+ len = sizeof(format2) + 2 *strlen(m_path.path) +
+ 2 * strlen( child) + strlen(get_tmpp());
+ command = my_malloc(len, "");
+ sprintf(command, format2, m_path.path, child, get_tmpp(),
+ child, m_path.path);
+ system(command);
+ my_free(command);
+ switch_path(CPATH);
+ len = sizeof(format3) + strlen(m_path.path) +
+ strlen( child);
+ command = my_malloc(len, "");
+ sprintf(command, format3, m_path.path, child);
+ system(command);
+ my_free(command);
+ }
+#endif
+ restore_paths(&mark);
+ if (my_defp && my_defp != pdefp)
+ free_def(my_defp);
+ return ok;
+}
+
+
+/*************************************************
+ commit_delete_child:
+ preconditions: t_path and c_path set up for parent
+ pdefp (IN) - parent definition (may be NULL)
+ child (IN) - name of the child
+ do_del (IN) - if FALSE we are looking for delete target
+ if TRUE, we found and switched to A (working) PATH
+ commit deleted child and its descendants
+ returns TRUE if no errors
+ exit if error during execution
+*/
+static boolean commit_delete_child(vtw_def *pdefp, char *child,
+ boolean deleting, boolean in_txn)
+{
+ boolean do_children, multi_tag = FALSE;
+ struct stat statbuf;
+ int status;
+ vtw_def def;
+ vtw_def *my_defp; /*def to be given to my children */
+ vtw_def *act_defp;/*def to be used for actions */
+ char *cp;
+ vtw_mark mark;
+ boolean ok, do_txn = FALSE;
+ int st;
+ ok = TRUE;
+
+#ifdef DEBUG
+ printf("commiting directory (node_cnt %d, free_node_cnt %d)\n"
+ "mpath |%s|\n",
+ node_cnt, free_node_cnt, t_path.path);
+#endif
+
+ /* deleted subdirectory */
+ if (strncmp(child, ".wh.", 4) == 0) { /* whiteout */
+ if (deleting)
+ /* in do_delete mode we traverse A hierarchy, no white-outs possible */
+ INTERNAL; /* it is exit */
+ else {
+ /* deal with counterpart in working */
+ switch_path(APATH);
+ push_path(&m_path, child+4);
+ st = lstat(m_path.path, &statbuf);
+ pop_path(&m_path);
+ if (st >= 0){
+ /*get rid of ".wh. part in child name"*/
+ /* deleting mode will handle txn, both
+ begin and end
+ */
+ ok = commit_delete_child(pdefp, child + 4, TRUE, in_txn);
+ }else {
+ /* I do not understand how we could be here */
+ printf("Mystery #1\n");
+ ok = TRUE;
+ }
+ switch_path(CPATH);
+ if (ok) {
+ /* delete whiteout */
+ if (!in_txn){ /*ELSE WAIT TILL THE END OF TXN*/
+ push_path(&m_path, child);
+ perform_delete_node();
+ pop_path(&m_path);
+ }
+ }
+ return ok;
+ }
+ /* done with whiteouts */
+ }
+ /* not white out */
+ mark_paths(&mark);
+ if (!deleting) {
+ int status;
+ /* are we marked with opaque */
+ push_path(&m_path, child);
+ push_path(&m_path, opaque_name);
+ status = lstat(m_path.path, &statbuf);
+ pop_path(&m_path);
+ pop_path(&m_path);
+ if (status >= 0) {
+ /* brand new directory, nothing is
+ deleted there;
+ update will handle txn (both begin and end)
+ */
+ return TRUE;
+ }
+ }
+ /* find our definition */
+ if (pdefp && pdefp->tag) {
+ /* parent is a tag, node is a tag value node */
+ my_defp = NULL;
+ act_defp = pdefp;
+ push_path(&t_path,tag_name);
+ } else {
+ push_path(&t_path, child);
+ push_path(&t_path, def_name);
+ if ((lstat(t_path.path, &statbuf) >= 0) &&
+ ((statbuf.st_mode & S_IFMT) == S_IFREG)) {
+ /* defniition present */
+ act_defp = my_defp = &def;
+ memset(&def, 0, sizeof(def));
+#ifdef DEBUG1
+ printf("Parsing definition\n");
+#endif
+ if ((status = parse_def(&def, t_path.path,
+ FALSE)))
+ exit(status);
+ my_defp = act_defp = &def;
+ if (def.tag)
+ multi_tag = TRUE; /* tag node itself*/
+ } else {
+ my_defp = act_defp = NULL;
+ }
+ pop_path(&t_path); /*def_name */
+ }
+ push_path(&m_path, child);
+ if (!multi_tag) {
+ set_at_string(child); /* for expand inside actions */
+ /* deal with txn */
+ if (!in_txn && act_defp &&
+ (act_defp->actions[begin_act].vtw_list_head ||
+ act_defp->actions[end_act].vtw_list_head)) {
+ /* if we are here we have change,
+ we either in do_del and our node is change node
+ or we are in change directory and our node is
+ change node also */
+ if (deleting)
+ /* if not deleting, update will handle values */
+ do_txn = TRUE;
+ in_txn = TRUE;
+ if (act_defp->actions[begin_act].vtw_list_head){
+ status = execute_list(act_defp->actions[begin_act].
+ vtw_list_head, act_defp);
+ if (!status) {
+#ifdef DEBUG
+ bye("begin action not NULL for %s\n", get_at_string());
+#else
+ return(FALSE);
+#endif
+ }
+ }
+ }
+ }
+ /* are we a "value" parent node */
+ if (act_defp && !act_defp->tag && act_defp->def_type != ERROR_TYPE ) {
+ /* we are value node */
+ if (!act_defp->multi) {
+ /* single node */
+ if (!deleting) {
+ /* if it was whiteout, it was converted to do_del_mode */
+ restore_paths(&mark);
+ return ok;
+ }
+
+ /* do we have actions */
+ if (act_defp->actions[delete_act].vtw_list_head){
+ status = get_value_to_at_string(&m_path);
+ if (status != VTWERR_OK)
+ bye("Can not read value at %s", m_path.path);
+ /* remove \n at the line end */
+ cp = strchr(get_at_string(), '\n');
+ if (cp)
+ *cp = 0;
+ if (act_defp->actions[delete_act].vtw_list_head) {
+ set_in_delete_action(TRUE);
+ status = execute_list(act_defp->actions[delete_act].
+ vtw_list_head, act_defp);
+ set_in_delete_action(FALSE);
+ if (!status) {
+#ifdef DEBUG
+ bye("begin action not NULL for %s\n", get_at_string());
+#else
+ return(FALSE);
+#endif
+ }
+ }
+ free_at_string();
+ }
+ /* now handle commit value */
+ if (!in_txn) /* ELSE WAIT TILL THE END OF TXN */
+ perform_delete_node();
+ goto restore;
+ }
+ /* else multi_node */
+ cp = NULL;
+ status = get_value(&cp, &m_path);
+ if (status != VTWERR_OK)
+ bye("Can not read value at %s", m_path.path);
+ ok = commit_value(act_defp, cp, deleting?do_del_mode:del_mode,in_txn);
+ if (cp)
+ my_free(cp);
+ goto restore;
+ }
+ /* else not a value */
+ /* regular */
+ do_children = TRUE;
+ /* do not do anything for tag itself, all action belong to values */
+ if (!multi_tag) {
+ set_at_string(child); /* for expand inside actions */
+ if (deleting) {
+ if (act_defp &&
+ act_defp->actions[delete_act].vtw_list_head){
+ do_children = FALSE;
+ set_in_delete_action(TRUE);
+ status = execute_list(act_defp->actions[delete_act].
+ vtw_list_head, act_defp);
+ set_in_delete_action(FALSE);
+ if (!status) {
+#ifdef DEBUG
+ bye("begin action not NULL for %s\n", get_at_string());
+#else
+ return(FALSE);
+#endif
+ }
+ }
+ }
+ }
+ /* children */
+ if (do_children){
+ ok = commit_delete_children(my_defp, deleting, in_txn);
+ if (!ok)
+ goto restore;
+ }
+ if (deleting) {
+ if (do_txn && act_defp &&
+ act_defp->actions[end_act].vtw_list_head) {
+ set_at_string(child);
+ ok = execute_list(act_defp->actions[end_act].
+ vtw_list_head, act_defp);
+ if (!ok)
+ goto restore;
+ }
+ /* delete node and all its descendants */
+ if (!in_txn || do_txn)/* ELSE WAIT TILL THE END OF TXN */
+ perform_delete_node();
+ }
+ restore:
+ restore_paths(&mark);
+ if (my_defp && my_defp != pdefp)
+ free_def(my_defp);
+ return ok;
+}
+
+static boolean commit_delete_children(vtw_def *defp, boolean deleting,
+ boolean in_txn)
+{
+ DIR *dp;
+ int status;
+ struct dirent *dirp;
+ boolean ok = TRUE;
+ char *child;
+ vtw_type_e type;
+ valstruct mvals;
+ boolean first;
+ char *cp;
+ int elem, curi;
+ vtw_sorted cur_sorted;
+ char *uename = NULL;
+
+ if ((dp = opendir(m_path.path)) == NULL){
+ if (deleting)
+ return TRUE;
+ INTERNAL;
+ }
+ if (defp)
+ type = defp->def_type;
+ else
+ type = TEXT_TYPE;
+ if (type == ERROR_TYPE)
+ type = TEXT_TYPE;
+ first = TRUE;
+ memset(&mvals, 0, sizeof (valstruct));
+ memset(&cur_sorted, 0, sizeof(vtw_sorted));
+
+ while ((dirp = readdir(dp)) != NULL) {
+ child = dirp->d_name;
+ if (strcmp(child, ".") == 0 ||
+ strcmp(child, "..") == 0 ||
+ strcmp(child, MOD_NAME) == 0 ||
+ strcmp(child, LOCK_NAME) == 0 ||
+ strcmp(child, OPQ_NAME) == 0)
+ continue;
+ uename = clind_unescape(child);
+ cp = uename;
+ if (first) {
+ mvals.free_me = TRUE;
+ mvals.val = cp;
+ mvals.val_type = type;
+ first = FALSE;
+ } else {
+ if (mvals.cnt%MULTI_ALLOC == 0) {
+ /* convert into multivalue */
+ mvals.vals = my_realloc(mvals.vals,
+ (mvals.cnt + MULTI_ALLOC) *
+ sizeof(char *), "add_value");
+ if (mvals.cnt == 0) { /* single value - convert */
+ mvals.vals[0] = mvals.val;
+ mvals.cnt= 1;
+ mvals.val = NULL;
+ }
+ }
+ mvals.vals[mvals.cnt] = cp;
+ ++mvals.cnt;
+ }
+ }
+ status = closedir(dp);
+ if (status)
+ INTERNAL;
+ if (first) {
+ return TRUE;
+ }
+ vtw_sort(&mvals, &cur_sorted);
+ for (curi = 0; curi < cur_sorted.num && ok; ++curi){
+ if (type == TEXT_TYPE ||
+ type == BOOL_TYPE)
+ child = (char *)(cur_sorted.ptrs[curi]);
+ else {
+ elem = (((unsigned int *)(cur_sorted.ptrs[curi]))-
+ cur_sorted.parts)/
+ cur_sorted.partnum;
+ child = mvals.cnt?mvals.vals[elem]:
+ mvals.val;
+ }
+ ok = commit_delete_child(defp, child, deleting, in_txn);
+ }
+ free_val(&mvals);
+ free_sorted(&cur_sorted);
+ return ok;
+}
+
+static boolean commit_update_children(vtw_def *defp, boolean creating,
+ boolean in_txn, boolean *parent_update)
+{
+ DIR *dp;
+ int status;
+ struct dirent *dirp;
+ boolean ok = TRUE;
+ char *child;
+ vtw_type_e type;
+ valstruct mvals;
+ boolean first;
+ char *cp;
+ int elem, curi;
+ vtw_sorted cur_sorted;
+ char *uename = NULL;
+
+
+ if ((dp = opendir(m_path.path)) == NULL){
+ printf("%s:%d: opendir error: path=%s\n",
+ __FUNCTION__,__LINE__,m_path.path);
+ INTERNAL;
+ }
+
+ memset(&mvals, 0, sizeof (valstruct));
+ memset(&cur_sorted, 0, sizeof(vtw_sorted));
+ if (defp)
+ type = defp->def_type;
+ else
+ type = TEXT_TYPE;
+ if (type == ERROR_TYPE)
+ type = TEXT_TYPE;
+ first = TRUE;
+
+ while ((dirp = readdir(dp)) != NULL) {
+ child = dirp->d_name;
+ if (strcmp(child, ".") == 0 ||
+ strcmp(child, "..") == 0 ||
+ strcmp(child, MOD_NAME) == 0 ||
+ strcmp(child, LOCK_NAME) == 0 ||
+ strcmp(child, OPQ_NAME) == 0)
+ continue;
+ cp = uename = clind_unescape(child);
+ if (first) {
+ mvals.free_me = TRUE;
+ mvals.val = cp;
+ mvals.val_type = type;
+ first = FALSE;
+ } else {
+ if (mvals.cnt%MULTI_ALLOC == 0) {
+ /* convert into multivalue */
+ mvals.vals = my_realloc(mvals.vals,
+ (mvals.cnt + MULTI_ALLOC) *
+ sizeof(char *), "add_value");
+ if (mvals.cnt == 0) { /* single value - convert */
+ mvals.vals[0] = mvals.val;
+ mvals.cnt= 1;
+ mvals.val = NULL;
+ }
+ }
+ mvals.vals[mvals.cnt] = cp;
+ ++mvals.cnt;
+ }
+ }
+ status = closedir(dp);
+ if (status)
+ INTERNAL;
+ if (first) {
+ if (uename)
+ my_free(uename);
+ return TRUE;
+ }
+ vtw_sort(&mvals, &cur_sorted);
+ for (curi = 0; curi < cur_sorted.num && ok; ++curi){
+ if (type == TEXT_TYPE ||
+ type == BOOL_TYPE)
+ child = (char *)(cur_sorted.ptrs[curi]);
+ else {
+ elem = (((unsigned int *)(cur_sorted.ptrs[curi]))-
+ cur_sorted.parts)/
+ cur_sorted.partnum;
+ child = mvals.cnt?mvals.vals[elem]:
+ mvals.val;
+ }
+ ok = commit_update_child(defp, child, creating, in_txn, parent_update);
+ }
+ free_val(&mvals);
+ free_sorted(&cur_sorted);
+ return ok;
+}
+
+
+/*************************************************
+ commit_value:
+ executes commit for the value leave node
+**************************************************/
+static boolean commit_value(vtw_def *defp, char *cp,
+ vtw_cmode mode, boolean in_txn)
+{
+
+ valstruct act_value;
+ int status;
+ int curi,acti, partnum, res=0;
+ void *actp, *curp;
+ boolean no_shadow;
+ boolean ok;
+ int total, a_res, c_res;
+ char **a_ptr, **c_ptr, *val_string;
+ boolean cur_pr_val;
+ int pr_index;
+ int sign;
+ boolean creating;
+ vtw_node *actions;
+ valstruct cur_value;
+ vtw_sorted cur_sorted;
+ vtw_sorted act_sorted;
+
+ ok = TRUE;
+ actions = NULL;
+ if(mode == del_mode || mode == do_del_mode) {
+ creating = FALSE;
+ if (defp && defp->actions[delete_act].vtw_list_head) {
+ set_in_delete_action(TRUE);
+ actions = defp->actions[delete_act].vtw_list_head;
+ }
+ } else {
+ creating = TRUE;
+ if (defp && defp->actions[create_act].vtw_list_head)
+ actions = defp->actions[create_act].vtw_list_head;
+ }
+ /* prepare cur_value */
+
+ status = char2val(defp, cp, &cur_value);
+ if (mode != do_del_mode && mode != create_mode) {
+ /* get active value */
+ switch_path(APATH); /* switch form CCD to ACD */
+ status = get_value(&cp, &m_path);
+ switch_path(CPATH); /* back to CCD */
+ if (status != VTWERR_OK) {
+ no_shadow = TRUE;
+ }else
+ no_shadow = FALSE;
+ } else {
+ no_shadow = TRUE;
+ }
+ vtw_sort(&cur_value, &cur_sorted);
+ if(no_shadow) {
+ act_sorted.num = 0;
+ }else {
+ status = char2val(defp, cp, &act_value);
+ if (status != VTWERR_OK) {
+ INTERNAL;
+ }
+ /* sort them */
+ vtw_sort(&act_value, &act_sorted);
+ }
+ if (mode == do_del_mode) {
+ /* it was actually act_sorted, not cur_sorted */
+ act_sorted = cur_sorted;
+ cur_sorted.num = 0;
+ act_value = cur_value;
+ /* act_value will be freed by freeing cur_value
+ do not zero out it here */
+ }
+
+ acti = 0;
+ curi = 0;
+ total = act_sorted.num + cur_sorted.num;
+ a_res=0;
+ c_res=0;
+ a_ptr = my_malloc(total*sizeof(char *), "");
+ c_ptr = my_malloc(total*sizeof(char *), "");
+ while (acti < act_sorted.num || curi < cur_sorted.num) {
+ if (acti == act_sorted.num) {
+ cur_pr_val = TRUE;
+ pr_index = curi;
+ sign = +1;
+ ++curi;
+ } else if (curi == cur_sorted.num) {
+ cur_pr_val = FALSE;
+ pr_index = acti;
+ sign = -1;
+ ++acti;
+ } else {
+ /* compare */
+ actp = act_sorted.ptrs[acti];
+ curp = cur_sorted.ptrs[curi];
+ /* compare */
+ if (act_sorted.partnum){
+ for(partnum = 0; partnum < act_sorted.partnum;
+ ++partnum) {
+ res = *((int *)actp + partnum) -
+ *((int *)curp + partnum);
+ if (res)
+ break;
+ }
+ } else{
+ res = strcmp((char *)actp, (char *) curp);
+ }
+ if (res == 0) {
+ /* the same */
+ cur_pr_val = TRUE;
+ pr_index = curi;
+ sign = 0;
+ ++acti;
+ ++curi;
+ } else if (res < 0) {
+ /* act < cur, act is unmatched */
+ cur_pr_val = FALSE;
+ pr_index = acti;
+ sign = -1;
+ ++acti;
+ }else {
+ /* cur < act, cur is unmatched */
+ cur_pr_val = TRUE;
+ pr_index = curi;
+ sign = 1;
+ ++curi;
+ }
+ }
+ if (defp->def_type == TEXT_TYPE ||
+ defp->def_type == BOOL_TYPE) {
+ val_string = cur_pr_val?
+ ((char *)(cur_sorted.ptrs[pr_index])):
+ ((char *)(act_sorted.ptrs[pr_index]));
+ } else {
+ if (cur_pr_val) {
+ int elem = (((unsigned int *)(cur_sorted.ptrs[pr_index]))-
+ cur_sorted.parts)/
+ cur_sorted.partnum;
+ val_string = cur_value.cnt?cur_value.vals[elem]:
+ cur_value.val;
+ } else {
+ int elem = (((unsigned int *)(act_sorted.ptrs[pr_index]))-
+ act_sorted.parts)/
+ act_sorted.partnum;
+ val_string = act_value.cnt?act_value.vals[elem]:
+ act_value.val;
+ }
+ }
+ set_at_string(val_string);
+ switch (sign) {
+ case 0: /* found in both, no actions, include in both */
+ a_ptr[a_res++]=val_string;
+ c_ptr[c_res++]=val_string;
+ break;
+ case 1: /* found only in change */
+ if (ok && creating) {
+ if (actions) {
+ /* do create action */
+ ok = execute_list(actions, defp);
+ } else if (defp && defp->actions[update_act].vtw_list_head) {
+ /* no create action => use update action */
+ ok = execute_list(defp->actions[update_act].vtw_list_head, defp);
+ }
+ if (ok && defp && defp->actions[activate_act].vtw_list_head) {
+ /* try activate action */
+ ok = execute_list(defp->actions[activate_act].vtw_list_head, defp);
+ }
+ /* if succ, make it look old */
+ if(ok)
+ a_ptr[a_res++]=val_string;
+ }
+ c_ptr[c_res++]=val_string; /* in all cases */
+ break;
+ case -1: /* found only in working */
+ if (ok && !creating && actions) {/* ok and deleting */
+ ok = execute_list(actions, defp);
+ }
+ /* if succ and deleting - do nothing, else */
+ if (!ok || creating)
+ a_ptr[a_res++]=val_string;
+ }
+ }
+ if (creating && ok)
+ c_res = 0;
+#if BITWISE
+ if (!in_txn) {/* ELSE WAIT TILL THE END OF TXN */
+ switch_path(APATH);
+ if (a_res) {
+ make_dir();
+ push_path(&m_path, VAL_NAME);
+ fp = fopen(m_path.path, "w");
+ if (fp == NULL)
+ bye("Can not open value file %s", m_path.path);
+ for(i=0;i<a_res;++i)
+ if (fputs(a_ptr[i], fp) < 0 || fputc('\n',fp) < 0)
+ bye("Error writing file %s", m_path.path);
+ fclose(fp);
+ pop_path(&m_path);
+ }else{
+ perform_delete_node();
+ }
+ switch_path(CPATH);
+ if (c_res) {
+ make_dir();
+ push_path(&m_path, VAL_NAME);
+ fp = fopen(m_path.path, "w");
+ if (fp == NULL)
+ bye("Can not open value file %s", m_path.path);
+ for(i=0;i<c_res;++i)
+ if (fputs(c_ptr[i], fp) < 0 || fputc('\n',fp) < 0)
+ bye("Error writing file %s", m_path.path);
+ fclose(fp);
+ pop_path(&m_path);
+ }else{
+ perform_delete_node();
+ }
+ }
+#endif /*BITWISE*/
+ if (mode == do_del_mode)
+ switch_path(APATH);
+ else
+ switch_path(CPATH);
+ if(act_sorted.num)
+ free_sorted(&act_sorted);
+ if(cur_sorted.num)
+ free_sorted(&cur_sorted);
+ my_free(a_ptr);
+ my_free(c_ptr);
+ free_val(&cur_value);
+ if (!no_shadow)
+ free_val(&act_value);
+ set_in_delete_action(FALSE);
+ return ok;
+}
+
+static int fin_commit(boolean ok)
+{
+ char *command;
+ static char format1[]="cp -r -f %s/* %s"; /*mdirp, tmpp*/
+ static char format2[]="sudo umount %s"; /*mdirp*/
+ static char format3[]="rm -f %s/" MOD_NAME " >&/dev/null ; /bin/true";
+ /*tmpp*/
+ static char format4[]="rm -rf %s/{.*,*} >&/dev/null ; /bin/true"; /*cdirp*/
+ static char format5[]="rm -rf %s/{.*,*} >&/dev/null ; /bin/true"; /*adirp*/
+ static char format6[]="mv -f %s/* -t %s";/*tmpp, adirp*/
+ static char format7[]="sudo mount -t unionfs -o dirs=%s=rw:%s=ro"
+ " unionfs %s"; /*cdirp, adirp, mdirp*/
+ int m_len = strlen(get_mdirp());
+ int t_len = strlen(get_tmpp());
+ int c_len = strlen(get_cdirp());
+ int a_len = strlen(get_adirp());
+ set_echo(TRUE);
+ if (!ok){
+ printf("Commit FAILED!\n");
+ return -1;
+ }
+ command = my_malloc(strlen(format1) + m_len + t_len, "");
+ sprintf(command, format1, get_mdirp(), get_tmpp());
+ system(command);
+ my_free(command);
+
+ command = my_malloc(strlen(format2) + m_len, "");
+ sprintf(command, format2, get_mdirp());
+ system(command);
+ my_free(command);
+
+ command = my_malloc(strlen(format3) + c_len, "");
+ sprintf(command, format3, get_tmpp());
+ system(command);
+ my_free(command);
+
+ command = my_malloc(strlen(format4) + c_len, "");
+ sprintf(command, format4, get_cdirp());
+ system(command);
+ my_free(command);
+
+ command = my_malloc(strlen(format5) + a_len, "");
+ sprintf(command, format5, get_adirp());
+ system(command);
+ my_free(command);
+
+ command = my_malloc(strlen(format6) + t_len + a_len, "");
+ sprintf(command, format6, get_tmpp(), get_adirp());
+ system(command);
+ my_free(command);
+
+ command = my_malloc(strlen(format7) + c_len + a_len + m_len, "");
+ sprintf(command, format7, get_cdirp(), get_adirp(), get_mdirp());
+ system(command);
+ my_free(command);
+
+ return 0;
+}
+
diff --git a/src/delete.c b/src/delete.c
new file mode 100644
index 0000000..a825a22
--- /dev/null
+++ b/src/delete.c
@@ -0,0 +1,258 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+#include <sys/stat.h>
+#include <dirent.h>
+
+#include "cli_val.h"
+#include "cli_objects.h"
+
+static void remove_rf(boolean do_umount)
+{
+ char *command;
+ touch();
+ if (do_umount) {
+ command = my_malloc(strlen(get_mdirp()) + 20, "delete");
+ sprintf(command, "sudo umount %s", get_mdirp());
+ system(command);
+ free(command);
+ }
+ command = my_malloc(strlen(m_path.path) + 10, "delete");
+ sprintf(command, "rm -rf %s", m_path.path);
+ system(command);
+ free(command);
+ if (do_umount) {
+ command = my_malloc(strlen(get_mdirp()) + strlen(get_cdirp()) +
+ strlen(get_mdirp()) + 100,
+ "delete");
+ sprintf(command, "sudo mount -t unionfs -o dirs=%s=rw:%s=ro:"
+ " unionfs %s", get_cdirp(), get_adirp(), get_mdirp());
+ system(command);
+ free(command);
+ }
+}
+/***************************************************
+ set_validate:
+ validate value against definition
+ return TRUE if OK, FALSE otherwise
+****************************************************/
+boolean set_validate(vtw_def *defp, char *valp)
+{
+ boolean res;
+ int status;
+ struct stat statbuf;
+
+ pop_path(&t_path); /* it was tag or real value */
+ push_path(&t_path, DEF_NAME);
+ if (lstat(t_path.path, &statbuf) < 0 ||
+ (statbuf.st_mode & S_IFMT) != S_IFREG) {
+ bye("Can not set value (2), no definition for %s", m_path.path);
+ }
+ /* defniition present */
+ memset(defp, 0, sizeof(vtw_def));
+ if ((status = parse_def(defp, t_path.path, FALSE)))
+ exit(status);
+ res = validate_value(defp, valp);
+ pop_path(&t_path);
+ return res;
+}
+
+int main(int argc, char **argv)
+{
+ int ai;
+ struct stat statbuf;
+ vtw_def def;
+ boolean last_tag=0;
+ int status;
+ FILE *fp;
+ boolean res;
+ char *cp, *delp, *endp;
+ boolean do_umount;
+
+ if (argc < 2) {
+ fprintf(stderr, "Need to specify the config node to delete\n");
+ exit(1);
+ }
+
+ dump_log( argc, argv);
+ do_umount = FALSE;
+ init_edit();
+ /* extend both paths per arguments given */
+ /* last argument is new value */
+ for (ai = 1; ai < argc; ++ai) {
+ push_path(&t_path, argv[ai]);
+ push_path(&m_path, argv[ai]);
+ if (lstat(t_path.path, &statbuf) >= 0) {
+ if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
+ bye("INTERNAL:regular file %s in templates", t_path.path);
+ }
+ last_tag = FALSE;
+ continue;
+ } /*else */
+ pop_path(&t_path);
+ push_path(&t_path, TAG_NAME);
+ if (lstat(t_path.path, &statbuf) >= 0) {
+ if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
+ bye("INTERNAL:regular file %s in templates", t_path.path);
+ }
+ last_tag = TRUE;
+ continue;
+ }
+ /* no match */
+ break;
+ }
+ /*
+ cases:
+ multiple tag-value - not achild
+ mutilple tag-value - not the last child
+ multiple tag-value - last child
+ single value modified
+ signle value unmodified
+ multiple non-tag value - the last value
+ multiple non-tag value - not the last value
+ regular child
+ */
+ if (ai == argc) {
+ /* full path found */
+ /* all cases except multiple non-tag value */
+ /* check for single value */
+ if (last_tag) {
+ /* case of multiple tag-value
+ was this a real child?
+ was it the last child?
+ */
+ struct dirent *dirp;
+ DIR *dp;
+
+ if (lstat(m_path.path, &statbuf) < 0)
+ bye("Nothing to delete at %s", m_path.path);
+ remove_rf(FALSE);
+ pop_path(&m_path);
+ if ((dp = opendir(m_path.path)) == NULL){
+ INTERNAL;
+ }
+ while ((dirp = readdir(dp)) != NULL) {
+ /*do we have real child */
+ if (strcmp(dirp->d_name, ".") &&
+ strcmp(dirp->d_name, "..") &&
+ strcmp(dirp->d_name, MOD_NAME) && /* XXX */
+ strcmp(dirp->d_name, LOCK_NAME) && /* XXX */
+ strncmp(dirp->d_name, ".wh.", 4) )
+ break;
+ }
+ if (dirp == NULL) {
+ /* no real children left */
+ /* kill parent also */
+ remove_rf(FALSE);
+ }
+ exit(0);
+ }
+ /*not tag */
+ push_path(&t_path, DEF_NAME);
+ if (lstat(t_path.path, &statbuf) >= 0 &&
+ (statbuf.st_mode & S_IFMT) == S_IFREG) {
+ /* defniition present */
+ memset(&def, 0, sizeof(vtw_def));
+ if ((status = parse_def(&def, t_path.path, FALSE)))
+ exit(status);
+ if (!def.tag && !def.multi && def.def_type!= ERROR_TYPE) {
+ /* signgle value */
+ /* is it modified ==
+ it is in C, but not OPAQUE */
+ switch_path(CPATH);
+ if(lstat(m_path.path, &statbuf) >= 0) {
+ push_path(&m_path, OPQ_NAME);
+ if(lstat(m_path.path, &statbuf) < 0) {
+ /* yes remove from C only */
+ pop_path(&m_path);
+ remove_rf(TRUE);
+ exit(0);
+ }
+ pop_path(&m_path); /*OPQ_NAME */
+ }
+ switch_path(MPATH);
+ }
+ }
+ /* else no defnition, remove it also */
+ remove_rf(FALSE);
+ exit(0);
+ }
+ if(ai < argc -1 || last_tag) {
+ bye("There is no appropriate template for %s",
+ m_path.path + strlen(get_mdirp()));
+ }
+ /*ai == argc -1, must be actual value */
+ pop_path(&m_path); /*it was value, not path segment */
+ push_path(&m_path, VAL_NAME);
+ /* set value */
+ if (lstat(m_path.path, &statbuf) < 0)
+ bye("Nothing to delete at %s", m_path.path);
+ if ((statbuf.st_mode & S_IFMT) != S_IFREG)
+ bye("Not a regular file %s", m_path.path);
+ /* get definition to deal with potential multi */
+ pop_path(&t_path); /* it was tag or real value */
+ push_path(&t_path, DEF_NAME);
+ if (lstat(t_path.path, &statbuf) < 0 ||
+ (statbuf.st_mode & S_IFMT) != S_IFREG) {
+ bye("Can not delete value, no definition for %s", m_path.path);
+ }
+ /* defniition present */
+ memset(&def, 0, sizeof(vtw_def));
+ if ((status = parse_def(&def, t_path.path, FALSE)))
+ exit(status);
+ if (def.multi) {
+ /* delete from multivalue */
+ valstruct new_value, old_value;
+ status = char2val(&def, argv[argc - 1], &new_value);
+ if (status)
+ exit(0);
+ cp = NULL;
+ pop_path(&m_path); /* get_value will push VAL_NAME */
+ status = get_value(&cp, &m_path);
+ if (status != VTWERR_OK)
+ bye("Cannot read old value %s\n", m_path.path);
+ status = char2val(&def, cp, &old_value);
+ if (status != VTWERR_OK)
+ bye("Corrupted old value ---- \n%s\n-----\n", cp);
+ res = val_cmp(&new_value, &old_value, IN_COND);
+ if (!res)
+ bye("Not in multivalue");
+ touch();
+ if (old_value.cnt) {
+ push_path(&m_path, VAL_NAME);
+ fp = fopen(m_path.path, "w");
+ if (fp == NULL)
+ bye("Can not open value file %s", m_path.path);
+ if (is_in_cond_tik()) {
+ for(delp=cp;delp && is_in_cond_tik(); dec_in_cond_tik()) {
+ delp = strchr(delp, '\n');
+ if (!delp)
+ INTERNAL;
+ ++delp; /* over \n */
+ }
+ /* write "left" of deleted */
+ fwrite(cp, 1, delp-cp, fp);
+ }else
+ delp = cp;
+ /* find end of value */
+ endp = strchr(delp, '\n');
+ if (endp && *++endp) {
+ /* write "right" of deleted */
+ fwrite(endp, 1, strlen(endp), fp);
+ /* need the final '\n' */
+ fwrite("\n", 1, 1, fp);
+ }
+ fclose(fp);
+ return 0;
+ }
+ /* it multi with only 1 value, remove */
+ remove_rf(FALSE);
+ return 0;
+ }
+ bye("There is no appropriate template for %s",
+ m_path.path + strlen(get_mdirp()));
+
+ return 0;
+}
+
diff --git a/src/set.c b/src/set.c
new file mode 100644
index 0000000..566dfe0
--- /dev/null
+++ b/src/set.c
@@ -0,0 +1,310 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <dirent.h>
+
+#include "cli_val.h"
+#include "cli_objects.h"
+#include "cli_path_utils.h"
+
+static void make_dir(void);
+static void handle_defaults(void);
+
+static void make_dir()
+{
+ touch_dir(m_path.path);
+}
+/***************************************************
+ set_validate:
+ validate value against definition
+ return TRUE if OK, FALSE otherwise
+****************************************************/
+boolean set_validate(vtw_def *defp, char *valp, boolean empty_val)
+{
+ boolean res;
+ int status;
+ struct stat statbuf;
+ char* path_end=NULL;
+
+ if (!empty_val) {
+ int i = 0;
+ int val_len = strlen(valp);
+
+ for (i = 0; i < val_len; i++) {
+ if (valp[i] == '\'') {
+ fprintf(stderr, "Cannot use the \"'\" (single quote) character "
+ "in a value string\n");
+ exit(1);
+ }
+ }
+
+ {
+ clind_path_ref tp = clind_path_construct(t_path.path);
+ if(tp) {
+ path_end=clind_path_pop_string(tp);
+ }
+ clind_path_destruct(&tp);
+ }
+
+ pop_path(&t_path); /* it was tag or real value */
+
+ }
+ push_path(&t_path, DEF_NAME);
+ if (lstat(t_path.path, &statbuf) < 0 ||
+ (statbuf.st_mode & S_IFMT) != S_IFREG) {
+ bye("Can not set value (4), no definition for %s, template %s",
+ m_path.path,t_path.path);
+ }
+ /* defniition present */
+ memset(defp, 0, sizeof(vtw_def));
+ if ((status = parse_def(defp, t_path.path, FALSE)))
+ exit(status);
+ pop_path(&t_path);
+ if(path_end) {
+ push_path(&t_path,path_end);
+ free(path_end);
+ path_end=NULL;
+ }
+ if (empty_val) {
+ if (defp->def_type != TEXT_TYPE || defp->tag || defp->multi){
+ printf("Empty string may be assigned only to TEXT type leaf node\n");
+ return FALSE;
+ }
+ return TRUE;
+ }
+ res = validate_value(defp, valp);
+ return res;
+}
+
+int main(int argc, char **argv)
+{
+
+ int ai;
+ struct stat statbuf;
+ vtw_def def;
+ boolean last_tag;
+ int status;
+ FILE *fp;
+ boolean res;
+ char *cp;
+ char *command;
+ boolean need_mod = FALSE, not_new = FALSE;
+ boolean empty_val = FALSE;
+
+ dump_log( argc, argv);
+ init_edit();
+ last_tag = FALSE;
+
+ /* extend both paths per arguments given */
+ /* last argument is new value */
+ for (ai = 1; ai < argc; ++ai) {
+ if (!*argv[ai]) { /* empty string */
+ if (ai < argc -1) {
+ bye("empty string in argument list \n");
+ }
+ empty_val = TRUE;
+ last_tag = FALSE;
+ break;
+ }
+ push_path(&t_path, argv[ai]);
+ push_path(&m_path, argv[ai]);
+ if (lstat(t_path.path, &statbuf) >= 0) {
+ if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
+ bye("INTERNAL:regular file %s in templates", t_path.path);
+ }
+ last_tag = FALSE;
+ continue;
+ } /*else */
+ pop_path(&t_path);
+ push_path(&t_path, TAG_NAME);
+ if (lstat(t_path.path, &statbuf) >= 0) {
+ if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
+ bye("INTERNAL:regular file %s in templates", t_path.path);
+ }
+ last_tag = TRUE;
+ /* every time tag match, need to verify*/
+ if(!set_validate(&def, argv[ai], FALSE)) {
+ exit(1);
+ }
+ continue;
+ }
+ /* no match */
+ break;
+ }
+
+ if (ai == argc) {
+ /* full path found */
+ /* every tag match validated already */
+ /* non tag matches are OK by definition */
+ /* do we already have it? */
+ if (lstat(m_path.path, &statbuf) >= 0)
+ bye("Already exists %s", m_path.path + strlen(get_mdirp()));
+ /* else */
+ /* prevent value node without actual value */
+ push_path(&t_path, DEF_NAME);
+ if (lstat(t_path.path, &statbuf) >= 0) {
+ memset(&def, 0, sizeof(vtw_def));
+ if ((status = parse_def(&def, t_path.path, FALSE)))
+ exit(status);
+ if (def.def_type != ERROR_TYPE && !def.tag)
+ bye("Must provide actual value\n");
+ if (def.def_type == ERROR_TYPE && !def.tag) {
+ pop_path(&t_path);
+ if(!validate_value(&def, "")) {
+ exit(1);
+ }
+ push_path(&t_path, DEF_NAME);
+ }
+ }
+ touch();
+ pop_path(&t_path);
+ make_dir();
+ handle_defaults();
+ exit(0);
+ }
+ if(ai < argc -1 || last_tag) {
+ fprintf(stderr, "There is no appropriate template for %s",
+ m_path.path + strlen(get_mdirp()));
+ exit(1);
+ }
+ /*ai == argc -1, must be actual value */
+ if (!empty_val)
+ pop_path(&m_path); /*it was value, not path segment */
+
+ if(!set_validate(&def, argv[argc-1], empty_val)) {
+ exit(1);
+ }
+ push_path(&m_path, VAL_NAME);
+ /* set value */
+ if (lstat(m_path.path, &statbuf) >= 0) {
+ valstruct new_value, old_value;
+ not_new = TRUE;
+ if ((statbuf.st_mode & S_IFMT) != S_IFREG)
+ bye("Not a regular file at path \"%s\"", m_path.path);
+ /* check if this new value */
+ status = char2val(&def, argv[argc - 1], &new_value);
+ if (status)
+ exit(0);
+ cp = NULL;
+ pop_path(&m_path); /* get_value will push VAL_NAME */
+ status = get_value(&cp, &m_path);
+ if (status != VTWERR_OK)
+ bye("Cannot read old value %s\n", m_path.path);
+ status = char2val(&def, cp, &old_value);
+ if (status != VTWERR_OK)
+ bye("Corrupted old value ---- \n%s\n-----\n", cp);
+ res = val_cmp(&new_value, &old_value, IN_COND);
+ if (res) {
+ if (def.multi) {
+ bye("Already in multivalue");
+ } else {
+ bye("The same value \"%s\" for path \"%s\"\n", cp, m_path.path);
+ }
+ }
+ } else {
+ pop_path(&m_path);
+ }
+ make_dir();
+ push_path(&m_path, VAL_NAME);
+ if(not_new && !def.multi) {
+ /* it is not multi and seen from M */
+ /* is it in C */
+ switch_path(CPATH);
+ if (lstat(m_path.path, &statbuf) < 0)
+ /* yes, we are modifying original value */
+ need_mod = TRUE;
+ switch_path(MPATH);
+ }
+ touch();
+ /* in case of multi we always append, never overwrite */
+ /* in case of single we always overwrite */
+ /* append and overwrite work the same for new file */
+ fp = fopen(m_path.path, def.multi?"a":"w");
+ if (fp == NULL)
+ bye("Can not open value file %s", m_path.path);
+ if (fputs(argv[argc-1], fp) < 0 || fputc('\n',fp) < 0)
+ bye("Error writing file %s", m_path.path);
+ if (need_mod) {
+ pop_path(&m_path); /* get rid of "value" */
+ command = my_malloc(strlen(m_path.path) + 30, "set");
+ sprintf(command, "touch %s/" MOD_NAME, m_path.path);
+ system(command);
+ }
+ return 0;
+}
+/**********************************************
+ handle_defaults:
+ now deal with defaults for children
+ if child has definition and not tag, nor multi, and
+ has type, and has default, and not have value
+ already, make a default value
+*/
+
+
+static void handle_defaults()
+{
+ DIR *dp;
+ int status;
+ struct dirent *dirp;
+ struct stat statbuf;
+ FILE *fp;
+ vtw_def def;
+ char *uename;
+
+ if ((dp = opendir(t_path.path)) == NULL){
+ INTERNAL;
+ }
+ while ((dirp = readdir(dp)) != NULL) {
+ if (strcmp(dirp->d_name, ".")==0 ||
+ strcmp(dirp->d_name, "..")==0 ||
+ strcmp(dirp->d_name, MOD_NAME) == 0 ||
+ strcmp(dirp->d_name, LOCK_NAME) == 0 ||
+ strcmp(dirp->d_name, DEF_NAME)==0)
+ continue;
+ uename = clind_unescape(dirp->d_name);
+ push_path(&t_path, uename);
+ if (lstat(t_path.path, &statbuf) < 0) {
+ bye("Cannot stat template directory %s\n",
+ t_path.path);
+ }
+ if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
+ bye("Non directory file %s\n", t_path.path);
+ }
+ push_path(&t_path, DEF_NAME);
+ if (lstat(t_path.path, &statbuf) < 0) {
+ /* no definition */
+ pop_path(&t_path); /* definition */
+ pop_path(&t_path); /* child */
+ continue;
+ }
+ memset(&def, 0, sizeof(def));
+ if ((status = parse_def(&def, t_path.path,
+ FALSE)))
+ exit(status);
+ if (def.def_default) {
+ push_path(&m_path, uename);
+ push_path(&m_path, VAL_NAME);
+ if (lstat(m_path.path, &statbuf) < 0) {
+ /* no value, write one */
+ pop_path(&m_path);
+ make_dir();/* make sure directory exist */
+ push_path(&m_path, VAL_NAME);
+ fp = fopen(m_path.path, "w");
+ if (fp == NULL)
+ bye("Can not open value file %s", m_path.path);
+ if (fputs(def.def_default, fp) < 0 ||
+ fputc('\n',fp) < 0)
+ bye("Error writing file %s", m_path.path);
+ fclose(fp);
+ }
+ pop_path(&m_path); /* value */
+ pop_path(&m_path); /* child */
+ }
+ free_def(&def);
+ pop_path(&t_path); /* definition */
+ pop_path(&t_path); /* child */
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-12 23:13:38 +0000