Sistemi Operativi - User contributions [en]

Esercizi con System Call

2016-04-26T14:32:20Z

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

Questi programmi contengono esempi di uso delle System-Call.

Il consiglio e' di compilarli, provarli e capirne passo-passo il funzionamento. (o spiegare perche' non funzionino).

Ovviamente potete proporre ulteriori esempi.
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 08:03, 2 November 2015 (CET)

== programma 0 ==
Il gatto di Schrödinger: Fork e' vero o falso?

<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>

int main(int argc, char* argv[]) {
if (fork())
printf("fork is true\n");
else
printf("fork is false\n");
usleep(100000);
return 0;
}
</syntaxhighlight>

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.

([[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]])

== 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.
([[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]])

= programma 5 =
==Secret channel with inotify==
Stavo leggendo sul libro che e' possibile creare un canale di comunicazione segreto praticamente con ogni cosa all'interno di un sistema UNIX. In particolare mi ha interessato il caso di creare un canale mono direzionale tramite l'apertura dei file in lettura o scrittura e ho voluto provare a implementarne uno. Questi canali sono quasi impossibili da scovare per un amministratore di sistema e potrebbero permettere lo scambio di informazioni illecite.
Una cosa interessante e' che a quanto pare il kernel ha bisogno di qualche millisecondo per eseguire la inotify e che una precedente implementazione senza delay portava all'arrivo di messaggi sbagliati.

===Server===

<syntaxhighlight lang="C">

#include <errno.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include <unistd.h>
#include <string.h>

void printChar(int n){

int a;
char c;
unsigned char buffer[8];
memset(buffer, '0', sizeof(buffer));
int i = 7;
while (n){

if(n & 1)
buffer[i]= '1';
i--;
n >>= 1;

}
c = strtol(buffer, 0, 2);
printf("%c", c);

}

static void handle_events (int fd, int wd, char *bin_message,int *current_bit){
char buf [4096]
__attribute__ ((aligned(__alignof__(struct inotify_event))));
const struct inotify_event *event;
int i;
ssize_t len;
char *ptr;

//loop while inotify events can be read from the fd
for (;;){
len = read (fd, buf, sizeof (buf));
if (len == -1 && errno != EAGAIN){
perror ("read");
exit (EXIT_FAILURE);
}

//if the read returns with the errono EAGAIN exit from the loop
if (len <= 0)
break;
//loop between all events in the buffer
for (ptr = buf; ptr < buf + len;
ptr += sizeof(struct inotify_event) + event->len){
event = (const struct inotify_event *) ptr;

if (event->mask & IN_CLOSE_NOWRITE){
//received 1

*bin_message |= 0x01;
}
if (event->mask & IN_CLOSE_WRITE){

//received 0
//do nothing to leave 0

}

}
}
}

void main () {
char buf;
int fd;
int wd;
struct pollfd fds [2];
int nfds;
int poll_num;
unsigned char message_str [4096] = "";
int count = 0;
int bit_wrote = 0;

char path [100] = "/inofify/watched";
int t;

//create the file descriptor where inotify events has to be read
fd = inotify_init1(IN_NONBLOCK);
if (fd == -1) {
perror("inotify_init1");
exit(EXIT_FAILURE);
}

wd = inotify_add_watch (fd, path, IN_CLOSE_NOWRITE | IN_CLOSE_WRITE);

if (wd == -1 ){
fprintf (stderr, "Cannot watch '%s' \n", path);
perror ("inotify_add_watch");
exit(EXIT_FAILURE);
}

//prepare for the polling on the fd

nfds = 2;
fds[0].fd = STDIN_FILENO;
fds[0].events = POLLIN;
fds[1].fd = fd;
fds[1].events = POLLIN;

printf ("Listening for events... Press ENTER to terminate and show the message\n");
while (1){

poll_num = poll(fds,nfds, -1);
if (poll_num == -1){
if (errno == EINTR)
continue;
perror ("poll");
exit (EXIT_FAILURE);

}
if (poll_num > 0){
if (fds[0].revents & POLLIN){

//exit on ENTER key pressed emptying the stdin
while (read (STDIN_FILENO,&buf,1) > 0 && buf != '\n') continue;
break;

}
//notify an event occurred
if (fds[1].revents & POLLIN ){
if (bit_wrote < 8){
printf("..");
fflush(stdout);
handle_events (fd,wd,&message_str[count],&bit_wrote);
if (bit_wrote < 7){
message_str[count] = message_str[count] << 0x01;
}

}
else {
bit_wrote = 0;
count += 1;
handle_events (fd,wd,&message_str[count],&bit_wrote);
}
bit_wrote += 1;
}

}
}
printf("\n**********MESSAGE***********\n");
t = 0;
while (t <= count ){

printChar(message_str[t]);
t += 1;
}
printf("\n**************************\n");
printf("\nClosing...\n");

exit(EXIT_SUCCESS);

}
</syntaxhighlight>

===Client===

<syntaxhighlight lang="C">

#include <errno.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <time.h>

void chat(int n){

int a;
int fd;
char path [] = "watched";
unsigned char buffer[8];
memset(buffer, '0', sizeof(buffer));
int i = 7;
const struct timespec timer = {
.tv_sec = 0,
.tv_nsec = 5000000
};
struct timespec s;
while (n){

if(n & 1){

buffer[i] = '1';

}
i--;
n >>= 1;

}
for (a = 0; a < 8; a++) {

if (buffer[a] == '0'){

fd = open(path,O_WRONLY);
close(fd);

}
else{

fd = open(path,O_RDONLY);
close(fd);
}

nanosleep(&timer,&s);

}

}
void main (){
char message[1024] = "";
int bit_message;
int len = 0;
int i = 0;

printf("Type in \n");

fgets(message,100,stdin);
printf("You typed: %s", message);

len = (unsigned)strlen(message);
while (i < len -1){
chat(message[i]);
i++;
}
}
</syntaxhighlight>

Alessio Trivisonno

Esercizi con System Call

2016-04-26T14:27:27Z

Aletri: /* Server */

Questi programmi contengono esempi di uso delle System-Call.

Il consiglio e' di compilarli, provarli e capirne passo-passo il funzionamento. (o spiegare perche' non funzionino).

Ovviamente potete proporre ulteriori esempi.
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 08:03, 2 November 2015 (CET)

== programma 0 ==
Il gatto di Schrödinger: Fork e' vero o falso?

<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>

int main(int argc, char* argv[]) {
if (fork())
printf("fork is true\n");
else
printf("fork is false\n");
usleep(100000);
return 0;
}
</syntaxhighlight>

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.

([[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]])

== 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.
([[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]])

= programma 5 =
==Secret channel with inotify==
Stavo leggendo sul libro che e' possibile creare un canale di comunicazione segreto praticamente con ogni cosa all'interno di un sistema UNIX. In particolare mi ha interessato il caso di creare un canale mono direzionale tramite l'apertura dei file in lettura o scrittura e ho voluto provare a implementarne uno. Questi canali sono quasi impossibili da scovare per un amministratore di sistema e potrebbero permettere lo scambio di informazioni illecite.
Una cosa interessante e' che a quanto pare il kernel ha bisogno di qualche millisecondo per eseguire la inotify e che una precedente implementazione senza delay portava all'arrivo di messaggi sbagliati.

===Server===

<syntaxhighlight lang="C">

#include <errno.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include <unistd.h>
#include <string.h>

void printChar(int n){

int a;
char c;
unsigned char buffer[8];
memset(buffer, '0', sizeof(buffer));
int i = 7;
while (n){

if(n & 1)
buffer[i]= '1';
i--;
n >>= 1;

}
c = strtol(buffer, 0, 2);
printf("%c", c);

}

static void handle_events (int fd, int wd, char *bin_message,int *current_bit){
char buf [4096]
__attribute__ ((aligned(__alignof__(struct inotify_event))));
const struct inotify_event *event;
int i;
ssize_t len;
char *ptr;

//loop while inotify events can be read from the fd
for (;;){
len = read (fd, buf, sizeof (buf));
if (len == -1 && errno != EAGAIN){
perror ("read");
exit (EXIT_FAILURE);
}

//if the read returns with the errono EAGAIN exit from the loop
if (len <= 0)
break;
//loop between all events in the buffer
for (ptr = buf; ptr < buf + len;
ptr += sizeof(struct inotify_event) + event->len){
event = (const struct inotify_event *) ptr;

if (event->mask & IN_CLOSE_NOWRITE){
//received 1

*bin_message |= 0x01;
}
if (event->mask & IN_CLOSE_WRITE){

//received 0
//do nothing to leave 0

}

}
}
}

void main () {
char buf;
int fd;
int wd;
struct pollfd fds [2];
int nfds;
int poll_num;
unsigned char message_str [4096] = "";
int count = 0;
int bit_wrote = 0;

char path [100] = "/inofify/watched";
int t;

//create the file descriptor where inotify events has to be read
fd = inotify_init1(IN_NONBLOCK);
if (fd == -1) {
perror("inotify_init1");
exit(EXIT_FAILURE);
}

wd = inotify_add_watch (fd, path, IN_CLOSE_NOWRITE | IN_CLOSE_WRITE);

if (wd == -1 ){
fprintf (stderr, "Cannot watch '%s' \n", path);
perror ("inotify_add_watch");
exit(EXIT_FAILURE);
}

//prepare for the polling on the fd

nfds = 2;
fds[0].fd = STDIN_FILENO;
fds[0].events = POLLIN;
fds[1].fd = fd;
fds[1].events = POLLIN;

printf ("Listening for events... Press ENTER to terminate and show the message\n");
while (1){

poll_num = poll(fds,nfds, -1);
if (poll_num == -1){
if (errno == EINTR)
continue;
perror ("poll");
exit (EXIT_FAILURE);

}
if (poll_num > 0){
if (fds[0].revents & POLLIN){

//exit on ENTER key pressed emptying the stdin
while (read (STDIN_FILENO,&buf,1) > 0 && buf != '\n') continue;
break;

}
//notify an event occurred
if (fds[1].revents & POLLIN ){
if (bit_wrote < 8){
printf("..");
fflush(stdout);
handle_events (fd,wd,&message_str[count],&bit_wrote);
if (bit_wrote < 7){
message_str[count] = message_str[count] << 0x01;
}

}
else {
bit_wrote = 0;
count += 1;
handle_events (fd,wd,&message_str[count],&bit_wrote);
}
bit_wrote += 1;
}

}
}
printf("\n**********MESSAGE***********\n");
t = 0;
while (t <= count ){

printChar(message_str[t]);
t += 1;
}
printf("\n**************************\n");
printf("\nClosing...\n");

exit(EXIT_SUCCESS);

}
</syntaxhighlight>

===Client===

<syntaxhighlight lang="C">

#include <errno.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <time.h>

void chat(int n){

int a;
int fd;
char path [] = "watched";
unsigned char buffer[8];
memset(buffer, '0', sizeof(buffer));
int i = 7;
const struct timespec timer = {
.tv_sec = 0,
.tv_nsec = 500000
};
struct timespec s;
while (n){

if(n & 1){

buffer[i] = '1';

}
i--;
n >>= 1;

}
for (a = 0; a < 8; a++) {

if (buffer[a] == '0'){

fd = open(path,O_WRONLY);
close(fd);

}
else{

fd = open(path,O_RDONLY);
close(fd);
}

nanosleep(&timer,&s);

}

}
void main (){
char message[1024] = "";
int bit_message;
int len = 0;
int i = 0;

printf("Type in \n");

fgets(message,100,stdin);
printf("You typed: %s", message);

len = (unsigned)strlen(message);
while (i < len -1){
chat(message[i]);
i++;
}
}
</syntaxhighlight>

Alessio Trivisonno

Esercizi con System Call

2016-04-26T14:26:29Z

Aletri: /* Client */

Questi programmi contengono esempi di uso delle System-Call.

Il consiglio e' di compilarli, provarli e capirne passo-passo il funzionamento. (o spiegare perche' non funzionino).

Ovviamente potete proporre ulteriori esempi.
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 08:03, 2 November 2015 (CET)

== programma 0 ==
Il gatto di Schrödinger: Fork e' vero o falso?

<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>

int main(int argc, char* argv[]) {
if (fork())
printf("fork is true\n");
else
printf("fork is false\n");
usleep(100000);
return 0;
}
</syntaxhighlight>

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.

([[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]])

== 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.
([[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]])

= programma 5 =
==Secret channel with inotify==
Stavo leggendo sul libro che e' possibile creare un canale di comunicazione segreto praticamente con ogni cosa all'interno di un sistema UNIX. In particolare mi ha interessato il caso di creare un canale mono direzionale tramite l'apertura dei file in lettura o scrittura e ho voluto provare a implementarne uno. Questi canali sono quasi impossibili da scovare per un amministratore di sistema e potrebbero permettere lo scambio di informazioni illecite.
Una cosa interessante e' che a quanto pare il kernel ha bisogno di qualche millisecondo per eseguire la inotify e che una precedente implementazione senza delay portava all'arrivo di messaggi sbagliati.

===Server===

<syntaxhighlight lang="C">

#include <errno.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include <unistd.h>
#include <string.h>

void printChar(int n){

int a;
char c;
unsigned char buffer[8];
memset(buffer, '0', sizeof(buffer));
int i = 7;
while (n){

if(n & 1)
buffer[i]= '1';
i--;
n >>= 1;

}
c = strtol(buffer, 0, 2);
printf("%c", c);

}

static void handle_events (int fd, int wd, char *bin_message,int *current_bit){
char buf [4096]
__attribute__ ((aligned(__alignof__(struct inotify_event))));
const struct inotify_event *event;
int i;
ssize_t len;
char *ptr;

//loop while inotify events can be read from the fd
for (;;){
len = read (fd, buf, sizeof (buf));
if (len == -1 && errno != EAGAIN){
perror ("read");
exit (EXIT_FAILURE);
}

//if the read returns with the errono EAGAIN exit from the loop
if (len <= 0)
break;
//loop between all events in the buffer
for (ptr = buf; ptr < buf + len;
ptr += sizeof(struct inotify_event) + event->len){
event = (const struct inotify_event *) ptr;

if (event->mask & IN_CLOSE_NOWRITE){
//received 1

*bin_message |= 0x01;
}
if (event->mask & IN_CLOSE_WRITE){

//received 0
//do nothing to leave 0

}

}
}
}

void main () {
char buf;
int fd;
int wd;
struct pollfd fds [2];
int nfds;
int poll_num;
/*char message = 0;*/
unsigned char message_str [4096] = "";
int count = 0;
int bit_wrote = 0;

char path [100] = "/inofify/watched";
int t;

//create the file descriptor where inotify events has to be read
fd = inotify_init1(IN_NONBLOCK);
if (fd == -1) {
perror("inotify_init1");
exit(EXIT_FAILURE);
}

wd = inotify_add_watch (fd, path, IN_CLOSE_NOWRITE | IN_CLOSE_WRITE);

if (wd == -1 ){
fprintf (stderr, "Cannot watch '%s' \n", path);
perror ("inotify_add_watch");
exit(EXIT_FAILURE);
}

//prepare for the polling on the fd

nfds = 2;
fds[0].fd = STDIN_FILENO;
fds[0].events = POLLIN;
fds[1].fd = fd;
fds[1].events = POLLIN;

printf ("Listening for events... Press ENTER to terminate and show the message\n");
while (1){

poll_num = poll(fds,nfds, -1);
if (poll_num == -1){
if (errno == EINTR)
continue;
perror ("poll");
exit (EXIT_FAILURE);

}
if (poll_num > 0){
if (fds[0].revents & POLLIN){

//exit on ENTER key pressed emptying the stdin
while (read (STDIN_FILENO,&buf,1) > 0 && buf != '\n') continue;
break;

}
//notify an event occurred
if (fds[1].revents & POLLIN ){
if (bit_wrote < 8){
printf("..");
fflush(stdout);
handle_events (fd,wd,&message_str[count],&bit_wrote);
if (bit_wrote < 7){
message_str[count] = message_str[count] << 0x01;
}

}
else {
bit_wrote = 0;
count += 1;
handle_events (fd,wd,&message_str[count],&bit_wrote);
}
bit_wrote += 1;
}

}
}
printf("\n**********MESSAGE***********\n");
t = 0;
while (t <= count ){

printChar(message_str[t]);
t += 1;
}
printf("\n**************************\n");
printf("\nClosing...\n");

exit(EXIT_SUCCESS);

}
</syntaxhighlight>

===Client===

<syntaxhighlight lang="C">

#include <errno.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <time.h>

void chat(int n){

int a;
int fd;
char path [] = "watched";
unsigned char buffer[8];
memset(buffer, '0', sizeof(buffer));
int i = 7;
const struct timespec timer = {
.tv_sec = 0,
.tv_nsec = 500000
};
struct timespec s;
while (n){

if(n & 1){

buffer[i] = '1';

}
i--;
n >>= 1;

}
for (a = 0; a < 8; a++) {

if (buffer[a] == '0'){

fd = open(path,O_WRONLY);
close(fd);

}
else{

fd = open(path,O_RDONLY);
close(fd);
}

nanosleep(&timer,&s);

}

}
void main (){
char message[1024] = "";
int bit_message;
int len = 0;
int i = 0;

printf("Type in \n");

fgets(message,100,stdin);
printf("You typed: %s", message);

len = (unsigned)strlen(message);
while (i < len -1){
chat(message[i]);
i++;
}
}
</syntaxhighlight>

Alessio Trivisonno

Esercizi con System Call

2016-04-26T14:26:10Z

Aletri: /* Client */

Questi programmi contengono esempi di uso delle System-Call.

Il consiglio e' di compilarli, provarli e capirne passo-passo il funzionamento. (o spiegare perche' non funzionino).

Ovviamente potete proporre ulteriori esempi.
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 08:03, 2 November 2015 (CET)

== programma 0 ==
Il gatto di Schrödinger: Fork e' vero o falso?

<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>

int main(int argc, char* argv[]) {
if (fork())
printf("fork is true\n");
else
printf("fork is false\n");
usleep(100000);
return 0;
}
</syntaxhighlight>

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.

([[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]])

== 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.
([[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]])

= programma 5 =
==Secret channel with inotify==
Stavo leggendo sul libro che e' possibile creare un canale di comunicazione segreto praticamente con ogni cosa all'interno di un sistema UNIX. In particolare mi ha interessato il caso di creare un canale mono direzionale tramite l'apertura dei file in lettura o scrittura e ho voluto provare a implementarne uno. Questi canali sono quasi impossibili da scovare per un amministratore di sistema e potrebbero permettere lo scambio di informazioni illecite.
Una cosa interessante e' che a quanto pare il kernel ha bisogno di qualche millisecondo per eseguire la inotify e che una precedente implementazione senza delay portava all'arrivo di messaggi sbagliati.

===Server===

<syntaxhighlight lang="C">

#include <errno.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include <unistd.h>
#include <string.h>

void printChar(int n){

int a;
char c;
unsigned char buffer[8];
memset(buffer, '0', sizeof(buffer));
int i = 7;
while (n){

if(n & 1)
buffer[i]= '1';
i--;
n >>= 1;

}
c = strtol(buffer, 0, 2);
printf("%c", c);

}

static void handle_events (int fd, int wd, char *bin_message,int *current_bit){
char buf [4096]
__attribute__ ((aligned(__alignof__(struct inotify_event))));
const struct inotify_event *event;
int i;
ssize_t len;
char *ptr;

//loop while inotify events can be read from the fd
for (;;){
len = read (fd, buf, sizeof (buf));
if (len == -1 && errno != EAGAIN){
perror ("read");
exit (EXIT_FAILURE);
}

//if the read returns with the errono EAGAIN exit from the loop
if (len <= 0)
break;
//loop between all events in the buffer
for (ptr = buf; ptr < buf + len;
ptr += sizeof(struct inotify_event) + event->len){
event = (const struct inotify_event *) ptr;

if (event->mask & IN_CLOSE_NOWRITE){
//received 1

*bin_message |= 0x01;
}
if (event->mask & IN_CLOSE_WRITE){

//received 0
//do nothing to leave 0

}

}
}
}

void main () {
char buf;
int fd;
int wd;
struct pollfd fds [2];
int nfds;
int poll_num;
/*char message = 0;*/
unsigned char message_str [4096] = "";
int count = 0;
int bit_wrote = 0;

char path [100] = "/inofify/watched";
int t;

//create the file descriptor where inotify events has to be read
fd = inotify_init1(IN_NONBLOCK);
if (fd == -1) {
perror("inotify_init1");
exit(EXIT_FAILURE);
}

wd = inotify_add_watch (fd, path, IN_CLOSE_NOWRITE | IN_CLOSE_WRITE);

if (wd == -1 ){
fprintf (stderr, "Cannot watch '%s' \n", path);
perror ("inotify_add_watch");
exit(EXIT_FAILURE);
}

//prepare for the polling on the fd

nfds = 2;
fds[0].fd = STDIN_FILENO;
fds[0].events = POLLIN;
fds[1].fd = fd;
fds[1].events = POLLIN;

printf ("Listening for events... Press ENTER to terminate and show the message\n");
while (1){

poll_num = poll(fds,nfds, -1);
if (poll_num == -1){
if (errno == EINTR)
continue;
perror ("poll");
exit (EXIT_FAILURE);

}
if (poll_num > 0){
if (fds[0].revents & POLLIN){

//exit on ENTER key pressed emptying the stdin
while (read (STDIN_FILENO,&buf,1) > 0 && buf != '\n') continue;
break;

}
//notify an event occurred
if (fds[1].revents & POLLIN ){
if (bit_wrote < 8){
printf("..");
fflush(stdout);
handle_events (fd,wd,&message_str[count],&bit_wrote);
if (bit_wrote < 7){
message_str[count] = message_str[count] << 0x01;
}

}
else {
bit_wrote = 0;
count += 1;
handle_events (fd,wd,&message_str[count],&bit_wrote);
}
bit_wrote += 1;
}

}
}
printf("\n**********MESSAGE***********\n");
t = 0;
while (t <= count ){

printChar(message_str[t]);
t += 1;
}
printf("\n**************************\n");
printf("\nClosing...\n");

exit(EXIT_SUCCESS);

}
</syntaxhighlight>

===Client===

<syntaxhighlight lang="C">

#include <errno.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <time.h>

void chat(int n){

int a;
int fd;
char path [] = "watched";
unsigned char buffer[8];
memset(buffer, '0', sizeof(buffer));
int i = 7;
const struct timespec timer = {
.tv_sec = 0,
.tv_nsec = 500000
};
struct timespec s;
while (n){

if(n & 1){

buffer[i] = '1';

}
i--;
n >>= 1;

}
for (a = 0; a < 8; a++) {

if (buffer[a] == '0'){

fd = open(path,O_WRONLY);
close(fd);

}
else{

fd = open(path,O_RDONLY);
close(fd);
}

/*sleep (1);*/
nanosleep(&timer,&s);

}

}
void main (){
char message[1024] = "";
int bit_message;
int len = 0;
int i = 0;

printf("Type in \n");

fgets(message,100,stdin);
printf("You typed: %s", message);

len = (unsigned)strlen(message);
while (i < len -1){
chat(message[i]);
i++;
}
}
</syntaxhighlight>

Alessio Trivisonno

Esercizi con System Call

2016-04-26T14:25:02Z

Aletri: Esperimento: secret channel with inotify

Questi programmi contengono esempi di uso delle System-Call.

Il consiglio e' di compilarli, provarli e capirne passo-passo il funzionamento. (o spiegare perche' non funzionino).

Ovviamente potete proporre ulteriori esempi.
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 08:03, 2 November 2015 (CET)

== programma 0 ==
Il gatto di Schrödinger: Fork e' vero o falso?

<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>

int main(int argc, char* argv[]) {
if (fork())
printf("fork is true\n");
else
printf("fork is false\n");
usleep(100000);
return 0;
}
</syntaxhighlight>

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.

([[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]])

== 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.
([[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]])

= programma 5 =
==Secret channel with inotify==
Stavo leggendo sul libro che e' possibile creare un canale di comunicazione segreto praticamente con ogni cosa all'interno di un sistema UNIX. In particolare mi ha interessato il caso di creare un canale mono direzionale tramite l'apertura dei file in lettura o scrittura e ho voluto provare a implementarne uno. Questi canali sono quasi impossibili da scovare per un amministratore di sistema e potrebbero permettere lo scambio di informazioni illecite.
Una cosa interessante e' che a quanto pare il kernel ha bisogno di qualche millisecondo per eseguire la inotify e che una precedente implementazione senza delay portava all'arrivo di messaggi sbagliati.

===Server===

<syntaxhighlight lang="C">

#include <errno.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include <unistd.h>
#include <string.h>

void printChar(int n){

int a;
char c;
unsigned char buffer[8];
memset(buffer, '0', sizeof(buffer));
int i = 7;
while (n){

if(n & 1)
buffer[i]= '1';
i--;
n >>= 1;

}
c = strtol(buffer, 0, 2);
printf("%c", c);

}

static void handle_events (int fd, int wd, char *bin_message,int *current_bit){
char buf [4096]
__attribute__ ((aligned(__alignof__(struct inotify_event))));
const struct inotify_event *event;
int i;
ssize_t len;
char *ptr;

//loop while inotify events can be read from the fd
for (;;){
len = read (fd, buf, sizeof (buf));
if (len == -1 && errno != EAGAIN){
perror ("read");
exit (EXIT_FAILURE);
}

//if the read returns with the errono EAGAIN exit from the loop
if (len <= 0)
break;
//loop between all events in the buffer
for (ptr = buf; ptr < buf + len;
ptr += sizeof(struct inotify_event) + event->len){
event = (const struct inotify_event *) ptr;

if (event->mask & IN_CLOSE_NOWRITE){
//received 1

*bin_message |= 0x01;
}
if (event->mask & IN_CLOSE_WRITE){

//received 0
//do nothing to leave 0

}

}
}
}

void main () {
char buf;
int fd;
int wd;
struct pollfd fds [2];
int nfds;
int poll_num;
/*char message = 0;*/
unsigned char message_str [4096] = "";
int count = 0;
int bit_wrote = 0;

char path [100] = "/inofify/watched";
int t;

//create the file descriptor where inotify events has to be read
fd = inotify_init1(IN_NONBLOCK);
if (fd == -1) {
perror("inotify_init1");
exit(EXIT_FAILURE);
}

wd = inotify_add_watch (fd, path, IN_CLOSE_NOWRITE | IN_CLOSE_WRITE);

if (wd == -1 ){
fprintf (stderr, "Cannot watch '%s' \n", path);
perror ("inotify_add_watch");
exit(EXIT_FAILURE);
}

//prepare for the polling on the fd

nfds = 2;
fds[0].fd = STDIN_FILENO;
fds[0].events = POLLIN;
fds[1].fd = fd;
fds[1].events = POLLIN;

printf ("Listening for events... Press ENTER to terminate and show the message\n");
while (1){

poll_num = poll(fds,nfds, -1);
if (poll_num == -1){
if (errno == EINTR)
continue;
perror ("poll");
exit (EXIT_FAILURE);

}
if (poll_num > 0){
if (fds[0].revents & POLLIN){

//exit on ENTER key pressed emptying the stdin
while (read (STDIN_FILENO,&buf,1) > 0 && buf != '\n') continue;
break;

}
//notify an event occurred
if (fds[1].revents & POLLIN ){
if (bit_wrote < 8){
printf("..");
fflush(stdout);
handle_events (fd,wd,&message_str[count],&bit_wrote);
if (bit_wrote < 7){
message_str[count] = message_str[count] << 0x01;
}

}
else {
bit_wrote = 0;
count += 1;
handle_events (fd,wd,&message_str[count],&bit_wrote);
}
bit_wrote += 1;
}

}
}
printf("\n**********MESSAGE***********\n");
t = 0;
while (t <= count ){

printChar(message_str[t]);
t += 1;
}
printf("\n**************************\n");
printf("\nClosing...\n");

exit(EXIT_SUCCESS);

}
</syntaxhighlight>

===Client===

<syntaxhighlight lang="C">

#include <errno.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <time.h>

void chat(int n){

int a;
int fd;
char path [] = "watched";
unsigned char buffer[8];
memset(buffer, '0', sizeof(buffer));
int i = 7;
const struct timespec timer = {
.tv_sec = 0,
.tv_nsec = 500000
};
struct timespec s;
while (n){

if(n & 1){

buffer[i] = '1';

}
i--;
n >>= 1;

}
for (a = 0; a < 8; a++) {

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

fd = open(path,O_WRONLY);
close(fd);

}
else{

fd = open(path,O_RDONLY);
close(fd);
}

/*sleep (1);*/
nanosleep(&timer,&s);

}

}
void main (){
char message[1024] = "";
int bit_message;
int len = 0;
int i = 0;

printf("Type in \n");

fgets(message,100,stdin);
printf("You typed: %s", message);

len = (unsigned)strlen(message);
while (i < len -1){
chat(message[i]);
i++;
}
}
</syntaxhighlight>

Alessio Trivisonno

Esercizi di lettura di codice C

2015-11-07T20:37:53Z

Aletri: Soluzione programma 9

Questi programmi non sono necessariamente stilisticamente belli (non sono "esempi da copiare") ma presentano dei passaggi di non semplice lettura.

Il consiglio e' di compilarli, provarli e capirne passo-passo il funzionamento. (o spiegare perche' non funzionino).

Ovviamente potete proporre ulteriori esempi.
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 15:42, 10 October 2015 (CEST)

== programma 0 ==
<syntaxhighlight lang="C">
#include <stdio.h>

int main(int argc, char *argv[]) {
int c;
while ((c=getchar())!=EOF)
putchar(c);
return 0;
}
</syntaxhighlight>
In questo esempio tutto ciò che viene preso in input viene messo in output, fino a quando non viene digitato il carattere di End of File (EOF). Solitamente nei sistemi DOS il carattere EOF viene definito come la combinazione di tasti CTRL+Z, mentre nei sistemi basati su Unix si utilizzano i tasti CTRL+D. ([[User:S.G|S.G]])

Nel caso l'input provenga da file e non da tastiera (ad esempio eseguendo da terminale la riga di comando "./programma0 < testo"), il carattere speciale EOF viene inserito automaticamente alla fine del file "testo". In questo caso il programma prende in input il contenuto di "testo" e stampa a video (carattere per carattere), il contenuto del file, finchè non riconosce il carattere speciale EOF, che fa terminare il ciclo while.

----
questo è l'esercizio visto in aula. Il punto da notare è l'uso dell'assegnazione all'interno del controllo del ciclo while. E' una struttura tipica del linguaggio C che semplifica sintatticamente la scrittura del programma.
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 10:02, 17 October 2015 (CEST)

== programma 1 ==
<syntaxhighlight lang="C">
#include <stdio.h>

char s1[]="hello world";
char *s2="hello world";

void foo(char *s) {
printf("%s\n",s);
s[4]=',';
printf("%s\n",s);
}

int main(int argc, char *argv[]) {
foo(s1);
foo(s2);
return 0;
}
</syntaxhighlight>
In questo esempio viene mostrata la differenza tra stringa variabile (s1) e stringa costante (s2). Nel primo caso a tempo di compilazione la stringa costante "hello world" viene copiata passo nella stringa variabile s1 consentendo le normali operazioni di modifica della stringa stessa. Mentre nel secondo caso a tempo di compilazione viene creata la stringa costante "hello world" e memorizzato il suo indirizzo nella variabile s2 NON consentendo le normali operazioni di modifica delle stringa stessa in quanto appunto un costante. ([[User:S.G|S.G]])
== programma 2 ==
<syntaxhighlight lang="C">
#include <stdio.h>

char t[]="test";
struct st {
char s[5];
char *t;
} st0={"test",t};

void foo (struct st i) {
i.s[2]='n';
i.t[2]='n';
}

void bar (struct st *i) {
i->s[2]='x';
i->t[2]='x';
}

int main(int argc, char *argv[]) {
printf("%s %s\n",st0.s,st0.t);
foo(st0); /* Vengono copiati i valori della struttura st0 in i, le uniche modifiche saranno sul campo i.t in quanto puntatore. */
printf("%s %s\n",st0.s,st0.t);
bar(&st0); /* Viene copiato l'indirizzo della struttura st0 in i, le modifiche vengono apportate su tutti i campi delle struttura. */
printf("%s %s\n",st0.s,st0.t);
return 0;
}
</syntaxhighlight>
Output del programma:

test test

test tent

text text

([[User:S.G|S.G]])

----
Sì, ma perché? Come è fatta la struttura st? [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 10:06, 17 October 2015 (CEST)

----
La struttura st è fatta da un array di 5 caratteri e da un puntatore a caratteri (che viene usato anch'esso per puntare ad un'array di caratteri).

Con la prima chiamata a printf vengono stampati i valori dei campi della struttura non ancora modificati, dal momento che non è stata ancora chiamata nè la funzione foo nè la funzione bar (test test)

In seguito viene passata la struct st0 alla funzione foo. In particolare viene passata alla funzione una COPIA del primo campo e una COPIA del secondo campo; tuttavia essendo il secondo campo della struttura un puntatore, viene passato il valore del puntatore, che è un indirizzo, cioè l'indirizzo a cui si trova l'array t (char t[]="test"). Per questo motivo viene modificato solo il valore del secondo campo nella struttura st0, infatti quando la funzione termina, la copia del primo campo viene persa, senza aver modificato il valore originale, mentre il valore del secondo campo viene modificato perchè l'abbiamo modificato tramite l'indirizzo. L'output finale sarà quindi: test tent.

Alla chiamata alla funzione bar, viene invece passato l'INDIRIZZO della struttura st0, e per questo quando andiamo a modificare i campi della struttura all'interno della funzione bar, non stiamo modificando una copia di st0, ma stiamo modificando direttamente st0, accedendo tramite puntatore ai suoi singoli campi. Quindi quando bar termina, i valori originali sono stati modificati e l'output risulterà: text text.

([[User:Alessio|Alessio]])

== programma 3 ==
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
while (argc > 1) {
int i,j;
char *s=argv[1];
for (i=0, j=strlen(s)-1; i < j; i++, j--)
s[i] ^= s[j], s[j] ^= s[i], s[i] ^= s[j];
printf("%s ",s);
argc--;
argv++;
}
printf("\n");
return 0;
}
</syntaxhighlight>
In questo esempio il programma effettua un reverse di tutte le parole che gli vengo date in input ad esclusione di argv[0] che sarebbe il nome del programma, esempio:

INPUT: ./programma3 ciao sistemi operativi

OUTPUT: oaic imetsis ivitarepo

Il punto importante di questo codice è che lo scambio delle singole lettere viene effettuato con l'operatore logico XOR senza cosi avere bisogno di una "variabile di scambio".
Qui viene spiegato nel dettaglio il [https://it.wikibooks.org/wiki/C/Variabili,_operatori_e_costanti/Operatori_sui_bit funzionamento dell'operatore logico]

([[User:S.G|S.G]])

== programma 4 ==
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

struct elem {
char *s;
struct elem *next;
};
struct elem *root=NULL;

void insert(char *s, struct elem **elp) { /* Inserimento in ordine alfabetico */
if (*elp && strcmp((*elp)->s, s) < 0) /* se la lista elp non è vuota e se (*elp)->s è alfabeticamente minore di s, inserisce in coda s */
insert(s,&((*elp)->next));
else { /* nel caso in cui la lista è vuota o se (*elp)->s è alfabeticamente maggiore di s, inserisce in testa s */
struct elem tmp={s,*elp};
struct elem *new=malloc(sizeof(struct elem));
*new=tmp;
*elp=new;
}
}

struct elem *print(struct elem *root) { /* stampa l'intera lista, alla fine dealloca root e restituisce NULL */
if (root) {
printf("%s ",root->s);
root->next=print(root->next);
free(root);
return NULL;
}
}

int main(int argc, char *argv[]) {
for (;argc>1;argc--,argv++) /* Scorre tutti gli elementi in input del programma (tranne il nome stesso del programma), aggiungendoli in una lista */
insert(argv[1],&root);
root=print(root);
printf("\n");
return 0;
}
</syntaxhighlight>
Il programma ordina alfabeticamente gli elementi presi input, esempio:

INPUT: ./programma4 ciao sistemi operativi e macchine virtuali

OUTPUT: ciao e macchine operativi sistemi virtuali

([[User:S.G|S.G]])

----
Però ci sono due tecniche diverse per la scrittura di funzioni ricorsive che modificano liste... Chi le spiega? [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 10:08, 17 October 2015 (CEST)

---

In quanto la lista va modificata, in questo esempio, è stato passato l'indirizzo di memoria del puntatore di testa della lista. Ne verrà quindi usata una copia all'interno della funzione ma, essendo una copia di un indirizzo di memoria, si andrà ugualmente ad agire fisicamente sulla struttura dati.
La seconda opzione è quella di passare la testa della lista come parametro, così facendo però ne verrà creata una copia. Per rendere quindi effettive le modifiche che avvengono nella funzione, bisogna quindi che la funzione non abbia risultato Void bensì deve ritornare come valore la testa della lista modificata. Nella chiamata della funzione è quindi necessario un assegnamento del tipo: head = func(head);

Alessandro Bandini

==Programma 5==
Propongo un esempio relativo all'uso dello statement static:

<syntaxhighlight lang="C">
#include <stdio.h>

int var;

int foo(){
static int var=0;
var++;
return var;
}

int bar(){
int var=0;
var ++;
return var;
}

int foobar(){
var++;
return var;
}

int main(int argc, char *argv[]){
int sum1, sum2, sum3;
int i;
for(i=0;i<100;i++){
sum1=foo();
}
printf("%d\n", sum1);
for(i=0;i<100;i++){
sum2=bar();
}
printf("%d\n", sum2);
for(i=0;i<100;i++){
sum3=foobar();
}
printf("%d\n", sum3);

return 0;
}
</syntaxhighlight>

Output del codice:

100

1

100

----

Le tre funzioni ''foo()'', ''bar()'' e ''foobar()'', sebbene si possa pensare agiscano sulla stessa variabile globale intera ''var'', hanno comportamenti diversi proprio perche' non agiscono sulla stessa variabile. Nella funzione ''foo()'', viene ridefinita una nuova variabile intera ''var'' che ha uno scope limitato al solo corpo della funzione (e' come se avesse una "precedenza" maggiore rispetto alla variabile globale); inoltre essa e' definita come ''static'': il valore della varibile non viene quindi salvato nello STACK della funzione bensi' nel segmento DATA, permettendo di avere il valore salvato anche dopo piu' chiamate della funzione.

Il discorso e' leggermente diverso per la funzione ''bar()'': anche qui viene ridefinita la variabile ''var'' ma non in modo static. Il valore di ''var'' e' quindi salvato nello STACK della funzione, che viene ricreato ad ogni chiamata. Sebbene ''bar()'' venga chiamata cento volte, a ''sum2'' viene assegnato solo un incremento, a causa dell'inizializzazione a 0 di ''var'' che avviene per ogni chiamata.

Infine, all'interno della funzione ''foobar()'' non viene definita una nuova variabile, quindi la ''var'' usata nel corpo e' la variabile globale definita in precedenza. Similmente ad una variabile static, anche il valore di una variabile globale viene memorizzato nel segmento DATA del programma, ed il cui valore rimane in memoria nonostante le successive chiamate della funzione.

Matteo Del Vecchio

==Programma 6==
Challenge: Cosa fa questo programma (progettato per processori atmega8/88/168 etc)?

<syntaxhighlight lang="C">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/twi.h>
#include <inttypes.h>
#ifdef ATMEGA88
#define F_CPU 8000000UL // 8 MHz
#else
#define F_CPU 1000000UL // 1 MHz
#endif
#include <util/delay.h>

void delay_ms(unsigned int ms)
{
while(ms){
_delay_ms(0.96);
ms--;
}
}

#define DMASK 0x07
#define TWSR_STATUS_MASK 0xF8
#define TWCR_CMD_MASK 0x0F

unsigned char newB;
unsigned char oldB;
unsigned char diffB;
unsigned char status;
unsigned char unstable;
unsigned char step;
unsigned char value;
unsigned char d0,d1,d2,d3,d4,d5,d6,d7,d8;

static unsigned char i2cs_addr;

void i2cs_init(void)
{
TWCR = 1<<TWINT | 1<<TWEA | 1<<TWEN | 1<<TWIE;
TWAR = i2cs_addr;
}

void i2cs_command(unsigned char comm)
{
switch (comm & 0xF8) {
case 0x80:
if (step)
status &= ~(1<<(comm & 0x07));
else
PORTD &= ~(1<<(comm & 0x07));
break;
case 0x88:
if (step)
status |= (1<<(comm & 0x07));
else
PORTD |= (1<<(comm & 0x07));
break;
}
}

ISR(TWI_vect)
{
unsigned char i2c_status= TWSR & TWSR_STATUS_MASK;
switch (i2c_status) {
case TW_SR_DATA_ACK:
i2cs_command(TWDR);
TWCR = (TWCR & TWCR_CMD_MASK) | 1<<TWINT | 1<<TWEA;
break;
case TW_ST_SLA_ACK:
case TW_ST_DATA_ACK:
TWDR = status;
TWCR = (TWCR & TWCR_CMD_MASK) | 1<<TWINT | 1<<TWEA;
break;
default:
TWCR = (TWCR & TWCR_CMD_MASK) | 1<<TWINT | 1<<TWEA;
break;
}
}

int main(void)
{
DDRD = 0xFF;
PORTB = 0xFF;
PORTC = 0x0F;
delay_ms(10);
i2cs_addr= (0x20 | ((~PINC & 0x0F) << 1));
step = (i2cs_addr & 0x10) == 0;
i2cs_init();
sei();
while (1) {
delay_ms(1);
oldB=newB;
newB=~PINB;
diffB=oldB ^ newB;
unstable=0;
if (diffB & 0x01) d0 = 1; else d0++;
if (diffB & 0x02) d1 = 1; else d1++;
if (diffB & 0x04) d2 = 1; else d2++;
if (diffB & 0x08) d3 = 1; else d3++;
if (diffB & 0x10) d4 = 1; else d4++;
if (diffB & 0x20) d5 = 1; else d5++;
if (diffB & 0x40) d6 = 1; else d6++;
if (diffB & 0x80) d7 = 1; else d7++;
if(d0 & DMASK) unstable |= 0x01;
if(d1 & DMASK) unstable |= 0x02;
if(d2 & DMASK) unstable |= 0x04;
if(d3 & DMASK) unstable |= 0x08;
if(d4 & DMASK) unstable |= 0x10;
if(d5 & DMASK) unstable |= 0x20;
if(d6 & DMASK) unstable |= 0x40;
if(d7 & DMASK) unstable |= 0x80;
if (step) {
status ^= (newB & ~value & ~unstable);
value = (value & unstable) | (newB & ~unstable);
} else
status = (status & unstable) | (newB & ~unstable);
if (step)
PORTD=status;
}
return(0);
}
</syntaxhighlight>
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 08:06, 21 October 2015 (CEST)

==Programma 7==
Guardate queste costanti predefinite. Come le utilizzereste?

<syntaxhighlight lang="C">
#include <stdio.h>

int main(int argc, char *argv[]) {
printf("%s: line %d\n",__FILE__,__LINE__);
printf("built %s %s\n",__DATE__,__TIME__);
return 0;
}
</syntaxhighlight>

==Programma 8==
Un "effetto speciale" del preprocessore:

<syntaxhighlight lang="C">
#include <stdio.h>
#define ik(x) int k##x = x
#define ck(x) char *k##x = #x

ik(0);
ik(1);
ik(2);
ck(tricky);

int main(int argc, char *argv[]) {
printf("%d %d %d %s\n", k0, k1, k2, ktricky);
}
</syntaxhighlight>

Il programma stampa: 0 1 2 tricky

Questo e' dovuto al fatto che il preprocessore sostituisce ogni occorrenza di ik(x) con int kx = x; Lo stesso avviene per la stringa tricky. Infatti se andiamo a guardare il programma facendo solo la fase di preproccessing dando il comando gcc -E [...] notiamo che diventa cosi':

<syntaxhighlight lang="C">
int k0 = 0;
int k1 = 1;
int k2 = 2;
char *ktricky = "tricky";

int main(int argc, char *argv[]) {
printf("%d %d %d %s\n", k0, k1, k2, ktricky);
}

</syntaxhighlight>

L'operatore ## concatena due argomenti senza lasciare spazi bianchi tra di loro, in questo caso concatena k ad x.
<br/>Non importa che ci sia uno spazio tra k e x. Vedi [http://www.cplusplus.com/doc/oldtutorial/preprocessor/]

[[User:Aletri|Aletri]] ([[User talk:Aletri|talk]])

==Programma 9==
Ecco un esempio di uso della libreria stdarg.

<syntaxhighlight lang="C">

#include <stdio.h>
#include <stdarg.h>

void intprint(int n, ...)
{
va_list ap;

va_start(ap, n);
while (n>0) {
int i;
printf("%d ",va_arg(ap,int));
n--;
}
printf("\n");
va_end(ap);
}

int main(int argc, char *argv) {
intprint(3,1,2,3);
intprint(5,1,2,3,4,5);
}
</syntaxhighlight>

L'uso della libreria stdarg e' particolarmente utile quando la funzione chiamata non conosce il numero di argomenti che le verranno passati. Infatti possiamo notare che intprint viene chiamata la prima volta con 4 parametri e la seconda volta con 6. Questo viene grestito dalla libreria mettendo gli argomenti nella lista va_list. Questa libreria utilizza delle macro per getire questa operazione. In particolare potete notare facendo solo il preprocessing che va_start e va_end vengono sostituiti con delle macro.

Il programma stampa 123 12345.

[[User:Aletri|Aletri]] ([[User talk:Aletri|talk]])

==Programma 10==
Un po' di trucchi con le macro e le funzioni a numero variabile di parametri con passaggio di liste di parametri.

<syntaxhighlight lang="C">
#define _GNU_SOURCE
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>

#define debugprintf(fmt, ...) private_debugprintf((fmt),__FILE__,__LINE__, ##__VA_ARGS__)

int private_debugprintf(const char *fmt, ...)
{
va_list ap;
char *newfmt;
int rv;

va_start(ap, fmt);
asprintf(&newfmt,"File %%s Line %%d %s",fmt);
rv=vfprintf(stderr, newfmt, ap);
free(newfmt);
return rv;
}

char *name="douglas adams";
int value=42;

int main(int argc, char *argv[]) {
debugprintf("hello world, bug!\n");
debugprintf("string: %s int: %d\n",name,value);
}
</syntaxhighlight>

==Programma 11==
getopt e getopt_long sono molto utili.... ecco un esempio. Cosa fa questo programma?

<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <libgen.h>

void usage(char *progname) {
fprintf(stderr,
"Usage:\n"
"\t%s [-m num] [-r] args...\n"
"\t%s [--mul num] [--rev] args...\n",progname,progname);
exit(1);
}

int main(int argc, char *argv[]) {
int c, oindex;
int rev=0;
int mul=1;
static struct option long_options[] = {
{"mul", required_argument, 0, 'm'},
{"rev", no_argument, 0, 'r'}};
while ((c = getopt_long(argc, argv, "m:r",
long_options, &oindex)) > 0) {
switch (c) {
case 'm': mul = atoi(optarg);
break;
case 'r': rev = 1;
break;
default:
usage(basename(argv[0]));
}
}
for (; mul>0; mul--) {
if (rev) {
for(oindex=argc-1; oindex>=optind; oindex--)
printf("%s ",argv[oindex]);
} else {
for(oindex=optind; oindex<argc; oindex++)
printf("%s ",argv[oindex]);
}
}
printf("\n");
return 0;
}
</syntaxhighlight>

Esercizi di lettura di codice C

2015-11-07T20:19:51Z

Aletri: /* Programma 8 */

Questi programmi non sono necessariamente stilisticamente belli (non sono "esempi da copiare") ma presentano dei passaggi di non semplice lettura.

Il consiglio e' di compilarli, provarli e capirne passo-passo il funzionamento. (o spiegare perche' non funzionino).

Ovviamente potete proporre ulteriori esempi.
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 15:42, 10 October 2015 (CEST)

== programma 0 ==
<syntaxhighlight lang="C">
#include <stdio.h>

int main(int argc, char *argv[]) {
int c;
while ((c=getchar())!=EOF)
putchar(c);
return 0;
}
</syntaxhighlight>
In questo esempio tutto ciò che viene preso in input viene messo in output, fino a quando non viene digitato il carattere di End of File (EOF). Solitamente nei sistemi DOS il carattere EOF viene definito come la combinazione di tasti CTRL+Z, mentre nei sistemi basati su Unix si utilizzano i tasti CTRL+D. ([[User:S.G|S.G]])

Nel caso l'input provenga da file e non da tastiera (ad esempio eseguendo da terminale la riga di comando "./programma0 < testo"), il carattere speciale EOF viene inserito automaticamente alla fine del file "testo". In questo caso il programma prende in input il contenuto di "testo" e stampa a video (carattere per carattere), il contenuto del file, finchè non riconosce il carattere speciale EOF, che fa terminare il ciclo while.

----
questo è l'esercizio visto in aula. Il punto da notare è l'uso dell'assegnazione all'interno del controllo del ciclo while. E' una struttura tipica del linguaggio C che semplifica sintatticamente la scrittura del programma.
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 10:02, 17 October 2015 (CEST)

== programma 1 ==
<syntaxhighlight lang="C">
#include <stdio.h>

char s1[]="hello world";
char *s2="hello world";

void foo(char *s) {
printf("%s\n",s);
s[4]=',';
printf("%s\n",s);
}

int main(int argc, char *argv[]) {
foo(s1);
foo(s2);
return 0;
}
</syntaxhighlight>
In questo esempio viene mostrata la differenza tra stringa variabile (s1) e stringa costante (s2). Nel primo caso a tempo di compilazione la stringa costante "hello world" viene copiata passo nella stringa variabile s1 consentendo le normali operazioni di modifica della stringa stessa. Mentre nel secondo caso a tempo di compilazione viene creata la stringa costante "hello world" e memorizzato il suo indirizzo nella variabile s2 NON consentendo le normali operazioni di modifica delle stringa stessa in quanto appunto un costante. ([[User:S.G|S.G]])
== programma 2 ==
<syntaxhighlight lang="C">
#include <stdio.h>

char t[]="test";
struct st {
char s[5];
char *t;
} st0={"test",t};

void foo (struct st i) {
i.s[2]='n';
i.t[2]='n';
}

void bar (struct st *i) {
i->s[2]='x';
i->t[2]='x';
}

int main(int argc, char *argv[]) {
printf("%s %s\n",st0.s,st0.t);
foo(st0); /* Vengono copiati i valori della struttura st0 in i, le uniche modifiche saranno sul campo i.t in quanto puntatore. */
printf("%s %s\n",st0.s,st0.t);
bar(&st0); /* Viene copiato l'indirizzo della struttura st0 in i, le modifiche vengono apportate su tutti i campi delle struttura. */
printf("%s %s\n",st0.s,st0.t);
return 0;
}
</syntaxhighlight>
Output del programma:

test test

test tent

text text

([[User:S.G|S.G]])

----
Sì, ma perché? Come è fatta la struttura st? [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 10:06, 17 October 2015 (CEST)

----
La struttura st è fatta da un array di 5 caratteri e da un puntatore a caratteri (che viene usato anch'esso per puntare ad un'array di caratteri).

Con la prima chiamata a printf vengono stampati i valori dei campi della struttura non ancora modificati, dal momento che non è stata ancora chiamata nè la funzione foo nè la funzione bar (test test)

In seguito viene passata la struct st0 alla funzione foo. In particolare viene passata alla funzione una COPIA del primo campo e una COPIA del secondo campo; tuttavia essendo il secondo campo della struttura un puntatore, viene passato il valore del puntatore, che è un indirizzo, cioè l'indirizzo a cui si trova l'array t (char t[]="test"). Per questo motivo viene modificato solo il valore del secondo campo nella struttura st0, infatti quando la funzione termina, la copia del primo campo viene persa, senza aver modificato il valore originale, mentre il valore del secondo campo viene modificato perchè l'abbiamo modificato tramite l'indirizzo. L'output finale sarà quindi: test tent.

Alla chiamata alla funzione bar, viene invece passato l'INDIRIZZO della struttura st0, e per questo quando andiamo a modificare i campi della struttura all'interno della funzione bar, non stiamo modificando una copia di st0, ma stiamo modificando direttamente st0, accedendo tramite puntatore ai suoi singoli campi. Quindi quando bar termina, i valori originali sono stati modificati e l'output risulterà: text text.

([[User:Alessio|Alessio]])

== programma 3 ==
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
while (argc > 1) {
int i,j;
char *s=argv[1];
for (i=0, j=strlen(s)-1; i < j; i++, j--)
s[i] ^= s[j], s[j] ^= s[i], s[i] ^= s[j];
printf("%s ",s);
argc--;
argv++;
}
printf("\n");
return 0;
}
</syntaxhighlight>
In questo esempio il programma effettua un reverse di tutte le parole che gli vengo date in input ad esclusione di argv[0] che sarebbe il nome del programma, esempio:

INPUT: ./programma3 ciao sistemi operativi

OUTPUT: oaic imetsis ivitarepo

Il punto importante di questo codice è che lo scambio delle singole lettere viene effettuato con l'operatore logico XOR senza cosi avere bisogno di una "variabile di scambio".
Qui viene spiegato nel dettaglio il [https://it.wikibooks.org/wiki/C/Variabili,_operatori_e_costanti/Operatori_sui_bit funzionamento dell'operatore logico]

([[User:S.G|S.G]])

== programma 4 ==
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

struct elem {
char *s;
struct elem *next;
};
struct elem *root=NULL;

void insert(char *s, struct elem **elp) { /* Inserimento in ordine alfabetico */
if (*elp && strcmp((*elp)->s, s) < 0) /* se la lista elp non è vuota e se (*elp)->s è alfabeticamente minore di s, inserisce in coda s */
insert(s,&((*elp)->next));
else { /* nel caso in cui la lista è vuota o se (*elp)->s è alfabeticamente maggiore di s, inserisce in testa s */
struct elem tmp={s,*elp};
struct elem *new=malloc(sizeof(struct elem));
*new=tmp;
*elp=new;
}
}

struct elem *print(struct elem *root) { /* stampa l'intera lista, alla fine dealloca root e restituisce NULL */
if (root) {
printf("%s ",root->s);
root->next=print(root->next);
free(root);
return NULL;
}
}

int main(int argc, char *argv[]) {
for (;argc>1;argc--,argv++) /* Scorre tutti gli elementi in input del programma (tranne il nome stesso del programma), aggiungendoli in una lista */
insert(argv[1],&root);
root=print(root);
printf("\n");
return 0;
}
</syntaxhighlight>
Il programma ordina alfabeticamente gli elementi presi input, esempio:

INPUT: ./programma4 ciao sistemi operativi e macchine virtuali

OUTPUT: ciao e macchine operativi sistemi virtuali

([[User:S.G|S.G]])

----
Però ci sono due tecniche diverse per la scrittura di funzioni ricorsive che modificano liste... Chi le spiega? [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 10:08, 17 October 2015 (CEST)

---

In quanto la lista va modificata, in questo esempio, è stato passato l'indirizzo di memoria del puntatore di testa della lista. Ne verrà quindi usata una copia all'interno della funzione ma, essendo una copia di un indirizzo di memoria, si andrà ugualmente ad agire fisicamente sulla struttura dati.
La seconda opzione è quella di passare la testa della lista come parametro, così facendo però ne verrà creata una copia. Per rendere quindi effettive le modifiche che avvengono nella funzione, bisogna quindi che la funzione non abbia risultato Void bensì deve ritornare come valore la testa della lista modificata. Nella chiamata della funzione è quindi necessario un assegnamento del tipo: head = func(head);

Alessandro Bandini

==Programma 5==
Propongo un esempio relativo all'uso dello statement static:

<syntaxhighlight lang="C">
#include <stdio.h>

int var;

int foo(){
static int var=0;
var++;
return var;
}

int bar(){
int var=0;
var ++;
return var;
}

int foobar(){
var++;
return var;
}

int main(int argc, char *argv[]){
int sum1, sum2, sum3;
int i;
for(i=0;i<100;i++){
sum1=foo();
}
printf("%d\n", sum1);
for(i=0;i<100;i++){
sum2=bar();
}
printf("%d\n", sum2);
for(i=0;i<100;i++){
sum3=foobar();
}
printf("%d\n", sum3);

return 0;
}
</syntaxhighlight>

Output del codice:

100

1

100

----

Le tre funzioni ''foo()'', ''bar()'' e ''foobar()'', sebbene si possa pensare agiscano sulla stessa variabile globale intera ''var'', hanno comportamenti diversi proprio perche' non agiscono sulla stessa variabile. Nella funzione ''foo()'', viene ridefinita una nuova variabile intera ''var'' che ha uno scope limitato al solo corpo della funzione (e' come se avesse una "precedenza" maggiore rispetto alla variabile globale); inoltre essa e' definita come ''static'': il valore della varibile non viene quindi salvato nello STACK della funzione bensi' nel segmento DATA, permettendo di avere il valore salvato anche dopo piu' chiamate della funzione.

Il discorso e' leggermente diverso per la funzione ''bar()'': anche qui viene ridefinita la variabile ''var'' ma non in modo static. Il valore di ''var'' e' quindi salvato nello STACK della funzione, che viene ricreato ad ogni chiamata. Sebbene ''bar()'' venga chiamata cento volte, a ''sum2'' viene assegnato solo un incremento, a causa dell'inizializzazione a 0 di ''var'' che avviene per ogni chiamata.

Infine, all'interno della funzione ''foobar()'' non viene definita una nuova variabile, quindi la ''var'' usata nel corpo e' la variabile globale definita in precedenza. Similmente ad una variabile static, anche il valore di una variabile globale viene memorizzato nel segmento DATA del programma, ed il cui valore rimane in memoria nonostante le successive chiamate della funzione.

Matteo Del Vecchio

==Programma 6==
Challenge: Cosa fa questo programma (progettato per processori atmega8/88/168 etc)?

<syntaxhighlight lang="C">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/twi.h>
#include <inttypes.h>
#ifdef ATMEGA88
#define F_CPU 8000000UL // 8 MHz
#else
#define F_CPU 1000000UL // 1 MHz
#endif
#include <util/delay.h>

void delay_ms(unsigned int ms)
{
while(ms){
_delay_ms(0.96);
ms--;
}
}

#define DMASK 0x07
#define TWSR_STATUS_MASK 0xF8
#define TWCR_CMD_MASK 0x0F

unsigned char newB;
unsigned char oldB;
unsigned char diffB;
unsigned char status;
unsigned char unstable;
unsigned char step;
unsigned char value;
unsigned char d0,d1,d2,d3,d4,d5,d6,d7,d8;

static unsigned char i2cs_addr;

void i2cs_init(void)
{
TWCR = 1<<TWINT | 1<<TWEA | 1<<TWEN | 1<<TWIE;
TWAR = i2cs_addr;
}

void i2cs_command(unsigned char comm)
{
switch (comm & 0xF8) {
case 0x80:
if (step)
status &= ~(1<<(comm & 0x07));
else
PORTD &= ~(1<<(comm & 0x07));
break;
case 0x88:
if (step)
status |= (1<<(comm & 0x07));
else
PORTD |= (1<<(comm & 0x07));
break;
}
}

ISR(TWI_vect)
{
unsigned char i2c_status= TWSR & TWSR_STATUS_MASK;
switch (i2c_status) {
case TW_SR_DATA_ACK:
i2cs_command(TWDR);
TWCR = (TWCR & TWCR_CMD_MASK) | 1<<TWINT | 1<<TWEA;
break;
case TW_ST_SLA_ACK:
case TW_ST_DATA_ACK:
TWDR = status;
TWCR = (TWCR & TWCR_CMD_MASK) | 1<<TWINT | 1<<TWEA;
break;
default:
TWCR = (TWCR & TWCR_CMD_MASK) | 1<<TWINT | 1<<TWEA;
break;
}
}

int main(void)
{
DDRD = 0xFF;
PORTB = 0xFF;
PORTC = 0x0F;
delay_ms(10);
i2cs_addr= (0x20 | ((~PINC & 0x0F) << 1));
step = (i2cs_addr & 0x10) == 0;
i2cs_init();
sei();
while (1) {
delay_ms(1);
oldB=newB;
newB=~PINB;
diffB=oldB ^ newB;
unstable=0;
if (diffB & 0x01) d0 = 1; else d0++;
if (diffB & 0x02) d1 = 1; else d1++;
if (diffB & 0x04) d2 = 1; else d2++;
if (diffB & 0x08) d3 = 1; else d3++;
if (diffB & 0x10) d4 = 1; else d4++;
if (diffB & 0x20) d5 = 1; else d5++;
if (diffB & 0x40) d6 = 1; else d6++;
if (diffB & 0x80) d7 = 1; else d7++;
if(d0 & DMASK) unstable |= 0x01;
if(d1 & DMASK) unstable |= 0x02;
if(d2 & DMASK) unstable |= 0x04;
if(d3 & DMASK) unstable |= 0x08;
if(d4 & DMASK) unstable |= 0x10;
if(d5 & DMASK) unstable |= 0x20;
if(d6 & DMASK) unstable |= 0x40;
if(d7 & DMASK) unstable |= 0x80;
if (step) {
status ^= (newB & ~value & ~unstable);
value = (value & unstable) | (newB & ~unstable);
} else
status = (status & unstable) | (newB & ~unstable);
if (step)
PORTD=status;
}
return(0);
}
</syntaxhighlight>
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 08:06, 21 October 2015 (CEST)

==Programma 7==
Guardate queste costanti predefinite. Come le utilizzereste?

<syntaxhighlight lang="C">
#include <stdio.h>

int main(int argc, char *argv[]) {
printf("%s: line %d\n",__FILE__,__LINE__);
printf("built %s %s\n",__DATE__,__TIME__);
return 0;
}
</syntaxhighlight>

==Programma 8==
Un "effetto speciale" del preprocessore:

<syntaxhighlight lang="C">
#include <stdio.h>
#define ik(x) int k##x = x
#define ck(x) char *k##x = #x

ik(0);
ik(1);
ik(2);
ck(tricky);

int main(int argc, char *argv[]) {
printf("%d %d %d %s\n", k0, k1, k2, ktricky);
}
</syntaxhighlight>

Il programma stampa: 0 1 2 tricky

Questo e' dovuto al fatto che il preprocessore sostituisce ogni occorrenza di ik(x) con int kx = x; Lo stesso avviene per la stringa tricky. Infatti se andiamo a guardare il programma facendo solo la fase di preproccessing dando il comando gcc -E [...] notiamo che diventa cosi':

<syntaxhighlight lang="C">
int k0 = 0;
int k1 = 1;
int k2 = 2;
char *ktricky = "tricky";

int main(int argc, char *argv[]) {
printf("%d %d %d %s\n", k0, k1, k2, ktricky);
}

</syntaxhighlight>

L'operatore ## concatena due argomenti senza lasciare spazi bianchi tra di loro, in questo caso concatena k ad x.
<br/>Non importa che ci sia uno spazio tra k e x. Vedi [http://www.cplusplus.com/doc/oldtutorial/preprocessor/]

[[User:Aletri|Aletri]] ([[User talk:Aletri|talk]])

==Programma 9==
Ecco un esempio di uso della libreria stdarg.

<syntaxhighlight lang="C">

#include <stdio.h>
#include <stdarg.h>

void intprint(int n, ...)
{
va_list ap;

va_start(ap, n);
while (n>0) {
int i;
printf("%d ",va_arg(ap,int));
n--;
}
printf("\n");
va_end(ap);
}

int main(int argc, char *argv) {
intprint(3,1,2,3);
intprint(5,1,2,3,4,5);
}
</syntaxhighlight>

==Programma 10==
Un po' di trucchi con le macro e le funzioni a numero variabile di parametri con passaggio di liste di parametri.

<syntaxhighlight lang="C">
#define _GNU_SOURCE
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>

#define debugprintf(fmt, ...) private_debugprintf((fmt),__FILE__,__LINE__, ##__VA_ARGS__)

int private_debugprintf(const char *fmt, ...)
{
va_list ap;
char *newfmt;
int rv;

va_start(ap, fmt);
asprintf(&newfmt,"File %%s Line %%d %s",fmt);
rv=vfprintf(stderr, newfmt, ap);
free(newfmt);
return rv;
}

char *name="douglas adams";
int value=42;

int main(int argc, char *argv[]) {
debugprintf("hello world, bug!\n");
debugprintf("string: %s int: %d\n",name,value);
}
</syntaxhighlight>

==Programma 11==
getopt e getopt_long sono molto utili.... ecco un esempio. Cosa fa questo programma?

<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <libgen.h>

void usage(char *progname) {
fprintf(stderr,
"Usage:\n"
"\t%s [-m num] [-r] args...\n"
"\t%s [--mul num] [--rev] args...\n",progname,progname);
exit(1);
}

int main(int argc, char *argv[]) {
int c, oindex;
int rev=0;
int mul=1;
static struct option long_options[] = {
{"mul", required_argument, 0, 'm'},
{"rev", no_argument, 0, 'r'}};
while ((c = getopt_long(argc, argv, "m:r",
long_options, &oindex)) > 0) {
switch (c) {
case 'm': mul = atoi(optarg);
break;
case 'r': rev = 1;
break;
default:
usage(basename(argv[0]));
}
}
for (; mul>0; mul--) {
if (rev) {
for(oindex=argc-1; oindex>=optind; oindex--)
printf("%s ",argv[oindex]);
} else {
for(oindex=optind; oindex<argc; oindex++)
printf("%s ",argv[oindex]);
}
}
printf("\n");
return 0;
}
</syntaxhighlight>

Esercizi di lettura di codice C

2015-11-07T20:19:05Z

Aletri: Soluzione programma 8

Questi programmi non sono necessariamente stilisticamente belli (non sono "esempi da copiare") ma presentano dei passaggi di non semplice lettura.

Il consiglio e' di compilarli, provarli e capirne passo-passo il funzionamento. (o spiegare perche' non funzionino).

Ovviamente potete proporre ulteriori esempi.
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 15:42, 10 October 2015 (CEST)

== programma 0 ==
<syntaxhighlight lang="C">
#include <stdio.h>

int main(int argc, char *argv[]) {
int c;
while ((c=getchar())!=EOF)
putchar(c);
return 0;
}
</syntaxhighlight>
In questo esempio tutto ciò che viene preso in input viene messo in output, fino a quando non viene digitato il carattere di End of File (EOF). Solitamente nei sistemi DOS il carattere EOF viene definito come la combinazione di tasti CTRL+Z, mentre nei sistemi basati su Unix si utilizzano i tasti CTRL+D. ([[User:S.G|S.G]])

Nel caso l'input provenga da file e non da tastiera (ad esempio eseguendo da terminale la riga di comando "./programma0 < testo"), il carattere speciale EOF viene inserito automaticamente alla fine del file "testo". In questo caso il programma prende in input il contenuto di "testo" e stampa a video (carattere per carattere), il contenuto del file, finchè non riconosce il carattere speciale EOF, che fa terminare il ciclo while.

----
questo è l'esercizio visto in aula. Il punto da notare è l'uso dell'assegnazione all'interno del controllo del ciclo while. E' una struttura tipica del linguaggio C che semplifica sintatticamente la scrittura del programma.
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 10:02, 17 October 2015 (CEST)

== programma 1 ==
<syntaxhighlight lang="C">
#include <stdio.h>

char s1[]="hello world";
char *s2="hello world";

void foo(char *s) {
printf("%s\n",s);
s[4]=',';
printf("%s\n",s);
}

int main(int argc, char *argv[]) {
foo(s1);
foo(s2);
return 0;
}
</syntaxhighlight>
In questo esempio viene mostrata la differenza tra stringa variabile (s1) e stringa costante (s2). Nel primo caso a tempo di compilazione la stringa costante "hello world" viene copiata passo nella stringa variabile s1 consentendo le normali operazioni di modifica della stringa stessa. Mentre nel secondo caso a tempo di compilazione viene creata la stringa costante "hello world" e memorizzato il suo indirizzo nella variabile s2 NON consentendo le normali operazioni di modifica delle stringa stessa in quanto appunto un costante. ([[User:S.G|S.G]])
== programma 2 ==
<syntaxhighlight lang="C">
#include <stdio.h>

char t[]="test";
struct st {
char s[5];
char *t;
} st0={"test",t};

void foo (struct st i) {
i.s[2]='n';
i.t[2]='n';
}

void bar (struct st *i) {
i->s[2]='x';
i->t[2]='x';
}

int main(int argc, char *argv[]) {
printf("%s %s\n",st0.s,st0.t);
foo(st0); /* Vengono copiati i valori della struttura st0 in i, le uniche modifiche saranno sul campo i.t in quanto puntatore. */
printf("%s %s\n",st0.s,st0.t);
bar(&st0); /* Viene copiato l'indirizzo della struttura st0 in i, le modifiche vengono apportate su tutti i campi delle struttura. */
printf("%s %s\n",st0.s,st0.t);
return 0;
}
</syntaxhighlight>
Output del programma:

test test

test tent

text text

([[User:S.G|S.G]])

----
Sì, ma perché? Come è fatta la struttura st? [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 10:06, 17 October 2015 (CEST)

----
La struttura st è fatta da un array di 5 caratteri e da un puntatore a caratteri (che viene usato anch'esso per puntare ad un'array di caratteri).

Con la prima chiamata a printf vengono stampati i valori dei campi della struttura non ancora modificati, dal momento che non è stata ancora chiamata nè la funzione foo nè la funzione bar (test test)

In seguito viene passata la struct st0 alla funzione foo. In particolare viene passata alla funzione una COPIA del primo campo e una COPIA del secondo campo; tuttavia essendo il secondo campo della struttura un puntatore, viene passato il valore del puntatore, che è un indirizzo, cioè l'indirizzo a cui si trova l'array t (char t[]="test"). Per questo motivo viene modificato solo il valore del secondo campo nella struttura st0, infatti quando la funzione termina, la copia del primo campo viene persa, senza aver modificato il valore originale, mentre il valore del secondo campo viene modificato perchè l'abbiamo modificato tramite l'indirizzo. L'output finale sarà quindi: test tent.

Alla chiamata alla funzione bar, viene invece passato l'INDIRIZZO della struttura st0, e per questo quando andiamo a modificare i campi della struttura all'interno della funzione bar, non stiamo modificando una copia di st0, ma stiamo modificando direttamente st0, accedendo tramite puntatore ai suoi singoli campi. Quindi quando bar termina, i valori originali sono stati modificati e l'output risulterà: text text.

([[User:Alessio|Alessio]])

== programma 3 ==
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
while (argc > 1) {
int i,j;
char *s=argv[1];
for (i=0, j=strlen(s)-1; i < j; i++, j--)
s[i] ^= s[j], s[j] ^= s[i], s[i] ^= s[j];
printf("%s ",s);
argc--;
argv++;
}
printf("\n");
return 0;
}
</syntaxhighlight>
In questo esempio il programma effettua un reverse di tutte le parole che gli vengo date in input ad esclusione di argv[0] che sarebbe il nome del programma, esempio:

INPUT: ./programma3 ciao sistemi operativi

OUTPUT: oaic imetsis ivitarepo

Il punto importante di questo codice è che lo scambio delle singole lettere viene effettuato con l'operatore logico XOR senza cosi avere bisogno di una "variabile di scambio".
Qui viene spiegato nel dettaglio il [https://it.wikibooks.org/wiki/C/Variabili,_operatori_e_costanti/Operatori_sui_bit funzionamento dell'operatore logico]

([[User:S.G|S.G]])

== programma 4 ==
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

struct elem {
char *s;
struct elem *next;
};
struct elem *root=NULL;

void insert(char *s, struct elem **elp) { /* Inserimento in ordine alfabetico */
if (*elp && strcmp((*elp)->s, s) < 0) /* se la lista elp non è vuota e se (*elp)->s è alfabeticamente minore di s, inserisce in coda s */
insert(s,&((*elp)->next));
else { /* nel caso in cui la lista è vuota o se (*elp)->s è alfabeticamente maggiore di s, inserisce in testa s */
struct elem tmp={s,*elp};
struct elem *new=malloc(sizeof(struct elem));
*new=tmp;
*elp=new;
}
}

struct elem *print(struct elem *root) { /* stampa l'intera lista, alla fine dealloca root e restituisce NULL */
if (root) {
printf("%s ",root->s);
root->next=print(root->next);
free(root);
return NULL;
}
}

int main(int argc, char *argv[]) {
for (;argc>1;argc--,argv++) /* Scorre tutti gli elementi in input del programma (tranne il nome stesso del programma), aggiungendoli in una lista */
insert(argv[1],&root);
root=print(root);
printf("\n");
return 0;
}
</syntaxhighlight>
Il programma ordina alfabeticamente gli elementi presi input, esempio:

INPUT: ./programma4 ciao sistemi operativi e macchine virtuali

OUTPUT: ciao e macchine operativi sistemi virtuali

([[User:S.G|S.G]])

----
Però ci sono due tecniche diverse per la scrittura di funzioni ricorsive che modificano liste... Chi le spiega? [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 10:08, 17 October 2015 (CEST)

---

In quanto la lista va modificata, in questo esempio, è stato passato l'indirizzo di memoria del puntatore di testa della lista. Ne verrà quindi usata una copia all'interno della funzione ma, essendo una copia di un indirizzo di memoria, si andrà ugualmente ad agire fisicamente sulla struttura dati.
La seconda opzione è quella di passare la testa della lista come parametro, così facendo però ne verrà creata una copia. Per rendere quindi effettive le modifiche che avvengono nella funzione, bisogna quindi che la funzione non abbia risultato Void bensì deve ritornare come valore la testa della lista modificata. Nella chiamata della funzione è quindi necessario un assegnamento del tipo: head = func(head);

Alessandro Bandini

==Programma 5==
Propongo un esempio relativo all'uso dello statement static:

<syntaxhighlight lang="C">
#include <stdio.h>

int var;

int foo(){
static int var=0;
var++;
return var;
}

int bar(){
int var=0;
var ++;
return var;
}

int foobar(){
var++;
return var;
}

int main(int argc, char *argv[]){
int sum1, sum2, sum3;
int i;
for(i=0;i<100;i++){
sum1=foo();
}
printf("%d\n", sum1);
for(i=0;i<100;i++){
sum2=bar();
}
printf("%d\n", sum2);
for(i=0;i<100;i++){
sum3=foobar();
}
printf("%d\n", sum3);

return 0;
}
</syntaxhighlight>

Output del codice:

100

1

100

----

Le tre funzioni ''foo()'', ''bar()'' e ''foobar()'', sebbene si possa pensare agiscano sulla stessa variabile globale intera ''var'', hanno comportamenti diversi proprio perche' non agiscono sulla stessa variabile. Nella funzione ''foo()'', viene ridefinita una nuova variabile intera ''var'' che ha uno scope limitato al solo corpo della funzione (e' come se avesse una "precedenza" maggiore rispetto alla variabile globale); inoltre essa e' definita come ''static'': il valore della varibile non viene quindi salvato nello STACK della funzione bensi' nel segmento DATA, permettendo di avere il valore salvato anche dopo piu' chiamate della funzione.

Il discorso e' leggermente diverso per la funzione ''bar()'': anche qui viene ridefinita la variabile ''var'' ma non in modo static. Il valore di ''var'' e' quindi salvato nello STACK della funzione, che viene ricreato ad ogni chiamata. Sebbene ''bar()'' venga chiamata cento volte, a ''sum2'' viene assegnato solo un incremento, a causa dell'inizializzazione a 0 di ''var'' che avviene per ogni chiamata.

Infine, all'interno della funzione ''foobar()'' non viene definita una nuova variabile, quindi la ''var'' usata nel corpo e' la variabile globale definita in precedenza. Similmente ad una variabile static, anche il valore di una variabile globale viene memorizzato nel segmento DATA del programma, ed il cui valore rimane in memoria nonostante le successive chiamate della funzione.

Matteo Del Vecchio

==Programma 6==
Challenge: Cosa fa questo programma (progettato per processori atmega8/88/168 etc)?

<syntaxhighlight lang="C">
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/twi.h>
#include <inttypes.h>
#ifdef ATMEGA88
#define F_CPU 8000000UL // 8 MHz
#else
#define F_CPU 1000000UL // 1 MHz
#endif
#include <util/delay.h>

void delay_ms(unsigned int ms)
{
while(ms){
_delay_ms(0.96);
ms--;
}
}

#define DMASK 0x07
#define TWSR_STATUS_MASK 0xF8
#define TWCR_CMD_MASK 0x0F

unsigned char newB;
unsigned char oldB;
unsigned char diffB;
unsigned char status;
unsigned char unstable;
unsigned char step;
unsigned char value;
unsigned char d0,d1,d2,d3,d4,d5,d6,d7,d8;

static unsigned char i2cs_addr;

void i2cs_init(void)
{
TWCR = 1<<TWINT | 1<<TWEA | 1<<TWEN | 1<<TWIE;
TWAR = i2cs_addr;
}

void i2cs_command(unsigned char comm)
{
switch (comm & 0xF8) {
case 0x80:
if (step)
status &= ~(1<<(comm & 0x07));
else
PORTD &= ~(1<<(comm & 0x07));
break;
case 0x88:
if (step)
status |= (1<<(comm & 0x07));
else
PORTD |= (1<<(comm & 0x07));
break;
}
}

ISR(TWI_vect)
{
unsigned char i2c_status= TWSR & TWSR_STATUS_MASK;
switch (i2c_status) {
case TW_SR_DATA_ACK:
i2cs_command(TWDR);
TWCR = (TWCR & TWCR_CMD_MASK) | 1<<TWINT | 1<<TWEA;
break;
case TW_ST_SLA_ACK:
case TW_ST_DATA_ACK:
TWDR = status;
TWCR = (TWCR & TWCR_CMD_MASK) | 1<<TWINT | 1<<TWEA;
break;
default:
TWCR = (TWCR & TWCR_CMD_MASK) | 1<<TWINT | 1<<TWEA;
break;
}
}

int main(void)
{
DDRD = 0xFF;
PORTB = 0xFF;
PORTC = 0x0F;
delay_ms(10);
i2cs_addr= (0x20 | ((~PINC & 0x0F) << 1));
step = (i2cs_addr & 0x10) == 0;
i2cs_init();
sei();
while (1) {
delay_ms(1);
oldB=newB;
newB=~PINB;
diffB=oldB ^ newB;
unstable=0;
if (diffB & 0x01) d0 = 1; else d0++;
if (diffB & 0x02) d1 = 1; else d1++;
if (diffB & 0x04) d2 = 1; else d2++;
if (diffB & 0x08) d3 = 1; else d3++;
if (diffB & 0x10) d4 = 1; else d4++;
if (diffB & 0x20) d5 = 1; else d5++;
if (diffB & 0x40) d6 = 1; else d6++;
if (diffB & 0x80) d7 = 1; else d7++;
if(d0 & DMASK) unstable |= 0x01;
if(d1 & DMASK) unstable |= 0x02;
if(d2 & DMASK) unstable |= 0x04;
if(d3 & DMASK) unstable |= 0x08;
if(d4 & DMASK) unstable |= 0x10;
if(d5 & DMASK) unstable |= 0x20;
if(d6 & DMASK) unstable |= 0x40;
if(d7 & DMASK) unstable |= 0x80;
if (step) {
status ^= (newB & ~value & ~unstable);
value = (value & unstable) | (newB & ~unstable);
} else
status = (status & unstable) | (newB & ~unstable);
if (step)
PORTD=status;
}
return(0);
}
</syntaxhighlight>
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 08:06, 21 October 2015 (CEST)

==Programma 7==
Guardate queste costanti predefinite. Come le utilizzereste?

<syntaxhighlight lang="C">
#include <stdio.h>

int main(int argc, char *argv[]) {
printf("%s: line %d\n",__FILE__,__LINE__);
printf("built %s %s\n",__DATE__,__TIME__);
return 0;
}
</syntaxhighlight>

==Programma 8==
Un "effetto speciale" del preprocessore:

<syntaxhighlight lang="C">
#include <stdio.h>
#define ik(x) int k##x = x
#define ck(x) char *k##x = #x

ik(0);
ik(1);
ik(2);
ck(tricky);

int main(int argc, char *argv[]) {
printf("%d %d %d %s\n", k0, k1, k2, ktricky);
}
</syntaxhighlight>

Il programma stampa: 0 1 2 tricky

Questo e' dovuto al fatto che il preprocessore sostituisce ogni occorrenza di ik(x) con int k##x = x; Lo stesso avviene per la stringa tricky. Infatti se andiamo a guardare il programma facendo solo la fase di preproccessing dando il comando gcc -E [...] notiamo che diventa cosi':

<syntaxhighlight lang="C">
int k0 = 0;
int k1 = 1;
int k2 = 2;
char *ktricky = "tricky";

int main(int argc, char *argv[]) {
printf("%d %d %d %s\n", k0, k1, k2, ktricky);
}

</syntaxhighlight>

L'operatore ## concatena due argomenti senza lasciare spazi bianchi tra di loro, in questo caso concatena k ad x.
<br/>Non importa che ci sia uno spazio tra k e x. Vedi [http://www.cplusplus.com/doc/oldtutorial/preprocessor/]

[[User:Aletri|Aletri]] ([[User talk:Aletri|talk]])

==Programma 9==
Ecco un esempio di uso della libreria stdarg.

<syntaxhighlight lang="C">

#include <stdio.h>
#include <stdarg.h>

void intprint(int n, ...)
{
va_list ap;

va_start(ap, n);
while (n>0) {
int i;
printf("%d ",va_arg(ap,int));
n--;
}
printf("\n");
va_end(ap);
}

int main(int argc, char *argv) {
intprint(3,1,2,3);
intprint(5,1,2,3,4,5);
}
</syntaxhighlight>

==Programma 10==
Un po' di trucchi con le macro e le funzioni a numero variabile di parametri con passaggio di liste di parametri.

<syntaxhighlight lang="C">
#define _GNU_SOURCE
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>

#define debugprintf(fmt, ...) private_debugprintf((fmt),__FILE__,__LINE__, ##__VA_ARGS__)

int private_debugprintf(const char *fmt, ...)
{
va_list ap;
char *newfmt;
int rv;

va_start(ap, fmt);
asprintf(&newfmt,"File %%s Line %%d %s",fmt);
rv=vfprintf(stderr, newfmt, ap);
free(newfmt);
return rv;
}

char *name="douglas adams";
int value=42;

int main(int argc, char *argv[]) {
debugprintf("hello world, bug!\n");
debugprintf("string: %s int: %d\n",name,value);
}
</syntaxhighlight>

==Programma 11==
getopt e getopt_long sono molto utili.... ecco un esempio. Cosa fa questo programma?

<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <libgen.h>

void usage(char *progname) {
fprintf(stderr,
"Usage:\n"
"\t%s [-m num] [-r] args...\n"
"\t%s [--mul num] [--rev] args...\n",progname,progname);
exit(1);
}

int main(int argc, char *argv[]) {
int c, oindex;
int rev=0;
int mul=1;
static struct option long_options[] = {
{"mul", required_argument, 0, 'm'},
{"rev", no_argument, 0, 'r'}};
while ((c = getopt_long(argc, argv, "m:r",
long_options, &oindex)) > 0) {
switch (c) {
case 'm': mul = atoi(optarg);
break;
case 'r': rev = 1;
break;
default:
usage(basename(argv[0]));
}
}
for (; mul>0; mul--) {
if (rev) {
for(oindex=argc-1; oindex>=optind; oindex--)
printf("%s ",argv[oindex]);
} else {
for(oindex=optind; oindex<argc; oindex++)
printf("%s ",argv[oindex]);
}
}
printf("\n");
return 0;
}
</syntaxhighlight>

Sistemi Operativi:Community portal

2015-11-05T09:52:45Z

Aletri:

Pensavo di utilizzare questa pagina del community portal per scambiarci suggerimenti per quanto riguarda la parte di elettronica. <br/>
[[User:Aletri|Aletri]] ([[User talk:Aletri|talk]]) 09:58, 5 November 2015 (CET)

*[[RaspberryPi - Interfacciarsi con un relay, esempio]]
*[[Quale numero di GPIO usare?]]

Quale numero di GPIO usare?

2015-11-05T09:51:30Z

Aletri:

Il problema principale che mi sono posto andando a guardare la gpio map del Raspberry è stato: ho due numeri, quale dei due devo utilizzare?

Esistono due diversi modi per interfacciarsi con i GPIO:
#Notazione BOARD
#Notazione BROADCOM (BCM)

;Notazione BOARD
:La notazione BOARD e' quella piu semplice ed e' quella che (nella maggior parte dei casi) garantisce una maggiore portabilita' tra i vari modelli di Raspberry Pi. Essa consiste nel contare il numero del GPIO proprio come se stessimo leggendo in riga.
;Notazione BCM
:La notazione BCM fa riferimento alla numerazione dei registri dello specifico modello di processore che stiamo utilizzando, dato che scrivere su una periferica di I/O dal punto di vista del processore e' come scrivere in un registro.

[[File:Raspberry-Pi-GPIO-Layout-Model-B-Plus-rotated-2700x900-1024x341.png|200px|thumb|center|Mappa con numerazione BCM e BOARD]]

La notazione BCM e' quella che viene usata dal kernel quando vogliamo attivare direttamente il GPIO.
ad esempio possiamo dare i comandi per attivare il gpio 18 per controllare un relay:

<syntaxhighlight lang="bash">

echo 18 > /sys/class/gpio/export
echo "out" > /sys/class/gpio/gpio18/direction
echo 1 > /sys/class/gpio/gpio18/value

</syntaxhighlight>

Il GPIO numero 18 (in notazione BCM) e' quello che ha il "pallino" numero 12 (notazione BOARD).

Quale numero di GPIO usare?

2015-11-05T09:50:44Z

Aletri:

Il problema principale che mi sono posto andando a guardare la gpio map del Raspberry è stato: ho due numeri, quale dei due devo utilizzare?

Esistono due diversi modi per interfacciarsi con i GPIO:
#Notazione BOARD
#Notazione BROADCOM (BCM)

;Notazione BOARD
:La notazione BOARD e' quella piu semplice ed e' quella che (nella maggior parte dei casi) garantisce una maggiore portabilita' tra i vari modelli di Raspberry Pi. Essa consiste nel contare il numero del GPIO proprio come se stessimo leggendo in riga.
;Notazione BCM
:La notazione BCM fa riferimento alla numerazione dei registri dello specifico modello di processore che stiamo utilizzando, dato che scrivere su una periferica di I/O dal punto di vista del processore e' come scrivere in un registro.

[[File:Raspberry-Pi-GPIO-Layout-Model-B-Plus-rotated-2700x900-1024x341.png|200px|thumb|center|Mappa con numerazione BCM e BOARD]]

La notazione BCM e' quella che viene usata dal kernel quando vogliamo attivare direttamente il GPIO.
ad esempio possiamo dare i comandi per attivare il gpio 18 per controllare un relay:

<syntaxhighlight lang="bash">

echo 18 > /sys/class/gpio/export
echo "out" > /sys/class/gpio/gpio18/direction
echo 1 > /sys/class/gpio/value

</syntaxhighlight>

Il GPIO numero 18 (in notazione BCM) e' quello che ha il "pallino" numero 12 (notazione BOARD).

Quale numero di GPIO usare?

2015-11-05T09:29:46Z

Aletri: Created page with "Il problema principale che mi sono posto andando a guardare la gpio map del Raspberry è stato: ho due numeri, quale dei due devo utilizzare? Esistono due diversi modi per in..."

File:Raspberry-Pi-GPIO-Layout-Model-B-Plus-rotated-2700x900-1024x341.png

2015-11-05T09:24:37Z

Aletri: Aletri uploaded a new version of "File:Raspberry-Pi-GPIO-Layout-Model-B-Plus-rotated-2700x900-1024x341.png"

File:Raspberry-Pi-GPIO-Layout-Model-B-Plus-rotated-2700x900-1024x341.png

2015-11-05T09:21:02Z

Aletri:

Sistemi Operativi:Community portal

2015-11-05T09:02:52Z

Aletri: aggiunta notazione gpio BCM e BOARD

Pensavo di utilizzare questa pagina del community portal per scambiarci suggerimenti per quanto riguarda la parte di elettronica. -- [[User:Aletri|Aletri]] ([[User talk:Aletri|talk]]) 09:58, 5 November 2015 (CET)

*[[RaspberryPi - Interfacciarsi con un relay, esempio]]
*[[Quale numero di GPIO usare?]]

Sistemi Operativi:Community portal

2015-11-05T08:59:06Z

Aletri:

Pensavo di utilizzare questa pagina del community portal per scambiarci suggerimenti per quanto riguarda la parte di elettronica.
newline
[[User:Aletri|Aletri]] ([[User talk:Aletri|talk]]) 09:58, 5 November 2015 (CET)

*[[RaspberryPi - Interfacciarsi con un relay, esempio]]

Sistemi Operativi:Community portal

2015-11-05T08:58:06Z

Aletri:

Pensavo di utilizzare questa pagina del community portal per scambiarci suggerimenti per quanto riguarda la parte di elettronica.
[[User:Aletri|Aletri]] ([[User talk:Aletri|talk]]) 09:58, 5 November 2015 (CET)

*[[RaspberryPi - Interfacciarsi con un relay, esempio]]

RaspberryPi - Interfacciarsi con un relay, esempio

2015-11-04T21:37:01Z

Aletri: Programma per controllare le luci in casa

Vi posto il programmino in python che ho scritto per controllare un relay. Questo è il programma che uso per accendere e spegnere le luci in camera. Se siete particolarmente pigri come me potreste utilizzarlo come sveglia, o se ci allegate un programmino che controlla l'input di un rilevatore di movimenti potete accendere le luci automaticamente quando entrate in camera. B-)
Da notare che a quanto pare il relay abbia la logica invertita, per cui dando il segnale LOW in realtà mandiamo 3.3V (accendendo il relay) e dando invece HIGH si torna a 0V.
Ho appena iniziato a cimentarmi con il python quindi se avete suggerimenti li accetto ben volentieri.

<syntaxhighlight lang="python">
#!/usr/bin/env python3

#MagicLamp 1.0
#questo programma e' usato per controllare un relay. Esegue un controllo di esistenza su due file shut_path e interr_path.
#Se shut_path e' presente termina il programma; se interr_path è presente accende il relay.

import RPi.GPIO as GPIO
from time import sleep
import os

#numero del pin GPIO
pin1 = #numero del GPIO che state usando
#questo file (se presente) viene usato per terminare il programma
shut_path= '**qui la path dove viene controllata l'esistenza dell'interruttore di terminazione**'
#questo file (se presente) viene usato per accendere la luce
interr_path= '**qui la path dove viene controllata l'esistenza dell'interruttore di accensione e spegnimento**'
#questa variabile viene usata per controllare che la luce non sia gia' accesa cosi da non inviare il segnale due volte
on = False

GPIO.setmode(GPIO.BOARD)
GPIO.setup(pin1,GPIO.OUT) #utilizza il relay numero 1
#GPIO.output(pin1, GPIO.HIGH) #spegni la lampada

try:

#rimuovo shut_path se presente poichè viene usao in fase di terminazione del servizio
if (os.path.isfile (interr_path) == True):
os.remove(interr_path)
if (os.path.isfile (shut_path) == True):
os.remove( shut_path)
print ("MagicLamp 0.1..... Ready!")
sleep (1)
while (1):
shutdown = os.path.isfile (shut_path)
interruttore = os.path.isfile (interr_path)
if (interruttore == True and shutdown == False):
if (on == False): #se non e gia accesa
GPIO.output(pin1, GPIO.LOW) #accendi la lampada
print ("Accendo la luce...\n")
on = True
elif (shutdown == True):
if (on == True):
print ("Spengo la luce e termino il programma...\n")
#rimuovi i file di controllo per un riavvio pulito
os.remove( shut_path)
if (interruttore == True):
os.remove( interr_path)
else:
print ("Termino il programma")
break
else:
if (on == True):
GPIO.output(pin1, GPIO.HIGH) #spegni la luce
print ("Spengo la lampada\n")
on = False
sleep (5)
GPIO.output(pin1, GPIO.HIGH) #spengo la luce
GPIO.cleanup()

except KeyboardInterrupt:
GPIO.output(pin1, GPIO.HIGH)
GPIO.cleanup()
if (os.path.isfile (interr_path) == True):
os.remove( interr_path)
if (os.path.isfile (shut_path) == True):
os.remove( shut_path)
print('Termino il programma\n')
</syntaxhighlight>

potete poi accendere e spegnere la la luce con uno script fatto così:
<syntaxhighlight lang="bash">

#!/bin/bash

INTERRUTTORE="**path del vostro interruttore**"

if [ -e "$INTERRUTTORE" ]
then
rm "$INTERRUTTORE"
else
echo 1 > "$INTERRUTTORE"
fi

</syntaxhighlight>

Sistemi Operativi:Community portal

2015-11-04T21:12:40Z

Aletri: Aggiunta sezione di elettronica

Pensavo di utilizzare questa pagina del community portal per scambiarci suggerimenti per quanto riguarda la parte di elettronica.
- Aletri

*[[RaspberryPi - Interfacciarsi con un relay, esempio]]

Genesi del linguaggio C: intenzioni degli autori

2015-10-08T08:13:48Z

Aletri: Created page with "''[Questo articolo raccoglie anche alcuni dei punti precedenti]'' Il linguaggio C è definito come un linguaggio imperativo e general purpose. Imperativo poichè composto da ..."

''[Questo articolo raccoglie anche alcuni dei punti precedenti]''

Il linguaggio C è definito come un linguaggio imperativo e general purpose. Imperativo poichè composto da ''statement'' che cambiano lo ''stato'' di un programma. Il funzionamento di un linguaggio imperativo quindi è molto simile a quello dell'omonimo verbo italiano, ovvero il programmatore impartisce ordini al programma ed esso esegue.
C è un linguaggio inventato nel 1969 da Dennis Ritchie alla AT&T Bell Labs ed è stato subito adottato in molti ambiti per via della sua plasticità ed efficienza. E' un inguaggio che è stato ridotto all'osso, esso infatti prevede (nelle versioni più moderne) soltanto 32 parole chiave. Tutte le altre funzionionalità (come printf, ecc..) sono implementate a parte nelle librerie che poi potranno essere incluse con delle direttive al preprocessore. L'ottimizzazione del linguaggio C è andata poi ben oltre la semplice ottimizzazione della sintassi e della semantica, si è guardato anche alla produttività del programmatore; Questo ha portato alla scelta di utilizzare come operatore di assegnamento "=" anziché ":=" come si fa ad esempio in Pascal e di utilizzare il simbolo "==" (più complesso) per i confronti, dato che questi ultimi sono statisticamente meno numerosi dei primi.

Un altro punto chiave del C è quello di essere ad ampio spettro. Esso infatti fornisce funzionalità sia alto che di basso livello. Il programmatore ha il pieno controllo della momoria e delle variabili (con tutti i suoi vantaggi e svantaggi).

References:
* Wikipedia [https://en.wikipedia.org/wiki/C_%28programming_language%29]
* Linguaggio imperativo [https://en.wikipedia.org/wiki/Imperative_programming]

Lezioni Anno Accademico 2015/16

2015-10-08T07:18:39Z

Aletri: /* temi da trattare: ripasso linguaggio C */

''scrivete qui idee, riassunti dei concetti espressi, commenti approfondimenti sulle lezioni.''

== Lezione del 22 settembre 2015 ==

Introduzione al corso di Sistemi Operativi.

=== concetti ===
* Hardware vs. Software
* Informatica
* Scienza vs. Tecnologia
* Informazione (vs. Dato)
* Linguaggio
* Elaborazione-Memorizzazione-Comunicazione
* Algoritmo vs. Programma
* Hacker/Hacking (vs. Cracker)
* Maker
* Analogico-Digitale

== Lezione del 23 settembre 2015 ==

Storia dei Sistemi.... anche operativi.

=== concetti ===
* Architettura a livelli (Layer)
* SO come livello di astrazione (semplificazione, portabilita')
* SO come gestore di risorse (controllo, sicurezza, continuita' di servizio)
* Storia le generazioni: ingranaggi->Valvole termoioniche->Transistor->Circuiti integrati->Microprocessori
* I "ruoli" dell'informatica: ideatore, costruttore, programmatore, operatore, utente
* Multitasking (perche' e' possibile? perche' e quando e' necessario?)
* Interattivita'
* TIme sharing
* Multiuser (multiutente)
* UNIX
* Personal Computer (e i sistemi operativi)

== Lezione del 30 settembre 2015 ==

Il materiale per poter replicare l'esperimento sulla portabilità dei compilatori è [http://www.cs.unibo.it/~renzo/so/tools/portability3.tgz qui].

[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 09:38, 3 October 2015 (CEST)

Per gli esperimenti con le macchine virtuali:
* il file debian_wheezy_i386_desktop.qcow2 l'ho preso da qui: https://people.debian.org/~aurel32/qemu/i386/.
il comando per kvm è:
kvm -m 1G -drive file=$(echo debian_wheezy*.qcow2),cache=writeback -monitor stdio
* chi volesse provare debian hurd può scaricare l'immagine: debian-hurd-20150424.img da qui: https://www.debian.org/ports/hurd/hurd-install. Nella pagina è anche indicato come lanciare kvm (io aggiungerei -monitor stdio in fondo per avere la console di qemu-kvm).
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 09:47, 3 October 2015 (CEST)

=== concetti ===
* Conoscenze a breve, medio e lungo termine dell'informatica
* Linguaggio dell'Hardware
* X ''Virtuale'' (dove X rappresenta qualsiasi cosa)
* Emulazione/Simulazione
* virtualizzazione senza emulazione
* Cosa e', cosa non e' e dov'e' (realmente) il sistema operativo
* macchine virtuali
* Distribuzione e Ambiente Operativo
* Licenze: differenza fra Software Libero e Open Source

== Lezione del 07 ottobre 2015 ==

Ricordo che è in sospeso una domanda: [["l'arduino ha un sistema operativo?"]]

=== temi da trattare: ripasso linguaggio C ===
* Compilatori vs. Interpreti
* Programmi vs. Script
* Le classi di linguaggi di programmazione
* Il "livello" dei linguaggi di programmazione
* Cosa e', cosa non e' il Linguaggio C
* [[Genesi del linguaggio C: intenzioni degli autori]]
* Le '''vere''' novita' del linguaggio C

=== temi da trattare: ripasso architettura ===
* Modelli architetturali: von Neumann vs. Harvard
* Struttura del processore: Control Path, Data Path
* CISC vs RISC
* Bus Indirizzi, Bus Dati, Gerarchie di Bus
* Interrupt (e Trap)
* Mascheramento degli Interrupt
* Gestione nidificata degli interrupt
* DMA (Direct Memory Access)
* Gerarchia di Memeoria
* Cache
* Indirizzi Logici, Indirizzi Fisici
* Rilocazione

== Lezione del 14 ottobre 2015 ==

== Lezione del 21 ottobre 2015 ==

== Lezione del 28 ottobre 2015 ==

"l'arduino ha un sistema operativo?"

2015-10-08T07:02:44Z

Aletri: Created page with "I programmi di Arduino vengono caricati tramite un programma chiamato [Sketch : http://arduino.cc/en/Main/Software]. Il programma caricato viene preso in gestione da un bootst..."

I programmi di Arduino vengono caricati tramite un programma chiamato [Sketch : http://arduino.cc/en/Main/Software]. Il programma caricato viene preso in gestione da un bootstrapper che però, a differenza degli altri sistemi comuni, rimane in esecuzione per tutto il tempo. Infatti i programmi per Arduino non hanno main, ma hanno una funzione di loop che viene chiamata ripetutamente dal bootstrapper.
Dalla definizione di Sistema Operativo ricordiamo che:
un sistema operativo è un programma che viene avviato al momento del boot e rimane in esecuzione per tutto il tempo.

Notiamo quindi che nel caso dell'Arduino il bootstrapper potrebbe essere considerato una sorta di sistema operativo, sebbene i programmi abbiano accesso diretto all'hardware.

Lezioni Anno Accademico 2015/16

2015-10-08T06:29:04Z

Aletri: /* Lezione del 07 ottobre 2015 */

''scrivete qui idee, riassunti dei concetti espressi, commenti approfondimenti sulle lezioni.''

== Lezione del 22 settembre 2015 ==

Introduzione al corso di Sistemi Operativi.

=== concetti ===
* Hardware vs. Software
* Informatica
* Scienza vs. Tecnologia
* Informazione (vs. Dato)
* Linguaggio
* Elaborazione-Memorizzazione-Comunicazione
* Algoritmo vs. Programma
* Hacker/Hacking (vs. Cracker)
* Maker
* Analogico-Digitale

== Lezione del 23 settembre 2015 ==

Storia dei Sistemi.... anche operativi.

=== concetti ===
* Architettura a livelli (Layer)
* SO come livello di astrazione (semplificazione, portabilita')
* SO come gestore di risorse (controllo, sicurezza, continuita' di servizio)
* Storia le generazioni: ingranaggi->Valvole termoioniche->Transistor->Circuiti integrati->Microprocessori
* I "ruoli" dell'informatica: ideatore, costruttore, programmatore, operatore, utente
* Multitasking (perche' e' possibile? perche' e quando e' necessario?)
* Interattivita'
* TIme sharing
* Multiuser (multiutente)
* UNIX
* Personal Computer (e i sistemi operativi)

== Lezione del 30 settembre 2015 ==

Il materiale per poter replicare l'esperimento sulla portabilità dei compilatori è [http://www.cs.unibo.it/~renzo/so/tools/portability3.tgz qui].

[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 09:38, 3 October 2015 (CEST)

Per gli esperimenti con le macchine virtuali:
* il file debian_wheezy_i386_desktop.qcow2 l'ho preso da qui: https://people.debian.org/~aurel32/qemu/i386/.
il comando per kvm è:
kvm -m 1G -drive file=$(echo debian_wheezy*.qcow2),cache=writeback -monitor stdio
* chi volesse provare debian hurd può scaricare l'immagine: debian-hurd-20150424.img da qui: https://www.debian.org/ports/hurd/hurd-install. Nella pagina è anche indicato come lanciare kvm (io aggiungerei -monitor stdio in fondo per avere la console di qemu-kvm).
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 09:47, 3 October 2015 (CEST)

=== concetti ===
* Conoscenze a breve, medio e lungo termine dell'informatica
* Linguaggio dell'Hardware
* X ''Virtuale'' (dove X rappresenta qualsiasi cosa)
* Emulazione/Simulazione
* virtualizzazione senza emulazione
* Cosa e', cosa non e' e dov'e' (realmente) il sistema operativo
* macchine virtuali
* Distribuzione e Ambiente Operativo
* Licenze: differenza fra Software Libero e Open Source

== Lezione del 07 ottobre 2015 ==

Ricordo che è in sospeso una domanda: [["l'arduino ha un sistema operativo?"]]

=== temi da trattare: ripasso linguaggio C ===
* Compilatori vs. Interpreti
* Programmi vs. Script
* Le classi di linguaggi di programmazione
* Il "livello" dei linguaggi di programmazione
* Cosa e', cosa non e' il Linguaggio C
* Genesi del linguaggio C: intenzioni degli autori
* Le '''vere''' novita' del linguaggio C

=== temi da trattare: ripasso architettura ===
* Modelli architetturali: von Neumann vs. Harvard
* Struttura del processore: Control Path, Data Path
* CISC vs RISC
* Bus Indirizzi, Bus Dati, Gerarchie di Bus
* Interrupt (e Trap)
* Mascheramento degli Interrupt
* Gestione nidificata degli interrupt
* DMA (Direct Memory Access)
* Gerarchia di Memeoria
* Cache
* Indirizzi Logici, Indirizzi Fisici
* Rilocazione

== Lezione del 14 ottobre 2015 ==

== Lezione del 21 ottobre 2015 ==

== Lezione del 28 ottobre 2015 ==

Main Page

2015-10-01T07:18:29Z

Aletri:

Questo è il Wiki del Corso di Sistemi Operativi

[[Materiale dell'AA 2015-16]]

[[Materiale dell'AA 2014-15]]

[[Materiale dell'AA 2013-14]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]