Enable path validation for copy, rename, debugwalk and other canonpath users.

This fixed the last bit of issue134.
Added some tests to test-rename and test-walk.

mercurial/util.py

@@ -1,800 +1,802 b''
 """
 util.py - Mercurial utility functions and platform specfic implementations
 
  Copyright 2005 K. Thananchayan <[e-mail]>
 
 This software may be used and distributed according to the terms
 of the GNU General Public License, incorporated herein by reference.
 
 This contains helper routines that are independent of the SCM core and hide
 platform-specific details from the core.
 """
 
 import os, errno
 from i18n import gettext as _
 from demandload import *
 demandload(globals(), "cStringIO errno popen2 re shutil sys tempfile")
 demandload(globals(), "threading time")
 
 def pipefilter(s, cmd):
     '''filter string S through command CMD, returning its output'''
     (pout, pin) = popen2.popen2(cmd, -1, 'b')
     def writer():
         pin.write(s)
         pin.close()
 
     # we should use select instead on UNIX, but this will work on most
     # systems, including Windows
     w = threading.Thread(target=writer)
     w.start()
     f = pout.read()
     pout.close()
     w.join()
     return f
 
 def tempfilter(s, cmd):
     '''filter string S through a pair of temporary files with CMD.
     CMD is used as a template to create the real command to be run,
     with the strings INFILE and OUTFILE replaced by the real names of
     the temporary files generated.'''
     inname, outname = None, None
     try:
         infd, inname = tempfile.mkstemp(prefix='hgfin')
         fp = os.fdopen(infd, 'wb')
         fp.write(s)
         fp.close()
         outfd, outname = tempfile.mkstemp(prefix='hgfout')
         os.close(outfd)
         cmd = cmd.replace('INFILE', inname)
         cmd = cmd.replace('OUTFILE', outname)
         code = os.system(cmd)
         if code: raise Abort(_("command '%s' failed: %s") %
                              (cmd, explain_exit(code)))
         return open(outname, 'rb').read()
     finally:
         try:
             if inname: os.unlink(inname)
         except: pass
         try:
             if outname: os.unlink(outname)
         except: pass
 
 filtertable = {
     'tempfile:': tempfilter,
     'pipe:': pipefilter,
     }
 
 def filter(s, cmd):
     "filter a string through a command that transforms its input to its output"
     for name, fn in filtertable.iteritems():
         if cmd.startswith(name):
             return fn(s, cmd[len(name):].lstrip())
     return pipefilter(s, cmd)
 
 def patch(strip, patchname, ui):
     """apply the patch <patchname> to the working directory.
     a list of patched files is returned"""
     fp = os.popen('patch -p%d < "%s"' % (strip, patchname))
     files = {}
     for line in fp:
         line = line.rstrip()
         ui.status("%s\n" % line)
         if line.startswith('patching file '):
             pf = parse_patch_output(line)
             files.setdefault(pf, 1)
     code = fp.close()
     if code:
         raise Abort(_("patch command failed: %s") % explain_exit(code)[0])
     return files.keys()
 
 def binary(s):
     """return true if a string is binary data using diff's heuristic"""
     if s and '\0' in s[:4096]:
         return True
     return False
 
 def unique(g):
     """return the uniq elements of iterable g"""
     seen = {}
     for f in g:
         if f not in seen:
             seen[f] = 1
             yield f
 
 class Abort(Exception):
     """Raised if a command needs to print an error and exit."""
 
 def always(fn): return True
 def never(fn): return False
 
 def patkind(name, dflt_pat='glob'):
     """Split a string into an optional pattern kind prefix and the
     actual pattern."""
     for prefix in 're', 'glob', 'path', 'relglob', 'relpath', 'relre':
         if name.startswith(prefix + ':'): return name.split(':', 1)
     return dflt_pat, name
 
 def globre(pat, head='^', tail='$'):
     "convert a glob pattern into a regexp"
     i, n = 0, len(pat)
     res = ''
     group = False
     def peek(): return i < n and pat[i]
     while i < n:
         c = pat[i]
         i = i+1
         if c == '*':
             if peek() == '*':
                 i += 1
                 res += '.*'
             else:
                 res += '[^/]*'
         elif c == '?':
             res += '.'
         elif c == '[':
             j = i
             if j < n and pat[j] in '!]':
                 j += 1
             while j < n and pat[j] != ']':
                 j += 1
             if j >= n:
                 res += '\\['
             else:
                 stuff = pat[i:j].replace('\\','\\\\')
                 i = j + 1
                 if stuff[0] == '!':
                     stuff = '^' + stuff[1:]
                 elif stuff[0] == '^':
                     stuff = '\\' + stuff
                 res = '%s[%s]' % (res, stuff)
         elif c == '{':
             group = True
             res += '(?:'
         elif c == '}' and group:
             res += ')'
             group = False
         elif c == ',' and group:
             res += '|'
         else:
             res += re.escape(c)
     return head + res + tail
 
 _globchars = {'[': 1, '{': 1, '*': 1, '?': 1}
 
 def pathto(n1, n2):
     '''return the relative path from one place to another.
     this returns a path in the form used by the local filesystem, not hg.'''
     if not n1: return localpath(n2)
     a, b = n1.split('/'), n2.split('/')
     a.reverse()
     b.reverse()
     while a and b and a[-1] == b[-1]:
         a.pop()
         b.pop()
     b.reverse()
     return os.sep.join((['..'] * len(a)) + b)
 
 def canonpath(root, cwd, myname):
     """return the canonical path of myname, given cwd and root"""
     if root == os.sep:
         rootsep = os.sep
     else:
         rootsep = root + os.sep
     name = myname
     if not name.startswith(os.sep):
         name = os.path.join(root, cwd, name)
     name = os.path.normpath(name)
     if name.startswith(rootsep):
-        return pconvert(name[len(rootsep):])
+        name = name[len(rootsep):]
+        audit_path(name)
+        return pconvert(name)
     elif name == root:
         return ''
     else:
         raise Abort('%s not under root' % myname)
 
 def matcher(canonroot, cwd='', names=['.'], inc=[], exc=[], head='', src=None):
     return _matcher(canonroot, cwd, names, inc, exc, head, 'glob', src)
 
 def cmdmatcher(canonroot, cwd='', names=['.'], inc=[], exc=[], head='', src=None):
     if os.name == 'nt':
         dflt_pat = 'glob'
     else:
         dflt_pat = 'relpath'
     return _matcher(canonroot, cwd, names, inc, exc, head, dflt_pat, src)
 
 def _matcher(canonroot, cwd, names, inc, exc, head, dflt_pat, src):
     """build a function to match a set of file patterns
 
     arguments:
     canonroot - the canonical root of the tree you're matching against
     cwd - the current working directory, if relevant
     names - patterns to find
     inc - patterns to include
     exc - patterns to exclude
     head - a regex to prepend to patterns to control whether a match is rooted
 
     a pattern is one of:
     'glob:<rooted glob>'
     're:<rooted regexp>'
     'path:<rooted path>'
     'relglob:<relative glob>'
     'relpath:<relative path>'
     'relre:<relative regexp>'
     '<rooted path or regexp>'
 
     returns:
     a 3-tuple containing
     - list of explicit non-pattern names passed in
     - a bool match(filename) function
     - a bool indicating if any patterns were passed in
 
     todo:
     make head regex a rooted bool
     """
 
     def contains_glob(name):
         for c in name:
             if c in _globchars: return True
         return False
 
     def regex(kind, name, tail):
         '''convert a pattern into a regular expression'''
         if kind == 're':
             return name
         elif kind == 'path':
             return '^' + re.escape(name) + '(?:/|$)'
         elif kind == 'relglob':
             return head + globre(name, '(?:|.*/)', tail)
         elif kind == 'relpath':
             return head + re.escape(name) + tail
         elif kind == 'relre':
             if name.startswith('^'):
                 return name
             return '.*' + name
         return head + globre(name, '', tail)
 
     def matchfn(pats, tail):
         """build a matching function from a set of patterns"""
         if not pats:
             return
         matches = []
         for k, p in pats:
             try:
                 pat = '(?:%s)' % regex(k, p, tail)
                 matches.append(re.compile(pat).match)
             except re.error:
                 if src: raise Abort("%s: invalid pattern (%s): %s" % (src, k, p))
                 else: raise Abort("invalid pattern (%s): %s" % (k, p))
 
         def buildfn(text):
             for m in matches:
                 r = m(text)
                 if r:
                     return r
 
         return buildfn
 
     def globprefix(pat):
         '''return the non-glob prefix of a path, e.g. foo/* -> foo'''
         root = []
         for p in pat.split(os.sep):
             if contains_glob(p): break
             root.append(p)
         return '/'.join(root)
 
     pats = []
     files = []
     roots = []
     for kind, name in [patkind(p, dflt_pat) for p in names]:
         if kind in ('glob', 'relpath'):
             name = canonpath(canonroot, cwd, name)
             if name == '':
                 kind, name = 'glob', '**'
         if kind in ('glob', 'path', 're'):
             pats.append((kind, name))
         if kind == 'glob':
             root = globprefix(name)
             if root: roots.append(root)
         elif kind == 'relpath':
             files.append((kind, name))
             roots.append(name)
 
     patmatch = matchfn(pats, '$') or always
     filematch = matchfn(files, '(?:/|$)') or always
     incmatch = always
     if inc:
         incmatch = matchfn(map(patkind, inc), '(?:/|$)')
     excmatch = lambda fn: False
     if exc:
         excmatch = matchfn(map(patkind, exc), '(?:/|$)')
 
     return (roots,
             lambda fn: (incmatch(fn) and not excmatch(fn) and
                         (fn.endswith('/') or
                          (not pats and not files) or
                          (pats and patmatch(fn)) or
                          (files and filematch(fn)))),
             (inc or exc or (pats and pats != [('glob', '**')])) and True)
 
 def system(cmd, environ={}, cwd=None, onerr=None, errprefix=None):
     '''enhanced shell command execution.
     run with environment maybe modified, maybe in different dir.
 
     if command fails and onerr is None, return status.  if ui object,
     print error message and return status, else raise onerr object as
     exception.'''
     oldenv = {}
     for k in environ:
         oldenv[k] = os.environ.get(k)
     if cwd is not None:
         oldcwd = os.getcwd()
     try:
         for k, v in environ.iteritems():
             os.environ[k] = str(v)
         if cwd is not None and oldcwd != cwd:
             os.chdir(cwd)
         rc = os.system(cmd)
         if rc and onerr:
             errmsg = '%s %s' % (os.path.basename(cmd.split(None, 1)[0]),
                                 explain_exit(rc)[0])
             if errprefix:
                 errmsg = '%s: %s' % (errprefix, errmsg)
             try:
                 onerr.warn(errmsg + '\n')
             except AttributeError:
                 raise onerr(errmsg)
         return rc
     finally:
         for k, v in oldenv.iteritems():
             if v is None:
                 del os.environ[k]
             else:
                 os.environ[k] = v
         if cwd is not None and oldcwd != cwd:
             os.chdir(oldcwd)
 
 def rename(src, dst):
     """forcibly rename a file"""
     try:
         os.rename(src, dst)
     except:
         os.unlink(dst)
         os.rename(src, dst)
 
 def unlink(f):
     """unlink and remove the directory if it is empty"""
     os.unlink(f)
     # try removing directories that might now be empty
     try: os.removedirs(os.path.dirname(f))
     except: pass
 
 def copyfiles(src, dst, hardlink=None):
     """Copy a directory tree using hardlinks if possible"""
 
     if hardlink is None:
         hardlink = (os.stat(src).st_dev ==
                     os.stat(os.path.dirname(dst)).st_dev)
 
     if os.path.isdir(src):
         os.mkdir(dst)
         for name in os.listdir(src):
             srcname = os.path.join(src, name)
             dstname = os.path.join(dst, name)
             copyfiles(srcname, dstname, hardlink)
     else:
         if hardlink:
             try:
                 os_link(src, dst)
             except:
                 hardlink = False
                 shutil.copy(src, dst)
         else:
             shutil.copy(src, dst)
 
 def audit_path(path):
     """Abort if path contains dangerous components"""
     parts = os.path.normcase(path).split(os.sep)
     if (os.path.splitdrive(path)[0] or parts[0] in ('.hg', '')
         or os.pardir in parts):
         raise Abort(_("path contains illegal component: %s\n") % path)
 
 def opener(base, audit=True):
     """
     return a function that opens files relative to base
 
     this function is used to hide the details of COW semantics and
     remote file access from higher level code.
     """
     p = base
     audit_p = audit
 
     def mktempcopy(name):
         d, fn = os.path.split(name)
         fd, temp = tempfile.mkstemp(prefix=fn, dir=d)
         fp = os.fdopen(fd, "wb")
         try:
             fp.write(file(name, "rb").read())
         except:
             try: os.unlink(temp)
             except: pass
             raise
         fp.close()
         st = os.lstat(name)
         os.chmod(temp, st.st_mode)
         return temp
 
     class atomicfile(file):
         """the file will only be copied on close"""
         def __init__(self, name, mode, atomic=False):
             self.__name = name
             self.temp = mktempcopy(name)
             file.__init__(self, self.temp, mode)
         def close(self):
             if not self.closed:
                 file.close(self)
                 rename(self.temp, self.__name)
         def __del__(self):
             self.close()
 
     def o(path, mode="r", text=False, atomic=False):
         if audit_p:
             audit_path(path)
         f = os.path.join(p, path)
 
         if not text:
             mode += "b" # for that other OS
 
         if mode[0] != "r":
             try:
                 nlink = nlinks(f)
             except OSError:
                 d = os.path.dirname(f)
                 if not os.path.isdir(d):
                     os.makedirs(d)
             else:
                 if atomic:
                     return atomicfile(f, mode)
                 if nlink > 1:
                     rename(mktempcopy(f), f)
         return file(f, mode)
 
     return o
 
 def _makelock_file(info, pathname):
     ld = os.open(pathname, os.O_CREAT | os.O_WRONLY | os.O_EXCL)
     os.write(ld, info)
     os.close(ld)
 
 def _readlock_file(pathname):
     return file(pathname).read()
 
 def nlinks(pathname):
     """Return number of hardlinks for the given file."""
     return os.stat(pathname).st_nlink
 
 if hasattr(os, 'link'):
     os_link = os.link
 else:
     def os_link(src, dst):
         raise OSError(0, _("Hardlinks not supported"))
 
 # Platform specific variants
 if os.name == 'nt':
     demandload(globals(), "msvcrt")
     nulldev = 'NUL:'
 
     class winstdout:
         '''stdout on windows misbehaves if sent through a pipe'''
 
         def __init__(self, fp):
             self.fp = fp
 
         def __getattr__(self, key):
             return getattr(self.fp, key)
 
         def close(self):
             try:
                 self.fp.close()
             except: pass
 
         def write(self, s):
             try:
                 return self.fp.write(s)
             except IOError, inst:
                 if inst.errno != 0: raise
                 self.close()
                 raise IOError(errno.EPIPE, 'Broken pipe')
 
     sys.stdout = winstdout(sys.stdout)
 
     def os_rcpath():
         '''return default os-specific hgrc search path'''
         try:
             import win32api, win32process
             proc = win32api.GetCurrentProcess()
             filename = win32process.GetModuleFileNameEx(proc, 0)
             systemrc = os.path.join(os.path.dirname(filename), 'mercurial.ini')
         except ImportError:
             systemrc = r'c:\mercurial\mercurial.ini'
 
         return [systemrc,
                 os.path.join(os.path.expanduser('~'), 'mercurial.ini')]
 
     def parse_patch_output(output_line):
         """parses the output produced by patch and returns the file name"""
         pf = output_line[14:]
         if pf[0] == '`':
             pf = pf[1:-1] # Remove the quotes
         return pf
 
     try: # ActivePython can create hard links using win32file module
         import win32api, win32con, win32file
 
         def os_link(src, dst): # NB will only succeed on NTFS
             win32file.CreateHardLink(dst, src)
 
         def nlinks(pathname):
             """Return number of hardlinks for the given file."""
             try:
                 fh = win32file.CreateFile(pathname,
                     win32file.GENERIC_READ, win32file.FILE_SHARE_READ,
                     None, win32file.OPEN_EXISTING, 0, None)
                 res = win32file.GetFileInformationByHandle(fh)
                 fh.Close()
                 return res[7]
             except:
                 return os.stat(pathname).st_nlink
 
         def testpid(pid):
             '''return False if pid is dead, True if running or not known'''
             try:
                 win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
                                      False, pid)
             except:
                 return True
 
     except ImportError:
         def testpid(pid):
             '''return False if pid dead, True if running or not known'''
             return True
 
     def is_exec(f, last):
         return last
 
     def set_exec(f, mode):
         pass
 
     def set_binary(fd):
         msvcrt.setmode(fd.fileno(), os.O_BINARY)
 
     def pconvert(path):
         return path.replace("\\", "/")
 
     def localpath(path):
         return path.replace('/', '\\')
 
     def normpath(path):
         return pconvert(os.path.normpath(path))
 
     makelock = _makelock_file
     readlock = _readlock_file
 
     def explain_exit(code):
         return _("exited with status %d") % code, code
 
 else:
     nulldev = '/dev/null'
 
     def rcfiles(path):
         rcs = [os.path.join(path, 'hgrc')]
         rcdir = os.path.join(path, 'hgrc.d')
         try:
             rcs.extend([os.path.join(rcdir, f) for f in os.listdir(rcdir)
                         if f.endswith(".rc")])
         except OSError, inst: pass
         return rcs
 
     def os_rcpath():
         '''return default os-specific hgrc search path'''
         path = []
         if len(sys.argv) > 0:
             path.extend(rcfiles(os.path.dirname(sys.argv[0]) +
                                   '/../etc/mercurial'))
         path.extend(rcfiles('/etc/mercurial'))
         path.append(os.path.expanduser('~/.hgrc'))
         path = [os.path.normpath(f) for f in path]
         return path
 
     def parse_patch_output(output_line):
         """parses the output produced by patch and returns the file name"""
         pf = output_line[14:]
         if pf.startswith("'") and pf.endswith("'") and pf.find(" ") >= 0:
             pf = pf[1:-1] # Remove the quotes
         return pf
 
     def is_exec(f, last):
         """check whether a file is executable"""
         return (os.stat(f).st_mode & 0100 != 0)
 
     def set_exec(f, mode):
         s = os.stat(f).st_mode
         if (s & 0100 != 0) == mode:
             return
         if mode:
             # Turn on +x for every +r bit when making a file executable
             # and obey umask.
             umask = os.umask(0)
             os.umask(umask)
             os.chmod(f, s | (s & 0444) >> 2 & ~umask)
         else:
             os.chmod(f, s & 0666)
 
     def set_binary(fd):
         pass
 
     def pconvert(path):
         return path
 
     def localpath(path):
         return path
 
     normpath = os.path.normpath
 
     def makelock(info, pathname):
         try:
             os.symlink(info, pathname)
         except OSError, why:
             if why.errno == errno.EEXIST:
                 raise
             else:
                 _makelock_file(info, pathname)
 
     def readlock(pathname):
         try:
             return os.readlink(pathname)
         except OSError, why:
             if why.errno == errno.EINVAL:
                 return _readlock_file(pathname)
             else:
                 raise
 
     def testpid(pid):
         '''return False if pid dead, True if running or not sure'''
         try:
             os.kill(pid, 0)
             return True
         except OSError, inst:
             return inst.errno != errno.ESRCH
 
     def explain_exit(code):
         """return a 2-tuple (desc, code) describing a process's status"""
         if os.WIFEXITED(code):
             val = os.WEXITSTATUS(code)
             return _("exited with status %d") % val, val
         elif os.WIFSIGNALED(code):
             val = os.WTERMSIG(code)
             return _("killed by signal %d") % val, val
         elif os.WIFSTOPPED(code):
             val = os.WSTOPSIG(code)
             return _("stopped by signal %d") % val, val
         raise ValueError(_("invalid exit code"))
 
 class chunkbuffer(object):
     """Allow arbitrary sized chunks of data to be efficiently read from an
     iterator over chunks of arbitrary size."""
 
     def __init__(self, in_iter, targetsize = 2**16):
         """in_iter is the iterator that's iterating over the input chunks.
         targetsize is how big a buffer to try to maintain."""
         self.in_iter = iter(in_iter)
         self.buf = ''
         self.targetsize = int(targetsize)
         if self.targetsize <= 0:
             raise ValueError(_("targetsize must be greater than 0, was %d") %
                              targetsize)
         self.iterempty = False
 
     def fillbuf(self):
         """Ignore target size; read every chunk from iterator until empty."""
         if not self.iterempty:
             collector = cStringIO.StringIO()
             collector.write(self.buf)
             for ch in self.in_iter:
                 collector.write(ch)
             self.buf = collector.getvalue()
             self.iterempty = True
 
     def read(self, l):
         """Read L bytes of data from the iterator of chunks of data.
         Returns less than L bytes if the iterator runs dry."""
         if l > len(self.buf) and not self.iterempty:
             # Clamp to a multiple of self.targetsize
             targetsize = self.targetsize * ((l // self.targetsize) + 1)
             collector = cStringIO.StringIO()
             collector.write(self.buf)
             collected = len(self.buf)
             for chunk in self.in_iter:
                 collector.write(chunk)
                 collected += len(chunk)
                 if collected >= targetsize:
                     break
             if collected < targetsize:
                 self.iterempty = True
             self.buf = collector.getvalue()
         s, self.buf = self.buf[:l], buffer(self.buf, l)
         return s
 
 def filechunkiter(f, size = 65536):
     """Create a generator that produces all the data in the file size
     (default 65536) bytes at a time.  Chunks may be less than size
     bytes if the chunk is the last chunk in the file, or the file is a
     socket or some other type of file that sometimes reads less data
     than is requested."""
     s = f.read(size)
     while len(s) > 0:
         yield s
         s = f.read(size)
 
 def makedate():
     lt = time.localtime()
     if lt[8] == 1 and time.daylight:
         tz = time.altzone
     else:
         tz = time.timezone
     return time.mktime(lt), tz
 
 def datestr(date=None, format='%a %b %d %H:%M:%S %Y'):
     """represent a (unixtime, offset) tuple as a localized time.
     unixtime is seconds since the epoch, and offset is the time zone's
     number of seconds away from UTC."""
     t, tz = date or makedate()
     return ("%s %+03d%02d" %
             (time.strftime(format, time.gmtime(float(t) - tz)),
              -tz / 3600,
              ((-tz % 3600) / 60)))
 
 def shortuser(user):
     """Return a short representation of a user name or email address."""
     f = user.find('@')
     if f >= 0:
         user = user[:f]
     f = user.find('<')
     if f >= 0:
         user = user[f+1:]
     return user
 
 def walkrepos(path):
     '''yield every hg repository under path, recursively.'''
     def errhandler(err):
         if err.filename == path:
             raise err
 
     for root, dirs, files in os.walk(path, onerror=errhandler):
         for d in dirs:
             if d == '.hg':
                 yield root
                 dirs[:] = []
                 break
 
 _rcpath = None
 
 def rcpath():
     '''return hgrc search path. if env var HGRCPATH is set, use it.
     for each item in path, if directory, use files ending in .rc,
     else use item.
     make HGRCPATH empty to only look in .hg/hgrc of current repo.
     if no HGRCPATH, use default os-specific path.'''
     global _rcpath
     if _rcpath is None:
         if 'HGRCPATH' in os.environ:
             _rcpath = []
             for p in os.environ['HGRCPATH'].split(os.pathsep):
                 if not p: continue
                 if os.path.isdir(p):
                     for f in os.listdir(p):
                         if f.endswith('.rc'):
                             _rcpath.append(os.path.join(p, f))
                 else:
                     _rcpath.append(p)
         else:
             _rcpath = os_rcpath()
     return _rcpath

tests/test-rename

@@ -1,181 +1,211 b''
 #!/bin/sh
 
 hg init
 mkdir d1 d1/d11 d2
 echo d1/a > d1/a
 echo d1/ba > d1/ba
 echo d1/a1 > d1/d11/a1
 echo d1/b > d1/b
 echo d2/b > d2/b
 hg add d1/a d1/b d1/ba d1/d11/a1 d2/b
 hg commit -m "1" -d "1000000 0"
 
 echo "# rename a single file"
 hg rename d1/d11/a1 d2/c
 hg status
 hg update -C
 
 echo "# rename --after a single file"
 mv d1/d11/a1 d2/c
 hg rename --after d1/d11/a1 d2/c
 hg status
 hg update -C
 
 echo "# move a single file to an existing directory"
 hg rename d1/d11/a1 d2
 hg status
 hg update -C
 
 echo "# move --after a single file to an existing directory"
 mv d1/d11/a1 d2
 hg rename --after d1/d11/a1 d2
 hg status
 hg update -C
 
 echo "# rename a file using a relative path"
 (cd d1/d11; hg rename ../../d2/b e)
 hg status
 hg update -C
 
 echo "# rename --after a file using a relative path"
 (cd d1/d11; mv ../../d2/b e; hg rename --after ../../d2/b e)
 hg status
 hg update -C
 
 echo "# rename directory d1 as d3"
 hg rename d1/ d3
 hg status
 hg update -C
 
 echo "# rename --after directory d1 as d3"
 mv d1 d3
 hg rename --after d1 d3
 hg status
 hg update -C
 
 echo "# move a directory using a relative path"
 (cd d2; mkdir d3; hg rename ../d1/d11 d3)
 hg status
 hg update -C
 
 echo "# move --after a directory using a relative path"
 (cd d2; mkdir d3; mv ../d1/d11 d3; hg rename --after ../d1/d11 d3)
 hg status
 hg update -C
 
 echo "# move directory d1/d11 to an existing directory d2 (removes empty d1)"
 hg rename d1/d11/ d2
 hg status
 hg update -C
 
 echo "# move directories d1 and d2 to a new directory d3"
 mkdir d3
 hg rename d1 d2 d3
 hg status
 hg update -C
 
 echo "# move --after directories d1 and d2 to a new directory d3"
 mkdir d3
 mv d1 d2 d3
 hg rename --after d1 d2 d3
 hg status
 hg update -C
 
 echo "# move everything under directory d1 to existing directory d2, do not"
 echo "# overwrite existing files (d2/b)"
 hg rename d1/* d2
 hg status
 diff d1/b d2/b
 hg update -C
 
 echo "# attempt to move potentially more than one file into a non-existent"
 echo "# directory"
 hg rename 'glob:d1/**' dx
 
 echo "# move every file under d1 to d2/d21 (glob)"
 mkdir d2/d21
 hg rename 'glob:d1/**' d2/d21
 hg status
 hg update -C
 
 echo "# move --after some files under d1 to d2/d21 (glob)"
 mkdir d2/d21
 mv d1/a d1/d11/a1 d2/d21
 hg rename --after 'glob:d1/**' d2/d21
 hg status
 hg update -C
 
 echo "# move every file under d1 starting with an 'a' to d2/d21 (regexp)"
 mkdir d2/d21
 hg rename 're:d1/([^a][^/]*/)*a.*' d2/d21
 hg status
 hg update -C
 
 echo "# attempt to overwrite an existing file"
 echo "ca" > d1/ca
 hg rename d1/ba d1/ca
 hg status
 hg update -C
 
 echo "# forced overwrite of an existing file"
 echo "ca" > d1/ca
 hg rename --force d1/ba d1/ca
 hg status
 hg update -C
 
 echo "# replace a symlink with a file"
 ln -s ba d1/ca
 hg rename --force d1/ba d1/ca
 hg status
 hg update -C
 
 echo "# do not copy more than one source file to the same destination file"
 mkdir d3
 hg rename d1/* d2/* d3
 hg status
 hg update -C
 
 echo "# move a whole subtree with \"hg rename .\""
 mkdir d3
 (cd d1; hg rename . ../d3)
 hg status
 hg update -C
 
 echo "# move a whole subtree with \"hg rename --after .\""
 mkdir d3
 mv d1/* d3
 (cd d1; hg rename --after . ../d3)
 hg status
 hg update -C
 
 echo "# move the parent tree with \"hg rename ..\""
 (cd d1/d11; hg rename .. ../../d3)
 hg status
 hg update -C
 
 echo "# skip removed files"
 hg remove d1/b
 hg rename d1 d3
 hg status
 hg update -C
 
 echo "# transitive rename"
 hg rename d1/b d1/bb
 hg rename d1/bb d1/bc
 hg status
 hg update -C
 
 echo "# transitive rename --after"
 hg rename d1/b d1/bb
 mv d1/bb d1/bc
 hg rename --after d1/bb d1/bc
 hg status
 hg update -C
 
 echo "# idempotent renames (d1/b -> d1/bb followed by d1/bb -> d1/b)"
 hg rename d1/b d1/bb
 echo "some stuff added to d1/bb" >> d1/bb
 hg rename d1/bb d1/b
 hg status
 hg debugstate | grep copy
 hg update -C
+
+echo "# check illegal path components"
+
+hg rename d1/d11/a1 .hg/foo
+hg status
+hg rename d1/d11/a1 ../foo
+hg status
+
+mv d1/d11/a1 .hg/foo
+hg rename --after d1/d11/a1 .hg/foo
+hg status
+hg update -C
+rm .hg/foo
+
+hg rename d1/d11/a1 .hg
+hg status
+hg rename d1/d11/a1 ..
+hg status
+
+mv d1/d11/a1 .hg
+hg rename --after d1/d11/a1 .hg
+hg status
+hg update -C
+rm .hg/a1
+
+(cd d1/d11; hg rename ../../d2/b ../../.hg/foo)
+hg status
+(cd d1/d11; hg rename ../../d2/b ../../../foo)
+hg status
+

tests/test-rename.out

@@ -1,256 +1,272 b''
 # rename a single file
 A d2/c
 R d1/d11/a1
 # rename --after a single file
 A d2/c
 R d1/d11/a1
 # move a single file to an existing directory
 A d2/a1
 R d1/d11/a1
 # move --after a single file to an existing directory
 A d2/a1
 R d1/d11/a1
 # rename a file using a relative path
 A d1/d11/e
 R d2/b
 # rename --after a file using a relative path
 A d1/d11/e
 R d2/b
 # rename directory d1 as d3
 copying d1/a to d3/a
 copying d1/b to d3/b
 copying d1/ba to d3/ba
 copying d1/d11/a1 to d3/d11/a1
 removing d1/a
 removing d1/b
 removing d1/ba
 removing d1/d11/a1
 A d3/a
 A d3/b
 A d3/ba
 A d3/d11/a1
 R d1/a
 R d1/b
 R d1/ba
 R d1/d11/a1
 # rename --after directory d1 as d3
 copying d1/a to d3/a
 copying d1/b to d3/b
 copying d1/ba to d3/ba
 copying d1/d11/a1 to d3/d11/a1
 removing d1/a
 removing d1/b
 removing d1/ba
 removing d1/d11/a1
 A d3/a
 A d3/b
 A d3/ba
 A d3/d11/a1
 R d1/a
 R d1/b
 R d1/ba
 R d1/d11/a1
 # move a directory using a relative path
 copying ../d1/d11/a1 to d3/d11/a1
 removing ../d1/d11/a1
 A d2/d3/d11/a1
 R d1/d11/a1
 # move --after a directory using a relative path
 copying ../d1/d11/a1 to d3/d11/a1
 removing ../d1/d11/a1
 A d2/d3/d11/a1
 R d1/d11/a1
 # move directory d1/d11 to an existing directory d2 (removes empty d1)
 copying d1/d11/a1 to d2/d11/a1
 removing d1/d11/a1
 A d2/d11/a1
 R d1/d11/a1
 # move directories d1 and d2 to a new directory d3
 copying d1/a to d3/d1/a
 copying d1/b to d3/d1/b
 copying d1/ba to d3/d1/ba
 copying d1/d11/a1 to d3/d1/d11/a1
 copying d2/b to d3/d2/b
 removing d1/a
 removing d1/b
 removing d1/ba
 removing d1/d11/a1
 removing d2/b
 A d3/d1/a
 A d3/d1/b
 A d3/d1/ba
 A d3/d1/d11/a1
 A d3/d2/b
 R d1/a
 R d1/b
 R d1/ba
 R d1/d11/a1
 R d2/b
 # move --after directories d1 and d2 to a new directory d3
 copying d1/a to d3/d1/a
 copying d1/b to d3/d1/b
 copying d1/ba to d3/d1/ba
 copying d1/d11/a1 to d3/d1/d11/a1
 copying d2/b to d3/d2/b
 removing d1/a
 removing d1/b
 removing d1/ba
 removing d1/d11/a1
 removing d2/b
 A d3/d1/a
 A d3/d1/b
 A d3/d1/ba
 A d3/d1/d11/a1
 A d3/d2/b
 R d1/a
 R d1/b
 R d1/ba
 R d1/d11/a1
 R d2/b
 # move everything under directory d1 to existing directory d2, do not
 # overwrite existing files (d2/b)
 d2/b: not overwriting - file exists
 copying d1/d11/a1 to d2/d11/a1
 removing d1/d11/a1
 A d2/a
 A d2/ba
 A d2/d11/a1
 R d1/a
 R d1/ba
 R d1/d11/a1
 1c1
 < d1/b
 ---
 > d2/b
 # attempt to move potentially more than one file into a non-existent
 # directory
 abort: with multiple sources, destination must be an existing directory
 # move every file under d1 to d2/d21 (glob)
 copying d1/a to d2/d21/a
 copying d1/b to d2/d21/b
 copying d1/ba to d2/d21/ba
 copying d1/d11/a1 to d2/d21/a1
 removing d1/a
 removing d1/b
 removing d1/ba
 removing d1/d11/a1
 A d2/d21/a
 A d2/d21/a1
 A d2/d21/b
 A d2/d21/ba
 R d1/a
 R d1/b
 R d1/ba
 R d1/d11/a1
 # move --after some files under d1 to d2/d21 (glob)
 copying d1/a to d2/d21/a
 copying d1/d11/a1 to d2/d21/a1
 removing d1/a
 removing d1/d11/a1
 A d2/d21/a
 A d2/d21/a1
 R d1/a
 R d1/d11/a1
 # move every file under d1 starting with an 'a' to d2/d21 (regexp)
 copying d1/a to d2/d21/a
 copying d1/d11/a1 to d2/d21/a1
 removing d1/a
 removing d1/d11/a1
 A d2/d21/a
 A d2/d21/a1
 R d1/a
 R d1/d11/a1
 # attempt to overwrite an existing file
 d1/ca: not overwriting - file exists
 ? d1/ca
 # forced overwrite of an existing file
 A d1/ca
 R d1/ba
 # replace a symlink with a file
 A d1/ca
 R d1/ba
 # do not copy more than one source file to the same destination file
 copying d1/d11/a1 to d3/d11/a1
 d3/b: not overwriting - d2/b collides with d1/b
 removing d1/d11/a1
 A d3/a
 A d3/b
 A d3/ba
 A d3/d11/a1
 R d1/a
 R d1/b
 R d1/ba
 R d1/d11/a1
 # move a whole subtree with "hg rename ."
 copying a to ../d3/d1/a
 copying b to ../d3/d1/b
 copying ba to ../d3/d1/ba
 copying d11/a1 to ../d3/d1/d11/a1
 removing a
 removing b
 removing ba
 removing d11/a1
 A d3/d1/a
 A d3/d1/b
 A d3/d1/ba
 A d3/d1/d11/a1
 R d1/a
 R d1/b
 R d1/ba
 R d1/d11/a1
 # move a whole subtree with "hg rename --after ."
 copying a to ../d3/a
 copying b to ../d3/b
 copying ba to ../d3/ba
 copying d11/a1 to ../d3/d11/a1
 removing a
 removing b
 removing ba
 removing d11/a1
 A d3/a
 A d3/b
 A d3/ba
 A d3/d11/a1
 R d1/a
 R d1/b
 R d1/ba
 R d1/d11/a1
 # move the parent tree with "hg rename .."
 copying ../a to ../../d3/a
 copying ../b to ../../d3/b
 copying ../ba to ../../d3/ba
 copying a1 to ../../d3/d11/a1
 removing ../a
 removing ../b
 removing ../ba
 removing a1
 A d3/a
 A d3/b
 A d3/ba
 A d3/d11/a1
 R d1/a
 R d1/b
 R d1/ba
 R d1/d11/a1
 # skip removed files
 copying d1/a to d3/a
 copying d1/ba to d3/ba
 copying d1/d11/a1 to d3/d11/a1
 removing d1/a
 removing d1/ba
 removing d1/d11/a1
 A d3/a
 A d3/ba
 A d3/d11/a1
 R d1/a
 R d1/b
 R d1/ba
 R d1/d11/a1
 # transitive rename
 A d1/bc
 R d1/b
 # transitive rename --after
 A d1/bc
 R d1/b
 # idempotent renames (d1/b -> d1/bb followed by d1/bb -> d1/b)
 M d1/b
+# check illegal path components
+abort: path contains illegal component: .hg/foo
+
+abort: ../foo not under root
+abort: path contains illegal component: .hg/foo
+
+! d1/d11/a1
+abort: path contains illegal component: .hg/a1
+
+abort: ../a1 not under root
+abort: path contains illegal component: .hg/a1
+
+! d1/d11/a1
+abort: path contains illegal component: .hg/foo
+
+abort: ../../../foo not under root

tests/test-walk

@@ -1,55 +1,61 b''
 #!/bin/sh
 
 mkdir t
 cd t
 hg init
 mkdir -p beans
 for b in kidney navy turtle borlotti black pinto; do
     echo $b > beans/$b
 done
 mkdir -p mammals/Procyonidae
 for m in cacomistle coatimundi raccoon; do
     echo $m > mammals/Procyonidae/$m
 done
 echo skunk > mammals/skunk
 echo fennel > fennel
 echo fenugreek > fenugreek
 echo fiddlehead > fiddlehead
 echo glob:glob > glob:glob
 hg addremove
 hg commit -m "commit #0" -d "1000000 0"
 hg debugwalk
 cd mammals
 hg debugwalk .
 hg debugwalk Procyonidae
 cd Procyonidae
 hg debugwalk .
 hg debugwalk ..
 cd ..
 hg debugwalk ../beans
 hg debugwalk .
+hg debugwalk .hg
+hg debugwalk ../.hg
 cd ..
 hg debugwalk -Ibeans
 hg debugwalk 'glob:mammals/../beans/b*'
 hg debugwalk '-X*/Procyonidae' mammals
 hg debugwalk path:mammals
 hg debugwalk ..
 hg debugwalk beans/../..
+hg debugwalk .hg
+hg debugwalk beans/../.hg
+hg debugwalk beans/../.hg/data
+hg debugwalk beans/.hg
 # Don't know how to test absolute paths without always getting a false
 # error.
 #hg debugwalk `pwd`/beans
 #hg debugwalk `pwd`/..
 hg debugwalk glob:\*
 hg debugwalk 're:.*[kb]$'
 hg debugwalk path:beans/black
 hg debugwalk beans 'glob:beans/*'
 hg debugwalk 'glob:j*'
 hg debugwalk NOEXIST
 mkfifo fifo
 hg debugwalk fifo
 rm fenugreek
 hg debugwalk fenugreek
 hg rm fenugreek
 hg debugwalk fenugreek
 touch new
 hg debugwalk new

tests/test-walk.out

@@ -1,87 +1,97 b''
 adding beans/black
 adding beans/borlotti
 adding beans/kidney
 adding beans/navy
 adding beans/pinto
 adding beans/turtle
 adding fennel
 adding fenugreek
 adding fiddlehead
 adding glob:glob
 adding mammals/Procyonidae/cacomistle
 adding mammals/Procyonidae/coatimundi
 adding mammals/Procyonidae/raccoon
 adding mammals/skunk
 f  beans/black                     beans/black
 f  beans/borlotti                  beans/borlotti
 f  beans/kidney                    beans/kidney
 f  beans/navy                      beans/navy
 f  beans/pinto                     beans/pinto
 f  beans/turtle                    beans/turtle
 f  fennel                          fennel
 f  fenugreek                       fenugreek
 f  fiddlehead                      fiddlehead
 f  glob:glob                       glob:glob
 f  mammals/Procyonidae/cacomistle  mammals/Procyonidae/cacomistle
 f  mammals/Procyonidae/coatimundi  mammals/Procyonidae/coatimundi
 f  mammals/Procyonidae/raccoon     mammals/Procyonidae/raccoon
 f  mammals/skunk                   mammals/skunk
 f  mammals/Procyonidae/cacomistle  Procyonidae/cacomistle
 f  mammals/Procyonidae/coatimundi  Procyonidae/coatimundi
 f  mammals/Procyonidae/raccoon     Procyonidae/raccoon
 f  mammals/skunk                   skunk
 f  mammals/Procyonidae/cacomistle  Procyonidae/cacomistle
 f  mammals/Procyonidae/coatimundi  Procyonidae/coatimundi
 f  mammals/Procyonidae/raccoon     Procyonidae/raccoon
 f  mammals/Procyonidae/cacomistle  cacomistle
 f  mammals/Procyonidae/coatimundi  coatimundi
 f  mammals/Procyonidae/raccoon     raccoon
 f  mammals/Procyonidae/cacomistle  cacomistle
 f  mammals/Procyonidae/coatimundi  coatimundi
 f  mammals/Procyonidae/raccoon     raccoon
 f  mammals/skunk                   ../skunk
 f  beans/black     ../beans/black
 f  beans/borlotti  ../beans/borlotti
 f  beans/kidney    ../beans/kidney
 f  beans/navy      ../beans/navy
 f  beans/pinto     ../beans/pinto
 f  beans/turtle    ../beans/turtle
 f  mammals/Procyonidae/cacomistle  Procyonidae/cacomistle
 f  mammals/Procyonidae/coatimundi  Procyonidae/coatimundi
 f  mammals/Procyonidae/raccoon     Procyonidae/raccoon
 f  mammals/skunk                   skunk
+.hg: No such file or directory
+abort: path contains illegal component: .hg
+
 f  beans/black     beans/black
 f  beans/borlotti  beans/borlotti
 f  beans/kidney    beans/kidney
 f  beans/navy      beans/navy
 f  beans/pinto     beans/pinto
 f  beans/turtle    beans/turtle
 f  beans/black     beans/black
 f  beans/borlotti  beans/borlotti
 f  mammals/skunk  mammals/skunk
 f  mammals/Procyonidae/cacomistle  mammals/Procyonidae/cacomistle
 f  mammals/Procyonidae/coatimundi  mammals/Procyonidae/coatimundi
 f  mammals/Procyonidae/raccoon     mammals/Procyonidae/raccoon
 f  mammals/skunk                   mammals/skunk
 abort: .. not under root
 abort: beans/../.. not under root
+abort: path contains illegal component: .hg
+
+abort: path contains illegal component: .hg
+
+abort: path contains illegal component: .hg/data
+
+beans/.hg: No such file or directory
 f  fennel      fennel
 f  fenugreek   fenugreek
 f  fiddlehead  fiddlehead
 f  glob:glob   glob:glob
 f  beans/black    beans/black
 f  fenugreek      fenugreek
 f  glob:glob      glob:glob
 f  mammals/skunk  mammals/skunk
 f  beans/black  beans/black
 f  beans/black     beans/black
 f  beans/borlotti  beans/borlotti
 f  beans/kidney    beans/kidney
 f  beans/navy      beans/navy
 f  beans/pinto     beans/pinto
 f  beans/turtle    beans/turtle
 NOEXIST: No such file or directory
 fifo: unsupported file type (type is fifo)
 m  fenugreek  fenugreek  exact
 m  fenugreek  fenugreek  exact
 f  new  new  exact