GNU socket su windows

[fedo]

però ho notato che la variabile serve a più di una funzione nel file...quindi mi serve globale...

Per fare questa variabile contatore globale, il cui valore rimane in memoria finchè non termina il programma, devo dichiarare

static int i; in testa al file?


CMQ grazie 1000 per la pazienza

[cionci]

Altrimenti, se fosse davvero un bug, fai una funzione del genere:

int incrementa(int add)
{
   static int i = 0;
   return i += add;
}

/*per iincrementarla*/
incrementa(1);
/*per leggerne il valore*/
incrementa(0);

[fedo]

ho provato anche questa,ma oltre che una "porcata", manco ha funzionato...

mi chiedo: non è possibile che una variabile non possa mantenere il suo valore durante tutta l'esecuzione...ci deve essere un modo per fare una cosa del genere....

[cionci]

Strano che non ti abbia funzionato.... Dovrebbe funzionare tranquillamente... Probabilemnte c'è qualche bug nel GCC del Cygwin...

[fedo]

voi se doveste usare una variabile contatore globale in memoria, come la dichiarereste?

[cionci]

Così:

#include <stdio.h>
#include "include.h"

/*extern implica che i è definita in un altro modulo oggetto*/
extern int i;

void stampa()
{
    printf("%d\n",++i);
}

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

  return 0;
}

include.h:

void incrementa();

include.c:

#include "include.h"
int i = 0;

void incrementa()
{
   ++i;
}

[fedo]

ok ..ora provo..

[fedo]

nulla

tutte le variabili globali che uso, vengono resettate quando le richiamo al nuovo ciclo...contatore sempre resettato..

Però ho scoperto che tale contatore viene portato correttamente nel main, se lo dichiaro extern nel file del main...

Appena si ripassa nell'altro file, si resetta..

Ma porca putt

[cionci]

Ma hai fatto tutto identico a come ho fatto io ? In quale altro file ti si resetta ? Puoi farmi un esempio di situazione in cui non ti funziona ?

[fedo]

allora,,

per tagliare la testa al toro, ho fatto un piccolo programmino a parte (tipo il tuo) dove uso queste variabili condivise..

il risultato è che qui funziona!!!

Quindi il problema sta nel mio programma, credo nel cilo for del main...

non so se postandovi il codice lo capireste, perchè sto progettando un proxy server http e la complessità è sostenuta...(cmq se volete vi do i files....)

Spero in qualche modo di capire perchè si resetta....

Ora mi viene un dubbio: siccome nel ciclo for del main viene fatta per ogni richiesta http una fork(), non è che nel passaggio processo padre-processo figlio, si perdono queste variabili? ..anche se ricordo che la fork duplica integralmente i dati, secondo voi c'entra qualcosa?

siete molto gentili cmq...

[mjordan]

Originariamente inviato da fedo
allora,,

per tagliare la testa al toro, ho fatto un piccolo programmino a parte (tipo il tuo) dove uso queste variabili condivise..

il risultato è che qui funziona!!!

Quindi il problema sta nel mio programma, credo nel cilo for del main...

non so se postandovi il codice lo capireste, perchè sto progettando un proxy server http e la complessità è sostenuta...(cmq se volete vi do i files....)

Spero in qualche modo di capire perchè si resetta....

Ora mi viene un dubbio: siccome nel ciclo for del main viene fatta per ogni richiesta http una fork(), non è che nel passaggio processo padre-processo figlio, si perdono queste variabili? ..anche se ricordo che la fork duplica integralmente i dati, secondo voi c'entra qualcosa?

siete molto gentili cmq...

Posta posta. Anch'io ho programmato un proxy tempo fa.

[fedo]

ecco i sorgenti...tenete conto che sono un pò disordinati e con istruzioni di debug..

per il mio problema sono da guardare i files myproxys.c e cache.c

io penso che il problema rimanga la fork() e lo switch tra processi...

ciao

[mjordan]

Originariamente inviato da fedo
ecco i sorgenti...tenete conto che sono un pò disordinati e con istruzioni di debug..

per il mio problema sono da guardare i files myproxys.c e cache.c

io penso che il problema rimanga la fork() e lo switch tra processi...

ciao

Grazie. Analizzo e propongo.

[mjordan]

Dio santo che casino
Io penso di aver capito da dove viene il problema.
Però mi devi dire qual è la variabile incriminata (rl_slot?) e la funzione che la incrementa (ovviamente anche il sorgente dove sta questa funzione). Inoltre dimmi il sorgente dove viene richiamata questa funzione di incremento.

PS: Se vuoi un consiglio lascia stare gli editor visuali grafici. I programmi unix vanno scritti in modalità console su terminali 80x25. I commenti che hai inserito complicano troppo le cose invece che semplificarle. Hai dei commenti che prendono tre righe di terminale. Inoltre considera che se ti compila su CYGWIN non compilerà di certo sotto Linux/Unix. E' buono per fare un porting, non per scrivere codice UNIX.

Spero tu sappia usare un debugger ....

[fedo]

grazie per i consigli...un debugger lo so usare...

Il fatto è che non sopporto nè Unix nè il C

Sono amante di Windows + Java...ti ho detto tutto

si la variabile è rl_slot..la funzione che la usa sta in fondo a cache.c

Ma guarda che il problema è certamente la fork() che sta nel main..

penso che la variabile debba essere messa in memoria condivisa per i processi che la fork genera...altrimenti ogni figlio,quando muore, fa perdere le modifiche apportate alla rl_slot .. quella del processo padre rimane sempre 0 .

Sai come mettere variabili in memoria condivisa?

[mjordan]

Ho trovato il problema. Il fatto è che usi la fork() in modo totalmente errato. Innanzitutto non controlli il valore di ritorno del pid per un eventuale continuazione del processo padre.

Ti ho scritto questo programma che dovrebbe essere il minimo insieme della situazione che hai creato all'interno del tuo proxy.

/* -*-linux-c-*-
 * Coded 13/09/2003 by mjordan - HWUPGRADE programming forum.
 * Compilare con la seguente riga di comando:
 * `gcc -Wall -std=c99 -g -O2 -D_GNU_SOURCE -o prova prova.c'
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

/* Variabile globale. Mai usarle per contatori. */
int i = 0;

void
var_increment(void)
{
	printf("\nOk...Siamo nel processo figlio...\n");
	printf("Valori di i.\n");
	for (int count = 0; count < 10; count++)
		printf("%d\n", ++i); /* Incrementiamo i */

	return;
}

int
main(int argc, char ** argv)
{
	int exit_status;
	pid_t pid;

	if ((pid = fork()) == 0) { /* processo figlio. */
		var_increment();
		if (WIFSIGNALED(exit_status))
			fprintf(stderr, "Processo %d: terminato dal segnale %d: %s\n",
				(int)pid, WTERMSIG(exit_status), strerror(errno));
	}
	else 
		if (pid < 0) { /* La fork() e' fallita. */
			fprintf(stderr, "fork() fallita. Buttami nel cesso.\n");
			abort();
		}
		else {
		       /* Ok. Ora siamo nel processo padre.
		        * Che valore abbiamo di i?
		        */
			pid = waitpid(pid, &exit_status, WUNTRACED);

	                printf("Ok...Siamo nel processo padre...\n");
	                printf("Valore restituito da i: %d\n", i);

	                if (i != 10)
				printf("Mmmm...Qualcosa non torna... :D\n");
		}

	return 0;
}

Questo invece è l'output:

Ok...Siamo nel processo figlio...
Valori di i.
1
2
3
4
5
6
7
8
9
10
Processo 0: terminato dal segnale 32: Success
Ok...Siamo nel processo padre...
Valore restituito da i: 0
Mmmm...Qualcosa non torna... :D

Che cosa puoi evincere???

[fedo]

ne evinco che è come dicevo...

per condividere il valore di quella variabile, bisogna usare una regione IPC condivisa...

solo che non ho mai usato le funzioni IPC per shared memory...

sapresti mica come usarle?

ciao

[mjordan]

Ci sono due modi per effettuare un meccanismo con la shared memory fra processi. La POSIX shared memory e la System V shared memory. Dette in parole povere consistono nel creare aree di locazione di memoria condivise mediante memory mapped I/O (e che tra parentesi lavorano con i file descriptor).

Vorresti mica usare l'mmap per una sola variabile. Secondo me per come la vedo io è sbagliato l'approccio. Faresti prima a scrivere una funzione che o restituisce o incrementa la variabile dichiarata localmente alla funzione in modo statico. Così puoi leggerla anche senza farvi un accesso diretto.
Del tipo:

int
var_increment(bool incr)
{
        static int rl_slot = 0;

        if (incr)
                return(++rl_slot);

        return rl_slot;
}

In questo modo con:

incr_var(true);

incrementi la variabile, invece con

incr_var(false);

la leggi semplicemente (magari all'interno del processo).

In questo modo la variabile risulta locale ad una sola funzione, ma puoi leggerne il contenuto globalmente sia nel parent che nel child process.

[fedo]

e se io volessi usare questa variabile contatore i e questo buffer caratteri cache_reg in memoria condivisa con mmap?

come dovrei dichiararli?

so che mmap ha il parametro SHARED_MEMORY che dovrebbe fare al caso mio...

Inoltre non mi dispiacerebbe un mapping della cache anche su disco..così se il proxy crasha, non mi perdo i dati cachati..

che ne dici?

[mjordan]

Originariamente inviato da fedo
e se io volessi usare questa variabile contatore i e questo buffer caratteri cache_reg in memoria condivisa con mmap?

come dovrei dichiararli?

so che mmap ha il parametro SHARED_MEMORY che dovrebbe fare al caso mio...

Inoltre non mi dispiacerebbe un mapping della cache anche su disco..così se il proxy crasha, non mi perdo i dati cachati..

che ne dici?

Per tutto questo ti rimando alla GNU C Library Reference Manual.

http://www.gnu.org/manual/glibc-2.2....ode/index.html

Se non lo trovi li vuol dire che non esiste. Considera comunque che mmap() lavora sui file descriptor.