summaryrefslogtreecommitdiff
path: root/scripts/install-system
blob: 2e821397206fda668f9109859621155cdfef3483 (plain)
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
#!/bin/bash
#
# Module: install-system
# 
# **** License ****
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# This code was originally developed by Vyatta, Inc.
# Portions created by Vyatta are Copyright (C) 2006, 2007 Vyatta, Inc.
# All Rights Reserved.
# 
# Author: Robert Bays
# Date: 2006
# Description:
# 
# **** End License ****
#
# Vyatta system installer script.
#

if [ `whoami` != 'root' ] ; then
    echo "This script must be run with root privileges."
    exit 1
fi

# If you set VYATTA_AUTO_INSTALL I will try to do an automated install for you

if [ -e /etc/default/vyatta ] ; then
    . /etc/default/vyatta
fi

: ${vyatta_prefix:=/opt/vyatta}
: ${vyatta_exec_prefix:=$vyatta_prefix}
: ${vyatta_bindir:=${vyatta_exec_prefix}/bin}
: ${vyatta_sbindir:=${vyatta_exec_prefix}/sbin}
: ${vyatta_sysconfdir:=${vyatta_prefix}/etc}

ofrconfdir=${vyatta_sysconfdir}/config
fdconfdir=/media/floppy/config
rootfsdir=/mnt/rootfs

# By default this is not a union install
# UNION=false

# install log file name
INSTALL_LOG=/tmp/install-$$.log
# Absolute minimum root partition size in MB.  Below this, we won't let
# you install.
ROOT_MIN=1000

# the base install drive e.g. sda
if [ -n "$INSTALL_DRIVE" ]; then
  INSTALL_DRIVE=""
fi
# the install partition e.g. sda1
if [ -n "$ROOT_PARTITION" ]; then
  ROOT_PARTITION=""
fi
# the config partition e.g. sda2
if [ -n "$CONFIG_PARTITION" ]; then
  CONFIG_PARTITION=""
fi
# the size of the root partition
if [ -n "$ROOT_PARTITION_SIZE" ]; then
  ROOT_PARTITION_SIZE=""
fi
# global holding variable used in the select_partition sub
PARTITION=''

# default file system type
ROOT_FSTYPE="ext3"

# Process ID of this script for the lame marketing spinner
SPID=$$

# Grub options
GRUB_OPTIONS="quiet"

# Output to both console (last device is /dev/console)
VTY_CONSOLE="console=ttyS0,9600 console=tty0"
SERIAL_CONSOLE="console=tty0 console=ttyS0,9600"

# trap signals so we can kill runaway progress indicators
trap 'progress_indicator stop; exit 1' 1
trap 'progress_indicator stop; exit 1' 2

# turn off any mounted swap partitions
turnoffswap () {
  if [ -f "/proc/swaps" ]; then
    myresponse=$(cat /proc/swaps)
    if [ -n "$myresponse" ]; then
      echo "turning off swaps..." >> $INSTALL_LOG
      swapoff -a
    fi
  fi
}

# Validates a user response.  Returns the response if valid.
# Returns the default is the user just hits enter.  
# Returns nothing if not valid.  Default parameter is $1.
# Options are in $2.  If options are defined return must be a member
# of the enum. 
get_response () {
  ldefault=$(echo "$1" | tr [:upper:] [:lower:])
  loptions=$(echo "$2" | tr [:upper:] [:lower:])

  # get the response from the user
  read myresponse
  myresponse=$(echo "$myresponse" | tr [:upper:] [:lower:])

  # Check to see if the user accepts the default
  if [ -z "$myresponse" ]; then
    echo -n $ldefault
  # if we are passing in options to check, make sure response is a valid option
  elif [ -n "$loptions" ]; then
    for token in $loptions
      do
        if [ "$token" == "$myresponse" ]; then
          echo -n "$myresponse"
          return 0
        fi
      done
    return 1
  else
    echo -n "$myresponse"
  fi

  return 0
}

# Return the size of the drive in MB
get_drive_size () {
  ldrive=$1

  # Make sure you can print disk info using parted
  parted /dev/$ldrive p >/dev/null 2>&1

  # If unable to read disk, it's likely it needs a disklabel
  if [  "$?" != "0" ]; then
    echo "Creating a new disklabel on $ldrive" >> $INSTALL_LOG
    echo "parted /dev/$ldrive mklabel msdos" >> $INSTALL_LOG
    output=$(parted /dev/$ldrive mklabel msdos)

    # Get the drive size from parted
    lsize=$(parted /dev/$ldrive p | grep "^Disk" | awk '{ print $3 }')

    if [ $(echo $lsize | grep error) ]; then
      echo "Unable to read disk label.  Exiting."
      exit 1
    fi
  fi

  # Get the drive size from parted
  lsize=$(parted /dev/$ldrive p | grep "^Disk" | awk '{ print $3 }')
  # Get the reported units (mB, GB, kB)
  lmodifier=$(echo $lsize | sed 's/[0-9\.]//g')
  # remove the modifier
  lsize=$(echo $lsize | sed 's/[a-z,A-Z]//g')
  # Remove any fractions
  lsize=$(echo $lsize | cut -f1 -d'.')
  # Translate our size into mB if not there already
  if [ $lmodifier = "GB" ]; then 
    lsize=$(($lsize * 1000))
  elif [ $lmodifier = "kB" ]; then 
    lsize=$(($lsize / 1000))
  fi

  echo $lsize
}


# Probe hardrives not shown in /proc/partitions by default
probe_drives () {
  # Find drives that may not be in /proc/partitions since not mounted
  drive=$(ls /sys/block  | grep '[hsv]d.')

  # now exclude all drives that are read-only
  for drive in $drive
  do
      if [ $(cat /sys/block/$drive/ro) -ne 0 ]
      then
	  output=$(mount | grep $drive)
	  if [ -z "$output" ]; then
              output=$(parted /dev/$drive p)
	  fi
      fi
  done
}


warn_of_dire_consequences () {
  # Give the user a requisite warning that we are about to nuke their drive
  response=''
  while [ -z $response ]
  do
    echo "This will destroy all data on /dev/$INSTALL_DRIVE."
    echo -n "Continue? (Yes/No) [No]: "
    response=$(get_response "No" "Yes No Y N")

    if [ "$response" == "no" ] || [ "$response" == "n" ]; then
      echo "Ok then.  Exiting..."
      exit 1
    fi
  done
}



check_for_old_raid () {
    # First, trigger construction of previously configured RAID groups
    echo -n "Looking for pre-existing RAID groups..."
    raid_config=`mdadm --examine --scan`
    if [ -z "$raid_config" ]; then
	echo "none found."
	return
    fi

    echo "found some."
    echo "Trying to configure pre-existing RAID groups..."
    mdadm --assemble --scan --auto=yes --symlink=no

    # Identify physical drives
    raid_drives=$(cat /proc/partitions | awk '{ if ($4!="name") { print $4 } }' | grep "md" | egrep -v "^$")

    if [ -z "$raid_drives" ]; then
	echo "Unable to configure any RAID groups."
	return
    fi

    numraids=`echo $raid_drives | wc -w`

    if [ $numraids -eq 1 ]; then
	echo "The following RAID group is now configured:"
    else
	echo "The following RAID groups are now configured:"
    fi

    for drive in $raid_drives
    do
	cat /proc/mdstat | grep --after-context 2 ^$drive | sed -e 's/^/\t/'
    done

    if [ $numraids -eq 1 ]; then
	echo -n "Would you like to use this one? (Yes/No) [Yes]:"
    else
	echo -n "Would you like to use one of these? (Yes/No) [Yes]:"
    fi

    response=$(get_response "Yes" "Yes No Y N")
    if [ "$response" == "no" ] || [ "$response" == "n" ]; then
	echo
	echo "Ok.  Not using existing RAID groups."
	echo

	# pick the first RAID group to be broken
	raid_drive=$(echo $raid_drives | /usr/bin/awk '{ print $1 }')

	echo "Would you like to break RAID group $raid_drive so that its"
	echo "members can be re-used for a new installation, understanding"
	echo -n "that doing so will destroy all data on it? (Yes/No) [No]:"
	destroy_raid=$(get_response "No" "Yes No Y N")
	echo

	if [ "${destroy_raid:0:1}" = "y" ]; then
	    echo "OK.  Breaking the RAID group $raid_drive."
	    
	    members=`ls /sys/block/$raid_drive/slaves`

	    echo "First, stopping all existing RAID groups:"
	    mdadm --stop --scan

	    for member in $members ; do
		drive=${member:0:3}
		part=${member:3:1}
		echo "Re-setting partition ID for RAID group $raid_drive member /dev/${member}:"
		sfdisk --change-id /dev/$drive $part 0x83
		echo "Clearing RAID superblock from RAID group $raid_drive member /dev/${member}."
		mdadm --zero-superblock /dev/$member
	    done
	else
	    echo "OK.  Stopping, but not breaking, existing RAID groups:"
	    mdadm --stop --scan
	fi

	echo
	return
    fi

    if [ $numraids -eq 1 ]; then
	INSTALL_DRIVE=$raid_drives
    else
	# take the first drive as the default
	INSTALL_DRIVE=$(echo $raid_drives | /usr/bin/awk '{ print $1 }')
    	echo -n "Which one would you like to use? ($raid_drives) [$INSTALL_DRIVE]: "
	INSTALL_DRIVE=$(get_response "$INSTALL_DRIVE" "$drives")
    fi

    echo "Using RAID partition $INSTALL_DRIVE"

    raid_degraded=`cat /sys/block/$INSTALL_DRIVE/md/degraded`
    raid_sync_action=`cat /sys/block/$INSTALL_DRIVE/md/sync_action`

    if [ "$raid_degraded" = "1" ]; then
	echo
	if [ "$raid_sync_action" = "recover" ]; then
	    echo "Error: This RAID set is degraded and is in the process of"
	    echo "rebuilding.  It is not safe to install onto it while the"
	    echo "rebuild is in progress. Please wait for the rebuild to"
	    echo "complete and then re-start the installation.  You may"
	    echo "monitor the progress of the RAID rebuild with the"
	    echo "command:"
	    echo
	    echo "    show raid $INSTALL_DRIVE"
	    echo
	    exit 1
	fi
	echo "Warning:  This RAID set is degraded, but is not in the"
	echo "process of rebuilding.  It is safe to perform the installation"
	echo "onto a degraded RAID set that is not in the process of"
	echo "rebuilding.  You may stop the installation now and rebuild the"
	echo "RAID set, or continue installing onto it.  If you continue"
	echo "installing, do not attempt to rebuild the RAID set until the"
	echo "installation has completed and you have rebooted the system."
	echo
    fi

    warn_of_dire_consequences

    ROOT_PARTITION=$INSTALL_DRIVE

    # make sure we aren't working on a mounted part
    unmount "$INSTALL_DRIVE"

    # check for an old config on the partition
    check_config_partition "$ROOT_PARTITION"

    # create the filesystem on the part
    make_filesystem "$ROOT_PARTITION"

    INSTALL_METHOD=RAID
}

check_for_new_raid () {
    # Identify physical drives
    drives=$(cat /proc/partitions | awk '{ if ($4!="name") { print $4 } }' | egrep -v "[0-9]$" | egrep -v "^$")

    numdrives=`echo $drives | wc -w`

    # Need at least two drives for RAID-1.  We don't yet have the code
    # to handle selection of two from a set of 3 or more, so for now, we
    # only support two drives.
    #
    if [ $numdrives -ne 2 ]; then
	return
    fi

    drive1=`echo $drives | awk '{ print $1 }'`
    drive2=`echo $drives | awk '{ print $2 }'`

    drivesize1=$(get_drive_size $drive1)
    drivesize2=$(get_drive_size $drive2)

    # Both drives must have enough space to hold our minimum root filesystem
    #
    if [ $drivesize1 -lt $ROOT_MIN -o $drivesize2 -lt $ROOT_MIN ]; then
	return
    fi


    echo "You have two disk drives:"
    echo -e "\t$drive1 \t$drivesize1 MB"
    echo -e "\t$drive2 \t$drivesize2 MB"

    echo -n "Would you like to configure RAID-1 mirroring on them? (Yes/No) [Yes]:"
    response=$(get_response "Yes" "Yes No Y N")
    if [ "$response" == "no" ] || [ "$response" == "n" ]; then
	echo "Ok.  Not configuring RAID-1."
	return
    fi

    if [ $drivesize1 -ne $drivesize2 ]; then
	echo "Since the disks are not the same size, we will use the smaller"
	echo "of the two sizes in configuring the RAID-1 set.  This will"
	echo "waste some space on the larger drive."
	echo ""
    fi

    # Configure RAID-1
    echo "This process will erase all data on both drives."
    echo -n "Are you sure you want to do this? (Yes/No) [No]: "
    response=$(get_response "Yes" "Yes No Y N")
    if [ "$response" == "no" ] || [ "$response" == "n" ]; then
	echo "Ok.  Not configuring RAID-1."
	return
    fi
    
    for drive in $drives
    do
	echo "Deleting old partitions on drive $drive"
	# remove any existing partitions on that drive
	delete_partitions "$drive"
    done

    # Need to leave space on both disks between the MBR and the start
    # of the first partition for grub.  Grub needs to embed a large
    # boot image there when booting off RAID devices.
    #
    # Partition creation variables are in units of megabytes.
    part_start_offset=2
    part_diag_size=60

    if [ $drivesize1 -lt $drivesize2 ]; then
	root_size=$drivesize1
    else
	root_size=$drivesize2
    fi

    let min_size_with_diag=${MIN_ROOT}+${part_diag_size}
    if [ $root_size -ge $min_size_with_diag ]; then
	echo "Would you like me to create a $part_diag_size MB partition for diagnostics?"
	echo -n "(Yes/No) [No]: "
	diag_response=$(get_response "No" "Yes No Y N")
	if [ "$diag_response" == "yes" ] || [ "$diag_response" == "y" ]; then
	    for drive in $drives
	    do
		echo "Creating diag partition on drive $drive"
		create_partitions "$drive" $part_diag_size $part_start_offset "no"
		sfdisk --change-id /dev/$drive 1 0x6
	    done
	    data_dev=2
	    let part_start_offset+=$part_diag_size
	else
	    data_dev=1
	fi
    fi

    let root_size-=$part_start_offset

    for drive in $drives
    do
	echo "Creating data partition: /dev/${drive}${data_dev}"
	create_partitions "$drive" $root_size $part_start_offset "no"
	sfdisk --change-id /dev/$drive $data_dev 0xfd
    done

    # Must give partition device time to settle
    sleep 5
    echo

    for drive in $drives
    do
	echo "Erasing any previous RAID metadata that may exist on /dev/${drive}${data_dev}"
	mdadm --zero-superblock /dev/${drive}${data_dev}
    done

    echo "Creating RAID-1 group on partitions: /dev/${drive1}${data_dev} /dev/${drive2}${data_dev}"

    raid_dev=md0
    mdadm --create /dev/$raid_dev --level=1 --raid-disks=2 /dev/${drive1}${data_dev} /dev/${drive2}${data_dev}

    if [ $? = 0 -a -e /dev/$raid_dev ]; then
	echo "RAID-1 group created successfully:"
	cat /proc/mdstat | grep --after-context 2 ^$raid_dev | sed -e 's/^/\t/'
    else
	echo "Unable to create RAID-1 group!"
	return
    fi

    INSTALL_DRIVE=$raid_dev
    ROOT_PARTITION=$INSTALL_DRIVE

    # Give device time to settle...
    sleep 5

    # create the filesystem on the part
    make_filesystem "$ROOT_PARTITION"

    INSTALL_METHOD=RAID
}


# Takes an argument to display text before choice
# Sets INSTALL_DRIVE.  Note that select_drive should be wrapped 
# in the verification loop, not the included get_response.
select_drive () {
  # list the drives in /proc/partitions.  Remove partitions and empty lines.
  # the first grep pattern looks for devices named c0d0, hda, and sda.
  drives=$(cat /proc/partitions | \
           awk '{ if ($4!="name") { print $4 } }' | \
           egrep "c[0-9]d[0-9]$|[hsv]d[a-z]$" | \
           egrep -v "^$")

  # take the first drive as the default
  INSTALL_DRIVE=$(echo $drives | /usr/bin/awk '{ print $1 }')

  # Add the drive sizes to the display to help the user decide
  display=''
  for drive in $drives
  do
    size=$(get_drive_size $drive)
    display="$display $drive\t$size"MB"\n"
  done

  while true
  do
	# Display the drives and ask the user which one to install to
	echo -e "$display"
	echo
	echo -n "$1 [$INSTALL_DRIVE]:"
	response=$(get_response "$INSTALL_DRIVE" "$drives") && break
  done
  INSTALL_DRIVE="$response"

  echo

  # If disk is small, it is probably a CF device or virtual environment
  # So avoid the overhead of a journal
  size=$(get_drive_size $INSTALL_DRIVE)
  if [[ $size -lt 11000 ]]
  then
      ROOT_FSTYPE="ext2"
  fi
}

# Allow the user to select a partition to work with
# sets the global PARTITION
# $1 is the text to display before prompt
select_partition () {
  minsize=$1
  text=$2
  exclude=$3

  echo -n "Looking for appropriate partitions:  "
  progress_indicator start

  # initialize out global var.  using globals in this way is bad form.  I know.
  PARTITION=''

  # list only the partitions in /proc/partitions.
  parts=$(cat /proc/partitions | awk '{ if ($4!="name") { print $4 " "} }' | egrep "[0-9]" | egrep -v "loop" | tr -d '\n')

  # remove any partitions we have already previously used
  if [ -n "$exclude" ]; then
    for part in $parts; 
    do
      temp=$(echo $part | egrep -v $exclude)
      parts_temp="$parts_temp $temp"
    done
    parts=$parts_temp
  fi

  # Get the partition sizes for display
  # only show linux partitions that have sizes, i.e. remove loops
  display=''
  myparts=''
  for part in $parts
  do
    if [ ${part:0:2} = "md" ]; then
      parttype="RAID"
    else
      rootdev=$(echo $part | sed 's/[0-9]//g')
      parttype=$(fdisk -l /dev/$rootdev | grep $part | grep Linux)
    fi
    if [ -n "$parttype" ]; then
      lsize=$(get_drive_size $part)
      if [ "$lsize" -a $lsize -ge $minsize ]; then
        display="$display $part\t\t$lsize"MB"\n"
        myparts="$myparts $part"
      fi
    fi
  done

  progress_indicator stop
  echo "OK"

  if [ -n "$myparts" ]; then
    lpartition=''
    while [ -z "$lpartition" ]
    do
      # take the first partition as the default
      lpartition=$(echo $myparts | /usr/bin/awk '{ print $1 }')

      echo "I found the following partitions suitable for the Vyatta image:"
      echo -e "Partition\tSize"
      echo -e "$display"
      echo
      echo -n "$text [$lpartition]: "

      lpartition=$(get_response "$lpartition" "$myparts")
      echo
    done
  else
    echo "No suitable partition sizes found.  Exiting..."  | tee $INSTALL_LOG
    exit 1
  fi
  PARTITION=$lpartition
}

rename_old_config() {
  files=$(find /mnt/config -mindepth 1 -type f | grep -v pre-glendale)
  for f in $files; do
    if grep -q '/\*XORP Configuration File, v1.0\*/' $f >&/dev/null; then
      CURTIME=$(date +%F-%H%M%S)
      mv $f $f.pre-glendale.$CURTIME
    fi
  done
}

## check_config_partition
# look to see if this partition contains a config file
# and back it up
check_config_partition() {
  lpart=$1

  # Cleanup from possible partial last run
  rm -fr /mnt/config

  # Look to see if this is a config partition
  mkdir -p /mnt/tmp
  output=$(mount /dev/$lpart /mnt/tmp 2>&1)
  if [ $? != 0 ]; then
    echo -e "Cannot mount /dev/$lpart"."\nmount /dev/$ldrive$part /mnt/tmp\nExiting..." >> $INSTALL_LOG
    echo "$output" >> $INSTALL_LOG
  else
    # Look to see if there is a config partition there
    if [ -f /mnt/tmp/opt/vyatta/etc/config/.vyatta_config ] || [ -f /mnt/tmp/.vyatta_config ]; then
      response=''
      while [ -z "$response" ]
      do
        echo "/dev/$lpart has an old configuration directory!"
        echo -ne "Would you like me to save the data on it\nbefore I delete it? (Yes/No) [Yes]: "
        response=$(get_response "Yes" "Yes No Y N")
        if [ "$response" == "yes" ] || [ "$response" == "y" ]; then
          mkdir -p /mnt/config
          if [ -d /mnt/tmp/opt/vyatta/etc/config ]; then
            output=$(cp -pR /mnt/tmp/opt/vyatta/etc/config/* /mnt/config)
          else
            output=$(cp -pR /mnt/tmp/* /mnt/config)
          fi
          if [ -n "$output" ]; then
            echo -e "Warning: error in copying the old config partition.\nSee $INSTALL_LOG for more details."
            echo -e "Warning: error in copying the old config partition.\ncp -pR /mnt/tmp/* /mnt/config\n$output\n" >> $INSTALL_LOG
          fi
          rename_old_config
        fi
      done
    fi
    umount /mnt/tmp
  fi
}

# Delete all existing partitions for an automated install
# $1 is the drive to delete partitions from
delete_partitions () {
  ldrive=$1

  # get the partitions on the drive
  # in the first grep below we add the optional [p] in order to accomdate cciss drives
  partitions=$(cat /proc/partitions | grep $ldrive[p]*[0-9] | awk '{ print $4 }' | sed 's/\(.*\)\([0-9]$\)/\2/g' | grep -v "^$")

  # now for each part, blow it away
  for part in $partitions
  do
    # Look to see if this is a config partition
    check_config_partition "$ldrive$part"

    echo "Removing partition $part on /dev/$ldrive" >> $INSTALL_LOG
    output=$(parted /dev/$ldrive rm $part)
    status=$?
    if [ "$status" != 0 ]; then
      echo -e "Warning: cannot delete partition $part on $ldrive.\nPlease see $INSTALL_LOG for more details."
      echo -e "Warning: cannot delete partition $part on $ldrive.\nparted /dev/$ldrive rm $part\n$output" >> $INSTALL_LOG
    fi

    # We add a bogus sleep here because the loop needs to wait for udev
    sleep 5
  done
}

# make a filesystem on the drive
# $1 is the drive to format
make_filesystem () {
  ldrive=$1

  echo -n "Creating filesystem on /dev/$ldrive:  "
  echo "Creating filesystem on /dev/$ldrive..." >> $INSTALL_LOG

  progress_indicator start
  output=$(mkfs -t $ROOT_FSTYPE /dev/$ldrive 2>&1)
  status=$?
  if [ "$status" != 0 ]; then
    echo -e "Error: couldn't create the root filesystem.\nSee $INSTALL_LOG for further details.\nExiting..."
    echo -e "Error: couldn't create the root filesystem.\n/sbin/mke2fs -j /dev/$ldrive\n$output"
    exit 1
  fi
  progress_indicator stop
  echo "OK"
}

# create the root partition
# $1 is the install drive e.g. sda
# $2 is the partition size e.g. 512
# This will set the global ROOT_PARTITION
create_partitions() {
  ldrive=$1
  root_part_size=$2
  start_offset=$3
  initialize_fs=$4

  # Make sure there is enough space on drive
  size=$(get_drive_size "$ldrive") 
  if [ "$root_part_size" -gt "$size" ]; then
    echo "Error: $ldrive is only $size"MB" large.  Desired root is $root_part_size"
    exit 1
  fi

  echo "Creating root partition on /dev/$ldrive" >> $INSTALL_LOG
  
  # make the root partition
  output=$(parted /dev/$ldrive mkpart primary $start_offset $root_part_size)
  status=$?
  if [ "$status" != 0 ]; then
    echo -e "Error creating primary partition on $ldrive.\nPlease see $INSTALL_LOG for more details.\nExiting..."
    echo -e "Error creating primary partition on $ldrive.\nparted /dev/$ldrive mkpart primary 0 $root_part_size\n$output" >> $INSTALL_LOG
    exit 1
  fi

  # set the partition number on the device.
  if [ -n "$( echo $ldrive | grep cciss )" ]; then
    # if this is a cciss
    ROOT_PARTITION=$ldrive"p1"
  else
    # else... the rest of the world
    ROOT_PARTITION=$ldrive"1"
  fi
  # udev takes time to re-add the device file, so wait for it
  while [ ! -b "/dev/$ROOT_PARTITION" ] 
  do 
    sleep 1
  done

  if [ "$initialize_fs" = "yes" ]; then
    # make the root and config file systems.
    make_filesystem "$ROOT_PARTITION"
  fi
}

# Install the root filesystem
# $1 is the partition to install on
install_root_filesystem () {
  ldrive=$1
  version=$(egrep -i version /opt/vyatta/etc/version | awk '{ print $3 }')

  dpkg="/usr/bin/dpkg --force-all --root=$rootfsdir"
  echo "Mounting /dev/$ldrive "
  echo "Mounting /dev/$ldrive..." >> $INSTALL_LOG

  # make the mount point
  output=$(/bin/mkdir -p $rootfsdir)

  # mount the partition
  output=$(mount /dev/$ldrive $rootfsdir)
  status=$?
  
  if [ "$status" != 0 ]; then
    echo -e "Error trying to mount the new root partition.\nPlease see $INSTALL_LOG for details.\nExiting..."
    echo -e "Error trying to mount the new root partition.\nmount /dev/$ldrive $rootfsdir\n$output" >> $INSTALL_LOG
    exit 1
  fi
  
  if [ -z $UNION ]; then
    echo -n "Copying system image files to /dev/$ROOT_PARTITION: "
    progress_indicator start
    # Mount the squashfs for copying
    output=$(mkdir -p /mnt/squashfs)
    if [ -f /live/image/live/filesystem.squashfs ]; then
      output=$(mount /live/image/live/filesystem.squashfs /mnt/squashfs -t squashfs -o loop)
      status=$?
    elif [ -f /live/image/boot/$version/$version.squashfs ]; then
      output=$(mount /live/image/boot/$version/$version.squashfs /mnt/squashfs -t squashfs -o loop)
      status=$?
    else
      echo -e "Error: Unable to find a squash image. To install natively\nthe install media must be a livecd or a union install.\nExiting...\n\n"
      echo -e "Error: Unable to find a squash image. To install natively\nthe install media must be a livecd or a union install.\nExiting...\n\n" >> $INSTALL_LOG
      exit 1
    fi
  
    if [ "$status" != 0 ]; then
      echo -e "Error trying to mount the squashfs.\nPlease see install log for more details.\nExiting..."
      echo -e "Error trying to mount the squashfs.\nmount /live/image/live/filesystem.squashfs /mnt/squashfs -t squashfs -o loop\n$output" >> $INSTALL_LOG
      exit 1
    fi

    output=$(cp -pR /mnt/squashfs/* $rootfsdir/)
    status=$?
  
    if [ "$status" != 0 ]; then
      echo -e "Error trying to copy the rootfs.\nPlease see install log for more details.\nExiting..."
      echo -e "Error trying to copy the rootfs.\ncp -pR /mnt/squashfs/* $rootfsdir/\n$output" >> $INSTALL_LOG
      exit 1
    fi

    # unmount the squashfs.  No big deal if it fails.
    output=$(umount /mnt/squashfs)

    # create the fstab
    local rootdev="/dev/$ROOT_PARTITION";
    uuid=$(dumpe2fs -h $rootdev 2>/dev/null | awk '/^Filesystem UUID/ {print $3}')
    if [ -z "$uuid" ]
    then
        echo "Unable to read filesystem UUID.  Exiting."
        exit 1
    else
      echo -e "UUID=$uuid\t/\t$ROOT_FSTYPE\tnoatime\t0 1" >> $rootfsdir/etc/fstab
    fi

    #setup the hostname file
    cp /etc/hostname $rootfsdir/etc/
    cp /etc/hosts $rootfsdir/etc/

    progress_indicator stop
    echo "OK"
  else
    mkdir -p $rootfsdir/boot/$version
    if [ -f /live/image/live/filesystem.squashfs ]; then
      echo Copying squashfs image...
      cp /live/image/live/filesystem.squashfs $rootfsdir/boot/$version/$version.squashfs
      echo Copying kernel and initrd images...
      cp -a /boot/* $rootfsdir/boot/$version/
    else
      echo Copying image files...
      cp -ar /live/image/boot/$version $rootfsdir/boot/
    fi
  fi
}

# copy the configuration to the config partition
# $1 is the config partition device
copy_config () {
  config_partition=$1
  lerror=''
  config_default=$vyatta_sysconfdir/config.boot.default
  tmp_config_default=/tmp/${vyatta_sysconfdir//\//__}

  # create the config directory on the union file system
  mkdir -p $rootfsdir$ofrconfdir

  # create the proper perms on the new config partition
  chgrp vyattacfg $rootfsdir$ofrconfdir
  chmod 775 $rootfsdir$ofrconfdir

  # create our config partition marker
  touch $rootfsdir$ofrconfdir/.vyatta_config

  if [ -d /mnt/config ]; then
    echo "Copying old configurations to config partition."
    cp -pR /mnt/config/* $rootfsdir$ofrconfdir
  else
    # Find the config files and give the user the option to copy config files
    # TODO: this needs cleaned up
    if [ -f $ofrconfdir/config.boot ]; then
	config=$ofrconfdir/config.boot
    fi
    if [ -f $fdconfdir/config.boot ]; then
      if [ -z "$config" ]; then
        config="$fdconfdir/config.boot"
      else
        config="$config $fdconfdir/config.boot"
      fi
    fi

    if [ -n "$config" ]; then
      echo "I found the following configuration files"
      for file in $config
      do 
        echo $file
      done

      default=$(echo -e $config | awk '{ print $1 }')

      while [ -z "$configfile" ]
      do
        echo -n "Which one should I copy to $INSTALL_DRIVE? [$default]: "
        configfile=$(get_response "$default" "$config")
      done
      
      echo
      output=$(cp $configfile $rootfsdir$ofrconfdir)
      if [ -n "$output" ]; then
        echo "Error copying file $configfile to config directory.  Exiting..." >> $INSTALL_LOG
        exit 1
      fi
    fi
  fi

  # set the permissions on the new config file
  if [ -f $rootfsdir$ofrconfdir/config.boot ]; then
    chgrp vyattacfg $rootfsdir$ofrconfdir/config.boot
    chmod 775 $rootfsdir$ofrconfdir/config.boot
  fi
}

set_encrypted_password() {
    sed -i \
       -e "/ user $1 {/,/}/s/encrypted-password.*\$/encrypted-password \"$2\"/" $3
}

change_password() {
    local user=$1
    local pwd1="1"
    local pwd2="2"

    until [ "$pwd1" == "$pwd2" ]
    do
        read -p "Enter $user password:" -r -s pwd1 <>/dev/tty 2>&0
	echo
	read -p "Retype $user password:" -r -s pwd2 <>/dev/tty 2>&0
	echo

	if [ "$pwd1" != "$pwd2" ]
	then echo "Passwords do not match"
	fi
    done

    # escape any slashes in resulting password
    local epwd=$(mkpasswd -H md5 "$pwd1" | sed 's:/:\\/:g')
    set_encrypted_password $user $epwd  $rootfsdir$ofrconfdir/config.boot
}

# setup grub on the boot sector of a user queried drive
install_grub () {
  # we now use INSTALL_DRIVE to reference the grub boot drive.
  #  that way I can re-use select_drive.  I'm lazy that way.

  if [ ${INSTALL_DRIVE:0:2} != "md" ]; then
    INSTALL_DRIVE=''
  fi

  mkdir -p $rootfsdir/boot/grub
  # Let the user choose the boot sector
  
  while [ -z "$INSTALL_DRIVE" ]
  do
    echo "I need to install the GRUB boot loader."
    echo "I found the following drives on your system:"
    select_drive "Which drive should GRUB modify the boot partition on?"
  done

  echo -n "Setting up grub:  "
  echo "Setting up grub..." >> $INSTALL_LOG

  # Install grub in the boot sector of the primary drive
  progress_indicator start
  grub-install --no-floppy --recheck --root-directory=$rootfsdir /dev/$INSTALL_DRIVE >>$INSTALL_LOG 2>&1
  progress_indicator stop

  # Check if using aufs
  if grep -q aufs /proc/filesystems
  then
      if [ -z "$grub_options" ]
      then
	  grub_options="union=aufs"
      else
	  grub_options="$grub_options union=aufs"
      fi
  fi

  # if union install tell vyatta-grub-setup
  if [ ! -z $UNION ]; then
    version=$(egrep -i version /opt/vyatta/etc/version | awk '{ print $3 }')
    grub_args="-u $version"
  fi
  if /opt/vyatta/sbin/vyatta-grub-setup $grub_args "$ROOT_PARTITION" "$grub_options" /mnt/rootfs >>$INSTALL_LOG
  then
    echo "OK"
  else
    echo Grub failed to install!
    exit 1
  fi
}

# ask for user input on the parted and skip setup methods
# $1 is whether or not to run parted
# sets globals INSTALL_DRIVE, ROOT_PARTITION, CONFIG_PARTITION
setup_method_manual() {
  parted=$1

  echo "The Vyatta install needs a minimum ${ROOT_MIN}MB root"
  echo "with partiton type 83 (Linux)."
  echo -e "\n\n"

  # if this is parted, let the user create the partitions
  if [ "$INSTALL_METHOD" == "parted" ] || [ "$INSTALL_METHOD" == "p" ]; then
    while [ -z "$INSTALL_DRIVE" ]
    do
      # TODO: right now we only run parted on a single drive
      echo -e "\nI found the following drives on your system:"
      select_drive "Which drive would you like to run parted on?"

    done

    # Unmount the install drive if it is mounted
    unmount "$INSTALL_DRIVE"

    # Run parted and let the user configure
    parted /dev/$INSTALL_DRIVE
  fi

  # Ask for the root partition and make sure it's valid
  while [ -z "$ROOT_PARTITION" ]
  do
    select_partition 500 "Which partition should I install the root on?"
    # Note that PARTITION is defined in select partition
    ROOT_PARTITION=$PARTITION
    unmount "$ROOT_PARTITION"
    vd=$(grep $ROOT_PARTITION /proc/partitions | awk '{ print $4 }')

    if [ -z "$vd" ]; then
      echo
      echo "$ROOT_PARTITION is an invalid partition. Please try again."
      ROOT_PARTITION=""
    fi
  done

  # check for an old config on the partition
  check_config_partition "$ROOT_PARTITION"

  # create the filesystem on the part
  make_filesystem "$ROOT_PARTITION"

  # We need to set the INSTALL_DRIVE if it wasn't set when the user ran parted
  # We assume that we will use the boot sector of the same drive that the 
  # partition is on.
  # TODO: Allow different drives to function as the boot device
  if [ -z "$INSTALL_DRIVE" ]; then
    if [ ${ROOT_PARTITION:0:2} = "md" ]; then
        INSTALL_DRIVE=$ROOT_PARTITION
    else
        INSTALL_DRIVE=$(echo $ROOT_PARTITION | sed 's/[0-9]//g')
    fi
  fi
}

# Walk the user through the auto setup method
# sets globals INSTALL_DRIVE, ROOT_PARTITION, CONFIG_PARTITION
setup_method_auto() {
  while [ -z "$INSTALL_DRIVE" ]
  do
    echo "I found the following drives on your system:"
    select_drive "Install the image on?"

    # check to make sure the drive is large enough to hold the image
    if [ -n "$INSTALL_DRIVE" ]; then 
      lsize=$(get_drive_size "$INSTALL_DRIVE")
      total=$ROOT_MIN
      if [ "$total" -gt "$lsize" ]; then
        echo "Unfortunately, Vyatta requires a total of at least $total"MB" to properly install." 
        echo "$INSTALL_DRIVE is below the minimum required capacity and therefore, cannot be used to"
        echo -e "complete the installation.\n"
        echo "If other drives are present"
        echo -e "Please select another drive...\n"

        INSTALL_DRIVE=''
      fi
    fi
  done

  warn_of_dire_consequences

  echo

  # make sure we aren't working on a mounted part
  unmount "$INSTALL_DRIVE"

  # remove any existing partitions on that drive
  delete_partitions "$INSTALL_DRIVE"

  # Enforce minimum partion size requirement.
  ROOT_PARTITION_SIZE=0
  while [ $ROOT_MIN -gt $ROOT_PARTITION_SIZE ]; do
    # Get the size of the drive
    size=$(get_drive_size $INSTALL_DRIVE)
    echo -n "How big of a root partition should I create? ($ROOT_MIN"MB" - $size"MB") [$size]MB: "
    response=$(get_response "$size")
    # TODO: need to have better error checking on this value
    ROOT_PARTITION_SIZE=$(echo "$response" | sed 's/[^0-9]//g')
    if [ $ROOT_PARTITION_SIZE -lt $ROOT_MIN ] || [ $ROOT_PARTITION_SIZE -gt $size ]; then
      echo "Root partion must be between $ROOT_MIN"MB" and $size"MB""
      echo
      ROOT_PARTITION_SIZE=0
    fi
  done

  echo

  # now take the data and create the partitions
  create_partitions "$INSTALL_DRIVE" "$ROOT_PARTITION_SIZE" 0 "yes"
}

# walk the user through a union setup
# sets globals INSTALL_DRIVE, ROOT_PARTITION, CONFIG_PARTITION
setup_method_union() {
  UNION=1

  echo "A union install requires an image partition of at least 250mbs." 
  echo "If you want to accomodate more than one image on the partition,"
  echo "it should be larger.  Each image is roughly 200mbs.  This "
  echo "partition will be the bootable partition for this machine."
  echo

  # Ask for the image partition and make sure it's valid
  while [ -z "$ROOT_PARTITION" ]
  do
    select_partition 250 "Which partition should I install the images on?"
    # Note that PARTITION is defined in select partition
    ROOT_PARTITION=$PARTITION
    unmount "$ROOT_PARTITION"
    vd=$(grep $ROOT_PARTITION /proc/partitions | awk '{ print $4 }')

    if [ -z "$vd" ]; then
      echo
      echo "$ROOT_PARTITION is an invalid partition. Please try again."
      ROOT_PARTITION=""
    fi
  done
 
  echo Creating filesystem on $ROOT_PARTITION 
  make_filesystem $ROOT_PARTITION

  echo
  echo "An optional writable persistent root partition may also"
  echo "be created.  This partition will allow you to store "
  echo "files between reboots and upgrade packages."  
  echo 
  echo -n "Would you like to create a persistent root partition? (Yes/No) [Yes]: "
  response=$(get_response "Yes" "Yes No Y N")
  if [ "$response" == "yes" ] || [ "$response" == "y" ]; then
    echo "The persistent root partition should be a minimum of 50mbs"
    echo "for log files.  If you plan on adding any other software or"
    echo "upgrading it, the root partition should be large enough to"
    echo "accomodate those packages"

    # Ask for the union partition and make sure it's valid
    while [ -z "$UNION_PARTITION" ]
    do
      select_partition 50 "Which partition should I install the binary images on?" "$ROOT_PARTITION"
      # Note that PARTITION is defined in select partition
      UNION_PARTITION=$PARTITION
      unmount "$UNION_PARTITION"
      vd=$(grep $UNION_PARTITION /proc/partitions | awk '{ print $4 }')

      if [ -z "$vd" ]; then
        echo
        echo "$UNION_PARTITION is an invalid partition. Please try again."
        UNION_PARTITION=""
      fi
    done

    echo Creating filesystems on $ROOT_PARTITION 
    make_filesystem $UNION_PARTITION

    echo Labeling $UNION_PARTITION 
    e2label /dev/$UNION_PARTITION live-rw
  fi
}

unmount () {
  # grab the list of mounted drives
  # make sure to reverse sort so as to unmount up the tree
  mounted=$(mount | grep "$1" | cut -f3 -d' ' | sort -r)
  if [ -n "$mounted" ]; then
    echo    "I need to unmount: "
    echo    "$mounted"

    response=''
    while [ -z $response ]
    do 
      echo -n "Continue (Yes/No) [No]: "
      response=$(get_response "No" "Yes No Y N")
      if [ "$response" == "no" ] || [ "$response" == "n" ]; then
        echo -e "Ok then.  Need to unmount to continue.\nExiting..."
        exit 1
      fi
    done
 
    for parts in "$mounted"
    do
      echo "umount $parts" >> $INSTALL_LOG
      output=$(umount $parts)
      status=$?
      if [ "$status" != 0 ]; then
        echo -e "Exiting: error unmounting $parts.\nPlease see $INSTALL_LOG for more details."
        echo -e "Exiting: error unmounting $parts.\numount $parts\n$output" >> $INSTALL_LOG
        exit 1
      fi
    done
  fi
}

setup_xen_partition_images () {
  if [ -d "$rootfsdir/var/xen/" ]; then
    echo Setting up Xen virtual machine images
    compressed_images=$(ls $rootfsdir/var/xen/*.img.gz 2> /dev/null)
    if [ -n "$compressed_images" ]; then
      for cmp_img in $compressed_images; do
        # uncompress the image
        uncmp_img=$(echo $cmp_img | sed s'/.gz$//') 
        if [ ! -f "$uncmp_img" ]; then
          echo decompressing $cmp_img
          gzip -dc $cmp_img > $uncmp_img
        fi
      done
    fi
    echo
  fi
}

progress_indicator () {
  case "$1" in
    start) $vyatta_bindir/progress-indicator $SPID &
             ;;
    *)
	     if ! rm /tmp/pi.$SPID 2>/dev/null
	     then
		sleep 1
		rm /tmp/pi.$SPID 2>/dev/null
	     fi

             sleep 1
	     echo -n -e "\b"
             ;;
  esac
}

#####  Main
##
# turn off any mounted swap files
turnoffswap

# Print welcome and instructions.
echo "Welcome to the Vyatta install program.  This script"
echo "will walk you through the process of installing the"
echo "Vyatta image to a local hard drive."
echo

response=''
while [ -z $response ]
do
  echo -n "Would you like to continue? (Yes/No) [Yes]: "
  response=$(get_response "Yes" "Yes No Y N")
  if [ "$response" == "no" ] || [ "$response" == "n" ]; then
    echo "Ok then.  Exiting..."
    exit 1
  fi
done

# some drives don't show up in /proc/partitions so we need to bootstrap them
echo -n "Probing drives:  "
progress_indicator start
probe_drives
progress_indicator stop
echo "OK"

INSTALL_METHOD=''
check_for_old_raid
if [ -z "$INSTALL_METHOD" ]; then
    check_for_new_raid
fi

if [ -z "$INSTALL_METHOD" ]; then
    echo "The Vyatta image will require a minimum ${ROOT_MIN}MB root."
    echo "Would you like me to try to partition a drive automatically"
    echo "or would you rather partition it manually with parted?  If"
    echo "you have already setup your partitions, you may skip this step."
    echo

    while [ -z $INSTALL_METHOD ]
    do
	echo -n "Partition (Auto/Union/Parted/Skip) [Auto]: "
	INSTALL_METHOD=$(get_response "Auto" "Auto Parted Skip Union A P S U")
    done

    echo
fi
  
# TODO: Note installs assume an LBA BIOS.  So no boot partition currently.
# also note that we are not creating a swap partition right now.
if [ "$INSTALL_METHOD" == "parted" ] || [ "$INSTALL_METHOD" == "p" ]; then
  setup_method_manual "parted"
elif [ "$INSTALL_METHOD" == "skip" ] || [ "$INSTALL_METHOD" == "s" ]; then
  setup_method_manual "skip" 
elif [ "$INSTALL_METHOD" == "auto" ] || [ "$INSTALL_METHOD" == "a" ]; then
  setup_method_auto
elif [ "$INSTALL_METHOD" == "union" ] || [ "$INSTALL_METHOD" == "u" ]; then
  echo "A union install requires an image partition of at least 250mbs."
  echo "If you want to accomodate more than one image on the partition,"
  echo "it should be larger.  Each image is roughly 200mbs.  This "
  echo "partition will be the bootable partition for this machine."
  echo

  UNION=1
  setup_method_auto
elif [ "$INSTALL_METHOD" == "vyatta" ]; then
  echo "Automated install..."
  echo "unmounting $INSTALL_DRIVE"
  unmount "$INSTALL_DRIVE"
  echo "deleting partitions on $INSTALL_DRIVE"
  delete_partitions "$INSTALL_DRIVE"
  echo "creating config partition"
  create_partitions "$INSTALL_DRIVE" "$ROOT_PARTITION_SIZE" 0 "yes"
fi

if [ ! -d /live/image -o -w /live/image ]; then
    if [ -z $UNION ]; then
	echo "install-system can only be run from livecd"
	exit 1
    fi
fi

# Install the root filesystem
install_root_filesystem "$ROOT_PARTITION"

# Copy the config files
copy_config "$CONFIG_PARTITION"

# Modify config to match system
# Assume user wants to keep password from old config
if [ ! -d /mnt/config ]; then
   # Disable root login
   set_encrypted_password root "*" $rootfsdir$ofrconfdir/config.boot

   echo "Enter password for administrator account"
   change_password vyatta
fi

# check for xen part images in /var/xen
setup_xen_partition_images

# Install grub
install_grub

if [ -z $UNION ]; then
  # Fix up PAM configuration for login so that invalid users are prompted
  # for password
  sed -i 's/requisite[ \t][ \t]*pam_securetty.so/required pam_securetty.so/' $rootfsdir/etc/pam.d/login
fi

#
# Only start the mdadm daemon if we have the root filesystem running
# on a RAID set.  Since this script is the only way that the root filesystem
# ever gets set up, we can do this configuration here.
#
MDADM_CONFIG_FILE=$rootfsdir/etc/default/mdadm
if [ -e $MDADM_CONFIG_FILE ]; then
    if [ ${INSTALL_DRIVE:0:2} = "md" ]; then
	sed -i 's/^START_DAEMON.*$/START_DAEMON=true/' $MDADM_CONFIG_FILE
    else
	sed -i 's/^START_DAEMON.*$/START_DAEMON=false/' $MDADM_CONFIG_FILE
    fi
fi


# postinst hook
if [ -e /opt/vyatta/etc/install-system/postinst ]; then
  echo "running post-install script"
  /opt/vyatta/etc/install-system/postinst $rootfsdir >>$INSTALL_LOG
fi


cp $INSTALL_LOG $rootfsdir/install.log

umount $rootfsdir

echo "Done!"
echo "Done!" >> $INSTALL_LOG

exit 0