Duplicate a system image onto 6 Different machines

Hello peoples,
Quick query. I work in a John Lewis shop in the UK, I've set one of our display imac's up to have all the demo content installed for Mac OS X Lion. But id rather not go around each machine and install everything again manually. What would you advise is the best way to create a system image that i can just install onto each of the other machines to the exact same state I have the one i've already done?
Is is best to clone the drive using carbon copy cloner? then just use system restore option from disk utilities? Will this work with the fact the macs have all different seriel numbers etc??
Thanks for your time
Nicholas Truby

As long as the machines are all the same model, you can Carbon Copy Cloner the master to a blank external hard drive then go around to each Mac and hold the option key down, boot off the external clone and clone the OS X partition of the clone to the internal OS X partition on the Mac's boot drive.
You could also use Firewire Target Disk Mode (hold T and boot) to make the target Mac's boot drive appear on the screen of the first Mac and use CCC that way as well.
Then the cloned machine can be used to clone to others etc., if you have a lot.
I read a article where someone cloned about 100 or so Mac Mini's this way from one master image

Similar Messages

  • How to restore mail files from Time Capsule onto a different machine?

    My Macbook Pro hard drive crashed, and I want to restore my backed-up mail files from Time Capsule onto my Desktop Mac (iMac 27").  When I try to restore by opening Time Capsule with Mail already open, I can only see the current mail files on the iMac (not the backed up files on the MacBook Pro), even when I point to the MacBook Pro backup file.

    Hello there, AngryMario.
    The following Knowledge Base article offers up how to restore mailboxes and content using Time Machine:
    Mail (Mountain Lion): Restore mailboxes and their content
    http://support.apple.com/kb/PH11713
    Thanks for reaching out to Apple Support Communities.
    Cheers,
    Pedro.

  • Uninstall and reinstall onto a different machine

    we have a machine at work which had ps cs4 installed. i have ran a belarc audit on the machine and got a licence key, but i need to uninstall and remove from the machine which is no longer needed and install onto a new laptop. i am unable to lcoate a cs4 trial, or confirm a best practice to get the cs4 onto the new laptop.
    can anyone assist?

    You can install the software on as many machines as you like.  The important tjhing that you need to manage is the activations.  You are allowed to have two activations for a single user license.  If you have the siioftware working on two machines already, then you have to deactivate one of them in order to free up an activation for the new machine.
    Uninstalling does not deactivate the software, so if you uninstall you lose the ability to perform the deactivation.
    To deactivate you normally just need to open an application in the suite and choose Help -> Deactivate.

  • How do I select an image with motion blur so that I can put it onto a different background ?

    How do I overlay a image with motion blur on a white background (like the first image) onto a different background (to look like the second image)? any help would be greatly appreciated, many thanks ,ed
    Message was edited by: motoredd

    I’m afraid you may have bitten off more than you might want to chew.
    The resulting pixels of an in-camera-blur combine information about the color/brightness of back- and foreground (edit: the result of surface properties and lighting conditions) with motion (basically transparency for this task) in such a way that it seems exceedingly difficult (maybe even improssible) to isolate the foreground in a »pure« form.
    One may get a halfway decent mask (as the backgound is at least almost uniform and brighter than the foreground elements) but you may have to manually decontaminate the transparent areas, otherwise the masked object in front of a dark background would have a bright edge.

  • Folio13 Windows 7 pro 64, system image, restore fails

    I have (10) HP Folio13, running Windows 7 pro 64, I have used the Windows 7 system tools, to create a system image onto a USB 2.0 external Seagate harddrive. It created fine.. to test it I tried to restore the image onto a different HP Folio13.
    I hooked up an external USB cd-rom/dvd reader/write to either USB ports, and the USB Seagate hard drive to the other free USB port, thats on the HP Folio13. and I'm using a Windows 7 system restore disc.  If the USB cd/dvd write is hooked up to the USB port on the left hand side, it crashes stating it can't find the x:\sources\recovery\tools\hp recovery manager.exe this application has request the runtime to terminate it in an unsual way please contact the application support team for more infomation, if i shutdown and place the cd/dvd drive into the USB port on the right hand side. it works.. and boots correctly but can't find the Windows system image, that exists on the USB external harddrive.  I know that the USB windows system image is valid.. I was able to restore it too a differnet HP laptop a 8560w.. with the same boot disk, but since the HP 8560w has a built in cd reader.. all works well.  I have updated the BIOS to the lastest as of today (F.18) I have updated the USB drivers, I have tired using F11 on the HP Folio and tried to restore it from that, but what comes up, does not support a system image restore, F11 only works for system restores..  I need some aid.. I have a valid Windows 7 system image on a external USB 2.0 hard drive. I would like to restore it to a HP Folio13.

    Hello canadianguy2,
    Your Folio13 is a Business model.  Your issue would be best answered on the HP Enterprise Business Community Forum
    Good luck!
    ↙-----------How do I give Kudos?| How do I mark a post as Solved? ----------------↓

  • System Image Recovery on Win 7 - Spectre XT 13

    There is no issue of creating a system image onto my seagate external Freeagent goflex hard disk. However, an issue is encountered during the restoring process in which the USB3.0 port turned out to be unavailable during pre-boot.
    The solution I discovered is to plug the hard disk onto the USB2.0 port. I hope this will save someone several hours of trying to figure out where goes wrong.

    Yes, that is a known issue that affects several recovery softwares including HP's
    http://h10025.www1.hp.com/ewfrf/wc/document?docname=c02906094&cc=us&dlc=en&lc=en

  • HP G62293sa - attemp to create system image has failed ....

    HP Pavilion G62293sa
    Windows 8
    I've just attempted to create a system image onto a Seagate external drive. There's plenty of space ... about 480GB. I knew something wasn't quite right when it only took around 20mins and then asked if I wanted to create a repair disc. When I checked the Seagate ... the 'Windowsbackupimage folder' size was only 4kb. And why does it keep telling me I don't have permission to access this folder when I try to open it ... then it opens anyway? I had an 8GB USB on hand to create the repair disc but it won't allow me to use a USB ... just keeps suggesting I use the DVD drive. I thought you could create a repair disc on a blank USB. If memory serves, I did create some sort of HP system recovery on about 4 disks when I first bought the laptop back in February. Is that the same as 'creating a repair disc'??
    Could someone give me suggestions on how to create a system image successfully on my external drive. I've no idea why it's failed.
    Thanks
    not tech minded btw ... if that isn't obvious )

    3 free imaging softwares that have been recommended by members here:. There are others of course. http://www.aomeitech.com/download.html http://www.macrium.com/reflectfree.aspx  (I have used this) https://www.paragon-software.com/home/br-free/ http://h30434.www3.hp.com/t5/Notebook-Operating-Systems-and-Software/Custom-Recovery-Options/m-p/329260#M45230

  • Can't Extract Files from System Image DVD

    I recently created a Windows 7 system image onto DVD-RWs as my HDD was suspect.  The HDD was replaced under warranty. When I came to restore the system image I got up to the fourth DVD and the process would not go any further (could not read the DVD).
    I then tried to extract some of the more important files from the first three disks that the restore process had read successfully.  I used the AttachVHD option under Computer management however for every .vhd file which I tried to attach I received a "The file or directory is corrupted anf unreadable" error message from the Virtual Disk Manager.
    I also tried 7-Zip to extract files but received the message "Can not open file as archive" each time.
    Can any one throw any light on why I can't read these .vfd files?

    marckelli
    Only last night a user went through the same situation as you are going through. Details are important. For now I am assuming that your computer is Windows 7, 8, or 8.1 64 bit. If other post immediately to let me know.
    1. You need two files from Adobe, one .exe and the other .7z. If you have a 64 bit computer operating system
    make sure the you see 64 in the name of the file.
    2. Assure that you have antivirus and firewall disabled.
    3. Right click the .exe file and select Run As Administrator. The double click the .exe to Run it. This will lead
    you into the 7z which is the program.
    If the desktop is not working as the destination for the Adobe Premiere Elements 12 Folder which will be present after the 7z has completed, then set it to Documents.
    In the Adobe Premiere Elements 12 Folder, double click the PRE12 Folder to find the Setup.exe from which you will
    install the program.
    I will be back in a moment to add the link to last night's thread where we went through what you are going through now.
    Make sure at the onset that you have the right files to be used with your specific operating system.
    ATR
    Add On...This is last night's thread on this type of issue
    Premeire elements 12 will only download as files...

  • System Image Utility - universal_boot option only on Intel machines

    I'm using System Image Utility on 1.8 GHz PowerPC G5 running Mac OS X Server version 10.5.2. When I try to create a NetBoot image with the standard settings (no customization) and a Mac OS X 10.5 Install DVD, I get the following message:
    updatedyld_sharedcache failed: universal_boot option can only be used on intel machines
    The rest of the log is below; any help you can provide would be appreciated. Thanks!
    Log:
    Starting image creation.
    Workflow Started (2008-05-16 16:05:27 -0500)
    Starting action: Define Image Source
    Finished running action: Define Image Source
    Starting action: Add User Account
    Finished running action: Add User Account
    Starting action: Create Image
    Starting image creation process...
    Create NetBoot Image
    created: /Users/[username]/Documents/NetBoot of Mac OS X Install DVD/NetBoot.dmg
    installer: Package name is Mac OS X
    installer: Installing at base path /tmp/mnt
    installer: The install was successful.
    updatedyld_sharedcache failed: universal_boot option can only be used on Intel machines
    hdiutil: couldn't eject "disk3" - error 49168
    "disk3" unmounted.
    Script is done.
    NetBoot creation failed.
    Image creation process finished...
    Stopping image creation.
    Image creation failed.

    Here's the contents of the Debug log; I couldn't find where the problem was, but maybe someone can help. (I'm also not sure how to keep the discussion board from translating some of the code to markup). Thanks!
    Starting image creation.
    Workflow Started (2008-05-19 16:42:42 -0500)
    Starting action: Define Image Source
    Finished running action: Define Image Source
    Starting action: Add User Account
    Finished running action: Add User Account
    Starting action: Create Image
    Starting image creation process...
    Create NetBoot Image
    progressPrefix="_progress"
    ++ progressPrefix=_progress
    scriptsDebugKey="DEBUG"
    ++ scriptsDebugKey=DEBUG
    imageIsUDIFKey="1"
    ++ imageIsUDIFKey=1
    mountPoint="/tmp/mnt"
    ++ mountPoint=/tmp/mnt
    ownershipInfoKey="1000:20"
    ++ ownershipInfoKey=1000:20
    dmgTarget="NetBoot"
    ++ dmgTarget=NetBoot
    sourceVol="/Volumes/Mac OS X Install DVD"
    ++ sourceVol='/Volumes/Mac OS X Install DVD'
    export CM_BUILD="CM_BUILD"
    ++ export CM_BUILD=CM_BUILD
    ++ CM_BUILD=CM_BUILD
    userLanguage[0]="English"
    ++ userLanguage[0]=English
    userIsAdmin[0]="1"
    ++ userIsAdmin[0]=1
    userImagePath[0]="/Library/User Pictures/Nature/Cactus.tif"
    ++ userImagePath[0]='/Library/User Pictures/Nature/Cactus.tif'
    export _com_apple_kextd_skiplocks="1"
    ++ export _com_apple_kextd_skiplocks=1
    ++ _com_apple_kextd_skiplocks=1
    userPassHash[0]="000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000006A29520ED4FE4E8C7DE0930018E9284B1078E0BB4CF77F870000000 000000000000
    00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000"
    ++ userPassHash[0
    ]=000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000006A29520ED4FE4E8C7DE0930018E9284B1078E0BB4CF77F870000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000
    00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000
    userFullName[0]="[user full name]"
    ++ userFullName[0]='[user full name]'
    destPath="/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD"
    ++ destPath='/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD'
    userUnixName[0]="[user short name]"
    ++ userUnixName[0]=[user short name]
    . "$1/createCommon.sh"
    + . /tmp/niutemp.mdOQAzsJ/createCommon.sh
    # createCommon.sh
    # Common functionality for the Image creation process.
    # sourced in by the various SIU scripts
    # Copyright 2007 Apple Inc. All rights reserved.
    # Using dscl, create a user account
    AddLocalUser()
    # $1 long name
    # $2 short name
    # $3 isAdminUser key
    # $4 password hash
    # $5 user picture path
    # $6 Language string
    local databasePath="/Local/Target/Users/${2}"
    # Find a free UID between 501 and 599
    for ((i=501; i<600; i++)); do
    output=`/usr/bi
    n/dscl -f "${mountPoint}/var/db/dslocal/nodes/Default" localonly -search /Local/Target/Users UniqueID $i`
    # If there is already an account dscl returns it, so we're looking for an empty return value.
    if [ "$output" == "" ]; then
    break
    fi
    done
    # Create the user record
    /usr/bin/dscl -f "${mountPoint}/var/db/dslocal/nodes/Default" localonly -create $databasePath || exit 1
    # Add long name
    /usr/bin/dscl -f "${mountPoint}/var/db/dslocal/nodes/Default" localonly -append $databasePath RealName "${1}" || exit 1
    # Add PrimaryGroupID
    if [ "${3}" == 1 ]; then
    /usr/bin/dscl -f "${mountPoint}/var/db/dslocal/nodes/Default" localonly -append $databasePath PrimaryGroupID 80 || exit 1
    else
    /usr/bin/dscl -f "${mountPoint}/var/db/dslocal/nodes/Default" localonly -append $databasePath PrimaryGroupID 20 || exit 1
    fi
    # Add UniqueID
    /usr/bin/dscl -f "${mountPoint}/var/db/dslocal/nodes/Default" localonly -append $databasePath UniqueID ${i} || exit 1
    # Add Home Directory entry
    /usr/bin/dscl -f "${mountP
    oint}/var/db/dslocal/nodes/Default" localonly -append $databasePath dsAttrTypeNative:home /Users/${2} || exit 1
    /usr/bin/dscl -f "${mountPoint}/var/db/dslocal/nodes/Default" localonly -append $databasePath authentication_authority ";ShadowHash;" || exit 1
    /usr/bin/dscl -f "${mountPoint}/var/db/dslocal/nodes/Default" localonly -append $databasePath picture "${5}" || exit 1
    /usr/bin/dscl -f "${mountPoint}/var/db/dslocal/nodes/Default" localonly -append $databasePath passwd "*" || exit 1
    # Add shell
    /usr/bin/dscl -f "${mountPoint}/var/db/dslocal/nodes/Default" localonly -append $databasePath UserShell "/bin/bash" || exit 1
    # lookup generated uid
    genUID=`/usr/bin/dscl -f "${mountPoint}/var/db/dslocal/nodes/Default" localonly -read /Local/Target/Users/${2} GeneratedUID` || exit 1
    genUID=${genUID:14:36}
    # make sure the shadow/hash directory exists
    if [ ! -e "${mountPoint}/var/db/shadow/hash" ] ; then
    /bin/mkdir -p "${mountPoint}/var/db/shadow/hash" || exit 1
    /bin/chmod -R 700 "${mountPoint}/var/
    db/shadow" || exit 1
    fi
    # to copy our password hash in there...
    echo "${4}" > "${mountPoint}/var/db/shadow/hash/$genUID"
    /bin/chmod 600 "${mountPoint}/var/db/shadow/hash/$genUID" || exit 1
    # Create Home directory
    if [ -e "/System/Library/User Template/${6}.lproj/" ]; then
    /usr/bin/ditto "/System/Library/User Template/${6}.lproj/" "${mountPoint}/Users/${2}" || exit 1
    else
    /usr/bin/ditto "/System/Library/User Template/English.lproj/" "${mountPoint}/Users/${2}" || exit 1
    fi
    /usr/sbin/chown -R $i:$i "${mountPoint}/Users/${2}" || exit 1
    # If they exist, apply any Append.bom changes
    ApplyAppendBom()
    local tempDir="$1"
    local srcVol="$2"
    local opt=""
    if [ "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    if [ -e "$tempDir/Append.bom" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Applying Append.bom additions from System Image Utility"
    fi
    /usr/bin/ditto $opt -bom "$tempDir/Append.bom" "$srcVol" "${mountPoint}" || exit
    1
    fi
    if [ -e "$srcVol/Library/Application Support/Apple/System Image Utility/Append.bom" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Applying Append.bom additions from $srcVol"
    fi
    /usr/bin/ditto $opt -bom "$srcVol/Library/Application Support/Apple/System Image Utility/Append.bom" "$srcVol" "${mountPoint}" || exit 1
    fi
    # Copies a list of packages (full paths contained in the file at $1) from source to .../System/Installation/Packages/
    CopyPackagesFromFile()
    local theFile="$1"
    local opt=""
    if [ "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    while read FILE
    do
    if [ -e "${FILE}" ]; then
    local leafName=`basename "${FILE}"`
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Copying ${FILE}."
    fi
    /usr/bin/ditto $opt "${FILE}" "${mountPoint}/System/Installation/Packages/${leafName}" || exit 1
    fi
    done < "
    local opt=""
    if [ "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    while read FILE
    do
    if [ -e "${FILE}" ]; then
    local leafName=`basename "${FILE}"`
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Copying ${FILE}."
    fi
    read SUB_PATH
    /usr/bin/ditto $opt "${FILE}" "${mountPoint}/System/Installation/Packages/${SUB_PATH}${leafName}" || exit 1
    fi
    done < "${theFile}"
    # Create the dyld shared cache files
    CreateDyldCaches()
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Creating dyld shared cache files"
    if [ "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-debug"
    fi
    fi
    /usr/bin/update_dyld_shared_cache -root "${mountPoint}" -universal_boot -force $opt
    # Validate or create the destination directory and mo
    unt point
    CreateOrValidateDestination()
    local destDir="$1"
    if [ ! -d "$destDir" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Creating working path at $destDir"
    fi
    /bin/mkdir -p "$destDir" || exit 1
    fi
    # Create mount point
    if [ ! -d "${mountPoint}" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Creating mountpoint for in $destDir"
    fi
    /bin/mkdir -p "${mountPoint}" || exit 1
    fi
    # If any exist, apply any user accounts
    CreateUserAccounts()
    local count="${#userFullName[*]}"
    if [ $count -gt 0 ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Adding $count user account(s) to the image"
    fi
    for ((index=0; index<$count; index++)); do
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Adding user ${userFullName[$index]}"
    fi
    #lay down user here
    AddLocalUser "${userFullN
    ame[$index]}" "${userUnixName[$index]}" "${userIsAdmin[$index]}" "${userPassHash[$index]}" "${userImagePath[$index]}" "${userLanguage[$index]}"
    done
    fi
    # Create an installer package in /System/Installation/Packages/ wrapping the supplied script
    InstallerPackageFromScript()
    local tempDir="$1"
    local scriptPath="$2"
    local scriptName=`basename "${scriptPath}"`
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Create installer for script $scriptName"
    if [ "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    fi
    # shouldn't exist on entry...
    if [ -e "${tempDir}/emptyDir" ]; then
    /bin/rm -rf "${tempDir}/emptyDir"
    fi
    # make some directories to work in
    /bin/mkdir $opt -p "${tempDir}/$scriptName.pkg/Contents/Resources"
    /bin/mkdir $opt "${tempDir}/emptyDir" || exit 1
    cd "${tempDir}/emptyDir"
    # Create Archive.pax.gz
    /bin/pax -w -x cpio -f "$tempDir/$scriptName.pkg/Contents/Archive.pax" .
    /usr/bin/gzip "$tempDir/$scriptName.pkg
    /Contents/Archive.pax"
    # Create the Archive.bom file
    /usr/bin/mkbom "$tempDir/emptyDir/" "$tempDir/$scriptName.pkg/Contents/Archive.bom"
    # Create the Info.plist
    /bin/cat > "$tempDir/$scriptName.pkg/Contents/Info.plist" << END
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
    <plist version="1.0">
    <dict>
    <key>CFBundleIdentifier</key>
    <string>com.apple.server.SystemImageUtility.$scriptName</string>
    <key>CFBundleShortVersionString</key>
    <string>1</string>
    <key>IFMajorVersion</key>
    <integer>1</integer>
    <key>IFMinorVersion</key>
    <integer>0</integer>
    <key>IFPkgFlagDefaultLocation</key>
    <string>/tmp</string>
    <key>IFPkgFlagInstallFat</key>
    <false/>
    <key>IFPkgFlagIsRequired</key>
    <false/>
    <key>IFPkgFormatVersion</key>
    <real>0.10000000149011612</real>
    </dict>
    </plist>
    END
    echo "pkmkrpkg1" > "$tempDir/$scriptName.pkg/Contents/PkgInfo"
    echo "major: 1\nminor: 0" > "$tempDir/$scriptName
    .pkg/Contents/Resources/package_version"
    # Copy the script
    /bin/cp "$scriptPath" "$tempDir/$scriptName.pkg/Contents/Resources/postflight"
    # copy the package to the Packages directory
    /usr/bin/ditto $opt "$tempDir/$scriptName.pkg" "${mountPoint}/System/Installation/Packages/$scriptName.pkg" || exit 1
    # clean up
    /bin/rm -r "$tempDir/emptyDir"
    /bin/rm -r "$tempDir/$scriptName.pkg"
    # If restoreDSBindings.sh exists, tar up the DS data and install it all onto the install image
    InstallLocalDSBindings()
    local tempDir="$1"
    local niuTempDir="var/tmp/niu"
    local scriptDir=${niuTempDir}/postinstall
    local opt=""
    if [ -e "$tempDir/restoreDSBindings.sh" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Installing Directory Service bindings from this computer"
    if [ "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    fi
    # make the directory if needed
    /bin/mkdir -p $opt "${mountPoint}/${scriptDir}" || exit 1
    # tar up the Directory
    Service settings
    /usr/bin/tar $opt -cf "${mountPoint}/${niuTempDir}/DSBindings.tar" /Library/Preferences/DirectoryService/ || exit 1
    /usr/bin/ditto $opt "$tempDir/restoreDSBindings.sh" "${mountPoint}/${scriptDir}/restoreDSBindings.sh" || exit 1
    # Set the permissions just in case
    /usr/sbin/chown root:wheel "${mountPoint}/${scriptDir}/restoreDSBindings.sh"
    /bin/chmod 755 "${mountPoint}/${scriptDir}/restoreDSBindings.sh"
    # make an installer package out of the script
    InstallerPackageFromScript "$tempDir" "$tempDir/restoreDSBindings.sh"
    fi
    # If it exists, install the PowerManagement.plist onto the install image
    InstallPowerManagementPlist()
    local tempDir="$1"
    local opt=""
    if [ -e "$tempDir/com.apple.PowerManagement.plist" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Installing progress announcer to install image"
    if [ "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    fi
    /usr/bin/ditto $opt "$tempDir/com.app
    le.PowerManagement.plist" "${mountPoint}/Library/Preferences/SystemConfiguration/com.apple.PowerManagemen t.plist" || exit 1
    /usr/sbin/chown root:wheel "${mountPoint}/Library/Preferences/SystemConfiguration/com.apple.PowerManagemen t.plist"
    /bin/chmod 644 "${mountPoint}/Library/Preferences/SystemConfiguration/com.apple.PowerManagemen t.plist"
    fi
    # If it exists, install the InstallerStatusNotifications.bundle and progress emitter onto the install image
    InstallProgressPieces()
    local tempDir="$1"
    local opt=""
    if [ -e "$tempDir/InstallerStatusNotifications.bundle" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Installing progress announcer to install image"
    if [ "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    fi
    /usr/bin/ditto $opt "$tempDir/InstallerStatusNotifications.bundle" "${mountPoint}/System/Library/CoreServices/InstallerStatusNotifications.bundle" || exit 1
    /usr/sbin/chown -R root:wheel "${mountPoint}/System/Lib
    rary/CoreServices/InstallerStatusNotifications.bundle"
    /bin/chmod 755 "${mountPoint}/System/Library/CoreServices/InstallerStatusNotifications.bundle"
    fi
    if [ -e "$tempDir/com.apple.ProgressEmitter.plist" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Installing status emitter to image"
    fi
    /usr/bin/ditto $opt "$tempDir/progress_emitter" "${mountPoint}/usr/sbin/progress_emitter" || exit 1
    /usr/sbin/chown root:wheel "${mountPoint}/usr/sbin/progress_emitter"
    /bin/chmod 555 "${mountPoint}/usr/sbin/progress_emitter"
    /usr/bin/ditto $opt "$tempDir/com.apple.ProgressEmitter.plist" "${mountPoint}/System/Library/LaunchDaemons/com.apple.ProgressEmitter.plist" || exit 1
    /usr/sbin/chown root:wheel "${mountPoint}/System/Library/LaunchDaemons/com.apple.ProgressEmitter.plist"
    /bin/chmod 644 "${mountPoint}/System/Library/LaunchDaemons/com.apple.ProgressEmitter.plist"
    fi
    # Converts a list of scripts (full paths contained in the file at $1) into pa
    ckages in .../System/Installation/Packages/
    InstallScriptsFromFile()
    local tempDir="$1"
    local theFile="$2"
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Converting scripts into install packages"
    fi
    while read FILE
    do
    if [ -e "${FILE}" ]; then
    # make an installer package out of the script
    InstallerPackageFromScript "$tempDir" "${FILE}"
    fi
    done < "
    local destDir="$2"
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Performing post install cleanup"
    if [ "${scriptsDebugKey}" == "DEBUG" ] ; then
    opt="-v"
    fi
    fi
    # delete the DS indices to force reindexing...
    if [ -e "${mountPoint}/var/db/dslocal/indices/Default/index" ]; then
    /bin/rm $opt "${mountPoint}/var/db/dslocal/indices/Default/index"
    fi
    if [ "${scriptsDebugKey}" == "VERBO
    SE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Detaching disk image"
    fi
    /usr/bin/hdiutil detach "${mountPoint}" || exit 1
    # remove the mount folder
    /bin/rmdir "${mountPoint}" || exit 1
    # copy the NBImageInfo.plist file
    /usr/bin/ditto $opt "$tempDir/NBImageInfo.plist" "$destDir/NBImageInfo.plist" || exit 1
    echo "Correcting permissions. ${ownershipInfoKey} $destDir"
    /usr/sbin/chown -R "${ownershipInfoKey}" "$destDir"
    # rename the folder to .nbi
    if [ ! -e "$destDir.nbi" ]; then
    /bin/mv $opt "$destDir" "$destDir.nbi" || exit 1
    else
    local parentDir=`dirname "${destDir}"`
    local targetName=`basename "${destDir}"`
    for ((i=2; i<1000; i++)); do
    if [ ! -e "${parentDir}/${targetName}_$i.nbi" ]; then
    /bin/mv $opt "$destDir" "${parentDir}/${targetName}_$i.nbi" || exit 1
    break
    fi
    done
    fi
    # Prepare the source by deleting stuff we don't want to copy if sourcing a volume
    PreCleanSource()
    local srcVol="$1"
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${
    scriptsDebugKey}" == "DEBUG" ]; then
    if [ "${scriptsDebugKey}" == "DEBUG" ] ; then
    opt="-v"
    fi
    fi
    if [ -e "$srcVol/private/var/vm/swapfile*" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Removing swapfiles on $1"
    fi
    /bin/rm $opt "$srcVol/private/var/vm/swapfile*"
    fi
    if [ -d "$srcVol/private/tmp" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Cleaning out /private/tmp on $1"
    fi
    /bin/rm -r $opt "$srcVol/private/tmp/*"
    fi
    if [ -d "$srcVol/private/var/tmp" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Cleaning out /private/var/tmp on $1"
    fi
    /bin/rm -r $opt "$srcVol/private/var/tmp/*"
    fi
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Cleaning out devices and volumes on $1"
    fi
    if [ -d "$srcVol/Volumes" ]; then
    /bin/rm -r $opt "$srcVol/Volumes/*"
    fi
    if [ -d "$srcVol/dev" ]; t
    hen
    /bin/rm $opt "$srcVol/dev/*"
    fi
    if [ -d "$srcVol/private/var/run" ]; then
    /bin/rm -r $opt "$srcVol/private/var/run/*"
    fi
    # Copy kernel and build the kext cache on the boot image
    PrepareKernelAndKextCache()
    local destDir="$1"
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Preparing the kernel and kext cache for the boot image"
    if [ "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    fi
    for ARCH in i386 ppc; do
    # Prepare the kernel
    /bin/mkdir $opt "$destDir/${ARCH}" || exit 1
    /usr/bin/lipo -extract "${ARCH}" "${mountPoint}/mach_kernel" -output "$destDir/${ARCH}/mach.macosx" || exit 1
    # Build kext cache
    /usr/sbin/kextcache -a ${ARCH} -s -l -n -z -m "$destDir/${ARCH}/mach.macosx.mkext" "${mountPoint}/System/Library/Extensions" || exit 1
    done
    # Create the PPC and I386 boot loaders on the boot image
    PrepareBootLoader()
    local srcVol="$1"
    local destDir="$2"
    local opt=""
    if [ "${scriptsDebugKey}
    " == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Preparing boot loader"
    if [ "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    fi
    if [ -e "${mountPoint}/usr/standalone/ppc/bootx.bootinfo" ]; then
    /usr/bin/ditto $opt "${mountPoint}/usr/standalone/ppc/bootx.bootinfo" "$destDir/ppc/booter" || exit 1
    /usr/bin/ditto $opt "${mountPoint}/usr/standalone/i386/boot.efi" "$destDir/i386/booter" || exit 1
    else
    /usr/bin/ditto $opt "$srcVol/usr/standalone/ppc/bootx.bootinfo" "$destDir/ppc/booter" || exit 1
    /usr/bin/ditto $opt "$srcVol/usr/standalone/i386/boot.efi" "$destDir/i386/booter" || exit 1
    fi
    # If it exists, install the partitioning application and data onto the install image
    ProcessAutoPartition()
    local tempDir="$1"
    local opt=""
    if [ -e "$tempDir/PartitionInfo.plist" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Installing Partitioning application and data to install image"
    if [ "${scriptsDebugKey}" ==
    "DEBUG" ]; then
    opt="-v"
    fi
    fi
    /usr/bin/ditto $opt "$tempDir/PartitionInfo.plist" "${mountPoint}/System/Installation/PartitionInfo.plist" || exit 1
    /usr/bin/ditto $opt "$tempDir/AutoPartition.app" "${mountPoint}/System/Installation/AutoPartition.app" || exit 1
    # Tell the installer to run the Partitioning application
    /bin/echo "#!/bin/sh
    /System/Installation/AutoPartition.app/Contents/MacOS/AutoPartition" > "${mountPoint}/private/etc/rc.cdrom.postWS"
    # Due to the way rc.install sources the script, it needs to be executable
    /usr/sbin/chown root:wheel "${mountPoint}/private/etc/rc.cdrom.postWS"
    /bin/chmod 755 "${mountPoint}/private/etc/rc.cdrom.postWS"
    fi
    # If it exists, install the minstallconfig.xml onto the install image
    ProcessMinInstall()
    local tempDir="$1"
    local opt=""
    if [ -e "$tempDir/minstallconfig.xml" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Installing minstallconfig.xml to install image"
    if
    [ "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    fi
    /usr/bin/ditto $opt "$tempDir/minstallconfig.xml" "${mountPoint}/etc/minstallconfig.xml" || exit 1
    /usr/sbin/chown root:wheel "${mountPoint}/etc/minstallconfig.xml"
    /bin/chmod 644 "${mountPoint}/etc/minstallconfig.xml"
    fi
    # untar the OSInstall.mpkg so it can be modified
    untarOSInstallMpkg()
    local tempDir="$1"
    local opt=""
    # we might have already done this, so check for it first
    if [ ! -d "${tempDir}/OSInstall_pkg" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "uncompressing OSInstall.mpkg"
    if [ "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    fi
    /bin/mkdir "${tempDir}/OSInstall_pkg"
    cd "${tempDir}/OSInstall_pkg"
    /usr/bin/xar $opt -xf "${mountPoint}/System/Installation/Packages/OSInstall.mpkg"
    # make Distribution writeable
    /bin/chmod 777 "${tempDir}/OSInstall_pkg"
    /bin/chmod 666 "${tempDir}/OSInstall_pkg/Distribution"
    fi
    handler (
    echo "Terminated. Cleaning up. Unmounting $destPath"
    /usr/bin/hdiutil detach "${mountPoint}"
    /bin/rmdir "${mountPoint}"
    /bin/rm -r "$destPath"
    exit
    trap "handler" TERM INT
    + trap handler TERM INT
    # Set up for script debugging
    debug_opt=""
    + debug_opt=
    if [ "${scriptsDebugKey}" == "DEBUG" ]; then
    debug_opt="-v"
    fi
    + '[' DEBUG == DEBUG ']'
    + debug_opt=-v
    # Prepare the destination
    CreateOrValidateDestination "$destPath"
    + CreateOrValidateDestination '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD'
    + local 'destDir=/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD'
    + '[' '!' -d '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD' ']'
    + '[' DEBUG == VERBOSE -o DEBUG == DEBUG ']'
    + echo 'Creating working path at /Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD'
    Creating working path at /Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD
    + /bin/mkdir -p '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD'
    + '[' '!' -d /tmp/mnt ']'
    # update progress i
    nformation
    echo "${progressPrefix}_creatingImage_"
    + echo
    # Create the appropriate disk image type
    imageExtension="sparseimage"
    + imageExtension=sparseimage
    if [ "${imageIsUDIFKey}" == 1 ]; then
    tempsize=""
    # if installing from DVD, get the max install size, otherwise use the volume size
    if [ -e "${sourceVol}/System/Installation/Packages/OSInstall.mpkg" ]; then
    /usr/sbin/installer -plist -verbose -pkginfo -pkg "${sourceVol}/System/Installation/Packages/OSInstall.mpkg" > "$1/OSInstall.plist"
    tempsize=`/usr/bin/defaults read "$1/OSInstall" Size`
    tempsize=$((tempsize/1024))
    else
    tempsize=`df -m "$sourceVol" | tail -n 1 | awk '{print $3}'`
    fi
    # Add one percent for safety, 500MB for the dyld caches and 400MB to eliminate the "disk is almost full" message
    size=$(($tempsize+$(($tempsize/100))+900))
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Creating disk image (Size: $size MB)"
    fi
    # Create and atta
    ch disk image
    /usr/bin/hdiutil create "$destPath/$dmgTarget" -megabytes $size -volname "$dmgTarget" -uid 0 -gid 80 -mode 1775 -layout "UNIVERSAL CD" -fs HFS+ -stretch 500g -ov || exit 1
    imageExtension="dmg"
    else
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Creating sparse disk image"
    fi
    /usr/bin/hdiutil create "$destPath/$dmgTarget" -type SPARSE -size 500g -volname "$dmgTarget" -uid 0 -gid 80 -mode 1775 -layout "UNIVERSAL CD" -fs HFS+ -ov || exit 1
    fi
    + '[' 1 == 1 ']'
    + tempsize=
    + '[' -e '/Volumes/Mac OS X Install DVD/System/Installation/Packages/OSInstall.mpkg' ']'
    + /usr/sbin/installer -plist -verbose -pkginfo -pkg '/Volumes/Mac OS X Install DVD/System/Installation/Packages/OSInstall.mpkg'
    /usr/bin/defaults read "$1/OSInstall" Size
    ++ /usr/bin/defaults read /tmp/niutemp.mdOQAzsJ/OSInstall Size
    + tempsize=11937692
    + tempsize=11657
    + size=12673
    + '[' DEBUG == VERBOSE -o DEBUG == DEBUG ']'
    + echo 'Creating disk image (Size: 12673 MB)'
    Creating disk image (Size: 12673 MB)
    + /usr/bin/hdiutil create '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD/NetBoot' -megabytes 12673 -volname NetBoot -uid 0 -gid 80 -mode 1775 -layout 'UNIVERSAL CD' -fs HFS+ -stretch 500g -ov
    created: /Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD/NetBoot.dmg
    + imageExtension=dmg
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Attaching disk image"
    fi
    + '[' DEBUG == VERBOSE -o DEBUG == DEBUG ']'
    + echo 'Attaching disk image'
    Attaching disk image
    /usr/bin/hdiutil attach "$destPath/$dmgTarget.$imageExtension" -owners on -nobrowse -mountpoint "${mountPoint}" -quiet || exit 1
    + /usr/bin/hdiutil attach '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD/NetBoot.dmg' -owners on -nobrowse -mountpoint /tmp/mnt -quiet
    # Copy source Volume base system to
    if [ -e "${sourceVol}/System/Installation/Packages/OSInstall.mpkg" ]; then
    # update progress information
    echo "${progressPrefix}_installingSystem_"
    if [ -e "$1/MacOSXInstaller.choiceChanges" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Installing to destination volume with choice selection."
    fi
    /usr/sbin/installer -applyChoiceChangesXML "$1/MacOSXInstaller.choiceChanges" -pkg "${sourceVol}/System/Installation/Packages/OSInstall.mpkg" -target "${mountPoint}"
    else
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Installing to destination volume"
    fi
    /usr/sbin/installer -pkg "${sourceVol}/System/Installation/Packages/OSInstall.mpkg" -target "${mountPoint}"
    fi
    # bless the boot folder
    /usr/sbin/bless -folder "${mountPoint}/System/Library/CoreServices" -quiet --bootinfo --bootefi
    # "kext"
    if [ -e "${mountPoint}/System/Library/StartupItems/NetBootSharingNames"
    ]; then
    /bin/chmod 0755 "${mountPoint}/System/Library/StartupItems"
    /usr/sbin/chown -R root:wheel "${mountPoint}/System/Library/StartupItems/NetBootSharingNames"
    /bin/chmod 0755 "${mountPoint}/System/Library/StartupItems/NetBootSharingNames"
    /bin/chmod 0755 "${mountPoint}/System/Library/StartupItems/NetBootSharingNames/NetBootSharingNa mes"
    /bin/chmod 0644 "${mountPoint}/System/Library/StartupItems/NetBootSharingNames/StartupParameter s.plist"
    fi
    if [ ! -d "${mountPoint}/Library/Preferences/DirectoryService" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Creating DirectoryService directory"
    fi
    /bin/mkdir $debug_opt "${mountPoint}/Library/Preferences/DirectoryService"
    /bin/chmod 0775 "${mountPoint}/Library/Preferences/DirectoryService"
    fi
    /usr/sbin/kextcache -a i386 -a ppc -l -z -m "${mountPoint}/System/Library/Extensions.mkext" "${mountPoint}/System/Library/Extensions" || exit 1
    else
    # update progress information
    echo "${progressPre
    fix}_copyingSource_"
    PreCleanSource "$sourceVol"
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Copying source volume"
    fi
    /usr/bin/ditto $debug_opt "$sourceVol" "${mountPoint}"
    fi
    + '[' -e '/Volumes/Mac OS X Install DVD/System/Installation/Packages/OSInstall.mpkg' ']'
    + echo
    + '[' -e /tmp/niutemp.mdOQAzsJ/MacOSXInstaller.choiceChanges ']'
    + '[' DEBUG == VERBOSE -o DEBUG == DEBUG ']'
    + echo 'Installing to destination volume'
    Installing to destination volume
    + /usr/sbin/installer -pkg '/Volumes/Mac OS X Install DVD/System/Installation/Packages/OSInstall.mpkg' -target /tmp/mnt
    installer: Package name is Mac OS X
    installer: Installing at base path /tmp/mnt
    installer: The install was successful.
    + /usr/sbin/bless -folder /tmp/mnt/System/Library/CoreServices -quiet --bootinfo --bootefi
    + '[' -e /tmp/mnt/System/Library/StartupItems/NetBootSharingNames ']'
    + '[' '!' -d /tmp/mnt/Library/Preferences/DirectoryService ']'
    + /usr/sbin/kextcache -a i386 -a ppc -l -z -m /tmp/mnt/System/Library/Extensions.mkext /tmp/mnt/System/Library/Extensions
    # install the PowerManagement.plist onto the bootable image
    InstallPowerManagementPlist "$1"
    + InstallPowerManagementPlist /tmp/niutemp.mdOQAzsJ
    + local tempDir=/tmp/niutemp.mdOQAzsJ
    + local opt=
    + '[' -e /tmp/niutemp.mdOQAzsJ/com.apple.PowerManagement.plist ']'
    + '[' DEBUG == VERBOSE -o DEBUG == DEBUG ']'
    + echo 'Installing progress announcer to install image'
    Installing progress announcer to install image
    + '[' DEBUG == DEBUG ']'
    + opt=-v
    + /usr/bin/ditto -v /tmp/niutemp.mdOQAzsJ/com.apple.PowerManagement.plist /tmp/mnt/Library/Preferences/SystemConfiguration/com.apple.PowerManagement.plis t
    Copying /tmp/niutemp.mdOQAzsJ/com.apple.PowerManagement.plist
    + /usr/sbin/chown root:wheel /tmp/mnt/Library/Preferences/SystemConfiguration/com.apple.PowerManagement.plis t
    + /bin/chmod 644 /tmp/mnt/Library/Preferences/SystemConfiguration/com.apple.PowerManagement.plis t
    # create the dyld caches
    CreateDyldCaches
    + CreateDyldCaches
    + local opt=
    + '[' DEBUG == VERBOSE -o DEBUG == DEBUG ']'
    + echo 'Creating dyld shared cache files'
    Creating dyld shared cache files
    + '[' DEBUG == DEBUG ']'
    + opt=-debug
    + /usr/bin/update_dyld_shared_cache -root /tmp/mnt -universal_boot -force -debug
    update_dyld_shared_cache failed: universal_boot option can only be used on Intel machines
    # If it exists, install the partition data onto the bootable image
    ProcessAutoPartition "$1"
    + ProcessAutoPartition /tmp/niutemp.mdOQAzsJ
    + local tempDir=/tmp/niutemp.mdOQAzsJ
    + local opt=
    + '[' -e /tmp/niutemp.mdOQAzsJ/PartitionInfo.plist ']'
    # install the progress emitter onto the install image
    InstallProgressPieces "$1"
    + InstallProgressPieces /tmp/niutemp.mdOQAzsJ
    + local tempDir=/tmp/niutemp.mdOQAzsJ
    + local opt=
    + '[' -e /tmp/niutemp.mdOQAzsJ/InstallerStatusNotifications.bundle ']'
    + '[' -e /tmp/niutemp.mdOQAzsJ/com.apple.ProgressEmitter.plist ']'
    + '[' DEBUG == VERBOSE -o DEBUG == DEBUG ']'
    + echo 'Insta
    lling status emitter to image'
    Installing status emitter to image
    + /usr/bin/ditto /tmp/niutemp.mdOQAzsJ/progress_emitter /tmp/mnt/usr/sbin/progress_emitter
    + /usr/sbin/chown root:wheel /tmp/mnt/usr/sbin/progress_emitter
    + /bin/chmod 555 /tmp/mnt/usr/sbin/progress_emitter
    + /usr/bin/ditto /tmp/niutemp.mdOQAzsJ/com.apple.ProgressEmitter.plist /tmp/mnt/System/Library/LaunchDaemons/com.apple.ProgressEmitter.plist
    + /usr/sbin/chown root:wheel /tmp/mnt/System/Library/LaunchDaemons/com.apple.ProgressEmitter.plist
    + /bin/chmod 644 /tmp/mnt/System/Library/LaunchDaemons/com.apple.ProgressEmitter.plist
    # update progress information
    echo "${progressPrefix}_buildingBooter_"
    + echo
    # Copy kernel and build the kext cache on the boot image
    PrepareKernelAndKextCache "$destPath"
    + PrepareKernelAndKextCache '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD'
    + local 'destDir=/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD'
    + local opt=
    + '[' DEBUG == VERBO
    SE -o DEBUG == DEBUG ']'
    + echo 'Preparing the kernel and kext cache for the boot image'
    Preparing the kernel and kext cache for the boot image
    + '[' DEBUG == DEBUG ']'
    + opt=-v
    + for ARCH in i386 ppc
    + /bin/mkdir -v '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD/i386'
    mkdir: created directory '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD/i386'
    + /usr/bin/lipo -extract i386 /tmp/mnt/mach_kernel -output '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD/i386/mach.macosx'
    + /usr/sbin/kextcache -a i386 -s -l -n -z -m '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD/i386/mach.macosx.mkext' /tmp/mnt/System/Library/Extensions
    + for ARCH in i386 ppc
    + /bin/mkdir -v '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD/ppc'
    mkdir: created directory '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD/ppc'
    + /usr/bin/lipo -extract ppc /tmp/mnt/mach_kernel -output '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD/ppc/mach.macosx'
    + /usr/sbin/kextcache -a ppc -s -l -n -z -m '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD/ppc/mach.macosx.mkext' /tmp/mnt/System/Library/Extensions
    # And finally, prepare the boot loader on the boot image
    PrepareBootLoader "$sourceVol" "$destPath"
    + PrepareBootLoader '/Volumes/Mac OS X Install DVD' '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD'
    + local 'srcVol=/Volumes/Mac OS X Install DVD'
    + local 'destDir=/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD'
    + local opt=
    + '[' DEBUG == VERBOSE -o DEBUG == DEBUG ']'
    + echo 'Preparing boot loader'
    Preparing boot loader
    + '[' DEBUG == DEBUG ']'
    + opt=-v
    + '[' -e /tmp/mnt/usr/standalone/ppc/bootx.bootinfo ']'
    + /usr/bin/ditto -v /tmp/mnt/usr/standalone/ppc/bootx.bootinfo '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD/ppc/booter'
    Copying /tmp/mnt/usr/standalone/ppc/bootx.bootinfo
    + /usr/bin/ditto -v /tmp/mnt/usr/standalone/i386/boot.efi '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD/i386/booter'
    Copying /tmp/mnt/usr/standalone/i386/boot.efi
    # "touch"
    /usr/bin/touch "${mountPoint}/private/var/db/.AppleSetupDone"
    + /usr/bin/touch /tmp/mnt/private/var/db/.AppleSetupDone
    /usr/bin/touch "${mountPoint}/Library/Receipts/.SetupRegComplete"
    + /usr/bin/touch /tmp/mnt/Library/Receipts/.SetupRegComplete
    /usr/bin/touch "${mountPoint}/.metadata_never_index"
    + /usr/bin/touch /tmp/mnt/.metadata_never_index
    # remove software update
    if [ -e "${mountPoint}/System/Library/CoreServices/Software Update.app" ]; then
    /bin/rm -rf "${mountPoint}/System/Library/CoreServices/Software Update.app"
    fi
    + '[' -e '/tmp/mnt/System/Library/CoreServices/Software Update.app' ']'
    + /bin/rm -rf '/tmp/mnt/System/Library/CoreServices/Software Update.app'
    if [ -e "${mountPoint}/System/Library/PreferencePanes/SoftwareUpdate.prefPane" ]; then
    /bin/rm -rf "${mountPoint}/System/Library/PreferencePanes/SoftwareUpdate.prefPane"
    fi
    + '[' -e /tmp/mnt/System/Library/PreferencePanes/SoftwareUpdate.prefPane ']'
    + /bin/rm -rf /tmp/mnt/System/Library/PreferencePanes/SoftwareUpdate.prefPane
    # add any user accounts
    CreateUserAccounts
    + CreateUserAccounts
    + local count=1
    + '[' 1 -gt 0 ']'
    + '[' DEBUG == VERBOSE -o DEBUG == DEBUG ']'
    + echo 'Adding 1 user account(s) to the image'
    Adding 1 user account(s) to the image
    + (( index=0 ))
    + (( index<1 ))
    + '[' DEBUG == VERBOSE -o DEBUG == DEBUG ']'
    + echo 'Adding user [user full name]'
    Adding user [user full name]
    + AddLocalUser '[user full name]' [user short name] 1 0000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 0000000006A29520ED4FE4E8C7DE0930018E9284B1078E0BB4CF77F8700000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000
    00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000 '/Library/User Pictures/Nature/Cactus.tif' English
    + local databasePath=/Local/Target/Users/[user short name]
    + (( i=501 ))
    + (( i<600 ))
    /usr/bin/dscl -f "${mountPoint}/var/db/dslocal/nodes/Default" localonly -search /Local/Target/Users UniqueID $i
    ++ /usr/bin/dscl -f /tmp/mnt/var/db/dslocal/nodes/Default localonly -search /Local/Target/Users UniqueID 501
    + output=
    + '[' '' == '' ']'
    + break
    + /usr/bin/dscl -f /tmp/mnt/var/db/dslocal/nodes/Default localonly -create /Local/Target/Users/[user short name]
    + /usr/bin/dscl -f /tmp/mnt/var/db/dslocal/nodes/Default localonly -append /Local/Target/Users/[user short name] RealName '[user full name]'
    + '[' 1 == 1 ']'
    + /usr/bin/dscl -f /tmp/mnt/var/db/dslocal/nodes/Default localonly -append /Local/Target/Users/[user short name] PrimaryGroupID 80
    + /usr/bin/dscl -f /tmp/mnt/var/db/dslocal/nodes/Default localonly -append /Local/Target/Users/[user short name] UniqueID 501
    + /usr/bin/dscl -f /tmp/mnt/var/db/dslocal/nodes/Default localonly -append /Local/Target/Users/[user short name] dsAttrTypeNative:home /Users/[user short name]
    + /usr/bin/dscl -f /tmp/mnt/var/db/dslocal/nodes/Default localonly -append /Local/Target/Users/[user short name] authentication_authority ';ShadowHash;'
    + /usr/bin/dscl -f /tmp/mnt/var/db/dslocal/nodes/Default localonly -append /Local/Target/Users/[user short name] picture '/Library/User Pictures/Nature/Cactus.tif'
    + /usr/bin/dscl -f /tmp/mnt/var/db/dslocal/nodes/Default localonly -append /Local/Target/Users/[user short name] passwd '*'
    + /usr/bin/dscl -f /tmp/mnt/var/db/dslocal/nodes/Default localonly -append /Local/Target/Users/[user short name] UserShell /bin/bash
    /usr/bin/dscl -f "${mountPoint}/var/db/dslocal/nodes/Default" localonly -read /Local/Target/Users/${2} GeneratedUID
    ++ /usr/bin/dscl -f /tmp/mnt/var/db/dslocal/nodes/Default localonly -read /Local/Target/Users/[user short name] GeneratedUID
    + genUID='GeneratedUID: 2609E2EC-9C33-469B-B850-A3BF935D72FE'
    + genUID=2609E2EC-9C33-469B-B850-A3BF935D72FE
    + '[' '!' -e /tmp/mnt/var/db/shadow/hash ']'
    + /bin/mkdir -p /tmp/mnt/var/db/shadow/hash
    + /bin/chmod -R 700 /tmp/mnt/var/db/shadow
    + echo 0000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 0000000006A29520ED4FE4E8C7DE0930018E9284B1078E0BB4CF77F8700000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000
    00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000
    + /bin/chmod 600 /tmp/mnt/var/db/shadow/hash/2609E2EC-9C33-469B-B850-A3BF935D72FE
    + '[' -e '/System/Library/User Template/English.lproj/' ']'
    + /usr/bin/ditto '/System/Library/User Template/English.lproj/' /tmp/mnt/Users/[user short name]
    + /usr/sbin/chown -R 501:501 /tmp/mnt/Users/[user short name]
    + (( index++ ))
    + (( index<1 ))
    # update progress information
    echo "${progressPrefix}_finishingUp_"
    + echo
    # perform the final cleanup
    PostFlightDestination "$1" "$destPath"
    + PostFlightDestination /tmp/niutemp.mdOQAzsJ '/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD'
    + local tempDir=/tmp/niutemp.mdOQAzsJ
    + local 'destDir=/Users/[user short name]/Documents/NetBoot of Mac OS X Install DVD'
    + local opt=
    + '[' DEBUG == VERBOSE -o DEBUG == DEBUG ']'
    + echo 'Performing post install cleanup'
    Performing post install cleanup
    + '[' DEBUG == DEBUG ']'
    + opt=-v
    + '[' -e /tmp/mnt/var/db/dslocal/indices/Default/index ']'
    + '[' DEBUG == VERBOSE -o DEBUG == DEBUG ']'
    + echo 'Detaching disk image'
    Detaching disk image
    + /usr/bin/hdiutil detach /tmp/mnt
    T?∞T?– A≈

  • Help: Windows cannot restore a system image to a computer with different firmware

    I want to recover a complete image of a Windows 7 operating system I have backed up to my other server. But I am getting the error "Windows cannot restore a system image to a computer with different firmware. The System Image was created by a computer using BIOS and this computer is using EFI"
    The image was definitely taken from this machine - the firmware has not changed!
    What do I need to do to restore the image?
    Background Story ..
    I bought a new HP 255 laptop per-installed with Windows 7 without Operating Systems instal disks (I will NEVER be stupid enough to do that again!).
    I took a complete image of the systems, as suggested so that I was well backed up.
    However, my machine corrupted its operating systems with a few weeks. The boot recovery CD did not work (would not boot). So in desperation, and because time was short I went out and bought another, legitimate copy of Windows 7 DVD with a license key (So now I have 2, legitimate copies of the operating system!).
    I installed the new copy of Windows 7 - but it was dreadful, because many drivers were missing. Mostly the missing drivers were not available on the HP support site for this machine. ALso, boot up was increadibly slow compared to the original OS installation.
    So I created a new boot recovery disk from the new version of Windows, and tried to restore using that. New boot disk loads ok, I can find the old image on my network (after loading a few network drivers). But I won't instal the image - giving the above error message.
    I tried deleting the EFI partition from the disk (using GPARTED to reformat that partition). That killed the Windows 7 on the machine - but still gives the same error message when I try to re-image the machine.
    I have tried going into the BIOS settings .. HP 255 has a "Legacy Mode" - which I have enabled, but this makes no difference at all!
    I think that the kind of solutions I am looking for might be:
    1. There is a clever way of disabling EFI on my 255 so that it looks like a legacy BIOS machine, or
    2. This EFI this is wired into my new boot recovery disk - and there is a way of creating a boot recovery disk that does not use EFI
    This has taken me about 2 weeks so far,please help with any suggestions!

    DonOxley wrote:
    Erico,
    I suspect that "MSDOS" is what the Gparted tool calls "MBR" for a partition table, as explained here:
    http://superuser.com/questions/700770/mbr-equals-msdos-for-gparted
    I think that you are suggesting I give up on trying to recover the image I have stored on my server and just to instal Windows 7 from my new copy. There are two problems with this.
    1. After having systematically downloaded all of the drivers from the HP 255 notebook support page, I am still seeing missing drivers listed. Install the AMD graphics softpaq driver first. It also contains the chipset drivers.
    2. The machine is taking a hugely long time to boot up, and seems much slower with this version. Maybe that is a product of using "EFI" rather than "bios" - I don't know.
    My assumption is that HP had some special set-up option with their version of Windows which makes the machine more performant. It does not seem to be a coincidence that the image they deliver the machine with is not quite compatible with a 'normal' Windows 7 instal.
    So my original question stands: How do I recover the image that I saved away (as per instructed) when I first bough the machine?
    You still have not said what you used to create the system image. What is the "image" file's extension?
    You are mistaken in your comparison. MSDOS is an operating sytem MBR is a partitioning scheme.  that is comparing apples to oranges. 
    The article is making an oblique reference in that using GPARTED is more or less equated to using the diskpart utility at the command line. Everything done at the comand line is essentially  done by use of MSDOS commands. GPARTED does the same thing with LINUX commands via a graphical interface so you don't have to type in the commands in a  Linux console.
    Do you mean making a backup? a backup is not a clone which can be reproduced on different hardware. The SSD disk replacement does make the hardware differ from the original configuration.
    Follow the instaructions on the following tutorial to make your disk a GPT type before installing.
    http://www.disk-partition.com/articles/mbr-partition-table-to-gpt.html
    ****Please click on Accept As Solution if a suggestion solves your problem. It helps others facing the same problem to find a solution easily****
    2015 Microsoft MVP - Windows Experience Consumer

  • System Imaging - Newbie Question

    If I setup a new Intel iMac, and make an image of it, can I use that image to install onto G5 and G4 machines of various ages? Or will that image only work to install onto similar hardware?
    I'm embarking on a spare time project to help my local weekly newspaper upgrade their 8 macs to OS X and CS2. The macs range from a G4 733 to eMac 700 - 1.25 to iMac G5 etc. I have a brand new intel iMac (17") 2.0 that I can setup from scratch. The rest of the machines are all in active use and I'm only able to do this work about one evening per week so I'm looking for a faster way to be able to backup each machine, install a fresh OS, and copy the user's files and settings back on. Many of the machines are OS 9.2.2 right now too which is a real pain. I did one machine the old fashioned way and it took me forever. I now have OS X Server available and would like to try this feature out but would appreciate the guidance. Thanks.

    So I need a seperate System Image for each system?
    Until Mac OS X 10.5 (Leopard) is released, you will need a different Mac OS X image for Intel-based Macs and PowerPC-based Macs.
    Or, if I setup a G4 733 system and image it can I use that image to setup an eMac 1.25? What about the G5 iMac?
    Best practice would be to use the most recent computer (the one that shipped with the most recent version of Mac OS X) to create your image from. After applying the software updates, it should be backwards-compatible with the earlier computers.
    -Doug

  • When HP Recovery isn't available... system image using Windows 8 as backup?

    Would like to start out with a big shout out to Paul T for his VERY useful thread here !    http://h30434.www3.hp.com/t5/Notebook-Operating-Systems-and-Software/Windows-8-Product-Key-for-Pavilion-G6/m-p/3882966/highlight/false#M205987 A friend's family asked me to work on their laptop since I know more about computers than they do ... they're very good people, was happy to help them out but true to form like a lot of PC users they didn't bother keeping ANY of the documentation that came with the laptop (HP Pavilion g6-2298nr ), nor did they bother to burn recovery DVD's using HP's built in recovery software program that comes standard on the laptops... if I'm interpreting what HP's website had to say about the laptop , model HP Pavilion g6-2298nr, correctly, according to it's serial number it no longer qualifies for free tech support and I'd have to pay HP a fee just to talk to someone and order  the recovery DVD's  (friend's family bought it back in Dec 2014  so to me it seems REALLY strange that I wouldn't be able to just order the recovery DVD's without having to pay tech support a fee just to ask to order  the recover DVD's !  .. but anyways...)...  This is where having the product key "built into" the BIOS really comes in handy !   I crossed my fingers, used the method mentioned in the thread linked above, and it worked !    ... have to admit it was a bit strange at first not using the product key sticker like the old days but I can see how this works better in the long run - helps to prevent piracy, you don't have to worry if someone who doesn't realize the importance of the product key sticker peels it off and throws it away ... Unfortunately it looks like when you reinstall Windows this way you lose the HP Backup and Recovery Program     ... in this case my friend's family had the misfortune of paying someone to repair this laptop who didn't bother to tell them " Hey, I replaced the hard drive that's going bad but if you don't get a laptop cooler for this sucker the laptop's just going to overheat again ! " ... sure enough, the money they paid this so called "tech repair" person went down the drain when the laptop fried a second hard drive, or maybe the tech saddled them with a bad hard drive who knows? (the tech bought an OEM hard drive off ebay) ... ... sorry to sound harsh about this tech guy, I will admit I only worked in the PC repair field for a few months over a decade ago before leaving it to be a stay-at-home-dad (wife is a pharmacist so I'm lucky enough to be able to stay home) so my experience is VERY limited compared to other people .. but back then  I always treated my customers the way I'd treat a friend, and if it's a friend you offer advice on how to prevent problems like this in the future... this laptop gets HOT like you wouldn't believe , I have it sitting on a very reliable laptop cooler (thick slab of aluminum that does a great job as a heatsink with fans, this one http://www.newegg.com/Product/Product.aspx?Item=N82E16834953038 and I've let my friend's family know in no uncertain terms they need to order this laptop cooler if they're going to use this laptop) ...  The hard drive  replacement I installed seems to be working fine but of course it's not an "official WD hard drive" .... when I tried to install the photolink cyberdirector software for example at the link below got  a " this isn't a WD hard drive so can't install this software" error message...  http://support.hp.com/us-en/drivers/selfservice/hp-pavilion-g6-2200-notebook-pc-series/5296082/model/5333338#Z7_3054ICK0K8UDA0AQC11TA930O2 which is fine I really don't think my friend's family will care about that program... but it makes me wonder, even if I trusted the download at this link below http://www.techspot.com/downloads/5190-hp-backup-and-recovery-manager.html if the HP Backup and Recovery manager program would even work to begin with since it's not an official WD hard drive (I also ordered an OEM hard  drive  off ebay    .. but not charging my friend's family for the hard drive since they've been good to my munchkins and didn't want them to pay through the nose for a more  expensive hard drive so of course I wanted to minimize my own expenses...)... also I think that sort of program relies on a " C " and " D " drive being set up like it was when the laptop shipped with the original hard drive and saves a backup copy on the " D " drive.. I suppose I could use disk management to create a different partition, label it " D " and see if HP Backup and Recovery worked but it seems a bit.. iffy... not to mention that I feel uncomfortable downloading something that isn't directly on HP's website as an "official" download...  I  know that Windows 8 has a "system image"  utility built into it that lets you make just that.. a system image.. like I said my friend's family are good people but I'm guessing sooner or later they're going to screw this laptop up again like a lot of computer users do .. it would be nice if I could burn a system image of what's on the laptop right now onto DVD and hang onto it so when they come back to me in the future hollering "Help , laptop isn't working again ! " I can just restore from the system image on DVD rather than having to go through the hassle of reinstalling Windows, graphics/audio/et cetera drivers, zillion and one Windows updates et cetera all over  again. What I'm wondering is... would this even work?    I've never tried to use system image in a situation like this with the product key being "built into" the BIOS , that sort of thing is brand new to me... is it worth burning the DVD's and hanging onto them just in case?  Sorry for the long essay and thanks in advance to anyone who actually takes the time to read all of this !    

    Thanks man it's really helpful to know that someone else has used this exact same method successfully to back up their HP computers !      Will do just that... yep, yep I know it'll be at least 10 DVD's or something crazy like that after all those windows updates download    ... problem with using an external hard drive is I can't convince my friend's family to buy one no matter how many times I warn them it's not "if" your PC gets messed up it's " when "    ..... and my external hard drives are all in use with system image backups of my own PC's ... so will burn the DVD's for 'em then just hang on to them and wait for the inevitable   And thanks for the kind words about my work for them too !    .. it's a lot of effort but they've been super nice to me so it's the least I can do  ... they're actually parents of one of my daughter's best friends and  they've taken my munchkin out to various places and flat out refused to let me pay them back for it so it feels good to be able to help them out this way... though I wish they'd come to me first instead of letting themselves get ripped off by the so called PC tech I mentioned earlier (would it have killed the guy to burn them a set of recovery DVD's?   Heck if he wanted to be selfish and greedy he could have just offered it to them for an "additional fee" but it would have saved them and me a lot of trouble !    Though I'm not sure if the recovery DVD's would cooperate given that it's not an "official HP hard drive" I put in there? ) It occured to me that if I call tech support they probably can't charge me if I don't give them a credit card number   .. so I did (1-888-698-3762).. they said the warranty on this laptop expired Dec 2013 !     Friend's family said they bought it in Dec 2014 from QVC, hope QVC didn't sell them a used laptop !   ... HP wanted over a hundred dollars for an "official" HP hard drive said no thanks to that... HP says despite me putting in a non-HP hard drive that recovery DVD's should work ... HP wanted  $     for recovery DVD's (tried to help me order recovery  DVD's off  HP website, they couldn't find the link on there to them either for some reason... maybe 'cause laptop is an older model??? ) ...  HP asked for thirty dollars (cheapest option!) for recovery DVD's ... but mentioned that if the laptop really was purchased Dec 2014 and if I e-mail them proof of purchase they'll ship out recovery DVD's for free instead since it would be within it's one year warranty period.. I'm waiting on the friend's family to give me the proof of purchase for me to scan and e-mail  to HP ... though I think I'm going to go ahead and use system image to burn the DVD's first THEN run the HP recovery DVD's (if they do in fact turn out ot be free) in case the HP rep made a mistake and the HP recovery DVD's don't like the "unofficial" HP hard drive on this laptop... 

  • System Image Restore Fails "No disk that can be used for recovering the system disk can be found"

    Greetings    
                                        - Our critical server image backup Fails on one
    server -
    Two 2008 R2 servers. Both do a nightly "Windows Server Backup" of Bare Metal Recovery, System State, C:, System Reserved partition, to another storage hard drive on the same machine as the source. Active Directory is on the C: The much larger D: data
    partition on each source hard drive is not included.
    Test recovery by disconnecting 500G System drive, booting from 2008R2 Install DVD, recovering to a new 500G SATA hard drive.
    Server A good.
    Server B fails. It finds the backed-up image, & then we can select the date we want. As soon as the image restore is beginning and the timeline appears, it bombs with "The system image restore failed. No disk that can be used for recovering the system
    disk can be found." There is a wordy Details message but none of it seems relevant (we are not using USB etc).
    At some point after this, in one (or two?) of the scenarios below, (I forget exactly where) we also got :
    "The system image restore failed. (0x80042403)"
    The destination drive is Not "Excluded".
    Used   diskpart clean   to remove volumes from destination drive. Recovery still errored.
    Tried a second restore-to drive, same make/model Seagate ST3500418AS, fails.
    Tried the earliest dated B image rather than the most recent, fail.
    The Server B backups show as "Success" each night.
    Copied image from B to the same storage drive on A where the A backup image is kept, and used the A hardware to attempt restore. Now only the latest backup date is available (as would occur normally if we had originally saved the backup to a network location).
    Restore still fails.         It looks like its to do with the image rather than with the hardware.
    Tried unticking "automatically check and update disk error info", still fail.
    Server A  SRP 100MB  C: 50.6GB on Seagate ST3500418AS 465.76GB  Microsoft driver 6.1.7600.16385   write cache off
    Server B  SRP 100MB  C: 102GB  on Seagate ST3500418AS 465.76GB  Microsoft driver 6.1.7600.16385   write cache off
    Restore-to hard drive is also Seagate ST3500418AS.
    http://social.answers.microsoft.com/Forums/en-US/w7repair/thread/e855ee43-186d-4200-a032-23d214d3d524      Some people report success after diskpart clean, but not us.
    http://social.technet.microsoft.com/Forums/en-US/windowsbackup/thread/31595afd-396f-4084-b5fc-f80b6f40dbeb
    "If your destination disk has a lower capacity than the source disk, you need to go into the disk manager and shrink each partition on the source disk before restoring."  Doesnt apply here.
    http://benchmarkreviews.com/index.php?option=com_content&task=view&id=439&Itemid=38&limit=1&limitstart=4
    for 0x80042403 says "The solution is really quite simple: the destination drive is of a lower capacity than the image's source drive." I cant see that here.
    Thank you so much.

    Hello,
    1. While recovering the OS to the new Hard disk, please don't keep the original boot disk attached to the System. There is a Disk signature for each hard disk. The signature will collide if the original boot disk signature is assigned to the new disk.
    You may attach the older disk after recovering the OS. If you want to recover data to the older disk then they should be attached as they were during backup.
    2. Make sure that the new boot disk is attached as the First Boot disk in hardware (IDE/SATA port 0/master) and is the first disk in boot order priority.
    3. In Windows Recovery Env (WinRE) check the Boot disk using: Cmd prompt -> Diskpart.exe -> Select Disk = System. This will show the disk where OS restore will be attempted. If the disk is different than the intended 2 TB disk then swap the disks in
    correct order in the hardware.
    4. Please make sure that the OS is always recovered to the System disk. (Due to an issue: BMR might recover the OS to some other disk if System disk is small in size. Here the OS won't boot. If you belive this is the case, then you should attach the
    bigger sized disk as System disk and/or exclude other disks from recovery). Disk exclusion is provided in System Image Restore/Complete PC Restore UI/cmdline. 
    5. Make sure that Number and Size of disks during restore match the backup config. Apart from boot volumes, some other volumes are also considered critical if there are services/roles installed on them. These disks will be marked critical for recovery and
    should be present with minimum size requirement.
    6. Some other requirements are discussed in following newsgroup threads:
    http://social.technet.microsoft.com/Forums/en-US/windowsbackup/thread/871a0216-fbaf-4a0c-83aa-1e02ae90dbe4
    http://social.technet.microsoft.com/Forums/en-US/windowsbackup/thread/9a082b90-bd7c-46f8-9eb3-9581f9d5efdd
    http://social.technet.microsoft.com/Forums/en-US/windowsbackup/thread/11d8c552-a841-49ac-ab2e-445e6f95e704
    Regards,
    Vikas Ranjan [MSFT]
    ------- This information is provided as-is without any warranties, implicit or explicit.-------

  • Trying to Create a Catalog file using WSIM (Windows System Image Manager)

    I have been looking online for a solution to htis problem for days and come up with nothing so any help would be amazingly helpful.
    I have created a Windows 8.1 image which I would like to role out to all users within my company but when trying to create a catalog file I am getting an erorr message saying "Windows SIM was unable to generate a catalog."  It says "Mounting
    Windows Image file......This might take a few minutes" and then fails after 6-7mins.
    When opening the log file I get this:
    10:00 : Cannot obtain read/write access for F:\sources\install.wim.
    In order to generate a catalog file, you must have read/write access to the Windows image file and its containing folder.
    10:13 :
    10:13 : Windows SIM was unable to generate a catalog. For troubleshooting assistance, see the topic: 'Windows System Image Manager Technical Reference' in the Windows OPK or Windows AIK User's Guide.
    10:13 :
    10:13 : System.InvalidOperationException: The operation failed to complete. ---> System.Reflection.TargetInvocationException: Exception has been thrown by the target of an invocation. ---> System.ArgumentNullException: String reference not set to
    an instance of a String.
    Parameter name: source
       at System.Globalization.CompareInfo.IsPrefix(String source, String prefix, CompareOptions options)
       at ?A0xfe36268f.ConvertToNtPath(String path)
       at Microsoft.ComponentStudio.ComponentPlatformInterface.CbsSessionAdaptor..ctor(String bootDrive, String imageWinDir, String servicingPath)
       at Microsoft.ComponentStudio.ComponentPlatformInterface.OfflineImageImpl.InitializePackages()
       at Microsoft.ComponentStudio.ComponentPlatformInterface.OfflineImageImpl..ctor(OfflineImageInfo imageInfo)
       --- End of inner exception stack trace ---
       at System.RuntimeMethodHandle._InvokeConstructor(Object[] args, SignatureStruct& signature, IntPtr declaringType)
       at System.Reflection.RuntimeConstructorInfo.Invoke(BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
       at System.RuntimeType.CreateInstanceImpl(BindingFlags bindingAttr, Binder binder, Object[] args, CultureInfo culture, Object[] activationAttributes)
       at Microsoft.ComponentStudio.ComponentPlatformInterface.Cpi.PlatformImplementation.CreateOfflineImageInstance(OfflineImageInfo imageInfo)
       --- End of inner exception stack trace ---
    The one image that did work (LiteTouchPE_x64.wim) was from the OS I imported to Microsoft Workbench but the components are different to any that I have seen online when looking on how to do this.
    I have made sure that the architecture is x64 and tried from ISO files I have on the system already but get the same error.
    This is the first project I have been involved in and only ever done IT support before this.
    Thanks for your help in advance.

    Yes I am trying to capture a reference image that I have created on another machine and then reploy this through MDT. I am trying to open the Unattend.xml file because the "Capture and Sysprep" fails on the reference machine when trying to run
    Sysprep. When I try to open the Unattend.xml file in MDT I get the error below:
    Performing operation "generate" on Target "Catalog".
    Starting: "C:\Program Files\Microsoft Deployment Toolkit\Bin\Microsoft.BDD.Catalog35.exe" "D:\Windows8.1 TEST3\Operating Systems\Windows8.1 x64\Sources\install.wim" 1 > "C:\Users\*****\AppData\Local\Temp\3\Microsoft.BDD.Catalog.log"
    2>&1
    No existing catalog file found.
    PROGRESS: 0: Starting.
    PROGRESS: 0: Creating mount folder: C:\Users\*****\AppData\Local\Temp\3\IMGMGR_install_Windows 8.1 Enterprise_njegg3ph.con.
    PROGRESS: 5: Creating temp folder: C:\Users\*****\AppData\Local\Temp\3\IMGMGR_install_temp_qj0x3ga5.obv.
    PROGRESS: 10: Mounting Windows image: D:\Windows8.1 TEST3\Operating Systems\Windows8.1 x64\Sources\install.wim. This might take a few minutes.
    ERROR: Unable to generate catalog on D:\Windows8.1 TEST3\Operating Systems\Windows8.1 x64\Sources\install.wim: System.ComponentModel.Win32Exception: The process cannot access the file because it is being used by another process
       at Microsoft.ComponentStudio.ComponentPlatformInterface.WimImageInfo.PreCreateCatalog()
       at Microsoft.ComponentStudio.ComponentPlatformInterface.OfflineImageInfo.CreateCatalog()
       at Microsoft.BDD.Catalog.Program.DoCatalog()
    Non-zero return code from catalog utility, rc = 2002

  • System Image Utility always fails, why?

    Hi everyone,
    on my clean and fresh install of 10.7.4 Server the System Image Utility always fails to create an image. I want to create a NetInstall image and have put the OS X Lion Installer in /Applications. I can select it in SIU and choose to create a NetInstall image. It asks for the admin pw and always presents an error at the very end: Image creation failed. An unknown error has occured.
    If I select to create a NetBoot image instead it fails directly after clicking on the Create button with this slightly different message: Image creation failed. An error has occured. At least it’s no unknown error…
    Any ideas what might be causing this? I have succesfully created NetInstall images with 10.6 Server and 10.8 Server, but 10.7 Server somehow won’t play nice.
    Thanks
    Björn

    Hi Brian,
    I first deleted the Installer and redownloaded it from the App Store, just to make sure there was no problem with it. Even though I now have the 10.7.4 Installer (had 10.7.0 before) nothing has changed. I then went on to set the log level as suggested. I now get different errors based on the chosen log level.
    Log level set to debug:
    Image creation failed.
    *** -[__NSArrayM insertObject:atIndex:]: object cannot be nil
    Log level set to verbose:
    Image creation failed.
    An unknown error has occurred.
    I did not see anything helpful in the logs unfortunately. The only noticeable thing mentioned was: Failed to create image from installer media.
    Any additional ideas? I will attach both logs here, just in case.
    VERBOSE LOG:
    Starting image creation.
    Workflow Started (2012-09-08 14:08:00 +0200)
    Mac OS X Server 10.7.4 (11E53), System Image Utility 10.7.3 (543)
    Starting action: Define Image Source (1.3)
    Finished running action: Define Image Source
    Starting action: Create Image (1.6.2)
    Starting image creation process...
    Create NetInstall Image
    Initiating NetInstall from Installer media.
    Creating working path at /Users/vm/Desktop/NetInstall of Install Mac OS X Lion
    Creating disk image (Size: 4062 MB)
    Finalizing disk image.
    created: /Users/vm/Desktop/NetInstall of Install Mac OS X Lion/NetInstall.dmg
    Attaching disk image
    Copying /Volumes/Mac OS X Install ESD
    Preparing the kernel and boot loader for the boot image
    /Users/vm/Desktop/NetInstall of Install Mac OS X Lion/i386
    /Users/vm/Desktop/NetInstall of Install Mac OS X Lion/i386/x86_64
    Copying /Volumes/Mac OS X Install ESD/boot.efi
    Copying /Volumes/Mac OS X Install ESD/System/Library/CoreServices/PlatformSupport.plist
    Performing post install cleanup
    Detaching disk image
    "disk4" unmounted.
    "disk4" ejected.
    Correcting permissions. 501:20 /Users/vm/Desktop/NetInstall of Install Mac OS X Lion
    Script is done.
    Failed to create image from installer media.
    An unknown error has occurred.
    NetInstall creation failed.
    Image creation process finished...
    Stopping image creation.
    Image creation failed.
    DEBUG LOG:
    Starting image creation.
    Workflow Started (2012-09-08 13:59:22 +0200)
    Mac OS X Server 10.7.4 (11E53), System Image Utility 10.7.3 (543)
    Starting action: Define Image Source (1.3)
    Finished running action: Define Image Source
    Starting action: Create Image (1.6.2)
    Starting image creation process...
    Create NetInstall Image
    Initiating NetInstall from Installer media.
    progressPrefix="_progress"
    ++ progressPrefix=_progress
    scriptsDebugKey="DEBUG"
    ++ scriptsDebugKey=DEBUG
    imageIsUDIFKey="1"
    ++ imageIsUDIFKey=1
    mountPoint=""
    ++ mountPoint=
    ownershipInfoKey="501:20"
    ++ ownershipInfoKey=501:20
    destVolFSType="HFS+"
    ++ destVolFSType=HFS+
    installSource="/Volumes/Mac OS X Install ESD"
    ++ installSource='/Volumes/Mac OS X Install ESD'
    dmgTarget="NetInstall"
    ++ dmgTarget=NetInstall
    destPath="/Users/vm/Desktop/NetInstall of Install Mac OS X Lion"
    ++ destPath='/Users/vm/Desktop/NetInstall of Install Mac OS X Lion'
    dmgVolName="NetInstall"
    ++ dmgVolName=NetInstall
    . "${1}/createCommon.sh"
    + . /tmp/niutemp.Yv8Z6Mqx/createCommon.sh
    # createCommon.sh
    # Common functionality for the Image creation process.
    # sourced in by the various SIU scripts
    # Copyright © 2007-2011 Apple Inc. All rights reserved.
    # Using dscl, create a user account
    AddLocalUser()
    # $1 volume whose local node database to modify
    # $2 long name
    # $3 short name
    # $4 isAdminUser key
    # $5 password data
    # $6 password hint
    # $7 user picture path
    # $8 Language string
    local databasePath="/Local/Default/Users/${3}"
    local targetVol="${1}"
    # Find a free UID between 501 and 599
    for ((i=501; i<600; i++)); do
    output=`/usr/bin/dscl -f "${targetVol}/var/db/dslocal/nodes/Default" localonly -search /Local/Default/Users UniqueID $i`
    # If there is already an account dscl returns it, so we're looking for an empty return value.
    if [ "$output" == "" ]; then
    break
    fi
    done
    # Create the user record
    /usr/bin/dscl -f "${targetVol}/var/db/dslocal/nodes/Default" localonly -create $databasePath
    if [ $? != 0 ]; then
    echo "Failed to create '${databasePath}'."
    return 1
    fi
    # Add long name
    /usr/bin/dscl -f "${targetVol}/var/db/dslocal/nodes/Default" localonly -append $databasePath RealName "${2}"
    if [ $? != 0 ]; then
    echo "Failed to set the RealName."
    return 1
    fi
    # Add PrimaryGroupID
    if [ "${4}" == 1 ]; then
    /usr/bin/dscl -f "${targetVol}/var/db/dslocal/nodes/Default" localonly -append $databasePath PrimaryGroupID 80
    else
    /usr/bin/dscl -f "${targetVol}/var/db/dslocal/nodes/Default" localonly -append $databasePath PrimaryGroupID 20
    fi
    if [ $? != 0 ]; then
    echo "Failed to set the PrimaryGroupID."
    return 1
    fi
    # Add UniqueID
    /usr/bin/dscl -f "${targetVol}/var/db/dslocal/nodes/Default" localonly -append $databasePath UniqueID ${i}
    if [ $? != 0 ]; then
    echo "Failed to set the UniqueID."
    return 1
    fi
    # Add Home Directory entry
    /usr/bin/dscl -f "${targetVol}/var/db/dslocal/nodes/Default" localonly -append $databasePath NFSHomeDirectory /Users/${3}
    if [ $? != 0 ]; then
    echo "Failed to set the NFSHomeDirectory."
    fi
    if [ "${6}" != "" ]; then
    /usr/bin/dscl -f "${targetVol}/var/db/dslocal/nodes/Default" localonly -append $databasePath AuthenticationHint "${6}"
    if [ $? != 0 ]; then
    echo "Failed to set the AuthenticationHint."
    return 1
    fi
    fi
    /usr/bin/dscl -f "${targetVol}/var/db/dslocal/nodes/Default" localonly -append $databasePath picture "${7}"
    if [ $? != 0 ]; then
    echo "Failed to set the picture."
    return 1
    fi
    /usr/bin/dscl -f "${targetVol}/var/db/dslocal/nodes/Default" localonly -passwd $databasePath "${5}"
    if [ $? != 0 ]; then
    echo "Failed to set the passwd."
    return 1
    fi
    # Add shell
    /usr/bin/dscl -f "${targetVol}/var/db/dslocal/nodes/Default" localonly -append $databasePath UserShell "/bin/bash"
    if [ $? != 0 ]; then
    echo "Failed to set the UserShell."
    return 1
    fi
    # Create Home directory
    if [ -e "/System/Library/User Template/${8}.lproj/" ]; then
    /usr/bin/ditto "/System/Library/User Template/${8}.lproj/" "${targetVol}/Users/${3}"
    else
    /usr/bin/ditto "/System/Library/User Template/English.lproj/" "${targetVol}/Users/${3}"
    fi
    if [ $? != 0 ]; then
    echo "Failed to copy the User Template."
    return 1
    fi
    /usr/sbin/chown -R $i:$i "${targetVol}/Users/${3}"
    if [ $? != 0 ]; then
    echo "Failed to set ownership on the User folder."
    return 1
    fi
    # Copies a list of files (full paths contained in the file at $1) from source to the path specified in $2
    CopyEntriesFromFileToPath()
    local theFile="$1"
    local theDest="$2"
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    while read FILE
    do
    if [ -e "${FILE}" ]; then
    local leafName=`basename "${FILE}"`
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Copying ${FILE}."
    fi
    /usr/bin/ditto $opt "${FILE}" "${theDest}/${leafName}" || return 1
    fi
    done < "${theFile}"
    return 0
    # Copies a list of packages (full path, destination pairs contained in the file at $1) from source to .../System/Installation/Packages/
    CopyPackagesWithDestinationsFromFile()
    local theFile="$1"
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    while read FILE
    do
    if [ -e "${FILE}" ]; then
    local leafName=`basename "${FILE}"`
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Copying ${FILE}."
    fi
    read SUB_PATH
    /usr/bin/ditto $opt "${FILE}" "${mountPoint}/Packages/${SUB_PATH}${leafName}" || return 1
    fi
    done < "${theFile}"
    return 0
    # Create an installer package in ${1} wrapping the supplied script ${2}
    CreateInstallPackageForScript()
    local tempDir="$1"
    local scriptPath="$2"
    local scriptName=`basename "${scriptPath}"`
    local entryDir=`pwd`
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Create installer for script ${scriptName}"
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    fi
    # shouldn't exist on entry...
    if [ -e "${tempDir}/emptyDir" ]; then
    /bin/rm -rf "${tempDir}/emptyDir"
    fi
    # make some directories to work in
    /bin/mkdir $opt -p "${tempDir}/${scriptName}.pkg/Contents/Resources" || return 1
    /bin/mkdir $opt "${tempDir}/emptyDir" || return 1
    # Create Archive.pax.gz
    cd "${tempDir}/emptyDir"
    /bin/pax -w -x cpio -f "${tempDir}/${scriptName}.pkg/Contents/Archive.pax" .
    /usr/bin/gzip "${tempDir}/${scriptName}.pkg/Contents/Archive.pax"
    cd "${entryDir}"
    # Create the Archive.bom file
    /usr/bin/mkbom "${tempDir}/emptyDir/" "${tempDir}/${scriptName}.pkg/Contents/Archive.bom" || return 1
    # Create the Info.plist
    /bin/cat > "${tempDir}/${scriptName}.pkg/Contents/Info.plist" << END
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
    <plist version="1.0">
    <dict>
    <key>CFBundleIdentifier</key>
    <string>com.apple.server.SystemImageUtility.${scriptName}</string>
    <key>CFBundleShortVersionString</key>
    <string>1</string>
    <key>IFMajorVersion</key>
    <integer>1</integer>
    <key>IFMinorVersion</key>
    <integer>0</integer>
    <key>IFPkgFlagDefaultLocation</key>
    <string>/tmp</string>
    <key>IFPkgFlagInstallFat</key>
    <false/>
    <key>IFPkgFlagIsRequired</key>
    <false/>
    <key>IFPkgFormatVersion</key>
    <real>0.10000000149011612</real>
    </dict>
    </plist>
    END
    echo "pkmkrpkg1" > "${tempDir}/${scriptName}.pkg/Contents/PkgInfo"
    echo "major: 1\nminor: 0" > "${tempDir}/${scriptName}.pkg/Contents/Resources/package_version"
    # Copy the script
    /bin/cp "$scriptPath" "${tempDir}/${scriptName}.pkg/Contents/Resources/postflight"
    # clean up
    /bin/rm -r "${tempDir}/emptyDir"
    return 0
    # Validate or create the requested directory
    CreateOrValidatePath()
    local targetDir="$1"
    if [ ! -d "${targetDir}" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Creating working path at ${targetDir}"
    fi
    /bin/mkdir -p "${targetDir}" || return 1
    fi
    # If any exist, apply any user accounts
    CreateUserAccounts()
    # $1 volume whose local node database to modify
    local count="${#userFullName[*]}"
    local targetVol="${1}"
    if [ $count -gt 0 ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Adding $count user account(s) to the image"
    fi
    for ((index=0; index<$count; index++)); do
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Adding user ${userFullName[$index]}"
    fi
    #lay down user here
    AddLocalUser "${targetVol}" "${userFullName[$index]}" "${userUnixName[$index]}" "${userIsAdmin[$index]}" "${userPassword[$index]}" "${userPassHint[$index]}" "${userImagePath[$index]}" "${userLanguage[$index]}"
    if [ $? != 0 ]; then
    echo "Failed to create the User '${userUnixName[$index]}'."
    return 1
    fi
    done
    # "touch"
    /usr/bin/touch "${targetVol}/private/var/db/.AppleSetupDone"
    /usr/bin/touch "${targetVol}/Library/Receipts/.SetupRegComplete"
    fi
    # retry the hdiutil detach until we either time out or it succeeds
    retry_hdiutil_detach()
    local mount_point="${1}"
    local tries=0
    local forceAt=0
    local limit=24
    local opt=""
    forceAt=$(($limit - 1))
    while [ $tries -lt $limit ]; do
    tries=$(( tries + 1 ))
    /bin/sleep 5
    echo "Attempting to detach the disk image again..."
    /usr/bin/hdiutil detach "${mount_point}" $opt
    if [ $? -ne 0 ]; then
    # Dump a list of any still open files on the mountPoint
    if [ "${scriptsDebugKey}" == "DEBUG" ]; then
    /usr/sbin/lsof +fg "${mount_point}"
    fi
    if [ $tries -eq $forceAt ]; then
    echo "Failed to detach disk image at '${mount_point}' normally, adding -force."
    opt="-force"
    fi
    if [ $tries -eq $limit ]; then
    echo "Failed to detach disk image at '${mount_point}'."
    exit 1
    fi
    else
    tries=$limit
    fi
    done
    # Create the dyld shared cache files
    DetachAndRemoveMount()
    local theMount="${1}"
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Detaching disk image"
    # Dump a list of any still open files on the mountPoint
    if [ "${scriptsDebugKey}" == "DEBUG" ]; then
    /usr/sbin/lsof +fg "${theMount}"
    fi
    fi
    # Finally detach the image and dispose the mountPoint directory
    /usr/bin/hdiutil detach "${theMount}" || retry_hdiutil_detach "${theMount}" || return 1
    /bin/rmdir "${theMount}" || return 1
    return 0
    # If the pieces exist, enable remote access for the shell image
    EnableRemoteAccess()
    local srcVol="${1}"
    local opt=""
    if [ -e "${srcVol}/usr/lib/pam/pam_serialnumber.so.2" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Enabling shell image remote access support"
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    fi
    # install some things (again which aren't part of BaseSystem) needed for remote ASR installs
    /usr/bin/ditto $opt "${srcVol}/usr/lib/pam/pam_serialnumber.so.2" "${mountPoint}/usr/lib/pam/pam_serialnumber.so.2" || return 1
    if [ -e "${srcVol}/usr/sbin/installer" ]; then
    /usr/bin/ditto $opt "${srcVol}/usr/sbin/installer" "${mountPoint}/usr/sbin/installer" || return 1
    fi
    # copy the sshd config and add our keys to the end of it
    if [ -e "${srcVol}/etc/sshd_config" ]; then
    /bin/cat "${srcVol}/etc/sshd_config" - > "${mountPoint}/etc/sshd_config" << END
    HostKey /private/var/tmp/ssh_host_key
    HostKey /private/var/tmp/ssh_host_rsa_key
    HostKey /private/var/tmp/ssh_host_dsa_key
    END
    fi
    fi
    return 0
    # If it exists, install the sharing names and/or directory binding support to the install image
    HandleNetBootClientHelper()
    local tempDir="${1}"
    local targetVol="${2}"
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    if [ -e  "${tempDir}/bindingNames.plist" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Installing Directory Service binding information"
    fi
    /usr/bin/ditto $opt "${tempDir}/bindingNames.plist" "${targetVol}/etc/bindingNames.plist" || return 1
    /usr/sbin/chown root:wheel "${targetVol}/etc/bindingNames.plist"
    /bin/chmod 644 "${targetVol}/etc/bindingNames.plist"
    fi
    if [ -e  "${tempDir}/sharingNames.plist" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Installing Sharing Names support"
    fi
    /usr/bin/ditto $opt "${tempDir}/sharingNames.plist" "${targetVol}/etc/sharingNames.plist" || return 1
    /usr/sbin/chown root:wheel "${targetVol}/etc/sharingNames.plist"
    /bin/chmod 644 "${targetVol}/etc/sharingNames.plist"
    fi
    if [ -e  "${tempDir}/NetBootClientHelper" ]; then
    /usr/bin/ditto $opt "${tempDir}/NetBootClientHelper" "${targetVol}/usr/sbin/NetBootClientHelper" || return 1
    /usr/sbin/chown root:wheel "${targetVol}/usr/sbin/NetBootClientHelper"
    /bin/chmod 555 "${targetVol}/usr/sbin/NetBootClientHelper"
    /usr/bin/ditto $opt "${tempDir}/com.apple.NetBootClientHelper.plist" "${targetVol}/System/Library/LaunchDaemons/com.apple.NetBootClientHelper.plist" || return 1
    /usr/sbin/chown root:wheel "${targetVol}/System/Library/LaunchDaemons/com.apple.NetBootClientHelper.plist"
    /bin/chmod 644 "${targetVol}/System/Library/LaunchDaemons/com.apple.NetBootClientHelper.plist"
    # finally, make sure it isn't disabled...
    /usr/libexec/PlistBuddy -c "Delete :com.apple.NetBootClientHelper" "${targetVol}/var/db/launchd.db/com.apple.launchd/overrides.plist" > /dev/null 2>&1
    fi
    return 0
    # If any exist, install configuration profiles to the install image
    InstallConfigurationProfiles()
    local tempDir="${1}"
    local targetVol="${2}"
    local profilesDir="${targetVol}/var/db/ConfigurationProfiles"
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    if [ -e  "${tempDir}/configProfiles.txt" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Installing Configuration Profiles"
    fi
    /bin/mkdir -p "${profilesDir}/Setup" || return 1
    # Make sure the perms are correct
    /usr/sbin/chown root:wheel "${profilesDir}"
    /bin/chmod 755 "${profilesDir}"
    /usr/sbin/chown root:wheel "${profilesDir}/Setup"
    /bin/chmod 755 "${profilesDir}/Setup"
    /usr/bin/touch "${profilesDir}/.profilesAreInstalled"
    CopyEntriesFromFileToPath "${tempDir}/configProfiles.txt" "${profilesDir}/Setup" || return 1
    # Enable MCX debugging
    if [ 1 == 1 ]; then
    if [ -e  "${targetVol}/Library/Preferences/com.apple.MCXDebug.plist" ]; then
    /usr/libexec/PlistBuddy -c "Delete :debugOutput" "${targetVol}/Library/Preferences/com.apple.MCXDebug.plist" > /dev/null 2>&1
    /usr/libexec/PlistBuddy -c "Delete :collateLogs" "${targetVol}/Library/Preferences/com.apple.MCXDebug.plist" > /dev/null 2>&1
    fi
    /usr/libexec/PlistBuddy -c "Add :debugOutput string -2" "${targetVol}/Library/Preferences/com.apple.MCXDebug.plist" > /dev/null 2>&1
    /usr/libexec/PlistBuddy -c "Add :collateLogs string 1" "${targetVol}/Library/Preferences/com.apple.MCXDebug.plist" > /dev/null 2>&1
    fi
    fi
    # Converts a list of scripts (full paths contained in the file at $1) into packages in $3
    InstallScriptsFromFile()
    local tempDir="${1}"
    local theFile="${2}"
    local targetDir="${3}"
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Converting scripts into install packages"
    fi
    while read FILE
    do
    if [ -e "${FILE}" ]; then
    # make an installer package out of the script
    CreateInstallPackageForScript "$tempDir" "${FILE}" || return 1
    # copy the resulting package to the Packages directory
    local leafName=`basename "${FILE}"`
    /usr/bin/ditto $opt "${tempDir}/${leafName}.pkg" "${targetDir}/${leafName}.pkg" || return 1
    # clean up
    /bin/rm -r "${tempDir}/${leafName}.pkg"
    fi
    done < "${theFile}"
    return 0
    # Prepare the source by deleting stuff we don't want to copy if sourcing a volume
    PostFlightDestination()
    local tempDir="${1}"
    local destDir="${2}"
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Performing post install cleanup"
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ] ; then
    opt="-v"
    fi
    fi
    # delete the DS indices to force reindexing...
    if [ -e "${mountPoint}/var/db/dslocal/indices/Default/index" ]; then
    /bin/rm $opt "${mountPoint}/var/db/dslocal/indices/Default/index"
    fi
    # detach the disk and remove the mount folder
    DetachAndRemoveMount "${mountPoint}"
    if [ $? != 0 ]; then
    echo "Failed to detach and clean up the mount at '${mountPoint}'."
    return 1
    fi
    echo "Correcting permissions. ${ownershipInfoKey} $destDir"
    /usr/sbin/chown -R "${ownershipInfoKey}" "$destDir"
    # Prepare the source by deleting stuff we don't want to copy if sourcing a volume
    PreCleanSource()
    local srcVol="$1"
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ] ; then
    opt="-v"
    fi
    fi
    if [ -e "$srcVol/private/var/vm/swapfile*" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Removing swapfiles on $1"
    fi
    /bin/rm $opt "$srcVol/private/var/vm/swapfile*"
    fi
    if [ -d "$srcVol/private/tmp" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Cleaning out /private/tmp on $1"
    fi
    /bin/rm -r $opt "$srcVol/private/tmp/*"
    fi
    if [ -d "$srcVol/private/var/tmp" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Cleaning out /private/var/tmp on $1"
    fi
    /bin/rm -r $opt "$srcVol/private/var/tmp/*"
    fi
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Cleaning out devices and volumes on $1"
    fi
    if [ -d "$srcVol/Volumes" ]; then
    /bin/rm -r $opt "$srcVol/Volumes/*"
    fi
    if [ -d "$srcVol/dev" ]; then
    /bin/rm $opt "$srcVol/dev/*"
    fi
    if [ -d "$srcVol/private/var/run" ]; then
    /bin/rm -r $opt "$srcVol/private/var/run/*"
    fi
    # Copy kernel and build the kext cache on the boot image
    PrepareKernelAndKextCache()
    local srcDir="$1"
    local destDir="$2"
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Preparing the kernel and kext cache for t          /bin/rmdir "${theMount}" || return 1
    return 0
    # If the pieces exist, enable remote access for the shell image
    EnableRemoteAccess()
    local srcVol="${1}"
    local opt=""
    if [ -e "${srcVol}/usr/lib/pam/pam_serialnumber.so.2" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Enabling shell image remote access support"
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    fi
    # install some things (again which aren't part of BaseSystem) needed for remote ASR installs
    /usr/bin/ditto $opt "${srcVol}/usr/lib/pam/pam_serialnumber.so.2" "${mountPoint}/usr/lib/pam/pam_serialnumber.so.2" || return 1
    if [ -e "${srcVol}/usr/sbin/installer" ]; then
    /usr/bin/ditto $opt "${srcVol}/usr/sbin/installer" "${mountPoint}/usr/sbin/installer" || return 1
    fi
    # copy the sshd config and add our keys to the end of it
    if [ -e "${srcVol}/etc/sshd_config" ]; then
    /bin/cat "${srcVol}/etc/sshd_config" - > "${mountPoint}/etc/sshd_config" << END
    HostKey /private/var/tmp/ssh_host_key
    HostKey /private/var/tmp/ssh_host_rsa_key
    HostKey /private/var/tmp/ssh_host_dsa_key
    END
    fi
    fi
    return 0
    # If it exists, install the sharing names and/or directory binding support to the install image
    HandleNetBootClientHelper()
    local tempDir="${1}"
    local targetVol="${2}"
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    if [ -e  "${tempDir}/bindingNames.plist" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Installing Directory Service binding information"
    fi
    /usr/bin/ditto $opt "${tempDir}/bindingNames.plist" "${targetVol}/etc/bindingNames.plist" || return 1
    /usr/sbin/chown root:wheel "${targetVol}/etc/bindingNames.plist"
    /bin/chmod 644 "${targetVol}/etc/bindingNames.plist"
    fi
    if [ -e  "${tempDir}/sharingNames.plist" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Installing Sharing Names support"
    fi
    /usr/bin/ditto $opt "${tempDir}/sharingNames.plist" "${targetVol}/etc/sharingNames.plist" || return 1
    /usr/sbin/chown root:wheel "${targetVol}/etc/sharingNames.plist"
    /bin/chmod 644 "${targetVol}/etc/sharingNames.plist"
    fi
    if [ -e  "${tempDir}/NetBootClientHelper" ]; then
    /usr/bin/ditto $opt "${tempDir}/NetBootClientHelper" "${targetVol}/usr/sbin/NetBootClientHelper" || return 1
    /usr/sbin/chown root:wheel "${targetVol}/usr/sbin/NetBootClientHelper"
    /bin/chmod 555 "${targetVol}/usr/sbin/NetBootClientHelper"
    /usr/bin/ditto $opt "${tempDir}/com.apple.NetBootClientHelper.plist" "${targetVol}/System/Library/LaunchDaemons/com.apple.NetBootClientHelper.plist" || return 1
    /usr/sbin/chown root:wheel "${targetVol}/System/Library/LaunchDaemons/com.apple.NetBootClientHelper.plist"
    /bin/chmod 644 "${targetVol}/System/Library/LaunchDaemons/com.apple.NetBootClientHelper.plist"
    # finally, make sure it isn't disabled...
    /usr/libexmountPoint=`mktemp -d "/tmp/mnt.XXXXXXXX"`
    errExit()
    echo "Execution of '`basename ${0}`' failed. Cleaning up."
    # detach the disk and remove the mount folder
    DetachAndRemoveMount "${mountPoint}"
    /bin/rm -r "${destPath}"
    exit 1
    # Set up for script debugging
    debug_opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ] ; then
    debug_opt="-v"
    fi
    # Prepare the destination
    CreateOrValidatePath "$destPath" || errExit
    # update progress information
    echo "${progressPrefix}_creatingImage_"
    if [ -e "${installSource}/BaseSystem.dmg" ]; then
    size=$2
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ] ; then
    echo "Creating disk image (Size: $size MB)"
    fi
    /usr/bin/hdiutil create "$destPath/$dmgTarget" -megabytes $size -volname "${dmgVolName}" -uid 0 -gid 80 -mode 1775 -layout "SPUD" -fs "$destVolFSType" -stretch 500g -ov -puppetstrings || errExit
    echo "${progressPrefix}_copyingSource_"
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ] ; then
    echo "Attaching disk image"
    fi
    /usr/bin/hdiutil attach "${destPath}/${dmgTarget}.dmg" -owners on -nobrowse -noautoopen -mountpoint "${mountPoint}" -quiet || errExit
    # Copy source Volume base system to
    /usr/bin/ditto $debug_opt "${installSource}" "${mountPoint}" || errExit
    else
    echo "This does not appear to be a Mac OS X Install DVD."
    errExit
    fi
    # If adding any additional packages or scripts
    if [ -e "${1}/OSInstall.collection" ]; then
    /usr/bin/ditto $debug_opt "${1}/OSInstall.collection" "${mountPoint}/Packages/OSInstall.collection" || errExit
    /usr/sbin/chown root:wheel "${mountPoint}/Packages/OSInstall.collection"
    # If adding any additional packages
    if [ -e "${1}/additionalPackages.txt" ]; then
    CopyPackagesWithDestinationsFromFile "${1}/additionalPackages.txt" || errExit
    fi
    # If adding any scripts
    if [ -e "${1}/additionalScripts.txt" ]; then
    InstallScriptsFromFile "${1}" "${1}/additionalScripts.txt" "${mountPoint}/Packages" || errExit
    fi
    fi
    # If it exists, install the partition data onto the install image
    ProcessAutoPartition "${1}" || errExit
    # If it exists, install minstallconfig.xml (AutoInstall data) onto the install image
    ProcessMinInstall "${1}" || errExit
    # update progress information
    echo "${progressPrefix}_buildingBooter_"
    # Copy kernel and boot loader
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Preparing the kernel and boot loader for the boot image"
    fi
    # make sure this doesn't exist
    if [ -e "${destPath}/i386" ]; then
    /bin/rm -rf "${destPath}/i386"
    fi
    /bin/mkdir -p $debug_opt "${destPath}/i386/x86_64" || errExit
    # copy these directly off the install media
    /usr/bin/ditto $debug_opt "${installSource}/boot.efi" "${destPath}/i386/booter" || errExit
    /usr/bin/chflags nohidden "${destPath}/i386/booter"
    # Grab the relevant portion of the com.apple.Boot.plist
    kernelFlags=`/usr/libexec/PlistBuddy -c "print :'Kernel Flags'" "${installSource}/Library/Preferences/SystemConfiguration/com.apple.Boot.plist"`
    /usr/libexec/PlistBuddy -c "add :'Kernel Flags' string ${kernelFlags}" "${destPath}/i386/com.apple.Boot.plist" > /dev/null 2>&1
    /usr/bin/ditto $debug_opt "${installSource}/System/Library/CoreServices/PlatformSupport.plist" "${destPath}/i386/PlatformSupport.plist" || errExit
    # extract the kernel & kernelcache for the boot shell
    /usr/bin/lipo -extract i386 "${mountPoint}/kernelcache" -output "${destPath}/i386/kernelcache" || errExit
    /usr/bin/lipo -extract x86_64 "${mountPoint}/kernelcache" -output "${destPath}/i386/x86_64/kernelcache" || errExit
    # Apply choice changes, if any
    if [ -e "${1}/MacOSXInstaller.choiceChanges" ]; then
    echo "Copy over package choice selection."
    /usr/bin/ditto $debug_opt "${1}/MacOSXInstaller.choiceChanges" "${mountPoint}/Packages/Extras/MacOSXInstaller.choiceChanges"
    fi
    # update progress information
    echo "${progressPrefix}_finishingUp_"
    # perform the final cleanup
    PostFlightDestination "${1}" "$destPath" || errExit
    errExit
    Vol/private/tmp" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Cleaning out /private/tmp on $1"
    fi
    /bin/rm -r $opt "$srcVol/private/tmp/*"
    fi
    if [ -d "$srcVol/private/var/tmp" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Cleaning out /private/var/tmp on $1"
    fi
    /bin/rm -r $opt "$srcVol/private/var/tmp/*"
    fi
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Cleaning out devices and volumes on $1"
    fi
    if [ -d "$srcVol/Volumes" ]; then
    /bin/rm -r $opt "$srcVol/Volumes/*"
    fi
    if [ -d "$srcVol/dev" ]; then
    /bin/rm $opt "$srcVol/dev/*"
    fi
    if [ -d "$srcVol/private/var/run" ]; then
    /bin/rm -r $opt "$srcVol/private/var/run/*"
    fi
    # Copy kernel and build the kext cache on the boot image
    PrepareKernelAndKextCache()
    local srcDir="$1"
    local destDir="$2"
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Preparing the kernel and kext cache for tPERCENT:0.000000
    PERCENT:4.332841
    PERCENT:8.985722
    PERCENT:12.358444
    PERCENT:14.524864
    PERCENT:16.617430
    PERCENT:19.522402
    PERCENT:21.614967
    PERCENT:23.535204
    PERCENT:26.070902
    PERCENT:29.271296
    PERCENT:33.111767
    PERCENT:38.847858
    PERCENT:42.343674
    PERCENT:44.707043
    PERCENT:46.578041
    PERCENT:49.138355
    PERCENT:51.772526
    PERCENT:55.563763
    PERCENT:58.567207
    PERCENT:62.210735
    PERCENT:64.795670
    PERCENT:69.719353
    PERCENT:74.741508
    PERCENT:77.055641
    PERCENT:79.591331
    PERCENT:83.013290
    PERCENT:85.548988
    PERCENT:88.010834
    PERCENT:91.728210
    PERCENT:97.710487
    PERCENT:100.000000
    PERCENT:-1.000000
    Finalizing disk image.
    created: /Users/vm/Desktop/NetInstall of Install Mac OS X Lion/NetInstall.dmg
    /bin/rmdir "${theMount}" || return 1
    return 0
    # If the pieces exist, enable remote access for the shell image
    EnableRemoteAccess()
    local srcVol="${1}"
    local opt=""
    if [ -e "${srcVol}/usr/lib/pam/pam_serialnumber.so.2" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Enabling shell image remote access support"
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    fi
    # install some things (again which aren't part of BaseSystem) needed for remote ASR installs
    /usr/bin/ditto $opt "${srcVol}/usr/lib/pam/pam_serialnumber.so.2" "${mountPoint}/usr/lib/pam/pam_serialnumber.so.2" || return 1
    if [ -e "${srcVol}/usr/sbin/installer" ]; then
    /usr/bin/ditto $opt "${srcVol}/usr/sbin/installer" "${mountPoint}/usr/sbin/installer" || return 1
    fi
    # copy the sshd config and add our keys to the end of it
    if [ -e "${srcVol}/etc/sshd_config" ]; then
    /bin/cat "${srcVol}/etc/sshd_config" - > Creating working path at /Users/vm/Desktop/NetInstall of Install Mac OS X Lion
    Creating disk image (Size: 4062 MB)
    /tmp/ssh_host_dsa_key
    END
    fi
    fi
    return 0
    # If it exists, install the sharing names and/or directory binding support to the install image
    HandleNetBootClientHelper()
    local tempDir="${1}"
    local targetVol="${2}"
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    opt="-v"
    fi
    if [ -e  "${tempDir}/bindingNames.plist" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Installing Directory Service binding information"
    fi
    /usr/bin/ditto $opt "${tempDir}/bindingNames.plist" "${targetVol}/etc/bindingNames.plist" || return 1
    /usr/sbin/chown root:wheel "${targetVol}/etc/bindingNames.plist"
    /bin/chmod 644 "${targetVol}/etc/bindingNames.plist"
    fi
    if [ -e  "${tempDir}/sharingNames.plist" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Installing Sharing Names support"
    fi
    /usr/bin/ditto $opt "${tempDir}/sharingNames.plist" "${targetVol}/etc/sharingNames.plist" || return 1
    /usr/sbin/chown root:wheel "${targetVol}/etc/sharingNames.plist"
    /bin/chmod 644 "${targetVol}/etc/sharingNames.plist"
    fi
    if [ -e  "${tempDir}/NetBootClientHelper" ]; then
    /usr/bin/ditto $opt "${tempDir}/NetBootClientHelper" "${targetVol}/usr/sbin/NetBootClientHelper" || return 1
    /usr/sbin/chown root:wheel "${targetVol}/usr/sbin/NetBootClientHelper"
    /bin/chmod 555 "${targetVol}/usr/sbin/NetBootClientHelper"
    /usr/bin/ditto $opt "${tempDir}/com.apple.NetBootClientHelper.plist" "${targetVol}/System/Library/LaunchDaemons/com.apple.NetBootClientHelper.plist" || return 1
    /usr/sbin/chown root:wheel "${targetVol}/System/Library/LaunchDaemons/com.apple.NetBootClientHelper.plist"
    /bin/chmod 644 "${targetVol}/System/Library/LaunchDaemons/com.apple.NetBootClientHelper.plist"
    # finally, make sure it isn't disabled...
    /usr/libex
    # update progress information
    echo "${progressPrefix}_creatingImage_"
    if [ -e "${installSource}/BaseSystem.dmg" ]; then
    size=$2
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ] ; then
    echo "Creating disk image (Size: $size MB)"
    fi
    /usr/bin/hdiutil create "$destPath/$dmgTarget" -megabytes $size -volname "${dmgVolName}" -uid 0 -gid 80 -mode 1775 -layout "SPUD" -fs "$destVolFSType" -stretch 500g -ov -puppetstrings || errExit
    echo "${progressPrefix}_copyingSource_"
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ] ; then
    echo "Attaching disk image"
    fi
    /usr/bin/hdiutil attach "${destPath}/${dmgTarget}.dmg" -owners on -nobrowse -noautoopen -mountpoint "${mountPoint}" -quiet || errExit
    # Copy source Volume base system to
    /usr/bin/ditto $debug_opt "${installSource}" "${mountPoint}" || errExit
    else
    echo "This does not appear to be a Mac OS X Install DVD."
    errExit
    fi
    # If adding any additional packages or scripts
    if [ -e "${1}/OSInstall.collection" ]; then
    /usr/bin/ditto $debug_opt "${1}/OSInstall.collection" "${mountPoint}/Packages/OSInstall.collection" || errExit
    /usr/sbin/chown root:wheel "${mountPoint}/Packages/OSInstall.collection"
    # If adding any additional packages
    if [ -e "${1}/additionalPackages.txt" ]; then
    CopyPackagesWithDestinationsFromFile "${1}/additionalPackages.txt" || errExit
    fi
    # If adding any scripts
    if [ -e "${1}/additionalScripts.txt" ]; then
    InstallScriptsFromFile "${1}" "${1}/additionalScripts.txt" "${mountPoint}/Packages" || errExit
    fi
    fi
    # If it exists, install the partition data onto the install image
    ProcessAutoPartition "${1}" || errExit
    # If it exists, install minstallconfig.xml (AutoInstall data) onto the install image
    ProcessMinInstall "${1}" || errExit
    # update progress information
    echo "${progressPrefix}_buildingBooter_"
    # Copy kernel and boot loader
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Preparing the kernel and boot loader for the boot image"
    fi
    # make sure this doesn't exist
    if [ -e "${destPath}/i386" ]; then
    /bin/rm -rf "${destPath}/i386"
    fi
    /bin/mkdir -p $debug_opt "${destPath}/i386/x86_64" || errExit
    # copy these directly off the install media
    /usr/bin/ditto $debug_opt "${installSource}/boot.efi" "${destPath}/i386/booter" || errExit
    /usr/bin/chflags nohidden "${destPath}/i386/booter"
    # Grab the relevant portion of the com.apple.Boot.plist
    kernelFlags=`/usr/libexec/PlistBuddy -c "print :'Kernel Flags'" "${installSource}/Library/Preferences/SystemConfiguration/com.apple.Boot.plist"`
    /usr/libexec/PlistBuddy -c "add :'Kernel Flags' string ${kernelFlags}" "${destPath}/i386/com.apple.Boot.plist" > /dev/null 2>&1
    /usr/bin/ditto $debug_opt "${installSource}/System/Library/CoreServices/PlatformSupport.plist" "${destPath}/i386/PlatformSupport.plist" || errExit
    # extract the kernel & kernelcache for the boot shell
    /usr/bin/lipo -extract i386 "${mountPoint}/kernelcache" -output "${destPath}/i386/kernelcache" || errExit
    /usr/bin/lipo -extract x86_64 "${mountPoint}/kernelcache" -output "${destPath}/i386/x86_64/kernelcache" || errExit
    # Apply choice changes, if any
    if [ -e "${1}/MacOSXInstaller.choiceChanges" ]; then
    echo "Copy over package choice selection."
    /usr/bin/ditto $debug_opt "${1}/MacOSXInstaller.choiceChanges" "${mountPoint}/Packages/Extras/MacOSXInstaller.choiceChanges"
    fi
    # update progress information
    echo "${progressPrefix}_finishingUp_"
    # perform the final cleanup
    PostFlightDestination "${1}" "$destPath" || errExit
    rrExit
    # Apply choice changes, if any
    if [ -e "${1}/MacOSXInstaller.choiceChanges" ]; then
    echo "Copy over package choice selection."
    /usr/bin/ditto $debug_opt "${1}/MacOSXInstaller.choiceChanges" "${mountPoint}/Packages/Extras/MacOSXInstaller.choiceChanges"
    fi
    # update progress information
    echo "${progressPrefix}_finishingUp_"
    # perform the final cleanup
    PostFlightDestination "${1}" "$destPath" || errExit
    tDestination "${1}" "$destPath" || errExit
    errExit
    Vol/private/tmp" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Cleaning out /private/tmp on $1"
    fi
    /bin/rm -r $opt "$srcVol/private/tmp/*"
    fi
    if [ -d "$srcVol/private/var/tmp" ]; then
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Cleaning out /private/var/tmp on $1"
    fi
    /bin/rm -r $opt "$srcVol/private/var/tmp/*"
    fi
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    echo "Cleaning out devices and volumes on $1"
    fi
    if [ -d "$srcVol/Volumes" ]; then
    /bin/rm -r $opt "$srcVol/Volumes/*"
    fi
    if [ -d "$srcVol/dev" ]; then
    /bin/rm $opt "$srcVol/dev/*"
    fi
    if [ -d "$srcVol/private/var/run" ]; then
    /bin/rm -r $opt "$srcVol/private/var/run/*"
    fi
    # Copy kernel and build the kext cache on the boot image
    PrepareKernelAndKextCache()
    local srcDir="$1"
    local destDir="$2"
    local opt=""
    if [ "${scriptsDebugKey}" == "VERBOSE" -o "${scriptsDebugKey}" == "DEBUG" ]; then
    Stopping image creation.
    Terminating script!
    Image creation failed.

Maybe you are looking for