Pratidhwani

Create a Virtual Directory and Edit its Properties in IIS using C#

rpdash — Wed, 11 Aug 2004 15:47:00 GMT

Back when I was working at Qwest Communications (Summer of ’02 precisely), I was given the task to create a virtual directory for reports on every server at my hand. The path was local to each computer and all the authentication requirements were identical. I could as well have gone to IIS Administrative console on each machine but I thought to take a shot at C#.

First, I’d to dig thro the bitmask values for the properties of a virtual directory on the IIS server. I’d to look no further than the following Microsoft documentation online (http://www.microsoft.com/windows2000/en/server/iis/default.asp?url=/windows2000/en/server/iis/htm/asp/apro1cms.htm ). Based on my requirements I created an XML config (WebSettings.Config) file which looks as follows:

WebSettings.Config

xml version="1.0" encoding="utf-8" ?>

WebSettings>

-- Directory to be set for virtual folder -->

ActualDirectory>E:\logs\imaedi\REPORTSActualDirectory>

ServerName>localhostServerName>

IISRootPath>IIS://IISRootPath>

VirtualDirectorySchemaName>IIsWebVirtualDirVirtualDirectorySchemaName>

WebServicePath>/W3SVC/1WebServicePath>

ActiveDirectoryRootPath>RootActiveDirectoryRootPath>

VirtualDirectoryName>DRBINTRFCRPRTSVirtualDirectoryName>

Authentication Bitmask Values

Constant Value Description

MD_AUTH_ANONYMOUS 0x00000001 Anonymous authentication available.

MD_AUTH_BASIC 0x00000002 Basic authentication available.

MD_AUTH_NT 0x00000004 Windows authentication schemes available.

-->

AuthFlagValue>0x00000001AuthFlagValue>

DefaultLogonDomain>YourCorporatePDCDefaultLogonDomain>

Access Bitmask Values

Constant Value Description

MD_ACCESS_READ 0x00000001 Allow read access.

MD_ACCESS_WRITE 0x00000002 Allow write access.

MD_ACCESS_EXECUTE 0x00000004 Allow file execution (includes script permission).

MD_ACCESS_SOURCE 0x00000010 Allow source access.

MD_ACCESS_SCRIPT 0x00000200 Allow script execution.

MD_ACCESS_NO_REMOTE_WRITE 0x00000400 Local write access only.

MD_ACCESS_NO_REMOTE_READ 0x00001000 Local read access only.

MD_ACCESS_NO_REMOTE_EXECUTE 0x00002000 Local execution only.

MD_ACCESS_NO_REMOTE_SCRIPT 0x00004000 Local host access only.

-->

AccessFlagValue>0x00000205AccessFlagValue>

SSL Bitmask Values

Constant Value Description

MD_ACCESS_SSL 0x00000008 SSL permissions required.

MD_ACCESS_NEGO_CERT 0x00000020 Client certificate optional.

MD_ACCESS_REQUIRE_CERT 0x00000040 Client certificate required.

MD_ACCESS_MAP_CERT 0x00000080 Server will map client certificate to Windows account.

MD_ACCESS_SSL128 0x00000100 SSL permissions with 128-bit key required.

-->

AccessSSLFlagValue>0x00000000AccessSSLFlagValue>

DefaultDocument>default.aspDefaultDocument>

Directory Browsing Bitmask Values

Constant Value Description

MD_DIRBROW_SHOW_DATE 0x00000002 Show date.

MD_DIRBROW_SHOW_TIME 0x00000004 Show time.

MD_DIRBROW_SHOW_SIZE 0x00000008 Show file size.

MD_DIRBROW_SHOW_EXTENSION 0x00000010 Show file name extension.

MD_DIRBROW_LONG_DATE 0x00000020 Show full date.

MD_DIRBROW_LOADDEFAULT 0x40000000 Load default page, if it exists.

MD_DIRBROW_ENABLED 0x80000000 Enable directory browsing.

-->

DirBrowseFlagValue>0xC000003EDirBrowseFlagValue>

For details of these properties and their bit mask values visit

http://www.microsoft.com/windows2000/en/server/iis/default.asp?url=/windows2000/en/server/iis/htm/asp/apro1cms.htm

-->

WebSettings>

The beauty of bitmask values is that you can add them to have your own custom requirements. For example, if I want to have both Anonymous authentication (bitmask: 0x00000001) and Integrated Windows authentication (bitmask: 0x00000004), I can set the AuthFlagValue to 0x00000005. Similarly when I am setting AccessFlagValue to 0x00000205, I am allowing script execution (bitmask: 0x00000200), file execution (bitmask: 0x00000004) and read access (bitmask: 0x00000001). Quite neat. Huh?

The next task was to have a class that can hold the values read from the config file. There are several ways to do this but it is out of the scope of the present discussion. In the meanwhile, you may look at the following skeleton and have your own constructor implementation to populate from the config file.

WebSettings.cs

using System;

using System.IO;

using System.Xml;

using System.Globalization;

namespace WebHosting {

public class WebSettings {

// Private variables defined

public string actualDirectory = null;

public string serverName = null;

public string iisRootPath = null;

public string virtualDirectorySchemaName = null;

public string webServicePath = null;

public string activeDirectoryRootPath = null;

public string virtualDirectoryName = null;

public int authFlagValue = 0;

public string defaultLogonDomain = null;

public int accessFlagValue = 0;

public int accessSSLFlagValue = 0;

public string defaultDocument = null;

public int dirBrowseFlagValue = 0;

public WebSettings() {

// Populate from the Xml Config File

}

The last and the most important task was to tell the IIS somehow about our intentions. “Active Directory” came to the rescue here. .NET provides a System.DirectoryServices namespace which gives us a way to control Active Directory objects. As Microsoft puts “The System.DirectoryServices namespace provides easy access to Active Directory from managed code. The namespace contains two component classes, DirectoryEntry and DirectorySearcher, which use the Active Directory Services Interfaces (ADSI) technology.”

So I had the HostWeb.cs file, which contained the entry point of the console application. When run, it looks for the virtual directory and if not found, creates one. Then it sets the properties specified in the config file in terms of the bitmask values and commits the changes. If in future, you need to change some of the properties, you can change it in the config file and rerun the application to apply the new values.

HostWeb.cs

using System;

using System.IO;

using System.DirectoryServices;

namespace WebHosting {

public class HostWeb {

[STAThread]

public static void Main(string[] args) {

WebSettings ws = null;

try {

ws = new WebSettings();

}

catch (Exception e) {

// Your exception handling

return;

}

// Create web service

try {

createVirtualDirectory(ws);

}

catch (Exception e) {

// Your exception handling

}

return;

}

public static void createVirtualDirectory (WebSettings ws) {

DirectoryEntry iisWebService = null;

DirectoryEntry webServiceRoot = null;

DirectoryEntry virDir = null;

try {

iisWebService = new DirectoryEntry(ws.iisRootPath + ws.serverName + ws.webServicePath);

webServiceRoot = iisWebService.Children.Find(ws.activeDirectoryRootPath, ws.virtualDirectorySchemaName);

}

catch (Exception e) {

throw new Exception("Could not connect to " + ws.serverName + " or its child " + ws.activeDirectoryRootPath + " in schema " + ws.virtualDirectorySchemaName, e);

}

// Find the virtual directory, if not found, create it

try {

virDir = webServiceRoot.Children.Find(ws.virtualDirectoryName, ws.virtualDirectorySchemaName);

}

catch (System.IO.DirectoryNotFoundException) {

virDir = webServiceRoot.Children.Add(ws.virtualDirectoryName, ws.virtualDirectorySchemaName);

virDir.CommitChanges();

}

catch (Exception e) {

Console.WriteLine(e.ToString());

return;

}

// Set Access depending on bit mask values

if (virDir != null) {

try {

// Authentication

virDir.Properties["AuthFlags"].Value = ws.authFlagValue;

virDir.Properties["DefaultLogonDomain"].Value = ws.defaultLogonDomain;

// Access Type

virDir.Properties["AccessFlags"].Value = ws.accessFlagValue;

// Set SSL

virDir.Properties["AccessSSLFlags"].Value = ws.accessSSLFlagValue;

// Default Path and Page to be displayed

virDir.Properties["Path"].Value = ws.actualDirectory;

virDir.Properties["DefaultDoc"].Value = ws.defaultDocument;

// Directory Browsing

virDir.Properties["DirBrowseFlags"].Value = ws.dirBrowseFlagValue;

// Commit Changes

virDir.CommitChanges();

webServiceRoot.CommitChanges();

iisWebService.CommitChanges();

}

catch (Exception e) {

Console.WriteLine(e.ToString());

throw new Exception("Virtual Directory " + ws.virtualDirectoryName + " can not be created or updated", e);

}

Summary: In this article, we learned how to create a virtual directory in IIS server from .NET environment using ADSI technology. We used classes from System.DirectoryServices namespace and used the Microsoft documentation to set the properties of the virtual directory in terms of bitmask values.

N.B.: All the code above was fully tested in .NET 1.0 environment. If you find any difficulty running the above code, kindly set a note to the author and he’ll correct the code with all the due appreciation to the sender.

Ram Dash is a ASP.NET, C# developer and can be reached at “ram underscore dash at fastmail dot fm”. If you wish to reprint this article, a note with the link to the author would suffice.

Unified Search Engine

rpdash — Wed, 11 Aug 2004 15:44:00 GMT

Quick and Dirty method to Combine MS Search Service, Indexing Service and SQL Server to provide a unified search engine for your ASP.NET website

Recently I was developing a site for a company and as usual they needed me to write a search engine. They had the contents in .aspx pages, not a problem, but they also had forums whose contents were collated in a database table, in a column to be precise. They wanted me to display the results from these two sources through a common search engine. Since I had little time to write a search engine of my own, I put the power of MS Search Service, Indexing Service and SQL Server together to do the task for me. There is a lot of scope for enhancement but here is how you can implement a very basic yet powerful search engine of your own.

STEP I: Create a Web Catalog in Indexing Service

By default, the indexing service has two catalogs, one for the file system (System) and one for the default web site (Web).

If Web catalog is not present, you can easily create one.

1. Open Control Panel --> Administrative Tools --> Computer Management

2. Scroll down to Computer Management --> Services and Applications --> Indexing Service in the MMC

3. Right click Indexing Service and choose New --> Catalog

4. In the name field give Web and choose C:\Inetpub as the location

5. Right click the newly created catalog, choose Properties. Click on the Tracking tab of the properties window. Select "Default Web Site" as the WWW server.

6. Restart Indexing Service

7. Go to Computer Management --> Services and Applications --> Services and configure Indexing Service as Automatic if it is Manual or Disabled.

STEP II: Optimize ASPX and ASCX files for full-text search

By default, the *.aspx and *.ascx file types are treated as text files which are not optimized for searching by the Indexing Service. To optimize searching for these two file types copy the following into a new .reg file and run it in your computer. The customary warning: Editing registry incorrectly may prohibit your computer to run properly. Edit the registry at your own risk. I may not be held responsible for the damage you do to your computer by incorrectly following the steps below.

REGEDIT4

[HKEY_CLASSES_ROOT\.aspx\PersistentHandler]

@="{eec97550-47a9-11cf-b952-00aa0051fe20}"

[HKEY_CLASSES_ROOT\.ascx\PersistentHandler]

@="{eec97550-47a9-11cf-b952-00aa0051fe20}"

You must have Index files with Unknown Extensions enabled. To enable this, right click on Indexing Service, choose Properties and click on Generation tab on the window. Check Index files with Unknown Extensions checkbox. Restart the computer, stop Indexing Service, delete all the contents of the catalog.wci folder (not the folder itself) corresponding to your catalog (in this case C:\Inetpub\catalog.wci), start the Indexing Service and allow it to rebuild the catalog.

STEP III: Using Full-Text Searches directly in ASP.NET Applications

This is not actually a step but a side step where you can take a pause for a moment and test whether your newly created catalog is returning some results. If you don’t have a database to worry about, then this might be your last step unless you want to link the Indexing Service with SQL Server.

Indexing service exposes itself via the OLEDB provider MSIDXS. You can take the full advantage of the server in your ASP.NET application via ADO.NET. If you have a TextBox (TextBox1), a Button (Button1) and a DataGrid (DataGrid1) on your web form and the Web catalog in place, this might as well be the content of your button click handler:

using System.Data;

using System.Data.OleDb;

…….

private void Button1_Click(object sender, EventArgs e)

{

string strCatalog = "Web";

string strQuery = "Select Filename, Rank, VPath from SCOPE() where FREETEXT('" + TextBox1.Text + "')";

string connString = "Provider=MSIDXS.1;Integrated Security .='';Data Source='" + strCatalog + "'";

OleDbConnection Connection = new OleDbConnection(connString);

Connection.Open();

OleDbDataAdapter da = new OleDbDataAdapter(strQuery, Connection);

DataSet ds = new DataSet();

da.Fill(ds);

Connection.Close();

DataView source= new DataView(ds.Tables[0]);

DataGrid1.DataSource = source;

DataGrid1.DataBind();

}

STEP IV: Link Indexing Service with SQL Server

The next step is to link the Indexing Service with your SQL Server. Open Query Analyzer or your favourite SQL script editor. Run the following script.

EXEC

sp_addlinkedserver FTIndexWeb, 'Index Server', 'MSIDXS', 'Web'

where FTIndexWeb is the chosen linked server name, and Web is the catalog name you created in STEP I.

STEP V: Querying Indexing Service via SQL Server

Let's modify the previous query and run it in SQL server. Run the following query in Query Analyzer.

SELECT Q.FileName, Q.Rank, Q.VPath

FROM OpenQuery(

FTIndexWeb,

'Select Filename, Rank, VPath

from SCOPE()

where FREETEXT(''Calcutta'')

ORDER BY Rank DESC'

) AS Q

Replace FTIndexWeb with whatever linked server name you chose in step IV and Calcutta with your search keyword(s).

STEP VI: Enabling a table/column in SQL Server for full-text searches

Open Enterprise Manager. Browse to Console Root--> Microsoft SQL Servers --> --> --> Databases --> --> Tables. Check two things before you proceed.

1. The table where you want full-text searching enabled, must have some unique constraint. If a primary key or a unique constraint is not present, create an "ID" column and apply a unique constraint.

2. Microsoft Search Service (mssearch.exe) must have been enabled and running in your computer. If not, browse to Computer Management --> Services and Applications --> Services in Computer Management MMC and configure Microsoft Search Service as Automatic and start the service.

On the Enterprise Manager MMC, right click on your table and choose Full-Text Index Table --> Define Full-Text Indexing on a table. If the option is grayed out, check #2 above.

Click Next on the popped up wizard .Choose the unique index and click Next. Choose the columns where you want indexing enabled. Click Next. Give the catalog a name and specify a physical location to store the catalog. Click Next. If you want the control over how and when the catalog is filled (full or incremental) click on New Catalog Schedule. After configuring it, come back to Full-Text Indexing Wizard and click Next. Click Finish. The wizard takes a minute or two to setup the catalog.

STEP VII: Querying Full-Text Catalog in SQL Server

Let’s test the newly created catalog in SQL Server. Run the following query.

SELECT FT_TBL.subject, KEY_TBL.RANK, FT_TBL.topicid

FROM forums_topics AS FT_TBL,

CONTAINSTABLE ( forums_topics

, message

, '"Calcutta"' )

AS KEY_TBL

WHERE FT_TBL.topicid = KEY_TBL.[KEY]

ORDER BY KEY_TBL.RANK DESC

Forums_Topics is the table name and Message is the column name on which full-text catalog is built. Replace Calcutta with your search keyword(s).

STEP VIII: Combining the results

The steps to combine the results would be to

1. Create a temporary table

2. Insert the results of the first query

3. Insert the results of the second query

4. Query the temp table

5. Drop the temp table

We need a stored procedure for this and here it is:

CREATE PROCEDURE sp_Accounts_SearchSite

@FreeText varchar (255)

SET NOCOUNT ON

CREATE TABLE #tempresults(

ID int IDENTITY,

FileNames varchar (255),

Rank int,

VPath varchar(255))

DECLARE @sql nvarchar(1000)

SET @sql = N'INSERT INTO #tempresults(FileNames, Rank, VPath) ' + CHAR(13) +

N'SELECT Q.FileName As FileNames, Q.Rank As Rank, Q.VPath As VPath ' + CHAR(13) +

N'FROM OpenQuery(FTIndexWeb, ''Select Filename, Rank, VPath from SCOPE() where FREETEXT(''''' + @FreeText + ''''')'' ) AS Q'

EXECUTE sp_executesql @sql

SET @SQL = N'INSERT INTO #tempresults(FileNames, Rank, VPath) ' + CHAR(13) +

N'SELECT FT_TBL.subject As FileNames, KEY_TBL.RANK As Rank, FT_TBL.topicid As VPath ' + CHAR(13) +

N'FROM forums_topics AS FT_TBL, ' + CHAR(13) +

N'CONTAINSTABLE ( forums_topics ' + CHAR(13) +

N', message' + CHAR(13) +

N', ''"' + @FreeText + '"'' ) ' + CHAR(13) +

N'AS KEY_TBL' + CHAR(13) +

N'WHERE FT_TBL.topicid = KEY_TBL.[KEY] '

EXECUTE sp_executesql @sql

SELECT FileNames, Rank, VPath from #tempresults ORDER BY Rank DESC

DROP TABLE #tempresults

SET NOCOUNT OFF

STEP IX: Modify your .NET Application

The rest is a piece of cake. Your Button click handler should now look like this:

using System.Data;

using System.Data.SqlClient; // Bye Bye OleDb

…….

private void Button1_Click(object sender, EventArgs e)

{

string connString = @"server=****;database=****;uid=****;pwd=****;";

string storedProcName = "sp_Accounts_SearchSite";

SqlConnection Connection = new SqlConnection(connString);

Connection.Open();

SqlCommand command = new SqlCommand( storedProcName, Connection );

command.CommandType = CommandType.StoredProcedure;

command.Parameters.Add("@FreeText", TextBox1.Text);

SqlDataAdapter sqlDA = new SqlDataAdapter();

sqlDA.SelectCommand = command;

DataSet dataSet = new DataSet();

sqlDA.Fill( dataSet, "mySearchResults" );

Connection.Close();

DataView source = new DataView(dataSet.Tables[0]);

DataGrid1.DataSource = source;

DataGrid1.DataBind();

}

The grid will show results from your file system as well as from your database tables. With everything indexed, the result is lightening fast for hundreds of results if not millions.

Many of you might think that there remains a lot to be told. But didn’t I say it was quick and dirty? No pun intended. To learn more about how to compose your own queries for full-text searches, visit the MSDN website at http://msdn.microsoft.com. With little logic of your own, you can have a nice search engine which would query different sources differently based on your own requirements. For example, you can redefine the scope (Deep Copy Traversal, Swallow Copy Traversal ring a bell?) and can do regular expression searches. You are the one to set your own limit.

Ram Dash is a ASP.NET, C# developer and can be reached at “ram underscore dash at fastmail dot fm”. If you wish to reprint this article, a note with the link to the author would suffice.