message = ntlmssp_create_challenge(request->pool, ntlm_request,
&message_size);
- flags = read_le32(&message->flags);
+ flags = le32_to_cpu(message->flags);
request->ntlm2_negotiated = (flags & NTLMSSP_NEGOTIATE_NTLM2) != 0;
request->unicode_negotiated = (flags & NTLMSSP_NEGOTIATE_UNICODE) != 0;
request->challenge = message->challenge;
ntlm.h \
ntlm-types.h \
ntlm-flags.h \
- ntlm-byteorder.h \
ntlm-des.h \
ntlm-encrypt.h \
ntlm-message.h
+++ /dev/null
-/*
- * Little-endian data access functions.
- *
- * Copyright (c) 2004 Andrey Panin <pazke@donpac.ru>
- *
- * This software is released under the MIT license.
- */
-
-#ifndef NTLM_BYTEORDER_H
-#define NTLM_BYTEORDER_H
-
-#if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
-
-static inline uint16_t read_le16(const void *addr)
-{
- return *((const uint16_t *) addr);
-}
-
-static inline uint32_t read_le32(const void *addr)
-{
- return *((const uint32_t *) addr);
-}
-
-static inline uint64_t read_le64(const void *addr)
-{
- return *((const uint64_t *) addr);
-}
-
-static inline void write_le16(void *addr, const uint16_t value)
-{
- *((uint16_t *) addr) = value;
-}
-
-static inline void write_le32(void *addr, const uint32_t value)
-{
- *((uint32_t *) addr) = value;
-}
-
-static inline void write_le64(void *addr, const uint64_t value)
-{
- *((uint64_t *) addr) = value;
-}
-
-#else
-
-/*
- * Dumb and slow, but byteorder and alignment independent code.
- */
-
-#define readb(addr, pos, type) ((type)(*(((uint8_t *) (addr)) + (pos))))
-
-static inline uint16_t read_le16(const void *addr)
-{
- return readb(addr, 0, uint16_t) | (readb(addr, 1, uint16_t) << 8);
-}
-
-static inline uint32_t read_le32(const void *addr)
-{
- return readb(addr, 0, uint32_t) |
- (readb(addr, 1, uint32_t) << 8) |
- (readb(addr, 2, uint32_t) << 16) |
- (readb(addr, 3, uint32_t) << 24);
-}
-
-static inline uint64_t read_le64(const void *addr)
-{
- return readb(addr, 0, uint64_t) |
- (readb(addr, 1, uint64_t) << 8) |
- (readb(addr, 2, uint64_t) << 16) |
- (readb(addr, 3, uint64_t) << 24) |
- (readb(addr, 4, uint64_t) << 32) |
- (readb(addr, 5, uint64_t) << 40) |
- (readb(addr, 6, uint64_t) << 48) |
- (readb(addr, 7, uint64_t) << 56);
-}
-
-#define writeb(addr, pos, value) \
- *(((uint8_t *)(addr)) + (pos)) = (uint8_t) (value)
-
-static inline void write_le16(void *addr, const uint16_t value)
-{
- writeb(addr, 0, value & 0xff);
- writeb(addr, 1, (value >> 8) & 0xff);
-}
-
-static inline void write_le32(void *addr, const uint32_t value)
-{
- writeb(addr, 0, value & 0xff);
- writeb(addr, 1, (value >> 8) & 0xff);
- writeb(addr, 2, (value >> 16) & 0xff);
- writeb(addr, 3, (value >> 24) & 0xff);
-}
-
-static inline void write_le64(void *addr, const uint64_t value)
-{
- writeb(addr, 0, value & 0xff);
- writeb(addr, 1, (value >> 8) & 0xff);
- writeb(addr, 2, (value >> 16) & 0xff);
- writeb(addr, 3, (value >> 24) & 0xff);
- writeb(addr, 4, (value >> 32) & 0xff);
- writeb(addr, 5, (value >> 40) & 0xff);
- writeb(addr, 6, (value >> 48) & 0xff);
- writeb(addr, 7, (value >> 56) & 0xff);
-}
-
-#endif
-
-#endif
const char *ntlmssp_t_str_i(const void *message, struct ntlmssp_buffer *buffer,
bool unicode)
{
- unsigned int len = read_le16(&buffer->length);
- const char *p = ((const char *) message) + read_le32(&buffer->offset);
+ unsigned int len = le16_to_cpu(buffer->length);
+ const char *p = ((const char *) message) + le32_to_cpu(buffer->offset);
string_t *str;
if (unicode)
struct ntlmssp_buffer buffer;
unsigned int length;
- write_le32(&buffer.offset, buf->used);
+ buffer.offset = cpu32_to_le(buf->used);
length = append_string(buf, str, FALSE, unicode);
- write_le16(&buffer.length, length);
- write_le16(&buffer.space, length);
+ buffer.length = cpu16_to_le(length);
+ buffer.space = cpu16_to_le(length);
buffer_write(buf, buffer_offset, &buffer, sizeof(buffer));
}
unsigned int length, total_length = 0;
int type;
- write_le32(&buffer.offset, buf->used);
+ buffer.offset = cpu32_to_le(buf->used);
va_start(args, buffer_offset);
type = va_arg(args, int);
i_zero(&info);
- write_le16(&info.type, type);
+ info.type = cpu16_to_le(type);
switch (type) {
case NTPLMSSP_V2_TARGET_END:
case NTPLMSSP_V2_TARGET_FQDN:
case NTPLMSSP_V2_TARGET_DNS:
data = va_arg(args, const char *);
- write_le16(&info.length,
- strlen(data) * sizeof(ucs2le_t));
+ info.length = cpu16_to_le(strlen(data) *
+ sizeof(ucs2le_t));
buffer_append(buf, &info, sizeof(info));
length = append_string(buf, data, FALSE, TRUE) +
sizeof(info);
va_end(args);
- write_le16(&buffer.length, total_length);
- write_le16(&buffer.space, total_length);
+ buffer.length = cpu16_to_le(total_length);
+ buffer.space = cpu16_to_le(total_length);
buffer_write(buf, buffer_offset, &buffer, sizeof(buffer));
}
size_t *size)
{
buffer_t *buf;
- uint32_t flags = ntlmssp_flags(read_le32(&request->flags));
+ uint32_t flags = ntlmssp_flags(le32_to_cpu(request->flags));
bool unicode = (flags & NTLMSSP_NEGOTIATE_UNICODE) != 0;
struct ntlmssp_challenge c;
buf = buffer_create_dynamic(pool, sizeof(struct ntlmssp_challenge));
i_zero(&c);
- write_le64(&c.magic, NTLMSSP_MAGIC);
- write_le32(&c.type, NTLMSSP_MSG_TYPE2);
- write_le32(&c.flags, flags);
+ c.magic = cpu64_to_le(NTLMSSP_MAGIC);
+ c.type = cpu32_to_le(NTLMSSP_MSG_TYPE2);
+ c.flags = cpu32_to_le(flags);
random_fill(c.challenge, sizeof(c.challenge));
buffer_write(buf, 0, &c, sizeof(c));
static bool ntlmssp_check_buffer(const struct ntlmssp_buffer *buffer,
size_t data_size, const char **error)
{
- uint32_t offset = read_le32(&buffer->offset);
- uint16_t length = read_le16(&buffer->length);
- uint16_t space = read_le16(&buffer->space);
+ uint32_t offset = le32_to_cpu(buffer->offset);
+ uint16_t length = le16_to_cpu(buffer->length);
+ uint16_t space = le16_to_cpu(buffer->space);
/* Empty buffer is ok */
if (length == 0 && space == 0)
return FALSE;
}
- if (read_le64(&request->magic) != NTLMSSP_MAGIC) {
+ if (le64_to_cpu(request->magic) != NTLMSSP_MAGIC) {
*error = "signature mismatch";
return FALSE;
}
- if (read_le32(&request->type) != NTLMSSP_MSG_TYPE1) {
+ if (le32_to_cpu(request->type) != NTLMSSP_MSG_TYPE1) {
*error = "message type mismatch";
return FALSE;
}
- flags = read_le32(&request->flags);
+ flags = le32_to_cpu(request->flags);
if ((flags & NTLMSSP_NEGOTIATE_NTLM) == 0) {
*error = "client doesn't advertise NTLM support";
return FALSE;
}
- if (read_le64(&response->magic) != NTLMSSP_MAGIC) {
+ if (le64_to_cpu(response->magic) != NTLMSSP_MAGIC) {
*error = "signature mismatch";
return FALSE;
}
- if (read_le32(&response->type) != NTLMSSP_MSG_TYPE3) {
+ if (le32_to_cpu(response->type) != NTLMSSP_MSG_TYPE3) {
*error = "message type mismatch";
return FALSE;
}
#include <stddef.h>
+#include "byteorder.h"
#include "ntlm-types.h"
#include "ntlm-flags.h"
-#include "ntlm-byteorder.h"
#include "ntlm-encrypt.h"
#include "ntlm-message.h"
static inline const void *
ntlmssp_buffer_data_i(void *message, struct ntlmssp_buffer *buffer)
{
- return ((char *) message) + read_le32(&buffer->offset);
+ return ((char *) message) + le32_to_cpu(buffer->offset);
}
#define ntlmssp_buffer_length(message, buffer) \
static inline unsigned int
ntlmssp_buffer_length_i(struct ntlmssp_buffer *buffer)
{
- return read_le16(&buffer->length);
+ return le16_to_cpu(buffer->length);
}
#define ntlmssp_t_str(message, buffer, unicode) \
projects / thirdparty / dovecot / core.git / commitdiff
