Just for completeness: ln.exe can do the normal ln stuff too.

In the above example sourcefile.txt gets hard-linked to destination.txt

In the above example sourcefile.txt gets hard-linked to dest_dir\sourcefile.txt

• a fully qualified path starting at the root of a drive, e.g e:\data\cpp\myfile.txt
• also fully qualified path but pointing to a volume, e.g. \\?\Volume{f6c8b244-1ce4-11e0-a607-005056c00008}\
• or can be be specified relatively, e.g ..\..\data\cpp\myfile.txt

ln.exe by default tries to create relative target path names for symbolic links as long as this is possible, e.g the file and its target are on the same logical drive. Having relative symbolic link targets is much smarter especially when the target of links is in the same directory. If a symbolic link and its target are on different drives, ln.exe uses absolute pathnames.

If the creation of absolute target pathnames should be forced use the --absolute option.

In the above example Sourcefile.txt gets linked to Destination.txt with an absolute target path.

In the above example a symbolic link DestinationDirectory\Sourcefile.txt gets linked to Sourcefile.txt with an absolute target path.

In the above example a symbolic link directory SourceDirectory gets linked to DestinationDirectory with an absolute target path.

In the above example a symbolic link directory DestinationDirectory\SourceDirectory gets linked to SourceDirectory with an absolute target path. A traling backslash is the trigger for this to work.

This option can be used together with other options like --copy and it supplies a virtual path or an anchor to the e.g copy process, so that junctions and absolute symbolic links can be restored properly in the destination even if they would be outer junctions/symbolic link.

• For some unknown reason the system can't be booted from c:\ anymore
• The system is booted from an external media, and your former drive c:\ is now available as e.g. e:\
• The whole drive should be copied from e:\ to y:\ ( Because you put a fresh disc into y:\ )
• Drive y:\ should afterwards replace your old c:\ and you would like to boot from it.
• Most important: All junctions and symbolic links should be alive after this operation.

There are absolute junction/symbolic links in your structure, which point to c:\ but with respect to its new root e:\ all junctions pointing to c:\ are now outer junctions/symbolic link. A normal --copy would simply crop these junctions, which is unwanted, because the whole disk should be recovered as much as possible.

The solution is to broaden the scope for ln.exe to decide if it is an outer or inner junction by supplying additional anchor path to the copy process.

The above example supplies c:\ as additional anchor path and lets ln.exe assume that all junctions and symbolic links below e:\, which point to some places below c:\ are inner junctions, and thus are restored in the destination as junctions/symbolic links pointing to places below c:\ properly.

The option --destination is needed because the inner junctions found on e: shall point to c: even if the destination of this copy operation is y:\

• Mount your drive to be copied to some drive letter, where no junctions point to. In the above example f:\ would be fine
• Use --anchor for each drive where you know junctions from former c:\ point to.

The order of --anchor and --destination in the above example is important: They build kind of pairs.

The full black magic on copying with permissions a whole drive also includes the --backup switch

Adding --backup also copies all permissions, streams and the like. Or you omit --backup and only use --keepsymlinkrelation.

If a system drive should be backuped regularly and data, which have been already copied in the run before, should not be copied, then go for:

If this should be done via snapshots, see Copying a whole drive via snapshots. The above example does not use --destination. This means the inner junctions/symbolic links, which point to c: on the source now in the destination y: point to y:

See also the note on quotes.

Using the Backup Mode ACLs aka Access Control Lists, which contain the security for Files, Folders, Junctions or SymbolicLinks, and Encrypted Files are also copied.

• Alternative Streams on files and folders
• EA Records on files and folders (rarely used)
• Reparse Info
• File Attributes
• Timestamps: Creation Time, Last Access Time, Last Write Time
• Sparse Files and Alternative Sparse Streams
• Encrypted files
• ACLs

The --backup switch is a modifier to all other operations like e.g --copy, --mirror or --delorean.

All files with all the above mentioned attributes are copied from x:\SourcePath to x:\DestinationPath

The --backup mode automatically enables the --keepsymlinkrelation modifier.

Smart Copy basically creates a copy of the directory structure from the source location to the destination, but it preserves the inner hardlink structure and inner junction/symbolic link relations of the source, and recreates this inner hardlink structure and inner junction/symbolic link relation at the destination location:

With hardlinks it behaves as follows:

By closely looking at the above picture one can find three different types of files:

With junctions or symbolic link directories the default behaviour during smartcopy is as follows:

By closely looking at the above picture one can find three different types of folders/junctions:

Symbolic Links to files behave as follows during Smart Copy:

By closely looking at the above picture one can find three different types of files/symbolic links:

e.g.:

In the above example the directories and files below x:\dir\dir2 are copied to y:\dir\newdir, and all hardlinks/junctions/symbolic links within x:\dir\dir2 are copied/tied to their new locations under y:\dir\newdir.

The --copy operation only copies if the files in the destination are either not there, or if the files in the source are newer. Otherwise the item is skipped. See also the note on quotes.

If you use ln.exe as a backup tool with the --copy option, please make sure you test that everything is copied. I tested ln --copy many times, and had no problems, but when it comes to backing up data, one has to be careful.

Smart Copy is a must if e.g. the whole content of a hard disk, which has lots of hardlinks/junctions/symbolic links, should be copied to another hard disk. During the Smart Copy operation empty folders get copied too and the time stamps of folders/junctions/symbolic links are also restored at the corresponding destination locations.

Because Smart Copy creates inner hardlinks/junctions/symbolic links, this feature is only available on NTFS volumes.

Smart Copy also processes all available alternative NTFS streams, EA Records, Sparse Files of a file. To also copy the ACLs, see the Backup Mode

See Output among Delorean Copy for a detailed description of Smart Copies output.

The Copy or Smart Copy functionality is also available via Link Shell Extension

During SmartCopy, Smart Mirror, Delorean Copy and Clone so called Outer Junctions/Symlink directories may need processing. There are 3 different ways to deal with those Outer Junctions/Symlink directories:

Crop	Crop breaks links to Outer Junctions/Symlink directories in the destination. Crop also applies to Outer Symlink Files. In the above example Folder1 is copied to Destination/Folder1, but Outer Junction/Symlink is not available in the destination, because Folder1/Outer Junction/Symlink pointed to Folder0/Outer Junction/Symlink Target, which is not below Folder1. The objective behind cropping Outer Junctions/Symlink Directories is to get a pure copy during Smart Copy, Smart Mirror, Delorean Copy and Clone without connections to the source. Crop is the default behaviour of ln.exe, e.g.: ln --copy "c:\Folder 1" "c:\Destination\Folder 1"
Unroll	Unroll follows Outer Junctions/Symlink Directories and rebuilds the content of Outer Junctions/Symlink Directories inside the hierarchy at the destination location. Unroll also applies to Outer Symlink Files, which means, that unroll causes the target of Outer Symlink Files to be copied to the destination location. In the above example Folder1 is copied to Destination/Folder1, and Outer Junction/Symlink and all the files/directories below Outer Junction/Symlink Target are copied to the folder Outer Junction/Symlink in the destination. The objective behind unrolling Outer Junctions/Symlink Directories is to get everything with which the source is connected and rebuild it as separate copy in the destination. It resembles the 'hair of the elephant' pattern: Pull on a hair of an elephant, and get the whole elephant. The command line invocation below unrolls all junctions/symbolic link directories below "c:\Folder 1" ln --unroll --copy "c:\Folder 1" "c:\Destination\Folder 1" In certain situations only certain junctions/symbolic link directories should be unrolled during SmartCopy, DeloreanCopy, SmartMirror or HardlinkClone. To accomplish this ln.exe can be run with wildcard expressions to specify certain directories for unrolling. ln --unroll "MyJunc*" --copy "c:\Folder 1" "c:\Destination\Folder 1" To specify junctions/symbolic link directories for unrolling more fine grained regular expressions can be given: ln --unrollregexp "[a-z]*" --copy "c:\Folder 1" "c:\Destination\Folder 1" The regular expressions used must conform to POSIX 1003.2 extended RE (ERE) syntax . They are not casesensitiv. The regular expression specified under --unrollregexp is applied to the whole source path: ln --unrollregexp "Folder 1\\MyJunc*" --copy "c:\Folder 1" "c:\Destination\Folder 1" In this example only Outer Junctions/Symbolic Link Directories, matching "Folder 1\\MyJunc*" are unrolled. Please make sure that the back slash \ is escaped by a double \\ as shown in the above example. Advanced thoughts on Unrolling The picture above was just the simplest case, because Unroll does much more when it encounters complex situations. Think of an outer junctions/symbolic links, which itself contains junctions/symbolic links, which are inner with respect to the first outer junction symbolic link: In the above example Folder1 is copied to Destination/Folder1, and Outer Junction/Symlink and is unrolled as expected, but since Junction/Symlink is an inner junction with respect to Outer Junction/Symlink Target, the junction/symlink relation is restored in the destination. This kind of nesting can be much more complex: In the above example Folder1 is copied to Destination/Folder1, and Outer Junction/Symlink and is unrolled as expected, but then it starts to get fascinating, because we have two levels of outer junctions/symlinks which all have respective inner junctions/symlinks, and which are restored properly. Once you have followed through the above picture, you got it. It is not simple I know, but it is necessary to properly unroll. And complexity increases if symbolic link files are within unrolled outer junctions/symbolic links: In the above example Folder1 is copied to Destination/Folder1, and Outer Junction/Symlink and is unrolled as expected, but it contains Inner Outer Symlink which points to Inner Outer Symlink Target and this is an inner junction/symbolic link with respect to Outer Junction/Symlink Target But worth mentioning is the Symbolic Link Outer Symlink, which would be a definitive outer symbolic link, but since its targets parent-directory Outer Junction/Symlink Target is unrolled, Outer Symlink becomes an inner symbolic link with respect to Folder1. File1 Symlink is also an outer symbolic link, but its target parent-directory Folder2 is not that lucky to get unrolled, so in the destination File1 Symlink is not a symbolic link any more, but a copy of the symbolic links' target. Nested Reparse Points are also an interesting use case, which the algorithm has to tackle with: In the above example Folder1 is copied to Destination, and Junction/Symlink F0 and is unrolled as expected, but it contains inner nested reparse points. Nested means Reparse point pointing to Reparse Points The Unroll functionality also opens up the possibility to have circular Junction/Symbolic Link relations among a set of copied items: In the above example Folder1 is copied via the --unroll option to Destination/Folder1. Smart Copy/Smart Mirror and Delorean Copy operations can deal with the above shown circularities and break circularities by not following the affected Junction/Symbolic Link. Junctions/Symbolic Links can also point to FAT drives or other NTFS drives requiring as a prerequisite unique Disk-IDs on all disks, which are chained together via Junctions/Symbolic links: Hardlink siblings are found by matching the per NTFS volume unique file-id, but if more volumes are chained together it might happen that the same file-ids can be found on two different NTFS volumes. To address this all operations use the disk-id and the file-id to match hardlink siblings. Furthermore it is not allowed to have the disk-id 0xFFFF-FFFF, because the algorithms use this as internal indicator of a FAT drive. The Unroll option also allows to point multiple junctions to point to the same target location, which causes the algorithms to traverse the same items many times: At the first glance multiple traversing of items looks simple, but for files this means that multiple traversed files are the same in the destination and are hardlinked together. So don't be confused when you see hardlinks, which have never ever been there before. Copying Junction/Symbolic Links from mapped network drives also needs extra care, because junctions on the remote machine relate with path references only valid on the remote machine to each other: The example in the above picture shows such a situation X:\Src\Foo\Junction/Symlink is a junction on a Remote Machine, which points to X:\Src\Foo\Folder. It is a valid Junction. X:\Src\Foo is sharded via \\RemoteMachine\MyShare, which still is no problem. \\RemoteMachine\MyShare mapped to T:\ on a local machine is fine, but the Junction T:\Junction/Symlink, if asked for its target, will still return X:\Src\Foo\Folder even on the Local Machine. One could expect that the target is T:\Folder, but it is not for Junctions. When SmartCopy/Mirror/Delorean comes across such a situation, it translates the Junction correctly when it is copied onto the Local Machines drive Y:\, so that the final Junction target points correctly to Y:\Dest\Bar\Folder This option supports taking its arguments from file. ln --unroll @List.txt --copy c:\source d:\b\dest The above example references to a file List.txt, which on every line contains a matching pattern. e.g. MountPoint TheDirectory Directory with blanks
Splice	Splice reconnects Outer Junctions/Symlink directories in the destination to their original targets. In the above example Folder1 is copied to Destination/Folder1, and Outer Junction/Symlink is available in the destination as junction, which points to the original location Outer Junction/Symlink Target. The objective behind splicing Outer Junctions/Symlink Directories to its original location is to get a copy during smartcopy, but to reuse Outer Junctions/Symlink Directories source locations. The command line invocation below splices all junctions/symbolic link directories below "c:\Folder 1" ln --splice --copy "c:\Folder 1" "c:\Destination\Folder 1" In certain situations only certain junctions/symbolic link directories should be spliced during SmartCopy, DeloreanCopy, SmartMirror or HardlinkClone. To accomplish this ln.exe can be run with wildcard expressions to specify certain directories for splicing. ln --splice "MyJunc*" --copy "c:\Folder 1" "c:\Destination\Folder 1" To specify junctions/symbolic link directories for splicing more fine grained regular expressions can be given: ln --spliceregexp "[a-z]*" --copy "c:\Folder 1" "c:\Destination\Folder 1" The regular expressions used must conform to POSIX 1003.2 extended RE (ERE) syntax . They are not casesensitiv. The Splice functionality is also useful, when mountpoints should be copied. Mountpoints are very similar to Junctions, but point to a path always starting with \\?\VolumeGuid. To specify a certain mountpoint to be copied specify it as argument to --splice: ln --splice "Mountpoint" --copy "x:\Folder 1" "x:\Destination\Folder 1" In the above example Folder1 is copied to Destination/Folder1 and the Mountpoint is created in the destination as Mountpoint again. It points to the original location under \\?\Volume{b4..bc}. Or drive complexity up one level and just use splice for mountpoints with wildcards, but unroll the rest. ln --unroll --splice "Mountpo*" --copy "x:\Folder 1" "x:\Destination\Folder 1" This option supports taking its arguments from file. ln --splice @List.txt --copy c:\source d:\b\dest The above example references to a file List.txt, which on every line contains a matching pattern. e.g. MountPoint TheDirectory Directory with blanks

In the above example the directories and files below x:\Bkp2 are deleted.

1. A Source was used to create three successive Delorean Copies: Bkp1,Bkp2,Bkp3. File B is ReadOnly in the Source and in all Delorean Copies. So far so good.
2. When it comes to delete Bkp2 the Readonly attribute of Bkp2/B has to be removed, otherwise deletion is impossible.
3. Due to the fact that all siblings of a hardlink share the same attribute and the same date, the readonly attributes of Bkp1/B and Bkp3/B are also 'changed'. This is shown via the blue dotted lines. Called it 'Hardlink Attribute Teleportation'
4. This results now in having a different attribute in Bkp1/B and Bkp3/B than in Source/B. This is shown via the grey dotted line.
5. A fourth delorean copy with Source and Bkp3 as Backup to Bkp4 is created.
6. Since the attributes of Bkp3/B and Source/B are different, the file Bkp4/B was copied over freshly from Source/B. So there is no hardlink between Bkp3/B and Bkp4/B, which is shown with the light red dotted line, and which is the basic problem.

1. Before deleting Bkp2/B retrieve at least one hardlink sibling, e.g. Bkp1/B
2. Delete Bkp2/B
3. Restore the attribute of Bkp2/B to one hardlink sibling, which has been retrieved in 1. e.g. Bkp1/B and rely on Hardlink Attribute Teleportation, so that it spreads to all other siblings.

DeLorean Copy is a way of creating incremental backups by using a combination of Hardlink Clone and SmartMirror.

The following picture gives an overview of what DeLorean Copy is about

In general a DeLorean Copy has 3 principals: Source(t), InitialBackup and Backup(n), where t represents time and n the number of backups.

With completion of this first round Backup1 contains the first lean and mean copy of Source only consisting of either hardlinks to InitialBackup, or of copied files if there was the need to copy them over from Source(t+1) because they were newer under Source(t+1).

The point is that all files in Backup1 are transparently accessible, but little space is used, because not all files in the Source(t+1) changed, so that there was only the need to effectively copy over a few files from Source(t+1) to Backup1.

The time stamps for LastWriteTime, CreationTime and LastAccessTime of files/folders/junctions/symbolic links are also restored at the corresponding destination locations during DeloreanCopy.

Different items means: Either the file size has changed, or the LastWriteTime has changed.

This can be repeated on and on. The second round would be using Source, Backup1 and Backup2 for DeLorean Copy:

A real word example looks like this:

This creates the initial Backup as shown above in Phase 1

This command does the first round of DeLorean copy as shown above in Phase 2 and Phase 3 creating a backup.

This command creates another set of incremental DeLorean copy as shown above in Phase 2 and Phase 3 creating another backup.

See also the note on quotes.

The logging generated by DeLorean Copy/Smart Copy/Smart Clone/Smart Mirror looks like e.g.:

Delorean Copy logs each action it did, and prefixes two characters to each item which it processed for each line of output. The first column of the output contains the Operation which was performed, and the second column specifies the Type of item which was processed.

After DeLorean Copy is finished it displays a statistics like this:

The statistics of DeLorean Copy only counts the operations which are performed during the Mirror phase between Source and Backup(n+1). The operations which are performed during cloning between Backup(n) and Backup(n+1) are not counted in the final DeLorean Copy statistics.

Total: The total number of items as they were found under the Source. Total is the sum of all other columns but the Removed column.

Copied:

• Items prefixed with + in the verbose output and which were were copied from Source to Backup
• Items prefixed with & in the verbose output and which have turned out to be dangling Junctions or Symbolic Links in the Backup

Linked:

• Items prefixed with * in the verbose output which were either hardlinks or
• Items prefixed with + in the verbose output which were symbolic links

Skipped:

• Items prefixed with = in the verbose output, which were skipped during copy, because they were already there

Removed:

• Items prefixed with - in the verbose output, and which were removed from Backup because they are not in the Source any more.

• Items prefixed with ~ in the verbose output and which were excluded from Backup, because they were excluded from the Source via --exclude.
• Items prefixed with # in the verbose output, because --splice/--unroll was specified with a regular expression, but the regexp didn't match.
• Items prefixed with # in the verbose output, because no --unroll or --splice was given at all, thus it was cropping.

Failed:

• The number of items which failed during creation.
• The number of items which failed during cleaning while doing SmartMirror and while doing Delorean Copy.

Overall: Time used up for the whole DeLorean Copy including the Clone from Backup(n) to Backup(n+1) and the Mirror from Source to Backup(n+1)

Clone: Time used up for the Clone from Backup(n) to Backup(n+1)

Mirror: Time used up for the Mirror from Source to Backup(n+1)

It is little known, but NTFS has a limit to create a maximum of 1023 hardlinks to one file. For DeLorean Copy this means that it will display an error message if this limit is exceeded, because exceeding this limit means loss of data among the most recent backup sets:

The reason for exceeding this limit could either be, that there have been more than 1023 backup sets but no hardlinks within the Source, or there are hardlinks within the Source and less than 1023 backup sets. See also

The filters of --includeXXX or --excludeXXX are applied in the source and the destination location

DeLorean Copy functionality is also available via Link Shell Extension

DeLorean Copy might need --anchor and/or --destination if there are inner junctions / symbolic links among the source and the source dir is not referenced via its native name (e.g. X:\path ), but via UNC Shares or GLOBALROOT / Volumeguid due to operation via snapshotservice

In general ln.exe operates on source/target pairs. The default pair is always provided via e.g.

• SourceDir/TargetDir
• AnchorDir/TargetDir

• SourceDir/TargetDir
• AnchorDir/DestinationDir

The --destination option can only be used in combination with the --source option, or the --anchor option

Smart Copy, Smart Mirror and SmartClone rely on finding the hardlink relations by enumerating the unique file-index attribute of each file. But there might be more equal files below a given path, some of them probably not hardlinked. When issuing the --dupemerge option ln.exe does not only rely on the file-indices, but also creates incremental hash sums on all files, so that it finds additional not yet hardlinked dupes and hardlinks them in the destination:

In the above example the directory Folder1 is searched for dupes and copied/hardlinked to destination. The files A, C, D are already hardlinked in the source, but B is not, even if it is the same as A,C,D. Similar situation with E,F, which are already hardlinked, but G is the same as E,F but not hardlinked. In the destination all equal files are hardlinked: There is a dupel B,C,D and a dupel E,F,G. A was omitted as in normal Smartcopy, because it is out of the source scope.

The --dupemerge option is also of help, when data from a drive should be copied which has a broken NTFS implementation.
NTFS drives which are accessed via SMB or CIFS sometimes show the same file-index attribute for files of different size. Well that's impossible, because the file-index attribute can only be the same for hardlinks, and hardlinks, since they are pointing to the same data, are the same files, with for sure the same size.

So the SMB or CIFS implementation of such drives is broken, and this means one can not detect already existing hardlinks by reading all file-indices from all files and searching for equal indices. ln.exe has a built in sanity check on file-indices, and once it finds files with same file-index but different size, it assumes the view on this NTFS drive is broken, and invalidates all file-indices, thus assuming no hardlinks are on this drive.

In such a situation --dupemerge is of great help because it scans the given path and calculates incremental MD5 hash sums for all files. This enables ln.exe to detect dupes, and hardlink equal files in the destination.

On the fly Dupemerge can take a while and ln.exe prints out a warning, that it entered the On the Fly Dupemerge mode.
The Dupemerge functionality can also be downloaded as a standalone tool for in-place dupemerge.

See also the note on quotes.

Sometimes it is convenient to find out which files are linked together, because hardlinked files might be spread around a NTFS volume. This is somehow the inverse hardlink functionality and it can be invoked as follows.

In the above example files below path are searched, and the files which are hardlinked are printed out.

The --enum option first prints so called saturated and afterwards unsaturated hardlinks. For saturated hardlinks the number of files found below path matches the hardlink reference count of these files, but unsaturated hardlinks have a reference count greater than the number found below path.

In certain situations not all files below a path should be used in Smart Copy, Smart Mirror, Delorean Copy or Clone. To accomplish this ln.exe can be run with wildcards specified to exclude certain files.

Basically any arbitrary wildcard expressions can be used, because the wildcard expressions are translated into a regular expression. This means that e.g *file*.ext*.* is also a valid wildcard expression for --exclude.

Sometimes it is necessary to just exclude certain files along a given path:

The above example excludes all files Logfile.* from all directories which have \Res\ in it.

This option supports taking its arguments from file.

The above example references to a file List.txt, which on every line contains a matching pattern. e.g.
*.dll
*.ocx
Myfile*.*

In certain situations not all directories should be used in Smart Copy, Smart Mirror, Delorean Copy or Clone. To accomplish this ln.exe can be run with wildcards to exclude certain directories.

Basically any arbitrary wildcard expressions can be used, because the wildcard expressions are translated into a regular expression. This means that e.g *file*.ext*.* is also a valid wildcard expression for --excludedir. Wildcard expression shall not span more than one directory level: e.g. *fotos\\temp* will not succeed.

This option supports taking its arguments from file.

The above example references to a file List.txt, which on every line contains a matching pattern. e.g.
*fotos*
aDir
Directory with blanks

In certain situations not all files below a path should be used in Smart Copy, Smart Mirror, Delorean Copy or Clone. To accomplish this ln.exe can be run with regular expressions specified to exclude certain files.

The regular expressions used must conform to POSIX 1003.2 extended RE (ERE) syntax . They are not casesensitiv.

The regular expression specified under --excluderegexp is applied to the whole path with the filename.

This option supports taking its arguments from file.

The above example references to a file List.txt, which on every line contains a regular expression. e.g.
[a-z]*
file[0-9]\.txt

In certain situations not all directories should be used with Smart Copy, Smart Mirror, Delorean Copy or Clone. To accomplish this ln.exe can be run with regular expressions to exclude certain directories.

The regular expressions used must conform to POSIX 1003.2 extended RE (ERE) syntax . They are not casesensitiv.

The regular expression specified under --excluderegexpdir is applied to the whole path with the filename.

This option supports taking its arguments from file.

The above example references to a file List.txt, which on every line contains a regular expression. e.g.
[a-z]*
directory[0-9]

The delete option normally stops on reparse boundaries, but in certain cases it is useful to force the --delete option to follow pathes, which match wildcards

This option supports taking its arguments from file.

The above example references to a file List.txt, which on every line contains a matching pattern. e.g.
Outer*
WhatEver
Somethi?g*
Directory with blanks

The delete option normally stops on reparse boundaries, but in certain cases it is useful to force the --delete option to follow pathes, which match regular expressions

The regular expressions used must conform to POSIX 1003.2 extended RE (ERE) syntax . They are not casesensitiv.

The regular expression specified under --followregexp is applied to the whole path with the filename.

This option supports taking its arguments from file.

The above example references to a file List.txt, which on every line contains a regular expression. e.g.
[a-z]*
file[0-9]\.txt

To selectively run Smart Copy, Smart Mirror, Delorean Copy or Clone on a certain set of files, the --include option can be used with wildcards.

Basically any arbitrary wildcard expressions can be used, because the wildcard expressions are translated into a regular expression. This means that e.g *file*.ext*.* is also a valid wildcard expression for --include.

Sometimes it is necessary to just include certain files along a given path:

The above example includes all files Logfile.* from all directories which have \Res\ in it.

This option supports taking its arguments from file.

The above example references to a file List.txt, which on every line contains a matching pattern. e.g.
*.dll
*.ocx
Myfile*.*

To selectivley run Smart Copy, Smart Mirror, Delorean Copy or Clone on a certain set of directories, the --includedir option can be used with wildcards.

Basically any arbitrary wildcard expressions can be used, because the wildcard expressions are translated into a regular expression. This means that e.g *ub?older* is also a valid wildcard expression for --includedir. Wildcard expression shall not span more than one directory level: e.g. *fotos\\temp* will not succeed

This option supports taking its arguments from file.

The above example references to a file List.txt, which on every line contains a matching pattern. e.g.
*fotos*
aDir
Directory with blanks

To selectively run Smart Copy, Smart Mirror, Delorean Copy or Clone on a certain set of files, the --includeregexp option can be used with regular expressions specified to include certain files.

The regular expressions used must conform to POSIX 1003.2 extended RE (ERE) syntax . They are not casesensitiv.

The regular expression specified under --includeregexp is applied to the whole path with the filename.

This option supports taking its arguments from file.

The above example references to a file List.txt, which on every line contains a regular expression. e.g.
[a-z]*
file[0-9]\.txt

To selectively run Smart Copy, Smart Mirror, Delorean Copy or Clone on a certain set of directories, the --includeregexpdir option can be used with regular expressions to include certain directories.

The regular expressions used must conform to POSIX 1003.2 extended RE (ERE) syntax . They are not casesensitiv.

The regular expression specified under --includeregexpdir is applied to the whole path with the filename.

This option supports taking its arguments from file.

The above example references to a file List.txt, which on every line contains a regular expression. e.g.
[a-z]*
directory[0-9]

To postprocess the results of ln.exe the whole output can be switched to Json.

The output looks like this

ln.exe can also create junctions, and print the target of junctions

In the above example a junction JunctionName is created, which points to TargetDirectory

In the above example the junction JunctionName is searched for its Target and the target is printed out.

In the above example the junction JunctionName is removed. This is accomplished with an simple built in command prompt command.

In the above example the junction JunctionName is created to a volume-guid target. This is useful if you are either out of drive letters, or just want to have a link to a directory on a mounted drive regardless of which drive-letter it is mounted on. To find out the available volume-guids use the mountvol.exe command.

• Format the disk in 'Disk Manager', but do not mount at all in 'Disk Manager'
• Use mountvol.exe to see which volumes are available.
• Mount the volume:
  ln --junction Mountpoint \\?\Volume{f6c8b244-1ce4-11e0-a607-005056c00008}\
  
• Use 'rmdir Mountpoint' to unmount.

In the early days of ln.exe the arguments of --junction were unfortunately defined in the opposite order as for --symbolic. So --junction has the target as first argument and --symbolic has it as second. So far so bad. To fix this and avoid breaking compatibility (and keep my regression test simple;-) for --junction an additional option --noitcnuj was introduced, which creates junctions and has the target as its second argument:

So everything which can be done with --junction can be done with --noitcnuj, but reversed argument order. Why 'noitcnuj'? Read noitcnuj backwards ... ;-)

Symbolic links can be created either absolute or relative. Setting this modifier creates symbolic links in the destination in the same way as the were in the source.

This modifier can be applied to all operation like --copy, --mirror, or --delorean. It is enabled by default if ln.exe is used with the --backup option.

With Windows7 and above finding out the siblings of a hardlink is very simple and needs no time-consuming operations

In the above example the hardlink siblings for filename are printed out.

With XP, W2K or W2K3 finding the hardlink siblings now also works, but it takes more time, because in the worst case the whole logical volume must be searched.

• A set of delorean backups have been created on a disk, and the disk becomes full.
• A new set of delorean backups from the same source is created on another disk.
• The two sets shall be merged into one. So copy both sets via smartcopy to one disk and use the merge functionality

The above example assumes two DeloreanSets. DeloreanSet1 contains 2 Backups and DeloreanSet2 contains 1 Backup. The DeloreanMerge operation hardlinks DeloreanSet2 into DeloreanSet1, so that DeloreanSet1 & DeloreanSet2 become one.

In the above example the directory x:\DeloreanSet1\bkp2 is merged with x:\DeloreanSet2\bkp3.

Merged files are marked with the ° character in the log.
If the hardlink limit of 1023 was exceeded, the files are not merged, and they are prefixed in the output with °~
If the files are already hardlinked, they are prefixed in the output with °=
If something goes wrong during merging the affected files it is prefixed in the output with !°f

This option will not work on Network drives.

See also the note on quotes.

• Smart Copy only different items from Source to Destination.
• Delete items no longer in Source from Destination.

Smart Mirror takes care of Hardlink Relations, restores Inner Junctions or Inner Symbolic links or when issued unrolls or splices Outer Junctions or Outer Symbolic Links. The time stamps for LastWriteTime, CreationTime and LastAccessTime of files/folders/junctions/symbolic links are also restored at the corresponding destination locations during SmartMirror.

Different Items means: Either the file size changed, or the LastWriteTime changed.

In the above example the directory x:\source is mirrored to x:\destination, and all symbolic links and junctions within x:\destination are updated with respect to their new locations under x:\destination.

The filters of --includeXXX or --excludeXXX are applied in the source and the destination location

See also the note on quotes.

Shell Integration
Smart Mirror functionality is also available via Link Shell Extension

• Create a symbolic link Clone from Source to Destination.
• Delete symbolic links in Destination which are no longer in Source

Clone Mirror takes care of Inner Junctions, Inner Symbolic links or when issued unrolls or splices Outer Junctions or Outer Symbolic Links.
Different Items means: The LastWriteTime has changed.

In the above example the directory x:\source is cloned to x:\destination, and all symbolic links and junctions within x:\destination are updated with respect to their new locations under x:\destination. Furthermore symbolic links, which are in the Destination, but have no longer a target in the Source, are deleted from the Destination.

See also the note on quotes.

• Create a Hardlink Clone from Source to Destination.
• Delete Hardlinks in Destination which are no longer in Source

Hardlink Clone Mirror takes care of Inner Junctions, Inner Symbolic links or when issued unrolls or splices Outer Junctions or Outer Symbolic Links.
Different Items means: The LastWriteTime has changed.

In the above example the directory x:\source is cloned to x:\destination, and all symbolic links and junctions within x:\destination are updated with respect to their new locations under x:\destination. Furthermore files, which are in the Destination, but are no longer in the Source, are deleted from the Destination.

See also the note on quotes.

Smart Move enables folders with junctions and symbolic links beneath to be renamed, and the junctions and symbolic links' targets are updated below that folder. Without Smart Move renaming of such folders would end in dangling junctions and symbolic links.

With junctions or symbolic link directories it behaves as follows:

By closely looking at the above picture one can find three different types of folders/junctions:

In the above example the directory x:\dir\dir2 is moved to x:\dir\newdir, and all symbolic links and junctions within x:\dir\dir2 are updated with respect to their new locations under x:\dir\newdir.

See also the note on quotes.

Shell Integration
Smart Move functionality is also available via Link Shell Extension

The --noads option tells ln.exe not to copy Alternative Data Streams (ADS) of files and directories. This option can be useful if the destination supports NTFS, but can not deal with ADS, which happens on certain NAS drives.

In the above example the files are copied normally from src to dest except for ADS.

The --noea option tells ln.exe not to copy EA Records of files and directories. This option can be useful if the destination supports NTFS, but can not deal with EA Records, which happens on certain NAS drives.

In the above example the files are copied normally from src to dest except for EA Records.

The output of ln.exe can be redirected to files via this commandline option

In the above example all output is redirected to filename

This option of ln.exe returns the type of the filesystem. e.g NTFS, FAT, ReFs ...

This option is a modifier and shows the progress during operations like --mirror, --copy, --clone, --delorean

The --progress option writes the progress only onto the console and is best used with --ouput. The --output option collects all important logging in a logfile, while the progress is written onto the console. e.g.:

The percentage progress is displayed as well as the estimated time left.

The amount of output during various operations can be controlled via the --quiet switch:

The --quiet option without arguments totally disables any output during ln.exe' operations.
To specify the amount of output an optional argument can be passed to the --quiet switch:

In the above example only changes are shown.

ln.exe can recursively hardlink all files found below a given directory location to a newly created directory structure under a different location.

In other words this means, the given directory structure is rebuilt under a different location, and all files from the given directory structure are hardlinked to the newly generated structure. Something like a xcopy, but the files are hardlinked and not copied:

e.g.:

In the above example the directories below x:\dir\dir2 are rebuilt below x:\dir\newdir, and all files from x:\dir\dir2 are hardlinked to their corresponding locations under x:\dir\newdir.

A folder tree might also contain Junctions or Symbolic Links. The clone process recreates inner junction/symbolic links at the destination location very similar to the way SmartCopy does.

Outer Junctions/Symbolic links are recreated with respect to the specified Outer Junction/Symbolic Link handling. e.g.

In the above example the directories below x:\dir\dir2 are rebuilt below x:\dir\newdir, all files from x:\dir\dir2 are hardlinked to their corresponding locations under x:\dir\newdir and all junctions/symbolic links are unrolled.

The cloning process is also available with Symbolic Links instead of Hardlinks.

Output See Output among Delorean Copy for a detailed description of HardlinkClone's Output

Shell Integration
The recursive support or HardlinkClone functionality is also available via Link Shell Extension

This option is a modifier to Smart Copy, Smart Mirror, Delorean Copy, or Clone, so that only directories symlinks and junctions are processed. The files are ommitted with this modifier used.

Smart Rename is very similar to Smart Move, but only renames junctions/symbolic links references below a given folder.

In the above example the symbolic links/junction references below x:\dir\dir2 are renamed to x:\dir\newdir. This leaves x:\dir\dir2 with dangling symbolic links/junction, but this feature is useful if someone wants to migrate a whole disk to another physical media.

See also the note on quotes

Multpiple source locations can be specified for SmartCopy, Clone and Delorean Copy. If there are junctions/symlinks between these source locations, they are handled as inner junctions/symlinks, because all source locations are dealt with as a common root.

In the above example Location 1 and Location 2 are copied to Destination. Location2/Junction_Symlink is treated as inner junctions to Location1/Folder 10 in the source, and that's why Destination/Junction_Symlink points to Destination/Folder 10 in the Destination.

The objective behind this is to treat all junctions/symlinks as inner junctions/symlinks as long as they are in the set of source folders.

Merging into one destination
The command line invocation below copies from "c:\Location 1" and "c:\Location 2" to c:\Destination :

There can be more than one additional --source command-line switches:

Specifying additional source paths can be combined with --splice or --unroll:

The above command copies all content from "c:\Location 2" and "c:\Location 1" to c:\Destination, but does not create a "c:\Destination\Location 2" and a "c:\Destination\Location 1".

Keeping several destinations
To keep several destinations the --destination option must be used:

The --destination option must always be used with a corresponding --source option building pairs. The order of --source --destination is also important. For --copy the normal destination builds the pair:

Mirror to several destinations
The --mirror option can also be used to mirror to several destinations

Make sure that c:\Destination already exists

There are a lot of filesystems out by third party vendors nowadays, which support hardlinks, symlinks... In order to provide the ln.exe functionality on that drives, the supported filesystems can be given:

Configuring your favourite filesystem to be recognized by ln.exe is on your own risk. Basically ln.exe would do all operations to the configured filesystems, which it does to NTFS. So make sure your filesystem supports the same primitives as NTFS does, otherwise certain operations will fail.

When used under Vista or Windows7/8 ln.exe can create symbolic links

In the above example a symbolic link SymbolicLinkToSourceFile.txt is created which points to sourcefile.txt.

In the above example a symbolic link DestinationDirectory\Sourcefile.txt is created which points to Sourcefile.txt.

In the above example a symbolic link SymbolicLinkToSourceDirectory is created which points to SourceDirectory.

In the above example a symbolic link DestinationDirectory\SourceDirectory is created which points to SourceDirectory. A traling backslash is the trigger for this to work.

ln.exe can also only show the target of a symbolic link

ln.exe can also symbolically link to volume-guid targets:

In the above example the symbolic link SymbolicLinkName is created to a volume-guid target. This is useful if you are either out of drive letters, or just want to have a link to a directory on a mounted drive regardless with of which drive-letter it is mounted on. To find out the available volume-guids use the mountvol.exe command.

During --mirror and --delorean it is sometimes useful to not have an exact timestamp comparison between source and destination, but kind of a fuzzy comparison, because the systemtime of NAS drives is not exactly synced with the host.

To overcome this ln.exe has a --timetolerance switch to specify a value in milliseconds

Some NAS boxes only support a very outdated version of the SMB protocol. SMB is used when network drives are connected. This old version of SMB in certain situations does not support the fast enumeration methods of ln.exe, which causes ln.exe to simply do nothing in SmartXXX functions.

To overcome this ln.exe has a --traditional switch, which forces ln.exe to enumerate files the old, but a little slower way.

Prints the true space used taking into account hardlinks. This means that a file with a size of e.g 12345kb and a reference count 5, will be listed with 61725kb by explorer, but indeed it only uses 12345kb, because it has a refcount of 5.

returns the following output

The --truesize option does not return info on alternate data streams right now.

NTFS puts a 1023 limit on the number of hardlinks a file can have. In most cases this is not a problem, but if many delorean copies are stored, and files are hardlinked within a delorean copy too, it might turn out that the limit of 1023 hardlinks is reached and the error ERROR_TOO_MANY_LINKS is thrown.

To overcome this either the number of stored backups can be reduced by applying the Tower of Hanoi backup strategy, or by using the 1023safe option

The 1023safe option can not lift NTFS limits, but for a little performance penalty it can check if the limit is exceeded and if neccessary introduce a copy in the chain of hardlinks, and then hardlink the files to this newly introduced copy:

In the above example a setup is shown, which has already applied three iterations of delorean copy:

• Intitially there was a directory which contained the file B, and the hardlinks A001 to A500. So the reference count was 1 for file B, and 500 for A001 to A500. So far so good.
• The first Delorean Copy copied over from Backup0 to Backup1, which increased the reference count for file B to 2, and A001 to A500 were pushed to a reference count of 1000. Still ok.
• With the third Delorean Copy the reference count for file B goes to 3 and for A001 to A500 it would have been increased to 1500. This would be a violation of the 1023 limit! Without the --1023safe option, this delorean copy would fail.
  
  With the --1023safe option ln.exe checks if the limit would have been reached, and if neccessary introduces a copy of A001 in Backup2 instead of hardlinks for A001, and links A002 to A500 to the newly created copy. This reduces the refcount for A001 ... A500 again to 500, and the game can go on.

Please make sure that the necessary runtime .dlls vcredist_x86.exe for VS2005 SP1, version 6195/June 2011 (2.6 Mb) are installed on your system. Afterwards install the ln.zip (2.08Mb)