Australian Personal Computer 2004 July/APC0407D1.iso/powerkit/firewall/files/NPF2004.exe/Setup/ISCommon/APP/fwUI.dll/HTML/PORTS.JS

JavaScript | 2003-09-06 | 7.9 KB | 285 lines

////////////////////////////////////////////////////////////////////////////////////////////
//
// PRODUCT: Norton Internet Security/Symantec Desktop Firewall
//
// NAME:    ports.js
//
// Copyright (c) 2001 by Symantec Corporation. All rights reserved.
//
////////////////////////////////////////////////////////////////////////////////////////////

//******************************************************************************************
//******************************************************************************************
//
//                          HELPERS FOR PORTS XML CODE
//
//******************************************************************************************
//******************************************************************************************

function addPort(xml, port)
{
    return ("" != findPort(xml, port, true));
}

function portExists(xml, port)
{
    return ("" != findPort(xml, port, false));
}

//
// Indicates whether port exists and whether its in a range.
//
function portExistsInRange(xml, port)
{
    return findPort(xml, port, false);
}

function getPortStr(port, bICMP)
{
    var retStr = "";
    var separ = StrID("port_separator");
    var openParen = StrID("port_openparen");
    var closeParen = StrID("port_closeparen");

    var knownPorts = new ActiveXObject("Microsoft.XMLDOM");
    knownPorts.load(bICMP?"res://fwui.dll/ICMP-services.xml":"res://fwui.dll/services.xml");

    //**TODO: Need JavaScript equivalent to sprintf to make localization easier.
    //
    // Determine if this is a single port or port range.
    //
    if (1 == port.Type)
    {
        //
        // It's a port range.
        //
        retStr = StrID(bICMP?"commands":"ports") + " " + port.RangeStart + StrID("dash_for_range") + port.RangeEnd;
    }
    else
    {
        //
        // It's a single port.
        //

        //
        // Find a friendly name, if any, for the port.
        //
        var friendlyName = knownPorts.selectSingleNode("/*/port[value=" + port.PortNum + "]");
        if (null != friendlyName)
        {
            //
            // Format for friendly name: "ftp-data (port 21)"
            //
            retStr = friendlyName.selectSingleNode("name").nodeTypedValue;
            retStr += " " + openParen + StrID(bICMP?"command":"port") + " " + port.PortNum + closeParen;
        }
        else
        {
            //
            // Format for unfriendly name: "port 21"
            //
            retStr = StrID(bICMP?"command":"port") + " " + port.PortNum;
        }
    }

    return retStr;
}

function getGenericServicesStr(rule)
{

    var services;
    var locPorts = rule.LocalPorts;
    var remPorts = rule.RemotePorts;

    if ((0 == locPorts.ItemCount) && (0 == remPorts.ItemCount))
        services = StrID("genericport_any");
    else
        services = StrID("genericport_specific");

    return services;

}

//******************************************************************************************
//                PRIVATES/IMPLEMENTATION: HELPERS FOR PORTS XML CODE
//******************************************************************************************

function findPort(xml, port, bUpdate)
{
    //
    // Determine if this is a single port or port range.
    //
    var aPort = port.toString().split(":");
    var bRange = (1 < aPort.length);

    if (bRange)
    {
        newStartPort = aPort[0];
        newEndPort = aPort[1];
    }
    else
    {
        newStartPort = port.toString();
        newEndPort = port.toString();
    }

    //
    // Check to ensure port/range doesn't already exist.
    //
    var ports = xml.selectNodes("Port|PortRange");
    var found = "";
    for (var nElem; ports.length > nElem; nElem++)
    {
        //
        // Determine if this node is a single port or port range.
        //
        if ("PORTRANGE" == ports[nElem].nodeName.toUpperCase())
        {
            //
            // Yup, its a range.
            //
            var aRange = ports[nElem].nodeTypedValue.split(":");
            startPort = aRange[0];
            endPort = aRange[1];
            bNodeIsRange = true;
        }
        else
        {
            //
            // Single port. Check for match
            //
            endPort = startPort = ports[nElem].nodeTypedValue;
            bNodeIsRange = false;
        }

        //
        // Check for overlap.
        //
        // First, check lower bound of new entry.
        //
        if ((startPort <= newStartPort) && (endPort >= newStartPort))
        {
            //
            // There's overlap, update this node (only if its a range
            // and the new range is larger or lies outside previous range).
            // This update only occurs for PortRange nodes (due to code logic).
            //
            if (bUpdate && (startPort < newEndPort))
                ports[nElem].text = startPort + ":" + newEndPort;

            //
            // Indicate a node already exists so we don't add one.
            //
            if (bNodeIsRange)
                found = "RANGE";
            else
                found = "PORT";
        }
        //
        // Now, check upper bound of new entry.
        //
        else if ((startPort <= newEndPort) && (endPort >= newEndPort))
        {
            //
            // There's overlap, update this node. This update only occurs
            // for PortRange nodes (due to code logic).
            //
            if (bUpdate)
                ports[nElem].text = newStartPort + ":" + endPort;

            //
            // Indicate a node already exists so we don't add one.
            //
            if (bNodeIsRange)
                found = "RANGE";
            else
                found = "PORT";
        }
    }

    //
    // If we didn't find a match, add a new Port/PortRange node.
    //
    if (("" == found) && bUpdate)
    {
        xmlDoc = xml.ownerDocument;
        if (null == xmlDoc)
            xmlDoc = xml;

        if (bRange)
        {
            newNode = xmlDoc.createElement("PortRange");
            newNode.text = newStartPort + ":" + newEndPort;
        }
        else
        {
            newNode = xmlDoc.createElement("Port");
            newNode.text = newStartPort;
        }

        //
        // The following is required to differentiate between document and
        // non-document nodes.
        //
        var appendTo = xml.selectSingleNode(".");
        if (null == xml.ownerDocument)
            appendTo = xml.selectSingleNode("*");
        appendTo.appendChild(newNode);
    }

    return found;
}

// dumbed down edition of add port used because port lists may not include both
// port ranges and port lists.

function addPort_limited(xml, port)
{
    //
    // Determine if this is a single port or port range.
    //
    var aPort = port.toString().split(":");
    var bRange = (1 < aPort.length);
    var ports = null;
    var bFound = false;

    if (bRange)
    {
        var ports = xml.selectNodes("./*");
        for (var nElem=0; nElem < ports.length; nElem++)
        {
            xml.removeChild(ports[nElem]);
        }

        newNode = xml.ownerDocument.createElement("PortRange");
        newNode.text = aPort[0] + ":" + aPort[1];
        xml.appendChild(newNode);
    }
    else
    {
        // adding port - test for range
        ports = xml.selectNodes("PortRange");
        if (ports.length > 0) {
            ports = xml.selectNodes("./*");
            for (var nElem=0; nElem < ports.length; nElem++)
            {
                xml.removeChild(ports[nElem]);
            }
        } else {
            ports = xml.selectNodes("./Port");
            for (var nElem=0; nElem < ports.length; nElem++)
            {
                if (ports[nElem].nodeTypedValue == port)
                    bFound = true;
            }
        }
        if (!bFound)
        {
            newNode = xml.ownerDocument.createElement("Port");
            newNode.text = port;
            xml.appendChild(newNode);
        }
    }
}