Using IIS URL Rewriting And CGI.PATH_INFO With IIS MOD-Rewrite

# IIS Mod-Rewrite configuration file
# Turn on the rewrite rules for this access file. This will
# will handle all requests based off of this directory.

RewriteEngine On


# If the given file or directory exits, then don't do any
# redirects - simply pass the request on to the file system.

RewriteCond %{REQUEST_FILENAME} -f [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule .? - [L]


# If the given file does not exist, then rewrite the request
# to use the front controller with the given file set as the
# path info for the script. We cannot make any assumptions
# about the file name as it might be purely a directory path
# without any file extension.
#
# NOTE: Because there is going to be a one-directory difference
# in browser path perception depending on whether or not the
# path info is entered manually, we have to flag that this was
# a rewrite for proper path calculations.

RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.+)$ index.cfm/$1?_rewrite [NC,L,QSA]

<cfcomponent
	output="false"
	hint="I define the application settings and event handlers.">

	<!--- Define the application. --->
	<cfset this.name = hash( getCurrentTemplatePath() ) />
	<cfset this.applicationTimeout = createTimeSpan( 0, 0, 5, 0 ) />

	<!--- Define page request settings. --->
	<cfsetting
		requesttimeout="10"
		showdebugoutput="false"
		/>


	<cffunction
		name="onApplicationStart"
		access="public"
		returntype="boolean"
		output="false"
		hint="I initialize the application.">

		<!--- Define the local scope. --->
		<cfset var local = {} />

		<!---
			As part of the application initialization, we
			want to figure out some constants surrounding our
			application location:

			RootDirectory
			The root directory of our application.

			RootScript
			The root script path of our application. This is in
			the case where our application lives below the web
			root of the server.

			RootUrl
			The root URL of our application.
		--->

		<!---
			Determining the root path is easy - we always know
			that it is this directory (the one containing the
			Application.cfc component).
		--->
		<cfset application.rootDirectory = getDirectoryFromPath(
			getCurrentTemplatePath()
			) />

		<!---
			To find the Root Script, we have to do a bit more
			calculation; we need to figure out the difference
			in the length between the root directory and
			requested directory and then subtract that depth
			from the requested script.
		--->

		<!---
			Start off with the current script directory as the
			root directory.
		--->
		<cfset application.rootScript = getDirectoryFromPath(
			cgi.script_name
			) />

		<!---
			Comparing the expanded root script to the root
			directory, we can now figure out how many directories
			below the application root we are.
		--->
		<cfset local.scriptDepth = (
			listLen( expandPath( application.rootScript ), "\/" ) -
			listLen( application.rootDirectory, "\/" )
			) />

		<!---
			Based on the script depth, we can now move up the path
			the corresponding number of steps.
		--->
		<cfset application.rootScript = reReplace(
			application.rootScript,
			"([^\\/]+[\\/]){#local.scriptDepth#}$",
			"",
			"one"
			) />

		<!---
			Now that we have our root script, we can easily find
			our root URL. The only special case we need to worry
			about is when the root script is "/". In that case,
			we are in the root of the web directory and don't need
			to append the script.
		--->
		<cfset application.rootUrl = (
			"http://" &
			cgi.server_name
			) />

		<!---
			Check to see if we have a script name worth appending
			to the URL.
		--->
		<cfif !reFind( "^[\\/]$", application.rootScript )>

			<!--- Append root script to URL. --->
			<cfset application.rootUrl &= application.rootScript />

		</cfif>

		<!--- Return true so the page request can process. --->
		<cfreturn true />
	</cffunction>


	<cffunction
		name="onRequestStart"
		access="public"
		returntype="boolean"
		output="false"
		hint="I intialize the page request.">

		<!--- Define arguments. --->
		<cfargument
			name="script"
			type="string"
			required="true"
			hint="I am the requested script name."
			/>

		<!--- Define the local scope. --->
		<cfset local = {} />

		<!---
			Combine the form and url scopes into a common request
			attributes collection so that we don't have to know
			what scope a variable came from.
		--->
		<cfset request.attributes = duplicate( url ) />
		<cfset structAppend( request.attributes, form ) />

		<!---
			Param the default action variable - this will be
			what the front-controller (and sub-controllers) use
			to figure out what scripts to execute.
		--->
		<cfparam
			name="request.attributes.do"
			type="string"
			default=""
			/>

		<!---
			Split the request variable into an array such that
			we can examine the parts of it in front-controller
			control flow. We are going to assume that the raw
			action variable is a dot-delimmited list of actions.
		--->
		<cfset request.do = listToArray(
			request.attributes.do,
			"."
			) />


		<!---
			Now that we have our action variable set up and based
			of the query string, let's check to see if the current
			page request is actually a URL Rewriting as determined
			by a PATH_INFO that is diffrent from the SCRIPT_NAME
			available in the CGI object (normally, these two are
			the same value unless path info is used explicitly).

			If so, we might have to translate the PATH_INFO into
			a new action AND a set of query string parameters.
		--->
		<cfif (cgi.script_name neq cgi.path_info)>

			<!---
				Create a normalized version of the script as taken
				from the path_info variable. Essentially, we are
				removing any leading or trailing slashes.
			--->
			<cfset local.script = reReplace(
				cgi.path_info,
				"^[\\/]+|[\\/]+$",
				"",
				"all"
				) />

			<!---
				Now that we have our script name normalized, let's
				use some regular expression pattern matching to
				see if we need to update our action varaible or
				any other URL variables.
			--->
			<cfif reFind( "^contact\b", local.script )>

				<!--- Routing to contact section. --->
				<cfset request.do = [ "contact" ] />

			<cfelseif reFind( "^about\b", local.script )>

				<!--- Routing to about section. --->
				<cfset request.do = [ "about" ] />

			<cfelseif reFind( "^blog/[\d+]", local.script )>

				<!--- Routing to blog section. --->
				<cfset request.do = [ "blog" ] />

				<!--- Get ID of blog post. --->
				<cfset request.attributes.id = listGetAt(
					local.script,
					2,
					"/"
					) />

			<cfelseif reFind( "^blog\b", local.script )>

				<!--- Routing to blog section. --->
				<cfset request.do = [ "blog" ] />

			<cfelse>

				<!---
					We could not match the requested URL against
					any of our SES patterns. As such, this is
					truly an invalid file request. As such, let's
					return a true 404 error.
				--->
				<cfheader
					statuscode="404"
					statustext="Page Not Found"
					/>

				<!---
					Return out with false so the request of the
					page will not get processed.
				--->
				<!--- <cfreturn false /> --->

			</cfif>

		</cfif>


		<!---
			Get the relative web root path from our current page
			(this will allow our traversal path to always be
			relative, rather than a hard-coded root path, which
			is the ultra lame... like really really lame).

			When calculating this path, we need to take into
			account BOTH the current file as well as any PATH_INFO
			value since the browsers views them both as adding to
			the depth of the page request.

			Get the initial web root based only on the requested
			page template.
		--->
		<cfset request.webRoot = repeatString(
			"../",
			(
				listLen( getDirectoryFromPath( expandPath( arguments.script ) ), "\\/" ) -
				listLen( application.rootDirectory, "\\/" )
			)) />

		<!---
			Now that we have the base web root from the requested
			template, we have to see if there is any extra pathing
			being used. As before, we will determine this to be
			true if the script name and the path info are different
			values.
		--->
		<cfif (cgi.script_name neq cgi.path_info)>

			<!---
				Because there will be a one directory difference
				in browser perception if the PATH_INFO was entered
				manually, versus if this was a rewrite, we have to
				check for the rewrite flag.
			--->
			<cfif structKeyExists( url, "_rewrite" )>

				<!---
					There will be an offset required when using
					the PATH_INFO for calculation.
				--->
				<cfset local.webRootOffset = 1 />

				<!---
					Delete the rewrite flag as it will not be
					needed for anything else in this request.
				--->
				<cfset structDelete( url, "_rewrite" ) />
				<cfset structDelete( request.attributes, "_rewrite" ) />

			<cfelse>

				<!---
					The PATH_INFO was entered manually. As such,
					there will be no offset needed for the web
					root.
				--->
				<cfset local.webRootOffset = 0 />

			</cfif>

			<!---
				We are using extra PATH_INFO. The good news here
				is that the browser acts the SAME whether or not
				the pathing is done via the URL or via the rewrite
				since they both add the same depth to the request.
			--->
			<cfset request.webRoot &= repeatString(
				"../",
				(
					listLen( (cgi.path_info & "-" ), "\/" ) -
					local.webRootOffset
				)) />

		</cfif>


		<!--- Return true so that the page can be processed. --->
		<cfreturn true />
	</cffunction>


	<cffunction
		name="onRequest"
		access="public"
		returntype="void"
		output="true"
		hint="I execute the page request.">

		<!--- Define arguments. --->
		<cfargument
			name="script"
			type="string"
			required="true"
			hint="I am the requested script name."
			/>

		<!--- Include the requested page. --->
		<cfinclude template="#arguments.script#" />

		<!--- Return out. --->
		<cfreturn />
	</cffunction>

</cfcomponent>