iso to usb betiği

[mimiksiz]

Güncelleme : dosya_ara fonksiyonunda ki file komutunun değeri artık "x-iso9660-image" olması gerektiği için iso dosyası bulunamamasını çözmek ve kod iyileştirmeleri için güncelleme yaptım.

Kod Seç Genişlet


#!/bin/zsh
#güncelleme tarihi : 12/06/2021
yaz(){
clear
seçilen_bellek_bölüm_adet=$(lsblk -no MOUNTPOINT $seçilen_bellek_dev|wc -l)
for a in {1..$seçilen_bellek_bölüm_adet}
do
for b in {1..$seçilen_bellek_bölüm_adet}
do
bağ=$(lsblk -no MOUNTPOINT $seçilen_bellek_dev|sed -n $b'p')
sudo umount "$bağ" >& /dev/null
done
done
[ ! -z $bağ ] && {echo "HATA! $bağ yoluna bağlanan bölüm ayrılamadı."; exit }
sudo dd if=/dev/zero of=$seçilen_bellek_dev bs=$_boyutu count=$sektör_adet >& /dev/null
sudo parted -s $seçilen_bellek_dev mklabel msdos >& /dev/null
echo "Bellek biçimlendirildi."
sudo dd if=$dosya of=$seçilen_bellek_dev bs=$_boyutu  >& /dev/null && sync
echo "Kalıp yazıldı."
exit 0
}
onay_al(){
bellek_konum=/sys/block/$seçilen_bellek
boyut=$(cat $bellek_konum/size)
sektör_boyutu=$(cat $bellek_konum/queue/hw_sector_size)
_boyutu=$(cat $bellek_konum/queue/physical_block_size)
sektör_adet=$(($(cat $bellek_konum/size)/$(cat $bellek_konum/queue/hw_sector_size)))
bellek_boyutu=$(($(($(cat $bellek_konum/size)*$(cat $bellek_konum/queue/hw_sector_size)))/1048576))
dosya_boyutu=$(($(stat -c %s $dosya)/1048576))
[ $bellek_boyutu -lt $(($dosya_boyutu+200)) ] && {echo "'$seçilen_bellek_dev' üzerinde '$dosya' dosyası için yeterli alan yok\n\nDosya boyutu:\t$dosya_boyutu MB\nBellek boyutu:\t$bellek_boyutu MB"; exit 1 }
while
do
clear
echo "Seçilen kalıp:  $dosya\nSeçilen bellek: $seçilen_bellek_dev\n\nUYARI:Kalıp yazılmadan önce belleğiniz biçimlendirilecek. Devam etmek istiyor musunuz?[e/h]"
read onay
onay=$(echo $onay|tr '[:upper:]' '[:lower:]')
[ "$onay" = "e" ] && {yaz; break } || {echo "İşleminiz iptal edildi."; exit }
done
}
dosya_seç(){
[ -z "$dosyalar" ] && {echo "Dosya bulunamadı."; exit 1 }
for a in {1..$(echo $dosyalar|wc -l)}
do
dosya_=$(printf $dosyalar|sed -n $a'p')
dosya_boyutu=$(stat -c %s $dosya_)
dosya_boyutu=$(( $dosya_boyutu/1048576 ))
dosya_boyutları="$dosya_boyutu $a.$dosya_boyutları"
done
for a in {$(echo $dosyalar|wc -l)..1}
do
_kb=$(echo -n $dosya_boyutları|tr "." "\n"|sort -h|awk '{print $2}'|sed -n $a'p')
_kb2=$(echo -n $dosya_boyutları|tr "." "\n"|sort -h|awk '{print $1}'|sed -n $a'p')
sıralı_dosyalar=$(echo -n "$a\t "; echo -n "$_kb2"; echo -n "mb\t"; echo $dosyalar|sed -n $_kb'p'; echo $sıralı_dosyalar)
done
while
do
clear
echo "==>Bulunan Kalıp Dosyaları:\n###########################\n"
echo "Numarası Boyutu\tYolu\n$sıralı_dosyalar"
echo -n "\nYazdırmak istediğiniz kalıbı seçin:\n->"
read dosya_seçim
if [[ $dosya_seçim =~ ^[0-9]+$ ]] && [ $dosya_seçim -le $(echo $dosyalar|wc -l) -a $dosya_seçim -gt 0 ]
then
dosya_seçim_=$(echo -n $dosya_boyutları|tr "." "\n"|sort -h|awk '{print $2}'|sed -n $dosya_seçim'p')
dosya=$(echo $dosyalar|sed -n $dosya_seçim_'p')
echo dosya$dosya
onay_al
break
fi
done
}
dosya_ara(){dosyalar=$(sudo find $dosya_arama_yolu $@ -type f -name "*.iso" -exec file -N -i -- {} + 2>/dev/null|awk /x-iso9660-image/|awk -F":" '{print $1}'; echo $dosyalar) }
#yazılım kontrol
command -v wc tr sed lsblk grep awk cat sudo umount find file sync dd parted stat sort &>/dev/null || {echo "Hata! Aşağıda ki yazılımların kurulu olduğuna emin misiniz?\nwc tr lsblk grep awk cat sudo umount find file sync dd parted stat sort sed"; exit 1 }
#
#usb disk yoksa bekle
[[ -z $(lsblk -o NAME,TYPE,HOTPLUG|grep disk|grep 1$) ]] && echo "==>Lütfen belleğinizi takınız...\n################################"
while [[ -z $(lsblk -o NAME,TYPE,HOTPLUG|grep disk|grep 1$) ]]
do
sleep 0.5
done
#
çıkarılabilir_bellekler=$(lsblk -o NAME,TYPE,HOTPLUG|grep disk|grep 1$|cut -d \  -f1)
for a in {$(echo $çıkarılabilir_bellekler|wc -l)..1}
do
bellek_konum=$(echo -n /sys/block/; echo $çıkarılabilir_bellekler|sed -n $a'p')
bellek_listesi=$(echo -n "$a\t\t /dev/"; echo -n $çıkarılabilir_bellekler|sed -n $a'p'|tr -d "\n"; echo -n "\t"; echo -n $(($(($(cat $bellek_konum/size)*$(cat $bellek_konum/queue/hw_sector_size)))/1048576)); echo "mb\n$bellek_listesi")
done
while
do
clear
echo "==>Kalıp Hangi Belleğe Yazılsın\n###############################\nNumarası\t Adresi\t\tBoyutu"
echo "$bellek_listesi\n\nKullanmak istediğiniz belleğin numarasını giriniz:\n->"
read seçim
[ $seçim -gt 0 -a $seçim -le $(echo $bellek_listesi|wc -l) ] && [[ $seçim =~ ^[0-9]+$ ]] && break
done
seçilen_bellek_dev=$(echo $bellek_listesi|sed -n $seçim'p'|awk '{print $2}')
seçilen_bellek=$(echo $seçilen_bellek_dev|awk -F "/dev/" '{print $2}')
#dosya_arama_konumu
bellekler=$(lsblk -lno NAME|sed -e 's/'"${seçilen_bellek}"'[0-9]//g'|sed -e 's/'"${seçilen_bellek}"'//g'|sed '/^$/d')
for a in {1..$(echo $bellekler|wc -l)}
do
if [[ ! -z $(lsblk -no MOUNTPOINT /dev/$(echo $bellekler|sed -n $a'p')|head -1) ]]
then
bağlı_bellekler=$(echo $bellekler|sed -n $a'p'; echo $bağlı_bellekler)
fi
done
[ -z $bağlı_bellekler ] && {echo "Bağlı bellek bulunamadı!"; exit 1 }
for a in {$(echo $bağlı_bellekler|wc -l)..1}
do
bağlı_bellek_listesi=$(echo -n "$a\t\t/dev/"; echo $bağlı_bellekler|sed -n $a'p'|tr -d "\n";echo -n "\t"; lsblk -no MOUNTPOINT /dev/$(echo $bağlı_bellekler|sed -n $a'p')|head -1; echo $bağlı_bellek_listesi)
done
while
do
clear
echo "==>Kalıp Dosya Hangi Bellekte Aransın\n###################################"
echo "Numarası:\tAdresi:\t\tBağlandığı Konum:\n$bağlı_bellek_listesi"
echo "\nAra:\t\t\t\t\t\t\t[2]\nÇoklu ara:\t\t\t\t\t\t[1,7,5]\nÇoklu ara:\t\t\t\t\t\t[2-8]\nBütün bağlı belleklerde ara:\t\t\t\t[H]\nArama yapma. Dosya yolunu elle gireceğim:\t\t[E]"
read nerde_aransın
nerde_aransın=$(echo $nerde_aransın|tr '[:upper:]' '[:lower:]')
if [ "$nerde_aransın" = "h" ]
then
dosya_arama_yolu="/"
dosya_ara && dosya_seç && break
elif [ "$nerde_aransın" = "e" ]
then
clear
while
do
echo "Dosya yolunu giriniz:"
read dosya
file -i $dosya|grep iso9660-image >& /dev/null && {onay_al; break } || {clear; echo "$dosya dosyası geçerli bir kalıp dosyası değil." }
done
elif [ $nerde_aransın -gt 0 -a $nerde_aransın -le $(echo $bağlı_bellekler|wc -l) ] &>/dev/null && [[ $nerde_aransın =~ ^[0-9]+$ ]]
then
dosya_arama_yolu=$(lsblk -no MOUNTPOINT /dev/$(echo $bağlı_bellekler|sed -n $nerde_aransın'p')|head -1)
dosya_ara -xdev && dosya_seç && break
elif [ $(echo $nerde_aransın|tr -cd -|wc -m) -eq 1 ] &>/dev/null && [ $(echo -n $nerde_aransın|wc -m) -ge 3 ] &>/dev/null && [ -z $(echo $nerde_aransın|tr -d "[0-9]-") ] &>/dev/null
then
aranacak_bellek_1=$(echo $nerde_aransın|awk -F - '{print $1}')
aranacak_bellek_2=$(echo $nerde_aransın|awk -F - '{print $2}')
bağlı_bellek_adet=$(echo $bağlı_bellekler|wc -l)
if [ $aranacak_bellek_1 -gt 0 -a $bağlı_bellek_adet -ge $aranacak_bellek_1 -a $aranacak_bellek_2 -gt 0 -a $bağlı_bellek_adet -ge $aranacak_bellek_2 -a ! $aranacak_bellek_1 -eq $aranacak_bellek_2 ]
then
[ $aranacak_bellek_1 -lt $aranacak_bellek_2 ] && {küçük=$aranacak_bellek_1; büyük=$aranacak_bellek_2 } || {küçük=$aranacak_bellek_2; büyük=$aranacak_bellek_1 }
for a in {$küçük..$büyük}
do
dosya_arama_yolu=$(lsblk -lno MOUNTPOINT /dev/$(echo $bağlı_bellekler|sed -n $a'p')|head -1)
dosya_ara -xdev
done
dosya_seç && break
fi
elif [ $(echo $nerde_aransın|tr -cd ,|wc -m) -eq 1 ] && [ $(echo -n $nerde_aransın|wc -m) -ge 3 ] && [ -z $(echo $nerde_aransın|tr -d "[0-9],") ]  && [[ $nerde_aransın =~ ^[0-9]+([,][0-9]+)$ ]]
then
aranacak_bellek_adet=$(($(echo -n $nerde_aransın|tr -cd ,|wc -m)+1))
konumlar=""
for a in {1..$aranacak_bellek_adet}
do
aranacak_bellek=$(echo $nerde_aransın|awk -F , '{print '"\$${a}"'}')
if [ $aranacak_bellek -gt 0 -a $(echo $bağlı_bellekler|wc -l) -ge $aranacak_bellek ]
then
dosya_arama_yolu=$(lsblk -lno MOUNTPOINT /dev/$(echo $bağlı_bellekler|sed -n $(echo $nerde_aransın|awk -F "," '{print '"\$${a}"'}')'p')|head -1)
if ! echo $konumlar|grep "$dosya_arama_yolu " >& /dev/null
then
konumlar=$(echo "$dosya_arama_yolu $konumlar")
else
konumlar=hata && break
fi
else
konumlar=hata && break
fi
done
if ! echo $konumlar|grep hata >& /dev/null; then
for a in {1..$(echo $konumlar|wc -w)}
do
dosya_arama_yolu=$(echo $konumlar|awk -F " " '{print '"\$${a}"'}') dosya_ara -xdev
done
dosya_seç && break
fi
fi
done


Yeni zsh betik hazır. Umarım işe yarar.

Kod Seç Genişlet

#!/bin/zsh
yaz(){
clear
seçilen_bellek_bölüm_adet=$(lsblk -no MOUNTPOINT $seçilen_bellek_dev|wc -l)
for (( a=1; a<=$(($seçilen_bellek_bölüm_adet)); a++ )); do
for (( b=1; b<=$(($seçilen_bellek_bölüm_adet)); b++ )); do
bağ=$(lsblk -no MOUNTPOINT $seçilen_bellek_dev|sed -n $b'p')
sudo umount "$bağ" >& /dev/null
done
done
if [ "$bağ" != "" ]; then echo "HATA! $bağ yoluna bağlanan bölüm ayrılamadı."; exit; fi
sudo dd if=/dev/zero of=$seçilen_bellek_dev bs=$_boyutu count=$sektör_adet >& /dev/null
sudo parted -s $seçilen_bellek_dev mklabel msdos >& /dev/null
echo "Bellek biçimlendirildi."
sudo dd if=$dosya of=$seçilen_bellek_dev bs=$_boyutu  >& /dev/null && sync
echo "Kalıp yazıldı."
}
onay_al(){
bellek_konum=/sys/block/$seçilen_bellek
boyut=$(cat $bellek_konum/size)
sektör_boyutu=$(cat $bellek_konum/queue/hw_sector_size)
_boyutu=$(cat $bellek_konum/queue/physical_block_size)
sektör_adet=$(($(cat $bellek_konum/size)/$(cat $bellek_konum/queue/hw_sector_size)))
bellek_boyutu=$(($(($(cat $bellek_konum/size)*$(cat $bellek_konum/queue/hw_sector_size)))/1048576))
dosya_boyutu=$(($(stat -c %s $dosya)/1048576))
if [ ! "$bellek_boyutu" -lt "$(($dosya_boyutu+200))" ]; then
while true; do
clear
echo "Seçilen kalıp:  $dosya\nSeçilen bellek: $seçilen_bellek_dev\n\nUYARI:Kalıp yazılmadan önce belleğiniz biçimlendirilecek. Devam etmek istiyor musunuz?[e/h]"
read onay
if [ "$onay" = "E" ] || [ "$onay" = "e" ]; then
yaz
break
elif [ "$onay" = "H" ] || [ "$onay" = "h" ]; then
echo "İşleminiz iptal edildi."
exit
fi
done
else
echo "'$seçilen_bellek_dev' üzerinde '$dosya' dosyası için yeterli alan yok\n\nDosya boyutu:\t$dosya_boyutu MB\nBellek boyutu:\t$bellek_boyutu MB"
exit
fi
}

dosya_seç(){
if [ "$dosyalar" != "" ]; then
dosya_adet=$(echo $dosyalar|wc -l)
for (( a=1; a<=dosya_adet; a++ )); do
dosya_=$(printf $dosyalar|sed -n $a'p')
dosya_boyutu=$(stat -c %s $dosya_)
dosya_boyutu=$(( $dosya_boyutu/1048576 ))
dosya_boyutları="$dosya_boyutu $a.$dosya_boyutları"
done
for (( a=$dosya_adet; a>=1; a-- )); do
_kb=$(echo -n $dosya_boyutları|tr "." "\n"|sort -h|awk '{print $2}'|sed -n $a'p')
_kb2=$(echo -n $dosya_boyutları|tr "." "\n"|sort -h|awk '{print $1}'|sed -n $a'p')
sıralı_dosyalar=$(echo -n "$a\t "; echo -n "$_kb2"; echo -n "mb\t"; echo $dosyalar|sed -n $_kb'p'; echo $sıralı_dosyalar)
done
while true; do
clear; echo "==>Bulunan Kalıp Dosyaları:\n###########################\n"
echo "Numarası Boyutu\tYolu\n$sıralı_dosyalar"
echo "\nYazdırmak istediğiniz kalıbı seçin:\n->"
read dosya_seçim
if [ "$(echo -n $dosya_seçim|tr -d "[0-9]")" = "" ] && [ ! "$dosya_adet" -lt "$dosya_seçim" ] && [ ! "$dosya_seçim" -lt "1" ]; then
dosya_seçim_=$(echo -n $dosya_boyutları|tr "." "\n"|sort -h|awk '{print $2}'|sed -n $dosya_seçim'p')
dosya=$(echo $dosyalar|sed -n $dosya_seçim_'p')
onay_al
break
fi
done
else
if [ "$(printf $nerde_aransın|tr -d "[0-9]")" = "" ]; then
echo "Arama yaptığınız bellekte geçerli kalıp dosyası olduğundan emin misiniz?"
else
echo "Arama yaptığınız belleklerde geçerli kalıp dosyası olduğundan emin misiniz?"
fi
exit
fi
}

dosya_ara(){dosyalar=$(sudo find $dosya_arama_yolu $@ -type f -name "*.iso" -exec file -N -i -- {} +|awk /octet-stream/|awk -F":" '{print $1}'; echo "$dosyalar") >& /dev/null}

dosya_arama_konumu(){
bellekler=$(lsblk -lno NAME|sed -e 's/'"${seçilen_bellek}"'[0-9]//g'|sed -e 's/'"${seçilen_bellek}"'//g'|sed '/^$/d')
bellek_adet=$(echo $bellekler|wc -l)
for (( a=1; a<=$bellek_adet; a++ )); do
bağlımı=$(lsblk -no MOUNTPOINT /dev/$(echo $bellekler|sed -n $a'p')|head -1)
if [ "$bağlımı" != "" ]; then
bağlı_bellek_adet=$(( $bağlı_bellek_adet+1 ))
bağlı_bellekler=$(echo $bellekler|sed -n $a'p'; echo $bağlı_bellekler)
fi
done
if [ "$bağlı_bellek_adet" -lt "1" ]; then echo "Bağlı bellek bulunamadı!"; exit; fi
for (( a=$bağlı_bellek_adet; a>=1; a-- )); do
bağlı_bellek_listesi=$(echo -n "$a\t\t/dev/"; echo $bağlı_bellekler|sed -n $a'p'|tr -d "\n";echo -n "\t"; lsblk -no MOUNTPOINT /dev/$(echo $bağlı_bellekler|sed -n $a'p')|head -1; echo $bağlı_bellek_listesi)
done

while true; do
clear
echo "==>Kalıp Dosya Hangi Bellekte Aransın\n###################################"
echo "Numarası:\tAdresi:\t\tBağlandığı Konum:\n$bağlı_bellek_listesi"
echo "\nAra:\t\t\t\t\t\t\t[2]\nÇoklu ara:\t\t\t\t\t\t[1,7,5]\nÇoklu ara:\t\t\t\t\t\t[2-8]\nBütün bağlı belleklerde ara:\t\t\t\t[H]\nArama yapma. Dosya yolunu elle gireceğim:\t\t[E]"
read nerde_aransın


if [ "$nerde_aransın" = "H" ] || [ "$nerde_aransın" = "h" ]; then  #hepsinde ara
dosya_arama_yolu="/"
dosya_ara && dosya_seç && break
elif [ "$nerde_aransın" = "E" ] || [ "$nerde_aransın" = "e" ]; then #elle giriş
clear
while true; do
echo "Dosya yolunu giriniz:"
read dosya
if file -i $dosya >& /dev/null |grep octet-stream >& /dev/null; then
onay_al && break
else
clear
echo "$dosya dosyası geçerli bir kalıp dosyası değil."
fi
done
elif [ "$nerde_aransın" != "" ] && [ "$(printf $nerde_aransın|tr -d "[0-9]")" = "" ]; then #sadece rakam girilmişse
if [ ! "$bağlı_bellek_adet" -lt "$nerde_aransın" ] && [ "0" -lt "$nerde_aransın" ];  then
dosya_arama_yolu=$(lsblk -no MOUNTPOINT /dev/$(echo $bağlı_bellekler|sed -n $nerde_aransın'p')|head -1) dosya_ara -xdev && dosya_seç && break
fi
elif [ $(echo $nerde_aransın|tr -cd -|wc -c) = 1 ] && [ ! "$(echo $nerde_aransın|wc -L)" -lt 3 ] && [ "$(echo $nerde_aransın|tr -d "[0-9]-")" = "" ]; then
aranacak_bellek_1=$(echo $nerde_aransın|awk -F - '{print $1}')
aranacak_bellek_2=$(echo $nerde_aransın|awk -F - '{print $2}')
if [ ! "$aranacak_bellek_1" -lt "1" ] && [ ! "$bağlı_bellek_adet" -lt "$aranacak_bellek_1" ] && [ ! "$aranacak_bellek_2" -lt "1" ] && [ ! "$bağlı_bellek_adet" -lt "$aranacak_bellek_2" ] && [ "$aranacak_bellek_1" != "$aranacak_bellek_2" ]; then
if [ "$aranacak_bellek_1" -lt "$aranacak_bellek_2" ]; then
for (( a=$aranacak_bellek_1; a<=$aranacak_bellek_2; a++ )); do
dosya_arama_yolu=$(lsblk -lno MOUNTPOINT /dev/$(echo $bağlı_bellekler|sed -n $a'p')|head -1)
dosya_ara -xdev
done
else
for (( a=$aranacak_bellek_2; a<=$aranacak_bellek_1; a++ )); do
dosya_arama_yolu=$(lsblk -lno MOUNTPOINT /dev/$(echo $bağlı_bellekler|sed -n $a'p')|head -1)
dosya_ara -xdev
done
fi
dosya_seç && break
fi
elif [ ! $(echo $nerde_aransın|tr -cd ,|wc -c) -lt 1 ] && [ ! "$(echo $nerde_aransın|wc -L)" -lt 3 ] && [ "$(echo $nerde_aransın|tr -d "[0-9],")" = "" ]; then
karakter_adet=$(echo $nerde_aransın|wc -L)
for (( a=1; a<=$karakter_adet; a++ )); do
karakter=$(echo -n ${nerde_aransın: -$a: 1})
if [ "$karakter" = "," ]; then
virgül=$(( $virgül+1 ))
else
virgül=0
fi
if [ "$virgül" = "2" ]; then break; fi
done
if [ "$virgül" != "2" ]; then # 2 virgül yan yana girilmemişse
aranacak_bellek_adet=$(echo $(($(echo $nerde_aransın|tr -cd ,|wc -c)+1)))
konumlar=""
for (( a=1; a<=$aranacak_bellek_adet; a++ )); do
aranacak_bellek=$(echo $nerde_aransın|awk -F , '{print '"\$${i}"'}')
if [ ! "$aranacak_bellek" -lt "1" ] && [ ! "$bağlı_bellek_adet" -lt "$aranacak_bellek" ]; then
dosya_arama_yolu=$(lsblk -lno MOUNTPOINT /dev/$(echo $bağlı_bellekler|sed -n $(echo $nerde_aransın|awk -F "," '{print '"\$${i}"'}')'p')|head -1)
if ! echo $konumlar|grep "$dosya_arama_yolu " >& /dev/null ; then
konumlar=$(echo "$dosya_arama_yolu $konumlar")
else
konumlar=hata && break
fi
else
konumlar=hata && break
fi
done
if ! echo $konumlar|grep hata >& /dev/null; then
konumlar_adet=$(echo $konumlar|wc -w)
for (( a=1; a<=$konumlar_adet; a++ )); do
dosya_arama_yolu=$(echo $konumlar|awk -F " " '{print '"\$${i}"'}')
dosya_ara -xdev
done
dosya_seç && break
fi
fi
fi
done
}

bellek_seç(){
çıkarılabilir_bellek_adet=$(echo $çıkarılabilir_bellekler|wc -l)
for (( a=$çıkarılabilir_bellek_adet; a>=1; a-- )); do
bellek_konum=$(echo -n /sys/block/; echo $çıkarılabilir_bellekler|sed -n $a'p')
bellek_listesi=$(echo -n "$a\t\t /dev/"; echo -n $çıkarılabilir_bellekler|sed -n $a'p'|tr -d "\n"; echo -n "\t"; echo -n $(($(($(cat $bellek_konum/size)*$(cat $bellek_konum/queue/hw_sector_size)))/1048576)); echo "mb\n$bellek_listesi")
done
while true; do
clear
echo "==>Kalıp Hangi Belleğe Yazılsın\n###############################\nNumarası\t Adresi\t\tBoyutu"
echo "$bellek_listesi\n\nKullanmak istediğiniz belleğin numarasını giriniz:\n->"
read seçim
if [ "$(echo $seçim|tr -d "[0-9]")" = "" ] && [ ! "$çıkarılabilir_bellek_adet" -lt "$seçim" ] && [ ! "$seçim" -lt "1" ]; then
seçilen_bellek=$(echo $bellek_listesi|sed -n $seçim'p'|awk '{print $2}'|awk -F"/dev/" '{print $2}') >& /dev/null
seçilen_bellek_dev=$(echo /dev/$seçilen_bellek)
dosya_arama_konumu
break
fi
done
}

çıkarılabilir_bellek_tespit_et(){
if ! lsblk -o NAME,TYPE,HOTPLUG|grep 1|grep disk >& /dev/null; then
echo "==>Lütfen belleğinizi takın...\n##############################"
while [ "$bellek_takılmasını_bekle" = "" ]; do
sleep 1
bellek_takılmasını_bekle=$(dmesg|tail -1|grep Attached|grep "removable disk")
done
fi
çıkarılabilir_bellekler=$(lsblk -o NAME,TYPE,HOTPLUG|grep 1|grep disk|awk '{print $1}') >& /dev/null
bellek_seç
}

yazılım_kontrol(){
clear
if ! which zsh >/dev/null; then
echo 'HATA:Sisteminizde "which" yazılımı bulunamadı.'; exit
elif ! which wc >/dev/null && which tr >/dev/null && which sed >/dev/null; then
echo "Hata! Aşağıda ki yazılımların kurulu olduğuna emin misiniz?\nwc tr sed"; exit
else
gerekli_yazılımlar=$(echo "lsblk grep awk cat sudo umount find mount file sync dd parted stat sort sed dmesg tail"|tr " " "\n")
gerekli_yazılım_adet=$(echo $gerekli_yazılımlar|wc -l)
eksik_yazılımlar=""
for (( a=1; a<=$gerekli_yazılım_adet; a++ )); do
if ! which $(echo $gerekli_yazılımlar|sed -n $a'p') >/dev/null; then
eksik_yazılımlar=$(echo -n "$eksik_yazılımlar "; echo $gerekli_yazılımlar|sed -n $a'p');
fi
done
if [ "$eksik_yazılımlar" = "" ]; then
çıkarılabilir_bellek_tespit_et
else
echo "Hata! Aşağıda ki yazılımların kurulu olduğuna emin misiniz?\n"; echo $eksik_yazılımlar|tr "\n" " "
fi
fi
}
yazılım_kontrol


Okubeni.txt

Kod Seç Genişlet


benioku.txt

Kurulum ve Çalıştırma:

chmod +x dosyaadı.sh
/dosya/yolu/./dosyaadı.sh

Özellikler:

Açılışta gerekli komutlar sistemde var mı diye which ile kontrol yapar.

İlk adımda çıkarılabilir bellek takılı mı diye kontrol yapar. Takılı değilse takıldığında ikinci adıma geçer.

İkinci adımda Kalıp yazdırmak istenen bellek seçimi için çıkarılabilir bellekleri liste halinde boyutuyla birlikte gösterip seçim yapmayı bekler, hatalı giriş olursa tekrar sorar.

Üçüncü adımda Kalıp dosya aramak için sisteme bağlı bellekleri konumu ve bağlandığı yolla gösterip bir kaç seçenek sunar;
Listede ki tek bellekte dosya aramak için numarasını <3> veya 1. 3. 5. belleklerde aramak için virgülle ayırarak <1,3,5> veya 2. diskten 6. diske kadar ki tüm disklerde aramak için tire ile ayırarak <2-6> veya bağlı disklerin hepsinde aramak için <H> veya arama yapmadan dosya yolunu girmek için <E> seçenekleri girilebilir. Döngü ile hatalı girişlerde işlem yapmaz (listede olmayan disk numarası veya 1,2 yerine ,1,2, ? vb.), ve tekrar sorar.

Eğer üçüncü adımda  dosya aramak için bellek seçilmişse find komutunu sudo ile çalıştırmak için şifre ister ve geçerli linux kalıp dosyası bulunduysa boyutu küçükten büyüğe doğru listeler. Seçimden sonra dördüncü adıma geçer.

Eğer üçüncü adımda <e> girilmişse dosya yolunu ister. Geçerli kalıp dosyası girilmemişse girilinceye kadar dosya yolu ister. Seçilen dosyayı yazmak için yeterli alan yoksa çıkar, varsa dördüncü adıma geçer.

Dördüncü adımda seçilen seçilen dosya yolunu, seçilen belleği tekrar gösterip biçimlendirmek için onay ister <e/h> e veya h den başka seçenek girilirse tekrar sorar. e ile onay verilirse beşinci adıma geçer.

Beşinci adımda Seçilen çıkarılabilir diskin bağlı bölümlerini ayırmak için (umount) sudo yetkisi ister.  Belleği ayırmada hata olursa betik sonlanır. Ayırabilirse bellek biçimlendirilir ve kalıp yazılır.


[mhmtkrktr]

Vaktiyle Archman için benimde bir uğraşım olmuştu. Bir sebeple yarım bıraktım. 
https://www.youtube.com/watch?v=eKLqgKlA1Yw
Devam ettirmek isteyen olursa paylaşabilirim.

Senin betiğe de şuna benzer bir ilave yapabilirsin belki.

Kod Seç Genişlet

#!/usr/bin/bash
#
#

DISK=$(lsblk -lo NAME,MOUNTPOINT,LABEL)
SDX=$(grep -E '^sd.*/media/' <<<"$DISK")
DEV=$(awk '{print $1}' <<<"$SDX")
TAG=$(awk '{print $3}' <<<"$SDX")
TNUM=$(grep -c  '[a-z]\|[0-9]' <<<"${TAG}")

select_multi_disk() {
NUM=1
  for i in $(echo "${DEV}");do
DL=$(awk '/'$i'/{print $1}' <<<"$SDX")
DT=$(awk '/'$i'/{print $3}' <<<"$SDX")
      echo -e "\n>\n  usb_no  $NUM \n  birim   :  /dev/${DL::-1}\n  etiket  :  $DT"
    ROW+="$NUM+$DL "
    let NUM+=1
  done
}

select_message() {
  clear; echo
  echo -e "\n>\n  seşilen bellek \t: /dev/${DEV::-1}\n  birim etiketi \t: ${TAG}"
  sleep 2
}

  if [[ ${TNUM} -eq 0 ]]; then
echo -e "\n ==> HATA : uygun aygıt bulunamadı ! \n"
        exit
  elif [[ ${TNUM} -eq 1 ]]; then
select_message
  elif [[ ${TNUM} -gt 1 ]]; then
select_multi_disk
echo -ne "\n\n Yazmak istediğiniz usb numarasını seçin : "
read -p "" NM
ROW=$(tr ' ' '\n' <<<$ROW|grep "^${NM}+")
  if [[ -n $ROW ]]; then
DEV=$(awk '/'${ROW##*+}'/{print $1}' <<<"$SDX")
TAG=$(awk '/'${ROW##*+}'/{print $3}' <<<"$SDX")
select_message
  else
echo -e "\n ==> Hata : (${NM}) geçersiz seçim ! \n"
  fi
  fi

  echo -e "\n\n ... Bilgisayarda ki kalıp dosyaları aranıyor ..."
 
  XISO=$(find ~ -type f -name "*.iso" -exec file -N -i -- {} +| \
  awk '/octet-stream/{print $1}')
  sleep 1
 
  if [[ $(grep -c '^/' <<<"$XISO") -ge 1 ]]; then
  echo -e "\n\n ===> Bulunan kalıp dosyaları\n"
  nl -nln -w1 <<<"$XISO"| \
  sed "s|${HOME}||g;s/^/ --> /g;s/^/\n/g;s/:$//g"
 
  echo -ne "\n\n ==?  Bir iso dosyası seçin : "
  read -p "" ISO
  echo -e "\n\n ${ISO} ... falan filan ;-)\n"
  else
echo -e "\n\n ===> Hiç kalıp dosyası bulunamadı !\n"
  fi

[mimiksiz]

[mention=636464]@mhmtkrktr[/mention] önceden mount edilmiş bölüm olmadan disk seçimi olmuyordu.:
DISK=$(lsblk -lo NAME,MOUNTPOINT,LABEL) burada sorun olmuyor. (echo $DISK sonucu true) ama bağlı disk bölümü yoksa altta ki değişkenler false oluyor.

Kod Seç Genişlet

SDX=$(grep -E '^sd.*/media/' <<<"$DISK")
DEV=$(awk '{print $1}' <<<"$SDX")
TAG=$(awk '{print $3}' <<<"$SDX")
TNUM=$(grep -c  '[a-z]\|[0-9]' <<<"${TAG}")

Kodları tam olarak anlayamadım. Nasıl seçiyor çıkarılabilir diski?

EDİT: parametre vermeden usb tespit ediyor, multi usb için çalışmaya devam

Kod Seç Genişlet


disk=$(lsblk  -lo NAME,HOTPLUG,TYPE)
disk_tipindekiler=$(echo $disk | grep 'disk') #partition olmayanlar
diskadet=$(echo $disk_tipindekiler | wc -l)
uygundiskadet=0
for (( i=1; i<=$diskadet; i++ )); do
    disk_kontrol=$(echo $disk_tipindekiler|sed -n $i'p'|awk  '{print $2}')
    if [ "$disk_kontrol" = 1 ]; then
        uygundiskadet=$((uygundiskadet+=1))
        disk_uygun=$(echo $disk_tipindekiler|sed -n $i'p'|awk '{print $1}')
    fi
done


[mhmtkrktr]

Söylediklerin soru mu, yoksa sorun mu anlayamadım.
$DISK boş ise alttakilerin de boş olması normal değil mi? Bu durumda uygun medya aygıtı bulunamadı diyor zaten.
Medyayı bulmak için dizin yapısında ki standartları kullanıyor. Ayrıca senin kullandığın mount komutu, sistem tam olarak açılmadan, harici aygıtlar için çalışmaz.
Madem uçbirimden çalışacak, açılmayan sistemler için tty üzerinde de çalışabilmesi için lsblk ile düzenledim. Zenity vb arayüz kullanılacaksa mount ile de devam edebilirsin.

Hangi halini denedin bilmiyorum ama burada ki exit i unutmuşum. Sonradan ekledim.

Kod Seç Genişlet

  if [[ ${TNUM} -eq 0 ]]; then
echo -e "\n ==> HATA : uygun aygıt bulunamadı ! \n"
        exit

[mimiksiz]

Soru veya sorun değil. usb belleğin hiçbir partitionu mount edilmemiş ise aşağıda ki değişkeninin sonucu false boş çıkıyor netice olarak disk bulamıyordu. Mount edilen bölüm varsa sorun olmuyordu. Mount işlemi için kullanıcı uğraşsın istemedim ama düzeltmeyide beceremedim yeni betik yazıyorum.

Kod Seç Genişlet

DEV=$(awk '{print $1}' <<<"$SDX")

EDIT:Yeni betik ilk mesaja eklendi mount zenity bildirim vs yok. tek parametre olarak şifre sormaya devam ediyor.
[mention=636468]@mhmtkrktr[/mention] Teşekkürler yardımların için.

[mhmtkrktr]

Şifreyi neden dışarıdan verdiğini anlayamadım. Özel bir nedeni yoksa, betik çalıştığında yönetici izni almak daha kullanışlı olurdu bence.

Birde neden sadece bölümlere ayrılmamış bellek üzerinde işlem yapabiliyor. Bu durum işleme başlamadan önce bellek üzerinde ek işlem yapmayı gerektirir ki, buna gerek yok.

İso dosyası bulma işlemini örnek olarak verdim ama yazdırılacak .iso dosyasının sadece $HOME içinde olmayacağını hesaba katmak gerekir. (sisteme bağlı harici bölüm, başka bir usb aygıtı üzerinde vb) Bunun için seçeneklerin içine birde elle dosya girişi yapabilecek seçenek oluşturabilirsin. Burada yine, verilen yolun octet-stream dosyası olduğunu doğrulatarak yazım işlemini sadece Linux kalıplarıyla sınırlandırabilirsin.

Faydalanmak istersen, diskler ile ilgili temel bilgiler /sys/block dizininde tutulur. Şuana kadar ihtiyaç duyduğun bazı değişkenler aşağıda mevcut.

Kod Seç Genişlet

# DEV=sdXX     \ XX = seçilen aygıt

  U_DIR=/sys/block/${DEV::-1}

  if [[ -d $U_DIR ]]; then

###################################
  source ${U_DIR}/uevent
[[ $DEVTYPE == 'disk' ]] && echo "$DEV = $DEVTYPE"

###################################
  REMOVABLE=$(cat ${U_DIR}/removable)
# seçilen aygıt HDD ise yazım işi yapılmaz
# taşınabilir HDD ler de buna dahil
    [[ $REMOVABLE -ne 1 ]] && \
    { echo "bu aygıt memory stick değil !"; exit; }

###################################
  TOP_SEC=$(cat ${U_DIR}/size)
echo $TOP_SEC # toplam_sector

###################################
  SEC_SIZE=$(cat ${U_DIR}/queue/hw_sector_size)
echo $SEC_SIZE # sector_boyutu

###################################
  NUMBER=$((TOP_SEC/SEC_SIZE))
echo $NUMBER  # adet

###################################
# iso ile disk boyutunun karşılaştırılması
  ISO_SIZE=$(stat -c %s seçilen_kalıp.iso)
  [[ $((${ISO_SIZE}+209715200)) -gt $TOP_SEC ]] && \
  { echo "${DEV} üzerinde bu iso için yeterli alan yok"; exit; }

###################################
    for i in $(ls "$U_DIR"|grep "sdb[1-9]"); do
echo /dev/$i
# umount /dev/$i    #disk bölümlerini ayırma
    done
  fi

[mimiksiz]

Birde neden sadece bölümlere ayrılmamış bellek üzerinde işlem yapabiliyor. Bu durum işleme başlamadan önce bellek üzerinde ek işlem yapmayı gerektirir ki, buna gerek yok.

Ya ben sizi anlayamadım ya da betik biraz makarna olduğu için siz anlayamadınız.
/dev/sdb aygıtına kalıp yazılacaksa, diske önceden kalıp yazılmış ise, diskin dosya sistemi iso9660 oluyor ve partitionları sdb1-2 mevcut oluyor. Betik varsa sdxY leri yani partitionları tespit edip eğer mount edilmiş ise ayırıyor. Sonra sdx için veri ve dosya sistemi silme komutu çalışıyor, aşağıda ki ilk komut partition varsa siliyor, zaten umount işlemini bu esnada hata çıkmaması için yazdım. Ama partition zaten yoksa direk sdx için veri ve dosya sistemi silme komutu çalışıyor. Sonrada iso dosyasını yazmaya geçiyor.
veri ve dosya sistemi silme komutu:

Kod Seç Genişlet

dd if=/dev/zero of=/dev/sdx bs=$sector_boyutu count=$adet
parted -s /dev/sdx mklabel msdos

Eğer /dev/sdx yerine /dev/sdx1 konumuna iso yazılabilir demek istediyseniz nasıl yapılabilir bilmiyorum. dd komutundan başka yöntem mi var zira

Kod Seç Genişlet

dd if=dosya.iso of=/dev/sdx1 bs=4M && sync işlemi başarısız oluyor yani boot etmiyor.

Şifreyi neden dışarıdan verdiğini anlayamadım. Özel bir nedeni yoksa, betik çalıştığında yönetici izni almak daha kullanışlı olurdu bence.

Kişisel alışkanlığımdı sadece. Bu ve diğer önerilerinizi dikkate alacağım. Kodlar için teşekkür ederim.


Mesaj tekrarı yüzünden mesajınız birleştirildi. Bu mesajın gönderim tarihi : 06 Şubat 2018 - 07:20:42
Betiğin yeni zsh sürümü kalıp yazdır 0.0.3 ilk mesaja eklendi.

[mimiksiz]

Yeni zsh sürümü hazırlanıyor. Yeniliklerden bazıları:
usb disk bağlı değilse çıkış yapmak yerine, usb diskin takılmasını bekleyip, tespit edince betik başlıyacak.
Dosya aramak için disklerin listesi veriliyordu. Yeni sürüm için çoklu disk seçimi hazırlanıyor.
Çoklu disk seçiminde 10 disk bölümü bulunduysa kullanıcının 2den 9a kadarki disklerde iso ara veya belirli disklerde 1,5,4,8,10. disklerde ara, diyebilmesi için çalışılıyor.
Edit: Bazı sebeplerden dolayı bırakıyorum. Devam etmek veya incelemek isteyenler için kodlar aşağıda. Usb tespit edince başlama özelleği tamamlandı ama çoklu disk seçiminde hata var. 7 disk bulunduysa kullanıcı 3. ve 6. diskte ara derse sonraki adıma geçiyor ama 7 den fazla yani olmayan disk numarasını girince betik doğru girene kadar tekrar girilmesini istiyor ama sonraki adımı yanlış girdiği kadar işliyor. Kodlar hatanın örneğidir:

Kod Seç Genişlet

#!/bin/bash
#örnektir
bitir(){ echo "Çıkılıyor"; }
kontrol_tamam(){ bitir; }
hata_bildir(){ echo "Başka rakam giriniz"; start; }
kontrol_et(){ if [ "$a" != "$b" ]; then hata_bildir; bitir; fi; }
start(){ read b; kontrol_et; }
a=3
echo "Bir rakam giriniz:";
start


Kod Seç Genişlet


#!/bin/zsh
_start_(){
    clear
    toplam_sector=$(cat ${disk_dir}/size)
    sector_size=$(cat ${disk_dir}/queue/hw_sector_size)
    sector_adet=$((toplam_sector/sector_size))
    disk_size=$((toplam_sector*sector_size))   
    dosya_size=$(stat -c %s $dosya)
   
    if [[ $((${dosya_size}+209715200)) -gt $disk_size ]]; then
        echo "${secilen_disk} üzerinde $dosya dosyası için yeterli alan yok\nDosya boyutu:\t$dosya_size bayt\nDisk boyutu:\t$disk_size bayt"; exit
    else
        echo "==>Disk = $secilen_disk\n##################"
        echo "==>Disk biçimlendiriliyor.\n##########################\n\n"
        sudo dd if=/dev/zero of=$secilen_disk bs=$sector_size count=$sector_adet
        sudo parted -s $secilen_disk mklabel msdos
        echo "==>Disk Biçimlendirildi.\n########################\n\n"
        echo "Dosya = $dosya\n"
        echo "==>Dosya yazılıyor.\n###################\n\n"
        sudo dd if=$dosya of=$secilen_disk bs=4M && sync
        echo "==>Dosya yazıldı.\n#################"
        exit
    fi
}

onay_al(){
    clear
    echo "==>Onaylıyor musunuz?\n#####################"
    echo -e "${dosya} dosyasını $secilen_disk diskine yazmak istiyormusunuz?\n\n$secilen_disk üzerinde ki tüm verileriniz silinecektir: ";echo -n "e/h\n"; echo -n "->"
    read onay
    if [ "$onay" = "h" ]; then
        bitir
    elif [ "$onay" = "e" ]; then
        _start_
    else
        hata $onay dosya_kontrol
    fi
}

dosya_kontrol(){
    if [ "$dosya" != "" ]; then
        if [ -f "$dosya" ]; then
            if file -i $dosya|grep octet-stream; then # octet-stream dosyası ise
                onay_al
            else
                clear; echo "==>Hata: $dosya dosyası octet stream değil.\n#####################################################"; dosya_arama_konumu
            fi
        else
            echo "==>Hata: $dosya dosyası mevcut değil.\n#####################################################"; dosya_arama_konumu
        fi
    else
        disk_durumu
    fi
   
}

iso_bulundumu(){
    if [ "$dosya" != "" ]; then #iso bulundu
        echo "==>Bulunan Kalıp Dosyaları:\n###########################\n\n"
        iso_adet=$(echo $dosya|wc -l)
        for (( i=1; i<=$iso_adet; i++ )); do
            echo -n "$i:  "; echo $dosya|sed -n $i'p'
        done
        echo "\n\nYazdırmak istediğiniz dosyanın numarasını giriniz:\nArama menüsüne dönmek için: G\n"; echo -n "->"
        read dosya_secimi
        if [ "$dosya_secimi" = "G" ] || [ "$dosya_secimi" = "g" ]; then
            clear; dosya_arama_konumu
        elif [ "$dosya_secimi" -eq "$dosya_secimi" ]; then #sayı girilmişse
            dosya=$(echo $dosya|sed -n $dosya_secimi'p')
            dosya_kontrol
        elif [ "$dosya_secimi" = "Q" ] || [ "$dosya_secimi" = "q" ]; then
            clear; echo "Çıkış yapılıyor."; exit
        else
            hata $numara disk_durumu
        fi
    else #iso bulunamadı ise
        echo "==>Uyarı:$aranacak_disk diskinde uygun dosya bulunamadı.\n\n"
        dosya_arama_konumu
    fi
}

hata_disk(){clear; echo "==>HATA: ('$@[1]') diski bağlanamadı.\n################################\n\n"; "$@[2]" }

disk_durumu(){
    if [ "$aranacak_disk" = "a" ]; then echo "==>Tüm bağlı disklerde arama yapılıyor."; aranacak_disk_konumu="/"; dosya_ara; fi
       
    if echo $aranacak_disk | grep ${secilen_disk: -3} >/dev/null; then
        clear
        echo "==>Hata: $secilen_disk diskini iso dosyasını yazmak için seçmiştiniz. Şimdilik dosya araması yapılmıyor.\n###################################################################################################"
        dosya_arama_konumu
    else
        if lsblk -lno NAME|grep $aranacak_disk; then #disk var
            clear
            mount_edildimi=$(lsblk -lo NAME,MOUNTPOINT|grep $aranacak_disk|head -1|awk '{print $2}')

            if [ "$mount_edildimi" != "" ]; then #disk var ve bağlı
                aranacak_disk_konumu=$(lsblk -lo NAME,MOUNTPOINT|grep $aranacak_disk|awk '{print $2}') #nerede bağlı
                dosya_ara -xdev
            else # disk var ama bağlı değil
                clear; echo "==>$aranacak_disk diski bağlı değil.\n##########################\n\nDiski bağlamak için:\tB\nÖnceki menü için:\tG\n"; echo -n "->"
                read mount_edilmedi
               
                if [ "$mount_edilmedi" = "B" ] || [ "$mount_edilmedi" = "b" ]; then
                    clear
                    mount_konumu="/tmp/$(date +%D)/$aranacak_disk"
                    echo "==>Bağlama Konumu Seçiniz:\n##########################\n\n"
                    echo "$mount_konumu klasörleri oluşturulup bağlanması için:\tE\nElle dizin konumu girmek için için:\t\t\t\tM\n"; echo -n "->"
                    read nerede_mount_edilsin
                   
                    if [ "$nerede_mount_edilsin" = "E" ] || [ "$nerede_mount_edilsin" = "e" ]; then
                        if sudo mount /dev/$aranacak_disk $mount_konumu;then
                            mkdir -p $mount_konumu && sudo mount /dev/$aranacak_disk $mount_konumu
                            aranacak_disk_konumu=$mount_konumu
                            dosya_ara -xdev
                        else
                            hata_disk $aranacak_disk dosya_arama_konumu
                        fi
                    elif [ "$nerede_mount_edilsin" = "M" ] || [ "$nerede_mount_edilsin" = "m" ]; then
                        clear; echo "==>$aranacak_disk diski hangi dizine bağlanacak?\n######################################\n"; echo -n "->"
                        read nerede_mount_edilsin_m
                        if [ -d "$nerede_mount_edilsin_m" ]; then
                            if sudo mount /dev/$aranacak_disk $nerede_mount_edilsin_m; then
                                sudo mount /dev/$aranacak_disk $nerede_mount_edilsin_m
                                aranacak_disk_konumu=$nerede_mount_edilsin_m
                                dosya_ara -xdev
                            else
                                hata_disk $aranacak_disk dosya_arama_konumu
                            fi
                        else #dizin yoksa
                            clear
                            if [ "$nerede_mount_edilsin_m" != "" ]; then
                                echo "==>Dizin mevcut değil\n#####################\n\n"
                                echo "$nerede_mount_edilsin_m dizini oluşturulup $aranacak_disk diskinin bağlanması için: E\n"; echo -n "->"
                                read nerede_mount_edilsin_m_yok
                                if [ "$nerede_mount_edilsin_m_yok" = "E" ] || [ "$nerede_mount_edilsin_m_yok" = "e" ]; then
                                    sudo mkdir -p $nerede_mount_edilsin_m
                                    if sudo mount /dev/$aranacak_disk $nerede_mount_edilsin_m; then
                                        sudo mount /dev/$aranacak_disk $nerede_mount_edilsin_m
                                        aranacak_disk_konumu=$nerede_mount_edilsin_m
                                        dosya_ara -xdev
                                    else
                                        hata_disk $aranacak_disk dosya_arama_konumu
                                    fi
                                elif [ "$nerede_mount_edilsin_m_yok" = "Q" ] || [ "$nerede_mount_edilsin_m_yok" = "q" ]; then
                                    bitir
                                else
                                    hata $nerede_mount_edilsin_m_yok dosya_arama_konumu
                                fi
                            else
                                clear; echo "HATA: Dizin adresini boş bırakamazsınız"; dosya_arama_konumu
                            fi
                        fi
                    elif [ "$nerede_mount_edilsin" = "Q" ] || [ "$nerede_mount_edilsin" = "q" ]; then
                            bitir
                    else
                        hata $nerede_mount_edilsin dosya_arama_konumu
                    fi
                elif [ "$mount_edilmedi" = "G" ] || [ "$mount_edilmedi" = "g" ]; then
                    clear; dosya_arama_konumu
                elif [ "$mount_edilmedi" = "Q" ] || [ "$mount_edilmedi" = "q" ]; then
                        bitir
                else
                    hata $mount_edilmedi dosya_arama_konumu
                fi
            fi
        else
            echo "Hata: $aranacak_disk aygıtı mevcut değil."; dosya_arama_konumu
        fi
    fi
}

dosya_ara(){dosya=$(sudo find $aranacak_disk_konumu $@ -type f -name "*.iso" -exec file -N -i -- {} +| awk '/octet-stream/{print $1}'|sed 's/.$//'); clear; iso_bulundumu}
multi_disk_durumu(){
    #_hata_kontrol_=$(echo $@|tr -d " "|tr -d ",")
    #if [ "$_hata_kontrol_" -eq "$_hata_kontrol_" ] >/dev/null;then echo "test $_hata_kontrol_"; fi
    echo $@
}

bitir(){clear; echo "Çıkılıyor"; exit}

dosya_arama_konumu(){
    secilen_disk=/dev/sdb ##########################   
    secilen_disk2=${secilen_disk: -3}
    uygun_diskler=$(lsblk -lno NAME|sed -e 's/'"${secilen_disk2}"'[0-9]//g'|sed -e 's/'"${secilen_disk2}"'//g'|sed '/^$/d')
    uygun_disk_adet=$(echo $uygun_diskler|wc -l)
    echo "==>Kalıp Dosya Hangi Diskte Aransın\n###################################"
    for (( i=1; i<=$uygun_disk_adet; i++ )); do
        echo -n "$i:\t/dev/"; echo $uygun_diskler| sed -n $i'p'
    done
    echo -e "\n\nTek diskte ara:\n###############\nListedi ki aygıt için:\t\t\t\t\t\t\t\tNumarası\nDisk konumunu elle girmek için:\t\t\t\t\t\t\tD\n\nÇok diskte ara:\n###############\nTüm bağlı disklerde aramak için:\t\t\t\t\t\tA\nTüm disklerde aramak (bağlı olmayanlar bağlanacak) için:\t\t\t///\nİki disk ve arada kalan disklerde aramak için örnek(tire ile ayırınız):\t\t2-15\nBelirlenmiş disklerde aramak için örnek(virgül ile ayırınız):\t\t\t3,1,5,13\n\n\nDosya yolunu elle girmek için:\t\t\t\t\t\t\tE"; echo -n "->"
   
    aranacak_disk=""
    aranacak_diskler=""
    read aranacak_disk
    disk_kontrol=$(echo $aranacak_disk|tr -d ","|tr -d "-")
    if [ "$disk_kontrol" = "" ]; then clear; echo "Boş bırakamazsınız."; dosya_arama_konumu; fi
    if [ "$aranacak_disk" = "q" ] || [ "$aranacak_disk" = "Q" ]; then bitir; fi
    if [ "$disk_kontrol" -eq "$disk_kontrol" ] 2>/dev/null && [ "$disk_kontrol2" -eq "$disk_kontrol2" ] 2>/dev/null; then # sadece - , ve rakam girilmişse
        aranacak_disk_adet=$(echo $aranacak_disk|tr "," " "|tr "-" " "|wc -w)
        if [ "$aranacak_disk_adet" = 0 ] || (($aranacak_disk_adet>$uygun_disk_adet)); then hata $aranacak_disk dosya_arama_konumu; fi

        if [ "$aranacak_disk_adet" = 1 ]; then
       
            if [ "$aranacak_disk" = "D" ] || [ "$aranacak_disk" = "d" ]; then #manual disk giriş
                clear
                echo "==>Disk konumunu sdX veya sdXY olarak yazınız:\n##############################################"; echo -n "->"
                read aranacak_disk
           
            elif [ "$aranacak_disk" = "A" ] || [ "$aranacak_disk" = "a" ]; then #tüm bağlı disklerde ara
                aranacak_disk="a"; clear
           
            elif [ "$aranacak_disk" -eq "$aranacak_disk" ] 2>/dev/null; then #sayı girilmişse
                disk_denetle $aranacak_disk
                aranacak_disk=$(echo $uygun_diskler|sed -n $aranacak_disk'p')
            elif [ "$aranacak_disk" = "E" ] || [ "$aranacak_disk" = "e" ]; then
                echo "==>iso dosyasının tam yolunu girin:\n###################################"; echo -n "->"
                read dosya
                if [ "$dosya" = "q" ] || [ "$dosya" = "Q" ]; then
                    bitir
                elif [ "$dosya" != "" ]; then
                    dosya_kontrol
                else
                    clear; echo "HATA: Dosya adresini boş bırakamazsınız"; dosya_arama_konumu
                fi
            elif [ "$aranacak_disk" = "Q" ] || [ "$aranacak_disk" = "q" ]; then
                bitir
            else
                hata $aranacak_disk dosya_arama_konumu
            fi
            disk_durumu
           


        elif [ "$aranacak_disk_adet" = 2 ]; then
            if echo $aranacak_disk|grep - >/dev/null; then
                aranacak_disk1=$(echo $aranacak_disk|tr '-' ' '|awk '{print $1}')
                aranacak_disk2=$(echo $aranacak_disk|tr '-' ' '|awk '{print $2}')
                if (( $aranacak_disk1 > $aranacak_disk2 )); then
                        aranacak_diskler=$(printf "%s " {$aranacak_disk2..$aranacak_disk1})
                        iki_disk_denetle -
                elif (( $aranacak_disk1 < $aranacak_disk2 )); then
                        aranacak_diskler=$(printf "%s " {$aranacak_disk1..$aranacak_disk2})
                iki_disk_denetle -
                fi
               
               
            elif echo $aranacak_disk|grep , >/dev/null; then
                aranacak_disk1=$(echo $aranacak_disk|tr ',' ' '|awk '{print $1}')
                aranacak_disk2=$(echo $aranacak_disk|tr ',' ' '|awk '{print $2}')
                if (( $aranacak_disk1 > $aranacak_disk2 )); then
                        aranacak_diskler=$(echo "$aranacak_disk1 $aranacak_disk2")
                elif (( $aranacak_disk1 < $aranacak_disk2 )); then
                        aranacak_diskler=$(echo "$aranacak_disk2 $aranacak_disk1")
                iki_disk_denetle ,
                fi
#                echo $aranacak_diskler; multi_disk_durumu $aranacak_diskler
            fi
           
        elif (($aranacak_disk_adet>2)) && (($aranacak_disk_adet<=$uygun_disk_adet)); then
            multi_disk_denetle
            aranacak_diskler=$(echo $aranacak_disk| tr "," " ")
            multi_disk_durumu $aranacak_diskler
        else
            hata $aranacak_disk dosya_arama_konumu
        fi
    else
        hata $aranacak_disk dosya_arama_konumu
    fi
   
}
disk_denetlendi(){
    echo "aranacak disk $aranacak_disk"
}
disk_denetle(){
    z=1; if (($@<$z)) || (($@>$uygun_disk_adet)); then durdur=1; devam=1; hata $@ dosya_arama_konumu; fi
}
multi_disk_denetle(){
    if echo $aranacak_disk|grep - >/dev/null; then hata $aranacak_disk dosya_arama_konumu; fi
    #disk seçerken virgül sayısı disk sayısından 1 eksik çıkmalı
    hata_kontrol1=$(echo $aranacak_disk|tr "," "\n"|wc -w) #disk adet
    hata_kontrol2=$(echo $aranacak_disk|sed 's/[0-9]*//g') #virgül tespiti
    hata_kontrol2=$(echo ${#hata_kontrol2}) #virgül adet
    hata_kontrol3=$(echo $((hata_kontrol1-hata_kontrol2)))
    z=0
    if [ "$hata_kontrol3" = 1 ]; then
        for (( a=1; a<=$aranacak_disk_adet; a++ )); do
            diska=$(echo $aranacak_disk|tr "," " "|awk '{print '"\$${a}"'}')
            if (($diska<=$z)) || (($diska>$uygun_disk_adet)); then  durdur=1; fi #gereksiz döngüyü önleyip hata engelleme
            if [ "$durdur" != 1 ]; then
                for (( b=1; b<=$aranacak_disk_adet; b++ )); do
                    if [ "$b" != "$a" ]; then
                        diskb=$(echo $aranacak_disk|tr "," " "|awk '{print '"\$${b}"'}')
                        if [ "$diskb" != "$diska" ]; then
                            if (($diskb>$z)) && (($diskb<=$uygun_disk_adet)); then
                                if [ "$durdur2" != 1 ]; then
                                    disk_denetlendi
                                fi
                                durdur2=1
                            else
                                hata $aranacak_disk dosya_arama_konumu
                            fi
                        else
                            hata $aranacak_disk dosya_arama_konumu
                        fi
                    fi
                done
            else
                break
            fi
        done
    else
        hata $aranacak_disk dosya_arama_konumu
    fi
}
iki_disk_denetle(){
    hata_kontrol_=$(echo $aranacak_disk|sed 's/[0-9]*//g') #tire, virgül tespiti
    hata_kontrol_=$(echo ${#hata_kontrol_}) #tire,virgül adeti
    a=1; if (($hata_kontrol_>$a)); then hata $aranacak_disk dosya_arama_konumu; fi #2 diske 1 virgül yada tire girilebilir
    #aranacak_disk1=$(echo $aranacak_disk|tr $@ ' '|awk '{print $1}')
    #aranacak_disk2=$(echo $aranacak_disk|tr $@ ' '|awk '{print $2}')
    disk_denetle $aranacak_disk[1-2]
    if [ "$aranacak_disk1" = "$aranacak_disk2" ]; then; hata $aranacak_disk dosya_arama_konumu; fi
}

hata(){clear; echo -e "==>Hata: ('$@[1]') geçersiz seçim! \n###########################"; "$@[2]"}


disk_umount_yap(){
    disk_mountpoint=$(lsblk -lno NAME,TYPE,MOUNTPOINT $secilen_disk|grep disk|awk '{print $3}')
        if [ "$disk_mountpoint" != "" ]; then
            echo "$secilen_disk aygıtı umount ediliyor."
            sudo umount $secilen_disk
        fi
    partition_adet=$(lsblk -lno TYPE,NAME $secilen_disk|grep part|wc -l)
    for (( i=1; i<=partition_adet; i++ )); do
        mount_point=$(lsblk -lo TYPE,NAME,MOUNTPOINT $secilen_disk|grep part|awk '{print $3}'|sed -n $i'p')
        if [ "$mount_point" != "" ]; then
            _part_=$(echo "/dev/$(lsblk -lo TYPE,NAME $secilen_disk|grep part|sed -n $i'p'|awk '{print $2}')")
            echo "$_part_ bölümü umount ediliyor."
            sudo umount $_part_
        fi
    done
    dosya_arama_konumu
}

disk_sorgula(){
    if [ "$numara" = "Q" ] || [ "$numara" = "q" ]; then bitir; fi
    if (( $numara<=$removable_disk_adet )) && (( $numara > 0 )); then
        secilen_disk=$(echo -n "/dev/"; echo $removable_diskler|awk '{print '"\$${numara}"'}')
        clear
        echo "==>Seçilen bellek: $secilen_disk\n"
        disk_umount_yap
       
    else
        hata $numara disk_sec
    fi
}

disk_sec(){
    echo "==>Kalıp Hangi Diske Yazılsın\n##############################"
    if [ "$removable_diskler" = "" ]; then
        echo -e "\n==> HATA : çıkarılabilir disk bulunamadı ! \n"
        exit
    fi
    for (( i=1; i<=$removable_disk_adet; i++ )); do
        echo -n "\n$i birim    :/dev/"; echo $removable_diskler|tr -d " "
    done
    echo "\n\nKullanmak istediğiniz usb numarasını seçin :";echo -n "->"
    read numara
    disk_sorgula

}
removable_disk_bekle(){
    while [ "$mount_kontrol" = 0 ]; do
        mount_kontrol=$(dmesg|tail -1|grep -i attached|wc -l); sleep 1
    done
    removable_disk_tespit_et
}
removable_disk_tespit_et(){
    diskler=$(lsblk  -lo NAME,HOTPLUG,TYPE|grep disk|awk '{print $1}')
    disk_adet=$(echo $diskler |wc -l)
    removable_diskler=""
    removable_disk_adet=0
    if [ $disk_adet = 0 ]; then echo "Disk bulunamadı"; exit; fi #canlı sistemi ram a yüklerse veya başka durumlarda olabilir mi? diye ekledim.
    for (( i=1; i<=$disk_adet; i++ )); do
        disk=$(echo $diskler|sed -n $i'p')
        disk_dir=/sys/block/$disk
        if [[ -d $disk_dir ]]; then
            REMOVABLE=$(cat ${disk_dir}/removable)
            if [ $REMOVABLE = 1 ]; then
                removable_diskler="$removable_diskler $disk"
                removable_disk_adet=$((removable_disk_adet+1))
            fi
        fi
    done
    if [ "$removable_diskler" = "" ]; then
        echo "==>Çıkarılabilir diskinizi takın...\n####################################"
        mount_kontrol=$(dmesg|tail -1|grep -i attached|wc -l)
        removable_disk_bekle
    fi
    disk_sec
}

software_check(){
    if which cp >/dev/null; then #which dosyası varsa
        if which wc >/dev/null && which tr >/dev/null && which sed >/dev/null; then #wc, tr, sed dosyaları varsa
            gerekli_dosyalar=$(echo "lsblk grep awk cat sudo umount find mount mkdir head date file sync dd parted stat zsh dmesg tail"|tr " " "\n")
            gerekli_dosyalar_adet=$(echo $gerekli_dosyalar|wc -l)
            dosya_eksik=0
            for (( i=1; i<=$gerekli_dosyalar_adet; i++ )); do
                if ! which $(echo $gerekli_dosyalar|sed -n $i'p') >/dev/null; then
                    echo -n $(echo $gerekli_dosyalar|sed -n $i'p'); echo " dosyasını yüklemeniz gerekiyor."
                    dosya_eksik=1
                fi
            done
            if [ $dosya_eksik = 0 ]; then removable_disk_tespit_et; fi
        else
            echo "Aşağıda ki dosyaları yüklemeniz gerekiyor:\nwc tr sed"
        fi
    else
        echo 'HATA:Sisteminizde "which" dosyası bulunamadı.'
    fi
}
clear
software_check #BETİĞİ BAŞLAT



[mimiksiz]

Forum yetkililerine soruyorum; Betiği temize çıkararak ve kırparak yeniden yazdım ama daha önce ki eklediklerim stabil olmadıdığı için onları silip yenisini paylaşmamda bir sakınca var mı?

[alquirel]

Eskisini kaldırmana gerek yok. Eski olduğunu iletinde belirtmen yeterli. Ya da GitHub gibi bir depon varsa bu iletide eskileri kaldırıp eskiler için depona bağlantı verebilirsin.

[mimiksiz]

Teşekkürler @alquirel
Şuan benioku dosyası hazırlıyorum.
Betik ilk yoruma eklendi.

[systmrrr]

harika bir çalışma olmuş elinize sağlık. daha başka çalışmalarınız için bekliyoruz. deneyip deneyimleri buradan paylaşmayı düşünüyorum.

[mimiksiz]

@systmrrr beğendiğinize sevindim, destekleriniz için teşekkürler
*
ilk yorumu yanlışlıkla boşaltmışım. Yeni betiği tekrar ekledim ama eski betiklerden sadece 1 tanesi var elimde