/*

    File:       NetworkSetupHelpers.c

    Contains:   High-level network preference routines.

    Written by: Quinn

    Copyright:  Copyright © 1998 by Apple Computer, Inc., all rights reserved.

                You may incorporate this Apple sample source code into your program(s) without

                restriction. This Apple sample source code has been provided "AS IS" and the

                responsibility for its operation is yours. You are not permitted to redistribute

                this Apple sample source code as "Apple sample source code" after having made

                changes. If you're going to re-distribute the source, we require that you make

                it clear in the source that the code was descended from Apple sample source

                code, but that you've made changes.

    Change History (most recent first):

        <21>     18/1/00    Quinn   Further updates for the new Network Setup header file.

        <20>     17/1/00    Quinn   Updates for latest Network Setup headers.

        <19>      6/1/00    Quinn   Updated NSHEncodeRemotePassword to use the Network Setup routine

                                    OTCfgEncrypt if it's available (Mac OS 9.0 and higher).

        <18>     7/12/99    Quinn   AOL registers as an Ethernet device, even though it supports

                                    dialling.  They will fix this, but I've added a special case to

                                    handle it here as well.

        <17>    19/10/99    Quinn   Fix embarrassing spelling error.

        <16>    12/10/99    Quinn   Fixed bug in the 'isdm' stage of

                                    BuildPackedPrefsFromTCPv4ConfigurationDigest where, if no

                                    fSearchDomains was specified, we would set up

                                    kTCPRoutersListAttr instead of kTCPDomainsListAttr.  Thanks to

                                    John Norstad.

        <15>     13/9/99    Quinn   Fix bug where CreateConfigurationDatabase wasn't setting up

                                    cookie4 correctly.  Thanks for Tom Bayley.

        <14>     13/9/99    Quinn   Fix bug in creating MacIP configurations.  Thanks to Thomas

                                    Weisbach for the fix.

        <13>     13/9/99    Quinn   Implement DHCPRelease.

        <12>     26/5/99    Quinn   Use cookie4 in NSHConfigurationEntry.  Implement support for

                                    Internet setup routines on legacy files.  Improved code sharing

                                    between database and legacy files. Fixed bug in

                                    BuildPackedPrefsFromModemConfigurationDigest; duplicated 'mdpw'

                                    prefs.

        <11>      7/5/99    Quinn   This "redux" word, I don't think it means what you think it

                                    means.

        <10>     22/4/99    Quinn   Added code to encode Remote Access passwords.  Also reworked how

                                    the default 'lcp ' preference was generated, using Network Setup

                                    if possible.

         <9>     21/4/99    Quinn   Added massive amounts of code to create, duplicate, get, set,

                                    delete and rename configurations for TCP/IP, Remote Access, and

                                    Modem.  Also fixed a bug in NSHIsAppleTalkActive where it was

                                    return an assembly Boolean (0/0xff) rather than a C Boolean

                                    (0/1).

         <8>     16/3/99    Quinn   Fixed one-based array problem in GetConfigurationListFromFile.

         <7>    10/11/98    Quinn   Fix = vs == in an assert.

         <6>    10/11/98    Quinn   Convert "MorePrefix.h" to "MoreSetup.h".

         <5>     9/11/98    Quinn   AppleTalk on/off support.

         <4>     9/11/98    Quinn   Add "TCP will dial" code.

         <3>     5/11/98    Quinn   Use MoreAssertQ instead of MoreAssert.

         <2>     5/11/98    Quinn   Fix header.

         <1>     5/11/98    Quinn   First checked in.

*/

/////////////////////////////////////////////////////////////////

// MoreIsBetter Setup

#include "MoreSetup.h"

// Mac OS Interfaces

#include <Types.h>

#include <Files.h>

#include <Errors.h>

#include <Folders.h>

#include <Resources.h>

#include <Gestalt.h>

#include <CodeFragments.h>

#include <NetworkSetup.h>

#include <OpenTptLinks.h>

#include <OpenTptConfig.h>

#include <Traps.h>

// MIB Prototypes (stuff that should be in Universal Interfaces)

#include "RemoteAccessInterface.h"

// MIB Prototypes (stuff that should be in Universal Interfaces)

#include "MoreTextUtils.h"

#include "MoreInterfaceLib.h"

#include "MoreNetworkSetup.h"

#include "OldOTConfigLib.h"

// Our Prototypes

#include "NetworkSetupHelpers.h"

/////////////////////////////////////////////////////////////////

// Testing Parameters

enum {

    // Throw this switch if you want to debug the direct preference

    // file access code on a machine with Network Setup installed.

    kUseNetworkSetup = true,

    // If you set kUseInetInterfaceInfo to false, NSHTCPWillDial will not

    // use the heuristic of "if the TCP/IP stack is loaded, it's safe

    // to open an endpoint".  This is especially useful when debugging.

    kUseInetInterfaceInfo = true

};

/////////////////////////////////////////////////////////////////

extern pascal ItemCount NSHCountConfigurationList(NSHConfigurationListHandle configList)

    // See comments in interface part.

{

    return GetHandleSize( (Handle) configList ) / sizeof(NSHConfigurationEntry);

}

/////////////////////////////////////////////////////////////////

#pragma mark ----- Configuration List using Database -----

// Parameter structure for SetterIterator.

struct TypeAndClassParam {

    OSType  fType;

    OSType  fClass;

    Boolean found;

    CfgEntityRef *currentEntity;

};

typedef struct TypeAndClassParam TypeAndClassParam;

static pascal void TypeAndClassIterator(const MNSDatabaseRef *ref, CfgSetsElement *thisElement, void *p)

    // This routine is used as a callback for MNSIterateSet.

    // It looks for the entity specified by the fType and fClass

    // fields of the param, and puts its entityRef into the

    // variable pointed to by the currentEntity field of param.

{

    TypeAndClassParam *param;

    param = (TypeAndClassParam *) p;

    MoreAssertQ(MNSValidDatabase(ref));

    MoreAssertQ(thisElement != nil);

    MoreAssertQ(param != nil);

    MoreAssertQ(param->currentEntity != nil);

    if (thisElement->fEntityInfo.fClass == param->fClass && thisElement->fEntityInfo.fType == param->fType) {

        MoreAssertQ( ! param->found );

        param->found = true;

        *(param->currentEntity) = thisElement->fEntityRef;

    }

}

enum {

    kNoCurrentConnectionErr = -6

};

static OSStatus FindCurrentConnection(const MNSDatabaseRef *ref, OSType protocol, CfgEntityRef *currentEntity)

    // This routine finds the current connection entity for the specified

    // protocol in the active set, returning it in currentEntity.

{

    OSStatus err;

    CfgEntityRef activeSet;

    TypeAndClassParam param;

    MoreAssertQ(MNSValidDatabase(ref));

    MoreAssertQ(currentEntity != nil);

    param.fClass = kOTCfgClassNetworkConnection;

    param.fType = protocol;

    param.found = false;

    param.currentEntity = currentEntity;

    err = MNSFindActiveSet(ref, &activeSet);

    if (err == noErr) {

        err = MNSIterateSet(ref, &activeSet, TypeAndClassIterator, &param, false);

    }

    if (err == noErr) {

        if (param.found) {

            // Set preferences contain entities from weird areas because

            // of the way the database is committed.  We can safely fix

            // that up here.  I discussed with the Network Setup engineer

            // and he reassured me that this was cool -- Quinn, 9 Nov 1998

            currentEntity->fLoc = ref->area;

        } else {

            err = kNoCurrentConnectionErr;

        }

    }

    return err;

}

static OSStatus AddEntityToConfigurationList(const MNSDatabaseRef *ref,

                                            const CfgEntityRef *entity,

                                            const CfgEntityInfo *entityInfo,

                                            OSType protocol,

                                            NSHConfigurationListHandle configList)

    // This routines adds the entity specified by entity and entityInfo

    // in the database specified by ref to the configList.

{

    OSStatus err;

    NSHConfigurationEntry thisEntry;

    StringPtr entityName;

    ByteCount junkSize;

    MoreAssertQ(configList != nil);

    MoreAssertQ(MNSValidDatabase(ref));

    MoreAssertQ(entity != nil);

    MoreAssertQ(entityInfo != nil);

    // Get the user-visible name from the configuration, which is

    // stored in the 'pnam' preferences.

    entityName = nil;

    err = MNSGetPref(ref, entity, kOTCfgUserVisibleNamePref, &entityName, &junkSize);

    if (err == noErr) {

        MoreAssertQ(junkSize == (entityName[0] + 1));

        BlockMoveData(entityName, &thisEntry.name, entityName[0] + 1);

        thisEntry.selected = false;

        thisEntry.cookie = 0;

        thisEntry.cookie2 = *entity;

        thisEntry.cookie3 = *entityInfo;

        thisEntry.cookie4 = protocol;

    }

    if (err == noErr) {

        err = PtrAndHand(&thisEntry, (Handle) configList, sizeof(thisEntry));

    }

    // Clean up.

    if (entityName != nil) {

        DisposePtr( (Ptr) entityName);

        MoreAssertQ(MemError() == noErr);

    }

    return err;

}

// Parameter structure for SetterIterator.

struct SetterParam {

    OSType fType;

    OSType fClass;

    const CfgEntityRef *chosenConfig;

    const CfgEntityInfo *chosenConfigInfo;

};

typedef struct SetterParam SetterParam;

static pascal void SetterIterator(const MNSDatabaseRef *ref, CfgSetsElement *thisElement, void *p)

    // This routine is used as a callback for MNSIterateSet.

    // It looks for the entity specified by the fType and fClass

    // fields of the param, and replaces it with the chosen

    // entity and info from the param.  It expects that the caller

    // of MNSIterateSet has specified writeAfterIterate so that

    // the changes get written back to the set.

{

    SetterParam *param;

    param = (SetterParam *) p;

    MoreAssertQ(MNSValidDatabase(ref));

    MoreAssertQ(MNSDatabaseWritable(ref));

    MoreAssertQ(thisElement != nil);

    MoreAssertQ(param != nil);

    MoreAssertQ(param->chosenConfig != nil);

    MoreAssertQ(param->chosenConfigInfo != nil);

    if (thisElement->fEntityInfo.fClass == param->fClass && thisElement->fEntityInfo.fType == param->fType) {

        thisElement->fEntityRef = *param->chosenConfig;

        thisElement->fEntityInfo = *param->chosenConfigInfo;

    }

}

static OSStatus GetConfigurationListFromDatabase(OSType protocol, NSHConfigurationListHandle configList)

    // Implementation of NSHGetConfigurationList which uses the Network Setup

    // database.  See NSHGetConfigurationList's comment in header

    // file for interface specification.

{

    OSStatus err;

    OSStatus err2;

    MNSDatabaseRef ref;

    ItemCount entityCount;

    CfgEntityRef *entityRefs;

    CfgEntityInfo *entityInfos;

    CfgEntityRef activeConn;

    ItemCount i;

    entityRefs = nil;

    entityInfos = nil;

    err = MNSOpenDatabase(&ref, false);

    if (err == noErr) {

        // Find all the network connection entities for this protocol.

        err = MNSGetEntitiesList(&ref,

                                kOTCfgClassNetworkConnection, protocol,

                                &entityCount,

                                &entityRefs,

                                &entityInfos);

        // Add each to the list of possible connections.

        if (err == noErr) {

            for (i = 0; i < entityCount; i++) {

                err = AddEntityToConfigurationList(&ref, &entityRefs[i], &entityInfos[i], protocol, configList);

            }

        }

        // Find the current configuration and mark it as selected

        // in the list.

        if (err == noErr) {

            err = FindCurrentConnection(&ref, protocol, &activeConn);

        }

        if (err == noErr) {

            for (i = 0; i < entityCount; i++) {

                if ( OTCfgIsSameEntityRef(&activeConn, &(*configList)[i].cookie2, kOTCfgIgnoreArea) ) {

                    (*configList)[i].selected = true;

                }

            }

        }

        err2 = MNSCloseDatabase(&ref, false);

        if (err == noErr) {

            err = err2;

        }

    }

    // Clean up.

    if (entityInfos != nil) {

        DisposePtr( (Ptr) entityInfos);

        MoreAssertQ(MemError() == noErr);

    }

    if (entityRefs != nil) {

        DisposePtr( (Ptr) entityRefs);

        MoreAssertQ(MemError() == noErr);

    }

    return err;

}

static OSStatus SelectConfigurationFromDatabase(const NSHConfigurationEntry *chosenEntry)

    // Implementation of NSHSelectConfiguration which uses the Network Setup

    // database.  See NSHSelectConfiguration's comment in header

    // file for interface specification.

{

    OSStatus err;

    OSStatus err2;

    MNSDatabaseRef ref;

    CfgEntityRef activeSet;

    SetterParam param;

    err = MNSOpenDatabase(&ref, true);

    if (err == noErr) {

        param.fClass = kOTCfgClassNetworkConnection;

        param.fType = chosenEntry->cookie4;

        param.chosenConfig = &chosenEntry->cookie2;

        param.chosenConfigInfo = &chosenEntry->cookie3;

        err = MNSFindActiveSet(&ref, &activeSet);

        if (err == noErr) {

            err = MNSIterateSet(&ref, &activeSet, SetterIterator, &param, true);

        }

        err2 = MNSCloseDatabase(&ref, err == noErr);

        if (err == noErr) {

            err = err2;

        }

    }

    return err;

}

/////////////////////////////////////////////////////////////////

#pragma mark ----- Configuration List using File -----

static OSStatus SearchFolder(SInt16 vRefNum, SInt32 dirID,

                                OSType typeToSearchFor, OSType creatorToSearchFor,

                                FSSpec *fss)

    // Search a particular folder for a file of a particular

    // type and creator.  If it's found, return an FSSpec to

    // the file.  If it's not found, return an error.

{

    OSStatus err;

    Boolean found;

    SInt16 index;

    HParamBlockRec pb;

    MoreAssertQ(fss != nil);

    fss->vRefNum = vRefNum;

    fss->parID = dirID;

    found = false;

    index = 1;

    do {

        pb.fileParam.ioVRefNum = vRefNum;

        pb.fileParam.ioDirID = dirID;

        pb.fileParam.ioNamePtr = fss->name;

        pb.fileParam.ioFDirIndex = index;

        err = PBHGetFInfoSync(&pb);

        if (err == noErr) {

            found = ( pb.fileParam.ioFlFndrInfo.fdType    == typeToSearchFor &&

                      pb.fileParam.ioFlFndrInfo.fdCreator == creatorToSearchFor );

        }

        index += 1;

    } while (err == noErr & ! found);

    return err;

}

enum {

    kOTNetworkPrefFileType = 'pref',

    kOTTCPPrefFileCreator = 'ztcp',

    kOTAppleTalkPrefFileCreator = 'atdv',

    kModemPrefFileType     = 'mdpf',

    kModemPrefFileCreator  = 'modm',

    kRemotePrefFileType    = 'lzcn',

    kRemotePrefFileCreator = 'rmot'

};

static OSStatus FindNetworkPrefFile(OSType protocol, FSSpec *fss)

    // This routine scans the Preferences folder looking

    // for the preferences for the given network protocol.

    // Scans are done by file type and creator to avoid

    // problems on localised systems.

{

    OSStatus err;

    Boolean searchSubFolders;

    OSType typeToSearchFor;

    OSType creatorToSearchFor;

    SInt16 prefFolderVRefNum;

    SInt32 prefFolderDirID;

    // Set up the file type and creator based on the protocol.

    searchSubFolders = false;

    switch (protocol) {

        case kOTCfgTypeTCPv4:

            typeToSearchFor    = kOTNetworkPrefFileType;

            creatorToSearchFor = kOTTCPPrefFileCreator;

            break;

        case kOTCfgTypeAppleTalk:

            typeToSearchFor    = kOTNetworkPrefFileType;

            creatorToSearchFor = kOTAppleTalkPrefFileCreator;

            break;

        case kOTCfgTypeRemote:

            typeToSearchFor    = kRemotePrefFileType;

            creatorToSearchFor = kRemotePrefFileCreator;

            searchSubFolders = true;

            break;

        case kOTCfgTypeModem:

            typeToSearchFor    = kModemPrefFileType;

            creatorToSearchFor = kModemPrefFileCreator;

            break;

        default:

            MoreAssertQ(false);

            break;

    }

    // Search the Preferences folder for a file with that type and creator.

    err = FindFolder(kOnSystemDisk, kPreferencesFolderType, kCreateFolder, &prefFolderVRefNum, &prefFolderDirID);

    if (err == noErr) {

        // The Remote Access preference file is stored in a folder within

        // the preferences folder.  We can't hard wire the name "Remote Access"

        // because the name is localised.  Instead, we search all the folders

        // within the preferences folder for the file.  In all other cases,

        // we just search the preferences folder for the file.

        if (searchSubFolders) {

            Boolean found;

            CInfoPBRec cpb;

            SInt16 index;

            found = false;

            index = 1;

            do {

                cpb.dirInfo.ioVRefNum = prefFolderVRefNum;

                cpb.dirInfo.ioDrDirID = prefFolderDirID;

                cpb.dirInfo.ioNamePtr = nil;

                cpb.dirInfo.ioFDirIndex = index;

                err = PBGetCatInfoSync(&cpb);

                if (err == noErr && ((cpb.dirInfo.ioFlAttrib & ioDirMask) != 0)) {

                    found = ( SearchFolder(prefFolderVRefNum, cpb.dirInfo.ioDrDirID,

                                            typeToSearchFor, creatorToSearchFor,

                                            fss) == noErr);

                }

                index += 1;

            } while (err == noErr & ! found);

        } else {

            err = SearchFolder(prefFolderVRefNum, prefFolderDirID,

                                typeToSearchFor, creatorToSearchFor,

                                fss);

        }

    }

    return err;

}

static OSStatus CheckResError(void *testH)

    // A trivial wrapper routine for ResError,

    // which is too lame to report an error code

    // in all cases when GetResource fails.

{

    OSStatus err;

    err = ResError();

    if (err == noErr && testH == nil) {

        err = resNotFound;

    }

    return err;

}

static OSStatus OpenNetworkPrefFile(OSType protocol, SInt8 permission,

                                    SInt16 *oldResFile, SInt16 *networkResFile)

    // Opens the legacy preference file for the given protocol with

    // the specified permission (typicallly fsRdPerm or fsRdWrPerm).

    // Returns the previous CurResFile and the refnum of the new

    // file, both of which you pass to CloseNetworkPrefFile to clean up

    // the open.

{

    OSStatus err;

    FSSpec fss;

    MoreAssertQ(oldResFile != nil);

    MoreAssertQ(networkResFile != nil);

    *oldResFile = CurResFile();

    err = FindNetworkPrefFile(protocol, &fss);

    if (err == noErr) {

        if (permission == fsRdWrPerm) {

            // ¥¥¥ Gotcha ¥¥¥

            // Really need to be careful here because it's possible

            // that fss is open in our current resource chain.

            // See DTS Technote 1120 "Opening Resource Files Twice Considered

            // Hard?" for details.

            //

            //   <http://developer.apple.com/technotes/tn/tn1120.html>

            //

            // I'll probably put real code to detect and handle this into

            // MoreResources eventually; in the mean time, you have to live 

            // with the limitation that you can't use this library when

            // a legacy preference file might be open in your resource chain.

            // -- Quinn, 9 Nov 1998

        }

        // SetResLoad to false around the open to avoid bringing

        // any preload resources in the file into memory.

        SetResLoad(false);

        *networkResFile = FSpOpenResFile(&fss, permission);

        err = ResError();

        SetResLoad(true);

    }

    // If we error, setup the outputs to values we can use to

    // detect client logic errors in CloseNetworkPrefFile.

    if (err != noErr) {

        *oldResFile = 0;

        *networkResFile = 0;

    }

    return err;

}

static OSStatus CloseNetworkPrefFile(SInt16 oldResFile, SInt16 networkResFile)

    // Closes the legacy preference file you opened using OpenNetworkPrefFile.

{

    OSStatus err;

    MoreAssertQ(oldResFile != 0);

    MoreAssertQ(networkResFile != 0);

    CloseResFile(networkResFile);

    err = ResError();

    if (err == noErr) {

        UseResFile(oldResFile);

        MoreAssertQ(ResError() == noErr);

    }

    return err;

}

static OSStatus CommitChangesToPrefFile(OSType protocol, SInt16 refNum, SInt16 config)

    // This routine represents the magic that allows you to force OT

    // to notice a configuration file change without rebooting.  It uses

    // some previously undocumented routines, the glue for which is provided

    // as part of this sample.  This routine is called by any direct file

    // modification code which modifies the active configuration.

    //

    // IMPORTANT:

    // The only reason it's safe to document these routines now is that we

    // know that they work on all old versions of OT, and new versions of OT

    // include the Network Setup library which allows you to change network

    // preferences without any of this hackery.  Never ship a product that

    // relies on these routines that doesn't also use Network Setup if it's

    // available.

{

    OSStatus err;

    err = noErr;

    switch (protocol) {

        case kOTCfgTypeTCPv4:

            if ( TCPCheckChangeConfigurationConsequences(refNum, config) == kMustReboot ) {

                err = -7;

            }

            if ( err == noErr ) {

                err = TCPChangeConfiguration(refNum, config);

            }

            break;

        case kOTCfgTypeAppleTalk:

            if ( ATCheckChangeConfigurationConsequences(refNum, config) == kMustReboot ) {

                err = -7;

            }

            if ( err == noErr ) {

                err = ATChangeConfiguration(refNum, config);

            }

            break;

        case kOTCfgTypeRemote:

        case kOTCfgTypeModem:

            {

                Handle currentConfigResourceH;

                // For Remote and Modem, we directly munge the preferences

                // file.  There's no way to tweak these protocol stacks

                // to get them to recognise the updated file.  Instead,

                // they'll pick up the preferences the next time you connect.

                // Hmmm, except for ARA Personal Server, for which we

                // have no solution at the moment.

                currentConfigResourceH = Get1Resource(kOTCfgCompatSelectedPref, 1);

                err = CheckResError(currentConfigResourceH);

                if (err == noErr && GetHandleSize(currentConfigResourceH) != sizeof(SInt16) ) {

                    // Assert: 'ccfg' is of the wrong size

                    MoreAssertQ(false);

                    err = -1;

                } else {

                    **(SInt16 **)currentConfigResourceH = config;

                    ChangedResource(currentConfigResourceH);

                    err = ResError();

                }

            }

            break;

        default:

            MoreAssertQ(false);

            err = -7;

            break;

    }

    return err;

}

static OSStatus GetCurrentConfigFromPrefFile(SInt16 *config)

    // This routine returns the resource ID of the current

    // configurator in a legacy preferences file.

{

    OSStatus err;

    Handle currentConfigResourceH;

    MoreAssertQ(config != nil);

    currentConfigResourceH = Get1Resource(kOTCfgCompatSelectedPref, 1);

    err = CheckResError(currentConfigResourceH);

    if (err == noErr && GetHandleSize(currentConfigResourceH) != sizeof(SInt16) ) {

        // Assert: 'ccfg' is of the wrong size

        MoreAssertQ(false);

        err = -1;

    } else {

        *config = **(SInt16 **)currentConfigResourceH;

    }

    return err;

}

static OSStatus AddResourceToConfigurationList(OSType protocol, Handle cnamHandle, NSHConfigurationListHandle configList)

    // Given a handle to a 'cnam' resource, generate a

    // NSHConfigurationEntry and append it to the list

    // of configurations.

{

    OSStatus err;

    NSHConfigurationEntry thisEntry;

    SInt16 cnamID;

    ResType junkType;

    GetResInfo(cnamHandle, &cnamID, &junkType, thisEntry.name);

    MoreAssertQ(ResError() == noErr);

    MoreAssertQ(junkType == kOTCfgCompatNamePref);

    thisEntry.selected = false;

    thisEntry.cookie = cnamID;

    OTMemzero(&thisEntry.cookie2, sizeof(thisEntry.cookie2));

    OTMemzero(&thisEntry.cookie3, sizeof(thisEntry.cookie3));

    thisEntry.cookie4 = protocol;

    err = PtrAndHand(&thisEntry, (Handle) configList, sizeof(thisEntry));

    return err;

}

static OSStatus GetConfigurationListFromFile(OSType protocol, NSHConfigurationListHandle configList)

    // Implementation of NSHGetConfigurationList which uses the legacy

    // preference files.  See NSHGetConfigurationList's comment in header

    // file for interface specification.

{

    OSStatus err;

    OSStatus err2;

    Handle cnamHandle;

    SInt16 refNum;

    SInt16 resCount;

    SInt16 i;

    SInt16 currentConfigID;

    SInt16 oldResFile;

    err = OpenNetworkPrefFile(protocol, fsRdPerm, &oldResFile, &refNum);

    if (err == noErr) {

        resCount = Count1Resources(kOTCfgCompatNamePref);

        for (i = 1; i <= resCount; i++) {

            SetResLoad(false);

            cnamHandle = Get1IndResource(kOTCfgCompatNamePref, i);

            err = CheckResError(cnamHandle);

            SetResLoad(true);

            if (err == noErr) {

                err = AddResourceToConfigurationList(protocol, cnamHandle, configList);

            }

            // Don't need to release the resource because CloseResFile will

            // clean it up.

            if (err != noErr) {

                break;

            }

        }

        if (err == noErr) {

            err = GetCurrentConfigFromPrefFile(&currentConfigID);

        }

        if (err == noErr) {

            for (i = 0; i < resCount; i++) {

                if ( (*configList)[i].cookie == currentConfigID ) {

                    (*configList)[i].selected = true;

                }

            }

        }

        err2 = CloseNetworkPrefFile(oldResFile, refNum);

        if (err == noErr) {

            err = err2;

        }

    }

    return err;

}

static OSStatus SelectConfigurationFromFile(const NSHConfigurationEntry *chosenEntry)

    // Implementation of NSHGetConfigurationList which uses the legacy

    // preference files.  See NSHGetConfigurationList's comment in header

    // file for interface specification.

{

    OSStatus err;

    OSStatus err2;

    SInt16 refNum;

    SInt16 oldResFile;

    err = OpenNetworkPrefFile(chosenEntry->cookie4, fsRdWrPerm, &oldResFile, &refNum);

    if (err == noErr) {

        err = CommitChangesToPrefFile(chosenEntry->cookie4, refNum, chosenEntry->cookie);

        err2 = CloseNetworkPrefFile(oldResFile, refNum);

        if (err == noErr) {

            err = err2;

        }

    }

    return err;

}

/////////////////////////////////////////////////////////////////

#pragma mark ----- Configuration List Abstraction ------

extern pascal OSStatus  NSHGetConfigurationList(OSType protocol, NSHConfigurationListHandle configList)

    // See comments in interface part.

{

    OSStatus err;

    SetHandleSize( (Handle) configList, 0);

    MoreAssertQ(MemError() == noErr);

    if ( kUseNetworkSetup && IsNetworkSetupAvailable() ) {

        #if TARGET_RT_MAC_CFM

            err = GetConfigurationListFromDatabase(protocol, configList);

        #else

            // Network Setup has no Mixed Mode glue.  When running

            // code on a PowerPC with Network Setup available, you

            // should either compile your code as Fat or, if that's

            // infeasible, write your own Mixed Mode glue.

            return -5;

        #endif

    } else {

        err = GetConfigurationListFromFile(protocol, configList);

    }

    return err;

}

extern pascal OSStatus  NSHSelectConfiguration(const NSHConfigurationEntry *chosenEntry)

    // See comments in interface part.

{

    OSStatus err;

    if ( kUseNetworkSetup && IsNetworkSetupAvailable() ) {

        #if TARGET_RT_MAC_CFM

            err = SelectConfigurationFromDatabase(chosenEntry);

        #else

            // Network Setup has no Mixed Mode glue.  When running

            // code on a PowerPC with Network Setup available, you

            // should either compile your code as Fat or, if that's

            // infeasible, write your own Mixed Mode glue.

            return -5;

        #endif

    } else {

        err = SelectConfigurationFromFile(chosenEntry);

    }

    return err;

}

/////////////////////////////////////////////////////////////////

#pragma mark ----- Internet Setup Documentation ------

/*

    The mapping from NSHTCPv4ConfigurationDigest fields to preferences

    is as follows:

    fProtocol           -> kOTCfgTypeTCPv4

    fConfigName;        -> 'pnam'

    fPortRef;           -> 'port', 'iitf'

    fUnloadAttr;        -> 'unld'

    fDNSServerList;     -> 'idns'

    fLocalDomain;       -> 'ihst'

    fAdminDomain;       -> 'ihst'

    fConfigMethod;      -> 'iitf'

    fIPAddress;         -> 'iitf'

    fSubnetMask;        -> 'iitf'

    fAppleTalkZone;     -> 'iitf'

    fFraming;           -> 'iitf'

    fSearchDomains;     -> 'isdm'

    fRouterList;        -> 'irte'

    The reverse mapping, from preference to NSHTCPv4ConfigurationDigest field,

    is:

    'pnam' -> fConfigName

    'port' -> UserVisibleName(fPortRef)         -- or "AppleTalk (Mac IP)", localisation?

    'pwrd' -> "\p"

    'cvrs' -> 1

    'prot' -> "tcp"

    'unld' -> fUnloadAttr

    'idns' -> GetHandleSize(fDNSServerList) div sizeof(InetHost), fDNSServerList;

    'ihst' -> 1, fLocalDomain, fAdminDomain (packed)

    'iitf' -> 1, fConfigMethod, fIPAddress, fSubnetMask, fAppleTalkZone, PortName(fPortRef), fModuleName(fPortRef), fFraming

    'dtyp' -> DeviceType(fPortRef)          -- or kOTNoDevice for MacIP

    'stng' -> $00 * 25

    'isdm' -> fSearchDomains

    'irte' -> fRouterList, padded appropriately

*/

/*

    Mapping from NSHRemoteConfigurationDigest fields to preference types:

    fProtocol;                          kOTCfgTypeRemote

    fConfigName;                        -> 'pnam'

    fGuestLogin                         -> 'conn' (isGuest)

    fPasswordValid                      -> 'conn' (passwordSaved)

    fUserName;                          -> 'cusr'

    fPassword;                          -> 'pass'

    fPhoneNumber;                       -> 'cadr', 'conn' (addressLength)

    fRedialMode;                        -> 'cdia' (dialMode)

    fRedialTimes;                       -> 'cdia' (redialTries)

    fRedialDelay;                       -> 'cdia' (redialDelay)

    fAlternatePhoneNumber;              -> 'cead'

    fVerboseLogging;                    -> 'logo' (logLevel)

    fFlashIconWhileConnected;           -> 'conn' (flashConnectedIcon)

    fPromptToRemainConnected;           -> 'conn' (issueConnectedReminders)

    fPromptInterval;                    -> 'conn' (reminderMinutes)

    fDisconnectIfIdle;                  -> 'ipcp' (idleTimerEnabled)

    fDisconnectInterval;                -> 'ipcp' (idleTimerMilliseconds)

    fSerialProtocol;                    -> 'conn' (serialProtocolMode)

    fPPPConnectAutomatically;           -> 'cmsc' (isAutoConnect)

    fPPPAllowModemCompression;          -> 'conn' (allowModemDataCompression)

    fPPPAllowTCPIPHeaderCompression;    -> 'ipcp' (compressTCPHeaders)

    fPPPConnectMode;                    -> 'conn' (chatMode)

    fPPPConnectScriptName;              -> 'conn' (chatScriptName)

    fPPPConnectScript;                  -> 'ccha', 'conn' (chatScriptLength)

    fixed value (see below)             -> 'lcp '

    $0002 $0003 "Script" [36]           -> 'arap'

    $0002 $0003 $00 * 596               -> 'x25 '

    $0002 $0003 $00 * 68                -> 'dass'

    $00010000 $00000001 $00 * 256       -> 'usmd'

    $0002 $0003 $00 * 64                -> 'clks'

    This is the mapping from preference type to NSHRemoteConfigurationDigest field.

    'pnam' -> fConfigName

    'cmsc' -> fPPPConnectAutomatically

    'conn' -> fGuestLogin, fPasswordValid, fPhoneNumber, fFlashIconWhileConnected, fPromptToRemainConnected, fPromptInterval, fSerialProtocol, fPPPAllowModemCompression, fPPPConnectMode, fPPPConnectScriptName, fPPPConnectScript

    'cusr' -> fUserName

    'pass' -> fPassword

    'cdia' -> fRedialMode, fRedialTimes, fRedialDelay

    'ipcp' -> fDisconnectIfIdle, fDisconnectInterval, fPPPAllowTCPIPHeaderCompression

    'logo' -> fVerboseLogging

    'cadr' -> fPhoneNumber

    'cead' -> fAlternatePhoneNumber

    'ccha' -> fPPPConnectScript

    'usmd' -> junk

    'clks' -> junk

    'lcp ' -> junk

    'arap' -> junk

    'dass' -> junk

    'x25 ' -> junk

    'term' -> junk

    'cnam' -> junk

    'resn' -> junk

    'resi' -> junk

*/

// This fixed value for the Remote Access 'lcp ' preference is only used if

// OTCfgGetDefault is not available.

static UInt8 gRemoteLCPValue[108] = {

    0x00, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x63, 0x72, 0x69,

    0x70, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

    0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x0A,

    0x00, 0x00, 0x27, 0x10, 0x00, 0x00, 0x27, 0x10, 0x00, 0x00, 0x27, 0x10, 0x00, 0x00, 0x00, 0x05,

    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x05, 0xDC, 0x00, 0x00, 0x11, 0x94, 0x00, 0x00, 0x00, 0x00,

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

};

/*

    This is the mapping from preference type to NSHModemConfigurationDigest field.

    'pnam' -> fConfigName

    'ccl ' -> fPortRef, fModemScript, fDialToneMode, fSpeakerOn, fPulseDial, fHintPortName

    'lkmd' -> $00000001 + $00000000 * 4

    'mdpw' -> $00 * 256

    'cnam' -> junk

    'resn' -> junk

    'resi' -> junk

*/

/////////////////////////////////////////////////////////////////

#pragma mark ----- Packed Pref Builder/Writer Infrastructure ------

// All the code that manipulates groups of preferences, ie an entity

// in a Network Setup sense, uses "packed preferences".  This is

// a group of preferences packed into a handle.  Each preference

// contains a header of its type (OSType) and its data size (ByteCount),

// not including the header itself.  The handle is terminated by

// an entry with a null preference type.

//

// The following routines are an easy way to build and parse these

// packed preferences.  The key focus here was to minimise error

// checked.  So when you build a packed preference, all the checking

// is done inside these helper routines and you only have to check

// for errors at the end.  Similarly, when you parse a packed preference

// handle, you know it was built successfully so you can rely on its

// structure.

//

// You typically use these routines in the following way.  First,

// call BuilderNew to initialise the PrefBuilderState record.  Then

// call BuilderNewPref to add a new preference to the handle.  If

// necessary, you can also call BuilderAddPrefData to add extra

// data to the most recently added preference.  Finally, call

// BuilderDone to extract the packed preference handle, or obtain

// any error that might have happened while building.

// When building a packed preference, the following state record

// is used to keep track of what's going on.

struct PrefBuilderState {

    Handle      prefData;                       // handle of packed preference itself, or nil if we got an error somewhere

    OSStatus    latchedError;                   // if an error occured, this field is used to store it until BuilderDone is called

    ByteCount   offsetToMostRecentPrefSize;     // offset to most recent pref size value,

                                                // allows BuilderAddPrefData to look back in the handle and bump this size

};

typedef struct PrefBuilderState PrefBuilderState;

static void BuilderError(PrefBuilderState *state, OSStatus errNum)

    // This routine is called when an error happens while building.

    // It disposes of the packed preference handle (which ensures

    // that no more building is done) and latches the error where

    // BuilderDone can find it.

{

    DisposeHandle(state->prefData);

    MoreAssertQ(MemError() == noErr);

    state->prefData = nil;

    state->latchedError = errNum;

}

static void BuilderNew(PrefBuilderState *state)

    // Initialise the builder state record.  See above for

    // this routines place in the big picture.  If you call

    // this routine, you must also call BuilderDone to clean

    // up the builder (ie dispose of the handle and recover

    // the latched error code).

{

    OSStatus err;

    state->latchedError = noErr;

    state->offsetToMostRecentPrefSize = 0;

    state->prefData = NewHandle(0);

    err = MemError();

    if (err != noErr) {

        BuilderError(state, err);

    }

}

static void BuilderAddPrefData(PrefBuilderState *state, const void *data, ByteCount size)

    // Add preference data, described by data and size, to the previous

    // preference added to the builder.  It's an error to call this without

    // first calling BuilderNewPref.

{

    OSStatus err;

    if (state->prefData != nil) {

        // If this assert fires, it means you've called this routine without first calling BuilderNewPref.

        MoreAssertQ(state->offsetToMostRecentPrefSize != 0);

        // Add the data to the preference handle.

        err = PtrAndHand(data, state->prefData, size);

        // Reach back into the preference handle, find the size

        // of the current preference, and increment it by the amount

        // of data we added.  Note that this might fail on a 68000

        // processor (because it can't handle memory accesses to words

        // off word boundaries) but this isn't an issue because OT

        // requires an 68030 or above.

        if (err == noErr) {

            *((ByteCount *)((*(state->prefData)) + state->offsetToMostRecentPrefSize)) += size;

        }

        // Handle errors.

        if (err != noErr) {

            BuilderError(state, err);

        }

    }

}

static void BuilderNewPref(PrefBuilderState *state, OSType prefType, const void *data, ByteCount size)

    // Add a new preference to the builder, with the data specified

    // by data and size.  You can pass nil and 0 to these parameters

    // to add an empty preference.  Regardless, you can later call

    // BuilderAddPrefData to add extra data to this preference, up

    // until you call BuilderNewPref again.

{

    OSStatus err;

    ByteCount initialPrefSize;

    if (state->prefData != nil) {

        // Add the preference type to the preference handle.

        err = PtrAndHand(&prefType, state->prefData, sizeof(prefType));

        // Record the current offset into the preference handle

        // (which is the offset of this preference size value,

        // which is needed by BuilderAddPrefData) and then add

        // a default size value of 0 to the preference.

        if (err == noErr) {

            state->offsetToMostRecentPrefSize = GetHandleSize(state->prefData);

            initialPrefSize = 0;

            err = PtrAndHand(&initialPrefSize, state->prefData, sizeof(initialPrefSize));

        }

        // Handle errors.

        if (err != noErr) {

            BuilderError(state, err);

        }

    }

    // Finally, call BuilderAddPrefData to add the actual

    // preference data.  Note that if the above errored, the

    // error will have been latched in the state record, and

    // this call will be a no-op.

    if (size != 0) {

        BuilderAddPrefData(state, data, size);

    }

}

static OSStatus BuilderDone(PrefBuilderState *state, Handle *prefData)

    // Extracts the prefData from the builder state.  You must

    // pass in a pointer to a nil handle.  If building was successful,

    // this routine returns noErr and sets the handle to be

    // the built packed preferences.  From there on, the memory

    // belongs to you.

    //

    // If the building was unsuccessful, the routine returns an error

    // and the handle remains nil.

{

    OSStatus err;

    MoreAssertQ(prefData != nil);

    // Add a sentinel null OSType to the data handle.

    BuilderNewPref(state, 0, nil, 0);

    // Return the latched error code.

    if (state->prefData == nil) {

        err = state->latchedError;

    } else {

        err = noErr;

    }

    *prefData = state->prefData;

    MoreAssertQ( err == noErr && *prefData != nil || err != noErr && *prefData == nil );

    return err;

}

static void WriterGetNextPref(ByteCount *cookie, Ptr prefData, OSType *prefType, void **prefPtr, ByteCount *prefSize)

    // This routine provides a simple way for you to iterate over

    // a group of packed preferences.  You get the first preference

    // by setting *cookie to 0 and calling the routine.  The routine

    // returns the preference, and updates *cookie so that next time

    // you call it you get the second preference, and so on.

    //

    // prefData must point to a packed preference structure, as described

    // in the comments at the start of this section.  Typically you get

    // this by locking and dereferencing the handle returned by BuilderDone.

    // [Locking the handle is advised by not strictly necessary as

    // long as you take care not to move or purge between when this routine

    // returns and when you use *prefPtr.]  You don't have to pass in

    // the size of this handle because it's terminated by a null preference

    // type.  You can keep calling this routine until *prefType is returned

    // as 0, in which case you've hit the end of the packed preferences.

    //

    // The routine sets *prefType to the type of the preference, and

    // *prefPtr and *prefSize to point to the preference data itself.

    // Note that *prefPtr is not necessarily aligned to any memory

    // boundary, so if you access it as a word or long pointer on an

    // original 68000 you may cause an address error.

{

    MoreAssertQ(cookie != nil);

    MoreAssertQ(prefData != nil);

    MoreAssertQ(prefType != nil);

    MoreAssertQ(prefSize != nil);

    MoreAssertQ(prefPtr != nil);

    *prefType = *((OSType *)(prefData + *cookie));

    *cookie += sizeof(OSType);                          // skip cookie past the prefType

    *prefSize = *((ByteCount *)(prefData + *cookie));

    *cookie += sizeof(ByteCount);                       // skip cookie past the prefSize

    *prefPtr = prefData + *cookie;

    *cookie += *prefSize;                               // skip cookie past the data

}

static Handle NSHGetDefaultPreference(ResType entityType, ResType entityClass, ResType recordType)

    // Returns a handle containing a default value for the preference

    // of the given entity, class and preference type, or nil if there

    // is not such value (or there isn't enough memory to get it).

    // The result is a memory handle, for which you are responsible for

    // disposing.

    //

    // I decided not to export this routine because of its limited value

    // to external clients.  But it follows the standard outline used

    // by external routines.

{

    Handle result;

    if ( kUseNetworkSetup && IsNetworkSetupAvailable() ) {

        #if TARGET_RT_MAC_CFM

            result = OTCfgGetDefault(entityType, entityClass, recordType);

        #else

            // Network Setup has no Mixed Mode glue.  When running

            // code on a PowerPC with Network Setup available, you

            // should either compile your code as Fat or, if that's

            // infeasible, write your own Mixed Mode glue.

            return nil;

        #endif

    } else {

        if ( entityType == kOTCfgTypeRemote && entityClass == kOTCfgClassNetworkConnection && recordType == kOTCfgRemoteLCPPref) {

            if ( PtrToHand(gRemoteLCPValue, &result, sizeof(gRemoteLCPValue)) != noErr ) {

                result = nil;

            }

        } else {

            result = nil;

        }

    }

    return result;

}

/////////////////////////////////////////////////////////////////

#pragma mark ----- TCP/IP Packer/Unpacker ------

// These routines convert between the TCP/IP configuration digest

// (a big record with all the relevant fields in it) and the

// packed preferences data (which is read from or written to the

// preferences store).  These routines are shared between the

// preferences database and preferences file implementations.

static const char *gProtocolName = "tcp";

static OSStatus BuildPackedPrefsFromTCPv4ConfigurationDigest(

                                    const NSHTCPv4ConfigurationDigest *configurationDigest, 

                                    Boolean forceDefaults,

                                    Handle *packedPrefs)

    // This routine converts a TCP/IP configuration digest

    // to a handle containing packed preferences.  The forceDefaults

    // parameter controls what happens to handle-based fields,

    // ie Handle fields in the digest.  Normally, if such a field

    // is nil, it's taken to mean "don't change".  However, if

    // forceDefaults is true, a nil means "write default value".

    // This happens when we're creating a new configuration,

    // where we want to make sure that empty default preferences

    // are created for these handle-based fields.

{

    OSStatus err;

    OTPortRecord portRec;

    Str255 portUserVisibleName;

    Boolean isMacIP;

    Str63 portName;

    Str63 moduleName;

    UInt8 tmpUInt8;

    UInt16 tmpUInt16;

    const char *kMacIPUserVisibleName = "AppleTalk (Mac IP)";

    static UInt8 zeros[25] = {0};

    PrefBuilderState state; 

    SInt8 s;

    MoreAssertQ(configurationDigest != nil);

    MoreAssertQ(packedPrefs != nil);

    *packedPrefs = nil;

    err = noErr;

    if ( OTFindPortByRef(&portRec, configurationDigest->fPortRef) ) {

        portName[0] = OTStrLength(portRec.fPortName);

        BlockMoveData(portRec.fPortName, &portName[1], portName[0]);

        moduleName[0] = OTStrLength(portRec.fModuleName);

        BlockMoveData(portRec.fModuleName, &moduleName[1], moduleName[0]);

    } else {

        err = kOTNotFoundErr;

    }

    if (err == noErr) {

        BuilderNew(&state);

    // 'pnam'

        BuilderNewPref(&state, kOTCfgUserVisibleNamePref, configurationDigest->fConfigName, configurationDigest->fConfigName[0] + 1);

    // 'port'

        isMacIP = OTStrEqual(portRec.fModuleName, "ddp");

        if (isMacIP) {

            portUserVisibleName[0] = OTStrLength(kMacIPUserVisibleName);

            BlockMoveData(kMacIPUserVisibleName, &portUserVisibleName[1], portUserVisibleName[0]);

        } else {

            OTGetUserPortNameFromPortRef(configurationDigest->fPortRef, portUserVisibleName);

        }

        BuilderNewPref(&state, kOTCfgPortUserVisibleNamePref, portUserVisibleName, portUserVisibleName[0] + 1);

    // 'pwrd'

        tmpUInt8 = 0;

        BuilderNewPref(&state, kOTCfgAdminPasswordPref, &tmpUInt8, sizeof(tmpUInt8));

    // 'cvrs'

        tmpUInt16 = 1;

        BuilderNewPref(&state, kOTCfgVersionPref, &tmpUInt16, sizeof(tmpUInt16));

    // 'prot'

        BuilderNewPref(&state, kOTCfgProtocolUserVisibleNamePref, gProtocolName, OTStrLength(gProtocolName) + 1);

    // 'unld'

        BuilderNewPref(&state, kOTCfgTCPUnloadAttrPref, &configurationDigest->fUnloadAttr, sizeof(configurationDigest->fUnloadAttr));

    // 'idns'

        if (configurationDigest->fDNSServerList != nil) {

            UInt16 numServers;

            MoreAssertQ(GetHandleSize(configurationDigest->fDNSServerList) % sizeof(InetHost) == 0);

            numServers = GetHandleSize(configurationDigest->fDNSServerList) / sizeof(InetHost);

            BuilderNewPref(&state, kOTCfgTCPDNSServersListPref, &numServers, sizeof(numServers));

            s = HGetState(configurationDigest->fDNSServerList);

            HLock(configurationDigest->fDNSServerList);

            BuilderAddPrefData(&state, *configurationDigest->fDNSServerList, GetHandleSize(configurationDigest->fDNSServerList));

            HSetState(configurationDigest->fDNSServerList, s);

        } else if (forceDefaults) {

            tmpUInt16 = 0;

            BuilderNewPref(&state, kOTCfgTCPDNSServersListPref, &tmpUInt16, sizeof(tmpUInt16));

        }

    // 'ihst'

        tmpUInt8 = 1;

        BuilderNewPref(&state, kOTCfgTCPSearchListPref, &tmpUInt8, sizeof(tmpUInt8));

        BuilderAddPrefData(&state, configurationDigest->fLocalDomain, configurationDigest->fLocalDomain[0] + 1);

        BuilderAddPrefData(&state, configurationDigest->fAdminDomain, configurationDigest->fAdminDomain[0] + 1);

    // 'iitf'

        tmpUInt16 = 1;

        BuilderNewPref(&state, kOTCfgTCPInterfacesPref, &tmpUInt16, sizeof(tmpUInt16));

        BuilderAddPrefData(&state, &configurationDigest->fConfigMethod, sizeof(configurationDigest->fConfigMethod));

        BuilderAddPrefData(&state, &configurationDigest->fIPAddress, sizeof(configurationDigest->fIPAddress));

        BuilderAddPrefData(&state, &configurationDigest->fSubnetMask, sizeof(configurationDigest->fSubnetMask));

        if (isMacIP) {

            BuilderAddPrefData(&state, configurationDigest->fAppleTalkZone, configurationDigest->fAppleTalkZone[0] + 1);

            BuilderAddPrefData(&state, "\pddp", 36);

        } else {

            BuilderAddPrefData(&state, "\p*", 2);

            BuilderAddPrefData(&state, portName, 36);

        }

        BuilderAddPrefData(&state, moduleName, 32);

        BuilderAddPrefData(&state, &configurationDigest->fFraming, sizeof(configurationDigest->fFraming));

    // 'dtyp'

        if (isMacIP) {

            tmpUInt16 = kOTNoDeviceType;

        } else {

            tmpUInt16 = OTGetDeviceTypeFromPortRef(configurationDigest->fPortRef);

        }

        BuilderNewPref(&state, kOTCfgTCPDeviceTypePref, &tmpUInt16, sizeof(tmpUInt16));

    // 'stng'

        BuilderNewPref(&state, kOTCfgTCPLocksPref, zeros, sizeof(zeros));

    // 'isdm'

        if (configurationDigest->fSearchDomains != nil) {

            s = HGetState(configurationDigest->fSearchDomains);

            HLock(configurationDigest->fSearchDomains);

            BuilderNewPref(&state, kOTCfgTCPSearchDomainsPref, *configurationDigest->fSearchDomains, GetHandleSize(configurationDigest->fSearchDomains));

            HSetState(configurationDigest->fSearchDomains, s);

        } else if (forceDefaults) {

            tmpUInt16 = 0;

            BuilderNewPref(&state, kOTCfgTCPSearchDomainsPref, &tmpUInt16, sizeof(tmpUInt16));

        }

    // 'irte'

        if (configurationDigest->fRouterList != nil || forceDefaults) {

            UInt16 numRouters;

            UInt16 routerIndex;

            if (configurationDigest->fRouterList == nil) {

                numRouters = 0;

            } else {

                MoreAssertQ(GetHandleSize(configurationDigest->fRouterList) % sizeof(InetHost) == 0);

                numRouters = GetHandleSize(configurationDigest->fRouterList) / sizeof(InetHost);

            }

            BuilderNewPref(&state, kOTCfgTCPRoutersListPref, &numRouters, sizeof(numRouters));

            for (routerIndex = 0; routerIndex < numRouters; routerIndex++) {

                OTCfgTCPRoutersListEntry entry;

                entry.fToHost = 0;

                entry.fViaHost = (*((InetHost **) configurationDigest->fRouterList))[routerIndex];

                entry.fLocal = 0;

                entry.fHost = 0;

                BuilderAddPrefData(&state, &entry, sizeof(entry));

            }

        }

        err = BuilderDone(&state, packedPrefs);

    }

    return err;

}

static Boolean UnpackTCPSearchList(const UInt8 *data, ByteCount length, NSHTCPv4ConfigurationDigest *configurationDigest)

    // This routine is used to unpacked the TCP search list preference

    // (kOTCfgTCPSearchListPref == 'ihst').  The preference is a weird

    // combination of packed strings and straight data, so we have to

    // mess around a bit.  The routine returns true if it could

    // parse the data successfully; false if it found a formatting

    // error in the data.

{

    const UInt8 *cursor;

    UInt8 primaryInterfaceIndex;

    MoreAssertQ(data != nil);

    MoreAssertQ(configurationDigest != nil);

    cursor = data;

    if (cursor + sizeof(SInt8) <= data + length) {

        primaryInterfaceIndex = *cursor;

        cursor += sizeof(SInt8);

    }

    if (cursor + *cursor + 1 <= data + length) {

        BlockMoveData(cursor, configurationDigest->fLocalDomain, *cursor + 1);

        cursor += (*cursor + 1);

    }

    if (cursor + *cursor + 1 <= data + length) {

        BlockMoveData(cursor, configurationDigest->fAdminDomain, *cursor + 1);

        cursor += (*cursor + 1);

    }

    return (primaryInterfaceIndex == 1) && (cursor == data + length);

}

static void UnpackTCPPrefs(Ptr *buffer, NSHTCPv4ConfigurationDigest *configurationDigest)

    // This routine unpacks an interface from an 'iitf' (kOTCfgTCPInterfacesPref)

    // preference into the relevant fields of a NSHTCPv4ConfigurationDigest.

    // *buffer must point to the beginning

    // of the interface, ie two bytes into the pref data if

    // if you're extracting the first interface.  *buffer

    // is updated to point to the byte after the last byte

    // parsed, so you can parse multiple interfaces by

    // repeatedly calling this routine.  You can also

    // check *buffer to determine whether the routine

    // consumed all the data you expected, and hence whether

    // the preference is formatted correctly.

{

    UInt8 *cursor;

    cursor = (UInt8 *) *buffer;

    configurationDigest->fConfigMethod = *cursor;

    cursor += sizeof(UInt8);

    configurationDigest->fIPAddress = *((InetHost *) cursor);

    cursor += sizeof(InetHost);

    configurationDigest->fSubnetMask = *((InetHost *) cursor);

    cursor += sizeof(InetHost);

    // fAppleTalkZone is a Str32.  A longer string in the

    // 'iitf' is a bug in the person who wrote the code and

    // causes us to stop parsing.  The caller will notice that 

    // the cursor did not advance far enough and error out.

    if ( *cursor <= 32 ) {

        BlockMoveData(cursor, configurationDigest->fAppleTalkZone, *cursor + 1);

        cursor += (*cursor + 1);

        BlockMoveData(cursor, configurationDigest->fHintPortName, 36);

        cursor += 36;

        BlockMoveData(cursor, configurationDigest->fHintDriverName, 32);

        cursor += 32;

        configurationDigest->fFraming = *((UInt32 *) cursor);

        cursor += sizeof(UInt32);

    }

    *buffer = (Ptr) cursor;

}

static Boolean PortMatchesTCPv4Hints(const OTPortRecord *portRec, const NSHTCPv4ConfigurationDigest *hints)

    // This routine checks whether a particular port matches the set

    // of hints extracted from the TCP/IP preferences, and returns true

    // if it does.  The hints include:

    //

    //   a) the user-visible name of the port,

    //   b) the port name itself,

    //   c) the name of the module controlling the part, and

    //   d) the device type of the module controlling the port.

{

    Str255 userVisibleName;

    OTGetUserPortNameFromPortRef(portRec->fRef, userVisibleName);

    return      OTMemcmp(userVisibleName, hints->fHintUserVisiblePortName, userVisibleName[0] + 1)

            &&  OTStrEqual(portRec->fPortName, ((char *) hints->fHintPortName) + 1)

            &&  OTStrEqual(portRec->fModuleName, ((char *) hints->fHintDriverName) + 1)

            &&  OTGetDeviceTypeFromPortRef(portRec->fRef) == hints->fHintDeviceType;

}

static void ClearTCPv4ConfigurationDigest(NSHTCPv4ConfigurationDigest *configurationDigest)

    // Clear out the entire parameter block, preserving the handle-based fields.

{

    Handle saveRouterList;

    Handle saveDNSServerList;

    Handle saveSearchDomains;

    saveRouterList = configurationDigest->fRouterList;

    saveDNSServerList = configurationDigest->fDNSServerList;

    saveSearchDomains = configurationDigest->fSearchDomains;

    OTMemzero(configurationDigest, sizeof(configurationDigest));

    configurationDigest->fRouterList = saveRouterList;

    configurationDigest->fDNSServerList = saveDNSServerList;

    configurationDigest->fSearchDomains = saveSearchDomains;

}

static OSStatus BuildTCPv4ConfigurationDigestFromPackedPrefs(Handle packedPrefs,                                    

                                    NSHTCPv4ConfigurationDigest *configurationDigest)

    // This routine fills out a TCP/IP configuration digest

    // based on the packed preferences.  The basic algorithm

    // is to iterate through all the preferences, looking at

    // each one and putting the data from that preference into

    // the configuration digest.  At the end it does some jiggery

    // pokery that's explained in the comment down there.

{

    OSStatus err;

    SInt8 s;

    ByteCount cookie;

    OSType prefType;

    ByteCount prefSize;

    void *prefData;

    UInt16 numServers;

    UInt16 numRouters;

    UInt16 routerIndex;

    OTPortRecord portRec;

    MoreAssertQ(packedPrefs != nil);

    MoreAssertQ(configurationDigest != nil);

    ClearTCPv4ConfigurationDigest(configurationDigest);

    configurationDigest->fProtocol = kOTCfgTypeTCPv4;

    s = HGetState(packedPrefs);

    HLock(packedPrefs);

    err = noErr;

    cookie = 0;

    do {

        WriterGetNextPref(&cookie, *packedPrefs, &prefType, &prefData, &prefSize);

        switch (prefType) {

            case 0:

                // do nothing, this is the loop exit condition

                break;

        // 'pnam'

            case kOTCfgUserVisibleNamePref:

                if ( prefSize <= sizeof(Str255) && prefSize == ((UInt8 *)prefData)[0] + 1 ) {

                    BlockMoveData(prefData, configurationDigest->fConfigName, sizeof(Str255));

                } else {

                    err = -8;

                }

                break;

        // 'port'

            case kOTCfgPortUserVisibleNamePref:

                if ( prefSize <= sizeof(Str255) && prefSize == ((UInt8 *)prefData)[0] + 1 ) {

                    BlockMoveData(prefData, configurationDigest->fHintUserVisiblePortName, sizeof(Str255));

                } else {

                    err = -8;

                }

                break;

        // 'pwrd'

            case kOTCfgAdminPasswordPref:

                // do nothing, we can ignore password prefs

                break;

        // 'cvrs'

            case kOTCfgVersionPref:

                // do nothing, except check that it's what we expect

                if ( prefSize != sizeof(UInt16) || *((UInt16 *)prefData) != 1) {

                    err = -8;

                }

                break;

        // 'prot'

            case kOTCfgProtocolUserVisibleNamePref:

                // do nothing, except check it's TCP/IP

                if ( prefSize != OTStrLength(prefData) + 1 || ! OTStrEqual(prefData, gProtocolName) ) {

                    err = -8;

                }

                break;

        // 'unld'

            case kOTCfgTCPUnloadAttrPref:

                configurationDigest->fUnloadAttr = *((UInt16 *)prefData);

                if ( prefSize != sizeof(UInt16) 

                            || configurationDigest->fUnloadAttr < kOTCfgTCPActiveLoadedOnDemand

                            || configurationDigest->fUnloadAttr > kOTCfgTCPInactive ) {

                    err = -8;

                }

                break;

        // 'idns'

            case kOTCfgTCPDNSServersListPref:

                numServers = *((UInt16 *)prefData);

                if ( prefSize == sizeof(UInt16) + numServers * sizeof(InetHost) ) {

                    if (configurationDigest->fDNSServerList != nil) {

                        err = PtrToXHand( ((char *) prefData) + sizeof(UInt16), configurationDigest->fDNSServerList, prefSize - sizeof(UInt16));

                    }

                } else {

                    err = -8;

                }

                break;

        // 'ihst'

            case kOTCfgTCPSearchListPref:

                if ( ! UnpackTCPSearchList(prefData, prefSize, configurationDigest) ) {

                    err = -8;

                }

                break;

        // 'iitf'

            case kOTCfgTCPInterfacesPref:

                if ( prefSize >= sizeof(UInt16) && *((UInt16 *)prefData) == 1 ) {

                    Ptr cursor;

                    cursor = (Ptr) prefData;

                    cursor += sizeof(UInt16);

                    UnpackTCPPrefs(&cursor, configurationDigest);

                    if ( cursor != ((Ptr) prefData) + prefSize ) {

                        err = -8;

                    }

                } else {

                    err = -8;

                }

                break;

        // 'dtyp'

            case kOTCfgTCPDeviceTypePref:

                if (prefSize == sizeof(SInt16)) {

                    configurationDigest->fHintDeviceType = *((UInt16 *)prefData);

                } else {

                    err = -8;

                }

                break;

        // 'stng'

            case kOTCfgTCPLocksPref:

                // The pref should be of size 25, but I've seen

                // cases where it was set to 27.  I have no idea

                // what causes this, but seeing as the size (or

                // indeed the contents) doesn't matter for this

                // program, I decided to handle that case.

                if (prefSize != 25 && prefSize != 27) {

                    err = -8;

                }

                break;

        // 'isdm'

            case kOTCfgTCPSearchDomainsPref:

                if (prefSize >= sizeof(UInt16)) {

                    if ( configurationDigest->fSearchDomains != nil ) {

                        err = PtrToXHand(prefData, configurationDigest->fSearchDomains, prefSize);

                        if (err == noErr) {

                            if ( ! ValidStringListHandle( configurationDigest->fSearchDomains ) ) {

                                err = -8;

                            }

                        }

                    }

                } else {

                    err = -8;

                }

                break;

        // 'irte'

            case kOTCfgTCPRoutersListPref:

                numRouters = *((UInt16 *)prefData);

                if ( prefSize == sizeof(UInt16) + numRouters * sizeof(OTCfgTCPRoutersListEntry) ) {

                    if (configurationDigest->fRouterList != nil) {

                        SetHandleSize(configurationDigest->fRouterList, numRouters * sizeof(InetHost));

                        err = MemError();

                        if (err == noErr) {

                            OTCfgTCPRoutersList *prefRouterList;

                            InetHost *digestRouterList;

                            prefRouterList = (OTCfgTCPRoutersList *) prefData;

                            digestRouterList = (InetHost *) *configurationDigest->fRouterList;

                            for (routerIndex = 0; routerIndex < numRouters; routerIndex++) {

                                digestRouterList[routerIndex] = prefRouterList->fList[routerIndex].fViaHost;

                                // Should really check that the other fields of

                                // the OTCfgTCPRoutersListEntry are zero, but I can't be bothered

                                // right now.

                            }

                        }

                    }

                } else {

                    err = -8;

                }

                break;

            case kOTCfgUserModePref:            // user level

            case kOTCfgPrefWindowPositionPref:  // control panel window position

            case kOTCfgTCPDHCPClientIDPref:     // DHCP client ID

            case kOTCfgTCPDHCPLeaseInfoPref:    // DHCP persistent state

            case kOTCfgTCPPushBelowIPPref:      // below IP module

            case kOTCfgTCPPushBelowIPListPref:  // below IP module list (OT 2.5 and higher)

            case kOTCfgProtocolOptionsPref:     // wacky protocol options

            case 'vers':                        // occasionally you find these in TCP/IP configs, although they shouldn't be there

                // Known preferences which we don't need to pay

                // attention to but shouldn't cause the following

                // assert to trigger.

                break;

            default:

                // Unexpected preference type in the packed prefs.

                // This is not super-fatal, but let the developer know in debug builds.

                MoreAssertQ(false);

                break;

        }

    } while (err == noErr && prefType != 0);

    HSetState(packedPrefs, s);

    // Before we leave, we have to set up the fPortRef field of the

    // configuration digest.  This is a tricky business because the

    // port that we last used might have been removed, or ejected,

    // and replaced by another remarkably similar port.  So we

    // only set up fPortRef is *all* of the hints we extracted from

    // the preferences match the port we found.  Otherwise, we

    // leave fPortRef set to 0 and expect the client to do the

    // matching based on the hints.

    //

    // Except, of course, for MacIP, where the algorithm is completely

    // different, as always.

    if (err == noErr) {

        // Put a null byte after the last byte of these two hints.

        // We know we have the space because they're declared as

        // Str63s.  We need this for later string comparisons,

        // both here and in PortMatchesTCPv4Hints.

        configurationDigest->fHintPortName[configurationDigest->fHintPortName[0] + 1] = 0;

        configurationDigest->fHintDriverName[configurationDigest->fHintDriverName[0] + 1] = 0;

        // Translation of the below:

        //

        // if the driver name was "ddp" and AppleTalk is active,

        //   return the port ref of the active AppleTalk port

        // else if we have a port which exactly matches all the hints,

        //   return the port ref of that port

        // else

        //   return 0

        // end-if

        if (    ( OTStrEqual(((char *) configurationDigest->fHintDriverName) + 1, "ddp")

                    && OTFindPort(&portRec, "ddp1") )

             || ( OTFindPort(&portRec, ((char *) configurationDigest->fHintPortName) + 1)

                    && PortMatchesTCPv4Hints(&portRec, configurationDigest) ) ) {

            configurationDigest->fPortRef = portRec.fRef;

        } else {

            configurationDigest->fPortRef = kOTInvalidPortRef;

        }

    }

    return err;

}

/////////////////////////////////////////////////////////////////

#pragma mark ----- Remote Access Packer/Unpacker ------

// These routines convert between the Remote Access configuration digest

// (a big record with all the relevant fields in it) and the

// packed preferences data (which is read from or written to the

// preferences store).  These routines are shared between the

// preferences database and preferences file implementations.

static Boolean RemoteVersionAcceptable(UInt32 version)

    // This routine returns true if the version number passed

    // in indicates that the preference was written by a

    // version of Remote Access whose preferences we understand.

{

    return version == kOTCfgRemoteDefaultVersion || version == kOTCfgRemoteAcceptedVersion;

}

static OSStatus BuildPackedPrefsFromRemoteConfigurationDigest(

                                    const NSHRemoteConfigurationDigest *configurationDigest, 

                                    Boolean forceDefaults,

                                    Handle *packedPrefs)

    // This routine converts a Remote Access configuration digest

    // to a handle containing packed preferences.

    //

    // forceDefaults is not needed for Remote Access because the

    // only handle-based field is an optional preference.

{

    #pragma unused(forceDefaults)

    OSStatus err;

    PrefBuilderState state; 

    UInt8 buffer[600];

    UInt32 tmpUInt32;

    Str255 encodedPassword;

    Handle prefH;

    MoreAssertQ(configurationDigest != nil);

    MoreAssertQ(packedPrefs != nil);

    *packedPrefs = nil;

    err = noErr;

    if (err == noErr) {

        BuilderNew(&state);

    // 'pnam'

        BuilderNewPref(&state, kOTCfgUserVisibleNamePref, configurationDigest->fConfigName, configurationDigest->fConfigName[0] + 1);

    // 'conn'

        {

            OTCfgRemoteConnect *connectPtr;

            OTMemzero(buffer, sizeof(buffer));

            MoreAssertQ(sizeof(buffer) >= sizeof(OTCfgRemoteConnect));

            connectPtr = (OTCfgRemoteConnect *) buffer;

            connectPtr->version = kOTCfgRemoteDefaultVersion;

            connectPtr->isGuest = configurationDigest->fGuestLogin;

            connectPtr->canInteract = true;

            connectPtr->passwordSaved = configurationDigest->fPasswordValid;

            connectPtr->flashConnectedIcon = configurationDigest->fFlashIconWhileConnected;

            connectPtr->issueConnectedReminders = configurationDigest->fPromptToRemainConnected;

            connectPtr->reminderMinutes = configurationDigest->fPromptInterval;

            connectPtr->allowModemDataCompression = configurationDigest->fPPPAllowModemCompression;

            connectPtr->chatMode = configurationDigest->fPPPConnectMode;

            connectPtr->serialProtocolMode = configurationDigest->fSerialProtocol;

            connectPtr->addressLength = configurationDigest->fPhoneNumber[0];

            BlockMoveData(configurationDigest->fPPPConnectScriptName, connectPtr->chatScriptName, sizeof(Str63));

            if ( configurationDigest->fPPPConnectScript != nil ) {

                connectPtr->chatScriptLength = GetHandleSize(configurationDigest->fPPPConnectScript);

            }

            BuilderNewPref(&state, kOTCfgRemoteConnectPref, connectPtr, sizeof(*connectPtr));

        }

    // 'cusr'

        BuilderNewPref(&state, kOTCfgRemoteUserPref, configurationDigest->fUserName, configurationDigest->fUserName[0] + 1);

    // 'pass'

        err = NSHEncodeRemotePassword(configurationDigest->fUserName, configurationDigest->fPassword, encodedPassword);

        if (err == noErr) {

            BuilderNewPref(&state, kOTCfgRemotePasswordPref, encodedPassword, sizeof(Str255));

        } else {

            BuilderError(&state, err);

        }

    // 'cadr'

        BuilderNewPref(&state, kOTCfgRemoteAddressPref, &configurationDigest->fPhoneNumber[1], configurationDigest->fPhoneNumber[0]);

    // 'cdia'

        {

            OTCfgRemoteDialing *dialPtr;

            OTMemzero(buffer, sizeof(buffer));

            MoreAssertQ(sizeof(buffer) >= sizeof(OTCfgRemoteDialing));

            dialPtr = (OTCfgRemoteDialing *) buffer;

            dialPtr->version = kOTCfgRemoteDefaultVersion;

            dialPtr->fType = 'dial';

            dialPtr->dialMode = configurationDigest->fRedialMode;

            dialPtr->redialTries = configurationDigest->fRedialTimes;

            dialPtr->redialDelay = configurationDigest->fRedialDelay;

            BuilderNewPref(&state, kOTCfgRemoteDialingPref, dialPtr, sizeof(*dialPtr));

        }

    // 'cead'

        if ( configurationDigest->fRedialMode == kOTCfgRemoteRedialMainAndAlternate ) {

            tmpUInt32 = 0;

            BuilderNewPref(&state, kOTCfgRemoteAlternateAddressPref, &tmpUInt32, sizeof(tmpUInt32));

            BuilderAddPrefData(&state, configurationDigest->fAlternatePhoneNumber, sizeof(Str255));

        }

    // 'logo'

        {

            OTCfgRemoteLogOptions *logPtr;

            OTMemzero(buffer, sizeof(buffer));

            MoreAssertQ(sizeof(buffer) >= sizeof(OTCfgRemoteLogOptions));

            logPtr = (OTCfgRemoteLogOptions *) buffer;

            logPtr->version = kOTCfgRemoteDefaultVersion;

            logPtr->fType = 'lgop';

            logPtr->logLevel = configurationDigest->fVerboseLogging;

            BuilderNewPref(&state, kOTCfgRemoteLogOptionsPref, logPtr, sizeof(*logPtr));

        }

    // 'ipcp'

        {

            OTCfgRemoteIPCP *ipcpPtr;

            OTMemzero(buffer, sizeof(buffer));

            MoreAssertQ(sizeof(buffer) >= sizeof(OTCfgRemoteIPCP));

            ipcpPtr = (OTCfgRemoteIPCP *) buffer;

            ipcpPtr->version = kOTCfgRemoteDefaultVersion;

            ipcpPtr->reserved[0] = 'ipcp';

            ipcpPtr->maxConfig = 10;

            ipcpPtr->maxTerminate = 10;

            ipcpPtr->maxFailureLocal = 10;

            ipcpPtr->maxFailureRemote = 10;

            ipcpPtr->timerPeriod = 10000;

            ipcpPtr->localIPAddress = 0;

            ipcpPtr->remoteIPAddress = 0;

            ipcpPtr->allowAddressNegotiation = 1;

            ipcpPtr->idleTimerEnabled = configurationDigest->fDisconnectIfIdle;

            ipcpPtr->compressTCPHeaders = configurationDigest->fPPPAllowTCPIPHeaderCompression;

            ipcpPtr->idleTimerMilliseconds = configurationDigest->fDisconnectInterval;

            BuilderNewPref(&state, kOTCfgRemoteIPCPPref, ipcpPtr, sizeof(*ipcpPtr));

        }

    // 'cmsc'

        tmpUInt32 = kOTCfgRemoteDefaultVersion;

        BuilderNewPref(&state, kOTCfgRemoteClientMiscPref, &tmpUInt32, sizeof(tmpUInt32));

        tmpUInt32 = configurationDigest->fPPPConnectAutomatically;

        BuilderAddPrefData(&state, &tmpUInt32, sizeof(tmpUInt32));

    // 'ccha'

        if ( configurationDigest->fPPPConnectScript != nil ) {

            SInt8 s;

            s = HGetState(configurationDigest->fPPPConnectScript);

            HLock(configurationDigest->fPPPConnectScript);

            BuilderNewPref(&state, kOTCfgRemoteChatPref, *configurationDigest->fPPPConnectScript, GetHandleSize(configurationDigest->fPPPConnectScript));

            HSetState(configurationDigest->fPPPConnectScript, s);

        }

    // 'lcp '

        prefH = NSHGetDefaultPreference(kOTCfgTypeRemote, kOTCfgClassNetworkConnection, kOTCfgRemoteLCPPref);

        if (prefH != nil) {

            MoreAssertQ(GetHandleSize(prefH) == sizeof(gRemoteLCPValue));

            HLock(prefH);

            MoreAssertQ(MemError() == noErr);

            BuilderNewPref(&state, kOTCfgRemoteLCPPref, *prefH, GetHandleSize(prefH));

            DisposeHandle(prefH);

            MoreAssertQ(MemError() == noErr);

        } else {

            BuilderError(&state, resNotFound);

        }

    // 'arap'

        tmpUInt32 = kOTCfgRemoteDefaultVersion;

        BuilderNewPref(&state, kOTCfgRemoteARAPPref, &tmpUInt32, sizeof(tmpUInt32));

        OTMemzero(buffer, sizeof(buffer));

        OTStrCopy( (char *) buffer, "Script");

        BuilderAddPrefData(&state, buffer, 36);

    // 'x25 '

        {

            OTCfgRemoteX25 *x25Ptr;

            OTMemzero(buffer, sizeof(buffer));

            MoreAssertQ(sizeof(buffer) >= sizeof(OTCfgRemoteX25));

            x25Ptr = (OTCfgRemoteX25 *) buffer;

            x25Ptr->version = kOTCfgRemoteDefaultVersion;

            BuilderNewPref(&state, kOTCfgRemoteX25Pref, x25Ptr, sizeof(*x25Ptr));

        }

    // 'dass'

        tmpUInt32 = kOTCfgRemoteDefaultVersion;