LAPORAN RESMI

PRAKTIKUM SISTEM OPERASI

MODUL 2
SYSTEM CALL DAN
INTERPROCESS COMUNICATION (IPC)

Oleh:
Kelompok 5
Adhitya Bhawiyuga 5107.100.084
Rizky Septiandy W 5107.100.103

Asisten:

Rio Indra Maulana

NRP. 5106.100.052

LABORATORIUM ARSITEKTUR DAN JARINGAN KOMPUTER

JURUSAN TEKNIK INFORMATIKA
FAKULTAS TEKNOLOGI INFORMASI
INSTITUT TEKNOLOGI SEPULUH NOPEMBER
2008
SOAL PENDAHULUAN

1. Jelaskan apa yang dimaksud dengan system call

System call adalah antarmuka antara proses (program yang run) dengan OS. Umumnya
dalam bentuk instruksi bahasa assembly. Bahasa untuk system programming tingkat
tinggi biasanya memungkinkan system call dilakukan langsung. Misal C, C++, Bliss,
PL/360

Tiga metode untuk passing parameter antara running program dan OS :

 Pass parameter melalui register

 Meyimpan parameter dalam blok atau tabel pada memory, dan alamat tabel
di-passing sebagai parameter dlm register

 Mmenyimpan parameter (push) ke dalam stack

2. Definisikan proses dan sebutkan atribut-atributnya!

Proses adalah program yang sedang dalam keadaan dieksekusi.yang memiliki sumber
daya dan dijadwalkan oleh system operasi. Sistem operasi mengolah seluruh proses yang ada
di sistem dan bertugas mengalokasikan sumber daya – sumber daya ke proses yang
membutuhkan sesuai dengan kebijaksanaan tertentu. Sumber daya yang
dibutuhkan proses diantaranya CPU, memori, file serta I/O device.

Jenis statusnya :
- Status New yaitu status dimana proses sedang dibuat.
- Status Ready yaitu status dimana proses siap dieksekusi tetapi CPU belum tersedia karena
sedang
mengerjakan proses lain.
- Status Waiting yaitu status dimana proses sedang menunggu suatu kejadian tertentu.
Misalnya sedang
menunggu operasi I/O selesai, menunggu signal dari proses lain, tersedianya memori, dsb.
- Status Running yaitu status dimana proses dieksekusi. Pada status ini CPU sedang
mengeksekusi
instruksi – instruksi pada proses.
- Status Terminated yaitu status dimana proses diakhiri.
Atribut:
-PID(Process ID)
-tty

3. Jelaskan apa yang dimaksud dengan thread!

Sebuah alur kontrol dari sebuah proses. Suatu proses yang multithreaded
mengandung beberapa perbedaan alur kontrol dengan ruang alamat yang sama.
Keuntungan dari multithreaded meliputi peningkatan respon dari pengguna, pembagian
sumber daya proses, ekonomis, dan kemampuan untuk mengambil keuntungan dari
arsitektur multiprosesor. Thread tingkat pengguna adalah thread yang tampak oleh
programer dan tidak diketahui oleh kernel. Thread tingkat pengguna secara tipikal
dikelola oleh sebuah pustaka thread di ruang pengguna. Thread tingkat kernel didukung
dan dikelola oleh kernel sistem operasi. Secara umum, thread tingkat pengguna lebih
cepat dalam pembuatan dan pengelolaan dari pada kernel thread.

4. Proses satu dengan proses lain dibedakan berdasarkan PID atau Process
Identification berupa angka integer positif yang unik.

5. Jelaskan kegunaan, parameter, dan return value dari fungsi-fungsi berikut :

a. fork()
- Kegunaan :
Untuk membuat sebuah proses baru. Proses baru terebut merupakan proses anak dan
merupakan kopian dari proses induk.
- Parameter :
void
- Syntax :
#include <unistd.h>
pid_t fork(void);

- Return value :
Jika sukses, fork() akan mengembalikan nilai 0 pada proses anak dan mengembalikan
proses Iddari proses anak ke proses induk. Jika terjadi error, maka akan mengembalikan
nilai -1.

b. getpid() / getppid()
- Kegunaan :
Untuk mendapatkan suatu process ID
- Parameter :
void
- Syntax :
#include <sys/types.h>
#include <unistd.h>
pid_t getpid(void);

- Return value :
Fungsi getpid() akan mengembalikan process ID dari proses yang memanggil. Funsi ini
selalu dikembalikan dengan sukses.

c. exit()
- Kegunaan :
Untuk menutup suatu proses
- Parameter :
int status
- Syntax :
#include <stdlib.h>
void exit(int status);

- Return value :
Fungsi exit() tidak memiliki return value.
d. wait()
- Kegunaan :
Menunggu pros to stop or terminate
- Parameter :
Pointer int *stat_loc yang akan menjadi tempat simpanan
- Syntax :
#include <sys/wait.h>
pid_t wait(int *stat_loc);

- Return value :
process ID dari child process pada status yang dilaporkan
e. execv()
- Kegunaan :
berguna untuk membentuk proses baru.Tapi child process mempunyai intruksi yang
berbeda dengan parent process sehingga kedua proses ini tidak lagi identik.
- Parameter :
- path : Nama dan path dari proses baru
- argv : Daftar argumen untuk proses yang baru. Berisi pointer dari sebuah array karakter.

- Syntax :
int execv(const char *path, char *const argv[]);

- Return value :
Jika sukses, fungsi ini tidak mengembalikan nilai, namun jika gagal akan mengembalikan
nilai -1.

6. Jelaskan dengan lengkap tentang beberapa hal berikut ini :

- shared memory
Komunikasi antar proses yang memungkinkan satu proses atau lebih
berkomunikasi melalui sharing data lewat memori yang ada.
- mapped memory
Mapped memory adalah sebuah mekanisme yang berhubungan dengan mapping
sebuah file dalam file system sesuai dengan porsi memory yang ada. Pelibatan langsung
yang berlebihan terhadap system call untuk permintaan data mungkin dapat ditolak oleh
mekanisme mapped memory. Hal ini terjadi disebabkan tersedianya porsi pada virtual
memory.
- pipe
Bagian memory yang dapat dipakai oleh satu proses untuk meneruskan informasi
kepada yang lain. pada dasarnya pipe bekerja seperti barang yang sama namanya. Ia
menghubungkan dua proses sehingga output yang satu dapat dipakai sebagai input pada
yang lain.
- FIFO
FIFO adalah penjadwalan dengan ketentuan-ketentuan paling sederhana, yaitu :
- Proses-proses diberi jatah waktu pemroses diurutan berdasarkan waktu
kedatangan proses-proses itu ke sistem.
- Begitu proses mendapat jatah waktu pemroses, proses dijalankan sampai selesai.
- semaphore
 Dua proses atau lebih dapat bekerja sama dengan menggunakan penanda-penanda
sederhana. Proses dipaksa berhenti sampai proses memperoleh penanda tertentu.
Sembarang kebutuhan koordinasi kompleks dapat dipenuhi dengan struktur penanda yang
sesuai kebutuhannya. Variabel khusus untuk penanda ini disebut semaphore. Digunakan
untuk sinkronisasi proses.
- socket
Adalah titik akhir dari komunikasi dimana akan melakukan korespodensi kepada
sebagian defenisi dari asosiasi.. Asosiasi adalah sebuah komunikasi antar 2 proses yang
berjalan pada 2 system computer. Pendefinisian dari sebagian asosiasi meliputi, protocol,
local-adress, local process, remote-adress dan remote process
- message queue
Komunikasi antar proses yang memungkinkan dua proses atau lebih menulis pesan
yang akan dibaca oleh satu proses pembaca atau lebih. Message dikirim ke queue secara
berurutan dan diambil dari antrian dengan beragam cara. Tiap message queue
diidentifikasikan identifier IPC secara unik.

7. Definisikan IPC (interprocess communication)

IPC merupakan penyedia sebuah mekanisme untuk mengizinkan proses-
proses untuk berkomunikasi dan menyelaraskan aksi-aksi mereka tanpa berbagi
ruang alamat yang sama.
IPC adalah khusus digunakan dalam sebuah lingkungan yang terdistribusi
dimana proses komunikasi tersebut mungkin saja tetap ada dalam komputer-
komputer yang berbeda yang tersambung dalam sebuah jaringan. IPC adalah
penyedia layanan terbaik dengan menggnakan sebuah sistem penyampaian pesan,
dan sistem-sistem pesan dapat diberikan dalam banyak cara.
IPC dapat dilakukan dengan beberapa cara yaitu Shared memory, Mapped
memory, Pipe, FIFO, socked dan sebagainya.

8. Sebutkan dan jelaskan perbedaan macam-macam mekanisme IPC berikut ini :

1. unnamed pipe
Dibentuk dengan system call pipe. Contoh inisialisi :
int pipe(int filedes[2]);
Jika sukses system call pipe mengembalikan sepasang of integer file descriptor
file integer, filedes[0] dan filedes[1], yang mereferensi 2 datastream. Pipes
ini merupakan unidirectional dan data dikirimdalam satu arah. Jika membutuhkan
komunikasi 2 arah, 2 pipe akan dibuka; 1 untuk membaca,satu untuk menulis.
Pada half duplex setting, filedes[1] digunakan untuk menulis, dan filedes[0]
digunakan untuk membaca.
Jumlah data yang mampu ditampung pipe terbatas tergantung system. Saat sebuah
pipe tidak berasosiasi dengan proses manapun, maka isinya akan di-flush oleh
system. read dan write system calls, yang dapat digunakan oleh pipe,
memberikan user kemudahan mengkoordinasi alur data dalam pipe. Saat
menggunakan pipe, kita harus berhati-hati dengan deadlock situations. Deadlock
dapat terjadi saat sebuah proses membuka sebuah akhir dari pipe untuk menulis
dan proses lain membuka akhiran pada pipe yang sama untuk menulis sehingga
tiap proses menunggu proses lain untuk menyelesaikan aksinya.
 Unnamed pipe ini hanya bisa digunakan dengan proses-proses yang berhubungan.
popen system call member user kemudahan jalan untuk menghasilkan sebuah
unnamed pipe untuk mengeksekusi shell command

2. named pipe
Named pipes (FIFOs), yang muncul sebagai masukan direktori aktual, dapat di-
share oleh proses-proses yang tidak berhubungan. Named pipes mirip dengan
unnamed pipes tapi memiliki keuntungan tambahan. Saat dibuat, named pipes
memiliki sebuah “directory entry”. Dengan directory entry maka akan ada file
access permissions dan kemampuan unrelated processes untuk menggunakan pipe
file. Meskipun FIFO memiliki sebuah directory entry, perlu diingat bahwa data
yang ditulis ke FIFO dilewatkan ke dan disimpan oleh kernel dan tidak secara
langsung ditulis ke file system.
Named pipes dapat dibuat pada shell level (dengan command line) atau dengan
sebuah program. Pada shell level, command yang digunakan untuk membuat
named pipe adalah mknod. Syntax untuk mknod command untuk membuat named
pipe adalah :
linux$ mknod PIPE p
Argumen pertama pada mknod command adalah file name untuk FIFO. Argumen
kedua adalah sebuah lowercase p, yang memberi peringatan mknod bahwa sebuah
FIFO file akan dibuat.

3. message queue
Designer UNIX menemukan bahwa jenis interprocess communications yang
diimplementasikan menggunakan signals dan pipes bersifat terbatas. Untuk
menambah flexibilitasdan ukuran interprocess communication, fasilitas
komunikasi tambahan pun dibuat. Fasilitas itu adalah message queue, semaphore
dan shared memory.
Sekali dibuat, sebuah message queue akan dijaga oleh system. Unrelated
processes, yang mengeksekusi pada waktu yang berbeda, dapat menggunakan
message queue untuk melewatkan informasi. Tiap message memiliki associated
type yang dapat digunakan untuk mengimplementasikan sebuah rudimentary form
of data multiplexing saat multiple producers dilibatkan. Message queues dibuat
dan diakses menggunakan system call msgget. Messages ditempatkan pada
message queue dengan system call msgsnd dan mengambil dari queue dengan
system call msgrcv. Manipulasi message queue dapat menggunakan msgctl.
msgctl system call mengembailkan informasi tentang message queue, ijin
modifikasi tergantung access permissions, dan mengizinkan pemilik untuk
menghapus fasilitas message queue.

4. shared memory
Shared memory memberikan user komunikasi yang efektif melalui sharing data
yang berada dalam memory. Tidak seperti komunikasi yang berbasis pipe, Data
ini dapat diakses pada nonserial (random) manner. Untuk mencegah
ketidakkonsistensian, semaphores sering digunakan untuk mengkoordinasi access
pada segmen shared memory. Shared memory segments dihasilkan dengan
shmget system call. Jika sebuah shared memory segment telah dibuat, shmget call
menghasilkan proses dengan access ke segment. System call shmctl digunakan
 untuk mendapatkan status sebuah memory segment, mengatur permissions, dan
menghapus sebuah shared memory segment. System call mmap digunakan untuk
memetakan virtual memory space dari sebuah process ke file. Saat file tetap ada
saat sebuah proses dihentikan, mmaped files mengizinkan komunikasi informasi
antar proses yang berada pada waktu yang berbeda.

9. Jelaskan yang dimaksud dengan signalling

Saat sebuah kejadian terjadi, sebuah proses mungkin akan menerima sinyal.
Sinyal digunakan untuk memberitahukan kejadian yang asinkronus pada satu atau
lebih proses yang membutuhkan respon dari prose yang diberi signal tersebut.
Sumber sinyal ini dapat melalui hardware, kernel, proses lain, atau user sendiri.

Tiap signal diberi nomer dan didefinisikan pada header file <signal.h>. Pada
Linux definisi signal juga berada pada <bits/signum.h>. File ini akan diikutkan
otomatis saat kita memanggil <signal.h>. Proses yang menerima signal dapat
melakukan salah satu dari 3 hal berikut :

1. Melakukan salah satu proses system default khusus untuk signal. Untuk
kebanyakan signal, aksi defaultnya adalah (a) memberitahukan proses induk
yang di-terminasi (b) Menghasilkan sebuah core file (sebua dile yang berisi
memory image dari proses), dan (c) terminate.
2. Tidak menghiraukan signal. Sebuah proses dapat melakukan hal ini dengan
semua signal kecuali 2 signal khusus: SIGSTOP (signal 23), Sebuah stop-
processing signal yang tidak dihasilkan dari terminal, dan SIGKILL (signal
9), yang mengindikasikan sebuah proses akan di-kill (terminated).
3. Menangkap signal. Seperti pada ignoring signal, hal ini dapat dilakukan
untuk semua signal kecuali SIGSTOP dan SIGKILL. Saat sebuah proses
menangkap dignal, proses akan membangkitkan fungsi khusus untuk
merespon signal.

Signal dapat diberikan dengan perintah kill. Perintah untuk melihat signal
dalam system adalah :
kill –l
Perintah untuk mengirim signal:
kill -<SIGNAL> <PID>

Berikut contoh peggunaan kill –l pada solaris system:

Sedangkan berikut perintah kill –l untuk linux

Jadi ada perbedaan value pada signal tergantung system operasinya.

SOAL WAJIB
Dengan menggunakan pipe, buat program dimana proses induk dapat mengirimkan pesan
kpada proses anak (pesan berasal dari inputan user) kemudian proses anak akan
menghasilkan reverse / kebalikan dari string tsb kepada proses induk

Algoritma dan Penjelasan

1. Pengguna pertama mengisi inputan string yang akan dibalik katanya. Inputan user
akan ditangkap dengan menggunakan fungsi gets() dan ditampung dalam sebuah
array of char.
2. Dua pipe dibuat dengan tujuan sebagai jalan pertukaran data antara parent dan
child untuk dua proses yang akan dijalankan yaitu parent mengirim pesan
pertama, dibaca oleh child. Hasil olahan string di child akan dikirim melalui pipe
kedua dan dibaca oleh parent kembali.
3. Dibuat proses anak dengan statemen fork()
4. Pada proses induk dilakukan pengiriman string inputan user melalui pipa pertama
ke proses child.
5. Proses child melakukan proses pembalikan string.
6. String yang sudah dibalik dikirim melalui pipa kedua ke parent
7. String dari child dibaca oleh parent dari pipa kedua dan dicetak ke layar hasil
pembalikan stringnya.

Source Code Soal Wajib Modul 2

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char array[100];
void
read_from_pipe (int file)
{
FILE *stream;
int c;
int i=0;
stream = fdopen (file, "r");
while ((c = fgetc (stream)) != EOF){
array[i]=c;
i++;
}
fclose (stream);
}

void
write_to_pipe (int file,char arr[],int length)
{
FILE *stream;
stream = fdopen (file, "w");
int i=0;
for(i=0;i<length;i++){
fprintf (stream, "%c",arr[i]);
}
fclose (stream);
}
int
main (void)
{
pid_t pid;
int mypipe[2];
int mypipe2[2];

int i=0;
char array_input[100];
/* Create the pipe. */
printf("Masukkan stringnya : ");
gets(array_input);
int length=strlen(array_input);
if (pipe (mypipe))
{
fprintf (stderr, "Pipe failed.\n");
return EXIT_FAILURE;
}
pipe(mypipe2);
pid = fork ();
if (pid == (pid_t) 0)
{
/* This is the child process.
Close other end first. */
//baca dulu dari pipe
close (mypipe[1]);
read_from_pipe (mypipe[0]);
printf("Sebelum : \n");
i=0;
for(i=0;i<strlen(array_input);i++) printf("%c",array_input[i]);
printf("\n");
close (mypipe[0]);
char temp[15];
int j = length-1;
i=0;
for(i=0;i<length;i++){
temp[i]=array[j];
j--;
}
i=0;
for(i=0;i<length;i++){
array[i]=temp[i];
}

close (mypipe2[0]);
write_to_pipe (mypipe2[1],array,strlen(array));
close(mypipe2[1]);
return EXIT_SUCCESS;
}
else if (pid < (pid_t) 0)
{
/* The fork failed. */
fprintf (stderr, "Fork failed.\n");
return EXIT_FAILURE;
}
else
{
/* This is the parent process.
Close other end first. */
//tulis ke pipe ke proses anak
close (mypipe[0]);
write_to_pipe (mypipe[1],array_input,strlen(array_input));
close (mypipe[1]);
//baca dari pipe hasil olahan proses anak
printf("Sesudah : \n");
close (mypipe2[1]);
read_from_pipe (mypipe2[0]);
int i=0;
 for(i=0;i<strlen(array);i++) printf("%c",array[i]);
printf("\n");
close (mypipe2[0]);
// write_to_pipe (mypipe[1],10);*/
return EXIT_SUCCESS;
}
}
SOAL PRAKTIKUM : SHIFT 11

11. Buatlah program manajemen file yang dilengkapi fitur :

1. membuat file dengan hak akses 755
2. menghapus file
3. mengetahui ukuran file
4. mengopi file
5. memindahkan atau mengubah nama file

Algoritma dan Penjelasan

1. Terdapat pilihan menu program, yaitu
1. Buat File
2. Hapus file
3. Rename File
4. Cek Ukuran File
5. Copy File
6. Keluar
Disini user diminta untuk memasukkan pilihan 1 – 6,jika inputan salah maka user
akan tetap dimintai masukan terus
2. Selama user tidak memilih pilihan 6, lakukan proses 3 – 7 :
3. Jika user memilih opsi 1, maka user akan diminta masukan nama file yang dibuat,
setelah akan di cek apakah file tersebut sudah ada apa belum,
3.1 Jika file sudah ada, maka kembali ke no 1
3.2 Jika belum, maka kirim sinyal 40 ke child melalui pipe dan child akan
melakukan perintah system touch [nama_file] chmod 755
4. Jika user memilih opsi 2, maka user akan diminta masukan nama file yang akan
dihapus, setelah akan di cek apakah file tersebut sudah ada apa belum,
4.1 Jika file belum ada, maka kembali ke no 1
4.2 Jika sudah, maka kirim sinyal 45 ke child melalui pipe dan child akan
melakukan perintah system rem [nama_file]
5. Jika user memilih opsi 3, maka user akan diminta masukan nama file yang akan
di-rename dan nama file baru-nya, setelah akan di cek apakah file tersebut sudah
ada apa belum,
5.1 Jika file asal belum ada atau file tujuan sudah ada, maka kembali ke no 1
5.2 Jika sudah, maka kirim sinyal 50 ke child melalui pipe dan child akan
melakukan perintah system mv [nama_file_asal] [nama_file_tujuan]
6. Jika user memilih opsi 4, maka user akan diminta masukan nama file yang akan
dicek, setelah akan di cek apakah file tersebut sudah ada apa belum,
 6.1 Jika file belum ada, maka kembali ke no 1
6.2 Jika sudah, maka kirim sinyal 55 ke child melalui pipe dan child akan
melakukan perintah system du -h [nama_file] | awk '{print $1}'
7. Jika user memilih opsi 5, maka user akan diminta masukan nama file yang akan
di-copy dan nama file baru-nya, setelah akan di cek apakah file tersebut sudah
ada apa belum,
7.1 Jika file asal belum ada atau file tujuan sudah ada, maka kembali ke no 1
7.2 Selain itu, maka kirim sinyal 50 ke child melalui pipe dan child akan
melakukan perintah system cp [nama_file_asal] [nama_file_tujuan]
8. Selesai

Source Code Soal Shift 11 Modul 2

#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

char array[100];
void sighup1();
void sighup2();
void sighup3();
void sighup4();
void sighup5();
void sigint();
void sigquit();
void read_from_pipe (int file);
void write_to_pipe (int file,char arr[],int length);

main()
{
int pid;
int opsi=1;
int mypipe[2];
//int i=0;
char array_input[100];
char array_input2[100];
char pil[100];
int error=0;
while(opsi != 6)
{
error=0;
system("clear");
printf("+++++++++++++++++++++++++++++++++++++++++++\nFile Manager with
Signalling Implementation\n+++++++++++++++++++++++++++++++++++++++++++\n");
printf("Opsi :\n1. Buat File\n2. Hapus file\n3. Rename\n4. Cek File\n5.
Copy File\n6. Keluar\n");
printf("Masukkan pilihan anda : ");
scanf("%s",pil);
opsi=atoi(pil);
//scanf("%d",&opsi);
if(opsi>0 && opsi<6){
printf("Masukkan nama file : ");
scanf("%s",&array_input);
FILE *temp;
if(opsi==1 && (temp=fopen(array_input,"r"))!=0){
printf("File sudah ada,Ulangi lagi...\n");
error=1;
 fclose(temp);
//exit(0);
}
if(error==0 && opsi>1 && opsi <6 &&
(temp=fopen(array_input,"r"))==0){
printf("File tidak ditemukan,Ulangi lagi...\n");
error=1;
//fclose(temp);
//exit(0);
}
if(error==0 && !(opsi==1||opsi==2||opsi==4)){
printf("Masukkan nama file tujuan : ");
scanf("%s",&array_input2);
if((temp=fopen(array_input2,"r"))!=0){
printf("File Tujuan sudah ada,Ulangi lagi...\n ");
fclose(temp);
error=1;
//exit(0);
}
strcat(array_input," ");
strcat(array_input,array_input2);
}
}
else if(opsi<1 && opsi>6)
{
printf("Pilihan hanya tersedia 1 - 6...\n");
error=1;
sleep(1);
}
if(error==0){
/* get child process */
pipe(mypipe);
if ((pid = fork()) < 0) {
perror("fork");
// exit(1);
}
if (pid == 0)
{ /* child */
close (mypipe[1]);
read_from_pipe (mypipe[0]);
signal(40,sighup1); /* set function calls */
signal(45,sighup2);
signal(50,sighup3);
signal(55,sighup4);
signal(60,sighup5);
signal(SIGQUIT, sigquit);
for(;;); /* loop for ever */
}
else /* parent */
{ /* pid hold id of child */
if(opsi==1){
close (mypipe[0]);
write_to_pipe (mypipe[1],array_input,strlen(array_input));
printf("\nPARENT: sending SIGNAL\n\n");
kill(pid,40);
}
else if(opsi==2){
close (mypipe[0]);
write_to_pipe (mypipe[1],array_input,strlen(array_input));
printf("\nPARENT: sending SIGNAL\n\n");
kill(pid,45);
}
else if(opsi==3){
close (mypipe[0]);
write_to_pipe (mypipe[1],array_input,strlen(array_input));
printf("\nPARENT: sending SIGNAL\n\n");
kill(pid,50);
}
else if(opsi==4){
 close (mypipe[0]);
write_to_pipe
(mypipe[1],array_input,strlen(array_input));
printf("\nPARENT: Ukuran file : \n\n");
kill(pid,55);
}
else if(opsi==5){
close (mypipe[0]);
write_to_pipe
(mypipe[1],array_input,strlen(array_input));
printf("\nPARENT: Ukuran file : \n\n");
kill(pid,60);
}
else if(opsi==6){
printf("PARENT: sending SIGQUIT\n\n");
kill(pid,SIGQUIT);
}
sleep(1); /* pause for 3 secs */
}
}
else{
//char c =getchar();
sleep(2); /* pause for 3 secs */
}
}
}

void sighup1()
{
signal(40,sighup1); /* reset signal */
int i=0;
char command[100]="touch ";
strcat(command,array);
for(i=0;i<strlen(command);i++) printf("%c",command[i]);
system(command);
strcpy(command,"chmod 755 ");
strcat(command,array);
system(command);
printf("\nCHILD: Proses 1 sukses\n");
exit(0);
}

void sighup2()
{
signal(45,sighup2); /* reset signal */
int i=0;
char command[100]="rm ";
strcat(command,array);
for(i=0;i<strlen(command);i++) printf("%c",command[i]);
system(command);
printf("\nCHILD: Proses 2 Sukses\n");
exit(0);
}

void sighup3()
{
signal(50,sighup3); /* reset signal */
int i=0;
char command[100]="mv ";
strcat(command,array);
for(i=0;i<strlen(command);i++) printf("%c",command[i]);
system(command);
printf("\nCHILD: Proses 3 Sukses\n");
exit(0);
}

void sighup4()
{
signal(55,sighup3); /* reset signal */
 int i=0;
char command[100]="du -h ";
strcat(command,array);
strcat(command," | awk '{print $1}'");
//for(i=0;i<strlen(command);i++) printf("%c",command[i]);

system(command);
printf("\nCHILD: Proses 4 Sukses\n");
exit(0);
}

void sighup5()
{
signal(60,sighup5); /* reset signal */
int i=0;
char command[100]="cp ";
strcat(command,array);
for(i=0;i<strlen(command);i++) printf("%c",command[i]);
system(command);
printf("\nCHILD: Proses 6 Sukses\n");
exit(0);
}

void sigint()
{
signal(SIGINT,sigint); /* reset signal */
printf("CHILD: I have received a SIGINT\n");
}

void sigquit()
{
printf("My DADDY has Killed me!!!\n");
exit(0);
}

void
read_from_pipe (int file)
{
FILE *stream;
int c;
int i=0;
stream = fdopen (file, "r");
while ((c = fgetc (stream)) != EOF){
array[i]=c;
i++;
}
fclose (stream);
}

void
write_to_pipe (int file,char arr[],int length)
{
FILE *stream;
stream = fdopen (file, "w");
int i=0;
for(i=0;i<length;i++){
fprintf (stream, "%c",arr[i]);
}
fclose (stream);
}