OpenGrok

/* $NetBSD: ldp_command.c,v 1.14 2013/08/02 07:29:56 kefren Exp $ */

/*-
 * Copyright (c) 2010 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Mihai Chelaru <kefren (at) NetBSD.org>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <arpa/inet.h>

#include <netinet/in.h>
#include <netinet/tcp.h>

#include <sys/socket.h>
#include <sys/queue.h>

#include <errno.h>
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "label.h"
#include "ldp.h"
#include "ldp_command.h"
#include "ldp_errors.h"
#include "ldp_peer.h"
#include "socketops.h"

struct com_sock csockets[MAX_COMMAND_SOCKETS];
extern int ldp_hello_time, ldp_keepalive_time, ldp_holddown_time,
	min_label, max_label, debug_f, warn_f;

#define	writestr(soc, str) write(soc, str, strlen(str))

#define	MAXSEND 1024
char sendspace[MAXSEND];

static void send_prompt(int);
static void send_pwd_prompt(int);
static int command_match(struct com_func*, int, char*, char*);

static int	verify_root_pwd(char *);
static void	echo_on(int s);
static void	echo_off(int s);

/* Main functions */
static int show_func(int, char *);
static int set_func(int, char *);
static int exit_func(int, char *);

/* Show functions */
static int show_debug(int, char *);
static int show_hellos(int, char *);
static int show_parameters(int, char *);
static int show_version(int, char *);
static int show_warning(int, char *);

/* Set functions */
static int set_hello_time(int, char *);
static int set_debug(int, char *);
static int set_warning(int, char *);

static struct com_func main_commands[] = {
	{ "show", show_func },
	{ "set", set_func },
	{ "quit", exit_func },
	{ "exit", exit_func },
	{ "", NULL }
};

static struct com_func show_commands[] = {
	{ "neighbours", show_neighbours },
	{ "bindings", show_bindings },
	{ "debug", show_debug },
	{ "hellos", show_hellos },
	{ "labels", show_labels },
	{ "parameters", show_parameters },
	{ "version", show_version },
	{ "warning", show_warning },
	{ "", NULL }
};

struct com_func set_commands[] = {
	{ "debug", set_debug },
	{ "hello-time", set_hello_time },
	{ "warning", set_warning },
	{ "", NULL }
};

static int
verify_root_pwd(char *pw)
{
	struct passwd *p;

	if ((p = getpwuid(0)) == NULL)
		return 0;

	if (strcmp(crypt(pw, p->pw_passwd), p->pw_passwd))
		return 0;

	return 1;
}


void
init_command_sockets()
{
	int i;

	for (i = 0; i<MAX_COMMAND_SOCKETS; i++) {
		csockets[i].socket = -1;
		csockets[i].auth = 0;
	}
}

int
create_command_socket(int port)
{
	struct sockaddr_in sin;
	int s;

	sin.sin_len = sizeof(sin);
	sin.sin_family = AF_INET;
	sin.sin_port = htons(port);
	sin.sin_addr.s_addr = ntohl(INADDR_LOOPBACK);

	s = socket(PF_INET, SOCK_STREAM, 6);
	if (s < 0)
		return s;

	if (bind(s, (struct sockaddr *) &sin, sizeof(sin))) {
		fatalp("bind: %s", strerror(errno));
		close(s);
		return -1;
	}

	if (listen(s, 5) == -1) {
		fatalp("listen: %s", strerror(errno));
		close(s);
		return -1;
	}
	debugp("Command socket created (%d)\n", s);
	return s;
}

void
command_accept(int s)
{
	int as = accept(s, NULL, 0);

	if (as < 0) {
		fatalp("Cannot accept new command socket %s",
		    strerror(errno));
		return;
	}

	if (add_command_socket(as) != 0) {
		fatalp("Cannot accept command. Too many connections\n");
		close(as);
		return;
	}

	/* auth */
	send_pwd_prompt(as);
}

struct com_sock *
is_command_socket(int s)
{
	int i;

	if (s == -1)
		return NULL;
	for (i=0; i<MAX_COMMAND_SOCKETS; i++)
		if (s == csockets[i].socket)
			return &csockets[i];
	return NULL;
}

int
add_command_socket(int s)
{
	int i;

	for (i=0; i<MAX_COMMAND_SOCKETS; i++)
		if (csockets[i].socket == -1) {
			csockets[i].socket = s;
			csockets[i].auth = 0;
			return 0;
		}
	return -1;
}

void
command_dispatch(struct com_sock *cs)
{
	char recvspace[MAX_COMMAND_SIZE + 1];
	char *nextc = recvspace;
	int r = recv(cs->socket, recvspace, MAX_COMMAND_SIZE, MSG_PEEK);

	if (r < 0) {
		command_close(cs->socket);
		return;
	}

	recv(cs->socket, recvspace, r, MSG_WAITALL);

	if (r < 3) { /*at least \r\n */
	    if (cs->auth) {
		/*writestr(cs->socket, "Unknown command. Use ? for help\n");*/
		send_prompt(cs->socket);
	    } else {
		writestr(cs->socket, "Bad password\n");
		command_close(cs->socket);
	    }
		return;
	}

	recvspace[r - 2] = '\0';

	if (!cs->auth) {
		if (verify_root_pwd(recvspace)) {
			echo_on(cs->socket);
			cs->auth = 1;
			writestr(cs->socket, "\n");
			send_prompt(cs->socket);
		} else {
			echo_on(cs->socket);
			writestr(cs->socket, "Bad password\n");
			command_close(cs->socket);
		}
		return;
	}

	strsep(&nextc, " ");

	command_match(main_commands, cs->socket, recvspace, nextc);

}

void
command_close(int s)
{
	int i;

	for (i=0; i<MAX_COMMAND_SOCKETS; i++)
		if (s == csockets[i].socket) {
			close(s);
			csockets[i].socket = -1;
			csockets[i].auth = 0;
			break;
		}
}

static void
send_prompt(int s) {
	writestr(s, "LDP> ");
}

static void
send_pwd_prompt(int s) {
	echo_off(s);
	writestr(s, "Password: ");
}

static void
echo_off(int s)
{
	char iac_will_echo[3] = { 0xff, 0xfb, 0x01 }, bf[32];
	write(s, iac_will_echo, sizeof(iac_will_echo));
	read(s, bf, sizeof(bf));
}

static void
echo_on(int s)
{
	char iac_wont_echo[3] = { 0xff, 0xfc, 0x01 }, bf[32];
	write(s, iac_wont_echo, sizeof(iac_wont_echo));
	read(s, bf, sizeof(bf));
}

/*
 * Matching function
 * Returns 1 if matched anything
 */
static int
command_match(struct com_func *cf, int s, char *orig, char *next)
{
	size_t i, len;
	int last_match = -1;
	const char *msg = NULL;

	if (orig == NULL || orig[0] == '\0')
		goto out;

	if (!strcmp(orig, "?")) {
		for (i = 0; cf[i].func != NULL; i++) {
			snprintf(sendspace, MAXSEND, "\t%s\n", cf[i].com);
			writestr(s, sendspace);
		}
		goto out;
	}

	len = strlen(orig);
	for (i = 0; cf[i].func != NULL; i++) {
		if (strncasecmp(orig, cf[i].com, len) == 0) {
			if (last_match != -1) {
				msg = "Ambiguous";
				goto out;
			} else
				last_match = i;
		}
	}

	if (last_match == -1) {
		msg = "Unknown";
		goto out;
	}

	if (cf[last_match].func(s, next) != 0)
		send_prompt(s);
	return 1;
out:
	if (msg) {
		writestr(s, msg);
		writestr(s, " command. Use ? for help\n");
	}
	send_prompt(s);
	return 0;
}

/*
 * Main CLI functions
 */
static int
set_func(int s, char *recvspace)
{
	char *nextc = recvspace;

	if (recvspace == NULL || recvspace[0] == '\0') {
		writestr(s, "Unknown set command. Use set ? for help\n");
		return 1;
	}

	strsep(&nextc, " ");

	command_match(set_commands, s, recvspace, nextc);
	return 0;
}

static int
show_func(int s, char *recvspace)
{
	char *nextc = recvspace;

	if (recvspace == NULL || recvspace[0] == '\0') {
		writestr(s, "Unknown show command. Use show ? for help\n");
		return 1;
	}

	strsep(&nextc, " ");

	command_match(show_commands, s, recvspace, nextc);
	return 0;
}

static int
exit_func(int s, char *recvspace)
{
	command_close(s);
	return 0;
}

/*
 * Show functions
 */
int
show_neighbours(int s, char *recvspace)
{
	struct ldp_peer *p;
	struct ldp_peer_address *wp;
	struct sockaddr_in ssin;
	socklen_t sin_len = sizeof(struct sockaddr_in);
	int enc;
	socklen_t enclen = sizeof(enc);

	SLIST_FOREACH(p, &ldp_peer_head, peers) {
		snprintf(sendspace, MAXSEND, "LDP peer: %s\n",
		    inet_ntoa(p->ldp_id));
		writestr(s, sendspace);
		snprintf(sendspace, MAXSEND, "Transport address: %s\n",
		    satos(p->transport_address));
		writestr(s, sendspace);
		snprintf(sendspace, MAXSEND, "Next-hop address: %s\n",
		    satos(p->address));
		writestr(s, sendspace);
		snprintf(sendspace, MAXSEND, "State: %s\n",
		    ldp_state_to_name(p->state));
		writestr(s, sendspace);
		if (p->state == LDP_PEER_ESTABLISHED) {
			snprintf(sendspace, MAXSEND, "Since: %s",
			    ctime(&p->established_t));
			writestr(s, sendspace);
		}
		snprintf(sendspace, MAXSEND, "Holdtime: %d\nTimeout: %d\n",
			p->holdtime, p->timeout);
		writestr(s, sendspace);

		switch(p->state) {
		    case LDP_PEER_CONNECTING:
		    case LDP_PEER_CONNECTED:
		    case LDP_PEER_ESTABLISHED:
			if (getsockname(p->socket,(struct sockaddr *) &ssin,
			    &sin_len))
				break;

			if (getsockopt(p->socket, IPPROTO_TCP, TCP_MD5SIG,
			    &enc, &enclen) == 0) {
				snprintf(sendspace, MAXSEND,
				    "Authenticated: %s\n",
				    enc != 0 ? "YES" : "NO");
				writestr(s, sendspace);
			}

			snprintf(sendspace, MAXSEND,"Socket: %d\nLocal %s:%d\n",
			    p->socket, inet_ntoa(ssin.sin_addr),
			    ntohs(ssin.sin_port));
			writestr(s, sendspace);

			if (getpeername(p->socket,(struct sockaddr *) &ssin,
			    &sin_len))
				break;
			snprintf(sendspace, MAXSEND, "Remote %s:%d\n",
				inet_ntoa(ssin.sin_addr), ntohs(ssin.sin_port));
			writestr(s, sendspace);
		}

		snprintf(sendspace, MAXSEND,"Addresses bounded to this peer: ");
		writestr(s, sendspace);
		SLIST_FOREACH(wp, &p->ldp_peer_address_head, addresses) {
			/* XXX: TODO */
			if (wp->address.sa.sa_family != AF_INET)
				continue;
			snprintf(sendspace, MAXSEND, "%s ",
			    inet_ntoa(wp->address.sin.sin_addr));
			writestr(s, sendspace);
		}
		sendspace[0] = sendspace[1] = '\n';
		write(s, sendspace, 2);
	}
	return 1;
}

/* Shows labels grabbed from unsolicited label maps */
int
show_labels(int s, char *recvspace)
{
	struct ldp_peer *p;
	struct label_mapping *lm = NULL;

	SLIST_FOREACH(p, &ldp_peer_head, peers) {
		if (p->state != LDP_PEER_ESTABLISHED)
			continue;
		while ((lm = ldp_peer_lm_right(p, lm)) != NULL) {
			char lma[256];
			/* XXX: TODO */
			if (lm->address.sa.sa_family != AF_INET)
				continue;
			strlcpy(lma, inet_ntoa(lm->address.sin.sin_addr),
			    sizeof(lma));
			snprintf(sendspace, MAXSEND, "%s:%d\t%s/%d\n",
			    inet_ntoa(p->ldp_id), lm->label, lma, lm->prefix);
			writestr(s, sendspace);
		}
	}
	return 1;
}

int
show_bindings(int s, char *recvspace)
{
	struct label *l = NULL;

	snprintf(sendspace, MAXSEND, "Local label\tNetwork\t\t\t\tNexthop\n");
	writestr(s, sendspace);
	while((l = label_get_right(l)) != NULL) {
		snprintf(sendspace, MAXSEND, "%d\t\t%s/", l->binding,
		    satos(&l->so_dest.sa));
		writestr(s, sendspace);
		snprintf(sendspace, MAXSEND, "%s", satos(&l->so_pref.sa));
		writestr(s, sendspace);
		if (l->p)
			snprintf(sendspace, MAXSEND, "\t%s:%d\n",
			    satos(l->p->address), l->label);
		else
			snprintf(sendspace, MAXSEND, "\n");
		writestr(s, sendspace);
	}
	return 1;
}

static int
show_debug(int s, char *recvspace)
{
	if (recvspace) {
		writestr(s, "Invalid command\n");
		return 1;
	}

	snprintf(sendspace, MAXSEND, "Debug: %s\n",
		debug_f ? "YES" : "NO");
	writestr(s, sendspace);
	return 1;
}

static int
show_hellos(int s, char *recvspace)
{
	struct hello_info *hi;

	SLIST_FOREACH(hi, &hello_info_head, infos) {
		snprintf(sendspace, MAXSEND,
		    "ID: %s\nKeepalive: %ds\nTransport address: %s\n\n",
		    inet_ntoa(hi->ldp_id),
		    hi->keepalive,
		    hi->transport_address.sa.sa_family != 0 ?
		    satos(&hi->transport_address.sa) : "None");
		writestr(s, sendspace);
	}
	return 1;
}

static int
show_parameters(int s, char *recvspace)
{
	snprintf(sendspace, MAXSEND, "LDP ID: %s\nProtocol version: %d\n"
		 "Hello time: %d\nKeepalive time: %d\nHoldtime: %d\n"
		 "Minimum label: %d\nMaximum label: %d\n",
		my_ldp_id,
		LDP_VERSION,
		ldp_hello_time,
		ldp_keepalive_time,
		ldp_holddown_time,
		min_label,
		max_label);
	writestr(s, sendspace);
	return 1;
}

static int
show_version(int s, char *recvspace)
{
	if (recvspace) {	/* Nothing more after this */
		writestr(s, "Invalid command\n");
		return 1;
	}

	snprintf(sendspace, MAXSEND, "NetBSD LDP daemon version: %s\n",
	    LDPD_VER);
	writestr(s, sendspace);
	return 1;
}

static int
show_warning(int s, char *recvspace)
{
	if (recvspace) {
		writestr(s, "Invalid command\n");
		return 1;
	}

	snprintf(sendspace, MAXSEND, "Warnings: %s\n",
		warn_f ? "YES" : "NO");
	writestr(s, sendspace);
	return 1;
}

/* Set commands */
static int
set_hello_time(int s, char *recvspace)
{
	if (!recvspace || atoi(recvspace) < 1) {
		writestr(s, "Invalid timeout\n");
		return 1;
	}

	ldp_hello_time = atoi(recvspace);
	return 1;
}

static int
set_debug(int s, char *recvspace)
{
	if (!recvspace || atoi(recvspace) < 0) {
		writestr(s, "Invalid command\n");
		return 1;
	}

	debug_f = atoi(recvspace);
	return 1;
}

static int
set_warning(int s, char *recvspace)
{
	if (!recvspace || atoi(recvspace) < 0) {
		writestr(s, "Invalid command\n");
		return 1;
	}

	warn_f = atoi(recvspace);
	return 1;
}