/* ----------------------------------------------------------------

Ryan Kellerman - Documentor Script v2.0.8
Last Updated: 3/25/09

----------------------------------------------------------------- *

NOTE: If you want to scan a pre-determined list of computers create a file named targets.txt and put
it in the same directory as this script file.  When you click run on the execute tab the computer 
name input and the domain scan checkbox will be ignored.  The systems can each be on their own line,
or multiples to line simply seperated by a comma.

*** To Do List ***
*create more effective layout for visio
*add windows event viewer gathering (options maybe for errors, warnings, information + time frames)
*allow choice for IP address range input
*validation on IP address ranges
*get that damned Last User logon working ...
*report ROM drives
*report Printers (local only most probably)
*report on shares off of a server (I dunno, maybe the share permissions also)
*agent mode
*clean up the god awful office report function
*column ordering?

2.0.8 - Updates
*now generates XML files for output with all of the computer data
*hacked in reporting all apps for 64-bit systems. :D

2.0.7 - Updates
*fixed bug, hopefully, where script errors out while dumping to text or excel

2.0.6 - Updates
*added Event Log reporting

2.0.5 - Updates
*added Windows Services listing
*fixed weird floating "to Excel, to Visio, toText" button issue introduced in 2.0.4
*add hard disk capacity and free space dump report to Excel
*created disk reporting tab for output to excel
*created disk reporting text file for output
*clean up comma's from output of report functions for Apps and Services (so CSV files workout alright)
*on HTML display form change commas to spaces so word wrap will happen in HTML output

2.0.4 - Updates
*clean up css for IE windows (roll into a function per window)
*get the stop scan button working 
*report to text file ...
*make application report collapsed in Internet Explorer window
*allow input of multiple alternate credentials 
*quickly validate a system that has retuned a ping request is a windows host
*altered behavior so the application appears as a foreground window

2.0.3 - Updates
*fixed IE crash problem after a long domain scan has run
*sped up IP and Network adapter performance by altering WMI query so that only enabled Network Adapters are returned
*fixed up so Office reports on x64 OSes
*report free space on hard disks
*break Windows Product Keys out
*filter servers/workstations on return, give users the choice

2.0.2 - Updates
*adding Visio output piece
*gather subnet mask and place it with IP address in slash format

2.0.1 - Updates
*started keeping track of updates.
*renamed Output more aptly to Execute
*fixed Excel dump crash when Application Report wasn't selected

------------------------------------------------------------------- */
var mainHeader  //DHTML h1 object
var mainStatus  //DHTML p object
var mainTabs   //DHTML unordered list object
var mainCredentialsTab   //DHTML Button item should be a child to mainTabs
var mainWorkstationTab   //DHTML Button item should be a child to mainTabs
var mainOutputTab    //DHTML Button item should be a child to mainTabs
var mainIE //my internet explorer object for the user setup screens
var scanIE //my internet explorer object for the scan process
var objScanIeQuitButton //this will need to accessible from multiple functions as the innerText of it will need to be changed when a scan is complete.
var userRequestedScanTermination = false;
var currentHostCredentials = new Array("",""); //currentHostCredentials
                                               //[0] is username [1] is password 
var strAppTitle = "Documentor 2.0.8"; //applications title

var wksArray = new Array();  //will be a multi-dimensional array with all of the workstation tab input values
                               /* wksArray map
                                 
                                    [0]  "wksName"      =>    status     => "Name"
                                    [1]  "wksIP"        =>    status     => "IP Address"
                                    [2]  "wksCPU"       =>    status     => "CPU(s)"
                                    [3]  "wksRAM"       =>    status     => "System Memory"
                                    [4]  "wksMake"      =>    status     => "System Make"
                                    [5]  "wksModel"     =>    status     => "System Model"
                                    [6]  "wksOS"        =>    status     => "Operating System"
                                    [7]  "wksWpk"       =>    status     => "Windows Product Key"
                                    [8]  "wksSerial"    =>    status     => "Serial Number"
                                    [9]  "wksLastUser"  =>    status     => "Last User Logon"
                                    [10] "wksVideo"     =>    status     => "Video Adapter(s)"
                                    [11] "wksAudio"     =>    status     => "Audio Adapter(s)"
                                    [12] "wksNetwork"   =>    status     => "Network Adapter(s)"
                                    [13] "wksOffice"    =>    status     => "Microsoft Office"
                                    [14] "wksDisk"      =>    status     => "Hard Disk Information"
                                    [15] "wksApps"      =>    status     => "Generic Application Report"
                                    [16] "wksServices"  =>    status     => "Report Services"
                                    [17] "wksLogs"      =>    status     => "Event Logs"
                                    
                                    Where status is a boolean flag for whether or not that is currently selected
                               */
var credArray = new Array(); //will be a multi-dimensional array with all of the credential input values
var outputArray = new Array(2);    /* 
                                   will be an array containing values for the output of data ... right now just an Excel spreadsheet path and the system the script will run against,
                                   in the future I hope to have database outputs and he option to set the script to "agent" mode for per system reporting
                                   outputArray[0] <- hostname or fqdn
                                   outputArray[1] <- scan based on hosts off of directory controller
                                   outputArray[2] <- Filter Type (Servers Only, Workstations Only, All)
                                    */

//application entry point
main();

function main()
{
    /*
	this function is the application
	arguments:
	none
	returns:
	nothing
	*/
	//setup my default data values
    initializeWksArray(); //create default values for my Workstation input array
    initializeCredArray(); //create default values for my Credentals input array
    initializeOutputArray(); //create deffault values for my Output input (heh) array
    //create internet explorer object for the application to run as ...
	ieMainSetup();
	while(true)
	{
	    WScript.Sleep(50);
	}
}

/* --------------------------------------------------------------------------------
***********************************************************************************
Main Scan portion Internet Explorer setup and manipulation functions (DHTML)
***********************************************************************************
---------------------------------------------------------------------------------*/
function ieMainSetup()
{
   /*
     create my internet explore object the way I want it and return it 
     arguemnts:
     returns:
     Returns an unhiden internet explorer object
   */
    mainIE = WScript.CreateObject("InternetExplorer.Application");   //ieObject for workstation scan output use
    var objShell = new ActiveXObject("WScript.Shell");
    mainIE.Navigate("about:blank");
    configureMainIeStyleSheets();
    mainIE.Toolbar = 0;
    mainIE.StatusBar = 0;
    mainIE.Width = 720;
    mainIE.Height = 750;
    mainIE.Resizable = true;
    while (mainIE.Busy)
    {
        WScript.Sleep(200);
    }
    mainIE.document.title = strAppTitle;   //set the window title for Internet Explorer
    mainIE.Visible = 1;
    WScript.Sleep(50);
    objShell.AppActivate(strAppTitle); //an attempt to bring the Inernet Explorer window into focus (Microsoft changed this behavior, now it just makes the title flash in the taskbar
    mainIE.document.body.appendChild(quitButtonSetup());
    mainHeader = headerSetup();  //the doc header...
    mainIE.document.body.appendChild(mainHeader);
    mainStatus = statusSetup(); //the status area
    mainIE.document.body.appendChild(mainStatus);
    mainTabs = tabsStripSetup(); //tab strip container
    mainIE.document.body.appendChild(mainTabs);
    mainCredentialsTab = tabSetup("Credentials");  //put in a tab "Credentials"
    mainTabs.appendChild(mainCredentialsTab);
    mainWorkstationsTab = tabSetup("Workstations"); //put in a tab "Workstations"
    mainTabs.appendChild(mainWorkstationsTab);
    mainOutputTab = tabSetup("Execute"); //put in a tab "Execute"
    mainTabs.appendChild(mainOutputTab);
    activateTab("Credentials");
}

function configureMainIeStyleSheets()
{
    /* creates css rules (mostly classes) and their properties for use else where in the script,
       this should help reduce the size of the script */
    try
    {
        mainIE.document.createStyleSheet();
    }
    catch(err)
    {   //sometimes the script is faster than Internet Explorer ... weird
        WScript.Sleep(500);
        mainIE.document.createStyleSheet();
    }
    var myCss = mainIE.document.styleSheets[0];
    //BODY element rules
    myCss.addRule("body","margin: 0px");
    myCss.addRule("body","padding: 0px");
    myCss.addRule("body","font-family: Arial");
    myCss.addRule("body","background: #fff");
    //.mainHeader class rules
    myCss.addRule(".mainHeader","color: #fff");
	myCss.addRule(".mainHeader","background: #333");
    myCss.addRule(".mainHeader","border: 1px solid #333");
    myCss.addRule(".mainHeader","font-size: 1.0em");
    myCss.addRule(".mainHeader","font-weight: Bold");
    myCss.addRule(".mainHeader","padding: 8px");
    myCss.addRule(".mainHeader","margin: 0px");
    //.mainStatus class rules
    myCss.addRule(".mainStatus","color: #000");
    myCss.addRule(".mainStatus","background: #eee");
    myCss.addRule(".mainStatus","border-bottom: 1px solid #888");
    myCss.addRule(".mainStatus","font-size: 12px");
    myCss.addRule(".mainStatus","padding-left: 10px");
    myCss.addRule(".mainStatus","padding-top: 2px");
    myCss.addRule(".mainStatus","padding-bottom: 2px");
    myCss.addRule(".mainStatus","margin: 0px");
    //.mainTabStripContainer class rules
    myCss.addRule(".mainTabStripContainer","margin: 0px");
    myCss.addRule(".mainTabStripContainer","padding: 0px");
    //.mainQuitButton class rules
	myCss.addRule(".mainQuitButton","border: 1px solid #fff");
    myCss.addRule(".mainQuitButton","font-size: 11px");
    myCss.addRule(".mainQuitButton","margin-top: 8px");
    myCss.addRule(".mainQuitButton","margin-right: 7px");
    myCss.addRule(".mainQuitButton","float: right");
    myCss.addRule(".mainQuitButton","width: 60px");
    //.mainTabActive class rules
    myCss.addRule(".mainTabActive","color: #fff");
    myCss.addRule(".mainTabActive","background: #000");
    myCss.addRule(".mainTabActive","font-weight: Bold");
    myCss.addRule(".mainTabActive","border: 1px solid #000");
    myCss.addRule(".mainTabActive","border-bottom: 1px solid #000");
    myCss.addRule(".mainTabActive","padding-top: 1px");
    myCss.addRule(".mainTabActive","padding-bottom: 1px");
    myCss.addRule(".mainTabActive","margin-top: 2px");
    myCss.addRule(".mainTabActive","margin-left: 2px");
    myCss.addRule(".mainTabActive","margin-bottom: 0px");
    myCss.addRule(".mainTabActive","width: 100px");
    //.mainTabInactive class rules
    myCss.addRule(".mainTabInactive","color: #333");
    myCss.addRule(".mainTabInactive","background: #fff");
    myCss.addRule(".mainTabInactive","font-weight: Bold");
    myCss.addRule(".mainTabInactive","border: 1px solid #000");
    myCss.addRule(".mainTabInactive","border-bottom: 1px solid #eee");
    myCss.addRule(".mainTabInactive","padding-top: 1px");
    myCss.addRule(".mainTabInactive","padding-bottom: 1px");
    myCss.addRule(".mainTabInactive","margin-top: 2px");
    myCss.addRule(".mainTabInactive","margin-left: 2px");
    myCss.addRule(".mainTabInactive","margin-bottom: 0px");
    myCss.addRule(".mainTabInactive","width: 100px");
    //.mainSubTabsTitle class rules
    myCss.addRule(".mainSubTabsTitle","background: #000");
    myCss.addRule(".mainSubTabsTitle","color: #fff");
    myCss.addRule(".mainSubTabsTitle","margin: 0px");
    myCss.addRule(".mainSubTabsTitle","paddingRight: 10px");
    myCss.addRule(".mainSubTabsTitle","text-align: right");
    myCss.addRule(".mainSubTabsTitle","font-weight: Bold");
    myCss.addRule(".mainSubTabsTitle","border: 1px solid #000");
    //.mainActiveFormTable class rules
    myCss.addRule(".mainActiveFormTable","border: 1px solid #000");
    myCss.addRule(".mainActiveFormTable","color: #000");
    myCss.addRule(".mainActiveFormTable","background: #000");
    myCss.addRule(".mainActiveFormTable","margin: 0px");
    myCss.addRule(".mainActiveFormTable","padding: 0px");
	myCss.addRule(".mainActiveFormTable","font-size: 14px");
    myCss.addRule(".mainActiveFormTable","width: 100%");
    //.mainInputContainer class rules
    myCss.addRule(".mainInputContainer","background: #eee");
    myCss.addRule(".mainInputContainer","text-align: center");
	myCss.addRule(".mainInputContainer","padding: 10px");
    //.mainInputTable class rules
    myCss.addRule(".mainInputTable","margin: 20px");
    myCss.addRule(".mainInputTable","backgroundColor: #eee");
    myCss.addRule(".mainInputTable","color: #000");
    myCss.addRule(".mainInputTable","text-align: left");
    //.mainCredentialInputField class rules
    myCss.addRule(".mainCredentialInputField", "border: 1px solid #000");
    myCss.addRule(".mainCredentialInputField", "width: 300px");
    //.mainCredentialsList class name
    myCss.addRule(".mainCredentialsList","border: 1px dotted #000");
    myCss.addRule(".mainCredentialsList","background: #fff");
    myCss.addRule(".mainCredentialsList","font-weight: Bold");
    myCss.addRule(".mainCredentialsList","font-size: 12px");
    myCss.addRule(".mainCredentialsList","width: 100%");
    myCss.addRule(".mainCredentialsList","text-align: left");
    //.mainRemoveCredButton class rules
    myCss.addRule(".mainRemoveCredButton","background: #eee");
    myCss.addRule(".mainRemoveCredButton","border: 1px solid #000");
    myCss.addRule(".mainRemoveCredButton","color: #000");
    //.mainCredBlankList class rules
    myCss.addRule(".mainCredBlankList","padding: 20px 20px 20px 20px");
    //.mainCredListItemRemoveCell class rules
    myCss.addRule(".mainCredListItemRemoveCell","text-align: left");
    myCss.addRule(".mainCredListItemRemoveCell","width: 100px");
    myCss.addRule(".mainCredListItemRemoveCell","border-bottom: 1px dotted #000");
    myCss.addRule(".mainCredListItemRemoveCell","padding: 10px 10px 10px 10px");
    myCss.addRule(".mainCredListItemRemoveCell","font-size: 12px");
    //.mainCredListItemTitleCell class rules
    myCss.addRule(".mainCredListItemTitleCell","text-align: left");
    myCss.addRule(".mainCredListItemTitleCell","border-bottom: 1px dotted #000");
    myCss.addRule(".mainCredListItemTitleCell","padding: 10px 10px 10px 10px");
    myCss.addRule(".mainCredListItemTitleCell","font-size: 12px");
    //.mainCredAddButton class rules
    myCss.addRule(".mainCredAddButton","background: #ccc");
    myCss.addRule(".mainCredAddButton","color: #000");
    myCss.addRule(".mainCredAddButton","border: 1px solid #000");
	myCss.addRule(".mainCredAddButton","float: right");
    myCss.addRule(".mainCredAddButton","width: 60px");
    myCss.addRule(".mainCredAddButton","font-size: 11px");
    //.mainLabelCell class rules
    myCss.addRule(".mainLabelCell","text-align: right");
    myCss.addRule(".mainLabelCell","width: 120px");
    //.mainInputTargetBox class rules
    myCss.addRule(".mainInputTargetBox","border: 1px solid #000");
    myCss.addRule(".mainInputTargetBox","width: 300px");
	//.mainInputDcCheckbox class rules
    myCss.addRule(".mainInputDcCheckBox","text-align: right");
    //.mainFilterDescriptionCell class rules
    myCss.addRule(".mainFilterDescriptionCell","text-align: right");
    myCss.addRule(".mainFilterDescriptionCell","verticalAlign: top");
	myCss.addRule(".mainFilterDescriptionCell","padding-top: 8px");
    //.mainWorkstationUnselected class rules
    myCss.addRule(".mainWorkstationUnselected","background: #ddd");
    myCss.addRule(".mainWorkstationUnselected","font-weight: Normal");
    myCss.addRule(".mainWorkstationUnselected","border: 1px solid #000");
    myCss.addRule(".mainWorkstationUnselected","width: 150px");
    //.mainWorkstationSelected class rules
    myCss.addRule(".mainWorkstationSelected","background: #fff");
    myCss.addRule(".mainWorkstationSelected","font-weight: Bold");
    myCss.addRule(".mainWorkstationSelected","border: 1px solid #000");
    myCss.addRule(".mainWorkstationSelected","width: 150px");
    //.mainExecButton class rules
    myCss.addRule(".mainExecButton","border: 1px solid #000");
    myCss.addRule(".mainExecButton","background: #ddd");
    myCss.addRule(".mainExecButton","color: #000");
    myCss.addRule(".mainExecButton","float: right");
}

function headerSetup()
{
    /*
    create my header object the way I want stylistically for use in the DHTML document
        arguemnts:
        pass the internet explorer object that we'll be using as the UI
        returns:
        DHTML H1 object for use with Internet Explorer
    */
	thisHeader = mainIE.document.createElement("H1");
	thisHeader.className = "mainHeader";
	thisHeader.innerText = strAppTitle;
	return thisHeader;
}

function statusSetup()
{
    /*
    create my status object the way I want stylistically for use in the DHTML document
        arguments:
        pass the internet explorer object that we'll be using as the UI
        returns:
        DHTML p object for use with internet explorer
    */
    thisStatus = mainIE.document.createElement("P");
    thisStatus.className = "mainStatus";
    thisStatus.innerText = "Initializing ...";
    return thisStatus;
}

function tabsStripSetup()
{
    /*
    this function creates the P DHTML object that will used to create the tabs ... ideally each LI will be a clickable button
    arguments:
    the internet explorer object it will be appended to
    returns:
    DHTML UL object
    */
    thisTabs = mainIE.document.createElement("P");
    thisTabs.className = "mainTabStripContainer";
	return thisTabs;
}

function tabSetup(strTabName)
{
    /*
    this function will create a credentials tab for the application in the UL variable named mainTabs
    arguments:
    thisIE is the UL DHTML object this item will be appended to
    strTabName is the text name that will appear on the tab
    returns:
    LI DHTML object
    */
    thisTab = mainIE.document.createElement("button");
    thisTab.className = "mainTab";
    thisTab.innerText = strTabName;
    thisTab.onclick = activateTab
    return thisTab;
}

function quitButtonSetup()
{
    /*
    create my quit button for terminating the application, it should appear in the title window
    arguments:
    none
    returns:
    none
    */
    thisButton = mainIE.document.createElement("button");
    thisButton.className = "mainQuitButton";
	thisButton.innerText = "Quit";
	thisButton.onclick = terminateApplication
	return thisButton;
}

function terminateApplication()
{
     /*
        this is what excutes when the Quit button is pushed
        arguments:
        none
        returns:
        none
    */
    mainIE.Quit();
    WScript.Quit();
}

function activateTab(strTab)
{
    /* input:
       the tab variable that has been activated
       return:
       nothing really, this more procedural than anything
    */
    //if this function was called by a button click then we'll need to use this to get the data about the button
    if(typeof(strTab) == "undefined")
	{
	    strTab = this.innerText;
	}
    mainStatus.innerText = "Activating tab " + strTab;
    //first I'll have remove everything below
	colTabs = mainTabs.getElementsByTagName("button");
	for(var i=0; i<colTabs.length; i++)
	{
		if(colTabs[i].innerText == strTab)
         {
            colTabs[i].className = "mainTabActive";
		} else {
		    colTabs[i].className = "mainTabInactive";
		}
	}
	//third I'll have to read variables and draw the data for the tab
	changeInputForm(strTab);
	mainStatus.innerText = "Waiting for user input";
}

function changeInputForm(strTab)
{
    /*
	creates the user input field for each "tab"
	arguments:
	the name of the "tab" the user clicked on
	retruns:
	nothing really, just draws the form on screen
	*/
    formExists = false;   //boolean flag for my for loop to see if the requested table exists already
    colForms = mainIE.document.getElementsByTagName("table");
	for (j=0; j<colForms.length; j++)
	{
	    if (colForms[j].id == "myActiveForm")
        {
			mainIE.document.body.removeChild(colForms[j]);  //get rid of an existing form that might be in the way
		}
	}
    currentTable = mainIE.document.createElement("table");
    currentTable.className = "mainActiveFormTable";
    currentTable.id = "myActiveForm";
    mainIE.document.body.appendChild(currentTable);
    currentRow = currentTable.insertRow();
    currentCell = currentRow.insertCell();
    currentCell.className = "mainSubTabsTitle";
    currentCell.innerText = strTab;
    switch(strTab) {
		case "Workstations":
			drawWorkstationForm(currentTable);
		break
		case "Credentials":
			drawCredentialsForm(currentTable);
		break
		case "Execute":
		    drawOutputForm(currentTable);
		break
    }
}

function drawCredentialsForm(tblAppend)
{
    /* --------------------------------------------------------
	Draws all of the buttons for the Workstation input form
	arguments:
	given the form table to append to
	returns:
	none
	---------------------------------------------------------*/
	//create my appended table
	userRequestedScanTermination = false;
	currentRow = tblAppend.insertRow();
	currentCell = currentRow.insertCell();
	currentCell.className = "mainInputContainer";
	//create and append the title of the first field (username)
	crdFormatTable = mainIE.Document.createElement("table");
	crdFormatTable.className = "mainInputTable";
    currentCell.appendChild(crdFormatTable);
	userRow = crdFormatTable.insertRow();
	userDesc = userRow.insertCell();
	userDesc.innerText = "Username:";
	userNameInput = userRow.insertCell();
	userNameInputBox = mainIE.Document.createElement("input");
	userNameInputBox.id = "userNameInputBox";
	userNameInputBox.value = "";
	userNameInputBox.className = "mainCredentialInputField";
	userNameInput.appendChild(userNameInputBox);
	passwordRow = crdFormatTable.insertRow();
	passwordDesc = passwordRow.insertCell();
	passwordDesc.innerText = "Password:";
	passwordInput = passwordRow.insertCell();
	passwordInputBox = mainIE.Document.createElement("input");
	passwordInputBox.id = "passwordInputBox";
	passwordInputBox.type = "password";
	passwordInputBox.value = "";
	passwordInputBox.className = "mainCredentialInputField";
	passwordInput.appendChild(passwordInputBox);
	//create and append Add button 
	addButtonRow = crdFormatTable.insertRow();
	addButtonDesc = addButtonRow.insertCell();
	addButtonCell = addButtonRow.insertCell();
	myAddButton = createCredentialAddButton();
	addButtonCell.appendChild(myAddButton);
	credentialsListTable = createCredentialsListTable(currentCell);
}

function createCredentialsListTable()
{
    /*
    puts in the list of credentials or lack thereof
    */
    try
    {
        var targetToRemove = mainIE.document.getElementById("credentialsListTable");
        currentCell.removeChild(targetToRemove);
    }
    catch(err)
    {
        //bupkis
    }
    var myTable = mainIE.document.createElement("table");
    myTable.id = "credentialsListTable";
    myTable.className = "mainCredentialsList";
    if(credArray.length == 1 && credArray[0][0] == "")
    {
         onlyRow = myTable.insertRow();
         onlyCell = onlyRow.insertCell();
         onlyCell.className = "mainCredBlankList";
         onlyCell.innerText = "No credentials currently added, type in domain\\username and password and click the Add button.";    
    }
    else
    {
         for(var i=0; i<credArray.length; i++)
         {
              newRow = myTable.insertRow();
              newCell = newRow.insertCell();
              newCell.className = "mainCredListItemRemoveCell";
              newCell.appendChild(removeCredButtonSetup("cred" + i));
              newCell = newRow.insertCell();
              newCell.className = "mainCredListItemTitleCell";
              newCell.innerText = credArray[i][0];
         }
    }
    currentCell.appendChild(myTable);
}

function removeCredButtonSetup(inputCred)
{
    thisButton = mainIE.document.createElement("button");
    thisButton.className = "mainRemoveCredButton";
    thisButton.id = inputCred;
    thisButton.innerText = "Remove";
    thisButton.onclick = removeFromCredArray
    return thisButton;
}

function removeFromCredArray()
{
    if(credArray.length < 2)
    {
        credArray[0] = new Array("","");
    }
    else
    {
        for(var i=0; i<credArray.length; i++)
        {
            if(this.id == ("cred" + i))
            {
                credArray.splice(i,1);
            }
        }
    }
    createCredentialsListTable();
}

function createCredentialAddButton()
{
    /*
    create my Add button adding credentials to the list of username/password combos
    arguments:
    none
    returns:
    none
    */
    thisButton = mainIE.document.createElement("button");
    thisButton.className = "mainCredAddButton";
	thisButton.innerText = "Add";
	thisButton.onclick = appendCredentials
	return thisButton;
}

function appendCredentials()
{
    var objShell = new ActiveXObject("WScript.Shell");
    if(mainIE.document.getElementById("userNameInputBox").value == "")
    {
        objShell.Popup("No username and\/or password specified.", 0, "Error", 0x0 + 0x20000 );
        return;
    }
    strUsername = mainIE.document.getElementById("userNameInputBox").value.toString();
    strPassword = mainIE.document.getElementById("passwordInputBox").value.toString();
    if(credArray.length == 1 && credArray[0][0] == "")
    {
        credArray[0] = new Array(strUsername, strPassword);
    }
    else
    {
        credArray.push(new Array(strUsername, strPassword));
    }
    createCredentialsListTable(mainIE.document.getElementById("credentialDisplayCell"));
}

function drawOutputForm(tblAppend)
{
    /* --------------------------------------------------------
	  Draws all of the Items for the Output web form
	  arguments:
	   given the form table to append to
	  returns:
	   none
	--------------------------------------------------------*/
	currentRow = tblAppend.insertRow();
	currentCell = currentRow.insertCell();
	currentCell.className = "mainInputContainer";
	//create and append the title of the first field (hostname)
	outputFormatTable = mainIE.Document.createElement("table");   //create table inside of table
	hostRow = outputFormatTable.insertRow();   //create the first row
	hostDesc = hostRow.insertCell();
	hostDesc.className = "mainLabelCell";
	hostDesc.innerText = "Target Host(s):";   //display Target Host: in the left cell
	hostNameInput = hostRow.insertCell();
	hostNameInputBox = mainIE.Document.createElement("input");
	hostNameInputBox.onchange = updateHostnameInfo
	hostNameInputBox.value = outputArray[0];
	hostNameInputBox.className = "mainInputTargetBox";
	hostNameInput.appendChild(hostNameInputBox); //display the input box for hostname in the right cell
	isDcRow = outputFormatTable.insertRow();    //setup for row that has the AD checkbox in it
	isDcRowInput = isDcRow.insertCell();
	isDcRowInput.className = "mainInputDcCheckbox";
	isDcInputBox = mainIE.Document.createElement("input");
	isDcInputBox.onchange = updateIsDcInfo
	isDcInputBox.type = "checkbox";
	if (outputArray[1] == true)
	{
	    isDcInputBox.defaultChecked = true;
	}
	else
	{
	    isDcInputBox.defaultChecked = false;
    }
 	isDcRowInput.appendChild(isDcInputBox);
	isDcRowDesc = isDcRow.insertCell();
	isDcRowDesc.innerText = "Check this box if the specified system is an Active Directory DC and you would like to scan all systems in the directory.";
	//**********   filter input section   *************
	filterRow = outputFormatTable.insertRow();
	filterRowDescriptionCell = filterRow.insertCell();
	filterRowDescriptionCell.className = "mainFilterDescriptionCell";
	filterRowDescriptionCell.innerText = "Filter:";
	filterRowOptionsCell = filterRow.insertCell();
	filterOptionsTable = mainIE.Document.createElement("table");  //table (should be 2 columns by 3 row that will hold radio objects and their descriptions
	filterRowOptionsCell.appendChild(filterOptionsTable);
	//setup the "Servers Only" option
	filterOptionsTableServersOnlyRow = filterOptionsTable.insertRow();
	filterOptionsTableServersOnlyChoiceCell = filterOptionsTableServersOnlyRow.insertCell();
	filterOptionsTableServersOnlyChoiceCell.appendChild(setupFilterOption("Servers Only"));
	filterOptionsTableServersOnlyDescription = filterOptionsTableServersOnlyRow.insertCell();
	filterOptionsTableServersOnlyDescription.innerText = "Servers Only";
	//setup the "Workstations Only" option
	filterOptionsTableWorkstationsOnlyRow = filterOptionsTable.insertRow();
	filterOptionsTableWorkstationsOnlyChoiceCell = filterOptionsTableWorkstationsOnlyRow.insertCell();
	filterOptionsTableWorkstationsOnlyChoiceCell.appendChild(setupFilterOption("Workstations Only"));
	filterOptionsTableWorkstationsOnlyDescription = filterOptionsTableWorkstationsOnlyRow.insertCell();
	filterOptionsTableWorkstationsOnlyDescription.innerText = "Workstations Only";
	//setup the "None" option
	filterOptionsTableAllRow = filterOptionsTable.insertRow();
	filterOptionsTableAllChoiceCell = filterOptionsTableAllRow.insertCell();
	filterOptionsTableAllChoiceCell.appendChild(setupFilterOption("All"));
	filterOptionsTableAllDescription = filterOptionsTableAllRow.insertCell();
	filterOptionsTableAllDescription.innerText = "None (all systems scanned)";
	//setup for button labeled "Run..."
	execRow = outputFormatTable.insertRow();
	execRowButtonCell = execRow.insertCell();
	execRowButtonCell.appendChild(setupExecButton());
	execRowTextCell = execRow.insertCell();
	execRowTextCell.innerText = "Click this button to execute a scan.";
	currentCell.appendChild(outputFormatTable);
}

function setupExecButton()
{
    /*
        creates a button that runs this whole process
    */
    myButton = mainIE.Document.createElement("button");
    myButton.className = "mainExecButton";
	myButton.onclick = execScan
	myButton.innerText = "Run...";
	return myButton;
}

function setupFilterOption(strOptionChoosen)
{
    var objFilterChoice = mainIE.document.createElement("input");
    objFilterChoice.type = "radio";
    objFilterChoice.className = "inputFilterRadioChoice";
    objFilterChoice.name = "filterGroup";
    switch(strOptionChoosen)
    {
        case "Servers Only":
            objFilterChoice.value = "Servers Only";
            objFilterChoice.id = "SERVERONLYCHOICE";
            objFilterChoice.onclick = serversOnlyFilterClicked
        break
        case "Workstations Only":
            objFilterChoice.value = "Workstations Only";
            objFilterChoice.id = "WORKSTATIONONLYCHOICE";
            objFilterChoice.onclick = workstationsOnlyFilterClicked
        break
        case "All":
            objFilterChoice.value = "All";
            objFilterChoice.id = "ALLCHOICE";
            objFilterChoice.onclick = allFilterClicked
        break
    }
    if(outputArray[2] == strOptionChoosen)
    {
        objFilterChoice.defaultChecked = true;
    }
    return objFilterChoice;
}

function serversOnlyFilterClicked()
{
    /* This is what executes when the users click the radio option named "Servers Only" it uses the changeInputForm function
    to redraw the entire tab form because I am too stupid to figure out how to make my radio buttons all behave like they're
    part of the same form ... it works but causes a slight delay when the user interacts with this part of the form */
    outputArray[2] = "Servers Only";
    changeInputForm("Execute");
}

function workstationsOnlyFilterClicked()
{
    /* User clicks the "Workstations Only" radio option */
    outputArray[2] = "Workstations Only";
    changeInputForm("Execute");
}

function allFilterClicked()
{
     /* User clicks the "None (all systems scanned)" radio option */
    outputArray[2] = "All";
    changeInputForm("Execute");
}

function drawWorkstationForm(tblAppend)
{
    /* --------------------------------------------------------
	Draws all of the buttons for the Workstation input form
	arguments:
	given the form table to append to
	returns:
	none
	---------------------------------------------------------*/
	currentRow = tblAppend.insertRow();
	currentCell = currentRow.insertCell();
	currentCell.className = "mainInputContainer";
	tableButtons = mainIE.Document.createElement("table");
	currentCell.appendChild(tableButtons);
	rowButton = new Array();
	for (i=0; i<wksArray.length; i++)
	{
	    rowButton[i] = new Array(2);
	    tempRow = tableButtons.insertRow();
	    rowButton[i][0] = tempRow.insertCell();
	    currentButton = mainIE.Document.createElement("button");
		currentButton.innerText = wksArray[i][2];
		rowButton[i][0].appendChild(currentButton);
		if(wksArray[i][1] == false)
		{
		    currentButton.className = "mainWorkstationUnselected";
		} else {
		    currentButton.className = "mainWorkstationSelected";
		}
		currentButton.onclick = wksItemActivate
		//insert the description here
		rowButton[i][1] = tempRow.insertCell();
		rowButton[i][1].innerText = wksArray[i][3];
	}
}

function wksItemActivate()
{
    /*
	when a button is clicked on the Workstations form this function is invoked and two things should happen.
	First the button should change color and second the related array field should toggle its boolean value...
	arguments:
	none
	returns:
	none
	*/
	//set the array opposite of whatever it is..
	for(var i=0; i<wksArray.length; i++)
	{
		if(this.innerText == wksArray[i][2])
		{
			if(wksArray[i][1])
			{
				wksArray[i][1] = false;
				this.className = "mainWorkstationUnselected";
			}
			else
			{
				wksArray[i][1] = true;
				this.className = "mainWorkstationSelected";
			}
		}
	}
}

function updateHostnameInfo()
{
    /*
    when ever a user changes the value ot the hostname field this will update the master array
    this is triggered by the javascript onChange event tied to the textbox
    */
    outputArray[0] = this.value;
}

function execScan()
{
     /*
     this is what happens the the Run button is clicked on the Output form...
     */
     mainIE.Visible = 0;  //I have no idea why this will happen but the next bit of code will not complete until after the scan finishes
     //anyway this has to be done and IE completely restarted later because if the script is off doing a scan this hidden IE
     //window just magically disappears.  But in case it doesn't I have to try to kill it...  weak.
     try
     {
         mainIE.Quit();
     }
     catch(err)
     {
        //I really don't care
     }
     workstationScan();
     ieMainSetup();
}

/* --------------------------------------------------------------------------------
***********************************************************************************
Workstation Scan portion Internet Explorer setup and manipulation functions (DHTML)
***********************************************************************************
---------------------------------------------------------------------------------*/

function scanIeSetup()
{
    /*
      create my internet explore object the way I want it and return it
      arguemnts:
      returns:
      Returns an unhiden internet explorer object
    */
    var objShell = new ActiveXObject("WScript.Shell");
    
    scanIE = WScript.CreateObject("InternetExplorer.Application");   //ieObject for workstation scan output use
    scanIE.Navigate("about:blank");
    scanIE.Toolbar = 0;
    scanIE.StatusBar = 0;
    scanIE.Width = 1024;
    scanIE.Height = 450;
    configureScanIeStyleSheets();
    scanIE.Resizable = true;
	while (scanIE.Busy)
    {
        WScript.Sleep(200);
    }
    scanIE.document.title = strAppTitle;
    scanIE.Visible = 1;
    WScript.Sleep(50);
    objShell.AppActivate(strAppTitle);
    objScanIeQuitButton = scanQuitButtonSetup();
    scanIE.document.body.appendChild(objScanIeQuitButton);
    scanHeader = scanHeaderSetup();  //the doc header...
    scanHeader.innerText = strAppTitle;
    scanIE.Document.body.appendChild(scanHeader);
    scanStatus = scanStatusSetup();
    scanIE.Document.body.appendChild(scanStatus);
}

function configureScanIeStyleSheets()
{
    /* creates css rules (mostly classes) and their properties for use else where in the script,
       this should help reduce the size of the script */
     
    scanIE.document.createStyleSheet();
    var scanCss = scanIE.document.styleSheets[0];
    //BODY element rules
    scanCss.addRule("body","margin: 0px");
    scanCss.addRule("body","padding: 0px");
    scanCss.addRule("body","font-family: Arial");
    scanCss.addRule("body","background: #fff");
    //.scanHeader class rules
	scanCss.addRule(".scanHeader","background: #333");
	scanCss.addRule(".scanHeader","border: 1px solid #000");
	scanCss.addRule(".scanHeader","color: #fff");
	scanCss.addRule(".scanHeader","font-size: 1.0em");
	scanCss.addRule(".scanHeader","font-weight: Bold");
	scanCss.addRule(".scanHeader","padding: 8px");
	scanCss.addRule(".scanHeader","margin: 0px");
	//.scanStatus class rules
	scanCss.addRule(".scanStatus","background: #eee");
    scanCss.addRule(".scanStatus","border-bottom: 1px solid #888");
    scanCss.addRule(".scanStatus","color: #000");
    scanCss.addRule(".scanStatus","font-size: 12px");
    scanCss.addRule(".scanStatus","padding-left: 10px");
	scanCss.addRule(".scanStatus","padding-top: 2px");
	scanCss.addRule(".scanStatus","padding-bottom: 2px");
    scanCss.addRule(".scanStatus","margin: 0px");
	//.scanReportAppButton class rules
	scanCss.addRule(".scanReportAppButton","background: #ccc");
	scanCss.addRule(".scanReportAppButton","color: 000");
	scanCss.addRule(".scanReportAppButton","border: 1px solid #fff");
	scanCss.addRule(".scanReportAppButton","float: left");
	scanCss.addRule(".scanReportAppButton","margin: 1px");
	scanCss.addRule(".scanReportAppButton","margin-right: 0px");
	scanCss.addRule(".scanReportAppButton","text-align: left");
	scanCss.addRule(".scanReportAppButton","font-size: 11px");
	//.scanReportServicesButton class rules
	scanCss.addRule(".scanReportServicesButton","background: #ccc");
	scanCss.addRule(".scanReportServicesButton","color: 000");
	scanCss.addRule(".scanReportServicesButton","border: 1px solid #fff");
	scanCss.addRule(".scanReportServicesButton","float: left");
	scanCss.addRule(".scanReportServicesButton","margin: 1px");
	scanCss.addRule(".scanReportServicesButton","margin-right: 0px");
	scanCss.addRule(".scanReportServicesButton","text-align: left");
	scanCss.addRule(".scanReportServicesButton","font-size: 11px");
	//.scanQuitButton class rules
	scanCss.addRule(".scanQuitButton","background: #eee");
	scanCss.addRule(".scanQuitButton","color: #000");
	scanCss.addRule(".scanQuitButton","border: 1px solid #fff");
	scanCss.addRule(".scanQuitButton","float: right");
	scanCss.addRule(".scanQuitButton","margin-top: 8px");
	scanCss.addRule(".scanQuitButton","margin-right: 7px");
	scanCss.addRule(".scanQuitButton","width: 60px");
	scanCss.addRule(".scanQuitButton","font-size: 11px");
	//.scanExcelButton class rules
	scanCss.addRule(".scanExcelButton","background: #eee");
	scanCss.addRule(".scanExcelButton","color: #000");
	scanCss.addRule(".scanExcelButton","border: 1px solid #fff");
	scanCss.addRule(".scanExcelButton","float: right");
	scanCss.addRule(".scanExcelButton","margin-top: -29px");
	scanCss.addRule(".scanExcelButton","margin-right: 125px");
	scanCss.addRule(".scanExcelButton","width: 60px");
	scanCss.addRule(".scanExcelButton","font-size: 11px");
	//.scanVisioButton class rules
	scanCss.addRule(".scanVisioButton","background: #eee");
	scanCss.addRule(".scanVisioButton","color: #000");
	scanCss.addRule(".scanVisioButton","border: 1px solid #fff");
	scanCss.addRule(".scanVisioButton","float: right");
	scanCss.addRule(".scanVisioButton","margin-top: -29px");
	scanCss.addRule(".scanVisioButton","margin-right: 4px");
	scanCss.addRule(".scanVisioButton","width: 60px");
	scanCss.addRule(".scanVisioButton","font-size: 11px");
	//.scanTextButton class rules
	scanCss.addRule(".scanTextButton","background: #eee");
	scanCss.addRule(".scanTextButton","color: #000");
	scanCss.addRule(".scanTextButton","border: 1px solid #fff");
	scanCss.addRule(".scanTextButton","float: right");
	scanCss.addRule(".scanTextButton","margin-top: -29px");
	scanCss.addRule(".scanTextButton","margin-right: 4px");
	scanCss.addRule(".scanTextButton","width: 60px");
	scanCss.addRule(".scanTextButton","font-size: 11px");
	//.scanXMLButton class rules
	scanCss.addRule(".scanXMLButton","background: #eee");
	scanCss.addRule(".scanXMLButton","color: #000");
	scanCss.addRule(".scanXMLButton","border: 1px solid #fff");
	scanCss.addRule(".scanXMLButton","float: right");
	scanCss.addRule(".scanXMLButton","margin-top: -29px");
	scanCss.addRule(".scanXMLButton","margin-right: 4px");
	scanCss.addRule(".scanXMLButton","width: 60px");
	scanCss.addRule(".scanXMLButton","font-size: 11px");
	//.scanReportTable class rules
    scanCss.addRule(".scanReportTable","font-size: 8pt");
    scanCss.addRule(".scanReportTable","width: 100%");
    scanCss.addRule(".scanReportTable","padding: 1px");
    //.scanReportHeadRow class rules
    scanCss.addRule(".scanReportHeadRow","background: #000");
    scanCss.addRule(".scanReportHeadRow","color: #fff");
    //.scanReportDataCell class rules
    scanCss.addRule(".scanReportDataCell","background: #eee");
    scanCss.addRule(".scanReportDataCell","color: #000");
}

function scanHeaderSetup()
{
    /*
    create my header object the way I want stylistically for use in the DHTML document
        arguemnts:
        pass the internet explorer object that we'll be using as the UI
        returns:
        DHTML H1 object for use with Internet Explorer
    */
	thisHeader = scanIE.document.createElement("H1");
	thisHeader.className = "scanHeader";
	thisHeader.innerText = "Documentor";
	return thisHeader;
}

function scanStatusSetup()
{
    /*
    create my status object the way I want stylistically for use in the DHTML document
        arguments:
        pass the internet explorer object that we'll be using as the UI
        returns:
        DHTML p object for use with internet explorer
    */
    thisStatus = scanIE.document.createElement("P");
    thisStatus.className = "scanStatus";
	thisStatus.innerText = "Initializing ...";
    return thisStatus;
}

function scanQuitButtonSetup()
{
    /*
    create my quit button for terminating the scan process, it should appear in the title window
    arguments:
    none
    returns:
    none
    */
    thisButton = scanIE.document.createElement("button");
    thisButton.className = "scanQuitButton";
	thisButton.innerText = "Stop Scan";
	thisButton.onclick = terminateScan
	return thisButton;
}

function scanApplicationToggleButtonSetup(inputArray)
{
    /*
    create my quit button for terminating the scan process, it should appear in the title window
    arguments:
    none
    returns:
    none
    */
    var strFromArray = inputArray.toString();
    strFromArray = strFromArray.replace(/,/gi,"\n");
    thisButton = scanIE.document.createElement("button");
    thisButton.className = "scanReportAppButton";
	thisButton.name = strFromArray;
	thisButton.innerText = "Apps List";
	thisButton.onclick = displayApplicationsForThisHost
	return thisButton;
}

function scanServicesToggleButtonSetup(inputArray)
{
    /*
    create my quit button for terminating the scan process, it should appear in the title window
    arguments:
    none
    returns:
    none
    */
    var strFromArray = inputArray.toString();
    strFromArray = strFromArray.replace(/,/gi,"\n");
    thisButton = scanIE.document.createElement("button");
    thisButton.className = "scanReportServicesButton";
	thisButton.name = strFromArray;
	thisButton.innerText = "Services List";
	thisButton.onclick = displayServicesForThisHost
	return thisButton;
}

function scanLogsToggleButtonSetup(inputArray)
{
    /*
    create my quit button for terminating the scan process, it should appear in the title window
    arguments:
    none
    returns:
    none
    */
    var strFromArray = inputArray.toString();
    strFromArray = strFromArray.replace(/,/gi,"\n");
    thisButton = scanIE.document.createElement("button");
    thisButton.className = "scanReportServicesButton";
	thisButton.name = strFromArray;
	thisButton.innerText = "Event Log List";
	thisButton.onclick = displayLogsForThisHost
	return thisButton;
}

function excelButtonSetup()
{
    /*
    create my quit button for terminating the scan process, it should appear in the title window
    arguments:
    none
    returns:
    none
    */
    thisButton = scanIE.document.createElement("button");
    thisButton.className = "scanExcelButton";
	thisButton.innerText = "to Excel";
	thisButton.onclick = dumpToExcel
	return thisButton;
}

function visioButtonSetup()
{
    /*
    create my quit button for terminating the scan process, it should appear in the title window
    arguments:
    none
    returns:
    none
    */
    thisButton = scanIE.document.createElement("button");
    thisButton.className = "scanVisioButton";
	thisButton.innerText = "to Visio";
	thisButton.onclick = dumpToVisio
	return thisButton;
}

function textButtonSetup()
{
    /*
    create my quit button for terminating the scan process, it should appear in the title window
    arguments:
    none
    returns:
    none
    */
    thisButton = scanIE.document.createElement("button");
    thisButton.className = "scanTextButton";
	thisButton.innerText = "to Text";
	thisButton.onclick = dumpToText
	return thisButton;
}

function xmlButtonSetup()
{
    /*
    create my quit button for terminating the scan process, it should appear in the title window
    arguments:
    none
    returns:
    none
    */
    thisButton = scanIE.document.createElement("button");
    thisButton.className = "scanXMLButton";
	thisButton.innerText = "to XML";
	thisButton.onclick = dumpToXML
	return thisButton;
}

function terminateScan()
{
    /* when scan process 'quit' button is clicked this is what should execute */
    //scanIE.Quit();
    userRequestedScanTermination = true;
}

function displayApplicationsForThisHost()
{
    if(this.innerText == "Apps List")
    {
        this.innerText = this.name;
    }
    else
    {
        this.innerText = "Apps List";
    }
}

function displayServicesForThisHost()
{
    if(this.innerText == "Services List")
    {
        this.innerText = this.name;
    }
    else
    {
        this.innerText = "Services List";
    }
}

function displayLogsForThisHost()
{
    if(this.innerText == "Event Log List")
    {
        this.innerText = this.name;
    }
    else
    {
        this.innerText = "Event Log List";
    }
}

function updateIsDcInfo()
{
     /*
     when ever a user checks of unchecks the box indicating that the hostname is a of DC and that
     they would like to run a domain scan this function updates the global array value
     */
     if (this.checked == true) {
         outputArray[1] = true;
     }
     else
     {
         outputArray[1] = false;
     }
}

/*------------------------------------------------
Data Initization and Handling Functions
-------------------------------------------------*/

function initializeWksArray()
{
    /* 
	This function will work on the the global array wksArray which should have been previously declared outside of main()
	arguments:
	none
	returns:
	none
	*/
	wksArray[0] = new Array("wksName", true, "Name", "Return the systems netbios name as reported by WMI.");
	wksArray[1] = new Array("wksIP",false, "IP Address", "Returns and all IP addresses on active network adapters.");
	wksArray[2] = new Array("wksCPU",true, "CPU(s)", "Get system processor speed and model.");
	wksArray[3] = new Array("wksRAM",true, "System Memory", "Displays size of main system memory.");
	wksArray[4] = new Array("wksMake",true, "System Make", "Return the manufacturer name reported by the BIOS.");
	wksArray[5] = new Array("wksModel",false, "System Model", "Return the system model name reported by the BIOS.");
	wksArray[6] = new Array("wksOS",true, "Operating System", "Get the version and service pack level of Windows .");
	wksArray[7] = new Array("wksWPK",false, "Windows Product Key", "Get the product key used to install\/activate Windows.");
	wksArray[8] = new Array("wksSerial",true, "Serial Number", "Display the serial number reported by the system BIOS.");
	wksArray[9] = new Array("wksLastUser",false, "Last User Logon", "*not yet functioning*");
	wksArray[10] = new Array("wksVideo",false, "Video Adapter(s)", "Show the grapics adapters installed on the target system.");
	wksArray[11] = new Array("wksAudio",false, "Audio Adapter(s)", "Display the audio cards installed on the target system.");
	wksArray[12] = new Array("wksNetwork",false, "Network Adapter(s)", "List the network cards install on the target system.");
	wksArray[13] = new Array("wksOffice",false,"Microsoft Office", "Get the versions and licese codes for MS Office on the target system.");
	wksArray[14] = new Array("wksDisk",false, "Hard Disk(s)", "Get the harddisk models and capacities installed on the target system.");
	wksArray[15] = new Array("wksApps",false,"Application Report", "Return a list of installed applications from the registry.");
	wksArray[16] = new Array("wksServices",false,"Report Services", "Gets list of Services, State, and Start-Up type.");
	wksArray[17] = new Array("wksLogs",false,"Report Logs", "Compressed report of Error and Warnings in Windows Event Logs.");
}

function initializeCredArray()
{
    /* 
	This function will work on the the global array credArray which should have been previously declared outside of main()
	arguments:
	none
	returns:
	none
	*/
	var WshNetwork = WScript.CreateObject("WScript.Network");
	credArray[0] = new Array("","");
}

function initializeOutputArray()
{
     /*
     This function will work on the global array outArray which should have been previously declared outside of main() (scope is global)
     arguments:
     none
     returns:
     none
     */
     var WshNetwork = WScript.CreateObject("WScript.Network");
     outputArray[0] = WshNetwork.ComputerName;
     outputArray[1] = true;
     outputArray[2] = "All";
}

function workstationScan()
{
    /*
    This is where the work happens ...
    */
    var objFso = new ActiveXObject("Scripting.FileSystemObject");
    targetPath = WScript.ScriptFullName.substr(0,WScript.ScriptFullName.length - WScript.ScriptName.length) + "targets.txt";
    //Setup Internet Explorer for my scan process
    scanIeSetup();
    //Run one of the following function based on scan type
    if(!objFso.FileExists(targetPath))
    {
        if(outputArray[1]) {
            domainScan();
        }
        else
        {
            singleScan();
        }
    }
    else
    {
        targetsFileScan(targetPath);
    }
    //when done and this function is terminated the user will be dropped back out to the input screen.
    scanIE.Quit();
}

function userAccessCredentials(hostName)
{
    var wshNetwork = WScript.CreateObject("WScript.Network");
    var returnArray = new Array("","");
    if(hostName.toUpperCase() == wshNetwork.ComputerName.toUpperCase() || hostName.toUpperCase() == "LOCALHOST" || hostName == ".")
    {
        return returnArray;
    }
    else if(credArray.length > 0)
    {
        for(var i=0; i<credArray.length; i++)
        {
            try
            {
                var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
                var objWMIService = objLocator.ConnectServer(hostName,"root\\default",credArray[i][0],credArray[i][1],"","",128);
                returnArray[0] = credArray[i][0];
                returnArray[1] = credArray[i][1];
                return returnArray;
            }
            catch(err)
            {
                if(err.number == -2147217308)  //this error occurs if you try to access a local system with credentials
                {    
                     return returnArray;
                }   
            }
        }
    }
}

function isHostWmiAccessible(hostName)
{
    try
    {
        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName,"root\\default",currentHostCredentials[0],currentHostCredentials[1],"","",128);
        return true;
    }
    catch(err)
    {
        return false;   
    }
}
    
function reportProductKey(hostName)
{
    /*
    function reportProductKey
    given: hostName - string with the target computer name
    returns: string with the Windows Installation Product Key used
    
    The Windows Product Key is stored in the registry in the key
    HKLM\Software\Microsoft\Windows NT\CurrentVersion\DigitalProductID.  It is encode
    in Big Endian byte order, base-24 encoded.        
    */    
    try
    {
        var bDigitalProductID ="";
        var bProductKey = new Array(15);   //binary data for the characters in array format
        var bKeyChars = new Array(24);    //the array mapping asci characters to their binary number
        var ilByte = "";    //counter to be used to read bytes into the array
        var nCur = "";
        var sCDKey = "";
        var ilKeyByte = "";
        var ilBit = "";
        
        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName,"root\\default",currentHostCredentials[0],currentHostCredentials[1],"","",128);
        objWMIService.Security_.ImpersonationLevel = 3;
        var objRegistry = objWMIService.Get("StdRegProv");
        var objMethod = objRegistry.Methods_("GetBinaryValue");
        var objInParam = objMethod.inParameters.SpawnInstance_();
        objInParam.hDefKey = 0x80000002;
        objInParam.sSubKeyName = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion";
        objInParam.sValueName = "DigitalProductId";
        var objOutParam = objRegistry.ExecMethod_("GetBinaryValue", objInParam);
        bDigitalProductID = objOutParam.uValue.toArray();
        objShell = null;
        for(ilByte = 52; ilByte <= 66; ilByte++)
        {
            bProductKey[ilByte - 52] = bDigitalProductID[ilByte];
        }
        //Possible characters in the CD Key:
        //the key is base 24 encoded, this is the mapping from that base to 
        //the characters you're used to entering at the installation wizard
        bKeyChars[0] = Asc("B");
        bKeyChars[1] = Asc("C");
        bKeyChars[2] = Asc("D");
        bKeyChars[3] = Asc("F");
        bKeyChars[4] = Asc("G");
        bKeyChars[5] = Asc("H");
        bKeyChars[6] = Asc("J");
        bKeyChars[7] = Asc("K");
        bKeyChars[8] = Asc("M");
        bKeyChars[9] = Asc("P");
        bKeyChars[10] = Asc("Q");
        bKeyChars[11] = Asc("R");
        bKeyChars[12] = Asc("T");
        bKeyChars[13] = Asc("V");
        bKeyChars[14] = Asc("W");
        bKeyChars[15] = Asc("X");
        bKeyChars[16] = Asc("Y");
        bKeyChars[17] = Asc("2");
        bKeyChars[18] = Asc("3");
        bKeyChars[19] = Asc("4");
        bKeyChars[20] = Asc("6");
        bKeyChars[21] = Asc("7");
        bKeyChars[22] = Asc("8");
        bKeyChars[23] = Asc("9");
    
        for(ilByte = 24; ilByte >= 0; ilByte--)
        {
            nCur = 0; 
            for(ilKeyByte = 14; ilKeyByte >= 0; ilKeyByte--)
            {
                //Step through each byte in the Product Key
                nCur = nCur * 256 ^ bProductKey[ilKeyByte];
                bProductKey[ilKeyByte] = Math.floor(nCur / 24);
                nCur = nCur % 24;
            }
            sCDKey = String.fromCharCode(bKeyChars[nCur]) + sCDKey;
            if(ilByte % 5 == 0 && ilByte != 0)
            {
                sCDKey = "-" + sCDKey;
            }
        }
        return sCDKey;
    }
    catch(err)
    {
        return "[Error: " + err.description + "]";
    }
}
    
function reportSerial(hostName)
{
    /*
    function reportSerial
    given: hostName - string with the target computer name
    returns: string with the system's serial number read out of WMI
   
    Sometimes this field is blank or in-appropriately populated by an OEM or hardware 
    manufacturer.  That being said, if the information doesn't look right, than it might
    be best just not to use it.
    */ 
    try
    {
        var wbemFlagReturnImmediately = 0x10;
        var wbemFlagForwardOnly = 0x20;
        var serialNumber;
    
        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName, "root\\cimv2",currentHostCredentials[0],currentHostCredentials[1],"","",128);
        objWMIService.Security_.ImpersonationLevel = 3;
        var colItems = objWMIService.ExecQuery("SELECT * FROM Win32_SystemEnclosure", "WQL", wbemFlagReturnImmediately | wbemFlagForwardOnly);
    
        var enumItems = new Enumerator(colItems);
        for (; !enumItems.atEnd(); enumItems.moveNext())
        {
            var objItem = enumItems.item();
            serialNumber = objItem.SerialNumber;
        }
        return serialNumber;
    }
    catch(err)
    {
        return "[Error: " + err.description + "]";
    }
}

function reportVideo(hostName)
{
    /*
    function reportVideo
    given: hostName - string with the target computer name
    returns: string with the video card description
      
    Gets the video card model from WMI and returns it.
    */
    try
    {
        var wbemFlagReturnImmediately = 0x10;
        var wbemFlagForwardOnly = 0x20;
        var videoCard = new Array();
 
        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName, "root\\cimv2",currentHostCredentials[0],currentHostCredentials[1],"","",128);
        objWMIService.Security_.ImpersonationLevel = 3;
        var colItems = objWMIService.ExecQuery("SELECT * FROM Win32_VideoController", "WQL", wbemFlagReturnImmediately | wbemFlagForwardOnly);
 
        var enumItems = new Enumerator(colItems);
        for (; !enumItems.atEnd(); enumItems.moveNext())
        {
            var objItem = enumItems.item();
            videoCard.push(objItem.VideoProcessor);
        }
        if(typeof(videoCard[0]) == "undefined")
        {
            return new Array("No video card found.  Something is most likely very wrong here.");
        }
        else
        {
            return videoCard;
        }
    }
    catch(err)
    {
        return "[Error: " + err.description + "]";
    }
}
   
function reportAudio(hostName)
{
    /*
    function reportAudio
    given: hostName - string with the target computer name
    returns: string with the audio card description
    
    Gets the audio card model from WMI and returns it.
    */
    try
    {
        var wbemFlagReturnImmediately = 0x10;
        var wbemFlagForwardOnly = 0x20;
        var audioCard = new Array();
 
        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName, "root\\cimv2",currentHostCredentials[0],currentHostCredentials[1],"","",128);
        objWMIService.Security_.ImpersonationLevel = 3;
        var colItems = objWMIService.ExecQuery("SELECT * FROM Win32_SoundDevice", "WQL", wbemFlagReturnImmediately | wbemFlagForwardOnly);
 
        var enumItems = new Enumerator(colItems);
        for (; !enumItems.atEnd(); enumItems.moveNext())
        {
            var objItem = enumItems.item();
            audioCard.push(objItem.Description);
        }
        if(typeof(audioCard[0]) == undefined)
        {
            return new Array("No audio cards found.");
        }
        else
        {
            return audioCard;
        }
    }
    catch(err)
    {
        return "[Error: " + err.description + "]";
    }
}

function reportNetwork(hostName)
{
    /*
    function reportNetwork
    given: hostName - string with the target computer name
    returns: string with the network card description
    
    Gets the network card model from WMI and returns it.
    */
    try
    {
        var wbemFlagReturnImmediately = 0x10;
        var wbemFlagForwardOnly = 0x20;
        var networkCard = new Array(); 

        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName, "root\\cimv2",currentHostCredentials[0],currentHostCredentials[1],"","",128);
        objWMIService.Security_.ImpersonationLevel = 3;
        var colItems = objWMIService.ExecQuery("SELECT * from Win32_NetworkAdapter WHERE NetConnectionStatus = 2", "WQL", wbemFlagReturnImmediately | wbemFlagForwardOnly);
    }
    catch(err)
    {
        return "[Error: " + err.description + "]";
    }
    var enumItems = new Enumerator(colItems);
    for (; !enumItems.atEnd(); enumItems.moveNext())
    {
        var objItem = enumItems.item();
        try
        {
            thisItem = enumItems.item();
            networkCard.push(thisItem.ProductName);
        }
        catch(err)
        {
             //eh, do nothing, we'll be moving onto the next device soon enough
        }
    }
    if(typeof(networkCard[0]) == "undefined")
    {
         return new Array("No active network adapters found.");
    }
    else
    {
        return networkCard;
    }
}
    
function reportIpAddress(hostName)
{
    /*
    function reportIpAddress
    given: hostName - string with the target computer name 
    returns: string with the system's ip address (wireless adapters not covered)
   
    I'm not sure what will happen if the system doesn't have a network adapter but 
    considering most of the systems this script will be communicating with will be across
    the network it SHOULDN'T be an issue.
    */
    var accum = new Array();  //string that will accumulate the IP addresses I catch
    try  //we'll try this seperate of the rest of the IP collection, as I'm counting on failers when there is no array of IPs on an adapter
    {
        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");

        var objWMIService = objLocator.ConnectServer(hostName, "root\\cimv2",currentHostCredentials[0],currentHostCredentials[1],"","",128);
        var colNics = objWMIService.ExecQuery("Select * From Win32_NetworkAdapter WHERE NetConnectionStatus = 2");
    }
    catch(err)
    {
        return "[Error: " + err.description + "]";
    }
    var enumItems = new Enumerator(colNics);
    for(; !enumItems.atEnd(); enumItems.moveNext())
    {
        var objItem = enumItems.item();
        var colNicConfigs = objWMIService.ExecQuery("ASSOCIATORS OF {Win32_NetworkAdapter.DeviceID='" + objItem.DeviceID + "'}");
        var enumNics = new Enumerator(colNicConfigs);
        for(; !enumNics.atEnd(); enumNics.moveNext())
        {
            var nicItem = enumNics.item();
            try
            {
                var arrayIpAddresses = nicItem.IPAddress.toArray();  //this will actually not work most of the time, so I put it inside a try/catch to keep the script running
                var arrayIpSubnetMasks = nicItem.IPSubnet.toArray();
                for (var w = 0; w < arrayIpSubnetMasks.length; w++)  //clean up subnet masks for IPv4 so it will appear in / form, IPv6 already comes this way so it will just return the input
                {
                    arrayIpSubnetMasks[w] = convertSubnetMaskToSlash(arrayIpSubnetMasks[w]);
                }
                if(arrayIpAddresses.length != 0)
                {
                    for(var x = 0; x < arrayIpAddresses.length; x++)
                    {
                        if(arrayIpAddresses[x] != "" && arrayIpAddresses[x] != "0.0.0.0")    //ignore the field if it is empty or it the IP is reported as 0.0.0.0, the later is usually the result of no network connectivity on that adapter
                        {
                           accum.push(arrayIpAddresses[x] + "/" + arrayIpSubnetMasks[x]);   //I've added the spaces for simple formatting
                        }
                    }
                }
            }
            catch(err)
            {
                //doesn't really matter
            }            
        }
    }
    if(typeof(accum[0]) == "undefined")
    {
        return new Array("No IPs listed");
    }
    else
    {
        return accum;
    }
}


function convertSubnetMaskToSlash(strInput) 
{
    /* *******************************************************
    Take dotted decimal form of the subnet mask and
    convert it in / form number

    i.e. "255.255.240.0" => "20"
    ******************************************************** */

    if (strInput.length > 3) //if the report subnet mask isn't at least 3 chars we've been given a / form already (probably becuase the IP is IPv6 not IPv4
    {
        //split dotted decimal form into array
        arrInput = strInput.split(".");
        var intReturn = "0";
        for (var i = 0; i < arrInput.length; i++)
        {
            arrInput[i] = convertDecToBin(arrInput[i]);
            for (var j = 0; j < arrInput[i].length; j++)
            {
                if (arrInput[i].charAt(j) == "1")
                {
                    intReturn++;
                }
            }
        }
        return intReturn;
    }
    return strInput;
}

function convertBinToDec(myNum)
{
    var returnNum = 0;
    myNum = reverseString(myNum);
    for(var i = 0; i < myNum.length; i++)
    {
        returnNum += myNum.charAt(i) * Math.pow(2,i);
    }
    return returnNum;
}

function convertDecToBin(myNum)
{
    /* *******************************************************
    Take an integer input and returns a string that is a
    big-endian notation of that number in  binary
    ******************************************************** */

   var strBits = "";
   while(myNum != 0)
   {
        if(myNum == 1)
        {
            strBits += "1";
            return reverseString(strBits);
        }
        myBit = myNum % 2;
        strBits += myBit.toString();
        myNum = Math.floor(myNum / 2);
   }
   if (strBits == "")
   {
       return "0";
   }
   else
   {
       return reverseString(strBits);
   }
}

function reverseString(myString)
{
    /* ******************************************************
    need this function converting decimal to binary
    my function returnDecFromBin return the binary
    number in little endian otherwise
    ****************************************************** */

    var strReturn = "";
    for(var i = myString.length; i > -1; i--)
    {
        strReturn += myString.charAt(i);
    }
    return strReturn;
}


function reportWmiHostName(hostName)
{
    /*
    function reportWmiHostName
    given: hostName - string with the target computer name
    returns: string with the system's hostname read out of WMI
   
    This is neccesary as the script can be called using a FQDN or IP to connect to the 
    remote host, and I want to make sure the output data is normalized and the application
    reports only Windows NetBIOS style names.
    */
    try
    {
        var wbemFlagReturnImmediately = 0x10;
        var wbemFlagForwardOnly = 0x20;
        var serialNumber;
 
        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName, "root\\cimv2",currentHostCredentials[0],currentHostCredentials[1],"","",128);
        objWMIService.Security_.ImpersonationLevel = 3;
        var colItems = objWMIService.ExecQuery("SELECT * FROM Win32_ComputerSystem", "WQL", wbemFlagReturnImmediately | wbemFlagForwardOnly);
 
        var enumItems = new Enumerator(colItems);
        for (; !enumItems.atEnd(); enumItems.moveNext())
        {
            var objItem = enumItems.item();
            serialNumber = objItem.Caption;
        }
        return serialNumber;
    }
    catch(err)
    {
        return hostName + "[Error: " + err.description + "]";
    }
}

function reportOS(hostName)
{
    /*
    function reportOS
    given: hostName - string with the target computer name
    returns: string with the system's Operating System name and type read out of WMI and
           service pack level if any read out of the registry
       
    WMI again was the best way to get the product name programmatically as it would report
    professional, home, stardard, or enterprise editions of windows.  The service pack
    level was easily handled with a registry read.          
    */
    try
    {
        var wbemFlagReturnImmediately = 0x10;
        var wbemFlagForwardOnly = 0x20;
        var serialNumber;

        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName, "root\\cimv2",currentHostCredentials[0],currentHostCredentials[1],"","",128);
        objWMIService.Security_.ImpersonationLevel = 3;
        
        var colItems = objWMIService.ExecQuery("SELECT * FROM Win32_OperatingSystem");
        var enumItems = new Enumerator(colItems);
        var strAccumOSes = "";
        for (; !enumItems.atEnd(); enumItems.moveNext())
        {
            var objItem = enumItems.item();
            strAccumOSes = strAccumOSes+objItem.Caption;
            if (objItem.ServicePackMajorVersion != 0)
            {
                strAccumOSes = strAccumOSes+" SP"+Math.round(objItem.ServicePackMajorVersion);
            }
        }
        return strAccumOSes;
    }
    catch(err)
    {
        return "[Error: " + err.description + "]";
    }
}

function reportMake(hostName)
{
    /*
    function reportMake
    given: hostName - string with the target computer name
    returns: string with the system's manufacturer read out of WMI
   
    This information is well handled and consistant from manufactures like Dell, HP, et al
    but generic hand assembled machines are another story.  Usually those systems will 
    report whatever the motherboard manufacture put into the DMI database.
    */
    try
    {
        var wbemFlagReturnImmediately = 0x10;
        var wbemFlagForwardOnly = 0x20;
        var i = -1;	//running count of position in array for all hardware

        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName, "root\\cimv2", currentHostCredentials[0], currentHostCredentials[1]);
        objWMIService.Security_.ImpersonationLevel = 3;
        var hardwareArray = new Array(); //the array that will accumulate all of the data in the function
        var colItems = objWMIService.ExecQuery("SELECT * FROM Win32_ComputerSystem","WQL",wbemFlagReturnImmediately | wbemFlagForwardOnly);
        var enumItems = new Enumerator(colItems);
        var temp = "";
        for (; !enumItems.atEnd(); enumItems.moveNext())
        {
            var objItem = enumItems.item();
            temp = objItem.Manufacturer;
            i++;
        }
        return temp;
    }
    catch(err)
    {
        return "[Error: " + err.description + "]";
    }
}
    
function reportModel(hostName)
{
    /*
    function reportModel
    given: hostName - string with the target computer name
    returns: string with the system's model read out of WMI
      
    See reportMake documentation.
    */
    try
    {
        var wbemFlagReturnImmediately = 0x10;
        var wbemFlagForwardOnly = 0x20;
        var i = -1;	//running count of position in array for all hardware

        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName, "root\\cimv2", currentHostCredentials[0], currentHostCredentials[1]);
        objWMIService.Security_.ImpersonationLevel = 3;
        var hardwareArray = new Array(); //the array that will accumulate all of the data in the function
        var colItems = objWMIService.ExecQuery("SELECT * FROM Win32_ComputerSystem","WQL",wbemFlagReturnImmediately | wbemFlagForwardOnly);
        var enumItems = new Enumerator(colItems);
        var temp = "";
        for (; !enumItems.atEnd(); enumItems.moveNext())
        {
            var objItem = enumItems.item();
            temp = objItem.Model;
            i++;
        }
        return removeFromString(temp,"  ");  //<<HACK!!!>> some models have a collection of spaces in there name ... so when there are w spaces in a row they'll be remove, this should hurt the formating as single spaces will remain
    }
    catch(err)
    {
        return "[Error: " + err.description + "]";
    }
}

function reportCPU(hostName)
{
    /*
    function reportCPURAM
    given: hostName - string with the target computer name
    returns: string with the system's cpu model and memory size read out of WMI
      
    This data is generally speaking well covered in the DMI database.  CPU makers have 
    been pretty good about stamping thier product name all over the inner circuits of
    these devices.
    */
    try
    {
        var wbemFlagReturnImmediately = 0x10;
        var wbemFlagForwardOnly = 0x20;
        var i = 0;	//running count of the number of Processors

        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName, "root\\cimv2", currentHostCredentials[0], currentHostCredentials[1]);
        objWMIService.Security_.ImpersonationLevel = 3;
        //get the cpu information
        var colItems = objWMIService.ExecQuery("SELECT * FROM Win32_Processor","WQL",wbemFlagReturnImmediately | wbemFlagForwardOnly);
        var enumItems = new Enumerator(colItems); //enumerate the collection of CPUs
        for (; !enumItems.atEnd(); enumItems.moveNext())
        {
            var objItem = enumItems.item();	//take enumerated object(CPU) and make it an item
            var cpuName = objItem.Name;
            i++;
        }
        if (i < 2) {
             return removeFromString(cpuName,"    ");
        } else {
             return removeFromString(i + "x" + cpuName,"    ");
        }
    }
    catch(err)
    {
        return "[Error: " + err.description + "]";
    }
}

function reportRAM(hostName)
{
    /*
    function reportCPURAM
    given: hostName - string with the target computer name
    returns: string with the system's cpu model and memory size read out of WMI
      
    This data is generally speaking well covered in the DMI database.  CPU makers have 
    been pretty good about stamping thier product name all over the inner circuits of
    these devices.
    */
    try
    {
        var wbemFlagReturnImmediately = 0x10;
        var wbemFlagForwardOnly = 0x20;
        var i = 0;	//running count of the number of Processors

        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName, "root\\cimv2", currentHostCredentials[0], currentHostCredentials[1]);
        objWMIService.Security_.ImpersonationLevel = 3;
        //get total memory size and motherboard model
        var colItems = objWMIService.ExecQuery("SELECT * FROM Win32_ComputerSystem","WQL",wbemFlagReturnImmediately | wbemFlagForwardOnly);
        var enumItems = new Enumerator(colItems);
        for (; !enumItems.atEnd(); enumItems.moveNext())
        {
            var objItem = enumItems.item();
            var memorySize = objItem.TotalPhysicalMemory;
        }
        return friendlySize(memorySize);
    }
    catch(err)
    {
        return "[Error: " + err.description + "]";
    }
}

function reportDisk(hostName)
{
    /*
    function reportDisk
    given: hostName - string with the target computer name
    returns: string with the disk information
      
    This should return a nice formatted string with all of the disks on the system's
    information.  I'd like to have it report drive letter, size, and free or used space
    on the volume ... we'll see what WMI gives me to  work with.
    */
    try
    {
        var wbemFlagReturnImmediately = 0x10;
        var wbemFlagForwardOnly = 0x20;
        var i = 0;	//running count of the number of Processors

        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName, "root\\cimv2", currentHostCredentials[0], currentHostCredentials[1]);
        objWMIService.Security_.ImpersonationLevel = 3;
        var diskArray = new Array();  //save disk info here
        var colItems = objWMIService.ExecQuery("SELECT * FROM Win32_LogicalDisk WHERE DriveType = 3","WQL",wbemFlagReturnImmediately | wbemFlagForwardOnly);
        var enumItems = new Enumerator(colItems);
        var diskCount = 0;
        for (; !enumItems.atEnd(); enumItems.moveNext())
        {
            var objItem = enumItems.item()
	        diskArray[diskCount] = new Array(objItem.Caption, "Capacity: " + friendlySize(objItem.Size), "Free Space: " + friendlySize(objItem.FreeSpace),"Free%: " + roundNumber(((objItem.FreeSpace / objItem.Size) * 100),3));
	        diskCount++;
        }
        return diskArray;
    }
    catch(err)
    {
        return new Array("Error: " + err.Description);
    }
}   //end of the reportDisk function

function reportLastUser(hostName)
{
   /* --------------------------------------------------------------------------------------
   function reportLastUser
   given: hostName - string with the target computer name
   returns: string with the name of the last user to have logged onto the workstaion
            or server
   
   Let's see what I can come up with shall ... hopefully WMI will give us a domain name
   and everything
   */
   try
    {
        var wbemFlagReturnImmediately = 0x10;
        var wbemFlagForwardOnly = 0x20;
        var serialNumber;

        var userId = "";
        
        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName, "root\\cimv2",currentHostCredentials[0],currentHostCredentials[1],"","",128);
        objWMIService.Security_.ImpersonationLevel = 3;
        var colItems = objWMIService.ExecQuery("SELECT * FROM Win32_NetworkLoginProfile", "WQL", wbemFlagReturnImmediately | wbemFlagForwardOnly);
 
        var enumItems = new Enumerator(colItems);
        for (; !enumItems.atEnd(); enumItems.moveNext())
        {
            var objItem = enumItems.item();
            userId = objItem.Name;
        }
        return userId;
    }
    catch(err)
    {
        return "[Error: " + err.description + "]";
    }
}   //end of the reportLastUser function

function reportLogs(hostName)
{
    var todayDate = new Date();
    var lastWeekDate = todayDate - 7;
    
    var arrayReturn = new Array();
    arrayReturn = compressLogReturn(hostName,getLastWeeksDate(),"System");
    var tempArray = compressLogReturn(hostName,getLastWeeksDate(),"Application");
    for(var i = 0; i < tempArray.length; i++)
    {
        arrayReturn.push(tempArray[i]);
    }
    return arrayReturn;
}

function compressLogReturn(hostName, strStartDate, strLogTarget)
{
    var arrayReturn = new Array();
    var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
    var objWMIService = objLocator.ConnectServer(hostName, "root\\cimv2",currentHostCredentials[0],currentHostCredentials[1],"","",128);
    objWMIService.Security_.ImpersonationLevel = 3;    
    var colLoggedEvents = objWMIService.ExecQuery("select * from Win32_NTLogEvent WHERE LogFile = \'" + strLogTarget + "\' AND (Type = \'Error\' OR Type = \'Warning\') AND (TimeWritten > \'" + strStartDate + "000000.000000-000\')");
    var enumItems = new Enumerator(colLoggedEvents);
    for(;!enumItems.atEnd(); enumItems.moveNext())
    {    
        var objItem = enumItems.item();
        var arrayTemp = new Array(objItem.ComputerName, strLogTarget, objItem.Category, objItem.EventCode, objItem.Type, objItem.Message, new Array(objItem.User));  //eventID in 2D array
        var itemIndex = doesLogEntryAlreadyExist(arrayReturn, arrayTemp);  //see if a similar event is already in the return array
        if(itemIndex >= 0)  //if the itemIndex is great than or equal to 0 this even already exists (keep in mind this is the array index, not the incidence counter)
        {
            arrayReturn[itemIndex][7]++;  //increment the instance count
            if(!isUserAlreadyInList(arrayReturn[itemIndex],objItem.User))   //see if the username in the event is already in the list
            {
                arrayTemp[6].push(objItem.User);   //if not add it
            }
        }
        else
        {
            arrayTemp.push(1);  //add 1 as the incidence number at the end of the array
            arrayReturn.push(arrayTemp);  //tack this array onto the array this function will return
        }
    }
    return arrayReturn;
}

function doesLogEntryAlreadyExist(arrayMasterList, arrayNewItem)
{
    for(var i = 0; i < arrayMasterList.length; i++)
    {
        if(arrayMasterList[i][0] == arrayNewItem[0] && arrayMasterList[i][2] == arrayNewItem[2] && arrayMasterList[i][3] == arrayNewItem[3] && arrayMasterList[i][4] == arrayNewItem[4])
        {
             return i;
        }
    }
    return -1;
}

function isUserAlreadyInList(strNameList, strName)
{
    for(var i = 0; i < strNameList.length; i++)
    {
        if(strNameList[i] == strName)
        {
           return true;
        }
    }
    return false;
}

function reportServices(hostName)
{
   /* --------------------------------------------------------------------------------------
   function reportServices
   given: hostName - string with the target computer name
   returns: array of the services on the system, the state, and their startup type

   */
   try
    {
        var wbemFlagReturnImmediately = 0x10;
        var wbemFlagForwardOnly = 0x20;
        var serialNumber;

        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName, "root\\cimv2",currentHostCredentials[0],currentHostCredentials[1],"","",128);
        objWMIService.Security_.ImpersonationLevel = 3;
        var colItems = objWMIService.ExecQuery("SELECT * FROM Win32_Service", "WQL", wbemFlagReturnImmediately | wbemFlagForwardOnly);
  
        var returnArray = new Array();
        var enumItems = new Enumerator(colItems);
        for (; !enumItems.atEnd(); enumItems.moveNext())
        {
            var objItem = enumItems.item();
            if(objItem.DisplayName != null)
            {
                tempArray = new Array(objItem.DisplayName.replace(","," "), objItem.State, objItem.StartMode);
                returnArray.push(tempArray);
            }
        }
        return returnArray;
    }
    catch(err)
    {
        return "[Error: " + err.description + "]";
    }
}   //end of the reportServices function

function reportSoftware(hostName)
{
    /*--------------------------------------------------------------------------------------------
    function reportSoftware
    given: hostName - string with the target computer name
    returns: an array of the software installed on the system (discovery done by using WMI to 
    open the registry and report the software from there).
    
    */
    softwareReturnArray = new Array();  //array with all of the software assocaited with this host to be returned
    y=0; //index of above array to be returned
    sRegTypes = new Array(
    " ", // 0
    "REG_SZ ", // 1
    "REG_EXPAND_SZ ", // 2
    "REG_BINARY ", // 3
    "REG_DWORD ", // 4
    "REG_DWORD_BIG_ENDIAN ", // 5
    "REG_LINK ", // 6
    "REG_MULTI_SZ ", // 7
    "REG_RESOURCE_LIST ", // 8
    "REG_FULL_RESOURCE_DESCRIPTOR ", // 9
    "REG_RESOURCE_REQUIREMENTS_LIST", // 10
    "REG_QWORD "); // 11

    HKLM = 0x80000002;   //hex value of the Local_Machine registry hive
    sRegPath = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall";
    try 
    {
        oLoc = new ActiveXObject("WbemScripting.SWbemLocator");
        oSvc = oLoc.ConnectServer(hostName, "root\\default", currentHostCredentials[0], currentHostCredentials[1]);
        oReg = oSvc.Get("StdRegProv");

        oMethod = oReg.Methods_.Item("EnumKey");
        oInParam = oMethod.InParameters.SpawnInstance_();
        oInParam.hDefKey = HKLM;
        oInParam.sSubKeyName = sRegPath;
        oOutParam = oReg.ExecMethod_(oMethod.Name, oInParam);

        aNames = oOutParam.sNames.toArray();
        for (i = 0; i <= aNames.length -1; i++)
        {
            var keyname = aNames[i]
            getskey(keyname);
        }
    }
    catch(err)
    {
        //softwareReturnArray = new Array("Software search failure: " + err);
    }
    sRegPath = "SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall";
    try 
    {
        oLoc = new ActiveXObject("WbemScripting.SWbemLocator");
        oSvc = oLoc.ConnectServer(hostName, "root\\default", currentHostCredentials[0], currentHostCredentials[1]);
        oReg = oSvc.Get("StdRegProv");

        oMethod = oReg.Methods_.Item("EnumKey");
        oInParam = oMethod.InParameters.SpawnInstance_();
        oInParam.hDefKey = HKLM;
        oInParam.sSubKeyName = sRegPath;
        oOutParam = oReg.ExecMethod_(oMethod.Name, oInParam);

        aNames = oOutParam.sNames.toArray();
        for (i = 0; i <= aNames.length -1; i++)
        {
            var keyname = aNames[i]
            getskey(keyname);
        }
    }
    catch(err)
    {
        //softwareReturnArray = new Array("Software search failure: " + err);
    }
    return softwareReturnArray.sort(function(x,y){ //return my alphabetically case-insensitive sorted array of software :O
      var a = String(x).toUpperCase(); 
      var b = String(y).toUpperCase(); 
      if (a > b) 
         return 1 
      if (a < b) 
         return -1 
      return 0; 
    }); 
}

function getskey(keyname)
{
    try
    {
        oMethod = oReg.Methods_.Item("EnumValues");
        oInParam = oMethod.InParameters.SpawnInstance_();
        oInParam.hDefKey = HKLM;
        oInParam.sSubKeyName = sRegPath + "\\" + keyname;
        oOutParam = oReg.ExecMethod_(oMethod.Name, oInParam);
        var newreg = sRegPath + "\\" + keyname
        bNames = oOutParam.sNames.toArray();
        aTypes = oOutParam.Types.toArray();

        for (j = 0; j <= bNames.length -1; j++)
        {
            if (aTypes[j] == "1")
            {
                subkeyval = bNames[j];
                getskeyval(subkeyval, newreg);
            }
        }
    }
    catch(error)
    {
        //nothing here
    }
}

function getskeyval(subkeyval, newreg)
{
    if (subkeyval == "DisplayName" || subkeyval == "QuietDiaplayName")
    {
        oMethod = oReg.Methods_.Item("GetStringValue");
        oInParam = oMethod.InParameters.SpawnInstance_();
        oInParam.hDefKey = HKLM;
        oInParam.sSubKeyName = newreg;
        oInParam.sValueName = subkeyval;
        oOutParam = oReg.ExecMethod_(oMethod.Name, oInParam);
        cNames = oOutParam.sValue
        softwareReturnArray[y] = cNames.replace(","," ");
        y++;
    }
}

/***************************************************************************************
 ***************************************************************************************
  BEGIN OFFICE KEY HANDLING FUNCTIONS
****************************************************************************************
****************************************************************************************/
    
function reportOffice(hostName)
{
    /*
    function reportOffice
    given hostName
    returns a one dimensional array with a list of office product names and cd-keys
    
    The hostName is the only data that should need to be passed to this function, this
    function will later call other functions that will need additional data but that
    data is mostly information needed from pre-defined locations in the registry that
    Microsoft uses.
    */
    var i = -1;   //stored integer that will keep track of the number of products and keys I've picked up
    var prodArray = new Array();   //array of products and keys to be returned when this is all said and done
    var HKEY_LOCAL_MACHINE = 0x80000002;
    var cleanPresentation = "";    //string that will be used to cleanly present the complete data
    
    //registry paths
    var officeTwelvePathX64 = "SOFTWARE\\Wow6432Node\\Microsoft\\Office\\12.0\\Registration";
    var officeElevenPathX64 = "SOFTWARE\\Wow6432Node\\Microsoft\\Office\\11.0\\Registration";
    var officeTenPathX64 = "SOFTWARE\\Wow6432Node\\Microsoft\\Office\\10.0\\Registration";
    var officeTwelvePath = "SOFTWARE\\Microsoft\\Office\\12.0\\Registration";
    var officeElevenPath = "SOFTWARE\\Microsoft\\Office\\11.0\\Registration";
    var officeTenPath = "SOFTWARE\\Microsoft\\Office\\10.0\\Registration";
    var officeNinePath = "SOFTWARE\\Microsoft\\Office\\9.0\\Registration";

    try
    {        
        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName,"root\\default",currentHostCredentials[0],currentHostCredentials[1],"","",128);
        objWMIService.Security_.ImpersonationLevel = 3;
    }
    catch(err)
    {
        return "[Error: " + err.description + "]";
    }
    //start reading names and keys for Office 2007 on x64 systems here
    if(true)  //if is only here because I've dragged this code in from the old version, I should probably clean this up sometime
    {
        var continueFlag = false;
        try
        {
            var thisVerSubKeys = enumSubKeys(HKEY_LOCAL_MACHINE,officeTwelvePathX64,hostName);
        }
        catch(err)
        {
            //failed reading subkeys
        }
        //make sure the returned array is working before continuing to the for loop
        try
        {
            var testLength = thisVerSubKeys.length;
            continueFlag = true;
        }
        catch(err)
        {
            continueFlag = false;
        }
        if(continueFlag == true)
        {
            for(var x=0; x<thisVerSubKeys.length; x++)
            {
                try
                {
                    var currentProductName = officeProductName(HKEY_LOCAL_MACHINE,officeTwelvePathX64+"\\"+thisVerSubKeys[x],hostName);
                    if (currentProductName != "")
                    {
                        var currentProductCode = decodeOfficeProductKey(HKEY_LOCAL_MACHINE,officeTwelvePathX64+"\\"+thisVerSubKeys[x],hostName);                        
                        i++;
                        prodArray[i] = currentProductName + " [PK: " + currentProductCode + "]";
                    }
                }
                catch(err)
                {
                    //just ignore for now...
                }
            } //end of for loop 
        }    //end of if(continueFlag == true)
    }   //of if(objExplorer.Docuement.workstationForm.msOffice2007.checked != 0)
    //start reading names and keys for Office 2007 here
    if(true)  //if is only here because I've dragged this code in from the old version, I should probably clean this up sometime
    {
        var continueFlag = false;
        try
        {
            var thisVerSubKeys = enumSubKeys(HKEY_LOCAL_MACHINE,officeTwelvePath,hostName);
        }
        catch(err)
        {
            //failed reading subkeys
        }
        //make sure the returned array is working before continuing to the for loop
        try
        {
            var testLength = thisVerSubKeys.length;
            continueFlag = true;
        }
        catch(err)
        {
            continueFlag = false;
        }
        if(continueFlag == true)
        {
            for(var x=0; x<thisVerSubKeys.length; x++)
            {
                try
                {
                    var currentProductName = officeProductName(HKEY_LOCAL_MACHINE,officeTwelvePath+"\\"+thisVerSubKeys[x],hostName);
                    if (currentProductName != "")
                    {
                        var currentProductCode = decodeOfficeProductKey(HKEY_LOCAL_MACHINE,officeTwelvePath+"\\"+thisVerSubKeys[x],hostName);                        
                        i++;
                        prodArray[i] = currentProductName + " [PK: " + currentProductCode + "]";
                    }
                }
                catch(err)
                {
                    //just ignore for now...
                }
            } //end of for loop 
        }    //end of if(continueFlag == true)
    }   //of if(objExplorer.Docuement.workstationForm.msOffice2007.checked != 0)
    //start reading names and keys for Office 2003 on X64 systems here
    if(true)  //if is only here because I've dragged this code in from the old version, I should probably clean this up sometime
    {
        var continueFlag = false;
        try
        {
            var thisVerSubKeys = enumSubKeys(HKEY_LOCAL_MACHINE,officeElevenPathX64,hostName);
        }
        catch(err)
        {
            //failed reading subkeys
        }
        //make sure the returned array is working before continuing to the for loop
        try
        {
            var testLength = thisVerSubKeys.length;
            continueFlag = true;
        }
        catch(err)
        {
            continueFlag = false;
        }
        if(continueFlag == true)
        {
            for(var x=0; x<thisVerSubKeys.length; x++)
            {
                try
                {
                    var currentProductName = officeProductName(HKEY_LOCAL_MACHINE,officeElevenPathX64+"\\"+thisVerSubKeys[x],hostName);
                    if (currentProductName != "")
                    {
                        var currentProductCode = decodeOfficeProductKey(HKEY_LOCAL_MACHINE,officeElevenPathX64+"\\"+thisVerSubKeys[x],hostName);                        
                        i++;
                        prodArray[i] = currentProductName + " [PK: " + currentProductCode + "]";
                    }
                }
                catch(err)
                {
                    //just ignore for now...
                }
            } //end of for loop 
        }    //end of if(continueFlag == true)
    }   //of if(objExplorer.Docuement.workstationForm.msOffice2003.checked != 0)
    //start reading names and keys for Office 2003 here
    if(true)  //if is only here because I've dragged this code in from the old version, I should probably clean this up sometime
    {
        var continueFlag = false;
        try
        {
            var thisVerSubKeys = enumSubKeys(HKEY_LOCAL_MACHINE,officeElevenPath,hostName);
        }
        catch(err)
        {
            //failed reading subkeys
        }
        //make sure the returned array is working before continuing to the for loop
        try
        {
            var testLength = thisVerSubKeys.length;
            continueFlag = true;
        }
        catch(err)
        {
            continueFlag = false;
        }
        if(continueFlag == true)
        {
            for(var x=0; x<thisVerSubKeys.length; x++)
            {
                try
                {
                    var currentProductName = officeProductName(HKEY_LOCAL_MACHINE,officeElevenPath+"\\"+thisVerSubKeys[x],hostName);
                    if (currentProductName != "")
                    {
                        var currentProductCode = decodeOfficeProductKey(HKEY_LOCAL_MACHINE,officeElevenPath+"\\"+thisVerSubKeys[x],hostName);                        
                        i++;
                        prodArray[i] = currentProductName + " [PK: " + currentProductCode + "]";
                    }
                }
                catch(err)
                {
                    //just ignore for now...
                }
            } //end of for loop 
        }    //end of if(continueFlag == true)
    }   //of if(objExplorer.Docuement.workstationForm.msOffice2003.checked != 0)
    //start reading names and keys for Office XP for X64 here
    if(true)    //if is only here because I've dragged this code in from the old version, I should probably clean this up sometime
    {
        try
        {
            var thisVerSubKeys = enumSubKeys(HKEY_LOCAL_MACHINE,officeTenPathX64,hostName);
        }
        catch(err)
        {
            //doesn't really matter yet, I'd prefer it to fail silently
        }
        //make sure the returned array is working before continuing to the for loop
        try
        {
            var testLength = thisVerSubKeys.length;
            continueFlag = true;
        }
        catch(err)
        {
            continueFlag = false;
        }
        if(continueFlag == true)
        {
            for(var x=0; x<thisVerSubKeys.length; x++)
            {
                try
                {
                    var currentProductName = officeXpProductName(HKEY_LOCAL_MACHINE,officeTenPathX64+"\\"+thisVerSubKeys[x],hostName);
                    if (currentProductName != null)
                    {
                        var currentProductCode = decodeOfficeProductKey(HKEY_LOCAL_MACHINE,officeTenPathX64+"\\"+thisVerSubKeys[x],hostName);
                        i++;
                        prodArray[i] = currentProductName + " [PK: " + currentProductCode + "]";
                    }
                }
                catch(err)
                {
                    //fail silently
                }
            } //end of for loop 
        }    //end of if(continueFlag == true)
    } //end of if(objExplorer.Document.workstationForm.msOfficeXP.checked != 0)
    //start reading names and keys for Office XP here
    if(true)    //if is only here because I've dragged this code in from the old version, I should probably clean this up sometime
    {
        try
        {
            var thisVerSubKeys = enumSubKeys(HKEY_LOCAL_MACHINE,officeTenPath,hostName);
        }
        catch(err)
        {
            //doesn't really matter yet, I'd prefer it to fail silently
        }
        //make sure the returned array is working before continuing to the for loop
        try
        {
            var testLength = thisVerSubKeys.length;
            continueFlag = true;
        }
        catch(err)
        {
            continueFlag = false;
        }
        if(continueFlag == true)
        {
            for(var x=0; x<thisVerSubKeys.length; x++)
            {
                try
                {
                    var currentProductName = officeXpProductName(HKEY_LOCAL_MACHINE,officeTenPath+"\\"+thisVerSubKeys[x],hostName);
                    if (currentProductName != null)
                    {
                        var currentProductCode = decodeOfficeProductKey(HKEY_LOCAL_MACHINE,officeTenPath+"\\"+thisVerSubKeys[x],hostName);
                        i++;
                        prodArray[i] = currentProductName + " [PK: " + currentProductCode + "]";
                    }
                }
                catch(err)
                {
                    //fail silently
                }
            } //end of for loop 
        }    //end of if(continueFlag == true)
    } //end of if(objExplorer.Document.workstationForm.msOfficeXP.checked != 0)
    
    //start reading names and keys for Office 2000 here
    if(true)    //if is only here because I've dragged this code in from the old version, I should probably clean this up sometime, ironically there is no way of extract Office 2000 keys as they're not put in the registry at all or anywhere on the system
    {
        try
        {
            var thisVerSubKeys = enumSubKeys(HKEY_LOCAL_MACHINE,officeNinePath,hostName);
            for(var x=0; x<thisVerSubKeys.length; x++)
            {
                var currentProductName = officeProductName(HKEY_LOCAL_MACHINE,officeElevenPath+"\\"+thisVerSubKeys[x],hostName);
                if (currentProductName != null)
                {
                    var currentProductCode = decodeOfficeProductKey(HKEY_LOCAL_MACHINE,officeElevenPath+"\\"+thisVerSubKeys[x],hostName);
                    i++;
                    prodArray[i] = currentProductName + " (" + currentProductCode + ")";
                }
            }
        }
        catch(err)
        {
            //I really really really don't care at all at this point
        }
    }
    if(prodArray.length == 0)
    {
        cleanPresentation = "nothing";
    }
    if(prodArray.length == 1)
    {
        cleanPresentation = prodArray[0];
    }
    if(prodArray.length > 1)
    {
        for(var y=0;y<prodArray.length;y++)
        {
            if(y<prodArray.length-1)
            {
                cleanPresentation += prodArray[y] + "\\";
            }
            else
            {
                cleanPresentation += prodArray[y];
            }
        }
    }
    return cleanPresentation;
        
}   //end of the reportOffice function

function enumSubKeys(regHive,subKey,hostName)
{
    /*
    function enumSubKeys
    given regHive, the hive of the registry we'll be accessing HKLM, HKCU, etc.
    given subKey, the path in the registry of the key from the Hive's root level on
    given hostName, the system name or IP of the system we'll be reading the data from
    returns a one dimensional array with a last of the subkeys to that given key
    
    This function will just enumerate subkeys to a given key, particularly useful for
    getting all of the GUIDs listed underneath the registration key for the office
    product line.
    */

    var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
    var objWMIService = objLocator.ConnectServer(hostName,"root\\default",currentHostCredentials[0],currentHostCredentials[1],"","",128);
    objWMIService.Security_.ImpersonationLevel = 3;

    //oLoc = new ActiveXObject("WbemScripting.SWbemLocator");
    //oSvc = oLoc.ConnectServer(null, "root\\default");
    oReg = objWMIService.Get("StdRegProv");
            
    oMethod = oReg.Methods_.Item("EnumKey");
    oInParam = oMethod.InParameters.SpawnInstance_();
    oInParam.hDefKey = regHive;
    oInParam.sSubKeyName = subKey;
    oOutParam = oReg.ExecMethod_(oMethod.Name, oInParam);
        
    sNames = oOutParam.sNames.toArray();
    //return the list of subkeys as an array
    return sNames;
}

function officeProductName(regHive,regPath,hostName)
{
    /*
    function officeProductName
    given regHive, the hive of the registry we'll be accessing HKLM, HKCU, etc.
    given subKey, the path in the registry of the key from the Hive's root level on
    given hostName, the system name or IP of the system we'll be reading the data from
    returns a string with the ProductName value
       
    At this point hopefully having read the GUID subkeys to the Registration key
    can look for product name values in each GUID.
    */
       
    var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
    var objWMIService = objLocator.ConnectServer(hostName,"root\\default",currentHostCredentials[0],currentHostCredentials[1],"","",128);
    objWMIService.Security_.ImpersonationLevel = 3;
            
    try
    {
        var licType = new Array();
        licType["0"] = "(Volume License)";
        licType["1"] = "(OEM/Retail)";
        licType["2"] = "(Trial)";
    
        var productType = licType[regPath.charAt(46)];
    }
    catch(err)
    {
        var productType = "";
    }

    //oLoc = new ActiveXObject("WbemScripting.SWbemLocator");
    //oSvc = oLoc.ConnectServer(null, "root\\default");
    oReg = objWMIService.Get("StdRegProv");
            
    oMethod = oReg.Methods_.Item("GetStringValue");
    oInParam = oMethod.InParameters.SpawnInstance_();
    oInParam.hDefKey = regHive;
    oInParam.sSubKeyName = regPath;
    oInParam.sValueName = "ProductName";
    oOutParam = oReg.ExecMethod_(oMethod.Name, oInParam);
    var sValue = oOutParam.sValue;
    //return the product's name and licensing type
    return sValue + " " + productType;
}
    
    
    
    
    /* --------------------------------------------------------------------------------------
       function officeXpProductName
       given regHive, the hive of the registry we'll be accessing HKLM, HKCU, etc.
       given subKey, the path in the registry of the key from the Hive's root level on
       given hostName, the system name or IP of the system we'll be reading the data from
       returns a string with the ProductName value
       
       At this point hopefully having read the GUID subkeys to the Registration key
       can look for product name values in each GUID.  Office XP differs from Office 2003
       in that the name of the product isn't stored in a key called "ProductName", the 
       best we get is a productid that I'll have to map to a product name.
    
    -------------------------------------------------------------------------------------- */
    
    function officeXpProductName(regHive,regPath,hostName)
    {
        //this is a bit of a hack, but it makes the function operate 
        //more like the office 2003 function ... the registry key that
        //contains the product GUID can be used to determine the type of
        //product installed ...

        try
        {
            var licType = new Array();
            licType["0"] = "(Volume License)";
            licType["1"] = "(OEM/Retail)";
            licType["2"] = "(Trial)";

            var productType = licType[regPath.charAt(46)];
        }
        catch(err)
        {
            var productType = "";
        }
        
        //grab the 2 digit product code
        var ProductNumber = regPath.charAt(47) + regPath.charAt(48);
        
        //array of all the product codes (I could find)
        var xpProdArray = new Array();
        xpProdArray["10"] = "Microsoft Office XP Premium";                             
        xpProdArray["11"] = "Microsoft Office XP Professional";                        
        xpProdArray["12"] = "Microsoft Office XP Standard";                            
        xpProdArray["13"] = "Microsoft Office XP Small Business";                      
        xpProdArray["14"] = "Microsoft Office XP Web Server";                          
        xpProdArray["15"] = "Microsoft Access 2002";                                   
        xpProdArray["16"] = "Microsoft Excel 2002";                                    
        xpProdArray["17"] = "Microsoft FrontPage® 2002";                               
        xpProdArray["18"] = "Microsoft PowerPoint® 2002";                              
        xpProdArray["19"] = "Microsoft Publisher 2002";                                
        xpProdArray["1A"] = "Microsoft Outlook 2002";                                  
        xpProdArray["1B"] = "Microsoft Word 2002";                                     
        xpProdArray["1C"] = "Microsoft Access 2002 Runtime";                           
        xpProdArray["1D"] = "Microsoft FrontPage Server Extensions 2002";              
        xpProdArray["1E"] = "Microsoft Office Multilingual User Interface Pack";       
        xpProdArray["1F"] = "Microsoft Office Proofing Tools Kit";                     
        xpProdArray["20"] = "System Files Update";                                     
        xpProdArray["22"] = "Microsoft PhotoDraw® 2002";                               
        xpProdArray["23"] = "Microsoft Office Multilingual User Interface Pack Wizard";
        xpProdArray["24"] = "Microsoft Office XP Resource Kit";                        
        xpProdArray["25"] = "Microsoft Office XP Resource Kit Tools";                  
        xpProdArray["26"] = "Microsoft Office Web Components";                         
        xpProdArray["27"] = "Microsoft Project 2002";                                  
        xpProdArray["28"] = "Microsoft Office XP Professional with FrontPage";         
        xpProdArray["29"] = "Microsoft Office XP Professional Annuity";                
        xpProdArray["2A"] = "Microsoft Office XP Small Business Edition Annuity";      
        xpProdArray["2B"] = "Microsoft Publisher 2002 Deluxe Edition";                 
        xpProdArray["2F"] = "Standalone IME (JPN Only)";                               
        xpProdArray["30"] = "Microsoft Office XP Media Content";                       
        xpProdArray["31"] = "Microsoft Project 2002 Web Client";                       
        xpProdArray["32"] = "Microsoft Project 2002 Web Server";                       
        xpProdArray["33"] = "Microsoft Office XP PIPC1 (Pre Installed PC) (JPN Only)"; 
        xpProdArray["34"] = "Microsoft Office XP PIPC2 (Pre Installed PC) (JPN Only)"; 
        xpProdArray["35"] = "Microsoft Office XP Media Content Deluxe"; 
        xpProdArray["3A"] = "Microsoft Project Standard 2002";
        xpProdArray["51"] = "Microsoft Visio Professional 2002 [English]";                       
        xpProdArray["53"] = "Microsoft Visio 2002 SR-1";                        
        //return the product name and licensing type
        return xpProdArray[ProductNumber] + " " + productType;     
    }    
    
    
    /* --------------------------------------------------------------------------------------
       function decodeOfficeProductKey
       given regHive, the hive of the registry we'll be accessing HKLM, HKCU, etc.
       given subKey, the path in the registry of the key from the Hive's root level on
       given hostName, the system name or IP of the system we'll be reading the data from
       returns a string with the Product Key as decoded from the DigitalProductID key in
           the registry
       
       When getting to this function the GUIDs should all have been found and the
       ProductName should return something other than "null".  This should be tested by the
       calling function, as a result of "null" for the ProductName indicates that there is
       no ProductName value and therefore most likely no DigitalProductId.
    
    -------------------------------------------------------------------------------------- */
        
    function decodeOfficeProductKey(regHive,regPath,hostName)
    {
        var bDigitalProductID ="";
        var bProductKey = new Array(15);
        var bKeyChars = new Array(25);
        var ilByte = "";
        var nCur = "";
        var sCDKey = "";
        var ilKeyByte = "";
        var ilBit = "";

        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        var objWMIService = objLocator.ConnectServer(hostName,"root\\default",currentHostCredentials[0],currentHostCredentials[1],"","",128);
        objWMIService.Security_.ImpersonationLevel = 3;

        var objRegistry = objWMIService.Get("StdRegProv");
        var objMethod = objRegistry.Methods_("GetBinaryValue");
        var objInParam = objMethod.inParameters.SpawnInstance_();

        objInParam.hDefKey = regHive;
        objInParam.sSubKeyName = regPath;
        objInParam.sValueName = "DigitalProductId";

        var objOutParam = objRegistry.ExecMethod_("GetBinaryValue", objInParam);
        bDigitalProductID = objOutParam.uValue.toArray();
        objShell = null;
        for(ilByte = 52; ilByte <= 66; ilByte++)
        {
            bProductKey[ilByte - 52] = bDigitalProductID[ilByte];
        }
        //Possible characters in the CD Key:
        //the key is base 24 encoded, this is the mapping from that base to 
        //the characters you're used to entering at the installation wizard
        bKeyChars[0] = Asc("B");
        bKeyChars[1] = Asc("C");
        bKeyChars[2] = Asc("D");
        bKeyChars[3] = Asc("F");
        bKeyChars[4] = Asc("G");
        bKeyChars[5] = Asc("H");
        bKeyChars[6] = Asc("J");
        bKeyChars[7] = Asc("K");
        bKeyChars[8] = Asc("M");
        bKeyChars[9] = Asc("P");
        bKeyChars[10] = Asc("Q");
        bKeyChars[11] = Asc("R");
        bKeyChars[12] = Asc("T");
        bKeyChars[13] = Asc("V");
        bKeyChars[14] = Asc("W");
        bKeyChars[15] = Asc("X");
        bKeyChars[16] = Asc("Y");
        bKeyChars[17] = Asc("2");
        bKeyChars[18] = Asc("3");
        bKeyChars[19] = Asc("4");
        bKeyChars[20] = Asc("6");
        bKeyChars[21] = Asc("7");
        bKeyChars[22] = Asc("8");
        bKeyChars[23] = Asc("9");
    
        for(ilByte = 24; ilByte >= 0; ilByte--)
        {
            nCur = 0; 
            for(ilKeyByte = 14; ilKeyByte >= 0; ilKeyByte--)
            {
                //Step through each byte in the Product Key
                nCur = nCur * 256 ^ bProductKey[ilKeyByte];
                bProductKey[ilKeyByte] = Math.floor(nCur / 24);
                nCur = nCur % 24;
            }
            sCDKey = String.fromCharCode(bKeyChars[nCur]) + sCDKey;
            if(ilByte % 5 == 0 && ilByte != 0)
            {
                sCDKey = "-" + sCDKey;
            }
        }
        return sCDKey;
    }   //End Function

    /***************************************************************************************
     ***************************************************************************************
      END OF OFFICE KEY HANDLING FUNCTIONS
    ****************************************************************************************
    ****************************************************************************************/
   
    
    
    /* --------------------------------------------------------------------------------------
       function isWorkstation
       given: strName - string with the target computer name
       returns: boolean
       
       If the name passed to this function is a systems hostname and WMI is working and
       connectable with the user credentials supplied this should return true.  If it fails
       at its try it will return false.
       
    --------------------------------------------------------------------------------------- */
    
    function isWorkstation(strName)
    {
        var wbemFlagReturnImmediately = 0x10;
        var wbemFlagForwardOnly = 0x20;
        var serialNumber;

        try
        {
            var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
            var objWMIService = objLocator.ConnectServer(strName, "root\\cimv2",currentHostCredentials[0],currentHostCredentials[1],"","",128);
            return true;
        }
        catch(err)
        {
            return false;
        }
    }
    
    /* --------------------------------------------------------------------------------------
       function getPath
       given: nothing
       returns: string with the file system path of where this script is being executed from
       
       This is used to get the location the script file is running from.  The script uses 
       this path to locate the form.htm file which should be by its side.
       
    --------------------------------------------------------------------------------------- */
        
    function getPath()
    {
        //get the path the script is executing from
        var path = WScript.ScriptFullname;
        path = path.substr(0, path.lastIndexOf("\\") + 1);
        return path;
    }
    
    /* --------------------------------------------------------------------------------------
       function Asc
       given: string - string
       returns: char - that corrosponds to the number passed to it
       
       Maps a number to the appropriate Ascii character.
       
    --------------------------------------------------------------------------------------- */
        
    function Asc(string)
    {
	    var symbols = " !\"#$%&'()*+'-./0123456789:;<=>?@";   //symbols start the symbols chain
	    var loAZ = "abcdefghijklmnopqrstuvwxyz";   //lower case chars
	    symbols += loAZ.toUpperCase();    //uppercase chars stored in symbols chain, just change the lowercase string to uppercase
	    symbols += "[\\]^_`";    //more charachter added to the chain
	    symbols += loAZ;    //lower case letters added to the chain
	    symbols += "{|}~";    //and them more symbols added
	    var loc;
	    loc = symbols.indexOf(string);
	    if (loc > -1)
	    { 
		    Ascii_Decimal = 32 + loc;
		    return (32 + loc);
	    }
	    return (0);
    }
    
    /* --------------------------------------------------------------------------------------
       function removeFromString
       given: testString - the string with potentially undesirable substrings
              pattern - the undesirable substring to be removed
       returns: string - string sans the substring
       
       This is mostly used to remove things like useless blocks of spaces put into processor
       names by companies like Intel.
              
    --------------------------------------------------------------------------------------- */
    
    function removeFromString(testString,pattern)
    {
        var re = new RegExp(pattern);
        var reducedString;
        if (!re.test(testString))
        {
            return testString;
        }
        else
        {	
            while (re.test(testString))
                {
                    testString = testString.replace(re,"");
	        }
                return testString;
        }
    }   //end of function removeFromString
    
    
    function roundNumber(num, dec) {
        var result = Math.round(num*Math.pow(10,dec))/Math.pow(10,dec);
	    return result;
    }
    
    /* --------------------------------------------------------------------------------------
       function friendlySize
       given: integerSize - size of something in bytes as an integer
       returns: string with a user friendly data size
       
       The numbers here need to be tweaked.  The gigabyte information is turning out nicely
       but the megabyte numbers leave a lot to be desired.
      
    --------------------------------------------------------------------------------------- */
    
    function friendlySize(integerSize)
    {
        var temp
        if (integerSize >= 1000000000)
        {
            temp = Math.round((integerSize / 1073741824)*100)/100;   //not 1000000000!!!
            temp = temp+"GB";
        }
        else if ((1000000000 > integerSize) && (integerSize >= 1000000))
        {
            temp = Math.round(integerSize / 1048576);     //not 1000000!!!
            temp = temp+"MB";
        }
        else if ((1000000 > integerSize) && (integerSize >= 1000))
        {
            temp = Math.round(integerSize / 1024);     //not 1000!!!
            temp = temp+"KB";
        }
        else
        {
            temp = integerSize+"Bytes";
        }
        return temp;
    }   //end of the friendlySize function

    /* --------------------------------------------------------------------------------------
       function ping
       given: sMachine - string that is the machine name
       returns: boolean
       
       This function is completely someone else's, thanks to whoever that was.  If the machine
       is accessible via WMI then it returns true, otherwise, nothing.
      
    --------------------------------------------------------------------------------------- */
        
    function ping(sMachine)
    { 
        var oPing 
        var sResp; 
        var oP; 
        var e; 
        var bResult; 

        try 
        { 
            oPing = GetObject("winmgmts:{impersonationLevel=impersonate}").ExecQuery("SELECT * FROM Win32_PingStatus WHERE address = '" + sMachine + "'"); 
            for (e = new Enumerator(oPing); !e.atEnd(); e.moveNext())
            { 
                oP = e.item(); 
                sResp = oP.StatusCode; 
                break;
            } 
            if (sResp == 0)
            {
                bResult = true; 
            } 
            else
            { 
                bResult = false; 
            } 
        } 
        catch(err)
        {
            ShowError(err);
        } 
        return(bResult); 
    }
    
    function domainScan() {
    /*
        Scan an entire windows domain given the parameters and update the output Array while drawing the information to an HTML table
    */
        scanHeader.innerText = "Domain systems scan from " + outputArray[0].toUpperCase();
        scanStatus.innerText = "Working...";
        domainWorkstationTable = scanIE.document.createElement("table");
        domainWorkstationTable.className = "scanReportTable";
        scanIE.document.body.appendChild(domainWorkstationTable);
        domainWorkstationHeadRow = domainWorkstationTable.insertRow();
        scanColumns = reportedColumns();
        scanStatus.innerText = "Pinging...";
        hostOutputRows = new Array();
        if(ping(outputArray[0])) {
            scanStatus.innerText = "Ping successful, retrieving computers in the directory...";
            domainComputerList = getAdSystems(outputArray[0]);   //get the list of machines from the domain controller
            if(domainComputerList != null)
            {
                if(domainComputerList.length != 0)   //if the machine we requested the computer list from returned an array of length of 0 then we're not going to be scaning any systems   
                {
                    scanStatus.innerText = "Ping successful, retrieving data...";
                    var scanColumnTitles = new Array();
                    for(var f=0; f<scanColumns.length; f++)   //put in the head row for the displayed output
                    {
                        if(userRequestedScanTermination)
                        {
                            scanStatus.innerText = "Terminated by user.";
                            break;
                        }
                        var thisCell = domainWorkstationHeadRow.insertCell();
                        domainWorkstationHeadRow.className = "scanReportHeadRow";
                        scanColumnTitles.push(scanColumns[f][1]);
                        thisCell.innerText = scanColumns[f][1];
                    }
                    thisReturnArray = new Array();
                    thisReturnArray.push(scanColumnTitles);
                    for(var d=0; d<domainComputerList.length; d++)
                    {
                         if(userRequestedScanTermination)
                         {
                            scanStatus.innerText = "Terminated by user.";
                            break;
                         }
                         intCurrent = d + 1;
                         scanStatus.innerText = "Pinging " + domainComputerList[d] + " (" + intCurrent + " of " + domainComputerList.length + ")";
                         if(ping(domainComputerList[d]))
                         {
                             scanStatus.innerText = "Testing credentials on " + domainComputerList[d] + " (" + intCurrent + " of " + domainComputerList.length + ")";
                             currentHostCredentials = userAccessCredentials(domainComputerList[d]);
                             if(isHostWmiAccessible(domainComputerList[d]))
                             {
                                 scanStatus.innerText = "Retrieving data from " + domainComputerList[d] + " (" + intCurrent + " of " + domainComputerList.length + ")";
                                 scanData = retrieveDataForHost(domainComputerList[d]);
                                 thisReturnArray.push(scanData);
                                 hostOutputRows[d] = domainWorkstationTable.insertRow();
                                 for(e=0; e<scanData.length; e++)
                                 {
                                     if(scanColumns[e][0] == "wksApps" )   //the applicaiton report column behavior will be different then all others
                                     {
                                         var thisCell = hostOutputRows[d].insertCell();
                                         thisCell.className = "scanReportDataCell";
                                         var myAppsButton = scanApplicationToggleButtonSetup(scanData[e]);
                                         thisCell.appendChild(myAppsButton);
                                     }
                                     else if(scanColumns[e][0] == "wksServices")
                                     {
                                         var thisCell = hostOutputRows[d].insertCell();
                                         thisCell.className = "scanReportDataCell";
                                         var myAppsButton = scanServicesToggleButtonSetup(scanData[e]);
                                         thisCell.appendChild(myAppsButton);
                                     }
                                     else if(scanColumns[e][0] == "wksIP")  //need to clean this up specifically for displayed output as IPs strun together without spaces can be a problem
                                     {
                                         var thisCell = hostOutputRows[d].insertCell();
                                         thisCell.className = "scanReportDataCell";
                                         thisCell.innerText = scanData[e].join(" ");
                                     }
                                     else if(scanColumns[e][0] == "wksLogs")
                                     {
                                         var thisCell = hostOutputRows[d].insertCell();
                                         thisCell.className = "scanReportDataCell";
                                         var myAppsButton = scanLogsToggleButtonSetup(scanData[e]);
                                         thisCell.appendChild(myAppsButton);
                                     }
                                     else
                                     {
                                         var thisCell = hostOutputRows[d].insertCell();
                                         thisCell.className = "scanReportDataCell";
                                         thisCell.innerText = scanData[e];
                                     } 
                                 }
                             }
                         }
                     }
                     scanStatus.innerText = "Domain scan completed.";
                     if(userRequestedScanTermination)
                     {
                         scanStatus.innerText = "User terminated scan.";
                     }
                     objScanIeQuitButton.innerText = "Return";
                     scanHeader.appendChild(excelButtonSetup());
                     scanHeader.appendChild(visioButtonSetup());
                     scanHeader.appendChild(textButtonSetup());
                     scanHeader.appendChild(xmlButtonSetup());
                     while(!userRequestedScanTermination)
                     {
                         WScript.Sleep(50);
                     }
                }
                else
                {
                     objScanIeQuitButton.innerText = "Return";
                     scanStatus.innerText = "Failed to retrieve any domain systems data from " + outputArray[0].toUpperCase() + ".  Verifty that this is a Windows Active Directory controller and that your credentials are correct.  Use the \"return\" button to validate your input.  Lastly make sure that at least one of your username and password combinations is valid for the target system.";
                }
            }
            else
            {
                scanStatus.innerText = "Failed to retrieve any domain systems data from " + outputArray[0].toUpperCase() + ".  This script was not able to contact the host via a ping test, sometimes it may be helpful to add a DNS suffix.  Use the \"return\" button to validate your input.";
                objScanIeQuitButton.innerText = "Return";
            }
            userRequestedScanTermination = false; //the user must have clicked the Stop Scan/Return button to get here (or there is a huge bug in my code) this is to re-initialize it
            objScanIeQuitButton.innerText = "Return";
        }
        else
        {
            objScanIeQuitButton.innerText = "Return";
            scanStatus.innerText = "Failed to retrieve any domain systems data from " + outputArray[0].toUpperCase() + ".  This script was not able to contact the host via a ping test, sometimes it may be helpful to add a DNS suffix.  Use the \"return\" button to validate your input.";
        }
        objScanIeQuitButton.innerText = "Return";
        while(userRequestedScanTermination == false)
        {
            WScript.Sleep(50);
        }
    }
    
    function singleScan()
    {
        /*
             Scan an single workstation given the parameters and update the 
             output Array while drawing the information to an HTML table
        */
        scanHeader.innerText = "Single Workstation scan on " + outputArray[0].toUpperCase();
        scanStatus.innerText = "Working...";
        singleWorkstationTable = scanIE.document.createElement("table");
        singleWorkstationTable.className = "scanReportTable";
        scanIE.document.body.appendChild(singleWorkstationTable);
        singleWorkstationHeadRow = singleWorkstationTable.insertRow();
        scanStatus.innerText = "Ping testing...";
        if(ping(outputArray[0]))
        {
            scanStatus.innerText = "Trying Credentials...";
            currentHostCredentials = userAccessCredentials(outputArray[0]);
            if(isHostWmiAccessible(outputArray[0]))
            {
                scanStatus.innerText = "Ping and logon successful, retrieving data...";
                scanColumns = reportedColumns();
                scanData = retrieveDataForHost(outputArray[0]);   //get the hostname from the user input from the "outputArray"
                var scanColumnTitles = new Array();
                for(f=0; f<scanColumns.length; f++)
                {
                    var thisCell = singleWorkstationHeadRow.insertCell();
                    thisCell.className = "scanReportHeadRow";
                    scanColumnTitles.push(scanColumns[f][1]);
                    thisCell.innerText = scanColumns[f][1];
                }
                singleWorkstationDataRow = singleWorkstationTable.insertRow();
                for(e=0; e<scanColumns.length; e++)
                {
                    if(scanColumns[e][0] == "wksApps" )   //the applicaiton report column behavior will be different then all others
                    {
                        var thisCell = singleWorkstationDataRow.insertCell();
                        thisCell.className = "scanReportDataCell";
                        var myAppsButton = scanApplicationToggleButtonSetup(scanData[e]);
                        thisCell.appendChild(myAppsButton);
                    }
                    else if(scanColumns[e][0] == "wksServices")
                    {
                        var thisCell = singleWorkstationDataRow.insertCell();
                        thisCell.className = "scanReportDataCell";
                        var myAppsButton = scanServicesToggleButtonSetup(scanData[e]);
                        thisCell.appendChild(myAppsButton);
                    }
                    else if(scanColumns[e][0] == "wksIP")  //gets out of hand with a lot of IPs, I need the HTML table to be allowed to line wrap
                    {
                        var thisCell = singleWorkstationDataRow.insertCell();
                        thisCell.className = "scanReportDataCell";
                        thisCell.innerText = scanData[e].join(" ");
                    }
                    else if(scanColumns[e][0] == "wksLogs")
                    {
                        var thisCell = singleWorkstationDataRow.insertCell();
                        thisCell.className = "scanReportDataCell";
                        var myAppsButton = scanLogsToggleButtonSetup(scanData[e]);
                        thisCell.appendChild(myAppsButton);
                    }
                    else
                    {
                        var thisCell = singleWorkstationDataRow.insertCell();
                        thisCell.className = "scanReportDataCell";
                        thisCell.innerText = scanData[e];
                    }
                }
                thisReturnArray = new Array();
                thisReturnArray.push(scanColumnTitles);
                thisReturnArray.push(scanData);
                scanStatus.innerText = "Scan complete.";
                scanHeader.appendChild(excelButtonSetup());
                scanHeader.appendChild(visioButtonSetup());
                scanHeader.appendChild(textButtonSetup());
                scanHeader.appendChild(xmlButtonSetup());
            }
            else
            {
                scanStatus.innerText = "Unable to logon to host.";
            }
        }
        else
        {
            scanStatus.innerText = "Ping failed.";
        }
        objScanIeQuitButton.innerText = "Return";
        while(userRequestedScanTermination == false) {
            WScript.Sleep(50);
        }
        userRequestedScanTermination = false; //the user must have clicked the Stop Scan/Return button to get here (or there is a huge bug in my code) this is to re-initialize it
        //get a report on the system here
        //dump the info from the previous line into the table here        
    }
    
    
    function targetsFileScan(strPath) {
    /*
        Scan an entire windows domain given the parameters and update the output Array while drawing the information to an HTML table
    */
        scanHeader.innerText = "Scanning systems found in file targets.txt";
        scanStatus.innerText = "Working...";
        domainWorkstationTable = scanIE.document.createElement("table");
        domainWorkstationTable.className = "scanReportTable";
        scanIE.document.body.appendChild(domainWorkstationTable);
        domainWorkstationHeadRow = domainWorkstationTable.insertRow();
        scanColumns = reportedColumns();
        scanStatus.innerText = "Pinging...";
        hostOutputRows = new Array();
        if(true) {
            scanStatus.innerText = "Parsing text file...";
            domainComputerList = getTextFileSystems(strPath);   //get the list of machines from the domain controller
            if(domainComputerList != null)
            {
                if(domainComputerList.length != 0)   //if the machine we requested the computer list from returned an array of length of 0 then we're not going to be scaning any systems   
                {
                    scanStatus.innerText = "Ping successful, retrieving data...";
                    var scanColumnTitles = new Array();
                    for(var f=0; f<scanColumns.length; f++)   //put in the head row for the displayed output
                    {
                        if(userRequestedScanTermination)
                        {
                            scanStatus.innerText = "Terminated by user.";
                            break;
                        }
                        var thisCell = domainWorkstationHeadRow.insertCell();
                        domainWorkstationHeadRow.className = "scanReportHeadRow";
                        scanColumnTitles.push(scanColumns[f][1]);
                        thisCell.innerText = scanColumns[f][1];
                    }
                    thisReturnArray = new Array();
                    thisReturnArray.push(scanColumnTitles);
                    for(var d=0; d<domainComputerList.length; d++)
                    {
                         if(userRequestedScanTermination)
                         {
                            scanStatus.innerText = "Terminated by user.";
                            break;
                         }
                         intCurrent = d + 1;
                         scanStatus.innerText = "Pinging " + domainComputerList[d] + " (" + intCurrent + " of " + domainComputerList.length + ")";
                         if(ping(domainComputerList[d]))
                         {
                             scanStatus.innerText = "Testing credentials on " + domainComputerList[d] + " (" + intCurrent + " of " + domainComputerList.length + ")";
                             currentHostCredentials = userAccessCredentials(domainComputerList[d]);
                             if(isHostWmiAccessible(domainComputerList[d]))
                             {
                                 scanStatus.innerText = "Retrieving data from " + domainComputerList[d] + " (" + intCurrent + " of " + domainComputerList.length + ")";
                                 scanData = retrieveDataForHost(domainComputerList[d]);
                                 thisReturnArray.push(scanData);
                                 hostOutputRows[d] = domainWorkstationTable.insertRow();
                                 for(e=0; e<scanData.length; e++)
                                 {
                                     if(scanColumns[e][0] == "wksApps" )   //the applicaiton report column behavior will be different then all others
                                     {
                                         var thisCell = hostOutputRows[d].insertCell();
                                         thisCell.className = "scanReportDataCell";
                                         var myAppsButton = scanApplicationToggleButtonSetup(scanData[e]);
                                         thisCell.appendChild(myAppsButton);
                                     }
                                     else if(scanColumns[e][0] == "wksServices")
                                     {
                                         var thisCell = hostOutputRows[d].insertCell();
                                         thisCell.className = "scanReportDataCell";
                                         var myAppsButton = scanServicesToggleButtonSetup(scanData[e]);
                                         thisCell.appendChild(myAppsButton);
                                     }
                                     else if(scanColumns[e][0] == "wksIP")  //gets out of hand with a lot of IPs, I need the HTML table to be allowed to line wrap
                                     {
                                         var thisCell = hostOutputRows[d].insertCell();
                                         thisCell.className = "scanReportDataCell";
                                         thisCell.innerText = scanData[e].join(" ");
                                     }
                                     else if(scanColumns[e][0] == "wksLogs")
                                     {
                                         var thisCell = hostOutputRows[d].insertCell();
                                         thisCell.className = "scanReportDataCell";
                                         var myAppsButton = scanLogsToggleButtonSetup(scanData[e]);
                                         thisCell.appendChild(myAppsButton);
                                     }
                                     else
                                     {
                                         var thisCell = hostOutputRows[d].insertCell();
                                         thisCell.className = "scanReportDataCell";
                                         thisCell.innerText = scanData[e];
                                     } 
                                 }
                             }
                         }
                     }
                     scanStatus.innerText = "Scan of targets in file completed.";
                     if(userRequestedScanTermination)
                     {
                         scanStatus.innerText = "User terminated scan.";
                     }
                     objScanIeQuitButton.innerText = "Return";
                     scanHeader.appendChild(excelButtonSetup());
                     scanHeader.appendChild(visioButtonSetup());
                     scanHeader.appendChild(textButtonSetup());
                     scanHeader.appendChild(xmlButtonSetup());
                     while(!userRequestedScanTermination)
                     {
                         WScript.Sleep(50);
                     }
                }
                else
                {
                     objScanIeQuitButton.innerText = "Return";
                     scanStatus.innerText = "Failed to retrieve list of targets form target.txt, are their any valid systems listed?  The file was found but no hosts inside.";
                }
            }
            else
            {
                scanStatus.innerText = "Failed to retrieve list of targets form target.txt, are their any valid systems listed?  The file was found but no hosts inside.";
                objScanIeQuitButton.innerText = "Return";
            }
            userRequestedScanTermination = false; //the user must have clicked the Stop Scan/Return button to get here (or there is a huge bug in my code) this is to re-initialize it
            objScanIeQuitButton.innerText = "Return";
        }
        else
        {
            objScanIeQuitButton.innerText = "Return";
            scanStatus.innerText = "Failed to retrieve list of targets form target.txt, are their any valid systems listed?  The file was found but no hosts inside.";
        }
        objScanIeQuitButton.innerText = "Return";
        while(userRequestedScanTermination == false)
        {
            WScript.Sleep(50);
        }
    }
    
    function retrieveDataForHost(hostName)
    {
         /*      This function should only need to be given a hostname and it will return the appropriate columns of data in an 
                 array in the order that the array uses for output.  The "columns" or scan items selected by the user will be read from
                 the global array of the selected items vis a vis the reportedColumns function. */
        var retrievalForHostArray = new Array();   //this is the array that will be returned when it is all said and done
        scanColumns = reportedColumns();
        for (d=0; d<scanColumns.length; d++) {
             switch(scanColumns[d][0]) { 
                 case "wksName":
                     retrievalForHostArray[d] = reportWmiHostName(hostName);
                 break
                 case "wksIP":
                     retrievalForHostArray[d] = reportIpAddress(hostName);
                 break
                 case "wksCPU":
                     retrievalForHostArray[d] = reportCPU(hostName);
                 break
                 case "wksRAM":
                     retrievalForHostArray[d] = reportRAM(hostName);
                 break
                 case "wksMake":
                     retrievalForHostArray[d] = reportMake(hostName);
                 break
                 case "wksModel":
                     retrievalForHostArray[d] = reportModel(hostName);
                 break
                 case "wksOS":
                     retrievalForHostArray[d] = reportOS(hostName);
                 break
                 case "wksWPK":
                     retrievalForHostArray[d] = reportProductKey(hostName);
                 break
                 case "wksSerial":
                     retrievalForHostArray[d] = removeFromString(reportSerial(hostName),"  ");
                 break       
                 case "wksLastUser":
                     retrievalForHostArray[d] = reportLastUser(hostName);
                 break
                 case "wksVideo":
                     retrievalForHostArray[d] = reportVideo(hostName);
                 break
                 case "wksAudio":
                     retrievalForHostArray[d] = reportAudio(hostName);
                 break
                 case "wksNetwork":
                     retrievalForHostArray[d] = reportNetwork(hostName);
                 break
                 case "wksDisk":
                     retrievalForHostArray[d] = reportDisk(hostName);
                 break
                 case "wksOffice":
                     retrievalForHostArray[d] = reportOffice(hostName);
                 break
                 case "wksApps":
                     retrievalForHostArray[d] = reportSoftware(hostName);
                 break
                 case "wksServices":
                     retrievalForHostArray[d] = reportServices(hostName);
                 break
                 case "wksLogs":
                     retrievalForHostArray[d] = reportLogs(hostName);
                 break
             }
        }
        return retrievalForHostArray;
    }
    
    
    function reportedColumns()
    {
        /*
             This function reads the users selected items to scan for and returns and array based on that.  Basically the UI side needs three columns. The
             short name variable, the boolean whether or not it is to be used, and the easly readable description.  The first column so to speak is will be 
             need by both the UI functions and the output functions for consistency sake and the last will be need for the end user's sake.  However here
             the function will filter the rows based on the "status" column and what is returned will have that entire column truncated as it is useless to
             the output functions.
            
             Or in short this looks like a stupid redundant function, but it isn't to me.
         */
         reportedOutputArray = new Array();
         g=0;
         for(h=0; h<wksArray.length; h++) {  
            if(wksArray[h][1] == true) {
                reportedOutputArray[g] = new Array(wksArray[h][0],wksArray[h][2]);
                g++;
            }
         }
         return reportedOutputArray;
    }

    //give a decent text file read in the system names that are
    //hopefully comma or cr/lf delimited...
    function getTextFileSystems(strFilePath)
    {
        var ForReading = 1;
        var objFso = new ActiveXObject("Scripting.FileSystemObject");
        var objSourceStream = objFso.OpenTextFile(strFilePath,ForReading);
        var arrayList = new Array();
        while (objSourceStream.AtEndOfStream != true)
        {
            var strTemp = objSourceStream.ReadLine();
            strTemp = strTemp.replace(" ","");
            if(strTemp.indexOf(",") > 0)
            {
                var arrayTemp = strTemp.split(",");
                for(var k = 0; k < arrayTemp.length; k++)
                {
                    if(arrayTemp[k] != "")
                    {
                        arrayList.push(arrayTemp[k]);
                    }
                }
            }
            else if(strTemp != "")
            {
                arrayList.push(strTemp);
            }
        }
        return arrayList;
    }

    function getAdSystems(domainName)
    {
        /* --------------------------------------------------------------------------------------
          function getAdSystems
          given: domainName - string that is the domain controller name
          return: array of strings that are computer account names in the active directory
       
          When the name name of a domain is given as an FQDN and is queried in DNS all of the
          IP addresses for domain controllers should be returned.  By using the FQDN like a 
          hostname this script "should" be able to attach to a domain controller via WMI and 
          from Active Directory collect a list of workstation names.  
       --------------------------------------------------------------------------------------- */
    
        var i = 0;   //used in for loop to index the array of hostnames
        var objComputer = "";   //make it a null string and local
        currentHostCredentials = userAccessCredentials(domainName);
        if(!isHostWmiAccessible(domainName))
        {
            scanStatus.innerText = "Unable to logon to domain controller.";
            return;
        }
        var computerArray = new Array();   //the array we will ultimately be returning with the computer names
        scanStatus.innerText = "Activating the Web Based Enterprise Managment locator for WMI...";
        var objLocator = new ActiveXObject("WbemScripting.SWbemLocator");
        scanStatus.innerText = "Connecting Remotely to " + domainName + " as user " + currentHostCredentials[0] + " to read root/directory/LDAP...";
        try
        {
            var objWMIService = objLocator.ConnectServer(domainName, "root/directory/LDAP", currentHostCredentials[0], currentHostCredentials[1],"","",128);
        }
        catch (err)
        {
            scanStatus.innerText = "Failed to access the domain controller with the error: " + err.description;
            var objWMIService = null;
        }
        if(objWMIService != null)
        {
            scanStatus.innerText = "Executeing Query: " + "SELECT * FROM ds_computer...";
            var result = objWMIService.ExecQuery("SELECT * FROM ds_computer");
        
            scanStatus.innerText = "Stepping through AD records...";
            for(var e = new Enumerator(result); !e.atEnd(); e.moveNext())
            {
                objComputer = e.item();
                switch(outputArray[2])
                {
                    case "Servers Only":
                        if(objComputer.ds_operatingSystem != null)
                        {
                            if(objComputer.ds_operatingSystem.match("Server"))
                            {
                                scanStatus.innerText = "Adding hostname " + objComputer.ds_cn + "...";
                                computerArray[i] = objComputer.ds_cn;
                                i++;
                            }
                        }
                    break
                    case "Workstations Only":
                        if(objComputer.ds_operatingSystem != null)
                        {
                            if(!objComputer.ds_operatingSystem.match("Server"))
                            {
                                scanStatus.innerText = "Adding hostname " + objComputer.ds_cn + "...";
                                computerArray[i] = objComputer.ds_cn;
                                i++;
                            }
                        }
                    break
                    case "All":
                        scanStatus.innerText = "Adding hostname " + objComputer.ds_cn + "...";
                        computerArray[i] = objComputer.ds_cn;
                        i++;
                    break
                }
            }
            scanStatus.innerText = "Alphabetically sorting the systems array...";
            computerArray.sort();   //might as well do it all alphabetically
            scanStatus.innerText = "Completed System Array generation for " + domainName + " with " + i-1 + " systems...";
            return computerArray;
        }
        else
        {
            return null;
        }
    }
    
    
    /*----------------------------------------------------------------------------------
    ------------------------------------------------------------------------------------
      Text File Dump Functions ...
    ------------------------------------------------------------------------------------
    ------------------------------------------------------------------------------------*/
    
    function dumpToText()
    {
        scriptPath = WScript.ScriptFullName.substr(0,WScript.ScriptFullName.length - WScript.ScriptName.length);
        var objShell = new ActiveXObject("WScript.Shell");   
        var primaryDumpArray = extractAllOtherArray(thisReturnArray);
        var appsDumpArray = extractGenericAppsArray(thisReturnArray);
        var servicesDumpArray = extractGenericServicesArray(thisReturnArray);
        var diskDumpArray = extractGenericDiskArray(thisReturnArray);
        var logsDumpArray = extractGenericLogsArray(thisReturnArray);
        if(wksArray[17][1] == true)  //check to see if the user has elected to use the "event logs" feature
        {
            dumpLogsToText(scriptPath + "\\Logs Report.csv",logsDumpArray);  //drop seperate array for event logs info into seperate excel sheet
        }
        if(wksArray[14][1] == true) //check to see if the user has elected to use the "disk report" feature
        {
            dumpDiskToText(scriptPath + "\\Disk Report.csv",diskDumpArray);  //drop seperate array for disk info into seperate excel sheet
        }
        if(wksArray[16][1] == true) //check to see if the user has elected to use the "services report" feature
        {   
            dumpServicesToText(scriptPath + "Services Report.csv",servicesDumpArray); //drop seperate array into seperate excel sheet
        }
        if(wksArray[15][1] == true) //check to see if the user has elected to use the "applications report" feature
        {
            dumpAppsToText(scriptPath + "\\Apps Report.csv",appsDumpArray);  //drop seperate array into seperate excel sheet
        }
        dumpPrimaryToText(scriptPath + "\\Base Report.csv",primaryDumpArray);
        objShell.PopUp("Report files created in same folder as this script file.", 0, "Finished");
    }
    
    function dumpToXML()
    {
         dumpArray = thisReturnArray;
         scriptPath = WScript.ScriptFullName.substr(0,WScript.ScriptFullName.length - WScript.ScriptName.length);
         var objDom = new ActiveXObject("MSXML.DOMDocument");  //create MSXML document object
         var objRootElement = objDom.createElement("Report");  //create root element
         objDom.appendChild(objRootElement);   //place create root element in XML doc
         for(var x = 1; x < dumpArray.length; x++)
         {
             var thisComputerElement = objDom.createElement("Computer");
             objRootElement.appendChild(thisComputerElement);
             for(var y = 0; y < dumpArray[x].length; y++)
             {
                 switch(dumpArray[0][y])
                 {
                     case "Name":
                         var hostNameAttribute = objDom.createAttribute("Hostname");
                         try
                         {
                             hostNameAttribute.nodeValue = dumpArray[x][y];
                         }
                         catch(err)
                         {
                             hostNameAttribute.nodeValue = "failed_write";
                         }
                         thisComputerElement.setAttributeNode(hostNameAttribute);
                     break;
                     case "IP Address":
                         var ipAddressesElement = objDom.createElement("IP_Addresses");
                         thisComputerElement.appendChild(ipAddressesElement);
                         for(var z = 0; z < dumpArray[x][y].length; z++)
                         {
                             var ipAddressElement = objDom.createElement("IP_Address");
                             try
                             {
                                 ipAddressElement.text = dumpArray[x][y][z];
                             }
                             catch(err)
                             {
                                 ipAddressElement.text = "failed_write";
                             }
                             ipAddressesElement.appendChild(ipAddressElement);
                         }
                     break;
                     case "CPU(s)":
                         var CPUAttribute = objDom.createAttribute("CPU");
                         try
                         {
                             CPUAttribute.nodeValue = dumpArray[x][y];
                         }
                         catch(err)
                         {
                             CPUAttribute.nodeValue = "failed_write";
                         }
                         thisComputerElement.setAttributeNode(CPUAttribute);
                     break;
                     case "System Memory":
                         var memoryAttribute = objDom.createAttribute("System_Memory");
                         try
                         {
                             memoryAttribute.nodeValue = dumpArray[x][y];
                         }
                         catch(err)
                         {
                             memoryAttribute.nodeValue = "failed_write";
                         }
                         thisComputerElement.setAttributeNode(memoryAttribute);
                     break;
                     case "System Make":
                         var makeAttribute = objDom.createAttribute("System_Make");
                         try
                         {
                             makeAttribute.nodeValue = dumpArray[x][y];
                         }
                         catch(err)
                         {
                             makeAttribute.nodeValue = "failed_write";
                         }
                         thisComputerElement.setAttributeNode(makeAttribute);
                     break;
                     case "System Model":
                         var modelAttribute = objDom.createAttribute("System_Model");
                         try
                         {
                             modelAttribute.nodeValue = dumpArray[x][y];
                         }
                         catch(err)
                         {
                             modelAttribute.nodeValue = "failed_write";
                         }
                         thisComputerElement.setAttributeNode(modelAttribute);
                     break;
                     case "Operating System":
                         var osAttribute = objDom.createAttribute("Operating_System");
                         try
                         {
                             osAttribute.nodeValue = dumpArray[x][y];
                         }
                         catch(err)
                         {
                             osAttribute.nodeValue = "failed_write";
                         }
                         thisComputerElement.setAttributeNode(osAttribute); 
                     break;
                     case "Windows Product Key":
                         var wpkAttribute = objDom.createAttribute("Windows_Product_Key");
                         try
                         {
                             wpkAttribute.nodeValue = dumpArray[x][y];
                         }
                         catch(err)
                         {
                             wpkAttribute.nodeValue = "failed_write";
                         }
                         thisComputerElement.setAttributeNode(wpkAttribute);
                     break;
                     case "Serial Number":
                         var snAttribute = objDom.createAttribute("Serial_Number");
                         try
                         {
                             snAttribute.nodeValue = dumpArray[x][y];
                         }
                         catch(err)
                         {
                             snAttribute.nodeValue = "failed_write";
                         }
                         thisComputerElement.setAttributeNode(snAttribute);
                     break;
                     case "Last User Logon":
                         var lulAttribute = objDom.createAttribute("Last_User_Logon");
                         try
                         {
                             lulAttribute.nodeValue = dumpArray[x][y];
                         }
                         catch(err)
                         {
                             lulAttribute.nodeValue = "failed_write";
                         }
                         thisComputerElement.setAttributeNode(lulAttribute);
                     break;
                     case "Video Adapter(s)":
                         var videoAdaptersElement = objDom.createElement("Video_Adapters");
                         thisComputerElement.appendChild(videoAdaptersElement);
                         for(var z = 0; z < dumpArray[x][y].length; z++)
                         {
                             var videoAdapterElement = objDom.createElement("Video_Adapter");
                             try
                             {
                                 videoAdapterElement.text = dumpArray[x][y][z];
                             }
                             catch(err)
                             {
                                 videoAdapterElement.text = "failed_write";
                             }
                             videoAdaptersElement.appendChild(videoAdapterElement);
                         }
                     break;
                     case "Audio Adapter(s)":
                         var audioAdaptersElement = objDom.createElement("Audio_Adapters");
                         thisComputerElement.appendChild(audioAdaptersElement);
                         for(var z = 0; z < dumpArray[x][y].length; z++)
                         {
                             var audioAdapterElement = objDom.createElement("Audio_Adapter");
                             try
                             {
                                 audioAdapterElement.text = dumpArray[x][y][z];
                             }
                             catch(err)
                             {
                                 audioAdapterElement.text = "failed_write";
                             }
                             audioAdaptersElement.appendChild(audioAdapterElement);
                         }
                     break;
                     case "Network Adapter(s)":
                         var networkAdaptersElement = objDom.createElement("Network_Adapters");
                         thisComputerElement.appendChild(networkAdaptersElement);
                         for(var z = 0; z < dumpArray[x][y].length; z++)
                         {
                             var networkAdapterElement = objDom.createElement("Network_Adapter");
                             try
                             {
                                 networkAdapterElement.text = dumpArray[x][y][z];
                             }
                             catch(err)
                             {
                                 networkAdapterElement.text = "failed_write";
                             }
                             networkAdaptersElement.appendChild(networkAdapterElement);
                         }
                     break;
                     case "Microsoft Office":
                         var tempArray = dumpArray[x][y].split("\\");
                         var msOfficeAppsElement = objDom.createElement("Microsoft_Office_Applications");
                         thisComputerElement.appendChild(msOfficeAppsElement);
                         for(var z = 0; z < tempArray.length; z++)
                         {
                             var officeElement = objDom.createElement("MS_Office");
                             try
                             {  
                                 officeElement.text = tempArray[z];
                             }
                             catch(err)
                             {
                                 officeElement.text = "failed_write";
                             }
                             msOfficeAppsElement.appendChild(officeElement);
                         }
                     break;
                     case "Hard Disk(s)":
                         var disksElement = objDom.createElement("Disks");
                         thisComputerElement.appendChild(disksElement);
                         for(var z = 0; z < dumpArray[x][y].length; z++)
                         {
                             var diskElement = objDom.createElement("Hard_Disk");
                             disksElement.appendChild(diskElement);
                             var letterAttribute = objDom.createAttribute("Letter");
                             try
                             {
                                 letterAttribute.nodeValue = dumpArray[x][y][z][0];
                             }
                             catch(err)
                             {
                                 letterAttribute.nodeValue = "failed_write";
                             }
                             diskElement.setAttributeNode(letterAttribute);
                             var capacityAttribute = objDom.createAttribute("Capacity");
                             try
                             {
                                 capacityAttribute.nodeValue = dumpArray[x][y][z][1].replace("Capacity: ","");
                             }
                             catch(err)
                             {
                                 capacityAttribute.nodeValue = "failed_write";
                             }
                             diskElement.setAttributeNode(capacityAttribute);
                             var freeSpaceAttribute = objDom.createAttribute("Free_Space");
                             try
                             {
                                 freeSpaceAttribute.nodeValue = dumpArray[x][y][z][2].replace("Free Space: ","");
                             }
                             catch(err)
                             {
                                 freeSpaceAttribute.nodeValue = "failed_write";
                             }
                             diskElement.setAttributeNode(freeSpaceAttribute);
                             var freePercentAttribute = objDom.createAttribute("Free_Percent");
                             try
                             {
                                 freePercentAttribute.nodeValue = dumpArray[x][y][z][3].replace("Free\%:","");
                             }
                             catch(err)
                             {
                                 freePercentAttribute.nodeValue = "failed_write";
                             }
                             diskElement.setAttributeNode(freePercentAttribute);
                         }
                     break;
                     case "Application Report":
                         var applicationsElement = objDom.createElement("Applications");
                         thisComputerElement.appendChild(applicationsElement);
                         for(var z = 0; z < dumpArray[x][y].length; z++)
                         {
                             var applicationElement = objDom.createElement("Application");
                             try
                             {
                                 applicationElement.text = dumpArray[x][y][z];
                             }
                             catch(err)    
                             {
                                 applicationElement.text = "failed_write";
                             }
                             applicationsElement.appendChild(applicationElement);
                         }
                     break;
                     case "Report Services":
                         var servicesElement = objDom.createElement("Windows_Services");
                         thisComputerElement.appendChild(servicesElement);
                         for(var z = 0; z < dumpArray[x][y].length; z++)
                         {
                             var serviceElement = objDom.createElement("Service");
                             servicesElement.appendChild(serviceElement);
                             var serviceNameAttribute = objDom.createAttribute("Service_Name");
                             try
                             {
                                 serviceNameAttribute.nodeValue = dumpArray[x][y][z][0];
                             }
                             catch(err)
                             {
                                 serviceNameAttribute.nodeValue = "failed_write";
                             }
                             serviceElement.setAttributeNode(serviceNameAttribute);
                             var serviceStatusAttribute = objDom.createAttribute("Service_Status");
                             try
                             {
                                 serviceStatusAttribute.nodeValue = dumpArray[x][y][z][1];
                             }
                             catch(err)
                             {
                                 serviceStatusAttribute.nodeValue = "failed_write";
                             }
                             serviceElement.setAttributeNode(serviceStatusAttribute);
                             var serviceStartupTypeAttribute = objDom.createAttribute("Service_Startup");
                             try
                             {
                                 serviceStartupTypeAttribute.nodeValue = dumpArray[x][y][z][2];
                             }
                             catch(err)
                             {
                                 serviceStartupTypeAttribute.nodeValue = "failed_write";
                             }
                             serviceElement.setAttributeNode(serviceStartupTypeAttribute);
                         }
                     break;
                     case "Report Logs":
                         var logsElement = objDom.createElement("Event_Logs");
                         thisComputerElement.appendChild(logsElement);
                         for(var z = 0; z < dumpArray[x][y].length; z++)
                         {
                             var logElement = objDom.createElement("Log_Entry");
                             logsElement.appendChild(logElement);
                             var logHostNameAttribute = objDom.createAttribute("Log_HostName");
                             try
                             {
                                 logHostNameAttribute.nodeValue = dumpArray[x][y][z][0];
                             }
                             catch(err)
                             {
                                 logHostNameAttribute.nodeValue = "failed_write";
                             }
                             logElement.setAttributeNode(logHostNameAttribute);
                             var logFileAttribute = objDom.createAttribute("Log_File");
                             try
                             {
                                 logFileAttribute.nodeValue = dumpArray[x][y][z][1];
                             }
                             catch(err)
                             {
                                 logFileAttribute.nodeValue = "failed_write";
                             }
                             logElement.setAttributeNode(logFileAttribute);
                             var logClassAttribute = objDom.createAttribute("Log_Class");
                             try
                             {
                                 logClassAttribute.nodeValue = dumpArray[x][y][z][2];
                             }
                             catch(err)
                             {
                                 logClassAttribute.nodeValue = "failed_write";
                             }
                             logElement.setAttributeNode(logClassAttribute);
                             var logEventIDAttribute = objDom.createAttribute("Log_Event_ID");
                             try
                             {
                                 logEventIDAttribute.nodeValue = dumpArray[x][y][z][3];
                             }
                             catch(err)
                             {
                                 logEventIDAttribute.nodeValue = "failed_write";
                             }
                             logElement.setAttributeNode(logEventIDAttribute);
                             var logDescriptionElement = objDom.createElement("Log_Description");
                             logElement.appendChild(logDescriptionElement);
                             try
                             {
                                 logDescriptionElement.text = dumpArray[x][y][z][4];
                             }
                             catch(err)
                             {
                                 logDescriptionElement.text = "failed_write";
                             }
                             var logEventIncidenceAttribute = objDom.createAttribute("Log_Incidence_Count");
                             try
                             {
                                 logEventIncidenceAttribute.nodeValue = dumpArray[x][y][z][5];
                             }
                             catch(err)
                             {
                                 logEventIncidenceAttribute.nodeValue = "failed_write";
                             }
                             logElement.setAttributeNode(logEventIncidenceAttribute);
                         }
                     break;
                 }
             }
         }
         objDom.save(scriptPath + "output.xml");
         WScript.Echo("Output at " + scriptPath + "output.xml.");
         objDom = null;
    }
    
    //put most of the core system information into an Text based csv file
    function dumpPrimaryToText(strPath,dumpArray)
    {
        var ForWriting = 2;
        var objFso = new ActiveXObject("Scripting.FileSystemObject");
        var outputFile = objFso.OpenTextFile(strPath, ForWriting, true); 
        for (var x = 0; x < dumpArray.length; x++)
        {
           for(var y = 0; y < dumpArray[x].length; y++)
           {
               if(!(typeof(dumpArray[x][y]) == "string")) 
               {
                   outputFile.Write(dumpArray[x][y].join(" ") + ",");
               }
               else
               {
                   outputFile.Write(dumpArray[x][y] + ",");
               }
           }
           outputFile.WriteLine();
        }
        outputFile = null;
    }

    //put logs information into an Text based csv file
    function dumpLogsToText(strPath,dumpArray)
    {
        var ForWriting = 2;
        var objFso = new ActiveXObject("Scripting.FileSystemObject");
        var outputFile = objFso.OpenTextFile(strPath, ForWriting, true); 
        outputFile.WriteLine("Host,Log Name,Category,Event ID,Event Type,Description,User,Incidence Count");
        for(var x = 0; x < dumpArray.length; x++)
        {
            for(var y = 0; y < dumpArray[x].length; y++)
            {
                for(var z = 0; z < dumpArray[x][y].length; z++)
                {
                   if(!(typeof(dumpArray[x][y][z]) == "undefined"))
                   {
                        for(var w = 0; w < dumpArray[x][y][z].length; w++)
                        {
                            var strTemp = dumpArray[x][y][z][w];   //this is the line causing the crash to the to text dump
                            if(typeof(strTemp) == "string")
                            {
                                strTemp = strTemp.replace(/,/g,";");
                                strTemp = strTemp.replace(/\r/g," ");
                                strTemp = strTemp.replace(/\n/g," ");
                                strTemp = strTemp.replace(/\f/g," ");
                            }
                            try
                            {
                                outputFile.Write(strTemp + ",");
                            }
                            catch(err)
                            {
                                outputFile.Write("ERROR WRITING THIS EVENT DESCRIPTION TO TEXT FILE,");
                            }
                        }
                        outputFile.WriteLine();
                    }
                    
                }
            }
        }
        outputFile = null;
    }

    //put the services lists into a csv file
    function dumpServicesToText(strPath, dumpArray)
    {
        if(wksArray[16][1] == true)  //if the application option is checked
        {
            var ForWriting = 2;
            var objFso = new ActiveXObject("Scripting.FileSystemObject");
            var outputFile = objFso.OpenTextFile(strPath, ForWriting, true);
            
            for(var x = 0; x < dumpArray.length; x++)
            {
                outputFile.Write(dumpArray[x][0] + ",,,");  
            }
            outputFile.WriteLine();
            for(var x = 0; x < dumpArray.length; x++)
            {
                outputFile.Write("Service Name, Status, Startup Type,");
            }
            outputFile.WriteLine();
            intLongestList = 0;  //get the longest list of services for the report
            for(var x = 0; x < dumpArray.length; x++)  
            {
                if(dumpArray[x][1].length > intLongestList)
                {
                    intLongestList = dumpArray[x][1].length;
                }
            }
            for(var w = 0; w < intLongestList; w++)  //first dimension through by number of services
            {
                for(var z = 0; z < dumpArray.length; z++)  //second dimension through by number of computers
                {
                    if(w < dumpArray[z][1].length)
                    {
                        outputFile.Write(dumpArray[z][1][w] + ",");  //write this is there is data
                    }
                    else
                    {
                        outputFile.Write(",,,");  //write this is there isn't data there
                    }
                }
                outputFile.WriteLine();
            }
        outputFile = null;
        }
    }
    
    function dumpAppsToText(strPath, dumpArray)
    {
        if(wksArray[15][1] == true)
        {
            var ForWriting = 2;
            var objFso = new ActiveXObject("Scripting.FileSystemObject");
            var outputFile = objFso.OpenTextFile(strPath, ForWriting, true);
            for(var x = 0; x < dumpArray.length; x++)
            {
                outputFile.Write(dumpArray[x][0] + ",");
            }
            outputFile.WriteLine();
            var intLongestList = "0";
            for(var x = 0; x < dumpArray.length; x++)
            {
                if(dumpArray[x][1].length > intLongestList)
                {
                    intLongestList = dumpArray[x][1].length;
                }
            }
            for(var w = 0; w < intLongestList; w++)
            {
                for(var z = 0; z < dumpArray.length; z++)
                {
                    if(w < dumpArray[z][1].length)
                    {
                        try
                        {
                            outputFile.Write(dumpArray[z][1][w].replace(",",";") + ",");
                        }
                        catch(err)
                        {
                            outputFile.Write("failed_write,");
                        }
                    }
                    else
                    {
                        outputFile.Write(" ,");
                    }
                }
                outputFile.WriteLine();
            }
            outputFile = null;
        }
    }
    
    function dumpDiskToText(strPath, dumpArray)
    {
        if(wksArray[14][1] == true)  //if the disk option is checked
        {
            var ForWriting = 2;
            var objFso = new ActiveXObject("Scripting.FileSystemObject");
            var outputFile = objFso.OpenTextFile(strPath, ForWriting, true);
            outputFile.WriteLine("Hostname,Drive,Capacity,Free Space,Free Percent");            
            for (var i=0; i<dumpArray.length; i++)
            {
                outputFile.Write(dumpArray[i][0] + ",");
                for(var j=1; j<dumpArray[i][1].length; j++);  //array of array of disks
                {
                    for(var k=0; k<dumpArray[i][1].length; k++)  //array of single drive
                    {
                         if(k != 0)
                         {
                             outputFile.Write(",");
                         }
                         outputFile.Write(dumpArray[i][1][k][0] + ",");  //this is the first time I've ever dug down into a 4-dimensional array
                         outputFile.Write(dumpArray[i][1][k][1].replace("Capacity: ","") + ",");
                         outputFile.Write(dumpArray[i][1][k][2].replace("Free Space: ","") + ",");
                         outputFile.Write(dumpArray[i][1][k][3].replace("Free\%: ","") + ",");
                         outputFile.WriteLine();
                    }
                }
            }
            outputFile = null;
        }
    }
    
    /*------------------------------------------------------------------------------------
    ------------------------------------------------------------------------------------
      EXCEL Manipulation Functions ...
    ------------------------------------------------------------------------------------
    ------------------------------------------------------------------------------------*/

    function dumpToExcel()
    {
        var objXL   //the excel application object
        var objWb   //the excel workbook object
        
        try
        {
            objXL = WScript.CreateObject("Excel.Application");    //get execl as an application
        }
        catch(err)
        {
            var objShell = new ActiveXObject("WScript.Shell");
            objShell.Popup("Excel object is inaccessible.  You need to have Microsoft Excel installed in order to use this feature.", 0, "Error", 0x0 + 0x20000 );
            return;
        }
        objXL.WindowState = 1;    //normal window state is fine
        objXL.Height = 600;
        objXL.Width = 800;
        objXL.Left = 40;
        objXL.Top = 20;
        objXL.Visible = true;   //in the end this will probably not be set to true, as I would prefer it not be seen
        objXL.WorkBooks.Add;
        var primaryDumpArray = extractAllOtherArray(thisReturnArray);
        var appsDumpArray = extractGenericAppsArray(thisReturnArray);
        var servicesDumpArray = extractGenericServicesArray(thisReturnArray);
        var diskDumpArray = extractGenericDiskArray(thisReturnArray);
        var logsDumpArray = extractGenericLogsArray(thisReturnArray);
        if(wksArray[17][1] == true)  //check to see if the user has elected to use the "event logs" feature
        {
            dumpLogsToExcel(objXL,logsDumpArray);  //drop seperate array for event logs info into seperate excel sheet
        }
        if(wksArray[14][1] == true)  //check to see if the user has elected to use the "disk report" feature
        {
            dumpDiskToExcel(objXL,diskDumpArray);  //drop seperate array for disk info into seperate excel sheet
        }
        if(wksArray[16][1] == true)  //check to see if the user has elected to use the "services report" feature
        {
            dumpServicesToExcel(objXL,servicesDumpArray); //drop seperate array into seperate excel sheet
        }
        if(wksArray[15][1] == true)  //check to see if the user has elected to use the "applications" feature
        {
            dumpAppsToExcel(objXL,appsDumpArray);  //drop seperate array into seperate excel sheet
        }
        dumpPrimaryToExcel(objXL,primaryDumpArray);  //drop primary array of info in excel
        //clean up Excel
        try
        {
            objXL.Sheets("Sheet3").Delete;
            objXL.Sheets("Sheet2").Delete;
            objXL.Sheets("Sheet1").Delete;
        }
        catch(err)
        {
            // eh.
        }
    }
    
    //put most of the core system information into an Excel spreadsheet
    function dumpPrimaryToExcel(objExcel,dumpArray)
    {
        var mySheet = objExcel.Sheets.Add();
        mySheet.Name = "Systems";
        var objWb = objExcel.ActiveWorkBook.Worksheets("Systems");
        objWb.Cells.Clear;
        objWb.Activate();
        for (var x=0; x<dumpArray.length; x++)
        {
            for (var y=0; y<dumpArray[x].length; y++)
            {
                objExcel.Cells(x+1,y+1).Value = dumpArray[x][y];
            }
        }
        objWb.Columns.AutoFit();
        objWb.Rows.AutoFit();
    }
    
    //put the Windows Event Log information collected into Excel
    function dumpLogsToExcel(objExcel,dumpArray)
    {
        var mySheet = objExcel.Sheets.Add();
        mySheet.Name = "Event Logs";
        var objWb = objExcel.ActiveWorkBook.Worksheets("Event Logs");
        objWb.Cells.Clear;
        objWb.Activate();
        objExcel.Cells(1,1).Value = "Host";
        objExcel.Cells(1,2).Value = "Log Name";
        objExcel.Cells(1,3).Value = "Category";
        objExcel.Cells(1,4).Value = "Event ID";
        objExcel.Cells(1,5).Value = "Event Type";
        objExcel.Cells(1,6).Value = "Description";
        objExcel.Cells(1,7).Value = "User";
        objExcel.Cells(1,8).Value = "Incidence Count";
        var intCellRow = 2;   //increment
        for(var x = 0; x < dumpArray.length; x++)
        {
            for(var y = 0; y < dumpArray[x].length; y++)
            {
                for(var z = 0; z < dumpArray[x][y].length; z++)
                {
                   if(!(typeof(dumpArray[x][y][z]) == "undefined"))
                   {
                        try
                        {
                            for(var w = 0; w < dumpArray[x][y][z].length; w++)  //this is the line causing the excel dump to crash for some people
                            {
                                objExcel.Cells(intCellRow,w+1).Value = dumpArray[x][y][z][w];
                            }
                        }
                        catch(err)
                        {
                            //meh
                        }
                        intCellRow++;
                    }
                }
            }
        }
        objWb.Columns.AutoFit();
        objWb.Rows.AutoFit();
    }
    
    //given the Excel Object and the application array
    //draws out the information
    function dumpDiskToExcel(objExcel,dumpArray)
    {
        if(wksArray[14][1] == true)  //if the disk option is checked
        {
            var mySheet = objExcel.Sheets.Add();
            mySheet.Name = "Disk Information";
            var objWb = objExcel.ActiveWorkBook.WorkSheets("Disk Information");
            objWb.Cells.Clear;
            objWb.Activate();
            objExcel.Cells(1,1).Value = "Hostname";
            objExcel.Cells(1,2).Value = "Drive";
            objExcel.Cells(1,3).Value = "Capacity";
            objExcel.Cells(1,4).Value = "Free Space";
            objExcel.Cells(1,5).Value = "Free Percent";
            var rowCounter = 2;
            for (var i=0; i<dumpArray.length; i++)
            {
                objExcel.Cells(rowCounter,1).Value = dumpArray[i][0];
                for(var j=1; j<dumpArray[i][1].length; j++);  //array of array of disks
                {
                    for(var k=0; k<dumpArray[i][1].length; k++)  //array of single drive
                    {
                         objExcel.Cells(rowCounter,2) = dumpArray[i][1][k][0];  //this is the first time I've ever dug down into a 4-dimensional array
                         objExcel.Cells(rowCounter,3) = dumpArray[i][1][k][1].replace("Capacity: ","");
                         objExcel.Cells(rowCounter,4) = dumpArray[i][1][k][2].replace("Free Space: ","");
                         objExcel.Cells(rowCounter,5) = dumpArray[i][1][k][3].replace("Free\%: ","");
                         rowCounter++;
                    }
                }
            }
            objWb.Columns.AutoFit();
            objWb.Rows.AutoFit();
        }
    }
    
    //given the Excel Object and the application array
    //draws out the information
    function dumpServicesToExcel(objExcel,dumpArray)
    {
        if(wksArray[16][1] == true)  //if the application option is checked
        {
            var mySheet = objExcel.Sheets.Add();
            mySheet.Name = "Windows Services";
            var objWb = objExcel.ActiveWorkBook.WorkSheets("Windows Services");
            objWb.Cells.Clear;
            objWb.Activate();
            for (var x=0; x<dumpArray.length; x++)
            {
                objExcel.Cells(1,x+1).Value = dumpArray[x][0];
                for(var y=1; y<dumpArray[x][1].length; y++);
                {
                    for(var z=0; z<dumpArray[x][1].length; z++)
                    {
                         objExcel.Cells(z+2,x+1) = dumpArray[x][1][z];
                    }
                }
            }
            objWb.Columns.AutoFit();
            objWb.Rows.AutoFit();
        }
    }
    
    //given the Excel Object and the application array
    //draws out the information
    function dumpAppsToExcel(objExcel, dumpArray)
    {
        if(wksArray[15][1] == true)  //if the application option is checked
        {
            var mySheet = objExcel.Sheets.Add();
            mySheet.Name = "Applications";
            var objWb = objExcel.ActiveWorkBook.WorkSheets("Applications");
            objWb.Cells.Clear;
            objWb.Activate();
            for (var x=0; x<dumpArray.length; x++)
            {
                objExcel.Cells(1,x+1).Value = dumpArray[x][0];
                for(var y=1; y<dumpArray[x][1].length; y++);
                {
                    for(var z=0; z<dumpArray[x][1].length; z++)
                    {
                         objExcel.Cells(z+2,x+1) = dumpArray[x][1][z];
                    }
                }
            }
            objWb.Columns.AutoFit();
            objWb.Rows.AutoFit();
        }
    }
    
    //takes the whole array of everything and returns and array with only the computer name and 
    //the apps array for that computer  ... to be used to dump to sheet #2.
    function extractGenericAppsArray(fullArray)
    {
        var returnArray = new Array();
        for(var i=1; i<fullArray.length; i++)
        {
             returnArray.push(new Array(fullArray[i][0],fullArray[i][getApplicationReportColumn(fullArray)]));
        }
        return returnArray;
    }
    
    function extractGenericServicesArray(fullArray)
    {
        var returnArray = new Array();
        for(var i=1; i<fullArray.length; i++)
        {
             returnArray.push(new Array(fullArray[i][0],fullArray[i][getServicesReportColumn(fullArray)]));
        }
        return returnArray;
    }
    
    function extractGenericDiskArray(fullArray)
    {
        var returnArray = new Array();
        for(var i=1; i<fullArray.length; i++)
        {
            returnArray.push(new Array(fullArray[i][0],fullArray[i][getDiskReportColumn(fullArray)]));
        }
        return returnArray;
    }
    
    function extractGenericLogsArray(fullArray)
    {
        var returnArray = new Array();
        for(var i=1; i<fullArray.length; i++)
        {
            returnArray.push(new Array(fullArray[i][0],fullArray[i][getLogsReportColumn(fullArray)]));
        }
        return returnArray;
    }
    
    //returns an array without the generic application dump or services dump in it
    //BTW this is really stupid, if jscript would make a copy of an array instead of referencing memory on me this
    //function would only be three lines long ... grrr
    function extractAllOtherArray(fullArray)
    {
        var intRemoveAppsColumn = getApplicationReportColumn(fullArray);
        var intRemoveServicesColumn = getServicesReportColumn(fullArray);
        var intRemoveDiskColumn = getDiskReportColumn(fullArray);
        var intRemoveLogsColumn = getLogsReportColumn(fullArray);
        var returnArray = new Array();
        for(var i=0; i<fullArray.length; i++)
        {
            var lineArray = new Array();
            for(var j=0; j<fullArray[i].length; j++)
            {
                if(j != intRemoveAppsColumn && j != intRemoveServicesColumn && j != intRemoveDiskColumn && j != intRemoveLogsColumn)
                { 
                    lineArray[j] = fullArray[i][j];
                }
            }
            returnArray[i] = lineArray;
        }
        return returnArray;
    }
    
    //returns the column number in the two-dimensional array that contains
    //all of the generic application information for systems, if it isn't there
    //it will return a -1
    function getApplicationReportColumn(fullArray)
    {
        var appsColumn = -1;
        for(var i=0; i<fullArray[0].length; i++)
        {
            if(fullArray[0][i] == "Application Report")
            {
                appsColumn = i;
            } 
        }
        return appsColumn;
    }
    
    //returns the column number in the two-dimensional array that contains
    //all of the Windows Services information for systems, if it isn't there
    //it will return a -1
    function getServicesReportColumn(fullArray)
    {
        var appsColumn = -1;
        for(var i=0; i<fullArray[0].length; i++)
        {
            if(fullArray[0][i] == "Report Services")
            {
                appsColumn = i;
            } 
        }
        return appsColumn;
    }
    
    //returns the column number in the two-dimensional array that contains
    //all of the Hard Disk information for systems, if it isn't there
    //it will return a -1
    function getDiskReportColumn(fullArray)
    {
        var appsColumn = -1;
        for(var i=0; i<fullArray[0].length; i++)
        {
            if(fullArray[0][i] == "Hard Disk(s)")
            {
                appsColumn = i;
            } 
        }
        return appsColumn;
    }
    
    //returns the column number in the two-dimensional array that contains
    //all of the Windows Event Log information for systems, if it isn't there
    //it will return a -1
    function getLogsReportColumn(fullArray)
    {
        var appsColumn = -1;
        for(var i=0; i<fullArray[0].length; i++)
        {
            if(fullArray[0][i] == "Report Logs")
            {
                appsColumn = i;
            } 
        }
        return appsColumn;
    }
    
    /*------------------------------------------------------------------------------------
    ------------------------------------------------------------------------------------
      Visio Manipulation Functions ...
    ------------------------------------------------------------------------------------
    ------------------------------------------------------------------------------------*/

    function dumpToVisio()
    {
    
        var intVisCharPlain = 0;
        var intVisCharHidden = 1;
        var intVisCharBold = 2;
        var intVisCharAllCaps = 3;
        var intVisCharSubscript = 4;
        var intVisCharDoubleUnderline = 8;
        var intVisCharDoubleOverline = 9;
        var intVisCharDoubleStrikethrough = 10;
        var intVisHorzAlign = 6;
        var intVisSectionParagraph = 4;
        var intVisSectionControls = 9;
        var intVisCtlX = 0;
        var intVisCtlY = 1;
        var intVisSectionProp = 243;
        var intVisCustPropsValue = 0;
        var intVisCustomShapeAssetNumber = 4;
        var intVisCustomShapeSerialNubmer = 5;
        var intVisCustomShapeManufacturer = 0;
        var intVisCustomShapeDescription = 12;
        var intVisCustomShapeNetworkName = 13;
        var intVisCustomShapeIpAddress = 11;
        var intVisSectionObject = 1;
        var intVisRowPage = 10;
        var intVisPageWidth = 0;
        var intVisPageHeight = 1;
        var intVisPageDrawSizeType = 6;
        try
        {
            objVisio = WScript.CreateObject("Visio.Application");    //get visio as an application
        }
        catch(err)
        {
            var objShell = new ActiveXObject("WScript.Shell");
            objShell.Popup("Visio object is inaccessible.  You need to have Microsoft Visio installed in order to use this feature.", 0, "Error", 0x0 + 0x20000 );
            return;
        }
        var colDocs = objVisio.Documents;
        var objDoc = colDocs.Add("Basic Network Diagram (US units).vst");
        var colPages = objVisio.ActiveDocument.Pages;
        var objPage = colPages.Item(1);
        
        var tempArray = extractAllOtherArray(thisReturnArray);
        var columnTitleArray = tempArray[0];
        var inputArray = tempArray.splice(1,tempArray.length);
        var intShpCount = inputArray.length;
        setVisionPageDimensions(intShpCount, objPage);
        for(var j = 0; j < inputArray.length; j++)
        {
    		generateServer(objPage, objVisio, columnTitleArray, inputArray[j], j, intShpCount);
        }
    }
    
    /* ****************************************************************************
    generate a server shape on Visio and populate data the appropriate data
    
    myVisPage is the page object in Visio
    
    myVisObj is the Visio applicaiton object
    
    settignsArray is a simple one dimensional array that contains the documnetor
    script based columns selected for reporting
    ***************************************************************************** */
    function generateServer(myVisPage, myVisObj, settingsArray, infoArray, intShapeNumber, intTotalShapeCount)
    {
        var intVisCtlX = 0;
        var intVisCtlY = 1;
    	var intVisSectionParagraph = 4;
        var intVisSectionControls = 9;
        var intVisCharPlain = 0;
        var intVisCharHidden = 1;
        var intVisCharBold = 2;
        var intVisCharAllCaps = 3;
        var intVisHorzAlign = 6;
        var intVisSectionProp = 243;
    
    	var objShp = myVisPage.Drop(myVisObj.Documents.Item("PERIPH_U.VSS").Masters.ItemU("Server"), (Math.floor(intShapeNumber/Math.ceil(Math.sqrt(intTotalShapeCount))) * 6 + 1), (intShapeNumber % Math.ceil(Math.sqrt(intTotalShapeCount))+1));
    	for(var k = 0; k < infoArray.length; k++)
    	{
    	    if(settingsArray[k] == "Name" || settingsArray[k] == "IP Address" || settingsArray[k] == "Operating System" || settingsArray[k] == "System Make" || settingsArray[k] == "System Model")
    	    {
    		    if(k == infoArray.length)
    		    {
    			    objShp.Text += infoArray[k];
    		    }
    		    else
    		    {
    			    objShp.Text += infoArray[k] + "\n";
    		    }
    		}
    		var numWidthValueInches = findLongestLineInString(objShp.Text) * 0.04 + 0.1;  //set an acceptable distance to the right for the label text
    		var objVsoChars = objShp.Characters;
    		objVsoChars.Begin = 0;
    		objVsoChars.End = objShp.Text.indexOf("\n");
    		objVsoChars.CharProps(intVisCharBold) = 17;
    		objShp.CellsSRC(intVisSectionParagraph, 0, intVisHorzAlign).FormulaU = "0"
    		objShp.CellsSRC(intVisSectionControls, 0, intVisCtlX).FormulaU = "Width--" + numWidthValueInches + " in"
            objShp.CellsSRC(intVisSectionControls, 0, intVisCtlY).FormulaU = "0.4 in"
            for (var h = 0; h < infoArray.length; h++)
            {
                 setPropertyOnServerShape(settingsArray[h], infoArray[h], objShp);
            }
    	}
    }
    /* ***********************************************************************************************
    will write to a Visio shape the given data
    
    strProperty is the name of the property according to the documentor script (i.e. wksName is the
    system's hostname, wksIP is systems IP address or addresses, etc.)
    
    strValueToAssign is the value that will be populated for this field
    
    myServerShape is the Visio shape object that this information will be applied to
    
    *********************************************************************************************** */    
    function setPropertyOnServerShape(strProperty,strValueToAssign,myServerShape)
    {
        var intVisCharPlain = 0;
        var intVisCharHidden = 1;
        var intVisCharBold = 2;
        var intVisCharAllCaps = 3;
        var intVisCharSubscript = 4;
        var intVisCharDoubleUnderline = 8;
        var intVisCharDoubleOverline = 9;
        var intVisCharDoubleStrikethrough = 10;
        var intVisSectionParagraph = 4;
        var intVisSectionControls = 9;
        var intVisSectionProp = 243;
        var intVisCustPropsValue = 0;
        var intVisCustomShapeAssetNumber = 4;
        var intVisCustomShapeSerialNubmer = 5;
        var intVisCustomShapeManufacturer = 0;
        var intVisCustomShapeDescription = 12;
        var intVisCustomShapeNetworkName = 10;
        var intVisCustomShapeIpAddress = 11;
        var intVisCustomShapeCPU = 17;
        var intVisCustomShapeMemory = 18;
        var intVisCustomShapeOS = 19;
        var intVisCustomShapeModel = 3;
        var intVisSectionObject = 1;
        
        switch(strProperty) 
        {
        case "Name":
             myServerShape.CellsSRC(intVisSectionProp, intVisCustomShapeNetworkName, intVisCustPropsValue).FormulaU = "\"" + strValueToAssign + "\"";
             break;
        case "IP Address":
             myServerShape.CellsSRC(intVisSectionProp, intVisCustomShapeIpAddress, intVisCustPropsValue).FormulaU = "\"" + strValueToAssign + "\"";
             break;
        case "CPU(s)":
             myServerShape.CellsSRC(intVisSectionProp, intVisCustomShapeCPU, intVisCustPropsValue).FormulaU = "\"" + strValueToAssign + "\"";
             break;
        case "System Memory":
             myServerShape.CellsSRC(intVisSectionProp, intVisCustomShapeMemory, intVisCustPropsValue).FormulaU = "\"" + strValueToAssign + "\"";
             break;
        case "System Make":
             myServerShape.CellsSRC(intVisSectionProp, intVisCustomShapeManufacturer, intVisCustPropsValue).FormulaU = "\"" + strValueToAssign + "\"";
             break;
        case "System Model":
             myServerShape.CellsSRC(intVisSectionProp, intVisCustomShapeModel, intVisCustPropsValue).FormulaU = "\"" + strValueToAssign + "\"";
             break;
        case "Operating System":
             myServerShape.CellsSRC(intVisSectionProp, intVisCustomShapeOS, intVisCustPropsValue).FormulaU = "\"" + strValueToAssign + "\"";
             break;
        case "Serial Number":
             myServerShape.CellsSRC(intVisSectionProp, intVisCustomShapeSerialNubmer, intVisCustPropsValue).FormulaU = "\"" + strValueToAssign + "\"";
             break;
        case "wksLastUser":
             /* this is pretty much ignored here */
             break;
        case "Video Adapter(s)":
             /* this is pretty much ignored here */
             break;
        case "Audio Adapter(s)":
             /* this is pretty much ignored here */
         break;
        case "Network Adapter(s)":
             /* this is pretty much ignored here */
             break;
        case "Hard Disk(s)":
             /* future use I hope! */
             break;
        case "Microsoft Office":
             /* this is pretty much ignored here */
             break;
        case "wksApps":
             /* this is pretty much ignored here */
             break;
        case "Report Services":
             /* this is pretty much ignored here */
             break;
        }
    }
    
    /* ****************************************************************************
    feed it with an integer value for the number of servers and set the page size
    for my target Visio page
    
    intItemCount is an integer value with the number of targeted incoming servers
    
    myVsoPage is the Visio page object will be dropping our shapes on
    ***************************************************************************** */
    function setVisionPageDimensions(intItemCount, myVsoPage)
    {
    	var intVisPageWidth = 0;
        var intVisPageHeight = 1;
        var intVisPageDrawSizeType = 6;
        var intVisSectionObject = 1;
        var intVisRowPage = 10;
    
        var intBaseXdim = 11;
        var intBaseYdim = 8;
        var intBaseSqr = Math.ceil(Math.sqrt(intItemCount));
        if((intBaseSqr + 1) > intBaseYdim)
        {
    		intBaseYdim = intBaseSqr + 1;
        }
    	if((intBaseSqr * 6) > intBaseXdim)
    	{
    		intBaseXdim = intBaseSqr * 6;
   	    }
        myVsoPage.PageSheet.CellsSRC(intVisSectionObject, intVisRowPage, intVisPageWidth).FormulaU = intBaseXdim + " in";
        myVsoPage.PageSheet.CellsSRC(intVisSectionObject, intVisRowPage, intVisPageHeight).FormulaU = intBaseYdim + " in";
        myVsoPage.PageSheet.CellsSRC(intVisSectionObject, intVisRowPage, intVisPageDrawSizeType).FormulaU = "1";
    }
    
    
    /* ****************************************************************************
    returns and integer that is a count of the characters in the longest line
    of the entire string, or in other words the largest number or characters
    in a string segment between \n chars
    **************************************************************************** */
    function findLongestLineInString(myString)
    {
        if (myString == "")
        {
            return 0;
        }
        var myArray = myString.split("\n");
        var myReturnValue = 0;
        for(var i = 0; i < myArray.length; i++)
        {
             if (myArray[i].length > myReturnValue)
             {
                  myReturnValue = myArray[i].length
             }
        }
        myArray = null;
        return myReturnValue;
    }
    
    function getLastWeeksDate()
    {
        var today = new Date();
        var thisYear = today.getFullYear();
        var thisMonth = today.getMonth();
        var thisDay = today.getDate();
        var returnYear;
        var returnMonth;
        var returnDay;
    
        if(thisDay <= 7)
        {
            if(thisMonth == 0)
            {
                returnYear = thisYear - 1;
                returnMonth = 12;
                returnDay = 31 + thisDay - 7;
            }
            else if(thisYear % 4 == 0 && thisMonth == 2)
            {
                returnYear = thisYear;
                returnMonth = thisMonth;
                returnDay = 29 + thisDay - 7;
            }
            else if(thisMonth == 2)
            {
                returnYear = thisYear;
                returnMonth = thisMonth;
                returnDay = 28 + thisDay - 7;
            }
            else
            {
                returnYear = thisYear;
                returnMonth = thisMonth;
                returnDay = 31 + thisDay - 7;
            }
        }
        else
        {
            returnYear = thisYear;
            returnMonth = thisMonth + 1;
            returnDay = thisDay - 7;
        }
        if(returnMonth < 10)
        {
            returnMonth = "0" + returnMonth.toString();
        }
        if(returnDay < 10)
        {
             returnDay = "0" + returnDay.toString();
        }
        return returnYear.toString() + returnMonth.toString() + returnDay.toString();
    }