1
0

shell_xml.c 34 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312
  1. /*
  2. * ------------------------------------------------------
  3. * shell_xml.c
  4. *
  5. * This file implements the means to read an XML encoded file and populate the
  6. * CLI tree based on the contents.
  7. * ------------------------------------------------------
  8. */
  9. #include "private.h"
  10. #include "xmlapi.h"
  11. #include "lub/string.h"
  12. #include "lub/ctype.h"
  13. #include "lub/system.h"
  14. #include "lub/conv.h"
  15. #include <stdlib.h>
  16. #include <string.h>
  17. #include <assert.h>
  18. #include <errno.h>
  19. #include <sys/types.h>
  20. #include <dirent.h>
  21. typedef int (PROCESS_FN) (clish_shell_t *instance,
  22. clish_xmlnode_t *element, void *parent);
  23. /* Define a control block for handling the decode of an XML file */
  24. typedef struct clish_xml_cb_s clish_xml_cb_t;
  25. struct clish_xml_cb_s {
  26. const char *element;
  27. PROCESS_FN *handler;
  28. };
  29. /* forward declare the handler functions */
  30. static PROCESS_FN
  31. process_clish_module,
  32. process_startup,
  33. process_view,
  34. process_command,
  35. process_param,
  36. process_action,
  37. process_ptype,
  38. process_overview,
  39. process_detail,
  40. process_namespace,
  41. process_config,
  42. process_var,
  43. process_wdog,
  44. process_hotkey,
  45. process_plugin,
  46. process_hook;
  47. static clish_xml_cb_t xml_elements[] = {
  48. {"CLISH_MODULE", process_clish_module},
  49. {"STARTUP", process_startup},
  50. {"VIEW", process_view},
  51. {"COMMAND", process_command},
  52. {"PARAM", process_param},
  53. {"ACTION", process_action},
  54. {"PTYPE", process_ptype},
  55. {"OVERVIEW", process_overview},
  56. {"DETAIL", process_detail},
  57. {"NAMESPACE", process_namespace},
  58. {"CONFIG", process_config},
  59. {"VAR", process_var},
  60. {"WATCHDOG", process_wdog},
  61. {"HOTKEY", process_hotkey},
  62. {"PLUGIN", process_plugin},
  63. {"HOOK", process_hook},
  64. {NULL, NULL}
  65. };
  66. /*
  67. * if CLISH_PATH is unset in the environment then this is the value used.
  68. */
  69. const char *default_path = "/etc/clish;~/.clish";
  70. static int process_node(clish_shell_t *shell, clish_xmlnode_t *node,
  71. void *parent);
  72. /*-------------------------------------------------------- */
  73. int clish_shell_load_scheme(clish_shell_t *this, const char *xml_path, const char *xslt_path)
  74. {
  75. const char *path = xml_path;
  76. char *buffer;
  77. char *dirname;
  78. char *saveptr = NULL;
  79. int res = -1;
  80. clish_xmldoc_t *doc = NULL;
  81. DIR *dir;
  82. #ifdef HAVE_LIB_LIBXSLT
  83. clish_xslt_t *xslt = NULL;
  84. /* Load global XSLT stylesheet */
  85. if (xslt_path) {
  86. xslt = clish_xslt_read(xslt_path);
  87. if (!clish_xslt_is_valid(xslt)) {
  88. fprintf(stderr, CLISH_XML_ERROR_STR"Can't load XSLT file %s\n",
  89. xslt_path);
  90. return -1;
  91. }
  92. }
  93. #else
  94. xslt_path = xslt_path; /* Happy compiler */
  95. #endif
  96. /* Use the default path */
  97. if (!path)
  98. path = default_path;
  99. buffer = lub_system_tilde_expand(path);
  100. /* Loop though each directory */
  101. for (dirname = strtok_r(buffer, ";", &saveptr);
  102. dirname; dirname = strtok_r(NULL, ";", &saveptr)) {
  103. struct dirent *entry;
  104. /* Search this directory for any XML files */
  105. dir = opendir(dirname);
  106. if (NULL == dir) {
  107. #ifdef DEBUG
  108. tinyrl_printf(this->tinyrl,
  109. "*** Failed to open '%s' directory\n",
  110. dirname);
  111. #endif
  112. continue;
  113. }
  114. for (entry = readdir(dir); entry; entry = readdir(dir)) {
  115. const char *extension = strrchr(entry->d_name, '.');
  116. char *filename = NULL;
  117. clish_xmlnode_t *root;
  118. int r;
  119. /* Check the filename */
  120. if (!extension || strcmp(".xml", extension))
  121. continue;
  122. /* Build the filename */
  123. lub_string_cat(&filename, dirname);
  124. lub_string_cat(&filename, "/");
  125. lub_string_cat(&filename, entry->d_name);
  126. #ifdef DEBUG
  127. fprintf(stderr, "Parse XML-file: %s\n", filename);
  128. #endif
  129. /* Load current XML file */
  130. doc = clish_xmldoc_read(filename);
  131. if (!clish_xmldoc_is_valid(doc)) {
  132. int errcaps = clish_xmldoc_error_caps(doc);
  133. printf("Unable to open file '%s'", filename);
  134. if ((errcaps & CLISH_XMLERR_LINE) == CLISH_XMLERR_LINE)
  135. printf(", at line %d", clish_xmldoc_get_err_line(doc));
  136. if ((errcaps & CLISH_XMLERR_COL) == CLISH_XMLERR_COL)
  137. printf(", at column %d", clish_xmldoc_get_err_col(doc));
  138. if ((errcaps & CLISH_XMLERR_DESC) == CLISH_XMLERR_DESC)
  139. printf(", message is %s", clish_xmldoc_get_err_msg(doc));
  140. printf("\n");
  141. goto error;
  142. }
  143. #ifdef HAVE_LIB_LIBXSLT
  144. /* Use embedded stylesheet if stylesheet
  145. * filename is not specified.
  146. */
  147. if (!xslt_path)
  148. xslt = clish_xslt_read_embedded(doc);
  149. if (clish_xslt_is_valid(xslt)) {
  150. clish_xmldoc_t *tmp = NULL;
  151. tmp = clish_xslt_apply(doc, xslt);
  152. if (!clish_xmldoc_is_valid(tmp)) {
  153. fprintf(stderr, CLISH_XML_ERROR_STR"Can't load XSLT file %s\n", xslt_path);
  154. goto error;
  155. }
  156. clish_xmldoc_release(doc);
  157. doc = tmp;
  158. }
  159. if (!xslt_path && clish_xslt_is_valid(xslt))
  160. clish_xslt_release(xslt);
  161. #endif
  162. root = clish_xmldoc_get_root(doc);
  163. r = process_node(this, root, NULL);
  164. clish_xmldoc_release(doc);
  165. /* Error message */
  166. if (r) {
  167. fprintf(stderr, CLISH_XML_ERROR_STR"File %s\n",
  168. filename);
  169. lub_string_free(filename);
  170. goto error;
  171. }
  172. lub_string_free(filename);
  173. }
  174. closedir(dir);
  175. }
  176. /* To don't free memory twice on cleanup */
  177. #ifdef HAVE_LIB_LIBXSLT
  178. if (!xslt_path)
  179. xslt = NULL;
  180. #endif
  181. doc = NULL;
  182. dir = NULL;
  183. res = 0; /* Success */
  184. error:
  185. lub_string_free(buffer);
  186. if (dir)
  187. closedir(dir);
  188. if (clish_xmldoc_is_valid(doc))
  189. clish_xmldoc_release(doc);
  190. #ifdef HAVE_LIB_LIBXSLT
  191. if (clish_xslt_is_valid(xslt))
  192. clish_xslt_release(xslt);
  193. #endif
  194. return res;
  195. }
  196. /*
  197. * ------------------------------------------------------
  198. * This function reads an element from the XML stream and processes it.
  199. * ------------------------------------------------------
  200. */
  201. static int process_node(clish_shell_t *shell, clish_xmlnode_t *node,
  202. void *parent)
  203. {
  204. int res = 0;
  205. switch (clish_xmlnode_get_type(node)) {
  206. case CLISH_XMLNODE_ELM: {
  207. clish_xml_cb_t * cb;
  208. char name[128];
  209. unsigned int namelen = sizeof(name);
  210. if (clish_xmlnode_get_name(node, name, &namelen) == 0) {
  211. for (cb = &xml_elements[0]; cb->element; cb++) {
  212. if (0 == strcmp(name, cb->element)) {
  213. #ifdef DEBUG
  214. fprintf(stderr, "NODE:");
  215. clish_xmlnode_print(node, stderr);
  216. fprintf(stderr, "\n");
  217. #endif
  218. /* process the elements at this level */
  219. res = cb->handler(shell, node, parent);
  220. /* Error message */
  221. if (res) {
  222. char *ename = clish_xmlnode_fetch_attr(node, "name");
  223. char *eref = clish_xmlnode_fetch_attr(node, "ref");
  224. char *ekey = clish_xmlnode_fetch_attr(node, "key");
  225. char *efile = clish_xmlnode_fetch_attr(node, "file");
  226. fprintf(stderr, CLISH_XML_ERROR_STR"Node %s", name);
  227. if (ename)
  228. fprintf(stderr, ", name=\"%s\"", ename);
  229. if (eref)
  230. fprintf(stderr, ", ref=\"%s\"", eref);
  231. if (ekey)
  232. fprintf(stderr, ", key=\"%s\"", ekey);
  233. if (efile)
  234. fprintf(stderr, ", file=\"%s\"", efile);
  235. fprintf(stderr, "\n");
  236. clish_xml_release(ename);
  237. clish_xml_release(eref);
  238. clish_xml_release(ekey);
  239. clish_xml_release(efile);
  240. }
  241. break;
  242. }
  243. }
  244. }
  245. break;
  246. }
  247. case CLISH_XMLNODE_DOC:
  248. case CLISH_XMLNODE_TEXT:
  249. case CLISH_XMLNODE_ATTR:
  250. case CLISH_XMLNODE_PI:
  251. case CLISH_XMLNODE_COMMENT:
  252. case CLISH_XMLNODE_DECL:
  253. case CLISH_XMLNODE_UNKNOWN:
  254. default:
  255. break;
  256. }
  257. return res;
  258. }
  259. /* ------------------------------------------------------ */
  260. static int process_children(clish_shell_t *shell,
  261. clish_xmlnode_t *element, void *parent)
  262. {
  263. clish_xmlnode_t *node = NULL;
  264. int res;
  265. while ((node = clish_xmlnode_next_child(element, node)) != NULL) {
  266. /* Now deal with all the contained elements */
  267. res = process_node(shell, node, parent);
  268. if (res)
  269. return res;
  270. }
  271. return 0;
  272. }
  273. /* ------------------------------------------------------ */
  274. static int process_clish_module(clish_shell_t *shell, clish_xmlnode_t *element,
  275. void *parent)
  276. {
  277. /* Create the global view */
  278. if (!shell->global)
  279. shell->global = clish_shell_find_create_view(shell, "__view_global");
  280. parent = parent; /* Happy compiler */
  281. return process_children(shell, element, shell->global);
  282. }
  283. /* ------------------------------------------------------ */
  284. static int process_view(clish_shell_t *shell, clish_xmlnode_t *element,
  285. void *parent)
  286. {
  287. clish_view_t *view;
  288. int res = -1;
  289. char *name = clish_xmlnode_fetch_attr(element, "name");
  290. char *prompt = clish_xmlnode_fetch_attr(element, "prompt");
  291. char *depth = clish_xmlnode_fetch_attr(element, "depth");
  292. char *restore = clish_xmlnode_fetch_attr(element, "restore");
  293. char *access = clish_xmlnode_fetch_attr(element, "access");
  294. /* Check syntax */
  295. if (!name) {
  296. fprintf(stderr, CLISH_XML_ERROR_ATTR("name"));
  297. goto error;
  298. }
  299. /* re-use a view if it already exists */
  300. view = clish_shell_find_create_view(shell, name);
  301. if (prompt)
  302. clish_view__set_prompt(view, prompt);
  303. if (depth && (lub_ctype_isdigit(*depth))) {
  304. unsigned int res = 0;
  305. lub_conv_atoui(depth, &res, 0);
  306. clish_view__set_depth(view, res);
  307. }
  308. if (restore) {
  309. if (!lub_string_nocasecmp(restore, "depth"))
  310. clish_view__set_restore(view, CLISH_RESTORE_DEPTH);
  311. else if (!lub_string_nocasecmp(restore, "view"))
  312. clish_view__set_restore(view, CLISH_RESTORE_VIEW);
  313. else
  314. clish_view__set_restore(view, CLISH_RESTORE_NONE);
  315. }
  316. if (access)
  317. clish_view__set_access(view, access);
  318. //process_view_end:
  319. res = process_children(shell, element, view);
  320. error:
  321. clish_xml_release(name);
  322. clish_xml_release(prompt);
  323. clish_xml_release(depth);
  324. clish_xml_release(restore);
  325. clish_xml_release(access);
  326. parent = parent; /* Happy compiler */
  327. return res;
  328. }
  329. /* ------------------------------------------------------ */
  330. static int process_ptype(clish_shell_t *shell, clish_xmlnode_t *element,
  331. void *parent)
  332. {
  333. clish_ptype_method_e method;
  334. clish_ptype_preprocess_e preprocess;
  335. int res = -1;
  336. clish_ptype_t *ptype;
  337. char *name = clish_xmlnode_fetch_attr(element, "name");
  338. char *help = clish_xmlnode_fetch_attr(element, "help");
  339. char *pattern = clish_xmlnode_fetch_attr(element, "pattern");
  340. char *method_name = clish_xmlnode_fetch_attr(element, "method");
  341. char *preprocess_name = clish_xmlnode_fetch_attr(element, "preprocess");
  342. /* Check syntax */
  343. if (!name) {
  344. fprintf(stderr, CLISH_XML_ERROR_ATTR("name"));
  345. goto error;
  346. }
  347. method = clish_ptype_method_resolve(method_name);
  348. if (CLISH_PTYPE_METHOD_MAX == method) {
  349. fprintf(stderr, CLISH_XML_ERROR_ATTR("method"));
  350. goto error;
  351. }
  352. if ((method != CLISH_PTYPE_METHOD_CODE) && !pattern) {
  353. fprintf(stderr, CLISH_XML_ERROR_ATTR("pattern"));
  354. goto error;
  355. }
  356. preprocess = clish_ptype_preprocess_resolve(preprocess_name);
  357. ptype = clish_shell_find_create_ptype(shell,
  358. name, help, pattern, method, preprocess);
  359. res = process_children(shell, element, ptype);
  360. error:
  361. clish_xml_release(name);
  362. clish_xml_release(help);
  363. clish_xml_release(pattern);
  364. clish_xml_release(method_name);
  365. clish_xml_release(preprocess_name);
  366. parent = parent; /* Happy compiler */
  367. return res;
  368. }
  369. /* ------------------------------------------------------ */
  370. static int process_overview(clish_shell_t *shell, clish_xmlnode_t *element,
  371. void *parent)
  372. {
  373. char *content = NULL;
  374. unsigned int content_len = 2048;
  375. int result;
  376. /*
  377. * the code below faithfully assume that we'll be able fully store
  378. * the content of the node. If it's really, really big, we may have
  379. * an issue (but then, if it's that big, how the hell does it
  380. * already fits in allocated memory?)
  381. * Ergo, it -should- be safe.
  382. */
  383. do {
  384. char *new = (char*)realloc(content, content_len);
  385. if (!new) {
  386. if (content)
  387. free(content);
  388. return -1;
  389. }
  390. content = new;
  391. result = clish_xmlnode_get_content(element, content,
  392. &content_len);
  393. } while (result == -E2BIG);
  394. if (result == 0 && content) {
  395. /* set the overview text for this view */
  396. assert(NULL == shell->overview);
  397. /* store the overview */
  398. shell->overview = lub_string_dup(content);
  399. }
  400. if (content)
  401. free(content);
  402. parent = parent; /* Happy compiler */
  403. return 0;
  404. }
  405. /* ------------------------------------------------------ */
  406. static int process_command(clish_shell_t *shell, clish_xmlnode_t *element,
  407. void *parent)
  408. {
  409. clish_view_t *v = (clish_view_t *) parent;
  410. clish_command_t *cmd = NULL;
  411. int res = -1;
  412. char *access = clish_xmlnode_fetch_attr(element, "access");
  413. char *name = clish_xmlnode_fetch_attr(element, "name");
  414. char *help = clish_xmlnode_fetch_attr(element, "help");
  415. char *view = clish_xmlnode_fetch_attr(element, "view");
  416. char *viewid = clish_xmlnode_fetch_attr(element, "viewid");
  417. char *escape_chars = clish_xmlnode_fetch_attr(element, "escape_chars");
  418. char *args_name = clish_xmlnode_fetch_attr(element, "args");
  419. char *args_help = clish_xmlnode_fetch_attr(element, "args_help");
  420. char *ref = clish_xmlnode_fetch_attr(element, "ref");
  421. #ifdef LEGACY
  422. char *lock = clish_xmlnode_fetch_attr(element, "lock");
  423. char *interrupt = clish_xmlnode_fetch_attr(element, "interrupt");
  424. clish_action_t *action;
  425. #endif
  426. /* Check syntax */
  427. if (!name) {
  428. fprintf(stderr, CLISH_XML_ERROR_ATTR("name"));
  429. goto error;
  430. }
  431. if (!help) {
  432. fprintf(stderr, CLISH_XML_ERROR_ATTR("help"));
  433. goto error;
  434. }
  435. /* Create a command with unique name */
  436. cmd = clish_view_new_command(v, name, help);
  437. if (!cmd) {
  438. fprintf(stderr, CLISH_XML_ERROR_STR"Duplicate COMMAND name=\"%s\".\n", name);
  439. goto error;
  440. }
  441. /* Reference 'ref' field */
  442. if (ref) {
  443. char *saveptr = NULL;
  444. const char *delim = "@";
  445. char *view_name = NULL;
  446. char *cmdn = NULL;
  447. char *str = lub_string_dup(ref);
  448. cmdn = strtok_r(str, delim, &saveptr);
  449. if (!cmdn) {
  450. fprintf(stderr, CLISH_XML_ERROR_STR"Invalid \"ref\" attribute value.\n");
  451. lub_string_free(str);
  452. goto error;
  453. }
  454. clish_command__set_alias(cmd, cmdn); /* alias name */
  455. view_name = strtok_r(NULL, delim, &saveptr);
  456. clish_command__set_alias_view(cmd, view_name);
  457. lub_string_free(str);
  458. }
  459. /* define some specialist escape characters */
  460. if (escape_chars)
  461. clish_command__set_escape_chars(cmd, escape_chars);
  462. if (args_name) {
  463. /* define a "rest of line" argument */
  464. clish_param_t *param;
  465. /* Check syntax */
  466. if (!args_help) {
  467. fprintf(stderr, CLISH_XML_ERROR_ATTR("args_help"));
  468. goto error;
  469. }
  470. param = clish_param_new(args_name, args_help, "__ptype_ARGS");
  471. clish_command__set_args(cmd, param);
  472. }
  473. /* define the view which this command changes to */
  474. if (view) {
  475. /* reference the next view */
  476. clish_command__set_viewname(cmd, view);
  477. }
  478. /* define the view id which this command changes to */
  479. if (viewid)
  480. clish_command__set_viewid(cmd, viewid);
  481. #ifdef LEGACY
  482. action = clish_command__get_action(cmd);
  483. /* lock */
  484. if (lock) { // Don't change anything if lock is not specified
  485. if (lub_string_nocasecmp(lock, "false") == 0)
  486. clish_action__set_lock(action, BOOL_FALSE);
  487. else
  488. clish_action__set_lock(action, BOOL_TRUE);
  489. }
  490. /* interrupt */
  491. if (interrupt) { // Don't change anything if lock is not specified
  492. if (lub_string_nocasecmp(interrupt, "true") == 0)
  493. clish_action__set_interrupt(action, BOOL_TRUE);
  494. else
  495. clish_action__set_interrupt(action, BOOL_FALSE);
  496. }
  497. #endif
  498. if (access)
  499. clish_command__set_access(cmd, access);
  500. //process_command_end:
  501. res = process_children(shell, element, cmd);
  502. error:
  503. clish_xml_release(access);
  504. clish_xml_release(name);
  505. clish_xml_release(help);
  506. clish_xml_release(view);
  507. clish_xml_release(viewid);
  508. clish_xml_release(escape_chars);
  509. clish_xml_release(args_name);
  510. clish_xml_release(args_help);
  511. clish_xml_release(ref);
  512. #ifdef LEGACY
  513. clish_xml_release(lock);
  514. clish_xml_release(interrupt);
  515. #endif
  516. return res;
  517. }
  518. /* ------------------------------------------------------ */
  519. static int process_startup(clish_shell_t *shell, clish_xmlnode_t *element,
  520. void *parent)
  521. {
  522. clish_command_t *cmd = NULL;
  523. int res = -1;
  524. char *view = clish_xmlnode_fetch_attr(element, "view");
  525. char *viewid = clish_xmlnode_fetch_attr(element, "viewid");
  526. char *default_shebang =
  527. clish_xmlnode_fetch_attr(element, "default_shebang");
  528. char *timeout = clish_xmlnode_fetch_attr(element, "timeout");
  529. char *default_plugin = clish_xmlnode_fetch_attr(element,
  530. "default_plugin");
  531. #ifdef LEGACY
  532. char *lock = clish_xmlnode_fetch_attr(element, "lock");
  533. char *interrupt = clish_xmlnode_fetch_attr(element, "interrupt");
  534. clish_action_t *action;
  535. #endif
  536. /* Check syntax */
  537. if (!view) {
  538. fprintf(stderr, CLISH_XML_ERROR_ATTR("view"));
  539. goto error;
  540. }
  541. if (shell->startup) {
  542. fprintf(stderr, CLISH_XML_ERROR_STR"STARTUP tag duplication.\n");
  543. goto error;
  544. }
  545. /* create a command with NULL help */
  546. cmd = clish_command_new("startup", NULL);
  547. clish_command__set_internal(cmd, BOOL_TRUE);
  548. /* reference the next view */
  549. clish_command__set_viewname(cmd, view);
  550. /* define the view id which this command changes to */
  551. if (viewid)
  552. clish_command__set_viewid(cmd, viewid);
  553. if (default_shebang)
  554. clish_shell__set_default_shebang(shell, default_shebang);
  555. if (timeout) {
  556. unsigned int to = 0;
  557. lub_conv_atoui(timeout, &to, 0);
  558. clish_shell__set_idle_timeout(shell, to);
  559. }
  560. #ifdef LEGACY
  561. action = clish_command__get_action(cmd);
  562. /* lock */
  563. if (lock) { // Don't change anything if lock is not specified
  564. if (lub_string_nocasecmp(lock, "false") == 0)
  565. clish_action__set_lock(action, BOOL_FALSE);
  566. else
  567. clish_action__set_lock(action, BOOL_TRUE);
  568. }
  569. /* interrupt */
  570. if (interrupt) { // Don't change anything if lock is not specified
  571. if (lub_string_nocasecmp(interrupt, "true") == 0)
  572. clish_action__set_interrupt(action, BOOL_TRUE);
  573. else
  574. clish_action__set_interrupt(action, BOOL_FALSE);
  575. }
  576. #endif
  577. /* If we need the default plugin */
  578. if (default_plugin && (0 == strcmp(default_plugin, "false")))
  579. shell->default_plugin = BOOL_FALSE;
  580. /* remember this command */
  581. shell->startup = cmd;
  582. res = process_children(shell, element, cmd);
  583. error:
  584. clish_xml_release(view);
  585. clish_xml_release(viewid);
  586. clish_xml_release(default_shebang);
  587. clish_xml_release(timeout);
  588. #ifdef LEGACY
  589. clish_xml_release(lock);
  590. clish_xml_release(interrupt);
  591. #endif
  592. return res;
  593. }
  594. /* ------------------------------------------------------ */
  595. static int process_param(clish_shell_t *shell, clish_xmlnode_t *element,
  596. void *parent)
  597. {
  598. clish_command_t *cmd = NULL;
  599. clish_param_t *p_param = NULL;
  600. clish_xmlnode_t *pelement;
  601. clish_param_t *param;
  602. char *pname;
  603. int res = -1;
  604. char *name = clish_xmlnode_fetch_attr(element, "name");
  605. char *help = clish_xmlnode_fetch_attr(element, "help");
  606. char *ptype = clish_xmlnode_fetch_attr(element, "ptype");
  607. char *prefix = clish_xmlnode_fetch_attr(element, "prefix");
  608. char *defval = clish_xmlnode_fetch_attr(element, "default");
  609. char *mode = clish_xmlnode_fetch_attr(element, "mode");
  610. char *optional = clish_xmlnode_fetch_attr(element, "optional");
  611. char *order = clish_xmlnode_fetch_attr(element, "order");
  612. char *value = clish_xmlnode_fetch_attr(element, "value");
  613. char *hidden = clish_xmlnode_fetch_attr(element, "hidden");
  614. char *test = clish_xmlnode_fetch_attr(element, "test");
  615. char *completion = clish_xmlnode_fetch_attr(element, "completion");
  616. char *access = clish_xmlnode_fetch_attr(element, "access");
  617. /* The PARAM can be child of COMMAND or another PARAM */
  618. pelement = clish_xmlnode_parent(element);
  619. pname = clish_xmlnode_get_all_name(pelement);
  620. if (pname && lub_string_nocasecmp(pname, "PARAM") == 0)
  621. p_param = (clish_param_t *)parent;
  622. else
  623. cmd = (clish_command_t *)parent;
  624. if (pname)
  625. free(pname);
  626. if (!cmd && !p_param)
  627. goto error;
  628. /* Check syntax */
  629. if (cmd && (cmd == shell->startup)) {
  630. fprintf(stderr, CLISH_XML_ERROR_STR"STARTUP can't contain PARAMs.\n");
  631. goto error;
  632. }
  633. if (!name) {
  634. fprintf(stderr, CLISH_XML_ERROR_ATTR("name"));
  635. goto error;
  636. }
  637. if (!help) {
  638. fprintf(stderr, CLISH_XML_ERROR_ATTR("help"));
  639. goto error;
  640. }
  641. if (!ptype) {
  642. fprintf(stderr, CLISH_XML_ERROR_ATTR("ptype"));
  643. goto error;
  644. }
  645. param = clish_param_new(name, help, ptype);
  646. /* If prefix is set clish will emulate old optional
  647. * command syntax over newer optional command mechanism.
  648. * It will create nested PARAM.
  649. */
  650. if (prefix) {
  651. const char *ptype_name = "__ptype_SUBCOMMAND";
  652. clish_param_t *opt_param = NULL;
  653. char *str = NULL;
  654. clish_ptype_t *tmp;
  655. /* Create a ptype for prefix-named subcommand that
  656. * will contain the nested optional parameter. The
  657. * name of ptype is hardcoded. It's not good but
  658. * it's only the service ptype.
  659. */
  660. tmp = clish_shell_find_create_ptype(shell,
  661. ptype_name, "Option", "[^\\\\]+",
  662. CLISH_PTYPE_METHOD_REGEXP, CLISH_PTYPE_PRE_NONE);
  663. assert(tmp);
  664. lub_string_cat(&str, "_prefix_");
  665. lub_string_cat(&str, name);
  666. opt_param = clish_param_new(str, help, ptype_name);
  667. lub_string_free(str);
  668. clish_param__set_mode(opt_param,
  669. CLISH_PARAM_SUBCOMMAND);
  670. clish_param__set_value(opt_param, prefix);
  671. clish_param__set_optional(opt_param, BOOL_TRUE);
  672. if (test)
  673. clish_param__set_test(opt_param, test);
  674. /* Add the parameter to the command */
  675. if (cmd)
  676. clish_command_insert_param(cmd, opt_param);
  677. /* Add the parameter to the param */
  678. if (p_param)
  679. clish_param_insert_param(p_param, opt_param);
  680. /* Unset cmd and set parent param to opt_param */
  681. cmd = NULL;
  682. p_param = opt_param;
  683. }
  684. if (defval)
  685. clish_param__set_defval(param, defval);
  686. if (hidden && lub_string_nocasecmp(hidden, "true") == 0)
  687. clish_param__set_hidden(param, BOOL_TRUE);
  688. else
  689. clish_param__set_hidden(param, BOOL_FALSE);
  690. if (mode) {
  691. if (lub_string_nocasecmp(mode, "switch") == 0) {
  692. clish_param__set_mode(param,
  693. CLISH_PARAM_SWITCH);
  694. /* Force hidden attribute */
  695. clish_param__set_hidden(param, BOOL_TRUE);
  696. } else if (lub_string_nocasecmp(mode, "subcommand") == 0)
  697. clish_param__set_mode(param,
  698. CLISH_PARAM_SUBCOMMAND);
  699. else
  700. clish_param__set_mode(param,
  701. CLISH_PARAM_COMMON);
  702. }
  703. if (optional && lub_string_nocasecmp(optional, "true") == 0)
  704. clish_param__set_optional(param, BOOL_TRUE);
  705. else
  706. clish_param__set_optional(param, BOOL_FALSE);
  707. if (order && lub_string_nocasecmp(order, "true") == 0)
  708. clish_param__set_order(param, BOOL_TRUE);
  709. else
  710. clish_param__set_order(param, BOOL_FALSE);
  711. if (value) {
  712. clish_param__set_value(param, value);
  713. /* Force mode to subcommand */
  714. clish_param__set_mode(param,
  715. CLISH_PARAM_SUBCOMMAND);
  716. }
  717. if (test && !prefix)
  718. clish_param__set_test(param, test);
  719. if (completion)
  720. clish_param__set_completion(param, completion);
  721. if (access)
  722. clish_param__set_access(param, access);
  723. /* Add the parameter to the command */
  724. if (cmd)
  725. clish_command_insert_param(cmd, param);
  726. /* Add the parameter to the param */
  727. if (p_param)
  728. clish_param_insert_param(p_param, param);
  729. res = process_children(shell, element, param);
  730. error:
  731. clish_xml_release(name);
  732. clish_xml_release(help);
  733. clish_xml_release(ptype);
  734. clish_xml_release(prefix);
  735. clish_xml_release(defval);
  736. clish_xml_release(mode);
  737. clish_xml_release(optional);
  738. clish_xml_release(order);
  739. clish_xml_release(value);
  740. clish_xml_release(hidden);
  741. clish_xml_release(test);
  742. clish_xml_release(completion);
  743. clish_xml_release(access);
  744. return res;
  745. }
  746. /* ------------------------------------------------------ */
  747. static int process_action(clish_shell_t *shell, clish_xmlnode_t *element,
  748. void *parent)
  749. {
  750. clish_action_t *action = NULL;
  751. char *builtin = clish_xmlnode_fetch_attr(element, "builtin");
  752. char *shebang = clish_xmlnode_fetch_attr(element, "shebang");
  753. char *lock = clish_xmlnode_fetch_attr(element, "lock");
  754. char *interrupt = clish_xmlnode_fetch_attr(element, "interrupt");
  755. char *interactive = clish_xmlnode_fetch_attr(element, "interactive");
  756. clish_xmlnode_t *pelement = clish_xmlnode_parent(element);
  757. char *pname = clish_xmlnode_get_all_name(pelement);
  758. char *text;
  759. clish_sym_t *sym = NULL;
  760. if (pname && lub_string_nocasecmp(pname, "VAR") == 0)
  761. action = clish_var__get_action((clish_var_t *)parent);
  762. else if (pname && lub_string_nocasecmp(pname, "PTYPE") == 0)
  763. action = clish_ptype__get_action((clish_ptype_t *)parent);
  764. else
  765. action = clish_command__get_action((clish_command_t *)parent);
  766. if (pname)
  767. free(pname);
  768. text = clish_xmlnode_get_all_content(element);
  769. if (text && *text) {
  770. /* store the action */
  771. clish_action__set_script(action, text);
  772. }
  773. if (text)
  774. free(text);
  775. if (builtin)
  776. sym = clish_shell_add_unresolved_sym(shell, builtin,
  777. CLISH_SYM_TYPE_ACTION);
  778. else
  779. sym = shell->hooks[CLISH_SYM_TYPE_ACTION];
  780. clish_action__set_builtin(action, sym);
  781. if (shebang)
  782. clish_action__set_shebang(action, shebang);
  783. /* lock */
  784. if (lock && lub_string_nocasecmp(lock, "false") == 0)
  785. clish_action__set_lock(action, BOOL_FALSE);
  786. /* interrupt */
  787. if (interrupt && lub_string_nocasecmp(interrupt, "true") == 0)
  788. clish_action__set_interrupt(action, BOOL_TRUE);
  789. clish_xml_release(builtin);
  790. clish_xml_release(shebang);
  791. clish_xml_release(lock);
  792. clish_xml_release(interrupt);
  793. clish_xml_release(interactive);
  794. return 0;
  795. }
  796. /* ------------------------------------------------------ */
  797. static int process_detail(clish_shell_t *shell, clish_xmlnode_t *element,
  798. void *parent)
  799. {
  800. clish_command_t *cmd = (clish_command_t *) parent;
  801. /* read the following text element */
  802. char *text = clish_xmlnode_get_all_content(element);
  803. if (text && *text) {
  804. /* store the action */
  805. clish_command__set_detail(cmd, text);
  806. }
  807. if (text)
  808. free(text);
  809. shell = shell; /* Happy compiler */
  810. return 0;
  811. }
  812. /* ------------------------------------------------------ */
  813. static int process_namespace(clish_shell_t *shell, clish_xmlnode_t *element,
  814. void *parent)
  815. {
  816. clish_view_t *v = (clish_view_t *)parent;
  817. clish_nspace_t *nspace = NULL;
  818. int res = -1;
  819. char *view = clish_xmlnode_fetch_attr(element, "ref");
  820. char *prefix = clish_xmlnode_fetch_attr(element, "prefix");
  821. char *prefix_help = clish_xmlnode_fetch_attr(element, "prefix_help");
  822. char *help = clish_xmlnode_fetch_attr(element, "help");
  823. char *completion = clish_xmlnode_fetch_attr(element, "completion");
  824. char *context_help = clish_xmlnode_fetch_attr(element, "context_help");
  825. char *inherit = clish_xmlnode_fetch_attr(element, "inherit");
  826. char *access = clish_xmlnode_fetch_attr(element, "access");
  827. /* Check syntax */
  828. if (!view) {
  829. fprintf(stderr, CLISH_XML_ERROR_ATTR("ref"));
  830. goto error;
  831. }
  832. clish_view_t *ref_view = clish_shell_find_view(shell, view);
  833. /* Don't include itself without prefix */
  834. if ((ref_view == v) && !prefix)
  835. goto process_namespace_end;
  836. nspace = clish_nspace_new(view);
  837. clish_view_insert_nspace(v, nspace);
  838. if (prefix) {
  839. clish_nspace__set_prefix(nspace, prefix);
  840. if (prefix_help)
  841. clish_nspace_create_prefix_cmd(nspace,
  842. "prefix",
  843. prefix_help);
  844. else
  845. clish_nspace_create_prefix_cmd(nspace,
  846. "prefix",
  847. "Prefix for the imported commands.");
  848. }
  849. if (help && lub_string_nocasecmp(help, "true") == 0)
  850. clish_nspace__set_help(nspace, BOOL_TRUE);
  851. else
  852. clish_nspace__set_help(nspace, BOOL_FALSE);
  853. if (completion && lub_string_nocasecmp(completion, "false") == 0)
  854. clish_nspace__set_completion(nspace, BOOL_FALSE);
  855. else
  856. clish_nspace__set_completion(nspace, BOOL_TRUE);
  857. if (context_help && lub_string_nocasecmp(context_help, "true") == 0)
  858. clish_nspace__set_context_help(nspace, BOOL_TRUE);
  859. else
  860. clish_nspace__set_context_help(nspace, BOOL_FALSE);
  861. if (inherit && lub_string_nocasecmp(inherit, "false") == 0)
  862. clish_nspace__set_inherit(nspace, BOOL_FALSE);
  863. else
  864. clish_nspace__set_inherit(nspace, BOOL_TRUE);
  865. if (access)
  866. clish_nspace__set_access(nspace, access);
  867. process_namespace_end:
  868. res = 0;
  869. error:
  870. clish_xml_release(view);
  871. clish_xml_release(prefix);
  872. clish_xml_release(prefix_help);
  873. clish_xml_release(help);
  874. clish_xml_release(completion);
  875. clish_xml_release(context_help);
  876. clish_xml_release(inherit);
  877. clish_xml_release(access);
  878. return res;
  879. }
  880. /* ------------------------------------------------------ */
  881. static int process_config(clish_shell_t *shell, clish_xmlnode_t *element,
  882. void *parent)
  883. {
  884. clish_command_t *cmd = (clish_command_t *)parent;
  885. clish_config_t *config;
  886. if (!cmd)
  887. return 0;
  888. config = clish_command__get_config(cmd);
  889. /* read the following text element */
  890. char *operation = clish_xmlnode_fetch_attr(element, "operation");
  891. char *priority = clish_xmlnode_fetch_attr(element, "priority");
  892. char *pattern = clish_xmlnode_fetch_attr(element, "pattern");
  893. char *file = clish_xmlnode_fetch_attr(element, "file");
  894. char *splitter = clish_xmlnode_fetch_attr(element, "splitter");
  895. char *seq = clish_xmlnode_fetch_attr(element, "sequence");
  896. char *unique = clish_xmlnode_fetch_attr(element, "unique");
  897. char *depth = clish_xmlnode_fetch_attr(element, "depth");
  898. if (operation && !lub_string_nocasecmp(operation, "unset"))
  899. clish_config__set_op(config, CLISH_CONFIG_UNSET);
  900. else if (operation && !lub_string_nocasecmp(operation, "none"))
  901. clish_config__set_op(config, CLISH_CONFIG_NONE);
  902. else if (operation && !lub_string_nocasecmp(operation, "dump"))
  903. clish_config__set_op(config, CLISH_CONFIG_DUMP);
  904. else {
  905. clish_config__set_op(config, CLISH_CONFIG_SET);
  906. /* The priority if no clearly specified */
  907. clish_config__set_priority(config, 0x7f00);
  908. }
  909. if (priority) {
  910. unsigned short pri = 0;
  911. lub_conv_atous(priority, &pri, 0);
  912. clish_config__set_priority(config, pri);
  913. }
  914. if (pattern)
  915. clish_config__set_pattern(config, pattern);
  916. else
  917. clish_config__set_pattern(config, "^${__cmd}");
  918. if (file)
  919. clish_config__set_file(config, file);
  920. if (splitter && lub_string_nocasecmp(splitter, "false") == 0)
  921. clish_config__set_splitter(config, BOOL_FALSE);
  922. else
  923. clish_config__set_splitter(config, BOOL_TRUE);
  924. if (unique && lub_string_nocasecmp(unique, "false") == 0)
  925. clish_config__set_unique(config, BOOL_FALSE);
  926. else
  927. clish_config__set_unique(config, BOOL_TRUE);
  928. if (seq)
  929. clish_config__set_seq(config, seq);
  930. else
  931. /* The entries without sequence cannot be non-unique */
  932. clish_config__set_unique(config, BOOL_TRUE);
  933. if (depth)
  934. clish_config__set_depth(config, depth);
  935. clish_xml_release(operation);
  936. clish_xml_release(priority);
  937. clish_xml_release(pattern);
  938. clish_xml_release(file);
  939. clish_xml_release(splitter);
  940. clish_xml_release(seq);
  941. clish_xml_release(unique);
  942. clish_xml_release(depth);
  943. shell = shell; /* Happy compiler */
  944. return 0;
  945. }
  946. /* ------------------------------------------------------ */
  947. static int process_var(clish_shell_t *shell, clish_xmlnode_t *element,
  948. void *parent)
  949. {
  950. clish_view_t *v = (clish_view_t *)parent;
  951. lub_list_t *vars = clish_view__get_vars(v);
  952. clish_var_t *var = NULL;
  953. int res = -1;
  954. char *name = clish_xmlnode_fetch_attr(element, "name");
  955. char *dynamic = clish_xmlnode_fetch_attr(element, "dynamic");
  956. char *value = clish_xmlnode_fetch_attr(element, "value");
  957. /* Check syntax */
  958. if (!name) {
  959. fprintf(stderr, CLISH_XML_ERROR_ATTR("name"));
  960. goto error;
  961. }
  962. /* Check if this var doesn't already exist */
  963. var = lub_list_find(vars, clish_var_fn_find_by_name, name);
  964. if (var) {
  965. fprintf(stderr, CLISH_XML_ERROR_STR"Duplicate VAR name=\"%s\".\n", name);
  966. goto error;
  967. }
  968. /* Create var instance */
  969. var = clish_var_new(name);
  970. lub_list_add(vars, var);
  971. if (dynamic && lub_string_nocasecmp(dynamic, "true") == 0)
  972. clish_var__set_dynamic(var, BOOL_TRUE);
  973. if (value)
  974. clish_var__set_value(var, value);
  975. res = process_children(shell, element, var);
  976. error:
  977. clish_xml_release(name);
  978. clish_xml_release(dynamic);
  979. clish_xml_release(value);
  980. parent = parent; /* Happy compiler */
  981. return res;
  982. }
  983. /* ------------------------------------------------------ */
  984. static int process_wdog(clish_shell_t *shell,
  985. clish_xmlnode_t *element, void *parent)
  986. {
  987. clish_command_t *cmd = NULL;
  988. int res = -1;
  989. /* Check syntax */
  990. if (shell->wdog) {
  991. fprintf(stderr, CLISH_XML_ERROR_STR"WATCHDOG tag duplication.\n");
  992. goto error;
  993. }
  994. /* Create a command for WDOG */
  995. cmd = clish_command_new("watchdog", NULL);
  996. #ifdef LEGACY
  997. // Legacy watchdog has lockless ACTION
  998. clish_action__set_lock(clish_command__get_action(cmd), BOOL_FALSE);
  999. #endif
  1000. /* Remember this command */
  1001. shell->wdog = cmd;
  1002. res = process_children(shell, element, cmd);
  1003. error:
  1004. return res;
  1005. }
  1006. /* ------------------------------------------------------ */
  1007. static int process_hotkey(clish_shell_t *shell, clish_xmlnode_t *element,
  1008. void *parent)
  1009. {
  1010. clish_view_t *v = (clish_view_t *)parent;
  1011. int res = -1;
  1012. char *key = clish_xmlnode_fetch_attr(element, "key");
  1013. char *cmd = clish_xmlnode_fetch_attr(element, "cmd");
  1014. /* Check syntax */
  1015. if (!key) {
  1016. fprintf(stderr, CLISH_XML_ERROR_ATTR("key"));
  1017. goto error;
  1018. }
  1019. if (!cmd) {
  1020. fprintf(stderr, CLISH_XML_ERROR_ATTR("cmd"));
  1021. goto error;
  1022. }
  1023. clish_view_insert_hotkey(v, key, cmd);
  1024. res = 0;
  1025. error:
  1026. clish_xml_release(key);
  1027. clish_xml_release(cmd);
  1028. shell = shell; /* Happy compiler */
  1029. return res;
  1030. }
  1031. /* ------------------------------------------------------ */
  1032. static int process_plugin(clish_shell_t *shell, clish_xmlnode_t *element,
  1033. void *parent)
  1034. {
  1035. clish_plugin_t *plugin;
  1036. char *file = clish_xmlnode_fetch_attr(element, "file");
  1037. char *name = clish_xmlnode_fetch_attr(element, "name");
  1038. char *alias = clish_xmlnode_fetch_attr(element, "alias");
  1039. char *rtld_global = clish_xmlnode_fetch_attr(element, "rtld_global");
  1040. int res = -1;
  1041. char *text;
  1042. /* Check syntax */
  1043. if (!name) {
  1044. fprintf(stderr, CLISH_XML_ERROR_ATTR("name"));
  1045. goto error;
  1046. }
  1047. plugin = clish_shell_find_plugin(shell, name);
  1048. if (plugin) {
  1049. fprintf(stderr,
  1050. CLISH_XML_ERROR_STR"PLUGIN %s duplication.\n", name);
  1051. goto error;
  1052. }
  1053. plugin = clish_shell_create_plugin(shell, name);
  1054. if (alias && *alias)
  1055. clish_plugin__set_alias(plugin, alias);
  1056. if (file && *file)
  1057. clish_plugin__set_file(plugin, file);
  1058. if (rtld_global && lub_string_nocasecmp(rtld_global, "true") == 0)
  1059. clish_plugin__set_rtld_global(plugin, BOOL_TRUE);
  1060. /* Get PLUGIN body content */
  1061. text = clish_xmlnode_get_all_content(element);
  1062. if (text && *text)
  1063. clish_plugin__set_conf(plugin, text);
  1064. if (text)
  1065. free(text);
  1066. res = 0;
  1067. error:
  1068. clish_xml_release(file);
  1069. clish_xml_release(name);
  1070. clish_xml_release(alias);
  1071. clish_xml_release(rtld_global);
  1072. parent = parent; /* Happy compiler */
  1073. return res;
  1074. }
  1075. /* ------------------------------------------------------ */
  1076. static int process_hook(clish_shell_t *shell, clish_xmlnode_t *element,
  1077. void *parent)
  1078. {
  1079. char *name = clish_xmlnode_fetch_attr(element, "name");
  1080. char *builtin = clish_xmlnode_fetch_attr(element, "builtin");
  1081. int res = -1;
  1082. int type = CLISH_SYM_TYPE_NONE;
  1083. /* Check syntax */
  1084. if (!name) {
  1085. fprintf(stderr, CLISH_XML_ERROR_ATTR("name"));
  1086. goto error;
  1087. }
  1088. /* Find out HOOK type */
  1089. if (!strcmp(name, "action"))
  1090. type = CLISH_SYM_TYPE_ACTION;
  1091. else if (!strcmp(name, "access"))
  1092. type = CLISH_SYM_TYPE_ACCESS;
  1093. else if (!strcmp(name, "config"))
  1094. type = CLISH_SYM_TYPE_CONFIG;
  1095. else if (!strcmp(name, "log"))
  1096. type = CLISH_SYM_TYPE_LOG;
  1097. if (CLISH_SYM_TYPE_NONE == type) {
  1098. fprintf(stderr, CLISH_XML_ERROR_STR"Unknown HOOK name %s.\n", name);
  1099. goto error;
  1100. }
  1101. /* Check duplicate HOOK tag */
  1102. if (shell->hooks_use[type]) {
  1103. fprintf(stderr,
  1104. CLISH_XML_ERROR_STR"HOOK %s duplication.\n", name);
  1105. goto error;
  1106. }
  1107. shell->hooks_use[type] = BOOL_TRUE;
  1108. clish_sym__set_name(shell->hooks[type], builtin);
  1109. res = 0;
  1110. error:
  1111. clish_xml_release(name);
  1112. clish_xml_release(builtin);
  1113. parent = parent; /* Happy compiler */
  1114. return res;
  1115. }
  1116. /* ------------------------------------------------------ */