[C] Copiare aree di memoria

[Jokulhaups]

Salve a tutti,

per un programma che simuli la gestione dell'allocazione della memoria, devo copiare un'area di memoria in un'altra area di memoria.

In pratica ho un'applicazione SERVER in ascolto...
Un'applicazione CLIENT alloca una determinata area di memoria, ci scrive dentro qualcosa, poi chiama una funzione del server passandogli il (void *) all'area di memoria allocata.

A questo punto il SERVER dovrà andare a leggere nell'area di memoria suddetta e copiare byte per byte i dati in un'altra area di memoria.


per fare ciò uso la funzione memcpy, il problema è che sembra che il SERVER non riesca ad accedere all'area di memoria allocata dal CLIENT, riesco ad ottenere il giusto indirizzo tramite FIFO, ma quando si tratta di accedervi sembra impossibile, infatti la memcpy non fa un bel niente...

E' possibile accedere da un processo ad un'area di memoria allocato da un altro processo? Un modo deve esserci ma non so quale.
Se può essere utile sto lavorando sotto linux.


Qualcuno sa aiutarmi?

[oregon]

Originariamente inviato da Jokulhaups
... E' possibile accedere da un processo ad un'area di memoria allocato da un altro processo?

No. E' assolutamente vietato.

Puoi accedere solamente a zone di "memoria condivisa" in maniera opportuna.

Leggi questo

http://tldp.org/LDP/lpg/node65.html#...00000000000000

[Jokulhaups]

Ciao, grazie della risposta.

Allora ho rifatto il tutto e ora mando i dati tramite FIFO per evitare l'accesso alla memoria dove non posso, però ho un problema.

Dopo che il SERVER legge la FIFO, le memcpy non funziona più, sembra rimanere in stallo. Tutti i dati dentro le fifo vengono letti correttamente, ma la funzione memcpy dopo non funziona proprio più, anche usando dati che non sono stati passati tramite FIFO, non capisco perchè!

faccio un esempio, questa è la parte del server:

Codice:

//////////////////////faccio una memcpy prima della READ/////////////////////////////////////////////
char s1[30] = "ciao a tutti";
char s2[30];
char s3[30];


memcpy(s2, s1, 30);

if ((n_byte = read(FIFO_to_read, buffer, buffer_dim) )== -1)
perror(" Errore nella lettura della fifo");
else
printf(" nella fifo sono stati letti %d byte e in buffer c'è %s\n", n_byte, buffer);


////////////////faccio una memcpy dopo la READ///////////////////////////////////////////
memcpy(s3, s1, 30);

questa è la parte del CLIENT:

Codice:

char stringa[30] ="sono la stringa da inviare";
int size = 30;

buffer = stringa;

n_byte = write(FIFO_to_write, buffer, size);

if (n_byte == -1)
perror(" Error while writing FIFO");
else
printf("nella fifo sono stati scritti %d byte \n",n_byte);

tutte le memcpy prima della read vengono effettuate normalmente, ma dopo la read la memcpy non va più il programma si blocca sulla sua istruzione.

La cosa strana è che prima faccio altre READ tramite FIFO, ma c'è una READ in particolare dopo la quale la memcpy non funziona più, eppure i dati dalla fifo vengono letti normalmente, se provo a stamparli ci sono e sono giusti.


Quel che sembra che gli dia fastidio è che dalla parte del client invio la stringa, il server la riceve correttamente ma dopodichè si blocca la memcpy, se invece invio l'indirizzo della stringa, il server riesce poi afare le varie memcpy, ma ovviamente poi non può accedere alla stringa perchè è stata dichiarata dall'altra applicazione.

COME DIAVOLO NE ESCO!?!?!

Se non sono stato chiaro fate pure domande che qui sto nella m... ehm pupù fino al collo!


Vi ringrazio per l'aiuto

[oregon]

Scusa ... ma buffer in

if ((n_byte = read(FIFO_to_read, buffer, buffer_dim) )== -1)

cosa e'?

[Jokulhaups]

riscrivo l'esempio che non avevo usato i tag CODE e riusltava poco chiaro, ho anche aggiunto le dichiarazioni di tutte le variabili.

FIFO_to_read è il File Descriptor della FIFO dalla parte del server.
FIFO_to_write è il File Descriptor della FIFO dalla parte del client.

La FIFO è stata aperta correttamente da entrambe le parti, come ho già detto le ho già utilizzate in precedenza e sono ok, il problema è quando gli una stringa anzichè il puntatore alla stringa e dopo faccio la memcopy.

//////////////////////faccio una memcpy prima della READ/////////////////////////////////////////////
char s1[30] = "ciao a tutti";
char s2[30];
char s3[30];

void * buffer;
int n_byte;
int buffer_dim = 30;


memcpy(s2, s1, 30);

if ((n_byte = read(FIFO_to_read, buffer, buffer_dim) )== -1)
perror(" Errore nella lettura della fifo");
else
printf(" nella fifo sono stati letti %d byte e in buffer c'è %s\n", n_byte, buffer);


////////////////faccio una memcpy dopo la READ///////////////////////////////////////////
memcpy(s3, s1, 30);

questa è la parte del CLIENT:

char stringa[30] ="sono la stringa da inviare";
int size = 30;
void * buffer = stringa;
int n_byte;


n_byte = write(FIFO_to_write, buffer, size);

if (n_byte == -1)
perror(" Error while writing FIFO");
else
printf("nella fifo sono stati scritti %d byte \n",n_byte);