Sistemi Operativi - User contributions [en]

Esercizio 1, prova pratica 17.06.2014

2015-05-28T09:58:46Z

Davide.quadrelli2:

<source lang="text">
Occorre scrivere due programmi: mytar myuntar.
Mytar prende come parametro il nome di una directory e il nome di un file:
mytar ddd ddd.mytar
mytar crea il file indicato come secondo parametro e registra in esso tutti i file regolari presenti nella directory (ddd
nell'esempio). Ogni file e' registrato nel secondo il seguente formato:
nome del file (stringa ASCII terminata da un byte 0)
lunghezza del file (stringa ASCII terminata da 0, la lunghezza e' registrata come stringa in rappresentazione in base 10
per non avere problemi di endianess e di ampiezza dei campi)
contenuto del file (un numero di byte corrispondente alla lunghezza indicata sopra).
Myuntar fa l'operazione inversa:
myuntar ddd.mytar newddd
crea la directory indicata come secondo parametro e, in essa, tutti i file registrati in ddd.mytar.
Per provare i due programmi, al termine dell'esecuzione di due comandi simili a quelli degli esempi mostrati qui sopra per
mytar e myuntar, tutti i file regolari presenti in ddd devono esistere in newddd e devono avere tutti lo stesso contenuto.
Se create una directory ddd contenente solo file regolare l'output di “diff -R ddd newddd” deve essere vuoto.
</source>

==Soluzione di Dado==
mytar e myuntar entrambi funzionanti

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

#define MAX 20
#define MAXI 1024

/*codice copiato da internet che ipotizzo funzioni :) */

void reverse(char s[])
{
int i, j;
char c;

for (i = 0, j = strlen(s)-1; i<j; i++, j--) {
c = s[i];
s[i] = s[j];
s[j] = c;
}
}

void itoa(int n, char s[])
{
int i, sign;

if ((sign = n) < 0) /* record sign */
n = -n; /* make n positive */
i = 0;
do { /* generate digits in reverse order */
s[i++] = n % 10 + '0'; /* get next digit */
} while ((n /= 10) > 0); /* delete it */
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}

/*mytar*/
int main(int argc, char * argv[]){
if(argc!=3){
fprintf(stderr, "Wrong arguments number\n");
return -1;
}
else{
FILE *dest;
FILE *temp;
DIR *dir;
char length[MAX];
char *buf_read;
char zero='\0';
size_t n_readed;
struct stat buf;
struct dirent *entry;
if((dir=opendir(argv[1]))==NULL){
fprintf(stderr, "Error opendir\n");
exit(-1);
}
if((dest=fopen(argv[2],"w"))==NULL){
fprintf(stderr, "Error fopen\n");
exit(-1);
}
while((entry=readdir(dir))!=NULL){
buf_read=NULL;
chdir(argv[1]);
if(entry->d_type==DT_REG){
if(stat(entry->d_name,&buf)==-1){
fprintf(stderr, "Error stat\n");
exit(-1);
}
if((temp=fopen(entry->d_name,"r"))==NULL){
fprintf(stderr, "Error fopen_temp\n");
exit(-1);
}
write(fileno(dest),entry->d_name,strlen(entry->d_name)+1);
itoa(buf.st_size-1,length);
write(fileno(dest),length,strlen(length)+1);
/*scrivere dati*/
while(getdelim(&buf_read,&n_readed,EOF,temp)>0){
write(fileno(dest),buf_read,strlen(buf_read)-1);
}
free(buf_read);
}
}
printf("File mytar creato con successo!\n");
return 0;
}
}
</source>

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

int main(int argc, char * argv[]){
if(argc!=3){
fprintf(stderr, "Wrong arguments number\n");
exit(-1);
}else{
FILE *mytar;
FILE *tmp;
char nome[256];
int dim, i;
char readed[2],length[20];
nome[0]=length[0]=0;
readed[1]=0;
if(mkdir(argv[2],(mode_t)0777)==-1){
fprintf(stderr, "Error mkdir\n");
exit(-1);
}
if((mytar=fopen(argv[1],"r"))==NULL){
fprintf(stderr, "Error fopen\n");
exit(-1);
}
if(chdir(argv[2])==-1){
fprintf(stderr, "Errore chdir\n");
exit(-1);
}
while((fread(&readed,1,1,mytar))){
strcat(nome,readed);
while((fread(&readed,1,1,mytar))){
if(readed[0]=='\0') break;
strcat(nome,readed);
}
printf("Nome trovato: %s\n",nome);
if((tmp=fopen(nome,"w"))==NULL){
fprintf(stderr, "Error fopen files\n");
exit(-1);
}
while((fread(&readed,1,1,mytar))){
if(readed[0]=='\0') break;
strcat(length,readed);
}
dim=atoi(length);
printf("Lunghezza trovata: %s\n",length);
for(i=0; i<dim; i++){
fread(&readed,1,1,mytar);
write(fileno(tmp),&readed,1);
}
fclose(tmp);
nome[0]=0;
length[0]=0;
}
fclose(mytar);
printf("File myuntar scompattato correttamente, credo\n");
return 0;
}
}
</source>

== Soluzione di MV ==
<source lang="text">
Per ora ho fatto solo la prima parte, cioè mytar.
L'unico problema che non riesco a capire è che entra in un loop infinito (scrivendo all'infinito sul file che crea!) se viene usato nella cartella dell'eseguibile stesso...
</source>

<source lang="c">
/*-------------------------------------MYTAR.C--------------------------------------------*/

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

#define BUF_DIM 512

/* scrive nome, dimensione e contenuto del file indicato da src nel file dest (già aperto in scrittura) */
int filecpy(const char *src, const int dest, off_t size);

/* ---------------------------------- MAIN ------------------------------- */
int main(int argc, char* argv[])
{
DIR *ddd;
int f;
struct dirent *entry;
struct stat dest_st;
int e,i,len;
char buf[BUF_DIM];

if(argc != 3)
{
printf("Error: needed 2 parameters\n");
return 1;
}

umask(0001);
/* Creo il file passato come secondo parametro */
if((f = open(argv[2], O_WRONLY|O_CREAT|O_TRUNC, 0666)) == -1)
{
printf("Error in open(): %s (%i)\n",strerror(errno),errno);
return errno;
}

/* Apro la directory passata come primo parametro, se c'è */
if((ddd = opendir(argv[1])) == NULL)
{
printf("Error in opendir(%s): %s (%i)\n",argv[1],strerror(errno),errno);
return errno;
}
/* mi sposto in quella directory */
if(chdir(argv[1]) == -1)
{
printf("Error in chdir(%s): %s (%i)\n",argv[1],strerror(errno),errno);
return errno;
}

e = errno;
i = 0; /* in i mantengo il numero totale di file copiati */
/* leggo lo stat del file che ho creato */
if(fstat(f, &dest_st) == -1)
{
printf("Error in stat(%s): %s (%i)\n",buf,strerror(errno),errno);
return errno;
}

/* leggo le entry della directory finchè ce ne sono */
while((entry = readdir(ddd)) != NULL)
{
struct stat st;

strcpy(buf, entry->d_name);

if(stat(buf, &st) == -1)
{
printf("Error in stat(%s): %s (%i)\n",buf,strerror(errno),errno);
return errno;
}
else if(st.st_mode & S_IFREG) /* è un file */
{
/* verifico che il file in questione sia diverso da quello aperto in scrittura, per evitare che scriva su se stesso all'infinito */
if((st.st_ino == dest_st.st_ino) && (st.st_rdev == dest_st.st_rdev))
continue;

if(filecpy(buf, f, st.st_size) == -1)
{
printf("Error in filecpy(%s, %i)\n",buf,f);
return -1;
}
printf("%s inserito.\n", buf);
i++;
}
}

if(e != errno) /* sono uscito dal ciclo a causa di un errore */
{
printf("Error in readdir(): %s (%i)\n",strerror(errno),errno);
return errno;
}
else /* perchè ho visitato tutte le entrate della directory */
printf("end of directory, %i entry found.\n", i);

return 0;
}

int filecpy(const char *src, const int dest, off_t size)
{
/* NB: dest è già aperto in scrittura */
int s, len, tot;
char buf[BUF_DIM];

if((s = open(src,O_RDONLY,0)) == -1) /* apro src in lettura */
return -1;

tot = write(dest, src, strlen(src)+1); /* per prima cosa copio il titolo del file src */
/* NB: faccio tot+1 per copiare anche lo 0 terminatore */
sprintf(buf, "%i", (int)size); /* poi copio la dimensione */
tot += write(dest, buf, strlen(buf)+1);

/* infine copio tutto il contenuto */
while( (len = read(s,buf,BUF_DIM)) != 0)
{
if(len == -1)
{
printf("Error in read(): %s (%i)\n",strerror(errno),errno);
return -1;
}
/*else printf("%i\n",len);*/
tot += write(dest, buf, len);
}

return tot; /* restituisce il numero totale di byte scritti */
}
</source>

Prova pratica 2014.05.29

2015-05-28T09:55:09Z

Davide.quadrelli2: Created page with "<source lang="text"> Scrivere un programma con un solo parametro. Come prima cosa il programma deve creare una directory con il path specificato nel parametro. Se la directory..."

Main Page

2015-05-28T09:50:40Z

Davide.quadrelli2:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizio 2 prova pratica 29.05.2014]]

[[Esercizio 1 Prova Pratica 30-05-11]]

[[Prova Teorica 14-02-2013]]

[[Prova Pratica Es.2 12-02-2009]]

[[Prova Teorica 13-05-2011]]

[[Prova Teorica 16-07-2014]]

[[Prova Pratica 20-02-2014]]

[[Prova Pratica 02-07-2014]]

[[Buffer Limitato]]

[[Esercizio 1-2 Prova Pratica 30-05-2012]]

[[Esercizio 3 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 30-05-2012]]

[[Esercizio 1 Prova Pratica 23-06-09]]

[[Esercizio 1 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 20-06-2013]]

[[Esercizio 3 Prova Pratica 29-05-14]]

[[Esercizio 2 esame 29/05/2014]]

[[Grep piramidale (non tanto grep) esame 2.7.2003]]

[[Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)]]

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

Esercizio 1, prova pratica 29.05.2014

2015-05-28T09:50:03Z

Davide.quadrelli2:

<source lang="text">
Scrivere un programma con un solo parametro.
Come prima cosa il programma deve creare una directory con il path specificato nel parametro. Se la directory esiste gia' o si
verifica un errore nella creazione, il programma deve terminare. Chiameremo questa directory “directory-base”
Il programma usando inotify rimane in attesa e stampa una riga di log per ogni file o directory creato o cancellato nella
directory-base. (solo nella directory-base, non nelle sottodirectory).
Quando viene cancellata la directory-base il programma termina.
</source>
==Soluzione di Pierg==
<source lang='c'>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <linux/inotify.h>

#define EVENT_SIZE ( sizeof (struct inotify_event) )
#define EVENT_BUF_LEN ( 1024 * ( EVENT_SIZE + 16 ) )

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

int stat, fd, wd, length, i = 0;
char *directory_base = argv[1];
char buffer[EVENT_BUF_LEN];
int boolean = 1;

/* Make the directory */
stat = mkdir(argv[1], S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);

/* Checking for error */
if (stat != 0) {
perror ("Error directory is not create");
}

/* Creating the INOTIFY instance */
fd = inotify_init();

/* Checking for error */
if ( fd < 0 ) {
perror("Error in inotify_init");
}

/* Adding the directory into watch list.
Here, the suggestion is to validate the existence of the directory before adding into monitoring list. */
wd = inotify_add_watch(fd, directory_base, IN_CREATE | IN_DELETE | IN_DELETE_SELF);

/* It continue until directory-base exist */
while (boolean != 0) {

/* Read to determine the event change happens on the directory.
Actually this read blocks until the change event occurs. */
length = read(fd, buffer, EVENT_BUF_LEN);

/* Checking for error */
if ( length < 0 ) {
perror("Error in read");
}

/* Actually read return the list of change events happens.
Here, read the change event one by one and process it accordingly. */
while (i < length) {

struct inotify_event *event = (struct inotify_event*) &buffer[i];

if (event->len) {

if (event->mask & IN_CREATE) {

if (event->mask & IN_ISDIR) {
printf("New directory %s created.\n", event->name);
}
else {
printf("New file %s created.\n", event->name);
}
break;
}
else if (event->mask & IN_DELETE) {

if (event->mask & IN_ISDIR) {
printf( "Directory %s deleted.\n", event->name );
}
else {
printf("File %s deleted.\n", event->name);
}
break;
}
/* Removing the directory */
else if (event->mask & IN_DELETE_SELF) {
boolean = 0;
printf( "Directory %s deleted.\n", event->name );
break;
}
}
i += EVENT_SIZE + event->len;
}
}
/* Removing the directory from the watch list */
inotify_rm_watch(fd, wd);

/* Closing the INOTIFY instance */
close(fd);
}
</source>

==Soluzione di Dado==

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

#define EVENT_SIZE (sizeof(struct inotify_event))
#define BUFFER_SIZE (100*(EVENT_SIZE+16))

/*dichiarazione di spy*/
void spy(char *path);

int main(int argc, char * argv[]){
if(argc!=2){
printf("Numero argomenti sbagliato\n");
return -1;
}else{
int res=mkdir(argv[1],(mode_t)0777);
if(res!=0)exit(-1);
else spy(argv[1]);
}
return 0;
}

/*metodo che utilizza la inotify*/
void spy(char *path){
int again=1;
int fd;
char buffer[BUFFER_SIZE];
/*inizializzo il File Descriptor dell inotify*/
fd=inotify_init();
/*aggiungo "handler" per creazioni, eliminazioni all'interno della cartella path e per la sua eliminazione*/
inotify_add_watch(fd,path, IN_CREATE | IN_DELETE | IN_DELETE_SELF);
/*ciclo del programma di attesa dei valori*/
printf("Entro in ascolto della cartella %s\n",path);
while(again){
int i=0;
int len=read(fd,buffer,BUFFER_SIZE);
while(i<len){
/*gestisco un evento alla volta*/
struct inotify_event *event =(struct inotify_event*)&buffer[i];
/*controllo eventuale creazione di un file o di una cartella*/
if(event->mask & IN_CREATE) {
/*distinguo i due casi distinti*/
if(event->mask & IN_ISDIR)
printf( "Cartella %s creata\n", event->name );
else
printf( "File %s creato\n", event->name );
}
/*controllo eventuale eliminazione di un file o di una cartella*/
else if(event->mask & IN_DELETE){
/*distinguo i due casi distinti*/
if(event->mask & IN_ISDIR)
printf( "Cartella %s eliminata\n", event->name );
else
printf( "File %s eliminato\n", event->name );
}
/*controllo eventuale eliminazione della cartella che sto controllando*/
else if(event->mask & IN_DELETE_SELF){
printf("Cartella in listening %s eliminata\n",path);
again=0; /*fermo il ciclo più esterno che esegue le read*/
}
/*avanzo all'evento successivo, se c'è*/
i += EVENT_SIZE + event->len;
}
}
}
</source>

Esercizio 1 Prova Pratica 30-05-11

2015-05-28T09:45:30Z

Davide.quadrelli2: Created page with "<source lang="text"> Scrivere due programmi in modo che i parametri passati al primo vengano stampati dal secondo. La comunicazione deve avvenire tramite una shared memory rea..."

<source lang="text">
Scrivere due programmi in modo che i parametri passati al
primo vengano stampati dal secondo. La comunicazione deve avvenire tramite una shared memory realizzata
con la chiamata POSIX shm_open, la sincronizzazione tramite segnali. Viene attivato per primo il programma
ricevente. (anche i pid dei processi possono venir scambiati attraverso la shared memory!).
Es: scrivere in un terminale:
$./receiver
l'esecuzione di “receiver rimane in attesa”. in un secondo terminale scrivere:
$./sender a bb ccc
nel primo deve comparire
./sender
a
bb
ccc
</source>
==Soluzione di Dado e Pierg==

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

int main(int argc, char * argv[]){
int fd,i;
fd=shm_open("/shared",O_RDWR,'w');
if(fd==-1){
fprintf(stderr,"Error while opening the shared memory\n");
}
for(i=0;i<argc;i++){
write(fd,argv[i],sizeof(argv[i]));
write(fd,"\n",1);
}
return 0;
}
</source>

receiver.c
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#define MAXLENGTH 1024

int main(int argc, char * argv[]){
int fd;
ssize_t dim;
char buff[MAXLENGTH];
fd=shm_open("/shared",O_RDWR,'r');
while((dim=read(fd,&buff,MAXLENGTH))){
write(stdout,buff,MAXLENGTH);
}
return 0;
}
</source>

Main Page

2015-05-28T09:42:06Z

Davide.quadrelli2:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizio 1 Prova Pratica 30-05-11]]

[[Prova Teorica 14-02-2013]]

[[Prova Pratica Es.2 12-02-2009]]

[[Prova Teorica 13-05-2011]]

[[Prova Teorica 16-07-2014]]

[[Prova Pratica 20-02-2014]]

[[Prova Pratica 02-07-2014]]

[[Buffer Limitato]]

[[Esercizio 1-2 Prova Pratica 30-05-2012]]

[[Esercizio 3 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 30-05-2012]]

[[Esercizio 1 Prova Pratica 23-06-09]]

[[Esercizio 1 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 20-06-2013]]

[[Esercizio 3 Prova Pratica 29-05-14]]

[[Esercizio 2 esame 29/05/2014]]

[[Grep piramidale (non tanto grep) esame 2.7.2003]]

[[Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)]]

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

Linker fisico (Prova pratica 20-02-2014)

2015-05-17T15:14:17Z

Davide.quadrelli2:

Il comando che dovrete implementare come script shell o programma python e' linkdir. linkdir prende due directory come parametri.

linkdir dira dirb

e deve creare in dirb un link fisico (non simbolico) a tutti i file regolari che sono in dira e non in dirb. Se un file regolare e'
presente con lo stesso nome sia in dira sia in dirb, nella directory dirb deve rim

===Soluzione di Claudio Kerov===
<source lang="bash">
#!/usr/local/bin/bash

if [[ -d $1 ]]; then
if [[ -d $2 ]]; then
dir1=$1
dir2=$2
fi
fi

ris1=`find $dir1 -type f | sort | cut -d "/" -f 2-`
ris2=`find $dir2 -type f | sort | cut -d "/" -f 2-`

indir1=`comm -2 -3 <(echo "$ris1") <(echo "$ris2")`
common=`comm -1 -2 <(echo "$ris1") <(echo "$ris2")`

for nome in $indir1; do
`ln ${dir1}/${nome} $dir2`
done

for file in $common; do
if [[ "${dir1}${file}" -ot "${dir2}${file}" ]]; then
`ln ${dir1}/${file} $dir2`
fi
done

</source>

===Soluzione di Maldus===
<source lang="python">
import os
import argparse

def main():
parser = argparse.ArgumentParser(description='linkdir')
parser.add_argument('dira', help='directory aggiornata')
parser.add_argument('dirb', help='directory da aggiornare')
args = parser.parse_args()

entrya = os.listdir(args.dira)
entryb = os.listdir(args.dirb)
for f in entrya:
if os.path.isfile(args.dira+'/'+f) and not f in entryb:
os.link( args.dira+'/'+f , args.dirb+'/'+f )
else:
timea = os.path.getmtime(args.dira+'/'+f)
timeb = os.path.getmtime(args.dirb+'/'+f)
if timea > timeb:
os.link( args.dira+'/'+f , args.dirb+'/'+f )

if __name__ == '__main__':
main()
</source>

Linker fisico (Prova pratica 20-02-2014)

2015-05-17T15:14:01Z

Davide.quadrelli2: Blanked the page

Prova Pratica 2014.02.20

2015-05-17T15:13:50Z

Davide.quadrelli2: Created page with "==Es. 1== <source lang="text"> Scrivere un programma in C “colonnan” che prenda come parametro il pathname di un file e un numero intero ..."

==Es. 1==
<source lang="text">
Scrivere un programma in C “colonnan” che prenda come parametro il pathname di un file
e un numero intero (che chiameremo n). Il programma deve stampare come output il numero di caratteri presenti
nella n-ma colonna del file se il file e' un file regolare di testo, non deve stampare nulla negli altri casi.
Un file viene considerato di testo se tutti i suoi byte hanno valori compresi nel range 1-127. Per controllare se il
file e' “regolare” usare la system call lstat.
</source>
===Soluzione di Dado===
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
int main(int argc, char * argv[]){
if(argc!=3){
printf("colonnan: 1st parameter is the pathname, the 2nd is the integer n\n");
}else{
struct stat info;
int ch,i=0,ret=0;
FILE *f;
int res=lstat(argv[1],&info);
int n=atoi(argv[2]);
if(n<=0){
fprintf(stderr, "Error: insert a number >0\n");
exit(-1);
}
if(res){
fprintf(stderr, "Error: lstat\n");
exit(-1);
}
if(S_ISREG(info.st_mode)){
f=fopen(argv[1],"r");
if(!f){
fprintf(stderr, "Error: fopen\n");
exit(-1);
}
while((ch=getc(f))!=EOF){
if(ch >=1 && ch <= 127){
if(ch==(char)'\n')i=0;
else{
i++;
if(i==n) ret++;
}
}else{
fprintf(stderr, "Error: not a text file\n");
}
}
printf("Result: %d\n",ret);
}else{
fprintf(stderr, "File is not a regular file\n");
exit(-1);
}
}
return 0;
}
</source>
==Es. 2==
<source lang="text">
Si scriva un programma C chiamato “colonnandir”. Il risultato del programma, stampato su standard output, deve essere un
solo numero intero: la somma del numero di caratteri presenti nelle n-me colonne di tutti i file regolari, di testo, non nascosti (il
primo carattere deve essere diverso da punto) della directory passata come parametro, ovvero della directory corrente se
colonnandir viene lanciato senza specificare parametri.
</source>
===Soluzione di Dado===
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
int count_col(char *path, int n){
int ch,i=0,ret=0;
FILE *f;
f=fopen(path,"r");
if(!f){
fprintf(stderr, "Error: fopen\n");
exit(-1);
}
while((ch=getc(f))!=EOF){
if(ch >=1 && ch <= 127){
if(ch==(char)'\n')i=0;
else{
i++;
if(i==n) ret++;
}
}else{
return 0;
}
}
return ret;
}

int main(int argc, char * argv[]){
if(argc!=3){
printf("colonnan: 1st parameter is the dir-name, the 2nd is the integer n\n");
exit(-1);
}else{
DIR *d;
int tot=0;
struct dirent *file;
int n=atoi(argv[2]);
d=opendir(argv[1]);
if(d==NULL){
fprintf(stderr, "Error: open directory\n");
exit(-1);
}
if(n<=0){
fprintf(stderr, "Error: insert a number >0\n");
exit(-1);
}
chdir(argv[1]);
while((file=readdir(d))!=NULL){
if(file->d_name[0]!='.' && file->d_type==DT_REG){
tot+=count_col(file->d_name,n);
}
}
printf("Result: %d\n",tot);
}
return 0;
}
</source>
==Es. 3==
<source lang="text">
Il comando che dovrete implementare come script shell o programma python e' linkdir. linkdir prende due directory come
parametri.
linkdir dira dirb
e deve creare in dirb un link fisico (non simbolico) a tutti i file regolari che sono in dira e non in dirb. Se un file regolare e'
presente con lo stesso nome sia in dira sia in dirb, nella directory dirb deve rimanere il file originariamente presente se e' piu'
recente di quello in dira altrimenti un link al file di dira con lo stesso nome.
</source>
===Soluzione di Dado===
<source lang="bash">
if [[ -n $1 ]]; then
if [[ -n $2 ]]; then
files=`ls $1`
for file in $files; do
if [[ -f $1/$file ]]; then
if [[ -e $2/$file ]]; then
if [[ $1/$file -nt $2/$file ]]; then
ln -P -f $1/$file $2/$file
fi
else
ln -P $1/$file $2/$file
fi
fi
done
fi
fi
</source>
===Soluzione di Claudio Kerov===
<source lang="bash">
#!/usr/local/bin/bash

if [[ -d $1 ]]; then
if [[ -d $2 ]]; then
dir1=$1
dir2=$2
fi
fi

ris1=`find $dir1 -type f | sort | cut -d "/" -f 2-`
ris2=`find $dir2 -type f | sort | cut -d "/" -f 2-`

indir1=`comm -2 -3 <(echo "$ris1") <(echo "$ris2")`
common=`comm -1 -2 <(echo "$ris1") <(echo "$ris2")`

for nome in $indir1; do
`ln ${dir1}/${nome} $dir2`
done

for file in $common; do
if [[ "${dir1}${file}" -ot "${dir2}${file}" ]]; then
`ln ${dir1}/${file} $dir2`
fi
done
</source>
===Soluzione di Maldus===
<source lang="python">
import os
import argparse

def main():
parser = argparse.ArgumentParser(description='linkdir')
parser.add_argument('dira', help='directory aggiornata')
parser.add_argument('dirb', help='directory da aggiornare')
args = parser.parse_args()

entrya = os.listdir(args.dira)
entryb = os.listdir(args.dirb)
for f in entrya:
if os.path.isfile(args.dira+'/'+f) and not f in entryb:
os.link( args.dira+'/'+f , args.dirb+'/'+f )
else:
timea = os.path.getmtime(args.dira+'/'+f)
timeb = os.path.getmtime(args.dirb+'/'+f)
if timea > timeb:
os.link( args.dira+'/'+f , args.dirb+'/'+f )

if __name__ == '__main__':
main()
</source>

Main Page

2015-05-17T15:06:31Z

Davide.quadrelli2:

Questo è il Wiki del Corso di Sistemi Operativi

[[Prova Pratica 20-02-2014]]

[[Prova Pratica 02-07-2014]]

[[Buffer Limitato]]

[[Esercizio 1-2 Prova Pratica 30-05-2012]]

[[Esercizio 3 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 30-05-2012]]

[[Esercizio 1 Prova Pratica 23-06-09]]

[[Esercizio 1 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 20-06-2013]]

[[Esercizio 3 Prova Pratica 29-05-14]]

[[Esercizio 2 esame 29/05/2014]]

[[Grep piramidale (non tanto grep) esame 2.7.2003]]

[[Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)]]

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

Prova Pratica 2012.05.30

2015-05-12T10:18:20Z

Davide.quadrelli2:

==Soluzione di Dado e Pierg==
<source lang="text">
Scrivere un minimake, cioe' una versione minimale del programma make.
Questo programma legge il file minimakefile nella directory corrente che ha il seguente formato:
target: comando
Il minimakefile e' scritto in modo che se le dipendenze sono generate da regole del minimakefile queste vengano definite
prima. Ad esempio il minimakefile per compilare ed eseguire il programma hw.c (hello world) sara':
hw.o: gcc -c hw.c
hw: gcc -o hw hw.o
run: ./hw
minimake deve scorrere il minimakefile, se il file indicato come target non esiste esegue il comando (e' vietato l'uso di popen,
system e simili!)
</source>

<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include "s2argv/s2argv.h"
#define MAKEFILE "minimakefile"
#define RUN "run"

int main(int argc, char * argv[]){
FILE *mf;
char *line=NULL;
char *target,*command;
int dim=0;
mf=fopen(MAKEFILE,"r");
if(mf==NULL){
fprintf(stderr,"minimakefile not found!\n");
exit(1);
}
while(getline(&line,&dim,mf)>0){
target=strtok(line,":");
command=strtok(NULL,"\n");
if(strcmp(target,RUN)==0){
system_noshell(command);
}
else if(fopen(target,"r")==NULL){
system_noshell(command);
}
else{
fprintf(stderr,"target %s già esistente: non eseguo\n",target);
}
}
free(line);
fclose(mf);
return 0;
}
</source>

<source lang="text">
la sintassi del minimakefile per l'esercizio2 deve prevedere le dipendenze come il vero makefile.
target: dependence1 dependence2
comando
comando
(come per il makefile il target viene scritto a inizio linea, i comandi hanno un tab come primo carattere)
es per compilare hw.c.
hw.o: hw.c
gcc -c hw.c
hw: hw.o
gcc -o hw hw.o
run: hw
hw
in questo caso occorre eseguire i comandi che seguono la regola di dipendenza solo se il file target non esiste o
se un file indicato come dipendenza e' stato modificato piu' recentemente del target.
</source>

<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <unistd.h>
#include "s2argv/s2argv.h"
#define MAKEFILE "minimakefile"
#define RUN "run"

int main(int argc, char * argv[]){
FILE *mf;
char *line=NULL;
char *target, *tmp;
int dim = 0;
int a = b = 0;
struct stat st_target, st_tmp;

mf=fopen(MAKEFILE,"r");
if(fd==NULL){
fprintf(stderr,"minimakefile not found!\n");
exit(1);
}
while(getline(&line,&dim,mf)>0){
if (line[0] == "\t") {
if(a || b){
system_noshell(line + 1);
}
}
else{
a = b = 0;
target = strtok(line, ":")
if(fopen(target,"r")==NULL){
a = 1;
}
else if(strcmp(target,RUN)==0){
char *command = strtok(NULL, "\n");
system_noshell(command);
}
else {
stat(target, &st_target);
while ((tmp = (strtok(NULL, " "))!=NULL){
stat(tmp, &st_tmp);
if (st_tmp.st_mtime > st_target.st_mtime ) {
b = 1;
break;
}
}
}
}
}
free(line);
fclose(fd);
return 0;
}
</source>

Esercizio 3 Prova Pratica 30-05-2012

2015-05-10T16:33:34Z

Davide.quadrelli2:

<source lang="text">
Lo script o il programma python prende il nome di una directory come parametro e deve listare i file nella directory che hanno
un file corrispondente con nome scritto al contrario (il file ailati deve essere nella lista solo se nella directory c'e' anche italia, i
palindromi devono essere listati una sola volta).
</source>
==Soluzione di Pierg==
<source lang ="python">
import sys, os

lines = []
directory = sys.argv[1]

for file in os.listdir(directory):
lines.append(file)

for el in lines:
for le in lines:
if el[::-1] == le:
print el
</source>
==Soluzione di Dado==
<source lang="bash">
#! /bin/bash
cd $1
files=`ls`
ls > /tmp/tmp.txt
rev /tmp/tmp.txt > /tmp/tmp2.txt
for file in $files; do
grep $file /tmp/tmp2.txt
done
rm /tmp/tmp.txt
rm /tmp/tmp2.txt
</source>

Esercizio 1 Prova Pratica 23-06-09

2015-05-10T16:31:51Z

Davide.quadrelli2: Created page with "<source lang ="text"> Scrivere un programma in linguaggio C denominato “scriptexec” che venga richiamato con un solo parametro: il nome di un file che contiene un elenco d..."

<source lang ="text">
Scrivere un programma in linguaggio C denominato “scriptexec” che venga
richiamato con un solo parametro: il nome di un file che contiene un elenco di comandi con i rispettivi parametri, uno per
riga.
Le righe che iniziano per '#' sono commenti.
Il programma esegue uno dopo l'altro i comandi presenti nel file.
(E'
vietato
l'uso di chiamate quali system o popen).
</source>
==Soluzione di Dado e Pierg==
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include "s2argv/s2argv.h"

int main(int argc, char * argv[]){
if(argc!=2){
printf("Wrong parameters number\n");
}else{
char *comm=NULL;
FILE *f;
ssize_t dim=0;
f=fopen(argv[1],"r");
if(f==NULL){
printf("Error while opening file %s\n",argv[1]);
exit(1);
}
while(getline(&comm,&dim,f)>0){
system_noshell(comm);
/*preparo comandi successivi*/
free(comm);
comm=NULL;
}
}
}
</source>

Main Page

2015-05-10T16:27:23Z

Davide.quadrelli2:

Questo è il Wiki del Corso di Sistemi Operativi
[[Esercizio 3 Prova Pratica 30-05-2012]]

[[Esercizio 1 Prova Pratica 23-06-09]]

[[Esercizio 1 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 20-06-2013]]

[[Esercizio 3 Prova Pratica 29-05-14]]

[[Esercizio 2 esame 29/05/2014]]

[[Grep piramidale (non tanto grep) esame 2.7.2003]]

[[Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)]]

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

Esercizio 2 esame 29/05/2014

2015-04-22T18:40:46Z

Davide.quadrelli2: /* Risoluzione Parte 2 */

<source lang="text">
Parte 1:
Scrivere un programma con un solo parametro.
Come prima cosa il programma deve creare una directory con il path specificato nel parametro. Se la directory esiste gia' o si
verifica un errore nella creazione, il programma deve terminare. Chiameremo questa directory “directory-base”
Il programma usando inotify rimane in attesa e stampa una riga di log per ogni file o directory creato o cancellato nella
directory-base. (solo nella directory-base, non nelle sottodirectory).
Quando viene cancellata la directory-base il programma termina.

Parte 2:
Si estenda il programma dell'esercizio 1 per operare anche nelle sottodirectory. Quindi il programma “dovrebbe” stampare una
riga di log per ogni file o directory creata o cancellata in tutto il sottoalbero che ha nella directory-base la radice.
Nota: se necessario, usate strutture dati molto semplici come vettori o liste semplici, non preoccupatevi dell'efficienza.
In realta' per un problema nel design dell'API inotify, alcuni eventi di creazione di directory nidificate troppo vicini nel tempo
possono venir perduti.
</source>
==Soluzione di Quadrelli==
===Risoluzione parte 1 ===
<source lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/inotify.h>

#define EVENT_SIZE (sizeof(struct inotify_event))
#define BUFFER_SIZE (100*(EVENT_SIZE+16))

/*dichiarazione di spy*/
void spy(char *path);

int main(int argc, char * argv[]){
if(argc!=2){
printf("Numero argomenti sbagliato\n");
return -1;
}else{
int res=mkdir(argv[1],(mode_t)0777);
if(res!=0)exit(-1);
else spy(argv[1]);
}
return 0;
}

/*metodo che utilizza la inotify*/
void spy(char *path){
int again=1;
int fd;
char buffer[BUFFER_SIZE];
/*inizializzo il File Descriptor dell inotify*/
fd=inotify_init();
/*aggiungo "handler" per creazioni, eliminazioni all'interno della cartella path e per la sua eliminazione*/
inotify_add_watch(fd,path, IN_CREATE | IN_DELETE | IN_DELETE_SELF);
/*ciclo del programma di attesa dei valori*/
printf("Entro in ascolto della cartella %s\n",path);
while(again){
int i=0;
int len=read(fd,buffer,BUFFER_SIZE);
while(i<len){
/*gestisco un evento alla volta*/
struct inotify_event *event =(struct inotify_event*)&buffer[i];
/*controllo eventuale creazione di un file o di una cartella*/
if(event->mask & IN_CREATE) {
/*distinguo i due casi distinti*/
if(event->mask & IN_ISDIR)
printf( "Cartella %s creata\n", event->name );
else
printf( "File %s creato\n", event->name );
}
/*controllo eventuale eliminazione di un file o di una cartella*/
else if(event->mask & IN_DELETE){
/*distinguo i due casi distinti*/
if(event->mask & IN_ISDIR)
printf( "Cartella %s eliminata\n", event->name );
else
printf( "File %s eliminato\n", event->name );
}
/*controllo eventuale eliminazione della cartella che sto controllando*/
else if(event->mask & IN_DELETE_SELF){
printf("Cartella in listening %s eliminata\n",path);
again=0; /*fermo il ciclo più esterno che esegue le read*/
}
/*avanzo all'evento successivo, se c'è*/
i += EVENT_SIZE + event->len;
}
}
}
</source>
===Risoluzione Parte 2===
Ho risolto l'esercizio senza utilizzare vettori o liste, come consigliato nel testo, ma utilizzando la fork.
<source lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <sys/inotify.h>

#define EVENT_SIZE (sizeof(struct inotify_event))
#define BUFFER_SIZE (100*(EVENT_SIZE+16))

/*dichiarazione di spy*/
int spy(char *path);

int main(int argc, char * argv[]){
if(argc!=2){
printf("Numero argomenti sbagliato\n");
return -1;
}else{
int res=mkdir(argv[1],(mode_t)0777);
if(res!=0)exit(-1);
else return spy(argv[1]);
}
}

/*metodo che utilizza la inotify*/
int spy(char *path){
int again=1;
int fd;
char buffer[BUFFER_SIZE];
/*inizializzo il File Descriptor dell inotify*/
fd=inotify_init();
/*aggiungo "handler" per creazioni, eliminazioni all'interno della cartella path e per la sua eliminazione*/
inotify_add_watch(fd,path, IN_CREATE | IN_DELETE | IN_DELETE_SELF);
/*ciclo del programma di attesa dei valori*/
printf("Entro in ascolto della cartella %s\n",path);
while(again){
int i=0;
int len=read(fd,buffer,BUFFER_SIZE);
while(i<len){
/*gestisco un evento alla volta*/
struct inotify_event *event =(struct inotify_event*)&buffer[i];
/*controllo eventuale creazione di un file o di una cartella*/
if(event->mask & IN_CREATE){
/*distinguo i due casi distinti*/
if(event->mask & IN_ISDIR){
int pid;
printf( "Cartella %s creata in %s\n",event->name,path);
pid=fork();
if(!pid){
char *newpath=malloc((strlen(path))+event->len+1); /*sommo 1 alla fine per lo /*/
strcpy(newpath,path);
strcat(newpath,"/");
strcat(newpath,event->name);
return spy(newpath);
}
}
else
printf("File %s creato in %s\n",event->name,path);
}
/*controllo eventuale eliminazione di un file o di una cartella*/
else if(event->mask & IN_DELETE){
/*distinguo i due casi distinti*/
if(!(event->mask & IN_ISDIR))
printf("File %s eliminato in %s\n",event->name,path);
}
/*controllo eventuale eliminazione della cartella che sto controllando*/
else if(event->mask & IN_DELETE_SELF){
printf("Cartella %s eliminata.\n",path);
again=0; /*fermo il ciclo più esterno che esegue le read*/
}
/*avanzo all'evento successivo, se c'è*/
i += EVENT_SIZE + event->len;
}
}
return 0;
}
</source>
Sfrutto la struttura gerarchica del filesystem per non preoccuparmi di possibili processi zombie. Il padre controlla la radice e ritornerà solo quando la radice sarà eliminata. Per eliminarla, bisogna prima "svuotarla", eliminando ogni file e directory al suo interno. Ciò mi assicura che ogni processo figlio (che sta controllando una sotto-cartella) terminerà prima del suo processo padre.

Esercizio 2 esame 29/05/2014

2015-04-22T18:39:51Z

Davide.quadrelli2: Created page with "<source lang="text"> Parte 1: Scrivere un programma con un solo parametro. Come prima cosa il programma deve creare una directory con il path specificato nel parametro. Se la ..."

<source lang="text">
Parte 1:
Scrivere un programma con un solo parametro.
Come prima cosa il programma deve creare una directory con il path specificato nel parametro. Se la directory esiste gia' o si
verifica un errore nella creazione, il programma deve terminare. Chiameremo questa directory “directory-base”
Il programma usando inotify rimane in attesa e stampa una riga di log per ogni file o directory creato o cancellato nella
directory-base. (solo nella directory-base, non nelle sottodirectory).
Quando viene cancellata la directory-base il programma termina.

Parte 2:
Si estenda il programma dell'esercizio 1 per operare anche nelle sottodirectory. Quindi il programma “dovrebbe” stampare una
riga di log per ogni file o directory creata o cancellata in tutto il sottoalbero che ha nella directory-base la radice.
Nota: se necessario, usate strutture dati molto semplici come vettori o liste semplici, non preoccupatevi dell'efficienza.
In realta' per un problema nel design dell'API inotify, alcuni eventi di creazione di directory nidificate troppo vicini nel tempo
possono venir perduti.
</source>
==Soluzione di Quadrelli==
===Risoluzione parte 1 ===
<source lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/inotify.h>

#define EVENT_SIZE (sizeof(struct inotify_event))
#define BUFFER_SIZE (100*(EVENT_SIZE+16))

/*dichiarazione di spy*/
void spy(char *path);

int main(int argc, char * argv[]){
if(argc!=2){
printf("Numero argomenti sbagliato\n");
return -1;
}else{
int res=mkdir(argv[1],(mode_t)0777);
if(res!=0)exit(-1);
else spy(argv[1]);
}
return 0;
}

/*metodo che utilizza la inotify*/
void spy(char *path){
int again=1;
int fd;
char buffer[BUFFER_SIZE];
/*inizializzo il File Descriptor dell inotify*/
fd=inotify_init();
/*aggiungo "handler" per creazioni, eliminazioni all'interno della cartella path e per la sua eliminazione*/
inotify_add_watch(fd,path, IN_CREATE | IN_DELETE | IN_DELETE_SELF);
/*ciclo del programma di attesa dei valori*/
printf("Entro in ascolto della cartella %s\n",path);
while(again){
int i=0;
int len=read(fd,buffer,BUFFER_SIZE);
while(i<len){
/*gestisco un evento alla volta*/
struct inotify_event *event =(struct inotify_event*)&buffer[i];
/*controllo eventuale creazione di un file o di una cartella*/
if(event->mask & IN_CREATE) {
/*distinguo i due casi distinti*/
if(event->mask & IN_ISDIR)
printf( "Cartella %s creata\n", event->name );
else
printf( "File %s creato\n", event->name );
}
/*controllo eventuale eliminazione di un file o di una cartella*/
else if(event->mask & IN_DELETE){
/*distinguo i due casi distinti*/
if(event->mask & IN_ISDIR)
printf( "Cartella %s eliminata\n", event->name );
else
printf( "File %s eliminato\n", event->name );
}
/*controllo eventuale eliminazione della cartella che sto controllando*/
else if(event->mask & IN_DELETE_SELF){
printf("Cartella in listening %s eliminata\n",path);
again=0; /*fermo il ciclo più esterno che esegue le read*/
}
/*avanzo all'evento successivo, se c'è*/
i += EVENT_SIZE + event->len;
}
}
}
</source>
===Risoluzione Parte 2===
<source lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <sys/inotify.h>

#define EVENT_SIZE (sizeof(struct inotify_event))
#define BUFFER_SIZE (100*(EVENT_SIZE+16))

/*dichiarazione di spy*/
int spy(char *path);

int main(int argc, char * argv[]){
if(argc!=2){
printf("Numero argomenti sbagliato\n");
return -1;
}else{
int res=mkdir(argv[1],(mode_t)0777);
if(res!=0)exit(-1);
else return spy(argv[1]);
}
}

/*metodo che utilizza la inotify*/
int spy(char *path){
int again=1;
int fd;
char buffer[BUFFER_SIZE];
/*inizializzo il File Descriptor dell inotify*/
fd=inotify_init();
/*aggiungo "handler" per creazioni, eliminazioni all'interno della cartella path e per la sua eliminazione*/
inotify_add_watch(fd,path, IN_CREATE | IN_DELETE | IN_DELETE_SELF);
/*ciclo del programma di attesa dei valori*/
printf("Entro in ascolto della cartella %s\n",path);
while(again){
int i=0;
int len=read(fd,buffer,BUFFER_SIZE);
while(i<len){
/*gestisco un evento alla volta*/
struct inotify_event *event =(struct inotify_event*)&buffer[i];
/*controllo eventuale creazione di un file o di una cartella*/
if(event->mask & IN_CREATE){
/*distinguo i due casi distinti*/
if(event->mask & IN_ISDIR){
int pid;
printf( "Cartella %s creata in %s\n",event->name,path);
pid=fork();
if(!pid){
char *newpath=malloc((strlen(path))+event->len+1); /*sommo 1 alla fine per lo /*/
strcpy(newpath,path);
strcat(newpath,"/");
strcat(newpath,event->name);
return spy(newpath);
}
}
else
printf("File %s creato in %s\n",event->name,path);
}
/*controllo eventuale eliminazione di un file o di una cartella*/
else if(event->mask & IN_DELETE){
/*distinguo i due casi distinti*/
if(!(event->mask & IN_ISDIR))
printf("File %s eliminato in %s\n",event->name,path);
}
/*controllo eventuale eliminazione della cartella che sto controllando*/
else if(event->mask & IN_DELETE_SELF){
printf("Cartella %s eliminata.\n",path);
again=0; /*fermo il ciclo più esterno che esegue le read*/
}
/*avanzo all'evento successivo, se c'è*/
i += EVENT_SIZE + event->len;
}
}
return 0;
}
</source>
Sfrutto la struttura gerarchica del filesystem per non preoccuparmi di possibili processi zombie. Il padre controlla la radice e ritornerà solo quando la radice sarà eliminata. Per eliminarla, bisogna prima "svuotarla", eliminando ogni file e directory al suo interno. Ciò mi assicura che ogni processo figlio (che sta controllando una sotto-cartella) terminerà prima del suo processo padre.

Main Page

2015-04-22T18:31:40Z

Davide.quadrelli2:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizio 2 esame 29/05/2014]]

[[Grep piramidale (non tanto grep) esame 2.7.2003]]

[[Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)]]

[[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-22T18:31:05Z

Davide.quadrelli2:

Questo è il Wiki del Corso di Sistemi Operativi

[[Grep piramidale (non tanto grep) esame 2.7.2003]]

[[Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)]]

[[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-22T18:29:58Z

Davide.quadrelli2:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizio 1, prova pratica 29.05.2014]]

[[Grep piramidale (non tanto grep) esame 2.7.2003]]

[[Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)]]

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

Esercizio 1 Prova Pratica 12-09-11

2015-04-14T11:06:47Z

Davide.quadrelli2: /* Soluzione di Pierg e Quadrelli */

Esercizio 1 Prova Pratica 12-09-11

2015-04-14T11:06:05Z

Davide.quadrelli2: Created page with "<source lang="text"> Siano date due directory del file system. Il programma deve cercare i file .c e .h presenti nelle due directory evidenziando quali sono presenti in una so..."

<source lang="text">
Siano date due directory del file system.
Il programma deve cercare i file .c e .h presenti nelle due directory evidenziando quali sono presenti in una sola
directory
Es:
$ cmpsource so.1.0 so.1.1
so.1.0/file.c not in so.1.1
so.1.1/head.h not in so.1.0
(L'ordine delle segnalazioni in output non e' importante).
</source>
==Soluzione di Pierg e Quadrelli==
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>

/*funzione per avere l'estensione del file*/
const char *get_filename_ext(const char *filename) {
const char *dot = strrchr(filename, '.');
if(!dot || dot == filename) return "";
return dot + 1;
}

/*funzione per comparare tutti i file tra una e l'altra directory*/
void cmp(char *path1,char *path2){
DIR *dir1,*dir2;
struct dirent *f1,*f2;
int bol;#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>

/*funzione per avere l'estensione del file*/
const char *get_filename_ext(const char *filename) {
const char *dot = strrchr(filename, '.');
if(!dot || dot == filename) return "";
return dot + 1;
}

/*funzione per comparare tutti i file tra una e l'altra directory*/
void cmp(char *path1,char *path2){
DIR *dir1,*dir2;
struct dirent *f1,*f2;
int bol;
if((dir1=opendir(path1))==NULL){
perror("ERRORE DIR1");
exit(-1);
}
while((f1=readdir(dir1))!=NULL){
bol=0;
if(strcmp(get_filename_ext(f1->d_name),"c")==0 || strcmp(get_filename_ext(f1->d_name),"h")==0){
if((dir2=opendir(path2))==NULL){
perror("ERRORE DIR2");
exit(-1);
}
while((f2=readdir(dir2))!=NULL){
if(strcmp(f1->d_name,f2->d_name)==0){
bol=1;
break;
}
}
closedir(dir2);
if(!bol){
printf("%s/%s not in %s\n",path1,f1->d_name,path2);
}
}
}
closedir(dir1);
}

/*main del programma*/
int main (int argc, char *argv[]){
if(argc!=3){
perror("PARAMETRI ERRATI");
exit(-1);
}
cmp(argv[1],argv[2]);
cmp(argv[2],argv[1]);
return 0;
}
if((dir1=opendir(path1))==NULL){
perror("ERRORE DIR1");
exit(-1);
}
while((f1=readdir(dir1))!=NULL){
bol=0;
if(strcmp(get_filename_ext(f1->d_name),"c")==0 || strcmp(get_filename_ext(f1->d_name),"h")==0){
if((dir2=opendir(path2))==NULL){
perror("ERRORE DIR2");
exit(-1);
}
while((f2=readdir(dir2))!=NULL){
if(strcmp(f1->d_name,f2->d_name)==0){
bol=1;
break;
}
}
closedir(dir2);
if(!bol){
printf("%s/%s not in %s\n",path1,f1->d_name,path2);
}
}
}
closedir(dir1);
}

/*main del programma*/
int main (int argc, char *argv[]){
if(argc!=3){
perror("PARAMETRI ERRATI");
exit(-1);
}
cmp(argv[1],argv[2]);
cmp(argv[2],argv[1]);
return 0;
}
</source>

Main Page

2015-04-14T11:02:37Z

Davide.quadrelli2:

Questo è il Wiki del Corso di Sistemi Operativi

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

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

Esercizio 3, prova pratica 13/09/2013

2015-04-04T09:24:39Z

Davide.quadrelli2:

Consegna([http://www.cs.unibo.it/~renzo/so/pratiche/2013.09.13.pdf]):
<source lang="text">
Sia data una directory che contiene file di testo.
Scopo dell'esercizio e' di contare i caratteri delle corrispondenti righe di testo di tutti i file della directory, si vuole cioe' sapere
il numero totale di caratteri presenti nelle prime righe di tutti i file, nelle seconde linee, ecc.
$ ccpl mydir
1 234
2 21
3 333
.....
l'ouput significa che se contiamo tutti i caratteri contenuti nella prima riga di tutti i file in mydir otteniamo 234 (mydir/file1
puo' avere 40 caratteri nella prima riga, mydir/file2 ne puo' avere 20, ecc... procedendo per tutti i file di mydir la somma fa
234).
</source>

===Soluzione di Maldus===
<source lang="bash">
#! /bin/bash

count=1 #conta il numero di riga che sto considerando
bool=1 #resta 1 finchè ci sono righe da contare in qualche file
file=`ls`

while [[ $bool -eq 1 ]]; do
tot=0
bool=0
for word in $file; do
if [[ (-r $word) && (-s $word) && (! $word = *~ ) ]]; then
x=`awk 'NR==c' c=$count $word | wc -m` #considero solo la riga contata da count
if [[ $x -ne 0 ]]; then #se la riga non è vuota
tot=`expr $tot + $x - 1` #con -1 tolgo il carattere \n che era stato contato da awk
bool=1 #bool=1 finchè c'è qualche riga da contare
fi
fi
done
if [[ $bool -eq 1 ]]; then
echo "$count: $tot"
fi
count=`expr $count + 1`
done
</source>

===Soluzione di Davide Quadrelli===
<source lang="bash">
#!/bin/bash
if [[ -n $1 ]]; then
cd $1
files=`ls -p | grep -v /` #elenco file
else
echo"Inserire cartella come parametro"
exit
fi
array=()
#per ogni file nella cartella
for file in $files; do
i=0
while read line; do
#conto la lunghezza di ogni riga e la aggiungo nella corrispondente cella dell'array
len=`expr length "${line}"`
array[$i]=`expr ${array[$i]} + $len`
((i++))
done < $file
done
#a questo punto l'i-esima cella contiene la somma delle lunghezze della i-esima riga di ogni file
i=1
for n in ${array[@]}; do
echo "$i $n"
((i++))
done
</source>

Prova Pratica 2014.06.17

2015-04-03T10:15:12Z

Davide.quadrelli2: /* Soluzione di Davide Quadrelli */

==Testo==
<source lang="text">
Il comando che dovrete implementare come script shell o programma python e' maxfreq.
Maxfreq ha come parametro un carattere alfanumerico e una directory.
Es:
maxfreq q mydir
Cerca in tutto il sottoalbero del file system originato da mydir il file che ha la maggior frequenza della lettera indicata (in
questo caso la maggior frequenza di 'q'). Fornisce in output il nome del file e la frequenza in percentuale.
</source>

===Soluzione di Davide Quadrelli===
<source lang="bash">
#! /bin/bash
if [[ -z $1 ]] ; then
echo "maxfreq [char da contare] [directory]"
exit
fi
if [[ -n $2 ]] ; then
files=`find -L $2`
else
echo if2
echo "maxfreq [char da contare] [directory]"
exit
fi
max=0
file=""
for var in $files; do
tmp=`cat $var 2> /dev/null | grep -c $1 2> /dev/null`
if [[ max -le tmp ]]; then
max=$tmp
file=$var
fi
done
dim=`ls -l $file | cut -d " " -f 5`
echo "( ${max} * 100 ) / ${dim}" > tmp
echo "quit" >> tmp
perc=`bc -q tmp`
rm tmp
echo "Il file $file contiene ${perc}% di $1 ($max su $dim caratteri)"
</source>
Ho sfruttato il comando bc per calcolare la percentuale. Utilizzo il parametro -q per impedire che stampi il "saluto" del programma e metto tutto il codice da eseguire nel file tmp. Oltre al comando, inserisco un "quit" per terminare il comando bc, che avrà restituito alla variabile soltanto il risultato del calcolo. Elimino poi ovviamente il file tmp.

Prova Pratica 2014.06.17

2015-04-03T10:12:33Z

Davide.quadrelli2: Created page with "==Testo== <source lang="text"> Il comando che dovrete implementare come script shell o programma python e' maxfreq. Maxfreq ha come parametro un carattere alfanumerico e una d..."

Main Page

2015-04-03T10:09:22Z

Davide.quadrelli2:

Questo è il Wiki del Corso di Sistemi Operativi

[[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-02T15:44:05Z

Davide.quadrelli2:

Questo è il Wiki del Corso di Sistemi Operativi

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

Prova pratica 17 07 14

2015-04-02T15:43:38Z

Davide.quadrelli2: Created page with "==Esercizio 1 == <source lang="text"> Scrivere un programma che per ogni file .c nella directory corrente chiami il compilatore gcc per generare il file oggetto (.o) a meno ch..."

==Esercizio 1 ==
<source lang="text">
Scrivere un programma che per ogni file .c nella directory corrente chiami il compilatore gcc per generare il file oggetto (.o) a
meno che esista gia' nella directory un file oggetto relativo allo stesso sorgente che sia piu' nuovo (ultima modifica) del
sorgente.
Tutti I parametri devono essere passati al compilatore.
Es:
genobj -I . -ggdb
se nella directory corrente esistono I file uno.c e due.c e il file due.o deve richiamare
gcc -I. -ggdb -c uno.c
e, solo se due.o ha ultima modifica precedente a due.c, deve chiamare
gcc -I. -ggdb -c due.c
</source>

===Soluzione di Davide Quadrelli===
<source lang="c">
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <stdlib.h>
#include <string.h>

#define MAX 256
#define DIM_MAX 1000
#define dim_last_data 4

int main (int argc, char *argv[]){
int i,len,com_size,bol=0;
struct stat o_data,f_data;
struct dirent *cur_file;
char name[MAX];
char prefix[DIM_MAX]="gcc ";
char *comm;
FILE *o;
FILE *obj=NULL;
DIR *dir=opendir("./");
/*store in prefix the common part of every command to launch*/
for (i=1;i<argc;i++){
strcat(prefix,argv[i]);
strcat(prefix," ");
}
com_size=strlen(prefix);
/*search in the current directory C files*/
while(cur_file=readdir(dir)){
if(cur_file->d_type==DT_REG){
/*it's a file*/
bol=0;
strcpy(name,cur_file->d_name);
printf("file found: %s ",name);
len=strlen(name);
if(strcmp(&(name[len-2]),".c")==0){
/*C file found*/
printf("... source code found ...");
/*check if the file has already an uptaded object file*/
name[len-1]='o';
if ((o=fopen(name,"r"))==NULL){
/*the corrispondent object file doesn't exists*/
bol=1;
name[len-1]='c';
}else{
fclose(o);
/*get the stat data of the object file*/
if(stat(name,&o_data)){
write(STDERR_FILENO,"ERRORE STAT",11);
exit(-1);
}
/*get the stat data of the C file*/
name[len-1]='c';
if(stat(name,&f_data)){
write(STDERR_FILENO,"ERRORE STAT",11);
exit(-1);
}
/*check if the object file must be re-created*/
if(o_data.st_mtime<f_data.st_mtime){
bol=1;
}
}
}
if(bol){
/*prepare and exec the command*/
comm=(char *)malloc(com_size+len+dim_last_data);
strcpy(comm,prefix);
strcat(comm,"-c ");
strcat(comm,name);
system(comm);
printf("object file created.\n%s",comm);
}
printf("\n\n");
}
}
return 0;
}
</source>

==Esercizio 3==
<source lang="text">
Il comando che dovrete implementare come script shell o programma python e' mytx.
Tale comando elenca tutti i file di una directory.
mytx ddd ddd.tx
Ogni riga del file di output (secondo parametro) deve contenere la lunghezza, uno spazio e il nume del file. Dopo l'ultima riga
deve inserire una riga bianca.
ddd.t2 deve contenere l'elenco dei file regolari. Il primo campo e' un numero intero seguito da uno spazio, tutto cio' che segue
fino alla fine riga e' il nome del file.
es.
12 file1
235 file di prova
</source>

===Soluzione di Davide Quadrelli===
<source lang="bash">
#!/bin/bash
#Interpreto la richiesta del testo come segue:
#implementare mytx ddd ddd.tx ove ddd è una directory, ddd.tx è un file
#mytx deve elencare i file della directory ddd scrivere nel file ddd.tx di output una riga per file contenente
#la lunghezza del file, uno spazio e il nome del file. ddd.tx deve terminare con una riga bianca.

if [[ -d $1 ]] ; then
ls $1
old=`pwd`
cd $1
files=`ls`
for var in $files ; do
if [[ -f $var ]]; then
wc -c ${var} 1>> ${old}/${2}
fi
done
echo >> ${old}/${2}

else
echo "inserire come primo parametro la directory e come secondo il file da scrivere"
fi
</source>