#!/bin/ash

#echo "Sucht zur Installierung freien Platz auf der Festplatte oder  Partitionen die abgeschnitten werden können"
echo " a) Freien Platz finden oder b) primaere Partition kleiner machen  oder c) extended Part. 5 kleiner machen"
echo    "   oder d)  loeschen oder hinten absaebeln"



# Aufruf durch  init 

#                                                                  (c) 2007 werner@copaya.yi.org  

#ls / 


STATUS=-3                                    #   -2  kein Platz da    -1 Platz da, Part. ist zu machen     1 Partition fertig
# TST=0 normaler Betrieb,  TST=1: Test, nur Erforschen / Ausdrucken der Partitionen, keine Redimensionierung

TST  REST < installinfo                         # Falls dieses Programm von aussen aufgerufen,
test TST -eq 0 ; if $? -ne 0 then TST=1  ; fi ; # dessen Wert fuer TEST annehmen, sonst =1 (TEST) 
                                                # So unveraendert seperat testbar

# Alle Groessen in Sektoren !!!!

# 1. Partitionstafel erhalten
#         Format von parted:  Nr, Anfg, Ende, Groesse, primary/extended, typ/filesystem, ifbootflag
#                 Wenn parted kein fs angibt, ist die Partition nicht formatiert


# Alle parted, fdisk sind schwachsinnig bzgl. Format, daher suchen wir alle infos zusammen und geben sie geeignet aus
# Nur akzeptiert: Partitionen 1-4 die mountbar sind, oder extended und mountbare Partitionen haben

# 2.   Geraete
# 2.1. Bestandsaufnahme

echo -e "\c" > devices 
###dmesg > dmesg0                   # oder unten hdparm , besser
for I0 in a b c d ; do 
for J0 in hd sd ; do
DEVICE0=$J0$I0 ; DEVICE=/dev/$DEVICE0  ; AUSGABE=0 
hdparm -I $DEVICE  > devices0      # oder oben dmesg 
###IFDMESG=0 ; grep $DEVICE0 dmesg0 > devices0 ; if test $? -eq 0 ; then IFDMESG=HD ; fi ;    # falls device unter dmesg gefunden
###            grep "LBA" devices0 ; if test $? -eq 0 ; then IFDMESG=HD ; fi ;   # alternativ falls hdparm statt dmesg verwendet
###            grep "DVD" devices0 ; if test $? -eq 0 ; then IFDMESG=CD ; fi ;
###            grep "CD" devices0 ; if test $? -eq 0 ; then IFDMESG=CD ; fi ;
IFDMESG=0 ; grep "LBA" devices0 ; if test $? -eq 0 ; then IFDMESG=HD ; fi ;
            grep "DVD" devices0 ; if test $? -eq 0 ; then IFDMESG=CD ; fi ;  
            grep "CD" devices0 ; if test $? -eq 0 ; then IFDMESG=CD ; fi ;
DEVSIZE=0 ; fdisk -s $DEVICE ; if test $? -eq 0 ; then fdisk -s -u $DEVICE > scr0 ; read DEVSIZE REST < scr0 ; fi ;
if  test $IFDMESG != 0 ; then AUSGABE=1 ; fi ; if  test $DEVSIZE -ne 0 ; then AUSGABE=1 ; fi ; 
if test $AUSGABE -ne 0 ; then DEVSIZE=$(($DEVSIZE * 2)) ; echo $DEVICE $IFDMESG $DEVSIZE >> devices ; fi ;
done
done
echo " Gefundene Geraete    = Festplatten, CDs: "
cat devices



# 2.2. Bewertung                       (was wir davon als Install-CD und als Ziel-Festplatte nehmen)

VON=0
grep "CD" devices > scr0  
grep -v " 0" scr0 > scr1  
read VON UNW SIZE00 REST < scr1    # erstes CD mit Groesse .ne. 0 als Install-CD VON angesehen.  SIZE immer 4.7 GB, nicht verwenden 
NACH0=0
grep "HD" devices > scr0
grep -v " 0" scr0 > scr1       # ggf noch umsortieren 
read NACH0 UNW DISKSIZE REST < scr1           # erste HD mit Groesse .ne. 0 als Install-Platte NACH0 angesehen 
echo " Installation von:  " $VON "  Groesse:" $SIZE00 "  nach: " $NACH0  "   Groesse:" $DISKSIZE " Sektoren" 




# 3. Groesse der Installation          (Groesse des Install-CDs, Kompaktrate, Sicherheit)

KOMPAKT10=42                #  10-fache max. Kompakt-Rate,  die bei lzma = 4.2 ist
SIZEMIN=200000              #  Mindestgroesse jedenfalls    , in Sektoren


mount $VON /von 
df -k > df0        
Z0=0
grep $VON df0 > scr0
if test $? -eq 0 ; then read UNW1 UNW2 SIZE00 REST < scr0 ; fi ;       #  SIZE00 : Groesse des Install-CD in k
SIZE=$(($SIZE00 * 2 * $KOMPAKT10 / 10))     # minimale Groesse, de facto wird mehr Platz genommen falls auf $NACH0 frei 
echo "SIZE: " $SIZE  " SIZEMIN " $SIZEMIN
test $(($SIZE - $SIZEMIN)) -gt 0 ;   if test $? -ne 0 ;  then SIZE=$SIZEMIN ; fi ;
echo " *** Groesse Install-CD:  " $(($SIZE00 * 2))  "  Benoetigter Platz / Neue Partition Sektoren:  "  $SIZE  "   mindestens:"   $SIZEMIN      


# 4   Auswerten von vhd. Partitionen 1-4 , Lücken ZWISCHEN Partitionen, freier Platz AUF den Partitionne  auf Festplatte NACH0
#               A  Name der Partition,  X Y Z  Anfang,Ende,Groesse Partition,  Y0 Z0  Ende,Groesse Daten (nach defrag)
#                     ART Art der Partition (83=Linux, 7=ntfs, 5=extended )  FS Datei-System (ext2,ext3,minix,reiserfs,ntfs)
#                     OBDA ob Partition da ist.     Extended wird gelscht falls keine Part. 5 da, sonst FS=extended  
#     Kandidat fr zu verkleinernde Parttionen werd gesucht unabhängig davon ob spter noetig, vorrangig primary 
#          NACHNR kleinste freie NR/Index der frei ist -> Install-Partition  
#          KLEINERNR  zu verkleinernde Partition falls  Partition voll 

# 4.1. Groesse von vhd. Partition und Dateisystem
fdisk -lu > scr0 
grep "/dev/" scr0 > fdisk0
cat scr0 > fdiskwar 

OLDSYS=0
grep '*' fdisk0  > scr0 
if test $? -eq 0 ; then read OLDSYS REST < scr0 ; fi ;     # Partition mit boot -Label  
EXT=0 
grep "Extended" fdisk0 > scr0
if test $? -eq 0 ; then read EXT REST < scr0 ; fi ;           # extended Partition
sed 's/*/ /g'  fdisk0 > scr0
sed 's/+/ /g'  scr0 > fdisk0
cat fdisk0
echo "  bisheriges System: " $OLDSYS "   extended partition: " $EXT

echo -e "\c" > partitions


# 4.1.1  Partitionen 1,2,3,4 der Reihe nach abklappern: ob von fdisk angezeigt, ob mounten geht  usw 

NACHNR=0 ; NACHART=83                             #  falls Disk leer, NACHNR=1 , sonst erhoehen, bei =5  eine Partition  ausschalten
KLEINERNR=0 ; GEHTKLEINER0=0          #  GEHTKLEINER0: bisher beste gefundene Verkleinerbarkeit einer Partition (freier Platz)
WINDOWSNR=0 ; WINDOWS=-   
ANZAHL=0 
echo -e "u \np Anfang " > fdisk.machen 

for K in 1 2 3 4 ; do
A=$NACH0$K  
# mounten um Dateisystem zu bestimmen
OBDA=1 ; FS=-                                      #  OBDA=0 falls nicht da,  = -1 zwar da aber zu löschen  
umount $A  
mount $A /nach -t ext4 -o ro,extents ; if test $? -eq 0 ; then FS=ext4 ;  fi ;    # das kann ein ext3 FS beschdigen
mount $A /nach -t ext4dev -o ro,extents ; if test $? -eq 0 ; then FS=ext4dev ;  fi ;    # das kann ein ext3 FS beschdigen
mount $A /nach -t ext3 -o ro; if test $? -eq 0 ; then FS=ext3 ; fi ; 
mount $A /nach -t ext2 -o ro ; if test $? -eq 0 ; then FS=ext2 ; fi ; 
mount $A /nach -t reiserfs -o ro ; if test $? -eq 0 ; then FS=reiserfs ; fi ; 
mount $A /nach -t vfat -o ro ; if test $? -eq 0 ; then FS=vfat ; fi ; 
mount $A /nach -t ntfs -o ro ; if test $? -eq 0 ; then FS=ntfs ; fi ; 
echo " *** FS auf Partition " $A " durch mounten bestimmt: "  $FS
#mount A /nach                                                                    # mounten auf jedem Fall irgendwie

# Auswerten von fdisk
X=0 ; Y=-1 ; ART=- 
grep $A fdisk0 > scr0 
if test $? -eq 0 ; then read UNW X Y UNW0 ART REST  < scr0 ; fi ;           #  X , Y  von ... bis ...     Sektor Part. K
Z=$(($Y - $X + 1))                                  #  Z Groesse Partition   Sektor
if test $Z -le 0 ; then OBDA=0 ; fi ;               #  Partition nicht von fdisk angezeigt oder Groesse =0 ist nicht da
echo $A "size:" $Z "obda: " $OBDA

# Auswerten von df
df -k > df0        
Z0=$Z
grep $A df0 > scr0 
if test $? -eq 0 ; then               #  falls mounten erfolglos (unbekannte, benutzte, extended Partition), nicht verkleinern 
read UNW UNW1 Z0 UNW2 REST  < scr0            #  X , Y  von ... bis ...     Sektor Part. K
Z0=$(($Z0 * 2))                      #     dgl.  Sektor
Z0=$(($Z0 + $Z0 / 20))              #  Sicherheit und etwas leeren Platz lassen
test $Z0 -gt $Z ; if test $? -eq 0 ; then  Z0=$Z     ; fi ;      # Dateisystem max. so gross wie Partition
fi ;
Y0=$(($X + $Z0 - 1))     
GEHTKLEINER=$(($Z - $Z0))                    # um wieviel die Partion kleiner zu machen ginge (freier Platz - Sicherheit)
#                                            # Vorlufiges Resultat, nach Sortieren der Partitionen: freier Platz + Verkleinern                                
#if test $Z0 -le 0 ; then OBDA=0 ; fi ;      # sollte nicht vorkommen, leere oder sehr kleine FS -> Part. redimensionieren
echo $A "reduced size:" $Z0 "  reduced end: " $Y0 



umount $A 
if test $A = $EXT ; then EXTFS="extended" ; EXTNR=$K 
                    grep "$NACH0"5 fdisk0 > scr0 
                       if test $? -ne 0 ; then OBDA=0 ; fi ;           # extended Part. ohne Part. 5 loeschen 
fi ;


#  daseiende Partitionen in Datei schreiben usw, kleinster Index nicht-daseiender für Install-Partition nehmen 
if test $OBDA -gt 0 ; then                   #  brauchbare Partitionen in Datei  partitions schreiben
   if test $A = $OLDSYS ; then OLDSYSFS=$FS ; OLDSYSNR=$K ; fi ;
   if test $GEHTKLEINER -gt $GEHTKLEINER0 ; then   GEHTKLEINER0=$GEHTKLEINER
     KLEINERNR=$K ; KLEINER=$A ; XKL=$X ; YKL=$Y ; ZKL=$Z ; KLEINERFS=$FS ; KLEINERART=$ART ;  fi ; 
   if test $FS = "ntfs" ; then  if test $WINDOWSNR -eq 0 ; then  WINDOWS=$A ; WINDOWSFS=$FS ; WINDOWSNR=$K ; fi ;  fi ;
   echo $A $X $Y $Z $Y0 $Z0 $FS $ART >> partitions  
   echo $A " ab:" $X " bis:" $Y " Groesse:" $Z "voll bis:" $Y0 " Groesse:" $Z0 " Platz:" $(($Z - $Z0)) " FS:" $FS "Part.-Art:" $ART 
   ANZAHL=$(($ANZAHL + 1))                # fuer fdisk  noetig
fi ;

if test $OBDA -le 0 ; then                   #  unbrauchbare Partitionen: lösche,  Nr. als frei registrierenn
   if test $NACHNR -eq 0 ; then NACHNR=$K ; NACH=$A ; fi ;                  # kleinste leere Partitions-Nummer finden    
###echo " **** UNBRAUCHBARE PARTITION " $NACH0$K " LOESCHEN ****"
###fdisk -lu $NACH0
echo -e "p \nd \n$K \np unbrauchbares loeschen" >> fdisk.machen      # Falls letzte Part., keine p-nr angeben !!
###fdisk $NACH0 < fdisk.machen
###fdisk -lu $NACH0
# nicht ANZAHL=$(($ANZAHL - 1))     
fi ;   

done 


if test $NACHNR = 0 ; then NACHNR=5 ; fi ; 

echo " Anzahl Part. schon da:" $ANZAHL " NACHNR: " $NACHNR "   vorlaeufig KLEINERNR: " $KLEINERNR 




echo "Partitionen:"
cat partitions

echo " altes System  Nr : " $OLDSYSNR "    Partition , nicht da = 0: " $OLDSYS  "    Format: "  $OLDSYSFS
#echo " Windows  Nr : " $WINDOWSNR "    Partition , nicht da = 0: " $WINDOWS  "    Format: " $WINDOWSFS
echo " vorl. Kandidat der zu verkleinernden Partition: " $KLEINERNR $XKL $YKL $ZKL $KLEINERART $KLEINERFS $REST
echo " *** Ob kleinerzumachende Partition / deren Groesse definiert: " $ZKL  "  Benoetigt / neue Part.: "  $SIZE


# Noch einbauen: falls keine zu verkleinernde Partition gefunden, aber gebraucht, irgendeine nehmen



# 2. Feststellen ob/wo grösster freier Platz auf Platte vh

echo " *** groesste freie Luecke auf Platte " $NACH0 " suchen :    *** "

sort -n -k 2 partitions > parts0        #  PARTITIONEN JETZT Nach phys. Reihenfolge auf Platte geordnet, nicht nach Nr.  
#echo "Partitionen nach Reihenfolge auf Platte sortiert: "

echo " Partitionen in echter Reihenfolge: " ; cat parts0

A1=0 ; A2=0 ; A3=0 ; A4=0 ; X1=1 ; X2=1 ; X3=1 ; X4=1 ; Y1=1 ; Y2=1 ; Y3=1 ; Y4=1
( read A1 X1 Y1 Z1 Y01 Z01 REST  ;  read A2 X2 Y2 Z2 Y02 Z02 REST  
  read A3 X3 Y3 Z3 Y03 Z03 REST  ;  read A4 X4 Y4 Z4 Y04 Z04  REST  
echo $A1 $X1 $Y1 $Z1 $Y01 $Z01 $A2 $X2 $Y2 $Z2 $Y02 $Z02 $A3 $X3 $Y3 $Z3 $Y03 $Z03 $A4 $X4 $Y4 $Z4 $Y04 $Z04 > tmp00 ) < parts0
read A1 X1 Y1 Z1 Y01 Z01 A2 X2 Y2 Z2 Y02 Z02 A3 X3 Y3 Z3 Y03 Z03 A4 X4 Y4 Z4 Y04 Z04 REST < tmp00
#echo "Eingabe:" $A1 $X1 $Y1 $Z1 $Y01 $Z01 $A2 $X2 $Y2 $Z2 $Y02 $Z02 $A3 $X3 $Y3 $Z3 $Y03 $Z03 $A4 $X4 $Y4 $Z4 $Y04 $Z04  

echo "Disk-Size: "  $DISKSIZE 
echo "Partition Nr/Anfg/Ende/Ende falls reformatiert/frei"  $A1 " " $X1 " " $Y1 "    " $Y01 " " $Z01       
echo "Partition Nr/Anfg/Ende/Ende falls reformatiert/frei"  $A2 " " $X2 " " $Y2 "    " $Y02 " " $Z02 
echo "Partition Nr/Anfg/Ende/Ende falls reformatiert/frei"  $A3 " " $X3 " " $Y3 "    " $Y03 " " $Z03    
echo "Partition Nr/Anfg/Ende/Ende falls reformatiert/frei"  $A4 " " $X4 " " $Y4 "    " $Y04 " " $Z04  

#  Zu jeder Partition J den vorigen J-1 und den folgenden J Zwischenraum bestimmen:
#     Anfg/Ende/Groesse  ohne Redimension der Partitionen:  ZA, ZE, ZG   , mit Redim:  WA, WE, WG 
echo " Bestimmung der freien Stellen auf der Platte: "
EINS=1 
Y0=0 ; Y00=0
ZA0=$(($Y0+$EINS)) ; ZE0=$DISKSIZE ; ZG0=$(($DISKSIZE-$Y0-1)) ; WA0=$ZA0 ; WE0=$ZE0 ; WG0=$ZG0
test $A1 != 0 ; if test $? -eq 0 ;  then ZE0=$(($X1-$EINS)) ; ZG0=$(($X1-$Y0-1)) ; ZA1=$(($Y1+$EINS)) ; ZE1=$DISKSIZE ; ZG1=$(($DISKSIZE-$Y1-1)) ; 
                                    WE0=$ZE0 ; WG0=$(($X1-$Y00-1)) ;  WA1=$(($Y01+$EINS)) ; WE1=$ZE1 ;  WG1=$(($DISKSIZE-$Y01-1)) ; fi ;
echo " Luecke vor P.1: " $ZA0 $ZE0 $ZG0   "    Groesse soll: "  $(($ZE0-$ZA0+$EINS)) 
test $A2 != 0 ; if test $? -eq 0 ;  then ZE1=$(($X2-$EINS)) ; ZG1=$(($X2-$Y1-1)) ; ZA2=$(($Y2+$EINS)) ; ZE2=$DISKSIZE ; ZG2=$(($DISKSIZE-$Y2-1)) ; 
                                    WE1=$ZE1 ; WG1=$(($X2-$Y01-1)) ;  WA2=$(($Y02+$EINS)) ; WE2=$ZE2 ;  WG2=$(($DISKSIZE-$Y02-1)) ; fi ;
echo " Luecke nach P.1: " $ZA1 $ZE1 $ZG1  "    Groesse soll: "  $(($ZE1-$ZA1+$EINS)) 
test $A3 != 0 ; if test $? -eq 0 ;  then ZE2=$(($X3-$EINS)) ; ZG2=$(($X3-$Y2-1)) ; ZA3=$(($Y3+$EINS)) ; ZE3=$DISKSIZE ; ZG3=$(($DISKSIZE-$Y3-1)) ; 
                                    WE2=$ZE2 ; WG2=$(($X3-$Y02-1)) ;  WA3=$(($Y03+$EINS)) ; WE3=$ZE3 ;  WG3=$(($DISKSIZE-$Y03-1)) ; fi ;
echo " Luecke nach P.2: " $ZA2 $ZE2 $ZG2  "    Groesse soll: "  $(($ZE2-$ZA2+$EINS))
test $A4 != 0 ; if test $? -eq 0 ;  then ZE3=$(($X4-$EINS)) ; ZG3=$(($X4-$Y3-1)) ; ZA4=$(($Y4+$EINS)) ; ZE4=$DISKSIZE ; ZG4=$(($DISKSIZE-$Y4-1)) ; 
                                    WE3=$ZE3 ; WG3=$(($X4-$Y03-1)) ;  WA4=$(($Y04+$EINS)) ; WE4=$ZE4 ;  WG4=$(($DISKSIZE-$Y04-1)) ; fi ;
echo " Luecke nach P.3: " $ZA3 $ZE3 $ZG3  "    Groesse soll: "  $(($ZE3-$ZA3+$EINS))
echo " Luecke nach P.4: " $ZA4 $ZE4 $ZG4  "    Groesse soll: "  $(($ZE4-$ZA4+$EINS))
echo -e "\c"   > tmp0
echo  "   -      " $ZG0  "   "  $ZA0 "   " $ZE0   "   "  $WG0  "   "  $WA0 "   " $WE0   >> tmp0
echo  $A1 "  " $ZG1  "   "  $ZA1 "   " $ZE1   "   "  $WG1  "   "  $WA1 "   " $WE1 >> tmp0  
echo  $A2 "  " $ZG2  "   "  $ZA2 "   " $ZE2   "   "  $WG2  "   "  $WA2 "   " $WE2  >> tmp0
echo  $A3 "  " $ZG3  "   "  $ZA3 "   " $ZE3   "   "  $WG3  "   "  $WA3 "   " $WE3   >> tmp0
echo  $A4 "  " $ZG4  "   "  $ZA4 "   " $ZE4   "   "  $WG4  "   "  $WA4 "   " $WE4  >> tmp0   
echo "  Zwischenrume auf der Platte:  OHNE Redim: " 
echo $ZG0 " ab " $ZA0  " ; " $ZG1 " ab " $ZA1 " ; " $ZG2 " ab " $ZA2 " ; "  $ZG3 " ab " $ZA3 " ; "  $ZG4 " ab " $ZA4   
echo "  Zwischenrume auf der Platte:  MIT Redim: " 
echo $WG0 " ab " $WA0  " ; " $WG1 " ab " $WA1 " ; " $WG2 " ab " $WA2 " ; "  $WG3 " ab " $WA3 " ; "  $WG4 " ab " $WA4
   
   
echo "  Zwischenraeume unsortiert:"  ; cat  tmp0  
sort  -o tmp1 -r  -n  -k 2   tmp0           # Auf tmp1 sind jetzt die ZWISCHENRAEUME / FREIE BEREICHE nach Groesse sortieret
echo "  Zw. sortiert OHNE Reformat Partitionen:    Bez., Groesse, Anfg, Ende,   Gr., Anf, Ende reform.: " ; cat tmp1
read AA ZZ XX YY  REST < tmp1                    # Partition davor, Groesse, Anfang, Ende des groessten freien Platzes 
#ZZ=$(($YY-$XX+1))
echo " *** ::: Groesster freier Platz auf der HD  OHNE Redimensionierung:  Gr/von/bis  " $ZZ  "   "  $XX  "    "  $YY  

# Reihenfolge auswerten:  1) primaere Part, 2) extended Part  3) groesste
sort  -o tmp2 -r  -n  -k 5   tmp0           # Auf tmp1 sind jetzt die ZWISCHENRAEUME / FREIE BEREICHE nach Groesse sortieret
grep -v $EXT tmp2 > tmp1                    # erst nicht-extended, dann extended
grep  $EXT tmp2 >> tmp1
echo "  Zw. sortiert MIT Reformat Partitionen:    Bez., Groesse, Anfg, Ende,   Gr., Anf, Ende reform.: " ; cat tmp1
read AAA UNW1 UNW2 UNW3 ZZZ XXX YYY  REST < tmp1                    # Partition davor, Groesse, Anfang, Ende des groessten freien Platzes 
KLEINER=$AAA

#if test $? -eq 0 ; then KLEINER=$AAA   ; fi ;   
#ZZZ=$(($YYY-$XXX+1))
echo " *** ::: Groesster freier Platz auf der HD  MIT Redimensionierung:  Gr/von/bis  " $ZZZ  "   "  $XXX  "    "  $YYY
echo " *** ::: Dazu redimensionieren Partition: " $AAA
# Noch verbessern:  extended Partitionen nor redim wenn keine andere vhd

grep $KLEINER partitions > scr0
read UNW XKL YKL ZKL Y0KL Z0KL KLEINERFS KLEINERART REST < scr0
echo " Partition " $KLEINER " Groesse " $ZKL " kann um " $(($ZKL - $Z0KL)) " zu " $Z0KL " verkleinert werden"
echo " Danach freier Platz bis zur naechsten Partition: "  $ZZZ  



# 3. Testen ob freier Platz ausreicht, sonst eine Partition kleiner machen

#echo " max. Zwischenraum auf Disk: "  $ZZ "  Groesse der zu machenden Partition:  "  $SIZE   "  Zylinder"
if test $ZZ -lt $SIZE  ;   then   STATUS="-2"  ; fi ;  #  echo " vhd. Partition kleiner machen:  "  ;  
if test $ZZ -ge $SIZE  ;   then   STATUS="-1"  ; fi ;  # echo " *** Platz reicht um neue Partition zu machen *** " ;  


echo " STATUS, -2 falls Part. kleiner zu machen, -1 falls Platz vhd:  "    $STATUS


if test $STATUS = "-2"  ;  then  

echo " Partition verkleinern: "  $KLEINER  "    "  $KLEINERNR  " vorher:  Sektor Anfg, Ende,  Bloecke: "  $XKL "  " $YKL "  " $ZKL 
echo " Part-Art: "  $KLEINERART  "Filesystem:  "  $KLEINERFS
echo " Zwischenraum durch Redimensionieren erreichbar:    vor: " $AAA "  Groesse:  " $ZZZ " von: " $XXX " bis: " $YYY
echo " Groesse mind. noetig fuer Installierung: " $SIZE  "     alles in Sektoren"
#Falls gewäehlte Partition selbst nahc Redimensionieren zu klein, wird sie soweit wie möglich verkleinert und dann hinten abgebelt
#Falls dagegen mehr als minimal noetige Groesse der Installierung redimensinoert werden kann, wird 70% davon aber max. 1 GB
#mehr der Installierung gegeben  (nicht mehr da sonst redimensionieren zu langsam)
MAXMS=2000000     #   1 GB
if test $ZZZ -gt $SIZE ; then  MEHRSIZE=$(( ($ZZZ - $SIZE) * 7)) ; MEHRSIZE=$(($MEHRSIZE / 10))  
                     if test $MEHRSIZE -gt $MAXMS ; then MEHRSIZE=$MAXMS  ; fi ;  fi ; 
SIZE=$(($SIZE + $MEHRSIZE))
echo " Gewaehlte Groesse der Partition der Installierung:  "  $SIZE   

# Verkleinerung der Partition KLEINER um Groesse SIZE 
# Neuer freier Platz von XX bis YY :  ZZ = XX - 1 + SIZE 
YY=$YYY
EINS=1
XX=$(($YY - $SIZE +1))
YKL=$(($XX - 1))
# XKL bleibt
ZKL=$(($YKL - $XKL + 1))   # Sektoren
ZKL0=$(($ZKL / 2))k     # in k

KLEINERLOG="$NACH0"5          # berücksichtigte logische Partition die ggf. verkleinert wird um extended zu verkleinern

echo " *** Zum Einrichten einer neuen Partition wird eine bestehende verkleinert *** "
echo "verkleinerte Partition: Platte, Name, Nr, Sektor von bis: " $NACH0 "  "  $KLEINER "  " $KLEINERNR  "    "  $XKL  "   "  $YKL  
echo " Danach freier Bereich von: " $XX "  bis: " $YY 
echo " Neue Groesse Partition:  " $ZKL " Sektoren   oder " $ZKL0  "    KB " 

echo " *** Beginn Verkleinern von Dateisystem auf: " $KLEINER " *** "
IFR=0
#/sbin/parted -s $NACH0 unit s resize $KLEINERNR $XKL $YKL   # das funktioniert fast nie, daher:
# Falls filesystem keins der nachfolgenden, bzw = "", ist Partition nicht formatiert, und kann einfach verkleinert werden ....
# Versucht wird  dann aber alles, da evtl nicht erkannt / kein Treiber da
test $KLEINERFS = ext2 ; if test $? -eq 0 ; then echo resize2fs -f -p $KLEINER $ZKL0 ; IFR=1 ; echo "EXT2"; fi ;      # geht nicht mit Sektoren
test $KLEINERFS = ext3 ; if test $? -eq 0 ; then echo resize2fs -f -p $KLEINER $ZKL0 ; IFR=1 ;echo "EXT3" ; fi ;    # geht nicht mit Sektoren
test $KLEINERFS = ext4 ; if test $? -eq 0 ; then echo resize2fs -f -p $KLEINER $ZKL0 ; IFR=1 ;echo "EXT4" ; fi ;      # geht nicht mit Sektoren
test $KLEINERFS = ext4dev ; if test $? -eq 0 ; then echo resize2fs -f -p $KLEINER $ZKL0 ; IFR=1 ; echo "EXT4DEV" ; fi ;      # geht nicht mit Sektoren
test $KLEINERFS = reiserfs ; if test $? -eq 0 ; then echo resize_reiserfs -s  $ZKL0 -f $KLEINER ; IFR=1 ; echo "REISERFS" ; fi ;
test $KLEINERFS = ntfs ; if test $? -eq 0 ; then ntfsfix $KLEINER  ;  echo ntfsresize -s $ZKL0  $KLEINER ; IFR=1 ; echo "NTFS"; fi ;
test $KLEINER = $EXT ; if test $? -eq 0 ; then ntfsfix $KLEINERLOG  ;  echo ntfsresize -s $ZKL0  $KLEINERLOG ; IFR=1 ; echo "NTFS";  fi ; 
test $IFR = 0 ; if test $? -eq 0 ; then echo ntfsfix $KLEINER  ;  echo ntfsresize -s $ZKL0  $KLEINER ; IFR=1 ; echo "NTFS"; fi ;
test $IFR = 0 ; if test $? -eq 0 ; then echo resize2fs -f -p $KLEINER $ZKL ; IFR=1 ;echo "EXT3" ; fi ;    # geht nicht mit Sektoren

if test $TST -eq 0 ; then
test $KLEINERFS = ext2 ; if test $? -eq 0 ; then  resize2fs -f -p $KLEINER $ZKL0 ; IFR=1 ; echo "EXT2"; fi ;      # geht nicht mit Sektoren
test $KLEINERFS = ext3 ; if test $? -eq 0 ; then  resize2fs -f -p $KLEINER $ZKL0 ; IFR=1 ; echo "EXT3" ; fi ;    # geht nicht mit Sektoren
test $KLEINERFS = ext4 ; if test $? -eq 0 ; then  resize2fs -f -p $KLEINER $ZKL0 ; IFR=1 ; echo "EXT4" ; fi ;      # geht nicht mit Sektoren
test $KLEINERFS = ext4dev ; if test $? -eq 0 ; then  resize2fs -f -p $KLEINER $ZKL0 ; IFR=1 ;echo "EXT4DEV" ; fi ;      # geht nicht mit Sektoren
test $KLEINERFS = reiserfs ; if test $? -eq 0 ; then  resize_reiserfs -s  $ZKL0 -f $KLEINER ; IFR=1 ; echo "REISERFS" ; fi ;
test $KLEINERFS = ntfs ; if test $? -eq 0 ; then ntfsfix $KLEINER  ;   ntfsresize -s $ZKL0  $KLEINER ; IFR=1 ; echo "NTFS"; fi ;
test $KLEINER = $EXT ; if test $? -eq 0 ; then ntfsfix $KLEINERLOG  ;  ntfsresize -s $ZKL0  $KLEINERLOG ; IFR=1 ; echo "NTFS";  fi ; 
test $IFR = 0 ; if test $? -eq 0 ; then  ntfsfix $KLEINER  ;  ntfsresize -s $ZKL0  $KLEINER ; IFR=1 ; echo "NTFS"; fi ;
test $IFR = 0 ; if test $? -eq 0 ; then resize2fs -f -p $KLEINER $ZKL0 ; IFR=1 ; echo "EXT3" ; fi ;    # geht nicht mit Sektoren
sync
fi ;

echo " egal ob FS verkleinern erfolgreich war oder nicht: "
echo " **** PARTITION "  $KLEINER " VERKLEINERN,    VON SEKTOR "  $XKL  "  BIS " $YKL  " **** "
# nach Loeschen mit fdisk, Rausgehen noetig, da Eingabe abhängig ob es die einzige Partition war oder nicht


###if test $TST -eq 0 ; then

if test $KLEINER = $EXT ; then 
echo -e "d \n$KLEINERLOG \np logische Part. redim Beginn" >> fdisk.machen    
###fdisk $NACH0 < fdisk.machen
fi ;

echo -e "d \n$KLEINERNR \np extended Part. redim Beginn" >> fdisk.machen    
###fdisk $NACH0 < fdisk.machen

#   Falls Renovierung der 4. Partition, in fdisk keine PartNr. angeben
if test $ANZAHL -lt 4 ; then   echo -e "n \np \n$KLEINERNR \n$XKL \n$YKL \np Ext.Part. redim Ende" >> fdisk.machen     ; fi ;
if test $ANZAHL -ge 4 ; then   echo -e "n \np \n$XKL \n$YKL \np Ext.Part. redim Ende" >> fdisk.machen     ; fi ;
echo -e "t \n$KLEINERNR \n$KLEINERART   Ext.Part. Art" >> fdisk.machen
###fdisk $NACH0 < fdisk.machen

if test $KLEINER = $EXT ; then  XKL1=$(($XKL + 63)) ;  echo -e "n \nl \n$KLEINERLOG \n$XKL1 \n$YKL \np log.Part. redim Ende" >> fdisk.machen     ; fi ;
if test $KLEINER = $EXT ; then  echo -e "t \n$KLEINERLOG \n7 log.Part. Art" >> fdisk.machen     ; fi ;
###fdisk $NACH0 < fdisk.machen

###fi ;


#if test $TST -eq 0 ; then  /sbin/parted -s $NACH0 rm $KLEINERNR ; fi ;        #  Partition hinten absbeln egal ob Filesystem verkleinert oder nicht
#echo " *** "  $KLEINER " verkleinert neu machen :"
#echo "          parted Aufruf mit File-System:  "  $KLEINERFS  " Bereich fuer KLEINER: "  $XKL  $YKL 
#if test $TST -eq 0 ; then /sbin/parted -s $NACH0 unit s mkpart $KLEINERART $KLEINERFS  $XKL $YKL ; fi ; 
#echo " *** "  $KLEINER  " neu gemacht.    Situation jetzt:  " 
#if test $TST -eq 0 ; then /sbin/parted -s $NACH0  unit s print ; fi ;


####STATUS="-1"    # da nachfolgendes ebenfalls zu durchlaufen ist

fi ;    


echo "Nach evtl. Platz machen:  status, Platte, nachnr, extendednr, kleinernr: "  $STATUS $NACH0  $NACHNR  $EXTNR  $KLEINERNR
echo "KLEINER: " $KLEINERNR  "kleiner, sizekleiner"   $KLEINER    $ZKL 

   


####if test $STATUS = "-1"  ;  then  
# 4.2 Nr.  NACHNR  der neuen Partition definitiv festlegen
 if test $NACHNR = 5 ; then
  NACHNR=4 ; if test $NACHNR = $EXTNR ; then NACHNR=3 ; fi ;    # EXTNR vermeiden, KLEINERNR dagegen ruhig verwendbar
echo " schon 4 Part. vhd: vhd. Partition" $NACHNR " wird in fdisk ausgeschaltet, um Nr. fr neue Part. zu benutzen, "
echo " wird aber nicht gelscht und kann durch Eintippen ihrer Grenzen in fdisk wieder benutzt werden" 
###if test $TST -eq 0 ; then    
#  /sbin/parted -s $NACH0 rm $NACHNR 
echo -e "p \nd \n$NACHNR \np Bei 4 Part. eine ausschalten um Index zu bekommen" >> fdisk.machen      # Falls letzte Part., keine p-nr angeben !!
###fdisk $NACH0  < fdisk.machen
###fi ;
 fi ;
 NACH=$NACH0$NACHNR

echo "nach definitiver Nr. fuer neue Part.: status, Platte, nachnr, extnr, kleinernr: "  $STATUS  $NACH0 $NACHNR  $EXTNR  $KLEINERNR


# 4.3 Partition für die Installierung machen
XX=$(($XX+128)) ; YY=$(($YY-128))                   # sicherbeitshalber ...aber zZt nicht noetig
echo " *** Platte / Partition machen:  NACH0 , NACHNR , NACH  " $NACH0 "  "  $NACHNR "   "  $NACH   " *** " 
echo " *** Groesse von/bis XX , YY : "  $XX  "   "  $YY  " , wurde sicherheitshalber um +/- 128 verkleinert "

echo " **** INSTALL - PARTITION " $NACH "MACHEN,    SEKTOR " $XX " BIS SEKTOR" $YY " **** "

###if test $TST -eq 0 ; then

echo -e "d \n$NACHNR \np evtl. vhd. Part. mit Index Install-Part. loeschen" >> fdisk.machen
###fdisk $NACH0  < fdisk.machen  

if test $ANZAHL -lt 3 ; then  echo -e "n \np \n$NACHNR \n$XX \n$YY \np Install-Partition machen" >> fdisk.machen ; fi ;     
if test $ANZAHL -ge 3 ; then  echo -e "n \np \n$XX \n$YY \np Install-Part. machen" >> fdisk.machen   ; fi ;   # da letzte Part., keine p-nr angeben !!
echo -e "t \n$NACHNR \n$NACHART   Ext.Part. Art" >> fdisk.machen
###fdisk $NACH0  < fdisk.machen  

echo -e "a \n$OLDSYSNR \na \n$NACHNR \np  Bootlabel aendern" >> fdisk.machen
###fdisk $NACH0  < fdisk.machen  

###fi ;



# Partition NACHNR machen:
#if test $TST -eq 0 ; then  /sbin/parted -s $NACH0  unit s mkpart primary   $XX $YY  ; fi ; 
#echo "          parted Aufruf mit:  "  $NACH0  " Bereich fuer KLEINER: "  $XX  $YY 
#sync
#echo " *** "  $NACH  " neu gemacht.    Situation jetzt:  " 
#/sbin/parted -s $NACH0  unit s print 
####fi ;


#if test $STATUS = "-2"  ;  then  
#echo " ******** testweise ******* als maximale Gewaehr: KLEINER loeschen, dann NACH nochmal machen lassen:  *********** "
#  Vorsicht falls man kleiner erst nach nach macht, ist die Nr. falsch
#  Einzige Lösung:  beide Partitionen löschen (NACHNR und KLEINERNR), und danach zuerst diejenige mit der kleineren Nr machen
#if test $TST -eq 0 ; then  /sbin/parted -s $NACH0 rm $KLEINERNR ; fi ;       
#XKL100=$(($XKL+256)) ; XKL200=$(($XKL+1024)) 
#if test $TST -eq 0 ; then   /sbin/parted -s $NACH0 unit s mkpart $KLEINERART $KLEINERFS  $XKL100 $XKL200 ; fi ;  # dummy wg Index   Hinterher reparieren
#if test $TST -eq 0 ; then  /sbin/parted -s $NACH0  unit s mkpart primary ext3  $XX $YY  ; fi ;   # falls vorher erfolgreich gemacht, kein Problem
#echo "          parted Aufruf mit:  "  $NACH0  " Bereich fuer KLEINER: "  $XX  $YY 
#sync
#echo " *** "  $NACH  " neu gemacht.    Situation jetzt:  " 
#/sbin/parted -s $NACH0  unit s print 
#echo " *** Versuch   KLEINER  wieder zu machen,  falls erfolgreich ist alles OK und dieses testweise unschaedlich "
#/sbin/parted -s $NACH0 rm $KLEINERNR ;  
#if test $TST -eq 0 ; then  /sbin/parted -s $NACH0 unit s mkpart $KLEINERART  $KLEINERFS $XKL $XKL ; fi ;         
#echo " ***   KLEINER   neu gemacht.    Situation jetzt:  " 
#/sbin/parted -s $NACH0  unit s print 
#echo " ************************ " 
#fi ;

#/sbin/parted -s $NACH0 set $NACHNR  boot on       # bootbar machen

# 4.4.  Hier ggf. nochmal Groesse ueberpruefen und wenn  wenn was nicht iO mit leicht geaenderten Bedingungen bzgl Groesse
#   o.ae. nach oben springen
#echo " *** INSTALL-DRIVE , DEVICE SOLLTEN JETZT DA SEIN:  "  $NACH0   "    "  $NACH  
#/sbin/parted -s $NACH  unit s  print
#echo "Alle Partitionen: "
#/sbin/parted -s $NACH0 unit s  print


# 5. Parameteruebergabe nach aussen
echo $TST " " $SIZE  "  "  $NACH0 "  " $NACH  "  " $VON "  "  $KLEINER " " $OLDSYS " " $WINDOWS  "  " $REST > installinfo 
echo " Ausgabe von mkpart: "
echo "neue Partition: Platte,  Name, Nr, Track von bis:   " $NACH0 "  "  $NACH "  " $NACHNR  "    "  $XX  "   "  $YY  
echo " altes System:  "  $OLDSYS  "     Windows:  " $WINDOWS  

if test $TST -eq 0 ; then  echo -e "p \nw  AUSFUEHREN, AUF DISK SCHREIBEN, KEIN TEST" >> fdisk.machen  ; fi ;         # Bei TST=0 kein Test, wirklich schreiben
if test $TST -ne 0 ; then  echo -e "p  SIMULIEREN, DA TEST" >> fdisk.machen  ; fi ;            #     TST=1  nur simulieren
fdisk $NACH0 < fdisk.machen 

sync 

echo " 

*** alte und neue Partitionen : 

"
cat fdiskwar
fdisk -lu $NACH0

STATUS="1" 

echo " 

*** Ende mkpart " 


