cmd/ttymon/tmpeek.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*  Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */


#pragma ident   "%Z%%M% %I% %E% SMI"

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stropts.h>
#include <poll.h>
#include <signal.h>
#include <errno.h>
#include "ttymon.h"
#include "tmstruct.h"
#include "tmextern.h"

#define BRK 1
#define DEL 2

struct  strbuf *do_peek();
static  int process();
extern  void    sigint();

static  int interrupt;

/*
 *  poll_data   - it polls the device, waiting for data
 *          - return BADSPEED it <brk> is received
 *          - return the result of process if data is received
 *          - write a newline if <del> is received
 *          - exit if hangup is received
 */
int
poll_data()
{
    int j;
    struct strbuf *ptr;
    struct pollfd fds[1];
    struct sigaction sigact;

#ifdef  DEBUG
    debug("in poll_data");
#endif
    if (peek_ptr != NULL) {
        for(j=0; j<peek_ptr->len; j++) peek_ptr->buf[j] &= 0x7F;
        return(process(0,peek_ptr));
    }
    fds[0].fd = 0;
    fds[0].events = POLLIN;
    sigact.sa_flags = 0;
    sigact.sa_handler = sigint;
    (void)sigemptyset(&sigact.sa_mask);
    (void)sigaddset(&sigact.sa_mask, SIGINT);
    (void)sigaction(SIGINT, &sigact, NULL);
    for (;;) {
        interrupt = 0;
        if ((j = poll(fds,1,-1)) == -1) {
            if (interrupt == BRK) {
                return(BADSPEED);
            }
            if (interrupt == DEL) { /* XXX revisit kmd */
                return(BADSPEED);
            }
        }
        else if (j > 0) {
            if (fds[0].revents & POLLHUP) {
                log( "POLLHUP received, about to exit");
                exit(1);
            }
            if (fds[0].revents & POLLIN) {
                ptr = do_peek(fds[0].fd, 255);
                if (ptr != NULL) {
                    return(process(fds[0].fd,ptr));
                }
            }
        }
    }
}

/*
 *  process - process the data
 *      - return GOODNAME if it is a non-empty line
 *      - return NONAME if a <CR> is received
 *      - return BADNAME if zero byte is detected
 *      - except the case of GOODNAME, data will be pulled out
 *        of the stream
 */
static int
process(
    int fd,     /* fd to read data from if necessary    */
    struct strbuf *ptr) /* ptr that holds data in ptr->buf  */
{
    unsigned i;
    char    junk[BUFSIZ];

    for (i = 0; i < ptr->len; i++) {
        if (ptr->buf[i] == '\0') {
            (void) read(fd, junk, i+1);
            return (BADSPEED);
        } else if ((ptr->buf[i] == '\n') || (ptr->buf[i] == '\r')) {
            if (i == 0) {
                (void) read(fd, junk, ptr->len);
                return (NONAME);
            } else
                return (GOODNAME);
        }
    }   /* end for loop */
    /* end of input is encountered */
#ifdef  DEBUG
    debug("in process: EOF encountered");
#endif
    exit(1);
    /*NOTREACHED*/
}

/*
 *  do_peek - peek at the stream to get the data
 *      - this only called when POLLIN is detected,
 *      - so there should always be something there
 *      - return a ptr to the buf that contains the data
 *      - return NULL if nothing to peek at
 */
struct  strbuf  *
do_peek(fd,n)
int fd; /* fd to do the ioctl on */
int n;  /* maxlen of data to peek at */
{
    int  ret;
    static   struct strpeek peek;
    register struct strpeek *peekp;
    static   char   buf[BUFSIZ];

#ifdef  DEBUG
    debug("in do_peek");
#endif

    peekp = &peek;
    peekp->flags = 0;
    /* need to ask for ctl info to avoid bug in I_PEEK code */
    peekp->ctlbuf.maxlen = 1;
    peekp->ctlbuf.buf = buf;
    peekp->databuf.maxlen = n;
    peekp->databuf.buf = buf;
    ret = ioctl(fd, I_PEEK, &peek);
    if (ret == -1) {
        log("do_peek: I_PEEK failed: %s", errno);
        exit(1);
    }
    if (ret == 0) {
        return( (struct strbuf *)NULL );
    }
    return(&(peekp->databuf));
}

/*
 *  sigint  - this is called when SIGINT is caught
 */
void
sigint()
{
    struct strbuf *ptr;
    char   junk[2];

#ifdef  DEBUG
    debug("in sigint");
#endif
    ptr = do_peek(0, 1);
    if (ptr == NULL) {  /* somebody type <del> */
        interrupt = DEL;
    }
    else {
        if (ptr->buf[0] == '\0') {
            /* somebody type <brk> or frame error */
            (void)read(0,junk,1);
            interrupt = BRK;
        }
    }
}