/* Copyright 1998 by the Massachusetts Institute of Technology.

*

* Permission to use, copy, modify, and distribute this

* software and its documentation for any purpose and without

* fee is hereby granted, provided that the above copyright

* notice appear in all copies and that both that copyright

* notice and this permission notice appear in supporting

* documentation, and that the name of M.I.T. not be used in

* advertising or publicity pertaining to distribution of the

* software without specific, written prior permission.

* M.I.T. makes no representations about the suitability of

* this software for any purpose. It is provided "as is"

* without express or implied warranty.

*/

/* This file is part of larvnetd, a monitoring server. It implements

* functions for querying the printers for queue status information.

*/

static const char rcsid[] = "$Id: printer.c,v 1.7 2000-01-05 22:01:35 ghudson Exp $";

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <arpa/nameser.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <unistd.h>

#include <fcntl.h>

#include <errno.h>

#include <netdb.h>

#include <syslog.h>

#include <hesiod.h>

#include "larvnetd.h"

#include "timer.h"

#define PRINTER_FALLBACK_PORT 515

struct printer_poll_args {

struct serverstate *state;

struct printer *printer;

};

static void printer_poll(void *arg);

static void printer_hes_callback(void *arg, int status, int timeouts,

unsigned char *abuf, int alen);

static void printer_host_callback(void *arg, int status, int timeouts,

struct hostent *host);

static void *make_pargs(struct serverstate *state, struct printer *printer);

void printer_start_polls(struct serverstate *state)

{

int i;

syslog(LOG_DEBUG, "printer_start_polls");

for (i = 0; i < state->config.nprinters; i++)

printer_poll(make_pargs(state, &state->config.printers[i]));

}

static void printer_poll(void *arg)

{

struct printer_poll_args *pargs = (struct printer_poll_args *) arg;

struct serverstate *state = pargs->state;

struct printer *printer = pargs->printer;

char *hesname;

/* Null out the timer, since it may have just gone off. */

printer->timer = NULL;

hesname = hesiod_to_bind(state->hescontext, printer->name, "pcap");

if (hesname == NULL)

{

syslog(LOG_ERR, "printer_poll: can't convert printer name %s to "

"hesiod name: %m", printer->name);

printer->timer = timer_set_rel(60, printer_poll, pargs);

return;

}

syslog(LOG_DEBUG, "printer_poll: printer %s starting query for %s",

printer->name, hesname);

ares_query(state->channel, hesname, C_IN, T_TXT, printer_hes_callback,

pargs);

hesiod_free_string(state->hescontext, hesname);

}

static void printer_hes_callback(void *arg, int status, int timeouts,

unsigned char *abuf, int alen)

{

struct printer_poll_args *pargs = (struct printer_poll_args *) arg;

struct serverstate *state = pargs->state;

struct printer *printer = pargs->printer;

char **vec = NULL, *p, *q;

if (status == ARES_EDESTRUCTION)

{

syslog(LOG_DEBUG, "printer_hes_callback: printer %s hesiod query "

"halted for channel destruction", printer->name);

free(pargs);

return;

}

if (status != ARES_SUCCESS)

{

syslog(LOG_ERR, "printer_hes_callback: could not resolve Hesiod pcap "

"for printer %s: %s", printer->name,

ares_strerror(status));

goto failure;

}

/* Parse the result buffer into text records. */

vec = hesiod_parse_result(state->hescontext, abuf, alen);

if (!vec || !*vec)

{

syslog(LOG_ERR, "printer_hes_callback: could not parse Hesiod pcap "

"result for printer %s: %m", printer->name);

goto failure;

}

/* Look for the print server name. */

p = strchr(*vec, ':');

while (p)

{

if (strncmp(p + 1, "rm=", 3) == 0)

break;

p = strchr(p + 1, ':');

}

if (!p)

{

syslog(LOG_ERR, "printer_hes_callback: can't find print server name in "

"Hesiod pcap result for printer %s", printer->name);

goto failure;

}

p += 4;

q = p;

while (*q && *q != ':')

q++;

*q = 0;

syslog(LOG_DEBUG, "printer_hes_callback: printer %s starting query for %s",

printer->name, p);

ares_gethostbyname(state->channel, p, AF_INET, printer_host_callback, pargs);

hesiod_free_list(state->hescontext, vec);

return;

failure:

if (vec)

hesiod_free_list(state->hescontext, vec);

printer->timer = timer_set_rel(60, printer_poll, pargs);

}

static void printer_host_callback(void *arg, int status, int timeouts,

struct hostent *host)

{

struct printer_poll_args *pargs = (struct printer_poll_args *) arg;

struct printer *printer = pargs->printer;

int s = -1, lport = IPPORT_RESERVED - 1, flags;

unsigned short port;

struct servent *servent;

struct sockaddr_in sin;

if (status == ARES_EDESTRUCTION)

{

syslog(LOG_DEBUG, "printer_host_callback: printer %s hostname query "

"halted for channel destruction", printer->name);

free(pargs);

return;

}

if (status != ARES_SUCCESS)

{

syslog(LOG_ERR, "printer_host_callback: printer %s can't resolve print "

"server name: %s", printer->name, ares_strerror(status));

goto failure;

}

s = rresvport(&lport);

if (s < 0)

{

syslog(LOG_ERR, "printer_host_callback: printer %s can't get reserved "

"port", printer->name);

goto failure;

}

/* Set s non-blocking so we can do a non-blocking connect. */

flags = fcntl(s, F_GETFL);

fcntl(s, F_SETFL, flags | O_NONBLOCK);

servent = getservbyname("printer", "tcp");

port = (servent) ? servent->s_port : htons(PRINTER_FALLBACK_PORT);

memset(&sin, 0, sizeof(sin));

sin.sin_family = AF_INET;

memcpy(&sin.sin_addr, host->h_addr, sizeof(sin.sin_addr));

sin.sin_port = port;

if (connect(s, (struct sockaddr *) &sin, sizeof(sin)) == -1

&& errno != EINPROGRESS)

{

syslog(LOG_ERR, "printer_host_callback: printer %s can't connect to "

"print server %s: %m", printer->name, host->h_name);

goto failure;

}

/* Set up the request we want to send; the main loop will call

* printer_handle_output() when the socket selects true for

* writing.

*/

printer->s = s;

printer->to_send = 1;

sprintf(printer->buf, "\3%.*s\n", (int)(sizeof(printer->buf) - 3),

printer->name);

printer->buflen = strlen(printer->buf);

printer->jobs_counted = 0;

printer->up_so_far = 1;

syslog(LOG_DEBUG, "printer_host_callback: printer %s queued %d-byte query",

printer->name, printer->buflen);

free(pargs);

return;

failure:

if (s >= 0)

close(s);

printer->timer = timer_set_rel(60, printer_poll, pargs);

return;

}

void printer_handle_output(struct serverstate *state, struct printer *printer)

{

int count;

count = write(printer->s, printer->buf, printer->buflen);

if (count < 0)

{

syslog(LOG_ERR, "printer_handle_output: printer %s error writing to "

"print server: %m", printer->name);

close(printer->s);

printer->s = -1;

printer->timer = timer_set_rel(60, printer_poll,

make_pargs(state, printer));

return;

}

syslog(LOG_DEBUG, "printer_handle_output: printer %s wrote %d bytes",

printer->name, count);

/* Slide the data to send back in the buffer. */

printer->buflen -= count;

memmove(printer->buf, printer->buf + count, printer->buflen);

/* If we emptied the buffer, we're ready to receive. */

if (printer->buflen == 0)

{

syslog(LOG_DEBUG, "printer_handle_output: printer %s receiving",

printer->name);

printer->to_send = 0;

}

}

void printer_handle_input(struct serverstate *state, struct printer *printer)

{

int count;

char *q;

const char *p;

/* Read in a chunk of data from the printer server. */

count = read(printer->s, printer->buf + printer->buflen,

sizeof(printer->buf) - printer->buflen);

if (count < 0)

{

syslog(LOG_ERR, "printer_handle_input: printer %s error reading from "

"print server: %m", printer->name);

}

if (count <= 0)

{

printer->jobs = printer->jobs_counted;

printer->up = printer->up_so_far;

close(printer->s);

printer->s = -1;

printer->timer = timer_set_rel(60, printer_poll,

make_pargs(state, printer));

syslog(LOG_DEBUG, "printer_handle_input: printer %s ending query, "

"jobs %d up %d", printer->name, printer->jobs, printer->up);

return;

}

printer->buflen += count;

syslog(LOG_DEBUG, "printer_handle_input: printer %s read %d bytes",

printer->name, count);

/* Now look over any complete lines we have. */

p = printer->buf;

q = memchr(p, '\n', printer->buflen);

while (q)

{

*q = 0;

syslog(LOG_DEBUG, "printer_handle_input: printer %s line: %s",

printer->name, p);

if (strncmp(p, "active ", 7) == 0 || isdigit((unsigned char)*p))

printer->jobs_counted++;

else if (strstr(p, "is down") || strstr(p, "Printer Error") ||

strstr(p, "ing disabled"))

printer->up_so_far = 0;

p = q + 1;

q = memchr(p, '\n', printer->buf + printer->buflen - p);

}

/* Copy any leftover partial line back into printer->buf. */

printer->buflen -= (p - printer->buf);

memmove(printer->buf, p, printer->buflen);

/* If the buffer is full and we don't have a complete line, toss the

* buffer so we can make some forward progress. We don't expect

* this to happen when the print server is functioning correctly.

*/

if (printer->buflen == sizeof(printer->buf))

{

syslog(LOG_NOTICE, "printer_handle_input: printer %s input buffer "

"full, flushing", printer->name);

printer->buflen = 0;

}

}

static void *make_pargs(struct serverstate *state, struct printer *printer)

{

struct printer_poll_args *pargs;

pargs = emalloc(sizeof(struct printer_poll_args));

pargs->state = state;

pargs->printer = printer;

return pargs;

}