Unix IPC —
Pipe, FIFO, Socket, Shared Memory.

#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/wait.h>

int main(void) {
    int fds[2];
    char buf[128];

    if (pipe(fds) == -1) {   /* pipe oluştur */
        perror("pipe");
        return 1;
    }

    pid_t pid = fork();

    if (pid == 0) {
        /* child: okuyucu — yazma ucunu kapat */
        close(fds[1]);
        ssize_t n = read(fds[0], buf, sizeof(buf) - 1);
        buf[n] = '\0';
        printf("child okudu: %s\n", buf);
        close(fds[0]);
        _exit(0);
    }

    /* parent: yazıcı — okuma ucunu kapat */
    close(fds[0]);
    const char *msg = "merhaba child";
    write(fds[1], msg, strlen(msg));
    close(fds[1]);   /* kapat → child'da EOF görülür */

    wait(NULL);
    return 0;
}

#include <signal.h>
#include <unistd.h>
#include <errno.h>

/* Yöntem 1: SIGPIPE'ı yoksay */
signal(SIGPIPE, SIG_IGN);
ssize_t n = write(fds[1], buf, len);
if (n == -1 && errno == EPIPE) {
    /* okuyucu kapandı, yazma başarısız */
}

/* Yöntem 2: MSG_NOSIGNAL (send() için) */
send(sock_fd, buf, len, MSG_NOSIGNAL);

# Komut satırından FIFO oluştur
mkfifo /tmp/myfifo

# İzinleri kontrol et
ls -l /tmp/myfifo
# prw-r--r-- 1 user user 0 Apr 12 10:00 /tmp/myfifo
# "p" → named pipe

#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>

int main(void) {
    const char *path = "/tmp/myfifo";

    /* FIFO oluştur (zaten varsa EEXIST — sorun değil) */
    mkfifo(path, 0666);

    printf("Yazıcı bekleniyor...\n");

    /* O_RDONLY: yazıcı taraf açana kadar BLOKLAR */
    int fd = open(path, O_RDONLY);

    char buf[256];
    ssize_t n;
    while ((n = read(fd, buf, sizeof(buf))) > 0) {
        buf[n] = '\0';
        printf("Alındı: %s", buf);
    }

    close(fd);
    unlink(path);   /* FIFO'yu sil */
    return 0;
}

#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main(void) {
    /* O_WRONLY: okuyucu taraf açana kadar BLOKLAR */
    int fd = open("/tmp/myfifo", O_WRONLY);

    const char *msg = "merhaba fifo\n";
    write(fd, msg, strlen(msg));

    close(fd);
    return 0;
}

/* Non-blocking open: karşı taraf yoksa -1 / ENXIO döner */
int fd = open("/tmp/myfifo", O_RDONLY | O_NONBLOCK);
if (fd == -1) {
    perror("open");   /* ENXIO: yazıcı henüz bağlanmamış */
}

#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

#define SOCK_PATH "/tmp/myapp.sock"

int main(void) {
    int srv, cli;
    struct sockaddr_un addr;
    char buf[256];

    /* 1. Socket oluştur */
    srv = socket(AF_UNIX, SOCK_STREAM, 0);

    /* 2. Adres ayarla */
    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, SOCK_PATH, sizeof(addr.sun_path) - 1);

    /* 3. Önceki socket dosyasını temizle */
    unlink(SOCK_PATH);

    /* 4. Bind + listen */
    bind(srv, (struct sockaddr *)&addr, sizeof(addr));
    listen(srv, 5);

    printf("İstemci bekleniyor: %s\n", SOCK_PATH);

    /* 5. Accept döngüsü */
    while (1) {
        cli = accept(srv, NULL, NULL);
        ssize_t n = read(cli, buf, sizeof(buf) - 1);
        buf[n] = '\0';
        printf("Alındı: %s\n", buf);

        const char *resp = "ACK";
        write(cli, resp, strlen(resp));
        close(cli);
    }

    close(srv);
    unlink(SOCK_PATH);
    return 0;
}

#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(void) {
    int fd;
    struct sockaddr_un addr;
    char buf[64];

    fd = socket(AF_UNIX, SOCK_STREAM, 0);

    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, "/tmp/myapp.sock", sizeof(addr.sun_path) - 1);

    if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
        perror("connect");
        return 1;
    }

    const char *msg = "merhaba server";
    write(fd, msg, strlen(msg));

    ssize_t n = read(fd, buf, sizeof(buf) - 1);
    buf[n] = '\0';
    printf("Yanıt: %s\n", buf);

    close(fd);
    return 0;
}

struct sockaddr_un addr;
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;

/* sun_path[0] = '\0' → abstract namespace */
/* gerçek isim sun_path[1]'den başlar        */
strncpy(addr.sun_path + 1, "myapp", sizeof(addr.sun_path) - 2);

/* addrlen: sun_family boyutu + 1 (null byte) + isim uzunluğu */
socklen_t len = sizeof(sa_family_t) + 1 + strlen("myapp");
bind(fd, (struct sockaddr *)&addr, len);

#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>

void send_fd(int sock, int fd_to_send) {
    struct msghdr msg = {0};
    char cmsg_buf[CMSG_SPACE(sizeof(int))];
    char dummy = '!';
    struct iovec iov = { .iov_base = &dummy, .iov_len = 1 };

    msg.msg_iov     = &iov;
    msg.msg_iovlen  = 1;
    msg.msg_control = cmsg_buf;
    msg.msg_controllen = sizeof(cmsg_buf);

    struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
    cmsg->cmsg_level = SOL_SOCKET;
    cmsg->cmsg_type  = SCM_RIGHTS;     /* fd passing protokolü */
    cmsg->cmsg_len   = CMSG_LEN(sizeof(int));
    memcpy(CMSG_DATA(cmsg), &fd_to_send, sizeof(int));

    sendmsg(sock, &msg, 0);
}

#include <sys/socket.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/wait.h>

int main(void) {
    int sv[2];
    char buf[128];

    /* İki bağlı socket oluştur */
    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == -1) {
        perror("socketpair");
        return 1;
    }

    pid_t pid = fork();

    if (pid == 0) {
        /* child: sv[1] kullanır, sv[0]'ı kapatır */
        close(sv[0]);

        const char *msg = "child'dan mesaj";
        write(sv[1], msg, strlen(msg));

        ssize_t n = read(sv[1], buf, sizeof(buf) - 1);
        buf[n] = '\0';
        printf("child yanıt aldı: %s\n", buf);

        close(sv[1]);
        _exit(0);
    }

    /* parent: sv[0] kullanır, sv[1]'i kapatır */
    close(sv[1]);

    ssize_t n = read(sv[0], buf, sizeof(buf) - 1);
    buf[n] = '\0';
    printf("parent aldı: %s\n", buf);

    const char *reply = "parent yanıtı";
    write(sv[0], reply, strlen(reply));

    wait(NULL);
    close(sv[0]);
    return 0;
}

#include <sys/mman.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/wait.h>

int main(void) {
    /* MAP_SHARED: fork sonrası aynı fiziksel sayfayı paylaşırlar */
    /* MAP_ANONYMOUS: dosya değil, sıfır-başlatılmış bellek       */
    int *shared = mmap(
        NULL,
        sizeof(int),
        PROT_READ | PROT_WRITE,
        MAP_SHARED | MAP_ANONYMOUS,
        -1, 0
    );

    if (shared == MAP_FAILED) {
        perror("mmap");
        return 1;
    }

    *shared = 0;

    pid_t pid = fork();

    if (pid == 0) {
        /* child: değeri artır */
        *shared = 42;
        _exit(0);
    }

    wait(NULL);

    /* parent: child'ın yazdığı değeri görür */
    printf("shared değer: %d\n", *shared);   /* 42 */

    munmap(shared, sizeof(int));
    return 0;
}

#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main(void) {
    /* /dev/shm: RAM-backed tmpfs */
    int fd = open("/dev/shm/myapp-buf", O_CREAT | O_RDWR, 0600);
    ftruncate(fd, 4096);   /* boyutu ayarla */

    char *buf = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    close(fd);   /* fd'yi kapat, mapping hâlâ aktif */

    strcpy(buf, "paylaşılan veri");

    msync(buf, 4096, MS_SYNC);   /* değişiklikleri garantile */
    munmap(buf, 4096);
    unlink("/dev/shm/myapp-buf");
    return 0;
}

#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>

#define SHM_NAME  "/myapp-shm"
#define SHM_SIZE  4096

int main(void) {
    /* 1. shm_open: /dev/shm/myapp-shm dosyası oluşturur */
    int fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0666);
    if (fd == -1) { perror("shm_open"); return 1; }

    /* 2. Boyutu ayarla */
    ftruncate(fd, SHM_SIZE);

    /* 3. mmap ile adres alanına eşle */
    char *ptr = mmap(NULL, SHM_SIZE,
                    PROT_READ | PROT_WRITE,
                    MAP_SHARED, fd, 0);
    close(fd);

    /* 4. Veri yaz */
    snprintf(ptr, SHM_SIZE, "producer verisi: %d", getpid());
    printf("Yazıldı, consumer bekleniyor...\n");

    sleep(10);   /* consumer okuyana kadar bekle */

    munmap(ptr, SHM_SIZE);
    shm_unlink(SHM_NAME);   /* temizlik */
    return 0;
}

#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

int main(void) {
    /* O_RDONLY: sadece oku */
    int fd = shm_open("/myapp-shm", O_RDONLY, 0);
    if (fd == -1) { perror("shm_open"); return 1; }

    char *ptr = mmap(NULL, 4096, PROT_READ, MAP_SHARED, fd, 0);
    close(fd);

    printf("Okunan: %s\n", ptr);

    munmap(ptr, 4096);
    return 0;
}

#include <mqueue.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <stdio.h>
#include <string.h>

#define QUE_NAME  "/myqueue"

int main(void) {
    struct mq_attr attr = {
        .mq_flags   = 0,
        .mq_maxmsg  = 10,       /* en fazla 10 mesaj bekleyebilir */
        .mq_msgsize = 256,      /* her mesaj en fazla 256 byte   */
        .mq_curmsgs = 0
    };

    mqd_t mqd = mq_open(QUE_NAME, O_CREAT | O_WRONLY, 0666, &attr);
    if (mqd == (mqd_t)-1) { perror("mq_open"); return 1; }

    const char *msg1 = "normal mesaj";
    const char *msg2 = "acil mesaj";

    /* Priority 5: normal */
    mq_send(mqd, msg1, strlen(msg1) + 1, 5);

    /* Priority 10: daha yüksek → kuyrukta öne geçer */
    mq_send(mqd, msg2, strlen(msg2) + 1, 10);

    mq_close(mqd);
    return 0;
}

#include <mqueue.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <stdio.h>
#include <string.h>

int main(void) {
    mqd_t mqd = mq_open("/myqueue", O_RDONLY);
    if (mqd == (mqd_t)-1) { perror("mq_open"); return 1; }

    struct mq_attr attr;
    mq_getattr(mqd, &attr);

    char buf[256];
    unsigned int prio;
    ssize_t n;

    /* Yüksek priority'li mesaj önce gelir */
    while ((n = mq_receive(mqd, buf, attr.mq_msgsize, &prio)) > 0) {
        printf("[prio=%u] %s\n", prio, buf);
    }

    mq_close(mqd);
    mq_unlink("/myqueue");   /* temizlik */
    return 0;
}

#include <mqueue.h>
#include <signal.h>
#include <fcntl.h>
#include <stdio.h>

static mqd_t g_mqd;

static void mq_handler(int sig) {
    char buf[256];
    unsigned int prio;
    ssize_t n = mq_receive(g_mqd, buf, sizeof(buf), &prio);
    if (n > 0) {
        buf[n] = '\0';
        printf("async alındı: %s\n", buf);
    }

    /* Her alımdan sonra notify yeniden kaydet */
    struct sigevent sev = { .sigev_notify = SIGEV_SIGNAL,
                           .sigev_signo  = SIGUSR1 };
    mq_notify(g_mqd, &sev);
}

int main(void) {
    g_mqd = mq_open("/myqueue", O_RDONLY);

    signal(SIGUSR1, mq_handler);

    struct sigevent sev = { .sigev_notify = SIGEV_SIGNAL,
                           .sigev_signo  = SIGUSR1 };
    mq_notify(g_mqd, &sev);

    /* Ana döngü: mesaj geldiğinde signal handler çalışır */
    while (1) pause();

    return 0;
}

# Maksimum kuyruk sayısı
cat /proc/sys/fs/mqueue/queues_max

# Maksimum mesaj sayısı per kuyruk
cat /proc/sys/fs/mqueue/msg_max

# Maksimum mesaj boyutu
cat /proc/sys/fs/mqueue/msgsize_max

# Geçici olarak artır
sudo sysctl fs.mqueue.msg_max=100

#include <semaphore.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <stdio.h>

int main(void) {
    /* Named semaphore: /my-sem → /dev/shm/sem.my-sem */
    sem_t *sem = sem_open("/my-sem", O_CREAT, 0666, 1);
    if (sem == SEM_FAILED) { perror("sem_open"); return 1; }

    sem_wait(sem);          /* değer > 0 ise azalt ve devam et; 0 ise blokla */
    /* kritik bölge */
    printf("kritik bölgedeyim\n");
    sem_post(sem);          /* değeri artır, bekleyenleri uyandır */

    sem_close(sem);
    sem_unlink("/my-sem");
    return 0;
}

#include <semaphore.h>
#include <sys/mman.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/wait.h>

typedef struct {
    sem_t sem;
    int   counter;
} SharedData;

int main(void) {
    SharedData *data = mmap(NULL, sizeof(SharedData),
                            PROT_READ | PROT_WRITE,
                            MAP_SHARED | MAP_ANONYMOUS, -1, 0);

    /* pshared=1: fork sonrası process'ler arasında paylaşılabilir */
    sem_init(&data->sem, 1, 1);
    data->counter = 0;

    for (int i = 0; i < 4; i++) {
        if (fork() == 0) {
            for (int j = 0; j < 10000; j++) {
                sem_wait(&data->sem);
                data->counter++;        /* race condition yok */
                sem_post(&data->sem);
            }
            _exit(0);
        }
    }

    for (int i = 0; i < 4; i++) wait(NULL);

    printf("Sonuç: %d (beklenen: 40000)\n", data->counter);

    sem_destroy(&data->sem);
    munmap(data, sizeof(SharedData));
    return 0;
}

#include <pthread.h>
#include <sys/mman.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/wait.h>

typedef struct {
    pthread_mutex_t mtx;
    int             value;
} ShmRegion;

int main(void) {
    ShmRegion *reg = mmap(NULL, sizeof(ShmRegion),
                          PROT_READ | PROT_WRITE,
                          MAP_SHARED | MAP_ANONYMOUS, -1, 0);

    /* Mutex'i process-shared olarak başlat */
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
    pthread_mutex_init(&reg->mtx, &attr);
    pthread_mutexattr_destroy(&attr);

    reg->value = 0;

    if (fork() == 0) {
        pthread_mutex_lock(&reg->mtx);
        reg->value = 99;
        pthread_mutex_unlock(&reg->mtx);
        _exit(0);
    }

    wait(NULL);

    pthread_mutex_lock(&reg->mtx);
    printf("value: %d\n", reg->value);   /* 99 */
    pthread_mutex_unlock(&reg->mtx);

    pthread_mutex_destroy(&reg->mtx);
    munmap(reg, sizeof(ShmRegion));
    return 0;
}

#include <semaphore.h>
#include <sys/mman.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/wait.h>
#include <string.h>

#define BUF_SIZE 256

typedef struct {
    sem_t  empty;   /* başlangıç: 1 (boş slot var) */
    sem_t  full;    /* başlangıç: 0 (dolu slot yok) */
    char   buf[BUF_SIZE];
} Channel;

int main(void) {
    Channel *ch = mmap(NULL, sizeof(Channel),
                       PROT_READ | PROT_WRITE,
                       MAP_SHARED | MAP_ANONYMOUS, -1, 0);

    sem_init(&ch->empty, 1, 1);
    sem_init(&ch->full,  1, 0);

    if (fork() == 0) {
        /* consumer */
        sem_wait(&ch->full);             /* veri gelene kadar bekle */
        printf("consumer: %s\n", ch->buf);
        sem_post(&ch->empty);            /* slot boşaldı */
        _exit(0);
    }

    /* producer */
    sem_wait(&ch->empty);               /* slot boşalana kadar bekle */
    strncpy(ch->buf, "merhaba consumer", BUF_SIZE);
    sem_post(&ch->full);                /* veri hazır */

    wait(NULL);
    sem_destroy(&ch->empty);
    sem_destroy(&ch->full);
    munmap(ch, sizeof(Channel));
    return 0;
}