Sistem-programlama

İçindekiler

• Sistem-programlama
  • İçindekiler
  • Bölüm-1 Giriş
    • neden Unix?
    • Unix versionları
    • Unix tabanlı bir sistemin katmanları
    • Unix hesapları
    • Shell(kabul) nedir?
    • Shell sistemi
  • Bölüm-2 Unix dosya sistemi
    • Çalışma dizini(working directory)
      
    • Başlangıç(ana) Dizini(home directory)
      
    • Unix Dosya Hiyerarşisi
    • Unix yolları (Unix paths)
    • Bazı standart dizinler
    • Dizin değiştirme (changing directories)
      
    • Dosya bilgisi (ls -al)
      
    • Dosya türleri
    • I-nodes
    • Dosya işlemleri
    • Dizin oluşturma ve silme
    • Links(bağlantılar) oluşturma
    • Dosya sahipliği
    • Dosya izinleri
    • Dosyanın içeriğine bakmak
    • Wildcards(joker karakterler)(Globbing)
    • Unix komutlarında yardım almak
    • Diğer dosya sistemleri
  • Bölüm-3 Text Editing
    • Neden vi?
    • cursor hareketi:
    • file operation:
    • arama:
  • Bölüm-4 Shell operatörleri
    • Üç standart dosya
    • stdout yönlendirme
    • stdin yönlendirme
    • Standart dosya tanımlayıcıları
    • Dosya tanımlayıcı oluşturma
    • Dosya Tanımlayıcıları ile Yönlendirme
    • Genel Giriş / Çıkış Yönlendirme
    • Ayrı Dosyaları Yeniden Yönlendirme
    • Tek Bir Dosyaya Yönlendirme.
    • Pipes ( veri yolu)
    • Süreçler(Processes)
    • Filtreler ( Filters)
    • Communication(iletişim) komutları
    • Processes(süreçler) komutları
    • Daha fazla dosya sistemi komutları
  • Bölüm-5 Regular Expressions(Düzenli ifadeler)
    • RE kullanan UNIX Programları
    • Temel ve Genişletilmiş RE'ler
    • egrep kullanımı
    • Metacharacters (Özel karakterler)
    • Bunlar ne anlama geliyor?
    • Egrep ile kelime arama
  • Bölüm-6 UNIX Kabuk Ortamları
    • Kabuk özellikleri
    • Kabuk Etkileşimi
    • Kabuk Programlama
    • Çeşitli Unix Kabukları
    • Kabuk Özellikleri.
    • Bourne Again SHell (bash)
    • Değişkenler
    • Kabuk Değişkenleri
    • Ortam Değişkenleri
    • Değişkenlere atama
    • Metin Tamamlama
    • Aliases (Takma adlar)
    • Komuta Tarihi(geçmişi)
    • Komut Satırında Düzenleme
    • Login(giriş) Script'leri
  • Bölüm-7 Temel Kabuk Betiği (basic shell script)
    • Komut dosyası yürütme (Script Execution)
  • Kabuk Değişkenleri
    • Dize(string) Değişkenleri
    • Dizi Değişkenleri
    • Dışa aktarılan değişkenler
    • Komut Satırı Argümanları
    • Çıktı ve alıntılama(quoting)
    • Dönüş değerleri(Return values)
    • Kullanıcı tanımlı değişkenler
    • Kullanıcı Girişi Okuma
    • Komut ve Aritmetik yerdeğiştirme
    • Tamsayılı(integer) Aritmetik
    • expr(ifade) komutu
    • Önceden Tanımlanmış Değişkenler
    • Argümanları komut dosyalarına geçirme
    • shift komutu
    • Null komutu
    • && ve || operatörleri
    • Koşullu İfadeler
    • İf deyimi
    • test komutu
    • Test komutuyla kullanılan Mantıksal Operatörler:
    • durum(case) açıklamaları
    • for döngüsü
    • While döngüsü
    • Until döngüsü
    • eval komutu
  • Bölüm-8 Gelişmiş Kabuk Betiği(Advanced Shell Scripting )
    • Fonksiyon oluşturma ve kullanma
    • Fonsiyona parametre verme
    • Değer döndürme(return)
    • Fonksiyonlar arasında veri paylaşımı
    • echo komutu
    • renkli metin gösterme
    • Komut dosyası yürütme(script execution)
  • Bölüm-9 Yazılım Geliştirme: g++ ve make
    • Yazılım geliştirme süreçi
    • Derleme şüreci
    • Temel g++ Örnekleri
    • g++ seçenekleri
    • g++ 'da tanımlar
    • Derlemede'de make kullanımı
    • make'in temek işlemleri
    • Temel Makefile Örnekleri
    • Bir Makefile'ın parçaları
    • Makrolar(macros) ve özel değişkenler
    • örneği basitleştirme
    • Make'i cağırmak (invoking make)
    • Diğer Makefile Notları ve Son ek(suffix) kuralları
    • En Basit Makefile Örneği
    • Diğer Faydalı Makefile İpuçları
  • Bölüm-10 Hata ayıklama (Debugging)
  • Bölüm-11 Dosya yönetimi (File Management)
    • Sistem Çağrıları
    • Program yürütmek
    • C'ye karşı C++
    • Arabelleksiz(unbeffered) G/Ç vs. Standart G/Ç
    • Temel Dosya G/Ç
    • open()
    • read() ve write()
    • read() örneği
    • write() örneği
    • stdin'i stdout'a kopyalamak
    • close()
    • lseek()
    • lseek() örnekler
  • Bölüm-12 Süreç Yönetimi (Process Management)
    • Unix'te süreçler
    • süreç belirtmek
    • Dosya Nesneleri ve Dosya Tanımlayıcıları
    • Ara belleğe alma(Buffering)
    • Dosya tanımlayıcıları
    • Süreç Yönetimi Sorunları
    • Unix'i başlatma
    • Csh komutları nasıl çalıştırır?
    • Süreç oluşturma
    • Fork : PID'ler ve PPID'ler
    • fork() başarısız olduğunda
    • fork () özellikleri
    • Program Yürütme (Executing a Program)
    • exec() özellikleri

Bölüm-1 Giriş

neden Unix?

modern bir işletim sistemi;

• stable : kararlı, kullanıcı ne kadar zorlasada hata yapmaya yönelik bundan etkilenmez.
• flexible : kullanıcı kendine çalışabilir bir alan oluşturabilir.
• configurable : yapılandırılabilir.
• allows multiple users and programs
• Birçok bilimsel ve endüstriyel ortamda kullanılır
• Çok sayıda özgür ve iyi yazılmış yazılım programı
• Açık kaynaklı işletim sistemi (OS)
• Mükemmel programlama ortamı
• Büyük ölçüde donanımdan bağımsız
• Standartlara dayalı
• İnternet sunucuları ve Unix’te çalışan servisler (Dünyadaki web sunucularının yaklaşık% 65’i Apache çalıştıran Linux / Unix makineleridir)

Unix versionları

iki ana gelişim kolu vardır. Two main threads of development:

• Berkeley software distribution (BSD) (http://www.bsd.org)
• Unix System Laboratories (http://www.unix.org)
  BSD: SunOS 4, Ultrix, BSDI, OS X, NetBSD, FreeBSD, OpenBSD, Linux (GNU)
  SYS V: System V (AT&T -> Novell -> SCO), Solaris (SunOS 5), HP-UX (Hewlett-Packard), AIX

Unix tabanlı bir sistemin katmanları

• işletim sistemi kernel modda çalışır, sistem çağrıları kernel moddadır.(sistem çağrısı: sistemin kaynağı kullanmak istemesi.)
• Standart Library, sistem çağrısı doğrudanda kullanılabilir, kütüphane çağrısı olarakta kullanılabilir.
• user mode , Bellek ve işletim sistemi üzerinde işlemler yapar.( kullanıcı seviyesinde printf("A") yazıldığında burda printf bir library function'dur, write(1,"A",1) şeklinde sistem çağrısı yapılır .)
• shell , kullanıcı komutlarını kabul eder ve bunları yerine getirmekle sorumludur.
• Unix sistemi ile birlikte dört yüzün üzerinde faydalı program veya araç sunulmaktadır. Bu yardımcı programlar (veya komutlar) dosya kopyalama, metin düzenleme, hesaplama yapma ve yazılım geliştirme gibi çeşitli görevleri destekler.

Unix hesapları

Bir Unix makinesine giriş yapmak o sistem için bir hesap gerektirir. Bir kullanıcı hesabı giriş ve şifre ile ilişkilendirilmiştir. “login” kullanıcı adınızdır, şifreniz siz yazarken gösterilmez.(login shell kullanıcıya hizmet veren ilk shell'dir)

Terminal bağlantısını il karşılayan süreç init sürecidir.Super user ıd'si ile koşar.Bu init süreci fork() sistem çağrısı ile süreç oluşturur süreç kendisini iki parçaya böler(parent,child). Sonra kullanıcıdan username girmesini ister username aldıktan sonra login, username için tanımlanmış şifreyi okur ama bu şifre de şifrelenmiştir bu yüzden girilenide şifreler ve karşılaştırır.Encryted halini okur ve karşılaştırır doğrulama yaptıkdan sonra home dizinine setlenir UID=100 ise UID=110 olur kullanıcıya verilecek hizmet hangisi ise ,hangi shell ise login shell icraya başlar kullanıcının çalışma ortamları açılır.

Shell(kabul) nedir?

Sadece giriş yaptığınızda bir Unix programı çalıştırılabilir. Bir komut yorumlayıcısıdır.  - UNIX yardımcı programlarına temel kullanıcı arabirimini sağlar. Bir programlama dilidir.   -kabuk komutlarından oluşan program kabuk komut dosyası olarak adlandırılır. Komutları bir dosyaya koyabilir ve çalıştırabilirsiniz

Shell sistemi

Giriş yaptıktan sonra, sistemle ilgili bazı bilgiler görüntülenecek ve ardından komutların girilebileceği bir kabuk istemi görüntülenecektir. Komut satırında yazdıklarımızı bir dosya içerisine yazarak hepsini icra edebiliriz bu dosya scriptfile dosyası olmuş olur. Dosya içersine yazdığımız kodların hangi bash'in koşacağını belirtmek gerekir.(ilk satırda)Buradaki syntax hangi shell'e göre yazılmıssa ona göre icra edilir.Size hizmet veren Shell ile script'in sytanx'ı aynıysa belirtmeye gerek yoktur. Dosyanın hangi shell ile koşacağını belirtmek için;

• #!/bin/bash

#!:Bir script dosyasının ilk satırı bu iki karakterle başlamalıdır. Shebang olarak ifade edilen bu karakterlerden hemen sonra, boşluk bırakmadan hangi bash programı kullanılacaksa o programın mutlak adresi yazılır.

/bin/bash: Burada belirtilmesi gereken diğer bir konu da sisteminizde hangi bash yazılımını kullandığınızdır. which bash komutunun sonucu size mutlak adresi söyleyecektir. #! ifadesinden sonra herhangi bir bash adresi yazmasanız da Script çalışabilir. Fakat sizin yazdığınız Script başka bir sistemde çalıştırılmak istendiğinde hata verme ihtimali vardır. Bu sebeple bash adresini yazmayı alışkanlık haline getirmek daha sağlıklı olacaktır.

• # ifadesiyle başlayan satırlar yorum satırlarıdır.

Bu satırları Bash yorum olarak farz edecek ve işleme almayacaktır. Dosyanın sahibi, oluşturulma tarihi ve oluşturulma maksadı vb. bilgilere burada yer verebilirsiniz.(not: bash=>komut dili yorumlayıcısı)

shell(kabuk), Unix sistemine komut göndermek için kullandığınız programdır. Bazı komutlar tek bir kelimedir.örneğin;

• who komutu

Bu komutla o anki kullancı detaylarını görebiliriz. aynı şekilde whoami komutu ile o anki kullanıcının adını görebiliriz w komutu ilede login olmuş kullanıcıları görebiliriz.

• date komutu

Bu komutla terminal ekranında sistem tarih ve saat bilgilerini görebiliriz.

• ls komutu

bulunduğumuz directory(dizin)'deki dosyaları listeler

• $> komut argüman1 argüman2

argümanlarla komuş işlemini değiştirebiliyoruz, daha detaylı listeleme gibi örneğin;

• ls -l
• ls -a
• ls -la
• ls -a;ls -l
• ls -F
• ls -al textfile1
• ls -al textfile1 textfile2
• ls -al directory

ls -l komutu ile dosların ve dizinlerin çok daha detaylı(izinler,kullanıcı ve grup
bilgileri, oluşturulma tarihi vb.) halini liste şeklinde görebiliriz. ls -a komutu gizli dosya ve dizinleri görebiliriz.
ls -la veya ls -al komutuylada ls -l ve ls -a komutlarını beraber kullanabiliriz.
ls -a;ls -l şeklinde de iki komut calıştırılabilir.
ls bin komutuda bin klasöründekileri listeler
ls textfile1 textfile2 yazarsakta bu dosyaları listeler.

Bir komut satırında komut icra ettiğinzde sistem komutu veya programı ise;
shell fork() ile iki süreçe ayrılır(parent ve child), child süreç exec() ile komutu icra eder bu sırada parent süreci bekler ve arka planda komut yürütülürse devam eder. shell kendi parça komutu ise herhangi bir child süreç oluşturmadan icra eder.(cd,export,echo... kendi komutlarını kendi icra eder yeni bir süreç oluşturmaz.

Komut satırı tepki vermiyorsa bir işlemi icra ediyor ve bir problem olmuş olabilir.

• ctrl + c

kesme gönderir, süreci keser.

• ctrl + z

sürecin icrasını durdurur.

• ps

ps komutu sistem üzerinde çalışan süreçleri görebilmenizi sağlar. Bunların arasından süreç kontrolü, süreç sorumlusu, süreç numarası, çalıştırılan komut, zaman, cpu, bellek gibi birçok bilgi görebilirsiniz.

• fg ve bg

bg komutu: Bu komut bütün Linux dağıtımlarında mevcut olmayabilir. Ancak genel görevi sistemde durmuş olan bir görevi yada processi arka planda devam ettirir.Bunun dışında sistem üzerinde şuanda koşmakta olan görevleri listeler.

fg komutu: Bu komut sistem üzerinde durmakta olan bir süreci yada görevi ön plana çekerek koşmasını sağlar. Her Shell kabuğu bu komutu koşmaz.

• ctrl + d ve exit

terminali kapatır(logout).

Bölüm-2 Unix dosya sistemi

Dosya sistemi, makinenizdeki fiziksel depolama(diskler) , diğer makinelerdeki depolama (NFS), giriş/çıkış cihazları ve benzeri durumlar için sizin arayüzünüzdür.
Unix'de herşey bir dosyadır.(porgramlar, text dosyaları, çevre birimleri, terminaller...)
Dizinler diğer dosyaları içeren(referanslara) bir dosyadır.
Unix'de sürücü harfleri yoktur.Dosya sistemi, depolama aygıtlarına mantıksal bir görünüm sağlar.

Çalışma dizini(working directory)

Çalışma dizini: dosya sisteminin geçerli konumu yani sistemdeki konumunuz.

• pwd komutu
  

pwd (print working directory) komutu çalışma dizininizin mutlak yolunu (daha sonra) verir. Başka bir dizin belirtmediğiniz sürece, bir komut çalışma dizini içerisinde çalışmak istediğinizi varsayar.

Başlangıç(ana) Dizini(home directory)

Ana dizin: kişisel kullanıcı alanı. Oturum açıldığında, çalışma dizininiz ana dizininize ayarlanacaktır. Ana dizininize giden yol, ~ (tilde) sembolüyle belirtilebilir. Kullanıcı1'in ana dizini ~ kullanıcı1 şeklinde belirtilebilir. Başka bir dizindeysek cd ~/ komutunu vererek ana dizine gidebiliriz.

Unix Dosya Hiyerarşisi

Kök dizini(Root directory) : / , bütün dosyalar root'a bağlanır. Dizinler düz dosyalar veya başka dizinler içerebilir. Sonuç, dosya sistemi bir ağaç yapısıdır. Unix, herhangi özel bir dosya adı uzantısını tanımıyor.

Unix yolları (Unix paths)

Dizinler / ile ayrılır. Absolute path(tam yol): Root(kök)'dan başlayarak ağacın takip edildiği yoldur.Örneğin:
/home/user1/textfile
~user1/textfile
~/textfile
Absolute path kullanıcı dizini referans alınarak bildirim yapar.

Relative path(göreceli yol): çalışma dizininden başlar.

• .. bir üst dizindir(parent)
• . çalışma dizinidir(yani dizinin kendisini ifade eder.

textfile
bil318/lec1.txt
çalışma dizinini referans alma : ./../textfile
parent'ı referans alma : ../textfile

Bazı standart dizinler

Bu dizinler / yani root altındadır.
/ bin - standart komutlar ve yardımcı programlar; yürütülebilir.Kullanıcının koşabildiği tüm programlar bu dizindedir.
/ sbin - root tarafından icra edilebilen programlar, sistem komutları ve yardımcı programları (önyükleme için gerekli) bulunur
/ dev - blok ve karakter aygıtı dizini.Dosya linleri yazıcı,cdrom sürücü tanımlamaları bu dizin altındadır.Terminale tty komutunu verirsek bizim kullandığımız terminal device numarasını verir
/ etc - ana bilgisayara özgü yapılandırma; host hizmetleri
/ home - kullanıcıların ana dizinleri.Kullanıcının login ismiyle dizinler açılır (home/hakan)
/ lib - çeşitli diller için kütüphane dizini.(.so unix dosyaları , .dll windows dosyaları)
/ tmp - geçici dosyalar.(veritabanında taplo update ,update set işlemlerinde tmp kullanılır)
/ usr - kullanıcı yardımcı programları ve uygulamaları; / Usr / local /. Kurulumda değil daha sonra sisteme dahil olan programlardır olsada olur olmasada.
/ var - çeşitli log işlemleri,değişken olan sistem dosyaları için bu dizin kullanılır (günlükler, makaralar, e-posta)

Dizin değiştirme (changing directories)

• cd komutu
  

Çalışma dizinini değiştirmek için kullanılır. cd <dizin yolu> şeklinde kullanılır. Absolute veya relative yollar kullanılabilir.
Herhangi bir argüman verilmezse cd ~ komutu verilmiş varsayılır ve home dizinine gidilir.Eğer ..(ikinokta) parametresi verilirse bir üst dizin .(teknokta) parametresi verilirse de mevcut çalışma dizinine gidilir.
cd /home/user1
cd ../../user1

Dosya bilgisi (ls -al)

Dosya türleri

Plain (düz) (-): çoğu dosya bu türdedir, ikili(binary) veya metin dosyaları.
Directory (dizin) (d): bir dosya kümesini gösterir
Symbolic (sembolik) link (l): Başka bir dosya veya dizine işaretçi(pointer).
Özel dosyalar;
       Karakter cihazı (c): klavye, yazıcı, joystick.
       Block cihazı (b): disk, CD-ROM.
İletişim dosyaları;
       FIFO (p): geçici bir depolama cihazı (sıra).
       Soket (ler): soket dosyaları

• ls -F komutu

ls -F komutu bir dosyanın türünün ne olduğunu gösterir ve dosyanın adının sonuna özel bir karakter yazdırılır.

(boş): Normal dosya
*:   Yürütülebilir program veya komut dosyası
/:   Dizin
@ :   Sembolik bağlantı
| :   FIFO (named pipe) =:   Soket

-ls -i komutu

ls -i komutu her dosya için i-node numarasını yazdırır.

I-nodes

Dosya sistemindeki her nesne için yönetim bilgisidir. İnode'lar diskte bulunur ve isimleri yoktur. Bunun yerine, inode dizisindeki pozisyonlarını belirten endekslere (sayılara) sahiptirler.
Her inode genellikle şunları içerir:

• Varsa, öğenin içeriğinin diskteki konumu
• Öğenin türü (örneğin, dosya, dizin, sembolik bağlantı)
• Varsa, öğenin bayt cinsinden boyutu
• Dosyanın inode'unun en son değiştirildiği saat (ctime)
• Dosyanın içeriğinin en son değiştirildiği saat (saat)
• Dosyanın en son erişildiği zaman (atime), okuma, yürütme vb.
• Referans sayısı: Dosyanın sahip olduğu adların sayısı
• Dosyanın sahibi (bir UID)
• Dosyanın grubu (bir GID)
• Dosyanın mod bitleri (ayrıca dosya izinleri veya izin bitleri olarak da bilinir)

(inode yapısı cizilebilir)

Dosya işlemleri

• touch komutu

touch komutu ile dosya oluşturulur veya oluşturulmuş dosyanın son değiştirilme tarihi değiştirilir.

• mv

mv komutunu bu şekilde kullanırsak file1 dosyasının adını file2 olarak değiştirmiş oluruz yani dosyaları yeniden adlandırmada kullanılabilir.

• mv

mv komutunun ikinci parametresine dizin verirsek , birinci parametredeki dosyayı bu dizine taşır.

• mv <dir/file2>

mv komutunu bu şekilde de kullanabilir. Bu şekilde kullanıldığı zaman dizine dosyayı taşır aynı zaman dosyanın adını file2 olarak değiştirir.

• cp [||<dir/file2>] komutu

cp komutu dosya kopyalama işlemlerinde kullanılır kopyalanır ad değiştirilir veya ikisini birden yapar. cp a deneme/b komutunu verirsek a dosyasını deneme dizininde b dosyası olusturarak bunu içine kopyalar.

• rm [-i] <files(s)>

dosya veya dosya listesini siler. link varsa oda eksilir ,dizin ile bağlantısı kopar dizinde o dosyanın yerine null atanır.Dosya silme işlemlerinde çoğu zaman parametre vermeye gerek kalmaz rm dosya_adı yazılarak dosya silinebilir.

Dizin oluşturma ve silme

• mkdir <directory_name> komutu

Geçerli dizinin altında yeni bir dizin oluşturur.

• rmdir <directory_name> komutu

sadece boş dizini silebilir.

• rm -r <directory_name> komutu

Dizini ve alt dizinler de dahil olmak üzere içeriğinin tümünü yinelemeli olarak kaldırır. r parametresi recursive anlamına gelmektedir silerken altdan yukarıya doğru siler.

Links(bağlantılar) oluşturma

• ln –s <existing_file> <link_name> komutu

sembolik bir bağ (-s) oluşturur.
link_name, başka bir dizinde veya başka bir fiziksel makinede bulunabilecek varolan dosyanın bir göstergesidir.
hard link(sert bir bağlantı) oluşturmaktan kaçınılmalıdır,aynı cihazın aynı fiziksel bölümünde olmalıdır; link_name, mevcut dosya için başka bir addır.

ln -s fileA fileB yazarsak, oluşmamış fileB dosyasına sembolik link oluşturuluyor ve fileA'yı işaret ediyor.Oluşturulan bu fileB'ye farklı bir inode atanıyor fakat yapı gereği fileA'ı işaret ediyor.Eğer fileA'da içerik değişirse fileB'de de bu değişiklik görülür. fileB yani sembolik link olam dosyaya birşey yazılırsa fileA'da da içerik değişir çünkü fileB, fileA'nın bölgesini işaret ediyor.

ln fileC fileD yazarsak, fileD yapı gereği fileC'yi işaret etmek yerine direk fileC'dir yani inode'ları aynıdır bu hard link'tir. fileC'nin link sayısı bir artar bu hard link'lerde böyledir sembolik link'lerde bu artma yoktur.

Dosya sahipliği

Her dosyanın tek bir sahibi var.
chown komutu sahibini değiştirmek için kullanılabilir; genellikle sadece root bu komutu kullanabilir.
Her dosya aynı zamanda tek bir gruba aittir.
Gruplar herkesten farklı izinlere sahip olabilir.

Dosya izinleri

Dosyalara veya dizinlere erişime izin vermek veya vermemek için kullanılan izinler aşağıdaki gibidir;
Üç tür izin vardır :

• Oku (r)
• Yaz (w)
• Yürüt (x) (örneğin dosyalarda arama yapmak)

İzinler üç düzeyde verilebilir:

• Kullanıcı (u)

• Grup (g)

• Diğer (o)

• chmod <file(s)> komutu

  

chmod komutu dosya sahibini(owner) değiştirmede kullanılır.Genellikle sadece root bu komutu kullanabilir.Yukarıda görüldüğü gibi chmod komutu iki farklı şekilde kullanılır;
Daha çok kullanılan sayılar kullanılarak verilen izinlerdir sayılar belirli bir düzene göre verilebilir;

• r=4 w=2 x=1

chmod 200 a.txt yazarsak a dosyasında kullanıcıya sadece yazma hakkı verilir, grup ve diğer(herkese) herhangi bir yetki verilmez.
chmod 635 a.txt yazarsak kullanıcıya okuma ve yazma, gruplara yazma ve calıstırma, herkese okuma ve calıstırma izni vermiş oluruz.
ikinci kullanım şeklinde grup için g,kullanıcı için u, digerleri icin o harfleri kullanılır.
chmod g-r a.txt yazarsak gruplardan okuma yetkisini alır veya benzer şekilde g+rw yazarsak gruplara okuma yazma yetkisi veririz.

• chgrp komutu

chgrp asd a.txt yazarak a.txt dosyasının grubunu değiştirerek asd grubuna alabiliriz.

• chown komutu

chown hkn a.txt yazarak a.txt dosyasını başka bir kullanıcıdan alıp hkn kullanıcısına verebiliriz.

Dosyanın içeriğine bakmak

• cat komutu

cat komutunu dosyaların içeriğine bakmak veya içeriğini değiştirmek için kullanılır.
cat textfile1 textfile2 şeklinde kullanırsak önce textfile1'in içeriği hemen ardından textfile2'nin içeriğini terminalde görebiliriz.Eğer dosyanın içeriğini değiştirmek istersek cat >> textfile1 yazarak terminalde textfile1'in içine gidilir ve dosyaya yazma yapılabilir cıkmak için ctrl+c kullanılır,ama burada dikkat edilmesi gereken şey dosyanın üzerine yazma yapılır yani önceki içerik kaybolur.

• more komutu

Uzun bir dosyayı açmak istediğiniz zaman bütün yazılar birden önünüze açılır ve öününzde son satırların olduğu kısımları görürsünüz. Bu gibi durumlarda "more" kullanarak önce ekrana sığabilecek kadar veriyi ekrana yazdırıp daha sonra ENTER ile birer birer satır atlatma yapabilirsiniz.

Herhangi bir satır numarasından itibaren veri çekme işlemi;
more +satir_numarası dosya_adi şeklinde olmaktadır.

Belirli bir kelime ile başlayan satırı içeren kısımdan itibaren veri çekme işlemi;
more +/"kelime" dosya_adi şeklinde olmaktadır.

• less komutu

"less" komutu verileri geriye doğru ilerleterek işleme alır. Öyle ki, bir dosyayı açmaya çalıştığı zaman dosyanın tamamını açıp sonra işlemlere geçmez, herhangi bir text editör programı(mesela vi) dosyayı açaçağı zaman dosyanın hepsini yükledikten sonra açma işlemi yapar, fakat "less" komutu bunun aksine dosyayı tamamiyle ele almaz sadece istenilen, belirtilen kısımlarını işleme alır. Bu yüzden "less" diğer kelime işlemcilerden daha hızlıdır. Performans açısından daha iyidir. Kullanımı "Vi" programına benzemektedir. "more" ile kıyaslandığında "less" daha iyidir.

Komutların kullanımı, "less dosya_adi" şeklinde dosya açıladıktan sonra da herhangi bir komut harfine tıklayarak kullanabilirsiniz. Mesela dosya açıldıktan sonra "q" harfine basarsanız çıkış yapar, "-N" ile satırları numaraları ile gösterir, "& /aranan_kelime" ile aradığınız kelimeleri satırları ile beraber bulur gösterir, "G" ile sayfa sonuna gider, "g" ile sayfa başına gider, "53g" ile 53. satıra gider vb.
"less" ile dosyalar üzerinde herhangi bir düzenleme yapamazsınız. "v" tuşuna basarsanız varsayılan olarak ayarlı olan text editör programınız ile dosya, düzenlenmek üzere açılacaktır.

Wildcards(joker karakterler)(Globbing)

Linux işletim sistemi, yazdığınız komutları daha kısa ve işlevsel hale getiren joker karakterleri(wildcards) desteklemektedir. Wildcard' lar, size, nispeten daha kompleks işlemler yaparken, kolaylık sağlar. Örnek olarak bir dizin altında bulunan .cfg uzantılı dosyaları başka bir dizine kopyalamak istediğimizi düşünelim. Bunun için normal şartlar altında, ya bir görsel arayüz programı kullanarak, ya da tüm dosyaları tek tek kopyala komutu kullanarak, kaynak dosyaları başka bir dizine yerleştirebiliriz. Ancak wildcards' lar sayesinde aşağıdaki gibi, çok daha kısa bir söz dizimi ile bu işlemi kolaylıkla gerçekleştirebiliriz.

cp ~/workspace/*.cfg ~/workspace2

• *Bütün karakterler, çoğul seçim
• ? Herhangi bir karakter, tekil seçim
• [karakterler] Karakter kümesi, veya operatörü ile çalışır.
• [!karakterler] Karakter kümesi haricinde demektir.
• [[:sınıf:]] Belirtilen bir karakter sınıfına ait olan eşleşme. Karakter sınıfları bir sonraki tabloda anlatılmaktadır.

örnekler;

*.cfg -> Sonu .cfg ile biten dosyalar

A*.cfg -> A ile başlayan Sonu .cfg ile biten dosyalar

???.txt-> 3 harfli olup sonu .txt ile biten dosyalar

[abc]* veya [a-c]-> a, b ya da c ile başlayan dosyalar,[a-c] demek a'dan c'ye kadar olan harfleri temsil etmekdir veya [a-cn-z] ifadesi ile a'dan c'ye ve n'den z'ye kadar olan karakterleri temsil ederiz.

Version.[:digit:] [:digit:] -> Version.rakam rakam formatındaki dosyalar

*[[:upper:]] -> Sonu buyuk harfli biten dosyalar

Unix komutlarında yardım almak

• man <command_name> komutu

Bu komut ile herhangi bir komut hakkında detaylı bir dökümana erişebiliyoruz. Komutun tüm belgelerini gösterir.

• apropos komutu

Belirtilen anahtar kelimeyle birlikte komutların tümünü açıklamalarında gösterir. apropos yerine man -k 'da kullanılabilir.

• type

komutun sistem yolunu verir.

Diğer dosya sistemleri

SunOS'ta 3 farklı dosya sistemi vardır

• Disk tabanlı
• Dağıtılmış
• Sözde(pseudo)

Disk tabanlı dosya sistemleri sabit diskler, CDROM'lar, disketler içerir.
Dağıtılmış dosya sistemleri ağ kaynaklarını yönetir.
Sözde dosya sistemleri bellek tabanlıdır ve disk alanı kullanmaz

Bölüm-3 Text Editing

Şimdiye kadar dosya sistemindeki dosyaları değiştirdik (cp, mv, rm, ln) ve içeriğini (cat, daha az) görüntüledik.
Dosyaların içeriğini nasıl düzenlersiniz? Unix editörleri düz ASCII metin dosyalarıyla çalışır: vi, emacs, pico.

Neden vi?

Kullanılabilirlik

• Herhangi bir Unix / Linux sisteminde çalışabilir.

Komutlar anahtarlardır.

• Uzaktan oturum açma yoluyla erişilebilir (ör. Ssh).
• Fare kullanımını önler.

Basit ve güçlü bir metin editörü.

viden baska emacs,pico gibi editörlerde vardır vi uzakdan erişim ile teriminale bağlanabilir.

• vi yazarak editörü açabiliriz
• :help yazarak vi editörü hakkında detaylı bir bilgiye ulaşabiliriz
• :q! ile çıkabiliriz
• vi deneme.txt diyerek bir deneme dosyasını editörde açabiliriz.
  

iki modu vardır.

• 1. command modu: komutlar icra edilir. ilk açıldığında bu moddadır
• 2. insert modu: dosya iceriği düzenlemesi yapılır. esc'ye basınca komut moduna geceriz.

üç komut modu var biri normal, ikincisi :'dan sonraki komutu, üçüncüsü i modu yani yazma modu

• escape tuşu ile geri gelebiliriz

insert modunda(i'e basınca) backspace ile silebiliriz ama insert modunun dışında x ile veya shift-x ilede silebiliriz. shift+c alt satırla üst satırı birleştirir

cursor hareketi:

yön tuşları veya h sol j asağı k yukarı l ise sağ yönde hareket etmemizi sağlar
4j yazınca 4 satır aşağıya gider
CTRL-F sonraki sayfa
u (undo) yazarsak son değişikliği iptal eder
:7 yazarsak direk 7.satıra gider
x cursorun üzerinde olduğu karekteri siler.(imlecin üzerindeki karekteri)
dd , D yazarsak cursorun üzerinde olduğu satırı siler
cc ,C cursor üzerinde oldugu kelimeyi değiştirir
rx karakteri x ile yer değiştirir
yy bir satırın kopyasını alır
p yapıstırır
j üzerinde bulundugu satır ve alt satırı birleştirir.
/bil yazarsak ilk bil yazan yeri bulur //bil ikinci bil yazan yeri bulur
?bil yazarsak bu sefer yukarıya doğru arar

file operation:

wq write quit (kaydeder ve çıkar)
w sadece write
w filename dosyaya yaz
q! değişiklik olsa bile değiştirmeden çıkabilirz
e filename editöre dosyayı yükle
r filename cursor'ın oldugu satırdan itibaren dosyanın oldugu satıra ekle
en son :W yazarsak dosyayı yazar :w! yazarsak üzerine yazar
:wq yazıp yazıp cık denebilir eğer dosyada değişiklik yapıp kaydetmeden cıkmak istiyorsak :q! yazmalıyız :q ile cıkamayız
daha fazla detay için :help dışında http://www.belgeler.org/lis/archive-tlkg-lis-7.2.html kullanılabilir.

arama:

/kelime ileri doğru ara
?kelime geri doğru ara
n son aranan tekrar
N son aranan tersi yönde tekrar

Bölüm-4 Shell operatörleri

Üç standart dosya

• stdin , standart giriş

giriş karakter akışı, varsayılan giriş klavye'dir.

• stdout , standart çıkış

çıkış karakter akışı, varsayılan çıkış terminaldir.

• stderr , standart hata(error)

hata mesajlarını alır, varsayılan olarak terminal ayarlıdır.

stdout yönlendirme

stdout'u terminale yönlendirmek yerine bir programı bir dosyaya yazmasını söyleyebilirsiniz.
>filename : stdout'u bir dosyaya yönlendirir.Eğer dosya yoksa dosyayı oluşturur.Eğer dosya varsa dosyayı sıfırlar.
>>filename : varolan bir dosyaya stdout ekler. örneğin;
man ls > ls_help.txt (man ls komutunun cıktısını terminale yazdırmak yerine belirlenen dosyaya yazar)
echo $PWD > current_directory
cat file1 >> file2 (file1 dosyasını file2ye yazar ama file2deki mevcut bilgiyi korur üstüne yazmaz dosyanın devamına yazar.)

stdin yönlendirme

stdin'in terminalden okumak yerine bir dosyadan okumasını söyleyebiliriz.
<filename : stdin'i mevcut bir dosyaya yönlendirir.
<<kelime : takip eden satırlandarn sadece kelime'yi içeren satırada kadar, stdin'i yönlendirir. örneğin;
mail [email protected] < message.txt
at 3am < cmds or at 0945 < cmds
sort < friends > sorted_friends
cat << end (end kelimesi girilip stdin okuyana kadar yönlendirme yapılır, end kelimesi girildiği an yönlendirme biter ve yazılanları ekrana basar)

Standart dosya tanımlayıcıları

Bir dosya bir tanımlayıcı ile ilişkilendirilebilir.
Kabuk(shell), sırasıyla her bir komut için üç standart dosyayı üç standart dosya tanımlayıcısı ile ilişkilendirir.

• 0 : standard input (STDIN)
• 1 : standard output (STDOUT)
• 2 : standard error (STDERR)

Standart tanımlayıcılar, kullanıcının terminali ile ilişkilendirilir, ancak başka dosyalara da yönlendirilebilirler.

Dosya tanımlayıcı oluşturma

Yazmak üzere bir dosyayı açmak için bunlardan birini kullanın.
exec n> filename (dosyayı yazma işlemi için açıyoruz , yazma işlemi kullanıldığında n dosya tanımlayıcıyı oluşturuyor.
exec n>> filename (sonundan itibaren yazmak üzere n oluşturuluyor)
n bir tamsayıdır ve dosya adı, yazmak için açılan dosyanın adıdır.
İlk form, eğer böyle bir dosya varsa, belirtilen dosyanın üzerine yazar.
İkinci form belirtilen dosya adına eklenir.
Bir dosyayı okumak üzere açmak için
exec n<filename (okuma işlemi için açılıyor, okumak için n'nin file nesnesi oluşturuluyor)
Hem okuma hem de yazma için bir dosyayı açmak için
exec n<> filename (n adında dosya tanımlayıcısı oluşturuluru)

Dosya Tanımlayıcıları ile Yönlendirme

Standart çıktıyı, dosya tanıtıcısı n ile ilişkilendirilmiş dosyaya yönlendirmek için,
komut>& n (n bağlı olduğu dosyaya yazıyor, terminalde yazılacak veri n'nin bağlı olduğu dosyaya yazılır)
Standart girişi, dosya tanımlayıcısı n ile ilişkilendirilmiş dosyadan yönlendirmek için,
komut<&n (komut bilmez veriyi nereden aldığını)
exec n> & -: çıktı dosyası tanımlayıcısı n kapalı.     exec 1>&- , exec>&-: standart çıkış kapalı. exec n <& -: giriş dosyası tanımlayıcısı n kapalı.     exec 0<&- , exec<&-: standart giriş kapalı.

Bir dosyaya yazma;
exec 4> dosya ("dosya" yı açın, fd 4 atayın.)
ls> & 4 (ls çıktısını "dosya" ya yaz)

Bir dosyadan okuma
exec 5 <dosya ("dosya" yı açın, fd 4 atayın.)
wc <& 5 ("dosya" dan giriş oku)

Bir dosyada belirtilen bir yere yazma
echo 1234567890 > dosya ("dosya" ya dize yaz.)
exec 3<> dosya ("dosya" yı açın, ona fd 3'ü atayın.)
read -n 4 <&3 ( Sadece 4 karakter oku.)
echo -n . >&3 (Oraya bir ondalık işareti yazın.)
exec 3>&- (fd 3'ü kapatın.)
cat dosya ( ==> 1234.67890)

Genel Giriş / Çıkış Yönlendirme

Standart çıkış veya giriş yönlendirmesi açıkça aşağıdaki genel şekilde belirtilir.

• komut 1>dosya
• komut 1>>dosya
• komut 0<dosya

STDOUT ve STDERR dosyalarını ayrı ayrı dosyalara yönlendirmek için kullanılan temel sözdizimi;

• komut 1>dosyaA 2>dosyaB
  Belirtilen komutun STDOUT dosyası A dosyasına yönlendirilir ve STDERR (hata mesajları) fileB dosyasına yönlendirilir.

Ayrı Dosyaları Yeniden Yönlendirme

• komut >> dosyaA 2> dosyaB
• komut > fileA 2 >> fileB
• komut >> dosyaA 2 >> dosyaB

İlk form STDOUT dosyasını fileA'ya ekler ve STDERR'yi fileB'ye yönlendirir.
İkinci form STDOUT'u fileA'ya yönlendirir ve STDERR'yi fileB'ye ekler.
Üçüncü form STDOUT dosyasını fileA'ya ekler ve STDERR'yi fileB'ye ekler.

Tek Bir Dosyaya Yönlendirme.

Aynı dosyaya STDOUT ve STDERR yönlendirmek veya eklemek için temel sözdizimi;
komut >file2>&1 veya command &> file
komut >>file2>&1
STDOUT (dosya tanımlayıcısı 1) ve STDERR (dosya tanımlayıcısı 2) belirtilen dosyaya yönlendirilir veya eklenir.
komut 2>&1>>file (bunu yukarıdakiyle karşılaştır).

m> & n: dosya tanımlayıcıları m, n'ye yönlendirilir.
  >&n: standart çıkışı n dosya tanımlayıcısına yönlendirilir Örnek;
rm -rf /tmp/my_tmp_dir > /dev/null 2>&1 rdate ntp.nasa.gov >> /var/log/rdate.log 2>&1 if [ ! -f $FILE ]; then echo "$FILE is not a file" >&2; fi

Pipes ( veri yolu)

Pipe (|): Bir komutun stdout'unu diğerinin stdinine bağlar.
Örnekler;

ls –la | less
ls –al | wc
ls-al | sort +4r
cat file | wc
man bash | grep "history"
ps aux | grep user1 | wc –l

Süreçler(Processes)

Bir seferde birden fazla program çalıştırmak için;.
Noktalı virgülle (;) ayrı komutlar yazılabilir

• date; who (sıralı bir şekilde koşar)

Aynı anda birden fazla program çalıştırmak için;
Komutun sonunda ve işaretini (&) kullanın.
ls -al & wc * (paralel bir şekilde koşar hangisinin nezaman biteceği kesin değildir.)

Filtreler ( Filters)

Filtre,girişi alan ve bir şekilde dönüştüren bir programdır.

• wc komutu
  wc , satır / sözcük / karakter sayısı verir
  

• grep komutu
  grep , belirli bir örneğe sahip hatları arar
  grep (örnek RE olabilir)
  

• sort komutu
  sort , satırları alfabetik veya sayısal olarak sıralar
  sort -r: normal sıralama düzenini tersine çevirir
  sort -n: sayısal sırada sıralar
  sort + 2n: ikinci sütundaki öğeleri sıralar
  

• cut komutu
  cut - stdout'a gönderilecek her satırın parçalarını seçer.
  cut -c1-5: her satırın ilk 5 karakterini seç
  cut -c1,5: her satırın ilk ve beşinci karakterlerini seç
  cut -d: -f1,3 /etc/passwd: kullanıcı adlarını ID'leriyle eşleştir
  

• head komutu
  head , dosyaların ilk birkaç satırını gösterir.
  head -n <dosyaadı> , n: bir tam sayı
  

• tail komutu
  tail , dosyanın son bölümünü görüntüler
  tail -n <dosyaadı> : son n satırı .
  tail + n <dosyaadı>: n. satırdan sonraki satırlar
  

• diff komutu
  diff ,farklı olan tüm satırları gösterir.
  

• cmp komutu
  cmp , iki dosyanın farklı olduğu ilk yeri bul
  <diff / cmp>
  

• od komutu
  od , Bir dosyanın içeriğini sekizlik(oktal) gösterimini gösterir.
  Örneğin. od –c: tüm baytların görsel gösterimi
  

• ls -lt komutu
  ls –lt , zaman sırasına göre dosya listesi
  

• crypt komutu
  crypt , bir dosyayı kodlama veya kod çözme
  Örneğin. şifreli anahtar <clear.file> encrypted.file
  

• tr komutu
  tr , girişindeki karakterleri çevirir.
  tr "[: lower:]" "[: upper:]" < (dosyadaki küçük harfleri büyük harflere çevirir.)
  

• uniq komutu
  uniq , bir dosyadaki tekrarlanan satırları rapor eder veya filtreler.
  uniq –d , 'da tekrarlanan satırları görüntüleme
  uniq –u , da tekrarlanmayan ekran satırları görüntüleme
  uniq –c , 'daki tekrarlanan satırları tekrar sayılarıyla birlikte görüntüleme
  

• pr komutu
  pr , dosyaları çeşitli şekillerde yazdırır. ls -a | pr -n -h $ (pwd) , geçerli dizindeki tüm dosyaların numaralandırılmış bir listesini yazdırır.

Aşağıdaki komut ne yapar? cat * | tr -sc A-Za-z '\012' | sort | uniq –c | sort –n | tail | pr -5 –t

Communication(iletişim) komutları

• talk komutu
  talk ,sisteme kayitli olan baska bir kullanici ile etkileşimli sohbet
  Örneğin. talk hakan pts/2
  

• write komutu
  write, başka bir kullanıcıya mesaj gönderme
  Örneğin. write hakan pts/2
  mesg [n | y] : mesajlara izin ver / reddet
  

• mail, pine : text tabanlı e-posta programı
  

• ftp, sftp : metin tabanlı FTP programı
  

• telnet, ssh : doğrudan diğer makinelere bağlanmak için kullanılır
  

• lynx : metin tabanlı web tarayıcısı
  

Processes(süreçler) komutları

• ps komutu
  ps , mevcut süreçleri listeler
  

• top komutu
  top , sistemin süreçler tarafından kullanımının dinamik gösterimini yapar

• kill komutu
  kill , belirlenen bir süreci sonlandır (varsayılan: SIGTERM)
  kill –9 (SIGKILL sinyali gönderiliyor)
  

• time komutu
  time, bir süreç için zamanlama bilgisini tutar ve gösterir.
  time ls (real / user / sys zamanı gösteriliyor).
  

• wait komutu
  wait , & ile başlayan tüm işlemleri bekliyor.(belli bir işlemi bekleme)
  

• nohup komutu
  nohup , oturumu kapattıktan sonra komutu çalıştırmaya devam ettirir.

• nice komutu
  nice , komutu düşük öncelikle çalıştırmaya devam et.
  nohup / nice &

Daha fazla dosya sistemi komutları

• file komutu
  file , dosya türünü belirler(gösterir)
  file /bin/ed
  /bin/ed: saf çalıştırılabilir
  

Çalıştırılabilir binary bir program, başında "sihirli sayı" ile işaretlenmiştir.
od / bin / ed
0000000 077505 046106 000402 000400 000000

• du komutu
  du , ne kadar disk alanı kullandığını gösterir.
  du <dosya / dizin> (disk blokları cinsinden)
  

• df komutu df , bağlı dosya alt sistemlerindeki alanı gösterir.
  df –k (disk blokları cinsinden) (bir blok = 512 veya 1024 bayt)
  

Bölüm-5 Regular Expressions(Düzenli ifadeler)

RE kullanan UNIX Programları

• grep (dosya içinde ara).
• egrep (genişletilmiş RE'ler ile grep).
• vi / emacs (metin editörleri).
• ex (çizgi(line) editörü).
• sed (akış(stream) editörü).
• awk (örüntü(pattern) tarama dili).
• perl (betik dili).

Temel ve Genişletilmiş RE'ler

Temel düzenli ifadelerde;
meta karakterleri ?, +, {,}, (,), |, ve ) özel bir anlamı yoktur (grep)
Onlara özel bir anlam vermek için kaçış versiyonlarını kullanın: ?, +, {, }, (, ) ve |

Genişletilmiş düzenli ifadeler kullanıldığında, bu meta karakterlerin özel bir anlamı vardır
grep –E = egrep

egrep kullanımı

egrep pattern filename(s)

Güvenli olmasu için, pattern(model) çevresine tırnak işaretleri yerleştirin. Örnekler:
egrep "abc" textfile
(dosyada “abc” içeren satırları yazdırır)
egrep -i "abc" textfile
(yukardakiyle aynı, ancak büyük/küçük harf farkını yoksayar ikisinide gösterir.)
egrep -v "abc" textfile
(dosyada “abc” içermeyen satırları yazdırır)
egrep -n "abc" textfile
(satır numaralarını ile beraber yazdırır)
egrep -c "abc" textfile
(dosyada “abc” içeren satır sayısı yazdırır)

Metacharacters (Özel karakterler)

• Nokta(period)(.): Herhangi bir karakterle eşleştirir.
  
  “a.c” abc, adc, a&c, a;c, ... ile eşleşir
  “u..x” unix, uvax, u3(x, ...ile eşleşir
  

• Yıldız işareti(): önceki RE'nin sıfır veya daha fazla oluşumuyla eşleşir.
  
  Kabuktaki joker karakterlerle(wilcards) aynı değildir!
  
  “abc” ac, abc, abbc, abbbc, ... ile eşleşir. (yani a karakteri ile c karakteri arasında b karakterinden kaç tane olduğu önemsizdir. çünkü * işareti önceki RE'yi kasteder yani b'yi )
  
  “. *” Herhangi bir string'le eşleşir.
  

• Artı(+): önceki RE'nin bir veya daha fazla tekrarını eşleştirir
  “ab+c” abc, abbc ile eşleşir ancak ac ile eşleşmez (yani a karakteri ile c karakteri arasında b karakterinden en az bir tane olmalı, en fazla kaçtane olduğu ise önemsizdir.çünkü * işareti önceki RE'yi kasteder yani b'yi )
  

• Soru işareti (?): Önceki RE'nin sıfır veya bir tekrarı ile eşleşir
  “ab?c” ac, abc ile eşleşir ancak abbc ile eşleşmez
  

• Mantıksal veya (|): bar öncesi RE veya bar sonrası RE ile eşleşir
  “abc | def”, abc veya def ile eşleşir
  

• Şapka (^): satırın başlangıcı anlamına gelir
  “^D.*”, D ile başlayan bir satırla eşleşir
  

• Dolar işareti ($) satır sonu anlamına gelir
  “.*d$”, d ile biten bir satırla eşleşir

• Ters eğik çizgi (\): diğer meta karakterlerden kaçar yani meta karakterler ile normal karakterlerin karışmasını önler
  “file\.txt”, file.txt ile eşleşiyor ancak file_txt ile eşleşmiyor
  

• Köşeli parantez ([]): bir karakter kümesi listesini belirtir.
  kümedeki herhangi bir karakter eşleşecek
  ^ 'den sonraki karakterler ile eşleşmeyecek .
  -bir karakter aralığını belirtir.
  Örnekler:
  

“[fF]un” fun,Fun ile eşleşir. Yani F yada f olmalı.
“b[aeiou]g” bag, beg, big, bog, bug ile eşleşiyor.
“[A-Z].”, Büyük harfle başlayan bir dizeyle eşleşir
“[^Abc].” a, b veya c ile başlamayan dizelerle eşleşir

• Parantezler (()): gruplamak için kullanılır.
  

“a(bc)*” ifadesi a, abc, abcbc, abcbcbc, ... ile eşleşir.
“(foot|base)ball” football ya da baseball ile eşleşir

• Süslü Parantez ({}): bir RE'nin tekrar sayısını belirtmede kullanılır.
  

“[a-z]{3}” üç küçük harfle eşleşiyor.Yani en az üç küçük harf barındırıyorsa
“m.{2,4}” dizeleri m ve ardından 2 ile 4 karakter arasında eşleştirir.

Bunlar ne anlama geliyor?

Örnekler
egrep ”^B.s$” dosya
egrep ”[0-9]{3}” dosya
egrep ”num(ber)? [0-9]+” dosya
egrep ”word” dosya | wc -l
egrep ”[A-Z].?” dosya
ls -l | egrep "^....r.-r.-"

Ya grep kullanılırsa? En az iki 0 içeren kullanıcı kimliğine sahip kullanıcıları arayın
  grep "^[^:]:[^:]:[^:]0[^:]0[^:]:." /etc/passwd

/etc/passwd dosya formatı;
<username>:\x:<userid>:<groupid>:<useridinfo>:<homedir>:<loginshell>
x karakteri, şifreli parolanın /etc/shadow dosyasında saklandığını gösterir.

Egrep ile kelime arama

Sistem yazım denetimi için küçük bir sözlüğe sahip olabilir:/usr/dict/words
Beş sesli harfin tümünü içeren kelimeleri alfabetik sırayla bulun.

cat alphvowels.
^[^aeiou]*a[^aeiou]*e[^aeiou]*i[^aeiou]*o[^aeiou]u[^aeiou]$
egrep -f alphvowels /usr/dict/words

Harfleri alfabetik sırada olan altı veya daha fazla harften oluşan tüm kelimeleri bulun.
cat > monotonic
^a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?x?$
egrep -f monotonic /usr/dict/words | grep "......"

pratik:
En az 10 karakterden oluşan bir sözcükle başlayan satırlar.
Standart 3 bölümlü formda öğrenci kimliği içeren satırlar.
Ardışık 2 büyük harfli sözcük içeren satır sayısı.
Alfabetik karakterle bitmeyen satır sayısı.
Bir cümlenin sonunda sesli harfle başlayan bir kelimeyi içeren satırlar.

Bölüm-6 UNIX Kabuk Ortamları

Kabuk özellikleri

Kullanıcı ve işletim sistemi arasındaki komut satırı arayüzüdür.
Giriş sırasında otomatik olarak başlar.
Hem komut yorumlayıcısı hem de programlama dilidir.
Kabuk betiği(Shell script), kabuk yorumlaması için mantık içeren bir metin dosyasıdır.

Kabuk Etkileşimi

• Komut satırı ayrıştırma(parsing)
  
• Ortam
  
• Metin tamamlama (tab tuşu ile)
  
• Takma adlar.(Aliases)
  
• Komut satırı düzenleme
  
• Komut geçmişi
  
• Yapılandırma.
  

Kabuk Programlama

• Değişkenler
• Kontrol Yapıları (Döngüler ve şartlamalar).
• Fonksiton tanımı ve çağırma.
• Kabuk betiği(scripts).
• Sonraki bölüm.

Çeşitli Unix Kabukları

• sh (Bourne kabuğu, orijinal Unix kabuğu)
• ksh (Korn kabuğu)
• csh (Berkeley'de geliştirilen C kabuğu)
• tcsh
• bash (Bourne Kabuğu.) Linux'ta varsayılan kullanıcı kabuğu ... Çoğunlukla etkileşim düzeyindeki farklılıklar desteklenir.
  http://www.faqs.org/faqs/unix-faq/shell/shell-differences/
  

Kabuk Özellikleri.

Bourne Again SHell (bash)

Bash bu döküman için standart kabuktur.
Bourne kabuğunun üst kümesidir(sh).
Sh, csh, tcsh & ksh'dan ödünç alınan özellikler vardır.
GNU projesinin bir parçasıdır.

Değişkenler

Çalışan bir kabuk için üç ana değişken türü vardır;

Yerel(local) değişkenler;
Şu anki kabuğun içinde mevcut olan değişkenlerdir. Komut isteminde, değişkene değer atanır.

Ortam(environment) Değişkenleri;
Herhangi bir alt kabuk işlemi(child process) için kullanılabilir

Kabuk değişkenleri;
Kabuk tarafından değer atanması(set) gerekir.

Kabuk Değişkenleri

Kabuğun belirli işlemler için kullandığı değişkenler kümesidir.
Kabuk değişkenleri şunları içerir:

• yerel değişkenler
• Ortam Değişkenleri

• env komutu
  

Geçerli ortam değişkenlerinin listesi, env komutu ile görüntülenebilir.
Değişkenlerin bir adı ve değeri vardır.Varname değerini(listedeki herhangi bir değişkenin adı), echo $varname ile standart çıktıya gönderilerek terminale yazdırılabilir.

Ortam Değişkenleri

Bazı ilginç değişkenler: HOME, PWD,PATH, PS1, USER, HOSTNAME
$ HOME: home dizini (cd için varsayılan değişken)
Örnek: /home/0607/student
$ PWD: mevcut çalışma dizini
Örnek: /export/home/staff/usern
$ PATH: komutlar için arama yolu
Örnek: /usr/local/bin:/bin:/usr/bin
$ PS1: komut istemi (varsayılan “$”)
Örnek: \u@\h:\w$
$ USER: kullanıcı adı
Örnek: usern
$ HOSTNAME: bilgisayar hostname
Örnek: ktuce

Diğer ilginç değişkenler: UID, PPID, RANDOM, HISTFILE, HISTSIZE, MAIL, MAILCHECK, PS2
$ UID: mevcut kullanıcı kimliği
$ PPID: Kabuğu çalıştıran programın işlem kimliği
$ RANDOM: 0-32767 arasında rastgele bir tam sayı oluşturur
$ HISTFILE: komut geçmişini saklamak için dosya
$ HISTSIZE: saklanacak komut sayısı
$ POSTA: posta gelmişmi diye kabuk tarafından kontrol edilen dosya
$ MAILCHECK: kontroller arasındaki saniye sayısı
$ PS2: İkincil komut istemi (varsayılan ">")

Değişkenlere atama

Değişkeni varname = value ile ayarlayın
PS1 = $USER@$HOSTNAME:
   Varsayılan kabuk istemini değiştirir
PS1 = "bash_prompt>"
PATH = $PATH:$HOME/bin , $HOME/bin yolu PATH değişkenine atandı
PATH = $PATH:~:. , ~ :. PATH'a atandı
DATE=`date` veya DATE=$(date) , DATE değişkeni oluşturduk ve bu değişkene sistem saatini atadık.

Metin Tamamlama

<tab> geçerli komutu veya dosya adını tamamlama girişiminde bulunur.
pus<tab> genişler(tamamlar) için pushd<space>
pu<tab> alternatifleri verir. yani pu ile başlayan alternatif komutları gösterir bazen 2 kez <tab> yapmak gerebiliyor.
pu pup pushd
/etc içinde, ls init girildiğinde aşağıdakileri verir
init init.d. initpipe inittab
[lecture]$ ls init

Aliases (Takma adlar)

Takma adlar, sık kullanılan komutlar için kısa yol olarak kullanılır.
Sözdizimi: alias kısayol=komut
Örnekler:
alian asd=ls (artık ls komutuna asd adında bir kısayol atadım terminale asd yazdığım zaman ls komutunu çalıştıracak.
alias pu=pushd
alias po=popd
alias l= " ls –F -C "
alias ll= " ls –L –l -F "
alias d=dirs
alias hide= " chmod og-rwx "
alias unhide= " chmod og+r "

Komuta Tarihi(geçmişi)

• history komutu
  

history,önceden girilmiş komutları listelemek için kullanılır.
m'den n'ye kadar önceden yazılmış komutları listelemek için (fc -l <m> <n>) kullanılabilir.Bu komutla ilk m ile başlayan satırdan sonra ilk n ile başlayan satıra kadarki geçmiş komutları yazdırır. fc -l ls man tarzı bir kullanımda mümkündür
Geçmiş listesinde gezinmek için imleç tuşlarını yukarı ve aşağı kullanılabilir.

Komut Satırında Düzenleme

bash bir dizi satır düzenleme komutu sağlar.
Varsayılan emacs modu komutları.(Terminalde komut yazarken uygulanabilecek kısa yollar.)
Esc-b Bir kelime geri git
Esc-f Bir kelime ileri git
Ctrl-a Satırın başına gitme
Ctrl-e Satırın sonuna gitme
Ctrl-k İmleçten satır sonuna kadar olan metini siler.
Diğer taraftan, ksh kullanıyorsanız komut satırını etkileşimli olarak birkaç şekilde düzenleyebilirsiniz.
set -o vi, komut satırını düzenlemek için vi komutlarını kullanmanızı sağlar.
set -o vi-tabcomplete ayrıca bir TAB girerek komutları/dosya adlarını tamamlamanıza izin verir.

Login(giriş) Script'leri

Her oturum açtığınızda takma adlar, ortam değişkenleri, komut satırı düzenlemeleri vb. Girmek istemezsiniz.
Bütün bunlar, kabuk her başlatıldığında çalıştırılan bir betikte(script) yapılabilir.

Başlangıçta çalıştırılan başlangıç komut dosyaları;
  /etc/profile
  ~/.bash_profile
      ~/.bash_login (eğer .bash_progile yoksa)
       ~/.profile (eğer ikiside yoksa)

Giriş yaptıktan sonra komut dosyası çalıştırıldı
     ~/.bashrc
Oturum kapatıldıktan sonra komut dosyası çalıştırıldı
   ~/.bash_logout

örnek .bash_ profile (partial);

# .bash_ profile: oturum açma kabukları için bash tarafından yürütülür.
umask 022 (0666 & ~022 = 0644 = rw-r--r--)
# varsa, .bashrc komutunu ekleyin
if [ -f ~/.bashrc ]; then
     . ~/.bashrc
fi
# değişkenleri ayarla
export CVSROOT=~/.cvsroot
export EDITOR=/bin/vi
export PAGER=/usr/bin/less

örnek .bashrc (partial)

# .bashrc # bazı genel komutların kısaltmaları alias bye=logout alias h=history alias l='ls –F -C' alias ll='ls-L –l -F' alias po=popd alias pu=pushd

Csh için, giriş kabukları çalıştırılır:
~/.profile
ENV ayarlanmışsa:
  Bu dosya her yeni terminal için yürütülür
  örnek:
  ENV=$HOME/.cshrc
  EXPORT ENV (for bash)

Bölüm-7 Temel Kabuk Betiği (basic shell script)

Bir kabuk betiği nedir?

.......

Komut dosyası yürütme (Script Execution)

komut dosyasını bir argüman gibi kabuk komutuna verin;
bash my_script

veya komut dosyasının ilk satırında kabuğu(shell) belirleyin;
#!/bin/bash
   komut dosyasının çalıştırılabilir olduğundan emin olun.
   my_script 'i doğrudan komut satırında çalıştırın.

Derlemek yoktur, kabuk tarafından yorumlanır.

Basit bir script;
#!/bin/bash
echo "Hello, World!"
path=$(pwd)
echo $path

Result:
Hello, World!
/home/user2

Kabuk Değişkenleri

• Numeric (Sayısal)
  
• String(Dize)
  
• Arrays (Diziler)
  
• Komut satırı argümanları; yalnızca okur
• Fonksiyonlar
• var değişkenin adını belirtir, $ var değere
  var = 100    # değeri 100 olarak ayarlar
  echo ”\$ var = $ var”    # $ var = 100 yazdıracak
• unset var ile, bir değişkeni kaldırabiliriz.
• İsimler bir harfle başlar ve harf, rakam ve alt çizgi içerebilir.

##Sayısal Değişkenler

Tamsayı değişkenleri bash'te kullanılabilecek tek saf sayısal değişkenlerdir.
beyan(declaration) ve set değeri:

• declare -i var = 100
  

Sayısal ifadeler çift parantez içine alınır (C stilinde).
Genel format:

var = $((ifade)) veya var = $[ifade]
Örneğin. i = $((var ++)) veya ((var + = 1))
Örneğin. i = $((var2 = 1 + $ var)) veya ((var2 = 1 + var))
Örneğin. i = $[var + 2] - [var + = 2] Hata!
Örneğin. echo $((var * 7)) veya echo $[var * 7]
Örneğin. echo ((var2 = 1 + var)) veya echo [var2 = 1 + var]

Operatörler C / C ++ ile aynıdır.
! +, -, *, /,%, &, |, <,>, <=,> =, ==, =, &&, ||, + =, -! =, * =, / =,% = ~, ~ =, <<, >>, ^

Dize(string) Değişkenleri

Açıkça başka bir tür olarak bildirilmediği sürece, değişkenler string'dir.
var = 100, var'ı "100" string'i yapar.
Bununla birlikte, değişkeni çift parantez içine koymak bir tamsayı olarak kabul edilir. ((var2 = 1 + $ var))

Alt stringlerin kullanılması;

• ${string:n} # n: index
     ${string:5} # ilk 5 karakter haric
     ${string:(-2)} # son iki karakter
  
• ${string:n:m} # n: index, m: number
      ${string:0:5} # ilk 5 karakter
      ${string:1:3} # 2.ile 4. arasındaki 3 karakter
  
• ${#string} # length of string
  

Birleştirilen strings;

• var1="$var1 $var2"
  

Manipüle string

• y=${x:${#x}-1}${x:1:${#x}-2}${x:0:1}
  bu örnekte x string'inin ilk ve son karakterleri değiştirilerek y'ye atanır.

Değişkenin Yerine koyma;

• $name veya ${name} # name değerini kullanır
  
• ${name:-value} # eğer name ayarlanmadıysa, değeri(value) kullan
• ${name:=value} # name ayarlanmadıysa, değeri kullanın ve name'e degeri ata
• ${name:?value} # name ayarlanmadıysa, değeri stderr'e yazın
• ${name:+value} # eğer name ayarlanmışsa, değeri kullanın; aksi takdirde null kullanın
• ${name%pattern} # en küçük sonek kalıbını kaldır
• ${name%%pattern} # en büyük sonek kalıbını kaldır
• ${name#pattern} # en küçük önek kalıbını kaldır
• ${name##pattern} # en büyük önek kalıbını kaldır

Dosya adı değiştirme karakterleri (*,?, [...],!) modelde kullanılabilir.

Dizi Değişkenleri

• Dizi bir değerler listesidir. Boyut bildirmek zorunda değilsiniz
• Bir değere $ {name [index]} ile referans verilebilir.
• ${a[3]}     #dördüncü konumdaki değer
• $a     #${a[0]} ile aynıdır

Bir dizi bildirmek için declare –a komutu kullanılabilir.

• declare -a sports

• sports=(basketball football soccer)

• spor [3] = hokey

• dizi oluşturma
  sports=(football basketball)
  moresports=($sports tennis)
  

• ${array[@]} or ${array[]} dizinin tüm içeriğini belirtir.
  echo ${moresports[]}
  Çıkış: football tennis
  

• ${#array[]} dizideki değerlerin sayısını döndürür. echo ${#moresports[]} Output: 2

Dışa aktarılan değişkenler

Export komutu , kabuğun alt(child) süreçlerin değişkene erişmesine izin verir.

• export <variables>
• declara -x <vars>

export –p değişkenlerin ve kabuğunuz tarafından verilen değerlerin bir listesini gösterir.

vartest bir program
$> cat vartest
echo x = $x
echo y = $y
$> x=100
$> y=10
$> vartest
x =
y =
$> export y
$> vartest
x =
y = 10

Parantez içinde bir veya daha fazla komut alt kabukta yürütülür

• $> (cd kutusu; ls;)
  Cwd'yi değiştirmeyen bin dizinindeki dosyaları listele
  
• $> (prog1; prog2; prog3) 2> error.txt &
  Arka planda üç program yürütür.</br error.txt dosyasına üç programdaki hataları yazar
• $> x=50; (x=100); echo $x 50 çıktılar

Kıvrımlı ayraçlar içindeki bir veya daha fazla komut geçerli kabuk tarafından yürütülür

• $> {cd bin; ls; } Cwd'yi değiştiren bin dizinindeli dosyaları listeler
• $> x=50; {x =100; }; echo $x çıktı 100 Giriş ve çıkış bu yapılardan piped yapılabilir. ve G / Ç yönlendirilebilir.

Komut Satırı Argümanları

Eğer argümanlar bir betiğe(script) geçirilirse, $1,$2,$3, vb. Değerlere sahiptirler.

• $0, betiğin(script) adıdır.
  
• $*, $0 hariç, boşluklarla ayrılmış tüm argümanların bir dizesidir.
• $@, $0 hariç argümanların bir dizisidir.
• $#, argümanların sayısıdır.

Çıktı ve alıntılama(quoting)

• echo message ,     stdout'a yazdırır.
• echo –n "yes/no? " ,     bir bilgi istemi Çıktıdan sonra yeni satır(newline) yazdırmıyor.

Shell, $ ve ‘ ‘(çift tırnak) işaretleri içindeki ifadeleri yorumlar

• $ —değşken yerine geçer
• ‘ —komut yerine geçer echo "`date +%D`"      # 04/30/05

Shell özel karakterleri tek tırnak işaretleri içinde yorumlamaz.

• echo '`date +%D`'      # `date +%D`

• \  ,   karakterlerden kaçmak için kullanılır (örneğin, \ ”, \ $)

Dönüş değerleri(Return values)

Komut dosyaları bir tamsayı değeri döndürebilir
return N kullanılır.
$? Değişkeni Son çalıştırılan komutun dönüş değerini içerir.
Koşulları test etmek için kullanılabilir
$> pwd
/home/user
$&gt; echo $?
0
$> pwdd
pwdd: not found
$&gt; echo $?
127

Kullanıcı tanımlı değişkenler

Örnekler:

• $> name =Ali , name değişkenine Ali değeri atanır
  
• $> echo $ name , Ali görüntülenecek
  
• $> echo Hello $name! , Welcome to $HOME ,bunun bilgisayarınızda çıktısını görün.

Değişken isimleri:
__FRUIT, TRUST_NO_1, _2_TIMES (geçerli)
2_TIMES, _2*2, NO-1  Invalid (geçersiz)

FRUIT=peach
FRUIT=2apples
FRUIT=apple+pear+kiwi

Boşluk kullanımına dikkat edin.
$> FRUIT=apple orange plum
bash: orange: command not found.
Tırnak kullanın.
$> FRUIT="apple orange plum"

Kullanıcı Girişi Okuma

Genel biçim:

• read <değişken>

Okuma yürütüldüğünde, kabuk;
standart girdiden bir satır okur.
ilk sözcüğü <değişken> 'de listelenen ilk değişkene atar .
ikinci sözcüğü ikinci değişkene atar. buna benzer şekilde okuma ve atama yapar.

Satırda listelenen değişkenlerden daha fazla kelime varsa, fazla sözcük son değişkene atanır.

• read x y
  

girilen ilk satırı okur, ilk sözcüğü x değişkeninde saklar ve satırın kalanını y değişkeninde saklar. Örnek

• $> cat read.sh
  echo   –n "Lütfen adınızı ve soyadınızı girin:"
  read name1 name2
           echo "KTU bilg. müh bölümüne hoşgeldiniz, $name1 $name2"

Komut ve Aritmetik yerdeğiştirme

Komuttan stdout ile değiştirme;
var=`komut` (' ' arasında geri alıntı yapar)
var=$(komut)

İfade değeri ile değiştirme;

var = $((expresssion))

Örnekler:
$> echo ‘date‘ # date komutunun çıktısını görüntüler
$> echo sistemde çalışan `who | wc –l` kişi var    # bunun çıktısını görün
c = $ ((2 + 3 * 4)) # "echo $ c" 14 görüntüleniyor

Tamsayılı(integer) Aritmetik

Bash, aritmetik ifadeleri, aritmetik yerdeğiştirme olmadan değerlendirmeyi destekler.
Sözdizimi dolar işareti olmadan $((...))'a benzer.
$> x=10
$> ((x=x*12))
$> echo $x # 120 verir.
Aritmetik ifadeler, if, while ve until komutlarında kullanılabilir.

Karşılaştırma operatörleri çıkış durumunu ayarlar(set'ler)
Karşılaştırma sonucu yanlış ise sıfır olmayan bir değer
sonuç doğruysa sıfır değeri
((i == 100)) eğer i, 100'e eşit ise çıkışa 1(true)dönderir, aksi halde çıkışa sıfır(false) dönderir.
if((i == 100)) ... [“$i” –eq 100] ile aynı etkiye sahip

expr(ifade) komutu

expr komutu, kullanıcı tanımlı değişkenler üzerinde hesaplamalar yapmak için başka formlar sağlar

expr val1 op val2 (boşluklarla ayrılmış)
expr $val1 op $val2
val3 = `expr $val1 op $val2`

Örnekler;
$>expr 5 + 7    #12 döndürür
$>expr 6 – 3 – 2 # gives 1
$>expr 3 + 4 \* 5 # gives 23
$>expr 24 / 3 # gives 8
$>sum= `expr 5 + 6`
$>echo $sum # gives 11
$>a=12
$>b=90
$>echo sum is $a + $b    # sum is 12 + 90
$>echo sum is `expr $a + $b`   # sum is 102

Önceden Tanımlanmış Değişkenler

Kabuk tarafından dahili olarak ayarlanan ve kullanıcıya sunulan bazı değişkenler vardır:
1$ - $9: Konumsal parametreler
$0: Komut adı
$#: Konumsal argümanların sayısı
$? : Yürütülen son komutun çıkış durumu ondalık dizgesi (0,1,2 ..) olarak verir.
$$: Eşsiz(unique) dosya isimleri oluşturmak için yararlı olabilen, çalışılan kabuğun süreç(process) numarası.
$! : Arka planda çalışan son komutun işlem kimliği (Son arka plan işleminin PID'sini tutar).
$- : Kabuğun bu çağrısına uygulanan tedarik edilmiş mevcut seçenekler.
$* : $1 'dan başlayan, kabuğun tüm argümanlarını içeren bir dize.
$@: Alıntılananlar hariç, yukarıdakiyle aynı.

Not: $* ve$ @ alıntı yapıldığında aynıdır ve değişkenlere genişler.
"$*", boşlukla birleştirilmiş, kabuğun tüm argümanlarını içeren tek bir kelimedir. Örneğin, '1 2' 3 , "1 2 3" olur.
"$@", kabuk tarafından alınan argümanlarla aynıdır, sonuçta ortaya çıkan sözcük listesi, kabuğa verilenlerle tamamen eşleşir. Örneğin, '1 2' 3 , "1 2" "3" olur.

Argümanları komut dosyalarına geçirme

Standart UNIX komutları gibi, kabuk komut dosyaları(shell scripts)'da komut satırından değişken alabilir.
Bağımsız değişkenler, komut satırından $1 ile $9 arasındaki konumsal parametreler kullanılarak bir kabuk programın içine geçirilir.
$0 konum parametresi, komut adını veya kabuk komut dosyasını içeren yürütülebilir dosyanın adını belirtir.
Tüm konumsal parametreler $* özel parametresi kullanılarak ifade edilebilir.

Examples

$ cat pass_arg.    # 5 sayı kabul eden ve toplamını gösteren bir script.
aktarılan parametrelerin gösterimleri(echo ile) : $1, $2, $3, $4, $5
betiğin adının gösterimi (echo ile) : $0
aktarılan parametrelerin sayısı(echo ile) : $#
sum=`expr $1 + $2 + $3 + $4 + $5`
toplamları : $sum

shift komutu

Bir komut dosyasına 9'dan fazla parametre iletilirse, parametrelere erişmek için iki alternatif vardır:

Notasyonu ${n}
shift komutu

Shift komutu parametreleri bir konum sola kaydırır.
Shift komutunun yürütülmesinde, ilk parametrenin üzerine ikincisi yazılır, ikinci'nin üzerine üçüncü yazılır ve bunun gibi devam eder.

Örnek;

Farklı sayıları kabul edecek ve toplamlarını bulacak bir komut dosyası yazalım. Parametrelerin sayısı değişebilir.

$ cat sum_arg
sum=0
while [ $# -gt 0 ]
do
     sum=`expr $sum + $1`
     shift
done
echo sum is $sum

Örnek; Bu örneği birtane script dosyasının içine yazıp daha sonra sh script.sh 1 2 3 4... şeklinde parametreler vererek terminalden çağırıp deneyebilirsiniz.

#!/bin/bash
echo "arg1=$1 arg2=$2 arg3=$3"
shift
echo "arg1=$1 arg2=$2 arg3=$3"
shift
echo "arg1=$1 arg2=$2 arg3=$3"
shift
echo "arg1=$1 arg2=$2 arg3=$3"

Null komutu

Kabuk yerleşik bir null komutuna sahiptir

formatı basit;

• :

Amaç hiçbir şey yapmamak

Genellikle bir komutun, özellikle de komutlarda görünmesi gerekliliğini yerine getirmek için kullanılır.

if grep “^$system” ~/mail/systems > /dev/null
then
    :
else
    echo “$system is not a valid system”
    exit 1
fi
Kabuk, bundan sonra bir komut yazmanızı gerektirir. Sistem geçerliyse, hiçbir şey yapılmaz

&& ve || operatörleri

Kabuk, bir önceki komutun başarılı veya başarısız olmasına bağlı olarak bir komutu çalıştırmanıza olanak tanıyan iki özel yapıya sahiptir.

&& operatörü eğer önceki komut başarılı bir şekilde derlenirse sonraki komutu uygular.

• komut1 && komut2

komut2 yalnızca komut1 sıfır çıkış durumunu döndürürse çalıştırılır.
örnek;
[ -z $EDITOR ] && EDITOR=/bin/ed

|| operatörü eğer önceki komut başarısız bir şekilde derlenirse sonraki komutu uygular.

• komut1 || komut2

komut2 yalnızca komut1 sıfır olmayan bir çıkış durumu döndürdüğünde çalıştırılır

Örnekler;
[ -z $PATH ] || echo $PATH
grep "$name" phonebook || echo \
“Not found $name“
who | grep "^$name " > /dev/null || echo \
"$name's not logged on“

(Satırın sonunda \ kullanıldığında, kabuğun satıra devam ettiğini bildirir.)

&& ve || Aynı komut satırında da birleştirilebilir:

who | grep "^$name " > /dev/null && \
echo "$name is logged on" || echo "$name’s \
not logged on"

Grep başarılı olursa ilk echo gerçekleşir;başarısız olursa ikinci echo.

Bu operatörler if komutları ile temsil edilebilir.

if grep "$name" phonebook
then
    :
else
    echo "Couldn't find $name“
fi

Koşullu İfadeler

Her Unix komutu, çıkışta kabuğun sorgulayabileceği bir değer döndürür. Bu değer salt okunur kabuk değişkeni $? İçinde tutulur.

0 (sıfır) değeri başarıyı gösterir; 0 (sıfır) dışında herhangi bir şey başarısızlık anlamına gelir.

Tamsayı kullanıyorsanız: ((koşul))
Dizeler kullanılıyorsa: [[koşul]]
Çıkış durumları duruma bağlı olarak sıfır veya sıfır değildir
Örnekler:
(( a == 10 ))
(( b >= 3 ))
[[ $1 = -n ]]
[[ ($v != fun) && ( $v != games) ]]
(( Z > 23 )) && echo Yes

Dosya varlığı, dosya izinleri, sahiplik, dosya türü vb. İçin özel koşullar.

• [[ -e $file ]] –File exists? (dosya mevcut mu?)
• [[ -f $file ]] –Regular file? (dosya normal mi?)
• [[ -d $file ]] –Directory? (dizin mi?)
• [[ -L $file ]] –Symbolic link? (sembolik link?)
• [[ -r $file ]] –File has read permission? (dosya okuma izni varmı)
• [[ -w $file ]] –File has write permission? (dosya okuma yazma varmı)
• [[ -x $file ]] –File has execute permission? (dosya çalıştırma izni varmı)
• [[ -p $file]] –File is a pipe?

İf deyimi

İf ifadesi verilen komutun çıkış durumunu kullanır ve şartlı olarak aşağıdaki ifadeleri çalıştırır.

Genel sözdizimi:
if koşul
then
    komutlar (koşul doğruysa)
else
    komutlar (koşul yanlışsa)
fi

İç içe if ifadesi:
if (-----)
then ...
else if ...
    ...
  fi
fi

elif ifadesi, else if ifadesi için kısa yol olarak kullanılabilir.

örnek:
if [[ -r $fname ]]
then
    echo “$fname is readable”
elif [[ -w $fname && -x $fname ]]
then
    echo “$fname is writeable and executable”
fi

test komutu

Unix sistemi, önceki komutun çıkış durumunu araştıran ve sonucu başarı ya da başarısızlık biçiminde çeviren, yani sonucu 0 ya da 1 olan test komutu sağlar.

Test komutu herhangi bir çıktı üretmez, ancak testin başarısız olup olmadığını kontrol etmek için çıkış durumu if ifadesine geçirilebiliriz.

Herhangi bir komutun çıkış durumunu nasıl öğrenebilirim?

Tüm komutlar çıkış durumunu, echo komutu kullanılarak görüntülenebilen önceden tanımlanmış bir Shell Değişkenine ‘?’ Döndürür. Örneğin;
echo$?
Bunun çıktısı 0 (Sıfır) ise önceki komut başarılı olmuş demektir veya çıktı 1 (Bir) ise önceki komutun başarısız olduğu anlamına gelir.

Test komutunun aşağıda açıklanan dosyalar, sayısal değerler ve diziler üzerinde çalışması için belirli operatörleri vardır: Test komutuyla kullanılan Sayısal

Değişkenlerdeki İşleçler:

• -eq : equal to(eşittir)
• -ne : not equals to(eşit değildir)
• -gt : grater than (dan büyüktür)
• -lt : less than (dan küçüktür)
• -ge : greater than or equal to(büyük veya eşittir)
• -le : less than or equal to(küçük veya eşittir.)

Test komutuyla kullanılan String Değişkenleri işleçleri:

• = : equality of strings(dizgelerin eşitliği)
• != : not equal (eşit değil)
• -z : zero length string (sıfır karakter içeren dize yani null dize).
• -n : String length is non zero.(dize uzunluğu sıfır değil)

Örnekler:
$> a=12; b=23
$> test $a –eq $b
$&gt; echo $?      # 1verir
$> name=”Ahmet”
$> test –z $name      #return 1
$> test –n $name      #return 0
$> test –z “$address”
$> test $name = “Ali”

Test komutuyla kullanılan dosyalardaki operatörler:

• -f: dosya var.
• -s: dosya var ve dosya boyutu sıfır değil.
• -d: dizin var.
• -r: dosya var ve okuma iznine sahip.
• -w: dosya mevcut ve yazma iznine sahip.
• -x: dosya var ve yürütme iznine sahip.

Örnekler:
$> test –f “mydoc.doc”
# mydoc.doc dosyasını kontrol eder, varsa 0, yoksa 1 döndürür.
$> test –r “mydoc.doc”
# mydoc.doc için okuma izni olup olmadığını denetler
$> test –d “$HOME”
# kullanıcıların ana dizininin varlığını kontrol eder..

Test komutuyla kullanılan Mantıksal Operatörler:

Birden fazla koşulu birleştirmek mantıksal AND, OR ve NOT işleçleriyle yapılır.

• -a: mantıksal AND(VE)
• -o: mantıksal OR(VEYA)
• ! : mantıksal NOT(DEĞİL)

$> test –r “mydoc.doc” –a –w “mydoc.doc”
# mydoc.doc dosyasının hem okuma hem de yazma iznini kontrol eder ve sonucA bağlı olarak 0 veya 1 döndürür.

if who | grep -s hakan > /dev/null
then
    echo hakan CE sunucusuna giris yapti
else
    echo hakan CE sunucusunda mevcut degis
fi

Bu script, şu anda sisteme giriş yapmış olan kişileri listeler ve çıktıyı grep üzerinden pipe ile yönlendirir.

durum(case) açıklamaları

Sözdizimi:
case expression in
  pattern1)
    commands ;;
  pattern2)
    commands ;;
... *)
    commands ;;
esac

örnekler:
örnek1:
case $1 in
-a)
    a seçeneğiyle ilgili komutlar ;;
-b)
    b seçeneğiyle ilgili komutlar ;;
*)
    diğer tüm seçenekler ;;
esac

örnek2:
clear
echo "1. Date and time"
echo
echo "2. Directory listing"
echo
echo "3. Users information "
echo
echo "4. Current Directory"
echo
echo –n "Enter choice (1,2,3 or 4):"

örnek3:

read choice
case $choice in
    1) date;;
    2) s -l;;
    3) who ;;
    4) pwd ;;
    *) echo wrong choice;;
esac

bu komutları birtane script dosyasının içine yazıp bu dosyayı terminalden çalıştırdığımız zaman bizden birtane argüman ister bu argümanı okuduktan sonra 1,2,3,4 veya diğer olacak şekilde ayırarak farklı komutları çalıştırır.

for döngüsü

Sözdizimi:
for var [in list ]
do
     commands
done

Tek bir satırdaki komutlar noktalı virgülle (;) ayrılır.
Liste belirtilmezse, $@ kabul edilir.
Aksi takdirde ${list [*]} , Burada liste bir dizi değişkenidir.

örnekler:

for colors in Red Blue Green Yellow Orange Black Gray
  do
    echo $colors
  done
echo

Bu örnek verilen tüm renkleri terminale yazdırır.

While döngüsü

Sözdizimi:
while command-list1
do
   command-list2
done

command-list1'deki son komutun çıkış durumu 0 (sıfır) ise, command-list2'deki komutlar yürütülür.

Anahtar kelimeler break, contiune ve return , C / C ++ ile aynı özelliklere sahiptir.

break [num] veya contiune [num] # num döngü sayısıdır

Until döngüsü

Sözdizimi:
Until command-list1
do
   command-list2
done

Döngü, command-list1'in çıkış durumu sıfır olmadıkça gerçekleştirilir.

While/until komutunun çıkış durumu, command-list2'de yürütülen son komutun çıkış durumudur. Eğer böyle bir komut listesi çalıştırılmazsa, while/until çıkış 0 durumundadır.

örnekler:

eval komutu

... (Bölüm 7 henüz bitmedi devam edicek :))

Bölüm-8 Gelişmiş Kabuk Betiği(Advanced Shell Scripting )

Fonksiyon oluşturma ve kullanma

Bir kabuk fonksiyonunun tanımı aşağıdaki gibidir:
isim(){list ;}

Geçerli ve geçersiz fonksiyon tanımları: lsl(){ ls -l ; }     # geçerli
lsl { ls -l ; }     # geçersiz

sh için takma ad tanımlama:
$> cat mycd
cd () { chdir ${1:-$HOME} ; PS1="`pwd`$ " ; export PS1 ; }
$> source mycd

Örnekler:

yazdir(){
    for i in {1..13}
     do
         echo "hakan"
         echo "$i"
     done
}

Bu fonksiyon 13 kere hakan ve sırasıyla sayıları yazar ama bu fonksiyonu terminalde koşabilmek için dosyayı source etmemiz gerekir.Bunuda şu şekilde yaparız.

• source dosya_adı

Bu komuttan sonra dosyamızdaki fonksiyonu ismiyle çağırabiliriz(sadece mevcut terminalde):
yazdir
hakan
1
hakan
2 ...

Her dizinin tek bir satırda listelenmesiyle, PATH'nin geçerli değerini listelemek:

lspath() {
    OLDIFS="$IFS"
    IFS=:
    for DIR in $PATH ; do echo $DIR ; done
    IFS="$OLDIFS"
}
$> lspath | grep "/usr/dt/bin"

Dizinini uygun hale getirmek:

setPath() {
    PATH=${PATH:="/sbin:/bin"};
    for _DIR in "$@"
do
        if [ -d "$_DIR" ] ; then
            PATH="$PATH":"$_DIR" ; fi
    done
    export PATH
    unset _DIR
}

Örnek bir çağrı:
$> setPath /sbin /usr/sbin /bin /usr/bin /usr/ccs/bin
Her argümanının bir dizin olup olmadığını kontrol eder ve bir dizin varsa PATH'ye eklenir.

Fonsiyona parametre verme

Bir parametre script'e iletildiği gibi bir fonsiyona da iletilebilir.
fonksyion tanımlamak için sözdizimi:
fonksyion fonksyion_adı() {
deyim1
deyim2
deyimN
}
Bu işlev komut satırından veya kabuk betiğinin içinde aşağıdaki şekilde çağrılır: fonsiyon-adı arg1 arg2 arg3 argN

örnek:

$ vi pass
function demo()
{
echo "All Arguments to function demo(): $*"
echo "First argument $1"
echo "Second argument $2"
echo "Third argument $3"
return
}
# fonksyionu cağrıyoruz.
demo -f foo bar

çıktısı:
All Arguments to function demo(): -f foo bar
First argument -f
Second argument foo
Third argument bar

Değer döndürme(return)

Örnek tanım:
function topla {
(( toplam=$1+$2 ))
return $toplam
}

fonksiyonu çağırmak:
topla 2 3
echo $?

$? son işlev çağrısından veya komut tarafından döndürülen değerdir.

Fonksiyonlar arasında veri paylaşımı

C kabuğu(shell),csh, UNIX dosya sisteminde hızlı hareket etmek için üç yardımcı komut sağlar:

• popd
• pushd
• dirs

Bu komutlar, dahili olarak bir dizin yığınını korur ve kullanıcının yığından dizinleri ekleyip, çıkarmasına olanak tanır ve yığının içeriğini listeler.

dirs uygulaması:

dirs() {
  # IFS'yi kaydedin, ardından şuna ayarlayın:
  # _DIR_STACK öğelerine ayrı ayrı erişmek için.
   OLDIFS="$IFS"
  IFS=:
  # her dizini ve ardından bir boşluk yazdır
  for i in $_DIR_STACK
  do
    echo "$i \c“
  done
  # tüm girişlerden sonra yeni bir satır ekle
   # _DIR_STACK yazdırıldı   echo
   # IFS'yi geri yükle   IFS="$OLDIFS"
}

pushd uygulaması:
...(gelecek)
popd uygulaması:
...(gelecek)

echo komutu

metin veya değişken değerlerini gösterir.
echo [options] [string, değişkenler ...]

Seçenekler:

• -n Sondaki yeni satırı çıkışa vermez.
• -e Aşağıdaki kaçış karakterleri yorumlar.
• \c Sondaki yeni satırı bastırır.
• \a Bir uyarı (zil).
• \b geri al.
• \n yeni satır.
• \r satır başı.
• \t yatay sekme(tab).
• \ters eğik çizgi.

renkli metin gösterme

echo ile birlikte kullanılan bazı kontrol karakterleri vardır.
Bu kod, mesajı Mavi renkte yazdırır:
$> echo "\033[34m Hello Colorful World!"
Hello Colorful World!

Bu ANSI kaçış dizisini kullanır (\033[34m).
\033, kaçış karakteri, biraz harekete geçiyor
[34m kaçış kodu ön plan rengini Mavi olarak ayarlar
    [ CSI'nin başlangıcıdır (Komut Dizisi Giriş).
    34, parametredir.
    m harfdir (eylemi belirtir).

Genel sözdizimi:
echo -e "\033[ escape-code your-message "
(Bu başlık vakit bulursam genişletilebilir...)

Komut dosyası yürütme(script execution)

Komut dosyasını kabuk programına bir argüman olarak verin (ör. Bash my_script).
Veya komut dosyasında hangi kabuğun kullanılacağını belirtin.

• script'in ilk satırı #!/bin/ bash
• Komut dosyasını chmod kullanarak yürütülebilir duruma getirin.
• PATH'in geçerli dizini içerdiğinden emin olun.
• Doğrudan komut satırından çalıştırın

Derleme gerekmez!

Bölüm-9 Yazılım Geliştirme: g++ ve make

Yazılım geliştirme süreçi

• Kaynak dosyalarının oluşturulması.(.c, .h, .cpp)
• Derleme (*.c , *.o) ve bağlama(linking)
• Programları çalıştırma ve test etme.

Geliştirme araçları:
Kaynak dosyalarının oluşturulması.(.c, .h, .cpp)
     Text editörleri; vi ,emacs
     versiyon kontrol sistemleri; rcs, cvs
Derleme (*.o) and bağlama.
    Derleyiciler; gcc, g++
    Otomatik yapı(building) araçları; make
Çalıştırma ve test etme(xdb,gdb)

Derleme şüreci

Temel g++ Örnekleri

• g++ hello.cpp
       hello.cpp derlenir
       çalıştırılabilir a.out dosyası üretir
• g++ -o hello hello.cpp
       hello.cpp derlenir
       çalıştırılabilir hello dosyası üretir.
• g++ -o hello hello.cpp util.cpp
       hello.cpp ve util.cpp derlenir
       çalıştırılabilir hello dosyası üretir.

Ayrı ayrı derleme: Herhangi bir kaynak dosyadan, daha sonra çalıştırılabilir yapmak için bağlanacak bir nesne dosyası oluşturabilirsiniz.

• g++ -c hello.cpp
• g++ -c util.cpp
• g++ -o hello hello.o util.o

g++ seçenekleri

• -c
      kaynak dosyalarını derler ama bağlantı(link) yapmak
      çıktı(output) kaynak dosyaya karşılık gelen bir nesne dosyasıdır.
• o <dosya>
      çıktıyı <dosya> adlı bir dosyaya koyar.
• g
      çıktıdaki hata ayıklama(debugging) sembollerini dahil et.
      daha sonra hata ayıklama programı(gdb) tarafından kullanılacak.
• Wall
      Tüm uyarıları göster(program hala derlenebilir).
• -D<macro>
      macro '1' string'i ile tanımlanır
• -l<name>
      lib<name>.a adlı kütüphaneyi dahil eder.
• -I<path>
      verilen dizinde bulunan dosyalar dahil etmek(include) için bakar.
• L<path>
      verilen dizinden bulanan kütüphanelere bakar.

g++'nın kütüphaneler ve dahil edilen dosyalar için varsayılan dizinleri vardır.

g++ 'da tanımlar

Genellikle programlar aşağıdakilere dayanan koşullu parçalar içerir:
#ifdef DEBUG
printf(“value of var is %d”, var);
#endif

Önişlemci tanımlarını komut satırından ayarlayabilirsiniz:
g++ -DDEBUG -o prog prog.c

(genişletilecek...)

Derlemede'de make kullanımı

Çok sayıda dosya içeren orta ve büyük çaplı yazılım projelerini derlemek şu sebeblerden zor olur:

• Her seferinde tüm dosyaları doğru bir şekilde derlemek için komutların yazılması
• Hangi dosyaların değiştirildiğinin takip edilmesi
• Dosyalar arasındaki bağlılıkların takip edilmesi

make, bu işlemleri otomatikleştirir.

make'in temek işlemleri

Programı oluşturmak için, kurallar içeren [Mm]akefile adlı bir dosyayı okur.

• Eğer program başka bir dosyaya bağlıysa, ozaman bu dosya oluşturulur.
• Tüm bağımlılıklar bağımlılıklar zincirinde geri doğru çalışacak şekilde inşa(build)edilir.
• Programlar yalnızca bağlı(depend) oldukları dosyalardan daha eski ise inşa(built) edilebilir.

Temel Makefile Örnekleri

# mydb için Makefile
mydb: mydb.o user.o database.o
    g++ -o mydb mydb.o user.o database.o
mydb.o : mydb.cpp mydb.h
    g++ -c mydb.cpp
user.o : user.cpp mydb.h
    g++ -c user.cpp
database.o : database.cpp mydb.h
    g++ -c database.cpp

Bir Makefile'ın parçaları

Bağımlılık satırları:

• Hedef(target) adlarını ve bağımlılıklarını içerir (isteğe bağlı)
• bağımlılıklar(dependencies)
      Dosyalar
      hedefler Komutlar:
• bağımlılık satırın altında olmalı
• her zaman bir çıkıntıyla(tab) başla
• bağımlılığı karşılamak için komutlar

Makrolar(macros) ve özel değişkenler

Makefile'daki metni temsil etmek için makrolar kullanılır.

• yazarken kaydeder.
• Makefile'ın kolayca değiştirilmesine izin verir.
• atamalar(assignment)
      Kullanımı: ${MACRONAME}

Komutlarda özel değişkenler kullanılır:

• $@ hedefi temsil ediyor.
• $? bağımlılıkları temsil ediyor.

örneği basitleştirme

OBJS = mydb.o user.o database.o
CC = /usr/bin/g++

mydb: ${OBJS}
    ${CC} -o $@ $?
mydb.o: mydb.cpp mydb.h
    ${CC} -c $?
user.o: user.cpp mydb.h
    ${CC} -c $?
database.o: database.cpp mydb.h
    ${CC} -c $?

Make'i cağırmak (invoking make)

• açıklama dosyası olduğundan emin olun
      makefile veya Makefile olarak adlandırılır
      kaynak dosyalarının bulunduğu dizinde
• make
      dosyada ilk hedefi oluşturur
• make hedef(leri)
       hedef(leri) oluşturur(builds).
• diğer seçenekler:
       -n: komutları çalıştırma, sadece listele
       -f <file>: [Mm]akefile yerine <file> 'ı kullan.

Diğer Makefile Notları ve Son ek(suffix) kuralları

Yorumlar ‘#’ ile başlar
Bir satırın başına veya yorum olmayan bir satırın sonuna konulabilir.
Çok uzun olan satırlar, önceki satırın sonuna line \ koyarak bir sonraki satırda devam edebilir.

Son Ek Kuralları: her .o dosyasını kaynak dosyadan nasıl oluşturacağını söylemek hala sıkıcı. Sonek kuralları bu tür durumları genelleştirmek için kullanılabilir.

• Varsayılan bir sonek kuralı, komut tarafından çalıştırarak kaynak dosyalarını, .o dosyalarına dönüştürür:
      ${CC} ${CFLAGS} -c $&lt;
• $< , önkoşul anlamına gelir (file.cpp)

En Basit Makefile Örneği

OBJS = mydb.cpp user.cpp database.cpp
CC = /usr/bin/g++

mydb: ${OBJS}
    ${CC} -o $@ $?

Diğer Faydalı Makefile İpuçları

Ara dosyaları(intermediate) kaldırmanın bir yolunu dahil edin.

• clean:
      rm –f mydb
      rm -f * .o

çoklu programlar oluşturmak için bir hedef dahil edin.

• all: mydb mycalendar myhomework

Bölüm-10 Hata ayıklama (Debugging)

(pek yakında...)

Bölüm-11 Dosya yönetimi (File Management)

(devamı pek yakında...)

Sistem Çağrıları

Programlar, kütüphaneler üzerinden sistem çağrıları yapar. 

• libc, sistem çağrıları için C arayüzü sağlar.
• doğrudan Unix çekirdeğine bir altprogram çağrısı.

4 ana sistem çağrısı kategorisi:

• Dosya yönetimi.
• Süreç yönetimi.
• İletişim.
• Hata ve sinyal işleme.

Program yürütmek

• Özel bir başlatma rutini (crt0) her zaman programınıza bağlanır.
• Bu rutin argümanları okur ve main'i çağırır.
• Libc kütüphanesi programınıza otomatik olarak bağlanır; bu şekilde birçok C işlevine (printf, open, vb.) erişiminiz vardır.
• Programınız, çıkışta dosya tanımlayıcılarını kapatan ve diğer kaynakları temizleyen özel işlevler de çağırır.

C'ye karşı C++

• string veri türü yok
  Bunun yerine karakter dizileri kullanın Karakter dizilerini “atamak” için strcpy (), strncpy (), strcmp (), strncmp () kullanın.
• Gömülü beyan yok(embedded declarations)
  Tüm değişkenlerin bir kod bloğunun başlangıcında bildirilmesi gerekir
• Çok farklı Dosya ve Standart G / Ç fonksiyonları
  printf() cout'a karşı
  scanf() ve fgets() cin'e karşı

Arabelleksiz(unbeffered) G/Ç vs. Standart G/Ç

Arabelleksiz giriş/çıkış:

• sistem çağrılarını kullanarak g/ç gerçekleştirebilir.(open,read,write,close,lseek)
• arabellek boyutunu ve bayt'ların numarasını belirtmeniz gerekir.
• Biçimlendirme seçeneği yok.
• Bu fonksiyonlar dosya tanımlayıcılarını argüman olarak kullanır.
• Sabitler unistd.h'da tanımlanır(STDIN_FILENO, gibi).

Standart giriş/çıkış:

• Bir C kütüphanesi fonksiyon dizisi(printf,scanf,getc)
• Arabellekleme(bufferin) otomatik.
• Birçok biçimlendirme seçeneği
• stdio fonksiyonları ilkel sistem çağrılarından oluşur.
• Sabitler stdio.h'da tanımlanır(stdin, gibi).

Temel Dosya G/Ç

• Unix'de herşeyin bir dosya olduğunu hatırlayın ve unutmayın.

• çekirdek(kernel), her süreç için açık dosyaların bir listesini tutar.

• Dosyalar okuma,yazma için açılabilir.

• G/Ç sistem çağrılarını kullanmak için <stdio.h> dahil edilmelidir.(include)
       Not: Unix çekirdeği ile etkileşime girmek için kullanılan sistem çağrılarının bazıları diğer işletim sistemlerinde de mevcuttur. Bununla birlikte, bunlar çok farklı şekilde uygulanabilir (muhtemelen). Bazıları hiç mevcut değil.

• Çoğu Unix G/Ç, 5 sistem çağrısı ile yapılabilir.
       open, read, write, close, lseek

• Her dosya bir dosya tanımlayıcısı tarafından referans edilir(bir tam sayı)).

• Üç dosya otomatik olarak açılır:
       FD 0: standart giriş
       FD 1: standart çıkış
       FD 2: standart hata

• Yeni bir dosya açıldığı zaman, en küçük FD'ye atanır.

• man -s 2 (daha fazla bilgi almak için)

open()

int open(char *path, int flags, mode_t mode);
path: absolute(mutlak) veya relative(göreceli) path
flags(bayraklar):

• O_RDONLY - okumak için aç
• O_WRONLY - yazmak için aç
• O_RDWR - okuma ve yazma için aç
• O_CREAT - mevcut değilse dosyayı oluştur
• O_TRUNC - eğer varsa dosyayı keser (üzerine yazar).
• O_APPEND - sadece dosyanın sonuna yaz

modu: eğer O_CREAT kullanıyorsanız, izinleri açıkca belirtin
Yeni atanan dosya tanımlayıcısını döndürür.

• Oluşturulma izinleri:
      777 vs 0777 vs 0x777
       izinler:

  • read(r--,4)
  • write(-w-,2)
  • execute(--x,1)

  kim(who):

  • user(0700)
  • group(0070)
  • others(0007)

• fd = open(”name”, O_RDWR|O_CREAT, 0700);

• fd dönen değer:
      fd >= 0 – açma başarılır
      fd < 0 – açma başarısız

read() ve write()

ssize_t read(int fd, void *buf, size_t nbytes);
ssize_t write(int fd, void *buf, size_t nbytes);

• fd, open tarafından döndürülen değerdir.
• buf genellikle bir veri dizisidir
• nbayt buf boyutu(okunan) veya yazılacak veri boyutudur
• döndürülen değer:
      > 0 okunan veya yazılan bayt sayısıdır.
      <= okumak için nbayt
      0 EOF(dosya sonunun habercisi)
      < 0 error

read() örneği

bytes = read(fd, buffer, count);
Fd ile ilişkili dosyadan okur.
okunan bayt sayısını veya hata mesajı yani -1 değerini döndürür

int fd=open("someFile", O_RDONLY);
char buffer[4];
int bytes = read(fd, buffer, 4);

write() örneği

bytes = write(fd, buffer, count); Fd ile ilişkili dosyaya yazar.
yazılan bayt sayısını veya hata mesajı yani -1 değerini döndürür

int fd=open("someFile", O_WRONLY);
char buffer[4];
int bytes = write(fd, buffer, 4);

stdin'i stdout'a kopyalamak

#define BUFFSIZE 8192
// bu nasıl seçilir
int main(void) {

int n;
char buf[BUFFSIZE];
while ((n=read(STDIN_FILENO, buf, BUFFSIZE)) > 0)
  if (write(STDOUT_FILENO, buf, n) != n)
    printf("write error");
  if (n < 0)
    printf("read error");
}

close()

int close(int fd);

• fd ile ilişkili dosya kapatılır.
• başarı durumda 0, hata durumunda -1 döndürür.
• close(1);
       standart çıkışı kapatır.

lseek()

off_t lseek(int fd, off_t offset, int whence);

• Dosya işaretcisini(pointer) yeni konumuna taşır.
• fd, open tarafından döndürülen sayıdır.
• off_t , long veya int... değil, dörtlü olabilir.
• ofsett , bayt sayısıdır.
• nereden(whence):
      SEEK_SET – dosyanın başlangıcından itibaren ofsett(bayt sayısı kadar)
      SEEK_CUR – mevcut konumdan offsett
      SEEK_END – dosyanın sonundan ofsett
• Dosyanın başlangıcında veya hata durumunda offsett -1 döndürür.

lseek() örnekler

Standart girişin aranıp aranmayacağını test edelim.

int main(void) {
if (lseek(STDIN_FILENO, 0, SEEK_CUR)==-1)
    printf("cannot seek\n");
else
    printf("seek OK\n");
exit(0);
}

a.out < /etc/motd “seek OK ” verir.
$ cat < /etc/motd | a.out “cannot seek” verir
$ a.out < /var/spool/cron/FIFO “cannot seek” verir

char buf1[] = "abcdefghij“, buf2[] = "ABCDEFGHIJ";
int fd = creat("file.hole", FILE_MODE);
write(fd, buf1, 10);
lseek(fd, 40, SEEK_SET);
write(fd, buf2, 10);

a.out
$ ls -l file.hole      boyutunu kontrol et
-rw-r--r-- 1 root 50 Jul 31 05:50 file.hole

$ od -c file.hole      gerçek içeriğine bakalım

Bölüm-12 Süreç Yönetimi (Process Management)

Unix'te süreçler

Süreç(process): Temel yürütme birimi

• Bir programın çalıştırılması
• Bir süreç kimliğine sahiptir (PID)
• Bir süreç hiyerarşisinde oluşurlar (parents and children)
• Root(kök) başlangıç sürecidir.
• Her sürecin kendi durumu/içeriği/belleği vardır.

Süreçler ile ilgili shell komutları:
ps, top, kill, nice,...

süreç belirtmek

Dosya Nesneleri ve Dosya Tanımlayıcıları

Stdio kütüphanesi, arabellek(buffering) kullanan FILE nesneleri sağlar.

• FILE *stdin, *stdout, *stderr;

Neden arabelleğe alma? Verimlilik.
FILE nesneleri, dosya tanımlayıcıların üzerine inşa edilmiştir.
Süreç yönetimi görevleri için dosya tanımlayıcılarını kullanacağız.

Ara belleğe alma(Buffering)

• un-buffered(ara belleğe alınmamış):çıktı hemen görünür
       stderr arabelleğe alınmaz
• line buffered(satır ara belleğe alınmış): tam bir satır yazıldığı zaman çıktı görüntülenir.
       stdout, ekrana giderken arabelleğe alınan satırdır
• block buffered(blok ara belleğe alınmış): bir tampon doldurulduğunda veya bir tampon temizlendiğinde çıktı görünür.
      normalde bir dosyaya çıkış blok arabelleğe alınır.
      stdout bir dosyaya yönlendirildiğinde arabelleğe alınmış bloktur.

Dosya tanımlayıcıları

Düşük seviye I / O tarafından kullanılır:

• open(), close(), read(), write()

Bir tam sayı gibi tanımlanır.

• int fd;

Bir FILE nesnesini fd'ye dönüştürmek için kullanışlı bir sistem çağrısı.

• int fileno( FILE *fp);

Elbette bir dosya tanıtıcısına bir akış arayüzü atamak mümkündür.

• FILE *fdopen(int fd, const char *mode);

Süreç Yönetimi Sorunları

Sistem, aşağıdakilerle ilgilenmektedir:   - Bir süreç oluşturmak   - Programın ayarlanması bir süreç yürütür   - Bir i sonlandırılması bekleniyor

• Bir süreçin sonlandırılması.   - Bir süreçe sinyal gönderme.
• süreçler arasında iletişim kurmak

Unix'i başlatma

Hangi süreçlerin çalıştını görmek için: "top" , "ps -aux" komutlarını çalıştırın.

Yeni bir işlem oluşturmanın tek yolu mevcut bir işlemi kopyalamaktır. Bu nedenle tüm işlemlerin atası pid = 1 ile başlatılır.

Csh komutları nasıl çalıştırır?

• Bir komut yazıldığında, csh fork olur(yeni süreç doğurma) ve sonra yazılan komutu yürütür.
• fork'dan(çatallanma) sonra, dosya tanımlayıcıları 0, 1 ve 2, yeni süreçde hala stdin, stdout ve stderr'ye başvurur.
• Kurallara göre, yürütülen program bu tanımlayıcıları uygun şekilde kullanacaktır.

Süreç oluşturma

• fork sistemi çağrısı, çalışmakta olan programın bir kopyasını oluşturur.
• Kopya (child süreç) ve orijinal (parent süreç) her ikisi de fork noktasından aynı verilerle devam eder.
• Tek fark, fork çağrısından dönüş(return) değeridir.

Fork : PID'ler ve PPID'ler

• Sistem çağrısı: int fork() -fork() başarılı olursa, çocuk(child) PID'yi ebeveynine(parent) ve 0 değerini çocuğa döndürür;
• fork() başarısız olursa, parent'a -1 döndürür (alt öğe oluşturulmaz)
• İlgili sistem çağrıları:
      int getpid() - geçerli süreçin PID değerini döndürür
      int getppid() - parent süreçinin PID değerini döndürür (1'in ppid değeri 1'dir)
      int getpgrp() - geçerli sürecin grup ID'sini döndürür

fork() başarısız olduğunda

İki olası sebep:
Bir kullanıcının oluşturabileceği maksimum işlem sayısının bir sınırı vardır.Bu sınıra ulaşıldığında (yani, işlem tablosu dolu), daha sonraki fork() çağrıları -1 değerini döndürür.

Çekirdek işlemlere sanal bellek ayırır Belleği yetersiz kaldığında, fork çağrıları başarısız olur.

fork () özellikleri

Çocuk tarafından ebeveynden miras alınan özellikler:

• UID, GID
• kontrol terminali
• CWD, kök dizini
• sinyal maskesi, çevre, kaynak sınırları
• paylaşılan bellek segmentleri

Ebeveyn ve çocuk arasındaki farklar:

• PID, PPID, fork()'dan dönüş değeri
• Bekleyen alarmlar çocuk için silindi.
• Çocuk için bekleyen sinyaller silinir.

fork örneği:

int i, pid;
i = 5;
printf(“%d\n”, i);
pid = fork();
if(pid != 0)
    i = 6; /* sadece parent buraya gelir /
else
    i = 4; / sadece child buraya gelir */
printf(“%d\n”, i);

PID/PPID örneği:

#include <stdio.h>
#include <unistd.h>
int main(void) {
int pid;
printf("ORIG: PID=%d PPID=%d\n",getpid(), getppid());
pid = fork();
if(pid != 0)
    printf("PARENT: PID=%d PPID=%d\n",getpid(), getppid());
else
    printf("CHILD: PID=%d PPID=%d\n",getpid(), getppid());
return(1);
}

çıktı:
ORIG: PID=27989 PPID=27167
PARENT: PID=27989 PPID=27167
CHILD: PID=27990 PPID=27989

Program Yürütme (Executing a Program)

• Exec sistem çağrısı, bir süreç tarafından yürütülen programın yerine farklı bir program koyar.
• Yeni program baştan yürütmeye başlar. Başarı durumunda, exec asla geri değer döndürmez, başarısızlık durumunda exec -1 döndürür.

Örnek:

Program X:
int i = 5;
printf("%d\n", i);
exec(“Y”);
printf("%d\n", i);

Program Y:
printf("hello\n");

exec() özellikleri

Yeni süreç çağrılan sürecinden aşağıdakileri miras alır:

• PID ve PPID, gerçek UID, GID, oturum ID.
• kontrol terminali.
• CWD, kök dizini, kaynak limitleri.
• süreç sinyali maskesi.
• Bekleyen sinyaller
• Bekleyen alarmlar
• dosya modu oluşturma maskesi (umask).
• dosya kilitleri.

altı versiyon exec():

• execl(char *path, char *arg0, ..., (char *)0);
• execv(char *path, char *argv[]);
• execle(char *path, char *arg0, ..., (char *)0,char *envp[]);
• execve(char *pathname, char *argv[], char *envp[]);
• execlp(char *file, char *arg0, ..., (char *)0);
• execvp(char *file, char *argv[]);