Esercizi con System Call - Revision history

Aletri: /* Client */ add more sleep to timer to get long messages

2016-04-26T14:32:20Z

Client: add more sleep to timer to get long messages

Aletri: /* Server */

2016-04-26T14:27:27Z

Server

Aletri: /* Client */

2016-04-26T14:26:29Z

Client

Aletri: /* Client */

2016-04-26T14:26:10Z

Client

Aletri: Esperimento: secret channel with inotify

2016-04-26T14:25:02Z

Esperimento: secret channel with inotify

Show changes

S.G at 17:59, 21 March 2016

2016-03-21T17:59:00Z

Simone at 15:44, 12 March 2016

2016-03-12T15:44:48Z

Simone at 15:44, 12 March 2016

2016-03-12T15:44:15Z

Alessio at 21:44, 24 November 2015

2015-11-24T21:44:29Z

Simone: /* programma 0 */

2015-11-03T12:37:28Z

programma 0

@@ Line 555: / Line 555: @@
          const struct timespec timer = {
                  .tv_sec = 0,
-                 .tv_nsec = 500000
+                 .tv_nsec = 5000000
          };
          struct timespec s;

@@ Line 440: / Line 440: @@
          int nfds;
          int poll_num;
          unsigned char message_str [4096] = "";
          int count = 0;

@@ Line 586: / Line 586: @@
+                 }
-                /*sleep (1);*/
                  nanosleep(&timer,&s);

← Older revision		Revision as of 14:26, 26 April 2016
Line 573:		Line 573:


−	~~/printf ("%c",buffer[a]);/~~	+
	if (buffer[a] == '0'){		if (buffer[a] == '0'){

← Older revision		Revision as of 17:59, 21 March 2016
Line 214:		Line 214:
	è possibile anche fornire un pid come argomento per comunicare con processi diversi.		è possibile anche fornire un pid come argomento per comunicare con processi diversi.
	([[User:Simone\|Simone]])		([[User:Simone\|Simone]])
		+
		+	== programma 3 (Fork del programma 2 di ([[User:Simone\|Simone]]) )==
		+	Sono state effettuate delle piccole modifiche rispetto al programma 2 e inoltre sono stati aggiunti dei commenti per rendere più intuitivo e leggibile il codice.
		+	<syntaxhighlight lang="C">
		+	#define _GNU_SOURCE
		+	#include <stdio.h>
		+	#include <signal.h>
		+	#include <stdlib.h>
		+
		+	#define BUFSIZE 1024
		+	sigset_t receiverMask;
		+	sigset_t senderMask;
		+	static int bit;
		+
		+	void receiverAction(int num, siginfo_t info, void useless) {
		+	if (num == SIGCHLD) // Se il processo figlio del ricevente è terminato
		+	bit = EOF;
		+	else{
		+	bit = (num == SIGUSR2); // Codifico 1 con il segnale SIGUSR2 e 0 con SIGUSR1
		+	kill(info->si_pid, SIGUSR1); // Invio il segnale SIGUSR1 al mittente
		+	}
		+	}
		+
		+	void senderAction(int num, siginfo_t info, void useless) {
		+	return;
		+	}
		+
		+	void write_bin(unsigned char x, pid_t recv){ / Funzione che riguarda il mittente */
		+	unsigned int i;
		+	for(i=0x80; i>0; i>>=1){ // Parto da 10000000, man mano shifto a destra, 01000000, 00100000 ecc ecc, fino a 00000000
		+	kill(*recv, (x & i) ? SIGUSR2 : SIGUSR1); // Invio segnale al ricevente
		+	sigsuspend(&senderMask); // Attendo segnale di ritorno
		+	}
		+	}
		+
		+	int readbit(void){
		+	sigsuspend(&receiverMask); // Sospende il processo e attende un segnale
		+	return bit;
		+	}
		+
		+	int read_char(){ /* Funzione che riguarda il ricevente */
		+	int i, c;
		+	for (i = c = 0; i < 8; i++) {
		+	int n = readbit();
		+	if (n<0)
		+	return EOF;
		+	c = c<<1 \| n;
		+	}
		+	}
		+
		+	void main(int argc, char *argv[]){
		+
		+	if (argc == 1) {
		+	pid_t pid = fork ();
		+
		+	if(pid > 0){ /* PROCESSO PADRE (PROCESSO RICEVENTE) */
		+	int c;
		+
		+	/*
		+	* Il valore di sa_flag permette di specificare vari aspetti del comportamento di sigaction:
		+	* SA_SIGINFO specifica che si vuole usare un gestore in forma estesa usando sa_sigaction al
		+	* posto di sa_handler. Il valore di sa_sigaction specifica la funzione da chiamare, permettendo
		+	* di usare un gestore piu complesso, in grado di ricevere informazioni piu dettagliate dal
		+	* sistema, attraverso la struttura siginfo_t
		+	*/
		+	struct sigaction sa = {
		+	.sa_sigaction = receiverAction,
		+	.sa_flags = SA_SIGINFO
		+	};
		+
		+	printf("%d\n", getpid());
		+
		+	/* Inserisci tutti i segnali nell'insieme receiverMask */
		+	sigfillset(&receiverMask);
		+
		+	/* Elimina il segnale SIGINT dall'insieme receiverMask */
		+	sigdelset(&receiverMask, SIGINT);
		+
		+	/* Setta la maschera dei segnali del processo con l'insieme receiverMask.
		+	* Il valore NULL indica che la maschera attuale del processo non verrà salvata. */
		+	sigprocmask(SIG_SETMASK, &receiverMask, NULL);
		+
		+	/* Elimina il segnale SIGCHLD, SIGUSR1 e SIGUSR2 dall'insieme receiverMask */
		+	sigdelset(&receiverMask, SIGCHLD);
		+	sigdelset(&receiverMask, SIGUSR1);
		+	sigdelset(&receiverMask, SIGUSR2);
		+
		+	/* Setta l'azione sa per i segnali SIGUSR1, SIGUSR2 e SIGCHLD.
		+	* Il valore NULL indica che l’azione corrente non viene restituita indietro. */
		+	sigaction(SIGUSR1, &sa, NULL);
		+	sigaction(SIGUSR2, &sa, NULL);
		+	sigaction(SIGCHLD, &sa, NULL);
		+
		+	while ((c = read_char()) != EOF)
		+	putchar(c);
		+
		+	}
		+	else if(pid == 0){ // PROCESSO FIGLIO
		+	char *cmd;
		+	pid_t ppid = getppid(); /* PID del processo padre (ricevente) */
		+
		+	/* Avvio un altro terminale eseguendo lo stesso programma con parametri di input */
		+	asprintf(&cmd, "xterm -e /proc/%d/exe %d", ppid, ppid);
		+	system(cmd);
		+	exit(1);
		+	}
		+	else{ // Errore Fork
		+	fprintf(stderr, "Errore fork");
		+	exit(1);
		+	}
		+	} else { /* PROCESSO MITTENTE */
		+	unsigned char buf[BUFSIZE], *read;
		+	pid_t receiver = atoi(argv[1]); // Pid del ricevente
		+
		+	/* Setto una banale azione (usr1action) alla ricezione del segnale SIGUSR1*/
		+	struct sigaction sa = {.sa_sigaction = senderAction};
		+	sigaction(SIGUSR1, &sa, NULL);
		+
		+	printf("%d->%d\n",getpid(),receiver);
		+
		+	sigfillset(&senderMask); // Inserisco tutti i segnali nell'insieme senderMask
		+	sigdelset(&senderMask, SIGINT); // e cancello dall'insieme il segnale SIGINT.
		+	sigprocmask(SIG_SETMASK,&senderMask,NULL); // Setto la maschera creata per il processo corrente, senza salvare la precedente.
		+	sigdelset(&senderMask,SIGUSR1); // Elimino il segnale SIGUSR1 dall'insieme.
		+	if (argc == 2){ // Se i paramentri in input sono 2
		+	while ((read = fgets(buf,BUFSIZE,stdin)) != NULL){ // Leggo dallo stdin
		+	while (*read) // Leggo tutta la stringa
		+	write_bin(*read++, &receiver); // Invio ogni singolo carattere della stringa al ricevente
		+	}
		+	}
		+	printf("\n");
		+	}
		+	}
		+	</syntaxhighlight>
		+	([[User:S.G\|S.G]])

← Older revision		Revision as of 15:44, 12 March 2016
Line 213:		Line 213:
	Possiamo quindi sfruttare il fatto che i due processi (essendo padre e figlio) conoscono i rispettivi pid e quindi automatizzare questa parte senza fornire alcun pid in input.		Possiamo quindi sfruttare il fatto che i due processi (essendo padre e figlio) conoscono i rispettivi pid e quindi automatizzare questa parte senza fornire alcun pid in input.
	è possibile anche fornire un pid come argomento per comunicare con processi diversi.		è possibile anche fornire un pid come argomento per comunicare con processi diversi.
		+	([[User:Simone\|Simone]])

← Older revision		Revision as of 15:44, 12 March 2016
Line 80:		Line 80:

	([[User:Alessio\|Alessio]])		([[User:Alessio\|Alessio]])
		+
		+	== programma 2 ==
		+	segnali + fork
		+	<syntaxhighlight lang="C">
		+	#define _GNU_SOURCE
		+	#include <stdio.h>
		+	#include <string.h>
		+	#include <unistd.h>
		+	#include <signal.h>
		+	#include <stdlib.h>
		+	#include <unistd.h>
		+	#include <pty.h>
		+	#include <utmp.h>
		+	#include <sys/types.h>
		+	#include <sys/wait.h>
		+
		+	#define BUFSIZE 1024
		+
		+	sigset_t usr12mask;
		+	sigset_t usr1mask;
		+	int status;
		+	int fd, fdout;
		+	char name[80];
		+	static int bit;
		+	char *ar[2] = {"bash", NULL};
		+
		+	void usr12action(int num, siginfo_t info, void useless) {
		+	if (num == SIGCHLD)
		+	bit=-1;
		+	else {
		+	bit = (num == SIGUSR2);
		+	kill(info->si_pid, SIGUSR1);
		+	}
		+	}
		+
		+	void usr1action(int num, siginfo_t info, void useless) {
		+	}
		+
		+	void char_to_bin(unsigned char x, void *rec){
		+	int i;
		+	pid_t *r = rec;
		+
		+	for(i=7; i>=0; i--){
		+	char f = x >> i & 1;
		+	kill(*r,f?SIGUSR2:SIGUSR1);
		+	sigsuspend(&usr1mask);
		+	}
		+	}
		+
		+	int readbit(void *v)
		+	{
		+	sigsuspend(&usr12mask);
		+	return bit;
		+	}
		+
		+	int bin2char(int (f)(void opaque), void *opaque) {
		+	int i;
		+	int c;
		+	for (i=c=0; i<8; i++) {
		+	int n=f(opaque);
		+	if (n<0)
		+	return -1;
		+	c = c<<1 \| n;
		+	}
		+	}
		+
		+	void main(int argc, char *argv[]){
		+
		+	if (argc == 1) {
		+	pid_t pid = fork ();
		+
		+	if(pid > 0){
		+	int c;
		+
		+	static struct sigaction sa={
		+	.sa_sigaction=usr12action,
		+	.sa_flags=SA_SIGINFO
		+	};
		+
		+	printf("%d\n",getpid());
		+
		+	sigfillset(&usr12mask);
		+	sigdelset(&usr12mask,SIGINT);
		+	sigprocmask(SIG_SETMASK,&usr12mask,NULL);
		+	sigdelset(&usr12mask,SIGCHLD);
		+	sigdelset(&usr12mask,SIGUSR1);
		+	sigdelset(&usr12mask,SIGUSR2);
		+	sigaction(SIGUSR1,&sa,NULL);
		+	sigaction(SIGUSR2,&sa,NULL);
		+	sigaction(SIGCHLD,&sa,NULL);
		+
		+	while ((c=bin2char(readbit,stdin)) != EOF)
		+	putchar(c);
		+	if (waitpid(pid, &status, 0) != pid) status = -1;
		+	}
		+	else {
		+	char *path;
		+	char *sppid;
		+	pid_t ppid=getppid();
		+	asprintf(&path,"/proc/%d/exe",ppid);
		+	asprintf(&sppid,"%d",ppid);
		+	execl("/usr/bin/xterm", "xterm", "-e", path, sppid, (void *) 0);
		+	exit(1);
		+	}
		+	} else {
		+	unsigned char buf[BUFSIZE];
		+	unsigned char *s;
		+	pid_t receiver=atoi(argv[1]);
		+
		+	static struct sigaction sa={.sa_sigaction=usr1action};
		+	sigaction(SIGUSR1,&sa,NULL);
		+
		+	printf("%d->%d\n",getpid(),receiver);
		+	sigfillset(&usr1mask);
		+	sigdelset(&usr1mask,SIGINT);
		+	sigprocmask(SIG_SETMASK,&usr1mask,NULL);
		+	sigdelset(&usr1mask,SIGUSR1);
		+	if (argc == 2){
		+	while ((s=fgets(buf,BUFSIZE,stdin))!=NULL){
		+	while (*s){
		+	char_to_bin(*s++, &receiver);
		+	}
		+	}
		+	}
		+	printf("\n");
		+	}
		+	}
		+	</syntaxhighlight>
		+
		+	il programma in questione "unisce" di fatto i due programmi sigsend e sigrec.
		+	l'idea è quella che venga lanciato un unico processo e aprire un nuovo terminale dove contiunare l'esecuzione del figlio creato attraverso la fork.
		+	Possiamo quindi sfruttare il fatto che i due processi (essendo padre e figlio) conoscono i rispettivi pid e quindi automatizzare questa parte senza fornire alcun pid in input.
		+	è possibile anche fornire un pid come argomento per comunicare con processi diversi.

← Older revision		Revision as of 21:44, 24 November 2015
Line 27:		Line 27:

	([[User:Simone\|Simone]])		([[User:Simone\|Simone]])
		+
		+	== programma 1 ==
		+	Open() Write() Read()
		+
		+	<syntaxhighlight lang="C">
		+	/IL PROGRAMMA APRE UN FILE SUL QUALE FA DELLE OPERAZIONI DI LETTURA E SCRITTURA/
		+	#include <sys/types.h>
		+	#include <sys/stat.h>
		+	#include <fcntl.h>
		+	#include <stdio.h>
		+	#include <errno.h>
		+	#include <stdlib.h>
		+	#include <unistd.h>
		+
		+	#define MAX_CHAR 100000
		+
		+	int main(int argc, char *argv[]){
		+
		+	int fd, c, n_read;
		+	int fine = EOF;
		+	int index = 0;
		+	char arr[MAX_CHAR];
		+	char c_arr_read[MAX_CHAR];
		+	const char *path = //inserisci qui il percorso del file che vuoi aprire, se il file specificato non esiste, la open fallisce e il
		+	//programma termina con un codice di errore
		+	fd = open(path, O_RDWR);
		+
		+	if(fd == -1){
		+	printf("fd: %d\n", fd);
		+	printf("Open failed, Err: %d\n", errno);
		+	exit(1);
		+	}
		+
		+	if( (n_read = read(fd, &c_arr_read, MAX_CHAR)) > 0 ) {
		+	printf("file non vuoto\nbytes letti: %d\n", n_read);
		+	write(fd, &fine, 0);
		+	} else printf("file vuoto\nbytes letti: %d\n", n_read);
		+
		+	//printf("fd: %d\n", fd);
		+	printf("Open().\n");
		+	while((c = getchar()) != EOF && index < MAX_CHAR){
		+	arr[index] = c;
		+	index++;
		+	}
		+	//printf("sizeof arr: %d\n", sizeof(arr));
		+	write(fd, &arr, index);
		+
		+	return 0;
		+	}
		+	</syntaxhighlight>
		+
		+
		+	([[User:Alessio\|Alessio]])

← Older revision		Revision as of 12:37, 3 November 2015
Line 26:		Line 26:
	il programma stampa entrambi i risultati perché la system call fork() crea un processo figlio identico al padre, questa system call ha come valore di ritorno al thread padre il pid del processo figlio (che essendo diverso da 0 è true) e al thread figlio ritorna 0, quindi il processo padre riceve un valore diverso da 0 (pid del figlio) e stampa true, mentre il processo figlio riceve 0, non entra nel if e stampa, ovviamente false.		il programma stampa entrambi i risultati perché la system call fork() crea un processo figlio identico al padre, questa system call ha come valore di ritorno al thread padre il pid del processo figlio (che essendo diverso da 0 è true) e al thread figlio ritorna 0, quindi il processo padre riceve un valore diverso da 0 (pid del figlio) e stampa true, mentre il processo figlio riceve 0, non entra nel if e stampa, ovviamente false.

−	Simone ~~preite~~	+	([[User:Simone\|Simone]])