/* $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@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;
}