view sat_frontends/jp/cmd_file.py @ 2646:712cb4ff3e13

core: new EncryptionHandler class which manage encrypted session as a core feature: Plugin handling encryption can now register using host.registerEncryptionPlugin, and an encryption session can now be started using messageEncryptionStart bridge method. This will make encryption handling more easy, as we now know if a session is clear or e2e encrypted, and which plugin handle it.
author Goffi <goffi@goffi.org>
date Sun, 29 Jul 2018 19:22:56 +0200
parents 56f94936df1e
children 003b8b4b56a7
line wrap: on
line source

#!/usr/bin/env python2
# -*- coding: utf-8 -*-

# jp: a SAT command line tool
# Copyright (C) 2009-2018 Jérôme Poisson (goffi@goffi.org)

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.

# 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 Affero General Public License for more details.

# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.


import base
import sys
import os
import os.path
import tarfile
from sat.core.i18n import _
from sat_frontends.jp.constants import Const as C
from sat_frontends.jp import common
from sat_frontends.tools import jid
from sat.tools.common.ansi import ANSI as A
import tempfile
import xml.etree.ElementTree as ET  # FIXME: used temporarily to manage XMLUI
from functools import partial
import json

__commands__ = ["File"]


class Send(base.CommandBase):
    def __init__(self, host):
        super(Send, self).__init__(
            host,
            "send",
            use_progress=True,
            use_verbose=True,
            help=_("send a file to a contact"),
        )
        self.need_loop = True

    def add_parser_options(self):
        self.parser.add_argument(
            "files", type=str, nargs="+", metavar="file", help=_(u"a list of file")
        )
        self.parser.add_argument(
            "jid", type=base.unicode_decoder, help=_(u"the destination jid")
        )
        self.parser.add_argument(
            "-b", "--bz2", action="store_true", help=_(u"make a bzip2 tarball")
        )
        self.parser.add_argument(
            "-d",
            "--path",
            type=base.unicode_decoder,
            help=(u"path to the directory where the file must be stored"),
        )
        self.parser.add_argument(
            "-N",
            "--namespace",
            type=base.unicode_decoder,
            help=(u"namespace of the file"),
        )
        self.parser.add_argument(
            "-n",
            "--name",
            type=base.unicode_decoder,
            default=u"",
            help=(u"name to use (DEFAULT: use source file name)"),
        )

    def start(self):
        """Send files to jabber contact"""
        self.send_files()

    def onProgressStarted(self, metadata):
        self.disp(_(u"File copy started"), 2)

    def onProgressFinished(self, metadata):
        self.disp(_(u"File sent successfully"), 2)

    def onProgressError(self, error_msg):
        if error_msg == C.PROGRESS_ERROR_DECLINED:
            self.disp(_(u"The file has been refused by your contact"))
        else:
            self.disp(_(u"Error while sending file: {}").format(error_msg), error=True)

    def gotId(self, data, file_):
        """Called when a progress id has been received

        @param pid(unicode): progress id
        @param file_(str): file path
        """
        # FIXME: this show progress only for last progress_id
        self.disp(_(u"File request sent to {jid}".format(jid=self.full_dest_jid)), 1)
        try:
            self.progress_id = data["progress"]
        except KeyError:
            # TODO: if 'xmlui' key is present, manage xmlui message display
            self.disp(
                _(u"Can't send file to {jid}".format(jid=self.full_dest_jid)), error=True
            )
            self.host.quit(2)

    def error(self, failure):
        self.disp(
            _("Error while trying to send a file: {reason}").format(reason=failure),
            error=True,
        )
        self.host.quit(1)

    def send_files(self):
        for file_ in self.args.files:
            if not os.path.exists(file_):
                self.disp(_(u"file [{}] doesn't exist !").format(file_), error=True)
                self.host.quit(1)
            if not self.args.bz2 and os.path.isdir(file_):
                self.disp(
                    _(
                        u"[{}] is a dir ! Please send files inside or use compression"
                    ).format(file_)
                )
                self.host.quit(1)

        self.full_dest_jid = self.host.get_full_jid(self.args.jid)
        extra = {}
        if self.args.path:
            extra[u"path"] = self.args.path
        if self.args.namespace:
            extra[u"namespace"] = self.args.namespace

        if self.args.bz2:
            with tempfile.NamedTemporaryFile("wb", delete=False) as buf:
                self.host.addOnQuitCallback(os.unlink, buf.name)
                self.disp(_(u"bz2 is an experimental option, use with caution"))
                # FIXME: check free space
                self.disp(_(u"Starting compression, please wait..."))
                sys.stdout.flush()
                bz2 = tarfile.open(mode="w:bz2", fileobj=buf)
                archive_name = u"{}.tar.bz2".format(
                    os.path.basename(self.args.files[0]) or u"compressed_files"
                )
                for file_ in self.args.files:
                    self.disp(_(u"Adding {}").format(file_), 1)
                    bz2.add(file_)
                bz2.close()
                self.disp(_(u"Done !"), 1)

                self.host.bridge.fileSend(
                    self.full_dest_jid,
                    buf.name,
                    self.args.name or archive_name,
                    "",
                    extra,
                    self.profile,
                    callback=lambda pid, file_=buf.name: self.gotId(pid, file_),
                    errback=self.error,
                )
        else:
            for file_ in self.args.files:
                path = os.path.abspath(file_)
                self.host.bridge.fileSend(
                    self.full_dest_jid,
                    path,
                    self.args.name,
                    "",
                    extra,
                    self.profile,
                    callback=lambda pid, file_=file_: self.gotId(pid, file_),
                    errback=self.error,
                )


class Request(base.CommandBase):
    def __init__(self, host):
        super(Request, self).__init__(
            host,
            "request",
            use_progress=True,
            use_verbose=True,
            help=_("request a file from a contact"),
        )
        self.need_loop = True

    @property
    def filename(self):
        return self.args.name or self.args.hash or u"output"

    def add_parser_options(self):
        self.parser.add_argument(
            "jid", type=base.unicode_decoder, help=_(u"the destination jid")
        )
        self.parser.add_argument(
            "-D",
            "--dest",
            type=base.unicode_decoder,
            help=_(
                u"destination path where the file will be saved (default: [current_dir]/[name|hash])"
            ),
        )
        self.parser.add_argument(
            "-n",
            "--name",
            type=base.unicode_decoder,
            default=u"",
            help=_(u"name of the file"),
        )
        self.parser.add_argument(
            "-H",
            "--hash",
            type=base.unicode_decoder,
            default=u"",
            help=_(u"hash of the file"),
        )
        self.parser.add_argument(
            "-a",
            "--hash-algo",
            type=base.unicode_decoder,
            default=u"sha-256",
            help=_(u"hash algorithm use for --hash (default: sha-256)"),
        )
        self.parser.add_argument(
            "-d",
            "--path",
            type=base.unicode_decoder,
            help=(u"path to the directory containing the file"),
        )
        self.parser.add_argument(
            "-N",
            "--namespace",
            type=base.unicode_decoder,
            help=(u"namespace of the file"),
        )
        self.parser.add_argument(
            "-f",
            "--force",
            action="store_true",
            help=_(u"overwrite existing file without confirmation"),
        )

    def onProgressStarted(self, metadata):
        self.disp(_(u"File copy started"), 2)

    def onProgressFinished(self, metadata):
        self.disp(_(u"File received successfully"), 2)

    def onProgressError(self, error_msg):
        if error_msg == C.PROGRESS_ERROR_DECLINED:
            self.disp(_(u"The file request has been refused"))
        else:
            self.disp(_(u"Error while requesting file: {}").format(error_msg), error=True)

    def gotId(self, progress_id):
        """Called when a progress id has been received

        @param progress_id(unicode): progress id
        """
        self.progress_id = progress_id

    def error(self, failure):
        self.disp(
            _("Error while trying to send a file: {reason}").format(reason=failure),
            error=True,
        )
        self.host.quit(1)

    def start(self):
        if not self.args.name and not self.args.hash:
            self.parser.error(_(u"at least one of --name or --hash must be provided"))
        #  extra = dict(self.args.extra)
        if self.args.dest:
            path = os.path.abspath(os.path.expanduser(self.args.dest))
            if os.path.isdir(path):
                path = os.path.join(path, self.filename)
        else:
            path = os.path.abspath(self.filename)

        if os.path.exists(path) and not self.args.force:
            message = _(u"File {path} already exists! Do you want to overwrite?").format(
                path=path
            )
            confirm = raw_input(u"{} (y/N) ".format(message).encode("utf-8"))
            if confirm not in (u"y", u"Y"):
                self.disp(_(u"file request cancelled"))
                self.host.quit(2)

        self.full_dest_jid = self.host.get_full_jid(self.args.jid)
        extra = {}
        if self.args.path:
            extra[u"path"] = self.args.path
        if self.args.namespace:
            extra[u"namespace"] = self.args.namespace
        self.host.bridge.fileJingleRequest(
            self.full_dest_jid,
            path,
            self.args.name,
            self.args.hash,
            self.args.hash_algo if self.args.hash else u"",
            extra,
            self.profile,
            callback=self.gotId,
            errback=partial(
                self.errback,
                msg=_(u"can't request file: {}"),
                exit_code=C.EXIT_BRIDGE_ERRBACK,
            ),
        )


class Receive(base.CommandAnswering):
    def __init__(self, host):
        super(Receive, self).__init__(
            host,
            "receive",
            use_progress=True,
            use_verbose=True,
            help=_("wait for a file to be sent by a contact"),
        )
        self._overwrite_refused = False  # True when one overwrite as already been refused
        self.action_callbacks = {
            C.META_TYPE_FILE: self.onFileAction,
            C.META_TYPE_OVERWRITE: self.onOverwriteAction,
        }

    def onProgressStarted(self, metadata):
        self.disp(_(u"File copy started"), 2)

    def onProgressFinished(self, metadata):
        self.disp(_(u"File received successfully"), 2)
        if metadata.get("hash_verified", False):
            try:
                self.disp(
                    _(u"hash checked: {algo}:{checksum}").format(
                        algo=metadata["hash_algo"], checksum=metadata["hash"]
                    ),
                    1,
                )
            except KeyError:
                self.disp(_(u"hash is checked but hash value is missing", 1), error=True)
        else:
            self.disp(_(u"hash can't be verified"), 1)

    def onProgressError(self, error_msg):
        self.disp(_(u"Error while receiving file: {}").format(error_msg), error=True)

    def getXmluiId(self, action_data):
        # FIXME: we temporarily use ElementTree, but a real XMLUI managing module
        #        should be available in the futur
        # TODO: XMLUI module
        try:
            xml_ui = action_data["xmlui"]
        except KeyError:
            self.disp(_(u"Action has no XMLUI"), 1)
        else:
            ui = ET.fromstring(xml_ui.encode("utf-8"))
            xmlui_id = ui.get("submit")
            if not xmlui_id:
                self.disp(_(u"Invalid XMLUI received"), error=True)
            return xmlui_id

    def onFileAction(self, action_data, action_id, security_limit, profile):
        xmlui_id = self.getXmluiId(action_data)
        if xmlui_id is None:
            return self.host.quitFromSignal(1)
        try:
            from_jid = jid.JID(action_data["meta_from_jid"])
        except KeyError:
            self.disp(_(u"Ignoring action without from_jid data"), 1)
            return
        try:
            progress_id = action_data["meta_progress_id"]
        except KeyError:
            self.disp(_(u"ignoring action without progress id"), 1)
            return

        if not self.bare_jids or from_jid.bare in self.bare_jids:
            if self._overwrite_refused:
                self.disp(_(u"File refused because overwrite is needed"), error=True)
                self.host.bridge.launchAction(
                    xmlui_id, {"cancelled": C.BOOL_TRUE}, profile_key=profile
                )
                return self.host.quitFromSignal(2)
            self.progress_id = progress_id
            xmlui_data = {"path": self.path}
            self.host.bridge.launchAction(xmlui_id, xmlui_data, profile_key=profile)

    def onOverwriteAction(self, action_data, action_id, security_limit, profile):
        xmlui_id = self.getXmluiId(action_data)
        if xmlui_id is None:
            return self.host.quitFromSignal(1)
        try:
            progress_id = action_data["meta_progress_id"]
        except KeyError:
            self.disp(_(u"ignoring action without progress id"), 1)
            return
        self.disp(_(u"Overwriting needed"), 1)

        if progress_id == self.progress_id:
            if self.args.force:
                self.disp(_(u"Overwrite accepted"), 2)
            else:
                self.disp(_(u"Refused to overwrite"), 2)
                self._overwrite_refused = True

            xmlui_data = {"answer": C.boolConst(self.args.force)}
            self.host.bridge.launchAction(xmlui_id, xmlui_data, profile_key=profile)

    def add_parser_options(self):
        self.parser.add_argument(
            "jids",
            type=base.unicode_decoder,
            nargs="*",
            help=_(u"jids accepted (accept everything if none is specified)"),
        )
        self.parser.add_argument(
            "-m",
            "--multiple",
            action="store_true",
            help=_(u"accept multiple files (you'll have to stop manually)"),
        )
        self.parser.add_argument(
            "-f",
            "--force",
            action="store_true",
            help=_(
                u"force overwritting of existing files (/!\\ name is choosed by sender)"
            ),
        )
        self.parser.add_argument(
            "--path",
            default=".",
            metavar="DIR",
            help=_(u"destination path (default: working directory)"),
        )

    def start(self):
        self.bare_jids = [jid.JID(jid_).bare for jid_ in self.args.jids]
        self.path = os.path.abspath(self.args.path)
        if not os.path.isdir(self.path):
            self.disp(_(u"Given path is not a directory !", error=True))
            self.host.quit(2)
        if self.args.multiple:
            self.host.quit_on_progress_end = False
        self.disp(_(u"waiting for incoming file request"), 2)


class Upload(base.CommandBase):
    def __init__(self, host):
        super(Upload, self).__init__(
            host, "upload", use_progress=True, use_verbose=True, help=_("upload a file")
        )
        self.need_loop = True

    def add_parser_options(self):
        self.parser.add_argument("file", type=str, help=_("file to upload"))
        self.parser.add_argument(
            "jid",
            type=base.unicode_decoder,
            nargs="?",
            help=_("jid of upload component (nothing to autodetect)"),
        )
        self.parser.add_argument(
            "--ignore-tls-errors",
            action="store_true",
            help=_("ignore invalide TLS certificate"),
        )

    def onProgressStarted(self, metadata):
        self.disp(_(u"File upload started"), 2)

    def onProgressFinished(self, metadata):
        self.disp(_(u"File uploaded successfully"), 2)
        try:
            url = metadata["url"]
        except KeyError:
            self.disp(u"download URL not found in metadata")
        else:
            self.disp(_(u"URL to retrieve the file:"), 1)
            # XXX: url is display alone on a line to make parsing easier
            self.disp(url)

    def onProgressError(self, error_msg):
        self.disp(_(u"Error while uploading file: {}").format(error_msg), error=True)

    def gotId(self, data, file_):
        """Called when a progress id has been received

        @param pid(unicode): progress id
        @param file_(str): file path
        """
        try:
            self.progress_id = data["progress"]
        except KeyError:
            # TODO: if 'xmlui' key is present, manage xmlui message display
            self.disp(_(u"Can't upload file"), error=True)
            self.host.quit(2)

    def error(self, failure):
        self.disp(
            _("Error while trying to upload a file: {reason}").format(reason=failure),
            error=True,
        )
        self.host.quit(1)

    def start(self):
        file_ = self.args.file
        if not os.path.exists(file_):
            self.disp(_(u"file [{}] doesn't exist !").format(file_), error=True)
            self.host.quit(1)
        if os.path.isdir(file_):
            self.disp(_(u"[{}] is a dir! Can't upload a dir").format(file_))
            self.host.quit(1)

        self.full_dest_jid = (
            self.host.get_full_jid(self.args.jid) if self.args.jid is not None else ""
        )
        options = {}
        if self.args.ignore_tls_errors:
            options["ignore_tls_errors"] = C.BOOL_TRUE

        path = os.path.abspath(file_)
        self.host.bridge.fileUpload(
            path,
            "",
            self.full_dest_jid,
            options,
            self.profile,
            callback=lambda pid, file_=file_: self.gotId(pid, file_),
            errback=self.error,
        )


class ShareList(base.CommandBase):
    def __init__(self, host):
        extra_outputs = {"default": self.default_output}
        super(ShareList, self).__init__(
            host,
            "list",
            use_output=C.OUTPUT_LIST_DICT,
            extra_outputs=extra_outputs,
            help=_(u"retrieve files shared by an entity"),
            use_verbose=True,
        )
        self.need_loop = True

    def add_parser_options(self):
        self.parser.add_argument(
            "-d",
            "--path",
            default=u"",
            help=_(u"path to the directory containing the files"),
        )
        self.parser.add_argument(
            "jid",
            type=base.unicode_decoder,
            nargs="?",
            default="",
            help=_("jid of sharing entity (nothing to check our own jid)"),
        )

    def file_gen(self, files_data):
        for file_data in files_data:
            yield file_data[u"name"]
            yield file_data.get(u"size", "")
            yield file_data.get(u"hash", "")

    def _name_filter(self, name, row):
        if row.type == C.FILE_TYPE_DIRECTORY:
            return A.color(C.A_DIRECTORY, name)
        elif row.type == C.FILE_TYPE_FILE:
            return A.color(C.A_FILE, name)
        else:
            self.disp(_(u"unknown file type: {type}").format(type=row.type), error=True)
            return name

    def _size_filter(self, size, row):
        if not size:
            return u""
        size = int(size)
        #  cf. https://stackoverflow.com/a/1094933 (thanks)
        suffix = u"o"
        for unit in [u"", u"Ki", u"Mi", u"Gi", u"Ti", u"Pi", u"Ei", u"Zi"]:
            if abs(size) < 1024.0:
                return A.color(A.BOLD, u"{:.2f}".format(size), unit, suffix)
            size /= 1024.0

        return A.color(A.BOLD, u"{:.2f}".format(size), u"Yi", suffix)

    def default_output(self, files_data):
        """display files a way similar to ls"""
        files_data.sort(key=lambda d: d["name"].lower())
        show_header = False
        if self.verbosity == 0:
            headers = (u"name", u"type")
        elif self.verbosity == 1:
            headers = (u"name", u"type", u"size")
        elif self.verbosity > 1:
            show_header = True
            headers = (u"name", u"type", u"size", u"hash")
        table = common.Table.fromDict(
            self.host,
            files_data,
            headers,
            filters={u"name": self._name_filter, u"size": self._size_filter},
            defaults={u"size": u"", u"hash": u""},
        )
        table.display_blank(show_header=show_header, hide_cols=["type"])

    def _FISListCb(self, files_data):
        self.output(files_data)
        self.host.quit()

    def start(self):
        self.host.bridge.FISList(
            self.args.jid,
            self.args.path,
            {},
            self.profile,
            callback=self._FISListCb,
            errback=partial(
                self.errback,
                msg=_(u"can't retrieve shared files: {}"),
                exit_code=C.EXIT_BRIDGE_ERRBACK,
            ),
        )


class SharePath(base.CommandBase):
    def __init__(self, host):
        super(SharePath, self).__init__(
            host, "path", help=_(u"share a file or directory"), use_verbose=True
        )
        self.need_loop = True

    def add_parser_options(self):
        self.parser.add_argument(
            "-n",
            "--name",
            type=base.unicode_decoder,
            default=u"",
            help=_(u"virtual name to use (default: use directory/file name)"),
        )
        perm_group = self.parser.add_mutually_exclusive_group()
        perm_group.add_argument(
            "-j",
            "--jid",
            type=base.unicode_decoder,
            action="append",
            dest="jids",
            default=[],
            help=_(u"jid of contacts allowed to retrieve the files"),
        )
        perm_group.add_argument(
            "--public",
            action="store_true",
            help=_(
                u"share publicly the file(s) (/!\\ *everybody* will be able to access them)"
            ),
        )
        self.parser.add_argument(
            "path",
            type=base.unicode_decoder,
            help=_(u"path to a file or directory to share"),
        )

    def _FISSharePathCb(self, name):
        self.disp(
            _(u'{path} shared under the name "{name}"').format(path=self.path, name=name)
        )
        self.host.quit()

    def start(self):
        self.path = os.path.abspath(self.args.path)
        if self.args.public:
            access = {u"read": {u"type": u"public"}}
        else:
            jids = self.args.jids
            if jids:
                access = {u"read": {u"type": "whitelist", u"jids": jids}}
            else:
                access = {}
        self.host.bridge.FISSharePath(
            self.args.name,
            self.path,
            json.dumps(access, ensure_ascii=False),
            self.profile,
            callback=self._FISSharePathCb,
            errback=partial(
                self.errback,
                msg=_(u"can't share path: {}"),
                exit_code=C.EXIT_BRIDGE_ERRBACK,
            ),
        )


class Share(base.CommandBase):
    subcommands = (ShareList, SharePath)

    def __init__(self, host):
        super(Share, self).__init__(
            host, "share", use_profile=False, help=_(u"files sharing management")
        )


class File(base.CommandBase):
    subcommands = (Send, Request, Receive, Upload, Share)

    def __init__(self, host):
        super(File, self).__init__(
            host, "file", use_profile=False, help=_(u"files sending/receiving/management")
        )