/*
* XXX: Should we worry about QUOTE'd chars?
*/
char *
vis_str(Char *cp)
{
static char *sdst = NULL;
static size_t dstsize = 0;
size_t n;
Char *dp;
if (cp == NULL)
return (NULL);
for (dp = cp; *dp++;)
continue;
n = ((dp - cp) << 2) + 1; /* 4 times + NULL */
if (dstsize < n) {
sdst = (char *) (dstsize ?
xrealloc(sdst, (size_t) n * sizeof(char)) :
xmalloc((size_t) n * sizeof(char)));
dstsize = n;
}
/*
* XXX: When we are in AsciiOnly we want all characters >= 0200 to
* be encoded, but currently there is no way in vis to do that.
*/
(void) strnvis(sdst, short2str(cp), dstsize, VIS_NOSLASH);
return (sdst);
}
void
logmsg(int pri, const char *message, ...)
{
va_list ap;
if (pri > loglevel)
return;
va_start(ap, message);
if (daemonize)
/* syslog does its own vissing. */
vsyslog(pri, message, ap);
else {
char buf[MAX_LOGLINE];
char visbuf[2 * MAX_LOGLINE];
/* We don't care about truncation. */
vsnprintf(buf, sizeof buf, message, ap);
#ifdef __NetBSD__
size_t len = strlen(buf);
if (len > sizeof visbuf) {
len = sizeof visbuf;
}
strvisx(visbuf, buf, len, VIS_CSTYLE | VIS_NL);
#else
strnvis(visbuf, buf, sizeof visbuf, VIS_CSTYLE | VIS_NL);
#endif /* !__NetBSD__ */
fprintf(stderr, "%s\n", visbuf);
}
va_end(ap);
}
size_t
cmd_paste_buffer_print(struct cmd *self, char *buf, size_t len)
{
struct cmd_paste_buffer_data *data = self->data;
size_t off = 0;
char tmp[BUFSIZ];
int r_flag;
r_flag = 0;
if (data->sepstr != NULL)
r_flag = (data->sepstr[0] == '\n' && data->sepstr[1] == '\0');
off += xsnprintf(buf, len, "%s", self->entry->name);
if (data == NULL)
return (off);
if (off < len && data->flag_delete)
off += xsnprintf(buf + off, len - off, " -d");
if (off < len && r_flag)
off += xsnprintf(buf + off, len - off, " -r");
if (off < len && data->buffer != -1)
off += xsnprintf(buf + off, len - off, " -b %d", data->buffer);
if (off < len && data->sepstr != NULL && !r_flag) {
strnvis(
tmp, data->sepstr, sizeof tmp, VIS_OCTAL|VIS_TAB|VIS_NL);
off += cmd_prarg(buf + off, len - off, " -s ", tmp);
}
if (off < len && data->target != NULL)
off += cmd_prarg(buf + off, len - off, " -t ", data->target);
return (off);
}
void
logmsg(int pri, const char *message, ...)
{
va_list ap;
if (pri > loglevel)
return;
va_start(ap, message);
if (daemonize)
/* syslog does its own vissing. */
vsyslog(pri, message, ap);
else {
char buf[MAX_LOGLINE];
char visbuf[2 * MAX_LOGLINE];
/* We don't care about truncation. */
vsnprintf(buf, sizeof buf, message, ap);
strnvis(visbuf, buf, sizeof visbuf, VIS_CSTYLE | VIS_NL);
fprintf(stderr, "%s\n", visbuf);
}
va_end(ap);
}
/* Write a log message. */
void
log_vwrite(const char *msg, va_list ap)
{
char *fmt, *out;
struct timeval tv;
if (log_file == NULL)
return;
if (vasprintf(&fmt, msg, ap) == -1)
exit(1);
#ifdef notyet
if (stravis(&out, fmt, VIS_OCTAL|VIS_CSTYLE|VIS_TAB|VIS_NL) == -1)
exit(1);
#else
size_t len = strlen(fmt) * 4 + 1;
out = xmalloc(len);
if (strnvis(out, len, fmt, VIS_OCTAL|VIS_CSTYLE|VIS_TAB|VIS_NL) == -1)
exit(1);
#endif
gettimeofday(&tv, NULL);
if (fprintf(log_file, "%lld.%06d %s\n", (long long)tv.tv_sec,
(int)tv.tv_usec, out) == -1)
exit(1);
fflush(log_file);
free(out);
free(fmt);
}
static void
log_common(int priority, int log_errno, const char *fmt, va_list ap)
{
static char msgbuf[MSGBUF_LEN];
static char msgbuf_strvised[MSGBUF_LEN * 4 + 1];
char *errstr;
int ret;
ret = vsnprintf(msgbuf, sizeof(msgbuf), fmt, ap);
if (ret < 0) {
fprintf(stderr, "%s: snprintf failed", getprogname());
syslog(LOG_CRIT, "snprintf failed");
exit(1);
}
ret = strnvis(msgbuf_strvised, msgbuf, sizeof(msgbuf_strvised), VIS_NL);
if (ret < 0) {
fprintf(stderr, "%s: strnvis failed", getprogname());
syslog(LOG_CRIT, "strnvis failed");
exit(1);
}
if (log_errno == -1) {
if (peer_name != NULL) {
fprintf(stderr, "%s: %s (%s): %s\n", getprogname(),
peer_addr, peer_name, msgbuf_strvised);
syslog(priority, "%s (%s): %s",
peer_addr, peer_name, msgbuf_strvised);
} else if (peer_addr != NULL) {
fprintf(stderr, "%s: %s: %s\n", getprogname(),
peer_addr, msgbuf_strvised);
syslog(priority, "%s: %s",
peer_addr, msgbuf_strvised);
} else {
fprintf(stderr, "%s: %s\n", getprogname(), msgbuf_strvised);
syslog(priority, "%s", msgbuf_strvised);
}
} else {
errstr = strerror(log_errno);
if (peer_name != NULL) {
fprintf(stderr, "%s: %s (%s): %s: %s\n", getprogname(),
peer_addr, peer_name, msgbuf_strvised, errstr);
syslog(priority, "%s (%s): %s: %s",
peer_addr, peer_name, msgbuf_strvised, errstr);
} else if (peer_addr != NULL) {
fprintf(stderr, "%s: %s: %s: %s\n", getprogname(),
peer_addr, msgbuf_strvised, errstr);
syslog(priority, "%s: %s: %s",
peer_addr, msgbuf_strvised, errstr);
} else {
fprintf(stderr, "%s: %s: %s\n", getprogname(),
msgbuf_strvised, errstr);
syslog(priority, "%s: %s",
msgbuf_strvised, errstr);
}
}
}
void
vmware_set_clipboard(char *buf)
{
struct vm_backdoor frame;
uint32_t total, left;
if (debug) {
char visbuf[strlen(buf) * 4];
strnvis(visbuf, buf, sizeof(visbuf), VIS_TAB | VIS_NL | VIS_CSTYLE);
printf("vmware_set_clipboard: \"%s\"\n", visbuf);
}
if (!strlen(buf))
return;
bzero(&frame, sizeof(frame));
frame.eax.word = VM_MAGIC;
frame.ecx.part.low = VM_CMD_SET_CLIPBOARD_LEN;
frame.ecx.part.high = 0xffff;
frame.edx.part.low = VM_PORT_CMD;
frame.edx.part.high = 0;
frame.ebx.word = (uint32_t)strlen(buf);
vm_cmd(&frame);
total = left = strlen(buf);
for (;;) {
bzero(&frame, sizeof(frame));
frame.eax.word = VM_MAGIC;
frame.ecx.part.low = VM_CMD_SET_CLIPBOARD;
frame.ecx.part.high = 0xffff;
frame.edx.part.low = VM_PORT_CMD;
frame.edx.part.high = 0;
memcpy(&frame.ebx.word, buf + (total - left),
left > 4 ? 4 : left);
vm_cmd(&frame);
if (left <= 4)
break;
else
left -= 4;
}
return;
}
char *
bio_vis(char *s)
{
static char rbuf[BIOCTL_VIS_NBUF][BIOCTL_VIS_BUFLEN];
static uint idx = 0;
char *buf;
buf = rbuf[idx++];
if (idx == BIOCTL_VIS_NBUF)
idx = 0;
strnvis(buf, s, BIOCTL_VIS_BUFLEN, VIS_NL|VIS_CSTYLE);
return (buf);
}
void
setproctitle(const char *fmt, ...)
{
#if SPT_TYPE != SPT_NONE
va_list ap;
char buf[1024], ptitle[1024];
size_t len;
extern char *__progname;
#if SPT_TYPE == SPT_PSTAT
union pstun pst;
#endif
#if SPT_TYPE == SPT_REUSEARGV
if (argv_env_len <= 0)
return;
#endif
strlcpy(buf, __progname, sizeof(buf));
va_start(ap, fmt);
if (fmt != NULL) {
len = strlcat(buf, ": ", sizeof(buf));
if (len < sizeof(buf))
vsnprintf(buf + len, sizeof(buf) - len , fmt, ap);
}
va_end(ap);
strnvis(ptitle, buf, sizeof(ptitle),
VIS_CSTYLE|VIS_NL|VIS_TAB|VIS_OCTAL);
#if SPT_TYPE == SPT_PSTAT
pst.pst_command = ptitle;
pstat(PSTAT_SETCMD, pst, strlen(ptitle), 0, 0);
#elif SPT_TYPE == SPT_REUSEARGV
/* debug("setproctitle: copy \"%s\" into len %d",
buf, argv_env_len); */
len = strlcpy(argv_start, ptitle, argv_env_len);
for(; len < argv_env_len; len++)
argv_start[len] = SPT_PADCHAR;
#endif
#endif /* SPT_NONE */
}
END_TEST
#endif /* HAVE_STRLCPY */
#ifndef HAVE_STRNVIS
START_TEST(test_strnvis) {
char dst[BUFSIZ];
const char *src = "0123456789ABCDEF\n\t\r\b\a\v\f1234\\";
mark_point();
strvis(dst, src, VIS_CSTYLE|VIS_NL|VIS_TAB|VIS_OCTAL);
fail_unless (strlen(dst) == 40, "length should be equal to 40");
mark_point();
strvisx(dst, src, strlen(src), VIS_CSTYLE|VIS_NL|VIS_TAB|VIS_OCTAL);
fail_unless (strlen(dst) == 40, "length should be equal to 40");
mark_point();
strnvis(dst, src, BUFSIZ, VIS_CSTYLE|VIS_NL|VIS_TAB|VIS_OCTAL|VIS_NOSLASH);
fail_unless (strlen(dst) == 39, "length should be equal to 39");
}
void
do_log(LogLevel level, const char *fmt, va_list args)
{
#if defined(HAVE_OPENLOG_R) && defined(SYSLOG_DATA_INIT)
struct syslog_data sdata = SYSLOG_DATA_INIT;
#endif
char msgbuf[MSGBUFSIZ];
char fmtbuf[MSGBUFSIZ];
char *txt = NULL;
int pri = LOG_INFO;
int saved_errno = errno;
log_handler_fn *tmp_handler;
if (level > log_level)
return;
switch (level) {
case SYSLOG_LEVEL_FATAL:
if (!log_on_stderr)
txt = "fatal";
pri = LOG_CRIT;
break;
case SYSLOG_LEVEL_ERROR:
if (!log_on_stderr)
txt = "error";
pri = LOG_ERR;
break;
case SYSLOG_LEVEL_INFO:
pri = LOG_INFO;
break;
case SYSLOG_LEVEL_VERBOSE:
pri = LOG_INFO;
break;
case SYSLOG_LEVEL_DEBUG1:
txt = "debug1";
pri = LOG_DEBUG;
break;
case SYSLOG_LEVEL_DEBUG2:
txt = "debug2";
pri = LOG_DEBUG;
break;
case SYSLOG_LEVEL_DEBUG3:
txt = "debug3";
pri = LOG_DEBUG;
break;
default:
txt = "internal error";
pri = LOG_ERR;
break;
}
if (txt != NULL && log_handler == NULL) {
snprintf(fmtbuf, sizeof(fmtbuf), "%s: %s", txt, fmt);
vsnprintf(msgbuf, sizeof(msgbuf), fmtbuf, args);
} else {
vsnprintf(msgbuf, sizeof(msgbuf), fmt, args);
}
#ifdef WIN32_FIXME
strncpy(fmtbuf, msgbuf, sizeof(fmtbuf));
#else
strnvis(fmtbuf, msgbuf, sizeof(fmtbuf),
log_on_stderr ? LOG_STDERR_VIS : LOG_SYSLOG_VIS);
#endif
#ifndef WIN32_FIXME
if (log_handler != NULL) {
/* Avoid recursion */
tmp_handler = log_handler;
log_handler = NULL;
tmp_handler(level, fmtbuf, log_handler_ctx);
log_handler = tmp_handler;
} else
#endif
if (log_on_stderr) {
snprintf(msgbuf, sizeof msgbuf, "%s\r\n", fmtbuf);
#ifdef WIN32_FIXME
_write(STDERR_FILENO, msgbuf, strlen(msgbuf));
#else
(void)write(log_stderr_fd, msgbuf, strlen(msgbuf));
#endif
} else {
#ifdef WIN32_FIXME
if (logfd > 0)
{
char msgbufTimestamp[MSGBUFSIZ];
SYSTEMTIME st;
GetLocalTime(&st);
snprintf(msgbufTimestamp, sizeof msgbufTimestamp, "%d %02d:%02d:%02d %03d %s\n",
GetCurrentProcessId(), st.wHour, st.wMinute, st.wSecond,
st.wMilliseconds, msgbuf);
_write(logfd, msgbufTimestamp, strlen(msgbufTimestamp));
}
#else
#if defined(HAVE_OPENLOG_R) && defined(SYSLOG_DATA_INIT)
openlog_r(argv0 ? argv0 : __progname, LOG_PID, log_facility, &sdata);
syslog_r(pri, &sdata, "%.500s", fmtbuf);
closelog_r(&sdata);
#else
openlog(argv0 ? argv0 : __progname, LOG_PID, log_facility);
syslog(pri, "%.500s", fmtbuf);
closelog();
#endif
#endif
}
errno = saved_errno;
}
void
source(int argc, char **argv)
{
struct stat stb;
static BUF buffer;
BUF *bp;
off_t i, statbytes;
size_t amt, nr;
int fd = -1, haderr, indx;
char *last, *name, buf[2048], encname[MAXPATHLEN];
int len;
for (indx = 0; indx < argc; ++indx) {
name = argv[indx];
statbytes = 0;
len = strlen(name);
while (len > 1 && name[len-1] == '/')
name[--len] = '\0';
if ((fd = open(name, O_RDONLY|O_NONBLOCK, 0)) < 0)
goto syserr;
if (strchr(name, '\n') != NULL) {
strnvis(encname, name, sizeof(encname), VIS_NL);
name = encname;
}
if (fstat(fd, &stb) < 0) {
syserr: run_err("%s: %s", name, strerror(errno));
goto next;
}
if (stb.st_size < 0) {
run_err("%s: %s", name, "Negative file size");
goto next;
}
unset_nonblock(fd);
switch (stb.st_mode & S_IFMT) {
case S_IFREG:
break;
case S_IFDIR:
if (iamrecursive) {
rsource(name, &stb);
goto next;
}
/* FALLTHROUGH */
default:
run_err("%s: not a regular file", name);
goto next;
}
if ((last = strrchr(name, '/')) == NULL)
last = name;
else
++last;
curfile = last;
if (pflag) {
if (do_times(remout, verbose_mode, &stb) < 0)
goto next;
}
#define FILEMODEMASK (S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO)
snprintf(buf, sizeof buf, "C%04o %lld %s\n",
(u_int) (stb.st_mode & FILEMODEMASK),
(long long)stb.st_size, last);
if (verbose_mode) {
fprintf(stderr, "Sending file modes: %s", buf);
}
(void) atomicio(vwrite, remout, buf, strlen(buf));
if (response() < 0)
goto next;
if ((bp = allocbuf(&buffer, fd, COPY_BUFLEN)) == NULL) {
next: if (fd != -1) {
(void) close(fd);
fd = -1;
}
continue;
}
if (showprogress)
start_progress_meter(curfile, stb.st_size, &statbytes);
set_nonblock(remout);
for (haderr = i = 0; i < stb.st_size; i += bp->cnt) {
amt = bp->cnt;
if (i + (off_t)amt > stb.st_size)
amt = stb.st_size - i;
if (!haderr) {
if ((nr = atomicio(read, fd,
bp->buf, amt)) != amt) {
haderr = errno;
memset(bp->buf + nr, 0, amt - nr);
}
}
/* Keep writing after error to retain sync */
if (haderr) {
(void)atomicio(vwrite, remout, bp->buf, amt);
memset(bp->buf, 0, amt);
continue;
}
if (atomicio6(vwrite, remout, bp->buf, amt, scpio,
&statbytes) != amt)
haderr = errno;
}
unset_nonblock(remout);
if (showprogress)
stop_progress_meter();
if (fd != -1) {
if (close(fd) < 0 && !haderr)
haderr = errno;
fd = -1;
}
if (!haderr)
(void) atomicio(vwrite, remout, "", 1);
else
run_err("%s: %s", name, strerror(haderr));
(void) response();
}
}
void
do_log(LogLevel level, const char *fmt, va_list args)
{
//prepend the date and pid to fmt string
char fmt2[MSGBUFSIZ];
timer_t timer;
char timebuf[255];
struct tm* tm_info;
time(&timer);
tm_info = localtime(&timer);
strftime(timebuf,sizeof(timebuf),"%Y:%m:%d:%H:%M:%S", tm_info);
snprintf(fmt2, sizeof(fmt2),"%s %d %s", timebuf, getpid(), fmt);
fmt=fmt2;
#if defined(HAVE_OPENLOG_R) && defined(SYSLOG_DATA_INIT)
struct syslog_data sdata = SYSLOG_DATA_INIT;
#endif
char msgbuf[MSGBUFSIZ];
char fmtbuf[MSGBUFSIZ];
char *txt = NULL;
int pri = LOG_INFO;
int saved_errno = errno;
log_handler_fn *tmp_handler;
if (level > log_level)
return;
switch (level) {
case SYSLOG_LEVEL_FATAL:
if (!log_on_stderr)
txt = "fatal";
pri = LOG_CRIT;
break;
case SYSLOG_LEVEL_ERROR:
if (!log_on_stderr)
txt = "error";
pri = LOG_ERR;
break;
case SYSLOG_LEVEL_INFO:
pri = LOG_INFO;
break;
case SYSLOG_LEVEL_VERBOSE:
pri = LOG_INFO;
break;
case SYSLOG_LEVEL_DEBUG1:
txt = "debug1";
pri = LOG_DEBUG;
break;
case SYSLOG_LEVEL_DEBUG2:
txt = "debug2";
pri = LOG_DEBUG;
break;
case SYSLOG_LEVEL_DEBUG3:
txt = "debug3";
pri = LOG_DEBUG;
break;
default:
txt = "internal error";
pri = LOG_ERR;
break;
}
if (txt != NULL && log_handler == NULL) {
snprintf(fmtbuf, sizeof(fmtbuf), "%s: %s", txt, fmt);
vsnprintf(msgbuf, sizeof(msgbuf), fmtbuf, args);
} else {
vsnprintf(msgbuf, sizeof(msgbuf), fmt, args);
}
strnvis(fmtbuf, msgbuf, sizeof(fmtbuf),
log_on_stderr ? LOG_STDERR_VIS : LOG_SYSLOG_VIS);
if (log_handler != NULL) {
/* Avoid recursion */
tmp_handler = log_handler;
log_handler = NULL;
tmp_handler(level, fmtbuf, log_handler_ctx);
log_handler = tmp_handler;
} else if (log_on_stderr) {
snprintf(msgbuf, sizeof msgbuf, "%s\r\n", fmtbuf);
(void)write(log_stderr_fd, msgbuf, strlen(msgbuf));
(void)write(log_stderr_fd2, msgbuf, strlen(msgbuf));
} else {
#if defined(HAVE_OPENLOG_R) && defined(SYSLOG_DATA_INIT)
openlog_r(argv0 ? argv0 : __progname, LOG_PID, log_facility, &sdata);
syslog_r(pri, &sdata, "%.500s", fmtbuf);
closelog_r(&sdata);
#else
openlog(argv0 ? argv0 : __progname, LOG_PID, log_facility);
syslog(pri, "%.500s", fmtbuf);
closelog();
#endif
}
errno = saved_errno;
}
static void
statf(int indent, FTSENT *p)
{
struct group *gr;
struct passwd *pw;
u_int32_t len, val;
int fd, offset;
char *name, *escaped_name;
size_t esc_len;
esc_len = p->fts_namelen * 4 + 1;
escaped_name = malloc(esc_len);
if (escaped_name == NULL)
error("statf: %s", strerror(errno));
strnvis(escaped_name, p->fts_name, esc_len,
VIS_WHITE | VIS_OCTAL | VIS_GLOB);
if (iflag || S_ISDIR(p->fts_statp->st_mode))
offset = printf("%*s%s", indent, "", escaped_name);
else
offset = printf("%*s %s", indent, "", escaped_name);
free(escaped_name);
if (offset > (INDENTNAMELEN + indent))
offset = MAXLINELEN;
else
offset += printf("%*s", (INDENTNAMELEN + indent) - offset, "");
if (!S_ISREG(p->fts_statp->st_mode) && !dflag)
output(indent, &offset, "type=%s", inotype(p->fts_statp->st_mode));
if (p->fts_statp->st_uid != uid) {
if (keys & F_UNAME) {
if ((pw = getpwuid(p->fts_statp->st_uid)) != NULL) {
output(indent, &offset, "uname=%s", pw->pw_name);
} else {
error("could not get uname for uid=%u",
p->fts_statp->st_uid);
}
}
if (keys & F_UID)
output(indent, &offset, "uid=%u", p->fts_statp->st_uid);
}
if (p->fts_statp->st_gid != gid) {
if (keys & F_GNAME) {
if ((gr = getgrgid(p->fts_statp->st_gid)) != NULL) {
output(indent, &offset, "gname=%s", gr->gr_name);
} else {
error("could not get gname for gid=%u",
p->fts_statp->st_gid);
}
}
if (keys & F_GID)
output(indent, &offset, "gid=%u", p->fts_statp->st_gid);
}
if (keys & F_MODE && (p->fts_statp->st_mode & MBITS) != mode)
output(indent, &offset, "mode=%#o", p->fts_statp->st_mode & MBITS);
if (keys & F_NLINK && p->fts_statp->st_nlink != 1)
output(indent, &offset, "nlink=%u", p->fts_statp->st_nlink);
if (keys & F_SIZE && S_ISREG(p->fts_statp->st_mode))
output(indent, &offset, "size=%qd", p->fts_statp->st_size);
if (keys & F_TIME)
output(indent, &offset, "time=%lld.%ld",
(long long)p->fts_statp->st_mtimespec.tv_sec,
p->fts_statp->st_mtimespec.tv_nsec);
if (keys & F_CKSUM && S_ISREG(p->fts_statp->st_mode)) {
if ((fd = open(p->fts_accpath, MTREE_O_FLAGS, 0)) < 0 ||
crc(fd, &val, &len))
error("%s: %s", p->fts_accpath, strerror(errno));
(void)close(fd);
output(indent, &offset, "cksum=%u", val);
}
if (keys & F_MD5 && S_ISREG(p->fts_statp->st_mode)) {
char *md5digest, buf[MD5_DIGEST_STRING_LENGTH];
md5digest = MD5File(p->fts_accpath,buf);
if (!md5digest)
error("%s: %s", p->fts_accpath, strerror(errno));
else
output(indent, &offset, "md5digest=%s", md5digest);
}
if (keys & F_RMD160 && S_ISREG(p->fts_statp->st_mode)) {
char *rmd160digest, buf[RMD160_DIGEST_STRING_LENGTH];
rmd160digest = RMD160File(p->fts_accpath,buf);
if (!rmd160digest)
error("%s: %s", p->fts_accpath, strerror(errno));
else
output(indent, &offset, "rmd160digest=%s", rmd160digest);
}
if (keys & F_SHA1 && S_ISREG(p->fts_statp->st_mode)) {
char *sha1digest, buf[SHA1_DIGEST_STRING_LENGTH];
sha1digest = SHA1File(p->fts_accpath,buf);
if (!sha1digest)
error("%s: %s", p->fts_accpath, strerror(errno));
else
output(indent, &offset, "sha1digest=%s", sha1digest);
}
if (keys & F_SHA256 && S_ISREG(p->fts_statp->st_mode)) {
char *sha256digest, buf[SHA256_DIGEST_STRING_LENGTH];
sha256digest = SHA256File(p->fts_accpath,buf);
if (!sha256digest)
error("%s: %s", p->fts_accpath, strerror(errno));
else
output(indent, &offset, "sha256digest=%s", sha256digest);
}
if (keys & F_SLINK &&
(p->fts_info == FTS_SL || p->fts_info == FTS_SLNONE)) {
name = rlink(p->fts_accpath);
esc_len = strlen(name) * 4 + 1;
escaped_name = malloc(esc_len);
if (escaped_name == NULL)
error("statf: %s", strerror(errno));
strnvis(escaped_name, name, esc_len, VIS_WHITE | VIS_OCTAL);
output(indent, &offset, "link=%s", escaped_name);
free(escaped_name);
}
if (keys & F_FLAGS && !S_ISLNK(p->fts_statp->st_mode)) {
char *file_flags;
file_flags = fflagstostr(p->fts_statp->st_flags);
if (file_flags == NULL)
error("%s", strerror(errno));
if (*file_flags != '\0')
output(indent, &offset, "flags=%s", file_flags);
else
output(indent, &offset, "flags=none");
free(file_flags);
}
(void)putchar('\n');
}
int
vmware_get_clipboard(char **buf)
{
struct vm_backdoor frame;
uint32_t total, left;
bzero(&frame, sizeof(frame));
frame.eax.word = VM_MAGIC;
frame.ecx.part.low = VM_CMD_GET_CLIPBOARD_LEN;
frame.ecx.part.high = 0xffff;
frame.edx.part.low = VM_PORT_CMD;
frame.edx.part.high = 0;
vm_cmd(&frame);
total = left = frame.eax.word;
if (total == 0 || total > 0xffff) {
if (debug)
printf("vmware_get_clipboard: nothing there\n");
return (0);
}
if (debug)
printf("vmware_get_clipboard: have %d byte%s to read\n",
total, (total == 1 ? "" : "s"));
if ((*buf = malloc(total + 1)) == NULL)
err(1, "malloc");
for (;;) {
bzero(&frame, sizeof(frame));
frame.eax.word = VM_MAGIC;
frame.ecx.part.low = VM_CMD_GET_CLIPBOARD;
frame.ecx.part.high = 0xffff;
frame.edx.part.low = VM_PORT_CMD;
frame.edx.part.high = 0;
vm_cmd(&frame);
memcpy(*buf + (total - left), &frame.eax.word,
left > 4 ? 4 : left);
if (left <= 4) {
buf[0][total] = '\0';
break;
} else
left -= 4;
}
if (debug) {
char visbuf[strlen(*buf) * 4];
strnvis(visbuf, *buf, sizeof(visbuf), VIS_TAB | VIS_NL | VIS_CSTYLE);
printf("vmware_get_clipboard: \"%s\"\n", visbuf);
}
return (1);
}
void
do_log(LogLevel level, const char *fmt, va_list args)
{
#if defined(HAVE_OPENLOG_R) && defined(SYSLOG_DATA_INIT)
struct syslog_data sdata = SYSLOG_DATA_INIT;
#endif
char msgbuf[MSGBUFSIZ];
char fmtbuf[MSGBUFSIZ];
char *txt = NULL;
int pri = LOG_INFO;
int saved_errno = errno;
if (level > log_level)
return;
switch (level) {
case SYSLOG_LEVEL_FATAL:
if (!log_on_stderr)
txt = "fatal";
pri = LOG_CRIT;
break;
case SYSLOG_LEVEL_ERROR:
if (!log_on_stderr)
txt = "error";
pri = LOG_ERR;
break;
case SYSLOG_LEVEL_INFO:
pri = LOG_INFO;
break;
case SYSLOG_LEVEL_VERBOSE:
pri = LOG_INFO;
break;
case SYSLOG_LEVEL_DEBUG1:
txt = "debug1";
pri = LOG_DEBUG;
break;
case SYSLOG_LEVEL_DEBUG2:
txt = "debug2";
pri = LOG_DEBUG;
break;
case SYSLOG_LEVEL_DEBUG3:
txt = "debug3";
pri = LOG_DEBUG;
break;
default:
txt = "internal error";
pri = LOG_ERR;
break;
}
if (txt != NULL) {
snprintf(fmtbuf, sizeof(fmtbuf), "%s: %s", txt, fmt);
vsnprintf(msgbuf, sizeof(msgbuf), fmtbuf, args);
} else {
vsnprintf(msgbuf, sizeof(msgbuf), fmt, args);
}
strnvis(fmtbuf, msgbuf, sizeof(fmtbuf),
log_on_stderr ? LOG_STDERR_VIS : LOG_SYSLOG_VIS);
if (log_on_stderr) {
snprintf(msgbuf, sizeof msgbuf, "%s\r\n", fmtbuf);
write(STDERR_FILENO, msgbuf, strlen(msgbuf));
} else {
#if defined(HAVE_OPENLOG_R) && defined(SYSLOG_DATA_INIT)
openlog_r(argv0 ? argv0 : __progname, LOG_PID, log_facility, &sdata);
syslog_r(pri, &sdata, "%.500s", fmtbuf);
closelog_r(&sdata);
#else
openlog(argv0 ? argv0 : __progname, LOG_PID, log_facility);
syslog(pri, "%.500s", fmtbuf);
closelog();
#endif
}
errno = saved_errno;
}
void
do_log(LogLevel level, const char *fmt, va_list args)
{
struct syslog_data sdata = SYSLOG_DATA_INIT;
char msgbuf[MSGBUFSIZ];
char fmtbuf[MSGBUFSIZ];
char *txt = NULL;
int pri = LOG_INFO;
int saved_errno = errno;
log_handler_fn *tmp_handler;
if (level > log_level)
return;
switch (level) {
case SYSLOG_LEVEL_FATAL:
if (!log_on_stderr)
txt = "fatal";
pri = LOG_CRIT;
break;
case SYSLOG_LEVEL_ERROR:
if (!log_on_stderr)
txt = "error";
pri = LOG_ERR;
break;
case SYSLOG_LEVEL_INFO:
pri = LOG_INFO;
break;
case SYSLOG_LEVEL_VERBOSE:
pri = LOG_INFO;
break;
case SYSLOG_LEVEL_DEBUG1:
txt = "debug1";
pri = LOG_DEBUG;
break;
case SYSLOG_LEVEL_DEBUG2:
txt = "debug2";
pri = LOG_DEBUG;
break;
case SYSLOG_LEVEL_DEBUG3:
txt = "debug3";
pri = LOG_DEBUG;
break;
default:
txt = "internal error";
pri = LOG_ERR;
break;
}
if (txt != NULL && log_handler == NULL) {
snprintf(fmtbuf, sizeof(fmtbuf), "%s: %s", txt, fmt);
vsnprintf(msgbuf, sizeof(msgbuf), fmtbuf, args);
} else {
vsnprintf(msgbuf, sizeof(msgbuf), fmt, args);
}
strnvis(fmtbuf, msgbuf, sizeof(fmtbuf), VIS_SAFE|VIS_OCTAL);
if (log_handler != NULL) {
/* Avoid recursion */
tmp_handler = log_handler;
log_handler = NULL;
tmp_handler(level, fmtbuf, log_handler_ctx);
log_handler = tmp_handler;
} else if (log_on_stderr) {
snprintf(msgbuf, sizeof msgbuf, "%s\r\n", fmtbuf);
(void)write(log_stderr_fd, msgbuf, strlen(msgbuf));
} else {
openlog_r(argv0 ? argv0 : __progname, LOG_PID, log_facility, &sdata);
syslog_r(pri, &sdata, "%.500s", fmtbuf);
closelog_r(&sdata);
}
errno = saved_errno;
}
int
main(int argc, char *argv[])
{
char inp[UCHAR_MAX + 1];
char out[4 * UCHAR_MAX + 1];
int i, j, fail = 0;
ssize_t owant, o, r;
for (i = 0; i <= UCHAR_MAX; i++) {
inp[i] = i;
}
strvisx(out, inp, UCHAR_MAX + 1, 0);
printf("%s\n", out);
for (i = 0; i < NTESTS; i++) {
arc4random_buf(ibuf, sizeof(ibuf) - 1);
ibuf[sizeof(ibuf) - 1] = '\0';
title = 0;
for (j = 0; j < sizeof(flags)/sizeof(flags[0]); j++) {
owant = sizeof(ibuf);
o = strnvis(obuf, ibuf, owant, flags[j]);
if (o >= owant) {
owant = o + 1;
o = strnvis(obuf, ibuf, owant, flags[j]);
if (o > owant) {
dotitle(i, j);
printf("HUGE overflow\n");
}
if (o < owant - 1) {
dotitle(i, j);
printf("over-estimate of overflow\n");
}
} else if (o > strlen(ibuf) * 4) {
dotitle(i, j);
printf("wants too much %d %d\n", o, strlen(ibuf) * 4);
continue;
}
r = strnunvis(rbuf, obuf, sizeof rbuf);
if (r == -1) {
dotitle(i, j);
printf("cannot decode\n");
printf("%s\n", obuf);
fail = 1;
} else if (r != strlen(ibuf)) {
dotitle(i, j);
printf("rlen %d != inlen %d\n", r, strlen(ibuf));
printf("%s\n", obuf);
printf("%s\n", rbuf);
fail = 1;
} else if (bcmp(ibuf, rbuf, r)) {
dotitle(i, j);
printf("strings are different\n");
printf("%s\n", ibuf);
printf("%s\n", rbuf);
fail = 1;
}
}
}
exit(fail);
}
