Simulate Server.Execute and Server.Transfer in ASP 2.0

By Francis Chau

Introduction
ASP 3.0 provides two useful functions not available on ASP 2.0: Server.Execute and Server.Transfer. In this article, I'll demonstrate a simple technique to simulate these functions in ASP 2.0 and give a few pros and cons on its usage in general. If you are not familiar with Server.Execute and Server.Transfer, read A Look at ASP 3.0 For More Information for a good intro. Also, it would be to your benefit to read the article, Understanding VBScript: Runtime Code Evaluation by Dino Esposito at Windows Scripting Solutions. Dino Esposito's article provides a lot of detail about VBScript's Execute, ExcuteGlobal, and Eval statements. Finally, if you are curious as to what version of ASP you are using, be sure to check out this FAQ. Let's get started!

- continued -

Simulating Server.Execute and Server.Transfer
The Server.Execute function accepts a URL parameter, stops execution of the current page (where the call to the function is made), and transfers the current environment to the new page. When that new page finishes execution, then control returns to the calling page just after where the Server.Execute was called. (Server.Transfer works the same, however, upon completion of the execution of the new page, processing ends.) To simulate this functionality in ASP 2.0, we need to do the following:

Obtain the file contents of target page to execute
Use VBScript's Execute statement (or ExecuteGlobal statement) to process the file contents of our target page. (For more information on Execute be sure to read: Using the Eval and Execute Functions.)

First, let's write a function to obtain the file contents of the page and prepare it to be processed by the Execute statement:

Listing 1 (page1.asp)

Function GetFileContentsForExecution(sTargetFile) Dim oFSO, sContents 'Obtain a reference to the FileSystemObject Set oFSO = Server.CreateObject("Scripting.FileSystemObject") 'Obtain the file contents sContents = oFSO.OpenTextFile(Server.MapPath(".") & _ "\" & sTargetFile).ReadAll Set oFSO = Nothing 'reference to the FileSystemObject 'Remove the ASP scripting tags sContents = Replace (sContents, "<" & "%", "") sContents = Replace (sContents, "%" & ">", "") GetFileContentsForExecution = sContents End Function

In our GetFileContentsForExecution() function, we first create and obtain a reference to the FileSystemObject. (For more on the FileSystemObject check out the FileSystemObject FAQ Category.)

Dim oFSO, sContents 'Obtain a reference to the FileSystemObject Set oFSO = Server.CreateObject("Scripting.FileSystemObject")

Then we do a few things in the next line:

'Obtain the file contents sContents = oFSO.OpenTextFile(Server.MapPath(".") & _ "\" & sTargetFile).ReadAll

Starting with our FileSystemObject reference (oFSO), we call the OpenTextFile() method passing the absolute file path to the target file as the argument. As you can see, we constructed the absolute file path on the fly using Server.MapPath("."). Since the OpenTextFile() method returns a TextStream object, we use the ReadAll method to "read all" of the contents of the file into our sContents variable.

Now that we've obtained the contents of the file, we can release the reference to the FileSystemObject (i.e., Set oFSO = Nothing 'reference to the FileSystemObject). (No sense in keeping resources, if it's not needed, right?)

It's important to note that the VBScript Execute and ExecuteGlobal statements expect only pure VBScript statements to be passed as its argument, therefore we must remove the ASP Scripting delimiters <% and %>. We'll see shortly that our file will have these delimiters as a precaution to protect our code from prying eyes.

Finally, to wrap up the GetFileContentsForExecution function, we take the file contents that we want to process and send it back as the return value of our function (GetFileContentsForExecution = sContents).

Before we move on to see how our GetFileContentsForExecution() function is used to assist in simulating Server.Execute and Server.Transfer, let's note the contents of our target file whose ASP code we want to execute:

Listing 2 (page2.asp)

<% Response.Write "Our Target File is " & sTargetFile Response.Write "<BR>but we are processing from " & _ Request.ServerVariables("SCRIPT_NAME") & "." %>

In this page, we have two Response.Write statements that will provide us information about the target file we are processing and in what context (page) we are processing it from. Notice that we've added the ASP Scripting tags <% and %>. This enables us to test and debug the page by itself by loading it directly in the browser. And if a wandering browser happened upon it, then the page would be processed vs. having all of our ASP source code available for viewing.

Now that we have our GetFileContentsForExecution function and know what script we want to execute, we need to add code to page1.asp to make the simulated Server.Execute call to the contents in page2.asp. To do this, add the following to page1.asp:

Listing 3 (added to page1.asp)

Dim sTargetFile, sTargetFileContents sTargetFile = "page2.asp" 'Get the contents of the file to execute sTargetFileContents = GetFileContentsForExecution(sTargetFile) Execute sTargetFileContents

Here, we declare a variable to hold the name of the file we want to execute. Then we use our GetFileContentsForExecution() function to get the file contents. Lastly, we use VBScript's Execute statement on the sTargetFileContents that contains the target file's VBScript code. (For a quick description of Execute, see this page.)

Here's the output we get when viewing page1.asp in the browser:

Our Target File is page2.asp but we are processing from page1.asp.

If we want to simulate a Server.Transfer, then we simply end page execution after using the Execute statement by using a Response.End statement like so:

Listing 4 (added to page1.asp to do Server.Transfer)

sTargetFile = "page2.asp" 'Get the contents of the file to execute sTargetFileContents = GetFileContentsForExecution(sTargetFile) Execute sTargetFileContents Response.End

Summary
Here are a few pros and cons with using this technique:

Pros

Simulates Server.Execute and Server.Transfer in ASP 2.0
Compatible with ASP 3.0
Easily integrated into existing code
Modularize code into pages
Run-time code evaluation
Provides a technique for dynamic #includes. (Read The low-down on #includes for a discussion on what dynamic includes are...)

Cons

Can only process pure script, however, you can output HTML using Response.Write
Possible performance implications due to accessing FileSystemObject for each call to page (Of course, you could implement some type of caching.)

So far, we have learned a technique that used the Execute statement to execute code contained in a separate file. This technique can be used to simulate the Server.Execute and Server.Transfer functionality available in ASP 3.0, albeit with some limitations. Although I didn't show it here, this same technique can be used to load functions, subroutines and VBScript class objects into memory as described in Dino Esposito's article (read "An Example: The Include Function" portion of his article Understanding VBScript: Runtime Code Evaluation).

Happy Programming!

By Francis Chau