Add support for following links, in VirtualDirectory.

pkg/http_server/lib/src/virtual_directory.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of http_server;
 
 /**
  * A [VirtualDirectory] can serve files and directory-listing from a root path,
  * to [HttpRequest]s.
  *
@@ skipping 37 matching lines @@
   /**
    * Set the [callback] to override the error page handler. When [callback] is
    * invoked, the `statusCode` property of the response is set.
    */
   void setErrorPageHandler(void callback(HttpResponse response));
 }
 
 class _VirtualDirectory implements VirtualDirectory {
   final String root;
 
-  bool _allowDirectoryListing = false;
-  bool _followLinks = true;
+  bool allowDirectoryListing = false;
+  bool followLinks = true;
 
   _VirtualDirectory(this.root);
 
   void serve(Stream<HttpRequest> requests) {
     requests.listen(serveRequest);
   }
 
   void serveRequest(HttpRequest request) {
     var path = new Path(request.uri.path).canonicalize();
 
     if (!path.isAbsolute) {
       return _serveErrorPage(HttpStatus.NOT_FOUND, request);
     }
 
-    _locateResource(new Path(root), path.segments())
+    _locateResource(new Path('.'), path.segments())
         .then((entity) {
           if (entity == null) {
             _serveErrorPage(HttpStatus.NOT_FOUND, request);
             return;
           }
           if (entity is File) {
             entity.openRead().pipe(request.response).catchError((_) {});
           } else {
             _serveErrorPage(HttpStatus.NOT_FOUND, request);
           }
         });
   }
 
   Future<FileSystemEntity> _locateResource(Path path,
                                            Iterable<String> segments) {
-    return FileSystemEntity.type(path.toNativePath(), followLinks: false)
+    Path fullPath() => new Path(root).join(path);
+    return FileSystemEntity.type(fullPath().toNativePath(), followLinks: false)
         .then((type) {
           switch (type) {
             case FileSystemEntityType.FILE:
-              if (segments.isEmpty) return new File.fromPath(path);
+              if (segments.isEmpty) return new File.fromPath(fullPath());
               break;
 
             case FileSystemEntityType.DIRECTORY:
               if (segments.isEmpty) {
-                if (_allowDirectoryListing) return new Directory.fromPath(path);
+                if (allowDirectoryListing) {
+                  return new Directory.fromPath(fullPath());
+                }
               } else {
                 return _locateResource(path.append(segments.first),
                                        segments.skip(1));
               }
               break;
 
             case FileSystemEntityType.LINK:
               if (followLinks) {
-                // TODO
+                return new Link.fromPath(fullPath()).target()
+                    .then((target) {
+                      var targetPath = new Path(target).canonicalize();
+                      if (targetPath.isAbsolute) return null;
+                      targetPath = path.append('..').join(targetPath)

[Søren Gjesse, 2013/06/24 08:08:53]

Why do you need this additional ..?

[Anders Johnsen, 2013/06/24 08:21:16]

To 'pop' the link. Changed to use path.directoryPath.join.

+                          .canonicalize();
+                      if (targetPath.segments().isEmpty ||
+                          targetPath.segments().first == '..') return null;
+                      return _locateResource(targetPath.append(segments.first),
+                                             segments.skip(1));
+                    });
               }
               break;
           }
           // Return `null` on fall-through, to indicate NOT_FOUND.
           return null;
         });
   }
 
   void _serveErrorPage(int error, HttpRequest request) {
     request.response.statusCode = error;
     request.response.close();
   }
 }