/*
* Dump contents of resource
*/
void dump_resource(int type, RES *reshdr,
void sendit(void *sock, const char *fmt, ...),
void *sock, bool hide_sensitive_data)
{
POOL_MEM buf;
URES *res = (URES *)reshdr;
BRSRES *resclass;
bool recurse = true;
if (res == NULL) {
sendit(sock, _("Warning: no \"%s\" resource (%d) defined.\n"), res_to_str(type), type);
return;
}
if (type < 0) { /* no recursion */
type = - type;
recurse = false;
}
switch (type) {
default:
resclass = (BRSRES *)reshdr;
resclass->print_config(buf);
break;
}
sendit(sock, "%s", buf.c_str());
if (recurse && res->res_dir.hdr.next) {
dump_resource(type, res->res_dir.hdr.next, sendit, sock, hide_sensitive_data);
}
}
void list_spool_stats(void sendit(const char *msg, int len, void *sarg), void *arg)
{
char ed1[30], ed2[30];
POOL_MEM msg(PM_MESSAGE);
int len;
len = Mmsg(msg, _("Spooling statistics:\n"));
if (spool_stats.data_jobs || spool_stats.max_data_size) {
len = Mmsg(msg, _("Data spooling: %u active jobs, %s bytes; %u total jobs, %s max bytes/job.\n"),
spool_stats.data_jobs, edit_uint64_with_commas(spool_stats.data_size, ed1),
spool_stats.total_data_jobs,
edit_uint64_with_commas(spool_stats.max_data_size, ed2));
sendit(msg.c_str(), len, arg);
}
if (spool_stats.attr_jobs || spool_stats.max_attr_size) {
len = Mmsg(msg, _("Attr spooling: %u active jobs, %s bytes; %u total jobs, %s max bytes.\n"),
spool_stats.attr_jobs, edit_uint64_with_commas(spool_stats.attr_size, ed1),
spool_stats.total_attr_jobs,
edit_uint64_with_commas(spool_stats.max_attr_size, ed2));
sendit(msg.c_str(), len, arg);
}
}
int vibrator_on(int timeout_ms)
{
/* constant on, up to maximum allowed time */
if(timeout_ms < 0)
return sendit(15000);
return sendit(timeout_ms);
}
void PrintWinnings(int sock) {
int i;
char buf[100];
sendit(sock, "Bets so far:\n");
for (i = 0; i < total_bets; i++) {
snprintf(buf, 99, "%d (%02x)\n", winnings[i], winnings[i] & 0xFF);
sendit(sock, buf);
}
}
static void list_resources(STATUS_PKT *sp)
{
#ifdef when_working
POOL_MEM msg(PM_MESSAGE);
int len;
len = Mmsg(msg, _("\nSD Resources:\n"));
if (!sp->api) sendit(msg, len, sp);
dump_resource(R_DEVICE, resources[R_DEVICE - R_FIRST], sp);
if (!sp->api) sendit("====\n\n", 6, sp);
#endif
}
static int do_a_command(FILE *input, BSOCK *UA_sock)
{
unsigned int i;
int status;
int found;
int len;
char *cmd;
found = 0;
status = 1;
Dmsg1(120, "Command: %s\n", UA_sock->msg);
if (argc == 0) {
return 1;
}
cmd = argk[0]+1;
if (*cmd == '#') { /* comment */
return 1;
}
len = strlen(cmd);
for (i=0; i<comsize; i++) { /* search for command */
if (bstrncasecmp(cmd, _(commands[i].key), len)) {
status = (*commands[i].func)(input, UA_sock); /* go execute command */
found = 1;
break;
}
}
if (!found) {
pm_strcat(&UA_sock->msg, _(": is an invalid command\n"));
UA_sock->msglen = strlen(UA_sock->msg);
sendit(UA_sock->msg);
}
return status;
}
int
sys_sendmsg(struct proc *p, void *v, register_t *retval)
{
struct sys_sendmsg_args /* {
syscallarg(int) s;
syscallarg(const struct msghdr *) msg;
syscallarg(int) flags;
} */ *uap = v;
struct msghdr msg;
struct iovec aiov[UIO_SMALLIOV], *iov;
int error;
error = copyin(SCARG(uap, msg), &msg, sizeof (msg));
if (error)
return (error);
if (msg.msg_iovlen > IOV_MAX)
return (EMSGSIZE);
if (msg.msg_iovlen > UIO_SMALLIOV)
iov = malloc(sizeof(struct iovec) * msg.msg_iovlen,
M_IOV, M_WAITOK);
else
iov = aiov;
if (msg.msg_iovlen &&
(error = copyin(msg.msg_iov, iov,
(unsigned)(msg.msg_iovlen * sizeof (struct iovec)))))
goto done;
msg.msg_iov = iov;
msg.msg_flags = 0;
error = sendit(p, SCARG(uap, s), &msg, SCARG(uap, flags), retval);
done:
if (iov != aiov)
free(iov, M_IOV);
return (error);
}
/*
* Return 1 if OK
* 0 if no input
* -1 error (must stop)
*/
int get_cmd(FILE *input, const char *prompt, BSOCK *sock, int sec)
{
static char *line = NULL;
static char *next = NULL;
static int do_history = 0;
char *command;
if (line == NULL) {
do_history = 0;
rl_catch_signals = 0; /* do it ourselves */
/* Here, readline does ***real*** malloc
* so, be we have to use the real free
*/
line = readline((char *)prompt); /* cast needed for old readlines */
if (!line) {
return -1; /* error return and exit */
}
strip_trailing_junk(line);
command = line;
} else if (next) {
command = next + 1;
} else {
sendit(_("Command logic problem\n"));
sock->msglen = 0;
sock->msg[0] = 0;
return 0; /* No input */
}
/*
* Split "line" into multiple commands separated by the eol character.
* Each part is pointed to by "next" until finally it becomes null.
*/
if (eol == '\0') {
next = NULL;
} else {
next = strchr(command, eol);
if (next) {
*next = '\0';
}
}
if (command != line && isatty(fileno(input))) {
senditf("%s%s\n", prompt, command);
}
sock->msglen = pm_strcpy(&sock->msg, command);
if (sock->msglen) {
do_history++;
}
if (!next) {
if (do_history) {
add_history(line);
}
actuallyfree(line); /* allocated by readline() malloc */
line = NULL;
}
return 1; /* OK */
}
void PrintHand(int sock, char *hand, int hide_first) {
int i;
char buf[10];
for (i = 0; i < 21; i++) {
if (hide_first && i == 0) {
sendit(sock, "X ");
continue;
}
if (hand[i] == 0) {
break;
}
if (hand[i] == 1) {
sendit(sock, "A ");
} else if (hand[i] == 11) {
sendit(sock, "J ");
} else if (hand[i] == 12) {
sendit(sock, "Q ");
} else if (hand[i] == 13) {
sendit(sock, "K ");
} else {
snprintf(buf, 9, "%d ", hand[i]);
sendit(sock, buf);
}
}
if (!hide_first) {
snprintf(buf, 9, "(%d)", CalculateHandValue(hand));
sendit(sock, buf);
}
}
int main()
{
/* Setup network socket */
memset(&hints, 0, sizeof(hints));
hints.ai_flags = AI_ADDRCONFIG | AI_CANONNAME;
hints.ai_socktype = SOCK_STREAM;
if ( (err = getaddrinfo(host,port,&hints,&server_ais)) ) {
error(0,"getaddrinfo: %s",gai_strerror(err));
}
/* Try to connect to addresses for server in given order */
socket_fd = -1;
for(server_ai=server_ais; server_ai!=NULL; server_ai=server_ai->ai_next) {
err = getnameinfo(server_ai->ai_addr,server_ai->ai_addrlen,server_addr,
sizeof(server_addr),NULL,0,NI_NUMERICHOST);
if ( err!=0 ) error(0,"getnameinfo: %s",gai_strerror(err));
socket_fd = socket(server_ai->ai_family,server_ai->ai_socktype,
server_ai->ai_protocol);
if ( socket_fd>=0 ) {
if ( connect(socket_fd,server_ai->ai_addr,server_ai->ai_addrlen)==0 ) {
break;
} else {
close(socket_fd);
socket_fd = -1;
}
}
}
if ( socket_fd<0 ) error(0,"cannot connect to %s via %s",host,port);
/* Set socket timeout option on read/write */
timeout.tv_sec = 10;
timeout.tv_usec = 0;
if ( setsockopt(socket_fd,SOL_SOCKET,SO_SNDTIMEO,&timeout,sizeof(timeout)) < 0) {
error(errno,"setting socket option");
}
if ( setsockopt(socket_fd,SOL_SOCKET,SO_RCVTIMEO,&timeout,sizeof(timeout)) < 0) {
error(errno,"setting socket option");
}
printf("Connected, server address is `%s'\nsending `%s'...\n",server_addr,request);
sendit(socket_fd,request);
/* Keep reading until end of file, then check for errors */
while ( receive(socket_fd) ) printf("%s",buffer);
freeaddrinfo(server_ais);
return 0;
}
static int eolcmd(FILE *input, BSOCK *UA_sock)
{
if ((argc > 1) && (strchr("!$%&'()*+,-/:;<>?[]^`{|}~", argk[1][0]) != NULL)) {
eol = argk[1][0];
} else if (argc == 1) {
eol = '\0';
} else {
sendit(_("Illegal separator character.\n"));
}
return 1;
}
/*
* List Volumes -- this should be moved to status.c
*/
void list_volumes(void sendit(const char *msg, int len, void *sarg), void *arg)
{
VOLRES *vol;
POOL_MEM msg(PM_MESSAGE);
int len;
lock_volumes();
foreach_dlist(vol, vol_list) {
DEVICE *dev = vol->dev;
if (dev) {
len = Mmsg(msg, "%s on device %s\n", vol->vol_name, dev->print_name());
sendit(msg.c_str(), len, arg);
len = Mmsg(msg, " Reader=%d writers=%d devres=%d volinuse=%d\n",
dev->can_read()?1:0, dev->num_writers, dev->num_reserved(),
vol->is_in_use());
sendit(msg.c_str(), len, arg);
} else {
len = Mmsg(msg, "%s no device. volinuse= %d\n", vol->vol_name,
vol->is_in_use());
sendit(msg.c_str(), len, arg);
}
}
/*
* Status command from Director
*/
static void output_status(JCR *jcr, STATUS_PKT *sp)
{
POOL_MEM msg(PM_MESSAGE);
int len;
list_status_header(sp);
/*
* List running jobs
*/
list_running_jobs(sp);
/*
* List jobs stuck in reservation system
*/
list_jobs_waiting_on_reservation(sp);
/*
* List terminated jobs
*/
list_terminated_jobs(sp);
/*
* List devices
*/
list_devices(jcr, sp);
len = Mmsg(msg, _("Used Volume status:\n"));
if (!sp->api) sendit(msg, len, sp);
list_volumes(sendit, (void *)sp);
if (!sp->api) sendit("====\n\n", 6, sp);
list_spool_stats(sendit, (void *)sp);
if (!sp->api) sendit("====\n\n", 6, sp);
}
static bool select_director(const char *director, DIRRES **ret_dir, CONRES **ret_cons)
{
int numcon=0, numdir=0;
int i=0, item=0;
BSOCK *UA_sock;
DIRRES *dir = NULL;
CONRES *cons = NULL;
*ret_cons = NULL;
*ret_dir = NULL;
LockRes();
numdir = 0;
foreach_res(dir, R_DIRECTOR) {
numdir++;
}
numcon = 0;
foreach_res(cons, R_CONSOLE) {
numcon++;
}
UnlockRes();
if (numdir == 1) { /* No choose */
dir = (DIRRES *)GetNextRes(R_DIRECTOR, NULL);
}
if (director) { /* Command line choice overwrite the no choose option */
LockRes();
foreach_res(dir, R_DIRECTOR) {
if (bstrcmp(dir->name(), director)) {
break;
}
}
UnlockRes();
if (!dir) { /* Can't find Director used as argument */
senditf(_("Can't find %s in Director list\n"), director);
return 0;
}
}
if (!dir) { /* prompt for director */
UA_sock = New(BSOCK_TCP);
try_again:
sendit(_("Available Directors:\n"));
LockRes();
numdir = 0;
foreach_res(dir, R_DIRECTOR) {
senditf( _("%2d: %s at %s:%d\n"), 1+numdir++, dir->name(), dir->address, dir->DIRport);
}
int main(int argc, char *argv[])
{
int nattempts = 0, n, best = 1025, threshold = THRESHOLD;
u08b_t inbuf[MAX_MSG_LEN], hashbuf[HASHLEN];
u08b_t *iter;
srand(time(NULL));
for (;;) {
iter = &inbuf[0];
*iter++ = get_random_char();
*iter = '\0';
for (n = 0; n < ITERS_PER_HUNK; ++n) {
int nbits;
get_hash(inbuf, hashbuf);
nbits = get_bit_diff(hashbuf, target, HASHLEN);
if (nbits < best) {
best = nbits;
iter = &inbuf[0];
if (nbits < threshold) {
puts("\n\nNew best hash found!");
puts("---BEGIN STRING:---");
puts((char *)inbuf);
puts("---END STRING---");
printf("(should be off by %d)\n", nbits);
puts("hex digest of computed hash:");
print_hash_hex_digest(hashbuf, HASHLEN);
threshold = nbits;
puts("Now attempting to upload to the xkcd server...");
sendit(inbuf);
puts("Done!");
}
}
*iter++ = get_random_char();
*iter = '\0';
nattempts++;
}
printf("\r%d hashes compared. Best so far is %d ",
nattempts, best);
}
return 0;
}
/*
* Get next input command from terminal.
*
* Returns: 1 if got input
* 0 if timeout
* -1 if EOF or error
*/
int get_cmd(FILE *input, const char *prompt, BSOCK *sock, int sec)
{
int len;
if (!stop) {
if (output == stdout || teeout) {
sendit(prompt);
}
}
again:
switch (wait_for_readable_fd(fileno(input), sec, true)) {
case 0:
return 0; /* timeout */
case -1:
return -1; /* error */
default:
len = sizeof_pool_memory(sock->msg) - 1;
if (stop) {
sleep(1);
goto again;
}
#ifdef HAVE_CONIO
if (bisatty(fileno(input))) {
input_line(sock->msg, len);
break;
}
#endif
if (fgets(sock->msg, len, input) == NULL) {
return -1;
}
break;
}
if (usrbrk()) {
clrbrk();
}
strip_trailing_junk(sock->msg);
sock->msglen = strlen(sock->msg);
return 1;
}
/*
* Get next input command from terminal.
*
* Returns: 1 if got input
* -1 if EOF or error
*/
int get_cmd(FILE *input, const char *prompt, BSOCK *sock, int sec)
{
int len;
if (!stop) {
if (output == stdout || teeout) {
sendit(prompt);
}
}
again:
len = sizeof_pool_memory(sock->msg) - 1;
if (stop) {
sleep(1);
goto again;
}
#ifdef HAVE_CONIO
if (bisatty(fileno(input))) {
input_line(sock->msg, len);
goto ok_out;
}
#endif
if (input == stdin) {
if (win32_cgets(sock->msg, len) == NULL) {
return -1;
}
} else {
if (fgets(sock->msg, len, input) == NULL) {
return -1;
}
}
if (usrbrk()) {
clrbrk();
}
strip_trailing_junk(sock->msg);
sock->msglen = strlen(sock->msg);
return 1;
}
/*
* Dump contents of resource
*/
void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fmt, ...), void *sock)
{
URES *res = (URES *)reshdr;
bool recurse = true;
char ed1[100], ed2[100];
if (res == NULL) {
sendit(sock, _("No %s resource defined\n"), res_to_str(type));
return;
}
if (type < 0) { /* no recursion */
type = - type;
recurse = false;
}
switch (type) {
case R_MONITOR:
sendit(sock, _("Monitor: name=%s FDtimeout=%s SDtimeout=%s\n"),
reshdr->name,
edit_uint64(res->res_monitor.FDConnectTimeout, ed1),
edit_uint64(res->res_monitor.SDConnectTimeout, ed2));
break;
case R_DIRECTOR:
sendit(sock, _("Director: name=%s address=%s FDport=%d\n"),
res->res_dir.hdr.name, res->res_dir.address, res->res_dir.DIRport);
break;
case R_CLIENT:
sendit(sock, _("Client: name=%s address=%s FDport=%d\n"),
res->res_client.hdr.name, res->res_client.address, res->res_client.FDport);
break;
case R_STORAGE:
sendit(sock, _("Storage: name=%s address=%s SDport=%d\n"),
res->res_store.hdr.name, res->res_store.address, res->res_store.SDport);
break;
case R_CONSOLE_FONT:
sendit(sock, _("ConsoleFont: name=%s font face=%s\n"),
reshdr->name, NPRT(res->con_font.fontface));
break;
default:
sendit(sock, _("Unknown resource type %d in dump_resource.\n"), type);
break;
}
if (recurse && res->res_monitor.hdr.next) {
dump_resource(type, res->res_monitor.hdr.next, sendit, sock);
}
}
/*
* Call-back for reading a passphrase for an encrypted PEM file
* This function uses getpass(),
* which uses a static buffer and is NOT thread-safe.
*/
static int tls_pem_callback(char *buf, int size, const void *userdata)
{
#ifdef HAVE_TLS
const char *prompt = (const char *)userdata;
#if defined(HAVE_WIN32)
sendit(prompt);
if (win32_cgets(buf, size) == NULL) {
buf[0] = 0;
return 0;
} else {
return strlen(buf);
}
#else
char *passwd;
passwd = getpass(prompt);
bstrncpy(buf, passwd, size);
return strlen(buf);
#endif
#else
buf[0] = 0;
return 0;
#endif
}
int
sys_sendto(struct proc *p, void *v, register_t *retval)
{
struct sys_sendto_args /* {
syscallarg(int) s;
syscallarg(const void *) buf;
syscallarg(size_t) len;
syscallarg(int) flags;
syscallarg(const struct sockaddr *) to;
syscallarg(socklen_t) tolen;
} */ *uap = v;
struct msghdr msg;
struct iovec aiov;
msg.msg_name = (caddr_t)SCARG(uap, to);
msg.msg_namelen = SCARG(uap, tolen);
msg.msg_iov = &aiov;
msg.msg_iovlen = 1;
msg.msg_control = 0;
msg.msg_flags = 0;
aiov.iov_base = (char *)SCARG(uap, buf);
aiov.iov_len = SCARG(uap, len);
return (sendit(p, SCARG(uap, s), &msg, SCARG(uap, flags), retval));
}
int TipWaitress(int sock) {
char buf[100];
int rnd;
sendit(sock, "But it's not all bad. The waitress just showed up with your ");
rnd = rand() % MAX_DRINK1;
sendit(sock, drink1[rnd]);
rnd = rand() % MAX_DRINK2;
sendit(sock, drink2[rnd]);
sendit(sock, "Would you like to tip $1 (y/n)? ");
read_until(sock, buf, 99);
if (buf[0] == 'y' || buf[0] == 'Y') {
rnd = rand() % MAX_TIPS;
sendit(sock, tips[rnd]);
return(1);
}
rnd = rand() % MAX_NOTIPS;
sendit(sock, notips[rnd]);
return(0);
}
static void list_terminated_jobs(STATUS_PKT *sp)
{
int len;
struct s_last_job *je;
POOL_MEM msg(PM_MESSAGE);
char level[10], dt[MAX_TIME_LENGTH], b1[30], b2[30];
if (!sp->api) {
len = pm_strcpy(msg, _("\nTerminated Jobs:\n"));
sendit(msg, len, sp);
}
if (last_jobs->size() == 0) {
if (!sp->api) {
len = pm_strcpy(msg, _("====\n"));
sendit(msg, len, sp);
}
return;
}
lock_last_jobs_list();
if (!sp->api) {
len = pm_strcpy(msg, _(" JobId Level Files Bytes Status Finished Name \n"));
sendit(msg, len, sp);
len = pm_strcpy(msg, _("======================================================================\n"));
sendit(msg, len, sp);
}
foreach_dlist(je, last_jobs) {
char *p;
char JobName[MAX_NAME_LENGTH];
const char *termstat;
bstrftime_nc(dt, sizeof(dt), je->end_time);
switch (je->JobType) {
case JT_ADMIN:
case JT_RESTORE:
bstrncpy(level, " ", sizeof(level));
break;
default:
bstrncpy(level, level_to_str(je->JobLevel), sizeof(level));
level[4] = 0;
break;
}
switch (je->JobStatus) {
case JS_Created:
termstat = _("Created");
break;
case JS_FatalError:
case JS_ErrorTerminated:
termstat = _("Error");
break;
case JS_Differences:
termstat = _("Diffs");
break;
case JS_Canceled:
termstat = _("Cancel");
break;
case JS_Terminated:
termstat = _("OK");
break;
default:
termstat = _("Other");
break;
}
bstrncpy(JobName, je->Job, sizeof(JobName));
/*
* There are three periods after the Job name
*/
for (int i=0; i<3; i++) {
if ((p=strrchr(JobName, '.')) != NULL) {
*p = 0;
}
}
if (sp->api) {
len = Mmsg(msg, _("%6d\t%-6s\t%8s\t%10s\t%-7s\t%-8s\t%s\n"),
je->JobId,
level,
edit_uint64_with_commas(je->JobFiles, b1),
edit_uint64_with_suffix(je->JobBytes, b2),
termstat,
dt,
JobName);
} else {
len = Mmsg(msg, _("%6d %-6s %8s %10s %-7s %-8s %s\n"),
je->JobId,
level,
edit_uint64_with_commas(je->JobFiles, b1),
edit_uint64_with_suffix(je->JobBytes, b2),
termstat,
dt,
JobName);
}
sendit(msg, len, sp);
}
void
printjob()
{
struct stat stb;
register struct queue *q, **qp;
struct queue **queue;
register int i, nitems;
long pidoff;
int count = 0;
init(); /* set up capabilities */
(void) write(1, "", 1); /* ack that daemon is started */
(void) close(2); /* set up log file */
if (open(LF, O_WRONLY|O_APPEND, 0664) < 0) {
syslog(LOG_ERR, "%s: %m", LF);
(void) open(_PATH_DEVNULL, O_WRONLY);
}
setgid(getegid());
pid = getpid(); /* for use with lprm */
setpgrp(0, pid);
signal(SIGHUP, abortpr);
signal(SIGINT, abortpr);
signal(SIGQUIT, abortpr);
signal(SIGTERM, abortpr);
(void) mktemp(tempfile);
/*
* uses short form file names
*/
if (chdir(SD) < 0) {
syslog(LOG_ERR, "%s: %m", SD);
exit(1);
}
if (stat(LO, &stb) == 0 && (stb.st_mode & 0100))
exit(0); /* printing disabled */
lfd = open(LO, O_WRONLY|O_CREAT, 0644);
if (lfd < 0) {
syslog(LOG_ERR, "%s: %s: %m", printer, LO);
exit(1);
}
if (flock(lfd, LOCK_EX|LOCK_NB) < 0) {
if (errno == EWOULDBLOCK) /* active deamon present */
exit(0);
syslog(LOG_ERR, "%s: %s: %m", printer, LO);
exit(1);
}
ftruncate(lfd, 0);
/*
* write process id for others to know
*/
sprintf(line, "%u\n", pid);
pidoff = i = strlen(line);
if (write(lfd, line, i) != i) {
syslog(LOG_ERR, "%s: %s: %m", printer, LO);
exit(1);
}
/*
* search the spool directory for work and sort by queue order.
*/
if ((nitems = getq(&queue)) < 0) {
syslog(LOG_ERR, "%s: can't scan %s", printer, SD);
exit(1);
}
if (nitems == 0) /* no work to do */
exit(0);
if (stb.st_mode & 01) { /* reset queue flag */
if (fchmod(lfd, stb.st_mode & 0776) < 0)
syslog(LOG_ERR, "%s: %s: %m", printer, LO);
}
openpr(); /* open printer or remote */
again:
/*
* we found something to do now do it --
* write the name of the current control file into the lock file
* so the spool queue program can tell what we're working on
*/
for (qp = queue; nitems--; free((char *) q)) {
q = *qp++;
if (stat(q->q_name, &stb) < 0)
continue;
restart:
(void) lseek(lfd, (off_t)pidoff, 0);
(void) sprintf(line, "%s\n", q->q_name);
i = strlen(line);
if (write(lfd, line, i) != i)
syslog(LOG_ERR, "%s: %s: %m", printer, LO);
if (!remote)
i = printit(q->q_name);
else
i = sendit(q->q_name);
/*
* Check to see if we are supposed to stop printing or
* if we are to rebuild the queue.
*/
if (fstat(lfd, &stb) == 0) {
/* stop printing before starting next job? */
if (stb.st_mode & 0100)
goto done;
/* rebuild queue (after lpc topq) */
if (stb.st_mode & 01) {
for (free((char *) q); nitems--; free((char *) q))
q = *qp++;
if (fchmod(lfd, stb.st_mode & 0776) < 0)
syslog(LOG_WARNING, "%s: %s: %m",
printer, LO);
break;
}
}
if (i == OK) /* file ok and printed */
count++;
else if (i == REPRINT) { /* try reprinting the job */
syslog(LOG_INFO, "restarting %s", printer);
if (ofilter > 0) {
kill(ofilter, SIGCONT); /* to be sure */
(void) close(ofd);
while ((i = wait(0)) > 0 && i != ofilter)
;
ofilter = 0;
}
(void) close(pfd); /* close printer */
if (ftruncate(lfd, pidoff) < 0)
syslog(LOG_WARNING, "%s: %s: %m", printer, LO);
openpr(); /* try to reopen printer */
goto restart;
}
}
free((char *) queue);
/*
* search the spool directory for more work.
*/
if ((nitems = getq(&queue)) < 0) {
syslog(LOG_ERR, "%s: can't scan %s", printer, SD);
exit(1);
}
if (nitems == 0) { /* no more work to do */
done:
if (count > 0) { /* Files actually printed */
if (!SF && !tof)
(void) write(ofd, FF, strlen(FF));
if (TR != NULL) /* output trailer */
(void) write(ofd, TR, strlen(TR));
}
(void) unlink(tempfile);
exit(0);
}
goto again;
}
int
pipecommand(Window *w, char *s)
{
ulong q0, q1;
char tmp[32], *t;
int n, k;
while(*s==' ' || *s=='\t' || *s=='\n')
s++;
if(strcmp(s, "Delete")==0){
windel(w, 1);
threadexits(nil);
return 1;
}
if(strcmp(s, "Del")==0){
if(windel(w, 0))
threadexits(nil);
return 1;
}
if(strcmp(s, "Send") == 0){
if(w->addr < 0)
w->addr = winopenfile(w, "addr");
ctlprint(w->ctl, "addr=dot\n");
seek(w->addr, 0UL, 0);
if(read(w->addr, tmp, 2*12) == 2*12){
q0 = atol(tmp+0*12);
q1 = atol(tmp+1*12);
if(q0 == q1){
t = nil;
k = 0;
if(snarffd > 0){
seek(0, snarffd, 0);
for(;;){
t = realloc(t, k+8192+2);
if(t == nil)
error("alloc failed: %r\n");
n = read(snarffd, t+k, 8192);
if(n <= 0)
break;
k += n;
}
t[k] = 0;
}
}else{
t = emalloc((q1-q0)*UTFmax+2);
winread(w, q0, q1, t);
k = strlen(t);
}
if(t!=nil && t[0]!='\0'){
if(t[k-1]!='\n' && t[k-1]!='\004'){
t[k++] = '\n';
t[k] = '\0';
}
sendit(t);
}
free(t);
}
return 1;
}
return 0;
}
int vibrator_on(int timeout_ms)
{
/* constant on, up to maximum allowed time */
return sendit(timeout_ms);
}
/*
*
* send command to and receive message from the server
*
*/
int main ( int argc, char *argv[])
{
char cmd[MAX_MODULE_INPUT_TEXT_LEN + 1];
char *f_stem, *fc_name, *fm_name;
char *sf_stem;
char *s;
int i;
int opt;
int ncnt;
int count;
int Rc;
struct timeval tv2;
extern char *optarg;
extern int optind;
#ifdef HAVE_SIGACTION
{
struct sigaction sigact;
sigemptyset(&sigact.sa_mask);
#ifdef SA_RESTART
sigact.sa_flags = SA_RESTART;
#else
sigact.sa_flags = 0;
#endif
sigact.sa_handler = sig_ttin;
sigaction(SIGTTIN, &sigact, NULL);
sigaction(SIGTTOU, &sigact, NULL);
sigaddset(&sigact.sa_mask, SIGINT);
sigaddset(&sigact.sa_mask, SIGHUP);
sigaddset(&sigact.sa_mask, SIGQUIT);
sigaddset(&sigact.sa_mask, SIGTERM);
#ifdef SA_INTERRUPT
sigact.sa_flags = SA_INTERRUPT;
#else
sigact.sa_flags = 0;
#endif
sigact.sa_handler = sig_quit;
sigaction(SIGINT, &sigact, NULL);
sigaction(SIGHUP, &sigact, NULL);
sigaction(SIGQUIT, &sigact, NULL);
sigaction(SIGTERM, &sigact, NULL);
sigaction(SIGPIPE, &sigact, NULL);
}
#else
#ifdef USE_BSD_SIGNALS
fvwmSetSignalMask(
sigmask(SIGINT) | sigmask(SIGHUP) | sigmask(SIGQUIT) |
sigmask(SIGTERM) | sigmask(SIGPIPE));
#endif
signal(SIGINT, sig_quit);
signal(SIGHUP, sig_quit);
signal(SIGQUIT, sig_quit);
signal(SIGTERM, sig_quit);
signal(SIGPIPE, sig_quit);
signal(SIGTTIN, sig_ttin);
signal(SIGTTOU, sig_ttin);
#ifdef HAVE_SIGINTERRUPT
siginterrupt(SIGINT, 1);
siginterrupt(SIGHUP, 1);
siginterrupt(SIGQUIT, 1);
siginterrupt(SIGTERM, 1);
siginterrupt(SIGPIPE, 1);
siginterrupt(SIGTTIN, 0);
siginterrupt(SIGTTOU, 0);
#endif
#endif
Opt_reply = 0;
Opt_info = -1;
f_stem = NULL;
sf_stem = NULL;
Opt_monitor = 0;
Opt_stdin = 0;
Opt_Serv = 0;
Opt_flags = 2;
Tv.tv_sec = 0;
Tv.tv_usec = 500000;
Rc = 0;
Bg = 0;
while( (opt = getopt( argc, argv, "S:hvF:f:w:i:rmc" )) != EOF )
{
switch(opt)
{
case 'h':
usage();
exit(0);
break;
case 'f':
f_stem = optarg;
break;
case 'F':
Opt_flags = atoi (optarg);
break;
case 'S':
sf_stem = optarg;
Opt_Serv = 1;
break;
case 'i':
Opt_info = atoi( optarg );
break;
case 'v':
printf("%s %s\n", MYNAME, VERSION );
exit(0);
case 'w':
Tv.tv_usec = atoi( optarg ) % 1000000;
Tv.tv_sec = atoi( optarg ) / 1000000;
break;
case 'm':
Opt_monitor = 1;
break;
case 'r':
Opt_reply = 1;
break;
case 'c':
Opt_stdin = 1;
break;
case '?':
exit(3);
}
}
if( f_stem == NULL )
{
if ((f_stem = fifos_get_default_name()) == NULL)
{
fprintf (stderr, "\n%s can't decide on fifo-name. "
"Make sure that $FVWM_USERDIR is set.\n",
MYNAME );
exit(1);
}
}
/* create 2 fifos */
fm_name = safemalloc( strlen(f_stem) + 2 );
strcpy(fm_name,f_stem);
strcat(fm_name, "M");
fc_name = safemalloc( strlen(f_stem) + 2 );
strcpy(fc_name,f_stem);
strcat(fc_name, "C");
s = safemalloc( strlen(f_stem) + 2 );
strcpy(s,f_stem);
strcat(s, "R");
Fdrun = open(s, O_WRONLY | O_CREAT | O_EXCL | O_NOFOLLOW, 0600);
if (Fdrun < 0)
{
FILE *f;
if ((f = fopen (s,"r" )) != NULL)
{
char *p;
*cmd = 0;
p = fgets(cmd, 20, f);
(void)p;
fclose(f);
fprintf (stderr, "\nFvwmCommand lock file %sR is detected. "
"This may indicate another FvwmCommand is running. "
"It appears to be running under process ID:\n%s\n",
f_stem, (*cmd) ? cmd : "(unknown)" );
fprintf (stderr, "You may either kill the process or run FvwmCommand "
"with another FIFO set using option -S and -f. "
"If the process doesn't exist, simply remove file:\n%sR\n\n",
f_stem);
exit(1);
}
else
{
err_quit ("writing lock file");
}
}
Fr_name = s;
if( Opt_Serv )
{
int n;
sprintf (cmd,"%s '%sS %s'", argv[0], MYNAME, sf_stem);
n = system (cmd);
(void)n;
}
{
char buf[64];
int n;
sprintf(buf, "%d\n", (int)getpid());
n = write(Fdrun, buf, strlen(buf));
(void)n;
close(Fdrun);
}
Fdr = Fdw = -1;
count = 0;
while ((Fdr=open (fm_name, O_RDONLY | O_NOFOLLOW)) < 0)
{
if (count++>5)
{
err_quit ("opening message fifo");
}
sleep(1);
}
count = 0;
while ((Fdw=open (fc_name, O_WRONLY | O_NOFOLLOW)) < 0)
{
if (count++>2)
{
err_quit ("opening command fifo");
}
sleep(1);
}
i = optind;
if (Opt_stdin)
{
while (fgets(cmd, MAX_MODULE_INPUT_TEXT_LEN - 1, stdin))
{
sendit(cmd);
}
}
else if( Opt_monitor )
{
/* test if its stdin is closed for coprocess */
tv2.tv_sec = 0;
tv2.tv_usec = 5;
FD_ZERO(&fdset);
FD_SET(STDIN_FILENO, &fdset);
ncnt = fvwmSelect(FD_SETSIZE, &fdset, 0, 0, &tv2);
if( ncnt && (fgets( cmd, 1, stdin )==0 || cmd[0] == 0))
{
Bg = 1;
}
/* line buffer stdout for coprocess */
setvbuf( stdout, NULL, _IOLBF, 0);
/* send arguments first */
for( ;i < argc; i++ )
{
strncpy( cmd, argv[i], MAX_MODULE_INPUT_TEXT_LEN - 1 );
sendit( cmd );
}
while( !isTerminated )
{
FD_ZERO(&fdset);
FD_SET(Fdr, &fdset);
if( Bg == 0 )
{
FD_SET(STDIN_FILENO, &fdset);
}
ncnt = fvwmSelect(FD_SETSIZE, &fdset, 0, 0, NULL);
/* message from fvwm */
if (FD_ISSET(Fdr, &fdset))
{
process_message();
}
if( Bg == 0 )
{
/* command input */
if( FD_ISSET(STDIN_FILENO, &fdset) )
{
if( fgets( cmd, MAX_MODULE_INPUT_TEXT_LEN - 1, stdin ) == 0 )
{
if( Bg == 0 )
{
/* other than SIGTTIN */
break;
}
continue;
}
sendit( cmd );
}
}
}
}
else
{
for( ;i < argc; i++ )
{
strncpy( cmd, argv[i], MAX_MODULE_INPUT_TEXT_LEN - 1 );
sendit( cmd );
if (Opt_info >= 0)
receive();
}
}
close_fifos();
return Rc;
}
/*
* Authenticate Director
*/
int authenticate_director(JCR *jcr, DIRRES *director, CONRES *cons)
{
BSOCK *dir = jcr->dir_bsock;
int tls_local_need = BNET_TLS_NONE;
int tls_remote_need = BNET_TLS_NONE;
bool tls_authenticate;
int compatible = true;
char bashed_name[MAX_NAME_LENGTH];
char *password;
TLS_CONTEXT *tls_ctx = NULL;
/*
* Send my name to the Director then do authentication
*/
if (cons) {
bstrncpy(bashed_name, cons->hdr.name, sizeof(bashed_name));
bash_spaces(bashed_name);
password = cons->password;
/* TLS Requirement */
if (cons->tls_enable) {
if (cons->tls_require) {
tls_local_need = BNET_TLS_REQUIRED;
} else {
tls_local_need = BNET_TLS_OK;
}
}
if (cons->tls_authenticate) {
tls_local_need = BNET_TLS_REQUIRED;
}
tls_authenticate = cons->tls_authenticate;
tls_ctx = cons->tls_ctx;
} else {
bstrncpy(bashed_name, "*UserAgent*", sizeof(bashed_name));
password = director->password;
/* TLS Requirement */
if (director->tls_enable) {
if (director->tls_require) {
tls_local_need = BNET_TLS_REQUIRED;
} else {
tls_local_need = BNET_TLS_OK;
}
}
if (director->tls_authenticate) {
tls_local_need = BNET_TLS_REQUIRED;
}
tls_authenticate = director->tls_authenticate;
tls_ctx = director->tls_ctx;
}
/* Timeout Hello after 5 mins */
btimer_t *tid = start_bsock_timer(dir, 60 * 5);
dir->fsend(hello, bashed_name);
if (!cram_md5_respond(dir, password, &tls_remote_need, &compatible) ||
!cram_md5_challenge(dir, password, tls_local_need, compatible)) {
goto bail_out;
}
/* Verify that the remote host is willing to meet our TLS requirements */
if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
sendit(_("Authorization problem:"
" Remote server did not advertise required TLS support.\n"));
goto bail_out;
}
/* Verify that we are willing to meet the remote host's requirements */
if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
sendit(_("Authorization problem:"
" Remote server requires TLS.\n"));
goto bail_out;
}
/* Is TLS Enabled? */
if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
/* Engage TLS! Full Speed Ahead! */
if (!bnet_tls_client(tls_ctx, dir, NULL)) {
sendit(_("TLS negotiation failed\n"));
goto bail_out;
}
if (tls_authenticate) { /* Authenticate only? */
dir->free_tls(); /* yes, shutdown tls */
}
}
/*
* It's possible that the TLS connection will
* be dropped here if an invalid client certificate was presented
*/
Dmsg1(6, ">dird: %s", dir->msg);
if (dir->recv() <= 0) {
senditf(_("Bad response to Hello command: ERR=%s\n"),
dir->bstrerror());
goto bail_out;
}
Dmsg1(10, "<dird: %s", dir->msg);
if (strncmp(dir->msg, OKhello, sizeof(OKhello)-1) != 0) {
sendit(_("Director rejected Hello command\n"));
goto bail_out;
} else {
sendit(dir->msg);
}
stop_bsock_timer(tid);
return 1;
bail_out:
stop_bsock_timer(tid);
sendit( _("Director authorization problem.\n"
"Most likely the passwords do not agree.\n"
"If you are using TLS, there may have been a certificate validation error during the TLS handshake.\n"
"Please see " MANUAL_AUTH_URL " for help.\n"));
return 0;
}
void
execevent(Window *w, Event *e, int (*command)(Window*, char*))
{
Event *ea, *e2;
int n, na, len, needfree;
char *s, *t;
ea = nil;
e2 = nil;
if(e->flag & 2)
e2 = recvp(w->cevent);
if(e->flag & 8){
ea = recvp(w->cevent);
na = ea->nb;
recvp(w->cevent);
}else
na = 0;
needfree = 0;
s = e->b;
if(e->nb==0 && (e->flag&2)){
s = e2->b;
e->q0 = e2->q0;
e->q1 = e2->q1;
e->nb = e2->nb;
}
if(e->nb==0 && e->q0<e->q1){
/* fetch data from window */
s = emalloc((e->q1-e->q0)*UTFmax+2);
n = winread(w, e->q0, e->q1, s);
s[n] = '\0';
needfree = 1;
}else
if(na){
t = emalloc(strlen(s)+1+na+2);
sprint(t, "%s %s", s, ea->b);
if(needfree)
free(s);
s = t;
needfree = 1;
}
/* if it's a known command, do it */
/* if it's a long message, it can't be for us anyway */
if(!command(w, s) && s[0]!='\0'){ /* send it as typed text */
/* if it's a built-in from the tag, send it back */
if(e->flag & 1)
fprint(w->event, "%c%c%d %d\n", e->c1, e->c2, e->q0, e->q1);
else{ /* send text to main window */
len = strlen(s);
if(len>0 && s[len-1]!='\n' && s[len-1]!='\004'){
if(!needfree){
/* if(needfree), we left room for a newline before */
t = emalloc(len+2);
strcpy(t, s);
s = t;
needfree = 1;
}
s[len++] = '\n';
s[len] = '\0';
}
sendit(s);
}
}
if(needfree)
free(s);
}
int vibrator_off()
{
return sendit(0);
}
static void list_status_header(STATUS_PKT *sp)
{
int len;
char dt[MAX_TIME_LENGTH];
POOL_MEM msg(PM_MESSAGE);
char b1[32], b2[32], b3[32], b4[32], b5[35];
#if defined(HAVE_WIN32)
char buf[300];
#endif
len = Mmsg(msg, _("%s Version: %s (%s) %s %s %s %s\n"),
my_name, VERSION, BDATE, VSS, HOST_OS, DISTNAME, DISTVER);
sendit(msg, len, sp);
bstrftime_nc(dt, sizeof(dt), daemon_start_time);
len = Mmsg(msg, _("Daemon started %s. Jobs: run=%d running=%d.\n"),
dt, num_jobs_run, job_count());
sendit(msg, len, sp);
#if defined(HAVE_WIN32)
if (GetWindowsVersionString(buf, sizeof(buf))) {
len = Mmsg(msg, "%s\n", buf);
sendit(msg, len, sp);
}
if (debug_level > 0) {
if (!privs) {
privs = enable_backup_privileges(NULL, 1);
}
len = Mmsg(msg, "Priv 0x%x\n", privs);
sendit(msg, len, sp);
len = Mmsg(msg, "APIs=%sOPT,%sATP,%sLPV,%sCFA,%sCFW,\n",
p_OpenProcessToken ? "" : "!",
p_AdjustTokenPrivileges ? "" : "!",
p_LookupPrivilegeValue ? "" : "!",
p_CreateFileA ? "" : "!",
p_CreateFileW ? "" : "!");
sendit(msg, len, sp);
len = Mmsg(msg, " %sWUL,%sWMKD,%sGFAA,%sGFAW,%sGFAEA,%sGFAEW,%sSFAA,%sSFAW,%sBR,%sBW,%sSPSP,\n",
p_wunlink ? "" : "!",
p_wmkdir ? "" : "!",
p_GetFileAttributesA ? "" : "!",
p_GetFileAttributesW ? "" : "!",
p_GetFileAttributesExA ? "" : "!",
p_GetFileAttributesExW ? "" : "!",
p_SetFileAttributesA ? "" : "!",
p_SetFileAttributesW ? "" : "!",
p_BackupRead ? "" : "!",
p_BackupWrite ? "" : "!",
p_SetProcessShutdownParameters ? "" : "!");
sendit(msg, len, sp);
len = Mmsg(msg, " %sWC2MB,%sMB2WC,%sFFFA,%sFFFW,%sFNFA,%sFNFW,%sSCDA,%sSCDW,\n",
p_WideCharToMultiByte ? "" : "!",
p_MultiByteToWideChar ? "" : "!",
p_FindFirstFileA ? "" : "!",
p_FindFirstFileW ? "" : "!",
p_FindNextFileA ? "" : "!",
p_FindNextFileW ? "" : "!",
p_SetCurrentDirectoryA ? "" : "!",
p_SetCurrentDirectoryW ? "" : "!");
sendit(msg, len, sp);
len = Mmsg(msg, " %sGCDA,%sGCDW,%sGVPNW,%sGVNFVMPW\n",
p_GetCurrentDirectoryA ? "" : "!",
p_GetCurrentDirectoryW ? "" : "!",
p_GetVolumePathNameW ? "" : "!",
p_GetVolumeNameForVolumeMountPointW ? "" : "!");
sendit(msg, len, sp);
}
#endif
len = Mmsg(msg, _(" Heap: heap=%s smbytes=%s max_bytes=%s bufs=%s max_bufs=%s\n"),
edit_uint64_with_commas((char *)sbrk(0)-(char *)start_heap, b1),
edit_uint64_with_commas(sm_bytes, b2),
edit_uint64_with_commas(sm_max_bytes, b3),
edit_uint64_with_commas(sm_buffers, b4),
edit_uint64_with_commas(sm_max_buffers, b5));
sendit(msg, len, sp);
len = Mmsg(msg, _(" Sizeof: boffset_t=%d size_t=%d debug=%d trace=%d "
"bwlimit=%skB/s\n"), sizeof(boffset_t), sizeof(size_t),
debug_level, get_trace(), edit_uint64_with_commas(me->max_bandwidth_per_job / 1024, b1));
sendit(msg, len, sp);
if (me->secure_erase_cmdline) {
len = Mmsg(msg, _(" secure erase command='%s'\n"), me->secure_erase_cmdline);
sendit(msg, len, sp);
}
len = list_fd_plugins(msg);
if (len > 0) {
sendit(msg, len, sp);
}
}