Garrett Serack: Open Source Development at Microsoft : scripting

Using JScript as a batch scripting language (Part III)

GarrettS — Mon, 18 May 2009 23:15:01 GMT

Now that I’ve shown how to build a cool .Format() method for strings, we can put it to good use in a lot of places.

In batch scripting, it’s really nice to be able to make nearly every call support replacement arguments in a consistent fashion. In cmd.exe batch scripts, we use %var% all over the place. In JScript batch scripting, we simply use {$VAR} instead, and put a little bit of code in the top of our functions to help out with that.

First, the one-stop-universal-arguments helper, which we can add to the source from before:

Scripting.js

function ArgsToArray(x) { return Array.prototype.slice.call(x);} 

// FormatArguments must be passed either:
//     one argument: 
//          containing the arguments object from the caller
//          where the first argument of that should be the format string.
//          == or ==
//          just the format string.
//
//     two arguments:
//          the first argument is the format string
//          the second argument is the argument collection from the caller.
function FormatArguments(args, moreargs) {
    var result = "";

    if (arguments.length == 1) {
        if (typeof (args) == "object") {
            args = ArgsToArray(args);
            result = "" + (args.shift());

            if (args.length == 1 && arguments[0].length > 0)
                args = arguments[0];

            return result.Format(args);
        } else return ("" + args).Format();
    } else if (arguments.length == 2) {
        if (typeof (args) == "string" && typeof (moreargs) == "object") {
            result = args;
            args = ArgsToArray(moreargs);
            args.shift();

            return result.Format(args);
        }
    }
    throw "Invalid Argument passed to FormatArguments";
}

FormatArguments() gives us the ability to do variable substitution in any function, in a very flexible way. You can simply use the function to give you a completed string:

Test-4.js

// use the first string as the format string, 
// the rest are potential value substitutions
function Test1() {
    var foo = FormatArguments(arguments)
    WScript.echo( foo );
}

Test1("the path is {$PATH}");

// both arguments are used as format strings. any 
// parameter substitution should use numbers starting
// at {1}, since the 'destfile' parameter is techincally {0}
function Test2(srcfile, destfile) {
    var srcfile = FormatArguments(srcfile, arguments);
    var destfile = FormatArguments(destfile, arguments);
    var msg = "Copy {0} to {1}".Format(srcfile, destfile);
    WScript.echo(msg);
}

Test2("{$WINDIR}\\system32\\notepad.exe" , "{$USERPROFILE}\\desktop\\notepad.exe");

Knowing that, we can create a few functions that will use the FormatArguments function:

Scripting.js

// Some global objects we'll need 
var WSHShell = WScript.CreateObject("WScript.Shell");
var WinShell = WScript.CreateObject("Shell.Application");
var procEnvironment=WSHShell.Environment("PROCESS")
var fso = new ActiveXObject("Scripting.FileSystemObject");

function Print() {
    WScript.echo(FormatArguments(arguments));
}

function cd() {
    WSHShell.CurrentDirectory = FormatArguments(arguments);
}

function pwd() {
    return WSHShell.CurrentDirectory;
}

function erase(file) {
    file = FormatArguments(arguments);
    if (exists(file))
        fso.DeleteFile(file);
}

function rmdir(folder) {
    folder = FormatArguments(arguments);
    if (folderExists(folder))
        fso.DeleteFolder(folder, true);
}

function exists(file) {
    return fso.FileExists(FormatArguments(arguments));
}

function folderExists(folder) {
    return fso.FolderExists(FormatArguments(arguments));
}

function mkdir(folder) {
    folder = FormatArguments(arguments);
    if (!folderExists(folder))
        fso.CreateFolder(folder);
}

Now, we can do some pretty nifty little batch scripting:

test-5.js

// Bootstrap Scripting Library
eval(new ActiveXObject("Scripting.FileSystemObject").OpenTextFile("Scripting.js", 1, false).ReadAll());

$ORIG_DIR = pwd();

if( exists("{$WINDIR}\\log.txt") ) {
    Print("Deleting log file");
    erase("{$WINDIR}\\log.txt");
}

mkdir("{$TEMP}\\tempdir");

Next time, we’ll see how we can call on command-line tools to do our bidding, and play with the results.

Using JScript as a batch scripting language (Part II)

GarrettS — Sat, 16 May 2009 02:17:56 GMT

Last time, I wrote about synthesizing an #include facility along with handling environment variables in a trivial way.

This time, let’s look at filling in a couple more gaps in JScript’s basic scripting functionality.

What’s wrong with String?

The String class in JavaScript/JScript is … ok. If you work in .NET enough, you’ll eventually get to the point where you’d like a couple of functions that seem to be missing. First, is Trim, which I’ve always thought as obvious:

Scripting.js – String Prototypes

//----------------------------------------------------------------------------
// String Prototypes



String.prototype.Trim = function() {
    return (this || "").replace(/^\s+|\s+$/g, "");
}

And secondly, is something I miss dearly from when I’m in .NET, is a string Format function. Now, I’ve seen a couple of these that were pretty simple, but I wanted to be able to do some really cool Format strings (and, since the rest of my scripting will rely on them quite a bit, I’m going for the gold here.

Scripting.js – String Prototypes

String.prototype.Format = function() {
    var args = (arguments.length == 1 && typeof (arguments[0]) == "object") ? arguments[0] : arguments;

    result = this;
    while (z = /{(.*?)}/.exec(result))
        try { result = result.replace(z[0], isNaN(z[1]) ? eval(z[1]) : (args[z[1]]||"??<" + z[1] + ">??" )); }
    catch (x) { result = result.replace(z[0], "??<" + z[1] + ">??"); }
    return result.replace("??<", "{").replace(">??", "}");
}

So, with this tasty little script in my pocket, I can do ad-hoc format strings that use one of a few types of replacement:

test-3.js

// simple parameter # replacement like .NET
var foo = "My Name is {0}. Please to meet you {1}".Format("Garrett", "Mr. Serack");
WScript.echo(foo);

// *global* variable replacement
ABC = "this is a test";
var bar = "'{ABC}' is really a replacement string".Format();
WScript.echo(bar);

// really, any legal expression in there is fine.
bar = "'{100+200/75}' is really a replacement value?".Format();
WScript.echo(bar);

// and if it doesn't match, just leave it alone...
bar = "'{teehee}' isn't really a replacement value.".Format();
WScript.echo(bar);

// even if it's just a number.
bar = "'{1}' isn't really an index.".Format();
WScript.echo(bar);

Which spits out the following:

Ouptut

My Name is Garrett. Please to meet you Mr. Serack
'this is a test' is really a replacement string
'102.66666666666667' is really a replacement value?
'{teehee}' isn't really a replacement value.
'{1}' isn't really an index.

Basically, it just looks for anything in braces, and checks to see if it’s a number. if it is, it tries to substitute in the n’th parameter passed in. Otherwise it just does an eval() on it—which, will replace expressions, or global variables. If something goes haywire, it just leaves it alone (well, it does some switcheroo stuff to get past the while loop, but it puts it back in the end).

Next time, we’ll see how to use this… everywhere.

VBScript: Betcha never thought of this one

GarrettS — Thu, 17 Jan 2008 00:17:00 GMT

I mentioned in a previous post that I had to solve a little issue with the wonderful WMCMD.VBS script that Alex Zambelli maintains. Because of some occasional nastyness, when the script is done--successful or not-- it tries to kill it's own process, in case any of the WM Encoder objects gets hung up.

The original script uses WMI to look on the machine for the cscript process for the currently running script:

function TerminateEncoderProcess()

   dim objWMIService
   dim objProcess

   On Error Resume Next

   ' Get Windows Manager object
   Set objWMIService = GetObject("winmgmts:" _
      & "{impersonationLevel=impersonate}!\\.\root\cimv2")

   ' Enumerate all CScript.exe processes
   dim colProcessList
   Set colProcessList = objWMIService.ExecQuery _
    ("Select * from Win32_Process Where Name =" _
    & "'cscript.exe'")

   dim strArguments
   strArguments = ""

   ' Enumerate all command-line arguments
   for i = 0 to wscript.arguments.Length-1
      strArguments = strArguments & " " & _
         wscript.arguments(i)
   next
   strArguments = Replace(strArguments, Chr(34), "")

   ' Kill the processes that match this one in name and arguments
   For Each objProcess in colProcessList
      if InStr(1, Replace(objProcess.CommandLine, _
         Chr(34), ""), _
      Trim(WScript.ScriptName & strArguments), 1 ) > 0 _
      then
         objProcess.Terminate()
      end if
   Next

   ' What? Still not terminated? OK, kill first occurrence.
   For Each objProcess in colProcessList
      if InStr(1, objProcess.CommandLine, _
            WScript.ScriptName) > 0 then
         objProcess.Terminate()
      end if
   Next

end function

Unfortunatly, this script, when all else fails, tries to kill itself by finding the first running cscript, and killing it. Hmmm. not too good, I had multiple encoder script processes going on, and it kept killing the wrong one.

A pity it seems so hard to find the current process in VBScript... until I thought about it a bit more:

function TerminateEncoderProcess()

   GetObject("winmgmts:root\cimv2:Win32_Process.Handle='" _
    & GetObject("winmgmts:root\cimv2:Win32_Process.Handle='" _
    & CreateObject( "WScript.Shell").Exec("cmd.exe").ProcessId _
    & "'").ParentProcessId & "'").Terminate

end function

Huh?

This version of the script spawns off a new cmd.exe process (which exits nearly instantly), but uses the process ID from that, looks up the process, and get it's parent process, and then terminate that. Nice thing is, it don't get confused :D

Where are the WS-* Protocols? (Part One)

GarrettS — Mon, 07 Aug 2006 18:06:00 GMT

Logging into a Website

When signing into a website using CardSpace, the website has the choice of accepting two card types, Personal Cards or Managed Cards.

Personal Cards are ones that you create the claim values yourself, support only a fixed set of claims, and have the cryptographic keys and PPID generated for you.

Managed Cards are cards that are issued to you from an Identity Provider, they decide the claims, and they provide the Security Token Server that issues the token to the webiste. We'll cover this one in Part Two.

Personal Cards and the Protocols

When a website requests a personal card, it does so by putting an object element into the HTML of the page, and engaging the CardSpace Identity Selector:

<html xmlns="http://www.w3.org/1999/xhtml" >
<head>
  <title>Sample 4</title>
    <object type="application/x-informationcard" name="_xmlToken">
      <param name="tokenType" value="urn:oasis:names:tc:SAML:1.0:assertion" />
      <param name="issuer"
         value="http://schemas.microsoft.com/ws/2005/05/identity/issuer/self" />
      <param name="requiredClaims"
        value="http://schemas.microsoft.com/ws/2005/05/identity/claims/givenname
               http://schemas.microsoft.com/ws/2005/05/identity/claims/surname
               http://schemas.microsoft.com/ws/2005/05/identity/claims/emailaddress
              http://schemas.microsoft.com/ws/2005/05/identity/claims/privatepersonalidentifier" />
    </object>
  <script language="javascript">
      function GetIdentity()
      {
        var xmltkn=document.getElementById("_xmltoken");
        var thetextarea = document.getElementById("xmltoken");
        thetextarea.value = xmltkn.value ;
      }
  </script>
</head>
<body>
  <form id="form1" method="post" action="login4.aspx">
  <div>
    <button name="go" id="go" onclick="javascript:GetIdentity();">
       Click here to get the token.
    </button>
    <button type="submit">
       Click here to send the card to the server
    </button>
    <textarea cols=100 rows=20 id="xmltoken" name="xmlToken" ></textarea>
  </div>
  </form>

</body>
</html>

This obviously does not use any WS-* protocols, it's just simply asking the browser to supply the token requested to the website. And, with no STS in the puzzle, where's the WS-*?

Well, there is an STS. It's built into the CardSpace Identity Selector. It's there to provide the Personal card to the Relying Party (the website). The communication between the Identity Selector and the STS should be WS-* right? Well, since they are tightly coupled in this case, the STS in CardSpace short-circuits some of that and delivers the token to the browser just using inter-process communication. But the STS is built as if it was going to go over a wire, just optimized for local use.

So, there really isn't WS-* involved here. Until CardSpace supports a Portable STS, which then would seperate the Idenity store from the Idenity Selector, thus requiring WS-*.

g	Garrett Serack \| Program Manager \|Federated Identity Team \| Microsoft Corporation blog: http://blogs.msdn.com/garretts

Detecting Information Card Support (CardSpace!) in a browser

GarrettS — Sat, 05 Aug 2006 01:23:00 GMT

I hacked out this a few weeks back, and never got around to publishing it. I've not decided that this is the 'official' way to detect Information Card support in a browser, but it'll do until I can think of something better.

I'd say something like, "see how it detects support in other browsers too?" except that I'm not thinking many people have a CardSpace plugin for another browser yet. But you can trust me--It works!

<html>

<head>

function AreCardsSupported()

{

var IEVer = -1;

if (navigator.appName == 'Microsoft Internet Explorer')

if (new RegExp("MSIE ([0-9]{1,}[\.0-9]{0,})")

.exec(navigator.userAgent) != null)

IEVer = parseFloat( RegExp.$1 );

if( IEVer >= 6 )

{

var embed = document.createElement("object");

embed.setAttribute("type", "application/x-informationcard");

if( ""+embed.issuerPolicy != "undefined" )

return true;

return false;

}

if( IEVer < 0 && navigator.mimeTypes && navigator.mimeTypes.length)

{

x = navigator.mimeTypes['application/x-informationcard'];

if (x && x.enabledPlugin)

return true;

}

return false;

}

function ShowDetection()

{

if( AreCardsSupported() )

alert( "Information Cards are supported by this browser :D" );

else

alert( "Information Cards are NOT supported by this browser :(" );

}

</SCRIPT>

</body>

</head>

g	Garrett Serack \| Program Manager \| Connected Identity and Directory\| Microsoft Corporation blog: http://blogs.msdn.com/garretts

Scripting: Detecting the host architecture vs the process architecture

GarrettS — Fri, 04 Aug 2006 22:06:00 GMT

I had some trouble lately with scripts running on a 64bit version of Vista, when they were run with a 32 bit parent host process.

After figuring out what was wrong, I wanted to be able to detect if I was running a 32-bit script engine under a 64-bit OS. With a bit of crafty (crufty?) coding, I came up with the following VBScript which I put at the top of my script:

sub EnsureNativeScriptEngine

On Error resume next

dim WshShell,WshProcEnv,system_architecture, process_architecture

Set WshShell = CreateObject("WScript.Shell")

Set WshProcEnv = WshShell.Environment("Process")

process_architecture= WshProcEnv("PROCESSOR_ARCHITECTURE")

if process_architecture = "x86" then

system_architecture= WshProcEnv("PROCESSOR_ARCHITEW6432")

if system_architecture = "" then

system_architecture = "x86"

end if

else

system_architecture = process_architecture

end if

if NOT system_architecture = process_architecture then

WshShell.popup "This script should be run as a "& system_architecture & _

"process, but is running as a "& process_architecture &" process."

WScript.quit 1

end if

end sub

EnsureNativeScriptEngine

Which is fine and dandy, except I’d really have liked to just transparently execute the script with the right version of the script host.

Ah well, at least this tells me what’s going on. J

g	Garrett Serack \| Program Manager \| Connected Identity and Directory\| Microsoft Corporation blog: http://blogs.msdn.com/garretts

Self compiling scripts for .NET languages: C#, VB.NET and JScript.NET

GarrettS — Tue, 01 Aug 2006 07:53:00 GMT

Ok, these ones are pretty cool. It took me a few more hours than I thought, but it was worth it.

The scripts in the zip file are javascripts which surround another language, and allow you to write .NET applications, but distribute simple text files as scripts.

The C# and JScript.net wrappers are perfectly identical, the VB.NET one required a little more playing to get right. – and it’s just the smuggling lines that are different, the script itself is the same.

I’ve coded a simple hello world example into each of the languages.

The ‘trimmed’ versions allow you to simply add the five lines at the top, and the last line to your source file and have it run anywhere .NET 2.0 is installed.

Oh, and even better: if you drop the .JS on the end, the script loads in Visual Studio just fine as a class—you can do all of your testing with the script header in place and then just rename it when you want to redistribute it.

http://serack.org/SelfCompilingScriptExamples.zip

g	Garrett Serack \| Program Manager \| Connected Identity and Directory\| Microsoft Corporation blog: http://blogs.msdn.com/garretts