Chameleon

Chameleon Commit Details

Date:2011-10-16 23:39:27 (7 years 9 months ago)
Author:ErmaC
Commit:1631
Parents: 1630
Message:Update the Localizable.string file for my subbranch (trunk) with out the module field, also merge latest Blackosx tweak.
Changes:
A/branches/ErmaC/Trunk/package/Scripts/Sub/patch
A/branches/ErmaC/Modules/package/Scripts/Sub/CheckPreviousChameleon.sh
A/branches/ErmaC/Trunk/package/Scripts/Sub/CheckPreviousChameleon.sh
A/branches/ErmaC/Modules/package/Scripts/Sub/patch
M/branches/ErmaC/Trunk/package/Scripts/Main/EFI/postinstall
M/branches/ErmaC/Modules/package/Scripts/Main/Standard/postinstall
M/branches/ErmaC/Trunk/package/Resources/ru.lproj/Localizable.strings
M/branches/ErmaC/Modules/package/Scripts/Main/EFI/postinstall
M/branches/ErmaC/Trunk/package/Resources/id.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Scripts/Sub/WriteChameleonStage2.sh
M/branches/ErmaC/Trunk/package/Scripts/Sub/CheckDiskMicrocode.sh
M/branches/ErmaC/Trunk/package/Resources/el.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Resources/en.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Resources/ar.lproj/Localizable.strings
M/branches/ErmaC/Modules/package/Scripts/Sub/CheckProceed.sh
M/branches/ErmaC/Trunk/package/Resources/es.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Resources/mk.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Resources/it.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Scripts/Main/Standard/postinstall
M/branches/ErmaC/Trunk/package/Resources/sr.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Resources/pt-BR.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Resources/Japanese.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Resources/de.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Resources/bg.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Resources/zh_TW.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Resources/he.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Scripts/Sub/CheckProceed.sh
M/branches/ErmaC/Trunk/package/Resources/zh_CN.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/buildpkg.sh
M/branches/ErmaC/Modules/package/Scripts/Sub/WriteChameleonStage2.sh
M/branches/ErmaC/Modules/package/Scripts/Sub/CheckDiskMicrocode.sh
M/branches/ErmaC/Trunk/package/Resources/pt-PT.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Resources/fr.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Resources/nl.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Resources/hr.lproj/Localizable.strings
M/branches/ErmaC/Trunk/package/Resources/pl.lproj/Localizable.strings

File differences

branches/ErmaC/Trunk/package/Scripts/Main/Standard/postinstall
7676
7777
7878
79
8079
8180
82
81
8382
8483
8584
......
156155
157156
158157
159
160
158
159
160
161
162
163
161164
162
163
165
166
164167
165
166
168
169
167170
168
169
171
172
173
174
175
176
177
178
170179
171180
172
173
174181
175182
176183
# Double check we can see the selected partition and it's of the right type.
# Now also check for another existing Chameleon installation on the same disk.
# If the following script finds anything, it returns 1 to indicate failure.
"$scriptDir"CheckProceed.sh "${targetDisk}" "${targetDeviceRaw}" "${targetVolume}" "${targetDevice}" "${targetVolume}" "${scriptDir}"
"$scriptDir"CheckProceed.sh "${targetVolume}" "${targetDevice}" "${targetVolume}" "${scriptDir}"
returnValue=$?
if [ ${returnValue} = 0 ]; then
# OK to proceed
"$scriptDir"InstallLog.sh "${targetVolume}" "Stage 0 loader not written to ${targetDisk}."
fi
# Write the stage 1 loader to the partition boot sector
"$scriptDir"WriteChameleonStage1.sh "${espformat}" "${stage1LoaderHFS}" "${stage1LoaderFAT}" "${3}" "${targetDeviceRaw}" "${targetVolume}" "${scriptDir}"
# Now also check for another existing Chameleon installation on the same disk.
# If the following script finds anything, it returns 1 to indicate failure.
"$scriptDir"CheckPreviousChameleon.sh "${targetDisk}" "${targetDeviceRaw}" "${targetDevice}" "${targetVolume}" "${scriptDir}"
returnValue=$?
if [ ${returnValue} = 0 ]; then
# OK to proceed
# Write the stage 2 loader to the root of the selected partition
"$scriptDir"WriteChameleonStage2.sh "${espformat}" "${stage2Loader}" "${3}" "${targetDevice}" "${targetVolume}" "${scriptDir}"
# Write the stage 1 loader to the partition boot sector
"$scriptDir"WriteChameleonStage1.sh "${espformat}" "${stage1LoaderHFS}" "${stage1LoaderFAT}" "${3}" "${targetDeviceRaw}" "${targetVolume}" "${scriptDir}"
# Append a line break to the installer log
"$scriptDir"InstallLog.sh "${targetVolume}" "LineBreak"
# Write the stage 2 loader to the root of the selected partition
"$scriptDir"WriteChameleonStage2.sh "${espformat}" "${stage2Loader}" "${3}" "${targetDevice}" "${targetVolume}" "${scriptDir}"
# Set the active partition ONLY if Windows is not installed
"$scriptDir"SetActivePartition.sh "${espformat}" "${diskSigCheck}" "${targetDiskRaw}" "${targetSlice}" "${targetVolume}" "${scriptDir}"
# Append a line break to the installer log
"$scriptDir"InstallLog.sh "${targetVolume}" "LineBreak"
# Set the active partition ONLY if Windows is not installed
"$scriptDir"SetActivePartition.sh "${espformat}" "${diskSigCheck}" "${targetDiskRaw}" "${targetSlice}" "${targetVolume}" "${scriptDir}"
else
echo "Stop" >"${targetVolumeChosenByUser}"/.ChameleonExists
fi
fi
fi
else
echo "Stop" >"${targetVolume}"/.ChameleonExists
fi
"$scriptDir"InstallLog.sh "${targetVolume}" "LineBreak"
branches/ErmaC/Trunk/package/Scripts/Main/EFI/postinstall
8989
9090
9191
92
9392
9493
95
94
9695
9796
9897
......
158157
159158
160159
161
162
160
161
162
163
164
165
163166
164
165
167
168
166169
167
168
170
171
169172
170
171
173
174
175
176
177
178
179
180
172181
173182
174
175
176183
177184
178185
echo "Confirm this is a GPT partitioned disk."
# Double check we can see the selected partition and it's of the right type.
# Now also check for another existing Chameleon installation on the same disk.
# If the following script finds anything, it returns 1 to indicate failure.
"$scriptDir"CheckProceed.sh "${targetDisk}" "${targetDeviceRaw}" "${targetVolume}" "${targetDeviceChosenByUser}" "${targetVolumeChosenByUser}" "${scriptDir}"
"$scriptDir"CheckProceed.sh "${targetVolume}" "${targetDeviceChosenByUser}" "${targetVolumeChosenByUser}" "${scriptDir}"
returnValue=$?
if [ ${returnValue} = 0 ]; then
# OK to proceed
"$scriptDir"InstallLog.sh "${targetVolumeChosenByUser}" "Stage 0 loader not written to ${targetDisk}."
fi
# Write the stage 1 loader to the partition boot sector
"$scriptDir"WriteChameleonStage1.sh "${espformat}" "${stage1LoaderHFS}" "${stage1LoaderFAT}" "${targetVolumeChosenByUser}" "${targetDeviceRaw}" "${targetVolumeChosenByUser}" "${scriptDir}"
# Now also check for another existing Chameleon installation on the same disk.
# If the following script finds anything, it returns 1 to indicate failure.
"$scriptDir"CheckPreviousChameleon.sh "${targetDisk}" "${targetDeviceRaw}" "${targetDeviceChosenByUser}" "${targetVolumeChosenByUser}" "${scriptDir}"
returnValue=$?
if [ ${returnValue} = 0 ]; then
# OK to proceed
# Write the stage 2 loader to the root of the selected partition
"$scriptDir"WriteChameleonStage2.sh "${espformat}" "${stage2Loader}" "${targetVolume}" "${targetDevice}" "${targetVolumeChosenByUser}" "${scriptDir}"
# Write the stage 1 loader to the partition boot sector
"$scriptDir"WriteChameleonStage1.sh "${espformat}" "${stage1LoaderHFS}" "${stage1LoaderFAT}" "${targetVolumeChosenByUser}" "${targetDeviceRaw}" "${targetVolumeChosenByUser}" "${scriptDir}"
# Append a LineBreak to the installer log
"$scriptDir"InstallLog.sh "${targetVolumeChosenByUser}" "LineBreak"
# Write the stage 2 loader to the root of the selected partition
"$scriptDir"WriteChameleonStage2.sh "${espformat}" "${stage2Loader}" "${targetVolume}" "${targetDevice}" "${targetVolumeChosenByUser}" "${scriptDir}"
# Set the active partition ONLY if Windows is not installed
"$scriptDir"SetActivePartition.sh "${espformat}" "${diskSigCheck}" "${targetDiskRaw}" "${targetSlice}" "${targetVolumeChosenByUser}" "${scriptDir}"
# Append a LineBreak to the installer log
"$scriptDir"InstallLog.sh "${targetVolumeChosenByUser}" "LineBreak"
# Set the active partition ONLY if Windows is not installed
"$scriptDir"SetActivePartition.sh "${espformat}" "${diskSigCheck}" "${targetDiskRaw}" "${targetSlice}" "${targetVolumeChosenByUser}" "${scriptDir}"
else
echo "Stop" >"${targetVolumeChosenByUser}"/.ChameleonExists
fi
fi
fi
else
echo "Stop" >"${targetVolumeChosenByUser}"/.ChameleonExists
fi
else
#echo "ERROR Volume is not on a GPT partitioned disc."
branches/ErmaC/Trunk/package/Scripts/Sub/CheckPreviousChameleon.sh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#!/bin/bash
echo "==============================================="
echo "Check Previous Chameleon: Will there be problems?"
echo "***********************************************"
# Checks the selected volume is present and the disk is partitioned
# Now also check for another existing Chameleon installation on the same disk.
# Receives targetDisk: for example, /dev/disk3.
# Receives targetDeviceRaw: for example, /dev/rdisk3s1.
# Receives targetDevice: Stores device number, for example /dev/disk2s1.
# Receives installerVolume: Volume to write the installer log to.
# Receives scriptDir: The location of the main script dir.
if [ "$#" -eq 5 ]; then
targetDisk="$1"
targetDeviceRaw="$2"
targetDevice="$3"
installerVolume="$4"
scriptDir="$5"
echo "DEBUG: passed argument for targetDisk = $targetDisk"
echo "DEBUG: passed argument for targetDeviceRaw = $targetDeviceRaw"
echo "DEBUG: passed argument for targetDevice = $targetDevice"
echo "DEBUG: passed argument for installerVolume = $installerVolume"
echo "DEBUG: passed argument for scriptDir = $scriptDir"
else
echo "Error - wrong number of values passed"
exit 9
fi
# Check for existing Chameleon installations on a different
# partition of the same target disk.
#echo "DEBUG: Checking for existing Chameleon installations on ${targetDisk#/dev/}..."
sliceNumber=$( echo ${targetDeviceRaw#*disk*s} )
# strip slice from end
targetDiskRawNoSlice=$( echo ${targetDeviceRaw%$sliceNumber} )
# Are there any other partitions on the disk?
# How many actual partitions are there?
numSlices=$(( $( diskutil list | grep $( echo ${targetDisk#/dev/} ) | sed -n '$=' ) -2 ))
# Only check the disk for Chameleon installations if there is more than one partition.
if [ $numSlices -gt 1 ]; then
#Scan all partitions for Chameleon code
for (( i=1; i <= $numSlices; i++ ));
do
stageExistence=0
stage0FirstBootable=0
previousExistence="NONE"
targetDiskRaw=$targetDiskRawNoSlice$i
# Check for existing stage 0 boot file (same code as CheckDiskMicrocode.sh script)
stage0type=$( dd 2>/dev/null if="$targetDisk" count=3 bs=1 skip=105 | xxd | awk '{print $2$3}' )
if [ "${stage0type}" == "0b807c" ] || [ "${stage0type}" == "0a803c" ] || [ "${stage0type}" == "ee7505" ] || [ "${stage0type}" == "742b80" ]; then
#echo "DEBUG: boot0 found on $targetDisk"
(( stageExistence++ ))
# While here, check just for either existing boot0hfs, boot0md or boot0md (dmazar's boot0workV2)
if [ "${stage0type}" == "0a803c" ] || [ "${stage0type}" == "ee7505" ] || [ "${stage0type}" == "742b80" ]; then
stage0FirstBootable=1
fi
fi
# Check for existence of a bootable partition boot sector containing either boot1h or boot1f32
boot1Search=$( dd 2>/dev/null if="$targetDiskRaw" count=1 | perl -ne '@a=split"";for(@a){printf"%02x",ord}' )
if [ "${boot1Search:0:16}" == "fa31c08ed0bcf0ff" ] && [ "${boot1Search:1020:2}" == "55" ]; then
#echo "DEBUG: boot1h found on "$targetDiskRaw
(( stageExistence++ ))
previousExistence="boot1"
elif [ "${boot1Search:0:4}" == "e962" ] && [ "${boot1Search:180:12}" == "424f4f542020" ] && [ "${boot1Search:1020:2}" == "55" ]; then
#echo "DEBUG: boot1f32 found on "$targetDiskRaw
(( stageExistence++ ))
previousExistence="boot1f32"
fi
# Check for existing stage 2 boot file also
# NOTE: This will fail to find /boot on /Volumes/EFI as it won't be mounted!
if [ -e "$( df | grep ${targetDisk}s${i} | awk '{ print $6 }' )"/boot ]; then
#echo "DEBUG: boot found on $targetDiskRaw"
(( stageExistence++ ))
fi
#if [ $stageExistence == 3 ] && [ $i -ne $sliceNumber ]; then
#echo "DEBUG: STOP: There is already an existing Chameleon installation on $targetDiskRaw"
#"$scriptDir"InstallLog.sh "${installerVolume}" "STOP: There is already an existing Chameleon installation on $targetDiskRaw."
#"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: This is allowed and does work as long as you aren't dual booting Windows"
#"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: from the same disk and are happy to control which partition is used by"
#"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: flagging the required partition active. General use doesn't require two"
#"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: Chameleon installs on the same disk, though might be done by advanced users."
#"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: If you still want to do this then proceed by installing Chameleon manually."
#exit 1
#fi
if [ $stageExistence -ge 2 ] && [ "$previousExistence" != "NONE" ] && [ $i -ne $sliceNumber ]; then
# There is previous Chameleon stage 1 code on a partition boot sector,
# and either a complete or incomplete installation (ie. boot0 or boot are missing).
if [ $stageExistence == 3 ]; then
"$scriptDir"InstallLog.sh "${installerVolume}" "WARN: There is already an existing Chameleon installation on $targetDiskRaw."
else
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: $previousExistence already exists at ${targetDisk}s${i}"
fi
# This could prove problematic and result in either a b1f:error or boot0:error
# if the following conditions are true:
# A) Boot0hfs, Boot0md or Boot0md (dmazar's Boot0workV2) is being used.
# B) The previous stage 1 code is on a lower partiton than the one being installed to now.
# stage0FirstBootable=1 is used to know if 'A' is true.
if [ $stage0FirstBootable == 1 ]; then
# i = current slice we're checking, slicenumber = slice trying to install to.
if [ $i -lt $sliceNumber ]; then
"$scriptDir"InstallLog.sh "${installerVolume}" "WARN: Conditions point to you receiving a boot failure"
# Fix by making previous paritionboot sector un-bootable
# Change Byte 01FExh to 00 (510 decimal)
"$scriptDir"InstallLog.sh "${installerVolume}" "---"
"$scriptDir"InstallLog.sh "${installerVolume}" "FIX: Make ${targetDisk}s${i} boot sector un-bootable by changing byte 1FEh to 00."
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: Any Extra folder you had there will still be there. If you want to use"
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: ${targetDisk}s${i} again as your boot partition then re-run this installer"
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: selecting it as the target, ONLY choosing the 'Chameleon Bootloader' option"
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: and NONE of the other options."
"$scriptDir"InstallLog.sh "${installerVolume}" "---"
dd if=${targetDisk}s${i} count=1 bs=512 of=/tmp/originalBootSector
cp /tmp/originalBootSector /tmp/newBootSector
dd if="$scriptDir/patch" of=/tmp/newBootSector bs=1 count=1 seek=510 conv=notrunc
dd if=/tmp/newBootSector of=${targetDisk}s${i} count=1 bs=512
else
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: but won't interfere as you're installing to an earlier partition."
fi
else
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: so select to boot that partition (if used) with active flag."
fi
fi
done
#else
#echo "DEBUG: Just one slice"
fi
exit 0
branches/ErmaC/Trunk/package/Scripts/Sub/WriteChameleonStage2.sh
3636
3737
3838
39
39
4040
41
41
4242
4343
4444
45
45
4646
4747
4848
if [ "${selectedDestination}" = "/Volumes/EFI" ]; then
#echo "DEBUG: EFI install chosen"
if [ ! -d "${selectedDestination}" ]; then
if [ ! -e "${selectedDestination}" ]; then
#echo "DEBUG: Executing Command: mkdir -p ${selectedDestination}"
mkdir -p "${targetVolume}"
mkdir -p "${selectedDestination}"
#else
#echo "DEBUG: folder /Volumes/EFI already exists"
fi
#if the EFI system partition was selected then
# mount '/Volumes/EFI' with the correct format type
branches/ErmaC/Trunk/package/Scripts/Sub/CheckDiskMicrocode.sh
5050
5151
5252
53
54
53
54
5555
5656
5757
# See if a Chameleon stage0 boot file already exists
# Note: The checks for Boot0 and Boot0hfs assume the code stays the same.
# if the code changes then the hex values 0b807c, 0a803c and ee7505 used for matching
# Note: The checks for Boot0, Boot0hfs, Boot0md and Boot0md (dmazar's Boot0workV2) assume the code stays the same.
# if the code changes then the hex values 0b807c, 0a803c, ee7505 and 742b80 used for matching
# need to be checked to see if they are the same or not.
stage0type=$( dd 2>/dev/null if="$targetDisk" count=3 bs=1 skip=105 | xxd | awk '{print $2$3}' )
branches/ErmaC/Trunk/package/Scripts/Sub/CheckProceed.sh
77
88
99
10
11
1210
1311
1412
1513
1614
17
18
19
20
21
22
23
24
25
15
16
17
18
19
2620
2721
2822
......
6862
6963
7064
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
13465
# Checks the selected volume is present and the disk is partitioned
# Now also check for another existing Chameleon installation on the same disk.
# Receives targetDisk: for example, /dev/disk3.
# Receives targetDeviceRaw: for example, /dev/rdisk3s1.
# Receives targetVolume: Volume to install to (will be '/Volumes/EFI' if EFI install)
# Receives targetDevice: Stores device number, for example /dev/disk2s1.
# Receives installerVolume: Volume to write the installer log to.
# Receives scriptDir: The location of the main script dir.
if [ "$#" -eq 6 ]; then
targetDisk="$1"
targetDeviceRaw="$2"
targetVolume="$3"
targetDevice="$4"
installerVolume="$5"
scriptDir="$6"
echo "DEBUG: passed argument for targetDisk = $targetDisk"
echo "DEBUG: passed argument for targetDeviceRaw = $targetDeviceRaw"
if [ "$#" -eq 4 ]; then
targetVolume="$1"
targetDevice="$2"
installerVolume="$3"
scriptDir="$4"
echo "DEBUG: passed argument for targetVolume = $targetVolume"
echo "DEBUG: passed argument for targetDevice = $targetDevice"
echo "DEBUG: passed argument for installerVolume = $installerVolume"
fi
fi
# Check for existing Chameleon installations on a different
# partition of the same target disk.
#echo "DEBUG: Checking for existing Chameleon installations on ${targetDisk#/dev/}..."
sliceNumber=$( echo ${targetDeviceRaw#*disk*s} )
# strip slice from end
targetDiskRawNoSlice=$( echo ${targetDeviceRaw%$sliceNumber} )
# Are there any other partitions on the disk?
# How many actual partitions are there?
numSlices=$(( $( diskutil list | grep $( echo ${targetDisk#/dev/} ) | sed -n '$=' ) -2 ))
# Only check the disk for Chameleon installations if there is more than one partition.
if [ $numSlices -gt 1 ]; then
#Scan all partitions for Chameleon code
for (( i=1; i <= $numSlices; i++ ));
do
stageExistence=0
targetDiskRaw=$targetDiskRawNoSlice$i
# Check for existing stage 0 boot file from CheckDiskMicrocode.sh script
stage0type=$( dd 2>/dev/null if="$targetDisk" count=3 bs=1 skip=105 | xxd | awk '{print $2$3}' )
if [ "${stage0type}" == "0b807c" ] || [ "${stage0type}" == "0a803c" ] || [ "${stage0type}" == "ee7505" ] || [ "${stage0type}" == "742b80" ]; then
#echo "DEBUG: boot0 found on $targetDisk"
(( stageExistence++ ))
fi
# Check for boot1h and boot1f32
boot1hSearch=$( dd 2>/dev/null if="$targetDiskRaw" count=1 | perl -ne '@a=split"";for(@a){printf"%02x",ord}' )
if [ "${boot1hSearch:0:16}" == "fa31c08ed0bcf0ff" ]; then
#echo "DEBUG: boot1h found on "$targetDiskRaw
(( stageExistence++ ))
elif [ "${boot1hSearch:0:4}" == "e962" ] && [ "${boot1hSearch:180:12}" == "424f4f542020" ]; then
#echo "DEBUG: boot1f32 found on "$targetDiskRaw
(( stageExistence++ ))
fi
# Check for existing stage 2 boot file also
if [ -e "$( df | grep $targetDisk"s"$i | awk '{ print $6 }' )"/boot ]; then
#echo "DEBUG: boot found on $targetDiskRaw"
(( stageExistence++ ))
fi
if [ $stageExistence == 3 ] && [ $i -ne $sliceNumber ]; then
#echo "DEBUG: STOP: There is already an existing Chameleon installation on $targetDiskRaw"
"$scriptDir"InstallLog.sh "${installerVolume}" "STOP: There is already an existing Chameleon installation on $targetDiskRaw."
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: This is allowed and does work as long as you aren't dual booting Windows"
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: from the same disk and are happy to control which partition is used by"
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: flagging the required partition active. General use doesn't require two"
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: Chameleon installs on the same disk, though might be done by advanced users."
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: If you still want to do this then proceed by installing Chameleon manually."
exit 1
fi
done
#else
#echo "DEBUG: Just one slice"
fi
#"$scriptDir"InstallLog.sh "${installerVolume}" "CheckProceed: PASS"
exit 0
branches/ErmaC/Trunk/package/buildpkg.sh
186186
187187
188188
189
189
190190
191191
192192
......
195195
196196
197197
198
198199
199200
200201
fi
((xmlindent--))
outline[$((outlinecount++))]="${indent[$xmlindent]}</line>"
outline[$((outlinecount++))]="${indent[$xmlindent]}\t</line>"
}
else
{
fi
# End build Modules packages
# build Extras package
# build options packages
branches/ErmaC/Modules/package/Scripts/Main/Standard/postinstall
7676
7777
7878
79
8079
8180
82
81
8382
8483
8584
......
156155
157156
158157
159
160
158
159
160
161
162
163
161164
162
163
165
166
164167
165
166
168
169
167170
168
169
171
172
173
174
175
176
177
178
170179
171180
172
173
174181
175182
176183
# Double check we can see the selected partition and it's of the right type.
# Now also check for another existing Chameleon installation on the same disk.
# If the following script finds anything, it returns 1 to indicate failure.
"$scriptDir"CheckProceed.sh "${targetDisk}" "${targetDeviceRaw}" "${targetVolume}" "${targetDevice}" "${targetVolume}" "${scriptDir}"
"$scriptDir"CheckProceed.sh "${targetVolume}" "${targetDevice}" "${targetVolume}" "${scriptDir}"
returnValue=$?
if [ ${returnValue} = 0 ]; then
# OK to proceed
"$scriptDir"InstallLog.sh "${targetVolume}" "Stage 0 loader not written to ${targetDisk}."
fi
# Write the stage 1 loader to the partition boot sector
"$scriptDir"WriteChameleonStage1.sh "${espformat}" "${stage1LoaderHFS}" "${stage1LoaderFAT}" "${3}" "${targetDeviceRaw}" "${targetVolume}" "${scriptDir}"
# Now also check for another existing Chameleon installation on the same disk.
# If the following script finds anything, it returns 1 to indicate failure.
"$scriptDir"CheckPreviousChameleon.sh "${targetDisk}" "${targetDeviceRaw}" "${targetDevice}" "${targetVolume}" "${scriptDir}"
returnValue=$?
if [ ${returnValue} = 0 ]; then
# OK to proceed
# Write the stage 2 loader to the root of the selected partition
"$scriptDir"WriteChameleonStage2.sh "${espformat}" "${stage2Loader}" "${3}" "${targetDevice}" "${targetVolume}" "${scriptDir}"
# Write the stage 1 loader to the partition boot sector
"$scriptDir"WriteChameleonStage1.sh "${espformat}" "${stage1LoaderHFS}" "${stage1LoaderFAT}" "${3}" "${targetDeviceRaw}" "${targetVolume}" "${scriptDir}"
# Append a line break to the installer log
"$scriptDir"InstallLog.sh "${targetVolume}" "LineBreak"
# Write the stage 2 loader to the root of the selected partition
"$scriptDir"WriteChameleonStage2.sh "${espformat}" "${stage2Loader}" "${3}" "${targetDevice}" "${targetVolume}" "${scriptDir}"
# Set the active partition ONLY if Windows is not installed
"$scriptDir"SetActivePartition.sh "${espformat}" "${diskSigCheck}" "${targetDiskRaw}" "${targetSlice}" "${targetVolume}" "${scriptDir}"
# Append a line break to the installer log
"$scriptDir"InstallLog.sh "${targetVolume}" "LineBreak"
# Set the active partition ONLY if Windows is not installed
"$scriptDir"SetActivePartition.sh "${espformat}" "${diskSigCheck}" "${targetDiskRaw}" "${targetSlice}" "${targetVolume}" "${scriptDir}"
else
echo "Stop" >"${targetVolumeChosenByUser}"/.ChameleonExists
fi
fi
fi
else
echo "Stop" >"${targetVolume}"/.ChameleonExists
fi
"$scriptDir"InstallLog.sh "${targetVolume}" "LineBreak"
branches/ErmaC/Modules/package/Scripts/Main/EFI/postinstall
8989
9090
9191
92
9392
9493
95
94
9695
9796
9897
......
158157
159158
160159
161
162
160
161
162
163
164
165
163166
164
165
167
168
166169
167
168
170
171
169172
170
171
173
174
175
176
177
178
179
180
172181
173182
174
175
176183
177184
178185
echo "Confirm this is a GPT partitioned disk."
# Double check we can see the selected partition and it's of the right type.
# Now also check for another existing Chameleon installation on the same disk.
# If the following script finds anything, it returns 1 to indicate failure.
"$scriptDir"CheckProceed.sh "${targetDisk}" "${targetDeviceRaw}" "${targetVolume}" "${targetDeviceChosenByUser}" "${targetVolumeChosenByUser}" "${scriptDir}"
"$scriptDir"CheckProceed.sh "${targetVolume}" "${targetDeviceChosenByUser}" "${targetVolumeChosenByUser}" "${scriptDir}"
returnValue=$?
if [ ${returnValue} = 0 ]; then
# OK to proceed
"$scriptDir"InstallLog.sh "${targetVolumeChosenByUser}" "Stage 0 loader not written to ${targetDisk}."
fi
# Write the stage 1 loader to the partition boot sector
"$scriptDir"WriteChameleonStage1.sh "${espformat}" "${stage1LoaderHFS}" "${stage1LoaderFAT}" "${targetVolumeChosenByUser}" "${targetDeviceRaw}" "${targetVolumeChosenByUser}" "${scriptDir}"
# Now also check for another existing Chameleon installation on the same disk.
# If the following script finds anything, it returns 1 to indicate failure.
"$scriptDir"CheckPreviousChameleon.sh "${targetDisk}" "${targetDeviceRaw}" "${targetDeviceChosenByUser}" "${targetVolumeChosenByUser}" "${scriptDir}"
returnValue=$?
if [ ${returnValue} = 0 ]; then
# OK to proceed
# Write the stage 2 loader to the root of the selected partition
"$scriptDir"WriteChameleonStage2.sh "${espformat}" "${stage2Loader}" "${targetVolume}" "${targetDevice}" "${targetVolumeChosenByUser}" "${scriptDir}"
# Write the stage 1 loader to the partition boot sector
"$scriptDir"WriteChameleonStage1.sh "${espformat}" "${stage1LoaderHFS}" "${stage1LoaderFAT}" "${targetVolumeChosenByUser}" "${targetDeviceRaw}" "${targetVolumeChosenByUser}" "${scriptDir}"
# Append a LineBreak to the installer log
"$scriptDir"InstallLog.sh "${targetVolumeChosenByUser}" "LineBreak"
# Write the stage 2 loader to the root of the selected partition
"$scriptDir"WriteChameleonStage2.sh "${espformat}" "${stage2Loader}" "${targetVolume}" "${targetDevice}" "${targetVolumeChosenByUser}" "${scriptDir}"
# Set the active partition ONLY if Windows is not installed
"$scriptDir"SetActivePartition.sh "${espformat}" "${diskSigCheck}" "${targetDiskRaw}" "${targetSlice}" "${targetVolumeChosenByUser}" "${scriptDir}"
# Append a LineBreak to the installer log
"$scriptDir"InstallLog.sh "${targetVolumeChosenByUser}" "LineBreak"
# Set the active partition ONLY if Windows is not installed
"$scriptDir"SetActivePartition.sh "${espformat}" "${diskSigCheck}" "${targetDiskRaw}" "${targetSlice}" "${targetVolumeChosenByUser}" "${scriptDir}"
else
echo "Stop" >"${targetVolumeChosenByUser}"/.ChameleonExists
fi
fi
fi
else
echo "Stop" >"${targetVolumeChosenByUser}"/.ChameleonExists
fi
else
#echo "ERROR Volume is not on a GPT partitioned disc."
branches/ErmaC/Modules/package/Scripts/Sub/CheckPreviousChameleon.sh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#!/bin/bash
echo "==============================================="
echo "Check Previous Chameleon: Will there be problems?"
echo "***********************************************"
# Checks the selected volume is present and the disk is partitioned
# Now also check for another existing Chameleon installation on the same disk.
# Receives targetDisk: for example, /dev/disk3.
# Receives targetDeviceRaw: for example, /dev/rdisk3s1.
# Receives targetDevice: Stores device number, for example /dev/disk2s1.
# Receives installerVolume: Volume to write the installer log to.
# Receives scriptDir: The location of the main script dir.
if [ "$#" -eq 5 ]; then
targetDisk="$1"
targetDeviceRaw="$2"
targetDevice="$3"
installerVolume="$4"
scriptDir="$5"
echo "DEBUG: passed argument for targetDisk = $targetDisk"
echo "DEBUG: passed argument for targetDeviceRaw = $targetDeviceRaw"
echo "DEBUG: passed argument for targetDevice = $targetDevice"
echo "DEBUG: passed argument for installerVolume = $installerVolume"
echo "DEBUG: passed argument for scriptDir = $scriptDir"
else
echo "Error - wrong number of values passed"
exit 9
fi
# Check for existing Chameleon installations on a different
# partition of the same target disk.
#echo "DEBUG: Checking for existing Chameleon installations on ${targetDisk#/dev/}..."
sliceNumber=$( echo ${targetDeviceRaw#*disk*s} )
# strip slice from end
targetDiskRawNoSlice=$( echo ${targetDeviceRaw%$sliceNumber} )
# Are there any other partitions on the disk?
# How many actual partitions are there?
numSlices=$(( $( diskutil list | grep $( echo ${targetDisk#/dev/} ) | sed -n '$=' ) -2 ))
# Only check the disk for Chameleon installations if there is more than one partition.
if [ $numSlices -gt 1 ]; then
#Scan all partitions for Chameleon code
for (( i=1; i <= $numSlices; i++ ));
do
stageExistence=0
stage0FirstBootable=0
previousExistence="NONE"
targetDiskRaw=$targetDiskRawNoSlice$i
# Check for existing stage 0 boot file (same code as CheckDiskMicrocode.sh script)
stage0type=$( dd 2>/dev/null if="$targetDisk" count=3 bs=1 skip=105 | xxd | awk '{print $2$3}' )
if [ "${stage0type}" == "0b807c" ] || [ "${stage0type}" == "0a803c" ] || [ "${stage0type}" == "ee7505" ] || [ "${stage0type}" == "742b80" ]; then
#echo "DEBUG: boot0 found on $targetDisk"
(( stageExistence++ ))
# While here, check just for either existing boot0hfs, boot0md or boot0md (dmazar's boot0workV2)
if [ "${stage0type}" == "0a803c" ] || [ "${stage0type}" == "ee7505" ] || [ "${stage0type}" == "742b80" ]; then
stage0FirstBootable=1
fi
fi
# Check for existence of a bootable partition boot sector containing either boot1h or boot1f32
boot1Search=$( dd 2>/dev/null if="$targetDiskRaw" count=1 | perl -ne '@a=split"";for(@a){printf"%02x",ord}' )
if [ "${boot1Search:0:16}" == "fa31c08ed0bcf0ff" ] && [ "${boot1Search:1020:2}" == "55" ]; then
#echo "DEBUG: boot1h found on "$targetDiskRaw
(( stageExistence++ ))
previousExistence="boot1"
elif [ "${boot1Search:0:4}" == "e962" ] && [ "${boot1Search:180:12}" == "424f4f542020" ] && [ "${boot1Search:1020:2}" == "55" ]; then
#echo "DEBUG: boot1f32 found on "$targetDiskRaw
(( stageExistence++ ))
previousExistence="boot1f32"
fi
# Check for existing stage 2 boot file also
# NOTE: This will fail to find /boot on /Volumes/EFI as it won't be mounted!
if [ -e "$( df | grep ${targetDisk}s${i} | awk '{ print $6 }' )"/boot ]; then
#echo "DEBUG: boot found on $targetDiskRaw"
(( stageExistence++ ))
fi
#if [ $stageExistence == 3 ] && [ $i -ne $sliceNumber ]; then
#echo "DEBUG: STOP: There is already an existing Chameleon installation on $targetDiskRaw"
#"$scriptDir"InstallLog.sh "${installerVolume}" "STOP: There is already an existing Chameleon installation on $targetDiskRaw."
#"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: This is allowed and does work as long as you aren't dual booting Windows"
#"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: from the same disk and are happy to control which partition is used by"
#"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: flagging the required partition active. General use doesn't require two"
#"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: Chameleon installs on the same disk, though might be done by advanced users."
#"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: If you still want to do this then proceed by installing Chameleon manually."
#exit 1
#fi
if [ $stageExistence -ge 2 ] && [ "$previousExistence" != "NONE" ] && [ $i -ne $sliceNumber ]; then
# There is previous Chameleon stage 1 code on a partition boot sector,
# and either a complete or incomplete installation (ie. boot0 or boot are missing).
if [ $stageExistence == 3 ]; then
"$scriptDir"InstallLog.sh "${installerVolume}" "WARN: There is already an existing Chameleon installation on $targetDiskRaw."
else
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: $previousExistence already exists at ${targetDisk}s${i}"
fi
# This could prove problematic and result in either a b1f:error or boot0:error
# if the following conditions are true:
# A) Boot0hfs, Boot0md or Boot0md (dmazar's Boot0workV2) is being used.
# B) The previous stage 1 code is on a lower partiton than the one being installed to now.
# stage0FirstBootable=1 is used to know if 'A' is true.
if [ $stage0FirstBootable == 1 ]; then
# i = current slice we're checking, slicenumber = slice trying to install to.
if [ $i -lt $sliceNumber ]; then
"$scriptDir"InstallLog.sh "${installerVolume}" "WARN: Conditions point to you receiving a boot failure"
# Fix by making previous paritionboot sector un-bootable
# Change Byte 01FExh to 00 (510 decimal)
"$scriptDir"InstallLog.sh "${installerVolume}" "---"
"$scriptDir"InstallLog.sh "${installerVolume}" "FIX: Make ${targetDisk}s${i} boot sector un-bootable by changing byte 1FEh to 00."
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: Any Extra folder you had there will still be there. If you want to use"
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: ${targetDisk}s${i} again as your boot partition then re-run this installer"
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: selecting it as the target, ONLY choosing the 'Chameleon Bootloader' option"
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: and NONE of the other options."
"$scriptDir"InstallLog.sh "${installerVolume}" "---"
dd if=${targetDisk}s${i} count=1 bs=512 of=/tmp/originalBootSector
cp /tmp/originalBootSector /tmp/newBootSector
dd if="$scriptDir/patch" of=/tmp/newBootSector bs=1 count=1 seek=510 conv=notrunc
dd if=/tmp/newBootSector of=${targetDisk}s${i} count=1 bs=512
else
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: but won't interfere as you're installing to an earlier partition."
fi
else
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: so select to boot that partition (if used) with active flag."
fi
fi
done
#else
#echo "DEBUG: Just one slice"
fi
exit 0
branches/ErmaC/Modules/package/Scripts/Sub/WriteChameleonStage2.sh
3636
3737
3838
39
39
4040
41
41
4242
4343
4444
45
45
4646
4747
4848
if [ "${selectedDestination}" = "/Volumes/EFI" ]; then
#echo "DEBUG: EFI install chosen"
if [ ! -d "${selectedDestination}" ]; then
if [ ! -e "${selectedDestination}" ]; then
#echo "DEBUG: Executing Command: mkdir -p ${selectedDestination}"
mkdir -p "${targetVolume}"
mkdir -p "${selectedDestination}"
#else
#echo "DEBUG: folder /Volumes/EFI already exists"
fi
#if the EFI system partition was selected then
# mount '/Volumes/EFI' with the correct format type
branches/ErmaC/Modules/package/Scripts/Sub/CheckDiskMicrocode.sh
5050
5151
5252
53
54
53
54
5555
5656
5757
# See if a Chameleon stage0 boot file already exists
# Note: The checks for Boot0 and Boot0hfs assume the code stays the same.
# if the code changes then the hex values 0b807c, 0a803c and ee7505 used for matching
# Note: The checks for Boot0, Boot0hfs, Boot0md and Boot0md (dmazar's Boot0workV2) assume the code stays the same.
# if the code changes then the hex values 0b807c, 0a803c, ee7505 and 742b80 used for matching
# need to be checked to see if they are the same or not.
stage0type=$( dd 2>/dev/null if="$targetDisk" count=3 bs=1 skip=105 | xxd | awk '{print $2$3}' )
branches/ErmaC/Modules/package/Scripts/Sub/CheckProceed.sh
77
88
99
10
11
1210
1311
1412
1513
1614
17
18
19
20
21
22
23
24
25
15
16
17
18
19
2620
2721
2822
......
6862
6963
7064
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
13465
# Checks the selected volume is present and the disk is partitioned
# Now also check for another existing Chameleon installation on the same disk.
# Receives targetDisk: for example, /dev/disk3.
# Receives targetDeviceRaw: for example, /dev/rdisk3s1.
# Receives targetVolume: Volume to install to (will be '/Volumes/EFI' if EFI install)
# Receives targetDevice: Stores device number, for example /dev/disk2s1.
# Receives installerVolume: Volume to write the installer log to.
# Receives scriptDir: The location of the main script dir.
if [ "$#" -eq 6 ]; then
targetDisk="$1"
targetDeviceRaw="$2"
targetVolume="$3"
targetDevice="$4"
installerVolume="$5"
scriptDir="$6"
echo "DEBUG: passed argument for targetDisk = $targetDisk"
echo "DEBUG: passed argument for targetDeviceRaw = $targetDeviceRaw"
if [ "$#" -eq 4 ]; then
targetVolume="$1"
targetDevice="$2"
installerVolume="$3"
scriptDir="$4"
echo "DEBUG: passed argument for targetVolume = $targetVolume"
echo "DEBUG: passed argument for targetDevice = $targetDevice"
echo "DEBUG: passed argument for installerVolume = $installerVolume"
fi
fi
# Check for existing Chameleon installations on a different
# partition of the same target disk.
#echo "DEBUG: Checking for existing Chameleon installations on ${targetDisk#/dev/}..."
sliceNumber=$( echo ${targetDeviceRaw#*disk*s} )
# strip slice from end
targetDiskRawNoSlice=$( echo ${targetDeviceRaw%$sliceNumber} )
# Are there any other partitions on the disk?
# How many actual partitions are there?
numSlices=$(( $( diskutil list | grep $( echo ${targetDisk#/dev/} ) | sed -n '$=' ) -2 ))
# Only check the disk for Chameleon installations if there is more than one partition.
if [ $numSlices -gt 1 ]; then
#Scan all partitions for Chameleon code
for (( i=1; i <= $numSlices; i++ ));
do
stageExistence=0
targetDiskRaw=$targetDiskRawNoSlice$i
# Check for existing stage 0 boot file from CheckDiskMicrocode.sh script
stage0type=$( dd 2>/dev/null if="$targetDisk" count=3 bs=1 skip=105 | xxd | awk '{print $2$3}' )
if [ "${stage0type}" == "0b807c" ] || [ "${stage0type}" == "0a803c" ] || [ "${stage0type}" == "ee7505" ] || [ "${stage0type}" == "742b80" ]; then
#echo "DEBUG: boot0 found on $targetDisk"
(( stageExistence++ ))
fi
# Check for boot1h and boot1f32
boot1hSearch=$( dd 2>/dev/null if="$targetDiskRaw" count=1 | perl -ne '@a=split"";for(@a){printf"%02x",ord}' )
if [ "${boot1hSearch:0:16}" == "fa31c08ed0bcf0ff" ]; then
#echo "DEBUG: boot1h found on "$targetDiskRaw
(( stageExistence++ ))
elif [ "${boot1hSearch:0:4}" == "e962" ] && [ "${boot1hSearch:180:12}" == "424f4f542020" ]; then
#echo "DEBUG: boot1f32 found on "$targetDiskRaw
(( stageExistence++ ))
fi
# Check for existing stage 2 boot file also
if [ -e "$( df | grep $targetDisk"s"$i | awk '{ print $6 }' )"/boot ]; then
#echo "DEBUG: boot found on $targetDiskRaw"
(( stageExistence++ ))
fi
if [ $stageExistence == 3 ] && [ $i -ne $sliceNumber ]; then
#echo "DEBUG: STOP: There is already an existing Chameleon installation on $targetDiskRaw"
"$scriptDir"InstallLog.sh "${installerVolume}" "STOP: There is already an existing Chameleon installation on $targetDiskRaw."
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: This is allowed and does work as long as you aren't dual booting Windows"
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: from the same disk and are happy to control which partition is used by"
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: flagging the required partition active. General use doesn't require two"
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: Chameleon installs on the same disk, though might be done by advanced users."
"$scriptDir"InstallLog.sh "${installerVolume}" "NOTE: If you still want to do this then proceed by installing Chameleon manually."
exit 1
fi
done
#else
#echo "DEBUG: Just one slice"
fi
#"$scriptDir"InstallLog.sh "${installerVolume}" "CheckProceed: PASS"
exit 0

Archive Download the corresponding diff file

Revision: 1631