Logo

A division of Busted Networks Ltd

home services networking products support contacts hdr-butn-fill.gif (965 bytes)

CALL 01243 553251

home>products>infoshop>bn-backup


Product Name:
Version:
Release Date:
Licence:
System Requirements:


bn-backup.js
3.5
15th February 2008
GNU General Public License V2
Microsoft Windows 2000, 2003
Microsoft Windows SMTP service for mailing
Microsoft ntbackup utility
Microsoft rsm.exe
 

bn-backup help


// ==========================[ File Header ]===================================
// File: bn-backup.js
// Version: 3.5
// Date: 15th February 2008
// Author: David Hewison
// Licence: GNU General Public License V2
//
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
//
//
// Note: Set the number of ntbackup log files in the overwrite cycle to 1.
// Setting in HKCU\Software\Microsoft\NTbackup\Log Files\Log File Count
// Set the script operating parameters in xData()
// Separate backups are done for each set to overcome problems with VSS/2003
// - see Microsoft's Tech note ID: 820852
// Backup name on command line has maximum length of 28 characters
// ===========================[ Variables ]====================================

var fso = new ActiveXObject("Scripting.FileSystemObject");
var FileHandle, ExitStatus=0, BackupStatus=0;
var ForReading = 1, ForWriting = 2, ForAppending = 8;
var EmailBody = "Supplementary information:\n\n";
var NewLabel, Tapedevice;

// ===========================[ Main Program ]=================================

EmailBody += OutlookWarning();

FileHandle = fso.OpenTextFile(IoLogFile(), ForWriting, true);
IoXMLHeader("", true, FileHandle);
IoLog("open", FileHandle);

BackupStatus = BackupStatus | Flag("firstset");
if (!((WScript.Arguments.length>0) && (WScript.Arguments(0).length<29)))
{
NewLabel = BackupLabel("");
BackupStatus += Flag("label");
}
else NewLabel = BackupLabel(WScript.Arguments(0));
if (BackupToDisk() && (xData(4040) == "")) BackupStatus += Flag("disk_path");
IoLogCustomerInfo(FileHandle);
IoXMLDataRaw("open", "System", FileHandle, GetData_TagAttributes("System"))
IoLogHostInfo(FileHandle);
if (BackupToTape() && ContinueBackup(BackupStatus,FileHandle)) Tapedevice = TapeInitialisation(FileHandle);
if ((xData(3121)=="yes") && ContinueBackup(BackupStatus,FileHandle))
{
if (SharePointBackup(FileHandle))
{
EmailBody += GetData_SharepointSize(FileHandle);
}
}
if ((BackupToTape()) && (Tapedevice=="") && ContinueBackup(BackupStatus,FileHandle))
{
if (xData(4034) !="")
{
Tapedevice = TapeInitialisation(FileHandle);
if (Tapedevice=="")
{
EmailBody += "\nError: No tape media found.\n";
BackupStatus += Flag("no_tape");
}
}
else
{
EmailBody += "\nError: No tape device GUID found.\n";
BackupStatus += Flag("no_guid");
}
}
for (i=1;i<5;i++)
{
if (ContinueBackup(BackupStatus,FileHandle))
BackupStatus = BackupRun(Tapedevice, NewLabel, i, BackupStatus, FileHandle);
}
if ((xData(4031) == "yes") && (xData(4030)=="tape"))
{
if (ContinueBackup(BackupStatus,FileHandle) && ((BackupStatus & Flag("firstset"))==0))
Tape_Eject(TapeLabel(Tapedevice, FileHandle), FileHandle);
}
GetData_LogicalDisk(FileHandle);
if (xData(3111) == "yes")
{
EmailBody += "\nExchange mailbox store size: " + GetData_ExchStoreSize("mbx",FileHandle) + " GB\n";
EmailBody += "\nExchange public store size: " + GetData_ExchStoreSize("pub",FileHandle) + " GB\n";
}
IoXMLDataRaw("close", "System", FileHandle, "")


IoLog("close", FileHandle);
FileHandle.Close();
Sleep(5);


if (xData(4024) != "yes") WScript.Quit(ExitStatus);

if (BackupStatus ==0)
{
Email(MyAddr(), xData(4023), xData(3001) + " " + NewLabel + " log", EmailBody, IoLogFile(), ConCatenateFile());
WScript.Quit(BackupStatus);
}
else
{
Email(MyAddr(), xData(4023), xData(3001) + " " + NewLabel + " Failed", EmailBody, IoLogFile(), "");
WScript.Quit(BackupStatus);
}

// ===========================[ functions ]====================================


function GetData_CompName()
{
var strComputer = ".", CompName="";
var objWMIService = GetObject("winmgmts:\\\\" + strComputer + "\\root\\cimv2");
var e = new Enumerator(objWMIService.ExecQuery("Select * from Win32_OperatingSystem","WQL",48));

for (;!e.atEnd();e.moveNext())
{ objItem = e.item();

CompName = objItem.CSName;
}
return(CompName);
}



function GetData_ExchStoreSize( store, LogHandle)
{
var Txt="", Units = "GB", LogF=0x00040000, size=0;

if ((xData(3111) == "yes") && ((store=="mbx") || (store=="pub")))
{
if (store == "mbx")
{
size = FsFileSize(xData(3112), LogHandle) + FsFileSize(xData(3113), LogHandle);
size = NumberConversion(size, "", Units,2);
if (FsLogFlag(LogF))
{
IoXMLDataRaw("open", "MSExchangeIS", LogHandle, GetData_TagAttributes("GetData_MSExchangeIS"));
IoXMLData("Store", "mailbox", LogHandle);
IoXMLData("dBFile", xData(3112), LogHandle);
IoXMLData("StmFile", xData(3113), LogHandle);
IoXMLData("Size", size, LogHandle);
IoXMLData("Units", Units, LogHandle);
IoXMLDataRaw("close", "MSExchangeIS", LogHandle, "");
}
}
if (store == "pub")
{
size = FsFileSize(xData(3114), LogHandle) + FsFileSize(xData(3115), LogHandle);
size = NumberConversion(size, "", Units,2);
if (FsLogFlag(LogF))
{
IoXMLDataRaw("open", "MSExchangeIS", LogHandle, GetData_TagAttributes("GetData_MSExchangeIS"));
IoXMLData("Store", "public", LogHandle);
IoXMLData("dBFile", xData(3114), LogHandle);
IoXMLData("StmFile", xData(3115), LogHandle);
IoXMLData("Size", size, LogHandle);
IoXMLData("Units", Units, LogHandle);
IoXMLDataRaw("close", "MSExchangeIS", LogHandle, "");
}
}
}
return(size);
}



function GetData_LogicalDisk(LogHandle)
{
var strComputer = ".", Units = "GB",LogF=0x00040000;
var objWMIService = GetObject("winmgmts:\\\\" + strComputer + "\\root\\cimv2");
var e = new Enumerator(objWMIService.ExecQuery("Select * from Win32_LogicalDisk","WQL",48));
if (FsLogFlag(LogF))
{
for (;!e.atEnd();e.moveNext())
{ objItem = e.item();
if (objItem.DriveType == 3)
{
IoXMLDataRaw("open", "LogicalDisk", LogHandle, GetData_TagAttributes("LogicalDisk"));
IoXMLData("DiskDrive", objItem.DeviceID, LogHandle);
IoXMLData("Description", objItem.Description, LogHandle);
IoXMLData("FileSystem", objItem.FileSystem, LogHandle);
IoXMLData("FreeSpace", NumberConversion(objItem.FreeSpace, "", Units,2), LogHandle);
IoXMLData("TotalSize", NumberConversion(objItem.Size, "", Units,2), LogHandle);
IoXMLData("Units", Units, LogHandle);
IoXMLData("VolumeName", objItem.VolumeName, LogHandle);
IoXMLDataRaw("close", "LogicalDisk", LogHandle, "");
}
}
}
return(0);
}



function GetData_OS(LogHandle)
{
var strComputer = ".",LogF=0x20000;
var objWMIService = GetObject("winmgmts:\\\\" + strComputer + "\\root\\cimv2");
var e = new Enumerator(objWMIService.ExecQuery("Select * from Win32_OperatingSystem","WQL",48));
if (FsLogFlag(LogF))
{
for (;!e.atEnd();e.moveNext())
{ objItem = e.item();
IoXMLDataRaw("open", "SystemSummary", LogHandle, GetData_TagAttributes("OS_Data"));
IoXMLData("Organisation", objItem.Organization, LogHandle);
IoXMLData("HostName", objItem.CSName, LogHandle);
IoXMLData("OS", objItem.Caption, LogHandle);
IoXMLData("Version", objItem.Version, LogHandle);
IoXMLData("ServicePack", objItem.CSDVersion, LogHandle);
//IoXMLData("SerialNumber", objItem.SerialNumber, LogHandle);
//IoXMLData("MaxPageFile", objItem.TotalVirtualMemorySize, LogHandle);
//IoXMLData("MemorySize", objItem.TotalVisibleMemorySize, LogHandle);
//IoXMLData("FreeMemory", objItem.FreePhysicalMemory, LogHandle);
//IoXMLData("LastBootUpTime", objItem.LastBootUpTime, LogHandle);
//IoXMLData("DateTime", objItem.LocalDateTime, LogHandle);
IoXMLDataRaw("close", "SystemSummary", LogHandle, "");
}
}
return(0);
}



function GetData_SharepointSize(LogHandle)
{
var Txt, Units="MB";
if (xData(3121) == "yes")
{
IoLogEvent("open", LogHandle, "");
Txt = "Size of sharepoint backup file is ";
Txt += NumberConversion( FsFileSize(xData(3123), LogHandle), "", Units, 2);
Txt += " " + Units + ".\n";
IoLogEvent("content", FileHandle, Txt);
IoLogEvent("close", LogHandle, "");
}
return(Txt);
}



function GetData_TagAttributes(SrcTxt)
{
var oTxt="";
oTxt += "date=\""+DateInfo()+"\"";
oTxt += " time=\""+TimeInfo()+"\"";
oTxt += " type=\"information\" source=\"GetData_"+SrcTxt+"\"";
oTxt += " category=\"none\" id=\"0\"";
return(oTxt);
}



function GetData_TapeDrive(LogHandle)
{
var objWMIService = GetObject("winmgmts:\\\\.\\root\\cimv2");
var tape0="";
var e = new Enumerator(objWMIService.ExecQuery("Select * from Win32_TapeDrive","WQL",48));
for (;!e.atEnd();e.moveNext())
{
objItem = e.item();
IoXMLDataRaw("open", "Tape_Drives", LogHandle, GetData_TagAttributes("Tape_Drives"));
IoXMLData("Name", objItem.Name, LogHandle);
if (tape0=="") tape0=objItem.Name;
IoXMLData("Description", objItem.Description, LogHandle);
IoXMLData("Manufacturer", objItem.Manufacturer, LogHandle);
IoXMLData("Status", objItem.Status, LogHandle);
if (objItem.NeedsCleaning) IoXMLData("Cleaning", "Drive needs cleaning", LogHandle);
switch (objItem.Availability)
{
case 0x3: IoXMLData("Availability", "Running/Full Power", LogHandle);
break;
case 0x4: IoXMLData("Availability", "Warning", LogHandle);
break;
case 0x5: IoXMLData("Availability", "In Test", LogHandle);
break;
case 0x7: IoXMLData("Availability", "Power Off", LogHandle);
break;
case 0x8: IoXMLData("Availability", "Offline", LogHandle);
break;
case 0x9: IoXMLData("Availability", "Off duty", LogHandle);
break;
case 0xA: IoXMLData("Availability", "Degraded", LogHandle);
break;
default: IoXMLData("Availability", "Unknown", LogHandle);
break;
}
switch (objItem.Capabilities[0])
{
case 0x1: IoXMLData("Capabilities", "Other", LogHandle);
break;
case 0x2: IoXMLData("Capabilities", "Sequential Access", LogHandle);
break;
case 0x3: IoXMLData("Capabilities", "Random Access", LogHandle);
break;
case 0x4: IoXMLData("Capabilities", "Supports Writing", LogHandle);
break;
default: IoXMLData("Capabilities","Unknown", LogHandle);
break;
}
if (objItem.Compression) IoXMLData("Compression", "Hardware compression is enabled", LogHandle);
IoXMLDataRaw("close", "Tape_Drives", LogHandle, "");
}
return(tape0);
}



function GetTempPath(os)
{
var wsh;
wsh = WScript.CreateObject("WScript.Shell").environment;
return(wsh("TEMP"));
}



// ============================================================================
// JScript Library module: email functions
// Author: David Hewison
// Version: 2007.02.07.01
//
// ===========================[ functions ]====================================


// [Email Library]

function Email(From, To, Subject, BodyText, AttachFile1, AttachFile2)
{
var objEmail = new ActiveXObject("CDO.Message");
objEmail.From = From;
objEmail.To = To;
objEmail.Subject = Subject;
objEmail.TextBody = BodyText;
if (AttachFile1 != "") objEmail.AddAttachment(AttachFile1);
if (AttachFile2 != "") objEmail.AddAttachment(AttachFile2);
objEmail.Send();
return(0);
}



function MyAddr()
{
return(xData(4021));
}



function OutlookWarning()
{
var msg="";
msg += "The attached log file bn-backup.xml will not open correctly inside Microsoft Outlook ";
msg += "(see Microsoft Q303487).";
msg += "If you are using Microsoft Outlook you must save the attached logfile to disk first ";
msg += "and open it from there.\n\n";
return(msg);
}



// ============================================================================
// JScript Library module: filesystem functions
// Author: David Hewison
// Version: 2007.02.07.01
// ===========================[ functions ]====================================


// [ FileSystem Library]

function FsCheckFileExists(FileName, LogHandle)
{
var ExitCode, LogF=0x2;
if (FsLogFlag(LogF)) IoLogEvent("open", LogHandle, "FsCheckFileExists");
var fso = new ActiveXObject("Scripting.FileSystemObject");
ExitCode = fso.FileExists(FileName)
if (FsLogFlag(LogF))
{
if (ExitCode) IoLogEvent("content", LogHandle, FileName +" does exist\n");
else IoLogEvent("content", LogHandle, FileName +" was not found\n");
IoLogEvent("close",LogHandle,"");
}
return(ExitCode);
}



function FsCheckFolderExists(FolderName, LogHandle)
{
var ExitCode, LogF=0x200;
if (FsLogFlag(LogF)) IoLogEvent("open", LogHandle, "");
var fso = new ActiveXObject("Scripting.FileSystemObject");
ExitCode = fso.FolderExists(FolderName)
if (FsLogFlag(LogF))
{
if (ExitCode) IoLogEvent("content", LogHandle, "FsCheckFolderExists success: " + FolderName +"\n");
else IoLogEvent("content", LogHandle, "FsCheckFolderExists fail: " + FolderName +"\n");
IoLogEvent("close",LogHandle,"");
}
return(ExitCode);
}



function FsFileCreate(FileName, LogHandle, Overwrite, Unicode)
{
var f, fso, LogF=0x1;

if ((FsCheckFileExists(FileName, LogHandle) && Overwrite) || (!FsCheckFileExists(FileName, LogHandle)))
{
if (FsLogFlag(LogF)) IoLogEvent("open", LogHandle, "");
fso = new ActiveXObject("Scripting.FileSystemObject");
f = fso.CreateTextFile(FileName, Overwrite, Unicode);
f.Close();
if (FsLogFlag(LogF))
{
IoLogEvent("content", LogHandle, "FsFileCreate: " + FileName +"\n");
IoLogEvent("close",LogHandle,"");
}
return(0);
}
else return(1);
}



function FsFileDelete(FileName, LogHandle)
{
var f, fso, LogF=0x8;

if (FsCheckFileExists(FileName, LogHandle))
{
if (FsLogFlag(LogF)) IoLogEvent("open", LogHandle, "");
fso = new ActiveXObject("Scripting.FileSystemObject");
f = fso.Getfile(FileName);
f.Delete();
if (FsLogFlag(LogF))
{
IoLogEvent("content", LogHandle, "FsFileDelete: " + FileName +"\n");
IoLogEvent("close",LogHandle,"");
}
return(0);
}
else return(1);
}


function FsFileSize(FileName, LogHandle)
{
var fso, s, o;
fso = new ActiveXObject("Scripting.FileSystemObject");
o = fso.GetFile(FileName);
if (FsCheckFileExists(o, LogHandle))
s = o.size;
else
s = -1;
return(s);
}



function FsFileWrite(FileName, LogHandle, Unicode, text)
{
var f, fso, LogF=0x10;

if (FsCheckFileExists(FileName, LogHandle))
{
if (FsLogFlag(LogF)) IoLogEvent("open", LogHandle, "");
fso = new ActiveXObject("Scripting.FileSystemObject");
f = fso.OpenTextFile(FileName, 2, false, Unicode);
f.Write(text);
f.Close();
if (FsLogFlag(LogF))
{
IoLogEvent("content", LogHandle, "FsFileWrite: " + FileName +"\n");
IoLogEvent("close",LogHandle,"");
}
return(0);
}
else return(1);
}



function FsFolderCopy(SrcPath, DestPath, LogHandle)
{
var LogF=0x400;
if (FsLogFlag(LogF)) IoLogEvent("open", LogHandle, "");
fso = new ActiveXObject("Scripting.FileSystemObject");
fso.CopyFolder(SrcPath, DestPath)
if (FsLogFlag(LogF))
{
IoLogEvent("content", LogHandle, "FsFolderCopy: " + SrcPath + " to " + DestPath + "\n");
IoLogEvent("close",LogHandle,"");
}
return(0);
}


function FsFolderCreate(Path, LogHandle)
{
var fso, a, LogF=0x100;
if (FsLogFlag(LogF)) IoLogEvent("open", LogHandle, "");
fso = new ActiveXObject("Scripting.FileSystemObject");
if (fso.FolderExists(Path)) return(0);
a = fso.CreateFolder(Path);
if (FsLogFlag(LogF))
{
IoLogEvent("content", LogHandle, "FsFolderCreate: " + Path +"\n");
IoLogEvent("close",LogHandle,"");
}
return(0);
}




function FsFolderListing(Path)
{

var fso, f, f1, fc, s;
fso = new ActiveXObject("Scripting.FileSystemObject");
f = fso.GetFolder(Path);
fc = new Enumerator(f.files);
s = "";
for (; !fc.atEnd(); fc.moveNext())
{
s += fc.item() + "\n";
}
return(s);
}





function FsGetTempPath(LogHandle)
{
var wsh, LogF=0x1000,v="";
wsh = WScript.CreateObject("WScript.Shell").environment;
v = wsh("TEMP");
if (FsLogFlag(LogF)) IoLogEvent("open", LogHandle, "");
if (FsLogFlag(LogF))
{
IoLogEvent("content", LogHandle, "Var TEMP: " + v +"\n");
IoLogEvent("close",LogHandle,"");
}
return(v);
}



function FsGetScriptPath(LogHandle)
{
var p, LogF=0x2000;
if (FsLogFlag(LogF)) IoLogEvent("open", LogHandle, "");
p = WScript.ScriptFullName.substring(0,WScript.ScriptFullName.length - WScript.ScriptName.length);
if (FsLogFlag(LogF))
{
IoLogEvent("content", LogHandle, "Script Path: " + p +"\n");
IoLogEvent("close",LogHandle,"");
}
return(p);
}



function FsLogFlag(flag)
{
if ((xData(1001) & flag) == flag)
{
return(true);
}
else
{
return(false);
}
}



function FsObjectSize(Obj, LogHandle)
{
var fso, s;
fso = new ActiveXObject("Scripting.FileSystemObject");
if ((FsCheckFileExists(Obj, LogHandle)) || (FsCheckFolderExists(Obj, LogHandle)))
s = fso.size;
else
s = -1;
return(s);
}



function FsRegistryWriteKey(Key, LogHandle)
{
var WshShell = WScript.CreateObject("WScript.Shell");
IoLogEvent("open", LogHandle, "");
IoLogEvent("content", LogHandle, "Adding registry key: " + Key + "\n");
WshShell.RegWrite( Key, 1, "REG_BINARY");
IoLogEvent("close", LogHandle, "");
return(0);
}



function FsRegistryWriteValue(Value, Type, Content, LogHandle)
{
// Permissible Types are: REG_SZ, REG_DWORD, REG_BINARY

var WshShell = WScript.CreateObject("WScript.Shell");
IoLogEvent("open", LogHandle, "");
IoLogEvent("content", LogHandle, "Adding registry value: " + Value + "\n");
IoLogEvent("content", LogHandle, " - value type: " + Type + "\n");
IoLogEvent("content", LogHandle, " - value content: " + Content + "\n");
WshShell.RegWrite(Value, Content, Type);
IoLogEvent("close", LogHandle, "");
return(0)
}



function FsRunExtProg(Prog, Synchronously, LogHandle)
{
var LogF=0x4000, Result;
var WshShell = new ActiveXObject("WScript.Shell");
var Process = WshShell.Exec(Prog);
if (FsLogFlag(LogF))
{
IoLogEvent("open", LogHandle, "Process_spawing");
if (!Synchronously)
IoLogEvent("content", LogHandle, "Spawning asynchronously: " + Prog +"\n");
else
IoLogEvent("content", LogHandle, "Spawning synchronously: " + Prog +"\n");
IoLogEvent("close",LogHandle,"");

}
if (!Synchronously)
{
return(0);
}
while (!Process.Status)
{
WScript.Sleep(10);
}
Result = Process.ExitCode
if (FsLogFlag(LogF))
{
IoLogEvent("open", LogHandle, "Process_Result");
IoLogEvent("content",LogHandle,Result);
IoLogEvent("close",LogHandle,"");
}
return(Result);
}



function FsScheduleCreate(Name, Command, Arguments, Type, Modifier, Start, LogHandle)
{
var ComStr = "schtasks /create";
ComStr += " /TN \"" + Name + "\"";
ComStr += " /TR \"" + Command + " " + Arguments + "\"";
ComStr += " /SC " + Type + " /MO " + Modifier;
if (Start != "") ComStr += " /ST " + Start;
ComStr += " /S " + xData(5) + " /RU " + xData(8) + " /RP " + xData(9);
IoLogEvent("open", LogHandle, "");
IoLogEvent("content", LogHandle, "Creating scheduler task: " + Name + "\n");
IoLogEvent("content", LogHandle, "Data: " + ComStr + "\n");
RunExtProg("cmd.exe /c " + ComStr, false);
IoLogEvent("close", LogHandle, "");
return(0);
}


function FsReadTempFile()
{
var fs0, fo, fh, Line, tXt="";
var fso = new ActiveXObject("Scripting.FileSystemObject");

fo = fso.GetFile(FsTempFile());
fh = fo.OpenAsTextStream( 1, -2);
while (!fh.AtEndOfStream)
{
Line = fh.ReadLine();
if (Line != "") tXt += " \"" + Line + "\" ";
}
fh.Close();
return(tXt);
}


function FsTempFile()
{
return(xData(1011) + "\\" + xData(4003));
}



// ============================================================================
// JScript Library module
// Author: David Hewison
// Version: 2006.08.26.01
//
// ===========================[ I/O Library ]====================================


function IoAsk(Question)
{
var answer="";
IoConsoleOut(Question);
return(IoConsoleIn());
}



function IoConsoleIn()
{
var fso, h1, TextIn;
fso = WScript.CreateObject("Scripting.FileSystemObject");

h1 = fso.OpenTextFile("con",1, false);
TextIn = h1.ReadLine();
h1.Close();
return(TextIn);
}



function IoConsoleOut(text)
{
var fso, h1;
fso = WScript.CreateObject("Scripting.FileSystemObject");

h2 = fso.OpenTextFile("con",2, true);
h2.Write(text);
h2.Close();
return;
}






function IoLog(mode, LogHandle)
{
if (mode=="open")
{
LogHandle.Write("<bnlog " + IoXMLSchema("bnlog") + ">\n");
}
if (mode=="close")
{
LogHandle.Write("</bnlog>\n");
}
return(0);
}



function IoLogCustomerInfo(LogHandle)
{
IoXMLDataRaw("open", "Customer", LogHandle, "");
IoXMLDataRaw("open", "Name", LogHandle, "");
IoXMLDataRaw("content", "", LogHandle, xData(3001));
IoXMLDataRaw("close", "Name", LogHandle, "");
IoXMLDataRaw("close", "Customer", LogHandle, "");
return(0);
}



function IoLogEvent(mode, LogHandle, Text)
{
if (mode=="open")
{
var Src = xData(1014), oTxt="";
if (Text != "") Src = Text;
oTxt = "<Logevent date=\""+DateInfo()+"\"";
oTxt += " time=\""+TimeInfo()+"\"";
oTxt += " type=\"information\""
oTxt += " source=\"" + Src + "\"";
oTxt += " category=\"none\" id=\"0\">\n";
LogHandle.Write(oTxt);
}
if (mode=="close")
{
var oTxt = "</Logevent>\n";
LogHandle.Write(oTxt);
}
if (mode=="content")
{
var oTxt = Text;
LogHandle.Write(oTxt);
}
return(0);
}




function IoLogFile()
{
return(xData(1011) + "\\" + xData(1012));
}



function IoLogHostInfo(LogHandle)
{
GetData_OS(LogHandle);
return(0);
}



function IoXMLComment(Text)
{
var comment="";
comment += "<!--";
comment += Text;
comment += "-->\n";
return(comment);
}



function IoXMLData( TagName, Content, LogHandle)
{
IoXMLDataRaw( "open", TagName, LogHandle, "");
IoXMLDataRaw( "content", "", LogHandle, Content);
IoXMLDataRaw( "close", TagName, LogHandle, "");
return(0);
}



function IoXMLDataRaw(mode, TagName, LogHandle, Text)
{
if (mode=="open")
{
var oTxt = "\n<" + TagName + " " + Text + ">";
LogHandle.Write(oTxt);
}
if (mode=="close")
{
var oTxt = "\n</" + TagName + ">";
LogHandle.Write(oTxt);
}
if (mode=="content")
{
var oTxt = Text;
LogHandle.Write(oTxt);
}
return(0);
}




function IoXMLHeader(DocType, Standalone, LogHandle)
{
var XMLHeader;
var InlineHeader="<?xml version=\"1.0\" standalone=\"yes\"?>";
var ExtHeader="<?xml version=\"1.0\" standalone=\"no\"?>";
var Style="bnlog";
var DocName = "Logging: " + xData(1) + " " + xData(2) + " \n Code libraries by David Hewison, Infoshop 2000-2008";
var BN="Busted Networks Ltd";
var BNDetails="";
BNDetails += "PO Box 103\nBognor Regis\nWest Sussex\nPO22 0WB\nUK";
BNDetails += "\nWeb: http://www.bustednetworks.com";
BNDetails += "\nEmail: sales@bustednetworks.com";

if (Standalone) XMLHeader = InlineHeader;
else XMLHeader = ExtHeader;
LogHandle.Write(XMLHeader + "\n");
LogHandle.Write( IoXMLStylesheet(Style) );
LogHandle.Write(IoXMLComment(DocName));
LogHandle.Write(IoXMLComment(BN));
LogHandle.Write(IoXMLComment(BNDetails));
return(0);
}



function IoXMLSchema(schema)
{
var xsd="";
switch (schema)
{
case "bnlog": //Schema for Busted Networks Log Files
xsd += "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" ";
xsd += "xsi:noNamespaceSchemaLocation=\"http://www.infoshop.co.uk/xsd/bnlog-schema.xsd\"\n";
break;
default:
break;
}
return(xsd);

}


function IoXMLStylesheet(style)
{
var xsl="";
switch (style)
{
case "bnlog": //Style sheet for Busted Networks Log Files
xsl += "<?xml-stylesheet TYPE='text/xsl' href='http://www.infoshop.co.uk/xsl/bnlogstyle.xsl'?>\n";
break;
default:
break;
}
return(xsl);
}



// ============================================================================
// JScript Library module: Number functions
// Author: David Hewison
// Version: 2007.02.07.01
//
// ===========================[ Num Library ]====================================


function NumberConversion(x,srcUnits,targetUnits, Digits)
{
var y = 1, z = 1;
switch (srcUnits)
{
case "KB": y = 1024;
break;

case "MB": y = 1048576;
break;

case "GB": y = 1073741824;
break;
}
switch (targetUnits)
{
case "KB": z = 1024;
break;

case "MB": z = 1048576;
break;

case "GB": z = 1073741824;
break;
}

return( parseInt(x * (y / z) * Math.pow(10,Digits))/Math.pow(10,Digits) );
}



// ============================================================================
// JScript Library module: rsm interface
// Author: David Hewison
// Version: 2007.02.01.01
//
// ===========================[ rsm library ]====================================


function rsm(Arguments, FileHandle, LoopMax)
{
var i, ExitCode, cmdLine, fh, fo, fso, info;
if (LoopMax>3) LoopMax = 3;
if (LoopMax<1) LoopMax = 1;
for (i=0; i<LoopMax; i++)
{
info = " --result:";
cmdLine = "cmd.exe /C rsm.exe " + Arguments;
TapeLog("append", "\nrsm command: " + cmdLine + "\n Command Output:\n");
IoLogEvent("open", FileHandle, "RSM_Command")
IoLogEvent("content", FileHandle, "\""+ Arguments + "\" \n")
IoLogEvent("close", FileHandle, "")
ExitCode = FsRunExtProg(cmdLine + " > \"" + FsTempFile() + "\"\"", true, FileHandle);
FsRunExtProg("cmd.exe /c type \"" + FsTempFile() + "\" >> \"" + TapeLogFile() + "\"\"", true, FileHandle);
IoLogEvent("open", FileHandle, "RSM_Result");
IoLogEvent("content", FileHandle, FsReadTempFile());
IoLogEvent("close", FileHandle, "");
if (ExitCode==0) i=LoopMax;
else
{
IoLogEvent("open", FileHandle, "RSM_Result");
IoLogEvent("content", FileHandle, "Tape drive not ready, waiting" + xData(4033) + " minutes\n");
IoLogEvent("close", FileHandle, "");
Sleep(xData(4033)*60);
}
}
return(FsReadTempFile());
}



// ============================================================================
// JScript Library module: sharepoint interface
// Author: David Hewison
// Version: 2007.02.01.01
//
// ===========================[ sharepoint library ]============================


function SharePointBackup(LogHandle)
{
var ExitStatus, UtilCmd;
var UtilCmd1 = "-o backup -url " + xData(3124) + " -filename ";
var UtilCmd2 = " -overwrite";
UtilCmd = UtilCmd1 + xData(3123) + UtilCmd2;

if (xData(3121)=="yes")
{
ExitStatus = FsRunExtProg("cmd.exe. /c " + xData(3122) + " " + UtilCmd, true, LogHandle)
IoLogEvent("open", LogHandle, "");
if (ExitStatus==0) IoLogEvent("content", LogHandle, "Sharepoint backed up to disk successfully\n");
else IoLogEvent("content", LogHandle, "Sharepoint backup returned error code " + ExitStatus + "\n");
IoLogEvent("close", LogHandle, "");
}
return((ExitStatus==0));
}



// ============================================================================
// JScript Library module: string handling functions
// Author: David Hewison
// Version: 2006.04.26.01
//
// ===========================[ functions ]====================================


// [String Library]

function StrNumToStr(Number, Length)
{
var Index = "";
Index = Number.toString();
while (Index.length<Length) Index = "0"+Index;
return(Index);
}


function StrIdxStr(Number, Length)
{
var Index = "";
Index = Number.toString();
while (Index.length<Length) Index = "0"+Index;
return(Index);
}


// ============================================================================
// JScript Library module: tape and backup functions
// Author: David Hewison
// Version: 2007.02.07.01
//
// ===========================[ functions ]====================================


function Backup( BkUpCommand, FileHandle)
{
var ExitCode=0, BkUpUtil;
BkUpUtil = BackUpUtil();
if (!FsCheckFileExists(BkUpUtil, FileHandle))
{
IoLogEvent("open", FileHandle, "Backup");
IoLogEvent("content", FileHandle, "Could not find: "+ BkUpUtil + "\n");
IoLogEvent("close", FileHandle, "");
ExitCode = 1;
}
else
{
IoLogEvent("open", FileHandle, "Backup");
IoLogEvent("content", FileHandle," Starting with options: " + BkUpCommand + "\n");
IoLogEvent("close", FileHandle, "");
ExitCode = FsRunExtProg("\""+BkUpUtil + "\" " + BkUpCommand, true, FileHandle);
IoLogEvent("open", FileHandle, "Backup_Result");
IoLogEvent("content", FileHandle, ExitCode);
IoLogEvent("close", FileHandle, "");
}
return(ExitCode);
}



function BackupArgs(Name, SetLoc, overwrite)
{
var Label = "", Command = "", SetName="",i;
for(i=1 ; i<5 ; i++)
{
if (BackUpSet(i)==SetLoc) SetName = "-" + i;
}
Label = "\"" + Name + "\"";
Command = "backup " + "\"" + SetLoc + "\"";
Command += " /L:s /V:" + xData(4038) + " /R:no /RS:no /HC:" + xData(4035) + " /SNAP:" + xData(4037);
Command += " /M normal /D " + Label + " /J " + Label;
if (BackupToTape())
{
if (overwrite)
Command += " /N " + Label + " /P \"" + xData(4032) + "\" /UM";
else
Command += " /T " + Label + " /A";
}
if (BackupToDisk())
{
Command += " /N " + Label + " /f \"" + xData(4040) + "\\" + TimeStr().substr(0,8) + SetName + ".bkf\""
}
return(Command);
}



function BackupLabel(text)
{
var label="";
if (text != "") text = " " + text + " ";
else text =" ";
label = GetData_CompName() + text + TimeStr().substr(0,8) + " Backup";
return(label);
}



function BackUpSet(n)
{
var x;
switch (n)
{
case 1: x=xData(4051);
break;
case 2: x=xData(4052);
break;
case 3: x=xData(4053);
break;
case 4: x=xData(4054);
break;
default:
x="";
break;
}
return(x);
}



function BackupToDisk()
{
if (xData(4030)=="disk") return(true);
else return(false);
}



function BackupToTape()
{
if (xData(4030)=="tape") return(true);
else return(false);
}



function BackUpUtil()
{
return(xData(4002));

}



function BackupRun(TapeDevice, NewLabel, Set, BackupStatus, LogHandle)
{
var CurrentLabel, Status=BackupStatus, FirstSet, ExitCode;

if (BackUpSet(Set) == "") return(BackupStatus);

FirstSet = (BackupStatus & Flag("firstset")) == Flag("firstset");
if (BackupToTape()) CurrentLabel = TapeLabel(TapeDevice, LogHandle);
if (BackupToDisk() || (BackupToTape() && (CurrentLabel !="")))
{
ExitCode = Backup(BackupArgs(NewLabel, BackUpSet(Set), FirstSet), LogHandle);
ConCatenateLogs(FirstSet, LogHandle);
Status = Status & (~ Flag("firstset"));
if (ExitCode != 0) Status = (Flag("results") << (Set-1)) | Status;
}
else Status = (Status & (~ Flag("firstset")) ) | (Flag("results") << (Set-1));
return(Status);
}



function ConCatenateFile()
{
return(xData(1011) + "\\" + xData(4005));
}



function ConCatenateLogs(mode, FileHandle)
{
IoLogEvent("open", FileHandle, "");
if (mode)
{
FileHandle.Write("Creating log - " + ConCatenateFile() + "\n");
command = "cmd.exe /c type \"" + xData(4006) + "\" > \"" + ConCatenateFile() + "\"";
}
else
{
FileHandle.Write("Appending to " + ConCatenateFile() + "\n");
command = "cmd.exe /c type \"" + xData(4006) + "\" >> \"" + ConCatenateFile() + "\"";
}
IoLogEvent("close", FileHandle, "");
FsRunExtProg(command , true, FileHandle);
return(0);
}



function ContinueBackup(CurrentStatus, FileHandle)
{
var Abort=0, LogF=0x10000000;
Abort = CurrentStatus & xData(4026);

if (FsLogFlag(LogF))
{
IoLogEvent("open", FileHandle, "exception_check");
IoLogEvent("content", FileHandle, "exception status code: " + Abort);
IoLogEvent("close", FileHandle, "");
}
return((Abort==0));
}



function Flag(which)
{
var answer;

switch (which)
{
case "label": //Command line label parameter
answer = 0x1;
break;

case "no_tape": // Tape not available
answer = 0x2;
break;

case "no_guid": //tape drive GUID not specified
answer = 0x4;
break;

case "disk_path": //path for backup-to-disk available
answer = 0x8
break;

case "firstset": //the first backup set has not been done yet
answer = 0x10;
break;

case "results": //base for pass fail flags for each set
answer = 0x100;
break;

default:
answer = 0;
break;
}
return(answer);
}



function Tape_Eject(MediaName, LogHandle)
{
rsm("eject /pf\"" + MediaName + "\" /astart", LogHandle, 1);
}



function TapeInitialisation(LogHandle)
{
var Device="";
if (xData(4034)=="") return(Device);
TapeLog("create", "Busted Networks Ltd. Tape Log " + TimeStr().substr(0,8) + "\n");
Device = GetData_TapeDrive(LogHandle);
if (Device=="") return(Device);
if (TapeLabel(Device, LogHandle)=="") Device="";
return(Device);
}



function TapeLabel(Drive, LogHandle)
{
var result="", i, tempstr="";
if (xData(4030)!="tape") return(1);
Tape_PollDrive(LogHandle);
result = rsm("view /tphysical_media /cg" + xData(4034), LogHandle, 1);
for(i=0;i<result.length;i++)
{
tempstr="";
while ( (result.substr(i,1)!="\"") && (i<result.length) ) i++;
i++;
while ( (result.substr(i,1)!="\"") && (i<result.length) )
{
tempstr += result.substr(i,1);
i++;
}
i++;
switch (tempstr)
{
case "PHYSICAL_MEDIA": tempstr=""; break;
case "The command completed successfully.": tempstr=""; break;
default:
i = result.length;
break;
}
}
return(tempstr);
}



function TapeLog(mode, data)
{
var fso = new ActiveXObject("Scripting.FileSystemObject");
var ForReading = 1, ForWriting = 2, ForAppending = 8, f;
switch (mode)
{
case "create":
f = fso.OpenTextFile(TapeLogFile(), ForWriting, true);
break;
case "append":
f = fso.OpenTextFile(TapeLogFile(), ForAppending, true);
break;
default:
return(1);
}
f.Write(data);
f.Close();
return(0);
}



function TapeLogFile()
{
return(xData(1011) + "\\" + xData(4004));
}



function Tape_PollDrive(LogHandle)
{
var result="", i=0, tempstr="";
if (xData(4030)!="tape") return("");
rsm("refresh /lg\""+ xData(4034) + "\"", LogHandle, 1);
tempstr="";
while ( (result.substr(i,1)!="\"") && (i<result.length) ) i++;
i++;
while ( (result.substr(i,1)!="\"") && (i<result.length) )
{
tempstr += result.substr(i,1);
i++;
}
i++;
Sleep(xData(4033)*60);
return(tempstr);
}



// ============================================================================
// JScript Library module: time and date functions
// Author: David Hewison
// Version: 2007.02.01.01
//
// ===========================[ functions ]====================================


// [TimeDate Library]

function DateInfo()
{
var Today, year, month, day, wsh, datestr;
Today = new Date();
wsh = WScript.createObject("WScript.Shell");

day = Today.getDate();
month = Today.getMonth()+1;
year = Today.getYear();
datestr = StrNumToStr(year.toString(),4) + "-" + StrNumToStr(month.toString(),2) + "-" + StrNumToStr(day.toString(),2);
return(datestr);
}




function Sleep(seconds)
{
WScript.Sleep(seconds * 1000);
return(0);
}




function TimeInfo()
{
var Today, wsh, timestr;
Today = new Date();
wsh = WScript.createObject("WScript.Shell");

timestr = StrNumToStr(Today.getHours(),2) + ":" + StrNumToStr(Today.getMinutes(),2) + ":" + StrNumToStr(Today.getSeconds(),2);
return(timestr);
}



function TimeStr()
{
var Today, year, month, day, hours, mins, secs, wsh, timestr;
Today = new Date();
wsh = WScript.createObject("WScript.Shell");

secs = StrIdxStr(Today.getSeconds(),2);
mins = StrIdxStr(Today.getMinutes(),2);
hours = StrIdxStr(Today.getHours(),2);
day = StrIdxStr(Today.getDate(),2);
month = StrIdxStr((Today.getMonth() +1),2);
year = Today.getFullYear().toString();
timestr = year + month + day + hours + mins + secs;
return(timestr);
}



// ============================================================================
// JScript Library module: xData
// Author: David Hewison
// Version: 2006.08.16.01
// Notes:
// This area is for the script configuration parameters.
// Configure your requiremets by modifying the answer lines.
//
// ===========================[ functions ]====================================

function xData(which)
{
var answer;
switch (which)
{

case 1: // Script label
answer = "bn-backup";
break;

case 2: // script version
answer = "3.41";
break;

// ----------[ Logging data]-------------------------------------------

case 1001: // Logging flags
answer = 0x0FFFBFF0;
break;

case 1011: // Log File Path
answer = "D:\\Logs";
break;

case 1012: // Log File Name
answer = "bn-backup.xml";
break;

case 1014: // Log Event Information Name
answer = "bn-backup";
break;

// ----------[ This System's exisiting configuration ] ----------------


case 2013: // This system's name
answer = GetData_CompName();
break;

case 2014: // This system's OS
answer = GetData_OS();
break;

// ----------[ Customer Data ]-----------------------------------------

case 3001: // Customer Company name
answer = "Customer";
break;

// --------[ Application data ]--------------------------------------

case 3111: // Is this an Exchange server (yes/no) ?
answer = "no";
break;

case 3112: // Exchange mailbox store rich text dB filename including full path
answer = "c:\\program Files\\Exchsrvr\\mdbdata\\priv1.edb";
break;

case 3113: // Exchange mailbox store streaming dB filename including full path
answer = "c:\\program Files\\Exchsrvr\\mdbdata\\priv1.stm";
break;

case 3114: // Exchange public store rich text dB filename including full path
answer = "c:\\program Files\\Exchsrvr\\mdbdata\\pub1.edb";
break;

case 3115: // Exchange public store streaming dB filename including full path
answer = "c:\\program Files\\Exchsrvr\\mdbdata\\pub1.stm";
break;

case 3121: // Is this a Sharepoint server (yes/no) ?
answer = "no";
break;

case 3122: // STS Admin utility path
answer = "\"C:\\Program Files\\Common Files\\Microsoft Shared\\web server extensions\\60\\BIN\\stsadm.exe\"";
break;

case 3123: //STS backup file with full path
answer = "d:\\admin\\backup\\STS\\sitebackup.dat";
break;

case 3124: //STS site url
answer = "http://companyweb/";
break;

case 3131: //Is this a SQL server
answer = "no";
break;

case 3140: //Name of SQL Server Instance 1
answer = "";
break;

case 3141: //Name of SQL Instance 1\database1
answer = "model";
break;

case 3142: //Name of SQL Instance 1\database2
answer = "";
break;

case 3143: //Name of SQL Instance 1\database3
answer = "";
break;

case 3144: //Name of SQL Instance 1\database4
answer = "";
break;

case 3145: //Name of SQL Instance 1\database5
answer = "";
break;

case 3146: //Name of SQL Instance 1\database6
answer = "";
break;

case 3147: //Name of SQL Instance 1\database7
answer = "";
break;

case 3148: //Name of SQL Instance 1\database8
answer = "";
break;

case 3149: //Name of SQL Instance 1\database9
answer = "";
break;

// ----------[ Backup Data ]-----------------------------------------------

case 4002: // Backup utility location
answer = "C:\\windows\\system32\\ntbackup.exe";
break;

case 4003: // Temporary work file
answer = "bn-temp.log";
break;

case 4004: // Tape utility log
answer = "bn-tape.log";
break;

case 4005: // Concatenation file for multiple logs
answer = "bn-backup.log";
break;

case 4006: // Backup program's logfile location
answer = "C:\\Documents and Settings\\";
answer += xData(4007);
answer += "\\Local Settings\\Application Data\\Microsoft";
answer += "\\Windows NT\\NTbackup\\Data\\backup01.log";
break;

case 4007: // Backup user profile folder name
answer = "administrator";
break;

case 4021: // This script's email address
answer = "bn-backup." + GetData_CompName() + "@" + xData(4022);
break;

case 4022: // Public DNS domain
answer = "domain.co.uk";
break;

case 4023: // Service monitor email address
answer = "sys-alerts@" + xData(4022);
break;

case 4024: //Enable email (yes/no)?
answer = "yes";
break;

case 4026: // Abort flags
answer = (Flag("results") * 0xF) | Flag("no_tape") | Flag("no_guid") | Flag("disk_path");
break;

case 4030: // Backup device? Currently supports 'tape' or 'disk'
answer = "tape";
break;

case 4031: // Eject tape after backup?
answer = "yes";
break;

case 4032: // Media Pool to use
answer = "LTO Ultrium";
break;

case 4033: // Tape drive settling time in minutes
answer = 1;
break;

case 4034: //Tape drive to use specified by its rsm GUID
// -to find the rsm GUID use: rsm view /tlibrary /guiddisplay
answer = "";
break;

case 4035: //Enable (on) or disable (off) hardware compression
answer = "on";
break;

case 4037: //Enable (on) or disable (off) shadow copying
answer = "on";
break;

case 4038: //Verify after backup (yes/no)?
answer = "yes";
break;

case 4040: //Destination for disk based backups
answer = "";
break;

case 4041: //Disk folder for temporary sql backup files
answer = "";
break;

case 4051: // backup set 1
answer = "@D:\\admin\\backup\\drive-c.bks";
break;

case 4052: // backup set 2
answer = "@D:\\admin\\backup\\drive-d.bks";
break;

case 4053: // backup set 3
answer = "@D:\\admin\\backup\\exchange.bks";
break;

case 4054: // backup set 4
answer = "@D:\\admin\\backup\\systemstate.bks";
break;

default:
answer = "";
break;
}
return(answer);
}
 

 

Registered as Busted Networks Limited in England and Wales as Company Number 3745185
Registered office Busted Networks Limited, The Victoria, 25 St. Pancras, Chichester, West Sussex, PO19 7LT
VAT registration number 787 5689 46

(c) InfoShop 2000-2013