Slashdot Mirror
Vista To Get Symlinks?
TheRealSlimShady writes "According to a post by Ward Ralston on the Windows server team's weblog, Vista server is to get symlinks as part of the SMB2 protocol." From the post: "In Vista/Longhorn server, the file system (NTFS) will start supporting a new filesystem object (examples of existing filesystem objects are files, folders etc.). This new object is a symbolic link. Think of a symbolic link as a pointer to another file system object (it can be a file, folder, shortcut or another symbolic link)."
Although the moon is smaller than the earth, it is farther away.
Some of the Vista previews have shown off things dubbed "virtual folders" which work in a similar way to browsing by artist or album in the current version of Media Player. You can manipulate the files like it's a normal folder window, yet the actual files may be scattered over different folders and drives. Presumably it's an effort to make managing large amounts of music/video outside of Media Player easier. They almost certainly use these symbolic links. They're a bit different from shortcuts.
No kidding!!! What do you say at this point?
See here :
m l
;-)
:(
http://www.sysinternals.com/Utilities/Junction.ht
Any feature new in Vista but the look and feel ?
What about booting the OS with less than about 20 services started and 256MB of memory used ?
Shortcuts are just ordinary files that, when opened, open the location it points to. A symlink, however, allows you transparently access it as though it were the actual file/folder; "C:\Shortcut to porn\hot lesbian action.jpg" won't work, whereas "C:\Symlink to porn\hot lesbian action.jpg" will. See the Wikipedia entry, for more info.
They are just not accesible from the shell. You need 3rd party utils to use them.. http://www.sysinternals.com/Utilities/Junction.htm l
Since Windows programs have not ever needed to check for the existence of symlinks, a lot of software will be a serious DoS waiting to happen. Recursive symlink traversal is one of the most devastating things a computer can do to itself. It can damage hard drives, crash software, take down servers and generally make the computer unusable. On UNIX, almost all software is aware of this pitfall and won't go crashing the computer.
The inventors of Unix scrapped symlinks when they did their next OS
Symbolic links make the Unix file system non-hierarchical, resulting in multiple valid path names for a given file. This ambiguity is a source of confusion, especially since some shells work overtime to present a consistent view from programs such as pwd, while other programs and the kernel itself do nothing about the problem.
http://plan9.bell-labs.com/sys/doc/lexnames.html
NT *was* going to have executables that pretended to be files, i.e. when you opened the executable to get the contents it would run and return the output rather than the by bytes of the executable, with a special NT syscall to read the *real* contents. Kind of like a named pipe. I was looking forward to this but it didn't work out.
There are places where the networks are not touching,and there are places where they are-Boeing's Lori Gunter
$ fortune -m 'condemned'
...
Those who do not understand Unix are condemned to reinvent it, poorly. -- Henry Spencer
And those who don't understand fortune(1) are condemned to ask about quotes =)
does the average user *really* need them? I certainly can't remember ever having said 'Damn, I wish this piece-of-crap-OS would support symlinks' during my Windows days.
Man, you need to use symlinks to see how useful they are. As someone pointed before, symlinks are great to create compilations of files on a directory. Also, they are very useful if you want to use different types of libraries (DLLs) on different programs (in different directoires).
As for the "average user", as someone else said also, this symlink will surely help the file system Virtual folders or whatever is named. It is the same as the SQL oriented file system, you could ask, will the average user make use of SQL queries?, and the answer is that, they will, indirectley through the applications that are make use of that technology.
Remember, this symlink will be a feature of the FILESYSTEM, which will be used by the programs. I for one would preffer to have multiple symlinks to DLLS than to have to copy the libraries through all the hard disk (or maybe not DLLS but other files).
Ubuntu is an African word meaning 'I can't configure Debian'
There can be some improvement, particularly with managing symlinks.
/usr/tunes to /usr/local/tunes. Later, you symlink /usr/local/tunes/YMCA.mp3 => ~/my_favorite_song.mp3. Now, you have a symlink that relies on both the existence of "/usr/tunes/" AND symlink "/usr/local/tunes >> /usr/tunes". Thus, while deleting 1st ("/usr/local/tunes => /usr/tunes") symlink doesn't actually delete anything, it does cause ~/my_favorite_song.mp3 to become unworkable.
1) When you move a destination object, symlinks don't follow the target . This leaves "broken" symlinks that refer to nothing. Why doesn't the mv command move these too?
2) When you symlink a symlinked folder, the root symlink is ignored. Let's say you symlink
3) Symlinks cause all kinds of weirds around chrooted file systems , especially ones on a different underlying filesystem. If you're not very careful, nothing is as it seems! Files go nowhere, files are accessable only sometimes, etc. It's logical when you understand and appreciate a symlink for what it is, just a referral, but it can be maddening when security contexts get distorted around a chroot...
I have no problem with your religion until you decide it's reason to deprive others of the truth.
Its too late....
Five years to late
My pics.
NTFS already had symlinks. Just that Explorer and cmd.exe didn't used the feature. But if created (with a third party tool) they are properly used.
Also, FAT had initially a flag indicating that an object is not a file, nor a folder, but a symlink. Unfortunately, the attribute got later used as a "Long Filename Part no. X" flag... talk about bad design..
gtkaml.org
I recall this Slashdot story from several years ago (damn, I can't believe a Slashdot headline has stayed with me that long). Sadly, the links referenced in the article are broken, so I don't recall exactly what it was about.
Reparse points (like links) http://msdn.microsoft.com/library/default.asp?url
Junctions (to mount file systems) http://msdn.microsoft.com/library/default.asp?url
Sparse files (highly underutilized) http://msdn.microsoft.com/library/default.asp?url
and of course the plain old short cuts that are really symbolic links in the traditional unix world.
I remember architecting a product to implement all unix based functionality in NT (IPC, memory mapped files, etc) and found NT40 to have that and more. Thats the time I really appreciated windows as a OS more mature than Unix.
The unfortunate part is people still think of DOS/Win95 code base when they think of windows. As a OS, W2K is much more mature in terms of the facilities they offer and as a filesystem, NTFS is way ahead.
Give me a feature in Unix and Im sure there is an equivalent in NT. Thousands of smart people working at Redmond are not idiots and millions of corporate architects proposing NT based solutions are not stupid either. They propose windows based technologies not just for looks (though end users do appreciate that).
That the Research Unix guys didn't add it to Plan9 doesn't have to mean anything else than they suffer from the NIH syndrome. I don't believe symbolic links were ever a part of Research Unix.
The commercial product, SysV, got symbolic links, but they had to compete in the real world.
"Microsoft 'innovating' once again" - by el_womble (779715) on Monday October 31, @06:41AM
m l
And, more "F.U.D." attempts by the 'pro-Unix/Linux/BSD' brothers @ "/.", as-per-usual... or, the usual "partially informed/incomplete data spouting rumor mill" is @ work here again, as-per-usual.
Take a read, so you are better informed:
http://www.sysinternals.com/Utilities/Junction.ht
-----
Win2K's version of NTFS supports directory symbolic links, where a directory serves as a symbolic link to another directory on the computer.
For example, if the directory D:\SYMLINK specified C:\WINNT\SYSTEM32 as its target, then an application accessing D:\SYMLINK\DRIVERS would in reality be accessing C:\WINNT\SYSTEM32\DRIVERS.
Directory symbolic links are known as NTFS junctions in Win2K.
Unfortunately, Win2K comes with no tools for creating junctions - you have to purchase the Win2K Resource Kit, which comes the linkd program for creating junctions.
I therefore decided to write my own junction-creating tool: Junction.
Junction not only allows you to create NTFS junctions, it allows you to see if files or directories are actually reparse points.
Reparse points are the mechanism on which NTFS junctions are based, and they are used by Win2K's Remote Storage Service (RSS), as well as volume mount points.
If you want to view reparse information, the usage for Junction is the following:
Usage: junction [-s]
-s
Recurse subdirectories.
If you want to create or delete a junction, use Junction like this:
Usage: junction [-d] []
To delete a junction specify the -d switch and the junction name.
-----
(NT's been there, & done that, ages ago already for DIRECTORY SYMBOLIC LINKS @ least... + the resource kit tools mentioned above, OR the tools offered by Dr. Russinovich & Bryce Cogswell @ SysInternals do the job in this matter as well as alternate methods of using what's already been in NTFS for ages now)
APK
P.S.=> "and giving the people what the want (10 years after everyone else). Go Redmond!" - by el_womble (779715) on Monday October 31, @06:41AM
They surely have, now, haven't they & for the last 12 years or more @ desktop/laptop levels up to Server OS + backoffice/industrial strength tools to match their Office Suite offerings + development tools?
So, with that statement of yours, I must agree:
Plus, 95%++ of the world's computers running Windows NT-based Operating Systems by now (e.g.-> NT/2000/XP/Server 2003), which run tons more hardwares than UNIX of any type does, + with more peripheral surrounding softwares for any imaginable purpose (thus, Win32 Os are far more ubiquitous + flexible) can't be TOO far wrong to second your statement now, can they? apk
Yes, the Mac OS had none of those problems with Aliases. I guess that's what happens when you design an OS from the ground up that doesn't use paths to reference everything. In fact, for a very long time there was no way to get a path in the Mac OS. OS X changed all that and now many programs are very fragile (like Preview).
There is a huge difference between the two: a hard link is filesystem-level (simply a second entry in a directory to a file); a symlink is OS-level. One cannot cross filesystem boundaries (being filesystem-level), the other can.
--
Given enough personal experience, all stereotypes are shallow.
I don't know where you got your info from, but plugging in a hotswap disk does NOT require a reboot, and hasn't since at least Windows 2000, but probably even NT 4. Open computer management, go to disk configuration, and click "rescan disks". It'll detect the drive just fine.
Geek used to be a four letter word. Now it's a six-figure one.
Windows 2k and above have both hardlinks (which are available via standard tools) as well as symlinks, restricted to directories only and not available via the OS' tools.
Check Juctions for the creation and handling of symlinks.
"The way we can tell it's C# instead of Haskell is because it's nine lines instead of two." -- wadler
It seems people are forgetting about the "almost there" aspects of NTFS 5 ..
.. Distributed Link Tracking and Object Identifiers ... http://support.microsoft.com/default.aspx?scid=kb; EN-US;q205524
NTFS junction points are useful for alternate mounting.
The point of some key Windows Services are built for exactly this purpose
Reparse points are handy too
NTFS is a great file system, you just need to read the documentation..
That would be really funny if it was true.
It is, alas, false, and junctions do not become "a drive letter", they are virtual folders akin to Linux' directory symlinks (since junctions sadly don't handle the file level but only the directory one).
"The way we can tell it's C# instead of Haskell is because it's nine lines instead of two." -- wadler
I try and keep them relevant.
This story is a case in point. Symlinks are a hack that hides the fact that disk drive based namespaces are a crock. And a crock that's easily solved.
Unix is 30 years old, Linux copies it. Windows is not in the picture.
Linux / BSD et. al. offers very little innovation any more. Instead anything new is coming in through the user space and we end up with stuff like GnomeVFS and smb:// handlers.
The only real place where any real Unix like innovation has occured in recent times was in Bell Labs and the expresssions of that are Plan 9 and Inferno.
You can try some of the concepts out in user space through http://swtch.com/plan9port/
"Plan 9 from User Space (aka plan9port) is a port of many Plan 9 programs from their native Plan 9 environment to Unix-like operating systems.
supported systems : Linux (x86 and PowerPC), FreeBSD (x86), Mac OS X (Power PC), NetBSD (x86), OpenBSD (x86 and PowerPC), SunOS (Sparc)."
There are places where the networks are not touching,and there are places where they are-Boeing's Lori Gunter
Yes, you could essentially re-implement Explorer in every app written by having them handle the *.lnk files the way Explorer does. It sort of is counterproductive. It is much cleaner to have that in the filesystem (or at least the MS APIs to open files) so that it is transparent to apps. Frankly the way the shortcut thing was implemented is a ugly hack. I figured what happened is that they wanted the symlink concept, but didn't want to (or couldn't) change the filesystem. Looks like they're finally (10 years later) decided to do it right.
As far as users are concerned, I suspect they won't know/see the difference. Creating symlinks will just work like creating shortcuts.
NAME SYNOPSIS DESCRIPTION RETURN VALUE
THIS THING CAN TURN ON A DIME, MACROSSZERO STYLE ALSO FUCK BETA, ~NYORON
Mac OS X (and all the way back to System 7 in 1990) did it right by creating aliases which use a two-factor plan to locate its target:
Aliases also store sufficient information about the volume they were located on that the Finder can mount the volume automatically (if it's on the network) or inform the user of exactly why it didn't work. This also allows aliases to cross filesystems, which symlinks can but hard links cannot.
This is why symlinks are such a stupid solution on UNIX, since that OS has no excuse - aliases could have been trivially implemented due to the dual-layer nature of the filesystem (inodes separate from hierarchy).
(Now, I agree completely with how sucky it is that the shell does not support them, and that aspect has been sucky since day 1. However, that has nothing to do with alias technology and everything to do with shell implementation.)
I don't know what kind of crack I was on, but I suspect it was decaf.
NTFS has had hard links since the first version in 1993. Reparse points were added to NTFS in Windows 2000. These work like symbolic links, but can only point at directories, not files.
The really funny thing is that nobody seems to realise that they were in Multics before Unix was even a gleam in Dennis Thompson's eye.
95%++ of the world's computers running Windows NT-based Operating Systems by now
Actually, 95% of the world's computers are embedded microproccessors, most of which don't even run anything classified as an "operating system", let alone windows. I expect that what you meant was that 95% of PC's are running Windows NT based operating systems. I doubt that, there are still plenty of older, pre-XP home machines in use today, so probably as many as 15-20% of PC's are running Windows 9x-based operating systems. You could have just said 95% of the world's PC's are running Win32-based operating systems, and you probably would have been correct.
As far as an application is concerned, there are only 3 different kinds of symlinks:
/dev/kmem or /dev/sda0, what what about /proc? There's no function you can call that will tell you whether something is a real file or a virtual one, so your program is SOL.
1. Object manager symlinks (1 and 5 are both drive letter mappings)
2. Filesystem symlinks (3 and 4 are both NTFS reparse points)
3. Application symlinks (shortcuts are imlemented by OLE)
If you're writing an end-user application, you probably only care about application symlinks if you care at all (because standard dialogs follow them for you). The advantage of shortcuts is that they can track their target if moved to another directory, or even to another computer!
If you are writing a system utility (such as backup or indexing) you have to pay attention to filesystem symlinks (like in Unix) because you can choose to follow them or not. But otherwise your burden is no different than without symlinks because the existence of hard links means that you already have to keep track of which filesystem/file number combinations you have already processed.
Now if you think that's bad, imagine how much worse it is on Unix. The proliferation of filesystems has made it so that you don't even know what's really a file and what isn't. Only a truly naive program would try to backup and restore
dom