path: root/src/services/vyos-http-api-server

#!/usr/bin/env python3
#
# Copyright (C) 2019 VyOS maintainers and contributors
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 or later as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
#

import os
import sys
import grp
import json
import traceback
import threading

import vyos.config

import bottle

from functools import wraps

from vyos.configsession import ConfigSession, ConfigSessionError
from vyos.config import VyOSError


DEFAULT_CONFIG_FILE = '/etc/vyos/http-api.conf'

CFG_GROUP = 'vyattacfg'

app = bottle.default_app()

# Giant lock!
lock = threading.Lock()

def load_server_config():
    with open(DEFAULT_CONFIG_FILE) as f:
        config = json.load(f)
    return config

def check_auth(key_list, key):
    id = None
    for k in key_list:
        if k['key'] == key:
            id = k['id']
    return id

def error(code, msg):
    bottle.response.status = code
    resp = {"success": False, "error": msg, "data": None}
    return json.dumps(resp)

def success(data):
    resp = {"success": True, "data": data, "error": None}
    return json.dumps(resp)

def auth_required(f):
    @wraps(f)
    def decorated_function(*args, **kwargs):
        key = bottle.request.forms.get("key")
        api_keys = app.config['vyos_keys']
        id = check_auth(api_keys, key)
        if not id:
            return error(401, "Valid API key is required")
        return f(*args, **kwargs)

    return decorated_function

@app.route('/configure', method='POST')
def configure():
    session = app.config['vyos_session']
    config = app.config['vyos_config']
    api_keys = app.config['vyos_keys']

    key = bottle.request.forms.get("key")
    id = check_auth(api_keys, key)
    if not id:
        return error(401, "Valid API key is required")

    strict_field = bottle.request.forms.get("strict")
    if strict_field == "true":
        strict = True
    else:
        strict = False

    commands = bottle.request.forms.get("data")
    if not commands:
        return error(400, "Non-empty data field is required")
    else:
        try:
            commands = json.loads(commands)
        except Exception as e:
            return error(400, "Failed to parse JSON: {0}".format(e))

    # Allow users to pass just one command
    if not isinstance(commands, list):
        commands = [commands]

    # We don't want multiple people/apps to be able to commit at once,
    # or modify the shared session while someone else is doing the same,
    # so the lock is really global
    lock.acquire()

    status = 200
    error_msg = None
    try:
        for c in commands:
            # What we've got may not even be a dict
            if not isinstance(c, dict):
                raise ConfigSessionError("Malformed command \"{0}\": any command must be a dict".format(json.dumps(c)))

            # Missing op or path is a show stopper
            if not ('op' in c):
                raise ConfigSessionError("Malformed command \"{0}\": missing \"op\" field".format(json.dumps(c)))
            if not ('path' in c):
                raise ConfigSessionError("Malformed command \"{0}\": missing \"path\" field".format(json.dumps(c)))

            # Missing value is fine, substitute for empty string
            if 'value' in c:
                value = c['value']
            else:
                value = ""

            op = c['op']
            path = c['path']

            if not path:
                raise ConfigSessionError("Malformed command \"{0}\": empty path".format(json.dumps(c)))

            # Type checking
            if not isinstance(path, list):
                raise ConfigSessionError("Malformed command \"{0}\": \"path\" field must be a list".format(json.dumps(c)))

            if not isinstance(value, str):
                raise ConfigSessionError("Malformed command \"{0}\": \"value\" field must be a string".format(json.dumps(c)))

            # Account for the case when value field is present and set to null
            if not value:
                value = ""

            # For vyos.configsessios calls that have no separate value arguments,
            # and for type checking too
            try:
                cfg_path = " ".join(path + [value]).strip()
            except TypeError:
                raise ConfigSessionError("Malformed command \"{0}\": \"path\" field must be a list of strings".format(json.dumps(c)))

            if op == 'set':
                # XXX: it would be nice to do a strict check for "path already exists",
                # but there's probably no way to do that
                session.set(path, value=value)
            elif op == 'delete':
                if strict and not config.exists(cfg_path):
                    raise ConfigSessionError("Cannot delete [{0}]: path/value does not exist".format(cfg_path))
                session.delete(path, value=value)
            elif op == 'comment':
                session.comment(path, value=value)
            else:
                raise ConfigSessionError("\"{0}\" is not a valid operation".format(op))
        # end for
        session.commit()
        print("Configuration modified via HTTP API using key \"{0}\"".format(id))
    except ConfigSessionError as e:
        session.discard()
        status = 400
        if app.config['vyos_debug']:
            print(traceback.format_exc(), file=sys.stderr)
        error_msg = str(e)
    except Exception as e:
        session.discard()
        print(traceback.format_exc(), file=sys.stderr)
        status = 500

        # Don't give the details away to the outer world
        error_msg = "An internal error occured. Check the logs for details."
    finally:
        lock.release()

    if status != 200:
        return error(status, error_msg)
    else:
        return success(None)

@app.route('/retrieve', method='POST')
def get_value():
    config = app.config['vyos_config']
    session = app.config['vyos_session']

    api_keys = app.config['vyos_keys']

    key = bottle.request.forms.get("key")
    id = check_auth(api_keys, key)
    if not id:
        return error(401, "Valid API key is required")

    command = bottle.request.forms.get("data")
    command = json.loads(command)

    try:
        op = command['op']
        path = " ".join(command['path'])
    except KeyError:
        return error(400, "Missing required field. \"op\" and \"path\" fields are required")

    try:
        if op == 'returnValue':
            res = config.return_value(path)
        elif op == 'returnValues':
            res = config.return_values(path)
        elif op == 'exists':
            res = config.exists(path)
        elif op == 'showConfig':
            config_format = 'json'
            if 'configFormat' in command:
                config_format = command['configFormat']

            res = session.show_config(path=command['path'])
            if config_format == 'json':
                config_tree = vyos.configtree.ConfigTree(res)
                res = json.loads(config_tree.to_json())
            elif config_format == 'json_ast':
                config_tree = vyos.configtree.ConfigTree(res)
                res = json.loads(config_tree.to_json_ast())
            elif config_format == 'raw':
                pass
            else:
                return error(400, "\"{0}\" is not a valid config format")
        else:
            return error(400, "\"{0}\" is not a valid operation".format(op))
    except VyOSError as e:
        return error(400, str(e))
    except Exception as e:
        print(traceback.format_exc(), file=sys.stderr)
        return error(500, "An internal error occured. Check the logs for details.")

    return success(res)

@app.route('/config-file', method='POST')
@auth_required
def config_file_op():
    config = app.config['vyos_config']
    session = app.config['vyos_session']

    command = bottle.request.forms.get("data")
    command = json.loads(command)

    try:
        op = command['op']
    except KeyError:
        return error(400, "Missing required field \"op\"")

    try:
        if op == 'save':
            try:
                path = command['file']
            except KeyError:
                path = '/config/config.boot'
            res = session.save_config(path)
        elif op == 'load':
            try:
                path = command['file']
            except KeyError:
                return error(400, "Missing required field \"file\"")
            res = session.load_config(path)
            res = session.commit()
        else:
            return error(400, "\"{0}\" is not a valid operation".format(op))
    except VyOSError as e:
        return error(400, str(e))
    except Exception as e:
        print(traceback.format_exc(), file=sys.stderr)
        return error(500, "An internal error occured. Check the logs for details.")

    return success(res)

@app.route('/image', method='POST')
@auth_required
def config_file_op():
    config = app.config['vyos_config']
    session = app.config['vyos_session']

    command = bottle.request.forms.get("data")
    command = json.loads(command)

    try:
        op = command['op']
    except KeyError:
        return error(400, "Missing required field \"op\"")

    try:
        if op == 'add':
            try:
                url = command['url']
            except KeyError:
                return error(400, "Missing required field \"url\"")
            res = session.install_image(url)
        elif op == 'delete':
            try:
                name = command['name']
            except KeyError:
                return error(400, "Missing required field \"name\"")
            res = session.remove_image(name)
        else:
            return error(400, "\"{0}\" is not a valid operation".format(op))
    except VyOSError as e:
        return error(400, str(e))
    except Exception as e:
        print(traceback.format_exc(), file=sys.stderr)
        return error(500, "An internal error occured. Check the logs for details.")

    return success(res)


if __name__ == '__main__':
    # systemd's user and group options don't work, do it by hand here,
    # else no one else will be able to commit
    cfg_group = grp.getgrnam(CFG_GROUP)
    os.setgid(cfg_group.gr_gid)

    # Need to set file permissions to 775 too so that every vyattacfg group member
    # has write access to the running config
    os.umask(0o002)

    try:
        server_config = load_server_config()
    except Exception as e:
        print("Failed to load the HTTP API server config: {0}".format(e))

    session = ConfigSession(os.getpid())
    env = session.get_session_env()
    config = vyos.config.Config(session_env=env)

    app.config['vyos_session'] = session
    app.config['vyos_config'] = config
    app.config['vyos_keys'] = server_config['api_keys']
    app.config['vyos_debug'] = server_config['debug']

    bottle.run(app, host=server_config["listen_address"], port=server_config["port"], debug=True)