/*
* Update the destination's file-tree with respect to changes in the
* source manpath components.
* "Change" is defined by an updated index or btree database.
* Returns 1 on success, 0 on failure.
*/
static int
manup(const struct manpaths *dirs, char *base)
{
char dst[MAXPATHLEN],
src[MAXPATHLEN];
const char *path;
int i, c;
size_t sz;
FILE *f;
/* Create the path and file for the catman.conf file. */
sz = strlen(base);
xstrlcpy(dst, base, MAXPATHLEN);
xstrlcat(dst, "/etc", MAXPATHLEN);
if (-1 == mkpath(dst, 0755, 0755)) {
perror(dst);
return(0);
}
xstrlcat(dst, "/catman.conf", MAXPATHLEN);
if (NULL == (f = fopen(dst, "w"))) {
perror(dst);
return(0);
} else if (verbose)
printf("%s\n", dst);
for (i = 0; i < dirs->sz; i++) {
path = dirs->paths[i];
dst[(int)sz] = '\0';
xstrlcat(dst, path, MAXPATHLEN);
if (-1 == mkpath(dst, 0755, 0755)) {
perror(dst);
break;
}
xstrlcpy(src, path, MAXPATHLEN);
if (-1 == (c = treecpy(dst, src)))
break;
else if (0 == c)
continue;
/*
* We want to use a relative path here because manpath.h
* will realpath() when invoked with man.cgi, and we'll
* make sure to chdir() into the cache directory before.
*
* This allows the cache directory to be in an arbitrary
* place, working in both chroot() and non-chroot()
* "safe" modes.
*/
assert('/' == path[0]);
fprintf(f, "_whatdb %s/whatis.db\n", path + 1);
}
fclose(f);
return(i == dirs->sz);
}
fstree_node_t treecpy ( fstree_node_t old_node ) {
fslist_node_t aux_node;
fstree_node_t new_node;
if (!old_node->children->size)
return nodecpy(old_node);
new_node = nodecpy(old_node);
aux_node = old_node->children->first;
while (aux_node != NULL) {
add_child(new_node, treecpy(aux_node->child));
aux_node = aux_node->next;
}
return new_node;
}
extern void funcall(char **av) {
Jbwrap j;
Edata jreturn, star;
Estack e1, e2;
if (sigsetjmp(j.j, 1))
return;
starassign(*av, av+1, TRUE);
jreturn.jb = &j;
star.name = "*";
except(eReturn, jreturn, &e1);
except(eVarstack, star, &e2);
walk(treecpy(fnlookup(*av), nalloc), TRUE);
varrm("*", TRUE);
unexcept(eVarstack);
unexcept(eReturn);
}
void initparse() {
star = treecpy(mk(nVar, mk(nWord,"*", NULL, FALSE)), ealloc);
nolist = treecpy(mk(nVar, mk(nWord,"ifs", NULL, FALSE)), ealloc);
}
extern Node *treecpy(const Node *s, void *(*alloc)(size_t)) {
Node *n;
if (s == NULL)
return NULL;
switch (s->type) {
default:
panic("unexpected node in treecpy");
/* NOTREACHED */
case nDup:
n = (*alloc)(offsetof(Node, u[3]));
n->u[0].i = s->u[0].i;
n->u[1].i = s->u[1].i;
n->u[2].i = s->u[2].i;
break;
case nWord:
n = (*alloc)(offsetof(Node, u[3]));
n->u[0].s = strcpy((char *) (*alloc)(strlen(s->u[0].s) + 1), s->u[0].s);
if (s->u[1].s != NULL) {
size_t i = strlen(s->u[0].s);
n->u[1].s = (*alloc)(i);
memcpy(n->u[1].s, s->u[1].s, i);
} else
n->u[1].s = NULL;
n->u[2].i = s->u[2].i;
break;
case nBang: case nNowait: case nCase:
case nCount: case nFlat: case nRmfn: case nSubshell: case nVar:
n = (*alloc)(offsetof(Node, u[1]));
n->u[0].p = treecpy(s->u[0].p, alloc);
break;
case nAndalso: case nAssign: case nBackq: case nBody: case nBrace: case nConcat:
case nElse: case nEpilog: case nIf: case nNewfn: case nCbody:
case nOrelse: case nPre: case nArgs: case nSwitch:
case nMatch: case nVarsub: case nWhile: case nLappend:
n = (*alloc)(offsetof(Node, u[2]));
n->u[0].p = treecpy(s->u[0].p, alloc);
n->u[1].p = treecpy(s->u[1].p, alloc);
break;
case nForin:
n = (*alloc)(offsetof(Node, u[3]));
n->u[0].p = treecpy(s->u[0].p, alloc);
n->u[1].p = treecpy(s->u[1].p, alloc);
n->u[2].p = treecpy(s->u[2].p, alloc);
break;
case nPipe:
n = (*alloc)(offsetof(Node, u[4]));
n->u[0].i = s->u[0].i;
n->u[1].i = s->u[1].i;
n->u[2].p = treecpy(s->u[2].p, alloc);
n->u[3].p = treecpy(s->u[3].p, alloc);
break;
case nRedir:
case nNmpipe:
n = (*alloc)(offsetof(Node, u[3]));
n->u[0].i = s->u[0].i;
n->u[1].i = s->u[1].i;
n->u[2].p = treecpy(s->u[2].p, alloc);
break;
}
n->type = s->type;
return n;
}
fstree_t branch_tree ( fstree_t old_tree ) {
fstree_t new_tree = new_fstree();
fstree_node_t new_root = treecpy(old_tree->root);
new_tree->root = new_root;
return new_tree;
}
