2024-04-29 13:28:55 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
C ve Sistem Programcı ı
Sistem Programlama ve İleri C Uygulamalar - I Kursu
Sı ı ı
Eğitmen: Kaan ASLAN
Bu notlar Kaan ASLAN tarafı ı ı ı
(Notları
2024-06-09 22:42:45 +03:00
Son Güncelleme: 09/06/2024 - Pazar
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
1. Ders 27/05/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
2. Ders 03/06/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
3. Ders 04/06/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
4.Ders 10/06/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
strtok fonsiyonun prototipi şöyledir:
#include <string.h>
char *strtok(char *str, const char *delims);
Fonksiyon basit yazı ı ı ı ı ı ı
parametresi ayrı ı ı ı ı ı
ikinci parametresi ayrı ı ı ı ı ı
Fonksiyon şöyle çalı ı ı
yerini elde eder. Sonra ayı ı
o kı ı ı ı ı ı
çağrı ı ı ı ı ı ı ı ı ı ı ı ı ı
birinci parametre yerine NULL adres girilmelidir. Fonksiyon en sonunda yazı ı ı ı ı
Fonksiyonun tipik kullanuı ı ı
char *str;
for (str = strtok(s, delims); str != NULL; str = strtok(NULL, delims))
puts(str);
Tabii aynı ı
str = strtok(s, delimes);
while (str != NULL) {
puts(str);
str = strtok(NULL, delims);
}
Fonksiyonun birinci parametresiyle belirtilen dizi içerisindeki yazı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[] = " Ali, Veli, Selami ";
char *pstr;
pstr = strtok(s, ", ");
while (pstr != NULL) {
puts(pstr);
pstr = strtok(NULL, ", ");
}
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
strtok Fonksiyonun Kullanı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[] = "...,,,,,ali,...,,,veli,....,selami..,,,,,,hakan";
char *str;
for (str = strtok(s, ",."); str != NULL; str = strtok(NULL, ".,"))
puts(str);
return 0;
}
/* ------------------------------------------------------------------------------------------------------------------------------------------
strtok fonksiyonun kullanı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[] = " Ali, Veli, Selami ";
char *pstr;
for (pstr = strtok(s, ", "); pstr != NULL; pstr = strtok(NULL, ", "))
puts(pstr);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
strtok fonksiyonun kullanı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[] = "12/11/2009";
char *pstr;
for (pstr = strtok(s, "/"); pstr != NULL; pstr = strtok(NULL, "/"))
puts(pstr);
return 0;
}
/* ------------------------------------------------------------------------------------------------------------------------------------------
strtok Fonksiyonunun birinci parametresiyle aldı ı ı ı ı
tanı ı ı ı
char *s = "12/11/2009";
char *pstr;
for (pstr = strtok(s, "/"); pstr != NULL; pstr = strtok(NULL, "/"))
puts(pstr);
Burada s föstericisi artı ı ı
güncellenmesi "tanı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
int main(void)
{
char *s = "12/11/2009";
char *pstr;
for (pstr = strtok(s, "/"); pstr != NULL; pstr = strtok(NULL, "/"))
puts(pstr);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
İleride görüleceği gibi static yerel değişken ve global değişken kullanan fonksiyonlar thread güvenli (thread safe) değildir.
Bunları ı
thread güvenli biçimini strtok_s ismiyle bir eklenti biçiminde bulundurmuştur. Fonksiyonun prototipi şöyledir:
#include <string.h>
char *strtok_s(char *str, const char *delims, char **context);
Fonksiyonun strtok fonksiyonundna farkı ı ı ı
bu göstericiye kalı ı
Microsoft derleyicilerinde strtok fonksiyonun strtok_s ismiyle thread güvenli bir versiyonu da vardı
eşdeğeri GNU C kütüphanesinde strtok_r ismiyle bulunmaktadı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[] = "12/11/2009";
char *pstr;
char *pstrl;
for (pstr = strtok_s(s, "/", &pstrl); pstr != NULL; pstr = strtok_s(NULL, "/", &pstrl))
puts(pstr);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
strtok fonksiyonun gerçekleştirimi aşağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
char *mystrtok(char *str, const cha *delim)
{
static char *pos;
char *beg;
if (str != NULL)
pos = str;
while (*pos != '\0' && strchr(delim, *pos) != NULL)
++pos;
if (*pos == '\0')
return NULL;
beg = pos;
while (*pos != '\0' && strchr(delim, *pos) == NULL)
++pos;
if (*pos != '\0')
*pos++ = '\0';
return beg;
}
int main(void)
{
char s[] = "";
char *pstr;
for (pstr = mystrtok(s, ","); pstr != NULL; pstr = mystrtok(NULL, ","))
puts(pstr);
return 0;
}
/* ------------------------------------------------------------------------------------------------------------------------------------------
strtok fonksiyonun birinci parametresinin const olan (yani birinci parametresindeki yazı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
char *mystrtok(const char *str, const char *delim, char *dest)
{
static const char *pos;
const char *beg;
if (str != NULL)
pos = str;
while (*pos != '\0' && strchr(delim, *pos) != NULL)
++pos;
if (*pos == '\0')
return NULL;
beg = pos;
while (*pos != '\0' && strchr(delim, *pos) == NULL)
++pos;
strncpy(dest, beg, pos - beg);
dest[pos - beg] = '\0';
if (*pos != '\0') /* bu kontrol kaldı ı
++pos;
return dest;
}
int main(void)
{
char text[] = "10/12/2009";
char str[100];
char *pstr;
for (pstr = mystrtok(text, "/", str); pstr != NULL; pstr = mystrtok(NULL, "/", str))
puts(pstr);
return 0;
}
/* ------------------------------------------------------------------------------------------------------------------------------------------
strtok fonksiyonun dinamik bir alan tahsis edip o alana geri dönen versyionu. Ancak burada fonksiyon kullanan kişinin bu alanı
free etmesi gerekir. Ayrı ı ı ı ı ı ı ı ı ı ı ı ı
fonksiyonun NULL adrese geri döndüğü anlaşı ı ı
Aslı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char *mystrtok(const char *str, const char *delim)
{
static const char *pos;
const char *beg;
char *dstr;
if (str != NULL)
pos = str;
while (*pos != '\0' && strchr(delim, *pos) != NULL)
++pos;
if (*pos == '\0')
return NULL;
beg = pos;
while (*pos != '\0' && strchr(delim, *pos) == NULL)
++pos;
if ((dstr = (char *)malloc(pos - beg + 1)) == NULL)
return NULL;
strncpy(dstr, beg, pos - beg);
dstr[pos - beg] = '\0';
return dstr;
}
int main(void)
{
char text[] = "10/12/2009";
char *pstr;
for (pstr = mystrtok(text, "/"); pstr != NULL; pstr = mystrtok(NULL, "/")) {
puts(pstr);
free(pstr);
}
return 0;
}
/* ------------------------------------------------------------------------------------------------------------------------------------------
Bir dosyayı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_LINE 4096
int isall_space(const char *str)
{
while (*str != '\0' && isspace(*str))
++str;
return *str == '\0';
}
int main(void)
{
FILE *f;
char line[MAX_LINE];
char *str;
if ((f = fopen("test.csv", "r")) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
while (fgets(line, MAX_LINE, f) != NULL) {
if (isall_space(line))
continue;
if ((str = strchr(line, '\n')) != NULL)
*str = '\0';
for (str = strtok(line, ","); str != NULL; str = strtok(NULL, ","))
printf("%s\n", str);
printf("-----------------\n");
}
fclose(f);
return 0;
}
/* test.csv */
Ali Serçe, 100, 200, 300
Sacit Bulut, 12.3, 56.3, 78.2
Hakan Akyı ı
Hüsnü Biter, 12, 34, 34
/* ------------------------------------------------------------------------------------------------------------------------------------------
remove standart bir C fonksiyonudur. Yol ifadesi ile belirtilen dosyayı ı ı
#include <stdio.h>
int remove(const char *filename);
Fonksiyon başarı ı ı ı ı ı ı ı ı
söz konusu olabilir. Örneğin dosya yoktur bu nedenle silinemez. Ya da örneğin silinmek istenen dosyaya prosesin silme yetkisi olmayabilir.
Bu nedenle fonksiyonun başarı ı
Bir dosya remove fonksiyonuyla silindiğinde dosya "geri dönüş kutusunda (recycle bin)" saklanmaz. Geri dönüşüm kutusu yüksek seviyeli bir
kabuk organizasyonudur. Geri dönüş kutusuyla işletim sisteminin çekirdeğinin bir ilgisi yoktur.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
if (remove("test.txt") != 0) {
fprintf(stderr, "cannot remove file!..\n");
exit(EXIT_FAILURE);
}
printf("success..\n");
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir dosya bir program tarafı ı ı ı
açı ı ı ı ı ı ı ı
sistemlerinde de böyledir.Windows sistemlerinde ise açı ı ı ı ı
Aşağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
if ((f = fopen("test.txt", "r")) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
printf("File successfully opened...\n");
if (remove("test.txt")) {
fprintf(stderr, "cannot remove file!..\n");
exit(EXIT_FAILURE);
}
printf("file removed...\n");
fclose(f);
return 0;
}
/* ------------------------------------------------------------------------------------------------------------------------------------------
rename isimli standart C fonksiyonu dosyanı ı ı ı
Bu da taşı ı
#include <stdio.h>
int rename(const char *old, const char *new);
Fonksiyonun birinci parametresi ismi değiştirilecek dosyanı ı
Yukarı ı ı
işlev görmektedir. Tabii rename işlemi sı ı ı ı ı ı ı
değerine başarı ı ı
Yine rename işlemi çeşitli nedenelrden dolayı ı
yapmaya yetkili olmayabilir. Bu nedenle fonksiyonun başarı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
if (rename("test.txt", "mest.txt") == -1) {
fprintf(stderr, "cannot rename file!..\n");
exit(EXIT_FAILURE);
}
printf("Success...\n");
return 0;
}
/* ------------------------------------------------------------------------------------------------------------------------------------------
system fonksiyonu ilgili sistemdeki "komut yorumlayı ı ı ı ı ı
verdiğimiz komutu işlettiren standart bir C fonksiyonudur. Fonksiyonun prototipi şöyledir:
#include <stdlib.h>
int system(const char *string);
Fonksiyonun geri dönüş değerinin anlamı ı ı ı ı ı
fonksiyon aşarı ı ı ı ı ı ı ı ı ı ı ı
ileride daha ayrı ı ı ı ı
C derleyicisinin olduğu bir sistemde komut yorumlayı ı
komut yorumlayı ı ı ı ı ı ı ı ı ı
adres ile çağı ı ı ı ı ı ı ı ı ı
geri dönerse ilgili sistemd ekomut yorumlayı ı
Komut yorumlayı ı ı ı ı
vereceğiniz komutlar belli bir sistemdeki belli komut yaorumlayı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
system("ls -l");
return 0;
}
/* ------------------------------------------------------------------------------------------------------------------------------------------
Programı ı ı ı ı ı ı
(temporary files)" denilmektedir. Geçici dosyaları ı
çakı ı ı
tmpfile isimli standart C fonksiyonu olmayan bir dosya ismi ile bir dosyayı ı
geri döner. Böyle dosyalar kapatı ı ı
dolayı ı ı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
int i, val;
if ((f = tmpfile()) == NULL) {
fprintf(stderr, "cannot create temporary file!..\n");
exit(EXIT_FAILURE);
}
for (i = 0; i < 100; ++i)
if (fwrite(&i, sizeof(int), 1, f) != 1) {
fprintf(stderr, "cannot write file!..\n");
exit(EXIT_FAILURE);
}
fseek(f, 0, SEEK_SET);
while (fread(&val, sizeof(int), 1, f) > 0)
printf("%d\n", val);
if (ferror(f)) {
fprintf(stderr, "cannot read file!..\n");
exit(EXIT_FAILURE);
}
fclose(f);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
tmpfile fonksiyonu ile biz açı ı ı ı ı
bir isimle geçici dosya oluşturmak isteyebilir. Örneğin bir text dosyadaki bütün "ankara" yazı ı ı
işlemi dosya üzerinde yapmak hem yavaşlı ı ı ı
bu geçici dosyaya kopyalamak, ancak bu sı ı ı ı ı ı
ası ı ı ı ı
tmpnam isimli standart C fonksiyonu geçici dosyayı ı
açmak programcı ı ı
#include <stdio.h>
char *tmpnam(char *s);
Fonksiyonun parametresi geçici dosya isminin yerleştirileceği dizinin adresini almaktadı ı ı
adres de geçilebilir. Bu durumda fonksiyon geçici dosya ismini static yerel bir dizinin içerisine yerleştirir ve o dizinin
adresiyle geri döner. Eğer argüman olarak NULL adres geçilmezse fonksiyon argüman olarak geçilmiş olan adresin aynı ı
Fonksiyonun en az TMP_MAX (<stdio.h> içerisinde define edilmiştir) dosya ismi üretebileceği garanti edilmiştir. Ancak makul bir limit aşı ı ı
fonksiyon başarı ı ı
içerisinde L_tmpnam isimli bir sembolik sabit de bulundurulmuştur.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* ------------------------------------------------------------------------------------------------------------------------------------------
Bir dosyadaki # ile başlayan satı ı ı ı ı ı ı ı ı ı ı
yol ifadesini belirtir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define MAX_LINE 8192
int issharp(const char *line);
int main(int argc, char *argv[])
{
FILE *f, *ftemp;
char line[MAX_LINE];
char *path;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((path = tmpnam(NULL)) == NULL) {
fprintf(stderr, "cannot get temporary file!..\n");
exit(EXIT_FAILURE);
}
if ((f = fopen(argv[1], "r")) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
if ((ftemp = fopen(path, "w")) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
while (fgets(line, MAX_LINE, f) != NULL) {
if (!issharp(line))
if (fputs(line, ftemp) == EOF) {
fprintf(stderr, "cannot write file temporary file!..\n");
goto FAILURE;
}
}
if (ferror(f)) {
fprintf(stderr, "cannot read file: %s\n", argv[1]);
goto FAILURE;
}
fclose(f);
fclose(ftemp);
if (remove(argv[1]) != 0) {
fprintf(stderr, "cannot remove file!..\n");
goto FAILURE;
}
if (rename(path, argv[1]) != 0) {
fprintf(stderr, "cannot rename file!..\n");
exit(EXIT_FAILURE);
}
printf("sucess...\n");
exit(EXIT_SUCCESS);
FAILURE:
fclose(ftemp);
if (remove(path) != 0)
fprintf(stderr, "cannot remove file!..\n");
exit(EXIT_FAILURE);
return 0;
}
int issharp(const char *line)
{
while (isspace(*line))
++line;
return *line == '#';
}
/*------------------------------------------------------------------------------------------------------------------------------------------
6.Ders 17/06/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir programı ı ı ı ı ı ı ı ı ı ı ı ı
denilmektedir. Örneğin:
prog ali veli selami
Burada çalı ı ı ı ı ı ı ı ı ı ı
oluşturmaktadı ı ı ı ı ı ı ı ı ı ı ı ı
C'de programı ı ı ı ı ı ı ı ı ı ı
kabuk (shell) programı ı ı ı ı ı ı
parametrik yapı ı
int main(void)
int main(int argc, char *argv[])
Tabii burada argc va argv isimleri gelenekseldir. Bu isimlerin kullanı ı ı
int türden olması ı ı
belirtmektedir. Anı ı ı ı
main fonksiyonu şöyle de yazı
int main(int argc, char **argv)
Buradaki argc komut satı ı ı ı ı ı ı
üzere komut satı ı ı ı ı ı ı
NULL adresin bulunucağı ı ı ı
Burada önemli noktalardan biri bu argc ve argv parametrelerinin main fonksiyonuna kim tarafı ı ı ı ı ı ı
satı ı ı ı ı ı ı ı ı ı ı ı ı ı
oluşturur. Bu gösteri dizisinin adresini main fonksiyonuna geçirir. Tabii sürecin bazı ı ı ı ı ı ı
duracağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Klavyeden (stdin dosyası ı ı ı ı ı
yazı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#define MAX_CMDLINE 4096
#define MAX_ARGV 1024
int main(void)
{
char cmdline[MAX_CMDLINE];
char *argv[MAX_ARGV];
char *str;
int argc;
fgets(cmdline, MAX_CMDLINE, stdin);
argc = 0;
for (str = strtok(cmdline, " \t"); str != NULL; str = strtok(NULL, " \t"))
argv[argc++] = str;
argv[argc] = NULL;
printf("-------------\n");
for (int i = 0; i < argc; ++i)
puts(argv[i]);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Komut satı ı ı ı ı ı ı ı
seçenek argümanlardan faydalanı ı ı ı ı ı ı ı ı
Seçenek belirtme işlemi UNIX/Linux dünyası ı ı ı
gcc -c sample.c
cl /c sample.c
Burada UNIX/Linux sistemlerindeki gcc derleyicisinin -c seçeneği "derle fakat link etme" anlamı
sistemlerinde Microsoft C derleyicilerindeki /c seçeneği de aynı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux dünyası ı ı ı ı ı ı ı ı
Bu biçime "GNU biçimi" de denilmektedir. Biz de kursumuzda UNIX/Linux dünyası ı ı ı
GNU stilinde komut satı ı ı ı ı
1) Argümansı
2) Argümanlı
3) Seçeneksiz argümanlar
Argümansı ı ı ı ı ı ı
dikkate alı ı
ls -l -i /usr/include
Burada -l ve -i argümansı ı ı ı
karakterden oluşturulduğu için birleştirilebilmektedir. Örneğin:
ls -li
Buradaki -li aslı ı ı ı ı ı
Yani örneğin:
ls -l -i
ile
ls -i -l
arası ı ı
Argümanlı ı
gcc -o sample sample.c
Burada -o seçeneği seçeneği tek başı ı ı ı ı ı
-o seçeneği tipik olarak argümanlı ı
Örneğin:
gcc -co sample.o sample.c
Bu yazı ı ı
gcc -c -o sample.o sample.c
Programlar argümanlı ı ı
gcc -osample sample.c
Burada -o argümanlı ı ı
ele alı ı
Seçeneklerle ilgisi olmayan argümanlara "seçeneksiz argüman" denilmektedir. Örneğin:
gcc -o sample sample.c
Burada "sample.c" argümanı
cp x.txt y.txt
Buradaki "x.txt" ve "y.txt" argümanları ı ı
gcc sample.c -o sample
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Eskiden yalnı ı ı ı ı ı ı ı
okunabilirliği bozduğu gerekçesiyle uzun seçenekler de kullanı ı ı ı
Ancak UNIX/Linux dünyası ı ı ı ı ı
prog --count -a -b --length 100
Uzun seçenkler de arümanlı ı ı ı ı
ve "--length 100" ise argümanlı
Uzun seçeneklerde "isteğe bağlı ı ı ı
uzun seçeneklerde yanı ı ı ı ı ı
yapı ı
prog --size=512
Burada --size uzun seçeneğinin argümanı ı ı ı ı ı
prog --size
Genel olarak bugün programlar kı ı ı ı ı
alternatif uzun seçeneklerini oluşturabilmektedir. Yukarı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı ı ı ı ı ı ı
henüz bu biçimin tam oturmadı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux dünyası ı ı ı ı ı
getopt fonksiyonu bir POSIX fonksiyonudur. Ancak bu fonksiyon uzun seçenekleri parse etmemektedir. getopt_long ise uzun seçenekleri de parse eden
getopt fonksiyonunun daha gelişmiş bir biçimidir. Ancak getopt_long bir POSIX fonksiyonu değildir. Ancak libc kütüphanesinde bulunmaktadı
Bu fonksiyonlar Windows sistemlerinde hazı ı ı
sistemlerindeki komut satı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
getopt fonksiyonunun prototipi şöyledir:
#include <unistd.h>
int getopt(int argc, char * const argv[], const char *optstring);
getopt fonksiyonunun ilk iki paramteresi main fonksiyonunun argc ve argv parametreleri gibidir. Yani programcı
getopt fonksiyonuna geçirir. Fonksiyon üçüncü parametresinde kı ı
Bu yazı ı ı
argümanlı ı
vardı
getopt fonksiyonu bir kez çağrı ı ı ı ı ı ı ı ı
Fonksiyon bütün kı ı ı ı
çağrı ı ı ı
int result;
...
while ((result = getopt(argc, argv, "ab:c")) != -1) {
...
}
getopt her kı ı ı ı ı ı
O halde bizim getopt fonksiyonunun geri dönüş değerini switch içerisinde ele almamaı
while ((result = getopt(argc, argv, "ab:c")) != -1) {
switch (result) {
case 'a':
...
break;
case 'b':
...
break;
case 'c':
...
break;
}
}
getopt fonksiyonu olmayan (yani üçüncü parametresinde belirtilmeyen) bir kı ı ı ı ı ı
halde girilmemiş bir kı ı ı ı ı ı
ekleyerel bu durumu da değerlendirmesi uygun olur. Örneğin:
while ((result = getopt(argc, argv, "ab:c")) != -1) {
switch (result) {
case 'a':
...
break;
case 'b':
...
break;
case 'c':
...
break;
case '?':
...
break;
}
}
getopt fonksiyonunun kullandı ı ı ı ı ı ı
extern bildirimi ile kullanabiliriz. Ancak bunları ı ı ı ı
extern int opterr;
extern int optopt;
extern int optind;
extern char *optarg;
Default durumda getopt fonksiyonu geçersiz bir seçenekle (yani üçüncü parametresinde belirtilmeyen bir seçenekle) karşı ı ı
stderr dosyası ı ı ı ı ı ı ı
hata geçersiz seçenekler için hata mesajı ı ı ı ı ı ı ı
bir değerdeyse (default durum) fonksiyon mesajı ı ı ı ı ı ı
yazmaz.
getopt fonksiyonu geçersiz bir seçenekle ya da argümanı ı ı ı ı ı
optopt global değişkenine geçersiz seçeneğin karakter karşı ı ı ı ı
Örneğin:
opterr = 0;
while ((result = getopt(argc, argv, "ab:c")) != -1) {
switch (result) {
case 'a':
printf("-a given...\n");
break;
case 'b':
printf("-b given...\n");
break;
case 'c':
printf("-c given...\n");
break;
case '?':
if (optopt == 'b')
fprintf(stderr, "-b option given without argument!..\n");
else
fprintf(stderr, "invalid option: -%c\n", optopt);
break;
}
}
Argümanlı ı ı ı ı
set eder. Ancak optarg yeni bir argümanlı ı ı ı
programcı ı ı ı ı ı
Pekiyi seçeneksiz argümnalrı ı
fonksiyonu her zaman seçeneksiz argümanları ı ı ı ı ı
değişkeninin göstermesini sağlar. O halde programcı ı ı
indeksinden argc indeksine kadar ilerleyerek tüm seçeneksiz argümanları
./sample -a ali -b veli selami -c
Burada "ali" ve "selami" seçeneksiz argümanlardı
./sample -a -b veli -c ali selami
Şimdi burada optind indeksi artı ı ı ı ı
Bu argümanları ı ı
for (int i = optind; i < argc; ++i)
puts(argv[i]);
Programcı ı ı ı ı ı ı
bir kalı
- Her seçenek için bir flag değişkeni tutulur. Bu flag değişkenlerine başlangı ı
- Her argümanlı
- Her seçenekle karşı ı ı ı ı ı ı
- Argümanlı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* ------------------------------------------------------------------------------------------------------------------------------------------
getopt fonksiyonunun kullanı ı ı ı
ise argümanlı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
int result;
int a_flag, b_flag, c_flag;
char *b_arg;
a_flag = b_flag = c_flag = 0;
opterr = 0;
while ((result = getopt(argc, argv, "ab:c")) != -1) {
switch (result) {
case 'a':
a_flag = 1;
break;
case 'b':
b_flag = 1;
b_arg = optarg;
break;
case 'c':
c_flag = 1;
break;
case '?':
if (optopt == 'b')
fprintf(stderr, "-b option given without argument!..\n");
else
fprintf(stderr, "invalid option: -%c\n", optopt);
break;
}
}
if (a_flag)
printf("-a given...\n");
if (b_flag)
printf("-b given with argument \"%s\"...\n", b_arg);
if (c_flag)
printf("-a given...\n");
if (argc - optind != 0)
printf("argument without options:\n");
for (int i = optind; i < argc; ++i)
puts(argv[i]);
return 0;
}
/* ------------------------------------------------------------------------------------------------------------------------------------------
Ayrı ı ı ı
Bunun için bir flag değişkenindne faydalanı ı ı
program sonlandı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
int result;
int a_flag, b_flag, c_flag, err_flag;
char *b_arg;
a_flag = b_flag = c_flag = err_flag = 0;
opterr = 0;
while ((result = getopt(argc, argv, "ab:c")) != -1) {
switch (result) {
case 'a':
a_flag = 1;
break;
case 'b':
b_flag = 1;
b_arg = optarg;
break;
case 'c':
c_flag = 1;
break;
case '?':
if (optopt == 'b')
fprintf(stderr, "-b option given without argument!..\n");
else
fprintf(stderr, "invalid option: -%c\n", optopt);
err_flag = 0;
break;
}
}
if (err_flag)
exit(EXIT_FAILURE);
if (a_flag)
printf("-a given...\n");
if (b_flag)
printf("-b given with argument \"%s\"...\n", b_arg);
if (c_flag)
printf("-a given...\n");
if (argc - optind != 0)
printf("argument without options:\n");
for (int i = optind; i < argc; ++i)
puts(argv[i]);
return 0;
}
/* ------------------------------------------------------------------------------------------------------------------------------------------
7.Ders 18/06/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
getopt fonksiyonun kullanı ı ı ı ı ı ı
-x (display hex)
-o (display octal)
-t (display text)
-n (number of character per line)
Burada -x, -o ve -t seçeneklerinden yalnı ı ı
biçimindedir. -n seçeneği yalnı ı
bir belirleme yapı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* disp.c */
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdbool.h>
#include <unistd.h>
#define DEFAULT_LINE_CHAR 16
bool disp_text(FILE *f);
bool disp_hex(FILE *f, int n_arg);
bool disp_octal(FILE *f, int n_arg);
int check_number(const char *str);
int main(int argc, char *argv[])
{
int result;
int t_flag, o_flag, x_flag, n_flag, err_flag;
int n_arg;
FILE *f;
t_flag = o_flag = x_flag = n_flag = err_flag = 0;
n_arg = DEFAULT_LINE_CHAR;
opterr = 0;
while ((result = getopt(argc, argv, "toxn:")) != -1) {
switch (result) {
case 't':
t_flag = 1;
break;
case 'o':
o_flag = 1;
break;
case 'x':
x_flag = 1;
break;
case 'n':
n_flag = 1;
if ((n_arg = check_number(optarg)) < 0) {
fprintf(stderr, "-n argument is invalid!..\n");
err_flag = 1;
}
break;
case '?':
if (optopt == 'n')
fprintf(stderr, "-%c option given without argument!..\n", optopt);
else
fprintf(stderr, "invalid option: -%c\n", optopt);
err_flag = 1;
break;
}
}
if (err_flag)
exit(EXIT_FAILURE);
if (t_flag + o_flag + x_flag > 1) {
fprintf(stderr, "only one of -[tox] option may be specified!..\n");
exit(EXIT_FAILURE);
}
if (t_flag + o_flag + x_flag == 0)
t_flag = 1;
if (t_flag && n_flag) {
fprintf(stderr, "-n option cannot be used with -t option!..\n");
exit(EXIT_FAILURE);
}
if (argc - optind == 0) {
fprintf(stderr, "file must be specified!..\n");
exit(EXIT_FAILURE);
}
if (argc - optind > 1) {
fprintf(stderr, "too many files specified!..\n");
exit(EXIT_FAILURE);
}
if ((f = fopen(argv[optind], t_flag ? "r" : "rb")) == NULL) {
fprintf(stderr, "cannot open file: %s\n", argv[optind]);
exit(EXIT_FAILURE);
}
if (t_flag)
result = disp_text(f);
else if (x_flag)
result = disp_hex(f, n_arg);
else if (o_flag)
result = disp_octal(f, n_arg);
if (!result) {
fprintf(stderr, "canno read file: %s\n", argv[optind]);
exit(EXIT_FAILURE);
}
fclose(f);
return 0;
}
bool disp_text(FILE *f)
{
int ch;
while ((ch = fgetc(f)) != EOF)
putchar(ch);
return feof(f);
}
bool disp_hex(FILE *f, int n_arg)
{
size_t i;
int ch;
for (i = 0;(ch = fgetc(f)) != EOF; ++i) {
if (i % n_arg == 0) {
if (i != 0)
putchar('\n');
printf("%08zX ", i);
}
printf("%02X ", ch);
}
putchar('\n');
return feof(f);
}
bool disp_octal(FILE *f, int n_arg)
{
size_t i;
int ch;
for (i = 0;(ch = fgetc(f)) != EOF; ++i) {
if (i % n_arg == 0)
printf("%08zo ", i);
printf("%03o ", ch);
if (i % n_arg == n_arg - 1)
putchar('\n');
}
putchar('\n');
return feof(f);
}
int check_number(const char *str)
{
const char *temp;
int result;
while (isspace(*str))
++str;
temp = str;
while (isdigit(*str))
++str;
if (*str != '\0')
return -1;
result = atoi(temp);
if (!result)
return -1;
return result;
}
/* ------------------------------------------------------------------------------------------------------------------------------------------
getopt kullanı ı ı ı ı ı ı ı
Uygulanacak işlemler seçeneklerle belirtmiştir. Seçenekler şunlardı
-a (addition)
-s (subtraction)
-m (multiplication)
-d (division)
Programı ı ı
./mycalc [-asmd] <number1> <number2>
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* mycalc.h */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
int result;
int a_flag, s_flag, m_flag, d_flag;
int err_flag;
double arg1, arg2, val_result;
opterr = 0;
a_flag = s_flag = m_flag = d_flag = 0;
err_flag = 0;
while ((result = getopt(argc, argv, "asmd")) != -1) {
switch (result) {
case 'a':
a_flag = 1;
break;
case 's':
s_flag = 1;
break;
case 'm':
m_flag = 1;
break;
case 'd':
d_flag = 1;
break;
case '?':
fprintf(stderr, "invalid option: -%c\n", optopt);
err_flag = 1;
}
}
if (err_flag)
exit(EXIT_FAILURE);
if (a_flag + s_flag + m_flag + d_flag != 1) {
fprintf(stderr, "exactly one option must be specified!..\n");
exit(EXIT_FAILURE);
}
if (argc - optind != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
arg1 = strtod(argv[optind], NULL);
arg2 = strtod(argv[optind + 1], NULL);
if (a_flag)
val_result = arg1 + arg2;
else if (s_flag)
val_result = arg1 - arg2;
else if (m_flag)
val_result = arg1 * arg2;
else
val_result = arg1 / arg2;
printf("%f\n", val_result);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
8. Ders 01/07/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Daha önceden de belirttiğimiz gibi komut satı ı ı ı ı
sistemdeki çeşitli yardı ı ı ı
bulunmaktadı ı ı ı ı ı
Uzun seçenekleri parse etmek için getopt_long isimli fonksiyon kullanı ı ı ı ı
getopt_long fonksiyonu da bir POSIX fonksiyonu değildir. Ancak GNU'nun glibc kütüphanesinde bir eklenti biçiminde bulunmaktadı
getopt_long fonksiyonu işlevsel olarak getopt fonksiyonunu kapsamaktadı ı ı
prototipi şöyledir:
#include <getopt.h>
int getopt_long(int argc, char * const argv[], const char *optstring, const struct option *longopts, int *longindex);
Fonksiyonun birinci ve ikinci parametrelerine main fonksiyonundan alı
yine kı ı ı ı ı ı
Fonksiyonun dördüncü parametresi uzun seçeneklerin belirtildiği struct option türünden bir yapı ı
struct option türünden bir nesneyle ifade edilmektedir. struct option yapı ı
struct option {
const char *name;
int has_arg;
int *flag;
int val;
};
Fonksiyon bu yapı ı ı ı ı ı ı
doldurulmalı ı ı ı ı ı
struct option yapı ı ı ı ı ı ı
no_argument (0)
required_argument (1)
optional_argument (2)
Bu eleman uzun seçeneğin argüman alı ı ı ı ı ı ı ı ı ı
uzun seçenek bulunduğunda bunun hangi sayı ı
uzun seçenek bulunduğunda bu val değeri bu int nesneye yerleştirilir. getopt_long iğse bu udurmda 0 değeri ile geri döner. Ancak bu flag
göstewricisine NULL adres de geçilebilir. Bu durumda getopt_long uzun seçenek bulunduğunda val elemanı
Örneğin:
struct option options[] = {
{"count", required_argument, NULL, 'c'},
{0, 0, 0, 0}
};
Burada uzun seçenek "--count" biçimindedir. Bir argümanla kullanı ı
geçildiği için getopt_long fonksiyonu 'c' değeri ile geri dönecektir. Örneğin:
int count_flag;
...
struct option options[] = {
{"count", required_argument, &count_flag, 1},
{0, 0, 0, 0}
};
Burada artı
getopt_long fonksiyonunun son parametresi uzun seçenek bulunduğunda o uzun seçeneğin option dizisindeki kaçı ı
anlamak için kullanı ı ı
Ancak bu bilgiye genellikle gereksinim duyulmamaktadı ı
Bu durumda getopt_long fonksiyonunun geri dönüş değeri beş biçimden biri olabilir:
1) Fonksiyon bir kı ı
2) Fonksiyon bir uzun seçenek bulmuştur ve option yapı ı ı ı ı ı ı ı
val elemanı
3) Fonksiyon bir uzun seçenek bulmuştur ve option yapı ı ı ı
yerleştirir ve 0 değeri ile geri döner.
4) Fonksiyon geçersiz (yani olmayan) bir kı ı ı ı ı ı
argümanı
5) Parse edecek argüman kalmamı ı
getopt fonksiyonundaki yardı ı ı ı ı ı
opterr: Hata mesajı ı ı ı ı ı ı ı ı
optarg: Argümanlı ı ı ı ı
ve bu uzun seçenek için argüman girilmemişse optarg nesnesine NULL adres yerleştirilmektedir.
optind: Bu değişken yine seöeneksiz argümanları ı ı
optopt: Bu değişken geçerisz bir uzun ya da kı ı
getopt_long geçersiz bir seçenekle karşı ı ı
1) Eğer fonksiyon argümanlı ı ı ı ı ı ı ı
optopt değişkenine yerleştirir.
2) Eğer fonksiyon argümanlı ı ı ı
optopt değişkenine yerleştirmektedir.
3) Eğer fonksiyon geçersiz bir kı ı ı ı ı ı ı
4) Eğer fonksiyon geçersiz bir uzun seçenekle karşı ı
Maalesef getopt_long olmayan bir uzun seçenek girildiğinde bunubize vermemektedir. Ancak GNU'nun getopt_long gerçekleştirimine bakı ı ı
bu geçersiz uzun seçeneğin argv dizisinin "optind - 1" indeksinde olduğu görülmektedir. Yani bu geçersiz uzun seçeneğe argv[optind - 1]
ifadesi ile erişilebilmektedir. Ancak bu durum glibc dokümanları ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı
-a
-b
-c <arg> ya da --count <arg>
--verbose
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
int main(int argc, char *argv[])
{
int a_flag, b_flag, c_flag, verbose_flag;
int err_flag;
char *c_arg;
int result;
struct option options[] = {
{"count", required_argument, NULL, 'c'},
{"verbose", no_argument, &verbose_flag, 1},
{0, 0, 0, 0}
};
a_flag = b_flag = c_flag = verbose_flag = err_flag = 0;
opterr = 0;
while ((result = getopt_long(argc, argv, "abc:", options, NULL)) != -1) {
switch (result) {
case 'a':
a_flag = 1;
break;
case 'b':
b_flag = 1;
break;
case 'c':
c_flag = 1;
c_arg = optarg;
break;
case '?':
if (optopt == 'c')
fprintf(stderr, "option -c or --count without argument!..\n");
else if (optopt != 0)
fprintf(stderr, "invalid option: -%c\n", optopt);
else
fprintf(stderr, "invalid long option!..\n");
/* fprintf(stderr, "invalid long option: %s\n", argv[optind - 1]); */
err_flag = 1;
break;
}
}
if (err_flag)
exit(EXIT_FAILURE);
if (a_flag)
printf("-a option given\n");
if (b_flag)
printf("-b option given\n");
if (c_flag)
printf("-c or --count option given with argument \"%s\"\n", c_arg);
if (verbose_flag)
printf("--verbose given\n");
if (optind != argc) {
printf("Arguments without options");
for (int i = optind; i < argc; ++i)
printf("%s\n", argv[i]);
}
return 0;
}
/* ------------------------------------------------------------------------------------------------------------------------------------------
getopt_long fonksiyonun kullanı ı ı ı ı ı ı ı ı
-a
-b <arg>
-c
-h ya da --help
--count <arg>
--line[=<arg>]
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
int main(int argc, char *argv[])
{
int result;
int a_flag, b_flag, c_flag, h_flag, count_flag, line_flag;
char *b_arg, *count_arg, *line_arg;
int err_flag;
int i;
struct option options[] = {
{"help", no_argument, &h_flag, 1},
{"count", required_argument, NULL, 2},
{"line", optional_argument, NULL, 3},
{0, 0, 0, 0 },
};
a_flag = b_flag = c_flag = h_flag = count_flag = line_flag = 0;
err_flag = 0;
opterr = 0;
while ((result = getopt_long(argc, argv, "ab:ch", options, NULL)) != -1) {
switch (result) {
case 'a':
a_flag = 1;
break;
case 'b':
b_flag = 1;
b_arg = optarg;
break;
case 'c':
c_flag = 1;
break;
case 'h':
h_flag = 1;
break;
case 2: /* --count */
count_flag = 1;
count_arg = optarg;
break;
case 3: /* --line */
line_flag = 1;
line_arg = optarg;
break;
case '?':
if (optopt == 'b')
fprintf(stderr, "-b option must have an argument!..\n");
else if (optopt == 2)
fprintf(stderr, "argument must be specified with --count option\n");
else if (optopt != 0)
fprintf(stderr, "invalid option: -%c\n", optopt);
else
fprintf(stderr, "invalid long option!..\n");
err_flag = 1;
break;
}
}
if (err_flag)
exit(EXIT_FAILURE);
if (a_flag)
printf("-a option given...\n");
if (b_flag)
printf("-b option given with argument \"%s\"...\n", b_arg);
if (c_flag)
printf("-c option given...\n");
if (h_flag)
printf("-h or --help option given...\n");
if (count_flag)
printf("--count option specified with \"%s\"...\n", count_arg);
if (line_flag) {
if (line_arg != NULL)
printf("--line option given with optional argument \"%s\"\n", line_arg);
else
printf("--line option given without optional argument...\n");
}
if (optind != argc) {
printf("Arguments without options:\n");
for (i = optind; i < argc; ++i)
printf("%s\n", argv[i]);
}
return 0;
}
/* ------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
-x: Hex olarak görünler
-o: Octal olarak görüntüler
-t: Yazı
-h ya da --header: Her dosyanı ı
--line[=<arg>]: Bu argüman hiç belirtilezse tüm dosya görüntülenir. İsteğe bağlı ı
İsteğe bağlı ı
myod [--top --header -x -o -t -h] <dosya listesi>
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* myod.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <getopt.h>
/* Symbolic Constans */
#define DEF_LINE 10
#define HEX_OCTAL_LINE_LEN 16
/* Function Prorotypes */
int print_text(FILE *f, int nline);
int print_hex_octal(FILE *f, int nline, int hexflag);
int main(int argc, char *argv[])
{
int result, err_flag = 0;
int x_flag = 0, o_flag = 0, t_flag = 0, top_flag = 0, header_flag = 0;
char *top_arg;
struct option options[] = {
{"top", optional_argument, NULL, 1},
{"header", no_argument, NULL, 'h'},
{0, 0, 0, 0}
};
FILE *f;
int i, nline = -1;
opterr = 0;
while ((result = getopt_long(argc, argv, "xoth", options, NULL)) != -1) {
switch (result) {
case 'x':
x_flag = 1;
break;
case 'o':
o_flag = 1;
break;
case 't':
t_flag = 1;
break;
case 'h':
header_flag = 1;
break;
case 1:
top_flag = 1;
top_arg = optarg;
break;
case '?':
if (optopt != 0)
fprintf(stderr, "invalid switch: -%c\n", optopt);
else
fprintf(stderr, "invalid switch: %s\n", argv[optind - 1]); /* argv[optind - 1] dokümante edilmemiş */
err_flag = 1;
}
}
if (err_flag)
exit(EXIT_FAILURE);
if (x_flag + o_flag + t_flag > 1) {
fprintf(stderr, "only one option must be specified from -o, -t, -x\n");
exit(EXIT_FAILURE);
}
if (x_flag + o_flag + t_flag == 0)
t_flag = 1;
if (top_flag)
nline = top_arg != NULL ? (int)strtol(top_arg, NULL, 10) : DEF_LINE;
if (optind == argc) {
fprintf(stderr, "at least one file must be specified!..\n");
exit(EXIT_FAILURE);
}
for (i = optind; i < argc; ++i) {
if ((f = fopen(argv[i], "rb")) == NULL) {
fprintf(stderr, "cannot open file: %s\n", argv[i]);
continue;
}
if (header_flag)
printf("%s\n\n", argv[i]);
if (t_flag)
result = print_text(f, nline);
else if (x_flag)
result = print_hex_octal(f, nline, 1);
else
result = print_hex_octal(f, nline, 0);
if (i != argc - 1)
putchar('\n');
if (!result)
fprintf(stderr, "cannot read file: %s\n", argv[i]);
fclose(f);
}
return 0;
}
int print_text(FILE *f, int nline)
{
int ch;
int count;
if (nline == -1)
while ((ch = fgetc(f)) != EOF)
putchar(ch);
else {
count = 0;
while ((ch = fgetc(f)) != EOF && count < nline) {
putchar(ch);
if (ch == '\n')
++count;
}
}
return !ferror(f);
}
int print_hex_octal(FILE *f, int nline, int hexflag)
{
int ch, i, count;
const char *off_str, *ch_str;
off_str = hexflag ? "%07X " : "%012o";
ch_str = hexflag ? "%02X%c" : "%03o%c";
if (nline == -1)
for (i = 0; (ch = fgetc(f)) != EOF; ++i) {
if (i % HEX_OCTAL_LINE_LEN == 0)
printf(off_str, i);
printf(ch_str, ch, i % HEX_OCTAL_LINE_LEN == HEX_OCTAL_LINE_LEN - 1 ? '\n' : ' ');
}
else {
count = 0;
for (i = 0; (ch = fgetc(f)) != EOF && count < nline; ++i) {
if (i % HEX_OCTAL_LINE_LEN == 0)
printf(off_str, i);
printf(ch_str, ch, i % HEX_OCTAL_LINE_LEN == HEX_OCTAL_LINE_LEN - 1 ? '\n' : ' ');
if (ch == '\n')
++count;
}
}
if (i % HEX_OCTAL_LINE_LEN != 0)
putchar('\n');
return !ferror(f);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
İşletim sistemlerinin çekirdekleri C Programlama Dili kullanı ı ı ı ı ı ı ı
işletim sistemlerinin bütün çekirdek kodları ı ı ı ı ı
"nesne yönelimli (object oriented)" değil "prosedürel teknikle" yazı ı ı
İşletim sistemlerinin çekirdeklerindeki bir grup fonksiyon dı ı ı ı ı ı
"işletim sisteminin sistem fonksiyonları
dosya silme gibi, başka bir programı ı ı ı ı ı ı
Biz bir dosyasyı ı ı ı
Yani fopen fonksiyonu aslı ı ı ı ı ı
Uygulama programcı ı ı ı ı ı ı ı
olan fonksiyonları ı
İşletim sistemlerinin sistem fonksiyonları ı ı ı ı
versiyondan versiyona değişebilmektedir. Dolaysı ı ı ı ı ı
isimleri sys_xxxx öneki ile başlatı
UNIX türevi sistemlerdeki ortak C fonksiyonları ı ı
ancak çekirdek kodlaması ı ı ı ı ı ı
oluşturulması ı ı ı ı ı ı ı ı ı ı
POSIX fonksiyonları ı ı ı ı
çağrı
Windows API fonksiyonları ı ı ı
türevi sistemlerin ortak fonksiyonları ı ı ı ı ı ı ı
barı ı ı ı ı ı
fonksiyonları ı ı ı ı ı ı ı
Standart C fonksiyonları ı ı ı ı ı
çağrı ı ı ı ı
open isimi POSIX fonksiyonunu çağı ı ı
fopen ---> open ---> sys_open
Aynı ı ı ı
fopen ---> CreateFile ---> NtCreeateFile
Tabii fopen fonksiyonu UNIX türevi sistemlerde yalnı ı ı
Başka şeyler de yapmaktadı ı ı ı ı ı ı ı ı ı
Java, C# ve Python gibi dillerde de tamamen bu tür işlemler benzer biçimde gerçekleştirilmektedir. Örneğin Python ile Linux sistemlerinde
bir dosya açı ı ı ı ı ı
open (Python) ---> fopen --> open ---> sys_open
Pekiyi bir C programcı ı ı ı ı ı ı ı ı ı
C programcı ı ı ı ı ı ı
Ancak çok seyrek de olsa bazen C prograöcı ı ı ı ı
bazı ı ı ı ı ı ı ı ı
Ancak böylesi gereksinimler oldukça seyrektir.
Pekiyi bir C programcı ı ı ı ı ı ı ı ı ı
sistem fonksiyonları ı ı ı ı
fonksiyonları ı ı ı ı ı ı ı
programcı ı ı ı ı ı
yazı ı ı ı ı ı ı
Bu durumda eğer biz bir işlemi etkin bir biçimde standart C fonksiyonları ı ı ı ı
bu işleme yetmiyorsa bu durumda UNIX/Linux sistemlerinde POSIX fonksiyonları ı ı ı ı ı
Eğer hala bunlar yetersiz kalı ı ı ı
Örneğin bir dizin (directory) yaratmak istediğimizi düşünelim. Bu işi yapacak bir standart C fonksiyonu yoktur. O halde biz bu işlem için
UNIX/Linux sistemlerinde mkdir isimli POSIX fonksiyonunu Windows sistemlerinde de CreateDirectory isimli API fonksiyonunu kullanı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
9. Ders - 02/07/2023-Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows'un API fonksiyonları ı ı ı ı ı ı
(bu dosya başka başlı ı ı ı ı ı
fonksiyonu kullanı ı
Windows API fonksiyonları ı ı ı ı ı ı ı
Örneğin yazı ı ı
xxxxxW biçiminde fonksiyonlar vardı ı ı ı ı ı
ayara göre" xxxxxA ya da xxxxxW haline getirmektedir. Biz kursumuzda bu API fonksiyonlaarı ı ı ı
yaratı ı ı ı ı ı
sekmesinden "Cahatacter Set" seçeneği "Not Set" haline getirilmelidir. Aksi takdirde bizim bu API fonksiyonları ı
gerekir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows dünyası ı ı ı ı ı ı ı ı
tarafı ı ı ı ı
isimlerinin hepsi büyük harflerle oluşturulmuştur. Programcı ı ı
kullanmalı ı ı ı ı
BYTE: 1 byte uzunlupunda işaretsiz tamsayı
WORD: 2 byte uzunlupunda işaretsiz tamsayı
DWORD: 4 byte uzunlupunda işaretsiz tamsayı
QWORD: 8 byte uzunlupunda işaretsiz tamsayı
Adres türleri başı
"far pointer" için kullanı ı ı ı ı
ayrı ı ı ı ı ı ı ı ı ı
önekini tercih etmektedir. Bir göstericinin gösterdiği yerin const olduğu P ya da LP önekinden sonraki C ekiyle belirtmiştir. Örneğin
PC ya da LPC önekleri "gösterdiği yer const olan" göstericiler için kullanı ı
Örneğin LPCDWORD tür ismi "const DWORD *" anlamı ı
da typedef edilmiştir. Bu duurmda örneğin LPVOID tür ismi "void *" anlamı ı
char türden adresler PSTR ya da LPSTR ismiyle typedef edilmiştir. Bunlar const biçimleri de PCSTR ya da LPCSTR biçiminde isimlendirilmiştir.
HANDLE tür ismi genel olarak "handle" belirtir. Bu tür ismi "void *" olarak typedef edilmiştir.
PSTR, PCSTR, LPSTR ve LPCSTR gibi yazı ı ı ı ı
LPCSTR türünün yanı ı
C'nin standart türleri de (her ne kadar gerekmiyorsa da) büyük harflerle typedef edilmiştir. Örneğin INT, LONG, CHAR, DOUBLE gibi typedef
isimleri orijinal C türlerine karşı ı
BOOL türü int olarak typedef edilmiştir. Bir API fonksiyonun geri dönüş değerinde BOOL gördüğümüzde bu geri dönüş değerinin başarı ı ı ı
biçiminde bir değer verdiğini anları
BOOL SomeFunc(void);
Yapı ı ı
Örneğin:
typedef struct tagRECT {
...
} RECT;
Yine yapı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows API programlamada kullanı ı ı ı
bu Macar notasyonu hakkı ı ı
değişkenlerin türlerini belirten öneklerin bulunması ı ı ı ı
b BYTE, BOOL
w WORD
dw DWORD
p, lp Adres
sz CHAR türden yazı
psz, lpsz CHAR türden yazı
pc CHAR türden adres
h HANDLE
l LONG
u UNSIGNED INT
lu UNSIGNED LONG
Yapı ı ı ı ı ı
değişkenlerde kullanı ı
Macar Notasyonunda bir değişken ismi onun türünü belirtne önekten sonra her sözcüğün ilk harfi büyük yazı
DWORD dwNumberOfSectors;
LONG lStudentNumber;
char szName[64];
DWORD dwWordCount;
LPSTR lpszFileName;
Macar notasyonundaki önek getirme bazı ı ı ı
için özel bir önek kullanmamaktadı ı ı
uygun yapı ı ı
int numberOfStudents;
Deve notasyonunda ilk sözcük tamamen küçük harflerle sonraki sözcüklerin yalnı ı ı
ismi zaten tek sözcükten oluşyorsa sözcüğün tamamı ı ı
int i;
int count;
Tabii değişken türe ilişkin bir önek içeriyorsa zaten bu önek deve notasyonundaki ilk sözcüğün yerini tutmaktadı
Macar Notasyonunda değişken isimleri biraz uzun olma eğilimindedir. Bu notasyon programcı
Macar notasyonunda fonksiyon isimleri "Pascal tarzı ı
sözcüğün (ilk sözcük de dahil) ilk harfi büyük yazı ı
ilişkin sözcükler kullanı ı
CreateFile
ReadFile
GetWindowLong
SetWindowText
Windows sistemlerinde Microsoft'un C ve C++ derleyicileri zaten default olarak API fonksiyonları ı ı
link aşaması ı ı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux dünyası ı ı ı ı ı ı
klasik C isimlendirme tekniği ile isimlendirilmiştir. Fonksiyon isimlerinde hiç büyük harf kullanı ı ı
sözcükleri ayı ı ı ı ı ı ı ı
taşı ı ı
içerisinde bildirilmiştir. Fonksiyonları ı ı ı ı
Pek çok temel fonskyionun prototipi <unistd.h> isimli bir başlı ı ı
"_t" soneki ile isimlendirilmiştir. Örneğin pid_t, pthread_mutex_t gibi. POSIX fonksiyonları ı ı ı ı ı
link aşaması ı ı ı ı
içerisinde (bunu "glibc" kütüphanesi denilmektdir) bulunmaktadı ı ı
onlar kullanı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Sistem programlamada yapı ı ı ı ı ı ı ı
Dolayı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
belirten hata mesajları ı ı ı ı ı ı
gruba ayı
1) Her çağrı ı ı ı ı ı ı
içinde bulunduğu koşullara bağlı ı ı ı ı ı ı
gerekir. Örneğin fopen gibi malloc gibi fonksiyonlar bu gruba örnek verilebilir.
2) Eğer programcı ı ı ı ı ı ı ı
Çünkü bu tür fonksiyonlar "biz her şeyi düzgün yapmı ı ı ı ı ı ı ı ı
yapmı ı ı
yapı ı ı ı ı ı
bu gruba örnek verebiliriz. Biz her şeyi doğru yapmı ı ı ı ı ı
3) Başarı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
Bazı ı ı ı ı ı ı ı ı ı ı ı ı ı
geçerli alan olup olmadı ı ı ı ı ı ı ı ı
vermemektedir. Örneğin getpid POSIX fonksiyonu o anda çalı ı ı
Bu fonksiyonun başarı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
10. Ders - 08/07/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Fonksiyonları ı ı ı ı ı ı ı ı ı ı
olan bir fonksiyon için başarı ı ı ı ı ı ı ı ı ı ı ı
onu telafi edici işlemler yapabilir. Bu bölümde biz Windows sistemlerinde ve UNIX/Linux sistemlerinde başarı ı ı ı ı
elde edileceği üzerinde duracağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde bir API fonksiyonu başarı ı ı ı
Bu fonksiyonun prototipi şöyledir:
DWORD GetLastError(void);
Fonksiyon her farklı ı
ERROR_XXXX biçiminde sembolik sabitlerle define edilmiştir. Tabii GetLastError fonksiyonı ı ı
kontrol etmek zordur ve oldukça zahmetlidir. Windows sistmlerinde belli bir API fonksiyonunun başarı ı ı
değerinin hangi seçeneklerden biri olacağı ı ı ı ı ı ı
listelenmiştir.) Dolayı ı ı ı ı
Microsoft API fonksiyonları ı ı ı ı
bağlantı
https://learn.microsoft.com/en-us/windows/win32/debug/system-error-codes
Programcı ı ı ı ı ı ı ı ı ı
bağlantı
if (!SomeAPIFunc(...)) {
fprintf(setderr, "SomeAPIFunc failed: %lu\n", GetLastError());
exit(EXIT_FAILURE);
}
Bir API fonksiyonu başarı ı ı ı
yalnı ı ı ı ı ı ı ı ı
Windows'ta GetLastError fonksiyonun verdiği "last error" kodu thread'e özgüdür. Yani her thread'in ayrı ı
Thread'ler konusu ileride ele alı ı
Hata nedenine ilişkin "last error" kodunun kullanı ı ı ı ı ı ı
rapor edilmesi daha uygundur. FormatMessage isimli API fonksiyonu "last error" değerini alarak bize o hata koduna ilişkin bir hata yazı ı
vermektedir. FormatMessage fonksiyonunun kullanı ı ı
"last error" değerinden hareketle hata yazı ı ı ı ı ı ı
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
Fonksiyon bizden bir yazı ı ı ı ı ı ı ı ı
"last error" değerine karşı ı ı ı
if ((hFile = CreateFile("xxxxx.txt", GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
ExitSys("CreateFile");
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
if (CreateSemaphore(NULL, -10, 1, "") == NULL)
ExitSys("CreateSemaphore");
printf("Ok\n");
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Programcı ı ı
Fonksiyonun prototipi şöyledir:
void SetLastError(DWORD dwErrCode);
Örneğin:
BOOL Foo(LPCSTR lpszName)
{
if (strlen(lpszName) == 0) {
SetLastError(ERROR_BAD_LENGTH);
return FALSE;
}
...
return TRUE;
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows API fonksiyonları ı
başarı ı ı ı ı ı ı ı ı ı ı ı
gibi iki sembolik de bulunmaktadı
#define FALSE 0
#define TRUE 1
Geri dönüş değeri BOOL türden olan API fonksiyonları ı ı ı ı ı ı
if (SomeAPIFunc() == TRUE) {
...
}
Çünkü fonksiyon başarı ı ı ı ı ı ı ı
gibi yapabiliriz:
if (SomeAPIFunc()) {
...
}
Başarı ı ı ı ı ı ı
if (SomeAPIFunc() == FALSE) {
...
}
Fakat pek çok programcı ı
if (!SomeAPIFunc()) {
...
}
------------------------------------------------------------------------------------------------------------------------------------------ */
/*------------------------------------------------------------------------------------------------------------------------------------------
POSIX fonksiyonları ı ı
başarı ı ı ı ı ı ı
başarı ı ı ı ı ı
if (some_posix_func() == -1) {
...
}
Bazı ı ı ı ı ı
if (some_posix_func() < 0) {
...
}
Böyle bir kontrolün uygulandı ı ı ı ı ı ı
izlenime kapı ı ı ı ı ı ı ı ı ı ı
Bazı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde bir POSIX fonksiyonu başarı ı ı ı ı ı
sayı ı ı ı ı ı ı ı ı ı
tespit edebiliriz. Tı ı ı ı ı ı ı ı
başarı ı
belirtilmiştir. errno değişkenine değer de atanabilmektedir. errno değişkeninin bildirimi <errno.h> dosyası ı ı
değişkeninin kullanabilmek için bu dosyanı ı
bildirilmiş olabilir. Bu nedenle programcı ı
POSIX standartları ı ı
standartları ı ı ı ı
örneğin bir sistemdeki EACCESS error değeri ile diğer sistemdeki EACCESS eror değerinin sayı ı
Programcı ı ı ı
POSIX standartları ı ı ı
ilişkin kesin bir liste verilmiştir. Yani biz bir POSIX fonksiyonunun başarı ı ı ı ı ı
dokümanlardan elde edebilmekteyiz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
POSIX fonksiyonun başarı ı ı ı ı ı ı ı ı ı ı ı ı ı
Çünkü bu sayı ı
rapor edilmesi hatalı ı ı
içerisine alı ı ı ı ı ı
if ((fd = open("test.dat", O_RDONLY)) == -1) {
switch (errno) {
case EACCESS:
...
case EISDIR:
...
...
}
}
Hatanı ı ı
prototipi şöyledir:
#include <string.h>
char *strerror(int errnum);
Fonksiyon errno değerini parametre olarak alı ı ı
static bir dizinin adresidir. Öneğin:
if ((fd = open("test.dat", O_RDONLY)) == -1) {
fprintf(stderr, "open failed: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
Aslı ı ı ı ı ı
sı ı ı ı
strerror fonksiyonu default durumda hata mesajları ı ı
elde edilmek isteniyorsa setlocale standart C fonksiyonu ile Türkçe locale'e geçilmelidir. strerror fonksiyonu LS_MESSGAES locale değerini
kullanmaktadı
if (setlocale(LC_ALL, "tr_TR.utf-8") == NULL) {
fprintf(stderr, "cannot set locale!..\n");
exit(EXIT_FAILURE);
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
int main(void)
{
int result;
if ((result = open("test.dat", O_RDONLY)) == -1) {
fprintf(stderr, "Open failed: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("success...\n");
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde perror fonksiyonu (aynı ı ı ı
sonra ':' ve SPACE karakterini, sonra da sonra da errno değişkeninin değerinin yazı ı ı ı ı ı ı ı
#include <stdio.h>
void perror(const char *msg);
Programcı ı ı ı ı ı ı
Örneğin:
if ((fd = open("test.dat, O_RDONLY)) == -1) {
perror("open");
exit(EXIT_FAILURE);
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
int main(void)
{
int result;
if ((result = open("test.dat", O_RDONLY)) == -1) {
perror("open failed");
exit(EXIT_FAILURE);
}
printf("success...\n");
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Genellikle UNIX/Linux sistemlerinde de bir POSIX fonksiyonu başarı ı ı ı ı ı ı ı ı ı
Bu işlem çok yapı ı ı ı
fonksiyon kullanacağı
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
void exit_sys(const char *msg);
int main(void)
{
int result;
if ((result = open("test.dat", O_RDONLY)) == -1)
exit_sys("open");
printf("success...\n");
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Sistem programalamda bir grup bilgiye erişmek içinkullanı ı
tekil bir bilgi belirtir. Ancak handle sayesinde konu ile ilgili gerekli bilgilere erişilebilmektedir. Handle'lar çeşitli biçimlerde karşı ı
çı ı
sayesinde diğer bilgilere erişilebilir. Bazen handle bir adres biçimindedir. Doğrudan veri yapsı ı
bir bozulmuş bir adres gibi de olabilir. Bu durumda biz handle değerini ilgili fonksiyona verdiğimizde fonksiyonu düzeltip erişimi sağlı
olabilir. Handle kavramı ı ı ı ı
dosyayı ı ı ı ı
Bu FILE adresi (stream) bu anlamda bir handle belirtmektedir. Biz bu adresi diğer dosya fonksiyonları
bu dosya bilgilerine erişirler. Örneğin:
FILE *f;
...
f = fopen(...);
...
ch = fgetc(f);
...
Bir handle sisteminde genel olarak üç tür fonksiyon bulunur:
1) Handle sistemini yaratan ya da açan fonksiyonlar: Bu fonksiyonlar handle alanı ı ı
O bilgilere ilkdeğerlerini verirler ve handle değeri ile geri dönerler. Örneğin fopen fonksiyonu FILE yapı ı ı
ve onun adresini handle olarak verir. Handle sisteminin yaratan ya da açan fonksiyonlar genellikle createxxx ya da openxxx biçiminde
isimlendirilirler.
2) Handle sistemini kullanan fonksiyonlar: Bu fonksiyonlar handle değerini parametre olarak alı ı
işlemler yaparlar. Örneğin fgetc, fputs gibi fonksiyonlar handle değerini alı ı
3) Handle sistemini kapatan ya da yok eden fonksiyonlar: Bunlar handle değerini parametre olarak alı ı ı
ve handle sistemi yaratı ı ı ı ı ı ı
yok eden ya da kapatan fonksiyona örnek olarak verilebilir. Handle sistemini yok eden ya da kapatan fonksiyonlar genellikle DestroyXXX
ya da CloseXXX biçiminde isimlendirilmektedir.
Windows API programalamada başı
Windows API sisteminde handle türleri void * olarak typedef edilmişse de aslı ı ı ı ı
Windows API sisteminde söz konusu handle değerleri bir grup bilginin bulunduğu alanları ı
orada bir şey yokmuş gibi void bir adres biçiminde handle'lar verilmektedir. Macar Notasyonunda handle türlerini tutacak değişkenler
h öneki ile isimlendirilmektgedir. Örneğin:
HBITMAP hBitmap;
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
11. Ders 09/07/ 2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Handle sistemine bir örnek
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
typedef int DATATYPE;
typedef struct tagMATRIX {
size_t rowsize;
size_t colsize;
DATATYPE *matrix;
} MATRIX, *HMATRIX;
HMATRIX CreateMatrix(size_t rowsize, size_t colsize);
void CloseMatrix(HMATRIX hMatrix);
void SetElem(HMATRIX hMatrix, size_t row, size_t col, DATATYPE val);
DATATYPE GetElem(HMATRIX hMatrix, size_t row, size_t col);
void DispMatrix(HMATRIX hMatrix);
int main(void)
{
HMATRIX hMatrix1, hMatrix2;
DATATYPE i;
if ((hMatrix1 = CreateMatrix(3, 3)) == NULL) {
fprintf(stderr, "cannot create matrix!..\n");
exit(EXIT_FAILURE);
}
if ((hMatrix2 = CreateMatrix(2, 2)) == NULL) {
fprintf(stderr, "cannot create matrix!..\n");
exit(EXIT_FAILURE);
}
i = 0;
for (int row = 0; row < 3; ++row)
for (int col = 0; col < 3; ++col)
SetElem(hMatrix1, row, col, i++);
i = 0;
for (int row = 0; row < 2; ++row)
for (int col = 0; col < 2; ++col)
SetElem(hMatrix2, row, col, i++);
DispMatrix(hMatrix1);
printf("------------------\n");
DispMatrix(hMatrix2);
CloseMatrix(hMatrix2);
CloseMatrix(hMatrix1);
return 0;
}
HMATRIX CreateMatrix(size_t rowsize, size_t colsize)
{
HMATRIX hMatrix;
if ((hMatrix = (HMATRIX)malloc(sizeof(MATRIX))) == NULL)
return NULL;
hMatrix->rowsize = rowsize;
hMatrix->colsize = rowsize;
if ((hMatrix->matrix = (DATATYPE *)malloc(sizeof(DATATYPE) * rowsize * colsize)) == NULL) {
free(hMatrix);
return NULL;
}
return hMatrix;
}
void CloseMatrix(HMATRIX hMatrix)
{
free(hMatrix->matrix);
free(hMatrix);
}
void SetElem(HMATRIX hMatrix, size_t row, size_t col, DATATYPE val)
{
size_t index;
index = row * hMatrix->colsize + col;
hMatrix->matrix[index] = val;
}
DATATYPE GetElem(HMATRIX hMatrix, size_t row, size_t col)
{
size_t index;
index = row * hMatrix->colsize + col;
return hMatrix->matrix[index];
}
void DispMatrix(HMATRIX hMatrix)
{
for (size_t i = 0; i < hMatrix->rowsize * hMatrix->colsize; ++i)
printf("%d%c", hMatrix->matrix[i], i % hMatrix->colsize == hMatrix->colsize - 1 ? '\n' : ' ');
/*
for (size_t row = 0; row < hMatrix->rowsize; ++row) {
for (size_t col = 0; col < hMatrix->colsize; ++col)
printf("%d ", hMatrix->matrix[row * hMatrix->colsize + col]);
printf("\n");
}
*/
}
/* ------------------------------------------------------------------------------------------------------------------------------------------
Windows API fonksiyonları ı ı ı
Bu sayede handle sistemini kullanacak kişilerin kafası ı ı ı
erişme olanağı ı ı ı
Aşağı ı ı ı
matris gerçekeleştiriminin bulunduğu kütüpane dosyası ı ı
orada handle alanı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* Matrix.c */
#include <stdio.h>
#include <stdlib.h>
/* Type Declarations */
typedef int DATATYPE;
typedef struct tagMATRIX {
size_t rowsize;
size_t colsize;
DATATYPE *matrix;
} MATRIX;
typedef void *HMATRIX;
/* Function Prototypes */
HMATRIX CreateMatrix(size_t rowsize, size_t colsize);
void CloseMatrix(HMATRIX hMatrix);
void SetElem(HMATRIX hMatrix, size_t row, size_t col, DATATYPE val);
DATATYPE GetElem(HMATRIX hMatrix, size_t row, size_t col);
void DispMatrix(HMATRIX hMatrix);
/* Function Definitions */
HMATRIX CreateMatrix(size_t rowsize, size_t colsize)
{
MATRIX *pMatrix;
if ((pMatrix = (HMATRIX)malloc(sizeof(MATRIX))) == NULL)
return NULL;
pMatrix->rowsize = rowsize;
pMatrix->colsize = rowsize;
if ((pMatrix->matrix = (DATATYPE *)malloc(sizeof(DATATYPE) * rowsize * colsize)) == NULL) {
free(pMatrix);
return NULL;
}
return pMatrix;
}
void CloseMatrix(HMATRIX hMatrix)
{
MATRIX *pMatrix = (MATRIX *)hMatrix;
free(pMatrix->matrix);
free(pMatrix);
}
void SetElem(HMATRIX hMatrix, size_t row, size_t col, DATATYPE val)
{
MATRIX *pMatrix = (MATRIX *)hMatrix;
size_t index;
index = row * pMatrix->colsize + col;
pMatrix->matrix[index] = val;
}
DATATYPE GetElem(HMATRIX hMatrix, size_t row, size_t col)
{
MATRIX *pMatrix = (MATRIX *)hMatrix;
size_t index;
index = row * pMatrix->colsize + col;
return pMatrix->matrix[index];
}
void DispMatrix(HMATRIX hMatrix)
{
MATRIX *pMatrix = (MATRIX *)hMatrix;
for (size_t i = 0; i < pMatrix->rowsize * pMatrix->colsize; ++i)
printf("%d%c", pMatrix->matrix[i], i % pMatrix->colsize == pMatrix->colsize - 1 ? '\n' : ' ');
}
/* Matrix.h */
#ifndef MATRIX_H_
#define MATRIX_H_
/* Type Declarations */
typedef int DATATYPE;
typedef void *HMATRIX;
/* Function Prototypes */
HMATRIX CreateMatrix(size_t rowsize, size_t colsize);
void CloseMatrix(HMATRIX hMatrix);
void SetElem(HMATRIX hMatrix, size_t row, size_t col, DATATYPE val);
DATATYPE GetElem(HMATRIX hMatrix, size_t row, size_t col);
void DispMatrix(HMATRIX hMatrix);
#endif
/* App.c */
#include <stdio.h>
#include <stdlib.h>
#include "Matrix.h"
int main(void)
{
HMATRIX hMatrix1, hMatrix2;
DATATYPE i;
if ((hMatrix1 = CreateMatrix(3, 3)) == NULL) {
fprintf(stderr, "cannot create matrix!..\n");
exit(EXIT_FAILURE);
}
if ((hMatrix2 = CreateMatrix(2, 2)) == NULL) {
fprintf(stderr, "cannot create matrix!..\n");
exit(EXIT_FAILURE);
}
i = 0;
for (int row = 0; row < 3; ++row)
for (int col = 0; col < 3; ++col)
SetElem(hMatrix1, row, col, i++);
i = 0;
for (int row = 0; row < 2; ++row)
for (int col = 0; col < 2; ++col)
SetElem(hMatrix2, row, col, i++);
DispMatrix(hMatrix1);
printf("------------------\n");
DispMatrix(hMatrix2);
CloseMatrix(hMatrix2);
CloseMatrix(hMatrix1);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir fonksiyon içerisinde çok sayı ı ı ı ı ı ı ı ı
geri bı ı ı ı ı ı
bool foo(void)
{
...
if ((p1 = malloc(size1)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n);
return false;
}
if ((p2 = malloc(size2)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n);
free(p1);
return false;
}
if ((p3 = malloc(size3)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n);
free(p1);
free(p2);
return false;
}
if ((p4 = malloc(size3)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n);
free(p1);
free(p2);
free(p3);
return false;
}
....
return true;
}
Tabii buradaki genel durumun bir tahsisat işlemi olması ı ı ı
Buradaki ana tema bir grup işlemde bunları ı ı ı ı ı ı
Yukarı ı ı ı ı ı ı
Bu teknik aşağı ı ı
bool foo(void)
{
bool status;
...
status = false;
if ((p1 = malloc(size1)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n);
goto EXIT1;
}
if ((p2 = malloc(size2)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n);
goto EXIT2;
}
if ((p3 = malloc(size3)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n);
goto EXIT3;
}
if ((p4 = malloc(size3)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n);
goto EXIT4;
}
....
status = true;
EXIT4:
free(p3);
EXIT3:
free(p2);
EXIT2:
free(p1);
EXIT1:
return status;
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Bilindiği gibi C'de char türünün dı ı ı ı ı ı ı
isteğine bı ı ı ı ı ı
Linux sistemlerinde de int türü 4 byte uzunluktadı ı
64 bit Linux sistemlerinde long türü 8 byte uzunluğundadı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
İşletim sistemlerinin dosya işlemleri ile ilgili alt sistemlerine "dosya sistemi (file system)" denilmektedir. İşletim sistemlerinin
dosya sistemleri dosyaları ı ı ı ı
İşletim sistemleri programcı ı ı ı ı
bazı ı ı ı ı ı ı ı ı
yapı ı ı ı
İşletim sistemlerinde açı ı
1) Dosyayı
2) Dosyayı
3) Dosyadan okuma yapan sistem fonksiyonu
4) Dosyaya yazma yapan sistem fonksiyonu
5) Dosya göstericisini konumlandı
Dosya işlemlerinden tamamen işletim sisteminin sorumlu olduğuna programa dillerinin ya da kütüphanelerinin sorumlu olmadı ı
Bi zhangi programlama dilinde ve hangi kütüphanede çalı ı ı ı
belirttiğimiz beş fonksiyonu çağrı ı ı ı ı ı ı
Bu nedenle biz temel dosya işlemleri için işletim sisteminin sistem fonksiyonları ı ı
ilgili Windows API fonksiyonları ı ı ı ı ı
Linux sistemlerinde dosyayı ı ı
POSIX fonksiyonları ı ı ı ı
Programlama dillerindeki o dile özgü dosya fonksiyonları
dikkate alı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
12.Ders 16/07/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde aşağı ı
kapatmak için ise CloseHandle isimli API fonksiyonu kullanı ı
HANDLE CreateFile(
LPCTSTR lpFileName,
DWORD dwDesiredAccess,
DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDistribution,
DWORD dwFlagsAndAttributes,
HANDLE hTemplateFile
);
CreateFile fonksiyonunun birinci parametresi açı ı
açı
parametresi başka bir prosesin dosyayı ı ı
bir düzeyinde OR işlemiyle birleştirilmesiyle oluşturulabilir.
FILE_SHARE_DELETE: Başka bir proses biizm açmı ı
FILE_SHARE_READ: Başka bir proses de dosyayı ı
FILE_SHARE_WRITE: Başka bir proses de dosyayı ı
Bu parametre 0 girilirse başka bir proses dosyayı
Fonksiyonun dördüncü parametresi olan lpSecurityAttributes kernel nesnesinin güvenlik (security) bilgilerini belirlemek için kullanı ı
Windwos sistemlerinde biraz ayrı ı ı ı ı ı ı ı
"Windows Sistem Programalama" kursunda ele alı ı ı ı ı ı
ancak diğerlerinin dosyayı ı ı ı ı
işlemleri söz konusu olduğunda özel bir güvenlik mekanizması
Fonksiyonun beşinci parametresi (dwCreationDistribution) açı ı ı ı ı ı
belirtmektedir. Bu parametreler için şu değerlerden biri girilebilir:
OPEN_EXISTING: Ancak zaten var olan bir dosya açı ı ı ı
CREATE_NEW: Olmayan dosyanı ı ı ı ı ı ı ı ı
gerekir. Bu durumda fonksiyon dosyayı ı
OPEN_ALWAYS: Bu durumda dosya varsa olan açı ı ı ı ı ı
CREATE_ALWAYS: Bu duurmda dosya yoksa yaratı ı ı ı ı ı ı ı ı
TRUNCATE_EXISTING: Dosya varsa sı ı ı ı ı ı ı
Fonksiyonun altı ı ı
açı ı ı ı ı ı ı ı ı ı ı ı
FILE_ATTRIBUTE_NORMAL değerini girebilrsiniz. Eğer zaten olan dosyayı ı
Fonksiyonun son parametresine (hTemplateFile) daha önce açı ı ı ı
yukarı ı ı ı ı ı ı
bu parametre NULL adres olarak geçilebilir.
CreateFile fonksiyonu başarı ı ı ı ı ı
temsil edilen özel bir değere geri dönmektedir. HANDLE türünün void * biçiminde typedef edildiğini anı ı ı
Örneğin:
HANDLE hFile;
...
if ((hFile = CreateFile("sample.c", GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
ExitSys("CreateFile");
Dosyayı ı ı
BOOL CloseHandle(
HANDLE hObject
);
Fonksiyon açı ı ı ı ı ı ı ı ı ı
başarı ı ı ı ı
CloseHandle(hFile);
Aşağı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hFile;
if ((hFile = CreateFile("test.txt", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, 0, NULL)) == INVALID_HANDLE_VALUE)
ExitSys("CreateFile");
printf("success...\n");
CloseHandle(hFile);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*-----------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde dosyadan okuma yapmak için ReadFile API fonksiyonu kullanı ı
BOOL ReadFile(
HANDLE hFile,
LPVOID lpBuffer,
DWORD nNumberOfBytesToRead,
LPDWORD lpNumberOfBytesRead,
LPOVERLAPPED lpOverlapped
);
Fonksiyonun birinci parametresi açı ı ı ı
belirtmektedir. Üçüncü parametre dosya göstericisinin gösterdiği yerden itibaren okunacak byte sayı ı ı
byte sayı ı ı
bir byte okunamayacaktı ı
IO işlemleri iiçin kullanı ı ı ı ı ı ı ı ı ı
durumunda sı ı
Aşağı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#define BUFFER_SIZE 512
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hFile;
char buf[BUFFER_SIZE + 1];
DWORD dwRead;
BOOL bResult;
if ((hFile = CreateFile("test.txt", GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
ExitSys("CreateFile");
while ((bResult = ReadFile(hFile, buf, BUFFER_SIZE, &dwRead, NULL)) != 0 && dwRead > 0) {
buf[dwRead] = '\0';
printf("%s", buf);
}
if (!bResult)
ExitSys("ReadFile");
CloseHandle(hFile);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde açı ı ı
BOOL WriteFile(
HANDLE hFile,
LPCVOID lpBuffer,
DWORD nNumberOfBytesToWrite,
LPDWORD lpNumberOfBytesWritten,
LPOVERLAPPED lpOverlapped
);
Aslı
parametre const bir göstericidir. Normal durumda talep edilen miktarda byte dosya yazı ı ı ı
talep edilen miktardan adah az byte değeri de dosyaya yazı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
yapı ı ı ı ı ı ı
Aslı ı ı
bir API fonksiyonu da bulunmaktadı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#define BUFFER_SIZE 8192
void ExitSys(LPCSTR lpszMsg);
int main(int argc, char *argv[])
{
HANDLE hFileSource, hFileDest;
char buf[BUFFER_SIZE];
DWORD dwRead, dwWritten;
BOOL bResult;
if (argc != 3) {
fprintf(stderr, "Wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((hFileSource = CreateFile(argv[1], GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
ExitSys("CreateFile");
if ((hFileDest = CreateFile(argv[2], GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL)) == INVALID_HANDLE_VALUE)
ExitSys("CreateFile");
while ((bResult = ReadFile(hFileSource, buf, BUFFER_SIZE, &dwRead, NULL)) != 0 && dwRead > 0) {
if (!WriteFile(hFileDest, buf, dwRead, &dwWritten, NULL))
ExitSys("WriteFile");
if (dwWritten != dwRead) {
fprintf(stderr, "Partial write Error!..\n");
exit(EXIT_FAILURE);
}
}
if (!bResult)
ExitSys("ReadFile");
CloseHandle(hFileDest);
CloseHandle(hFileSource);
printf("1 file copied...\n");
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde dosya göstericisinin konumlandı ı ı
prototipi şöyledir:
DWORD SetFilePointer(
HANDLE hFile,
LONG lDistanceToMove,
PLONG lpDistanceToMoveHigh,
DWORD dwMoveMethod
);
Fonksiyonun birinci parametresi açı ı ı ı
belirtir. İkinci parametre konumlandı ı
geçilirse konumlandı ı ı
parametreler 64 bitlik bir offset belirtir. Fonksiyon başarı ı ı ı ı ı
geri dönmektedir. Eğer üçüncü parametre NULL geçilmediyse konumlandı ı ı ı ı ı ı
gösteridği yere yerleştirilmektedir. Fonksiyonun son parametresi tı ı ı ı ı ı ı
belirtmektedir. Konumlandı
FILE_BEGIN (0): Konumlandı ı ı ı ı
FILE_CURRENT (1): Konumlandı ı ı
FILE_END (2): Konumlandı ı ı
Fonksiyon başarı ı ı
bu değer geçerli bir offset değeri olabilmektedir. MSDN dokümanları ı ı
NO_ERROR dı ı ı ı
if (SetFilePointer(...) == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
ExitSys("SetFilePointer");
Aşağı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hFile;
char buf[] = "this is a test";
DWORD dwWritten;
if ((hFile = CreateFile("test.txt", GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
ExitSys("CreateFile");
if (SetFilePointer(hFile, 0, NULL, FILE_END) == INVALID_SET_FILE_POINTER && GetLastError() != 0)
ExitSys("SetFilePointer");
if (!WriteFile(hFile, buf, strlen(buf), &dwWritten, NULL))
ExitSys("WriteFile");
CloseHandle(hFile);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi SetFilePointer fonksiyonunda 64 bitlik offset nası ı ı ı ı ı
değer biçiminde oluşturması ı ı ı ı
değerini oluşturmak isteyelim bu -2 değeri aslı
FFFF FFFF FFFF FFFF FFFF FFFF FFFF FFFFE
Burada yüksek anlamlı ı
Aşağı ı ı ı ı ı
yapı ı ı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#define BUFFER_SIZE 512
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hFile;
char buf[BUFFER_SIZE + 1];
DWORD dwRead, dwWritten;
LONG high = -1;
if ((hFile = CreateFile("test.txt", GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
ExitSys("CreateFile");
if (SetFilePointer(hFile, 0, NULL, FILE_END) == INVALID_SET_FILE_POINTER && GetLastError() != 0)
ExitSys("SetFilePointer");
if (SetFilePointer(hFile, -2, &high, FILE_CURRENT) == INVALID_SET_FILE_POINTER && GetLastError() != 0)
ExitSys("SetFilePointer");
if (!ReadFile(hFile, buf, BUFFER_SIZE, &dwRead, NULL))
ExitSys("ReadFileFile");
buf[dwRead] = '\0';
puts(buf);
CloseHandle(hFile);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde aslı ı ı ı ı ı ı ı ı ı ı ı
"Ali" kullanı ı ı ı ı ı ı
bu kursumuzda ele alı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde de temel dosya işlemleri için beş temel POSIX fonksiyonu bulundurulmuştur. Bu POSIX fonksiyonları ı
çok UNIX türevi sistemde bire bir o sistemdeki sistem fonksiyonları ı ı ı
open
close
read
write
lseek
open fonksiyonu Windows'taki CreateFile fonksiyonunun, close fonksiyonu CloseHandle fonksiyonunun, read fonksiyonu ReadFile fonksiyonunun,
write fonksiyonu WriteFile fonksiyonunun lseek fonksiyonu da SetFilePointer fonksiyonunun UNIX/Linux sistemlerindeki karşı ı ı
Biz POSIX fonksiyonları ı ı ı ı ı
buna gerek yoktur. Çünkü temel fonksiyonları
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde var olan bir dosyayı ı ı
Fonksiyonun prototipi şöyledir:
#include <fcntl.h>
int open(const char *path, int oflag, ...);
open fonksiyonu ya iki argümanla ya da üç argümanla çağrı ı ı
mode_t türünden bir üçüncü parametreye sahipmiş gibi çağrı ı ı ı
kullanı ı
int open(const char *path, int oflag);
int open(const char *path, int oflag, mode_t mode);
open fonksiyonun birinci parametresi açı ı ı ı
parametre O_XXX biçimindeki sembolik sabitlerin bit OR işlemine sokulması ı ı
yalnı
O_RDONLY
O_WRONLY
O_RDWR
O_EXEC
O_SEARCH
O_EXEC ve O_SEARCH bayrakları ı ı ı ı
"yalnı ı ı ı ı
bazı ı ı
açı ı
O_CREAT: Bu bayrak dosya yoksa dosyanı ı ı ı ı ı
dosya açı
O_TRUNC: Bu bayrak dosya varsa dosyanı ı ı ı ı ı ı
bayrağı ı ı ı ı ı ı ı
O_EXCL: Bu bayrak O_CREAT bayrağı ı ı ı ı
anlamı ı ı ı ı ı
O_APPEND: Bu modda eğer bayraklaruygunsa dosyanı ı ı
yapı ı
open fonksiyonunda eğer yeni bir dosyanı ı ı
programcı ı ı ı ı ı ı
Ancak yeni bir dosyanı ı ı ı ı ı
argümanı ı ı ı ı ı
girdiği üçüncü argüman fonksiyon tarafı ı ı
open fonksiyonu başarı ı ı ı
geri dönmektedir.
Örneğin:
int fd;
...
if ((fd = open("test.txt", O_RDONLY)) == -1)
exit_sys("open");
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde dosyayı ı ı ı ı
işletim sistemi tarafı ı ı ı ı ı ı
Bir dosya ile işi biten programcı ı ı ı
#include <unistd.h>
int close(int fd);
Fonksiyon dosya betimleyicisini parametre olarak alı ı ı ı ı ı ı
değerine geri dönmektedir. Ancak fonksiyonun başarı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Dosyadan okuma yapmak için read isimli POSIX fonksiyonu kullanı ı
#include <unistd.h>
ssize_t read(int fd, void *buf, size_t nbyte);
Fonksiyonun birinci parametresi okuma işleminin yapı ı
bilgilerin yerleştirileceği bellekteki transfer adresini belirtir. Üçüncü parametre ise okunmak istenen byte sayı ı ı
Fonksiyon başarı ı ı ı ı ı
dosya göstericinin gösterdiği yerden dosya sonuna kadar var olan byte sayı ı
kadar byte'ı ı ı
Fonksiyon 0 ile geri döner. Tabii bu durum fonksiyonun başarı ı ı
Bu durumda fonksiyon hata kontrollerini yapar, eğer bir hata söz konusu değilse 0 ile geri döner.
Fonksiyonun geri dönüş değerinin ssize_t türünden olduğuna dikkat ediniz. ssize_t standart C typedef ismi değildir. POSIX sistemlerinde
bulunmaktadı ı ı ı
size_t türünün işaretli versiyonu olarak bulundurmuştur.Aslı
typedef edilmiş durumdadı ı ı ı ı ı ı ı ı
dosyaları ı
Aşağı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#define BUFFER_SIZE 512
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int fd;
char buf[BUFFER_SIZE + 1];
ssize_t result;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((fd = open(argv[1], O_RDONLY)) == -1)
exit_sys("open");
while ((result = read(fd, buf, BUFFER_SIZE)) > 0) {
buf[result] = '\0';
printf("%s", buf);
}
if (result == -1)
exit_sys("read");
close(fd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde dosyaya yazma yapmak için write isimli POSIX fonksiyonu kullanı ı
#include <unistd.h>
ssize_t write(int fd, const void *buf, size_t nbyte);
Fonksiyonun parametrik yapı ı ı ı ı ı ı ı ı
durumunda -1 değerine geri dönmektedir. write fonksiyonu ile istediğimiz kadar byte'ı ı ı ı ı
karşı ı ı ı
Eğer bir hata söz konusu olmazsa 0 değeri ile geri döner.
Aşağı ı ı ı ı ı ı ı ı ı ı
olarak alı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int fd;
char buf[] = "this is a test";
ssize_t result;
size_t len;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((fd = open(argv[1], O_WRONLY)) == -1)
exit_sys("open");
len = strlen(buf);
if ((result = write(fd, buf, len)) == -1)
exit_sys("write");
if (result != len) {
fprintf(stderr, "partial write error!...\n");
exit(EXIT_FAILURE);
}
close(fd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde dosya göstericisinin konumlandı ı ı ı ı
şöyledir:
#include <unistd.h>
off_t lseek(int fd, off_t offset, int whence);
Fonksiyon C'nin fseek fonksiyonuna çok benzemektedir. Fonksiyonun birinci parametresi dosya betimleyicisini, ikinci parametresi konumlandı
offset'ini ve üçüncü parametresi de konumlandı ı
birini alabilir:
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_SEND 2
Fonksiyon başarı ı ı ı ı ı
off_t <unistd.h> ve <sys/types.h> içerisinde "işaretli bir tamsayı
başarı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux dünyası ı
sahiptir. Bu sistemlerde dosya göstericisi EOF ötesine konumlandı ı ı ı ı
denilmektedir. Dosya delikleri gerçek anlamda diskte tahsis edilemzler. Dosya deliklerinden okuma yapı ı ı ı
Aşağı ı ı ı ı ı ı ı ı
aşağı
$ls -l test.txt
-rw-r--r-- 1 kaan study 5000001 Tem 22 20:07 test.txt
$du test.txt
8 test.txt
Burada dosyanı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
int fd;
if ((fd = open("test.txt", O_WRONLY)) == -1)
exit_sys("open");
if (lseek(fd, 5000000, SEEK_SET) == -1)
exit_sys("open");
if (write(fd, "x", 1) == -1)
exit_sys("write");
close(fd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Text mode, binary mode kavramları ı ı
byte toplulukları ı ı ı
yüksek seviyeli kavramlardı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde bri kullanı ı ı ı ı ı ı ı
proseslere ilişkin "proses kontrol bloğunda turulan" şu önemli erişim bilgileri vardrı
- Gerçek Kullanı ı
- Gerçek Grup Id'si (Real Group Id)
- Etkin Kullanı ı
- Etkin Grup Id'si (Effective Group Id)
Default durumda prosesin gerçek kullanı ı ı ı ı ı
her zaman etkin kullanı ı ı
Pekiyi prosesin kullanı ı ı ı ı ı
aslı ı ı ı ı ı ı
ile yine burada belirtilen proramı ı ı ı ı ı ı ı
aslı ı ı
aktarı ı ı ı ı ı ı ı ı ı ı
/etc/passwd dosyası ı ı ı ı ı ı ı ı ı
Örnek bir satı
student:x:1001:1001:Student,,,:/home/student:/bin/bash
İlk alan kullanı ı ı ı ı ı
'x' varsa bu şifre bilgisinin /etc/shadow dosyası
bu alanda şifre "şifrelenmiş bir biçimde" tutulmaktadı ı ı ı
bulunmaktadı ı ı ı ı ı
Dördüncü alanda kullanı ı ı ı ı
ve etkin grup id'sini bu değer olarak set etmektedir. Beşinci alanda kullanı ı ı ı
sistemin işleyişi ile ilgili değildir. Altı ı ı ı ı
Nihayet yedinci alanda login başarı ı ı ı ı ı ı
programı ı
UNIX/Linux sistemlerinde geleneksel olarak her kullanı ı ı ı
UNIX/Linux sistemlerinde bir grup kullanı ı ı ı
saklanmaktadı
Linux sistemleri kurulurken zaten kurulum programları ı ı ı ı ı ı
oluşturulabilir. Bu işlemler "adduser" ya da "useradd" komutları ı ı ı
yapı
UNIX/Linux sistemlerinde aynı ı ı ı ı
Ancak dosyalar söz konusu olduğunda "gerçek" ve "etkin" kavramları ı
iki id'si yoktur. Tek bir id'si vardı ı ı ı
kaan@kaan-virtual-machine:~/Study/SysProg$ ls -l
toplam 76
-rwxr-xr-x 1 kaan study 16136 Haz 17 18:51 a.out
-rw-r--r-- 1 kaan study 3570 Haz 18 18:57 disp.c
-rw-r--r-- 1 kaan study 1622 Haz 11 20:40 mample.c
......
Aslı ı ı ı ı ı ı
"/etc/group" dosyaları ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde her dosyanı ı ı ı
görüntülenmektedir. Örneğin:
-rw-r--r-- 1 kaan study 3570 Haz 18 18:57 disp.c
Buradaki karakterlerin en solundaki karakter dosyanı ı ı
anlamı ı ı ı
türündne sonraki karakterler üçlü üç grup oluşturmaktadı
- rwx rwx rwx
İlk üçlü gruba "owner", sonraki üçlü gruba "group" ve sonraki üçlü gruba "other" denilmektedir. Bu gruplar dosyanı ı
grupta olanları
"r", "w" ya da "x" harflerini görürüz. Eğer burada bir hak yoksa biz ilgili pozisyonda "-" karakterini görürüz. Örneğin bir dosyanı
hakları
-rw-r-----
Bu dosyaya dosyanı ı ı ı
yapabilirler. Herhangi kişiler bu dosya üzerinde işlem yapamazlar.
Bir dosyanı ı ı ı ı ı ı ı ı ı
"ilgili kişey çalı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Dosya erişim hakları ı ı ı
1) open fonksiyonu önce prosesin etkin kullanı ı ı ı ı
İstek kabul edilir. Etkin kullanı ı
2) open fonksiyonu prosesin etkin kullanı ı ı ı ı ı ı
ilişkin kullanı ı ı ı ı ı ı ı
3) open fonksiyonu prosesin etkin grup id'si ile dosyanı ı ı ı
bir kullanı ı ı ı ı ı ı ı
4) open fonksiyonu dosyanı ı ı ı ı ı
Örneğin bir prosesin etkin kullanı ı ı ı ı
-rw-r--r-- 1 ali study 3570 Haz 18 18:57 test.txt
Bu proses dosyayı ı ı
fd = open("test.txt", O_RDWR);
Burada open fonksiyonu başarı ı ı ı ı ı ı ı
id'si dosyanı ı ı ı ı ı ı ı ı
"group" kı ı ı ı ı ı ı ı ı ı
open başarı ı ı ı
fd = open("test.txt", O_RDONLY);
Şimdi aynı ı ı ı
uygulamı
fd = open("test.txt", O_RDONLY);
Burada prosess dosyaya göre "other" durumundadı ı ı ı ı ı ı
biçimindedir. Bu durumda open başarı ı ı
Diğer bir dosyanı ı
---------- 1 ali study 3570 Haz 18 18:57 x.txt
Bu dosyayı ı ı ı
fd = open("x.txt", O_RDWR);
Etkin kullanı ı ı ı ı ı ı
Bir kullanı ı ı ı ı ı ı
-r--rw-rw-
Burada dosyanı ı ı
yapabilecektir.
Bir programı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
yetkisizlikten bir şeyi yapamı ı ı ı
yapamamaktadı ı ı ı ı ı ı ı ı ı
UNIX/Linux sistemlerindeki güvenlik mekanizması ı ı ı
kullanı ı ı ı
proses yalnı ı
geliştirilmek istenmiştir. Örneğin Linux sistemleri "capability" denilen bir özelliğe sahiptir. Linux sistemlerinde bir proses root olmadı ı
halde bazı
sistemlerinde bu biçimde çeşitli konulara ilişkin capablity'ler oluşturulmuştur. Bazı ı
denilen bir mekanizmaya da sahiptir. POSIX standartları ı ı ı ı
işletim sistemlerinin bu tür özelliklere sahip olabileceği fikriyle tasarlanmı ı ı
"etkin kullanı ı ı ı ı
terimi Linux için "ya prosesin etkin kullanı ı ı ı ı
gelmektedir. Biz de kursa notları ı ı ı ı ı
terimini kullanacağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi UNIX/Linux sistemlerinde bir dosyanı ı ı ı ı ı ı
bu dosya ilk kez yaratı ı ı ı ı ı ı
set edilmektedir. Ancak yeni yaratı ı ı
standartları ı ı
onu yaratan prosesin etkin grup id'si olarak (System 5 semantiği) ya da o dosyanı
set edilmektedir. Linux default durumda yeni yaratı ı
Pekiyi dosyanı ı ı ı ı
üçüncü parametresi erişim hakları ı
bayrağı ı ı ı ı ı ı ı
oluşturmalı ı ı
dosyası ı
open fonksiyonunda erişim hakları ı
sokulmaktadı
S_IRUSR
S_IWUSR
S_IXUSR
S_IRGRP
S_IWGRP
S_IXGRP
S_IROTH
S_IWOTH
S_IXOTH
Buradaki sembolik sabitlerin hepsi S_I öneki ile başlatı ı ı
harfleri izlemektedir. Örneğin S_IRUSR|S_IWUSR|S_IRGRP|_SIROTH hakları ı
Yukarı ı ı
bu sembolik sabitlerin değerlerini tamamen bir tamsayı ı ı ı ı ı
karşı ı ı
rwx rwx rwx
Bir octal digit 3 bit ile açı ı ı ı ı ı ı
girilebilmektedir. Örneğin 0644 ocal sayı ı ı
deyişle S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH işleminin eşdeğeri 0644'tür. Ancak eski sistemler bu sembolik sabitleri bu biçimde define
etmemiş olabilirler. Dolayı ı ı ı
uygun olabilir. Ayrı ı ı ı
#define S_IRWXU (S_IRUSR|S_IWUSR|S_IXUSR)
#define S_IRWXG (S_IRGRP|S_IWGRP|S_IXGRP)
#define S_IRWXO (S_IROTH|S_IWOTH|S_IXOTH)
Bu durumda tüm erişim hakları ı ı ı ı
Aşağı
int fd;
...
if ((fd = open("y.txt", O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) == -1)
exit_sys("open");
Burada bir noktaya yeniden dikkatinizi çekmek istiyoruz: open fonksiyonun ikinci parametresinde O_CREAT bayrağı ı ı ı
üçüncü parametrenin fonksiyon tarafı ı ı ı ı ı
parametre kullanı ı ı ı
Örneğin:
fd = open("z.tzt", O_RDWR|O_CREAT, 0);
Burada dosyanı ı ı ı ı ı ı
yaratı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı
denilen bir değerle işleme sokulur. Nihai erişim hakları
fonksiyonunda girilse bile dosyaya verilmemektedir. Prosesin umask değeri üst prosesten alt prosese aktarı ı ı ı
umask değeri "umask" isimli komutla elde edilebilir. Örneğin:
$umask
0022
Buradaki umask değeri octal değer olarak görüntülenmektedir. Yukarı ı ı ı
000 010 010
Burada gruba write hakkı ı ı ı ı ı ı
mode olmak üzere nihai erişim hakları ı ı
silinmektedir.
Kabuk programı ı ı ı ı ı ı ı
$umask 0
$umask
0000
Bir proses kendi umask değerini istediği zaman umask isimli POSIX fonksiyonu ile değiştirebilir. Bunun için bir koşul gerekmemektedir.
Fonksiyonun prototipi şöyledir:
#include <sys/stat.h>
mode_t umask(mode_t cmask);
Fonksiyon yeni umask değerini parametre olarak alı ı ı ı
biçimde verebiliriz. Ancak S_IXXX sembolik sabitleriyle vermek iyi bir tekniktir. Fonksiyon başarı ı ı
fonksiyonunda verdiğimiz erişim hakları ı ı ı ı ı ı ı ı ı ı
çekebiliriz. Örneğin:
int fd;
...
umask(0);
if ((fd = open("z.txt", O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)) == -1)
exit_sys("open");
Prosesin umask değerini alan arı
yapmak gerekir. Örneğin:
mode_t mode;
...
mode = umask(0);
umask(mode);
Pekiyi prosesler için umask değerine nedne gereksinim duyulmuştur? Bunun birkaç nedeni vardı
ortadan otomatik biçimde kaldı ı ı ı ı ı ı ı
de kullanı ı ı ı ı ı ı
İşte UNIX/Linux sistemleri için standart C kütüphanesini yazanlar genellikle default erişim hakları ı
Fakat bu işlem prosesin umask değerinden etkileneceği için biz programı ı ı ı
bunu dı ı ı ı ı ı ı
ilişkin erişim hakları ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde dosya kopyalamaya bir örnek.
./mycp [-i -n][--interactive --no-clobber] <source path> <destination path>
Bir dosyanı ı ı ı ı ı ı ı ı
anlayabilmek için access isimli bir POSIX fonksiyonu kullanı ı ı
yapabilmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* mycp.c */
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <getopt.h>
#define BUF_SIZE 8192
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int result;
int i_flag, n_flag;
int err_flag;
char buf[BUF_SIZE];
int fds, fdd;
ssize_t n;
struct option options[] = {
{"interactive", no_argument, NULL, 'i'},
{"no-clobber", required_argument, NULL, 'n'},
{0, 0, 0, 0 },
};
opterr = 0;
i_flag = n_flag = 0;
err_flag = 0;
while ((result = getopt_long(argc, argv, "in", options, NULL)) != -1) {
switch (result) {
case 'i':
i_flag = 1;
break;
case 'n':
n_flag = 1;
break;
case '?':
if (optopt != 0)
fprintf(stderr, "invalid option: -%c\n", optopt);
else
fprintf(stderr, "invalid long option!..\n");
err_flag = 1;
break;
}
}
if (err_flag)
exit(EXIT_FAILURE);
if (argc - optind != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if (n_flag || i_flag) {
if (access(argv[optind + 1], F_OK) == 0) {
if (n_flag) {
fprintf(stderr, "file already exits! (-n specified)\n");
exit(EXIT_FAILURE);
}
if (i_flag) {
printf("file already exists! Overwrite? (Y/N):");
if (tolower(getchar()) != 'y')
exit(EXIT_FAILURE);
}
}
}
if ((fds = open(argv[optind], O_RDONLY)) == -1)
exit_sys("open");
if ((fdd = open(argv[optind + 1], O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == -1)
exit_sys("open");
while ((n = read(fds, buf, BUF_SIZE)) > 0)
if (write(fdd, buf, n) == -1)
exit_sys("write");
if (n == -1)
exit_sys("read");
close(fds);
close(fdd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
15. Ders 29/07/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Bugün kullandı ı ı ı ı ı
bası ı ı ı ı ı
bası ı ı ı ı ı
teknolojisi gelişince grafik modda çalı ı ı ı ı
programlara "konsol tabanlı ı ı ı
şeyler bu imlecin bulunduğu yerden itibaren yazı ı ı
dosyası ı ı ı
de yazı ı ı ı
sütun bittiğinde sonraki satı ı ı ı ı ı ı
her satı ı ı ı ı ı ı ı ı
olarak basit bir arayüz oluşturmaktadı ı ı ı ı ı ı ı
80 sütun eskiden beri en yaygı ı
Grafik modda ekrandaki en küçük birim bir pixel'dir. Pixel ("picture element" sözcüklerinden kı ı ı ı
grafik öğedir. Grafik modda her şey ğixel'lerin uygun biçimde bir araya getirilmesiyle oluşturulmaktadı
genişlik ve yükseklik değeri ile belirtilmektedir. Örneğin 1920X1080 çözünürlük demek ekranda toplam 1980 * 1020 tane pixel var demektir.
Text modda yalnı
modda görüntüleyemeyiz. Ancak grafik modda görüntüleyebiliriz. Bir program çı ı ı ı ı
"GUI (Graphical User Interface) tabanlı ı ı
Text mod için program yazmak oldukça kolaydı ı
fonksiyonları ı ı ı
Bugün GUI tabanlı ı ı ı ı ı ı
Bu nedenle pek çok temel araç GUI çalı ı ı ı
arayüzü arayüzü kullanmazlar. Klasik konsole tabanlı ı ı ı
sistemlerdir. Ancak UNIX/Linux dünyası ı ı ı ı ı ı ı
server sistemlerinde ve gömülü sistemlerde kullanı ı ı ı ı
gerektirmesinden dolayı ı ı ı ı ı ı ı
Ancak bu grafik arayüz kolaylı ı ı ı ı
Bugün kullandı ı ı ı ı ı ı
GUI arayüzleri konsole ekranı ı ı
grafik modda çalı ı ı ı ı ı ı ı ı ı ı
bir emülasyon yapı ı ı ı ı ı
pixel işlemleriyle oluşturulmuştur. Yani bugün grafik arayüze sahip işletim sistemlerinde biz bir konsol terminali açtı ı ı
penceresi eski devirdeki text modda çalı
Renkli görüntünün bilgisayar ekranları ı ı ı ı ı ı
olgusu vardı ı ı ı ı ı
olmak üzere üç temel renk vardı ı
bu üç ana renk toplam 256 farklı ı ı ı
renkten biri ile renklendirilebilmektedir. Ayrı ı
daha bulunudurlmaktadı ı ı ı ı ı
Pekiyi eskiden text modda renk kavramı ı ı ı ı ı ı
sokulmultur. Text moddaki her bir karakter matrisinin zemini ve şekli yarı ı ı
da söz konusu olmaktadı ı ı
renkleri de aslı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi konsole ekranı ı ı ı ı ı ı ı ı
yazdı ı
renkli yazı ı ı
1) ANSI terminal komutları
2) Özel kütüphane fonksiyonları
stdout için aygı ı ı ı ı
Bu özel karakterler kullanı ı ı ı ı
başlatı ı ı ı ı ı
denilebilmektedir. Tüm ANSI terminal komutları ı ı ı
Örneğin imleci (cursor) belli bir yere taşı ı ı
"\x1B[row;colH"
Buradaki \x1B aslı ı ı ı
row imlecin taşı ı ı ı ı ı ı ı ı
"\x1B[12;18H"
Bu komut imleci 12'inci satı ı ı ı
void move_cursor(int row, int col)
{
printf("\x1B[%d;%dH", row, col);
}
İmleci yok etmek şu ANSI terminal komutu kullanı ı
"\x1B[?25l"
İmleci yeniden görünür yapmak için ise şu komut kullanı ı
"\x1B[?25h"
Tabii bu işlemleri birer fonksiyon haline de getirebiliriz:
void hide_cursor(void)
{
printf("\x1B[?25l");
}
void show_cursor(void)
{
printf("\x1B[?25h");
}
İmlecin konumunu aygı ı ı ı
"\x1B\x37"
İmlecin son saklanan pozisyona geri yerleştirilmesi için ise şu komut komut kullanı ı
"\x1B\x38"
Bu işlemleri fonksiyon olarak da yazabiliriz:
void save_cursor(void)
{
printf("\x1B\x37");
}
void restore_cursor(void)
{
printf("\x1B\x38");
}
ANSI escape komutları
Text modda yazı ı ı ı ı
yapı ı ı ı ı ı ı ı ı ı ı ı ı ı
şu komut kullanı ı
"\x1b[31m"
Her renk için buradaki sayı ı
#define BLACK_COLOR 30
#define RED_COLOR 31
#define WHITE_COLOR 37
#define BLUE_COLOR 34
....
void change_color(int color)
{
printf("\x1b[%dm", color);
}
Renkelndirme için aşağı
https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Text ekranda ayrı ı ı ı ı ı
yeni versiyonu olan "ncurses" kütüphaneleri bu amaçla çokça kullanı ı ı
ismine "Console API Fonksiyonları
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define BLACK_COLOR 30
#define RED_COLOR 31
#define WHITE_COLOR 37
#define BLUE_COLOR 34
void move_cursor(int row, int col)
{
printf("\x1B[%d;%dH", row, col);
}
void hide_cursor(void)
{
printf("\x1B[?25l");
}
void show_cursor(void)
{
printf("\x1B[?25h");
}
void change_color(int color)
{
printf("\x1b[%dm", color);
}
int main(void)
{
time_t t, prev_t;
struct tm *pt;
int count;
change_color(BLUE_COLOR);
hide_cursor();
prev_t = 0;
count = 0;
for (;;) {
t = time(NULL);
pt = localtime(&t);
move_cursor(1, 80);
printf("%02d:%02d:%02d", pt->tm_hour, pt->tm_min, pt->tm_sec);
if (prev_t != t) {
++count;
if (count == 10)
break;
}
prev_t = t;
}
show_cursor();
change_color(WHITE_COLOR);
return 0;
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Windows'un Console API fonksiyonları ı ı ı
Bu işlem GetStdHandle isimli API fonksiyonuyla yapı ı
HANDLE WINAPI GetStdHandle(
DWORD nStdHandle
);
Fonksiyon parametre olarak handle değeri alı ı ı
STD_INPUT_HANDLE
STD_OUTPUT_HANDLE
STD_ERROR_HANDLE
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
16. Ders 30/07/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
WrtiteConsole API fonksiyonu bir adresten itibaren belli miktardaki karakteri imlecin bulunduğu yerden itibaren yazmaktadı ı
puts gibi bir işleve sahiptir. (Tabii imleci aşağı ı ı ı
BOOL WINAPI WriteConsole(
HANDLE hConsoleOutput,
const VOID *lpBuffer,
DWORD nNumberOfCharsToWrite,
LPDWORD lpNumberOfCharsWritten,
LPVOID lpReserved
);
Fonksiyonun birinci parametresi stdout dosyası ı ı
üçüncü parametresiyle belirtilen miktarda karakteri imlecin bulunduğu yere yazar. Başarı ı ı ı ı
parametresiyle girdiğimiz DWORD nesye yerleştirmektedir. Son parametre reserved durumdadı ı
Ancak genellikle başarı
İmleci konumlandı ı ı
BOOL WINAPI SetConsoleCursorPosition(
HANDLE hConsoleOutput,
COORD dwCursorPosition
);
Örneğin:
HANDLE hConsole;
char buf[] = "this is a test";
DWORD dwWritten;
...
WriteConsole(hConsole, buf, strlen(buf), &dwWritten, NULL);
Fonksiyonun birinci parametresi stdout dosyası ı ı ı ı
COORD yapı ı
typedef struct _COORD {
SHORT X;
SHORT Y;
} COORD, *PCOORD;
Fonksiyon işlemin başarı ı
COORD coord;
...
coord.X = 10;
coord.Y = 20;
SetConsoleCursorPosition(hConsole, coord);
C99 ile birlikte dile eklenen "bileşik sabitler (compound literals)" ile aynı ı
SetConsoleCursorPosition(hConsole, (COORD){10, 12});
İmlecin bulunduğu yerden bağı ı ı ı ı ı ı
isimli API fonksiyonu kullanı ı
BOOL WINAPI WriteConsoleOutputCharacter(
HANDLE hConsoleOutput,
LPCTSTR lpCharacter,
DWORD nLength,
COORD dwWriteCoord,
LPDWORD lpNumberOfCharsWritten
);
fonksiyonun birinci parametres, console ekranı ı ı ı ı ı ı
parametresi yazdı ı ı ı ı ı ı ı ı ı ı ı
yazı ı ı ı ı ı ı ı ı ı ı ı ı
başarı ı ı ı ı
bir fonksiyon şöyle yazı
void putclock(int row, int col)
{
HANDLE hConsole;
struct tm *pt;
time_t t;
char buf[1024];
DWORD dwWritten;
if ((hConsole = GetStdHandle(STD_OUTPUT_HANDLE)) == INVALID_HANDLE_VALUE)
ExitSys("GetStdHandle");
t = time(NULL);
pt = localtime(&t);
sprintf(buf, "%02d:%02d:%02d", pt->tm_hour, pt->tm_min, pt->tm_sec);
if (!WriteConsoleOutputCharacter(hConsole, buf, strlen(buf), (COORD){ col, row }, &dwWritten))
ExitSys("WriteConsoleOutputCharacter");
}
Yazı ı ı ı
BOOL WINAPI SetConsoleTextAttribute(
HANDLE hConsoleOutput,
WORD wAttributes
);
Fonsiyonun ikinci parametresi özellik bilgisini belirtmektedir. Özellik bir renk ya da diğer bazı ı ı
sembolik sabitler bit düzeyinde OR işlemiyle özellik oluşturmakta kullanı
FOREGROUND_BLUE
FOREGROUND_GREEN
FOREGROUND_RED
FOREGROUND_INTENSITY
BACKGROUND_BLUE
BACKGROUND_GREEN
BACKGROUND_RED
BACKGROUND_INTENSITY
COMMON_LVB_REVERSE_VIDEO
COMMON_LVB_UNDERSCORE
Örneğin:
SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE);
WriteConsole(hConsole, buf, strlen(buf), &dwWritten, NULL);
SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED);
İmleci yok etmek için SetConsoleCursorInfo isimli fonksiyon kullanı ı
BOOL WINAPI SetConsoleCursorInfo(
HANDLE hConsoleOutput,
const CONSOLE_CURSOR_INFO *lpConsoleCursorInfo
);
Fonksiyonun ikinci parametresi CONSOLE_CURSOR_INFO isimli bir yapı ı ı
typedef struct _CONSOLE_CURSOR_INFO {
DWORD dwSize;
BOOL bVisible;
} CONSOLE_CURSOR_INFO, *PCONSOLE_CURSOR_INFO;
Yapı ı ı ı ı ı ı ı
ya da FALSE girilebilir. Eğer bu elemana FALSE girilirse imleç görünmez olur. Aslı
bir fonksiyon vardı ı ı ı ı ı ı ı
yapı
CONSOLE_CURSOR_INFO cci;
...
GetConsoleCursorInfo(hConsole, &cci);
cci.bVisible = FALSE;
SetConsoleCursorInfo(hConsole, &cci);
Konsole penceresinin karakter genişliğini ve yüksekliğini almak için GetConsoleScreenBufferInfo API fonksiyonu kullakı ı
prototipi şöyledir:
BOOL WINAPI GetConsoleScreenBufferInfo(
HANDLEhConsoleOutput,
PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
);
Fonksiyonun ikinci parametresi CONSOLE_SCREEN_BUFFER_INFO isimli bir yapı ı ı
typedef struct _CONSOLE_SCREEN_BUFFER_INFO {
COORD dwSize;
COORD dwCursorPosition;
WORD wAttributes;
SMALL_RECT srWindow;
COORD dwMaximumWindowSize;
} CONSOLE_SCREEN_BUFFER_INFO;
Bu fonksiyonla imlecin konumuda alı ı
CONSOLE_SCREEN_BUFFER_INFO csbi;
...
GetConsoleScreenBufferInfo(hConsole, &csbi);
width = csbi.srWindow.Right - csbi.srWindow.Left + 1;
height = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
Aşağı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hConsole;
char buf[1024] = "this is a test";
DWORD dwWritten;
CONSOLE_CURSOR_INFO cci;
CONSOLE_SCREEN_BUFFER_INFO csbi;
int width, height;
int len;
if ((hConsole = GetStdHandle(STD_OUTPUT_HANDLE)) == INVALID_HANDLE_VALUE)
ExitSys("GetStdHandle");
GetConsoleCursorInfo(hConsole, &cci);
cci.bVisible = FALSE;
SetConsoleCursorInfo(hConsole, &cci);
SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE);
SetConsoleCursorPosition(hConsole, (COORD){ 10, 12 });
WriteConsole(hConsole, buf, strlen(buf), &dwWritten, NULL);
GetConsoleScreenBufferInfo(hConsole, &csbi);
width = csbi.srWindow.Right - csbi.srWindow.Left + 1;
height = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
SetConsoleCursorPosition(hConsole, (COORD){ 10, 13 });
len = snprintf(buf, 1024, "Width: %d, Height: %d\n", width, height);
WriteConsole(hConsole, buf, len, &dwWritten, NULL);
SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED);
getchar();
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı
karakterlerin kalı ı ı ı ı ı ı ı
ekranı ı ı
çizimleri yapı
bulundurulmuştur. Bugün bilgisyaraları ı ı
ve bunun UTF-8 denilen encoding'i en yaygı ı
Örneğin UNICODE tabloda tipik çerçeve karakterlerinin code point'leri şunlardı
#define BOX_LL "\u2514"
#define BOX_V "\u2502"
#define BOX_H "\u2500"
#define BOX_UL "\u250C"
#define BOX_UR "\u2510"
#define BOX_LR "\u2518"
Bu UNICODE karakterlerin aynı ı ı ı ı ı ı
de bulunmaktadı
Yukarı
derleyicilerin "execution character set" denilen ayarları ı ı
derleyicisinin default "execution character set" ayarı ı
çı ı ı ı ı ı ı ı ı ı ı ı ı
biçimde ele alı ı
Visual Studio'da derleyicinin "execution character set"i eğer UTF-8 değilse onu proje seçeneklerinden C/C++ komut satı ı
"/utf-8" girerek UTF-8 olarak dğeiştirebilirsiniz. Eğer console ekranı ı ı ı ı
"65001" yaparak UTF-9'e geçirebilirsiniz:
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Nls\CodePage\OEMCP
Ayrı ı ı ı ı
girmelisiniz:
HKEY_LOCAL_MACHINE\Software\Microsoft\Command Processor\Autorun
Aşağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define BOX_LL "\u2514"
#define BOX_V "\u2502"
#define BOX_H "\u2500"
#define BOX_UL "\u250C"
#define BOX_UR "\u2510"
#define BOX_LR "\u2518"
void save_cursor(void)
{
printf("\x1B\x37");
}
void restore_cursor(void)
{
printf("\x1B\x38");
}
void move_cursor(int row, int col)
{
printf("\x1B[%d;%dH", row, col);
}
void hide_cursor(void)
{
printf("\x1B[?25l");
}
void show_cursor(void)
{
printf("\x1B[?25h");
}
int main(int argc, char *argv[])
{
save_cursor();
hide_cursor();
move_cursor(10, 10);
printf(BOX_LL);
move_cursor(9, 10);
printf(BOX_V);
move_cursor(10, 11);
printf(BOX_H);
move_cursor(10, 12);
printf(BOX_H);
move_cursor(8, 10);
printf(BOX_UL);
move_cursor(8, 11);
printf(BOX_H);
move_cursor(8, 12);
printf(BOX_H);
move_cursor(8, 13);
printf(BOX_UR);
move_cursor(9, 13);
printf(BOX_V);
move_cursor(10, 13);
printf(BOX_LR);
restore_cursor();
show_cursor();
return 0;
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Biz daha önce Windows'ta UNIX/Linux sistemlerinde "temel dosyaları ı ı
yapmaktaydı ı ı ı ı
Bu yardı ı ı ı ı
ilgili API fonksiyonları ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde dosya silmek için DeleteFile isimli API fonksiyonu kullanı ı
BOOL DeleteFile(
LPCTSTR lpFileName
);
Fonksiyon silinecek dosyanı ı ı ı ı ı ı ı ı
geri döner. Bir dosya çeşitli nedenlereden dolayı ı ı ı ı
uygun hata mesajı
if (!DeleteFile("test.txt"))
ExitSys("DeleteFile");
Kursun başı ı ı
fonksiyondur.
Windows'ta bir dosya açı ı ı ı ı ı ı
Eğer bir dosya CreateFile fonksiyonu ile açı ı ı
dosya açı ı ı ı ı ı
FILE_SHARE_DELETE baytrağı ı ı
dosya açmı ı ı ı ı
Microsoft C derleyicisinin fopen fonksiyonu dosyayı ı ı ı
Aşağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
if (!DeleteFile("test.txt"))
ExitSys("DeleteFile");
printf("File successfully deleted...\n");
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
17. Ders 05/08/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Bir dosyanı ı ı ı ı ı
isimli bir dosya bulunuyor olsun. Biz de bu dosyayı ı
yoluyla erişiriz. Dosyaları ı ı ı
içindeki bilgilerin bulunduğu disk alanı ı ı ı ı ı ı ı ı
dosyanı ı ı ı ı ı ı
diskteki bilgilerine referans edecek biçimde oluşturulmaktadı ı ı
dizinine taşı ı ı ı ı ı
"C:\Study" dizinindeki "test.txt" dizin girişini siler, "C:\Sample" dizininde aynı ı
dizin girişi oluşturur. Bu işlem dosyanı ı ı ı ı
sistemlerinde "isim değiştirme (rename)" "taşı ı ı ı ı
sanki onu aynı ı ı ı
bilgileri de taşı ı ı
mecburen işletim sistemi dosya içeriğini de fiziksel olarak taşı ı
Windows sistemlerinde dosya taşı ı ı ı
Fonksiyonun prototipi şöyledir:
BOOL MoveFile(
LPCTSTR lpExistingFileName,
LPCTSTR lpNewFileName
);
Fonksiyonun birinciparametresi kaynak yol ifadesini ikinci parametresi hedef yol ifadesini almaktadı
işlemin başarı ı ı ı ı ı ı ı ı ı
Dolayı ı ı ı ı ı ı ı
Aşağı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
if (!MoveFile("test.txt", "mest.txt"))
ExitSys("MoveFile");
printf("File successfully moved...\n");
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Windows API fonksiyonları ı ı ı ı
genişletme (yani işlevlerini gemişletme) yapma gereksinimi ortaya çı ı ı
daha gelişmiş yeni bir versiyonunu da oluşturmuştur. Genel olarak Micrsoft bir fonksiyonun genişletilmiş yeni versyionunu Ex sonekiyle isimlendirmektedir.
Örneğin LockFile fonksiyonunun yeni genişletilmiş ismi LockFileEx biçimindedir. APı ı ı ı ı ı ı
niteliktedir. Ancak genel olarak Ex'li versiyonları ı ı
için nedeniniz yoksa bunları ı ı
API fonksiyonları ı ı ı ı ı
"deprecated" yapı ı ı ı ı ı
bu fonksiyonu kullanmamaları ı ı ı
da bulunuyor durumdadı
"Deprecated" sözcüğü yalnı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde GetFileSize API fonksiyonu açı ı ı
genişletilmiş bir biçimi de vardı
DWORD GetFileSize(
HANDLE hFile,
LPDWORD lpFileSizeHigh
);
Fonksiyonun birinci parametresi açı ı ı ı
anlamlı ı ı ı ı ı ı ı
adresini almaktadı ı ı
Fonksiyonun ikinci parametresi NULL girilmediğinde fonksiyon başarı ı
Tabii bu özel değerin aslı ı ı ı ı ı ı
ayrı ı ı ı ı ı ı
değer vermektedir. Ancak fonksiyon da şöyle bir kusur vardı
değerinde başarı ı ı ı ı ı
dwSizeLow = GetFileSize(hFile, &dwLow);
if (dwSizeLow == INVALID_FILE_SIZE && GetLastError() != NO_ERROR)
ExitSys("GetFileSize");
Açı ı
almak olabilir. Tabii bir dosyanı ı ı ı ı ı
elde edilmesi de mümkündür. Bu işlemin yapı ı ı
Aşağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hFile;
DWORD dwSizeLow, dwSizeHigh;
if ((hFile = CreateFile("Test.c", GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
ExitSys("CreateFile");
if ((dwSize = GetFileSize(hFile, &dwSizeHigh)) == INVALID_FILE_SIZE && GetLastError() != NO_ERROR)
ExitSys("GetFileSize");
printf("%lu\n", (unsigned long)dwSize); /* prints only low part */
CloseHandle(hFile);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
GetFileSize fonksiyonundaki tasarı ı
BOOL GetFileSizeEx(
HANDLE hFile,
PLARGE_INTEGER lpFileSize
);
Fonksiyon dosya uzunluğunu LARGE_INTEGER türündne bir yapı
başarı ı ı ı ı
typedef union _LARGE_INTEGER {
struct {
DWORD LowPart;
LONG HighPart;
} DUMMYSTRUCTNAME;
struct {
DWORD LowPart;
LONG HighPart;
} u;
LONGLONG QuadPart;
} LARGE_INTEGER;
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hFile;
LARGE_INTEGER li;
if ((hFile = CreateFile("Test.c", GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
ExitSys("CreateFile");
if (!GetFileSizeEx(hFile, &li))
ExitSys("GetFileSizeEx");
printf("%lld\n", li.QuadPart);
CloseHandle(hFile);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Bir dizin (directory) de aslı ı ı ı ı ı
içerisinde o dizindeki dosyaları ı
aynı
Windows'ta bir dizin yaratmak için CreateDirectory isimli API fonksiyonu kullanı ı
BOOL CreateDirectory(
LPCSTR lpPathName,
LPSECURITY_ATTRIBUTES lpSecurityAttributes
);
Fonksiyonun birinci parametresi yaratı ı
almaktadı ı ı
Bir dizin yaratı ı ı
"." ve ".." girişleri de birer dizin belirtir. "." girişi içinde bulunulan dizini, ".." girişi ise içinde bulunulan dizinin üst dizinini
belirtir. Bu dizin girişleri silinememektedir. Kök dizinin dı ı ı
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
if (!CreateDirectory("TestDir", NULL))
ExitSys("CreateDirectory");
printf("Ok\n");
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Windows'ta bir dizin silmek için RemoveDirectory isimli API fonksiyonu kullanı ı
BOOL RemoveDirectory(
LPCSTR lpPathName
);
Fonksiyon parametre olarak silinecek dizin'in yol ifadesini almaktadı ı ı ı
fonksiyonu ile biz ancak boş dizinleri silebiliriz. Bir dizin'in boş olması ı ı
olmaması ı
kullanı ı ı ı
Geri Dönüşüm Kutusu (Recycle Bin) işletim sisteminin çekirdeği ile ilgili bir oragizasyon değildir. Kabuk kı ı
Bu nedenle DeleteFile ya da RemoveFile API fonksiyonları
ile bir dosyayı ı ı
Çünkü geri dönüşüm kutusu zaten kabuk tarafı
de bu bakı ı
Aşağı ı ı ı ı ı
Bu durumda RemoveDirectory fonksiyonunun başarı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
if (!RemoveDirectory("TestDir", NULL))
ExitSys("CreateDirectory");
printf("Ok\n");
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
18. Ders 06/08/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde dosya unlink isimli POSIX fonksiyonu ile silinmektedir. Bu sistemlerde aslı
doğrudan bu unlink fonksiyonunu çağı ı ı
fark yoktur. unlink fonksiyonun prototipi şöyledir:
#include <unistd.h>
int unlink(const char *pathname);
Fonksiyon parametre olarak silinecek dosyanı ı ı ı ı ı
errno değişkeni uygun biçimde set edilir.
Yukarı ı ı
normal dosyalar gibidir. Bir dosyanı ı ı
UNIX/Linux sistemlerinde bir dosyayı ı ı ı ı
bunduğu dizine "w" hakkı ı ı ı ı ı
dosyanı ı ı ı ı
Aşağı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
if (argc == 1) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
for (int i = 1; i < argc; ++i)
if (unlink(argv[i]) == -1)
fprintf(stderr, "cannot unlink %s: %s\n", argv[i], strerror(errno));
return 0;
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Anı ı ı ı ı ı
belirleniyordu. İşte dosyanı ı
şöyledir:
#include <sys/stat.h>
int chmod(const char *pathname, mode_t mode);
Fonksiyonun birinci parametresi erişim hakları ı ı ı
Erişim hakları ı
Açı ı ı
#include <sys/stat.h>
int fchmod(int fd, mode_t mode);
Fonksiyonun birinci parametresi dosya betimleyicisini ikinci parametresi erişim hakları ı ı
0 değerine, başarı ı ı
Eğer dosya zaten açı ı ı ı
daha hı ı
chmod fonksiyonuyla bir dosyanı ı ı ı ı ı ı ı ı
id'si ile aynı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
void exit_sys(const char *msg);
int main(void)
{
if (chmod("test.txt", S_IRUSR | S_IWUSR) == -1)
exit_sys("chmod");
printf("success...\n");
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
int fd;
if ((fd = open("test.txt", O_RDONLY)) == -1)
exit_sys("open");
if (fchmod(fd, S_IRUSR | S_IWUSR) == -1)
exit_sys("fchmod");
close(fd);
printf("success...\n");
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı ı
Programı ı ı ı
./mychmod 666 x.dat y.dat ...
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* chmod.c */
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <errno.h>
#include <sys/stat.h>
bool check_octal(const char *str);
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int mode;
if (argc < 3) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if (!check_octal(argv[1])) {
fprintf(stderr, "file mode incorrect!..\n");
exit(EXIT_FAILURE);
}
sscanf(argv[1], "%o", &mode);
for (int i = 2; i < argc; ++i)
if (chmod(argv[i], mode) == -1)
fprintf(stderr, "chmode failed for %s: %s\n", argv[i], strerror(errno));
return 0;
}
bool check_octal(const char *str)
{
while (*str != '\0') {
if (*str < '0' || *str > '8')
return false;
++str;
}
return true;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı ı
komutu vardı ı ı ı
yazı ı ı ı ı
chmod 666 x.dat y.dat
chmod a+w x.dat
chmod +w x.dat
chmod o+w x.dat
chmod ugo-w x.dat
Komutun detaylı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde bir "dizin (directory)" yaratmak için mkdir isimli POSIX fonksiyonu kullanı ı
şöyledir:
#include <sys/stat.h>
int mkdir(const char *pathname, mode_t mode);
Fonksiyonun birinci parametresi dizin'in yol ifadesini ikinci parametresi ise dizin'in erişim hakları ı ı ı
prosesin umask değeri etkili olmaktadı ı ı
dizinlerde "x" var olduğuna dikkat ediniz. Fonksiyon başarı ı ı ı
başarı ı ı
Bir dizin yaratabilmek için ve bir dosya yaratabilmek için o diznin'in ya da dosyanı ı ı ı ı ı
Çünkü yukarı ı ı ı
dosya ya da dizin yaratmak aslı ı ı
"w" hakkı ı ı
Komut satı ı ı ı
verilmezse komut default olarak tüm erişim hakları ı ı
açı ı ı ı
Yine UNIX/Linux sistemlerinde de bir dizin yaratı ı ı ı
Aşağı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* mymkdir.c */
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <getopt.h>
bool check_octal(const char *str);
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int m_flag;
int err_flag;
char *m_arg;
int result;
int mode;
struct option options[] = {
{"mode", required_argument, NULL, 'm'},
{0, 0, 0, 0}
};
m_flag = err_flag = 0;
opterr = 0;
while ((result = getopt_long(argc, argv, "m:", options, NULL)) != -1) {
switch (result) {
case 'm':
m_arg = optarg;
m_flag = 1;
break;
case '?':
if (optopt == 'm')
fprintf(stderr, "option -m or --mode without argument!..\n");
else if (optopt != 0)
fprintf(stderr, "invalid option: -%c\n", optopt);
else
fprintf(stderr, "invalid long option: %s\n", argv[optind - 1]);
err_flag = 1;
break;
}
}
if (err_flag)
exit(EXIT_FAILURE);
if (argc - optind == 0) {
fprintf(stderr, "requires at least one path name!..\n");
exit(EXIT_FAILURE);
}
if (m_flag) {
if (!check_octal(m_arg)) {
fprintf(stderr, "invalid file mode: %s\n", m_arg);
exit(EXIT_FAILURE);
}
sscanf(m_arg, "%o", &mode);
umask(0);
}
else
mode = 0777; /* POSIX 2008 ve sonrası ı
for (int i = optind; i < argc; ++i)
if (mkdir(argv[i], mode) == -1)
perror(argv[i]);
return 0;
}
bool check_octal(const char *str)
{
while (*str != '\0') {
if (*str < '0' || *str > '8')
return false;
++str;
}
return true;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde dizin silmek için rmdir isimli POSIX fonksiyonu kullanı ı
#include <unistd.h>
int rmdir(const char *pathname);
Fonksiyon dizin'in yol ifadesini parametre olarak alı ı ı ı ı
bir dizin'in silinmnesi için prosesin dizin'in içinde bulunduğu dizine "w" hakkı ı
sahip olması
Komut satrtı ı ı ı
programdı ı ı ı ı
Aşağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
if (argc < 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
for (int i = 1; i < argc; ++i)
if (rmdir(argv[i]) == -1)
perror(argv[i]);
return 0;
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Bir dosyanı ı ı ı
yazı ı ı ı ı ı ı ı
Bu üç fonksiyon aslı ı ı ı ı ı ı
#include <sys/stat.h>
int stat(const char *path, struct stat *buf);
int fstat(int fd, struct stat *buf);
int lstat(const char *path, struct stat *buf);
stat fonksiyonu yol ifadesiyle belirtilen dosyanı ı ı
hareketle dosya bilgilerini elde etmektedir. lstat fonksiyonu da yol ifadesinden hareketle dosya bilgilerini elde eder. Ancak lstat
sembolik bağlantı ı ı ı ı ı
ikinci parametreleriyle belirtilen struct stat isimli bir yapı ı
başarı ı ı ı ı ı ı ı
<sys/stat.h> dosyası
struct stat {
dev_t st_dev; /* ID of device containing file */
ino_t st_ino; /* inode number */
mode_t st_mode; /* protection */
nlink_t st_nlink; /* number of hard links */
uid_t st_uid; /* user ID of owner */
gid_t st_gid; /* group ID of owner */
dev_t st_rdev; /* device ID (if special file) */
off_t st_size; /* total size, in bytes */
blksize_t st_blksize; /* blocksize for file system I/O */
blkcnt_t st_blocks; /* number of 512B blocks allocated */
struct timespec st_atim; /* Time of last access */
struct timespec st_mtim; /* Time of last modification */
struct timespec st_ctim; /* Time of last status change */
#define st_atime st_atim.tv_sec /* Backward compatibility */
#define st_mtine st_mtim.tv_sec
#define st_ctime st_ctim.tv_sec
};
Yapı ı ı ı ı
Yapı ı ı ı ı ı ı ı ı
zorundadı ı ı ı ı ı ı ı ı ı
işaretsiz bir tamsayı ı ı ı ı ı ı ı
mode_t türü bir tamsayı ı ı ı ı ı ı ı ı
Hard link kavramı ı ı ı ı ı ı
elemanları ı ı ı ı ı ı ı
zorundadı ı ı ı ı ı ı ı ı ı ı ı
belirtmektedir. Yapı ı ı ı ı
zorundadı ı ı ı ı ı ı ı
Bu uzunluk sektör katları ı ı ı
alı ı ı ı ı
bölümlerinde ele alı ı ı ı ı ı ı ı
diskte kaç sektörde (yani kaç tane 512 byte içerisinde) bulunduğunu belirtmektedir. blkcnt_t işaretli bir tamsayı
edilmek zorundadı ı ı ı ı ı ı ı ı ı
yapı ı ı ı ı ı
belirtmektedir. Eskiden bu elemanlar time_t türündendi ve 01/01/1970 tarihinden geçen saniyesi sayı ı ı
Standartları ı ı ı ı ı ı ı ı ı ı
hem 01/01/1970'ten geçen saniye sayı ı ı ı ı ı ı ı ı ı
tarih ve zamanı ı ı ı ı ı ı
struct timespec {
time_t tv_sec;
long tv_nsec;
};
Eskiden stat yapı ı ı ı ı
time_t st_atime;
time_t st_mtime;
time_t st_ctime;
POSIX 2008 ile bu konuda değişiklik yapı ı ı ı
#define st_atime st_atim.tv_sec
#define st_mtine st_mtim.tv_sec
#define st_ctime st_ctim.tv_sec
Böylece programcı ı ı
zaman bilgisinin hangilerini değiştirdiği POSIX standartları ı ı
ve st_ctim elemanları ı ı ı
stat yapı ı ı ı ı ı ı ı
elemanı ı ı ı ı ı ı ı ı ı
bu tür bilgilerinin st_mode elemanı ı ı ı ı ı ı
içerisinde S_ISXXX biçiminde çeşitli tür makroları ı ı ı ı ı
bu makrolar elemanı ı ı ı ı
sı ı ı ı ı
S_ISBLK(m) Dosya bir blok aygı ı ı
S_ISCHR(m) Dosya bir karakter aygı ı ı
S_ISDIR(m) Dosya bir dizin dosyası ı
S_ISFIFO(m) Dosya bir boru (pipe) dosyası ı
S_ISREG(m) Dosya sı ı ı
S_ISLNK(m) Dosya bir sembolik bağlantı ı ı
S_ISSOCK(m) Dosya bir UNIX Domain soket dosyası ı
O halde örneğin dosyanı
struct stat finfo;
...
if (stat(path, &finfo) == -1)
exit_sys("stat");
...
if (S_ISBLK(finfo.st_mode))
putchar('b');
else if (S_ISCHR(finfo.st_mode))
putchar('c');
else if (S_ISDIR(finfo.st_mode))
putchar('d');
else if (S_ISFIFO(finfo.st_mode))
putchar('p');
else if (S_ISREG(finfo.st_mode))
putchar('-');
else if (S_ISLNK(finfo.st_mode))
putchar('l');
else if (S_ISSOCK(finfo.st_mode))
putchar('s');
else
putchar('?');
Dosyanı ı ı ı ı ı ı
çekmek ve bunun sonucunu switch deyimine sokmak olabilir. S_IFMT st_mode elemanı
elde edilmesine yol açmaktadı ı
S_IFBLK
S_IFCHR
S_IFIFO
S_IFREG
S_IFDIR
S_IFLNK
S_IFSOCK
Bu durumda dosya türü şöyle de tespit edebilir:
struct stat finfo;
...
if (stat(path, &finfo) == -1)
exit_sys("stat");
...
switch (finfo.st_mode & S_IFMT) {
case S_IFBLK:
putchar('b');
break;
case S_IFCHR:
putchar('c');
break;
case S_IFIFO:
putchar('p');
break;
case S_IFREG:
putchar('-');
break;
case S_IFDIR:
putchar('d');
break;
case S_IFLNK:
putchar('l');
break;
case S_IFSOCK:
putchar('s');
break;
default:
putchar('?');
break;
}
Dosyanı ı ı ı ı ı ı
bit AND işlemine sokmaktı ı ı ı ı ı ı
erişim hakkı ı ı ı ı ı
mode_t modes[9] = {S_IRUSR, S_IWUSR, S_IXUSR, S_IRGRP, S_IWGRP, S_IXGRP, S_IROTH, S_IWOTH, S_IXOTH};
...
for (int i = 0; i < 9; ++i)
putchar(finfo.st_mode & modes[i] ? "rwx"[i % 3] : '-');
Daha önceden de belirttiğimiz gibi POSIX 2008 ile birlikte artı ı
Bu değerler incelendiğinde aslı ı ı ı ı ı
aslı ı ı ı ı
ve sonrası ı
for (int i = 8; i >= 0; --i)
putchar(finfo.st_mode >> i & 1 ? "rwx"[(8 - i) % 3] : '-');
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <time.h>
#include <locale.h>
#include <sys/stat.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
struct stat finfo;
mode_t modes[9] = {S_IRUSR, S_IWUSR, S_IXUSR, S_IRGRP, S_IWGRP, S_IXGRP, S_IROTH, S_IWOTH, S_IXOTH};
char buf[32];
struct tm *ptm;
if (setlocale(LC_ALL, "tr_TR.utf-8") == NULL) {
fprintf(stderr, "cannot set locale!..\n");
exit(EXIT_FAILURE);
}
if (argc == 1) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
for (int i = 1; i < argc; ++i) {
if (stat(argv[i], &finfo) == -1) {
perror(argv[i]);
continue;
}
printf("File Name: %s\n", argv[i]);
printf("File Mode: ");
/*
if (S_ISBLK(finfo.st_mode))
putchar('b');
else if (S_ISCHR(finfo.st_mode))
putchar('c');
else if (S_ISDIR(finfo.st_mode))
putchar('d');
else if (S_ISFIFO(finfo.st_mode))
putchar('p');
else if (S_ISREG(finfo.st_mode))
putchar('-');
else if (S_ISLNK(finfo.st_mode))
putchar('l');
else if (S_ISSOCK(finfo.st_mode))
putchar('s');
else
putchar('?');
*/
switch (finfo.st_mode & S_IFMT) {
case S_IFBLK:
putchar('b');
break;
case S_IFCHR:
putchar('c');
break;
case S_IFIFO:
putchar('p');
break;
case S_IFREG:
putchar('-');
break;
case S_IFDIR:
putchar('d');
break;
case S_IFLNK:
putchar('l');
break;
case S_IFSOCK:
putchar('s');
break;
default:
putchar('?');
break;
}
for (int i = 0; i < 9; ++i)
putchar(finfo.st_mode & modes[i] ? "rwx"[i % 3] : '-');
/*
for (int i = 8; i >= 0; --i)
putchar(finfo.st_mode >> i & 1 ? "rwx"[(8 - i) % 3] : '-');
*/
putchar('\n');
printf("Hard Link Count: %ju\n", (uintmax_t)finfo.st_nlink);
printf("User Id: %ju\n", (uintmax_t)finfo.st_uid);
printf("Group Id: %ju\n", (uintmax_t)finfo.st_gid);
printf("Size: %jd\n", (intmax_t)finfo.st_size);
ptm = localtime(&finfo.st_mtim.tv_sec);
strftime(buf, 32, "%b %2e %Y %H:%M\n", ptm);
printf("Last Modification Time: %s\n", buf);
printf("--------------------------\n");
}
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Aağı ı ı ı ı ı ı ı ı ı
id'leri isimsel olarak değil sayı ı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <time.h>
#include <locale.h>
#include <sys/stat.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
struct stat finfo;
mode_t modes[9] = {S_IRUSR, S_IWUSR, S_IXUSR, S_IRGRP, S_IWGRP, S_IXGRP, S_IROTH, S_IWOTH, S_IXOTH};
char buf[32];
struct tm *ptm;
if (setlocale(LC_ALL, "tr_TR.utf-8") == NULL) {
fprintf(stderr, "cannot set locale!..\n");
exit(EXIT_FAILURE);
}
if (argc == 1) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
for (int i = 1; i < argc; ++i) {
if (stat(argv[i], &finfo) == -1) {
perror(argv[i]);
continue;
}
switch (finfo.st_mode & S_IFMT) {
case S_IFBLK:
putchar('b');
break;
case S_IFCHR:
putchar('c');
break;
case S_IFIFO:
putchar('p');
break;
case S_IFREG:
putchar('-');
break;
case S_IFDIR:
putchar('d');
break;
case S_IFLNK:
putchar('l');
break;
case S_IFSOCK:
putchar('s');
break;
default:
putchar('?');
break;
}
for (int i = 0; i < 9; ++i)
putchar(finfo.st_mode & modes[i] ? "rwx"[i % 3] : '-');
printf("%ju ", (uintmax_t)finfo.st_nlink);
printf("%ju ", (uintmax_t)finfo.st_uid);
printf("%ju ", (uintmax_t)finfo.st_gid);
printf("%jd ", (intmax_t)finfo.st_size);
ptm = localtime(&finfo.st_mtim.tv_sec);
strftime(buf, 32, "%b %2e %Y %H:%M ", ptm);
printf("%s ", buf);
printf("%s\n", argv[i]);
}
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde stat fonksiyonunun yanı ı ı ı
onları ı ı ı ı ı ı ı
kaan@kaan-virtual-machine:~/Study/SysProg$ stat sample.c
Dosya: sample.c
Boyut: 2008 Bloklar: 8 Kimlik bloku: 4096 normal dosya
Device: 803h/2051d Inode: 280141 Links: 1
Erişim: (0644/-rw-r--r--) Uid: ( 1000/ kaan) Gid: ( 1000/ study)
Erişim: 2023-08-12 19:28:23.516502007 +0300
Değiştirme: 2023-08-12 19:28:23.500502009 +0300
Değişiklik: 2023-08-12 19:28:23.500502009 +0300
Doğum: 2023-06-11 19:48:04.987271791 +0300
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Bir kullanı ı ı ı ı
fonksiyonu kullanı ı ı ı ı ı
bilgileri bize vermektedir. getpwnam fonksiyonu "isimle" arama yaparken getpwuid fonksiyonu "kullanı ı ı
Fonksiyonları
#include <pwd.h>
struct passwd *getpwnam(const char *name);
struct passwd *getpwuid(uid_t uid);
Fonksiyonlar sı ı ı ı ı ı ı
geri dönmektedir. passwd yapı ı ı ı
struct passwd {
char *pw_name; /* username */
char *pw_passwd; /* user password */
uid_t pw_uid; /* user ID */
gid_t pw_gid; /* group ID */
char *pw_gecos; /* user information */
char *pw_dir; /* home directory */
char *pw_shell; /* shell program */
};
Fonksiyonlar statik ömürlü, nesnelerin adresiyle geri dönmektedir. Dolayı ı ı ı ı
Fonksiyonlar başarı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux türevi sistemlerde genellikle grup bilgileri "/etc/group" denilen dosyanı ı
belli bir grup id'ye karşı ı
grup bilgilerinin elde edilmesi için getgrnam ve getgrgid POSIX fonksiyonları ı
#include <grp.h>
struct group *getgrnam(const char *name);
struct group *getgrgid(gid_t gid);
Fonksiyonları ı ı ı ı
adresine, başarı ı ı ı ı ı
froup yapı ı
struct group {
char *gr_name; /* group name */
char *gr_passwd; /* group password */
gid_t gr_gid; /* group ID */
char **gr_mem; /* NULL-terminated array of pointers to names of group members */
};
Aşağı ı ı ı ı ı ı
yazdı ı ı ı ı ı ı ı ı
"ls -l" komutu default olarak dosya isimlerini sı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <time.h>
#include <locale.h>
#include <sys/stat.h>
#include <pwd.h>
#include <grp.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
struct stat finfo;
mode_t modes[9] = {S_IRUSR, S_IWUSR, S_IXUSR, S_IRGRP, S_IWGRP, S_IXGRP, S_IROTH, S_IWOTH, S_IXOTH};
char buf[32];
struct tm *ptm;
struct passwd *pwd;
struct group *grp;
if (setlocale(LC_ALL, "tr_TR.utf-8") == NULL) {
fprintf(stderr, "cannot set locale!..\n");
exit(EXIT_FAILURE);
}
if (argc == 1) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
for (int i = 1; i < argc; ++i) {
if (stat(argv[i], &finfo) == -1) {
perror(argv[i]);
continue;
}
switch (finfo.st_mode & S_IFMT) {
case S_IFBLK:
putchar('b');
break;
case S_IFCHR:
putchar('c');
break;
case S_IFIFO:
putchar('p');
break;
case S_IFREG:
putchar('-');
break;
case S_IFDIR:
putchar('d');
break;
case S_IFLNK:
putchar('l');
break;
case S_IFSOCK:
putchar('s');
break;
default:
putchar('?');
break;
}
for (int i = 0; i < 9; ++i)
putchar(finfo.st_mode & modes[i] ? "rwx"[i % 3] : '-');
printf("%ju ", (uintmax_t)finfo.st_nlink);
if ((pwd = getpwuid(finfo.st_uid)) != NULL)
printf("%s ", pwd->pw_name);
else
printf("%ju ", (uintmax_t)finfo.st_uid);
if ((grp = getgrgid(finfo.st_gid)) != NULL)
printf("%s ", grp->gr_name);
else
printf("%ju ", (uintmax_t)finfo.st_gid);
printf("%jd ", (intmax_t)finfo.st_size);
ptm = localtime(&finfo.st_mtim.tv_sec);
strftime(buf, 32, "%b %2e %Y %H:%M ", ptm);
printf("%s ", buf);
printf("%s\n", argv[i]);
}
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Tüm kullanı ı ı ı ı
başı ı ı ı ı ı ı ı ı ı
çağı ı ı ı ı ı
#include <pwd.h>
void endpwent(void);
struct passwd *getpwent(void);
void setpwent(void);
getpwent fonksiyonu her çağrı ı ı ı ı ı ı ı ı
dosyası ı ı ı ı
da fonksiyon NULL adrese geri dönmektedir. Fonksiyonun neden NULL adrese geri döndüğünü anlamak için her çağrı ı
tarafı ı ı ı ı ı
bittiğinde dolayı
Aşağı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <pwd.h>
void exit_sys(const char *msg);
int main(void)
{
struct passwd *pwd;
setpwent();
while (errno = 0, (pwd = getpwent()) != NULL)
printf("%s\n", pwd->pw_name);
if (errno != 0)
exit_sys("getpwent");
endpwent();
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Grup dosyası ı ı ı ı ı ı ı
fonksiyonlar şunlardı
#include <grp.h>
struct group *getgrent(void);
void setgrent(void);
void endgrent(void);
Aşağı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <grp.h>
void exit_sys(const char *msg);
int main(void)
{
struct group *grp;
setgrent();
while (errno = 0, (grp = getgrent()) != NULL)
printf("%s\n", grp->gr_name);
if (errno != 0)
exit_sys("getgrent");
endgrent();
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
20.Ders 13/08/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Dizinlerin içerisinde dosyalar ve dizinler olabilmektedir. İşletim sistemleri dünyası
"dizin girişi (directory entry)" denilmektedir. Bir dizin içerisinde dosyaları ı ı ı
önemli bilgileri bulundurulur. Daha önceden de belirttiğimiz gibi dizinler aslı
gibi organize edilmiştir. Dizinlerin içerisindeki girişlerin elde edilmesi dizinlerle ilgili önemli işlemlerden biridir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde bir dizin'in içerisindeki dizin girişlerini elde etmek için FindFirstFile, FindNextFile ve FindClose API fonksiyonları
kullanı ı ı ı
HANDLE FindFirstFile(
LPCSTR lpFileName,
LPWIN32_FIND_DATA lpFindFileData
);
BOOL FindNextFile(
HANDLE hFindFile,
LPWIN32_FIND_DATA lpFindFileData
);
BOOL FindClose(
HANDLE hFindFile
);
FindFirstFile fonksiyonunun birinci parametresi yol ifadesini almaktadı
gibi * ve ? gibi joker karakterlerini kullanarak birden fazla girişin bilgilerini de alabiliriz. Tabii eğer FindFirstFile ile birden
fazla girişin bilgileri alı ı ı ı
WIN32_FIND_DATA isimli bir yapı ı
için gereken HANDLE değerine başarı ı ı ı ı ı ı
belirtilen kalı ı ı
Eğer dizin içerisindeki birden fazla girişin bilgileri elde edilecekse bunları ı
FindNextFile fonksiyonu tarafı ı ı ı
her çağrı ı
elde edilen HANDLE değeridir. İkinci parametre yine bulunan dizin girişinin bilgilerinin yerleştirileceği WIN32_FIND_DATA türünden nesnenin
adresini almaktadı ı ı ı ı ı ı
olmaktadı ı ı ı ı ı ı ı ı
döngüden çı ı ı ı ı ı
gayet normal olarak fonksiyonun tüm girişleri elde ettiğinden dolayı ı ı ı
İşlemler bitince elde edilen HANDLE alanı ı ı ı ı ı ı
başarı ı ı ı ı
WIN32_FIND_DATA yapı ı
typedef struct _WIN32_FIND_DATA {
DWORD dwFileAttributes;
FILETIME ftCreationTime;
FILETIME ftLastAccessTime;
FILETIME ftLastWriteTime;
DWORD nFileSizeHigh;
DWORD nFileSizeLow;
DWORD dwReserved0;
DWORD dwReserved1;
CHAR cFileName[MAX_PATH];
CHAR cAlternateFileName[14];
DWORD dwFileType; // Obsolete. Do not use.
DWORD dwCreatorType; // Obsolete. Do not use
WORD wFinderFlags; // Obsolete. Do not use
} WIN32_FIND_DATA, *PWIN32_FIND_DATA, *LPWIN32_FIND_DATA;
Burada bulunan dizin girişinin ismi yapı ı ı ı ı ı
yapı ı ı ı ı ı ı
dwFileAttributes elemanı ı ı ı
olup olmadı ı ı
dizin girişinin bir dizine ilişkin olup olmadı ı ı ı ı
sokulması
Windows dosya sistemine de bağlı ı ı ı
ve ilk yaratma zamanı ı ı ı ı ı
iki parçadan oluşmaktadı ı ı ı ı
Windows her zaman dizin girişlerindeki zamanları ı ı
önce FileTimeToLocalFileTime fonksiyonuna sokmalı ı ı ı ı ı
Aşağı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hFileFind;
WIN32_FIND_DATA findData;
unsigned long long ullSize;
SYSTEMTIME sysTime;
if ((hFileFind = FindFirstFile("*.*", &findData)) == INVALID_HANDLE_VALUE)
ExitSys("FindFirstFile");
do {
FileTimeToLocalFileTime(&findData.ftLastWriteTime, &findData.ftLastWriteTime);
FileTimeToSystemTime(&findData.ftLastWriteTime, &sysTime);
printf("%02d.%02d.%04d %02d:%02d ", sysTime.wDay, sysTime.wMonth, sysTime.wYear, sysTime.wHour, sysTime.wMinute);
if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
printf("%-14s", "<DIR>");
else {
ullSize = (unsigned long long)findData.nFileSizeHigh << 32 | findData.nFileSizeLow;
printf("%14llu", ullSize);
}
printf(" %s\n", findData.cFileName);
} while (FindNextFile(hFileFind, &findData));
if (GetLastError() != ERROR_NO_MORE_FILES)
ExitSys("FindNextFile");
FindClose(hFileFind);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde dizin içerisindeki dosyaları
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <dirent.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
DIR *dir;
struct dirent *dent;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((dir = opendir(argv[1])) == NULL)
exit_sys("open");
while (errno = 0, (dent = readdir(dir)) != NULL)
printf("%s\n", dent->d_name);
if (errno != 0)
exit_sys("readdir");
closedir(dir);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde dizinler için "x" hakkı ı ı
anlamı
ifadesinde hedeflenen dizin girişine önceki dizin girişlerinden geçerek erişmektedir. Bu sürece İngilizce "pathname resolution" ya da
"pathname lookup" denilmektedir. Pathname resolution işlemi sı ı ı ı
gerekmektedir. Örneğin yukarı
SysProg dizinine "x" hakkı ı
prosesin çalı ı ı ı ı ı ı ı
Bir yol ifadesinde hedef dosyanı ı ı ı
hedefteki dosyaya erişim hakkı ı ı
modunda açabilmemiz için bu dosyaya "r" hakkı ı ı ı
buradaki diziler için "x" hakkı ı ı
Komut satı ı ı ı ı
fonksiyonun ikinci parametresinde bu hakları
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde bir dizin içerisindeki dizin girişlerini elde etmek için aşağı ı ı ı
opendir
readdir
closedir
Fonksiyonları
#include <dirent.h>
DIR *opendir(const char *name);
struct dirent *readdir(DIR *dirp);
int closedir(DIR *dirp);
opendir dizini açmak için kullanı ı ı ı ı ı
durumunda DIR isimli yapı ı ı ı ı ı
Programcı ı ı ı ı ı
readdir fonksiyonu çağrı ı ı ı ı
bize verilmektedir. readdir fonksiyonun geri döndürdüğü adresteki yapı ı
dizin listesinin sonuna gelindiğinde ya da IO hatası
(bu normal durumdur) errno değişkeninin değeri değiştirilmemektedir. Eğer fonksiyon IO hatası ı ı ı
uygun biçimde set edilmektedir. Burada programcı ı ı ı ı ı ı
değişkeninin değerine bakmalı ı
Nihayet programcı ı ı ı ı ı ı
durumunda -1 değerine geri dönmektedir.Fonksiyonun başarı ı ı
readdir fonksiyonu her çağrı ı ı ı ı
adresiyle geri döner. Yani programcı ı ı
Windows sistemlerinde dizin girişlerinde dosyaya ya da dizine ilişkin pek çok bilgi tutulmaktadı
girişlerinde yalnı ı ı
aşağidaki gibi bir yapı
dizin_girişi_ismi i-node_no
dizin_girişi_ismi i-node_no
dizin_girişi_ismi i-node_no
dizin_girişi_ismi i-node_no
...
dirent yapı ı
struct dirent {
ino_t d_ino; /* Inode number */
char d_name[256]; /* Null-terminated filename */
};
Görüldüğü gibi UNIX/Linux sistemlerinde biz dizin girişlerindne yalnı ı ı ı
UNIX/Linux sistemlerinde Windows sistemlerinde olduğu gibi "*" ve "?" gibi joker karakterlerini kullanamadı ı ı
sistemlerde biz dizindeki belli girişleri değil tüm girişleri elde etmekteyiz.
Aşağı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Biz UNIX/Linux sistemlerinde readdir fonksiyonuyla yalnı ı ı ı
uzunluğu, erişim hakları ı ı ı
sonra ayrı ı ı ı
fonksiyonunun da kullanı ı
Aşağı
elde edilmiştir. Bu örnekte bir noktaya dikkat ediniz. readdir fonksiyonu ile elde ettiğimiz giriş isminde bir yol ifadesi yoktur.
Halbuki bizim stat fonksiyonu için uygun bir yol ifadesine gereksnimimiz vardı
elde edilmiştir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <errno.h>
#include <dirent.h>
#include <sys/stat.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
DIR *dir;
struct dirent *ent;
struct stat finfo;
char path[PATH_MAX];
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((dir = opendir(argv[1])) == NULL)
exit_sys("opendir");
while (errno = 0, (ent = readdir(dir)) != NULL) {
snprintf(path, PATH_MAX, "%s/%s", argv[1], ent->d_name);
if (stat(path, &finfo) == -1)
perror(path);
printf("%-30s%jd\n", ent->d_name, (intmax_t)finfo.st_size);
}
if (errno != 0)
exit_sys("readdir");
closedir(dir);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi readdir fonksiyonu ile okuduğumuz dizin girişlerindeki i-node numarası ı ı
stat fonksiyonları ı ı ı ı ı ı ı
Bir disk i-node tabanlı ı ı ı ı
Boot Block
Super Block
I-Node Block
Data Block
Boot Block 1024 byte uzunluğunda sistemin boot edilmesi için gereken bilgileri içermektedir. Formatlanmı
Super Block'ta bulunmaktadı ı ı ı
elemanları ı
I-Node Block
----------------
i-node elemanı
i-node elemanı
i-node elemanı
...
i-node elemanı
i-node elemanı
...
Bir dosyaya ilişkin tüm bilgiler o dosyaya ilişkin i-node elemanı ı
aslı ı ı ı ı
numarası ı ı ı
I-Node Block
----------------
0 i-node elemanı
1 i-node elemanı
2 i-node elemanı
...
1200 i-node elemanı
1201 i-node elemanı
...
İşte bir dosyanı ı ı ı ı ı
Ancak bir dosyanı ı ı
bilgileri yol ifadelerinden ya da dosya betimleyicilerinden hareketle elde edilebilmektedir. Tabii işletim sistemi kendisi bu i-node
numarası ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir dizindeki dosya bilgilerini "ls -l" formatı ı ı
"ls -l" formatı ı ı ı ı ı ı ı ı ı
olacaktı ı ı ı
hizalama uygulanmamaktadı ı ı ı ı ı ı
-rw-r--r--1 kaan study 99 Haz 11 2023 18:17 y.c
-rwxr-xr-x1 kaan study 16136 Haz 17 2023 18:51 a.out
-rw-r--r--1 kaan study 0 Tem 23 2023 19:56 y.txt
drwxr-xr-x2 kaan study 4096 Ağu 13 2023 19:29 xxx
-rw-r--r--1 kaan study 895 Ağu 26 2023 17:09 sample.c
-rw-r--r--1 kaan study 2645 Ağu 26 2023 17:37 mample.c
-rw-rw-rw-1 kaan study 0 Tem 23 2023 20:57 m.txt
prw-r--r--1 kaan study 0 Ağu 12 2023 17:35 mypipe
-rw-r--r--1 kaan study 0 Tem 23 2023 19:31 x.txt
-rwxr-xr-x1 kaan study 16328 Haz 18 2023 19:17 mycalc
-rwxr-xr-x1 kaan study 16472 Ağu 26 2023 17:09 sample
-rw-r--r--1 kaan study 3570 Haz 18 2023 18:57 disp.c
-rw-r--r--1 kaan study 1161 Haz 18 2023 19:16 mycalc.c
-rw-r--r--1 kaan study 99 Haz 11 2023 18:17 x.c
drwxrwxr-x8 kaan study 4096 Ağu 14 2023 22:15 ..
-rw-r--r--1 kaan study 5000001 Tem 22 2023 20:07 test.txt
-rwxr-xr-x1 kaan study 16816 Ağu 26 2023 17:37 mample
-rw-rw-rw-1 kaan study 0 Tem 23 2023 20:45 z.txt
drwxrwxr-x3 kaan study 4096 Ağu 26 2023 17:37 .
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <time.h>
#include <errno.h>
#include <locale.h>
#include <dirent.h>
#include <sys/stat.h>
#include <pwd.h>
#include <grp.h>
void disp_ls_style(const struct stat *finfo, const char *name);
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
DIR *dir;
struct dirent *ent;
char path[PATH_MAX];
struct stat finfo;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if (setlocale(LC_ALL, "tr_TR.utf-8") == NULL) {
fprintf(stderr, "cannot set locale!..\n");
exit(EXIT_FAILURE);
}
if ((dir = opendir(argv[1])) == NULL)
exit_sys("opendir");
while (errno = 0, (ent = readdir(dir)) != NULL) {
snprintf(path, PATH_MAX, "%s/%s", argv[1], ent->d_name);
if (stat(path, &finfo) == -1)
perror(path);
disp_ls_style(&finfo, ent->d_name);
}
if (errno != 0)
exit_sys("readdir");
closedir(dir);
}
void disp_ls_style(const struct stat *finfo, const char *name)
{
mode_t modes[9] = {S_IRUSR, S_IWUSR, S_IXUSR, S_IRGRP, S_IWGRP, S_IXGRP, S_IROTH, S_IWOTH, S_IXOTH};
char buf[32];
struct tm *ptm;
struct passwd *pwd;
struct group *grp;
switch (finfo->st_mode & S_IFMT) {
case S_IFBLK:
putchar('b');
break;
case S_IFCHR:
putchar('c');
break;
case S_IFIFO:
putchar('p');
break;
case S_IFREG:
putchar('-');
break;
case S_IFDIR:
putchar('d');
break;
case S_IFLNK:
putchar('l');
break;
case S_IFSOCK:
putchar('s');
break;
default:
putchar('?');
break;
}
for (int i = 0; i < 9; ++i)
putchar(finfo->st_mode & modes[i] ? "rwx"[i % 3] : '-');
printf("%ju ", (uintmax_t)finfo->st_nlink);
if ((pwd = getpwuid(finfo->st_uid)) != NULL)
printf("%s ", pwd->pw_name);
else
printf("%ju ", (uintmax_t)finfo->st_uid);
if ((grp = getgrgid(finfo->st_gid)) != NULL)
printf("%s ", grp->gr_name);
else
printf("%ju ", (uintmax_t)finfo->st_gid);
printf("%jd ", (intmax_t)finfo->st_size);
ptm = localtime(&finfo->st_mtim.tv_sec);
strftime(buf, 32, "%b %2e %Y %H:%M ", ptm);
printf("%s ", buf);
printf("%s\n", name);
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı
elemanları ı ı ı ı ı ı ı
fonksiyona havale edilmiştir. Ancak bu fonksiyon bu bilgileri stdout dosyası ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <sys/stat.h>
#include <errno.h>
#include <unistd.h>
#include <pwd.h>
#include <grp.h>
#include <dirent.h>
void exit_sys(const char *msg);
const char *get_ls(const char *path, int hlink_digit, int uname_digit, int gname_digit, int size_digit);
int main(int argc, char *argv[])
{
DIR *dir;
struct dirent *dent;
struct stat finfo;
char path[PATH_MAX];
struct passwd *pass;
struct group *gr;
int len;
int hlink_digit, uname_digit, gname_digit, size_digit;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((dir = opendir(argv[1])) == NULL)
exit_sys("open");
hlink_digit = uname_digit = gname_digit = size_digit = 0;
while (errno = 0, (dent = readdir(dir)) != NULL) {
snprintf(path, PATH_MAX, "%s/%s", argv[1], dent->d_name);
if (stat(path, &finfo) == -1)
exit_sys("stat");
len = (int)log10(finfo.st_nlink) + 1;
if (len > hlink_digit)
hlink_digit = len;
if ((pass = getpwuid(finfo.st_uid)) == NULL)
exit_sys("getppuid");
len = (int)strlen(pass->pw_name);
if (len > uname_digit)
uname_digit = len;
if ((gr = getgrgid(finfo.st_gid)) == NULL)
exit_sys("getgrgid");
len = (int)strlen(gr->gr_name);
if (len > gname_digit)
gname_digit = len;
len = (int)log10(finfo.st_size) + 1;
if (len > size_digit)
size_digit = len;
}
if (errno != 0)
exit_sys("readdir");
rewinddir(dir);
while (errno = 0, (dent = readdir(dir)) != NULL) {
sprintf(path, "%s/%s", argv[1], dent->d_name);
if (stat(path, &finfo) == -1)
exit_sys("stat");
printf("%s\n", get_ls(path, hlink_digit, uname_digit, gname_digit, size_digit));
}
if (errno != 0)
exit_sys("readdir");
closedir(dir);
return 0;
}
const char *get_ls(const char *path, int hlink_digit, int uname_digit, int gname_digit, int size_digit)
{
struct stat finfo;
static char buf[4096];
static mode_t modes[] = { S_IRUSR, S_IWUSR, S_IXUSR, S_IRGRP, S_IWGRP, S_IXGRP, S_IROTH, S_IWOTH, S_IXOTH };
struct passwd *pass;
struct group *gr;
char *str;
int index = 0;
int i;
if (stat(path, &finfo) == -1)
return NULL;
if (S_ISREG(finfo.st_mode))
buf[index] = '-';
else if (S_ISDIR(finfo.st_mode))
buf[index] = 'd';
else if (S_ISCHR(finfo.st_mode))
buf[index] = 'c';
else if (S_ISBLK(finfo.st_mode))
buf[index] = 'b';
else if (S_ISFIFO(finfo.st_mode))
buf[index] = 'p';
else if (S_ISLNK(finfo.st_mode))
buf[index] = 'l';
else if (S_ISSOCK(finfo.st_mode))
buf[index] = 's';
++index;
for (i = 0; i < 9; ++i)
buf[index++] = (finfo.st_mode & modes[i]) ? "rwx"[i % 3] : '-';
buf[index] = '\0';
index += sprintf(buf + index, " %*llu", hlink_digit, (unsigned long long)finfo.st_nlink);
if ((pass = getpwuid(finfo.st_uid)) == NULL)
return NULL;
index += sprintf(buf + index, " %-*s", uname_digit, pass->pw_name);
if ((gr = getgrgid(finfo.st_gid)) == NULL)
return NULL;
index += sprintf(buf + index, " %-*s", gname_digit, gr->gr_name);
index += sprintf(buf + index, " %*lld", size_digit, (long long)finfo.st_size);
index += strftime(buf + index, 100, " %b %e %H:%M", localtime(&finfo.st_mtime));
str = strrchr(path, '/');
sprintf(buf + index, " %s", str ? str + 1 : path);
return buf;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir bildirim işleminin C'deki genel biçimi şöyledir:
<tür belirleyicisi> [yer belirleyicisi] [tür niteleyicileri] <dekleratör> [= <ilkdeğer], <dekleratör> [= <ilkdeğer], ...;
Tür belirten belirleyici ve niteleyicilerinin dı ı ı ı
(declarator)" denilmektedir. Çrneğin:
int a = 10, *pi = &a, *b[10];
Burada a, *pi, ve *b[10] birer dekleratördür. Bildirimdeki türün tüm dekleratörlerin türü olduğunda dikkat ediniz. Örneğin:
int a = 10, *pi = &a, *b[20];
Barada a'nı
ve b de int türden bir göstericisi dizisidir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı ı ı
Bir fonksiyonu çağı ı ı ı ı ı ı ı ı
çağı ı ı ı ı ı
başlangı ı
CALL address
Pekiyi CALL makine komutuyla goto işlemini yapan JMP (bu komut BRANCH olarak da isimlendirilmektedir) komutları ı
İşte CALL makine komutları ı ı ı ı ı ı ı
İşte CALL makine komutu adrese dallanmadan önce sonraki komutun adresini stack denilen alamda saklar sonra adrese dallanı
bir RET makine kmoutu bulunur. Bu RET makime komutu da stack'te saklanan adrese dallanı ı ı ı
geri dönüş adresinin saklanmı ı ı ı ı
Biz fonksiyonları ı ı ı ı ı ı ı ı
olmaktadı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Fonksiyon adreslerini tutan özel göstericilere "fonksiyon göstericileri (pointer to function)" denilmektedir. Bir fonksiyon göstericisi
tanı ı
<geri dönüş değerinin türü> (*<gösterici_ismi>)([parametrik yapı
Burada önemli olan noktalardan biri * ve gösterici isminin parantez içerisinde olması ı
int (*pf1)(int);
double (*pf2)(int, int);
int (*pf3)(struct stat *);
Bir fonksiyon göstericisine herhangi bir fonksiyonun adresi atanamaz. Geri dönüş değeri ve parametre türleri belli biçimde olan fonksiyonları
adresleri atanabilmektedir. Yukarı
bir fonksiyonun adresi atanabilir. pf2 göstericisine "geri dönüş değeri double türden olan ve parametreleri int ve int türden olan" fonksiyonları
adresleri atanabilmektedir. pf3 göstericisine ise "geri dönüş değeri int türden olan ve parametresi struct stat türünden gösterici olan"
fonksiyonları ı
yazı ı ı
okunabilirliği artı ı ı
int (*pf)(int, int);
int (*pf)(int a, int b);
Bu iki prototip arası ı ı
Fonksiyon gösterici bildiriminde dekleratördeki parantezler kullanı
Örneğin:
int (*pf)(int, int);
Burada geri dönüş değeri int olan ve parametreleri int, int olan fonksiyonları ı ı ı
Fakat örneğin:
int *pf(int, int);
Bu bildirim ise "geri dönüş değeri int * olan parametreleri int, int olan pf isimli bir fonksiyonun" prototip bildirimidir. Örneğin:
int (*pf)(int, int);
Buradaki fonksiyon gösterici bildiriminde dekleratör (*pf)(int, int) biçimindedir.
Fonskiyon göstericisi bildiriminde C'de parametre parantezlerinin içinin boş bı ı ı ı ı ı
farklı ı ı ı ı ı
korunmak üzere herhangi bir parametrik yapı ı ı
int (*pf1)();
Burada pf1 göstericisine geri dönüş değeri int türden olmak koşuluyla parametrik yapı ı ı
Halbuki örneğin:
int (*pf2)(void);
Burada pf2 göstericisine geri dönüş değeri int olan ve parametresi olmayan (ya da void olan da diyebiliriz) fonksiyonları
atanabilmektedir. Ancak C++'ta yukarı ı
int olan parametresi olmayan fonksiyonları
C'de tür dönüştürmelerinde kullanabileceğimiz türlerin sembolik isimleri vardı
int a;
int *pi;
int b[10];
int *c[20];
Burada a "int" türden, pi "int *" türünden, b "int[10]" türünden ve c de "int *[20]" türündendir. Bir fonksiyon göstericisinin bu biçimdeki
sembolik tür isimleri belirtilirken yine * atomu parantez içerisine alı ı
int (*pf)(void);
Burada pf göstericisi "int (*)(void)" türündendir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
C'de bir fonksiyonun yalnı ı ı
int foo(void)
{
...
}
Burada yalnı ı ı ı
olduğu gibi bir sağ taraf değeri belirtmektedir. Zaten C'de fonksiyonları ı ı ı
foo ifadesi ile foo() ifadesi tamamen farklı ı ı ı
foo() ifadesinde bu adreste bulunan fonksiyon çağrı ı
foo() ifadesi ise "int" türdendir.
Fonksiyon çağı ı ı ı ı ı ı ı
foo();
Burada aslı ı ı ı ı ı
Bu durumda biz bir fonksiyon göstericisine bir fonksiyonun adresini atamak istediğimizde fonksiyonun yalnı ı ı
int foo(void)
{
....
}
...
int (*pf)(void);
pf = foo; /* geçerli */
Atama işlemini şöyle yapamayı
pf = foo(); /* geçersiz! */
Burada pf değişkenine bir fonksiyon adresi değil düz bir int değer atanmaya çalı ı ı
bir fonksiyon adresi ile ilkdeğer de verebiliriz. Örneğin:
int (*pf)(void) = foo;
Örneğin:
int a, *pi, (*pf)(int);
Bu bildirimde a int türden, pi int * türünden ve pf ise int (*)(int) türündendir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Şimdi aşağı ı
void foo(void)
{
...
}
....
void (*pf)(void);
pf = foo;
Pekiyi bu pf yoluyla bu fonksiyonu nası ı ı
1) pf(...) sentaksı ı
2) (*pf)(...) sentaksı ı
Her iki sentaksta da pf göstericisinin içerisindeki adrste bulunan fonksiyon çağrı ı ı
iki sentaksla da çağrı
void foo(void)
{
...
}
...
foo();
(*foo)();
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void foo(void)
{
printf("foo\n");
}
int main(void)
{
void (*pf)(void) = foo;
pf();
(*pf)();
foo();
(*foo)();
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
int add(int a, int b)
{
return a + b;
}
int mul(int a, int b)
{
return a * b;
}
int main(void)
{
int (*pf)(int, int);
int result;
pf = add;
result = pf(10, 20);
printf("%d\n", result);
pf = mul;
result = pf(10, 20);
printf("%d\n", result);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir fonksiyon göstericisine farklı ı ı ı ı ı
derleme işlemi başarı ı ı ı ı ı ı
void foo(int a)
{
...
}
...
void (*pf)(int);
pf = foo; /* geçersiz' */
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir fonksiyonun parametre değişkeni bir fonksiyon gösterici olabilir. Örneğin:
void foo(void (*pf)(void))
{
....
}
Burada foo fonksiyonunun parametre değişkeni geri dönüş değeri void olan ve parametresi void olan bir fonksiyonun adresini alacaktı
Örneğin:
void bar(void)
{
...
}
...
foo(bar);
Böyle bir çağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void foo(void (*pf)(void))
{
pf();
}
void bar(void)
{
printf("bar\n");
}
int main(void)
{
foo(bar);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Fonksiyon göstericilerine bazı ı ı ı
göstericileri yoluyla sağlanmaktadı ı ı ı ı
callback fonksiyon mekanizaması
void for_each(int *pi, size_t size, void (*pf)(int *))
{
for (size_t i = 0; i < size; ++i)
pf(&pi[i]);
}
Burada for_each fonksiyonu int bir dizinin tüm elemanları ı ı ı ı
Bizim verdiğimiz callback fonksiyona for_each dizinin elemanları ı ı ı
değiştirebilecektir. Örneğin:
void disp(int *pi)
{
printf("%d\n", *pi);
}
void square(int *pi)
{
*pi = *pi * *pi;
}
...
int a[] = {10, 20, 30, 40, 50};
for_each(a, 5, disp);
for_each(a, 5, square);
for_each(a, 5, disp);
Görüldüğü gibi fonksiyon göstericileri bir fonksiyonun davranı ı ı ı ı ı
kullanı ı ı ı ı ı ı ı ı
isteyebiliriz. Ancak düğmenin kodları ı ı ı ı ı
onun üzerinde tı ı ı ı ı ı ı ı
çağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void for_each(int *pi, size_t size, void (*pf)(int *))
{
for (size_t i = 0; i < size; ++i)
pf(&pi[i]);
}
void disp(int *pi)
{
printf("%d\n", *pi);
}
void square(int *pi)
{
*pi = *pi * *pi;
}
int main(void)
{
int a[] = {10, 20, 30, 40, 50};
for_each(a, 5, disp);
for_each(a, 5, square);
for_each(a, 5, disp);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Fonksiyon parametrelerinde fonksiyon göstericileri (tı ı
Örneğin:
void foo(void pf(void))
{
...
}
Bu bildirim tamamne geçerlidir ve aşağı
void foo(void (*pf)(void))
{
...
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Fonksiyon adresleri typedef edilerek daha kolay bir kullanı
typedef void (*PF)(void);
Burada PF geri dönüş değeri void olan ve parametresi void olan bir fonksiyon adresi türüdür. Yani sembolik olarak PF aslı
türünü temsil etmektedir. Örneğin:
PF pf;
bildirimi ile,
void (*pf)(void);
bildirimi tamamen yanı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Her elemanı
parantez içerisine alı ı ı
void (*pfs[5])(void);
Burada pfs 5 eleanlı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void foo(void)
{
printf("foo\n");
}
void bar(void)
{
printf("bar\n");
}
void tar(void)
{
printf("tar\n");
}
int main(void)
{
void (*pfs[3])(void);
pfs[0] = foo;
pfs[1] = bar;
pfs[2] = foo;
for (int i = 0; i < 3; ++i)
pfs[i]();
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Fonksiyon gösterici dizilerine de küme parantezleri içerisinde ilkdeğer verebiliriz. Tabii verdiğimiz ilkdeğerlerin aynı
adresleri olması
void (*pfs[3])(void) = {foo, bar, tar};
Tabii yine ilkdeğer verirken dizi uzunluğu belirtilmeyebilir. Örneğin:
void (*pfs[])(void) = {foo, bar, tar};
Burada pfs dizisine üç elemanla ilkdeğer verildiği için pfs üç elemanlı
Yukarı ı ı
typedef void (*PF)(void);
...
PF pfs[] = {foo, bar, tar};
Tabii istersek fonksiyon gösterici dizileri için de typedef işlemi yapabiliriz. Örneğin:
typedef void (*PFS[3])(void);
...
PFS pfs = {foo, bar, tar};
Burada artı ı
sembolik gösterimi void (*[3])(void) biçimindedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void foo(void)
{
printf("foo\n");
}
void bar(void)
{
printf("bar\n");
}
void tar(void)
{
printf("tar\n");
}
int main(void)
{
void (*pfs[3])(void) = {foo, bar, tar};
for (int i = 0; i < 3; ++i)
pfs[i]();
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Her ne kadar fonksiyon isimleri zaten fonksiyonları ı
Yani aslı
üzere bu fonksiyonu çağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void foo(void)
{
printf("foo\n");
}
int main(void)
{
void (*pf)(void);
pf = &foo; /* eşdeğeri: pf = foo */
(*pf)(); /* eşdeğer: pf() */
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
C'de (ve C++'ta) data adreslerinden fonksiyon adreslerine fonksiyon adreslerinden data adreslerine bir dönüştürme yapı ı
C standartları ı
void (*pf)(void);
int pi;
pi = (int *)pf; /* geçersiz! böyle bir dönüştürme yok! */
Her ne kadar böylesi dönüştürmeler C'de geçerli değilse de Microsoft, gcc ve clang derleyicilerinde bu dönüştürmelere izin verilmektedir.
C'de (C++'ta da böyle) void göstericiler data göstericisi olarak kabul edilmektedir. Yani void göstericilere biz türü ne olursa olsun
nesnelerin adreslerini atayabiliriz ancak fonksiyon adreslerini atayamayı
int a;
double b;
void foo(void);
void *pv;
...
pv = &a; /* geçerli */
pv = &b; /* geçerli */
pv = foo; /* geçersiz! fonksiyon adreslerinden data adreslerine, data adreslerinden fonksiyon adreslerine dönüştürme yok! */
Ancak Microsoft derleyicileri, gcc ve clang derleyicileri bunu kabul etmektedir.
Fonksiyon adreslerinin data adreslerine dönüştürülmesi ve data adreslerinin fonksiyon adreslerine dönüştürülmesi aslı ı
biçimde sağlanabilmektedir. Örneğin elimizde bir fonksiyon adresi olsun biz de bunu void göstericiye atamak isteyelim:
void (*pf)(void);
void *pv;
...
pv = (void *)pf; /* geçersiz! */
Burada pf'nin adresi bir fonksiyon adresi değildir. Fonksiyon göstericisinin adresidir. O halde bu işlem şöyle yapı
pv = *(void **) &pf;
Buradaki anahtar nokta bir fonksiyon göstericisinin adresinin bir fonksiyon adresi değil data adresi olduğudur. Bunun tersi de şöyle
yapı
void (*pf)(void);
void *pv;
...
*(void **)&pf = pv;
C'de (ve C++'ta) NULL adres fonksiyon göstericilerine de atanabilmektedir. Örneğin:
void (*pf)(void) = 0;
Burada pf göstericisine int 0 değil, o sistemdeki NULL adres atanmı ı ı
(void *)0 biçiminde de belirtilebilir. Bu özel bir durum olduğu için data adresi kabul edilmemektedir. Örneğin:
void (*pf)(void) = (void *)0;
Burada her ne kadar sanki void bir adres fonksiyon göstericisine atanı
anlamı ı
Bir fonksiyon adresi başka türden bir fonksiyon adresine dönüştürülebilir. Örneğin:
void foo(int a);
...
void (*pf)(int);
pf = foo; /* geçeriz! */
pf (void (*)(void))foo /* geçerli */
Tabii bu tür dönüştürmeleri typedef işlemleriyle daha kolay yapabiliriz. Örneğin:
typedef void(*PF)(void);
void foo(int a);
...
void (*pf)(int);
pf = foo; /* geçeriz! */
pf (PF)foo /* geçerli */
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir fonksiyonun geri dönüş değeri de bir fonksiyon adresi olabilir. Bu durumda * atomu yine parantez içerisine alı ı
geri dönüş değerine ilişkin fonksiyonun geri dönüş değerinin türü parantezin sağı
yazı ı ı
void (*foo(int a))(int)
{
...
}
Burada foo fonksiyonunun parametresi int türdendir. Ancak geri dönüş değeri paramtresi int türden olan geri dönüş değeri void türden olan
bir fonksiyon adresidir. Buradaki tanı ı ı ı
1) foo(int a)
foo fonksiyonunun parametresi int türdendir.
2) (*foo(int a))
foo fonksiyonunun geri dönüş değeri bir fonksiyon adresidir.
3) void (*foo(int a))
foo fonksiyonunun geri dönüş değerine ilişkin fonksiyonun geri dönüş değeri void türdendir.
4) void (*foo(int a))(int)
foo fonksiyonunun geri dönüş değerine ilişkin fonksiyonun parametresi int türdendir. Örneğin:
#include <stdio.h>
void bar(void)
{
printf("bar\n");
}
void (*foo(void))(void)
{
return bar;
}
int main(void)
{
void (*pf)(void);
pf = foo();
pf();
return 0;
}
Bu tür bildirimlerde typedef işlemleri bildirimleri oldukça kolaylaştı ı
#include <stdio.h>
typedef void (*PF)(void);
void bar(void)
{
printf("bar\n");
}
PF foo(void)
{
return bar;
}
int main(void)
{
PF pf;
pf = foo();
pf();
return 0;
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void bar(void)
{
printf("bar\n");
}
void (*foo(void))(void)
{
return bar;
}
int main(void)
{
void (*pf)(void);
pf = foo();
pf();
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
C'de fonksiyon göstericilerine ilişkin daha karmaşı
seyrek karşı ı ı
- Fonksiyonumuz ismi foo olsun ve parametresi void türden olsun,
- Fonksiyonumuzun geri dönüş değeri bir fonksiyon adresi olsun ve o fonksiyon adresinin parametresi int türden olsun.
- Fonksiyonumuzun geri dönüş değerine ilişkin fonksiyonun geri dönüş değeri de parametresi void geri dönüş değeri void olan
bir fonksiyon adresi olsun.
Şimdi yuakrı ı ı
"foo parametresi void olan geri dönüş değeri parametresi int olan geri dönüş değeri paramtresi void olan geri dönüş değeri void olan bir
fonksiyon adresidir."
Şimdi bu fonksiyonu adı ı ı ı
1) foo(void)
foo fonksiyonun kendi parametresi void
2) (*foo(void))
foo fonksiyonunun geri dönüş değeri bir fonksiyon adresi
3) (*foo(void))(int)
foo fonksiyonunun geri dönüş değerine ilişkin fonksiyonun parametresi int
4) (*(*foo(void))(int))
foo fonksiyonun geri dönüş değerine ilişkin fonksiyon adresinin geri dönüş değeri de fonksiyon adresi
5) (*(*foo(void))(int))(void)
foo fonksiyonun geri dönüş değerine ilişkin fonksiyon adresinin geri dönüş değerine ilişkin fonksiyonun parametresi void
5) void (*(*foo(void))(int))(void)
foo fonksiyonun geri dönüş değerine ilişkin fonksiyon adresinin geri dönüş değerine ilişkin geri dönüş değeri void
Burada foo fonksiyonu şöyle tanı
void(*(*foo(void))(int))(void)
{
...
}
Pekiyi burada foo fonksiyonu nası
olan geri dönüş değeri void olan bir fonksiyon adresine. Örneğin:
void (*bar(int a))(void)
{
...
}
void(*(*foo(void))(int))(void)
{
return bar;
}
Pekiyi bar fonksiyonun neye geri dönmesi gerekmektedir? Tabii geri döüş değeri void ola parametresi void olan bir fonksiyonun adresine.
Örneğin:
#include <stdio.h>
void tar(void)
{
printf("tar\n");
}
void (*bar(int a))(void)
{
return tar;
}
void(*(*foo(void))(int))(void)
{
return bar;
}
int main(void)
{
void (*(*pf1)(int))(void);
void (*pf2)(void);
pf1 = foo();
pf2 = pf1(0);
pf2();
foo()(0)();
return 0;
}
Tabii typedef işlemi ile yukarı ı
#include <stdio.h>
typedef void (*PF1)(void);
typedef PF1(*PF2)(int);
void tar(void)
{
printf("tar\n");
}
PF1 bar(int a)
{
return tar;
}
PF2 foo(void)
{
return bar;
}
int main(void)
{
PF2 pf2;
PF1 pf1;
pf2 = foo();
pf1 = pf2(0);
pf1();
return 0;
}
Bu tür bildirimler daha karmaşı ı ı ı ı
en fazla bir fonksiyonun geri dönüş değerinin basit bir fonksiyon adresi olması ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void tar(void)
{
printf("tar\n");
}
void (*bar(int a))(void)
{
return tar;
}
void(*(*foo(void))(int))(void)
{
return bar;
}
int main(void)
{
void (*(*pf1)(int))(void);
void (*pf2)(void);
pf1 = foo();
pf2 = pf1(0);
pf2();
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Örneğin signal isimli bir POSIX fonksiyonunun prototipi aşağı
#include <signal.h>
void (*signal(int sig, void (*func)(int)))(int);
Burada signal fonksiyonu iki parametreli bir fonksiyondur. Fonksiyonun birinci parametresi int türden ikinci parametresi ise bir fonksiyo
türündendir. Yani fonksiyonun ikinci parametresi geri dönüş değeri void olan parametresi int olan bir fonksiyon adresini almaktadı
Burada signal fonksiyonunun geri dönüş değeri void, parametresi int olan bir fonksiyon adresidir. <signal.h> başlı ı
aşağı ı ı ı ı
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı
Windows için ListDir isimli bir fonksiyon yazmak isteyelim. Fonksiyon bir dizindeki dizin girişlerini bulsun ancak onları ı
bizim ona verdiğimiz bir fonksiyonu çağı ı ı
parametrik yapı ı ı
BOOL ListDir(const char *szPath, BOOL (*Proc)(WIN32_FIND_DATA *));
Fonksiyonun birinci parametresi joker karakterleri de içeren dizine ilişkin bir yol ifadesidir. İkinci parametre ilgili dizinde bir dizin
girişi bulunduğunda onun bilgilerinin bulunduğu WIN32_FIND_DATA yapı ı ı ı
fonksiyonu her dizin girişini buldukça o dizin girişi ile ikinci paramtresinde belirtilen bizim fonksiyonumuzu çağı ı
durumlarda callback fonksiyon yoluyla işlemin durdurulması
geri döndürülmüştür. Bu fonksiyon sı ı ı ı ı ı
Pekiyi burada ListDir fonksiyonunun geri dönüş değeri neyi belirtmektedir? İşte fonksiyonun geri dönüş değeri işlemin başarı ı ı
Aşağı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
BOOL ListDir(const char *szPath, BOOL(*Proc)(WIN32_FIND_DATA *));
void ExitSys(LPCSTR lpszMsg);
BOOL FindFile(WIN32_FIND_DATA *fd)
{
printf("%s\n", fd->cFileName);
if (!_strcmpi(fd->cFileName, "notepad.exe")) {
printf("notepad.exe found\n");
return FALSE;
}
return TRUE;
}
BOOL DispFile(WIN32_FIND_DATA *fd)
{
unsigned long long ullSize;
SYSTEMTIME sysTime;
FileTimeToLocalFileTime(&fd->ftLastWriteTime, &fd->ftLastWriteTime);
FileTimeToSystemTime(&fd->ftLastWriteTime, &sysTime);
printf("%02d.%02d.%04d %02d:%02d ", sysTime.wDay, sysTime.wMonth, sysTime.wYear, sysTime.wHour, sysTime.wMinute);
if (fd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
printf("%-14s", "<DIR>");
else {
ullSize = (unsigned long long)fd->nFileSizeHigh << 32 | fd->nFileSizeLow;
printf("%14llu", ullSize);
}
printf(" %s\n", fd->cFileName);
return TRUE;
}
int main(void)
{
if (!ListDir("c:\\windows\\*.*", FindFile))
ExitSys("ListDir");
printf("----------------------------\n");
if (!ListDir("c:\\windows\\*.*", DispFile))
ExitSys("ListDir");
return 0;
}
BOOL ListDir(const char *szPath, BOOL(*Proc)(WIN32_FIND_DATA *))
{
HANDLE hFileFind;
WIN32_FIND_DATA findData;
BOOL bResult = TRUE;;
if ((hFileFind = FindFirstFile(szPath, &findData)) == INVALID_HANDLE_VALUE)
return FALSE;
do {
if (!Proc(&findData))
goto EXIT;
} while (FindNextFile(hFileFind, &findData));
if (GetLastError() != ERROR_NO_MORE_FILES)
return FALSE;
EXIT:
FindClose(hFileFind);
return TRUE;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <errno.h>
#include <dirent.h>
#include <sys/stat.h>
int list_dir(const char *path, int (*proc)(const struct stat *, const char *name));
void exit_sys(const char *msg);
int disp_file(const struct stat *finfo, const char *name)
{
printf("%-30s%jd\n", name, (intmax_t)finfo->st_size);
return 1;
}
int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if (list_dir(argv[1], disp_file) == -1)
exit_sys("list_dir");
return 0;
}
int list_dir(const char *path, int (*proc)(const struct stat *, const char *name))
{
DIR *dir;
struct dirent *de;
char fpath[PATH_MAX];
struct stat finfo;
int status = 0;
if ((dir = opendir(path)) == NULL)
return -1;
while ((errno = 0, de = readdir(dir)) != NULL) {
snprintf(fpath, PATH_MAX, "%s/%s", path, de->d_name);
if (stat(fpath, &finfo) == -1) {
status = -1;
goto EXIT;
}
if (!proc(&finfo, de->d_name))
goto EXIT;
}
if (errno)
status = -1;
EXIT:
closedir(dir);
return status;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
C'de her türden diziyi sı ı ı
yalnı ı
void sort(int *pi, size_t size);
Her tür için bu fonksiyonu içi aynı
void sort_int(int *pi, size_t size);
void sort_long(long *pi, size_t size);
void sort_double(double *pi, size_t size);
...
Ancak burada yine bir problem vardı ı ı ı ı ı ı ı
Türden bağı ı
mekanizma oluşturmuştur. Önce C# sonra da Java C++'ı ı ı ı ı
oluşturmuştur. Yeni tasarlanan dilelrin çoğunda (Swift gibi, Kotlin gibi Rust gibi) bu generic mekanizma artı ı
C'de böyle bir mekanizma yoktur. Python gibi Ruby gibi dinamik tür sistemine sahip programlama dillerinde zaten bu generic mekanizma
doğuştan vardı
Sort işlemi hangi alagoritmaya göre yapı ı ı ı ı ı ı ı ı
uygulamaktadı ı ı ı ı ı ı
karşı ı ı ı ı ı ı ı ı
adresini void gösterici biçiminde almalı ı ı ı ı
onu çağı ı ı ı ı ı ı ı ı
Tabii bunu bir fonksiyon gösterici kullanarak sağlayacaktı ı ı ı ı
kaç byte uzunlukta olduğunu biliyor olması ı
almalı ı ı
parametrik yapı ı ı
void sort(void *pv, size_t count, size_t width, int (*compare)(const void *, const void *))
Fonksiyonun birinci parametresi dizinin başlangı ı ı ı
parametre dizinin bir elemanı ı ı ı ı
ne zaman bir karşı ı ı ı ı ı ı ı
çağı ı ı ı ı ı
dizi elemanı ı
belirtilen dizi elemanı ı ı
böyle bir fonksiyonla int bir dizi şöyel sı
int cmp(const void *ptr1, const void *ptr2);
int main(void)
{
int a[10] = {3, 6, 2, 12, 1, 87, 45, 23, 54, 78};
sort(a, 10, sizeof(int), cmp);
for (int i = 0; i < 10; ++i)
printf("%d ", a[i]);
printf("\n");
return 0;
}
int cmp(const void *ptr1, const void *ptr2)
{
const int *elem1 = (const int *)ptr1;
const int *elem2 = (const int *)ptr2;
if (*elem1 > *elem2)
return 1;
if (*elem1 < *elem2)
return -1;
return 0;
}
Aşağı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
void bsort(void *pv, size_t count, size_t width, int (*compare)(const void *, const void *));
int cmp(const void *ptr1, const void *ptr2);
int main(void)
{
int a[10] = {3, 6, 2, 12, 1, 87, 45, 23, 54, 78};
bsort(a, 10, sizeof(int), cmp);
for (int i = 0; i < 10; ++i)
printf("%d ", a[i]);
printf("\n");
return 0;
}
void bsort(void *pv, size_t count, size_t width, int (*compare)(const void *, const void *))
{
unsigned char *pc = (unsigned char *)pv;
unsigned char *elem1, *elem2;
unsigned char temp;
for (size_t i = 0; i < count - 1; ++i)
for (size_t k = 0; k < count - 1 - i; ++k) {
elem1 = pc + k * width;
elem2 = pc + (k + 1) * width;
if (compare(elem1, elem2) > 0)
for (size_t j = 0; j < width; ++j) {
temp = elem1[j];
elem1[j] = elem2[j];
elem2[j] = temp;
}
}
}
int cmp(const void *ptr1, const void *ptr2)
{
const int *elem1 = (const int *)ptr1;
const int *elem2 = (const int *)ptr2;
if (*elem1 > *elem2)
return 1;
if (*elem1 < *elem2)
return -1;
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı ı ı
void qsort(void *base, size_t nmemb, size_t size, int (*compare)(const void *, const void *));
Fonksiyonun yine birinci parameresi dizinin başlangı ı ı ı ı ı
byte uzunluğunu, dördüncü parametresi ise karşı ı ı ı ı ı
eğer soldaki eleman sağdaki elemandan büyükse pozitif herhangi bir değere, eğer sağdaki eleman soldaki elemandan büyükse negatif herhangi
bir değere ve iki eleman biribine eşitse 0 değerine geri dönmelidir. C standartları ı ı
belirtilmemiş olsa da tipik olarak fonksiyon mevcut C derleyicilerde "quick sort" algoritması ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct PERSON {
char name[64];
int no;
};
int cmp_no(const void *ptr1, const void *ptr2);
int cmp_name(const void *ptr1, const void *ptr2);
int main(void)
{
struct PERSON persons[10] = {
{"Kazim Tanis", 654},
{"Hasan Aslan", 145},
{"Kamil Zorlu", 487},
{"Necati Ergin", 534},
{"Ali Serce", 931},
{"Guray Sonmez", 245},
{"Fehmi Oz", 543},
{"Ayse Er", 321},
{"Sibel Cetinsoy", 423},
{"Mualla Yilmaz", 739}
};
qsort(persons, 10, sizeof(struct PERSON), cmp_no);
for (size_t i = 0; i < 10; ++i) printf("%-20s%d\n", persons[i].name, persons[i].no);
printf("-------------------------------------------\n");
qsort(persons, 10, sizeof(struct PERSON), cmp_name);
for (size_t i = 0; i < 10; ++i)
printf("%-20s%d\n", persons[i].name, persons[i].no);
return 0;
}
int cmp_no(const void *ptr1, const void *ptr2)
{
const struct PERSON *per1 = (const struct PERSON *)ptr1;
const struct PERSON *per2 = (const struct PERSON *)ptr2;
if (per1->no > per2->no)
return 1;
if (per1->no < per2->no)
return -1;
return 0;
}
int cmp_name(const void *ptr1, const void *ptr2)
{
const struct PERSON *per1 = (const struct PERSON *)ptr1;
const struct PERSON *per2 = (const struct PERSON *)ptr2;
return strcmp(per1->name, per2->name);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Biz yukardaki örnekte küçükten büyüğe sı ı ı ı ı ı
ters yazı ı ı
değere ve eşitse sı ı ı ı ı ı ı ı ı ı
fonksiyonunu sarmalayan bir fonksiyon yazı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir gösterici dizisini qsort fonksiyonuyla sı ı ı ı ı ı
Aşağı ı ı
sı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct PERSON {
char name[64];
int no;
};
int cmp(const void *ptr1, const void *ptr2);
int main(void)
{
const char *names[10] = {
"Kazim Tanis", "Hasan Aslan", "Kamil Zorlu", "Necati Ergin", "Ali Serce",
"Guray Sonmez", "Fehmi Oz", "Ayse Er", "Sibel Cetinsoy", "Mualla Yilmaz"
};
qsort(names, 10, sizeof(const char *), cmp);
for (size_t i = 0; i < 10; ++i)
printf("%s\n", names[i]);
return 0;
}
int cmp(const void *ptr1, const void *ptr2)
{
const char **elem1 = (const char **)ptr1;
const char **elem2 = (const char **)ptr2;
return strcmp(*elem1, *elem2);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde ls -l işleminden elde edilen dosyaları ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <sys/stat.h>
#include <errno.h>
#include <unistd.h>
#include <pwd.h>
#include <grp.h>
#include <dirent.h>
#define MAX_PATH 4096
#define BLOCK_SIZE 32
struct lsinfo {
struct stat finfo;
char *name;
};
void exit_sys(const char *msg);
const char *get_ls(const struct lsinfo *lsinfo, int hlink_digit, int uname_digit, int gname_digit, int size_digit);
int cmp_name(const void *lsinfo1, const void *lsinfo2);
int main(int argc, char *argv[])
{
DIR *dir;
struct dirent *dent;
struct lsinfo *lsinfo;
int count;
char path[MAX_PATH];
struct passwd *pass;
struct group *gr;
int len;
int hlink_digit, uname_digit, gname_digit, size_digit;
int i;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((dir = opendir(argv[1])) == NULL)
exit_sys("open");
lsinfo = NULL;
for (count = 0, errno = 0; (dent = readdir(dir)) != NULL; ++count) {
sprintf(path, "%s/%s", argv[1], dent->d_name);
if (count % BLOCK_SIZE == 0)
if ((lsinfo = realloc(lsinfo, (count + BLOCK_SIZE) * sizeof(struct lsinfo))) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
if ((lsinfo[count].name = (char *)malloc(strlen(dent->d_name) + 1)) == NULL) {
fprintf(stderr, "cannot allocate memory!...\n");
exit(EXIT_FAILURE);
}
strcpy(lsinfo[count].name, dent->d_name);
if (stat(path, &lsinfo[count].finfo) == -1)
exit_sys("stat");
}
if (errno != 0)
exit_sys("readdir");
closedir(dir);
hlink_digit = uname_digit = gname_digit = size_digit = 0;
for (i = 0; i < count; ++i) {
len = (int)log10(lsinfo[i].finfo.st_nlink) + 1;
if (len > hlink_digit)
hlink_digit = len;
if ((pass = getpwuid(lsinfo[i].finfo.st_uid)) == NULL)
exit_sys("getppuid");
len = (int)strlen(pass->pw_name);
if (len > uname_digit)
uname_digit = len;
if ((gr = getgrgid(lsinfo[i].finfo.st_gid)) == NULL)
exit_sys("getgrgid");
len = (int)strlen(gr->gr_name);
if (len > gname_digit)
gname_digit = len;
len = (int)log10(lsinfo[i].finfo.st_size) + 1;
if (len > size_digit)
size_digit = len;
}
qsort(lsinfo, count, sizeof(struct lsinfo), cmp_name);
for (i = 0; i < count; ++i)
printf("%s\n", get_ls(&lsinfo[i], hlink_digit, uname_digit, gname_digit, size_digit));
for (i = 0; i < count; ++i)
free(lsinfo[i].name);
free(lsinfo);
return 0;
}
const char *get_ls(const struct lsinfo *lsinfo, int hlink_digit, int uname_digit, int gname_digit, int size_digit)
{
static char buf[4096];
static mode_t modes[] = { S_IRUSR, S_IWUSR, S_IXUSR, S_IRGRP, S_IWGRP, S_IXGRP, S_IROTH, S_IWOTH, S_IXOTH };
struct passwd *pass;
struct group *gr;
int index = 0;
int i;
if (S_ISREG(lsinfo->finfo.st_mode))
buf[index] = '-';
else if (S_ISDIR(lsinfo->finfo.st_mode))
buf[index] = 'd';
else if (S_ISCHR(lsinfo->finfo.st_mode))
buf[index] = 'c';
else if (S_ISBLK(lsinfo->finfo.st_mode))
buf[index] = 'b';
else if (S_ISFIFO(lsinfo->finfo.st_mode))
buf[index] = 'p';
else if (S_ISLNK(lsinfo->finfo.st_mode))
buf[index] = 'l';
else if (S_ISSOCK(lsinfo->finfo.st_mode))
buf[index] = 's';
++index;
for (i = 0; i < 9; ++i)
buf[index++] = (lsinfo->finfo.st_mode & modes[i]) ? "rwx"[i % 3] : '-';
buf[index] = '\0';
index += sprintf(buf + index, " %*llu", hlink_digit, (unsigned long long)lsinfo->finfo.st_nlink);
if ((pass = getpwuid(lsinfo->finfo.st_uid)) == NULL)
return NULL;
index += sprintf(buf + index, " %-*s", uname_digit, pass->pw_name);
if ((gr = getgrgid(lsinfo->finfo.st_gid)) == NULL)
return NULL;
index += sprintf(buf + index, " %-*s", gname_digit, gr->gr_name);
index += sprintf(buf + index, " %*lld", size_digit, (long long)lsinfo->finfo.st_size);
index += strftime(buf + index, 100, " %b %e %H:%M", localtime(&lsinfo->finfo.st_mtime));
sprintf(buf + index, " %s", lsinfo->name);
return buf;
}
int istrcmp(const char *s1, const char *s2)
{
while (tolower(*s1) == tolower(*s2)) {
if (*s1 == '\0')
return 0;
++s1;
++s2;
}
return tolower(*s1) - tolower(*s2);
}
int cmp_name(const void *pv1, const void *pv2)
{
const struct lsinfo *lsinfo1 = (const struct lsinfo *)pv1;
const struct lsinfo *lsinfo2 = (const struct lsinfo *)pv2;
return istrcmp(lsinfo1->name, lsinfo2->name);
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
scandir POSIX fonksiyonun kullanı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <dirent.h>
void exit_sys(const char *msg);
int mycallback(const struct dirent *de)
{
if (tolower(de->d_name[0]) == 'a')
return 1;
return 0;
}
int main(void)
{
struct dirent **dents;
int i, count;
if ((count = scandir("/usr/include", &dents, mycallback, NULL)) == -1)
exit_sys("scandir");
for (i = 0; i < count; ++i)
printf("%s\n", dents[i]->d_name);
for (i = 0; i < count; ++i)
free(dents[i]);
free(dents);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Fonksiyon göstericilerine iyi bir alı ı ı
eden bir POSIX fonksiyonudur. Fonksiyonun tasarı ı ı ı ı ı ı ı ı ı
(Kanı ı ı ı
#include <dirent.h>
int scandir(const char *dirp, struct dirent ***namelist,
int (*filter)(const struct dirent *),
int (*compar)(const struct dirent **, const struct dirent **));
Fonksiyonun birinci parametresi dizin listesi elde edilecek dizin'in yol ifadesini almaktadı
bilgilerini malloc ile tahsis ettiği dinamik alana kopyalar ve alanları
adresine de bizim ikinci parametreyle verdiğimiz göstericiyi gösteren göstericinin içerisine yerleştirmektedir. Tabii bu gösterici dizisi
de dinamik biçimde tahsis edilmiştir. Dolayı ı ı ı ı ı
filtreleme yapmak için kullanı ı ı ı
fonksiyon sı ı ı ı ı ı
listeye dahil etmez. scandir fonksiyonunun son parametresi girişlerin sı ı ı ı ı
Gerçi dirent yapı ı ı ı ı
sı ı ı ı ı
NULL adres de geçilebilmektedir. scandir fonksiyonu çaşarı ı ı ı ı ı
değeri ile geri dönmektedir.
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <dirent.h>
#include <sys/stat.h>
void exit_sys(const char *msg);
int mycallback(const struct dirent *de)
{
struct stat finfo;
char path[4096];
sprintf(path, "/usr/include/%s", de->d_name);
if (stat(path, &finfo) == -1)
exit_sys("stat");
return finfo.st_size < 1000;
}
int main(void)
{
struct dirent **dents;
int i, count;
if ((count = scandir("/usr/include", &dents, mycallback, NULL)) == -1)
exit_sys("scandir");
for (i = 0; i < count; ++i)
printf("%s\n", dents[i]->d_name);
for (i = 0; i < count; ++i)
free(dents[i]);
free(dents);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
24. Ders 03/09/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Komut satı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* myshell.c */
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#define PROMPT "CSD>"
#define MAX_CMD_LINE 4096
#define MAX_CMD_PARAMS 128
#define BUFFER_SIZE 8192
void parse_cmdline(void);
void cat_cmd(void);
void cp_cmd(void);
void rename_proc(void);
typedef struct tagCMD {
char *cmd_name;
void (*cmd_proc)(void);
} CMD;
char g_cmdline[MAX_CMD_LINE];
char *g_params[MAX_CMD_PARAMS];
int g_nparams;
CMD g_cmds[] = {
{"cat", cat_cmd},
{"cp", cp_cmd},
{"rename", rename_proc},
{NULL, NULL}
};
int main(void)
{
char *str;
int i;
for (;;) {
printf("%s", PROMPT);
if (fgets(g_cmdline, MAX_CMD_LINE, stdin) == NULL)
continue;
if ((str = strchr(g_cmdline, '\n')) != NULL)
*str = '\0';
parse_cmdline();
if (g_nparams == 0)
continue;
if (!strcmp(g_params[0], "exit"))
break;
for (i = 0; g_cmds[i].cmd_name != NULL; ++i)
if (!strcmp(g_cmds[i].cmd_name, g_params[0])) {
g_cmds[i].cmd_proc();
break;
}
if (g_cmds[i].cmd_name == NULL) {
printf("invalid command: %s\n", g_params[0]);
}
}
return 0;
}
void parse_cmdline(void)
{
char *str;
g_nparams = 0;
for (str = strtok(g_cmdline, " \t"); str != NULL; str = strtok(NULL, " \t"))
g_params[g_nparams++] = str;
}
void cat_cmd(void)
{
FILE *f;
int ch;
if (g_nparams != 2) {
printf("cat command missing file!..\n");
return;
}
if ((f = fopen(g_params[1], "r")) == NULL) {
printf("file not found or cannot open file: %s\n", g_params[1]);
return;
}
while ((ch = fgetc(f)) != EOF)
putchar(ch);
if (ferror(f))
printf("cannot read file: %s\n", g_params[1]);
fclose(f);
}
void cp_cmd(void)
{
int fds, fdd;
char buf[BUFFER_SIZE];
ssize_t result;
if (g_nparams != 3) {
printf("source and destination path must be specified!..\n");
return;
}
if ((fds = open(g_params[1], O_RDONLY)) == -1) {
printf("file not found or cannot open: %s\n", g_params[1]);
return;
}
if ((fdd = open(g_params[2], O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) == -1) {
printf("file not found or cannot open: %s\n", g_params[2]);
goto EXIT2;
}
while ((result = read(fds, buf, BUFFER_SIZE)) > 0)
if (write(fdd, buf, result) != result) {
printf("cannot write file: %s\n", g_params[2]);
goto EXIT1;
}
if (result == -1) {
printf("cannot read file: %s\n", g_params[1]);
goto EXIT1;
}
printf("1 file copied...\n");
EXIT1:
close(fdd);
EXIT2:
close(fds);
}
void rename_proc(void)
{
printf("rename command...\n");
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir gösterici dizisinin ismi onun ilk elemanı ı ı ı ı
int x = 10, y = 20, z = 30;
int *a[] = {&x, &y, &z};
int **ppi;
ppi = a; /* geçerli */
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
const char *names[] = {"ali", "veli", "selami", "ayse", "fatma", NULL};
const char **pps;
pps = names;
for (int i = 0; pps[i] != NULL; ++i)
puts(pps[i]);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
C'de parametre parantezi içerisindeki dizisel gösterim tamamen "gösterici" anlamı ı ı
da hiçbir önemi yoktur. Dolayı ı ı ı ı
void foo(int *a);
void foo(int a[]);
void foo(int a[100]);
void foo(int a[5]);
Bunları ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Fonksiyonun parametresi göstericiyi gösteren gösterici ise o parametre yine dizi sentaksı ı ı ı
de yine eşdeğerdir:
void bar(int **a);
void bar(int *a[10]);
void bar(int *a[]);
Bunları ı ı
int main(int argc, char **argv)
{
...
}
Ancak geleneksel olarak programcı ı
int main(int argc, char *argv[])
{
...
}
Ancak bir fonksiyonun parametresi sanki çok boyutlu diziymiş gibi belirtilirse bu tamamen başka bir anlama gelemketdir. Örneğin:
void foo(int a[][3])
{
...
}
Bu bildirmin ne anlamı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void foo(int *a[], size_t size)
{
for (size_t i = 0; i < size; ++i)
printf("%d\n", *a[i]);
}
int main(void)
{
int x = 10, y = 20, z = 30;
int *a[] = {&x, &y, &z};
foo(a, 3);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Fonksiyon parametresi fonksiyon göstericisi ise o da alternatif biçimde fonksiyon sentaksı ı
eşdeğerdir. Örneğin:
void foo(int (*a)(double));
void foo(int a(double));
Tabii prototipte değişken ismi belirtilmek zorunda olmadı ı ı ı
void foo(int (double));
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Çok boyutlu diziler aslı
int a[3][2];
Burada a aslı ı ı ı
her zaman ası
ilk elemanı ı ı ı
Biz C'de dizilerin adreslerini alabiliriz. Bu durumda elde edilen adres dizi türünden adres olur. Dizi türünden adresler sembolik olarak
"tür (*)[uzunuk]" biçiminde ifade edilir. Dizi türünden adresleri tutan göstericilere "dizi göstericileri (pointer to array)" denilmektedir.
Örneğin:
int a[2];
int (*pa)[2];
pa = &a;
Mademki bir dizinin ismi o dizinin ilk elemanı ı
int a[3][2];
Burada a 3 elemanlı ı ı
aslı ı
int a[3][2];
int(*pa)[2];
pa = a;
Dizi göstericileri bildirilirken ilk boyut dı ı ı ı
int (*pa)[]; /* geçersiz! */
Bir dizisinin adresini aynı
int a[3];
int (*pa)[2];
pa = &a; /* geçersiz! */
Burada pa göstericisinin aşağı ı ı
int (*pa)[3];
Çok boyutlu dizilerin adresleri de benzer biçimde aynı
int a[2][3][4];
int (*pa)[3][4];
pa = a; /* geçerli */
C'de çok yapı ı ı ı ı
void foo(int **ppi)
{
...
}
...
int a[3][2];
...
foo(a); /* geçersiz! */
Burada foo fonksiyonunun parametresinin aşağı ı
void foo(int (*pa)[2])
{
...
}
...
int a[3][2];
...
foo(a); /* geçerli ! */
Maalesef C'de her uzunlukta çok boyutlu dizinin adresinin atanabileceği gösterici oluşturmak mümkün değildir. Bu tür durumlarda ne yapı ı
gerektiği izleyen paragraflarda açı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir dizi göstericisinin gösterdiği yere erişirsek o dizinin tamamı
int a[3][2];
int (*pa)[2];
pa = a;
Burada pa aslı ı ı ı ı ı ı
aslı ı ı ı ı ı
etmektedir.
Dizi isimler dizinin tamamı ı ı ı ı ı ı ı
anlamı
int a[3] = {1, 2, 3};
a = 100; /* a nesne belirtmiyor, bir adres sabiti belirtiyor */
Bu durumda örneğin:
int a[3][2];
burada a[i] ifadesi de *a ifadesi de nesne belirtmemektedir. Bu ifadeler adeta dizi isimleri gibi düşünülmelidir.
Biz C'de çok boyutlu dizilerin elemanları ı ı
int a[3][2] = {{1, 2}, {3, 4}, {5, 6}};
Burada a[i] aslı ı ı ı ı ı
dizinin k'ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
int main(void)
{
int a[3][2] = { {1, 2}, {3, 4}, {5, 6} };
int(*pa)[2];
pa = a;
printf("%d\n", (*pa)[0]);
printf("%d\n", (*pa)[1]);
printf("%d\n", pa[1][0]);
printf("%d\n", pa[1][1]);
printf("%d\n", pa[2][0]);
printf("%d\n", pa[2][1]);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi bir matrisi fonksiyona partametre olarak nası ı
gerekir. Ayrı ı ı ı ı
uzunlukları ı ı
void foo(int (*pa)[2], size_t size);
Bu fonksiyon sütun sayı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void foo(int(*pa)[2], size_t size)
{
size_t i, k;
for (i = 0; i < size; ++i) {
for (k = 0; k < 2; ++k)
printf("%d ", pa[i][k]);
printf("\n");
}
}
int main(void)
{
int a[3][2] = { {1, 2}, {3, 4}, {5, 6} };
foo(a, 3);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Çok boyutlu dizi kavramı ı ı ı ı
derleyici aslı ı ı ı ı ı ı
ve bu ardı ı ı ı ı ı
int a[3][2] = {{1, 2}, {3, 4}, {5, 6}};
Buradaki a dizisi aslı ı ı ı ı
1
2
3
4
5
6
Örneğin:
int a[2][2][3] = {{{1, 2, 3}, {4, 5, 6}}, {{7, 8, 9}, {10, 11, 12}}};
Bu dizinin bellekteki yerleşimi ise şöyle olacaktı
1
2
3
4
5
6
7
8
9
10
11
12
Bu durumda çok boyutlu bir dizinin ismi tek boyutlu bir göstericiye atanı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Tek boyutlu bir dizi de bir dizi göstericisine tür dönüştürme operatörü kullanı ı
matris sentaksı
int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
int (*pa)[3];
pa = (int (*)[3]) a;
for (int i = 0; i < 4; ++i) {
for (int k = 0; k < 3; ++k)
printf("%d ", pa[i][k]);
putchar('\n');
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
int main(void)
{
int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
int (*pa)[3];
pa = (int (*)[3]) a;
for (int i = 0; i < 4; ++i) {
for (int k = 0; k < 3; ++k)
printf("%d ", pa[i][k]);
putchar('\n');
}
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir matiris için de dinamik tahsisatlar yapabiliriz. Tabii buradaki önemli nokta tahsis edilen alanı ı ı
göstericisinin nası ı ı ı
tahsis edilen alanı ı
int (*pa)[3];
Örneğin:
int(*pa)[3];
if ((pa = (int(*)[3])malloc(4 * 3 * sizeof(int))) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int(*pa)[3];
if ((pa = (int(*)[3])malloc(4 * 3 * sizeof(int))) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 4; ++i)
for (int k = 0; k < 3; ++k)
pa[i][k] = i + k;
for (int i = 0; i < 4; ++i) {
for (int k = 0; k < 3; ++k)
printf("%d ", pa[i][k]);
putchar('\n');
}
free(pa);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı
yazı ı ı ı ı
bir matrisi parametre olarak alan bir fonksiyonun parametrik yapı ı
void foo(int *pi, size_t rowsize, size_t colsize);
Fonksiyon içerisinde bu matrisin i'inci satı ı ı ı ı
doğal matris erişiminde daha yavaş değildir. Çünkü matrisler zaten doğal türler değildir. Yani bir matrisin elemanı
eriştiğimizde de zaten derleyici aynı ı
Tabii bu fonksiyonu çağı ı
int a[3][2] = { {1, 2}, {3, 4}, {5, 6} };
...
foo(a, 3, 2); /* geçersiz! */
foo((int *)a, 3, 2); /* geçerli
Tabii tür dönüştürmesi yapı ı ı
yapı
void foo(void *pv, size_t rowsize, size_t colsize)
{
int *pi = (int *)pv;
...
}
Artı
foo(a, 3, 2);
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void disp_matrix(void *pv, size_t rowsize, size_t colsize)
{
int *pi = (int *)pv;
for (size_t i = 0; i < rowsize; ++i) {
for (size_t k = 0; k < colsize; ++k)
printf("%d ", pi[i * colsize + k]);
putchar('\n');
}
}
int main(void)
{
int a[3][2] = {{1, 2}, {3, 4}, {5, 6}};
disp_matrix(a, 3, 2);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Her elemanı
int (*a[10])[2];
Burada a 10 elemanlı ı
göstericisidir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
25. Ders 09/09/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Fonksiyonun parametre parantezi içerisinde çok boyutlu dizi sentaksı ı
void foo(int a[][3])
{
...
}
Bu tanı ı
void foo(int (*a)[3])
{
...
}
Tabii dizisel gösterimde ikinci koşeli parantezin (çok boyutlu dizilerde ilki haricindeki tüm köşeli parantezlerin) içinde uzunluk belirten
bir sabit ifadesinin bulunuyor olması ı
uzunluğun hiçbir önemi yoktur. Örneğin aşağı
void foo(int a[][3]);
void foo(int a[10][3]);
void foo(int (*a)[3]);
-------------------------------------------------------------------------------------------------------------------------------------------*/
void foo(int a[][5]) /* int (*a)[5] */
{
/* ... */
}
int main(void)
{
int a[5];
foo(&a);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Fonksiyonları ı ı
Parantezin soluna geri dönüş değerine ilişkin dizinin türü, sağı ı ı
int (*foo(int a))[3]
{
...
}
Burada foo fonksiyonunun parametresi int türdendir. Ancak geri dönüş değeri 3 elemanlı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
int(*foo(void))[5]
{
static int a[3] = {1, 2, 3, 4, 5};
return &a;
}
int main(void)
{
int(*pa)[5];
int i;
pa = foo();
for (i = 0; i < 5; ++i)
printf("%d ", (*pa)[i]);
printf("\n");
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
İşletim sistemlerinde bir dosyanı ı
geçişleri kullanı
kullanı ı ı
Örneğin:
"/home/kaan/Study/test.txt"
Burada "home", "kaan", "Study", "test.txt" birer yol ifadesi girişidir.
Windows sistemlerinde "sürücü (drive)" kavramı ı ı ı ı ı
sürücüler de belirtilebilmektedir. Örneğin:
"F:\Dropbox\Study\test.txt"
Halbuki UNIX/Linux sistemlerinde ve macOS sistemlerinde sürücü kavramı ı ı
herhangi bir yere monte edilirler. Bu işleme İngilizce "mount" denilmektedir. Mount işleminin yapı ı ı ı ı ı
kök dizini gibi işlem görmektedir.
Yol ifadeleri "mutlak (absolute)" ve "göreli (relative)" olmak üzere ikiye ayrı ı
ise bu tür yol ifadelerine mutlak yol ifadeleri denilmektedir. Örneğin:
"/home/kaan/Study/test.txt"
Bu yol ifadesi UNIX/Linux sistemlerinde mutlak bir yol ifadesidir. Örneğin:
"\Windows\notepad.exe"
Bu yol ifadesi de Windows sistemleri için mutlak bir yol ifadesidir. Mutlak yol ifadeleri her zaman kök dizinden itibaren yer belirtirler.
Eğer yol ifadelerindeki ilk karakter "/" ya da "\" değilse böyle yol ifadelerine de "göreli yol ifadeleri" denilmektedir. Örneğin:
"Study/C/test.txt"
"Doc\Temp\test.txt"
"samle.c"
Bu yol ifadeleri görelidir. İşletim sistemleri her proses için prosesin kontrol bloğu içerisinde ismine "prosesin çalı
current working directory)" denilen bir dizin tutmaktadı ı ı
Yani prosesin çalı ı
proses yaratı ı ı ı ı
yaratı ı ı ı ı ı ı ı ı ı ı ı ı
"sample" programı ı ı ı ı ı ı ı ı ı
programı ı ı ı ı ı ı ı
yaratan prosesin çalı ı ı
çalı
Windows sistemlerinde bir yol ifadesinde sürücü bilgisi de varsa buna "tam yol ifadesi (full path)" denilmektedir. Örneğin:
"C:\Windows\temp\x.txt"
Pekiyi bu sistemlerde mutlak bir yol ifadesi sürücü içermezse default sürücü ne olacaktı
"\temp\test.txt"
Bu mutlak ifadesi hangi sürücünün kök dizininden itibaren yer belirtmektedir? İşte Windows sistemlerinde sürücüsü belirtilmemiş olan yol mutlak
yol ifadeleri prosesin çalı ı
ise yukarı ı ı
yukarı
göreli ise bu durumda proseste bazı ı ı
kök dizini orijin kabul edilmektedir. Örneğin:
"D:Ali\test.txt"
Burada yol ifadesinde sürücü belirtilmiştir. Ancak yol ifadesi görelidir. İşte bu durumda orijin noktası ı ı ı
Ancak bu çevre değişkenleri yoksa bu yol ifadesi "D:\Ali\test.txt" ile eşdeğer kabul edilir. Tabii programcı ı ı ı
daha uygun olur.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde prosesin çalı
Fonksiyonun prototipi şöyledir:
DWORD GetCurrentDirectory(
DWORD nBufferLength,
LPTSTR lpBuffer
);
Fonksiyonun ikinci parametresi prosesin çalı ı ı
bu dizinin uzunluğunu belirtmektedir. Fonksiyon başarı ı ı ı ı
uzunluğu yetersiz kalı
uzunluğunu verir. Fonksiyon başarı ı ı ı ı ı
null karakter dahil değildir. Eğer fonksiyonunun birinci parametresi 0 ve ikinci parametresi NULL adres geçilirse fonksiyon prosesin çalı
dizininin yerleştirilmesi için gereken karakter sayı ı ı
Windows sistemlerinde bir yol ifadesinin maksimum uzunluğu MAX_PATH değeri ile önceden belirlenmiştir. Bu tür durumlarda dizi uzunlukları ı
MAX_PATH kadar açı ı
GetCurrentDirectory fonksiyonunun başarı ı ı
char cwd[BUFFER_SIZE];
DWORD dwResult;
if (!(dwResult = GetCurrentDirectory(BUFFER_SIZE, cwd)))
ExitSys("GetCurrentDirectory");
if (dwResult > BUFFER_SIZE) {
fprintf(stderr, "Buffer too small!..\n");
exit(EXIT_FAILURE);
}
Aşağı ı ı ı ı ı ı ı ı ı
olup olmadı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
char cwd[MAX_PATH];
if (!GetCurrentDirectory(MAX_PATH, cwd))
ExitSys("GetCurrentDirectory");
puts(cwd);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
GetCurrentDirectory fonksiyonunda birinci parametre 0, ikinci parametre NULL geçilirse çalı
elde edilir. Aşağı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
char *cwd;
DWORD dwBufSize;
if (!(dwBufSize = GetCurrentDirectory(0, NULL)))
ExitSys("GetCurrentDirectory");
if ((cwd = (char *)malloc(dwBufSize)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
if (!GetCurrentDirectory(dwBufSize, cwd))
ExitSys("GetCurrentDirectory");
puts(cwd);
free(cwd);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde prosesin çalı ı ı
prototipi şöyledir:
BOOL SetCurrentDirectory(
LPCTSTR lpPathName
);
Fonksiyon set edilecek çalı ı ı ı ı ı ı ı ı ı
Aşağı ı
çalı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
char cwd[MAX_PATH];
DWORD dwResult;
if (!SetCurrentDirectory("c:\\windows"))
ExitSys("SetCurrentDirectory");
if (!(dwResult = GetCurrentDirectory(MAX_PATH, cwd)))
ExitSys("GetCurrentDirectory");
puts(cwd);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Basit bir shell uygulaması ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include <windows.h>
#define MAX_CMD_LINE 4096
#define MAX_CMD_PARAMS 64
struct CMD {
char *cmd_text;
void (*proc)(void);
};
void ExitSys(LPCSTR lpszMsg);
void ParseCmdLine(void);
void DirProc(void);
void CopyProc(void);
void ClsProc(void);
void RenameProc(void);
void ChangeDirProc(void);
void DispDirectory(LPCTSTR lpszPath);
char g_cmd_line[MAX_CMD_LINE];
struct CMD g_cmds[] = {
{"dir", DirProc},
{"copy", CopyProc},
{"cls", ClsProc},
{"rename", RenameProc},
{"cd", ChangeDirProc},
{NULL, NULL},
};
char *g_params[MAX_CMD_PARAMS];
int g_nparams;
char g_cwd[MAX_PATH];
int main(void)
{
char *str;
int i;
if (!GetCurrentDirectory(MAX_PATH, g_cwd))
ExitSys("GetCurrentDirectory");
for (;;) {
printf("%s>", g_cwd);
fgets(g_cmd_line, MAX_CMD_LINE, stdin);
if ((str = strchr(g_cmd_line, '\n')) != NULL)
*str = '\0';
ParseCmdLine();
if (g_nparams == 0)
continue;
if (!strcmp(g_params[0], "exit"))
break;
for (i = 0; g_cmds[i].cmd_text != NULL; ++i)
if (!strcmp(g_cmds[i].cmd_text, g_params[0])) {
g_cmds[i].proc();
break;
}
if (g_cmds[i].cmd_text == NULL)
printf("command not found: %s\n\n", g_params[0]);
}
return 0;
}
void ParseCmdLine(void)
{
char *str;
g_nparams = 0;
for (str = strtok(g_cmd_line, " \t"); str != NULL; str = strtok(NULL, " \t"))
g_params[g_nparams++] = str;
g_params[g_nparams] = NULL;
}
void DirProc(void)
{
if (g_nparams > 2) {
printf("too many arguments!..\n");
return;
}
DispDirectory(g_nparams == 1 ? g_cwd : g_params[1]);
}
void CopyProc(void)
{
if (g_nparams != 3) {
printf("argument too few or too many!..\n\n");
return;
}
}
void ClsProc(void)
{
if (g_nparams != 1) {
printf("too many arguments!\n\n");
return;
}
printf("cls command\n");
}
void RenameProc(void)
{
printf("rename command\n");
}
void ChangeDirProc(void)
{
if (g_nparams > 2) {
printf("too many arguments!..\n\n");
return;
}
if (g_nparams == 1) {
printf("%s\n\n", g_cwd);
return;
}
if (!SetCurrentDirectory(g_params[1])) {
printf("directory not found or cannot change: %s\n\n", g_params[1]);
return;
}
if (!GetCurrentDirectory(MAX_PATH, g_cwd))
ExitSys("GetCurrentDirectory");
}
void DispDirectory(LPCTSTR lpszPath)
{
WIN32_FIND_DATA wfd;
char lpszDirPath[MAX_PATH];
HANDLE hFF;
sprintf(lpszDirPath, "%s/*.*", lpszPath);
if ((hFF = FindFirstFile(lpszDirPath, &wfd)) == INVALID_HANDLE_VALUE) {
printf("directory not found or cannot display!\n\n");
return;
}
do {
if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
printf("%-10s", "<DIR>");
else
printf("%-10lu", wfd.nFileSizeLow);
printf("%s\n", wfd.cFileName);
} while (FindNextFile(hFF, &wfd));
printf("\n");
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde prosesin çalı
#include <unistd.h>
char *getcwd(char *buf, size_t size);
Fonksiyonun birinci prosesin çalı
uzunluğunu almaktadı ı ı
başarı ı ı ı ı ı
UNIX/Linux sistemlerinde yol ifadelerinin maksimum değerleri <limits.h> içerisinde bildirilmiş olan PATH_MAX isimli bir sembolik sabitle
ifade edilmektedir. Ancak bu sembolik sabitin define edilmiş olma zorunluluğu yoktur. Eğer bu sembolik sabit define edilmemişse bu durumda
maksimum yol ifadesinin uzunluğu pathconf isimli POSIX fonksiyonuyla elde edilmektedir. Linux'ta PATH_MAX sembolik sabiti 4096 olarak
define edilmiştir.
Aşağı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
char cwd[4096];
if (getcwd(cwd, 4096) == NULL)
exit_sys("getcwd");
puts(cwd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
26. Ders 10/09/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı
UNIX/Linux sistemlerinde bunun karşı ı ı
sabitinin 4096 olarak define edildiğini anı ı ı ı
elde edenbilmek için aşağı ı ı
long path_max(void)
{
static long result = 0;
#define PATH_MAX_INDETERMINATE_GUESS 4096
#ifdef PATH_MAX
result = PATH_MAX;
#else
if (result == 0) {
errno = 0;
if ((result = pathconf("/", _PC_PATH_MAX)) == -1 && errno == 0)
result = PATH_MAX_INDETERMINATE_GUESS;
}
#endif
return result;
}
Aşağı
alan malloc fonksiyonuyla tahsis edilmiştir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
void exit_sys(const char *msg);
long path_max(void)
{
static long result = 0;
#define PATH_MAX_INDETERMINATE_GUESS 4096
#ifdef PATH_MAX
result = PATH_MAX;
#else
if (result == 0) {
errno = 0;
if ((result = pathconf("/", _PC_PATH_MAX)) == -1 && errno == 0)
result = PATH_MAX_INDETERMINATE_GUESS;
}
#endif
return result;
}
int main(void)
{
char *cwd;
long size;
size = path_max();
if ((cwd = (char *)malloc(size)) == NULL)
exit_sys("malloc");
if (getcwd(cwd, size) == NULL)
exit_sys("getcwd");
printf("size: %ld, cwd = %s\n", size, cwd);
free(cwd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde proseslerin çalı ı ı
şöyledir:
#include <unistd.h>
int chdir(const char *path);
Fonksiyon çalı ı ı ı ı ı ı
değerine geri döner.
Aşağı ı ı ı ı ı ı ı ı
elde edilip yazdı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
char cwd[4096];
if (getcwd(cwd, 4096) == NULL)
exit_sys("getcwd");
puts(cwd);
if (chdir("/usr/include") == -1)
exit_sys("getcwd");
if (getcwd(cwd, 4096) == NULL)
exit_sys("getcwd");
puts(cwd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı
Programda yine myshell programı ı ı ı
Normal olarak UNIX/Linux sistemlerinde cd komutu argüman almazsa çalı ı
örnekte biz bu özelliği sağlamı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* myshell.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <math.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <dirent.h>
#include <pwd.h>
#include <grp.h>
#define MAX_CMD_LINE 4096
#define MAX_CMD_PARAMS 128
#define BUFFER_SIZE 8192
#define MAX_PATH_SIZE 4096
void parse_cmdline(void);
void cat_cmd(void);
void cp_cmd(void);
void rename_proc(void);
void pwd_proc(void);
void cd_proc(void);
void ls_proc(void);
void clear_proc(void);
const char *get_ls(const char *path, int hlink_digit, int uname_digit, int gname_digit, int size_digit);
void exit_sys(const char *msg);
typedef struct tagCMD {
char *cmd_name;
void (*cmd_proc)(void);
} CMD;
char g_cmdline[MAX_CMD_LINE];
char *g_params[MAX_CMD_PARAMS];
int g_nparams;
CMD g_cmds[] = {
{"cat", cat_cmd},
{"cp", cp_cmd},
{"rename", rename_proc},
{"pwd", pwd_proc},
{"cd", cd_proc},
{"ls", ls_proc},
{"clear", clear_proc},
{NULL, NULL}
};
char g_cwd[MAX_PATH_SIZE];
int main(void)
{
char *str;
int i;
if (getcwd(g_cwd, MAX_PATH_SIZE) == NULL)
exit_sys("getcwd");
for (;;) {
printf("CSD:%s>", g_cwd);
if (fgets(g_cmdline, MAX_CMD_LINE, stdin) == NULL)
continue;
if ((str = strchr(g_cmdline, '\n')) != NULL)
*str = '\0';
parse_cmdline();
if (g_nparams == 0)
continue;
if (!strcmp(g_params[0], "exit"))
break;
for (i = 0; g_cmds[i].cmd_name != NULL; ++i)
if (!strcmp(g_cmds[i].cmd_name, g_params[0])) {
g_cmds[i].cmd_proc();
break;
}
if (g_cmds[i].cmd_name == NULL) {
printf("invalid command: %s\n", g_params[0]);
}
}
return 0;
}
void parse_cmdline(void)
{
char *str;
g_nparams = 0;
for (str = strtok(g_cmdline, " \t"); str != NULL; str = strtok(NULL, " \t"))
g_params[g_nparams++] = str;
g_params[g_nparams] = NULL;
}
void cat_cmd(void)
{
FILE *f;
int ch;
if (g_nparams != 2) {
printf("cat command missing file!..\n");
return;
}
if ((f = fopen(g_params[1], "r")) == NULL) {
printf("file not found or cannot open file: %s\n", g_params[1]);
return;
}
while ((ch = fgetc(f)) != EOF)
putchar(ch);
if (ferror(f))
printf("cannot read file: %s\n", g_params[1]);
fclose(f);
}
void cp_cmd(void)
{
int fds, fdd;
char buf[BUFFER_SIZE];
ssize_t result;
if (g_nparams != 3) {
printf("source and destination path must be specified!..\n");
return;
}
if ((fds = open(g_params[1], O_RDONLY)) == -1) {
printf("file not found or cannot open: %s\n", g_params[1]);
return;
}
if ((fdd = open(g_params[2], O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) == -1) {
printf("file not found or cannot open: %s\n", g_params[2]);
goto EXIT2;
}
while ((result = read(fds, buf, BUFFER_SIZE)) > 0)
if (write(fdd, buf, result) != result) {
printf("cannot write file: %s\n", g_params[2]);
goto EXIT1;
}
if (result == -1) {
printf("cannot read file: %s\n", g_params[1]);
goto EXIT1;
}
printf("1 file copied...\n");
EXIT1:
close(fdd);
EXIT2:
close(fds);
}
void rename_proc(void)
{
printf("rename command...\n");
}
void pwd_proc(void)
{
puts(g_cwd);
}
void cd_proc(void)
{
if (g_nparams == 1) {
printf("argument missing!..\n");
return;
}
if (g_nparams > 2) {
printf("too many arguments!..\n");
return;
}
if (chdir(g_params[1]) == -1) {
printf("%s: %s!..\n", g_params[1], strerror(errno));
return;
}
if (getcwd(g_cwd, MAX_PATH_SIZE) == NULL)
exit_sys("getcwd");
}
#include <sys/wait.h>
void ls_proc(void)
{
int result;
int l_flag;
int hlink_digit, uname_digit, gname_digit, size_digit;
DIR *dir;
struct dirent *dent;
char path[PATH_MAX];
struct stat finfo;
int len;
struct passwd *pass;
struct group *gr;
char *target_path;
l_flag = 0;
opterr = 0;
optind = 0;
while ((result = getopt(g_nparams, g_params, "l")) != -1) {
switch (result) {
case 'l':
l_flag = 1;
break;
case '?':
printf("invalid option: -%c\n", optopt);
break;
}
}
if (g_nparams - optind > 1) {
printf("too many arguments!..\n");
return;
}
target_path = optind == g_nparams ? "." : g_params[optind];
if ((dir = opendir(target_path)) == NULL) {
printf("%s: %s\n", target_path, strerror(errno));
return;
}
hlink_digit = uname_digit = gname_digit = size_digit = 0;
while (errno = 0, (dent = readdir(dir)) != NULL) {
snprintf(path, PATH_MAX, "%s/%s", target_path, dent->d_name);
if (stat(path, &finfo) == -1) {
printf("%s: %s\n", path, strerror(errno));
continue;
}
len = (int)log10(finfo.st_nlink) + 1;
if (len > hlink_digit)
hlink_digit = len;
if ((pass = getpwuid(finfo.st_uid)) == NULL)
exit_sys("getppuid");
len = (int)strlen(pass->pw_name);
if (len > uname_digit)
uname_digit = len;
if ((gr = getgrgid(finfo.st_gid)) == NULL)
exit_sys("getgrgid");
len = (int)strlen(gr->gr_name);
if (len > gname_digit)
gname_digit = len;
len = (int)log10(finfo.st_size) + 1;
if (len > size_digit)
size_digit = len;
}
if (errno != 0)
exit_sys("readdir");
rewinddir(dir);
while (errno = 0, (dent = readdir(dir)) != NULL) {
sprintf(path, "%s/%s", target_path, dent->d_name);
if (stat(path, &finfo) == -1) {
printf("%s: %s\n", path, strerror(errno));
continue;
}
if (l_flag)
printf("%s\n", get_ls(path, hlink_digit, uname_digit, gname_digit, size_digit));
else
printf("%s\t", dent->d_name);
}
if (errno != 0)
exit_sys("readdir");
if (!l_flag)
putchar('\n');
closedir(dir);
}
void clear_proc(void)
{
printf("\033[2J");
printf("\033[0;0f");
}
const char *get_ls(const char *path, int hlink_digit, int uname_digit, int gname_digit, int size_digit)
{
struct stat finfo;
static char buf[4096];
static mode_t modes[] = { S_IRUSR, S_IWUSR, S_IXUSR, S_IRGRP, S_IWGRP, S_IXGRP, S_IROTH, S_IWOTH, S_IXOTH };
struct passwd *pass;
struct group *gr;
char *str;
int index = 0;
int i;
if (stat(path, &finfo) == -1)
return NULL;
if (S_ISREG(finfo.st_mode))
buf[index] = '-';
else if (S_ISDIR(finfo.st_mode))
buf[index] = 'd';
else if (S_ISCHR(finfo.st_mode))
buf[index] = 'c';
else if (S_ISBLK(finfo.st_mode))
buf[index] = 'b';
else if (S_ISFIFO(finfo.st_mode))
buf[index] = 'p';
else if (S_ISLNK(finfo.st_mode))
buf[index] = 'l';
else if (S_ISSOCK(finfo.st_mode))
buf[index] = 's';
++index;
for (i = 0; i < 9; ++i)
buf[index++] = (finfo.st_mode & modes[i]) ? "rwx"[i % 3] : '-';
buf[index] = '\0';
index += sprintf(buf + index, " %*llu", hlink_digit, (unsigned long long)finfo.st_nlink);
if ((pass = getpwuid(finfo.st_uid)) == NULL)
return NULL;
index += sprintf(buf + index, " %-*s", uname_digit, pass->pw_name);
if ((gr = getgrgid(finfo.st_gid)) == NULL)
return NULL;
index += sprintf(buf + index, " %-*s", gname_digit, gr->gr_name);
index += sprintf(buf + index, " %*lld", size_digit, (long long)finfo.st_size);
index += strftime(buf + index, 100, " %b %e %H:%M", localtime(&finfo.st_mtime));
str = strrchr(path, '/');
sprintf(buf + index, " %s", str ? str + 1 : path);
return buf;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
27. Ders 16/09/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Stack (yı ı ı ı ı ı ı ı ı
çalı ı ı ı ı ı ı ı ı ı
isimli bir veri yapı ı ı ı ı ı ı ı ı
verilmiştir.)
Biz C derlerinden fonksiyonları ı ı ı ı ı ı
sistemlerde stack'te bazı ı ı ı
bir yerdir. Bir programı ı ı ı ı
program yüklendiğinde işlemcinin kullanacağı ı ı ı ı
aşağı ı ı ı ı ı ı ı ı
noktası ı ı
Her fonksiyon çağrı ı ı
yaratı ı
void bar(void)
{
int x, y;
}
void foo(void)
{
int a, b;
bar();
}
Buraada başlangı ı ı ı
SP ----> Stack'in sonu
foo çağrı ı ı ı
SP ---->
a
b
Stack'in sonu
Şimdi foo fonksiyonu bar fonksiyonunu çağı ı
SP ---->
x
y
a
b
Stack'in sonu
Şimdi bar fonksiyonunun sonlandı ı ı
SP ---->
a
b
Stack'in sonu
Fonksiyonun yerel değişkenlerinin stack'teki konumları ı ı ı ı
yerel değişkenlerini ardı ı ı
bazı ı ı
Ancak stack yalnı ı ı ı ı ı
olabilmesi için CALL makine komutunda işlemci sonraki komutun adresini stack'te saklar. ret makine komutu da stack'ten bu adresi alarak geri
dmüşü sağlar. Yani bir fonksiyon çağı ı ı ı ı ı ı ı
çağı ı ı
SP ---->
x
y
<bar için geri dönüş adresi>
a
b
<foo için geri dönüş adresi>
Stack'in sonu
Stack'te yerel değişkenlerin tahsisatı ı ı ı
100 byte uzunluğunda yerel değişkenleri olsun.Tahisat stack pointer'ı ı ı ı
Benzer biçimde tahsisatı ı ı ı ı ı ı ı
Pekiyi stack için ayrı ı ı ı
Buna İngilizce "stack overflow" denilmektedir. Tabii stack'in taşması ı ı ı
hangi fonksiyonun hangi fonksiyonu çağı ı ı ı ı
Linux gibi, macOS gibi sistemlerde taşma işlemci tarafı
açan prosesi sonlandı ı
32 bit ve 64 bit Windows sistemlerinde default stack 1MB'tı
aslı
Pekiyi fonksiyonları ı ı ı ı ı ı
ya da yazmaç yoluyla yapı ı ı ı
Linux ve macOS sistemlerinde yazmaç yoluyla yapı ı ı ı ı ı ı ı ı
Binary Interface (ABI)" denilmektedir. Fonksiyon çağrı ı ı
da denilmektedir. Eğer parametreler yazmaç yoluyla aktarı ı ı ı ı ı
sorumluluğundadı ı ı ı ı
söyleyebiliriz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Özyineleme (recursion) doğada da karşı ı ı ı ı
Örneğin tohumdan ağaç olur, ağaç da yeniden tohum vermektedir. Matruşkalar da özyineleme içermektedir. Programlamada özyineleme bazı
özel algoritmalarda karşı ı ı ı ı ı ı ı ı
sonra ilk duruma benzer bir durumla karşı ı ı
listesini alt dizinlerle dolaşmak isteyelim. Bunun için kök dizindeki dizin girişlerini elde ederiz. Eğer o dizin girişlerinin biri de
bir dizine ilişkinse o dizine geçtiğimizde yine ilk işe başladı ı ı ı ı
dolaşı ı
Bir algoritmik problemin özyineleme olmadan çözümüne "iteratif çözüm" de denilmektedir. O halde algoritmalar bu bakı ı
1) Yalnı
2) Hem iteratif hem de özyinemelei biçimde çözülebilen algoritmalar
3) Yalnı
Bazı ı ı ı
hem özyineleme ile hem de klasik iteratif yöntemlerle çözülebilmektedir. Ancak bazı ı
makul değildir.
Özyinelemeli karaktere sahip olan algoritmalar tipik olarak kendi kendini çağı ı
özyinelemeli algoritmalar yapay stack kullanı ı
kendini çağı ı ı ı
denilmektedir.
Bir algoritma hem iteratif yöntemle hem de özyinelemeli yöntemle çözülebiliyorsa genellikle (ancak her zaman değil) iteratif yöntem daha
etkin bir gerçekleştirim sunmaktadı ı
gibi bazı ı ı
Genellikle bir fonksiyonun kendini çağı ı ı ı ı ı ı
çağı ı ı ı ı ı ı ı ı ı ı ı
fonksiyon bittiğinde akı ı ı ı ı ı ı
yine akı ı
fonksiyon kendisini kontrolsüz bir biçimde çağı ı
void foo(void)
{
printf("foo\n");
foo();
}
Burada foo fonksiyonu çağrı ı ı ı ı ı ı
hiç yerel değişkeni olmasa bile CALL işlemi sonucunda geri dönüş adresi stack'te kaydedildiği için bir stack taşması
Linux, macOS sistemlerinde program çökecektir.
Özyinelemeli fonksiyonlarda anahtar noktalardan biri fonksiyon her kendini çağı ı ı
kopyası ı ı ı ı
void foo(void)
{
int a, b;
a = 10;
b = 20;
foo();
...
}
Burada foo kendisini çağı ı ı ı ı ı ı ı ı
Fonksiyonun parametre değişkenleri de fonksiyonunun her kendini çağı ı ı ı
Bir fonksiyon kendini kontrolsüz bir biçimde çağı ı ı ı ı ı ı
Örneğin:
void foo(int n)
{
if (n == 0)
return;
printf("n before call: %d\n", n);
foo(n - 1);
printf("n after call: %d\n", n);
}
...
foo(3);
Burada her foo çağrı ı ı ı ı
çağı ı ı ı ı ı ı ı ı
dikkat ediniz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void foo(int n)
{
if (n == 0)
return;
printf("n before call: %d\n", n);
foo(n - 1);
printf("n after call: %d\n", n);
}
int main(void)
{
foo(3);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
unsigned long long factorial(int n)
{
unsigned long long total = 1;
for (int i = 2; i <= n; ++i)
total *= i;
return total;
}
int main(void)
{
unsigned long long result;
result = factorial(10);
printf("%llu\n", result);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Şimdi faktörüyel hesabı ı ı ı
unsigned long long factorial(int n)
{
unsigned long long temp;
if (n == 0)
return 1;
temp = n * factorial(n - 1);
return temp;
}
Aslı ı ı ı ı
kullandı ı ı ı ı ı
factorial(4);
Burada özyinemeli çağı ı
factorial(4)
************
temp = 4 * factorial(3);
factorial(3)
************
temp = 3 * factorial(2);
factorial(2)
************
temp = 2 * factorial(1);
factorial(1)
************
temp = 1 * factorial(0);
factorial(0)
************
return 1;
En sonunda factorial(0) çağrı ı ı ı ı ı ı
gerek yoktur:
unsigned long long factorial(int n)
{
if (n == 0)
return 1;
return n * factorial(n - 1);;
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
unsigned long long factorial(int n)
{
if (n == 0)
return 1;
return n * factorial(n - 1);;
}
int main(void)
{
unsigned long long result;
result = factorial(4);
printf("%llu\n", result);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir yazı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void putsrev(const char *str)
{
size_t i;
for (i = 0; str[i] != '\0'; ++i)
;
while (i-- > 0)
putchar(str[i]);
putchar('\n');
}
int main(void)
{
char s[] = "ankara";
putsrev(s);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Genel olarak düzden yapı ı ı
çı ı ı ı ı
void putsrev(const char *str)
{
if (*str == '\0')
return;
putsrev(str + 1);
putchar(*str);
}
Burada biz putsrev fonksiyonunu putsrev("ali") biçiminde çağı ı ı ı ı ı ı
İkinci çağrı ı ı ı ı ı ı ı ı ı ı ı ı ı
bir önceki çağı ı ı ı ı ı ı
str değişkeninin yaratı ı ı ı ı ı ı
çok daha etkindir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void putsrev(const char *str)
{
if (*str == '\0')
return;
putsrev(str + 1);
putchar(*str);
}
int main(void)
{
putsrev("ankara");
putchar('\n');
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir yazı ı ı ı ı ı ı
elemanları ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void revstr(char *str)
{
size_t n;
char temp;
for (n = 0; str[n] != '\0'; ++n)
;
for (size_t k = 0; k < n / 2; ++k) {
temp = str[k];
str[k] = str[n - k - 1];
str[n - k - 1] = temp;
}
}
int main(void)
{
char s[] = "ankara";
revstr(s);
puts(s);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı
indeks numaraları ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
void revstr(char *str, size_t left, size_t right)
{
char temp;
while (left < right) {
temp = str[left];
str[left] = str[right];
str[right] = temp;
++left, --right;
}
}
int main(void)
{
char s[] = "ankara";
revstr(s, 0, strlen(s) - 1);
puts(s);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Şimdi yukarı
void revstr(char *str, size_t left, size_t right)
{
char temp;
if (right <= left)
return;
temp = str[left];
str[left] = str[right];
str[right] = temp;
revstr(str, left + 1, right - 1);
}
Burada hger defası ı ı ı ı ı ı ı
yer değiştirilmektedir. Tabii biz burada yalnı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
void revstr(char *str, size_t left, size_t right)
{
char temp;
if (right <= left)
return;
temp = str[left];
str[left] = str[right];
str[right] = temp;
revstr(str, left + 1, right - 1);
}
int main(void)
{
char s[] = "ankara";
revstr(s, 0, strlen(s) - 1);
puts(s);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bazen özyinelemeli fonksiyonun parametrik yapı ı ı ı
function) yazarak özyinelemeli fonksiyonu çağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
void revstr_recur(char *str, size_t left, size_t right)
{
char temp;
if (right <= left)
return;
temp = str[left];
str[left] = str[right];
str[right] = temp;
revstr_recur(str, left + 1, right - 1);
}
void revstr(char *s)
{
size_t n;
for (n = 0; s[n] != '\0'; ++n)
;
revstr_recur(s, 0, n ? n - 1 : 0);
}
int main(void)
{
char s[] = "ankara";
revstr(s);
puts(s);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir int sayı ı ı ı
void binprint(unsigned val)
{
for (int i = sizeof(val) * 8 - 1; i >= 0; --i)
putchar((val >> i & 1) + '0');
putchar('\n');
}
Burada sayı ı ı ı ı ı ı ı ı ı ı
void binprint(unsigned val)
{
int i;
for (i = sizeof(val) * 8 - 1; val >> i == 0 && i >= 0; --i)
;
for (; i >= 0; --i)
putchar((val >> i & 1) + '0');
putchar('\n');
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void binprint(unsigned val)
{
int i;
for (i = sizeof(val) * 8 - 1; val >> i == 0 && i >= 0; --i)
;
for (; i >= 0; --i)
putchar((val >> i & 1) + '0');
putchar('\n');
}
int main(void)
{
binprint(255);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Şimdi sayı ı ı
özyinelemeli biçimde çağı ı ı ı ı ı ı ı ı ı ı ı
düzden yapı
void binprint(unsigned val)
{
if (val == 0)
return;
binprint(val >> 1);
putchar((val & 1) + '0');
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void binprint(unsigned val)
{
if (val == 0)
return;
binprint(val >> 1);
putchar((val & 1) + '0');
}
int main(void)
{
binprint(255);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
28. Ders 17/09/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir bilgisayar sisteminde bir ekran varsa genel olarak o ekrana text modda yalnı ı ı ı ı
karakterle dönüştürülüp yazı ı ı ı ı
bu karakterleri ekrana basar. Başka bir deyişle aslı ı ı ı
fonksiyon vardı
Pekiyi biz int bir değeri yalnı ı ı ı ı ı ı ı ı ı
putchar kullanarak yazdı ı ı ı ı ı ı ı ı ı
edilmektedir. Örneğin:
while (val) {
digit = val % 10;
val /= 10;
}
O halde bizim basamakları ı ı ı ı ı
onun negatif olduğu bilgisini saklayı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void printd(int val)
{
int digit;
char buf[64];
int nflag;
int i;
nflag = 0;
i = 0;
if (val < 0) {
nflag = 1;
val = -val;
}
for (i = 0; val != 0; ++i) {
digit = val % 10;
buf[i] = '0' + digit;
val /= 10;
}
if (nflag)
buf[i++] = '-';
for (--i; i >= 0; --i)
putchar(buf[i]);
putchar('\n');
}
int main(void)
{
printd(-123456);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı
Yani bu problemin özyinelemeli çözümü iteratif çözümünden daha etkindir. Özyinelemeli çözüm şöyle olabilir:
void printd(int val)
{
if (val < 0) {
putchar('-');
val = -val;
}
if (val / 10)
printd(val / 10);
putchar(val % 10 + '0');
}
Burada fonksiyonu -12345 değeri ile çağı ı ı ı
basmayacaktı ı ı ı ı
if (val / 10)
printd(val / 10);
Burada 12345 değerinin 10'a bölümü 0 olmadı ı ı ı ı
tekrarlanacaktı
val = 12345
val = 1234
val = 123
val = 12
val = 1
Burada artı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void printd(int val)
{
if (val < 0) {
putchar('-');
val = -val;
}
if (val / 10)
printd(val / 10);
putchar(val % 10 + '0');
}
int main(void)
{
printd(-123456);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aslı ı ı
sistemden büyük sistemlerde (örneğin 16'lı ı ı
(ve diğer tablolarda da böyle) 0-9 arası ı ı
farklı ı
putchar(n % base > 9 ? n % base - 10 + 'A' : n % base + '0');
Buraada taban 10'dan büyükse düzeltme yapı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void printd(int val, int base)
{
if (val < 0) {
putchar('-');
val = -val;
}
if (val / base)
printd(val / base, base);
putchar(val % base > 9 ? val % base - 10 + 'A' : val % base + '0');
}
int main(void)
{
printd(255, 16);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Kapalı ı ı ı ı
algoritmada iç bir noktadan başlanı ı ı ı ı ı ı ı
gelindiğinde ya da da önce boyabnı
Aşağı ı ı ı ı ı
#######
##### #
####### ######
# #
# #
# ######
#### #
##### #
## #
###
Biz örneğimizde önce resmi bir text dosyaya kaydedip bu text dosyayı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
##include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define ROWSIZE 10
#define COLSIZE 20
#define FILLCHAR '.'
char g_bitmap[ROWSIZE][COLSIZE];
void read_bitmap(void)
{
FILE *f;
char buf[1024];
if ((f = fopen("bitmap.txt", "r")) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < ROWSIZE; ++i) {
fgets(buf, 1024, f);
memcpy(g_bitmap[i], buf, COLSIZE);
}
fclose(f);
}
void disp_bitmap(void)
{
for (int i = 0; i < ROWSIZE; ++i) {
for (int k = 0; k < COLSIZE; ++k)
putchar(g_bitmap[i][k]);
putchar('\n');
}
}
void floodfill(int row, int col)
{
if (g_bitmap[row][col] == '#' || g_bitmap[row][col] == FILLCHAR)
return;
g_bitmap[row][col] = FILLCHAR;
floodfill(row + 1, col);
floodfill(row, col - 1);
floodfill(row - 1, col);
floodfill(row, col + 1);
}
int main(void)
{
read_bitmap();
disp_bitmap();
floodfill(6, 10);
printf("\n\n");
disp_bitmap();
return 0;
}
int main(void)
{
if (!read_bitmap("bitmap.txt")) {
fprintf(stderr, "cannot read bitmap!..\n");
exit(EXIT_FAILURE);
}
floodfill(5, 5, '.');
disp_bitmap();
return 0;
}
/*
#######
##### #
####### ######
# #
# #
# ######
#### #
##### #
## #
###
*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bilindiği gibi ""seçerek sı ı ı ı
temeline daynmaktadı ı ı ı ı ı ı ı
iteratif çözümü aşağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void ssort(int *pi, size_t size)
{
size_t i, k;
size_t min_index;
int min;
for (i = 0; i < size - 1; ++i) {
min_index = i;
min = pi[i];
for (k = i + 1; k < size; ++k)
if (pi[k] < min) {
min = pi[k];
min_index = k;
}
pi[min_index] = pi[i];
pi[i] = min;
}
}
void disp(const int *pi, size_t size)
{
size_t i;
for (i = 0; i < size; ++i)
printf("%d ", pi[i]);
printf("\n");
}
#define SIZE 10
int main(void)
{
int a[SIZE] = { 34, 12, 7, 84, 72, 39, 75, 45, 59, 21 };
ssort(a, SIZE);
disp(a, SIZE);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Seçerek sı ı
Ancak biz burada özyineleme çalı ı ı ı
son elemanla yer değiştirilir. Sonra fonksiyon bir eksik uzunlukla kendini çağı ı ı ı ı
girmelidir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void selection_sort(int *pi, size_t size)
{
int max;
size_t max_index;
if (size <= 1)
return;
max = pi[0];
max_index = 0;
for (size_t i = 1; i < size; ++i)
if (pi[i] > max) {
max = pi[i];
max_index = i;
}
pi[max_index] = pi[size - 1];
pi[size - 1] = max;
selection_sort(pi, size - 1);
}
int main(void)
{
int a[10] = {41, 23, 12, 7, 37, 98, 29, 16, 82, 66};
selection_sort(a, 10);
for (int i = 0; i < 10; ++i)
printf("%d ", a[i]);
printf("\n");
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
8 vezir problemi bir satranç tahtası
Tipik bir çözümde satranç tahtası
işaretlenir. Özyinelemeli fonksiyon global matrise bakarak o anda vezirlerin yemediği ilk kareye verizi yerleştirir. Global matirisi
günceller ve kendisini çağı ı ı ı
yerleştirilebilmişse tahta print edilir. Bir çağrı ı ı
Aşağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#define SIZE 8
int g_qcount;
int g_count;
char g_board[SIZE][SIZE];
void init_board(void)
{
int r, c;
for (r = 0; r < SIZE; ++r)
for (c = 0; c < SIZE; ++c)
g_board[r][c] = '.';
}
void print_board(void)
{
int r, c;
printf("%d\n", g_count);
for (r = 0; r < SIZE; ++r) {
for (c = 0; c < SIZE; ++c)
printf("%c", g_board[r][c]);
printf("\n");
}
printf("\n");
}
void locate_queen(int row, int col)
{
int r, c;
g_board[row][col] = 'V';
r = row;
for (c = col + 1; c < SIZE; ++c)
g_board[r][c] = 'o';
for (c = col - 1; c >= 0; --c)
g_board[r][c] = 'o';
c = col;
for (r = row - 1; r >= 0; --r)
g_board[r][c] = 'o';
for (r = row + 1; r < SIZE; ++r)
g_board[r][c] = 'o';
for (r = row - 1, c = col - 1; r >= 0 && c >= 0; --r, --c)
g_board[r][c] = 'o';
for (r = row - 1, c = col + 1; r >= 0 && c < SIZE; --r, ++c)
g_board[r][c] = 'o';
for (r = row + 1, c = col - 1; r < SIZE && c >= 0; ++r, --c)
g_board[r][c] = 'o';
for (r = row + 1, c = col + 1; r < SIZE && c < SIZE; ++r, ++c)
g_board[r][c] = 'o';
}
void queen8(int row, int col)
{
char board[SIZE][SIZE];
for (; row < SIZE; ++row) {
for (; col < SIZE; ++col) {
if (g_board[row][col] == '.') {
memcpy(board, g_board, sizeof(board));
++g_qcount;
locate_queen(row, col);
if (g_qcount == SIZE) {
++g_count;
print_board();
}
queen8(row, col);
--g_qcount;
memcpy(g_board, board, sizeof(board));
}
}
col = 0;
}
}
int main(void)
{
init_board();
queen8(0, 0);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
29. Ders 23/09/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Dizin ağacı ı ı ı ı ı ı ı
çalı ı ı
girişi eğer bir dizin belirtiyorsa fonksiyon o dizin ile kendini çağı ı
prosesin çalı
içeriği erişim hakkı
sistemlerinde bir dizin var olduğu halde SetCurrentDirectory fonksiyonu ile erişim hakları ı ı
Halbuki UNIX/Linux sistemlerinde chdir fonksiyonu bir dizine erişim hakkı ı ı ı
Aşağı ı ı ı ı ı ı
prosesin çalı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include <windows.h>
void PutSysErr(LPCSTR lpszMsg);
void WalkDir(LPCSTR lpszDirPath)
{
HANDLE hFF;
WIN32_FIND_DATA fd;
if (!SetCurrentDirectory(lpszDirPath)) {
PutSysErr("SetCurrentDirectory");
return;
}
if ((hFF = FindFirstFile("*.*", &fd)) == INVALID_HANDLE_VALUE) {
PutSysErr("FindFirstFile");
goto EXIT;
}
do {
if (strcmp(fd.cFileName, ".") == 0 || strcmp(fd.cFileName, "..") == 0)
continue;
/* printf("%s\n", fd.cFileName); */
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
printf("%s\n", fd.cFileName);
WalkDir(fd.cFileName);
}
} while (FindNextFile(hFF, &fd));
if (GetLastError() != ERROR_NO_MORE_FILES)
PutSysErr("FindNextFile");
FindClose(hFF);
EXIT:
if (!SetCurrentDirectory(".."))
PutSysErr("SetCurrentDirectory");
}
int main(void)
{
WalkDir("C:\\windows");
return 0;
}
void PutSysErr(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Dizin ağacı ı ı ı ı
eklenebilir. Sonra her özyinelemede bu level parametresi bir artı ı ı
kullanabiliriz. Örneğin:
printf("%*s%s\n", level * TABSIZE, "", fd.cFileName);
Burada "%*s" format karakterinde "*" format karakterine level * TABSIZE argümanı ı ı ı
Dolayı ı ı ı ı ı ı
Aşağı ı ı ı ı
dosyası
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include <windows.h>
#define TABSIZE 4
void PutSysErr(LPCSTR lpszMsg);
void WalkDir(LPCSTR lpszDirPath, int level)
{
HANDLE hFF;
WIN32_FIND_DATA fd;
if (!SetCurrentDirectory(lpszDirPath)) {
PutSysErr("SetCurrentDirectory");
return;
}
if ((hFF = FindFirstFile("*.*", &fd)) == INVALID_HANDLE_VALUE) {
PutSysErr("FindFirstFile");
goto EXIT;
}
do {
if (strcmp(fd.cFileName, ".") == 0 || strcmp(fd.cFileName, "..") == 0)
continue;
/* printf("%s\n", fd.cFileName); */
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
printf("%*s%s\n", level * TABSIZE, "", fd.cFileName);
WalkDir(fd.cFileName, level + 1);
}
} while (FindNextFile(hFF, &fd));
if (GetLastError() != ERROR_NO_MORE_FILES)
PutSysErr("FindNextFile");
FindClose(hFF);
EXIT:
if (!SetCurrentDirectory(".."))
PutSysErr(lpszDirPath);
}
int main(void)
{
WalkDir("C:\Dropbox\Shared\Kurslar\SysProg-1"", 0);
return 0;
}
void PutSysErr(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı
çağrı ı ı
_access ismiyle de bulunmaktadı ı ı ı ı ı ı
Dolayı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include <windows.h>
#define TABSIZE 4
void PutSysErr(LPCSTR lpszMsg);
void WalkDirRecur(LPCSTR lpszDirPath, int level)
{
HANDLE hFF;
WIN32_FIND_DATA fd;
if (!SetCurrentDirectory(lpszDirPath)) {
PutSysErr("SetCurrentDirectory");
return;
}
if ((hFF = FindFirstFile("*.*", &fd)) == INVALID_HANDLE_VALUE) {
PutSysErr("FindFirstFile");
goto EXIT;
}
do {
if (strcmp(fd.cFileName, ".") == 0 || strcmp(fd.cFileName, "..") == 0)
continue;
/* printf("%s\n", fd.cFileName); */
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
printf("%*s%s\n", level * TABSIZE, "", fd.cFileName);
WalkDirRecur(fd.cFileName, level + 1);
}
} while (FindNextFile(hFF, &fd));
if (GetLastError() != ERROR_NO_MORE_FILES)
PutSysErr("FindNextFile");
FindClose(hFF);
EXIT:
if (!SetCurrentDirectory(".."))
PutSysErr(lpszDirPath);
}
void WalkDir(LPCTSTR lpszDirPath)
{
char cwd[MAX_PATH];
if (!GetCurrentDirectory(MAX_PATH, cwd))
PutSysErr("GetCurrentDirectory");
WalkDirRecur(lpszDirPath, 0);
if (!SetCurrentDirectory(cwd))
PutSysErr("SetCurrentDirectory");
}
int main(void)
{
WalkDir("C:\\Dropbox");
return 0;
}
void PutSysErr(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Dizin ağacı ı ı ı
genelleştirilmesi için fonksiyon göstericilerinden faydalanı ı
çağrı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include <windows.h>
#define TABSIZE 4
void PutSysErr(LPCSTR lpszMsg);
void WalkDirRecur(LPCSTR lpszDirPath, int level, void (*Proc)(const WIN32_FIND_DATA *, int))
{
HANDLE hFF;
WIN32_FIND_DATA fd;
if (!SetCurrentDirectory(lpszDirPath)) {
PutSysErr("SetCurrentDirectory");
return;
}
if ((hFF = FindFirstFile("*.*", &fd)) == INVALID_HANDLE_VALUE) {
PutSysErr("FindFirstFile");
goto EXIT;
}
do {
if (strcmp(fd.cFileName, ".") == 0 || strcmp(fd.cFileName, "..") == 0)
continue;
Proc(&fd, level);
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
WalkDirRecur(fd.cFileName, level + 1, Proc);
} while (FindNextFile(hFF, &fd));
if (GetLastError() != ERROR_NO_MORE_FILES)
PutSysErr("FindNextFile");
FindClose(hFF);
EXIT:
if (!SetCurrentDirectory(".."))
PutSysErr(lpszDirPath);
}
void WalkDir(LPCTSTR lpszDirPath, void (*Proc)(const WIN32_FIND_DATA *, int))
{
char cwd[MAX_PATH];
if (!GetCurrentDirectory(MAX_PATH, cwd))
PutSysErr("GetCurrentDirectory");
WalkDirRecur(lpszDirPath, 0, Proc);
if (!SetCurrentDirectory(cwd))
PutSysErr("SetCurrentDirectory");
}
void DispFile(const WIN32_FIND_DATA *fd, int level)
{
printf("%*s%s\n", level * TABSIZE, "", fd->cFileName);
}
int main(void)
{
WalkDir("C:\\Dropbox\\Shared\\Kurslar\\SysProg-1", DispFile);
return 0;
}
void PutSysErr(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Özyinelemeli fonksiyonlarda belli bir koşul sağlandı ı ı ı ı ı
fonksiyonun prototipi şöyledir:
BOOL Proc(const WIN32_FIND_DATA *fd, int level);
Fonksiyon her dizin girişi bulundukça çağrı ı ı ı ı ı
devam edeceği anlamı ı ı ı ı
Tabii özyineleme sonlandı ı ı ı ı ı
bunları ı ı ı
Aşağı ı ı ı ı
kullanı ı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include <windows.h>
#define TABSIZE 4
void PutSysErr(LPCSTR lpszMsg);
BOOL WalkDirRecur(LPCSTR lpszDirPath, int level, BOOL (*Proc)(const WIN32_FIND_DATA *, int))
{
HANDLE hFF;
WIN32_FIND_DATA fd;
BOOL bResult;
bResult = TRUE;
if (!SetCurrentDirectory(lpszDirPath)) {
PutSysErr("SetCurrentDirectory");
return TRUE;
}
if ((hFF = FindFirstFile("*.*", &fd)) == INVALID_HANDLE_VALUE) {
PutSysErr("FindFirstFile");
goto EXIT1;
}
do {
if (strcmp(fd.cFileName, ".") == 0 || strcmp(fd.cFileName, "..") == 0)
continue;
if (!Proc(&fd, level)) {
bResult = FALSE;
goto EXIT2;
}
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
if (!WalkDirRecur(fd.cFileName, level + 1, Proc)) {
bResult = FALSE;
goto EXIT2;
}
} while (FindNextFile(hFF, &fd));
if (GetLastError() != ERROR_NO_MORE_FILES)
PutSysErr("FindNextFile");
EXIT2:
FindClose(hFF);
EXIT1:
if (!SetCurrentDirectory(".."))
PutSysErr(lpszDirPath);
return bResult;
}
BOOL WalkDir(LPCTSTR lpszDirPath, BOOL (*Proc)(const WIN32_FIND_DATA *, int))
{
char cwd[MAX_PATH];
BOOL bResult;
if (!GetCurrentDirectory(MAX_PATH, cwd))
PutSysErr("GetCurrentDirectory");
bResult = WalkDirRecur(lpszDirPath, 0, Proc);
if (!SetCurrentDirectory(cwd))
PutSysErr("SetCurrentDirectory");
return bResult;
}
BOOL DispFile(const WIN32_FIND_DATA *fd, int level)
{
printf("%*s%s\n", level * TABSIZE, "", fd->cFileName);
if (!_stricmp(fd->cFileName, "sample.c"))
return FALSE;
return TRUE;
}
int main(void)
{
WalkDir("C:\\Dropbox\\Shared\\Kurslar\\SysProg-1", DispFile);
return 0;
}
void PutSysErr(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi callback fonksiyon içerisinde dosyaya ilişkin tam yol ifadesi (full path) nası ı
callback fonksiyon çağrı ı ı ı ı ı
fonksiyon içerisinde GetCurrentDirectory fonksiyonu uygulanı
WIN32_FIND_DATA içerisindeki dosya birleştirilirse tam yol ifadesi eld edilebilir.
Aşağı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include <windows.h>
#define TABSIZE 4
void PutSysErr(LPCSTR lpszMsg);
BOOL WalkDirRecur(LPCSTR lpszDirPath, int level, BOOL(*Proc)(const WIN32_FIND_DATA *, int))
{
HANDLE hFF;
WIN32_FIND_DATA fd;
BOOL bResult;
bResult = TRUE;
if (!SetCurrentDirectory(lpszDirPath)) {
PutSysErr("SetCurrentDirectory");
return TRUE;
}
if ((hFF = FindFirstFile("*.*", &fd)) == INVALID_HANDLE_VALUE) {
PutSysErr("FindFirstFile");
goto EXIT1;
}
do {
if (strcmp(fd.cFileName, ".") == 0 || strcmp(fd.cFileName, "..") == 0)
continue;
if (!Proc(&fd, level)) {
bResult = FALSE;
goto EXIT2;
}
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
if (!WalkDirRecur(fd.cFileName, level + 1, Proc)) {
bResult = FALSE;
goto EXIT2;
}
} while (FindNextFile(hFF, &fd));
if (GetLastError() != ERROR_NO_MORE_FILES)
PutSysErr("FindNextFile");
EXIT2:
FindClose(hFF);
EXIT1:
if (!SetCurrentDirectory(".."))
PutSysErr(lpszDirPath);
return bResult;
}
BOOL WalkDir(LPCTSTR lpszDirPath, BOOL(*Proc)(const WIN32_FIND_DATA *, int))
{
char cwd[MAX_PATH];
BOOL bResult;
if (!GetCurrentDirectory(MAX_PATH, cwd))
PutSysErr("GetCurrentDirectory");
bResult = WalkDirRecur(lpszDirPath, 0, Proc);
if (!SetCurrentDirectory(cwd))
PutSysErr("SetCurrentDirectory");
return bResult;
}
BOOL DispFile(const WIN32_FIND_DATA *fd, int level)
{
char buf[1024];
if (!_stricmp(fd->cFileName, "sample.c")) {
GetCurrentDirectory(MAX_PATH, buf);
strcat(buf, "\\");
strcat(buf, fd->cFileName);
printf("%s\n", buf);
}
return TRUE;
}
int main(void)
{
WalkDir("C:\\Dropbox\\Shared\\Kurslar\\SysProg-1", DispFile);
return 0;
}
void PutSysErr(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde de dizin ağacı ı ı ı
çı ı ı ı
readdir fonksiyonu ile yalnı ı ı ı ı ı
için stat fonksiyonları ı ı ı
bağlantı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/stat.h>
void walkdir(const char *path)
{
DIR *dir;
struct dirent *de;
struct stat finfo;
if (chdir(path) == -1) {
perror("chdir");
return;
}
if ((dir = opendir(".")) == NULL) {
perror("opendir");
goto EXIT;
}
while (errno = 0, (de = readdir(dir)) != NULL) {
if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
continue;
if (lstat(de->d_name, &finfo) == -1) {
perror("lstat");
continue;
}
if (S_ISDIR(finfo.st_mode)) {
printf("%s\n", de->d_name);
walkdir(de->d_name);
}
}
if (errno != 0)
perror("readdir");
closedir(dir);
EXIT:
if (chdir("..") == -1)
perror("chdir");
}
int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
walkdir(argv[1]);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
30. Ders 24/09/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/stat.h>
#define TABSIZE 4
void walkdir(const char *path, int level)
{
DIR *dir;
struct dirent *de;
struct stat finfo;
if (chdir(path) == -1) {
perror("chdir");
return;
}
if ((dir = opendir(".")) == NULL) {
perror("opendir");
goto EXIT;
}
while (errno = 0, (de = readdir(dir)) != NULL) {
if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
continue;
if (lstat(de->d_name, &finfo) == -1) {
perror("lstat");
continue;
}
if (S_ISDIR(finfo.st_mode)) {
printf("%*s%s\n", level * TABSIZE, "", de->d_name);
walkdir(de->d_name, level + 1);
}
}
if (errno != 0)
perror("readdir");
closedir(dir);
EXIT:
if (chdir("..") == -1)
perror("chdir");
}
int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
walkdir(argv[1], 0);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Fonksiyonun prosesin çalı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/stat.h>
#define TABSIZE 4
void walkdir_recur(const char *path, int level)
{
DIR *dir;
struct dirent *de;
struct stat finfo;
if (chdir(path) == -1) {
perror("chdir");
return;
}
if ((dir = opendir(".")) == NULL) {
perror("opendir");
goto EXIT;
}
while (errno = 0, (de = readdir(dir)) != NULL) {
if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
continue;
if (lstat(de->d_name, &finfo) == -1) {
perror("lstat");
continue;
}
if (S_ISDIR(finfo.st_mode)) {
printf("%*s%s\n", level * TABSIZE, "", de->d_name);
walkdir_recur(de->d_name, level + 1);
}
}
if (errno != 0)
perror("readddir");
closedir(dir);
EXIT:
if (chdir("..") == -1)
perror("chdir");
}
void walkdir(const char *path)
{
char cwd[4096];
if (getcwd(cwd, 4096) == NULL) {
perror("getcwd");
return;
}
walkdir_recur(path, 0);
if (chdir(cwd) == -1) {
perror("chdir");
return;
}
}
int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
walkdir(argv[1]);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı
yaptı ı ı
bool walkproc(const char *name, const struct stat *finfo, int level);
Yine callback fonksiyon çağrı ı ı ı ı ı ı ı
geri döndürülürse dolaşma devam ettirlir, 0 değeri ile geri döndürülürse dolaşma sonlandı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <errno.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/stat.h>
#define TABSIZE 4
bool walkdir_recur(const char *path, bool (*proc)(const char *, const struct stat *, int), int level)
{
DIR *dir;
struct dirent *de;
struct stat finfo;
bool retval;
retval = true;
if (chdir(path) == -1) {
perror("chdir");
return true;
}
if ((dir = opendir(".")) == NULL) {
perror("opendir");
goto EXIT1;
}
while (errno = 0, (de = readdir(dir)) != NULL) {
if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
continue;
if (lstat(de->d_name, &finfo) == -1) {
perror("lstat");
continue;
}
if (!proc(de->d_name, &finfo, level)) {
retval = false;
goto EXIT2;
}
if (S_ISDIR(finfo.st_mode))
if (!walkdir_recur(de->d_name, proc, level + 1)) {
retval = false;
goto EXIT2;
}
}
if (errno != 0)
perror("readddir");
EXIT2:
closedir(dir);
EXIT1:
if (chdir("..") == -1)
perror("chdir");
return retval;
}
void walkdir(const char *path, bool (*proc)(const char *, const struct stat *, int))
{
char cwd[4096];
if (getcwd(cwd, 4096) == NULL) {
perror("getcwd");
return;
}
walkdir_recur(path, proc, 0);
if (chdir(cwd) == -1) {
perror("chdir");
return;
}
}
bool disp(const char *name, const struct stat *finfo, int level)
{
printf("%*s%s\n", level * TABSIZE, "", name);
return true;
}
int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
walkdir(argv[1], disp);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <errno.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/stat.h>
#define TABSIZE 4
bool walkdir_recur(const char *path, bool (*proc)(const char *, const struct stat *, int), int level)
{
DIR *dir;
struct dirent *de;
struct stat finfo;
bool retval;
retval = true;
if (chdir(path) == -1) {
perror("chdir");
return true;
}
if ((dir = opendir(".")) == NULL) {
perror("opendir");
goto EXIT1;
}
while (errno = 0, (de = readdir(dir)) != NULL) {
if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
continue;
if (lstat(de->d_name, &finfo) == -1) {
perror("lstat");
continue;
}
if (!proc(de->d_name, &finfo, level)) {
retval = false;
goto EXIT2;
}
if (S_ISDIR(finfo.st_mode))
if (!walkdir_recur(de->d_name, proc, level + 1)) {
retval = false;
goto EXIT2;
}
}
if (errno != 0)
perror("readddir");
EXIT2:
closedir(dir);
EXIT1:
if (chdir("..") == -1)
perror("chdir");
return retval;
}
void walkdir(const char *path, bool (*proc)(const char *, const struct stat *, int))
{
char cwd[4096];
if (getcwd(cwd, 4096) == NULL) {
perror("getcwd");
return;
}
walkdir_recur(path, proc, 0);
if (chdir(cwd) == -1) {
perror("chdir");
return;
}
}
bool disp(const char *name, const struct stat *finfo, int level)
{
char buf[4096];
if (!strcmp(name, "sample.c")) {
getcwd(buf, 4096);
strcat(buf, "/");
strcat(buf, name);
printf("%s, %lld\n", buf, (long long)finfo->st_size);
}
return true;
}
int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
walkdir(argv[1], disp);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
C'de derleyiciler yapı ı ı ı ı ı ı
Bu duruma "yapı ı ı ı ı
struct SAMPLE {
short a;
int b;
short c;
int d;
};
struct SAMPLE s;
Burada short türünün 2 byte int türünün 4 byte olduğu bir sistemde ilk bakı ı
Ancak muhtemelen bu sizeof değeri yazdı ı ı ı ı ı ı
boşluklar bı ı ı
a (2)
Boşluk (2)
b (4)
c (2)
Boşluk (2)
d (4)
Derleyicinin bı ı ı ı ı ı ı ı
ne kadar boşluk bı ı ı ı ı
ps->c ifadesiyle ps adresinden başlayan yapı ı ı ı ı ı ı ı
elemanı ı ı ı ı
olacak biçimde sı ı ı ı ı ı ı ı
elemanlar arası ı ı ı ı ı ı ı ı ı
Pekiyi derleyici yapı ı ı ı ı ı ı ı
kazancı ı ı ı ı ı ı ı
bilgileri dörder byte'lı ı
Onun içinde bulunduğu 4 byte'ı ı ı ı ı ı ı
şöyledir:
xxxx
xxxx
xxxx
xxxx
....
xxxx
xxxx
xxxx
xxxx
Burada her satı ı ı ı ı
xxxx
xxxx
xxxx
xxxx
....
xxxx
xxii
iixx
xxxx
Burada erişelecek int nesne 4'ün katı ı ı ı ı ı
okuyup kendi içinde birleştirmektedir. Tabii bu erişim makine komutuna yansı ı ı
komut olarak onu yazmı ı ı ı ı ı
Pekiyi aynı ı ı ı
xxxx
xxxx
xxxx
xxxx
....
xxxx
xxxx
iiii
xxxx
Burada işlemci tek bir RAM erişimi ile int nesneyi tek hamlede elde edebilecekti. Buradan çı
4 byte'lı ı ı ı ı ı
(örneğin short türden) bir nesne için bu böyle bir hizalamaya gerek var mı ı ı ı ı ı
göre bu durum değişebilir. Örneğin:
xxxx
xxxx
xxxx
xxxx
....
xxxx
xxxx
xxss
xxxx
Burada iki byte'lı ı ı
xxxx
xxxx
xxxx
xxxx
....
xxxx
xxxx
xxxs
sxxx
Burada 2 byte'lı ı ı
önemli midir? Bunun yanı ı ı ı ı ı ı ı ı
işlemci tarafı ı
cxxx
xxxx
xcxx
xxxx
....
xxxc
xxxx
xxcx
xxxx
Burada tüm 1 byte'lı ı ı ı ı
Aslı ı ı ı ı ı
için yeterli olmaktadı ı ı ı
yerleştirilmelidir. Pekiyi 8 byte'lı ı ı ı ı ı ı ı
bu nesnelrin de 8'in katları ı ı ı ı ı ı ı ı ı
anlaşı
/*------------------------------------------------------------------------------------------------------------------------------------------
31. Ders - 30/09/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi hizalama yalnı ı ı ı ı ı ı
tüm nesneler için yapmaktadı ı ı
void foo(void)
{
char a;
int b;
...
}
Burada bu iki yerel değişkenin ardı ı ı ı ı ı
garantisi yoktur. Dolayı ı ı ı ı ı ı ı
elemanı ı ı ı ı
short a[10];
Derleyici bu diziyi 2'nin katları ı ı ı
int b[10];
Burada da derleyici b dizisini 4'ün katı ı ı ı
durum nası ı
struct SAMPLE {
char a;
int b;
char c;
int d;
};
...
struct SAMPLE *ps;
ps = malloc(sizeof(struct SAMPLE));
Burada malloc alan tahsis ederken zaten oranı ı
Örneğin burada malloc fonksiyonun 4'ün katları ı ı ı ı ı ı
bilmemektedir. Bu nedenle en kötü olası ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Derleyiciler genel olarak beş farklı
1 Byte Hizalama (Byte Alignment)
2 Byte Hizalama (Word Alignment)
4 Byte Hizalama (Double Word Alignment)
8 Byte Hizalama (Quad Word Alignemnet)
16 Byte Hizalama (Double Quad Word Alignment)
N byte hizalama şu anlama gelmektedir: "Nesnenin uzunluğu ve N değerinin hangisi küçükse nesne o değerin katları ı
tamamı ı ı ı
nesne) 1'in katları ı ı ı
katları ı ı ı
nesne 1'in katları ı ı ı ı ı ı ı
"1 byte hizalamanı ı ı ı ı ı ı ı
1 byte hizalama ayaralayabilir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Derleyicinin yaptı ı ı ı ı ı ı
istemeyebilir. Hizalamanı ı ı ı
derleyicilerinde hizalama komut satı ı ı ı ı
Hizalama Visual Studio IDE'sinde proje seçeneklerinden "C-C++/Code Generation/Struct Member Alignment" combo box seçneğinden ayarlanabilmektedir.
Eğer bu ayarlamalar yapı
Microsoft derleyicileri bir yapı ı ı ı ı ı ı ı ı
bu durumda yapı ı ı ı ı ı
gcc ve clang derleyicilerinde de default durumda Microsoft'taki gibi 32 bit derleyiciler için 8 byte hizalama, 64 bit derleyiciler için 16
byte hizalama kullanı ı ı ı ı ı ı ı
gcc -fpack-struct=1 -o sample sample.c
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Hizalama konusunda default belirlemeye neden müdahale etmek isteriz? İşte bunun en tipik örneği bir dosyanı
ya da readgibi bir fonksiyonla bir yapı ı ı ı ı ı ı
byte'a BMP başlı ı ı ı
Uzunluk İçerik
2 byte Magic Number
4 byte Dosya uzunluğu
2 byte Reserved
2 byte Reserved
4 byte Image bilgilerinin bulunduğu offset
Şimdi biz bu dosyanı ı ı ı ı ı ı ı
struct BITMAP_HEADER {
char magic[2]; /* 2 byte */
uint32_t size; /* 4 byte */
uint16_t reserved1; /* 2 byte */
uint16_t reserved2; /* 2 byte */
uint32_t dataloc; /* 4 byte */
};
İşte okudğumuz 12 byte bu elemanlarla default hizalama yüzünden çakı ı ı ı ı ı
olarak ayarlamamı ı ı
ile deneyiniz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
struct BITMAP_HEADER {
char magic[2]; /* 2 byte */
uint32_t size; /* 4 byte */
uint16_t reserved1; /* 2 byte */
uint16_t reserved2; /* 2 byte */
uint32_t dataloc; /* 4 byte */
};
#pragma pack(4)
int main(void)
{
FILE *f;
struct BITMAP_HEADER bh;
if ((f = fopen("test.bmp", "rb")) == NULL) {
fprintf(stderr, "Cannot open file!..\n");
exit(EXIT_FAILURE);
}
fread(&bh, sizeof(struct BITMAP_HEADER), 1, f);
printf("Magic: %c%c\n", bh.magic[0], bh.magic[1]);
printf("Size: %u\n", bh.size);
printf("Bitmap Data Locatiion: %u\n", bh.dataloc);
fclose(f);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi hizalama program kodunun içerisinde ayaralanabilir mi? İşte hizalamayı
derleyicilerinde #pragma pack(N) direktifi kullanı ı ı
yüksek önceliklidir. (Yani hem komut satı ı ı
alı ı
#include <stdio.h>
#pragma pack(1)
struct SAMPLE {
char a;
int b;
char c;
int d;
};
int main(void)
{
struct SAMPLE s;
printf("%zd\n", sizeof s); /* 10 */
return 0;
}
#pragma pack direktifi sonraki #pragma pack direktifine kadar etkili olmaktadı ı ı ı ı
hizalamalar kullanabilir. Örneğin:
#include <stdio.h>
#pragma pack(1)
struct SAMPLE {
char a;
int b;
char c;
int d;
};
#pragma pack(8)
struct MAMPLE {
char a;
int b;
char c;
int d;
};
int main(void)
{
struct SAMPLE s;
struct MAMPLE m;
printf("%zd\n", sizeof s); /* 10 */
printf("%zd\n", sizeof m); /* 16*/
return 0;
}
C11 ile birlikte bir nesnenin (bir yapı ı ı ı
Örneğin:
#include <stdio.h>
struct SAMPLE {
int a;
_Alignas(8) int b;
};
int main(void)
{
struct SAMPLE s;
printf("%zd\n", sizeof s); /* 16 */
return 0;
}
Burada yapı ı ı ı ı ı
8'in katları ı ı
bir hizalamaya çevrielemez. Örneğin:
struct SAMPLE {
int a;
_Alignas(1) int b; /* geçersiz! */
};
_Alignas ile belli nesnelerin ya da belli yapı ı ı
Ayrı ı ı ı
bize vermektedir. Örneğin:
#include <stdio.h>
int main(void)
{
printf("%zd\n", _Alignof(int)); /* 4 */
return 0;
}
_Alignas belirleyicisi bir tür ismiyle de kullanı
_Alignas(int) char c;
_Alignas(tür_ismi) aslı ı
o sayı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Anı ı ı ı ı ı ı ı ı ı ı ı
nesnesi birbirine atandı ı ı ı ı ı ı
struct SAMPLE {
char a;
int b;
};
...
struct SAMPLE x = {'a', 3}, y;
x = y;
Burada C standartları ı ı ı ı ı ı ı ı ı
bir garanti vermemektedir. Programcı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Sistem programalama karşı ı ı ı ı ı
temel bilgileri edinmiş olması ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir bilgiye erişilmek istenen durumlarda çoğu kez karşı ı ı ı ı ı
bol ve ucuzdur. Hı ı ı ı ı ı ı ı ı ı
Ayrı ı ı ı ı ı
belleklerde saklanı ı ı ı ı ı ı
Bir cache sisteminde yavaş belleğin belli bölümleri hı
hı ı ı ı ı ı ı ı
içerisindeki bilgi o anda hı ı
yavaş belleğin belli bölümlerini tutan hı ı ı ı ı
(Cache sözcüğünün genellikle Türkçe karşı ı ı
sözcüğünü kullanacağı
Cache sisteminde bilgiye erişilmek istendiğinde eğer bilgi cache bellekte bulunuyorsa bu duruma İngilizce "cache hit (ön belleğin isabet
ettirilmesi") denilmektedir. Eğer bilgi cache bellekte yoksa bu duruma da İngilizce "cache miss (cache belleğin ı ı
İyi bir cache sisteminde "cache hit" oranı ı ı ı ı ı ı ı
denilmektedir. Bunu şöyle gösterebiliriz:
Cache hit oranı ı ı
Pekiyi bir cache sisteminde cache hit oranı ı ı ı ı
bir etkisi olacaktı ı ı
hangi sürelerde hı ı ı ı
Bazen "cache" sözcüğü ile "buffer (tampon)" sözcükleri biribirine karı ı ı ı ı ı ı ı
Halbuki buffer mekanizması ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir cache sistemi donanı ı ı ı
devreleriyle yapı ı ı ı ı ı ı ı ı ı
tamamen programalama yoluyla oluşturulmuş cache sistemleridir.
Sistem programlama faaliyetlerinde cache sistemleri değişik biçimlerde karşı ı ı
- Bugün bilgisayar sistemlerinde genellikle ana bellek olarak DRAM (Dynamic RAM) denilen bellekler kullanı ı
belleğin bir biti tipik olarak bir kapasitif elemanla bir transistörden oluşturulmaktadı ı ı ı ı
olması ı ı ı ı ı ı ı ı ı ı ı ı
oraları ı ı ı ı ı ı
sonları ı ı ı
kadar bekliyordu (buna CPU terminolojisinde "wait state" denilmektedir) İşte 80'li yı ı ı
DRAM beklemeleri azaltmak için donanı ı ı ı
ile üretilen hı ı ı ı
Bu tasarı ı ı ı ı ı
olmaktadı ı ı ı ı
CPU'lar daha da hı ı ı ı ı
cache sistemleri uygulandı ı ı ı
dı ı ı ı
sistemlerinde genellikle 3 kademe cache kullanı ı ı ı ı ı ı
Çok çekirdekli sistemlerde her çekirdeğin ayrı ı
- Çok karşı ı ı
ya da "page cache" denilen cache sistemleridir. İşletim sistemleri yazı ı ı ı
tutmaktadı ı ı ı
yapı ı ı ı
Çünkü bilgisayar sistemlerinin en yavaş bileşenlerinden biri disk sistemidir. Bu cache sisteminde yavaş bellek diski hı ı
belleği temsil etmektedir.
- İşletim sistemlerinin çekirdekleri disk cache (buffer cache) sisteminin yanı ı ı ı
"i-node cache" ve son işleme sokulan dizin girişlerinin saklandı ı
kullanmaktadı ı ı ı ı
- Web tarayı ı ı ı ı ı ı ı
cache sisteminde bulunuyor olabilir. Bu durumda doğrudan sayfa kullanı ı ı ı ı ı ı ı ı
sunucuyu, hı ı ı
- Dağı ı ı ı ı ı
yakı ı ı
- Standart C kütüphaenesindeki dosya fonksiyonları ı ı ı ı
- Manyetik temelli Hard Disklerde de bir cache sistemi bulundurulmaktadı ı ı
o blok HDD'nin kendi cache'i içerisinde varsa doğrudan oradan alı ı ı
mekanik bir biçimde diskten elde edilmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Cache bellek genel olarak bloklardan (yani ardı ı ı ı ı
Eğer cache sisteminde cache bellek yalnı ı ı ı ı ı
"read only cache sistemleri" denilmektedir. Eğer yazma işlemi de cache belleğe yapı
sistemleri" ya da "write throuh cache sistemleri" denilmektedir. Şüphesiz read-write cache sistemleri daha yüksek bir performans sunmaktadı
Ancak bu sistemlerde birtakı ı ı ı
olası ı ı ı ı ı
bakı ı ı ı ı ı ı ı
cache terminolojisinde bir cache bloğunun içeriğinin güncellenmiş olması ı
Bir cache bloğunun yavaş belleğe içeriği değiştiğinden dolayı ı ı ı
ne zaman flush edilmelidir? Bir cache bloğu cache'ten atı ı
edilmesine gerek yoktur. Ancak kirlenmiş cache blokları ı ı ı ı
yol açabilmektedir. Örneğin işletim sistemlerinin disk cache (buffer cache) sistemleri read-write cache sistemleridir. Ancak kirlenmiş cache
blokları ı ı
"delayed write" denilmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
32. Ders - 01/10/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı
cache'teki her bir bloğun bir numarası ı ı
toplam 100 tane cache bloğu vardı ı ı
Cache
0. Blok (1K)
1. Blok (1K)
2. Blok (1K)
...
97. Blok (1K)
98. Blok (1K)
99. Blok (1K)
Yavaş belleğin de 1MB olduğunu varsayalı ı ı ı
Yavaş Bellek
0. Blok (1K)
1. Blok (1K)
2. Blok (1K)
...
997. Blok (1K)
998. Blok (1K)
999. Blok (1K)
Bu örnekte toplam 1000 bloktan oluşan yavaş belleğin ardı ı ı ı ı
oluşturulacaksa bizim cache bloklerı ı
Bu sistemde örneğin biz yavaş belleğin 718'inci bloğuna erişmek isteyelim. Sistemin önce bu 718'inci bloğun cache içerisinde olup olmadı ı
bakması ı ı
54'üncü bloğundan sağlanacaktı
elde edilecektir. Mademki her blok işleminde önce o blok cache'te mi diye bakı ı ı ı ı ı
Bu tür sistemlerde sı ı ı
denilen veri yapı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı
Cache sistemlerindeki en önemli algoritmik sorun şudur: Biz yavaş belleğin hangi blokları ı ı ı ı
örnekte 1000 blokluk yavaş belleğin hangi 100 bloğunu cache bellekte tutmalı ı ı ı ı ı
yavaş belleğin nerelerinin çok kullanı ı ı ı ı ı
tutardı ı ı
dinamik bir biçimde kullanı ı ı ı
alı ı ı ı ı
denilmektedir. Biz buna "cache algoritmaları
Literatürde değişik durumlar için düşünülmüş çeşitli cache algoritmaları ı ı ı ı ı
1) En Az Kullanı ı ı ı ı ı ı
Cache'teki her blok için bir sayaç tutulur. Her "cache hit" oluştuğunda o bloğun sayacı ı ı
oluştuğunda o zamana kadar en az kullanı ı ı ı ı ı
o zamana kadar fazla kullanı ı ı ı
az kullanı ı ı ı
0'da tutulursa ilk cache miss olduğunda bu blok yeniden cache'ten atı ı ı ı ı ı ı ı
uygun değildir.
2) Son Zamanlarda En Az Kullanı ı ı ı ı ı
Örneğin Linux çekirdeğindeki çeşitli cache sistemlerinde hep bu algortima kullanı ı ı ı ı
zaman onları ı ı ı ı ı ı ı ı ı ı
tipik çalı ı ı ı ı ı ı
Örneğin işletim sisteminin disk cache sistemini düşünelim. Bir program çalı ı ı ı ı ı
Ancak programı ı ı ı ı ı ı ı
gerçekleştirilmektedir. Cache hit olan bloklar bağlı ı ı
kalı ı ı ı ı ı ı ı
3) En Fazla Kullanı ı ı ı ı ı ı
o zamana kadar en fazla kullanı ı ı
yaklaşı ı ı ı ı ı ı
potansiyilene sahiptir. Tabii bu algoritma çok seyrek kullanı ı
4) Rastgele Blokları ı ı ı ı ı
blokları ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı
100 bloktan oluşaşn (toplam 3200 byte) bir dosya kullanı ı ı ı ı
oluşturulan cache sistemindeki fonksiyonlar şunlardı
HCACHE open_disk(const char *path, int flags);
int read_disk(HCACHE hc, int blockno, void *buf);
int close_disk(HCACHE hc);
open_disk fonksiyonu "test.dat" dosyası ı ı ı
bir blok okumaktadı ı ı ı ı
typedef struct tagCACHELINE {
char buf[LINE_SIZE];
int blockno;
size_t count;
} CACHE_LINE;
typedef struct tagCACHE {
int fd;
CACHE_LINE clines[NCACHE_LINES];
size_t tcount;
} CACHE, *HCACHE;
Burada cache sistemi CACHE isimli bir yapı ı
Tüm cache blokları ı ı ı ı
tutulmaktadı
Buradaki simülasyon kodundaki algoritmik kusurlar şunlardı
1) Okunmak istenen bloğun tek tek cache blokları ı ı ı ı
Dolayı ı ı ı ı ı ı ı ı ı ı
arama iyi bir yöntemdir. Yukarı ı ı ı
2) En düşük sayaca sahip olan cache bloğu da sı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* diskcache.h */
#ifndef DISKCACHE_H_
#define DISKCACHE_H_
/* Symbolic Constants */
#define LINE_SIZE 32
#define NCACHE_LINES 10
#define INITIAL_COUNT 2
#ifdef DEBUG
#define DEBUG_PRINT(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__)
#else
#define DEBUG_PRINT(fmt, ...)
#endif
/* Type Definitions */
typedef struct tagCACHELINE {
char buf[LINE_SIZE];
int blockno;
size_t count;
} CACHE_LINE;
typedef struct tagCACHE {
int fd;
CACHE_LINE clines[NCACHE_LINES];
size_t tcount;
} CACHE, *HCACHE;
/* Function Prototypes */
HCACHE open_disk(const char *path, int flags);
int read_disk(HCACHE hc, int blockno, void *buf);
void close_disk(HCACHE hc);
#endif
/* diskcache.c */
#define DEBUG
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include "diskcache.h"
#ifdef DEBUG
static void print_cline_counts(HCACHE hc);
#endif
static size_t select_line(HCACHE hc);
HCACHE open_disk(const char *path, int flags)
{
HCACHE hc;
int i;
if ((hc = (HCACHE)malloc(sizeof(CACHE))) == NULL)
return NULL;
if ((hc->fd = open(path, flags)) == -1) {
free(hc);
return NULL;
}
for (i = 0; i < NCACHE_LINES; ++i) {
hc->clines[i].blockno = -1;
hc->clines[i].count = 0;
}
hc->tcount = 0;
return hc;
}
int read_disk(HCACHE hc, int blockno, void *buf)
{
int i;
int rline;
for (i = 0; i < NCACHE_LINES; ++i)
if (hc->clines[i].blockno == blockno) {
DEBUG_PRINT("Cache hit block %d, used cache line %d\n", blockno, i);
memcpy(buf, hc->clines[i].buf, LINE_SIZE);
++hc->clines[i].count;
++hc->tcount;
#ifdef DEBUG
print_cline_counts(hc);
#endif
return 0;
}
rline = select_line(hc);
if (lseek(hc->fd, (off_t)blockno * LINE_SIZE, SEEK_SET) == -1)
return -1;
if (read(hc->fd, hc->clines[rline].buf, LINE_SIZE) == -1)
return -1;
hc->clines[rline].blockno = blockno;
hc->clines[rline].count = hc->tcount / NCACHE_LINES + 1;
hc->tcount += hc->clines[rline].count;
memcpy(buf, hc->clines[rline].buf, LINE_SIZE);
DEBUG_PRINT("Cache miss block %d, used cache line %d\n", blockno, rline);
#ifdef DEBUG
print_cline_counts(hc);
#endif
return 0;
}
void close_disk(HCACHE hc)
{
close(hc->fd);
DEBUG_PRINT("Cache closed!\n");
free(hc);
}
static size_t select_line(HCACHE hc)
{
size_t min_count;
size_t min_index;
int i;
min_count = hc->clines[0].count;
min_index = 0;
for (i = 1; i < NCACHE_LINES; ++i) {
if (hc->clines[i].count < min_count) {
min_count = hc->clines[i].count;
min_index = i;
}
}
return min_index;
}
#ifdef DEBUG
static void print_cline_counts(HCACHE hc)
{
int i;
putchar('\n');
printf("Total count: %llu\n", (unsigned long long)hc->tcount);
for (i = 0; i < NCACHE_LINES; ++i)
printf("Cachle Line %d --> Block: %d, Count: %llu\n", i, hc->clines[i].blockno, (unsigned long long)hc->clines[i].count);
putchar('\n');
}
#endif
/* diskcache-test.c */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <fcntl.h>
#include "diskcache.h"
int create_test_file(const char *path, int nblocks);
int main(void)
{
HCACHE hc;
char buf[32 + 1];
int blockno;
if (create_test_file("test.dat", 100) == -1) {
perror("create_test_file");
exit(EXIT_FAILURE);
}
if ((hc = open_disk("test.dat", O_RDONLY)) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
for (;;) {
printf("Block No:");
scanf("%d", &blockno);
putchar('\n');
if (blockno == -1)
break;
if (read_disk(hc, blockno, buf) == -1) {
perror("read_file");
exit(EXIT_FAILURE);
}
buf[32] = '\0';
printf("Block content: %s\n\n", buf);
}
close_disk(hc);
return 0;
}
int create_test_file(const char *path, int nblocks)
{
FILE *f;
int i, k;
char buf[LINE_SIZE];
srand(time(NULL));
if ((f = fopen(path, "wb")) == NULL)
return -1;
for (i = 0; i < nblocks; ++i) {
sprintf(buf, "%04d ", i);
for (k = 5; k < 32; ++k)
buf[k] = rand() % 26 + 'A';
if (fwrite(buf, LINE_SIZE, 1, f) != 1)
return -1;
}
fclose(f);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Read-write cache sistemlerinde cache belleğin yazma sı ı ı ı ı ı ı
o blok cache'te varsa doğrudan cache bloğu üzerine yazma yapı ı ı ı
için yavaş belleğe geri yazı ı ı ı ı ı ı ı
1) Blok doğrudan yavaş belleğe yazı
2) Blok önce cache'e çekilip yazma cache'e yapı ı
Doğurdan yazma cache üzerine yapı
Bazen yazma sı ı ı
yavaş bellekte bir kayı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* filecache.h */
#ifndef FILECACHE_H_
#define FILECACHE_H_
/* Symbolic Constants */
#define LINE_SIZE 32
#define NCACHE_LINES 10
#define INITIAL_COUNT 2
#ifdef DEBUG
#define DEBUG_PRINT(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__)
#else
#define DEBUG_PRINT(fmt, ...)
#endif
/* Type Definitions */
typedef struct tagCACHELINE {
char buf[LINE_SIZE];
int blockno;
size_t count;
int dirty;
} CACHE_LINE;
typedef struct tagCACHE {
int fd;
CACHE_LINE clines[NCACHE_LINES];
size_t tcount;
} CACHE, *HCACHE;
/* Function Prototypes */
HCACHE open_disk(const char *path, int flags);
int read_disk(HCACHE hc, int blockno, void *buf);
int write_disk(HCACHE hc, int blockno, const void *buf);
int fluch_disk(HCACHE hc);
int close_disk(HCACHE hc);
#endif
/* filecahe.c */
#define DEBUG
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include "diskcache.h"
#ifdef DEBUG
static void print_cline_counts(HCACHE hc);
#endif
static size_t select_line(HCACHE hc);
HCACHE open_disk(const char *path, int flags)
{
HCACHE hc;
int i;
if ((hc = (HCACHE)malloc(sizeof(CACHE))) == NULL)
return NULL;
if ((hc->fd = open(path, flags)) == -1) {
free(hc);
return NULL;
}
for (i = 0; i < NCACHE_LINES; ++i) {
hc->clines[i].blockno = -1;
hc->clines[i].count = 0;
hc->clines[i].dirty = 0;
}
hc->tcount = 0;
return hc;
}
int read_disk(HCACHE hc, int blockno, void *buf)
{
int i;
int rline;
for (i = 0; i < NCACHE_LINES; ++i)
if (hc->clines[i].blockno == blockno) {
DEBUG_PRINT("Cache hit block %d, used cache line %d\n", blockno, i);
memcpy(buf, hc->clines[i].buf, LINE_SIZE);
++hc->clines[i].count;
++hc->tcount;
#ifdef DEBUG
print_cline_counts(hc);
#endif
return 0;
}
rline = select_line(hc);
if (hc->clines[rline].dirty) {
if (lseek(hc->fd, hc->clines[rline].blockno * LINE_SIZE, SEEK_SET) == -1)
return -1;
if (write(hc->fd, hc->clines[rline].buf, LINE_SIZE) == -1)
return -1;
hc->clines[rline].dirty = 0;
}
if (lseek(hc->fd, (off_t)blockno * LINE_SIZE, SEEK_SET) == -1)
return -1;
if (read(hc->fd, hc->clines[rline].buf, LINE_SIZE) == -1)
return -1;
hc->clines[rline].blockno = blockno;
hc->clines[rline].count = hc->tcount / NCACHE_LINES + 1;
hc->tcount += hc->clines[rline].count;
memcpy(buf, hc->clines[rline].buf, LINE_SIZE);
DEBUG_PRINT("Cache miss block %d, used cache line %d\n", blockno, rline);
#ifdef DEBUG
print_cline_counts(hc);
#endif
return 0;
}
int write_disk(HCACHE hc, int blockno, const void *buf)
{
int rline;
for (int i = 0; i < NCACHE_LINES; ++i)
if (hc->clines[i].blockno == blockno) {
DEBUG_PRINT("Cache hit block %d, used cache line %d\n", blockno, i);
memcpy(hc->clines[i].buf, buf, LINE_SIZE);
++hc->clines[i].count;
++hc->tcount;
hc->clines[i].dirty = 1;
#ifdef DEBUG
print_cline_counts(hc);
#endif
return 0;
}
rline = select_line(hc);
if (hc->clines[rline].dirty) {
if (lseek(hc->fd, hc->clines[rline].blockno * LINE_SIZE, SEEK_SET) == -1)
return -1;
if (write(hc->fd, hc->clines[rline].buf, LINE_SIZE) == -1)
return -1;
}
memcpy(hc->clines[rline].buf, buf, LINE_SIZE);
hc->clines[rline].blockno = blockno;
hc->clines[rline].count = hc->tcount / NCACHE_LINES + 1;
hc->clines[rline].dirty = 1;
DEBUG_PRINT("Cache miss block %d, used cache line %d\n", blockno, rline);
#ifdef DEBUG
print_cline_counts(hc);
#endif
return 0;
}
int flush_disk(HCACHE hc)
{
for (int i = 0; i < NCACHE_LINES; ++i) {
if (hc->clines[i].dirty) {
if (lseek(hc->fd, hc->clines[i].blockno * LINE_SIZE, SEEK_SET) == -1)
return -1;
if (write(hc->fd, hc->clines[i].buf, LINE_SIZE) == -1)
return -1;
}
}
return 0;
}
int close_disk(HCACHE hc)
{
if (flush_disk(hc) == -1)
return -1;
close(hc->fd);
DEBUG_PRINT("Cache closed!\n");
free(hc);
return 0;
}
static size_t select_line(HCACHE hc)
{
size_t min_count;
size_t min_index;
int i;
min_count = hc->clines[0].count;
min_index = 0;
for (i = 1; i < NCACHE_LINES; ++i) {
if (hc->clines[i].count < min_count) {
min_count = hc->clines[i].count;
min_index = i;
}
}
return min_index;
}
#ifdef DEBUG
static void print_cline_counts(HCACHE hc)
{
int i;
putchar('\n');
printf("Total count: %llu\n", (unsigned long long)hc->tcount);
for (i = 0; i < NCACHE_LINES; ++i)
printf("Cachle Line %d --> Block: %d, Count: %llu, Dirty: %d\n", i, hc->clines[i].blockno, (unsigned long long)hc->clines[i].count, hc->clines[i].dirty);
putchar('\n');
}
#endif
/* filecache-test.c */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <fcntl.h>
#include "diskcache.h"
int create_test_file(const char *path, int nblocks);
int main(void)
{
HCACHE hc;
char buf[32 + 1];
int rw;
int blockno;
if (create_test_file("test.dat", 100) == -1) {
perror("create_test_file");
exit(EXIT_FAILURE);
}
if ((hc = open_disk("test.dat", O_RDWR)) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
for (;;) {
printf("Block No:");
scanf("%d", &blockno);
if (blockno == -1)
break;
printf("(r)ead/(w)rite?");
while (getchar() != '\n')
;
rw = getchar();
if (rw == 'r') {
if (read_disk(hc, blockno, buf) == -1) {
perror("read_file");
exit(EXIT_FAILURE);
}
}
else if (rw == 'w') {
for (int k = 5; k < 32; ++k)
buf[k] = rand() % 26 + 'A';
if (write_disk(hc, blockno, buf) == -1) {
perror("read_file");
exit(EXIT_FAILURE);
}
}
else {
printf("invalid operation!...\n");
continue;
}
buf[32] = '\0';
printf("Block content: %s\n\n", buf);
}
close_disk(hc);
return 0;
}
int create_test_file(const char *path, int nblocks)
{
FILE *f;
int i, k;
char buf[LINE_SIZE];
srand(time(NULL));
if ((f = fopen(path, "wb")) == NULL)
return -1;
for (i = 0; i < nblocks; ++i) {
sprintf(buf, "%04d ", i);
for (k = 5; k < 32; ++k)
buf[k] = rand() % 26 + 'A';
if (fwrite(buf, LINE_SIZE, 1, f) != 1)
return -1;
}
fclose(f);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
33. Ders 07/10/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bugün kullandı ı ı ı
ARM işlemcileri, Intel işlemcileri, Power PC işlemcileri, Alpha işlemcileri, Itanium işlemcileri koruma mekanizmaları
mikrodenetleyiciler ve küçük kapasiteli işlemcilerde bu mekanizma bulunmamaktadı ı
80386 modelleriyle birlikte sayfa tabanlı ı ı
koruma mekanizması ı ı
Bugün Windows, Linux, macOS gibi işletim sistemleri ancak koruma mekanizması ı
Koruma mekanizması ı ı
1) Bellek Koruması
2) Komut Koruması
Çok prosesli işletim sistemlerinde farklı ı ı ı ı ı ı ı ı
programları ı
prgramı ı ı ı ı ı ı ı
erişmesi de tehlikeldir. Bu sayede kötü amaçlı ı ı ı ı
RAM'deki herhangi bir adresi yerleştirip RAM'in o bölgesine erişebiliriz. Pekiyi bir programı ı ı ı ı
engellenebilir? Bu engelleme yalnı ı ı ı ı ı
Bir program kendi bellek alanı ı ı ı ı
sistemine bildirir. İşletim sistemi de programı ı ı ı
Bazı ı ı ı ı ı
komutları ı ı ı ı
İşlemci durumu işletim sistemine bildirir. İşletim sistemi de programı ı ı ı
Yukarı ı ı ı ı ı ı ı ı ı ı ı
tarafı ı ı ı ı ı ı ı ı
alı ı
İşletim sistemleri bellekte her yere erişebilmeli her makine komutunu kullanabilmeldir. Aksi takdirde faaliyetlerini yürütemezler. O halde
koruma mekanizması ı ı ı ı ı ı
genellikle çalı ı ı ı ı ı
mekanizması ı
user modda çalı ı ı ı ı ı
Word, Visual Studio, Internet Explorer vs hep user modda çalı ı
(örneğin bash), dı ı ı
sistemlerde biz bir programı ı ı ı ı ı ı ı
İşletim sisteminin kodları ı ı ı ı ı ı ı ı
modda çalı ı ı ı ı ı ı ı
"ring" de denilmektedir. Bu çalı ı ı ı ı ı ı ı
mod 3'tür. Windows, Linux ve macOS sistemleri Intel işlemcilerinin iki modunu kullanmaktadı
4 çalı ı ı
Pekiyi user mod bir program işletim sisteminin istem fonksiyonunu çağı ı ı ı
her yere erişebilmekte ve özel makine komutları ı ı ı
çalı ı ı ı ı ı ı ı ı ı ı
otomatik olarak user mod'tan kernel mod'a geçirilmektedir. Böylece sistem fonksiyonları ı ı ı ı
çı ı ı
denilmektedir. Tabii kernel moda geçişin ve geri dönüşün bir zaman maliyeti vardı ı ı ı ı
diğer fonksiyonları ı ı
Biz kendi programı ı ı ı ı ı ı ı ı
"aygı ı ı ı ı ı
sürücüler sistemin yöneticileri tarafı ı ı ı ı ı
edilmesi sı ı ı ı ı
İşlemcileri tasarlayanlar genellikle koruma mekanizaması ı ı ı ı ı
koruma mekanizması ı ı ı
hale getirilmektedir. Koruma mekanizması ı ı
koruma mekanizması ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir dosyanı ı ı ı ı ı ı
çalı
while ((result = read(fd, &ch, 1)) > 0) {
/* ... */
}
Çünkü her byte için read fonksiyonun çağrı ı ı ı
geçişleri nedneiyle zaman kaybı ı ı ı
Örneğin:
while ((result = read(fd, buf, 8192)) > 0)
for (ssize_t i = 0; i < result; ++i) {
/* ... */
}
Burada sistem fonksiyonu çok daha az çağrı ı ı ı
Aşağı ı ı ı ı ı
Bu dosya aşağı ı
dd if=/dev/zero of=test.dat bs=512 count=10000
Aşağı ı ı ı ı ı ı ı ı ı
test1 programı ı ı ı ı ı ı ı
kat bir hı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* test1.c */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <fcntl.h>
#include <unistd.h>
void exit_sys(const char *msg);
void proc(int ch)
{
/* EMPTY */
}
int main(int argc, char *argv[])
{
int fd;
char ch;
ssize_t result;
clock_t start, stop;
double telapsed;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
start = clock();
if ((fd = open(argv[1], O_RDONLY)) == -1)
exit_sys("open");
while ((result = read(fd, &ch, 1)) > 0)
proc(ch);
if (result == -1)
exit_sys("read");
close(fd);
stop = clock();
telapsed = (double) (stop - start) / CLOCKS_PER_SEC;
printf("%.3f\n", telapsed);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/* test2.c */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <fcntl.h>
#include <unistd.h>
void exit_sys(const char *msg);
void proc(int ch)
{
/* empty */
}
int main(int argc, char *argv[])
{
int fd;
ssize_t result;
clock_t start, stop;
double telapsed;
char buf[8192];
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
start = clock();
if ((fd = open(argv[1], O_RDONLY)) == -1)
exit_sys("open");
while ((result = read(fd, buf, 8192)) > 0)
for (ssize_t i = 0; i < result; ++i)
proc(buf[i]);
if (result == -1)
exit_sys("read");
close(fd);
stop = clock();
telapsed = (double) (stop - start) / CLOCKS_PER_SEC;
printf("%.3f\n", telapsed);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
C'nin prototipleri <stdio.h> içerisinde bulunan dosya fonksiyonları ı ı ı ı ı ı ı
örnekte yaptı ı ı ı ı ı
yerine "buffer" denilmektedir. Bu nedenle SC'nin standart dosya fonksiyonları ı
denilmektedir. Biz örneğin fgetc fonksiyonu ile dosyadan bir byte bile okumak istesek aslı ı
ile okuyup bize okunan tampondan byte'ı ı ı ı
bu tampondan alı ı ı
Şimdi yukarı ı ı ı
while ((ch = fgetc()) != EOF) {
/* ... */
}
Burada programı ı ı ı ı ı ı ı ı
Her defası ı ı
read fonksiyonu ile blok blok okuma yapı ı
C'nin tamponlu fgetc fonksiyonu il byte byte okuma yapı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* test3.c */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void proc(int ch)
{
/* EMPTY */
}
int main(int argc, char *argv[])
{
FILE *f;
int ch;
double telapsed;
clock_t start, stop;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
start = clock();
if ((f = fopen(argv[1], "rb")) == NULL) {
fprintf(stderr, "cannot open file!...\n");
exit(EXIT_FAILURE);
}
while ((ch = fgetc(f)) != EOF)
proc(ch);
if (ferror(f)) {
fprintf(stderr, "IO error!..\n");
exit(EXIT_FAILURE);
}
fclose(f);
stop = clock();
telapsed = (double) (stop - start) / CLOCKS_PER_SEC;
printf("%.3f\n", telapsed);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bu noktada terminolojiye ilişkin bir noktayı ı ı ı ı ı ı
göstericiye İngilizce "stream" denilmektedir. Biz buna Derneğimizde "dosya bilgi göstericisi" diyoruz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
C'nin dosya fonksiyonları ı ı ı ı
gcc derleyicilerinde (yani glibc kütüphanesinde) BUFIZ değeri 8192, Microsoft derleyicilerinde 512 biçimindedir. Tabii biz BUFSIZ değerini
değiştirmekle bu tamponun büyüklüğünü değiştirmiş olmayı ı ı
tampon büyüklüğünü öğrenebilmemiz için <stdio.h> içerisinde bulundurulmuştur.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir dosyayı ı ı ı
kullanı ı ı ı ı ı ı ı
Her defası ı ı
read fonksiyonu ile blok blok okuma yapı ı
C'nin tamponlu fgetc fonksiyonu il byte byte okuma yapı ı
Neden fgetc fonksiyonun kullanı ı ı ı ı ı ı ı ı ı ı
8192 byte uzunluğundadı ı ı ı ı ı ı
düzeyde bir zmana kaybı ı ı ı ı
C kütüphanesinde fgetc fonksiyonunun yanı ı ı
fonksiyonunun bir makro olarak yazı ı ı ı ı ı
göreli zaman kaybı ı ı ı ı ı
Yukarı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
C'nin <stdio.h> fonksiyonları ı ı ı ı ı ı ı
cache siştemi gibidir. Dolayı ı ı ı ı ı ı ı ı
ne zaman dosyaya aktarı ı ı ı ı
- Tampona dosyanı ı ı ı ı
ile de ilgilidir.
- Dosya fclose fonksiyonu ile kapatı ı ı ı ı ı
- exit standart C fonksiyonu zaten tüm dosyaları ı ı ı ı ı ı ı ı ı
tampona yazı ı ı ı
- fflsuh fonksiyonu her çağrı ı ı ı ı ı
Aşağı ı ı ı ı ı ı ı ı ı ı ı
Bu durumda tampona yazı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
if ((f = fopen("test.txt", "w")) == NULL) {
fprintf(stderr, "Cannot open file!..\n");
exit(EXIT_FAILURE);
}
fputc('a', f);
fputc('b', f);
getchar();
fclose(f);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
C'nin dosya fonksiyonları ı
çağrı ı ı ı ı ı ı ı ı ı ı ı
ch = fgetc(f);
fputc('x', f);
Burada fgetc ile 1 byte okunduğunda dosya göstericisi 1 byte ilerletilmektedir. Böylece fputc fonksiyonu sonraki offset'e yazı
Ancak işlem hatalı ı ı
ch = fgetc(f);
fseek(f, 0, SEEK_CUR);
fputc('x', f);
Burada aslı
hazı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
C'de her fopen fonksiyonu ile dosya açı ı ı ı ı ı
bir tane değildir, dosya başı ı ı ı ı ı
donksiyonunun geri döndürdüğü FILE türünden yapı ı ı ı
ile açabiliriz. Bu durumda bu açı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
C'nin standart dosya fonksiyonları ı ı
modu da denilmektedir. Bu modlar şunlardı
1) Tam Tamponlamalı
2) Satı ı
3) Sı ı ı
Tam tamponlamalı ı ı ı ı ı ı
bilgiler mümkün olduğunca tampondan verilir. Tamponun dı ı ı ı ı ı ı ı
kirlenmişse flush edilir. Bu en doğal çalı
Satı ı ı ı ı ı ı ı ı
Satı ı ı ı
yeni satı ı ı ı ı
Halbuki tam tamponlamada flush oluşturan özel bir byte yoktur.
Sı ı ı ı ı ı
sistem fonksiyonları ı ı
gerçekleştirirler.
Biz yukarı ı ı ı ı ı ı ı
olmayan biçimde yani bir "niyet biçiminde" belirtmiştir. Detayları ı ı ı ı ı
tamponlama seçilse bile işlemler tam tamponlamalı ı ı ı ı ı
açı ı ı ı ı ı ı ı
Bu nedenle örneğin Microsoft derleyicileri, gcc ve clang derleyicileri (glibc kütüpahnesi) normal disk dosyaları ı ı
'\n' karakteri tampona yazı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi bir dosyayı ı ı ı ı ı
Fakat en normal durum disk dosyaları ı ı ı
tam tamponlamalı ı ı ı
şeyler söylenmiştir. Bunu izleyen graflarda ele alacağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Dosyanı ı
fonksiyonunu işlevsel olarak kapsamaktadı ı ı
setvbuf fonksiyonları ı ı ı ı ı ı ı ı
davranı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
setbuf fonksiyonu temel olarak dosya için ayrı ı ı
Tampon her zaman BUFSIZ uzunluğundadı ı
void setbuf(FILE *stream, char *buf);
Fonksiyonun birinci parametresi tamponu değiştirilecek dosyaya ilişkin dosya bilgi göstericisini belirtmektedir. İkinci parametre yeni
tamponun yerini belirtmektedir. Bu parametreye en azı ı
ikinci parametresine NULL adres geçirilirse dosya sı ı ı ı
Aşağı ı ı
değiştirilmiş sonra dosyadan okuma yapı ı ı ı
Okumadan yazmaya geçerken bir fseek çağı ı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
void disp_hex(const void *buf, size_t size, size_t lbytes)
{
size_t i, k, remainder;
unsigned char *cbuf = (unsigned char *)buf;
for (i = 0; i < size; ++i) {
if (i % lbytes == 0)
printf("%08x ", (unsigned int)i);
printf("%02X ", cbuf[i]);
if (i % lbytes == lbytes - 1) {
for (k = 0; k < lbytes; ++k)
printf("%c", iscntrl(cbuf[i - lbytes + k]) ? '.' : cbuf[i - lbytes + k]);
putchar('\n');
}
}
remainder = size % lbytes;
for (k = 0; k < 3 * (lbytes - remainder); ++k)
putchar(' ');
for (k = 0; k < remainder; ++k)
printf("%c", iscntrl(cbuf[i - remainder + k]) ? '.' : cbuf[i - remainder + k]);
putchar('\n');
}
int main(void)
{
FILE *f;
char buf[BUFSIZ];
if ((f = fopen("test.txt", "r+")) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
setbuf(f, buf);
fgetc(f);
disp_hex(buf, BUFSIZ, 16);
printf("---------------------------------------------\n\n");
fseek(f, 0, SEEK_CUR);
fputc('x', f);
disp_hex(buf, BUFSIZ, 16);
fclose(f);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı
tamponlama modunu hem de tamponun yerini ve büyüklüğünü değiştirebiliriz. Fonksiyonun prototipi şöyledir:
int setvbuf(FILE *stream, char *buf, int mode, size_t size);
Fonksiyonun birinci parametresi ilgili dosyaya ilişkin dosya bilgi göstericisini, ikinci parametresi yeni tamponun yerini, üçüncü parametresi
yeni tamponlama modunu ve dördüncü parametresi de tamponun yeni uzunluğunu belirtmektedir. Tamponlama modu için şu değerlerden biri
girilmelidir:
_IOFBF (Tam tamponlama)
_IOLBF (Sator tamponlaması
_IONBF (Sı ı
Tamponlama modunu belirten üçünü parametreye _IONBF değeri girilirse artı ı ı ı
Fonksiyonun ikinci parametresine NULL adres geçilebilir. Bu durumda tampon fonksiyon tarafı
edilmektedir. Fonksiyon başarı ı ı ı ı ı ı ı
Aşağı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
void disp_hex(const void *buf, size_t size, size_t lbytes)
{
size_t i, k, remainder;
unsigned char *cbuf = (unsigned char *)buf;
for (i = 0; i < size; ++i) {
if (i % lbytes == 0)
printf("%08x ", (unsigned int)i);
printf("%02X ", cbuf[i]);
if (i % lbytes == lbytes - 1) {
for (k = 0; k < lbytes; ++k)
printf("%c", iscntrl(cbuf[i - lbytes + k]) ? '.' : cbuf[i - lbytes + k]);
putchar('\n');
}
}
remainder = size % lbytes;
for (k = 0; k < 3 * (lbytes - remainder); ++k)
putchar(' ');
for (k = 0; k < remainder; ++k)
printf("%c", iscntrl(cbuf[i - remainder + k]) ? '.' : cbuf[i - remainder + k]);
putchar('\n');
}
int main(void)
{
FILE *f;
char buf[BUFSIZ * 2];
if ((f = fopen("test.txt", "r+")) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
setvbuf(f, buf, _IOFBF, BUFSIZ * 2);
fgetc(f);
disp_hex(buf, BUFSIZ * 2, 16);
printf("---------------------------------------------\n\n");
fseek(f, 0, SEEK_CUR);
fputc('x', f);
disp_hex(buf, BUFSIZ * 2, 16);
fclose(f);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bilgisayar sistemlerinde tüm işlemler aslı ı ı ı ı
bir kart taktı ı ı ı ı ı ı
yerleştirilmiştir. Ancak bu tür donanı ı ı
yaptı ı ı
Yani genişleme yuvası ı ı
programlar yazı ı ı ı ı ı
sı ı ı ı ı
kodları ı ı ı ı ı ı
(device drivers)" denilmektedir. O halde nerede bir donanı ı ı ı ı ı
Bu kodlar da aygı ı ı ı ı ı ı ı ı ı
sonra kart bir işe yaramaktadı
Aygı ı ı ı ı ı
mimarisi vardı ı ı ı ı ı ı
masaüstü bilgisayarları ı ı ı ı
işletim sisteminin belirlediği bazı ı
Pekiyi aygı ı ı ı
bölümü sistem boot edilirken yüklenmektedir. Diğer bir bölümü ise gerektiğinde donanı ı ı ı ı
Örneğin modern sistemlerde genişleme yuvaları ı ı ı ı ı ı ı
donanı ı ı ı ı
ilişkin aygı ı ı ı
sistemlerde bir aygı ı ı
aygı ı ı ı ı ı ı
sürücüler yüklenirken bir pop pencereyle sistem yöneticisi bilgilendirilir ve onun onayı ı ı
Bazı ı ı ı ı ı ı
programcı ı ı ı ı ı
gerçekleştirebilir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aygı ı ı ı ı ı ı ı ı
öyle açı ı ı ı ı ı ı ı ı ı ı
dosya fonksiyonları ı ı ı ı ı
Örneğin UNIX/Linux sistemlerinde bir aygı ı ı
okuma yapı ı ı ı ı ı ı ı
kapatı ı
Örneğin Windows sistemlerinde yine aygı ı ı
aygı ı ı ı ı
içerisindeki fonksiyonlar çağrı ı
/*------------------------------------------------------------------------------------------------------------------------------------------
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi aygı ı ı ı ı ı ı ı ı ı ı ı
aygı ı ı ı ı ı ı ı ı ı ı ı ı ı
aygı ı ı ı ı ı ı ı ı ı ı
verip user moddan bu fonksiyonları ı ı
Örneğin bir termometre devresini kontrol eden bir aygı ı ı ı ı
açı ı ı ı ı ı ı ı ı ı ı ı
yine bizim bir fonksiyonumuz çağrı ı ı ı ı ı
kapatı ı ı ı ı ı
Aygı ı ı ı
otomatik olarak geçirilmektedir. Yani aygı ı ı ı ı ı ı
yeniden user moddan kernel moda geri dönülmektedir.
/*------------------------------------------------------------------------------------------------------------------------------------------
/*------------------------------------------------------------------------------------------------------------------------------------------
Klavye ve ekran aslı ı ı ı ı ı ı
şeyler yazdı ı ı ı ı ı ı ı
klavyeden okuma yaparken aygı ı ı ı ı
"terminal" bunlara aygı ı
C standartları ı ı ı ı
Ekran ve klavye yerine C standartları ı ı ı ı
stdout ve stdin birer dosya olarak geçmektedir. Böylece örneğin printf fonksiyonu ekrana yazmamaktadı ı
scanf fonksiyonu klavyeden okumamaktadı ı ı ı
standartlarda belirtilmemiştir. Tabii modern masaüstü sistemlerinde stdout dosyası ı ı ı
stdin dosyası ı ı ı ı ı
bunları ı ı ı ı ı ı ı ı ı ı
şeyler aygı ı ı ı ı ı
aslı ı ı
Modrn işletim sistemlerinde açı ı ı ı ı ı
gönderilmektedir. Ancak biz istersek bu dosyaya yazı ı
Bu işleme işletim sistemleri dünyası
stdout ve stdin dosyaları ı
/*------------------------------------------------------------------------------------------------------------------------------------------
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux dünyası ı ı
terminalde tty komutunu vererek aygı
$tty
/dev/pts/1
Aygı ı ı ı ı ı ı ı ı
terminale çı ı
int fd;
if ((fd = open("/dev/pts/1", O_WRONLY)) == -1)
exit_sys("open");
write(fd, "ankara\n", 7);
close(fd);
İşte aslı ı ı ı ı
sürücüye yollamaktadı ı ı ı ı
puts ---> write(stdout, ....) ----> Aygı
Aşaı ı ı ı ı ı ı ı
ekran ve klavye işlemleri tek bir aygı ı ı ı ı
Zaten terminal kavramı ı ı ı ı ı ı ı
sürücüsüdür.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
int fd;
char buf[4096];
ssize_t result;
if ((fd = open("/dev/pts/1", O_RDWR)) == -1)
exit_sys("open");
if ((result = read(fd, buf, 4096)) == -1)
exit_sys("read");
buf[result] = '\0';
if (write(fd, buf, strlen(buf)) == -1)
exit_sys("write");
close(fd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
C'de stdin, stdout ve stderr değişken isimleri aslı
ekran ve klavyeyi kontrol eden aygı ı ı ı ı ı ı ı ı ı ı ı ı
şeyler terminal aygı
Yani diğer dosyalar için nası ı ı ı ı ı ı
yapı ı ı ı
stdout ve stdin dosyaları ı ı ı ı ı
fprintf(stdout, ...);
printf(....);
Aşağı ı
fscanf(stdin, ...);
scanf(....);
Zaten C standartları ı ı ı
diye kı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
35. Ders 14/10/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
UNIX/Linux sistemlerinde bir proses çalı ı ı ı ı ı
0 numaralı ı
yapı ı ı ı ı ı ı ı ı ı
de yine terminal aygı ı ı ı ı ı ı
bastı ı ı ı ı ı ı ı
betimleyicde olduğu gibi terminal aygı ı ı ı ı ı ı
UNIX/Linux dünyası ı ı ı
betimelyiciye de "stderr betimleyicisi" denilmektedir. Bizim açmadı ı ı ı
kapatmamalı ı ı ı ı
betimleyicileri kullanmaktadı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define BUFFER_SIZE 4096
void exit_sys(const char *msg);
int main(void)
{
char buf[BUFFER_SIZE];
ssize_t result;
if ((result = read(0, buf, BUFFER_SIZE)) == -1)
exit_sys("read");
if (write(1, buf, result) == -1)
exit_sys("write");
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Benzer biçimde Windows sistemlerinde de bir proses çalı ı ı ı ı
temsil eden dosyalar açı ı ı ı
önceden belli değildir. Dolayı ı ı ı ı ı
Fonksiyonun prototipi şöyledir:
HANDLE WINAPI GetStdHandle(
DWORD nStdHandle
);
Fonksiyona parametre olarak aşağı
STD_INPUT_HANDLE
STD_OUTPUT_HANDLE
STD_ERROR_HADNLER
Bu değerler biçizm hangi standart handle'ı ı ı ı
geri döner. Prosesin standart handle'ları
set edilmemektedir.
Windows sistemlerinde de standart C kütühanesindeki stdin, stdout ve stderr dosya bilgi göstericileri GetStdHandle ile elde eidlen aygı
ilişkin dosyaları ı
Aşağı ı ı ı ı ı
okunanlar stdout dosyası ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#define BUFFER_SIZE 4096
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hStdIn, hStdOut;
char buf[BUFFER_SIZE];
DWORD dwRead, dwWritten;
if ((hStdIn = GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE)
ExitSys("GetStdHandle");
if ((hStdOut = GetStdHandle(STD_OUTPUT_HANDLE)) == INVALID_HANDLE_VALUE)
ExitSys("GetStdHandle");
if (hStdIn == NULL || hStdOut == NULL) {
fprintf(stderr, "Standard input or standard output handle doesn't exist!..\n");
exit(EXIT_FAILURE);
}
if (!ReadFile(hStdIn, buf, BUFFER_SIZE, &dwRead, NULL))
ExitSys("ReadFile");
if (!WriteFile(hStdOut, buf, dwRead, &dwWritten, NULL))
ExitSys("WriteLile");
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Biz default olarak stderr dosyası ı ı ı ı
belirtmiştik. Pekiyi stdout ile stderr arası ı ı ı ı ı ı ı ı ı
ikisi de ekranda görüntülenmektedir.
Bir dosya dosyanı ı ı
dünyası ı ı ı ı
biz onu bir disk dosyası ı ı ı
olurlar. Benzer biçimde biz stdin ve stderr dosyaları ı
IO yönlendirmelerinin kernel tarafı ı ı ı ı ı ı ı ı ı ı
yönlenidrmesi ile ilgileneceğiz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Biz bir programı ı ı ı ı ı ı ı ı ı ı ı ı
yönlendirmiş oluruz. Örneğin:
./sample > test.txt
Burada stdou dosyası ı ı ı ı ı ı ı ı
ekrana çı ı ı ı ı ı
oluruz. Örneğin:
./sample 2> test.txt
Burada sample programı ı ı ı ı ı ı ı ı
birlikte de yapabliriz. Örneğin:
./sample > test.txt 2> mest.txt
Kabukta yönlendirme Windows'un komut satı ı ı ı ı
Biz programı ı ı ı ı ı ı ı ı ı ı ı
çalı ı ı ı ı ı ı
bu durumda programı ı ı ı ı
Örneğin find isimli programla bir dosyayı ı ı ı
$>find / -name "sample.c"
find bu ii yaparken erişim hakları ı ı ı ı ı ı ı
dosyası ı ı ı ı ı ı ı
mesajlar görünecektir. Ancak biz stderr dosyası ı ı
$>find / -name "sample.c" 2> err.txt
Burada kullanı ı ı ı ı ı ı
bazı ı ı ı ı ı ı ı
şöyle de öalı ı
$>find / -name "sample.c" 2> /dev/null
Bu kullanı ı ı
stdout ve stderr dosyaları ı ı ı ı ı ı
./sample > test.txt 2> test.txt
Çünkü genel olarak kabuk programları ı ı
isteniyorsa aşağı ı ı ı
./sample > test.txt 2>&1
Burada "2>&1" karakterleri "2 numaralı ı ı
yönlendir" anlamı
Normal olarak klavyeden okunacak bilgiler sanki klavyeden girilmiş gibi dosyadan da okunabilir. Bunun için kabuk üzerinde "<" sembolü ile
stdin dosyası ı
$>sample < test.txt
Burada sample programı ı ı ı ı ı ı
terminal aygı ı ı ı ı
Biz bir dosyadan okuma yapan dosya sonuna geldiğinde sonlanan bir program yazmı ı ı ı ı ı
getirdiğimizde EOF etkisi nası ı
gelmek biçiminde bir kavram yoktur. İşte terminal aygı ı ı
dünyası ı ı ı ı ı ı ı
kapatmı ı ı ı ı ı
yaratmak için Ctrl+z ve Ctrl+d tuşları ı ı ı ı ı ı ı
bası ı ı
Aşağı ı ı ı ı ı ı ı ı ı ı
stdin dosyası ı ı
tuşları ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
FILE *f;
int ch;
if (argc > 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if (argc == 1)
f = stdin;
else
if ((f = fopen(argv[1], "r")) == NULL) {
fprintf(stderr, "cannot open file: %s\n", argv[1]);
exit(EXIT_FAILURE);
}
while ((ch = fgetc(f)) != EOF)
putchar(ch);
if (ferror(f)) {
fprintf(stderr, "cannot read file!..\n");
exit(EXIT_FAILURE);
}
fclose(f);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
C'deki (işletim sisteminin değil) stdin, stdout ve stderr dosyaları ı ı
biz stdout dosyası ı ı ı ı ı
fonksiyonları ı ı ı ı ı
tamponlama modu nedir? Standartlar şunları
1) stdout ve stdin dosyaları ı ı ı ı
tamponlamalı ı ı ı ı ı
tamponlamalı ı ı ı
olmayan aygı ı
2) stderr dosyası ı ı ı
tamponlamalı
Standartlardaki bu anlatı ı ı
- Biz stdin ve stdout dosyaları ı ı
C derleyicilerini yazanlara bağlı ı ı ı ı ı
işin başı ı ı ı ı ı ı
- stderr dosyası ı ı ı ı ı ı
ya da sı ı ı
Bu durumda örneğin aşağı ı ı ı ı
printf("this is a test");
Eğer ilgili derleyici satı ı ı ı
Eğer ilgil derleyici sı ı ı ı ı
Pekiyi yukarı ı ı ı ı ı ı ı ı ı ı
için şunlar yapı
- Yazdı ı ı ı ı ı ı ı
printf bitince ekranda görünecektir. Örneğin:
printf("this is a test\n");
Tabii burada imleç aşağı ı ı ı
- printf çağrı ı
printf("this is a test");
fflush(stdout);
- stdout dosyası ı ı ı ı ı ı ı ı
gerekir. Örneğin:
setbuf(stdout, NULL);
printf("this is a test");
C derleyicilerinin çoğunda stdin dosyası ı ı ı
etmektedir. Bu nedenle aşağı ı ı ı
printf("input a number:");
scanf("%d", &val);
Ancak C standartları ı ı ı
printf("input a number:");
fflush(stdout);
scanf("%d", &val);
Her ne kadar C'nin stdin dosyası ı ı ı ı ı ı
pratikte hep bu dosya staı ı ı ı
satı ı ı ı ı ı ı ı ı
Aşağı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
int main(void)
{
printf("ankara");
for (;;)
;
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
stdin dosyası ı ı ı ı
klavyeden okunup tampona yerleştirilecek ve tampondaki, ilk karakter okunacaktı ı ı ı
karakteri tampona yerleştirilmektedir. Örneğin:
ch = getchar();
ch = getchar();
Burada birinci getchar fonksiyonu eğer stdin tamponununda karakter varsa hemen karakteri tampondan alı
satı ı ı ı ı
şöyle olacaktı
a\n
İlk getchar fonksiyonu a karakterini tampondna alı
karakterini alı ı ı
şaşı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
36. Ders 15/10/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
karakter ile geri dönecektir. İkinci getchar tampon boş olmadı ı ı
Dolayı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
int main(void)
{
int ch;
ch = getchar();
printf("%c (%d)\n", ch, ch);
ch = getchar();
printf("%c (%d)\n", ch, ch);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
stdin işin başı ı ı ı ı ı
standart C fonksiyonları ı ı ı ı ı
Tamponun sonunda da \n karakteri bulunacakı ı ı ı
dosyası ı ı ı ı
karakterini gördüğünde onu okur ancak parametresiyle aldı ı
Dolayı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
int main(void)
{
int ch;
char buf[1024];
ch = getchar();
printf("%c\n", ch);
gets(buf);
printf("%s\n", buf);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı
int ch;
...
while ((ch = getchar()) != EOF)
putchar(ch);
Burada ilk getchar stdin tamponu boş olduğu için bir satı ı ı ı
ENTER tuşuna basmı ı ı
ankara\n
İlk getchar tampondan 'a' karakterini alı ı ı ı ı ı
diğer karakterleri alı ı ı ı ı ı ı ı ı ı ı ı
imleç aşağı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
için aynı ı ı
döngünden çı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
int main(void)
{
int ch;
while ((ch = getchar()) != EOF)
putchar(ch);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Biz gerçekten klavyedem yeni bir giriş yapı ı ı
tamponunu başaltabilen standart bir C fonksiyonu yoktur. '\n' karakteri görene kadar stdin tamponundan karakterleri atmak için aşağı
gibi bir döngü yeterli olmaktadı
while (getchar() != '\n')
;
Bu döngüde en son '\n' karakteri okunacak ve döngüden çı ı ı ı ı ı ı ı
fonksiyonlar klavyeden yeni bir giriş isteyecektir. Bu tür durumlarda stdin dosyası ı ı ı
sonunda '\n' karakterinin olmaması
istiyorsanı ı
while ((ch = getchar()) != '\n' && ch != EOF)
;
stdin taponun boşaltı ı ı
void clear_stdin(void)
{
int ch;
while ((ch = getchar()) != '\n' && ch != EOF)
;
}
Tabii bu fonksiyonu biz zaten boşken çağı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void clear_stdin(void)
{
int ch;
while ((ch = getchar()) != '\n' && ch != EOF)
;
}
int main(void)
{
int ch;
char buf[1024];
ch = getchar();
printf("%c\n", ch);
clear_stdin();
ch = getchar();
printf("%c\n", ch);
clear_stdin();
gets(buf);
puts(buf);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Anı ı ı ı ı ı ı
yazı
#define clear_stdin() \
do \
{ \
int ch; \
\
while ((ch = getchar()) != '\n' && ch != EOF) \
; \
} \
while (0)
-------------------------------------------------------------------------------------------------------------------------------------------*/
#define clear_stdin() \
do \
{ \
int ch; \
\
while ((ch = getchar()) != '\n' && ch != EOF) \
; \
} \
while (0)
int main(void)
{
int ch;
char buf[1024];
ch = getchar();
printf("%c\n", ch);
clear_stdin();
ch = getchar();
printf("%c\n", ch);
clear_stdin();
gets(buf);
puts(buf);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
İstersek işin başı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
int main(void)
{
setvbuf(stdout, NULL, _IONBF, 0);
printf("ali");
for (;;)
;
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
getchar fonksiyonu stdin dosyası ı ı ı
ya da IO hatası
int getchar(void);
getchar fonksyonu aşağı
fgetc(stdin)
Hatta bazı ı ı ı ı
#define getchar() fgetc(stdin)
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Şimdi de stdin dosyası ı ı
gets fonksiyonu yukarı ı ı ı ı ı ı ı
derleyicilerde geçmişe uyum için bulundurulmaktadı
#include <stdio.h>
char *gets(char *s);
gets fonksiyonu stdin dosyası ı ı
okuduğunda ya da dosya sonuna gelindiğinde bu karakter yerine hedef diziye '\0' yerleştirip işlemini sonlandı ı
'\n' karakteri görene kadar ya da dosya sonunagelinene kadar stdin dosyası ı
yerleştirmemektedir. gets fonksiyonu başarı ı ı
okuyamadan EOF ile karşı ı ı ı
NULL adresle geri dönmektedir. Bu durumda dizinin içeriği yarı
gets fonksiyonu genellikle getchar fonksiyonu kullanı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
char *mygets(char *s);
int main(void)
{
char buf[1024];
printf("Bir yazi giriniz:");
fflush(stdout);
mygets(buf);
puts(buf);
return 0;
}
char *mygets(char *s)
{
int ch;
size_t i;
for (i = 0; (ch = getchar()) != '\n' && ch != EOF; ++i)
s[i] = ch;
if (ch == EOF)
if (i == 0 || ferror(stdin))
return NULL;
s[i] = '\0';
return s;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı
gets_s Microsoft derleyicilerinde zaten uzun süredir bulunmaktadı ı ı ı
bulunmamaktadı
char *gets_s(char *s, rsize_t n);
Fonksiyon stdin dosyası ı
yada dosya sonuna geldiğinde ya da IO hatası ı ı
gibidir.
Aşağı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
char *mygets_s(char *str, size_t size);
int main(void)
{
char buf[5];
mygets_s(buf, 5);
puts(buf);
return 0;
}
char *mygets_s(char *str, size_t n)
{
size_t i;
int ch;
if (str == NULL || n == 0)
return NULL;
for (i = 0; i < n - 1; ++i) {
if ((ch = getchar()) == '\n')
break;
if (ch == EOF) {
if (i == 0 || ferror(stdin))
return NULL;
break;
}
str[i] = ch;
}
str[i] = '\0';
return str;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
gets fonksiyonu gğvensiz olduğundan ve C'den kaldı ı ı ı ı ı
gets yerine fgets fonksiyonunu tercih etmektedir. fgets fonksiyonunun prototipini anı ı ı
#include <stdio.h>
char *fgets(char *s, int size, FILE *stream);
fgets fonksiyonu gets_s fonksiyonuna benzemekle birlikte önemli bir farklı ı
bu '\n' karakterini de diziye yerleştirmektedir. Oysa gets ve gets_s hiçbir zaman '\n' karakterini diziye yerleştirmemektedir.
fgets fonksiyonunun diğer davranı ı
fgets(buf, 10, stdin);
Burada fgtes en fazla 9 karakter okuyacaktı
ankara\n
Burada fgtes '\n' dahil olmak üzere bu karakterlerin hepsini diziye yerleştirir ayrı ı ı
girilen karakterler şunlar olsun:
kastamonu\n
Burada fgets 9 karakter okurken '\n' karakterini görmediği için '\n' karakterini diziye yerleştirmez. Ancak null karakteri diziye
yerleştirir. Yine fgets henüz hiçbir karakter okunmadan dosya sonuna gelinmişse NULL adresle geri dönmektedir. Normal durumda fgets
parametresi ile belirtilen adresin aynı ı
Görüldüğü fgets maalesef bazı ı ı
genellikle fgets çağrı ı
fonksiyonu ile stdin dosyası ı ı ı
char buf[10];
char *str;
...
fgets(buf, 10, stdin);
if ((str = strchr(buf, '\n')) != NULL)
*str = '\0';
Burada dizinin sonunda '\n' karakterinin olup olmadı ı ı ı
karakter diziye yerleştirilmiştir. Burada fgtes hiçbir okuma yapı ı ı ı ı
Ctrl+z ya da Ctrl+d tuşları ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
scanf fonksiyonunun prototipi şöyledir:
#include <stdio.h>
int scanf(const char *format, ...);
Fonksiyon aslı ı ı
#include <stdio.h>
int fscanf(FILE *f, const char *format, ...);
scanf fonksiyonunun bazı ı ı ı ı ı ı ı ı
fonksiyonu stdin dosyası ı ı
(tampona) geri yerleştirir ve işlemi sonlandı ı ı ı ı ı
result = scanf("%d%d", &a, &b);
Şimdi dosyada (tamponda) şu karakterler bulunyor olsun:
123istanbul\n
scanf 123 sayı ı ı ı ı
bir yerleştirme yapmaz ve 1 değerine geri döner. Dosyadaki (tampondaki) karakterler şöyle olsun:
istanbul\n
Burada scanf hiç yerleştirme yapamayacağı
atmaktadı ı ı
görürse bu durumda EOF özl değerine geri dönmektedir. Örneğin dosyanı
___EOF
Bu durumda scanf EOF değerine geri dönecektir. Ancak örneğin:
___istanbulEOF
Bu durumda scanf 0 değerine geri döncektir.
scanf işle birden fazla okuma yapı ı ı ı
result = scanf("%d%d", &a, &b);
stdin dosyası
__10___20__\n
scanf burada iki yerleştirmeyi de başarı ı
(leading space)" attı ı ı ı ı ı
şu karakterler kalacaktı
__\n
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
scanf fonksiyonu ile menü oluştururken geçirsiz girişlerin ele alı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
void clear_stdin(void)
{
int ch;
while ((ch = getchar()) != '\n' && ch != EOF)
;
}
int disp_menu(void)
{
int choice;
printf("1) Kayit ekle\n");
printf("2) Kayit sil\n");
printf("3) Arama\n");
printf("4) Cikis\n\n");
printf("Seciminiz:");
fflush(stdout);
if (scanf("%d", &choice) == 0) {
clear_stdin();
return 0;
}
return choice;
}
int main(void)
{
int choice;
for (;;) {
choice = disp_menu();
switch (choice) {
case 1:
printf("kayit ekleniyor\n\n");
break;
case 2:
printf("kayit siliniyor\n\n");
break;
case 3:
printf("arama yapiliyor\n\n");
break;
case 4:
goto EXIT;
default:
printf("gecersiz giris!..\n\n");
break;
}
}
EXIT:
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
37. Ders 22/10/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
scanf fonksiyonunda format karakterleri arası ı
scanf("%d/%d/%d", &day, &month, &year);
Burada her ilk iki int değerden hemen sonra bir tane '/' karakterinin kullanı ı
12/10/2009
'/' karakterelerinin solunda ve sağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
int main(void)
{
int day, month, year;
printf("Tarihi dd/mm/yyyy biçiminde giriniz:");
scanf("%d/%d/%d", &day, &month, &year);
printf("%d-%d-%d\n", day, month, year);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
scanf fonksiyonunda format karakterlerindeki herhangi bir boşluk karakteri (SPACE ve \n olabilir) "boşluk karakteri görmeyene kadar stdin'den
okuma yap ve onları ı ı ı
kullanabilmektedir. Örneğin:
scanf("%d%d\n", &a, &b);
Burada programcı ı ı
yerleştirilseydi davranı ı
kadar stdin dosyası ı ı ı ı
bitirmeyecektir. Örneğin:
scanf("%d / %d / %d", &day, &month, &year);
Burada artı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
scanf fonksiyonunun baştaki boşluk karakterlerini (leading space) attı ı ı ı
Bu durumda scanf fonksiyonundan sonra gets, getchar gibi fonksiyonları ı ı
scanf fonksiyonunun başka ayrı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
void clear_stdin(void)
{
int ch;
while ((ch = getchar()) != '\n' && ch != EOF)
;
}
int main(void)
{
int a;
char ch;
printf("Bir sayi giriniz:");
fflush(stdout);
scanf("%d", &a);
clear_stdin();
printf("Bir karakter giriniz:");
fflush(stdout);
ch = getchar();
printf("%d %c\n", a, ch);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Daha önceden de belirttiğimiz gibi scanf eğer baştaki bpşluk karakterlerini attı ı ı
dönmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
int main(void)
{
int val;
while (scanf("%d", &val) != EOF)
printf("%d\n", val);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
scanf fonksiyonu ile ilgili başka yarı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde open fonksiyonu ile bir dosya betimleyicisini elde etmiş olalı
yapabilmek ve C'nin standart dosya fonksiyonları ı
geri dönüştürülmesi gerekmektedir. Bu işlem fdopen isimli POSIX fonksiyonuyla yapı ı
#include <stdio.h>
FILE *fdopen(int fd, const char *mode);
Fonksiyonun birinci parametresi open fonksiyonundan eldee dilmş olan dosya betimleyicisini, ikinci parametresi ise dosya açı
belirtmektedir. Fonksiyon başarı ı ı ı
Şüphesiz burada belirtilen açı ı ı
dönüştürmeden sonra dosya fclose ile kapatı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int fd;
FILE *f;
int ch;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((fd = open(argv[1], O_RDONLY)) == -1)
exit_sys("open");
if ((f = fdopen(fd, "r")) == NULL)
exit_sys("fdopen");
while ((ch = fgetc(f)) != EOF)
putchar(ch);
if (ferror(f)) {
fprintf(stderr, "cannot read!..\n");
exit(EXIT_FAILURE);
}
fclose(f);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde fdopen fonksiyonunun tersini yapan fileno isimli bir fonksiyon da bulunmaktadı
dosya bilgi göstericisini bizden alı ı ı ı
Fonksiyonun prototipi şöyledir:
#include <stdio.h>
int fileno(FILE *stream);
Fonksiyon başarı ı ı ı
set edilmektedir.
Aşağı ı ı
ile dosyadna okuma yapı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int fd;
FILE *f;
char buf[30 + 1];
ssize_t result;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((f = fopen(argv[1], "r")) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
if ((fd = fileno(f)) == -1)
exit_sys("fileno");
if ((result = read(fd, buf, 30)) == -1)
exit_sys("read");
buf[result] = '\0';
puts(buf);
fclose(f);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi fdopen ve fileno fonksiyonları ı ı ı ı ı ı
yerine HANDLE türü ile temsil edilen handle değerlei kullanı ı
yoktur. Ancak Microsoft DOS zamanları ı ı ı ı ı
işletim sistemi çekirdeği tarafı ı
fonksiyonlardı ı ı ı
Microsoft'un UNIX/Linux sistemlerindeki POSIX fonksiyonları ı ı ı ı
Bu fonksiyonlar klasik UNIX tarzı ı ı ı
_open ve _sopen_s
_read
_write
_close
_lseek
...
İşte bu <io.h> içerisinde _fdopen ve _fileno fonksiyonları ı
yapı
Aşağı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <io.h>
void exit_sys(const char *msg);
int main(void)
{
int fd;
FILE *f;
int ch;
if ((fd = _open("sample.c", _O_RDONLY)) == -1)
exit_sys("_open");
if ((f = _fdopen(fd, "r")) == NULL)
exit_sys("_fdopen");
while ((ch = fgetc(f)) != EOF)
putchar(ch);
if (ferror(f)) {
fprintf(stderr, "cannot read file!..\n");
exit(EXIT_FAILURE);
}
fclose(f);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi biz sı ı ı
kabaca aşağı ı ı
- Öncelikle bir FILE yapı ı ı ı ı ı ı ı ı ı ı ı ı
Dolayı ı ı ı ı ı ı ı ı ı
typedef struct {
....
} FILE;
Pekiyi bu FILE yapı ı ı ı ı ı ı ı ı
barı ı ı ı ı ı ı
- Aşağı ı
Windows sistemleri için HANDLE değeri).
- Dosyanı ı
- Tamponun yeri ve uzunluğu
- Tamponun aktif noktası ı ı ı ı ı
- Tamponun kirli (dirty) olup olmadı ı
- Ası ı
- Son işlem EOF yüzünden başarı ı ı ı ı ı ı ı
işlemi başarı ı ı ı ı
- Diğer bilgiler
- fopen fonksiyonu yazı ı ı ı ı ı
açı ı ı
FILE *fopen(const char *path, const char *mode)
{
1) mode parametresi parse edilmeli
2) FILE yapı ı
3) Tampon tahsis edilip bilgileri FILE yapı ı ı ı
4) Diğer işlemler
5) FILE yapı ı ı
}
C'nin Stdio ktüphenesinin yazı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* csd_stdio.h */
#ifndef CSD_STDIO_H_
#define CSD_STDIO_H_
#define CSD_EOF -1
#define CSD_BUFSIZ 5
#include <sys/types.h>
typedef struct {
int fd;
unsigned char *beg; /* starting buffer address */
size_t size; /* buffer size */
size_t count; /* number of bytes in the buffer */
unsigned char *pos; /* current buffer address */
off_t offset; /* file offset */
int dirty;
int error;
int eof;
/* .... */
} CSD_FILE;
CSD_FILE *csd_fopen(const char *path, const char *mode);
int csd_fgetc(CSD_FILE *f);
#endif
/* csd_stdio.c */
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include "csd_stdio.h"
static ssize_t refresh_buffer(CSD_FILE *f);
CSD_FILE *csd_fopen(const char *path, const char *mode)
{
CSD_FILE *f;
int i;
static char *modes[] = { "r", "r+", "w", "w+", "a", "a+", "rb", "r+b", "wb", "w+b", "ab", "a+b", NULL };
static int flags[] = { O_RDONLY, O_RDWR, O_WRONLY | O_CREAT | O_TRUNC, O_RDWR | O_CREAT | O_TRUNC, O_WRONLY | O_CREAT | O_APPEND,
O_WRONLY | O_CREAT | O_APPEND, O_WRONLY | O_CREAT | O_APPEND };
if ((f = (CSD_FILE *)malloc(sizeof(CSD_FILE))) == NULL)
return NULL;
for (i = 0; modes[i] != NULL; ++i)
if (!strcmp(mode, modes[i]))
break;
if (modes[i] == NULL) {
free(f);
return NULL;
}
if ((f->fd = open(path, flags[i % 6], S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == -1) {
free(f);
return NULL;
}
if ((f->beg = (unsigned char *)malloc(CSD_BUFSIZ)) == NULL) {
free(f);
return NULL;
}
f->size = CSD_BUFSIZ;
f->count = 0;
f->pos = NULL;
f->offset = 0;
f->dirty = 0;
f->error = 0;
return f;
}
static ssize_t refresh_buffer(CSD_FILE *f)
{
ssize_t result;
if (f->dirty) {
if (lseek(f->fd, f->offset, SEEK_SET) == -1)
return -1;
if (write(f->fd, f->beg, f->pos - f->beg) == -1)
return -1;
}
if (lseek(f->fd, f->offset + f->count, SEEK_SET) == -1)
return -1;
if ((result = read(f->fd, f->beg, f->size)) == -1)
return -1;
f->pos = f->beg;
f->offset = f->offset + f->count;
f->count = result;
return result;
}
int csd_fgetc(CSD_FILE *f)
{
ssize_t result;
if (f->pos == NULL || f->pos == f->beg + f->count) {
if ((result = refresh_buffer(f)) == -1) {
f->error = 1;
return CSD_EOF;
}
if (result == 0) {
f->eof = 1;
return CSD_EOF;
}
}
return *f->pos++;
}
int csd_ferror(CSD_FILE *f)
{
return f->error;
}
/* sample.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "csd_stdio.h"
void exit_sys(const char *msg);
int main(void)
{
CSD_FILE *f;
int ch;
if ((f = csd_fopen("test.txt", "r")) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
ch = csd_fgetc(f);
putchar(ch);
while ((ch = csd_fgetc(f)) != CSD_EOF)
putchar(ch);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
freopen isimli standart C fonksiyonu yüksek seviyeli biçimde ""dosya yönlendirmeesi (IO redirection)" yapmaktadı
şöyledir:
#include <stdio.h>
FILE *freopen(const char *path, const char *mode, FILE *stream);
Fonksiyonun birinci parametresi yönlendirmenin yapı ı ı ı ı ı ı ı ı
belirtir. Eğer bu ikinci parametre "w" içeren bir parametre ise yönlendirme bu dosyaya yazı ı ı
"r" içeren biçimdeyse yönlendirme bu dosyadan okunacak biçimde yapı ı
dosya bilgi göstericisini (stream) almaktadı ı ı ı ı
NULL adrese geri dönmektedir. Fonksiyonun bize verdiği dosya bilgi göstericisi birinci parametreyle belirttiğimiz dosyaya ilişkin dosya
bilgi göstericisidir. Bu işlem sonrası ı
FILE nesnesini gösteriyor durumda olur. Örneğin:
FILE *f;
if ((f = freopen("test.txt", "w", stdout)) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
Burada stdout dosyası ı ı ı ı ı ı
yazı ı ı ı ı ı
gösteicisinin gösterdiği yer aslı ı ı ı
geri döndürdüğü dosya bilgi göstericisine aslı ı
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
if ((f = freopen("test.txt", "w", stdout)) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 10; ++i)
printf("%d\n", i);
fprintf(f, "Ok\n");
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi freopen ile yaı ı ı ı ı
sonra onları ı ı
IO yönlendirmesi çokça karşı ı ı ı
yönlendirilecek dosyası ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
freopen fonksiyonu ile stdin dosyası ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *f;
int ch;
if ((f = freopen("test.txt", "r", stdin)) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
while ((ch = getchar()) != EOF)
putchar(ch);
if (ferror(stdin)) {
fprintf(stderr, "cannot read file!..\n");
exit(EXIT_FAILURE);
}
fclose(f);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
getenv standart C fonksiyonu ile bir çevre değişkeninin değerinin elde eidlmesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char *val;
if ((val = getenv("PATH")) == NULL) {
fprintf(stderr, "Environment variable not found!..\n");
exit(EXIT_FAILURE);
}
printf("%s\n", val);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde çevre değişkenini elde eden ası ı
getenv bu sistemlerde bu API fonksiyonunu çağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#define SIZE 4096
int main(void)
{
char val[SIZE];
DWORD dwResult;
if ((dwResult = GetEnvironmentVariable("PATH", val, SIZE)) == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
fprintf(stderr, "Environment variable not found!..\n");
exit(EXIT_FAILURE);
}
if (dwResult > SIZE) {
fprintf(stderr, "Insufficient buffer!..\n");
exit(EXIT_FAILURE);
}
printf("%s\n", val);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
38. Ders 28/10/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
İşletim sistemleri dünyası ı ı ı ı ı
Sistem programcı ı ı ı ı
üzerinde duracağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Proseslerin çevre değişkenleri "anahtar-değer (key-value)" çiftlerini tutan, anahtar verildiğinde ona karşı
sözlük tarzı ı
yazı ı ı ı
değişkeni "CITY" isminde olabilir. Ona karşı
Çevre değişkenleri ilk bakı ı ı
yapı ı ı ı ı ı ı
Gerçekten de pek çok programlama dilinin standart kütüphanesinde ya da bizzat sentaks ve semantik yapı ı
tarzı ı ı ı ı
Genellikle işletim sistemleri (örneğin Windows, Linux, macOS) prosesin çevre değişkenlerini "anahtar-değer" çiftleri biçiminde liste
tarzı ı ı ı ı
çevre değişkenleri pek çok işletim sisteminde proses kontrol blokta değil bizzat prosesin bellek alanı ı
değişken listesinin tutulduğu alan İngilizce genellikle "environment block" biçiminde isimlendirilmektedir.
İşletim sisteminde prosesin çevre değişkenleri default durumda genellikle proses yaratı ı ı ı
Yani bir programı ı ı ı ı ı ı ı ı
almaktadı ı ı ı
Linux ya da macOS sistemlerinde komut satı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
komut satı ı ı ı ı ı ı ı
çift tı ı ı ı ı ı ı ı ı ı ı
prosesten alı ı
Bir sistem programcı ı ı ı ı
ilişkin bazı ı ı ı ı ı ı ı ı
bir konu olduğu için ilgili sistemdeki düşük seviyeli fonksiyonlarla gerçekleştirilmektedir. Çevre değişkenleri üzerinde işlemler Windows
sistemlerinde API fonksiyonları ı ı ı
Çevre değişkenlerinin (yani anahtarları ı ı ı
ve macOS sistemlerinde büyük harf küçük harf duyarlı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir çevre değişkeninin anahtarı
fonksiyon genel olarak ilgili sistemdeki daha aşağı ı ı ı
şöyledir:
#include <stdlib.h>
char *getenv(const char *name);
Fonksiyon parametre olarak çevre değişkenin ismini alı
Fonksiyonun geri döndürdüğü adresteki dizi statik biçimde tahsis edilmiştir. Dolayı ı ı
adresteki dizi üzerinde değişiklik yapı ı ı
Aşağı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
char *value;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((value = getenv(argv[1])) == NULL) {
fprintf(stderr, "environment variable not found: %s\n", argv[1]);
exit(EXIT_FAILURE);
}
puts(value);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde ve macOS sistemlerinde getenv aynı ı ı ı
zamanda bir POSIX fonksiyonu kabul edilmektedir.) Dolayı ı
sistemlerinde prosesin çevre değişkenini elde edebilmek için GetEnvironmentVariable isimli bi API fonksiyonu kullanı ı
standart C fonksiyonu Windows sistemlerinde aslı ı ı ı ı
GetEnvironmentVariable fonksiyonunun prototipi şöyledir:
DWORD GetEnvironmentVariable(
LPCTSTR lpName,
LPTSTR lpBuffer,
DWORD nSize
);
Fonksiyonunun birinci parametresi aranacak çevre değişkenini belirtmektedir. İkinci parametre çevre değişkeninin değerinin yerleştirileceği
char türden dizinin adresini almaktadı ı ı
karakter sayı ı ı
dizi için gereken uzunluğu (null karakter dahil olacak biçimde) bize verir. Windows sistemlerinde bir çevre değişkeninin maksimum değeri
32768 karakter olabilmektedir.
Fonksiyonda hata kontrolü yapı ı
GetEnvironmentVariable fonksiyonu yine 0 değerine geri dönecektir. O halde fonksiyonun 0 değerine dönmesinin iki gerekçesi olabilir. Birincisi
çevre değişkenini bulamaması ı ı
zaman GetLastError fonksiyonu ile durum tespit edilmelidir.
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#define BUFFER_SIZE 4096
int main(void)
{
char value[BUFFER_SIZE];
DWORD dwResult;
dwResult = GetEnvironmentVariable("PATH", value, BUFFER_SIZE);
if ((dwResult == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND)) {
fprintf(stderr, "envirionment variable not found!..\n");
exit(EXIT_FAILURE);
}
if (dwResult > BUFFER_SIZE) {
fprintf(stderr, "buffer too small, requşred size: %u\n", dwResult);
exit(EXIT_FAILURE);
}
puts(value);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde ve macOS sistemlerinde program çalı ı
isimli POSIX fonksiyonları ı ı ı ı ı ı
prosesin bütün çevre değişkenleri zaten yok edilmektedir.
setenv fonksiyonunun protoripi şöyledir:
#include <stdlib.h>
int setenv(const char *envname, const char *envval, int overwrite);
Fonksiyonun birinci parametresi çevre değişkeninin ismini (anahtar değeri), ikinc parametresi ise değerini almaktadı
sı ı ı ı ı ı ı ı ı ı
olduğu durumda artı ı ı
eçre değişkeninin değeri değişmez.
Aşağı ı ı ı ı ı
sonra da get ederek yazdı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
char *value;
if (argc != 3) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if (setenv(argv[1], argv[2], 1) == -1)
exit_sys("setenv");
if ((value = getenv(argv[1])) == NULL) {
fprintf(stderr, "environment variable not found: %s\n", argv[1]);
exit(EXIT_FAILURE);
}
puts(value);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
putenv fonksiyonunu ele almadan önce tipik bir UNIX türevi işletim sisteminin çevre değişkenlerini bellekte nası ı
istiyoruz. Çevre değişkenleri için "environ" isminde global bir göstericiyi gösteren gösterici bulundurulmaktadı
bir gösterici dizisini göstermektedir. Gösterici dizisinin sonunda NULL adres vardı
environ (char **) -----> adres (char *) -----> "anahtar=değer"
adres (char *) -----> "anahtar=değer"
adres (char *) -----> "anahtar=değer"
...
adres (char *) -----> "anahtar=değer"
adres (char *) -----> "anahtar=değer"
NULL
Örneğin getenv fonksiyonu aslı ı
karakterinin sağı ı
çevre değişken bloğuna anahtarı
environ (char **) -----> adres (char *) -----> "anahtar=değer" (malloc ile tahsis edilmiş)
adres (char *) -----> "anahtar=değer" (malloc ile tahsis edilmiş)
adres (char *) -----> "anahtar=değer" (malloc ile tahsis edilmiş)
...
adres (char *) -----> "anahtar=değer" (malloc ile tahsis edilmiş)
adres (char *) -----> "anahtar=değer" (malloc ile tahsis edilmiş)
YENİ EKLENEN ADRES -----> "CITY=ankara" (burası
NULL
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
putenv isimli POSIX fonksiyonu da prosesin çevre değişkenlerine ekleme yapmak için kullanı
#include <stdlib.h>
int putenv(char *string);
Fonksiyon parametre anahtar=değer" biçiminde yazı ı ı ı ı ı ı ı ı
ek yaparken environ göstericisini gösterdiği yeri malloc ile tahsis etmemktedir. Doprudna bizim verdiğimiz adresi o gösterisi dizisine
yazmaktadı ı ı ı ı ı ı
char buf[] = "COUNTRY=turkey";
putenv(buf);
Bu işlemi yaptı ı
environ (char **) -----> adres (char *) -----> "anahtar=değer"
adres (char *) -----> "anahtar=değer"
adres (char *) -----> "anahtar=değer"
...
adres (char *) -----> "anahtar=değer"
adres (char *) -----> "anahtar=değer"
YENI EKLENEN ADRES (buf) -----> "COUNTRY=turkey"
NULL
Dolayı ı ı ı ı
0 değerine, başarı ı ı ı ı ı ı
putenv fonksiyonu ile olan bir çevre değişkeninin değerini de değiştirebiliriz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
void exit_sys(const char *msg);
int main(void)
{
char *value;
if (putenv("CITY=istanbul") != 0) /* string'ler statik ömürlüdür */
exit_sys("putenv");
if ((value = getenv("CITY")) == NULL) {
fprintf(stderr, "cannot find environment variable!..\n");
exit(EXIT_FAILURE);
}
puts(value);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde çevre değişkenini değiştirmek ve çevre değişken bloğuna yeni bir çevre değişkeni eklemek için SetEnvironmentVariable
isimli API fonksiyonu kullanı ı
BOOL SetEnvironmentVariable(
LPCTSTR lpName,
LPCTSTR lpValue
);
Fonksiyonun birinci parametresi çevre değişkeninin ismini (yani anahtarı ı ı ı
durumunda sı ı ı ı ı ı ı
onun değerini değiştirmektedir. Fonksiyonun ikinci parametresi NULL adres geçilebilir. Bu durumda ilgili eçvre değişkeni silinmektedir.
SetEnvironmentVariable fonksiyonunda ikinci parametre NULL adres geçilirse ilgili çevre değişkeni silinmektedir. Ancak çevre değişkenlerinin
silinmesi seyrek olarak karşı ı ı
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#define SIZE 4096
int main(void)
{
char val[SIZE];
DWORD dwResult;
if (!SetEnvironmentVariable("CITY", "Ankara")) {
fprintf(stderr, "Cannot set environment variable!..\n");
exit(EXIT_FAILURE);
}
if ((dwResult = GetEnvironmentVariable("CITY", val, SIZE)) == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
fprintf(stderr, "Environment variable not found!..\n");
exit(EXIT_FAILURE);
}
if (dwResult > SIZE) {
fprintf(stderr, "Insufficient buffer!..\n");
exit(EXIT_FAILURE);
}
printf("%s\n", val);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
39. Ders 04/11/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Nası ı
Ancak oluşturulmuş çevre değişkenlerinin değerlerinin değiştirilmesi çok karşı ı
çok seyrek karşı ı
girilierek ilgili çevre dğeişkeni silinebilir. Örneğin:
if (!SetEnvironmentVariable("CITY", NULL)) {
fprintf(stderr, "Cannot set environment variable!..\n");
exit(EXIT_FAILURE);
}
UNIX/Linux sistemlerinde çevre değişkenlerinin silinmesi için unsetenv POSIX fonksiyonu kullanı ı
#include <stdlib.h>
int unsetenv(const char *name);
Fonksiyon silinecek çevre değişkeninin ismini (anahtarı ı ı ı
başarı ı ı
Aşağı ı ı ı ı
elde edilmeye çalı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#define SIZE 4096
int main(void)
{
char val[SIZE];
DWORD dwResult;
if ((dwResult = GetEnvironmentVariable("PATH", val, SIZE)) == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
fprintf(stderr, "Environment variable not found!..\n");
exit(EXIT_FAILURE);
}
if (dwResult > SIZE) {
fprintf(stderr, "Insufficient buffer!..\n");
exit(EXIT_FAILURE);
}
printf("%s\n", val);
if (!SetEnvironmentVariable("PATH", NULL)) {
fprintf(stderr, "Cannot set environment variable!..\n");
exit(EXIT_FAILURE);
}
if ((dwResult = GetEnvironmentVariable("PATH", val, SIZE)) == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
fprintf(stderr, "Environment variable not found!..\n");
exit(EXIT_FAILURE);
}
if (dwResult > SIZE) {
fprintf(stderr, "Insufficient buffer!..\n");
exit(EXIT_FAILURE);
}
printf("%s\n", val);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde prosesin tüm çevre değişkenlerini elde edebilmek için environ isimli global göstericiyi gösteren göstericiden
faydalanı ı ı ı ı ı ı ı
environ değişkeninin extern bildirimini kendisinin yapması
extern char **environ;
environ global değişkeninin bir gösterici dizisini gösterdiğini ve bu dizinin sonunda NULL adres bulunduğunu anı ı ı
environ (char **) -----> adres (char *) -----> "anahtar=değer"
adres (char *) -----> "anahtar=değer"
adres (char *) -----> "anahtar=değer"
...
adres (char *) -----> "anahtar=değer"
adres (char *) -----> "anahtar=değer"
NULL
Tabii biz bu biçimde eçre değişkenlerini elde edeken onları ı
'=' karaketerini dikkate alarak ayrı ı ı ı
Ancak çevre değişken bloğunu mümkün olduğunca değiştirmeye çalı ı ı
Aşağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
extern char **environ;
int main(void)
{
char *str;
for (int i = 0; environ[i] != NULL; ++i)
puts(environ[i]);
puts("--------------------------");
for (int i = 0; environ[i] != NULL; ++i) {
if ((str = strchr(environ[i], '=')) != NULL) {
*str = '\0';
printf("%s --> %s\n", environ[i], str + 1);
*str = '=';
}
}
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde "env" isimli kabuk komutu kabuğun çevre değişken listesini tı ı ı ı ı ı
görüntülemektedir. Programcı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde GetEnvironmentStrings isimli API fonksiyonu çevre değişken listesini tek bir adresle aşağı
Anahtar=Değer\0Anahtar=Değer\0Anahtar=Değer\0\0
Fonksiyonun prototipi şöyledir:
LPCH GetEnvironmentStrings(VOID);
Burada LPCH aslı ı ı ı ı
Windows'ta komut satı ı ı ı
Aşağı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
int main(void)
{
LPCH envStr;
if ((envStr = GetEnvironmentStrings()) == NULL) {
fprintf(stderr, "Cannot get environment strings!..\n");
exit(EXIT_FAILURE);
}
while (*envStr != '\0') {
puts(envStr);
envStr += strlen(envStr) + 1;
}
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Prosesin tüm çevre değişken bloğunu yok etmek için Windows sistemlerinde FreeEnvironmentStrings API fonksiyonu kullanı ı
BOOL FreeEnvironmentStringsA(
LPCH penv
);
Fonksiyon parametre olarak GetEnvirionmentStrings fonksiyonundan elde edilen adresi almaktadı ı ı ı
değere başarı ı ı ı ı ı
Fonksiyonun prototipi şöyledir:
#include <stdlib.h>
int clearenv(void);
Fonksiyon başarı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Peikiyi prosesin çevre değişkenlerinden kim ve nası ı ı ı ı
(ya da bazen programlar tarafı ı ı
yaparlar. Örneğin biz Microsoft ya da gcc derleyicilerinde derleme işlemini yaparken açı ı
berlirtilmiş olan include dosyaları ı ı ı
Ancak komut satı ı ı ı
include dosyaları ı ı ı ı
Aşağı ı ı ı ı ı
Örneğin biz bir program yazacak olalı ı ı ı ı ı ı ı ı
dizinde "data.dat" isminde bulunabilir. Ancak programı ı ı ı ı ı ı
Bunun için biz DATA_LOCATION isminde bir çevre değişkeni uydurabiliriz. Programı ı ı
yol ifadesini bu çevre değişkenine yazması ı ı ı ı
#define DEFAULT_DATA_PATH "data.dat"
...
char *data_path;
FILE *f;
...
if ((data_path = getenv("DATA_LOCATION")) == NULL)
data_path = DEFAULT_DATA_PATH;
if ((f = fopen(data_path, "r+b")) == NULL) {
fprintf(stderr, "cannot open data file: %s\n", data_path);
exit(EXIT_FAILURE);
}
Buarada eğer kullanı ı ı ı ı
Eğer kullanı ı ı ı
edilecektir.
Çevre değişkenlerini işletim sistemi düzeyindeki global değişkenler gibi düşünebilirsiniz. Bunları ı
Kursumuz ilerledikçe çeşitli eçvre değişkenlerinin kim tarafı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Çevre değişkenleri üst prosesten alt prosese aktarı ı ı ı ı ı
çalı ı ı ı
ekleyebiliriz.
UNIX/Linux sistemlerinde komut satı ı ı ı ı ı
Komutun genel biçimi şöyledir:
export değişken=değer
Örneğin:
export CITY=Ankara
Eğer değer boşluk içeriyorsa tı ı
export CITY="NewYork City"
Değişken bir kere export edildikten sonra artı ı
CITY=Trabzon
Aynı ı ı
set CITY=Ankara
Bu sistemlerde değeri değiştirmek için yeniden set kullanmak zorunludur.
UNIX/Linux sistemlerinde komut satı ı ı
Örneğin:
$ export CITY=ankara
$ $CITY
ankara: komut bulunamadı
Burada $CITY yazı ı ı ı ı ı ı ı ı
komutu yazı ı ı ı ı
$ echo bugün hava çok güzel
bugün hava çok güzel
O halde bir eçvre değişkeninin değerini ekrana "echo $isim" komutunu uygulayarak yazdı
$ echo $CITY
ankara
Eğer bir çevre değişkeni yoksa kabul $isim yerine boşluk karakteri yerleştirmektedir. Yani bu durum bir hataya yol açmamaktadı
Windows'ta çevre değişkenini değeriyle değişirmek için %isim% sentaksı ı ı
C:\>set CITY=ankara
C:\>echo %CITY%
ankara
Şimdi de bir çevre değişkeninin değerinin sonuna ekeleme yaapalı
$ export CITY=Ankara
$ echo $CITY
Ankara
$ CITY=$CITY"-Istanbul"
$ echo $CITY
Ankara-Istanbul
Şimdi aynı ı
C:\>set CITY=Ankara
C:\>echo %CITY%
Ankara
C:\>set CITY=%CITY%-Istanbul
C:\>echo %CITY%
Ankara-Istanbul
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Biz kabuk üzerinde kabuk komutları ı
listesine eklenmektedir. Başka bir terminal penceresi açtı ı ı ı
kabuk çalı ı ı ı ı ı ı ı
biri ayrı ı ı
genel Windows ve UNIX/Linux (macOS'te UNIX türevi bir sistem gibidir) sistemlerinde farklı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde bir kabuk programı ı ı ı ı ı ı ı ı ı ı ı
Kabuk programları ı ı ı ı ı ı ı
neler olduğu kabuktan kabuğa ve kabuğun çalı ı ı
değineceğiz. bash kabuğunun baktı ı ı ı ı ı ı ı ı
çalı ı ı
1) Interactive login shell
2) Interactive nopn-login shell
3) Non-interactive shell
Burada "interactive" sözcüğü komut satı ı ı ı ı ı ı ı ı ı
düşülür. Buradaki "login shell" kabuk çalı ı ı ı ı ı ı ı
tek bir komut çalı ı ı ı ı ı ı ı
biz bash programı ı ı ı ı ı ı ı ı
açı
programı ı ı ı ı
Nihayet biz bash programı ı ı ı ı ı ı ı ı ı ı ı ı ı
da "non-interactive" çalı ı
1) Eğer bash "interactive login shell" biçiminde çalı ı ı ı ı
komutları ı ı ı ı ı
çalı ı ı
2) Eğer bash "interactive non-login shell" biçiminde çalı ı ı ı ı ı ı ı ı
dosyası ı ı ı ı
bash programı ı ı
https://www.gnu.org/software/bash/manual/html_node/Bash-Startup-Files.html
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
40. Ders 05/11/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde aslı ı ı ı ı ı ı ı ı
(terminal programı ı ı ı ı ı
alt prosese aktarı ı ı ı ı ı
Bunu sağlamak için Windows 11'de "Ayarlar/Sistem Bilgisi/Gelişmiş Sistem Ayarları ı ı
alt alta iki bölüm bulunmaktadı ı ı
değişkenlerini belirtmektedir. Eğer biz bir çevre dğeişkeninin belli bir kullanı ı ı ı ı
ile giriş yapı ı ı ı
başka kullanı ı ı ı
o anda çalı ı ı ı ı
durumlarda programlardan çı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi proses içerisinde pek çok çevre dğeişkeni görmekteyiz. Bunlar nereden gelmektedir? Aslı
edilirken peşi sı ı ı ı ı ı ı ı ı ı ı
prosesler yeni çevre değişkenlerini eklerler. Böylece çevre değişkenleri arta arta oluşmaktadı ı
yukarı ı ı ı ı ı
"user name/password" login isimli program tarafı ı ı ı ı
dosyası ı
Kabul programı ı ı ı ı ı ı ı ı ı
prosese eklemektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Daha önceden de belirttiğimiz gibi çalı ı ı ı
prosesi izlemek için ismine "Proses Kontrol Block (Process Control Block)" bir veri yapı ı ı
koruma mekanizması ı ı ı
programı ı ı ı ı ı ı ı ı
İşletim sistemlerinde pek çok özellik prosese özgdür. Örneğin her prosesin ayrı ı ı
Her prosesin açtı ı ı ı ı ı ı ı
sistemlerin çoğunda "heap" alanı
Eskiden proseslerin tek bir akı ı ı ı ı
modern işlem sistemleri "multithread" çalı ı ı ı ı ı
programı ı ı ı ı ı ı ı ı
"thread" denilmektedir. Bir proses tek bir akı ı ı
yaratmaktadı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bugün kullandı ı ı ı ı ı ı
oluşturmaktadı ı ı
Çalı ı ı ı ı ı ı
CPU'dan alı ı ı ı ı ı ı ı ı
(time quantum)" denilmektedir. Quanta süreleri işlemcinin hı ı ı
Quanta süresi uzun tutulursa interaktivite azalı ı ı ı ı ı ı ı
sürekli çalı ı ı ı ı ı ı ı ı ı ı ı ı
atanı ı ı ı ı ı ı
denilmektedir. Tabii context switch işlemi de belli bir zman almaktadı
"çizelgeleyici (scheduler)" denilmektedir.
Bugün bilgisayarları ı ı ı ı ı ı ı ı
Nası ı ı ı ı ı
oluşmuyorsa aynı
çekirdek için ayrı ı ı ı ı ı
(Yani örneğin bir CPU ya da çekirdeğin açlı ı ı ı
CPU'ya atanan bir thread'in quanta süresini bitirdiğinde CPU'dan kopartı ı ı ı ı
"preemtive" sistemler denilmektedir. Bazı ı ı ı
isteğiyle bı ı ı ı ı ı ı
sistem gibi düşünülebilir. Bu tür işletim sistem sistemlerine "non-preemptive" sistemler ya da "cooperative multitask" sistemler denilmektedir.
Örneğin Windows 3.X işletim sistemleri, PalmOS işletim sistemleri böyle sistemlerdi. Ancak günümüzde sistemler hep preemtive biçimdedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Prosesler konusunda en temel işlem bir prosesin yaratı ı ı ı ı ı ı ı
çalı ı ı ı ı ı ı ı ı
Windows'ta bir dosyaya çift tı ı ı ı ı
sistem fonksiyonları ı ı ı ı ı ı ı ı ı
için Windows'ta sistem fonksiyonları ı ı ı ı ı
Biz bu bölümde öcne Windows sistemlerinde sonra UNIX/Linux ve macOS sistemlerinde proses yaratı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde proses yaratmak için (yani bir programı ı ı ı ı
Fonksiyonun prototipi şöyledir:
BOOL CreateProcess(
LPCTSTR lpApplicationName,
LPSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCSTR lpCurrentDirectory,
LPSTARTUPINFO lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
);
Fonskiyonun birinci parametresi çalı ı ı ı ı
Fonksiyonun ikinci parametresi programı ı ı ı ı ı ı ı ı
oluşturulur. Ancak bu parametrenin const olamayan bir gösterici olduğuna dikkat ediniz. Fonksiyon verilen adreste değişiklik yapı
onu eski haline getirmektedir. Bu nedenle ikinci parametrenin bir string olarak girilmemesi gerekir. (C'de stringlerin karakterlerinin
değiştirilmesi tanı ı ı ı ı ı ı ı ı ı ı ı
gösterici dizisine yerleştirilmekte ve main fonksiyonun argv parametresi bu biçimde oluşturulmaktadı ı ı ı ı
programı ı
char szCmdLine[] = "C:\\windows\\notepad.exe test.txt";
...
CreateProcess("C:\\windows\\notepad.exe", szCmdLine, ...);
Burada "C:\windows\notepad.exe" programı ı ı ı ı ı ı ı
C:\\windows\\notepad.exe
test.txt
Program için uzantı ı ı ı
Fonksiyonun birinci parametresi NULL adres geçilebilmektedir. Bu durumda çalı ı ı
olarak belirlenmektedir. Örneğin:
char szCmdLine[] = "C:\\windows\\notepad.exe test.txt";
...
CreateProcess(NULL, szCmdLine, ...);
Burada birinci parametre NULL adres geçilmiştir. Bu durumda fonksiyon ikinci parametrededki ilk string'i çalı ı ı
ele alı ı ı ı ı ı ı ı
NULL geçip çalı ı ı ı ı ı ı ı ı ı ı
boşluklardan parse edildiği için dikkat etmek gerekir. Windows eğer iki tı ı ı ı ı
Örneğin ikinci parametre şöyle girilmiş olsun:
"c:\\program files\\sub dir\\program name"
Burada sistem sı ı ı ı ı ı ı ı
c:\program.exe
c:\program files\sub.exe
c:\program files\sub dir\program.exe
c:\program files\sub dir\program name.exe
Bu tür durumlarda boşluk içeren kı ı ı ı
"\"c:\\my folder\\prog.exe\" ali veli selami"
CreateProcess fonksiyonunun ikinci parametresinde önemli bir özellik vardı
CreateProcess fonksiyonun birinci NULL geçilip ikinci parametresindeki ilk boşluksuz yazı
bölü karakteri kullanı ı ı ı ı ı
aranması ı ı ı ı
1) CreateProcess uygulayan prosesin ".exe" dosyası ı
2) CreateProcess uygulayan prosesin çalı
3) 32 Bit Windows Sistem Dizini ("Windows" dizininin içerisindeki "System32" dizini)
4) 16 bit Windows Sistem Dizini ("Windows" dizininin içerisindeki "System" dizini)
5) Windows dizininin kendisi
6) CreateProcess uygulayan prosesin PATH çevre değişkininde belirtlen dizinler sı ı
Tabii bu sı ı ı
nokta şudur. Yukarı ı ı ı
ilk boşluksuz yazı ı ı
çevre değişkenine dikkat ediniz. Eğer CreateProcess söz konusu dosyayı
belirtilen dizinlerde de aramaktadı ı ı
Her ";" arası ı
C:\Program Files (x86)\VMware\VMware Player\bin\;C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.4\bin;
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.4\libnvvp;C:\Program Files\Java\jdk-11.0.2\bin;
C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\WINDOWS\System32\WindowsPowerShell\v1.0\;
...
O halde CreateProcess son maddedeki aramaya yapmak için PATH çevre değişkeninin değerini elde etmekte ve buradaki yazı ı
ayrı ı ı ı ı ı
bulunan dizindeki program çalı ı ı ı
Windows'un komut satı ı ı ı ı ı ı ı ı ı
bu "cmd.exe" tarafı ı ı ı ı ı
PATH çevre değişkeni ile belirtilen dizinlerde de aranacaktı ı ı ı ı ı ı
onun çalı ı ı
CreateProcess fonksiyonunun üçüncü ve dördüncü parametreleri (lpProcessAttributes ve lpThreadAttributes) kernel tarafı ı
proses ve thread nesnelerinin güvenlik bilgilerini (yetki derecelerini) belirtmektedir. Ancak Windows sistemlerinde proseslerin yetki dereceleri
UNIX/Linux sistemlerindeki kadar basit değildir. Biz bu kursta bu konu üzerinde durmayacağı ı
ele alı ı ı
Windows işletim sisteminde "kernel nesnesi (kernel object)" denildiğinde kendi HANDLE değeri olan kernel tarafı
anlaşı ı ı ı ı
"kernel nesnesi" grubundadı ı
fonksiyonuyla boşaltı ı ı
yaratı ı ı ı ı ı
CreateProcess fonksiyonunun beşinci parametresi (bInheritHandles) kernel nesnelerinin yaratı ı ı ı ı
belirtmektedir. Bu bir ana şalter görevindedir. Bu parametreye sı ı ı ı ı ı ı
sı ı ı ı ı ı ı ı
o kernel nesnenin bireysel olarak alt proseslere aktarı
ilgili kernek nesnesi yaratı ı ı ı ı ı ı
Programcı
CreateProcess fonksiyonunun altı ı ı ı ı ı
Bu parametreye bazı ı
Ancak thread'ler konusunda buraya atı ı
Fonksiyonun yedinci parametresi (lpEnvironment) yaratı ı
bloğun adresi geçirilmelidir:
değişken=değer\0değişken=değer\0....değişken=değer\0\0
Eğer bu parametreye NULL adres geçilirse alt prosesin çevre değişken listesi üzet prosesten alı ı
adres geçilmektedir.
Fonksiyonun sekizinci parametresi (lpCurrentDirectory) oluşturulacak olan alt prosesin çalı
isterse alt proses yaratı ı ı ı ı
Bu durumda alt prosesin çalı ı
CreateProcess fonksiyonunun dokuzuncu parametresi STARTUPINFO isimli bir yapı ı ı ı
içini doldurmalı ı ı
belirlenmesi amacı ı ı ı ı ı ı ı ı ı ı ı
sı ı ı ı ı ı ı ı
ilk elemanı ı ı ı ı
ileride elemanlar eklenebilmektedir. Bu durumda yapı ı ı ı ı ı ı ı ı
Bu yapı ı ı ı ı ı ı
STARTUPINFO si = {sizeof(STARTUPINFO)};
Fonksiyonun onuncu ve son parametresi (lpProcessInformation) PROCESS_INFORMATION isimli bir yapı ı
yapı ı ı ı ı ı ı ı
typedef struct _PROCESS_INFORMATION {
HANDLE hProcess;
HANDLE hThread;
DWORD dwProcessId;
DWORD dwThreadId;
} PROCESS_INFORMATION, *PPROCESS_INFORMATION, *LPPROCESS_INFORMATION;
Bir proses yaratı ı ı ı ı
nesnelerinin handle değerleri ve id değerleri vardı
geçilememektedir.
Fonksiyon başarı ı ı ı ı ı ı ı ı ı
Fonksiyonun örnek bir kullanı ı
char szPath[] = "notepad.exe";
STARTUPINFO si = {sizeof(STARTUPINFO)};
PROCESS_INFORMATION pi;
...
if (!CreateProcess(NULL, szPath, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
ExitSys("CreateProcess");
Aşağı ı ı ı ı
çalı ı ı ı ı ı
için yukarı ı ı
uygulanacaktı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* Prog1.c */
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
char szPath[] = "prog2.exe prog1.c";
char env[] = "ALI=10\0Veli=20\0";
STARTUPINFO si = {sizeof(STARTUPINFO)};
PROCESS_INFORMATION pi;
if (!CreateProcess(NULL, szPath, NULL, NULL, TRUE, 0, env, "c:\\windows", &si, &pi))
ExitSys("CreateProcess");
Sleep(1000);
printf("Ok\n");
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(int argc, char *argv[])
{
LPCH envStr;
char cwd[MAX_PATH];
printf("Prog2 command line arguments:\n");
printf("--------------------------\n");
for (int i = 0; i < argc; ++i)
puts(argv[i]);
printf("--------------------------\n");
printf("Prog2 environment variables:\n");
if ((envStr = GetEnvironmentStrings()) == NULL) {
fprintf(stderr, "Cannot get environment strings!..\n");
exit(EXIT_FAILURE);
}
while (*envStr != '\0') {
puts(envStr);
envStr += strlen(envStr) + 1;
}
printf("--------------------------\n");
printf("Prog2 current workşng directory:\n");
if (!GetCurrentDirectory(MAX_PATH, cwd))
ExitSys("GetCurrentDirectory");
printf("%s\n", cwd);
printf("--------------------------\n");
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı ı ı ı ı ı
farklı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
char szPath[] = "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe", csystem.org cumhuriyet.com\"";
STARTUPINFO si = { sizeof(STARTUPINFO) };
PROCESS_INFORMATION pa;
if (!CreateProcess(NULL, szPath, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pa))
ExitSys("CreateProcess");
printf("Ok\n");
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı
"kernel nesneleri" denilmektedir. Tüm kernel nesneleri prosese özgü "proses handle tablosu" denilen bir tabloda giriş belirtmektedir.
Tüm kernel nesnelerinin yok edilmesi (ya da kapatı ı ı ı ı
PROCESS_INFORMATION yapı ı ı ı ı ı
olmanı ı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
char szPath[] = "notepad.exe";
STARTUPINFO si = {sizeof(STARTUPINFO)};
PROCESS_INFORMATION pi;
if (!CreateProcess(NULL, szPath, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
ExitSys("CreateProcess");
printf("Ok\n");
CloseHandle(pi.hThread);
CloseHandle(pi.hProcess);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
CreateProcess API fonksiyonu bir kernel fonksiyonudur. Yani en alt seviyedki proses yaratan fonksiyondur. Windows'ta kernel API fonksiyonları ı
yanı ı ı ı ı
fonksiyonlardı ı ı ı ı ı ı ı ı
seviyeli API fonksiyonu CreateProcess fonksiyonudur. Ancak ShellExecute isimli bir shell API fonksiyonu da bulunmaktadı
fonksiyonu yüksek seviyeli bir fonksiyondur ve nihai olarak CreateProcess fonksiyonunu çağı ı
üzerinde de duracağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
ShellExecute kabuk fonksiyonunun en önemli özelliği "dosya ilişkilendirmesini" dikkate alması ı
".docx" dosyası ı ı ı ı ı ı
programı ı ı ı ı ı ı ı ı ı ı ı
Hangi uzantı ı ı ı ı
manuel işlem yapabilmek için "regedit" isimli bir program da bulundurulmaktadı ı ı ı ı
ya da komut satı ı ı ı ı ı ı ı ı ı ı ı
Dosya ilişkilendirmelerine bakan ShellExecute fonksiyondur. Ancak proses aslı ı ı ı
ShellExecute ---> Dosya ilişkilendirmesine bak ----> CreateProcess
ShellExecute API fonksiyonunun parametrik yapı ı
HINSTANCE ShellExecuteA(
HWND hwnd,
LPCSTR lpOperation,
LPCSTR lpFile,
LPCSTR lpParameters,
LPCSTR lpDirectory,
INT nShowCmd
);
Fonksiyonun birinci parametresi (hwnd) UI mesajları ı ı ı ı
durmayacağı ı ı ı ı
almaktadı ı
"edit"
"explore"
"find"
"open"
"print"
"runas"
Program çalı ı ı ı
Fonksiyonun üçüncü parametresi (lpFile) işlem uygulanacak dosyanı
Burada belirtilen dosya çalı ı ı ı ı ı ı ı
dosyalar kastedişmektedir) olabilir. Yukarı ı ı ı
program dosyası ı ı ı ı ı ı ı ı ı ı ı ı ı
ve bu dosya ismi hiç "\" içermiyorsa yine CreateProcess fonksiyonunda açı ı ı ı ı ı
Fonksiyonun dördüncü parametresi (lpParameters) üçüncü
parametre çalı ı ı ı ı ı ı ı ı
geçilebilir. Beşinci parametre (lpDirectory) çalı ı ı ı ı
durumda ShellExecute fonksiyonunu uygulayan prosesin çalı ı ı
hangi boyutta açı ı ı
(restore boyutunda) açı ı
ShellExecute fonksiyonu başarı
korumak için HINSTANCE olarak alı ı ı ı ı ı ı
adres ile aynı ı
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <shellapi.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HINSTANCE hResult;
hResult = ShellExecute(NULL, "open", "test.txt", NULL, NULL, SW_NORMAL);
if ((INT_PTR)hResult < 32)
ExitSys("ShellExecute");
printf("Ok\n");
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
ShellExecute fonksiyonunun ikinci parametresinde "explore" komutu kullanı ı ı ı
bir dizin belirtmesi gerekmektedir. Aşağı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <shellapi.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HINSTANCE hResult;
hResult = ShellExecute(NULL, "explore", "c:\\windows", NULL, NULL, SW_NORMAL);
if ((INT_PTR)hResult < 32)
ExitSys("ShellExecute");
printf("Ok\n");
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
42. Ders 12/11/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi Windows'ta kendi uzantı ı ı ı ı ı ı ı ı ı ı
komut satı ı ı ı ı ı ı ı
ilgili dokğman dosyası ı ı ı ı ı ı
yapmamı ı ı ı ı ı ı
olarak da yapı ı ı ı ı
Programlama yoluyla dosya ilişkilendirmesi için hazı ı
"Resgistry API'leri" denilen API fonksiyonları ı ı ı
Registry işlemlerini yapabilmek için hangi ayarı
dokümanları
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde her prosesin sistem genelinde tek (unique) olan bir "proses id" değeri vardı
temsil edilen tamsayı
Anı ı ı ı ı
parametresi yoluyla elde edebiliyorduk. Windows sistemlerinde proses id değerleri sistem genelinde tek olduğu halde handle değerleri tek
değildir. Biz bir proses nesnesini her açtı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Proseslerle ilgili sı
fonksiyonuyla yapı ı ı ı ı ı
etmek için kullanı ı
#include <psapi.h>
BOOL EnumProcesses(
DWORD *lpidProcess,
DWORD cb,
LPDWORD lpcbNeeded
);
Fonksiyonun birinci parametresi prosslerin id değerlerinin yerleştirileceği DWORD dizinin adresini almaktadı
birinci parametresindeki dizinin byte uzunluğunu (eleman uzunluğunu değil) belirtmektedir. Üçüncü parametre ise diziye yerleştirilen
byte sayı ı ı ı ı ı ı ı ı ı
başarı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <Psapi.h>
#define NPROC_IDS 4096
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
DWORD dwProcessIds[NPROC_IDS];
DWORD dwNeeded;
DWORD i;
if (!EnumProcesses(dwProcessIds, sizeof(dwProcessIds), &dwNeeded))
ExitSys("EnumProcesses");
for (i = 0; i < dwNeeded / sizeof(DWORD); ++i)
printf("%lu\n", (unsigned long)dwProcessIds[i]);
printf("%lu process Ids listed...\n", dwNeeded / sizeof(DWORD));
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Sistemdeki prosesler hakkı
gereksinim vardı ı ı
Fonksiyonun prototipi şöyledir:
HANDLE OpenProcess(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
DWORD dwProcessId
);
Fonksiyonun birinci parametresi açı ı ı ı ı
Buradaki bayrak değerleri PROCESS_XXXX biçiminde isimlendirilmiş sembolik sabitlerden oluşmaktadı
parametreye en azı ı ı
bu handle değerinin alt prosese aktarı
id değerini belirtmektedir. Fonksiyon başarı ı ı ı
Windows sistemlerinde bir proses nesnenin açı ı ı ı ı
bu fonksiyonla id değerini bildiğimiz her prosesi açamayı
Windows sistemlerinde bağı ı ı
uygulama bir "exe dosya" ve birtakı ı ı ı
fonksiyonuyla yapı ı
BOOL EnumProcessModules(
HANDLE hProcess,
HMODULE *lphModule,
DWORD cb,
LPDWORD lpcbNeeded
);
Fonksiyonun birinci parametresi prosesin handle değerini belirtmektedir. İkinci parametre proses modüllerinin handle değerlerinin yerleştirileceği
HMODULE türünden dizinin adresini almaktadı
bu dizinin byte uzunluğunu (eleman uzunluğunu değil) belirtmektedir. Fonksiyonun son parametresi diziye yerleştirilen byte sayı ı ı ı
(eleman sayı ı ı ı ı ı ı ı ı ı ı ı
durumunda sı ı
Nihayet modülün handle değerindne hareketle GetModuleBaseName API fonksiyonu ile modülün ismi elde edilebilmektedir. Fonksiyonun prototipi
şöyledir:
DWORD GetModuleBaseName(
HANDLE hProcess,
HMODULE hModule,
LPSTR lpBaseName,
DWORD nSize
);
Fonksiyonun ilk iki parametresi sı ı
yerleştirileceği dizinin adresini alı
başarı ı ı ı ı ı
Aşağı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <psapi.h>
#define NPROCESSES 4096
#define NMODULES 4096
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
DWORD dwProcessIds[NPROCESSES];
DWORD cbNeeded;
HANDLE hProcess;
HMODULE hModules[NMODULES];
DWORD dwProcessCount;
DWORD dwModuleCount;
char szModuleName[MAX_PATH];
if (!EnumProcesses(dwProcessIds, sizeof(dwProcessIds), &cbNeeded))
ExitSys("EnumProcesses");
dwProcessCount = cbNeeded / sizeof(DWORD);
for (DWORD i = 0; i < dwProcessCount; ++i) {
if ((hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, dwProcessIds[i])) == NULL)
continue;
if (!EnumProcessModules(hProcess, hModules, sizeof(hModules), &cbNeeded)) {
CloseHandle(hProcess);
continue;
}
dwModuleCount = cbNeeded / sizeof(DWORD);
for (DWORD k = 0; k < dwModuleCount; ++k) {
if (!GetModuleBaseName(hProcess, hModules[k], szModuleName, MAX_PATH))
continue;
if (k == 0) {
printf("%s: ", szModuleName);
continue;
}
if (k != 1)
printf(", ");
printf("%s", szModuleName);
}
printf("\n\n");
CloseHandle(hProcess);
}
printf("%lu process(es) listed...\n", dwProcessCount);
getchar();
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
C derleyicilerinin çok büyük kı ı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
Bunun için Microsoft derleyicilerinde /D seçeneği, gcc ve clang derleyicilerinde -D seçeneği kullanı ı ı
sembolik sabitin ismini almaktadı
cl -D TestXXX sample.c
Burada sanki "sample.c" dosyası ı ı ı ı ı
#define TestXXX
Tabii sembolik sabite değer de verilebilir. Örneğin:
cl /D TestXXX=123 sample.c
Burada da sanki kaynak kodun tepesinde aşağı ı ı
#define TestXXX 123
Aynı ı ı
gcc /D TestXXX=123 -o sample sample.c
Tabii IDE'lerle bu seçenkler görsel biçimde de oluşturulabilmektedir. Microsoft Visual Studio IDE'sinde bu işlem için proje seçeneklerinden
"Properties/C-C++ Preprocessor/Preprocessor Definitions" edit alanı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
C standartları ı
başlı ı
<stddef.h>
<stdlib.h>
<wchar.h>
C standartları ı
derleyicileri yazanları ı ı ı ı
gcc ve clang derleyicilerinde ise wchar_t türü unsigned int olarak typedef edilmiştir.
wchar_t türü karakterleri bir byte'tan uzun olan karakter tabloları ı ı
wchar_t türünün hangi karakter tablosunu temsil edeceği konusunda bir belirlemede bulunmamı ı
wchar_t türü UNICODE UTF-16 encoding'ini temsil etmektedir. gcc ve clang derleyicilerinde ise wchar_t türü UNICODE UTF-32 encoding'ini
temsil etmektedir. C standartları ı
wchar_t ch = L'ş';
Benzer biçimde wchar_t türünden yazı ı
wchar_t s[] = L"ağrı ı
char_t *ps = L"kpnya ovası
Aşağı
wchar_t s[] = "ağrı ı
char k[] = L"ağrı ı
O halde bir fonksiyon bizden bir UNICODE yazı
fonksiyona yazı ı
C'deki klasik string fonksiyonları ı ı
kadar birer byte'lı ı ı ı ı ı ı
dosyası ı ı ı ı ı
bulundurulmuştur. char türü ile çalı ı ı ı
fonksiyonları ı ı ı
wcslen fonksiyonunu kullanmamı ı ı
ya da ilgili dokğmanlardan char türü ile çalı ı ı ı ı
Örneğin:
wchar_t s[] = L"ali";
wprintf(L"%zd\n", wcslen(s));
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Eskiden Windows'un 3'lü versiyonları ı ı ı ı
kernel ASCII olarak çalı ı ı ı ı ı
tam tersine UNICODE olarak çalı ı ı ı ı ı
Windows kernel kodları ı ı ı ı ı ı ı ı
dönüştürülerek işleme sokulmaktadı
Bugün Windows sistemlerinde bütün yazı ı ı ı ı ı
parametresi alan API fonksiyonunun ismi XXX olmak üzere aslı ı ı
fonksiyonu yoktur. Örneğin CreateFile isimli bir API fonksiyonu aslı ı ı
İşte ileride açı ı ı ı ı ı ı ı
CreateFileW biçimine dönüştürülmektedir.
Pekiyi XXX isimli bir API fonksiyonu önişlemci tarafı ı
bir sembolik sabit kullanı ı ı ı ı ı
#ifdef UNICODE
#define CreateFile CreateFileW
#define CreateProcess CreateProcessW
#define SetCurrentDirecory SetCurrentDirectoryW
...
#else
#define CreateFile CreateFileA
#define CreateProcess CreateProcessA
#define SetCurrentDirecory SetCurrentDirectoryA
...
#endif
Görüldüğü gibi yazı ı ı ı ı
UNICODE sembolik sabiti define edilmemişse program ASCII uyumlu define edilmişse UNICODE uyumlu hale gelmektedir. Eğer bu sembolik sabit
define edilecekse <windows.h> dosyası ı ı ı ı ı ı
IDE'sinde bu işlem de görsel olarak yapı
eğer "Use Unicode Character Set" olarak girilirse aslı ı ı ı ı ı ı ı
Dolayı ı ı ı ı ı ı ı ı ı ı
Tabii bu seçenek seçilmezse UNICODE sembolik sabiti define edilmemiş olacağı ı ı ı ı ı
Ancak programı ı ı ı ı ı ı ı ı ı
fonksiyonları ı ı ı ı ı
Aşağı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#define UNICODE
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCWSTR lpszMsg);
int main(void)
{
HANDLE hFile;
if ((hFile = CreateFile(L"test.txt", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
ExitSys(L"CreateFile");
printf("success...\n");
CloseHandle(hFile);
return 0;
}
void ExitSys(LPCWSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPWSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fwprintf(stderr, L"%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir Windows programı ı ı ı
yapı ı ı
dikkat etmek gerekmektedir:
1) Program içerisindeki tüm string'ler TEXT makrosuyla ya da _TEXT makrosuyla kullanı ı ı
ise <tchar.h> içerisinde bulunmaktadı ı ı ı ı
include edilmesi yeterlidir. Ancak biz _TEXT makrosunu kullanacaksak <tchar.h> dosyası ı ı
her iki dosyayı ı ı ı
C için daha uygun gibi görünmektedir. İki makronun da yaptı ı ı ı
sembolik sabitine bakmaktadı ı ı ı
#ifdef UNICODE
#define TEXT(s) L##s
#else
#define TEXT(s) s
#endif
_TEXT makrosu ise şöyle yazı ı ı
#ifdef _UNICODE
#define _TEXT(s) L##s
#else
#define _TEXT(s) s
#endif
Genellikle programcı ı
"character set" UNICODE olarak değiştirildiğinde her iki sembolik sabit de define edilmektedir.
2) char türü yerine TCHAR isimli typedef türünün kullanı ı
türü anlamı ı
#ifdef UNICODE
#define TCHAR wchar_t
#else
#define TCHAR char
#endif
Karakter sabitleri için de <tchar.h> içerisindeki _T makrosu kullanı ı
#ifdef _UNICODE
#define _T(c) L##c
#else
#define _T(c) c
#endif
3) LPCSTR const char * anlamı ı ı ı
T li versiyonlar yine UNICODE sembolik sabitine bağlı ı
gösterici parametreleri ya TCHAR * ve const TCHAR * biçiminde ya da LPTSTR ve LPCTSTR biçiminde belirtilmelidir. Burada örneğin LPCSTR
türü ile LPCTSTR türü arası ı
göre const char * duruma göre ise const wchar_t * anlamı
4) Standart C fonksiyonları ı ı ı
kullanı ı ı ı ı
Her standart C fonksiyonun Windows sistemlerindeki UNICODE uyumlu ismi bilinmelidir. Örneğin _tprintf ismi printf fonksiyonun UNICODE
uyumlu ismidir. Bu isim _UNICODE sembolik sabiti define edilmişse wprintf olarak, edilmemişse printf olarak değiştirilmektedir.
5) Microsoft aslı ı ı
bir fonskiyon yoksa da Microsoft Windows sistemlerinde main fonksiyonunun UNICODE versiyonu wmain biçimindedir. Yani siz eğer main fonksiyonunun
argv parametresinin UNICODE olması ı ı ı ı ı ı
_tmain biçimindedir. O halde main fonksiyonu da şöyle tanı
int _tmain(int args, TCHAR *argv[])
{
//...
}
Aşağı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <tchar.h>
void ExitSys(LPCTSTR lpszMsg);
int _tmain()
{
HANDLE hFile;
TCHAR path[MAX_PATH] = _TEXT("test.txt");
if ((hFile = CreateFile(path, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
ExitSys(_TEXT("CreateFile"));
_tprintf(_TEXT("Ok"));
CloseHandle(hFile);
return 0;
}
void ExitSys(LPCTSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
_ftprintf(stderr, _TEXT("%s: %s"), lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Şimdi de daha önce ASCII uyumlu olarak yazdı ı ı ı ı ı
Programda yukarı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <psapi.h>
#include <tchar.h>
#define NPROCESSES 4096
#define NMODULES 4096
void ExitSys(LPCTSTR lpszMsg);
int _tmain(void)
{
DWORD dwProcessIds[NPROCESSES];
DWORD cbNeeded;
HANDLE hProcess;
HMODULE hModules[NMODULES];
DWORD dwProcessCount;
DWORD dwModuleCount;
TCHAR szModuleName[MAX_PATH];
if (!EnumProcesses(dwProcessIds, sizeof(dwProcessIds), &cbNeeded))
ExitSys(_TEXT("EnumProcesses"));
dwProcessCount = cbNeeded / sizeof(DWORD);
for (DWORD i = 0; i < dwProcessCount; ++i) {
if ((hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, dwProcessIds[i])) == NULL)
continue;
if (!EnumProcessModules(hProcess, hModules, sizeof(hModules), &cbNeeded)) {
CloseHandle(hProcess);
continue;
}
dwModuleCount = cbNeeded / sizeof(DWORD);
for (DWORD k = 0; k < dwModuleCount; ++k) {
if (!GetModuleBaseName(hProcess, hModules[k], szModuleName, MAX_PATH))
continue;
if (k == 0) {
_tprintf(_TEXT("%s: "), szModuleName);
continue;
}
if (k != 1)
_tprintf(_TEXT(", "));
_tprintf(_TEXT("%s"), szModuleName);
}
_tprintf(_TEXT("\n\n"));
CloseHandle(hProcess);
}
_tprintf(_TEXT("%lu process(es) listed...\n"), dwProcessCount);
getchar();
return 0;
}
void ExitSys(LPCTSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
_ftprintf(stderr, _TEXT("%s: %s"), lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Programları ı ı
Bütün POSIX fonksiyonları ı ı ı
yoktur. Zaten Linux sistemlerinde UNICODE gerektiği zaman UNICODE UTF-8 encoding'i kullanı ı
oluşturduğu için char * türü ile ifade edilebilmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir proses sonlandı ı ı ı
bir değerdir. İşletim sistemleri bu exit kodunu alı
proses) isterse ona verilmektedir. Böylece biz bir programı ı ı ı ı ı ı ı ı ı
bakarak anlayabiliriz. Proseslerin exkit kodları ı
başarı ı ı ı ı ı ı ı ı ı ı ı
Bir C programı ı ı ı ı
void exit(int status);
Ayrı ı
standartları
#define EXIT_SUCCESS 0
#define EXIT_FAILURE 1
Pekiyi biz hiç exit fonksiyonunu çağı ı
exit kodu olmaktadı ı ı ı ı ı
Pekiyi bir program normal dı ı ı
void abort(void);
Bir program abort fonksiyonuyla sonlanı ı ı
olur. Dolayı ı ı ı ı ı
UNIX/Linux kabuk programları ı ı ı ı
$ ./sample
$ echo $?
123
Aynı ı ı ı
C:\>sample
C:\>echo %errorlevel%
123
C standartları ı ı ı
bloğu bitirerek main sonlanmı ı ı
int main(void)
{
...
return 0;
}
ile aşağı ı ı ı
int main(void)
{
...
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
44. Ders 19/11/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Tipik olarak bir prosesin sonlandı ı ı ı ı ı ı ı
zaten main bittiğinde çağrı ı ı ı ı ı
çağı ı
Ancak exit standart C fonksiyonu bundan önce sı ı ı
1) atexit fonksiyonuyla kaydettirilmiş olan fonksiyonları ı ı ı
2) Açı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde prosesi sonlandı
fonksiyonu bu fonksiyonu çağı ı
void ExitProcess(UINT uExitCode);
Fonksiyon parametre olarak prosesin exit kodunu almaktadı ı ı ı
fonksiyonları ı ı
çağrı ı ı ı ı ı ı
tamponları ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde bir proses bir program çalı ı ı ı ı ı ı ı ı
elde edebilmektedir. Bu işlemi yapabilen herhangi bir standart C fonksiyonu yoktur. Fonksiyonun prototipi şöyşedir:
BOOL GetExitCodeProcess(
HANDLE hProcess,
LPDWORD lpExitCode
);
Fonksiyonun birinci parametresi exit kodun elde edileceği prosesin handle değerini belirtmektedir. İkinci parametresi exit kodunun
yerleştirileceği DWORD türünden nesnenin adresini almaktadı ı ı ı ı ı ı ı ı
sı ı
Aşağı ı ı ı ı ı ı
ile elde etmiştir. Programlar UNICODE/ASCII uyumlu biçimde yazı ı ı ı ı ı ı ı ı ı
WaitForSingleObject fonksiyonuyla beklemektedir. Bu fonksiyonu thread'ler konusunda ele alacağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* prog1.c */
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <tchar.h>
void ExitSys(LPCTSTR lpszMsg);
int main(void)
{
TCHAR szPath[] = _TEXT("prog2.exe");
STARTUPINFO si = {sizeof(STARTUPINFO)};
PROCESS_INFORMATION pi;
DWORD dwExitCode;
if (!CreateProcess(NULL, szPath, NULL, NULL, TRUE, CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi))
ExitSys(_TEXT("CreateProcess"));
_tprintf(_TEXT("waiting for process to exit...\n"));
if (WaitForSingleObject(pi.hProcess, INFINITE) == WAIT_FAILED)
ExitSys(_TEXT("WaitForSingleObject"));
if (!GetExitCodeProcess(pi.hProcess, &dwExitCode))
ExitSys(_TEXT("GetExitCodeProcess"));
if (dwExitCode == STILL_ACTIVE) {
_tprintf(_TEXT("Proces still active...\n"));
exit(EXIT_FAILURE);
}
_tprintf(_TEXT("Exit Code: %lu\n"), dwExitCode);
CloseHandle(pi.hThread);
CloseHandle(pi.hProcess);
return 0;
}
void ExitSys(LPCTSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
_ftprintf(stderr, _TEXT("%s: %s"), lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/* prog2.c */
#include <stdio.h>
#include <tchar.h>
int _tmain(void)
{
_tprintf(_TEXT("press ENTER to exit...\n"));
getchar();
return 123;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
exit standart C fonksiyonu ve ExitProcess API fonksiyonu kendi prosesini sonlandı ı ı
da isteyebiliriz. Bunun için Windows sistemlerinde TerminateProcess isimli API fonksiyonu kullanı ı
BOOL TerminateProcess(
HANDLE hProcess,
UINT uExitCode
);
Fonksiyonun birinci parametresi sonlandı ı ı ı
Fonksiyon başarı ı ı ı ı ı ı ı ı ı
TerminateProcess fonksiyonu geri döndüğünde proses sonlanmı ı ı ı ı
WaitForSingleObject gibi bir fonksiyonla beklenmesi uygun olur.
Her proses handle değerini bildiği her prosesi sonlandı ı
Windows'taki yetkisel özellikler karmaşı ı ı
ele alı ı
TerminateProcess fonksiyonu son çare olarak uygulanmalı ı ı ı ı ı ı ı ı ı ı ı ı
olumsuzluklar oluşturabilir. Proses kritik birtakı ı ı ı
Aşağı ı ı ı ı ı ı ı ı
kod yine UNICODE/ASCII uyumlu yazı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* prog1.c */
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <tchar.h>
void ExitSys(LPCTSTR lpszMsg);
int main(void)
{
TCHAR szPath[] = _TEXT("prog2.exe");
STARTUPINFO si = {sizeof(STARTUPINFO)};
PROCESS_INFORMATION pi;
DWORD dwExitCode;
if (!CreateProcess(NULL, szPath, NULL, NULL, TRUE, CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi))
ExitSys(_TEXT("CreateProcess"));
_tprintf(_TEXT("Press ENTER to to terminate child process...\n"));
getchar();
if (!TerminateProcess(pi.hProcess, 999))
ExitSys(_TEXT("TerminateProcess"));
if (WaitForSingleObject(pi.hProcess, INFINITE) == WAIT_FAILED)
ExitSys(_TEXT("WaitForSingleObject"));
if (!GetExitCodeProcess(pi.hProcess, &dwExitCode))
ExitSys(_TEXT("GetExitCodeProcess"));
if (dwExitCode == STILL_ACTIVE) {
_tprintf(_TEXT("Proces still active...\n"));
exit(EXIT_FAILURE);
}
_tprintf(_TEXT("Exit Code: %lu\n"), dwExitCode);
CloseHandle(pi.hThread);
CloseHandle(pi.hProcess);
return 0;
}
void ExitSys(LPCTSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
_ftprintf(stderr, _TEXT("%s: %s"), lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/* prog2.c */
#include <stdio.h>
#include <tchar.h>
#include <Windows.h>
int _tmain(void)
{
for (int i = 0; i < 100; ++i) {
_tprintf(_TEXT("%d\n"), i);
Sleep(1000);
}
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux ve macOS sistemlerinde her prosesin sistem genelinde tek olan (unique) bir "proses id" değeri vardı
sistemlerindeki gibi ayrı
yapmak için proses id değeri yetmektedir.
UNIX/Linux ve macOS sistemlerinde proseslerin id değerleri pid_t türü ile temsil edilmektedir. POSIX standartları
işaretli bir tamsayı ı ı
typedef edilmek zorundadı
UNIX/Linux sistemleri boot edildiğinde boot kodu kendini bir proses yapmakta ve 0 numaralı ı
"pager" da denilmektedir. Bu proses "init" isimli prosesi yaratmaktadı ı
her yaratı ı ı ı ı ı
UNIX/Linux sistemlerinde çekirdek proses id verildiğinde çok hı ı
Yani bu sistemlerde proses id'ler proses kontrol bloğuna erişmekte kullanı
tipik olarak bir hash tablosu kullanmaktadı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde proseslerin yaratı ı ı ı
yaratmak için fork isimli POSIX fonksiyonu kullanı ı
fonksiyonunu çağı ı ı
fonksiyonun artı ı ı ı
biridir.
fork fonksiyonu bir prosesin özdeş bir kopyası ı ı ı ı ı ı
1) Proses kontrol bloğunun yeni bir kopyası ı ı
içeriği bazı ı ı ı
etkin kullancı ı ı ı
2) Üst prosesin bellek alanı ı ı ı ı ı
iki ayrı ı ı ı ı ı
aynı ı
3) Yeni bir çizelgele elemanı ı ı ı ı ı
4) Çatallanma fork fonksiyonun içinde olmaktadı ı ı
Böylece hem üst proses hem de alt proses fork fonksiyonundan çı ı
fork fonksiyonun prototipi şöyledir:
#include <unistd.h>
pid_t fork(void);
Hem üst proses hem de alt proses fork fonksiyonundan çı ı
alt proseste ise 0 değeriyle geri dönmektedir. (Alt prosesin fork fonksiyonundan 0 ile geri dönmesi onun proses id'sinin 0 olduğu
anlamı ı ı
fork fonksiyonunun kullaı ı ı
pid_t pid;
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid != 0) { /* parent process */
...
}
else { /* chile process */
...
}
Üst prosesin ve alt prosesin her ikisin de fork fonksiyonundan çı ı ı ı
çı ı ı
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
pid_t pid;
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid != 0) { /* parent process */
printf("parent process...\n");
}
else {
printf("child process...\n"); /* child process */
}
printf("common code...\n");
sleep(1);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
fork işleminden sonra artı ı ı ı ı ı ı ı ı
etkilemez. Örneğin aşağı ı ı ı
g_x'tir. Dolayı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void exit_sys(const char *msg);
int g_x;
int main(void)
{
pid_t pid;
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid != 0) { /* parent process */
g_x = 10;
printf("parent: %d\n", g_x);
}
else {
sleep(1);
printf("child: %d\n", g_x);
}
printf("common code...\n");
sleep(1);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı ı
fork();
fork();
fork();
printf("common code...\n");
Birinci fork'a bir proses girer ondan 2 proses çı ı
ondan 8 proses çı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
pid_t pid;
if ((pid = fork()) == -1)
exit_sys("fork");
if ((pid = fork()) == -1)
exit_sys("fork");
if ((pid = fork()) == -1)
exit_sys("fork");
printf("common code...\n");
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
45. Ders 25/11/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
fork fonksiyonu başka bir programı ı ı ı ı ı ı ı ı ı ı
Oysa Windows'taki CreateProcess başka bir programı ı ı ı
yaramaktadı ı ı ı ı ı
Sonraki paragraflarda açı ı ı ı ı ı ı ı
Eskiden thread'ler yoktu. Bir işi birden fazla akı ı
alt proses aynı ı ı ı ı ı
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid != 0) { /* üst proses */
/* üst proses işin bir parçası ı ı
}
else { /* üst proses */
/* üst proses işin diğer bir parçası ı ı
}
Ancak artı ı ı ı ı ı ı
yaratı ı ı ı ı ı ı ı ı ı ı
de gerekmektedir. Bu koordinasyon için fork modelinde proseslerarası ı ı ı
Halbuki thread'ler global değişkenler yoluyla haberleşebilmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Başka program dosyası ı ı ı ı ı
kullanı ı ı ı ı ı
yapmaktadı ı ı
execl
execlp
execv
execvp
execle
execvpe
execve (Linux'ta yalnı
Aslı ı ı ı ı ı
bu execve fonksiyonunu çağı
exec fonksiyonları ı ı ı ı ı ı ı ı ı
fonksiyonları ı ı ı ı ı
exec yapan kod yok olacak exec işleminde belirtilen program dosyası ı ı ı ı
Dolayı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
En çok kullanı ı
#include <unistd.h>
int execl(const char *path, const char *arg0, ... /*, (char *)0 */);
Fonksiyonun birinci parametresi çalı ı ı ı ı
geçirilecek olan komut satı ı ı ı ı ı
kadar çok argümanla çağrı ı ı ı ı ı ı
adresleri olmalı ı
adresle bitirilmelidir. Ancak burada NULL adesi düz sı ı ı ı ı
argümanlarda düz sı ı ı ı ı ı
benzer soruna yol açabilmektedir. Bu nedenle programcı ı ı
uygun olmaktadı ı ı ı ı ı ı
execl fonksiyonu başarı ı ı ı ı
başka bir program kodu çalı ı
if (execl("/bin/ls", "/bin/ls", "-l", (char *)0) == -1)
exit_sys("execl");
Burada "/bin/ls" programı ı ı ı ı ı ı ı ı ı ı ı
argümanı ı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
printf("main begins...\n");
if (execl("/bin/ls", "/bin/ls", "-l", (char *)0) == -1)
exit_sys("execl");
/* unreachable code */
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı
if (execl("mample", "mample", "ali", "veli", "selami", (char *)0) == -1)
exit_sys("execl");
"mample" programı ı ı ı ı ı ı ı ı ı ı ı
main begins...
argv[0] ==> mample
argv[1] ==> ali
argv[2] ==> veli
argv[3] ==> selami
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* sample.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
printf("main begins...\n");
if (execl("mample", "mample", "ali", "veli", "selami", (char *)0) == -1)
exit_sys("execl");
/* unreachable code */
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/* mample.c */
#include <stdio.h>
int main(int argc, char *argv[])
{
for (int i = 0; i < argc; ++i)
printf("argv[%d] ==> %s\n", i, argv[i]);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Tek başı ı ı ı ı ı ı ı ı ı ı
O halde hem üst prosesin kodu çalı ı ı ı ı ı ı ı ı
önce bir kez fork yapı ı ı ı ı ı ı ı ı ı
bellek alanı ı ı ı ı ı ı ı ı ı
yüklenip çalı ı ı ı ı ı
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0) {
if (execl(....) == -1)
exit_sys("execl"); /* dikkat burada sonlanan alt proses */
/* unreachable code */
}
/* buraya yalnı ı ı
&& operatörünün kı ı
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0 && execl(....) == -1) {
exit_sys("execl"); /* dikkat burada sonlanan alt proses */
/* unreachable code */
}
/* buraya yalnı ı ı
Bazı ı ı ı ı
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0) {
execl(....);
exit_sys("execl"); /* exec başarı ı ı
}
/* buraya yalnı ı ı
Microsoft sistemlerindeki CreateProcess API fonksiyonunun fork/exec ikilisi gibi işlem gördüğüne dikkat ediniz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
pid_t pid;
printf("main begins...\n");
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0 && execl("/bin/ls", "/bin/ls", "-l", (char *)0) == -1)
exit_sys("execl");
for (int i = 0; i < 10; ++i) {
printf("%d\n", i);
sleep(1);
}
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
fork/exec modelinde etkin olmayan şöyle bir durum kişilerin aklı ı ı ı
üst prosesin bellek alanı ı ı ı
düşünülmektedir. Eski sistemlerde gerçekten bu bir sorundu. Bu nedenle fork fonksiyonun vfork isminde bir kardeşi bulundurulmuştu.
vfork fonksiyonunun fork fonksiyonundan tek farkı ı ı ı ı ı ı
sonra artı ı ı ı ı ı ı ı ı
Bugün vfork fonksiyonu POSIX standratları ı ı ı ı
UNIX/Linux sistemlerinin çalı ı ı ı ı
Bu mekanizma sayesinde aslı ı ı ı ı ı
denilmektedir. Dolayı ı ı ı ı
Bu nednele artı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* sample.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
pid_t pid;
printf("main begins...\n");
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0 && execl("mample", "mample", "ali", "veli", "selami", (char *)0) == -1)
exit_sys("execl");
for (int i = 0; i < 10; ++i) {
printf("%d\n", i);
sleep(1);
}
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/* mample.c */
#include <stdio.h>
int main(int argc, char *argv[])
{
printf("mample running...\n");
for (int i = 0; i < argc; ++i)
printf("argv[%d] ==> %s\n", i, argv[i]);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
execv (v vector'den geliyor) fonksiyonu execl fonksiyonun komut satı ı ı ı
tek bir parametreyle alan biçimidir. Yani çalı ı ı ı ı ı ı
bu dizinin adresi execv fonksiyonuna verilmektedir. Fonksiyonun prototipi şöyledir:
#include <unistd.h>
int execv(const char *path, char * const argv[]);
Fonksiyonun birinci parametresi çalı ı ı ı ı ı ı ı ı ı
bulunduğu dizinin başlangı ı ı ı ı ı ı ı
-1 değerine geri döner. Başrı ı ı ı
const char *args[] = {"ls", "-l", NULL};
...
if (execv("/bin/ls", args) == -1)
exit_sys("execv");
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
pid_t pid;
char *args[] = {"ls", "-l", NULL};
printf("main begins...\n");
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0 && execv("/bin/ls", args) == -1)
exit_sys("execl");
for (int i = 0; i < 10; ++i) {
printf("%d\n", i);
sleep(1);
}
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bazen execv fonksiyonu execl fonksiyonundan daha uygun olabilmektedir. Örneğin komut satı ı ı ı ı ı ı ı ı
istesek execl işimizi çok zorlaştı ı ı ı ı ı ı ı ı ı
çalı ı ı ı ı
./sample /bin/ls -l -i
Burada çalı ı ı ı ı ı ı ı ı ı ı ı ı
aynı ı ı ı ı ı ı ı ı ı
buradan başlayan bir gösterici dizisi gibidir. argv listesinin sonunda zaten NULL adres bulunmaktadı
bir biçimde yapı
if (execv(argv[1], &argv[1]) == -1)
exit_sys("execv");
Aşağı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
pid_t pid;
if (argc < 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0 && execv(argv[1], &argv[1]) == -1)
exit_sys("execl");
sleep(1);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
exec fonksiyonları ı ı ı
dosyayı ı ı
durumda dosya belirtilen yol ifadesinde aranı ı ı ı ı ı
bir fark olmaz.
execlp ve execvp fonksiyonları ı ı ı ı ı ı ı
"path" yerine "file" olarak isimlendirilmiştir:
#include <unistd.h>
int execlp(const char *file, const char *arg0, ... /*, (char *)0 */);
int execvp(const char *file, char *const argv[]);
PATH çevre değişkeni UNIX/Linux sistemlerinde ':' karakterinden ayrı ı ı ı ı ı ı ı ı ı
anı ı ı ı ı
/home/kaan/anaconda3/bin:/home/kaan/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
"/bin", "/usr/bin", "/usr/local/bin" gibi prgram dosyaları ı
Artı ı ı ı ı ı
olmalı ı ı ı ı ı ı ı ı ı ı ı
eğer çalı ı ı ı
sı ı ı ı ı
çalı ı ı ı ı ı
çalı ı ı
./sample
Bu programı ı ı ı ı ı
sample
Çünkü burada exec fonksiyonları ı ı ı
ile belirtilen dizinlerde arayacaktı ı ı ı ı
sokulduğu için exec fonksiyonları ı ı ı ı
anlamı ı ı ı ı ı
aranı ı
Pekiyi exec fonksiyonları ı ı ı ı
neden prosesin çalı ı ı ı
bakı ı ı ı ı ı ı ı ı ı
bir program dosyası ı ı ı ı ı ı ı ı ı ı ı ı
ismini yanlı ı ı ı ı ı ı ı ı ı
exec fonksiyonları ı ı ı
Aşağı ı ı ı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
pid_t pid;
if (argc < 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0) {
execvp(argv[1], &argv[1]);
exit_sys("execvp");
}
sleep(1);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
46. Ders 02/12/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı ı
komutu aslı ı ı ı ı ı ı ı
"cd" komutudur. (Zaten "cd" komutu bir program olarak yazı ı ı ı
(yani shell'in değil) kendi prosesinin çalı ı
Aşağı ı ı ı ı ı ı
henüz görmediğimiz wait isimli bir fonksiyonu kullandı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* myshell.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/wait.h>
#define MAX_CMD_LINE 4096
#define MAX_CMD_PARAMS 128
#define BUFFER_SIZE 8192
#define MAX_PATH_SIZE 4096
void parse_cmdline(void);
void cd_proc(void);
void exit_sys(const char *msg);
typedef struct tagCMD {
char *cmd_name;
void (*cmd_proc)(void);
} CMD;
char g_cmdline[MAX_CMD_LINE];
char *g_params[MAX_CMD_PARAMS];
int g_nparams;
CMD g_cmds[] = {
{"cd", cd_proc},
{NULL, NULL}
};
char g_cwd[MAX_PATH_SIZE];
int main(void)
{
char *str;
int i;
pid_t pid;
if (getcwd(g_cwd, MAX_PATH_SIZE) == NULL)
exit_sys("getcwd");
for (;;) {
printf("CSD:%s>", g_cwd);
if (fgets(g_cmdline, MAX_CMD_LINE, stdin) == NULL)
continue;
if ((str = strchr(g_cmdline, '\n')) != NULL)
*str = '\0';
parse_cmdline();
if (g_nparams == 0)
continue;
if (!strcmp(g_params[0], "exit"))
break;
for (i = 0; g_cmds[i].cmd_name != NULL; ++i)
if (!strcmp(g_cmds[i].cmd_name, g_params[0])) {
g_cmds[i].cmd_proc();
break;
}
if (g_cmds[i].cmd_name == NULL) {
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0 && execvp(g_params[0], &g_params[0]) == -1) {
printf("invalid command: %s\n", g_params[0]);
exit(EXIT_FAILURE);
}
if (wait(NULL) == -1)
exit_sys("wait");
}
}
return 0;
}
void parse_cmdline(void)
{
char *str;
g_nparams = 0;
for (str = strtok(g_cmdline, " \t"); str != NULL; str = strtok(NULL, " \t"))
g_params[g_nparams++] = str;
g_params[g_nparams] = NULL;
}
void cd_proc(void)
{
if (g_nparams == 1) {
printf("argument missing!..\n");
return;
}
if (g_nparams > 2) {
printf("too many arguments!..\n");
return;
}
if (chdir(g_params[1]) == -1) {
printf("%s: %s!..\n", g_params[1], strerror(errno));
return;
}
if (getcwd(g_cwd, MAX_PATH_SIZE) == NULL)
exit_sys("getcwd");
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
exec fonksiyonları ı ı ı ı ı ı ı
takı ı ı ı ı
#include <unistd.h>
int execle(const char *path, const char *arg0, ... /*, (char *)0, char *const envp[]*/);
int execve(const char *path, char *const argv[], char *const envp[]);
Bu fonksiyonlar p'li olmadı ı ı ı ı ı ı
yol ifadesini belirtmektedir. execle fonksiyonu önce komut satı ı ı ı ı ı
bulunmalı ı ı ı
girilmelidir. execve fonksiyonu ise hem komut satı ı ı ı ı
Her iki fonksiyon da yine başarı ı ı ı
UNIX/Linux sistemlerinde çevre değişkenlerinin genel olarak prsoesin bellek alanı ı ı ı
aslı ı ı ı ı ı ı
fonksiyonları ı ı ı ı ı
kaybolması ı ı ı ı ı ı ı
program için ayrı ı ı ı ı ı ı ı ı ı ı ı
değişkenleri üst prosesle aynı ı ı ı ı ı
işlemi sı ı ı ı ı
execle fonksiyonu tipik olarak şöyle kullanı ı
pid_t pid;
char *env[] = {"city=eskişehir", "plate=26", NULL};
...
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0 && execle("mample", "mample", "ali", "veli", "selami", (char *)NULL, env) == -1)
exit_sys("execl");
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* sample .c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
void exit_sys(const char *msg);
int main(void)
{
pid_t pid;
char *envs[] = {"city=eskişehir", "plate=26", NULL};
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0 && execle("mample", "mample", "ali", "veli", "selami", (char *)NULL, envs) == -1)
exit_sys("execl");
if (wait(NULL) == -1)
exit_sys("wait");
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/* mample.c */
#include <stdio.h>
extern char **environ;
int main(int argc, char *argv[])
{
printf("Command line arguments:\n");
for (int i = 0; i < argc; ++i)
printf("%s\n", argv[i]);
printf("\nEnvironment Variables:\n");
for (int i = 0; environ[i] != NULL; ++i)
puts(environ[i]);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı
değişkenlerinin gösterici dizisi biçiminde verildiğine dikkat ediniz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* sample.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
void exit_sys(const char *msg);
int main(void)
{
pid_t pid;
char *args[] = {"mample", "ali", "veli", "selami", NULL};
char *envs[] = {"city=eskişehir", "plate=26", NULL};
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0 && execve("mample", args, envs) == -1)
exit_sys("execl");
if (wait(NULL) == -1)
exit_sys("wait");
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/* mample.c */
#include <stdio.h>
extern char **environ;
int main(int argc, char *argv[])
{
printf("Command line arguments:\n");
for (int i = 0; i < argc; ++i)
printf("%s\n", argv[i]);
printf("\nEnvironment Variables:\n");
for (int i = 0; environ[i] != NULL; ++i)
puts(environ[i]);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aslı ı
fonksiyonları ı ı ı ı ı ı
argümanları ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* sample.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
void exit_sys(const char *msg);
int main(void)
{
pid_t pid;
char *args[] = {"./mample", "mample", "ali", "veli", "selami", NULL};
char *env[] = {"city=eskişehir", "plaka=26", NULL};
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0 && execve("./mample", args, env) == -1)
exit_sys("execve");
if (wait(NULL) == -1)
exit_sys("wait");
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/* mample.c */
#include <stdio.h>
extern char **environ;
int main(int argc, char *argv[])
{
int i;
printf("Command line arguments:\n");
for (i = 0; i < argc; ++i)
printf("%s\n", argv[i]);
printf("Environment Variables:\n");
for (i = 0; environ[i] != NULL; ++i)
puts(environ[i]);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
exec fonksiyonları ı ı ı ı ı ı
yol ifadesini değil onun dosya betimleyicisini alması ı ı ı
#include <unistd.h>
int fexecve(int fd, char *const argv[], char *const envp[]);
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı
fonksiyonu çekirdeğin içerisindedir. Diğer exec fonksiyonları ı
kütüphane içerisinde bulunmaktadı ı ı ı ı ı ı ı
yerleştirilip environ değişkenini kullanarak execve fonksiyonunu çağı ı ı
belirtilen dizinlerde tek tek execve uygulayarak aramaktadı ı ı ı
kütüphane fonksiyonu tarafı ı ı ı ı ı ı
"Advanced Programming in the UNIX Environment" kitabı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Çeşitli uzantı ı ı ı ı ı
bazen standardizasyon kurumları ı ı ı
ilişkin yüzlerce dosya formatı ı ı ı ı ı
Autocad kullanmamı ı ı
Dosya formatları ı ı ı ı ı ı
başlı ı ı ı ı ı ı ı
Bunun nedeni o dosya formatı ı ı ı ı ı ı ı
test etmesini sağlamaktı
İşte derleyicilerin ürettikleri "amaç dosyaları ı ı ı ı ı ı ı
da belli formatları ı ı ı ı ı
Microsoft'un kullandı ı ı ı
"OMF (Object Module Format)" basit bir format kullanı ı ı ı ı ı
dosya formatı ı ı ı
Bugün Linux sistemleri ve diğer UNIX türevi sistemler amaç dosya formatı ı ı ı ı
and Linkable Format)" denilen formatı ı ı ı ı ı ı ı
Uzun süredir macOS sistemlri Mach-O isimli bir amaç dosya ve çalı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
exec fonksiyonları ı ı ı ı ı ı ı
fonksiyonları ı ı ı
"shebang" denilmektedir. shebang karakterlerini gerçek çalı ı ı ı
karakterleri bulunabilir.) İşte exec fonksiyonları ı ı ı ı ı ı ı ı ı ı
dosyayı ı ı ı ı
sistem fonksiyonu olarak gerçekleştirilmiştir. Bu shebang kontrolü kernel tarafı ı ı
belirtilen çalı ı ı ı
istenmektedir. Ancak bugünkü sistemler göreli yol ifadelerini de kabul etmektedir. Buradaki dosya execve tarafı
bakı ı ı ı ı ı ı ı ı ı
tek bir komut satı ı ı ı ı ı ı ı ı
argümanları ı ı
Aşağı ı ı ı ı ı ı ı ı ı ı ı ı
Biz bu programla "test.txt" dosyası ı ı ı ı ı
#! /home/kaan/Study/SysProg/mample
Burada execp fonksiyonunda programı ı ı ı ı ı ı ı
kı ı
#! #! /home/kaan/Study/SysProg/mample
mample programı ı ı ı ı ı ı
argv[0]: /home/csd/Study/SysProg-2020/mample
argv[1]: ali veli selami
argv[2]: test.txt
argv[3]: xxx
argv[4]: yyy
Shebang içeren dosyanı ı ı
x hakları
chmod +x test.txt
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* sample.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
void exit_sys(const char* msg);
int main(int argc, char* argv[])
{
pid_t pid;
if (argc == 1) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0 && execv(argv[1], &argv[1]) == -1)
exit_sys("execv");
if (wait(NULL) == -1)
exit_sys("wait");
return 0;
}
void exit_sys(const char* msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
nt main(int argc, char* argv[])
{
int i;
for (i = 0; i < argc; ++i)
printf("argv[%d]: %s\n", i, argv[i]);
return 0;
}
test.txt
#!mample
/*------------------------------------------------------------------------------------------------------------------------------------------
Tabii aslı ı ı ı ı ı
bunları ı ı ı ı ı
#! /home/kaan/Study/SysProg/mample
Şimdi biz bu dosyayı ı ı ı ı ı ı ı ı ı ı ı
ve "test.txt" parametre olarak geçirilecektir. Örneğin:
$ ./test.txt
argv[0]: /home/kaan/Study/SysProg/mample
argv[1]: ./test.txt
$ ./test.txt xxx yyy
argv[0]: /home/kaan/Study/SysProg/mample
argv[1]: ./test.txt
argv[2]: xxx
argv[3]: yyy
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Shebang kullanı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
aşağı ı
#! /usr/bin/python3
for i in range(10) :
print(' {}'.format(i))
Biz bu "sample.py" dosyası ı ı ı ı ı ı ı ı ı ı ı ı
"sample.py" komut satı ı ı ı ı ı ı ı ı
python3 sample.py
Windows sistemlerinde shebang gibi bir kullanı ı ı
dosya ilişkilendirmesine baktı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#!/usr/bin/python3
for i in range(10) :
print(' {}'.format(i))
/*------------------------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı ı
sanki bir program gibi çalı ı ı ı ı ı
gerekir. Örneğin aşağı ı ı ı ı ı ı
#!/bin/bash
for n in {1..10};
do
echo $n
done
Çalı ı ı
./sample.sh
Aslı ı ı ı ı ı ı
/bin/bash sample.sh
-------------------------------------------------------------------------------------------------------------------------------------------*/
#!/bin/bash
for n in {1..10};
do
echo $n
done
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir çalı ı ı ı ı ı ı ı
gibi çalı ı ı ı
for n in {1..10};
do
echo $n
done
Buradaki dosyanı ı ı ı ı
çalı ı ı ı ı ı ı ı ı ı ı ı ı
yoksa bu kez onu script dosyası ı ı ı ı ı ı ı
başı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
47. Ders 03/12/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Biz Windows sistemlerinde prosesin exit kodunu GetExitCodeProcess isimli API fonksiyonuyla elde etmiştik. WaitForSingleObject fonksiyonunu
ise Proses sonlanana kadar beklemek için kullanmı ı ı ı ı ı
UNIX/Linux sistemlerinde alt proses sonlanana kadar bekleme işlemi ve alt prosesin exit kodunu alma işlemi wait, waitpid ve waitid isimli
üç POSIX fonksiyonu kullanı ı ı ı ı ı
önemli işlevi vardı ı
fonksiyonu vardı ı ı ı
hepsinin prototipleri <sys/wait.h> dosyası
#include <sys/wait.h>
pid_t wait(int *status);
Fonksiyon parametre olarak alt prosesin exit kodunun ve sonlanma biçiminin (buna "status" de denilmektedir) yerleştirileceği int nesnenin
adresini almaktadı ı ı ı ı
Fonksiyon çağrı ı ı ı
alt prosese kadar bekleme yapar. Eğer fonksiyon çağrı ı ı ı
herhangi birinin durumunu (status) elde ederek hemen geri döner. Fonksiyonun ilk sonlanmı
edilmemiştir. Fonksiyonun parametresi NULL adres de geçilebilir. Bu durumda fonksiyon yine bekleme işlevini yerine getirir ancak alt prosesin
durum bilgisini programcı ı ı
parametre olarak NULL adres geçebilir.)
Fonksiyonun bize verdiği durumsal bilgide hem prosesin nası ı ı ı
neresinde depolandı ı ı ı ı
wait fonksiyonun parametresine geçirilen int nesneyi parametre olarak almaktadı
sinyal dolayı ı ı ı ı ı ı ı
int nesne içerisindeki prosesin exit kodu WEXITSTATUS makrosuyla elde edilmektedir. Tabii programcı ı
exit kodunu bu makroyla almaya çalı ı ı
int status;
...
if (wait(&status) == -1)
exit_sys("wait");
if (WIFEXITED(status))
printf("Exit code: %d\n", WEXITSTATUS(status));
else /* if (WIFSIGNALED(status)) */
printf("child terminates via signal!..\n");
Aşağı ı ı ı ı ı ı ı ı ı ı ı ı
"sample" programı ı ı ı ı
$ ./sample mample
Buradaki "mample" programı ı ı ı ı
Sonra da "sample" programı ı ı ı
$ ./sample /bin/ls
Pek çok UNIX/Linux sisteminde prosesin exit kodu 1 byte uzunlukta işaretsiz tamsayı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
void exit_sys(const char* msg);
int main(int argc, char* argv[])
{
pid_t pid;
int status;
if (argc == 1) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0 && execv(argv[1], &argv[1]) == -1)
exit_sys("execv");
printf("parent process waiting for the child to exit...\n");
if (wait(&status) == -1)
exit_sys("wait");
if (WIFEXITED(status))
printf("child exited with %d\n", WEXITSTATUS(status));
else /* if (WIFSIGNALED(status)) */
printf("child terminates via signal!..\n");
return 0;
}
void exit_sys(const char* msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/* mample.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char* argv[])
{
for (int i = 0; i < 10; ++i) {
printf("%d\n", i);
sleep(1);
}
exit(123);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı
göreceksiniz:
child created: 3471
child running...
child created: 3472
child running...
child created: 3473
child (3472) terminated with 20
child running...
child (3471) terminated with 10
child (3473) terminated with 30
Tabii buradaki alt proseslerin sonlanma sı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <sys/wait.h>
void exit_sys(const char* msg);
int main(void)
{
pid_t pid1, pid2, pid3, pid;
int status;
if ((pid1 = fork()) == -1)
exit_sys("fork");
if (pid1 == 0) {
printf("child running...\n");
exit(10);
}
else
printf("child created: %jd\n", (intmax_t)pid1);
if ((pid2 = fork()) == -1)
exit_sys("fork");
if (pid2 == 0) {
printf("child running...\n");
exit(20);
}
else
printf("child created: %jd\n", (intmax_t)pid2);
if ((pid3 = fork()) == -1)
exit_sys("fork");
if (pid3 == 0) {
printf("child running...\n");
exit(30);
}
else
printf("child created: %jd\n", (intmax_t)pid3);
for (int i = 0; i < 3; ++i) {
if ((pid = wait(&status)) == -1)
exit_sys("wait");
if (WIFEXITED(status))
printf("child (%jd) terminated with %d\n", (intmax_t)pid, WEXITSTATUS(status));
else /* if (WIFSIGNALED(status)) */
printf("child terminates via signal!..\n");
}
return 0;
}
void exit_sys(const char* msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
waitpid fonksiyonu wait fonksiyonunun daha gelişmiş bir biçimidir. Fonksiyonun prototipi şöyledir:
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *status, int options);
Fonksiyonun birinci parametresi beklenecek prosesin id'sini belirtmektedir. Anı ı
bekliyordu. Oysa waitpid fonksiyonunda biz fonksiyonun hangi alt prosesi bekleyeceğini belirleyebiliyoruz. Fonksiyonun ikinci parametresi
yine durum bilgisinin yerleştirileceği int nesnesnenin adresini almaktadı ı ı
ya da birden fazlası ı ı
WCONTINUED
WNOHANG
WUNTRACED
Bu parametre 0 da geçilebilmektedir. WNOHANG bekleme yapmadan alt prosesin sonlanı ı ı ı ı ı ı
Fonksiyonun birinci parametresi özel olarak -1 biçiminde girilirse herhangi bir alt proses beklenir. Başka bir deyişle wait(&status) çağrı ı
ile waitpid(-1, &status, 0) çağrı ı ı ı
proseslerden herhangi bir beklenmektedir. Eğer pid değeri -1 değerindne küçükse fonksiyon bu negatif değerin mutlak değerine ilişkin proses
grubunundaki herhangi bir alt prosesi beklemektedir. Proses grupları ı ı
parametresi NULL adres geçilebilir. Bu durumda alt proses beklenir ancak durumsal bilgi elde edilmez.
waitpid fonksiyonu da başarı ı ı ı
Aşağı ı ı ı ı
ile bekleme alt proseslerin yaratı ı ı ı ı ı ı ı ı ı ı ı ı
$ ./sample
child created: 3313
child created: 3314
child running...
child created: 3315
child running...
child running...
child (3313) terminated with 10
child (3314) terminated with 20
child (3315) terminated with 30
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <sys/wait.h>
void exit_sys(const char* msg);
int main(void)
{
pid_t pids[3], pid;
int status;
if ((pids[0] = fork()) == -1)
exit_sys("fork");
if (pids[0] == 0) {
printf("child running...\n");
sleep(3);
exit(10);
}
else
printf("child created: %jd\n", (intmax_t)pids[0]);
if ((pids[1] = fork()) == -1)
exit_sys("fork");
if (pids[1] == 0) {
printf("child running...\n");
sleep(2);
exit(20);
}
else
printf("child created: %jd\n", (intmax_t)pids[1]);
if ((pids[2] = fork()) == -1)
exit_sys("fork");
if (pids[2] == 0) {
printf("child running...\n");
sleep(1);
exit(30);
}
else
printf("child created: %jd\n", (intmax_t)pids[2]);
for (int i = 0; i < 3; ++i) {
if ((pid = waitpid(pids[i], &status, 0)) == -1)
exit_sys("wait");
if (WIFEXITED(status))
printf("child (%jd) terminated with %d\n", (intmax_t)pid, WEXITSTATUS(status));
else /* if (WIFSIGNALED(status)) */
printf("child terminates via signal!..\n");
}
return 0;
}
void exit_sys(const char* msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux dünyası ı ı
üst prosesten önce sonlanı ı ı
düşünerek onun proses kontrol bloğunu ve dolayı ı
blokları ı ı ı ı
bloğu ve proses id'si sistem tarafı ı ı ı ı ı ı ı ı ı ı ı
olsa da binlerce alt proses yaratan ve bunları ı
getirecek derecede ciddi sonuçlar oluşturabilmektedir. İşte sonlandı ı ı ı ı ı
UNIX/Linux dünyası ı ı ı ı ı
Zaten zombie sözcüğü tam ölememiş, yaşamakla ölmek arası ı ı
bulunmamaktadı
Zombie'lik ancak üst proses devam ederken alt proses sonlanmı ı
içerisinde oluşmaktadı ı ı ı ı
alt prosesin kaynakları ı ı
Eğer üst proses alt prosesten daha önce sonlanı
bir proses öksüz duruma geldiğinde 1 numaralı ı
prosesi de öksüz proses sonlandı ı ı ı ı
Aşağı ı ı ı
Başka bir ekrandan girip ps komutuyla bu proseslere bakı ı ı ı
<defunct> ibaresinin bulunduğunu göreceksiniz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
void exit_sys(const char* msg);
int main(void)
{
pid_t pid;
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0) { /* child process */
exit(EXIT_SUCCESS);
}
printf("Press ENTER to exit...\n");
getchar();
return 0;
}
void exit_sys(const char* msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bazen üst proses alt prosesi yarattı ı ı ı
uygulamadı ı ı ı ı ı
sistemlerde iki yolu vardı
1) Üst proses SIGCHLD sinyalini set eder. Alt proses sonlandı ı
sintyalde asenkron biçimde wait uygular.
2) Üst proses işin başı ı
kaynakları ı
Biz bu kursumuzda UNIX/Linux sistemlerinde "sinyal (signal)" kavramı ı ı
ele alı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Anı ı ı ı ı ı ı ı
handle değeri vermektedir. Bu dosya betimleyicisi read, write, lseek, close fonksiyonları ı ı ı
için kullanı ı ı ı ı
ettiğini bilmesi gerekmektedir.
UNIX/Linux sistemlerinde proses kontrol blok içerisinde "dosya betimleyici tablosu (file descriptor table)" bir tablonun adresini tutan
bir eleman vardı
açı ı ı
Proses Kontrol Blok
...
... Dosya Betimleyici Tablosu
...
pfds ----------------> 0 adres --------------------------> Dosya Nesnesi
... 1 adres --------------------------> Dosya Nesnesi (aşağı ı
... 2 adres --------------------------> Dosya Nesnesi (yukarı ı
... 3 BOŞ
4 BOŞ
5 BOŞ
...
1022 BOŞ
1023 BOŞ
Örneğin Linux çekirdeğinde proses kontrol blok "task_struct" isimli yapı ı
temsil edilmiş durumdadı ı
her elemana bir slot da diyebiliriz. Buradaki her elemanı ı ı ı ı ı
dosya betimleyici tablosunun ilk üç slotu (yani 0, 1 ve 2 numaralı ı
aslı ı ı
klavyeyi temsil eden terminal aygı ı ı
temsil eden terminal aygı ı ı ı ı ı
klavyeden okuma yapı ı ı ı ı ı ı ı ı ı
open fonksiyonu ile bir dosya açı ı ı
boş slotun bu nesneyi göstermesini sağlar ve dosya betimleyicisi olarak bu slotun numarası ı
Örneğin yukarı ı ı
Proses Kontrol Blok
...
... Dosya Betimleyici Tablosu
...
pfds ----------------> 0 adres --------------------------> Dosya Nesnesi
... 1 adres --------------------------> Dosya Nesnesi (aşağı ı
... 2 adres --------------------------> Dosya Nesnesi (yukarı ı
... 3 adres --------------------------> Dosya Nesnesi
4 BOŞ
5 BOŞ
...
1022 BOŞ
1023 BOŞ
Burada bize dosya betimeleyicisi olarak 3 değeri verilecektir.
open fonksiyonunun dosya betimelyici tablosundaki ilk boş betimleyiciyi vermesi garanti edilmiştir. Yukarı
UNIX/Linux sistemlerinde proses çalı ı ı ı ı ı ı
3 numaralı
Aşağı ı ı ı ı ı
numaralı ı ı ı ı ı ı ı
edilmiştir. Çünkü open fonksiyonu her zaman eldeki ilk boş betimleyiciyi vermektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
int fd1, fd2, fd3;
if ((fd1 = open("test.txt", O_RDONLY)) == -1)
exit_sys("open");
printf("%d\n", fd1); /* 3 */
if ((fd2 = open("test.txt", O_RDONLY)) == -1)
exit_sys("open");
printf("%d\n", fd2); /* 4 */
close(fd1);
if ((fd3 = open("test.txt", O_RDONLY)) == -1)
exit_sys("open");
printf("%d\n", fd3); /* 3 */
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
48. Ders 09/12/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir dosya ile ilgili işlem yaapabilmek için gereken her şey "dosya nesnesi (file object)" içerisinde bulunmaktadı
normal bir dosyaya ilişkin olabildiği gibi aygı ı ı
read, write, lseek, close gibi işlemlerde çağrı ı ı
fd ----> Dosya Nesnesi
...
okuma fonksiyonunun adresi
yazma fonksiyonun adresi
konumlandı
kapatma fonksiyonun adresi
...
Böylece örneğin bir betimleyici kullanı ı ı ı ı
bulunan okuma fonksiyonunu çağı ı ı ı ı ı ı ı ı ı
mekanizmayı ı
ssize_t sys_read(int fd, ...)
{
1) prosesin dosya betimeleyici tablosunun fd numaralı ı
2) Dosya nesnesinde belirtilen okuma fonksiyonunu çağı
}
write fonksiyonu ve temel dosya fonksiyonları
Aygı ı ı ı ı ı ı ı ı
write ile yazma yapı ı ı ı ı ı ı ı ı ı ı
yapı ı ı ı ı ı ı ı ı ı ı ı
artı ı ı ı
aslı ı ı ı ı ı ı ı ı ı
betimelyici ekranı ı ı ı ı ı ı ı ı
içerisindeki bir fonksiyonu çağı ı ı ı ı ı
kapatma işlemlerinin dı ı ı ı ı
tarafı ı ı ı
DeviceIOControl isimli API fonksiyonu bulunmaktadı ı ı ı ı
da user mode programlar tarafı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Linux sistemlerinde bir prosesin dosya betimleyici tablosu default olarak 1024 elemanlı ı ı ı
1024 dosyayı ı ı ı
proses onları ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
int fd;
int i;
for (i = 0;; ++i) {
if ((fd = open("test.txt", O_RDONLY)) == -1) {
perror("open");
break;
}
printf("%d\n", fd);
}
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Linux sistemlerinde bir proses isterse dosya betimelyici tablosunu 1048576 kadar büyütebilir. Bunun için setrlimit POSIX fonksiyonu
kullanı ı ı
kursumuzun kapsamı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/resource.h>
void exit_sys(const char *msg);
int main(void)
{
int fd;
struct rlimit rl;
rl.rlim_cur = 5000;
rl.rlim_max = 5000;
if (setrlimit(RLIMIT_NOFILE, &rl) == -1)
exit_sys("setrlimit");
printf("%ld\n", sysconf(_SC_OPEN_MAX));
for (int i = 0;; ++i) {
if ((fd = open("sample.c", O_RDONLY)) == -1)
exit_sys("open");
printf("%d\n", fd);
}
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Biz daha önce standart C fonksiyonları ı ı ı ı ı
işlemlerinin wninde sonı ı ı ı ı ı ı
sistem fonksiyonları ı ı ı ı
1 numaralı ı ı ı ı ı
read fonksiyonunu 0 numaralı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Mademki UNIX/Linux sistemlerinde open fonksiyonu en düşük boş betimleyiciyi bize vermektedir. O halde biz stdout aygı
1 numaralı ı ı ı
Yani artı ı ı ı
olur. İşte dosya yönlendirmeleri böyle bir mekanizmayla yapı ı ı
C fonksiyonları ı
numaralı ı ı ı ı ı ı
aslı ı ı
Örnekte açtı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
int fd;
close(1);
if ((fd = open("test.txt", O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == -1)
exit_sys("open");
for (int i = 0; i < 10; ++i)
printf("Test: %d\n", i);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı
sayı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
int fd;
int val;
close(0);
if ((fd = open("test.txt", O_RDONLY)) == -1)
exit_sys("open");
while (scanf("%d", &val) == 1)
printf("%d\n", val);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir dosya betimelyicisnin gösterdiği dosya nesnesi başka bir betimelyici tarafı
fd2 betiemleyicisinin aynı ı ı
betimeleyicilerinin geçirilmesinde bir fark oluşmayacaktı
hareketle yapı ı ı
Dosya betimleyicilerini çiftlemek (duplicate etmek) için dup ve dup2 isimli iki POSIX fonksiyonu kullanı ı ı
aslı ı ı ı ı
#include <unistd.h>
int dup(int fd);
Fonksiyon parametresi ile belirtilen dosya betimleyicisinin gösteridği dosya nesnesini gösteren yeni bir betimelyici tahsis etmektedir.
Yani fonksiyon başarı ı ı
nesnesini gösterir durumda olur. dup başarı ı ı
ilk boş betimelyiciyi vermesi garanti edilmiştir.
Aşağı ı ı ı
bulunduğunu anı ı ı ı ı ı ı ı ı ı ı
kalmamaktadı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
int fd1;
int fd2;
char buf[10 + 1];
ssize_t n;
if ((fd1 = open("test.txt", O_RDONLY)) == -1)
exit_sys("open");
if ((fd2 = dup(fd1)) == -1)
exit_sys("dup");
if ((n = read(fd1, buf, 10)) == -1)
exit_sys("read");
buf[n] = '\0';
puts(buf);
if ((n = read(fd2, buf, 10)) == -1)
exit_sys("read");
buf[n] = '\0';
puts(buf);
close(fd1);
close(fd2);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
dup2 fonksiyonu da dup fonksiyonu gibi dosya betimleyicisini çiftlemekte kullanı ı
#include <unistd.h>
#include <unistd.h>
int dup2(int fd, int fd2);
Fonksiyon birinci parametresiyle belirtilen dosya betimleyicisi ile aynı
en düşük boş betimleyici değil ikinci parametrede belirtilen betimleyicidir. Yani fonksiyon başarı ı
belirtilen dosya betimleyicileri aynı ı
dosyanı ı ı ı ı
betimelycinin gösterdiği dosya nesnesini göstermesi sağlanı ı ı ı
Dosya yönlendirmeleri genellikle dup2 fonksiyonuyla yapı ı ı
thread varsa ve o thread de tesadüfen open fonksiyonunu çağı ı ı
duruma göre farklı ı
kontroller uygulanmamı ı
fd = open(....);
dup2(fd, 1);
close(fd);
Aşağı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(void)
{
int fd;
if ((fd = open("test.txt", O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) == -1)
exit_sys("open");
if (dup2(fd, 1) == -1)
exit_sys("dup2");
close(fd);
for (int i = 0; i < 10; ++i)
printf("test: %d\n", i);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
49. Ders 10/12/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi kabuk programları ı ı ı ı ı
fork uygulayı ı ı ı ı ı
kontrol bloğu değişmediği için dosya betimleyici tablosu da değişmemektedir. Dolayı ı ı ı ı ı ı
IO yönlendirmesinin etkisi altı ı
UNIX/Linux sistemlerinde exec yapı ı ı ı ı ı ı ı
Örneğin biz 100 tane dosya açmı ı ı ı ı ı ı ı ı ı
ilgilenmediği 100 dosyayı ı ı
çalı ı ı ı
bayrak set edilmişse bu durumda exec işlemi sı ı ı ı ı ı ı ı
default durumda betimleyicinin "close on exec" bayrı ı ı ı ı ı ı
"close on exec" bayrağı ı ı ı ı
Biz kursumuzda bu konunun ayrı ı ı
Aşağı ı ı ı ı ı ı ı ı
Programı ı ı ı ı
./redirect "ls -l -i > test.txt"
Programı ı ı ı ı ı ı ı ı ı
da ayrı ı ı ı ı ı ı ı
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0) { /* child process */
if ((fd = open(rargs.redirect_path, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) == -1)
exit_sys("open");
if (dup2(fd, 1) == -1)
exit_sys("dup2");
close(fd);
if (execvp(rargs.exe_args[0], rargs.exe_args) == -1)
exit_sys("execvp");
/* unreacable code */
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* redirect.c */
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/wait.h>
#define MAX_ARGS 1024
typedef struct tagREDIRECT_ARGS {
char *exe_args[MAX_ARGS];
char *redirect_path;
} REDIRECT_ARGS;
bool check_arg(char *arg, REDIRECT_ARGS *rargs);
void exit_sys(const char *msg);
/* ./redirect "./sample > test" */
int main(int argc, char *argv[])
{
char *arg;
REDIRECT_ARGS rargs;
pid_t pid;
int fd;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((arg = strdup(argv[1])) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
if (!check_arg(arg, &rargs)) {
fprintf(stderr, "invalid argument: \"%s\"\n", argv[1]);
exit(EXIT_FAILURE);
}
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0) { // child process
if ((fd = open(rargs.redirect_path, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) == -1)
exit_sys("open");
if (dup2(fd, 1) == -1)
exit_sys("dup2");
close(fd);
if (execvp(rargs.exe_args[0], rargs.exe_args) == -1)
exit_sys("execvp");
/* unreacable code */
}
if (wait(NULL) == -1)
exit_sys("wait");
free(arg);
return 0;
}
bool check_arg(char *arg, REDIRECT_ARGS *rargs)
{
char *str;
size_t i = 0;
if ((str = strchr(arg, '>')) == NULL || strchr(str + 1, '>') != NULL)
return false;
*str = '\0';
if ((rargs->redirect_path = strtok(str + 1, " \t")) == NULL)
return false;
for (str = strtok(arg, " \t"); str != NULL; str = strtok(NULL, " \t"))
rargs->exe_args[i++] = str;
if (i == 0)
return false;
rargs->exe_args[i] = NULL;
return true;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
fork işlemi sı ı ı ı ı
kopyalama bir nesnenin (yapı ı ı ı ı ı ı ı ı
gösteriyorsa o nesnenin kopyası ı ı ı ı ı ı ı ı ı ı ı
sonucunda iki nesnenin gösterici elemanları ı
fork işlemi sı ı
dosya nesnelerinin adresleri alt prosesin dosya betimeleyici tablosuna kopyalanı ı
gösteriyor durumda olur. Tabii bu surada dosya nesnelerinin referans sayaçları ı ı ı
fork işlemi sı ı ı ı ı ı
tutulmaktadı ı ı ı ı ı ı
üst proses açtı ı ı ı ı ı ı ı ı
offset'ten itibaren okuma yapmı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/wait.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int fd;
pid_t pid;
char buf[10 + 1];
ssize_t result;
if ((fd = open("test.txt", O_RDONLY)) == -1)
exit_sys("open");
if ((pid = fork()) == -1)
exit_sys("");
if (pid != 0) { /* parent process */
lseek(fd, 10, SEEK_CUR);
}
else { /* child process */
sleep(1);
if ((result = read(fd, buf, 10)) == -1)
exit_sys("read");
buf[result] = '\0';
puts(buf);
close(fd);
exit(EXIT_SUCCESS);
}
if (waitpid(pid, NULL, 0) == -1)
exit_sys("waitpid");
close(fd);
return 0;
}
void exit_sys(const char* msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
C'de bir fonksiyonun istenildiği kadar çok argümanla çağrı ı ı ı ı
atmonun bulundurulması
void foo(int a, ...);
Burada foo fonksiyonu en azı ı ı ı
foo(10); /* geçerli */
foo(10, 20); /* geçerli */
foo(10, 20, 30); /* geçerli */
foo(10, 20, 30, 40); /* geçerli */
foo(10, 20, 30, 40, 50); /* geçerli */
Fonksiyonun ... parametresi parametre listesinin sonunda bulunmak zorundadı ı
void bar(int a, ..., int b); /* geçersiz! ... parametresi parametre listesinin sonunda bulunmak zorunda */
Fonksiyonun ... parametresinden önce en az bir parametresi olmak zorundadı
void tar(...); /* geçersiz! ... parametresinden önce en az bir parametrenin olması
Değişken sayı
Örneğin printf fonksiyonunun prototipi şöyledir:
int printf(const char *format, ...);
Görüldüğü gibi printf en azı ı ı ı ı
girilebilir. printf fonksiyonu stdout dosyası ı ı ı ı ı ı
Bu durumda negatif herhangi bir değere geri döner.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi değişken sayı ı ı ı ı ı ı
karşı ı ı
void foo(int a, ...)
{
/* ... */
}
foo fonksiyonunu şöyle çağı ı ı
foo(10, 20, "ankara", 40.5, 50);
Biz fonksiyon içerisinde a parametre değişkeni yoluyla yalnı
İşte ... parametresine karşı ı ı ı ı ı ı
void va_start(va_list ap, argN);
type va_arg(va_list ap, type);
void va_end(va_list ap);
Bu makrolar va_list isimli bir tür ile çalı ı ı ı ı ı
va_list türünden bir nesne, ikinci parametresiise ... parametresinden bir önceki parametreyi almaktadı
void foo(int a, ...)
{
va_list va;
va_start(va, a);
/* ... */
}
Programcı ı ı ı
void foo(int a, ...)
{
va_list va;
va_start(va, a);
/* ... */
va_end(va);
}
... parametresine karşı ı ı ı ı
eden ası ı ı
Bu makro her çağrı ı ı ı ı ı ı ı ı ı ı
da bilmemektedir. Bu sayı ı ı
makrosunun kullanı ı
arg1 = va_arg(va, int);
arg2 = va_arg(va, const char *);
...
Programcı ı ı ı ı ı
(undefined behavior)" oluşmakatadı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı
argümanları ı ı
int add(int count, ...);
Fonksiyon argümanları ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdarg.h>
int add(int count, ...)
{
va_list va;
int total, val;
va_start(va, count);
total = 0;
for (int i = 0; i < count; ++i) {
val = va_arg(va, int);
total += val;
}
va_end(va);
return total;
}
int main(void)
{
int total;
total = add(5, 10, 20, 30, 40, 50);
printf("%d\n", total);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı
void vputs(const char *str, ...);
Fonksiyonu çağı
va_arg makrosuyla argüman çekmektedir. Örneğin:
vputs("ali", "veli", "selami", "ayse", "fatma", (char *)0);
execl ve execlp fonksiyonları ı ı ı ı
Burada NULL adres girilirken tür dönüştürmesi yapı ı ı ı ı ı
açı ı ı ı ı ı
dönüştürmesi (default argument conversion)" denilen bir dönüştürme yapmaktadı
türler int türüne (integer promotion), float türü double türüne ve 0 sabiti de int türden 0 olarak fonksiyona gönderilmektyedir. Yani
biz argümanda düz 0 kullanı ı ı
adrestir. Ancak int türü ile adres türlerinin farklı ı ı ı
olmaktadı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdarg.h>
void vputs(const char *str, ...)
{
va_list va;
const char *arg;
va_start(va, str);
arg = str;
for (;;) {
if (arg == NULL)
break;
puts(arg);
arg = va_arg(va, const char *);
}
va_end(va);
}
int main(void)
{
vputs("ali", "veli", "selami", (char *)NULL);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı
olmadı ı ı ı ı ı ı ı ı ı
hangi türden argüman çekileceğine karar verilmiştir. Tabii orijinal printf fonksiyonu stdout dosyası ı ı
örneğimizde putchar fonksiyonu ile yazdı ı ı ı ı ı ı ı
temel bir fonksiyon zaten bulunmaktadı ı
Zaten genel olarak standart C'deki <stdio> kütüphaneleri yazı ı ı
(bizim örneğimizde bu putchar) sonra o fonksiyon kullanı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <math.h>
#include <stdarg.h>
void disp_int(int val)
{
if (val < 0) {
putchar('-');
val = -val;
}
if (val / 10)
disp_int(val / 10);
putchar(val % 10 + '0');
}
int myprintf(const char *format, ...)
{
va_list va;
int total;
int val_int;
const char *val_str;
va_start(va, format);
total = 0;
while (*format != '\0') {
if (*format == '%') {
switch (*++format) {
case 'd':
val_int = va_arg(va, int);
disp_int(val_int);
if (val_int < 0) {
val_int = -val_int;
++total;
}
total += log10(val_int) + 1;
break;
case 'c':
putchar(va_arg(va, int));
++total;
break;
case 's':
val_str = va_arg(va, const char *);
while (*val_str != '\0') {
putchar(*val_str++);
++total;
}
break;
/* ... */
}
}
else {
putchar(*format);
++total;
}
++format;
}
va_end(va);
return total;
}
int main(void)
{
int a = -10;
char c = 'x';
char s[] = "ankara";
int result;
result = myprintf("a = %d, ch = %c, s = %s\n", a, c, s);
myprintf("%d\n", result);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
50. Ders 16/12/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
C'nin "stdio" kütüphanesinde printf ailesi fonksiyonları ı ı ı
biz bu printf ailesi fonksiyonları
fonksiyonunun v'li versiyonun ismi vfprintf fonksiyonudur. Bu fonksiyonları
printf ===> vprintf
scanf ===> vscanf
fprintf ===> vfprintf
fscanf ===> vfscanf
sprintf ===> vsprintf
snprintf ===> vsnprintf
sscanf ===> vsscanf
Bu fonksiyonları ı ı
ve va_list türündendir. Örneğin vprintf fonksiyonunun parametrik yapı ı ı ı ı ı ı ı ı
int printf(const char *format, ...);
int vprintf(const char *format, va_list ap);
printf fonksiyonunu sarmalayan bir fonksiyon vprintf kullanı ı
int wrapper_printf(const char *format, ...)
{
va_list va;
int result;
va_start(va, format);
result = vprintf(format, va);
va_end(va);
return result;
}
Aslı ı ı ı ı
örnek verilmiştir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <math.h>
#include <stdarg.h>
int wrapper_printf(const char *format, ...)
{
va_list va;
int result;
va_start(va, format);
result = vprintf(format, va);
va_end(va);
return result;
}
int main(void)
{
int a = 10;
double b = 3.14;
wrapper_printf("%d, %f\n", a, b);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
printf ailesi fonksiyonları ı
bir hata olduğunda errno değişkenine karşı ı ı ı ı ı ı ı
kullanı
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
Burada perror fonksiyonu önce yazı ı ı ı ı ı ı
dosyası ı ı ı ı ı ı
printf gibi kullanı
void exit_vsys(const char *format, ...)
{
va_list va;
va_start(va, format);
vfprintf(stderr, format, va);
fprintf(stderr, ": %s\n", strerror(errno));
va_end(va);
exit(EXIT_FAILURE);
}
Burada önce vfprintf fonksiyonu ile printf gibi bilgiler stderr dosyası ı ı ı
errno değerinin yazı ı ı ı ı ı ı
if ((fd = open(argv[1], O_RDONLY)) == -1)
exit_vsys("%s cannot open", argv[1]);
Hata durumunda stderr dosyası ı ı ı ı
xxx cannot open: No such file or directory
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdarg.h>
void exit_vsys(const char *format, ...);
int main(int argc, char *argv[])
{
int fd;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((fd = open(argv[1], O_RDONLY)) == -1)
exit_vsys("%s cannot open", argv[1]);
close(fd) ;
return 0;
}
void exit_vsys(const char *format, ...)
{
va_list va;
va_start(va, format);
vfprintf(stderr, format, va);
fprintf(stderr, ": %s\n", strerror(errno));
va_end(va);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
Bu dosya bir kez derlenip aşağı ı
gcc -c libsys.c
gcc -Wall -o sample sample.c libsys.o
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* sample.c */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include "libsys.h"
int main(int argc, char *argv[])
{
int fd;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((fd = open(argv[1], O_RDONLY)) == -1)
exit_vsys("%s cannot open", argv[1]);
close(fd);
return 0;
}
/* libsys.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <stdarg.h>
void exit_vsys(const char *format, ...)
{
va_list va;
va_start(va, format);
vfprintf(stderr, format, va);
fprintf(stderr, ": %s\n", strerror(errno));
va_end(va);
exit(EXIT_FAILURE);
}
/* libsys.h */
#ifndef LIBSYS_H_
#define LIBSYS_H_
/* Function Prototypes */
void exit_vsys(const char *format, ...);
#endif
/*------------------------------------------------------------------------------------------------------------------------------------------
Masaüstü (desktop) işletim sistemlerinin çalı ı ı ı ı
programcı ı ı ı ı ı ı
denilen bellek yönetim tekniği için de bir araç durumundadı
Intel işlemcileri 80386 ile birlikte (ilk kez 1985) sayfalama mekanizması ı
cortex'leri bu mekanizmaya sahiptir. PwerPC; Itanimum, Alpha gibi yaygı ı ı
kapasiteli işlemcilerde ve mikrodenetleyicilerde genel olarak bu mekanizma yoktur. Örneğin ARM işlemcilerinin M'li (Microcontoller) serisi
genel olarak sayfalama mekanizması
Sayfa (page) bellekteki ardı ı ı ı
aynı ı ı ı
Bazı ı ı ı ı
4K'dı ı ı ı
denildiğinde onun büyüklüğünün default olarak 4K olduğunu varsayacağı
İşlemciler RAM'in her sayfası ı ı
sı ı ı ı
Burada "offset" demekle ilgili sayfanı ı ı ı ı
uygulanan tipik durum). İşlemcinin belli bir adresin hangi sayfada o sayfanı ı ı
sağdaki 12 biti sayfa offsetini verir. Adres değeri 12 kere sağa ötelenirse bu da adresin sayfa numarası ı
biçiminde bir adres olsun. Bu adres RAM'in 3F7'inci sayfası ı ı
3F7 ==> sayfa numarası
Sayfalama mekanizması ı ı ı ı
sayfa büyüklüklerine göre parçalara ayrı ı ı
sayfalama mekanizması ı ı ı ı ı
program 4K'lı ı ı ı ı ı ı ı ı
farklı ı ı ı
Sayfa Numarası ı
... ...
3FC5 <DOLU>
3FC6 <BOŞ>
3FC7 <DOLU>
3FC8 <DOLU>
3FC9 <BOŞ>
3FCA <BOŞ>
3FCB <DOLU>
3FCC <DOLU>
3FCD <BOŞ>
3FCE <DOLU>
3FCF <BOŞ>
3FD0 <DOLU>
... ....
Şimdi işletim sistemi programı ı ı
Sayfa Numarası ı
... ...
3FC5 <DOLU>
3FC6 Programı ı
3FC7 <DOLU>
3FC8 <DOLU>
3FC9 Programı ı
3FCA Programı ı
3FCB <DOLU>
3FCC <DOLU>
3FCD Programı ı
3FCE <DOLU>
3FCF Programı ı
3FD0 <DOLU>
... ....
Burada iki soru karşı ı ı ı ı ı ı ı ı ı ı
hangi sayfalarda olduğunu işletim sistemi nası
Sayfalama mekanizması ı ı ı ı
işletim sistemi tarafı ı ı ı
belli bir yazmacı ı
sayfa tablosunun adresini yerleştirir. İşlemci de o sayfa tablosunu kullanı
thread temelinde preemptive zaman paylaşı ı ı ı ı ı ı ı ı
ara verilip diğer bir thread işlemciye atanı ı ı ı
farklı ı
ilişkin olduğu prosesin sayfa tablosunu kullanması ı ı ı
kullanı ı
Sayfa tablosu aslı ı ı
Sanal Sayfa No Fiziksel Sayfa No
... ...
4000 3FC6
4001 3FC9
4002 3FCA
4003 3FCB
4004 3FCF
... ....
Örneğin 32 bitlik bir sistemde derleyici sanki program 4GB'lik boş bir RAM'e tek başı
32 bit Windows sistemlerinde derleyici ve linker sanki program boş bir 4GB'lik belleğin 4MB'sinden itibaren yüklenecekmiş gibi kod
üretir. İşletim sistemi programı ı ı ı ı ı ı
adres alanı ı ı ı ı ı ı ı ı
karşı ı ı ı ı ı ı
fiziksel sayfa numarası ı ı
komutu ile karşı ı
MOV EAX, [4003F12]
Burada 4003F12 adresi 4003 sayfa numarası ı ı ı ı
fiziksel sayfayla eşleştirildiğini görür aslı
fiziksel adresler değildir. Bunlara "sanal adres (virtaul address)" ya da "doğrusal adres (linear address)" denilmektedir. İşlemci sanal
adresleri fiziksel adreslere dönüştürüp fiziksel RAM'de gerçek yere erişmektedir. Prosesin sanal adres alanı ı ı ı
fiziksel adres alanı ı ı ı ı ı ı ı ı
belirtmemektedir. Çünkü işletim sistemi her prosesin sayfa tablosunda sanal adresleri farklı
Örneğin aynı ı ı ı ı ı ı ı
onun belli bir noktası ı ı ı
çalı ı ı ı
Sanal Sayfa No Fiziksel Sayfa No
... ...
4000 3FC6
4001 3FC9
4002 3FCA
4003 3FCB
4004 3FCF
... ....
Sanal Sayfa No Fiziksel Sayfa No
... ...
4000 4F12
4001 7B14
4002 F12A
4003 47C8
4004 16CB
... ....
Burada örneğin 40013FC adresi her iki proseste aynı ı
Sayfalama mekanizması ı ı ı ı ı
iki prosesin sayfa tabloları ı ı ı
zaten erişemez.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
51. Ders 17/12/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Sayfalama "sanal bellek (virtual memory)" denilen bellek yönetim tekniğini uygulanması ı
programı ı ı ı ı ı ı ı ı ı ı
anlamı ı ı ı
Sanal bellek mekanizması ı ı ı ı ı ı
programı ı ı ı ı ı ı
Sanal Sayfa No Fiziksel Sayfa No
... ...
4000 3FC6
4001 -
4002 3FCA
4003 -
4004 3FCF
... ....
Buradaki '-' karakterleri ilgili sanal sayfa için bir fiziksel sayfanı ı ı
böyle bir durumla karşı ı ı ı ı ı ı
MOV EAX, [400117C]
Bu makine komutunda belleğin 400117C adresindeki 4 byte CPU yazmacı ı
4001'dir. İşlemci sayfa tablosuna başvurup bu sanal sayfa için bir fiziksel sayfanı ı
(internal interrupt)" oluşturmaktadı ı ı ı
belirlediği bir kodu çalı ı ı ı
yazı ı ı ı
bu page fault kodu önce buna yol açan adresi incelemektedir. Bu kod söz konusu adresteki adresteki sanal sayfa numarı ı
programı ı ı ı ı ı ı ı ı ı
yükler. Sonra sayfa tablosunu düzeltir. Artı ı ı
sonlandı ı ı ı ı ı ı ı
artı ı ı ı ı ı ı ı ı ı ı
sanmaktadı ı ı ı ı ı ı ı ı
onun sürekli yanı ı ı ı ı
adresine erişldiğinde oluşan page fault'ta işletim sisteminin programı ı ı ı ı
sayfaya yüklediğini düşünelim. Artı ı ı ı
Sanal Sayfa No Fiziksel Sayfa No
... ...
4000 3FC6
4001 418F
4002 3FCA
4003 -
4004 3FCF
... ....
Pekiyi page fault oluştuğunda fiziksel RAM'deki tüm sayfalar doluysa ne olacaktı ı
RAM'den atacak ve programa ilişkin 4K'lı ı ı ı
bir sayfayı ı ı ı ı
edilen "page replacment" algoritması ı ı ı ı ı
diskteki bir sayfanı ı
verilmektedir.
Pekiyi swap-out işlemi yapı ı ı ı
ve bu sayfa çalı ı ı ı ı
yine çalı ı ı ı ı
bu durumda o sayfa daha sonra yeniden swap-in yapı ı ı
bu tür sayfaları ı ı
oluşturduğu swap dosyaları ı ı ı ı ı ı
aslı ı ı ı ı
zamanı ı ı ı ı
belirleyebilmektedir. Örneğin Windows sistemlerinde "Denetim Masası
penceresinden değiştirilebilmektedir. Linux sistemleri bu bakı ı
bölümü (disk paritition)" olarak ayrı ı ı ı ı
Bu sistemlerde "free" komutu ile ya da "swapon -s" komutu ile swap alanları ı ı ı ı
dahil edilmesi için ne yapı ı
Pekiyi sanal bellek kullanan sistemlerde dinamik bellek tahsisatı ı ı ı ı ı ı ı
olmadı ı ı ı ı ı ı ı ı ı ı
içerisinde sayfalar için yer ayı ı ı
sayfaları ı ı
dosyaları ı ı ı
Pekiyi işletim sistemi bir sayfanı ı ı ı ı
tutulduğu bir yer de vardı ı
Sanal Sayfa No Fiziksel Sayfa No Sayfa Özellikleri
... ... ...
4000 3FC1 read-write-user
4001 1FC2 read-kernel
4002 4D02 read-write-user
... ... ...
İşlemci ne zaman bir sayfaya erişse o sayfanı
eder sonra swap-out yapacağı ı
Sayfalara "read only" ya da "read/write" biçiminde özellikler verilebilmektedir. "read-only" bir sayfaya yazma yapı ı ı
oluşmaktadı ı ı ı ı
"read-only" section'lara yerleştirmektedir. İşletim sistemi de bu sectionlar'ı
bu sayfaları ı ı ı
herhangi bir karakterini değiştirmek istediğimizde page fault oluşmakta bunun sonucu olarak da prosesimiz işletim sistemi tarafı
sonlandı ı ı ı ı ı ı
Sayfaları ı
prosesler ve kernel modda çalı ı
kernel modda çalı ı
fault oluşmaktadı ı ı ı
Bir proses çalı ı ı ı
fonksiyonları ı ı ı ı ı ı ı ı ı ı
kodları ı ı ı
için kendi kodları ı ı
erişmek istediğinde page fault oluşmakta ve proses sonlandı ı ı ı ı ı ı ı
user mode'dan kernel mode'a geçtiğini anı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
32 bit Windows sistemleri 32 bit işlemciler için yazı ı ı ı ı
sistemlerde zaten sayfa tabloları ı ı ı
bir sanal belleğe tek başı ı ı
kernel için ayı ı ı
64 bit Windows sistemleri 64 bit işlemciler için yazı ı ı
sistemleri eskiden yalnı ı
128TB alan da kernel tarafı ı ı ı ı ı ı
32 bit Linux sistemlerinde sanal bellek alanı ı ı ı ı ı ı
sistemlerinde ise user alanı ı
onları
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi işletim sistemi farklı ı ı ı ı ı
prosesin sayfa tablosuna temsil bir örnek verilmiştir:
Sanal Sayfa No Fiziksel Sayfa No
... ...
4000 3FC6
4001 56F1
4002 3FCA
4003 26C3
4004 3FCF
... ....
Sanal Sayfa No Fiziksel Sayfa No
... ...
4000 246C
4001 17F3
4002 5421
4003 5421
4004 3FC6
... ....
Burada birinci prosesin 4000 numaralı ı ı ı ı
O halde birinci proses 4000000-400FFF sanal adreslerine bir şey yazdı ı ı ı
okuyabilecektir. Yani iki prosesin farklı ı ı ı ı ı
yöntemine "shared memory" denilmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Şimdi aynı ı ı ı ı ı ı ı ı ı ı ı ı
durumlarda işletim sistemi başlangı ı ı ı ı ı
kullandı ı ı ı
olduğunca aynı ı ı ı
bu yazmadan etkilenmemesi gerekir. Pekiyi bu nası ı ı ı ı
proseslerin birinin bu fiziksel sayfaya yazma yaptı ı ı ı ı ı ı
olabilir) başlangı ı ı ı ı ı
ayrı ı
Pekiyi "copy on write" mekanizması ı ı ı
aslı ı
biri yazma yapmaya çalı ı ı ı ı ı ı ı ı
sistemi kopyası ı ı ı
Örneğin UNIX/Linux sistemlerinde fork işlemi sı ı ı ı ı ı ı
Alt prosesin sayfa tablosunun içeriği üzt prosesteki gibi yapı ı
yaptı ı ı ı ı ı ı ı ı ı ı ı
kopyalama maliyeti oluşmamaktadı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
52. Ders 23/12/2023 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir prosesin diğer bir prosese byte düzeyinde bir bilgi göndermesine v o prosesin de bu bilgiyi alması ı
(inteprocess communication ya da IOPC) denilmektedir. Proseslerarsı ı ı ı
işletim sistemlerinde proseslerin bellek alanları ı
gönderip ondan bilgi alması ı ı
ayrı
1) Aynı ı
2) Farklı ı
Aynı ı ı ı
prosesleri arası ı ı ı ı
ortamı ı ı ı
Farklı ı ı ı ı ı
aileleri geliştirilmiştir. Günümüzde en yaygı ı
Biz kursumuzun bu bölümünde öne "aynı ı
ailesi ile haberleşme üzerinde duracağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aynı ı ı
Tabii bu yöntemler bu sistemlerde farklı ı ı
farklı ı ı ı ı
da Windows sistemlerinde göreceğiz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Boru haberleşmesi en yalı ı ı ı
Borunun bir usu bir proseste diğer ucu diğer prosestedir. Proseslerden biri boruya yazma yaptı ı ı ı ı ı ı ı
okumaktadı ı ı ı
Dolu bir boruya yazma yapı ı ı ı ı
Benzer biçimde borudan okuma yapan taraf boru boşsa okunacek bir şey kalmadı ı ı
yazana kadar. Böylece boru haberleşmesinde yazan taraf okuyan tarafı ı ı ı
içerisinde bir senkroniasyon da içermektedir. Boru haberleşmesi her zaman önce yazan tarafı ı ı ı ı
borudan okuma yapan taraf önce boruda kalanları ı ı ı
boruyu kapatması
Boru haberleşmeleri kendi araları ı ı
1) İsimsiz Boru Haberleşmeleri (Unnamed Pipes ya da Anonymous Pipe)
2) İsimli Boru Haberleşmeleri (Named Pipes ya da FIFO)
İsimiz boru haberleşmesi üst ve alt prosesler arası ı ı ı
kullanı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux (ve macOS) sistemlerinde isimsiz boru haberleşmesi şu adı
1) Önce üst proses pipe POSIX fonksiyonuyla isimsiz boruyu yaratı
#include <unistd.h>
int pipe(int pipefd[2]);
pipe fonksiyonunun parametresi int türden göstericidir. Programcı ı
(Prototipteki dizi sentaksı ı ı ı ı ı ı ı
adresini geçirmek zorunda dğeildir. Burada okunabilirliğin artı ı ı ı ı ı ı
Boruya ilişkin iki betimleyiciyi argüman olarak verdiğimiz int diziye yerleştirir. Dizinin ilk elemanı ı ı
"read-only" bir betimleyicidir ve borudan okuma yapmak için kullanı ı ı ı ı
"write only" bir betimleycidir boruya yazma yapmak için kullanı ı ı ı ı ı ı
değerine geri döner. Örneğin:
int pfds[2];
if (pipe(pfds) == -1)
exit_sys("pipe");
/* pfds[0] betimleyicisi okuma yapmak için pfds[1] betimleyicisi yazma yapmak için kullanı ı ı
2) Artı ı ı ı
int pfds[2];
int pid;
if (pipe(pfds) == -1)
exit_sys("pipe");
if ((pid = fork()) == -1)
exit_sys("pid");
if (pid != 0) { /* parent process */
...
}
else { /* child process */
...
}
3) Boru ve alt proses yaratı ı ı ı ı ı ı ı
gerekir. Örneğin üst proses yazma yapacak, alt proses okuma yapacak olabilir. Ya da bunun tersi olabilir. Borular sanki birer dosyaymı
gibi ele alı ı ı ı ı ı
fork işlemi sonrası ı ı
okuma ve yazma betimleyicileri bulunacaktı
betimleyici bulunmalı ı ı ı ı
üst proses yazma yapacak olsun alt proses de okuma yapacak olsun:
int pfds[2];
int pid;
if (pipe(pfds) == -1)
exit_sys("pipe");
if ((pid = fork()) == -1)
exit_sys("pid");
if (pid != 0) { /* üst proses boruya yazma yapacak */
close(pfds[0]);
...
}
else { /* alt proses borudan okuma yapacak */
close(pfds[1]);
...
}
read fonksiyonu ile borudan n byte okuma yapı
okuyana kadar beklemeye yol açar. Eğer borudan n byte okunmak istediniğinde boruda en az 1 byte bilgi oluşmuşsa bu durumda read fonksiyonu
n byte'ı ı ı ı ı
okunacak bir şey yoksa ancak boruya yazma potansiyelinde olan tüm betimleyiciler de kapatı ı
ve 0 değeri ile geri döner. Yani read fonksiyonu 0 ile geri dönmüşse bu durum "boruda bir şey kalmadı ı
anlamı
write fonksiyonu ile boruya n byte yazma yapı ı
Yani borulara kı ı ı
15 byte yazmak isteyelim. Bu durumda bu 15 byte'ı ı ı
sahip hiçbir betimleyici kalmadı ı ı
isimli sinyal oluşmaktadı ı ı ı ı
Aşağı ı
dosyası ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
void exit_sys(const char *msg);
int main(void)
{
int pfds[2];
int pid;
ssize_t result;
int val;
if (pipe(pfds) == -1)
exit_sys("pipe");
if ((pid = fork()) == -1)
exit_sys("pid");
if (pid != 0) { /* parent process writes to pipe */
close(pfds[0]);
for (int i = 0; i < 10; ++i)
if (write(pfds[1], &i, sizeof(int)) == -1)
exit_sys("write");
close(pfds[1]);
if (wait(NULL) == -1)
exit_sys("wait");
}
else { /* child process reads from pipe */
close(pfds[1]);
while ((result = read(pfds[0], &val, sizeof(int))) > 0) {
printf("%d ", val);
fflush(stdout);
}
if (result == -1)
exit_sys("write");
close(pfds[0]);
}
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
İsimsiz boru haberleşmesinde neden okuyan taraf yazma betimleyicini yazan taraf da okuma betimleyicini kapatmaktadı
yazma betimeleyicisini kapatmazsa yazab taraf yazma betimleyicisini kapatsa bile okuyan taraftaki read fonksiyonu "hala boruya yazma
potansiyelinde olan bir betimleyici bulunduğu için" 0 ile geri dönmeyecektir ve bloke oluşturacaktı ı
kapatmaması ı
teknik değildir. Yazna tarafı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı ı ı
programı ı ı ı
"sample" programı ı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* sample.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int pfds[2];
int pid;
ssize_t result;
int val;
char buf[10];
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if (pipe(pfds) == -1)
exit_sys("pipe");
if ((pid = fork()) == -1)
exit_sys("pid");
if (pid != 0) { /* parent process writes to pipe */
close(pfds[0]);
for (int i = 0; i < 1000000; ++i)
if (write(pfds[1], &i, sizeof(int)) == -1)
exit_sys("write");
close(pfds[1]);
if (wait(NULL) == -1)
exit_sys("wait");
}
else { /* child process reads from pipe */
close(pfds[1]);
sprintf(buf, "%d", pfds[0]);
if (execlp(argv[1], argv[1], buf, (char *)NULL) == -1)
exit_sys("execvp");
/* unreachable code */
}
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/* mample.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int pfd;
ssize_t result;
int val;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
pfd = atoi(argv[1]);
while ((result = read(pfd, &val, sizeof(int))) > 0) {
printf("%d ", val);
fflush(stdout);
}
printf("\n");
if (result == -1)
exit_sys("read");
close(pfd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
53. Ders 24/12/2023 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Şimdi de kabuk programları ı ı ı ı ı ı ı ı
programı ı ı ı ı ı ı ı ı ı ı
./shellpipe "ls -l | wc"
Programda önce '|' karakterinin yeri bulunmuş ve bu karakterin iki tarafı ı
1) Üst proses ("shellpipe.c") bir boru yaratmı ı
2) Üst proses '|' karakterin solundaki program için fork yapmı ı ı ı ı ı
Sonra alt proseste okuma yapı ı ı ı
diğer boru betimelyicisi de bu işlemden sonra kapatı ı ı ı ı
if (pid1 == 0) { /* first child */
close(pfds[0]);
if (dup2(pfds[1], 1) == -1)
exit_sys("dup2");
close(pfds[1]);
if (execvp(pargs.prog1[0], &pargs.prog1[0]) == -1)
exit_sys("execvp");
/* unreachable code */
}
3) Benzer işlemler '|' karakterinin sağı ı ı ı ı ı ı ı
artı
if ((pid1 = fork()) == -1)
exit_sys("fork");
if ((pid2 = fork()) == -1)
exit_sys("fork");
if (pid2 == 0) { /* first child */
close(pfds[1]);
if (dup2(pfds[0], 0) == -1)
exit_sys("dup2");
close(pfds[0]);
if (execvp(pargs.prog2[0], &pargs.prog2[0]) == -1)
exit_sys("execvp");
/* unreachable code */
}
4) Artı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <unistd.h>
#include <sys/wait.h>
#define MAX_ARGS 1024
typedef struct tagPIPE_ARGS {
char *prog1[MAX_ARGS];
char *prog2[MAX_ARGS];
} PIPE_ARGS;
bool check_arg(char *arg, PIPE_ARGS *rargs);
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
char *arg;
PIPE_ARGS pargs;
int pfds[2];
pid_t pid1, pid2;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((arg = strdup(argv[1])) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
if (!check_arg(arg, &pargs)) {
fprintf(stderr, "invalid argument: \"%s\"\n", argv[1]);
exit(EXIT_FAILURE);
}
if (pipe(pfds) == -1)
exit_sys("pipe");
if ((pid1 = fork()) == -1)
exit_sys("fork");
if (pid1 == 0) { /* first child */
close(pfds[0]);
if (dup2(pfds[1], 1) == -1)
exit_sys("dup2");
close(pfds[1]);
if (execvp(pargs.prog1[0], &pargs.prog1[0]) == -1)
exit_sys("execvp");
/* unreachable code */
}
if ((pid2 = fork()) == -1)
exit_sys("fork");
if (pid2 == 0) { /* first child */
close(pfds[1]);
if (dup2(pfds[0], 0) == -1)
exit_sys("dup2");
close(pfds[0]);
if (execvp(pargs.prog2[0], &pargs.prog2[0]) == -1)
exit_sys("execvp");
/* unreachable code */
}
free(arg);
close(pfds[0]);
close(pfds[1]);
if (waitpid(pid1, NULL, 0) == -1)
exit_sys("waitpid");
if (waitpid(pid2, NULL, 0) == -1)
exit_sys("waitpid");
return 0;
}
bool check_arg(char *arg, PIPE_ARGS *pargs)
{
char *pos, *str;
size_t i;
if ((pos = strchr(arg, '|')) == NULL || strchr(pos + 1, '|') != NULL)
return false;
*pos = '\0';
i = 0;
for (str = strtok(arg, " \t"); str != NULL; str = strtok(NULL, " \t"))
pargs->prog1[i++] = str;
pargs->prog1[i] = NULL;
if (i == 0)
return false;
i = 0;
for (str = strtok(pos + 1, " \t"); str != NULL; str = strtok(NULL, " \t"))
pargs->prog2[i++] = str;
pargs->prog2[i] = NULL;
if (i == 0)
return false;
return true;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux (ve macOS) sistemlerinde isimli borular sanki bir dosyaymı ı ı ı
dosyası ı ı ı ı ı ı ı
fonksiyonuyla yaratı ı
#include <sys/stat.h>
int mkfifo(const char *path, mode_t mode);
Boru dosyaları ı ı ı ı ı ı ı
sistemi tarafı ı ı ı ı ı ı ı
için kullanı ı ı ı ı
erişim hakları ı ı ı ı ı
if (mkfifo("myfifo", S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) == -1)
exit_sys("mkfifo");
mkfifo fonksiyonu prosesin umask değerini dikkat ealmaktadı ı ı
sahip olması ı ı ı ı ı ı ı ı
Boru dosyaları
prw-r--r-- 1 kaan study 0 Ara 24 17:34 myfifo
Aşağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* mymkfifo.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <sys/stat.h>
#include <getopt.h>
bool check_octal(const char *arg);
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int m_flag, err_flag;
int result;
char *m_arg;
int mode;
m_flag = err_flag = 0;
mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH;
opterr = 0;
while ((result = getopt(argc, argv, "m:")) != -1) {
switch (result) {
case 'm':
m_flag = 1;
m_arg = optarg;
break;
case '?':
if (optopt == 'b')
fprintf(stderr, "-b option given without argument!..\n");
else
fprintf(stderr, "invalid option: -%c\n", optopt);
err_flag = 0;
break;
}
}
if (err_flag)
exit(EXIT_FAILURE);
if (argc - optind == 0) {
fprintf(stderr, "pipe name(s) must be specified!..\n");
exit(EXIT_FAILURE);
}
if (m_flag) {
if (!check_octal(m_arg)) {
fprintf(stderr, "invalid mode parameter: %s\n", m_arg);
exit(EXIT_FAILURE);
}
sscanf(m_arg, "%o", &mode);
}
umask(0);
for (int i = optind; i < argc; ++i)
if (mkfifo(argv[i], mode) == -1)
perror(argv[i]);
return 0;
}
bool check_octal(const char *arg)
{
if (strlen(arg) > 3)
return false;
for (int i = 0; arg[i] != '\0'; ++i)
if (arg[i] < '0' || arg[i] > '7')
return false;
return true;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
İsimli boru mkfifo fonksiyonuyla ya da mkfifo komutuyla yaratı ı
açmalı ı ı ı ı ı ı ı ı
modunda açı ı ı ı ı ı ı
İki proses de uygun bir biçimde open fonksiyonuyla boruyu açtı ı ı ı ı
haberleşme sağlanı ı ı ı ı ı
kullanı ı ı ı ı ı ı ı
Pkuyan taraf yine önce boruda kalanları
boruyu kapatı
open fonksiyonuyla isimli boru O_WRONLY modunda açı ı
açı ı ı ı ı
O_WRONLY modunda açana kadar open blokeye yol açmaktadı ı ı
kursumuzun kapsamı ı ı ı
Aşağı ı ı
yapmaktadı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* pwrite.c */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int pfd;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((pfd = open(argv[1], O_WRONLY)) == -1)
exit_sys("open");
for (int i = 0; i < 1000000; ++i)
if (write(pfd, &i, sizeof(i)) == -1)
exit_sys("write");
close(pfd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/* pread.c */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int pfd;
ssize_t result;
int val;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((pfd = open(argv[1], O_RDONLY)) == -1)
exit_sys("open");
while ((result = read(pfd, &val, sizeof(int))) > 0)
printf("%d ", val), fflush(stdout);
if (result == -1)
exit_sys("read");
printf("\n");
close(pfd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi iki proses aynı ı ı
<limits.h> dosyası ı ı
aynı ı ı ı
miktarda bilgi boruya yazı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde boru haberleşmesi UNIX/Linux sistemindekilere benzer bir biçimde yapı ı
(anonymous)" ve "isimli (named)" olmak üzere ikiye ayrı ı ı
proseslerin haberleşmesi için de kullanı ı ı ı
bu kursumuzda Windows sstemlerindeki isimli borular üzerinde durmayacağı ı ı ı
Windows sistemlerinde isimsiz borular yine üst ve alt proseslerin haberleşmesinde kullanı ı ı ı ı
CreateProcess API fonksiyonunun adresta fork/exec ikilisi gibi bir işleve sahip olduğunu anı ı ı ı ı
alt prosese boruları ı
tipik olarak şu adı
1) Üst proses boruyu CreatePipe isimli API fonksiyonuyla yaratı
BOOL CreatePipe(
PHANDLE hReadPipe,
PHANDLE hWritePipe,
LPSECURITY_ATTRIBUTES lpPipeAttributes,
DWORD nSize
);
Fonksiyonun birinci ve ikinci parametresi boruya yazma yapmakta kullanı ı
yerleştirileceği nesnelerin adreslerini almaktadı ı
boru nesnesinin güvenlik bilgilerini içermektedir. Bu patametre NULL geçilebilir. Son parametre borunun byte cinsinden uzunluğunu belirtmektedir.
Bu parametre için girilecek değer yalnı ı ı
yaratı ı
Fonksiyon başarı ı ı ı ı ı ı ı ı ı
2) Borudan okuma için ReadFile fonksiyonu, boruya yazma için WriteFile API fonksiyonu kullanı ı ı
görmüştük. ReadFile fonksiyonu ile borudan okuma yapı
WriteFile fonksiyonu ile boruya yazma yapı ı ı ı
için gerekli alan açı ı ı ı ı
davranı ı ı ı ı ı ı ı
taraf önce boruda kalanları ı ı ı
kapatı ı ı ı
ReadFile ya da WriteFile fonksiyonları ı ı ı ı ı ı
ERROR_BROKEN_PIPE değerini vermektedir.
3) Windows sistemlerinde üst prosesteki HANDLE değerleri alt prosese default durumda aktarı ı
default durumda üst prosesin betimeleyicilerinin exec işlemi sı ı ı ı ı
prosese aktarı ı ı ı ı
if (!SetHandleInformation(handle, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT))
ExitSys(TEXT("CreatePipe"));
Ayrı ı ı ı ı
gerekmektedir.
4) Artı ı ı ı ı
betimelyicileri kapatmalı ı
5) CreateProses fonksiyonu ile alt proses yaratı ı ı ı ı ı ı
Aşağı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* Parent.c */
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#define CHILD_PATH "Child.exe"
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hPipeRead, hPipeWrite;
DWORD dwWritten, dwRead;
char args[4096];
STARTUPINFO si = { sizeof(STARTUPINFO) };
PROCESS_INFORMATION pi;
if (!CreatePipe(&hPipeRead, &hPipeWrite, NULL, 0))
ExitSys("CreatePipe");
if (!SetHandleInformation(hPipeRead, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT))
ExitSys("SetHandleInformation");
sprintf(args, "%s %p", CHILD_PATH, hPipeRead);
if (!CreateProcess(NULL, args, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
ExitSys("CreateProcess");
CloseHandle(hPipeRead);
for (int i = 0; i < 1000000; ++i)
if (!WriteFile(hPipeWrite, &i, sizeof(int), &dwWritten, NULL))
ExitSys("WriteFile");
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
CloseHandle(hPipeWrite);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/* Child.c */
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(int argc, char *argv[])
{
HANDLE hPipeRead;
DWORD dwRead;
int val;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
sscanf(argv[1], "%p", &hPipeRead);
while (ReadFile(hPipeRead, &val, sizeof(int), &dwRead, 0)) {
printf("%d ", val);
fflush(stdout);
}
if (GetLastError() != ERROR_BROKEN_PIPE)
ExitSys("ReadFile");
printf("\n");
CloseHandle(hPipeRead);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*-----------------------------------------------------------------------------------------------------------------------------------------
54. Ders 06/01/2024 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------------------------------------------------
Proseslerarası ı ı ı
hakkı ı ı ı ı ı ı ı ı ı ı
sanal sayfa numaraları ı ı ı
diğer sanal sayfa yoluyla görebilmektedir. Örneğin:
Proses-1 Sayfa Tablosu
Sanal Sayfa No Fiziksel Sayfa No
.... ....
1784 3641
.... ....
Proses-2 Sayfa Tablosu
Sanal Sayfa No Fiziksel Sayfa No
.... ....
1432 3641
.... ....
Buradaki numaraları ı ı ı
yaptı ı ı ı ı ı ı
belirtmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux (ve macOS) sistemlerinde paylaşı ı ı ı ı ı
Bunlardan biri eski System-5 fonksiyonları ı ı ı
Memory" fonksiyonları ı ı ı ı
aşanı ı ı ı ı ı
90'lı ı ı ı ı ı ı ı ı ı
yalnı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------------------------------------------------------
POSIX paylaşı ı ı ı ı
1) POSIX paylaşı ı ı ı
fonksiyonu ile açı
#include <sys/mman.h>
int shm_open(const char *name, int oflag, mode_t mode);
Fonksiyonun birinci parametresi paylaşı ı
gerekmektedir. (POSIX standartları ı ı
Fonksiyonun ikinci parametresi paylaşı ı ı ı ı ı
O_RDONLY: Bu durumda paylaşı ı ı ı
O_RDWR: Bu durumda paylaşı ı ı ı
Aşağı ı
O_CREAT: Paylaşı ı ı ı ı ı
O_EXCL: O_CREAT bayrağı ı ı ı ı ı
O_TRUNC: Paylaşı ı ı ı ı ı ı ı ı ı ı
Fonksiyonun üçüncü parametresi paylaşı ı ı ı ı
bayrağı ı ı ı ı ı ı
fonksiyon tarafı ı ı
shm_open bize tı ı ı ı ı
döner ve errno değişkeni uygun biçimde set edilir. Burada yaratı ı ı ı
Yani paylaşı ı ı ı ı
Örneğin:
int fdshm;
if ((fdshm = shm_open(SHM_NAME, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) == -1)
exit_sys("shm_open");
2) Paylaşı ı ı ı
if (ftruncate(fdshm, SHM_SIZE) == -1)
exit_sys("ftruncate");
Tabii paylaşı ı ı ı ı ı ı ı ı ı ı
fonksiyon herhangi bir şey yapmayacaktı ı ı ı ı ı ı ı
Ancak yukarı ı
ftruncate aslı ı ı
#include <unistd.h>
int ftruncate(int fd, off_t length);
Fonksiyonun birinci parametresi dosya betimleyicisini ikinci parametresi dosyanı ı ı
0 değerine başarı ı ı ı
biçimi de vardı
POSIX paylaşı ı ı
bu dizin içerisindeki nesneleri komut satı ı
3) Artı ı ı ı ı
mmap fonksiyonu pek çok UNIX türevi sistemde bir sistem fonksiyonu olarak gerçekleştirilmiştir. mmap paylaşı ı ı ı ı
başka amaçlarla da kullanı ı ı ı ı ı
kullanı ı ı ı ı ı ı ı
#include <sys/mman.h>
void *mmap(void *addr, size_t len, int prot, int flags, int fd, off_t off);
Fonksiyonun birinci parametresi, "mapping için" önerilen sanal adresi belirtmektedir. Programcı
kullanı ı ı
kullanmayabilir. Fonksiyon bu önerilen adresin yakı ı ı ı
yapı ı ı ı
Eğer bu adres NULL olarak geçilirse bu durumda mapping işlemi işletim sisteminin kendi belirlediği bir adresten itibaren yapı ı
en tipik durum bu parametrenin NULL adres olarak geçilmesidir.
Fonksiyonun ikinci parametresi, paylaşı ı ı ı ı ı ı
nesnesi 1MB olabilir. Ancak biz onun 100K'lı ı ı ı ı ı ı
isteyebiliriz. Bu uzunluk sayfa katları ı ı
yuvarlamaktadı ı
Fonksiyonun üçüncü parametresi, mapping işleminin koruma özelliklerini belirtmektedir. Başka bir deyişle bu parametre
paylaşı ı ı ı
oluşturulabilir:
PROT_READ
PROT_WRITE
PROT_EXEC
PROT_NONE
PROT_READ sayfanı ı ı
sinyali ile sonlandı ı ı ı
yazma anlamı
çalı ı ı ı
o sayfadaki bir kod çalı ı ı ı ı ı
PROT_NONE olan bir sayfa ne okunabilir ne de yazı ı
Tabii bir sayfanı ı
desteklemeyebilirler. Örneğin Intel işlemcilerinde PROT_WRITE zaten okuma özelliğini de kapsamaktadı ı
PROT_EXEC özelliğini hiç bulundurmamaktadı ı ı
oluşturmalı ı
Fonksiyonun dördüncü parametresi olan flags aşağı ı
MAP_PRIVATE
MAP_SHARED
MAP_PRIVATE ile oluşturulan mapping'e "private mapping", MAP_SHARED ile oluşturulan mapping'e ise "shared mapping" denilmektedir.
MAP_PRIVATE "copy on write" denilen semantik için kullanı ı ı ı
aynı ı ı ı ı ı ı ı
özel olarak yapı ı ı ı ı ı ı ı ı ı
MAP_PRIVATE şunlara yol açmaktadı
- Okuma yapı ı ı ı ı ı
- Ancak yazma yapı ı ı ı ı ı ı ı ı ı ı ı
yazma o kopya üzerine yapı ı ı ı
Bir proses ilgili paylaşı ı ı ı ı ı ı
yapan prosesin görüp görmeyeceği POSIX standartları ı ı ı ı ı
aynı ı ı ı ı
bu yazma private mapping'in yapı ı ı ı ı ı ı ı ı
çı ı ı ı ı
MAP_SHARED ise yazma işleminin paylaşı ı ı ı ı ı ı ı
Dolayı ı ı ı ı ı
amaç doğrultusunda shared mapping kullanı ı
Örneğin işletim sistemi (exec fonksiyonları ı ı ı ı
ile yüklemektedirler.
Fonksiyonun flags parametresinde MAP_PRIVATE ve MAP_SHARED değerlerinin yalnı ı
MAP_FIXED değeri bit düzeyinde OR işlemine sokulabilmektedir. MAP_FIXED bayrağı
bu adresin kendisinin aynen (hiç değiştirilmeden) kullanı ı ı ı ı
kendisi tahsis edilecek ve fonksiyon bu adresin aynı ı ı
parametredeki adresin sayfa katları ı ı ı ı
bunun zorunlu olmayabileceğini belirtmektedir.
Fonksiyonun son iki parametresi dosya betimleyicisi ve bir de offset içermektedir. Paylaşı ı ı
sonraki kı ı ı ı ı
kı ı ı ı
shmaddr = mmap(NULL, SHM_SIZE, PROT_WRITE, MAP_SHARED, fdshm, 0);
Burada paylaşı ı ı
olacaktı ı ı ı ı ı ı
yani aynı ı ı ı ı
nesnesinin 0'ı ı ı
mmap fonksiyonun son parametresindeki offset değeri MAP_FIXED belirtilmişse, birinci parametre ile son parametrenin sayfa katları
bölümünden elde edilen kalan aynı ı ı
ediyorsa 5000 % 4096 = 4'tür. Bu durumda son parametrenin de 4096'ya bölümünden elde edilen kalan 4 olmalı ı
belirtilmemişse POSIX standartları ı ı ı ı
bı ı ı ı ı
mmap fonksiyonu başarı ı ı ı ı
MAP_FAILED özel değerine geri döner. Pek çok sistemde MAP_FAILED bellekteki son adres olarak aşağı
#define MAP_FAILED ((void *) -1)
Kontrol şöyle yapı
shmaddr = mmap(NULL, SHM_SIZE, PROT_WRITE, MAP_SHARED, fdshm, 0);
if (shmaddr == MAP_FAILED)
exit_sys("mmap");
Paylaşı ı ı
4) Programcı ı ı ı ı
fonksiyonu ile yapı ı
munmap fonksiyonunun prototipi şöyledir:
#include <sys/mman.h>
int munmap(void *addr, size_t len);
Fonksiyonun birinci parametresi, daha önce map edilen alanı ı ı
uzunluğunu belirtmektedir. Fonksiyon birinci parametresinde belirtilen adresten itibaren ikinci parametresinde belirtilen miktardaki
byte'ı ı ı ı ı
ortaları ı
belirtilen adresin sayfa katları ı ı
adres sayfa katları ı ı ı ı ı
değişkeni uygun biçimde set edilir. munmap ile zaten map edilmemiş bir alan unmap edilmeye çalı ı ı
fonksiyon başarı ı ı
Paylaşı ı ı ı ı
ile kapatı ı ı ı ı ı ı ı
Bunun mapping işlemine bir etkisi olmaz.
Unmap işlemi mevcut mapping'in bir kı ı ı ı ı
parçalara kendisi ayı ı
xxxxmmmmmmmmmxxxx
Burada "m" map edilmiş sayfaları ı ı
xxxxmmmmxxmmmxxxx
Görüldüğü gibi artı ı ı ı
Proses bittiğinde map edilmiş bütün alanlar zaten işletim sistemi tarafı
5) Paylaşı ı ı ı ı ı
belirttiğimiz gibi bu kapatma işlemi aslı ı
6) Artı ı ı ı
kadar nesne hayatta kalmaya devam edecektir (kernel persistant). shm_unlink fonksiyonun prototipi şöyledir:
#include <sys/mman.h>
int shm_unlink(const char *name);
Fonksiyon paylaşı ı ı ı ı ı ı
değerine geri dönmektedir. Örneğin:
if (shm_unlink(SHM_PATH) == -1)
exit_sys("shm_unlink");
Aşağı ı ı ı ı ı
programı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* prog1.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/mman.h>
#define SHM_PATH "/this_is_a_sample_shared_memory"
void exit_sys(const char *msg);
int main(void)
{
int fdshm;
char *shmem;
if ((fdshm = shm_open(SHM_PATH, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) == -1)
exit_sys("shm_open");
if (ftruncate(fdshm, 4096) == -1)
exit_sys("ftruncate");
if ((shmem = (char *)mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fdshm, 0)) == MAP_FAILED)
exit_sys("mmap");
printf("press ENTER to write shared memory...\n");
getchar();
strcpy(shmem, "this is a test...");
printf("press ENTER to exit...\n");
getchar();
if (munmap(shmem, 4096) == -1)
exit_sys("munmap");
close(fdshm);
if (shm_unlink(SHM_PATH) == -1)
exit_sys("shm_unlink");
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/* prog2.c */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/mman.h>
#define SHM_PATH "/this_is_a_sample_shared_memory"
void exit_sys(const char *msg);
int main(void)
{
int fdshm;
char *shmem;
if ((fdshm = shm_open(SHM_PATH, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) == -1)
exit_sys("shm_open");
if (ftruncate(fdshm, 4096) == -1)
exit_sys("ftruncate");
if ((shmem = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fdshm, 0)) == MAP_FAILED)
exit_sys("mmap");
printf("press ENTER to read shared memory...\n");
getchar();
puts(shmem);
printf("press ENTER to exit...\n");
getchar();
if (munmap(shmem, 4096) == -1)
exit_sys("munmap");
close(fdshm);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Paylaşı ı ı ı ı
birden fazla bilgiyi farklı ı ı ı
biçimde çalı ı
kursumuzun thread'ler kı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Bellek tabanlı ı ı
sistemlerinde (Windows NT ve sonra da Windows 95) bellek tabanlı ı ı ı
bellek tabanlı ı
dosyaları
Bellek tabanlı ı ı ı
Biz bir disk dosyası ı ı ı ı ı ı
dosyanı ı ı ı ı ı ı ı ı
işlemler yapı ı ı ı ı
read fonksiyonu ile dosyanı ı ı ı
result = read(fd, buf, size);
Burada genellikle işletim sistemlerinde arka planda iki işlem yapı ı ı
bir alana (bu alana buffer cache ya da page cache denilmektedir) çekilir. Sonra bu alandan bizim belirttiğimiz alana aktarı ı ı
bellek tabanlı ı ı
tabanlı ı ı ı ı ı
ortadan kalkmaktadı ı ı ı ı ı ı
dosyalar klasik read/write sistemine göre oldukça avantaj sağlamaktadı
Bu noktada kişilerin akı ı ı ı ı ı
bellek üzerinde yapsak sonra da write fonksiyonu ile tek hamlede yine onları ı ı
kalı ı ı ı ı ı ı
farklı ı ı ı ı ı ı ı
dosyaları ı ı ı ı ı ı ı ı ı
bellek tabanlı ı ı ı ı ı ı
yere yerleştirip o proseslerin aynı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Bir dosya bellek tabanlı ı ı ı ı ı
1) Dosya open fonksiyonuyla açı ı
int fd;
...
if ((fd = open("test.txt", O_RDWR)) == -1)
exit_sys("open");
İleride de belirteceğimiz gibi dosyalar bellek tabanlı ı ı ı ı
Yani zaten var olan dosyalar bellek tabanlı ı
2) Açı ı ı ı
bellek alanları ı ı ı ı
işleminde genellikle shared mapping (MAP_SHARED) tercih edilir. Eğer private mapping (MAP_PRIVATE) yapı ı ı ı ı ı
bu dosyaya yansı ı ı
belirtmektedir. İşte dosya betimleyicisi olarak açmı ı ı
edeceksek oranı ı ı ı
char *maddr;
struct stat finfo;
...
if (fstat(fd, &finfo) == -1)
exit_sys("fstat");
if ((maddr = (char *)mmap(NULL, finfo.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED)
exit_sys("mmap");
Burada biz önce dosyanı ı
Artı ı
for (off_t i = 0; i < finfo.st_size; ++i)
putchar(maddr[i]);
mapping işleminden sonra artı ı ı
yoktur.
3) Tı ı ı ı ı
bı ı ı
if (munmap(maddr, finfo.st_size) == -1)
exit_sys("munmap");
4) Nihayet dosya betimleyicisi close fonksiyonuyla kapatı ı ı ı ı
hemen de close fonksiyonu ile dosya betimleyicisini kapatabilirdik. Örneğin:
close(fd);
Aşağı ı ı ı ı ı ı ı ı ı ı ı ı
Aynı ı ı ı ı ı ı ı ı ı
dikkat ediniz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/mman.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int fd;
struct stat finfo;
char *fmaddr;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((fd = open(argv[1], O_RDWR)) == -1)
exit_sys("open");
if (fstat(fd, &finfo) == -1)
exit_sys("fstat");
if ((fmaddr = (char *)mmap(NULL, finfo.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED)
exit_sys("mmap");
for (off_t i = 0; i < finfo.st_size; ++i)
putchar(fmaddr[i]);
putchar('\n');
memcpy(fmaddr, "XXXXXX", 6);
if (munmap(fmaddr, finfo.st_size) == -1)
exit_sys("munmap");
close(fd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerindeki bellek tabanlı ı ı ı ı ı
edilmesi gerekir. Burada bu ayrı ı ı
- Dosyayı ı ı
açı ı ı ı
değeri ile set edilecektir. Eğer biz dosyayı ı ı ı ı ı
bu durumda dosyaya yazma hakkı ı ı ı
program SIGSEGV sinyali ile çökecektir.
- Bellek tabanlı ı ı ı ı ı ı
fonksiyonunda PROT_WRITE olarak map edilmesi gerekir. Halbuki Intel gibi bazı ı
izni anlamı ı
anlamı ı ı ı ı
bu PROT_WRITE aynı ı ı ı
POSIX standartları ı ı ı ı ı ı
belirtilmiştir. Yani POSIX standartları ı ı ı ı ı ı ı
başarı ı ı ı
- Bir dosyanı ı ı ı ı ı
değeri EINVAL olarak set edilmektedir. Yani 0 uzunlukta bir dosya map edilememektedir.
- Anı ı ı ı
"may require" biçimde belirtmiştir). Yani Linux'ta biz dosyayı ı
zaten map edilen adres sayfanı ı ı
- Biz normal bir dosyayı ı
fonksiyonları ı ı ı
Biz bir dosyayı
halde biz dosyayı ı ı
erişebiliriz. Dosyanı ı ı ı
İşte bizim bu son sayfadaki 2288 byte'a erişmemizde hiçbir sakı ı ı ı
3 * 4096 = 12288'den 20000'e kadarki alana erişmeye çalı ı ı ı
prosesimiz sonlandı ı ı ı ı
gibi bellek tabanlı ı
dosyayı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
55. Ders 07/01/2024 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Bellek tabanlı ı ı ı ı ı ı ı ı ı ı
hakkı ı
Biz write POSIX fonksiyonuyla dosyaya bir yazma yaptı ı ı
çağı ı
çağı ı ı ı
hemen yazma işlemini diske yapmazlar. Önce kernel içerisindeki bir tampona yazma yaparlar. Bu tampona Linux sistemlerinde eskiden "buffer cache"
denirdi. Sonradan sistem biraz değiştirildi ve "page cache" denilmeye başlandı
tarafı ı ı ı ı ı
içerisindeki bir tampona (Linux'ta page cache) yazı ı ı ı ı ı ı
bu tamponlar diske flush edilmektedir. Pekiyi neden write fonksiyonu doğrudan diske yazmak yerine önce bir tampona (page cache) yazmaktadı
İşte bunun amacı ı ı ı ı ı
diske yazı ı ı ı ı ı ı
(Örneğin biz dosyaya peşi sı ı ı ı ı
ve bu page cache'teki sayfa tek hamlede işletim sistemi tarafı ı
flush eden kernel thread'i çok fazla beklemeden bu işi yapmaya çalı ı ı ı
daha yüksek düzeyde olabilmektedir. Pekiyi biz write fonksiyonu ile yazma yaptı ı ı ı ı ı
o halde başka bir proses tam bu işlemden hemen sonra open fonksiyonu ile dosyayı ı ı ı ı ı
okuyabilecek midir? POSIX standartları ı ı
write yapı ı ı ı ı ı ı ı ı
tamponu kullanmaktadı ı ı ı
her proses işletim sistemi içerisindeki aynı ı ı ı
bakmaktadı ı ı ı ı
bypass edip doğrudan disk sektörlerine erişirse bu durumda gerçekten henüz write fonksiyonu ile yazı ı ı ı
görebilir.)
Pekiyi biz bir dosyayı ı ı ı ı
read işlemi sı ı ı ı
bu yazı ı ı ı ı ı
içeriğinde değişiklik yapı ı ı ı ı ı
işleminin bellek tabanlı ı ı ı ı ı ı
Her ne kadar POSIX standartları ı ı
"unified file system" tasarı ı ı ı ı ı ı ı
map ettiğimizde aslı ı ı
Yani zaten Linux sistemlerinde bütün prosesler dosya işlemlerinde önce bu page cahche'e bakmaktadı ı ı ı ı
bellekteki alanı ı ı ı ı ı ı ı ı
dolayı ı ı ı ı ı ı ı ı
yazma yapmaktadı ı ı ı ı ı
Aşağı ı ı ı ı ı ı ı
ise bir dosyanı ı ı ı ı ı
yapı ı ı ı ı ı ı ı
bile o değişikliği gördüğünün ispat edilmesidir. Programları ı
çalı ı
./sample test.txt
./mample test.txt
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* sample.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/mman.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int fd;
struct stat finfo;
char *fmaddr;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((fd = open(argv[1], O_RDWR)) == -1)
exit_sys("open");
if (fstat(fd, &finfo) == -1)
exit_sys("fstat");
if ((fmaddr = (char *)mmap(NULL, finfo.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED)
exit_sys("mmap");
printf("press ENTER to write...\n");
getchar();
memcpy(fmaddr, "XXXXXX", 6);
printf("press ENTER to exit...\n");
getchar();
if (munmap(fmaddr, finfo.st_size) == -1)
exit_sys("munmap");
close(fd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/* mample.c */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int fd;
char buf[32 + 1];
ssize_t result;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((fd = open(argv[1], O_RDONLY)) == -1)
exit_sys("open");
if ((result = read(fd, buf, 32)) == -1)
exit_sys("read");
for (ssize_t i = 0; i < result; ++i)
putchar(buf[i]);
putchar('\n');
close(fd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı
gerekmiyorsa da bellek tabanlı ı ı ı ı ı
bellek tabanlı ı ı ı ı ı ı ı
prototipi şöyledir:
#include <sys/mman.h>
int msync(void *addr, size_t len, int flags);
Fonksiyonun birinci parametresi flush edilecek bellek tabanlı ı
POSIX standartları ı ı
yapabilir (may require)". Linux sistemlerinde bu adresin sayfa katları ı
edilecek byte miktarı ı ı ı
birinci parametrede belirtilen adres sayfa katları
gibi etki oluşacaktı ı ı
alabilir:
MS_SYNC: Burada yön bellekten diske doğrudur. Yani biz bellek tabanlı ı ı ı ı ı
yansı ı ı
sağlamaktadı ı ı ı ı
MS_ASYNC: MS_SYNC bayrağı ı ı
geri döndüğünde flush işlemi başlatı ı ı
MS_INVALIDATE: Buradaki yön diskten belleğe doğrudur. Yani başka bir proses diskteki dosyayı ı
dosyanı ı ı ı ı ı
munmap işlemi ile bellek tabanlı ı ı ı ı
sonlanmı ı ı ı ı
Fonksiyon başarı ı ı ı
Bu durumda biz POSIX standartları ı ı ı ı ı ı ı ı
o alanı ı ı ı ı ı
if ((maddr = (char *)mmap(NULL, finfo.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED)
exit_sys("mmap");
memcpy(maddr, "ankara", 6);
if (msync(maddr, finfo.st_size, MS_SYNC) == -1) /* bellekteki değişiklikler diske yansı ı ı
exit_sys("msync");
Yine POSIX standartları ı ı ı ı ı ı ı
dosyanı ı ı ı ı ı ı
if ((maddr = (char *)mmap(NULL, finfo.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED)
exit_sys("mmap");
/* başka bir proses dosya üzerinde değişiklik yapmı
if (msync(maddr, finfo.st_size, MS_INVALIDATE) == -1) /* diskteki değişiklikler belleğe yansı ı ı
exit_sys("msync");
msync fonksiyonunda yalnı ı
çalı ı ı
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/mman.h>
void exit_sys(const char *msg);
int main(int argc, char *argv[])
{
int fd;
struct stat finfo;
char *fmaddr;
if (argc != 2) {
fprintf(stderr, "wrong number of arguments!..\n");
exit(EXIT_FAILURE);
}
if ((fd = open(argv[1], O_RDWR)) == -1)
exit_sys("open");
if (fstat(fd, &finfo) == -1)
exit_sys("fstat");
if ((fmaddr = (char *)mmap(NULL, finfo.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED)
exit_sys("mmap");
printf("press ENTER to write...\n");
getchar();
memcpy(fmaddr, "XXXXXX", 6);
if (msync(fmaddr, 4096, MS_SYNC) == -1)
exit_sys("msync");
if (munmap(fmaddr, finfo.st_size) == -1)
exit_sys("munmap");
close(fd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows'ta paylaşı ı ı
bu sistemlerde kullanı ı ı ı ı ı
kullanı ı
1) Önce iki proses de CreateFileMapping API fonksiyonuyla bir "file mapping" nesnesi oluşturur. CreateFileMapping fonksiyonunun prototipi
şöyledir:
HANDLE CreateFileMappingA(
HANDLE hFile,
LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
DWORD flProtect,
DWORD dwMaximumSizeHigh,
DWORD dwMaximumSizeLow,
LPCSTR lpName
);
Fonksiyonun birinci parametresi bellek tabanlı ı ı ı ı
için INVALID_HANDLE_VALUE özel değeri geçilmelidir. İkinci parametre kernel nesnesinin güvenlik bilgilerine ilişkindir. Bu parametre
NULL geçilebilir. Üçüncü parametre file mapping nesnesinin koruma özelliklerini belirtir. Bu parametre aşağı
girilmelidir:
PAGE_EXECUTE_READ
PAGE_EXECUTE_READWRITE
PAGE_EXECUTE_WRITECOPY
PAGE_READONLY
PAGE_READWRITE
PAGE_WRITECOPY
Burada PAGE_READONLY yalnı
için, PAGE_EXECUTE_XXX bayrakları ı ı ı ı ı ı ı ı
kullanı ı ı ı
düşük anlamlı ı ı ı
nesnesinin uzunuğu ilgili dosyanı ı
için gerekli olan ismi belirtir. Bu isim bir dosya ismi değildir. Programcı ı
alt prosesler arası ı ı ı
bir file mapping nesnesi yoksa onu yaratı ı ı ı ı ı
durumunda NULL adrese geri dönmektedir. Eğer file mapping nesnesi varsa ve biz onu açı ı ı
fonksiyonu fonksiyonu çağrı ı ı
CreateFileMapping fonksiyonu UNIX/Linux sistemlerindeki işlevsel olarak shm_open fonksiyonuna benzetilebilir.
Örneğin:
HANDLE hFileMapping;
...
if ((hFileMapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, FILE_MAPPING_NAME)) == NULL)
ExitSys("CreateFileMapping");
2) Artı
Bu işlem MapViewOfFile API fonksiyonuyla yapı ı
LPVOID MapViewOfFile(
HANDLE hFileMappingObject,
DWORD dwDesiredAccess,
DWORD dwFileOffsetHigh,
DWORD dwFileOffsetLow,
SIZE_T dwNumberOfBytesToMap
);
Fonksiyonun birinci parametresi file mapping nesnesinin handle değerini almaktadı
sayfaları
"read only" yapabiliriz.) Buradaki bayraklar aşağı ı ı ı
FILE_MAP_READ
FILE_MAP_WRITE
FILE_MAP_ALL_ACCESS
FILE_MAP_COPY
FILE_MAP_EXECUTE
FILE_MAP_LARGE_PAGES
FILE_MAP_TARGETS_INVALID
Bu parametre tipik olarak FILE_MAP_READ|FILE_MAP_WRITE biçiminde girilir. Tabii bu durumda file mapping nesnesinin de PAGE_READWRITE
biçiminde yaratı ı ı
Fonksiyoun sonraki iki parametresi file mapping nesnesinin neresinin map edileceğini belirtmektedir. Bu parametreler 8 byte'lı
değerinin yüksek anlamlı ı ı ı ı ı ı
parametre map edilecek uzunluğu belirtmektedir. Bu değer 0 girilirse file mapping nesnesinin belirtilen offset'ten itibaren geri kalan
hepsi map edilmektedir.
Fonksiyon başarı ı ı ı
MapViewOfFile API fonksiyonu işlevsel olarak UNIX/Linux sistemlerindeki mmap POSIX fonksiyonuna benzetilebilir. Örneğin:
char *pcMapAddr;
...
if ((pcMapAddr = (char*)MapViewOfFile(hFileMapping, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0)) == NULL)
ExitSys("MapViewOfFile");
3) Haberleşme bittikten sonra artı ı ı ı
Fonksiyonun prototipi şöyledir:
BOOL UnmapViewOfFile(
LPCVOID lpBaseAddress
);
Fonksiyon parametre olarak MapViewOfFile fonksiyonu ile tahsis edilmiş olan sanal bellek adresini alı ı ı ı ı ı
bir değere başarı ı ı ı ı
benzetilebilir. Ancak maunmap fonksiyonunun parçalı ı ı ı ı ı
geri bı ı
4) Nihayet CreateFileMapping fonksiyonu ile elde edilmiş olan file mapping nesnesi CloseHandle API fonksiyonuyle kapatı ı ı
prototipini daha önce vermiştik:
BOOL CloseHandle(
HANDLE hObject
);
FileMapping nesneleri son proses de nesneyi kapattı ı
nesnelerin reboot edilene kadar (kernel persistent) ya da silinene kadar kaldı ı ı ı ı ı
Aşağı ı ı ı ı ı
bellek alanı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* Prog1.c */
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#define FILE_MAPPING_NAME "TestFileSharedMemory"
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hFileMapping;
int *mapAddr;
if ((hFileMapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, FILE_MAPPING_NAME)) == NULL)
ExitSys("CreateFileMapping");
if ((mapAddr = (int *)MapViewOfFile(hFileMapping, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0)) == NULL)
ExitSys("MapViewOfFile");
for (int i = 0; i < 100; ++i)
mapAddr[i] = i;
printf("Press ENTER to EXIT...\n");
getchar();
UnmapViewOfFile(mapAddr);
CloseHandle(hFileMapping);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/* Prog2.c */
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#define FILE_MAPPING_NAME "TestFileSharedMemory"
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hFileMapping;
int *mapAddr;
if ((hFileMapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, FILE_MAPPING_NAME)) == NULL)
ExitSys("CreateFileMapping");
if ((mapAddr = (int *)MapViewOfFile(hFileMapping, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0)) == NULL)
ExitSys("MapViewOfFile");
printf("Press ENTER to read...\n");
for (int i = 0; i < 100; ++i)
printf("%d ", mapAddr[i]);
printf("\n");
UnmapViewOfFile(mapAddr);
CloseHandle(hFileMapping);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde bellek tabalı ı ı ı ı ı ı ı
1) İlgili dosya CreateFile API fonksiyonuyla açı ı
2) Açı ı
artı
3) File mapping nesnesinin handle değeri verilerek MapViewOfFile fonksiyonu çağrı ı
4) Kullanı ı ı ı ı ı
dosya CloseHandle fonksiyonları ı ı
Windows sistemlerinde de "unified file system" kullanı ı ı ı ı
olduğu gibi işletim sisteminin kullandı ı ı ı
bir şey yazdı ı ı ı ı ı
sistemlerinde bu durum Microsoft tarafı
bir fonksiyon yoktur.
Aşağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hFile;
HANDLE hFileMapping;
char *mapAddr;
DWORD dwSize;
if ((hFile = CreateFile("test.txt", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
ExitSys("CreateFile");
if ((dwSize = GetFileSize(hFile, NULL)) == INVALID_FILE_SIZE && GetLastError() != NO_ERROR)
ExitSys("GetFileSize");
if ((hFileMapping = CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, 0, NULL)) == NULL)
ExitSys("CreateFileMapping");
if ((mapAddr = (char *)MapViewOfFile(hFileMapping, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0)) == NULL)
ExitSys("MapViewOfFile");
for (DWORD i = 0; i < dwSize; ++i)
putchar(mapAddr[i]);
putchar('\n');
memcpy(mapAddr, "XXXXX", 5);
UnmapViewOfFile(mapAddr);
CloseHandle(hFileMapping);
CloseHandle(hFile);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
56. Ders 13/01/2024 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı
çeşitli kaynaklara başvurabilirsiniz. Örneğin aşağı ı ı ı ı ı
https://www.ece.ualberta.ca/~elliott/ee552/studentAppNotes/2003_w/misc/bmp_file_format/bmp_file_format.htm
Aşağı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <Windows.h>
void ExitSys(LPCSTR lpszMsg);
#define ROUND_UP(val, n) (((val) + (n) - 1) / (n) * (n))
#pragma pack(1)
typedef struct tagBITMAP_FILE_HEADER {
uint8_t signature[2];
uint32_t file_size;
uint32_t reserved;
uint32_t data_offset;
} BITMAP_FILE_HEADER;
typedef struct tagBITMAP_INFO_HEADER {
uint32_t header_size;
uint32_t image_width;
uint32_t image_height;
uint16_t plane;
uint16_t bits_per_pixel;
uint32_t compression;
uint32_t compressed_image_size;
uint32_t horizontal_res;
uint32_t vertical_res;
uint32_t color_used;
uint32_t important_colors;
} BITMAP_INFO_HEADER;
typedef struct tagBITMAP_FORMAT {
BITMAP_FILE_HEADER file_header;
BITMAP_INFO_HEADER info_header;
/* ... */
} BITMAP_FORMAT;
typedef struct tagRGB {
uint8_t red, green, blue;
} RGB;
void get_pixel24(uint8_t *dbmp, int width, int height, int row, int col, RGB *rgb);
int main(void)
{
HANDLE hFile;
HANDLE hFileMapping;
DWORD dwSize;
BITMAP_FORMAT *bmp;
const char *compression_types[] = {"NO COMPRESSION", "8 BIT RLE ENCODING", "4 BIT RLE_ENCODING"};
uint8_t *dbmp;
RGB rgb;
if ((hFile = CreateFile("test.bmp", GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
ExitSys("CreateFile");
if ((dwSize = GetFileSize(hFile, NULL)) == INVALID_FILE_SIZE && GetLastError() != NO_ERROR)
ExitSys("GetFileSize");
if ((hFileMapping = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) == NULL)
ExitSys("CreateFileMapping");
if ((bmp= (BITMAP_FORMAT *)MapViewOfFile(hFileMapping, FILE_MAP_READ, 0, 0, 0)) == NULL)
ExitSys("MapViewOfFile");
printf("Signature: %c%c (%02X %02X)\n", bmp->file_header.signature[0], bmp->file_header.signature[1],
bmp->file_header.signature[0], bmp->file_header.signature[1]);
printf("File Size:%lu (%lX)\n", (unsigned long)bmp->file_header.file_size, (unsigned long)bmp->file_header.file_size);
printf("Data Offset: %lu (%lX)\n", (unsigned long)bmp->file_header.data_offset, (unsigned long)bmp->file_header.data_offset);
printf("Info Header Size: %lu (%lX)\n", (unsigned long)bmp->info_header.header_size, (unsigned long)bmp->info_header.header_size);
printf("Image Width: %lu (%lX)\n", (unsigned long)bmp->info_header.image_width, (unsigned long)bmp->info_header.image_width);
printf("Image Height: %lu (%lX)\n", (unsigned long)bmp->info_header.image_height, (unsigned long)bmp->info_header.image_height);
printf("Bits Per Pixel: %lu (%lX)\n", (unsigned long)bmp->info_header.bits_per_pixel, (unsigned long)bmp->info_header.bits_per_pixel);
printf("Compression: %s\n", compression_types[bmp->info_header.compression]);
/* .... */
dbmp = (uint8_t *)bmp + bmp->file_header.data_offset;
get_pixel24(dbmp, bmp->info_header.image_width, bmp->info_header.image_height, 46, 157, &rgb);
printf("Red: %d, Green: %d, Blue: %d\n", rgb.red, rgb.green, rgb.blue);
UnmapViewOfFile(bmp);
CloseHandle(hFileMapping);
CloseHandle(hFile);
return 0;
}
void get_pixel24(uint8_t *dbmp, int width, int height, int row, int col, RGB *rgb)
{
uint32_t destoff;
destoff = (height - row - 1) * ROUND_UP(width * 3, 4) + col * 3;
rgb->blue = dbmp[destoff];
rgb->green = dbmp[destoff + 1];
rgb->red = dbmp[destoff + 2];
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Diğer bir proseslerarası ı ı
sistemlerinde kullanı ı ı ı ı ı ı
fonksiyon grubuyla kullanı ı ı ı
POSIX mesaj kuyrukları ı ı ı ı ı ı ı
POSIX standartları ı ı ı
Bugün programcı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Haberleşme sistemleri verilerin gönderilip alı ı ı ı
1) Stream Tarzı
2) Paket ya da Mesaj Tarzı
Stream tarzı ı ı ı ı
stream tarzı ı ı
sı ı ı
almak zorunda değildir. Paket ya da mesaj tabanlı ı ı
Alan taraf byte düzeyinde alma yapamaz. Gönderilen paketin hepsini almak zorundadı
haberleşmesi de denilmektedir.
İşte borular stream tabanlı ı ı ı
sunmaktadı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
POSIX mesaj kuyrukları ı ı
1) İki proses de (daha fazla proses de olabilir) mesaj kuyruğunu mq_open fonksiyonuyla ortak bir isim altı
mq_open fonksiyonunun prototipi şöyledir:
#include <mqueue.h>
mqd_t mq_open(const char *name, int oflag, ...);
Fonksiyon ya iki argümanla ya da dört argümanla çağrı ı ı ı
mesaj kuyruğunun yaratı ı ı ı ı ı
ise son iki parametreye sı ı ı ı
adeta fonksiyonun parametrik yapı ı ı ı ı ı ı
mqd_t mq_open(const char *name, int oflag, mode_t mode, const struct mq_attr *attr);
Fonksiyonun birinci parametresi IPC nesnesinin kök dizindeki dosya ismi gibi uydurulmuş olan ismini belirtir. İkinci parametre açı ı ı
belirtmektedir. Burada open fonksiyonundaki bayrakları ı ı ı ı ı ı ı ı
zorundadı
O_RDONLY
O_WRONLY
O_RDWR
Açı ı ı ı
O_CREAT
O_EXCL
O_NONBLOCK
O_CREAT bayrağı ı ı ı
bu durumda fonksiyonun başarı ı ı ı ı ı
Eğer açı ı ı ı
iki argüman zaten kullanı ı ı ı ı ı ı
hakları ı ı ı ı ı
vermelidir. Eğer mesaj kuyruğu yaratı ı
yapı ı
struct mq_attr {
long mq_flags; /* Flags: 0 or O_NONBLOCK */
long mq_maxmsg; /* Max. # of messages on queue */
long mq_msgsize; /* Max. message size (bytes) */
long mq_curmsgs; /* # of messages currently in queue */
};
Yapı ı ı ı ı ı ı
Yapı ı ı ı ı ı ı ı
Programcı ı ı ı ı
yaratı ı ı ı ı ı ı ı ı ı ı ı
Yapı ı ı ı ı ı
Bu durumda mesaj kuyruğu default değerlerle yaratı ı
genel olarak default durumda maksimum mesaj mq_maxmsg değeri 10, mq_msgsize değeri ise 8192 alı ı
girerken mq_maxmsg ve mq_msgsize elemanları ı ı
elemanları ı ı
sı ı ı ı ı
bu değeri 10'un yukarı ı ı ı
sonraki paragraflarda açı ı
mq_open fonksiyonu başarı ı ı ı ı
dönmektedir. Fonksiyonun geri döndürdüğü "mesaj kuyruğu betimleyicisi (message queue descriptor)" diğer fonksiyonlarda bir handle değeri
gibi kullanı ı ı ı ı ı
sistemlerinde dosya betimleyici tablosunda bir betimleyici tahsis edip ona geri dönmektedir. Ancak POSIX standartları
dönüş değerini mqd_t türüyle temsil etmiştir. Bu durum değişik çekirdeklerde mesaj kuyrukları ı ı ı
de gerçekleştirilebileceği anlamı ı ı
<mqueue.h> dosyası
2) POSIX mesaj kuyruğuna mesaj yollamak için mq_send fonksiyonu kullanı ı
#include <mqueue.h>
int mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio);
Fonksiyonun birinci parametresi mesaj kuyruğunun betimleyicisini belirtir. Fonksiyonun ikinci parametresi mesajı
dizin'in adresini almaktadı ı ı
tür dönüştürmesinin yapı ı ı
mesajı ı
öncelik derecesi yüksek olan mesajlar FIFO sı ı ı ı ı ı ı
olduğu gibi belli bir öncelik derecesine sahip mesajları
MQ_PRIO_MAX değerinden küçük olması ı
_POSIX_MQ_PRIO_MAX (32) değerinden düşük olamaz. Yani başka bir deyişle buradaki desteklenen değer 32'den küçük olamamaktadı
(Mevcut Linux sistemlerinde bu değer 32768 biçimindedir.)
Fonksiyon başarı ı ı ı
POSIX mesaj kuyrukları ı ı ı ı
fonksiyonu bloke olmaktadı ı ı ı ı
hiçbir şey yazmadan başarı ı ı
Örneğin:
for (int i = 0; i < 100; ++i) {
if (mq_send(mqdes, (const char *)&i, sizeof(int), 0) == -1)
exit_sys("mq_send");
}
Burada 0'dan 100'e kadar 100 tane int değer mesaj kuyruğuna mesaj olarak yazı ı ı
Mesaj kuyrukları ı
(Linux'taki default değerin 10 olduğunu anı ı ı ı ı
yer açana kadar.
3) POSIX mesaj kuyrukları ı ı
#include <mqueue.h>
ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *msg_prio);
Fonksiyonun birinci parametresi mq_open fonksiyonundan elde edilen mesaj kuyruğu betimleyicisidir. İkinci parametre mesajı
yerleştirileceği adresi belirtmektedir. Yine bu parametrenin void bir gösterici olmadı ı
ediniz. Yani char türünden farklı ı ı
mesajı ı
mq_msgsize değerinden küçük olmaması
ise fonksiyon hemen başarı ı ı
fonksiyonunu uygulayacak programcı ı ı ı ı ı
özellik belirtmişse programcı ı ı
genellikle kuyruk mq_receive yapan programcı ı ı ı ı ı ı ı
programcı ı ı ı ı ı ı ı ı ı
mesajı ı
kuyruktan alı ı ı
adres biçiminde geçilebilir. Bu durumda fonksiyon mesajı
Fonksiyon başarı ı ı ı ı
uygun biçimde set edilmektedir.
Örneğin:
char buf[65536];
...
if (mq_receive(mqdes, buf, 65536, NULL) == -1)
exit_sys("mq_receive");
Burada biz mesajı
büyük bir değer olarak uydurduk. Aslı ı ı ı ı
biliyor durumda olmamı
4) Pekiyi POSIX mesaj kuyrukları ı ı ı ı ı ı ı
anlayamamaktadı ı ı ı ı
Eğer 0 uzunluklu mesaj gönderilirse alan tarafta mq_receive fonksiyonu 0 ile geri dönecek ve alan taraf haberleşmenin bittiğini anlayabilecektir.
5) POSIX mesaj kuyruğu ile işlemler bitince programcı ı ı
#include <mqueue.h>
int mq_close(mqd_t mqdes);
Fonksiyon parametre olarak mesaj kuyruğu betimleyicicisini alı ı ı ı ı
Programcı ı ı ı ı ı
Tabii eğer programcı ı ı
6) POSIX mesaj kuyrukları ı ı
reboot edilene kadar (kernel persistant) yaşamaya ve içerisindeki mesajları
fonksiyonu ile silindiğinde halen mesaj kuyruğunu kullanan programlar varsa onlar kullanmaya devam ederler. Mesaj kuyruğu gerçek anlamda
son mesaj kuyruğu betimleyicisi kapatı ı ı
#include <mqueue.h>
int mq_unlink(const char *name);
Fonksiyon mesaj kuyruğunun ismini alı ı ı ı ı
Mesaj kuyruğunu, kuyruğu yaratan tarafı ı ı
kuyruğu silebilir.
Aşağı ı ı ı ı
yazmaktadı ı ı ı ı ı ı ı
kuyruğa yazdı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* prog1.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mqueue.h>
#define MESSAGE_QUEUE_NAME "/TestMessageQueue"
#define BUFFER_SIZE 8192
void exit_sys(const char *msg);
int main(void)
{
mqd_t mqd;
char buf[BUFFER_SIZE];
char *str;
if ((mqd = mq_open(MESSAGE_QUEUE_NAME, O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH, NULL)) == -1)
exit_sys("mq_open");
for (;;) {
printf("Message:");
if (fgets(buf, BUFFER_SIZE, stdin) == NULL)
continue;
if ((str = strchr(buf, '\n')) != NULL)
*str = '\0';
if (mq_send(mqd, buf, strlen(buf), 0) == -1)
exit_sys("mq_send");
if (!strcmp(buf, "quit"))
break;
}
mq_close(mqd);
if (mq_unlink(MESSAGE_QUEUE_NAME) == -1)
exit_sys("mq_unlink");
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/* prog2.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mqueue.h>
#define MESSAGE_QUEUE_NAME "/TestMessageQueue"
#define BUFFER_SIZE 8192
void exit_sys(const char *msg);
int main(void)
{
mqd_t mqd;
char buf[BUFFER_SIZE];
ssize_t result;
if ((mqd = mq_open(MESSAGE_QUEUE_NAME, O_RDONLY|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH, NULL)) == -1)
exit_sys("mq_open");
for (;;) {
if ((result = mq_receive(mqd, buf, BUFFER_SIZE, NULL)) == -1)
exit_sys("mq_receive");
buf[result] = '\0';
if (!strcmp(buf, "quit"))
break;
printf("%s\n", buf);
}
mq_close(mqd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Kurusumuzun bu bölümünde dikkatimizi veri yapı ı ı ı ı ı ı
ve algoritmalar konusunda belli düzeyde bilgi sahibi olması
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Araları ı ı ı
Veri yapı ı ı ı
yapı ı ı ı ı
"birlikler (unions)" dilin sentaksı ı ı ı ı ı
yapı ı ı ı ı ı ı ı ı ı ı
kullanarak diğer veri yapı ı ı ı
Nesne Yönelimli Programlama Dillerinde genellikle o dillerin kütüphanelerinde pek çok veri yapı ı ı ı ı
bulunudurlmaktadı ı ı
"bağlı ı ı ı ı ı
yapı ı ı
bu bölümde ele alacağı ı ı ı ı ı ı ı ı ı ı
tanı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir problemi kesin çözüme götüren adı ı
Muhammed bin Mûsâ el-Hârizmî'nin isminden hareketle (bazı ı ı ı
çözüme götürmesi gerekir. Eğer söz konusu adı
yerine "sezgisel yöntemler (heuristic)" denilmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi algoritmalar nası ı ı ı ı
Algoritmaları ı ı ı ı
edilip bir değişkende saklanı ı ı ı ı
değişkene yerleştirilir" gibi. Ancak sözel açı ı ı
belirlemelerin yapı ı ı ı ı
programlama dilinde yazı ı ı ı ı ı ı
Artı ı ı
Pekiyi algoritmaları
Dil ne kadar alçak seviyeli olursa algoritmadaki inceliği o kadar iyi yansı ı ı
ön plandadı ı ı ı ı ı
Python kanı ı ı ı
ve dokümanlar bulunmaktadı ı ı ı ı ı ı
mevcut bir dil kullanı ı ı ı ı ı
kodlar biçiminde ifade edilmektedir.
Algoritmalar konusunda en bilindik kişi Donald Knuth isimli araştı ı ı
"The Art of Compuer Programming" isimli kitabı ı
başvuru kitabı ı ı ı
MIX dilinin RMIX isimli RISC tabanlı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir problemi çözebilen pek çok alternatif algoritmalar söz konusu olabilmektedir. Bunları
gerekir. Tabii bunun için bir "iyilik ölçütü" tespit edilmelidir. Algoritmaları ı ı ı ı
önemli ölçüt "hı ı ı ı ı ı ı ı ı
sonuç veriyorsa o algoritma tercih edilmektedir. Tabii bazen kı ı ı ı ı ı
kullanı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
İki algoritmanı ı ı ı ı ı ı ı
sağlanması ı ı ı ı ı ı
Bu durumda örneğin dizinin dağı ı ı ı
Algoritmaları ı ı ı ı ı ı ı ı ı
Bu algoritmalar rastgele girdilerle çok fazla kez çalı ı ı ı ı ı ı
yöntemlerden biridir. Ancak simülasyon yöntemini uygulamak oldukça zordur. Her algoritmayı ı ı
çalı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
58. Ders 20/01/2024 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Algoritmaları ı ı ı ı ı ı
denilmektedir. Pekiyi algoritma analizi nası ı ı ı ı ı ı ı ı
Tabii bu işlem sayı ı ı ı ı
işlemlerin sayı ı ı ı ı ı
çarpma işlemi toplama işlemine göre çok daha yavaş yapı ı
işlemde bulunacağı ı
int a[N];
for (int i = 0; i < N; ++i)
if (a[i] == VAL)
break; /* bulundu */
Burada işlem sayı ı
int i = 0
i < N
++i
a[i] == VAL
Ancak burada aranacak olan VAL değerinin dizinin kaçı ı ı ı ı ı
algoritma analiz edilirken tipik olarak iki durum için hesaplama yapı ı
1) En kötü durum analizi (worst case analyisis)
2) Ortalama durum analizi (average case analysis)
En iyi durum analizi de söz konusu olabilirse de pratikte çok iyimser bir yaklaşı ı
Yukarı ı ı ı ı ı ı
en kötü durumdaki işlem sayı ı ı ı ı
indekslerde bulunması ı ı
1 + (3 * (1 + 2 + 3 + ... + N) / N)
1'den N'e kadar sayı ı ı
1 + (3 * (N + 1) / 2)
Tabii bu tür hesaplamalarda bizim sabit olmayan kı ı ı ı ı ı ı ı
Bu tür durumlarda bizim için önemli olan bu N değerinin artması ı ı ı ı
Algoritmalar dünyası ı ı ı ı ı ı
ifadelere "algoritmanı ı ı ı ı ı ı ı ı
olarak algortimanı ı ı ı ı ı ı ı ı ı ı ı
1 + (3 * (N + 1) / 2) olarak belirtilebilir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir algoritmanı ı ı ı ı ı ı ı ı ı
oldukça zor olabilmektedir. Bu nedenle genellikle karmaşı ı ı ı ı ı ı ı ı
yoluna gidilmektedir. Bu tür kategorik karşı ı ı ı ı
karakteri hakkı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Algoritmaları ı ı ı ı ı
aslı ı ı ı ı ı ı ı
büyüme karakteristiği ile ilgili çalı ı ı
Algoritma karmaşı ı ı ı ı
- Big O Notasyonu
- Büyük Teta Notasyonu
- Büyük Omega Notasyonu
- Küçük o Notasyonu
Ancak Big O notasyonu en çok kullanı
Bu notasyonlar aslı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Big O notasyonu aşağı
f(x) = O(g(x))
Burada f(x) ve g(x) iki fonksiyondur. Notasyondaki eşittir karakteri eleştirilmektedir. Buradaki eşittir karakteri aslı
eşitliği anlatmamaktadı ı ı ı
3x = O(X^2)
5X^2 = O(X^2)
Burada 3x ve 5X^2 fonksiyonları
Big O notasyonunun matematiksel sembollerle biçimsel (formal) açı ı ı ı ı ı ı
"Algorithms and Complexity" kitabı ı ı ı
biçimsel açı ı
Big O notasyonunda kategori olarak O(gx(x)) ifadesiyle belirtilmiş olan fonksiyon ile üstel bakı ı
fonksiyonlar kstedilmektedir. Örneğin O(x^2) kategorisi üssü en fazla iki olan tüm fonksiyonları ı
belirtmektedir. Örneğin aşağı ı ı ı
f(x) = 100
f(x) = 3x
f(x) = 3x^2
f(x) = 100x^2 + 80x +5
f(x) = 2X^2 - 5x - 8
Burada x^2'nin katsayı ı ı ı ı
Başka bir deyişle O(x^2) kategorisi k x^2 ve x^1 ve sabitin tüm toplamları ı
O(x) kategorisine ilişkin bazı ı
f(x) = 3x
f(x) 0 100x - 5
f(x) = x - 1
f(x) = 10
Burada da x'in katsayı ı ı
Big O notasyonunda O(1) karmaşı ı ı ı ı ı
Yani O(5) ile O(1) aynı ı ı ı ı
f(x) = 123
f(x) = 1234567
f(x) = 1
Big O notasyonunda g(x) fonksiyonundaki çarpanı ı ı
arası ı ı ı ı ı
Bu nedenle kategoriler belirtilirken gereksiz biçimde g(x) fonksiyonunda çarpan ve toplam değerler belirtilmez.
Big O natsyonunun biçimsel açı ı ı
f(x) = O(g(x)) (x → ∞) if ∃ C, x0 öyle ki |f(x)| < Cg(x) tüm x > x0 değerleri için
Burada şu belirtilmektedir: f(x) = O(g(x)) olabilmesi için |f(x)| < Cg(x) eşitliğini sağlayabilecek bir C değerinin bulunması
Örneğin 3x^2 + 5x + 2 = O(x^2) yazı
sonra her zaman 3X^2 + 5x + 2 değerinden büyük kalacaktı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Algoritmaları ı ı ı ı
gösterimini kullanacağı
O(1) Sabit Karmaşı ı
O(log log N) Çifte Logaritmik Karmaşı ı
O(log N) Logaritmik Karmaşı ı
O((log N)^c) c > 1 olmak üzere Polylogaritmik Karmaşı ı
O(N^c) c < 0 < 1 olmak üzere Oransal Kuvvet Karmaşı ı ı
O(N) Doğrusal Karmaşı ı
O(N log N) N Log N karmaşı ı ı
O(N^2) Karesel Karmaşı ı
O(N^3) Küpsel Karmaşı ı
O(N^c) Polinomsal Karmaşı ı
O(c^N) c > 1 olmak üzere Üstel Karmaşı ı
O(N!) Faktöriyel Karmaşı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Algoritmaları ı ı ı ı
Hangi kategorinin diğerinden daha iyi olup olmadı ı ı ı ı ı ı ı
bu farklı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi bir algoritmanı ı ı ı ı
Örneğin N bir dizinin uzunluğu olabilir. Bazı ı
- Tekil ifadeler içeren ve N değrine bağlı ı ı ı
alanı ı ı ı ı ı ı ı ı ı
O(1) yani sabit karmaşı ı ı ı ı ı ı ı ı
sahip bir algoritma kullanı ı ı
dizinin bir elemanı ı ı ı
- Bir algoritmada bir döngü varsa ancak döngü N'in logaritması
O(log N) karmaşı ı ı ı ı ı
- Bir algoritma N'e dayalı ı ı ı ı ı
sözel olarak "doğrusal karmaşı ı ı ı ı ı ı
bulunması ı ı ı ı ı ı ı ı ı
belli bir elemanı ı ı ı ı ı ı ı
arama sı ı
- O(N log N) karmaşı ı ı ı ı ı
Tabii algoritma başka N'e dayalı ı
O(N log N) karmaşı ı ı
- N'e dayalı ı ı ı ı ı
Örneğin "boubble sort", "selection sort" gibi algoritmalar O(N^2) karmaşı ı ı ı ı ı ı
Bu durumda örneğin "selection sort" algoritması ı
- N'e dayalı ı
O(N^3) yani küpsel karmaşı ı ı ı ı ı ı ı
çözümleri de vardı
- İç içe k tane döngü içerebilen tüm algoritmalara genel olarak "polinomsal karmaşı ı
- Alt küme işlemlerine ilişkin algoritmalar tipik olarak O(c^n) yani üstel karmaşı ı ı ı ı ı
olduğunu anı ı ı
- Bazı ı ı ı ı ı
karmaşı ı ı ı ı ı ı
Üstel karmaşı ı ı ı ı ı ı
kı ı ı ı ı
boyutlara gelebilmektedir. Pek çok NP algoritma için polinomsal karmaşı ı ı
önemli başarı ı ı ı
denilen yöntemler kullanı ı ı ı
makul bir zaman içerisinde bulmayı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Algoritma analizinde en çok Big O notasyonu kullanı ı ı ı ı
üst sı ı
Büyük omega notasyonu Big O notasyonunun tersi gibidir. Yani bu notasyondan amaç alt sı ı
x^2 den daha yüksek üslü polinomları ı ı
3x^3 + 4x = Ω(x^2)
3x^5 = Ω(x^2)
7x^5 + 6x^2 + 4x = Ω(x^2)
3x^2 gibi bir fonksiyonun Ω(x^2) kategorisinde olamayacağı ı ı
Yukarı ı ı ı ı
Büyük Teta notasyonu tam sı ı ı ı
Ancak katsayı ı ı
3x^2 = Θ(x^2)
7x^2 + 4x = Θ(x^2)
10x^2 + 5x + 2= Θ(x^2)
Ancak aşağı
7x
5x^3
7x^4 + 3X^2 + 2
100
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
C'de "diziler", "yapı ı ı ı ı ı
Ancak bu veri yapı ı ı ı ı ı ı
desteklenmeyen ancak uygulamalarda sı ı ı ı ı ı ı ı
dilinin temel kütüphanelerinde birer sı ı ı ı ı ı
veri yapı ı ı ı ı ı ı ı
çalı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Veri yapı ı ı ı ı
türü" biçiminde çevirebiliriz. Abstract data type denildiğinde Belli bir veri yapı ı ı ı ı ı
Burada "abstract" sözcüğü "soyutlama" yani "aytrı ı ı ı ı
data type denildiğinde bir veri yapı ı ı ı
tekniğinde bir sı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
En çok kullanı ı ı ı ı ı
anlamı ı ı ı ı ı ı
etmiş olduğu diziyi büyütmektedir. Ancak veri yapı ı ı ı ı ı ı ı ı
kütüphanesinde "vector" ismi ile C# ve Java ortamları ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Dinamik dizilerin gerçekleştirilmesinde önemli olan birkaç nokta vardı ı
dizinin ne kadar büyütüleceğidir. Diziyi birer birer büyütmek iyi bir fikir değildir. Çünkü dinamik tahsisatlar yavaş olma eğilimindedir.
Genellikle büyütme "eskisinin iki katı ı ı
karmaşı ı ı ı ı ı ı ı ı
ve o anda dizi için tahsis edilen elemanı ı ı ı
"size" denilmektedir. Dizi için tahsis edilmiş olan eleman sayı ı
Dinamik dizinin sonuna eleman eklerken eleman count (ya da size) ile belirtien indekse eklenir ve count değer bir artı ı
capacity değerine ulaştı ı ı
benzer biçimde eklenmektedir. Genel olarka dinamik dizilerin gerçekleştirimlerinde eleman silindiğinde kapasite azaltı ı ı ı
Dinamik dizilerin gerçekleştirilmesinde kullanı ı ı
- Dinamik dizinin yaratı ı
- Dinamik dizinin yok edilmesi
- Dinamik dizinin sonuna eleman eklenmesi
- Araya elemanı
- Count ve capacity değerleriin dı ı
- Elemanları
- Belli bir indeksteki elemanı
- Dizideki tüm elemanları
- Capacity değerinin büyütülmesi
- Capacity değerinin count değerine çekilmesi
Genel olarak dinamik büyütülen dizilerde bir elemanı ı
yaratmamaktadı ı ı
Ancak özel bir durum olarak capacity değeri count değerine çekilebilmektedir.
Aşağı ı
fonksiyon biçiminde başlı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* dynamicarray.h */
#ifndef DYNAMICARRAY_H_
#define DYNAMICARRAY_H_
/* Symbolic Constants */
#define DARRAY_DEF_CAPACITY 8
#define DARRAY_FAILED ((size_t)-1)
/* Type Declaratrions */
typedef int DATATYPE;
typedef struct tagDARRAY {
DATATYPE *darray;
size_t capacity;
size_t count;
} DARRAY, *HDARRAY;
/* Function Prototypes */
HDARRAY create_darray(void);
void destroy_darray(HDARRAY hdarray);
size_t add_darray(HDARRAY hdarray, DATATYPE val);
size_t multiadd_darray(HDARRAY hdarray, const DATATYPE *vals, size_t size);
size_t addp_darray(HDARRAY hdarray, const DATATYPE *val);
size_t insert_darray(HDARRAY hdarray, size_t index, DATATYPE val);
size_t remove_darray(HDARRAY hdarray, size_t index);
size_t reserve_darray(HDARRAY hdarray, size_t newcapacity);
/* inine function definitions */
static inline size_t capacity_darray(HDARRAY hdarray)
{
return hdarray->capacity;
}
static inline size_t count_darray(HDARRAY hdarray)
{
return hdarray->count;
}
static inline DATATYPE get_darray(HDARRAY hdarray, size_t index)
{
return hdarray->darray[index];
}
static inline void set_darray(HDARRAY hdarray, size_t index, DATATYPE val)
{
hdarray->darray[index] = val;
}
static inline void setp_darray(HDARRAY hdarray, size_t index, const DATATYPE *val)
{
hdarray->darray[index] = *val;
}
static inline void getp_darray(HDARRAY hdarray, size_t index, DATATYPE *val)
{
*val = hdarray->darray[index];
}
static inline void clear_darray(HDARRAY hdarray)
{
hdarray->count = 0;
}
#endif
/* dynamic.arry.c */
#include <stdio.h>
#include <stdlib.h>
#include "dynamicarray.h"
static int reallocate(HDARRAY hdarray, size_t newcapacity);
HDARRAY create_darray(void)
{
HDARRAY hdarray;
if ((hdarray = (HDARRAY)malloc(sizeof(DARRAY))) == NULL)
return NULL;
if ((hdarray->darray = (DATATYPE *)malloc(sizeof(DATATYPE) * DARRAY_DEF_CAPACITY)) == NULL) {
free(hdarray);
return NULL;
}
hdarray->capacity = DARRAY_DEF_CAPACITY;
hdarray->count = 0;
return hdarray;
}
void destroy_darray(HDARRAY hdarray)
{
free(hdarray->darray);
free(hdarray);
}
size_t add_darray(HDARRAY hdarray, DATATYPE val)
{
if (hdarray->count == hdarray->capacity && reallocate(hdarray, hdarray->capacity * 2) == -1)
return DARRAY_FAILED;
hdarray->darray[hdarray->count++] = val;
return hdarray->count - 1;
}
size_t multiadd_darray(HDARRAY hdarray, const DATATYPE *vals, size_t size)
{
if (hdarray->count + size > hdarray->capacity && reallocate(hdarray, hdarray->capacity * 2 + size) == -1)
return DARRAY_FAILED;
memmove(hdarray->darray + hdarray->count, vals, sizeof(DATATYPE) * size);
hdarray->count += size;
return hdarray->count - 1;
}
size_t addp_darray(HDARRAY hdarray, const DATATYPE *val)
{
if (hdarray->count == hdarray->capacity && reallocate(hdarray, hdarray->capacity * 2) == -1)
return DARRAY_FAILED;
hdarray->darray[hdarray->count++] = *val;
return hdarray->count - 1;
}
size_t insert_darray(HDARRAY hdarray, size_t index, DATATYPE val)
{
if (index > hdarray->count)
return DARRAY_FAILED;
if (hdarray->count == hdarray->capacity && reallocate(hdarray, hdarray->capacity * 2) == -1)
return DARRAY_FAILED;
memmove(hdarray->darray + index + 1, hdarray->darray + index, (hdarray->count - index) * sizeof(DATATYPE));
hdarray->darray[index] = val;
++hdarray->count;
return index;
}
size_t insertp_darray(HDARRAY hdarray, size_t index, const DATATYPE *val)
{
if (index > hdarray->count)
return DARRAY_FAILED;
if (hdarray->count == hdarray->capacity && reallocate(hdarray, hdarray->capacity * 2) == -1)
return DARRAY_FAILED;
memmove(hdarray->darray + index + 1, hdarray->darray + index, (hdarray->count - index) * sizeof(DATATYPE));
hdarray->darray[index] = *val;
++hdarray->count;
return index;
}
size_t remove_darray(HDARRAY hdarray, size_t index)
{
if (index >= hdarray->count)
return DARRAY_FAILED;
memmove(hdarray->darray + index, hdarray->darray + index + 1, (hdarray->count - index - 1) * sizeof(DATATYPE));
--hdarray->count;
return index;
}
size_t reserve_darray(HDARRAY hdarray, size_t newcapacity)
{
if (newcapacity <= hdarray->capacity)
return 0;
if (reallocate(hdarray, newcapacity) == -1)
return 0;
return newcapacity;
}
static int reallocate(HDARRAY hdarray, size_t newcapacity)
{
DATATYPE *new_darray;
if ((new_darray = (DATATYPE *)realloc(hdarray->darray, sizeof(DATATYPE) * newcapacity)) == NULL)
return -1;
hdarray->darray = new_darray;
hdarray->capacity = newcapacity;
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
60. Ders 27/01/2024 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Araları ı ı ı ı ı
veri yapı ı ı ı ı ı ı ı ı ı ı ı ı ı
elemanı ı ı ı ı ı ı ı ı ı ı ı ı
denilmektedir. Dizi elemanları ı ı ı ı ı ı ı ı
ardı ı
Bağlı ı ı ı ı
listelerde her düğüm sonraki düğümün yerini tutarsa ve ilk elemanı ı ı
Örneğin:
head ----> node ---> node ---> node ----> node (NULL)
Bağlı ı ı ı ı ı
ile ifade edilmektedir. Örneğin:
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *next;
} NODE;
Bağlı ı ı ı ı
denilmektdir. Örneğin:
NODE *head; /* ilk elemanı
Bağlı ı ı ı ı ı
de "tail göstericisi" denilmektedir.
NODE *tail; /* son elemanı
Tipik olarak bağlı ı
Bağlı ı ı ı
NODE *node;
...
node = head;
while (node != NULL) {
...
node = node->next;
}
Tabii bu dolaşı ı
for (NODE *node = head; node != NULL; node = node->next) {
...
}
Her düğümün yalnı ı ı ı
(double linked list)" denilmektedir. Çift bağlı ı
da gidebiliriz. Çift bağlı ı ı
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *next;
struct tagNODE *prev;
} NODE;
Çift bağlı ı ı ı
en önemli özelliği "adresi bilinen bir düğümün" silinebilmesidir. Tek bağlı
sı ı
Eğer bir bağlı ı ı ı
denilmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi bağlı ı ı ı ı ı ı
farklı ı ı ı
1) Diziler ardı ı ı
alanlar olduğu halde bunlar ardı ı ı ı ı ı ı ı ı
bağlı ı ı ı ı ı ı
açabilmektedir. Bu dinamik diziler zamanla büyüdükçe birbirini engeller hale gelebilmektedir. İşte uzunluğu baştan belli olmayan çok sayı
dizinin oluşturulacağı ı
dinamik dizinin büyütülmesi yavaş bir işlemdir. Çünkü büyütme sı ı
2) Dizilerde araya eleman ekleme (insert etme) ve aradaki bir elemanı ı ı ı
açacağı ı ı ı
listelerde eğer düğümün yerini biliyorsak bu işlem O(1) karmaşı ı ı
araya eleman eklemenin ve aradan eleman silmenin çok yapı ı ı ı ı
3) Bağlı ı ı ı ı
yani çok hı ı ı ı ı ı ı
edilmelidir.
4) Bağlı ı
elemanı ı
O halde bağlı
- Eleman insert etmenin ve eleman silmenin çok yapı ı ı
- Uzunluğu baştan belli olmayan çok sayı ı ı ı
- İndeks yoluyla erişimin az yapı ı ı
- Bellek miktarı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Soyut bir veri türü (abstract data type) olarak bağlı ı ı
- Bağlı ı
- Bağlı ı ı ı
- Adresi bilinen bir düğümün önüne ya da arkası
- Adresi bilinen bir düğümün silinmesi
Aşağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* llist.h */
#ifndef LLIST_H_
#define LLIST_H_
#include <stddef.h>
#include <stdbool.h>
/* Type Declarations */
typedef int DATATYPE;
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *next;
struct tagNODE *prev;
} NODE;
typedef struct tagLLIST {
NODE *head;
NODE *tail;
size_t count;
} LLIST, *HLLIST;
/* Function Prototypes */
HLLIST create_llist(void);
NODE *add_tail(HLLIST hllist, DATATYPE val);
NODE *addp_tail(HLLIST hllist, const DATATYPE *val);
NODE *add_head(HLLIST hllist, DATATYPE val);
NODE *addp_head(HLLIST hllist, const DATATYPE *val);
NODE *insert_next(HLLIST hllist, NODE *node, DATATYPE val);
NODE *insertp_next(HLLIST hllist, NODE *node, const DATATYPE *val);
NODE *insert_prev(HLLIST hllist, NODE *node, DATATYPE val);
NODE *insertp_prev(HLLIST hllist, NODE *node, const DATATYPE *val);
void remove_node(HLLIST hllist, NODE *node);
DATATYPE *getp_item(HLLIST hllist, size_t index);
bool walk_llist(HLLIST hllist, bool (*proc)(DATATYPE *));
bool walk_llist_rev(HLLIST hllist, bool (*proc)(DATATYPE *));
void clear_llist(HLLIST hllist);
void destroy_llist(HLLIST hllist);
/* inline Function Definitions */
static inline size_t count_llist(HLLIST hllist)
{
return hllist->count;
}
#endif
/* llist.c */
#include <stdio.h>
#include <stdlib.h>
#include "llist.h"
/* static Functions Prototypes */
static bool disp(DATATYPE *val);
/* Function Definitions */
HLLIST create_llist(void)
{
HLLIST hllist;
if ((hllist = (HLLIST)malloc(sizeof(LLIST))) == NULL)
return NULL;
hllist->head = hllist->tail = NULL;
hllist->count = 0;
return hllist;
}
NODE *add_tail(HLLIST hllist, DATATYPE val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = val;
if (hllist->head != NULL) /* is list is empty? */
hllist->tail->next = new_node;
else
hllist->head = new_node;
new_node->prev = hllist->tail;
new_node->next = NULL;
hllist->tail = new_node;
++hllist->count;
return new_node;
}
NODE *addp_tail(HLLIST hllist, const DATATYPE *val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = *val;
if (hllist->head != NULL) /* is list is empty? */
hllist->tail->next = new_node;
else
hllist->head = new_node;
new_node->prev = hllist->tail;
new_node->next = NULL;
hllist->tail = new_node;
++hllist->count;
return new_node;
}
NODE *add_head(HLLIST hllist, DATATYPE val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = val;
new_node->next = hllist->head;
new_node->prev = NULL;
if (hllist->head == NULL)
hllist->tail = new_node;
else
hllist->head->prev = new_node;
hllist->head = new_node;
++hllist->count;
return new_node;
}
NODE *addp_head(HLLIST hllist, const DATATYPE *val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = *val;
new_node->next = hllist->head;
new_node->prev = NULL;
if (hllist->head == NULL)
hllist->tail = new_node;
else
hllist->head->prev = new_node;
hllist->head = new_node;
++hllist->count;
return new_node;
}
NODE *insert_next(HLLIST hllist, NODE *node, DATATYPE val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = val;
if (node != hllist->tail)
node->next->prev = new_node;
else
hllist->tail = new_node;
new_node->next = node->next;
node->next = new_node;
new_node->prev = node;
++hllist->count;
return new_node;
}
NODE *insertp_next(HLLIST hllist, NODE *node, const DATATYPE *val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = *val;
if (node != hllist->tail)
node->next->prev = new_node;
else
hllist->tail = new_node;
new_node->next = node->next;
node->next = new_node;
new_node->prev = node;
++hllist->count;
return new_node;
}
NODE *insert_prev(HLLIST hllist, NODE *node, DATATYPE val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = val;
if (node != hllist->head)
node->prev->next = new_node;
else
hllist->head = new_node;
new_node->next = node;
new_node->prev = node->prev;
node->prev = new_node;
++hllist->count;
return new_node;
}
NODE *insertp_prev(HLLIST hllist, NODE *node, const DATATYPE *val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = *val;
if (node != hllist->head)
node->prev->next = new_node;
else
hllist->head = new_node;
new_node->next = node;
new_node->prev = node->prev;
node->prev = new_node;
++hllist->count;
return new_node;
}
void remove_node(HLLIST hllist, NODE *node)
{
if (node == hllist->head)
hllist->head = node->next;
else
node->prev->next = node->next;
if (node == hllist->tail)
hllist->tail = node->prev;
else
node->next->prev = node->prev;
--hllist->count;
free(node);
}
DATATYPE *getp_item(HLLIST hllist, size_t index)
{
NODE *node;
if (index >= hllist->count)
return NULL;
node = hllist->head;
for (size_t i = 0; i < index; ++i)
node = node->next;
return &node->val;
}
bool walk_llist(HLLIST hllist, bool (*proc)(DATATYPE *))
{
bool retval = true;
bool def_flag = false;
if (proc == NULL) {
proc = disp;
def_flag = true;
}
for (NODE *node = hllist->head; node != NULL; node = node->next)
if (!proc(&node->val)) {
retval = false;
break;
}
if (def_flag)
putchar('\n');
return retval;
}
bool walk_llist_rev(HLLIST hllist, bool (*proc)(DATATYPE *))
{
bool retval = true;
bool def_flag = false;
if (proc == NULL) {
proc = disp;
def_flag = true;
}
for (NODE *node = hllist->tail; node != NULL; node = node->prev)
if (!proc(&node->val)) {
retval = false;
break;
}
if (def_flag)
putchar('\n');
return retval;
}
void clear_llist(HLLIST hllist)
{
NODE *node, *temp_node;
node = hllist->head;
while (node != NULL) {
temp_node = node->next;
free(node);
node = temp_node;
}
hllist->head = hllist->tail = NULL;
hllist->count = 0;
}
void destroy_llist(HLLIST hllist)
{
NODE *node, *temp_node;
node = hllist->head;
while (node != NULL) {
temp_node = node->next;
free(node);
node = temp_node;
}
free(hllist);
}
static bool disp(DATATYPE *val)
{
printf("%d ", *val);
fflush(stdout);
return true;
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include "llist.h"
int main(void)
{
HLLIST hllist;
NODE *node, *pos_node;
DATATYPE *val;
if ((hllist = create_llist()) == NULL) {
fprintf(stderr, "cannot create linked list...\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 10; ++i) {
if ((node = add_tail(hllist, i)) == NULL) {
fprintf(stderr, "cannot add item!..\n");
exit(EXIT_FAILURE);
}
if (i == 9)
pos_node = node;
}
walk_llist(hllist, NULL);
remove_node(hllist, pos_node);
walk_llist(hllist, NULL);
if ((val = getp_item(hllist, 5)) == NULL) {
fprintf(stderr, "invalid index!..\n");
exit(EXIT_FAILURE);
}
printf("%d\n", *val);
clear_llist(hllist);
for (int i = 0; i < 10; ++i)
if (add_tail(hllist, i) == NULL) {
fprintf(stderr, "cannot add item!..\n");
exit(EXIT_FAILURE);
}
walk_llist(hllist, NULL);
destroy_llist(hllist);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Çift bağlı ı ı ı
durumlar ortadan kaldı ı ı
next göstericisi handle alanı ı
prev göstericisi ise son düğümün yerini göstermelidir.
Tabii bu durumda handle alanı ı ı ı ı
için kullanı ı ı ı ı
programcı ı ı ı ı ı
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *next;
struct tagNODE *prev;
} NODE;
typedef struct tagLLIST {
NODE head;
size_t count;
} LLIST, *HLLIST;
Başlangı ı ı
yapı ı ı ı ı ı
eşit olmaması
Aşağı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* llist.h */
#ifndef LLIST_H_
#define LLIST_H_
#include <stddef.h>
#include <stdbool.h>
/* Type Declarations */
typedef int DATATYPE;
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *next;
struct tagNODE *prev;
} NODE;
typedef struct tagLLIST {
NODE head;
size_t count;
} LLIST, *HLLIST;
/* Function Prototypes */
HLLIST create_llist(void);
NODE *insert_next(HLLIST hllist, NODE *node, DATATYPE val);
NODE *insertp_next(HLLIST hllist, NODE *node, const DATATYPE *val);
NODE *insert_prev(HLLIST hllist, NODE *node, DATATYPE val);
NODE *insertp_prev(HLLIST hllist, NODE *node, const DATATYPE *val);
NODE *add_tail(HLLIST hllist, DATATYPE val);
NODE *addp_tail(HLLIST hllist, const DATATYPE *val);
NODE *add_head(HLLIST hllist, DATATYPE val);
NODE *addp_head(HLLIST hllist, const DATATYPE *val);
void remove_node(HLLIST hllist, NODE *node);
DATATYPE *getp_item(HLLIST hllist, size_t index);
bool walk_llist(HLLIST hllist, bool (*proc)(DATATYPE *));
bool walk_llist_rev(HLLIST hllist, bool (*proc)(DATATYPE *));
void clear_llist(HLLIST hllist);
void destroy_llist(HLLIST hllist);
/* inline Function Definitions */
static inline size_t count_llist(HLLIST hllist)
{
return hllist->count;
}
#endif
/* llist.c */
#include <stdio.h>
#include <stdlib.h>
#include "llist.h"
/* static Functions Prototypes */
static bool disp(DATATYPE *node);
/* Function Definitions */
HLLIST create_llist(void)
{
HLLIST hllist;
if ((hllist = (HLLIST)malloc(sizeof(LLIST))) == NULL)
return NULL;
hllist->head.next = &hllist->head;
hllist->head.prev = &hllist->head;
hllist->count = 0;
return hllist;
}
NODE *insert_next(HLLIST hllist, NODE *node, DATATYPE val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = val;
node->next->prev = new_node;
new_node->next = node->next;
node->next = new_node;
new_node->prev = node;
++hllist->count;
return new_node;
}
NODE *insertp_next(HLLIST hllist, NODE *node, const DATATYPE *val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = *val;
node->next->prev = new_node;
new_node->next = node->next;
node->next = new_node;
new_node->prev = node;
++hllist->count;
return new_node;
}
NODE *insert_prev(HLLIST hllist, NODE *node, DATATYPE val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = val;
node->prev->next = new_node;
new_node->next = node;
new_node->prev = node->prev;
node->prev = new_node;
++hllist->count;
return new_node;
}
NODE *insertp_prev(HLLIST hllist, NODE *node, const DATATYPE *val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = *val;
node->prev->next = new_node;
new_node->next = node;
new_node->prev = node->prev;
node->prev = new_node;
++hllist->count;
return new_node;
}
NODE *add_tail(HLLIST hllist, DATATYPE val)
{
return insert_prev(hllist, &hllist->head, val);
}
NODE *addp_tail(HLLIST hllist, const DATATYPE *val)
{
return insertp_prev(hllist, &hllist->head, val);
}
NODE *add_head(HLLIST hllist, DATATYPE val)
{
return insert_next(hllist, &hllist->head, val);
}
NODE *addp_head(HLLIST hllist, const DATATYPE *val)
{
return insertp_next(hllist, &hllist->head, val);
}
void remove_node(HLLIST hllist, NODE *node)
{
node->prev->next = node->next;
node->next->prev = node->prev;
--hllist->count;
free(node);
}
DATATYPE *getp_item(HLLIST hllist, size_t index)
{
NODE *node;
if (index >= hllist->count)
return NULL;
node = hllist->head.next;
for (size_t i = 0; i < index; ++i)
node = node->next;
return &node->val;
}
bool walk_llist(HLLIST hllist, bool (*proc)(DATATYPE *))
{
bool retval = true;
bool def_flag = false;
if (proc == NULL) {
proc = disp;
def_flag = true;
}
for (NODE *node = hllist->head.next; node != &hllist->head; node = node->next)
if (!proc(&node->val)) {
retval = false;
break;
}
if (def_flag)
putchar('\n');
return retval;
}
bool walk_llist_rev(HLLIST hllist, bool (*proc)(DATATYPE *))
{
bool retval = true;
bool def_flag = false;
if (proc == NULL) {
proc = disp;
def_flag = true;
}
for (NODE *node = hllist->head.prev; node != &hllist->head; node = node->prev)
if (!proc(&node->val)) {
retval = false;
break;
}
if (def_flag)
putchar('\n');
return retval;
}
void clear_llist(HLLIST hllist)
{
NODE *node, *temp_node;
node = hllist->head.next;
while (node != &hllist->head) {
temp_node = node->next;
free(node);
node = temp_node;
}
hllist->head.next = &hllist->head;
hllist->head.prev = &hllist->head;
hllist->count = 0;
}
void destroy_llist(HLLIST hllist)
{
NODE *node, *temp_node;
node = hllist->head.next;
while (node != &hllist->head) {
temp_node = node->next;
free(node);
node = temp_node;
}
free(hllist);
}
static bool disp(DATATYPE *val)
{
printf("%d ", *val);
fflush(stdout);
return true;
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include "llist.h"
int main(void)
{
HLLIST hllist;
NODE *node, *pos_node;
DATATYPE *val;
if ((hllist = create_llist()) == NULL) {
fprintf(stderr, "cannot create linked list...\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 10; ++i) {
if ((node = add_tail(hllist, i)) == NULL) {
fprintf(stderr, "cannot add item!..\n");
exit(EXIT_FAILURE);
}
if (i == 0)
pos_node = node;
}
walk_llist(hllist, NULL);
remove_node(hllist, pos_node);
walk_llist(hllist, NULL);
if ((val = getp_item(hllist, 5)) == NULL) {
fprintf(stderr, "invalid index!..\n");
exit(EXIT_FAILURE);
}
printf("%d\n", *val);
clear_llist(hllist);
for (int i = 0; i < 10; ++i)
if (add_tail(hllist, i) == NULL) {
fprintf(stderr, "cannot add item!..\n");
exit(EXIT_FAILURE);
}
walk_llist(hllist, NULL);
destroy_llist(hllist);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Tek bağlı ı ı ı ı ı
listelerde adresini bildiğimiz düğümün yalnı
Ancak adresini bildiğimiz düğümün önündeki düğümü silebiliriz. Bunun için oluşturulacak handle alanı
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *next;
} NODE;
typedef struct tagLLIST {
NODE *head;
NODE *tail;
size_t count;
} LLIST, *HLLIST;
Soyut bir veri türü olarak tek baalı
- Listenin başı
- Listenin dolaşı ı ı
- Adresi bilinen bir düğümün önüne eleman insert edilmesi
- Adresi bilinen bir düğümün önündeki elemanı
Aşağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* llist.h */
#ifndef LLIST_H_
#define LLIST_H_
#include <stddef.h>
#include <stdbool.h>
/* Type Declarations */
typedef int DATATYPE;
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *next;
} NODE;
typedef struct tagLLIST {
NODE *head;
NODE *tail;
size_t count;
} LLIST, *HLLIST;
/* Function Prototypes */
HLLIST create_llist(void);
NODE *add_tail(HLLIST hllist, DATATYPE val);
NODE *addp_tail(HLLIST hllist, const DATATYPE *val);
NODE *add_head(HLLIST hllist, DATATYPE val);
NODE *addp_head(HLLIST hllist, const DATATYPE *val);
NODE *insert_next(HLLIST hllist, NODE *node, DATATYPE val);
NODE *insertp_next(HLLIST hllist, NODE *node, const DATATYPE *val);
void remove_next(HLLIST hllist, NODE *node);
DATATYPE *getp_item(HLLIST hllist, size_t index);
bool walk_llist(HLLIST hllist, bool (*proc)(DATATYPE *));
void clear_llist(HLLIST hllist);
void destroy_llist(HLLIST hllist);
/* inline Function Definitions */
static inline size_t count_llist(HLLIST hllist)
{
return hllist->count;
}
#endif
/* llist.c */
#include <stdio.h>
#include <stdlib.h>
#include "llist.h"
/* static Functions Prototypes */
static bool disp(DATATYPE *val);
/* Function Definitions */
HLLIST create_llist(void)
{
HLLIST hllist;
if ((hllist = (HLLIST)malloc(sizeof(LLIST))) == NULL)
return NULL;
hllist->head = hllist->tail = NULL;
hllist->count = 0;
return hllist;
}
NODE *add_tail(HLLIST hllist, DATATYPE val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = val;
if (hllist->tail != NULL)
hllist->tail->next = new_node;
else
hllist->head = new_node;
hllist->tail = new_node;
new_node->next = NULL;
++hllist->count;
return new_node;
}
NODE *addp_tail(HLLIST hllist, const DATATYPE *val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = *val;
if (hllist->tail != NULL)
hllist->tail->next = new_node;
else
hllist->head = new_node;
hllist->tail = new_node;
new_node->next = NULL;
++hllist->count;
return new_node;
}
NODE *add_head(HLLIST hllist, DATATYPE val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = val;
new_node->next = hllist->head;
if (hllist->head == NULL)
hllist->tail = new_node;
hllist->head = new_node;
++hllist->count;
return new_node;
}
NODE *addp_head(HLLIST hllist, const DATATYPE *val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = *val;
new_node->next = hllist->head;
if (hllist->head == NULL)
hllist->tail = new_node;
hllist->head = new_node;
++hllist->count;
return new_node;
}
NODE *insert_next(HLLIST hllist, NODE *node, DATATYPE val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = val;
if (node == hllist->tail)
hllist->tail = new_node;
new_node->next = node->next;
node->next = new_node;
++hllist->count;
return new_node;
}
NODE *insertp_next(HLLIST hllist, NODE *node, const DATATYPE *val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = *val;
if (node == hllist->tail)
hllist->tail = new_node;
new_node->next = node->next;
node->next = new_node;
++hllist->count;
return new_node;
}
void remove_next(HLLIST hllist, NODE *node)
{
NODE *next_node;
if (node == hllist->tail)
return;
if (node->next == hllist->tail)
hllist->tail = node;
next_node = node->next;
node->next = next_node->next;
--hllist->count;
free(next_node);
}
bool walk_llist(HLLIST hllist, bool (*proc)(DATATYPE *))
{
bool retval = true;
bool def_flag = false;
if (proc == NULL) {
proc = disp;
def_flag = true;
}
for (NODE *node = hllist->head; node != NULL; node = node->next)
if (!proc(&node->val)) {
retval = false;
break;
}
if (def_flag)
putchar('\n');
return retval;
}
DATATYPE *getp_item(HLLIST hllist, size_t index)
{
NODE *node;
if (index >= hllist->count)
return NULL;
node = hllist->head;
for (size_t i = 0; i < index; ++i)
node = node->next;
return &node->val;
}
void clear_llist(HLLIST hllist)
{
NODE *node, *temp_node;
node = hllist->head;
while (node != NULL) {
temp_node = node->next;
free(node);
node = temp_node;
}
hllist->head = hllist->tail = NULL;
hllist->count = 0;
}
void destroy_llist(HLLIST hllist)
{
NODE *node, *temp_node;
node = hllist->head;
while (node != NULL) {
temp_node = node->next;
free(node);
node = temp_node;
}
free(hllist);
}
static bool disp(DATATYPE *val)
{
printf("%d ", *val);
fflush(stdout);
return true;
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include "llist.h"
int main(void)
{
HLLIST hllist;
NODE *node, *pos_node;
int *val;
if ((hllist = create_llist()) == NULL) {
fprintf(stderr, "cannot create linked list...\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 10; ++i) {
if ((node = add_tail(hllist, i)) == NULL) {
fprintf(stderr, "cannot add item!..\n");
exit(EXIT_FAILURE);
}
if (i == 8)
pos_node = node;
}
walk_llist(hllist, NULL);
if ((val = getp_item(hllist, 5)) == NULL) {
fprintf(stderr, "invalid index!..\n");
exit(EXIT_FAILURE);
}
printf("%d\n", *val);
remove_next(hllist, pos_node);
walk_llist(hllist, NULL);
clear_llist(hllist);
for (int i = 0; i < 10; ++i)
if ((node = add_tail(hllist, i)) == NULL) {
fprintf(stderr, "cannot add item!..\n");
exit(EXIT_FAILURE);
}
walk_llist(hllist, NULL);
destroy_llist(hllist);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Tek bağlı ı ı
bağlı ı ı ı
ayrı ı ı ı ı
göstermesi gerekir. Tabii işin başı ı ı
kendisini göstermlidir. Bu tasarı ı ı
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *next;
} NODE;
typedef struct tagLLIST {
NODE head;
NODE *tail;
size_t count;
} LLIST, *HLLIST;
Yapı ı ı ı ı ı
Aşağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* llist.h */
#ifndef LLIST_H_
#define LLIST_H_
#include <stddef.h>
#include <stdbool.h>
/* Type Declarations */
typedef int DATATYPE;
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *next;
} NODE;
typedef struct tagLLIST {
NODE head;
NODE *tail;
size_t count;
} LLIST, *HLLIST;
/* Function Prototypes */
HLLIST create_llist(void);
NODE *insert_next(HLLIST hllist, NODE *node, DATATYPE val);
NODE *insertp_next(HLLIST hllist, NODE *node, const DATATYPE *val);
NODE *add_tail(HLLIST hllist, DATATYPE val);
NODE *addp_tail(HLLIST hllist, const DATATYPE *val);
NODE *add_head(HLLIST hllist, DATATYPE val);
NODE *addp_head(HLLIST hllist, const DATATYPE *val);
void remove_next(HLLIST hllist, NODE *node);
void remove_head(HLLIST hllist);
DATATYPE *getp_item(HLLIST hllist, size_t index);
bool walk_llist(HLLIST hllist, bool (*proc)(DATATYPE *));
void clear_llist(HLLIST hllist);
void destroy_llist(HLLIST hllist);
/* inline Function Definitions */
static inline size_t count_llist(HLLIST hllist)
{
return hllist->count;
}
#endif
/* llist.c */
#include <stdio.h>
#include <stdlib.h>
#include "llist.h"
/* static Functions Prototypes */
static bool disp(DATATYPE *val);
/* Function Definitions */
HLLIST create_llist(void)
{
HLLIST hllist;
if ((hllist = (HLLIST)malloc(sizeof(LLIST))) == NULL)
return NULL;
hllist->head.next = &hllist->head;
hllist->tail = &hllist->head;
hllist->count = 0;
return hllist;
}
NODE *insert_next(HLLIST hllist, NODE *node, DATATYPE val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = val;
if (node == hllist->tail)
hllist->tail = new_node;
new_node->next = node->next;
node->next = new_node;
++hllist->count;
return new_node;
}
NODE *insertp_next(HLLIST hllist, NODE *node, const DATATYPE *val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = *val;
if (node == hllist->tail)
hllist->tail = new_node;
new_node->next = node->next;
node->next = new_node;
++hllist->count;
return new_node;
}
NODE *add_tail(HLLIST hllist, DATATYPE val)
{
return insert_next(hllist, hllist->tail, val);
}
NODE *addp_tail(HLLIST hllist, const DATATYPE *val)
{
return insertp_next(hllist, hllist->tail, val);
}
NODE *add_head(HLLIST hllist, DATATYPE val)
{
return insert_next(hllist, &hllist->head, val);
}
NODE *addp_head(HLLIST hllist, const DATATYPE *val)
{
return insertp_next(hllist, &hllist->head, val);
}
void remove_next(HLLIST hllist, NODE *node)
{
NODE *next_node;
if (node == hllist->tail)
return;
if (node->next == hllist->tail)
hllist->tail = node;
next_node = node->next;
node->next = next_node->next;
--hllist->count;
free(next_node);
}
void remove_head(HLLIST hllist)
{
remove_next(hllist, &hllist->head);
}
DATATYPE *getp_item(HLLIST hllist, size_t index)
{
NODE *node;
if (index >= hllist->count)
return NULL;
node = hllist->head.next;
for (size_t i = 0; i < index; ++i)
node = node->next;
return &node->val;
}
bool walk_llist(HLLIST hllist, bool (*proc)(DATATYPE *))
{
bool retval = true;
bool def_flag = false;
if (proc == NULL) {
proc = disp;
def_flag = true;
}
for (NODE *node = hllist->head.next; node != &hllist->head; node = node->next)
if (!proc(&node->val)) {
retval = false;
break;
}
if (def_flag)
putchar('\n');
return retval;
}
void clear_llist(HLLIST hllist)
{
NODE *node, *temp_node;
node = hllist->head.next;
while (node != &hllist->head) {
temp_node = node->next;
free(node);
node = temp_node;
}
hllist->head.next = &hllist->head;
hllist->tail = &hllist->head;
hllist->count = 0;
}
void destroy_llist(HLLIST hllist)
{
NODE *node, *temp_node;
node = hllist->head.next;
while (node != &hllist->head) {
temp_node = node->next;
free(node);
node = temp_node;
}
free(hllist);
}
static bool disp(DATATYPE *val)
{
printf("%d ", *val);
fflush(stdout);
return true;
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include "llist.h"
int main(void)
{
HLLIST hllist;
NODE *node, *pos_node;
int *val;
if ((hllist = create_llist()) == NULL) {
fprintf(stderr, "cannot create linked list...\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 10; ++i) {
if ((node = add_tail(hllist, i)) == NULL) {
fprintf(stderr, "cannot add item!..\n");
exit(EXIT_FAILURE);
}
if (i == 5)
pos_node = node;
}
walk_llist(hllist, NULL);
if ((val = getp_item(hllist, 5)) == NULL) {
fprintf(stderr, "invalid index!..\n");
exit(EXIT_FAILURE);
}
printf("%d\n", *val);
remove_next(hllist, pos_node);
walk_llist(hllist, NULL);
remove_head(hllist);
walk_llist(hllist, NULL);
clear_llist(hllist);
for (int i = 0; i < 10; ++i)
if ((node = add_tail(hllist, i)) == NULL) {
fprintf(stderr, "cannot add item!..\n");
exit(EXIT_FAILURE);
}
walk_llist(hllist, NULL);
destroy_llist(hllist);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Tabii bağlı ı
fonksiyonları ı ı ı ı ı ı
oluşturulmuştur.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* llist.h */
#ifndef LLIST_H_
#define LLIST_H_
#include <stddef.h>
#include <stdbool.h>
/* Type Declarations */
typedef struct tagPERSON {
char name[32];
int no;
} PERSON;
typedef PERSON DATATYPE;
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *next;
} NODE;
typedef struct tagLLIST {
NODE head;
NODE *tail;
size_t count;
} LLIST, *HLLIST;
/* Function Prototypes */
HLLIST create_llist(void);
NODE *insert_next(HLLIST hllist, NODE *node, DATATYPE val);
NODE *insertp_next(HLLIST hllist, NODE *node, const DATATYPE *val);
NODE *add_tail(HLLIST hllist, DATATYPE val);
NODE *addp_tail(HLLIST hllist, const DATATYPE *val);
NODE *add_head(HLLIST hllist, DATATYPE val);
NODE *addp_head(HLLIST hllist, const DATATYPE *val);
void remove_next(HLLIST hllist, NODE *node);
void remove_head(HLLIST hllist);
DATATYPE *getp_item(HLLIST hllist, size_t index);
bool walk_llist(HLLIST hllist, bool (*proc)(DATATYPE *));
void clear_llist(HLLIST hllist);
void destroy_llist(HLLIST hllist);
/* inline Function Definitions */
static inline size_t count_llist(HLLIST hllist)
{
return hllist->count;
}
#endif
/* llist.c */
#include <stdio.h>
#include <stdlib.h>
#include "llist.h"
/* static Functions Prototypes */
static bool disp(DATATYPE *node);
/* Function Definitions */
HLLIST create_llist(void)
{
HLLIST hllist;
if ((hllist = (HLLIST)malloc(sizeof(LLIST))) == NULL)
return NULL;
hllist->head.next = &hllist->head;
hllist->tail = &hllist->head;
hllist->count = 0;
return hllist;
}
NODE *insert_next(HLLIST hllist, NODE *node, DATATYPE val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = val;
if (node == hllist->tail)
hllist->tail = new_node;
new_node->next = node->next;
node->next = new_node;
++hllist->count;
return new_node;
}
NODE *insertp_next(HLLIST hllist, NODE *node, const DATATYPE *val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = *val;
if (node == hllist->tail)
hllist->tail = new_node;
new_node->next = node->next;
node->next = new_node;
++hllist->count;
return new_node;
}
NODE *add_tail(HLLIST hllist, DATATYPE val)
{
return insert_next(hllist, hllist->tail, val);
}
NODE *addp_tail(HLLIST hllist, const DATATYPE *val)
{
return insertp_next(hllist, hllist->tail, val);
}
NODE *add_head(HLLIST hllist, DATATYPE val)
{
return insert_next(hllist, &hllist->head, val);
}
NODE *addp_head(HLLIST hllist, const DATATYPE *val)
{
return insertp_next(hllist, &hllist->head, val);
}
void remove_next(HLLIST hllist, NODE *node)
{
NODE *next_node;
if (node == hllist->tail)
return;
if (node->next == hllist->tail)
hllist->tail = node;
next_node = node->next;
node->next = next_node->next;
--hllist->count;
free(next_node);
}
void remove_head(HLLIST hllist)
{
remove_next(hllist, &hllist->head);
}
DATATYPE *getp_item(HLLIST hllist, size_t index)
{
NODE *node;
if (index >= hllist->count)
return NULL;
node = hllist->head.next;
for (size_t i = 0; i < index; ++i)
node = node->next;
return &node->val;
}
bool walk_llist(HLLIST hllist, bool (*proc)(DATATYPE *))
{
bool retval = true;
bool def_flag = false;
if (proc == NULL) {
proc = disp;
def_flag = true;
}
for (NODE *node = hllist->head.next; node != &hllist->head; node = node->next)
if (!proc(&node->val)) {
retval = false;
break;
}
if (def_flag)
putchar('\n');
return retval;
}
void clear_llist(HLLIST hllist)
{
NODE *node, *temp_node;
node = hllist->head.next;
while (node != &hllist->head) {
temp_node = node->next;
free(node);
node = temp_node;
}
hllist->head.next = &hllist->head;
hllist->tail = &hllist->head;
hllist->count = 0;
}
void destroy_llist(HLLIST hllist)
{
NODE *node, *temp_node;
node = hllist->head.next;
while (node != &hllist->head) {
temp_node = node->next;
free(node);
node = temp_node;
}
free(hllist);
}
static bool disp(DATATYPE *val)
{
printf("%s, %d\n", val->name, val->no);
fflush(stdout);
return true;
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include "llist.h"
bool disp_person(PERSON *per);
void clear_stdin(void);
int main(void)
{
HLLIST hllist;
PERSON per;
char *str;
if ((hllist = create_llist()) == NULL) {
fprintf(stderr, "cannot create linked list...\n");
exit(EXIT_FAILURE);
}
for (;;) {
printf("Adi soyadi:");
if (fgets(per.name, 32, stdin) == NULL)
continue;
if ((str = strchr(per.name, '\n')) != NULL)
*str = '\0';
if (!strcmp(per.name, "quit"))
break;
printf("No:");
scanf("%d", &per.no);
clear_stdin();
addp_tail(hllist, &per);
}
walk_llist(hllist, disp_person);
destroy_llist(hllist);
return 0;
}
bool disp_person(PERSON *per)
{
printf("%s, %d\n", per->name, per->no);
return true;
}
void clear_stdin(void)
{
int ch;
while ((ch = getchar()) != '\n' && ch != EOF)
;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Çok karşı ı ı ı ı ı ı ı ı
kuyruk denildiğinde default olarak FIFO kuyruklar anlaşı ı
Kuyruk veri yapı ı ı ı
anlamı ı ı ı ı ı
FIFO kuyruk sistemine eleman yerleştirileceği zaman eleman her zaman sona yerleştirilmektedir. Bu kuyruk sisteminden eleman alı ı
zaman eleman baştan alı ı
FIFO kuyruk sistemleri gerçek hayatta çokça karşı ı ı ı ı
Yemekhanede kuyruğun sonuna gireriz. Kuyruğun başı
FIFO kuyruk sistemleri "bilgilerin sı ı ı ı
genellikle FIFO kuyruk sistemi biçiminde oluşturulmaktadı ı
O zaman gelen bilgiyi geçici süre bir FIFO kuyruk sisteminde tutabiliriz. Daha sonra oradan alarak geldiği sı ı
daha önce görmüş olduğumuz borularda bir FIFO kuyruk sistemi ile gerçekleştirilmektedir. Örneğin boruya br şey yazı ı ı
borunun sonuna yazı ı ı ı ı
Kuyruk sistemine eleman yerleştirmeye İngilizce genellikle "put" ya da "enqueue" işlemi denilmektedir. Kuyruktan eleman alamaya da İngilizce
genellikle "get" ya da "dequeue" işlemi denilmektedir.
Kuyruk sistemlerinin bir uzunlukları ı ı ı ı ı
artı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
62. Ders 03/02/2024 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
FIFO kuyruk sistemlerinin gerçekleştirilmesi için üç yöntem kullanı ı
1) Dizi Kaydı ı
Bu yöntemde kuyruk için bir dizi yaratı ı ı
ile tutulur. Çrneğin:
abcdexxxxxxxxxxxxx
^
Burada a, b, c, d, e kuruktaki elemanları ı ı
ekleneceği zaman sona ekleme yapı ı
abcdefxxxxxxxxxxxx
^
Kuyruktan eleman alı ı ı ı ı ı ı ı
bcdefxxxxxxxxxxxx
^
Bu tasarı ı ı ı ı ı
2) İndeks Kaydı ı ı ı
tutturulur. Kuruğun bgaşı ı
göstericiye de "tail" göstericisi denilmektedir. Örneğin:
xxxxabcdefgxxxxxx
^(h) ^(t)
Eleman tail göstericisinin gösterdeiği yere yerleştirilir ve tail göstericisi 1 artı ı ı
gelmişse yeniden başa geçirilir. Örneğin:
xxxxabcdefghxxxxxxx
^(h) ^(t)
Eleman head göstericisinin gösteridği yerden alı ı ı ı ı
yeniden başa geçirilir. Bu yöntemde head ve tail göstericileri aynı
Genellikle kuyruktaki eleman sayı ı ı ı
verilir. Bu yöntemde eleman ekleme de eleman alma da O(1) karmaşı ı ı
İndeks kaydı ı ı
uygulamadan uygulamaya değişebilmektedir.
3) Bağlı ı ı ı ı ı ı
tek bağlı ı ı ı ı
eğer elemanlar dinamik olarak tahsis edilip free edeilecekse genellikle bu işlemler O(N) karmaşı ı ı ı ı ı
çalı ı ı ı ı ı
gerçekleştirilmiştir. Bu yöntemin avantajı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağda indeks kaydı ı
typedef struct tagQUEUE {
DATATYPE *queue;
size_t head;
size_t tail;
size_t size;
size_t count;
} QUEUE, *HQUEUE;
Handle alanı ı
sayı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* queue.h */
#ifndef QUEUE_H_
#define QUEUE_H_
#include <stddef.h>
#include <stdbool.h>
typedef int DATATYPE;
typedef struct tagQUEUE {
DATATYPE *queue;
size_t head;
size_t tail;
size_t size;
size_t count;
} QUEUE, *HQUEUE;
/* Function Prototypes */
HQUEUE create_queue(size_t size);
bool put_queue(HQUEUE hqueue, DATATYPE val);
bool putp_queue(HQUEUE hqueue, const DATATYPE *val);
bool get_queue(HQUEUE hqueue, DATATYPE *val);
bool resize_queue(HQUEUE hqueue, size_t newsize);
void clear_queue(HQUEUE hqueue);
void destroy_queue(HQUEUE hqueue);
/* inline Function Definitions */
static inline bool isempty_queue(HQUEUE hqueue)
{
return hqueue->count == 0;
}
static inline bool count_queue(HQUEUE hqueue)
{
return hqueue->count;
}
#endif
/* queue.c */
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"
HQUEUE create_queue(size_t size)
{
HQUEUE hqueue;
if ((hqueue = (HQUEUE)malloc(sizeof(QUEUE))) == NULL)
return NULL;
if ((hqueue->queue = (DATATYPE *)malloc(sizeof(DATATYPE) * size)) == NULL) {
free(hqueue);
return NULL;
}
hqueue->head = hqueue->tail = 0;
hqueue->size = size;
hqueue->count = 0;
return hqueue;
}
bool put_queue(HQUEUE hqueue, DATATYPE val)
{
if (hqueue->count == hqueue->size)
return false;
hqueue->queue[hqueue->tail++] = val;
hqueue->tail %= hqueue->size;
++hqueue->count;
return true;
}
bool putp_queue(HQUEUE hqueue, const DATATYPE *val)
{
if (hqueue->count == hqueue->size)
return false;
hqueue->queue[hqueue->tail++] = *val;
hqueue->tail %= hqueue->size;
++hqueue->count;
return true;
}
bool get_queue(HQUEUE hqueue, DATATYPE *val)
{
if (hqueue->count == 0)
return false;
*val = hqueue->queue[hqueue->head++];
hqueue->head %= hqueue->size;
--hqueue->count;
return true;
}
bool resize_queue(HQUEUE hqueue, size_t newsize)
{
DATATYPE *new_queue;
if (newsize <= hqueue->size)
return false;
if ((new_queue = (DATATYPE *)malloc(newsize * sizeof(DATATYPE))) == NULL)
return false;
for (size_t i = 0, head = hqueue->head; i < hqueue->size; ++i) {
new_queue[i] = hqueue->queue[head++];
head %= hqueue->size;
}
hqueue->head = 0;
hqueue->tail = hqueue->count;
hqueue->size = newsize;
free(hqueue->queue);
hqueue->queue = new_queue;
return true;
}
void clear_queue(HQUEUE hqueue)
{
hqueue->count = 0;
hqueue->head = 0;
hqueue->tail = 0;
}
void destroy_queue(HQUEUE hqueue)
{
free(hqueue->queue);
free(hqueue);
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"
int main(void)
{
HQUEUE hqueue;
DATATYPE val;
if ((hqueue = create_queue(10)) == NULL) {
fprintf(stderr, "cannot create queue!..\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 8; ++i)
if (!put_queue(hqueue, i)) {
fprintf(stderr, "cannot put queue!..\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 5; ++i)
get_queue(hqueue, &val);
if (!resize_queue(hqueue, 20)) {
fprintf(stderr, "cannot resize queue!..\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 15; ++i)
if (!put_queue(hqueue, i)) {
fprintf(stderr, "cannot put queue!..\n");
exit(EXIT_FAILURE);
}
while (!isempty_queue(hqueue)) {
get_queue(hqueue, &val);
printf("%d ", val);
fflush(stdout);
}
destroy_queue(hqueue);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *next;
} NODE;
typedef struct tagQUEUE {
NODE *head;
NODE *tail;
size_t count;
} QUEUE, *HQUEUE;
Handle alanı ı ı ı
yerleştirirken bağlı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* queue.h */
#ifndef QUEUE_H_
#define QUEUE_H_
#include <stddef.h>
#include <stdbool.h>
typedef int DATATYPE;
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *next;
} NODE;
typedef struct tagQUEUE {
NODE *head;
NODE *tail;
size_t count;
} QUEUE, *HQUEUE;
/* Function Prototypes */
HQUEUE create_queue(voids);
bool put_queue(HQUEUE hqueue, DATATYPE val);
bool putp_queue(HQUEUE hqueue, const DATATYPE *val);
bool get_queue(HQUEUE hqueue, DATATYPE *val);
void clear_queue(HQUEUE hqueue);
void destroy_queue(HQUEUE hqueue);
/* inline Function Definitions */
static inline bool isempty_queue(HQUEUE hqueue)
{
return hqueue->count == 0;
}
static inline bool count_queue(HQUEUE hqueue)
{
return hqueue->count;
}
#endif
/* queue.c */
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"
HQUEUE create_queue(void)
{
HQUEUE hqueue;
if ((hqueue = (HQUEUE)malloc(sizeof(QUEUE))) == NULL)
return NULL;
hqueue->head = hqueue->tail = NULL;
hqueue->count = 0;
return hqueue;
}
bool put_queue(HQUEUE hqueue, DATATYPE val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return false;
new_node->val = val;
new_node->next = NULL;
if (hqueue->tail != NULL)
hqueue->tail->next = new_node;
else
hqueue->head = new_node;
hqueue->tail = new_node;
++hqueue->count;
return true;
}
bool putp_queue(HQUEUE hqueue, const DATATYPE *val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return false;
new_node->val = *val;
new_node->next = NULL;
if (hqueue->tail != NULL)
hqueue->tail->next = new_node;
else
hqueue->head = new_node;
hqueue->tail = new_node;
++hqueue->count;
return true;
}
bool get_queue(HQUEUE hqueue, DATATYPE *val)
{
NODE *node;
if (hqueue->head == NULL)
return false;
node = hqueue->head;
*val = node->val;
if (node->next == NULL)
hqueue->tail = NULL;
hqueue->head = node->next;
--hqueue->count;
free(node);
return true;
}
void clear_queue(HQUEUE hqueue)
{
NODE *node, *temp_node;
node = hqueue->head;
while (node != NULL) {
temp_node = node->next;
free(node);
node = temp_node;
}
hqueue->head = hqueue->tail = NULL;
hqueue->count = 0;
}
void destroy_queue(HQUEUE hqueue)
{
NODE *node, *temp_node;
node = hqueue->head;
while (node != NULL) {
temp_node = node->next;
free(node);
node = temp_node;
}
free(hqueue);
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"
int main(void)
{
HQUEUE hqueue;
DATATYPE val;
if ((hqueue = create_queue(10)) == NULL) {
fprintf(stderr, "cannot create queue!..\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 8; ++i)
if (!put_queue(hqueue, i)) {
fprintf(stderr, "cannot put queue!..\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 15; ++i)
if (!put_queue(hqueue, i)) {
fprintf(stderr, "cannot put queue!..\n");
exit(EXIT_FAILURE);
}
while (!isempty_queue(hqueue)) {
get_queue(hqueue, &val);
printf("%d ", val);
fflush(stdout);
}
destroy_queue(hqueue);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
LIFO (Last In First Out) kuyruk sistemlerine "Stack Veri Yapı ı ı ı ı
eleman eklemek ve stack'ten eleman almak. Geleneksel olarak stack'e eleman yerleştirmeye "push" işlemi, stack'ten eleman almaya da "pop"
işlemi denilmektedir. LIFO kuyruk sistemleri FIFO kuyruk sistemlerine göre daha seyrek kullanı ı ı
sistemleriyle karşı ı ı
- Tabaklar üst üste konulduğunda en üsttek ilk alı ı
- Asansöre son binen çoğu kez ilk inmektedir.
- Bazı ı ı ı ı ı ı ı ı ı
Bilgisayar dünyası ı ı ı ı ı ı
Yani örneğin biz bir editörde birtakı ı ı ı ı
alı ı ı ı ı
fonksiyon peşi sı ı ı ı ı ı ı ı ı
yapı ı ı ı ı ı ı
ters yüz etmek için kullanı
Stack veri yapı ı ı
bir dizi yaratı ı ı ı ı
geleneksel olarak "stack göstericisi (stack pointer)" denilmektedir. Başlangı
Örneğin:
x
x
x
x
x
SP -->
Push işleminde stack göstericisi önce bir azaltı ı
a değerini yukarı
x
x
x
x
x
SP ---> a
Şimdi de b değerine stack'e push edelim:
x
x
x
x
SP ---> b
a
Şmdi de c değerini push edelim:
x
x
x
SP ---> c
b
a
Pop işleminde tam tersi yapı ı ı ı ı
durumda pop işlemi yapalı
x
x
x
c
SP ---> b
a
Şimdi bir daha pop yapalı
x
x
x
c
b
SP ---> a
Eğer stack uzunluğundan daha fazla psuh işlemi yapı ı ı ı ı ı ı
taşı ı ı ı
(yani boş bir stack'ta pop işlemi yaparsak) bu durumda stack için ayrı ı ı ı
"stack underflow" denilmektedir.
Stack sistemleri tek bağlı ı ı ı
bu stack olur.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı
isimli bir yapı
typedef struct tagSTACK {
DATATYPE *stack;
DATATYPE *sp;
size_t size;
size_t count;
} STACK, *HSTACK;
Yapı ı ı
sayı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* stack.h */
#ifndef STACK_H_
#define STACK_H_
#include <stddef.h>
#include <stdbool.h>
typedef int DATATYPE;
typedef struct tagSTACK {
DATATYPE *stack;
DATATYPE *sp;
size_t size;
size_t count;
} STACK, *HSTACK;
/* Function Prototypes */
HSTACK create_stack(size_t size);
bool push_stack(HSTACK hstack, DATATYPE val);
bool pushp_stack(HSTACK hstack, const DATATYPE *val);
bool pop_stack(HSTACK hstack, DATATYPE *val);
void clear_stack(HSTACK hstack);
void destroy_stack(HSTACK hstack);
/* inline Function Definitions */
static inline size_t count_stack(HSTACK hstack)
{
return hstack->count;
}
static inline bool isempty_stack(HSTACK hstack)
{
return hstack->count == 0;
}
#endif
/* stack.c */
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"
HSTACK create_stack(size_t size)
{
HSTACK hstack;
if ((hstack = (HSTACK)malloc(sizeof(STACK))) == NULL)
return NULL;
if ((hstack->stack = (DATATYPE *)malloc(sizeof(DATATYPE) * size)) == NULL) {
free(hstack);
return NULL;
}
hstack->sp = hstack->stack + size;
hstack->size = size;
hstack->count = 0;
return hstack;
}
bool push_stack(HSTACK hstack, DATATYPE val)
{
if (hstack->count >= hstack->size)
return false;
*--hstack->sp = val;
++hstack->count;
return true;
}
bool pushp_stack(HSTACK hstack,const DATATYPE *val)
{
if (hstack->count >= hstack->size)
return false;
*--hstack->sp = *val;
++hstack->count;
return true;
}
bool pop_stack(HSTACK hstack, DATATYPE *val)
{
if (hstack->count == 0)
return false;
*val = *hstack->sp++;
--hstack->count;
return true;
}
void clear_stack(HSTACK hstack)
{
hstack->sp = hstack->stack + hstack->size;
hstack->count = 0;
}
void destroy_stack(HSTACK hstack)
{
free(hstack->stack);
free(hstack);
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"
int main(void)
{
HSTACK hstack;
DATATYPE val;
if ((hstack = create_stack(10)) == NULL) {
fprintf(stderr, "cannot create stack!..\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 10; ++i)
if (!push_stack(hstack, i)) {
fprintf(stderr, "cannot push stack!..\n");
exit(EXIT_FAILURE);
}
while (!isempty_stack(hstack)) {
pop_stack(hstack, &val);
printf("%d ", val);
fflush(stdout);
}
printf("\n");
destroy_stack(hstack);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı ı
eden STACK yapı ı ı
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *next;
} NODE;
typedef struct tagSTACK {
NODE *head;
size_t count;
} STACK, *HSTACK;
Bu gerçekleştirimde düğüm bağlı ı ı ı ı ı ı
dikkat ediniz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* stack.h */
#ifndef STACK_H_
#define STACK_H_
#include <stddef.h>
#include <stdbool.h>
typedef int DATATYPE;
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *next;
} NODE;
typedef struct tagSTACK {
NODE *head;
size_t count;
} STACK, *HSTACK;
/* Function Prototypes */
HSTACK create_stack(void);
bool push_stack(HSTACK hstack, DATATYPE val);
bool pushp_stack(HSTACK hstack, const DATATYPE *val);
bool pop_stack(HSTACK hstack, DATATYPE *val);
void clear_stack(HSTACK hstack);
void destroy_stack(HSTACK hstack);
/* inline Function Definitions */
static inline size_t count_stack(HSTACK hstack)
{
return hstack->count;
}
static inline bool isempty_stack(HSTACK hstack)
{
return hstack->count == 0;
}
#endif
/* stack.c */
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"
HSTACK create_stack(void)
{
HSTACK hstack;
if ((hstack = (HSTACK)malloc(sizeof(STACK))) == NULL)
return NULL;
hstack->head = NULL;
hstack->count = 0;
return hstack;
}
bool push_stack(HSTACK hstack, DATATYPE val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return false;
new_node->val = val;
new_node->next = hstack->head;
hstack->head = new_node;
++hstack->count;
return true;
}
bool pushp_stack(HSTACK hstack,const DATATYPE *val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return false;
new_node->val = *val;
new_node->next = hstack->head;
hstack->head = new_node;
++hstack->count;
return true;
}
bool pop_stack(HSTACK hstack, DATATYPE *val)
{
NODE *node;
if (hstack->head == NULL)
return false;
node = hstack->head;
hstack->head = node->next;
*val = node->val;
free(node);
--hstack->count;
return true;
}
void clear_stack(HSTACK hstack)
{
NODE *node, *temp_node;
node = hstack->head;
while (node != NULL) {
temp_node = node->next;
free(node);
node = temp_node;
}
hstack->head = NULL;
hstack->count = 0;
}
void destroy_stack(HSTACK hstack)
{
NODE *node, *temp_node;
node = hstack->head;
while (node != NULL) {
temp_node = node->next;
free(node);
node = temp_node;
}
free(hstack);
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"
int main(void)
{
HSTACK hstack;
DATATYPE val;
if ((hstack = create_stack()) == NULL) {
fprintf(stderr, "cannot create stack!..\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 10; ++i)
if (!push_stack(hstack, i)) {
fprintf(stderr, "cannot push stack!..\n");
exit(EXIT_FAILURE);
}
while (!isempty_stack(hstack)) {
pop_stack(hstack, &val);
printf("%d ", val);
fflush(stdout);
}
printf("\n");
for (int i = 0; i < 10; ++i)
if (!push_stack(hstack, i)) {
fprintf(stderr, "cannot push stack!..\n");
exit(EXIT_FAILURE);
}
while (!isempty_stack(hstack)) {
pop_stack(hstack, &val);
printf("%d ", val);
fflush(stdout);
}
printf("\n");
destroy_stack(hstack);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
64. Ders 10/02/2024 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Diğer önemli bir veri yapı ı ı ı ı
normal dinamik dizilere benzemekle birlikte bunları ı ı ı ı
(Halbuki normal dinamik dizilerde başa eleman eklenmesi ve baştaki elemanı ı ı ı ı
O(N) karmaşlı ı ı
Çift yönlü dizmaik dizilere kı ı ı ı ı ı
kı ı ı ı ı ı ı ı
Bu veri yaı ı ı ı ı
Çift yönlü dinamik dizilerde elemana erişim yine sabit karmaşı ı ı ı
O(N) karmaşı ı ı ı ı ı ı ı ı ı ı
Çift yönlü dinamik diziler pek çok kütüphanede (örneğin C++'ı ı ı ı
temel bir veri yapı ı ı ı
edip başı ı ı ı ı
başı
Çift yönlü dinamik diziler tipik olarak üç biçimde gerçekleştirilmektedir. Bu gerçekleştirimlerin etkinliği birbirine yakı ı
dikkat alı
İndeks Kaydı ı
ile tutulur. Sona ekleme tail göstericisinin gösteriği yere, başa ekleme head göstericisinin gösterdiği yere yapı ı
sistemlerindeki gerçekleştirim ile benzerdir. Kuyruk dolduğunda yine normal dinamik dizilerde olduğu gibi iki kat artı ı
Başa ve sona eleman ekleme, baştaki ve sondaki elemanı ı ı ı ı
erişilebilir.
Dinamik Dizi Yoluyla Gerçekleştirim: Bu gerçekleştirimde bir dinamik dizi oluşturulur. Başlangı
dizinin ortası
yere yapı ı
silinmesinde ise tail sola doğru ilerleyecektir. head ve tail göstericileri iki uçtan herhangi birine eriştiğinde dizi büyütülecektir.
Bu gerçekleştirimde kullanı ı ı ı ı ı ı
Yani sona ekleme ve baştan silme işlemleri yoğun olabilir. Bu durumda head ve tail göstericileri dizinin sonları ı
Ancak yeniden tahsisat yapı ı ı ı ı
Birden Fazla Dizinin Kullanı ı ı ı
her biri 64 byte uzunluğunda dizilerin kullanı ı ı ı ı ı
Tabii bu dizilerin adreslerinin de bir yerde saklanması
saklanmaktadı ı ı ı ı
önemli bir zamana yol açmayabilir. Bu gerçekleştirimde yine elemana erişim O(1) karmaşı ı
baştan ve sondan eleman silme yine O(1) karmaşı ı ı ı ı
kaydı ı ı ı
karmaşı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
65. Ders 11/02/2024 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
bilgilerini tutan handle alanı
typedef int DATATYPE;
typedef struct tagDEQUE {
DATATYPE *deque;
size_t capacity;
size_t count;
size_t head;
size_t tail;
} DEQUE, *HDEQUE;
Bu gerçekleştirimde deque için başlangı ı ı ı ı
yeni bir aalan tahsis edilmiş ve eski alandan yeni alana kopyalama yapı ı ı ı ı
ve sondan eleman silmek O(1) karmaşı ı ı ı ı ı
aşağı ı ı
Aslı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* deque.h */
#ifndef DEQUE_H_
#define DEQUE_H_
#include <stddef.h>
#include <stdbool.h>
/* Symbolic Constants */
#define DEQUE_DEF_CAPACITY 8
#define DEQUE_FAILED ((size_t)-1)
#define MIN(a, b) ((a) < (b) ? (a) : (b))
/* Type Declerations */
typedef int DATATYPE;
typedef struct tagDEQUE {
DATATYPE *deque;
size_t capacity;
size_t count;
size_t head;
size_t tail;
} DEQUE, *HDEQUE;
/* Function Prototypes */
HDEQUE create_deque(void);
size_t add_back_deque(HDEQUE hdeque, DATATYPE val);
size_t add_backp_deque(HDEQUE hdeque, const DATATYPE *val);
size_t add_front_deque(HDEQUE hdeque, DATATYPE val);
size_t add_frontp_deque(HDEQUE hdeque, const DATATYPE *val);
DATATYPE at_deque(HDEQUE hdeque, size_t index);
void atp_deque(HDEQUE hdeque, size_t index, DATATYPE *val);
DATATYPE pop_front_deque(HDEQUE hdeque);
void pop_frontp_deque(HDEQUE hdeque, DATATYPE *val);
size_t insert_deque(HDEQUE hdeque, size_t index, DATATYPE val);
size_t remove_deque(HDEQUE hdeque, size_t index);
DATATYPE *set_capacity_deque(HDEQUE hdeque, size_t new_capacity);
void clear_deque(HDEQUE hdeque);
void destroy_deque(HDEQUE hdeque);
/* inline Function Definitions */
static inline size_t count_deque(HDEQUE hdeque)
{
return hdeque->count;
}
static inline size_t capacity_deque(HDEQUE hdeque)
{
return hdeque->capacity;
}
#endif
/* deque.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "deque.h"
HDEQUE create_deque(void)
{
HDEQUE hdeque;
if ((hdeque = (HDEQUE)malloc(sizeof(DEQUE))) == NULL)
return NULL;
if ((hdeque->deque = (DATATYPE *)malloc(DEQUE_DEF_CAPACITY * sizeof(DATATYPE))) == NULL) {
free(hdeque);
return NULL;
}
hdeque->count = 0;
hdeque->capacity = DEQUE_DEF_CAPACITY;
hdeque->head = hdeque->tail = 0;
return hdeque;
}
size_t add_back_deque(HDEQUE hdeque, DATATYPE val)
{
if (hdeque->count == hdeque->capacity && set_capacity_deque(hdeque, hdeque->capacity * 2) == NULL)
return DEQUE_FAILED;
hdeque->deque[hdeque->tail++] = val;
hdeque->tail %= hdeque->capacity;
++hdeque->count;
return hdeque->count - 1;
}
size_t add_backp_deque(HDEQUE hdeque, const DATATYPE *val)
{
if (hdeque->count == hdeque->capacity && set_capacity_deque(hdeque, hdeque->capacity * 2) == NULL)
return DEQUE_FAILED;
hdeque->deque[hdeque->tail++] = *val;
hdeque->tail %= hdeque->capacity;
++hdeque->count;
return hdeque->count - 1;
}
size_t add_front_deque(HDEQUE hdeque, DATATYPE val)
{
if (hdeque->count == hdeque->capacity && set_capacity_deque(hdeque, hdeque->capacity * 2) == NULL)
return DEQUE_FAILED;
if (hdeque->head == 0)
hdeque->head = hdeque->capacity - 1;
else
--hdeque->head;
hdeque->deque[hdeque->head] = val;
++hdeque->count;
return 0;
}
size_t add_frontp_deque(HDEQUE hdeque, const DATATYPE *val)
{
if (hdeque->count == hdeque->capacity && set_capacity_deque(hdeque, hdeque->capacity * 2) == NULL)
return DEQUE_FAILED;
if (hdeque->head == 0)
hdeque->head = hdeque->capacity - 1;
else
--hdeque->head;
hdeque->deque[hdeque->head] = *val;
++hdeque->count;
return 0;
}
DATATYPE *set_capacity_deque(HDEQUE hdeque, size_t new_capacity)
{
size_t size1, size2;
DATATYPE *new_deque;
if ((new_deque = (DATATYPE *)malloc(new_capacity * sizeof(DATATYPE))) == NULL)
return NULL;
size1 = MIN(hdeque->capacity - hdeque->head, hdeque->count);
size2 = hdeque->count - size1;
memcpy(new_deque, &hdeque->deque[hdeque->head], size1 * sizeof(DATATYPE));
if (size2 != 0)
memcpy(new_deque + size1, hdeque->deque, size2 * sizeof(DATATYPE));
free(hdeque->deque);
hdeque->deque = new_deque;
hdeque->capacity = new_capacity;
hdeque->head = 0;
hdeque->tail = hdeque->count;
return new_deque;
}
DATATYPE at_deque(HDEQUE hdeque, size_t index)
{
return hdeque->deque[(hdeque->head + index) % hdeque->capacity];
}
void atp_deque(HDEQUE hdeque, size_t index, DATATYPE *val)
{
*val = hdeque->deque[(hdeque->head + index) % hdeque->capacity];
}
DATATYPE pop_front_deque(HDEQUE hdeque)
{
size_t head;
head = hdeque->head++;
hdeque->head %= hdeque->capacity;
return hdeque->deque[head];
}
void pop_frontp_deque(HDEQUE hdeque, DATATYPE *val)
{
*val = hdeque->deque[hdeque->head++];
hdeque->head %= hdeque->capacity;
}
size_t insert_deque(HDEQUE hdeque, size_t index, DATATYPE val)
{
size_t k;
if (index > hdeque->count)
return DEQUE_FAILED;
if (hdeque->count == hdeque->capacity && set_capacity_deque(hdeque, hdeque->capacity * 2) == NULL)
return DEQUE_FAILED;
k = hdeque->tail;
for (size_t i = 0; i < hdeque->count - index; ++i) {
if (k == 0) {
k = hdeque->capacity - 1;
hdeque->deque[0] = hdeque->deque[k];
}
else {
hdeque->deque[k] = hdeque->deque[k - 1];
--k;
}
}
hdeque->deque[k] = val;
hdeque->tail = (hdeque->tail + 1) % hdeque->capacity;
++hdeque->count;
return index;
}
size_t remove_deque(HDEQUE hdeque, size_t index)
{
size_t k;
if (index >= hdeque->count)
return DEQUE_FAILED;
k = (hdeque->head + index) % hdeque->capacity;
for (size_t i = 0; i < hdeque->count - index - 1; ++i) {
if (k == hdeque->capacity - 1) {
hdeque->deque[k] = hdeque->deque[0];
k = 0;
}
else {
hdeque->deque[k] = hdeque->deque[k + 1];
++k;
}
}
hdeque->tail = (hdeque->tail + hdeque->capacity - 1) % hdeque->capacity;
--hdeque->count;
return index;
}
void clear_deque(HDEQUE hdeque)
{
hdeque->head = hdeque->tail = 0;
hdeque->count = 0;
}
void destroy_deque(HDEQUE hdeque)
{
free(hdeque->deque);
free(hdeque);
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include "deque.h"
void disp_deque(HDEQUE hdeque);
int main(void)
{
HDEQUE hdeque;
if ((hdeque = create_deque()) == NULL) {
fprintf(stderr, "cannot create deque!..\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 10; ++i)
add_back_deque(hdeque, i);
disp_deque(hdeque);
remove_deque(hdeque, 1);
disp_deque(hdeque);
destroy_deque(hdeque);
return 0;
}
void disp_deque(HDEQUE hdeque)
{
DATATYPE val;
for (int i = 0; i < count_deque(hdeque); ++i) {
val = at_deque(hdeque, i);
printf("%d ", val);
fflush(stdout);
}
printf("\n");
printf("head: %zd, tail: %zd, count: %zd, capacity: %zd\n", hdeque->head, hdeque->tail, count_deque(hdeque), capacity_deque(hdeque));
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Algoritmalar ve veri yapı ı ı ı ı
bulunması ı ı ı ı
Arama işlemleri doğrudan ana bellek (RAM) üzerinde ya da diskteki dosyalar üzerinde yapı
(internal searches)" işlemleri denilmektedir. Diskteki dosyalar üzerinde yapı ı
denilmektedir. Örneğin bir dizideki elemanı ı ı ı
Veritabanı ı ı ı ı ı
yöntemlerinden farklı ı ı ı
yöntemleri "Sistem Programlama ve İleri C Uygulamarı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Elimizde liste tarzı ı ı ı ı
elemanları ı ı ı ı ı ı ı
listenin başı ı ı ı ı
search" denilmektedir. Eğer aranacak eleman listede yoksa buna da "başrı ı
Başarı ı ı ı ı ı ı ı
bu değer N olacaktı ı ı ı ı ı ı ı ı
Örneğin 1000000 elamanı ı ı ı ı ı ı ı
az olduğu listelerde (örneğin eleman sayı ı ı ı ı ı ı ı
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
typedef int DATATYPE;
DATATYPE *linear_search(const DATATYPE *array, size_t size, DATATYPE val)
{
for (size_t i = 0; i < size; ++i)
if (array[i] == val)
return (DATATYPE *)&array[i];
return NULL;
}
int main(void)
{
DATATYPE array[10] = {4, 67, 34, 12, 45, 32, 98, 11, 9, 85};
DATATYPE *val;
if ((val = linear_search(array, 10, 98)) == NULL) {
fprintf(stderr, "cannot find!..\n");
exit(EXIT_FAILURE);
}
printf("%d\n", *val);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı ı
her defası ı ı ı ı
sonuna yerleştirilir. Sonra gereksiz biçimde her yinelemede bu kontrol yapı ı ı
bulunmuş olacaktı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
typedef int DATATYPE;
DATATYPE *linear_search(DATATYPE *array, size_t size, DATATYPE val)
{
size_t i;
array[size] = val;
for (i = 0;; ++i)
if (array[i] == val)
break;
return i != size ? &array[i] : NULL;
}
int main(void)
{
DATATYPE array[10 + 1] = {4, 67, 34, 12, 45, 32, 98, 11, 9, 85};
DATATYPE *val;
if ((val = linear_search(array, 10, 98)) == NULL) {
fprintf(stderr, "cannot find!..\n");
exit(EXIT_FAILURE);
}
printf("%d\n", *val);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Eğer aramanı ı ı ı ı ı ı ı
dizi üzerinde yapı ı
sürekli bir biçimde ikiye bölünerek daraltı ı ı ı ı ı ı ı
milyon eleman için 20 karşı ı ı ı ı
Bir diziyi önce sı ı ı ı
aramadan daha yüksektir. En iyi sı ı ı ı ı ı
arama yaapı ı ı ı ı
İkili arama yapı ı ı ı ı ı ı
aranacak elemanla karşı ı ı ı ı
yanı ı ı ı ı ı
mid = (left + right) / 2;
Bu işlem aslı ı
mid = left + (right - left) / 2;
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
typedef int DATATYPE;
DATATYPE *binary_search(const DATATYPE *array, size_t size, DATATYPE val)
{
size_t left, right, mid;
left = 0, right = size - 1;
while (left <= right) {
mid = (right + left) / 2;
if (val > array[mid])
left = mid + 1;
else if (val < array[mid])
right = mid - 1;
else
return (DATATYPE *)&array[mid];
}
return NULL;
}
int main(void)
{
DATATYPE array[10] = {4, 11, 18, 24, 38, 43, 52, 68, 74, 89};
DATATYPE *val;
if ((val = binary_search(array, 10, 100)) == NULL) {
fprintf(stderr, "cannot find!..\n");
exit(EXIT_FAILURE);
}
printf("%d\n", *val);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Eğer sı ı ı ı ı
çarpı
Yukarı ı ı ı ı ı ı ı ı ı
doğrudan ikili aramaya geçilebilir. Örneğin:
1 3 6 9 11 17 23 28 36 41 48 54 61 67 72 78 82 86 90 92 .....
Böyle bir dizide bir sı ı ı ı ı
başlatı ı
right = 1;
while (array[right] < val && right < size)
right *= 2;
left = right / 2;
Burada artı ı ı ı ı ı ı
yukarı ı ı ı ı
Ondan sonra 4'üncü indeksteki sonra 8'inci (36) sonra 16'ı ı ı ı ı ı ı
eleman olan 78'den büyüktür. Döngü çı ı ı ı ı ı ı
Aşağı ı ı ı ı
sı ı ı ı ı ı ı ı ı ı ı
sağlamamaktadı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
typedef int DATATYPE;
DATATYPE *binary_search(const DATATYPE *array, size_t size, DATATYPE val)
{
size_t left, right, mid;
left = 0, right = size - 1;
while (left <= right) {
mid = (right + left) / 2;
if (val > array[mid])
left = mid + 1;
else if (val < array[mid])
right = mid - 1;
else
return (DATATYPE *)&array[mid];
}
return NULL;
}
DATATYPE *exponential_search(const DATATYPE *array, size_t size, DATATYPE val)
{
size_t left, right;
if (array[0] == val)
return (DATATYPE *)&array[0];
right = 1;
while (right < size && val > array[right])
right *= 2;
if (right >= size)
right = size - 1;
left = right / 2;
return binary_search(array + left, right - left + 1, val);
}
int main(void)
{
DATATYPE array[] = {1, 3, 6, 9, 11, 17, 23, 28, 36, 41, 48, 54, 61, 67, 72, 78, 82, 86, 90, 92};
DATATYPE *val;
if ((val = exponential_search(array, sizeof(array) / sizeof(*array), 61)) == NULL) {
fprintf(stderr, "cannot find!..\n");
exit(EXIT_FAILURE);
}
printf("%d\n", *val);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Sı ı ı ı
yöntem ikili arama gibidir ancak aralı ı ı ı ı
Bu sözlükte y harfi ile başlayan biz sözcüğü aramak isteyelim. Aramayı ı ı ı ı
başlatı ı ı ı ı
aranack anahtarla oranlı ı ı ı ı
aramadan farkı ı ı ı ı ı ı
mid = left + ((right - left) /(array[right] - array[left]) * (val - array[left]))
İfadedeki şu kı
(right - left) / (array[right] - array[left])
Burada yapı ı ı ı ı ı ı ı
edildikten sonra bu değer (val - array[left]) değeri ile çarpı ı ı ı ı
Pekiyi bu yöntem ikili aramadan daha mı ı ı ı ı ı
bir artı ı ı ı ı
çok düşmektedir. Örneğin:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 1000000
Bu gibi durumlarda enterpolasyon araması ı ı ı ı ı ı ı ı ı
hakkı ı ı ı ı
ilerliyorsa ve dizide uç değerler yoksa bu ymntem daha iyi performans gösterebilmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
typedef int DATATYPE;
DATATYPE *interpolation_search(const DATATYPE *array, size_t size, DATATYPE val)
{
size_t left, right, mid;
left = 0, right = size;
while (left <= right) {
mid = left + ((right - left) / (array[right] - array[left]) * (val - array[left]));
if (val > array[mid])
left = mid + 1;
else if (val < array[mid])
right = mid - 1;
else
return (DATATYPE *)&array[mid];
}
return NULL;
}
int main(void)
{
DATATYPE array[] = {1, 3, 6, 9, 11, 17, 23, 28, 36, 41, 48, 54, 61, 67, 72, 78, 82, 86, 90, 92};
DATATYPE *val;
if ((val = interpolation_search(array, sizeof(array) / sizeof(*array), 12)) == NULL) {
fprintf(stderr, "cannot find!..\n");
exit(EXIT_FAILURE);
}
printf("%d\n", *val);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aramalar aslı ı ı ı ı ı
anahtarları ı ı ı ı ı
olmadı ı ı ı
elde edilir. Örneğin öğrencilerin bilgileri numaraları ı ı ı
Arama sonucunda o numaralı
Veri yapı ı ı ı ı
(dictionary)" tarzı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
66. Ders 17/02/2024 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Sözlük tarzı ı ı ı ı ı ı ı
dizide tutulması ı ı ı ı ı ı
yöntemleri" kullanı ı ı ı ı ı
trees)" denilen yöntemlerdir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
İdeal bir anahtar-değer araması ı ı ı ı ı ı ı
değer olduğunu ve kişinin numarası ı
bilgilerini PERSON isimli bir yapı
struct PERSON {
....
};
Sonra da PERSON türünden büyük bir dizi açabiliriz:
struct PERSON people[MAX_SIZE];
Sonra da kişilerin numaraları ı ı
yerleştirilebilir:
people[123] = person_info;
Numarası ı ı ı ı ı
person_info = people[123];
Bu yöntem ilk bakı ı
Ancak anahtarlar farklı ı ı ı
diğer bir sakı ı ı ı ı ı
Örrneğin kişinin TC numarası ı ı ı ı
sı ı ı ı ı ı
arama index search" denilmektedir. Ancak çok özel durumlarda bu yöntem kullanı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Algoritmik aramalarda en çok kullanı ı ı ı ı
belirttiğimiz indeksli arama ile sı ı ı
oluşturulur. Sonra anahtarlar ismine "hash fonksiyonu (hash function)" denilem bir fonksiyona sokularak dizi indeksine dönüştürülür. Sonra da
dizinin o indeksteki elemanı ı ı
uzunluğu da 1000 olsun. Hash fonksiyonunun "1000'e bölümden elde edilen kalan" değerini veren fonksiyon olduğunu varsayalı
örneğin 2566198712 TC kimlik numarası ı
TC kimlik numarası ı ı ı ı
hash fonksiyonuna sokuldupunda aynı ı
elemanı ı
çakı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Hash tabloları ı ı ı ı
(separate chaining) ve açı ı ı
"karesel yoklama (quadratic probing)", "çift hash'leme (double hasing)" gibi alternatif alt yöntemlere ayrı ı ı
ve açı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Ayrı ı ı ı
her elemanı ı ı ı ı
hemen önüne (ya da duruma göre arkası ı
bağlı ı ı ı ı
Hash tabloları ı ı ı ı
hash fonksiyonları ı ı ı ı ı ı ı
olabilmesi için bağlı ı ı ı ı ı ı ı ı ı
Bu koşulda sı ı ı ı ı
tutulursa arama işleminin de O(1) karmaşı ı ı
Sözlük tarzı ı ı ı ı ı
Bazı ı ı ı ı
değerle yer değiştirmektedir. Yani başka bir deyişle anahtarı ı ı ı
insert yapmayı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi hash tabloları ı ı ı ı ı ı ı
her türlü insert gibi arama gibi işlemlerde hash fonksiyonu kullanı ı ı
onları ı ı ı ı
değildir. Hash tabloları ı ı ı ı ı ı ı ı ı
tablo uzunluğu için 100 yerine 101 değeri tercih edilmelidir.) Hash fonksiyonları ı ı ı ı
fonksiyonlar biçiminde oluşturulabilir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Hash tabloları ı ı ı
yeniden hash'lenip yeni tablodaki uygun slotlara yerleştirilmesi gerekmektedir. Pekiyi büyütme ne zaman yapı ı ı
eleman sayı ı ı ı
küçük bir değerde tutulur. Ancak yukarı ı ı ı
tabloları ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı
çift bağlı ı ı ı ı ı
adresi verildiğinde hı ı ı ı ı
eğer ilk düğümse tablonun güncellenmesi gerekir. Onun için de anahtarı ı
adreslerini tutmak yerine doğrudan bir düğüm de tutabilirdik. Bu durumda düğüme dayalı
Örneğimizde hash tablosunu eleman sayı ı ı
tablonun uzunluğu 100 olsun. Tablodaki eleman sayı ı ı ı
kadar düşük tutmayabiliriz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* htable.h */
#ifndef HTABLE_H_
#define HTABLE_H_
#include <stddef.h>
#include <stdbool.h>
/* Type Decalarations */
typedef struct tagPERSON {
char name[32];
int city;
int no;
} PERSON;
typedef struct tagNODE {
char key[32];
PERSON value;
struct tagNODE *next;
struct tagNODE *prev;
} NODE;
typedef struct tagHTABLE {
NODE **table;
size_t tsize;
size_t count;
double lf;
} HTABLE, *HHTABLE;
/* Function Prototypes */
HHTABLE create_lf_ht(size_t tsize, double lf);
NODE *insert_ht(HHTABLE hhtable, const char *key, const PERSON *value);
NODE *update_ht(HHTABLE hhtable, const char *key, const PERSON *value);
PERSON *find_ht(HHTABLE hhtable, const char *key);
bool remove_ht(HHTABLE hhtable, const char *key);
bool resize_ht(HHTABLE hhtable, size_t new_size);
void clear_ht(HHTABLE hhtable);
void destroy_ht(HHTABLE hhtable);
/* inline Function Definitions */
static inline size_t count_ht(HHTABLE hhtable)
{
return hhtable->count;
}
static inline size_t tsize_ht(HHTABLE hhtable)
{
return hhtable->tsize;
}
static inline HHTABLE create_ht(size_t tsize)
{
return create_lf_ht(tsize, 0.75);
}
#endif
/* htable.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "htable.h"
static size_t hash_func(const char *str, size_t tsize);
HHTABLE create_lf_ht(size_t tsize, double lf)
{
HHTABLE hhtable;
if ((hhtable = (HHTABLE)malloc(sizeof(HTABLE))) == NULL)
return NULL;
if ((hhtable->table = (NODE **)malloc(tsize * sizeof(NODE *))) == NULL) {
free(hhtable);
return NULL;
}
for (size_t i = 0; i < tsize; ++i)
hhtable->table[i] = NULL;
hhtable->tsize = tsize;
hhtable->count = 0 ;
hhtable->lf = lf;
return hhtable;
}
NODE *insert_ht(HHTABLE hhtable, const char *key, const PERSON *value)
{
NODE *new_node;
size_t hash;
hash = hash_func(key, hhtable->tsize);
for (NODE *node = hhtable->table[hash]; node != NULL; node = node->next)
if (!strcmp(key, node->key))
return NULL;
if (((double)hhtable->count / hhtable->tsize) >= hhtable->lf)
if (!resize_ht(hhtable, hhtable->tsize * 2))
return NULL;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
strcpy(new_node->key, key);
new_node->value = *value;
new_node->next = hhtable->table[hash];
hhtable->table[hash] = new_node;
++hhtable->count;
return new_node;
}
NODE *update_ht(HHTABLE hhtable, const char *key, const PERSON *value)
{
NODE *new_node;
size_t hash;
hash = hash_func(key, hhtable->tsize);
for (NODE *node = hhtable->table[hash]; node != NULL; node = node->next)
if (!strcmp(key, node->key)) {
node->value = *value;
return node;
}
if (((double)hhtable->count / hhtable->tsize) >= hhtable->lf)
if (!resize_ht(hhtable, hhtable->tsize * 2))
return NULL;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
strcpy(new_node->key, key);
new_node->value = *value;
new_node->next = hhtable->table[hash];
hhtable->table[hash] = new_node;
++hhtable->count;
return new_node;
}
PERSON *find_ht(HHTABLE hhtable, const char *key)
{
size_t hash;
hash = hash_func(key, hhtable->tsize);
for (NODE *node = hhtable->table[hash]; node != NULL; node = node->next)
if (!strcmp(key, node->key))
return &node->value;
return NULL;
}
bool remove_ht(HHTABLE hhtable, const char *key)
{
size_t hash;
NODE *node, *prev_node;
hash = hash_func(key, hhtable->tsize);
prev_node = NULL;
node = hhtable->table[hash];
while (node != NULL) {
if (!strcmp(key, node->key)) {
if (hhtable->table[hash] == node)
hhtable->table[hash] = node->next;
else
prev_node->next = node->next;
free(node);
--hhtable->count;
return true;
}
prev_node = node;
node = node->next;
}
return false;
}
bool resize_ht(HHTABLE hhtable, size_t new_size)
{
NODE **new_table;
NODE *node, *temp_node;
size_t hash;
if (new_size <= hhtable->tsize)
return false;
if ((new_table = (NODE **)malloc(new_size * sizeof(NODE *))) == NULL)
return false;
for (size_t i = 0; i < new_size; ++i)
new_table[i] = NULL;
for (size_t i = 0; i < hhtable->tsize; ++i) {
node = hhtable->table[i];
while (node != NULL) {
temp_node = node->next;
hash = hash_func(node->key, new_size);
node->next = new_table[hash];
new_table[hash] = node;
node = temp_node;
}
}
free(hhtable->table);
hhtable->table = new_table;
hhtable->tsize = new_size;
return true;
}
void clear_ht(HHTABLE hhtable)
{
NODE *node, *temp_node;
for (size_t i = 0; i < hhtable->tsize; ++i) {
node = hhtable->table[i];
while (node != NULL) {
temp_node = node->next;
free(node);
node = temp_node;
}
hhtable->table[i] = NULL;
}
hhtable->count = 0;
}
void destroy_ht(HHTABLE hhtable)
{
NODE *node, *temp_node;
for (size_t i = 0; i < hhtable->tsize; ++i) {
node = hhtable->table[i];
while (node != NULL) {
temp_node = node->next;
free(node);
node = temp_node;
}
}
free(hhtable);
}
static size_t hash_func(const char *str, size_t tsize)
{
size_t hash = 0;
while (*str != '\0') {
hash = (13 * hash + *str) % tsize;
++str;
}
return hash;
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "htable.h"
void get_random_record(char *key, PERSON *per);
int main(void)
{
HHTABLE hhtable;
char name[32];
PERSON per;
PERSON specific_per = {"Kaan Aslan", 34, 123456};
PERSON *retper;
srand((unsigned)time(NULL));
if ((hhtable = create_ht(10)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 1000; ++i) {
if (i == 500) {
if (insert_ht(hhtable, "Kaan Aslan", &specific_per) == NULL) {
fprintf(stderr, "cannot insert item!..\n");
exit(EXIT_FAILURE);
}
}
else {
get_random_record(name, &per);
if (insert_ht(hhtable, name, &per) == NULL) {
fprintf(stderr, "cannot insert item!..\n");
exit(EXIT_FAILURE);
}
}
}
if ((retper = find_ht(hhtable, "Kaan Aslan")) != NULL)
printf("Found: %s, %d, %d\n", retper->name, retper->city, retper->no);
else
printf("cannot find key!..\n");
strcpy(per.name, "Kaan Aslan");
per.city = 35;
per.no = 1000;
if (update_ht(hhtable, "Kaan Aslan", &per) == NULL)
printf("Update failed!..\n");
if ((retper = find_ht(hhtable, "Kaan Aslan")) != NULL)
printf("Found: %s, %d, %d\n", retper->name, retper->city, retper->no);
else
printf("cannot find key!..\n");
printf("count: %zd\n", count_ht(hhtable));
printf("tsize: %zd\n", tsize_ht(hhtable));
destroy_ht(hhtable);
return 0;
}
void get_random_record(char *key, PERSON *per)
{
int i;
for (i = 0; i < 31; ++i)
key[i] = per->name[i] = rand() % 26 + 'A';
per->name[i] = key[i] = '\0';
per->city = rand() % 81;
per->no = rand() % 1000000;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* htable.h */
#ifndef HTABLE_H_
#define HTABLE_H_
#include <stddef.h>
#include <stdbool.h>
#define HT_DEF_LOAD_FACTOR 0.75
/* Type Decalarations */
typedef struct tagPERSON {
char name[32];
int city;
int no;
} PERSON;
typedef struct tagNODE {
char key[32];
PERSON value;
struct tagNODE *next;
} NODE;
typedef struct tagHTABLE {
NODE **table;
size_t tsize;
size_t count;
double lf;
} HTABLE, *HHTABLE;
/* Function Prototypes */
HHTABLE create_lf_ht(size_t tsize, double lf);
NODE *insert_ht(HHTABLE hhtable, const char *key, const PERSON *value);
NODE *update_ht(HHTABLE hhtable, const char *key, const PERSON *value);
PERSON *find_ht(HHTABLE hhtable, const char *key);
bool remove_ht(HHTABLE hhtable, const char *key);
bool resize_ht(HHTABLE hhtable, size_t new_size);
void clear_ht(HHTABLE hhtable);
void destroy_ht(HHTABLE hhtable);
/* inline Function Definitions */
static inline size_t count_ht(HHTABLE hhtable)
{
return hhtable->count;
}
static inline size_t tsize_ht(HHTABLE hhtable)
{
return hhtable->tsize;
}
static inline HHTABLE create_ht(size_t tsize)
{
return create_lf_ht(tsize, HT_DEF_LOAD_FACTOR);
}
#endif
/* htable.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "htable.h"
static size_t hash_func(const char *str, size_t tsize);
HHTABLE create_lf_ht(size_t tsize, double lf)
{
HHTABLE hhtable;
if ((hhtable = (HHTABLE)malloc(sizeof(HTABLE))) == NULL)
return NULL;
if ((hhtable->table = (NODE **)malloc(tsize * sizeof(NODE *))) == NULL) {
free(hhtable);
return NULL;
}
for (size_t i = 0; i < tsize; ++i)
hhtable->table[i] = NULL;
hhtable->tsize = tsize;
hhtable->count = 0 ;
hhtable->lf = lf;
return hhtable;
}
NODE *insert_ht(HHTABLE hhtable, const char *key, const PERSON *value)
{
NODE *new_node;
size_t hash;
hash = hash_func(key, hhtable->tsize);
for (NODE *node = hhtable->table[hash]; node != NULL; node = node->next)
if (!strcmp(key, node->key))
return NULL;
if ((hhtable->count / hhtable->tsize) >= hhtable->lf)
if (!resize_ht(hhtable, hhtable->tsize * 2))
return NULL;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
strcpy(new_node->key, key);
new_node->value = *value;
new_node->next = hhtable->table[hash];
hhtable->table[hash] = new_node;
++hhtable->count;
return new_node;
}
NODE *update_ht(HHTABLE hhtable, const char *key, const PERSON *value)
{
NODE *new_node;
size_t hash;
hash = hash_func(key, hhtable->tsize);
for (NODE *node = hhtable->table[hash]; node != NULL; node = node->next)
if (!strcmp(key, node->key)) {
node->value = *value;
return node;
}
if ((hhtable->count / hhtable->tsize) >= hhtable->lf)
if (!resize_ht(hhtable, hhtable->tsize * 2))
return NULL;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
strcpy(new_node->key, key);
new_node->value = *value;
new_node->next = hhtable->table[hash];
hhtable->table[hash] = new_node;
++hhtable->count;
return new_node;
}
PERSON *find_ht(HHTABLE hhtable, const char *key)
{
size_t hash;
hash = hash_func(key, hhtable->tsize);
for (NODE *node = hhtable->table[hash]; node != NULL; node = node->next)
if (!strcmp(key, node->key))
return &node->value;
return NULL;
}
bool remove_ht(HHTABLE hhtable, const char *key)
{
size_t hash;
NODE *node, *prev_node;
hash = hash_func(key, hhtable->tsize);
prev_node = NULL;
node = hhtable->table[hash];
while (node != NULL) {
if (!strcmp(key, node->key)) {
if (hhtable->table[hash] == node)
hhtable->table[hash] = node->next;
else
prev_node->next = node->next;
free(node);
--hhtable->count;
return true;
}
prev_node = node;
node = node->next;
}
return false;
}
bool resize_ht(HHTABLE hhtable, size_t new_size)
{
NODE **new_table;
NODE *node, *temp_node;
size_t hash;
if (new_size <= hhtable->tsize)
return false;
if ((new_table = (NODE **)malloc(new_size * sizeof(NODE *))) == NULL)
return false;
for (size_t i = 0; i < new_size; ++i)
new_table[i] = NULL;
for (size_t i = 0; i < hhtable->tsize; ++i) {
node = hhtable->table[i];
while (node != NULL) {
temp_node = node->next;
hash = hash_func(node->key, new_size);
node->next = new_table[hash];
new_table[hash] = node;
node = temp_node;
}
}
free(hhtable->table);
hhtable->table = new_table;
hhtable->tsize = new_size;
return true;
}
void clear_ht(HHTABLE hhtable)
{
NODE *node, *temp_node;
for (size_t i = 0; i < hhtable->tsize; ++i) {
node = hhtable->table[i];
while (node != NULL) {
temp_node = node->next;
free(node);
node = temp_node;
}
hhtable->table[i] = NULL;
}
hhtable->count = 0;
}
void destroy_ht(HHTABLE hhtable)
{
NODE *node, *temp_node;
for (size_t i = 0; i < hhtable->tsize; ++i) {
node = hhtable->table[i];
while (node != NULL) {
temp_node = node->next;
free(node);
node = temp_node;
}
}
free(hhtable);
}
static size_t hash_func(const char *str, size_t tsize)
{
size_t hash = 0;
while (*str != '\0') {
hash = (13 * hash + *str) % tsize;
++str;
}
return hash;
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "htable.h"
void get_random_record(char *key, PERSON *per);
int main(void)
{
HHTABLE hhtable;
char name[32];
PERSON per;
PERSON specific_per = {"Kaan Aslan", 34, 123456};
PERSON *retper;
srand((unsigned)time(NULL));
if ((hhtable = create_ht(10)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 1000; ++i) {
if (i == 500) {
if (insert_ht(hhtable, "Kaan Aslan", &specific_per) == NULL) {
fprintf(stderr, "cannot insert item!..\n");
exit(EXIT_FAILURE);
}
}
else {
get_random_record(name, &per);
if (insert_ht(hhtable, name, &per) == NULL) {
fprintf(stderr, "cannot insert item!..\n");
exit(EXIT_FAILURE);
}
}
}
if ((retper = find_ht(hhtable, "Kaan Aslan")) != NULL)
printf("Found: %s, %d, %d\n", retper->name, retper->city, retper->no);
else
printf("cannot find key!..\n");
strcpy(per.name, "Kaan Aslan");
per.city = 35;
per.no = 1000;
if (update_ht(hhtable, "Kaan Aslan", &per) == NULL)
printf("Update failed!..\n");
if ((retper = find_ht(hhtable, "Kaan Aslan")) != NULL)
printf("Found: %s, %d, %d\n", retper->name, retper->city, retper->no);
else
printf("cannot find key!..\n");
printf("count: %zd\n", count_ht(hhtable));
printf("tsize: %zd\n", tsize_ht(hhtable));
destroy_ht(hhtable);
return 0;
}
void get_random_record(char *key, PERSON *per)
{
int i;
for (i = 0; i < 31; ++i)
key[i] = per->name[i] = rand() % 26 + 'A';
per->name[i] = key[i] = '\0';
per->city = rand() % 81;
per->no = rand() % 1000000;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Anı ı ı ı ı ı
"yoklama (probing)" biçimine göre çeşitli alt yöntemlere ayrı ı ı ı
(linear probing)" denilen biçimidir.
Doğrusal yoklama (linear probing) oldukça basit bir fikre dayanmaktadı
bağlı
elde edilir. Doğrudan değer tablonun hash ile elde edilen indeksine yerleştirilir. Başka bir anahtar aynı
çakı ı ı ı ı
değerini elde etmiş olalı ı ı ı
elemanı ı ı
bizim indeksimize yerleşmişse biz de aslı
sahip olan değer de bizim yaptı ı ı ı ı
Yani aranacak elemanı
görülene kadar yan yana diğer indekslere bakı ı
Anahtara dayalı ı ı ı ı
işlemlerinde sorunlara yol açabilecektir. Burada yöntemlerden biri silinen elemanı ı
belirtilmesidir. Örneğin her slot için bir status bayrağı ı
ya da "silinmiş" olduğunu belirtebilir. Böylece arama sı ı
durulur. Tabii silinmiş slotlara yeni elemanlar eklenebilir.
Aşağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* htable.h */
#ifndef HASHTABLE_
#define HASHTABLE_
#include <stddef.h>
#include <stdbool.h>
/* Symbolic Constants */
#define HT_DEF_LOAD_FACTOR 0.75
#define HT_STATUS_EMPTY 0
#define HT_STATUS_INUSE 1
#define HT_STATUS_DELETED 2
/* Type Declarations */
typedef struct tagPERSON {
char name[32];
int city;
int no;
} PERSON;
typedef struct tagBUCKET {
int status;
char key[32];
PERSON value;
} BUCKET;
typedef struct tagHTABLE {
BUCKET *ht;
size_t tsize;
size_t count;
double lf;
} HTABLE, *HHTABLE;
/* Function Prototypes */
HHTABLE create_lf_ht(size_t tsize, double lf);
bool insert_ht(HHTABLE hhtable, const char *key, const PERSON *value);
bool update_ht(HHTABLE hhtable, const char *key, const PERSON *value);
bool remove_ht(HHTABLE hhtable, const char *key);
void clear_ht(HHTABLE hhtable);
void destroy_ht(HHTABLE hhtable);
PERSON *find_ht(HHTABLE hhtable, const char *key);
bool resize_ht(HHTABLE hhtable, size_t new_size);
/* inline Function Definitions */
static inline size_t count_ht(HHTABLE hhtable)
{
return hhtable->count;
}
static inline size_t tsize_ht(HHTABLE hhtable)
{
return hhtable->tsize;
}
static inline HHTABLE create_ht(size_t tsize)
{
return create_lf_ht(tsize, HT_DEF_LOAD_FACTOR);
}
#endif
/* htable.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "hashtable.h"
static size_t hash_func(const char *str, size_t tsize);
HHTABLE create_lf_ht(size_t tsize, double lf)
{
HHTABLE hhtable;
if ((hhtable = (HHTABLE)malloc(sizeof(HTABLE))) == NULL)
return NULL;
if ((hhtable->ht = (BUCKET *)malloc(tsize * sizeof(BUCKET))) == NULL) {
free(hhtable);
return NULL;
}
for (size_t i = 0; i < tsize; ++i)
hhtable->ht[i].status = HT_STATUS_EMPTY;
hhtable->tsize = tsize;
hhtable->lf = lf;
hhtable->count = 0;
return hhtable;
}
bool insert_ht(HHTABLE hhtable, const char *key, const PERSON *value)
{
size_t index;
if (hhtable->count >= hhtable->tsize)
return false;
if (((double)hhtable->count / hhtable->tsize) >= hhtable->lf)
if (!resize_ht(hhtable, hhtable->tsize * 2))
return false;
index = hash_func(key, hhtable->tsize);
while (hhtable->ht[index].status != HT_STATUS_EMPTY) {
if (!strcmp(hhtable->ht[index].key, key))
return false;
index = (index + 1) % hhtable->tsize;
}
strcpy(hhtable->ht[index].key, key);
hhtable->ht[index].value = *value;
hhtable->ht[index].status = HT_STATUS_INUSE;
++hhtable->count;
return true;
}
bool update_ht(HHTABLE hhtable, const char *key, const PERSON *value)
{
size_t index;
if (hhtable->count >= hhtable->tsize)
return false;
if (((double)hhtable->count / hhtable->tsize) >= hhtable->lf)
if (!resize_ht(hhtable, hhtable->tsize * 2))
return false;
index = hash_func(key, hhtable->tsize);
while (hhtable->ht[index].status != HT_STATUS_EMPTY) {
if (!strcmp(hhtable->ht[index].key, key)) {
hhtable->ht[index].value = *value;
return true;
}
index = (index + 1) % hhtable->tsize;
}
strcpy(hhtable->ht[index].key, key);
hhtable->ht[index].value = *value;
hhtable->ht[index].status = HT_STATUS_INUSE;
++hhtable->count;
return true;
}
bool remove_ht(HHTABLE hhtable, const char *key)
{
size_t index, hash;
hash = index = hash_func(key, hhtable->tsize);
do {
if (hhtable->ht[index].status == HT_STATUS_EMPTY)
break;
if (hhtable->ht[index].status == HT_STATUS_INUSE && !strcmp(hhtable->ht[index].key, key)) {
hhtable->ht[index].status = HT_STATUS_DELETED;
--hhtable->count;
return true;
}
index = (index + 1) % hhtable->tsize;
} while (index != hash);
return false;
}
PERSON *find_ht(HHTABLE hhtable, const char *key)
{
size_t index, hash;
hash = index = hash_func(key, hhtable->tsize);
do {
if (hhtable->ht[index].status == HT_STATUS_EMPTY)
break;
if (hhtable->ht[index].status == HT_STATUS_INUSE && !strcmp(hhtable->ht[index].key, key))
return &hhtable->ht[index].value;
index = (index + 1) % hhtable->tsize;
} while (index != hash);
return NULL;
}
bool resize_ht(HHTABLE hhtable, size_t new_size)
{
BUCKET *new_ht;
size_t index;
if (new_size <= hhtable->tsize)
return false;
if ((new_ht = (BUCKET *)malloc(new_size * sizeof(BUCKET))) == NULL)
return false;
for (size_t i = 0; i < new_size; ++i)
new_ht[i].status = HT_STATUS_EMPTY;
for (size_t i = 0; i < hhtable->tsize; ++i) {
if (hhtable->ht[i].status == HT_STATUS_INUSE) {
index = hash_func(hhtable->ht[i].key, new_size);
while (new_ht[index].status != HT_STATUS_EMPTY)
index = (index + 1) % new_size;
new_ht[index] = hhtable->ht[i];
}
}
free(hhtable->ht);
hhtable->ht = new_ht;
hhtable->tsize = new_size;
return true;
}
void clear_ht(HHTABLE hhtable)
{
for (size_t i = 0; i < hhtable->tsize; ++i)
hhtable->ht[i].status = HT_STATUS_EMPTY;
hhtable->count = 0;
}
void destroy_ht(HHTABLE hhtable)
{
free(hhtable->ht);
free(hhtable);
}
static size_t hash_func(const char *str, size_t tsize)
{
size_t hash = 0;
while (*str != '\0') {
hash = (13 * hash + *str) % tsize;
++str;
}
return hash;
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "hashtable.h"
void get_random_record(char *key, PERSON *per);
int main(void)
{
HHTABLE hhtable;
char name[32];
PERSON per, *pper;
PERSON specific_per = {"Kaan Aslan", 34, 123456};
srand((unsigned)time(NULL));
if ((hhtable = create_ht(10)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 1000; ++i) {
if (i == 500) {
if (!insert_ht(hhtable, "Kaan Aslan", &specific_per)) {
fprintf(stderr, "cannot insert item!..\n");
exit(EXIT_FAILURE);
}
}
else {
get_random_record(name, &per);
if (!insert_ht(hhtable, name, &per)) {
fprintf(stderr, "cannot insert item!..\n");
exit(EXIT_FAILURE);
}
}
}
if (remove_ht(hhtable, "Kaan Aslan"))
printf("Item removed...\n");
else
printf("cannot remove item!..\n");
if ((pper = find_ht(hhtable, "Kaan Aslan")) != NULL)
printf("Found: %s %d %d\n", pper->name, pper->city, pper->no);
else
printf("cannot find record!..\n");
destroy_ht(hhtable);
return 0;
}
void get_random_record(char *key, PERSON *per)
{
int i;
for (i = 0; i < 31; ++i)
key[i] = per->name[i] = rand() % 26 + 'A';
per->name[i] = key[i] = '\0';
per->city = rand() % 81;
per->no = rand() % 1000000;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı ı ı
yöntemleri de vardı ı ı ı ı
yoluyla bakı ı ı ı ı
Biz bu yöntemde 20 + 1, 20 + 2, 20 + 9, 20 + 16 gibi karesel değerlerle yoklama yaparı
Çift hash'leme (double hasing) yönteminde ise önce bir hash fonksiyonu ile indeks elde edilir. Eğer çakı
ikinci bir hash fonksiyonuna başvurularak belirlenir.
Yukarı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Biz tek bağlı ı ı
sonraki düğümü gösteriyordu. Pekiyi bir düğüm birden fazla düğümü gösterirse bu nası ı ı
düğümü göstermesi durumunda oluşan veri yapı ı ı ı
inceleyeceğiz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Her ağacı ı
her düğüme gitmenin yalnı ı ı ı
"graf" denilmektedir. Ağaçlar konusunu iyi anlayabilmek için ağaç terminolojisini biliyor olmak gerekir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Ağaçlarda bir düğümden gidel sonraki düğümlere "o düğümün alt düğümleri (child nodes)" denilmektedir. Kök düğüm haricindeki her düğümün
tek bir "üst düğümü (parent node)" vardı ı ı
Ağacı ı ı
sahip olabileceği alt düğüm sayı ı ı
bir ağaçta her düğümün "en fazla düğümü" olabiliyorsa böyle ağaçlara "ikili ağaçlar (binary trees)", en fazla üç düğümü olabiliyorsa bunlara
"üçlü ağaçlar (ternary tree)", en fazla n düğümü olabiliyorsa bunlara "n'li ağaçlar (n'ary tree)" denilmektedir. Uygulamada en fazla
karşı ı ı ı ı
durumundadı
Ağaçlarda "her düğümün bir yükseliği (height)" vardı ı ı
ile belirlenir. Kök düğüm yüksekliği 0'dı ı ı
Bir ağaçta bütün yaprak düğümlerin yükseklikleri arası
ağaçlara "dengelenmiş ağaçlar (balanced trees)" denilmektedir. Örneğin bu farklı ı ı
yükseklikleri arası ı ı
Bir N'li ağaçta ağacı ı ı ı
yaprakları ı
Bir N'li ağaç en son kademe (en alt kademe) dı ı ı
"tam ağaçlar (complete tree)" denilmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Uygulamada en fazla kullanı ı ı
düğümü olabilmektedir. Bir ikili ağaca ilişkin düğüm aşağı ı
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *left;
struct tagNODE *right;
} NODE;
Burada val elemanı ı ı
sol ya da sağ alt düğümü yoksa bu left ve right elemanları ı
tutmamı ı ı
typedef struct tagBTREE {
NODE *root;
size_t count;
} BTREE, *HBTREE;
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Ağaçlar en çok "arama (search)" amaçlı ı ı ı ı ı
Arama ağaçları ı ı ı
Arama ağaçları
bir anahtara göre yapı ı ı ı
typedef struct tagNODE {
KEY key;
VALUE value;
struct tagNODE *left;
struct tagNODE *right;
} NODE;
Burada key arama için kullanı ı
numarası ı
typedef struct tagNODE {
int key;
PERSON value;
struct tagNODE *left;
struct tagNODE *right;
} NODE;
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir ikili arama ağacı ı ı ı
girilir. Eklenecek anahtar düğümdeki anahtarla karşı ı ı ı
doğru ilerlenir. Örneğin ağaca sı ı
40
Sonra 60 değeri 40'dan büyük olduğu için 40'ı ı
40
60
Sonra 25 değeri 40'tan küçük olduğu için 40'ı
40
25 60
Sonra 16 değeri 40'tan küçük ve 25'ten küçük olduğu için 25'in soluna eklenir:
40
25 60
16
Sonra 52 değeri 40'tan büyük 60'tan küçük olduğuna göre 60'ı
40
25 60
16 52
8 değeri 40'tan küçük, 25'ten küçük ve 16'dan küçük olduğuna göre 16'nı
40
25 60
16 52
8
İkili ağaçlarda eleman arama benzer biçimde yapı ı ı ı ı ı
Eğer aranan anahtar düğümdeki anahtardan küçükse sola, büyükse sağa doğru ilerlenir. Yapraklara gelindiğinde yani daha fazla sola ya da
sağa gidilemediğinde arama sonlandı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
İkili arama ağacı ı ı ı
karmaşı ı ı ı ı
sı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Ağaçları ı ı ı ı
1) In-Order dolaşı
2) Pre-Order dolaşı
3) Post-Order dolaşı
4) Breadt-First Dolaşı
Buradaki "in", "pre" ve "post" sözcükleri alt düğümlere göre üst düğümün hangi sı ı ı ı ı
soldan-sağa ya da sağdan sola yapı
In-order soldan sağa dolaşı ı ı ı
void inorder_walk_lr(Node *node)
{
if (node->left != NULL)
inorder_walk_lr(node->left);
printf(node->val);
if (node->right != NULL)
inorder_walk_lr(node->right);
}
In-order soldan sağa dolaşı ı ı ı ı ı ı
sol koldan ilerlenmeye çalı ı ı ı ı ı ı ı
In-order sağdan sola dolaşı ı ı
void inorder_walk_rl(Node *node)
{
if (node->right != NULL)
inorder_walk_rl(node->right);
printf(node->val);
if (node->left != NULL)
inorder_walk_rl(node->left);
}
In-order sağdan sola dolaşı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Post-order dolaşı ı ı
Temsili kodu aşağı
void postorder_walk_lr(Node *node)
{
if (node->left != NULL)
postorder_walk_lr(node->left);
if (node->right != NULL)
postorder_walk_lr(node->right);
printf(node->val);
}
postoreder dolaşı ı ı ı ı ı ı
Post-order dolaşı
önce alt düğümlerin sonra ana düğümün free hale getirilmesiyle gerçekleştirilmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Pre-order dolaşı
yapı ı ı ı ı ı ı ı
Pre-order soldan sağa dolaşı ı
void preorder_walk_lr(Node *node)
{
printf(node->val);
if (node->left != NULL)
preorder_walk_lr(node->left);
if (node->right != NULL)
preorder_walk_lr(node->right);
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
70. Ders 02/03/2024 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Kademe Kademe breadth-first dolaşı
1
2 3
4 5 6 7
8 9 10 11 12 13 14 15
Buradaki numaralar breadt-first dolaşı ı ı ı ı ı ı ı ı ı
vardı ı ı ı ı ı
düğümler kuyruk sisteminden çekilir. Dolaşı ı
put(root);
while ((node = get()) != NULL) {
process(node);
if (node->left != NULL)
put(node->left);
if (node->right != NULL)
put(node->right);
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
İkili ağaçlarda en karmaşı ı ı ı
sahip olması ı
1) Silinecek düğüm bir yaprak düğüm ise tek yapı ı
2) Silinecek düğümün tek bir alt düğümü varsa işlem yine kolaydı ı ı
3) Silincek düğümün iki alt düğümünün de olması ı
düğüm "ya sol kolun en büyük düğümü" ya da "sağ kolun en küçük düğümü" olabilir. Fakat bu durumda ağaçta birkaç güncellemenin yapı ı
gerekmektedir. Silinecek düğümünyerine geçecek olan düğümün süt düğümünün ve silinecek düğümün üst düğümünün gencellenmesi gerekmektedir.
4) Silinecek düğümün kök düğüm olması ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* binarytree. h */
#ifndef BINARYTREE_H_
#define BINARYTREE_H_
#include <stddef.h>
#include <stdbool.h>
/* Type Declararions */
typedef struct tagPERSON {
char name[32];
int city;
} PERSON;
typedef struct tagNODE {
int key;
PERSON value;
struct tagNODE *left;
struct tagNODE *right;
} NODE;
typedef struct tagQNODE {
struct tagQNODE *next;
NODE *node;
} QNODE;
typedef struct tagBTREE {
NODE *root;
size_t count;
QNODE *head;
QNODE *tail;
} BTREE, *HBTREE;
/* Function Prototypes */
HBTREE create_bt(void);
bool insert_item_bt(HBTREE hbtree, int key, const PERSON *value);
bool insert_item_alternative_bt(HBTREE hbtree, int key, const PERSON *value);
bool walk_inorder_lr_bt(HBTREE hbtree, bool (*proc)(int, PERSON *));
bool walk_inorder_rl_bt(HBTREE hbtree, bool (*proc)(int, PERSON *));
bool walk_postorder_lr_bt(HBTREE hbtree, bool (*proc)(int, PERSON *));
bool walk_preorder_lr_bt(HBTREE hbtree, bool (*proc)(int, PERSON *));
bool walk_breadth_first_bt(HBTREE hbtree, bool (*proc)(int, PERSON *));
bool delete_bt(HBTREE hbtree, int key);
void clear_bt(HBTREE hbtree);
void destroy_bt(HBTREE hbtree);
/* inline Function Fefinitions */
static inline size_t count_bt(HBTREE hbtree)
{
return hbtree->count;
}
#endif
/* binarytree.c */
#include <stdio.h>
#include <stdlib.h>
#include "binarytree.h"
static bool walk_inorder_lr_recur(NODE *node, bool (*proc)(int, PERSON *));
static bool walk_inorder_rl_recur(NODE *node, bool (*proc)(int, PERSON *));
static bool walk_postorder_lr_recur(NODE *node, bool (*proc)(int, PERSON *));
static bool walk_preorder_lr_recur(NODE *node, bool (*proc)(int, PERSON *));
static void clear_recur(NODE *node);
static void create_queue(HBTREE hbtree);
static NODE *put_queue(HBTREE hbtree, NODE *node);
static NODE *get_queue(HBTREE hbtree);
static void destroy_queue(HBTREE hbtree);
static void subtree_shift(HBTREE hbtree, NODE *node1, NODE *node2, NODE *node3);
HBTREE create_bt(void)
{
HBTREE hbtree;
if ((hbtree = (HBTREE)malloc(sizeof(BTREE))) == NULL)
return NULL;
hbtree->root = NULL;
hbtree->count = 0;
return hbtree;
}
bool insert_item_bt(HBTREE hbtree, int key, const PERSON *value)
{
NODE *new_node, *node, *parent_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return false;
new_node->key = key;
new_node->value = *value;
new_node->left = NULL;
new_node->right = NULL;
if (hbtree->root == NULL) {
hbtree->root = new_node;
++hbtree->count;
return true;
}
node = hbtree->root;
while (node != NULL) {
parent_node = node;
if (key < node->key)
node = node->left;
else if (key > node->key)
node = node->right;
else {
node->value = *value;
return true;
}
}
if (key < parent_node->key)
parent_node->left = new_node;
else
parent_node->right = new_node;
++hbtree->count;
return true;
}
bool insert_item_alternative_bt(HBTREE hbtree, int key, const PERSON *value)
{
NODE *new_node, *node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return false;
new_node->key = key;
new_node->value = *value;
new_node->left = NULL;
new_node->right = NULL;
if (hbtree->root == NULL) {
hbtree->root = new_node;
++hbtree->count;
return true;
}
node = hbtree->root;
while (node != NULL) {
if (key < node->key)
if (node->left == NULL) {
node->left = new_node;
break;
}
else
node = node->left;
else if (key > node->key)
if (node->right == NULL) {
node->right = new_node;
break;
}
else
node = node->right;
else {
node->value = *value;
return true;
}
}
++hbtree->count;
return true;
}
bool walk_inorder_lr_bt(HBTREE hbtree, bool (*proc)(int, PERSON *))
{
if (hbtree->root != NULL)
return walk_inorder_lr_recur(hbtree->root, proc);
return true;
}
bool walk_inorder_rl_bt(HBTREE hbtree, bool (*proc)(int, PERSON *))
{
if (hbtree->root != NULL)
return walk_inorder_rl_recur(hbtree->root, proc);
return true;
}
bool walk_postorder_lr_bt(HBTREE hbtree, bool (*proc)(int, PERSON *))
{
if (hbtree->root != NULL)
return walk_postorder_lr_recur(hbtree->root, proc);
return true;
}
bool walk_preorder_lr_bt(HBTREE hbtree, bool (*proc)(int, PERSON *))
{
if (hbtree->root != NULL)
return walk_preorder_lr_recur(hbtree->root, proc);
return true;
}
void clear_bt(HBTREE hbtree)
{
if (hbtree->root != NULL) {
clear_recur(hbtree->root);
hbtree->root = NULL;
hbtree->count = 0;
}
}
void destroy_bt(HBTREE hbtree)
{
if (hbtree->root != NULL)
clear_recur(hbtree->root);
free(hbtree);
}
bool walk_breadth_first_bt(HBTREE hbtree, bool (*proc)(int, PERSON *))
{
NODE *node;
bool result = true;
create_queue(hbtree);
put_queue(hbtree, hbtree->root);
while ((node = get_queue(hbtree)) != NULL) {
if (!proc(node->key, &node->value)) {
result = false;
break;
}
if (node->left != NULL)
if (put_queue(hbtree, node->left) == NULL) {
fprintf(stderr, "put_queue cannot allocate memory!..\n");
result = false;
break;
}
if (node->right != NULL)
if (put_queue(hbtree, node->right) == NULL) {
result = false;
fprintf(stderr, "put_queue cannot allocate memory!..\n");
break;
}
}
destroy_queue(hbtree);
return result;
}
bool delete_bt(HBTREE hbtree, int key)
{
NODE *delete_node, *delete_parent_node, *replace_parent_node, *replace_node;
delete_node= hbtree->root;
delete_parent_node = NULL;
while (delete_node != NULL) {
if (delete_node->key == key)
break;
delete_parent_node = delete_node;
if (key < delete_node->key)
delete_node = delete_node->left;
else if (key > delete_node->key )
delete_node = delete_node->right;
}
if (delete_node == NULL)
return false;
if (delete_node->left == NULL)
subtree_shift(hbtree, delete_parent_node, delete_node, delete_node->right);
else if (delete_node->right == NULL)
subtree_shift(hbtree, delete_parent_node, delete_node, delete_node->left);
else {
replace_parent_node = delete_node;
replace_node = delete_node->right;
while (replace_node->left!= NULL) {
replace_parent_node = replace_node;
replace_node= replace_node->left;
}
if (replace_parent_node != delete_node) {
subtree_shift(hbtree, replace_parent_node, replace_node, replace_node->right);
replace_node->right= delete_node->right;
}
subtree_shift(hbtree, delete_parent_node, delete_node, replace_node);
replace_node->left = delete_node->left;
}
free(delete_node);
--hbtree->count;
return true;
}
static bool walk_inorder_lr_recur(NODE *node, bool (*proc)(int, PERSON *))
{
if (node->left != NULL)
if (!walk_inorder_lr_recur(node->left, proc))
return false;
if(!proc(node->key, &node->value))
return false;
if (node->right != NULL)
if (!walk_inorder_lr_recur(node->right, proc))
return false;
return true;
}
static bool walk_inorder_rl_recur(NODE *node, bool (*proc)(int, PERSON *))
{
if (node->right != NULL)
if (!walk_inorder_rl_recur(node->right, proc))
return false;
if (!proc(node->key, &node->value))
return false;
if (node->left != NULL)
if (!walk_inorder_rl_recur(node->left, proc))
return false;
return true;
}
static bool walk_postorder_lr_recur(NODE *node, bool (*proc)(int, PERSON *))
{
if (node->left != NULL)
if (!walk_postorder_lr_recur(node->left, proc))
return false;
if (node->right != NULL)
if (!walk_postorder_lr_recur(node->right, proc))
return false;
if (!proc(node->key, &node->value))
return false;
return true;
}
static bool walk_preorder_lr_recur(NODE *node, bool (*proc)(int, PERSON *))
{
if (!proc(node->key, &node->value))
return false;
if (node->left != NULL)
if (!walk_preorder_lr_recur(node->left, proc))
return false;
if (node->right != NULL)
if (!walk_preorder_lr_recur(node->right, proc))
return false;
return true;
}
static void clear_recur(NODE *node)
{
if (node->left != NULL)
clear_recur(node->left);
if (node->right != NULL)
clear_recur(node->right);
free(node);
}
static void create_queue(HBTREE hbtree)
{
hbtree->head = NULL;
hbtree->tail = NULL;
}
static NODE *put_queue(HBTREE hbtree, NODE *node)
{
QNODE *new_qnode;
if ((new_qnode = (QNODE *)malloc(sizeof(QNODE))) == NULL)
return NULL;
new_qnode->node = node;
new_qnode->next = NULL;
if (hbtree->tail != NULL)
hbtree->tail->next = new_qnode;
else
hbtree->head = new_qnode;
hbtree->tail = new_qnode;
return node;
}
static NODE *get_queue(HBTREE hbtree)
{
QNODE *qnode;
NODE *rnode;
if (hbtree->head == NULL)
return NULL;
qnode = hbtree->head;
hbtree->head = qnode->next;
if (hbtree->head == NULL)
hbtree->tail = NULL;
rnode = qnode->node;
free(qnode);
return rnode;
}
static void destroy_queue(HBTREE hbtree)
{
QNODE *qnode, *temp_qnode;
qnode = hbtree->head;
while (qnode != NULL) {
temp_qnode = qnode->next;
free(qnode);
qnode = temp_qnode;
}
}
static void subtree_shift(HBTREE hbtree, NODE *node1, NODE *node2, NODE *node3)
{
if (node1 == NULL)
hbtree->root = node3;
else if (node1->left == node2)
node1->left = node3;
else
node1->right = node3;
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include "binarytree.h"
bool disp_node(int key, PERSON *value);
int main(void)
{
HBTREE hbtree;
PERSON per = {"Noname", 0};
int keys[] = {70, 50, 34, 56, 19, 80, 67, 43, 27, 76, 79, 105, 82, 65, 0};
if ((hbtree = create_bt()) == NULL) {
fprintf(stderr, "cannot create binary tree!..\n");
exit(EXIT_FAILURE);
}
for (int i = 0; keys[i] != 0; ++i)
if (!insert_item_alternative_bt(hbtree, keys[i], &per)) {
fprintf(stderr, "cannot insert item: %d\n", keys[i]);
exit(EXIT_FAILURE);
}
walk_inorder_lr_bt(hbtree, disp_node);
printf("\n------------------------------\n");
walk_inorder_rl_bt(hbtree, disp_node);
printf("\n------------------------------\n");
walk_postorder_lr_bt(hbtree, disp_node);
printf("\n------------------------------\n");
walk_inorder_lr_bt(hbtree, disp_node);
printf("\n------------------------------\n");
walk_preorder_lr_bt(hbtree, disp_node);
printf("\n------------------------------\n");
walk_breadth_first_bt(hbtree, disp_node);
printf("\n------------------------------\n");
if (!delete_bt(hbtree, 70)) {
fprintf(stderr, "cannot find item!...\n");
exit(EXIT_FAILURE);
}
walk_breadth_first_bt(hbtree, disp_node);
printf("\n------------------------------\n");
printf("total item: %jd\n", count_bt(hbtree));
destroy_bt(hbtree);
return 0;
}
bool disp_node(int key, PERSON *value)
{
printf("%d ", key);
fflush(stdout);
return true;;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Biz yukarı ı ı ı
Dengelenmemiş ikili ağaçlarda eleman eklemenin ve aramanı ı ı
Örneğin ağaca aşağı ı ı
10, 20, 30, 40, 50, 60, 70, ...
Bu durumda ikili arama ağacı ı ı ı ı
edilmektedir. Dengelenmiş ağaçlarda ağaca her eleman eklendiğinde ve eleman silindiğinde ağacı ı ı
Pekiyi dengelenmiş ağaçlar nası ı ı ı
O(log N) karmaşı ı ı ı ı ı ı ı
kalması ı ı
önerilmiştir. En önemli iki dengeleme algoritması ı
Bu iki algoritma arası ı ı ı ı
AVL algoritması ı ı ı ı ı ı ı ı
Biz kursumunda ikili ağaçları ı ı
Uygulamaları
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi 3'lü, 4'lü 5'li gibi arama ağaçları ı ı ı
düğüme sahip olan ağaçlar bellek üzerindeki aramalarda (internal search) tercih edilmemektedir. Bunlar tipik olarak veritabanı
sistemleri (DBMS) tarafı ı ı ı ı
organize edilmektedir. İşte bu tür durumlarda düğüm üzerinde tek değer değil birden fazla değer tutulur. Örneğin 3'lü bir amarama ağacı
göstericilerden biri a değerinden küçük olan düğümü, diğeri a ile b arası
Böylece ağacı ı ı ı
ilgili kayda daha hı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Çok kullanı ı ı
geçen "heap" terimi ile bir ilgisi yoktur. Heap ağaçları ı ı ı ı
Öncelik kuyrukları ı ı ı ı ı
ya da sondaki eleman değil öncelik numarası ı ı
4 10 7 2 14 6 5
Kuyruğun başı ı
FIFO olsaydı ı ı ı ı ı
biz kuyruktan 14'ü alı ı ı ı
Öncelik kuyrukları ı ı ı ı ı
için kullanı ı
Heap ağaçları ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Heap ağaçları ı ı ı ı ı
uygulamada 2'li heap ağaçları ı
ağacı ı ı ı ı
Bir heap ağacı ı ı
1) Heap ağaçları ı ı
sahip olduğunu yaprakları ı ı ı
2) Heap ağacı ı
düğümlerinden daha yüksek değere sahipse böyle heap ağaçları
böyle heap ağaçları
100
50 70
30 40 60 35
17 24 32
Bu örnekteki ağaç yukarı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Heap ağacı ı
eklenen eleman kuralı ı ı ı
Bu işleme İngilizce "heapify" da denilmektedir. Örneğin yukarı
yaparı
100
50 70
30 40 60 35
17 24 32 75
Sonra bu 75 değeri üst düğümle karşı ı ı ı
100
50 70
30 75 60 35
17 24 32 40
Bu işlem devam ettirlir:
100
75 70
30 50 60 35
17 24 32 40
Artı ı ı ı ı ı ı
ağaçtan eleman alacaksak 100'ü alı ı ı ı
75
75 70
30 50 60 35
17 24 32 40
Tabii alt düğümün yerine onun alt düğümlerinden en büyük olan getirilir:
75
75 70
30 50 60 35
17 24 32 40
Böyle devam edilir:
75
50 70
30 75 60 35
17 24 32 40
Ta ki yapraklara iniline kadar:
75
50 70
30 40 60 35
17 24 32 75
Alı ı
Heap ağacı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı
diziye dönüştürürken dizinin 0'ı ı ı ı ı ı ı ı
Her zaman üst düğümün alt düğümleri üzet düğümün indeksinin iki katı ı ı ı
bakı ı
100
50 70
30 40 60 35
17 24 32 75
Bu heap ağacı ı ı ı
0 1 2 3 4 5 6 7 8 9 10 11
x 100 50 70 30 40 60 35 17 26 32 75
Burada örneğin 70 numaralı ı ı ı
ağaçları ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* hpqueue.h */
#ifndef PQUEUE_H_
#define PQUEUE_H_
#include <stddef.h>
#include <stdbool.h>
#define PQUEUE_DEF_CAPACITY 8
/* Type Declarartion */
typedef struct tagPERSON {
char name[32];
} PERSON;
typedef PERSON VALUETYPE;
typedef struct tagHEAP_ITEM {
int prio;
VALUETYPE value;
} HEAP_ITEM;
typedef struct PQUEUE {
HEAP_ITEM *hitems;
size_t capacity;
size_t count;
} PQUEUE, *HPQUEUE;
/* Function Prototypes */
HPQUEUE create_pq(void);
bool put_pq(HPQUEUE hpqueue, int prio, VALUETYPE *value);
bool get_pq(HPQUEUE hpqueue, int *prio, VALUETYPE *value);
bool resize_pq(HPQUEUE hpqueue, size_t new_capacity);
void destroy_pq(HPQUEUE hqueue);
/* inline Function Definitions */
static inline bool isempty_pq(HPQUEUE hpqueue)
{
return hpqueue->count == 0;
}
static inline void clear_pq(HPQUEUE hpqueue)
{
hpqueue->count = 0;
}
#endif
/* hpqueue.c */
#include <stdio.h>
#include <stdlib.h>
#include "pqueue.h"
HPQUEUE create_pq(void)
{
HPQUEUE hpqueue;
if ((hpqueue = (HPQUEUE)malloc(sizeof(PQUEUE))) == NULL)
return NULL;
if ((hpqueue->hitems = (HEAP_ITEM *)malloc(sizeof(HEAP_ITEM) * PQUEUE_DEF_CAPACITY)) == NULL) {
free(hpqueue);
return NULL;
}
hpqueue->capacity = PQUEUE_DEF_CAPACITY;
hpqueue->count = 0;
return hpqueue;
}
bool put_pq(HPQUEUE hpqueue, int prio, VALUETYPE *value)
{
size_t index;
if (hpqueue->count + 1 == hpqueue->capacity)
if (!resize_pq(hpqueue, hpqueue->capacity * 2))
return false;
index = hpqueue->count + 1;
while (index > 1 && prio > hpqueue->hitems[index / 2].prio) {
hpqueue->hitems[index] = hpqueue->hitems[index / 2];
index /= 2;
}
hpqueue->hitems[index].prio = prio;
hpqueue->hitems[index].value = *value;
++hpqueue->count;
return true;
}
bool get_pq(HPQUEUE hpqueue, int *prio, VALUETYPE *value)
{
size_t i, ci;
if (hpqueue->count == 0)
return false;
*prio = hpqueue->hitems[1].prio;
*value = hpqueue->hitems[1].value;
i = 1;
ci = 2;
while (ci <= hpqueue->count) {
if (ci + 1 < hpqueue->count && hpqueue->hitems[ci + 1].prio > hpqueue->hitems[ci].prio)
++ci;
if (hpqueue->hitems[hpqueue->count].prio > hpqueue->hitems[ci].prio)
break;
hpqueue->hitems[i] = hpqueue->hitems[ci];
i = ci;
ci *= 2;
}
hpqueue->hitems[i] = hpqueue->hitems[hpqueue->count];
--hpqueue->count;
return true;
}
bool resize_pq(HPQUEUE hpqueue, size_t new_capacity)
{
HEAP_ITEM *hitems;
if (new_capacity <= hpqueue->capacity)
return false;
if ((hitems = (HEAP_ITEM *)realloc(hpqueue->hitems, new_capacity * sizeof(HEAP_ITEM))) == NULL)
return false;
hpqueue->hitems = hitems;
hpqueue->capacity = new_capacity;
return true;
}
void destroy_pq(HPQUEUE hpqueue)
{
free(hpqueue->hitems);
free(hpqueue);
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include "pqueue.h"
void disp_pq(HPQUEUE hpqueue)
{
for (size_t i = 1; i <= hpqueue->count; ++i)
printf("%d ", hpqueue->hitems[i].prio);
printf("\n");
}
int main(void)
{
HPQUEUE hpqueue;
int prios[] = {100, 85, 90, 60, 70, 10, 40, -1};
VALUETYPE values[] = {{"Ali Serce"}, {"Sacit Bulut"}, {"Ayse Er"}, {"Necati Ergin"}, {"Guray Sonmez"},
{"Ziya Taskent"}, {"Gencay Coskun"}};
int prio;
VALUETYPE value;
if ((hpqueue = create_pq()) == NULL) {
fprintf(stderr, "cannot create priority queue!...\n");
exit(EXIT_FAILURE);
}
for (int i = 0; prios[i] != -1; ++i)
if (!put_pq(hpqueue, prios[i], &values[i])) {
fprintf(stderr, "cannot add item!..\n");
exit(EXIT_FAILURE);
}
disp_pq(hpqueue);
while (!isempty_pq(hpqueue)) {
if (!get_pq(hpqueue, &prio, &value)) {
fprintf(stderr, "cannot get value!..\n");
exit(EXIT_FAILURE);
}
printf("prio: %d, value: %s\n", prio, value.name);
disp_pq(hpqueue);
printf("----------------------\n");
}
destroy_pq(hpqueue);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Şimdiye kadar yaptı ı ı ı ı ı ı ı
veri yapı ı
oluşturmamaktadı ı ı ı ı ı ı
Örneğin bağlı ı ı ı ı
typedef int DATATYPE;
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *next;
} NODE;
typedef struct tagLLIST {
NODE head;
NODE *tail;
size_t count;
} LLIST, *HLLIST;
Burada biz birden fazla bağlı ı ı ı ı
DATATYPE türü int olarak typedef edilldiğine göre biz ne kadar bağlı ı ı ı
olacaktı ı ı ı ı ı
typedef struct tagPERSON {
char name[32];
int city;
} PERSON;
typedef struct tagNODE {
int key;
PERSON value;
struct tagNODE *left;
struct tagNODE *right;
} NODE;
typedef struct tagBTREE {
NODE *root;
size_t count;
} BTREE, *HBTREE;
Burada da biz birden fazla bağlı ı ı
olmak zorundadı ı ı ı ı
yani her türle çalı ı ı ı ı ı ı ı ı ı ı
hale getirebileceğiz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Türden bağı ı ı ı ı ı
1) void Gösterici Tekniği
2) Gömme Tekniği
void gösterici tekniği aslı ı ı ı
Bu nedenle programcı ı ı ı
bu teknik kullanı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
void gösterici tekniğinde veri yapı ı ı ı ı ı ı ı ı ı
yapı ı ı ı ı
artı ı ı ı ı
Bunun için gereken yapı
typedef struct tagNODE {
struct tagNODE *left;
struct tagNODE *right;
char key_value[];
} NODE;
typedef struct tagQNODE {
struct tagQNODE *next;
NODE *node;
} QNODE;
typedef struct tagBTREE {
NODE *root;
size_t count;
QNODE *head;
QNODE *tail;
size_t key_size;
size_t value_size;
bool (*compare)(const void *, const void *);
} BTREE, *HBTREE;
Burada tagNODE yapı ı ı ı
kullanı ı ı ı ı ı ı ı
Derleyici bu dizi için bir yer ayı ı ı
edilmesini sağlamaktı ı ı ı ı ı ı
fonksiyonunun adresinin bulundurulduğna dikkat ediniz. Biz ikili arama ağacı ı ı ı
Aşağı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* binarytree.h */
#ifndef BINARYTREE_H_
#define BINARYTREE_H_
#include <stddef.h>
#include <stdbool.h>
/* Type Declararions */
typedef struct tagNODE {
struct tagNODE *left;
struct tagNODE *right;
char key_value[];
} NODE;
typedef struct tagQNODE {
struct tagQNODE *next;
NODE *node;
} QNODE;
typedef struct tagBTREE {
NODE *root;
size_t count;
QNODE *head;
QNODE *tail;
size_t key_size;
size_t value_size;
int (*compare)(const void *, const void *);
} BTREE, *HBTREE;
/* Function Prototypes */
HBTREE create_bt(size_t key_size, size_t value_size, int (*compare)(const void *, const void *));
bool insert_item_bt(HBTREE hbtree, const void *key, const void *value);
bool walk_inorder_lr_bt(HBTREE hbtree, bool (*proc)(const void *, const void *));
bool walk_inorder_rl_bt(HBTREE hbtree, bool (*proc)(const void *, const void *));
bool walk_postorder_lr_bt(HBTREE hbtree, bool (*proc)(const void *, const void *));
bool walk_preorder_lr_bt(HBTREE hbtree, bool (*proc)(const void *, const void *));
bool walk_breadth_first_bt(HBTREE hbtree, bool (*proc)(const void *, const void *));
bool delete_bt(HBTREE hbtree, const void *key);
void clear_bt(HBTREE hbtree);
void destroy_bt(HBTREE hbtree);
/* inline Function Fefinitions */
static inline size_t count_bt(HBTREE hbtree)
{
return hbtree->count;
}
#endif
/* binarytree.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "binarytree.h"
static bool walk_inorder_lr_recur(NODE *node, size_t key_size, bool (*proc)(const void *, const void *));
static bool walk_inorder_rl_recur(NODE *node, size_t key_size, bool (*proc)(const void *, const void *));
static bool walk_postorder_lr_recur(NODE *node, size_t key_size, bool (*proc)(const void *, const void *));
static bool walk_preorder_lr_recur(NODE *node, size_t key_size, bool (*proc)(const void *, const void *));
static void create_queue(HBTREE hbtree);
static NODE *put_queue(HBTREE hbtree, NODE *node);
static NODE *get_queue(HBTREE hbtree);
static void destroy_queue(HBTREE hbtree);
static void subtree_shift(HBTREE hbtree, NODE *node1, NODE *node2, NODE *node3);
static void clear_recur(NODE *node);
HBTREE create_bt(size_t key_size, size_t value_size, int (*compare)(const void *, const void *))
{
HBTREE hbtree;
if ((hbtree = (HBTREE)malloc(sizeof(BTREE))) == NULL)
return NULL;
hbtree->root = NULL;
hbtree->count = 0;
hbtree->key_size = key_size;
hbtree->value_size = value_size;
hbtree->compare = compare;
return hbtree;
}
bool insert_item_bt(HBTREE hbtree, const void *key, const void *value)
{
NODE *new_node, *node, *parent_node = NULL;
int result;
if ((new_node = (NODE *)malloc(sizeof(NODE) + hbtree->key_size + hbtree->value_size)) == NULL)
return false;
memcpy(new_node->key_value, key, hbtree->key_size);
memcpy(new_node->key_value + hbtree->key_size, value, hbtree->value_size);
new_node->left = NULL;
new_node->right = NULL;
if (hbtree->root == NULL) {
hbtree->root = new_node;
++hbtree->count;
return true;
}
node = hbtree->root;
while (node != NULL) {
parent_node = node;
result = hbtree->compare(key, node->key_value);
if (result < 0)
node = node->left;
else if (result > 0)
node = node->right;
else {
memcpy(node->key_value + hbtree->key_size, value, hbtree->value_size);
return true;
}
}
if (hbtree->compare(key, parent_node->key_value) < 0)
parent_node->left = new_node;
else
parent_node->right = new_node;
++hbtree->count;
return true;
}
bool walk_inorder_lr_bt(HBTREE hbtree, bool (*proc)(const void *, const void *))
{
if (hbtree->root != NULL)
return walk_inorder_lr_recur(hbtree->root, hbtree->key_size, proc);
return true;
}
bool walk_inorder_rl_bt(HBTREE hbtree, bool (*proc)(const void *, const void *))
{
if (hbtree->root != NULL)
return walk_inorder_rl_recur(hbtree->root, hbtree->key_size, proc);
return true;
}
bool walk_postorder_lr_bt(HBTREE hbtree, bool (*proc)(const void *, const void *))
{
if (hbtree->root != NULL)
return walk_postorder_lr_recur(hbtree->root, hbtree->key_size, proc);
return true;
}
bool walk_preorder_lr_bt(HBTREE hbtree, bool (*proc)(const void *, const void *))
{
if (hbtree->root != NULL)
return walk_preorder_lr_recur(hbtree->root, hbtree->key_size, proc);
return true;
}
static bool walk_preorder_lr_recur(NODE *node, size_t key_size, bool (*proc)(const void *, const void *))
{
if (!proc(node->key_value, node->key_value + key_size))
return false;
if (node->left != NULL)
if (!walk_preorder_lr_recur(node->left, key_size, proc))
return false;
if (node->right != NULL)
if (!walk_preorder_lr_recur(node->right, key_size, proc))
return false;
return true;
}
bool walk_breadth_first_bt(HBTREE hbtree, bool (*proc)(const void *, const void *))
{
NODE *node;
bool result = true;
create_queue(hbtree);
put_queue(hbtree, hbtree->root);
while ((node = get_queue(hbtree)) != NULL) {
if (!proc(node->key_value, node->key_value + hbtree->key_size)) {
result = false;
break;
}
if (node->left != NULL)
if (put_queue(hbtree, node->left) == NULL) {
fprintf(stderr, "put_queue cannot allocate memory!..\n");
result = false;
break;
}
if (node->right != NULL)
if (put_queue(hbtree, node->right) == NULL) {
result = false;
fprintf(stderr, "put_queue cannot allocate memory!..\n");
break;
}
}
destroy_queue(hbtree);
return result;
}
static void create_queue(HBTREE hbtree)
{
hbtree->head = NULL;
hbtree->tail = NULL;
}
static NODE *put_queue(HBTREE hbtree, NODE *node)
{
QNODE *new_qnode;
if ((new_qnode = (QNODE *)malloc(sizeof(QNODE))) == NULL)
return NULL;
new_qnode->node = node;
new_qnode->next = NULL;
if (hbtree->tail != NULL)
hbtree->tail->next = new_qnode;
else
hbtree->head = new_qnode;
hbtree->tail = new_qnode;
return node;
}
static NODE *get_queue(HBTREE hbtree)
{
QNODE *qnode;
NODE *rnode;
if (hbtree->head == NULL)
return NULL;
qnode = hbtree->head;
hbtree->head = qnode->next;
if (hbtree->head == NULL)
hbtree->tail = NULL;
rnode = qnode->node;
free(qnode);
return rnode;
}
bool delete_bt(HBTREE hbtree, const void *key)
{
NODE *delete_node, *delete_parent_node, *replace_parent_node, *replace_node;
int result;
delete_node = hbtree->root;
delete_parent_node = NULL;
while (delete_node != NULL) {
result = hbtree->compare(key, delete_node->key_value);
if (result == 0)
break;
delete_parent_node = delete_node;
if (result < 0)
delete_node = delete_node->left;
else if (result > 0)
delete_node = delete_node->right;
}
if (delete_node == NULL)
return false;
if (delete_node->left == NULL)
subtree_shift(hbtree, delete_parent_node, delete_node, delete_node->right);
else if (delete_node->right == NULL)
subtree_shift(hbtree, delete_parent_node, delete_node, delete_node->left);
else {
replace_parent_node = delete_node;
replace_node = delete_node->right;
while (replace_node->left != NULL) {
replace_parent_node = replace_node;
replace_node = replace_node->left;
}
if (replace_parent_node != delete_node) {
subtree_shift(hbtree, replace_parent_node, replace_node, replace_node->right);
replace_node->right = delete_node->right;
}
subtree_shift(hbtree, delete_parent_node, delete_node, replace_node);
replace_node->left = delete_node->left;
}
free(delete_node);
--hbtree->count;
return true;
}
void clear_bt(HBTREE hbtree)
{
if (hbtree->root != NULL) {
clear_recur(hbtree->root);
hbtree->root = NULL;
hbtree->count = 0;
}
}
void destroy_bt(HBTREE hbtree)
{
if (hbtree->root != NULL)
clear_recur(hbtree->root);
free(hbtree);
}
static bool walk_inorder_lr_recur(NODE *node, size_t key_size, bool (*proc)(const void *, const void *))
{
if (node->left != NULL)
if (!walk_inorder_lr_recur(node->left, key_size, proc))
return false;
if (!proc(node->key_value, node->key_value + key_size))
return false;
if (node->right != NULL)
if (!walk_inorder_lr_recur(node->right, key_size, proc))
return false;
return true;
}
static bool walk_inorder_rl_recur(NODE *node, size_t key_size, bool (*proc)(const void *, const void *))
{
if (node->right != NULL)
if (!walk_inorder_rl_recur(node->right, key_size, proc))
return false;
if (!proc(node->key_value, node->key_value + key_size))
return false;
if (node->left != NULL)
if (!walk_inorder_rl_recur(node->left, key_size, proc))
return false;
return true;
}
static bool walk_postorder_lr_recur(NODE *node, size_t key_size, bool (*proc)(const void *, const void *))
{
if (node->left != NULL)
if (!walk_postorder_lr_recur(node->left, key_size, proc))
return false;
if (node->right != NULL)
if (!walk_postorder_lr_recur(node->right, key_size, proc))
return false;
if (!proc(node->key_value, node->key_value + key_size))
return false;
return true;
}
static void destroy_queue(HBTREE hbtree)
{
QNODE *qnode, *temp_qnode;
qnode = hbtree->head;
while (qnode != NULL) {
temp_qnode = qnode->next;
free(qnode);
qnode = temp_qnode;
}
}
static void subtree_shift(HBTREE hbtree, NODE *node1, NODE *node2, NODE *node3)
{
if (node1 == NULL)
hbtree->root = node3;
else if (node1->left == node2)
node1->left = node3;
else
node1->right = node3;
}
static void clear_recur(NODE *node)
{
if (node->left != NULL)
clear_recur(node->left);
if (node->right != NULL)
clear_recur(node->right);
free(node);
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include "binarytree.h"
typedef struct tagPERSON {
char name[32];
int no;
} PERSON;
bool disp_node(const void *key, const void *value);
int comp_person(const void *key1, const void *key2);
int main(void)
{
HBTREE hbtree;
PERSON per = {"Noname", 0};
int keys[] = {70, 50, 34, 56, 19, 80, 67, 43, 27, 76, 79, 105, 82, 65, 0};
int del_key = 70;
if ((hbtree = create_bt(sizeof(int), sizeof(PERSON), comp_person)) == NULL) {
fprintf(stderr, "cannot create binary tree!..\n");
exit(EXIT_FAILURE);
}
for (int i = 0; keys[i] != 0; ++i)
if (!insert_item_bt(hbtree, &keys[i], &per)) {
fprintf(stderr, "cannot insert item: %d\n", keys[i]);
exit(EXIT_FAILURE);
}
walk_inorder_lr_bt(hbtree, disp_node);
printf("\n------------------------------\n");
walk_inorder_rl_bt(hbtree, disp_node);
printf("\n------------------------------\n");
walk_postorder_lr_bt(hbtree, disp_node);
printf("\n------------------------------\n");
walk_preorder_lr_bt(hbtree, disp_node);
printf("\n------------------------------\n");
walk_breadth_first_bt(hbtree, disp_node);
printf("\n------------------------------\n");
if (!delete_bt(hbtree, &del_key)) {
fprintf(stderr, "cannot find item!...\n");
exit(EXIT_FAILURE);
}
walk_breadth_first_bt(hbtree, disp_node);
destroy_bt(hbtree);
return 0;
}
bool disp_node(const void *key, const void *value)
{
const int *ikey = (const int *)key;
printf("%d ", *ikey);
fflush(stdout);
return true;
}
int comp_person(const void *key1, const void *key2)
{
const int *ikey1 = (const int *)key1;
const int *ikey2 = (const int *)key2;
if (*ikey1 > *ikey2)
return 1;
if (*ikey1 < *ikey2)
return -1;
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Genelleştirmede void gösterici tekniği yerine gömme tekniğinin tercih edildiğini belirtmiştik. Bu tekniği açı ı ı
amacı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
C'nin <stddef.h> içerisinde bildirilmiş olan offsetof makrosu yapı ı ı ı
o elemanı ı ı ı ı ı
struct SAMPLE {
int a;
int b;
char c[32];
char d;
int e;
};
size_t result;
result = offsetof(struct SAMPLE, e);
Burada yapı ı ı ı ı ı ı ı
gibi olacaktı
struct SAMPLE {
int a; /* 0 */
int b; /* 4 */
char c[32]; /* 8 */
char d; /* 40 */
int e; /* 44 */
};
İşte offsetof makrosu bir yapı ı ı ı ı ı ı ı
size_t türündne bir değer vermektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stddef.h>
struct SAMPLE {
int a;
int b;
char c[32];
char d;
int e;
};
int main(void)
{
size_t result;
result = offsetof(struct SAMPLE, e);
printf("%zd\n", result); /* 44 */
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
offsetof makrosu tipik olarak aşağı ı ı
#define myoffsetof(type, member) ((size_t)&((type *)0)->member)
Burada 0 adresi önce ilgili yapı
anlamı ı ı ı ı
alı ı ı ı ı ı ı
dönüştürülmüştür. Yukarı ı ı ı ı ı ı
Çünkü burada standartlara göre gerçek bir erişim yapı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#define myoffsetof(type, member) ((size_t)&((type *)0)->member)
struct SAMPLE {
int a;
int b;
char c[32];
char d;
int e;
};
int main(void)
{
size_t result;
result = myoffsetof(struct SAMPLE, e);
printf("%zd\n", result); /* 44 */
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir yapı ı ı ı ı ı ı
ilişkin yapı ı
#define container_of(ptr, type, member) ((type *) ((char *) (ptr) - offsetof(type, member)))
Makronun birinci parametresi nesne içerisindeki elemanı ı ı ı
ismini almaktadı ı ı
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stddef.h>
#define container_of(ptr, type, member) ((type *) ((char *) (ptr) - offsetof(type, member)))
struct SAMPLE {
int a;
char b;
int c;
char d;
double e;
int f;
};
int main(void)
{
struct SAMPLE s = { 10, 'x', 20, 'y', 12.4, 100 };
double *pd = &s.e;
struct SAMPLE *ps;
ps = container_of(pd, struct SAMPLE, e);
printf("%d, %f\n", ps->a, ps->e);
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Gömme yöntemiyle veri yapı ı ı ı ı ı ı ı ı
listenin türden bağı ı ı
düğümleri birbirine bağlayacaktı ı ı ı ı
typedef struct tagNODE {
struct tagNODE *next;
struct tagNODE *prev;
} NODE;
Görüldüğü gibi burada NODE yapı ı ı ı
Örneğin:
head_node <---> node <----> node <---> node <---> ....
Pekiyi bağlı ı ı ı ı ı
başka bir yapı ı ı
struct PERSON {
char name[32];
int no;
NODE link;
};
Görüldüğü gibi PERSON yapı ı ı ı ı ı ı ı ı
ancak bu düğümler de ilgili türden nesnelerin elemanı ı ı ı ı ı ı ı
nesnesinin başlangı ı
Bu yöntemde bir yapı ı
eden task_struct yapı ı ı ı ı ı ı ı
Örneğin:
struct PERSON {
char name[32];
int no;
NODE link1;
NODE link2;
};
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı
create_llist gibi bir fonksiyonla yaratı ı ı ı ı ı
uygun bir yöntem olmayabilir. Ancak biz aşağı
aynı ı ı ı ı
kullanı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* llist.h */
#ifndef LLIST_H_
#define LLIST_H_
#include <stddef.h>
#include <stdbool.h>
/* Type Declarations */
typedef struct tagNODE {
struct tagNODE *next;
struct tagNODE *prev;
} NODE;
typedef struct tagLLIST {
NODE head;
size_t count;
} LLIST, *HLLIST;
/* Function Prototypes */
HLLIST create_llist(void);
NODE *insert_next(HLLIST hllist, NODE *node, NODE *new_node);
NODE *insert_prev(HLLIST hllist, NODE *node, NODE *new_node);
NODE *add_tail(HLLIST hllist, NODE *new_node);
NODE *add_head(HLLIST hllist, NODE *new_node);
void remove_node(HLLIST hllist, NODE *node);
NODE *getp_item(HLLIST hllist, size_t index);
bool walk_llist(HLLIST hllist, bool (*proc)(NODE *));
bool walk_llist_rev(HLLIST hllist, bool (*proc)(NODE *));
void clear_llist(HLLIST hllist);
void destroy_llist(HLLIST hllist);
/* inline Function Definitions */
static inline size_t count_llist(HLLIST hllist)
{
return hllist->count;
}
static inline NODE *head_llist(HLLIST hllist)
{
return hllist->head.next;
}
static inline NODE *tail__llist(HLLIST hllist)
{
return hllist->head.prev;
}
/* Macro Definitions */
#define container_of(ptr, type, member) ((type *) ((char *) (ptr) - offsetof(type, member)))
#define FOR_EACH(hllist, node) for (node = (hllist)->head.next; node != &(hllist)->head; node = node->next)
#define FOR_EACH_REV(hllist, node) for (node = (hllist)->head.prev; node != &(hllist)->head; node = node->prev)
#define FREE_LLIST(hllist, node) for (NODE *tnode = (hllist)->head.next; node = tnode, tnode = tnode->next, node != &(hllist)->head; )
#endif
/* llist.c */
#include <stdio.h>
#include <stdlib.h>
#include "llist.h"
/* Function Definitions */
HLLIST create_llist(void)
{
HLLIST hllist;
if ((hllist = (HLLIST)malloc(sizeof(LLIST))) == NULL)
return NULL;
hllist->head.next = &hllist->head;
hllist->head.prev = &hllist->head;
hllist->count = 0;
return hllist;
}
NODE *insert_next(HLLIST hllist, NODE *node, NODE *new_node)
{
node->next->prev = new_node;
new_node->next = node->next;
node->next = new_node;
new_node->prev = node;
++hllist->count;
return new_node;
}
NODE *insert_prev(HLLIST hllist, NODE *node, NODE *new_node)
{
node->prev->next = new_node;
new_node->next = node;
new_node->prev = node->prev;
node->prev = new_node;
++hllist->count;
return new_node;
}
NODE *add_tail(HLLIST hllist, NODE *new_node)
{
return insert_prev(hllist, &hllist->head, new_node);
}
NODE *add_head(HLLIST hllist, NODE *new_node)
{
return insert_next(hllist, &hllist->head, new_node);
}
void remove_node(HLLIST hllist, NODE *node)
{
node->prev->next = node->next;
node->next->prev = node->prev;
--hllist->count;
}
NODE *getp_item(HLLIST hllist, size_t index)
{
NODE *node;
if (index >= hllist->count)
return NULL;
node = hllist->head.next;
for (size_t i = 0; i < index; ++i)
node = node->next;
return node;
}
bool walk_llist(HLLIST hllist, bool (*proc)(NODE *))
{
for (NODE *node = hllist->head.next; node != &hllist->head; node = node->next)
if (!proc(node))
return false;
return true;
}
bool walk_llist_rev(HLLIST hllist, bool (*proc)(NODE *))
{
for (NODE *node = hllist->head.prev; node != &hllist->head; node = node->prev)
if (!proc(node))
return false;
return true;
}
void clear_llist(HLLIST hllist)
{
hllist->head.next = &hllist->head;
hllist->head.prev = &hllist->head;
hllist->count = 0;
}
void destroy_llist(HLLIST hllist)
{
free(hllist);
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include "llist.h"
typedef struct tagPERSON {
char name[32];
int no;
NODE link;
} PERSON;
bool disp_person(NODE *node);
int main(void)
{
HLLIST hllist;
PERSON *per;
NODE *node;
if ((hllist = create_llist()) == NULL) {
fprintf(stderr, "cannot create linked list...\n");
exit(EXIT_FAILURE);
}
for (int i = 0; i < 100; ++i) {
if ((per = (PERSON *)malloc(sizeof(PERSON))) == NULL) {
fprintf(stderr, "ccano tallocate memory!..\n");
exit(EXIT_FAILURE);
}
per->no = i;
per->name[0] = '\0';
add_tail(hllist, &per->link);
}
walk_llist(hllist, disp_person);
printf("\n--------------------\n");
FOR_EACH (hllist, node) {
per = container_of(node, PERSON, link);
printf("%d ", per->no);
fflush(stdout);
}
printf("\n--------------------\n");
FOR_EACH_REV (hllist, node) {
per = container_of(node, PERSON, link);
printf("%d ", per->no);
fflush(stdout);
}
FREE_LLIST(hllist, node) {
per = container_of(node, PERSON, link);
free(per);
}
return 0;
}
bool disp_person(NODE *node)
{
PERSON *per;
per = container_of(node, PERSON, link);
printf("%d ", per->no);
fflush(stdout);
return true;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
En sı ı ı ı ı ı ı
İngilizce "vertex" ya da "node" denilmektedir. Düğüm arası ı ı
Aslı ı ı ı ı ı ı ı
düğüm kök yapı ı ı ı
aslı ı ı ı
gelinebilmektedir. Graph veri yapı ı ı ı ı ı
tanı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Graph'lar konusunda çalı
Yönlü ve Yönsüz Graflar (Directed and Undirected): Eğer düğümler arası
denilmektedir. Düğümler arası ı
graflar iki yönlü graflar gibi de düşünülebilir. Örneğin kara yolları
edilebilir.
Döngüsel Olan (Cyclic) ve Döngüsel Olmayan (Acyclic) Graflar: Bir grafta bir düğümden başlanarak aynı
bu tür graflara döngüsel graflar denilmektedir. Döngüsel graflarda her düğüm için kendine gelen bir yol olması
düğümden kendisine gelen herhangi bir yol varsa bu grafı ı ı
bir terimdir. İngilizce buna "directed acyclic grapg (DAG)" da denilmektedir.
Yol (Path): Bir grafta bir düğümden diğerine varabilmek için geçilen kenarları ı ı
Tur (Cycle): Bir yolun ilk ve son düğümü aynı ı ı ı ı
Tuları ı
Bağlantı ı ı ı ı
graphs)" denilmektedir. Graflardaki düğümleri bilye, kenarları ı ı ı
bilyeyi tutup yukarı ı ı ı ı ı
Öz döngülü (self-loop) Graflar: Eğer graflarda kendindne kendine bir kenar tanı
graphs) denilmektedir. Genellikle gragflar öz döngülü olmazlar.
Alt Graflar (Subgraphs): Bir grafı
Tam Graflar (Complete Graphs): Bir yönsüz grafta her düğümden her düğüme bir kenar varsa bu tür graflara "tam graflar (complete graphs)"
denilmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Graflarla çalı ı ı ı ı
kullanı ı
1) Komşuluk Matrisi (Adjacency-Matrix) Yöntemi
2) Komşuluk Listeleri (Adjacency-Lists) Yöntemi
Komşuluk matrisi yönteminde düğümlerden bir kare matris oluşturulur. Matrisin elemanları
düğüm arası ı ı ı
A B C D
A 0 1 0 1
B 0 0 1 1
C 1 1 0 0
D 0 1 1 0
Burada örneğin C'den C'ye kenar yoktur, ancak C'den D'ye kenar vardı
gibi) bu durumda matrisin elemanları ı
yol yoksa matrisin ilgili elemanı ı
ediniz.
Komşuluk listeleri yönteminde her düğümün bir listesi vardı
dinamik büyütülen bir dizi olabilir ya da bağlı ı ı ı
A: B, C
B: C, D
C: A, B
D: B, C
BUrada eğer yollara bilgiler iliştirilecekse listenin elemanları ı
Pekiyi hangi temsil daha iyidir? Aslı ı ı ı
iliştirilen bilgiye O(1) karmaşı ı ı ı ı ı
bu yöntemde her düğüm için bir hash tablosu ya da ikili arama ağacı ı
tercih edilmektedir.
Bu temsillerde düğümlerin nası ı
en etkin yöntem düğümlere isim değil numara vermektir. Tabii numaradan isim elde edilebilir ya da isimden numara alde edilebilir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Graflarlar üzerinde algoritmalar için değişik graf kütüphaneleri oluşturulmuştur. En yaygı ı
Graf Kütüphanesi (Boost Graph Library (BGL))" denilen kütüphanedir. Bu kütüphanede düğümler ve kenarlar sı ı
Graf Kütüphanesi pek çok graf kütüphanesine de ilham kaynağı
geliştirilmiştir. C için yaygı ı ı
Kütüphanenin kaynak kodları ı
https://igraph.org/
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı ı ı
Bu yöntemin türden bağı ı ı ı
Gerçekleştiririmizde DGRAPH nesnesi VERTEX nesnelerini, VERTEX nesneleri de EDGE nesnelerini tutacaktı
her vertex'in o vertex'ten gidilebilecek vertex'leri tuttuğunu belirtmiştik. Ancak biz burada bir vertex'ten gidilecek vertex'leri değil
gidilecek vertex'lere ilişkin kenar nesnelerini tutacağı ı ı
typedef struct tagDGRAPH{
VERTEX **vertices;
size_t count;
size_t capacity;
} DGRAPH;
Görüldüğü gibi burada graf veri yapı ı ı
VERTEX nesnelerinin adreslerinin değişmemesinin sağlanması ı ı ı ı
ise gösterici dizisi için ayrı ı ı ı
typedef struct tagVERTEX {
EDGE **edges;
size_t count;
size_t capacity;
/* VERTEX INFO */
char name[32];
} VERTEX;
Görüldüğü gibi VERTEX nesneleri EDGE nesnelerinin adreslerini tutmaktadı ı ı ı
dizi için tahsis edilen toplam alan ise capacity elemanı ı
vertex'lere başka bilgiler de iliştirebilirsiniz. EDGE yapı ı
typedef struct tagEDGE {
VERTEX *v1;
VERTEX *v2;
/* EDGE INFO */
int length;
} EDGE;
Görüldüğü gibi bir EDGE nesnesi başlangı ı
iliştirilmiştir. Tabi başka bilgiler de iliştirilebilir. Bu tasarı
dizi ile, vertex'lerin tuttuğu kenarları ı ı
kullanı
Graf veri yapı ı ı ı ı ı
vardı ı ı ı
tüm düğümlerinin dolaşı ı ı ı ı ı
fonksiyon kendini çağı ı ı
gerekir. Bunu engellemenin tipik yolu her ziyaret edilen düğümün ziyaret edildiğini bir yerde tutmak ve eğer düğüm daha önce ziyaret
edilmişse onu yeniden ziyaret etmemektir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Graf veri yapı ı ı ı
tanı ı ı ı ı ı
- Grafı ı ı
- Grafta iki düğüm arası ı
- Grafta iki düğüm arası ı
- En küçük örten ağaç problemi (minimum spanning tree)
- Gezgin satı ı
- Maximum akı
- Graf boyama problemi (graph coloring problem)
- Graf çizdirme problemi (graph drawing problem)
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı ı ı ı ı
çözecek algoritmaları
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* graph.h */
#ifndef GRAPH_H_
#define GRAPH_H_
#include <stddef.h>
#include <stdbool.h>
/* Symbolic Constants */
#define DEF_VERTEX_CAPACITY 4
#define DEF_EDGE_CAPACITY 4
#define MAX_CSV_LINE_LENGTH 1024
/* Type Declarations */
typedef struct tagEDGE {
struct tagVERTEX *v1;
struct tagVERTEX *v2;
/* EDGE INFO */
double length;
} EDGE;
typedef struct tagVERTEX {
EDGE **edges;
size_t count;
size_t capacity;
size_t index;
/* VERTEX INFO */
char name[32];
} VERTEX;
typedef struct tagDGRAPH{
VERTEX **vertices;
size_t count;
size_t capacity;
size_t ecount;
} DGRAPH, *HDGRAPH;
/* Function Prototypes */
HDGRAPH create_dgraph(void);
VERTEX *add_vertex(HDGRAPH hdgraph, VERTEX *vertex);
VERTEX *add_vertex_info(HDGRAPH hdgraph, const char *name);
EDGE *add_edge(HDGRAPH hdgraph, VERTEX *v1, VERTEX *v2, double length);
EDGE *add_edge_info(HDGRAPH hdgraph, const char *name1, const char *name2, double length);
DGRAPH *build_graph(const char *path);
bool traverse_depth_first_vertex(HDGRAPH hdgraph, VERTEX *vertex, bool (*proc)(VERTEX *));
bool traverse_depth_first_name(HDGRAPH hdgraph, const char *name, bool (*proc)(VERTEX *));
void clear_dgraph(HDGRAPH hdgraph);
void destroy_dgraph(HDGRAPH hdgraph);
/* inline Funcrion Definitions */
static inline size_t vertex_count(HDGRAPH hdgraph)
{
return hdgraph->count;
}
#endif
/* graph.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "graph.h"
static VERTEX *find_vertex_name(HDGRAPH hdgraph, const char *name);
static EDGE *create_edge(VERTEX *v1, VERTEX *v2, double length);
static VERTEX *create_vertex(const char *name);
static bool traverse_depth_first_vertex_recur(VERTEX *vertex, int *visiteds, bool (*proc)(VERTEX *));
HDGRAPH create_dgraph(void)
{
HDGRAPH hdgraph;
if ((hdgraph = (HDGRAPH)malloc(sizeof(DGRAPH))) == NULL)
return NULL;
if ((hdgraph->vertices = (VERTEX **)malloc(DEF_VERTEX_CAPACITY * sizeof(VERTEX *))) == NULL) {
free(hdgraph);
return NULL;
}
hdgraph->count = 0;
hdgraph->capacity = DEF_VERTEX_CAPACITY;
hdgraph->ecount = 0;
return hdgraph;
}
VERTEX *add_vertex(HDGRAPH hdgraph, VERTEX *vertex)
{
VERTEX **new_vertices;
if (find_vertex_name(hdgraph, vertex->name) != NULL)
return NULL;
if (hdgraph->count == hdgraph->capacity) {
if ((new_vertices = realloc(hdgraph->vertices, hdgraph->capacity * sizeof(VERTEX *) * 2)) == NULL)
return NULL;
hdgraph->vertices = new_vertices;
hdgraph->capacity *= 2;
}
vertex->index = hdgraph->count;
hdgraph->vertices[hdgraph->count] = vertex;
++hdgraph->count;
return vertex;
}
VERTEX *add_vertex_info(HDGRAPH hdgraph, const char *name)
{
VERTEX *vertex;
VERTEX **new_vertices;
if (find_vertex_name(hdgraph, name) != NULL)
return NULL;
if ((vertex = create_vertex(name)) == NULL)
return NULL;
if (hdgraph->count == hdgraph->capacity) {
if ((new_vertices = realloc(hdgraph->vertices, hdgraph->capacity * sizeof(VERTEX *) * 2)) == NULL)
return NULL;
hdgraph->vertices = new_vertices;
hdgraph->capacity *= 2;
}
vertex->index = hdgraph->count;
hdgraph->vertices[hdgraph->count] = vertex;
++hdgraph->count;
return vertex;
}
EDGE *add_edge(HDGRAPH hdgraph, VERTEX *v1, VERTEX *v2, double length)
{
EDGE *edge;
EDGE **new_edges;
if ((edge = create_edge(v1, v2, length)) == NULL)
return NULL;
if (v1->count == v1->capacity) {
if ((new_edges = realloc(v1->edges, v1->capacity * 2 * sizeof(EDGE *))) == NULL) {
free(edge);
return NULL;
}
v1->capacity *= 2;
}
v1->edges[v1->count] = edge;
++v1->count;
++hdgraph->ecount;
return edge;
}
EDGE *add_edge_info(HDGRAPH hdgraph, const char *name1, const char *name2, double length)
{
VERTEX *v1, *v2;
EDGE *edge;
if ((v1 = find_vertex_name(hdgraph, name1)) == NULL) {
if ((v1 = create_vertex(name1)) == NULL)
return NULL;
if (add_vertex(hdgraph, v1) == NULL)
goto EXIT1;
}
if ((v2 = find_vertex_name(hdgraph, name2)) == NULL) {
if ((v2 = create_vertex(name2)) == NULL)
goto EXIT1;
if (add_vertex(hdgraph, v2) == NULL)
goto EXIT2;
}
if ((edge = add_edge(hdgraph, v1, v2, length)) == NULL)
goto EXIT2;
return edge;
EXIT2:
free(v2);
EXIT1:
free(v1);
return NULL;
}
DGRAPH *build_graph(const char *path)
{
FILE *f;
HDGRAPH hdgraph;
char buf[MAX_CSV_LINE_LENGTH + 2];
const char *name1, *name2, *length;
char *str;
if ((f = fopen(path, "r")) == NULL)
goto EXIT1;
if ((hdgraph = create_dgraph()) == NULL)
goto EXIT2;
while (fgets(buf, MAX_CSV_LINE_LENGTH + 2, f) != NULL) {
if ((name1 = strtok(buf, ",\n")) == NULL)
continue;
if ((name2 = strtok(NULL, ",\n")) == NULL)
goto EXIT3;
if ((length = strtok(NULL, ",\n")) == NULL)
goto EXIT3;
if (strtok(NULL, ",\n") != NULL)
goto EXIT3;
if (add_edge_info(hdgraph, name1, name2, atof(length)) == NULL)
goto EXIT3;
}
return hdgraph;
EXIT3:
destroy_dgraph(hdgraph);
EXIT2:
fclose(f);
EXIT1:
return NULL;
}
bool traverse_depth_first_vertex(HDGRAPH hdgraph, VERTEX *vertex, bool (*proc)(VERTEX *))
{
int *visiteds;
bool result;
if (!proc(vertex))
return false;
if ((visiteds = (int *)calloc(hdgraph->count, sizeof(int))) == NULL)
return false;
result = traverse_depth_first_vertex_recur(vertex, visiteds, proc);
free(visiteds);
return result;
}
bool traverse_depth_first_name(HDGRAPH hdgraph, const char *name, bool (*proc)(VERTEX *))
{
VERTEX *vertex;
if ((vertex = find_vertex_name(hdgraph, name)) == NULL)
return false;
return traverse_depth_first_vertex(hdgraph, vertex, proc);
}
void clear_dgraph(HDGRAPH hdgraph)
{
for (size_t v = 0; v < hdgraph->count; ++v) {
for (size_t e = 0; e < hdgraph->vertices[v]->count; ++e)
free(hdgraph->vertices[v]->edges[e]);
hdgraph->vertices[v]->count = 0;
free(hdgraph->vertices[v]);
}
hdgraph->count = 0;
}
void destroy_dgraph(HDGRAPH hdgraph)
{
for (size_t v = 0; v < hdgraph->count; ++v) {
for (size_t e = 0; e < hdgraph->vertices[v]->count; ++e)
free(hdgraph->vertices[v]->edges[e]);
free(hdgraph->vertices[v]->edges);
}
free(hdgraph->vertices);
free(hdgraph);
}
static VERTEX *create_vertex(const char *name)
{
VERTEX *vertex;
if ((vertex = (VERTEX *)malloc(sizeof(VERTEX))) == NULL)
return NULL;
if ((vertex->edges = (EDGE **)malloc(DEF_EDGE_CAPACITY * sizeof(EDGE *))) == NULL) {
free(vertex);
return NULL;
}
vertex->count = 0;
vertex->capacity = DEF_EDGE_CAPACITY;
strcpy(vertex->name, name);
return vertex;
}
static VERTEX *find_vertex_name(HDGRAPH hdgraph, const char *name)
{
for (size_t i = 0; i < hdgraph->count; ++i)
if (!strcmp(name, hdgraph->vertices[i]->name))
return hdgraph->vertices[i];
return NULL;
}
static EDGE *create_edge(VERTEX *v1, VERTEX *v2, double length)
{
EDGE *edge;
if ((edge = (EDGE *)malloc(sizeof(EDGE))) == NULL)
return NULL;
edge->v1 = v1;
edge->v2 = v2;
edge->length = length;
return edge;
}
static bool traverse_depth_first_vertex_recur(VERTEX *vertex, int *visiteds, bool (*proc)(VERTEX *))
{
VERTEX *v;
visiteds[vertex->index] = 1;
for (size_t e = 0; e < vertex->count; ++e) {
v = vertex->edges[e]->v2;
if (visiteds[v->index])
continue;
if (!proc(v))
return false;
if (!traverse_depth_first_vertex_recur(v, visiteds, proc))
return false;
}
return true;
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "graph.h"
void err_exit(const char *msg);
bool disp_vertex(VERTEX *v);
int main(void)
{
HDGRAPH hdgraph;
if ((hdgraph = build_graph("graph.csv")) == NULL) {
fprintf(stderr, "cannot build graph!..\n");
exit(EXIT_FAILURE);
}
traverse_depth_first_name(hdgraph, "A", disp_vertex);
destroy_dgraph(hdgraph);
return 0;
}
void err_exit(const char *msg)
{
fprintf(stderr, "%s\n", msg);
exit(EXIT_FAILURE);
}
bool disp_vertex(VERTEX *v)
{
printf("%s\n", v->name);
return true;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Graph çizdirmek için en fazla kullanı ı ı
ismine "dot dili (dot language)" bir dilde betimlenir. Sonra "dot" isimli programa bu dosya girdi olarak verilir. Bu program da bu girdi
dosyası ı ı ı ı ı ı ı ı
kurmamı ı ı
https://graphviz.org/download/
Graphviz'de bir graf çizmek için grafı ı ı
Örneğin:
digraph G {
size="30, 40!"
A -> B
B -> D
B -> C
C -> A
D -> C
D -> E
E -> D
E -> F
F -> C
C -> F
G -> F
C -> G
C -> E
D -> H
H -> I
I -> D
}
Buradaki size ibaresi inch cinsinden grafin genişlik ve yülksekliğiniş belirtmektedir. Satı ı ı
label eklenebilir. Bu durumda belirtilen yazı ı ı
digraph G {
A -> B [label="10"]
B -> D [label="7"]
B -> C [label="15"]
C -> A [label="5"]
D -> C [label="20"]
D -> E [label="18"]
E -> D [label="18"]
E -> F [label="19"]
F -> C [label="16"]
C -> F [label="16"]
G -> F [label="11"]
C -> G [label="25"]
C -> E [label="12"]
D -> H [label="11"]
H -> I [label="9"]
I -> D [label="20"]
}
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
77. Ders 24/03/2024 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı ı
çalı ı ı ı ı ı
örnek "graph.csv" dosyası
A,B,10
B,D,7
B,C,15
C,A,5
D,C,20
D,E,18
E,D,18
E,F,19
F,C,16
C,F,16
G,F,11
C,G,25
C,E,12
D,H,11
H,I,9
I,D,20
A,I,40
I,J,11
J,D,21
D,A,17
F,H,30
G,J,40
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* graphmake.c */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <windows.h>
#define MAX_LINE_LEN 4096
void ExitSys(LPCSTR lpszMsg);
bool csv2dot(const char *path_csv, const char *path_dot)
{
FILE *f_csv, *f_dot;
char buf[MAX_LINE_LEN];
char *name1, *name2, *length;
bool retval = false;
if ((f_csv = fopen(path_csv, "r")) == NULL)
return false;
if ((f_dot = fopen(path_dot, "w")) == NULL)
goto EXIT1;
if (fprintf(f_dot, "digraph G {\n") < 0)
goto EXIT2;
while (fgets(buf, MAX_LINE_LEN, f_csv) != NULL) {
if ((name1 = strtok(buf, ",\n")) == NULL)
continue;
if ((name2 = strtok(NULL, ",\n")) == NULL)
goto EXIT2;
if ((length = strtok(NULL, ",\n")) == NULL)
goto EXIT2;
if (strtok(NULL, ",\n") != NULL)
goto EXIT2;
if (fprintf(f_dot, "\t%s -> %s [label=\"%s\"]\n", name1, name2, length) < 0)
goto EXIT2;
}
if (fprintf(f_dot, "}\n") < 0)
goto EXIT2;
retval = true;
EXIT2:
fclose(f_dot);
EXIT1:
fclose(f_csv);
return retval;
}
bool dot2png(const char *path_dot, char *path_png)
{
char cmdline[4096];
STARTUPINFO si = {sizeof(si)};
PROCESS_INFORMATION pi;
bool result;
sprintf(cmdline, "dot -Tpng %s -o %s", path_dot, path_png);
result = CreateProcess(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
CloseHandle(pi.hThread);
CloseHandle(pi.hProcess);
return result;
}
int main(void)
{
HINSTANCE hResult;
if (!csv2dot("graph.csv", "test.dot")) {
fprintf(stderr, "cannot generate dot file!..\n");
exit(EXIT_FAILURE);
}
if (!dot2png("test.dot", "test.png")) {
fprintf(stderr, "cannot generate png file!..\n");
exit(EXIT_FAILURE);
}
hResult = ShellExecute(NULL, "open", "test.png", NULL, NULL, SW_NORMAL);
if ((INT_PTR)hResult < 32)
ExitSys("ShellExecute");
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Kursumuzun bu bölümünde thread kavramı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir prosesin bağı ı ı ı ı ı
Akı ı ı ı ı
Thread'ler proseslerin akı ı ı ı
sahip olabileceği gibi birden fazla akı ı ı ı ı
sokulmuştur. Bugün artı ı ı ı ı
Windows 95 ile thread'li çalı ı ı ı ı
eklenmiştir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
İşletim sistemlerinde prosesler çalı ı ı ı ı ı ı
Prosesin bu thread'ine "ana thread (main thread)" denilmektedir. Prosesin diğer thread'leri program çalı ı ı
ya da bunları ı ı ı ı ı ı
programcı ı ı ı ı ı ı ı ı ı ı ı
Windows sistemlerinde thread'ler Windows API fonksiyonlaı ı ı ı
idare edilmektedir. Bazı ı ı ı ı ı ı
Tabii burada platform bağı ı ı ı ı ı ı
çağı ı
hep aynı ı ı ı
POSIX fonksiyonları ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi thread'lere neden gereksinim duyulmaktadı ı
1) Thread'ler arkaplan işlemlerin yapı ı ı
birtakı ı ı
eklenenince bu işlemleri yapmak çok kolaylaştı
o thread'e havale edebiliriz.
2) Thread'ler programları ı ı ı ı ı ı ı ı ı
Sistemimizde tek bir işlemci olsa bile bizim prosesimiz diğer proseslere göre daha fazla CPU zamanı
3) Thread'ler blokeye yol açan durumlarda işlemlerin devam ettirilmesini sağlayabilmektedir. Çünkü işletim sistemleri thread temelinde
bloke uygulamaktadı ı ı ı ı
edecektir. Bu durum da prosesin başka işlemlere yanı ı
4) Thread'ler paralel programlama için mecburen kullanı ı ı
olduğu durumda prosesin thread'lerinin farklı ı ı ı ı ı ı
büyük bir diziyi sı ı
çekirdek olması ı ı ı ı ı ı ı
bunlar paralel bir biçimde dizinin çeşitli parçaları ı ı ı ı ı ı
olabiliriz.
5) Thread'ler GUI programlama ortamları ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
78. Ders 30/03/2024 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir proses çalı ı
tipik olarak akı ı ı ı ı
bu sistem fonksiyonları ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Modern işletim sisemlerinin çizelgeleyici (scheduler) alt sistemleri thread'leri çizelgelemektedir. Yani işletim sistemi hangi prosese
ilişkin olursa olsun sı ı ı ı ı ı
Modern çok thread'li (multithreaded) işletim sistemlerinde prosesler değil thread'ler çizelgelenmektedir. Yukarı
prosesin bir thread'i bloke olduğunda diğerleri çalı ı ı
kaldı ı ı ı ı ı
thread ile sonraki thread aynı ı
sistemlerde zaman paylaşı ı ı ı ı
Thread'lerin sı ı
ya da çekirdekli sistemlerde çalı ı ı
olabilir. Örneğin Linux bir ara O(1) çizelgelemesi adı ı ı
thread'in işi biterse o çalı ı ı
değiştirildi. Bugünkü çizelgeleme algoritması ı ı ı
bu tür durumlarda işlemci ya da çekirdeklerin çalı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Thread'lerin stack'leri birbirinden ayrı ı ı ı ı ı ı ı ı ı
stack'leri biribirindne ayrı ı ı ı ı
yaratı ı ı ı ı
iki thread aynı ı ı ı ı ı ı
yerel değişkenlerin her thread için ayrı ı ı
void foo(void))
{
int a;
a = 10;
...
++a;
...
++a;
...
}
İki farklı ı ı ı ı ı
biri bu a değişkenini değiştirdiğinde kendi thread'inin stack'indeki a değişkenini değiştirmiş olur. Bu değişiklikten diğer thread'in a
değişkeni etkilenmeyecektir.
Ancak global değişkenler tüm thread'ler tarafı ı ı
özgü değil prosese özgüdür. Örneğin bir thread bir global değişkeni değiştirdiğinde diğer thread o global değişkeni değişmiş görmektedir.
Benzer biçimde heap alanı ı ı
alanı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir işin birden fazla akı ı ı ı ı
yaratı ı ı ı ı ı ı ı ı
önceki konularda da gördüğümüz gibi proseslerarası
global nesneler yoluyla haberleşebilmektedir. Eskiden thread'ler yokken bir işin birden fazla akı ı ı ı
gerçekleştiriliyordu. Oysa thread'ler işletim sistemlerine girince artı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Artı ı ı
için standart kütüpaheneler bulunmaktadı ı ı ı ı
mega hertz düzeyinde çalı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
Artı ı ı ı ı ı
sistemleri de işlemcilere ya da çekirdeklere thread'leri atamaktadı
thread'lerdir.
Eskiden board'lara birden fazla işlemci takı
başlandı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı
çağı ı ı ı
buluan thread fonksiyonları ı ı ı ı ı ı ı ı ı
bu dillerin kütüphaneleri yaratı ı ı ı ı
fonksiyonları ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde thread'ler CreateThread isimli API fonksiyonuyla yaratı ı
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);
Fonksiyonun birinci parametresi thread kernel nesnesinin güvenlik bilgilerini belirtmektedir. Bu parametre NULL geçilebilir. İkinci parametre
yaratı ı ı ı ı ı
(PE formatı ı ı ı ı ı
başlatı ı ı ı
aşağı
typedef DWORD (WINAPI *PTHREAD_START_ROUTINE)(LPVOID lpThreadParameter);
Görüldüğü gibi LPTHREAD_START_ROUTINE geri dönüş değeri DWORD, parametresi LPVOID (yani void *) türünden olan bir fonksiyon adresini
belirtmektedir. 32 bit Windows sistemlerinde "fonksiyon çağı ı
anahtar sözcüğü Microsoft'a özgü olan bir eklentidir (extension). __stdcall WINAPI olarak da define edişmiştir:
#define WINAPI __stdcall
Bu çağı ı
DWORD WINAPI ThreadProc(LPVOID param)
{
...
}
64 bit Windows sistemlerinde "çağı ı ı ı ı ı
aşağı
#define __stdcall
O halde Windows programı ı ı ı ı
64 bit derlemede bu çağı
CreateThread fonksiyonunun dördüncü parametresi thread fonksiyonuna geçirilecek olan parametreyi belirtmektedir. Thread'leryaratı ı ı
akı ı ı ı ı
bu parametreyi NULL biçimde belirtebiliriz. Fonksiyonun beşinci parametresi tipik olarak 0 biçiminde ya da CREATE_SUSPENDED biçiminde
geçilir. Eğer bu parametre 0 geçilirse thread yaratı ı ı ı
threda yaratı ı ı ı ı ı ı ı
parametresi thread'in ID değerinin yerleştirileceği DWORD nesnesinin adresini almaktadı ı
Eğer thread'in ID değeri alı ı ı
değerine, başarı ı ı ı ı
Thread'in değeri thread işlemlerinde kullanı ı ı
HANDLE hThread;
DWORD dwThreadId;
DWORD __stdcall ThreadProc(LPVOID param);
...
if ((hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, &dwThreadId)) == NULL)
ExitSys("CreateThread");
...
Thread fonksiyonu bittiğinde thread kaynakları ı ı ı
boşaltı ı ı
Aşağı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
DWORD __stdcall ThreadProc(LPVOID param);
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
DWORD dwThreadId;
HANDLE hThread;
printf("main thread begins...\n");
if ((hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, &dwThreadId)) == NULL)
ExitSys("CreateThread");
for (int i = 0; i < 10; ++i) {
printf("Main thread: %d\n", i);
Sleep(1000);
}
CloseHandle(hThread);
return 0;
}
DWORD __stdcall ThreadProc(LPVOID param)
{
for (int i = 0; i < 10; ++i) {
printf("Other thread: %d\n", i);
Sleep(1000);
}
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde thread işlemleri başı ı ı ı ı
kullanı ı ı
tüm fonksiyonlar pthread_xxx biçiminde isimlendirilmiştir. Tüm thread fonksiyonları ı ı ı ı
içerisindedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde thread yaratmak için pthread_create isimli POSIX fonksiyonu kullanı ı
#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);
Fonksiyonun birinci parametresi thread'in id'sinin yerleştirileceği pthread_t türünden nesnenin adresini almaktadı
thread'lerin yalnı ı ı ı ı
herhangi bir olarak typedef edilebilmektedir. Linux sistemlerinde bu tür unsigned long olarak typedef edilmiştir. Ancak başka sistemlerde
bir yapı ı ı
thread özellik nesnesinin adresinin almaktadı ı
vermektedir. Ancak bu parametre NULL adres olarak da geçilebilir. Bu durumda thread default özelliklerle yaratı ı
parametresi thread akı ı ı ı ı ı ı
parametrelerinin de void * türünden olması
void *thread_proc(void *param)
{
....
}
Fonksiyonun son parametresi thread fonksiyonuna geçirilecek olan argümanı
geçirilmek istenmiyorsa bu parametre için NULL adres kullanı
pthread_create fonksiyonu başarı ı ı ı
Başarı ı ı ı ı ı
pthread_t tid;
int result;
void *thread_proc(void *param);
...
if ((result = pthread_create(&tid, NULL, thread_proc, NULL)) != 0) {
fprintf(stderr, "pthread_create: %s\n", strerror(result));
exit(EXIT_FAILURE);
}
...
Tabii işlemleri kı
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
pthread_create fonksiyonuyla yaratı ı ı ı ı
bir örnek verilmiştir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void *thread_proc(void *param);
void exit_sys_errno(const char *msg, int eno);
int main(void)
{
pthread_t tid;
int result;
if ((result = pthread_create(&tid, NULL, thread_proc, NULL)) != 0)
exit_sys_errno("pthread_create", result);
for (int i = 0; i < 10; ++i) {
printf("main thread: %d\n", i);
sleep(1);
}
CloseHandle(hThread);
return 0;
}
void *thread_proc(void *param)
{
for (int i = 0; i < 10; ++i) {
printf("other thread: %d\n", i);
sleep(1);
}
return NULL;
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Thread'ler çeşitli biçimlerde sonlanabilmektedir. Bir thread'in en doğal sonlanması
Windows sistemlerinde hem de UNIX/Linux ve macOS sistemlerinde thread fonksiyonu bittiğinde thread'ler de otomatik olarak sonlanmaktadı
Yukarı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir thread herhangi bir noktada Windows'ta ExitThread API fonksiyonu ile UNIX/Linux ve macOS sistemlerinde pthread_exit fonksiyonu ile
sonlandı ı ı ı ı ı ı ı ı ı
ExitThread ve pthread_exit fonksiyonları ı ı ı ı ı
Therad'lerin de tı ı ı ı ı
sistemlerinde ise void * bir değerle temsil edilmektedir. Thread'in exit kodları ı ı ı ı ı
çeşitli amaçlarla kullanı ı ı
Windows'taki ExitThread API fonksiyonunun prototipi şöyledir:
void ExitThread(
DWORD dwExitCode
);
Fonksiyon thread'in exit kodunu parametre olarak almaktadı
Aşağı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
DWORD __stdcall ThreadProc(LPVOID param);
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
DWORD dwThreadId;
HANDLE hThread;
printf("main thread begins...\n");
if ((hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, &dwThreadId)) == NULL)
ExitSys("CreateThread");
for (int i = 0; i < 10; ++i) {
printf("Main thread: %d\n", i);
Sleep(1000);
}
CloseHandle(hThread);
return 0;
}
DWORD __stdcall ThreadProc(LPVOID param)
{
for (int i = 0; i < 10; ++i) {
printf("Other thread: %d\n", i);
if (i == 5)
ExitThread(0);
Sleep(1000);
}
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux ve macOS sistemlerinde thread'i sonlandı ı
#include <pthread.h>
void pthread_exit(void *retval);
Fonksiyon yine thread'in exit kodunu parametre olarka olmaktadı ı
temsil edilmektedir.
Aşağı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void *thread_proc(void *param);
void exit_sys_errno(const char *msg, int eno);
int main(void)
{
pthread_t tid;
int result;
if ((result = pthread_create(&tid, NULL, thread_proc, NULL)) != 0)
exit_sys_errno("pthread_create", result);
for (int i = 0; i < 10; ++i) {
printf("main thread: %d\n", i);
sleep(1);
}
CloseHandle(hThread);
return 0;
}
void *thread_proc(void *param)
{
for (int i = 0; i < 10; ++i) {
printf("other thread: %d\n", i);
if (i == 5)
pthread_exit(NULL);
sleep(1);
}
return NULL;
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir proses sonlandı ı ı ı ı ı ı ı ı
tüm prosesi sonlandı ı ı ı ı ı ı ı
anı ı ı ı
bu hatayı ı ı ı ı ı ı ı
durumda yaratı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void *thread_proc(void *param);
void exit_sys_errno(const char *msg, int eno);
int main(void)
{
pthread_t tid;
int result;
if ((result = pthread_create(&tid, NULL, thread_proc, NULL)) != 0)
exit_sys_errno("pthread_create", result);
/* dikkat! main bitince yaratı ı ı ı ı
return 0;
}
void *thread_proc(void *param)
{
for (int i = 0; i < 10; ++i) {
printf("other thread: %d\n", i);
if (i == 5)
pthread_exit(NULL);
sleep(1);
}
return NULL;
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Threadler arası ı
thread'in yarattı ı ı ı ı ı ı
sistemlerinde TerminateThread API fonksiyonuyla o anda zorla sonlandı ı
thread'in belli bir noktada (örneğin printf fonksiyonunun içerisinde) zorla sonlandı ı ı ı
TerminateThread API fonksiyonunun prototipi şöyledir:
BOOL TerminateThread(HANDLE hThread, DWORD dwExitCode);
Fonksiyonun birinci parametresi sonlandı ı ı
Fonksiyon başarı ı ı ı ı ı ı ı ı ı
Aşağı ı ı ı ı
olumsuz etkilenebilir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
DWORD __stdcall ThreadProc(LPVOID param);
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
DWORD dwThreadId;
HANDLE hThread;
printf("main thread begins...\n");
if ((hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, &dwThreadId)) == NULL)
ExitSys("CreateThread");
for (int i = 0; i < 10; ++i) {
if (i == 5)
if (!TerminateThread(hThread, 0))
ExitSys("TerminateThread");
printf("Main thread: %d\n", i);
Sleep(1000);
}
CloseHandle(hThread);
return 0;
}
DWORD __stdcall ThreadProc(LPVOID param)
{
for (int i = 0; i < 10; ++i) {
printf("Other thread: %d\n", i);
Sleep(1000);
}
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde de bir thread başka bir thread'i zorla pthread_cancel fonksiyonu ile sonlandı
sistemlerindeki TerminateThread fonksiyonu gibi çalı ı ı
thread akı ı ı ı ı ı ı ı ı
fonksiyonuna göre daha güvenlidir. pthread_cancel uygulandı ı ı ı ı ı ı ı
"cancellation points" denilmektedir. Bu fonksiyonarı ı
pthread_cancel fonksiyonunun prototipi şöyledir:
#include <pthread.h>
int pthread_cancel(pthread_t thread);
Fonksiyon parametre olarak sonlandı ı ı ı ı ı ı
değerine geri dönmektedir.
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void *thread_proc(void *param);
void exit_sys_errno(const char *msg, int eno);
int main(void)
{
pthread_t tid;
int result;
if ((result = pthread_create(&tid, NULL, thread_proc, NULL)) != 0)
exit_sys_errno("pthread_create", result);
for (int i = 0; i < 10; ++i) {
printf("main thread: %d\n", i);
if (i == 5)
if ((result = pthread_cancel(tid)) != 0)
exit_sys_errno("pthread_cancel", result);
sleep(1);
}
return 0;
}
void *thread_proc(void *param)
{
for (int i = 0; i < 10; ++i) {
printf("other thread: %d\n", i);
if (i == 5)
pthread_exit(NULL);
sleep(1);
}
return NULL;
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı
POSIX fonksiyonları ı ı ı ı ı ı ı ı
seçeneğini kullanarak görebilirsiniz. Komut şöyle uygulanabilir:
$ ps -t /dev/pts/0 -T
Burada /dev/pts/0 thread'li programı ı ı ı ı
tty komutu ile öğrenebilirisniz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void *thread_proc(void *param);
void exit_errno(const char *msg, int result);
int main(int argc, char *argv[])
{
pthread_t tid;
int result;
int i;
if ((result = pthread_create(&tid, NULL, thread_proc, NULL)) != 0)
exit_errno("pthread_create", result);
for (i = 0; i < 10; ++i) {
if (i == 5)
if ((result = pthread_cancel(tid)) != 0)
exit_errno("pthread_cancel", result);
printf("main thread: %d\n", i);
sleep(1);
}
printf("press ENTER to exit..\n");
getchar();
return 0;
}
void *thread_proc(void *param)
{
for (;;)
;
return NULL;
}
void exit_errno(const char *msg, int result)
{
fprintf(stderr, "%s: %s\n", msg, strerror(result));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Thread'lerin stack'leri birbirlerinden ayrı ı ı ı ı ı ı
yerel değişkenlerin ve parametre değişkenlerinin farklı ı ı ı ı
ve yaratı ı ı ı ı ı
i yerel değişkenini global değişken yaparak da çalı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
DWORD __stdcall ThreadProc(LPVOID param);
void Foo(LPCSTR pszName);
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
DWORD dwThreadId;
HANDLE hThread;
printf("main thread begins...\n");
if ((hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, &dwThreadId)) == NULL)
ExitSys("CreateThread");
Foo("main thread");
return 0;
}
DWORD __stdcall ThreadProc(LPVOID param)
{
Foo("other thread");
return 0;
}
int i = 0;
void Foo(LPCSTR pszName)
{
while (i < 10) {
printf("%s: %d\n", pszName, i);
Sleep(1000);
++i;
}
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir thread'in sonlanması ı ı ı
sonlanana kadar beklemek isteyebilir.
Windows sistemlerinde thread sonlanana kadar bekleme yapmak için WaitForSingleObject ve WaitForMultipleObjects isimli API fonksiyonları
bulunmaktadı ı
kullanı ı ı ı ı ı
nası ı ı ı ı ı ı ı ı
üzerinde duracağı
DWORD WaitForSingleObject(
HANDLE hHandle,
DWORD dwMilliseconds
);
Yukarı ı
(nonsignaled) olduğu sürece bekleme yapar. Senktronizasyon nesnesi açı ı
nesnesinin hangi durumda kapalı ı ı
kullanı ı ı ı ı
O halde bu fonksiyon thread bitene kadar bekleme sağlamaktadı ı ı
belirtmektedir. Eğer nesne burada belirtilen zaman aşı ı ı ı ı ı
Bu parametre için INFINITE özel değeri girilirse zaman aşı ı ı ı ı ı
WaitForSingleObject fonksiyonu başarı ı ı ı ı
şunlardan biri olabilir:
WAIT_OBJECT_0: Nesne açı ı ı
WAIT_TIMEOUT: Zaman aşı ı ı ı
WAIT_ABONDONED: Mutex'in beklendiği durumda mutex'in sahipliğini alan thread'in sonlanması ı ı
"abondoned mutex" denilmektedir.
WaitForSingleObject fonksyionu çağrı ı ı ı
hemen geri döner.
Bu durumda bir thread sonlanana kadar bekleme yapmak şöyle sağlanabilir:
if (WaitForSingleObject(hThread, INFINITE) == WAIT_FAILED)
ExitSys("WaitForSingleObject")
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
DWORD __stdcall ThreadProc(LPVOID param);
void Foo(LPCSTR pszName);
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
DWORD dwThreadId;
HANDLE hThread;
printf("main thread begins...\n");
if ((hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, &dwThreadId)) == NULL)
ExitSys("CreateThread");
printf("main thread waits at WaitForSingleObject...\n");
if (WaitForSingleObject(hThread, INFINITE) == WAIT_FAILED)
ExitSys("WaitForSingleObject");
CloseHandle(hThread);
printf("main thread continues...\n");
return 0;
}
DWORD __stdcall ThreadProc(LPVOID param)
{
for (int i = 0; i < 10; ++i) {
printf("Other thread: %d\n", i);
Sleep(1000);
}
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
WaitForMultipleObjects fonksiyonu birden fazla senkronizasyon nesnesini beklemek için kullanı ı ı
olalı ı ı ı
Diğer bir yolu ise bir kez WaitForMultipleObject fonksiyonunu kullanmaktı
WaitForMultipleObjects fonksiyonunun prototipi şöyledir:
DWORD WaitForMultipleObjects(
DWORD nCount,
const HANDLE *lpHandles,
BOOL bWaitAll,
DWORD dwMilliseconds
);
Fonksiyonun birinci parametresi kaç senkronizasyon nesnesinin bekleneceğini belirtmektedir. (Yani bu parametre ikinci parametredeki dizinin
uzunluğunu belirtir.) İkinci parametre beklenecek senkronizasyon nesnelerinin hhandle değerlerinin bulundurğu dizinin adresini almaktadı
Üçüncü parametre tek bir nesnenin mi yoksa bütün nesnelerin mi açı ı ı ı ı
TRUE geçilirse tüm nesneler açı ı ı ı
kadar bekleme yapı ı ı ı
WaitForMultiplrObjects fonksiyonu başarı ı ı ı ı ı ı
yine WAIT_TIMEOUT değerine geri döner. Eğer fonksiyonun üçüncü parametresi TRUE geçilirse tüm senkronizasyon nesneleri açı ı ı
WAIT_OBJECT_0 değerinden WAIT_OBJECT_0 + nCunt değerine kadar herhangi bir değerle geri dönebilir. Eğer fonksiyonun üçüncü parametresi
FALSE geçilirse fonksiyon hangi senkronizasyon nesnesi açı
n açı ı
indeksle geri dönmektedir.
Aşağı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#define NTHREADS 10
DWORD __stdcall ThreadProc(LPVOID param);
void Foo(LPCSTR pszName);
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
DWORD dwThreadIds[NTHREADS];
HANDLE hThreads[NTHREADS];
char szName[64];
char *pszName;
printf("main thread begins...\n");
for (int i = 0; i < NTHREADS; ++i) {
sprintf(szName, "Thread %d", i);
if ((pszName = strdup(szName)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
if ((hThreads[i] = CreateThread(NULL, 0, ThreadProc, pszName, 0, &dwThreadIds[i])) == NULL)
ExitSys("CreateThread");
}
printf("main thread waits at WaitForSingleObject...\n");
if (WaitForMultipleObjects(NTHREADS, hThreads, TRUE, INFINITE) == WAIT_FAILED)
ExitSys("WaitForMultipkeObjects");
for (int i = 0; i < NTHREADS; ++i)
CloseHandle(hThreads[i]);
printf("main thread continues...\n");
return 0;
}
DWORD __stdcall ThreadProc(LPVOID param)
{
const char *pszName = (const char *)param;
for (int i = 0; i < 10; ++i) {
printf("%s: %d\n", pszName, i);
Sleep(1000);
}
free(pszName);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Thread'lerin de exit kodları ı ı
sonraki paragrafta göreceğimiz pthread_join fonksiyonu ile elde edilmeketdir. Tabii sonlanmamı
çalı ı ı ı ı ı ı ı ı
DWORD bir değerken UNIX/Linux sistemlerinde void * türünden bir değerdir. Anı ı ı
durumu yoktur. Bir thread'in exit kodu herhangi bir thread tarafı ı
Windows'ta GetExitCodeThread fonksiyonunun protoipi şöyledir:
BOOL GetExitCodeThread(
HANDLE hThread,
LPDWORD lpExitCode
);
Foksiyonun birinci parametresi exit kodu elde edilecek thread'in HANDLE değerini belirtir. İkinci parametre exit kodunun yerleştirileceği
DWORD nesnenin adresini almaktadı ı ı ı ı ı ı ı ı ı ı
Aşağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
DWORD __stdcall ThreadProc(LPVOID param);
void Foo(LPCSTR pszName);
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
DWORD dwThreadId;
HANDLE hThread;
DWORD dwExitCode;
printf("main thread begins...\n");
if ((hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, &dwThreadId)) == NULL)
ExitSys("CreateThread");
printf("main thread waits at WaitForSingleObject...\n");
if (WaitForSingleObject(hThread, INFINITE) == WAIT_FAILED)
ExitSys("WaitForSingleObject");
if (!GetExitCodeThread(hThread, &dwExitCode))
ExitSys("GetExitCodeThread");
CloseHandle(hThread);
printf("Exit Code: %u\n", dwExitCode);
return 0;
}
DWORD __stdcall ThreadProc(LPVOID param)
{
for (int i = 0; i < 10; ++i) {
printf("Other thread: %d\n", i);
Sleep(1000);
}
return 123;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde thread'lerin sonlanması ı ı ı ı ı ı
Yani fonksiyon hem bekleme yapı ı
#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);
Fonksiyonun birinci parametresi beklemecek thread'in id değerini belirtmektedir. İkinci parametre exit kodunun yerleştirileceği void
göstericinin adresini belirtmektedir. Eğer ikinci parametre NULL geçilirse thread'in birmesi beklenir ancak exit kodu çağı
iletilmez. Fonksiyon baları ı ı ı
Aşağı ı ı ı
beklenmiştir. Bu örnekte exit kodu bir tamsayı
alı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void *thread_proc(void *param);
void exit_sys_errno(const char *msg, int eno);
int main(void)
{
pthread_t tid;
int result;
void *exit_code;
printf("main begins...\n");
if ((result = pthread_create(&tid, NULL, thread_proc, NULL)) != 0)
exit_sys_errno("pthread_create", result);
printf("main thread waits at pthread_join...\n");
if ((result = pthread_join(tid, &exit_code)) != 0)
exit_sys_errno("pthread_join", result);
printf("Exit code: %d\n", (int)exit_code);
return 0;
}
void *thread_proc(void *param)
{
for (int i = 0; i < 10; ++i) {
printf("other thread: %d\n", i);
sleep(1);
}
return (void *)123;
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde "zombie proses" kavramı ı ı ı ı ı
tı ı ı ı ı ı ı
thread kavramı ı
potansiyelinde değildir. Fakat yine pthread_join fonksiyonuyla zombie thread'lerin oluşması ı
kodu ile ilgilenmiyorsa thread biter bitmez kaynakalrı ı ı ı
kullanı ı
#include <pthread.h>
int pthread_detach(pthread_t thread);
Fonksiyon parametre olarak thread'in id değerini alı ı ı ı ı ı ı
Tabii detach moda sokulmuş thread'ler artı ı ı ı
fonksiyonu başarı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Thread'ler konusunun en önemli alt konusu thread senkronizasyonudur. Bir grup thread birlikte bir işi gerçekleştirirken kimi zaman
birbirlerini beklemesi, birbirleriyle koordineli bir biçimde çalı ı
mekanizmalara ""thread senkronizasyonu" denilmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Thread senkronizasyonunun önemi basit örnekle anlaşı ı ı ı ı
aynı ı ı ı
Ancak senkronizasyon problemi yüzünden muhtemelen iki milyon olamayacaktı ı
Programı ı ı ı ı ı ı ı
$ ./sample
1140644
$ ./sample
1175870
$ ./sample
1900343
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void *thread_proc1(void *param);
void *thread_proc2(void *param);
void exit_sys_errno(const char *msg, int eno);
int g_count;
int main(void)
{
pthread_t tid1, tid2;
int result;
if ((result = pthread_create(&tid1, NULL, thread_proc1, NULL)) != 0)
exit_sys_errno("pthread_create", result);
if ((result = pthread_create(&tid2, NULL, thread_proc2, NULL)) != 0)
exit_sys_errno("pthread_create", result);
if ((result = pthread_join(tid1, NULL)) != 0)
exit_sys_errno("pthread_join", result);
if ((result = pthread_join(tid2, NULL)) != 0)
exit_sys_errno("pthread_join", result);
printf("%d\n", g_count);
return 0;
}
void *thread_proc1(void *param)
{
for (int i = 0; i < 1000000; ++i)
++g_count;
return NULL;
}
void *thread_proc2(void *param)
{
for (int i = 0; i < 1000000; ++i)
++g_count;
return NULL;
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
DWORD __stdcall ThreadProc1(LPVOID lpvParam);
DWORD __stdcall ThreadProc2(LPVOID lpvParam);
void ExitSys(LPCSTR lpszMsg);
int g_count;
int main(void)
{
HANDLE hThread1, hThread2;
DWORD dwThreadID1, dwThreadID2;
if ((hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, &dwThreadID1)) == NULL)
ExitSys("CreateThread");
if ((hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, &dwThreadID2)) == NULL)
ExitSys("CreateThread");
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
CloseHandle(hThread1);
CloseHandle(hThread2);
printf("%d\n", g_count);
return 0;
}
DWORD __stdcall ThreadProc1(LPVOID lpvParam)
{
int i;
for (i = 0; i < 1000000; ++i)
++g_count;
return 0;
}
DWORD __stdcall ThreadProc2(LPVOID lpvParam)
{
int i;
for (i = 0; i < 1000000; ++i)
++g_count;
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Thread senkronizasyon problemleri tipik olarak birden fazla thread'in ortak bir kaynak üzerinde çalı ı ı ı ı
Thread'lerden biri bu ortak kaynak üzerinde yazma (gemel olarka güncelleme) yaptı ı ı ı ı
geçiş oluşursa ve başka bir thread de bu kararsı ı ı ı
kaldı ı ı ı ı ı
Bu nesne global bir değişken olabileceği gibi dı ı ı
Örneğin iki thread dı ı ı ı ı ı
edelim:
...
<Makineyi 1'inci konuma sok>
<Makineyi 2'inci konuma sok>
<Makineyi 3'üncü konuma sok>
<Makineyi 4'üncü konuma sok>
<Makineyi 5'inci konuma sok>
...
Şimdi thread'lerden biri aşağı ı
...
<Makineyi 1'inci konuma sok>
<Makineyi 2'inci konuma sok>
<Makineyi 3'üncü konuma sok>
----> Bu noktada "context switch" olsun
<Makineyi 4'üncü konuma sok>
<Makineyi 5'inci konuma sok>
...
Başka bir thread aynı ı ı
beşinci konumdadı ı ı ı ı
Halbuki makine şu anda 5'inci konumdadı ı
Şimdi de yukarı ı ı ı ı ı ı
artı ı ı
MOV reg, g_count
INC reg
MOV g_count, reg
Önce g_count CPU yazmacı ı ı ı ı ı ı ı
yerleştirilmiştir. Şimdi tam aşağı ı ı
MOV reg, g_count
----> Bu noktada "context switch" olsun
INC reg
MOV g_count, reg
Bu noktada g_cunt değerinin 1250305 olduğunu varsayalı ı ı
1756340'a getirmiş olsun. Önceki thread kalan noktadan çalı ı ı ı ı
1250306 elde edilir. Bu değeri yeniden g_count nesnesine yerleştrecek ve g_count'taki değeri bozacaktı
Thread'ler arası ı ı ı
geçişin oluşacağu "quanta" durumuna bağlı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Başı ı ı ı ı ı ı ı ı ı
denilmektedir. Kritik kod blokları ı
bu bloğa girmek istediğinde daha girmiş olan thread'in buradan çı ı ı ı ı ı
tarafı ı ı ı ı ı ı ı ı
...
MOV reg, g_count
INC reg
MOV g_count, reg
...
Bu üç makine komutu bir kritik kod oluşturmaktadı ı ı ı ı
çı ı ı
Ancak bu yöntemin user mode'tan uygulanması ı
...
<Makineyi 1'inci konuma sok>
<Makineyi 2'inci konuma sok>
<Makineyi 3'üncü konuma sok>
<Makineyi 4'üncü konuma sok>
<Makineyi 5'inci konuma sok>
...
Bir thread bu kritik koda girdiğinde arada kesilse bile başka thread bu thread kritik koddan çı
Senkronizasyon bağlamı ı ı ı ı
denilmektedir. Yani "bir işlemin atomik bir biçimde yapı ı ı
yapı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Kritik kodları ı ı ı
fonksiyonları ı
kullanı ı
int g_flag = 0;
...
while (g_flag == 1)
;
g_flag = 1;
......
...... <KRİTİK KOS>
......
g_falg = 0;
Buradaki kodun iki önemli problemi vardı
1) Burada tam while döngüsünden çı ı ı ı ı
while (g_flag == 1)
;
----> Dikkat tan bu noktada "context switch" olabilir
g_flag = 1;
......
...... <KRİTİK KOS>
......
g_falg = 0;
Bu durumda g_flag 0 konumunda kalmı ı
2) Burada bekleme "meşgul bir döngüyle (busy loop)" yapı ı ı ı ı ı
İşet bu tür kodlar özel birtakı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Kritik kodlar tek bir blok biçiminde olmayabilir. Birden fazla yere yayı ı ı
thread'lerden biri ekleme yaparken diğer bir thread ekleme de silme de hatta dolaşma da yapmamı ı
yapan, bağlı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows'ta kritik kod oluşturmak için en yalı ı ı ı
şöyle oluşturulmaktadı
1) Önce global bir değişken biçiminde CRITICAL_SECTION türünden bir nesne yaratı ı ı
belirtmektedir. Ancak programcı ı ı ı
CRITICAL_SECTION g_cs;
2) Yaratı
void InitializeCriticalSection(
LPCRITICAL_SECTION lpCriticalSection
);
Fonksiyon CRITICAL_SECTION nesneninin adresini parametre olarak almaktadı ı
yapı
InitializeCriticalSection(&g_cs);
3) Kritik kod EnterCriticalSection ve LeaveCriticalSection API fonksiyonları ı ı ı
EnterCriticalSection(&g_cs);
...
... <KRİTİK KOD>
...
LeaveCriticalSection(&g_cs);
Fonksiyonları
void EnterCriticalSection(
LPCRITICAL_SECTION lpCriticalSection
);
void LeaveCriticalSection(
LPCRITICAL_SECTION lpCriticalSection
);
Her iki fonksiyon da CRITICAL_SECTION nesnesinin adresini almaktadı
LeaveCriticalSection fonksiyonunu çağı
geçiş yapma istediğinde bloke olur. Ta ki önceki thread LeaveCriticalSection fonksiyonunu çağı
bir kilit gibi davrandı ı
LeaveCriticalSection kritik kodun kilidini açmaktadı
Bir thread EnterCriticalSection fonksiyonundan geçerek nesneyi kilitlemiş olsun. Bu sı
EnterCriticalSection fonksiyonunda bekliyor olsun. İlk thread kritik koddan çı ı ı
hangi thread kritik koda girecektir? En adil durumun ilk gelen thread'in girmesi olduğunu düşünebilirsiniz. Ancak Windows sistemleri
çeşitli nedenlerden dolayı
4) Kullanı
DeleteCriticalSection(&g_cs);
Fonksiyonun prototipi şöyledir:
VOID DeleteCriticalSection(
LPCRITICAL_SECTION lpCriticalSection
);
Fonksiyon yine CRITICAL_SECTION nesnesinin adresini almaktradı
Kritik kod bloğu birden fazla yere yayı ı ı ı ı
temsil etmektedir. Örneğin:
void insert_item(...)
{
...
EnterCriticalSection(&g_s);
....
.... <bağlı
....
LeaveCriticalSection(&g_s);
...
}
void delete_item(...)
{
...
EnterCriticalSection(&g_s);
....
.... <bağlı
....
LeaveCriticalSection(&g_s);
...
}
Burada bir thread eleman insert ederken diğer thread elemanı
edemeyecektir. Çünkü bu iki kritik kod aynı ı ı ı ı ı ı ı
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
DWORD __stdcall ThreadProc1(LPVOID lpvParam);
DWORD __stdcall ThreadProc2(LPVOID lpvParam);
void ExitSys(LPCSTR lpszMsg);
int g_count;
CRITICAL_SECTION g_cs;
int main(void)
{
HANDLE hThread1, hThread2;
DWORD dwThreadID1, dwThreadID2;
InitializeCriticalSection(&g_cs);
if ((hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, &dwThreadID1)) == NULL)
ExitSys("CreateThread");
if ((hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, &dwThreadID2)) == NULL)
ExitSys("CreateThread");
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
CloseHandle(hThread1);
CloseHandle(hThread2);
printf("%d\n", g_count);
DeleteCriticalSection(&g_cs);
return 0;
}
DWORD __stdcall ThreadProc1(LPVOID lpvParam)
{
int i;
for (i = 0; i < 1000000; ++i) {
EnterCriticalSection(&g_cs);
++g_count;
LeaveCriticalSection(&g_cs);
}
return 0;
}
DWORD __stdcall ThreadProc2(LPVOID lpvParam)
{
int i;
for (i = 0; i < 1000000; ++i) {
EnterCriticalSection(&g_cs);
++g_count;
LeaveCriticalSection(&g_cs);
}
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aağı ı ı ı ı ı
biri kritik koda girdiğinde diğeri kiritk koda girmemektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
DWORD __stdcall ThreadProc1(LPVOID lpvParam);
DWORD __stdcall ThreadProc2(LPVOID lpvParam);
void UseMachine(LPCSTR pszName);
void ExitSys(LPCSTR lpszMsg);
CRITICAL_SECTION g_cs;
int main(void)
{
HANDLE hThread1, hThread2;
DWORD dwThreadID1, dwThreadID2;
InitializeCriticalSection(&g_cs);
if ((hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, &dwThreadID1)) == NULL)
ExitSys("CreateThread");
if ((hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, &dwThreadID2)) == NULL)
ExitSys("CreateThread");
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
CloseHandle(hThread1);
CloseHandle(hThread2);
DeleteCriticalSection(&g_cs);
return 0;
}
DWORD __stdcall ThreadProc1(LPVOID lpvParam)
{
int i;
for (i = 0; i < 10; ++i)
UseMachine("Therad-1");
return 0;
}
DWORD __stdcall ThreadProc2(LPVOID lpvParam)
{
int i;
for (i = 0; i < 10; ++i)
UseMachine("Thread-2");
return 0;
}
void UseMachine(LPCSTR pszName)
{
EnterCriticalSection(&g_cs);
printf("-------------------\n");
printf("%s: 1. Step\n", pszName);
Sleep(rand() % 500);
printf("%s: 2. Step\n", pszName);
Sleep(rand() % 500);
printf("%s: 3. Step\n", pszName);
Sleep(rand() % 500);
printf("%s: 4. Step\n", pszName);
Sleep(rand() % 500);
printf("%s: 5. Step\n", pszName);
Sleep(rand() % 500);
LeaveCriticalSection(&g_cs);
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Örneğin iki thread aynı ı ı ı
davranı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* sample.c */
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "llist.h"
DWORD __stdcall ThreadProc1(LPVOID lpvParam);
DWORD __stdcall ThreadProc2(LPVOID lpvParam);
void ExitSys(LPCSTR lpszMsg);
CRITICAL_SECTION g_cs;
HLLIST g_hllist;
int main(void)
{
HANDLE hThread1, hThread2;
DWORD dwThreadID1, dwThreadID2;
InitializeCriticalSection(&g_cs);
if ((g_hllist = create_llist()) == NULL) {
fprintf(stderr, "cannot create linked list!..\n");
exit(EXIT_FAILURE);
}
if ((hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, &dwThreadID1)) == NULL)
ExitSys("CreateThread");
if ((hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, &dwThreadID2)) == NULL)
ExitSys("CreateThread");
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
CloseHandle(hThread1);
CloseHandle(hThread2);
DeleteCriticalSection(&g_cs);
printf("%zd\n", count_llist(g_hllist));
return 0;
}
DWORD __stdcall ThreadProc1(LPVOID lpvParam)
{
for (int i = 0; i < 1000000; ++i) {
EnterCriticalSection(&g_cs);
if (add_tail(g_hllist, i) == NULL) {
fprintf(stderr, "cannot add item..\n");
exit(EXIT_FAILURE);
}
LeaveCriticalSection(&g_cs);
}
return 0;
}
DWORD __stdcall ThreadProc2(LPVOID lpvParam)
{
for (int i = 0; i < 1000000; ++i) {
EnterCriticalSection(&g_cs);
if (add_tail(g_hllist, i) == NULL) {
fprintf(stderr, "cannot add item..\n");
exit(EXIT_FAILURE);
}
LeaveCriticalSection(&g_cs);
}
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/* llist.h */
/* llist.h */
#ifndef LLIST_H_
#define LLIST_H_
#include <stddef.h>
#include <stdbool.h>
/* Type Declarations */
typedef int DATATYPE;
typedef struct tagNODE {
DATATYPE val;
struct tagNODE *next;
} NODE;
typedef struct tagLLIST {
NODE head;
NODE *tail;
size_t count;
} LLIST, *HLLIST;
/* Function Prototypes */
HLLIST create_llist(void);
NODE *insert_next(HLLIST hllist, NODE *node, DATATYPE val);
NODE *insertp_next(HLLIST hllist, NODE *node, const DATATYPE *val);
NODE *add_tail(HLLIST hllist, DATATYPE val);
NODE *addp_tail(HLLIST hllist, const DATATYPE *val);
NODE *add_head(HLLIST hllist, DATATYPE val);
NODE *addp_head(HLLIST hllist, const DATATYPE *val);
void remove_next(HLLIST hllist, NODE *node);
void remove_head(HLLIST hllist);
DATATYPE *getp_item(HLLIST hllist, size_t index);
bool walk_llist(HLLIST hllist, bool (*proc)(DATATYPE *));
void clear_llist(HLLIST hllist);
void destroy_llist(HLLIST hllist);
/* inline Function Definitions */
static inline size_t count_llist(HLLIST hllist)
{
return hllist->count;
}
#endif
/* llist.c */
/* llist.c */
#include <stdio.h>
#include <stdlib.h>
#include "llist.h"
/* static Functions Prototypes */
static bool disp(DATATYPE *val);
/* Function Definitions */
HLLIST create_llist(void)
{
HLLIST hllist;
if ((hllist = (HLLIST)malloc(sizeof(LLIST))) == NULL)
return NULL;
hllist->head.next = &hllist->head;
hllist->tail = &hllist->head;
hllist->count = 0;
return hllist;
}
NODE *insert_next(HLLIST hllist, NODE *node, DATATYPE val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = val;
if (node == hllist->tail)
hllist->tail = new_node;
new_node->next = node->next;
node->next = new_node;
++hllist->count;
return new_node;
}
NODE *insertp_next(HLLIST hllist, NODE *node, const DATATYPE *val)
{
NODE *new_node;
if ((new_node = (NODE *)malloc(sizeof(NODE))) == NULL)
return NULL;
new_node->val = *val;
if (node == hllist->tail)
hllist->tail = new_node;
new_node->next = node->next;
node->next = new_node;
++hllist->count;
return new_node;
}
NODE *add_tail(HLLIST hllist, DATATYPE val)
{
return insert_next(hllist, hllist->tail, val);
}
NODE *addp_tail(HLLIST hllist, const DATATYPE *val)
{
return insertp_next(hllist, hllist->tail, val);
}
NODE *add_head(HLLIST hllist, DATATYPE val)
{
return insert_next(hllist, &hllist->head, val);
}
NODE *addp_head(HLLIST hllist, const DATATYPE *val)
{
return insertp_next(hllist, &hllist->head, val);
}
void remove_next(HLLIST hllist, NODE *node)
{
NODE *next_node;
if (node == hllist->tail)
return;
if (node->next == hllist->tail)
hllist->tail = node;
next_node = node->next;
node->next = next_node->next;
--hllist->count;
free(next_node);
}
void remove_head(HLLIST hllist)
{
remove_next(hllist, &hllist->head);
}
DATATYPE *getp_item(HLLIST hllist, size_t index)
{
NODE *node;
if (index >= hllist->count)
return NULL;
node = hllist->head.next;
for (size_t i = 0; i < index; ++i)
node = node->next;
return &node->val;
}
bool walk_llist(HLLIST hllist, bool (*proc)(DATATYPE *))
{
bool retval = true;
bool def_flag = false;
if (proc == NULL) {
proc = disp;
def_flag = true;
}
for (NODE *node = hllist->head.next; node != &hllist->head; node = node->next)
if (!proc(&node->val)) {
retval = false;
break;
}
if (def_flag)
putchar('\n');
return retval;
}
void clear_llist(HLLIST hllist)
{
NODE *node, *temp_node;
node = hllist->head.next;
while (node != &hllist->head) {
temp_node = node->next;
free(node);
node = temp_node;
}
hllist->head.next = &hllist->head;
hllist->tail = &hllist->head;
hllist->count = 0;
}
void destroy_llist(HLLIST hllist)
{
NODE *node, *temp_node;
node = hllist->head.next;
while (node != &hllist->head) {
temp_node = node->next;
free(node);
node = temp_node;
}
free(hllist);
}
static bool disp(DATATYPE *val)
{
printf("%d ", *val);
fflush(stdout);
return true;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı
krtik kodları ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include <vector>
void ExitSys(LPCSTR lpszMsg);
DWORD __stdcall ThreadProc1(LPVOID lpvParam);
DWORD __stdcall ThreadProc2(LPVOID lpvParam);
CRITICAL_SECTION g_cs;
std::vector<int> g_v;
int main(void)
{
HANDLE hThread1, hThread2;
DWORD dwThreadID1, dwThreadID2;
int i;
srand(time(NULL));
InitializeCriticalSection(&g_cs);
if ((hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, &dwThreadID1)) == NULL)
ExitSys("CreateThread");
if ((hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, &dwThreadID2)) == NULL)
ExitSys("CreateThread");
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
CloseHandle(hThread1);
CloseHandle(hThread2);
DeleteCriticalSection(&g_cs);
return 0;
}
DWORD __stdcall ThreadProc1(LPVOID lpvParam)
{
int i;
for (i = 0; i < 1000; ++i) {
EnterCriticalSection(&g_cs);
g_v.push_back(i);
LeaveCriticalSection(&g_cs);
}
return 0;
}
DWORD __stdcall ThreadProc2(LPVOID lpvParam)
{
int i;
for (i = 0; i < 1000; ++i) {
EnterCriticalSection(&g_cs);
g_v.push_back(i);
LeaveCriticalSection(&g_cs);
}
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Kritik kod oluşturmak için kullanı ı ı
nesneleri pek çok işletim sisteminde benzer bir biçimde bulunmaktadı
halde mutex nesneleri hem Windows, hem UNIX/Linux hem de macOS sistemlerinde benzer biçimde bulunmaktadı
Mutex nesnelerinin thread temelinde bir "sahipliği (ownership)" vardı ı
o mutex nesnesini kilitlemiştir. Başka bir thread mutex nesnesinin sahipliğine almaya çalı ı ı
blokede bekler. Mutex nesnesinin sahipliğini nesnenin sahipliğin almı ı
sahipliğini almı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows'ta mutex nesneleri hem aynı ı ı ı ı
kullanı ı ı
nesnelerinden daha hı ı ı ı
Windows'ta mutex nesneleri şöyle kullanı ı
1) Önce mutex nesnesi CreateMutex isimli API fonksiyonuyla yaratı ı ı ı ı
CreateMutex fonksiyonun prototipi şöyledir:
HANDLE CreateMutex(
LPSECURITY_ATTRIBUTES lpMutexAttributes,
BOOL bInitialOwner,
LPCTSTR lpName
);
Fonksiyonun birinci parametresi mutex nesnesinin güvenlik bilgilerini belirlemek için kullanı ı
(Windows'ta mutex nesneleri birer kernel nesnesidir. Tüm kernel nesnelerinin SECURITY_ATTRIBUTES türünden bir güvenlik parametresi vardı
Bu konu oldukça karmaşı ı ı
geçilirse mutex nesnesini yaratan thread aynı ı ı
olarak FALSE biçiminde geçilmektedir. Fonksiyonun son parametresi mutex nesnesi farklı ı ı
eden ismi belirtmektedir. Bu isim programcı ı ı ı
yapı ı ı ı ı ı
NULL adrese geri dönmektedir.
Eğer aynı ı ı
bir değişkene atanmalı ı ı ı
Örneğin:
HANDLE g_hMutex;
...
if ((g_hMutex = CreateMutex(NULL, FALSE, NULL)) == NULL)
ExitSys("CreateMutex");
2) Kritik kod aşağı ı ı
WaitForSingleObject(g_hMutex, INFINITE);
...
... KRİTİK KOD
...
ReleaseMutex(g_hMutex);
WaitForSingleObject fonksiyonunu daha önce görmüştük. Bu fonksiyon (ve WaitForMultipleObjects fonksiyonu) senkronizasyon nesnelerini
beklemek için kullanı
sahipliğini başka bir thread almamı
tarafı ı ı ı ı
Böylece aynı ı
bı ı ı ı
ile geri dönmektedir.
ReleaseMutex fonksiyonu mutex nesnesinin sahipliğini bı ı ı
BOOL ReleaseMutex(
HANDLE hMutex
);
Fonksiyon mutex nesnesinin handle değerini parametre olarak alı ı ı ı ı ı ı ı
başarı ı ı ı ı
3) Mutex nesnesinin kullanı ı ı ı
"kernel nesneleri (kernel objects)" denilen tüm nesneler ortak biçimde CloseHandle fonksiyonuyla kapatı ı
Aşağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
DWORD __stdcall ThreadProc1(LPVOID lpvParam);
DWORD __stdcall ThreadProc2(LPVOID lpvParam);
void UseMachine(LPCSTR pszName);
void ExitSys(LPCSTR lpszMsg);
HANDLE g_hMutex;
int main(void)
{
HANDLE hThread1, hThread2;
DWORD dwThreadID1, dwThreadID2;
if ((g_hMutex = CreateMutex(NULL, FALSE, NULL)) == NULL)
ExitSys("CreateMutex");
if ((hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, &dwThreadID1)) == NULL)
ExitSys("CreateThread");
if ((hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, &dwThreadID2)) == NULL)
ExitSys("CreateThread");
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
CloseHandle(hThread1);
CloseHandle(hThread2);
CloseHandle(g_hMutex);
return 0;
}
DWORD __stdcall ThreadProc1(LPVOID lpvParam)
{
int i;
for (i = 0; i < 10; ++i)
UseMachine("Therad-1");
return 0;
}
DWORD __stdcall ThreadProc2(LPVOID lpvParam)
{
int i;
for (i = 0; i < 10; ++i)
UseMachine("Thread-2");
return 0;
}
void UseMachine(LPCSTR pszName)
{
WaitForSingleObject(g_hMutex, INFINITE);
printf("-------------------\n");
printf("%s: 1. Step\n", pszName);
Sleep(rand() % 500);
printf("%s: 2. Step\n", pszName);
Sleep(rand() % 500);
printf("%s: 3. Step\n", pszName);
Sleep(rand() % 500);
printf("%s: 4. Step\n", pszName);
Sleep(rand() % 500);
printf("%s: 5. Step\n", pszName);
Sleep(rand() % 500);
ReleaseMutex(g_hMutex);
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows'ta mutex nesneleri farklı ı
fonksiyonunun üçüncü (son) parametresine mutex nesnesi için bir isim girilir. İki farklı
aynı ı ı ı ı ı ı
fonksiyonu son parametresiyle belirtilen isimde daha önce bir mutex nesnesi yaratı ı ı ı
mutex nesnesi açmı ı ı ı ı ı
yaratacak diğer yaratı ı ı
nesnesi zaten başkaları ı ı ı ı ı ı
Pekiyi farklı ı ı ı
ortak veriler üzerinde işlem yapı ı ı ı ı
nesneleriyle senkronize edilmesi gerekebilmektedir.
Windows sistemlerinde mutex nesneleri "özyinelemeli (recursive)" davranı ı
nesnesinin thread tarafı ı ı ı ı ı
Örneğin:
void foo(void)
{
...
WaitForSingleObject(g_hMutex, INFINITE);
...
bar();
...
ReleaseMutex(g_hMutex);
...
}
void bar(void)
{
...
WaitForSingleObject(g_hMutex, INFINITE);
...
...
...
ReleaseMutex(g_hMutex);
...
}
Burada programcı ı ı ı ı ı ı ı ı ı ı
aynı ı ı ı
sahipliğini ne kadar almı ı ı ı
Aşağı ı ı ı ı ı ı ı ı
durumda bu sayaç değeri yanlı ı ı ı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* prog1.c */
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#define SHARED_MEMORY_NAME "MySharedMemory"
#define MUTEX_NAME "MyMutexObject"
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hFileMapping;
HANDLE hMutex;
long long *pCount;
if ((hFileMapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, SHARED_MEMORY_NAME)) == NULL)
ExitSys("CreateFileMapping");
if ((pCount = (long long *) MapViewOfFile(hFileMapping, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 4096)) == NULL)
ExitSys("MapViewOfFile");
if ((hMutex = CreateMutex(NULL, FALSE, MUTEX_NAME)) == NULL)
ExitSys("CreateMutex");
for (long long i = 0; i < 10000000; ++i) {
WaitForSingleObject(hMutex, INFINITE);
++*pCount;
ReleaseMutex(hMutex);
}
printf("Press ENTER to continue...\n");
getchar();
printf("%lld\n", *pCount);
UnmapViewOfFile(pCount);
CloseHandle(hFileMapping);
getchar();
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/* prog2.c */
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#define SHARED_MEMORY_NAME "MySharedMemory"
#define MUTEX_NAME "MyMutexObject"
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hFileMapping;
HANDLE hMutex;
long long *pCount;
if ((hFileMapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, SHARED_MEMORY_NAME)) == NULL)
ExitSys("CreateFileMapping");
if ((pCount = (long long *)MapViewOfFile(hFileMapping, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 4096)) == NULL)
ExitSys("MapViewOfFile");
if ((hMutex = CreateMutex(NULL, FALSE, MUTEX_NAME)) == NULL)
ExitSys("CreateMutex");
for (long long i = 0; i < 10000000; ++i) {
WaitForSingleObject(hMutex, INFINITE);
++*pCount;
ReleaseMutex(hMutex);
}
UnmapViewOfFile(pCount);
CloseHandle(hFileMapping);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı
mutex nesneleri kullanı ı ı ı
tasarlandı ı ı ı ı ı
mutex nesneleri prosesler arası ı
UNIX/Linux sistemlerinde mutex nesneleri şu adı ı ı
1) Henüz thread'ler yaratı ı ı
#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
Fonksiyonun birinci parametresi pthread_mutex_t türünden bir nesnenin adresini almaktadı ı
Buna mutex nesnesi diyebiliriz. pthread_mutex_t bir yapı ı ı ı
senkronizasyon uygulamak için bu nesneyi global düzeyde ranı ı ı ı ı
özelliklerini belirlemek için kullanı ı ı ı
Biz bu kursta mutex nesnelerinin özellikleri üzerinde durmayacağı ı ı ı ı
errno değerine geri dönmektedir. Örneğin:
pthread_mutex_t g_mutex;
...
if ((result = pthread_mutex_init(&g_mutex, NULL)) != 0)
exit_sys_errno("pthread_mutex_init", result);
Mutex nesnelerine pthread_mutex_init yerine doğrudan PTHREAD_MUTEX_INITIALIZER makrosuyla da ilkdeğer verilebilmektedir. Örneğin:
pthread_mutex_t g_mutex = PTHERAD_MUTEX_INIALIZER;
2) Kritik kod pthread_muutex_lock ve pthread_mutex_unlock çağrı ı ı
pthread_mutex_lock(&g_mutex);
...
... KRİTİK KOD
...
pthread_mutex_unlock(&g_mutex);
Bir thread pthread_mutex_lock fonksiyonuna girdiğinde eğer mutex'in sahipliği başka bir thread tarafı ı ı
bı ı ı
kritik koda giriş yapar. Nesnenin sahipliği pthread_mutex_unlock fnksiyonuyla bı ı ı ı
#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
Fonksiyonlar mutex nesnesinin adresini parametre olarak alı ı ı ı ı
dönerler.
3) Mutex ile çalı
#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);
Fonksiyon mutex nesnesinin adresini parametre olarak alı ı ı ı ı
Aslı ı ı ı ı
olabilir.
Aşağı ı ı ı ı ı
de bu sayacı ı ı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void *thread_proc1(void *param);
void *thread_proc2(void *param);
void exit_sys_errno(const char *msg, int eno);
pthread_mutex_t g_mutex;
int g_count;
int main(void)
{
pthread_t tid1, tid2;
int result;
if ((result = pthread_mutex_init(&g_mutex, NULL)) != 0)
exit_sys_errno("pthread_mutex_init", result);
if ((result = pthread_create(&tid1, NULL, thread_proc1, NULL)) != 0)
exit_sys_errno("pthread_create", result);
if ((result = pthread_create(&tid2, NULL, thread_proc2, NULL)) != 0)
exit_sys_errno("pthread_create", result);
if ((result = pthread_join(tid1, NULL)) != 0)
exit_sys_errno("pthread_join", result);
if ((result = pthread_join(tid2, NULL)) != 0)
exit_sys_errno("pthread_join", result);
if ((result = pthread_mutex_destroy(&g_muex)) != 0)
exit_sys_errno("pthread_mutex_destroy", result);
printf("%d\n", g_count);
return 0;
}
void *thread_proc1(void *param)
{
int result;
for (int i = 0; i < 1000000; ++i) {
if ((result = pthread_mutex_lock(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_lock", result);
++g_count;
if ((result = pthread_mutex_unlock(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_lock", result);
}
return NULL;
}
void *thread_proc2(void *param)
{
int result;
for (int i = 0; i < 1000000; ++i) {
if ((result = pthread_mutex_lock(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_lock", result);
++g_count;
if ((result = pthread_mutex_unlock(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_lock", result);
}
return NULL;
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <pthread.h>
void *thread_proc1(void *param);
void *thread_proc2(void *param);
void exit_sys_errno(const char *msg, int eno);
void use_machine(const char *name);
pthread_mutex_t g_mutex;
int main(void)
{
pthread_t tid1, tid2;
int result;
srand(time(NULL));
if ((result = pthread_mutex_init(&g_mutex, NULL)) != 0)
exit_sys_errno("pthread_mutex_init", result);
if ((result = pthread_create(&tid1, NULL, thread_proc1, NULL)) != 0)
exit_sys_errno("pthread_create", result);
if ((result = pthread_create(&tid2, NULL, thread_proc2, NULL)) != 0)
exit_sys_errno("pthread_create", result);
if ((result = pthread_join(tid1, NULL)) != 0)
exit_sys_errno("pthread_join", result);
if ((result = pthread_join(tid2, NULL)) != 0)
exit_sys_errno("pthread_join", result);
if ((result = pthread_mutex_destroy(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_destroy", result);
return 0;
}
void use_machine(const char *name)
{
int result;
if ((result = pthread_mutex_lock(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_lock", result);
printf("-------------------\n");
printf("%s: 1. Step\n", name);
usleep(rand() % 300000);
printf("%s: 2. Step\n", name);
usleep(rand() % 300000);
printf("%s: 3. Step\n", name);
usleep(rand() % 300000);
printf("%s: 4. Step\n", name);
usleep(rand() % 300000);
printf("%s: 5. Step\n", name);
usleep(rand() % 300000);
if ((result = pthread_mutex_unlock(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_unlock", result);
}
void *thread_proc1(void *param)
{
int i;
for (i = 0; i < 10; ++i)
use_machine("Thread-1");
return NULL;
}
void *thread_proc2(void *param)
{
int i;
for (i = 0; i < 10; ++i)
use_machine("Thread-2");
return NULL;
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde mutex nesneleri default durumda özyinelemeli değildir. Bu sistemlerde mutex nesnelerin özyinelemeli yapmak için
önce pthread_mutexattr_t türünden bir nesne oluşturulur. Sonra bu nesne pthread_mutexattr_init fonksiyonuyla ilkdeğerlenir. Sonra da
pthread_mutexattr_settype fonksiyonu ile PTHREAD_MUTEX_RECURSIVE parametresi kullanı
Nihayet bu attribute nesnesi pthread_mutex_create fonksiyonunda kullanı ı
fonksiyonuyla yok edilir.Buradaki fonksiyonları
#include <pthread.h>
int pthread_mutexattr_init(pthread_mutexattr_t *attr);
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
Bu fonksiyonları ı ı ı ı
başarı ı ı
Örneğin:
pthread_mutex_t g_mutex;
...
pthread_mutexattr_t mattr;
...
if ((result = pthread_mutexattr_init(&mattr)) != 0)
exit_sys_errno("pthread_mutexattr_init", result);
if ((result = pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE)) != 0)
exit_sys_errno("pthread_mutexattr_settype", result);
if ((result = pthread_mutex_init(&g_mutex, &mattr)) != 0)
exit_sys_errno("pthread_mutex_init", result);
if ((result = pthread_mutexattr_destroy(&mattr)) != 0)
exit_sys_errno("pthread_mutexattr_destroy", result);
Mutex attribute nesnesinin yalnı ı ı ı ı ı ı ı
Tabii UNIX/Linux sistemlerinde de özyinelemeli mutex'lerin kilidini açmak için pthread_mutex_lock işlemi kadar pthread_mutex_unlock
işleminin yapı ı
Aşağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <pthread.h>
void *thread_proc1(void *param);
void *thread_proc2(void *param);
void exit_sys_errno(const char *msg, int eno);
void do_machine(const char *name);
void use_machine(const char *name);
pthread_mutex_t g_mutex;
int main(void)
{
pthread_t tid1, tid2;
int result;
pthread_mutexattr_t mattr;
srand(time(NULL));
if ((result = pthread_mutexattr_init(&mattr)) != 0)
exit_sys_errno("pthread_mutexattr_init", result);
if ((result = pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE)) != 0)
exit_sys_errno("pthread_mutexattr_settype", result);
if ((result = pthread_mutex_init(&g_mutex, &mattr)) != 0)
exit_sys_errno("pthread_mutex_init", result);
if ((result = pthread_mutexattr_destroy(&mattr)) != 0)
exit_sys_errno("pthread_mutexattr_destroy", result);
if ((result = pthread_create(&tid1, NULL, thread_proc1, NULL)) != 0)
exit_sys_errno("pthread_create", result);
if ((result = pthread_create(&tid2, NULL, thread_proc2, NULL)) != 0)
exit_sys_errno("pthread_create", result);
if ((result = pthread_join(tid1, NULL)) != 0)
exit_sys_errno("pthread_join", result);
if ((result = pthread_join(tid2, NULL)) != 0)
exit_sys_errno("pthread_join", result);
if ((result = pthread_mutex_destroy(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_destroy", result);
return 0;
}
void do_machine(const char *name)
{
int result;
if ((result = pthread_mutex_lock(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_lock", result);
use_machine(name);
if ((result = pthread_mutex_unlock(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_unlock", result);
}
void use_machine(const char *name)
{
int result;
if ((result = pthread_mutex_lock(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_lock", result);
printf("-------------------\n");
printf("%s: 1. Step\n", name);
usleep(rand() % 300000);
printf("%s: 2. Step\n", name);
usleep(rand() % 300000);
printf("%s: 3. Step\n", name);
usleep(rand() % 300000);
printf("%s: 4. Step\n", name);
usleep(rand() % 300000);
printf("%s: 5. Step\n", name);
usleep(rand() % 300000);
if ((result = pthread_mutex_unlock(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_unlock", result);
}
void *thread_proc1(void *param)
{
int i;
for (i = 0; i < 10; ++i)
do_machine("Thread-1");
return NULL;
}
void *thread_proc2(void *param)
{
int i;
for (i = 0; i < 10; ++i)
do_machine("Thread-2");
return NULL;
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde mutex nesnesini prosesler arası ı ı ı ı
gerekir. (Yani bizim pthread_mutex_t türünden nesnseyi paylaşı ı ı ı
nesnesini görecektir. Ancak ayrı ı ı ı ı
pthread_mutexattr_setpshared fonksiyonu ile belirleme yapmak gerekir. Bu fonksiyonun prototipi şöyledir:
int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared);
Fonksiyonun birinci parametresi mutex attribute nesnesinin adresini almaktadı
proseslerarası ı ı ı ı ı ı ı
Fonksiyon başarı ı ı ı ı ı
Aşağı ı ı ı ı ı ı
mutex nesnesini kullanmı ı ı ı ı ı ı ı
struct SHARED_OBJECT {
pthread_mutex_t mutex;
long long count;
};
Aşağı ı ı ı ı ı ı ı ı ı ı ı
yaratmaktadı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* prog1.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/mman.h>
#include <pthread.h>
void exit_sys(const char* msg);
void exit_sys_errno(const char *msg, int eno);
struct SHARED_OBJECT {
pthread_mutex_t mutex;
long long count;
};
int main(void)
{
int fdshm;
int result;
void *shmaddr;
pthread_mutexattr_t mattr;
struct SHARED_OBJECT *so;
if ((fdshm = shm_open("/sample_shared_memory_name", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == -1)
exit_sys("shm_open");
if (ftruncate(fdshm, 4096) == -1)
exit_sys("ftruncate");
if ((shmaddr = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fdshm, 0)) == MAP_FAILED)
exit_sys("mmap");
so = (struct SHARED_OBJECT*)shmaddr;
so->count = 0;
if ((result = pthread_mutexattr_init(&mattr)) != 0)
exit_sys_errno("pthread_mutexattr_init", result);
if ((result = pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED)) != 0)
exit_sys_errno("pthread_mutexattr_setpshared", result);
if ((result = pthread_mutex_init(&so->mutex, &mattr)) != 0)
exit_sys_errno("pthread_mutex_init", result);
if ((result = pthread_mutexattr_destroy(&mattr)) != 0)
exit_sys_errno("pthread_mutexattr_destroy", result);
for (long long int i = 0; i < 1000000000; ++i) {
if ((result = pthread_mutex_lock(&so->mutex)) != 0)
exit_sys_errno("pthread_mutex_lock", result);
++so->count;
if ((result = pthread_mutex_unlock(&so->mutex)) != 0)
exit_sys_errno("pthread_mutex_unlock", result);
}
printf("Press ENTER to continue...\n");
getchar();
printf("%lld\n", so->count);
if ((result = pthread_mutex_destroy(&so->mutex)) != 0)
exit_sys_errno("pthread_mutex_destroy", result);
if (munmap(shmaddr, 4096) == -1)
exit_sys("munmap");
close(fdshm);
if (shm_unlink("/sample_shared_memory_name") == -1)
exit_sys("shm_unlink");
return 0;
}
void exit_sys(const char* msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/* prog2.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/mman.h>
#include <pthread.h>
void exit_sys(const char* msg);
void exit_sys_errno(const char *msg, int eno);
struct SHARED_OBJECT {
pthread_mutex_t mutex;
long long int count;
};
int main(void)
{
int fdshm;
int result;
void *shmaddr;
struct SHARED_OBJECT *so;
if ((fdshm = shm_open("/sample_shared_memory_name", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == -1)
exit_sys("shm_open");
if ((shmaddr = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fdshm, 0)) == MAP_FAILED)
exit_sys("mmap");
so = (struct SHARED_OBJECT*)shmaddr;
for (long long int i = 0; i < 1000000000; ++i) {
if ((result = pthread_mutex_lock(&so->mutex)) != 0)
exit_sys_errno("pthread_mutex_lock", result);
++so->count;
if ((result = pthread_mutex_unlock(&so->mutex)) != 0)
exit_sys_errno("pthread_mutex_unlock", result);
}
if (munmap(shmaddr, 4096) == -1)
exit_sys("munmap");
close(fdshm);
return 0;
}
void exit_sys(const char* msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
83. Ders 27/04/2024 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Diğer çok kullanı ı
eskiden trafik ı ı ı ı ı ı ı
nesneleridir. Bir kritk koda en fazla N tane thread'in (akı ı ı ı
nesneleri ve Windows'taki CRITCAL_SECTION nesneleri kritik koda yalnı ı ı ı
bilimlerinin öncülerinden Edsger Dijkstra ("edsger daystra" gibi okunuyor) tarafı
Bir kritik koda birden fazla akı ı ı ı ı ı
İşte semaphore'lar özellikle "kaynak paylaşı ı ı ı ı
thread'e paylaştı ı
makineler doluysa makine talep eden thread makinelerden biri boşaltı ı
tipik olarak semaphore nesneleriyle çözülmektedir.
Semaphore nesnelerinin bir sayacı ı ı
sayacı ı ı ı ı ı
olacaktı ı ı ı
0 olacaktı ı ı ı
bir thread kritik koddan çı ı ı ı ı ı ı ı
kodda şu anda 2 thread vardı ı ı
Böylece semaphore sayacı ı ı ı
kodun içerisinde "en fazla" o kadar thread bulunacaktı
Bşlangı ı
denilmektedir. İkili semaphore'lar mutex nesnelerine benzese de onlardan önemli bir farklı ı
(yani kilidini) ancak sahipliğini almı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde semaphore nesneleri şu adı ı ı
1) Önce semaphore nesnesi CreateSemaphore API fonksiyonuyla yaratı ı
HANDLE CreateSemaphore(
LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
LONG lInitialCount,
LONG lMaximumCount,
LPCSTR lpName
);
Fonksiyonun birinci parametresi semaphore nesnesinin güvenlik bilgilerini belirtir. Bu parametre NULL adres geçilebilir. İkinci parametre
semaphore sayacı ı ı ı ı
Genellikle ikinci ve üçüncü parametreye aynı ı ı
belirtmektedir. Eğer semaphore nesnesi aynı ı ı
başarı ı ı ı
Semaphore nesnesi aynı ı ı
global bir değişkende tutulmalı ı
HANDLE g_hSemaphore;
...
if ((g_hSemaphore = CreateSemaphore(NULL, 1, 1, NULL)) == NULL)
ExitSys("CreateSemaphore");
2) Kritik kod aşağı ı
WaitForSingleObject(g_hSemaphore, INFINITE);
...
... KRİTİK KOD
...
ReleaseSemaphore(g_hSemahore, 1, NULL);
Burada akı ı
semaphore sayacı ı
ReleaseSemaphore fonksiyonu semaphore sayacı ı ı ı
ReleaseSemaphore fonksiyonun prototipi şöyledir:
BOOL ReleaseSemaphore(
HANDLE hSemaphore,
LONG lReleaseCount,
LPLONG lpPreviousCount
);
Fonksiyonun birinci parametresi semaphore nesnesinin handle değerini almaktadı ı ı
değer hemen her zaman 1 olur) son parametre semaphore sayacı ı ı
NULL adres biçiminde geçilirse önceki sayaç değeri yerleştirilmez. Fonksiyon başarı ı ı ı ı ı ı ı
bir değere geri dönmektedir. Örneğin:
for (int i = 0; i < 1000000; ++i) {
WaitForSingleObject(g_hSemaphore, INFINITE);
...
...
...
ReleaseSemaphore(g_hSemaphore, 1, NULL);
}
3) Semaphore kullanı ı
Örneğin:
CloseHandle(g_hSemaphore);
Aşağı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
DWORD __stdcall ThreadProc1(LPVOID lpvParam);
DWORD __stdcall ThreadProc2(LPVOID lpvParam);
void ExitSys(LPCSTR lpszMsg);
HANDLE g_hSemaphore;
int g_count;
int main(void)
{
HANDLE hThread1, hThread2;
DWORD dwThreadID1, dwThreadID2;
if ((g_hSemaphore = CreateSemaphore(NULL, 1, 1, NULL)) == NULL)
ExitSys("CreateSemaphore");
if ((hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, &dwThreadID1)) == NULL)
ExitSys("CreateThread");
if ((hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, &dwThreadID2)) == NULL)
ExitSys("CreateThread");
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
CloseHandle(g_hSemaphore);
CloseHandle(hThread1);
CloseHandle(hThread2);
printf("%d\n", g_count);
return 0;
}
DWORD __stdcall ThreadProc1(LPVOID lpvParam)
{
for (int i = 0; i < 1000000; ++i) {
WaitForSingleObject(g_hSemaphore, INFINITE);
++g_count;
ReleaseSemaphore(g_hSemaphore, 1, NULL);
}
return 0;
}
DWORD __stdcall ThreadProc2(LPVOID lpvParam)
{
for (int i = 0; i < 1000000; ++i) {
WaitForSingleObject(g_hSemaphore, INFINITE);
++g_count;
ReleaseSemaphore(g_hSemaphore, 1, NULL);
}
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde tı ı ı ı ı ı
Eskiden beri var olan klasik semaphore fonksiyonları ı ı ı ı ı
oldukça zordur. 90'lı ı ı ı ı ı
eklenmiştir. Artı ı ı ı ı
POSIX standartları ı ı ı
fonksiyonları ı ı ı ı ı ı
hem aynı ı ı ı ı
Biz kursumuzda modern POSIX semaphore fonksiyonları ı ı
kursları ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
POSIX semaphore fonksiyonları ı ı ı ı
1) POSIX semapore nesneleri sem_t türüyle temsil edilmektedir. sem_t bir yapı ı ı
prosesin thread'leri arası ı ı ı
verilir. sem_init fonksiyonunun prototipi şöyledir:
#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
Fonksiyonun birinci parametresi sem_t türünden nesnenin adresini almaktadı ı
paylaşı ı ı ı ı ı ı ı ı ı ı ı
sı ı ı ı ı ı
Fonlsiyonun üçüncü parametresi semaphore sayacı ı ı ı ı
belirtir. Fonksiyon başarı ı ı ı
(Diğer thread fonksiyonları ı ı ı ı
Eğer semaphore nesnesi prosesler arası ı
üzerinde daha sonra durulacaktı
2) Kritik kod sem_wait ve sem_post çağrı ı ı
sem_wait(&g_sem);
...
... <KRİTİK KOD>
...
sem_post(&g_sem);
Akı ı ı
bekler. Eğer semaphore sayacı ı ı
semaphore sayacı ı ı ı ı
#include <semaphore.h>
int sem_wait(sem_t *sem);
int sem_post(sem_t *sem);
Fonksiyonlar semaphore nesnelerinin adresini parametre olarak almakta, başarı ı ı ı ı ı
geri dönmektedirler. Yine başarı ı ı
3) Semaphore nesnesinin kullanı ı
#include <semaphore.h>
int sem_destroy(sem_t *sem);
Fonksiyon semaphore nesnesinin adresini parametre olarak alı ı ı ı ı
Başarı ı ı ı ı
yaratı ı ı ı ı
Aşağı ı ı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
void *thread_proc1(void *param);
void *thread_proc2(void *param);
void exit_sys(const char* msg);
void exit_sys_errno(const char *msg, int eno);
sem_t g_sem;
int g_count;
int main(void)
{
pthread_t tid1, tid2;
int result;
if (sem_init(&g_sem, 0, 1) == -1)
exit_sys("sem_init");
if ((result = pthread_create(&tid1, NULL, thread_proc1, NULL)) != 0)
exit_sys_errno("pthread_create", result);
if ((result = pthread_create(&tid2, NULL, thread_proc2, NULL)) != 0)
exit_sys_errno("pthread_create", result);
if ((result = pthread_join(tid1, NULL)) != 0)
exit_sys_errno("pthread_join", result);
if ((result = pthread_join(tid2, NULL)) != 0)
exit_sys_errno("pthread_join", result);
if (sem_destroy(&g_sem) == -1)
exit_sys("sem_destroy");
printf("%d\n", g_count);
return 0;
}
void *thread_proc1(void *param)
{
for (int i = 0; i < 1000000; ++i) {
if (sem_wait(&g_sem) == -1)
exit_sys("sem_wait");
++g_count;
if (sem_post(&g_sem) == -1)
exit_sys("sem_post");
}
return NULL;
}
void *thread_proc2(void *param)
{
for (int i = 0; i < 1000000; ++i) {
if (sem_wait(&g_sem) == -1)
exit_sys("sem_wait");
++g_count;
if (sem_post(&g_sem) == -1)
exit_sys("sem_post");
}
return NULL;
}
void exit_sys(const char* msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
void *thread_proc1(void* param);
void *thread_proc2(void* param);
void do_machine(const char* name);
void exit_sys(const char *msg);
void exit_sys_errno(const char *msg, int eno);
sem_t g_sem;
int main(void)
{
int result;
pthread_t tid1, tid2;
srand(time(NULL));
if (sem_init(&g_sem, 0, 1) == -1)
exit_sys("sem_init");
if ((result = pthread_create(&tid1, NULL, thread_proc1, NULL)) != 0)
exit_sys_errno("pthread_create", result);
if ((result = pthread_create(&tid2, NULL, thread_proc2, NULL)) != 0)
exit_sys_errno("pthread_create", result);
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
sem_destroy(&g_sem);
return 0;
}
void *thread_proc1(void *param)
{
int i;
for (i = 0; i < 10; ++i)
do_machine("thread-1");
return NULL;
}
void *thread_proc2(void *param)
{
int i;
for (i = 0; i < 10; ++i)
do_machine("thread-2");
return NULL;
}
void do_machine(const char *name)
{
if (sem_wait(&g_sem) == -1)
exit_sys("sem_wait");
printf("---------------\n");
printf("1) %s\n", name);
usleep(rand() % 300000);
printf("2) %s\n", name);
usleep(rand() % 300000);
printf("3) %s\n", name);
usleep(rand() % 300000);
printf("4) %s\n", name);
usleep(rand() % 300000);
printf("5) %s\n", name);
usleep(rand() % 300000);
if (sem_post(&g_sem) == -1)
exit_sys("sem_post");
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Üretici-Tüketici Problemi (Producer-Consumer Problem) gerçek hayatta en sı ı ı
thread'lerden biri (üretici thread) bir döngü içerisinde bir değer üretir ve onu paylaşı ı
(tüketici thread) bir döngü içerisinde onu oradan alı ı ı
değeri almdan paylaşı ı
yeni bir değer koymadan paylaşı ı ı
uygun biçimde senkronize edilmesi gerekmektedir. Öyle ki üretici thread tüketici thread eski değeri almadan paylaşı
yerleştirmemeli, tüketici thread de üretici thread paylaşı ı ı
Üretici-Tüketici probleminde aslı
thread tüketici olabilir. Ancak problemin en basit halinde tek üretici ve tek tüketici vardı
Pekiyi üretici-tüketici probleminde neden üretici thread elde ettiği değeri kendisi işlemiyor da onu tüketici thread'e pas edip onun
işlemesini sağlı ı ı ı ı ı ı
ve sonra yeni değeri elde edip işleyecektir. Ancak thread'lerden biri değeri elde ederken diğeri onu işlerse işlemler toplamda daha hı ı
yürütülmüş olur.
Üretici-Tüketici probleminde paylaşı
Böylece üretici ve tüketici birbirlerini daha az bekler. Uygulamada genellikle paylaşı
edilmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Üretici-Tüketici problemleri tipik olarak semaphore nesneleriyle çözülmektedir. Problemin çözümü için iki semaphore nesnesi yatatı ı
Semaphore'lardan biri üretici semaphore'u diğeri ise tüketici semaphore'u olur. Başlangı
ise 0'a kurulur:
sem_t g_sem_producer;
sem_t g_sem_consumer;
...
sem_init(&g_sem_producer, 0, 1);
sem_init(&g_sem_consumer, 0, 0);
Üretici ve tüketici döngülerinin temsili biçimi şöyledir:
ÜRETİCİ
-------
for (;;) {
<değeri elde ediliyor>
sem_wait(&g_sem_producer);
<değer paylaşı
sem_post(&g_sem_consumer);
}
TÜKETİCİ
--------
for (;;) {
sem_wait(&g_sem_consumer);
<değer paylaşı ı ı
sem_post(&g_sem_producer);
<değer kullanı ı
}
Burada üretici semaphore'unun başlangı ı
alana bı ı ı ı
Üretici thread'in tüketicinin semaphore sayacı ı ı ı ı ı ı
Böylece üretici tüketiciyi tüketici de üreticiyi sem_wait fonksiyonundan geçirmektedir. Bunu tbir tahteravalliye benzetebilirsiniz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aaşğı
üretici thread 0'dan 100'a kadar sayı ı ı ı
beklemelerle almaktadı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
void *thread_proc_producer(void* param);
void *thread_proc_consumer(void* param);
void exit_sys(const char *msg);
void exit_sys_errno(const char *msg, int eno);
sem_t g_sem_producer;
sem_t g_sem_consumer;
int g_shared;
int main(void)
{
int result;
pthread_t tid1, tid2;
srand(time(NULL));
if (sem_init(&g_sem_producer, 0, 1) == -1)
exit_sys("sem_init");
if (sem_init(&g_sem_consumer, 0, 0) == -1)
exit_sys("sem_init");
if ((result = pthread_create(&tid1, NULL, thread_proc_producer, NULL)) != 0)
exit_sys_errno("pthread_create", result);
if ((result = pthread_create(&tid2, NULL, thread_proc_consumer, NULL)) != 0)
exit_sys_errno("pthread_create", result);
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
sem_destroy(&g_sem_producer);
sem_destroy(&g_sem_consumer);
return 0;
}
void *thread_proc_producer(void *param)
{
int val;
val = 0;
for (;;) {
usleep(rand() % 300000);
if (sem_wait(&g_sem_producer) == -1)
exit_sys("sem_wait");
g_shared = val;
if (sem_post(&g_sem_consumer) == -1)
exit_sys("sem_post");
if (val == 99)
break;
++val;
}
return NULL;
}
void *thread_proc_consumer(void *param)
{
int val;
for (;;) {
if (sem_wait(&g_sem_consumer) == -1)
exit_sys("sem_wait");
val = g_shared;
if (sem_post(&g_sem_producer) == -1)
exit_sys("sem_post");
printf("%d ", val);
fflush(stdout);
usleep(rand() % 300000);
if (val == 99)
break;
}
putchar('\n');
return NULL;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde üretici-tüketici probleminin semaphore nesneleriyle çözümüne ilişkin bir örnek aşağı ı
verdiğimiz UNIX/Linux örneğinin Windows eşdeğeri gibidir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
DWORD __stdcall ThreadProducer(LPVOID lpvParam);
DWORD __stdcall ThreadConsumer(LPVOID lpvParam);
HANDLE g_hSemProducer;
HANDLE g_hSemConsumer;
int g_shared;
int main(void)
{
HANDLE hThreadProducer, hThreadConsumer;
DWORD dwThreadIDProducer, dwThreadIDConsumer;
srand(time(NULL));
if ((g_hSemProducer = CreateSemaphore(NULL, 1, 1, NULL)) == NULL)
ExitSys("CreateSemaphore");
if ((g_hSemConsumer = CreateSemaphore(NULL, 0, 1, NULL)) == NULL)
ExitSys("CreateSemaphore");
if ((hThreadProducer = CreateThread(NULL, 0, ThreadProducer, NULL, 0, &dwThreadIDProducer)) == NULL)
ExitSys("CreateThread");
if ((hThreadConsumer = CreateThread(NULL, 0, ThreadConsumer, NULL, 0, &dwThreadIDConsumer)) == NULL)
ExitSys("CreateThread");
WaitForSingleObject(hThreadProducer, INFINITE);
WaitForSingleObject(hThreadConsumer, INFINITE);
CloseHandle(hThreadProducer);
CloseHandle(hThreadConsumer);
CloseHandle(g_hSemProducer);
CloseHandle(g_hSemConsumer);
return 0;
}
DWORD __stdcall ThreadProducer(LPVOID lpvParam)
{
int val;
val = 0;
for (;;) {
Sleep(rand() % 300);
WaitForSingleObject(g_hSemProducer, INFINITE);
g_shared = val;
ReleaseSemaphore(g_hSemConsumer, 1, NULL);
if (val == 99)
break;
++val;
}
return 0;
}
DWORD __stdcall ThreadConsumer(LPVOID lpvParam)
{
int val;
for (;;) {
WaitForSingleObject(g_hSemConsumer, INFINITE);
val = g_shared;
ReleaseSemaphore(g_hSemProducer, 1, NULL);
printf("%d ", val);
fflush(stdout);
if (val == 99)
break;
Sleep(rand() % 300);
}
putchar('\n');
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı
bekleme olası ı ı ı ı ı ı
boşken" bekleyecektir.
Üretici-Tüketici probleminin kuyruklu versiyonunda üretici semaphore sayacı ı ı ı
(Yani tüketici hiç çalı
Aşağı ı
erişimler için senkronize edilmesine gerek yoktur. Çünkü aslı ı ı
erişmediği görülecektir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
#define QUEUE_BUFFER_SIZE 10
void *thread_proc_producer(void* param);
void *thread_proc_consumer(void* param);
void exit_sys(const char *msg);
void exit_sys_errno(const char *msg, int eno);
sem_t g_sem_producer;
sem_t g_sem_consumer;
int g_qbuf[QUEUE_BUFFER_SIZE];
int g_head;
int g_tail;
int main(void)
{
int result;
pthread_t tid1, tid2;
srand(time(NULL));
if (sem_init(&g_sem_producer, 0, QUEUE_BUFFER_SIZE) == -1)
exit_sys("sem_init");
if (sem_init(&g_sem_consumer, 0, 0) == -1)
exit_sys("sem_init");
if ((result = pthread_create(&tid1, NULL, thread_proc_producer, NULL)) != 0)
exit_sys_errno("pthread_create", result);
if ((result = pthread_create(&tid2, NULL, thread_proc_consumer, NULL)) != 0)
exit_sys_errno("pthread_create", result);
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
sem_destroy(&g_sem_producer);
sem_destroy(&g_sem_consumer);
return 0;
}
void *thread_proc_producer(void *param)
{
int val;
val = 0;
for (;;) {
usleep(rand() % 300000);
if (sem_wait(&g_sem_producer) == -1)
exit_sys("sem_wait");
g_qbuf[g_tail++] = val;
g_tail = g_tail % QUEUE_BUFFER_SIZE; /* burası ı ı ı
if (sem_post(&g_sem_consumer) == -1)
exit_sys("sem_post");
if (val == 99)
break;
++val;
}
return NULL;
}
void *thread_proc_consumer(void *param)
{
int val;
for (;;) {
if (sem_wait(&g_sem_consumer) == -1)
exit_sys("sem_wait");
val = g_qbuf[g_head++];
g_head = g_head % QUEUE_BUFFER_SIZE; /* burası ı ı ı
if (sem_post(&g_sem_producer) == -1)
exit_sys("sem_post");
printf("%d ", val);
fflush(stdout);
usleep(rand() % 300000);
if (val == 99)
break;
}
putchar('\n');
return NULL;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#define QUEUE_BUFFER_SIZE 10
void ExitSys(LPCSTR lpszMsg);
DWORD __stdcall ThreadProducer(LPVOID lpvParam);
DWORD __stdcall ThreadConsumer(LPVOID lpvParam);
HANDLE g_hSemProducer;
HANDLE g_hSemConsumer;
int g_queueBuf[QUEUE_BUFFER_SIZE];
size_t g_head;
size_t g_tail;
int main(void)
{
HANDLE hThreadProducer, hThreadConsumer;
DWORD dwThreadIDProducer, dwThreadIDConsumer;
srand(time(NULL));
if ((g_hSemProducer = CreateSemaphore(NULL, QUEUE_BUFFER_SIZE, QUEUE_BUFFER_SIZE, NULL)) == NULL)
ExitSys("CreateSemaphore");
if ((g_hSemConsumer = CreateSemaphore(NULL, 0, QUEUE_BUFFER_SIZE, NULL)) == NULL)
ExitSys("CreateSemaphore");
if ((hThreadProducer = CreateThread(NULL, 0, ThreadProducer, NULL, 0, &dwThreadIDProducer)) == NULL)
ExitSys("CreateThread");
if ((hThreadConsumer = CreateThread(NULL, 0, ThreadConsumer, NULL, 0, &dwThreadIDConsumer)) == NULL)
ExitSys("CreateThread");
WaitForSingleObject(hThreadProducer, INFINITE);
WaitForSingleObject(hThreadConsumer, INFINITE);
CloseHandle(hThreadProducer);
CloseHandle(hThreadConsumer);
CloseHandle(g_hSemProducer);
CloseHandle(g_hSemConsumer);
return 0;
}
DWORD __stdcall ThreadProducer(LPVOID lpvParam)
{
int val;
val = 0;
for (;;) {
Sleep(rand() % 300);
WaitForSingleObject(g_hSemProducer, INFINITE);
g_queueBuf[g_tail++] = val;
g_tail = g_tail % QUEUE_BUFFER_SIZE;
ReleaseSemaphore(g_hSemConsumer, 1, NULL);
if (val == 99)
break;
++val;
}
return 0;
}
DWORD __stdcall ThreadConsumer(LPVOID lpvParam)
{
int val;
for (;;) {
WaitForSingleObject(g_hSemConsumer, INFINITE);
val = g_queueBuf[g_head++];
g_head = g_head % QUEUE_BUFFER_SIZE;
ReleaseSemaphore(g_hSemProducer, 1, NULL);
printf("%d ", val);
fflush(stdout);
if (val == 99)
break;
Sleep(rand() % 300);
}
putchar('\n');
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
84. Ders 28/04/2024 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Konunun başı ı ı
Bunun için sem_open fonksiyonu ile iki prosesin de ortak bir isimde anlaşarak semaphore nesnesini açması
prototipi şöyledir:
#include <semaphore.h>
sem_t *sem_open(const char *name, int oflag, ...);
Fonksiyon ya iki parametreyle ya da dört parametreyle kullanı ı ı ı
aşağı ı ı
sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value);
Fonksiyonun birinci parametresi prosesler arası ı ı ı
ismin "kök dizindeki bir dosya ismi gibi" oluşturulması ı ı ı
bir temsildir.) Fonksiyonun ikinci parametresi yaratı ı ı
O_CREAT
O_CREAT|O_EXCL
0
O_CREAT bayrağı ı ı ı ı ı ı ı
kullanı ı ı ı ı ı ı ı ı
semaphore nesnesi" kullanı ı ı ı ı ı ı
bu durumda fonksiyon üçünüc ve dördüncü parametreleri kullanmaktadı ı
üçüncü ve dördüncü parametreler nesne ilk kez yaratı ı ı ı ı ı
ve O_RDWR kullanı ı ı ı ı ı ı ı ı
Bu konu "UNIX Linux Sistem Programlama" kursları ı ı
sem_open fonksiyonu ile yaratı ı ı
kadar yaşamaya devam etmektedir (kernel persistent). Bu nesneyi reboot etmeden silmek için sem_unlik fonksiyonu kullanı ı
Fonksiyonun prototipi şöyledir:
#include <semaphore.h>
int sem_unlink(const char *name);
Fonksiyon isimli semaphore nesnesinin ismini parametre olarak alı ı ı ı ı
döner.
Bu fonksiyonları ı ı ı ı ı
gcc -Wall -o sample sample.c -lrt -lpthread
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı ı
"consumer" isimli iki program vardı ı ı ı ı
bellek alanı ı ı ı
çalı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
açmaktadı ı ı ı ı ı ı
bir hata rapor edilmemiştir. Örneğimizde kuyruk sistemi paylaşı ı ı ı
$ gcc -o producer producer.c -lrt -lpthread
$ gcc -o consumer consumer.c -lrt -lpthread
Programları ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* producer.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/mman.h>
#include <pthread.h>
#include <semaphore.h>
#define SHARED_MEM_NAME "/sample_shared_memory_name"
#define SEM_PRODUCER_NAME "/sample_mutex_producer_name"
#define SEM_CONSUMER_NAME "/sample_mutex_consumer_name"
#define QUEUE_BUFFER_SIZE 10
void exit_sys(const char* msg);
void exit_sys_errno(const char *msg, int eno);
struct SHARED_OBJECT {
int qbuf[QUEUE_BUFFER_SIZE];
size_t head;
size_t tail;
};
int main(void)
{
int fdshm;
sem_t *sem_producer;
sem_t *sem_consumer;
void *shmaddr;
struct SHARED_OBJECT *so;
int val;
srand(time(NULL));
if ((fdshm = shm_open(SHARED_MEM_NAME, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == -1)
exit_sys("shm_open");
if (ftruncate(fdshm, 4096) == -1) {
perror("ftruncate");
goto EXIT1;
}
if ((shmaddr = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fdshm, 0)) == MAP_FAILED) {
perror("mmap");
goto EXIT2;
}
if ((sem_producer = sem_open(SEM_PRODUCER_NAME, O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH, QUEUE_BUFFER_SIZE)) == NULL) {
perror("sem_open");
goto EXIT3;
}
if ((sem_consumer = sem_open(SEM_CONSUMER_NAME, O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH, 0)) == NULL) {
perror("sem_open");
goto EXIT4;
}
so = (struct SHARED_OBJECT *)shmaddr;
so->head = 0;
so->tail = 0;
val = 0;
for (;;) {
usleep(rand() % 300000);
if (sem_wait(sem_producer) == -1) {
perror("sem_wait");
goto EXIT5;
}
so->qbuf[so->tail++] = val;
if (sem_post(sem_consumer) == -1) {
perror("sem_wait");
goto EXIT5;
}
so->tail = so->tail % QUEUE_BUFFER_SIZE;
if (val == 99)
break;
++val;
}
EXIT5:
sem_destroy(sem_consumer);
if (sem_unlink(SEM_CONSUMER_NAME) == -1 && errno != ENOENT)
exit_sys("sem_unlink");
EXIT4:
sem_destroy(sem_producer);
if (sem_unlink(SEM_PRODUCER_NAME) == -1 && errno != ENOENT)
exit_sys("sem_unlink");
EXIT3:
if (munmap(shmaddr, 4096) == -1)
exit_sys("munmap");
EXIT2:
close(fdshm);
EXIT1:
if (shm_unlink(SHARED_MEM_NAME) == -1 && errno != ENOENT)
exit_sys("shm_unlink");
return 0;
}
void exit_sys(const char* msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/* consumer.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/mman.h>
#include <pthread.h>
#include <semaphore.h>
#define SHARED_MEM_NAME "/sample_shared_memory_name"
#define SEM_PRODUCER_NAME "/sample_mutex_producer_name"
#define SEM_CONSUMER_NAME "/sample_mutex_consumer_name"
#define QUEUE_BUFFER_SIZE 10
void exit_sys(const char* msg);
void exit_sys_errno(const char *msg, int eno);
struct SHARED_OBJECT {
int qbuf[QUEUE_BUFFER_SIZE];
size_t head;
size_t tail;
};
int main(void)
{
int fdshm;
sem_t *sem_producer;
sem_t *sem_consumer;
void *shmaddr;
struct SHARED_OBJECT *so;
int val;
srand(time(NULL));
if ((fdshm = shm_open(SHARED_MEM_NAME, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == -1)
exit_sys("shm_open");
if (ftruncate(fdshm, 4096) == -1) {
perror("ftruncate");
goto EXIT1;
}
if ((shmaddr = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fdshm, 0)) == MAP_FAILED) {
perror("mmap");
goto EXIT2;
}
if ((sem_producer = sem_open(SEM_PRODUCER_NAME, O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH, QUEUE_BUFFER_SIZE)) == NULL) {
perror("sem_open");
goto EXIT3;
}
if ((sem_consumer = sem_open(SEM_CONSUMER_NAME, O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH, 0)) == NULL) {
perror("sem_open");
goto EXIT4;
}
so = (struct SHARED_OBJECT *)shmaddr;
for (;;) {
if (sem_wait(sem_consumer) == -1) {
perror("sem_wait");
goto EXIT5;
}
val = so->qbuf[so->head++];
if (sem_post(sem_producer) == -1) {
perror("sem_wait");
goto EXIT5;
}
so->head = so->head % QUEUE_BUFFER_SIZE;
usleep(rand() % 300000);
printf("%d ", val);
fflush(stdout);
if (val == 99)
break;
}
putchar('\n');
EXIT5:
sem_destroy(sem_consumer);
if (sem_unlink(SEM_CONSUMER_NAME) == -1 && errno != ENOENT)
exit_sys("sem_unlink");
EXIT4:
sem_destroy(sem_producer);
if (sem_unlink(SEM_PRODUCER_NAME) == -1 && errno != ENOENT)
exit_sys("sem_unlink");
EXIT3:
if (munmap(shmaddr, 4096) == -1)
exit_sys("munmap");
EXIT2:
close(fdshm);
EXIT1:
if (shm_unlink(SHARED_MEM_NAME) == -1 && errno != ENOENT)
exit_sys("shm_unlink");
return 0;
}
void exit_sys(const char* msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde de proseslerarası ı
verilmiştir. Bu örnekte de yine "producer" ve "consumer" isimli iki program vardı ı
örneğin Windows karşı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* producer.c */
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#define FILE_MAPPING_NAME "ProducerConsumerSharedMemoryName"
#define PRODUCER_SEMAPHORE_NAME "ProducerSemaphoreName"
#define CONSUMER_SEMAPHORE_NAME "ConsumerSemaphoreName"
#define QUEUE_BUFFER_SIZE 10
void ExitSys(LPCSTR lpszMsg);
struct SHARED_OBJECT {
int qbuf[QUEUE_BUFFER_SIZE];
size_t head;
size_t tail;
};
int main(void)
{
HANDLE hFileMapping;
HANDLE hSemProducer;
HANDLE hSemConsumer;
int val;
struct SHARED_OBJECT *sharedObject;
if ((hFileMapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, FILE_MAPPING_NAME)) == NULL)
ExitSys("CreateFileMapping");
if ((sharedObject = (struct SHARED_OBJECT *)MapViewOfFile(hFileMapping, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0)) == NULL)
ExitSys("MapViewOfFile");
if ((hSemProducer = CreateSemaphore(NULL, QUEUE_BUFFER_SIZE, QUEUE_BUFFER_SIZE, PRODUCER_SEMAPHORE_NAME)) == NULL)
ExitSys("CreateSemaphore");
if ((hSemConsumer = CreateSemaphore(NULL, QUEUE_BUFFER_SIZE, QUEUE_BUFFER_SIZE, CONSUMER_SEMAPHORE_NAME)) == NULL)
ExitSys("CreateSemaphore");
val = 0;
for (;;) {
Sleep(rand() % 300);
WaitForSingleObject(hSemProducer, INFINITE);
sharedObject->qbuf[sharedObject->tail++] = val;
ReleaseSemaphore(hSemConsumer, 1, NULL);
sharedObject->tail = sharedObject->tail % QUEUE_BUFFER_SIZE;
if (val == 99)
break;
++val;
}
CloseHandle(hSemProducer);
CloseHandle(hSemConsumer);
UnmapViewOfFile(sharedObject);
CloseHandle(hFileMapping);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/* Consumer.c */
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#define FILE_MAPPING_NAME "ProducerConsumerSharedMemoryName"
#define PRODUCER_SEMAPHORE_NAME "ProducerSemaphoreName"
#define CONSUMER_SEMAPHORE_NAME "ConsumerSemaphoreName"
#define QUEUE_BUFFER_SIZE 10
void ExitSys(LPCSTR lpszMsg);
struct SHARED_OBJECT {
int qbuf[QUEUE_BUFFER_SIZE];
size_t head;
size_t tail;
};
int main(void)
{
HANDLE hFileMapping;
HANDLE hSemProducer;
HANDLE hSemConsumer;
struct SHARED_OBJECT *sharedObject;
int val;
if ((hFileMapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, FILE_MAPPING_NAME)) == NULL)
ExitSys("CreateFileMapping");
if ((sharedObject = (struct SHARED_OBJECT *)MapViewOfFile(hFileMapping, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0)) == NULL)
ExitSys("MapViewOfFile");
if ((hSemProducer = CreateSemaphore(NULL, QUEUE_BUFFER_SIZE, QUEUE_BUFFER_SIZE, PRODUCER_SEMAPHORE_NAME)) == NULL)
ExitSys("CreateSemaphore");
if ((hSemConsumer = CreateSemaphore(NULL, 0, QUEUE_BUFFER_SIZE, CONSUMER_SEMAPHORE_NAME)) == NULL)
ExitSys("CreateSemaphore");
for (;;) {
WaitForSingleObject(hSemConsumer, INFINITE);
val = sharedObject->qbuf[sharedObject->head++];
ReleaseSemaphore(hSemProducer, 1, NULL);
sharedObject->head = sharedObject->head % QUEUE_BUFFER_SIZE;
printf("%d ", val);
fflush(stdout);
if (val == 99)
break;
Sleep(rand() % 300);
}
putchar('\n');
CloseHandle(hSemProducer);
CloseHandle(hSemConsumer);
UnmapViewOfFile(sharedObject);
CloseHandle(hFileMapping);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastError = GetLastError();
LPSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde "event senkronizasyon nesnesi" denilen önemli bir senkronizasyon nesnesi daha vardı
UNIX/Linux sistemlerinde tam bir karşı ı ı
Windows'taki event senkronizasyon nesnelerinin görevini de yapabilmektedir.
Windows'taki event senkronizasyon nesneleri belli bir thread akı ı ı
amacı ı ı ı ı
olsun. Thread'ler asenkron çalı ı ı ı ı ı ı ı
thread'in diziyi oluşturmuş olması ı ı
diğer thread diziyi oluşturduktan sonra bu işe başlamalı ı
Thread'in bir noktada bekletilmesi semaphore nesneleriyle de kı ı ı ı
için thread'i bekletebilir. Diğer thread de semaphore sayacı ı ı
sağladı ı ı ı ı ı ı ı ı
senkronizasyon nesnesinde thread'in beklememesi gerekebilir. Semaphore'lar bunu doğrudan sağlaymamaktadı
kurtaran thread bunu birden fazla kez yaptı ı ı
Windows sistemlerindeki event senkronizasyon nesnesi aşağı ı ı ı
1) Event senkronizasyon nesnesi CreateEvent API fonksiyonuyla yaratı ı
HANDLE CreateEvent(
LPSECURITY_ATTRIBUTES lpEventAttributes,
BOOL bManualReset,
BOOL bInitialState,
LPCSTR lpName
);
Fonksiyonun birinci parametresi kernel nesnesinin güvenlik bilgilerini belirtmektedir. Bu parametre NULL geçilebilir. Fonksiyonun ikinci
parametresi event nesnesinin "manuel mi otomatik mi" olduğunu belirtmektedir. Eğer bu parametreye TRUE girilirse nesne manuel olur, FALSE
girilirse otomatik olur. Event nesnesi manuel ise SetEvent yapı ı ı ı ı
yapı ı ı ı ı ı ı ı
Fonksiyonun üçüncü parametresi nesnenin başlangı ı ı ı ı ı ı
TRUE girilirse nesne başlangı ı ı ı ı ı ı ı
Fonksiyonun son parametresi nesnenin proseslerarası ı ı ı
arası ı ı ı ı ı
durumunda NULL adrese geri dönemktedir. Örneğin:
HANDLE g_hEvent;
...
if ((g_hEvent = CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL)
Exitrys("CreateEvent");
2) Event nesnesi yine diğer kernel senkronizasyon nesnelerinde olduğu gibi WaitForSingleObject ve WaitForMultipleObjects fonksiyonları
yapı ı ı ı
Yani akı ı
3) Event nesnesini açı ı ı
BOOL SetEvent(
HANDLE hEvent
);
Fonksiyon event nesnesinin handle değerini parametre olarak alı ı ı ı ı
bekleyen thread WaitForSingleObject fonksiyonundan çı ı ı ı ı ı ı ı ı ı ı
değerine geri dönmektedir. Örneğin:
SetEvent(g_hEvent);
2024-05-20 16:33:07 +03:00
Nesne SetEvent fonksiyonu ile açı ı
nesne otomatik ise bu durumda WaitForSİngleObject fonksiyonundan çı ı ı ı
Eğer nesne manuel durumdaysa WaitForSingleObject fonksiyonu sonlandı ı ı
kapalı ı ı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
BOOL ResetEvent(
HANDLE hEvent
);
Fonksiyon event nesnesinin handle değerini parametre olarak alı ı ı ı ı ı ı ı ı ı ı
değere geri döner.
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
WaitForSingleObject (ya da WaitForMultipleObjects) fonksiyonu ile birden fazla thread otomatik moddaki event nesnesini bekliyorsa, bu
event nesnesi açı ı
WaitForSingleObject fonksiyonundan çı ı ı ı ı ı
manuel modda ise SetEvent yapı ı ı
Aşağı ı ı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
DWORD __stdcall ThreadProc1(LPVOID lpvParam);
DWORD __stdcall ThreadProc2(LPVOID lpvParam);
2024-05-20 16:33:07 +03:00
void ExitSys(LPCSTR lpszMsg);
2024-04-29 13:28:55 +03:00
HANDLE g_hEvent;
int main(void)
{
2024-05-20 16:33:07 +03:00
HANDLE hThread1, hThread2;
DWORD dwThreadID1, dwThreadID2;
2024-04-29 13:28:55 +03:00
if ((g_hEvent = CreateEvent(NULL, TRUE, FALSE, NULL)) == NULL)
ExitSys("CreateEvent");
if ((hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, &dwThreadID1)) == NULL)
ExitSys("CreateThread");
if ((hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, &dwThreadID2)) == NULL)
ExitSys("CreateThread");
2024-05-20 16:33:07 +03:00
printf("Press ENTER to set event...\n");
getchar();
SetEvent(g_hEvent);
2024-04-29 13:28:55 +03:00
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
2024-05-20 16:33:07 +03:00
CloseHandle(hThread1);
CloseHandle(hThread2);
2024-04-29 13:28:55 +03:00
return 0;
}
DWORD __stdcall ThreadProc1(LPVOID lpvParam)
{
2024-05-20 16:33:07 +03:00
printf("Thread1 running...\n");
printf("waiting for the event object...\n");
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
WaitForSingleObject(g_hEvent, INFINITE);
printf("Ok, thread1 resumes...\n");
2024-04-29 13:28:55 +03:00
return 0;
}
DWORD __stdcall ThreadProc2(LPVOID lpvParam)
{
2024-05-20 16:33:07 +03:00
printf("Thread2 running...\n");
printf("waiting for the event object...\n");
2024-04-29 13:28:55 +03:00
WaitForSingleObject(g_hEvent, INFINITE);
2024-05-20 16:33:07 +03:00
printf("Ok, thread2 resumes...\n");
2024-04-29 13:28:55 +03:00
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-05-20 16:33:07 +03:00
Sı ı ı
neden gereksinim duyulduğunu açı ı
düşünelim. Burada "okuma" eylemi demekle "kaynakta değişiklik yaratmayan", yazma eylemi demekle de "kaynakta değişiklik yaratan" eylemleri
kastediyoruz. Örneğin global bir bağlı ı ı ı ı ı
da bu bağlı ı
etmektedir. Birden fazla thread'in aynı ı ı ı ı ı ı
yaparken başka thread'lerin o işlem bitene kadar arama işlemi ya da insert işlemi yapmaması ı
üzerinde arama işlemi yaparken başka bir thread'in insert işlemi de yapmaması ı ı
edebiliriz:
Thread1 Thread2 Ne Yapı ı
-------------------------------------------------------
Okuma Okuma İzin Verilmeli
Okuma Yazma Senkronize Edilmeli
Yazma Okuma Senkronize Edilmeli
Yazma Yzma Senkronize Edilmeli
O halde buradan çı
1) Bir thread yazma yaparken yazma ve okuma yapacak thread'ler bu yazma olayı ı
2) Bir thread okuma yaparken yazma yapacak thread'ler bu okuma işlminin bitmesini beklemelidir.
3) Bir thread okuma yaparken, okuma yapacak diğer thread'ler eş zamanlı
Okuma-yazma kilitleri Windows sistemlerinde de UNIX/Linux sistemlerinde de var olan senkronizasyon nesnelerindendir. Biz burada önce Windows
sistemlerindeki okuma-yazma kilitlerini daha sonra UNIX/Linux sistemlerindeki okuma-yazma kilitlerini göreceğiz.
Pekiyi reader-writer lock yerine yukarı ı ı ı
çalı ı ı ı ı ı ı ı ı
thread birbirlerini beklemek zorunda kalı ı
pthread_mutex_t g_mutex;
...
read()
{
pthread_mutex_lock(&g_mutex);
...
pthread_mutex_unlock(&g_mutex);
}
write()
{
pthread_mutex_lock(&g_mutex);
...
pthread_mutex_unlock(&g_mutex);
}
Burada görüldüğü gibi bireden fazla read işlemi birlikte yapı ı
Reader-writer lock nesneleri aslı
variable) kullanı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde okuma-yazma kilitleri şöyle kullanı ı
1) Okuma-yazma kilit nesneleri SRWLOCK türüyle temsil edilmektedir. Önce global düzeyde SRWLOCK türünden bir nesne yaratı ı
InitializeSRWLock fonksiyonu ile ilkdeğerleri verilir. Fonksiyonun prototipi şöyledir:
void InitializeSRWLock(
PSRWLOCK SRWLock
);
Fonksiyon SRWLOCK nesnesinin başlangı ı
SWRLOCK g_srwLock;
...
InitializeSRWLock(&g_srwLock);
2) Okuma amaçlı ı
AcquireSRWLockShared(&g_srwLock);
...
... <KRİTİK KOD>
...
ReleaseSRWLockShared(&g_srwLock)
Burada okuma amaçlı ı ı ı ı ı
yazma amaçlı ı ı ı ı ı ı ı
kritik koda geçişi sağlamaktadı ı ı ı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Yazma Amaçlı ı
AcquireSRWLockExclusive(&g_srwLock);
...
... <KRİTİK KOD>
...
ReleaseSRWLockExclusive(g_srwLock)
Eğer kilit başka bir thread tarafı ı ı ı ı
Eğer kilit okuma ya da yazma amaçlı ı ı ı ı ı ı ı ı ı
kilit ReleaseSRWLockExclusive fonksiyonu ile serbest bı ı ı ı
Fonksiyonları
void AcquireSRWLockShared(
PSRWLOCK SRWLock
);
void ReleaseSRWLockShared(
PSRWLOCK SRWLock
);
void AcquireSRWLockExclusive(
PSRWLOCK SRWLock
);
void ReleaseSRWLockExclusive(
PSRWLOCK SRWLock
);
Fonksiyonlar SRWLOCK nesnelerinin adreslerini parametre olarak almaktadı
Windows'ta reader-writer lock nesnelerinin serbest bı ı ı ı
Aşağı ı ı ı
yaratı ı ı ı ı ı ı ı ı ı
kadar başka hiç read ya da write işleminin yapı ı ı ı ı
çı ı ı ı ı ı ı
...
Thread-1 thread begins writing...
Thread-1 thread ends writing...
Thread-3 thread begins reading...
Thread-3 thread ends reading...
Thread-6 thread begins writing...
Thread-6 thread ends writing...
Thread-2 thread begins reading...
Thread-7 thread begins reading...
Thread-7 thread ends reading...
Thread-2 thread ends reading...
...
Burada örneğin Thread-2 ve Thread-7'nin read işlemine birlikte girdiği görülmektedir. Ancak bir write işlemi başladı ı
bitene kadar read ya da write yapı ı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
2024-05-20 16:33:07 +03:00
#include <string.h>
2024-04-29 13:28:55 +03:00
#include <time.h>
#include <windows.h>
2024-05-20 16:33:07 +03:00
#define NTHREADS 10
2024-04-29 13:28:55 +03:00
DWORD __stdcall ThreadProc(LPVOID lpvParam);
2024-05-20 16:33:07 +03:00
void Read(const char *pszThreadName);
void Write(const char *pszThreadName);
void ExitSys(LPCSTR lpszMsg);
2024-04-29 13:28:55 +03:00
SRWLOCK g_srwLock;
int main(void)
{
HANDLE hThreads[NTHREADS];
2024-05-20 16:33:07 +03:00
DWORD dwThreadIds[NTHREADS];
char szThreadName[32];
char *pszThreadName;
2024-04-29 13:28:55 +03:00
srand(time(NULL));
InitializeSRWLock(&g_srwLock);
2024-05-20 16:33:07 +03:00
for (int i = 0; i < NTHREADS; ++i) {
sprintf(szThreadName, "Thread-%d", i + 1);
if ((pszThreadName = strdup(szThreadName)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
2024-04-29 13:28:55 +03:00
exit(EXIT_FAILURE);
}
2024-05-20 16:33:07 +03:00
if ((hThreads[i] = CreateThread(NULL, 0, ThreadProc, pszThreadName, 0, &dwThreadIds[i])) == NULL)
2024-04-29 13:28:55 +03:00
ExitSys("CreateThread");
}
2024-05-20 16:33:07 +03:00
if (WaitForMultipleObjects(NTHREADS, hThreads, TRUE, INFINITE) == WAIT_FAILED)
ExitSys("CreateThread");
for (int i = 0; i < NTHREADS; ++i)
CloseHandle(hThreads[i]);
2024-04-29 13:28:55 +03:00
return 0;
}
DWORD __stdcall ThreadProc(LPVOID lpvParam)
{
2024-05-20 16:33:07 +03:00
const char *pszThreadName = (LPCTSTR)lpvParam;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
for (int i = 0; i < 10; ++i) {
Sleep(rand() % 100);
2024-04-29 13:28:55 +03:00
if (rand() % 2 == 0)
2024-05-20 16:33:07 +03:00
Read(pszThreadName);
2024-04-29 13:28:55 +03:00
else
2024-05-20 16:33:07 +03:00
Write(pszThreadName);
2024-04-29 13:28:55 +03:00
}
free(lpvParam);
return 0;
}
2024-05-20 16:33:07 +03:00
void Read(const char *pszThreadName)
2024-04-29 13:28:55 +03:00
{
AcquireSRWLockShared(&g_srwLock);
2024-05-20 16:33:07 +03:00
printf("%s thread begins reading...\n", pszThreadName);
Sleep(rand() % 300);
printf("%s thread ends reading...\n", pszThreadName);
2024-04-29 13:28:55 +03:00
ReleaseSRWLockShared(&g_srwLock);
}
2024-05-20 16:33:07 +03:00
void Write(const char *pszThreadName)
2024-04-29 13:28:55 +03:00
{
AcquireSRWLockExclusive(&g_srwLock);
2024-05-20 16:33:07 +03:00
printf("%s thread begins writing...\n", pszThreadName);
Sleep(rand() % 300);
printf("%s thread ends writing...\n", pszThreadName);
2024-04-29 13:28:55 +03:00
ReleaseSRWLockExclusive(&g_srwLock);
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-05-20 16:33:07 +03:00
UNIX/Linux sistemlerinde de okuma-yazma kilitlerinin temel kullanı
1) Okuma yazma kilitleri pthread_rwlock_t türüyle temsil edilmektedir. Programcı ı
vermenin iki yolu vardı ı
#include <pthread.h>
pthread_rwlock_t g_rwlock = PTHREAD_RWLOCK_INITIALIZER;
İkincisi ise pthread_rwlock_init fonksiyonunu kullanmaktı
pthread_rwlock_t g_rwlock;
...
int pthread_rwlock_init(&g_rwlock);
pthread_rwlock_init fonksiyonunun prototipi şöyledir:
int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr);
Fonksiyonun birinci parametresi ilkdeğer verilecek pthread_rwlock_t nesnesinin adresini almaktadı
nesnesinin özelliklerinin belirtildiği pthread_rwlockattr_t türünden nesnenin adresini almaktadı
durumda nesne default özelliklerle yaratı ı ı ı ı ı
2) Okuma amaçlı ı
pthread_rwlock_rdlock(&g_rwlock);
...
... <KRİTİK KOD>
...
pthread_rwlock_unlock(&g_rwlock);
Yazma amaçlı ı
pthread_rwlock_wrlock(&g_rwlock);
...
... <KRİTİK KOD>
...
pthread_rwlock_unlock(&g_rwlock);
Fonksiyonları
#include <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
Fonksiyonlar pthread_rwlock_t türünden nesnenin adresini almaktadı ı ı ı ı ı ı
gibidir. Burada Windows sistemlerinden farklı ı ı ı
yazma amaçlı ı ı ı ı ı ı ı
başarı ı ı
3) Programcı
prototipi şöyledir:
#include <pthread.h>
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
Fonksiyon yine pthread_rwlock_t nesnesinin adresini parametre olarak alı ı ı ı ı ı ı
errno değerine geri döner.
Aşağı ı ı ı ı
sistemeri için yaptiğimı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <pthread.h>
2024-05-20 16:33:07 +03:00
#define NTHREADS 10
2024-04-29 13:28:55 +03:00
void *thread_proc(void *param);
2024-05-20 16:33:07 +03:00
void read_proc(const char *ptname);
void write_proc(const char *ptname);
void exit_sys_errno(const char *msg, int eno);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
pthread_rwlock_t g_rwlock = PTHREAD_RWLOCK_INITIALIZER;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
int main(void)
2024-04-29 13:28:55 +03:00
{
pthread_t tids[NTHREADS];
2024-05-20 16:33:07 +03:00
char tname[32], *ptname;
int result;
2024-04-29 13:28:55 +03:00
srand(time(NULL));
2024-05-20 16:33:07 +03:00
for (int i = 0; i < NTHREADS; ++i) {
sprintf(tname, "Thread-%d", i + 1);
if ((ptname = strdup(tname)) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
if ((result = pthread_create(&tids[i], NULL, thread_proc, ptname)) != 0)
exit_sys_errno("pthread_create", result);
}
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
for (int i = 0; i < NTHREADS; ++i)
pthread_join(tids[i], NULL);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((result = pthread_rwlock_destroy(&g_rwlock)) != 0)
exit_sys_errno("pthread_rwlock_destroy", result);
2024-04-29 13:28:55 +03:00
return 0;
}
void *thread_proc(void *param)
{
2024-05-20 16:33:07 +03:00
const char *ptname = (const char *)param;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
for (int i = 0; i < 10; ++i) {
usleep(rand() % 100000);
if (rand() % 2 == 0)
read_proc(ptname);
else
write_proc(ptname);
}
2024-04-29 13:28:55 +03:00
return NULL;
}
2024-05-20 16:33:07 +03:00
void read_proc(const char *ptname)
2024-04-29 13:28:55 +03:00
{
2024-05-20 16:33:07 +03:00
int result;
if ((result = pthread_rwlock_rdlock(&g_rwlock)) != 0)
exit_sys_errno("pthread_rwlock_rdlock", result);
printf("%s thread begins reading...\n", ptname);
usleep(rand() % 300000);
printf("%s thread ends reading...\n", ptname);
if ((result = pthread_rwlock_unlock(&g_rwlock)) != 0)
exit_sys_errno("pthread_rwlock_unlock", result);
2024-04-29 13:28:55 +03:00
}
2024-05-20 16:33:07 +03:00
void write_proc(const char *ptname)
2024-04-29 13:28:55 +03:00
{
2024-05-20 16:33:07 +03:00
int result;
if ((result = pthread_rwlock_wrlock(&g_rwlock)) != 0)
exit_sys_errno("pthread_rwlock_wrlock", result);
printf("%s thread begins writing...\n", ptname);
usleep(rand() % 300000);
printf("%s thread ends writing...\n", ptname);
if ((result = pthread_rwlock_unlock(&g_rwlock)) != 0)
exit_sys_errno("pthread_rwlock_unlock", result);
2024-04-29 13:28:55 +03:00
}
2024-05-20 16:33:07 +03:00
void exit_sys_errno(const char *msg, int eno)
2024-04-29 13:28:55 +03:00
{
2024-05-20 16:33:07 +03:00
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
2024-04-29 13:28:55 +03:00
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-05-20 16:33:07 +03:00
UNIX/Linux sistemlerinde ismine "koşul değişkenleri (condition variables)" denilen önemli bir senkronizasyon nesnesi vardı
değişkenleri eskiden Windows sistemlerinde yoktu. Ancak belli bir zamandan sonra Windows sistemlerine de sokuldu. Windows'ta event nesneleri
olduğu için koşul değişkenleri yerine bu nesneler onları ı ı
da belirttiğimiz gibi daha sonraları
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Koşul değişkenlerinin amacı ı ı ı
Ancak koşul değişkenlerinin kullanı ı ı ı ı
daha zordur.
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde koşul değişkenleri tipik olarak aşağı ı ı ı
1) UNIX/Linux sistemlerinde koşul değişkenleri tek başları ı ı ı ı
değişkenleri pthread_cond_t türüyle temsil edilmektedir. Programcı
tanı ı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
pthread_cond_t g_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Kooşul değişkenlerine ilkdeğer vermek için pthread_cond_init fonksiyonu da kullanı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
#include <pthread.h>
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Fonksiyonun birinci parametresi pthread_cond_t nesnesini adresini, ikinci parametresi koşul değişkeninin özelliklerin belirtildiği
pthread_condattr_t nesnesinin adresini almaktadı ı
NULL olarak geçebilirsiniz. Bu durumda koşul değişkenleri default özelliklerle yaratı ı
koşul değişkenlerini default özelliklerle yaratmaktadı ı ı ı ı ı ı
geri dönmektedir.
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
2) Koşul değişkenleri ile koşul sağlanana kadar bekleme yapmak için pthread_cond_wait isimli fonksiyon kullanı ı
prototipi şöyledir:
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
#include <pthread.h>
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Fonksiyonun birinci parametresi koşul değişkeninin adresini, ikinci parametresi mutex nesnesinin adresini almaktadı ı
durumunda 0 değerine, başarı ı ı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
pthread_cond_wait(&g_cond, &g_mutex);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Ancak koşul sağlanana kadar bekleme böyle yapı ı ı ı ı ı
bekleme kalı ı ı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
pthread_mutex_lock(&g_mutex);
while (koşul_sağlanmadı ı
pthread_cond_wait(&g_cond, &g_mutex);
pthread_mutex_unlock(&g_mutex);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Burada dikkat edilmesi gereken durumlar şunlardı ı ı ı ı
dikkat ediniz:
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
while (koşul_sağlanmadı ı
pthread_cond_wait(&g_cond, &g_mutex);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Burada döngünün içerisindeki koşul "koşulun sağlanmadı ı ı ı ı ı
thread uyandı ı ı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
while (g_flag == 0)
pthread_cond_wait(&g_cond, &g_mutex);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Burada g_flag değişkeni sı ı ı
bir değerde olması
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Yukarı ı ı ı ı ı ı
bı ı ı ı ı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
3) Koşul değişkenini bekleyen thread'i uyandı ı
pthread_cond_signal fonksiyonu koşul değişkeninde bekleyen tek bir thread'i uyandı ı ı
değişkeninde bekleyen tüm thread'leri uyandı ı ı ı ı
Ancak işletim sistemlerinde bu durum her zaman mümkün olamadı ı ı ı
"yanlı ı
yalnı ı ı ı ı ı
uyanması ı ı ı
pthread_cond_broadcast işlemine benzemektedir. Şimdi siz "yanlı ı ı ı
teknoloji gereken işletim sistemlerinde söz konusu olabildiğini merak edebilirsiniz. İşte işletim sistemlerinin etkin tasarı ı
durumlar oluşabilmektedir. pthread_cond_signal fonksiyonunun koşul değişkeninde bekleyen bir thread'i değil "en az bir thread'i" uyandı ı ı
dikkat ediniz. Ayrı ı ı ı ı ı
istiyoruz.
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Koşul değişkeninde bekleyen bir thread'in pthread_cond_signal ya da pthread_cond_broadcast fonksiyonu ile uyandı ı ı ı ı
anlamı ı
O halde pthread_cond_signal ya da pthread_cond_broadcast uygulanmadan önce bu fonksiyonları ı ı
açması ı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
pthread_mutex_lock(&g_mutex);
while (g_flag == 0)
pthread_cond_wait(&g_cond, &g_mutex);
pthread_mutex_unlock(&g_mutex);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Burada diğer bir thread g_flag değişkenini değiştrmeden pthread_cond_signal ya da pthread_cond_broadcast uygularsa thrad uyandı ı ı
pthread_cond_wait fonksiyonundan çı ı ı ı ı ı
ya da pthread_cond_broadcast uygulamadan önce mutex nesnesinin sahipliğini almalı ı ı
çağı ı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
pthread_mutex_lock(&g_mutex);
g_flag = 1;
pthread_cond_broadcast(&g_cond);
pthread_mutex_unlock(&g_mutex);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
pthread_cond_signal ve pthread_cond_broadcast fonksiyonları ı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
#include <pthread.h>
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
Fonksiyonlar koşul değişken nesnesinin adresini paranetre olarak almakta, başarı ı ı ı
geri dönmektedirler.
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
4) Koşul değişkeninin ve mutex nesnesinin kullanı ı
yok edilmelidir. pthread_cond_destroy fonksiyonunun prototipi şöyledir:
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
#include <pthread.h>
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
int pthread_cond_destroy(pthread_cond_t *cond);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Fonksiyon başarı ı ı ı ı
ve pthread_mutex_destroy fonksiyonları ı ı ı ı
çağrı ı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Aşağı ı ı ı ı ı ı
olması ı ı ı
de uyanmaktadı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
void *thread_proc1(void *param);
void *thread_proc2(void *param);
void exit_sys_errno(const char *msg, int eno);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t g_cond = PTHREAD_COND_INITIALIZER;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
int g_flag = 0;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
int main(void)
{
pthread_t tid1, tid2;
int result;
if ((result = pthread_create(&tid1, NULL, thread_proc1, NULL)) != 0)
exit_sys_errno("pthread_create", result);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((result = pthread_create(&tid2, NULL, thread_proc2, NULL)) != 0)
exit_sys_errno("pthread_create", result);
printf("press ENTER to continue...\n");
getchar();
if ((result = pthread_mutex_lock(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_lock", result);
g_flag = 1;
if ((result = pthread_cond_broadcast(&g_cond)) != 0)
exit_sys_errno("pthread_cond_broadcast", result);
if ((result = pthread_mutex_unlock(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_lunock", result);
if ((result = pthread_join(tid1, NULL)) != 0)
exit_sys_errno("pthread_join", result);
if ((result = pthread_join(tid2, NULL)) != 0)
exit_sys_errno("pthread_join", result);
if ((result = pthread_cond_destroy(&g_cond)) != 0)
exit_sys_errno("pthread_cond_destroy", result);
if ((result = pthread_mutex_destroy(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_destroy", result);
return 0;
}
void *thread_proc1(void *param)
2024-04-29 13:28:55 +03:00
{
int result;
2024-05-20 16:33:07 +03:00
printf("thread-1 is waiting at the condition variable..\n");
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((result = pthread_mutex_lock(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_lock", result);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
while (g_flag == 0)
if ((result = pthread_cond_wait(&g_cond, &g_mutex)) != 0)
exit_sys_errno("pthread_cond_wait", result);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((result = pthread_mutex_unlock(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_unlock", result);
printf("ok, thread-1 resumes...\n");
return NULL;
}
void *thread_proc2(void *param)
{
int result;
printf("thread-2 is waiting at the condition variable..\n");
if ((result = pthread_mutex_lock(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_lock", result);
while (g_flag == 0)
if ((result = pthread_cond_wait(&g_cond, &g_mutex)) != 0)
exit_sys_errno("pthread_cond_wait", result);
if ((result = pthread_mutex_unlock(&g_mutex)) != 0)
exit_sys_errno("pthread_mutex_unlock", result);
printf("ok, thread-2 resumes...\n");
2024-04-29 13:28:55 +03:00
return NULL;
}
2024-05-20 16:33:07 +03:00
void exit_sys_errno(const char *msg, int eno)
2024-04-29 13:28:55 +03:00
{
2024-05-20 16:33:07 +03:00
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
2024-04-29 13:28:55 +03:00
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-05-20 16:33:07 +03:00
Şimdi de koşul değişkenlerini kullanmak için belirttiğimiz kalı ı ı
nesnesinin sahipliği alı ı ı
pthread_mutex_lock(&g_mutex);
while (g_flag == 0)
pthread_cond_wait(&g_cond, &g_mutex);
pthread_mutex_unlock(&g_mutex);
Burada önce mutex nesnesinin sahipliğinin alı ı ı ı
mutex nesnesinin sahipliğini bı ı ı ı
pthread_mutex_lock(&g_mutex);
g_flag = 1;
pthread_mutex_unlock(&g_mutex);
pthread_cond_broadcast(&g_cond);
Burada pthread_cond_broadcast uygulandı ı ı
uykuya dalmadan önce mutex nesnesinin sahipliğini nası ı ı ı ı ı ı
koşul eğer sağlanı ı ı ı ı ı
düşünelim. Bu durumda mutex nesnesinin sahipliği alı
bı ı ı
Pekiyi neden yukarı ı ı ı ı ı ı ı ı
(spurious wakeup)" yüzündendir. Döngü yerine aşağı ı
pthread_mutex_lock(&g_mutex);
if (g_flag == 0)
pthread_cond_wait(&g_cond, &g_mutex);
pthread_mutex_unlock(&g_mutex);
Burada yanlı ı ı ı ı ı
gerekmektedir. Şimdi programcı ı ı ı ı
bunu yapamayacaktı
pthread_mutex_lock(&g_mutex);
while (g_flag == 0)
pthread_cond_wait(&g_cond, &g_mutex);
pthread_mutex_unlock(&g_mutex);
Burada diğer tarafı ı ı ı ı ı ı ı ı
mutex nesnesinin sahipliğini almaya çalı ı ı ı ı
mutex nesnesinin sahipliğini almı ı ı ı
çı ı ı ı
pthread_mutex_lock(&g_mutex);
while (g_flag == 0)
pthread_cond_wait(&g_cond, &g_mutex);
g_flag = 0;
pthread_mutex_unlock(&g_mutex);
pthread_cond_signal ya da pthread_cond_broadcast uygulayan tarafı ı
aslı
pthread_mutex_lock(&g_mutex);
g_flag = 1;
pthread_cond_broadcast(&g_cond);
pthread_mutex_unlock(&g_mutex);
Ancak koşulları ı ı ı
gerekebilmektedir. C'deki aslı ı
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde durum değişkenleri daha çok aynı ı ı ı ı ı
da kullanı ı ı ı ı ı
sı ı ı ı
biçimde yapı ı
2024-04-29 13:28:55 +03:00
pthread_cond_t g_cond;
...
pthread_condattr_t attr;
pthread_condattr_init(&attr);
2024-05-20 16:33:07 +03:00
pthread_condattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
2024-04-29 13:28:55 +03:00
pthread_cond_init(&g_cond, &attr);
pthread_condattr_destroy(&attr);
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-05-20 16:33:07 +03:00
Daha önce de belirttiğimiz gibi belli bir zamandan sonra Windows sistemlerine de durum değişkenleri eklenmiştir. Windows sistemlerindeki
durum değişkenleri mutex nesneleriyle değil CRITICAL_SECTION ve Read/Write Lock nesneleriyle kullanı ı
UNIX/Linux sistemlerindekine çok benzemektedir.
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-05-20 16:33:07 +03:00
Bir thread'in çalı ı ı ı ı
çalı ı ı ı ı ı ı
Thread'ler dünyası ı ı ı ı ı ı
Aşağı ı ı
++g_count;
Böyle bir kod genellikle derleyiciler tarafı ı ı
işlemcilerinde bu işlem için derleyici aşağı
MOV EAX, g_count
INC EAX
MOV g_count, EAX
İşte komutlar arası ı ı ı ı ı ı
Aslı ı ı ı
gibi tek bir makine komutuyla da yapı
INC g_count
Makine komutları ı ı
arası ı ı
bazı ı ı ı ı
üzerinde burada durmayacağı ı ı ı
bir değer yazarken diğer bir çekirdek oradan değer okumak istediğinde okuyan taraf önceki ya da sonraki değeri değil bozuk bir değeri de
okuyabilmektedir. Bu durumda maalesef tek bir değişken bile iki thread arası ı ı
edilmesi gerekmektedir. Ancak bir tek değişkene bir değer atamak için mutex gibi bir senkronizasyon nesnesini kullanmak performansı
düşürmektedir. Aslı
o komutluk durdurarak yalnı ı ı
bir makine komutunun başı ı ı ı
LOCK INC g_count
Bu işlem artı ı
Derleyicinin her komutta bu öneki kullanması ı ı ı ı ı
bir kod üretmesini nası
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde diğer işlemcileri bir komutluk durdurarak bellek işlemi yapabilmek için tasarlanmı ı
InterlockedXXX biçiminde API fonksiyonları ı ı ı ı ı
fonksiyonları ı ı
LONG InterlockedIncrement(LONG volatile *Addend);
LONG InterlockedAdd(LONG volatile *Addend, LONG Value);
LONG InterlockedDecrement(LONG volatile *Addend);
LONG InterlockedExchange(LONG volatile *Target, LONG Value);
Aslı ı ı ı ı
https://learn.microsoft.com/en-us/windows/win32/sync/synchronization-functions
Yukarı ı ı ı
makine komutuyla yapı
Aşağı ı ı ı ı ı
fonksiyonuyla yapmı ı ı ı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
DWORD __stdcall ThreadProc1(LPVOID lpvParam);
DWORD __stdcall ThreadProc2(LPVOID lpvParam);
long g_count;
int main(void)
{
HANDLE hThread1, hThread2;
DWORD dwThreadID1, dwThreadID2;
if ((hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, &dwThreadID1)) == NULL)
ExitSys("CreateThread");
if ((hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, &dwThreadID2)) == NULL)
ExitSys("CreateThread");
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
printf("%ld\n", g_count);
return 0;
}
DWORD __stdcall ThreadProc1(LPVOID lpvParam)
{
long i;
for (i = 0; i < 1000000; ++i)
2024-05-20 16:33:07 +03:00
InterlockedIncrement(&g_count);
2024-04-29 13:28:55 +03:00
return 0;
}
DWORD __stdcall ThreadProc2(LPVOID lpvParam)
{
long i;
for (i = 0; i < 1000000; ++i)
2024-05-20 16:33:07 +03:00
InterlockedIncrement(&g_count);
2024-04-29 13:28:55 +03:00
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-05-20 16:33:07 +03:00
Derleyiciler tarafı ı ı ı
yerine inline fonksiyon gibi açı ı ı
bölümü bazı ı ı ı ı ı
derleyicilerinde, gcc ve clang derleyicilerinde "built-in" ya da "intrinsic" fonksiyonlar bulunmaktadı
"intrinsic" fonksiyon listesine aşağı ı
https://learn.microsoft.com/en-us/cpp/intrinsics/compiler-intrinsics?view=msvc-170
gcc Derleyicilerinin built-in fonksiyonları ı ı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
https://gcc.gnu.org/onlinedocs/gcc/Target-Builtins.html
https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
gcc'de bazı ı ı
Ancak gcc'de önceleri bu atomic built-in fonksiyonlar __sync_xxx biçiminde isimlendirilmişti. Sonra C++'a <atomic> kütüphanesi eklenince
C++ kütüphanesi de kullanabilsin diye bu eski __sync_xxx isimli fonksiyonlar yerine bunları
versiyonları ı ı ı ı
fonksiyon grubunun dokümanları ı ı ı
https://gcc.gnu.org/onlinedocs/gcc-4.9.0/gcc/_005f_005fatomic-Builtins.html
https://gcc.gnu.org/onlinedocs/gcc-4.1.0/gcc/Atomic-Builtins.html
__atomic_xxx fonksiyonları
ne anlam ifade ettiği üzerinde durmayacağı
Örneğin bir nesneyi atomic bir biçimde 1 artı
__atomic_fetch_add(&g_count, 1, __ATOMIC_SEQ_CST);
Bir değişkene yalnı ı ı
void __atomic_store_n(type *ptr, type val, int memmodel);
void __atomic_store(type *ptr, type *val, int memmodel);
Benzer biçimde bir nesnenin içerisindeki değeri almak için de aşağı ı
void __atomic_load_n (type *ptr, int memmodel);
void __atomic_load (type *ptr, type *ret, int memmodel);
Aşağı ı ı ı
yapmı ı ı ı ı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-05-20 16:33:07 +03:00
/* atomic.c */
2024-04-29 13:28:55 +03:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
2024-05-20 16:33:07 +03:00
#define MAX_COUNT 100000000
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
void *thread_proc1(void *param);
void *thread_proc2(void *param);
void exit_sys_errno(const char *msg, int eno);
int g_count;
2024-04-29 13:28:55 +03:00
int main(void)
{
pthread_t tid1, tid2;
2024-05-20 16:33:07 +03:00
int result;
2024-04-29 13:28:55 +03:00
if ((result = pthread_create(&tid1, NULL, thread_proc1, NULL)) != 0)
2024-05-20 16:33:07 +03:00
exit_sys_errno("pthread_create", result);
2024-04-29 13:28:55 +03:00
if ((result = pthread_create(&tid2, NULL, thread_proc2, NULL)) != 0)
2024-05-20 16:33:07 +03:00
exit_sys_errno("pthread_create", result);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((result = pthread_join(tid1, NULL)) != 0)
exit_sys_errno("pthread_join", result);
if ((result = pthread_join(tid2, NULL)) != 0)
exit_sys_errno("pthread_join", result);
2024-04-29 13:28:55 +03:00
printf("%d\n", g_count);
return 0;
}
void *thread_proc1(void *param)
{
2024-05-20 16:33:07 +03:00
for (int i = 0; i < MAX_COUNT; ++i)
__atomic_fetch_add(&g_count, 1, __ATOMIC_SEQ_CST);
2024-04-29 13:28:55 +03:00
return NULL;
}
void *thread_proc2(void *param)
{
2024-05-20 16:33:07 +03:00
for (int i = 0; i < MAX_COUNT; ++i)
__atomic_fetch_add(&g_count, 1, __ATOMIC_SEQ_CST);
2024-04-29 13:28:55 +03:00
return NULL;
}
2024-05-20 16:33:07 +03:00
void exit_sys_errno(const char *msg, int eno)
2024-04-29 13:28:55 +03:00
{
2024-05-20 16:33:07 +03:00
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
2024-04-29 13:28:55 +03:00
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-05-20 16:33:07 +03:00
C11 ile birlikte C'ye isteğe bağlı ı
nesneler için derleyiciler atomik işlem yapacak biçimde kod üretmektedir. Tabii bu _Atomic belirleyicisi atomic yapı
bir etki göstermemektedir. Bir C11 derleyicisinin _Atomic belirleyicisini destekleyip desteklemediği __STDC_NO_ATOMICS__ makrosuna
bakı
sürümden sonra bu belirleyiciyi desteklemektedir. Ayrı ı ı ı ı
bulundurulmuştur:
atomic_bool _Atomic _Bool
atomic_char _Atomic char
atomic_schar _Atomic signed char
atomic_uchar _Atomic unsigned char
atomic_short _Atomic short
atomic_ushort _Atomic unsigned short
atomic_int _Atomic int
atomic_uint _Atomic unsigned int
atomic_long _Atomic long
atomic_ulong _Atomic unsigned long
atomic_llong _Atomic long long
...
Bunları ı
standart hale getirilmiştir. Bunları ı ı ı ı
atomic_store
atomic_store_explicit
atomic_load
atomic_load_explicit
atomic_exchange
atomic_exchange_explicit
atomic_compare_exchange_strong
atomic_compare_exchange_strong_explicit
atomic_compare_exchange_weak
atomic_compare_exchange_weak_explicit
atomic_fetch_add
atomic_fetch_add_explicit
atomic_fetch_sub
atomic_fetch_sub_explicit
Aşağı ı ı ı ı
yapı ı ı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-05-20 16:33:07 +03:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
2024-04-29 13:28:55 +03:00
#include <pthread.h>
2024-05-20 16:33:07 +03:00
void *thread_proc1(void *param);
void *thread_proc2(void *param);
void exit_sys_errno(const char *msg, int eno);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
_Atomic int g_count;
2024-04-29 13:28:55 +03:00
int main(void)
{
pthread_t tid1, tid2;
2024-05-20 16:33:07 +03:00
int result;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
srand(time(NULL));
if ((result = pthread_create(&tid1, NULL, thread_proc1, NULL)) != 0)
exit_sys_errno("pthread_create", result);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((result = pthread_create(&tid2, NULL, thread_proc2, NULL)) != 0)
exit_sys_errno("pthread_create", result);
if ((result = pthread_join(tid1, NULL)) != 0)
exit_sys_errno("pthread_join", result);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((result = pthread_join(tid2, NULL)) != 0)
exit_sys_errno("pthread_join", result);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
printf("%d\n", g_count);
2024-04-29 13:28:55 +03:00
return 0;
}
void *thread_proc1(void *param)
{
2024-05-20 16:33:07 +03:00
for (int i = 0; i < 1000000; ++i)
2024-04-29 13:28:55 +03:00
++g_count;
return NULL;
}
void *thread_proc2(void *param)
{
2024-05-20 16:33:07 +03:00
for (int i = 0; i < 1000000; ++i)
2024-04-29 13:28:55 +03:00
++g_count;
return NULL;
}
2024-05-20 16:33:07 +03:00
void exit_sys_errno(const char *msg, int eno)
2024-04-29 13:28:55 +03:00
{
2024-05-20 16:33:07 +03:00
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
2024-04-29 13:28:55 +03:00
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-05-20 16:33:07 +03:00
C++'ta C'nin _Atomic belirleyicisi yoktur. (Genel olarak C++ Programlama Dili C Programlama Dilini kapsı
düzeyde değildir. C++'ta atomik işlemler <atomic> başlı ı ı ı ı ı
Bu sı ı ı ı ı ı ı ı
C++'taki eşdeğerleri aşağı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-05-20 16:33:07 +03:00
#include <cstdio>
#include <cstdlib>
#include <atomic>
#include <windows.h>
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
using namespace std;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
void ExitSys(LPCSTR lpszMsg);
DWORD __stdcall ThreadProc1(LPVOID lpvParam);
DWORD __stdcall ThreadProc2(LPVOID lpvParam);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
atomic<int> g_count;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
int main(void)
2024-04-29 13:28:55 +03:00
{
2024-05-20 16:33:07 +03:00
HANDLE hThread1, hThread2;
DWORD dwThreadID1, dwThreadID2;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, &dwThreadID1)) == NULL)
ExitSys("CreateThread");
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, &dwThreadID2)) == NULL)
ExitSys("CreateThread");
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
printf("%ld\n", (int)g_count);
2024-04-29 13:28:55 +03:00
return 0;
}
2024-05-20 16:33:07 +03:00
DWORD __stdcall ThreadProc1(LPVOID lpvParam)
2024-04-29 13:28:55 +03:00
{
2024-05-20 16:33:07 +03:00
long i;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
for (i = 0; i < 1000000; ++i)
++g_count;
2024-04-29 13:28:55 +03:00
return 0;
}
2024-05-20 16:33:07 +03:00
DWORD __stdcall ThreadProc2(LPVOID lpvParam)
{
long i;
for (i = 0; i < 1000000; ++i)
++g_count;
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir fonksiyon farklı ı ı ı ı
güvenlilik (thread safety)" birden fazla thread tarafı ı ı ı ı ı ı
Pekiyi thread güvenliliği bozan faktörler nelerdir? İşte eğer fonksiyon bir "statik data" kullanı
static yerel bir nesneyi kullanı
toplamda tek bir kopyası ı ı ı ı ı ı ı ı
oluşabilecektir. Örneğin:
void foo(void)
{
static int a = 0;
++a;
...
++a
...
++a;
...
}
Burada bu foo fonksiyonu farklı ı ı ı ı ı ı ı ı ı
dolayı ı ı ı ı ı ı ı ı ı
Aynı ı
bir fonksiyonun farklı ı ı ı ı ı ı ı
en faktör "static data" kullanı ı ı ı ı ı
char *myitoa(int a)
{
static char buf[32];
sprintf(buf, "%d", a);
return buf;
}
Burada myitoa thread güvenli değildir. Çünkü bu fonksiyon birden fazla thread tarafı ı ı ı
sorun oluşacaktı ı ı ı ı ı
Pekiyi fonksiyonu "thread güvensiz" yapan şey nedir? Eğer bir fonksiyon statik veri kullanı
nesneler) fonksiyon thread güvenli olmaz. Ortak kaynakları
olmaktan çı ı ı ı ı
hale getirmiş oluruz. Örneğin:
char *myitoa_tsafe(char *buf, int a)
{
sprintf(str, "%d", a);
return buf;
}
Burada myitoa fonksiyonu artı
bir kullanı
char s[100];
myitoa_tsafe(s, 123456)
Burada myitoa_tsafe fonksiyonu artı ı ı ı ı ı
yerel bir dizi olduğunu kabul ediyoruz.)
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
C'nin de bazı ı ı ı ı
Örneğin localtime fonksiyonu thread güvenli değildir. local time fonksiyonunun parametrik yapı ı ı ı ı ı
struct tm *localtime(const time_t *timep);
Burada localtime fonksiyonu struct tm türünden static yerel bir nesnenin adresiyle geri dönmektedir.
struct tm *localtime(const time_t *timep)
{
static struct tm lt;
....
return <
}
Görüldüğü gibi fonksiyon aslı ı ı
bir kopyası ı ı ı ı ı ı ı ı ı
nesnenin içeriği bozulacaktı
thread güvenli değildir. Benzer biçimde rassal sayı ı ı
Dolayı ı ı ı ı
listesini veriyoruz:
strtok
strerror
ctime
gmtime
localtime
asctime
rand
srand
tmpnam
tempnam
setlocal
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi thread güvenli olmayan bir fonksiyonu nası ı
(statik yerel ya da global nesneleri kastediyoruz) kullanması ı
Bu durumda fonksiyonu thread güvenli hale getirmek için yapı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi C'nin standart kütüphanesindeki bazı
paragraflarda ele alacağı ı ı
getirilebilirler. Çalı ı ı ı ı ı ı
C'nin 2011 versiyonuna kadar (C11) C standartları ı ı
isteğe bağlı ı ı
thread güvenli olup olmadı ı ı ı ı ı
C fonksşyonları
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Microsoft 2005 yı ı ı ı
Ancak 2005'ten itibaren tek bir standart C kütüphanesi bulundurmaya başlamı ı
POSIX sistemlerinde static data kullanan sorunlu standart C fonksiyonları ı
bulundurulmuştur. Bu versiyonlar genel olarak static data kullanmak yerine ekstra bir parametre ile static data için kullanı ı
fonksiyonu çağı ı ı
struct tm *localtime(const time_t *timep);
struct tm *localtime_r(const time_t *timep, struct tm *result);
localtime_r fonksiyonu static yerel nesne kullanmamakta parametre olarak alı ı
fonksiyon parametresiyle aldı ı ı ı
int rand(void);
int rand_r(unsigned int *seedp);
rand_r fonksiyonunun global tohum değişkeni kullanmadı ı ı ı
Aşağı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <pthread.h>
void *thread_proc1(void* param);
void *thread_proc2(void* param);
void foo(void);
void exit_errno(const char* msg, int result);
int main(void)
{
int result;
pthread_t tid1, tid2;
if ((result = pthread_create(&tid1, NULL, thread_proc1, NULL)) != 0)
exit_errno("pthread_create", result);
if ((result = pthread_create(&tid2, NULL, thread_proc2, NULL)) != 0)
exit_errno("pthread_create", result);
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
return 0;
}
void foo(void)
2024-04-29 13:28:55 +03:00
{
time_t t;
char s[64];
t = time(NULL);
ctime_r(&t, s);
printf("%s", s);
}
void *thread_proc1(void *param)
{
foo();
return NULL;
}
void *thread_proc2(void *param)
{
foo();
return NULL;
}
void exit_errno(const char *msg, int result)
{
fprintf(stderr, "%s: %s\n", msg, strerror(result));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-05-20 16:33:07 +03:00
C'nin standart FILE stream işlemlerinin thread güvenli olup olmadı ı ı
hem de GNU C kütüphanesi FILE stream işlemlerini thread güveli biçimde yapmaktadı ı
işlem yapı ı ı ı ı
Benzer biçimde C++'ı ı ı ı
etmemktedir.
Aşağı ı ı ı ı ı
bir biçimde oluşturulduğunu anı ı ı ı
olabilirdi. Buradaki örnekte "test.txt" dosyası ı ı ı ı
...
thread-1
Thread-1
Thread-1
Thread-1
Thread-1
Thread-2
Thread-2
Thread-2
Thread-2
Thread-2
Thread-2
Thread-1
Thread-1
Thread-1
Thread-1
Thread-1
Thread-1
Thread-1
...
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
DWORD __stdcall ThreadProc1(LPVOID lpvParam);
DWORD __stdcall ThreadProc2(LPVOID lpvParam);
FILE *g_f;
int main(void)
{
HANDLE hThread1, hThread2;
DWORD dwThreadID1, dwThreadID2;
if ((g_f = fopen("test.txt", "w")) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
if ((hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, &dwThreadID1)) == NULL)
ExitSys("CreateThread");
if ((hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, &dwThreadID2)) == NULL)
ExitSys("CreateThread");
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
return 0;
}
DWORD __stdcall ThreadProc1(LPVOID lpvParam)
{
int i;
for (i = 0; i < 1000; ++i)
fprintf(g_f, "Thread-1\n");
return 0;
}
DWORD __stdcall ThreadProc2(LPVOID lpvParam)
{
int i;
for (i = 0; i < 1000; ++i)
fprintf(g_f, "Thread-2\n");
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı
karşı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
void *thread_proc1(void *param);
void *thread_proc2(void *param);
void exit_sys_errno(const char *msg, int eno);
FILE *g_f;
int main(void)
{
pthread_t tid1, tid2;
int result;
if ((g_f = fopen("test.txt", "w")) == NULL) {
fprintf(stderr, "cannot open file!..\n");
exit(EXIT_FAILURE);
}
if ((result = pthread_create(&tid1, NULL, thread_proc1, NULL)) != 0)
exit_sys_errno("pthread_create", result);
if ((result = pthread_create(&tid2, NULL, thread_proc2, NULL)) != 0)
exit_sys_errno("pthread_create", result);
if ((result = pthread_join(tid1, NULL)) != 0)
exit_sys_errno("pthread_join", result);
if ((result = pthread_join(tid2, NULL)) != 0)
exit_sys_errno("pthread_join", result);
return 0;
}
void *thread_proc1(void *param)
{
int i;
for (i = 0; i < 10000; ++i)
fprintf(g_f, "Thread-1\n");
return NULL;
}
void *thread_proc2(void *param)
{
int i;
for (i = 0; i < 10000; ++i)
fprintf(g_f, "Thread-2\n");
return NULL;
}
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
C++'ı ı ı ı ı
bunun için bir garanti bulunmamaktadı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <iostream>
#include <string>
#include <fstream>
#include <thread>
using namespace std;
fstream g_f;
void thread_proc1()
{
for (int i = 0; i < 1000; ++i)
g_f << "thread-1 running...\n";
}
void thread_proc2()
{
for (int i = 0; i < 1000; ++i)
g_f << "Thread-2 running...\n";
}
int main(void)
{
g_f.open("test.txt", ios::out);
thread t1(thread_proc1);
thread t2(thread_proc2);
t1.join();
t2.join();
g_f.close();
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Daha önceden de belirttiğimiz gibi Windows sistemlerindeki ReadFile ve WriteFile API fonksiyonları
write POSIX fonksiyonları ı ı ı ı ı
okuma ve yazma bağlamı ı ı ı ı
aynı ı ı
thread ya da proseslerden biri tam bir dosyanı ı
sı ı ı
byte'ı ı ı ı ı ı ı ı ı ı
100 byte okumaz. Benzer biçimde iki thread ya da proses WriteFile ya da write ile aynı ı ı ı
iç içe geçme oluşmamaktadı ı ı
write işlemi sı ı
thread-1
--------
write(...)
write(...)
thread-2
---------
write(...)
write(...)
Burada write çapı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
C++'da C++11 ile birlikte standart bir thread kütüphanesi oluşturulmuştur. Tabii aslı
fonksiyonları ı ı ı ı ı
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <iostream>
#include <string>
#include <thread>
using namespace std;
class Sample {
public:
Sample(const char *name) : m_name(name)
{}
void operator()()
{
cout << m_name + "\n";
}
private:
string m_name;
};
void thread_proc1()
{
cout << "thread-1 running...\n";
}
void thread_proc2()
{
cout << "thread-2 running...\n";;
}
int main(void)
{
Sample s1("thread-1"), s2("thread-2");
thread t1(s1);
thread t2(s2);
thread t3(thread_proc1);
thread t4(thread_proc1);
t1.join();
t2.join();
t3.join();
t4.join();
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Genel olarak C++'ı ı ı ı ı
farklı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Thread'e özgü global değişkenler olabilir mi? Yani örneğin iki thread akı ı ı ı ı
değişkenler olabilir mi? İşte işletim sistemleri uzun süredir bunu sağlamak için mekanizmalar bulundurmaktadı
thread'e özgü global değişken oluşturma mekanizması
(TSD)" denilmektedir. Hatta C11 ile birlikte C standartları ı
yer belirleyici (storage class specifier) anahtar sözcükler sokulmuştur. Yani artı ı ı
ve POSIX fonksiyonları ı ı
_Thread_local int g_tl;
Burada aslı ı ı ı ı ı
Aşağı ı
her thread için ayrı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
void Foo(const char *str);
DWORD __stdcall ThreadProc1(LPVOID lpvParam);
DWORD __stdcall ThreadProc2(LPVOID lpvParam);
void ExitSys(LPCSTR lpszMsg);
_Thread_local int g_tl;
int main(void)
{
HANDLE hThread1, hThread2;
DWORD dwThreadID1, dwThreadID2;
if ((hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, &dwThreadID1)) == NULL)
ExitSys("CreateThread");
if ((hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, &dwThreadID2)) == NULL)
ExitSys("CreateThread");
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
Foo("Main Thread"); /* Main Thread: 0 */
return 0;
}
void Foo(const char *str)
{
printf("%s: %d\n", str, g_tl);
}
DWORD __stdcall ThreadProc1(LPVOID lpvParam)
{
g_tl = 10;
Sleep(5000);
Foo("Thread1"); /* THread: 10 */
return 0;
}
DWORD __stdcall ThreadProc2(LPVOID lpvParam)
{
g_tl = 20;
Foo("Thread2"); /* Thread2: 20 */
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı
de arka planda aslı ı ı ı ı
değişkenler oluşturabilmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows'ta her thread için işletim sistemi TLS adı ı ı ı ı
temsil edilmektedir. Belli bir slot indeksi her thread'te ayrı
Windows'ta TLS (Thread Local Storage) kullanı ı ı ı
1) Önce henüz thread'ler yaratı ı ı
DWORD TlsAlloc(void);
Fonksiyon parametre almamaktadı ı ı ı
yaratı ı ı ı
nesnede saklar. Fonksiyon başarı ı ı
slot bulunmaktadı
DWORD g_slot;
...
if ((g_slot = TlsAlloc()) == TLS_OUT_OF_INDEXES)
ExitSys("TlsAlloc");
2) Artı ı ı ı
farklı ı ı
şöyledir:
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
BOOL TlsSetValue(
DWORD dwTlsIndex,
LPVOID lpTlsValue
);
Fonksiyonun birinci parametresi TLS slot indeksini, ikinci parametresi ise slota yerleştirilecek adres belirtmektedir. Fonksiyon başarı
durumunda sı ı ı ı ı ı ı ı ı
ettiğimiz alanı
Örneğin:
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
struct THREAD_LOCAL_DATA {
int a;
int b;
ibt c;
};
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
struct THREAD_LOCAL_DATA *tld;
...
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((tld = (struct THREAD_LOCAL_DATA *)malloc(sizeof(struct THREAD_LOCAL_DATA))) == NULL) {
fprintf(stderr, "cannot allocate memory!...\n");
exit(EXIT_FAILURE);
2024-04-29 13:28:55 +03:00
}
2024-05-20 16:33:07 +03:00
tld->a = 10;
tld->b = 20;
tld->c = 30;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if (!TlsSetValue(g_slot, tld))
ExitSys("TlsSetValue");
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
3) Değer TLS slotundan geri almak için TLSGetValue fonksiyonu kullanı ı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
LPVOID TlsGetValue(
DWORD dwTlsIndex
);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Fonsiyon TLS slot indeksini parametre olarak alı ı ı ı
durumunda NULL adrese geri dönmektedir. Tabii yaratı ı ı ı ı ı ı
Dolayı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
struct THREAD_LOCAL_DATA *tld;
...
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((tld = (struct THREAD_LOCAL_DATA *)TlsGetValue(g_slot)) == NULL)
ExitSys("TlsGetValue");
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Ancak gerçekten solota NULL adres de yerleştirilebilir. Bu durumda fonksiyon NULL adrese geri döndüğünde GetLastError değerine bakı ı ı
Eğer GetLastError ERROR_SUCESS değerindeyse işlem başarı ı ı ı ı ı
başka bir değer geri döndürürse işlemin başarı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
4) Slot kullanı ı
BOOL TlsFree(
DWORD dwTlsIndex
);
Fonksiyon başarı ı ı ı ı ı ı ı ı ı ı ı ı
fonksiyonun başarı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Aşağı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
2024-05-20 16:33:07 +03:00
void Foo(const char *str);
2024-04-29 13:28:55 +03:00
DWORD __stdcall ThreadProc1(LPVOID lpvParam);
DWORD __stdcall ThreadProc2(LPVOID lpvParam);
2024-05-20 16:33:07 +03:00
void ExitSys(LPCSTR lpszMsg);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
DWORD g_slot;
2024-04-29 13:28:55 +03:00
int main(void)
{
HANDLE hThread1, hThread2;
DWORD dwThreadID1, dwThreadID2;
2024-05-20 16:33:07 +03:00
if ((g_slot = TlsAlloc()) == TLS_OUT_OF_INDEXES)
ExitSys("TlsAlloc");
2024-04-29 13:28:55 +03:00
if ((hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, &dwThreadID1)) == NULL)
ExitSys("CreateThread");
if ((hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, &dwThreadID2)) == NULL)
ExitSys("CreateThread");
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
2024-05-20 16:33:07 +03:00
Foo("Main Thread");
TlsFree(g_slot);
2024-04-29 13:28:55 +03:00
return 0;
}
2024-05-20 16:33:07 +03:00
void Foo(const char *str)
2024-04-29 13:28:55 +03:00
{
2024-05-20 16:33:07 +03:00
int *pVal;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((pVal = (int *)TlsGetValue(g_slot)) == NULL && GetLastError() != ERROR_SUCCESS)
ExitSys("TlsGetValue");
printf("%d\n", (int)pVal);
}
DWORD __stdcall ThreadProc1(LPVOID lpvParam)
{
if (!TlsSetValue(g_slot, (LPVOID)10)) /* g_tl = 10 */
ExitSys("TlsSetValue");
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Sleep(5000);
Foo("Thread1");
2024-04-29 13:28:55 +03:00
return 0;
}
DWORD __stdcall ThreadProc2(LPVOID lpvParam)
{
2024-05-20 16:33:07 +03:00
if (!TlsSetValue(g_slot, (LPVOID)20)) /* g_tl = 20 */
ExitSys("TlsSetValue");
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Foo("Thread2");
2024-04-29 13:28:55 +03:00
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-05-20 16:33:07 +03:00
89. Ders 18/05/2024 - Cumartesi
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-05-20 16:33:07 +03:00
Her ne kadar TlsSetValue ile slota yalnı ı ı ı
yerleştirebiliriz. Böylece istediğimiz kadar çok bilgiyi thread'e özgü biçimde kullanabiliriz. Örneğin:
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
struct THREAD_DATA {
int a;
int b;
int c;
};
...
struct THREAD_DATA *td;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
td = (struct THREAD_DATA *)malloc(sizeof(struct THREAD_DATA));
td->a = 10;
td->b = 20;
td->c = 30;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
TlsSetValue(g_slot, td);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Aşağı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
2024-05-20 16:33:07 +03:00
void Foo(const char *str);
2024-04-29 13:28:55 +03:00
DWORD __stdcall ThreadProc1(LPVOID lpvParam);
DWORD __stdcall ThreadProc2(LPVOID lpvParam);
2024-05-20 16:33:07 +03:00
void ExitSys(LPCSTR lpszMsg);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
DWORD g_slot;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
struct THREAD_DATA {
int a;
int b;
int c;
};
2024-04-29 13:28:55 +03:00
int main(void)
{
HANDLE hThread1, hThread2;
DWORD dwThreadID1, dwThreadID2;
2024-05-20 16:33:07 +03:00
if ((g_slot = TlsAlloc()) == TLS_OUT_OF_INDEXES)
2024-04-29 13:28:55 +03:00
ExitSys("TlsAlloc");
if ((hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, &dwThreadID1)) == NULL)
ExitSys("CreateThread");
if ((hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, &dwThreadID2)) == NULL)
ExitSys("CreateThread");
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
2024-05-20 16:33:07 +03:00
Foo("Main Thread");
TlsFree(g_slot);
2024-04-29 13:28:55 +03:00
return 0;
}
2024-05-20 16:33:07 +03:00
void Foo(const char *str)
2024-04-29 13:28:55 +03:00
{
2024-05-20 16:33:07 +03:00
struct THREAD_DATA* td;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((td = (struct THREAD_DATA *)TlsGetValue(g_slot)) == NULL && GetLastError() != ERROR_SUCCESS)
ExitSys("TlsGetValue");
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
printf("%s: %d, %d, %d\n", str, td->a, td->b, td->c);
2024-04-29 13:28:55 +03:00
}
2024-05-20 16:33:07 +03:00
DWORD __stdcall ThreadProc1(LPVOID lpvParam)
2024-04-29 13:28:55 +03:00
{
2024-05-20 16:33:07 +03:00
struct THREAD_DATA* td;
if ((td = (struct THREAD_DATA*)malloc(sizeof(struct THREAD_DATA))) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
td->a = 10;
td->b = 20;
td->c = 30;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if (!TlsSetValue(g_slot, td))
ExitSys("TlsSetValue");
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Sleep(5000);
Foo("Thread1");
free(td);
2024-04-29 13:28:55 +03:00
return 0;
}
2024-05-20 16:33:07 +03:00
DWORD __stdcall ThreadProc2(LPVOID lpvParam)
2024-04-29 13:28:55 +03:00
{
2024-05-20 16:33:07 +03:00
struct THREAD_DATA* td;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((td = (struct THREAD_DATA*)malloc(sizeof(struct THREAD_DATA))) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
td->a = 100;
td->b = 200;
td->c = 300;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if (!TlsSetValue(g_slot, td))
ExitSys("TlsSetValue");
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
Foo("Thread2");
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
free(td);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
return 0;
2024-04-29 13:28:55 +03:00
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-05-20 16:33:07 +03:00
Standart C kütüphanesi fonksiyonları ı ı ı ı
bazı ı ı ı ı
nası ı ı ı ı
init ve exit fonksiyonları ı ı ı ı ı ı
konusuysa dinamik kütüphanenin bazı ı ı ı ı ı ı
kendi kütüphanesinin içerine alabilmektedir. Ancak statik kütüphanelerde böyle bir callback mekanizması
C kütüphanesinin statik versiyonunu yazarken mecburen sarma thread fonksiyonları ı ı
kütüphanesi kullanı ı
çağı ı ı ı ı
tarafı ı ı ı ı ı
çağrı ı ı ı ı ı ı
fonksiyonları ı ı ı ı ı ı ı ı ı
biçimde xxxxx_r ismiyle yazı ı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* cstdlib.h */
#ifndef CSTDLIB_H_
#define CSTDLIB_H_
#include <stddef.h>
/* Type Definitions */
typedef struct tagCSTDLIB_STATIC_DATA {
char *strtok_pos;
size_t rand_next;
} CSTDLIB_STATIC_DATA;
/* Function Prototypes */
int init_cstdlib(void);
void exit_cstdlib(void);
int init_csdlib_thread(void);
int exit_csdlib_thread(void);
char *csd_strtok(char *str, const char *delim);
void csd_srand(size_t seed);
int csd_rand(void);
#endif
/* cstdlib.c */
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "cstdlib.h"
static DWORD g_cstdSlot;
int init_cstdlib(void)
{
CSTDLIB_STATIC_DATA *clib;
if ((g_cstdSlot = TlsAlloc()) == TLS_OUT_OF_INDEXES)
return 0;
return 1;
}
int init_csdlib_thread(void)
{
CSTDLIB_STATIC_DATA *clib;
if ((clib = (CSTDLIB_STATIC_DATA *)malloc(sizeof(CSTDLIB_STATIC_DATA))) == NULL) {
TlsFree(g_cstdSlot);
return 0;
}
clib->rand_next = 1;
if (!TlsSetValue(g_cstdSlot, clib))
return 0;
}
int exit_csdlib_thread(void)
{
CSTDLIB_STATIC_DATA *clib;
if ((clib = (CSTDLIB_STATIC_DATA *)malloc(sizeof(CSTDLIB_STATIC_DATA))) == NULL) {
TlsFree(g_cstdSlot);
return 0;
}
free(clib);
}
void exit_cstdlib(void)
{
TlsFree(g_cstdSlot);
}
char *csd_strtok(char *str, const char *delim)
{
CSTDLIB_STATIC_DATA *clib;
char *beg;
if ((clib = TlsGetValue(g_cstdSlot)) == NULL)
return NULL;
if (str != NULL)
clib->strtok_pos = str;
while (*clib->strtok_pos != '\0' && strchr(delim, *clib->strtok_pos) != NULL)
++clib->strtok_pos;
if (*clib->strtok_pos == '\0')
return NULL;
beg = clib->strtok_pos;
while (*clib->strtok_pos != '\0' && strchr(delim, *clib->strtok_pos) == NULL)
++clib->strtok_pos;
if (*clib->strtok_pos != '\0')
*clib->strtok_pos++ = '\0';
return beg;
}
void csd_srand(size_t seed)
{
CSTDLIB_STATIC_DATA *clib;
if ((clib = TlsGetValue(g_cstdSlot)) == NULL)
return NULL;
clib->rand_next = seed;
}
int csd_rand(void)
{
CSTDLIB_STATIC_DATA *clib;
if ((clib = TlsGetValue(g_cstdSlot)) == NULL)
return NULL;
clib->rand_next = clib->rand_next * 1103515245 + 12345;
return (unsigned int)(clib->rand_next / 65536) % 32768;
}
/* Sample.c */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include "cstdlib.h"
void ExitSys(LPCSTR lpszMsg);
DWORD __stdcall ThreadProc1(LPVOID lpvParam);
DWORD __stdcall ThreadProc2(LPVOID lpvParam);
int main(void)
{
HANDLE hThread1, hThread2;
DWORD dwThreadID1, dwThreadID2;
if (!init_cstdlib()) {
fprintf(stderr, "cannot initialize CSD Standard C Library!..\n");
exit(EXIT_FAILURE);
}
if ((hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0, &dwThreadID1)) == NULL)
ExitSys("CreateThread");
if ((hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, &dwThreadID2)) == NULL)
ExitSys("CreateThread");
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
exit_cstdlib();
return 0;
}
DWORD __stdcall ThreadProc1(LPVOID lpvParam)
{
char s[] = "ali, veli, selami, ayşe, fatma";
char *str;
int i, val;
if (!init_csdlib_thread()) {
fprintf(stderr, "CSDLib initialization failed!..\n");
exit(EXIT_FAILURE);
}
for (str = csd_strtok(s, ", "); str != NULL; str = csd_strtok(NULL, ", "))
printf("threadproc1 --> %s\n", str);
for (i = 0; i < 10; ++i) {
val = csd_rand();
printf("threadproc1_rand --> %d\n", val);
}
exit_csdlib_thread();
return 0;
}
DWORD __stdcall ThreadProc2(LPVOID lpvParam)
{
char s[] = "adana, izmir, balikesir, muğla";
char *str;
int i, val;
if (!init_csdlib_thread()) {
fprintf(stderr, "CSDLib initialization failed!..\n");
exit(EXIT_FAILURE);
}
for (str = csd_strtok(s, ", "); str != NULL; str = csd_strtok(NULL, ", "))
printf("threadproc2 --> %s\n", str);
for (i = 0; i < 10; ++i) {
val = csd_rand();
printf("threadproc2_rand --> %d\n", val);
}
exit_csdlib_thread();
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-05-20 16:33:07 +03:00
UNIX/Linux sistemlerinde thread'e özgü statik alanlara "Thread Specific Data (TSD)" denilmektedir. Genel kullanı
sistemlerindekilere oldukça benzemektedir. Sı ı ı ı ı
1) Önce pthread_key_create fonksiyonu ile TSD için bir slot yaratı ı
benzetebiliriz. Fonksiyonun prototipi şöyledir:
#include <pthread.h>
int pthread_key_create(pthread_key_t *key, void (*destructor)(void *));
Fonksiyonun birinci parametresi slot anahtarı ı ı
bilgisini bu nesnenin içerisine yerleştirmektedir. Tipik olarak programcı ı
Fonksiyonun ikinci parametresi thread sonlandı ı ı ı
Bu durumda sonlanma sı ı ı ı ı ı ı ı ı
2) TSD slotuna yerleştirme yapmak için pthread_setspecific slottan değer almak için ise pthread_getspecific fonksiyonları ı ı
Fonksiyonları
#include <pthread.h>
int pthread_setspecific(pthread_key_t key, const void *value);
void *pthread_getspecific(pthread_key_t key);
pthread_setspecific fonksiyonunun birinci parametresi slotu belirten pthread_key_t türünden nesneyi ikinci parametresi ise o slota yerleştirilecek
adresi almaktadı ı
TlsSetValue ve TlsGetValue fonksiyonları ı ı ı ı
ise errno değerine geri dönmektedir. pthread_getspecific fonksiyonu başarı ı ı
3) Kullanı
#include <pthread.h>
int pthread_key_delete(pthread_key_t key);
Fonksiyon slota ilişkin pthread_key_t türünden nesneyi parametre olarak alı ı ı ı ı ı ı
errno değerine geri döner.
pthread_key_create fonksiyonunun ikinci parametresine geçirilecek destructor fonksiyonunun parametrik yapı ı ı ı
void destructor(void *value);
Fonksiyona TSD alanı ı
dinamik tahsis edilen alanları
Aşağı ı ı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
2024-05-20 16:33:07 +03:00
#include <unistd.h>
2024-04-29 13:28:55 +03:00
#include <pthread.h>
2024-05-20 16:33:07 +03:00
void foo(const char *str);
void destructor(void *value);
void *thread_proc1(void *param);
void *thread_proc2(void *param);
void exit_sys_errno(const char *msg, int eno);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
struct THREAD_DATA {
int a;
int b;
int c;
};
2024-04-29 13:28:55 +03:00
pthread_key_t g_tsdkey;
int main(void)
{
pthread_t tid1, tid2;
2024-05-20 16:33:07 +03:00
int result;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((result = pthread_key_create(&g_tsdkey, destructor)) != 0)
exit_sys_errno("pthread_key_create", result);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((result = pthread_create(&tid1, NULL, thread_proc1, NULL)) != 0)
exit_sys_errno("pthread_create", result);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((result = pthread_create(&tid2, NULL, thread_proc2, NULL)) != 0)
exit_sys_errno("pthread_create", result);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((result = pthread_join(tid1, NULL)) != 0)
exit_sys_errno("pthread_join", result);
if ((result = pthread_join(tid2, NULL)) != 0)
exit_sys_errno("pthread_join", result);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((result = pthread_key_delete(g_tsdkey)) != 0)
exit_sys_errno("pthread_key_delete", result);
2024-04-29 13:28:55 +03:00
return 0;
}
2024-05-20 16:33:07 +03:00
void foo(const char *str)
2024-04-29 13:28:55 +03:00
{
2024-05-20 16:33:07 +03:00
struct THREAD_DATA *td;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((td = (struct THREAD_DATA *)pthread_getspecific(g_tsdkey)) == NULL) {
fprintf(stderr, "cannot get key value!..\n");
exit(EXIT_FAILURE);
}
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
printf("%s: %d, %d, %d\n", str, td->a, td->b, td->c);
2024-04-29 13:28:55 +03:00
}
2024-05-20 16:33:07 +03:00
void destructor(void *value)
{
free(value);
2024-04-29 13:28:55 +03:00
}
2024-05-20 16:33:07 +03:00
void *thread_proc1(void *param)
2024-04-29 13:28:55 +03:00
{
2024-05-20 16:33:07 +03:00
struct THREAD_DATA* td;
int result;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((td = (struct THREAD_DATA*)malloc(sizeof(struct THREAD_DATA))) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
td->a = 10;
td->b = 20;
td->c = 30;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((result = pthread_setspecific(g_tsdkey, td)) != 0)
exit_sys_errno("pthread_setspecific", result);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
sleep(5);
foo("Thread1");
return NULL;
2024-04-29 13:28:55 +03:00
}
2024-05-20 16:33:07 +03:00
void *thread_proc2(void *param)
2024-04-29 13:28:55 +03:00
{
2024-05-20 16:33:07 +03:00
struct THREAD_DATA* td;
int result;
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
if ((td = (struct THREAD_DATA*)malloc(sizeof(struct THREAD_DATA))) == NULL) {
fprintf(stderr, "cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
td->a = 100;
td->b = 200;
td->c = 300;
if ((result = pthread_setspecific(g_tsdkey, td)) != 0)
exit_sys_errno("pthread_setspecific", result);
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
foo("Thread2");
2024-04-29 13:28:55 +03:00
2024-05-20 16:33:07 +03:00
return NULL;
2024-04-29 13:28:55 +03:00
}
2024-05-20 16:33:07 +03:00
void exit_sys_errno(const char *msg, int eno)
2024-04-29 13:28:55 +03:00
{
2024-05-20 16:33:07 +03:00
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
2024-04-29 13:28:55 +03:00
exit(EXIT_FAILURE);
}
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
90. Ders 25/05/2024 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bugün işletim sistemlerinde en çok kullanı ı
(round robin scheduling)" denilen tekniktir. Döngüsel çizelgelemede her thread sı ı ı ı ı ı
sistemine özgü ayrı ı ı ı
süreleri atar. Quanta süresini dolduran thread'lerin quanta süreleri yeniden doldurulmadan önce çalı
quanta sürelerinin bitmesi beklenmektedir. Tabii bir thread çalı ı ı
kullanamayabilmektedir. İşletim sistemi her thread'in quanta süresinden harcağı ı ı
60 ms. quanta süresi verdiğini düşünelim. O anda da çalı ı
T1 (40 ms)
T2 (0 ms) ==> quanta süresi bitti
T3 (10 ms)
T4 (25 ms)
Burada T2 thread'inin ona atanan 60 ms'lik quanta süresinin dolduğunu varsayalı
doldurmayacaktı ı ı ı
birlikte 60 ms ile dolduracaktı
olacaktı ı ı
thread'lerin quanta süreleri sı ı ı ı ı
İşte işletim sistemleri genellikle blokede bekleyen thread'lere de doldurma yapmaktadı ı ı
sahip olacak biçimde daha fazla çalı ı ı ı ı ı ı ı
da anomali yaratabilmektedir. Bunun için işletim sistemleri blokede bekleyen thread'ler için maksimum bir üst sı ı
Pekiyi çalı ı ı
bu konuda işletim sistemleri arası ı ı ı ı ı
SCHED_OTHER çizelgeleme politikası ı ı ı
bir thread'in önceliğini artı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-05-20 16:33:07 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Thread'li işletim sistemlerinde thread'lerin zaman paylaşı ı ı
olarak thread'lere öncelik dereceleri atanabilmektedir. Böylece yksek öncelikli thread'lerin CPU'dan daha fazla zaman alması
Thread öncelikleri konusu yukarı ı ı
durumu sonra da UNIX/Linux sistemlerindeki durumu kabaca ele alacağı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinin kullandı ı ı ı ı ı
robin scheduling )" denilmektedir. Windows'ta her thread'in [0, 31] arası ı ı
thread'lerin default öncelik dereceleri 8'dir.
Windows'ta thread'ler şöyle çizelgelenmektedir: Önce en yüksek önceliğe sahip thread'lerden bir grup oluşturulur. Sanki diğer thread'ler
hiç yokmuş gibi yalnı ı ı ı ı ı ı ı
düşük öncelikli en yüksek grup aynı ı ı
yüksek öncelikli thread'lerin sonlanması ı
2024-06-09 22:42:45 +03:00
sistemi düşük öncelikli thread'in çalı ı
2024-05-20 16:33:07 +03:00
aşağı
T1 -> 12
T2 -> 12
T3 -> 10
T4 -> 9
T5 -> 9
T6 -> 8
T7 -> 8
T8 -> 8
Burada sistem sanki diğer thread'ler yokmuş gibi T1 ve T2 thread'lerini kendi araları ı ı ı ı ı
Bu thread'ler sonlanı ı ı ı ı
T4 thread'i, o da sonlanı ı ı ı
Görüldüğü gibi bu sistemde düşük öncelikli bir thread'in çalı ı ı
gerekmektedir.
Windows'un çizelgeleme algoritması ı ı ı ı
2024-06-09 22:42:45 +03:00
sistemlerde eeğer boşta işlemci ya da çekirdek varsa işletim sistemi daha düşük öncelikli sı ı ı
atayabilmektedir.
Windows'ta bir thread'in [0, 31] arası ı ı ı ı
Göreli Öncelik Derecesi. Prosesin öncelik sı ı ı ı
öncelik sı ı ı ı
NORMAL_PRIORITY_CLASS (8 default)
ABOVE_NORMAL_PRIORITY_CLASS (10)
BELOW_NORMAL_PRIORITY_CLASS (6)
HIGH_PRIORITY_CLASS (13)
REALTIME_PRIORITY_CLASS (24)
IDLE_PRIORITY_CLASS (4)
Thread'in göreli öncelik dereceleri de şöyledir:
THREAD_PRIORITY_NORMAL (0 default)
THREAD_PRIORITY_IDLE (Öncelik sı ı ı
THREAD_PRIORITY_LOWEST (-2)
THREAD_PRIORITY_BELOW_NORMAL (-1)
THREAD_PRIORITY_ABOVE_NORMAL (+1)
THREAD_PRIORITY_HIGHEST (+2)
THREAD_PRIORITY_TIME_CRITICAL (Öncelik sı ı ı
Herhangi bir öncelik oluşturmak için bu ikşi ayarlamadı ı ı ı
Default durumda prosesin öncelik sı ı ı
thread'in öncelik derecesi 8 + 0 = 8 biçimindedir. Örneğin thread önceliğini 15 yapmak isteyelim. Bunun birkaç yolu olabilir:
IDLE_PRIORITY_CLASS + THREAD_PRIORITY_TIME_CRITICAL
BELOW_NORMAL_PRIORITY_CLASS + THREAD_PRIORITY_TIME_CRITICAL
NORMAL_PRIORITY_CLASS + THREAD_PRIORITY_TIME_CRITICAL
ABOVE_NORMAL_PRIORITY_CLASS + THREAD_PRIORITY_TIME_CRITICAL
HIGH_PRIORITY_CLASS + THREAD_PRIORITY_TIME_CRITICAL
HIGH_PRIORITY_CLASS + THREAD_PRIORITY_TIME_CRITICAL
Thread'in önceliğini 31'e çekmek isteyelim. Bunun tek yolu şöyleidr:
2024-05-20 16:33:07 +03:00
2024-06-09 22:42:45 +03:00
REALTIME_PRIORITY_CLASS + THREAD_PRIORITY_TIME_CRITICAL
2024-05-20 16:33:07 +03:00
2024-06-09 22:42:45 +03:00
Thread önceliklerinin belirlenmesine ilişkin Microsoft dokğmanları ı ı
https://learn.microsoft.com/en-us/windows/win32/procthread/scheduling-priorities
2024-05-20 16:33:07 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
Prosesin öncelik sı ı ı ı ı ı ı
prototipleri şöyledir:
DWORD GetPriorityClass(
HANDLE hProcess
);
BOOL SetPriorityClass(
HANDLE hProcess,
DWORD dwPriorityClass
);
Fonksiyonları ı ı ı
prosesin öncelik sı ı ı ı ı ı ı
sı ı ı ı ı ı ı ı ı ı
bir değere başarsı ı ı ı ı ı ı
GetCurrentProcess API fonksiyonuyla elde edilmektedir.
Biz bir prosesin öncelik sı ı ı ı ı ı ı
bu konuya girmeyeceğiz. Ancak bu tür uygulamalarda programı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Aşağı ı ı ı ı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
LPCSTR GetPriorityClassName(DWORD dwPriority);
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
DWORD dwPriorityClass;
if ((dwPriorityClass = GetPriorityClass(GetCurrentProcess())) == 0)
ExitSys("GetPriorityClass");
puts(GetPriorityClassName(dwPriorityClass));
2024-06-09 22:42:45 +03:00
if (!SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS))
ExitSys("SetPriorityClass");
if ((dwPriorityClass = GetPriorityClass(GetCurrentProcess())) == 0)
ExitSys("GetPriorityClass");
puts(GetPriorityClassName(dwPriorityClass));
2024-04-29 13:28:55 +03:00
return 0;
}
LPCSTR GetPriorityClassName(DWORD dwPriority)
{
2024-06-09 22:42:45 +03:00
const char *pszName = "NONE";
2024-04-29 13:28:55 +03:00
switch (dwPriority) {
2024-06-09 22:42:45 +03:00
case ABOVE_NORMAL_PRIORITY_CLASS:
pszName = "ABOVE_NORMAL_PRIORITY_CLASS";
break;
case BELOW_NORMAL_PRIORITY_CLASS:
pszName = "BELOW_NORMAL_PRIORITY_CLASS";
break;
case HIGH_PRIORITY_CLASS:
pszName = "HIGH_PRIORITY_CLASS";
break;
case IDLE_PRIORITY_CLASS:
pszName = "IDLE_PRIORITY_CLASS";
break;
case NORMAL_PRIORITY_CLASS:
pszName = "NORMAL_PRIORITY_CLASS";
break;
case REALTIME_PRIORITY_CLASS:
pszName = "REALTIME_PRIORITY_CLASS";
break;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
return pszName;
2024-04-29 13:28:55 +03:00
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
Thread'in göreli önceliğini almak ve set etmek için GetThreadPriorty ve SetThreadPriority API fonksiyonları ı ı ı
prototipleri şöyledir:
int GetThreadPriority(
HANDLE hThread
);
BOOL SetThreadPriority(
HANDLE hThread,
int nPriority
);
Fonksiyonları ı ı
fonksiyonunun ikinci parametresi thread'in göreli önceliğini belirtmektedir. GetThreadPriority fonksiyonu başarı ı
göreli önceliği ile geri dönmektedir. SetThreadPriority fonksiyonu başarı ı ı ı ı ı ı ı ı ı
değerine geri dönmektedir. O anda çalı
Aşağı ı ı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
LPCSTR GetThreadPriorityName(int threadPriority);
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
int threadPriority;
if ((threadPriority = GetThreadPriority(GetCurrentThread())) == THREAD_PRIORITY_ERROR_RETURN)
ExitSys("GetPriorityClass");
puts(GetThreadPriorityName(threadPriority));
2024-06-09 22:42:45 +03:00
if (!SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL))
ExitSys("SetThreadPriority");
if ((threadPriority = GetThreadPriority(GetCurrentThread())) == THREAD_PRIORITY_ERROR_RETURN)
ExitSys("GetPriorityClass");
puts(GetThreadPriorityName(threadPriority));
2024-04-29 13:28:55 +03:00
return 0;
}
LPCSTR GetThreadPriorityName(int threadPriority)
{
2024-06-09 22:42:45 +03:00
const char *pszName = "NONE";
2024-04-29 13:28:55 +03:00
switch (threadPriority) {
case THREAD_PRIORITY_ABOVE_NORMAL:
2024-06-09 22:42:45 +03:00
pszName = "THREAD_PRIORITY_ABOVE_NORMAL";
2024-04-29 13:28:55 +03:00
break;
case THREAD_PRIORITY_BELOW_NORMAL:
2024-06-09 22:42:45 +03:00
pszName = "THREAD_PRIORITY_BELOW_NORMAL";
2024-04-29 13:28:55 +03:00
break;
case THREAD_PRIORITY_HIGHEST:
2024-06-09 22:42:45 +03:00
pszName = "THREAD_PRIORITY_HIGHEST";
2024-04-29 13:28:55 +03:00
break;
case THREAD_PRIORITY_IDLE:
2024-06-09 22:42:45 +03:00
pszName = "THREAD_PRIORITY_IDLE";
2024-04-29 13:28:55 +03:00
break;
case THREAD_PRIORITY_LOWEST:
2024-06-09 22:42:45 +03:00
pszName = "THREAD_PRIORITY_LOWEST";
2024-04-29 13:28:55 +03:00
break;
case THREAD_PRIORITY_NORMAL:
2024-06-09 22:42:45 +03:00
pszName = "THREAD_PRIORITY_NORMAL";
2024-04-29 13:28:55 +03:00
break;
case THREAD_PRIORITY_TIME_CRITICAL:
2024-06-09 22:42:45 +03:00
pszName = "THREAD_PRIORITY_TIME_CRITICAL";
2024-04-29 13:28:55 +03:00
break;
}
2024-06-09 22:42:45 +03:00
return pszName;
2024-04-29 13:28:55 +03:00
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
Aşağı ı
çalı ı ı ı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
2024-06-09 22:42:45 +03:00
LPCSTR GetPriorityClassName(DWORD dwPriority);
LPCSTR GetThreadPriorityName(int threadPriority);
2024-04-29 13:28:55 +03:00
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
2024-06-09 22:42:45 +03:00
DWORD dwPriorityClass;
int threadPriority;
if ((dwPriorityClass = GetPriorityClass(GetCurrentProcess())) == 0)
ExitSys("GetPriorityClass");
puts(GetPriorityClassName(dwPriorityClass));
if ((threadPriority = GetThreadPriority(GetCurrentThread())) == THREAD_PRIORITY_ERROR_RETURN)
ExitSys("GetPriorityClass");
puts(GetThreadPriorityName(threadPriority));
printf("-----------------------\n");
2024-04-29 13:28:55 +03:00
if (!SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS))
ExitSys("SetPriorityClass");
if (!SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL))
ExitSys("SetThreadPriority");
2024-06-09 22:42:45 +03:00
if ((dwPriorityClass = GetPriorityClass(GetCurrentProcess())) == 0)
ExitSys("GetPriorityClass");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
puts(GetPriorityClassName(dwPriorityClass));
if ((threadPriority = GetThreadPriority(GetCurrentThread())) == THREAD_PRIORITY_ERROR_RETURN)
ExitSys("GetPriorityClass");
puts(GetThreadPriorityName(threadPriority));
getchar();PCSTR GetPriorityClassName(DWORD dwPriority)
{
const char *pszName = "NONE";
switch (dwPriority) {
case ABOVE_NORMAL_PRIORITY_CLASS: pszName = "ABOVE_NORMAL_PRIORITY_CLASS";
brezName = "BELOW_NORMAL_PRIORITY_CLASS";
break;
case HIGH_PRIORITY_CLASS:
pszName = "HIGH_PRIORITY_CLASS";
break;
case IDLE_PRIORITY_CLASS:
pszName = "IDLE_PRIORITY_CLASS";
break;
case NORMAL_PRIORITY_CLASS:
pszName = "NORMAL_PRIORITY_CLASS";
break;
case REALTIME_PRIORITY_CLASS:
pszName = "REALTIME_PRIORITY_CLASS";
break;
}
return pszName;
}
LPCSTR GetThreadPriorityName(int threadPriority)
{
const char *pszName = "NONE";
switch (threadPriority) {
case THREAD_PRIORITY_ABOVE_NORMAL:
pszName = "THREAD_PRIORITY_ABOVE_NORMAL";
break;
case THREAD_PRIORITY_BELOW_NORMAL:
pszName = "THREAD_PRIORITY_BELOW_NORMAL";
break;
case THREAD_PRIORITY_HIGHEST:
pszName = "THREAD_PRIORITY_HIGHEST";
break;
case THREAD_PRIORITY_IDLE:
pszName = "THREAD_PRIORITY_IDLE";
break;
case THREAD_PRIORITY_LOWEST:
pszName = "THREAD_PRIORITY_LOWEST";
break;
case THREAD_PRIORITY_NORMAL:
pszName = "THREAD_PRIORITY_NORMAL";
break;
case THREAD_PRIORITY_TIME_CRITICAL:
pszName = "THREAD_PRIORITY_TIME_CRITICAL";
break;
}
return pszName;
2024-04-29 13:28:55 +03:00
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
UNIX/Linux sistemlerinde her thread'in belirlenmiş olan bir "çizelgeleme politikası ı ı
göre şu çizelgeleme politikaları ı
SCHED_FIFO
SCHED_RR
SCHED_OTHER
SCHED_SPORADIC
SCHED_SPORADIC politikası ı ı ı ı ı ı ı ı
çizelgeleme politikalrı ı ı ı ı ı ı
isteğine bı ı ı ı ı ı ı ı ı
yazanları ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
POSIX standartları ı ı ı
öncelik 20'dir. Dinamik öncelikte yüksek değer düşük öncelik, düşük değer yüksek öncelik belirtmektedir. Linux sistemlerinde thread'lere
quanta doldurulurken her thread'e o thread'in dinamik önceliği ile orantı ı ı
olan thread'lere daha fazla quanta süresi, dinamik önceliği düşük thread'lere daha az quanta süresi atanmaktadı ı
diğer thread'lere göre daha fazla CPU zamanı ı ı
süresi arası ı
dinamik önceliğin etkisi nispeten azdı
Eskiden UNIX/Linux sistemlerinde thread kavramı ı
sistemlere eklenince thread'lerin de dinamik öncelikleri oluşturuldu. Ancak eski POSIX fonksiyonları ı
göre bir prosesin dinamik önceliğ değiştirildiğinde prosesin tüm thread'lerinin dinamik önceliği değiştirilmiş olmalı ı
sistemleri bu kurala uymamaktadı ı
etkilenmektedir. (Halbuki POSIX standartları ı ı ı
değişmesi gerekmektedir.)
Dinamik önceliği değiştirmede en çok kullanı
değiştirmektedir. (Linux sistemlerinde bu durum tüm thread2lerin değil ana thread'in dinamik önceliğinin değiştirilmesine yol açmaktadı
nice fonksiyonun protoripi şöyledir:
#include <unistd.h>
int nice(int inc);
nice fonksiyonu prosesin dinamik önceliğini o anki dinamik öncelikten parametresi belirtilen miktarda yükseltir ya da alçaltı
parametrenin anlamı ı
[-20, +19] arası ı
belirten 39 olur, -20 verirsek dinamik öncelik en yükske değeri belirten 0 olur. Fonksiyon başarı ı ı ı
durumunda -1 değerine geri dönmektedir. nice fonksiyonu ile sı
yükseltemezler (negatif parametre). Yükseltme işlemi için prosesin uygun önceliğe sahip olması ı ı ı ı ı
gerekmektedir. Prosesin nice değeri getpriority POSIX fonksiyonyla elde edilebilmektedir.
nice fonksiyonun prosesin dinamik önceliğini değiştirdiğini belirtmiştik. Yalnı
pthread_schedsetparam fonksiyonu kullanı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı
UNIX/Linux sistemlerinde çalı ı
thread çizelgelenmemektedir. Tabii çok işlemcili ya da çekirdekli sistemlerde SCHED_FIFO ya da SCHED_RR thread'ler CPU'ya atabndı
çalı ı
Yani SCHED_FIFO ve SCHED_RR thread'lerin SCHED_OTHER thread'lere tam bir üstünlüğü vardı
araları ı ı
SCHED_FIFO ve ve SCHED_RR thread'lerin de birer önceliği vardı ı ı
Linux sistemlerinde SCHED_FIFO ve SCHED_RR thread'lerin öncelik derecesi 1 ile 99 arası ı
Ancak POSIX standartları
sched_get_priority_max fonksiyonları
Çalı ı ı
Çizelgeleme algoritması
1) Çizelgeleyici kuyruktaki en yüksek önceliğe sahip olanlar arası
atanan thread SCHED_FIFO ise bloke olana kadar sürekli çalı ı ı ı ı ı
Ancak atanan CPU'ya atanan thread SCHED_RR ise bir quanta çalı ı ı ı ı ı
2) SCHED_FIFO thread bloke olursa bu durumda kuyrukta en yüksek öncelikte ve önde olan ilk SCHED_FIFO ya da SCHED_RR thread CPU'ya atanı
3) Bloke olmuş olan bir thread'in blokesi çözüldüğünde eğer o anda çalı ı
olan thread'in çalı ı ı ı ı ı ı ı ı
ise bir quanta çalı ı ı ı ı ı ı
daha düşük öncelikli ise kuyruğun sonuna alı ı ı
thread'se kuyruğun önüne yerleştirilir. SCHED_RR thread'se kuyruğun sonuna alı ı
Bu çizelgeleme sisteminde şu durumlara dikkat ediniz.
- Bu sistemde çalı ı ı ı
çizelgelemeye çok benzer durumdadı ı
- CPU'ya atanmı ı ı
uyanması ı ı ı ı ı
bu sistemlerde "sürekli çalı ı ı ı
SCHED_FIFO thread'ler diğer thread'lerin çalı ı ı
Aşağı ı ı
ve sched_get_priority_max fonksiyonları ı ı ı ı ı
döndürmektedir.
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
2024-06-09 22:42:45 +03:00
#include <time.h>
2024-04-29 13:28:55 +03:00
#include <pthread.h>
2024-06-09 22:42:45 +03:00
#include <unistd.h>
#include <semaphore.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#define QUEUE_SIZE 10
void *thread_producer(void *param);
void *thread_consumer(void *param);
void exit_sys(const char *msg);
void exit_sys_errno(const char *msg, int eno);
sem_t g_sem_producer;
sem_t g_sem_consumer;
int g_queue[QUEUE_SIZE];
size_t g_head;
size_t g_tail;
2024-04-29 13:28:55 +03:00
int main(void)
{
2024-06-09 22:42:45 +03:00
pthread_t tid1, tid2;
int result;
if (sem_init(&g_sem_producer, 0, QUEUE_SIZE) == -1)
exit_sys("sem_init");
if (sem_init(&g_sem_consumer, 0, 0) == -1)
exit_sys("sem_init");
if ((result = pthread_create(&tid1, NULL, thread_producer, NULL)) != 0)
exit_sys_errno("pthread_create", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((result = pthread_create(&tid2, NULL, thread_consumer, NULL)) != 0)
exit_sys_errno("pthread_create", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((result = pthread_join(tid1, NULL)) != 0)
exit_sys_errno("pthread_join", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((result = pthread_join(tid2, NULL)) != 0)
exit_sys_errno("pthread_join", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (sem_destroy(&g_sem_consumer) == -1)
exit_sys("sem_destroy");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (sem_destroy(&g_sem_producer) == -1)
exit_sys("sem_destroy");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return 0;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void *thread_producer(void *param)
{
int val;
unsigned seed;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
seed = time(NULL) + 123;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
val = 0;
for (;;) {
usleep(rand_r(&seed) % 300000);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (sem_wait(&g_sem_producer) == -1)
exit_sys("sem_wait");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
g_queue[g_tail] = val;
g_tail = (g_tail + 1) % QUEUE_SIZE;
if (sem_post(&g_sem_consumer) == -1)
exit_sys("sem_post");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (val == 99)
break;
++val;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return NULL;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
void *thread_consumer(void *param)
{
int val;
unsigned seed;
seed = time(NULL) + 456;
for (;;) {
if (sem_wait(&g_sem_consumer) == -1)
exit_sys("sem_wait");
val = g_queue[g_head];
g_head = (g_head + 1) % QUEUE_SIZE;
if (sem_post(&g_sem_producer) == -1)
exit_sys("sem_post");
usleep(rand_r(&seed) % 300000);
printf("%d ", val);
fflush(stdout);
if (val == 99)
break;
}
printf("\n");
return NULL;
}
void exit_sys(const char *msg)
2024-04-29 13:28:55 +03:00
{
perror(msg);
exit(EXIT_FAILURE);
}
2024-06-09 22:42:45 +03:00
void exit_sys_errno(const char *msg, int eno)
{
fprintf(stderr, "%s: %s\n", msg, strerror(eno));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
91. Ders 26/05/2024 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
Pekiyi bir prosesin ya da thread'in çizelgeleme politikası ı ı
çizelgeleme politikası ı ı
Linux sistemlerinde doğrudan ilgili sistem fonksiyonları ı ı ı ı
#include <sched.h>
int sched_setscheduler(pid_t pid, int policy, const struct sched_param *param);
int sched_getscheduler(pid_t pid);
Fonksiyonları ı ı
işlem yapı ı ı ı ı
çizelgeleme politikaları
Bu parametre yalnı ı ı ı ı ı ı ı
durumunda -1 değerine geri dönmektedir. sched_getscheduler fonksiyonu da başarı ı ı ı ı
değerine geri dönmektedir.
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Prosesin çizelgeleme politikası ı ı ı
gerekir.
Aşağı ı ı ı ı ı
Tabii programı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
void* thread_proc(void* param);
void exit_errno(const char* msg, int result);
int main(void)
{
int result;
pthread_t tid;;
if ((result = pthread_create(&tid, NULL, thread_proc, NULL)) != 0)
exit_errno("pthread_create", result);
pthread_join(tid, NULL);
return 0;
}
void* thread_proc(void* param)
{
struct sched_param sparam;
int result;
long i;
sparam.sched_priority = 99;
if ((result = pthread_setschedparam(pthread_self(), SCHED_FIFO, &sparam)) != 0)
exit_errno("pthread_setschedparam", result);
for (i = 0; i < 1000000000; ++i)
;
return NULL;
}
void exit_errno(const char* msg, int result)
{
fprintf(stderr, "%s: %s\n", msg, strerror(result));
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
Yukarı ı ı ı
bundan prosesin tüm thread'leri etkilenmektedir. Ancak Linux'ta bundan yalnı
thread'imizin de diğerlerin bağı ı ı ı
pthread_getschedparam fonksiyonları ı ı
#include <pthread.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param);
int pthread_getschedparam(pthread_t thread, int *policy, struct sched_param *param);
Fonksiyonlar sched_setscheduler ve sched_getscheduler fonksiyonları ı ı ı
parametre olarak almaktadı ı ı ı ı ı
durumunda errno değerine geri dönemektedir.
Aşağı ı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
2024-06-09 22:42:45 +03:00
#include <string.h>
#include <pthread.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void* thread_proc(void* param);
void exit_errno(const char* msg, int result);
2024-04-29 13:28:55 +03:00
int main(void)
{
int result;
2024-06-09 22:42:45 +03:00
pthread_t tid;;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((result = pthread_create(&tid, NULL, thread_proc, NULL)) != 0)
exit_errno("pthread_create", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
pthread_join(tid, NULL);
2024-04-29 13:28:55 +03:00
return 0;
}
2024-06-09 22:42:45 +03:00
void* thread_proc(void* param)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
struct sched_param sparam;
int result;
sparam.sched_priority = 99;
if ((result = pthread_setschedparam(pthread_self(), SCHED_FIFO, &sparam)) != 0)
exit_errno("pthread_setschedparam", result);
for (long i = 0; i < 1000000000; ++i)
;
return NULL;
}
void exit_errno(const char* msg, int result)
{
fprintf(stderr, "%s: %s\n", msg, strerror(result));
2024-04-29 13:28:55 +03:00
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
Kütüphane (library) kavramı ı ı ı ı ı ı
bir terimdir. Ancak aşağı ı ı ı ı
denilmektedir.
Kütüphaneler statik ve dinamik olmak üzere ikiye ayrı ı ı ı
ve macOS sistemlerindeki uzantı ı ı ı
ve macOS sistemlerindeki uzantı ı ı ı ı ı
"dll" uzantı ı ı ı ı ı ı ı
Kütüphane konusunun aslı ı ı ı ı ı ı
bilgiler edineceğiz.
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Derleyicilerin ürettiği dosyalara "amaç dosyalar (object files)" ya da "yeniden yüklemebilen dosyalar (relocatable object files)" denilmektedir.
Bağlayı ı ı ı ı ı ı
oluşturmaktadı ı ı ı ı ı
tipik bir C projesi şöyle derlenip oluşturulmaktadı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
a1.c ----> Derleyici ----> a1.obj ----> \
a2.c ----> Derleyici ----> a2.obj ----> \
a3.c ----> Derleyici ----> a3.obj ----> ===> Bağlayı ı ı ı ı
a4.c ----> Derleyici ----> a4.obj ----> / /
a5.c ----> Derleyici ----> a5.obj ----> / /
Kütüphane Dosyaları
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Amaç dosyaları ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Pekiyi bağlayı ı ı ı ı
bir program söz konusu olsun:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* a1.c */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
extern int g_x;
void foo(void);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int main(void)
{
g_x = 10;
foo(); CALL adres
return 0;
}
/* a2.c */
int g_x;
void foo(void)
{
printf("foo\n");
}
Proje oluşturan bu "a1.c" ve "a2.c" dosyaları ı ı ı ı
derlendiğinde foo fonksiyonu o dosya yoktur. g_x global değişkeni de o dosyada yoktur. Pekiyi oradaki makine komutları ı
İşte derleyiciler bu yüt durumlarda makine kodları ı ı ı ı ı ı ı ı ı ı ı ı ı
Bu işleme "relocation" denilmektedir. "a1.c" dosyası ı ı
foo();
Bir fonksiyonun çağrı ı ı ı
almaktadı
CALL <adres>
Oysa derleyici derleme aşaması ı ı
yerini bulunup ilgili adresin düzeltilmesini" talep etmektedir. Bu relocation bilgileri amaç dosyanı ı
bağlayı ı ı ı ı ı ı ı
foo fonksiyonunu bağlayı ı ı ı ı ı
olan kütğphane amaç dosyalarda aramaktadı ı ı ı ı ı
da bakmaktadı
Standart C fonksiyonları ı ı ı ı
aşaması ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
Statik kütüphane dosyaları ı ı ı ı ı
değil amaç dosyalar bulunmaktadı ı ı ı
içerisine yazarı ı ı
C derleyicilerinde dosyayı ı ı ı
cl /c myutil.c
gcc -c myutil.c
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Microsoft Windows sistemlerinde statik kütüphane dosyaları
yardı ı ı
otomatik olarak kurulmaktadı
lib.exe programı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
lib /OUT:myutil.lib a.obj b.obj
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Burada "myutil.lib" dosyası ı ı ı ı ı
yeniden oluşturulmaktadı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
lib myutil.lib c.obj
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Burada "myutil.lib" "dosyası ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
lib /LIST myutil.lib
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Burada "myutil.lib" içerisindeki amaç dosyalar görüntülenir.
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
lib /REMOVE:a.obj myutil.lib
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Burada "myutil.lib" içerisinden "a.obj" dosyası
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
lib /EXTRACT:a.obj myutil.lib
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Burada "myutil.lib" içerisindeki "a.obj" dosyası ı ı
"lib.exe" hakkı ı ı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
https://learn.microsoft.com/en-us/cpp/build/reference/overview-of-lib?view=msvc-170
Aşağı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
cl /c a.c
cl /c b.c
lib /OUT:mmyutil.lib a.obj b.obj
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* a.c */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#include <stdio.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int g_x;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
double add(double a, double b)
{
return a + b;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
double sub(double a, double b)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
return a - b;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
double multiply(double a, double b)
{
return a * b;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
double divide(double a, double b)
{
return a / b;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
/* b.c */
2024-04-29 13:28:55 +03:00
#include <stdio.h>
2024-06-09 22:42:45 +03:00
int g_y;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void foo(void)
{
printf("foo\n");
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void bar(void)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
printf("bar\n");
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir kütüphanedeki fonksiyonlar çağrı ı ı ı
biçimde kütüphane içerisindeki global değişkenlerin kullanı ı
gerekir. Her kütüphane için o kütüphanedeki bildirimleri barı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#ifndef MYUTIL_H_
#define MYUTIL_H_
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* Function Prototypes */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
double add(double a, double b);
double sub(double a, double b);
double multiply(double a, double b);
double divide(double a, double b);
void foo(void);
void bar(void);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* extern Declarations */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
extern int g_x;
extern int g_y;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#endif
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Böylece bu kütüphaneyi kullanacak kişiler bu başlı ı ı
Eğer kütüphane çok fazla öğeden oluşyorsa tek bir başlı ı ı ı
birden çok başlı ı ı ı ı
onlara ilişkin bildirimler çeşitli başlı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bağlayı ı ı ı ı ı ı ı ı
programı ı ı ı ı
zaten bakmaktadı ı ı ı ı ı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Anı ı ı ı
bağlayı ı ı ı ı ı ı ı ı ı ı ı ı
olan kütüphane dosyaları ı ı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
cl app.c myutil.lib
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Burada "app.c" programı ı ı ı ı ı
Oluşturulacak çalı ı ı ı ı ı ı
komut satı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
cl /Fe:project.exe app.c myutil.lib
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Tabii istersek derleyici ve bağlayı ı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
cl /c app.c
link app.obj myutil.lib
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Burada yine default olarak "link.exe" programı ı ı ı ı ı ı ı
dosyanı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
cl /c app.c
link /OUT:project.exe app.obj myutil.lib
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Aşağı ı ı
kullanı ı ı ı ı ı ı
cl -c a.c
cl -c b.c
lib /OUT:myutil.lib a.obj b.obj
cl app.c myutil.lib
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* a.c */
#include <stdio.h>
int g_x;
double add(double a, double b)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
return a + b;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
double sub(double a, double b)
{
return a - b;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
double multiply(double a, double b)
{
return a * b;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
double divide(double a, double b)
{
return a / b;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* b.c */
2024-04-29 13:28:55 +03:00
#include <stdio.h>
2024-06-09 22:42:45 +03:00
int g_y;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void foo(void)
{
printf("foo\n");
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void bar(void)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
printf("bar\n");
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* myutil.h */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#ifndef MYUTIL_H_
#define MYUTIL_H_
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* Function Prototypes */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
double add(double a, double b);
double sub(double a, double b);
double multiply(double a, double b);
double divide(double a, double b);
void foo(void);
void bar(void);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* extern declarations */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
extern int g_x;
extern int g_y;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#endif
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* app.c*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#include <stdio.h>
#include "myutil.h"
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int main(void)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
double result;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
result = add(10, 20);
printf("%f\n", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
result = sub(10, 20);
printf("%f\n", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
result = multiply(10, 20);
printf("%f\n", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
result = divide(10, 20);
printf("%f\n", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
foo();
bar();
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return 0;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir statik kütüphaneden bir fonksiyon çağrı ı ı ı ı ı ı
olduğunu belirleri, o amaç dosyayı ı ı ı ı ı ı ı ı
o statik kütüphaneye gereksinim duyulmaz. Şu noktalara dikkat ediniz:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
- Statik kütüphane içerisinde bir fonksiyon bile çağı ı ı ı ı ı ı ı ı ı
Amaç dosya içerisindeki tek bir fonksiyonun çalı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
- Statik kütüphane kullanı ı ı ı ı ı ı ı ı ı
için aynı ı ı ı ı ı ı ı ı ı ı ı ı
Bu da çalı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
- Statik bağlanmı ı ı ı ı ı ı ı ı ı ı
fonksiyonları ı ı ı ı ı ı ı
bir durum oluşturmaktadı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
- Statik kütüphanelerin en önemli avantajı ı ı ı ı ı ı ı ı ı
şey tek bir çalı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
92. Ders 01/06/2024 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Aslı ı ı
yeni boş bir bir proje oluşturulduktan sonra proje seçeneklerinden "Configuration Type" "Application" yerine "Static library" seçilirse
proje build edildiğinde statik kütüphane dosyası ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Visual Studio derleyicisi default durumda standart C kütüphanesinin dinamik versiyonunu kullanmaktadı
kütüphanesinin statik versyionunu kullanmak istiyorsanı ı ı ı
"C-C++/Code Generation/Runtime Library" sekmesinden de ayarlanabilmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Visual Studio IDE'sinde (diğer IDE'lerde de benzer) bir projede başka bir statik kütüphanenin içerisindeki fonksiyonları ı
düşünelim. Pekiyi bu statik kütüphaneye IDE içerisinden nası ı ı ı ı ı ı
sağlamak için Visual Studio IDE'sinde proje seçeneklerinden "Linker/Input/Additional Dependencies" edit alanı
(Bu alandaki kütüphane isimleri ';' karakterleriyle birbirinden ayrı ı ı
girilmez. Eğer kütüphane özel bazı ı ı
/Additional Library Directories" edit alanı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde statik kütüphane dosyaları ı ı ı
UNIX/Linux sistemlerindeki "ar" programı ı ı ı ı ı ı
programı ı ı ı ı ı ı ı
karakteri olmadan doğrudan belirtilmektedir. "r" komut satı ı ı ı
için kullanı ı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
ar r <kütüphane_dosyası ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Eğer eklenecek amaç dosya zaten kütüphanenin içerisinde varsa o değiştirilmektedir. Örneğin:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
$ gcc -c a.c
$ gcc -c b.c
$ ar r libmyutil.a a.o
$ ar r libmyutil.a b.o
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
"t" seçeneği kütüphane içerisindeki amaç dosyaları ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
ar t <kütüphane_dosyası ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Örneğin:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
$ ar t libmyutil.a
a.o
b.o
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
"d" seçeneği ("delete" sözcüğünden geliyor) kütüphane içerisindeki bir amaç dosyayı ı ı ı ı
şöyledir:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
ar d <kütüphane_dosyasnı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Örneğin:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
$ ar t libmyutil.a
a.o
b.o
$ ar d libmyutil.a a.o
$ ar t libmyutil.a
b.o
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
"x" seçeneği ("extract" sözcüğünden geliyor) kütüphane içerisindeki bir amaç dosyayı ı ı ı ı
Kullanı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
ar x <kütüphane_dosyası ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Örneğin:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
$ ar x libmyutil.a a.o
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
UNIX/Linux sistemlerinde geleneksel olarak kütüphane dosyaları ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistelerinde bir statik kütüphaneye başvuru işlemi gcc komut satı ı ı ı ı
Örneğin:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
$ gcc -o app app.c libmyutil.a
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Burada gcc programı ı ı ı ı ı ı ı ı ı ı ı
de yapı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
$ gcc -c app.c
$ gcc -o app app.o libmyutil.a
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Daha önceden de belirttiğimiz gibi standart C fonksiyonları ı ı
kütüphanenin static ve dinamik biçimleri vardı ı ı ı ı
"-static" seçeneği ile bu kütüphanenin statik versiyonunun kullanı ı ı ı
statik versiyonları ı ı ı ı
de bağlama aşaması ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
$ gcc -o app app.c -static
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde kütüphane dosyası ı
Öneğin:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
$ gcc -o app app.c xxx/libmyutil.a
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Eğer kütüphanenin ismi "lib" öneki ile başlatı ı ı ı ı ı ı
"-l" seçeneği ile yapı ı ı ı
Örneğin:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
4 gcc -o app app.c -lmyutil
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Burada bağlama işlemine "libmyutil.a" dosyası ı
"/usr/lib" dizinlerinde aranmaktadı ı ı
seçeneğine ek olarak "-L" seçeneği ile ek arama dizi belirtilebilmektedir. Örneğin:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
$ gcc -o app app.c -lmyutil -L/home/kaan
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Burada "libmyutil.a" dosaysı ı ı ı ı
o anda bulunulan dizini "." ile de belirtebiliriz. Örneğin:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
$ gcc -o app app.c -lmyutil -L.
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Örneğin daha önceden de kullandı ı ı ı ı
bağlama aşaması
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
$ gcc -o app app.c -lpthread
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Dinamik kütüphaneler statik kütüphanelerden oldukça farklı ı ı ı
".so" biçimindedir. ".dll" uzantı ı ı ı ı ı ı ı
Bir program dinamik kütüphaneden bir fonksiyon çağı ı ı ı ı ı ı ı
yazmaz. Bağlayı ı ı ı ı ı ı
yazmaktadı ı ı ı ı ı ı
dinamik kütüphaneleri prosesin sanal bellek alanı ı ı ı ı ı
geldiğinde bellekte dinamik kütüphanenin yüklü olduğu alana atlayarak fonksiyonu çalı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Dinamik kütüphane kullanı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
1) Dinamik kütüphane kullanan programlar diskte daha az yer kaplarlar.
2) Dinamik kütüphane kullanan programlarda dinamik kütüphane içerisindeki fonksiyonlarda değişiklikler yapı ı ı ı ı ı
programı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
3) Farklı ı ı
Bu da aslı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Ancak dinamik kütüphane kullanan programlar başka bir makineye konuşlandı ı ı ı ı ı ı
onun kullandı ı ı ı ı ı ı
oluşmamaktadı ı ı ı ı ı ı ı ı ı
dezavantajları
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
1) Dinamik kütüphane kullanan programları ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
2) Dinamik kütüphane kullanan programları
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
3) Dinamik kütüphane kullanan programlar prosesin sanal bellek alanı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Microsoft Windows sistemlerinde bir DLL oluşturmak için tek yapı ı ı
b.c dosyaları ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
cl /c a.c
cl /c b.c
link /DLL a.obj b.obj
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Buradan ilk dosyanı ı ı ı
".exe" dosyası ı ı ı ı ı ı
ile belirlenebilmektedir. Örneğin:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
cl /c a.c
cl /c b.c
link /OUT:myutil.dll /DLL a.obj b.obj
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Burada "myutil.dll" dosyası ı ı ı ı ı ı ı ı
aşağı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
cl /LD a.c b.c
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Burada ilk dosyanı ı ı ı
istiyorsak "cl" komut satı ı ı ı ı ı
seçeneğidir. (Başka bir deyişle biz "cl" derleyicisini "/Fe" seçeneği ile çalı ı ı ı ı ı ı ı ı
"/OUT" seçeneği ile çalı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
cl /Fe:myutil.dll /LD a.c b.c
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Bura artı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Teknik anlamda Microsoft Windows sistemlerinde ".EXE" dosyası ı ı ı ı ı ı
da "PE (Portable Executable)" dosya formaı ı ı ı ı
sahip olması ı ı ı ı ı ı
sı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows'ta bir DLL içerisindeki fonksiyonun ya da global nesnenin dı ı ı
PE formatı ı ı
export tablosuna yazı ı ı ı
o fonksiyonlar ve nesneler başka bir modülden (yani başka bir DLL ya da EXE programdan) kullanı ı
foo ve g_a dı ı ı ı ı ı
kullanı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#include <stdio.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
__declspec(dllexport) int g_y;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
__declspec(dllexport) void foo(void)
{
printf("foo\n");
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void bar(void)
{
printf("bar\n");
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
Buarada g_y global değişkeni ve foo fonksiyonu dı ı ı ı ı ı
kullanı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
93. Ders 02/06/2024 - Pazar
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Aslı ı ı ı ı ı ı ı ı ı
sı ı ı ı ı ı ı ı
önünde hangi üye fonksiyonlar dı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
class Sample {
public:
__declspec(dllexport) Sample(int a);
__declspec(dllexport) void foo() const;
__declspec(dllexport) void disp() const;
void bar() const;
private:
int m_a;
};
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Bu örnekte sı ı ı ı ı ı ı ı ı ı ı
kullanı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#include <iostream>
using namespace std;
class Sample {
public:
__declspec(dllexport) Sample(int a);
__declspec(dllexport) void foo() const;
__declspec(dllexport) void disp() const;
void bar() const;
private:
int m_a;
2024-04-29 13:28:55 +03:00
};
2024-06-09 22:42:45 +03:00
Sample::Sample(int a)
{
m_a = a;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void Sample::foo() const
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
cout << "foo" << endl;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void Sample::disp() const
{
cout << m_a << endl;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void Sample::bar() const
{
cout << "bar" << endl;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir sı ı ı ı ı ı ı ı ı
anahtar sözcüğü ile sı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
class __declspec(dllexport) Sample {
public:
Sample(int a);
void foo() const;
void disp() const;
void bar() const;
private:
int m_a;
};
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Burada sı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#include <iostream>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
using namespace std;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
class __declspec(dllexport) Sample {
public:
Sample(int a);
void foo() const;
void disp() const;
void bar() const;
private:
int m_a;
};
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Sample::Sample(int a)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
m_a = a;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void Sample::foo() const
{
cout << "foo" << endl;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void Sample::disp() const
{
cout << m_a << endl;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
void Sample::bar() const
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
cout << "bar" << endl;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows'ta bir DLL içerisindeki fonksiyonlar dı ı ı ı ı ı ı ı
bir DLL içerisindeki global nesneler dı ı ı ı ı
nesnenin DLL içerisinde olduğu derleyiciye bildirilirse derleyici daha etkin kod üretebilmektedir. (Bu konudaki ayrı ı
Programlama Kursu" içerisinde ele alı ı
anlatabilmek için fonksiyonun prototipinin önüne __declspec(dllimport) belirleyicisi getirilir. Örneğin:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#ifndef MYUTIL_H_
#define MYUTIL_H_
/* Function Prototypes */
__declspec(dllimport) double add(double a, double b);
__declspec(dllimport) double sub(double a, double b);
__declspec(dllimport) double multiply(double a, double b);
__declspec(dllimport) double divide(double a, double b);
__declspec(dllimport) void foo(void);
/* extern declarations */
__declspec(dllimport) extern int g_x;
__declspec(dllimport) extern int g_y;
#endif
Burada DLL içerisindeki fonksiyonları ı
Ancak DLL içerisinden export edilmiş fonksiyonlar ve global nesneler kullanı ı ı ı ı ı ı
hangi sembollerin kullanı ı ı ı ı
denilen bir kütüphanenin de bulundurulması ı ı ı ı ı
yaratı ı
cl /Fe:myutil.dll /LD a.c b.c
Burada biz "myutil.dll" isimli dinamik kütüphaneyi yaratmak istemekteyiz. İşte bu kütüphane yaratı ı ı
kütüphanesi de yaratı ı ı ı ı ı
zamanda "myutil.lib" isimli DLL'in import kütüphanesi de oluşturulmaktadı ı ı
biçiminde olsa da bu dosyalar statik kütüphane dosyaları ı
bazı ı ı ı ı ı ı
cl app.c myutil.lib
Windows'ta bir DLL'i kullanabilmek için yalnı ı ı ı
gerekir. DLL'in import kütüphanesi yalnı ı ı ı ı ı ı ı ı ı
kütüphanesinin hedef makineye kopyalanması
Aşağı ı ı ı
çalı ı ı ı ı ı ı
cl /OUT:myutil.dll /LD a.c b.c
cl app.c myutil.lib
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* app.c */
#include <stdio.h>
__declspec(dllexport) int g_x;
__declspec(dllexport) double add(double a, double b)
{
return a + b;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
__declspec(dllexport) double sub(double a, double b)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
return a - b;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
__declspec(dllexport) double multiply(double a, double b)
{
return a * b;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
__declspec(dllexport) double divide(double a, double b)
{
return a / b;
}
/* b.c */
2024-04-29 13:28:55 +03:00
#include <stdio.h>
2024-06-09 22:42:45 +03:00
__declspec(dllexport) int g_y;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
__declspec(dllexport) void foo(void)
{
printf("foo\n");
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void bar(void)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
printf("bar\n");
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* app.c */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#ifndef MYUTIL_H_
#define MYUTIL_H_
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* Function Prototypes */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
__declspec(dllimport) double add(double a, double b);
__declspec(dllimport) double sub(double a, double b);
__declspec(dllimport) double multiply(double a, double b);
__declspec(dllimport) double divide(double a, double b);
__declspec(dllimport) void foo(void);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* extern declarations */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
__declspec(dllimport) extern int g_x;
__declspec(dllimport) extern int g_y;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#endif
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* app.c */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#include <stdio.h>
#include "myutil.h"
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int main(void)
{
double result;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
result = add(10, 20);
printf("%f\n", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
result = sub(10, 20);
printf("%f\n", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
result = multiply(10, 20);
printf("%f\n", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
result = divide(10, 20);
printf("%f\n", result);
foo();
2024-04-29 13:28:55 +03:00
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
Kütüphaneler için birer başlı ı ı ı ı
kütüphane kullanı ı ı ı ı
mi yoksa __declspec(dllimport) belirleyicisi mi bulunmalı ı
kütüphaneyi kullanan kodlar derlenirken __declspec(dllimport) belirleyicisi bulunmalı ı ı
gerçekleştirilebilir. Örneğin:
#ifdef DLLBUILD
#define DLLSPEC __declspec(dllexport)
#else
#define DLLSPEC __declspec(dllimport)
#endif
Burada DLLBUILD isimli sembolik sabit define edilmişse DLLSPEC makrosu yerine __declspec(dllexport) belirleyicisi define edilmemişse
DLLSPEC makrosu yerine __declspec(dllimport) belirleyicisi yerleştirilecektir. Bu durumda fonksiyon prototipleri şöyle belirtilebilir:
DLLSPEC double add(double a, double b);
DLLSPEC double sub(double a, double b);
DLLSPEC double multiply(double a, double b);
DLLSPEC double divide(double a, double b);
DLLSPEC void foo(void);
İşte eğer DLL'in kendisi oluşturulacaksa bu başlı ı ı ı
DLL kullanı ı ı ı
dosyalar tarafı
Aşağı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-06-09 22:42:45 +03:00
/* myutil.h */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#ifndef MYUTIL_H_
#define MYUTIL_H_
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#ifdef DLLBUILD
#define DLLSPEC __declspec(dllexport)
#else
#define DLLSPEC __declspec(dllimport)
#endif
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* Function Prototypes */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
DLLSPEC double add(double a, double b);
DLLSPEC double sub(double a, double b);
DLLSPEC double multiply(double a, double b);
DLLSPEC double divide(double a, double b);
DLLSPEC void foo(void);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* extern declarations */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
DLLSPEC extern int g_x;
DLLSPEC extern int g_y;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#endif
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* a.c */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#define DLLBUILD
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#include <stdio.h>
#include "myutil.h"
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int g_x;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
double add(double a, double b)
{
return a + b;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
double sub(double a, double b)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
return a - b;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
double multiply(double a, double b)
{
return a * b;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
double divide(double a, double b)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
return a / b;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* b.c */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#define DLLBUILD
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#include <stdio.h>
#include "myutil.h"
int g_y;
void foo(void)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
printf("foo\n");
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void bar(void)
{
printf("bar\n");
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
/* app.c */
2024-04-29 13:28:55 +03:00
#include <stdio.h>
2024-06-09 22:42:45 +03:00
#include "myutil.h"
2024-04-29 13:28:55 +03:00
int main(void)
{
2024-06-09 22:42:45 +03:00
double result;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
result = add(10, 20);
printf("%f\n", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
result = sub(10, 20);
printf("%f\n", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
result = multiply(10, 20);
printf("%f\n", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
result = divide(10, 20);
printf("%f\n", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
foo();
return 0;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir DLL'i kullanan bir program çalı ı ı ı ı ı ı ı ı
aramaktadı ı ı ı ı ı ı ı ı ı ı
çalı ı ı ı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
1) Çalı ı ı ı ı
2) Windows\System32 dizini
3) Window\System dizini
4) Windows dizininin kendisi
5) Programı ı ı ı
6) PATH çevre değişkeni ile belirtilen dizinlerde sı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Dinamik kütüphaneler Windows sistemlerinde IDE'lerle daha kolay yaratı
olarak "Dynamic Link Library" seçilirse bu proje build edildiğinde DLL dosyası
yalnı ı ı ı ı
boş bir console projesi yaratı ı ı
yerine "Dynamic Link Library" olarak seçilir. Artı ı ı ı ı
Tabii DLL'in import kütüphanesi de aynı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde dinamik kütüphane oluşturmak için önce dinamik kütüphane oluşturulacak ".c" dosyaları
tekniği ile derlenmelidir. "Position Independent Code" ilgili dinamik kütüphanenin yüklenme yerinden bağı ı ı ı
Windows bu tekniği tercih etmemiştir. Windows'un yükleyicisi "relocation" işlemi ile DLL'leri farklı
Independent Code tekniği ile derlenmiş olan dosyalar "-shared" bağlama seçeneği ile bağlanı
UNIX/Linux sistemlerinde kütüphane içerisindeki global sembollerin hepsi otomatik olarak export edilmektedir. Dolayı ı
Windows sistemlerinde olduğu gibi __declspec(dllexport) ve __declspec(dllimport) biçiminde bildirimler yoktur. Tabii bu konuda da bazı
ayrı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
gcc ve clang derleyicilerinde bir dosyanı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
$ gcc -c -fPIC a.C
$ gcc -c -fPIC b.C
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Burada "a.o" ve "b.o" dosyaları ı ı ı ı ı
gerekmektedir. Örneğin:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
$ gcc -o libmyutil.so -shared a.o b.o
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Aslı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
$ gcc -o libmyutil.so -shared -fPIC a.c b.c
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Yine UNIX/Linux sistemlerinde dinamik kütüphane dosyaları ı
Aşağı ı ı ı
deneyiniz.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* a.c */
#include <stdio.h>
int g_x;
double add(double a, double b)
{
return a + b;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
double sub(double a, double b)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
return a - b;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
double multiply(double a, double b)
{
return a * b;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
double divide(double a, double b)
{
return a / b;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* b.c */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#include <stdio.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int g_y;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void foo(void)
{
printf("foo\n");
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void bar(void)
{
printf("bar\n");
2024-04-29 13:28:55 +03:00
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
UNIX/Linux sistemlerinde "dinamik kütüphanelerin import kütüphanesi" denilen kütüphaneleri yoktur. Dinamik kütüphane kullanan programlar
doğrudan bu dinamik kütüphane dosyası ı ı ı ı
kütüphanesini kullanı ı ı ı ı
gcc -o app app.c libmyutil.so
Aşağı ı ı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-06-09 22:42:45 +03:00
/* myutil.h */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#ifndef MYUTIL_H_
#define MYUTIL_H_
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* Function Prototypes */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
double add(double a, double b);
double sub(double a, double b);
double multiply(double a, double b);
double divide(double a, double b);
void foo(void);
void bar(void);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* extern declarations */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
extern int g_x;
extern int g_y;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#endif
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* app.c */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#include <stdio.h>
#include "myutil.h"
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int main(void)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
double result;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
result = add(10, 20);
printf("%f\n", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
result = sub(10, 20);
printf("%f\n", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
result = multiply(10, 20);
printf("%f\n", result);
result = divide(10, 20);
printf("%f\n", result);
foo();
bar();
return 0;
2024-04-29 13:28:55 +03:00
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
UNIX/Linux sistemlerinde yine çalı ı ı ı ı ı ı ı
Dinamik kütüphaneler yine bu sistemlerde de belli yerlerde aranmaktadı ı ı ı ı
bulunduğu dizinde ya da onu çalı ı ı ı
kullanan bir programla dinamik kütüphanenin kendisi aynı ı ı ı ı ı ı
UNIX/Linux sistemlerinde dinamik kütüphanelerin aranma prosedürlerine ilişkin bazı ı ı ı ı ı ı
durmayacağı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
1) Programı ı ı ı ı
Bu eçvre değişkeninin değeri ':' karakterleriyle ayrı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
$ export LD_LIBRARY_PATH=/home/kaan:/home/kaan/Study:.
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Burada dinamik kütüphaneler sı ı ı
aranacaktı ı ı ı ı
$ LD_LIBRARY_PATH=. ./app
2) Çalı ı ı ı ı
3) "/lib" ve "/usr/lib" dizinlerine bakı ı ı ı ı ı ı ı
Eğer bu sistemlerde oluşturduğumuz dinamik kütüphaneler başka programlar tarafı ı ı
"/usr/lib" dizinidir. "/lib" dizini daha aşağı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
94. Ders 08/06/2024 - Cumartesi
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Dinamik kütüphaneler programı ı ı ı ı ı ı ı ı
Bu duruma "dinamik kütüphanelerin dinamik yüklenmesi" denilmektedir. Dinamik yükleme özelliği hem Windows sistemlerinde hem de UNIX/Linux
ve macOS sistemlerinde bulunmaktadı ı ı ı
sistemlerinde işlemler tamamen UNIX/Linux sistemlerinde olduğu gibi yapı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows sistemlerinde dinamik kütüphanelerin dinamaik biçimde yüklenerek kullanı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
1) Önce LoadLibrary API fonksiyonuyla DLLprosesin sanal bellek alanı
şöyledir:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
HMODULE LoadLibraryA(
LPCSTR lpLibFileName
);
Fonksiyon yüklenecek olan DLL'in yol ifadesini parametre olaraj almaktadı ı
o dizinde aranmaktadı ı ı ı ı ı ı ı
aranı
Bu tür de aslı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
HMODULE hModule;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((hModule = LoadLibrary("MyUtil.dll")) == NULL)
ExitSys("LoadLibrary");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
2) DLL içerisinden çağrı ı
prototipi şöyledir:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
FARPROC GetProcAddress(
HMODULE hModule,
LPCSTR lpProcName
);
Fonksiyonun birinci parametresi LoadLibrary fonksiyonundan elde edilen modül yükleme adresini, ikinci parametresi ise adresi elde edlecek
fonksiyonun ya da global değişkenin ismini almaktadı ı
başarı ı ı ı
typedef edilmiştir:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
typedef int (WINAPI *FARPROC)();
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
64 bit Windows sistemlerinde ise şöyle typedef edilmiştir:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
typedef INT_PTR (WINAPI *FARPROC)();
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Bu geri dönüş değeri genel bir tür biçiminde bulundurulmuştur. Uygun fonksiyon türüne dönüştürrülmelidir. Örneğin:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
typedef double (*PROCADDR)(double, double);
...
PROCADDR padd;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((padd = (PROCADDR)GetProcAddress(hModule, "add")) == NULL)
ExitSys("GetProcAddress");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
GetProcAddress fonksiyonunda bir noktaya dikkat edilmesi gerekir. Derleyiciler C'deki değişken isimlerini amaç dosyaya dekore ederek
yazabilmektedir. Bizim GetProcAddress fonksiyonunda bu dekore edilmiş isimleri kullanmamı
cdecl çağı ı ı ı ı ı
DLL'in export tablosuna yazarken bu baştaki '_' karakterlerini atmaktadı ı ı ı
bulunabileceği için C++ derleyicilerinin hepsi meecburen bir isim dekorasyonu uygulamaktadı ı ı
olabilmesi için dumpbin programı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
C:\Dropbox\Shared\Kurslar\SysProg-1\Src\Libraries\Dynamic>DUMPBIN /EXPORTS myutil.dll
Microsoft (R) COFF/PE Dumper Version 14.39.33523.0
Copyright (C) Microsoft Corporation. All rights reserved.
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Dump of file myutil.dll
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
File Type: DLL
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Section contains the following exports for myutil.dll
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
00000000 characteristics
FFFFFFFF time date stamp
0.00 version
1 ordinal base
7 number of functions
7 number of names
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
ordinal hint RVA name
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
1 0 00001000 add
2 1 00001060 divide
3 2 00001080 foo
4 3 0001B39C g_x
5 4 0001B398 g_y
6 5 00001040 multiply
7 6 00001020 sub
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Summary
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
2000 .data
7000 .rdata
1000 .reloc
12000 .text
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Ancak eğer biz bir C++ dosyası ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
C:\Dropbox\Shared\Kurslar\SysProg-1\Src\Libraries\Dynamic>DUMPBIN /EXPORTS myutilcpp.dll
Microsoft (R) COFF/PE Dumper Version 14.39.33523.0
Copyright (C) Microsoft Corporation. All rights reserved.
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Dump of file myutilcpp.dll
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
File Type: DLL
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Section contains the following exports for myutilcpp.dll
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
00000000 characteristics
FFFFFFFF time date stamp
0.00 version
1 ordinal base
7 number of functions
7 number of names
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
ordinal hint RVA name
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
1 0 00001000 ?add@@YANNN@Z
2 1 00001060 ?divide@@YANNN@Z
3 2 00001080 ?foo@@YAXXZ
4 3 0001A968 ?g_x@@3HA
5 4 0001A96C ?g_y@@3HA
6 5 00001040 ?multiply@@YANNN@Z
7 6 00001020 ?sub@@YANNN@Z
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Summary
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
2000 .data
7000 .rdata
1000 .reloc
12000 .text
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
3) Artı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
result = padd(10, 20);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
4) Dinamik kütüphanenin kullanı ı ı ı
FreeLibrary fonksiyonunun prototipi şöyledir:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
BOOL FreeLibrary(
HMODULE hLibModule
);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Fonksiyon modülün yüklenme adresini parametre olarak alı ı ı ı ı ı ı ı ı ı ı
geri döner. Tabii proses sonlaadı ı ı ı ı
Aşağı ı ı
proje dizininde bulunduğundan emin olunuz. DLL'in derlenmesini komut satı ı
cl /Fe:myutil.dll a.c b.c /LD
-------------------------------------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ExitSys(LPCSTR lpszMsg);
typedef double (*PROCADDR)(double, double);
int main(void)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
HMODULE hModule;
PROCADDR padd, psub, pmultiply, pdivide;
double result;
if ((hModule = LoadLibrary("myutilcpp.dll")) == NULL)
ExitSys("LoadLibrary");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((padd = (PROCADDR)GetProcAddress(hModule, "?add@@YANNN@Z")) == NULL)
ExitSys("GetProcAddress");
result = padd(10, 20);
printf("%f\n", result);
if ((psub = (PROCADDR)GetProcAddress(hModule, "sub")) == NULL)
ExitSys("GetProcAddress");
result = psub(10, 20);
printf("%f\n", result);
if ((pmultiply = (PROCADDR)GetProcAddress(hModule, "multiply")) == NULL)
ExitSys("GetProcAddress");
result = pmultiply(10, 20);
printf("%f\n", result);
if ((pdivide = (PROCADDR)GetProcAddress(hModule, "divide")) == NULL)
ExitSys("GetProcAddress");
result = pdivide(10, 20);
printf("%f\n", result);
FreeLibrary(hModule);
2024-04-29 13:28:55 +03:00
return 0;
}
2024-06-09 22:42:45 +03:00
void ExitSys(LPCSTR lpszMsg)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
exit(EXIT_FAILURE);
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
/* myutil.h */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#ifndef MYUTIL_H_
#define MYUTIL_H_
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#ifdef DLLBUILD
#define DLLSPEC __declspec(dllexport)
#else
#define DLLSPEC __declspec(dllimport)
#endif
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* Function Prototypes */
DLLSPEC double add(double a, double b);
DLLSPEC double sub(double a, double b);
DLLSPEC double multiply(double a, double b);
DLLSPEC double divide(double a, double b);
/* extern declarations */
DLLSPEC extern int g_x;
#endif
/* a.c */
#define DLLBUILD
#include <stdio.h>
#include "myutil.h"
int g_x;
double add(double a, double b)
{
return a + b;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
double sub(double a, double b)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
return a - b;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
double multiply(double a, double b)
{
return a * b;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
double divide(double a, double b)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
return a / b;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Dinamik kütüphanelerin UNIX/Linux sistemlerinde dinamik yüklenmesi aslı ı ı
şöyle yürütülür:
1) Önce dinamik kütüphane ldopen fonksiyonuyla adres alanı
benzetebilirsiniz. Bu fonksiyon yine dinamik kütüphanenin bellekteki yükleme adresine geri dönmektedir. Fonksiyonun prototipi şöyledir:
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#include <dlfcn.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void *dlopen(const char *filename, int flags);
Fonksiyonun birinci parametresi yüklenecek dinamik kütüphane dosyası ı
karakteri kullanı ı ı ı ı ı ı
dosya yalnı ı ı ı
oluşmaktadı
fonksiyonun çağrı ı ı ı ı ı ı ı ı ı ı ı ı ı ı ı
belirtmektedir. Diğer bayraklar için dokümanalara başvurulabilir. Fonksiyon başarı ı ı ı
adrese geri döner. Başarı ı ı ı ı ı ı
edilmelidir. dlerror fonksiyonun prototipi şöyledir:
char *dlerror(void);
Fonksiyon statik bir biçimde tahsis edilmiş olan hata yazı ı ı
void *soaddr;
...
if ((soaddr = dlopen("./libmyutil.so", RTLD_LAZY)) == NULL) {
fprintf(stderr, "dlopen: %s\n", dlerror());
exit(EXIT_FAILURE);
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
Tı ı ı
bu durumda dosya Linux sistemlerindeki yukarı ı ı ı ı
bakı ı ı ı ı ı ı ı ı ı
2) dlsym fonksiyonuyla dinamik kütüpahane içerisindeki herhangi bir fonksiyon ya da nesnenin adresi elde edilebilmektedir. dlsym fonksiyonun
prototipi şöyledir:
#include <dlfcn.h>
void *dlsym(void *handle, const char *symbol);
Fonksiyonun birinci parametresi dlopen fonksiyonundan elde edilen adresi, ikinci parametresi ise adresi elde edilecek fonksiyon ya da global
nesnenin ismini belirtmektedir. Fonksiyon başarı ı ı ı ı
Yine başarı ı ı
adreslerine tür dönüştürme operatör ile bile dönüştürmenin geçerli olmadı ı
Anı ı ı
typedef double (*PROCADDR)(double);
...
PROCADDR padd;
...
if ((*(void **)&padd = dlsym(soaddr, "add")) == NULL) {
fprintf(stderr, "dlsym: %s\n", dlerror());
exit(EXIT_FAILURE);
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
dlsym fonksiyonunu Windows sistemlerindeki GeProcAddress fonksiyonuna benzetebilirsiniz.
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
3) Artı ı ı
4) Dinamik kütüphanenin kullanı ı ı ı
#include <dlfcn.h>
int dlclose(void *handle);
Fonksiyon parametre olarak dinamik kütüphanenin yükleme adres,n, alı ı ı ı ı
değrine başarı ı ı ı ı ı ı ı ı ı ı ı ı
Örneğin:
dlclose(soaddr);
Bütün bu fonksiyonlar "libdl.so" kütüphanesi içerisinde bulunmaktadı ı ı ı ı
bulundurunuz.
Örnek bir kullanı ı ı
$ gcc -fPIC -o libmyutil.so libmyutil.c -shared
$ gcc -o app app.c -ldl
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
void exit_sys(const char *msg);
typedef double (*PROCADDR)(double, double);
int main(void)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
void *soaddr;
PROCADDR padd, psub, pmultiply, pdivide;
double result;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((soaddr = dlopen("./libmyutil.so", RTLD_LAZY)) == NULL) {
fprintf(stderr, "dlopen: %s\n", dlerror());
exit(EXIT_FAILURE);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((*(void **)&padd = dlsym(soaddr, "add")) == NULL) {
fprintf(stderr, "dlsym: %s\n", dlerror());
exit(EXIT_FAILURE);
}
result = padd(10, 20);
printf("%f\n", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((*(void **)&psub = dlsym(soaddr, "sub")) == NULL) {
fprintf(stderr, "dlsym: %s\n", dlerror());
exit(EXIT_FAILURE);
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
result = psub(10, 20);
printf("%f\n", result);
if ((*(void **)&pmultiply = dlsym(soaddr, "multiply")) == NULL) {
fprintf(stderr, "dlsym: %s\n", dlerror());
exit(EXIT_FAILURE);
}
result = pmultiply(10, 20);
printf("%f\n", result);
if ((*(void **)&pdivide = dlsym(soaddr, "divide")) == NULL) {
fprintf(stderr, "dlsym: %s\n", dlerror());
exit(EXIT_FAILURE);
}
result = pdivide(10, 20);
printf("%f\n", result);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return 0;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
void exit_sys(const char *msg)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
perror(msg);
exit(EXIT_FAILURE);
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
/* libmyutil.c */
#include <stdio.h>
double add(double a, double b)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
return a + b;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
double sub(double a, double b)
{
return a - b;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
double multiply(double a, double b)
{
return a * b;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
double divide(double a, double b)
{
return a / b;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Kursumuzun bu bölümünde IP prokol ailesi ile ağa bağlı ı ı ı ı ı ı
TCP ve UDP protokollerini inceleyeceğiz ve bu protokolleri kullanarak soket arayüzü ile temel programları ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Farklı ı ı ı
göre daha karmaşı ı ı ı ı ı
gerekir. İşte ağ haberleşmesinde önceden belirlenmiş kurallar topluluğuna "protokol" denilmektedir. Ağ haberleşmesi için tarihsel süreç
içerisinde pek çok protokol ailesi gerçekletirilmiştir. Bunları ı ı ı ı ı ı
Ancak açı ı ı
tercih edilen protokol ailesidir.
Protokol ailesi (protocol family) denildiğinde birbirleriyle ilişkili bir grup protokol anlaşı ı
protokolü başka protokollerin üzerine konumlandı ı ı ı ı
olmuştur. Üst seviye bir protokol alt seviye protokolün "zaten var olduğu fikriyle" o alt seviye protokol kullanı ı
Bu katmanlı ı ı
benzetebiliriz.
Ağ haberleşmesi için katmanlı ı ı ı ı ı ı ı ı
başları ı
Kavramsal bir referans dokümanı ı ı ı
protokol ailesinde tipik olarak 7 katman bulunmalı ı ı
Uygulama Katmanı
Sunum Katmanı
Oturum Katmanı
Aktarı ı
Network Katmanı
Veri Bağlantı ı
Fiziksel Katman (Physical Layer)
- En aşağı ı ı ı ı ı ı
konnektörlerin özellikleri, akı ı
- Veri bağlantı ı ı ı ı ı ı ı
gönderilip alı ı ı ı
tanı ı ı ı ı ı ı ı
Ethernet kartları ı ı
ve veri bağlantı ı ı ı ı
byte'lı ı ı
"paket anahtarlaması ı ı ı ı
getirilir sonra ilgili fiziksel katmanla seri bir biçimde gönderilir. Bugün kullandı ı ı ı
değil hub'lar yoluyla ağa bağlı ı
kablosuz haberleşmede kullanı ı ı ı
katmanı ı ı
Fiziksel katman ve veri katmanı ı ı ı ı
alabilir duruma gelmekteyiz.
- Ağ Katmanı ı ı ı ı
oluşan network'ler" anlamı ı
ağlar "router" denilen aygı ı ı ı
artı ı ı ı ı ı
İşte "network katmanı ı ı ı
Ağ katmanı ı ı ı ı ı ı ı
bilgilerin paketlere ayrı ı ı ı ı ı
yalnı ı ı ı ı ı
yollayı
- Aktarı ı ı ı ı ı ı ı ı ı
oluşturulabilmekte ve veri aktarı ı ı ı ı ı ı ı
da oluşturmaktadı ı ı
Bu durumda aktarı ı ı
- Bağlantnı ı ı ı
- Ağ katmanı ı
- Veri aktarı ı ı ı
- Gönderilen bilgilerin hedefte ayrı ı ı ı ı ı ı
- Oturum katmanı ı ı
yapmaktı ı ı ı ı ı ı ı ı ı ı
belirlemeler bulunmaktadı ı
- Sunum katmanı ı ı ı ı ı ı
OSI'de belirtildiği biçimde bulunmamaktadı
- Nihayet protokol ailesini kullanarak yazı ı ı ı ı ı
ortamı ı ı
somut işleri yapmakta kullanı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bugün farklı ı ı
protokol ailesi temel ve yardı ı ı ı
IP protoküdür. Pekiyi pekiyi IP ailesi neden bu kadar popüler olmuştur? Bunun en büyük nedeni 1983 yı ı ı ı ı
(I'nin büyük yazı ı ı ı ı ı ı ı ı
bilgisayarda hem yerel ağı ı ı ı ı
malı ı ı ı ı
IP ailesi 70'li yı ı
"internetworking" anlamı ı ı ı ı ı ı ı
ve bu protokollerin ilk versiyonları ı ı
Bugün hepimizin bağlandı ı ı ı ı ı ı
bir soğuk savaş projesi biçiminde başlatı ı ı ı ı ı ı ı ı
"WAN (Wide Area Network)" oluşturuldu. Bu proje Amerikan Savunma Bakanlı ı ı ı ı ı ı ı
ve projeye "ARPA.NET" ismi verilmiştir. Daha sonra bu ağa Amerika'daki çeşitli devlet kurumları ı ı
ağ Avrupa'ya sı ı ı ı ı ı
yerine "Internet" ismi kullanı ı ı ı ı
harfle yazı ı ı ı ı ı ı ı ı ı ı ı
oluşturabiliriz. Örneğin bir şirket hiç Internet'e bağlanmadan kendi internet'ini oluşturabilir. Buna eskiden "intranet" denirdi. IP
protokol ailesi herkesin kendi internet'ini oluşturabilmesi için bütün gerekli protokolleri barı ı ı ı ı
herkes zaten var olan ve "Internet" denilen bu dev ağa bağlanmayı
IP protokol ailesi 4 katmanlı ı ı
Ethernet ve Wireless protokolleri biçiminde kullanı ı ı ı
Aktarı ı
çok protokol ailenin uygulama katmanı ı ı ı ı
çok protokol de bulunmaktadı
+---------------------+-------------------------------+
| Application Layer | HTTP, SSH, POP3, IMAP, ... |
+---------------------+---------------+---------------+
| Transport Layer | TCP | UDP |
+---------------------+---------------+---------------+
| Network Layer | IP |
+---------------------+-------------------------------+
| Physical/Data Link | Ethernet |
| Layer | Wireless |
+---------------------+-------------------------------+
IP protokolü tek başı ı ı ı
tek başı ı ı ı ı ı ı
IP ailesinin uygulama katmanı
Ailede genellikle TCP protokolü kullanı ı ı ı
IP protokolü ailenin en önemli ve taban protokolüdür. IP protokolünde ağa bağlı
"host" denilmektedir. IP protokolü bir host'tan diğerine bir paket (buna IP paketi denilmektedir) bilginin gönderimine ilişkin tanı ı
içermektedir. IP protokolünde her host'un ismine "IP adresi" denilen mantı ı
gönderilmektedir. IP protokolünün iki önemli versiyonu vardı ı ı ı
IP adresleri 4 byte uzunluktadı ı ı ı ı ı ı
adresleri 16 byte uzunluğundadı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
TCP bağlantı ı ı ı ı ı
mantı ı ı ı ı ı ı ı ı
birbirleriyle konuşabilirler. Bağlantı ı ı
akla "client-server" haberleşme gelmektedir. TCP modelinde client önce server'a bağlanı ı ı ı
konuşmalarla sürdürürlür. Tabii TCP bunu yaparken IP paketlerini yani IP protokolünü kullanmaktadı ı ı ı
UDP protokolünde bizim bir host'a UDP paketi gönderebilmemiz için bir bağlantı ı ı ı
modeline benzemektedir. Verici görüntüyü yollar ancak alı ı ı ı ı ı ı ı ı
bağlantı ı
TCP "stream tabanlı ı ı
olduğu gibi gönderen tarafı ı ı ı ı ı
okuyabilmesi demektir. Datagram tabanlı ı
demektir. Yani datagram haberleşmede alı ı ı ı ı
oluşturulabilmesi için IP paketlerine bir numara verilmesi ve bunları
diğerine 10K'lı ı ı ı ı ı
10000 byte'lı ı ı ı ı ı ı ı ı
birleştirilmesi zorunlu değildir. IP protokolünde bir host birtakı ı ı ı ı ı
almayabilir. Bu özelliğinden dolayı ı ı ı
TCP güvenilir (reliable), UDP güvenilir olmayan (unreliable) bir protokoldür. TCP'de mantı ı
paketlerin telafi edilmesi mümkündür. Alı ı ı ı ı ı ı
kontrolü (flow control)" de uygulanmaktadı ı ı ı ı ı ı
Halbuki UDP'de böyle bir mekanizma yoktur. Gönderen taraf alı ı ı ı ı ı ı
Tüm bunlar eşliğinde IP ailesinin en çok kullanı ı ı ı ı
protokoller hep TCP kullanmaktadı
Yukarı ı
İşte bu protokol ailesinde her host'un mantı ı
IPv6'da 16 byte uzunluktadı ı ı ı
paketlerinin o host'ta ayrı ı ı ı ı ı
şirketin içerisinde çalı ı ı ı
1024 port numarası ı ı ı ı
nedenle programcı ı ı ı
gönderecekse bilginin gönderileceği host'un IP numarası ı ı ı ı
IP numarası ı
belirtmek durumundadı ı ı
gelen bilgilerle ilgileniriz. Port numarası ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
TCP ve UDP protokollerinin IP protokolü üzerine oturdulduğunu belirtmiştik. Bu ne anlama gelmektedir? Biz TCP ile belli bir IP numarası
ve port numarası ı ı ı
paketi biçiminde yola çı ı ı ı ı
+-------------------------+
| IP Header |
+-------------------------+
| IP Data |
+-------------------------+
Burada IP Header'da söz konusu IP paketinin hedefe ulaştı ı ı
"IP Data" kı ı ı ı ı ı
Bu durumda TCP paketinin genel görünümü şöyledir:
+-------------------------+
| IP Header |
+-------------------------+ <---+
| TCP Header | |
+-------------------------+ IP Data
| TCP Data | |
+-------------------------+ <---+
TCP paketinin de bir header ve data alanı ı ı ı
Yani TCP paketinin header ve data kı ı ı ı ı ı ı
TCP paketi değil IP paketidir. TCP bilgileri bu IP paketinin data kı ı ı
IPv4 başlı ı ı ı ı
<------- Byte 1 -------><------- Byte 2 -------><------- Byte 3 -------><------- Byte 4 ------->
+-----------+-----------+----------------------+-----------------------------------------------+ ^
| Version | IHL | Type of Service | Total Length | (4 bytes) |
| (4 bits) | (4 bits) | (8 bits) | (16 bits) | |
+-----------+-----------+----------------------+-----------+-----------------------------------+ |
| Identification | Flags | Fragment Offset | (4 bytes) |
| (16 bits) | (3 bits) | (13 bits) | |
+-----------------------+----------------------+-----------+-----------------------------------+ |
| Time to Live (TTL) | Protocol | Header Checksum | (4 bytes) | 20 bytes
| (8 bits) | (8 bits) | (16 bits) | |
+-----------------------+----------------------+-----------------------------------------------+ |
| Source IP Address (32 bits) | (4 bytes) |
+----------------------------------------------------------------------------------------------+ |
| Destination IP Address (32 bits) | (4 bytes) |
+----------------------------------------------------------------------------------------------+ v
| Segment (L4 protocol (TCP/UDP) + Data) |
+----------------------------------------------------------------------------------------------+
TCP header'ı ı ı ı ı
<------- Byte 1 -------><------- Byte 2 -------><------- Byte 3 -------><------- Byte 4 ------->
+----------------------------------------------+-----------------------------------------------+ ^
| Source Port | Destination Port | (4 bytes) |
| (16 bits) | (16 bits) | |
+----------------------------------------------+-----------------------------------------------+ |
| Sequence Number | (4 bytes) |
| (32 bits) | |
+----------------------------------------------------------------------------------------------+ |
| Acknowledgement Number | (4 bytes) |
| (32 bits) | | 20 bytes
+-----------+----------------+-----------------+-----------------------------------------------+ |
|Header Len.| Reserved | Control Bits | Window Size | (4 bytes) |
| (4 bits) | (6 bits) | (6 bits) | (16 bits) | |
+-----------+----------------+-----------------+-----------------------------------------------+ |
| Checksum | Urgent | (4 bytes) |
| (16 bits) | (16 bits) | |
+----------------------------------------------+-----------------------------------------------+ v
| Options |
| (0 or 32 bits) |
+----------------------------------------------------------------------------------------------+
| Application Layer Data |
| (Size Varies) |
+----------------------------------------------------------------------------------------------+
UDP header'ı ı ı ı ı
<------- Byte 1 -------><------- Byte 2 -------><------- Byte 3 -------><------- Byte 4 ------->
+----------------------------------------------+-----------------------------------------------+ ^
| Source Port | Destination Port | (4 bytes) |
| (16 bits) | (16 bits) | |
+----------------------------------------------+-----------------------------------------------+ | 8 bytes
| Header Length | Checksum | (4 bytes) |
| (16 bits) | (16 bits) | |
+----------------------------------------------+-----------------------------------------------+ v
| Application Layer Data |
| (Size Varies) |
+----------------------------------------------------------------------------------------------+
/*------------------------------------------------------------------------------------------------------------------------------------------
IP haberleşmesi (yani paketlerin, oluşturulması ı ı ı ı ı
Tabii User mode programlar için sistem çağrı ı ı ı ı ı ı
kullanı ı ı ı
türevi sistem bu kütüphaneyi aynı ı
sistemleri için kendi soket kütüphanesini oluşturmuştur. Buna "Windows Socket API (WSA)" denilmektedir. Ancak Microsoft aynı
BSD soket arayüzünü de desteklemektedir. Yani biz Windows sistemlerinde hem başı ı ı
hem de klasik Berkeley soket fonksiyonları ı ı ı ı ı ı
değişikliklerle Windows sistemlerine taşı
Berkeley soket kütüphanesi yalnı ı
nedenle kütüphanedeki fonksiyonlar daha genel biçimde tasarlanmı ı
Biz soket fonksiyonları ı ı ı
Örneğin biz send soket fonksiyonu ile bir bilgiyi göndermek istediğimizde aslı ı ı
IP paketi oluşturarak protokole uygun bir biçimde bu bilgiyi göndermektedir. Soket kütüphanesinin yalnı
ediniz.
Yukarı ı ı
aynı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-07-15 13:23:34 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
96. Ders 16/06/2024 - Pazar
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir TCP/IP uygulaması ı ı ı ı
daha sonra da TCP client programı ı ı ı ı ı
soket fonksiyonları ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir TCP server program tipik olarak aşağı ı ı ı
(Windows'ta WSAStartup --->) socket ---> bind ---> listen ---> accept ---> send/recv (ya da UNIC/Linux'ta read/write)
---> shutdown ---> close (Windows'ta closesocket) (---> Windows'ta WSACleanup)
Buradan da gördüğünüz gibi her ne kadar Windows UNIX tarzı
farklı ı
1) Windows'ta soket sistemini başlatmak ve sonlandı ı ı ı
2) Windows'ta soket nesnesini yok etmek için close yerine closesocket API fonksiyonu bulunmaktadı
3) Windows'ta bazı ı ı ı ı ı ı ı ı
WSAGetLastError fonksiyonuyla elde edilmektedir. Bu nedenle Windows örneğimizde hataları ı
biçimde tanı ı
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr)
{
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
4) Windows'ta soket kütüphanesi API fonksiyonları ı ı
bulunduğu dinamik kütüphanenin import kütüphanesi ("Ws2_32.lib") linker ayarları
5) Windows sistemlerinde soket fonksiyonları ı ı ı
prototipleri farklı ı ı ı ı
<windows.h> dosyası
Windows'ta soket sistemini başlatmak için WSAStartup fonksiyonu kullanı ı
#include <winsock2.h>
int WSAStartup(
WORD wVersionRequired,
LPWSADATA lpWSAData
);
Fonksiyonun birinci parametresi talep edilen soket kütüphanesinin versiyonunu belirtmektedir. Buradaki WORD değer iki ayrı ı
oluşmaktadı
Dolayı ı ı
talep edilenden küçük olan en yüksek versiyon kullanı ı ı
nesnesinin adresini almaktadı ı ı ı ı ı ı
hata kodunun kendisine geri dönmektedir. (Yani bu fonksiyon için WSAGetLastError çağrı ı ı ı
WSADATA wsaData;
int result;
...
if ((result = WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0)
ExitSys("WSAStartup", result);
Windows'ta WSACleaanup fonksiyonun prototipi ise şöyledir:
#include <winsock2.h>
int WSACleanup(void);
Fonksiyon başarı ı ı ı
geri dönmektedir. Hatanı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Haberleşme için öncelikle bir soket nesnesinin yaratı ı ı ı
bir soket nesnesi (handle alanı ı
değeri SOCKET isimli bir türdendir. Ancak UNIX/Linux sistemlerinde bir dosya betimleyicisi biçimindedir. Yani UNIX/Linux sistemlerinde
socket nesneleri tamamen bir dosya gibi kullanı ı
#include <winsock2.h>
SOCKET socket(
int af,
int type,
int protocol
);
UNIX/Linux sistemlerindeki prototipi ise şöyledir:
#include <sys/socket.h>
int socket(int domain, int type, int protocol);
Fonksiyonları ı ı ı
SOCKET türüyle UNIX/Linux sistemlerinde ise int türüyle temsil edilmesidir.
socket fonksiyonunun birinci parametresi kullanı
sabitlerden biri olarak girilir. IPv4 için bu parametreye AF_INET, IPv6 için AF_INET6 girilmelidir. UNIX domain soketler için bu parametre
AF_UNIX olarak girilmelidir.
Fonksiyonun ikinci parametresi kullanı ı ı ı ı ı ı
için SOCK_STREAM, datagram soketler için SOCK_DGRAM kullanı ı ı ı
SOCK_STREAM biçiminde UDP protokülünde ise bu parametre SOCK_DGRAM biçiminde girilmelidir.
Fonksiyonun üçüncü parametresi aktarı ı ı
anlaşı ı ı
parametredeki SOCK_STREAM zaten TCP'yi, SOCK_DGRAM ise zaten UDP'yi anlatmaktadı
IPPROTO_TCP ya da IPPROTO_UDP girilebilir. (Bu sembolik sabitler UNIX/Linux sistemlerinde <netinet/in.h> içerisindedir.)
socket fonksiyonu başarı
Fonksiyon başarı ı ı
SOCKET_ERROR sembolik sabiti de zaten -1 biçiminde define edilmiştir. Ancak Windows sistemlerinde SOCKET_ERROR sembolik sabitinin kullanı ı
gerekir.
Örneğin Windows sistemlerinde socket nesnesi şöyle yaratı
SOCKET serverSock;
...
if ((serverSock = socket(AF_INET, SOCK_STREAM, 0)) == SOCKET_ERROR)
ExitSys("socket", WSAGetLastError());
Aynı ı
int server_sock;
...
if ((server_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
exit_sys("socket");
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Server program soketi yarattı ı ı ı ı ı
hangi network arayüzünden (kartı ı
Yalnı
#include <winsock2.h>
int bind(
SOCKET s,
const sockaddr *addr,
int namelen
);
UNIX/Linux sistemlerindeki prototipi ise şöyledir:
#include <sys/socket.h>
int bind(int socket, const struct sockaddr *addr, socklen_t addrlen);
Görüldüğü gibi fonksiyonları ı ı
Biz kursumuzda anlatı ı ı
bind fonksiyonunun birinci parametresi yaratı ı ı
türünden gösterici ise de de aslı ı ı ı ı ı
(void gösterici gibi) temsil etmek için kullanı ı ı ı ı
domain soketler için ise sockaddr_un biçiminde olmalı ı ı ı
girilmelidir.
sockaddr_in yapı ı ı ı
#include <winsock2.h>
typedef struct sockaddr_in {
short sin_family;
u_short sin_port;
struct in_addr sin_addr;
char sin_zero[8];
} SOCKADDR_IN, *PSOCKADDR_IN, *LPSOCKADDR_IN;
UNIX/Linux sistemlerinde ise bu yapı
#include <netinet/in.h>
struct sockaddr_in {
sa_family_t sin_family;
in_port_t sin_port;
struct in_addr sin_addr;
};
Yapı ı ı ı ı ı ı ı ı ı
elemanı ı ı
elemanı ı ı ı
sin_addr elemanı ı ı ı ı
bildirilmiştir:
struct in_addr {
union {
struct {
u_char s_b1;
u_char s_b2;
u_char s_b3;
u_char s_b4;
} S_un_b;
struct {
u_short s_w1;
u_short s_w2;
} S_un_w;
u_long S_addr;
} S_un;
};
#define s_addr S_un.S_addr
UNIX/Linux sistemlerinde ise in_addr yapı ı ı
#include <netinet/in.h>
struct in_addr {
in_addr_t s_addr;
};
Aslı ı ı ı ı ı ı
tamsayı
kartı ı ı
Yukarı ı ı ı
"network byte ordering" denildiğinde "big endian" format anlaşı ı
"little endian" kullanmaktadı ı ı
(host to network byte ordering short) ve htonl (host to network byte ordering long) isimli iki fonksiyon vardı
yapan da ntohs (network byte ordering to host short) ve ntohl (network byte ordering to host long) fonksiyonları ı
Fonksiyonları
#include <winsock2.h>
u_short htons(
u_short hostshort
);
u_long htonl(
u_long hostlong
);
u_short ntohs(
u_short netshort
);
u_long ntohl(
u_long netlong
);
Fonksiyonları
#include <arpa/inet.h>
uint32_t htonl(uint32_t hostlong);
uint16_t htons(uint16_t hostshort);
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);
Bu durumda sockaddr_in yapı ı
struct sockaddr_in sinaddr;
sinaddr.sin_family = AF_INET;
sinaddr.sin_port = htons(SERVER_PORT);
sinaddr.sin_addr.s_addr = htonl(INADDR_ANY);
bind fonksiyonu başarı ı ı ı ı ı
ise -1 değerine geri dönmektedir. Örneğin Windows sistemlerinde fonksiyon şöyle çağrı
if (bind(serverSock, (struct sockaddr *)&sin_server, sizeof(sin_server)) == SOCKET_ERROR)
ExitSys("bind", WSAGetLastError());
UNIX/Linux sistemlerinde de çağrı
if (bind(server_sock, (struct sockaddr *)&sin_server, sizeof(sin_server)) == -1)
exit_sys("bind");
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
server program bind işleminden sonra soketi aktif dinleme konumuna sokmak için listen fonkiyonunu çağı ı ı
sistemlerindeki prototipi şöyledir:
#include <windows.h>
int listen(
SOCKET s,
int backlog
);
UNIX/Linux sistemlerindeki prototipi ise şöyledir:
#include <sys/socket.h>
int listen(int socket, int backlog);
Fonksiyonun birinci parametresi soket betimleyicisini, ikinci parametresi kuyruk uzunluğunu belirtir. listen işlemi blokeye yol açmamaktadı
İşletim sistemi listen işleminden sonra ilgili porta gelen bağlantı ı
Kuyruk uzunluğunu yüksek tutmak meşgul server'larda bağlantı ı ı ı ı
en yüksek değer 128'dir. Ancak "/proc/sys/net/core/somaxconn" dosyası ı ı
başarı ı ı ı
geri dönmektedir. Örneğin Windows sistemlerinde fonksiyon şöyle çağrı
if (listen(serverSock, 8) == SOCKET_ERROR)
ExitSys("listen", WSAGetLastError());
UNIX/Linux sistemlerinde de çağrı ı
if (listen(server_sock, 8) == -1)
exit_sys("listen");
Bu fonksiyon işletim sistemlerinin "firewall mekanizması ı ı ı ı ı
firewall tarafı ı ı ı ı ı ı
görüntülemektedir.)
Yukarı ı ı
porta gelecek bağlantı ı ı ı
alarak bağlantı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
97. Ders 22/06/2024 - Cumartesi
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-06-09 22:42:45 +03:00
2024-07-15 13:23:34 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
accept fonksiyonu bağlantı ı ı ı
isteği yoksa default durumda blokede bekler. Ancak accept fonksiyonu blokesiz modda da kullanı
sistemlerindeki prototipi şöyledir:
#include <winsock2.h>
SOCKET accept(
SOCKET s,
struct sockaddr *addr,
int *addrlen
);
UNIX/Linux sistemlerindeki prototipi ise şöyledir:
#include <sys/socket.h>
int accept(int socket, struct sockaddr *address, socklen_t *address_len);
Fonksiyonları ı ı
yerleştirileceği sockaddr_in yapı ı ı ı ı ı
Bizim bu parametre için IPv4'te sockaddr_in türünden, IPv6'da sockaddr_in6 türünden bir yapı
sockaddr_in yapı ı ı ı ı ı ı ı
port numarası ı ı ı
IP adresi ve port numarası ı ı ı ı ı ı
port numarası ı ı
176.234.135.196 adresi ve 55555 numaralı ı ı ı ı
İşte biz accept fonksiyonunun ikinci parametresinden client hakkı ı
Client (178.231.152.127:52310) ---> Server (176.234.135.196:55555)
accept fonksiyonunun üçüncü parametresi yine ikinci parametredeki yapı ı ı ı ı
parametre bir adres olarak alı ı ı ı ı
bu nesneye bu sizeof değerini yerleştirmeli ve nesnenin adresini de fonksiyonun üçüncü parametresine geçirmelidir. Fonksiyon bağlanı
ilişkin soket bilgilerinin byte uzunluğunu yine bu adrese yerleştirmektedir. Tabii IP protokol ailesinde her iki taraf da aynı ı ı ı
fonksiyon çı ı ı ı ı ı ı ı
accept fonksiyonu başarı ı ı ı
soket yoluyla konuşulacaktı ı ı ı
değeri ile geri dönmektedir. Örneğin Windows sistemlerine accpet fonksiyonu şöyle kullanı
struct sockaddr_in sin_client;
int sin_len;
SOCKET serverSock;
...
sin_len = sizeof(sin_client);
if ((clientSock = accept(serverSock, (struct sockaddr *)&sin_client, &sin_len)) == SOCKET_ERROR)
ExitSys("accept", WSAGetLastError());
UNIX/Linux sistemlerinde de fonksiyon şöyle kullanı
struct sockaddr_in sin_client;
socklen_t sin_len;
int client_sock;
...
sin_len = sizeof(sin_client);
if ((client_sock = accept(server_sock, (struct sockaddr *)&sin_client, &sin_len)) == -1)
exit_sys("accept");
Server tarafta temelde iki soket bulunmaktadı ı
terminolojisinde ""pasif soket (passive socket)" ya da "dinleme soketi (listening socket)" denilmektedir. İkinci soket ise client ile
konuşmakta kullanı
program birden fazla client ile konuşacaksa accept fonksiyonunu bir kez değil, çok kez uygulamalı ı ı
ile konuşmakta kullanı ı ı
bağlantı ı ı ı ı
accept fonksiyonu default durumda blokeli modda çalı ı ı ı ı ı
yoksa accept fonksiyonu blokeye yol açmaktadı ı ı ı ı ı
accept bloke olmadan bağlantı ı
accept fonksiyonu ile elde edilen client bilgilerindeki IP adresini ve port numaraları ı
formatı ı ı ı ı ı ı ı
alacağı ı ı ı ı
görüntülenmektedir.
IPV4 adresini alarak noktalı ı
şöyledir:
#include <winsock2.h>
#include <arpa/inet.h>
char *inet_ntoa(struct in_addr in);
Fonksiyon parametre olarak sockaddr_in yapı ı ı ı ı ı
alı ı ı ı ı ı
ekrana yazdı
printf("waiting for client...\n");
sin_len = sizeof(sin_client);
if ((clientSock = accept(serverSock, (struct sockaddr *)&sin_client, &sin_len)) == SOCKET_ERROR)
ExitSys("accept", WSAGetLastError());
printf("Connected %s:%d\n", inet_ntoa(sin_client.sin_addr), ntohs(sin_client.sin_port));
inet_nto fonksiyonunun tersini yapan inet_aton isimli bir fonksiyon da bulunmaktadı ı
in_addr yapı ı ı ı
#include <arpa/inet.h>
int inet_aton(const char *cp, struct in_addr *inp);
Fonksiyonun birinci parametresi noktalı ı
in_addr yapı ı ı ı ı ı ı ı
inet_ntoa ve inet_aton fonksiyonları ı ı ı ı ı ı
"deprecated" yapı ı ı ı ı ı ı ı ı
kolaylı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* Windows ""server.c" */
#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#include <windows.h>
#define PORT_NO 55555
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr);
int main(void)
{
WSADATA wsaData;
int result;
SOCKET serverSock, clientSock;
struct sockaddr_in sinServer, sinClient;
int sin_len;
if ((result = WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0)
ExitSys("WSAStartup", result);
if ((serverSock = socket(AF_INET, SOCK_STREAM, 0)) == SOCKET_ERROR)
ExitSys("socket", WSAGetLastError());
sinServer.sin_family = AF_INET;
sinServer.sin_port = htons(PORT_NO);
sinServer.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(serverSock, (struct sockaddr *)&sinServer, sizeof(sinServer)) == SOCKET_ERROR)
ExitSys("bind", WSAGetLastError());
if (listen(serverSock, 8) == SOCKET_ERROR)
ExitSys("listen", WSAGetLastError());
printf("waiting for client...\n");
sin_len = sizeof(sinClient);
if ((clientSock = accept(serverSock, (struct sockaddr *)&sinClient, &sin_len)) == SOCKET_ERROR)
ExitSys("accept", WSAGetLastError());
printf("Connected %s:%d\n", inet_ntoa(sinClient.sin_addr), ntohs(sinClient.sin_port));
WSACleanup();
printf("Ok\n");
return 0;
}
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr)
{
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/* UNIX/Linux "server.c" */
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#define PORT_NO 55555
void exit_sys(const char* msg);
int main(void)
{
int server_sock, client_sock;
struct sockaddr_in sin_server, sin_client;
socklen_t sin_len;
if ((server_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
exit_sys("socket");
sin_server.sin_family = AF_INET;
sin_server.sin_port = htons(PORT_NO);
sin_server.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(server_sock, (struct sockaddr *)&sin_server, sizeof(sin_server)) == -1)
exit_sys("bind");
if (listen(server_sock, 8) == -1)
exit_sys("listen");
printf("waiting for client..\n");
sin_len = sizeof(sin_client);
if ((client_sock = accept(server_sock, (struct sockaddr *)&sin_client, &sin_len)) == -1)
exit_sys("accept");
printf("Client connected %s:%d\n", inet_ntoa(sin_client.sin_addr), ntohs(sin_client.sin_port));
return 0;
}
void exit_sys(const char* msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
TCP client program, server programa bağlanabilmek için tipik bazı ı ı ı ı ı ı ı
şunlardı
(Windows'ta WSAStartup) ---> socket ---> bind (isteğe bağlı ı
---> shutdown ---> close (Windows'ta closesocket) (---> Windows'ta WSACleanup)
Client taraf önce yine socket fonksiyonuyla bir soket yaratı
Eğer client taraf belli bir port'tan bağlanmak istiyorsa bu durumda bind işlemini uygulayabilir. Eğer client bind işlemi yapmazsa zaten işletim
sistemi connect işlemi sı ı ı ı ı
sı ı ı ı ı ı ı
client için belli bir remote port numarası ı
uygulaması
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Client bağlantı ı ı ı ı ı ı
adresleri ile eşleşen "host isimleri" oluşturulmuştur. Ancak IP protokol ailesi host isimleriyle değil, IP numaraları ı ı
İşte host isimleriyle IP numaraları ı ı
IP protokol ailesindeki DNS isimli bir protokol ile çalı ı ı ı ı
DNS işlemi yaparak o host ismine karşı ı ı ı ı ı ı
bir DNS server'da yoksa başka bir DNS server'a referans edilmektedir.
DNS server'larda host isimleriyle IP numaraları ı ı ı
olabileceği gibi belli bir IP numarası
DNS işlemleri yapan iki geleneksel fonksiyon vardı ı ı ı ı
fonksiyonlar artı ı ı ı ı ı
oluşturulmuştur. Bu fonksiyonlar POSIX standartları ı ı
ve "gethostbyaddress" kullanmayacağı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
getaddrinfo isimli fonksiyon inet_addr ve gethosybyname fonksiyonları ı ı
getaddrinfo hem noktalı ı ı
server isimsel olarak girilmiş olabilir) DNS işlemi yaparak ilgili host'un IP adresini elde eder. Maalesef fonksiyon biraz karı ı ı ı
Fonksiyonun Windows sistemlerindeki prototipi şöyledir:
#include <ws2tcpip.h>
INT getaddrinfo(
PCSTR pNodeName,
PCSTR pServiceName,
const ADDRINFOA *pHints,
PADDRINFOA *ppResult
);
UNIX/Linux sistemlerindeki prototipi ise şöyledir:
#include <netdb.h>
int getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res);
Aslı ı ı ı ı ı ı
"noktalı ı ı
Ancak bu parametreye port numarası ı ı ı
dönüştürüp bize verecektir. Bu parametreye aynı ı
(Örneğin "http" gibi, "ftp" gibi). Bu durumda bu protokollerin port numaraları ı
yapı ı ı ı
Fonksiyonun üçüncü parametresi nası ı
türündendir. Bu yapı ı ı ı ı ı ı ı ı ı ı
sı ı ı ı ı ı
belirtmektedir). addrinfo yapı ı
struct addrinfo {
int ai_flags;
int ai_family;
int ai_socktype;
int ai_protocol;
socklen_t ai_addrlen;
struct sockaddr *ai_addr;
char *ai_canonname;
struct addrinfo *ai_next;
};
Yapı ı ı ı ı ı
host'a ilişkin IPv4 adresleri, AF_INET6 girilirse host'a ilişkin IPv6 adresleri, AF_UNSPEC girilirse hem IPv4 hem de IPv6 adresleri elde edilir.
Yapı ı ı ı ı ı ı ı
Bu parametre NULL adres de girilebilir. Bu durumda ilgili host'a ilişkin tüm adresler elde edilir.
getaddrinfo fonksiyonunun son parametresine bir bağlı ı ı ı
elemanı ı ı ı ı ı ı ı ı ı ı ı
getaddrinfo fonksiyonu başarı ı ı ı ı
WSAGetLastError fonksiyonuyla elde ettiğimiz hata kodları ı ı ı ı ı
UNIX/Linux sistemlerinde gai_strerror fonksiyonuyla yazı
Bağlı ı ı
#include <netdb.h>
void freeaddrinfo(struct addrinfo *ai);
Fonksiyon getaddrinfo fonksiyonunun verdiği bağlı ı ı ı
gai_strerror fonksiyonunun prototipi de şöyledir:
#include <netdb.h>
const char *gai_strerror(int ecode);
getaddrinfo fonksiyonunun client programda tipik kullanı ı ı
Bu fonksiyon bize connect için gereken sockaddr_in ya da sockadd_in6 yapı
Örneğin biz "microsoft.com" host isminin bütün IPV4 AIP adreslerini aşağı
struct addrinfo *ainfoHead, *ainfo;
struct sockaddr_in *sinHost;
struct addrinfo hints = {0, AF_INET, SOCK_STREAM};
...
if ((result = getaddrinfo(HOST_NAME, "55555", &hints, &ainfoHead)) != 0)
ExitSys("bind", result);
for (ainfo = ainfoHead; ainfo != NULL; ainfo = ainfo->ai_next) {
sinHost = (struct sockaddr_in *)ainfo->ai_addr;
printf("%s\n", inet_ntoa(sinHost->sin_addr));
}
freeaddrinfo(ainfoHead);
Programcı ı ı ı
getaddrinfo fonksiyonunun tersini yapan getnameinfo isminde bir fonksiyon da sonraları
olarak ilgili host'un IP adresini alı ı ı ı
Eğer elimizde zaten server'ı ı
noktalı ı
fonksiyonun kullanı ı
#include <winsock2.h>
unsigned long inet_addr(const char *cp);
UNIX/Linux sistemlerindeki prototipi ise şöyledir:
#include <arpa/inet.h>
in_addr_t inet_addr(const char *cp);
Fonksiyonlar noktası ı ı ı ı
sistemlerinde INADDR_NONE değerine, UNIX/Linux sistemlrinde ise -1 değerine geri dönmektedir.
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------------------------------------------------
Artı ı ı ı
#include <winsock2.h>
int WSAAPI connect(
SOCKET s,
const sockaddr *name,
int namelen
);
UNIX/Linux sistemlerindeki prototipi ise şöyledir:
#include <sys/socket.h>
int connect(int socket, const struct sockaddr *address, socklen_t address_len);
Fonksiyonun birinci parametresi soket betimleyicisini belirtir. İkinci parametre bağlanı
yapı ı ı ı
Fonksiyon başarı ı ı ı ı ı
Eğer connect fonksiyonu çağrı ı ı ı ı ı ı
belli bir zaman aşı ı ı ı
set edilir. Örneğin:
if (connect(client_sock, (struct sockaddr *)&sin_server, sizeof(sin_server)) == -1)
exit_sys("connect");
Aşağı ı ı
Client programda bind işlemini yorum satı ı ı ı
(ki genellikle yapmaz) bu durumda işletim sistemi client program için o programı ı ı ı ı ı
Ayrı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* Windows "client.c" */
#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
#define PORT_NO "55555"
#define HOST_NAME "127.0.0.1"
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr);
int main(void)
{
WSADATA wsaData;
int result;
SOCKET clientSock;
struct addrinfo *ainfoHead, *ainfo;
struct addrinfo hints = {0, AF_INET, SOCK_STREAM};
if ((result = WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0)
ExitSys("WSAStartup", result);
if ((clientSock = socket(AF_INET, SOCK_STREAM, 0)) == SOCKET_ERROR)
ExitSys("socket", WSAGetLastError());
/*
{
#define CLIENT_PORT_NO 50000
struct sockaddr_in sinClient;
sinClient.sin_family = AF_INET;
sinClient.sin_port = htons(CLIENT_PORT_NO);
sinClient.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(clientSock, (struct sockaddr *)&sinClient, sizeof(sinClient)) == SOCKET_ERROR)
ExitSys("bind", WSAGetLastError());
}
*/
if ((result = getaddrinfo(HOST_NAME, PORT_NO, &hints, &ainfoHead)) != 0)
ExitSys("getaddrinfo", result);
for (ainfo = ainfoHead; ainfo != NULL; ainfo = ainfo->ai_next)
if (connect(clientSock, ainfo->ai_addr, sizeof(struct sockaddr_in)) == 0)
break;
if (ainfo == NULL)
ExitSys("connect", WSAGetLastError());
freeaddrinfo(ainfoHead);
/*
{
struct sockaddr_in sinServer;
sinServer.sin_family = AF_INET;
sinServer.sin_port = htons(55555);
if ((sinServer.sin_addr.s_addr = inet_addr(HOST_NAME)) == INADDR_NONE)
ExitSys("inet_addr", WSAGetLastError());
if (connect(clientSock, (struct sockaddr *)&sinServer, sizeof(sinServer)) == SOCKET_ERROR)
ExitSys("connect", WSAGetLastError());
}
*/
printf("connected...\n");
WSACleanup();
return 0;
}
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr)
{
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/* Unix/Linux "client.c" */
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netdb.h>
#define PORT_NO "55555"
#define HOST_NAME "127.0.0.1"
void exit_sys(const char* msg);
int main(void)
{
int client_sock;
struct addrinfo *ainfo_head, *ainfo;
struct addrinfo hints = {0, AF_INET, SOCK_STREAM};
int result;
if ((client_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
exit_sys("socket");
/*
{
#define CLIENT_PORT_NO 50000
struct sockaddr_in sin_client;
sin_client.sin_family = AF_INET;
sin_client.sin_port = htons(CLIENT_PORT_NO);
sin_client.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(client_sock, (struct sockaddr *)&sin_client, sizeof(sin_client)) == -1)
exit_sys("bind");
}
*/
if ((result = getaddrinfo(HOST_NAME, PORT_NO, &hints, &ainfo_head)) != 0)
exit_sys("getaddrinfo");
for (ainfo = ainfo_head; ainfo != NULL; ainfo = ainfo->ai_next)
if (connect(client_sock, ainfo->ai_addr, sizeof(struct sockaddr_in)) == 0)
break;
if (ainfo == NULL)
exit_sys("connect");
freeaddrinfo(ainfo_head);
/*
{
struct sockaddr_in sin_server;
sin_server.sin_family = AF_INET;
sin_server.sin_port = htons(55555);
if ((sin_server.sin_addr.s_addr = inet_addr(HOST_NAME)) == -1)
exit_sys("inet_addr");
if (connect(client_sock, (struct sockaddr *)&sin_server, sizeof(sin_server)) == -1)
exit_sys("connect");
}
*/
printf("connected...\n");
return 0;
}
void exit_sys(const char* msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
Bağlantı ı ı ı ı ı
byte okumak için recv fonksiyonları ı ı ı
sistemlerde send yerine write, recv yerine read POSIX fonksiyonları ı ı
client ve server programlar aynı
recv fonksiyonunun Windows sistemlerindeki prototipi şöyledir:
#include <winsock2.h>
int recv(
SOCKET s,
char *buf,
int len,
int flags
);
UNIX/linux sistemlerindeki prototipi ise şöyledir:
#include <sys/socket.h>
ssize_t recv(int socket, void *buffer, size_t length, int flags);
Fonksiyonları ı
adresini almaktadı ı ı ı ı
sabitin bit OR işlemine sokulması
MSG_PEEK
MSG_OOB
MSG_WAITALL
Biz şimdilik bu değerlerin anlamları ı ı ı ı ı ı ı ı
belirtmektedir. Bu parametre 0 da geçilebilir. Zaten recv fonksiyonunun read fonksiyonundan tek farkı
0 geçilmesiyle read kullanı ı ı ı ı
recv fonksiyonu blokeli modda (default durum blokeli moddur) tı ı ı
bilgiyi okur ve okuyabildiği byte sayı ı
kadar blokede bekler. (Yani başka bir deyişle recv tı ı
en az 1 byte varsa okuyabildiğini okur ve beklemeden geri döner.)
recv fonksiyonu başarı ı ı ı ı ı
-1 değerine geri dönmektedir. Eğer karşı ı ı ı
ile geri dönmektedir. Soketlerle boruları ı ı ı
Soketten bilgi göndermek için send ya da UNIX/Linux sistemleribde write fonksiyonu kullanı ı
prototipi şöyledir:
#include <winsock2.h>
int send(
SOCKET s,
const char *buf,
int len,
int flags
);
UNIX/Linux sistemlerindeki prototipi ise şöyledir:
#include <sys/socket.h>
ssize_t send(int socket, const void *buffer, size_t length, int flags);
Fonksiyoları
belirtir. Üçüncü parametre ise gönderilecek byte miktarı ı ı
sokulması
MSG_EOR
MSG_OOB
MSG_NOSIGNAL
Bu parametre 0 da geçilebilir. Biz şimdilik bu bayraklar üzerinde durmayacağı
send fonksiyonu bilgileri karşı ı ı
IP) paketleri oluşturarak mesajı ı ı ı
karşı ı
gönderilecek bilginin tamamı ı ı ı ı
olabilmektedir. Örneğin Windows sistemlerinde send fonksiyonu eğer network tamponununda gönderilmek istenen kadar yer yoksa ancak en az
bir byte'lı ı ı ı
send fonksiyonunun davranı ı ı ı ı ı ı
tamponuna yazı ı ı ı ı
send fonksiyonu network tamponuna yazı ı ı ı
değerle aynı ı ı ı
ile UNIX/Linux sistemlerinde ise -1 değeri ile geri döner.Tı ı
karşı ı ı ı ı
istenmiyorsa bu durumda send fonksiyonunun son parametresi (flags) MSG_NOSIGNAL olarak geçilmelidir. Bu durumda karşı ı
send fonksiyonu başarı ı ı ı ı ı
çok benzediğine dikkat ediniz.
send fonksiyonunun son parametresi 0 geçildiğinde bu fonksiyonun davranı ı
------------------------------------------------------------------------------------------------------------------------------------------*/
<BURADA KALDIK>
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Aşağı ı ı
Server da bu yazı ı ı ı ı ı ı
2024-07-15 13:23:34 +03:00
------------------------------------------------------------------------------------------------------------------------------------------*/
2024-06-09 22:42:45 +03:00
/* Server.c */
2024-04-29 13:28:55 +03:00
#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#define SERVER_PORTNO 55000
2024-06-09 22:42:45 +03:00
#define BUFFER_SIZE 1024
2024-04-29 13:28:55 +03:00
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr);
int main(void)
{
WSADATA wsaData;
DWORD dwResult;
2024-06-09 22:42:45 +03:00
SOCKET serverSock, clientSock;
struct sockaddr_in sinServer, sinClient;
int addrLen;
2024-04-29 13:28:55 +03:00
char buf[BUFFER_SIZE];
2024-06-09 22:42:45 +03:00
char *str;
2024-04-29 13:28:55 +03:00
int result;
if ((dwResult = WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0)
ExitSys("WSAStartup", dwResult);
2024-06-09 22:42:45 +03:00
if ((serverSock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) /* third parameter IPPROTO_TCP */
2024-04-29 13:28:55 +03:00
ExitSys("socket", WSAGetLastError());
sinServer.sin_family = AF_INET;
sinServer.sin_port = htons(SERVER_PORTNO);
2024-06-09 22:42:45 +03:00
sinServer.sin_addr.s_addr = htonl(INADDR_ANY);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (bind(serverSock, (struct sockaddr *)&sinServer, sizeof(sinServer)) == SOCKET_ERROR)
ExitSys("bind", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (listen(serverSock, 8) == SOCKET_ERROR)
ExitSys("listen", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
printf("Waiting for client connection....\n");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
addrLen = sizeof(sinClient);
if ((clientSock = accept(serverSock, (struct sockaddr *)&sinClient, &addrLen)) == INVALID_SOCKET)
ExitSys("accept", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
printf("Connected: %s:%d\n", inet_ntoa(sinClient.sin_addr), ntohs(sinClient.sin_port));
2024-04-29 13:28:55 +03:00
for (;;) {
2024-06-09 22:42:45 +03:00
if ((result = recv(clientSock, buf, BUFFER_SIZE - 1, 0)) == SOCKET_ERROR)
ExitSys("recv", WSAGetLastError());
2024-04-29 13:28:55 +03:00
if (result == 0)
break;
2024-06-09 22:42:45 +03:00
buf[result] = '\0';
if (!strcmp(buf, "exit"))
2024-04-29 13:28:55 +03:00
break;
2024-06-09 22:42:45 +03:00
printf("%d bytes received: %s\n", result, buf);
_strrev(buf);
if (send(clientSock, buf, strlen(buf), 0) == SOCKET_ERROR)
ExitSys("send", WSAGetLastError());
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
2024-04-29 13:28:55 +03:00
shutdown(clientSock, SD_BOTH);
closesocket(clientSock);
2024-06-09 22:42:45 +03:00
closesocket(serverSock);
2024-04-29 13:28:55 +03:00
WSACleanup();
return 0;
}
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr)
{
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
2024-06-09 22:42:45 +03:00
/* Client.c */
2024-04-29 13:28:55 +03:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>
2024-06-09 22:42:45 +03:00
#define SERVER_PORTNO 55000
#define CLIENT_PORTNO 62000
#define BUFFER_SIZE 1024
#define SERVER_NAME "127.0.0.1"
2024-04-29 13:28:55 +03:00
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr);
int main(void)
{
WSADATA wsaData;
DWORD dwResult;
SOCKET clientSock;
struct sockaddr_in sinServer;
struct hostent *hostEnt;
2024-06-09 22:42:45 +03:00
char buf[BUFFER_SIZE];
2024-04-29 13:28:55 +03:00
char *str;
2024-06-09 22:42:45 +03:00
int result;
2024-04-29 13:28:55 +03:00
if ((dwResult = WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0)
ExitSys("WSAStartup", dwResult);
if ((clientSock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
ExitSys("socket", WSAGetLastError());
/*
{
struct sockaddr_in sinClient;
sinClient.sin_family = AF_INET;
sinClient.sin_port = htons(CLIENT_PORTNO);
sinClient.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(clientSock, (struct sockaddr *)&sinClient, sizeof(sinClient)) == SOCKET_ERROR)
ExitSys("bind", WSAGetLastError());
}
*/
sinServer.sin_family = AF_INET;
sinServer.sin_port = htons(SERVER_PORTNO);
sinServer.sin_addr.s_addr = inet_addr(SERVER_NAME);
if (sinServer.sin_addr.s_addr == INADDR_NONE) {
2024-06-09 22:42:45 +03:00
if ((hostEnt = gethostbyname(SERVER_NAME)) == NULL)
2024-04-29 13:28:55 +03:00
ExitSys("gethostbyname", WSAGetLastError());
memcpy(&sinServer.sin_addr.s_addr, hostEnt->h_addr_list[0], hostEnt->h_length);
}
if (connect(clientSock, (struct sockaddr *)&sinServer, sizeof(sinServer)) == SOCKET_ERROR)
ExitSys("connect", WSAGetLastError());
2024-06-09 22:42:45 +03:00
printf("Connected...\n");
2024-04-29 13:28:55 +03:00
for (;;) {
2024-06-09 22:42:45 +03:00
printf("Text:");
2024-04-29 13:28:55 +03:00
fgets(buf, BUFFER_SIZE, stdin);
if ((str = strchr(buf, '\n')) != NULL)
*str = '\0';
2024-06-09 22:42:45 +03:00
if (send(clientSock, buf, strlen(buf), 0) == SOCKET_ERROR)
ExitSys("send", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (!strcmp(buf, "exit"))
2024-04-29 13:28:55 +03:00
break;
2024-06-09 22:42:45 +03:00
if ((result = recv(clientSock, buf, BUFFER_SIZE - 1, 0)) == SOCKET_ERROR)
ExitSys("recv", WSAGetLastError());
2024-04-29 13:28:55 +03:00
if (result == 0)
break;
buf[result] = '\0';
2024-06-09 22:42:45 +03:00
printf("%d bytes received: %s\n", result, buf);
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
shutdown(clientSock, SD_BOTH);
2024-04-29 13:28:55 +03:00
closesocket(clientSock);
WSACleanup();
return 0;
}
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr)
{
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
Yukarı ı ı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-06-09 22:42:45 +03:00
/* server.c */
2024-04-29 13:28:55 +03:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define SERVER_PORTNO 55000
#define BUFFER_SIZE 1024
void exit_sys(const char *msg);
2024-06-09 22:42:45 +03:00
void reverse_str(char *str);
2024-04-29 13:28:55 +03:00
int main(void)
{
2024-06-09 22:42:45 +03:00
int server_sock, client_sock;
2024-04-29 13:28:55 +03:00
struct sockaddr_in sin_server, sin_client;
socklen_t addrlen;
2024-06-09 22:42:45 +03:00
char buf[BUFFER_SIZE];
char *str;
2024-04-29 13:28:55 +03:00
int result;
2024-06-09 22:42:45 +03:00
if ((server_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
2024-04-29 13:28:55 +03:00
exit_sys("socket");
sin_server.sin_family = AF_INET;
sin_server.sin_port = htons(SERVER_PORTNO);
sin_server.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(server_sock, (struct sockaddr *)&sin_server, sizeof(sin_server)) == -1)
exit_sys("bind");
2024-06-09 22:42:45 +03:00
if (listen(server_sock, 8) == -1)
exit_sys("listen");
printf("Waiting for client connection....\n");
addrlen = sizeof(sin_client);
if ((client_sock = accept(server_sock, (struct sockaddr *)&sin_client, &addrlen)) == -1)
exit_sys("accept");
printf("Connected: %s:%d\n", inet_ntoa(sin_client.sin_addr), ntohs(sin_client.sin_port));
2024-04-29 13:28:55 +03:00
for (;;) {
2024-06-09 22:42:45 +03:00
if ((result = recv(client_sock, buf, BUFFER_SIZE - 1, 0)) == -1)
exit_sys("recv");
if (result == 0)
break;
2024-04-29 13:28:55 +03:00
buf[result] = '\0';
2024-06-09 22:42:45 +03:00
if (!strcmp(buf, "exit"))
break;
printf("%d bytes received: %s\n", result, buf);
reverse_str(buf);
if (send(client_sock, buf, strlen(buf), 0) == -1)
exit_sys("recv");
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
shutdown(client_sock, SHUT_RDWR);
close(client_sock);
close(server_sock);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return 0;
}
void reverse_str(char *str)
{
size_t len, i;
char temp;
for (len = 0; str[len] != '\0'; ++len)
;
for (i = 0; i < len / 2; ++i) {
temp = str[i];
str[i] = str[len - i - 1];
str[len - i - 1] = temp;
}
2024-04-29 13:28:55 +03:00
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
2024-06-09 22:42:45 +03:00
/* client.c */
2024-04-29 13:28:55 +03:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#define SERVER_PORTNO 55000
2024-06-09 22:42:45 +03:00
#define CLIENT_PORTNO 62000
2024-04-29 13:28:55 +03:00
#define BUFFER_SIZE 1024
#define SERVER_NAME "127.0.0.1"
void exit_sys(const char *msg);
int main(void)
{
2024-06-09 22:42:45 +03:00
int client_sock;
struct sockaddr_in sin_server;
struct hostent *hostent;
char *str;
char buf[BUFFER_SIZE];
int result;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((client_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
exit_sys("socket");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*
struct sockaddr_in sin_client;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
sin_client.sin_family = AF_INET;
sin_client.sin_port = htons(CLIENT_PORTNO);
sin_client.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(client_sock, (struct sockaddr *)&sin_client, sizeof(sin_client)) == -1)
exit_sys("socket");
*/
sin_server.sin_family = AF_INET;
sin_server.sin_port = htons(SERVER_PORTNO);
sin_server.sin_addr.s_addr = inet_addr(SERVER_NAME);
if (sin_server.sin_addr.s_addr == INADDR_NONE) {
if ((hostent = gethostbyname(SERVER_NAME)) == NULL)
exit_sys("gethostbyname");
memcpy(&sin_server.sin_addr.s_addr, hostent->h_addr_list[0], hostent->h_length);
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
if (connect(client_sock, (struct sockaddr *)&sin_server, sizeof(sin_server)) == -1)
exit_sys("gethostbyname");
printf("Connected...\n");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
for (;;) {
printf("Text:");
2024-04-29 13:28:55 +03:00
fgets(buf, BUFFER_SIZE, stdin);
if ((str = strchr(buf, '\n')) != NULL)
*str = '\0';
2024-06-09 22:42:45 +03:00
if (send(client_sock, buf, strlen(buf), 0) == -1)
exit_sys("send");
2024-04-29 13:28:55 +03:00
if (!strcmp(buf, "exit"))
break;
2024-06-09 22:42:45 +03:00
if ((result = recv(client_sock, buf, BUFFER_SIZE - 1, 0)) == -1)
exit_sys("recv");
if (result == 0)
break;
buf[result] = '\0';
printf("%d bytes received: %s\n", result, buf);
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
shutdown(client_sock, SHUT_RDWR);
close(client_sock);
return 0;
2024-04-29 13:28:55 +03:00
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
Windows'ta çok client'lı ı ı ı ı ı ı ı
o thread'in bağlanı ı ı ı ı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-06-09 22:42:45 +03:00
/* Server.c */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#define SERVER_PORTNO 55000
#define BUFFER_SIZE 1024
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr);
DWORD __stdcall ClientThreadProc(LPVOID lpParam);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
struct CLIENT_INFO {
SOCKET sock;
char addr[16];
int port;
};
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int main(void)
{
WSADATA wsaData;
DWORD dwResult;
SOCKET serverSock, clientSock;
struct sockaddr_in sinServer, sinClient;
int addrLen;
HANDLE hThread;
DWORD dwThreadId;
struct CLIENT_INFO *ci;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((dwResult = WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0)
ExitSys("WSAStartup", dwResult);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((serverSock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) /* third parameter IPPROTO_TCP */
ExitSys("socket", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
sinServer.sin_family = AF_INET;
sinServer.sin_port = htons(SERVER_PORTNO);
sinServer.sin_addr.s_addr = htonl(INADDR_ANY);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (bind(serverSock, (struct sockaddr *)&sinServer, sizeof(sinServer)) == SOCKET_ERROR)
ExitSys("bind", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (listen(serverSock, 8) == SOCKET_ERROR)
ExitSys("listen", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
printf("Waiting for client connection....\n");
for (;;) {
addrLen = sizeof(sinClient);
if ((clientSock = accept(serverSock, (struct sockaddr *)&sinClient, &addrLen)) == INVALID_SOCKET)
ExitSys("accept", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((ci = (struct CLIENT_INFO *)malloc(sizeof(struct CLIENT_INFO))) == NULL) {
fprintf(stderr, "Cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
ci->sock = clientSock;
strcpy(ci->addr, inet_ntoa(sinClient.sin_addr));
ci->port = ntohs(sinClient.sin_port);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
printf("Connected: %s:%d\n", ci->addr, ci->port);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((hThread = CreateThread(NULL, 0, ClientThreadProc, ci, 0, &dwThreadId)) == NULL)
ExitSys("CreateThread", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
CloseHandle(hThread);
}
closesocket(serverSock);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
WSACleanup();
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return 0;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
DWORD __stdcall ClientThreadProc(LPVOID lpParam)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
struct CLIENT_INFO *ci = (struct CLIENT_INFO *)lpParam;
int result;
char buf[BUFFER_SIZE];
for (;;) {
if ((result = recv(ci->sock, buf, BUFFER_SIZE - 1, 0)) == SOCKET_ERROR)
goto FAILED;
if (result == 0)
break;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
buf[result] = '\0';
if (!strcmp(buf, "exit"))
break;
printf("%d bytes received from %s:%d => \"%s\"\n", result, ci->addr, ci->port, buf);
_strrev(buf);
if (send(ci->sock, buf, strlen(buf), 0) == SOCKET_ERROR)
goto FAILED;
}
FAILED:
printf("Client %s:%d exits...\n", ci->addr, ci->port);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
shutdown(ci->sock, SD_BOTH);
closesocket(ci->sock);
free(ci);
return 0;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
LPTSTR lpszErr;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
exit(EXIT_FAILURE);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* Client.c */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#define SERVER_PORTNO 55000
#define CLIENT_PORTNO 62000
#define BUFFER_SIZE 1024
#define SERVER_NAME "127.0.0.1"
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int main(void)
{
WSADATA wsaData;
DWORD dwResult;
SOCKET clientSock;
struct sockaddr_in sinServer;
struct hostent *hostEnt;
char buf[BUFFER_SIZE];
char *str;
int result;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((dwResult = WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0)
ExitSys("WSAStartup", dwResult);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((clientSock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
ExitSys("socket", WSAGetLastError());
/*
{
struct sockaddr_in sinClient;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
sinClient.sin_family = AF_INET;
sinClient.sin_port = htons(CLIENT_PORTNO);
sinClient.sin_addr.s_addr = htonl(INADDR_ANY);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (bind(clientSock, (struct sockaddr *)&sinClient, sizeof(sinClient)) == SOCKET_ERROR)
ExitSys("bind", WSAGetLastError());
}
*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
sinServer.sin_family = AF_INET;
sinServer.sin_port = htons(SERVER_PORTNO);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
sinServer.sin_addr.s_addr = inet_addr(SERVER_NAME);
if (sinServer.sin_addr.s_addr == INADDR_NONE) {
if ((hostEnt = gethostbyname(SERVER_NAME)) == NULL)
ExitSys("gethostbyname", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
memcpy(&sinServer.sin_addr.s_addr, hostEnt->h_addr_list[0], hostEnt->h_length);
}
if (connect(clientSock, (struct sockaddr *)&sinServer, sizeof(sinServer)) == SOCKET_ERROR)
ExitSys("connect", WSAGetLastError());
printf("Connected...\n");
for (;;) {
printf("Text:");
fgets(buf, BUFFER_SIZE, stdin);
if ((str = strchr(buf, '\n')) != NULL)
*str = '\0';
if (send(clientSock, buf, strlen(buf), 0) == SOCKET_ERROR)
ExitSys("send", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (!strcmp(buf, "exit"))
break;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((result = recv(clientSock, buf, BUFFER_SIZE - 1, 0)) == SOCKET_ERROR)
ExitSys("recv", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (result == 0)
break;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
buf[result] = '\0';
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
printf("%d bytes received: %s\n", result, buf);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
shutdown(clientSock, SD_BOTH);
closesocket(clientSock);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
WSACleanup();
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return 0;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr)
{
LPTSTR lpszErr;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
exit(EXIT_FAILURE);
}
2024-04-29 13:28:55 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
Yukarı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* server.c */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#define SERVER_PORTNO 55000
#define BUFFER_SIZE 1024
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
struct CLIENT_INFO {
int sock;
char addr[16];
int port;
};
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void exit_sys(const char *msg);
void *client_thread_proc(void *param);
void reverse_str(char *str);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int main(void)
{
int server_sock, client_sock;
struct sockaddr_in sin_server, sin_client;
socklen_t addrlen;
struct CLIENT_INFO *ci;
pthread_t tid;
int result;
if ((server_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
exit_sys("socket");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
sin_server.sin_family = AF_INET;
sin_server.sin_port = htons(SERVER_PORTNO);
sin_server.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(server_sock, (struct sockaddr *)&sin_server, sizeof(sin_server)) == -1)
exit_sys("bind");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (listen(server_sock, 8) == -1)
exit_sys("listen");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
printf("Waiting for client connection....\n");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
for (;;) {
addrlen = sizeof(sin_client);
if ((client_sock = accept(server_sock, (struct sockaddr *)&sin_client, &addrlen)) == -1)
exit_sys("accept");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((ci = (struct CLIENT_INFO *)malloc(sizeof(struct CLIENT_INFO))) == NULL) {
fprintf(stderr, "Cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
ci->sock = client_sock;
strcpy(ci->addr, inet_ntoa(sin_client.sin_addr));
ci->port = ntohs(sin_client.sin_port);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
printf("Connected: %s:%d\n", ci->addr, ci->port);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((result = pthread_create(&tid, NULL, client_thread_proc, ci)) != 0) {
fprintf(stderr, "pthread_create: %s\n", strerror(result));
exit(EXIT_FAILURE);
}
if ((result = pthread_detach(tid)) != 0) {
fprintf(stderr, "pthread_create: %s\n", strerror(result));
exit(EXIT_FAILURE);
}
}
shutdown(server_sock, SHUT_RDWR);
close(server_sock);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return 0;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void *client_thread_proc(void *param)
{
struct CLIENT_INFO *ci = (struct CLIENT_INFO *)param;
int result;
char buf[BUFFER_SIZE];
for (;;) {
if ((result = recv(ci->sock, buf, BUFFER_SIZE - 1, 0)) == -1)
goto FAILED;
if (result == 0)
break;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
buf[result] = '\0';
if (!strcmp(buf, "exit"))
break;
printf("%d bytes received from %s:%d => \"%s\"\n", result, ci->addr, ci->port, buf);
reverse_str(buf);
if (send(ci->sock, buf, strlen(buf), 0) == -1)
goto FAILED;
}
FAILED:
printf("Client %s:%d exits...\n", ci->addr, ci->port);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
shutdown(ci->sock, SHUT_RDWR);
close(ci->sock);
free(ci);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return NULL;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void reverse_str(char *str)
{
size_t len, i;
char temp;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
for (len = 0; str[len] != '\0'; ++len)
;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
for (i = 0; i < len / 2; ++i) {
temp = str[i];
str[i] = str[len - i - 1];
str[len - i - 1] = temp;
}
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void exit_sys(const char *msg)
{
perror(msg);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
exit(EXIT_FAILURE);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* client.c */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#define SERVER_PORTNO 55000
#define CLIENT_PORTNO 62000
#define BUFFER_SIZE 1024
#define SERVER_NAME "127.0.0.1"
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void exit_sys(const char *msg);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int main(void)
{
int client_sock;
struct sockaddr_in sin_server;
struct hostent *hostent;
char *str;
char buf[BUFFER_SIZE];
int result;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((client_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
exit_sys("socket");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*
struct sockaddr_in sin_client;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
sin_client.sin_family = AF_INET;
sin_client.sin_port = htons(CLIENT_PORTNO);
sin_client.sin_addr.s_addr = htonl(INADDR_ANY);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (bind(client_sock, (struct sockaddr *)&sin_client, sizeof(sin_client)) == -1)
exit_sys("socket");
*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
sin_server.sin_family = AF_INET;
sin_server.sin_port = htons(SERVER_PORTNO);
sin_server.sin_addr.s_addr = inet_addr(SERVER_NAME);
if (sin_server.sin_addr.s_addr == INADDR_NONE) {
if ((hostent = gethostbyname(SERVER_NAME)) == NULL)
exit_sys("gethostbyname");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
memcpy(&sin_server.sin_addr.s_addr, hostent->h_addr_list[0], hostent->h_length);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (connect(client_sock, (struct sockaddr *)&sin_server, sizeof(sin_server)) == -1)
exit_sys("gethostbyname");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
printf("Connected...\n");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
for (;;) {
printf("Text:");
fgets(buf, BUFFER_SIZE, stdin);
if ((str = strchr(buf, '\n')) != NULL)
*str = '\0';
if (send(client_sock, buf, strlen(buf), 0) == -1)
exit_sys("send");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (!strcmp(buf, "exit"))
break;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((result = recv(client_sock, buf, BUFFER_SIZE - 1, 0)) == -1)
exit_sys("recv");
if (result == 0)
break;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
buf[result] = '\0';
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
printf("%d bytes received: %s\n", result, buf);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
shutdown(client_sock, SHUT_RDWR);
close(client_sock);
return 0;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
void exit_sys(const char *msg)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
perror(msg);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
exit(EXIT_FAILURE);
2024-04-29 13:28:55 +03:00
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
Aslı ı ı ı ı ı
client ile bağlantı ı ı
Aşağı ı ı
Ancak daha pratiktir.
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-06-09 22:42:45 +03:00
/* fork-server.c */
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#define SERVER_PORTNO 55000
#define BUFFER_SIZE 1024
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void exit_sys(const char *msg);
void client_proc(int sock, const char *addr, int port);
void reverse_str(char *str);
int main(void)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
int server_sock, client_sock;
struct sockaddr_in sin_server, sin_client;
socklen_t addrlen;
pid_t pid;
char *addr;
int port;
struct sigaction act;
act.sa_handler = SIG_IGN;
act.sa_flags = SA_NOCLDWAIT;
if (sigaction(SIGCHLD, &act, NULL) == -1)
exit_sys("sigaction");
if ((server_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
exit_sys("socket");
sin_server.sin_family = AF_INET;
sin_server.sin_port = htons(SERVER_PORTNO);
sin_server.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(server_sock, (struct sockaddr *)&sin_server, sizeof(sin_server)) == -1)
exit_sys("bind");
if (listen(server_sock, 8) == -1)
exit_sys("listen");
printf("Waiting for client connection....\n");
for (;;) {
addrlen = sizeof(sin_client);
if ((client_sock = accept(server_sock, (struct sockaddr *)&sin_client, &addrlen)) == -1)
exit_sys("accept");
addr = inet_ntoa(sin_client.sin_addr);
port = ntohs(sin_client.sin_port);
printf("Connected: %s:%d\n", addr, port);
if ((pid = fork()) == -1)
exit_sys("fork");
if (pid == 0) {
client_proc(client_sock, addr, port);
exit(EXIT_SUCCESS);
}
}
shutdown(server_sock, SHUT_RDWR);
close(server_sock);
return 0;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
void client_proc(int sock, const char *addr, int port)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
int result;
char buf[BUFFER_SIZE];
for (;;) {
if ((result = recv(sock, buf, BUFFER_SIZE - 1, 0)) == -1)
goto FAILED;
if (result == 0)
break;
buf[result] = '\0';
if (!strcmp(buf, "exit"))
break;
printf("%d bytes received from %s:%d => \"%s\"\n", result, addr, port, buf);
reverse_str(buf);
if (send(sock, buf, strlen(buf), 0) == -1)
goto FAILED;
}
FAILED:
printf("Client %s:%d exits...\n", addr, port);
shutdown(sock, SHUT_RDWR);
close(sock);
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
void reverse_str(char *str)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
size_t len, i;
char temp;
for (len = 0; str[len] != '\0'; ++len)
;
for (i = 0; i < len / 2; ++i) {
temp = str[i];
str[i] = str[len - i - 1];
str[len - i - 1] = temp;
}
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
void exit_sys(const char *msg)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
perror(msg);
exit(EXIT_FAILURE);
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
/* client.c */
2024-04-29 13:28:55 +03:00
#include <stdio.h>
2024-06-09 22:42:45 +03:00
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#define SERVER_PORTNO 55000
#define CLIENT_PORTNO 62000
#define BUFFER_SIZE 1024
#define SERVER_NAME "127.0.0.1"
void exit_sys(const char *msg);
2024-04-29 13:28:55 +03:00
int main(void)
{
2024-06-09 22:42:45 +03:00
int client_sock;
struct sockaddr_in sin_server;
struct hostent *hostent;
char *str;
char buf[BUFFER_SIZE];
int result;
if ((client_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
exit_sys("socket");
/*
struct sockaddr_in sin_client;
sin_client.sin_family = AF_INET;
sin_client.sin_port = htons(CLIENT_PORTNO);
sin_client.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(client_sock, (struct sockaddr *)&sin_client, sizeof(sin_client)) == -1)
exit_sys("socket");
*/
sin_server.sin_family = AF_INET;
sin_server.sin_port = htons(SERVER_PORTNO);
sin_server.sin_addr.s_addr = inet_addr(SERVER_NAME);
if (sin_server.sin_addr.s_addr == INADDR_NONE) {
if ((hostent = gethostbyname(SERVER_NAME)) == NULL)
exit_sys("gethostbyname");
memcpy(&sin_server.sin_addr.s_addr, hostent->h_addr_list[0], hostent->h_length);
}
if (connect(client_sock, (struct sockaddr *)&sin_server, sizeof(sin_server)) == -1)
exit_sys("gethostbyname");
printf("Connected...\n");
for (;;) {
printf("Text:");
fgets(buf, BUFFER_SIZE, stdin);
if ((str = strchr(buf, '\n')) != NULL)
*str = '\0';
if (send(client_sock, buf, strlen(buf), 0) == -1)
exit_sys("send");
if (!strcmp(buf, "exit"))
break;
if ((result = recv(client_sock, buf, BUFFER_SIZE - 1, 0)) == -1)
exit_sys("recv");
if (result == 0)
break;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
buf[result] = '\0';
printf("%d bytes received: %s\n", result, buf);
}
shutdown(client_sock, SHUT_RDWR);
close(client_sock);
2024-04-29 13:28:55 +03:00
return 0;
}
2024-06-09 22:42:45 +03:00
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
2024-04-29 13:28:55 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
Şüphesiz TCP/IP uygulamaları ı ı ı ı ı
bizim programı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Aşağı ı ı ı ı ı ı ı ı ı ı
arka planda otomatik yapı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-06-09 22:42:45 +03:00
using System;
using System.Net.Sockets;
using System.Text;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
namespace CSD
{
class App
{
public const int SERVER_PORTNO = 55000;
public static void Main()
{
try
{
TcpClient tcpClient = new TcpClient("127.0.0.1", SERVER_PORTNO);
string text;
byte[] buf;
int result;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
for (; ; )
{
Console.Write("Text:");
text = Console.ReadLine();
if (text == "exit")
break;
buf = Encoding.UTF8.GetBytes(text);
tcpClient.Client.Send(buf);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
buf = new byte[1024];
result = tcpClient.Client.Receive(buf);
text = Encoding.UTF8.GetString(buf, 0, result);
Console.WriteLine(text);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Bir soketten garantili biçimde n byte okumak ve sokete garantili biçimde n byte yamakiçin aşağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int ReadSocket(SOCKET sock, char *buf, int size)
{
int left, count;
int result;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
left = size;
count = 0;
while (left > 0) {
if ((result = recv(sock, buf + count, left, 0)) == SOCKET_ERROR)
return SOCKET_ERROR;
if (result == 0)
break;
left -= result;
count += result;
}
return count;
}
int WriteSocket(SOCKET sock, const char *buf, int size)
{
int left, count;
int result;
left = size;
count = 0;
while (left > 0) {
if ((result = send(sock, buf + count, left, 0)) == SOCKET_ERROR)
return SOCKET_ERROR;
if (result == 0)
break;
left -= result;
count += result;
}
return count;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Garantili n byte okumak için UNIX/Linux sistemlerinde aşağdaki gibi bir fonksiyon yazı
tüm bilgi network tampouna yazı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
int read_socket(int sock, char *buf, int size)
{
int left, count;
int result;
left = size;
count = 0;
while (left > 0) {
if ((result = recv(sock, buf + count, left, 0)) == -1)
return -1;
if (result == 0)
break;
left -= result;
count += result;
}
return count;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Text tabanlı ı ı ı ı ı ı
ve gerekeni yapar. Ancak soketten bir satı ı ı
Onun yerine bir grup byte bir tampona yerleştirilip o tampondan '\n' ya da '\r\n' görünene kadar ilerlenir. Aşağı ı
benzeri bulunan soketten bir satı ı ı ı
Normal durumda satı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
int ReadLineSocket(SOCKET sock, char *buf, int size)
{
char *bufx = buf;
static char *bp;
static int count = 0;
static char b[2048];
char ch;
while (--size > 0) {
if (--count <= 0) {
count = recv(sock, b, sizeof(b), 0);
if (count == SOCKET_ERROR)
return SOCKET_ERROR;
if (count == 0)
return 0;
bp = b;
}
ch = *bp++;
*buf++ = ch;
if (ch == '\n') {
*buf = '\0';
return buf - bufx;
}
}
return SOCKET_ERROR;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukardaki fonksiyonun UNIX/Linux sistemlerindeki karşı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
int readline_socket(int sock, char *buf, int size)
{
char *bufx = buf;
static char *bp;
static int count = 0;
static char b[2048];
char ch;
while (--size > 0) {
if (--count <= 0) {
count = recv(sock, b, sizeof(b), 0);
if (count == -1)
return -1;
if (count == 0)
return 0;
bp = b;
}
ch = *bp++;
*buf++ = ch;
if (ch == '\n') {
*buf = '\0';
return buf - bufx;
}
}
return -1;
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Yazı ı ı
thread modeli, kullanı ı ı ı ı ı
- Client server'a fiziksel olarak bağlandı ı ı
LOGIN user_name password\n
Server kendisine kayı ı ı ı ı ı
LOGIN_ACCEPTED mesajı
LOGIN_ACCEPTED\n
Bundan sonra client server'a aşağı ı
ADD op1 ope\n
SUB op1 op2\n
MUL op1 op2\n
DIV op1 op2\n
Server'da bu hesaplamaları ı
RESULT result\n
Eğer client server'a uygun bir komnut göndermezse server client'a ERROR mesajı ı
ERROR mesaj\n
Client server'a gönderdiği her mesaj için server da client'a bir mesaj göndermektedir. İletişim yine el sı ı ı ı ı
client server'a LOGOUT komutunu gönderir. Server kabul ederse client'a LOGOUT_ACCEPTED mesajı ı ı
iletişimi sonlandı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* Server.c */
2024-04-29 13:28:55 +03:00
#include <stdio.h>
2024-06-09 22:42:45 +03:00
#include <stdlib.h>
#include <winsock2.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#define SERVER_PORTNO 55000
#define BUFFER_SIZE 2048
#define MAX_PARAMS 32
typedef struct tagCLIENT_REQUEST {
char buf[BUFFER_SIZE];
char *params[MAX_PARAMS + 1];
int nparams;
} CLIENT_REQUEST;
typedef struct tagCLIENT_INFO {
SOCKET sock;
char addr[16];
int port;
} CLIENT_INFO;
typedef struct tagUSER_INFO {
char *userName;
char *password;
} USER_INFO;
enum COMMANDS {
LOGIN_COMMAND,
ADD_COMMAND,
SUB_COMMAND,
MUL_COMMAND,
DIV_COMMAND,
LOGOUT_COMMAND,
};
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr);
DWORD __stdcall ClientThreadProc(LPVOID lpParam);
int ReadLineSocket(SOCKET sock, char *buf, int size);
int WriteSocket(SOCKET sock, const char *buf, int size);
void ParseCommand(char *buf, CLIENT_REQUEST *clientRequest);
BOOL ProcessCommand(const CLIENT_INFO *clientInfo, const CLIENT_REQUEST *clientRequest);
BOOL LoginCommandProc(const CLIENT_REQUEST *clientRequest, char *buf);
void OpCommandProc(const CLIENT_REQUEST *clientRequest, int commandCode, char *buf);
void LogoutCommandProc(const CLIENT_REQUEST *clientRequest, char *buf);
USER_INFO g_users[] = {
{"student", "12345"},
{"kaan", "xxxxx"},
{NULL, NULL}
};
int main(void)
{
WSADATA wsaData;
DWORD dwResult;
SOCKET serverSock, clientSock;
struct sockaddr_in sinServer, sinClient;
int addrLen;
HANDLE hThread;
DWORD dwThreadId;
CLIENT_INFO *clientInfo;
if ((dwResult = WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0)
ExitSys("WSAStartup", dwResult);
if ((serverSock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) /* third parameter IPPROTO_TCP */
ExitSys("socket", WSAGetLastError());
sinServer.sin_family = AF_INET;
sinServer.sin_port = htons(SERVER_PORTNO);
sinServer.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(serverSock, (struct sockaddr *)&sinServer, sizeof(sinServer)) == SOCKET_ERROR)
ExitSys("bind", WSAGetLastError());
if (listen(serverSock, 8) == SOCKET_ERROR)
ExitSys("listen", WSAGetLastError());
printf("Waiting for client connection....\n");
for (;;) {
addrLen = sizeof(sinClient);
if ((clientSock = accept(serverSock, (struct sockaddr *)&sinClient, &addrLen)) == INVALID_SOCKET)
ExitSys("accept", WSAGetLastError());
if ((clientInfo = (CLIENT_INFO *)malloc(sizeof(CLIENT_INFO))) == NULL) {
fprintf(stderr, "Cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
clientInfo->sock = clientSock;
strcpy(clientInfo->addr, inet_ntoa(sinClient.sin_addr));
clientInfo->port = ntohs(sinClient.sin_port);
printf("Connected client %s:%d\n", clientInfo->addr, clientInfo->port);
if ((hThread = CreateThread(NULL, 0, ClientThreadProc, clientInfo, 0, &dwThreadId)) == NULL)
ExitSys("CreateThread", WSAGetLastError());
CloseHandle(hThread);
}
closesocket(serverSock);
WSACleanup();
return 0;
}
DWORD __stdcall ClientThreadProc(LPVOID lpParam)
{
CLIENT_INFO *clientInfo = (CLIENT_INFO *)lpParam;
char buf[BUFFER_SIZE];
int result;
CLIENT_REQUEST clientRequest;
for (;;) {
if ((result = ReadLineSocket(clientInfo->sock, buf, BUFFER_SIZE)) == SOCKET_ERROR) {
fprintf(stderr, "Error: ReadLineSocket, ClientConnection is closing...\n");
break;
}
if (result == 0)
break;
printf("Client request: %s", buf);
ParseCommand(buf, &clientRequest);
if (!ProcessCommand(clientInfo, &clientRequest))
break;
}
shutdown(clientInfo->sock, SD_BOTH);
closesocket(clientInfo->sock);
free(clientInfo);
return 0;
}
int ReadLineSocket(SOCKET sock, char *buf, int size)
{
char *bufx = buf;
static char *bp;
static int count = 0;
static char b[2048];
char ch;
while (--size > 0) {
if (--count <= 0) {
count = recv(sock, b, sizeof(b), 0);
if (count == SOCKET_ERROR)
return SOCKET_ERROR;
if (count == 0)
return 0;
bp = b;
}
ch = *bp++;
*buf++ = ch;
if (ch == '\n') {
*buf = '\0';
return (int)(buf - bufx);
}
}
return SOCKET_ERROR;
}
int WriteSocket(SOCKET sock, const char *buf, int size)
{
int left, count;
int result;
left = size;
count = 0;
while (left > 0) {
if ((result = send(sock, buf + count, left, 0)) == SOCKET_ERROR)
return SOCKET_ERROR;
if (result == 0)
break;
left -= result;
count += result;
}
return count;
}
void ParseCommand(char *buf, CLIENT_REQUEST *clientRequest)
{
char *str;
int count;
strcpy(clientRequest->buf, buf);
for (count = 0, str = strtok(buf, " \t\n"); str != NULL && count < MAX_PARAMS; str = strtok(NULL, " \t\n"), ++count)
clientRequest->params[count] = str;
clientRequest->nparams = count;
}
BOOL ProcessCommand(const CLIENT_INFO *clientInfo, const CLIENT_REQUEST *clientRequest)
{
static char *clientRequests[] = { "LOGIN", "ADD", "SUB", "MUL", "DIV", "LOGOUT", NULL};
int i;
int result;
char buf[BUFFER_SIZE];
BOOL retVal = TRUE;
if (clientRequest->nparams == 0) {
sprintf(buf, "ERROR Empty command\n", clientRequest->params[0]);
if ((result = WriteSocket(clientInfo->sock, buf, (int)strlen(buf))) == SOCKET_ERROR)
fprintf(stderr, "Error: WriteSocket\n");
return retVal;
}
for (i = 0; clientRequests[i] != NULL; ++i)
if (!strcmp(clientRequests[i], clientRequest->params[0]))
break;
if (clientRequests[i] == NULL) {
sprintf(buf, "ERROR Command not found \"%s\"\n", clientRequest->params[0]);
if ((result = WriteSocket(clientInfo->sock, buf, (int)strlen(buf))) == SOCKET_ERROR)
fprintf(stderr, "Error: WriteSocket\n");
return retVal;
}
switch (i) {
case LOGIN_COMMAND:
if (!LoginCommandProc(clientRequest, buf)) {
retVal = FALSE;
break;
}
break;
case ADD_COMMAND:
OpCommandProc(clientRequest, ADD_COMMAND, buf);
break;
case SUB_COMMAND:
OpCommandProc(clientRequest, SUB_COMMAND, buf);
break;
case MUL_COMMAND:
OpCommandProc(clientRequest, MUL_COMMAND, buf);
break;
case DIV_COMMAND:
OpCommandProc(clientRequest, DIV_COMMAND, buf);
break;
case LOGOUT_COMMAND:
LogoutCommandProc(clientRequest, buf);
retVal = FALSE;
break;
}
if ((result = WriteSocket(clientInfo->sock, buf, (int)strlen(buf))) == SOCKET_ERROR) {
fprintf(stderr, "Error: WriteSocket\n");
retVal = FALSE;
}
return retVal;
}
void OpCommandProc(const CLIENT_REQUEST *clientRequest, int commandCode, char *buf)
{
double op1, op2, opResult;
if (clientRequest->nparams == 3)
if (sscanf(clientRequest->params[1], "%lf", &op1) == 1)
if (sscanf(clientRequest->params[2], "%lf", &op2) == 1) {
switch (commandCode) {
case ADD_COMMAND:
opResult = op1 + op2;
break;
case SUB_COMMAND:
opResult = op1 - op2;
break;
case MUL_COMMAND:
opResult = op1 * op2;
break;
case DIV_COMMAND:
opResult = op1 / op2;
break;
}
sprintf(buf, "RESULT %f\n", opResult);
}
else
sprintf(buf, "ERROR Invalid command operand\n");
else
sprintf(buf, "ERROR Invalid command operand\n");
else
sprintf(buf, "ERROR Invalid command operand\n");
}
BOOL LoginCommandProc(const CLIENT_REQUEST *clientRequest, char *buf)
{
int i;
for (i = 0; g_users[i].userName != NULL; ++i) {
if (!strcmp(g_users[i].userName, clientRequest->params[1]) && !strcmp(g_users[i].password, clientRequest->params[2])) {
sprintf(buf, "LOGIN_ACCEPTED\n");
return TRUE;
}
}
sprintf(buf, "ERROR Invalid user name or password\n");
return FALSE;
}
void LogoutCommandProc(const CLIENT_REQUEST *clientRequest, char *buf)
{
if (clientRequest->nparams == 1)
sprintf(buf, "LOGOUT_ACCEPTED Logout Accepted\n");
else
sprintf(buf, "ERROR Invalid command operand\n");
}
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr)
{
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/* Client.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>
#define SERVER_PORTNO 55000
#define CLIENT_PORTNO 62000
#define SERVER_NAME "185.86.155.34"
#define BUFFER_SIZE 2048
#define MAX_USER_NAME 32
#define MAX_PASSWORD 32
typedef struct tagSERVER_RESPONSE {
char *command;
char *text;
} SERVER_RESPONSE;
enum COMMANDS {
LOGIN_ACCEPTED_COMMAND,
RESULT_COMMAND,
ERROR_COMMAND,
LOGOUT_ACCEPTED_COMMAND,
};
int ReadLineSocket(SOCKET sock, char *buf, int size);
int WriteSocket(SOCKET sock, const char *buf, int size);
BOOL LoginProc(SOCKET clientSock, char *buf, SERVER_RESPONSE *serverResponse);
void ParseCommand(char *buf, SERVER_RESPONSE *serverResponse);
BOOL ProcessCommand(const SERVER_RESPONSE *serverResponse);
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr);
int main(void)
{
WSADATA wsaData;
DWORD dwResult;
SOCKET clientSock;
struct sockaddr_in sinServer;
struct hostent *hostEnt;
char buf[BUFFER_SIZE];
int result;
SERVER_RESPONSE serverResponse;
if ((dwResult = WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0)
ExitSys("WSAStartup", dwResult);
if ((clientSock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
ExitSys("socket", WSAGetLastError());
/*
{
struct sockaddr_in sinClient;
sinClient.sin_family = AF_INET;
sinClient.sin_port = htons(CLIENT_PORTNO);
sinClient.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(clientSock, (struct sockaddr *)&sinClient, sizeof(sinClient)) == SOCKET_ERROR)
ExitSys("bind", WSAGetLastError());
}
*/
sinServer.sin_family = AF_INET;
sinServer.sin_port = htons(SERVER_PORTNO);
sinServer.sin_addr.s_addr = inet_addr(SERVER_NAME);
if (sinServer.sin_addr.s_addr == INADDR_NONE) {
if ((hostEnt = gethostbyname(SERVER_NAME)) == NULL)
ExitSys("gethostbyname", WSAGetLastError());
memcpy(&sinServer.sin_addr.s_addr, hostEnt->h_addr_list[0], hostEnt->h_length);
}
if (connect(clientSock, (struct sockaddr *)&sinServer, sizeof(sinServer)) == SOCKET_ERROR)
ExitSys("connect", WSAGetLastError());
printf("Connected...\n");
if (!LoginProc(clientSock, buf, &serverResponse))
goto FAILED;
printf("Client connected...\n");
for (;;) {
printf("Calculator>");
fflush(stdout);
fgets(buf, BUFFER_SIZE, stdin);
if ((result = WriteSocket(clientSock, buf, (int)strlen(buf))) == SOCKET_ERROR)
ExitSys("WriteSocket", WSAGetLastError());
if (result == 0)
break;
if ((result = ReadLineSocket(clientSock, buf, BUFFER_SIZE)) == SOCKET_ERROR)
ExitSys("ReadLineSocket", WSAGetLastError());
if (result == 0)
break;
ParseCommand(buf, &serverResponse);
if (!ProcessCommand(&serverResponse))
break;
}
FAILED:
shutdown(clientSock, SD_BOTH);
closesocket(clientSock);
WSACleanup();
return 0;
}
int ReadLineSocket(SOCKET sock, char *buf, int size)
{
char *bufx = buf;
static char *bp;
static int count = 0;
static char b[2048];
char ch;
while (--size > 0) {
if (--count <= 0) {
count = recv(sock, b, sizeof(b), 0);
if (count == SOCKET_ERROR)
return SOCKET_ERROR;
if (count == 0)
return 0;
bp = b;
}
ch = *bp++;
*buf++ = ch;
if (ch == '\n') {
*buf = '\0';
return (int) (buf - bufx);
}
}
return SOCKET_ERROR;
}
int WriteSocket(SOCKET sock, const char *buf, int size)
{
int left, count;
int result;
left = size;
count = 0;
while (left > 0) {
if ((result = send(sock, buf + count, left, 0)) == SOCKET_ERROR)
return SOCKET_ERROR;
if (result == 0)
break;
left -= result;
count += result;
}
return count;
}
BOOL LoginProc(SOCKET clientSock, char *buf, SERVER_RESPONSE *serverResponse)
{
char userName[MAX_USER_NAME];
char password[MAX_PASSWORD];
int result;
char *str;
printf("User name:");
fgets(userName, MAX_USER_NAME, stdin);
if ((str = strchr(userName, '\n')) != NULL)
*str = '\0';
printf("Password:");
fgets(password, MAX_PASSWORD, stdin);
if ((str = strchr(password, '\n')) != NULL)
*str = '\0';
sprintf(buf, "LOGIN %s %s\n", userName, password);
if ((result = WriteSocket(clientSock, buf, (int)strlen(buf))) == SOCKET_ERROR || result == 0) {
fprintf(stderr, "Error WriteSocket!..\n");
return FALSE;
}
/* buffer problem */
if ((result = ReadLineSocket(clientSock, buf, BUFFER_SIZE)) == SOCKET_ERROR || result == 0) {
fprintf(stderr, "Error ReadLineSocket!..\n");
return FALSE;
}
ParseCommand(buf, serverResponse);
if (strcmp(serverResponse->command, "LOGIN_ACCEPTED") != 0) {
printf("%s\n", serverResponse->text);
return FALSE;
}
return TRUE;
}
void ParseCommand(char *buf, SERVER_RESPONSE *serverResponse)
{
char *str = buf;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
str = buf;
serverResponse->command = str;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
while (*buf != ' ' && *buf != '\n')
++buf;
if (*buf == '\n') {
*buf = '\0';
serverResponse->text = NULL;
return;
}
*buf++ = '\0';
str = buf;
while (*buf != '\n')
++buf;
*buf = '\0';
serverResponse->text = str;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
BOOL ProcessCommand(const SERVER_RESPONSE *serverResponse)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
static char *serverCommands[] = { "LOGIN_ACCEPTED", "RESULT", "ERROR", "LOGOUT_ACCEPTED", NULL};
int i;
BOOL retVal = TRUE;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
for (i = 0; serverCommands[i] != NULL; ++i)
if (!strcmp(serverCommands[i], serverResponse->command))
break;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
switch (i) {
case RESULT_COMMAND:
case ERROR_COMMAND:
printf("%s\n", serverResponse->text);
break;
case LOGOUT_ACCEPTED_COMMAND:
printf("%s\n", serverResponse->text);
retVal = FALSE;
break;
default:
printf("Unknown server command: %s\n", serverResponse->text);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return retVal;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
LPTSTR lpszErr;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
2024-04-29 13:28:55 +03:00
}
/*------------------------------------------------------------------------------------------------------------------------------------------
2024-06-09 22:42:45 +03:00
Aslı ı ı ı ı ı
haberleşme yapmaktadı ı ı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
USER user_name\r\n
PASS password\r\n
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Sonra client server'daki posta kutusundaki postalar hakkı ı ı ı
RETR komutuyla indeks numarası ı ı ı
server'a DELE komutunu gönderir. Tüm komutlar yazı
yanı ı ı ı ı ı ı
dokümanı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Aşağı ı ı ı ı ı ı ı ı ı
denilen hazı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-06-09 22:42:45 +03:00
/* pop3.c */
2024-04-29 13:28:55 +03:00
#include <stdio.h>
2024-06-09 22:42:45 +03:00
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#define SERVER_PORTNO 110
#define BUFFER_SIZE 2048
#define SERVER_NAME "mail.csystem.org"
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int ReadLineSocket(SOCKET sock, char *buf, int size);
int WriteSocket(SOCKET sock, const char *buf, int size);
DWORD __stdcall Pop3ReadThreadProc(LPVOID lpvParam);
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr);
2024-04-29 13:28:55 +03:00
int main(void)
{
2024-06-09 22:42:45 +03:00
WSADATA wsaData;
DWORD dwResult;
SOCKET clientSock;
struct sockaddr_in sinServer;
struct hostent *hostEnt;
char buf[BUFFER_SIZE + 1];
int result;
char *str;
HANDLE hThread;
DWORD dwThreadId;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((dwResult = WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0)
ExitSys("WSAStartup", dwResult);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((clientSock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
ExitSys("socket", WSAGetLastError());
/*
{
struct sockaddr_in sinClient;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
sinClient.sin_family = AF_INET;
sinClient.sin_port = htons(CLIENT_PORTNO);
sinClient.sin_addr.s_addr = htonl(INADDR_ANY);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (bind(clientSock, (struct sockaddr *)&sinClient, sizeof(sinClient)) == SOCKET_ERROR)
ExitSys("bind", WSAGetLastError());
}
*/
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
sinServer.sin_family = AF_INET;
sinServer.sin_port = htons(SERVER_PORTNO);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
sinServer.sin_addr.s_addr = inet_addr(SERVER_NAME);
if (sinServer.sin_addr.s_addr == INADDR_NONE) {
if ((hostEnt = gethostbyname(SERVER_NAME)) == NULL)
ExitSys("gethostbyname", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
memcpy(&sinServer.sin_addr.s_addr, hostEnt->h_addr_list[0], hostEnt->h_length);
}
if (connect(clientSock, (struct sockaddr *)&sinServer, sizeof(sinServer)) == SOCKET_ERROR)
ExitSys("connect", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((hThread = CreateThread(NULL, 0, Pop3ReadThreadProc, (LPVOID)clientSock, 0, &dwThreadId)) == NULL)
ExitSys("CreateThread", GetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
for (;;) {
Sleep(500);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
printf("POP3>");
fflush(stdout);
fgets(buf, BUFFER_SIZE, stdin);
if ((str = strchr(buf, '\n')) != NULL)
*str = '\0';
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
strcat(buf, "\r\n");
if ((result = WriteSocket(clientSock, buf, (int)strlen(buf))) == SOCKET_ERROR)
ExitSys("WriteSocket", WSAGetLastError());
if (result == 0) {
printf("Other side closed connection...\n");
break;
}
if (!strcmp(buf, "QUIT\r\n"))
break;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
}
shutdown(clientSock, SD_BOTH);
closesocket(clientSock);
CloseHandle(hThread);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
WSACleanup();
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return 0;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
int ReadLineSocket(SOCKET sock, char *buf, int size)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
char *bufx = buf;
static char *bp;
static int count = 0;
static char b[2048];
char ch;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
while (--size > 0) {
if (--count <= 0) {
count = recv(sock, b, sizeof(b), 0);
if (count == SOCKET_ERROR)
return SOCKET_ERROR;
if (count == 0)
return 0;
bp = b;
}
ch = *bp++;
*buf++ = ch;
if (ch == '\n') {
buf[-2] = '\0';
return (int)(buf - bufx);
}
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return SOCKET_ERROR;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int WriteSocket(SOCKET sock, const char *buf, int size)
{
int left, count;
int result;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
left = size;
count = 0;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
while (left > 0) {
if ((result = send(sock, buf + count, left, 0)) == SOCKET_ERROR)
return SOCKET_ERROR;
if (result == 0)
break;
left -= result;
count += result;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return count;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
DWORD __stdcall Pop3ReadThreadProc(LPVOID lpvParam)
{
char buf[BUFFER_SIZE + 1];
int result;
SOCKET sock = (SOCKET)lpvParam;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
for (;;) {
if ((result = recv(sock, buf, BUFFER_SIZE, 0)) == SOCKET_ERROR)
ExitSys("recv", WSAGetLastError());
buf[result] = '\0';
printf("%s", buf);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return 0;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr)
{
LPTSTR lpszErr;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
exit(EXIT_FAILURE);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
UDP bağlantı ı ı ı ı ı
Bilgileri paket halinde gönderir. Hiç bağlantı ı ı ı
Sonra da döngü içerisinde recvfrom fonksiyonu ile datagram paketlerini okur. Clieng taraf bilgi alı ı
soketi yaratı
server rolleri bu protokolde çok belli değildir. Bir server'a hiç bağlantı
datagram paketini alı ı
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
Aşağı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-06-09 22:42:45 +03:00
/* Server.c */
2024-04-29 13:28:55 +03:00
#include <stdio.h>
#include <stdlib.h>
2024-06-09 22:42:45 +03:00
#include <winsock2.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#define SERVER_PORTNO 55000
#define BUFFER_SIZE 1024
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr);
2024-04-29 13:28:55 +03:00
int main(void)
{
2024-06-09 22:42:45 +03:00
WSADATA wsaData;
DWORD dwResult;
SOCKET serverSock;
struct sockaddr_in sinServer, sinClient;
int addrLen;
char buf[BUFFER_SIZE + 1];
int result;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((dwResult = WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0)
ExitSys("WSAStartup", dwResult);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((serverSock = socket(AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET) /* third parameter IPPROTO_UDP */
ExitSys("socket", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
sinServer.sin_family = AF_INET;
sinServer.sin_port = htons(SERVER_PORTNO);
sinServer.sin_addr.s_addr = htonl(INADDR_ANY);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (bind(serverSock, (struct sockaddr*)&sinServer, sizeof(sinServer)) == SOCKET_ERROR)
ExitSys("bind", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
printf("Waiting for messages...\n");
for (;;) {
addrLen = sizeof(sinClient);
if ((result = recvfrom(serverSock, buf, BUFFER_SIZE, 0, (struct sockaddr*)&sinClient, &addrLen)) == SOCKET_ERROR)
ExitSys("recvfrom", GetLastError());
buf[result] = '\0';
printf("%d bytes received from %s:%d \"%s\"\n", result, inet_ntoa(sinClient.sin_addr), ntohs(sinClient.sin_port), buf);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
closesocket(serverSock);
WSACleanup();
2024-04-29 13:28:55 +03:00
return 0;
}
2024-06-09 22:42:45 +03:00
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr)
2024-04-29 13:28:55 +03:00
{
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
2024-06-09 22:42:45 +03:00
/* Client.c */
2024-04-29 13:28:55 +03:00
#include <stdio.h>
2024-06-09 22:42:45 +03:00
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#define SERVER_PORTNO 55000
#define BUFFER_SIZE 1024
#define SERVER_NAME "127.0.0.1"
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int main(void)
2024-04-29 13:28:55 +03:00
{
2024-06-09 22:42:45 +03:00
WSADATA wsaData;
DWORD dwResult;
SOCKET clientSock;
struct sockaddr_in sinServer;
struct hostent *hostEnt;
char buf[BUFFER_SIZE];
char *str;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((dwResult = WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0)
ExitSys("WSAStartup", dwResult);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((clientSock = socket(AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET)
ExitSys("socket", WSAGetLastError());
sinServer.sin_family = AF_INET;
sinServer.sin_port = htons(SERVER_PORTNO);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
sinServer.sin_addr.s_addr = inet_addr(SERVER_NAME);
if (sinServer.sin_addr.s_addr == INADDR_NONE) {
if ((hostEnt = gethostbyname(SERVER_NAME)) == NULL)
ExitSys("gethostbyname", WSAGetLastError());
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
memcpy(&sinServer.sin_addr.s_addr, hostEnt->h_addr_list[0], hostEnt->h_length);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
for (;;) {
printf("Text:");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
fgets(buf, BUFFER_SIZE, stdin);
if ((str = strchr(buf, '\n')) != NULL)
*str = '\0';
if (!strcmp(buf, "exit"))
break;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (sendto(clientSock, buf, (int)strlen(buf), 0, (struct sockaddr *) &sinServer, sizeof(sinServer)) == SOCKET_ERROR)
ExitSys("send", WSAGetLastError());
}
closesocket(clientSock);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
WSACleanup();
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return 0;
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void ExitSys(LPCSTR lpszMsg, DWORD dwLastErr)
{
LPTSTR lpszErr;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
exit(EXIT_FAILURE);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı
2024-04-29 13:28:55 +03:00
-------------------------------------------------------------------------------------------------------------------------------------------*/
2024-06-09 22:42:45 +03:00
/* udp-server.c */
2024-04-29 13:28:55 +03:00
#include <stdio.h>
#include <stdlib.h>
2024-06-09 22:42:45 +03:00
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
#define SERVER_PORTNO 55000
#define BUFFER_SIZE 1024
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
void exit_sys(const char *msg);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
int main(void)
{
int server_sock;
struct sockaddr_in sin_server, sin_client;
socklen_t addrlen;
char buf[BUFFER_SIZE + 1];
int result;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((server_sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
exit_sys("socket");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
sin_server.sin_family = AF_INET;
sin_server.sin_port = htons(SERVER_PORTNO);
sin_server.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(server_sock, (struct sockaddr *)&sin_server, sizeof(sin_server)) == -1)
exit_sys("bind");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
printf("Waiting for messages...\n");
for (;;) {
addrlen = sizeof(sin_server);
if ((result = recvfrom(server_sock, buf, BUFFER_SIZE, 0, (struct sockaddr*)&sin_client, &addrlen)) == -1)
exit_sys("recvfrom");
buf[result] = '\0';
printf("%d bytes received from %s:%d \"%s\"\n", result, inet_ntoa(sin_client.sin_addr), ntohs(sin_client.sin_port), buf);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
close(server_sock);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return 0;
2024-04-29 13:28:55 +03:00
}
2024-06-09 22:42:45 +03:00
void exit_sys(const char *msg)
{
perror(msg);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
exit(EXIT_FAILURE);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
/* udp-client.c */
2024-04-29 13:28:55 +03:00
#include <stdio.h>
#include <stdlib.h>
2024-06-09 22:42:45 +03:00
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#define SERVER_PORTNO 55000
#define BUFFER_SIZE 1024
#define SERVER_NAME "127.0.0.1"
void exit_sys(const char *msg);
2024-04-29 13:28:55 +03:00
int main(void)
{
2024-06-09 22:42:45 +03:00
int client_sock;
struct sockaddr_in sin_server;
struct hostent *hoste;
char buf[BUFFER_SIZE];
char *str;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if ((client_sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
exit_sys("socket");
sin_server.sin_family = AF_INET;
sin_server.sin_port = htons(SERVER_PORTNO);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
sin_server.sin_addr.s_addr = inet_addr(SERVER_NAME);
if (sin_server.sin_addr.s_addr == INADDR_NONE) {
if ((hoste = gethostbyname(SERVER_NAME)) == NULL)
exit_sys("gethostbyname");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
memcpy(&sin_server.sin_addr.s_addr, hoste->h_addr_list[0], hoste->h_length);
}
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
for (;;) {
printf("Text:");
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
fgets(buf, BUFFER_SIZE, stdin);
if ((str = strchr(buf, '\n')) != NULL)
*str = '\0';
if (!strcmp(buf, "exit"))
break;
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
if (sendto(client_sock, buf, (int)strlen(buf), 0, (struct sockaddr *) &sin_server, sizeof(sin_server)) == -1)
exit_sys("sendto");
}
close(client_sock);
2024-04-29 13:28:55 +03:00
2024-06-09 22:42:45 +03:00
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
2024-04-29 13:28:55 +03:00
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Eskiden diskler elektromekanik bir birim olarak üretiliyordu. Bunlara "hard disk" denilmektedir. Ancak artı
harddisk kullanı ı ı ı ı ı ı ı
İster hard disk olsun isterse SSD disk olsun bir diskten okunabilen ya da yazı
1 byte okumak istersek aslı ı ı ı
onun bulunduğu sektörü okuruz. Değişikliği ana bellek üzerinde yaparı ı ı
Diskteki sektörleri görüntülemek ve güncellemek için kullanı
çeşitli disk editörleri bulunmaktadı ı ı ı
yapan od gibi hd gibi programlar kullanı ı ı
Donanı ı ı ı ı ı
artan sı ı ı ı ı ı ı ı
onları ı ı ı ı
bu aygı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Windows'ta diski bir bütün olarak ele alan aygı
biçiminde artan sı ı ı ı
denilmektedir. Disk bölümleri aslı ı ı ı ı
davranabilmektedir. Bu biçimde disk bölümünü sanaki ayrı ı ı ı
harfini belirtmektedir.
Aşağı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* DiskIO.h */
/* DiskIO.h */
#ifndef DISKIO_H_
#define DISKIO_H_
#include <Windows.h>
/* Symbolic Constants */
#define BYTES_PER_SECTOR 512
/* Function Prototypes */
HANDLE OpenDisk(int disk, DWORD dwDesiredAccess);
HANDLE OpenVolume(int drive, DWORD dwDesiredAccess);
BOOL ReadSector(HANDLE hDrive, long long sector, DWORD count, void *buf);
BOOL WriteSector(HANDLE hDrive, long long sector, DWORD count, const void *buf);
#endif
/* DiskIO.c */
#include <stdio.h>
#include <Windows.h>
#include "DiskIO.h"
/* static Function Prototypes */
static BOOL SetFilePosition(HANDLE hDrive, long long distance, DWORD MoveMethod);
/* Function definitions */
HANDLE OpenDisk(int disk, DWORD dwDesiredAccess)
{
char driverName[32];
DWORD shareMode = 0;
sprintf(driverName, "\\\\.\\PhysicalDrive%d", disk);
if (dwDesiredAccess & GENERIC_READ)
shareMode |= FILE_SHARE_READ;
if (dwDesiredAccess & GENERIC_WRITE)
shareMode |= FILE_SHARE_WRITE;
return CreateFile(driverName, dwDesiredAccess, shareMode, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
}
HANDLE OpenVolume(int drive, DWORD dwDesiredAccess)
{
char driverName[32];
DWORD shareMode = 0;
sprintf(driverName, "\\\\.\\%c:", drive + 'A');
if (dwDesiredAccess & GENERIC_READ)
shareMode |= FILE_SHARE_READ;
if (dwDesiredAccess & GENERIC_WRITE)
shareMode |= FILE_SHARE_WRITE;
return CreateFile(driverName, dwDesiredAccess, shareMode, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
}
BOOL ReadSector(HANDLE hDrive, long long sector, DWORD count, void *buf)
{
long long location = (long long)sector * BYTES_PER_SECTOR;
DWORD dwBytes = count * BYTES_PER_SECTOR;
DWORD dwRead;
if (!SetFilePosition(hDrive, location, FILE_BEGIN))
return FALSE;
if (!ReadFile(hDrive, buf, dwBytes, &dwRead, NULL))
return FALSE;
return TRUE;
}
BOOL WriteSector(HANDLE hDrive, __int64 sector, DWORD count, void *buf)
{
long long location = (long long)sector * BYTES_PER_SECTOR;
DWORD dwBytes = count * BYTES_PER_SECTOR;
DWORD dwRead, status;
if (!SetFilePosition(hDrive, location, FILE_BEGIN))
return FALSE;
if (!DeviceIoControl(hDrive, FSCTL_DISMOUNT_VOLUME, NULL, 0, NULL, 0, &status, NULL))
return FALSE;
if (!WriteFile(hDrive, buf, dwBytes, &dwRead, NULL))
return FALSE;
return TRUE;
}
static BOOL SetFilePosition(HANDLE hDrive, __int64 distance, DWORD MoveMethod)
{
LARGE_INTEGER li;
li.QuadPart = distance;
li.LowPart = SetFilePointer(hDrive, li.LowPart, &li.HighPart, MoveMethod);
if (li.LowPart == 0xFFFFFFFF && GetLastError() != NO_ERROR)
return FALSE;
return TRUE;
}
/* Test.c */
#include <stdio.h>
#include <windows.h>
#include "DiskIO.h"
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hDisk;
HANDLE hVolume;
unsigned char buf[BYTES_PER_SECTOR];
int i;
if ((hDisk = OpenDisk(1, GENERIC_READ)) == INVALID_HANDLE_VALUE)
ExitSys("OpenDisk");
if (!ReadSector(hDisk, 409966399, 1, buf))
ExitSys("ReadSector");
for (i = 0; i < 512; ++i)
printf("%02X%c", buf[i], i % 16 == 15 ? '\n' : ' ');
CloseHandle(hDisk);
printf("-------------------------------------------------------\n");
if ((hVolume = OpenVolume('H' - 'A', GENERIC_READ)) == INVALID_HANDLE_VALUE)
ExitSys("OpenDisk");
if (!ReadSector(hVolume, 0, 1, buf))
ExitSys("ReadSector");
for (i = 0; i < 512; ++i)
printf("%02X%c", buf[i], i % 16 == 15 ? '\n' : ' ');
CloseHandle(hVolume);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Linux sistemlerinde yine disk sektörlerini okumak ve yazmak için aygı ı
temsil etmektedir. Bu diskteki disk bölümler /dev/sda1, /dev/sda2 vs. biçimindedir. Diskin bölüm yapı ı ı
komutunu kullanabilirsiniz. Yine bu aygı ı ı ı ı ı ı
işlemlerine sokulabilmektedir.
Aşağı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* diskio.h */
#ifndef DISKIO_H_
#define DISKIO_H_
/* Symbolic Constants */
#define BYTES_PER_SECTOR 512
/* Function Prototypes */
int read_sector(int fd, size_t sector, size_t count, void *buf);
int write_sector(int fd, size_t sector, size_t count, const void *buf);
#endif
/* diskio.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "diskio.h"
int read_sector(int fd, size_t sector, size_t count, void *buf)
{
if (lseek(fd, sector * BYTES_PER_SECTOR, SEEK_SET) == -1)
return -1;
if (read(fd, buf, BYTES_PER_SECTOR * count) != BYTES_PER_SECTOR * count)
return -1;
return 0;
}
int write_sector(int fd, size_t sector, size_t count, const void *buf)
{
if (lseek(fd, sector * BYTES_PER_SECTOR, SEEK_SET) == -1)
return -1;
if (write(fd, buf, BYTES_PER_SECTOR * count) != BYTES_PER_SECTOR * count)
return -1;
return 0;
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include "diskio.h"
void exit_sys(const char *msg);
int main(void)
{
int fd;
unsigned char buf[BYTES_PER_SECTOR];
int i;
if ((fd = open("/dev/sda", O_RDONLY)) == -1)
exit_sys("open");
if (read_sector(fd, 24065464, 1, buf) == -1)
exit_sys("read_sector");
for (i = 0; i < BYTES_PER_SECTOR; ++i)
printf("%02X%c", buf[i], i % 16 == 15 ? '\n' : ' ');
close(fd);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
FAT12 ve FAT16 sistemlerinde boot sektör içerisindeki BPB (Bios Parameter Block) bilgilerini boot sektörden okuyarak onu bir yapı
GetBPB isimli bir fonksiyon aşağı ı ı ı ı ı ı ı ı
Yanı ı
hangi sektörden başladı ı
artı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* FatSys.h */
#ifndef FATSYS_H_
#define FATSYS_H_
#include <Windows.h>
/* Symbolic contants */
#define FILE_INFO_LENGTH 32
/* Type Declaration */
typedef struct tagBPB {
HANDLE hVolume; /* volume */
WORD fatLen; /* number of sectors of FAT (A) */
WORD rootLen; /* number of sectors of ROOT */
WORD fatCopyNum; /* number of copies of FAT (A) */
DWORD totalSec; /* total sector (A) */
WORD bps; /* byte per sector(A) */
WORD spc; /* sector per cluster(A) */
WORD reservedSect; /* reserved sector(A) */
BYTE medDes; /* media descriptor byte(A) */
WORD spt; /* sector per track(A) */
WORD rootEntryNum; /* root entry(A) */
WORD headNum; /* number of heads(A) */
WORD hidNum; /* number of hidden sector(A)*/
WORD tph; /* track per head */
WORD fatOrigin; /* fat directory location */
WORD rootOrigin; /* root directory location */
WORD dataOrigin; /* first data sector location */
DWORD serialNumber; /* Volume Serial Number (A) */
BYTE volumeName[12]; /* Volume Name (A) */
} BPB;
/* Function Prototypes */
BOOL GetBPB(HANDLE hVolume, BPB *pBPB);
#endif
/* FatSys.c */
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#include "DiskIo.h"
#include "FatSys.h"
BOOL GetBPB(HANDLE hVolume, BPB *pBPB)
{
BYTE bootSect[BYTES_PER_SECTOR];
if (!ReadSector(hVolume, 0, 1, bootSect))
return FALSE;
pBPB->hVolume = hVolume;
pBPB->bps = *(WORD *)(bootSect + 0x0B);
pBPB->spc = *(BYTE *)(bootSect + 0x0D);
pBPB->reservedSect = *(WORD *)(bootSect + 0x0E);
pBPB->fatLen = *(WORD *)(bootSect + 0x16);
pBPB->rootLen = *(WORD *)(bootSect + 0x11) * FILE_INFO_LENGTH / pBPB->bps;
pBPB->fatCopyNum = *(BYTE *)(bootSect + 0x10);
if (*(WORD *)(bootSect + 0x13))
pBPB->totalSec = *(WORD *)(bootSect + 0x13);
else
pBPB->totalSec = *(DWORD *)(bootSect + 0x20);
pBPB->medDes = *(bootSect + 0x15);
pBPB->spt = *(WORD *)(bootSect + 0x18);
pBPB->rootEntryNum = *(WORD *)(bootSect + 0x11);
pBPB->headNum = *(WORD *)(bootSect + 0x1A);
pBPB->hidNum = *(WORD *)(bootSect + 0x1C);
pBPB->tph = (WORD)(pBPB->totalSec / pBPB->spt / pBPB->headNum);
pBPB->fatOrigin = pBPB->reservedSect;
pBPB->rootOrigin = pBPB->reservedSect + pBPB->fatLen * pBPB->fatCopyNum;
pBPB->dataOrigin = pBPB->rootOrigin + pBPB->rootLen;
pBPB->serialNumber = *(DWORD *)(bootSect + 0x27);
memcpy(pBPB->volumeName, bootSect + 0x2B, 11);
pBPB->volumeName[11] = '\0';
return TRUE;
}
/* Test.c */
#include <stdio.h>
#include <windows.h>
#include "DiskIO.h"
#include "FatSys.h"
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hVolume;
BPB bpb;
if ((hVolume = OpenVolume('H' - 'A', GENERIC_READ)) == INVALID_HANDLE_VALUE)
ExitSys("OpenDisk");
if (!GetBPB(hVolume, &bpb))
ExitSys("GetBPB");
printf("Success...\n");
printf("Fat'in başlangı ı
printf("Fat'in sektör uzunluğu: %u\n", bpb.fatLen);
printf("Root Dir bölümünün başlangı ı
printf("Root Dir bölümünün sektör uzunluğu: %u\n", bpb.rootLen);
printf("Data bölümünün başlangı ı
printf("Volümdeki toplam sektör sayı ı
printf("Bir cluster'ı
CloseHandle(hVolume);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Boot Sektör BPB bilgileri okunduktan sonra artı ı ı ı ı
okunacak cluster numarası ı ı ı
O halde ReadClutser ve WriteCluster fonksiyonları ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
BOOL ReadCluster(const BPB *pBPB, WORD clu, void *pData)
{
return ReadSector(pBPB->hVolume, pBPB->dataOrigin + (clu - 2) * pBPB->spc, pBPB->spc, pData);
}
BOOL WriteCluster(const BPB *pBPB, WORD clu, const void *pData)
{
return WriteSector(pBPB->hVolume, pBPB->dataOrigin + (clu - 2) * pBPB->spc, pBPB->spc, pData);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Yukarı ı ı ı ı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* fatsys.h */
#ifndef FATSYS_H_
#define FATSYS_H_
#include <stdint.h>
#include <stdbool.h>
/* Symbolic contants */
#define FILE_INFO_LENGTH 32
/* Type Declaration */
typedef struct tagBPB {
int volume; /* volume */
uint16_t fatLen; /* number of sectors of FAT (A) */
uint16_t rootLen; /* number of sectors of ROOT */
uint16_t fatCopyNum; /* number of copies of FAT (A) */
uint32_t totalSec; /* total sector (A) */
uint16_t bps; /* byte per sector(A) */
uint16_t spc; /* sector per cluster(A) */
uint16_t reservedSect; /* reserved sector(A) */
uint8_t medDes; /* media descriptor byte(A) */
uint16_t spt; /* sector per track(A) */
uint16_t rootEntryNum; /* root entry(A) */
uint16_t headNum; /* number of heads(A) */
uint16_t hidNum; /* number of hidden sector(A)*/
uint16_t tph; /* track per head */
uint16_t fatOrigin; /* fat directory location */
uint16_t rootOrigin; /* root directory location */
uint16_t dataOrigin; /* first data sector location */
uint32_t serialNumber; /* Volume Serial Number (A) */
uint8_t volumeName[12]; /* Volume Name (A) */
} BPB;
/* Function Prototypes */
bool get_bpb(int volume, BPB *bpb);
bool read_cluster(const BPB *bpb, uint16_t clu, void *data);
#endif
/* fatsys. c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdbool.h>
#include "diskio.h"
#include "fatsys.h"
bool get_bpb(int volume, BPB *bpb)
{
uint8_t bootSect[BYTES_PER_SECTOR];
if (read_sector(volume, 0, 1, bootSect) == -1)
return false;
bpb->volume = volume;
bpb->bps = *(uint16_t *)(bootSect + 0x0B);
bpb->spc = *(uint8_t *)(bootSect + 0x0D);
bpb->reservedSect = *(uint16_t *)(bootSect + 0x0E);
bpb->fatLen = *(uint16_t *)(bootSect + 0x16);
bpb->rootLen = *(uint16_t *)(bootSect + 0x11) * FILE_INFO_LENGTH / bpb->bps;
bpb->fatCopyNum = *(uint8_t *)(bootSect + 0x10);
if (*(uint16_t *)(bootSect + 0x13))
bpb->totalSec = *(uint16_t *)(bootSect + 0x13);
else
bpb->totalSec = *(uint16_t *)(bootSect + 0x20);
bpb->medDes = *(bootSect + 0x15);
bpb->spt = *(uint16_t *)(bootSect + 0x18);
bpb->rootEntryNum = *(uint16_t *)(bootSect + 0x11);
bpb->headNum = *(uint16_t *)(bootSect + 0x1A);
bpb->hidNum = *(uint16_t *)(bootSect + 0x1C);
bpb->tph = (uint16_t)(bpb->totalSec / bpb->spt / bpb->headNum);
bpb->fatOrigin = bpb->reservedSect;
bpb->rootOrigin = bpb->reservedSect + bpb->fatLen * bpb->fatCopyNum;
bpb->dataOrigin = bpb->rootOrigin + bpb->rootLen;
bpb->serialNumber = *(uint32_t *)(bootSect + 0x27);
memcpy(bpb->volumeName, bootSect + 0x2B, 11);
bpb->volumeName[11] = '\0';
return true;
}
bool read_cluster(const BPB *bpb, uint16_t clu, void *data)
{
return read_sector(bpb->volume, bpb->dataOrigin + (clu - 2) * bpb->spc, bpb->spc, data) == 0;
}
bool write_cluster(const BPB *bpb, uint16_t clu, const void *data)
{
return write_sector(bpb->volume, bpb->dataOrigin + (clu - 2) * bpb->spc, bpb->spc, data) == 0;
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdint.h>
#include <fcntl.h>
#include <unistd.h>
#include "diskio.h"
#include "fatsys.h"
void exit_sys(const char *msg);
int main(void)
{
int volume;
BPB bpb;
uint8_t *buf;
int i, k;
if ((volume = open("/dev/loop0", O_RDONLY)) == -1)
exit_sys("open");
if (!get_bpb(volume, &bpb))
exit_sys("getbpb");
printf("Fat'in başlangı ı
printf("Fat'in sektör uzunluğu: %u\n", bpb.fatLen);
printf("Root Dir bölümünün başlangı ı
printf("Root Dir bölümünün sektör uzunluğu: %u\n", bpb.rootLen);
printf("Data bölümünün başlangı ı
printf("Volümdeki toplam sektör sayı ı
printf("Bir cluster'ı
if ((buf = (uint8_t *)calloc(bpb.spc * bpb.bps, 1)) == NULL) {
fprintf(stderr, "Cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
if (!read_cluster(&bpb, 3, buf))
exit_sys("WriteCluster");
for (i = 0; i < 1024; ++i) {
printf("%02X ", buf[i]);
if (i % 16 == 15) {
for (k = 0; k < 16; ++k)
putchar(isalnum(buf[i - 15 + k]) ? buf[i - 15 + k] : '.');
putchar('\n');
}
}
free(buf);
close(volume);
return 0;
}
void exit_sys(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
FAT bölümü bir bağlı ı ı
dosyanı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/* fatsys.h */
#ifndef FATSYS_H_
#define FATSYS_H_
#include <Windows.h>
/* Symbolic contants */
#define FILE_INFO_LENGTH 32
#define MAX_CLUSTER_CHAIN 65536
/* Type Declaration */
typedef struct tagBPB {
HANDLE hVolume; /* volume */
WORD fatLen; /* number of sectors of FAT (A) */
WORD rootLen; /* number of sectors of ROOT */
WORD fatCopyNum; /* number of copies of FAT (A) */
DWORD totalSec; /* total sector (A) */
WORD bps; /* byte per sector(A) */
WORD spc; /* sector per cluster(A) */
WORD reservedSect; /* reserved sector(A) */
BYTE medDes; /* media descriptor byte(A) */
WORD spt; /* sector per track(A) */
WORD rootEntryNum; /* root entry(A) */
WORD headNum; /* number of heads(A) */
WORD hidNum; /* number of hidden sector(A)*/
WORD tph; /* track per head */
WORD fatOrigin; /* fat directory location */
WORD rootOrigin; /* root directory location */
WORD dataOrigin; /* first data sector location */
DWORD serialNumber; /* Volume Serial Number (A) */
BYTE volumeName[12]; /* Volume Name (A) */
} BPB;
/* Function Prototypes */
BOOL GetBPB(HANDLE hVolume, BPB *pBPB);
BOOL ReadCluster(const BPB *pBPB, WORD clu, void *pData);
BOOL WriteCluster(const BPB *pBPB, WORD clu, const void *pData);
WORD *GetClusterChain16(BYTE *pFat, WORD firstCluster, WORD *pCount);
WORD *GetClusterChain12(BYTE *pFat, WORD firstCluster, WORD *pCount);
#endif
/* fatsys.c */
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#include "DiskIo.h"
#include "FatSys.h"
BOOL GetBPB(HANDLE hVolume, BPB *pBPB)
{
BYTE bootSect[BYTES_PER_SECTOR];
if (!ReadSector(hVolume, 0, 1, bootSect))
return FALSE;
pBPB->hVolume = hVolume;
pBPB->bps = *(WORD *)(bootSect + 0x0B);
pBPB->spc = *(BYTE *)(bootSect + 0x0D);
pBPB->reservedSect = *(WORD *)(bootSect + 0x0E);
pBPB->fatLen = *(WORD *)(bootSect + 0x16);
pBPB->rootLen = *(WORD *)(bootSect + 0x11) * FILE_INFO_LENGTH / pBPB->bps;
pBPB->fatCopyNum = *(BYTE *)(bootSect + 0x10);
if (*(WORD *)(bootSect + 0x13))
pBPB->totalSec = *(WORD *)(bootSect + 0x13);
else
pBPB->totalSec = *(DWORD *)(bootSect + 0x20);
pBPB->medDes = *(bootSect + 0x15);
pBPB->spt = *(WORD *)(bootSect + 0x18);
pBPB->rootEntryNum = *(WORD *)(bootSect + 0x11);
pBPB->headNum = *(WORD *)(bootSect + 0x1A);
pBPB->hidNum = *(WORD *)(bootSect + 0x1C);
pBPB->tph = (WORD)(pBPB->totalSec / pBPB->spt / pBPB->headNum);
pBPB->fatOrigin = pBPB->reservedSect;
pBPB->rootOrigin = pBPB->reservedSect + pBPB->fatLen * pBPB->fatCopyNum;
pBPB->dataOrigin = pBPB->rootOrigin + pBPB->rootLen;
pBPB->serialNumber = *(DWORD *)(bootSect + 0x27);
memcpy(pBPB->volumeName, bootSect + 0x2B, 11);
pBPB->volumeName[11] = '\0';
return TRUE;
}
BOOL ReadCluster(const BPB *pBPB, WORD clu, void *pData)
{
return ReadSector(pBPB->hVolume, pBPB->dataOrigin + (clu - 2) * pBPB->spc, pBPB->spc, pData);
}
BOOL WriteCluster(const BPB *pBPB, WORD clu, const void *pData)
{
return WriteSector(pBPB->hVolume, pBPB->dataOrigin + (clu - 2) * pBPB->spc, pBPB->spc, pData);
}
WORD *GetClusterChain16(BYTE *pFat, WORD firstCluster, WORD *pCount)
{
static WORD chain[MAX_CLUSTER_CHAIN];
WORD cluster;
int count;
cluster = firstCluster;
count = 0;
while (cluster < 0xFFF8) {
chain[count++] = cluster;
cluster = *(WORD *)(pFat + cluster * 2);
}
*pCount = count;
return chain;
}
WORD *GetClusterChain12(BYTE *pFat, WORD firstCluster, WORD *pCount)
{
static WORD chain[MAX_CLUSTER_CHAIN];
WORD cluster;
int count;
cluster = firstCluster;
count = 0;
while (cluster < 0xFF8) {
chain[count++] = cluster;
if (cluster % 2 == 0)
cluster = *(WORD *)(pFat + cluster * 3 / 2) & 0x0FFF;
else
cluster = *(WORD *)(pFat + cluster * 3 / 2) >> 4;
}
*pCount = count;
return chain;
}
/* app.c */
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <windows.h>
#include "DiskIO.h"
#include "FatSys.h"
void ExitSys(LPCSTR lpszMsg);
int main(void)
{
HANDLE hVolume;
BPB bpb;
BYTE *pFat;
WORD *pClusterChain;
WORD nclusters;
int i;
if ((hVolume = OpenVolume('H' - 'A', GENERIC_READ)) == INVALID_HANDLE_VALUE)
ExitSys("OpenDisk");
if (!GetBPB(hVolume, &bpb))
ExitSys("GetBPB");
printf("Fat'in başlangı ı
printf("Fat'in sektör uzunluğu: %u\n", bpb.fatLen);
printf("Root Dir bölümünün başlangı ı
printf("Root Dir bölümünün sektör uzunluğu: %u\n", bpb.rootLen);
printf("Data bölümünün başlangı ı
printf("Volümdeki toplam sektör sayı ı
printf("Bir cluster'ı
if ((pFat = (BYTE *)malloc(bpb.fatLen * bpb.bps)) == NULL) {
fprintf(stderr, "Cannot allocate memory!..\n");
exit(EXIT_FAILURE);
}
if (!ReadSector(hVolume, bpb.fatOrigin, bpb.fatLen, pFat))
ExitSys("ReadSector");
pClusterChain = GetClusterChain12(pFat, 10, &nclusters);
for (i = 0; i < nclusters; ++i)
printf("%d ", pClusterChain[i]);
printf("\n");
CloseHandle(hVolume);
return 0;
}
void ExitSys(LPCSTR lpszMsg)
{
DWORD dwLastErr = GetLastError();
LPTSTR lpszErr;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwLastErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpszErr, 0, NULL)) {
fprintf(stderr, "%s: %s", lpszMsg, lpszErr);
LocalFree(lpszErr);
}
exit(EXIT_FAILURE);
}
/*------------------------------------------------------------------------------------------------------------------------------------------
Alt dizinler tamamen bir dosya gibi organize edilmektedir. Nası ı
o dizin içerisindeki dosyalara ilişkin bilgiler vardı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
FAT12 ve FAT16 sistemlerinde FAT elemanları ı ı ı ı
Bir cluster en fazla 64 sektör olabilmektedir. Bu nedenle FAT16 volümlerinin de maksimum kapasitesi 2GB olabilir. Microsoft FAT32 ile birlikte
FAT dosya sistemine şu eklemeleri yapmı ı
1) Boot sektör içerisindeki BPB alanı ı
2) FAT elemanları ı ı ı ı ı ı ı
3) Kök dizin alt dizinler gibi DATA bölümünün içerisine alı ı ı ı ı ı
Dolayı ı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
UNIX/Linux sistemlerinde kullanı ı ı ı ı
benzemektedir. Bu aileye "I-Node Tabanlı ı ı
gibi sistemlerdir. Linux sistemleri ağı ı ı ı
I-Node Tabanlı ı ı ı ı
1) Boot Block
2) Super Block
3) I-Node Block
4) Data Block
Boot Block volümün ilk iki sektörünü oluşturur. 1024 byte uzunluktadı
Boot Block FAT dosya sistemlerindeki Boot sektöre işlevsel olarak benzetilebilir. Boot bloğunu I-Node Block denilen yine 1024 byte uzunlukta olan
Super Block izler. Super Block FAT dosya sistemindeki BPB bölümüne benzetilebilir. Dosya sistemin tüm parametrik bilgileri Super blokta tutulmaktadı
I-Node blok I-Node elemanları ı ı ı ı
dosya bilgilerini bu dosya için ayrı ı ı ı ı ı ı
I-Node bloktaki i-node elemanları ı ı ı ı ı ı
Data Block FAT dosya sistemindeki Data Block ile aynı ı ı ı ı ı
küçük farklı ı ı ı ı ı ı ı
sistemlerinde "cluster" sözcüğü yerine "block" sözcüğü kullanı ı ı
her bloğa ilki 0 olmak üzere bir blok numarası ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
Ext-2 Dosya sistemi bazı ı ı ı ı
Boot Block bulunur. Onu yine 1024 byte uzunluğunda Super Block izler. Ancak Ext-2'de Super Bloğu I-Node Block izlemez. Çünkü Ext-2 adeta
küçük bölümlerin toplamı ı ı ı
bilgiler "Block Group Descriptor Table" isimli bir veri yapı ı ı ı ı ı ı ı ı ı
1K'dan daha büyük blok yapı ı ı ı ı ı ı ı
uzunlupunda olan "Block Group Descriptor" denilen ve bir block group hakkı ı
üç block group varsa Block Group Descriptor Table'da her biri 32 byte'tan oluşan 3 tane Block Group Descriptor.
Pekiyi Group Block'lar içerisinde ne vardı ı ı ı ı
Bu kopyalardan sonra DataBlcok Bitmap ve I-Node bitmap denilen iki bit tablosu bulunmaktadı ı
I-Node Block ve Data Block bulunmaktadı ı ı
ayrı ı
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------*/
