v0.6.2

bin/copyparty-fuse.py

@@ -906,6 +906,7 @@ class TheArgparseFormatter(
 
 def main():
     global info, log, dbg
+    time.strptime("19970815", "%Y%m%d")  # python#7980
 
     # filecache helps for reads that are ~64k or smaller;
     #   linux generally does 128k so the cache is a slowdown,

bin/copyparty-fuseb.py

@@ -567,6 +567,8 @@ class CPPF(Fuse):
 
 
 def main():
+    time.strptime("19970815", "%Y%m%d")  # python#7980
+
     server = CPPF()
     server.parser.add_option(mountopt="url", metavar="BASE_URL", default=None)
     server.parse(values=server, errex=1)

copyparty/__main__.py

@@ -9,6 +9,7 @@ __license__ = "MIT"
 __url__ = "https://github.com/9001/copyparty/"
 
 import os
+import time
 import shutil
 import filecmp
 import locale
@@ -85,6 +86,7 @@ def ensure_cert():
 
 
 def main():
+    time.strptime("19970815", "%Y%m%d")  # python#7980
     if WINDOWS:
         os.system("")  # enables colors
 

copyparty/__version__.py

@@ -1,8 +1,8 @@
 # coding: utf-8
 
-VERSION = (0, 6, 0)
+VERSION = (0, 6, 2)
 CODENAME = "CHRISTMAAAAAS"
-BUILD_DT = (2020, 12, 1)
+BUILD_DT = (2020, 12, 14)
 
 S_VERSION = ".".join(map(str, VERSION))
 S_BUILD_DT = "{0:04d}-{1:02d}-{2:02d}".format(*BUILD_DT)

copyparty/authsrv.py

@@ -104,7 +104,7 @@ class VFS(object):
         real.sort()
         if not rem:
             for name, vn2 in sorted(self.nodes.items()):
-                if uname in vn2.uread:
+                if uname in vn2.uread or "*" in vn2.uread:
                     virt_vis[name] = vn2
 
             # no vfs nodes in the list of real inodes

copyparty/httpcli.py

@@ -568,24 +568,24 @@ class HttpCli(object):
                     self.log("discarding incoming file without filename")
                     # fallthrough
 
-                fn = os.devnull
                 if p_file and not nullwrite:
                     fdir = os.path.join(vfs.realpath, rem)
-                    fn = os.path.join(fdir, sanitize_fn(p_file))
+                    fname = sanitize_fn(p_file)
 
                     if not os.path.isdir(fsenc(fdir)):
                         raise Pebkac(404, "that folder does not exist")
 
-                    # TODO broker which avoid this race and
-                    # provides a new filename if taken (same as up2k)
-                    if os.path.exists(fsenc(fn)):
-                        fn += ".{:.6f}-{}".format(time.time(), self.addr[0])
-                        # using current-time instead of t0 cause clients
-                        # may reuse a name for multiple files in one post
+                    suffix = ".{:.6f}-{}".format(time.time(), self.addr[0])
+                    open_args = {"fdir": fdir, "suffix": suffix}
+                else:
+                    open_args = {}
+                    fname = os.devnull
+                    fdir = ""
 
                 try:
-                    with open(fsenc(fn), "wb") as f:
-                        self.log("writing to {0}".format(fn))
+                    with ren_open(fname, "wb", 512 * 1024, **open_args) as f:
+                        f, fname = f["orz"]
+                        self.log("writing to {}/{}".format(fdir, fname))
                         sz, sha512_hex, _ = hashcopy(self.conn, p_data, f)
                         if sz == 0:
                             raise Pebkac(400, "empty files in post")
@@ -594,8 +594,14 @@ class HttpCli(object):
                         self.conn.nbyte += sz
 
                 except Pebkac:
-                    if fn != os.devnull:
-                        os.rename(fsenc(fn), fsenc(fn + ".PARTIAL"))
+                    if fname != os.devnull:
+                        fp = os.path.join(fdir, fname)
+                        suffix = ".PARTIAL"
+                        try:
+                            os.rename(fsenc(fp), fsenc(fp + suffix))
+                        except:
+                            fp = fp[: -len(suffix)]
+                            os.rename(fsenc(fp), fsenc(fp + suffix))
 
                     raise
 
@@ -731,7 +737,7 @@ class HttpCli(object):
         if p_field != "body":
             raise Pebkac(400, "expected body, got {}".format(p_field))
 
-        with open(fp, "wb") as f:
+        with open(fp, "wb", 512 * 1024) as f:
             sz, sha512, _ = hashcopy(self.conn, p_data, f)
 
         new_lastmod = os.stat(fsenc(fp)).st_mtime

copyparty/up2k.py

@@ -13,7 +13,7 @@ import threading
 from copy import deepcopy
 
 from .__init__ import WINDOWS
-from .util import Pebkac, Queue, fsenc, sanitize_fn
+from .util import Pebkac, Queue, fsenc, sanitize_fn, ren_open
 
 
 class Up2k(object):
@@ -68,9 +68,11 @@ class Up2k(object):
                         # symlink to the client-provided name,
                         # returning the previous upload info
                         job = deepcopy(job)
-                        suffix = self._suffix(dst, now, job["addr"])
-                        job["name"] = cj["name"] + suffix
-                        self._symlink(src, dst + suffix)
+                        job["rdir"] = cj["rdir"]
+                        job["name"] = self._untaken(cj["rdir"], cj["name"], now, cj["addr"])
+                        dst = os.path.join(job["rdir"], job["name"])
+                        os.unlink(fsenc(dst))  # TODO ed pls
+                        self._symlink(src, dst)
             else:
                 job = {
                     "wark": wark,
@@ -85,9 +87,6 @@ class Up2k(object):
                     "hash": deepcopy(cj["hash"]),
                 }
 
-                path = os.path.join(job["rdir"], job["name"])
-                job["name"] += self._suffix(path, now, cj["addr"])
-
                 # one chunk may occur multiple times in a file;
                 # filter to unique values for the list of missing chunks
                 # (preserve order to reduce disk thrashing)
@@ -108,13 +107,12 @@ class Up2k(object):
                 "wark": wark,
             }
 
-    def _suffix(self, fpath, ts, ip):
+    def _untaken(self, fdir, fname, ts, ip):
         # TODO broker which avoid this race and
         # provides a new filename if taken (same as bup)
-        if not os.path.exists(fsenc(fpath)):
-            return ""
-
-        return ".{:.6f}-{}".format(ts, ip)
+        suffix = ".{:.6f}-{}".format(ts, ip)
+        with ren_open(fname, "wb", fdir=fdir, suffix=suffix) as f:
+            return f["orz"][1]
 
     def _symlink(self, src, dst):
         # TODO store this in linktab so we never delete src if there are links to it
@@ -218,8 +216,9 @@ class Up2k(object):
 
     def _new_upload(self, job):
         self.registry[job["wark"]] = job
-        path = os.path.join(job["rdir"], job["name"])
-        with open(fsenc(path), "wb") as f:
+        suffix = ".{:.6f}-{}".format(job["t0"], job["addr"])
+        with ren_open(job["name"], "wb", fdir=job["rdir"], suffix=suffix) as f:
+            f, job["name"] = f["orz"]
             f.seek(job["size"] - 1)
             f.write(b"e")
 

copyparty/util.py

@@ -2,6 +2,7 @@
 from __future__ import print_function, unicode_literals
 
 import re
+import os
 import sys
 import time
 import base64
@@ -10,6 +11,7 @@ import hashlib
 import platform
 import threading
 import mimetypes
+import contextlib
 import subprocess as sp  # nosec
 
 from .__init__ import PY2, WINDOWS
@@ -96,6 +98,80 @@ class Unrecv(object):
         self.buf = buf + self.buf
 
 
+@contextlib.contextmanager
+def ren_open(fname, *args, **kwargs):
+    fdir = kwargs.pop("fdir", None)
+    suffix = kwargs.pop("suffix", None)
+
+    if fname == os.devnull:
+        with open(fname, *args, **kwargs) as f:
+            yield {"orz": [f, fname]}
+            return
+    
+    orig_name = fname
+    bname = fname
+    ext = ""
+    while True:
+        ofs = bname.rfind(".")
+        if ofs < 0 or ofs < len(bname) - 7:
+            # doesn't look like an extension anymore
+            break
+
+        ext = bname[ofs:] + ext
+        bname = bname[:ofs]
+
+    b64 = ""
+    while True:
+        try:
+            if fdir:
+                fpath = os.path.join(fdir, fname)
+            else:
+                fpath = fname
+
+            if suffix and os.path.exists(fpath):
+                fpath += suffix
+                fname += suffix
+                ext += suffix
+
+            with open(fsenc(fpath), *args, **kwargs) as f:
+                if b64:
+                    fp2 = "fn-trunc.{}.txt".format(b64)
+                    fp2 = os.path.join(fdir, fp2)
+                    with open(fsenc(fp2), "wb") as f2:
+                        f2.write(orig_name.encode("utf-8"))
+
+                yield {"orz": [f, fname]}
+                return
+
+        except OSError as ex_:
+            ex = ex_
+            if ex.errno != 36:
+                raise
+
+        if not b64:
+            b64 = (bname + ext).encode("utf-8", "replace")
+            b64 = hashlib.sha512(b64).digest()[:12]
+            b64 = base64.urlsafe_b64encode(b64).decode("utf-8").rstrip("=")
+
+        badlen = len(fname)
+        while len(fname) >= badlen:
+            if len(bname) < 8:
+                raise ex
+
+            if len(bname) > len(ext):
+                # drop the last letter of the filename
+                bname = bname[:-1]
+            else:
+                try:
+                    # drop the leftmost sub-extension
+                    _, ext = ext.split(".", 1)
+                except:
+                    # okay do the first letter then
+                    ext = "." + ext[2:]
+
+            fname = "{}~{}{}".format(bname, b64, ext)
+
+
 class MultipartParser(object):
     def __init__(self, log_func, sr, http_headers):
         self.sr = sr

copyparty/web/md2.js

@@ -660,6 +660,10 @@ function md_backspace() {
     if (/^\s*$/.test(left))
         return true;
 
+    // same if selection
+    if (o0 != dom_src.selectionEnd)
+        return true;
+
     // same if line is all-whitespace or non-markup
     var v = m[0].replace(/[^ ]/g, " ");
     if (v === m[0] || v.length !== left.length)

copyparty/web/up2k.js

@@ -667,12 +667,26 @@ function up2k_init(have_crypto) {
                 }
                 tasker();
             }
-            else
+            else {
+                var err = "";
+                var rsp = (xhr.responseText + '');
+                if (rsp.indexOf('partial upload exists') !== -1) {
+                    err = rsp.slice(5);
+                }
+                if (err != "") {
+                    ebi('f{0}t'.format(t.n)).innerHTML = "ERROR";
+                    ebi('f{0}p'.format(t.n)).innerHTML = err;
+
+                    st.busy.handshake.splice(st.busy.handshake.indexOf(t), 1);
+                    tasker();
+                    return;
+                }
                 alert("server broke (error {0}):\n\"{1}\"\n".format(
                     xhr.status,
                     (xhr.response && xhr.response.err) ||
                     (xhr.responseText && xhr.responseText) ||
                     "no further information"));
+            }
         };
         xhr.open('POST', post_url + 'handshake.php', true);
         xhr.responseType = 'text';

scripts/copyparty-repack.sh

@@ -1,4 +1,5 @@
 #!/bin/bash
+repacker=1
 set -e
 
 # -- download latest copyparty (source.tgz and sfx),
@@ -27,13 +28,24 @@ cd "$td"
 pwd
 
 
-# debug: if cache exists, use that instead of bothering github
+dl_text() {
+	command -v curl && exec curl "$@"
+	exec wget -O- "$@"
+}
+dl_files() {
+	command -v curl && exec curl -L --remote-name-all "$@"
+	exec wget "$@"
+}
+export -f dl_files
+
+
+# if cache exists, use that instead of bothering github
 cache="$od/.copyparty-repack.cache"
 [ -e "$cache" ] &&
-	tar -xvf "$cache" ||
+	tar -xf "$cache" ||
 {
 	# get download links from github
-	curl https://api.github.com/repos/9001/copyparty/releases/latest |
+	dl_text https://api.github.com/repos/9001/copyparty/releases/latest |
 	(
 		# prefer jq if available
 		jq -r '.assets[]|select(.name|test("-sfx|tar.gz")).browser_download_url' ||
@@ -42,10 +54,10 @@ cache="$od/.copyparty-repack.cache"
 		awk -F\" '/"browser_download_url".*(\.tar\.gz|-sfx\.)/ {print$4}'
 	) |
 	tee /dev/stderr |
-	tr -d '\r' | tr '\n' '\0' | xargs -0 curl -L --remote-name-all
+	tr -d '\r' | tr '\n' '\0' |
+	xargs -0 bash -c 'dl_files "$@"' _
 
-	# debug: create cache
-	#tar -czvf "$cache" *
+	tar -czf "$cache" *
 }
 
 
@@ -58,10 +70,21 @@ mv copyparty-*.tar.gz copyparty-extras/
 
 # unpack the source code
 ( cd copyparty-extras/
-tar -xvf *.tar.gz
+tar -xf *.tar.gz
 )
 
 
+# use repacker from release if that is newer
+p_other=copyparty-extras/copyparty-*/scripts/copyparty-repack.sh
+other=$(awk -F= 'BEGIN{v=-1} NR<10&&/^repacker=/{v=$NF} END{print v}' <$p_other) 
+[ $repacker -lt $other ] &&
+  cat $p_other >"$od/$0" && cd "$od" && rm -rf "$td" && exec "$0" "$@"
+
+
+# now drop the cache
+rm -f "$cache"
+
+
 # fix permissions
 chmod 755 \
   copyparty-extras/sfx-full/* \
@@ -89,7 +112,9 @@ rm -rf copyparty-{0..9}*.*.*{0..9}
 
 
 # and include the repacker itself too
-cp -pv "$od/$0" copyparty-extras/ 
+cp -av "$od/$0" copyparty-extras/ ||
+cp -av "$0" copyparty-extras/ ||
+true
 
 
 # create the bundle

scripts/make-sfx.sh

@@ -115,7 +115,7 @@ git describe --tags >/dev/null 2>/dev/null && {
 		exit 1
 	}
 
-	dt="$(git log -1 --format=%cd --date=format:'%Y, %m, %d')"
+	dt="$(git log -1 --format=%cd --date=format:'%Y,%m,%d' | sed 's/,0?/, /g')"
 	printf 'git %3s: \033[36m%s\033[0m\n' ver "$ver" dt "$dt"
 	sed -ri '
 		s/^(VERSION =)(.*)/#\1\2\n\1 ('"$t_ver"')/;

tests/test_vfs.py

@@ -6,6 +6,7 @@ import os
 import time
 import json
 import shutil
+import tempfile
 import unittest
 import subprocess as sp  # nosec
 
@@ -31,9 +32,6 @@ class TestVFS(unittest.TestCase):
         response = self.unfoo(response)
         self.assertEqual(util.undot(query), response)
 
-    def absify(self, root, names):
-        return ["{}/{}".format(root, x).replace("//", "/") for x in names]
-
     def ls(self, vfs, vpath, uname):
         """helper for resolving and listing a folder"""
         vn, rem = vfs.get(vpath, uname, True, False)
@@ -60,23 +58,31 @@ class TestVFS(unittest.TestCase):
 
         if os.path.exists("/Volumes"):
             devname, _ = self.chkcmd("hdiutil", "attach", "-nomount", "ram://8192")
+            devname = devname.strip()
+            print("devname: [{}]".format(devname))
             for _ in range(10):
                 try:
-                    _, _ = self.chkcmd("diskutil", "eraseVolume", "HFS+", "cptd", devname)
+                    _, _ = self.chkcmd(
+                        "diskutil", "eraseVolume", "HFS+", "cptd", devname
+                    )
                     return "/Volumes/cptd"
-                except:
-                    print('lol macos')
+                except Exception as ex:
+                    print(repr(ex))
                     time.sleep(0.25)
-            
+
             raise Exception("ramdisk creation failed")
 
-        raise Exception("TODO support windows")
+        ret = os.path.join(tempfile.gettempdir(), "copyparty-test")
+        try:
+            os.mkdir(ret)
+        finally:
+            return ret
 
     def log(self, src, msg):
         pass
 
     def test(self):
-        td = self.get_ramdisk() + "/vfs"
+        td = os.path.join(self.get_ramdisk(), "vfs")
         try:
             shutil.rmtree(td)
         except OSError:
@@ -107,7 +113,7 @@ class TestVFS(unittest.TestCase):
         vfs = AuthSrv(Namespace(c=None, a=[], v=["a/ab/::r"]), self.log).vfs
         self.assertEqual(vfs.nodes, {})
         self.assertEqual(vfs.vpath, "")
-        self.assertEqual(vfs.realpath, td + "/a/ab")
+        self.assertEqual(vfs.realpath, os.path.join(td, "a", "ab"))
         self.assertEqual(vfs.uread, ["*"])
         self.assertEqual(vfs.uwrite, [])
 
@@ -117,7 +123,7 @@ class TestVFS(unittest.TestCase):
         ).vfs
         self.assertEqual(vfs.nodes, {})
         self.assertEqual(vfs.vpath, "")
-        self.assertEqual(vfs.realpath, td + "/a/aa")
+        self.assertEqual(vfs.realpath, os.path.join(td, "a", "aa"))
         self.assertEqual(vfs.uread, ["*"])
         self.assertEqual(vfs.uwrite, [])
 
@@ -146,42 +152,63 @@ class TestVFS(unittest.TestCase):
         n = n.nodes["acb"]
         self.assertEqual(n.nodes, {})
         self.assertEqual(n.vpath, "a/ac/acb")
-        self.assertEqual(n.realpath, td + "/a/ac/acb")
+        self.assertEqual(n.realpath, os.path.join(td, "a", "ac", "acb"))
         self.assertEqual(n.uread, ["k"])
         self.assertEqual(n.uwrite, ["*", "k"])
 
+        # something funky about the windows path normalization,
+        # doesn't really matter but makes the test messy, TODO?
+
         fsdir, real, virt = self.ls(vfs, "/", "*")
         self.assertEqual(fsdir, td)
         self.assertEqual(real, ["b", "c"])
         self.assertEqual(list(virt), ["a"])
 
         fsdir, real, virt = self.ls(vfs, "a", "*")
-        self.assertEqual(fsdir, td + "/a")
+        self.assertEqual(fsdir, os.path.join(td, "a"))
         self.assertEqual(real, ["aa", "ab"])
         self.assertEqual(list(virt), ["ac"])
 
         fsdir, real, virt = self.ls(vfs, "a/ab", "*")
-        self.assertEqual(fsdir, td + "/a/ab")
+        self.assertEqual(fsdir, os.path.join(td, "a", "ab"))
         self.assertEqual(real, ["aba", "abb", "abc"])
         self.assertEqual(list(virt), [])
 
         fsdir, real, virt = self.ls(vfs, "a/ac", "*")
-        self.assertEqual(fsdir, td + "/a/ac")
+        self.assertEqual(fsdir, os.path.join(td, "a", "ac"))
         self.assertEqual(real, ["aca", "acc"])
         self.assertEqual(list(virt), [])
 
         fsdir, real, virt = self.ls(vfs, "a/ac", "k")
-        self.assertEqual(fsdir, td + "/a/ac")
+        self.assertEqual(fsdir, os.path.join(td, "a", "ac"))
         self.assertEqual(real, ["aca", "acc"])
         self.assertEqual(list(virt), ["acb"])
 
         self.assertRaises(util.Pebkac, vfs.get, "a/ac/acb", "*", True, False)
 
         fsdir, real, virt = self.ls(vfs, "a/ac/acb", "k")
-        self.assertEqual(fsdir, td + "/a/ac/acb")
+        self.assertEqual(fsdir, os.path.join(td, "a", "ac", "acb"))
         self.assertEqual(real, ["acba", "acbb", "acbc"])
         self.assertEqual(list(virt), [])
 
+        # admin-only rootfs with all-read-only subfolder
+        vfs = AuthSrv(Namespace(c=None, a=["k:k"], v=[".::ak", "a:a:r"]), self.log,).vfs
+        self.assertEqual(len(vfs.nodes), 1)
+        self.assertEqual(vfs.vpath, "")
+        self.assertEqual(vfs.realpath, td)
+        self.assertEqual(vfs.uread, ["k"])
+        self.assertEqual(vfs.uwrite, ["k"])
+        n = vfs.nodes["a"]
+        self.assertEqual(len(vfs.nodes), 1)
+        self.assertEqual(n.vpath, "a")
+        self.assertEqual(n.realpath, os.path.join(td, "a"))
+        self.assertEqual(n.uread, ["*"])
+        self.assertEqual(n.uwrite, [])
+        self.assertEqual(vfs.can_access("/", "*"), [False, False])
+        self.assertEqual(vfs.can_access("/", "k"), [True, True])
+        self.assertEqual(vfs.can_access("/a", "*"), [True, False])
+        self.assertEqual(vfs.can_access("/a", "k"), [True, False])
+
         # breadth-first construction
         vfs = AuthSrv(
             Namespace(
@@ -215,20 +242,20 @@ class TestVFS(unittest.TestCase):
         self.assertEqual(list(v1), ["a"])
 
         fsp, r1, v1 = self.ls(vfs, "a", "*")
-        self.assertEqual(fsp, td + "/a")
+        self.assertEqual(fsp, os.path.join(td, "a"))
         self.assertEqual(r1, ["aa", "ab"])
         self.assertEqual(list(v1), ["ac"])
 
         fsp1, r1, v1 = self.ls(vfs, "a/ac", "*")
         fsp2, r2, v2 = self.ls(vfs, "b", "*")
-        self.assertEqual(fsp1, td + "/b")
-        self.assertEqual(fsp2, td + "/b")
+        self.assertEqual(fsp1, os.path.join(td, "b"))
+        self.assertEqual(fsp2, os.path.join(td, "b"))
         self.assertEqual(r1, ["ba", "bb", "bc"])
         self.assertEqual(r1, r2)
         self.assertEqual(list(v1), list(v2))
 
         # config file parser
-        cfg_path = self.get_ramdisk() + "/test.cfg"
+        cfg_path = os.path.join(self.get_ramdisk(), "test.cfg")
         with open(cfg_path, "wb") as f:
             f.write(
                 dedent(
@@ -256,10 +283,11 @@ class TestVFS(unittest.TestCase):
         self.assertEqual(len(n.nodes), 1)
         n = n.nodes["dst"]
         self.assertEqual(n.vpath, "dst")
-        self.assertEqual(n.realpath, td + "/src")
+        self.assertEqual(n.realpath, os.path.join(td, "src"))
         self.assertEqual(n.uread, ["a", "asd"])
         self.assertEqual(n.uwrite, ["asd"])
         self.assertEqual(len(n.nodes), 0)
 
+        os.chdir(tempfile.gettempdir())
         shutil.rmtree(td)
         os.unlink(cfg_path)