Programmi utili in C - ult. modif. 23-1-2016

Segui il link se vuoi copiare in Office con colori evidenziati!!!

Funzioni: random()/RANDOMIZE()

Funzioni I/O C

Vettori C

/* Funzione C scanfvet()
  legge da tastiera un vettore di LIM interi ( o fino a LIM elementi) 
  Scritto da: F. Sacco */

void scanfvet(int vett[], int LIM)    
{
    int i;
	for(i=0; i < LIM; i++)
	{
		printf("Elemento v[%d]->",i);   // il primo ha indice 0
		scanf("%d",&vett[i]);
	}
}

/* Funzione C printfvet()
   visualizza a video un vettore di LIM interi ( o fino a LIM elementi) 
   Scritto da: F. Sacco */
  
void printfvet(int vett[], int LIM)    
{
	int i;
	for(i=0; i < LIM; i++)
		printf("Elemento v[%d]->%d\n",i,vett[i]);   // il primo ha indice 0
}

/* Funzione C minvet() (maxvet e' simile)
   ritorna l'elemento minimo di un vettore di LIM interi 
   ( o fino a LIM elementi) 
   Scritto da: F. Sacco */

int minvet(int vett[], int LIM)    
{
	int i,minimo=0;   
	/* minimo indica la posizione del minimo */
	
	for(i=1; i < LIM; i++)
		if (vett[i] < vett[minimo])
			minimo=i;
	return minimo;
}

/* Funzione C scambia() 
   scambia due elementi di posizione i e j nel vettore 
   E' indipendente dalla dimensione del vettore!!!
   Scritto da: F. Sacco */
   
   
   void scambia(int vett[],int i, int j)
   {
		int dep=vett[i];
		if (i!=j)  // altrimenti e' inutile scambiare!!!
		{
			vett[i]=vett[j];
			vett[j]=dep;
		}
   }

/* Funzione C sortvet() 
   ordina un vettore di LIM interi 
   ( o fino a LIM elementi) - usa: scambia()
   Scritto da: F. Sacco */

void sortvet(int vett[], int LIM)
   {
		int i,j;
		for(i=0; i < LIM-1; i++)
			for(j=i+1; j < LIM; j++)
				if (vett[i] > vett[j])
					scambia(vett,i,j);
   }
   
   
 /*---------------------FINE--------------------------*/

Mybyte4.h - Gestione Byte/Parallela/Seriale (GIVEIO)

/* programma per classe 3^B   AND, OR, NOT, XOR, CICLO(), GIVEIO e controllo parallela e seriale

// metti nei programmi #include "mybyte4.h"

AND: spegne i bit con maschera a zeri per i bit da spegnere
OR:  accende i bit con maschera a uni per i bit da accendere
NOT: capovolge tutti i bit
SHIFT a destra:   divide per due ad ogni posizione (divisione intera)
SHIFT a sinistra: moltiplica per due (fino al raggiungimento del valore massimo)

CODIFICA NEL main() !!!!!!

#include <stdio.h>
#include <stdlib.h> // per atoi()
#include <string.h> // per strlen()
#include <windows.h> // per giveio

#include <time.h>

void RANDOMIZE()   // per compatibilità Borland C
{
    time_t t;
    srand((unsigned) time(&t));
}

int random(int n)
{
    return rand() % n;
}

#define BYTE    unsigned char         // un carattere senza segno equivale ad un BYTE
#define LEN 80                        // lunghezza stringhe

#define CICLO(X,N)  for(X=0; X < N; X++)       // ciclo semplificato
#define GIVEIO()         giveio()              // accesso porte consentito Wxp

// Parallela
#define PARALL(valore)     _outp(0x378,valore) // accesso a porta parallela
#define PARALLDEB(valore)  scrivibyte(valore)  // debug parallela --> il valore va su schermo

// Seriale (segue parametri x porta seriale

#define PORTA 0X300       // 0x300 = seriale1, 0X200 = seriale2

void SETTA_SERIALE(void) // seriale 1, 8 bit, 1 di stop, No parity, 2400 Baud
{

BYTE velocita = 0X30;  // se dimezzi 0X30 ... raddoppia velocita'

_outp(PORTA+0xFB,0x80); /* Dico all'8250 (UART) che sto X programmarla..*/
    /* FB == REGISTRO CONTROLLO LINEA */

_outp(PORTA+0xF9,0);       /* BYTE ALTO baud rate, sempre 0 */
    _outp(PORTA+0xF8,velocita);/* BYTE basso baud rate */
    _outp(PORTA+0xFB,0x3);     /* 0x3 == 8 bit, 1 stop, NO Parity */
    /* FB = REGISTRO CONTROLLO LINEA */
}

void ATTESA_SERIALE_RICEZIONE()
{
    BYTE c;
    do
    {
        c = _inp(PORTA+0xfD);
    }
    while((c & 1) == 0);

}

void ATTESA_SERIALE_TRASMISSIONE()
{
    BYTE c;
    do
    {
        c = _inp(PORTA+0xfD);
    }
    while((c & 32) == 0);

}

void INVIA_SERIALE(BYTE c)
{
    _outp(PORTA+0xF8,c);
}

BYTE RICEVI_SERIALE(void)
{
    BYTE c;
    c =  _inp(PORTA+0xF8,c);
    return c;
}

// FINE funzioni sulla seriale

void leggistr(char str[])   // legge una stringa
{
    fgets(str,LEN,stdin);
    str[strlen(str)-1] = '\0';   // metto il \0 anzichè il \n
}

BYTE binario(char str[])  // trasforma un stringa contenente un numero in binario in decimale
{
    int somma = 0;
    int pot=1;
    int i;
    char c;

for(i=strlen(str)-1; i>=0; i--)
    {
        c = str[i];
        if (c == '0' || c == '1')
        {
            somma+= pot*(str[i]-'0');
            pot*=2;
        }
        else
        {
            printf("\nfunzione binario() - il valore [%s] NON e' in binario\n",str);
            exit(0);
        }
    }

return somma;

}

void scrivibyte(BYTE b)          // scrive un byte in binario / ricorsiva
{
    int i;
    printf("\n        ");
    for (i=0; i < 8; i++)
    {
        printf("%d",b % 2);
        b/=2;
        printf("\b\b"); // torno indietro di 2 caratteri
    }

}

BYTE leggibyte(char modo)   // legge un byte in 'D' -> decimale, 'B' -> binario
{
    char stringa[LEN+2];

printf("digita un valore in ");
    if 		(modo == 'D') printf(" decimale    ->");
    else if  (modo == 'B') printf(" binario     ->");
    else
    {
        printf("Errore chiamata funzione leggibyte()");
        exit(0);
    };
    leggistr(stringa);
    if 		(modo == 'D') return      atoi(stringa);
    else                   return      binario(stringa);
}

void giveio() // WOW provato giveio su seven a scuola 32 bit: VA!!!!! 14 nov 2012
{
    int i;
    HANDLE h;
    printf("\nCHIAMATO GIVEIO()\7\n");
    h = CreateFile("\\\\.\\giveio",
                   GENERIC_READ, 0, NULL,OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
                   NULL);
    if(h == INVALID_HANDLE_VALUE)
    {
        printf("%c\nErrore, driver GiveIo NON installato\n",7);
        exit(1);
    }
    CloseHandle(h);
}
// vedi prova2.c per utilizzo!!!

// prova.c - prova mybyte.h

#include "Mybyte4.h"

int main() // prova
{

BYTE uno, due;
    int i;

uno = leggibyte('D');
	due = leggibyte('B');

printf("primo byte in binario ->");
    scrivibyte(uno);
	printf("\n");
	printf("Secondo byte in decimale    -> %d\n",due);
	printf("Secondo byte in ottale      -> %o\n",due);
	printf("Secondo byte in esadecimale -> %x\n",due);

CICLO(i,5) // test ciclo
   {
	   printf("i=%d\n",i);
	}

GIVEIO();   // test giveio
   uno = 8;  // byte da produrre su parallela
   PARALL(uno); // produco il byte uno su parallela
   PARALLDEB(uno);  // produco il byte uno su schermo X debug
   return 0;
}

/*---------------------FINE--------------------------*/

CGI Windows/Linux compatibili (Header cgi.h 2014)

/******************************************************************/
/**** Scritto Da F.Sacco              *****************************/
/**** Ultima mod. 19 Febbraio 2014                                */
/**** File:    CGI.H                  *****************************/
/***  Tratto da cgi_sql.c (routine di base X cgi)                 */
/***  in piu' mask() per maschere di ritorno (caratteri '$'       */
/******************************************************************/
/** Feb 2014: corretto riconoscimento caratteri esa (es. '/', ',',':' **/
/** funzionalità nuova in debug() --> vedo vcgi[] posizioni */
/** Implementato request(nomecampo) --> ritorna il contenuto o NULL se non c'e'

/** Il modulo" cgi.h", puo' essere utile per interpretare la QUERY_STRING
   in ricezione da un applicativo C CGI.
   Il metodo sopportato, e' sia il GET che il POST.
   I campi NON sopportati sono i TEXTAREA.
   Viene fatta la sostituzione del solo carattere particolare '+' in ' '
   (spazio).
   Il parsing della query string viene fatto alla chiamata della funzione
   "cgi()".
   La funzione "cgi()" prende l'input dalla stringa d'ambiente QUERY_STRING
   (percio' e' possibile anche simularne il lancio impostando con il comando
   dos/unix "set QUERY_STRING=.......") e ne spezza il contenuto in un
   vettore di strutture cgi(); la struttura cgi contiene due campi:
   "nome" che conterra' il nome del campo FORM assegnato dal modulo HTML.
   "contenuto"  che sara' cio' che l'utente ha scritto nel campo "nome"
   Una volta chiamata la funzione cgi(), e' possibile cercare cio' che
   e' stato digitato dall'utente nel modulo HTML (modulo FORM) direttamente
   conoscendo il nome del campo, utilizzando la funzione cerca().
   La cerca(), riceve in ingresso il nome del campo e ritorna il contenuto */

/** ATTENZIONE: il programma CGI deve costruire il modulo HTML:
   possono essere utili le funzioni:

1) testa()         : apre il documento HTML, segnalando anche
                        al browser (explorer o netscape) il tipo
                        di documento di ritorno (content type).
                        Il documento e' generato dinamicamente
                        dall'applicativo CGI, dopo aver chiamato
                        la funzione cgi().

2) piede()   :       chiude il documento HTML generato dinamicamente

3) fatalerror():     interrompe l'esecuzione del programma CGI
                        e segnala l'errore direttamente al BROWSER.
                        Utile per condizioni anomale o debug...
   4) debug():          Fatta il 26-02-2004, per stampare il vettore vcgi[] in forma di tabella

***********/

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

#define MAX 128
/* massimo numero campi nel modulo */

#define LMAX 32000
/* massima lunghezza di un nome variabile o di un suo contenuto */

struct cgi
{
    char *nome;       /* nome variabile */
    char *contenuto;  /* contenuto */
} vcgi[MAX];

char buffer[LMAX];   /* buffer di appoggio: LMAX */
char campo[LMAX/2];  /* Max lunghezza di un contenuto di campo */
int numerocampi = 0;   /* numero campi modulo cgi */

// Nuova 2014 !!!
char *request(char nomecampo[]) // come $_REQUEST di PHP
{
    int i;
    for (i=0; i < numerocampi; i++)
        if (strcmp(vcgi[i].nome,nomecampo)==0)
            return vcgi[i].contenuto;
    return NULL;
}

void testa(void)   /* testa per ogni HTML generato dinamicamente */
{
    printf("Content-type: text/html\n\n"); /* Senza questa, il browser non
                                            interpreta l'HTML di ritorno!!!*/

printf("<HTML>\n");                    /* Parte da qui l'HTML di ritorno..
                                            dinamico!! */
    printf("<BODY>\n");
}

void piede()   /* CHIUDE il documento HTML .. dinamico */
{
    printf("</BODY>");
    printf("</HTML>");
}

void fatalerror(char *msgerr)  /* errore che implica la terminzione */
/* Interfaccia standard in HTML */
{
    testa();
    printf("<H2><HR>Errore [%s] <HR></H2>",msgerr);
    piede();
    exit(1) ;                           /* Il cgi termina qui...*/
}

// Nov 2002: traduzione in una stringa della codifica '+' in spazio
// e %hh in valore carattere (es %25 -> '%', %3d -> '=', etc...

// Febbraio 2014 :: modificata con sscanf:
static int valore(char s[])   // Ricevuto %hh ritorna valore decimale
{
    int v;
    char appoggio[10];
    strncpy(appoggio,s+1,2);
    appoggio[2]='\0';
    sscanf(appoggio,"%x",&v);
    //  printf("<br>stringa=[%s] valore=[%d] carattere=[%c]\n",appoggio,v,v);
    return v;
}

char *decod(char cod[]) // riceve la stringa CODificata
{
    // e la DECodifica, ritornandola
    // in se stessa, visto che la
    // dimensione della stringa decodificata
    // dovrebbe essere minore dell'originale
    char *l, *s;    // (l)eggo, (s)crivo
    l = s = cod;
    while(*l)
    {
        switch (*l)
        {
        case '+': // spazio   NON dovrebbe esserci...
            *s = ' ';
            break;
        case '&': // NON dovrebbe esserci
            *s = '\n'; /// ?????
            break;
        case '%':
            *s = valore(l);
            if ( s[1] && s[2]) // c'e' ancora qualcosa...
                l+=2; // salto 2 caratteri, dopo il %
            break;
        default:
            *s = *l;
        }
        ++s;
        ++l;  // prox carattere...
    }
    *s = '\0'; // chiudo la stringa ...  se serve

return(cod);
}

/* la getword NON fa controlli sulla lunghezza stringhe...
   in certi ambiti la sicurezza potrebbe essere NON sufficiente...
   La funzione spezza in parole la stringa QUERY_STRING
   ritornando il puntatore al punto in cui si era interrotta
   nel penultimo richiamo. Inoltre vengono trasformati i '+' in spazi ' '*/

char *getword(char *s, char *w)
/* restituisce in w la prossima parola presa da *s */
/* (fino al carattere '&', '=' o a '\0') */
/* trasforma i '+' in spazi  in w */
{
    for (; *s && *s != '&' && *s != '='; s++)
        *w++ = (*s == '+') ? ' ': *s;
    *w = '\0';
    if (*s != '\0')
        ++s;
    return s;
}

void *duplica(char *s)
/* duplica con malloc() una stringa *s */
/* e ritorna il puntatore alla copia */
{
    void *p = malloc(strlen(s)+1);
    if (p)
    {
        strcpy((char *)p,s);
    }
    else
        fatalerror("Malloc: fine memoria");
    return p;
}

void cgi(void) /* interpretazione query_string con getword() */
{
    int i;
    char *query;   /* punatore alla query_strimg */
    char *method;  /* puntatore alls request_method */
    char *env;     /* puntatore di appoggio... */
    int ldati;     /* numero byte in input (caratteri ricevuti) */

method = getenv("REQUEST_METHOD");
    if ( method == NULL)
        fatalerror("Non trovo var. REQUEST_METHOD");
    if (strcmp(method,"GET") == 0)
    {
        query = getenv("QUERY_STRING");
        if ( query == NULL)
            fatalerror("Non trovo var. QUERY_STRING\n");
        strcpy(buffer,query);       /* La metto nel buffer */
        ldati = strlen(query);
    }
    else if (strcmp(method,"POST") == 0)
    {
        // attenzione, sotto windows 98, c'e' un limite piu' stretto
        // con UNA SOLA READ... ; in UNIX e' OK!!
        // (per migliorare, se e' il caso usare CONTENT_LENGHT
        // e piu' di una write()!
        ldati = read(0,buffer,LMAX); /* pesco dall'input standard */
        /* e metto nel buffer */
    }

env = buffer;   // Buffer OK sia per GET che per POST !!
    // FUNZIONA CON env == buffer la getword ??? BOH!!!!
    // eventualmente dichiarare un secondo buffer...
    for (i = 0; i < MAX && *env; i++)
    {
        env = getword(env,campo); /* pesco nome */
        vcgi[i].nome = (char *)duplica(campo);
        env = getword(env,campo); /* pesco contenuto */
        vcgi[i].contenuto = (char *) duplica(decod(campo));
    }
    if (i == MAX)
        fatalerror("Troppi campi nel modulo!");
    numerocampi = i; /* numero campi del modulo */
}

char *cerca(char *nomevariabile)
/* dato il nome della variabile */
/* mi ritorna il suo contenuto */
{
    int i;
    char *errore = "VARIABILE NON TROVATA!";
    for (i =0; i < numerocampi; i++)
        if (strcmp(nomevariabile,vcgi[i].nome) == 0)
            return(vcgi[i].contenuto);
    return (errore);
}

void debug(void)
{
    int i;
    printf("<table border=1>\n");
    printf("<th colspan=4>Funzione debug()</th><tr>\n");
    printf("<th>request()</th><th>Vettore CGI</th><th>Nome Campo</th><th>Contenuto</th><tr>\n");
    for (i=0; i < numerocampi; i++)
    {
        printf("<td>request(\"%s\")==%s</td><td>vcgi[%d]</td><td>%s</td><td>%s</td><tr>\n",
               vcgi[i].nome, request(vcgi[i].nome),i,vcgi[i].nome,vcgi[i].contenuto);

}
    printf("</table>\n");
}
/* Ultima modifica 27-04-2002 ********/
/* Programma CGI-MASK.C - per sostituire maschere */
/* Uso: richiamare mask("nomefile.html"),
   dopo aver lanciato cgi() **********/

/* Il seguente modulo C serve per organizzare le risposte dell'applicativo */
/* CGI, in modo da semplificare l'output in HTML; la funzione mask() e'    */
/* LA FUNZIONE principale, E VA USATA con il nome del file (html) che si */
/* intende usare come maschera fissa HTML di risposta dati. */
/* la funzione mask() accetta anche in ingresso un vettore di strutture */
/* di tipo "struct cgi" ed il numero di campi contenuti. */
/* Per quanto riguarda il tipo "struct cgi" si veda il file cgi-sql.c; */
/* in pratica la struttura cgi, viene utilizzata da mask() per sostituire*/
/* i campi dinamici (marcati dal carattere "$" (dollaro)) che devono essere*/
/* presenti sia nel file html (il cui nome costituisce il primo parametro */
/* in ingresso per la mask() ) che nel vettore di strutture cgi ( passato */
/* sempre alla mask() come secondo parametro in ingresso); */
/* nel vettore di strutture cgi, i campi "nome" NON debbono invece */
/* cominciare con il carattere speciale "$" (dollaro)              */

#define SMAX 512   /* lunghezza massima stringhe locali */

/* funzioni di base */

/* rimpiazza nella stringa stringa[], la parola vecchia oldword[]
   con la parola nuova newword[]. NON usa caratteri speciali '$' */

void replace(char stringa[], char oldword[], char newword[])
{
    char buffer[SMAX];
    int car;
    char *o;
    o = strstr(stringa,oldword);
    if ( o == NULL)
        return;   /* NON POSSO FARE replace */

car = (int) (o - stringa);
    strncpy(buffer,stringa,car); /* copio la prima parte */
    sprintf(buffer+car,"%s",newword);
    strcat(buffer,o+strlen(oldword));
    strcpy(stringa,buffer);
}

int loadfile(char file[], char *vs[], int max)
/* carica un file in un vettore di max-1 puntatori. Attenzione alla */
/* lunghezza stringa che nel file NON deve superare SMAX */
/* Viene allocata la memoria per ogni stringa caricata  */
/* vs[] = vettore di stringhe; carico un file in vs[], allocando memoria */
/* Metto ultimo pointer a NULL e ritorno anche numero linee lette ...*/
/* viene usata dalla mask() per caricare in memoria il file HTML */

{
    FILE *fd;
    char buffer[SMAX];
    int i;
    fd = fopen(file,"r");
    if (fd == NULL)
        fatalerror("Errore loadfile() apertura file ...");
    for ( i = 0;
            i < max-1 && (fgets(buffer,SMAX-1,fd)!=NULL);
            i++)
    {
        vs [i] = (char *) malloc(strlen(buffer)+1);
        if (vs[i] == NULL)
            fatalerror("Da loadfile, funz. malloc()");
        strcpy(vs[i],buffer);
    }
    fclose(fd);
    vs[i] = NULL;
    return (i);
}

int sostituisci(char *vs[], char oldword[], char newword[])
{
    /* scandisce un file di testo e per ogni occorrenza di
       parole oldword[], viene sostituita la parola oldword[]
       con newword[].
       Se strlen(newword) > strlen(oldword) viene riallocata la
       memoria ... per contenerla...!!;

ATTENZIONE: Occorre che il puntatore in fondo a vs[] sia NULL
     per segnalare la dimensione (come, ad es. il '\0' nelle stringhe..)
     del vettore di stringhe vs[];

Ritorna al chiamante il numero di sostituzioni fatte.
     E' usata direttamente dalla mask() ***/

int i, sostituzioni;
    char buffer[SMAX]; /* appoggio */
    for (i=0, sostituzioni = 0; vs[i]; i++)
    {
        strcpy(buffer,vs[i]);
        /* buffer[] dovrebbe essere abbastanza capiente ...*/
        while(strstr(buffer,oldword) != NULL)
            /* finche ho sostituito almeno una stringa oldword[] */
        {
            replace(buffer,oldword,newword);
            sostituzioni++;
        }
        if (strlen(buffer) > strlen(vs[i]))
        {
            /* occore fare spazio....*/
            free(vs[i]);
            vs[i] = (char *)malloc(strlen(buffer)+1);
            if (vs[i] == NULL)
                fatalerror("da sostituisci(), malloc()");
        }
        strcpy(vs[i],buffer);
    }
    return sostituzioni;
}

void stampavs(char *vs[])
/* stampa un vettore di stringhe sull'output */
/* viene usata dalla mask(), una volta sostituiti i campi dinamici con '$'*/
/* l'output viene rediretto dal server web (apache..) direttamente al    */
/* browser (client) */

{
    int i=0;
    while(vs[i])
        printf("%s",vs[i++]);
}

/* libero memoria */
void freevs(char *vs[])
/* una volta caricato il file da mask() in un vettore di pointer a stringa */
/* e, dopo essere stato stampato con stampavs(), viene liberata la memoria */
/* allocata da loadfile con malloc() */
{
    int i;
    for (i = 0; vs[i]; i++)
    {
        free(vs[i]);
        vs[i] = NULL;
    }
}

static char *dollaro(char str[])
/* ritorna una stringa con un dollaro in testa */
/* in questo modo NON e' necessario immettere forzamente un '$' nei campi*/
/* di tipo "nome", nel vettore di struct cgi passato alla mask()*/
/* Attenzione alla lunghezza SMAX delle stringhe ...*/
/* Il vettore e' STATICO INTERNO, cioe' privato .. ma SEMPRE definito */

{
    static char buffer[SMAX];
    strcpy(buffer,"$");
    strcat(buffer,str);
    return buffer;
}

/*** mask() ==> funzione principale. Vedi la documentazione a linea 1 */

void mask(char file[], struct cgi vcgi[], int numerocampi) /* FUNZIONE PRINCIPALE */
{
    char *vs[SMAX];

int i;

loadfile(file,vs,SMAX);
    for (i = 0; i < numerocampi; i++)
        sostituisci(vs,dollaro(vcgi[i].nome),vcgi[i].contenuto);
    stampavs(vs);
    freevs(vs);
}

/************************************/
/** Esempi di utilizzo di cgi.h: ****/
/************************************/

// debug.c: Uso della routine debug() di cgi.h
// Ultima modifica 28 Feb 2004
// STAMPA IN TABELLA I VALORI PASSATI COME GET O POST da un MODULO

#include "cgi.h"
int main()
{
	cgi();
	testa();
	debug();   // stampa in tabella le variabili del modulo form html
	piede();
	return 0;
}

/**** provacgi.c: Pesco i campi di un modulo ****/
#include "cgi.h"   // modulo di prova... ult mod 27-11-02

void test_cgi(void) /* per test...*/
{
    int i;
    char w[256];
    cgi();
    testa();
    printf("<pre>");
    for (i = 0; i < numerocampi; i++)
        printf("Nome [%s], contenuto [%s]\n",
               vcgi[i].nome, vcgi[i].contenuto);
    piede();

/*** test X cerca() *******************************
    
    do {
    	printf("Nome variabile [INVIO = FINE] ->");
    	gets(w);
    	printf("Contenuto [%s]\n",cerca(w));
    } while(*w);          fine test X funzione cerca() ***/

}
main()
{
    test_cgi();
}

/**** provamask.c: presento i dati con maschera HTML preconfezionata (mask.html) ****/
#include "cgi.h"

/*** void test_cgimask() /* SOLO PER DEBUG di prova............
{
	char w1[100], w2[100], w3[100];
	char *vs[100];
	printf("File di testo ->"); gets(w1);
	printf("Parola vecchia ->"); gets(w2);
	printf("Parola nuova->"); gets(w3);
	loadfile(w1,vs,100);
	sostituisci(vs,w2,w3);
	stampavs(vs);
}   ******************/

int main()
{
	    cgi();
        testa();
        mask("./mask.html",vcgi,numerocampi);
		return 0;
}

Sock.h Windows/Linux compatibili

/***************************************************************/
// sock.h : definizioni per rendere + semplici le chiamate di sistema
// della famiglia socket!! (23/01/2004) F. Sacco
// funziona: linux, cygwin, mingw, djgpp (DOS EXT 386),...
// Grazie anche a P. Ollari X la parte sulle Winsock
// Corretto buco closesocket() invece di close() (23/01/2004)
// Ok anche per Visual C++ 19 Marzo 2004
// F. Sacco
/***************************************************************/

#include <stdio.h>

#ifdef WIN32          // se siamo in windows
#include <winsock.h>
#else                 // o in altri sistemi (UNIX, LINUX, CYGWIN...)
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#endif

static struct sockaddr_in sai;
static struct hostent * ht;

int Socket(void)     // Sia per SERVER, CHE PER CLIENT
{
    int sock =-1;
#ifdef WIN32
    // Parte aggiunta per winsock ....
    static int primavolta = TRUE;  // per chiamare inizializzazione

void win_inizio();             // win_inizio() solo una volta!
    if ( primavolta )
    {
        win_inizio();
        primavolta = FALSE;
    }

#endif // FINE PARTE SOLO PER X Winsock

sock = socket( PF_INET, SOCK_STREAM, IPPROTO_IP ); // IPPROTO_IP = 0
    if ( sock < 0 )
    {
        perror( "Errore chiamata sock()" );
        return -1;
    }
    return sock;
}

void Close(int socket)
{
    // In windows NON close ma closesocket()
#ifdef WIN32
    closesocket( socket); // SOlo WIN
#else
    close(socket);   // SOLO UNIX/LINUX
#endif
}

void Connect(int sock, int port, char server[])  // SOLO LATO CLIENT
{
    sai.sin_family = AF_INET;
    sai.sin_port =  htons((unsigned short) port);
    ht = gethostbyname(server);
    sai.sin_addr =  * (struct in_addr *) ht->h_addr_list[0];
    if ( connect( sock, (struct sockaddr *) &sai,
                  sizeof( struct sockaddr_in ) ) < 0 )
    {
        perror( "1) Errore connect()" );
        Close( sock );
        return;
    }
}

// DEFINIZIONI PER LATO SERVER

struct sockaddr_in client;
int addr_len = sizeof(struct sockaddr_in);

void Bind(int port,int sock)       // SOLO LATO SERVER
{

sai.sin_family = AF_INET;
    sai.sin_port = htons( (unsigned short) port );
    sai.sin_addr.s_addr = INADDR_ANY;
    if( bind( sock, (struct sockaddr *)&sai,
              sizeof( struct sockaddr_in ) ) < 0 )
    {
        perror( "Errore  bind()" );
        Close( sock );
    }
}

void Listen(int sock)    // SOLO LATO SERVER
{
    if ( listen( sock, 5 ) < 0 )
    {
        perror( "Errore: listen( sock, 5 )" );
        Close( sock );
    }
}

int Accept(int sock , char cliente[])  // SOLO LATO SERVER
{
    int stream;
    stream = accept( sock, (struct sockaddr *)&client,&addr_len);
    if ( stream > 0 )
        strcpy(cliente,(char *)inet_ntoa( client.sin_addr ));
    return(stream);
}

int Read(int socket, char buffer[], int len)
{
    return recv(socket, buffer, len,0);
}

int Write(int socket, char buffer[], int len)
{
    return send(socket, buffer, len,0);
}

void Sockend(void)
{
    // Serve SOLO per WINDOWS: per compatibilità ..
#ifdef WIN32
    void win_fine(void); // prototipo
    win_fine();
#endif
}

// SEGUE Parte SOLO X WINDOWS

#ifdef WIN32

void win_inizio(void)  // Inizializzazione SOLO X WINDOWS
// NON CHIAMARE da applicativi!!!
// Gia' chiamata da Socket
{

// Parte aggiunta per winsock ....
    WORD    wd;
    WSADATA ws;
    int     esito;

wd = MAKEWORD(1,1);
    esito = WSAStartup(wd, &ws);
    if ( esito != 0)
        printf("Attenzione, win_inizio() : esito [%d]=",esito);
}

void win_fine(void)    // Chiusura: solo per windows
// NON CHIAMARE da applicativi!!!
// Gia' chiamata da Sockend();
{
    int esito = WSACleanup();
    if ( esito != 0 )
        printf("Attenzione, win_fine() : esito [%d]=",esito);
}
#endif // fine parte SOLO PER WINDOWS

/*-----Segue esempio Client/server/myapache----------*/

/***************************************************************/
/* CLIent ESempio: CLIES.C: client esempio                     */
// Ultima modifica 4 febbraio 2003
// CLIENT Esempio: invia una stringa "Ci sei???\n" ad il server e
// legge il messaggio di risposta dal server, mostrandolo su
// standard output (schermo)
// Richiede all'utente l'ip o il name del server ed il Numero di porta
// da usarsi per lo scambio.
// Provare con server
/***************************************************************/
#include "sock.h"

// Attenzione: le chiamate di sistema Virtuali
// Hanno la prima lettera Maiuscola
// Es. Socket() invece di socket(), Write() invece di write(), etc...
#define LMAX 1024
int sock;
int port;
int msg_len;
char server[LMAX], buffer[LMAX];

void parametri(void)
{

char invio;

printf("Porta tcp-ip ->");
    scanf("%d%c",&port,&invio);
    printf("Server con cui connettersi ->");
    gets(server);
}

void connetti(void)
{
    sock = Socket();
    Connect(sock,port,server);
}

int main(void)
{
    int i;
    printf("Sono il client!\n");
    parametri();
    connetti();
    // comunicazione client/server
    //...... Invio dati o richiesta
    strcpy(buffer,"Ci Sei???\n");
    Write(sock,buffer,strlen(buffer));
    // Invio al server la richiesta

for (i = 0; i < LMAX; i++)
        buffer[i] = '\0';  // Svuoto il buffer...
    msg_len = Read( sock, buffer,LMAX  );
    // leggo dal server la risposta...
    printf("Ricevuto messaggio ->%slungo [%d] byte\n",buffer,msg_len);
    // .. e la stampo su schermo...
    printf("Premi invio...");
    getchar();
    Close( sock );
    Sockend();      // fine uso socket...
    return 0;
}

/***************************************************************/
/*SERver ESempio SERVES.C (da usarsi con clies.c)              */
// Ultima modifica 4 febbraio 2003
// riceve una stringa dal client e rimanda al client un messaggio
// stampando sullo schermo sia la stringa ricevuta che l'ip di
// provenienza del client.
// Richiede all'utente solo il Numero di porta
// da usarsi per lo scambio.
// Provare con client.c
/***************************************************************/

#include "sock.h"

// Attenzione: le chiamate di sistema Virtuali
// Hanno la prima lettera Maiuscola
// Es. Socket() invece di socket(), Write() invece di write(), etc...

int sock, newsock;
int port;
int msg_len;
#define LMAX 1024
char buffer[LMAX];
char messaggio[LMAX];

void parametri(void)
{
    char invio;

printf("Porta tcp-ip ->");
    scanf("%d%c",&port,&invio);
    printf("Messaggio da inviare al client ? ->");
    gets(messaggio);
}

void prepara(void)
{
    sock = Socket();
    Bind(port,sock);
    Listen(sock);
}

int main(void)
{
#define MAX 256
    char cliente[MAX];
    int i;

printf("Sono il SERVER !!\n");
    parametri();
    prepara();
    // comunicazione client/server
    do     // Il server e' sempre attivo...
    {
        newsock = Accept(sock,cliente);
        if ( newsock > 0)   // Mi e' arrivata una richiesta...
        {
            printf("Richiesta da [%s]\n",cliente);
            fflush(stdout);
            for ( i = 0; i < LMAX; i++)
                buffer[i] = '\0'; // svuoto buffer
            msg_len = Read(newsock,buffer,LMAX);
            // ho letto il msg dal client...
            if (msg_len > 0)
            {
                printf("Letto da messaggio ->%slungo [%d] byte\n",buffer,msg_len);
                Write(newsock,messaggio,strlen(messaggio));
                // .. e gli ho risposto!
            }
            Close( newsock );
        }
    }
    while(1);   // Sempre attivo
    // .. qui il programma NON ci arriva, ma le istruzioni seguenti
    // andrebbero fatte, nel caso di un server che termina...
    Close( sock );
    Sockend(); // Fine uso socket
    return 0;
}

/***************************************************************/
/*SERver ESempio myapache.C       */
// Ultima modifica 23 gennaio 2004
// Nuovo server web ....con sock.h - Usare Close() per Closesocket
/***************************************************************/

#include "sock.h"
#include <string.h>

// Attenzione: le chiamate di sistema Virtuali
// Hanno la prima lettera Maiuscola
// Es. Socket() invece di socket(), Write() invece di write(), etc...

int sock, newsock;
int port = 80;       // Cambia porta se già attivo l'apache o altro ...
int msg_len;
#define LMAX 65535   // lungh. massima pagina HTML o immagine ....
#define MAX  1024    // lungh. max stringa
char buffer[LMAX];
char messaggio[LMAX];

void prepara(void)
{
    sock = Socket();
    Bind(port,sock);
    Listen(sock);
}

int servi_client(int link)
{

int msg_len;

char *errore =   /** NON serve Content type!!! */
        "<HTML> <H1> <BR> Errore, myapache: link NON valido!  <BR> </HTML>";

if ((msg_len = Read(link,buffer,LMAX)) > 0)
        /* se il client invia almeno 1 byte ... */
    {
        FILE *fd;
        int i =0;
        char nomefile[MAX];
        char *inizio, *fine;

puts("Ricevuto messaggio:");
        fflush(stdout);
        write(1,buffer,msg_len); /* scrive su output standard ...*/
        inizio = strstr(buffer,"GET ");  // Richiesta GET del browser remoto
        fine = strstr(buffer,"HTTP");  // Pesco il nome del file richiesto
        for ( inizio+=5, i = 0; inizio && fine && inizio < fine-1 && i < 255;
                inizio++,i++)
        {
            nomefile[i]=*inizio;
        }
        nomefile[i] = 0;
        printf("\n\nmyapache: Richiesto:[%s]\n",nomefile);
        if (strcmp(nomefile,"") == 0)
        {
            strcpy(nomefile,"index.html"); /* richiesta base */
            printf("\nmyapache risponde inviando il file: [%s]\n",nomefile);
        }
        if ((fd = fopen(nomefile,"rb")) == NULL) // NON dimenticare parametro b
        {
            Write(link,errore,strlen(errore));
            return(1);
        }
        if ((msg_len = fread(buffer,1,LMAX,fd)) <=0)
        {
            Write(link,errore,strlen(errore));
        }
        else
        {
            // write(1,buffer,msg_len);  scrivo sull'output, se voglio debug
            if (Write(link,buffer,msg_len) < 0)
            {

perror("errore scrittura messaggio");
                exit(-1);
            }
            Close(newsock);
            // printf("\n\n\nFINE INVIO!!!\n\n\n"); per debug
        }
        fclose(fd);
    }
    return(0);
}

int main()
{

char cliente[MAX];

printf("SERVER WEB Ultra semplificato, ma rapido (myapache.c) !!\n");
    printf("Compatibile Windows/Linux!!!\n");
    printf("(Max dimensione pagina o immagine o file: 64Kbytes)\n");
    prepara();
    // comunicazione client/server
    do     // Il server e' sempre attivo...
    {
        newsock = Accept(sock,cliente);
        if ( newsock > 0)   // Mi e' arrivata una richiesta...
        {
            printf("Richiesta da [%s]\n",cliente);
            fflush(stdout);
            servi_client(newsock); // servi il client
        }
    }
    while(1);   // Sempre attivo
    // .. qui il programma NON ci arriva, ma le istruzioni seguenti
    // andrebbero fatte, nel caso di un server che termina...
    Close( sock );
    Sockend(); // Fine uso socket
    return 0;
}

/*---------------------FINE--------------------------*/

Calendar.c - Calendario perpetuo

#include <stdio.h>  
#include <string.h>  
// calendar.c  written by martin for 59.102 July 1999
// verson 1.1 multiple columns

int leapyear(int year) 
{  
    // is year a leap year?
    // the rule for leap years is that a year is a leap year if it
    // is divisible by four but not by 100 or it is divisible by 400
    if(((year%4==0) && (year%100!=0)) || (year%400==0)) 
        return 1;
    else
        return 0;
}
int daysinmonth(int year, int month)
{
    // Thirty days hath September, April, June, and November;
    // All the rest have thirty-one
    // Excepting February alone: Which hath but twenty-eight, in fine,
    // Till leap year gives it twenty-nine.
    int monthlengths[]={31,28,31,30,31,30,31,31,30,31,30,31};
    if ((month==1) && leapyear(year)) return 29;
    else return monthlengths[month];
}
int printmonth(char s[8][32],int year, int month, int firstday)
{
    // print a complete month into the string s
    // firstday gives the number for the first day of the month (0 is sunday)
    char *monthnames[]={"January","February"," March"," April","  May"," June"," July","August","September","October","November","December"};
    int i;
    sprintf(s[0],"         %-8s      ",monthnames[month]); // print month name
    sprintf(s[1],"  Su Mo Tu We Th Fr Sa ");               // print day heading
    for(i=2;i<8;i++)
        strcpy(s[i],"                       ");               // blank week
    for(i=0;i<daysinmonth(year,month);i++)
    {
        sprintf(s[(i+firstday)/7+2]+(i+firstday)%7*3+2,"%2d",i+1); // print day no
        s[(i+firstday)/7+2][(i+firstday)%7*3+4]=' '; // remove string termimator
    }
    return (firstday+i)%7; 
} 
int main(int argc,char *argv[]) {
    int i,j,k;
    int day;
    int year=2006;
    char months[3][8][32]; // array to store three months

if(argc==2)
	 	sscanf(argv[1],"%d",&year);
	 else {
      printf("What year would you like a calendar for? ");
      scanf("%d",&year);
    }
    // work out what day of the week the first day of the year is
    // add no of leap years to 365*(year-1)
    day=((year-1)*365+(year-1)/4+(year-1)/400-(year-1)/100+1)%7;
    // print title
    printf("\n                           Calendar for %d\n\n",year);
    for(j=0;j<4;j++)
    {         // print 4 rows of months
        for(i=0;i<3;i++)         // print months into the array
            day=printmonth(months[i],year,i+j*3,day);
        for(i=0;i<8;i++)
        {       // print all 8 rows
            for(k=0;k<3;k++)       // of three months from the array
                printf(months[k][i]);
            puts("");                // return at end of line
        }
    }
    return 0; // success
}

/*---------------------FINE--------------------------*/

Pesco i nomi di file in una cartella (solo Windows)

/* Programma C: dir.c
   Scritto da: F. Sacco
   Descrizione: lista file cartella (SOLO WINDOWS!!!)
*/

#include <stdio.h>
#include <dir.h>

/********************  definite in io.h
struct _finddata_t
{
	unsigned	attrib;		* Attributes, see constants above. *
	time_t		time_create;
	time_t		time_access;	* always midnight local time *
	time_t		time_write;
	_fsize_t	size;
	char		name[FILENAME_MAX];	* may include spaces. *
};

int	_findfirst (const char* szFilespec, struct _finddata_t* find);
int	_findnext (int nHandle, struct _finddata_t* find);
int	_findclose (int nHandle);

int	_chdir (const char* szPath);
char*	_getcwd (char* caBuffer, int nBufferSize);
int	_mkdir (const char* szPath);
char*	_mktemp (char* szTemplate);
int	_rmdir (const char* szPath);

*****************/

void mydir(char *path)  // lista la cartella
{
   struct _finddata_t ff;
   int handle;
   printf("Lista dei file *.*\n");
   handle = _findfirst(path,&ff);
   //printf("Handle = %d\n",handle);
   while (_findnext(handle,&ff)!= -1) 
   {
      printf("  %s\n", ff.name);
   }
   return;
}

int main()
{
	char w[256];
	printf("Cartella e file da listare [esempio  C:\\*.*] ->");
	gets(w);
	mydir(w);
	return 0;
}
/*---------------------FINE--------------------------*/

Generatore di password data la partenza (X Smemorati!!!)

/* Programma C: paswd-html.c
   Scritto da: F. Sacco
   Genera una serie di password con una sola password...
*/
#include <stdio.h>
#include <ctype.h>

char paswd[128];

char *password(char paswd[])
{
    int i;
    int c;
    static long base=0x12345678;
    int len = strlen(paswd);
    for (i=0; i<len; i++)
    {
        paswd[i]=(long)paswd[i] ^ base;
        base--;
        c = paswd[i];
        while(!(isalpha(c) || isalnum(c)))
        {
            paswd[i]=(long)paswd[i] ^ base;
            base--;
            c = paswd[i];
            if (c <'A' || c > 'z')
                c=0;
        }
    }
    return(paswd);
}

int main()
{
    int i,quante;
    FILE *fd;
    if ((fd = fopen("password.html","w"))==0)
        printf("\nERRORE: non riesco ad aprire in scrittura il file password.html\n\7\nPremi INVIO..."),getchar(),exit(0);

printf("Password di base --->");
    gets(paswd);
    printf("Quante password genero ?--->");
    scanf("%d",&quante);
    fprintf(fd,"<html><body><table border=1><tr><th>Numero</th><th>Password</th><tr>\n");
    for (i=0; i < quante; i++)
    {
        fprintf(fd,"<td>%3d</td><td>%s</td><tr>\n",i+1,password(paswd));
    }
    fclose(fd);
    fprintf(fd,"\n</table></html>");
    printf("\nFile password.html creato con successo!\nAttendere visualizzazione con browser...");
    system("explorer password.html");
    return 0;

}
/*---------------------FINE--------------------------*/

Reti.c / Capire meglio le reti tcp/ip

/* Programma C: reti.c
   Scritto da: F. Sacco
   
*/
// reti.c : per capire il TCP/IP     aprile 2004
// Funziona anche sotto Linux (29 apr. 2004)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

char *version = "Reti.c, by F.Sacco - versione 5/5/2004\n";

#define gets(s) { fgets(s,sizeof(s)-1,stdin); s[strlen(s)-1]='\0'; }   // funzione pericolosa ...

typedef unsigned char BYTE;
#define LUN 4   // ipv4

#define LSTR 128
union myip {
					
				BYTE decimale[LUN];   // notazione decimale puntata
				unsigned long l;   // notazione long
			};

typedef union myip MYIP;

typedef int BOOLEAN;
#define TRUE  1
#define FALSE 0
			
struct rete {
						MYIP ip;
						MYIP netmask;
				};

typedef struct rete RETE;

RETE dieci, unonovedue, unosettedue; // Reti private 10.*, 192.168.*, 172.16.*

// inizio funzioni....
				
void binario(FILE *fd,BYTE b)  // stampa in binario
{
	int i;
	for (i=0; i < 8; i++, b<<=1)
		(b&128) ? putc('1',fd) : putc('0',fd);
}
	
void stampa_binario(FILE *fd,MYIP ip)
{
	int i;
	for (i=0; i < LUN; i++)
	{
		binario(fd,ip.decimale[i]);
		if ( i != LUN -1)
			putc('.',fd);			
	}
}

unsigned long atoip(char *strip)   // data la stringa "001.002.003.004" 											 // mi ritorna il valore in long
{		
		MYIP ip;
		int i = 0;
		char *p;
		strcat(strip,"."); // un punto in piu' ...
		while((p = strchr(strip,'.')) != NULL && i < LUN)
		if (p)
		{
			*p =0;
			ip.decimale[i++] = atoi(strip);
			strip = p+1;
		}
		return ip.l;
}

char *iptoa(MYIP ip)
{
			static char buf[LSTR];
			
			buf[0]='\0'; // pulizia
			sprintf(buf,"%3d.%3d.%3d.%3d",ip.decimale[0],ip.decimale[1],ip.decimale[2],ip.decimale[3]);
			return buf;
			
}

unsigned rete_del_nodo(MYIP ip, RETE r)  // ritorna la rete a cui appartiene il nodo, secondo la netmask di R
{
		return  ip.l & r.netmask.l; 		
}

BOOLEAN appartiene(MYIP ip, RETE r) // verifica se il nodo "ip" appartiene alla rete "r"
{
	
	   
	   
	   //int i;
	   //for (i = 0; i < LUN; i++)
	   //	ip.decimale[i] &= r.netmask.decimale[i];
	   
      //printf("Rete         [%ld]\n",r.ip.l);
		//printf("ip & netmask [%ld]\n",(ip.l & r.netmask.l));
		//printf("netmask [%ld]\n",r.netmask.l);
		//printf("ip      [%ld]\n",ip.l);
		return (ip.l & r.netmask.l) == r.ip.l;  // vero se ip AND netmask == rete
		
}

MYIP indirizzo_del_nodo(MYIP ip, RETE r)   // ritorna l'indirizzo relativo al nodo, es. 0.0.0.253 su rete 255.255.255.0
{
	MYIP dep;
	dep.l = (ip.l & ~r.netmask.l);   // indirizzo di rete AND (not(netmask))
   return dep;
}

MYIP indirizzo_broadcast(RETE r)   // ritorna l'indirizzo relativo al broadcast: es 192.168.64.0/24 = 192.168.64.255
{
	MYIP dep;
	dep.l = (r.ip.l | ~r.netmask.l);  // indirizzo di rete OR (not(netmask))
   return dep;
}

long inverse(long l)    // capotta un long!!!
{
	long dep;
	char *pl = (char *)&l;
	char *pdep = (char *)&dep;
	int i=4;
	pdep+=3;
	while(i--)
		*pdep-- = *pl++;
	return dep;
		
}

void print_rete(RETE r, int maxnodi)  // stampa la rete, mi fermo a maxnodi ...
{
	int i;
	MYIP broadcast;
	BOOLEAN fine = FALSE;
	broadcast = indirizzo_broadcast(r);
	for (i=0; i < maxnodi && !fine; i++)
	{
		
		printf("[%s]\n",iptoa(r.ip));
		
		r.ip.l = inverse(r.ip.l);  // LA RAPPRESENTAZIONE IN ram DEL LONG ... E' INVERTITA
		r.ip.l++;
		r.ip.l = inverse(r.ip.l);  
		if (r.ip.l == broadcast.l)
			fine = TRUE;
	}		
}

MYIP primo_nodo(RETE r) // calcola il primo nodo di rete
{
	MYIP n = r.ip;
	n.l = inverse(n.l);  // LA RAPPRESENTAZIONE IN ram DEL LONG ... E' INVERTITA
   n.l++;
   n.l = inverse(n.l);
   return n;  
}

MYIP ultimo_nodo(RETE r) // calcola l'ultimo nodo di rete
{
	MYIP n = indirizzo_broadcast(r);
	n.l = inverse(n.l);  // LA RAPPRESENTAZIONE IN ram DEL LONG ... E' INVERTITA
   n.l--;
   n.l = inverse(n.l);
   return n;  
}

long numero_nodi(RETE r)
{
	MYIP primo,ultimo;
	
	primo = primo_nodo(r);
	ultimo = ultimo_nodo(r);
	return (inverse(ultimo.l) - inverse(primo.l))+1;
}
void visrete(RETE r)
{
	MYIP dep; 
	
	printf("Indirizzo di rete [%s] [",iptoa(r.ip));     stampa_binario(stdout,r.ip);       putchar('\n');
	printf("Netmask           [%s] [",iptoa(r.netmask)); stampa_binario(stdout,r.netmask);  putchar('\n');
	dep = indirizzo_broadcast(r);
	printf("Broacast          [%s] [",iptoa(dep));       stampa_binario(stdout,dep);        putchar('\n');
	dep = primo_nodo(r);
   printf("Primo  ip libero  [%s] [",iptoa(dep));      stampa_binario(stdout,dep);        putchar('\n');	   
   dep = ultimo_nodo(r);
   printf("Ultimo ip libero  [%s] [",iptoa(dep));      stampa_binario(stdout,dep);        putchar('\n');	 
   printf("Numero nodi rete  [%ld]\n",numero_nodi(r));
   
}

void print_html(FILE *fd, RETE r, int n, int bit)
// scrive su file HTML le informazioni relative ad una rete ...
{
	char s[LSTR];
	unsigned long l;
	MYIP dep;
	fprintf(fd,"\n<br>");
	fprintf(fd,"<table border=1>\n");
	strcpy(s,iptoa(r.netmask));
	fprintf(fd,"<th>[Rete N. %d] <br> %s/%s</th>\n",n,iptoa(r.ip),s);
	fprintf(fd,"<th>Decimale</th><th>Binario</th><tr>\n");
	
	fprintf(fd,"<td>Indirizzo di rete </td> <td>%s</td>",iptoa(r.ip)); fprintf(fd,"<td>"); 
	stampa_binario(fd,r.ip); fprintf(fd,"</td><tr>\n");  // 1a riga
	 
	fprintf(fd,"<td>Netmask</td><td>%s</td>",iptoa(r.netmask));  fprintf(fd,"<td>");
	stampa_binario(fd,r.netmask); fprintf(fd,"</td><tr>\n");  // 2a riga
	
	dep = indirizzo_broadcast(r);
	
	fprintf(fd,"<td>Broacast</td><td>%s</td>",iptoa(dep));   fprintf(fd,"<td>");    
	stampa_binario(fd,dep); fprintf(fd,"</td><tr>\n");  // 3a riga
	
	dep = primo_nodo(r);
   fprintf(fd,"<td>Primo  ip libero</td><td>%s</td>",iptoa(dep)); fprintf(fd,"<td>");     
   stampa_binario(fd,dep); fprintf(fd,"</td><tr>\n");  // 3a riga 
   
   dep = ultimo_nodo(r);
   fprintf(fd,"<td>Ultimo ip libero</td><td>%s</td>",iptoa(dep)); fprintf(fd,"<td>");     
   stampa_binario(fd,dep); fprintf(fd,"</td><tr>\n");  // 3a riga 
   
   l = numero_nodi(r);
   fprintf(fd,"<tr><tr><th>Nodi liberi di rete</th><th>Nodi totali di rete</th>\n");
   if (bit > 0)
   	fprintf(fd,"<th>Bit X Nodo</th><tr>\n");
   fprintf(fd,"<td>%ld</td><td>%ld</td>",l,l+2);
   if (bit > 0)
		fprintf(fd,"<td>%d</td><tr>\n",bit);
   fprintf(fd,"</table>\n");
   
}

FILE *apri_html(RETE r)
{
	FILE *fd=NULL;
	char s[LSTR];
	
	printf("\nNome del file da generare [INVIO=rete.html] ->");
	gets(s);
	if (s[0] == '\0')  // invio
		strcpy(s,"rete.html");
	fd = fopen(s,"w");
	if (fd == NULL)
	{
		printf("Non riesco a creare il file [%s]\n",s);
		return fd;
	}
	strcpy(s,iptoa(r.netmask));
	fprintf(fd,"<html><head><title>Rete %s/%s</title></head>\n",iptoa(r.ip),s);
	fprintf(fd,"<body>\n");
	return fd;
}

void chiudi_html(FILE *fd)
{
	fprintf(fd,"</body>\n</html>\n");
	
}

// Parte relativa alle sottoreti ...  14 apr 2004

BYTE inv_byte(BYTE b) // inverte i bit da dx a sx -> da sx a dx
{
		BYTE app=0;
		int i = 8;
		int p = 128;
		while(i--)
		{
			if ( b & 1)
				app+=p;
			b>>=1;
			p/=2;
		}
		return app;
}

RETE crea_net_mask(RETE r, int uni) 
// data una rete che parte da r.ip, viene calcolata ed inserita una netmask con 
// "uni" numero di uni (es 24 uni = 255.255.255.0)
{
	unsigned long primobit = 1;
	int i;
	uni = 32 - uni;
	r.netmask.l=0; // azzerata
	while(uni--) // limito la netmask
	{
		
		r.netmask.l |= primobit;
	  
		primobit<<=1;
		
	}
	
	for (i=0; i < LUN; i++) // LUN = 4
		r.netmask.decimale[i] = inv_byte(r.netmask.decimale[i]); // bit riempiti al contrario
	return r;			
}

int bit_per_nodi(unsigned long nodi) // ritorna quanti bit servono per "nodi" nodi. es 1024 nodi= 10 bit
{
	unsigned long pot=1;
	int n = 0;
	do {
			++n;
			pot=pot*2;
		} while(pot < nodi);
	
	return n;
	
}

unsigned long prox_potenza(unsigned long num) // ritorna la prossima potenza di due
// maggiore o uguale a num
{
	unsigned long pot=1;
	int n = 0;
	do {
			++n;
			pot=pot*2;
		} while(pot < num);
	
	return pot;
}

RETE pianifica_sottoreti(RETE r)  // modifica 21 aprile 2004
{
			unsigned long sottoreti;
			unsigned long nodi;
			int bit;
			char invio;
			int i;
			unsigned long l;
			RETE app;
			FILE *fd;
			//char s[128];
			
			printf("Quante sottoreti prevedi ? ->");
			scanf("%ld%c",&sottoreti,&invio);
			printf("Quanti nodi per sottorete ? ->");
			scanf("%ld%c",&nodi,&invio);
			
			l =  nodi; // Numero di gradi di libertà
			
			bit = bit_per_nodi(l);
//printf("Bit occorrenti = %d\n",bit); getchar();
		   app = crea_net_mask(r,bit);
		   
		   fd = apri_html(r);

for (i=0; i < (int) sottoreti; i++)
			
				{
					   //printf("\nRete N. %6d\n",i+1);  decommenta se visrete()
						print_html(fd,app,i+1,bit);
					   //visrete(app);  decommenta se vuoi vedere a video
						app.ip.l = inverse(app.ip.l);
						app.ip.l+=prox_potenza(nodi);  // prossima potenza di due
//printf("[Prox pot [%ld] di [%ld]\n",prox_potenza(nodi),nodi); 
//getchar();
						app.ip.l = inverse(app.ip.l);	
						//getchar();	decommenta se decommenti visrete()	
				}	
				chiudi_html(fd);
	return r;
}

void menu()
{
	
	RETE r;
	
	MYIP ip, nodo;
	
	int scelta,n;
	char invio;
	char s[LSTR];
			
	do {
			printf("\n\n\n\n\%s\n\n",version);
			printf("1) Immetti la rete\n");
			printf("2) Immetti la netmask\n");
			printf("3) Verifica se un ip appartiene alla rete\n");
			printf("4) Visualizza dati relativi alla rete\n");
			printf("5) Visualizza l'elenco dei nodi della rete\n");
			printf("6) Genera tabulato html\n");
			printf("7) Scegli una rete privata\n");
			printf("8) Pianificazione sottoreti e generazione tabulato HTML\n");
			printf("0) Uscita dal programma\n");
			scanf("%d%c",&scelta,&invio);
			switch(scelta)
			{
				case 1:
					printf("Indirizzo di rete (esempio 192.168.64.0 ) ->");	
					gets(s);
					r.ip.l = atoip(s);
					putchar('\n');
					stampa_binario(stdout,r.ip);
					putchar('\n');
					printf("%s\n",iptoa(r.ip));
					break;
					
				case 2:
					printf("Netmask (esempio 255.255.240.0 ) ->");	
					gets(s);
					r.netmask.l = atoip(s);
  					putchar('\n');
					stampa_binario(stdout,r.netmask);
					putchar('\n');
					printf("%s\n",iptoa(r.netmask));
					break;
				
				case 3:
					printf("Indirizzo da verificare (esempio 192.168.57.132) ->");	
					gets(s);
					ip.l = atoip(s);	
  					nodo.l = rete_del_nodo(ip,r);
   				printf("Rete di appartenenza [%s]\n",iptoa(nodo));
   				printf("Il nodo "); 
   				appartiene(ip,r) ? printf("appartiene\n") : printf("non appartiene\n");	
					break;
					
				case 4:  // visualizzazione dati rete
					visrete(r);
					break;
					
				case 5:
					printf("Quanti nodi vuoi vedere della rete ? ->");
					scanf("%d%c",&n,&invio);
					print_rete(r,n);
					break;
					
			   case 6:
			   {
				   FILE *fd;
				   fd = apri_html(r);
				   print_html(fd,r,1,0);
					chiudi_html(fd);
				}
					break;
					
				case 7:
					printf("quale rete (A=10.*/24), (B=172.16.*/16) (C=192.168.*/16) ->");	
					gets(s);
					if (toupper(s[0])== 'B')	
						r=unosettedue;
					else if(toupper(s[0]) == 'C')
					   r=unonovedue;
					else
					   r=dieci;
					break;
					
				case 8:
						pianifica_sottoreti(r);
						break;
			}
		} while(scelta != 0);
				
	}

// Perte per il calcolo delle sottoreti  14 Aprile 2004

void inizializza_reti_private(void)
{
	      char w[128];
	      strcpy(w,"10.0.0.0");     dieci.ip.l              = atoip(w);
	      strcpy(w,"255.0.0.0");    dieci.netmask.l         = atoip(w);  // CLASSE A 10.*/24
	      
	      strcpy(w,"172.16.0.0");   unosettedue.ip.l        = atoip(w);
	      strcpy(w,"255.255.0.0");  unosettedue.netmask.l   = atoip(w);  // CLASSE B 172.16.*/16  
		
		   strcpy(w,"192.168.0.0");  unonovedue.ip.l         = atoip(w);
	      strcpy(w,"255.255.0.0");  unonovedue.netmask.l    = atoip(w);  // CLASSE C 192.168.*/16

}

int main()
{
	inizializza_reti_private();
	menu();
	return 0;
}

/*---------------------FINE--------------------------*/

Ordinamenti ingenui e confronto tempi con quicksort di sistema

/// ORDINAMENTI: VERSIONE IN C .- 1 ott 2009: per provare i tempi di ordinamento
/// Contiene 3 algoritmi di ordinamento (di complessità n^2 ): per scambio, per selezione e per tabella
/// Contiene anche il richiamo alla funzione di sistema qsort()

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <time.h>

int limite;

#define MAX 1000000 // limite max vettore: 1 milione di interi

int v[MAX];

void RANDOMIZE()   
{
    time_t t;
    srand((unsigned) time(&t));
}

int random(int n)
{
    return rand() % n;
}

void pulisci()
{
    int i;
    for (i=0; i < 25; i++)
        printf("\n");
}

#define randomize RANDOMIZE()  // chiamata "randomize;" in borland C

#define clrscr pulisci

int scelta (void) //
{
    int sc; // scelta utente

clrscr();
    printf("1) Dimensionamento vettore\n");
    printf("2) Riempimento vettore    \n");
    printf("3) Stampa vettore \n");
    printf("4) Ordinamento X scambio ------> (n^2)\n");
    printf("5) Ordinamento X selezione ----> (n^2)\n");
    printf("6) Ordinamento X tabella ------> (n^2)\n");
    printf("7) Ordinamento con QuickSort --> (n*log(n))\n");
    printf("8) Esci ...");
    scanf("%d",&sc);
    return sc;
}

void scambia (int v[], int i, int j)
{
    int tmp=v[i];
    v[i]=v[j];
    v[j]=tmp;
}

//=======================================================
/*Algoritmo di Ordinamento per Selezione (select sort)*/

void SelectSort(int v[], int n)
{
    int min,i,j;
    for (i=0; i<n-1; i++)
    {
        min=i;
        for (j=i+1; j<n; j++)
            if (v[j]<v[min]) min=j;
        if (min!=i) scambia(v,i,min);
    }
}
//=======================================================
/*Algoritmo di insert sort [tabella]*/
void InsertSort(int v[], int n)
{
    int tmp;  // appoggio
    int i,j;
    for (i=1; i<n; i++)
    {
        tmp=v[i];
        j=i-1;
        while (j>=0 && v[j]>tmp)
        {
            v[j+1]=v[j];
            j--;
        }
        v[j+1]=tmp;
    }
}
//=======================================================
/*Algoritmo di Ordinamento per Scambio:BubbleSort*/
void BubbleSort(int v[], int n)
{

int ordinato,i;

do
    {
        ordinato =1; // booleano
        for (i=0; i < n-1; i++)
            if (v[i] > v[i+1])
            {
                scambia(v,i,i+1);
                ordinato=0;
            }
    }
    while (!ordinato);

}

void dimensionamento()
{
    printf("Quanti elementi vuoi nel vettore ....");
    scanf("%d",&limite);
}

void riempimento(int v[], int n)
{
    int i;
    int valmax;
    printf("Valore Massimo generato da random() ->");
    scanf("%d",&valmax);

for (i = 0; i < n; i++)
        v[i] = random(valmax) +1;
}

void stampa()
{
    int i;
    int ancora = 1;   // ancora == 1 significa continuo a stampare

for (i=0; i < limite && ancora; i++)
    {
        printf("v[ %d] = %d\n",i,v[i]);
        if ((i+1) % 20 == 0 ) // ogni 20 stampati ... chiedo se continuare
        {
            printf("Ancora [0=no, 1=si] ->");
            scanf("%d",&ancora);
        }
    }
    printf("Premi INVIO ...");
    getchar();
    getchar();
}

void tasto(char msg[],int tempo)  // se tempo = SI, visualizzo anche il tempo
{
    static time_t vecchio;
    static time_t nuovo;   // per contare la differenza di tempo...
    static int primavolta = 1; // booleano

nuovo = time(NULL);
    if ( primavolta )
    {
        primavolta=0;
        vecchio = nuovo;
    }
    printf("%s",msg);
    if (tempo)
        printf(" (Tempo trascorso in secondi:) %10.2lf  - Elementi ordinati: %d " ,difftime(nuovo,vecchio), limite);
    else
        printf("\nPremi INVIO PER FAR PARTIRE L'ALGORITMO SCELTO ED IL CRONOMETRO...");
    vecchio = nuovo;
    getchar();
    getchar();
    printf("\n Sto ordinando, attendere ....\n");
}

//=======================================================
/*Ordinamento (funzione di liberira standard C  qsort() */

int confronto( const void *i, const void *j)  // serve per qsort
{
    return *((int*) i) - *((int*)j);
}

void QuickSort(int v[], int n)
{

qsort((void *)v, n, sizeof(int), confronto);
}

int main(void)
{
    int sc;

randomize;    // va fatto 1 sola volta
    do
    {
        sc = scelta();
        switch(sc)
        {
        case 1:
            dimensionamento();

break;

case 2:
            riempimento(v,limite);
            break;

case 3:
            stampa();
            break;

case 4:
            tasto("Inizializzo tempo !",0);
            BubbleSort(v,limite);
            tasto("\nFine BubbleSort()\n\7",1);
            break;

case 5:
            tasto("Inizializzo tempo !",0);
            SelectSort(v,limite);
            tasto("\nFine SelectSort()\n\7",1);
            break;

case 6:
            tasto("Inizializzo tempo !",0);
            InsertSort(v,limite);
            tasto("\nFine InsertSort()\n\7",1);
            break;

case 7:
            tasto("Inizializzo tempo !",0);
            QuickSort(v,limite);
            tasto("\nFine QuickSort()\n\7",1);

break;

} // end switch
    }
    while(sc != 8);
    printf("\n\nFine programma\n");
    return 1;
}

Nasconde file (.exe o .zip o altro) in immagine (.jpg o altro)

ricerca Dicotomica (in vettore ordinato)

Ordinamento e Scambio di stringhe

/// F. Sacco - Ordinamento e Scambio di stringhe / senza limiti di lunghezza
// da completare, con 3 scambi: fatti con malloc, new e carattere x carattere

#include <stdio.h>
#include <string.h>

#define LMAX 256
#define LINEE 100

char vs[LINEE][LMAX+1];

void sporca()  // se vs NON fosse pulito.....
{
    int i,j;
    char c='A';
    for (i=0; i < LINEE; i++)
        for (j=0; j < LMAX; j++)
        {
            vs[i][j]=c++;
            if (c > 'Z') c='A';
        }
}

void stampa()
{
    int i,j;

for (i=0; i < LINEE; i++)
        printf("[%s]\n",vs[i]);
}

void scambio1(char s1[], char s2[])
{
// con malloc e free
}

void scambio2(char s1[], char s2[])
{
// con new e dispose
}

void scambio3(char s[], char t[])  // carattere x carattere
{
    char dep;
    int i,ls=strlen(s), lt=strlen(t), lmax,lmin;

lmax= ls > lt ? ls : lt;
    lmin= ls < lt ? ls : lt;
    for (i=0; i < lmin; i++)
        dep = s[i],s[i]=t[i], t[i]=dep;

if (ls == lmin) // se s e' la + corta ora diventa la + lunga...
    {

while( i < lmax)
            s[i]=t[i],i++;
        s[i]='\0';
        t[lmin]='\0';  // t diventa la + corta
    }
    else // se t e' la + corta ora diventa la + lunga...
    {
        while( i < lmax)
            t[i]=s[i],i++;
        t[i]='\0';
        s[lmin]='\0'; // s diventa la + corta
    }
}

void scambio4(char s[], char t[])   // con pointer, carattere x carattere
{
    char *max=s, *min=t,dep;
    if ( strlen(s) < strlen(t) )
        max=t,min=s;    // max punta lla + lunga, min alla + corta
    for (; *min; min++,max++)
        dep=*min,*min=*max,*max=dep;  // scambio fino alla lunghezza della + corta
    dep=*max;
    *max++='\0'; // chiudo la stringa + lunga (che ora e' la + corta)
    for(*min++=dep; *max; max++,min++) // copio il rimanente nella + corta (ora la + lunga)
        *min=*max;
    *min='\0'; // chiudo la + corta (ora la + lunga)

}

void ordina(int linee)
{
    int i,j;
    for (i=0; i < linee-1; i++)
        for(j= i+1; j < linee; j++)
            if (strcmp(vs[i],vs[j]) > 0) //if (vs[i] > vs[j])
                scambio4(vs[i],vs[j]);
}

int main()
{
    int i=0,j;

sporca();
    stampa();

do
    {
        printf("Stringa->");
        gets(vs[i]);
        i++;
    }
    while (i < LINEE	&& strlen(vs[i-1]) > 0);
    i--;
    ordina(i);
    for(j=0; j < i; j++)
        printf("[%s]\n",vs[j]);
}

mybyte4-raspberry.h

/***
Header mybyte4-raspberry.h - Dovrebbe far funzionare su raspberry i programmi
scritti con mybyte4.h ***/

#ifndef WIN32  /// se non siamo in Windows
/// ... includo la libreria raspberry per controllo GPIO
#include <wiringPi.h>   /// Commenta in Windows
#endif

#include <stdio.h>
#include <stdlib.h> // per atoi()
#include <string.h> // per strlen()
#include <time.h>

unsigned char pin[8] = {0,3,4,5,6,26,27,25}; /// Pin della GPIO mappati nei bit della PARALLELA
#define BYTE    unsigned char         // un carattere senza segno equivale ad un BYTE
#define LEN 80                        // lunghezza stringhe

#define CICLO(X,N)  for(X=0; X < N; X++)       // ciclo semplificato

#define GIVEIO()         giveio()              // accesso porte

#ifdef WIN32 /// se siamo in Windows
#define OUTPUT 1  /// non serve in raspberry
#define INPUT 0   /// idem

int wiringPiSetup()
{
    printf("\nChiamato wiringPiSetup() - In Windows non faccio nulla!!!\n");
    return 1;
}
int pinMode(int pin, int mode)
{
   /// non faccio nulla in Windows
}
#endif

void giveio()     /// Versione Raspberry di giveio()
{
    int i;
    if(wiringPiSetup() == -1)                  /// inizializza wiringPi
    {
        printf("WiringPi non installato!");
        return;
    }
	for(i=0;i<8;i++){           //imposta gli 8 pin in output
		pinMode(pin[i], OUTPUT);
	}

}

#define PARALLDEB(valore)  scrivibyte(valore)  // debug parallela --> il valore va su schermo

#ifdef WIN32 ///Se siamo in Windows
/// ... simulo la DigitalWrite delle wiringPi... e la delay in windows...

void digitalWrite(int pin, int valore)  /// crea file html di debug
{
    /// non serve in raspberry
    #define LOW 0
    #define HIGH 1
    int i;
    static FILE *fd=0;   /// e' statico, lo apre solo la prima volta
    static int cont = 0;   /// a 8 conta un Byte
    if (!fd)
    {
        fd = fopen("digitalWrite.html","w");
        if (fd == 0)
            printf("Errore apertura file digitalWrite.txt"), exit(0);
        fprintf(fd,"<html><table border=1>\n");
        for (i=0; i <8; i++)
            fprintf(fd,"<th>bit %d</th>",i);
        fprintf(fd,"<tr>\n");
    }
	fprintf(fd,"<td>DigWrt(%d,%d)</td>",pin,valore);
	cont++;
	if (cont == 8) fprintf(fd,"<tr>\n"), cont=0; /// separo un Byte (8 bit) dal prossimo
}

void delay(unsigned int mseconds) /// non serve in raspberry, solo X Windows
{
    clock_t goal = mseconds + clock();
    while (goal > clock());
}
#endif // WIN32

/***FINE PARTE PER WINDOWS ***/

}

/// ritardo di sistema in linux funziona bene e non salta delay()
/// micro overclock 1GHz = 1 000 000 000 operazioni al secondo

#define led_on(pin)     digitalWrite(pin, HIGH)
#define led_off(pin)    digitalWrite(pin, LOW)

void PARALL(unsigned char n)  /// simula il PARALLEL() in windows
{

int i;
    if (n == 0) /// In windows PARALL(0) toglie tesnsione
        for(i = 0; i < 8; i++)
            led_off(pin[i]);
    else  // accetto valori in binario
    {
        /// E' possibile fare il codice qui sotto con un ciclo, ma cosi' e' piu' leggibile...
        n &   1 ? led_on(pin[0]): led_off(pin[0]);
        n &   2 ? led_on(pin[1]): led_off(pin[1]);
        n &   4 ? led_on(pin[2]): led_off(pin[2]);
        n &   8 ? led_on(pin[3]): led_off(pin[3]);
        n &  16 ? led_on(pin[4]): led_off(pin[4]);
        n &  32 ? led_on(pin[5]): led_off(pin[5]);
        n &  64 ? led_on(pin[6]): led_off(pin[6]);
        n & 128 ? led_on(pin[7]): led_off(pin[7]);
    }

#ifdef WIN32
        return PARALLDEB(n); /// Se compilo da windows ... vado a schermo
    #endif // WIN32
}

void pausa(int n) /// per compatibilita' con mybyte4.h
{
    delay(n);
}

void leggistr(char str[])   // legge una stringa
{
    fgets(str,LEN,stdin);
    str[strlen(str)-1] = '\0';   // metto il \0 anzichè il \n
}

BYTE binario(char str[])  // trasforma un stringa contenente un numero in binario in decimale
{
    int somma = 0;
    int pot=1;
    int i;
    char c;

return somma;

}

BYTE leggibyte(char modo)   // legge un byte in 'D' -> decimale, 'B' -> binario
{
    char stringa[LEN+2];

/*---------------------FINE--------------------------*/

Programmi utili in C - ult. modif. 23-1-2016

Segui il link se vuoi copiare in Office con colori evidenziati!!!

Funzioni: random()/RANDOMIZE()

Funzioni I/O C

Vettori C

Mybyte4.h - Gestione Byte/Parallela/Seriale (GIVEIO)

CGI Windows/Linux compatibili (Header cgi.h 2014)

Sock.h Windows/Linux compatibili

Calendar.c - Calendario perpetuo

Pesco i nomi di file in una cartella (solo Windows)

Generatore di password data la partenza (X Smemorati!!!)

Reti.c / Capire meglio le reti tcp/ip

Ordinamenti ingenui e confronto tempi con quicksort di sistema

Nasconde file (.exe o .zip o altro) in immagine (.jpg o altro)

ricerca Dicotomica (in vettore ordinato)

Ordinamento e Scambio di stringhe

mybyte4-raspberry.h

(Vers. 23 Gen 2016)