copyparty 1.15.2__py3-none-any.whl → 1.15.4__py3-none-any.whl

copyparty/httpcli.py

@@ -32,11 +32,12 @@ try:
 except:
     pass
 
-from .__init__ import ANYWIN, PY2, TYPE_CHECKING, EnvParams, unicode
+from .__init__ import ANYWIN, PY2, RES, TYPE_CHECKING, EnvParams, unicode
 from .__version__ import S_VERSION
 from .authsrv import VFS  # typechk
 from .bos import bos
 from .star import StreamTar
+from .stolen.qrcodegen import QrCode, qr2svg
 from .sutil import StreamArc, gfilter
 from .szip import StreamZip
 from .up2k import up2k_chunksize
@@ -44,6 +45,7 @@ from .util import unquote  # type: ignore
 from .util import (
     APPLESAN_RE,
     BITNESS,
+    DAV_ALLPROPS,
     HAVE_SQLITE3,
     HTTPCODE,
     META_NOBOTS,
@@ -67,13 +69,16 @@ from .util import (
     get_df,
     get_spd,
     guess_mime,
+    gzip_file_orig_sz,
     gzip_orig_sz,
+    has_resource,
     hashcopy,
     hidedir,
     html_bescape,
     html_escape,
     humansize,
     ipnorm,
+    load_resource,
     loadpy,
     log_reloc,
     min_ex,
@@ -93,6 +98,7 @@ from .util import (
     sanitize_vpath,
     sendfile_kern,
     sendfile_py,
+    stat_resource,
     ub64dec,
     ub64enc,
     ujoin,
@@ -418,6 +424,7 @@ class HttpCli(object):
             vpath = undot(vpath)
 
             ptn = self.conn.hsrv.ptn_cc
+            k_safe = self.conn.hsrv.uparam_cc_ok
             for k in arglist.split("&"):
                 if "=" in k:
                     k, zs = k.split("=", 1)
@@ -430,7 +437,7 @@ class HttpCli(object):
                 k = k.lower()
                 uparam[k] = sv
 
-                if k in ("doc", "move", "tree"):
+                if k in k_safe:
                     continue
 
                 zs = "%s=%s" % (k, sv)
@@ -484,6 +491,9 @@ class HttpCli(object):
             self.vpath + "/" if self.trailing_slash and self.vpath else self.vpath
         )
 
+        if "qr" in uparam:
+            return self.tx_qr()
+
         if relchk(self.vpath) and (self.vpath != "*" or self.mode != "OPTIONS"):
             self.log("invalid relpath [{}]".format(self.vpath))
             self.cbonk(self.conn.hsrv.gmal, self.req, "bad_vp", "invalid relpaths")
@@ -1088,14 +1098,17 @@ class HttpCli(object):
             if self.vpath == ".cpr/metrics":
                 return self.conn.hsrv.metrics.tx(self)
 
-            path_base = os.path.join(self.E.mod, "web")
-            static_path = absreal(os.path.join(path_base, self.vpath[5:]))
-            if static_path in self.conn.hsrv.statics:
-                return self.tx_file(static_path)
+            res_path = "web/" + self.vpath[5:]
+            if res_path in RES:
+                ap = os.path.join(self.E.mod, res_path)
+                if bos.path.exists(ap) or bos.path.exists(ap + ".gz"):
+                    return self.tx_file(ap)
+                else:
+                    return self.tx_res(res_path)
 
-            if not static_path.startswith(path_base):
+            if res_path != undot(res_path):
                 t = "malicious user; attempted path traversal [{}] => [{}]"
-                self.log(t.format(self.vpath, static_path), 1)
+                self.log(t.format(self.vpath, res_path), 1)
                 self.cbonk(self.conn.hsrv.gmal, self.req, "trav", "path traversal")
 
             self.tx_404()
@@ -1190,10 +1203,6 @@ class HttpCli(object):
         tap = vn.canonical(rem)
 
         if "davauth" in vn.flags and self.uname == "*":
-            self.can_read = self.can_write = self.can_get = False
-
-        if not self.can_read and not self.can_write and not self.can_get:
-            self.log("inaccessible: [%s]" % (self.vpath,))
             raise Pebkac(401, "authenticate")
 
         from .dxml import parse_xml
@@ -1202,6 +1211,7 @@ class HttpCli(object):
         # enc = "shift_jis"
         enc = "utf-8"
         uenc = enc.upper()
+        props = DAV_ALLPROPS
 
         clen = int(self.headers.get("content-length", 0))
         if clen:
@@ -1212,33 +1222,13 @@ class HttpCli(object):
                     break
 
             xroot = parse_xml(buf.decode(enc, "replace"))
-            xtag = next(x for x in xroot if x.tag.split("}")[-1] == "prop")
-            props_lst = [y.tag.split("}")[-1] for y in xtag]
-        else:
-            props_lst = [
-                "contentclass",
-                "creationdate",
-                "defaultdocument",
-                "displayname",
-                "getcontentlanguage",
-                "getcontentlength",
-                "getcontenttype",
-                "getlastmodified",
-                "href",
-                "iscollection",
-                "ishidden",
-                "isreadonly",
-                "isroot",
-                "isstructureddocument",
-                "lastaccessed",
-                "name",
-                "parentname",
-                "resourcetype",
-                "supportedlock",
-            ]
+            xtag = next((x for x in xroot if x.tag.split("}")[-1] == "prop"), None)
+            if xtag is not None:
+                props = set([y.tag.split("}")[-1] for y in xtag])
+            # assume <allprop/> otherwise; nobody ever gonna <propname/>
 
-        props = set(props_lst)
-        depth = self.headers.get("depth", "infinity").lower()
+        zi = int(time.time())
+        vst = os.stat_result((16877, -1, -1, 1, 1000, 1000, 8, zi, zi, zi))
 
         try:
             topdir = {"vp": "", "st": bos.stat(tap)}
@@ -1247,10 +1237,22 @@ class HttpCli(object):
                 raise
             raise Pebkac(404)
 
-        if depth == "0" or not self.can_read or not stat.S_ISDIR(topdir["st"].st_mode):
-            fgen = []
+        fgen   = []
+
+        depth = self.headers.get("depth", "infinity").lower()
+        if depth == "infinity":
+            if not self.can_read:
+                t = "depth:infinity requires read-access in /%s"
+                t = t % (self.vpath,)
+                self.log(t, 3)
+                raise Pebkac(401, t)
+
+            if not stat.S_ISDIR(topdir["st"].st_mode):
+                t = "depth:infinity can only be used on folders; /%s is 0o%o"
+                t = t % (self.vpath, topdir["st"])
+                self.log(t, 3)
+                raise Pebkac(400, t)
 
-        elif depth == "infinity":
             if not self.args.dav_inf:
                 self.log("client wants --dav-inf", 3)
                 zb = b'<?xml version="1.0" encoding="utf-8"?>\n<D:error xmlns:D="DAV:"><D:propfind-finite-depth/></D:error>'
@@ -1278,22 +1280,28 @@ class HttpCli(object):
                 [[True, False]],
                 lstat="davrt" not in vn.flags,
             )
+            if not self.can_read:
+                vfs_ls = []
             if not self.can_dot:
                 names = set(exclude_dotfiles([x[0] for x in vfs_ls]))
                 vfs_ls = [x for x in vfs_ls if x[0] in names]
 
-            zi = int(time.time())
-            zsr = os.stat_result((16877, -1, -1, 1, 1000, 1000, 8, zi, zi, zi))
-            ls = [{"vp": vp, "st": st} for vp, st in vfs_ls]
-            ls += [{"vp": v, "st": zsr} for v in vfs_virt]
-            fgen = ls  # type: ignore
+            fgen = [{"vp": vp, "st": st} for vp, st in vfs_ls]
+            fgen += [{"vp": v, "st": vst} for v in vfs_virt]
+
+        elif depth == "0":
+            pass
 
         else:
             t = "invalid depth value '{}' (must be either '0' or '1'{})"
             t2 = " or 'infinity'" if self.args.dav_inf else ""
             raise Pebkac(412, t.format(depth, t2))
 
-        fgen = itertools.chain([topdir], fgen)  # type: ignore
+        if not self.can_read and not self.can_write and not self.can_get and not fgen:
+            self.log("inaccessible: [%s]" % (self.vpath,))
+            raise Pebkac(401, "authenticate")
+
+        fgen = itertools.chain([topdir], fgen)
         vtop = vjoin(self.args.R, vjoin(vn.vpath, rem))
 
         chunksz = 0x7FF8  # preferred by nginx or cf (dunno which)
@@ -1790,7 +1798,7 @@ class HttpCli(object):
             if rnd:
                 fn = rand_name(fdir, fn, rnd)
 
-            fn = sanitize_fn(fn or "", "", [".prologue.html", ".epilogue.html"])
+            fn = sanitize_fn(fn or "", "")
 
         path = os.path.join(fdir, fn)
 
@@ -2528,7 +2536,7 @@ class HttpCli(object):
         self.gctx = vpath
         vpath = undot(vpath)
         vfs, rem = self.asrv.vfs.get(vpath, self.uname, False, True)
-        rem = sanitize_vpath(rem, "/", [])
+        rem = sanitize_vpath(rem, "/")
         fn = vfs.canonical(rem)
         if not fn.startswith(vfs.realpath):
             self.log("invalid mkdir [%s] [%s]" % (self.gctx, vpath), 1)
@@ -2574,7 +2582,7 @@ class HttpCli(object):
         if not ext or len(ext) > 5 or not self.can_delete:
             new_file += ".md"
 
-        sanitized = sanitize_fn(new_file, "", [])
+        sanitized = sanitize_fn(new_file, "")
 
         if not nullwrite:
             fdir = vfs.canonical(rem)
@@ -2653,9 +2661,7 @@ class HttpCli(object):
                     # fallthrough
 
                 fdir = fdir_base
-                fname = sanitize_fn(
-                    p_file or "", "", [".prologue.html", ".epilogue.html"]
-                )
+                fname = sanitize_fn(p_file or "", "")
                 abspath = os.path.join(fdir, fname)
                 suffix = "-%.6f-%s" % (time.time(), dip)
                 if p_file and not nullwrite:
@@ -3282,6 +3288,130 @@ class HttpCli(object):
 
         return txt
 
+    def tx_res(self, req_path )  :
+        status = 200
+        logmsg = "{:4} {} ".format("", self.req)
+        logtail = ""
+
+        editions = {}
+        file_ts = 0
+
+        if has_resource(self.E, req_path):
+            st = stat_resource(self.E, req_path)
+            if st:
+                file_ts = max(file_ts, st.st_mtime)
+            editions["plain"] = req_path
+
+        if has_resource(self.E, req_path + ".gz"):
+            st = stat_resource(self.E, req_path + ".gz")
+            if st:
+                file_ts = max(file_ts, st.st_mtime)
+            if not st or st.st_mtime > file_ts:
+                editions[".gz"] = req_path + ".gz"
+
+        if not editions:
+            return self.tx_404()
+
+        #
+        # if-modified
+
+        if file_ts > 0:
+            file_lastmod, do_send = self._chk_lastmod(int(file_ts))
+            self.out_headers["Last-Modified"] = file_lastmod
+            if not do_send:
+                status = 304
+
+            if self.can_write:
+                self.out_headers["X-Lastmod3"] = str(int(file_ts * 1000))
+        else:
+            do_send = True
+
+        #
+        # Accept-Encoding and UA decides which edition to send
+
+        decompress = False
+        supported_editions = [
+            x.strip()
+            for x in self.headers.get("accept-encoding", "").lower().split(",")
+        ]
+        if ".gz" in editions:
+            is_compressed = True
+            selected_edition = ".gz"
+
+            if "gzip" not in supported_editions:
+                decompress = True
+            else:
+                if re.match(r"MSIE [4-6]\.", self.ua) and " SV1" not in self.ua:
+                    decompress = True
+
+            if not decompress:
+                self.out_headers["Content-Encoding"] = "gzip"
+        else:
+            is_compressed = False
+            selected_edition = "plain"
+
+        res_path = editions[selected_edition]
+        logmsg += "{} ".format(selected_edition.lstrip("."))
+
+        res = load_resource(self.E, res_path)
+
+        if decompress:
+            file_sz = gzip_file_orig_sz(res)
+            res = gzip.open(res)
+        else:
+            res.seek(0, os.SEEK_END)
+            file_sz = res.tell()
+            res.seek(0, os.SEEK_SET)
+
+        #
+        # send reply
+
+        if is_compressed:
+            self.out_headers["Cache-Control"] = "max-age=604869"
+        else:
+            self.permit_caching()
+
+        if "txt" in self.uparam:
+            mime = "text/plain; charset={}".format(self.uparam["txt"] or "utf-8")
+        elif "mime" in self.uparam:
+            mime = str(self.uparam.get("mime"))
+        else:
+            mime = guess_mime(req_path)
+
+        logmsg += unicode(status) + logtail
+
+        if self.mode == "HEAD" or not do_send:
+            res.close()
+            if self.do_log:
+                self.log(logmsg)
+
+            self.send_headers(length=file_sz, status=status, mime=mime)
+            return True
+
+        ret = True
+        self.send_headers(length=file_sz, status=status, mime=mime)
+        remains = sendfile_py(
+            self.log,
+            0,
+            file_sz,
+            res,
+            self.s,
+            self.args.s_wr_sz,
+            self.args.s_wr_slp,
+            not self.args.no_poll,
+        )
+        res.close()
+
+        if remains > 0:
+            logmsg += " \033[31m" + unicode(file_sz - remains) + "\033[0m"
+            ret = False
+
+        spd = self._spd(file_sz - remains)
+        if self.do_log:
+            self.log("{},  {}".format(logmsg, spd))
+
+        return ret
+
     def tx_file(self, req_path , ptop  = None)  :
         status = 200
         logmsg = "{:4} {} ".format("", self.req)
@@ -3663,7 +3793,7 @@ class HttpCli(object):
         items ,
     )  :
         if self.args.no_zip:
-            raise Pebkac(400, "not enabled")
+            raise Pebkac(400, "not enabled in server config")
 
         logmsg = "{:4} {} ".format("", self.req)
         self.keepalive = False
@@ -3789,6 +3919,33 @@ class HttpCli(object):
         self.reply(ico, mime=mime, headers={"Last-Modified": lm})
         return True
 
+    def tx_qr(self):
+        url = "%s://%s%s%s" % (
+            "https" if self.is_https else "http",
+            self.host,
+            self.args.SRS,
+            self.vpaths,
+        )
+        uhash = ""
+        uparams = []
+        if self.ouparam:
+            for k, v in self.ouparam.items():
+                if k == "qr":
+                    continue
+                if k == "uhash":
+                    uhash = v
+                    continue
+                uparams.append(k if v == "" else "%s=%s" % (k, v))
+        if uparams:
+            url += "?" + "&".join(uparams)
+        if uhash:
+            url += "#" + uhash
+
+        self.log("qrcode(%r)" % (url,))
+        ret = qr2svg(QrCode.encode_binary(url.encode("utf-8")), 2)
+        self.reply(ret.encode("utf-8"), mime="image/svg+xml")
+        return True
+
     def tx_md(self, vn , fs_path )  :
         logmsg = "     %s @%s " % (self.req, self.uname)
 
@@ -3797,15 +3954,11 @@ class HttpCli(object):
                 return self.tx_404(True)
 
         tpl = "mde" if "edit2" in self.uparam else "md"
-        html_path = os.path.join(self.E.mod, "web", "{}.html".format(tpl))
         template = self.j2j(tpl)
 
         st = bos.stat(fs_path)
         ts_md = st.st_mtime
 
-        st = bos.stat(html_path)
-        ts_html = st.st_mtime
-
         max_sz = 1024 * self.args.txt_max
         sz_md = 0
         lead = b""
@@ -3839,7 +3992,7 @@ class HttpCli(object):
             fullfile = html_bescape(fullfile)
             sz_md = len(lead) + len(fullfile)
 
-        file_ts = int(max(ts_md, ts_html, self.E.t0))
+        file_ts = int(max(ts_md, self.E.t0))
         file_lastmod, do_send = self._chk_lastmod(file_ts)
         self.out_headers["Last-Modified"] = file_lastmod
         self.out_headers.update(NO_CACHE)
@@ -3878,7 +4031,7 @@ class HttpCli(object):
         zs = template.render(**targs).encode("utf-8", "replace")
         html = zs.split(boundary.encode("utf-8"))
         if len(html) != 2:
-            raise Exception("boundary appears in " + html_path)
+            raise Exception("boundary appears in " + tpl)
 
         self.send_headers(sz_md + len(html[0]) + len(html[1]), status)
 
@@ -3968,7 +4121,7 @@ class HttpCli(object):
                     erd = quotep(rd)
                     rds = rd.replace("/", " / ")
                     spd = humansize(sz * fdone / td, True) + "/s"
-                    eta = s2hms((td / fdone) - td, True)
+                    eta = s2hms((td / fdone) - td, True) if rem < 1 else "--"
                     idle = s2hms(now - poke, True)
                     ups.append((int(100 * fdone), spd, eta, idle, erd, rds, fn))
             except Exception as ex:
@@ -3983,6 +4136,7 @@ class HttpCli(object):
                 "dbwt": None,
             }
 
+
         fmt = self.uparam.get("ls", "")
         if not fmt and (self.ua.startswith("curl/") or self.ua.startswith("fetch")):
             fmt = "v"
@@ -4362,9 +4516,6 @@ class HttpCli(object):
         if self.uname != self.args.shr_adm:
             rows = [x for x in rows if x[5] == self.uname]
 
-        for x in rows:
-            x[1] = "yes" if x[1] else ""
-
         html = self.j2s(
             "shares", this=self, shr=self.args.shr, rows=rows, now=int(time.time())
         )
@@ -4442,7 +4593,7 @@ class HttpCli(object):
         else:
             for zs in vps:
                 if zs.endswith("/"):
-                    t = "you cannot select more than one folder, or mix flies and folders in one selection"
+                    t = "you cannot select more than one folder, or mix files and folders in one selection"
                     raise Pebkac(400, t)
             vp = vps[0].rsplit("/", 1)[0]
             for zs in vps:
@@ -4985,6 +5136,9 @@ class HttpCli(object):
         for k in ["zip", "tar"]:
             v = self.uparam.get(k)
             if v is not None and (not add_og or not og_fn):
+                if is_dk and "dks" not in vn.flags:
+                    t = "server config does not allow download-as-zip/tar; only dk is specified, need dks too"
+                    raise Pebkac(403, t)
                 return self.tx_zip(k, v, self.vpath, vn, rem, [])
 
         fsroot, vfs_ls, vfs_virt = vn.ls(
@@ -5019,14 +5173,14 @@ class HttpCli(object):
         except:
             pass
 
+        lnames = {x.lower(): x for x in ls_names}
+
         # show dotfiles if permitted and requested
         if not self.can_dot or (
             "dots" not in self.uparam and (is_ls or "dots" not in self.cookies)
         ):
             ls_names = exclude_dotfiles(ls_names)
 
-        lnames = {x.lower(): x for x in ls_names}
-
         add_dk = vf.get("dk")
         add_fk = vf.get("fk")
         fk_alg = 2 if "fka" in vf else 1
@@ -5360,6 +5514,8 @@ class HttpCli(object):
                 fmt = vn.flags.get("og_th", "j")
                 th_base = ujoin(url_base, quotep(thumb))
                 query = "th=%s&cache" % (fmt,)
+                if use_filekey:
+                    query += "&k=" + self.uparam["k"]
                 query = ub64enc(query.encode("utf-8")).decode("ascii")
                 # discord looks at file extension, not content-type...
                 query += "/th.jpg" if "j" in fmt else "/th.webp"
@@ -5369,7 +5525,10 @@ class HttpCli(object):
             j2a["og_file"] = file
             if og_fn:
                 og_fn_q = quotep(og_fn)
-                query = ub64enc(b"raw").decode("ascii")
+                query = "raw"
+                if use_filekey:
+                    query += "&k=" + self.uparam["k"]
+                query = ub64enc(query.encode("utf-8")).decode("ascii")
                 query += "/%s" % (og_fn_q,)
                 j2a["og_url"] = ujoin(url_base, og_fn_q)
                 j2a["og_raw"] = j2a["og_url"] + "/.uqe/" + query

copyparty/httpconn.py

@@ -100,9 +100,6 @@ class HttpConn(object):
         self.log_src = ("%s \033[%dm%d" % (ip, color, self.addr[1])).ljust(26)
         return self.log_src
 
-    def respath(self, res_name )  :
-        return os.path.join(self.E.mod, "web", res_name)
-
     def log(self, msg , c   = 0)  :
         self.log_func(self.log_src, msg, c)
 

copyparty/httpsrv.py

@@ -66,9 +66,10 @@ from .util import (
     Magician,
     Netdev,
     NetMap,
-    absreal,
     build_netmap,
+    has_resource,
     ipnorm,
+    load_resource,
     min_ex,
     shut_socket,
     spack,
@@ -88,6 +89,11 @@ if not hasattr(socket, "AF_UNIX"):
     setattr(socket, "AF_UNIX", -9001)
 
 
+def load_jinja2_resource(E , name ):
+    with load_resource(E, "web/" + name, "r") as f:
+        return f.read()
+
+
 class HttpSrv(object):
     """
     handles incoming connections using HttpConn to process http,
@@ -150,7 +156,7 @@ class HttpSrv(object):
         self.u2idx_n = 0
 
         env = jinja2.Environment()
-        env.loader = jinja2.FileSystemLoader(os.path.join(self.E.mod, "web"))
+        env.loader = jinja2.FunctionLoader(lambda f: load_jinja2_resource(self.E, f))
         jn = [
             "splash",
             "shares",
@@ -163,18 +169,15 @@ class HttpSrv(object):
             "cf",
         ]
         self.j2 = {x: env.get_template(x + ".html") for x in jn}
-        zs = os.path.join(self.E.mod, "web", "deps", "prism.js.gz")
-        self.prism = os.path.exists(zs)
+        self.prism = has_resource(self.E, "web/deps/prism.js.gz")
 
         self.ipa_nm = build_netmap(self.args.ipa)
         self.xff_nm = build_netmap(self.args.xff_src)
         self.xff_lan = build_netmap("lan")
 
-        self.statics  = set()
-        self._build_statics()
-
         self.ptn_cc = re.compile(r"[\x00-\x1f]")
         self.ptn_hsafe = re.compile(r"[\x00-\x1f<>\"'&]")
+        self.uparam_cc_ok = set("doc move tree".split())
 
         self.mallow = "GET HEAD POST PUT DELETE OPTIONS".split()
         if not self.args.no_dav:
@@ -206,14 +209,6 @@ class HttpSrv(object):
         except:
             pass
 
-    def _build_statics(self)  :
-        for dp, _, df in os.walk(os.path.join(self.E.mod, "web")):
-            for fn in df:
-                ap = absreal(os.path.join(dp, fn))
-                self.statics.add(ap)
-                if ap.endswith(".gz"):
-                    self.statics.add(ap[:-3])
-
     def set_netdevs(self, netdevs  )  :
         ips = set()
         for ip, _ in self.bound:

copyparty/metrics.py

@@ -88,7 +88,7 @@ class Metrics(object):
         addg("cpp_total_bans", str(self.hsrv.nban), t)
 
         if not args.nos_vst:
-            x = self.hsrv.broker.ask("up2k.get_state")
+            x = self.hsrv.broker.ask("up2k.get_state", True, "")
             vs = json.loads(x.get())
 
             nvidle = 0

copyparty/smbd.py

@@ -12,7 +12,7 @@ from types import SimpleNamespace
 from .__init__ import ANYWIN, EXE, TYPE_CHECKING
 from .authsrv import LEELOO_DALLAS, VFS
 from .bos import bos
-from .util import Daemon, min_ex, pybin, runhook
+from .util import Daemon, absreal, min_ex, pybin, runhook, vjoin
 
 if TYPE_CHECKING:
     from .svchub import SvcHub
@@ -148,6 +148,8 @@ class SMB(object):
     def _uname(self)  :
         if self.noacc:
             return LEELOO_DALLAS
+        if not self.asrv.acct:
+            return "*"
 
         try:
             # you found it! my single worst bit of code so far
@@ -186,7 +188,7 @@ class SMB(object):
         vfs, rem = self.asrv.vfs.get(vpath, uname, *perms)
         if not vfs.realpath:
             raise Exception("unmapped vfs")
-        return vfs, vfs.canonical(rem)
+        return vfs, vjoin(vfs.realpath, rem)
 
     def _listdir(self, vpath , *a , **ka )  :
         vpath = vpath.replace("\\", "/").lstrip("/")
@@ -210,7 +212,7 @@ class SMB(object):
         sz = 112 * 2  # ['.', '..']
         for n, fn in enumerate(ls):
             if sz >= 64000:
-                t = "listing only %d of %d files (%d byte) in /%s; see impacket#1433"
+                t = "listing only %d of %d files (%d byte) in /%s for performance; see --smb-nwa-1"
                 warning(t, n, len(ls), sz, vpath)
                 break
 
@@ -239,6 +241,7 @@ class SMB(object):
                 t = "blocked write (no-write-acc %s): /%s @%s"
                 yeet(t % (vfs.axs.uwrite, vpath, uname))
 
+            ap = absreal(ap)
             xbu = vfs.flags.get("xbu")
             if xbu and not runhook(
                 self.nlog,

copyparty/stolen/qrcodegen.py

@@ -589,3 +589,20 @@ def _get_bit(x , i )  :
 
 class DataTooLongError(ValueError):
     pass
+
+
+def qr2svg(qr , border )  :
+    parts  = []
+    for y in range(qr.size):
+        sy = border + y
+        for x in range(qr.size):
+            if qr.modules[y][x]:
+                parts.append("M%d,%dh1v1h-1z" % (border + x, sy))
+    t = """\
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 {0} {0}" stroke="none">
+<rect width="100%" height="100%" fill="#F7F7F7"/>
+<path d="{1}" fill="#111111"/>
+</svg>
+"""
+    return t.format(qr.size + border * 2, " ".join(parts))