]>
git.proxmox.com Git - mirror_ovs.git/blob - lib/byte-order.h
2 * Copyright (c) 2008, 2010, 2011, 2013, 2016 Nicira, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #define BYTE_ORDER_H 1
19 #include <sys/types.h>
20 #include <netinet/in.h>
21 #include <arpa/inet.h>
23 #include "openvswitch/types.h"
26 #if !(defined(_WIN32) || defined(htonll))
27 static inline ovs_be64
30 return htonl(1) == 1 ? n
: ((uint64_t) htonl(n
) << 32) | htonl(n
>> 32);
33 static inline uint64_t
36 return htonl(1) == 1 ? n
: ((uint64_t) ntohl(n
) << 32) | ntohl(n
>> 32);
38 #endif /* !(defined(_WIN32) || defined(htonll)) */
40 /* Making sparse happy with these functions also makes them unreadable, so
41 * don't bother to show it their implementations. */
42 ovs_be64
htonll(uint64_t);
43 uint64_t ntohll(ovs_be64
);
46 static inline ovs_be128
47 hton128(const ovs_u128 src
)
51 dst
.be64
.hi
= htonll(src
.u64
.hi
);
52 dst
.be64
.lo
= htonll(src
.u64
.lo
);
56 static inline ovs_u128
57 ntoh128(const ovs_be128 src
)
61 dst
.u64
.hi
= ntohll(src
.be64
.hi
);
62 dst
.u64
.lo
= ntohll(src
.be64
.lo
);
66 static inline uint32_t
67 uint32_byteswap(uint32_t crc
) {
68 return (((crc
& 0x000000ff) << 24) |
69 ((crc
& 0x0000ff00) << 8) |
70 ((crc
& 0x00ff0000) >> 8) |
71 ((crc
& 0xff000000) >> 24));
74 /* These macros may substitute for htons(), htonl(), and htonll() in contexts
75 * where function calls are not allowed, such as case labels. They should not
76 * be used elsewhere because all of them evaluate their argument many times. */
77 #if defined(WORDS_BIGENDIAN) || __CHECKER__
78 #define CONSTANT_HTONS(VALUE) ((OVS_FORCE ovs_be16) ((VALUE) & 0xffff))
79 #define CONSTANT_HTONL(VALUE) ((OVS_FORCE ovs_be32) ((VALUE) & 0xffffffff))
80 #define CONSTANT_HTONLL(VALUE) \
81 ((OVS_FORCE ovs_be64) ((VALUE) & UINT64_C(0xffffffffffffffff)))
83 #define CONSTANT_HTONS(VALUE) \
84 (((((ovs_be16) (VALUE)) & 0xff00) >> 8) | \
85 ((((ovs_be16) (VALUE)) & 0x00ff) << 8))
86 #define CONSTANT_HTONL(VALUE) \
87 (((((ovs_be32) (VALUE)) & 0x000000ff) << 24) | \
88 ((((ovs_be32) (VALUE)) & 0x0000ff00) << 8) | \
89 ((((ovs_be32) (VALUE)) & 0x00ff0000) >> 8) | \
90 ((((ovs_be32) (VALUE)) & 0xff000000) >> 24))
91 #define CONSTANT_HTONLL(VALUE) \
92 (((((ovs_be64) (VALUE)) & UINT64_C(0x00000000000000ff)) << 56) | \
93 ((((ovs_be64) (VALUE)) & UINT64_C(0x000000000000ff00)) << 40) | \
94 ((((ovs_be64) (VALUE)) & UINT64_C(0x0000000000ff0000)) << 24) | \
95 ((((ovs_be64) (VALUE)) & UINT64_C(0x00000000ff000000)) << 8) | \
96 ((((ovs_be64) (VALUE)) & UINT64_C(0x000000ff00000000)) >> 8) | \
97 ((((ovs_be64) (VALUE)) & UINT64_C(0x0000ff0000000000)) >> 24) | \
98 ((((ovs_be64) (VALUE)) & UINT64_C(0x00ff000000000000)) >> 40) | \
99 ((((ovs_be64) (VALUE)) & UINT64_C(0xff00000000000000)) >> 56))
102 /* Returns the ovs_be32 that you would get from:
104 * union { uint8_t b[4]; ovs_be32 be32; } x = { .b = { b0, b1, b2, b3 } };
107 * but without the undefined behavior. */
108 static inline ovs_be32
109 bytes_to_be32(uint8_t b0
, uint8_t b1
, uint8_t b2
, uint8_t b3
)
112 uint32_t x
= ((uint32_t) b0
<< 24) | (b1
<< 16) | (b2
<< 8) | b3
;
114 uint32_t x
= ((uint32_t) b3
<< 24) | (b2
<< 16) | (b1
<< 8) | b0
;
116 return (OVS_FORCE ovs_be32
) x
;
119 /* These functions zero-extend big-endian values to longer ones,
120 * or truncate long big-endian value to shorter ones. */
123 static inline ovs_be32
be16_to_be32(ovs_be16 x
) { return x
; }
124 static inline ovs_be64
be16_to_be64(ovs_be16 x
) { return x
; }
125 static inline ovs_be64
be32_to_be64(ovs_be32 x
) { return x
; }
126 static inline ovs_be32
be64_to_be32(ovs_be64 x
) { return x
; }
127 static inline ovs_be16
be64_to_be16(ovs_be64 x
) { return x
; }
128 static inline ovs_be16
be32_to_be16(ovs_be32 x
) { return x
; }
129 #else /* !WORDS_BIGENDIAN */
130 static inline ovs_be32
be16_to_be32(ovs_be16 x
) { return (ovs_be32
) x
<< 16; }
131 static inline ovs_be64
be16_to_be64(ovs_be16 x
) { return (ovs_be64
) x
<< 48; }
132 static inline ovs_be64
be32_to_be64(ovs_be32 x
) { return (ovs_be64
) x
<< 32; }
133 static inline ovs_be32
be64_to_be32(ovs_be64 x
) { return x
>> 32; }
134 static inline ovs_be16
be64_to_be16(ovs_be64 x
) { return x
>> 48; }
135 static inline ovs_be16
be32_to_be16(ovs_be32 x
) { return x
>> 16; }
136 #endif /* !WORDS_BIGENDIAN */
137 #else /* __CHECKER__ */
138 /* Making sparse happy with these functions also makes them unreadable, so
139 * don't bother to show it their implementations. */
140 ovs_be32
be16_to_be32(ovs_be16
);
141 ovs_be64
be16_to_be64(ovs_be16
);
142 ovs_be64
be32_to_be64(ovs_be32
);
143 ovs_be32
be64_to_be32(ovs_be64
);
144 ovs_be16
be64_to_be16(ovs_be64
);
145 ovs_be16
be32_to_be16(ovs_be32
);
148 #endif /* byte-order.h */