* OLSR-Autodetect probe packets are UDP - port 51698 */
/* Check if UDP */
- ipHeader = (struct ip *)ipPacket;
+ ipHeader = (struct ip *)(ARM_NOWARN_ALIGN)ipPacket;
if (ipHeader->ip_p != SOL_UDP) {
/* Not UDP */
return 0;
}
/* Go into the UDP header and check port number */
- udpHeader = (struct udphdr *)(ipPacket + ipHeaderLen);
+ udpHeader = (struct udphdr *)(ARM_NOWARN_ALIGN)(ipPacket + ipHeaderLen);
destPort = ntohs(udpHeader->dest);
if (destPort == olsr_cnf->olsrport || destPort == BMF_ENCAP_PORT || destPort == 51698)
/* if (pktAddr.sll_pkttype ...) */
/* Check if the received packet is UDP - BMF port */
- ipHeader = (struct ip *)rxBuffer;
+ ipHeader = (struct ip *)(ARM_NOWARN_ALIGN)rxBuffer;
if (ipHeader->ip_p != SOL_UDP) {
/* Not UDP */
continue; /* for */
}
- udpHeader = (struct udphdr *)(rxBuffer + GetIpHeaderLength(rxBuffer));
+ udpHeader = (struct udphdr *)(ARM_NOWARN_ALIGN)(rxBuffer + GetIpHeaderLength(rxBuffer));
destPort = ntohs(udpHeader->dest);
if (destPort != BMF_ENCAP_PORT) {
/* Not BMF */
EtherTunTapIp = ETHERTUNTAPDEFAULTIP;
}
- ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr = htonl(EtherTunTapIp);
+ ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifreq.ifr_addr)->sin_addr.s_addr = htonl(EtherTunTapIp);
ioctlres = ioctl(ioctlSkfd, SIOCSIFADDR, &ifreq);
if (ioctlres >= 0) {
/* Set net mask */
- ((struct sockaddr_in *)&ifreq.ifr_netmask)->sin_addr.s_addr = htonl(EtherTunTapIpMask);
+ ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifreq.ifr_netmask)->sin_addr.s_addr = htonl(EtherTunTapIpMask);
ioctlres = ioctl(ioctlSkfd, SIOCSIFNETMASK, &ifreq);
if (ioctlres >= 0) {
/* Set broadcast IP */
- ((struct sockaddr_in *)&ifreq.ifr_broadaddr)->sin_addr.s_addr = htonl(EtherTunTapIpBroadcast);
+ ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifreq.ifr_broadaddr)->sin_addr.s_addr = htonl(EtherTunTapIpBroadcast);
ioctlres = ioctl(ioctlSkfd, SIOCSIFBRDADDR, &ifreq);
if (ioctlres >= 0) {
/* Bring EtherTunTap interface up (if not already) */
newIf->intAddr.v4.s_addr = inet_addr("0.0.0.0");
} else {
/* Downcast to correct sockaddr subtype */
- newIf->intAddr.v4 = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr;
+ newIf->intAddr.v4 = ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifr.ifr_addr)->sin_addr;
}
/* For a non-OLSR interface, retrieve the IP broadcast address ourselves */
newIf->broadAddr.v4.s_addr = inet_addr("0.0.0.0");
} else {
/* Downcast to correct sockaddr subtype */
- newIf->broadAddr.v4 = ((struct sockaddr_in *)&ifr.ifr_broadaddr)->sin_addr;
+ newIf->broadAddr.v4 = ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifr.ifr_broadaddr)->sin_addr;
}
}
}
/* ...find the OLSR interface structure, if any */
- ipAddr.v4 = ((struct sockaddr_in *)&ifr->ifr_addr)->sin_addr;
+ ipAddr.v4 = ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifr->ifr_addr)->sin_addr;
olsrIntf = if_ifwithaddr(&ipAddr);
if (skipThisIntf != NULL && olsrIntf == skipThisIntf) {
assert(ipPacket != NULL && broadAddr != NULL);
- iph = (struct iphdr *)ipPacket;
+ iph = (struct iphdr *)(ARM_NOWARN_ALIGN)ipPacket;
destIp.v4.s_addr = iph->daddr;
if (!IsMulticast(&destIp)) {
u_int32_t origDaddr, newDaddr;
/* Re-calculate UDP/IP checksum for new destination */
int ipHeaderLen = GetIpHeaderLength(ipPacket);
- struct udphdr *udph = (struct udphdr *)(ipPacket + ipHeaderLen);
+ struct udphdr *udph = (struct udphdr *)(ARM_NOWARN_ALIGN)(ipPacket + ipHeaderLen);
/* RFC 1624, Eq. 3: HC' = ~(~HC - m + m') */
memset(&kernel_route, 0, sizeof(struct rtentry));
- ((struct sockaddr_in *)&kernel_route.rt_dst)->sin_family = AF_INET;
- ((struct sockaddr_in *)&kernel_route.rt_gateway)->sin_family = AF_INET;
- ((struct sockaddr_in *)&kernel_route.rt_genmask)->sin_family = AF_INET;
+ ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&kernel_route.rt_dst)->sin_family = AF_INET;
+ ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&kernel_route.rt_gateway)->sin_family = AF_INET;
+ ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&kernel_route.rt_genmask)->sin_family = AF_INET;
/* 224.0.0.0/4 */
- ((struct sockaddr_in *)&kernel_route.rt_dst)->sin_addr.s_addr = htonl(0xE0000000);
- ((struct sockaddr_in *)&kernel_route.rt_genmask)->sin_addr.s_addr = htonl(0xF0000000);
+ ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&kernel_route.rt_dst)->sin_addr.s_addr = htonl(0xE0000000);
+ ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&kernel_route.rt_genmask)->sin_addr.s_addr = htonl(0xF0000000);
kernel_route.rt_metric = 0;
kernel_route.rt_flags = RTF_UP;
memset(&kernel_route, 0, sizeof(struct rtentry));
- ((struct sockaddr_in *)&kernel_route.rt_dst)->sin_family = AF_INET;
- ((struct sockaddr_in *)&kernel_route.rt_gateway)->sin_family = AF_INET;
- ((struct sockaddr_in *)&kernel_route.rt_genmask)->sin_family = AF_INET;
+ ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&kernel_route.rt_dst)->sin_family = AF_INET;
+ ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&kernel_route.rt_gateway)->sin_family = AF_INET;
+ ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&kernel_route.rt_genmask)->sin_family = AF_INET;
/* 224.0.0.0/4 */
- ((struct sockaddr_in *)&kernel_route.rt_dst)->sin_addr.s_addr = htonl(0xE0000000);
- ((struct sockaddr_in *)&kernel_route.rt_genmask)->sin_addr.s_addr = htonl(0xF0000000);
+ ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&kernel_route.rt_dst)->sin_addr.s_addr = htonl(0xE0000000);
+ ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&kernel_route.rt_genmask)->sin_addr.s_addr = htonl(0xF0000000);
kernel_route.rt_metric = 0;
kernel_route.rt_flags = RTF_UP;
#include <netinet/in.h> /* ntohs(), htons() */
#include <netinet/ip.h> /* struct iphdr */
+#include "defs.h" /* ARM_NOWARN_ALIGN */
+
/* -------------------------------------------------------------------------
* Function : IsIpFragment
* Description: Check if an IP packet is an IP fragment
assert(ipPacket != NULL);
- iph = (struct ip *)ipPacket;
+ iph = (struct ip *)(ARM_NOWARN_ALIGN)ipPacket;
if ((ntohs(iph->ip_off) & IP_OFFMASK) != 0) {
return 1;
}
assert(ipPacket != NULL);
- iph = (struct iphdr *)ipPacket;
+ iph = (struct iphdr *)(ARM_NOWARN_ALIGN)ipPacket;
return ntohs(iph->tot_len);
} /* GetIpTotalLength */
assert(ipPacket != NULL);
- iph = (struct iphdr *)ipPacket;
+ iph = (struct iphdr *)(ARM_NOWARN_ALIGN)ipPacket;
return iph->ihl << 2;
} /* GetIpHeaderLength */
assert(ipPacket != NULL);
- iph = (struct iphdr *)ipPacket;
+ iph = (struct iphdr *)(ARM_NOWARN_ALIGN)ipPacket;
return iph->ttl;
} /* GetTtl */
assert(ipPacket != NULL && sttl != NULL);
- iph = (struct iphdr *)ipPacket;
+ iph = (struct iphdr *)(ARM_NOWARN_ALIGN)ipPacket;
sttl->ttl = iph->ttl;
sttl->check = ntohs(iph->check);
} /* SaveTtlAndChecksum */
assert(ipPacket != NULL && sttl != NULL);
- iph = (struct iphdr *)ipPacket;
+ iph = (struct iphdr *)(ARM_NOWARN_ALIGN)ipPacket;
iph->ttl = sttl->ttl;
iph->check = htons(sttl->check);
} /* RestoreTtlAndChecksum */
assert(ipPacket != NULL);
- iph = (struct iphdr *)ipPacket;
+ iph = (struct iphdr *)(ARM_NOWARN_ALIGN)ipPacket;
iph->ttl--; /* decrement ttl */
sum = ntohs(iph->check) + 0x100; /* increment checksum high byte */
struct ip *
GetIpHeader(unsigned char *encapsulationUdpData)
{
- return (struct ip *)(encapsulationUdpData + ENCAP_HDR_LEN);
+ return (struct ip *)(ARM_NOWARN_ALIGN)(encapsulationUdpData + ENCAP_HDR_LEN);
} /* GetIpHeader */
/* -------------------------------------------------------------------------
SaveTtlAndChecksum(ipPacket, &sttl);
- ipHeader = (struct ip *)ipPacket;
+ ipHeader = (struct ip *)(ARM_NOWARN_ALIGN)ipPacket;
ipHeader->ip_ttl = 0xFF; /* fixed value of TTL for CRC-32 calculation */
ipHeader->ip_sum = 0x5A5A; /* fixed value of IP header checksum for CRC-32 calculation */
message->v4.hopcnt = 0;
message->v4.seqno = htons(get_msg_seqno());
- namesize = encap_namemsg((struct namemsg *)&message->v4.message);
+ namesize = encap_namemsg((struct namemsg *)(ARM_NOWARN_ALIGN)&message->v4.message);
namesize = namesize + sizeof(struct olsrmsg);
message->v4.olsr_msgsize = htons(namesize);
message->v6.hopcnt = 0;
message->v6.seqno = htons(get_msg_seqno());
- namesize = encap_namemsg((struct namemsg *)&message->v6.message);
+ namesize = encap_namemsg((struct namemsg *)(ARM_NOWARN_ALIGN)&message->v6.message);
namesize = namesize + sizeof(struct olsrmsg6);
message->v6.olsr_msgsize = htons(namesize);
if (olsr_cnf->ip_version == AF_INET) {
vtime = me_to_reltime(m->v4.olsr_vtime);
size = ntohs(m->v4.olsr_msgsize);
- namemessage = (struct namemsg *)&m->v4.message;
+ namemessage = (struct namemsg *)(ARM_NOWARN_ALIGN)&m->v4.message;
} else {
vtime = me_to_reltime(m->v6.olsr_vtime);
size = ntohs(m->v6.olsr_msgsize);
- namemessage = (struct namemsg *)&m->v6.message;
+ namemessage = (struct namemsg *)(ARM_NOWARN_ALIGN)&m->v6.message;
}
/* Check if message originated from this node.
// names
for (my_name = my_names; my_name != NULL; my_name = my_name->next) {
- pos = create_packet((struct name *)pos, my_name);
+ pos = create_packet((struct name *)(ARM_NOWARN_ALIGN)pos, my_name);
i++;
}
// forwarders
for (my_name = my_forwarders; my_name != NULL; my_name = my_name->next) {
- pos = create_packet((struct name *)pos, my_name);
+ pos = create_packet((struct name *)(ARM_NOWARN_ALIGN)pos, my_name);
i++;
}
// services
for (my_name = my_services; my_name != NULL; my_name = my_name->next) {
- pos = create_packet((struct name *)pos, my_name);
+ pos = create_packet((struct name *)(ARM_NOWARN_ALIGN)pos, my_name);
i++;
}
// macs
for (my_name = my_macs; my_name != NULL; my_name = my_name->next) {
- pos = create_packet((struct name *)pos, my_name);
+ pos = create_packet((struct name *)(ARM_NOWARN_ALIGN)pos, my_name);
i++;
}
// latlon
e.type = NAME_LATLON;
e.name = s;
lookup_defhna_latlon(&e.ip);
- pos = create_packet((struct name *)pos, &e);
+ pos = create_packet((struct name *)(ARM_NOWARN_ALIGN)pos, &e);
i++;
}
// write the namemsg header with the number of announced entries and the protocol version
end_pos = pos + msg_size - sizeof(struct name *); // at least one struct name has to be left
for (i = ntohs(msg->nr_names); i > 0 && pos < end_pos; i--) {
- from_packet = (struct name *)pos;
+ from_packet = (struct name *)(ARM_NOWARN_ALIGN)pos;
switch (ntohs(from_packet->type)) {
case NAME_HOST:
olsr_printf(2, "[ENC]Adding signature for packet size %d\n", *size);
fflush(stdout);
- msg = (struct s_olsrmsg *)&pck[*size];
+ msg = (struct s_olsrmsg *)(ARM_NOWARN_ALIGN)&pck[*size];
/* Update size */
((struct olsr *)pck)->olsr_packlen = htons(*size + sizeof(struct s_olsrmsg));
if (packetsize < 4)
return 0;
- sig = (const struct s_olsrmsg *)&pck[packetsize];
+ sig = (const struct s_olsrmsg *)(const ARM_NOWARN_ALIGN)&pck[packetsize];
//olsr_printf(1, "Size: %d\n", packetsize);
struct stamp *entry;
struct ipaddr_str buf;
- msg = (struct c_respmsg *)in_msg;
+ msg = (struct c_respmsg *)(ARM_NOWARN_ALIGN)in_msg;
olsr_printf(1, "[ENC]Challenge-response message received\n");
olsr_printf(3, "[ENC]To: %s\n", olsr_ip_to_string(&buf, (union olsr_ip_addr *)&msg->destination));
struct stamp *entry;
struct ipaddr_str buf;
- msg = (struct r_respmsg *)in_msg;
+ msg = (struct r_respmsg *)(ARM_NOWARN_ALIGN)in_msg;
olsr_printf(1, "[ENC]Response-response message received\n");
olsr_printf(3, "[ENC]To: %s\n", olsr_ip_to_string(&buf, (union olsr_ip_addr *)&msg->destination));
uint32_t hash;
struct ipaddr_str buf;
- msg = (struct challengemsg *)in_msg;
+ msg = (struct challengemsg *)(ARM_NOWARN_ALIGN)in_msg;
olsr_printf(1, "[ENC]Challenge message received\n");
olsr_printf(3, "[ENC]To: %s\n", olsr_ip_to_string(&buf, (union olsr_ip_addr *)&msg->destination));
#include "lstate.h"
#include "lzio.h"
+#include "defs.h" /* ARM_NOWARN_ALIGN */
+
/*
** macro to control inclusion of some hard tests on stack reallocation
*/
#define incr_top(L) {luaD_checkstack(L,1); L->top++;}
#define savestack(L,p) ((char *)(p) - (char *)L->stack)
-#define restorestack(L,n) ((TObject *)((char *)L->stack + (n)))
+#define restorestack(L,n) ((TObject *)(ARM_NOWARN_ALIGN)((char *)L->stack + (n)))
#define saveci(L,p) ((char *)(p) - (char *)L->base_ci)
-#define restoreci(L,n) ((CallInfo *)((char *)L->base_ci + (n)))
+#define restoreci(L,n) ((CallInfo *)(ARM_NOWARN_ALIGN)((char *)L->base_ci + (n)))
/* type of protected functions, to be ran by `runprotected' */
typedef void (*Pfunc) (lua_State * L, void *ud);
#include <stddef.h>
#include "lua.h"
+#include "defs.h" /* ARM_NOWARN_ALIGN */
/*
** try to find number of bits in an integer
#define cast(t, exp) ((t)(exp))
#endif
+#ifndef cast_align
+#define cast_align(t, exp) ((t)(ARM_NOWARN_ALIGN)(exp))
+#endif
+
/*
** type for virtual-machine instructions
** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
#define sethvalue(obj,x) \
{ TObject *i_o=(obj); i_o->tt=LUA_TTABLE; \
- i_o->value.gc=cast(GCObject *, (x)); \
+ i_o->value.gc=cast_align(GCObject *, (x)); \
lua_assert(i_o->value.gc->gch.tt == LUA_TTABLE); }
#define setnilvalue(obj) ((obj)->tt=LUA_TNIL)
return NULL;
else {
block += EXTRASPACE;
- return cast(lua_State *, block);
+ return cast_align(lua_State *, block);
}
}
#define gcototh(o) check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th))
/* macro to convert any value into a GCObject */
-#define valtogco(v) (cast(GCObject *, (v)))
+#define valtogco(v) (cast_align(GCObject *, (v)))
lua_State *luaE_newthread(lua_State * L);
void luaE_freethread(lua_State * L, lua_State * L1);
#include "http.h"
#include "glua.h"
#include "glua_ext.h"
+#include "defs.h" /* ARM_NOWARN_ALIGN */
#include <sys/types.h>
#include <sys/socket.h>
memset(sockAddr, 0, sizeof(struct sockaddr));
if (addr->domain == PF_INET) {
- sockAddr4 = (struct sockaddr_in *)sockAddr;
+ sockAddr4 = (struct sockaddr_in *)(ARM_NOWARN_ALIGN)sockAddr;
sockAddr4->sin_family = AF_INET;
sockAddr4->sin_port = htons((short)port);
}
if (addr->domain == PF_INET6) {
- sockAddr6 = (struct sockaddr_in6 *)sockAddr;
+ sockAddr6 = (struct sockaddr_in6 *)(ARM_NOWARN_ALIGN)sockAddr;
sockAddr6->sin6_family = AF_INET6;
sockAddr6->sin6_port = htons((short)port);
static int
addrFromSockAddr(struct ipAddr *addr, const struct sockaddr *sockAddr)
{
- const struct sockaddr_in *sockAddr4 = (const struct sockaddr_in *)sockAddr;
- const struct sockaddr_in6 *sockAddr6 = (const struct sockaddr_in6 *)sockAddr;
+ const struct sockaddr_in *sockAddr4 = (const struct sockaddr_in *)(const ARM_NOWARN_ALIGN)sockAddr;
+ const struct sockaddr_in6 *sockAddr6 = (const struct sockaddr_in6 *)(const ARM_NOWARN_ALIGN)sockAddr;
memset(addr, 0, sizeof(struct ipAddr));
parserFunc(union olsr_message *msg, struct interface *inInt __attribute__ ((unused)), union olsr_ip_addr *neighIntAddr)
{
char *mess = (char *)msg;
- union olsr_ip_addr *orig = (union olsr_ip_addr *)(mess + 4);
+ union olsr_ip_addr *orig = (union olsr_ip_addr *)(ARM_NOWARN_ALIGN)(mess + 4);
int len = (mess[2] << 8) | mess[3];
char *service, *string;
int i;
*haddr = nb->address;
/* Point to next address */
- haddr = (union olsr_ip_addr *)&haddr->v6.s6_addr[4];
+ haddr += sizeof(haddr->v4);
curr_size += olsr_cnf->ipsize; /* IP address added */
first_entry = false;
{\
return( \
ptr ? \
- (structname *) (((uint8_t *) ptr) - offsetof(structname, avlnodename)) : \
+ (structname *) (((size_t) ptr) - offsetof(structname, avlnodename)) : \
NULL); \
}
#define INLINE inline __attribute__((always_inline))
+/*
+ * On ARM, the compiler spits out additional warnings if called
+ * with -Wcast-align if you cast e.g. char* -> int*. While this
+ * is fine, most of that warnings are un-critical. Also the ARM
+ * CPU will throw BUS_ERROR if alignment does not fit. For this,
+ * we add an additional cast to (void *) to prevent the warning.
+ */
+#define ARM_NOWARN_ALIGN void *
+
/*
* A somewhat safe version of strncpy and strncat. Note, that
* BSD/Solaris strlcpy()/strlcat() differ in implementation, while
prefix += 8;
break; /* Shouldn't happen */
default:
- OLSR_PRINTF(0, "%s: Got bogus netmask %s\n", __func__, olsr_ip_to_string(&buf, (const union olsr_ip_addr *)adr));
+ OLSR_PRINTF(0, "%s: Got bogus netmask %s\n", __func__, olsr_ip_to_string(&buf, (const union olsr_ip_addr *)(const void *)adr));
prefix = UCHAR_MAX;
break;
}
}
#ifdef DEBUG
- OLSR_PRINTF(3, "Netmask: %s = Prefix %d\n", olsr_ip_to_string(&buf, (const union olsr_ip_addr *)adr), prefix);
+ OLSR_PRINTF(3, "Netmask: %s = Prefix %d\n", olsr_ip_to_string(&buf, (const union olsr_ip_addr *)(const void *)adr), prefix);
#endif
return prefix;
}
static INLINE const char *
sockaddr4_to_string(struct ipaddr_str *const buf, const struct sockaddr *const addr)
{
- const struct sockaddr_in *const addr4 = (const struct sockaddr_in *)addr;
- return ip4_to_string(buf, addr4->sin_addr);
+ union {
+ const struct sockaddr *a_sockaddr;
+ const struct sockaddr_in *a_sockaddr_in;
+ } nowarn;
+ nowarn.a_sockaddr = addr;
+ return ip4_to_string(buf, nowarn.a_sockaddr_in->sin_addr);
}
/* we need to handle one value specifically since shifting 32 bits of a 32 bit integer is the same as shifting 0 bits.
static void
olsr_netlink_addreq(struct olsr_rtreq *req, int type, const void *data, int len)
{
- struct rtattr *rta = (struct rtattr *)(((char *)req) + NLMSG_ALIGN(req->n.nlmsg_len));
+ struct rtattr *rta = (struct rtattr *)(ARM_NOWARN_ALIGN)(((char *)req) + NLMSG_ALIGN(req->n.nlmsg_len));
req->n.nlmsg_len = NLMSG_ALIGN(req->n.nlmsg_len) + RTA_LENGTH(len);
assert(req->n.nlmsg_len < sizeof(struct olsr_rtreq));
rta->rta_type = type;
iov.iov_base = req.buf;
iov.iov_len = sizeof(req.buf);
if (0 < (ret = recvmsg(olsr_cnf->rtnl_s, &msg, 0))) {
- struct nlmsghdr *h = (struct nlmsghdr *)req.buf;
+ struct nlmsghdr *h = (struct nlmsghdr *)(ARM_NOWARN_ALIGN)req.buf;
while (NLMSG_OK(h, (unsigned int)ret)) {
if (NLMSG_DONE == h->nlmsg_type) {
/* seems to reached never */
olsr_syslog(OLSR_LOG_INFO,"_received %u Byte rtnetlink response of type %u with seqnr %u and flags %u from %u (%u)",
h->nlmsg_len, h->nlmsg_type, h->nlmsg_seq, h->nlmsg_flags, h->nlmsg_pid, NLMSG_ERROR);
}
- h = NLMSG_NEXT(h, ret);
+/*
+ * The ARM compile complains about alignment. Copied
+ * from /usr/include/linux/netlink.h and adapted for ARM
+ */
+#define MY_NLMSG_NEXT(nlh,len) ((len) -= NLMSG_ALIGN((nlh)->nlmsg_len), \
+ (struct nlmsghdr*)(ARM_NOWARN_ALIGN)(((char*)(nlh)) + NLMSG_ALIGN((nlh)->nlmsg_len)))
+ h = MY_NLMSG_NEXT(h, ret);
}
}
}
bool lq_tc_pending = false;
static uint32_t msg_buffer_aligned[(MAXMESSAGESIZE - OLSR_HEADERSIZE) / sizeof(uint32_t) + 1];
-static unsigned char *msg_buffer = (unsigned char *)msg_buffer_aligned;
+static unsigned char *const msg_buffer = (unsigned char *)msg_buffer_aligned;
static void
create_lq_hello(struct lq_hello_message *lq_hello, struct interface *outif)
{
if (olsr_cnf->ip_version == AF_INET) {
// serialize an IPv4 OLSR message header
- struct olsr_header_v4 *olsr_head_v4 = (struct olsr_header_v4 *)msg_buffer;
+ struct olsr_header_v4 *olsr_head_v4 = (struct olsr_header_v4 *)(ARM_NOWARN_ALIGN)msg_buffer;
olsr_head_v4->type = comm->type;
olsr_head_v4->vtime = reltime_to_me(comm->vtime);
olsr_head_v4->seqno = htons(get_msg_seqno());
} else {
// serialize an IPv6 OLSR message header
- struct olsr_header_v6 *olsr_head_v6 = (struct olsr_header_v6 *)msg_buffer;
+ struct olsr_header_v6 *olsr_head_v6 = (struct olsr_header_v6 *)(ARM_NOWARN_ALIGN)msg_buffer;
olsr_head_v6->type = comm->type;
olsr_head_v6->vtime = reltime_to_me(comm->vtime);
// initialize the LQ_HELLO header
- struct lq_hello_header *head = (struct lq_hello_header *)(msg_buffer + off);
+ struct lq_hello_header *head = (struct lq_hello_header *)(ARM_NOWARN_ALIGN)(msg_buffer + off);
head->reserved = 0;
head->htime = reltime_to_me(lq_hello->htime);
// create a new info header
if (is_first) {
- info_head = (struct lq_hello_info_header *)(buff + size);
+ info_head = (struct lq_hello_info_header *)(ARM_NOWARN_ALIGN)(buff + size);
size += sizeof(struct lq_hello_info_header);
info_head->reserved = 0;
// initialize the LQ_TC header
- head = (struct lq_tc_header *)(msg_buffer + off);
+ head = (struct lq_tc_header *)(ARM_NOWARN_ALIGN)(msg_buffer + off);
head->ansn = htons(lq_tc->ansn);
head->lower_border = 0;
genipcopy(buff + size, &neigh->address);
// remember last ip
- last_ip = (union olsr_ip_addr *)(buff + size);
+ last_ip = (union olsr_ip_addr *)(ARM_NOWARN_ALIGN)(buff + size);
size += olsr_cnf->ipsize;
static INLINE void
pkt_put_u8(uint8_t ** p, uint8_t var)
{
- *(uint8_t *) (*p) = var;
+ **((uint8_t **)p) = var;
*p += sizeof(uint8_t);
}
static INLINE void
pkt_put_u16(uint8_t ** p, uint16_t var)
{
- *(uint16_t *) (*p) = htons(var);
+ **((uint16_t **)p) = htons(var);
*p += sizeof(uint16_t);
}
static INLINE void
pkt_put_u32(uint8_t ** p, uint32_t var)
{
- *(uint32_t *) (*p) = htonl(var);
+ **((uint32_t **)p) = htonl(var);
*p += sizeof(uint32_t);
}
static INLINE void
pkt_put_s8(uint8_t ** p, int8_t var)
{
- *(int8_t *) (*p) = var;
+ **((int8_t **)p) = var;
*p += sizeof(int8_t);
}
static INLINE void
pkt_put_s16(uint8_t ** p, int16_t var)
{
- *(int16_t *) (*p) = htons(var);
+ **((int16_t **)p) = htons(var);
*p += sizeof(int16_t);
}
static INLINE void
pkt_put_s32(uint8_t ** p, int32_t var)
{
- *(int32_t *) (*p) = htonl(var);
+ **((int32_t **)p) = htonl(var);
*p += sizeof(int32_t);
}
static INLINE void
* indicating presence of a cookie. This will be checked against
* When the block is freed to detect corruption.
*/
- branding = (struct olsr_cookie_mem_brand *)((unsigned char *)ptr + ci->ci_size);
+ branding = (struct olsr_cookie_mem_brand *)(ARM_NOWARN_ALIGN)((unsigned char *)ptr + ci->ci_size);
memcpy(&branding->cmb_sig, "cookie", 6);
branding->cmb_id = ci->ci_id;
struct list_node *free_list_node;
bool reuse = false;
- branding = (struct olsr_cookie_mem_brand *)((unsigned char *)ptr + ci->ci_size);
+ branding = (struct olsr_cookie_mem_brand *)(ARM_NOWARN_ALIGN)((unsigned char *)ptr + ci->ci_size);
/*
* Verify if there has been a memory overrun, or
olsr_status_to_string(EXTRACT_STATUS(hinf->link_code)), ntohs(hinf->size));
for (haddr = (union olsr_ip_addr *)&hinf->neigh_addr; (char *)haddr < (char *)hinf + ntohs(hinf->size);
- haddr = (union olsr_ip_addr *)&haddr->v6.s6_addr[4]) {
+ haddr += sizeof(haddr->v4)) {
struct ipaddr_str buf;
fprintf(handle, " ++ %s\n", olsr_ip_to_string(&buf, haddr));
}
olsr_status_to_string(EXTRACT_STATUS(hinf->link_code)), ntohs(hinf->size));
for (haddr = (union olsr_ip_addr *)&hinf->neigh_addr; (char *)haddr < (char *)hinf + ntohs(hinf->size);
- haddr = (union olsr_ip_addr *)&haddr->v6.s6_addr[8]) {
+ haddr += sizeof(haddr->v4)) {
struct ipaddr_str buf;
uint8_t *quality = (uint8_t *) haddr + olsr_cnf->ipsize;
fprintf(handle, " ++ %s\n", olsr_ip_to_string(&buf, haddr));
while (remsize) {
struct ipaddr_str buf;
- fprintf(handle, " +Neighbor: %s\n", olsr_ip_to_string(&buf, (union olsr_ip_addr *)data));
+ fprintf(handle, " +Neighbor: %s\n", olsr_ip_to_string(&buf, (union olsr_ip_addr *)(ARM_NOWARN_ALIGN)data));
data += olsr_cnf->ipsize;
fprintf(handle, " +LQ: %d, ", *data);
data += 1;
while (remsize) {
struct ipaddr_str buf;
- fprintf(handle, " +Neighbor: %s\n", olsr_ip_to_string(&buf, (union olsr_ip_addr *)data));
+ fprintf(handle, " +Neighbor: %s\n", olsr_ip_to_string(&buf, (union olsr_ip_addr *)(ARM_NOWARN_ALIGN)data));
data += olsr_cnf->ipsize;
remsize -= olsr_cnf->ipsize;
while (remsize) {
struct ipaddr_str buf;
- fprintf(handle, " +Network: %s\n", olsr_ip_to_string(&buf, (union olsr_ip_addr *)data));
+ fprintf(handle, " +Network: %s\n", olsr_ip_to_string(&buf, (union olsr_ip_addr *)(ARM_NOWARN_ALIGN)data));
data += olsr_cnf->ipsize;
- fprintf(handle, " +Netmask: %s\n", olsr_ip_to_string(&buf, (union olsr_ip_addr *)data));
+ fprintf(handle, " +Netmask: %s\n", olsr_ip_to_string(&buf, (union olsr_ip_addr *)(ARM_NOWARN_ALIGN)data));
data += olsr_cnf->ipsize;
remsize -= (olsr_cnf->ipsize * 2);
while (remsize) {
struct ipaddr_str buf;
- fprintf(handle, " +Alias: %s\n", olsr_ip_to_string(&buf, (union olsr_ip_addr *)data));
+ fprintf(handle, " +Alias: %s\n", olsr_ip_to_string(&buf, (union olsr_ip_addr *)(ARM_NOWARN_ALIGN)data));
data += olsr_cnf->ipsize;
remsize -= olsr_cnf->ipsize;
}
#endif
if (memcmp
- (&((struct sockaddr_in *)&ifp->int_addr)->sin_addr.s_addr, &((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr,
+ (&((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifp->int_addr)->sin_addr.s_addr, &((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifr.ifr_addr)->sin_addr.s_addr,
olsr_cnf->ipsize) != 0) {
/* New address */
OLSR_PRINTF(1, "IPv4 address changed for %s\n", ifr.ifr_name);
OLSR_PRINTF(1, "\tOld:%s\n", ip4_to_string(&buf, ifp->int_addr.sin_addr));
OLSR_PRINTF(1, "\tNew:%s\n", sockaddr4_to_string(&buf, &ifr.ifr_addr));
- ifp->int_addr = *(struct sockaddr_in *)&ifr.ifr_addr;
+ ifp->int_addr = *(struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifr.ifr_addr;
/* deactivated to prevent change of originator IP */
#if 0
if (memcmp(&olsr_cnf->main_addr, &ifp->ip_addr, olsr_cnf->ipsize) == 0) {
memcpy(&olsr_cnf->main_addr, &((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr, olsr_cnf->ipsize);
}
#endif
- memcpy(&ifp->ip_addr, &((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr, olsr_cnf->ipsize);
+ memcpy(&ifp->ip_addr, &((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifr.ifr_addr)->sin_addr.s_addr, olsr_cnf->ipsize);
if_changes = 1;
}
#endif
if (memcmp
- (&((struct sockaddr_in *)&ifp->int_netmask)->sin_addr.s_addr, &((struct sockaddr_in *)&ifr.ifr_netmask)->sin_addr.s_addr,
+ (&((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifp->int_netmask)->sin_addr.s_addr, &((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifr.ifr_netmask)->sin_addr.s_addr,
olsr_cnf->ipsize) != 0) {
/* New address */
OLSR_PRINTF(1, "IPv4 netmask changed for %s\n", ifr.ifr_name);
OLSR_PRINTF(1, "\tOld:%s\n", ip4_to_string(&buf, ifp->int_netmask.sin_addr));
OLSR_PRINTF(1, "\tNew:%s\n", sockaddr4_to_string(&buf, &ifr.ifr_netmask));
- ifp->int_netmask = *(struct sockaddr_in *)&ifr.ifr_netmask;
+ ifp->int_netmask = *(struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifr.ifr_netmask;
if_changes = 1;
}
OLSR_PRINTF(3, "\tBroadcast address:%s\n", sockaddr4_to_string(&buf, &ifr.ifr_broadaddr));
#endif
- if (ifp->int_broadaddr.sin_addr.s_addr != ((struct sockaddr_in *)&ifr.ifr_broadaddr)->sin_addr.s_addr) {
+ if (ifp->int_broadaddr.sin_addr.s_addr != ((struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifr.ifr_broadaddr)->sin_addr.s_addr) {
/* New address */
OLSR_PRINTF(1, "IPv4 broadcast changed for %s\n", ifr.ifr_name);
OLSR_PRINTF(1, "\tOld:%s\n", ip4_to_string(&buf, ifp->int_broadaddr.sin_addr));
OLSR_PRINTF(1, "\tNew:%s\n", sockaddr4_to_string(&buf, &ifr.ifr_broadaddr));
- ifp->int_broadaddr = *(struct sockaddr_in *)&ifr.ifr_broadaddr;
+ ifp->int_broadaddr = *(struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifr.ifr_broadaddr;
if_changes = 1;
}
}
return 0;
}
- ifs.int_addr = *(struct sockaddr_in *)&ifr.ifr_addr;
+ ifs.int_addr = *(struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifr.ifr_addr;
/* Find netmask */
return 0;
}
- ifs.int_netmask = *(struct sockaddr_in *)&ifr.ifr_netmask;
+ ifs.int_netmask = *(struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifr.ifr_netmask;
/* Find broadcast address */
if (iface->cnf->ipv4_broadcast.v4.s_addr) {
return 0;
}
- ifs.int_broadaddr = *(struct sockaddr_in *)&ifr.ifr_broadaddr;
+ ifs.int_broadaddr = *(struct sockaddr_in *)(ARM_NOWARN_ALIGN)&ifr.ifr_broadaddr;
}
/* Deactivate IP spoof filter */