You had me at "Hello World" : Programming

How to Give Authenticated Users or Everyone Access to Your Share Programmatically

HelloWorld — Mon, 13 Jul 2009 19:41:40 GMT

Another follow-up from my previous article, Programmatically Configuring Permissions on a Share, David B asked a question, how to share a folder to Everyone, instead of to a specific users. This article will answer that question, based on the code on my previous article.

That is an interesting question, since ‘Everyone’ can be replaced with ‘Authenticated Users’, ‘Network Service’, etc.

First, if you need only to give Everyone read-only access permission, the easiest thing is to set the DACL property of Win32_SecurityDescriptor to null. This is not equal with an array of null. An array of null will lock everyone out from this share.

ManagementObject secDescriptor = new ManagementClass(new ManagementPath("Win32_SecurityDescriptor"), null);
secDescriptor["ControlFlags"] = 4; //SE_DACL_PRESENT 
secDescriptor["DACL"] = null;

If you need to be more explicit, or you need to assign other security principal different access, that method above will not work. As soon as you assign someone access to the share, ‘Everyone’ will lose its read access.

To assign the permission explicitly, the key is to form the correct Win32_Trustee to represent that special account (Network Service, Everyone, Authenticated Users, etc.). Take a look at System.Security.Principal.WellKnownSidType enum. It has a number of well known sid that you might be interested with.

What needs to be done is to assign the SID property of the Win32_Trustee object with the security identifier derived from the well known sid.

Let assume you have this method:

private byte[] GetWellKnwonSid(WellKnownSidType SidType)
{
    SecurityIdentifier Result = new SecurityIdentifier(SidType, null);
    byte[] sidArray = new byte[Result.BinaryLength];
    Result.GetBinaryForm(sidArray, 0);

    return sidArray;
}

Then when Win32_Trustee object is created, assign the SID property as follow:

ManagementObject Trustee = new ManagementClass(new ManagementPath("Win32_Trustee"), null);
Trustee["SID"] = GetWellKnwonSid(WellKnownSidType.WorldSid);

That code above will create Win32_Trustee for ‘Everyone’. Use this Win32_Trustee to form the Win32_Ace, and you now explicitly assign ‘Everyone’ access to your share.

How to Programmatically Modify the IIS Virtual Directory

HelloWorld — Fri, 29 May 2009 19:16:45 GMT

If you have more than a dozen web servers in a cluster with identical setting, and you need to update the virtual directory, it is much more convenient to write a simple program to update it. This example shows how to do it. In this case, this snippet will change the physical path of a virtual directory.

This snippet works on IIS 6 and IIS 7. PowerShell may not be installed in Server 2003, to make this snippet more generic, this snippet is written in C#, otherwise, PowerShell script may be a better option.

private const string MetabasePath = "IIS://Localhost/W3SVC/1/Root";

//Get the virtual directory of IIS.
private static DirectoryEntry GetVirtualDirectory(DirectoryEntry IISDirectory, string vDirName)
{
    string ClassName = IISDirectory.SchemaClassName.ToString();

    if (!((ClassName.EndsWith("Server")) || (ClassName.EndsWith("VirtualDir"))))
    {
        throw new Exception(String.Format("Virtual Directory can be updated under site or virual directory node. Metabase:{0}, SchemaClassName={1}", MetabasePath, ClassName));
    }

    //Iterate through the children, as Find() method is having an issue with IIS 6, if more than one thread is accessing IIS, an AccessViolationException is thrown.
    //The fix is applying the a hot fix http://support.microsoft.com/kb/946517. Either use Find(), or use this method below.
    //Since IIS may not have the hot fix installed, this sample iterates the children.
    foreach (DirectoryEntry VirtualDir in IISDirectory.Children)
        if (String.Compare(VirtualDir.Name, vDirName, StringComparison.OrdinalIgnoreCase) == 0)
            return VirtualDir;

    return null;
}

//Update the physical path of the site.
private static void UpdatePhysicalPath(string virtualDirectoryName, string newPath)
{
    using (DirectoryEntry Site = new DirectoryEntry(MetabasePath))
    {
        DirectoryEntry StatsNet = GetVirtualDirectory(Site, virtualDirectoryName);

        if (StatsNet == null)
            throw new Exception(String.Format("Site not found. Metabase={0}, virtualDirectory={1}", MetabasePath, virtualDirectoryName));

        StatsNet.Properties["Path"][0] = newPath;
        StatsNet.CommitChanges();
    }
}

static void Main(string[] args)
{
    UpdatePhysicalPath("MySite", @"d:\http\MyNewSite");
}

That snippet above shows how to change the path, there are a lot of properties that can be changed, at least this shows the basic idea.

C# 3.0 Automatic Property

HelloWorld — Fri, 13 Feb 2009 02:30:06 GMT

C# introduces a number of syntactic sugar, including Automatic Property link. A question was asked, why is this useful, what is the advantage of this approach compared to exposing the field as public field?

The advantage of the automatic property is that while you have a much cleaner code, you still have encapsulation, you can restrict the setter, so only internal classes, or descendant classes can update the property.

public class AutomaticPropertyClass
{
    public string PublicProperty { get; set; }
    public int    ReadOnlyProperty { get; private set; }
    public double InternalProperty { get; internal set; }
    public char   ProtectedProperty { get; protected set; }
}

That code is much simpler than having to declare private field and then the property, and the developer still can define the accessibility. Yes, this is quite old, but since I was asked that question, might as well blog about it. :)

How to Add Command Line Support with Your .MSI

HelloWorld — Fri, 06 Feb 2009 21:23:59 GMT

One of the requirements in building setups was to allow the Operations team to execute the .msi file from the command line. GUI is not for expert! :)

If you are familiar with Visual Studio setup, each of the UI element has a property, and you pass this property to your custom action, or use it as condition in your setup (whether to install the documentation, help, or whether to install to the gac or not, etc.).

msiexec.exe allows you to pass some parameters to override those properties. Unfortunately the .msi file that Visual Studio generates always set the default values, default value being the values that the developers set during design time.

After inspecting the .msi, there are some custom actions that will set the property value to the default. This custom actions are always executed, whether the users sets the property via command line parameter or not. That means, if the user pass some parameters to override the property, the setup will execute the custom action, reassign the property value to the original default value.

So what needs to be done is to prevent the custom action from executing when the property is overridden by the user. This can be done quite easily with text box dialogs, checkbox dialogs are a little bit more difficult, I will cover it in other post.

The property has blank value/null in the beginning, if the user overrides the property via command line parameter, this value will not be null. By giving custom actions a condition, to execute only if the property is blank, the value that the user gave via command line will not be overridden.

You need to set the conditions in two different tables in your .msi file, InstallExecuteSequence and InstallUISequence. One to support GUI mode (interactive) and the other to support quiet/passive mode.

This is the example on how to do it, repeat the steps for every property that you want to be able to override:

Identify the property that you want to override. From within Visual Studio, writes down the property that you want to be able to override. For example, you set a property SERVERNAME, related to Edit1Property on Textboxes (A), and the default value is 'DefaultServerName'.
Check the InstallUISequence and InstallExecuteSequence tables in the .msi using Orcas, you should see something like this:

You know this is the action that you want from the Action name, it is CustomTextA, corresponds to the Textboxes (A), and it is the Edit1 control. If you check the CustomAction table, you will see something like this:
To prevent the custom action from executing, add this condition on both InstallUISequence and InstallExecuteSequence tables, SERVERNAME = "".

This tells, if the SERVERNAME is blank (the user did not override), execute the custom action to assign the default value. Please pay attention that the condition is for an empty string (two double quotes).
Save the .msi and close Orcas.
Execute the .msi using this command:
msiexec /i [The msi name].msi SERVERNAME="HELLOWORLDSERVER"

After executing those steps, the UI will show HELLOWORLDSERVER in the text box.

To set this condition automatically as part of your build process, we need to use a script to modify the setup. This can be done by setting the post build event for your project.

Create a .js script. Call it CommandLineSupport.js, repeat the update statement for every property that you want to be able to override.
//This script adds command-line support for MSI build with Visual Studio 2008.
var msiOpenDatabaseModeTransact = 1;

if (WScript.Arguments.Length != 1)
{
    WScript.StdErr.WriteLine(WScript.ScriptName + " file");
    WScript.Quit(1);
}

WScript.Echo(WScript.Arguments(0));
var filespec = WScript.Arguments(0);
var installer = WScript.CreateObject("WindowsInstaller.Installer");
var database = installer.OpenDatabase(filespec, msiOpenDatabaseModeTransact);

var sql
var view

try
{
    //Update InstallUISequence to support command-line parameters in interactive mode.
    sql = "UPDATE InstallUISequence SET Condition = 'SERVERNAME=\"\"' WHERE Action = 'CustomTextA_SetProperty_EDIT1'";
    view = database.OpenView(sql);
    view.Execute();
    view.Close();

    //Update InstallExecuteSequence to support command line in passive or quiet mode.
    sql = "UPDATE InstallExecuteSequence SET Condition = 'SERVERNAME=\"\"' WHERE Action = 'CustomTextA_SetProperty_EDIT1'";
    view = database.OpenView(sql);
    view.Execute();
    view.Close();

    database.Commit();
}
catch(e)
{
    WScript.StdErr.WriteLine(e);
    WScript.Quit(1);
}

Save the CommandLineSupport.js in the same folder with your setup project file, and set PostBuildEvent for the setup project.

Make sure .msi name matches your .msi file name.
Build the project.

Standard disclaimer applies, no warranty, use it at your own risk, always test the changes. Wow, this post is longer than what I thought it would be....

When Building Multi-Threaded Applications using ThreadPool, Make the Number of Worker Threads Configurable

HelloWorld — Tue, 16 Dec 2008 14:14:14 GMT

Just a simple thought, when creating a multi-threaded applications, make the number of threads configurable. ThreadPool has this behavior that it will immediately set the minimum worker threads equal to the number of logical processors in your machine, and set the maximum to 250 per logical processor, well documented in msdn (.Net Framework 2.0 SP1).

ThreadPool will create a new thread every half second, also documented in msdn. This behavior could lead to thread explosions, where there are too much threads fighting for limited resources (memory, lock, disk IO, processor, etc.). Your app may run slower if the thread creation is not managed wisely.

It is also a good idea to be able to throttle the application to use fewer threads. It is a good idea to be able to limit the number of threads in the system through configuration. Set the max number of threads by calling SetMaxThreads, and if the config value is less than the number of logical processors, do not forget to call SetMinThreads. Be aware that this can also lead to other issue, like thread starvation.

This is just an idea, if you have been writing multi-threaded applications using ThreadPool, probably you have thought about this already. Keep in mind, your application needs as few thread as possible, but not fewer.

String.Split has High Cost on Performance

HelloWorld — Tue, 16 Dec 2008 01:59:24 GMT

One application had a memory issue, it just consume too much resources. The application performed well, but it is very obvious when we saw the performance counters, something can be done to make it better. Reviewing the code did not reveal something significant, the code already allocated objects that are necessary. The code parses a text file and generate an object based on the content of that text file.

After running CLR Profiler, I noticed that a lot of memory are consumed by int[], but there is no code that generates that kind of object. Digging a little bit deeper, I discovered that one method calls String.Split(). This method is one of the main method, it is being called about 80% of the time.

String.Split() creates an array of strings, and in the process, it creates a helper array of int. The size of the helper array can be really huge. After the code had been modified to avoid calling String.Split(), the memory consumption was significantly reduced.

If you need performance in a tight loop, avoid String.Split().

If you are using Visual Studio 2008, I strongly recommend for you to step through the .Net framework source code using debugger. Check Shawn Burke's post to do that.

How to Create Custom Event Log for Windows Service

HelloWorld — Thu, 11 Dec 2008 20:52:42 GMT

When you created a Windows Service, you usually add a Service Installer to allow this service to be installed using InstallUtil or installing it programmatically like this post shows you.

The service installer will create the Event Log for the service, and by default it is "Application", and the source is the name of your service.

The Event Source is most likely to be fine, but the event log may need to be set to something else. Unfortunately, the option is not visible from the installer.

The Installer object for your windows service, actually hosted several other Installer objects, one of the child Installer is responsible to create the Event Log. You need to find this object and then changed the Log property and it will create the appropriate event log. It is easy to find this object as this object is an instance of EventLogInstaller.

The code:

public partial class MyServiceInstaller : Installer
{
    private const stringLogName = "My Service Log";

    public MyServiceInstaller()
    {
        InitializeComponent();

        EventLogInstaller EventLogInstall = null;

        foreach (Installer I in this.serviceInstaller.Installers)
        {
            EventLogInstall = I as EventLogInstaller;

            if(EventLogInstall != null)
            {
                EventLogInstall.Log = LogName;
                EventLogInstall.UninstallAction = UninstallAction.NoAction;
                break;
            }
        }
    }
}

That code above shows how to create a custom Event Log for your service, the code also shows that the custom event log will never be uninstalled, depending on the requirements it can be easily changed.

If the event source needs to be changed as well, simply change the Source property and you are set.

One thing to pay attention, if you create a custom event log, you install the service programmatically, and your service is running with a restricted account, then you have to modify the code to install the service by adding a code to write one entry to the event log that you just created.

After the service installer is executed, the log is 'registered', but not created yet. To create it, one event must be written. If the service runs using a restricted user account, that account may not have enough security permission to write the first log, as the log need to be created.

When installing the service, the user must run the installer as Administrator, so the installer has all security privilege that it needs. So remember to write one event entry after programmatically installing the service.

How to Get IIS Web Sites Information Programmatically

HelloWorld — Fri, 31 Oct 2008 08:03:41 GMT

I needed to get the location of IIS log files on my servers, after doing a quick investigation, I am quite amazed on how much information are exposed via managed code.

This snippet will return the name of the sites and the location of the log files.

foreach (DirectoryEntry Site in new DirectoryEntry("IIS://" + System.Environment.MachineName + "/w3svc").Children)
    if (String.Compare(Site.SchemaClassName, "IIsWebServer", StringComparison.OrdinalIgnoreCase) == 0)
        Console.WriteLine(Site.Properties["ServerComment"].Value.ToString() + " == " + Site.Properties["LogFileDirectory"].Value.ToString());

To get more information about what fields and method you can access, please refer to this MSDN doc: http://msdn.microsoft.com/en-us/library/ms524487.aspx.

Just remember, in Vista/Windows Server 2008, you will need to run that code with elevated privilege.

Watch PDC Videos Online

HelloWorld — Thu, 30 Oct 2008 23:40:07 GMT

PDC is almost over, did you know that you can access the recorded sessions online?

Go to http://www.microsoftpdc.com, and click on Agenda on the top. then click on Sessions tab. Pick the session that you want to watch, scroll down, you should see a Video tab.

Much shorter shortcut, got to this link https://sessions.microsoftpdc.com/public/timeline.aspx.

Today is Friday, 10/30, most likely today video is not available at this moment, but should be available soon.

Advice for New Programmers

HelloWorld — Tue, 26 Aug 2008 11:47:00 GMT

I was reading an old post that Chuck Jazdzewski wrote. This one is really good, it is not applicable only for new programmers, if you are a seasoned programmer, this article is still a good read. Jump to Chuck’s fatherly advice for new programmers.

In God We Trust, Everybody Else Must Bring Data

HelloWorld — Mon, 25 Aug 2008 23:25:00 GMT

One day, I was presented with a problem, that the finalizer was not called during application pool recycle. I was busy, so I did not have chance to respond. Later on, I checked the code, it was modified to inherit from CriticalFinalizerObject class, and a comment saying that even though the class is inherited from CriticalFinalizerObject, the finalizer sometimes is not getting called. There was a logic in the finalizer that is often not got executed, the assumption was, the finalizer sometime was not called.

After digging the code, I discovered what was going on, above the logic that often not get executed, there was one line of code that close a FileStream object that is also a field of this class.

Managed code does not guarantee the order of the objects that are being garbage-collected, the finalizer may have accessed the garbage-collected objects. The code below the code that closes the FileStream object did not get executed if the FileStream has been garbage-collected.

It does not matter whether the class is inherited from CriticalFinalizerObject or not, the exception will give the impression that the finalizer was not called.

A quick look on ASP.Net Event Log shows ObjectDisposed exception whenever the logic is not called, a simple logging showed that the finalizer was always called. After isolating the issue, the fix is much simpler and guaranteed to work all the time.

Next time you hear about a problem, ask for data, profiler, repro steps. Just like a Test Manager that I knew said, ‘In God we trust, everybody else must bring data’.

The server did not provide a meaningful reply; this might be caused by a contract mismatch, a premature session shutdown or an internal server error

HelloWorld — Fri, 22 Aug 2008 17:30:09 GMT

I am playing around with WCF, and I got that error message above. Searching did not really help in defining what was going on. And yes, it was working on my previous test environment. :)

Luckily, I still had one of my test method, which just ping the service and did nothing else. That method works, so at least I know that the problem was not with the service, only with this operation.

The problematic parameter took a parameter, an array of byte. Out of curiosity, I sent an empty array, lo behold, it worked.

It turned out that my test data was too big, I used a file to create that array of byte, and it worked great. I lost that small file and randomly picked a file. I did not realize the file was 6 GB in size. After replacing that file with a smaller one, it worked.

So, if you see that error above and you are passing an array of byte as parameter, probably this will help you to quickly fixed the issue.

Disclaimer, I do not think this is the only cause for that error.

Replacing ASMX Web Service with WCF Web Service

HelloWorld — Fri, 01 Aug 2008 22:38:10 GMT

I found a good article about replacing ASMX web wervice with WCF web service here (ASMX to WCF migration). Very cool, and my client application do not need to be recompiled.

Just one thing that I notice, I believe on step 3, instead of XmlSerializerAttribute it should be XmlSerializerFormat. Have fun!

Boosting Performance with READ_COMMITTED_SNAPSHOT

HelloWorld — Tue, 22 Jul 2008 10:10:00 GMT

I had a problem with one of our database in our testing environment, it performs OK, but we know it can be faster. There are millions of data in that database. Everything are properly indexed and the stored procedure plan is optimum.

I was not aware about read committed snapshot option when the dba suggested this option. I was reading more information and was convinced that this setting would help performance.

We set this configuration, the application is now running really fast, processing hundreds of row per second. Our application has a lot of transactions per second, multiple read and multiple write within the same seconds. With this option, readers won’t block writers, and vice versa.

Take a look at this option, it may give the performance boost that your application needs. Kimberley Tripp has a good article on msdn about this subject. http://msdn.microsoft.com/en-us/library/ms345124.aspx. A long read, but it has good information.

Of course, you should always measure it, and nothing comes for free, it consumes more space in the temp db.

Editing Share Permission

HelloWorld — Tue, 22 Jul 2008 04:00:00 GMT

In my previous post, I have shown you how to set up permission on a share. The thing with Win32_Share, when you set the permission, you basically overwrites the existing permission.

If you want to edit permission on the share (grant a new user access to the share, or revoke an existing user's permission), then you have to get the security descriptor for that share, and modify it, and then call Win32_Share.SetShareInfo to set the share permission.

To get security descriptor of a share, you can use Win32_LogicalShareSecuritySetting class. Then update the security descriptor and set that security descriptor back to the share.

When calling ManagementObject.GetSecurityDescriptor, it will return a ManagementBaseObject instance, it has two properties, ReturnValue and Descriptor. ReturnValue is an integer value, that tells you whether the operation is successful or not. Look for the possible value here. The Descriptor property is an instance of SecurityDescriptor.

To summarize (for those who love bullet points):

Get the Win32_Ace instance for the new user.
Get the current security descriptor.
Get the DACL (Array of Win32_Ace) from the security descriptor.
Add the Win32_Ace for the new user into the Win32_Ace array.
Reassign the edited DACL back to the security descriptor.
Call Win32_Share.SetShareInfo to set the permission.

You can delete a particular user, or changing the existing permission, by modifying the DACL or SACL in the Security Descriptor.

This snippet below is just an example on how to read, modify and assign permission on a share, this code was derived from the example on my previous post.

//Create a new Win32_Ace instance. Please refer to my previous post about creating Win32_Ace.
NTAccount account = new NTAccount("contoso", "janedoe");
SecurityIdentifier sid = (SecurityIdentifier)account.Translate(typeof(SecurityIdentifier));
byte[] sidArray = new byte[sid.BinaryLength];
sid.GetBinaryForm(sidArray, 0);

ManagementObject Trustee = new ManagementClass(new ManagementPath("Win32_Trustee"), null);
Trustee["Domain"] = "contoso";
Trustee["Name"]   = "janedoe";
Trustee["SID"]   = sidArray; 

ManagementObject ACE = new ManagementClass(new ManagementPath("Win32_Ace"), null); 
ACE["AccessMask"] = 2032127; 
ACE["AceFlags"]   = 3; 
ACE["AceType"]    = 0; 
ACE["Trustee"]    = Trustee; 

//After we have the new Win_32Ace, now we need to get the existing Ace instances (DACL).
//Create an instance of Win32_LogicalSecuritySetting, set the path to the server and the share.
ManagementObject Win32LogicalSecuritySetting = new ManagementObject(@"\\ContosoServer\root\cimv2:Win32_LogicalShareSecuritySetting.Name='JohnShare'");

//Call the GetSecurityDescriptor method. This method returns one out parameter.
ManagementBaseObject Return = Win32LogicalSecuritySetting.InvokeMethod("GetSecurityDescriptor", null, null);
    
//The return value of that call above has two properties, ReturnValue, which you can use
//to read the status of the call (failed, success, etc.), and Descriptor, which is an instance
//of Win32_SecurityDescriptor.
Int32 ReturnValue = Convert.ToInt32(Return.Properties["ReturnValue"].Value);

if (ReturnValue != 0)
    throw new Exception(String.Format("Error when calling GetSecurityDescriptor. Error code : {0}.", ReturnValue));

//Retrieve the array of DACL from the Security Descriptor.
ManagementBaseObject SecurityDescriptor = Return.Properties["Descriptor"].Value as ManagementBaseObject;
ManagementBaseObject[] DACL = SecurityDescriptor["DACL"] as ManagementBaseObject[];

if (DACL == null)
    DACL = new ManagementBaseObject[] { ACE };
else
{
    Array.Resize(ref DACL, DACL.Length + 1);
    DACL[DACL.Length - 1] = ACE;
}

//Reassign the new DACL array with the new user Ace back to the Win32_SecurityDescriptor instance, and call the
//SetSecurityDescriptor method.
SecurityDescriptor["DACL"] = DACL;

ManagementObject Share = new ManagementObject(@"\\ContosoServer\root\cimv2:Win32_Share.Name='JohnShare'");
ReturnValue = Convert.ToInt32(Share.InvokeMethod("SetShareInfo", new object[] {Int32.MaxValue, "This is John's share", SecurityDescriptor})); 

if (ReturnValue != 0)
    throw new Exception(String.Format("Error when calling GetSecurityDescriptor. Error code : {0}.", ReturnValue));