/*=========================================================
* intersect_nodes -- Return intersection of two node trees
* UNUSED CODE
*=======================================================*/
NODE
intersect_nodes (NODE node1,
NODE node2,
BOOLEAN kids) /* children matter */
{
NODE prev1, curs1, next1, prev2, curs2, next2;
NODE node3, curs3;
if (!node1 || !node2) return NULL;
node1 = copy_nodes(node1, TRUE, TRUE);
node2 = copy_nodes(node2, TRUE, TRUE);
node3 = curs3 = NULL;
prev1 = NULL;
curs1 = node1;
while (curs1) {
prev2 = NULL;
curs2 = node2;
while (curs2 && !iso_nodes(curs1, curs2, kids, FALSE)) {
prev2 = curs2;
curs2 = nsibling(curs2);
}
if (curs2) {
next2 = nsibling(curs2);
nsibling(curs2) = NULL;
if (node3)
curs3 = nsibling(curs3) = curs2;
else
node3 = curs3 = curs2;
if (prev2)
nsibling(prev2) = next2;
else
node2 = next2;
next1 = nsibling(curs1);
nsibling(curs1) = NULL;
free_nodes(curs1);
if (prev1)
nsibling(prev1) = next1;
else
node1 = next1;
curs1 = next1;
} else {
prev1 = curs1;
curs1 = nsibling(curs1);
}
}
free_nodes(node1);
free_nodes(node2);
return node3;
}
/*========================================================================
* difference_nodes -- Return difference of two node lists -- all in node1
* that are not in node2
* UNUSED CODE
*======================================================================*/
NODE
difference_nodes (NODE node1,
NODE node2,
BOOLEAN kids) /* children matter */
{
NODE prev1, next1, curs1, curs2;
node1 = copy_nodes(node1, TRUE, TRUE);
prev1 = NULL;
curs1 = node1;
while (curs1) {
curs2 = node2;
while (curs2 && !iso_nodes(curs1, curs2, kids, FALSE))
curs2 = nsibling(curs2);
if (curs2) {
next1 = nsibling(curs1);
nsibling(curs1) = NULL;
free_nodes(curs1);
if (!prev1)
node1 = next1;
else
nsibling(prev1) = next1;
curs1 = next1;
} else {
prev1 = curs1;
curs1 = nsibling(curs1);
}
}
return node1;
}
/*==============================================
* union_nodes -- Return union of two node trees
*============================================*/
NODE
union_nodes (NODE node1,
NODE node2,
BOOLEAN kids, /* children matter */
BOOLEAN copy) /* copy operands first */
{
NODE curs1, next1, prev1, curs2, prev2;
if (copy) node1 = copy_nodes(node1, TRUE, TRUE);
if (copy) node2 = copy_nodes(node2, TRUE, TRUE);
prev2 = NULL;
curs2 = node2;
while (curs2) {
prev1 = NULL;
curs1 = node1;
while (curs1 && !iso_nodes(curs1, curs2, kids, FALSE)) {
prev1 = curs1;
curs1 = nsibling(curs1);
}
if (curs1) {
next1 = nsibling(curs1);
nsibling(curs1) = NULL;
free_nodes(curs1);
if (prev1)
nsibling(prev1) = next1;
else
node1 = next1;
}
prev2 = curs2;
curs2 = nsibling(curs2);
}
if (prev2) {
nsibling(prev2) = node1;
return node2;
}
return node1;
}
/*=================================================================
* expand_tree -- Create copy of node tree with additional link info
*===============================================================*/
static NODE
expand_tree (NODE root0)
{
NODE copy, node, sub;
STRING key;
static NODE root; /* root of record being edited */
LIST subs; /* list of contained records */
NODE expd; /* expanded main record - copy - our retval */
root = root0;
expd = copy_nodes(root, TRUE, TRUE);
subs = create_list();
traverse_nodes(expd, advedit_expand_traverse, subs);
/* expand the list of records into the copied record */
FORLIST(subs, el)
node = (NODE) el;
#ifdef DEBUG
llwprintf("in list: %s %s\n", ntag(node), nval(node));
#endif
key = rmvat(nval(node));
if ((sub = nztop(key_possible_to_record(key, *key)))) {
copy = copy_node_subtree(sub);
nxref(node) = nxref(copy);
ntag(node) = ntag(copy);
nchild(node) = nchild(copy);
nparent(node) = nparent(copy);
/*MEMORY LEAK; MEMORY LEAK; MEMORY LEAK: node not removed (because its
value and possibly xref [probably not] are still being referred to */
}
ENDLIST
/* Shouldn't we free subs now ? Perry 2001/06/22 */
#ifdef DEBUG
show_node(expd);
#endif
return expd;
}
/*=======================================
* edit_record -- Edit record in database
* root1: [IN] record to edit (may be NULL)
* idedt: [IN] user id prompt
* letr: [IN] record type (E, S, or X)
* redt: [IN] reedit prompt displayed if hard error after editing
* redtopt: [IN] reedit prompt displayed if soft error (unresolved links)
* val: [IN] callback to validate routine
* cfrm: [IN] confirmation msg string
* tag: [IN] tag (SOUR, EVEN, or NULL)
* todbase: [IN] callback to write record to dbase
* gdmsg: [IN] success message
* rfmt: [IN] display reformatter
*=====================================*/
static BOOLEAN
edit_record (RECORD rec1, STRING idedt, INT letr, STRING redt, STRING redtopt
, BOOLEAN (*val)(NODE, STRING *, NODE)
, STRING cfrm, void (*todbase)(NODE), STRING gdmsg
, RFMT rfmt)
{
XLAT ttmi = transl_get_predefined_xlat(MEDIN);
STRING msg, key;
BOOLEAN emp;
NODE root0=0, root1=0, root2=0;
NODE refn1=0, refn2=0, refnn=0, refn1n=0;
NODE body=0, node=0;
/* Identify record if need be */
if (!rec1) {
rec1 = ask_for_record(idedt, letr);
}
root1 = nztop(rec1);
if (!root1) {
message(_(qSnosuchrec));
return FALSE;
}
/* Have user edit record */
annotate_with_supplemental(root1, rfmt);
write_node_to_editfile(root1);
resolve_refn_links(root1);
do_edit();
if (readonly) {
root2 = file_to_node(editfile, ttmi, &msg, &emp);
if (!equal_tree(root1, root2))
message(_(qSronlye));
free_nodes(root2);
return FALSE;
}
while (TRUE) {
INT cnt;
root2 = file_to_node(editfile, ttmi, &msg, &emp);
if (!root2) {
if (ask_yes_or_no_msg(msg, redt)) {
do_edit();
continue;
}
break;
}
cnt = resolve_refn_links(root2);
/* check validation & allow user to reedit if invalid */
/* this is a showstopper, so alternative is to abort */
if (!(*val)(root2, &msg, root1)) {
if (ask_yes_or_no_msg(msg, redt)) {
do_edit();
continue;
}
free_nodes(root2);
root2 = NULL;
break;
}
/* Allow user to reedit if desired if any refn links unresolved */
/* this is not a showstopper, so alternative is to continue */
if (cnt > 0) {
char msgb[120];
snprintf(msgb, sizeof(msgb)
, get_unresolved_ref_error_string(cnt), cnt);
if (ask_yes_or_no_msg(msgb, redtopt)) {
write_node_to_editfile(root2);
do_edit();
continue;
}
}
break;
}
/* If error or no change or user backs out return */
if (!root2) return FALSE;
if (equal_tree(root1, root2) || !ask_yes_or_no(cfrm)) {
free_nodes(root2);
return FALSE;
}
/* Prepare to change database */
/* Move root1 data into root0 & save refns */
split_othr(root1, &refn1, &body);
root0 = copy_node(root1);
join_othr(root0, NULL, body);
/* delete root0 tree & root1 node (root1 is solitary node) */
free_nodes(root0); root0 = 0;
free_nodes(root1); root1 = 0;
/* now copy root2 node into root1, then root2 tree under it */
root1 = copy_node(root2);
split_othr(root2, &refn2, &body);
refnn = copy_nodes(refn2, TRUE, TRUE);
join_othr(root1, refn2, body);
/* now root2 is solitary node, delete it */
free_node(root2); root2 = 0;
/* Change the database */
(*todbase)(root1);
key = rmvat(nxref(root1));
/* remove deleted refns & add new ones */
classify_nodes(&refn1, &refnn, &refn1n);
for (node = refn1; node; node = nsibling(node))
if (nval(node)) remove_refn(nval(node), key);
for (node = refnn; node; node = nsibling(node))
if (nval(node)) add_refn(nval(node), key);
free_nodes(refn1);
free_nodes(refnn);
free_nodes(refn1n);
msg_info(gdmsg);
return TRUE;
}
int main(int argc, char *argv[]) {
int rc, i;
pid_t pid = -1;
pid_t ppid = getpid();
uid_t uid = -1;
gid_t gid = -1;
_free_ char *user = NULL;
_free_ char *dest = NULL;
_free_ char *change = NULL;
_free_ char *env = NULL;
_free_ char *cgroup = NULL;
_close_ int master_fd = -1;
char *master_name;
int detach = 0;
int keepenv = 0;
siginfo_t status;
while ((rc = getopt_long(argc, argv, short_opts, long_opts, &i)) !=-1) {
switch (rc) {
case 'm':
validate_optlist("--mount", optarg);
add_mount_from_spec(optarg);
break;
case 'n':
clone_flags |= CLONE_NEWNET;
if (optarg != NULL) {
validate_optlist("--netif", optarg);
add_netif_from_spec(optarg);
}
break;
case 'u':
clone_flags |= CLONE_NEWUSER;
freep(&user);
user = strdup(optarg);
break;
case 'r':
freep(&dest);
dest = realpath(optarg, NULL);
if (dest == NULL) sysf_printf("realpath()");
break;
case 'c':
freep(&change);
change = strdup(optarg);
break;
case 'g':
validate_optlist("--cgroup", optarg);
validate_cgroup_spec(optarg);
freep(&change);
cgroup = strdup(optarg);
break;
case 'd':
detach = 1;
break;
case 'a': {
char *end = NULL;
pid = strtol(optarg, &end, 10);
if (*end != '\0')
fail_printf("Invalid value '%s' for --attach", optarg);
break;
}
case 's': {
validate_optlist("--setenv", optarg);
if (env != NULL) {
char *tmp = env;
rc = asprintf(&env, "%s,%s", env, optarg);
if (rc < 0) fail_printf("OOM");
freep(&tmp);
} else {
env = strdup(optarg);
}
break;
}
case 'k':
keepenv = 1;
break;
case 'U':
clone_flags &= ~(CLONE_NEWUSER);
break;
case 'M':
clone_flags &= ~(CLONE_NEWNS);
break;
case 'N':
clone_flags &= ~(CLONE_NEWNET);
break;
case 'I':
clone_flags &= ~(CLONE_NEWIPC);
break;
case 'H':
clone_flags &= ~(CLONE_NEWUTS);
break;
case 'P':
clone_flags &= ~(CLONE_NEWPID);
break;
case '?':
case 'h':
help();
return 0;
}
}
if (pid != -1) {
master_fd = recv_pty(pid);
if (master_fd < 0) fail_printf("Invalid PID '%u'", pid);
pid = -1;
goto process_fd;
}
if (user == NULL) {
user = strdup("root");
if (user == NULL) fail_printf("OOM");
}
open_master_pty(&master_fd, &master_name);
uid = getuid();
gid = getgid();
if (detach == 1)
do_daemonize();
pid = do_clone();
if (pid == 0) {
closep(&master_fd);
open_slave_pty(master_name);
rc = setsid();
if (rc < 0) sysf_printf("setsid()");
rc = prctl(PR_SET_PDEATHSIG, SIGKILL);
if (rc < 0) sysf_printf("prctl(PR_SET_PDEATHSIG)");
if (clone_flags & CLONE_NEWUSER)
map_user_to_user(uid, gid, user);
do_cgroup(cgroup, ppid);
do_mount(dest);
if (dest != NULL) {
copy_nodes(dest);
make_ptmx(dest);
make_symlinks(dest);
make_console(dest, master_name);
do_chroot(dest);
}
if (clone_flags & CLONE_NEWNET)
setup_loopback();
umask(0022);
/* TODO: drop capabilities */
do_user(user);
if (change != NULL) {
rc = chdir(change);
if (rc < 0) sysf_printf("chdir()");
}
if (dest != NULL) {
char *term = getenv("TERM");
if (keepenv == 0)
clearenv();
setenv("PATH", "/usr/sbin:/usr/bin:/sbin:/bin", 1);
setenv("USER", user, 1);
setenv("LOGNAME", user, 1);
setenv("TERM", term, 1);
}
if (env != NULL) {
size_t i, c;
_free_ char **vars = NULL;
_free_ char *tmp = strdup(env);
if (tmp == NULL) fail_printf("OOM");
c = split_str(tmp, &vars, ",");
for (i = 0; i < c; i++) {
rc = putenv(strdup(vars[i]));
if (rc != 0) sysf_printf("putenv()");
}
}
setenv("container", "pflask", 1);
if (argc > optind)
rc = execvpe(argv[optind], argv + optind, environ);
else
rc = execle("/bin/bash", "-bash", NULL, environ);
if (rc < 0) sysf_printf("exec()");
}
do_netif(pid);
process_fd:
if (detach == 1)
serve_pty(master_fd);
else
process_pty(master_fd);
if (pid == -1)
return 0;
kill(pid, SIGKILL);
rc = waitid(P_PID, pid, &status, WEXITED);
if (rc < 0) sysf_printf("waitid()");
switch (status.si_code) {
case CLD_EXITED:
if (status.si_status != 0)
err_printf("Child failed with code '%d'",
status.si_status);
else
ok_printf("Child exited");
break;
case CLD_KILLED:
err_printf("Child was terminated");
break;
default:
err_printf("Child failed");
break;
}
undo_cgroup(cgroup, ppid);
return status.si_status;
}
