fastd/fastd
1
0
Fork 0
mirror of https://github.com/neocturne/fastd.git synced 2025-05-22 23:25:08 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Coding style: always add a space between a pointer's type and the *

Browse source
This commit is contained in:
Matthias Schiffer 2014-08-24 21:06:09 +02:00
parent 1ae3aae351
commit 9855a34f48
43 changed files with 102 additions and 102 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
src/crypto.h
View file

@ -50,7 +50,7 @@ struct fastd_cipher {
bool (*available)(void);
/** Initializes a cipher context with the given key */
fastd_cipher_state_t* (*init)(const uint8_t *key);
fastd_cipher_state_t * (*init)(const uint8_t *key);
/** Encrypts or decrypts data */
bool (*crypt)(const fastd_cipher_state_t *state, fastd_block128_t *out, const fastd_block128_t *in, size_t len, const uint8_t *iv);
/** Frees a cipher context */
@ -69,7 +69,7 @@ struct fastd_mac {
bool (*available)(void);
/** Initializes a MAC context with the given key */
fastd_mac_state_t* (*init)(const uint8_t *key);
fastd_mac_state_t * (*init)(const uint8_t *key);
/** Computes the MAC of data blocks */
bool (*hash)(const fastd_mac_state_t *state, fastd_block128_t *out, const fastd_block128_t *in, size_t n_blocks);
/** Frees a MAC context */
@ -80,14 +80,14 @@ struct fastd_mac {
void fastd_cipher_init(void);
bool fastd_cipher_config(const char *name, const char *impl);
const fastd_cipher_info_t* fastd_cipher_info_get_by_name(const char *name);
const fastd_cipher_t* fastd_cipher_get(const fastd_cipher_info_t *info);
const fastd_cipher_info_t * fastd_cipher_info_get_by_name(const char *name);
const fastd_cipher_t * fastd_cipher_get(const fastd_cipher_info_t *info);
void fastd_mac_init(void);
bool fastd_mac_config(const char *name, const char *impl);
const fastd_mac_info_t* fastd_mac_info_get_by_name(const char *name);
const fastd_mac_t* fastd_mac_get(const fastd_mac_info_t *info);
const fastd_mac_info_t * fastd_mac_info_get_by_name(const char *name);
const fastd_mac_t * fastd_mac_get(const fastd_mac_info_t *info);
/** Sets a range of memory to zero, ensuring the operation can't be optimized out by the compiler */

4
src/crypto/cipher/aes128_ctr/nacl/cipher_aes128_ctr_nacl.c
View file

@ -42,12 +42,12 @@ struct __attribute__((aligned(16))) fastd_cipher_state {
/** Initializes the cipher state */
static fastd_cipher_state_t* aes128_ctr_init(const uint8_t *key) {
static fastd_cipher_state_t * aes128_ctr_init(const uint8_t *key) {
fastd_block128_t k;
memcpy(k.b, key, sizeof(fastd_block128_t));
fastd_cipher_state_t *state;
if (posix_memalign((void**)&state, 16, sizeof(fastd_cipher_state_t)))
if (posix_memalign((void **)&state, 16, sizeof(fastd_cipher_state_t)))
abort();
crypto_stream_aes128ctr_beforenm(state->d, k.b);

8
src/crypto/cipher/aes128_ctr/openssl/aes128_ctr_openssl.c
View file

@ -43,11 +43,11 @@ struct fastd_cipher_state {
/** Initializes the cipher state */
static fastd_cipher_state_t* aes128_ctr_init(const uint8_t *key) {
static fastd_cipher_state_t * aes128_ctr_init(const uint8_t *key) {
fastd_cipher_state_t *state = fastd_new(fastd_cipher_state_t);
state->aes = EVP_CIPHER_CTX_new();
EVP_EncryptInit(state->aes, EVP_aes_128_ctr(), (const unsigned char*)key, NULL);
EVP_EncryptInit(state->aes, EVP_aes_128_ctr(), (const unsigned char *)key, NULL);
return state;
}
@ -59,10 +59,10 @@ static bool aes128_ctr_crypt(const fastd_cipher_state_t *state, fastd_block128_t
if (!EVP_EncryptInit(state->aes, NULL, NULL, iv))
return false;
if (!EVP_EncryptUpdate(state->aes, (unsigned char*)out, &clen, (const unsigned char*)in, len))
if (!EVP_EncryptUpdate(state->aes, (unsigned char *)out, &clen, (const unsigned char *)in, len))
return false;
if (!EVP_EncryptFinal(state->aes, ((unsigned char*)out) + clen, &clen2))
if (!EVP_EncryptFinal(state->aes, ((unsigned char *)out) + clen, &clen2))
return false;
if ((size_t)(clen+clen2) != len)

4
src/crypto/cipher/ciphers.c.in
View file

@ -101,7 +101,7 @@ bool fastd_cipher_config(const char *name, const char *impl) {
}
/** Returns information about the cipher with the specified name if there is an implementation available */
const fastd_cipher_info_t* fastd_cipher_info_get_by_name(const char *name) {
const fastd_cipher_info_t * fastd_cipher_info_get_by_name(const char *name) {
size_t i;
for (i = 0; i < array_size(ciphers); i++) {
if (strcmp(ciphers[i].name, name))
@ -117,7 +117,7 @@ const fastd_cipher_info_t* fastd_cipher_info_get_by_name(const char *name) {
}
/** Returns the chosen cipher implementation for a given cipher */
const fastd_cipher_t* fastd_cipher_get(const fastd_cipher_info_t *info) {
const fastd_cipher_t * fastd_cipher_get(const fastd_cipher_info_t *info) {
size_t i;
for (i = 0; i < array_size(ciphers); i++) {
if (ciphers[i].info == info)

2
src/crypto/cipher/null/memcpy/null_memcpy.c
View file

@ -34,7 +34,7 @@
/** Doesn't do anything as the null cipher doesn't use any state */
static fastd_cipher_state_t* null_init(const uint8_t *key UNUSED) {
static fastd_cipher_state_t * null_init(const uint8_t *key UNUSED) {
return NULL;
}

2
src/crypto/cipher/salsa20/nacl/salsa20_nacl.c
View file

@ -43,7 +43,7 @@ struct fastd_cipher_state {
/** Initializes the cipher state */
static fastd_cipher_state_t* salsa20_init(const uint8_t *key) {
static fastd_cipher_state_t * salsa20_init(const uint8_t *key) {
fastd_cipher_state_t *state = fastd_new(fastd_cipher_state_t);
memcpy(state->key, key, crypto_stream_salsa20_KEYBYTES);

2
src/crypto/cipher/salsa20/xmm/salsa20_xmm.c
View file

@ -67,7 +67,7 @@ static bool salsa20_available(void) {
}
/** Initializes the cipher state */
static fastd_cipher_state_t* salsa20_init(const uint8_t *key) {
static fastd_cipher_state_t * salsa20_init(const uint8_t *key) {
fastd_cipher_state_t *state = fastd_new(fastd_cipher_state_t);
memcpy(state->key, key, KEYBYTES);

2
src/crypto/cipher/salsa2012/nacl/salsa2012_nacl.c
View file

@ -43,7 +43,7 @@ struct fastd_cipher_state {
/** Initializes the cipher state */
static fastd_cipher_state_t* salsa2012_init(const uint8_t *key) {
static fastd_cipher_state_t * salsa2012_init(const uint8_t *key) {
fastd_cipher_state_t *state = fastd_new(fastd_cipher_state_t);
memcpy(state->key, key, crypto_stream_salsa2012_KEYBYTES);

2
src/crypto/cipher/salsa2012/xmm/salsa2012_xmm.c
View file

@ -67,7 +67,7 @@ static bool salsa2012_available(void) {
}
/** Initializes the cipher state */
static fastd_cipher_state_t* salsa2012_init(const uint8_t *key) {
static fastd_cipher_state_t * salsa2012_init(const uint8_t *key) {
fastd_cipher_state_t *state = fastd_new(fastd_cipher_state_t);
memcpy(state->key, key, KEYBYTES);

4
src/crypto/mac/ghash/builtin/ghash_builtin.c
View file

@ -72,9 +72,9 @@ static inline void mulH_a(fastd_block128_t *x, const fastd_mac_state_t *cstate)
/** Initializes the MAC state with the unpacked key data */
static fastd_mac_state_t* ghash_init(const uint8_t *key) {
static fastd_mac_state_t * ghash_init(const uint8_t *key) {
fastd_mac_state_t *state;
if (posix_memalign((void**)&state, 16, sizeof(fastd_mac_state_t)))
if (posix_memalign((void **)&state, 16, sizeof(fastd_mac_state_t)))
abort();
fastd_block128_t Hbase[4];

2
src/crypto/mac/ghash/pclmulqdq/ghash_pclmulqdq.h
View file

@ -35,6 +35,6 @@
#include "../../../../crypto.h"
fastd_mac_state_t* fastd_ghash_pclmulqdq_init(const uint8_t *key);
fastd_mac_state_t * fastd_ghash_pclmulqdq_init(const uint8_t *key);
bool fastd_ghash_pclmulqdq_hash(const fastd_mac_state_t *state, fastd_block128_t *out, const fastd_block128_t *in, size_t n_blocks);
void fastd_ghash_pclmulqdq_free(fastd_mac_state_t *state);

4
src/crypto/mac/ghash/pclmulqdq/ghash_pclmulqdq_impl.c
View file

@ -76,9 +76,9 @@ static inline __m128i byteswap(__m128i v) {
/** Initializes the state used by this GHASH implementation */
fastd_mac_state_t* fastd_ghash_pclmulqdq_init(const uint8_t *key) {
fastd_mac_state_t * fastd_ghash_pclmulqdq_init(const uint8_t *key) {
fastd_mac_state_t *state;
if (posix_memalign((void**)&state, 16, sizeof(fastd_mac_state_t)))
if (posix_memalign((void **)&state, 16, sizeof(fastd_mac_state_t)))
abort();
memcpy(&state->H, key, sizeof(__m128i));

4
src/crypto/mac/macs.c.in
View file

@ -101,7 +101,7 @@ bool fastd_mac_config(const char *name, const char *impl) {
}
/** Returns information about the MAC with the specified name if there is an implementation available */
const fastd_mac_info_t* fastd_mac_info_get_by_name(const char *name) {
const fastd_mac_info_t * fastd_mac_info_get_by_name(const char *name) {
size_t i;
for (i = 0; i < array_size(macs); i++) {
if (strcmp(macs[i].name, name))
@ -117,7 +117,7 @@ const fastd_mac_info_t* fastd_mac_info_get_by_name(const char *name) {
}
/** Returns the chosen MAC implementation for a given cipher */
const fastd_mac_t* fastd_mac_get(const fastd_mac_info_t *info) {
const fastd_mac_t * fastd_mac_get(const fastd_mac_info_t *info) {
size_t i;
for (i = 0; i < array_size(macs); i++) {
if (macs[i].info == info)

2
src/fastd.c
View file

@ -399,7 +399,7 @@ static inline void notify_systemd(void) {
if (sa.sun_path[0] == '@')
sa.sun_path[0] = 0;
if (connect(fd, (struct sockaddr*)&sa, offsetof(struct sockaddr_un, sun_path) + strnlen(notify_socket, sizeof(sa.sun_path))) < 0) {
if (connect(fd, (struct sockaddr *)&sa, offsetof(struct sockaddr_un, sun_path) + strnlen(notify_socket, sizeof(sa.sun_path))) < 0) {
pr_debug_errno("unable to connect to notify socket: connect");
close(fd);
return;

14
src/fastd.h
View file

@ -238,7 +238,7 @@ struct fastd_context {
int64_t now; /**< The current monotonous timestamp in microseconds after an arbitrary point in time */
uint64_t next_peer_id; /**< An monotonously increasing ID peers are identified with in some components */
VECTOR(fastd_peer_t*) peers; /**< The currectly active peers */
VECTOR(fastd_peer_t *) peers; /**< The currectly active peers */
#ifdef WITH_DYNAMIC_PEERS
fastd_sem_t verify_limit; /**< Keeps track of the number of verifier threads */
@ -253,7 +253,7 @@ struct fastd_context {
bool has_floating; /**< Specifies if any of the configured peers have floating remotes */
uint32_t peer_addr_ht_seed; /**< The hash seed used for peer_addr_ht */
VECTOR(fastd_peer_t*) *peer_addr_ht; /**< An array of hash buckets for the peer hash table */
VECTOR(fastd_peer_t *) *peer_addr_ht; /**< An array of hash buckets for the peer hash table */
fastd_dlist_head_t handshake_queue; /**< A doubly linked list of the peers currently queued for handshakes (ordered by the time of the next handshake) */
fastd_timeout_t next_maintenance; /**< The time of the next maintenance call */
@ -307,7 +307,7 @@ void fastd_handle_receive(fastd_peer_t *peer, fastd_buffer_t buffer);
void fastd_close_all_fds(void);
bool fastd_socket_handle_binds(void);
fastd_socket_t* fastd_socket_open(fastd_peer_t *peer, int af);
fastd_socket_t * fastd_socket_open(fastd_peer_t *peer, int af);
void fastd_socket_close(fastd_socket_t *sock);
void fastd_socket_error(fastd_socket_t *sock);
@ -351,7 +351,7 @@ static inline void fastd_setnonblock(int fd) {
*/
#define container_of(ptr, type, member) ({ \
const __typeof__(((type *)0)->member) *_mptr = (ptr); \
(type*)((char*)_mptr - offsetof(type, member)); \
(type *)((char *)_mptr - offsetof(type, member)); \
})
/**
@ -393,7 +393,7 @@ static inline bool fastd_peer_address_is_v6_ll(const fastd_peer_address_t *addr)
}
/** Duplicates a string, creating a one-element string stack */
static inline fastd_string_stack_t* fastd_string_stack_dup(const char *str) {
static inline fastd_string_stack_t * fastd_string_stack_dup(const char *str) {
fastd_string_stack_t *ret = fastd_alloc(alignto(sizeof(fastd_string_stack_t) + strlen(str) + 1, 8));
ret->next = NULL;
strcpy(ret->str, str);
@ -402,7 +402,7 @@ static inline fastd_string_stack_t* fastd_string_stack_dup(const char *str) {
}
/** Duplicates a string of a given maximum length, creating a one-element string stack */
static inline fastd_string_stack_t* fastd_string_stack_dupn(const char *str, size_t len) {
static inline fastd_string_stack_t * fastd_string_stack_dupn(const char *str, size_t len) {
size_t str_len = strnlen(str, len);
fastd_string_stack_t *ret = fastd_alloc(alignto(sizeof(fastd_string_stack_t) + str_len + 1, 8));
ret->next = NULL;
@ -413,7 +413,7 @@ static inline fastd_string_stack_t* fastd_string_stack_dupn(const char *str, siz
}
/** Pushes the copy of a string onto the top of a string stack */
static inline fastd_string_stack_t* fastd_string_stack_push(fastd_string_stack_t *stack, const char *str) {
static inline fastd_string_stack_t * fastd_string_stack_push(fastd_string_stack_t *stack, const char *str) {
fastd_string_stack_t *ret = fastd_alloc(alignto(sizeof(fastd_string_stack_t) + strlen(str) + 1, 8));
ret->next = stack;
strcpy(ret->str, str);

22
src/handshake.c
View file

@ -58,14 +58,14 @@ static const char *const RECORD_TYPES[RECORD_MAX] = {
/** Reads a TLV record as an 8bit integer */
#define AS_UINT8(ptr) (*(uint8_t*)(ptr).data)
#define AS_UINT8(ptr) (*(uint8_t *)(ptr).data)
/** Reads a TLV record as a 16bit integer (big endian) */
#define AS_UINT16(ptr) ((*(uint8_t*)(ptr).data) + (*((uint8_t*)(ptr).data+1) << 8))
#define AS_UINT16(ptr) ((*(uint8_t *)(ptr).data) + (*((uint8_t *)(ptr).data+1) << 8))
/** Generates a zero-separated list of supported methods */
static uint8_t* create_method_list(size_t *len) {
static uint8_t * create_method_list(size_t *len) {
*len = 0;
size_t i;
@ -75,7 +75,7 @@ static uint8_t* create_method_list(size_t *len) {
uint8_t *ret = fastd_alloc(*len);
(*len)--;
char *ptr = (char*)ret;
char *ptr = (char *)ret;
for (i = 0; conf.methods[i].name; i++)
ptr = stpcpy(ptr, conf.methods[i].name) + 1;
@ -93,16 +93,16 @@ static inline bool string_equal(const char *str, const char *buf, size_t maxlen)
/** Checks if a string is equal to the value of a TLV record */
static inline bool record_equal(const char *str, const fastd_handshake_record_t *record) {
return string_equal(str, (const char*)record->data, record->length);
return string_equal(str, (const char *)record->data, record->length);
}
/** Parses a list of zero-separated strings */
static fastd_string_stack_t* parse_string_list(const uint8_t *data, size_t len) {
static fastd_string_stack_t * parse_string_list(const uint8_t *data, size_t len) {
const uint8_t *end = data+len;
fastd_string_stack_t *ret = NULL;
while (data < end) {
fastd_string_stack_t *part = fastd_string_stack_dupn((char*)data, end-data);
fastd_string_stack_t *part = fastd_string_stack_dupn((char *)data, end-data);
part->next = ret;
ret = part;
data += strlen(part->str) + 1;
@ -304,7 +304,7 @@ static inline bool check_records(fastd_socket_t *sock, const fastd_peer_address_
}
/** Returns the method info with a specified name and length */
static inline const fastd_method_info_t* get_method_by_name(const char *name, size_t n) {
static inline const fastd_method_info_t * get_method_by_name(const char *name, size_t n) {
char name0[n+1];
memcpy(name0, name, n);
name0[n] = 0;
@ -313,7 +313,7 @@ static inline const fastd_method_info_t* get_method_by_name(const char *name, si
}
/** Returns the most appropriate method to negotiate with a peer a handshake was received from */
static inline const fastd_method_info_t* get_method(const fastd_handshake_t *handshake) {
static inline const fastd_method_info_t * get_method(const fastd_handshake_t *handshake) {
if (handshake->records[RECORD_METHOD_LIST].data && handshake->records[RECORD_METHOD_LIST].length) {
fastd_string_stack_t *method_list = parse_string_list(handshake->records[RECORD_METHOD_LIST].data, handshake->records[RECORD_METHOD_LIST].length);
@ -335,7 +335,7 @@ static inline const fastd_method_info_t* get_method(const fastd_handshake_t *han
if (!handshake->records[RECORD_METHOD_NAME].data)
return NULL;
return get_method_by_name((const char*)handshake->records[RECORD_METHOD_NAME].data, handshake->records[RECORD_METHOD_NAME].length);
return get_method_by_name((const char *)handshake->records[RECORD_METHOD_NAME].data, handshake->records[RECORD_METHOD_NAME].length);
}
/** Handles a handshake packet */
@ -364,7 +364,7 @@ void fastd_handshake_handle(fastd_socket_t *sock, const fastd_peer_address_t *lo
method = get_method(&handshake);
if (handshake.records[RECORD_VERSION_NAME].data)
handshake.peer_version = peer_version = fastd_strndup((const char*)handshake.records[RECORD_VERSION_NAME].data, handshake.records[RECORD_VERSION_NAME].length);
handshake.peer_version = peer_version = fastd_strndup((const char *)handshake.records[RECORD_VERSION_NAME].data, handshake.records[RECORD_VERSION_NAME].length);
}
if (handshake.type > 1 && !method) {

6
src/handshake.h
View file

@ -99,7 +99,7 @@ void fastd_handshake_handle(fastd_socket_t *sock, const fastd_peer_address_t *lo
/** Returns the TLV data of a handshake packet in a given buffer */
static inline void* fastd_handshake_tlv_data(const fastd_buffer_t *buffer) {
static inline void * fastd_handshake_tlv_data(const fastd_buffer_t *buffer) {
fastd_handshake_packet_t *packet = buffer->data;
return packet->tlv_data;
}
@ -111,7 +111,7 @@ static inline uint16_t fastd_handshake_tlv_len(const fastd_buffer_t *buffer) {
}
/** Adds an uninitialized TLV record of given type and length to a handshake buffer */
static inline uint8_t* fastd_handshake_extend(fastd_buffer_t *buffer, fastd_handshake_record_type_t type, size_t len) {
static inline uint8_t * fastd_handshake_extend(fastd_buffer_t *buffer, fastd_handshake_record_type_t type, size_t len) {
uint8_t *dst = buffer->data + buffer->len;
if (buffer->data + buffer->len + 4 + len > buffer->base + buffer->base_len)
@ -138,7 +138,7 @@ static inline void fastd_handshake_add(fastd_buffer_t *buffer, fastd_handshake_r
}
/** Adds an TLV record of given type and length initialized with zeros to a handshake buffer */
static inline uint8_t* fastd_handshake_add_zero(fastd_buffer_t *buffer, fastd_handshake_record_type_t type, size_t len) {
static inline uint8_t * fastd_handshake_add_zero(fastd_buffer_t *buffer, fastd_handshake_record_type_t type, size_t len) {
uint8_t *dst = fastd_handshake_extend(buffer, type, len);
memset(dst, 0, len);

2
src/hash.h
View file

@ -43,7 +43,7 @@
static inline void fastd_hash(uint32_t *hash, const void *data, size_t len) {
size_t i;
for (i = 0; i < len; ++i) {
*hash += ((uint8_t*)data)[i];
*hash += ((uint8_t *)data)[i];
*hash += (*hash << 10);
*hash ^= (*hash >> 6);
}

4
src/hkdf_sha256.c
View file

@ -45,14 +45,14 @@ void fastd_hkdf_sha256_expand(fastd_sha256_t *out, size_t blocks, const fastd_sh
memset(buf, 0, FASTD_SHA256_HASH_BYTES);
memcpy(buf+FASTD_SHA256_HASH_WORDS, info, infolen);
((uint8_t*)buf)[len-1] = 0x01;
((uint8_t *)buf)[len-1] = 0x01;
fastd_hmacsha256(out, prk->w, buf+FASTD_SHA256_HASH_WORDS, infolen + 1);
while (--blocks) {
memcpy(buf, out, FASTD_SHA256_HASH_BYTES);
out++;
((uint8_t*)buf)[len-1]++;
((uint8_t *)buf)[len-1]++;
fastd_hmacsha256(out, prk->w, buf, len);
}

4
src/lex.c
View file

@ -158,7 +158,7 @@ static inline char current(fastd_lex_t *lex) {
}
/** Returns the current token as a newly allocated string */
static char* get_token(fastd_lex_t *lex) {
static char * get_token(fastd_lex_t *lex) {
return fastd_strndup(lex->buffer+lex->start, lex->tok_len);
}
@ -443,7 +443,7 @@ static int parse_keyword(YYSTYPE *yylval, YYLTYPE *yylloc, fastd_lex_t *lex) {
/** Initializes a new scanner for the given file */
fastd_lex_t* fastd_lex_init(FILE *file) {
fastd_lex_t * fastd_lex_init(FILE *file) {
fastd_lex_t *lex = fastd_new0(fastd_lex_t);
lex->file = file;

2
src/lex.h
View file

@ -38,7 +38,7 @@
#include <stdio.h>
fastd_lex_t* fastd_lex_init(FILE *file);
fastd_lex_t * fastd_lex_init(FILE *file);
void fastd_lex_destroy(fastd_lex_t *lex);
int fastd_lex(YYSTYPE *yylval, YYLTYPE *yylloc, fastd_lex_t *lex);

16
src/log.c
View file

@ -144,15 +144,15 @@ static int fastd_vsnprintf(char *buffer, size_t size, const char *format, va_lis
break;
case 's':
buffer += snprintf_safe(buffer, buffer_end-buffer, "%s", va_arg(ap, char*));
buffer += snprintf_safe(buffer, buffer_end-buffer, "%s", va_arg(ap, char *));
break;
case 'p':
buffer += snprintf_safe(buffer, buffer_end-buffer, "%p", va_arg(ap, void*));
buffer += snprintf_safe(buffer, buffer_end-buffer, "%p", va_arg(ap, void *));
break;
case 'E':
eth_addr = va_arg(ap, const fastd_eth_addr_t*);
eth_addr = va_arg(ap, const fastd_eth_addr_t *);
if (eth_addr) {
if (conf.hide_mac_addresses)
@ -168,18 +168,18 @@ static int fastd_vsnprintf(char *buffer, size_t size, const char *format, va_lis
break;
case 'P':
buffer += snprint_peer_str(buffer, buffer_end-buffer, va_arg(ap, const fastd_peer_t*));
buffer += snprint_peer_str(buffer, buffer_end-buffer, va_arg(ap, const fastd_peer_t *));
break;
case 'I':
case 'B':
case 'L':
p = va_arg(ap, const fastd_peer_address_t*);
p = va_arg(ap, const fastd_peer_address_t *);
iface = (*format == 'L') ? va_arg(ap, const char*) : NULL;
iface = (*format == 'L') ? va_arg(ap, const char *) : NULL;
if (p)
buffer += snprint_peer_address(buffer, buffer_end-buffer, (const fastd_peer_address_t*)p, iface, *format != 'I');
buffer += snprint_peer_address(buffer, buffer_end-buffer, (const fastd_peer_address_t *)p, iface, *format != 'I');
else
buffer += snprintf_safe(buffer, buffer_end-buffer, "(null)");
break;
@ -198,7 +198,7 @@ static int fastd_vsnprintf(char *buffer, size_t size, const char *format, va_lis
}
/** Returns a prefix string to use for log messages of a specified level */
static inline const char* get_log_prefix(fastd_loglevel_t log_level) {
static inline const char * get_log_prefix(fastd_loglevel_t log_level) {
switch(log_level) {
case LL_FATAL:
return "Fatal: ";

6
src/method.h
View file

@ -59,9 +59,9 @@ struct fastd_method_provider {
size_t (*key_length)(const fastd_method_t *method);
/** Initiates a session */
fastd_method_session_state_t* (*session_init)(const fastd_method_t *method, const uint8_t *secret, bool initiator);
fastd_method_session_state_t * (*session_init)(const fastd_method_t *method, const uint8_t *secret, bool initiator);
/** Initiates a session in pre-v11 compatiblity mode */
fastd_method_session_state_t* (*session_init_compat)(const fastd_method_t *method, const uint8_t *secret, size_t length, bool initiator);
fastd_method_session_state_t * (*session_init_compat)(const fastd_method_t *method, const uint8_t *secret, size_t length, bool initiator);
/** Closes a session */
void (*session_free)(fastd_method_session_state_t *session);
@ -85,7 +85,7 @@ bool fastd_method_create_by_name(const char *name, const fastd_method_provider_t
/** Finds the fastd_method_info_t for a configured method */
static inline const fastd_method_info_t* fastd_method_get_by_name(const char *name) {
static inline const fastd_method_info_t * fastd_method_get_by_name(const char *name) {
size_t i;
for (i = 0; conf.methods[i].name; i++) {
if (!strcmp(conf.methods[i].name, name))

2
src/methods/cipher_test/cipher_test.c
View file

@ -89,7 +89,7 @@ static size_t method_key_length(const fastd_method_t *method) {
}
/** Initializes a session */
static fastd_method_session_state_t* method_session_init(const fastd_method_t *method, const uint8_t *secret, bool initiator) {
static fastd_method_session_state_t * method_session_init(const fastd_method_t *method, const uint8_t *secret, bool initiator) {
fastd_method_session_state_t *session = fastd_new(fastd_method_session_state_t);
fastd_method_common_init(&session->common, initiator);

2
src/methods/composed_gmac/composed_gmac.c
View file

@ -132,7 +132,7 @@ static size_t method_key_length(const fastd_method_t *method) {
}
/** Initializes a session */
static fastd_method_session_state_t* method_session_init(const fastd_method_t *method, const uint8_t *secret, bool initiator) {
static fastd_method_session_state_t * method_session_init(const fastd_method_t *method, const uint8_t *secret, bool initiator) {
fastd_method_session_state_t *session = fastd_new(fastd_method_session_state_t);
fastd_method_common_init(&session->common, initiator);

2
src/methods/generic_gmac/generic_gmac.c
View file

@ -107,7 +107,7 @@ static size_t method_key_length(const fastd_method_t *method) {
}
/** Initializes a session */
static fastd_method_session_state_t* method_session_init(const fastd_method_t *method, const uint8_t *secret, bool initiator) {
static fastd_method_session_state_t * method_session_init(const fastd_method_t *method, const uint8_t *secret, bool initiator) {
fastd_method_session_state_t *session = fastd_new(fastd_method_session_state_t);
fastd_method_common_init(&session->common, initiator);

2
src/methods/generic_poly1305/generic_poly1305.c
View file

@ -101,7 +101,7 @@ static size_t method_key_length(const fastd_method_t *method) {
}
/** Initializes a session */
static fastd_method_session_state_t* method_session_init(const fastd_method_t *method, const uint8_t *secret, bool initiator) {
static fastd_method_session_state_t * method_session_init(const fastd_method_t *method, const uint8_t *secret, bool initiator) {
fastd_method_session_state_t *session = fastd_new(fastd_method_session_state_t);
fastd_method_common_init(&session->common, initiator);

4
src/methods/null/null.c
View file

@ -54,7 +54,7 @@ static size_t method_key_length(const fastd_method_t *method UNUSED) {
}
/** Initiates a new null session */
static fastd_method_session_state_t* method_session_init(const fastd_method_t *method UNUSED, const uint8_t *secret UNUSED, bool initiator) {
static fastd_method_session_state_t * method_session_init(const fastd_method_t *method UNUSED, const uint8_t *secret UNUSED, bool initiator) {
fastd_method_session_state_t *session = fastd_new(fastd_method_session_state_t);
session->valid = true;
@ -64,7 +64,7 @@ static fastd_method_session_state_t* method_session_init(const fastd_method_t *m
}
/** Initiates a new null session (pre-v11 compat handshake) */
static fastd_method_session_state_t* method_session_init_compat(const fastd_method_t *method, const uint8_t *secret, size_t length UNUSED, bool initiator) {
static fastd_method_session_state_t * method_session_init_compat(const fastd_method_t *method, const uint8_t *secret, size_t length UNUSED, bool initiator) {
return method_session_init(method, secret, initiator);
}

4
src/methods/xsalsa20_poly1305/xsalsa20_poly1305.c
View file

@ -64,7 +64,7 @@ static size_t method_key_length(const fastd_method_t *method UNUSED) {
}
/** Initializes the session state */
static fastd_method_session_state_t* method_session_init(const fastd_method_t *method UNUSED, const uint8_t *secret, bool initiator) {
static fastd_method_session_state_t * method_session_init(const fastd_method_t *method UNUSED, const uint8_t *secret, bool initiator) {
fastd_method_session_state_t *session = fastd_new(fastd_method_session_state_t);
fastd_method_common_init(&session->common, initiator);
@ -75,7 +75,7 @@ static fastd_method_session_state_t* method_session_init(const fastd_method_t *m
}
/** Initializes the session state (pre-v11 compat handshake) */
static fastd_method_session_state_t* method_session_init_compat(const fastd_method_t *method, const uint8_t *secret, size_t length, bool initiator) {
static fastd_method_session_state_t * method_session_init_compat(const fastd_method_t *method, const uint8_t *secret, size_t length, bool initiator) {
if (length < crypto_secretbox_xsalsa20poly1305_KEYBYTES)
exit_bug("xsalsa20-poly1305: tried to init with short secret");

2
src/options.c
View file

@ -394,7 +394,7 @@ static bool config_match(const char *opt, ...) {
va_start(ap, opt);
while((str = va_arg(ap, const char*)) != NULL) {
while((str = va_arg(ap, const char *)) != NULL) {
if (strcmp(opt, str) == 0) {
match = true;
break;

4
src/peer.c
View file

@ -160,7 +160,7 @@ static inline size_t peer_index(fastd_peer_t *peer) {
}
/** Finds a peer with a specified ID */
fastd_peer_t* fastd_peer_find_by_id(uint64_t id) {
fastd_peer_t * fastd_peer_find_by_id(uint64_t id) {
fastd_peer_t **ret = peer_p_find_by_id(id);
if (ret)
@ -884,7 +884,7 @@ void fastd_peer_eth_addr_add(fastd_peer_t *peer, fastd_eth_addr_t addr) {
}
/** Finds the peer that is associated with a given MAC address */
fastd_peer_t* fastd_peer_find_by_eth_addr(const fastd_eth_addr_t addr) {
fastd_peer_t * fastd_peer_find_by_eth_addr(const fastd_eth_addr_t addr) {
const fastd_peer_eth_addr_t key = {.addr = addr};
fastd_peer_eth_addr_t *peer_eth_addr = VECTOR_BSEARCH(&key, ctx.eth_addrs, peer_eth_addr_cmp);

4
src/peer.h
View file

@ -168,7 +168,7 @@ bool fastd_peer_matches_address(const fastd_peer_t *peer, const fastd_peer_addre
bool fastd_peer_claim_address(fastd_peer_t *peer, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, bool force);
void fastd_peer_reset_socket(fastd_peer_t *peer);
void fastd_peer_schedule_handshake(fastd_peer_t *peer, int delay);
fastd_peer_t* fastd_peer_find_by_id(uint64_t id);
fastd_peer_t * fastd_peer_find_by_id(uint64_t id);
void fastd_peer_set_shell_env(fastd_shell_env_t *env, const fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr);
void fastd_peer_exec_shell_command(const fastd_shell_command_t *command, const fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr);
@ -266,7 +266,7 @@ static inline bool fastd_eth_addr_is_unicast(fastd_eth_addr_t addr) {
}
void fastd_peer_eth_addr_add(fastd_peer_t *peer, fastd_eth_addr_t addr);
fastd_peer_t* fastd_peer_find_by_eth_addr(fastd_eth_addr_t addr);
fastd_peer_t * fastd_peer_find_by_eth_addr(fastd_eth_addr_t addr);
void fastd_peer_handle_handshake_queue(void);
void fastd_peer_maintenance(void);

2
src/protocols/ec25519_fhmqvc/ec25519_fhmqvc.c
View file

@ -58,7 +58,7 @@ static inline void check_session_refresh(fastd_peer_t *peer) {
}
/** Initializes the protocol-specific configuration */
static fastd_protocol_config_t* protocol_init(void) {
static fastd_protocol_config_t * protocol_init(void) {
fastd_protocol_config_t *protocol_config = fastd_new(fastd_protocol_config_t);
if (!conf.secret)

2
src/protocols/ec25519_fhmqvc/handshake.c
View file

@ -129,7 +129,7 @@ static inline bool new_session(fastd_peer_t *peer, const fastd_method_info_t *me
fastd_sha256_t secret[blocks];
derive_key(secret, blocks, salt, method->name, A, B, X, Y, sigma);
peer->protocol_state->session.method_state = method->provider->session_init(method->method, (const uint8_t*)secret, initiator);
peer->protocol_state->session.method_state = method->provider->session_init(method->method, (const uint8_t *)secret, initiator);
}
else {
fastd_sha256_t hash;

2
src/random.c
View file

@ -51,7 +51,7 @@ void fastd_random_bytes(void *buffer, size_t len, bool secure) {
exit_errno("unable to open random device");
while (read_bytes < len) {
ssize_t ret = read(fd, ((char*)buffer)+read_bytes, len-read_bytes);
ssize_t ret = read(fd, ((char *)buffer)+read_bytes, len-read_bytes);
if (ret < 0)
exit_errno("unable to read from random device");

8
src/receive.c
View file

@ -42,18 +42,18 @@
static inline void handle_socket_control(struct msghdr *message, const fastd_socket_t *sock, fastd_peer_address_t *local_addr) {
memset(local_addr, 0, sizeof(fastd_peer_address_t));
const uint8_t *end = (const uint8_t*)message->msg_control + message->msg_controllen;
const uint8_t *end = (const uint8_t *)message->msg_control + message->msg_controllen;
struct cmsghdr *cmsg;
for (cmsg = CMSG_FIRSTHDR(message); cmsg; cmsg = CMSG_NXTHDR(message, cmsg)) {
if ((const uint8_t*)cmsg + sizeof(*cmsg) > end)
if ((const uint8_t *)cmsg + sizeof(*cmsg) > end)
return;
#ifdef USE_PKTINFO
if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO) {
struct in_pktinfo pktinfo;
if ((const uint8_t*)CMSG_DATA(cmsg) + sizeof(pktinfo) > end)
if ((const uint8_t *)CMSG_DATA(cmsg) + sizeof(pktinfo) > end)
return;
memcpy(&pktinfo, CMSG_DATA(cmsg), sizeof(pktinfo));
@ -69,7 +69,7 @@ static inline void handle_socket_control(struct msghdr *message, const fastd_soc
if (cmsg->cmsg_level == IPPROTO_IPV6 && cmsg->cmsg_type == IPV6_PKTINFO) {
struct in6_pktinfo pktinfo;
if ((uint8_t*)CMSG_DATA(cmsg) + sizeof(pktinfo) > end)
if ((uint8_t *)CMSG_DATA(cmsg) + sizeof(pktinfo) > end)
return;
memcpy(&pktinfo, CMSG_DATA(cmsg), sizeof(pktinfo));

4
src/resolve.c
View file

@ -46,7 +46,7 @@ typedef struct resolv_arg {
/** The resolver thread main routine */
static void* resolve_peer(void *varg) {
static void * resolve_peer(void *varg) {
resolv_arg_t *arg = varg;
struct addrinfo *res = NULL, *res2;
@ -77,7 +77,7 @@ static void* resolve_peer(void *varg) {
}
uint8_t retbuf[sizeof(fastd_async_resolve_return_t) + n_addr*sizeof(fastd_peer_address_t)] __attribute__((aligned(8)));
fastd_async_resolve_return_t *ret = (fastd_async_resolve_return_t*)retbuf;
fastd_async_resolve_return_t *ret = (fastd_async_resolve_return_t *)retbuf;
ret->peer_id = arg->peer_id;
ret->remote = arg->remote;

8
src/send.c
View file

@ -41,7 +41,7 @@ static inline void add_pktinfo(struct msghdr *msg, const fastd_peer_address_t *l
if (!local_addr)
return;
struct cmsghdr *cmsg = (struct cmsghdr*)((char*)msg->msg_control + msg->msg_controllen);
struct cmsghdr *cmsg = (struct cmsghdr *)((char *)msg->msg_control + msg->msg_controllen);
#ifdef USE_PKTINFO
if (local_addr->sa.sa_family == AF_INET) {
@ -94,12 +94,12 @@ static void send_type(const fastd_socket_t *sock, const fastd_peer_address_t *lo
switch (remote_addr->sa.sa_family) {
case AF_INET:
msg.msg_name = (void*)&remote_addr->in;
msg.msg_name = (void *)&remote_addr->in;
msg.msg_namelen = sizeof(struct sockaddr_in);
break;
case AF_INET6:
msg.msg_name = (void*)&remote_addr->in6;
msg.msg_name = (void *)&remote_addr->in6;
msg.msg_namelen = sizeof(struct sockaddr_in6);
break;
@ -111,7 +111,7 @@ static void send_type(const fastd_socket_t *sock, const fastd_peer_address_t *lo
remote_addr6 = *remote_addr;
fastd_peer_address_widen(&remote_addr6);
msg.msg_name = (void*)&remote_addr6.in6;
msg.msg_name = (void *)&remote_addr6.in6;
msg.msg_namelen = sizeof(struct sockaddr_in6);
}

8
src/sha256.c
View file

@ -145,7 +145,7 @@ static void sha256_blocks_va(uint32_t out[FASTD_SHA256_HASH_WORDS], va_list ap)
va_list ap2;
va_copy(ap2, ap);
while (va_arg(ap2, const uint32_t*))
while (va_arg(ap2, const uint32_t *))
count++;
va_end(ap2);
@ -153,7 +153,7 @@ static void sha256_blocks_va(uint32_t out[FASTD_SHA256_HASH_WORDS], va_list ap)
size_t i = 0;
const uint32_t *block;
while ((block = va_arg(ap, const uint32_t*)) != NULL)
while ((block = va_arg(ap, const uint32_t *)) != NULL)
blocks[i++] = block;
sha256_list(out, blocks, count*FASTD_SHA256_BLOCK_BYTES);
@ -228,7 +228,7 @@ static void hmacsha256_blocks_va(fastd_sha256_t *out, const uint32_t key[FASTD_H
va_list ap2;
va_copy(ap2, ap);
while (va_arg(ap2, const uint32_t*))
while (va_arg(ap2, const uint32_t *))
count++;
va_end(ap2);
@ -236,7 +236,7 @@ static void hmacsha256_blocks_va(fastd_sha256_t *out, const uint32_t key[FASTD_H
size_t i = 0;
const uint32_t *block;
while ((block = va_arg(ap, const uint32_t*)) != NULL)
while ((block = va_arg(ap, const uint32_t *)) != NULL)
blocks[i++] = block;
hmacsha256_list(out, key, blocks, count*FASTD_SHA256_BLOCK_BYTES);

2
src/shell.c
View file

@ -143,7 +143,7 @@ static bool shell_command_do_exec(const fastd_shell_command_t *command, const fa
sigemptyset(&set);
pthread_sigmask(SIG_SETMASK, &set, NULL);
execl("/bin/sh", "sh", "-c", command->command, (char*)NULL);
execl("/bin/sh", "sh", "-c", command->command, (char *)NULL);
_exit(127);
}

2
src/socket.c
View file

@ -227,7 +227,7 @@ bool fastd_socket_handle_binds(void) {
}
/** Opens a single unbound socket for the given address family */
fastd_socket_t* fastd_socket_open(fastd_peer_t *peer, int af) {
fastd_socket_t * fastd_socket_open(fastd_peer_t *peer, int af) {
const fastd_bind_address_t any_address = { .addr.sa.sa_family = af };
int fd = bind_socket(&any_address, true);

2
src/tuntap.c
View file

@ -379,7 +379,7 @@ void fastd_tuntap_handle(void) {
/** Writes a packet to the TUN/TAP device */
void fastd_tuntap_write(fastd_buffer_t buffer) {
if (multiaf_tun && conf.mode == MODE_TUN) {
uint8_t version = *((uint8_t*)buffer.data) >> 4;
uint8_t version = *((uint8_t *)buffer.data) >> 4;
uint32_t af;
switch (version) {

8
src/vector.h
View file

@ -67,7 +67,7 @@ void _fastd_vector_delete(fastd_vector_desc_t *desc, void **data, size_t pos, si
*/
#define VECTOR_RESIZE(v, n) ({ \
__typeof__(v) *_v = &(v); \
_fastd_vector_resize(&_v->desc, (void**)&_v->data, (n), sizeof(*_v->data)); \
_fastd_vector_resize(&_v->desc, (void **)&_v->data, (n), sizeof(*_v->data)); \
})
/**
@ -106,7 +106,7 @@ void _fastd_vector_delete(fastd_vector_desc_t *desc, void **data, size_t pos, si
#define VECTOR_INSERT(v, elem, pos) ({ \
__typeof__(v) *_v = &(v); \
__typeof__(*_v->data) _e = (elem); \
_fastd_vector_insert(&_v->desc, (void**)&_v->data, &_e, (pos), sizeof(_e)); \
_fastd_vector_insert(&_v->desc, (void **)&_v->data, &_e, (pos), sizeof(_e)); \
})
/**
@ -117,7 +117,7 @@ void _fastd_vector_delete(fastd_vector_desc_t *desc, void **data, size_t pos, si
#define VECTOR_ADD(v, elem) ({ \
__typeof__(v) *_v = &(v); \
__typeof__(*_v->data) _e = (elem); \
_fastd_vector_insert(&_v->desc, (void**)&_v->data, &_e, _v->desc.length, sizeof(_e)); \
_fastd_vector_insert(&_v->desc, (void **)&_v->data, &_e, _v->desc.length, sizeof(_e)); \
})
/**
@ -127,7 +127,7 @@ void _fastd_vector_delete(fastd_vector_desc_t *desc, void **data, size_t pos, si
*/
#define VECTOR_DELETE(v, pos) ({ \
__typeof__(v) *_v = &(v); \
_fastd_vector_delete(&_v->desc, (void**)&_v->data, (pos), sizeof(*_v->data)); \
_fastd_vector_delete(&_v->desc, (void **)&_v->data, (pos), sizeof(*_v->data)); \
})
/**