/*
 * 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 2002 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * modem_setup.c: support for the scadm modem_setup option (access to the
 * service processor modem - if present)
 */

#include <curses.h>
#include <libintl.h>
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <time.h>  /* required by librsc.h */
#include <unistd.h>

#include "librsc.h"
#include "adm.h"


extern char *ADM_Get_Var(char *Variable);

static void ADM_Send_Char(char  C);
static void *ADM_Modem_Listen(void *);
static void cleanup();


typedef enum {ST_RESET, ST_IDLE, ST_TILDA} ADM_state_t;

static int ADM_Continue;
static int winOn = 0;
static pthread_t modemListen;


void
ADM_Process_modem_setup(void)
{
	rscp_msg_t	msg;
	struct timespec	timeout;

	int		Input;
	ADM_state_t	State;
	int		exitLoop = 1;
	char		rsc_escape[2];
	char		string[40];


	ADM_Start();

	msg.type = DP_MODEM_CONNECT;
	msg.len  = 0;
	msg.data = NULL;
	ADM_Send(&msg);

	timeout.tv_nsec = 0;
	timeout.tv_sec  = ADM_TIMEOUT;
	ADM_Recv(&msg, &timeout, DP_MODEM_CONNECT_R,
	    sizeof (dp_modem_connect_r_t));
	if (*(int *)msg.data != DP_MODEM_PASS) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("scadm: could not connect to modem"));
		exit(-1);
	}
	ADM_Free(&msg);

	/* Get the escape char BEFORE starting up the "listen" thread */
	(void) strcpy(rsc_escape, ADM_Get_Var("escape_char"));


	/* Create Listening Thread */
	ADM_Continue = 1;
	if (pthread_create(&modemListen, NULL, ADM_Modem_Listen, NULL) != 0) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("scadm: couldn't create thread"));
		exit(-1);
	}

	if (signal(SIGINT, cleanup) == SIG_ERR) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("scadm: cleanup() registration failed"));
		ADM_Continue = 0;
		exit(-1);
	}


	(void) sprintf(string, gettext("... Type %s. to return to prompt ..."),
	    rsc_escape);
	Input = 0;
	State = ST_RESET;
	winOn = 1;
	initscr();
	noecho();
	printw("\n%s\n\n", string);

	while (exitLoop) {
		while ((Input = getch()) == ERR)
			;

		if (Input == 10) {
			State = ST_RESET;
			ADM_Send_Char('\n');
			ADM_Send_Char('\r');
			continue;
		}

		switch (State) {
			case ST_RESET:
				if ((char)Input == rsc_escape[0]) {
					State = ST_TILDA;
				} else {
					State = ST_IDLE;
					ADM_Send_Char((char)Input);
				}
				break;

			case ST_IDLE:
				ADM_Send_Char((char)Input);
				break;

			case ST_TILDA:
				if ((char)Input == '.') {
					ADM_Send_Char('~');
					ADM_Send_Char('.');
					exitLoop = 0;
				} else {
					State = ST_IDLE;
					ADM_Send_Char((char)Input);
				}
				break;

			default:
				State = ST_IDLE;
				ADM_Send_Char((char)Input);
		}
	}
	endwin();
	winOn = 0;

	/* Terminate Thread */
	ADM_Continue = 0;
	(void) sleep(3);	/* Make sure thread has time to 'see' */
				/* termination */

	msg.type = DP_MODEM_DISCONNECT;
	msg.len  = 0;
	msg.data = NULL;
	ADM_Send(&msg);

	timeout.tv_nsec = 0;
	timeout.tv_sec  = ADM_TIMEOUT;
	ADM_Recv(&msg, &timeout, DP_MODEM_DISCONNECT_R,
	    sizeof (dp_modem_disconnect_r_t));
	if (*(int *)msg.data != DP_MODEM_PASS) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("scadm: could not disconnect from modem"));
		ADM_Continue = 0;
		exit(-1);
	}
	ADM_Free(&msg);

	pthread_join(modemListen, NULL);

}


static void
ADM_Send_Char(char C)
{
	rscp_msg_t	Message;
	char		Data[2];

	Data[0] = C;
	Data[1] = 0x0;
	Message.type = DP_MODEM_DATA;
	Message.len  = 2;
	Message.data = Data;

	if (rscp_send(&Message) != 0) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("scadm: Unable to send modem data to SC"));
		if (winOn)
			endwin();
		ADM_Continue = 0;
		exit(-1);
	}
}


static void *
ADM_Modem_Listen(void *arg __unused)
{
	rscp_msg_t	Message;
	struct timespec	Timeout;


	while (ADM_Continue) {
		Timeout.tv_nsec = 500000000;
		Timeout.tv_sec  = 0;
		if (rscp_recv(&Message, &Timeout) != 0) {
			continue;
		}

		if (Message.type != DP_MODEM_DATA) {
			(void) fprintf(stderr, "\n%s: 0x%08x:0x%08lx\n\n",
			    gettext("scadm: SC returned garbage"),
			    Message.type, Message.len);
			exit(-1);
		}

		(void) printf("%s", (char *)Message.data);
		(void) fflush(stdout);
		ADM_Free(&Message);
	}
	return (NULL);
}


static void
cleanup()
{
	rscp_msg_t	msg;
	struct timespec	timeout;


	if (winOn)
		endwin();

	/* Terminate Thread */
	ADM_Continue = 0;

	msg.type = DP_MODEM_DISCONNECT;
	msg.len  = 0;
	msg.data = NULL;
	ADM_Send(&msg);

	timeout.tv_nsec = 0;
	timeout.tv_sec  = ADM_TIMEOUT;
	ADM_Recv(&msg, &timeout, DP_MODEM_DISCONNECT_R,
	    sizeof (dp_modem_disconnect_r_t));
	if (*(int *)msg.data != DP_MODEM_PASS) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("scadm: could not disconnect from modem"));
		exit(-1);
	}
	ADM_Free(&msg);

	pthread_join(modemListen, NULL);

	exit(-1);
}