socket forbindelse

I kan enten send en struct per send/recv eller
i kan pakke alle struct'ene ned i en data-struktur
(enten en ny struct eller bare et char array) og
bruge en enkelt send/recv.

Det lyder cool nok, men jeg kunne godt bruge et lille kode eksempel....:-)

Argh nu røg pointene, men kan du ikke lige ligge et eksempel alligevel :-)

Hvis du har:
  struct s1 v1;
  struct s2 v2;
  struct s2 v3;

Så kan du enten sende dem med 3 send:

status = send(sd, &v1, sizeof(v1), 0);
status = send(sd, &v2, sizeof(v2), 0);
status = send(sd, &v3, sizeof(v3), 0);

eller du kan pakke dem ned:

struct s { struct s1 m1;
          struct s2 m2;
          struct s3 m3; };


struct s v;
v.m1 = v1;
v.m2 = v2;
v.m3 = v3;
status = send(sd, &v, sizeof(v), 0);

eller:

char *v = malloc(sizeof(v1) + sizeof(v2) + sizeof(v3));
memcpy(v,&v1,sizeof(v1));
memcpy(v+sizeof(v1),&v2,sizeof(v2));
memcpy(v+sizeof(v1)+sizeof(v2),&v3,sizeof(v3));
status = send(sd, v, sizeof(v1) + sizeof(v2) + sizeof(v3), 0);

Tilsvarende med recv i den anden ende.

Vil du også have recv eksemplerne ?

det kunne være super lækkert!

(samme erklræringer som for send)

3 recv:

len = recv(sd, &v1, sizeof(v1), 0);
len = recv(sd, &v2, sizeof(v2), 0);
len = recv(sd, &v3, sizeof(v3), 0);

med en struct:

len = recv(sd, &v, sizeof(v), 0);
v1 = v.m1;
v2 = v.m2;
v3 = v.m3;
med char array:

char *v = malloc(sizeof(v1) + sizeof(v2) + sizeof(v3));
len = recv(sd, v, sizeof(v1) + sizeof(v2) + sizeof(v3), 0);
memcpy(&v1, v, sizeof(v1));
memcpy(&v2, v+sizeof(v1), sizeof(v2));
memcpy(&v3, v+sizeof(v1)+sizeof(v2), sizeof(v3));

Jeg håber disse skitserede eksempler giver dig
lidt ideer.

Nu kan vi til dels godt få oprettet forbindelse mellem en send og en receive. men efterfølgende ville vi også gerne kunne sende den anden vej. altså have en send funktion i den fil hvor der er en receive. Men der opstår et problem med at få programmet til at læse de nye funktioner. Det er som om at den ikke vil gå ud af den første send og receive funktion og kalde andre funktioner. Er der en logisk årsag til dette?

I kan god send og recv på den samme socket.

I skal være opmærksom på at recv default er blocking
d.v.s. at hvis der ikke er noget at læse, så venter den
indtil der kommer noget.

Så enten skal I have en helt klar protokol mellem
client og server programmet, så de ved hvornår de
skal recv og hvornår de ikke skal gøre det eller
så skal I have fat i lidt mere avancerede løsninger.

F.eks. recv non-blocking fra den socket eller have
to sockets of to tråde - den ene tråde skriver til den
ene socket og den anden tråd læser fra den anden socket.

Der er *rigtigt* mange muligheder.

Men prøv og se om ikke I kan designe kommunikationen,
så I kan undgå den slags (der er en del muligheder
for at lave fejl i den slags kode).

Selv om vi modtager noget på den første receive, er den ikke meget for at gå videre og læse næste funktion.
lille kode bid:
/*server*/
int main()
{
writeToCLient(fd);

readToClient(fd);
}

/*client*/
int main()
{
  readFromServer(fd);
  writeToServer(fd);
}
problemet er at når den har kaldt henholdvis writeToClient(fd)(i server) og readFromServer(fd) (i Client) så kan vi ikke få den til at kalde de readFromClient(fd) og writeToServer(fd).
hvad kan det skyldes? og der bliver sendt noget fra writeToClient(fd)

Det lyder lidt mystisk.

Programmer går ikke bare i stå uden grunf.

Hvordan ser readFromServer og readFromClient ud ?

Hey Arne_v. vi har fået styr på tingene nu. tak for hjælpen