/*
 * 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   */

#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <termio.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stropts.h>

#include "tmextern.h"

#define NTRY    5

/*
 * At this time, we only recognize certain speeds.
 * This table can be expanded if new patterns are found
 */
static struct   autobaud {
        char    *a_speed;
        char    *a_pattern;     /* first byte is length */
} autob2400[] = {
#ifdef i386
        /*
         * These are the bit patterns returned on x86 boxes
         */
        "110",          "\1\000",
#else
        "110",          "\3\000\000\000",
#endif
        "1200",         "\2\346\200",
        "2400",         "\1\15",
        "4800",         "\1\371",
        "4800",         "\1\362",
        "9600",         "\1\377",
        0,              0
};

/*
 *      auto_termio - set termio to allow autobaud
 *                  - the line is set to raw mode, with VMIN = 5, VTIME = 1
 *                  - baud rate is set to 2400
 */
int
auto_termio(int fd)
{
        struct termio termio;
        struct termios termios;

        if (ioctl(fd, TCGETS, &termios) == -1) {
                if (ioctl(fd, TCGETA, &termio) == -1) {
                        log("auto_termio: ioctl TCGETA failed, fd = %d: %s", fd,
                            strerror(errno));
                        return (-1);
                }
                termio.c_iflag = 0;
                termio.c_cflag &= ~(CBAUD|CSIZE|PARENB);
                termio.c_cflag |= CREAD|HUPCL|(CS8&CSIZE)|(B2400&CBAUD);
                termio.c_lflag &= ~(ISIG|ICANON|ECHO|ECHOE|ECHOK);
                termio.c_oflag = 0;

                termio.c_cc[VMIN] = 5;
                termio.c_cc[VTIME] = 1;

                if (ioctl(fd, TCSETAF, &termio) == -1) {
                        log("auto_termio: ioctl TCSETAF failed, fd = %d: %s",
                            fd, strerror(errno));
                        return (-1);
                }
        } else {
                termios.c_iflag &= 0xffff0000;
                termios.c_cflag &= ~(CSIZE|PARENB);
                termios.c_cflag |= CREAD|HUPCL|(CS8&CSIZE);
                termios.c_lflag &= ~(ISIG|ICANON|ECHO|ECHOE|ECHOK);
                termios.c_oflag &= 0xffff0000;

                termios.c_cc[VMIN] = 5;
                termios.c_cc[VTIME] = 1;
                (void) cfsetospeed(&termios, B2400);

                if (ioctl(fd, TCSETSF, &termios) == -1) {
                        log("auto_termio: ioctl TCSETSF failed, fd = %d: %s",
                            fd, strerror(errno));
                        return (-1);
                }
        }
        return (0);
}

/*
 *      autobaud - determine the baudrate by reading data at 2400 baud rate
 *               - the program is anticipating <CR>
 *               - the bit pattern is matched again an autobaud table
 *               - if a match is found, the matched speed is returned
 *               - otherwise, NULL is returned
 */

char *
autobaud(int fd, int timeout)
{
        int i, k, count;
        static char     buf[5];
        char *cp = buf;
        struct  autobaud *tp;
        struct  sigaction sigact;

#ifdef  DEBUG
        debug("in autobaud");
#endif
        (void) auto_termio(fd);
        sigact.sa_flags = 0;
        sigact.sa_handler = SIG_IGN;
        (void) sigemptyset(&sigact.sa_mask);
        (void) sigaction(SIGINT, &sigact, NULL);
        count = NTRY;
        while (count--) {
                if (timeout) {
                        sigact.sa_flags = 0;
                        sigact.sa_handler = timedout;
                        (void) sigemptyset(&sigact.sa_mask);
                        (void) sigaction(SIGALRM, &sigact, NULL);
                        (void) alarm((unsigned)timeout);
                }
                cp = &buf[1];
                if (peek_ptr != NULL) {
                        k = peek_ptr->len;
                        (void) strncpy(cp, peek_ptr->buf, k);
                        peek_ptr = NULL;
                } else if ((k = read(fd, cp, 5)) < 0) {
                        fatal("autobaud: read failed: %s", strerror(errno));
                }
                if (timeout)
                        (void) alarm((unsigned)0);
                buf[0] = (char)k;
                for (tp = autob2400; tp->a_speed; tp++) {
                        for (i = 0; ; i++) {
                                if (buf[i] != tp->a_pattern[i])
                                        break;
                                if (i == buf[0]) {
                                        return (tp->a_speed);
                                }
                        }
                }
                flush_input(fd);
        } /* end while */
        return (NULL);          /* autobaud failed */
}