View Full Version : GNU socket su windows
Salve,
sapete se è possibile programmare con le socket in C di Linux , rimanendo però sotto Windows?
Lo so che i Linuxiani mi meneranno, ma lo chiedo solo perchè gli editors e l'ambiente Win mi è più familiare..
ovviamente a programma terminato, il tutto girerà sotto Linux..
Mi serve quindi un ambiente C per windows che accetti le chiamate bind() , listen() ..insomma quelle per l' HTTP di Linux..
Che dite? ciao
Che tra l'altro sono le stesse funzioni che ci sono su Windows...
Comunque puoi programmare con Cygwin e potrai usare le stesse identiche funzioni che usi su Linux...
grazie per la dritta..
vediamo se riesco a programmare roba per Linux con gli ottimi editors e compilatori visuali di windows..
credo che i puristi bestemmieranno :p :eek: :D
Kleidemos
26-08-2003, 09:09
Originariamente inviato da cionci
Comunque puoi programmare con Cygwin e potrai usare le stesse identiche funzioni che usi su Linux...
spiegati meglio...............
Originariamente inviato da cionci
Che tra l'altro sono le stesse funzioni che ci sono su Windows...
Comunque puoi programmare con Cygwin e potrai usare le stesse identiche funzioni che usi su Linux...
GRANDE!!! :sofico:
Riesco a compilare ed eseguire con successo sotto Win il programma che stavo creando sotto Linux...
Ottimo questo cygwin!!!
Grazie ancora :D
una cosetta:
perchè quando dichiaro una variabile globale (cioè in testa al file,fuori da ogni funzione), questa non mi rimane aggiornata se la usano le funzioni?
Esempio:
dichiaro in testa al file int i=0;
in una funzione (che viene richiamata periodicamente) ci metto
i++; perchè voglio usarlo come contatore...
Sapete cosa succede?
Se metto una printf("i= %i",i) sotto all' istruzione i++;
mi stampa i= 1 continuamente, fregandosene dell' incremento ad ogni passo..
Non capisco....mi pare assurdo...è come se venisse richiamata int i=0 ogni volta oppure non venga fatto l'incremento...entrambi le cose sono inverosimili..
Commenti? thx
Originariamente inviato da fedo
una cosetta:
perchè quando dichiaro una variabile globale (cioè in testa al file,fuori da ogni funzione), questa non mi rimane aggiornata se la usano le funzioni?
Esempio:
dichiaro in testa al file int i=0;
in una funzione (che viene richiamata periodicamente) ci metto
i++; perchè voglio usarlo come contatore...
Sapete cosa succede?
Se metto una printf("i= %i",i) sotto all' istruzione i++;
mi stampa i= 1 continuamente, fregandosene dell' incremento ad ogni passo..
Non capisco....mi pare assurdo...è come se venisse richiamata int i=0 ogni volta oppure non venga fatto l'incremento...entrambi le cose sono inverosimili..
Commenti? thx
Perchè non mi posti un piccolo esempio di codice funzionante che implementi questo comportamento???
OK! :p
in testa al file .c ho:
#include "config.h"
#include "richiesta.h"
int i; //Contatore globale del programma
Poi ho le varie funzioni, tra cui:
int ris_list_save(struct risposta * risposta)
{
//altre istruzioni che non contano....
i++;
printf("\n%i",i);
return i;
}
Ecco, questa funzione viene richiamata spesso nel programma...solo che la "i" rimane con lo stesso valore invece di incrementarsi ogni volta.... :confused:
Non ci sono altre istruzioni che modificano i...
Boh.. ciao
Originariamente inviato da fedo
OK! :p
in testa al file .c ho:
#include "config.h"
#include "richiesta.h"
int i; //Contatore globale del programma
Poi ho le varie funzioni, tra cui:
int ris_list_save(struct risposta * risposta)
{
//altre istruzioni che non contano....
i++;
printf("\n%i",i);
return i;
}
Ecco, questa funzione viene richiamata spesso nel programma...solo che la "i" rimane con lo stesso valore invece di incrementarsi ogni volta.... :confused:
Non ci sono altre istruzioni che modificano i...
Boh.. ciao
Ok... Dimmi che versione di compilatore hai installato. Si vede con gcc --version. Devo fare un piccolo esperimento.
Comunque se ti serve una variabile contatore non serve dichiarare una variabile globale. Basta una variabile locale dichiarata static (visto che stai una variabile globale utilizzata da una sola funzione utilizzarne una globale mi sembra un po eccessivo):
int
increment_counter(void)
{
static int i = 0;
return (++i);
}
Dimmi un po... Ma perchè quel return alla fine della funzione??
Grazie..
allora la versione è 3.2 del 2002 (un anno fa preciso)
Ora ti dico come è il flusso delle chiamate a funzione:
dal main contenuto nel file pippo.c viene chiamata la funzione
prova() contenuta in un altro file topolino.c
La variabile globale i sta proprio in questo file...
Dunque, prova() chiama int ris_list_save(struct risposta * risposta) che ti ho postato...
Quando essa termina, ritorna a prova() che poi ritorna al main nell'altro file....il ciclo iterativo sta proprio qui..
E' possibile che siccome il ciclo iterativo sta in un altro file, allora la variabile i muore perchè è globale del topolino.c e non di tutto il programma?
Il return i che mi chiedevi mi serviva per debug precedenti...de la i rimane globale non ha senso...infatti lo toglierò...
Thx
Originariamente inviato da fedo
Grazie..
allora la versione è 3.2 del 2002 (un anno fa preciso)
Ora ti dico come è il flusso delle chiamate a funzione:
dal main contenuto nel file pippo.c viene chiamata la funzione
prova() contenuta in un altro file topolino.c
La variabile globale i sta proprio in questo file...
Dunque, prova() chiama int ris_list_save(struct risposta * risposta) che ti ho postato...
Quando essa termina, ritorna a prova() che poi ritorna al main nell'altro file....il ciclo iterativo sta proprio qui..
E' possibile che siccome il ciclo iterativo sta in un altro file, allora la variabile i muore perchè è globale del topolino.c e non di tutto il programma?
Il return i che mi chiedevi mi serviva per debug precedenti...de la i rimane globale non ha senso...infatti lo toglierò...
Thx
Aspetta aspetta ... Non intrecciarmi la testa!! La variabile globale si trova nello stesso file della funzione che la incrementa??
si, la var. globale sta nello stesso file della funzione che la utilizza..
E' solo che tale funzione viene richiamata ciclicamente dal main...non vorrei che ogni volta che si ritorna al main, il valore della variabile viene perso dalla memoria...
Ora mi è chiaro...
La funzione non è stata dichiarata come static, quindi richiamabile anche all'esterno del file di codice.
Prova nel file di codice sorgente della main a mettere dopo gli header, globalmente, questa dichiarazione. Poi fammi sapere come va:
extern int i;
:eekk:
Aspetta aspetta che ho detto una minchiata assurda!!!!!!
Ti prego dimmi i valori che ottieni della var i dopo ogni chiamata della funzione di incremento ...
Inoltre utilizza il flag '-Wall' quando compili...Sono sicuro che il compilatore emetterà qualche warning utile allo scopo...
con il -Wall il compilatore non emette nessun warning, però il linker fallisce per cause indipendenti da questo problema....non penso possa servire..
mettendo la extern int i nel main non si ottiene nulla e cmq non servirebbe perchè non è che mi serve la variabile i dentro il main...
i valori dopo ogni chiamata sono tutti uguali...
in particolare, è sempre 1...questo perchè parte da zero, poi fa il primo incremento ma non i successivi....
oppure (cosa + plausibile) si perde la variabile quando torna al main e quindi poi riparte sempre da zero e fornisce 1...
mi serve proprio questo cavolo di contatore globale per il programma...non deve resettarsi...accidenti...
:rolleyes:
ho provato ad aggirare il suo uso, ma non posso...è necessario averlo..
ciao
Originariamente inviato da fedo
mi serve proprio questo cavolo di contatore globale per il programma...non deve resettarsi...accidenti...
:rolleyes:
ho provato ad aggirare il suo uso, ma non posso...è necessario averlo..
ciao
Ma io stavo continuando la discussione perchè mi interessava capire il motivo di questo comportamento ... Altrimenti ti ho già detto come devi fare per usare un contatore ...
il motivo te l'ho detto...secondo me la var. globale si perde quando ritorna al main che sta in un altro file...
che dici?
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 ;)
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);
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.... :cry:
Strano che non ti abbia funzionato.... Dovrebbe funzionare tranquillamente... Probabilemnte c'è qualche bug nel GCC del Cygwin...
voi se doveste usare una variabile contatore globale in memoria, come la dichiarereste?
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;
}
nulla :cry: :cry:
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 :muro: :muro:
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 ?
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.... :confused:
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...
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.... :confused:
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.
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
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.
Dio santo che casino :eek:
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 ....
grazie per i consigli...un debugger lo so usare...
Il fatto è che non sopporto nè Unix nè il C :D
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?
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??? :D :D :D
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
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.
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?
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.5/html_node/index.html
Se non lo trovi li vuol dire che non esiste. Considera comunque che mmap() lavora sui file descriptor.
Originariamente inviato da fedo
Inoltre non mi dispiacerebbe un mapping della cache anche su disco..così se il proxy crasha, non mi perdo i dati cachati..
Per quello basta salvare i file anche su disco con una ID consecutiva...e poi organizzarti un file che contiene tutta la lista dei link in cache (caricato in memoria al momento dell'esecuzione e salvato periodicamente)
si infatti era quello che pensavo...
grazie ragazzi.. ;)
mjordan, sai che faccio?
invece di usare la fork() , il proxy concorrente lo faccio con la select().. stavo leggendo come funziona e dovrebbe andare bene (infatti il processo rimane uno solo, con il round robin tra le connessioni) ..
quindi almeno risolvo il problema della mem. condivisa...e anche dell' I/O bloccante sulla accept ,read e write...
ti faccio sapere...ciao
P.S. saluto pure Cionci :)
Originariamente inviato da fedo
mjordan, sai che faccio?
invece di usare la fork() , il proxy concorrente lo faccio con la select().. stavo leggendo come funziona e dovrebbe andare bene (infatti il processo rimane uno solo, con il round robin tra le connessioni) ..
quindi almeno risolvo il problema della mem. condivisa...e anche dell' I/O bloccante sulla accept ,read e write...
ti faccio sapere...ciao
P.S. saluto pure Cionci :)
Un grosso in bocca al lupo ;)
Se ti serve un esempio...
grazie ragazzi..
sta cavolo di select è tremenda da gestire, ma è mooolto professionale :p
Originariamente inviato da cionci
Se ti serve un esempio...
Il tuo file ha una buona procedura concorrente...
ho fatto il porting del codice all'interno del mio progetto e l'unico errore si presenta a queste istruzioni:
setsockopt(accept_fd, SOL_SOCKET, SO_REUSEPORT, &x, sizeof(x));
bzero(&servaddr, sizeof(servaddr));
La bzero() non ha problemi (a che diamine serve
:confused: )
Invece gcc mi comunica che SO_REUSEPORT non è stata dichiarata...è una variabile che avevi in altri files, oppure è di qualche libreria H che mi manca?
Sai nulla di questo parametro..?
ciao
Quel sorgente era per FreeBSD, probabilmente è per questo che hai errori...
Quel parametro serve per poter riuitilizzare subito la porta se il programma non viene chiuso correttamente... Prova a toglierlo...se la porta rimane in uso dopo che hai chiuso il programma con CTRL-C allora sicuramente ci sarà il modo di inserirlo...
bzero azzera il contenuto della memoria a partire dall'indirizzo passato come primo parametro, per un numero di byte passato come secondo parametro...
Che io sappia su Linux funziona tranquillamente quel bzero...
Comunque puoi realizzarlo in questo modo:
#define bzero(mem, num) memset(mem, 0, num)
Ci credo che è fatta bene...l'ha fatta questo prof: http://info.iet.unipi.it/~luigi/
Leggi perchè ha cambiato l'email...
OK..thx..
bzero funge infatti...è solo che non so come sostituire quel SO_REUSEPORT ...col NULL non và..
Non so se conoscete la libreria MM Shared Memory...dato che ho saputo che con tale libreria, gestire la shared memory tra i processi è molto facile, ho provato a ritornare al vecchio fork...
usando le varie API per la gestione della memoria (tipo MM_create), quando compilo solo con l'opzione -c ottengo:
myproxys.c: In function `main':
myproxys.c:73: warning: assignment makes pointer from integer without a cast
myproxys.c: In function `make_den':
myproxys.c:119: warning: initialization from incompatible pointer type
myproxyc.c: In function `proxy_forward':
myproxyc.c:37: warning: assignment makes pointer from integer without a cast
myproxyc.c:55: warning: assignment makes pointer from integer without a cast
E fin qui tutto bene (non fate caso ai warnings...)
Se vado a compilare con -o per ottenere l'eseguibile:
myproxys.c: In function `main':
myproxys.c:73: warning: assignment makes pointer from integer without a cast
myproxys.c: In function `make_den':
myproxys.c:119: warning: initialization from incompatible pointer type
myproxyc.c: In function `proxy_forward':
myproxyc.c:37: warning: assignment makes pointer from integer without a cast
myproxyc.c:55: warning: assignment makes pointer from integer without a cast
/cygdrive/c/DOCUME~1/fedo/IMPOST~1/Temp/ccGhz5fu.o(.text+0xb1):myproxys.c: undef
ined reference to `_MM_create'
/cygdrive/c/DOCUME~1/fedo/IMPOST~1/Temp/cccz97Hy.o(.text+0xe):cache.c: undefined
reference to `_MM_lock'
/cygdrive/c/DOCUME~1/fedo/IMPOST~1/Temp/cccz97Hy.o(.text+0x1a):cache.c: undefine
d reference to `_MM_malloc'
/cygdrive/c/DOCUME~1/fedo/IMPOST~1/Temp/cccz97Hy.o(.text+0x2b):cache.c: undefine
d reference to `_MM_malloc'
/cygdrive/c/DOCUME~1/fedo/IMPOST~1/Temp/cccz97Hy.o(.text+0x3c):cache.c: undefine
d reference to `_MM_malloc'
collect2: ld returned 1 exit status
Quindi un problema di linker...sapete mica come ovviare?
Pensavo che fosse installato male il package MM, ma la compilazione funge, quindi le funzioni le trova...o sbaglio?
bye
per quanto riguarda la select che mi hai mandato, ecco qui il sorgente, dove al posto di So_REUSEPORT ho messo uno 0 .
puoi provare a compilarlo e mi dici se funziona?
grazie ciao
setsockopt puoi anche evitare di usarla...non è fondamentale...
uè , guarda che proxy che ho tirato fuori (con la fork)
funziona sotto windows :D
avvia mp.exe da una finestra prompt,
setta 127.0.0.1 porta 8080 come proxy di I. Explorer e dimmi se ti và veloce in navigazione...
ciao
oh, non riesco a risolvere quel problema di compilazione...come diamine si installa questa libreria??
che dici. cio?
Non usare setsocketopt !!!
Dove te lo da il problema ?
guarda qui:
for ( ; ; )
{
int n;
fd_set r, w, e;
int nfds;
struct timeval t;
prepara(&nfds, &r, &w, &e, &t);
n = select(nfds, &r, &w, &e, &t);
fprintf(stderr, "-- select returns %d\n", n);
gestisci_fd(&r, &w, &e);
} //chiude for(;;)
#if 0
printf("ciao");
j = accept(i, NULL, NULL);
fprintf(stderr, "accept returns %d\n", j);
err=read (j, buf, sizeof(buf));
fprintf(stderr, "++ read returns %d\n", err);
richiesta = parse_richiesta(buf);
risposta = proxy_forward(richiesta->host,richiesta->port,buf,j);
write_risposta(j,risposta);
close(j);
#endif
Ecco, dentro l' #if 0 non ci entra mai... si pianta a scrivere di continuo:
"-- select returns 0,
"-- select returns 1,
.
.
Le funzioni che svolgono il lavoro di proxy, non le chiama...
Cmq ho risolto il problema di linking di cui parlavo sopra...
ciao
Quel #if 0 è sempre falso quindi è normale che non ci entri...
Inoltre il for(;;) cicla all'infinito...e quindi nonci esce mai...
Il codice all'interno di #if 0 #endif era codice rimasto da un programma di prova precedente...
Le tue funzioni le devi mettere dentro a gestisci !!!
grazie..non mi ero mai imbattuto in
#if 0
.
.
.
#endif
Rieccomi qui :D
Ho risolto molti dei problemi, ma ora mi si presenta questo:
typedef struct res_info
{
char url[300];
int quality;
char last_mod[25];
char expires[25];
}res_info;
int main(int argc, char argv[][])
{
res_info cache_reg[10];
FILE *fp_cache;
if((fp_cache = fopen("tt_reg.txt","a+")) == NULL) printf("Errore nell'apertura del registro di cache");
cache_reg = (res_info ) mmap(NULL, 10 * sizeof(res_info), PROT_READ|PROT_WRITE, MAP_SHARED,fileno(fp_cache),0);
return 0;
};
Ecco, il problema sta nella mmap...quando compilo mi dice "conversion to non-scalar type required" ...
Come la faccio quella assegnazione mmap?
ciao ;)
ah ok
così pare funzionare:
res_info * cache_reg;
cache_reg = (res_info *) mmap(NULL, 10 * sizeof(res_info),PROT_READ|PROT_WRITE, MAP_SHARED,fileno(fp_cache),0);
In compilazione tutto OK.
Se al codice aggiungo una:
strcpy(*cache_reg[0].url,"ok url 0");
, quando esegui il programma, mi và in eccezione di memoria e termina...
cosa diamine è ora? :mad:
che ridicolaggine!
per fare quell' assegnazione il file che mappi non deve essere vuoto.... potevano fare che se mappi un file vuoto, lo riempivano con caratteri fasulli temporanei... :D
spero che tutto ciò possa servire ad altri programmatori...è pur sempre GNU avanzato...
vBulletin® v3.6.4, Copyright ©2000-2025, Jelsoft Enterprises Ltd.