# file es260607
# soluzione del compito del 26 giugno 2007
# parte principale shell

if test $# -lt 2
then
   echo Errore nel numero dei parametri
   echo USO: $0 direttorio c1, c2, ...
   exit 1
fi

case $1 in
/*) if test ! -d $1
    then
     echo Errore: $1 non direttorio
     exit 2
    fi;;
*) echo Errore: $1 non nome assoluto
   exit 3 ;;
esac

DIR=$1
# elimino il primo parametro
shift

#controllo parametri/caratteri
for i in $*
do
  case $i in
  ?) ;;
  *) echo Errore: il parametro $i non un singolo carattere
     exit 4 ;;
  esac
done

PATH=`pwd`:$PATH
export PATH

# chiamata alla parte ricorsiva
cerca260607 $DIR $*


# file cerca260607
# soluzione del compito del 26 giugno 2007
# parte ricorsiva shell

cd $1
shift 
for i in *
do
  #se un file
  if test -f $i
  then
    # lunghezza del file
    dim=`wc -c < $i `
    # se pari
    if test `expr $dim % 2` -eq 0
    then
      cont=0
      # cerca i caratteri nel file
      for j in $*
      do
        if grep $j $i 2>&1 >/dev/null
        then
          cont=`expr $cont + 1`
        fi
      done
      # se il numero di caratteri trovati
      # e' uguale al numero di parametri
      if test $cont -eq $#
      then
        echo Trovato file `pwd`/$i
        partec260607 $i $*
      fi
    fi
  fi
done

# chiamata ricorsiva
for i in *
do
 if test -d $i -a -x $i
 then
  cerca260607 `pwd`/$i $*
 fi
done


/* file partec260607.c */

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

typedef int pipe_t[2];
typedef struct {
  long pos;
  int val;
} messaggio;

main(int argc, char *argv[])
{
  int i, pid, N, cont, j, fdr, pos2[2], status, r, r1;
  long lun, p;
  pipe_t *pp;
  char c[2], ch;
  messaggio msg, msg1;
  
  if (argc < 3)
  { printf("Errore nel numero dei parametri\n");
    exit(1);
  }
  
  /* calcoliamo il numero di processi figli da creare */
  N = argc - 2;
  
  /* alloca l'array di pipe */
  if ((pp = malloc(N*sizeof(pipe_t))) == 0)
  { printf("Errore nella malloc\n");
    exit(1);
  }
  
  /* crea le N pipe. NOTA BENE: Ne bastano N dato che ogni coppia figlio-nipote usera' la stessa pipe per comunicare con il padre */            
  for (i=0; i < N; i++)
    if (pipe(pp[i]) < 0)
    { printf("Errore nella creazione della pipe\n");
      exit(1);
    }

  printf("Padre con pid %d\n", getpid());
              
  for (i=0; i < N; i++)
  {
    if ((pid = fork()) < 0)
    { printf ("Errore nella fork\n");
      exit(1);
    }
    
    if (pid == 0) /* figlio */
    {
      printf("Figlio %d con pid %d\n", i, getpid());
      
      /* chiude tutte le pipe non usate */
      for (j=0; j<N; j++)
      { if (j != i)
          close(pp[j][1]);
        close(pp[j][0]);
      }
      /* NOTA BENE: la pipe pp[i] verra' usata anche dal nipote che non dovra' fare nessuna chiusura */	
      /* genera il nipote */
      if ((pid = fork()) < 0)
      { printf ("Errore nella fork\n");
        exit(1);
      }
    
      /* SIA il processo figlio che il processo nipote devono aprire lo STESSO file: codice comune */
      if ((fdr = open(argv[1], O_RDONLY)) < 0)
      { printf ("Errore nell'apertura del file %s\n", argv[1]);
        exit(1);
      }
      
      /* SIA il processo figlio che il processo nipote calcolano la lunghezza del file: codice comune  */
      lun = lseek(fdr, 0, SEEK_END);
      
      if (pid == 0)
        { /* il nipote si posiziona a meta' */
          lseek(fdr, lun/2, SEEK_SET);
/* mantiene la posizione corrente: in alternativa di puo' usare lseek per sapere a che punto siamo */          
          p = lun/2;     
          msg.val = 1; /* nipote */
        }
      else
        { /* il figlio si posiziona all'inizio */
          lseek(fdr, 0, SEEK_SET);
          p = 0;        /* mantiene la posizione corrente */
          msg.val = 0;  /* figlio */
        }

      cont = 0;      /* conta le occorrenze (solo per il figlio) */
      msg.pos = -1L; /* inizializza la posizione */
      for (j=0; j < lun/2; j++)
      {
        if (read(fdr, &ch, 1) < 0)
        { printf("Errore nella lettura\n");
          exit(1);
        }
        /****  printf("processo %d controlla %c\n", getpid(), ch); *****/
        /* cerca il carattere i-esimo */
        if (ch == argv[i+2][0])
        {
          cont++;
          /* se e' la prima occorrenza trovata */
          if (msg.pos == -1L)
          {
            /* memorizza la posizione */
            msg.pos = p;
            /* e invia la struttura al padre */
            write(pp[i][1], &msg, sizeof(msg));
            /* il nipote esce */
            if (msg.val == 1)
              exit(0);
          }
        }
        /* in ogni caso, incrementa la posizione */
        p++;
      }
      
      /* se il carattere non e' stato trovato */
      if (msg.pos == -1)
      /* invia la struttura */
      write(pp[i][1], &msg, sizeof(msg));
                  
      exit(cont);
    } /* fine figlio e nipote: il nipote manda un valore di ritorno al figlio che non viene considerato */
  }
  /* padre */
  /* chiude tutte le pipe non usate */
  for (j=0; j < N; j++)
    close(pp[j][1]);

  /* legge dalle pipe */
  for (i=0; i < N; i++)
  {
/* dalla stessa pipe si leggono le due strutture, una inviata dal figlio e una dal nipote: nota bene che l'ordine non e' noto! */
    if ((r = read(pp[i][0], &msg, sizeof(msg))) < 0)
      printf ("Errore nella lettura della pipe %d\n", i);
    if ((r1 = read(pp[i][0], &msg1, sizeof(msg))) < 0)
      printf ("Errore nella lettura della pipe %d\n", i);
    /* se ha letto da entrambe le pipe */
    if ((r != 0) && (r1 != 0))
    {
      if ((msg.pos == -1) && (msg1.pos == -1))
/* la parte shell garantisce che questo caso non si verifichi mai! */
        printf("Carattere %c non trovato\n", argv[i+2][0]);
      else
      {
        if (msg.pos > -1)
          if (msg.val == 0)
            printf("Carattere %c trovato nella prima meta'\n", argv[i+2][0]);
          else
            printf("Carattere %c trovato nella seconda meta'\n", argv[i+2][0]);
        if (msg1.pos > -1)
          if (msg1.val == 0)
            printf("Carattere %c trovato nella prima meta'\n", argv[i+2][0]);
          else
            printf("Carattere %c trovato nella seconda meta'\n", argv[i+2][0]);
      }
    }
  }

  for (i=0; i<N; i++)
  {
    pid = wait(&status);
    status = (status >> 8) & 0xFF;
    printf("Il figlio con pid %d ha trovato %d occorrenze\n", pid, status);
  }
}