O kodu tam hatırlamıyorum ama yapmış olduğunuz configurasyon dosyasını test etmeniz için bir komut; Çalışan config dosyasını aktif ediyor ancak startup confige yazmıyor böylelikle sizin belirtiğiniz süre içinde reset atıp eski config dosyanıza geri dönmenizi sağlıyor. Hatırlayan olursa bi zahmet yazıversin bana Neyse konumuza geri dönelim kullandığımız script çok basit iptables’ı sıfırlıyor tabi cronjob a bunu atıyoruz çalışamaya başlamadan olurda kendimizi kilitlersek diye
#!/bin/bash
# Firewallumuzu olduğu gibi bırakmak için aşağıdaki durum değerini 0 bırakıyoruz.
# Firewallumuzu resetlemek istiyorsak durum degeri 1 olmalı ki döngüye girip firewallu sıfırlasın.
durum=1
# Centos Redhat ve Fedora sistemler dışındaki dağıtımlar için değerimiz "hayir" olucak
# Ben Centos kullandığım için benim değerim evet
sistem=evet
yol=/sbin/iptables
if [ "$durum" == "1" ];
then
if [ "$sistem" == "evet" ];
then
# Firewall'u durdurmak için
/etc/init.d/iptables stop
else
# Diğer linux distroları için aşağıdaki kodları kullanıyor.
$yol -F
$yol -X
$yol -Z
for tablo in $(/proc/net/ip_tables_names)
do
$yol -t $tablo -F
$yol -t $tablo -X
$yol -t $tablo -Z
done
$yol -P INPUT ACCEPT
$yol -P OUTPUT ACCEPT
$yol -P FORWARD ACCEPT

fi
else
:
fi
Çalıştırma izni için
chmod +x /root/sifirla.sh
Bu dosyamızı 5 dk da bir çalıştırmak için /etc/crontab altına
*/5 * * * * root /root/sifirla.sh satırını ekliyoruz.
Önemli nokta: Çalışmaya başlamadan önce yukarıdaki durumu dikkate alınız!!!

Öncelikle sisteminizin şu anki ip adresini kontrol edin:

kitap# ifconfig
lnc0: flags=8843 mtu 1500
        inet 10.0.0.58 netmask 0xffffff00 broadcast 10.0.0.255
        ether 00:0c:29:a7:61:41
lp0: flags=8810 mtu 1500
lo0: flags=8049 mtu 16384
        inet 127.0.0.1 netmask 0xff000000
kitap# _
Koyu harflerle yazılmış olan kısım lnc0 isimli ethernetinizin ip adresidir.
ether Kelimesiyle başlayan ifade ise ethernet kartınızın MAC adresidir.

Gelelim ethernet kartımızın (unixte ağ arayüzü yani network interface diye geçer) ayarlarını yapmaya:

kitap# /stand/sysinstall 

komutunu çalıştırıyoruz.
Karşımıza gelen menüden Configure seçeneğini seçelim.
Gelen seçeneklerden ise Network konfigurasyonu bölümüne girelim.
Network konfigurasyonunda ise Interfaces kısmına girelim.
(Girdiğimiz menülerin isimlerini bir araya getirin. Bakın ne oluyo= Configure Network Interfaces Dikkat ettiniz mi? )

Aşağıdaki gibi bir menü gelecek:

Bu menüden IP adresini değiştirmek istediğiniz ethernet kartınızı seçin.
(Burada benim ethernet kartım lnc0: Lance/PCnet (Isolan/Novell Ne2100/NE32-VL) ethernet)

Kartınızı seçtikten sonra aşağıdaki gibi bir konfigurasyon ekranı gelecek. Burada istediğiniz değişikliği yapın:

Değişiklikleri yaptıktan sonra OK seçeneğini seçin ve program çıkın.

Yapmış olduğunuz değişiklikler henüz uygulanmadı ancak konfigürasyon dosyasına kaydedildi.
Bu değişiklikleri aktif hale getirmek için:

kitap# /etc/netstart

komutunu çalıştırın.

kitap# /etc/netstart
hw.bus.devctl_disable: 1 -> 1
lnc0: flags=8843 mtu 1500
        inet 10.0.0.10 netmask 0xffffff00 broadcast 10.0.0.255
        ether 00:0c:29:a7:61:41
lo0: flags=8049 mtu 16384
        inet 127.0.0.1 netmask 0xff000000
add net default: gateway 10.0.0.2
Additional routing options:.

Değişikliklerin uygulanıp uygulanmadığını netstart’ın ekrana vermiş olduğu çıktıdan kontrol edebilirsiniz.

IP Değiştirme bitti. Hepsi bu kadar

Özkan KIRIK 
FreeBSD Sistem Yöneticisi 
    

if / if-else Yapısı:
Kullanımı diğer dillerde olduğu gibi;

if  koşul
        koşul gerçeklenmişse çalışacak kod

Yalnız, sözdizimi C programcıları için biraz yabancı olabilir. Herşeyden önce kontrol yapılarının bloklarının kapanışları ve karşılaştırma operatörleri biraz farklı. Mesela çok basit bir if örneği yazacak olursak;
root@gnu [17:13:53] # cat current.sh
#!/bin/bash
 
Gördüğünüz gibi gerçekliğini denediğimiz koşul köşeli parantezler arasında ve blok kapanışı da farklı. Bu arada kısa bir not; köşeli parantezleri kullanmadan da karşılaştırmalar yapabiliriz. Bunun için test deyimi kullanılır. Yukarıdaki kodun test ile yazılmış hali aşağıdadır.
if test $bir -lt $iki; then
        echo 'bir > iki'
fi
 
Tekrar sözdizimine dönecek olursak;if yapısının şablonunu Bash’e göre tekrar yazalım:

bir=1
iki=2

if [ $bir -lt $iki ]; then
        echo ‘bir > iki’
fi

exit
root@gnu [17:14:30] # ./current.sh
bir > iki

if koşul; then
        # Çalışacak Kod
elif koşul; then
        # Çalışacak Kod
fi

if’in bloğunu kapatan anahtar sözcüğün if’in tersi olduğuna dikkat; aynı kural case (o da esac anahtar sözcüğü ile kapanır) yapısında da geçerli.

Burada kullanabileceğimiz operatörlerden bazıları şunlar:
-eq  :  eşit (equal)
-ne  :  eşit değil (not equal)
-lt  :  küçük (less than)
-le  :  küçük eşit (less than or equal to)
-gt  :  büyük (greater than)
-ge  :  büyük eşit (greater than or equal to)
Not: Bash betiklerindeki karşılaştırmalarda <, > ve != gibi operatörleri de kullanabilirsiniz ancak bunlar diziler için kullanılırlar (mesela iki karakter dizisinin karşılaştırılmasında).

Bu operatörlerle ilgili bir örnek daha sanırım yeterli olacaktır. Betiğimizin parametre olarak aldığı dosyanın satır sayısını ekrana yazsın ( biri wc -l < current.sh mi dedi? ) Tabii ki daha kolay sonuca ulaşabiliriz ancak bu sadece bir örnek;
root@gnu [18:32:06] # cat -n current.sh
     1  #!/bin/bash
     2
     3  if [ $# -ne 1 ]; then
     4          echo "Hatali parametre!";
     5          echo "Kullanim: $0 dosya_adi";
     6          exit;
     7  fi
     8
     9  echo $1 adli dosya `wc -l < $1` satir
    10
    11  exit
    12
root@gnu [18:32:41] # ./current.sh current.sh
current.sh adli dosya 12 satir
 
Geçen dersten hatırlarsanız $# kabuk değişkeni betiğe gelen parametre sayısını tutuyordu;

Not: Eğer betiğinizde bir hata varsa Bash kabuğuna -x parametresini göndererek yapılan işlemleri ve çalıştırılan komutları adım adım görebilirsiniz:
root@gnu [18:43:29] # cat current.sh
#!/bin/bash -x
 
Bu şekilde, özellikle ayırma (parsing) hataları, çok kolay bulunuyor.

if [ $# != 1 ]; then
        echo “Hatali parametre!”;
        echo “Kullanim: $0 dosya_adi”;
        exit;
fi

echo $1 adli dosya `wc -l < $1` satir

exit

root@gnu [18:43:32] # ./current.sh current.sh
+ ‘[' 1 '!=' 1 ']‘
++ wc -l
+ echo current.sh adli dosya 12 satir
current.sh adli dosya 12 satir
+ exit

case/esac Yapısı:

case/esac de tıpkı C ve Pascal’da olduğu gibi olması muhtemel durumları ele almak için kullanılır. Genel yapısı aşağıdaki şekildedir:
case seçenek in
     durum_1)
          komutlar
          ;;
     durum_2)
          komutlar
          ;;
     durum_3)
          komutlar
          ;;
     *)
          komutlar
esac
Burada tahmin edeceğiniz gibi çeşitli durumlarda aradığımız seçenek’in gerçekleşip gerçekleşmediğine bakıyoruz. Yukarıda yazılan 3 durumda da aradığımız koşulun olmaması durumunda *) ile belirtilen kısımdaki kod çalıştırılır. Sanırım bir örnekle daha rahat anlaşılacaktır. Aşağıdaki örnekte kullanıcıdan bir dosya adı alıp bu dosyanın çeşitli özelliklerini yazdıralım; yazdırılacak özellikler de bir menüden seçilsin. Ancak bundan önce kodda kullanacağımız bir kaç özelliği söylemekte fayda var.

Aşağıdaki operatörler sorunun cevabının evet olduğu yerlerde doğru değerini üretir.

-a dosya : Dosya var mı?
-b dosya : Dosya var mı ve blok özel dosyası mı? (aşağıdaki not’a bakınız)
-c dosya : Dosya var mı ve karakter özel dosyası mı? (aşağıdaki not’a bakınız)
-d dosya : Dosya var mı ve bir dizin mi?
-e dosya : Dosya var mı?
-f dosya : Dosya var mı ve sıradan bir dosya mı?
….
Bu gibi bir çok kontrol operatörü var; diğerleri için bash kabuğunun yardım dosyalarına bakmanızı tavsiye ederim..

Not: “block special file” ve “character special file” kelimelerinin çevirilerinin sırıttığının farkındayım ve çeviri önerilerinizi bekliyorum. Bunları açıklamak gerekirse blok özel dosyalar taşıdıkları veriye rastgele erişim yapabildiğimiz dosyalardır ve bunlara örnek olarak ana bellek ve sabit diskler verilebilir. Karakter özel dosyalar ise çoğunlukla girdi/çıktı işlemlerinde kullanılan ve sadece veri alıp yolladığımız -yani rastgele erişimin sözkonusu olmadığı- dosyalardır. Bunlara ise USB girişleri ve konsol örnek verilebilir. Daha ayrıntılı bir liste için:
root@slackware [20:11:37] # cat /proc/devices
Character devices:
  1 mem
  2 pty
  3 ttyp
  4 ttyS
  5 cua
  7 vcs
10 misc
14 sound
29 fb
...........
 
komutunu kullanabilir ve devices dosyasını inceleyebilirsiniz. Artık örneğimize dönebiliriz (örneğin ne yaptığını hatırlıyoruz değil mi? )
#!/bin/bash
# -x
 

echo “Dosya Adi:”
read dosya

echo : $dosya adli dosya hakkinda bilmek istedikleriniz?

# Seçenekleri ekrana yaz ve kullaniciya sor
echo “1) Ben yazdim ama bu dosya var mi?”
echo “2) Bu dosyadaki haklarim nelerdir?”
echo “3) Ayni isimde baska neler var?”
echo “4) Sil sen bu dosyayi isim yok onla!”
echo “Seçiminiz: ”
read secenek

case $secenek in
     1)
          if [ -a $dosya ]; then
               echo “Evet var”
          else
               echo “Hayir yok ama yaratirizz ”
          fi
          ;;
     2)
          echo “Haklariniz: ”
          if     [ -r $dosya ]; then
               echo -n “r (okuma) “;
          fi;if     [ -w $dosya ]; then
               echo -n “w (yazma) “;
          fi;if     [ -x $dosya ]; then
               echo “x (calistirma) “;
          fi
          ;;
     3)
          echo \”$dosya\” adinda `locate -i $dosya|wc -l` tane daha dosya var
          ;;
     4)
          rm -i $dosya
          ;;
     *)
          echo “Hatali seçenek! ”
esac

exit

Örnek bir çıktı ise;
root@slackware [22:59:14] # ./shell.sh
Dosya Adi:
core
: core adli dosya hakkinda bilmek istedikleriniz?
1) Ben yazdim ama bu dosya var mi?
2) Bu dosyadaki haklarim nelerdir?
3) Ayni isimde baska neler var?
4) Sil sen bu dosyayi isim yok onla!
Seçiminiz:
3
“core” adinda 2231 tane daha dosya var

case/esac yapısıyla ilgili son bir örnek; bu örneğimiz ise calc adında olsun ve komut satırından girilen basit aritmetik işlemleri (3+5, 7*8 gibi 2 sayı ve bir operatörden oluşan) yapsın.
#!/bin/bash
 
Yalnız bu betikte dikkat edilmesi gereken iki nokta var: Birincisi çarpma operatörünün Bash kabuğunda özel bir anlamı vardır ve komut satırı parametrelerinin elde edilmesinde kullanılır. Bu yüzden çarpma işlemi yaparken betiğe “3 \* 4″ gibi bir parametre vermelisiniz (hatırlarsanız ters bölü karakteri özel karakterlerin anlamlarını yitirmesine yarıyordu). İkincisi ise bir bug (böcük); case/esac yapısında en sondaki -düşündüklerimizin dışındaki durumları ele alan- *) kısmı çarpma işlemi ile çakışıyor. Yani, operatör yerine herhangi bir değer girmeniz halinde kendince bir çıktı üretecektir. Bu konuda aklıma gelen bir şey yok, önerilerinizi bekliyorum.

if [ $# -ne 3 ]; then
     echo hatali parametre!
     echo kullanim: $0 sayi operator sayi
     exit
fi

case $2 in
     +)
          echo sonuc: `expr $1 + $3`
          ;;
     -)
          echo sonuc: `expr $1 – $3`
          ;;
     /)
          echo sonuc: `expr $1 / $3`
          ;;
     *)
          echo sonuc: `expr $1 \* $3`
          ;;
esac

exit

Örnek bir çıktı;
root@slackware [20:22:05] # ./calc.sh 3 + 99
sonuc: 102
Şimdilik benden bu kadar. Bir sonraki derste görüşmek üzere.

M.Barış Demiray

Öncelikle kabuk programları DO$’taki .bat (batch) dosyaları gibi düz metin dosyalarıdır. Yani bildiğiniz/duyduğunuz C, Pascal dillerinde olduğu gibi yazdığınız kod derlenmez, yorumlanır (interpretation). Derlenen dillerde oluşturulan ikili dosyada herhangi bir çevirime gerek yoktur, çünkü zaten bilgisayarın anlayabileceği dilde (ikilik) oluşturulmuş dosyalardır. Ancak yorumlanma işleminde adı üstünde kod okunur ve karşılaşılan ifadeye göre bir işlem yapılır (Örnek Java). Kabuk programlarının düz metin olduğunu söylemiştik. Yani istediğiniz herhangi bir metin editörünü kullanabilirsiniz. Bir örnek olarak yeni bir dosya yaratalım ve bu betiğimiz (script) windows bölümümüzü (partition) bağlasın ve çalışma dizinimizi seçtiğimiz bir dizin olarak değiştirip o dizindeki dosyaları listelesin. Bunun için ben pico’yu kullandım.

pico win_c.sh

win_c.sh

mount -t vfat /dev/hda1 /windows/C
cd /windows/C; clear; ls -la

Bu satırları win_c.sh dosyası içine yazdıktan sonra editörden çıkıyoruz. Yalnız dosya uzantısının .sh olmasına gerek yok. Herhangi bir uzantı olabilir. Linux’te, dosya türlerini uzantılarına bakarak belirleme gibi bir saçmalık yoktur. Burada ayrıntılı bir dizin listelemesi yaparsak

ls -la

root @ linux # ls -la
total 12
drwxr-xr-x    2 root     root         4096 Dec 23 18:16 .
drwxr-xr-x    7 root     root         4096 Dec 21 12:19 ..
-rw-r–r–    1 root     root           65 Dec 23 18:16 win_c.sh

Gördüğümüz gibi win_c.sh dosyasının çalıştırma hakları ayarlı değil. Bu durumda bu dosyayı çalıştıramayacağımızdan aşağıdaki komutla çalıştırma haklarını veriyoruz.

chmod 755 win_c.sh

Tekrar listeleyecek olursak:

root @ linux # ls -la
total 12
drwxr-xr-x    2 root     root         4096 Dec 23 18:16 .
drwxr-xr-x    7 root     root         4096 Dec 21 12:19 ..
-rwxr-xr-x    1 root     root           65 Dec 23 18:16 win_c.sh

Burada 755′in anlamı şudur. Bu sayıyı ayırırsak

7 5 5
|  | |______ Diğerlerinin hakları
|  |________ Dosya sahibinin ait olduğu grubun hakları
|__________ Dosya sahibinin hakları

7,5,5 rakamları ise şu şekilde oluşur.

4 – (R) Okuma hakkı
2 – (W) Yazma hakkı
1 – (X) Çalıştırma hakkı

Bu sayılardan verilen hakların karşılıkları toplanarak yukarıdaki sayılar elde edilir. Yani win_c.sh dosyasını sahibi okur,yazar,çalıştırır; grubu ve diğerleri ise sadece okur ve çalıştırır.

Dosya haklarını belirlemek için aşağıdaki komutu da kullanabilirdik.

chmod u+x win_c.sh

Şimdi “e peki madem böyle oluyor neden kendimize eziyet edelim?” diyorsanız şunu söylerim, bir problemde zor yoldan gidiyorsanız daha çok şey bilmeniz gerekir. Burada u+x ifadesini kullanırsanız kabuk sizin yerinize komutu ayırır (parse), yorumlar ve gerekeni yapar. Ancak 755 ifadesinin mantığı “bit manipulation” (tek tek bit değiştirme) ‘a kadar gidiyor. Bu yüzden ikisini de öğrenmekte fayda var.

Burada da user’a (sahibine), execute (çalıştırma) hakkını veriyoruz. Verilen çalıştırma hakkı

chmod 644 win_c.sh

ya da

chmod u-x win_c.sh

şeklinde geri alınabilir.

Konudan yeterince uzaklaştığımıza göre artık kabuk programlamaya geri dönebiliriz

Bahsetmek istediğim bir başka şey de yorum satırları. # karakteri ile betiklerinize yorum satırları koyabilirsiniz. Örneğin;

# Yazar : Dionysos
# Tarih  : 23 Aralık 2003

# karakteri ile tüm satır yorum satırı haline gelecektir.

Yazdığınız betikleri çalıştırmanın ise bir kaç yolu vardır:

win_c.sh

ya da

. win_c.sh

yazarak çalıştırabilirsiniz. İkinci örnekte dosya adının başında . karakteri olduğuna dikkat. Bu kabuğa “bir betik geliyor, adam gibi iyice oku anla ve adım adım çalıştır” direktifini verir. Yani içinde çalıştırılabilir kod olan herhangi bir dosyayı -haklarını verdikten sonra- başına . karakterini ekleyerek çalıştırabiliriz. Betiklerinizi çalıştırmak için bir başka yol da betiğin yazıldığı kabuktan yeni bir tane çalıştırmak ve dosya adını parametre olarak göndermektir. Bunun için aşağıdaki gibi bir komut kullanabilirsiniz:

bash win_c.sh

Bu durumda yeni bir kabuk çalıştırılır ve komutlar o kabukta çalışır. Tabi bu durumda win_c.sh dosyasının ya bulunulan dizinde ya da PATH adlı kabuk dizininde bulunması gerekir. Hatırlayacağınız gibi PATH değişkeninde komutların aranması gereken dizinler yer alır.

Değişkenler: Çoğu kabukta aşağıdaki formatta bir komutla değişken tanımlayabilir ve değer verebilirsiniz:

Sampiyon=Fenerbahce

Burada Sampiyon adında bir değişken tanımladık ve değerini Fenerbahçe yaptık. Bu değişkenin uzun bir süre kullanılabileceğinden emin olabilirsiniz.

NOT: tcsh kabuğunda
set Sampiyon = Fenerbahce
yazmanız gerekir.

Yukarıdaki notu yazma sebebim değişken tanımlarken komut formatına dikkat çekmekti. Bash kabuğunda = karakteri ve değişken isimleri/değerleri arasında boşluk olmamalıdır. Ancak örneğin tcsh ( csh kabuğunun geliştirilmiş hali ) ‘de arada boşluk olup olmaması farketmez.

Ayrıca değişken tanımlarken “bildirim” kısmının olmadığına dikkat! Kabuk betiklerinde bildirim (bellekten yer ayırma) işlemine gerek yoktur çünkü kodlar yorumlanır. Kabuk satır satır kodları okurken bu işlemi yapacaktır. Ayrıca bu bize karakterleri, dizgileri (string) ve sayıları aynı değişkende tanımlama esnekliğini kazandırır. Örnek olarak yukarıda tanımladığımız Sampiyon değişkenine bir dizgi değeri atamıştık.

Değişkenlere Erişim: Kabuk programlamada değişkenlerin değerlerini elde etmek için $ karakteri kullanılır. Değişkenlerin değerlerini direk değişken adıyla yazamayız çünkü bu durumda dizgi olarak algılanırlar.

echo Sampiyon

Bunun yerine aşağıdaki formatı kullanmalıyız:

echo $Sampiyon

root @ linux # Sampiyon=Fenerbahce
root @ linux # echo Sampiyon # Yanlis!
Sampiyon
root @ linux # echo $Sampiyon # Dogru!
Fenerbahce

Komut Satırı Parametreleri:
Bash kabuğunda kabuk betiğimize parametre gönderebiliriz (Bu komutlara Positional Parameters adı verilir). Komut satırı parametrelerini elde etmek için bir kaç öntanımlı değişken vardır. Bunlara girmeden önce bir hatırlatma yapmak istiyorum. Bir programa gönderilen parametreler çoğunlukla bir dizide tutulur. Mesela C’de bu dizinin ilk elemanı (0. indeksteki) parametrelerin yollandığı programın adını alır. Kabuk betiklerinde de bu parametreler bir dizidedir ve ilk parametre (0. indeks) betik dosyasının ismidir.

Bu parametreleri almak için Bash’te aşağıdaki değişkenler tanımlanmıştır:

$# : Betiğe gönderilen parametre sayısını saklar
$* : Betiğe gönderilen parametrelerin değerlerini tutar (Yani $0 dosya adı, $1 ilk parametre, ..)
"$@" : Komut satırından yollanan tüm parametreler, " karakteriyle beraber ("$1", "$2", gibi)
$? : Çalıştırılan bir önceki komutun gönderdiği değer (Exit Value).

$# Örneği

root @ linux # . win_c.sh bir iki uc
3

$* Örneği

root @ linux # . win_c.sh bir iki uc
bir iki

Bu değişkenler ile parametreleri tek tek ya da beraber olarak işleyebiliriz. Mesela

+—————– sil ———————-+

#Gönderilen parametredeki dosyayı sil
rm -i "$1"

+—————- /sil ———————-+

Bu dosyayı oluşturursanız ve aşağıdaki şekilde çalıştırırsanız ismini verdiğiniz dosyayı -sizden onay alıp- silecektir. Onay işlemini ise -i (interactive) parametresi sağlar.

root @ linux # ls -l
total 4
-rw-r–r–    1 root     root            0 Dec 23 18:32 bi_ayagi_cukurda
-rwxr-xr-x    1 root     root           12 Dec 23 18:33 sil
root @ linux # . sil bi_ayagi_cukurda
rm: remove `bi_ayagi_cukurda’? y
root @ linux # ls -l
total 4
-rwxr-xr-x    1 root     root           12 Dec 23 18:33 sil

Ya da ilk parametreyi alarak bu isimde başka bir dosya olup olmadığına bakan kompleksli bir betik..:

+—————– var_mi —————–+

find / -name "$0"

+—————- /var_mi —————–+

$# gibi diğer değişkenler döngüleri anlattıktan sonra daha iyi anlaşılacağından o zamana bırakıyorum.

“, ‘ ve \ karakterlerinin kullanımı:

Eğer yazdığımız komutlarda kabuk tarafından çalıştırılabilecek kodlar varsa ve biz bunları engellemek istiyorsak başlıktaki karakterleri kullanabiliriz.

Bu üç karakterin hepsinin engelleme derecesi farklıdır. Engelleme derecesinden kastım; tek bir karakterin yorumlanmasını ya da tüm dizginin yorumlanmasını engelleme arasındaki fark.

” (Çift Tırnak) Karakteri ve Yorumu: Çift tırnak karakteri, yukarıda bahsettiğimiz engelleme derecelerinden en alt seviye olanıdır. Sadece boşlukların yok sayılmasını sağlar. Bu ise birden fazla kelimeden oluşan dizgileri kullanırken işe yarar. Örnek olarak kimlik adlı değişkene baris demiray dizgisini atamak için kullanabiliriz;

kimlik="baris demiray"

Eğer çift tırnakları kullanmasaydık:

root @ linux # kimlik=”baris demiray”
root @ linux # kimlik=baris demiray
bash: demiray: command not found

‘ (Tek Tırnak) Karakteri ve Yorumu: Tek tırnak karakteri çift tırnaktan daha etkilidir. Kabuktan tüm özel karakterleri saklar. Örneğin programınızda;

echo "Program Adı $0" #Çift Tırnak

yazarsanız sorunsuz çalışacak ve dosya adını yazacaktır.

root @ linux # betik_ad
Program Adi ./betik_ad

Ancak tek tırnak kullanırsanız tüm özel karakterler yok sayılacağından ;

echo 'Program Adı $0' #Tek tırnak

kodu

root @ linux # betik_ad
Program Adi $0

çıktısını üretir. Bu nedenle bu karakterleri kullanırken derecelerini hesaba katarak biraz daha dikkatli olmakta fayda var.

\ Karakteri ve Yorumu: Ters bölü karakteri ise karakter bazında işlem yapar. Yani \ karakteri ile sadece bir özel karakteri kabuktan saklayabiliriz. Örneğin $ karakterini görüntüleyebilmek için;

echo \$Test

yazmalıyız ( ya da echo ‘$Test’ tabii ki). Mesela ilk örnekte ” karakterinin boşlukları yok saydığını söylemiştik. \ karakterini kullanarak ” kullanmadan boşlukları tanıtabiliriz. Bu durumda -normalde komut ayıracı olan- boşluklar özel anlamını kaybederek bildiğimiz boşluk olacaktır:

kimlik=baris\ demiray

root @ linux # kimlik=baris\ demiray
root @ linux # echo $kimlik
baris demiray

Yukarıdaki karakterlerden ayrı olarak bir karakterden daha bahsetmek istiyorum. Amacı “saklamak” değil ancak gerçekten güzel işler yapıyor: ` (Ters tek tırnak) Bu karakterin görevi de çevrelediği komutun sonucundan standart çıktı oluşturmak. Örneğin ;

kim_var_kim_yok=`who`

kod parçasını yazarsak kim_var_kim_yok değişkeni o anda sistemde bulunan kullanıcıları içerecektir:

root @ linux # kim_var_kim_yok=`who`
root @ linux # echo $kim_var_kim_yok
root :0 Dec 23 18:10 (console)

Ya da

file `ls`

komutu ile bulunduğumuz dizindeki -görünür- tüm dosyaların türlerini öğrenebiliriz.

root @ linux # file `ls`
betik_ad: ASCII text

Son olarak bir ipucu.. Betiğinizin çalışacağı kabuğu belirtmek için kodun ilk satırı olarak aşağıdaki ifadeyi yazabilirsiniz:

#!/bin/bash

Şimdilik benden bu kadar. Kolay gelsin.

Barış Demiray

Kullandığınız kabuğu öğrenmek için ise SHELL çevresel kabuk değişkenini kullanabilirsiniz. Bunun için aşağıdaki komutu kullanabilirsiniz:

echo $SHELL

Artık Bash’e geçebiliriz sanırım.
Bash kelimesinin açılımı “Bourne-Again Shell”‘dir ve Bash Kabuğu Brian Fox tarafından yazılmıştır. Bash kabuğu sağladığı komut tamamlama gibi özelliklerle varsayılan kabuk haline gelmiştir, ayrıca POSIX uyumludur. Komut tamamlama özelliğini kullanmanız için komutun/dosyanın bir kaç karakterini yazmanız yeterlidir. TAB tuşuna basarak aradığınız komutu bulabilir ya da bir kaç tane varsa ardarda iki TAB ile tümünü listeleyebilirsiniz. Kabuk komutları kullandığı özelliklere göre çeşitli adlar alır. Bunlardan Tekli Komut (Simple Command) En temel komut şeklidir. Sadece bir komuttan ve -varsa- parametrelerinden oluşur. Örnek olarak;

cat /etc/lilo.conf

komutunu verebiliriz. Burada sadece /etc/lilo.conf dosyası ekrana basılacaktır. Komutlarımızda yönlendirme de kullanabiliriz. Bu işleme komut yönlendirme (piping) denir ve | (Boru karakteri – Pipeline) kullanılır. Mesela /bin dizininde kaç tane dosya olduğunu öğrenmek için ls ve wc komutlarını kullanabiliriz:

ls -l | wc -l

Burada ls ‘den alt alta dosya isimlerini sıralamasını istiyoruz ve bu komutun çıktısını wc (Word Count) komutuna yönlendirerek -l (line) parametresiyle kaç satır olduğunu öğreniyoruz.

Ayrıca bir komutun çıktısını bir dosyaya ya da standart çıktılara da yönlendirebilirsiniz. Bunun için ise <, >, >> gibi karakterler kullanılır. > karakteri ile bir akıma (stream) yönlendirmek için aşağıdaki formatta komutlar yazmalısınız:

Komut > Akım

Burada yönlendireceğiniz akım bir cihaz bile olabilir. Örnek olarak sistemde kimlerin olduğunu ve ne yaptıklarını yazdırmak için aşağıdaki komutu kullanabiliriz.

w > /dev/lp0

Dosyaya yönlendirme yaparken > karakteri kullanırsanız belirttiğiniz dosya varsa sıfırlanır, yoksa oluşturulur (C bilenler için: w modu gibi) . Eğer bir dosyanın içeriğini sıfırlamadan sonuna eklemek isterseniz >> karakterlerini kullanabilirsiniz. Örneğin aşağıdaki komut /var/log/messages dosyasının sonuna belirtilen mesajı ekler:

echo "Hata: Kullanıcı uyukluyor!" >> /var/log/messages

> karakteri ile standart çıktıları kullanmak isterseniz ise ya > olarak tek başına ya da 2> olarak standart akım numarasıyla beraber kullanabilirsiniz. Birincide standart çıktı, ikincide ise standart hata çıktısı (Hatırlatma: stdin 0, stdout 1, stderr 2 numaralı akımlardır) kullanılır. Ayrıca komutlarınızı bir akımdan almak için < karakterini kullanabilirsiniz. Örneğin

wc -l < /etc/passwd

komutu ile sistemde kayıtlı kaç kullanıcı olduğunu öğrenebilirsiniz.

Tekli komuttan ayrı olarak bir kaç komutu birleştirecek ve aralarındaki ilişkiyi tanımlayacak şekilde listeler (list) oluşturabilirsiniz. Listelerde komutlar çeşitli operatörlerle birleştirilirler. Örnek olarak ; karakteri ile birleştirdiğiniz komutlar sadece ardarda çalışırken && ya da || operatörleri ile biri diğerine bağlı olacak şekilde işlemler yapabilirsiniz. Ardarda çalışmaya bir kaç örnek;

clear; pwd; ls -la

Benim de alias olarak tanımladığım bir liste. Burada ekran temizlenir, çalışma dizini yazılır ve dosyalar listelenir.
echo Islem Tamam > Sonuc.txt && Sonuc.txt | lpr
Bu komutla bildiğimiz AND operatörünün görevi yapılır. Birinci komut başarılıysa ikinci komut çalıştırılır, başarısız ise ikinci çalıştırılmaz.
cd /Belgeler || mkdir /Belgeler
Burada ise önce /Belgeler dizinine geçilmeye çalışılıyor, başarılı olunamazsa (dizin yok) yaratılıyor.

Takma Ad (Alias): Takma adlar karmaşık bir komutu daha basit bir adla kullanmak ya da sadece bir komutun ismini değiştirmek için kullanılabilir. Örnek olarak listele diye bir komut yaratmak için aşağıdaki komutu kullanabilirsiniz.

alias listele="ls -la"

ya da çalışma dizininizi öğrenmek için aşağıdaki gibi bir komut olabilir:

alias nerdeyim="pwd"

Bir takma adı kaldırmak için unalias komutunu kullanabilirsiniz.

unalias nerdeyim

Ayrıca Bash kabuğunda dizin değiştirirken kolaylık sağlayacak bazı özellikler vardır. Örneğin ev dizininize geçmek için kısaca

cd ~

yazabilirsiniz. Bu işlem Tilda Expansion (Tilda Açılımı) adını alır ve Bash’e C Shell’den gelmiştir. Burada yapılan işlem ise ~ karakteri yerine HOME kabuk değişkeninin koyulmasıdır.

Bir diğer özellik ise bir önceki dizine

cd -

komutunu kullanarak erişebilmenizdir. Burada da OLDPWD adlı kabuk değişkeninden yararlanılır.

Bash kabuğunda bulunan bir başka özellik de Brace Expansion (Küme parantezi açılımı) ‘dir. Genel olarak “wildcard karakterleri”yle ilgili fikrinizin olduğunu sanıyorum. Yani

ls *.txt
ile .txt uzantılı tüm dosyaların listelenebildiğini ya da
rm a?b
ile 3 harfli ancak a ile başlayıp b ile sonlanan tüm dosyaların silinebildiğini biliyorsunuz.

Küme parantezleri kullanarak bir adım daha gibiyoruz ve olabilecek karakterleri ya da dizgi (string) leri de belirleyebiliyoruz. Şöyle ki;

file P{enguen, isibaligi}

ile Penguen ve Pisibaligi ( amma attım adında dosyalar varsa bunların türlerini öğrenebiliriz. Bu işlemde ise gördüğünüz gibi önek (prefix) veya sonek (suffix) leri belli olan ancak arada sadece istediğimiz dizgileri içeren dizgiler elde edip istediğimiz işlemde kullanabiliriz.

Kabuk Tanımları: Bash kabuğunda çeşitli özellikleri belirleyen tanımlar vardır. Bir kabuk tanımını set komutuyla aktif edebilir ya da kaldırabilirsiniz. Bazı kabuk tanımlarını aşağıya yazıyorum:

History: Kullanıcının komut tarihinin kaydını belirler ( kayıt ~/.bash_history dosyasındadır )
Noclobber: Bir dosyaya çıktı gönderilirken içeriğin sıfırlanmasını belirler
..

Örnek olarak komutlarınızın kaydedilmesini istemiyorsanız

set +o history

komutunu kullanabilirsiniz.

Kabuk Değişkenleri: Bir kabukta işlemlerde kullanılan genel değişkenler kabuk değişkenlerinde tutulur. Örneğin kabukta bir komut girdiğiniz zaman kabuk bu komutu/programı öntanımlı PATH değişkenindeki dizinlerde arayacaktır. Mesela daha önce bahsettiğimiz kabuk geçmişimizi tutan dosya HISTFILE adlı değişkende tutulur. Bir kabuk değişkeninin değerini ekrana yazdırmak için

echo $HISTFILE

ya da tüm değişkenleri ve değerlerini görmek için

printenv

komutunu kullanabilirsiniz. Bu gibi kabuk değişkenlerini, takma adları tanımlamak ya da sadece başlangıçta yapılacak işlemler için ~/.bashrc (ev dizininiz altında) dosyasını kullanabilirsiniz.

Kabuk değişkenleri ile yapabildiğiniz bir başka işlem de “prompt” u değiştirmek. Bunun için komut satırında ve komut bir alt satıra uzadığında kullanılan yazıları tutan kabuk değişkenleri PS1 ve PS2′yi kullanabiliriz. Burada kullanabileceğimiz bazı “escape sequence” lerden bazıları şunlar:

\u  :  Kullanıcı Adı
\h  :  Makine Adı
\t   :  Saat
\$  :  Kullanıcı simgesi ( Normal kullanıcıyken $, root olduğunuzda # değerini alır )
...

Şimdi bir örnekle PS1′i değiştirelim:

export PS1='\u@\h [\t]\$'

Bendeki sonuç :
root@linux [16:08:18]#

Şimdilik benden bu kadar. Burada kısaca bahsettiğim komut/özelliklerin herhangi birini incelerseniz sayfalarca yardım sayfası olduğunu görürsünüz. Bu yüzden meraklı arkadaşlara www.gnu.org/software/bash sayfasını tavsiye ediyorum. Kolay gelsin.

Barış Demiray

LINUX, sunucu ve istemci bilgisayarlarda çalışan türleriyle yaygın kullanılan bir işletim sistemi haline gelmiştir. Bu bölümde LINUX ‘un bazı özelliklerine göz atacağız:

1. BİRDEN ÇOK KULLANICI DESTEĞİ

İşletim sistemi aynı anda birçok kullanıcıya hizmet verir.

2.ÇOK GÖREVLİ

İşletim sistemi aynı anda birçok programı çalıştırır ve çok sayıda kullanıcıya hizmet verir.

İşletim sistemi üzerindeki programları korumalı (protected) moda çalışırlar. Bu moda uygulamalar birbirini etkilemeden sanki tek başına çalışıyormuş gibi bilgisayar üzerinde çalışırlar.

3. ÇOK İŞLEMCİ DESTEĞİ

Linux işletim sisteminin çok işlemci desteği vardır. 16 işlemciye kadar destekleyen Linux işletim sistemleri vardır.

4. TCP/IP DESTEĞİ

Linux, yerleşik TCP/IP desteği ile gelir ve Internet bağlantılarını kolayca yapar.

5. ORTAMLAR: KABUKLAR

Linux ‘te çekirdek üzerindeki işlemleri kabuk (shell) sağlar. Örneğin bir komut yazdığınızda bu komutu yorumlayan program kabuktur.

6. DOSYA YAPISI

Linux işletim sisteminde dosyalar, dizinler (directory) halinde düzenlenmiştir. Yaygın olarak kullanılan bu yapıda, programlar, sistem dosyaları ve kullanıcı dosyaları belli dizinler içinde yer alır. Kullanıcılar kendi dosyalarını istedikleri dizinleri açarak tutabilirler. Dosya sistemi aynı zamanda hiyerarşiktir. En tepede bir kök (root) nokta bulunur. Ardından dizinler dallanarak devam eder.

Microsoft® Sistem Mühendisi
Microsoft® Veri Tabanı Yöneticisi
Microsoft® Eğitmen
Bilgisayar Mühendisi
Webmaster
Ayhan ERGUN

LILO: Linux

Linux ‘un seçilmesiyle bilgisayarınıza Linux yüklenecektir.

Linux ‘e komut vermek için $ ya da # işareti ile başlayan bilgi istemi (prompt) kullanılır. Bu işaretin ardından komutlar yazılır ve ENTER tuşuna basılır.

# ls 's
gibi.

Linux, komut satırı arabiriminin yanı sıra, X Windows gibi grafik kullanıcı arabirimine sahiptir.

1. KOMUT SATIRI

Komut satırı (command line, command prompt), komutları yazabileceğiniz bir satırdır. Komutların yazılarak işletilmesini sağlar.

Komut satırı kullanımı eskiden beri (DOS, UNIX, vb) işletim sistemlerinde yaygın olarak kullanılan bir ortamdır. Günümüzde hemen her işletim sisteminde komut satırı aracılığıyla yazabileceğiniz komut (hala) vardır.

Genel olarak komut satırı formatı:

# komut parametreleri

Komutun ardından komutun parametreleri yazılır. Örneğin ls bir komut s ise bir parametredir.

# ls 's

Komut satırında, kullanılan komutların parametreleri hakkında geniş bilgi için man komutu kullanılır.

# man ls

Yukarıdaki komut sayesinde, ls komutuna ait yardım bilgileri alınır.

2. KDE

K Desktop Environment olarak bilinen bir masaüstü arabirim programıdır. KDE, Windows işletim sistemlerinde yer alan, masaüstü ve grafik arabirim olarak kullanılan programlara benzer.

KDE, sayesinde programları başlatmak, sistem ayarları yapmak ve diğer yönetim işlemlerinin çoğu grafik kullanıcı arabirimi sayesinde kolayca yapılır. KDE ‘nin diğer arabirim ortamları gibi ana amacı, kullanıcıların işletim sistemini kolayca (fare ile) kullanabilmelerini sağlamaktır. Grafik kullanıcı arabiriminin alternatifi komut satırıdır. Komut satırında işlem yapabilmek için komutları ve parametrelerini bilmek gerekir.

KDE pencereleri, Windows pencereleri gibi belli bir stile sahiptir.

3. GNOME

GNOME (GNU Network Object Model Environment) da KDE gibi kullanıcı arabirimi için araçlar (programlar) topluluğudur. GNOME arabiriminde bir panel ve ekranın alt tarafından da bir görev çubuğu vardır.

Pencere yönetiminde KDE kadar etkili olmayan GNOME özellikle dosya yöneticisi olarak kullanılır. Dosya yöneticileri, bildiğiniz gibi sistemin sabit diskinde yer alan dizin ve dosyaları görüntüler ve üzerinde çeşitli işlemlerin yapılmasını sağlar.

4. X WINDOWS

X WINDOWS SYSTEM X olarak bilinen diğer bir grafik kullanıcı arabirimi de özellikle Windows işletim sistemine benzer kullanıcı arabirimi sağlar.

X WINDOWS ortamında pencere, dosya ve program yöneticileri vardır. Pencere yöneticileri, komut satırı arabirimi yerine Linux işletim sistemi üzerinde pencereleri, menüleri kullanabilme olanağı sunar.

Dosya yöneticileri sistemin sabit diskinde yer alan dizin ve dosyaları yönetmek için grafik kullanıcı arabirimi sağlar.

5. LİNUX İÇİN PENCERE YÖNETİCİLERİ

Bazı pencere yöneticileri:

BlackBox
Enlightenment
AfterStep
WindowMaker
IceWm

Linux üzerinde kabuk (shell) işlemlerini açıklamak.

A. KABUK (SHELL)

Kabuk (shell) işlemleri denince genellikle UNIX işletim sistemlerinde bulunan gelişmiş komut satırı sistemi düşünülür. Onu da size şu size şekilde aktarmak istiyorum: Hepimiz DOS işletim sistemini duymuş ve kullanmışızdır. İşte DOS üzerinde DIR komutu ile yaptığımız işlemler, bu sözü edilen kabuk işlemlerine (komutlarına) karşılık gelmektedir.

Kabuk, Linux işletim sistemini komut satırı arabirimi ile yönetebileceğimiz bir arabirimdir. Kabuk, yalnızca verilen komutları yorumlamak ya da yerine getirmenin yanı sıra gelişmiş ve etkileşimli bir programlama ortamıdır. Yani kullanıcı ve uygulama yönetimi için çeşitli kabuk programları yazılabilir.

Genel olarak komut satırı formatı:

# komut parametreleri

Komutun ardından komutun parametreleri yazılır. Örneğin ls bir komut s ise bir parametredir.

# ls 's

Komut satırında, kullanılan komutların parametreleri hakkında geniş bilgi için man komutu kullanılır.

Linux ve UNIX işletim sistemleri üzerinde çalışmak üzere çok sayıda kabuk sistemi vardır. Programcı ya da sistem yöneticisi bunlardan istediğini seçebilir.

Microsoft® Sistem Mühendisi
Microsoft® Veri Tabanı Yöneticisi
Microsoft® Eğitmen
Bilgisayar Mühendisi
Webmaster
Ayhan ERGUN