Übergeben einer Struktur durch Sockets in C

Ich versuche, die gesamte Struktur vom Client zum Server oder umgekehrt zu übergeben. Nehmen wir meine Struktur wie folgt an

struct temp {
  int a;
  char b;
}

ich benutze senden an und Senden der Adresse der Strukturvariablen und Empfangen auf der anderen Seite unter Verwendung der recvfrom Funktion. Aber ich bin nicht in der Lage, die ursprünglichen Daten zu erhalten, die auf der Empfängerseite gesendet werden. In der sendto-Funktion speichere ich die empfangenen Daten in einer Variablen vom Typ struct temp.

n = sendto(sock, &pkt, sizeof(struct temp), 0, &server, length);
n = recvfrom(sock, &pkt, sizeof(struct temp), 0, (struct sockaddr *)&from,&fromlen);

Wobei pkt die Variable vom Typ struct temp ist.

Ich erhalte zwar 8 Byte Daten, aber wenn ich versuche zu drucken, werden einfach Müllwerte angezeigt. Irgendwelche Hilfe für eine Lösung?

HINWEIS: Es müssen keine Bibliotheken von Drittanbietern verwendet werden.

EDIT1: Ich bin wirklich neu in diesem Serialisierungskonzept. Aber ohne Serialisierung kann ich keine Struktur über Sockets senden?

EDIT2: Wenn ich versuche, eine Zeichenfolge oder eine Integer-Variable mit dem zu senden senden an und recvfrom funktioniert Ich erhalte die Daten auf der Empfängerseite ordnungsgemäß. Warum nicht bei einer Struktur? Wenn ich keine Serialisierungsfunktion verwenden muss, sollte ich dann jedes einzelne Mitglied der Struktur einzeln senden? Dies ist wirklich keine geeignete Lösung, denn wenn es ‘n’ Mitglieder gibt, dann werden ‘n’ Codezeilen hinzugefügt, nur um Daten zu senden oder zu empfangen.

Das ist eine sehr schlechte Idee. Binäre Daten sollten immer so gesendet werden, dass:

• Griffe anders Endianität
• Griffe anders Polsterung
• Behandelt Unterschiede in der Bytegrößen von intrinsischen Typen

Schreiben Sie niemals eine ganze Struktur binär, nicht in eine Datei, nicht in einen Socket.

Schreiben Sie jedes Feld immer separat und lesen Sie es auf die gleiche Weise.

Sie müssen Funktionen wie haben

unsigned char * serialize_int(unsigned char *buffer, int value)
{
  /* Write big-endian int value into buffer; assumes 32-bit int and 8-bit char. */
  buffer[0] = value >> 24;
  buffer[1] = value >> 16;
  buffer[2] = value >> 8;
  buffer[3] = value;
  return buffer + 4;
}

unsigned char * serialize_char(unsigned char *buffer, char value)
{
  buffer[0] = value;
  return buffer + 1;
}

unsigned char * serialize_temp(unsigned char *buffer, struct temp *value)
{
  buffer = serialize_int(buffer, value->a);
  buffer = serialize_char(buffer, value->b);
  return buffer;
}

unsigned char * deserialize_int(unsigned char *buffer, int *value);

Oder das Äquivalent, es gibt natürlich mehrere Möglichkeiten, dies in Bezug auf die Pufferverwaltung und so weiter einzurichten. Dann müssen Sie die übergeordneten Funktionen ausführen, die ganze Strukturen serialisieren/deserialisieren.

Dies setzt voraus, dass die Serialisierung zu/von Puffern erfolgt, was bedeutet, dass die Serialisierung nicht wissen muss, ob das endgültige Ziel eine Datei oder ein Socket ist. Es bedeutet auch, dass Sie etwas Speicheraufwand bezahlen, aber es ist im Allgemeinen aus Leistungsgründen ein gutes Design (Sie möchten nicht jeden Wert in den Socket schreiben).

Sobald Sie das oben Gesagte haben, können Sie wie folgt eine Strukturinstanz serialisieren und übertragen:

int send_temp(int socket, const struct sockaddr *dest, socklen_t dlen,
              const struct temp *temp)
{
  unsigned char buffer[32], *ptr;

  ptr = serialize_temp(buffer, temp);
  return sendto(socket, buffer, ptr - buffer, 0, dest, dlen) == ptr - buffer;
}

Ein paar Punkte, die zu den oben genannten Punkten zu beachten sind:

• Die zu sendende Struktur wird zuerst Feld für Feld serialisiert buffer.
• Die Serialisierungsroutine gibt einen Zeiger auf das nächste freie Byte im Puffer zurück, mit dem wir berechnen, wie viele Bytes es serialisiert hat
• Offensichtlich schützen meine Beispielserialisierungsroutinen nicht vor Pufferüberlauf.
• Der Rückgabewert ist 1, wenn die sendto() Aufruf erfolgreich, sonst 0.

Die Verwendung der Option „Pragma“ des Pakets hat mein Problem gelöst, aber ich bin mir nicht sicher, ob es irgendwelche Abhängigkeiten gibt.

#pragma pack(1)   // this helps to pack the struct to 5-bytes
struct packet {
int i;
char j;
};
#pragma pack(0)   // turn packing off

Dann funktionierten die folgenden Codezeilen ohne Probleme

n = sendto(sock,&pkt,sizeof(struct packet),0,&server,length);

n = recvfrom(sock, &pkt, sizeof(struct packet), 0, (struct sockaddr *)&from, &fromlen);

Es müssen keine eigenen Serialisierungsroutinen geschrieben werden short und long Integer-Typen – verwenden htons()/htonl() POSIX-Funktionen.

Wenn Sie den Serialisierungscode nicht selbst schreiben möchten, finden Sie ein geeignetes Serialisierungsframework und verwenden Sie dieses.

Vielleicht Googles Protokollpuffer wäre möglich?

Serialisierung ist eine gute Idee. Sie können auch verwenden Wireshark um den Datenverkehr zu überwachen und zu verstehen, was tatsächlich in den Paketen weitergegeben wird.

Anstatt zu serialisieren und von Bibliotheken von Drittanbietern abhängig zu sein, ist es einfach, ein primitives Protokoll mit Tag, Länge und Wert zu erstellen.

Tag: 32 bit value identifying the field
Length: 32 bit value specifying the length in bytes of the field
Value: the field

Verketten Sie nach Bedarf. Verwenden Sie Aufzählungen für die Tags. Und verwenden Sie die Netzwerk-Byte-Reihenfolge …

Einfach zu codieren, einfach zu decodieren.

Auch wenn Sie TCP verwenden, denken Sie daran, dass es a ist Strom von Daten, wenn Sie also zB 3 Pakete senden, werden Sie nicht unbedingt 3 Pakete empfangen. Sie können unter anderem abhängig vom Nodelay / Nagel-Algorithmus in einen Stream “zusammengeführt” werden, und Sie können sie alle in einem Recv erhalten … Sie müssen die Daten beispielsweise mit RFC1006 begrenzen.

UDP ist einfacher, Sie erhalten für jedes gesendete Paket ein eigenes Paket, aber es ist viel weniger sicher.

Wenn das Format der Daten, die Sie übertragen möchten, sehr einfach ist, dann ist die Konvertierung in und aus einer ANSI-Zeichenfolge einfach und portabel.