#!/bin/ash


echo " *** mkpart ***   "
echo "Sucht zur Installierung freien Platz auf der Festplatte oder  Partitionen die abgeschnitten werden können"

# Aufruf durch  init 

echo "schreiben geht " > schreiben
echo "Schreiben geht oder nicht:"
cat schreiben 

echo "Part.Tafel, Ausgabe direkt:"
fdisk -l 
fdisk -l > fdisk.log
cat fdisk.log  
#cat fdisk.log | sort > parts0       # cut -f 1-11,16-80 geht nicht in busybox, Part. ohne boot-label machen
cat fdisk.log | cut -b 1-11,16-80 | sort > parts0      
echo "fdisk.log: "
cat fdisk.log
echo "parts0: "
cat parts0
cat fdisk.log | sort > parts0     #  test, spaeter weg ...
echo "parts0 ohne cut von fstab: "
cat parts0
sleep 20
      
cat parts0 | grep "NTFS"  > parts
cat parts0 | grep "FAT"  >> parts
cat parts0 | grep "/dev/[h,s]da[1-4]" | sort -r -n -k 4  >  tmp0
cat tmp0 | grep "Linux" >> parts        # nicht-extended Linux Partitionen
cat parts | grep -o "/dev/[h,s]da" > devs

echo " brauchbare Partitionen: "
cat  parts
echo " brauchbare devices: "
cat devs

read READTEST REST < readtest
echo " *********** test read-funktion : "  $READTEST  $REST 
sleep 20 
# Erste device wird benutzt:  
read NACH0 REST < devs 
echo " Device benutzen: "  $NACH0
sleep 20
fdisk -l > tmp0
cat tmp0 | grep "Disk" > tmp1                 # everything is stupid and shit in Linux, nothing logical ...
read A1 A2 A3 A4 DISKSIZE REST <  tmp1       #  ... so that also for this one need two lines
echo "gelesen mit DISKSIZE: A1-A4: " $A1 $A2 $A3 $A4 " Disksize: " $DISKSIZE " Rest: " $REST
cat tmp0 | grep "cylinders"  > tmp1
read A1 A2 A3 A4 ZYLINDER REST <  tmp1
echo "gelesen mit ZYLINDER: A1-A4: "  $A1 $A2 $A3 $A4 " Zylinder: " $ZYLINDER " Rest: " $REST
cat tmp0 | grep "Units"  > tmp1
read A1 A2 A3 A4 A5 A6 A7 A8 CYL REST <  tmp1
echo "gelesen mit Block-pro-Zyl: A1-A8: "  $A1 $A2 $A3 $A4 $A5 $A6 $A7 $A8 " Block-pro-Zylinder: " $CYL 
echo " Rest: " $REST
sleep 30
BLOCK=1024
#CYL=$(($DISKSIZE/$ZYLINDER))    # Nicht berechnen da Probleme mit grossen Zahlen
####CYLBLK=$(($CYL / $BLOCK))    #### spaeter anschalten, momentan aus da CYL nicht gelesen wird        
echo " Device: " $NACH0  " Size: "  $DISKSIZE " Cyl: " $ZYLINDER "byte-per-cyl: " $CYL " block-per-cyl: " $CYLBLK 
# Weil der shit nicht richtig geht, hier Vorgaben:
NACH0=/dev/hda 
CYLBLK=8000
echo "ALS TEST EINSTWEILEN: "  $NACH0  "  Cyl per block:  "  $CYLBLK

# Bezeichnung der Partition suchen die noch nicht benutzt ist:
NACHNR=4
TST="$NACH0"3 ; grep -q "$TST" parts0 ;     if test $? -ne 0  ;  then NACHNR=3 ; fi ;
echo "TEST: " $TST "   "  $?   "    "  $NACHNR  
TST="$NACH0"2 ; grep -q "$TST" parts0 ;     if test $? -ne 0  ;  then NACHNR=2 ; fi ;
echo "TEST: " $TST "   "  $?   "    "  $NACHNR  
TST="$NACH0"1 ; grep -q "$TST" parts0 ;     if test $? -ne 0  ;  then NACHNR=1 ; fi ;
echo "TEST: " $TST "   "  $?   "    "  $NACHNR  
NACH=$NACH0$NACHNR 
echo " Partition benutzen: "  $NACH  "    "  $NACHNR
if test $NACHNR = 4 ; then  
  TST="$NACH0"3 ; grep -q "$TST" parts0 ;  if test ! $?  ;  then 
  echo "Part. 4 nicht geloescht, nur desaktiviert da Nr. benutzt, mit fdisk wieder aktivierbar selbe Zyl-Nrmn" ; fi   ; 
fi ;



# Feststellen wo grösster freier Platz auf Platte vhd, egal ob noch primäre Partitionsnummern frei

fdisk -l $NACH0 | grep "/dev/[h,s]da[1-4]" | cut -b 1-11,16-38 | sort -n -k 2 > tmp0        #  Nach Reihenfolge geordnet  
echo "Partitionen nach Reihenfolge auf Platte sortiert: "
cat tmp0  
echo "Attemt to read this shit with Linux:  "
( read A1  X1  Y1  REST  ;  echo "  Zeile 1 " $A1 "  " $X1 " "  $Y1
read A2  X2  Y2  REST  ;  echo "  Zeile 2 " $A2 "  " $X2 " "  $Y2    
read A3  X3  Y3  REST  ;  echo "  Zeile 3 " $A3 "  " $X3 " "  $Y3
read A4  X4  Y4  REST  ;  echo "  Zeile 4 " $A4 "  " $X4 " "  $Y4    # Linux-Bescheuerterweise weiter Klammer nötig ...  
#(read  A1 X1 Y1  ;   read  A2 X2 Y2  ; read  A3 X3 Y3  ; read A4 X4 Y4 ) <  tmp0                             #  X1-Y1 usw belegte Tracks
echo "Partitionen Groesse/Anfg/Ende"  $A1 " " $X1 " " $Y1  " " $A2 " " $X2 " " $Y2 
echo "Partitionen Groesse/Anfg/Ende"  $A3 " " $X3 " " $Y3  " " $A4 " " $X4 " " $Y4  
EINS=1 ; X1=$(($X1-$EINS)) ; X2=$(($X2-$EINS)) ; X3=$(($X3-$EINS)) ; X4=$(($X4-$EINS))
echo  $X1 "  "  1  "  " $X1   > tmp2
echo  $(($X2-$Y1))  "   "  $Y1  "   "  $X2  >> tmp2  
echo  $(($X3-$Y2))  "   "  $Y2  "   "  $X3  >> tmp2
echo  $(($X4-$Y3))  "   "  $Y3  "   "  $X4  >> tmp2
echo  $(($ZYLINDER-$Y4))  "   "  $Y4  "   "  $ZYLINDER  >> tmp2  )  < tmp0  
echo "  Zwischenrume auf der Platte:  " 
cat  tmp2  
sleep 20
sort tmp2   -r  -n  -k 1          # Zwischenraeume nach Groesse sortieren
read AA XX YY < tmp2                    # Groesse, Anfang, Ende des groessten freien Platzes 
echo "Groesster freier Platz auf der HD, und Zwischenräume sortiert"  $AA  "   "  $XX  "    "  $YY  
sleep 20                                      

# Neu zu machende Partition
SIZEBL=4000000          #  in Bloecken
SIZE=$(($SIZEBL/$CYLBLK))
echo "Neue Partition Bloecke:  "  $SIZEBL  " Tracks: "  $SIZE  " 1 cyl in block = " $CYLBLK 


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

echo " max. Zwischenraum auf Disk: "  $AA "  Groesse der zu machenden Partition:  "  $SIZE   "  Zylinder"



echo " ermittelte Werte:  NACH0 , NACHNR , NACH , XX , YY " $NACH0 "  "  $NACHNR "   "  $NACH 
echo " XX , YY  "  $XX  "   "  $YY  "  "
#### Als Test
NACHNR=1
NACH=/dev/hda1
AA=10000
echo "NUR ZUM TEST / Vorgabe:    Drive, Part.   einrichten: "  $NACH0  "  " $NACHNR   "   "  $NACH   
XX=1
YY=501
echo " Vorgabe Grenzen der 1. Partition zu machen  XX , YY :"  $XX  "   "  $YY
sleep 30


if test $AA -ge $SIZE  ;   then

echo " neue Partition in leerem Platz machen:  "
echo -e "p \nd \n$NACHNR \np \nn \np \n$XX \n$YY \np \nw \nq\r\n" > fdisk.machen      # Falls letzte Part., keine p-nr angeben !!
####echo -e "p \nd \n$NACHNR \np \nn \np \n$NACHNR \n \n \np \nw \nq\r\n" > fdisk.machen        #### Als Test geaendert
sleep 10

#cat << EOF > fdisk.machen
#p
#d
#$NACHNR
#p
#n
#p
#$NACHNR
#$XX
#$YY
#p
#w
#q
#EOF  

#echo " Nachsehen ob dieser shit bis hier geht"

else 

#if test $AA -lt $SIZE  ;   then


echo " vhd. Partition kleiner machen:  "

# Erste Partition in parts  4 GB kleiner machen
read KLEINER S1 S2  SIZE0 REST < parts   
echo " read für KLEINER S1 S2 SIZE0 REST: "  $KLEINER $S1 $S2 $SIZE0 $REST 
echo $KLEINER | grep -o "[1-4]" > tmp0
read KLEINERNR < tmp0
echo " read fr KLEINERNR: "  $KLEINERNR
echo " Partition verkleinern: "  $KLEINER  "    "  $KLEINERNR  "  Sektor Anfg, Ende,  Bloecke: "  $S1 "  " $S2 "  " $SIZE0
sleep 20

N2=$S2
EINS=1
N1=$(($N2-$SIZE))
S2=$(($N1-$EINS))
echo "neue Partition,  Name, Nr, Track von bis: "  $NACH "  " $NACHNR  "    "  $N1  "   "  $N2  

echo "verkleinerte Partition,  Name, Nr, Track von bis: "  $KLEINER "  " $KLEINERNR  "    "  $S1  "   "  $S2  

#### \nw  noch am Schluss einbauen
echo -e "p \nd \n$KLEINERNR \nd \n$NACHNR \nd \nn \np \n$KLEINERNR \n$S1 \n$S2 \nn \np \n$NACHNR \n$N1 \n$N2 \np \nq\r\n" > fdisk.machen



#cat << EOF > fdisk.machen
#p
#d 
#$KLEINERNR
#d
#$NACHNR
#d
#n 
#p
#$KLEINERNR
#$S1
#$S2
#n
#p
#$NACHNR
#$N1
#$N2
#p
##w
#q
#EOF  

echo " mkfile fuer fdisk fertig  " 


fi    



echo  " fdisk-Mach-File fertig,    Partition:  "  $NACH0
fdisk $NACH0  <  fdisk.machen  
sleep 10

# Parameteruebergabe

echo $NACH0 "  " $NACH  > installdevice

echo " *** INSTALL-DRIVE , DEVICE SOLLTEN JETZT DA SEIN:  "  $NACH0   "    "  $NACH  
fdisk -l    

#echo "NUR ZUM TEST EXIT AUS SHELL"
sleep 30 
cat fdisk.machen 
sleep 20

#exit  


