shell_var.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516
  1. /*
  2. * shell_var.c
  3. */
  4. #include <stdlib.h>
  5. #include <assert.h>
  6. #include <string.h>
  7. #include <ctype.h>
  8. #include "lub/string.h"
  9. #include "private.h"
  10. /*----------------------------------------------------------- */
  11. /*
  12. * search the current viewid string for a variable
  13. */
  14. void clish_shell__expand_viewid(const char *viewid, lub_bintree_t *tree,
  15. clish_context_t *context)
  16. {
  17. char *expanded;
  18. char *q, *saveptr;
  19. expanded = clish_shell_expand(viewid, SHELL_VAR_NONE, context);
  20. if (!expanded)
  21. return;
  22. for (q = strtok_r(expanded, ";", &saveptr);
  23. q; q = strtok_r(NULL, ";", &saveptr)) {
  24. char *value;
  25. clish_var_t *var;
  26. value = strchr(q, '=');
  27. if (!value)
  28. continue;
  29. *value = '\0';
  30. value++;
  31. /* Create var instance */
  32. var = clish_var_new(q);
  33. lub_bintree_insert(tree, var);
  34. clish_var__set_value(var, value);
  35. }
  36. lub_string_free(expanded);
  37. }
  38. /*----------------------------------------------------------- */
  39. /*
  40. * expand context dependent fixed-name variables
  41. */
  42. static char *find_context_var(const char *name, clish_context_t *this)
  43. {
  44. char *result = NULL;
  45. clish_shell_t *shell = this->shell;
  46. if (!shell || !shell->tinyrl)
  47. return NULL;
  48. if (!lub_string_nocasecmp(name, "_width")) {
  49. char tmp[5];
  50. snprintf(tmp, sizeof(tmp), "%u",
  51. tinyrl__get_width(shell->tinyrl));
  52. tmp[sizeof(tmp) - 1] = '\0';
  53. result = strdup(tmp);
  54. } else if (!lub_string_nocasecmp(name, "_height")) {
  55. char tmp[5];
  56. snprintf(tmp, sizeof(tmp), "%u",
  57. tinyrl__get_height(shell->tinyrl));
  58. tmp[sizeof(tmp) - 1] = '\0';
  59. result = strdup(tmp);
  60. } else if (!lub_string_nocasecmp(name, "_watchdog_timeout")) {
  61. char tmp[5];
  62. snprintf(tmp, sizeof(tmp), "%u", shell->wdog_timeout);
  63. tmp[sizeof(tmp) - 1] = '\0';
  64. result = strdup(tmp);
  65. } else if (!this->cmd) { /* The vars dependent on command */
  66. return NULL;
  67. } else if (!lub_string_nocasecmp(name, "_full_cmd")) {
  68. result = lub_string_dup(clish_command__get_name(this->cmd));
  69. } else if (!lub_string_nocasecmp(name, "_cmd")) {
  70. result = lub_string_dup(clish_command__get_name(
  71. clish_command__get_cmd(this->cmd)));
  72. } else if (!lub_string_nocasecmp(name, "_orig_cmd")) {
  73. result = lub_string_dup(clish_command__get_name(
  74. clish_command__get_orig(this->cmd)));
  75. } else if (!lub_string_nocasecmp(name, "_line")) {
  76. result = clish_shell__get_line(this);
  77. } else if (!lub_string_nocasecmp(name, "_full_line")) {
  78. result = clish_shell__get_full_line(this);
  79. } else if (!lub_string_nocasecmp(name, "_params")) {
  80. if (this->pargv)
  81. result = clish_shell__get_params(this);
  82. } else if (!lub_string_nocasecmp(name, "_interactive")) {
  83. if (clish_shell__get_interactive(this->shell))
  84. result = strdup("1");
  85. else
  86. result = strdup("0");
  87. } else if (!lub_string_nocasecmp(name, "_isatty")) {
  88. if (tinyrl__get_isatty(this->shell->tinyrl))
  89. result = strdup("1");
  90. else
  91. result = strdup("0");
  92. } else if (lub_string_nocasestr(name, "_prefix") == name) {
  93. int idx = 0;
  94. int pnum = 0;
  95. pnum = lub_argv_wordcount(clish_command__get_name(this->cmd)) -
  96. lub_argv_wordcount(clish_command__get_name(
  97. clish_command__get_cmd(this->cmd)));
  98. idx = atoi(name + strlen("_prefix"));
  99. if (idx < pnum) {
  100. lub_argv_t *argv = lub_argv_new(
  101. clish_command__get_name(this->cmd), 0);
  102. result = lub_string_dup(lub_argv__get_arg(argv, idx));
  103. lub_argv_delete(argv);
  104. }
  105. } else if (!lub_string_nocasecmp(name, "_cur_depth")) {
  106. char tmp[10];
  107. int depth = clish_shell__get_depth(shell);
  108. snprintf(tmp, sizeof(tmp), "%u", depth);
  109. tmp[sizeof(tmp) - 1] = '\0';
  110. result = strdup(tmp);
  111. } else if (!lub_string_nocasecmp(name, "_cur_pwd")) {
  112. int depth = clish_shell__get_depth(shell);
  113. result = clish_shell__get_pwd_full(shell, depth);
  114. }
  115. return result;
  116. }
  117. /*--------------------------------------------------------- */
  118. static char *find_var(const char *name, lub_bintree_t *tree, clish_context_t *context)
  119. {
  120. clish_var_t *var = lub_bintree_find(tree, name);
  121. char *value;
  122. bool_t dynamic;
  123. char *res = NULL;
  124. if (!var)
  125. return NULL;
  126. /* Try to get saved value for static var */
  127. dynamic = clish_var__get_dynamic(var);
  128. if (!dynamic) {
  129. char *saved = clish_var__get_saved(var);
  130. if (saved)
  131. return lub_string_dup(saved);
  132. }
  133. /* Try to expand value field */
  134. value = clish_var__get_value(var);
  135. if (value)
  136. res = clish_shell_expand(value, SHELL_VAR_NONE, context);
  137. /* Try to execute ACTION */
  138. if (!res) {
  139. char *out = NULL;
  140. clish_action_t *action = clish_var__get_action(var);
  141. if (clish_shell_exec_action(action, context, &out)) {
  142. lub_string_free(out);
  143. return NULL;
  144. }
  145. res = out;
  146. }
  147. /* Save value for static var */
  148. if (!dynamic && res)
  149. clish_var__set_saved(var, res);
  150. return res;
  151. }
  152. /*--------------------------------------------------------- */
  153. static char *find_global_var(const char *name, clish_context_t *context)
  154. {
  155. return find_var(name, &context->shell->var_tree, context);
  156. }
  157. /*--------------------------------------------------------- */
  158. static char *find_viewid_var(const char *name, clish_context_t *context)
  159. {
  160. int depth = clish_shell__get_depth(context->shell);
  161. if (depth < 0)
  162. return NULL;
  163. return find_var(name, &context->shell->pwdv[depth]->viewid, context);
  164. }
  165. static char * chardiff(const char *syms, const char *minus)
  166. {
  167. char *dst = malloc(strlen(syms) + 1);
  168. char *p = dst;
  169. const char *src;
  170. for (src = syms; *src; src++) {
  171. if (!strchr(minus, *src))
  172. *(p++) = *src;
  173. }
  174. *p = '\0';
  175. return dst;
  176. }
  177. /*--------------------------------------------------------- */
  178. /*
  179. * return the next segment of text from the provided string
  180. * segments are delimited by variables within the string.
  181. */
  182. static char *expand_nextsegment(const char **string, const char *escape_chars,
  183. clish_context_t *this)
  184. {
  185. const char *p = *string;
  186. char *result = NULL;
  187. size_t len = 0;
  188. if (!p)
  189. return NULL;
  190. if (*p && (p[0] == '$') && (p[1] == '{')) {
  191. /* start of a variable */
  192. const char *tmp;
  193. p += 2;
  194. tmp = p;
  195. /*
  196. * find the end of the variable
  197. */
  198. while (*p && p++[0] != '}')
  199. len++;
  200. /* ignore non-terminated variables */
  201. if (p[-1] == '}') {
  202. bool_t valid = BOOL_FALSE;
  203. char *text, *q;
  204. char *saveptr;
  205. /* get the variable text */
  206. text = lub_string_dupn(tmp, len);
  207. /*
  208. * tokenise this INTO ':' separated words
  209. * and either expand or duplicate into the result string.
  210. * Only return a result if at least
  211. * of the words is an expandable variable
  212. */
  213. for (q = strtok_r(text, ":", &saveptr);
  214. q; q = strtok_r(NULL, ":", &saveptr)) {
  215. char *var;
  216. int mod_quote = 0; /* quote modifier */
  217. int mod_esc = 0; /* internal escape modifier */
  218. int mod_esc_chars = 1; /* escaping */
  219. int mod_esc_dec = 0; /* remove internal chars from escaping */
  220. char *space;
  221. char *all_esc = NULL;
  222. /* Search for modifiers */
  223. while (*q && !isalpha(*q)) {
  224. if ('#' == *q) {
  225. mod_quote = 1;
  226. mod_esc = 1;
  227. } else if ('\\' == *q) {
  228. mod_esc = 1;
  229. } else if ('!' == *q) {
  230. mod_quote = 1;
  231. mod_esc = 1;
  232. mod_esc_chars = 0;
  233. } else if ('~' == *q) {
  234. mod_esc = 1;
  235. mod_esc_chars = 0;
  236. /* Internal automatic variable like ${__line} */
  237. } else if (('_' == *q) && ('_' == *(q+1))) {
  238. mod_esc_dec = 1;
  239. q++;
  240. break;
  241. /* No escaping at all. Usefull for macros VAR */
  242. } else if ('^' == *q) {
  243. mod_quote = 0;
  244. mod_esc = 0;
  245. mod_esc_chars = 0;
  246. } else
  247. break;
  248. q++;
  249. }
  250. /* Get clean variable value */
  251. var = clish_shell_expand_var(q, this);
  252. if (!var) {
  253. lub_string_cat(&result, q);
  254. continue;
  255. }
  256. valid = BOOL_TRUE;
  257. /* Quoting */
  258. if (mod_quote)
  259. space = strchr(var, ' ');
  260. if (mod_quote && space)
  261. lub_string_cat(&result, "\"");
  262. /* Escape special chars */
  263. if (escape_chars && mod_esc_chars) {
  264. /* Remove internal esc from escape chars */
  265. if (mod_esc_dec)
  266. all_esc = chardiff(escape_chars,
  267. lub_string_esc_quoted);
  268. else
  269. all_esc = lub_string_dup(escape_chars);
  270. }
  271. /* Internal escaping */
  272. if (mod_esc)
  273. lub_string_cat(&all_esc,
  274. lub_string_esc_quoted);
  275. /* Real escaping */
  276. if (all_esc) {
  277. char *tstr = lub_string_encode(var,
  278. all_esc);
  279. lub_string_free(var);
  280. var = tstr;
  281. lub_string_free(all_esc);
  282. }
  283. /* copy the expansion or the raw word */
  284. lub_string_cat(&result, var);
  285. /* Quoting */
  286. if (mod_quote && space)
  287. lub_string_cat(&result, "\"");
  288. lub_string_free(var);
  289. }
  290. if (!valid) {
  291. /* not a valid variable expansion */
  292. lub_string_free(result);
  293. result = lub_string_dup("");
  294. }
  295. /* finished with the variable text */
  296. lub_string_free(text);
  297. }
  298. } else {
  299. /* find the start of a variable */
  300. while (*p) {
  301. if ((p[0] == '$') && (p[1] == '{'))
  302. break;
  303. len++;
  304. p++;
  305. }
  306. if (len > 0)
  307. result = lub_string_dupn(*string, len);
  308. }
  309. /* move the string pointer on for next time... */
  310. *string = p;
  311. return result;
  312. }
  313. /*--------------------------------------------------------- */
  314. /*
  315. * This function builds a dynamic string based on that provided
  316. * subtituting each occurance of a "${FRED}" type variable sub-string
  317. * with the appropriate value.
  318. */
  319. char *clish_shell_expand(const char *str, clish_shell_var_t vtype, clish_context_t *context)
  320. {
  321. char *seg, *result = NULL;
  322. const char *escape_chars = NULL;
  323. const clish_command_t *cmd = context->cmd;
  324. /* Escape special characters */
  325. if (SHELL_VAR_REGEX == vtype) {
  326. if (cmd)
  327. escape_chars = clish_command__get_regex_chars(cmd);
  328. if (!escape_chars)
  329. escape_chars = lub_string_esc_regex;
  330. } else if (SHELL_VAR_ACTION == vtype) {
  331. if (cmd)
  332. escape_chars = clish_command__get_escape_chars(cmd);
  333. if (!escape_chars)
  334. escape_chars = lub_string_esc_default;
  335. }
  336. /* read each segment and extend the result */
  337. while ((seg = expand_nextsegment(&str, escape_chars, context))) {
  338. lub_string_cat(&result, seg);
  339. lub_string_free(seg);
  340. }
  341. return result;
  342. }
  343. /*--------------------------------------------------------- */
  344. char *clish_shell__get_params(clish_context_t *context)
  345. {
  346. clish_pargv_t *pargv = context->pargv;
  347. char *line = NULL;
  348. unsigned i, cnt;
  349. const clish_param_t *param;
  350. const clish_parg_t *parg;
  351. char *request = NULL;
  352. if (!pargv)
  353. return NULL;
  354. cnt = clish_pargv__get_count(pargv);
  355. for (i = 0; i < cnt; i++) {
  356. param = clish_pargv__get_param(pargv, i);
  357. if (clish_param__get_hidden(param))
  358. continue;
  359. parg = clish_pargv__get_parg(pargv, i);
  360. if (request)
  361. lub_string_cat(&request, " ");
  362. lub_string_cat(&request, "${!");
  363. lub_string_cat(&request, clish_parg__get_name(parg));
  364. lub_string_cat(&request, "}");
  365. }
  366. line = clish_shell_expand(request, SHELL_VAR_NONE, context);
  367. lub_string_free(request);
  368. return line;
  369. }
  370. /*--------------------------------------------------------- */
  371. static char *internal_get_line(clish_context_t *context, int cmd_type)
  372. {
  373. const clish_command_t *cmd = context->cmd;
  374. clish_pargv_t *pargv = context->pargv;
  375. char *line = NULL;
  376. char *params = NULL;
  377. if (0 == cmd_type) /* __cmd */
  378. lub_string_cat(&line, clish_command__get_name(
  379. clish_command__get_cmd(cmd)));
  380. else /* __full_cmd */
  381. lub_string_cat(&line, clish_command__get_name(cmd));
  382. if (!pargv)
  383. return line;
  384. params = clish_shell__get_params(context);
  385. if (params) {
  386. lub_string_cat(&line, " ");
  387. lub_string_cat(&line, params);
  388. }
  389. lub_string_free(params);
  390. return line;
  391. }
  392. /*--------------------------------------------------------- */
  393. char *clish_shell__get_line(clish_context_t *context)
  394. {
  395. return internal_get_line(context, 0); /* __cmd */
  396. }
  397. /*--------------------------------------------------------- */
  398. char *clish_shell__get_full_line(clish_context_t *context)
  399. {
  400. return internal_get_line(context, 1); /* __full_cmd */
  401. }
  402. /*--------------------------------------------------------- */
  403. char *clish_shell_expand_var(const char *name, clish_context_t *context)
  404. {
  405. clish_shell_t *this;
  406. const clish_command_t *cmd;
  407. clish_pargv_t *pargv;
  408. const char *tmp = NULL;
  409. char *string = NULL;
  410. assert(name);
  411. if (!context)
  412. return NULL;
  413. this = context->shell;
  414. cmd = context->cmd;
  415. pargv = context->pargv;
  416. /* try and substitute a parameter value */
  417. if (pargv) {
  418. const clish_parg_t *parg = clish_pargv_find_arg(pargv, name);
  419. if (parg)
  420. tmp = clish_parg__get_value(parg);
  421. }
  422. /* try and substitute the param's default */
  423. if (!tmp && cmd)
  424. tmp = clish_paramv_find_default(
  425. clish_command__get_paramv(cmd), name);
  426. /* try and substitute a viewId variable */
  427. if (!tmp && this)
  428. tmp = string = find_viewid_var(name, context);
  429. /* try and substitute context fixed variable */
  430. if (!tmp)
  431. tmp = string = find_context_var(name, context);
  432. /* try and substitute a global var value */
  433. if (!tmp && this)
  434. tmp = string = find_global_var(name, context);
  435. /* get the contents of an environment variable */
  436. if (!tmp)
  437. tmp = getenv(name);
  438. if (string)
  439. return string;
  440. return lub_string_dup(tmp);
  441. }
  442. /*----------------------------------------------------------- */