/* wrapper around xs_read
*/
static char*
do_read (xs_handle_t *xsh, char* path)
{
char *val = NULL, *san_val = NULL, *tmp = NULL;
static struct expanding_buffer ebuf = { 0, };
unsigned len = 0;
val = xs_read (xsh, 0, path, &len);
if (val == NULL) {
syslog (LOG_WARNING,
"xs_read on %s returned null",
path);
return NULL;
}
san_val = sanitise_value (&ebuf, val, len);
if (san_val == NULL) {
syslog (LOG_CRIT, "sanitise_value returned NULL");
free (val);
return NULL;
}
tmp = strdup (san_val);
/* don't free san_val */
free (val);
return tmp;
}
static int
perform(enum mode mode, int optind, int argc, char **argv, struct xs_handle *xsh,
xs_transaction_t xth, int prefix, int tidy, int upto, int recurse, int nr_watches)
{
switch (mode) {
case MODE_ls:
if (optind == argc)
{
optind=0;
argc=1;
argv[0] = "/";
}
break;
default:
break;
}
while (optind < argc) {
switch (mode) {
case MODE_unknown:
/* CANNOT BE REACHED */
errx(1, "invalid mode %d", mode);
case MODE_read: {
static struct expanding_buffer ebuf;
unsigned len;
char *val = xs_read(xsh, xth, argv[optind], &len);
if (val == NULL) {
warnx("couldn't read path %s", argv[optind]);
return 1;
}
if (prefix)
output("%s: ", argv[optind]);
output("%s\n", sanitise_value(&ebuf, val, len));
free(val);
optind++;
break;
}
case MODE_write: {
static struct expanding_buffer ebuf;
char *val_spec = argv[optind + 1];
unsigned len;
expanding_buffer_ensure(&ebuf, strlen(val_spec)+1);
unsanitise_value(ebuf.buf, &len, val_spec);
if (!xs_write(xsh, xth, argv[optind], ebuf.buf, len)) {
warnx("could not write path %s", argv[optind]);
return 1;
}
optind += 2;
} break;
case MODE_rm: {
/* Remove the specified path. If the tidy flag is set, then also
remove any containing directories that are both empty and have no
value attached, and repeat, recursing all the way up to the root if
necessary.
*/
char *slash, *path = argv[optind];
if (tidy) {
/* Copy path, because we can't modify argv because we will need it
again if xs_transaction_end gives us EAGAIN. */
char *p = malloc(strlen(path) + 1);
strcpy(p, path);
path = p;
again:
if (do_rm(path, xsh, xth)) {
return 1;
}
slash = strrchr(p, '/');
if (slash) {
char *val;
unsigned len;
*slash = '\0';
val = xs_read(xsh, xth, p, &len);
if (val && len == 0) {
unsigned int num;
char ** list = xs_directory(xsh, xth, p, &num);
if (list) {
free(list);
if (num == 0)
goto again;
}
}
}
free(path);
}
else {
if (do_rm(path, xsh, xth)) {
return 1;
}
}
optind++;
break;
}
case MODE_exists: {
char *val = xs_read(xsh, xth, argv[optind], NULL);
if (val == NULL) {
return 1;
}
free(val);
optind++;
break;
}
case MODE_list: {
unsigned int i, num;
char **list = xs_directory(xsh, xth, argv[optind], &num);
if (list == NULL) {
warnx("could not list path %s", argv[optind]);
return 1;
}
for (i = 0; i < num; i++) {
if (prefix)
output("%s/", argv[optind]);
output("%s\n", list[i]);
}
free(list);
optind++;
break;
}
case MODE_ls: {
do_ls(xsh, argv[optind], 0, prefix);
optind++;
break;
}
case MODE_chmod: {
/* save path pointer: */
char *path = argv[optind++];
int nperms = argc - optind;
struct xs_permissions perms[nperms];
int i;
for (i = 0; argv[optind]; optind++, i++)
{
perms[i].id = atoi(argv[optind]+1);
switch (argv[optind][0])
{
case 'n':
perms[i].perms = XS_PERM_NONE;
break;
case 'r':
perms[i].perms = XS_PERM_READ;
break;
case 'w':
perms[i].perms = XS_PERM_WRITE;
break;
case 'b':
perms[i].perms = XS_PERM_READ | XS_PERM_WRITE;
break;
default:
errx(1, "Invalid permission specification: '%c'",
argv[optind][0]);
}
}
do_chmod(path, perms, nperms, upto, recurse, xsh, xth);
break;
}
case MODE_watch: {
for (; argv[optind]; optind++) {
const char *w = argv[optind];
if (!xs_watch(xsh, w, w))
errx(1, "Unable to add watch on %s\n", w);
}
do_watch(xsh, nr_watches);
}
}
}
return 0;
}
static void do_ls(struct xs_handle *h, char *path, int cur_depth, int show_perms)
{
static struct expanding_buffer ebuf;
char **e;
char newpath[STRING_MAX], *val;
int newpath_len;
int i;
unsigned int num, len;
e = xs_directory(h, XBT_NULL, path, &num);
if (e == NULL)
err(1, "xs_directory (%s)", path);
for (i = 0; i<num; i++) {
char buf[MAX_STRLEN(unsigned int)+1];
struct xs_permissions *perms;
unsigned int nperms;
int linewid;
/* Compose fullpath */
newpath_len = snprintf(newpath, sizeof(newpath), "%s%s%s", path,
path[strlen(path)-1] == '/' ? "" : "/",
e[i]);
/* Print indent and path basename */
linewid = 0;
if (show_whole_path) {
fputs(newpath, stdout);
} else {
for (; linewid<cur_depth; linewid++) {
putchar(' ');
}
linewid += printf("%.*s",
(int) (max_width - TAG_LEN - linewid), e[i]);
}
/* Fetch value */
if ( newpath_len < sizeof(newpath) ) {
val = xs_read(h, XBT_NULL, newpath, &len);
}
else {
/* Path was truncated and thus invalid */
val = NULL;
len = 0;
}
/* Print value */
if (val == NULL) {
printf(":\n");
}
else {
if (max_width < (linewid + len + TAG_LEN)) {
printf(" = \"%.*s\\...\"",
(int)(max_width - TAG_LEN - linewid),
sanitise_value(&ebuf, val, len));
}
else {
linewid += printf(" = \"%s\"",
sanitise_value(&ebuf, val, len));
if (show_perms) {
putchar(' ');
for (linewid++;
linewid < MIN(desired_width, max_width);
linewid++)
putchar((linewid & 1)? '.' : ' ');
}
}
}
free(val);
if (show_perms) {
perms = xs_get_permissions(h, XBT_NULL, newpath, &nperms);
if (perms == NULL) {
warn("\ncould not access permissions for %s", e[i]);
}
else {
int i;
fputs(" (", stdout);
for (i = 0; i < nperms; i++) {
if (i)
putchar(',');
xs_perm_to_string(perms+i, buf, sizeof(buf));
fputs(buf, stdout);
}
putchar(')');
}
}
putchar('\n');
do_ls(h, newpath, cur_depth+1, show_perms);
}
free(e);
}
