Zuweisung an eine member-Variable in einem struct erfolgt an einer falschen Adresse

[Frank H. (gowi)]

Hallo,
ich beschäftige mich gerade mit Sockets in C auf einem NIOS 
II-Prozessor.

Dabei habe ich das folgende Problem:

struct sockaddr {
   U16     sa_family;     /* address family */
   char     sa_data[14];      /* up to 14 bytes of direct address */
};

/* Berkeley style "Internet address" */
struct in_addr {
   U32  s_addr;
};

/* Berkeley style "Socket address" */
struct sockaddr_in {
  short    sin_family;
  U16      sin_port;
  struct   in_addr  sin_addr;
  char     sin_zero[8];
};

void setSockAddr( struct sockaddr* sockAddrStorage )
{
struct sockaddr_in * sockaddr_in;
void * a;

sockaddr_in = ( struct sockaddr_in * ) sockAddrStorage;

a = &(sockaddr_in->sin_addr.s_addr); // a zeigt dann auf 0x08177a32

sockaddr_in->sin_addr.s_addr = 0xFF;
}

Die Speicheradresse des Members sin_addr.s_addr ist 0x08177a32. Der Wert 
0xFF wird aber an die Adresse 0x8177a30 geschrieben. Der Speicher an der 
Adresse 0x8177a30 gehört aber zum Member sin_port. Hat jemand eine 
Erklärung für dieses für mich merkwürdige Verhalten?

[Andreas B. (andreas_b77)]

Merkwürdig. Ist das mit dem Debugger festgestellt? Falls ja, läuft dann 
auf dem Nios auch genau das Binary mit dem der Debugger arbeitet?

[Rufus Τ. F. (rufus)]

Die Strukturen sind nicht gepackt, sprich, zugunsten des Alignments 
werden Dummybytes zwischen die einzelnen Strukturelemente eingefügt, 
damit mit glatten 32-Bit-Zugriffen gearbeitet werden kann.

Vergleiche einfach mal das, was sizeof von Deinen Strukturdefinitionen 
hält und was Du durch Auszählen der Elemente herausbekommst.

[Jörg W. (dl8dtl) (Moderator)]

Rufus Τ. Firefly schrieb:
> Die Strukturen sind nicht gepackt

Das würde nur einen Zugriff "weiter hinten" erklären, nicht aber,
dass der Compiler eine kleinere Adresse zugreift als erwartet.

[Frank H. (gowi)]

struct sockaddr_in {
  short    sin_family;         //  2 Byte
  U16      sin_port;           //  2 Byte
  struct   in_addr  sin_addr;  //  4 Byte
  char     sin_zero[8];        //  8 Byte
};

sizeof(sockaddr_in) = 16


Es scheinen also keine Padding-bytes im struct eingefügt zu sein. Aber 
auch wenn das so sein sollte, das erklärt doch nicht, warum die 
Anweisung

sockaddr_in->sin_addr.s_addr = 0xFF;

den Wert 0xFF an die Adresse 0x08177a30 schreibt, während ich bei

a = &(sockaddr_in->sin_addr.s_addr);

für a den Wert 0x08177a32 erhalte?

[Frank H. (gowi)]

Kann dieses Problem irgendwas mit dem memory alignment zu tun haben? Mir 
ist aufgefallen, dass alles problemlos funktioniert, wenn 
sockaddr_in->sin_addr.s_addr an einer durch 4 teilbaren Adresse liegt. 
Im obigen Beispiel ist das nicht der Fall.

[Jörg W. (dl8dtl) (Moderator)]

Ja, kann, aber sofern man den Compiler nicht aktiv davon abhält,
sollte er sich um das notwendige alignment eigentlich selbst kümmern.

[Udo S. (urschmitt)]

Frank Hans schrieb:
> Kann dieses Problem irgendwas mit dem memory alignment zu tun haben?
Das hat Rufus ja schon gesagt aber wie Jörg dann gesagt hat würde das 
nur einen Zugriff an einer größeren Speicherstelle erklären, nicht aber 
weiter vorne.
Irgendwas übersehen wir da noch oder da wäre wirklich ein 
Compilerfehler.
Aber das glaube ich erst ganz zum Schluss.

[Udo S. (urschmitt)]

Blöde Idee:
Was passiert wenn du statt 0xff den Wert 0x11224488 reinschreibst.
Wo steht dann welches Byte?

[Frank H. (gowi)]

Eventuell komme ich einer Antwort näher. Es ist wohl so, dass der NIOS 
auf 4-Byte Daten nur zugreifen kann, wenn die Adresse ein Vielfaches von 
4 ist (data-misalignment wird nicht unterstützt).

Das obige Beispiel war nicht ganz vollständig. Es müsste lauten:

typedef struct al_sockaddr
{
    uint8_t         sa_data[16];
} al_sockaddr_t

struct sockaddr {
   U16     sa_family;     /* address family */
   char     sa_data[14];      /* up to 14 bytes of direct address */
};

/* Berkeley style "Internet address" */
struct in_addr {
   U32  s_addr;
};

/* Berkeley style "Socket address" */
struct sockaddr_in {
  short    sin_family;
  U16      sin_port;
  struct   in_addr  sin_addr;
  char     sin_zero[8];
};

void setSockAddr( al_sockaddr_t* sockAddrStorage )
{
struct sockaddr_in * sockaddr_in;
void * a;

sockaddr_in = ( struct sockaddr_in * ) sockAddrStorage;

a = &(sockaddr_in->sin_addr.s_addr); // a zeigt dann auf 0x08177a32

sockaddr_in->sin_addr.s_addr = 0xFF;
}

Meine Vermutung: sockAddrStorage ist Byte-Aligned - kann also 
prinzipiell an jeder Speicheradresse stehen. sockaddr_in muss aber 
4-Byte-Aligned sein, damit die Member entsprechend auch richtig aligned 
sind. Durch das Casten nimmt sockaddr_in aber das Alignment von 
sockAddrStorage an und daher kann u.U. das Alignment nicht mehr stimmen. 
Sehe ich das so richtig?

[Uli T. (avaron)]

sockAddrStorage ist mal nur ein Pointer, der kann auf alles zeigen, also 
Byte-Aligned.
sockaddr_in muß 4-Byte alligned liegen, wenn Du 4-Byte zugriffe machst.

*((unit8_t*)&(sockaddr_in->sin_addr.s_addr)) = 0xFF;

sollte eigentlich auch gehen...

[Johann L. (gjlayde)]

Welche Endianess hat das Ding denn?

[Frank H. (gowi)]

Johann L. schrieb:
> Welche Endianess hat das Ding denn?

Little Endian. Die notwendigen htonl()-Funktionen usw. kommen noch.

[Rolf M. (rmagnus)]

Frank Hans schrieb:
> Meine Vermutung: sockAddrStorage ist Byte-Aligned - kann also
> prinzipiell an jeder Speicheradresse stehen. sockaddr_in muss aber
> 4-Byte-Aligned sein, damit die Member entsprechend auch richtig aligned
> sind. Durch das Casten nimmt sockaddr_in aber das Alignment von
> sockAddrStorage an und daher kann u.U. das Alignment nicht mehr stimmen.
> Sehe ich das so richtig?

Kann im Prinzip sein. Die Frage bleibt, warum sockAddrStorage ein 
falsches Alignment hat. Das passiert normalerweise nicht, weil sich, wie 
schon geschrieben wurde, der Compiler eigentlich selbst um das korrekte 
Algiment kümmert, wenn man nicht noch irgendwelche "Schweiereien" 
einbaut, die das verhindern. Wo kommt denn die Struktur her und wie wird 
sie erzeugt?

[Frank H. (gowi)]

> Kann im Prinzip sein. Die Frage bleibt, warum sockAddrStorage ein
> falsches Alignment hat. Das passiert normalerweise nicht, weil sich, wie
> schon geschrieben wurde, der Compiler eigentlich selbst um das korrekte
> Algiment kümmert, wenn man nicht noch irgendwelche "Schweiereien"
> einbaut, die das verhindern. Wo kommt denn die Struktur her und wie wird
> sie erzeugt?

sockAddrStorage ist vom Typ al_sockaddr_t:

typedef struct al_sockaddr
{
    uint8_t         sa_data[16];
} al_sockaddr_t

[Frank H. (gowi)]

Gelöst habe ich das Problem erstmal, indem ich das Alignment von 
al_sockaddr_t manuell vorgebe:

typedef struct al_sockaddr
{
    uint8_t         sa_data[16];
} al_sockaddr_t __attribute__ ((aligned (4)));

Ich frage mich aber, ob ich nicht eine Compiler-Warnung aufgrund des 
nicht übereinstimmenden Alignments beim Casten erhalten müsste.

[Uli T. (avaron)]

Der Compiler weiß zur compile time nicht wie das was Du castest alligned 
ist, wie soll er da warnen?

[Frank H. (gowi)]

Uli Trautenberg schrieb:
> Der Compiler weiß zur compile time nicht wie das was Du castest alligned
> ist, wie soll er da warnen?

Hmm. Beim Kompilieren müsste doch feststehen, dass

struct sockaddr_in {
  short    sin_family;
  U16      sin_port;
  struct   in_addr  sin_addr;
  char     sin_zero[8];
};

4-Byte-aligned ist, während

typedef struct al_sockaddr
{
    uint8_t         sa_data[16];
} al_sockaddr_t

 Byte-aligned ist.

D.h. es könnte doch eigentlich prinzipiell festgestellt werden, dass es 
beim Casten

sockaddr_in = ( struct sockaddr_in * ) sockAddrStorage;

 zu Problemen kommen könnte.

[Rolf M. (rmagnus)]

Frank Hans schrieb:
> sockAddrStorage ist vom Typ al_sockaddr_t:
> typedef struct al_sockaddr
> {
>     uint8_t         sa_data[16];
> } al_sockaddr_t

Ach das sehe ich jetzt erst. Dann ist das logisch. Warum ist das denn so 
definiert?

Frank Hans schrieb:
> Byte-aligned ist.
>
> D.h. es könnte doch eigentlich prinzipiell festgestellt werden, dass es
> beim Castensockaddr_in = ( struct sockaddr_in * ) sockAddrStorage; zu
> Problemen kommen könnte.

Das ist die Sache mit Casts in C. Mit einem Cast sagst du deinem 
Compiler soviel wie: "Auch wenn das deiner Meinung nach nicht paßt, 
mach's trotzdem so. Ich weiß, was ich tue!". Und dann ist der Compiler 
eben still.

[Jörg W. (dl8dtl) (Moderator)]

Rolf Magnus schrieb:
> Mit einem Cast sagst du deinem
> Compiler soviel wie: "Auch wenn das deiner Meinung nach nicht paßt,
> mach's trotzdem so. Ich weiß, was ich tue!".

Das ist genau das, was ich weiter oben gemeint habe mit "sofern man
den Compiler nicht aktiv davon abhält".  Wenn man den Speicherplatz
natürlich für Bytes anfordert, dann aber auf eine Socket-Adresse
"umwidmet", dann muss man sich nicht weiter wundern.

[Frank H. (gowi)]

Rolf Magnus schrieb:
> Frank Hans schrieb:
>> sockAddrStorage ist vom Typ al_sockaddr_t:
>> typedef struct al_sockaddr
>> {
>>     uint8_t         sa_data[16];
>> } al_sockaddr_t
>
> Ach das sehe ich jetzt erst. Dann ist das logisch. Warum ist das denn so
> definiert?

Die Definiton kommt aus dem DPWS-Stack (Device Profile for Web 
Services), den ich benutze. Dort sollte die Definiton wohl möglichst 
allgemein gehalten werden.

[(prx) A. K. (prx)]

Rolf Magnus schrieb:

> Kann im Prinzip sein. Die Frage bleibt, warum sockAddrStorage ein
> falsches Alignment hat. Das passiert normalerweise nicht,

Das passiert ganz von allein, wenn der Kram in einem korrekt alignten 
Ethernet Frame sitzt, dessen Header aber leider 14 Bytes lang ist. 
Schlauköpfe sorgen deshalb dafür, dass der Puffer vom Frame passend 
misaligned im Speicher liegt, also an (addr % 4) == 2.