void
Cbuf_write_from_fd(cbuf_t buf, int fd)
{
int n, dropped = 0;
assert(buf);
if ((n = cbuf_write_from_fd(buf, fd, -1, &dropped)) < 0)
ierr_exit("Cbuf_write_from_fd(%d): %s", fd, strerror(errno));
/* achu: If you are running ipmipower in co-process mode with
* powerman, this error condition will probably be hit with the file
* descriptor STDIN_FILENO. The powerman daemon is usually closed
* by /etc/init.d/powerman stop, which kills a process through a
* signal. Thus, powerman closes stdin and stdout pipes to
* ipmipower and the call to cbuf_write_from_fd will give us an EOF
* reading. We'll consider this EOF an "ok" error.
*/
if (!n)
{
if (fd == STDIN_FILENO)
exit(1);
else
ierr_exit("Cbuf_write_from_fd(%d): EOF", fd);
}
if (dropped)
ierr_dbg("Cbuf_write_from_fd: read dropped %d bytes", dropped);
}
int zio_read (zio_t *zio)
{
int n;
assert ((zio != NULL) && (zio->magic == ZIO_MAGIC));
if ((n = cbuf_write_from_fd (zio->buf, zio->srcfd, -1, NULL)) < 0)
return (-1);
zio_debug (zio, "zio_read: read = %d\n", n);
if (n == 0) {
zio_set_eof (zio);
zio_debug (zio, "zio_read_cb: Got eof\n");
}
zio_flush (zio);
return (n);
}
/* _poll_loop
* - poll on all descriptors
*/
static void
_poll_loop (int non_interactive)
{
int nfds = 0;
struct pollfd *pfds = NULL;
int extra_fds;
/* number of fds for stdin and stdout we'll need when polling
*
* Right now, always poll stdout. When non-interactive,
* don't need stdin
*/
extra_fds = 1 + (non_interactive ? 0 : 1);
while (non_interactive || ipmipower_prompt_process_cmdline ())
{
int i, num, timeout;
int powercmd_timeout = -1;
int ping_timeout = -1;
/* If there are no pending commands before this call,
* powercmd_timeout will not be set, leaving it at -1
*/
num = ipmipower_powercmd_process_pending (&powercmd_timeout);
if (non_interactive && !num)
break;
/* ping timeout is always set if cmd_args.ping_interval > 0 */
ipmipower_ping_process_pings (&ping_timeout);
if (cmd_args.ping_interval)
{
if (powercmd_timeout == -1)
timeout = ping_timeout;
else
timeout = (ping_timeout < powercmd_timeout) ?
ping_timeout : powercmd_timeout;
}
else
timeout = powercmd_timeout;
/* achu: I always wonder if this poll() loop could be done far
* more elegantly and efficiently without all this crazy
* indexing, perhaps through a callback/event mechanism. It'd
* probably be more efficient, since most callback/event based
* models have min-heap like structures inside for determining
* what things timed out. Overall though, I don't think the O(n)
* (n being hosts/fds) processing is really that inefficient for
* this particular application and is not worth going back and
* changing. By going to a callback/event mechanism, there will
* still be some O(n) activities within the code, so I am only
* going to create a more efficient O(n) poll loop.
*/
/* Has the number of hosts changed? */
if (nfds != (ics_len*2) + extra_fds)
{
/* The "*2" is for each host's two fds, one for ipmi
* (ipmi_fd) and one for rmcp (ping_fd).
*/
nfds = (ics_len*2) + extra_fds;
free (pfds);
if (!(pfds = (struct pollfd *)malloc (nfds * sizeof (struct pollfd))))
{
IPMIPOWER_ERROR (("malloc: %s", strerror (errno)));
exit (EXIT_FAILURE);
}
}
for (i = 0; i < ics_len; i++)
{
pfds[i*2].fd = ics[i].ipmi_fd;
pfds[i*2+1].fd = ics[i].ping_fd;
pfds[i*2].events = pfds[i*2+1].events = 0;
pfds[i*2].revents = pfds[i*2+1].revents = 0;
pfds[i*2].events |= POLLIN;
if (!cbuf_is_empty (ics[i].ipmi_out))
pfds[i*2].events |= POLLOUT;
if (!cmd_args.ping_interval)
continue;
pfds[i*2+1].events |= POLLIN;
if (!cbuf_is_empty (ics[i].ping_out))
pfds[i*2+1].events |= POLLOUT;
}
if (!non_interactive)
{
pfds[nfds-2].fd = STDIN_FILENO;
pfds[nfds-2].events = POLLIN;
pfds[nfds-2].revents = 0;
}
pfds[nfds-1].fd = STDOUT_FILENO;
if (!cbuf_is_empty (ttyout))
pfds[nfds-1].events = POLLOUT;
else
pfds[nfds-1].events = 0;
pfds[nfds-1].revents = 0;
ipmipower_poll (pfds, nfds, timeout);
for (i = 0; i < ics_len; i++)
{
if (pfds[i*2].revents & POLLERR)
{
IPMIPOWER_DEBUG (("host = %s; IPMI POLLERR", ics[i].hostname));
/* See comments in _ipmi_recvfrom() regarding ECONNRESET/ECONNREFUSED */
_recvfrom (ics[i].ipmi_in, ics[i].ipmi_fd, &(ics[i].destaddr));
}
else
{
if (pfds[i*2].revents & POLLIN)
_recvfrom (ics[i].ipmi_in, ics[i].ipmi_fd, &(ics[i].destaddr));
if (pfds[i*2].revents & POLLOUT)
_sendto (ics[i].ipmi_out, ics[i].ipmi_fd, &(ics[i].destaddr));
}
if (!cmd_args.ping_interval)
continue;
if (pfds[i*2+1].revents & POLLERR)
{
IPMIPOWER_DEBUG (("host = %s; PING_POLLERR", ics[i].hostname));
_recvfrom (ics[i].ping_in, ics[i].ping_fd, &(ics[i].destaddr));
}
else
{
if (pfds[i*2+1].revents & POLLIN)
_recvfrom (ics[i].ping_in, ics[i].ping_fd, &(ics[i].destaddr));
if (pfds[i*2+1].revents & POLLOUT)
_sendto (ics[i].ping_out, ics[i].ping_fd, &(ics[i].destaddr));
}
}
if (!non_interactive && (pfds[nfds-2].revents & POLLIN))
{
int n, dropped = 0;
if ((n = cbuf_write_from_fd (ttyin, STDIN_FILENO, -1, &dropped)) < 0)
{
IPMIPOWER_ERROR (("cbuf_write_from_fd: %s", strerror (errno)));
exit (EXIT_FAILURE);
}
/* achu: If you are running ipmipower in co-process mode
* with powerman, this error condition will probably be hit
* with the file descriptor STDIN_FILENO. The powerman
* daemon is usually closed by /etc/init.d/powerman stop,
* which kills a process through a signal. Thus, powerman
* closes stdin and stdout pipes to ipmipower and the call
* to cbuf_write_from_fd will give us an EOF reading. We'll
* consider this EOF an "ok" error. No need to output an
* error message.
*/
if (!n)
exit (EXIT_FAILURE);
if (dropped)
IPMIPOWER_DEBUG (("cbuf_write_from_fd: read dropped %d bytes", dropped));
}
if (!cbuf_is_empty (ttyout) && (pfds[nfds-1].revents & POLLOUT))
{
if (cbuf_read_to_fd (ttyout, STDOUT_FILENO, -1) < 0)
{
IPMIPOWER_ERROR (("cbuf_read_to_fd: %s", strerror (errno)));
exit (EXIT_FAILURE);
}
}
}
free (pfds);
}
