node-http-server – Diff between revs 30 and 31

Subversion Repositories:

?pathlinks?

Rev 30 – Rev 32 – Go to most recent revision – Details – Blame – Last modification – View Log

 const path = require('path');
 const fs = require('fs');
 const mime = require('mime');
 const auth = require("http-auth");
 const stream = require('stream');
+const util = require('util');
+const EventEmitter = require('events').EventEmitter;
 // Checks whether userPath is a child of rootPath.
 function isRooted(userPath, rootPath, separator, callback) {
 	userPath = userPath.split(separator).filter(Boolean);
 	rootPath = rootPath.split(separator).filter(Boolean);
 	callback(userPath.length >= rootPath.length &&
 		rootPath.every((e, i) => e === userPath[i]));
+}
 // Serves files.
-function files(config, file, client, callback) {
+function files(self, config, file, client) {
 	// Check if the file is accessible.
 	fs.access(file, fs.constants.R_OK, (error) => {
 		if (error) {
-			callback({
+			self.emit('log', {
 				message: 'Client: ' +
 					client.address + ':' +
 					client.port +
 					' requesting inaccessible path: ' +
 					file,
+				severity: 'warning'
-				severity: 'warning'
+			});
-			}, {
+			self.emit('data', {
 				status: 403,
 				data: new stream.Readable({
 					read(size) {
 						this.push(null);
+					}
 				}),
 				type: 'text/plain'
 			});
 			return;
+		}
-		callback({
+		self.emit('log', {
 			message: 'Client: ' +
 				client.address + ':' +
 				client.port +
 				' sent file: ' +
 				file,
+			severity: 'info'
-			severity: 'info'
+		});
-		}, {
+		self.emit('data', {
 			status: 200,
 			data: fs
 				.createReadStream(file),
 			type: mime
 				.lookup(file)
 		});
 	});
 }
 // Serves a directory listing or the document index in case it exists.
-function index(config, directory, href, client, callback) {
+function index(self, config, directory, href, client) {
 	const root = path.resolve(directory, config.site.index);
 	fs.stat(root, (error, stats) => {
 		if (error) {
 			if (config.site.indexing
 				.some((directory) =>
-					directory.toUpperCase() === href.toUpperCase())) {
-				fs.readdir(directory, (error, paths) => {
+					directory.toUpperCase() === href.toUpperCase())) {
-					if (error) {
+				fs.readdir(directory, (error, paths) => {
-						console.log("listing forbidden...");
+					if (error) {
-						callback({
+						self.emit('log', {
 							message: 'Client: ' +
 								client.address + ':' +
 								client.port +
 								' could not access directory: ' +
+								directory,
-								directory,
+							severity: 'warning'
-							severity: 'warning'
+						});
-						}, {
+						self.emit('data', {
 							status: 500,
 							data: new stream.Readable({
 								read(size) {
 									this.push(null);
+								}
 							}),
 							type: 'text/plain'
-						});
-						return;
+						});
 						return;
 					console.log("sending listing...");
-					callback({
+					self.emit('log', {
 						message: 'Client: ' +
 							client.address + ':' +
 							client.port +
 							' accessed directory listing: ' +
+							directory,
-							directory,
+						severity: 'info'
-						severity: 'info'
+					});
-					}, {
+					self.emit('data', {
 						status: 200,
 						data: new stream.Readable({
 					});
 				});
 				return;
+			}
 			// Could not access directory index file and directory listing not allowed.
-			console.log("no dirindex...");
-			callback({
+			self.emit('log', {
 				message: 'Client: ' +
 					client.address + ':' +
 					client.port +
 					' no index file found and accessing forbiden index: ' +
 					href,
 				severity: 'warning'
-			}, {
+			});
+			self.emit('data', {
 				status: 403,
 				data: new stream.Readable({
 					read(size) {
 						this.push(null);
+					}
+		}
 		// Serve the document index.
 		fs.access(root, fs.constants.R_OK, (error) => {
 			if (error) {
-				callback({
+				self.emit('log', {
 					message: 'Client: ' +
 						client.address + ':' +
 						client.port +
 						' unable to access path: ' +
 						directory,
 					severity: 'warning'
+				});
-				}, {
+				self.emit('data', {
 					status: 403,
 					data: new stream.Readable({
 						read(size) {
 							this.push(null);
+						}
 					}),
 					type: 'text/plain'
 				});
 				return;
 			}
-			callback({
+			self.emit('log', {
 				message: 'Client: ' +
 					client.address + ':' +
 					client.port +
 					' sent file: ' +
 					root,
 				severity: 'info'
+			});
-			}, {
+			self.emit('data', {
 				status: 200,
 				data: fs.createReadStream(root),
 				type: mime.lookup(root)
 			});
 		});
 	});
+}
 // Determines whether the requested filesystem request path is a directory or a file.
-function serve(config, local, href, address, callback) {
+function serve(self, config, local, href, address) {
 	fs.stat(local, (error, stats) => {
 		// Document does not exist.
 		if (error) {
-			callback({
+			self.emit('log', {
 				message: 'Client: ' +
 					address.address + ':' +
 					address.port +
 					' accessing non-existent document: ' +
 					local,
+				severity: 'warning'
-				severity: 'warning'
+			});
-			}, {
+			self.emit('data', {
 				status: 404,
 				data: new stream.Readable({
 					read(size) {
 			return;
+		}
 		if (stats.isDirectory()) {
 			// Directory is requested so provide directory indexes.
-			index(config, local, href, address, callback);
+			index(self, config, local, href, address);
 			return;
+		}
 		if (stats.isFile()) {
 			const file = path.parse(local).base;
 			// If the file matches the reject list or is not in the accept list,
 			// then there is no file to serve.
 			if (config.site.reject.some((expression) => expression.test(file)) ||
 				!config.site.accept.some((expression) => expression.test(file))) {
-				callback({
+				self.emit('log', {
 					message: 'Client: ' +
 						address.address + ':' +
 						address.port +
 						' requested disallowed file: ' +
 						file,
+					severity: 'warning'
-					severity: 'warning'
+				});
-				}, {
+				self.emit('data', {
 					status: 404,
 					data: new stream.Readable({
 						read(size) {
 				});
 				return;
+			}
 			// A file was requested so provide the file.
-			files(config, local, address, callback);
+			files(self, config, local, address);
+		}
 	});
+}
-}
+// Constructor.
+function Handler() {
+	// Create events emitters for logging and data.
+	EventEmitter.call(this);
+};
+// Process a request.
+Handler.prototype.process = function(config, request, response, root) {
+	EventEmitter.call(this);
+	var self = this;
-module.exports = {
+	// Get client details.
-	process: (config, request, response, root, callback) => {
+	const requestAddress = request.socket.address();
-		const requestAddress = request.socket.address();
+	// Get requested URL.
-		const requestURL = url.parse(
+	const requestURL = url.parse(
-			request.url, true
+		request.url, true
-		);
+	);
-		// Perform URL re-writes.
+	// Perform URL re-writes.
-		Object.keys(config.site.rewrite).forEach((key, index) => {
+	Object.keys(config.site.rewrite).forEach((key, index) => {
-			if (config.site.rewrite[key].test(requestURL.path)) {
+		if (config.site.rewrite[key].test(requestURL.path)) {
-				const originalPath = requestURL.path;
+			const originalPath = requestURL.path;
+			requestURL.path = requestURL
+				.path
+				.replace(
+					config.site.rewrite[key], key
+				);
+			requestURL.pathname = url.parse(
-				requestURL.path = requestURL
+					requestURL
-					.path
+					.pathname
-					.replace(
-						config.site.rewrite[key], key
-					);
-				requestURL.pathname = url.parse(
-						requestURL
-						.pathname
-						.replace(
+					.replace(
-							config.site.rewrite[key], key
+						config.site.rewrite[key], key
-						),
+					),
-						true
+					true
-					)
+				)
-					.pathname;
+				.pathname;
-				callback({
+			self.emit('log', {
-					message: 'Rewrite path: ' +
+				message: 'Rewrite path: ' +
-						originalPath +
+					originalPath +
-						' to: ' +
+					' to: ' +
-						requestURL.path,
+					requestURL.path,
-					severity: 'info'
+				severity: 'info'
-				});
+			});
-			}
+		}
-		});
+	});
-		const trimmedPath = requestURL
+	const trimmedPath = requestURL
-			.pathname
+		.pathname
-			.split('/')
+		.split('/')
-			.filter(Boolean)
+		.filter(Boolean)
-			.join('/');
+		.join('/');
-		const requestPath = trimmedPath === '/' ?
+	const requestPath = trimmedPath === '/' ?
-			path.join(root, trimmedPath) :
+		path.join(root, trimmedPath) :
-			path.resolve(root, trimmedPath);
+		path.resolve(root, trimmedPath);
-		fs.realpath(requestPath, (error, resolvedPath) => {
+	fs.realpath(requestPath, (error, resolvedPath) => {
+		// If the path does not exist, then return early.
+		if (error) {
+			self.emit('log', {
+				message: 'Unknown path requested: ' +
+					requestAddress.address + ':' +
+					requestAddress.port +
+					' requesting: ' +
+					requestURL.pathname,
+				severity: 'warning'
+			});
+			self.emit('done', {
+				status: 404,
+				data: new stream.Readable({
+					read(size) {
+						this.push(null);
+					}
+				}),
+				type: 'text/plain'
+			});
+			return;
+		}
+		// Check for path traversals early on and bail if the requested path does not
+		// lie within the specified document root.
-			// If the path does not exist, then return early.
+		isRooted(resolvedPath, root, path.sep, (rooted) => {
-			if (error) {
+			if (!rooted) {
-				callback({
+				self.emit('log', {
-					message: 'Unknown path requested: ' +
+					message: 'Attempted path traversal: ' +
 						requestAddress.address + ':' +
 						requestAddress.port +
+						' requesting: ' +
-						' requesting: ' +
+						requestURL.pathname,
-						requestURL.pathname,
+					severity: 'warning'
-					severity: 'warning'
+				});
-				}, {
+				self.emit('done', {
 					status: 404,
 					data: new stream.Readable({
 						read(size) {
 							this.push(null);
+						}
 					}),
+					type: 'text/plain'
-					type: 'text/plain'
+				});
+				return;
+			}
-				});
-				return;
+			// If authentication is required for this path then perform authentication.
+			if (config.auth.locations.some(
-			}
+					(authPath) => authPath.toUpperCase() === requestURL.pathname.toUpperCase())) {
+				// Create digest authentication.
+				const authentication = auth.digest({
+					realm: config.auth.realm,
+					file: path.resolve(
+						path.dirname(require.main.filename),
+						config.auth.digest
-			// Check for path traversals early on and bail if the requested path does not
+					)
-			// lie within the specified document root.
+				});
-			isRooted(resolvedPath, root, path.sep, (rooted) => {
+				// Requested location requires authentication.
-				if (!rooted) {
+				authentication.check(request, response, (request, response) => {
-					callback({
+					self.emit('log', {
-						message: 'Attempted path traversal: ' +
+						message: 'Authenticated client: ' +
 							requestAddress.address + ':' +
-							requestAddress.port +
-							' requesting: ' +
-							requestURL.pathname,
-						severity: 'warning'
-					}, {
-						status: 404,
-						data: new stream.Readable({
-							read(size) {
-								this.push(null);
-							}
-						}),
-						type: 'text/plain'
-					});
-					return;
-				}
-				// If authentication is required for this path then perform authentication.
-				if (config.auth.locations.some(
-						(authPath) => authPath.toUpperCase() === requestURL.pathname.toUpperCase())) {
-					// Create digest authentication.
-					const authentication = auth.digest({
-						realm: config.auth.realm,
-						file: path.resolve(
+							requestAddress.port +
-							path.dirname(require.main.filename),
-							config.auth.digest
-						)
-					});
-					// Requested location requires authentication.
-					authentication.check(request, response, (request, response) => {
-						callback({
+							' accessing: ' +
-							message: 'Authenticated client: ' +
-								requestAddress.address + ':' +
+							requestURL.pathname,
-								requestAddress.port +
-								' accessing: ' +
+						severity: 'info'
-								requestURL.pathname,
+					});
-							severity: 'info'
+					process.nextTick(() =>
-						});
+						serve(self,
-						serve(config,
-							requestPath,
+							config,
-							requestURL.pathname,
+							requestPath,
-							requestAddress,
-							callback
-						);
-					});
-					return;
-				}
-				// If no authentication is required then serve the request.
-				callback({
-					message: 'Client: ' +
-						requestAddress.address + ':' +
-						requestAddress.port +
+							requestURL.pathname,
-						' accessing: ' +
+							requestAddress
+						)
+					);
+				});
+				return;
+			}
-						requestURL.pathname,
+			// If no authentication is required then serve the request.
+			self.emit('log', {
-					severity: 'info'
+				message: 'Client: ' +
-				});
+					requestAddress.address + ':' +
-				serve(config,
-					requestPath,
-					requestURL.pathname,
+					requestAddress.port +
+					' accessing: ' +
+					requestURL.pathname,
+				severity: 'info'
+			});
+			process.nextTick(() =>
+				serve(self,
+					config,
+					requestPath,
-					requestAddress,
+					requestURL.pathname,
-					callback
+					requestAddress
+				)
+			);
-				);
+		});
+	});
+	return this;