static void build_cmd(char *buf, size_t bufsize, const char *cmdname,
int numarg, const char **arg)
{
int i;
size_t len;
char enc[UPSCLI_NETBUF_LEN];
const char *format;
memset(buf, '\0', bufsize);
snprintf(buf, bufsize, "%s", cmdname);
/* encode all arguments so they arrive intact */
for (i = 0; i < numarg; i++) {
if (strchr(arg[i], ' '))
format = " \"%s\""; /* wrap in "" */
else
format = " %s";
/* snprintfcat would tie us to common */
len = strlen(buf);
snprintf(buf + len, bufsize - len, format,
pconf_encode(arg[i], enc, sizeof(enc)));
}
len = strlen(buf);
snprintf(buf + len, bufsize - len, "\n");
}
int state_addenum(st_tree_t *root, const char *var, const char *val)
{
st_tree_t *sttmp;
char enc[ST_MAX_VALUE_LEN];
/* find the tree node for var */
sttmp = state_tree_find(root, var);
if (!sttmp) {
upslogx(LOG_ERR, "state_addenum: base variable (%s) "
"does not exist", var);
return 0; /* failed */
}
/* smooth over any oddities in the enum value */
pconf_encode(val, enc, sizeof(enc));
return st_tree_enum_add(&sttmp->enum_list, enc);
}
static void get_upsdesc(nut_ctype_t *client, const char *upsname)
{
const upstype_t *ups;
char esc[SMALLBUF];
ups = get_ups_ptr(upsname);
if (!ups) {
send_err(client, NUT_ERR_UNKNOWN_UPS);
return;
}
if (ups->desc) {
pconf_encode(ups->desc, esc, sizeof(esc));
sendback(client, "UPSDESC %s \"%s\"\n", upsname, esc);
} else {
sendback(client, "UPSDESC %s \"Unavailable\"\n", upsname);
}
}
static void do_set(const char *varname, const char *newval)
{
char buf[SMALLBUF], enc[SMALLBUF];
snprintf(buf, sizeof(buf), "SET VAR %s %s \"%s\"\n", upsname, varname, pconf_encode(newval, enc, sizeof(enc)));
if (upscli_sendline(ups, buf, strlen(buf)) < 0) {
fatalx(EXIT_FAILURE, "Can't set variable: %s", upscli_strerror(ups));
}
if (upscli_readline(ups, buf, sizeof(buf)) < 0) {
fatalx(EXIT_FAILURE, "Set variable failed: %s", upscli_strerror(ups));
}
/* FUTURE: status cookies will tie in here */
if (strncmp(buf, "OK", 2) != 0) {
fatalx(EXIT_FAILURE, "Unexpected response from upsd: %s", buf);
}
fprintf(stderr, "%s\n", buf);
}
static void val_escape(st_tree_t *node)
{
char etmp[ST_MAX_VALUE_LEN];
/* escape any tricky stuff like \ and " */
pconf_encode(node->raw, etmp, sizeof(etmp));
/* if nothing was escaped, we don't need to do anything else */
if (!strcmp(node->raw, etmp)) {
node->val = node->raw;
return;
}
/* if the escaped value grew, deal with it */
if (node->safesize < (strlen(etmp) + 1)) {
node->safesize = strlen(etmp) + 1;
node->safe = xrealloc(node->safe, node->safesize);
}
snprintf(node->safe, node->safesize, "%s", etmp);
node->val = node->safe;
}
static void sendcmd(const char *cmd, const char *arg1, const char *arg2)
{
int i, pipefd, ret;
char buf[SMALLBUF], enc[SMALLBUF];
/* insanity */
if (!arg1)
return;
/* build the request */
snprintf(buf, sizeof(buf), "%s \"%s\"",
cmd, pconf_encode(arg1, enc, sizeof(enc)));
if (arg2)
snprintfcat(buf, sizeof(buf), " \"%s\"",
pconf_encode(arg2, enc, sizeof(enc)));
snprintf(enc, sizeof(enc), "%s\n", buf);
/* see if the parent needs to be started (and maybe start it) */
for (i = 0; i < MAX_TRIES; i++) {
pipefd = check_parent(cmd, arg2);
if (pipefd == PARENT_STARTED) {
/* loop back and try to connect now */
usleep(250000);
continue;
}
/* special case for CANCEL when no parent is running */
if (pipefd == PARENT_UNNECESSARY)
return;
/* we're connected now */
ret = write(pipefd, enc, strlen(enc));
/* if we can't send the whole thing, loop back and try again */
if ((ret < 1) || (ret != (int) strlen(enc))) {
upslogx(LOG_ERR, "write failed, trying again");
close(pipefd);
continue;
}
/* ugh - probably should use select here... */
setup_sigalrm();
alarm(2);
ret = read(pipefd, buf, sizeof(buf));
alarm(0);
signal(SIGALRM, SIG_IGN);
close(pipefd);
/* same idea: no OK = go try it all again */
if (ret < 2) {
upslogx(LOG_ERR, "read confirmation failed, trying again");
continue;
}
if (!strncmp(buf, "OK", 2))
return; /* success */
upslogx(LOG_ERR, "read confirmation got [%s]", buf);
/* try again ... */
}
fatalx(EXIT_FAILURE, "Unable to connect to daemon and unable to start daemon");
}
